| 1 |
use crate::consts::K32; |
| 2 |
|
| 3 |
#[rustfmt::skip] |
| 4 |
macro_rules! repeat64 { |
| 5 |
($i:ident, $b:block) => { |
| 6 |
let $i = 0; $b; let $i = 1; $b; let $i = 2; $b; let $i = 3; $b; |
| 7 |
let $i = 4; $b; let $i = 5; $b; let $i = 6; $b; let $i = 7; $b; |
| 8 |
let $i = 8; $b; let $i = 9; $b; let $i = 10; $b; let $i = 11; $b; |
| 9 |
let $i = 12; $b; let $i = 13; $b; let $i = 14; $b; let $i = 15; $b; |
| 10 |
let $i = 16; $b; let $i = 17; $b; let $i = 18; $b; let $i = 19; $b; |
| 11 |
let $i = 20; $b; let $i = 21; $b; let $i = 22; $b; let $i = 23; $b; |
| 12 |
let $i = 24; $b; let $i = 25; $b; let $i = 26; $b; let $i = 27; $b; |
| 13 |
let $i = 28; $b; let $i = 29; $b; let $i = 30; $b; let $i = 31; $b; |
| 14 |
let $i = 32; $b; let $i = 33; $b; let $i = 34; $b; let $i = 35; $b; |
| 15 |
let $i = 36; $b; let $i = 37; $b; let $i = 38; $b; let $i = 39; $b; |
| 16 |
let $i = 40; $b; let $i = 41; $b; let $i = 42; $b; let $i = 43; $b; |
| 17 |
let $i = 44; $b; let $i = 45; $b; let $i = 46; $b; let $i = 47; $b; |
| 18 |
let $i = 48; $b; let $i = 49; $b; let $i = 50; $b; let $i = 51; $b; |
| 19 |
let $i = 52; $b; let $i = 53; $b; let $i = 54; $b; let $i = 55; $b; |
| 20 |
let $i = 56; $b; let $i = 57; $b; let $i = 58; $b; let $i = 59; $b; |
| 21 |
let $i = 60; $b; let $i = 61; $b; let $i = 62; $b; let $i = 63; $b; |
| 22 |
}; |
| 23 |
} |
| 24 |
|
| 25 |
/// Read round constant |
| 26 |
fn rk(i: usize) -> u32 { |
| 27 |
// `read_volatile` forces compiler to read round constants from the static |
| 28 |
// instead of inlining them, which improves codegen and performance on some platforms. |
| 29 |
// On x86 targets 32-bit constants can be encoded using immediate argument on the `add` |
| 30 |
// instruction, so it's more efficient to inline them. |
| 31 |
cfg_if::cfg_if! { |
| 32 |
if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { |
| 33 |
use core::ptr::read as r; |
| 34 |
} else { |
| 35 |
use core::ptr::read_volatile as r; |
| 36 |
} |
| 37 |
} |
| 38 |
|
| 39 |
unsafe { |
| 40 |
let p = K32.as_ptr().add(i); |
| 41 |
r(p) |
| 42 |
} |
| 43 |
} |
| 44 |
|
| 45 |
/// Process a block with the SHA-256 algorithm. |
| 46 |
fn compress_block(state: &mut [u32; 8], block: &[u8; 64]) { |
| 47 |
let mut block = super::to_u32s(block); |
| 48 |
let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut h] = *state; |
| 49 |
|
| 50 |
repeat64!(i, { |
| 51 |
let w = if i < 16 { |
| 52 |
block[i] |
| 53 |
} else { |
| 54 |
let w15 = block[(i - 15) % 16]; |
| 55 |
let s0 = (w15.rotate_right(7)) ^ (w15.rotate_right(18)) ^ (w15 >> 3); |
| 56 |
let w2 = block[(i - 2) % 16]; |
| 57 |
let s1 = (w2.rotate_right(17)) ^ (w2.rotate_right(19)) ^ (w2 >> 10); |
| 58 |
block[i % 16] = block[i % 16] |
| 59 |
.wrapping_add(s0) |
| 60 |
.wrapping_add(block[(i - 7) % 16]) |
| 61 |
.wrapping_add(s1); |
| 62 |
block[i % 16] |
| 63 |
}; |
| 64 |
|
| 65 |
let s1 = e.rotate_right(6) ^ e.rotate_right(11) ^ e.rotate_right(25); |
| 66 |
let ch = (e & f) ^ ((!e) & g); |
| 67 |
let t1 = s1 |
| 68 |
.wrapping_add(ch) |
| 69 |
.wrapping_add(rk(i)) |
| 70 |
.wrapping_add(w) |
| 71 |
.wrapping_add(h); |
| 72 |
let s0 = a.rotate_right(2) ^ a.rotate_right(13) ^ a.rotate_right(22); |
| 73 |
let maj = (a & b) ^ (a & c) ^ (b & c); |
| 74 |
let t2 = s0.wrapping_add(maj); |
| 75 |
|
| 76 |
h = g; |
| 77 |
g = f; |
| 78 |
f = e; |
| 79 |
e = d.wrapping_add(t1); |
| 80 |
d = c; |
| 81 |
c = b; |
| 82 |
b = a; |
| 83 |
a = t1.wrapping_add(t2); |
| 84 |
}); |
| 85 |
|
| 86 |
state[0] = state[0].wrapping_add(a); |
| 87 |
state[1] = state[1].wrapping_add(b); |
| 88 |
state[2] = state[2].wrapping_add(c); |
| 89 |
state[3] = state[3].wrapping_add(d); |
| 90 |
state[4] = state[4].wrapping_add(e); |
| 91 |
state[5] = state[5].wrapping_add(f); |
| 92 |
state[6] = state[6].wrapping_add(g); |
| 93 |
state[7] = state[7].wrapping_add(h); |
| 94 |
} |
| 95 |
|
| 96 |
pub(in super::super) fn compress(state: &mut [u32; 8], blocks: &[[u8; 64]]) { |
| 97 |
for block in blocks { |
| 98 |
compress_block(state, block); |
| 99 |
} |
| 100 |
} |