http-msgsign-draft 0.3.0

Add functionality for draft-cavage-http-signatures-12 to http.
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

use std::time::Duration;

use http::{Request, Response};
use indexmap::IndexSet;

use crate::errors::{HttpPayloadSeekError, SignatureParamsError};
use crate::sign::SignatureBase;
use crate::sign::field::{TargetField, TimeOrDuration};

#[derive(Debug, Clone)]
pub struct SignatureParams {
    targets: IndexSet<TargetField>,
}

pub struct SignatureParamsBuilder {
    builder: Result<SignatureParams, SignatureParamsError>,
}

impl SignatureParams {
    pub fn builder() -> SignatureParamsBuilder {
        SignatureParamsBuilder {
            builder: Ok(SignatureParams {
                targets: Default::default(),
            }),
        }
    }

    pub(crate) fn seek_request<B>(
        &self,
        request: &Request<B>,
    ) -> Result<SignatureBase, HttpPayloadSeekError> {
        let seeked = self
            .targets
            .iter()
            .map(|target| target.seek_request(request))
            .collect::<Result<IndexSet<_>, _>>()?;

        Ok(SignatureBase::from_components(seeked))
    }

    pub(crate) fn seek_response<B>(
        &self,
        response: &Response<B>,
    ) -> Result<SignatureBase, HttpPayloadSeekError> {
        let seeked = self
            .targets
            .iter()
            .map(|target| target.seek_response(response))
            .collect::<Result<IndexSet<_>, _>>()?;

        Ok(SignatureBase::from_components(seeked))
    }
}

impl SignatureParamsBuilder {
    pub fn add_header<H>(self, header: H) -> Self
    where
        H: TryInto<http::HeaderName>,
        H::Error: Into<http::Error>,
    {
        self.and_then(|mut params| {
            let header = header.try_into().map_err(Into::into)?;
            params.targets.insert(TargetField::HeaderField(header));
            Ok(params)
        })
    }

    pub fn add_request_target(self) -> Self {
        self.and_then(|mut params| {
            params.targets.insert(TargetField::RequestTarget);
            Ok(params)
        })
    }

    pub fn set_created(self) -> Self {
        self.and_then(|mut params| {
            params.targets.insert(TargetField::Created(None));
            Ok(params)
        })
    }

    pub fn set_expires(self, expires: impl Into<Duration>) -> Self {
        self.and_then(|mut params| {
            params
                .targets
                .insert(TargetField::Expires(TimeOrDuration::Duration(
                    expires.into(),
                )));
            Ok(params)
        })
    }

    pub fn build(self) -> Result<SignatureParams, SignatureParamsError> {
        // If not specified, implementations MUST operate as if the field were specified
        // with a single value, `(created)`, in the list of HTTP headers.
        self.builder.map(|mut params| {
            if params.targets.is_empty() {
                params.targets.insert(TargetField::Created(None));
            }
            Ok(params)
        })?
    }

    fn and_then<F>(self, f: F) -> Self
    where
        F: FnOnce(SignatureParams) -> Result<SignatureParams, SignatureParamsError>,
    {
        Self {
            builder: self.builder.and_then(f),
        }
    }
}