dymokomi/luce-auth
Source of release 0.6.1
## Users, one-use invitations and session tokens on a Prism store.
import interop
import memory
from luce_prism import prism
from luce_crypto import native as crypto_native
import time
import password as passwords
pub let invalid = prism.invalid
pub let missing = prism.missing
pub let conflict = prism.conflict
pub let closed = prism.closed
pub let busy = passwords.busy
## Ten years: a session lasts until it is revoked, as gh and the AWS CLI keep theirs.
pub let session_lifetime_seconds: i64 = 315360000
pub let credential_lifetime_min_seconds: i64 = 60
pub let credential_lifetime_max_seconds: i64 = 7776000
pub let scope_git_read = "git:read"
pub let scope_git_write = "git:write"
pub let scope_package_read = "package:read"
pub let scope_package_publish = "package:publish"
func valid_token(token: str) -> bool:
if token.length != 32: return false
for byte in token.bytes:
if not ((byte >= '0' and byte <= '9') or (byte >= 'a' and byte <= 'f')): return false
return true
func valid_credential_token(token: str) -> bool:
if token.length != 64: return false
for byte in token.bytes:
if not ((byte >= '0' and byte <= '9') or (byte >= 'a' and byte <= 'f')): return false
return true
func valid_scope(scope: str) -> bool:
return scope == scope_git_read or scope == scope_git_write or scope == scope_package_read or scope == scope_package_publish
func scope_allows(granted: str, required: str) -> bool:
if granted == required: return true
if granted == scope_git_write and required == scope_git_read: return true
if granted == scope_package_publish and required == scope_package_read: return true
return false
func valid_repository(name: str) -> bool:
if name.length == 0 or name.length > 64: return false
for i in 0..<name.length:
let byte = name.bytes[i]
let alnum = (byte >= 'a' and byte <= 'z') or (byte >= '0' and byte <= '9')
if not alnum and (i == 0 or (byte != '_' and byte != '-')): return false
return true
## Absolute session lifetime. Backward clock movement before issue fails closed.
pub func session_window_valid(issued: i64, expires: i64, now: i64) -> bool:
if issued <= 0 or issued > 9223372036539415807: return false
if expires != issued + session_lifetime_seconds: return false
return now >= issued and now < expires
## Scoped credentials have caller-selected, bounded absolute lifetimes.
pub func credential_window_valid(issued: i64, expires: i64, now: i64) -> bool:
if issued <= 0 or expires <= issued: return false
let lifetime = expires - issued
if lifetime < credential_lifetime_min_seconds or lifetime > credential_lifetime_max_seconds: return false
return now >= issued and now < expires
func hex_digit(n: u8) -> u8:
if n < 10:
return 48 + n
return 87 + n
func hex_encode(bytes: const u8[], out: u8[]) -> usize:
var i: usize = 0
while i < bytes.length:
out[i * 2] = hex_digit(bytes[i] >> 4)
out[i * 2 + 1] = hex_digit(bytes[i] & 15)
i += 1
return bytes.length * 2
func valid_name(name: str) -> bool:
if name.length == 0 or name.length > 32:
return false
for byte in name.bytes:
let ok = (byte >= 'a' and byte <= 'z') or (byte >= '0' and byte <= '9') or byte == '_'
if not ok:
return false
return true
func random_bytes(count: usize, out: u8[]) -> !:
var secret = try crypto_native.random_secret(count)
defer secret.close()
let bytes = try secret.bytes()
var i: usize = 0
while i < count:
out[i] = bytes[i]
i += 1
func user_path(name: str, out: u8[]) -> usize!:
let prefix = b"/users/"
if prefix.length + name.length > out.length:
error(invalid, "auth path is too long")
var i: usize = 0
while i < prefix.length:
out[i] = prefix[i]
i += 1
var j: usize = 0
while j < name.length:
out[i] = name.bytes[j]
i += 1
j += 1
return i
func join_prefix(prefix: const u8[], name: str, out: u8[]) -> usize!:
if prefix.length + name.length > out.length:
error(invalid, "auth path is too long")
var i: usize = 0
while i < prefix.length:
out[i] = prefix[i]
i += 1
var j: usize = 0
while j < name.length:
out[i] = name.bytes[j]
i += 1
j += 1
return i
## Session secrets are never storage keys. Persist only SHA-256 of the exact
## bearer text so a database/path disclosure does not reveal a usable token.
func session_path(token: str, out: u8[]) -> usize!:
if not valid_token(token): error(invalid, "invalid session token")
var digest: u8[32]
_ = try crypto_native.digest(token.bytes, digest)
var encoded: u8[64]
_ = hex_encode(digest, encoded)
return try join_prefix(b"/sessions/", (str)encoded, out)
## Scoped credential secrets are also represented only by a SHA-256 storage key.
func credential_path(token: str, out: u8[]) -> usize!:
if not valid_credential_token(token): error(invalid, "invalid credential token")
var digest: u8[32]
_ = try crypto_native.digest(token.bytes, digest)
var encoded: u8[64]
_ = hex_encode(digest, encoded)
return try join_prefix(b"/credentials/", (str)encoded, out)
pub struct Authority:
var store: interop.Reference[prism.Store]
var borrowed: prism.Store*?
var owns: bool
var alive: bool
var test_only: bool
pub func init():
return
pub static func open(path: str, token: str, test_only: bool = false) -> interop.Reference[Authority]!:
if token.length == 0:
error(invalid, "auth store token is required")
let store = try prism.Store.open(path, token = token)
let native = new Authority() in memory.heap catch failure:
store.release()
error(failure.code, failure.message)
native.store = store
native.borrowed = none
native.owns = true
native.alive = true
native.test_only = test_only
native.ensure_dirs() catch failure:
native.close()
free(native) in memory.heap
error(failure.code, failure.message)
# adopt consumes/disposes native even when its allocation fails.
return try interop.Reference[Authority].adopt(native, authority_type, memory.heap)
pub static func attach(store: prism.Store*, test_only: bool = false) -> interop.Reference[Authority]!:
let native = try new Authority() in memory.heap
native.borrowed = store
native.owns = false
native.alive = true
native.test_only = test_only
native.ensure_dirs() catch failure:
native.close()
free(native) in memory.heap
error(failure.code, failure.message)
return try interop.Reference[Authority].adopt(native, authority_type, memory.heap)
func engine() -> prism.Store*!:
if not self.alive:
error(closed, "authority is closed")
if self.owns:
return self.store.value()
return self.borrowed else error(closed, "authority is closed")
func ensure_dirs() -> !:
let store = try self.engine()
let tx = try store.begin()
defer tx.release()
var changed = false
for path in ["/users", "/invites", "/sessions", "/credentials"]:
if not try tx.value().contains(path):
try tx.value().add(path, "directory")
changed = true
if not changed: return
_ = try tx.value().commit()
_ = try store.bake()
pub func bootstrap(name: str, password: str) -> !:
if not valid_name(name) or password.length == 0:
error(invalid, "invalid user or password")
try self.put_user(name, password, first_user = true)
pub func invite() -> interop.Reference[prism.Value]!:
var raw: u8[16]
try random_bytes(16, raw)
var code: u8[32]
_ = hex_encode(raw, code)
let text = (str)code
var path_buf: u8[48]
let n = try join_prefix(b"/invites/", text, path_buf)
let path = (str)path_buf[..<n]
let store = try self.engine()
let tx = try store.begin()
defer tx.release()
try tx.value().add(path, "file")
let flag = try prism.Value.text("open")
defer flag.release()
try tx.value().set(path, "state", flag)
_ = try tx.value().commit()
_ = try store.bake()
return try prism.Value.text(text)
pub func accept(code: str, name: str, password: str) -> !:
if code.length == 0 or not valid_name(name) or password.length == 0:
error(invalid, "invalid invitation, user or password")
var path_buf: u8[48]
let n = try join_prefix(b"/invites/", code, path_buf)
let invite = (str)path_buf[..<n]
try self.put_user(name, password, invite)
func put_user(name: str, password: str, invitation: str = "", first_user: bool = false) -> !:
var path_buf: u8[48]
let n = try user_path(name, path_buf)
let path = (str)path_buf[..<n]
var record: u8[64]
defer crypto_native.wipe(record)
try passwords.create(password.bytes, record, passwords.Profile.test_only if self.test_only else passwords.Profile.interactive)
let store = try self.engine()
let tx = try store.begin()
defer tx.release()
if first_user:
let kids = try tx.value().children("/users")
defer kids.release()
if kids.value().count() != 0:
error(conflict, "authority already has users")
# Prism detects write overlap, not read predicates. Competing first
# users must both write this same field to force a commit conflict.
let marker = try prism.Value.text(name)
defer marker.release()
try tx.value().set("/users", "bootstrap_owner", marker)
if try tx.value().contains(path):
error(conflict, "user already exists")
if invitation.length > 0:
let state = tx.value().get(invitation, "state") catch failure:
error(invalid, "invitation is not valid")
defer state.release()
if try state.value().text_at() != "open":
error(invalid, "invitation is not valid")
try tx.value().remove(invitation)
try tx.value().add(path, "file")
let verifier = try prism.Value.array(prism.DType.uint8, [64], record)
defer verifier.release()
try tx.value().set(path, "password_record", verifier)
_ = try tx.value().commit(wait_ms = 1000)
_ = try store.bake(wait_ms = 1000)
pub func login(name: str, password: str) -> interop.Reference[prism.Value]!:
if not valid_name(name) or password.length == 0 or password.length > 1024:
error(invalid, "invalid user or password")
var path_buf: u8[48]
let n = try user_path(name, path_buf)
let path = (str)path_buf[..<n]
let store = try self.engine()
let snap = try store.snapshot()
defer snap.release()
let verifier = snap.value().get(path, "password_record") catch failure:
error(invalid, "invalid user or password")
defer verifier.release()
let accepted = passwords.verify(password.bytes, verifier.value().bytes(), allow_test = self.test_only) catch failure:
if failure.code == busy: error(busy, "password hashing capacity exhausted")
error(invalid, "invalid user or password")
if not accepted:
error(invalid, "invalid user or password")
let issued = time.unix()
if issued <= 0 or issued > 9223372036854689407:
error(invalid, "session clock is unavailable")
var raw: u8[16]
defer crypto_native.wipe(raw)
try random_bytes(16, raw)
var token: u8[32]
defer crypto_native.wipe(token)
_ = hex_encode(raw, token)
let text = (str)token
var session_buffer: u8[80]
let sn = try session_path(text, session_buffer)
let spath = (str)session_buffer[..<sn]
let tx = try store.begin()
defer tx.release()
try tx.value().add(spath, "file")
let who = try prism.Value.text(name)
defer who.release()
try tx.value().set(spath, "name", who)
let created = try prism.Value.integer(issued)
defer created.release()
let expires = try prism.Value.integer(issued + session_lifetime_seconds)
defer expires.release()
try tx.value().set(spath, "issued_at", created)
try tx.value().set(spath, "expires_at", expires)
_ = try tx.value().commit()
_ = try store.bake()
return try prism.Value.text(text)
pub func verify(token: str) -> interop.Reference[prism.Value]!:
if not valid_token(token): error(invalid, "invalid session token")
let store = try self.engine()
let snap = try store.snapshot()
defer snap.release()
return try self.session_principal(snap.value(), token)
## Mint a repository-bound credential from a live interactive session.
## The returned 256-bit secret is shown once and is never stored verbatim.
pub func issue_credential(token: str, scope: str, repository: str, lifetime_seconds: i64) -> interop.Reference[prism.Value]!:
if not valid_token(token): error(invalid, "invalid session token")
if not valid_scope(scope) or not valid_repository(repository): error(invalid, "invalid credential scope")
if lifetime_seconds < credential_lifetime_min_seconds or lifetime_seconds > credential_lifetime_max_seconds:
error(invalid, "invalid credential lifetime")
let issued = time.unix()
if issued <= 0 or issued > 9223372036854775807 - lifetime_seconds:
error(invalid, "credential clock is unavailable")
let store = try self.engine()
let tx = try store.begin()
defer tx.release()
let who = try self.enrollment_session(tx.value(), token)
defer who.release()
var raw: u8[32]
defer crypto_native.wipe(raw)
try random_bytes(32, raw)
var encoded: u8[64]
defer crypto_native.wipe(encoded)
_ = hex_encode(raw, encoded)
let text = (str)encoded
var path_buffer: u8[96]
let size = try credential_path(text, path_buffer)
let path = (str)path_buffer[..<size]
try tx.value().add(path, "file")
try tx.value().set(path, "name", who)
let scope_value = try prism.Value.text(scope)
defer scope_value.release()
try tx.value().set(path, "scope", scope_value)
let repository_value = try prism.Value.text(repository)
defer repository_value.release()
try tx.value().set(path, "repository", repository_value)
let created = try prism.Value.integer(issued)
defer created.release()
try tx.value().set(path, "issued_at", created)
let expiry = try prism.Value.integer(issued + lifetime_seconds)
defer expiry.release()
try tx.value().set(path, "expires_at", expiry)
_ = try tx.value().commit(wait_ms = 1000)
_ = try store.bake(wait_ms = 1000)
return try prism.Value.text(text)
## Authorize one exact owner/repository/operation from a single snapshot.
pub func authorize_credential(token: str, required_scope: str, owner: str, repository: str) -> interop.Reference[prism.Value]!:
if not valid_credential_token(token) or not valid_scope(required_scope): error(invalid, "invalid credential")
if not valid_name(owner) or not valid_repository(repository): error(invalid, "invalid credential target")
var path_buffer: u8[96]
let size = try credential_path(token, path_buffer)
let path = (str)path_buffer[..<size]
let store = try self.engine()
let snap = try store.snapshot()
defer snap.release()
let who = try snap.value().get(path, "name")
errdefer who.release()
let granted = try snap.value().get(path, "scope")
defer granted.release()
let target = try snap.value().get(path, "repository")
defer target.release()
let issued = try snap.value().get(path, "issued_at")
defer issued.release()
let expires = try snap.value().get(path, "expires_at")
defer expires.release()
let principal = try who.value().text_at()
if not valid_name(principal) or principal != owner: error(invalid, "credential owner mismatch")
if try target.value().text_at() != repository: error(invalid, "credential repository mismatch")
if not scope_allows(try granted.value().text_at(), required_scope): error(invalid, "credential scope denied")
if issued.value().count() != 1 or expires.value().count() != 1: error(invalid, "invalid credential lifetime")
let created = issued.value().integer_at() catch: error(invalid, "invalid credential lifetime")
let deadline = expires.value().integer_at() catch: error(invalid, "invalid credential lifetime")
if not credential_window_valid(created, deadline, time.unix()): error(invalid, "expired credential")
var user_buffer: u8[48]
let user_size = try user_path(principal, user_buffer)
let verifier = snap.value().get((str)user_buffer[..<user_size], "password_record") catch:
error(invalid, "credential account is unavailable")
defer verifier.release()
_ = passwords.profile_of(verifier.value().bytes(), allow_test = self.test_only) catch:
error(invalid, "credential account profile is disallowed")
return who
## Revoke one credential owned by the authenticated session principal.
pub func revoke_credential(token: str, credential: str) -> !:
if not valid_token(token) or not valid_credential_token(credential): error(invalid, "invalid credential revocation")
var path_buffer: u8[96]
let size = try credential_path(credential, path_buffer)
let path = (str)path_buffer[..<size]
let store = try self.engine()
let tx = try store.begin()
defer tx.release()
let who = try self.enrollment_session(tx.value(), token)
defer who.release()
let stored = try tx.value().get(path, "name")
defer stored.release()
if try stored.value().text_at() != try who.value().text_at(): error(invalid, "credential owner mismatch")
try tx.value().remove(path)
_ = try tx.value().commit(wait_ms = 1000)
_ = try store.bake(wait_ms = 1000)
func session_principal(snap: prism.Session*, token: str) -> interop.Reference[prism.Value]!:
if not valid_token(token):
error(invalid, "invalid session token")
var session_buffer: u8[80]
let n = try session_path(token, session_buffer)
let path = (str)session_buffer[..<n]
let who = try snap.get(path, "name")
errdefer who.release()
let issued = snap.get(path, "issued_at") catch:
error(invalid, "session lifetime is unavailable")
defer issued.release()
let expires = snap.get(path, "expires_at") catch:
error(invalid, "session lifetime is unavailable")
defer expires.release()
if issued.value().count() != 1 or expires.value().count() != 1:
error(invalid, "invalid session lifetime")
let created = issued.value().integer_at() catch: error(invalid, "invalid session lifetime")
let deadline = expires.value().integer_at() catch: error(invalid, "invalid session lifetime")
if not session_window_valid(created, deadline, time.unix()):
error(invalid, "expired or invalid session lifetime")
let name = try who.value().text_at()
if not valid_name(name): error(invalid, "invalid session principal")
var user_buffer: u8[48]
let user_size = try user_path(name, user_buffer)
let verifier = snap.get((str)user_buffer[..<user_size], "password_record") catch:
error(invalid, "session password profile is unavailable")
defer verifier.release()
_ = passwords.profile_of(verifier.value().bytes(), allow_test = self.test_only) catch:
error(invalid, "session password profile is disallowed")
return who
func enrollment_session(tx: prism.Session*, token: str) -> interop.Reference[prism.Value]!:
let who = try self.session_principal(tx, token)
errdefer who.release()
var buffer: u8[80]
let size = try session_path(token, buffer)
# Same-field write guards the authenticated read against concurrent revoke.
try tx.set((str)buffer[..<size], "name", who)
return who
static func require_unbound(tx: prism.Session*, path: str) -> !:
let existing: interop.Reference[prism.Value]? = tx.get(path, "signing_key") catch failure:
if failure.code != missing: error(failure.code, failure.message)
recover none
if let key = existing:
key.release()
error(conflict, "account already has a signing key")
pub func revoke(token: str) -> !:
if not valid_token(token):
error(invalid, "invalid session token")
var session_buffer: u8[80]
let n = try session_path(token, session_buffer)
let path = (str)session_buffer[..<n]
let store = try self.engine()
let tx = try store.begin()
defer tx.release()
try tx.value().remove(path)
_ = try tx.value().commit()
_ = try store.bake()
pub func close():
if not self.alive:
return
self.alive = false
if self.owns:
self.store.release()
self.borrowed = none
pub let authority_type = interop.Type[Authority]("Prism authority", Authority.close, closeable = true)