From 46cfdd7fe0835b24ef954200eefc4e2fa467674d Mon Sep 17 00:00:00 2001 From: multipleof4 Date: Thu, 11 Sep 2025 21:58:16 -0700 Subject: [PATCH] Add files via upload --- dash.html | 144 ++++++++ dash.js | 999 ++++++++++++++++++++++++++++++++++++++++++++++++++ icon.png | Bin 0 -> 17333 bytes manifest.json | 25 ++ 4 files changed, 1168 insertions(+) create mode 100644 dash.html create mode 100644 dash.js create mode 100644 icon.png create mode 100644 manifest.json diff --git a/dash.html b/dash.html new file mode 100644 index 0000000..681e87a --- /dev/null +++ b/dash.html @@ -0,0 +1,144 @@ + + + + + + + +

inØsight 2.1.0source

+ + + + + +info +

+ notice: some platforms restrict Ø width characters. + donate +

+ + + + \ No newline at end of file diff --git a/dash.js b/dash.js new file mode 100644 index 0000000..3736032 --- /dev/null +++ b/dash.js @@ -0,0 +1,999 @@ +(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) + } + + 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) + } + + 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] + } + } + + 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]); diff --git a/icon.png b/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..084fde87789448596255d1cfd01d989cc956574d GIT binary patch literal 17333 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