dymokomi/luce-crypto
Source of release 0.6.0
## 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)