Change Sha2::Digest to make {:x} easier (hex format)

[gjvnq]

Hi, I was writing a simple program and I discovered that getting a hex output of a generic hash is harder than I thought.

I expected that something like this would work:

extern crate sha2;
use sha2::Digest;

fn example<D: Digest>() {
    let mut hasher = D::new();
    hasher.input(b"hello world");
    let hash = hasher.result();
    println!("{:x}", hash);
}

However, the above code generates the following error:

error[E0277]: cannot add `<D as sha2::Digest>::OutputSize` to `<D as sha2::Digest>::OutputSize`
   --> src/main.rs:103:22
    |
99  | fn example<D: Digest>() {
    |                        - help: consider further restricting the associated type: `where <D as sha2::Digest>::OutputSize: std::ops::Add`
...
103 |     println!("{:x}", hash);
    |                      ^^^^ no implementation for `<D as sha2::Digest>::OutputSize + <D as sha2::Digest>::OutputSize`
    |
    = help: the trait `std::ops::Add` is not implemented for `<D as sha2::Digest>::OutputSize`
    = note: required because of the requirements on the impl of `std::fmt::LowerHex` for `sha2::digest::generic_array::GenericArray<u8, <D as sha2::Digest>::OutputSize>`
    = note: required by `std::fmt::LowerHex::fmt`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0277`.

After some experimentation, I discovered that the following code does work:

extern crate sha2;
use sha2::Digest;

fn example<D: Digest>() where <D as sha2::Digest>::OutputSize: std::ops::Add, <<D as sha2::Digest>::OutputSize as std::ops::Add>::Output: sha2::digest::generic_array::ArrayLength<u8>   {
    let mut hasher = D::new();
    hasher.input(b"hello world");
    let hash = hasher.result();
    println!("{:x}", hash);
}

So, I think that the Digest trait should be changed to make the extra code unecessary.

[tarcieri]

Wow, those are some wacky trait bound requirements!

This seems like an unfortunate complication of generic-array. I wonder if newer versions of generic-array than the one it’s presently using (v0.12) are any better...

[tarcieri]

@gjvnq do you really need something that’s generic around Digest? If not, you can use the concrete Sha256 type instead, which should eliminate the generic parameter and therefore the associated trait bounds.

[gjvnq]

Yes, I have a function like this:

fn do_backup(source: &Path, storage: &Path, alg: Digest)

However, I changed to OpenSSL to get hardware acceleration.

[newpavlov]

@gjvnq
FYI: we have added hardware acceleration support for SHA-1 and SHA-256.

[newpavlov]

Overall I am not sure if it's worth to complicate Digest for such corner case. The following signature is annoying, but will work in practice:

use digest::Digest;
use digest::generic_array::ArrayLength;
use std::ops::Add;

fn example<D>()
    where D: Digest, D::OutputSize: Add,
        <D::OutputSize as Add>::Output: ArrayLength<u8>
{ .. }

And personally I would use the hex crate instead of relying on formatting support from generic-array. Note that in future we will migrate to const generics and support of {:x} will disappear either way.

[kpcyrd]

Has this been removed with sha2 0.12/digest 0.11? :)

[newpavlov]

Effectively, yes. We migrated to hybrid-array and it does not implement Hex formatting traits since it tries to follow std as much as possible.

[kpcyrd]

Assuming other people also arrive at this issue with the same question - can somebody recommend a no_alloc hex encoder? Essentially "for any Iterator<Item = u8>, impl LowerHex"?

I checked multiple but they allocate into a temporary String or Vec internally. easy_hex::Hex](https://docs.rs/easy-hex/1.0.0/easy_hex/struct.Hex.html) looked really promising, yet still doesn't do it quite right.

Would something like this be of interest for the RustCrypto crate ecosystem? Writing the code for this is easy, having a well established crate for this isn't.

[tarcieri]

We already have https://docs.rs/base16ct/latest/base16ct/struct.HexDisplay.html