| 1 |
// SPDX-License-Identifier: MPL-2.0 |
| 2 |
// (c) Hare authors <https://harelang.org> |
| 3 |
|
| 4 |
// This implementation was ported from Loup Vaillant's monocypher project. |
| 5 |
|
| 6 |
use bytes; |
| 7 |
use crypto::mac; |
| 8 |
use endian; |
| 9 |
use io; |
| 10 |
|
| 11 |
// Internal block size in bytes. |
| 12 |
export def BLOCKSZ: size = 16; |
| 13 |
|
| 14 |
// Length of the resulting MAC in bytes. |
| 15 |
export def SZ: size = 16; |
| 16 |
|
| 17 |
// Poly1305 key. |
| 18 |
export type key = [32]u8; |
| 19 |
|
| 20 |
export type state = struct { |
| 21 |
mac::mac, |
| 22 |
r: [4]u32, |
| 23 |
h: [5]u32, |
| 24 |
c: [16]u8, |
| 25 |
pad: [4]u32, |
| 26 |
cidx: size, |
| 27 |
}; |
| 28 |
|
| 29 |
const poly1305_vtable: io::vtable = io::vtable { |
| 30 |
writer = &write, |
| 31 |
... |
| 32 |
}; |
| 33 |
|
| 34 |
// Creates a [[crypto::mac::mac]] that computes the poly1305 MAC. It needs to |
| 35 |
// be initialised using [[init]]. Like the other MACs it needs to be finished |
| 36 |
// using [[crypto::mac::finish]] after use. |
| 37 |
export fn poly1305() state = { |
| 38 |
return state { |
| 39 |
stream = &poly1305_vtable, |
| 40 |
sum = &sum, |
| 41 |
finish = &finish, |
| 42 |
sz = SZ, |
| 43 |
bsz = BLOCKSZ, |
| 44 |
... |
| 45 |
}; |
| 46 |
}; |
| 47 |
|
| 48 |
// Initialises the MAC with given one time key. |
| 49 |
export fn init(p: *state, key: *key) void = { |
| 50 |
leputu32slice(p.r, key); |
| 51 |
leputu32slice(p.pad, key[16..]); |
| 52 |
|
| 53 |
p.r[0] &= 0x0fffffff; |
| 54 |
for (let i = 1z; i < 4; i += 1) { |
| 55 |
p.r[i] &= 0x0ffffffc; |
| 56 |
}; |
| 57 |
|
| 58 |
p.cidx = 0; |
| 59 |
}; |
| 60 |
|
| 61 |
fn leputu32slice(dest: []u32, src: []u8) void = { |
| 62 |
for (let i = 0z; i < len(dest); i += 1) { |
| 63 |
dest[i] = endian::legetu32(src[i * 4..(i + 1) * 4]); |
| 64 |
}; |
| 65 |
}; |
| 66 |
|
| 67 |
fn write(st: *io::stream, bbuf: const []u8) (size | io::error) = { |
| 68 |
let p = st: *state; |
| 69 |
let buf: []u8 = bbuf; |
| 70 |
const written = len(buf); |
| 71 |
|
| 72 |
for (len(buf) > 0) { |
| 73 |
const n = if (len(buf) <= BLOCKSZ - p.cidx) { |
| 74 |
yield len(buf); |
| 75 |
} else { |
| 76 |
yield BLOCKSZ - p.cidx; |
| 77 |
}; |
| 78 |
|
| 79 |
p.c[p.cidx..p.cidx + n] = buf[..n]; |
| 80 |
p.cidx += n; |
| 81 |
buf = buf[n..]; |
| 82 |
|
| 83 |
if (p.cidx >= BLOCKSZ) { |
| 84 |
block(p, p.c, 1); |
| 85 |
p.cidx = 0; |
| 86 |
}; |
| 87 |
}; |
| 88 |
|
| 89 |
return written; |
| 90 |
}; |
| 91 |
|
| 92 |
fn block(p: *state, buf: []u8, end: u32) void = { |
| 93 |
let s: [4]u32 = [0...]; |
| 94 |
leputu32slice(s, buf); |
| 95 |
|
| 96 |
// s = h + c, without carry propagation |
| 97 |
const s0: u64 = p.h[0]: u64 + s[0]; |
| 98 |
const s1: u64 = p.h[1]: u64 + s[1]; |
| 99 |
const s2: u64 = p.h[2]: u64 + s[2]; |
| 100 |
const s3: u64 = p.h[3]: u64 + s[3]; |
| 101 |
const s4: u32 = p.h[4] + end; |
| 102 |
|
| 103 |
// Local all the things! |
| 104 |
const r0: u32 = p.r[0]; |
| 105 |
const r1: u32 = p.r[1]; |
| 106 |
const r2: u32 = p.r[2]; |
| 107 |
const r3: u32 = p.r[3]; |
| 108 |
const rr0: u32 = (r0 >> 2) * 5; |
| 109 |
const rr1: u32 = (r1 >> 2) + r1; |
| 110 |
const rr2: u32 = (r2 >> 2) + r2; |
| 111 |
const rr3: u32 = (r3 >> 2) + r3; |
| 112 |
|
| 113 |
// (h + c) * r, without carry propagation |
| 114 |
const x0: u64 = s0 * r0 + s1 * rr3 + s2 * rr2 + s3 * rr1 + s4 * rr0; |
| 115 |
const x1: u64 = s0 * r1 + s1 * r0 + s2 * rr3 + s3 * rr2 + s4 * rr1; |
| 116 |
const x2: u64 = s0 * r2 + s1 * r1 + s2 * r0 + s3 * rr3 + s4 * rr2; |
| 117 |
const x3: u64 = s0 * r3 + s1 * r2 + s2 * r1 + s3 * r0 + s4 * rr3; |
| 118 |
const x4: u32 = s4 * (r0 & 3); |
| 119 |
|
| 120 |
// partial reduction modulo 2^130 - 5 |
| 121 |
const u5: u32 = x4 + (x3 >> 32): u32; |
| 122 |
const u0: u64 = (u5 >> 2) * 5 + (x0 & 0xffffffff); |
| 123 |
const u1: u64 = (u0 >> 32) + (x1 & 0xffffffff) + (x0 >> 32); |
| 124 |
const u2: u64 = (u1 >> 32) + (x2 & 0xffffffff) + (x1 >> 32); |
| 125 |
const u3: u64 = (u2 >> 32) + (x3 & 0xffffffff) + (x2 >> 32); |
| 126 |
const u4: u64 = (u3 >> 32) + (u5 & 3); |
| 127 |
|
| 128 |
// Update the hash |
| 129 |
p.h[0] = u0: u32; |
| 130 |
p.h[1] = u1: u32; |
| 131 |
p.h[2] = u2: u32; |
| 132 |
p.h[3] = u3: u32; |
| 133 |
p.h[4] = u4: u32; |
| 134 |
}; |
| 135 |
|
| 136 |
fn sum(m: *mac::mac, buf: []u8) void = { |
| 137 |
let p = m: *state; |
| 138 |
if (p.cidx > 0) { |
| 139 |
// update last block |
| 140 |
p.c[p.cidx] = 1; |
| 141 |
bytes::zero(p.c[p.cidx + 1..]); |
| 142 |
block(p, p.c, 0); |
| 143 |
}; |
| 144 |
|
| 145 |
// check if we should subtract 2^130-5 by performing the |
| 146 |
// corresponding carry propagation. |
| 147 |
let c: u64 = 5; |
| 148 |
for (let i = 0z; i < 4; i += 1) { |
| 149 |
c += p.h[i]; |
| 150 |
c >>= 32; |
| 151 |
}; |
| 152 |
c += p.h[4]; |
| 153 |
c = (c >> 2) * 5; // shift the carry back to the beginning |
| 154 |
// c now indicates how many times we should subtract 2^130-5 (0 or 1) |
| 155 |
|
| 156 |
for (let i = 0z; i < 4; i += 1) { |
| 157 |
c += p.h[i]: u64 + p.pad[i]: u64; |
| 158 |
endian::leputu32(buf[i * 4..(i + 1) * 4], c: u32); |
| 159 |
c = c >> 32; |
| 160 |
}; |
| 161 |
}; |
| 162 |
|
| 163 |
fn finish(m: *mac::mac) void = { |
| 164 |
let p = m: *state; |
| 165 |
bytes::zero((p.r[..]: *[*]u8)[..len(p.r) * size(u32)]); |
| 166 |
bytes::zero((p.h[..]: *[*]u8)[..len(p.h) * size(u32)]); |
| 167 |
bytes::zero(p.c[..]); |
| 168 |
bytes::zero((p.pad[..]: *[*]u8)[..len(p.pad) * size(u32)]); |
| 169 |
}; |