blake2s 纯翻译源码 看都没有纯易得 分享一下

crossdiy

感谢分享

光影魔术

感谢分享

一指温柔

学习一下

396384183

学习一下

pipicool

学习一下

汇编代码

.版本 2

.程序集 blake2b类, , 公开
.程序集变量 blake2b_v_, 长整数型, , "0"
.程序集变量 blake2b_w_, 字节型, , "0"
.程序集变量 blake2b_y_, 长整数型, , "0"
.程序集变量 blake2b_U_, 长整数型, , "0"

.子程序 _初始化, , , 当基于本类的对象被创建后，此方法会被自动调用

blake2b_v_ ＝ { 4089235720, 1779033703, 2227873595, 3144134277, 4271175723, 1013904242, 1595750129, 2773480762, 2917565137, 1359893119, 725511199, 2600822924, 4215389547, 528734635, 327033209, 1541459225 }
blake2b_w_ ＝ { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 28, 20, 8, 16, 18, 30, 26, 12, 2, 24, 0, 4, 22, 14, 10, 6, 22, 16, 24, 0, 10, 4, 30, 26, 20, 28, 6, 12, 14, 2, 18, 8, 14, 18, 6, 2, 26, 24, 22, 28, 4, 12, 10, 20, 8, 0, 30, 16, 18, 0, 10, 14, 4, 8, 20, 30, 28, 2, 22, 24, 12, 16, 6, 26, 4, 24, 12, 20, 0, 22, 16, 6, 8, 26, 14, 10, 30, 28, 2, 18, 24, 10, 2, 30, 28, 26, 8, 20, 0, 14, 12, 6, 18, 4, 16, 22, 26, 22, 14, 28, 24, 2, 6, 18, 10, 0, 30, 8, 16, 12, 4, 20, 12, 30, 28, 18, 22, 6, 0, 16, 24, 4, 26, 14, 2, 8, 20, 10, 20, 4, 16, 8, 14, 12, 2, 10, 30, 22, 18, 28, 6, 24, 26, 0, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 28, 20, 8, 16, 18, 30, 26, 12, 2, 24, 0, 4, 22, 14, 10, 6 }
重定义数组 (blake2b_y_, 假, 32)
重定义数组 (blake2b_U_, 假, 32)

.子程序 _销毁, , , 当基于本类的对象被销毁前，此方法会被自动调用



.子程序 blake2b, 字节集, 公开
.参数 data, 字节集
.参数 len, 整数型, , 提取长度
.参数 salt, 字节集, 可空, 盐值

返回 (blake2b_b (data, salt, len))

.子程序 blake2bHex, 文本型, 公开
.参数 data, 字节集
.参数 len, 整数型, , 提取长度
.参数 salt, 字节集, 可空, 盐值

返回 (bin2hex_ (blake2b_b (data, salt, len), 真))

.子程序 blake2bInit, blake2b数据类型
.参数 n, 整数型, , 0 < length <= 64
.参数 t, 字节集, , 0 < length <= 64

返回 (blake2b_f (n, t))

.子程序 blake2bUpdate
.参数 n, blake2b数据类型, 参考
.参数 t, 字节集

blake2b_l (n, t)

.子程序 blake2bFinal, 字节集
.参数 n, blake2b数据类型

返回 (blake2b_h (n))

.子程序 blake2b_o, 长整数型
.参数 n, 字节型, 数组
.参数 t, 整数型, , 0开始
.局部变量 tindex, 整数型
.局部变量 a, 长整数型
.局部变量 b, 长整数型
.局部变量 c, 长整数型
.局部变量 d, 长整数型

' function o(n, t) {
' return n[t] ^ n[t + 1] << 8 ^ n[t + 2] << 16 ^ n[t + 3] << 24
' }
tindex ＝ t ＋ 1
a ＝ n [tindex]
b ＝ 左移L (n [tindex ＋ 1], 8)
c ＝ 左移L (n [tindex ＋ 2], 16)
d ＝ 左移L (n [tindex ＋ 3], 24)
' 调试输出 (a, b, c, d)
返回 (位与L (位异或L (位异或L (位异或L (a, b), c), d), 4294967295))




.子程序 blake2b_t
.参数 n, 长整数型, 参考 数组
.参数 t, 整数型
.参数 o, 长整数型
.参数 u, 长整数型
.局部变量 tindex, 整数型
.局部变量 c, 长整数型
.局部变量 f, 长整数型

' function t(n, t, o, u) {
' var c = n[t] + o;
' o < 0 && (c += 4294967296);
' var f = n[t + 1] + u;
' c >= 4294967296 && f++,
' n[t] = c,
' n[t + 1] = f
' }
tindex ＝ t ＋ 1
c ＝ 加法_64 (n [tindex], o)
.如果真 (o ＜ 0)
    c ＝ 加法_64 (c, 4294967296)
.如果真结束
f ＝ 加法_64 (n [tindex ＋ 1], u)
.如果真 (c ≥ 4294967296)
    f ＝ 加法_64 (f, 1)
.如果真结束
n [tindex] ＝ 位与L (c, 4294967295)
n [tindex ＋ 1] ＝ 位与L (f, 4294967295)

.子程序 blake2b_n
.参数 n, 长整数型, 参考 数组
.参数 t, 整数型
.参数 o, 整数型
.局部变量 tindex, 整数型
.局部变量 oindex, 整数型
.局部变量 u, 长整数型
.局部变量 c, 长整数型

' function n(n, t, o) {
' var u = n[t] + n[o]
' , c = n[t + 1] + n[o + 1];
' u >= 4294967296 && c++,
' n[t] = u,
' n[t + 1] = c
' }
tindex ＝ t ＋ 1
oindex ＝ o ＋ 1
u ＝ 加法_64 (n [tindex], n [oindex])
c ＝ 加法_64 (n [tindex ＋ 1], n [oindex ＋ 1])
.如果真 (u ≥ 4294967296)
    c ＝ 加法_64 (c, 1)
.如果真结束
n [tindex] ＝ 位与L (u, 4294967295)
n [tindex ＋ 1] ＝ 位与L (c, 4294967295)

.子程序 blake2b_l
.参数 n, blake2b数据类型, 参考
.参数 t, 字节集
.局部变量 o, 整数型

' function l(n, t) {
' for (var o = 0; o < t.length; o++)
' 128 === n.c && (n.t += n.c,
' c(n, !1),
' n.c = 0),
' n.b[n.c++] = t[o]
' }

.计次循环首 (取字节集长度 (t), o)
    .如果真 (128 ＝ n.c)
        n.t ＝ n.t ＋ n.c
        blake2b_c (n, 假)
        n.c ＝ 0
    .如果真结束
    n.b [n.c ＋ 1] ＝ t [o]
    n.c ＝ n.c ＋ 1
.计次循环尾 ()

.子程序 blake2b_c
.参数 n, blake2b数据类型, 参考
.参数 t, 逻辑型
.局部变量 c, 整数型

' function c(n, t) {
' var c = 0;
' for (c = 0; c < 16; c++)
' y[c] = n.h[c],
' y[c + 16] = v[c];
' for (y[24] = y[24] ^ n.t,
' y[25] = y[25] ^ n.t / 4294967296,
' t && (y[28] = ~y[28],
' y[29] = ~y[29]),
' c = 0; c < 32; c++)
' U[c] = o(n.b, 4 * c);
' for (c = 0; c < 12; c++)
' u(0, 8, 16, 24, w[16 * c + 0], w[16 * c + 1]),
' u(2, 10, 18, 26, w[16 * c + 2], w[16 * c + 3]),
' u(4, 12, 20, 28, w[16 * c + 4], w[16 * c + 5]),
' u(6, 14, 22, 30, w[16 * c + 6], w[16 * c + 7]),
' u(0, 10, 20, 30, w[16 * c + 8], w[16 * c + 9]),
' u(2, 12, 22, 24, w[16 * c + 10], w[16 * c + 11]),
' u(4, 14, 16, 26, w[16 * c + 12], w[16 * c + 13]),
' u(6, 8, 18, 28, w[16 * c + 14], w[16 * c + 15]);
' for (c = 0; c < 16; c++)
' n.h[c] = n.h[c] ^ y[c] ^ y[c + 16]
' }

.计次循环首 (16, c)
    blake2b_y_ [c] ＝ n.h [c]
    blake2b_y_ [c ＋ 16] ＝ blake2b_v_ [c]
.计次循环尾 ()
blake2b_y_ [24 ＋ 1] ＝ 位与L (位异或L (blake2b_y_ [24 ＋ 1], n.t), 4294967295)
blake2b_y_ [25 ＋ 1] ＝ 位与L (位异或L (blake2b_y_ [25 ＋ 1], n.t ＼ 4294967296), 4294967295)
.如果真 (t ＝ 真)
    blake2b_y_ [28 ＋ 1] ＝ 位与L (位取反L (blake2b_y_ [28 ＋ 1]), 4294967295)
    blake2b_y_ [29 ＋ 1] ＝ 位与L (位取反L (blake2b_y_ [29 ＋ 1]), 4294967295)

.如果真结束

.计次循环首 (32, c)
    blake2b_U_ [c] ＝ blake2b_o (n.b, 4 × (c － 1))
.计次循环尾 ()

.计次循环首 (12, c)
    blake2b_u (0, 8, 16, 24, blake2b_w_ [16 × (c － 1) ＋ 0 ＋ 1], blake2b_w_ [16 × (c － 1) ＋ 1 ＋ 1])
    blake2b_u (2, 10, 18, 26, blake2b_w_ [16 × (c － 1) ＋ 2 ＋ 1], blake2b_w_ [16 × (c － 1) ＋ 3 ＋ 1])
    blake2b_u (4, 12, 20, 28, blake2b_w_ [16 × (c － 1) ＋ 4 ＋ 1], blake2b_w_ [16 × (c － 1) ＋ 5 ＋ 1])
    blake2b_u (6, 14, 22, 30, blake2b_w_ [16 × (c － 1) ＋ 6 ＋ 1], blake2b_w_ [16 × (c － 1) ＋ 7 ＋ 1])
    blake2b_u (0, 10, 20, 30, blake2b_w_ [16 × (c － 1) ＋ 8 ＋ 1], blake2b_w_ [16 × (c － 1) ＋ 9 ＋ 1])
    blake2b_u (2, 12, 22, 24, blake2b_w_ [16 × (c － 1) ＋ 10 ＋ 1], blake2b_w_ [16 × (c － 1) ＋ 11 ＋ 1])
    blake2b_u (4, 14, 16, 26, blake2b_w_ [16 × (c － 1) ＋ 12 ＋ 1], blake2b_w_ [16 × (c － 1) ＋ 13 ＋ 1])
    blake2b_u (6, 8, 18, 28, blake2b_w_ [16 × (c － 1) ＋ 14 ＋ 1], blake2b_w_ [16 × (c － 1) ＋ 15 ＋ 1])

.计次循环尾 ()
.计次循环首 (16, c)
    n.h [c] ＝ 位与L (位异或L (位异或L (n.h [c], blake2b_y_ [c]), blake2b_y_ [c ＋ 16]), 4294967295)
.计次循环尾 ()



.子程序 blake2b_u
.参数 o, 整数型
.参数 u, 整数型
.参数 c, 整数型
.参数 f, 整数型
.参数 l, 整数型
.参数 h, 整数型
.局部变量 b, 长整数型
.局部变量 v, 长整数型
.局部变量 w, 长整数型
.局部变量 A, 长整数型
.局部变量 p, 长整数型
.局部变量 k, 长整数型

' function u(o, u, c, f, l, h) {
' var b = U[l]
' , v = U[l + 1]
' , w = U[h]
' , A = U[h + 1];
' n(y, o, u),
' t(y, o, b, v);
' var p = y[f] ^ y[o]
' , k = y[f + 1] ^ y[o + 1];
' y[f] = k,
' y[f + 1] = p,
' n(y, c, f),
' p = y[u] ^ y[c],
' k = y[u + 1] ^ y[c + 1],
' y[u] = p >>> 24 ^ k << 8,
' y[u + 1] = k >>> 24 ^ p << 8,
' n(y, o, u),
' t(y, o, w, A),
' p = y[f] ^ y[o],
' k = y[f + 1] ^ y[o + 1],
' y[f] = p >>> 16 ^ k << 16,
' y[f + 1] = k >>> 16 ^ p << 16,
' n(y, c, f),
' p = y[u] ^ y[c],
' k = y[u + 1] ^ y[c + 1],
' y[u] = k >>> 31 ^ p << 1,
' y[u + 1] = p >>> 31 ^ k << 1
' }
b ＝ blake2b_U_ [l ＋ 1]
v ＝ blake2b_U_ [l ＋ 1 ＋ 1]
w ＝ blake2b_U_ [h ＋ 1]
A ＝ blake2b_U_ [h ＋ 1 ＋ 1]
blake2b_n (blake2b_y_, o, u)
blake2b_t (blake2b_y_, o, b, v)
p ＝ 位异或L (blake2b_y_ [f ＋ 1], blake2b_y_ [o ＋ 1])
k ＝ 位异或L (blake2b_y_ [f ＋ 1 ＋ 1], blake2b_y_ [o ＋ 1 ＋ 1])
blake2b_y_ [f ＋ 1] ＝ 位与L (k, 4294967295)
blake2b_y_ [f ＋ 1 ＋ 1] ＝ 位与L (p, 4294967295)
blake2b_n (blake2b_y_, c, f)

p ＝ 位异或L (blake2b_y_ [u ＋ 1], blake2b_y_ [c ＋ 1])
k ＝ 位异或L (blake2b_y_ [u ＋ 1 ＋ 1], blake2b_y_ [c ＋ 1 ＋ 1])
blake2b_y_ [u ＋ 1] ＝ 位与L (位异或L (右移L (p, 24), 左移L (k, 8)), 4294967295)
blake2b_y_ [u ＋ 1 ＋ 1] ＝ 位与L (位异或L (右移L (k, 24), 左移L (p, 8)), 4294967295)
blake2b_n (blake2b_y_, o, u)
blake2b_t (blake2b_y_, o, w, A)

p ＝ 位异或L (blake2b_y_ [f ＋ 1], blake2b_y_ [o ＋ 1])
k ＝ 位异或L (blake2b_y_ [f ＋ 1 ＋ 1], blake2b_y_ [o ＋ 1 ＋ 1])
blake2b_y_ [f ＋ 1] ＝ 位与L (位异或L (右移L (p, 16), 左移L (k, 16)), 4294967295)
blake2b_y_ [f ＋ 1 ＋ 1] ＝ 位与L (位异或L (右移L (k, 16), 左移L (p, 16)), 4294967295)
blake2b_n (blake2b_y_, c, f)

p ＝ 位异或L (blake2b_y_ [u ＋ 1], blake2b_y_ [c ＋ 1])
k ＝ 位异或L (blake2b_y_ [u ＋ 1 ＋ 1], blake2b_y_ [c ＋ 1 ＋ 1])
blake2b_y_ [u ＋ 1] ＝ 位与L (位异或L (右移L (k, 31), 左移L (p, 1)), 4294967295)
blake2b_y_ [u ＋ 1 ＋ 1] ＝ 位与L (位异或L (右移L (p, 31), 左移L (k, 1)), 4294967295)



.子程序 blake2b_h, 字节集
.参数 n, blake2b数据类型, 参考
.局部变量 t, 字节型, , "0"
.局部变量 o, 整数型
.局部变量 q, 长整数型

' function h(n) {
' for (n.t += n.c; n.c < 128; )
' n.b[n.c++] = 0;
' c(n, !0);
' for (var t = new Uint8Array(n.outlen), o = 0; o < n.outlen; o++)
' t[o] = n.h[o >> 2] >> 8 * (3 & o);
' return t
' }
n.t ＝ n.t ＋ n.c
.判断循环首 (n.c ＜ 128)
    n.b [n.c ＋ 1] ＝ 0
    n.c ＝ n.c ＋ 1
.判断循环尾 ()
blake2b_c (n, 真)
重定义数组 (t, 假, n.outlen)
.计次循环首 (n.outlen, o)
    q ＝ 右移L (n.h [右移L (o － 1, 2) ＋ 1], 8 × 位与L (3, o － 1))
    t [o] ＝ 取字节集数据 (到字节集 (q), #字节型, 1)
.计次循环尾 ()
返回 (到字节集 (t))

.子程序 blake2b_f, blake2b数据类型
.参数 n, 整数型, , 0 < length <= 64
.参数 t, 字节集, , 0 < length <= 64
.局部变量 o, blake2b数据类型
.局部变量 u, 整数型
.局部变量 c, 整数型

' function f(n, t) {
' if (0 === n || n > 64)
' throw new Error('Illegal output length, expected 0 < length <= 64');
' if (t && t.length > 64)
' throw new Error('Illegal key, expected Uint8Array with 0 < length <= 64');
' for (var o = {
' b: new Uint8Array(128),
' h: new Uint32Array(16),
' t: 0,
' c: 0,
' outlen: n
' }, u = 0; u < 16; u++)
' o.h[u] = v[u];
' var c = t ? t.length : 0;
' return o.h[0] ^= 16842752 ^ c << 8 ^ n,
' t && (l(o, t),
' o.c = 128),
' o
' }
.如果真 (0 ＝ n 或 n ＞ 64)
    返回 (o)
.如果真结束
.如果真 (取数组成员数 (t) ＞ 0 且 取数组成员数 (t) ＞ 64)
    返回 (o)
.如果真结束
o.outlen ＝ n
.计次循环首 (16, u)
    o.h [u] ＝ blake2b_v_ [u]
.计次循环尾 ()
c ＝ 选择 (取数组成员数 (t) ＞ 0, 取数组成员数 (t), 0)
o.h [1] ＝ 位异或L (o.h [1], 位异或L (位异或L (16842752, 左移L (c, 8)), n))
.如果真 (取数组成员数 (t) ＞ 0)
    blake2b_l (o, t)
    o.c ＝ 128
.如果真结束

返回 (o)

.子程序 blake2b_b, 字节集
.参数 n, 字节集, 参考
.参数 t, 字节集
.参数 o, 整数型
.局部变量 u, blake2b数据类型

' function b(n, t, o) {
' o = o || 64,
' n = r(d[0]).normalizeInput(n);
' var u = f(o, t);
' return l(u, n),
' h(u)
' }
o ＝ 选择 (o ＞ 0, o, 64)
u ＝ blake2b_f (o, t)
blake2b_l (u, n)
返回 (blake2b_h (u))