Struct BodyHash

pub struct BodyHash<T, D: Digest> { /* private fields */ }

Wraps an extractor and calculates a body checksum hash alongside.

If your extractor would usually be T and you want to create a hash of type D then you need to use BodyHash<T, D>. E.g., BodyHash<String, Sha256>.

Any hasher that implements Digest can be used. Type aliases for common hashing algorithms are available at the crate root.

Errors

This extractor produces no errors of its own and all errors from the underlying extractor are propagated correctly; for example, if the payload limits are exceeded.

When Used On The Wrong Extractor

Use on a non-body extractor is tolerated unless it is used after a different extractor that takes the payload. In this case, the resulting hash will be as if an empty input was given to the hasher.

Example

use actix_web::{Responder, web};
use actix_hash::BodyHash;
use sha2::Sha256;

async fn hash_payload(form: BodyHash<web::Json<T>, Sha256>) -> impl Responder {
    if !form.verify_slice(b"correct-signature") {
        // return unauthorized error
    }

    "Ok"
}

Implementations

impl<T, D: Digest> BodyHash<T, D>

pub fn hash(&self) -> &[u8]

Returns hash slice.

pub fn hash_size(&self) -> usize

Returns hash output size.

pub fn verify_slice(&self, tag: &[u8]) -> bool

Verifies HMAC hash against provided tag using constant-time equality.

pub fn into_parts(self) -> BodyHashParts<T>

Returns body type parts, including extracted body type, raw body bytes, and hash bytes.

Trait Implementations

impl<T: Clone, D: Clone + Digest> Clone for BodyHash<T, D>

where D::OutputSize: Clone,

fn clone(&self) -> BodyHash<T, D>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, D: Debug + Digest> Debug for BodyHash<T, D>

where D::OutputSize: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, D> FromRequest for BodyHash<T, D>

where T: FromRequest + 'static, D: Digest + 'static,

type Error = <T as FromRequest>::Error

The associated error which can be returned.

type Future = BodyHashFut<T, D>

Future that resolves to a Self.

fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future

Create a Self from request parts asynchronously.

fn extract(req: &HttpRequest) -> Self::Future

Create a Self from request head asynchronously.