Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-auth

Source of release 0.6.1

0.6.1 / tests / password.lucb

from luce_auth import password
from luce_crypto import native as crypto_native
import thread

var gate: password.Admission
var completed: @u32
var admitted: @u32
var rejected: @u32
var finish: @u32

func contender(raw: void*?):
    _ = raw
    let taken = gate.try_acquire()
    if taken: _ = admitted.add(1, .relaxed)
    else: _ = rejected.add(1, .relaxed)
    _ = completed.add(1, .release)
    while finish.load(.acquire) == 0: thread.sleep(1)
    if taken: gate.release()

func admission_test() -> !:
    var workers: thread.Handle[16]
    for i in 0..<(usize)16:
        workers[i] = thread.spawn(contender, none, name = "kdf-admission") catch failure:
            finish.store(1, .release)
            for j in 0..<i: try workers[j].join()
            error(failure.code, failure.message)
    while completed.load(.acquire) != 16: thread.sleep(1)
    assert(admitted.load(.acquire) == 4 and rejected.load(.acquire) == 12)
    assert(not gate.try_acquire())
    finish.store(1, .release)
    for i in 0..<(usize)16: try workers[i].join()
    for i in 0..<(usize)4: assert(gate.try_acquire())
    assert(not gate.try_acquire())
    for i in 0..<(usize)4: gate.release()
    print("PASS bounded KDF admission: four permits, concurrent overload and reuse")

pub func main(arguments: str[]) -> i32!:
    try admission_test()
    var record: u8[64]
    try password.create(b"fixture password", record, password.Profile.test_only)
    assert(try password.verify(b"fixture password", record, true))
    assert(not try password.verify(b"wrong password", record, true))
    var failed = false
    _ = password.verify(b"fixture password", record) catch:
        failed = true
        recover false
    assert(failed)
    var another: u8[64]
    try password.create(b"fixture password", another, password.Profile.test_only)
    assert(not crypto_native.equal(record, another))
    for i in 0..<(usize)16:
        record[i] ^= 128
        failed = false
        _ = password.profile_of(record, true) catch:
            failed = true
            recover password.Profile.interactive
        assert(failed)
        record[i] ^= 128
    for n in 0..<record.length:
        failed = false
        _ = password.profile_of(record[..<n], true) catch:
            failed = true
            recover password.Profile.interactive
        assert(failed)
    for i in 0..<record.length: record[i] = 173
    failed = false
    password.create(b"", record) catch:
        failed = true
    assert(failed)
    for byte in record: assert(byte == 173)
    if arguments.length == 2 and arguments[1] == "production":
        try password.create(b"fixture password", record)
        assert(try password.profile_of(record) == password.Profile.interactive)
        assert(try password.verify(b"fixture password", record))
        assert(not try password.verify(b"wrong password", record))
    print("PASS versioned password records, explicit test opt-in, bounds and atomic failure")
    return 0