use crate::host::with_host;
use crate::stdlib::common::{arg, int_arg, str_arg, throws};
use fusevm::Value;
type HmacAlgo = (fn(&[u8]) -> Vec<u8>, usize);
pub fn dispatch(name: &str, args: &[Value]) -> Option<Result<Value, String>> {
Some(match name {
"md5_file" => file_digest_fn(md5_bytes, args),
"sha1_file" => file_digest_fn(sha1_bytes, args),
"hash_file" => hash_file(args),
"hash_hmac_file" => hash_hmac_file(args),
"hash_equals" => Ok(Value::bool(hash_equals(args))),
"hash_pbkdf2" => hash_pbkdf2(args),
"random_bytes" => random_bytes(args),
_ => return None,
})
}
fn bool_arg(args: &[Value], i: usize) -> bool {
with_host(|h| h.is_truthy(&arg(args, i)))
}
fn wrap(bytes: Vec<u8>, raw: bool) -> Value {
if raw {
Value::str(bytes.iter().map(|&b| char::from(b)).collect::<String>())
} else {
Value::str(hex::encode(bytes))
}
}
fn read_file(path: &str) -> Option<Vec<u8>> {
std::fs::read(path).ok()
}
fn file_digest_fn(f: fn(&[u8]) -> Vec<u8>, args: &[Value]) -> Result<Value, String> {
let path = str_arg(args, 0);
let raw = bool_arg(args, 1);
match read_file(&path) {
Some(bytes) => Ok(wrap(f(&bytes), raw)),
None => Ok(Value::bool(false)),
}
}
fn hash_file(args: &[Value]) -> Result<Value, String> {
let algo = str_arg(args, 0).to_ascii_lowercase();
let path = str_arg(args, 1);
let raw = bool_arg(args, 2);
if !is_supported_algo(&algo) {
return Err(throws(
"ValueError",
"hash_file(): Argument #1 ($algo) must be a valid hashing algorithm",
));
}
let bytes = match read_file(&path) {
Some(b) => b,
None => return Ok(Value::bool(false)),
};
Ok(wrap(
digest_bytes(&algo, &bytes).expect("algo checked above"),
raw,
))
}
fn hash_hmac_file(args: &[Value]) -> Result<Value, String> {
let algo = str_arg(args, 0).to_ascii_lowercase();
let path = str_arg(args, 1);
let key = str_arg(args, 2).into_bytes();
let raw = bool_arg(args, 3);
let (f, block_size) = match hmac_algo(&algo) {
Some(pair) => pair,
None => {
return Err(throws(
"ValueError",
"hash_hmac_file(): Argument #1 ($algo) must be a valid cryptographic \
hashing algorithm",
));
}
};
let bytes = match read_file(&path) {
Some(b) => b,
None => return Ok(Value::bool(false)),
};
Ok(wrap(hmac(block_size, f, &key, &bytes), raw))
}
fn hash_equals(args: &[Value]) -> bool {
let known = str_arg(args, 0).into_bytes();
let user = str_arg(args, 1).into_bytes();
if known.len() != user.len() {
return false;
}
let mut diff: u8 = 0;
for (a, b) in known.iter().zip(user.iter()) {
diff |= a ^ b;
}
diff == 0
}
fn hash_pbkdf2(args: &[Value]) -> Result<Value, String> {
let algo = str_arg(args, 0).to_ascii_lowercase();
let password = str_arg(args, 1).into_bytes();
let salt = str_arg(args, 2).into_bytes();
let iterations = int_arg(args, 3);
let length = int_arg(args, 4);
let raw = bool_arg(args, 5);
let (f, block_size) = match hmac_algo(&algo) {
Some(pair) => pair,
None => {
return Err(throws(
"ValueError",
"hash_pbkdf2(): Argument #1 ($algo) must be a valid cryptographic \
hashing algorithm",
));
}
};
if iterations <= 0 {
return Err(throws(
"ValueError",
"hash_pbkdf2(): Argument #4 ($iterations) must be greater than 0",
));
}
if length < 0 {
return Err(throws(
"ValueError",
"hash_pbkdf2(): Argument #5 ($length) must be greater than or equal to 0",
));
}
if length > (1 << 24) {
return Err("hash_pbkdf2(): Argument #5 ($length) is too large".to_string());
}
let hlen = f(&[]).len();
let length = length as usize;
let (dk_len, full) = if length == 0 {
(hlen, true)
} else if raw {
(length, false)
} else {
(length.div_ceil(2), false)
};
let dk = pbkdf2(f, block_size, &password, &salt, iterations as usize, dk_len);
if raw {
Ok(wrap(dk, true))
} else {
let hexed = hex::encode(dk);
if full {
Ok(Value::str(hexed))
} else {
Ok(Value::str(hexed[..length].to_string()))
}
}
}
fn random_bytes(args: &[Value]) -> Result<Value, String> {
let len = int_arg(args, 0);
if len < 1 {
return Err(throws(
"ValueError",
"random_bytes(): Argument #1 ($length) must be greater than 0",
));
}
if len > (1 << 24) {
return Err("random_bytes(): Argument #1 ($length) is too large".to_string());
}
let len = len as usize;
let mut out = Vec::with_capacity(len);
let mut state = seed();
while out.len() < len {
state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
for b in splitmix64(state).to_le_bytes() {
if out.len() < len {
out.push(b);
}
}
}
Ok(wrap(out, true))
}
fn is_supported_algo(algo: &str) -> bool {
matches!(
algo,
"md5" | "sha1" | "sha256" | "sha384" | "sha512" | "crc32b"
)
}
fn digest_bytes(algo: &str, data: &[u8]) -> Option<Vec<u8>> {
Some(match algo {
"md5" => md5_bytes(data),
"sha1" => sha1_bytes(data),
"sha256" => sha256_bytes(data),
"sha384" => sha384_bytes(data),
"sha512" => sha512_bytes(data),
"crc32b" => crc32b_bytes(data),
_ => return None,
})
}
fn hmac_algo(algo: &str) -> Option<HmacAlgo> {
Some(match algo {
"md5" => (md5_bytes, 64),
"sha1" => (sha1_bytes, 64),
"sha256" => (sha256_bytes, 64),
"sha384" => (sha384_bytes, 128),
"sha512" => (sha512_bytes, 128),
_ => return None,
})
}
fn md5_bytes(data: &[u8]) -> Vec<u8> {
use md5::{Digest, Md5};
let mut h = Md5::new();
h.update(data);
h.finalize().to_vec()
}
fn sha1_bytes(data: &[u8]) -> Vec<u8> {
use sha1::{Digest, Sha1};
let mut h = Sha1::new();
h.update(data);
h.finalize().to_vec()
}
fn sha256_bytes(data: &[u8]) -> Vec<u8> {
use sha2::{Digest, Sha256};
let mut h = Sha256::new();
h.update(data);
h.finalize().to_vec()
}
fn sha384_bytes(data: &[u8]) -> Vec<u8> {
use sha2::{Digest, Sha384};
let mut h = Sha384::new();
h.update(data);
h.finalize().to_vec()
}
fn sha512_bytes(data: &[u8]) -> Vec<u8> {
use sha2::{Digest, Sha512};
let mut h = Sha512::new();
h.update(data);
h.finalize().to_vec()
}
fn crc32b_bytes(data: &[u8]) -> Vec<u8> {
let mut h = crc32fast::Hasher::new();
h.update(data);
h.finalize().to_be_bytes().to_vec()
}
fn hmac(block_size: usize, f: fn(&[u8]) -> Vec<u8>, key: &[u8], msg: &[u8]) -> Vec<u8> {
let mut k = if key.len() > block_size {
f(key)
} else {
key.to_vec()
};
k.resize(block_size, 0);
let mut inner: Vec<u8> = k.iter().map(|b| b ^ 0x36).collect();
inner.extend_from_slice(msg);
let ih = f(&inner);
let mut outer: Vec<u8> = k.iter().map(|b| b ^ 0x5c).collect();
outer.extend_from_slice(&ih);
f(&outer)
}
fn pbkdf2(
f: fn(&[u8]) -> Vec<u8>,
block_size: usize,
password: &[u8],
salt: &[u8],
iterations: usize,
dk_len: usize,
) -> Vec<u8> {
let hlen = f(&[]).len();
let n_blocks = dk_len.div_ceil(hlen);
let mut out = Vec::with_capacity(n_blocks * hlen);
for i in 1..=n_blocks as u32 {
let mut msg = salt.to_vec();
msg.extend_from_slice(&i.to_be_bytes());
let mut u = hmac(block_size, f, password, &msg);
let mut t = u.clone();
for _ in 1..iterations {
u = hmac(block_size, f, password, &u);
for (tb, ub) in t.iter_mut().zip(u.iter()) {
*tb ^= *ub;
}
}
out.extend_from_slice(&t);
}
out.truncate(dk_len);
out
}
fn seed() -> u64 {
let pid = std::process::id() as u64;
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos() as u64)
.unwrap_or(0);
nanos ^ pid.wrapping_mul(0x9E37_79B9_7F4A_7C15)
}
fn splitmix64(mut z: u64) -> u64 {
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
}