# Struct openssl::hash::Hasher [−] [src]

    pub struct Hasher { /* fields omitted */ }

Provides message digest (hash) computation.

# Examples

Calculate a hash in one go:

    use openssl::hash::{hash, MessageDigest};

    let data = b"\x42\xF4\x97\xE0";
    let spec = b"\x7c\x43\x0f\x17\x8a\xef\xdf\x14\x87\xfe\xe7\x14\x4e\x96\x41\xe2";
    let res = hash(MessageDigest::md5(), data).unwrap();
    assert_eq!(&*res, spec);

Supply the input in chunks:

    use openssl::hash::{Hasher, MessageDigest};

    let data = [b"\x42\xF4", b"\x97\xE0"];
    let spec = b"\x7c\x43\x0f\x17\x8a\xef\xdf\x14\x87\xfe\xe7\x14\x4e\x96\x41\xe2";
    let mut h = Hasher::new(MessageDigest::md5()).unwrap();
    h.update(data[0]).unwrap();
    h.update(data[1]).unwrap();
    let res = h.finish().unwrap();
    assert_eq!(&*res, spec);

Use an XOF hasher (OpenSSL 1.1.1+):

    #[cfg(ossl111)]
    {
        use openssl::hash::{hash_xof, MessageDigest};

        let data = b"\x41\x6c\x6c\x20\x79\x6f\x75\x72\x20\x62\x61\x73\x65\x20\x61\x72\x65\x20\x62\x65\x6c\x6f\x6e\x67\x20\x74\x6f\x20\x75\x73";
        let spec = b"\x49\xd0\x69\x7f\xf5\x08\x11\x1d\x8b\x84\xf1\x5e\x46\xda\xf1\x35";
        let mut buf = vec![0; 16];
        hash_xof(MessageDigest::shake_128(), data, buf.as_mut_slice()).unwrap();
        assert_eq!(buf, spec);
    }

# Warning

Don’t actually use MD5 and SHA-1 hashes, they’re not secure anymore.

Don’t ever hash passwords, use the functions in the `pkcs5` module or bcrypt/scrypt instead.

For extendable output functions (XOFs, i.e. SHAKE128/SHAKE256), you must use finish_xof instead of finish and provide a buf to store the hash. The hash will be as long as the buf.

## Implementations

### `impl Hasher` [src]

#### `pub fn new(ty: MessageDigest) -> Result<Hasher, ErrorStack>` [src]

Creates a new `Hasher` with the specified hash type.

#### `pub fn update(&mut self, data: &[u8]) -> Result<(), ErrorStack>` [src]

Feeds data into the hasher.

#### `pub fn finish(&mut self) -> Result<DigestBytes, ErrorStack>` [src]

Returns the hash of the data written and resets the non-XOF hasher.

#### `pub fn finish_xof(&mut self, buf: &mut [u8]) -> Result<(), ErrorStack>` [src]

Writes the hash of the data into the supplied buf and resets the XOF hasher. The hash will be as long as the buf.

## Trait Implementations

### `impl Clone for Hasher` [src]

#### `fn clone(&self) -> Hasherⓘ

### Notable traits for Hasher

`impl Write for Hasher`
` [src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Drop for Hasher` [src]

#### `fn drop(&mut self)` [src]

Executes the destructor for this type. Read more

### `impl Send for Hasher` [src]

### `impl Sync for Hasher` [src]

### `impl Write for Hasher` [src]

#### `fn write(&mut self, buf: &[u8]) -> Result<usize>` [src]

Write a buffer into this writer, returning how many bytes were written. Read more

#### `fn flush(&mut self) -> Result<()>` [src]

Flush this output stream, ensuring that all intermediately buffered contents reach their destination. Read more

#### `pub fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>`1.36.0 [src]

Like `write`, except that it writes from a slice of buffers. Read more

#### `pub fn is_write_vectored(&self) -> bool` [src]

🔬 This is a nightly-only experimental API. (`can_vector`)

Determines if this `Write`r has an efficient `write_vectored` implementation. Read more

#### `pub fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>`1.0.0 [src]

Attempts to write an entire buffer into this writer. Read more

#### `pub fn write_all_vectored(
&mut self,
bufs: &mut [IoSlice<'_>]
) -> Result<(), Error>` [src]

🔬 This is a nightly-only experimental API. (`write_all_vectored`)

Attempts to write multiple buffers into this writer. Read more

#### `pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>`1.0.0 [src]

Writes a formatted string into this writer, returning any error encountered. Read more

#### `pub fn by_ref(&mut self) -> &mut Self` 1.0.0 [src]

Creates a “by reference” adaptor for this instance of `Write`. Read more

## Auto Trait Implementations

### `impl RefUnwindSafe for Hasher`

### `impl Unpin for Hasher`

### `impl UnwindSafe for Hasher`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.