#[cfg(feature = "zeroize")]
use zeroize::Zeroize;
use crate::block::Block;
use crate::memory::{
compress::compress,
init::{Mode, initial_blocks},
};
use crate::params::Params;
pub(crate) fn build_buffer(
mode: Mode,
secret: Option<&[u8]>,
context: &str,
params: Params,
) -> Vec<Block> {
let q = params.m_cost() as usize;
let t = params.t_cost() as usize;
let mut v = vec![Block::new(); q];
let dst = v.first_chunk_mut::<2>().expect("m_cost is at least 2");
initial_blocks(dst, mode, params, context, secret);
fill(&mut v, q, t);
v
}
fn fill(v: &mut [Block], q: usize, t: usize) {
for pass in 0..t {
let start = if pass == 0 { 2 } else { 0 };
for j in start..q {
fill_block(v, q, pass, j);
}
}
}
fn fill_block(v: &mut [Block], q: usize, pass: usize, j: usize) {
let prev = prev_index(pass, j, q);
let len = w_len(pass, j, q);
let z = reference_index(prev, len, &v[prev]);
let mut r = &v[prev] ^ &v[z];
v[j].copy_from(&r);
compress(&mut v[j], &r);
#[cfg(feature = "zeroize")]
r.zeroize();
}
fn prev_index(pass: usize, j: usize, q: usize) -> usize {
if pass > 0 && j == 0 { q - 1 } else { j - 1 }
}
fn w_len(pass: usize, j: usize, q: usize) -> usize {
if pass == 0 { j - 1 } else { q - 1 }
}
fn reference_index(prev: usize, len: usize, prev_block: &Block) -> usize {
let pos = select(len, prev_block.j1());
w_index(prev, pos)
}
fn select(w_len: usize, j1: u32) -> usize {
let x = (u64::from(j1) * u64::from(j1)) >> 32;
let y = (w_len as u64 * x) >> 32;
w_len - 1 - y as usize
}
fn w_index(prev: usize, pos: usize) -> usize {
if pos < prev { pos } else { pos + 1 }
}
#[cfg(test)]
mod tests {
use argon2::{
Algorithm, Argon2, Block as ArgonBlock, Params as ArgonParams, Version,
};
use crate::block::Block;
use crate::params::Params;
use super::*;
const CONTEXT: &str = "TRAVERSEV_TEST";
const SECRET: &[u8] = b"This is a secret.";
#[test]
fn runs_passes_over_seeded_memory() {
let g = |x: &Block, y: &Block| -> Block {
let r = x ^ y;
let mut q = r.clone();
compress(&mut q, &r);
q
};
for (mode, secret) in
[(Mode::Trustless, None), (Mode::Permissioned, Some(SECRET))]
{
let params =
Params::new(8, 1, 1, 1).expect("test parameters are valid");
let mut dst = [Block::new(), Block::new()];
initial_blocks(&mut dst, mode, params, CONTEXT, secret);
let v = build_buffer(mode, secret, CONTEXT, params);
assert_eq!(v.len(), 8);
assert_eq!(v[0], dst[0]);
assert_eq!(v[1], dst[1]);
for j in 2..v.len() {
assert!((0..j - 1).any(|i| g(&v[j - 1], &v[i]) == v[j]));
}
let params =
Params::new(8, 2, 1, 1).expect("test parameters are valid");
let mut dst = [Block::new(), Block::new()];
initial_blocks(&mut dst, mode, params, CONTEXT, secret);
let v = build_buffer(mode, secret, CONTEXT, params);
assert_ne!(v[0], dst[0]);
assert_ne!(v[1], dst[1]);
}
}
#[test]
fn matches_argon2d_first_pass() {
let params = ArgonParams::new(8, 1, 1, None).unwrap();
let argon2 = Argon2::new(Algorithm::Argon2d, Version::V0x13, params);
let mut blocks = vec![ArgonBlock::default(); 8];
argon2
.fill_memory(b"password", b"some_salt", &mut blocks)
.unwrap();
let expected: Vec<Block> = blocks
.iter()
.map(|block| {
let words: &[u64] = block.as_ref();
let mut b = Block::new();
b.copy_from_slice(words);
b
})
.collect();
let mut v = vec![Block::new(); 8];
v[0].copy_from(&expected[0]);
v[1].copy_from(&expected[1]);
fill(&mut v, 8, 1);
assert_eq!(v, expected);
}
#[test]
fn later_passes_wrap_and_self_ref() {
let mut b0 = Block::new();
b0.fill(1);
let mut b1 = Block::new();
b1.fill(2);
let mut v = vec![b0.clone(), b1.clone()];
fill(&mut v, 2, 2);
let r = &b1 ^ &b0;
let mut new_b0 = r.clone();
compress(&mut new_b0, &r);
let r = &new_b0 ^ &b1;
let mut new_b1 = r.clone();
compress(&mut new_b1, &r);
assert_eq!(v, [new_b0, new_b1]);
}
}