rust-auth-utils 1.0.0

A rust port of @better-auth/utils.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

#[derive(Debug, Clone, PartialEq)]
pub enum TypedArray {
    Uint8Array,
    Int8Array,
    Uint16Array,
    Int16Array,
    Uint32Array,
    Int32Array,
    Float32Array,
    Float64Array,
    BigInt64Array,
    BigUint64Array,
}

#[derive(Debug, Clone, PartialEq)]
pub enum SHAFamily {
    SHA1,
    SHA256,
    SHA384,
    SHA512,
}

#[derive(Debug, Clone, PartialEq)]
pub enum EncodingFormat {
    Hex,
    Base64,
    Base64Url,
    Base64UrlNoPad,
    None,
}

#[derive(Debug, Clone, PartialEq)]
pub enum ECDSACurve {
    P256,
    P384,
    P521,
}

#[derive(Debug, Clone, PartialEq)]
pub enum ExportKeyFormat {
    JWK,
    SPKI,
    PKCS8,
    Raw,
}

impl ToString for SHAFamily {
    fn to_string(&self) -> String {
        match self {
            SHAFamily::SHA1 => "SHA-1".to_string(),
            SHAFamily::SHA256 => "SHA-256".to_string(),
            SHAFamily::SHA384 => "SHA-384".to_string(),
            SHAFamily::SHA512 => "SHA-512".to_string(),
        }
    }
}

impl ToString for EncodingFormat {
    fn to_string(&self) -> String {
        match self {
            EncodingFormat::Hex => "hex".to_string(),
            EncodingFormat::Base64 => "base64".to_string(),
            EncodingFormat::Base64Url => "base64url".to_string(),
            EncodingFormat::Base64UrlNoPad => "base64urlnopad".to_string(),
            EncodingFormat::None => "none".to_string(),
        }
    }
}

impl ToString for ECDSACurve {
    fn to_string(&self) -> String {
        match self {
            ECDSACurve::P256 => "P-256".to_string(),
            ECDSACurve::P384 => "P-384".to_string(),
            ECDSACurve::P521 => "P-521".to_string(),
        }
    }
}

impl ToString for ExportKeyFormat {
    fn to_string(&self) -> String {
        match self {
            ExportKeyFormat::JWK => "jwk".to_string(),
            ExportKeyFormat::SPKI => "spki".to_string(),
            ExportKeyFormat::PKCS8 => "pkcs8".to_string(),
            ExportKeyFormat::Raw => "raw".to_string(),
        }
    }
}