use base64::Engine as _;
use base64::engine::general_purpose::URL_SAFE_NO_PAD as B64URL;
use chacha20poly1305::aead::{Aead as _, Payload};
use chacha20poly1305::{XChaCha20Poly1305, XNonce};
use hmac::{Hmac, Mac as _};
use mlua::{Lua, LuaString, Table, Value};
use sha2::{Digest as _, Sha256};
use subtle::ConstantTimeEq as _;
const MAX_RANDOM_BYTES: usize = 64 * 1024;
fn rng_err(err: getrandom::Error) -> mlua::Error {
mlua::Error::RuntimeError(format!("failed to read OS entropy: {err}"))
}
const HEX_DIGITS: &[u8; 16] = b"0123456789abcdef";
fn hex(bytes: &[u8]) -> String {
let mut out = String::with_capacity(bytes.len() * 2);
for b in bytes {
out.push(HEX_DIGITS[(b >> 4) as usize] as char);
out.push(HEX_DIGITS[(b & 0x0f) as usize] as char);
}
out
}
pub fn create_crypto_table(lua: &Lua) -> mlua::Result<Table> {
let crypto = lua.create_table()?;
crypto.set(
"sha256",
lua.create_function(|_, data: LuaString| Ok(hex(&Sha256::digest(data.as_bytes()))))?,
)?;
crypto.set(
"hmac_sha256",
lua.create_function(|_, (key, data): (LuaString, LuaString)| {
let mut mac: Hmac<Sha256> = crate::utils::new_hmac(&key.as_bytes());
mac.update(&data.as_bytes());
Ok(hex(&mac.finalize().into_bytes()))
})?,
)?;
crypto.set(
"random_bytes",
lua.create_function(|lua, n: i64| {
if n < 1 || n > MAX_RANDOM_BYTES as i64 {
return Err(mlua::Error::RuntimeError(format!(
"random_bytes(n) requires 1 <= n <= {MAX_RANDOM_BYTES}, got {n}"
)));
}
let mut buf = vec![0u8; n as usize];
getrandom::fill(&mut buf).map_err(rng_err)?;
lua.create_string(&buf)
})?,
)?;
crypto.set(
"constant_time_eq",
lua.create_function(|_, (a, b): (LuaString, LuaString)| {
let (a, b) = (a.as_bytes(), b.as_bytes());
Ok(a.len() == b.len() && bool::from(a.ct_eq(&b)))
})?,
)?;
crypto.set(
"password_hash",
lua.create_async_function(|_, password: LuaString| async move {
let password = password.as_bytes().to_vec();
check_password_len(&password)?;
tokio::task::spawn_blocking(move || hash_password(&password))
.await
.map_err(mlua::Error::external)?
})?,
)?;
crypto.set("max_password_bytes", MAX_PASSWORD_BYTES)?;
crypto.set(
"seal",
lua.create_function(
|lua, (key, plaintext, aad): (LuaString, LuaString, Option<LuaString>)| {
let cipher = aead_cipher(&key)?;
let mut nonce = [0u8; 24];
getrandom::fill(&mut nonce).map_err(rng_err)?;
let nonce = XNonce::from(nonce);
let aad = aad
.as_ref()
.map(|s| s.as_bytes().to_vec())
.unwrap_or_default();
let ciphertext = cipher
.encrypt(
&nonce,
Payload {
msg: &plaintext.as_bytes(),
aad: &aad,
},
)
.map_err(|_| mlua::Error::RuntimeError("encryption failed".into()))?;
let mut sealed = nonce.to_vec();
sealed.extend_from_slice(&ciphertext);
lua.create_string(B64URL.encode(sealed))
},
)?,
)?;
crypto.set(
"open",
lua.create_function(
|lua, (key, sealed, aad): (LuaString, LuaString, Option<LuaString>)| {
let cipher = aead_cipher(&key)?;
let aad = aad
.as_ref()
.map(|s| s.as_bytes().to_vec())
.unwrap_or_default();
let Ok(raw) = B64URL.decode(&*sealed.as_bytes()) else {
return Ok(Value::Nil);
};
if raw.len() < 24 {
return Ok(Value::Nil);
}
let (nonce, ciphertext) = raw.split_at(24);
let Ok(nonce) = XNonce::try_from(nonce) else {
return Ok(Value::Nil);
};
match cipher.decrypt(
&nonce,
Payload {
msg: ciphertext,
aad: &aad,
},
) {
Ok(plaintext) => Ok(Value::String(lua.create_string(plaintext)?)),
Err(_) => Ok(Value::Nil),
}
},
)?,
)?;
crypto.set("jwt", create_jwt_table(lua)?)?;
crypto.set(
"password_verify",
lua.create_async_function(|lua, (password, hash): (LuaString, String)| async move {
let password = password.as_bytes().to_vec();
if password.len() > MAX_PASSWORD_BYTES {
tracing::debug!(
bytes = password.len(),
"password_verify: over the {MAX_PASSWORD_BYTES}-byte cap, answered false \
before hashing"
);
return Ok((false, Value::Nil));
}
let owned = hash.clone();
let outcome = tokio::task::spawn_blocking(move || verify_stored(&password, &owned))
.await
.map_err(mlua::Error::external)?;
match outcome {
VerifyOutcome::Matched => Ok((true, Value::Nil)),
VerifyOutcome::Mismatch => Ok((false, Value::Nil)),
VerifyOutcome::Rejected(reason) => reject_hash(&lua, &hash, reason),
}
})?,
)?;
crypto.set(
"password_verify_dummy",
lua.create_async_function(|_, password: LuaString| async move {
let password = password.as_bytes().to_vec();
if password.len() > MAX_PASSWORD_BYTES {
return Ok(false);
}
tokio::task::spawn_blocking(move || dummy_verify(&password))
.await
.map_err(mlua::Error::external)?
})?,
)?;
Ok(crypto)
}
fn aead_cipher(key: &LuaString) -> mlua::Result<XChaCha20Poly1305> {
let key = key.as_bytes();
if key.len() != 32 {
return Err(mlua::Error::RuntimeError(format!(
"seal/open take a 32-byte key, got {} bytes — generate one with \
nitr.crypto.random_bytes(32) and keep it in the configuration",
key.len()
)));
}
let key = chacha20poly1305::Key::try_from(&*key)
.map_err(|_| mlua::Error::RuntimeError("seal/open key conversion failed".into()))?;
Ok(<XChaCha20Poly1305 as chacha20poly1305::KeyInit>::new(&key))
}
mod auth;
mod jwt;
mod password;
#[cfg(test)]
mod tests;
pub use auth::create_auth_table;
use jwt::create_jwt_table;
pub use password::VERIFY_REASONS;
use password::{
MAX_PASSWORD_BYTES, VerifyOutcome, check_password_len, dummy_verify, hash_password,
reject_hash, verify_stored,
};