123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138
use argon2::{hash_encoded, verify_encoded, Config, ThreadMode, Variant, Version};use bytes::Bytes;use deno_core::{plugin_api::Interface, Op, ZeroCopyBuf};
use crate::error::Error;
#[derive(Deserialize)]pub struct HashOptions {    salt: Bytes,    secret: Option<Bytes>,    data: Option<Bytes>,    version: Option<String>,    variant: Option<String>,    #[serde(rename(deserialize = "memoryCost"))]    memory_cost: Option<u32>,    #[serde(rename(deserialize = "timeCost"))]    time_cost: Option<u32>,    #[serde(rename(deserialize = "lanes"))]    lanes: Option<u32>,    #[serde(rename(deserialize = "threadMode"))]    thread_mode: Option<u8>,    #[serde(rename(deserialize = "hashLength"))]    hash_length: Option<u32>,}
#[derive(Deserialize)]struct HashParams {    password: String,    options: HashOptions,}
#[derive(Deserialize)]struct VerifyParams {    password: String,    hash: String,}
pub fn hash(_interface: &mut dyn Interface, buffs: &mut [ZeroCopyBuf]) -> Op {    let data = buffs[0].clone();    let mut buf = buffs[1].clone();    match hash_internal(&data) {        Ok(result) => {            buf[0] = 1;            Op::Sync(result.into_bytes().into_boxed_slice())        }        Err(err) => {            error_handler(err, &mut buf);            Op::Sync(Box::new([]))        }    }}
pub fn verify(_interface: &mut dyn Interface, buffs: &mut [ZeroCopyBuf]) -> Op {    let data = buffs[0].clone();    let mut buf = buffs[1].clone();    match verify_internal(&data) {        Ok(result) => {            buf[0] = 1;            Op::Sync(Box::new([result as u8]))        }        Err(err) => {            error_handler(err, &mut buf);            Op::Sync(Box::new([]))        }    }}
fn error_handler(err: Error, buf: &mut ZeroCopyBuf) {    buf[0] = 0;    let e = format!("{}", err);    let e = e.as_bytes();    for (index, byte) in e.iter().enumerate() {        buf[index + 1] = *byte;    }}
fn hash_internal(data: &ZeroCopyBuf) -> Result<String, Error> {    let params: HashParams = serde_json::from_slice(data)?;    let salt = params.options.salt;
    let mut config: Config = Config::default();
    if let Some(ref secret) = params.options.secret {        config.secret = &secret[..];    }
    if let Some(ref data) = params.options.data {        config.ad = &data[..];    }
    if let Some(memory_cost) = params.options.memory_cost {        config.mem_cost = memory_cost;    }
    if let Some(time_cost) = params.options.time_cost {        config.time_cost = time_cost;    }
    if let Some(variant) = params.options.variant {        if let Ok(v) = Variant::from_str(&variant) {            config.variant = v;        }    }
    if let Some(version) = params.options.version {        if let Ok(v) = Version::from_str(&version) {            config.version = v;        }    }
    if let Some(lanes) = params.options.lanes {        config.lanes = lanes;    }
    if let Some(hash_length) = params.options.hash_length {        config.hash_length = hash_length;    }
    if let Some(thread_mode) = params.options.thread_mode {        match thread_mode {            0 => config.thread_mode = ThreadMode::Sequential,            1 => config.thread_mode = ThreadMode::Parallel,            _ => {}        }    }
    Ok(hash_encoded(&params.password.into_bytes(), &salt, &config)?)}
fn verify_internal(data: &ZeroCopyBuf) -> Result<bool, Error> {    let options: VerifyParams = serde_json::from_slice(data)?;
    Ok(verify_encoded(        &options.hash,        &options.password.into_bytes(),    )?)}