http-signature-normalization-actix 0.3.0

An HTTP Signatures library that leaves the signing to you
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use log::{debug, warn};
use sha2::{Sha224, Sha256, Sha384, Sha512, Sha512Trunc224, Sha512Trunc256};

use super::{DigestCreate, DigestPart, DigestVerify};

fn create(digest: &mut impl sha2::Digest, input: &[u8]) -> String {
    digest.update(input);
    base64::encode(&digest.finalize_reset())
}

fn verify(digest: &mut impl sha2::Digest, name: &str, parts: &[DigestPart], bytes: &[u8]) -> bool {
    if let Some(part) = parts
        .iter()
        .find(|p| p.algorithm.to_lowercase() == name.to_lowercase())
    {
        debug!("Verifying digest type, {}", name);
        digest.update(bytes);
        let encoded = base64::encode(&digest.finalize_reset());

        return part.digest == encoded;
    }
    warn!("No matching digest algorithm found for {}", name);
    warn!(
        "Provided: [{}]",
        parts.iter().fold(String::new(), |mut acc, item| {
            if acc.is_empty() {
            } else {
                acc.push_str(", ");
            }
            acc.push_str(&item.algorithm);
            acc
        })
    );

    false
}

impl DigestCreate for Sha224 {
    const NAME: &'static str = "SHA-224";

    fn compute(&mut self, input: &[u8]) -> String {
        create(self, input)
    }
}

impl DigestVerify for Sha224 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        verify(self, <Self as DigestCreate>::NAME, parts, bytes)
    }
}

impl DigestCreate for Sha256 {
    const NAME: &'static str = "SHA-256";

    fn compute(&mut self, input: &[u8]) -> String {
        create(self, input)
    }
}

impl DigestVerify for Sha256 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        verify(self, <Self as DigestCreate>::NAME, parts, bytes)
    }
}

impl DigestCreate for Sha384 {
    const NAME: &'static str = "SHA-384";

    fn compute(&mut self, input: &[u8]) -> String {
        create(self, input)
    }
}

impl DigestVerify for Sha384 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        verify(self, <Self as DigestCreate>::NAME, parts, bytes)
    }
}

impl DigestCreate for Sha512 {
    const NAME: &'static str = "SHA-512";

    fn compute(&mut self, input: &[u8]) -> String {
        create(self, input)
    }
}

impl DigestVerify for Sha512 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        verify(self, <Self as DigestCreate>::NAME, parts, bytes)
    }
}

impl DigestCreate for Sha512Trunc224 {
    const NAME: &'static str = "SHA-512-224";

    fn compute(&mut self, input: &[u8]) -> String {
        create(self, input)
    }
}

impl DigestVerify for Sha512Trunc224 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        verify(self, <Self as DigestCreate>::NAME, parts, bytes)
    }
}

impl DigestCreate for Sha512Trunc256 {
    const NAME: &'static str = "SHA-512-256";

    fn compute(&mut self, input: &[u8]) -> String {
        create(self, input)
    }
}

impl DigestVerify for Sha512Trunc256 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        verify(self, <Self as DigestCreate>::NAME, parts, bytes)
    }
}