use mlua::{Lua, ObjectLike as _, Table, Value};
use crate::http;
const MAX_SESSION_JSON: usize = 2800;
const RESERVED: &[&str] = &["save", "clear"];
const EXPIRES_KEY: &str = "_exp";
fn unix_now() -> i64 {
crate::clock::now_unix()
}
fn cookie_opts(lua: &Lua, base: Option<&Table>, max_age: Option<i64>) -> mlua::Result<Table> {
let opts = lua.create_table()?;
opts.set("path", "/")?;
opts.set("same_site", "Lax")?;
let opts = http::merge_cookie_opts(opts, base)?;
if let Some(max_age) = max_age {
opts.set("max_age", max_age)?;
}
Ok(opts)
}
fn load_into(lua: &Lua, session: &Table, payload: &str, now: i64) -> mlua::Result<()> {
let Ok(serde_json::Value::Object(map)) = serde_json::from_str::<serde_json::Value>(payload)
else {
return Ok(());
};
if let Some(exp) = map.get(EXPIRES_KEY) {
if exp.as_i64().is_none_or(|exp| now >= exp) {
return Ok(());
}
}
for (key, value) in map {
if key == EXPIRES_KEY {
continue;
}
use mlua::LuaSerdeExt as _;
session.set(key, lua.to_value(&value)?)?;
}
Ok(())
}
fn serialize(session: &Table, max_age: Option<i64>, now: i64) -> mlua::Result<String> {
for reserved in RESERVED {
if !session.raw_get::<Value>(*reserved)?.is_nil() {
return Err(mlua::Error::RuntimeError(format!(
"`{reserved}` is reserved on a session (it is a method name)"
)));
}
}
if !session.raw_get::<Value>(EXPIRES_KEY)?.is_nil() {
return Err(mlua::Error::RuntimeError(format!(
"`{EXPIRES_KEY}` is reserved on a session (it carries the expiry)"
)));
}
let session = Value::Table(session.clone());
let bounds = crate::bounded::Bounds::new(true);
let path = crate::bounded::TablePath::default();
let mut json = serde_json::to_value(crate::bounded::Guarded::new(
&crate::bounded::LuaData::new(&session, &path),
&bounds,
))
.map_err(|err| {
mlua::Error::RuntimeError(format!(
"session values must be JSON-serializable (strings, numbers, booleans, tables): {err}"
))
})?;
if let (Some(max_age), serde_json::Value::Object(map)) = (max_age, &mut json)
&& max_age > 0
&& !map.is_empty()
{
map.insert(
EXPIRES_KEY.into(),
serde_json::Value::from(now.saturating_add(max_age)),
);
}
let json = json.to_string();
if json.len() > MAX_SESSION_JSON {
return Err(mlua::Error::RuntimeError(format!(
"the session is {} bytes serialized; the whole session travels in a signed \
cookie, which bounds it to {MAX_SESSION_JSON} bytes — store a key here and \
the data in the database",
json.len()
)));
}
Ok(json)
}
pub(crate) fn signed_value(
data: &Table,
name: &str,
secret: &str,
max_age: Option<i64>,
) -> mlua::Result<String> {
check_secret(secret)?;
let json = serialize(data, max_age, unix_now())?;
Ok(http::sign(name, &json, secret))
}
fn check_secret(secret: &str) -> mlua::Result<()> {
if secret.len() < 16 {
return Err(mlua::Error::RuntimeError(
"nitr.session `secret` must be at least 16 bytes".into(),
));
}
Ok(())
}
pub(crate) fn create_session_fn(lua: &Lua) -> mlua::Result<mlua::Function> {
lua.create_function(|lua, (req, opts): (Value, Table)| {
let secret: String = opts.get::<Option<String>>("secret")?.ok_or_else(|| {
mlua::Error::RuntimeError("nitr.session requires a `secret` option".into())
})?;
check_secret(&secret)?;
let name = opts
.get::<Option<String>>("name")?
.unwrap_or_else(|| "session".into());
let max_age: Option<i64> = opts.get("max_age")?;
let base_opts: Option<Table> = opts.get("cookie")?;
let session = lua.create_table()?;
if let Value::UserData(ud) = &req
&& let Ok(cookies) = ud.get::<mlua::AnyUserData>("cookies")
&& let Ok(cookies) = cookies.borrow::<http::RequestCookies>()
&& let Some(raw) = cookies.get(&name)
&& let Some(payload) = http::verify(&name, raw, &secret)
{
load_into(lua, &session, &payload, unix_now())?;
}
let methods = lua.create_table()?;
{
let (name, secret) = (name.clone(), secret.clone());
let base_opts = base_opts.clone();
methods.set(
"save",
lua.create_function(move |lua, (session, resp): (Table, Value)| {
let Value::Table(resp) = resp else {
return Err(mlua::Error::RuntimeError(format!(
"session:save(resp) takes the response table, got {}",
resp.type_name()
)));
};
let json = serialize(&session, max_age, unix_now())?;
let empty = json == "{}" || json == "[]";
let cookie = if empty {
http::build_cookie(
lua,
&name,
"",
Some(&cookie_opts(lua, base_opts.as_ref(), Some(0))?),
)?
} else {
http::build_cookie(
lua,
&name,
&http::sign(&name, &json, &secret),
Some(&cookie_opts(lua, base_opts.as_ref(), max_age)?),
)?
};
http::attach_cookie(&resp, cookie)
})?,
)?;
}
methods.set(
"clear",
lua.create_function(|_, session: Table| {
let keys: Vec<Value> = session
.pairs::<Value, Value>()
.map(|pair| pair.map(|(k, _)| k))
.collect::<mlua::Result<_>>()?;
for key in keys {
session.set(key, Value::Nil)?;
}
Ok(())
})?,
)?;
let meta = lua.create_table()?;
meta.set("__index", methods)?;
session.set_metatable(Some(meta))?;
Ok(session)
})
}
#[cfg(test)]
mod tests {
use super::*;
fn make_session(lua: &Lua, opts: &str) -> Table {
let session_fn = create_session_fn(lua).expect("fn");
let opts: Table = lua.load(opts).eval().expect("opts");
session_fn.call((Value::Nil, opts)).expect("session")
}
#[test]
fn save_rejects_a_session_nested_beyond_the_json_depth_bound() {
let lua = Lua::new();
let session = make_session(&lua, r#"{ secret = "0123456789abcdef" }"#);
let mut cur = lua.create_table().expect("table");
session.set("deep", cur.clone()).expect("set");
for _ in 0..128 {
let next = lua.create_table().expect("table");
cur.set("x", next.clone()).expect("set");
cur = next;
}
let save: mlua::Function = session.get("save").expect("method");
let resp = lua.create_table().expect("resp");
let err = save.call::<Value>((session, resp)).expect_err("too deep");
assert!(
err.to_string().contains("nested deeper than 128 levels"),
"got: {err}"
);
}
#[test]
fn save_rejects_a_session_mixing_list_items_and_named_keys() {
let lua = Lua::new();
let session = make_session(&lua, r#"{ secret = "0123456789abcdef" }"#);
session.set("user", "ann").expect("set");
session.set(1, "positional").expect("set");
let save: mlua::Function = session.get("save").expect("method");
let resp = lua.create_table().expect("resp");
let err = save.call::<Value>((session, resp)).expect_err("mixed");
assert!(
err.to_string().contains("mixes list items and named keys"),
"got: {err}"
);
}
#[test]
fn save_rejects_reserved_names_oversize_and_unserializable_values() {
let lua = Lua::new();
let session = make_session(&lua, r#"{ secret = "0123456789abcdef" }"#);
let resp = lua.create_table().expect("resp");
let save: mlua::Function = session.get("save").expect("method");
session.set("save2", "ok").expect("set");
session.raw_set("clear", "shadowed").expect("set");
let err = save
.call::<()>((&session, &resp))
.expect_err("reserved name");
assert!(err.to_string().contains("reserved"), "got: {err}");
session.raw_set("clear", Value::Nil).expect("unset");
let f = lua.create_function(|_, ()| Ok(())).expect("fn");
session.set("cb", f).expect("set");
let err = save.call::<()>((&session, &resp)).expect_err("function");
assert!(err.to_string().contains("JSON-serializable"), "got: {err}");
session.set("cb", Value::Nil).expect("unset");
session
.set("blob", "x".repeat(MAX_SESSION_JSON))
.expect("set");
let err = save.call::<()>((&session, &resp)).expect_err("oversize");
assert!(err.to_string().contains("bytes"), "got: {err}");
let err = save
.call::<()>((&session, "not a response"))
.expect_err("bad resp");
assert!(err.to_string().contains("response table"), "got: {err}");
}
#[test]
fn sessions_stay_http_only_and_empty_sessions_expire_the_cookie() {
let lua = Lua::new();
let session = make_session(
&lua,
r#"{ secret = "0123456789abcdef", cookie = { http_only = false, secure = true } }"#,
);
session.set("user", "ada").expect("set");
let resp = lua.create_table().expect("resp");
let save: mlua::Function = session.get("save").expect("method");
save.call::<()>((&session, &resp)).expect("save");
let cookies: mlua::AnyUserData = resp.get("cookies").expect("builder");
let values = cookies.borrow::<http::ResponseCookies>().expect("borrow");
let cookie = &values.values()[0];
assert!(cookie.contains("HttpOnly"), "got: {cookie}");
assert!(cookie.contains("Secure"), "got: {cookie}");
let clear: mlua::Function = session.get("clear").expect("method");
clear.call::<()>(&session).expect("clear");
let resp = lua.create_table().expect("resp");
save.call::<()>((&session, &resp)).expect("save");
let cookies: mlua::AnyUserData = resp.get("cookies").expect("builder");
let values = cookies.borrow::<http::ResponseCookies>().expect("borrow");
let cookie = &values.values()[0];
assert!(cookie.contains("Max-Age=0"), "got: {cookie}");
}
#[test]
fn a_short_secret_is_refused() {
let lua = Lua::new();
let session_fn = create_session_fn(&lua).expect("fn");
for opts in ["{}", r#"{ secret = "short" }"#] {
let opts: Table = lua.load(opts).eval().expect("opts");
let err = session_fn
.call::<Table>((Value::Nil, opts))
.expect_err("weak secret");
assert!(err.to_string().contains("secret"), "got: {err}");
}
}
#[test]
fn corrupt_payloads_start_an_empty_session_instead_of_failing() {
let lua = Lua::new();
let session = lua.create_table().expect("table");
load_into(&lua, &session, "not json at all", 0).expect("load");
load_into(&lua, &session, "[1,2,3]", 0).expect("load");
assert_eq!(session.len().expect("len"), 0);
}
#[test]
fn sessions_expire_server_side_when_max_age_is_set() {
let lua = Lua::new();
let session = lua.create_table().expect("table");
session.set("user", "ada").expect("set");
let json = serialize(&session, Some(3600), 1_000_000).expect("serialize");
assert!(json.contains("\"_exp\":1003600"), "got: {json}");
let fresh = lua.create_table().expect("table");
load_into(&lua, &fresh, &json, 1_003_599).expect("load");
assert_eq!(fresh.get::<String>("user").expect("user"), "ada");
assert!(fresh.get::<Value>("_exp").expect("get").is_nil());
let stale = lua.create_table().expect("table");
load_into(&lua, &stale, &json, 1_003_600).expect("load");
assert_eq!(stale.len().expect("len"), 0);
let forever = serialize(&session, None, 1_000_000).expect("serialize");
assert!(!forever.contains("_exp"), "got: {forever}");
let empty = lua.create_table().expect("table");
assert_eq!(serialize(&empty, Some(3600), 0).expect("serialize"), "{}");
session.set("_exp", 1).expect("set");
let err = serialize(&session, None, 0).expect_err("reserved");
assert!(err.to_string().contains("reserved"), "got: {err}");
}
}