Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-auth

Source of release 0.6.1

0.6.1 / tests / credentials.lucb

from luce_auth import auth
from luce_crypto import native as crypto
import interop
from luce_prism import prism

func stored_credential(token: str, output: u8[]) -> str!:
    var digest: u8[32]
    _ = try crypto.digest(token.bytes, digest)
    let prefix = b"/credentials/"
    let digits = b"0123456789abcdef"
    for i in 0..<prefix.length: output[i] = prefix[i]
    for i in 0..<(usize)32:
        output[prefix.length + i * 2] = digits[(usize)(digest[i] >> 4)]
        output[prefix.length + i * 2 + 1] = digits[(usize)(digest[i] & 15)]
    return (str)output[..<prefix.length + 64]

func denied(authority: auth.Authority*, token: str, scope: str, owner: str, repository: str):
    var rejected = false
    let result: interop.Reference[prism.Value]? = authority.authorize_credential(token, scope, owner, repository) catch failure:
        assert(failure.code == auth.invalid or failure.code == auth.missing)
        rejected = true
        recover none
    if let value = result: value.release()
    assert(rejected)

pub func main(arguments: str[]) -> i32!:
    assert(arguments.length == 2)
    assert(auth.credential_window_valid(100, 160, 100))
    assert(auth.credential_window_valid(100, 7776100, 7776099))
    assert(not auth.credential_window_valid(100, 159, 100))
    assert(not auth.credential_window_valid(100, 7776101, 100))
    assert(not auth.credential_window_valid(100, 160, 99))
    assert(not auth.credential_window_valid(100, 160, 160))

    let authority = try auth.Authority.open(arguments[1], "credential-fixture", test_only = true)
    try authority.value().bootstrap("alice", "fixture password")
    let session = try authority.value().login("alice", "fixture password")
    let session_text = try session.value().text_at()

    # Invalid requests fail before writes or entropy use.
    var invalid_issue = false
    let bad: interop.Reference[prism.Value]? = authority.value().issue_credential(session_text, "git:admin", "demo", 60) catch failure:
        assert(failure.code == auth.invalid)
        invalid_issue = true
        recover none
    if let value = bad: value.release()
    assert(invalid_issue)

    let git = try authority.value().issue_credential(session_text, auth.scope_git_write, "demo-repo", 3600)
    let package = try authority.value().issue_credential(session_text, auth.scope_package_read, "demo-repo", 3600)
    let git_token = try git.value().text_at()
    let package_token = try package.value().text_at()
    assert(git_token.length == 64 and package_token.length == 64 and git_token != package_token)

    let writer = try authority.value().authorize_credential(git_token, auth.scope_git_write, "alice", "demo-repo")
    defer writer.release()
    assert(try writer.value().text_at() == "alice")
    let reader = try authority.value().authorize_credential(git_token, auth.scope_git_read, "alice", "demo-repo")
    defer reader.release()
    assert(try reader.value().text_at() == "alice")
    denied(authority.value(), git_token, auth.scope_package_read, "alice", "demo-repo")
    denied(authority.value(), git_token, auth.scope_git_read, "alice", "other")
    denied(authority.value(), git_token, auth.scope_git_read, "bob", "demo-repo")
    denied(authority.value(), package_token, auth.scope_package_publish, "alice", "demo-repo")
    denied(authority.value(), "ffffffffffffffffffffffffffffffff", auth.scope_git_read, "alice", "demo-repo")

    authority.release()
    let store = try prism.Store.open(arguments[1], token = "credential-fixture")
    let snapshot = try store.value().snapshot()
    var git_path_buffer: u8[96]
    let git_path = try stored_credential(git_token, git_path_buffer)
    var package_path_buffer: u8[96]
    let package_path = try stored_credential(package_token, package_path_buffer)
    var raw_buffer: u8[96]
    let prefix = b"/credentials/"
    for i in 0..<prefix.length: raw_buffer[i] = prefix[i]
    for i in 0..<git_token.length: raw_buffer[prefix.length + i] = git_token.bytes[i]
    assert(not try snapshot.value().contains((str)raw_buffer[..<prefix.length + git_token.length]))
    assert(try snapshot.value().contains(git_path))
    assert(try snapshot.value().contains(package_path))
    let stored_scope = try snapshot.value().get(git_path, "scope")
    assert(try stored_scope.value().text_at() == auth.scope_git_write)
    stored_scope.release()
    snapshot.release()
    store.release()

    let reopened = try auth.Authority.open(arguments[1], "credential-fixture", test_only = true)
    # Device credentials survive logout independently.
    try reopened.value().revoke(session_text)
    let after_logout = try reopened.value().authorize_credential(git_token, auth.scope_git_read, "alice", "demo-repo")
    after_logout.release()
    var issue_after_logout = false
    let refused: interop.Reference[prism.Value]? = reopened.value().issue_credential(session_text, auth.scope_git_read, "demo-repo", 60) catch:
        issue_after_logout = true
        recover none
    if let value = refused: value.release()
    assert(issue_after_logout)

    let second_session = try reopened.value().login("alice", "fixture password")
    try reopened.value().revoke_credential(try second_session.value().text_at(), git_token)
    denied(reopened.value(), git_token, auth.scope_git_read, "alice", "demo-repo")
    let package_reader = try reopened.value().authorize_credential(package_token, auth.scope_package_read, "alice", "demo-repo")
    package_reader.release()
    reopened.release()

    let mutable = try prism.Store.open(arguments[1], token = "credential-fixture")
    let tx = try mutable.value().begin()
    let issued = try prism.Value.integer(1)
    let expires = try prism.Value.integer(61)
    try tx.value().set(package_path, "issued_at", issued)
    try tx.value().set(package_path, "expires_at", expires)
    issued.release()
    expires.release()
    _ = try tx.value().commit()
    _ = try mutable.value().bake()
    tx.release()
    mutable.release()

    let final_authority = try auth.Authority.open(arguments[1], "credential-fixture", test_only = true)
    denied(final_authority.value(), package_token, auth.scope_package_read, "alice", "demo-repo")
    final_authority.release()
    second_session.release()
    git.release()
    package.release()
    session.release()
    print("PASS scoped credentials: digest storage, scope, target, expiry, logout independence and revocation")
    return 0