ihash 0.1.2

World's fastest high-quality non-cryptographic hash, deterministic cross-platform XOF, and seekable stream cipher
Documentation
use core::mem::offset_of;

use crate::state::{State, aes_enc};

const MASTER_SEED: u64 = 0x517C_C1B7_2722_0A95;
pub(crate) const M_CTR: u64 = 0xD1B5_4A32_D192_ED03;
pub(crate) const GOLDEN_RATIO: u64 = 0x9E37_79B9_7F4A_7C15;

const fn splitmix(state: &mut u64) -> u64 {
  *state = state.wrapping_add(GOLDEN_RATIO);
  let mut z = *state;
  z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
  z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
  z ^ (z >> 31)
}

const fn next_state(state: &mut u64) -> State {
  let lo = splitmix(state) as u128;
  let hi = splitmix(state) as u128;
  (lo | (hi << 64)).to_le_bytes()
}

const fn next_state_li<const N: usize>(state: &mut u64) -> [State; N] {
  let mut out_li = [[0u8; 16]; N];
  let mut i = 0;
  while i < N {
    out_li[i] = next_state(state);
    i += 1;
  }
  out_li
}

struct ConstSpec {
  k_short_li: [u64; 12],
  lane_li: [State; 16],
  fin_li: [State; 8],
  stream_key_li: State,
}

const SPEC: ConstSpec = {
  let mut st = MASTER_SEED;
  let _ = splitmix(&mut st);
  let mut k_short_li = [0u64; 12];
  let mut i = 0;
  while i < 12 {
    k_short_li[i] = splitmix(&mut st) | 1;
    i += 1;
  }

  let lane_li = next_state_li::<16>(&mut st);
  let fin_li = next_state_li::<8>(&mut st);
  let stream_key_li = next_state(&mut st);

  ConstSpec {
    k_short_li,
    lane_li,
    fin_li,
    stream_key_li,
  }
};

const fn xor_state_const(a: State, b: State) -> State {
  let mut out_li = [0u8; 16];
  let mut i = 0;
  while i < 16 {
    out_li[i] = a[i] ^ b[i];
    i += 1;
  }
  out_li
}

/// Single cache-line-aligned table holding all hot SIMD lookup constants under one base pointer.
#[repr(C, align(64))]
pub(crate) struct ConstTable {
  /// Pre-expanded AES round state for `seed == 0` fast paths (Cache Line 0, bytes 0..16).
  pub(crate) sv0: State,
  /// Finalizer constants (`fin_li[1..3]` in `finalize_hi`, `fin_li[6]` in `expand_seed`/`sv0`;
  /// remaining slots pad `lane_sv0_li` to cache-line-aligned offset 128).
  pub(crate) fin_li: [State; 7],
  /// Pre-XORed lane keys (`lane_li[i] ^ sv0`) for seed-0 fast paths (64B-aligned at offset 128).
  pub(crate) lane_sv0_li: [State; 16],
  pub(crate) lane_li: [State; 16],
}

pub(crate) const K_SHORT_LI: [u64; 12] = SPEC.k_short_li;
pub(crate) static TBL: ConstTable = {
  let sv0 = aes_enc(SPEC.fin_li[6], [0u8; 16]);
  let mut lane_sv0_li = [[0u8; 16]; 16];
  let mut i = 0;
  while i < 16 {
    lane_sv0_li[i] = xor_state_const(SPEC.lane_li[i], sv0);
    i += 1;
  }
  ConstTable {
    sv0,
    fin_li: [
      SPEC.fin_li[0],
      SPEC.fin_li[1],
      SPEC.fin_li[2],
      SPEC.fin_li[3],
      SPEC.fin_li[4],
      SPEC.fin_li[5],
      SPEC.fin_li[6],
    ],
    lane_sv0_li,
    lane_li: SPEC.lane_li,
  }
};
pub(crate) const STREAM_KEY_LI: State = SPEC.stream_key_li;
pub(crate) const STREAM_FIN_LI: State = SPEC.fin_li[7];

/// Returns the base byte pointer to the pre-XORed or raw 16-lane key table.
#[inline(always)]
pub(crate) fn lane_ptr<const SEED0: bool>() -> *const u8 {
  if SEED0 {
    TBL.lane_sv0_li.as_ptr()
  } else {
    TBL.lane_li.as_ptr()
  }
  .cast()
}
pub(crate) const CTR_STEP_LI: [State; 17] = {
  let mut step_li = [[0u8; 16]; 17];
  let mut k = 0;
  while k < 17 {
    let lo = k as u128;
    let hi = ((k as u64).wrapping_mul(M_CTR) as u128) << 64;
    step_li[k] = (hi | lo).to_le_bytes();
    k += 1;
  }
  step_li
};

const fn state_eq(a: &State, b: &State) -> bool {
  let mut i = 0;
  while i < 16 {
    if a[i] != b[i] {
      return false;
    }
    i += 1;
  }
  true
}

const fn all_distinct(state_li: &[State]) -> bool {
  let mut i = 0;
  while i < state_li.len() {
    let mut j = i + 1;
    while j < state_li.len() {
      if state_eq(&state_li[i], &state_li[j]) {
        return false;
      }
      j += 1;
    }
    i += 1;
  }
  true
}

const _: () = {
  assert!(M_CTR & 1 == 1);
  assert!(CTR_STEP_LI[1][0] == 1);
  assert!(offset_of!(ConstTable, lane_sv0_li) == 128);
  assert!(all_distinct(&SPEC.lane_li));
  assert!(all_distinct(&SPEC.fin_li));
  assert!(!state_eq(&SPEC.fin_li[0], &[0u8; 16]));
};

const fn mul2(x: u8) -> u8 {
  (x << 1) ^ if x & 0x80 != 0 { 0x1B } else { 0 }
}

/// AES forward S-box computed at compile time over GF(2^8).
pub(crate) const SBOX_LI: [u8; 256] = {
  let mut sbox_li = [0x63; 256];
  let (mut p, mut q) = (1u8, 1u8);
  loop {
    p ^= mul2(p);
    q ^= q << 1;
    q ^= q << 2;
    q ^= q << 4;
    if q & 0x80 != 0 {
      q ^= 0x09;
    }
    sbox_li[p as usize] =
      0x63 ^ q ^ q.rotate_left(1) ^ q.rotate_left(2) ^ q.rotate_left(3) ^ q.rotate_left(4);
    if p == 1 {
      break sbox_li;
    }
  }
};

const MIX_LI: [u32; 256] = {
  let mut mix_li = [0u32; 256];
  let mut i = 0;
  while i < 256 {
    let s = SBOX_LI[i];
    mix_li[i] = u32::from_le_bytes([mul2(s), s, s, mul2(s) ^ s]);
    i += 1;
  }
  mix_li
};

const fn make_rot_tbl(rot: u32) -> [u32; 256] {
  let mut tbl_li = [0u32; 256];
  let mut i = 0;
  while i < 256 {
    tbl_li[i] = MIX_LI[i].rotate_left(rot);
    i += 1;
  }
  tbl_li
}

/// Pre-rotated 32-bit T-tables for branchless portable AES rounds.
pub(crate) const T0_LI: [u32; 256] = MIX_LI;
pub(crate) const T1_LI: [u32; 256] = make_rot_tbl(8);
pub(crate) const T2_LI: [u32; 256] = make_rot_tbl(16);
pub(crate) const T3_LI: [u32; 256] = make_rot_tbl(24);