diff --git a/dash.js b/dash.js index 3736032..1429b05 100644 --- a/dash.js +++ b/dash.js @@ -1,999 +1,73 @@ -(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 { - const key64bit = blake.blake2bHex(kStr, null, 8) // expand key to fixed length of 64 bits - const key64arr = [parseInt(key64bit.slice(0, 4), 16), parseInt(key64bit.slice(4, 8), 16), parseInt(key64bit.slice(8, 12), 16), parseInt(key64bit.slice(12, 16), 16)] - return zwus.encodeNumberArray(Array.from(ptStr, c => speck32_64.encrypt(c.codePointAt(0), key64arr)), base) - }, - PLAIN: (ptStr, base) => zwus.encodeString(ptStr, base) - }, - YES: { - SPECK32_64ECB: (ptStr, base, kStr) => { - const key64bit = blake.blake2bHex(kStr, null, 8) // expand key to fixed length of 64 bits - const key64arr = [parseInt(key64bit.slice(0, 4), 16), parseInt(key64bit.slice(4, 8), 16), parseInt(key64bit.slice(8, 12), 16), parseInt(key64bit.slice(12, 16), 16)] - - return zwus.decodeToNumberArray(ptStr, base).map(x => { try { return String.fromCodePoint(speck32_64.decrypt(x, key64arr)); } catch { return '' } }).join(''); - }, - PLAIN: (ptStr, base) => zwus.decodeToString(ptStr, base) - } -} // https://soundcloud.com/esudesu/tried-luvletter -},{"blakejs":4,"generic-speck":6,"zwus":7}],2:[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":5}],3:[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":5}],4:[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":2,"./blake2s":3}],5:[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 -} - -},{}],6:[function(require,module,exports){ -function speck (params = {}) { - const BITS = params.bits || 16 - const ROUNDS = params.rounds || 22 - const RIGHT_ROTATIONS = params.rightRotations || 7 - const LEFT_ROTATIONS = params.leftRotations || 2 - - const BIT_MAX = 2 ** BITS - const BIT_MASK = BIT_MAX - 1 - - const ROR = (x, r) => (x >> r) | ((x << (BITS - r)) & BIT_MASK) - const ROL = (x, r) => ((x << r) & BIT_MASK) | (x >> (BITS - r)) - - const R = (x, y, k) => { - x = ROR(x, RIGHT_ROTATIONS) - x = (x + y) & BIT_MASK - x ^= k - y = ROL(y, LEFT_ROTATIONS) - y ^= x - return [x, y] - } - const RR = (x, y, k) => { - y ^= x - y = ROR(y, LEFT_ROTATIONS) - x ^= k - x = (x - y) & BIT_MASK - x = ROL(x, RIGHT_ROTATIONS) - return [x, y] - } - - function encryptRaw (pt, K) { - let y = pt[0] - let x = pt[1] - let b = K[0] - let a = K.slice(1) - - ;[x, y] = R(x, y, b) - for (let i = 0; i < ROUNDS - 1; i++) { - const j = i % a.length - ;[a[j], b] = R(a[j], b, i) - ;[x, y] = R(x, y, b) +/** + * ZWUS (Zero Width Unicode Standard) + */ +const zwus = { + 3: {unifier: "\u{00AD}", 0: "\u{180E}", 1: "\u{200B}", 2: "\u{200D}"}, + 6: {unifier: "\u{200C}", 0: "\u{200D}", 1: "\u{200F}", 2: "\u{00AD}", 3: "\u{2060}", 4: "\u{200B}", 5: "\u{200E}"}, + 8: {unifier: "\u{200C}", 0: "\u{200D}", 1: "\u{200F}", 2: "\u{00AD}", 3: "\u{2060}", 4: "\u{200B}", 5: "\u{200E}", 6: "\u{180E}", 7: "\u{FEFF}"}, + /** + * Encodes a string into a sequence of zero-width characters. + * @param {string} text - The input text to encode. + * @param {number} base - The numerical base for encoding. Options: 3, 6, 8. Larger the base, the smaller the output, but the more likely the zero width will be detectable by sight. + * @returns {string} The encoded string. + */ + encodeString: (text, base = 3) => Array.from(text, u => u.codePointAt(0).toString(base).split('').map(x => zwus[base][x]).join('')).join(zwus[base].unifier), + /** + * Encodes an array of numbers into a sequence of zero-width characters. + * @param {Array} arr - The array of numbers to encode. + * @param {number} base - The numerical base for encoding. Options: 3, 6, 8. Larger the base, the smaller the output, but the more likely the zero width will be detectable by sight. + * @returns {string} The encoded array. + */ + encodeNumberArray: (arr, base = 3) => arr.map(n => n.toString(base).split('').map(x => zwus[base][x]).join('')).join(zwus[base].unifier), + /** + * Decodes a string of zero-width characters back into the original string. + * NOTE: Decoding accuracy is contingent upon the original encoding base and alphabet. + * @param {string} text - The encoded text to decode. + * @param {number} base - The numerical base for decoding. Must match the base used for encoding. + * @returns {string} The decoded string. + */ + decodeToString: (text, base = 3) => text.split(zwus[base].unifier).map(x => String.fromCodePoint(parseInt(Array.from(x).map(z => Object.keys(zwus[base]).find(k => zwus[base][k] === z)).join(''), base))).join(''), + /** + * Decodes a string of zero-width characters back into the original array of numbers. + * NOTE: Decoding accuracy is contingent upon the original encoding base and alphabet. + * @param {string} text - The encoded text to decode. + * @param {number} base - The numerical base for decoding. Must match the base used for encoding. + * @returns {Array} The decoded array of numbers. + */ + decodeToNumberArray: (text, base = 3) => text.split(zwus[base].unifier).map(x => parseInt(Array.from(x).map(z => Object.keys(zwus[base]).find(k => zwus[base][k] === z)).join(''), base)), +}; + +const textarea = document.getElementById('textarea'); +const encoderDropdown = document.getElementById('encoder'); +const cipherDropdown = document.getElementById('cipher'); +document.getElementById('encodeButton').addEventListener('click', ACT); +document.getElementById('decodeButton').addEventListener('click', ACT); + +function ACT(event) { + if (textarea.value === '') { + textarea.value = 'The text box is empty.'; + return; } - return [y, x] - } - - function decryptRaw (pt, K) { - let y = pt[0] - let x = pt[1] - let b = K[0] - let a = K.slice(1) - - for (let i = 0; i < ROUNDS - 1; i++) { - const j = i % a.length - ;[a[j], b] = R(a[j], b, i) - } - for (let i = 0; i < ROUNDS; i++) { - const j = (ROUNDS - 2 - i) % a.length - ;[x, y] = RR(x, y, b) - ;[a[j], b] = RR(a[j], b, ROUNDS - 2 - i) + const op = event.target.id === 'encodeButton' ? 'NO' : 'YES'; + try { + textarea.value = DESCRY[op]['PLAIN'](textarea.value, encoderDropdown.value.split('-')[1]); + } catch (e) { + console.log(e); } - return [y, x] - } - - // Wrap function in order to convert any bit size to the internal format - function wrapFn (fn) { - return (input, key) => { - const result = fn([input / BIT_MAX | 0, input & BIT_MASK], key) - return result[0] * BIT_MAX + result[1] + if (op === 'NO') { + textarea.select(); + document.execCommand('copy'); + textarea.value = 'Copied to your clipboard.\n A copy has been placed between these brackets [' + textarea.value + ']'; } - } - - return { - encrypt: wrapFn(encryptRaw), - decrypt: wrapFn(decryptRaw), - encryptRaw, - decryptRaw - } } -module.exports = speck - -},{}],7:[function(require,module,exports){ -'use strict'; - -/** - * ZWUS (Zero Width Unicode Standard) - * https://raw.githubusercontent.com/planetrenox/ZWUS/master/license - */ -const ZWUS = { - 3: {unifier: "\u{00AD}", 0: "\u{180E}", 1: "\u{200B}", 2: "\u{200D}"}, - 6: {unifier: "\u{200C}", 0: "\u{200D}", 1: "\u{200F}", 2: "\u{00AD}", 3: "\u{2060}", 4: "\u{200B}", 5: "\u{200E}"}, - 8: {unifier: "\u{200C}", 0: "\u{200D}", 1: "\u{200F}", 2: "\u{00AD}", 3: "\u{2060}", 4: "\u{200B}", 5: "\u{200E}", 6: "\u{180E}", 7: "\u{FEFF}"}, - /** - * Encodes a string into a sequence of zero-width characters. - * @param {string} text - The input text to encode. - * @param {number} base - The numerical base for encoding. Options: 3, 6, 8. Larger the base, the smaller the output, but the more likely the zero width will be detectable by sight. - * @returns {string} The encoded string. - */ - encodeString: (text, base = 3) => Array.from(text, u => u.codePointAt(0).toString(base).split('').map(x => ZWUS[base][x]).join('')).join(ZWUS[base].unifier), - /** - * Encodes an array of numbers into a sequence of zero-width characters. - * @param {Array} arr - The array of numbers to encode. - * @param {number} base - The numerical base for encoding. Options: 3, 6, 8. Larger the base, the smaller the output, but the more likely the zero width will be detectable by sight. - * @returns {string} The encoded array. - */ - encodeNumberArray: (arr, base = 3) => arr.map(n => n.toString(base).split('').map(x => ZWUS[base][x]).join('')).join(ZWUS[base].unifier), - /** - * Decodes a string of zero-width characters back into the original string. - * NOTE: Decoding accuracy is contingent upon the original encoding base and alphabet. - * @param {string} text - The encoded text to decode. - * @param {number} base - The numerical base for decoding. Must match the base used for encoding. - * @returns {string} The decoded string. - */ - decodeToString: (text, base = 3) => text.split(ZWUS[base].unifier).map(x => String.fromCodePoint(parseInt(Array.from(x).map(z => Object.keys(ZWUS[base]).find(k => ZWUS[base][k] === z)).join(''), base))).join(''), - /** - * Decodes a string of zero-width characters back into the original array of numbers. - * NOTE: Decoding accuracy is contingent upon the original encoding base and alphabet. - * @param {string} text - The encoded text to decode. - * @param {number} base - The numerical base for decoding. Must match the base used for encoding. - * @returns {Array} The decoded array of numbers. - */ - decodeToNumberArray: (text, base = 3) => text.split(ZWUS[base].unifier).map(x => parseInt(Array.from(x).map(z => Object.keys(ZWUS[base]).find(k => ZWUS[base][k] === z)).join(''), base)), -}; // https://soundcloud.com/crystal-castles/pino-placentile-wooden-girl - -module.exports = ZWUS; - -},{}]},{},[1]); +var DESCRY = { + NO: { + PLAIN: (ptStr, base) => zwus.encodeString(ptStr, base) + }, + YES: { + PLAIN: (ptStr, base) => zwus.decodeToString(ptStr, base) + } +};