Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-auth

Source of release 0.6.1

0.6.1 / src / auth.lucb

## 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)