pharpend
371b45c3d8
jr: c_a2w_handler: error from controller Error: blakejs.blake2b is not a function content.ts:70:16
onErrorCase content.ts:70
(Async: promise callback)
c_a2w_handler content.ts:83
(Async: EventListener.handleEvent)
c_main content.ts:100
<anonymous> content.ts:106
tried using browserify on blake
think i need to inject it in the namespace like nacl
so progress
828 lines
51 KiB
JavaScript
828 lines
51 KiB
JavaScript
(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
|
// Blake2B in pure Javascript
|
|
// Adapted from the reference implementation in RFC7693
|
|
// Ported to Javascript by DC - https://github.com/dcposch
|
|
|
|
const util = require('./util')
|
|
|
|
// 64-bit unsigned addition
|
|
// Sets v[a,a+1] += v[b,b+1]
|
|
// v should be a Uint32Array
|
|
function ADD64AA (v, a, b) {
|
|
const o0 = v[a] + v[b]
|
|
let o1 = v[a + 1] + v[b + 1]
|
|
if (o0 >= 0x100000000) {
|
|
o1++
|
|
}
|
|
v[a] = o0
|
|
v[a + 1] = o1
|
|
}
|
|
|
|
// 64-bit unsigned addition
|
|
// Sets v[a,a+1] += b
|
|
// b0 is the low 32 bits of b, b1 represents the high 32 bits
|
|
function ADD64AC (v, a, b0, b1) {
|
|
let o0 = v[a] + b0
|
|
if (b0 < 0) {
|
|
o0 += 0x100000000
|
|
}
|
|
let o1 = v[a + 1] + b1
|
|
if (o0 >= 0x100000000) {
|
|
o1++
|
|
}
|
|
v[a] = o0
|
|
v[a + 1] = o1
|
|
}
|
|
|
|
// Little-endian byte access
|
|
function B2B_GET32 (arr, i) {
|
|
return arr[i] ^ (arr[i + 1] << 8) ^ (arr[i + 2] << 16) ^ (arr[i + 3] << 24)
|
|
}
|
|
|
|
// G Mixing function
|
|
// The ROTRs are inlined for speed
|
|
function B2B_G (a, b, c, d, ix, iy) {
|
|
const x0 = m[ix]
|
|
const x1 = m[ix + 1]
|
|
const y0 = m[iy]
|
|
const y1 = m[iy + 1]
|
|
|
|
ADD64AA(v, a, b) // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s
|
|
ADD64AC(v, a, x0, x1) // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits
|
|
|
|
// v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
|
|
let xor0 = v[d] ^ v[a]
|
|
let xor1 = v[d + 1] ^ v[a + 1]
|
|
v[d] = xor1
|
|
v[d + 1] = xor0
|
|
|
|
ADD64AA(v, c, d)
|
|
|
|
// v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
|
|
xor0 = v[b] ^ v[c]
|
|
xor1 = v[b + 1] ^ v[c + 1]
|
|
v[b] = (xor0 >>> 24) ^ (xor1 << 8)
|
|
v[b + 1] = (xor1 >>> 24) ^ (xor0 << 8)
|
|
|
|
ADD64AA(v, a, b)
|
|
ADD64AC(v, a, y0, y1)
|
|
|
|
// v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
|
|
xor0 = v[d] ^ v[a]
|
|
xor1 = v[d + 1] ^ v[a + 1]
|
|
v[d] = (xor0 >>> 16) ^ (xor1 << 16)
|
|
v[d + 1] = (xor1 >>> 16) ^ (xor0 << 16)
|
|
|
|
ADD64AA(v, c, d)
|
|
|
|
// v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
|
|
xor0 = v[b] ^ v[c]
|
|
xor1 = v[b + 1] ^ v[c + 1]
|
|
v[b] = (xor1 >>> 31) ^ (xor0 << 1)
|
|
v[b + 1] = (xor0 >>> 31) ^ (xor1 << 1)
|
|
}
|
|
|
|
// Initialization Vector
|
|
const BLAKE2B_IV32 = new Uint32Array([
|
|
0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372,
|
|
0x5f1d36f1, 0xa54ff53a, 0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c,
|
|
0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19
|
|
])
|
|
|
|
const SIGMA8 = [
|
|
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13,
|
|
6, 1, 12, 0, 2, 11, 7, 5, 3, 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1,
|
|
9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2, 4,
|
|
10, 15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5,
|
|
15, 14, 1, 9, 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11, 13, 11, 7,
|
|
14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10, 6, 15, 14, 9, 11, 3, 0, 8, 12, 2,
|
|
13, 7, 1, 4, 10, 5, 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0, 0,
|
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13, 6,
|
|
1, 12, 0, 2, 11, 7, 5, 3
|
|
]
|
|
|
|
// These are offsets into a uint64 buffer.
|
|
// Multiply them all by 2 to make them offsets into a uint32 buffer,
|
|
// because this is Javascript and we don't have uint64s
|
|
const SIGMA82 = new Uint8Array(
|
|
SIGMA8.map(function (x) {
|
|
return x * 2
|
|
})
|
|
)
|
|
|
|
// Compression function. 'last' flag indicates last block.
|
|
// Note we're representing 16 uint64s as 32 uint32s
|
|
const v = new Uint32Array(32)
|
|
const m = new Uint32Array(32)
|
|
function blake2bCompress (ctx, last) {
|
|
let i = 0
|
|
|
|
// init work variables
|
|
for (i = 0; i < 16; i++) {
|
|
v[i] = ctx.h[i]
|
|
v[i + 16] = BLAKE2B_IV32[i]
|
|
}
|
|
|
|
// low 64 bits of offset
|
|
v[24] = v[24] ^ ctx.t
|
|
v[25] = v[25] ^ (ctx.t / 0x100000000)
|
|
// high 64 bits not supported, offset may not be higher than 2**53-1
|
|
|
|
// last block flag set ?
|
|
if (last) {
|
|
v[28] = ~v[28]
|
|
v[29] = ~v[29]
|
|
}
|
|
|
|
// get little-endian words
|
|
for (i = 0; i < 32; i++) {
|
|
m[i] = B2B_GET32(ctx.b, 4 * i)
|
|
}
|
|
|
|
// twelve rounds of mixing
|
|
// uncomment the DebugPrint calls to log the computation
|
|
// and match the RFC sample documentation
|
|
// util.debugPrint(' m[16]', m, 64)
|
|
for (i = 0; i < 12; i++) {
|
|
// util.debugPrint(' (i=' + (i < 10 ? ' ' : '') + i + ') v[16]', v, 64)
|
|
B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1])
|
|
B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3])
|
|
B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5])
|
|
B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7])
|
|
B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9])
|
|
B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11])
|
|
B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13])
|
|
B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15])
|
|
}
|
|
// util.debugPrint(' (i=12) v[16]', v, 64)
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16]
|
|
}
|
|
// util.debugPrint('h[8]', ctx.h, 64)
|
|
}
|
|
|
|
// reusable parameterBlock
|
|
const parameterBlock = new Uint8Array([
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 0: outlen, keylen, fanout, depth
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 4: leaf length, sequential mode
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 8: node offset
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 12: node offset
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 16: node depth, inner length, rfu
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 20: rfu
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 24: rfu
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 28: rfu
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 32: salt
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 36: salt
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 40: salt
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 44: salt
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 48: personal
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 52: personal
|
|
0,
|
|
0,
|
|
0,
|
|
0, // 56: personal
|
|
0,
|
|
0,
|
|
0,
|
|
0 // 60: personal
|
|
])
|
|
|
|
// Creates a BLAKE2b hashing context
|
|
// Requires an output length between 1 and 64 bytes
|
|
// Takes an optional Uint8Array key
|
|
// Takes an optinal Uint8Array salt
|
|
// Takes an optinal Uint8Array personal
|
|
function blake2bInit (outlen, key, salt, personal) {
|
|
if (outlen === 0 || outlen > 64) {
|
|
throw new Error('Illegal output length, expected 0 < length <= 64')
|
|
}
|
|
if (key && key.length > 64) {
|
|
throw new Error('Illegal key, expected Uint8Array with 0 < length <= 64')
|
|
}
|
|
if (salt && salt.length !== 16) {
|
|
throw new Error('Illegal salt, expected Uint8Array with length is 16')
|
|
}
|
|
if (personal && personal.length !== 16) {
|
|
throw new Error('Illegal personal, expected Uint8Array with length is 16')
|
|
}
|
|
|
|
// state, 'param block'
|
|
const ctx = {
|
|
b: new Uint8Array(128),
|
|
h: new Uint32Array(16),
|
|
t: 0, // input count
|
|
c: 0, // pointer within buffer
|
|
outlen: outlen // output length in bytes
|
|
}
|
|
|
|
// initialize parameterBlock before usage
|
|
parameterBlock.fill(0)
|
|
parameterBlock[0] = outlen
|
|
if (key) parameterBlock[1] = key.length
|
|
parameterBlock[2] = 1 // fanout
|
|
parameterBlock[3] = 1 // depth
|
|
if (salt) parameterBlock.set(salt, 32)
|
|
if (personal) parameterBlock.set(personal, 48)
|
|
|
|
// initialize hash state
|
|
for (let i = 0; i < 16; i++) {
|
|
ctx.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameterBlock, i * 4)
|
|
}
|
|
|
|
// key the hash, if applicable
|
|
if (key) {
|
|
blake2bUpdate(ctx, key)
|
|
// at the end
|
|
ctx.c = 128
|
|
}
|
|
|
|
return ctx
|
|
}
|
|
|
|
// Updates a BLAKE2b streaming hash
|
|
// Requires hash context and Uint8Array (byte array)
|
|
function blake2bUpdate (ctx, input) {
|
|
for (let i = 0; i < input.length; i++) {
|
|
if (ctx.c === 128) {
|
|
// buffer full ?
|
|
ctx.t += ctx.c // add counters
|
|
blake2bCompress(ctx, false) // compress (not last)
|
|
ctx.c = 0 // counter to zero
|
|
}
|
|
ctx.b[ctx.c++] = input[i]
|
|
}
|
|
}
|
|
|
|
// Completes a BLAKE2b streaming hash
|
|
// Returns a Uint8Array containing the message digest
|
|
function blake2bFinal (ctx) {
|
|
ctx.t += ctx.c // mark last block offset
|
|
|
|
while (ctx.c < 128) {
|
|
// fill up with zeros
|
|
ctx.b[ctx.c++] = 0
|
|
}
|
|
blake2bCompress(ctx, true) // final block flag = 1
|
|
|
|
// little endian convert and store
|
|
const out = new Uint8Array(ctx.outlen)
|
|
for (let i = 0; i < ctx.outlen; i++) {
|
|
out[i] = ctx.h[i >> 2] >> (8 * (i & 3))
|
|
}
|
|
return out
|
|
}
|
|
|
|
// Computes the BLAKE2B hash of a string or byte array, and returns a Uint8Array
|
|
//
|
|
// Returns a n-byte Uint8Array
|
|
//
|
|
// Parameters:
|
|
// - input - the input bytes, as a string, Buffer or Uint8Array
|
|
// - key - optional key Uint8Array, up to 64 bytes
|
|
// - outlen - optional output length in bytes, default 64
|
|
// - salt - optional salt bytes, string, Buffer or Uint8Array
|
|
// - personal - optional personal bytes, string, Buffer or Uint8Array
|
|
function blake2b (input, key, outlen, salt, personal) {
|
|
// preprocess inputs
|
|
outlen = outlen || 64
|
|
input = util.normalizeInput(input)
|
|
if (salt) {
|
|
salt = util.normalizeInput(salt)
|
|
}
|
|
if (personal) {
|
|
personal = util.normalizeInput(personal)
|
|
}
|
|
|
|
// do the math
|
|
const ctx = blake2bInit(outlen, key, salt, personal)
|
|
blake2bUpdate(ctx, input)
|
|
return blake2bFinal(ctx)
|
|
}
|
|
|
|
// Computes the BLAKE2B hash of a string or byte array
|
|
//
|
|
// Returns an n-byte hash in hex, all lowercase
|
|
//
|
|
// Parameters:
|
|
// - input - the input bytes, as a string, Buffer, or Uint8Array
|
|
// - key - optional key Uint8Array, up to 64 bytes
|
|
// - outlen - optional output length in bytes, default 64
|
|
// - salt - optional salt bytes, string, Buffer or Uint8Array
|
|
// - personal - optional personal bytes, string, Buffer or Uint8Array
|
|
function blake2bHex (input, key, outlen, salt, personal) {
|
|
const output = blake2b(input, key, outlen, salt, personal)
|
|
return util.toHex(output)
|
|
}
|
|
|
|
module.exports = {
|
|
blake2b: blake2b,
|
|
blake2bHex: blake2bHex,
|
|
blake2bInit: blake2bInit,
|
|
blake2bUpdate: blake2bUpdate,
|
|
blake2bFinal: blake2bFinal
|
|
}
|
|
|
|
},{"./util":4}],2:[function(require,module,exports){
|
|
// BLAKE2s hash function in pure Javascript
|
|
// Adapted from the reference implementation in RFC7693
|
|
// Ported to Javascript by DC - https://github.com/dcposch
|
|
|
|
const util = require('./util')
|
|
|
|
// Little-endian byte access.
|
|
// Expects a Uint8Array and an index
|
|
// Returns the little-endian uint32 at v[i..i+3]
|
|
function B2S_GET32 (v, i) {
|
|
return v[i] ^ (v[i + 1] << 8) ^ (v[i + 2] << 16) ^ (v[i + 3] << 24)
|
|
}
|
|
|
|
// Mixing function G.
|
|
function B2S_G (a, b, c, d, x, y) {
|
|
v[a] = v[a] + v[b] + x
|
|
v[d] = ROTR32(v[d] ^ v[a], 16)
|
|
v[c] = v[c] + v[d]
|
|
v[b] = ROTR32(v[b] ^ v[c], 12)
|
|
v[a] = v[a] + v[b] + y
|
|
v[d] = ROTR32(v[d] ^ v[a], 8)
|
|
v[c] = v[c] + v[d]
|
|
v[b] = ROTR32(v[b] ^ v[c], 7)
|
|
}
|
|
|
|
// 32-bit right rotation
|
|
// x should be a uint32
|
|
// y must be between 1 and 31, inclusive
|
|
function ROTR32 (x, y) {
|
|
return (x >>> y) ^ (x << (32 - y))
|
|
}
|
|
|
|
// Initialization Vector.
|
|
const BLAKE2S_IV = new Uint32Array([
|
|
0x6a09e667,
|
|
0xbb67ae85,
|
|
0x3c6ef372,
|
|
0xa54ff53a,
|
|
0x510e527f,
|
|
0x9b05688c,
|
|
0x1f83d9ab,
|
|
0x5be0cd19
|
|
])
|
|
|
|
const SIGMA = new Uint8Array([
|
|
0,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
8,
|
|
9,
|
|
10,
|
|
11,
|
|
12,
|
|
13,
|
|
14,
|
|
15,
|
|
14,
|
|
10,
|
|
4,
|
|
8,
|
|
9,
|
|
15,
|
|
13,
|
|
6,
|
|
1,
|
|
12,
|
|
0,
|
|
2,
|
|
11,
|
|
7,
|
|
5,
|
|
3,
|
|
11,
|
|
8,
|
|
12,
|
|
0,
|
|
5,
|
|
2,
|
|
15,
|
|
13,
|
|
10,
|
|
14,
|
|
3,
|
|
6,
|
|
7,
|
|
1,
|
|
9,
|
|
4,
|
|
7,
|
|
9,
|
|
3,
|
|
1,
|
|
13,
|
|
12,
|
|
11,
|
|
14,
|
|
2,
|
|
6,
|
|
5,
|
|
10,
|
|
4,
|
|
0,
|
|
15,
|
|
8,
|
|
9,
|
|
0,
|
|
5,
|
|
7,
|
|
2,
|
|
4,
|
|
10,
|
|
15,
|
|
14,
|
|
1,
|
|
11,
|
|
12,
|
|
6,
|
|
8,
|
|
3,
|
|
13,
|
|
2,
|
|
12,
|
|
6,
|
|
10,
|
|
0,
|
|
11,
|
|
8,
|
|
3,
|
|
4,
|
|
13,
|
|
7,
|
|
5,
|
|
15,
|
|
14,
|
|
1,
|
|
9,
|
|
12,
|
|
5,
|
|
1,
|
|
15,
|
|
14,
|
|
13,
|
|
4,
|
|
10,
|
|
0,
|
|
7,
|
|
6,
|
|
3,
|
|
9,
|
|
2,
|
|
8,
|
|
11,
|
|
13,
|
|
11,
|
|
7,
|
|
14,
|
|
12,
|
|
1,
|
|
3,
|
|
9,
|
|
5,
|
|
0,
|
|
15,
|
|
4,
|
|
8,
|
|
6,
|
|
2,
|
|
10,
|
|
6,
|
|
15,
|
|
14,
|
|
9,
|
|
11,
|
|
3,
|
|
0,
|
|
8,
|
|
12,
|
|
2,
|
|
13,
|
|
7,
|
|
1,
|
|
4,
|
|
10,
|
|
5,
|
|
10,
|
|
2,
|
|
8,
|
|
4,
|
|
7,
|
|
6,
|
|
1,
|
|
5,
|
|
15,
|
|
11,
|
|
9,
|
|
14,
|
|
3,
|
|
12,
|
|
13,
|
|
0
|
|
])
|
|
|
|
// Compression function. "last" flag indicates last block
|
|
const v = new Uint32Array(16)
|
|
const m = new Uint32Array(16)
|
|
function blake2sCompress (ctx, last) {
|
|
let i = 0
|
|
for (i = 0; i < 8; i++) {
|
|
// init work variables
|
|
v[i] = ctx.h[i]
|
|
v[i + 8] = BLAKE2S_IV[i]
|
|
}
|
|
|
|
v[12] ^= ctx.t // low 32 bits of offset
|
|
v[13] ^= ctx.t / 0x100000000 // high 32 bits
|
|
if (last) {
|
|
// last block flag set ?
|
|
v[14] = ~v[14]
|
|
}
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
// get little-endian words
|
|
m[i] = B2S_GET32(ctx.b, 4 * i)
|
|
}
|
|
|
|
// ten rounds of mixing
|
|
// uncomment the DebugPrint calls to log the computation
|
|
// and match the RFC sample documentation
|
|
// util.debugPrint(' m[16]', m, 32)
|
|
for (i = 0; i < 10; i++) {
|
|
// util.debugPrint(' (i=' + i + ') v[16]', v, 32)
|
|
B2S_G(0, 4, 8, 12, m[SIGMA[i * 16 + 0]], m[SIGMA[i * 16 + 1]])
|
|
B2S_G(1, 5, 9, 13, m[SIGMA[i * 16 + 2]], m[SIGMA[i * 16 + 3]])
|
|
B2S_G(2, 6, 10, 14, m[SIGMA[i * 16 + 4]], m[SIGMA[i * 16 + 5]])
|
|
B2S_G(3, 7, 11, 15, m[SIGMA[i * 16 + 6]], m[SIGMA[i * 16 + 7]])
|
|
B2S_G(0, 5, 10, 15, m[SIGMA[i * 16 + 8]], m[SIGMA[i * 16 + 9]])
|
|
B2S_G(1, 6, 11, 12, m[SIGMA[i * 16 + 10]], m[SIGMA[i * 16 + 11]])
|
|
B2S_G(2, 7, 8, 13, m[SIGMA[i * 16 + 12]], m[SIGMA[i * 16 + 13]])
|
|
B2S_G(3, 4, 9, 14, m[SIGMA[i * 16 + 14]], m[SIGMA[i * 16 + 15]])
|
|
}
|
|
// util.debugPrint(' (i=10) v[16]', v, 32)
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
ctx.h[i] ^= v[i] ^ v[i + 8]
|
|
}
|
|
// util.debugPrint('h[8]', ctx.h, 32)
|
|
}
|
|
|
|
// Creates a BLAKE2s hashing context
|
|
// Requires an output length between 1 and 32 bytes
|
|
// Takes an optional Uint8Array key
|
|
function blake2sInit (outlen, key) {
|
|
if (!(outlen > 0 && outlen <= 32)) {
|
|
throw new Error('Incorrect output length, should be in [1, 32]')
|
|
}
|
|
const keylen = key ? key.length : 0
|
|
if (key && !(keylen > 0 && keylen <= 32)) {
|
|
throw new Error('Incorrect key length, should be in [1, 32]')
|
|
}
|
|
|
|
const ctx = {
|
|
h: new Uint32Array(BLAKE2S_IV), // hash state
|
|
b: new Uint8Array(64), // input block
|
|
c: 0, // pointer within block
|
|
t: 0, // input count
|
|
outlen: outlen // output length in bytes
|
|
}
|
|
ctx.h[0] ^= 0x01010000 ^ (keylen << 8) ^ outlen
|
|
|
|
if (keylen > 0) {
|
|
blake2sUpdate(ctx, key)
|
|
ctx.c = 64 // at the end
|
|
}
|
|
|
|
return ctx
|
|
}
|
|
|
|
// Updates a BLAKE2s streaming hash
|
|
// Requires hash context and Uint8Array (byte array)
|
|
function blake2sUpdate (ctx, input) {
|
|
for (let i = 0; i < input.length; i++) {
|
|
if (ctx.c === 64) {
|
|
// buffer full ?
|
|
ctx.t += ctx.c // add counters
|
|
blake2sCompress(ctx, false) // compress (not last)
|
|
ctx.c = 0 // counter to zero
|
|
}
|
|
ctx.b[ctx.c++] = input[i]
|
|
}
|
|
}
|
|
|
|
// Completes a BLAKE2s streaming hash
|
|
// Returns a Uint8Array containing the message digest
|
|
function blake2sFinal (ctx) {
|
|
ctx.t += ctx.c // mark last block offset
|
|
while (ctx.c < 64) {
|
|
// fill up with zeros
|
|
ctx.b[ctx.c++] = 0
|
|
}
|
|
blake2sCompress(ctx, true) // final block flag = 1
|
|
|
|
// little endian convert and store
|
|
const out = new Uint8Array(ctx.outlen)
|
|
for (let i = 0; i < ctx.outlen; i++) {
|
|
out[i] = (ctx.h[i >> 2] >> (8 * (i & 3))) & 0xff
|
|
}
|
|
return out
|
|
}
|
|
|
|
// Computes the BLAKE2S hash of a string or byte array, and returns a Uint8Array
|
|
//
|
|
// Returns a n-byte Uint8Array
|
|
//
|
|
// Parameters:
|
|
// - input - the input bytes, as a string, Buffer, or Uint8Array
|
|
// - key - optional key Uint8Array, up to 32 bytes
|
|
// - outlen - optional output length in bytes, default 64
|
|
function blake2s (input, key, outlen) {
|
|
// preprocess inputs
|
|
outlen = outlen || 32
|
|
input = util.normalizeInput(input)
|
|
|
|
// do the math
|
|
const ctx = blake2sInit(outlen, key)
|
|
blake2sUpdate(ctx, input)
|
|
return blake2sFinal(ctx)
|
|
}
|
|
|
|
// Computes the BLAKE2S hash of a string or byte array
|
|
//
|
|
// Returns an n-byte hash in hex, all lowercase
|
|
//
|
|
// Parameters:
|
|
// - input - the input bytes, as a string, Buffer, or Uint8Array
|
|
// - key - optional key Uint8Array, up to 32 bytes
|
|
// - outlen - optional output length in bytes, default 64
|
|
function blake2sHex (input, key, outlen) {
|
|
const output = blake2s(input, key, outlen)
|
|
return util.toHex(output)
|
|
}
|
|
|
|
module.exports = {
|
|
blake2s: blake2s,
|
|
blake2sHex: blake2sHex,
|
|
blake2sInit: blake2sInit,
|
|
blake2sUpdate: blake2sUpdate,
|
|
blake2sFinal: blake2sFinal
|
|
}
|
|
|
|
},{"./util":4}],3:[function(require,module,exports){
|
|
const b2b = require('./blake2b')
|
|
const b2s = require('./blake2s')
|
|
|
|
module.exports = {
|
|
blake2b: b2b.blake2b,
|
|
blake2bHex: b2b.blake2bHex,
|
|
blake2bInit: b2b.blake2bInit,
|
|
blake2bUpdate: b2b.blake2bUpdate,
|
|
blake2bFinal: b2b.blake2bFinal,
|
|
blake2s: b2s.blake2s,
|
|
blake2sHex: b2s.blake2sHex,
|
|
blake2sInit: b2s.blake2sInit,
|
|
blake2sUpdate: b2s.blake2sUpdate,
|
|
blake2sFinal: b2s.blake2sFinal
|
|
}
|
|
|
|
},{"./blake2b":1,"./blake2s":2}],4:[function(require,module,exports){
|
|
const ERROR_MSG_INPUT = 'Input must be an string, Buffer or Uint8Array'
|
|
|
|
// For convenience, let people hash a string, not just a Uint8Array
|
|
function normalizeInput (input) {
|
|
let ret
|
|
if (input instanceof Uint8Array) {
|
|
ret = input
|
|
} else if (typeof input === 'string') {
|
|
const encoder = new TextEncoder()
|
|
ret = encoder.encode(input)
|
|
} else {
|
|
throw new Error(ERROR_MSG_INPUT)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// Converts a Uint8Array to a hexadecimal string
|
|
// For example, toHex([255, 0, 255]) returns "ff00ff"
|
|
function toHex (bytes) {
|
|
return Array.prototype.map
|
|
.call(bytes, function (n) {
|
|
return (n < 16 ? '0' : '') + n.toString(16)
|
|
})
|
|
.join('')
|
|
}
|
|
|
|
// Converts any value in [0...2^32-1] to an 8-character hex string
|
|
function uint32ToHex (val) {
|
|
return (0x100000000 + val).toString(16).substring(1)
|
|
}
|
|
|
|
// For debugging: prints out hash state in the same format as the RFC
|
|
// sample computation exactly, so that you can diff
|
|
function debugPrint (label, arr, size) {
|
|
let msg = '\n' + label + ' = '
|
|
for (let i = 0; i < arr.length; i += 2) {
|
|
if (size === 32) {
|
|
msg += uint32ToHex(arr[i]).toUpperCase()
|
|
msg += ' '
|
|
msg += uint32ToHex(arr[i + 1]).toUpperCase()
|
|
} else if (size === 64) {
|
|
msg += uint32ToHex(arr[i + 1]).toUpperCase()
|
|
msg += uint32ToHex(arr[i]).toUpperCase()
|
|
} else throw new Error('Invalid size ' + size)
|
|
if (i % 6 === 4) {
|
|
msg += '\n' + new Array(label.length + 4).join(' ')
|
|
} else if (i < arr.length - 2) {
|
|
msg += ' '
|
|
}
|
|
}
|
|
console.log(msg)
|
|
}
|
|
|
|
// For performance testing: generates N bytes of input, hashes M times
|
|
// Measures and prints MB/second hash performance each time
|
|
function testSpeed (hashFn, N, M) {
|
|
let startMs = new Date().getTime()
|
|
|
|
const input = new Uint8Array(N)
|
|
for (let i = 0; i < N; i++) {
|
|
input[i] = i % 256
|
|
}
|
|
const genMs = new Date().getTime()
|
|
console.log('Generated random input in ' + (genMs - startMs) + 'ms')
|
|
startMs = genMs
|
|
|
|
for (let i = 0; i < M; i++) {
|
|
const hashHex = hashFn(input)
|
|
const hashMs = new Date().getTime()
|
|
const ms = hashMs - startMs
|
|
startMs = hashMs
|
|
console.log('Hashed in ' + ms + 'ms: ' + hashHex.substring(0, 20) + '...')
|
|
console.log(
|
|
Math.round((N / (1 << 20) / (ms / 1000)) * 100) / 100 + ' MB PER SECOND'
|
|
)
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
normalizeInput: normalizeInput,
|
|
toHex: toHex,
|
|
debugPrint: debugPrint,
|
|
testSpeed: testSpeed
|
|
}
|
|
|
|
},{}]},{},[3])
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../.npm-packages/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","src/blake2b.js","src/blake2s.js","src/index.js","src/util.js"],"names":[],"mappings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jWA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","// Blake2B in pure Javascript\n// Adapted from the reference implementation in RFC7693\n// Ported to Javascript by DC - https://github.com/dcposch\n\nconst util = require('./util')\n\n// 64-bit unsigned addition\n// Sets v[a,a+1] += v[b,b+1]\n// v should be a Uint32Array\nfunction ADD64AA (v, a, b) {\n  const o0 = v[a] + v[b]\n  let o1 = v[a + 1] + v[b + 1]\n  if (o0 >= 0x100000000) {\n    o1++\n  }\n  v[a] = o0\n  v[a + 1] = o1\n}\n\n// 64-bit unsigned addition\n// Sets v[a,a+1] += b\n// b0 is the low 32 bits of b, b1 represents the high 32 bits\nfunction ADD64AC (v, a, b0, b1) {\n  let o0 = v[a] + b0\n  if (b0 < 0) {\n    o0 += 0x100000000\n  }\n  let o1 = v[a + 1] + b1\n  if (o0 >= 0x100000000) {\n    o1++\n  }\n  v[a] = o0\n  v[a + 1] = o1\n}\n\n// Little-endian byte access\nfunction B2B_GET32 (arr, i) {\n  return arr[i] ^ (arr[i + 1] << 8) ^ (arr[i + 2] << 16) ^ (arr[i + 3] << 24)\n}\n\n// G Mixing function\n// The ROTRs are inlined for speed\nfunction B2B_G (a, b, c, d, ix, iy) {\n  const x0 = m[ix]\n  const x1 = m[ix + 1]\n  const y0 = m[iy]\n  const y1 = m[iy + 1]\n\n  ADD64AA(v, a, b) // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s\n  ADD64AC(v, a, x0, x1) // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits\n\n  // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits\n  let xor0 = v[d] ^ v[a]\n  let xor1 = v[d + 1] ^ v[a + 1]\n  v[d] = xor1\n  v[d + 1] = xor0\n\n  ADD64AA(v, c, d)\n\n  // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits\n  xor0 = v[b] ^ v[c]\n  xor1 = v[b + 1] ^ v[c + 1]\n  v[b] = (xor0 >>> 24) ^ (xor1 << 8)\n  v[b + 1] = (xor1 >>> 24) ^ (xor0 << 8)\n\n  ADD64AA(v, a, b)\n  ADD64AC(v, a, y0, y1)\n\n  // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits\n  xor0 = v[d] ^ v[a]\n  xor1 = v[d + 1] ^ v[a + 1]\n  v[d] = (xor0 >>> 16) ^ (xor1 << 16)\n  v[d + 1] = (xor1 >>> 16) ^ (xor0 << 16)\n\n  ADD64AA(v, c, d)\n\n  // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits\n  xor0 = v[b] ^ v[c]\n  xor1 = v[b + 1] ^ v[c + 1]\n  v[b] = (xor1 >>> 31) ^ (xor0 << 1)\n  v[b + 1] = (xor0 >>> 31) ^ (xor1 << 1)\n}\n\n// Initialization Vector\nconst BLAKE2B_IV32 = new Uint32Array([\n  0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372,\n  0x5f1d36f1, 0xa54ff53a, 0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c,\n  0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19\n])\n\nconst SIGMA8 = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13,\n  6, 1, 12, 0, 2, 11, 7, 5, 3, 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1,\n  9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2, 4,\n  10, 15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5,\n  15, 14, 1, 9, 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11, 13, 11, 7,\n  14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10, 6, 15, 14, 9, 11, 3, 0, 8, 12, 2,\n  13, 7, 1, 4, 10, 5, 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0, 0,\n  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13, 6,\n  1, 12, 0, 2, 11, 7, 5, 3\n]\n\n// These are offsets into a uint64 buffer.\n// Multiply them all by 2 to make them offsets into a uint32 buffer,\n// because this is Javascript and we don't have uint64s\nconst SIGMA82 = new Uint8Array(\n  SIGMA8.map(function (x) {\n    return x * 2\n  })\n)\n\n// Compression function. 'last' flag indicates last block.\n// Note we're representing 16 uint64s as 32 uint32s\nconst v = new Uint32Array(32)\nconst m = new Uint32Array(32)\nfunction blake2bCompress (ctx, last) {\n  let i = 0\n\n  // init work variables\n  for (i = 0; i < 16; i++) {\n    v[i] = ctx.h[i]\n    v[i + 16] = BLAKE2B_IV32[i]\n  }\n\n  // low 64 bits of offset\n  v[24] = v[24] ^ ctx.t\n  v[25] = v[25] ^ (ctx.t / 0x100000000)\n  // high 64 bits not supported, offset may not be higher than 2**53-1\n\n  // last block flag set ?\n  if (last) {\n    v[28] = ~v[28]\n    v[29] = ~v[29]\n  }\n\n  // get little-endian words\n  for (i = 0; i < 32; i++) {\n    m[i] = B2B_GET32(ctx.b, 4 * i)\n  }\n\n  // twelve rounds of mixing\n  // uncomment the DebugPrint calls to log the computation\n  // and match the RFC sample documentation\n  // util.debugPrint('          m[16]', m, 64)\n  for (i = 0; i < 12; i++) {\n    // util.debugPrint('   (i=' + (i < 10 ? ' ' : '') + i + ') v[16]', v, 64)\n    B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1])\n    B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3])\n    B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5])\n    B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7])\n    B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9])\n    B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11])\n    B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13])\n    B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15])\n  }\n  // util.debugPrint('   (i=12) v[16]', v, 64)\n\n  for (i = 0; i < 16; i++) {\n    ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16]\n  }\n  // util.debugPrint('h[8]', ctx.h, 64)\n}\n\n// reusable parameterBlock\nconst parameterBlock = new Uint8Array([\n  0,\n  0,\n  0,\n  0, //  0: outlen, keylen, fanout, depth\n  0,\n  0,\n  0,\n  0, //  4: leaf length, sequential mode\n  0,\n  0,\n  0,\n  0, //  8: node offset\n  0,\n  0,\n  0,\n  0, // 12: node offset\n  0,\n  0,\n  0,\n  0, // 16: node depth, inner length, rfu\n  0,\n  0,\n  0,\n  0, // 20: rfu\n  0,\n  0,\n  0,\n  0, // 24: rfu\n  0,\n  0,\n  0,\n  0, // 28: rfu\n  0,\n  0,\n  0,\n  0, // 32: salt\n  0,\n  0,\n  0,\n  0, // 36: salt\n  0,\n  0,\n  0,\n  0, // 40: salt\n  0,\n  0,\n  0,\n  0, // 44: salt\n  0,\n  0,\n  0,\n  0, // 48: personal\n  0,\n  0,\n  0,\n  0, // 52: personal\n  0,\n  0,\n  0,\n  0, // 56: personal\n  0,\n  0,\n  0,\n  0 // 60: personal\n])\n\n// Creates a BLAKE2b hashing context\n// Requires an output length between 1 and 64 bytes\n// Takes an optional Uint8Array key\n// Takes an optinal Uint8Array salt\n// Takes an optinal Uint8Array personal\nfunction blake2bInit (outlen, key, salt, personal) {\n  if (outlen === 0 || outlen > 64) {\n    throw new Error('Illegal output length, expected 0 < length <= 64')\n  }\n  if (key && key.length > 64) {\n    throw new Error('Illegal key, expected Uint8Array with 0 < length <= 64')\n  }\n  if (salt && salt.length !== 16) {\n    throw new Error('Illegal salt, expected Uint8Array with length is 16')\n  }\n  if (personal && personal.length !== 16) {\n    throw new Error('Illegal personal, expected Uint8Array with length is 16')\n  }\n\n  // state, 'param block'\n  const ctx = {\n    b: new Uint8Array(128),\n    h: new Uint32Array(16),\n    t: 0, // input count\n    c: 0, // pointer within buffer\n    outlen: outlen // output length in bytes\n  }\n\n  // initialize parameterBlock before usage\n  parameterBlock.fill(0)\n  parameterBlock[0] = outlen\n  if (key) parameterBlock[1] = key.length\n  parameterBlock[2] = 1 // fanout\n  parameterBlock[3] = 1 // depth\n  if (salt) parameterBlock.set(salt, 32)\n  if (personal) parameterBlock.set(personal, 48)\n\n  // initialize hash state\n  for (let i = 0; i < 16; i++) {\n    ctx.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameterBlock, i * 4)\n  }\n\n  // key the hash, if applicable\n  if (key) {\n    blake2bUpdate(ctx, key)\n    // at the end\n    ctx.c = 128\n  }\n\n  return ctx\n}\n\n// Updates a BLAKE2b streaming hash\n// Requires hash context and Uint8Array (byte array)\nfunction blake2bUpdate (ctx, input) {\n  for (let i = 0; i < input.length; i++) {\n    if (ctx.c === 128) {\n      // buffer full ?\n      ctx.t += ctx.c // add counters\n      blake2bCompress(ctx, false) // compress (not last)\n      ctx.c = 0 // counter to zero\n    }\n    ctx.b[ctx.c++] = input[i]\n  }\n}\n\n// Completes a BLAKE2b streaming hash\n// Returns a Uint8Array containing the message digest\nfunction blake2bFinal (ctx) {\n  ctx.t += ctx.c // mark last block offset\n\n  while (ctx.c < 128) {\n    // fill up with zeros\n    ctx.b[ctx.c++] = 0\n  }\n  blake2bCompress(ctx, true) // final block flag = 1\n\n  // little endian convert and store\n  const out = new Uint8Array(ctx.outlen)\n  for (let i = 0; i < ctx.outlen; i++) {\n    out[i] = ctx.h[i >> 2] >> (8 * (i & 3))\n  }\n  return out\n}\n\n// Computes the BLAKE2B hash of a string or byte array, and returns a Uint8Array\n//\n// Returns a n-byte Uint8Array\n//\n// Parameters:\n// - input - the input bytes, as a string, Buffer or Uint8Array\n// - key - optional key Uint8Array, up to 64 bytes\n// - outlen - optional output length in bytes, default 64\n// - salt - optional salt bytes, string, Buffer or Uint8Array\n// - personal - optional personal bytes, string, Buffer or Uint8Array\nfunction blake2b (input, key, outlen, salt, personal) {\n  // preprocess inputs\n  outlen = outlen || 64\n  input = util.normalizeInput(input)\n  if (salt) {\n    salt = util.normalizeInput(salt)\n  }\n  if (personal) {\n    personal = util.normalizeInput(personal)\n  }\n\n  // do the math\n  const ctx = blake2bInit(outlen, key, salt, personal)\n  blake2bUpdate(ctx, input)\n  return blake2bFinal(ctx)\n}\n\n// Computes the BLAKE2B hash of a string or byte array\n//\n// Returns an n-byte hash in hex, all lowercase\n//\n// Parameters:\n// - input - the input bytes, as a string, Buffer, or Uint8Array\n// - key - optional key Uint8Array, up to 64 bytes\n// - outlen - optional output length in bytes, default 64\n// - salt - optional salt bytes, string, Buffer or Uint8Array\n// - personal - optional personal bytes, string, Buffer or Uint8Array\nfunction blake2bHex (input, key, outlen, salt, personal) {\n  const output = blake2b(input, key, outlen, salt, personal)\n  return util.toHex(output)\n}\n\nmodule.exports = {\n  blake2b: blake2b,\n  blake2bHex: blake2bHex,\n  blake2bInit: blake2bInit,\n  blake2bUpdate: blake2bUpdate,\n  blake2bFinal: blake2bFinal\n}\n","// BLAKE2s hash function in pure Javascript\n// Adapted from the reference implementation in RFC7693\n// Ported to Javascript by DC - https://github.com/dcposch\n\nconst util = require('./util')\n\n// Little-endian byte access.\n// Expects a Uint8Array and an index\n// Returns the little-endian uint32 at v[i..i+3]\nfunction B2S_GET32 (v, i) {\n  return v[i] ^ (v[i + 1] << 8) ^ (v[i + 2] << 16) ^ (v[i + 3] << 24)\n}\n\n// Mixing function G.\nfunction B2S_G (a, b, c, d, x, y) {\n  v[a] = v[a] + v[b] + x\n  v[d] = ROTR32(v[d] ^ v[a], 16)\n  v[c] = v[c] + v[d]\n  v[b] = ROTR32(v[b] ^ v[c], 12)\n  v[a] = v[a] + v[b] + y\n  v[d] = ROTR32(v[d] ^ v[a], 8)\n  v[c] = v[c] + v[d]\n  v[b] = ROTR32(v[b] ^ v[c], 7)\n}\n\n// 32-bit right rotation\n// x should be a uint32\n// y must be between 1 and 31, inclusive\nfunction ROTR32 (x, y) {\n  return (x >>> y) ^ (x << (32 - y))\n}\n\n// Initialization Vector.\nconst BLAKE2S_IV = new Uint32Array([\n  0x6a09e667,\n  0xbb67ae85,\n  0x3c6ef372,\n  0xa54ff53a,\n  0x510e527f,\n  0x9b05688c,\n  0x1f83d9ab,\n  0x5be0cd19\n])\n\nconst SIGMA = new Uint8Array([\n  0,\n  1,\n  2,\n  3,\n  4,\n  5,\n  6,\n  7,\n  8,\n  9,\n  10,\n  11,\n  12,\n  13,\n  14,\n  15,\n  14,\n  10,\n  4,\n  8,\n  9,\n  15,\n  13,\n  6,\n  1,\n  12,\n  0,\n  2,\n  11,\n  7,\n  5,\n  3,\n  11,\n  8,\n  12,\n  0,\n  5,\n  2,\n  15,\n  13,\n  10,\n  14,\n  3,\n  6,\n  7,\n  1,\n  9,\n  4,\n  7,\n  9,\n  3,\n  1,\n  13,\n  12,\n  11,\n  14,\n  2,\n  6,\n  5,\n  10,\n  4,\n  0,\n  15,\n  8,\n  9,\n  0,\n  5,\n  7,\n  2,\n  4,\n  10,\n  15,\n  14,\n  1,\n  11,\n  12,\n  6,\n  8,\n  3,\n  13,\n  2,\n  12,\n  6,\n  10,\n  0,\n  11,\n  8,\n  3,\n  4,\n  13,\n  7,\n  5,\n  15,\n  14,\n  1,\n  9,\n  12,\n  5,\n  1,\n  15,\n  14,\n  13,\n  4,\n  10,\n  0,\n  7,\n  6,\n  3,\n  9,\n  2,\n  8,\n  11,\n  13,\n  11,\n  7,\n  14,\n  12,\n  1,\n  3,\n  9,\n  5,\n  0,\n  15,\n  4,\n  8,\n  6,\n  2,\n  10,\n  6,\n  15,\n  14,\n  9,\n  11,\n  3,\n  0,\n  8,\n  12,\n  2,\n  13,\n  7,\n  1,\n  4,\n  10,\n  5,\n  10,\n  2,\n  8,\n  4,\n  7,\n  6,\n  1,\n  5,\n  15,\n  11,\n  9,\n  14,\n  3,\n  12,\n  13,\n  0\n])\n\n// Compression function. \"last\" flag indicates last block\nconst v = new Uint32Array(16)\nconst m = new Uint32Array(16)\nfunction blake2sCompress (ctx, last) {\n  let i = 0\n  for (i = 0; i < 8; i++) {\n    // init work variables\n    v[i] = ctx.h[i]\n    v[i + 8] = BLAKE2S_IV[i]\n  }\n\n  v[12] ^= ctx.t // low 32 bits of offset\n  v[13] ^= ctx.t / 0x100000000 // high 32 bits\n  if (last) {\n    // last block flag set ?\n    v[14] = ~v[14]\n  }\n\n  for (i = 0; i < 16; i++) {\n    // get little-endian words\n    m[i] = B2S_GET32(ctx.b, 4 * i)\n  }\n\n  // ten rounds of mixing\n  // uncomment the DebugPrint calls to log the computation\n  // and match the RFC sample documentation\n  // util.debugPrint('          m[16]', m, 32)\n  for (i = 0; i < 10; i++) {\n    // util.debugPrint('   (i=' + i + ')  v[16]', v, 32)\n    B2S_G(0, 4, 8, 12, m[SIGMA[i * 16 + 0]], m[SIGMA[i * 16 + 1]])\n    B2S_G(1, 5, 9, 13, m[SIGMA[i * 16 + 2]], m[SIGMA[i * 16 + 3]])\n    B2S_G(2, 6, 10, 14, m[SIGMA[i * 16 + 4]], m[SIGMA[i * 16 + 5]])\n    B2S_G(3, 7, 11, 15, m[SIGMA[i * 16 + 6]], m[SIGMA[i * 16 + 7]])\n    B2S_G(0, 5, 10, 15, m[SIGMA[i * 16 + 8]], m[SIGMA[i * 16 + 9]])\n    B2S_G(1, 6, 11, 12, m[SIGMA[i * 16 + 10]], m[SIGMA[i * 16 + 11]])\n    B2S_G(2, 7, 8, 13, m[SIGMA[i * 16 + 12]], m[SIGMA[i * 16 + 13]])\n    B2S_G(3, 4, 9, 14, m[SIGMA[i * 16 + 14]], m[SIGMA[i * 16 + 15]])\n  }\n  // util.debugPrint('   (i=10) v[16]', v, 32)\n\n  for (i = 0; i < 8; i++) {\n    ctx.h[i] ^= v[i] ^ v[i + 8]\n  }\n  // util.debugPrint('h[8]', ctx.h, 32)\n}\n\n// Creates a BLAKE2s hashing context\n// Requires an output length between 1 and 32 bytes\n// Takes an optional Uint8Array key\nfunction blake2sInit (outlen, key) {\n  if (!(outlen > 0 && outlen <= 32)) {\n    throw new Error('Incorrect output length, should be in [1, 32]')\n  }\n  const keylen = key ? key.length : 0\n  if (key && !(keylen > 0 && keylen <= 32)) {\n    throw new Error('Incorrect key length, should be in [1, 32]')\n  }\n\n  const ctx = {\n    h: new Uint32Array(BLAKE2S_IV), // hash state\n    b: new Uint8Array(64), // input block\n    c: 0, // pointer within block\n    t: 0, // input count\n    outlen: outlen // output length in bytes\n  }\n  ctx.h[0] ^= 0x01010000 ^ (keylen << 8) ^ outlen\n\n  if (keylen > 0) {\n    blake2sUpdate(ctx, key)\n    ctx.c = 64 // at the end\n  }\n\n  return ctx\n}\n\n// Updates a BLAKE2s streaming hash\n// Requires hash context and Uint8Array (byte array)\nfunction blake2sUpdate (ctx, input) {\n  for (let i = 0; i < input.length; i++) {\n    if (ctx.c === 64) {\n      // buffer full ?\n      ctx.t += ctx.c // add counters\n      blake2sCompress(ctx, false) // compress (not last)\n      ctx.c = 0 // counter to zero\n    }\n    ctx.b[ctx.c++] = input[i]\n  }\n}\n\n// Completes a BLAKE2s streaming hash\n// Returns a Uint8Array containing the message digest\nfunction blake2sFinal (ctx) {\n  ctx.t += ctx.c // mark last block offset\n  while (ctx.c < 64) {\n    // fill up with zeros\n    ctx.b[ctx.c++] = 0\n  }\n  blake2sCompress(ctx, true) // final block flag = 1\n\n  // little endian convert and store\n  const out = new Uint8Array(ctx.outlen)\n  for (let i = 0; i < ctx.outlen; i++) {\n    out[i] = (ctx.h[i >> 2] >> (8 * (i & 3))) & 0xff\n  }\n  return out\n}\n\n// Computes the BLAKE2S hash of a string or byte array, and returns a Uint8Array\n//\n// Returns a n-byte Uint8Array\n//\n// Parameters:\n// - input - the input bytes, as a string, Buffer, or Uint8Array\n// - key - optional key Uint8Array, up to 32 bytes\n// - outlen - optional output length in bytes, default 64\nfunction blake2s (input, key, outlen) {\n  // preprocess inputs\n  outlen = outlen || 32\n  input = util.normalizeInput(input)\n\n  // do the math\n  const ctx = blake2sInit(outlen, key)\n  blake2sUpdate(ctx, input)\n  return blake2sFinal(ctx)\n}\n\n// Computes the BLAKE2S hash of a string or byte array\n//\n// Returns an n-byte hash in hex, all lowercase\n//\n// Parameters:\n// - input - the input bytes, as a string, Buffer, or Uint8Array\n// - key - optional key Uint8Array, up to 32 bytes\n// - outlen - optional output length in bytes, default 64\nfunction blake2sHex (input, key, outlen) {\n  const output = blake2s(input, key, outlen)\n  return util.toHex(output)\n}\n\nmodule.exports = {\n  blake2s: blake2s,\n  blake2sHex: blake2sHex,\n  blake2sInit: blake2sInit,\n  blake2sUpdate: blake2sUpdate,\n  blake2sFinal: blake2sFinal\n}\n","const b2b = require('./blake2b')\nconst b2s = require('./blake2s')\n\nmodule.exports = {\n  blake2b: b2b.blake2b,\n  blake2bHex: b2b.blake2bHex,\n  blake2bInit: b2b.blake2bInit,\n  blake2bUpdate: b2b.blake2bUpdate,\n  blake2bFinal: b2b.blake2bFinal,\n  blake2s: b2s.blake2s,\n  blake2sHex: b2s.blake2sHex,\n  blake2sInit: b2s.blake2sInit,\n  blake2sUpdate: b2s.blake2sUpdate,\n  blake2sFinal: b2s.blake2sFinal\n}\n","const ERROR_MSG_INPUT = 'Input must be an string, Buffer or Uint8Array'\n\n// For convenience, let people hash a string, not just a Uint8Array\nfunction normalizeInput (input) {\n  let ret\n  if (input instanceof Uint8Array) {\n    ret = input\n  } else if (typeof input === 'string') {\n    const encoder = new TextEncoder()\n    ret = encoder.encode(input)\n  } else {\n    throw new Error(ERROR_MSG_INPUT)\n  }\n  return ret\n}\n\n// Converts a Uint8Array to a hexadecimal string\n// For example, toHex([255, 0, 255]) returns \"ff00ff\"\nfunction toHex (bytes) {\n  return Array.prototype.map\n    .call(bytes, function (n) {\n      return (n < 16 ? '0' : '') + n.toString(16)\n    })\n    .join('')\n}\n\n// Converts any value in [0...2^32-1] to an 8-character hex string\nfunction uint32ToHex (val) {\n  return (0x100000000 + val).toString(16).substring(1)\n}\n\n// For debugging: prints out hash state in the same format as the RFC\n// sample computation exactly, so that you can diff\nfunction debugPrint (label, arr, size) {\n  let msg = '\\n' + label + ' = '\n  for (let i = 0; i < arr.length; i += 2) {\n    if (size === 32) {\n      msg += uint32ToHex(arr[i]).toUpperCase()\n      msg += ' '\n      msg += uint32ToHex(arr[i + 1]).toUpperCase()\n    } else if (size === 64) {\n      msg += uint32ToHex(arr[i + 1]).toUpperCase()\n      msg += uint32ToHex(arr[i]).toUpperCase()\n    } else throw new Error('Invalid size ' + size)\n    if (i % 6 === 4) {\n      msg += '\\n' + new Array(label.length + 4).join(' ')\n    } else if (i < arr.length - 2) {\n      msg += ' '\n    }\n  }\n  console.log(msg)\n}\n\n// For performance testing: generates N bytes of input, hashes M times\n// Measures and prints MB/second hash performance each time\nfunction testSpeed (hashFn, N, M) {\n  let startMs = new Date().getTime()\n\n  const input = new Uint8Array(N)\n  for (let i = 0; i < N; i++) {\n    input[i] = i % 256\n  }\n  const genMs = new Date().getTime()\n  console.log('Generated random input in ' + (genMs - startMs) + 'ms')\n  startMs = genMs\n\n  for (let i = 0; i < M; i++) {\n    const hashHex = hashFn(input)\n    const hashMs = new Date().getTime()\n    const ms = hashMs - startMs\n    startMs = hashMs\n    console.log('Hashed in ' + ms + 'ms: ' + hashHex.substring(0, 20) + '...')\n    console.log(\n      Math.round((N / (1 << 20) / (ms / 1000)) * 100) / 100 + ' MB PER SECOND'\n    )\n  }\n}\n\nmodule.exports = {\n  normalizeInput: normalizeInput,\n  toHex: toHex,\n  debugPrint: debugPrint,\n  testSpeed: testSpeed\n}\n"]}
|