dymokomi/luce-crypto
Source of release 0.6.1
## FIPS 202 SHAKE128/SHAKE256. Keccak-f[1600] sponge; little-endian lanes.
import secure
import sha2
import memory
pub let invalid = sha2.invalid
pub let closed = sha2.closed
pub let length_exceeded = sha2.length_exceeded
let rc: u64[24] = [
0x0000000000000001, 0x0000000000008082, 0x800000000000808a, 0x8000000080008000,
0x000000000000808b, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009,
0x000000000000008a, 0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
0x000000008000808b, 0x800000000000008b, 0x8000000000008089, 0x8000000000008003,
0x8000000000008002, 0x8000000000000080, 0x000000000000800a, 0x800000008000000a,
0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008
]
let rot: u32[25] = [
0, 1, 62, 28, 27,
36, 44, 6, 55, 20,
3, 10, 43, 25, 39,
41, 45, 15, 21, 8,
18, 2, 61, 56, 14
]
func rotl(x: u64, n: u32) -> u64:
if n == 0: return x
let k = (u64)n
return (x << k) | (x >> (64 - k))
func permute(a: u64[]):
var c: u64[5]
var d: u64[5]
var b: u64[25]
for round in 0..<(usize)24:
for x in 0..<(usize)5:
c[x] = a[x] ^ a[x + 5] ^ a[x + 10] ^ a[x + 15] ^ a[x + 20]
for x in 0..<(usize)5:
d[x] = c[(x + 4) % 5] ^ rotl(c[(x + 1) % 5], 1)
for x in 0..<(usize)5:
for y in 0..<(usize)5:
a[x + 5 * y] ^= d[x]
for x in 0..<(usize)5:
for y in 0..<(usize)5:
let n = rot[x + 5 * y]
let dest = y + 5 * ((2 * x + 3 * y) % 5)
b[dest] = rotl(a[x + 5 * y], n)
for x in 0..<(usize)5:
for y in 0..<(usize)5:
let i = x + 5 * y
a[i] = b[i] ^ ((~b[(x + 1) % 5 + 5 * y]) & b[(x + 2) % 5 + 5 * y])
a[0] ^= rc[round]
secure.wipe(u8[]((u8*)&c[0], memory.size_of(c)))
secure.wipe(u8[]((u8*)&d[0], memory.size_of(d)))
secure.wipe(u8[]((u8*)&b[0], memory.size_of(b)))
func xor_lane(a: u64[], at: usize, value: u64):
a[at] ^= value
func load_xor(a: u64[], bytes: const u8[], n: usize):
var i: usize
while i + 8 <= n:
var lane: u64
for j in 0..<(usize)8: lane |= (u64)bytes[i + j] << (j * 8)
xor_lane(a, i // 8, lane)
i += 8
if i < n:
var lane: u64
for j in i..<n: lane |= (u64)bytes[j] << ((j - i) * 8)
xor_lane(a, i // 8, lane)
func store_lanes(a: const u64[], bytes: u8[], n: usize):
var i: usize
while i < n:
let lane = a[i // 8]
let shift = (u32)((i & 7) * 8)
bytes[i] = (u8)(lane >> shift)
i += 1
pub struct Shake:
var a: u64[25]
var buffer: u8[200]
var used: usize
var rate: usize
var squeezing: bool
var disposed: bool = true
pub func start(bits: u32):
self.close()
if bits == 128:
self.rate = 168
else:
self.rate = 136
self.disposed = false
pub func update(input: const u8[]) -> !:
if self.disposed: error(closed, "SHAKE is closed")
if self.squeezing: error(invalid, "SHAKE cannot absorb after squeezing")
var at: usize
if self.used != 0:
let take = self.rate - self.used if self.rate - 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 == self.rate:
load_xor(self.a, self.buffer, self.rate)
permute(self.a)
self.used = 0
while input.length - at >= self.rate:
load_xor(self.a, input[at..<at + self.rate], self.rate)
permute(self.a)
at += self.rate
for i in at..<input.length:
self.buffer[self.used] = input[i]
self.used += 1
func finish_absorb():
for i in self.used..<self.rate: self.buffer[i] = 0
self.buffer[self.used] ^= 0x1f
self.buffer[self.rate - 1] ^= 0x80
load_xor(self.a, self.buffer, self.rate)
permute(self.a)
self.used = 0
self.squeezing = true
pub func squeeze(output: u8[]) -> !:
if self.disposed: error(closed, "SHAKE is closed")
if not self.squeezing: self.finish_absorb()
var at: usize
while at < output.length:
if self.used == self.rate:
permute(self.a)
self.used = 0
let take = self.rate - self.used if self.rate - self.used < output.length - at else output.length - at
store_lanes(self.a, self.buffer, self.rate)
for i in 0..<take: output[at + i] = self.buffer[self.used + i]
self.used += take
at += take
pub func close():
secure.wipe(u8[]((u8*)&self.a[0], memory.size_of(self.a)))
secure.wipe(self.buffer)
self.used = 0
self.rate = 0
self.squeezing = false
self.disposed = true
pub func make(bits: u32 = 256) -> Shake!:
if bits != 128 and bits != 256: error(invalid, "SHAKE bits must be 128 or 256")
var state = Shake(disposed = true)
state.start(bits)
return state
pub func shake256(input: const u8[], output: u8[]) -> !:
var state = try make(256)
defer state.close()
try state.update(input)
try state.squeeze(output)
pub func shake128(input: const u8[], output: u8[]) -> !:
var state = try make(128)
defer state.close()
try state.update(input)
try state.squeeze(output)