use crate::host::with_host;
use crate::stdlib::common::{arg, str_arg, throws};
use fusevm::Value;
pub fn dispatch(name: &str, args: &[Value]) -> Option<Result<Value, String>> {
Some(match name {
"md5" => Ok(digest_fn(md5_bytes, args)),
"sha1" => Ok(digest_fn(sha1_bytes, args)),
"crc32" => Ok(Value::int(crc32b(&input_bytes(args, 0)) as i64)),
"hash" => php_hash(args),
"hash_hmac" => php_hash_hmac(args),
"hash_algos" => Ok(hash_algos()),
_ => return None,
})
}
fn input_bytes(args: &[Value], i: usize) -> Vec<u8> {
str_arg(args, i).into_bytes()
}
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 digest_fn(f: fn(&[u8]) -> Vec<u8>, args: &[Value]) -> Value {
wrap(f(&input_bytes(args, 0)), bool_arg(args, 1))
}
fn php_hash(args: &[Value]) -> Result<Value, String> {
let algo = str_arg(args, 0).to_ascii_lowercase();
let data = input_bytes(args, 1);
let raw = bool_arg(args, 2);
match digest_bytes(&algo, &data) {
Some(b) => Ok(wrap(b, raw)),
None => Err(throws(
"ValueError",
"hash(): Argument #1 ($algo) must be a valid hashing algorithm",
)),
}
}
fn php_hash_hmac(args: &[Value]) -> Result<Value, String> {
let algo = str_arg(args, 0).to_ascii_lowercase();
let data = input_bytes(args, 1);
let key = input_bytes(args, 2);
let raw = bool_arg(args, 3);
let f: fn(&[u8]) -> Vec<u8>;
let block_size = match algo.as_str() {
"md5" => {
f = md5_bytes;
64
}
"sha1" => {
f = sha1_bytes;
64
}
"sha256" => {
f = sha256_bytes;
64
}
"sha384" => {
f = sha384_bytes;
128
}
"sha512" => {
f = sha512_bytes;
128
}
_ => {
return Err(throws(
"ValueError",
"hash_hmac(): Argument #1 ($algo) must be a valid cryptographic \
hashing algorithm",
));
}
};
Ok(wrap(hmac(block_size, f, &key, &data), raw))
}
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),
"sha512" => sha512_bytes(data),
"crc32b" => crc32b(data).to_be_bytes().to_vec(),
"crc32" => crc32_bzip2(data).to_le_bytes().to_vec(),
_ => return None,
})
}
fn hash_algos() -> Value {
with_host(|h| {
let arr = h.new_array();
for a in ["md5", "sha1", "sha256", "sha512", "crc32", "crc32b"] {
h.arr_push_auto(&arr, Value::str(a.to_string()));
}
arr
})
}
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(data: &[u8]) -> u32 {
let mut h = crc32fast::Hasher::new();
h.update(data);
h.finalize()
}
fn crc32_bzip2(data: &[u8]) -> u32 {
let mut crc: u32 = 0xFFFF_FFFF;
for &byte in data {
crc ^= (byte as u32) << 24;
for _ in 0..8 {
crc = if crc & 0x8000_0000 != 0 {
(crc << 1) ^ 0x04C1_1DB7
} else {
crc << 1
};
}
}
crc ^ 0xFFFF_FFFF
}
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)
}