// SHA-256 and HMAC-SHA-256 (FIPS 180-4, RFC 2104), for verifying webhook signatures. Written here until `std/crypto` is // on main: when it is, this file goes and `webhooks.weft` calls `hmac` and `timingSafeEqual` from there. let K: i64[] = [ 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, ] /// The low 32 bits. Words are held in an `i64`, whose sums can't overflow, and masked: SHA-256's additions wrap, and an /// `int`'s panic. let WORD: i64 = 0xffffffff fn shr(x: i64, n: int): i64 { return x >>> n } fn rotr(x: i64, n: int): i64 { return (shr(x, n) | (x << (32 - n))) & WORD } fn compress(mut h: i64[], m: int[], at: int) { let mut w: i64[] = [] for t of 0..16 { let i = at + t * 4 w.push(i64((m[i] << 24) | (m[i + 1] << 16) | (m[i + 2] << 8) | m[i + 3]) & WORD) } for t of 16..64 { let a = w[t - 15] let b = w[t - 2] let s0 = rotr(a, 7) ^ rotr(a, 18) ^ shr(a, 3) let s1 = rotr(b, 17) ^ rotr(b, 19) ^ shr(b, 10) w.push((w[t - 16] + s0 + w[t - 7] + s1) & WORD) } let mut a = h[0] let mut b = h[1] let mut c = h[2] let mut d = h[3] let mut e = h[4] let mut f = h[5] let mut g = h[6] let mut k = h[7] for t of 0..64 { let s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25) let ch = (e & f) ^ (~e & g & WORD) let t1 = (k + s1 + ch + K[t] + w[t]) & WORD let s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22) let maj = (a & b) ^ (a & c) ^ (b & c) let t2 = (s0 + maj) & WORD k = g g = f f = e e = (d + t1) & WORD d = c c = b b = a a = (t1 + t2) & WORD } let sums = [a, b, c, d, e, f, g, k] for i of 0..8 { h[i] = (h[i] + sums[i]) & WORD } } /// The byte of `word` that `shift` bits down. fn byteOf(word: i64, shift: int): int { return try int(shr(word, shift) & 255) else 0 } /// The SHA-256 digest of `data`. export fn sha256(data: Bytes): Bytes { let mut m = data.toList() let length = i64(m.length) m.push(0x80) while m.length % 64 != 56 { m.push(0) } // The length in bits, as 64 bits big-endian. let bits = length * 8 let high = shr(bits, 32) & WORD let low = bits & WORD for shift of [24, 16, 8, 0] { m.push(byteOf(high, shift)) } for shift of [24, 16, 8, 0] { m.push(byteOf(low, shift)) } let mut h: i64[] = [ 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, ] let mut at = 0 while at < m.length { compress(&h, m, at) at += 64 } let mut out: int[] = [] for word of h { for shift of [24, 16, 8, 0] { out.push(byteOf(word, shift)) } } return Bytes.of(out) } /// HMAC-SHA-256 of `data` with `key`. export fn hmacSha256(key: Bytes, data: Bytes): Bytes { let mut block = (key.length > 64 ? sha256(key) : key).toList() while block.length < 64 { block.push(0) } let inner = Bytes.of(block.map(b => b ^ 0x36)).concat(data) let outer = Bytes.of(block.map(b => b ^ 0x5c)) return sha256(outer.concat(sha256(inner))) } /// Whether two byte strings are equal, looking at every byte whatever it finds. export fn constantTimeEqual(a: Bytes, b: Bytes): boolean { if a.length != b.length { return false } let x = a.toList() let y = b.toList() let mut diff = 0 for i of 0..x.length { diff = diff | (x[i] ^ y[i]) } return diff == 0 }