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