use argon2::{Algorithm, Argon2, Block, Params, Version};
use secure_gate::{Dynamic, RevealSecret, RevealSecretMut};
use sha1::digest::Output;
use sha1::{Digest, Sha1};
use sha2::Sha256;
use crate::limits::{ARGON2_MIN_M_COST_KIB, ARGON2_MIN_P_COST, ARGON2_MIN_T_COST};
use crate::sensitive::{PasswordBytes, PasswordDigest};
use crate::types::StartKeyAlg;
pub(crate) fn start_key(password: &str, alg: StartKeyAlg) -> PasswordDigest {
fn digest_into<D: Digest>(password: &str) -> PasswordDigest {
let mut h = D::new();
h.update(password.as_bytes());
PasswordDigest::new_with(<D as Digest>::output_size(), |slot| {
if let Ok(out) = <&mut Output<D>>::try_from(slot) {
h.finalize_into(out);
}
})
}
match alg {
StartKeyAlg::Sha1 => digest_into::<Sha1>(password),
StartKeyAlg::Sha256 => digest_into::<Sha256>(password),
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum LegacyStartKey {
StarOfficeUtf8,
ForcedSha256,
StarOfficeMs1252,
}
pub(crate) const SHA1_LADDER: [LegacyStartKey; 3] = [
LegacyStartKey::StarOfficeUtf8,
LegacyStartKey::ForcedSha256,
LegacyStartKey::StarOfficeMs1252,
];
pub(crate) fn legacy_start_key(password: &str, rung: LegacyStartKey) -> PasswordDigest {
match rung {
LegacyStartKey::StarOfficeUtf8 => staroffice_sha1(password.as_bytes()),
LegacyStartKey::ForcedSha256 => start_key(password, StartKeyAlg::Sha256),
LegacyStartKey::StarOfficeMs1252 => {
crate::ms1252::encode(password).with_secret(|b| staroffice_sha1(b))
}
}
}
const SHA1_INIT: [u32; 5] = [
0x6745_2301,
0xEFCD_AB89,
0x98BA_DCFE,
0x1032_5476,
0xC3D2_E1F0,
];
const SHA1_BLOCK: usize = 64;
fn staroffice_sha1(msg: &[u8]) -> PasswordDigest {
let mut state = SHA1_INIT;
let full = msg.len() - msg.len() % SHA1_BLOCK;
let (blocks, tail) = msg.split_at(full);
sha1::block_api::compress(&mut state, blocks.as_chunks::<SHA1_BLOCK>().0);
let padded_len = if tail.len() >= 52 {
2 * SHA1_BLOCK
} else {
SHA1_BLOCK
};
let bit_len = (msg.len() as u64).wrapping_mul(8);
let padded = PasswordBytes::new_with(padded_len, |buf| {
if let Some(dst) = buf.get_mut(..tail.len()) {
dst.copy_from_slice(tail);
}
if let Some(b) = buf.get_mut(tail.len()) {
*b = 0x80;
}
if let Some(dst) = buf.get_mut(padded_len - 8..) {
dst.copy_from_slice(&bit_len.to_be_bytes());
}
});
padded.with_secret(|buf| {
sha1::block_api::compress(&mut state, buf.as_chunks::<SHA1_BLOCK>().0);
});
PasswordDigest::new_with(20, |slot| {
for (dst, word) in slot.as_chunks_mut::<4>().0.iter_mut().zip(state) {
dst.copy_from_slice(&word.to_be_bytes());
}
})
}
#[derive(Debug)]
pub(crate) enum KdfError {
Params(crate::BadParameter),
Internal(&'static str),
HostCannotAllocate { requested_bytes: usize },
HostCannotSpawn { requested_bytes: usize },
}
pub(crate) fn derive_argon2id(
start_key: &[u8],
salt: &[u8],
t: i32,
m: i32,
p: i32,
limits: &crate::DecryptLimits,
out: &mut [u8],
) -> Result<(), KdfError> {
use crate::bad_parameter::{wide, BadParameter, ManifestField, Primitive};
use crate::Argon2Axis;
let out_of_range = |axis, got: i64, min: u32, max: u32| {
KdfError::Params(BadParameter::OutOfRange {
field: ManifestField::Argon2(axis),
got,
min: min.into(),
max: max.into(),
})
};
let argon2_rejects = |field, got: i64, min: i64, max: i64| {
KdfError::Params(BadParameter::CipherRejects {
field,
by: Primitive::Argon2,
got,
min,
max,
})
};
let (t_max, m_max) = (limits.argon2_max_t, limits.argon2_max_m_kib);
let t = u32::try_from(t)
.map_err(|_| out_of_range(Argon2Axis::T, t.into(), ARGON2_MIN_T_COST, t_max))?;
let m = u32::try_from(m)
.map_err(|_| out_of_range(Argon2Axis::MKib, m.into(), ARGON2_MIN_M_COST_KIB, m_max))?;
let p_wide = i64::from(p);
let p = u32::try_from(p).map_err(|_| {
out_of_range(
Argon2Axis::P,
p_wide,
ARGON2_MIN_P_COST,
limits.argon2_max_p,
)
})?;
if !(ARGON2_MIN_T_COST..=t_max).contains(&t) {
return Err(out_of_range(
Argon2Axis::T,
t.into(),
ARGON2_MIN_T_COST,
t_max,
));
}
if !(ARGON2_MIN_M_COST_KIB..=m_max).contains(&m) {
return Err(out_of_range(
Argon2Axis::MKib,
m.into(),
ARGON2_MIN_M_COST_KIB,
m_max,
));
}
let p_max = limits.argon2_max_p.min(Params::MAX_P_COST);
if !(ARGON2_MIN_P_COST..=p_max).contains(&p) {
return Err(
if p > Params::MAX_P_COST && Params::MAX_P_COST <= limits.argon2_max_p {
argon2_rejects(
ManifestField::Argon2(Argon2Axis::P),
p.into(),
ARGON2_MIN_P_COST.into(),
Params::MAX_P_COST.into(),
)
} else {
out_of_range(
Argon2Axis::P,
p.into(),
ARGON2_MIN_P_COST,
limits.argon2_max_p,
)
},
);
}
if u64::from(m) < 8 * u64::from(p) {
return Err(argon2_rejects(
ManifestField::Argon2(Argon2Axis::MKib),
m.into(),
8 * i64::from(p),
m_max.into(),
));
}
if !(argon2::MIN_SALT_LEN..=argon2::MAX_SALT_LEN).contains(&salt.len()) {
return Err(argon2_rejects(
ManifestField::SaltLen,
wide(salt.len()),
wide(argon2::MIN_SALT_LEN),
wide(argon2::MAX_SALT_LEN),
));
}
let params = Params::new(m, t, p, Some(out.len())).map_err(argon2_internal)?;
let block_count = params.block_count();
let requested_bytes = block_count.saturating_mul(Block::SIZE);
let mut blocks: Vec<Block> = Vec::new();
blocks
.try_reserve_exact(block_count)
.map_err(|_| KdfError::HostCannotAllocate { requested_bytes })?;
blocks.resize(block_count, Block::default());
let lanes = params.p_cost() as usize;
let argon2 = Argon2::new(Algorithm::Argon2id, Version::V0x13, params);
let mut blocks = Dynamic::<Vec<Block>>::new(blocks);
on_lane_threads(lanes, || {
blocks.with_secret_mut(|b| {
argon2.hash_password_into_with_memory(start_key, salt, out, b.as_mut_slice())
})
})?
.map_err(argon2_internal)
}
const LANE_THREAD_STACK: usize = 2 * 1024 * 1024;
fn on_lane_threads<T: Send>(lanes: usize, hash: impl FnOnce() -> T + Send) -> Result<T, KdfError> {
let cores = std::thread::available_parallelism().map_or(1, usize::from);
let want = lanes.clamp(1, cores);
let pool = |n: usize| {
rayon::ThreadPoolBuilder::new()
.num_threads(n)
.stack_size(LANE_THREAD_STACK)
.build()
};
let pool = pool(want)
.or_else(|_| pool(1))
.map_err(|_| KdfError::HostCannotSpawn {
requested_bytes: LANE_THREAD_STACK,
})?;
Ok(pool.install(hash))
}
fn argon2_internal(e: argon2::Error) -> KdfError {
KdfError::Internal(match e {
argon2::Error::OutputTooShort | argon2::Error::OutputTooLong => {
"argon2 refused the derived key length"
}
argon2::Error::PwdTooLong | argon2::Error::SecretTooLong => {
"argon2 refused the start key's length"
}
argon2::Error::SaltTooShort | argon2::Error::SaltTooLong => {
"argon2 refused a salt length the screen passed"
}
argon2::Error::MemoryTooLittle | argon2::Error::MemoryTooMuch => {
"argon2 refused a memory cost the screen passed"
}
_ => "argon2 refused parameters the screen passed",
})
}
#[cfg(test)]
mod tests {
use super::*;
fn digest(msg: &[u8]) -> Vec<u8> {
staroffice_sha1(msg).with_secret(|d| d.to_vec())
}
fn msg(n: usize) -> Vec<u8> {
(0..n).map(|i| (i * 7 + 3) as u8).collect()
}
#[test]
fn staroffice_sha1_matches_the_reference_model_inside_the_window() {
for (n, want) in [
(52, "e43b7c9b5d04760bc10659c3b67558bf2ca2fb39"),
(55, "c61212f6827fa5ee15e4b421ce9e81ae554c3e84"),
(116, "7ad0ef8d27d013d9df5c9f4ffc2f24e6ef9b8ca6"),
(119, "cf36aca5f9366e17bf93f4f4b7cc205a6873c2dd"),
] {
let got: String = digest(&msg(n)).iter().map(|b| format!("{b:02x}")).collect();
assert_eq!(got, want, "len {n}");
assert_ne!(digest(&msg(n)), Sha1::digest(msg(n)).to_vec(), "len {n}");
}
}
#[test]
fn staroffice_sha1_is_sha1_outside_the_window() {
for n in (0..200).filter(|n| !(52..=55).contains(&(n % 64))) {
assert_eq!(digest(&msg(n)), Sha1::digest(msg(n)).to_vec(), "len {n}");
}
}
#[test]
fn the_rungs_are_distinct_for_a_password_built_to_separate_them() {
let pw = format!("{}\u{e4}", "x".repeat(51));
let mut keys: Vec<Vec<u8>> = SHA1_LADDER
.iter()
.map(|&r| legacy_start_key(&pw, r).with_secret(|d| d.to_vec()))
.collect();
keys.push(start_key(&pw, StartKeyAlg::Sha1).with_secret(|d| d.to_vec()));
let n = keys.len();
keys.sort();
keys.dedup();
assert_eq!(keys.len(), n);
}
#[test]
fn argon2id_matches_the_reference_implementation() {
let start = b"start key bytes, 32 long........";
let salt = b"saltsaltsaltsalt";
let limits = crate::DecryptLimits::default();
for (t, m, p, want) in [
(
2,
256,
4,
"a4022fe20744a918661506e69a8cd366d894c11359ce49ffec42c75caa26ffc5",
),
(
3,
65536,
4,
"cb0e4d45be1b5338783f5f3fea374cd1a705e6d84131e3a7930cadcdd3074677",
),
(
1,
64,
8,
"26c3f9dd5063a88489e501c23dc687ee72a57fc141b8069237a5e6c2d1956603",
),
] {
let mut out = [0u8; 32];
derive_argon2id(start, salt, t, m, p, &limits, &mut out).unwrap();
let got: String = out.iter().map(|b| format!("{b:02x}")).collect();
assert_eq!(got, want, "(t, m, p) = ({t}, {m}, {p})");
}
}
#[test]
fn one_lane_thread_derives_what_many_do() {
let params = Params::new(256, 2, 8, Some(32)).unwrap();
let run = |threads: usize| {
let argon2 = Argon2::new(Algorithm::Argon2id, Version::V0x13, params.clone());
let mut blocks = vec![Block::default(); params.block_count()];
let mut out = [0u8; 32];
rayon::ThreadPoolBuilder::new()
.num_threads(threads)
.build()
.unwrap()
.install(|| {
argon2.hash_password_into_with_memory(
b"pw",
b"saltsaltsaltsalt",
&mut out,
&mut blocks,
)
})
.unwrap();
out
};
assert_eq!(run(1), run(8));
}
}