Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-crypto

Source of release 0.6.1

0.6.1 / tests / oracles / drivers / blake2b.lucb

## Test-only RFC 7693/H' oracle driver; this module is not a package export.
import blake2b as blake
import sha2 as errors
import secure
from luce_std import files
import memory
import c

struct Reader:
    var data: const u8[]
    var position: usize

    func take(count: usize) -> const u8[]:
        assert(count <= self.data.length - self.position)
        let start = self.position
        self.position += count
        return self.data[start..<self.position]

    func number() -> usize:
        let data = self.take(4)
        var result: u32
        for i in 0..<(usize)4: result |= (u32)data[i] << (i * 8)
        return (usize)result

    func blob() -> const u8[]:
        let count = self.number()
        assert(count <= 65536)
        return self.take(count)

func boundaries() -> !:
    var output: u8[65]
    for bad_size in [(usize)0, 65]:
        var rejected = false
        _ = blake.make_hash(bad_size) catch failure:
            assert(failure.code == errors.invalid)
            rejected = true
            recover blake.Hash()
        assert(rejected)
    var state = try blake.make_hash(64)
    state.low = 0xffffffffffffff80
    state.high = 0xffffffffffffffff
    try state.update(output)
    try state.update(output[..<62])
    assert(state.used == 127)
    let before = state
    var rejected = false
    state.update(output[..<1]) catch failure:
        assert(failure.code == errors.length_exceeded)
        rejected = true
    assert(rejected)
    assert(secure.equal(u8[]((u8*)&state, memory.size_of(state)), u8[]((u8*)&before, memory.size_of(before))))
    try state.update(b"")
    try state.finish(output)
    assert(state.count == 0)
    ## Low counter carry with a non-overflowing high counter.
    state = try blake.make_hash(64)
    state.low = 0xffffffffffffff80
    state.high = 7
    var block: u8[128]
    try state.update(block)
    try state.update(output[..<1])
    assert(state.high == 8 and state.low == 0 and state.used == 1)
    state.close()
    for byte in u8[]((u8*)&state, memory.size_of(state)): assert(byte == 0)
    rejected = false
    blake.expand(b"", output[..<0]) catch failure:
        assert(failure.code == errors.invalid)
        rejected = true
    assert(rejected)

func check_case(kind: usize, data: const u8[], expected: const u8[]) -> !:
    assert(expected.length > 0)
    let output = try new u8[expected.length + 2] --- in memory.heap
    defer free(output) in memory.heap
    for i in 0..<output.length: output[i] = 173
    if kind == 1:
        assert(expected.length <= 64)
        try blake.digest(data, output[1..<expected.length + 1])
    else:
        assert(kind == 2)
        try blake.expand(data, output[1..<expected.length + 1])
    assert(secure.equal(output[1..<expected.length + 1], expected))
    assert(output[0] == 173 and output[output.length - 1] == 173)
    if kind == 1:
        for chunk in [(usize)1, 127, 128, 129, 4096]:
            if data.length > 1024 and chunk < 127: continue
            var state = try blake.make_hash(expected.length)
            defer state.close()
            var position: usize
            var borrowed: u8[4096]
            while position < data.length:
                let count = chunk if chunk < data.length - position else data.length - position
                for i in 0..<count: borrowed[i] = data[position + i]
                try state.update(borrowed[..<count])
                secure.wipe(borrowed)
                try state.update(b"")
                position += count
            var rejected = false
            state.finish(output[..<expected.length - 1]) catch failure:
                assert(failure.code == errors.invalid)
                rejected = true
            assert(rejected)
            try state.finish(output)
            assert(secure.equal(output[..<expected.length], expected))
            for byte in u8[]((u8*)&state, memory.size_of(state)): assert(byte == 0)
            rejected = false
            state.update(b"") catch failure:
                assert(failure.code == errors.closed)
                rejected = true
            assert(rejected)
    ## Both one-shot functions consume the whole input before writing output.
    let capacity = data.length if data.length > expected.length else expected.length
    let overlap = try new u8[capacity + 1] --- in memory.heap
    defer free(overlap) in memory.heap
    for i in 0..<data.length: overlap[i] = data[i]
    overlap[capacity] = 173
    if kind == 1: try blake.digest(overlap[..<data.length], overlap[..<expected.length])
    else: try blake.expand(overlap[..<data.length], overlap[..<expected.length])
    assert(secure.equal(overlap[..<expected.length], expected) and overlap[capacity] == 173)

pub func main(arguments: str[]) -> i32!:
    assert(arguments.length == 2)
    try boundaries()
    let file = try files.read((c.str)arguments[1], limit = 16777216)
    defer file.release()
    let bytes = file.value
    var reader = Reader(data = bytes)
    assert((str)reader.take(8) == "LCBLK01\0")
    let records = reader.number()
    assert(records > 0 and records <= 64)
    for i in 0..<records:
        let identity = reader.number()
        let kind = reader.number()
        let data = reader.blob()
        let expected = reader.blob()
        print(f"CASE {identity}")
        try check_case(kind, data, expected)
    assert(reader.position == bytes.length)
    print(f"PASS blake batch {records}")
    return 0