From ac965cf5e65a120134e5fe15be637a71ecd9ff60 Mon Sep 17 00:00:00 2001 From: ame Date: Fri, 12 Apr 2024 14:13:33 -0500 Subject: blake2s --- src/hash/blake.c | 15 ----- src/hash/blake.h | 16 +++-- src/hash/blake2.c | 196 +++++++++++++++++++++++++++++++++++++++++++++++++++++- src/hash/blake2.h | 6 +- 4 files changed, 211 insertions(+), 22 deletions(-) (limited to 'src/hash') diff --git a/src/hash/blake.c b/src/hash/blake.c index bd73cef..84aa727 100644 --- a/src/hash/blake.c +++ b/src/hash/blake.c @@ -87,14 +87,6 @@ void compress256(uint32_t* hash, char *block, uint64_t compressed){ //printf("\n"); } -struct blake256_hash { - uint8_t* buffer; - size_t bufflen; - uint32_t total, *hash; - uint64_t compressed; -}; -#define blake224_hash blake256_hash - #define bs 64 struct blake256_hash blake256_init(){ struct blake256_hash a = {.bufflen = 0, .total = 0, .compressed = 0}; @@ -307,13 +299,6 @@ void compress512(uint64_t* hash, uint8_t *block, uint64_t compressed){ for(int i = 0; i < 16; i++) hash[i % 8] ^= v[i]; } -struct blake512_hash { - uint8_t* buffer; - size_t bufflen; - uint64_t total, *hash; - uint64_t compressed; -}; -#define blake384_hash blake512_hash //#undef bs #define bs_2 128 diff --git a/src/hash/blake.h b/src/hash/blake.h index a08a31f..e0aac85 100644 --- a/src/hash/blake.h +++ b/src/hash/blake.h @@ -18,13 +18,21 @@ #define wtf(b) (b[0] << 24)&0xff000000 | (b[1] << 16)&0xff0000 | (b[2] << 8)&0xff00 | b[3]&0xff -enum blake256_v { - b256, b224 +struct blake256_hash { + uint8_t* buffer; + size_t bufflen; + uint32_t total, *hash; + uint64_t compressed; }; +#define blake224_hash blake256_hash -enum blake512_v { - b512, b384 +struct blake512_hash { + uint8_t* buffer; + size_t bufflen; + uint64_t total, *hash; + uint64_t compressed; }; +#define blake384_hash blake512_hash int l_blake256(lua_State* L); int l_blake256_init(lua_State* L); diff --git a/src/hash/blake2.c b/src/hash/blake2.c index 2da4cd0..3dc44e1 100644 --- a/src/hash/blake2.c +++ b/src/hash/blake2.c @@ -6,6 +6,7 @@ #include "../crypto.h" //#include "blake2.h" #include "../util.h" +#include "lua5.4/lua.h" void mix2b(uint64_t* a, uint64_t* b, uint64_t* c, uint64_t* d, int64_t x, int64_t y){ *a = *a + *b + x; @@ -85,6 +86,9 @@ void compress2b(uint64_t* hash, uint8_t* inp, uint64_t compressed, int final){ } void compress2s(uint32_t* hash, uint8_t* inp, uint32_t compressed, int final){ + printf("block:\n"); + for(int i = 0; i != 64; i++) printf("%x ", inp[i]); + printf("\n"); uint32_t v[16], s[16], m[16]; #pragma unroll @@ -168,7 +172,139 @@ void blake2b(char* inp, int inp_len, char* key, int key_len, int dig_len, char* for(int i = 0; i != dig_len; i++)sprintf(buffer, "%s%02x", buffer, (((uint8_t*)hash)[i])); } -void blake2s(char* inp, int inp_len, char* key, int key_len, int dig_len, char* buffer){ +struct blake2s_hash { + uint8_t *buffer, *key; + size_t bufflen, keylen; + uint32_t total, *hash; + uint64_t compressed, digest_len; +}; + +void blake2s_round(struct blake2s_hash* hash, int last){ + compress2s(hash->hash, hash->buffer, hash->compressed, last); +} + +#define bs 64 +struct blake2s_hash blake2s_init(char* key, int key_len, int digest_len){ + struct blake2s_hash a = {.bufflen = key_len, .total = 0, .compressed = 0, .keylen = key_len, .digest_len = digest_len}; + a.buffer = calloc(sizeof * a.buffer, bs); + a.hash = calloc(sizeof * a.hash, 8); + a.key = calloc(sizeof* a.key, key_len); + memcpy(a.key, key, key_len); + memcpy(a.buffer, key, key_len); + + a.hash[0] = sha512_iv.h0 >> 32; + a.hash[0] ^= digest_len; + a.hash[0] ^= key_len << 8; + a.hash[0] ^= 0x01010000; + a.hash[1] = sha512_iv.h1 >> 32; + a.hash[2] = sha512_iv.h2 >> 32; + a.hash[3] = sha512_iv.h3 >> 32; + a.hash[4] = sha512_iv.h4 >> 32; + a.hash[5] = sha512_iv.h5 >> 32; + a.hash[6] = sha512_iv.h6 >> 32; + a.hash[7] = sha512_iv.h7 >> 32; + if(key_len != 0){ + a.compressed = 64; + blake2s_round(&a, 0); + memset(a.buffer, 0, bs); + a.bufflen = 0; + } + return a; +} + +struct blake2s_hash blake2s_init_l(lua_State* L, char* key, int key_len, int digest_len){ + struct blake2s_hash a = {.bufflen = key_len, .total = 0, .compressed = 0, .keylen = key_len, .digest_len = digest_len}; + a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs); + a.hash = lua_newuserdata(L, sizeof * a.hash * 8); + a.key = lua_newuserdata(L, sizeof* a.key * key_len); + memcpy(a.key, key, key_len); + memset(a.buffer, 0, bs); + memcpy(a.buffer, key, key_len); + + a.hash[0] = sha512_iv.h0 >> 32; + a.hash[0] ^= digest_len; + a.hash[0] ^= key_len << 8; + a.hash[0] ^= 0x01010000; + a.hash[1] = sha512_iv.h1 >> 32; + a.hash[2] = sha512_iv.h2 >> 32; + a.hash[3] = sha512_iv.h3 >> 32; + a.hash[4] = sha512_iv.h4 >> 32; + a.hash[5] = sha512_iv.h5 >> 32; + a.hash[6] = sha512_iv.h6 >> 32; + a.hash[7] = sha512_iv.h7 >> 32; + if(key_len != 0){ + a.compressed = 64; //TODO: allow for keys larger than 64 chars + blake2s_round(&a, 0); + memset(a.buffer, 0, bs); + a.bufflen = 0; + } + return a; +} + +void blake2s_update(uint8_t* input, size_t len, struct blake2s_hash* hash){ + hash->total += len; + size_t total_add = len + hash->bufflen; + size_t read = 0; + if(total_add < bs){ + memcpy(hash->buffer + hash->bufflen, input, len); + hash->bufflen += len; + return; + } + + for(; total_add >= bs;){ + memcpy(hash->buffer + hash->bufflen, input + read, bs - hash->bufflen); + total_add -= bs; + hash->bufflen = 0; + read += bs; + hash->compressed += 64; + blake2s_round(hash, 0); + } + + memset(hash->buffer, 0, bs); + + if(0 != total_add){ + memcpy(hash->buffer, input + read, total_add); + hash->bufflen = total_add; + } +} + +void blake2s_final(struct blake2s_hash* hash, char* out_stream){ + uint8_t old[bs]; + uint32_t hashh[8]; + struct blake2s_hash old_hash; + memcpy(&old_hash, hash, sizeof * hash); + memcpy(old, hash->buffer, bs); + memcpy(hashh, hash->hash, 8 * sizeof * hashh); + + hash->compressed += hash->bufflen; + + if(hash->bufflen > 55) { + //too large, needs another buffer + memset(hash->buffer + hash->bufflen + 1, 0, 64 - hash->bufflen); + blake2s_round(hash, 0); + hash->compressed = 0; + memset(hash->buffer, 0, 64); + } + + blake2s_round(hash, 1); + + for(int i = 0; i != hash->digest_len; i++)sprintf(out_stream, "%s%02x", out_stream, (((uint8_t*)hash->hash)[i])); + + memcpy(hash, &old_hash, sizeof * hash); + memcpy(hash->buffer, old, bs); + memcpy(hash->hash, hashh, 8 * sizeof * hashh); +} + +void blake2s(uint8_t* inp, int len, char* key, int key_len, int dig_len, char* out){ + struct blake2s_hash aa = blake2s_init(key, key_len, dig_len); + blake2s_update(inp, len, &aa); + blake2s_final(&aa, out); + free(aa.buffer); + free(aa.hash); + free(aa.key); +} + +void _blake2s(char* inp, int inp_len, char* key, int key_len, int dig_len, char* buffer){ uint32_t hash[8]; uint32_t iv0 = hash[0] = sha512_iv.h0 >> 32; @@ -232,9 +368,65 @@ int l_blake2b(lua_State* L){ return 1; } +int l_blake2s_clone(lua_State* L){ + + struct blake2s_hash* a = (struct blake2s_hash*)lua_touserdata(L, -1); + + lua_pushinteger(L, a->digest_len); + lua_pushlstring(L, (char*)a->key, a->keylen); + l_blake2s_init(L); + + struct blake2s_hash* b = (struct blake2s_hash*)lua_touserdata(L, -1); + + memcpy(b->hash, a->hash, 8 * sizeof * b->hash); + memcpy(b->buffer, a->buffer, bs * sizeof * b->buffer); + + b->keylen = a->keylen; + b->digest_len = a->digest_len; + b->keylen = a->keylen; + b->total = a->total; + b->bufflen = a->bufflen; + b->compressed = a->compressed; + b->total = a->total; + return 1; +} + +lua_common_hash_meta(blake2s); + +int l_blake2s_init(lua_State* L){ + char* key = NULL; + size_t keylen = 0, outlen = 32; + + if(lua_gettop(L) > 1){ + key = (char*)luaL_checklstring(L, -1, &keylen); + outlen = luaL_checkinteger(L, -2); + } else if(lua_gettop(L) > 0) outlen = luaL_checkinteger(L, -1); + + struct blake2s_hash* a = (struct blake2s_hash*)lua_newuserdata(L, sizeof * a); + int ud = lua_gettop(L); + *a = blake2s_init_l(L, key, keylen, outlen); + lua_common_hash_meta_def(blake2s); + lua_pushvalue(L, ud); + return 1; +} + +lua_common_hash_update(blake2s, blake2s); + +int l_blake2s_final(lua_State* L){ + struct blake2s_hash* a = (struct blake2s_hash*)lua_touserdata(L, -1); + + char digest[a->digest_len * 8]; + memset(digest, 0, a->digest_len * 8); + blake2s_final(a, digest); + + lua_pushstring(L, digest); + return 1; +} + int l_blake2s(lua_State* L){ + if(lua_gettop(L) == 0 || lua_type(L, 1) == LUA_TNUMBER) return l_blake2s_init(L); size_t len = 0; - char* a = (char*)luaL_checklstring(L, 1, &len); + uint8_t* a = (uint8_t*)luaL_checklstring(L, 1, &len); int argv = lua_gettop(L); uint32_t out_len = 32; diff --git a/src/hash/blake2.h b/src/hash/blake2.h index cde04b3..91c69f6 100644 --- a/src/hash/blake2.h +++ b/src/hash/blake2.h @@ -14,8 +14,12 @@ static const uint8_t blake2b_sigma[10][16] = { { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 }, }; -void blake2s(char*, int, char*, int, int, char*); +//void blake2s(char*, int, char*, int, int, char*); void blake2b(char*, int, char*, int, int, char*); int l_blake2s(lua_State*); +int l_blake2s_init(lua_State*); +int l_blake2s_update(lua_State*); +int l_blake2s_final(lua_State*); + int l_blake2b(lua_State*); \ No newline at end of file -- cgit v1.2.3