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

use reqwest::{Client, Response};
use reqwest::header::{HeaderName, WWW_AUTHENTICATE};
use url::Url;

use crate::api::request::{ensure_success, ResponseError};
use crate::crypto::b64;

/// The name of the header the nonce is delivered in.
const HEADER_NONCE: HeaderName = WWW_AUTHENTICATE;

/// Do a new request, and extract the nonce from a header in the given
/// response.
pub fn request_nonce(client: &Client, url: Url) -> Result<Vec<u8>, NonceError> {
    // Make the request
    let response = client.get(url).send().map_err(|_| NonceError::Request)?;

    // Ensure the response is successful
    ensure_success(&response)?;

    // Extract the nonce
    header_nonce(&response)
}

/// Extract the nonce from a header in the given response.
pub fn header_nonce(response: &Response) -> Result<Vec<u8>, NonceError> {
    // Get the authentication nonce
    b64::decode(
        response
            .headers()
            .get(HEADER_NONCE)
            .ok_or(NonceError::NoNonceHeader)?
            .to_str()
            .map_err(|_| NonceError::MalformedNonce)?
            .split_terminator(' ')
            .nth(1)
            .ok_or(NonceError::MalformedNonce)?,
    )
    .map_err(|_| NonceError::MalformedNonce)
}

#[derive(Fail, Debug)]
pub enum NonceError {
    /// Sending the request to fetch a nonce failed,
    /// as the file has expired or did never exist.
    #[fail(display = "the file has expired or did never exist")]
    Expired,

    /// Sending the request to fetch a nonce failed.
    #[fail(display = "failed to request encryption nonce")]
    Request,

    /// The server responded with an error while requesting the encryption nonce,
    /// required for some operations.
    #[fail(display = "bad response from server while requesting encryption nonce")]
    Response(#[cause] ResponseError),

    /// The nonce header was missing from the request.
    #[fail(display = "missing nonce in server response")]
    NoNonceHeader,

    /// The received nonce could not be parsed, because it was malformed.
    /// Maybe the server responded with a new format that isn't supported yet
    /// by this client.
    #[fail(display = "received malformed nonce")]
    MalformedNonce,
}

impl From<ResponseError> for NonceError {
    fn from(err: ResponseError) -> Self {
        match err {
            ResponseError::Expired => NonceError::Expired,
            err => NonceError::Response(err),
        }
    }
}