dymokomi/luce-auth
Source of release 0.6.1
from luce_auth import auth
from luce_prism import prism
import interop
from luce_crypto import native as crypto
func stored_session(token: str, output: u8[]) -> str!:
var digest: u8[32]
_ = try crypto.digest(token.bytes, digest)
let digits = b"0123456789abcdef"
for i in 0..<(usize)10: output[i] = b"/sessions/"[i]
for i in 0..<(usize)32:
output[10 + i * 2] = digits[(usize)(digest[i] >> 4)]
output[11 + i * 2] = digits[(usize)(digest[i] & 15)]
return (str)output[..<74]
func denied(authority: auth.Authority*, token: str):
var rejected = false
let who: interop.Reference[prism.Value]? = authority.verify(token) catch failure:
assert(failure.code == auth.invalid)
rejected = true
recover none
if let value = who: value.release()
assert(rejected)
func create(path: str) -> interop.Reference[prism.Value]!:
let authority = try auth.Authority.open(path, "session-fixture", test_only = true)
defer authority.release()
try authority.value().bootstrap("alice", "fixture password")
return try authority.value().login("alice", "fixture password")
func expire(path: str, token: str) -> !:
let store = try prism.Store.open(path, token = "session-fixture")
defer store.release()
let authority = try auth.Authority.attach(store.value(), test_only = true)
defer authority.release()
let who = try authority.value().verify(token)
defer who.release()
assert(try who.value().text_at() == "alice")
let before = try store.value().snapshot()
defer before.release()
let revision = try before.value().revision()
for bad in ["", "../users/alice", "../users/alice/", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", "fffffffffffffffffffffffffffffff/", "fffffffffffffffffffffffffffffff", "fffffffffffffffffffffffffffffffff"]:
denied(authority.value(), bad)
var rejected = false
authority.value().revoke(bad) catch failure:
assert(failure.code == auth.invalid)
rejected = true
assert(rejected)
let after = try store.value().snapshot()
defer after.release()
assert(try after.value().revision() == revision)
var buffer: u8[80]
let session = try stored_session(token, buffer)
var raw_buffer: u8[42]
for i in 0..<(usize)10: raw_buffer[i] = b"/sessions/"[i]
for i in 0..<(usize)32: raw_buffer[10 + i] = token.bytes[i]
assert(not try before.value().contains((str)raw_buffer))
assert(try before.value().contains(session))
let bad_tx = try store.value().begin()
defer bad_tx.release()
let malformed = try prism.Value.text("not a timestamp")
defer malformed.release()
try bad_tx.value().set(session, "expires_at", malformed)
_ = try bad_tx.value().commit()
denied(authority.value(), token)
let tx = try store.value().begin()
defer tx.release()
let issued = try prism.Value.integer(1)
defer issued.release()
let deadline = try prism.Value.integer(86401)
defer deadline.release()
try tx.value().set(session, "issued_at", issued)
try tx.value().set(session, "expires_at", deadline)
# Old raw-token storage and a digest-keyed session with only a principal
# must never gain an implicit lifetime.
try tx.value().add("/sessions/ffffffffffffffffffffffffffffffff", "file")
let name = try prism.Value.text("alice")
defer name.release()
try tx.value().set("/sessions/ffffffffffffffffffffffffffffffff", "name", name)
var legacy_buffer: u8[80]
let legacy = try stored_session("ffffffffffffffffffffffffffffffff", legacy_buffer)
try tx.value().add(legacy, "file")
try tx.value().set(legacy, "name", name)
_ = try tx.value().commit()
_ = try store.value().bake()
denied(authority.value(), token)
denied(authority.value(), "ffffffffffffffffffffffffffffffff")
pub func main(arguments: str[]) -> i32!:
assert(arguments.length == 2)
let life = auth.session_lifetime_seconds
assert(life == 315360000)
assert(auth.session_window_valid(100, 100 + life, 100))
assert(auth.session_window_valid(100, 100 + life, 99 + life))
assert(not auth.session_window_valid(100, 100 + life, 100 + life))
assert(not auth.session_window_valid(100, 100 + life, 99))
assert(not auth.session_window_valid(0, life, 1))
assert(not auth.session_window_valid(100, 101 + life, 100))
assert(not auth.session_window_valid(9223372036854775807, 1, 1))
assert(auth.session_window_valid(9223372036539415807, 9223372036854775807, 9223372036539415807))
let token = try create(arguments[1])
defer token.release()
try expire(arguments[1], try token.value().text_at())
let reopened = try auth.Authority.open(arguments[1], "session-fixture", test_only = true)
defer reopened.release()
denied(reopened.value(), try token.value().text_at())
denied(reopened.value(), "ffffffffffffffffffffffffffffffff")
try reopened.value().revoke(try token.value().text_at())
print("PASS session lifetime boundaries, reopen, legacy rejection and malformed-token no-write")
return 0