# Function crypto::sha2::sha512_digest_block [−] [src]

    pub fn sha512_digest_block(state: &mut [u64; 8], block: &[u8])

Process a block with the SHA-512 algorithm. (See more...)

Internally, this uses functions that resemble the new Intel SHA instruction set extensions, but since no architecture seems to have any designs, these may not be the final designs if and/or when there are instruction set extensions with SHA-512. So to summarize: SHA-1 and SHA-256 are being implemented in hardware soon (at the time of this writing), but it doesn't look like SHA-512 will be hardware accelerated any time soon.

# Implementation

These functions fall into two categories: message schedule calculation, and the message block 64-round digest calculation. The schedule-related functions allow 4 rounds to be calculated as:

    use std::simd::u64x2;
    use self::crypto::sha2::{
        sha512msg,
        sha512load
    };

    fn schedule4_data(work: &mut [u64x2], w: &[u64]) {

        // this is to illustrate the data order
        work[0] = u64x2(w[1], w[0]);
        work[1] = u64x2(w[3], w[2]);
        work[2] = u64x2(w[5], w[4]);
        work[3] = u64x2(w[7], w[6]);
        work[4] = u64x2(w[9], w[8]);
        work[5] = u64x2(w[11], w[10]);
        work[6] = u64x2(w[13], w[12]);
        work[7] = u64x2(w[15], w[14]);
    }

    fn schedule4_work(work: &mut [u64x2], t: usize) {

        // this is the core expression
        work[t] = sha512msg(work[t - 8],
                            work[t - 7],
                            sha512load(work[t - 4], work[t - 3]),
                            work[t - 1]);
    }

instead of 4 rounds of:

    fn schedule_work(w: &mut [u64], t: usize) {
        w[t] = sigma1!(w[t - 2]) + w[t - 7] + sigma0!(w[t - 15]) + w[t - 16];
    }

and the digest-related functions allow 4 rounds to be calculated as:

    use std::simd::u64x2;
    use self::crypto::sha2::{K64X2, sha512rnd};

    fn rounds4(state: &mut [u64; 8], work: &mut [u64x2], t: usize) {
        let [a, b, c, d, e, f, g, h]: [u64; 8] = *state;

        // this is to illustrate the data order
        let mut ae = u64x2(a, e);
        let mut bf = u64x2(b, f);
        let mut cg = u64x2(c, g);
        let mut dh = u64x2(d, h);
        let u64x2(w1, w0) = K64X2[2*t]     + work[2*t];
        let u64x2(w3, w2) = K64X2[2*t + 1] + work[2*t + 1];

        // this is the core expression
        dh = sha512rnd(ae, bf, cg, dh, w0);
        cg = sha512rnd(dh, ae, bf, cg, w1);
        bf = sha512rnd(cg, dh, ae, bf, w2);
        ae = sha512rnd(bf, cg, dh, ae, w3);

        *state = [ae.0, bf.0, cg.0, dh.0,
                  ae.1, bf.1, cg.1, dh.1];
    }

instead of 4 rounds of:

    fn round(state: &mut [u64; 8], w: &mut [u64], t: usize) {
        let [a, b, c, mut d, e, f, g, mut h]: [u64; 8] = *state;

        h += big_sigma1!(e) +   choose!(e, f, g) + K64[t] + w[t]; d += h;
        h += big_sigma0!(a) + majority!(a, b, c);

        *state = [h, a, b, c, d, e, f, g];
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)