http-signature-normalization/reqwest/src/digest/mod.rs

use crate::{Config, Sign, SignError};
use reqwest::{Body, Request, RequestBuilder};
use std::fmt::Display;

#[cfg(feature = "sha-2")]
mod sha2;
#[cfg(feature = "sha-3")]
mod sha3;

/// A trait for creating digests of an array of bytes
pub trait DigestCreate {
    /// The name of the digest algorithm
    const NAME: &'static str;

    /// Compute the digest of the input bytes
    fn compute(&mut self, input: &[u8]) -> String;
}

/// Extend the Sign trait with support for adding Digest Headers to the request
///
/// It generates HTTP Signatures after the Digest header has been added, in order to have
/// verification that the body has not been tampered with, or that the request can't be replayed by
/// a malicious entity
#[async_trait::async_trait]
pub trait SignExt: Sign {
    async fn authorization_signature_with_digest<F, E, K, D, V>(
        self,
        config: Config,
        key_id: K,
        digest: D,
        v: V,
        f: F,
    ) -> Result<Request, E>
    where
        F: FnOnce(&str) -> Result<String, E> + Send + 'static,
        E: From<SignError> + From<reqwest::Error> + Send + 'static,
        K: Display + Send + 'static,
        D: DigestCreate + Send + 'static,
        V: AsRef<[u8]> + Into<Body> + Send + 'static,
        Self: Sized;

    async fn signature_with_digest<F, E, K, D, V>(
        self,
        config: Config,
        key_id: K,
        digest: D,
        v: V,
        f: F,
    ) -> Result<Request, E>
    where
        F: FnOnce(&str) -> Result<String, E> + Send + 'static,
        E: From<SignError> + From<reqwest::Error> + Send + 'static,
        K: Display + Send + 'static,
        D: DigestCreate + Send + 'static,
        V: AsRef<[u8]> + Into<Body> + Send + 'static,
        Self: Sized;
}

#[async_trait::async_trait]
impl SignExt for RequestBuilder {
    async fn authorization_signature_with_digest<F, E, K, D, V>(
        self,
        config: Config,
        key_id: K,
        mut digest: D,
        v: V,
        f: F,
    ) -> Result<Request, E>
    where
        F: FnOnce(&str) -> Result<String, E> + Send + 'static,
        E: From<SignError> + From<reqwest::Error> + Send + 'static,
        K: Display + Send + 'static,
        D: DigestCreate + Send + 'static,
        V: AsRef<[u8]> + Into<Body> + Send + 'static,
    {
        let (v, digest) = tokio::task::spawn_blocking(move || {
            let digest = digest.compute(v.as_ref());
            (v, digest)
        })
        .await
        .map_err(|_| SignError::Canceled)?;

        let mut req = self
            .header("Digest", format!("{}={}", D::NAME, digest))
            .authorization_signature(&config, key_id, f)
            .await?;

        *req.body_mut() = Some(Body::from(v.as_ref().to_vec()));

        Ok(req)
    }

    async fn signature_with_digest<F, E, K, D, V>(
        self,
        config: Config,
        key_id: K,
        mut digest: D,
        v: V,
        f: F,
    ) -> Result<Request, E>
    where
        F: FnOnce(&str) -> Result<String, E> + Send + 'static,
        E: From<SignError> + From<reqwest::Error> + Send + 'static,
        K: Display + Send + 'static,
        D: DigestCreate + Send + 'static,
        V: AsRef<[u8]> + Into<Body> + Send + 'static,
    {
        let (v, digest) = tokio::task::spawn_blocking(move || {
            let digest = digest.compute(v.as_ref());
            (v, digest)
        })
        .await
        .map_err(|_| SignError::Canceled)?;

        let mut req = self
            .header("Digest", format!("{}={}", D::NAME, digest))
            .signature(&config, key_id, f)
            .await?;

        *req.body_mut() = Some(Body::from(v.as_ref().to_vec()));

        Ok(req)
    }
}

#[cfg(feature = "middleware")]
mod middleware {
    use super::{Config, DigestCreate, Sign, SignError, SignExt};
    use reqwest::{Body, Request};
    use reqwest_middleware::RequestBuilder;
    use std::fmt::Display;

    #[async_trait::async_trait]
    impl SignExt for RequestBuilder {
        async fn authorization_signature_with_digest<F, E, K, D, V>(
            self,
            config: Config,
            key_id: K,
            mut digest: D,
            v: V,
            f: F,
        ) -> Result<Request, E>
        where
            F: FnOnce(&str) -> Result<String, E> + Send + 'static,
            E: From<SignError> + From<reqwest::Error> + Send + 'static,
            K: Display + Send + 'static,
            D: DigestCreate + Send + 'static,
            V: AsRef<[u8]> + Into<Body> + Send + 'static,
            Self: Sized,
        {
            let (v, digest) = tokio::task::spawn_blocking(move || {
                let digest = digest.compute(v.as_ref());
                (v, digest)
            })
            .await
            .map_err(|_| SignError::Canceled)?;

            let mut req = self
                .header("Digest", format!("{}={}", D::NAME, digest))
                .authorization_signature(&config, key_id, f)
                .await?;

            *req.body_mut() = Some(Body::from(v.as_ref().to_vec()));

            Ok(req)
        }

        async fn signature_with_digest<F, E, K, D, V>(
            self,
            config: Config,
            key_id: K,
            mut digest: D,
            v: V,
            f: F,
        ) -> Result<Request, E>
        where
            F: FnOnce(&str) -> Result<String, E> + Send + 'static,
            E: From<SignError> + From<reqwest::Error> + Send + 'static,
            K: Display + Send + 'static,
            D: DigestCreate + Send + 'static,
            V: AsRef<[u8]> + Into<Body> + Send + 'static,
            Self: Sized,
        {
            let (v, digest) = tokio::task::spawn_blocking(move || {
                let digest = digest.compute(v.as_ref());
                (v, digest)
            })
            .await
            .map_err(|_| SignError::Canceled)?;

            let mut req = self
                .header("Digest", format!("{}={}", D::NAME, digest))
                .signature(&config, key_id, f)
                .await?;

            *req.body_mut() = Some(Body::from(v.as_ref().to_vec()));

            Ok(req)
        }
    }
}
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`use crate::{Config, Sign, SignError};`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`use reqwest::{Body, Request, RequestBuilder};`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`use std::fmt::Display;`
Bump http-signature-normalization version, update actix to 3.0 2020-03-16 00:29:47 +00:00
Fix feature builds 2020-09-30 00:48:00 +00:00			`#[cfg(feature = "sha-2")]`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`mod sha2;`
Fix feature builds 2020-09-30 00:48:00 +00:00			`#[cfg(feature = "sha-3")]`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`mod sha3;`

			`/// A trait for creating digests of an array of bytes`
			`pub trait DigestCreate {`
			`/// The name of the digest algorithm`
			`const NAME: &'static str;`

			`/// Compute the digest of the input bytes`
			`fn compute(&mut self, input: &[u8]) -> String;`
Bump http-signature-normalization version, update actix to 3.0 2020-03-16 00:29:47 +00:00			`}`

Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`/// Extend the Sign trait with support for adding Digest Headers to the request`
			`///`
			`/// It generates HTTP Signatures after the Digest header has been added, in order to have`
			`/// verification that the body has not been tampered with, or that the request can't be replayed by`
			`/// a malicious entity`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`#[async_trait::async_trait]`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`pub trait SignExt: Sign {`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`async fn authorization_signature_with_digest<F, E, K, D, V>(`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`self,`
			`config: Config,`
			`key_id: K,`
			`digest: D,`
			`v: V,`
			`f: F,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`) -> Result<Request, E>`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`where`
			`F: FnOnce(&str) -> Result<String, E> + Send + 'static,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`E: From<SignError> + From<reqwest::Error> + Send + 'static,`
reqwest: Support multi-threaded tokio runtime 2022-04-25 16:03:00 +00:00			`K: Display + Send + 'static,`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`D: DigestCreate + Send + 'static,`
			`V: AsRef<[u8]> + Into<Body> + Send + 'static,`
			`Self: Sized;`
Bump http-signature-normalization version, update actix to 3.0 2020-03-16 00:29:47 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`async fn signature_with_digest<F, E, K, D, V>(`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`self,`
			`config: Config,`
			`key_id: K,`
			`digest: D,`
			`v: V,`
			`f: F,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`) -> Result<Request, E>`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`where`
			`F: FnOnce(&str) -> Result<String, E> + Send + 'static,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`E: From<SignError> + From<reqwest::Error> + Send + 'static,`
reqwest: Support multi-threaded tokio runtime 2022-04-25 16:03:00 +00:00			`K: Display + Send + 'static,`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`D: DigestCreate + Send + 'static,`
			`V: AsRef<[u8]> + Into<Body> + Send + 'static,`
			`Self: Sized;`
Bump http-signature-normalization version, update actix to 3.0 2020-03-16 00:29:47 +00:00			`}`

Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`#[async_trait::async_trait]`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`impl SignExt for RequestBuilder {`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`async fn authorization_signature_with_digest<F, E, K, D, V>(`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`self,`
			`config: Config,`
			`key_id: K,`
			`mut digest: D,`
			`v: V,`
			`f: F,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`) -> Result<Request, E>`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`where`
			`F: FnOnce(&str) -> Result<String, E> + Send + 'static,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`E: From<SignError> + From<reqwest::Error> + Send + 'static,`
reqwest: Support multi-threaded tokio runtime 2022-04-25 16:03:00 +00:00			`K: Display + Send + 'static,`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`D: DigestCreate + Send + 'static,`
			`V: AsRef<[u8]> + Into<Body> + Send + 'static,`
			`{`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`let (v, digest) = tokio::task::spawn_blocking(move \|\| {`
			`let digest = digest.compute(v.as_ref());`
			`(v, digest)`
			`})`
			`.await`
			`.map_err(\|_\| SignError::Canceled)?;`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`let mut req = self`
			`.header("Digest", format!("{}={}", D::NAME, digest))`
			`.authorization_signature(&config, key_id, f)`
			`.await?;`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`*req.body_mut() = Some(Body::from(v.as_ref().to_vec()));`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`Ok(req)`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`}`

Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`async fn signature_with_digest<F, E, K, D, V>(`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`self,`
			`config: Config,`
			`key_id: K,`
			`mut digest: D,`
			`v: V,`
			`f: F,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`) -> Result<Request, E>`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`where`
			`F: FnOnce(&str) -> Result<String, E> + Send + 'static,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`E: From<SignError> + From<reqwest::Error> + Send + 'static,`
reqwest: Support multi-threaded tokio runtime 2022-04-25 16:03:00 +00:00			`K: Display + Send + 'static,`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`D: DigestCreate + Send + 'static,`
			`V: AsRef<[u8]> + Into<Body> + Send + 'static,`
			`{`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`let (v, digest) = tokio::task::spawn_blocking(move \|\| {`
			`let digest = digest.compute(v.as_ref());`
			`(v, digest)`
			`})`
			`.await`
			`.map_err(\|_\| SignError::Canceled)?;`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`let mut req = self`
			`.header("Digest", format!("{}={}", D::NAME, digest))`
			`.signature(&config, key_id, f)`
			`.await?;`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`*req.body_mut() = Some(Body::from(v.as_ref().to_vec()));`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`Ok(req)`
Add methods for explicit mastodon compat, requiring digest Update actix library with new methods Build reqwest client with feature parity to actix client 2020-09-29 23:57:59 +00:00			`}`
Bump http-signature-normalization version, update actix to 3.0 2020-03-16 00:29:47 +00:00			`}`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
			`#[cfg(feature = "middleware")]`
			`mod middleware {`
			`use super::{Config, DigestCreate, Sign, SignError, SignExt};`
			`use reqwest::{Body, Request};`
			`use reqwest_middleware::RequestBuilder;`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`use std::fmt::Display;`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`#[async_trait::async_trait]`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`impl SignExt for RequestBuilder {`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`async fn authorization_signature_with_digest<F, E, K, D, V>(`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`self,`
			`config: Config,`
			`key_id: K,`
			`mut digest: D,`
			`v: V,`
			`f: F,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`) -> Result<Request, E>`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`where`
			`F: FnOnce(&str) -> Result<String, E> + Send + 'static,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`E: From<SignError> + From<reqwest::Error> + Send + 'static,`
reqwest: Support multi-threaded tokio runtime 2022-04-25 16:03:00 +00:00			`K: Display + Send + 'static,`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`D: DigestCreate + Send + 'static,`
			`V: AsRef<[u8]> + Into<Body> + Send + 'static,`
			`Self: Sized,`
			`{`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`let (v, digest) = tokio::task::spawn_blocking(move \|\| {`
			`let digest = digest.compute(v.as_ref());`
			`(v, digest)`
			`})`
			`.await`
			`.map_err(\|_\| SignError::Canceled)?;`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`let mut req = self`
			`.header("Digest", format!("{}={}", D::NAME, digest))`
			`.authorization_signature(&config, key_id, f)`
			`.await?;`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`*req.body_mut() = Some(Body::from(v.as_ref().to_vec()));`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`Ok(req)`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`}`

Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`async fn signature_with_digest<F, E, K, D, V>(`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`self,`
			`config: Config,`
			`key_id: K,`
			`mut digest: D,`
			`v: V,`
			`f: F,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`) -> Result<Request, E>`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`where`
			`F: FnOnce(&str) -> Result<String, E> + Send + 'static,`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`E: From<SignError> + From<reqwest::Error> + Send + 'static,`
reqwest: Support multi-threaded tokio runtime 2022-04-25 16:03:00 +00:00			`K: Display + Send + 'static,`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`D: DigestCreate + Send + 'static,`
			`V: AsRef<[u8]> + Into<Body> + Send + 'static,`
			`Self: Sized,`
			`{`
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`let (v, digest) = tokio::task::spawn_blocking(move \|\| {`
			`let digest = digest.compute(v.as_ref());`
			`(v, digest)`
			`})`
			`.await`
			`.map_err(\|_\| SignError::Canceled)?;`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`let mut req = self`
			`.header("Digest", format!("{}={}", D::NAME, digest))`
			`.signature(&config, key_id, f)`
			`.await?;`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`*req.body_mut() = Some(Body::from(v.as_ref().to_vec()));`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00
Run signature creation in spawn_blocking Also move -reqwest fully to async trait 2023-07-06 17:11:27 +00:00			`Ok(req)`
Add support for reqwest-middleware 2021-12-05 22:45:37 +00:00			`}`
			`}`
			`}`