http-msgsign 0.1.0

Provide RFC9421 HTTP Message Signature functionality to http crate.
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

use crate::components::values::Value;

#[derive(Debug, thiserror::Error)]
pub enum SignatureError {
    #[error("`Signature` for the specified Label(`{0}`) is missing.")]
    NotExist(String),
    #[error("`Signature` does not exist in header.")]
    NotExistInHeader,
    #[error("`Signature` is not a valid `Dictionary`. {0}")]
    InvalidFormat(#[from] InvalidFormat),
}

#[derive(Debug, thiserror::Error)]
pub enum SignatureInputError {
    #[error("`Signature-Input` does not exist in header.")]
    NotExistInHeader,
    #[error(transparent)]
    InvalidDataFormat(#[from] InvalidFormat),
}

#[derive(Debug, thiserror::Error)]
pub enum SignatureParamsError {
    #[error(transparent)]
    InvalidHeaderName(#[from] http::Error),
    #[error(transparent)]
    InvalidParameter(#[from] InvalidSerializer),
}

#[derive(Debug, thiserror::Error)]
pub enum InvalidFormat {
    #[error("Type `Dictionary` was expected. {0}")]
    Dictionary(sfv::Error),
    #[error("Type `InnerList` was expected")]
    InnerList,
    #[error("Type `Integer` was expected. {0}")]
    Integer(sfv::Error),
    #[error("Type `String` was expected.")]
    String,
    #[error(transparent)]
    HeaderName(http::Error),
    #[error("Type `ByteSequence` was expected.")]
    ByteSequence,
    #[error(transparent)]
    DerivedComponent(#[from] InvalidDerivedComponent),
}

#[derive(Debug, thiserror::Error)]
pub enum InvalidSerializer {
    #[error("{0} is duplicated. Parameter keys must always be unique.")]
    Duplicated(String),

    #[error("`{interrogator}` does not correspond to {reject}.")]
    Incompatible {
        interrogator: &'static str,
        reject: String,
    },
}

#[derive(Debug, thiserror::Error)]
pub enum SerializeError {
    #[error("`{0:?}` is not a valid ASCII string.")]
    MustBeASCIIString(Value),
    #[error(transparent)]
    SfvSerialize(#[from] sfv::Error),
    #[error("{param_type} parameter does not support `{current_type}`.")]
    InvalidSerializableValue {
        param_type: String,
        current_type: &'static str,
    },
    #[error("Entry with the specified key=`{0}` does not exist.")]
    EntryNotExistsInDictionary(String),
    #[error("Cannot be parsed as SFV format.")]
    FailedParseToSfv,
    #[error(transparent)]
    InvalidFormat(#[from] InvalidFormat),
}

#[derive(Debug, thiserror::Error)]
#[error("Invalid derived component.")]
pub struct InvalidDerivedComponent;

#[derive(Debug, thiserror::Error)]
#[error("invalid component parameter: {0}={1:?}")]
pub struct InvalidComponentParameter(pub sfv::Key, pub sfv::BareItem);

#[derive(Debug, thiserror::Error)]
pub enum HttpComponentError {
    #[error("Incorrect data type. expect: {expect}")]
    InvalidDataType { expect: &'static str },
    #[error(transparent)]
    FailedSerializeValue(#[from] SerializeError),
    #[error("Necessary requirement have not been met. {reason}")]
    UnmetRequirement { reason: &'static str },
    #[error("DerivedComponent({0}) not supported.")]
    UnsupportedComponent(String),
}

#[derive(Debug, thiserror::Error)]
pub enum SignError {
    #[error(transparent)]
    FailedBuildSignatureBase(#[from] HttpComponentError),
}

#[derive(Debug, thiserror::Error)]
pub enum VerificationError {
    #[error(transparent)]
    MissingSignature(#[from] SignatureError),
    #[error("`Signature-Input` for the specified Label(`{0}`) is missing.")]
    MissingSignatureInput(String),
    #[error(transparent)]
    FailedParseSignatureInput(#[from] SignatureInputError),
    #[error("Failed to decode signature. {0}")]
    FailedDecodeSignature(#[from] base64::DecodeError),
    #[error(transparent)]
    FailedBuildSignatureBase(#[from] HttpComponentError),
    #[error("Failed to verify signature")]
    FailedVerifySignature,
}