734 lines
28 KiB
Haxe
734 lines
28 KiB
Haxe
package leenkx.network.torrent;
|
|
|
|
import haxe.io.Bytes;
|
|
|
|
class TweetNaCl {
|
|
|
|
static var _0:Array<Int> = [for (i in 0...16) 0];
|
|
static var _9:Array<Int> = { var a = [for (i in 0...32) 0]; a[0] = 9; a; };
|
|
static var sigma:Array<Int> = [101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107];
|
|
static var minusp:Array<Int> = [5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252];
|
|
static var L:Array<Float> = [0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10];
|
|
|
|
static inline function gf(?init:Array<Float>):Array<Float> {
|
|
var r = [for (i in 0...16) 0.0];
|
|
if (init != null) for (i in 0...init.length) r[i] = init[i];
|
|
return r;
|
|
}
|
|
|
|
static var gf0 = gf();
|
|
static var gf1 = gf([1]);
|
|
static var _121665 = gf([0xdb41, 1]);
|
|
static var D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]);
|
|
static var D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]);
|
|
static var X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]);
|
|
static var Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]);
|
|
static var I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]);
|
|
|
|
static var K:Array<Array<Int>> = [
|
|
[0x428a2f98, 0xd728ae22], [0x71374491, 0x23ef65cd], [0xb5c0fbcf, 0xec4d3b2f], [0xe9b5dba5, 0x8189dbbc],
|
|
[0x3956c25b, 0xf348b538], [0x59f111f1, 0xb605d019], [0x923f82a4, 0xaf194f9b], [0xab1c5ed5, 0xda6d8118],
|
|
[0xd807aa98, 0xa3030242], [0x12835b01, 0x45706fbe], [0x243185be, 0x4ee4b28c], [0x550c7dc3, 0xd5ffb4e2],
|
|
[0x72be5d74, 0xf27b896f], [0x80deb1fe, 0x3b1696b1], [0x9bdc06a7, 0x25c71235], [0xc19bf174, 0xcf692694],
|
|
[0xe49b69c1, 0x9ef14ad2], [0xefbe4786, 0x384f25e3], [0x0fc19dc6, 0x8b8cd5b5], [0x240ca1cc, 0x77ac9c65],
|
|
[0x2de92c6f, 0x592b0275], [0x4a7484aa, 0x6ea6e483], [0x5cb0a9dc, 0xbd41fbd4], [0x76f988da, 0x831153b5],
|
|
[0x983e5152, 0xee66dfab], [0xa831c66d, 0x2db43210], [0xb00327c8, 0x98fb213f], [0xbf597fc7, 0xbeef0ee4],
|
|
[0xc6e00bf3, 0x3da88fc2], [0xd5a79147, 0x930aa725], [0x06ca6351, 0xe003826f], [0x14292967, 0x0a0e6e70],
|
|
[0x27b70a85, 0x46d22ffc], [0x2e1b2138, 0x5c26c926], [0x4d2c6dfc, 0x5ac42aed], [0x53380d13, 0x9d95b3df],
|
|
[0x650a7354, 0x8baf63de], [0x766a0abb, 0x3c77b2a8], [0x81c2c92e, 0x47edaee6], [0x92722c85, 0x1482353b],
|
|
[0xa2bfe8a1, 0x4cf10364], [0xa81a664b, 0xbc423001], [0xc24b8b70, 0xd0f89791], [0xc76c51a3, 0x0654be30],
|
|
[0xd192e819, 0xd6ef5218], [0xd6990624, 0x5565a910], [0xf40e3585, 0x5771202a], [0x106aa070, 0x32bbd1b8],
|
|
[0x19a4c116, 0xb8d2d0c8], [0x1e376c08, 0x5141ab53], [0x2748774c, 0xdf8eeb99], [0x34b0bcb5, 0xe19b48a8],
|
|
[0x391c0cb3, 0xc5c95a63], [0x4ed8aa4a, 0xe3418acb], [0x5b9cca4f, 0x7763e373], [0x682e6ff3, 0xd6b2b8a3],
|
|
[0x748f82ee, 0x5defb2fc], [0x78a5636f, 0x43172f60], [0x84c87814, 0xa1f0ab72], [0x8cc70208, 0x1a6439ec],
|
|
[0x90befffa, 0x23631e28], [0xa4506ceb, 0xde82bde9], [0xbef9a3f7, 0xb2c67915], [0xc67178f2, 0xe372532b],
|
|
[0xca273ece, 0xea26619c], [0xd186b8c7, 0x21c0c207], [0xeada7dd6, 0xcde0eb1e], [0xf57d4f7f, 0xee6ed178],
|
|
[0x06f067aa, 0x72176fba], [0x0a637dc5, 0xa2c898a6], [0x113f9804, 0xbef90dae], [0x1b710b35, 0x131c471b],
|
|
[0x28db77f5, 0x23047d84], [0x32caab7b, 0x40c72493], [0x3c9ebe0a, 0x15c9bebc], [0x431d67c4, 0x9c100d4c],
|
|
[0x4cc5d4be, 0xcb3e42b6], [0x597f299c, 0xfc657e2a], [0x5fcb6fab, 0x3ad6faec], [0x6c44198c, 0x4a475817]
|
|
];
|
|
|
|
static var iv:Array<Int> = [
|
|
0x6a, 0x09, 0xe6, 0x67, 0xf3, 0xbc, 0xc9, 0x08,
|
|
0xbb, 0x67, 0xae, 0x85, 0x84, 0xca, 0xa7, 0x3b,
|
|
0x3c, 0x6e, 0xf3, 0x72, 0xfe, 0x94, 0xf8, 0x2b,
|
|
0xa5, 0x4f, 0xf5, 0x3a, 0x5f, 0x1d, 0x36, 0xf1,
|
|
0x51, 0x0e, 0x52, 0x7f, 0xad, 0xe6, 0x82, 0xd1,
|
|
0x9b, 0x05, 0x68, 0x8c, 0x2b, 0x3e, 0x6c, 0x1f,
|
|
0x1f, 0x83, 0xd9, 0xab, 0xfb, 0x41, 0xbd, 0x6b,
|
|
0x5b, 0xe0, 0xcd, 0x19, 0x13, 0x7e, 0x21, 0x79
|
|
];
|
|
|
|
static inline function u64(h:Int, l:Int):Array<Int> { return [h, l]; }
|
|
static inline function u64add(a:Array<Int>, b:Array<Int>):Array<Int> {
|
|
var a0 = a[1] & 65535, a1 = a[1] >>> 16, a2 = a[0] & 65535, a3 = a[0] >>> 16;
|
|
var b0 = b[1] & 65535, b1 = b[1] >>> 16, b2 = b[0] & 65535, b3 = b[0] >>> 16;
|
|
var s0 = a0 + b0; var s1 = a1 + b1 + (s0 >>> 16);
|
|
var s2 = a2 + b2 + (s1 >>> 16); var s3 = a3 + b3 + (s2 >>> 16);
|
|
return [(s2 & 65535) | ((s3 & 65535) << 16), (s0 & 65535) | ((s1 & 65535) << 16)];
|
|
}
|
|
static function u64addMulti(args:Array<Array<Int>>):Array<Int> {
|
|
var a0 = 0, a1 = 0, a2 = 0, a3 = 0;
|
|
for (v in args) {
|
|
a0 += v[1] & 65535; a1 += v[1] >>> 16;
|
|
a2 += v[0] & 65535; a3 += v[0] >>> 16;
|
|
}
|
|
a1 += a0 >>> 16; a2 += a1 >>> 16; a3 += a2 >>> 16;
|
|
return [(a2 & 65535) | ((a3 & 65535) << 16), (a0 & 65535) | ((a1 & 65535) << 16)];
|
|
}
|
|
static inline function u64xor(a:Array<Int>, b:Array<Int>):Array<Int> {
|
|
return [a[0] ^ b[0], a[1] ^ b[1]];
|
|
}
|
|
static function u64xorMulti(args:Array<Array<Int>>):Array<Int> {
|
|
var h = 0, l = 0;
|
|
for (v in args) { h ^= v[0]; l ^= v[1]; }
|
|
return [h, l];
|
|
}
|
|
static function u64R(x:Array<Int>, c:Int):Array<Int> {
|
|
var h:Int, l:Int, c1 = 32 - c;
|
|
if (c < 32) {
|
|
h = (x[0] >>> c) | (x[1] << c1);
|
|
l = (x[1] >>> c) | (x[0] << c1);
|
|
} else {
|
|
h = (x[1] >>> (c - 32)) | (x[0] << (64 - c));
|
|
l = (x[0] >>> (c - 32)) | (x[1] << (64 - c));
|
|
}
|
|
return [h, l];
|
|
}
|
|
static inline function u64shr(x:Array<Int>, c:Int):Array<Int> {
|
|
return [x[0] >>> c, (x[1] >>> c) | (x[0] << (32 - c))];
|
|
}
|
|
static inline function u64Ch(x:Array<Int>, y:Array<Int>, z:Array<Int>):Array<Int> {
|
|
return [(x[0] & y[0]) ^ (~x[0] & z[0]), (x[1] & y[1]) ^ (~x[1] & z[1])];
|
|
}
|
|
static inline function u64Maj(x:Array<Int>, y:Array<Int>, z:Array<Int>):Array<Int> {
|
|
return [(x[0] & y[0]) ^ (x[0] & z[0]) ^ (y[0] & z[0]), (x[1] & y[1]) ^ (x[1] & z[1]) ^ (y[1] & z[1])];
|
|
}
|
|
static inline function u64Sigma0(x:Array<Int>):Array<Int> { return u64xorMulti([u64R(x, 28), u64R(x, 34), u64R(x, 39)]); }
|
|
static inline function u64Sigma1(x:Array<Int>):Array<Int> { return u64xorMulti([u64R(x, 14), u64R(x, 18), u64R(x, 41)]); }
|
|
static inline function u64sigma0(x:Array<Int>):Array<Int> { return u64xorMulti([u64R(x, 1), u64R(x, 8), u64shr(x, 7)]); }
|
|
static inline function u64sigma1(x:Array<Int>):Array<Int> { return u64xorMulti([u64R(x, 19), u64R(x, 61), u64shr(x, 6)]); }
|
|
|
|
static function dl64(x:Array<Int>, i:Int):Array<Int> {
|
|
var h = (x[i] << 24) | (x[i + 1] << 16) | (x[i + 2] << 8) | x[i + 3];
|
|
var l = (x[i + 4] << 24) | (x[i + 5] << 16) | (x[i + 6] << 8) | x[i + 7];
|
|
return [h, l];
|
|
}
|
|
|
|
static function ts64u(x:Array<Int>, i:Int, v:Array<Int>):Void {
|
|
x[i] = (v[0] >> 24) & 0xff;
|
|
x[i + 1] = (v[0] >> 16) & 0xff;
|
|
x[i + 2] = (v[0] >> 8) & 0xff;
|
|
x[i + 3] = v[0] & 0xff;
|
|
x[i + 4] = (v[1] >> 24) & 0xff;
|
|
x[i + 5] = (v[1] >> 16) & 0xff;
|
|
x[i + 6] = (v[1] >> 8) & 0xff;
|
|
x[i + 7] = v[1] & 0xff;
|
|
}
|
|
|
|
static function L32(x:Int, c:Int):Int { return (x << c) | (x >>> (32 - c)); }
|
|
|
|
static function ld32(x:Array<Int>, i:Int):Int {
|
|
var u = x[i + 3] & 0xff;
|
|
u = (u << 8) | (x[i + 2] & 0xff);
|
|
u = (u << 8) | (x[i + 1] & 0xff);
|
|
return (u << 8) | (x[i + 0] & 0xff);
|
|
}
|
|
|
|
static function st32(x:Array<Int>, j:Int, u:Int):Void {
|
|
for (i in 0...4) { x[j + i] = u & 255; u = u >>> 8; }
|
|
}
|
|
|
|
static function vn(x:Array<Int>, xi:Int, y:Array<Int>, yi:Int, n:Int):Int {
|
|
var d = 0;
|
|
for (i in 0...n) d |= x[xi + i] ^ y[yi + i];
|
|
return (1 & ((d - 1) >>> 8)) - 1;
|
|
}
|
|
|
|
static function crypto_verify_16(x:Array<Int>, xi:Int, y:Array<Int>, yi:Int):Int { return vn(x, xi, y, yi, 16); }
|
|
static function crypto_verify_32(x:Array<Int>, xi:Int, y:Array<Int>, yi:Int):Int { return vn(x, xi, y, yi, 32); }
|
|
|
|
static function core(out:Array<Int>, inp:Array<Int>, k:Array<Int>, c:Array<Int>, h:Bool):Void {
|
|
var w = [for (i in 0...16) 0], x = [for (i in 0...16) 0], y = [for (i in 0...16) 0], t = [for (i in 0...4) 0];
|
|
for (i in 0...4) {
|
|
x[5 * i] = ld32(c, 4 * i); x[1 + i] = ld32(k, 4 * i);
|
|
x[6 + i] = ld32(inp, 4 * i); x[11 + i] = ld32(k, 16 + 4 * i);
|
|
}
|
|
for (i in 0...16) y[i] = x[i];
|
|
for (i in 0...20) {
|
|
for (j in 0...4) {
|
|
for (m in 0...4) t[m] = x[(5 * j + 4 * m) % 16];
|
|
t[1] ^= L32(t[0] + t[3], 7); t[2] ^= L32(t[1] + t[0], 9);
|
|
t[3] ^= L32(t[2] + t[1], 13); t[0] ^= L32(t[3] + t[2], 18);
|
|
for (m in 0...4) w[4 * j + (j + m) % 4] = t[m];
|
|
}
|
|
for (m in 0...16) x[m] = w[m];
|
|
}
|
|
if (h) {
|
|
for (i in 0...16) x[i] += y[i];
|
|
for (i in 0...4) { x[5 * i] -= ld32(c, 4 * i); x[6 + i] -= ld32(inp, 4 * i); }
|
|
for (i in 0...4) { st32(out, 4 * i, x[5 * i]); st32(out, 16 + 4 * i, x[6 + i]); }
|
|
} else {
|
|
for (i in 0...16) st32(out, 4 * i, x[i] + y[i]);
|
|
}
|
|
}
|
|
|
|
static function crypto_stream_salsa20_xor(c:Array<Int>, cpos:Int, m:Array<Int>, mpos:Int, b:Int, n:Array<Int>, k:Array<Int>):Int {
|
|
var z = [for (i in 0...16) 0], x = [for (i in 0...64) 0];
|
|
if (b == 0) return 0;
|
|
for (i in 0...8) z[i] = n[i];
|
|
while (b >= 64) {
|
|
crypto_core_salsa20(x, z, k, sigma);
|
|
for (i in 0...64) c[cpos + i] = (m != null ? m[mpos + i] : 0) ^ x[i];
|
|
var u = 1;
|
|
for (i in 8...16) { u += z[i]; z[i] = u & 0xff; u >>>= 8; }
|
|
b -= 64; cpos += 64; if (m != null) mpos += 64;
|
|
}
|
|
if (b > 0) {
|
|
crypto_core_salsa20(x, z, k, sigma);
|
|
for (i in 0...b) c[cpos + i] = (m != null ? m[mpos + i] : 0) ^ x[i];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static function crypto_stream(c:Array<Int>, cpos:Int, d:Int, n:Array<Int>, k:Array<Int>):Int {
|
|
var np = [for (i in 0...32) 0];
|
|
for (i in 0...n.length) np[i] = n[i];
|
|
var s = [for (i in 0...32) 0];
|
|
crypto_core_hsalsa20(s, np, k, sigma);
|
|
var n2 = [for (i in 0...16) 0];
|
|
for (i in 0...16) n2[i] = np[16 + i];
|
|
return crypto_stream_salsa20(c, cpos, d, n2, s);
|
|
}
|
|
|
|
static function crypto_stream_xor(c:Array<Int>, cpos:Int, m:Array<Int>, mpos:Int, d:Int, n:Array<Int>, k:Array<Int>):Int {
|
|
var np = [for (i in 0...32) 0];
|
|
for (i in 0...n.length) np[i] = n[i];
|
|
var s = [for (i in 0...32) 0];
|
|
crypto_core_hsalsa20(s, np, k, sigma);
|
|
var n2 = [for (i in 0...16) 0];
|
|
for (i in 0...16) n2[i] = np[16 + i];
|
|
return crypto_stream_salsa20_xor(c, cpos, m, mpos, d, n2, s);
|
|
}
|
|
|
|
static inline function crypto_core_salsa20(out:Array<Int>, inp:Array<Int>, k:Array<Int>, c:Array<Int>):Int { core(out, inp, k, c, false); return 0; }
|
|
static inline function crypto_core_hsalsa20(out:Array<Int>, inp:Array<Int>, k:Array<Int>, c:Array<Int>):Int { core(out, inp, k, c, true); return 0; }
|
|
static inline function crypto_stream_salsa20(c:Array<Int>, cpos:Int, d:Int, n:Array<Int>, k:Array<Int>):Int { return crypto_stream_salsa20_xor(c, cpos, null, 0, d, n, k); }
|
|
|
|
static function add1305(h:Array<Int>, c:Array<Int>):Void {
|
|
var u = 0;
|
|
for (j in 0...17) { u += h[j] + c[j]; h[j] = u & 255; u >>>= 8; }
|
|
}
|
|
|
|
static function crypto_onetimeauth(out:Array<Int>, outpos:Int, m:Array<Int>, mpos:Int, n:Int, k:Array<Int>):Int {
|
|
var s:Int, i:Int, j:Int, u:Int;
|
|
var x = [for (i in 0...17) 0], r = [for (i in 0...17) 0], h = [for (i in 0...17) 0], c = [for (i in 0...17) 0], g = [for (i in 0...17) 0];
|
|
for (j in 0...17) r[j] = h[j] = 0;
|
|
for (j in 0...16) r[j] = k[j];
|
|
r[3] &= 15; r[4] &= 252; r[7] &= 15; r[8] &= 252; r[11] &= 15; r[12] &= 252; r[15] &= 15;
|
|
while (n > 0) {
|
|
for (j in 0...17) c[j] = 0;
|
|
j = 0; while (j < 16 && j < n) { c[j] = m[mpos + j]; j++; }
|
|
c[j] = 1; mpos += j; n -= j;
|
|
add1305(h, c);
|
|
for (i in 0...17) {
|
|
x[i] = 0;
|
|
for (j in 0...17) x[i] += Std.int(h[j] * ((j <= i) ? r[i - j] : (320 * r[i + 17 - j])));
|
|
}
|
|
for (i in 0...17) h[i] = x[i];
|
|
u = 0;
|
|
for (j in 0...16) { u += h[j]; h[j] = u & 255; u >>>= 8; }
|
|
u += h[16]; h[16] = u & 3; u = 5 * (u >>> 2);
|
|
for (j in 0...16) { u += h[j]; h[j] = u & 255; u >>>= 8; }
|
|
u += h[16]; h[16] = u;
|
|
}
|
|
for (j in 0...17) g[j] = h[j];
|
|
add1305(h, minusp);
|
|
s = -(h[16] >>> 7);
|
|
for (j in 0...17) h[j] ^= s & (g[j] ^ h[j]);
|
|
for (j in 0...16) c[j] = k[j + 16];
|
|
c[16] = 0; add1305(h, c);
|
|
for (j in 0...16) out[outpos + j] = h[j];
|
|
return 0;
|
|
}
|
|
|
|
static function crypto_secretbox(c:Array<Int>, m:Array<Int>, d:Int, n:Array<Int>, k:Array<Int>):Int {
|
|
if (d < 32) return -1;
|
|
crypto_stream_xor(c, 0, m, 0, d, n, k);
|
|
crypto_onetimeauth(c, 16, c, 32, d - 32, c);
|
|
for (i in 0...16) c[i] = 0;
|
|
return 0;
|
|
}
|
|
|
|
static function crypto_secretbox_open(m:Array<Int>, c:Array<Int>, d:Int, n:Array<Int>, k:Array<Int>):Int {
|
|
var x = [for (i in 0...32) 0];
|
|
if (d < 32) return -1;
|
|
crypto_stream(x, 0, 32, n, k);
|
|
if (crypto_onetimeauth_verify(c, 16, c, 32, d - 32, x) != 0) return -1;
|
|
crypto_stream_xor(m, 0, c, 0, d, n, k);
|
|
for (i in 0...32) m[i] = 0;
|
|
return 0;
|
|
}
|
|
|
|
static inline function crypto_onetimeauth_verify(h:Array<Int>, hpos:Int, m:Array<Int>, mpos:Int, n:Int, k:Array<Int>):Int {
|
|
var x = [for (i in 0...16) 0];
|
|
crypto_onetimeauth(x, 0, m, mpos, n, k);
|
|
return crypto_verify_16(h, hpos, x, 0);
|
|
}
|
|
|
|
static function set25519(r:Array<Float>, a:Array<Float>):Void { for (i in 0...16) r[i] = a[i]; }
|
|
|
|
static function car25519(o:Array<Float>):Void {
|
|
var c:Float;
|
|
for (i in 0...16) {
|
|
o[i] += 65536;
|
|
c = Math.floor(o[i] / 65536);
|
|
o[(i + 1) * (i < 15 ? 1 : 0)] += c - 1 + 37 * (c - 1) * (i == 15 ? 1 : 0);
|
|
o[i] -= c * 65536;
|
|
}
|
|
}
|
|
|
|
static function sel25519(p:Array<Float>, q:Array<Float>, b:Int):Void {
|
|
var c = ~((b - 1));
|
|
for (i in 0...16) {
|
|
var t:Int = c & (Std.int(p[i]) ^ Std.int(q[i]));
|
|
p[i] = Std.int(p[i]) ^ t; q[i] = Std.int(q[i]) ^ t;
|
|
}
|
|
}
|
|
|
|
static function pack25519(o:Array<Int>, n:Array<Float>):Void {
|
|
var m = gf(), t = gf();
|
|
for (i in 0...16) t[i] = n[i];
|
|
car25519(t); car25519(t); car25519(t);
|
|
for (j in 0...2) {
|
|
m[0] = t[0] - 0xffed;
|
|
for (i in 1...15) {
|
|
m[i] = t[i] - 0xffff - ((Std.int(m[i - 1]) >> 16) & 1);
|
|
m[i - 1] = Std.int(m[i - 1]) & 0xffff;
|
|
}
|
|
m[15] = t[15] - 0x7fff - ((Std.int(m[14]) >> 16) & 1);
|
|
var b = (Std.int(m[15]) >> 16) & 1;
|
|
m[14] = Std.int(m[14]) & 0xffff;
|
|
sel25519(t, m, 1 - b);
|
|
}
|
|
for (i in 0...16) {
|
|
o[2 * i] = Std.int(t[i]) & 0xff;
|
|
o[2 * i + 1] = Std.int(t[i]) >> 8;
|
|
}
|
|
}
|
|
|
|
static function neq25519(a:Array<Float>, b:Array<Float>):Int {
|
|
var c = [for (i in 0...32) 0], d = [for (i in 0...32) 0];
|
|
pack25519(c, a); pack25519(d, b);
|
|
return crypto_verify_32(c, 0, d, 0);
|
|
}
|
|
|
|
static function par25519(a:Array<Float>):Int {
|
|
var d = [for (i in 0...32) 0];
|
|
pack25519(d, a);
|
|
return d[0] & 1;
|
|
}
|
|
|
|
static function unpack25519(o:Array<Float>, n:Array<Int>):Void {
|
|
for (i in 0...16) o[i] = n[2 * i] + (n[2 * i + 1] << 8);
|
|
o[15] = Std.int(o[15]) & 0x7fff;
|
|
}
|
|
|
|
static function A(o:Array<Float>, a:Array<Float>, b:Array<Float>):Void { for (i in 0...16) o[i] = a[i] + b[i]; }
|
|
static function Z(o:Array<Float>, a:Array<Float>, b:Array<Float>):Void { for (i in 0...16) o[i] = a[i] - b[i]; }
|
|
|
|
static function M(o:Array<Float>, a:Array<Float>, b:Array<Float>):Void {
|
|
var t = [for (i in 0...31) 0.0];
|
|
for (i in 0...16) for (j in 0...16) t[i + j] += a[i] * b[j];
|
|
for (i in 0...15) t[i] += 38 * t[i + 16];
|
|
for (i in 0...16) o[i] = t[i];
|
|
car25519(o); car25519(o);
|
|
}
|
|
|
|
static inline function S(o:Array<Float>, a:Array<Float>):Void { M(o, a, a); }
|
|
|
|
static function inv25519(o:Array<Float>, i:Array<Float>):Void {
|
|
var c = gf();
|
|
for (a in 0...16) c[a] = i[a];
|
|
var a = 253; while (a >= 0) {
|
|
S(c, c);
|
|
if (a != 2 && a != 4) M(c, c, i);
|
|
a--;
|
|
}
|
|
for (a in 0...16) o[a] = c[a];
|
|
}
|
|
|
|
static function pow2523(o:Array<Float>, i:Array<Float>):Void {
|
|
var c = gf();
|
|
for (a in 0...16) c[a] = i[a];
|
|
var a = 250; while (a >= 0) {
|
|
S(c, c);
|
|
if (a != 1) M(c, c, i);
|
|
a--;
|
|
}
|
|
for (a in 0...16) o[a] = c[a];
|
|
}
|
|
|
|
static function crypto_scalarmult(q:Array<Int>, n:Array<Int>, p:Array<Int>):Int {
|
|
var z = [for (i in 0...32) 0];
|
|
var x = [for (i in 0...80) 0.0];
|
|
var a = gf(), b = gf(), c = gf(), d = gf(), e = gf(), f = gf();
|
|
for (i in 0...31) z[i] = n[i];
|
|
z[31] = (n[31] & 127) | 64;
|
|
z[0] &= 248;
|
|
unpack25519(x, p);
|
|
for (i in 0...16) { b[i] = x[i]; d[i] = a[i] = c[i] = 0; }
|
|
a[0] = d[0] = 1;
|
|
var r:Int;
|
|
var i = 254; while (i >= 0) {
|
|
r = (z[i >>> 3] >>> (i & 7)) & 1;
|
|
sel25519(a, b, r); sel25519(c, d, r);
|
|
A(e, a, c); Z(a, a, c); A(c, b, d); Z(b, b, d);
|
|
S(d, e); S(f, a); M(a, c, a); M(c, b, e);
|
|
A(e, a, c); Z(a, a, c); S(b, a); Z(c, d, f);
|
|
M(a, c, _121665); A(a, a, d); M(c, c, a); M(a, d, f); M(d, b, x);
|
|
S(b, e); sel25519(a, b, r); sel25519(c, d, r);
|
|
i--;
|
|
}
|
|
for (i in 0...16) {
|
|
x[i + 16] = a[i]; x[i + 32] = c[i]; x[i + 48] = b[i]; x[i + 64] = d[i];
|
|
}
|
|
var x32 = [for (i in 0...16) 0.0]; for (i in 0...16) x32[i] = x[i + 32];
|
|
var x16 = [for (i in 0...16) 0.0]; for (i in 0...16) x16[i] = x[i + 16];
|
|
inv25519(x32, x32);
|
|
M(x16, x16, x32);
|
|
pack25519(q, x16);
|
|
return 0;
|
|
}
|
|
|
|
static function crypto_scalarmult_base(q:Array<Int>, n:Array<Int>):Int { return crypto_scalarmult(q, n, _9); }
|
|
|
|
static function crypto_box_beforenm(k:Array<Int>, y:Array<Int>, x:Array<Int>):Int {
|
|
var s = [for (i in 0...32) 0];
|
|
crypto_scalarmult(s, x, y);
|
|
return crypto_core_hsalsa20(k, _0, s, sigma);
|
|
}
|
|
|
|
static function crypto_box(c:Array<Int>, m:Array<Int>, d:Int, n:Array<Int>, y:Array<Int>, x:Array<Int>):Int {
|
|
var k = [for (i in 0...32) 0];
|
|
crypto_box_beforenm(k, y, x);
|
|
return crypto_secretbox(c, m, d, n, k);
|
|
}
|
|
|
|
static function crypto_box_open(m:Array<Int>, c:Array<Int>, d:Int, n:Array<Int>, y:Array<Int>, x:Array<Int>):Int {
|
|
var k = [for (i in 0...32) 0];
|
|
crypto_box_beforenm(k, y, x);
|
|
return crypto_secretbox_open(m, c, d, n, k);
|
|
}
|
|
|
|
static function crypto_box_keypair(y:Array<Int>, x:Array<Int>, randomFn:Int->Array<Int>):Int {
|
|
var rb = randomFn(32);
|
|
for (i in 0...32) x[i] = rb[i];
|
|
return crypto_scalarmult_base(y, x);
|
|
}
|
|
|
|
static function crypto_hashblocks(x:Array<Int>, m:Array<Int>, mpos:Int, n:Int):Int {
|
|
var z = [for (i in 0...8) null], b = [for (i in 0...8) null], a = [for (i in 0...8) null], w = [for (i in 0...16) null];
|
|
for (i in 0...8) z[i] = a[i] = dl64(x, 8 * i);
|
|
while (n >= 128) {
|
|
for (i in 0...16) w[i] = dl64(m, 8 * i + mpos);
|
|
for (i in 0...80) {
|
|
for (j in 0...8) b[j] = a[j];
|
|
var t = u64addMulti([a[7], u64Sigma1(a[4]), u64Ch(a[4], a[5], a[6]), u64(K[i][0], K[i][1]), w[i % 16]]);
|
|
b[7] = u64addMulti([t, u64Sigma0(a[0]), u64Maj(a[0], a[1], a[2])]);
|
|
b[3] = u64add(b[3], t);
|
|
for (j in 0...8) a[(j + 1) % 8] = b[j];
|
|
if (i % 16 == 15) {
|
|
for (j in 0...16) w[j] = u64addMulti([w[j], w[(j + 9) % 16], u64sigma0(w[(j + 1) % 16]), u64sigma1(w[(j + 14) % 16])]);
|
|
}
|
|
}
|
|
for (i in 0...8) { a[i] = u64add(a[i], z[i]); z[i] = a[i]; }
|
|
mpos += 128; n -= 128;
|
|
}
|
|
for (i in 0...8) ts64u(x, 8 * i, z[i]);
|
|
return n;
|
|
}
|
|
|
|
static function crypto_hash(out:Array<Int>, m:Array<Int>, n:Int):Int {
|
|
var h = [for (i in 0...64) 0], x = [for (i in 0...256) 0];
|
|
var b = n;
|
|
for (i in 0...64) h[i] = iv[i];
|
|
crypto_hashblocks(h, m, 0, n);
|
|
n = n % 128;
|
|
for (i in 0...256) x[i] = 0;
|
|
for (i in 0...n) x[i] = m[b - n + i];
|
|
x[n] = 128;
|
|
var sz = 256 - 128 * (n < 112 ? 1 : 0);
|
|
x[sz - 9] = 0;
|
|
ts64u(x, sz - 8, u64(Std.int(b / 0x20000000), b << 3));
|
|
crypto_hashblocks(h, x, 0, sz);
|
|
for (i in 0...64) out[i] = h[i];
|
|
return 0;
|
|
}
|
|
|
|
static function edAdd(p:Array<Array<Float>>, q:Array<Array<Float>>):Void {
|
|
var a = gf(), b = gf(), c = gf(), d = gf(), e = gf(), f = gf(), g = gf(), h = gf(), t = gf();
|
|
Z(a, p[1], p[0]); Z(t, q[1], q[0]); M(a, a, t);
|
|
A(b, p[0], p[1]); A(t, q[0], q[1]); M(b, b, t);
|
|
M(c, p[3], q[3]); M(c, c, D2);
|
|
M(d, p[2], q[2]); A(d, d, d);
|
|
Z(e, b, a); Z(f, d, c); A(g, d, c); A(h, b, a);
|
|
M(p[0], e, f); M(p[1], h, g); M(p[2], g, f); M(p[3], e, h);
|
|
}
|
|
|
|
static function cswap(p:Array<Array<Float>>, q:Array<Array<Float>>, b:Int):Void {
|
|
for (i in 0...4) sel25519(p[i], q[i], b);
|
|
}
|
|
|
|
static function edPack(r:Array<Int>, p:Array<Array<Float>>):Void {
|
|
var tx = gf(), ty = gf(), zi = gf();
|
|
inv25519(zi, p[2]); M(tx, p[0], zi); M(ty, p[1], zi);
|
|
pack25519(r, ty);
|
|
r[31] ^= par25519(tx) << 7;
|
|
}
|
|
|
|
static function edScalarmult(p:Array<Array<Float>>, q:Array<Array<Float>>, s:Array<Int>):Void {
|
|
set25519(p[0], gf0); set25519(p[1], gf1); set25519(p[2], gf1); set25519(p[3], gf0);
|
|
var i = 255; while (i >= 0) {
|
|
var b = (s[Std.int(i / 8)] >> (i & 7)) & 1;
|
|
cswap(p, q, b);
|
|
edAdd(q, p);
|
|
edAdd(p, p);
|
|
cswap(p, q, b);
|
|
i--;
|
|
}
|
|
}
|
|
|
|
static function edScalarbase(p:Array<Array<Float>>, s:Array<Int>):Void {
|
|
var q = [gf(), gf(), gf(), gf()];
|
|
set25519(q[0], X); set25519(q[1], Y); set25519(q[2], gf1);
|
|
M(q[3], X, Y);
|
|
edScalarmult(p, q, s);
|
|
}
|
|
|
|
static function crypto_sign_keypair(pk:Array<Int>, sk:Array<Int>, seeded:Bool, randomFn:Int->Array<Int>):Int {
|
|
var d = [for (i in 0...64) 0];
|
|
var p = [gf(), gf(), gf(), gf()];
|
|
if (!seeded) {
|
|
var rb = randomFn(32);
|
|
for (i in 0...32) sk[i] = rb[i];
|
|
}
|
|
crypto_hash(d, sk, 32);
|
|
d[0] &= 248; d[31] &= 127; d[31] |= 64;
|
|
edScalarbase(p, d);
|
|
edPack(pk, p);
|
|
for (i in 0...32) sk[i + 32] = pk[i];
|
|
return 0;
|
|
}
|
|
|
|
static function modL(r:Array<Int>, roff:Int, x:Array<Float>):Void {
|
|
var carry:Int, i:Int, j:Int, k:Int;
|
|
i = 63; while (i >= 32) {
|
|
carry = 0;
|
|
j = i - 32; k = i - 12;
|
|
while (j < k) {
|
|
x[j] += carry - 16 * x[i] * L[j - (i - 32)];
|
|
carry = Std.int(Math.floor((x[j] + 128) / 256));
|
|
x[j] -= carry * 256;
|
|
j++;
|
|
}
|
|
x[j] += carry;
|
|
x[i] = 0;
|
|
i--;
|
|
}
|
|
carry = 0;
|
|
for (j in 0...32) {
|
|
x[j] += carry - (Std.int(x[31]) >> 4) * L[j];
|
|
carry = Std.int(x[j]) >> 8;
|
|
x[j] = Std.int(x[j]) & 255;
|
|
}
|
|
for (j in 0...32) x[j] -= carry * L[j];
|
|
for (i in 0...32) {
|
|
x[i + 1] += Std.int(x[i]) >> 8;
|
|
r[roff + i] = Std.int(x[i]) & 255;
|
|
}
|
|
}
|
|
|
|
static function reduce(r:Array<Int>):Void {
|
|
var x = [for (i in 0...64) 0.0];
|
|
for (i in 0...64) x[i] = r[i];
|
|
for (i in 0...64) r[i] = 0;
|
|
modL(r, 0, x);
|
|
}
|
|
|
|
static function crypto_sign(sm:Array<Int>, m:Array<Int>, n:Int, sk:Array<Int>):Int {
|
|
var d = [for (i in 0...64) 0], h = [for (i in 0...64) 0], r = [for (i in 0...64) 0];
|
|
var x = [for (i in 0...64) 0.0];
|
|
var p = [gf(), gf(), gf(), gf()];
|
|
crypto_hash(d, sk, 32);
|
|
d[0] &= 248; d[31] &= 127; d[31] |= 64;
|
|
for (i in 0...n) sm[64 + i] = m[i];
|
|
for (i in 0...32) sm[32 + i] = d[32 + i];
|
|
var sm32 = [for (i in 0...n + 32) 0];
|
|
for (i in 0...n + 32) sm32[i] = sm[32 + i];
|
|
crypto_hash(r, sm32, n + 32);
|
|
reduce(r);
|
|
edScalarbase(p, r);
|
|
edPack(sm, p);
|
|
for (i in 32...64) sm[i] = sk[i];
|
|
var smFull = [for (i in 0...n + 64) 0];
|
|
for (i in 0...n + 64) smFull[i] = sm[i];
|
|
crypto_hash(h, smFull, n + 64);
|
|
reduce(h);
|
|
for (i in 0...64) x[i] = 0;
|
|
for (i in 0...32) x[i] = r[i];
|
|
for (i in 0...32) for (j in 0...32) x[i + j] += h[i] * d[j];
|
|
modL(sm, 32, x);
|
|
return n + 64;
|
|
}
|
|
|
|
static function unpackneg(r:Array<Array<Float>>, p:Array<Int>):Int {
|
|
var t = gf(), chk = gf(), num = gf(), den = gf(), den2 = gf(), den4 = gf(), den6 = gf();
|
|
set25519(r[2], gf1);
|
|
unpack25519(r[1], p);
|
|
S(num, r[1]); M(den, num, D); Z(num, num, r[2]); A(den, r[2], den);
|
|
S(den2, den); S(den4, den2); M(den6, den4, den2);
|
|
M(t, den6, num); M(t, t, den);
|
|
pow2523(t, t);
|
|
M(t, t, num); M(t, t, den); M(t, t, den);
|
|
M(r[0], t, den);
|
|
S(chk, r[0]); M(chk, chk, den);
|
|
if (neq25519(chk, num) != 0) M(r[0], r[0], I);
|
|
S(chk, r[0]); M(chk, chk, den);
|
|
if (neq25519(chk, num) != 0) return -1;
|
|
if (par25519(r[0]) == (p[31] >> 7)) Z(r[0], gf0, r[0]);
|
|
M(r[3], r[0], r[1]);
|
|
return 0;
|
|
}
|
|
|
|
static function crypto_sign_open(m:Array<Int>, sm:Array<Int>, n:Int, pk:Array<Int>):Int {
|
|
var t = [for (i in 0...32) 0], h = [for (i in 0...64) 0];
|
|
var p = [gf(), gf(), gf(), gf()], q = [gf(), gf(), gf(), gf()];
|
|
if (n < 64) return -1;
|
|
if (unpackneg(q, pk) != 0) return -1;
|
|
for (i in 0...n) m[i] = sm[i];
|
|
for (i in 0...32) m[i + 32] = pk[i];
|
|
crypto_hash(h, m, n);
|
|
reduce(h);
|
|
edScalarmult(p, q, h);
|
|
var sm32 = [for (i in 0...32) 0];
|
|
for (i in 0...32) sm32[i] = sm[32 + i];
|
|
edScalarbase(q, sm32);
|
|
edAdd(p, q);
|
|
edPack(t, p);
|
|
n -= 64;
|
|
if (crypto_verify_32(sm, 0, t, 0) != 0) {
|
|
for (i in 0...n) m[i] = 0;
|
|
return -1;
|
|
}
|
|
for (i in 0...n) m[i] = sm[i + 64];
|
|
return n;
|
|
}
|
|
|
|
public static inline var crypto_box_PUBLICKEYBYTES = 32;
|
|
public static inline var crypto_box_SECRETKEYBYTES = 32;
|
|
public static inline var crypto_box_NONCEBYTES = 24;
|
|
public static inline var crypto_box_ZEROBYTES = 32;
|
|
public static inline var crypto_box_BOXZEROBYTES = 16;
|
|
public static inline var crypto_sign_BYTES = 64;
|
|
public static inline var crypto_sign_PUBLICKEYBYTES = 32;
|
|
public static inline var crypto_sign_SECRETKEYBYTES = 64;
|
|
public static inline var crypto_sign_SEEDBYTES = 32;
|
|
public static inline var crypto_hash_BYTES = 64;
|
|
|
|
public static function hash(msg:Bytes):Bytes {
|
|
var m = bytesToArray(msg);
|
|
var out = [for (i in 0...64) 0];
|
|
crypto_hash(out, m, msg.length);
|
|
return arrayToBytes(out);
|
|
}
|
|
|
|
public static function signDetached(msg:Bytes, secretKey:Bytes):Bytes {
|
|
var m = bytesToArray(msg);
|
|
var sk = bytesToArray(secretKey);
|
|
var sm = [for (i in 0...crypto_sign_BYTES + msg.length) 0];
|
|
crypto_sign(sm, m, msg.length, sk);
|
|
var sig = [for (i in 0...crypto_sign_BYTES) 0];
|
|
for (i in 0...crypto_sign_BYTES) sig[i] = sm[i];
|
|
return arrayToBytes(sig);
|
|
}
|
|
|
|
public static function signDetachedVerify(msg:Bytes, sig:Bytes, publicKey:Bytes):Bool {
|
|
var sm = [for (i in 0...crypto_sign_BYTES + msg.length) 0];
|
|
var m = [for (i in 0...crypto_sign_BYTES + msg.length) 0];
|
|
var sigArr = bytesToArray(sig);
|
|
var msgArr = bytesToArray(msg);
|
|
for (i in 0...crypto_sign_BYTES) sm[i] = sigArr[i];
|
|
for (i in 0...msg.length) sm[i + crypto_sign_BYTES] = msgArr[i];
|
|
var pk = bytesToArray(publicKey);
|
|
return crypto_sign_open(m, sm, sm.length, pk) >= 0;
|
|
}
|
|
|
|
public static function signKeyPairFromSeed(seed:Bytes):{publicKey:Bytes, secretKey:Bytes} {
|
|
var pk = [for (i in 0...32) 0];
|
|
var sk = [for (i in 0...64) 0];
|
|
var seedArr = bytesToArray(seed);
|
|
for (i in 0...32) sk[i] = seedArr[i];
|
|
crypto_sign_keypair(pk, sk, true, null);
|
|
return {publicKey: arrayToBytes(pk), secretKey: arrayToBytes(sk)};
|
|
}
|
|
|
|
public static function boxKeyPair():{publicKey:Bytes, secretKey:Bytes} {
|
|
var pk = [for (i in 0...32) 0];
|
|
var sk = [for (i in 0...32) 0];
|
|
crypto_box_keypair(pk, sk, randomBytesArray);
|
|
return {publicKey: arrayToBytes(pk), secretKey: arrayToBytes(sk)};
|
|
}
|
|
|
|
public static function box(msg:Bytes, nonce:Bytes, publicKey:Bytes, secretKey:Bytes):Bytes {
|
|
var m = [for (i in 0...crypto_box_ZEROBYTES + msg.length) 0];
|
|
var c = [for (i in 0...m.length) 0];
|
|
var msgArr = bytesToArray(msg);
|
|
for (i in 0...msg.length) m[i + crypto_box_ZEROBYTES] = msgArr[i];
|
|
var n = bytesToArray(nonce);
|
|
var pk = bytesToArray(publicKey);
|
|
var sk = bytesToArray(secretKey);
|
|
crypto_box(c, m, m.length, n, pk, sk);
|
|
var result = [for (i in 0...c.length - crypto_box_BOXZEROBYTES) 0];
|
|
for (i in 0...result.length) result[i] = c[i + crypto_box_BOXZEROBYTES];
|
|
return arrayToBytes(result);
|
|
}
|
|
|
|
public static function boxOpen(box:Bytes, nonce:Bytes, publicKey:Bytes, secretKey:Bytes):Bytes {
|
|
var c = [for (i in 0...crypto_box_BOXZEROBYTES + box.length) 0];
|
|
var m = [for (i in 0...c.length) 0];
|
|
var boxArr = bytesToArray(box);
|
|
for (i in 0...box.length) c[i + crypto_box_BOXZEROBYTES] = boxArr[i];
|
|
if (c.length < 32) return null;
|
|
var n = bytesToArray(nonce);
|
|
var pk = bytesToArray(publicKey);
|
|
var sk = bytesToArray(secretKey);
|
|
if (crypto_box_open(m, c, c.length, n, pk, sk) != 0) return null;
|
|
var result = [for (i in 0...m.length - crypto_box_ZEROBYTES) 0];
|
|
for (i in 0...result.length) result[i] = m[i + crypto_box_ZEROBYTES];
|
|
return arrayToBytes(result);
|
|
}
|
|
|
|
public static var boxNonceLength(get, null):Int;
|
|
static inline function get_boxNonceLength():Int { return crypto_box_NONCEBYTES; }
|
|
|
|
static function bytesToArray(b:Bytes):Array<Int> {
|
|
var a = [for (i in 0...b.length) 0];
|
|
for (i in 0...b.length) a[i] = b.get(i);
|
|
return a;
|
|
}
|
|
|
|
static function arrayToBytes(a:Array<Int>):Bytes {
|
|
var b = Bytes.alloc(a.length);
|
|
for (i in 0...a.length) b.set(i, a[i] & 0xff);
|
|
return b;
|
|
}
|
|
|
|
static function randomBytesArray(n:Int):Array<Int> {
|
|
var b = Crypto.randomBytes(n);
|
|
var a = [for (i in 0...n) 0];
|
|
for (i in 0...n) a[i] = b.get(i);
|
|
return a;
|
|
}
|
|
}
|