use std::sync::Arc;
use base64::Engine as _;
use base64::engine::general_purpose::URL_SAFE_NO_PAD as B64;
use mlua::{Function, Lua, MetaMethod, ObjectLike as _, Table, Value};
use subtle::ConstantTimeEq as _;
use crate::http;
struct CsrfSlot {
req_id: String,
token: String,
}
struct Config {
secret: String,
cookie: String,
header: String,
field: String,
cookie_opts: Option<Table>,
}
fn new_token() -> mlua::Result<String> {
let mut buf = [0u8; 32];
getrandom::getrandom(&mut buf)
.map_err(|err| mlua::Error::RuntimeError(format!("failed to read OS entropy: {err}")))?;
Ok(B64.encode(buf))
}
fn default_cookie_opts(lua: &Lua) -> mlua::Result<Table> {
let opts = lua.create_table()?;
opts.set("path", "/")?;
opts.set("http_only", true)?;
opts.set("same_site", "Lax")?;
Ok(opts)
}
async fn supplied_token(req: &Value, config: &Config) -> mlua::Result<Option<String>> {
let Value::UserData(ud) = req else {
return Ok(None);
};
let headers: Table = ud.get("headers")?;
if let Some(token) = headers.get::<Option<String>>(config.header.as_str())? {
return Ok(Some(token));
}
let content_type: Option<String> = headers.get("content-type")?;
let is_form = content_type
.as_deref()
.is_some_and(|ct| ct.starts_with("application/x-www-form-urlencoded"));
if !is_form {
return Ok(None);
}
let form = ud.call_async_method::<Table>("form", ()).await?;
form.get(config.field.as_str())
}
fn cookie_token(req: &Value, config: &Config) -> Option<String> {
let Value::UserData(ud) = req else {
return None;
};
let cookies = ud.get::<mlua::AnyUserData>("cookies").ok()?;
let cookies = cookies.borrow::<http::RequestCookies>().ok()?;
http::verify(&config.cookie, cookies.get(&config.cookie)?, &config.secret)
}
async fn handle(lua: Lua, config: Arc<Config>, next: Function, req: Value) -> mlua::Result<Value> {
let req_id: String = match &req {
Value::UserData(ud) => ud.get("id")?,
other => {
return Err(mlua::Error::RuntimeError(format!(
"nitr.csrf middleware expects the request object, got {}",
other.type_name()
)));
}
};
let existing = cookie_token(&req, &config);
let issue = existing.is_none();
let token = match existing {
Some(token) => token,
None => new_token()?,
};
lua.set_app_data(CsrfSlot {
req_id,
token: token.clone(),
});
let method: String = match &req {
Value::UserData(ud) => ud.get("method")?,
_ => unreachable!("checked above"),
};
let safe = matches!(method.as_str(), "GET" | "HEAD" | "OPTIONS" | "TRACE");
let resp = if safe {
next.call_async::<Value>(&req).await?
} else {
let supplied = supplied_token(&req, &config).await?;
let ok = supplied.as_deref().is_some_and(|supplied| {
let (a, b) = (supplied.as_bytes(), token.as_bytes());
!issue && a.len() == b.len() && bool::from(a.ct_eq(b))
});
if ok {
next.call_async::<Value>(&req).await?
} else {
let resp = http::response_table(&lua, 403)?;
resp.get::<Table>("headers")?
.set("Content-Type", "text/plain; charset=utf-8")?;
resp.set("body", "Forbidden: missing or invalid CSRF token")?;
Value::Table(resp)
}
};
if issue && let Value::Table(resp) = &resp {
let opts = match &config.cookie_opts {
Some(opts) => opts.clone(),
None => default_cookie_opts(&lua)?,
};
let signed = http::sign(&config.cookie, &token, &config.secret);
http::attach_cookie(
resp,
http::build_cookie(&config.cookie, &signed, Some(&opts))?,
)?;
}
Ok(resp)
}
pub(crate) fn create_csrf_table(lua: &Lua) -> mlua::Result<Table> {
let csrf = lua.create_table()?;
csrf.set(
"token",
lua.create_function(|lua, req: Value| {
let req_id: Option<String> = match &req {
Value::UserData(ud) => ud.get("id").ok(),
_ => None,
};
let slot = lua.app_data_ref::<CsrfSlot>();
match (req_id, slot) {
(Some(req_id), Some(slot)) if slot.req_id == req_id => {
Ok(lua.create_string(&slot.token)?)
}
_ => Err(mlua::Error::RuntimeError(
"nitr.csrf.token(req): the nitr.csrf middleware did not run for this \
request — add app:use(nitr.csrf({ secret = ... })) before the routes"
.into(),
)),
}
})?,
)?;
let meta = create_call_metatable(lua)?;
csrf.set_metatable(Some(meta))?;
Ok(csrf)
}
fn create_call_metatable(lua: &Lua) -> mlua::Result<Table> {
let meta = lua.create_table()?;
meta.set(
MetaMethod::Call.name(),
lua.create_function(|lua, (_, opts): (Table, Table)| {
let secret: String = opts.get::<Option<String>>("secret")?.ok_or_else(|| {
mlua::Error::RuntimeError("nitr.csrf requires a `secret` option".into())
})?;
if secret.len() < 16 {
return Err(mlua::Error::RuntimeError(
"nitr.csrf `secret` must be at least 16 bytes".into(),
));
}
let config = Arc::new(Config {
secret,
cookie: opts
.get::<Option<String>>("cookie")?
.unwrap_or_else(|| "_csrf".into()),
header: opts
.get::<Option<String>>("header")?
.unwrap_or_else(|| "x-csrf-token".into()),
field: opts
.get::<Option<String>>("field")?
.unwrap_or_else(|| "_csrf".into()),
cookie_opts: opts.get("cookie_opts")?,
});
lua.create_function(move |lua, next: Function| {
let config = config.clone();
lua.create_async_function(move |lua, req: Value| {
handle(lua, config.clone(), next.clone(), req)
})
})
})?,
)?;
Ok(meta)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tokens_are_long_random_and_url_safe() {
let a = new_token().expect("token");
let b = new_token().expect("token");
assert_ne!(a, b);
assert_eq!(a.len(), 43);
assert!(
a.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
);
}
#[test]
fn the_factory_validates_its_secret_up_front() {
let lua = Lua::new();
let csrf = create_csrf_table(&lua).expect("table");
for opts in ["{}", r#"{ secret = "short" }"#] {
let opts: Table = lua.load(opts).eval().expect("opts");
let err = csrf.call::<Value>(opts).expect_err("weak secret");
assert!(err.to_string().contains("secret"), "got: {err}");
}
let opts: Table = lua
.load(r#"{ secret = "0123456789abcdef" }"#)
.eval()
.expect("opts");
let factory: Function = csrf.call(opts).expect("factory");
let next = lua.create_function(|_, v: Value| Ok(v)).expect("next");
let _handler: Function = factory.call(next).expect("handler");
}
#[test]
fn token_refuses_to_serve_a_stale_or_missing_slot() {
let lua = Lua::new();
let csrf = create_csrf_table(&lua).expect("table");
let token: Function = csrf.get("token").expect("fn");
let err = token.call::<Value>(Value::Nil).expect_err("no slot");
assert!(err.to_string().contains("middleware"), "got: {err}");
lua.set_app_data(CsrfSlot {
req_id: "other-request".into(),
token: "t0ken".into(),
});
let err = token.call::<Value>(Value::Nil).expect_err("stale slot");
assert!(err.to_string().contains("middleware"), "got: {err}");
}
}