Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-crypto

Source of release 0.6.0

0.6.0 / src / sha1.lucb

## FIPS 180-4 SHA-1. Isolated legacy Git object IDs only. Never for secrets.
import secure
import sha2
import memory

func rotl(x: u32, n: u32) -> u32:
    return (x << n) | (x >> (32 - n))

func block(state: u32[], input: const u8[]):
    var w: u32[80]
    defer secure.wipe(u8[]((u8*)&w[0], memory.size_of(w)))
    for i in 0..<(usize)16:
        let j = i * 4
        w[i] = ((u32)input[j] << 24) | ((u32)input[j + 1] << 16) | ((u32)input[j + 2] << 8) | (u32)input[j + 3]
    for i in (usize)16..<(usize)80:
        w[i] = rotl(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1)
    var a = state[0]
    var b = state[1]
    var c = state[2]
    var d = state[3]
    var e = state[4]
    for i in 0..<(usize)80:
        var f: u32
        var k: u32
        if i < 20:
            f = (b & c) | ((~b) & d)
            k = 0x5a827999
        elif i < 40:
            f = b ^ c ^ d
            k = 0x6ed9eba1
        elif i < 60:
            f = (b & c) | (b & d) | (c & d)
            k = 0x8f1bbcdc
        else:
            f = b ^ c ^ d
            k = 0xca62c1d6
        let temp = rotl(a, 5) +% f +% e +% k +% w[i]
        e = d
        d = c
        c = rotl(b, 30)
        b = a
        a = temp
    state[0] +%= a
    state[1] +%= b
    state[2] +%= c
    state[3] +%= d
    state[4] +%= e

pub struct Hash:
    var h: u32[5]
    var buffer: u8[64]
    var used: usize
    var length: u64
    var disposed: bool = true

    pub func start():
        self.close()
        self.h[0] = 0x67452301
        self.h[1] = 0xefcdab89
        self.h[2] = 0x98badcfe
        self.h[3] = 0x10325476
        self.h[4] = 0xc3d2e1f0
        self.disposed = false

    pub func update(input: const u8[]) -> !:
        if self.disposed: error(sha2.closed, "SHA-1 is closed")
        if self.length > 0x1fffffffffffffff - (u64)input.length:
            error(sha2.length_exceeded, "SHA-1 message too long")
        var at: usize
        if self.used != 0:
            let take = 64 - self.used if 64 - self.used < input.length else input.length
            for i in 0..<take: self.buffer[self.used + i] = input[i]
            self.used += take
            at = take
            if self.used == 64:
                block(self.h, self.buffer)
                self.used = 0
        while input.length - at >= 64:
            block(self.h, input[at..<at + 64])
            at += 64
        for i in at..<input.length:
            self.buffer[self.used] = input[i]
            self.used += 1
        self.length += (u64)input.length

    pub func finish(output: u8[]) -> usize!:
        if self.disposed: error(sha2.closed, "SHA-1 is closed")
        if output.length < 20: error(sha2.invalid, "SHA-1 output buffer is too small")
        self.buffer[self.used] = 0x80
        self.used += 1
        if self.used > 56:
            while self.used < 64:
                self.buffer[self.used] = 0
                self.used += 1
            block(self.h, self.buffer)
            self.used = 0
        while self.used < 56:
            self.buffer[self.used] = 0
            self.used += 1
        let bits = self.length << 3
        for i in 0..<(usize)8: self.buffer[56 + i] = (u8)(bits >> ((7 - i) * 8))
        block(self.h, self.buffer)
        for i in 0..<(usize)5:
            output[i * 4] = (u8)(self.h[i] >> 24)
            output[i * 4 + 1] = (u8)(self.h[i] >> 16)
            output[i * 4 + 2] = (u8)(self.h[i] >> 8)
            output[i * 4 + 3] = (u8)self.h[i]
        self.close()
        return 20

    pub func close():
        secure.wipe(u8[]((u8*)&self.h[0], memory.size_of(self.h)))
        secure.wipe(self.buffer)
        self.used = 0
        self.length = 0
        self.disposed = true

pub func make() -> Hash:
    var state = Hash(disposed = true)
    state.start()
    return state

pub func digest(input: const u8[], output: u8[]) -> usize!:
    var state = make()
    defer state.close()
    try state.update(input)
    return try state.finish(output)