From c038f88aeccb56a96db7b2cbaa742a8d1a9ec94c Mon Sep 17 00:00:00 2001 From: JP Aumasson Date: Tue, 11 Oct 2016 15:06:44 +0200 Subject: basic b2xs and b2xb --- ref/blake2xb-ref.c | 155 +++++++++++++++++++++++++++++++++++++++++++++++++++++ ref/blake2xs-ref.c | 154 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 309 insertions(+) create mode 100644 ref/blake2xb-ref.c create mode 100644 ref/blake2xs-ref.c diff --git a/ref/blake2xb-ref.c b/ref/blake2xb-ref.c new file mode 100644 index 0000000..8fcde66 --- /dev/null +++ b/ref/blake2xb-ref.c @@ -0,0 +1,155 @@ +#include +#include +#include + +#include "blake2.h" +#include "blake2-impl.h" + + +int blake2xb_init( blake2b_state *S, const uint16_t outlen, const void *key, const uint8_t keylen) +{ + blake2b_param P[1]; + + if ( !outlen ) return -1; + + P->digest_length = BLAKE2B_OUTBYTES; + P->key_length = keylen; + P->fanout = 1; + P->depth = 1; + store32( &P->leaf_length, 0 ); + store32( &P->node_offset, 0 ); + store32( &P->xof_length, outlen ); + P->node_depth = 0; + P->inner_length = 0; + memset( P->reserved, 0, sizeof( P->reserved ) ); + memset( P->salt, 0, sizeof( P->salt ) ); + memset( P->personal, 0, sizeof( P->personal ) ); + + if( blake2b_init_param( S, P ) < 0 ) return -1; + + if (keylen) + { + if ( !key || keylen > BLAKE2B_KEYBYTES ) return -1; + uint8_t block[BLAKE2B_BLOCKBYTES]; + memset( block, 0, BLAKE2B_BLOCKBYTES ); + memcpy( block, key, keylen ); + blake2b_update( S, block, BLAKE2B_BLOCKBYTES ); + secure_zero_memory( block, BLAKE2B_BLOCKBYTES ); + } + return 0; +} + + +int blake2xb_update( blake2b_state *S, const uint8_t *in, uint64_t inlen ) +{ + if ( !in ) return -1; + + return blake2b_update( S, in, inlen ); +} + +int blake2xb_final( blake2b_state *S, uint8_t *out, const uint16_t outlen) { + + blake2b_state C[1]; + blake2b_param P[1]; + int i; + uint16_t last_index = outlen/BLAKE2B_OUTBYTES; + uint8_t root[BLAKE2B_BLOCKBYTES]; + + if ( !out ) return 1; + + /* Finalize the root hash */ + if (blake2b_final( S, root, BLAKE2B_OUTBYTES ) < 0 ) + return -1; + + /* Set common block structure values */ + P->digest_length = BLAKE2B_OUTBYTES; + P->key_length = 0; + P->fanout = 0; + P->depth = 0; + store32( &P->leaf_length, BLAKE2B_OUTBYTES ); + store32( &P->xof_length, outlen ); + P->inner_length = 0; + P->node_depth = 0; + memset( P->reserved, 0, sizeof( P->reserved ) ); + memset( P->salt, 0, sizeof( P->salt ) ); + memset( P->personal, 0, sizeof( P->personal ) ); + + for( i = 0; i < last_index; ++ i ) { + /* Initialize state */ + store32( &P->node_offset, i ); + if( blake2b_init_param( C, P ) < 0 ) return -1; + /* Process key if needed */ + blake2b_update( C, root, BLAKE2B_OUTBYTES); + blake2b_final( C, out + i*BLAKE2B_OUTBYTES, BLAKE2B_OUTBYTES ); + } + /* Last instance */ + store32( &P->node_offset, last_index); + P->digest_length = outlen % BLAKE2B_OUTBYTES; + if( blake2b_init_param( C, P ) < 0 ) return -1; + blake2b_update( C, root, BLAKE2B_OUTBYTES); + blake2b_final( C, out + last_index*BLAKE2B_OUTBYTES, outlen % BLAKE2B_OUTBYTES ); + + return 0; +} + +int blake2xb( uint8_t *out, const void *in, const void *key, const +uint16_t outlen, const uint64_t inlen, const uint8_t keylen ) +{ + blake2b_state S[1]; + + /* Verify parameters */ + if ( NULL == in && inlen > 0 ) return -1; + + if ( NULL == out ) return -1; + + if ( NULL == key && keylen > 0) return -1; + + if( keylen > BLAKE2B_KEYBYTES ) return -1; + + if( !outlen ) return -1; + + /* Initialize the root block structure */ + if ( blake2xb_init( S, outlen, key, keylen ) < 0 ) { + return -1; + } + + /* Compute the root of the tree */ + if ( blake2xb_update( S, ( const uint8_t * )in, inlen ) < 0 ) + return -1; + + /* Compute the final hash using the counter construction */ + blake2xb_final( S, out, outlen ); + + return 0; +} + +#if defined(BLAKE2XB_SELFTEST) +#include +#include "blake2-kat.h" +int main( int argc, char **argv ) +{ + uint8_t key[BLAKE2B_KEYBYTES]; + uint8_t buf[BLAKE2_KAT_LENGTH]; + + for( size_t i = 0; i < BLAKE2B_KEYBYTES; ++i ) + key[i] = ( uint8_t )i; + + for( size_t i = 0; i < BLAKE2_KAT_LENGTH; ++i ) + buf[i] = ( uint8_t )i; + + for( size_t i = 0; i < BLAKE2_KAT_LENGTH; ++i ) + { + uint8_t hash[BLAKE2_KAT_LENGTH]; + blake2xb( hash, buf, key, i, BLAKE2_KAT_LENGTH, BLAKE2B_KEYBYTES ); + + for( size_t j = 0; j < i; ++j ) { + printf("%02x", hash[j]); + } + printf("\n"); + } + + //puts( "ok" ); + return 0; +} +#endif + diff --git a/ref/blake2xs-ref.c b/ref/blake2xs-ref.c new file mode 100644 index 0000000..5c6145e --- /dev/null +++ b/ref/blake2xs-ref.c @@ -0,0 +1,154 @@ +#include +#include +#include + +#include "blake2.h" +#include "blake2-impl.h" + + +int blake2xs_init( blake2s_state *S, const uint16_t outlen, const void *key, const uint8_t keylen) +{ + blake2s_param P[1]; + + if ( !outlen ) return -1; + + P->digest_length = BLAKE2S_OUTBYTES; + P->key_length = keylen; + P->fanout = 1; + P->depth = 1; + store32( &P->leaf_length, 0 ); + store32( &P->node_offset, 0 ); + store16( &P->xof_length, outlen ); + P->node_depth = 0; + P->inner_length = 0; + memset( P->salt, 0, sizeof( P->salt ) ); + memset( P->personal, 0, sizeof( P->personal ) ); + + if( blake2s_init_param( S, P ) < 0 ) return -1; + + if (keylen) + { + if ( !key || keylen > BLAKE2S_KEYBYTES ) return -1; + uint8_t block[BLAKE2S_BLOCKBYTES]; + memset( block, 0, BLAKE2S_BLOCKBYTES ); + memcpy( block, key, keylen ); + blake2s_update( S, block, BLAKE2S_BLOCKBYTES ); + secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); + } + return 0; +} + + +int blake2xs_update( blake2s_state *S, const uint8_t *in, uint64_t inlen ) +{ + if ( !in ) return -1; + + return blake2s_update( S, in, inlen ); + +} + +int blake2xs_final( blake2s_state *S, uint8_t *out, const uint16_t outlen ) { + + blake2s_state C[1]; + blake2s_param P[1]; + int i; + uint16_t last_index = outlen/BLAKE2S_OUTBYTES; + uint8_t root[BLAKE2S_BLOCKBYTES]; + + if ( !out ) return 1; + + /* Finalize the root hash */ + if (blake2s_final( S, root, BLAKE2S_OUTBYTES ) < 0 ) + return -1; + + /* Set common block structure values */ + P->digest_length = BLAKE2S_OUTBYTES; + P->key_length = 0; + P->fanout = 0; + P->depth = 0; + store32( &P->leaf_length, BLAKE2S_OUTBYTES ); + store16( &P->xof_length, outlen ); + P->inner_length = 0; + P->node_depth = 0; + memset( P->salt, 0, sizeof( P->salt ) ); + memset( P->personal, 0, sizeof( P->personal ) ); + + for( i = 0; i < last_index; ++ i ) { + /* Initialize state */ + store32( &P->node_offset, i ); + if( blake2s_init_param( C, P ) < 0 ) return -1; + /* Process key if needed */ + blake2s_update( C, root, BLAKE2S_OUTBYTES); + blake2s_final( C, out + i*BLAKE2S_OUTBYTES, BLAKE2S_OUTBYTES ); + } + /* Last instance */ + store32( &P->node_offset, last_index); + P->digest_length = outlen % BLAKE2S_OUTBYTES; + if( blake2s_init_param( C, P ) < 0 ) return -1; + blake2s_update( C, root, BLAKE2S_OUTBYTES); + blake2s_final( C, out + last_index*BLAKE2S_OUTBYTES, outlen % BLAKE2S_OUTBYTES ); + + return 0; +} + +int blake2xs( uint8_t *out, const void *in, const void *key, const +uint16_t outlen, const uint64_t inlen, const uint8_t keylen ) +{ + blake2s_state S[1]; + + /* Verify parameters */ + if ( NULL == in && inlen > 0 ) return -1; + + if ( NULL == out ) return -1; + + if ( NULL == key && keylen > 0) return -1; + + if( keylen > BLAKE2S_KEYBYTES ) return -1; + + if( !outlen ) return -1; + + /* Initialize the root block structure */ + if ( blake2xs_init( S, outlen, key, keylen ) < 0 ) { + return -1; + } + + /* Compute the root of the tree */ + if ( blake2xs_update( S, ( const uint8_t * )in, inlen ) < 0 ) + return -1; + + /* Compute the final hash using the counter construction */ + blake2xs_final( S, out, outlen ); + + return 0; +} + +#if defined(BLAKE2XS_SELFTEST) +#include +#include "blake2-kat.h" +int main( int argc, char **argv ) +{ + uint8_t key[BLAKE2S_KEYBYTES]; + uint8_t buf[BLAKE2_KAT_LENGTH]; + + for( size_t i = 0; i < BLAKE2S_KEYBYTES; ++i ) + key[i] = ( uint8_t )i; + + for( size_t i = 0; i < BLAKE2_KAT_LENGTH; ++i ) + buf[i] = ( uint8_t )i; + + for( size_t i = 0; i < BLAKE2_KAT_LENGTH; ++i ) + { + uint8_t hash[BLAKE2_KAT_LENGTH]; + blake2xs( hash, buf, key, i, BLAKE2_KAT_LENGTH, BLAKE2S_KEYBYTES ); + + for( size_t j = 0; j < i; ++j ) { + printf("%02x", hash[j]); + } + printf("\n"); + } + + //puts( "ok" ); + return 0; +} +#endif + -- cgit v1.2.3