blake!

10 files changed, 336 insertions, 34 deletions

diff --git a/src/crypto.c b/src/crypto.c
index b99add7..8070eee 100644
--- a/src/crypto.c
+++ b/src/crypto.c
@@ -1,17 +1,17 @@
 #include "crypto.h"
 
-unsigned i_lr(unsigned y, unsigned offset){
+unsigned rotl32(unsigned y, unsigned offset){
     return ( y << offset ) | ( y >> (32 - offset));
 }
 
-unsigned i_rr(unsigned x, unsigned n) {
+unsigned rotr32(unsigned x, unsigned n) {
     return (x >> n % 32) | (x << (32-n) % 32);
 }
 
-uint64_t i_lr64(uint64_t y, uint64_t offset){
+uint64_t rotl64(uint64_t y, uint64_t offset){
     return ( y << offset ) | ( y >> (64 - offset));
 }
 
-uint64_t i_rr64(uint64_t x, uint64_t n) {
+uint64_t rotr64(uint64_t x, uint64_t n) {
     return (x >> n) | (x << (64-n));
-}
+}
\ No newline at end of file
diff --git a/src/crypto.h b/src/crypto.h
index 8fd83a5..400e503 100644
--- a/src/crypto.h
+++ b/src/crypto.h
@@ -26,15 +26,16 @@
 #include "hash/sha2-256.h"
 #include "hash/spookyhash.h"
 #include "hash/blake2.h"
+#include "hash/blake.h"
 
 #include "encode/uuencode.h"
 #include "encode/base64.h"
 #include "encode/baseN.h"
 
-unsigned i_lr(unsigned, unsigned);
-unsigned i_rr(unsigned, unsigned);
-uint64_t i_lr64(uint64_t, uint64_t);
-uint64_t i_rr64(uint64_t, uint64_t);
+unsigned rotl32(unsigned, unsigned);
+unsigned rotr32(unsigned, unsigned);
+uint64_t rotl64(uint64_t, uint64_t);
+uint64_t rotr64(uint64_t, uint64_t);
 
 
 static const luaL_Reg crypto_function_list [] = {
@@ -56,7 +57,8 @@ static const luaL_Reg crypto_function_list [] = {
       {"spookyhash128_v1", l_spookyhash128_v1}, {"spookyhash128_v2", l_spookyhash128_v2},
       {"spookyhash64_v1", l_spookyhash64_v1}, {"spookyhash64_v2", l_spookyhash64_v2},
       {"spookyhash32_v1", l_spookyhash32_v1}, {"spookyhash32_v2", l_spookyhash32_v2},
-      {"blake2b", l_blake2b}, {"blake2s", l_blake2s},
+      {"blake2b", l_blake2b}, {"blake2s", l_blake2s}, {"blake256", l_blake256},
+      {"blake224", l_blake224}, {"blake512", l_blake512}, {"blake384", l_blake384},
 
 
       {"uuencode",l_uuencode},
diff --git a/src/hash/blake.c b/src/hash/blake.c
new file mode 100644
index 0000000..b1df1f7
--- /dev/null
+++ b/src/hash/blake.c
@@ -0,0 +1,271 @@
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdlib.h>
+#include "../crypto.h"
+#include "../util.h"
+
+const uint8_t blake_sigma[][16] = {
+  { 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 },
+  {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 }
+};
+
+const uint32_t blake_u256[16] = {
+  0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+  0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+  0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+  0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917
+};
+
+const uint64_t blake_u512[16] = {
+  0x243f6a8885a308d3ULL, 0x13198a2e03707344ULL, 
+  0xa4093822299f31d0ULL, 0x082efa98ec4e6c89ULL,
+  0x452821e638d01377ULL, 0xbe5466cf34e90c6cULL, 
+  0xc0ac29b7c97c50ddULL, 0x3f84d5b5b5470917ULL,
+  0x9216d5d98979fb1bULL, 0xd1310ba698dfb5acULL, 
+  0x2ffd72dbd01adfb7ULL, 0xb8e1afed6a267e96ULL,
+  0xba7c9045f12c7f99ULL, 0x24a19947b3916cf7ULL, 
+  0x0801f2e2858efc16ULL, 0x636920d871574e69ULL
+};
+
+#define blake_round_256(a,b,c,d,e)          \
+  v[a] += (m[blake_sigma[i][e]] ^ blake_u256[blake_sigma[i][e+1]]) + v[b]; \
+  v[d] = rotr32( v[d] ^ v[a],16);        \
+  v[c] += v[d];           \
+  v[b] = rotr32( v[b] ^ v[c],12);        \
+  v[a] += (m[blake_sigma[i][e+1]] ^ blake_u256[blake_sigma[i][e]])+v[b]; \
+  v[d] = rotr32( v[d] ^ v[a], 8);        \
+  v[c] += v[d];           \
+  v[b] = rotr32( v[b] ^ v[c], 7);
+
+void compress256(uint32_t* hash, char *block, uint64_t compressed){
+  uint32_t v[16], m[16], i;
+
+  for(int i = 0; i < 16; i++)  m[i] = wtf((block + i * 4));
+
+  for(int i = 0; i < 8; i++)  v[i] = hash[i];
+
+  for(int i = 0; i != 8; i++)
+    v[i + 8] = blake_u256[i];
+
+  v[12] ^= (uint32_t)compressed;
+  v[13] ^= (uint32_t)compressed;
+  v[14] ^= compressed >> 32;
+  v[15] ^= compressed >> 32;
+
+  for(int i = 0; i < 14; i++){
+    blake_round_256( 0,  4,  8, 12,  0 );
+    blake_round_256( 1,  5,  9, 13,  2 );
+    blake_round_256( 2,  6, 10, 14,  4 );
+    blake_round_256( 3,  7, 11, 15,  6 );
+
+    blake_round_256( 0,  5, 10, 15,  8 );
+    blake_round_256( 1,  6, 11, 12, 10 );
+    blake_round_256( 2,  7,  8, 13, 12 );
+    blake_round_256( 3,  4,  9, 14, 14 );
+  }
+
+  for(int i = 0; i < 16; i++)  hash[i % 8] ^= v[i];
+}
+
+void blake256(char *out, char *in, uint64_t inlen, enum blake256_v v){
+    uint32_t hash[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 
+            0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
+    if(v == b224){
+        hash[0] = 0xc1059ed8;
+        hash[1] = 0x367cd507;
+        hash[2] = 0x3070dd17;
+        hash[3] = 0xf70e5939;
+        hash[4] = 0xffc00b31;
+        hash[5] = 0x68581511;
+        hash[6] = 0x64f98fa7;
+        hash[7] = 0xbefa4fa4;
+    }
+
+    int aw = inter(inlen, 64);
+    uint64_t compressed = 0;
+    char* owo = calloc(aw, sizeof * owo);
+    memcpy(owo, in, inlen);
+
+    owo[inlen] = 0x80;
+
+    if(inlen == 55){
+        owo[inlen] = v==b256?0x81:0x80;
+    } else {
+        owo[aw - 9] = v==b256?0x01:0x00;
+    }
+
+    U32TO8_BIG(owo + aw - 8, 0x0);
+    U32TO8_BIG(owo + aw - 4, inlen << 3);
+
+    for(; aw >= 64;){
+        compressed += 64;
+        if(aw == 64) compressed = inlen;
+
+        compress256(hash, owo, compressed * 8);
+        aw -= 64;
+        owo += 64;
+    }
+
+    for(int i = 0; i != (v==b256?8:7); i++){
+        sprintf(out, "%s%08x",out,(hash)[i]);
+    }
+}
+
+#define blake_round_512(a,b,c,d,e)          \
+  v[a] += (m[blake_sigma[i][e]] ^ blake_u512[blake_sigma[i][e+1]]) + v[b];\
+  v[d] = rotr64( v[d] ^ v[a],32);        \
+  v[c] += v[d];           \
+  v[b] = rotr64( v[b] ^ v[c],25);        \
+  v[a] += (m[blake_sigma[i][e+1]] ^ blake_u512[blake_sigma[i][e]])+v[b];  \
+  v[d] = rotr64( v[d] ^ v[a],16);        \
+  v[c] += v[d];           \
+  v[b] = rotr64( v[b] ^ v[c],11);
+
+void compress512(uint64_t* hash, uint8_t *block, uint64_t compressed){
+  uint64_t v[16], m[16], i;
+
+   for( i = 0; i < 16; ++i )  m[i] = U8TO64_BIG( block + i * 8 );
+
+  for(int i = 0; i < 8; i++)  v[i] = hash[i];
+
+  for(int i = 0; i != 8; i++)
+    v[i + 8] = blake_u512[i];
+
+  v[12] ^= compressed;
+  v[13] ^= compressed;
+  v[14] ^= 0;
+  v[15] ^= 0;
+
+
+  for(i = 0; i < 16; i++){
+    blake_round_512(0, 4, 8, 12, 0);
+    blake_round_512(1, 5, 9, 13, 2);
+    blake_round_512(2, 6, 10, 14, 4);
+    blake_round_512(3, 7, 11, 15, 6);
+
+    blake_round_512(0, 5, 10, 15, 8);
+    blake_round_512(1, 6, 11, 12, 10);
+    blake_round_512(2, 7, 8, 13, 12);
+    blake_round_512(3, 4, 9, 14, 14);
+    
+  }
+
+  for(int i = 0; i < 16; i++)  hash[i % 8] ^= v[i];
+}
+
+void blake512(char *out, char *in, uint64_t inlen, enum blake512_v v){
+    uint64_t hash[8] = {0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL, 
+        0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL};
+    
+    if(v == b384){
+        hash[0] = 0xcbbb9d5dc1059ed8ULL;
+        hash[1] = 0x629a292a367cd507ULL;
+        hash[2] = 0x9159015a3070dd17ULL;
+        hash[3] = 0x152fecd8f70e5939ULL;
+        hash[4] = 0x67332667ffc00b31ULL;
+        hash[5] = 0x8eb44a8768581511ULL;
+        hash[6] = 0xdb0c2e0d64f98fa7ULL;
+        hash[7] = 0x47b5481dbefa4fa4ULL;
+    }
+
+    int aw = inter(inlen, 128);
+    uint64_t compressed = 0;
+    uint8_t* owo = calloc(aw, sizeof * owo);
+    memcpy(owo, in, inlen);
+
+    owo[inlen] = 0x80;
+
+    if(inlen == 111){
+        owo[inlen] = v==b512?0x81:0x80;
+    } else {
+        owo[aw - 17] = v==b512?0x01:0x00;
+    }
+
+    U64TO8_BIG(owo + aw - 8, inlen << 3);
+
+    for(; aw >= 128;){
+        compressed += 128;
+        if(aw == 128) compressed = inlen;
+
+        compress512(hash, owo, compressed * 8);
+        aw -= 128;
+        owo += 128;
+    }
+
+    for(int i = 0; i != (v==b512?8:6); i++){
+        sprintf(out, "%s%016llx",out, (hash)[i]);
+    }
+}
+
+int l_blake256(lua_State* L){
+    size_t len = 0;
+    char* a = (char*)luaL_checklstring(L, 1, &len);
+    int argv = lua_gettop(L); 
+
+    char digest[257] = {0};
+    memset(digest, 0, 257);
+
+    blake256(digest, a, len, b256);
+    lua_pushstring(L, digest);
+
+    return 1;
+}
+
+int l_blake224(lua_State* L){
+    size_t len = 0;
+    char* a = (char*)luaL_checklstring(L, 1, &len);
+    int argv = lua_gettop(L); 
+
+    char digest[257] = {0};
+    memset(digest, 0, 257);
+
+    blake256(digest, a, len, b224);
+    lua_pushstring(L, digest);
+
+    return 1;
+}
+
+int l_blake512(lua_State* L){
+    size_t len = 0;
+    char* a = (char*)luaL_checklstring(L, 1, &len);
+    int argv = lua_gettop(L); 
+
+    char digest[513] = {0};
+    memset(digest, 0, 513);
+
+    blake512(digest, a, len, b512);
+    lua_pushstring(L, digest);
+
+    return 1;
+}
+
+int l_blake384(lua_State* L){
+    size_t len = 0;
+    char* a = (char*)luaL_checklstring(L, 1, &len);
+    int argv = lua_gettop(L); 
+
+    char digest[513] = {0};
+    memset(digest, 0, 513);
+
+    blake512(digest, a, len, b384);
+    lua_pushstring(L, digest);
+
+    return 1;
+}
\ No newline at end of file
diff --git a/src/hash/blake.h b/src/hash/blake.h
new file mode 100644
index 0000000..05bdaab
--- /dev/null
+++ b/src/hash/blake.h
@@ -0,0 +1,32 @@
+#include <stdint.h>
+#include "../lua.h"
+
+#define U8TO32_BIG(p)					      \
+  (((uint32_t)((p)[0]) << 24) | ((uint32_t)((p)[1]) << 16) |  \
+   ((uint32_t)((p)[2]) <<  8) | ((uint32_t)((p)[3])      ))
+
+#define U32TO8_BIG(p, v)				        \
+  (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
+  (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
+
+#define U8TO64_BIG(p) \
+  (((uint64_t)U8TO32_BIG(p) << 32) | (uint64_t)U8TO32_BIG((p) + 4))
+
+#define U64TO8_BIG(p, v)		      \
+  U32TO8_BIG((p),     (uint32_t)((v) >> 32)); \
+  U32TO8_BIG((p) + 4, (uint32_t)((v)      ));
+
+#define wtf(b) (b[0] << 24)&0xff000000 | (b[1] << 16)&0xff0000 | (b[2] << 8)&0xff00 | b[3]&0xff
+
+enum blake256_v {
+    b256, b224
+};
+
+enum blake512_v {
+    b512, b384
+};
+
+int l_blake256(lua_State* L);
+int l_blake224(lua_State* L);
+int l_blake512(lua_State* L);
+int l_blake384(lua_State* L);
\ No newline at end of file
diff --git a/src/hash/blake2.c b/src/hash/blake2.c
index aeb48ad..2da4cd0 100644
--- a/src/hash/blake2.c
+++ b/src/hash/blake2.c
@@ -3,17 +3,10 @@
 #include <string.h>

 #include <stdlib.h>

 #include <math.h>

-#include "sha2-256.h"

-#include "blake2.h"

+#include "../crypto.h"

+//#include "blake2.h"

 #include "../util.h"

 

-uint64_t rotr64(uint64_t w, unsigned c){

-  return (w >> c) | (w << (64 - c));

-}

-uint32_t rotr32(uint32_t w, unsigned c){

-  return (w >> c) | (w << (32 - c));

-}

-

 void mix2b(uint64_t* a, uint64_t* b, uint64_t* c, uint64_t* d, int64_t x, int64_t y){

     *a = *a + *b + x;

     *d = rotr64((*d ^  *a), 32);

diff --git a/src/hash/md5.c b/src/hash/md5.c
index a909819..fd8320c 100644
--- a/src/hash/md5.c
+++ b/src/hash/md5.c
@@ -72,7 +72,7 @@ void i_md5(char* input, size_t len, char out_stream[64]){
       uint32_t temp = D; 
       D = C;
       C = B;
-      B = B + i_lr(F, s[i]);
+      B = B + rotl32(F, s[i]);
       A = temp;
     }
 
diff --git a/src/hash/sha01.c b/src/hash/sha01.c
index b8b70f9..87b9273 100644
--- a/src/hash/sha01.c
+++ b/src/hash/sha01.c
@@ -37,7 +37,7 @@ void i_sha01(uint8_t version, char* out_stream, int len, const char* input){
             }
         }
         for(int i = 16; i != 80; i++)
-            W[i] = i_lr(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], version);
+            W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], version);
             
         
         uint32_t a = h0;
@@ -63,10 +63,10 @@ void i_sha01(uint8_t version, char* out_stream, int len, const char* input){
                 k = 0xCA62C1D6;
             }
             
-            uint32_t temp = i_lr(a, 5) + f + e + k + W[i];
+            uint32_t temp = rotl32(a, 5) + f + e + k + W[i];
             e = d;
             d = c;
-            c = i_lr(b, 30);
+            c = rotl32(b, 30);
             b = a;
             a = temp;
         }
diff --git a/src/hash/sha2-256.c b/src/hash/sha2-256.c
index 32af13a..d06c4b4 100644
--- a/src/hash/sha2-256.c
+++ b/src/hash/sha2-256.c
@@ -78,8 +78,8 @@ void sha512_gen(uint64_t* out_stream, uint8_t* input, size_t len, struct iv sha_
         }
 
         for (int i = 16; i != 80; i++){
-            W[i] = (i_rr64(W[i - 2],19) ^ i_rr64(W[i - 2], 61) ^ (W[i - 2] >> 6)) 
-                + W[i - 7] + (i_rr64(W[i - 15],1) ^ i_rr64(W[i - 15],8) ^ (W[i - 15] >> 7)) + W[i - 16];
+            W[i] = (rotr64(W[i - 2],19) ^ rotr64(W[i - 2], 61) ^ (W[i - 2] >> 6)) 
+                + W[i - 7] + (rotr64(W[i - 15],1) ^ rotr64(W[i - 15],8) ^ (W[i - 15] >> 7)) + W[i - 16];
         }
 
         uint64_t a = h0;
@@ -92,11 +92,11 @@ void sha512_gen(uint64_t* out_stream, uint8_t* input, size_t len, struct iv sha_
         uint64_t h = h7;
         
         for(int i = 0; i != 80; i++){
-            uint64_t S1 = i_rr64(e, 14) ^ i_rr64(e, 18) ^ i_rr64(e, 41);
+            uint64_t S1 = rotr64(e, 14) ^ rotr64(e, 18) ^ rotr64(e, 41);
             uint64_t ch = (e & f) ^ ((~e) & g);
             uint64_t temp1 = h + S1 + ch + k[i] + W[i];
             
-            uint64_t S0 = i_rr64(a, 28) ^ i_rr64(a, 34) ^ i_rr64(a, 39);
+            uint64_t S0 = rotr64(a, 28) ^ rotr64(a, 34) ^ rotr64(a, 39);
             uint64_t maj = (a & b) ^ (a & c) ^ (b & c);
             uint64_t temp2 = S0 + maj;
             
diff --git a/src/hash/sha2xx.c b/src/hash/sha2xx.c
index 00dd286..eafcc09 100644
--- a/src/hash/sha2xx.c
+++ b/src/hash/sha2xx.c
@@ -58,8 +58,8 @@ void i_sha2xx(enum version v, char* out_stream, char* input){
 		    W[i] = (by[i * 4] << 24) | (by[i * 4 + 1] << 16) | (by[i * 4 + 2] << 8) | (by[i * 4 + 3]);
 		
         for(int i = 16; i != 64; i++){
-            uint32_t s0 = i_rr(W[i - 15], 7) ^ i_rr(W[i - 15], 18) ^ (W[i - 15] >> 3);
-            uint32_t s1 = i_rr(W[i - 2], 17) ^ i_rr(W[i - 2], 19) ^ (W[i - 2] >> 10);
+            uint32_t s0 = rotr32(W[i - 15], 7) ^ rotr32(W[i - 15], 18) ^ (W[i - 15] >> 3);
+            uint32_t s1 = rotr32(W[i - 2], 17) ^ rotr32(W[i - 2], 19) ^ (W[i - 2] >> 10);
             W[i] = W[i - 16] + s0 + W[i - 7] + s1;
         }
         
@@ -73,11 +73,11 @@ void i_sha2xx(enum version v, char* out_stream, char* input){
         uint32_t h = h7;
         
         for(int i = 0; i != 64; i++){
-            uint32_t S1 = i_rr(e, 6) ^ i_rr(e, 11) ^ i_rr(e, 25);
+            uint32_t S1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
             uint32_t ch = (e & f) ^ ((~e) & g);
             uint32_t temp1 = h + S1 + ch + k[i] + W[i];
             
-            uint32_t S0 = i_rr(a, 2) ^ i_rr(a, 13) ^ i_rr(a, 22);
+            uint32_t S0 = rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22);
             uint32_t maj = (a & b) ^ (a & c) ^ (b & c);
             uint32_t temp2 = S0 + maj;
             
diff --git a/tests/hash.lua b/tests/hash.lua
index 6bd3295..c72d08c 100644
--- a/tests/hash.lua
+++ b/tests/hash.lua
@@ -10,7 +10,7 @@ function test(name,b,exp,oargs)
     add = table.concat(oargs, ", ")
   end
   if not (hash == exp) then
-    llib.io.error(name.." not working, got \n\t"..hash.." wanted\n\t"..exp.."\n\twith args: {"..add.."}")
+    llib.io.error(name.." not working, got:\n\t"..hash.." wanted:\n\t"..exp.."\n\twith args: {"..add.."}")
   else
     llib.io.log(name.." was correct, "..hash)
   end
@@ -63,5 +63,9 @@ test("murmur1_32","meow","743df82f")
 test("murmur2_32","meow","05d01b88")
 test("blake2b","meow","9919ae53fbea6c5da68e51b6e19a890fdbc01baf97fff29efd7efaa7163ea7aa205109b818bde29da815e16b869dbb2cb1b367ed1027f52116287d760808a43d")
 test("blake2b","meow","424969d2fe47cdec2a824709b8066cc1d63cc4b6a16a3c1fa421cc2a6625f7c2",{32})
-test("blake2b","meow","6f30dec70f9ed6d8db2e7407d3e2325af23935464ec3ec1cf4c12575ff3c18043bf772033b91d52978c451d01f7eaeacabda76460b9f4b7bf516dd9d0cc886d",{64,"owo"})
-test("blake2s","meow","f461bed24c982ccb29cb967acdaebc9494b51c1d0f88f6bc47850952261a512d")
\ No newline at end of file
+test("blake2b","meow","6f30fdec70f9ed6d8db2e7407d3e2325af23935464ec3ec1cf4c12575ff3c18043bf772033b91d52978c451d01f7eaeacabda76460b9f4b7bf516dd9d0cc886d",{64,"owo"})
+test("blake2s","meow","f461bed24c982ccb29cb967acdaebc9494b51c1d0f88f6bc47850952261a512d")
+test("blake256", "meow", "067805dd21a4ef97460c6613f231437917a1c1c7f1dcd1bfe67d952d09ccb028")
+test("blake224", "meow", "0a099d692027cfbe69d2424a5b2520a7398fa4945e0878f6c541f5ce")
+test("blake512", "meow", "09d5abe166c4ad855d4527d0be21df2b1a01c3d7c5637572561ebc247908fd7db30bf342391dd0a834fd35f391807480fb31e8a7ee3b1098e46d996d5601948f")
+test("blake384", "meow", "7edb2ff04616f5551a789217029496c3c8601ac7aba2d40d7fcd1ec85fc63f37514e5884f2ebc807b11854247620446c")
\ No newline at end of file