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

    pub fn sha256_digest_block(state: &mut [u32; 8], block: &[u8])

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

Internally, this uses functions which resemble the new Intel SHA instruction sets, and so it's data locality properties may improve performance. However, to benefit the most from this implementation, replace these functions with x86 intrinsics to get a possible speed boost.

# Implementation

The `Sha256` algorithm is implemented with functions that resemble the new Intel SHA instruction set extensions. These intructions fall into two categories: message schedule calculation, and the message block 64-round digest calculation. The schedule-related instructions allow 4 rounds to be calculated as:

    use std::simd::u32x4;
    use self::crypto::sha2::{
        sha256msg1,
        sha256msg2,
        sha256load
    };

    fn schedule4_data(work: &mut [u32x4], w: &[u32]) {

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

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

        // this is the core expression
        work[t] = sha256msg2(sha256msg1(work[t - 4], work[t - 3]) +
                             sha256load(work[t - 2], work[t - 1]),
                             work[t - 1])
    }

instead of 4 rounds of:

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

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

    use std::simd::u32x4;
    use self::crypto::sha2::{K32X4,
        sha256rnds2,
        sha256swap
    };

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

        // this is to illustrate the data order
        let mut abef = u32x4(a, b, e, f);
        let mut cdgh = u32x4(c, d, g, h);
        let temp = K32X4[t] + work[t];

        // this is the core expression
        cdgh = sha256rnds2(cdgh, abef, temp);
        abef = sha256rnds2(abef, cdgh, sha256swap(temp));

        *state = [abef.0, abef.1, cdgh.0, cdgh.1,
                  abef.2, abef.3, cdgh.2, cdgh.3];
    }

instead of 4 rounds of:

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

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

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

NOTE: It is important to note, however, that these instructions are not implemented by any CPU (at the time of this writing), and so they are emulated in this library until the instructions become more common, and gain support in LLVM (and GCC, etc.).

# 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`)