Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-crypto

Source of release 0.6.0

0.6.0 / src / crypto.lucb

## Owning Luce hashing/keyed API. Experimental: see the secret-memory limitations.
import interop
import memory
import sha2
import secret
import secure
import hmac as mac
import hkdf as kdf
import argon2id as password_kdf

pub let invalid = sha2.invalid
pub let closed = sha2.closed
pub let length_exceeded = sha2.length_exceeded

pub struct Digest:
    var data: u8[64]
    var text: u8[128]
    var used: usize
    var disposed: bool

    pub func bytes() -> const u8[]!:
        if self.disposed: error(closed, "digest is closed")
        return self.data[..<self.used]

    pub func hexdigest() -> str!:
        if self.disposed: error(closed, "digest is closed")
        return (str)self.text[..<self.used * 2]

    pub func close():
        self = Digest(disposed = true)

pub let digest_type: interop.Type[Digest] = interop.Type[Digest]("Digest", Digest.close, closeable = true)

func snapshot(state: const sha2.Hash*) -> interop.Reference[Digest]!:
    _ = try state.digest_size()
    var reservation = try interop.Reservation[Digest](digest_type)
    errdefer reservation.cancel()
    let result = try new Digest() in memory.heap
    errdefer free(result) in memory.heap
    result.used = try state.digest(result.data)
    let digits = b"0123456789abcdef"
    for i in 0..<result.used:
        result.text[i * 2] = digits[(usize)(result.data[i] >> 4)]
        result.text[i * 2 + 1] = digits[(usize)(result.data[i] & 15)]
    return reservation.publish(result, memory.heap)

pub struct Hasher:
    var state: sha2.Hash

    pub func init(algorithm: str = "sha256") -> !:
        self.state = try sha2.make_hash(algorithm)

    pub func update(input: const u8[]) -> !:
        try self.state.update(input)

    pub func digest() -> interop.Reference[Digest]!:
        return try snapshot(&self.state)

    pub func reset() -> !:
        try self.state.reset()

    pub func close():
        self.state.close()

pub let hasher_type: interop.Type[Hasher] = interop.Type[Hasher]("Hasher", Hasher.close, closeable = true)

pub func digest(input: const u8[], algorithm: str = "sha256") -> interop.Reference[Digest]!:
    var state = try sha2.make_hash(algorithm)
    defer state.close()
    try state.update(input)
    return try snapshot(&state)

## No implicit bytes/hex accessor: reveal explicitly copies into managed memory.
pub struct Secret:
    var buffer: secret.Buffer

    pub func length() -> i64!:
        return (i64)(try self.buffer.bytes()).length

    pub func matches(candidate: const u8[]) -> bool!:
        return secure.equal(try self.buffer.bytes(), candidate)

    pub func reveal() -> const u8[]!:
        return try self.buffer.bytes()

    pub func close():
        self.buffer.close()

pub let secret_type: interop.Type[Secret] = interop.Type[Secret]("Secret", Secret.close, closeable = true)

func owned_secret(buffer: secret.Buffer) -> interop.Reference[Secret]!:
    let result = new Secret(buffer = buffer) in memory.heap catch failure:
        var cleanup = buffer
        cleanup.close()
        error(failure.code, failure.message)
    return try interop.Reference[Secret].adopt(result, secret_type, memory.heap)

pub func secret_from_bytes(input: const u8[]) -> interop.Reference[Secret]!:
    return try owned_secret(try secret.from_bytes(input))

pub func random_secret(length: i64) -> interop.Reference[Secret]!:
    if length < 0 or length > 65536: error(invalid, "secret length must be in 0-65536")
    return try owned_secret(try secret.random((usize)length))

pub struct Hmac:
    var engine: mac.Hmac

    pub func init(key: interop.Reference[Secret], algorithm: str = "sha256") -> !:
        let owner = try key.get()
        self.engine = try mac.make_hmac(try owner.buffer.bytes(), algorithm)

    pub func update(input: const u8[]) -> !:
        try self.engine.update(input)

    pub func finish() -> interop.Reference[Digest]!:
        _ = try self.engine.size()
        var reservation = try interop.Reservation[Digest](digest_type)
        errdefer reservation.cancel()
        let result = try new Digest() in memory.heap
        errdefer free(result) in memory.heap
        result.used = try self.engine.finish(result.data)
        let digits = b"0123456789abcdef"
        for i in 0..<result.used:
            result.text[i * 2] = digits[(usize)(result.data[i] >> 4)]
            result.text[i * 2 + 1] = digits[(usize)(result.data[i] & 15)]
        return reservation.publish(result, memory.heap)

    pub func verify(expected: const u8[]) -> bool!:
        return try self.engine.verify(expected)

    pub func close():
        self.engine.close()

pub let hmac_type: interop.Type[Hmac] = interop.Type[Hmac]("Hmac", Hmac.close, closeable = true)

pub func authenticate(key: interop.Reference[Secret], input: const u8[], algorithm: str = "sha256") -> interop.Reference[Digest]!:
    var context = try Hmac(key, algorithm)
    defer context.close()
    try context.update(input)
    return try context.finish()

pub func hkdf(input: interop.Reference[Secret], salt: const u8[], info: const u8[], length: i64,
    algorithm: str = "sha256") -> interop.Reference[Secret]!:
    var hash_state = try sha2.make_hash(algorithm)
    defer hash_state.close()
    let count = try hash_state.digest_size()
    if length < 0 or length > (i64)(255 * count): error(invalid, "HKDF length must be in 0-255*HashLen")
    let owner = try input.get()
    let source = try owner.buffer.bytes()
    var buffer = try secret.create((usize)length)
    kdf.derive(source, salt, info, try buffer.writable(), algorithm) catch failure:
        buffer.close()
        error(failure.code, failure.message)
    return try owned_secret(buffer)

## Explicit costs, immutable configuration during derive, owning secret result.
## Default admission ceilings are not calibrated vault parameters. One config is
## used by one Luce caller at a time; Base internals own/join their lane workers.
pub struct Argon2id:
    var parameters: password_kdf.Parameters = password_kdf.Parameters()
    var count: usize
    var workers: usize
    var disposed: bool = true

    pub func init(memory_kib: i64, passes: i64, lanes: i64, length: i64 = 32, workers: i64 = 1) -> !:
        if memory_kib < 0 or memory_kib > 0xffffffff or passes < 0 or passes > 0xffffffff or lanes < 0 or lanes > 0xffffffff:
            error(invalid, "Argon2id costs must be nonnegative u32 values")
        if length < 4 or length > 65536 or workers < 1 or workers > 8:
            error(invalid, "Argon2id result/worker bounds")
        let parameters = password_kdf.Parameters(memory_kib = (u32)memory_kib, passes = (u32)passes, lanes = (u32)lanes)
        _ = try password_kdf.validate(parameters, password_kdf.Limits(), 0, 8, 0, 0, (usize)length, (usize)workers)
        self.parameters = parameters
        self.count = (usize)length
        self.workers = (usize)workers
        self.disposed = false

    func run(password: const u8[], salt: const u8[], key: const u8[], associated: const u8[]) -> interop.Reference[Secret]!:
        if self.disposed: error(closed, "Argon2id configuration is closed")
        _ = try password_kdf.validate(self.parameters, password_kdf.Limits(), password.length, salt.length,
            key.length, associated.length, self.count, self.workers)
        var buffer = try secret.create(self.count)
        password_kdf.derive(password, salt, try buffer.writable(), self.parameters, key, associated, self.workers) catch failure:
            buffer.close()
            error(failure.code, failure.message)
        return try owned_secret(buffer)

    pub func derive(password: interop.Reference[Secret], salt: const u8[], associated: const u8[] = b"") -> interop.Reference[Secret]!:
        let owner = try password.get()
        return try self.run(try owner.buffer.bytes(), salt, b"", associated)

    pub func derive_keyed(password: interop.Reference[Secret], key: interop.Reference[Secret], salt: const u8[],
        associated: const u8[] = b"") -> interop.Reference[Secret]!:
        let password_owner = try password.get()
        let key_owner = try key.get()
        return try self.run(try password_owner.buffer.bytes(), salt, try key_owner.buffer.bytes(), associated)

    pub func close():
        self.parameters = password_kdf.Parameters()
        self.count = 0
        self.workers = 0
        self.disposed = true

pub let argon2id_type: interop.Type[Argon2id] = interop.Type[Argon2id]("Argon2id", Argon2id.close, closeable = true)