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>,
refuse_cross_site: bool,
}
fn refuses_cross_site(cookie_opts: Option<&Table>) -> mlua::Result<bool> {
let Some(opts) = cookie_opts else {
return Ok(true);
};
let same_site: Option<String> = opts.get("same_site")?;
Ok(!same_site.is_some_and(|value| value.eq_ignore_ascii_case("none")))
}
fn new_token() -> mlua::Result<String> {
let mut buf = [0u8; 32];
getrandom::fill(&mut buf)
.map_err(|err| mlua::Error::RuntimeError(format!("failed to read OS entropy: {err}")))?;
Ok(B64.encode(buf))
}
fn cookie_opts(lua: &Lua, caller: Option<&Table>) -> mlua::Result<Table> {
let opts = lua.create_table()?;
opts.set("path", "/")?;
opts.set("same_site", "Lax")?;
http::merge_cookie_opts(opts, caller)
}
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, method): (String, String) = match &req {
Value::UserData(ud) => (ud.get("id")?, ud.get("method")?),
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 safe = matches!(method.as_str(), "GET" | "HEAD" | "OPTIONS" | "TRACE");
let resp = if safe {
next.call_async::<Value>(&req).await?
} else {
let cross_site = match &req {
Value::UserData(ud) if config.refuse_cross_site => ud
.get::<Table>("headers")?
.get::<Option<String>>("sec-fetch-site")?
.is_some_and(|site| site.eq_ignore_ascii_case("cross-site")),
_ => false,
};
let supplied = if cross_site {
None
} else {
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)?;
let headers = resp.get::<Table>("headers")?;
let wants_json = match &req {
Value::UserData(ud) => ud
.get::<Table>("headers")?
.get::<Option<String>>("accept")?
.is_some_and(|accept| accept.contains("application/json")),
_ => false,
};
if wants_json {
headers.set("Content-Type", "application/json")?;
resp.set(
"body",
r#"{"code":"CSRF_INVALID","message":"missing or invalid CSRF token"}"#,
)?;
} else {
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 = cookie_opts(&lua, config.cookie_opts.as_ref())?;
let signed = http::sign(&config.cookie, &token, &config.secret);
http::attach_cookie(
resp,
http::build_cookie(&lua, &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(),
));
}
if opts.contains_key("cookie_opts")? {
return Err(mlua::Error::RuntimeError(
"nitr.csrf: `cookie_opts` is now `cookie` (the attribute table), and the \
cookie's name is `name`, as in nitr.session"
.into(),
));
}
let cookie_attrs = match opts.get::<Value>("cookie")? {
Value::Nil => None,
Value::Table(attrs) => Some(attrs),
other => {
return Err(mlua::Error::RuntimeError(format!(
"nitr.csrf: `cookie` is the attribute table (`{{ path = ..., same_site = \
... }}`); the cookie's name is `name`, got {}",
other.type_name()
)));
}
};
let config = Arc::new(Config {
secret,
cookie: opts
.get::<Option<String>>("name")?
.unwrap_or_else(|| "_csrf".into()),
header: opts
.get::<Option<String>>("header")?
.unwrap_or_else(|| "x-csrf-token".into())
.to_ascii_lowercase(),
field: opts
.get::<Option<String>>("field")?
.unwrap_or_else(|| "_csrf".into()),
refuse_cross_site: refuses_cross_site(cookie_attrs.as_ref())?,
cookie_opts: cookie_attrs,
});
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_refuses_the_old_cookie_spellings() {
let lua = Lua::new();
let csrf = create_csrf_table(&lua).expect("table");
for (opts, expected) in [
(
r#"{ secret = "csrf-secret-0123456789", cookie_opts = { path = "/" } }"#,
"`cookie_opts` is now `cookie`",
),
(
r#"{ secret = "csrf-secret-0123456789", cookie = "_token" }"#,
"the cookie's name is `name`",
),
] {
let opts: Table = lua.load(opts).eval().expect("opts");
let err = csrf
.call::<mlua::Function>(opts)
.expect_err("refused")
.to_string();
assert!(err.contains(expected), "{err}");
}
let opts: Table = lua
.load(r#"{ secret = "csrf-secret-0123456789", name = "_token", cookie = { path = "/" } }"#)
.eval()
.expect("opts");
csrf.call::<mlua::Function>(opts)
.expect("the new spellings");
}
#[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 cross_site_refusal_follows_the_cookie_policy() {
let lua = Lua::new();
assert!(refuses_cross_site(None).expect("default"));
for (opts, expected) in [
("{ path = '/admin' }", true),
("{ same_site = 'Lax' }", true),
("{ same_site = 'Strict' }", true),
("{ same_site = 'None' }", false),
("{ same_site = 'none' }", false),
] {
let table: Table = lua.load(opts).eval().expect("opts");
assert_eq!(
refuses_cross_site(Some(&table)).expect("policy"),
expected,
"{opts}"
);
}
}
#[test]
fn the_header_option_matches_regardless_of_case() {
let lua = Lua::new();
let csrf = create_csrf_table(&lua).expect("table");
let opts: Table = lua
.load(r#"{ secret = "0123456789abcdef", header = "X-CSRF-Token" }"#)
.eval()
.expect("opts");
let factory: Function = csrf.call(opts).expect("factory");
let _handler: Function = factory
.call(lua.create_function(|_, v: Value| Ok(v)).expect("next"))
.expect("handler");
let opts: Table = lua
.load(r#"{ secret = "0123456789abcdef", header = "X-CSRF-Token" }"#)
.eval()
.expect("opts");
let header: String = opts.get("header").expect("header");
assert_eq!(header.to_ascii_lowercase(), "x-csrf-token");
}
#[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}");
}
}