dymokomi/luce-crypto
Source of release 0.6.1
0.6.1 / tests / keyed_failures / main.lucb
## Single-process allocation interception. No workers while memory.heap is replaced.
import crypto
import native
import interop
import memory
struct Block:
var address: u8*?
var size: usize
struct Heap: memory.Allocator:
var parent: memory.Allocator
var blocks: Block[32]
var attempts: usize
var fail_at: usize
var persistent: bool
var refused: usize
var live: usize
var erased: usize
var erased_matrices: usize
func arm(index: usize, persistent: bool = false):
self.attempts = 0
self.refused = 0
self.fail_at = index
self.persistent = persistent
pub func allocate(size: usize, alignment: usize) -> u8[]?:
self.attempts += 1
if self.fail_at > 0 and (self.attempts == self.fail_at or (self.persistent and self.attempts >= self.fail_at)):
self.refused += 1
return none
let block = self.parent.allocate(size, alignment) else trap("upstream allocation failure")
assert(block.length == size and size > 0)
for other in self.blocks: assert(other.address != block.data)
for i in 0..<self.blocks.length:
if self.blocks[i].address == none:
self.blocks[i] = Block(address = block.data, size = size)
self.live += 1
return block
trap("allocation ledger exhausted")
pub func resize(block: u8[], size: usize) -> bool:
_ = block
_ = size
trap("unexpected resize")
pub func release(block: u8[]):
for i in 0..<self.blocks.length:
if self.blocks[i].address == block.data:
assert(self.blocks[i].size == block.length and self.live > 0)
## All secret byte allocations in this harness are exactly 73.
## Ownership headers/context allocations have other sizes.
if block.length == 73:
for byte in block: assert(byte == 0, "owned secret allocation not erased")
self.erased += 1
if block.length == 32768:
for byte in block: assert(byte == 0, "Argon2 matrix not erased")
self.erased_matrices += 1
self.blocks[i] = Block()
self.live -= 1
self.parent.release(block)
return
trap("duplicate or foreign free")
func clean():
assert(self.live == 0)
for block in self.blocks: assert(block.address == none)
func restore(original: memory.Allocator):
memory.heap = original
func create(kind: usize, key: interop.Reference[crypto.Secret], input: const u8[]) -> interop.Reference[crypto.Secret]!:
if kind == 0: return try crypto.secret_from_bytes(input)
if kind == 1: return try crypto.random_secret(73)
if kind == 2: return try crypto.hkdf(key, b"salt", b"info", 73)
var configuration = try crypto.Argon2id(32, 2, 4, 73, 1)
defer configuration.close()
return try configuration.derive(key, b"somesalt")
func creation(heap: Heap*, kind: usize, key: interop.Reference[crypto.Secret], input: const u8[], at: usize, persistent: bool) -> usize!:
heap.arm(at, persistent)
let result: interop.Reference[crypto.Secret]? = create(kind, key, input) catch failure:
assert(at > 0 and failure.code == memory.exhausted)
recover none
let attempts = heap.attempts
heap.arm(0)
if let owner = result:
assert(at == 0 and (try owner.value().length()) == 73)
owner.close()
owner.close()
owner.release()
else: assert(at > 0)
heap.clean()
return attempts
pub func main(arguments: str[]) -> i32!:
_ = arguments
var input: u8[73]
for i in 0..<input.length: input[i] = (u8)i
let key = try crypto.secret_from_bytes(input)
defer key.release()
let expected = try crypto.authenticate(key, b"input")
defer expected.release()
let original = memory.heap
var heap = Heap(parent = original)
memory.heap = &heap
defer restore(original)
var cases: usize
for kind in 0..<(usize)4:
let allocations = try creation(&heap, kind, key, input, 0, false)
assert(allocations == (4 if kind == 3 else 3))
for persistent in [false, true]:
for at in 1..<allocations + 1:
assert((try creation(&heap, kind, key, input, at, persistent)) == at)
cases += 1
assert(heap.erased == 22 and heap.erased_matrices == 5)
for persistent in [false, true]:
heap.arm(1, persistent)
var refused = false
_ = native.make_hmac(input) catch failure:
assert(failure.code == memory.exhausted)
refused = true
recover native.Hmac()
assert(refused and heap.attempts == 1 and heap.refused == 1)
heap.arm(0)
heap.clean()
cases += 1
for at in [(usize)1, 2]:
var state = try crypto.Hmac(key)
try state.update(b"input")
assert(heap.live == 1)
heap.arm(at, persistent)
let failed: interop.Reference[crypto.Digest]? = state.finish() catch failure:
assert(failure.code == memory.exhausted)
recover none
assert(failed == none and heap.refused == 1 and heap.attempts == at and heap.live == 1)
heap.arm(0)
let result = try state.finish()
assert((try result.value().hexdigest()) == (try expected.value().hexdigest()))
result.release()
state.close()
heap.clean()
cases += 1
heap.arm(0)
var rejected = false
_ = native.make_hmac(input, "unknown") catch failure:
assert(failure.code == native.invalid)
rejected = true
recover native.Hmac()
assert(rejected and heap.attempts == 1)
heap.clean()
heap.arm(0)
for length in [(i64)-1, 65537]:
let invalid_random: interop.Reference[crypto.Secret]? = crypto.random_secret(length) catch failure:
assert(failure.code == native.invalid)
recover none
assert(invalid_random == none and heap.attempts == 0)
for length in [(i64)-1, 8161]:
let invalid_kdf: interop.Reference[crypto.Secret]? = crypto.hkdf(key, b"", b"", length) catch failure:
assert(failure.code == native.invalid)
recover none
assert(invalid_kdf == none and heap.attempts == 0)
for bad in 0..<10:
heap.arm(0)
let invalid_argon: crypto.Argon2id? = crypto.Argon2id(
-1 if bad == 0 else (262145 if bad == 1 else (0x100000000 if bad == 2 else 32)),
-1 if bad == 3 else (0 if bad == 4 else 2),
-1 if bad == 5 else (65 if bad == 6 else 4),
-1 if bad == 7 else (65537 if bad == 8 else 32),
0 if bad == 9 else 1) catch failure:
assert(failure.code == native.invalid)
recover none
assert(invalid_argon == none and heap.attempts == 0)
var configuration = try crypto.Argon2id(32, 2, 4)
heap.arm(0)
let invalid_salt: interop.Reference[crypto.Secret]? = configuration.derive(key, b"short") catch failure:
assert(failure.code == native.invalid)
recover none
assert(invalid_salt == none and heap.attempts == 0)
configuration.close()
configuration.close()
let closed_configuration: interop.Reference[crypto.Secret]? = configuration.derive(key, b"somesalt") catch failure:
assert(failure.code == native.closed)
recover none
assert(closed_configuration == none and heap.attempts == 0)
## The input owner is closed but alive: high-level APIs must return errors,
## not trap through Reference.value().
key.close()
rejected = false
let closed_hmac: crypto.Hmac? = crypto.Hmac(key) catch failure:
assert(failure.code == interop.invalid)
rejected = true
recover none
assert(rejected and closed_hmac == none)
rejected = false
let closed_result: interop.Reference[crypto.Secret]? = crypto.hkdf(key, b"", b"", 73) catch failure:
assert(failure.code == interop.invalid)
rejected = true
recover none
assert(rejected and closed_result == none)
configuration = try crypto.Argon2id(32, 2, 4)
let closed_argon: interop.Reference[crypto.Secret]? = configuration.derive(key, b"somesalt") catch failure:
assert(failure.code == interop.invalid)
recover none
assert(closed_argon == none)
configuration.close()
heap.clean()
print(f"PASS {cases} keyed allocation-failure paths, wipe-before-free, result-allocation retry and closed references")
return 0