diff options
author | Samuel Neves <sneves@dei.uc.pt> | 2016-06-11 01:56:26 +0300 |
---|---|---|
committer | Samuel Neves <sneves@dei.uc.pt> | 2016-06-11 01:56:26 +0300 |
commit | ef9d717e460ec5a432e19d6a5ed7afecad48f144 (patch) | |
tree | f3e1c5695273a7f44afedea990cc6868c0d665c9 | |
parent | 003671f8af0a212892596169fff2a2e35b98de53 (diff) |
tidy up
-rw-r--r-- | b2sum/makefile | 4 | ||||
-rw-r--r-- | ref/blake2-impl.h | 97 | ||||
-rw-r--r-- | ref/blake2.h | 38 | ||||
-rw-r--r-- | ref/blake2b-ref.c | 54 | ||||
-rw-r--r-- | ref/blake2bp-ref.c | 63 | ||||
-rw-r--r-- | ref/blake2s-ref.c | 59 | ||||
-rw-r--r-- | ref/blake2sp-ref.c | 63 | ||||
-rw-r--r-- | sse/blake2-impl.h | 99 | ||||
-rw-r--r-- | sse/blake2.h | 6 | ||||
-rw-r--r-- | sse/blake2b.c | 4 |
10 files changed, 257 insertions, 230 deletions
diff --git a/b2sum/makefile b/b2sum/makefile index 8558b2b..164cb26 100644 --- a/b2sum/makefile +++ b/b2sum/makefile @@ -2,8 +2,8 @@ PROG=b2sum PREFIX?=/usr/local MANDIR?=$(PREFIX)/man CC?=gcc -CFLAGS?=-O3 -march=native -static -Werror=declaration-after-statement -CFLAGS+=-std=c99 -I../sse -fopenmp +CFLAGS?=-O3 -march=native -static +CFLAGS+=-I../sse -fopenmp LIBS= #FILES=b2sum.c ../ref/blake2b-ref.c ../ref/blake2s-ref.c ../ref/blake2bp-ref.c ../ref/blake2sp-ref.c FILES=b2sum.c ../sse/blake2b.c ../sse/blake2s.c ../sse/blake2bp.c ../sse/blake2sp.c diff --git a/ref/blake2-impl.h b/ref/blake2-impl.h index 63a2394..8314380 100644 --- a/ref/blake2-impl.h +++ b/ref/blake2-impl.h @@ -19,7 +19,7 @@ #include <stdint.h> #include <string.h> -BLAKE2_LOCAL_INLINE(uint32_t) load32( const void *src ) +static uint32_t load32( const void *src ) { #if defined(NATIVE_LITTLE_ENDIAN) uint32_t w; @@ -27,15 +27,14 @@ BLAKE2_LOCAL_INLINE(uint32_t) load32( const void *src ) return w; #else const uint8_t *p = ( const uint8_t * )src; - uint32_t w = *p++; - w |= ( uint32_t )( *p++ ) << 8; - w |= ( uint32_t )( *p++ ) << 16; - w |= ( uint32_t )( *p++ ) << 24; - return w; + return (( uint32_t )( p[0] ) << 0) | + (( uint32_t )( p[1] ) << 8) | + (( uint32_t )( p[2] ) << 16) | + (( uint32_t )( p[3] ) << 24) ; #endif } -BLAKE2_LOCAL_INLINE(uint64_t) load64( const void *src ) +static uint64_t load64( const void *src ) { #if defined(NATIVE_LITTLE_ENDIAN) uint64_t w; @@ -43,93 +42,91 @@ BLAKE2_LOCAL_INLINE(uint64_t) load64( const void *src ) return w; #else const uint8_t *p = ( const uint8_t * )src; - uint64_t w = *p++; - w |= ( uint64_t )( *p++ ) << 8; - w |= ( uint64_t )( *p++ ) << 16; - w |= ( uint64_t )( *p++ ) << 24; - w |= ( uint64_t )( *p++ ) << 32; - w |= ( uint64_t )( *p++ ) << 40; - w |= ( uint64_t )( *p++ ) << 48; - w |= ( uint64_t )( *p++ ) << 56; - return w; + return (( uint64_t )( p[0] ) << 0) | + (( uint64_t )( p[1] ) << 8) | + (( uint64_t )( p[2] ) << 16) | + (( uint64_t )( p[3] ) << 24) | + (( uint64_t )( p[4] ) << 32) | + (( uint64_t )( p[5] ) << 40) | + (( uint64_t )( p[6] ) << 48) | + (( uint64_t )( p[7] ) << 56) ; #endif } -BLAKE2_LOCAL_INLINE(void) store32( void *dst, uint32_t w ) +static void store32( void *dst, uint32_t w ) { #if defined(NATIVE_LITTLE_ENDIAN) memcpy(dst, &w, sizeof w); #else uint8_t *p = ( uint8_t * )dst; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; + p[0] = (uint8_t)(w >> 0); + p[1] = (uint8_t)(w >> 8); + p[2] = (uint8_t)(w >> 16); + p[3] = (uint8_t)(w >> 24); #endif } -BLAKE2_LOCAL_INLINE(void) store64( void *dst, uint64_t w ) +static void store64( void *dst, uint64_t w ) { #if defined(NATIVE_LITTLE_ENDIAN) memcpy(dst, &w, sizeof w); #else uint8_t *p = ( uint8_t * )dst; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; + p[0] = (uint8_t)(w >> 0); + p[1] = (uint8_t)(w >> 8); + p[2] = (uint8_t)(w >> 16); + p[3] = (uint8_t)(w >> 24); + p[4] = (uint8_t)(w >> 32); + p[5] = (uint8_t)(w >> 40); + p[6] = (uint8_t)(w >> 48); + p[7] = (uint8_t)(w >> 56); #endif } -BLAKE2_LOCAL_INLINE(uint64_t) load48( const void *src ) +static uint64_t load48( const void *src ) { const uint8_t *p = ( const uint8_t * )src; - uint64_t w = *p++; - w |= ( uint64_t )( *p++ ) << 8; - w |= ( uint64_t )( *p++ ) << 16; - w |= ( uint64_t )( *p++ ) << 24; - w |= ( uint64_t )( *p++ ) << 32; - w |= ( uint64_t )( *p++ ) << 40; - return w; + return (( uint64_t )( p[0] ) << 0) | + (( uint64_t )( p[1] ) << 8) | + (( uint64_t )( p[2] ) << 16) | + (( uint64_t )( p[3] ) << 24) | + (( uint64_t )( p[4] ) << 32) | + (( uint64_t )( p[5] ) << 40) ; } -BLAKE2_LOCAL_INLINE(void) store48( void *dst, uint64_t w ) +static void store48( void *dst, uint64_t w ) { uint8_t *p = ( uint8_t * )dst; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; + p[0] = (uint8_t)(w >> 0); + p[1] = (uint8_t)(w >> 8); + p[2] = (uint8_t)(w >> 16); + p[3] = (uint8_t)(w >> 24); + p[4] = (uint8_t)(w >> 32); + p[5] = (uint8_t)(w >> 40); } -BLAKE2_LOCAL_INLINE(uint32_t) rotl32( const uint32_t w, const unsigned c ) +static uint32_t rotl32( const uint32_t w, const unsigned c ) { return ( w << c ) | ( w >> ( 32 - c ) ); } -BLAKE2_LOCAL_INLINE(uint64_t) rotl64( const uint64_t w, const unsigned c ) +static uint64_t rotl64( const uint64_t w, const unsigned c ) { return ( w << c ) | ( w >> ( 64 - c ) ); } -BLAKE2_LOCAL_INLINE(uint32_t) rotr32( const uint32_t w, const unsigned c ) +static uint32_t rotr32( const uint32_t w, const unsigned c ) { return ( w >> c ) | ( w << ( 32 - c ) ); } -BLAKE2_LOCAL_INLINE(uint64_t) rotr64( const uint64_t w, const unsigned c ) +static uint64_t rotr64( const uint64_t w, const unsigned c ) { return ( w >> c ) | ( w << ( 64 - c ) ); } /* prevents compiler optimizing out memset() */ -BLAKE2_LOCAL_INLINE(void) secure_zero_memory(void *v, size_t n) +static void secure_zero_memory(void *v, size_t n) { static void *(*const volatile memset_v)(void *, int, size_t) = &memset; memset_v(v, 0, n); diff --git a/ref/blake2.h b/ref/blake2.h index 1a9fdf4..fd25987 100644 --- a/ref/blake2.h +++ b/ref/blake2.h @@ -19,12 +19,10 @@ #include <stddef.h> #include <stdint.h> -#ifdef BLAKE2_NO_INLINE -#define BLAKE2_LOCAL_INLINE(type) static type -#endif - -#ifndef BLAKE2_LOCAL_INLINE -#define BLAKE2_LOCAL_INLINE(type) static inline type +#if defined(_MSC_VER) +#define BLAKE2_PACKED(x) __pragma(pack(push, 1)) x __pragma(pack(pop)) +#else +#define BLAKE2_PACKED(x) x __attribute__((packed)) #endif #if defined(__cplusplus) @@ -86,23 +84,24 @@ extern "C" { } blake2bp_state; -#pragma pack(push, 1) - typedef struct __blake2s_param + BLAKE2_PACKED(struct __blake2s_param { uint8_t digest_length; /* 1 */ uint8_t key_length; /* 2 */ uint8_t fanout; /* 3 */ uint8_t depth; /* 4 */ uint32_t leaf_length; /* 8 */ - uint8_t node_offset[6];// 14 + uint8_t node_offset[6];/* 14 */ uint8_t node_depth; /* 15 */ uint8_t inner_length; /* 16 */ /* uint8_t reserved[0]; */ uint8_t salt[BLAKE2S_SALTBYTES]; /* 24 */ uint8_t personal[BLAKE2S_PERSONALBYTES]; /* 32 */ - } blake2s_param; + }); - typedef struct __blake2b_param + typedef struct __blake2s_param blake2s_param; + + BLAKE2_PACKED(struct __blake2b_param { uint8_t digest_length; /* 1 */ uint8_t key_length; /* 2 */ @@ -115,8 +114,15 @@ extern "C" { uint8_t reserved[14]; /* 32 */ uint8_t salt[BLAKE2B_SALTBYTES]; /* 48 */ uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */ - } blake2b_param; -#pragma pack(pop) + }); + + typedef struct __blake2b_param blake2b_param; + + /* Padded structs result in a compile-time error */ + enum { + BLAKE2_DUMMY_1 = 1/(sizeof(blake2s_param) == BLAKE2S_OUTBYTES), + BLAKE2_DUMMY_2 = 1/(sizeof(blake2b_param) == BLAKE2B_OUTBYTES) + }; /* Streaming API */ int blake2s_init( blake2s_state *S, const uint8_t outlen ); @@ -148,10 +154,8 @@ extern "C" { int blake2sp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); int blake2bp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); - static inline int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ) - { - return blake2b( out, in, key, outlen, inlen, keylen ); - } + /* This is simply an alias for blake2b */ + int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); #if defined(__cplusplus) } diff --git a/ref/blake2b-ref.c b/ref/blake2b-ref.c index ac91568..be2ec04 100644 --- a/ref/blake2b-ref.c +++ b/ref/blake2b-ref.c @@ -45,25 +45,25 @@ static const uint8_t blake2b_sigma[12][16] = }; -BLAKE2_LOCAL_INLINE(int) blake2b_set_lastnode( blake2b_state *S ) +static int blake2b_set_lastnode( blake2b_state *S ) { S->f[1] = -1; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_clear_lastnode( blake2b_state *S ) +static int blake2b_clear_lastnode( blake2b_state *S ) { S->f[1] = 0; return 0; } /* Some helper functions, not necessarily useful */ -BLAKE2_LOCAL_INLINE(int) blake2b_is_lastblock( const blake2b_state *S ) +static int blake2b_is_lastblock( const blake2b_state *S ) { return S->f[0] != 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_set_lastblock( blake2b_state *S ) +static int blake2b_set_lastblock( blake2b_state *S ) { if( S->last_node ) blake2b_set_lastnode( S ); @@ -71,7 +71,7 @@ BLAKE2_LOCAL_INLINE(int) blake2b_set_lastblock( blake2b_state *S ) return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_clear_lastblock( blake2b_state *S ) +static int blake2b_clear_lastblock( blake2b_state *S ) { if( S->last_node ) blake2b_clear_lastnode( S ); @@ -79,7 +79,7 @@ BLAKE2_LOCAL_INLINE(int) blake2b_clear_lastblock( blake2b_state *S ) return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_increment_counter( blake2b_state *S, const uint64_t inc ) +static int blake2b_increment_counter( blake2b_state *S, const uint64_t inc ) { S->t[0] += inc; S->t[1] += ( S->t[0] < inc ); @@ -89,65 +89,66 @@ BLAKE2_LOCAL_INLINE(int) blake2b_increment_counter( blake2b_state *S, const uint /* Parameter-related functions */ -BLAKE2_LOCAL_INLINE(int) blake2b_param_set_digest_length( blake2b_param *P, const uint8_t digest_length ) +static int blake2b_param_set_digest_length( blake2b_param *P, const uint8_t digest_length ) { P->digest_length = digest_length; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_param_set_fanout( blake2b_param *P, const uint8_t fanout ) +static int blake2b_param_set_fanout( blake2b_param *P, const uint8_t fanout ) { P->fanout = fanout; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_param_set_max_depth( blake2b_param *P, const uint8_t depth ) +static int blake2b_param_set_max_depth( blake2b_param *P, const uint8_t depth ) { P->depth = depth; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_param_set_leaf_length( blake2b_param *P, const uint32_t leaf_length ) +static int blake2b_param_set_leaf_length( blake2b_param *P, const uint32_t leaf_length ) { store32( &P->leaf_length, leaf_length ); return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_param_set_node_offset( blake2b_param *P, const uint64_t node_offset ) +static int blake2b_param_set_node_offset( blake2b_param *P, const uint64_t node_offset ) { store64( &P->node_offset, node_offset ); return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_param_set_node_depth( blake2b_param *P, const uint8_t node_depth ) +static int blake2b_param_set_node_depth( blake2b_param *P, const uint8_t node_depth ) { P->node_depth = node_depth; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_param_set_inner_length( blake2b_param *P, const uint8_t inner_length ) +static int blake2b_param_set_inner_length( blake2b_param *P, const uint8_t inner_length ) { P->inner_length = inner_length; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_param_set_salt( blake2b_param *P, const uint8_t salt[BLAKE2B_SALTBYTES] ) +static int blake2b_param_set_salt( blake2b_param *P, const uint8_t salt[BLAKE2B_SALTBYTES] ) { memcpy( P->salt, salt, BLAKE2B_SALTBYTES ); return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_param_set_personal( blake2b_param *P, const uint8_t personal[BLAKE2B_PERSONALBYTES] ) +static int blake2b_param_set_personal( blake2b_param *P, const uint8_t personal[BLAKE2B_PERSONALBYTES] ) { memcpy( P->personal, personal, BLAKE2B_PERSONALBYTES ); return 0; } -BLAKE2_LOCAL_INLINE(int) blake2b_init0( blake2b_state *S ) +static int blake2b_init0( blake2b_state *S ) { + int i; memset( S, 0, sizeof( blake2b_state ) ); - for( int i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i]; + for( i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i]; return 0; } @@ -156,11 +157,12 @@ BLAKE2_LOCAL_INLINE(int) blake2b_init0( blake2b_state *S ) int blake2b_init_param( blake2b_state *S, const blake2b_param *P ) { const uint8_t *p = ( const uint8_t * )( P ); + size_t i; blake2b_init0( S ); /* IV XOR ParamBlock */ - for( size_t i = 0; i < 8; ++i ) + for( i = 0; i < 8; ++i ) S->h[i] ^= load64( p + sizeof( S->h[i] ) * i ); return 0; @@ -319,6 +321,7 @@ int blake2b_update( blake2b_state *S, const uint8_t *in, uint64_t inlen ) int blake2b_final( blake2b_state *S, uint8_t *out, uint8_t outlen ) { uint8_t buffer[BLAKE2B_OUTBYTES] = {0}; + int i; if( out == NULL || outlen == 0 || outlen > BLAKE2B_OUTBYTES ) return -1; @@ -339,7 +342,7 @@ int blake2b_final( blake2b_state *S, uint8_t *out, uint8_t outlen ) memset( S->buf + S->buflen, 0, 2 * BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */ blake2b_compress( S, S->buf ); - for( int i = 0; i < 8; ++i ) /* Output full hash to temp buffer */ + for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */ store64( buffer + sizeof( S->h[i] ) * i, S->h[i] ); memcpy( out, buffer, outlen ); @@ -376,6 +379,10 @@ int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen return 0; } +int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ) { + return blake2b(out, in, key, outlen, inlen, keylen); +} + #if defined(SUPERCOP) int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen ) { @@ -386,18 +393,19 @@ int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen #if defined(BLAKE2B_SELFTEST) #include <string.h> #include "blake2-kat.h" -int main( int argc, char **argv ) +int main( void ) { uint8_t key[BLAKE2B_KEYBYTES]; uint8_t buf[KAT_LENGTH]; + size_t i; - for( size_t i = 0; i < BLAKE2B_KEYBYTES; ++i ) + for( i = 0; i < BLAKE2B_KEYBYTES; ++i ) key[i] = ( uint8_t )i; - for( size_t i = 0; i < KAT_LENGTH; ++i ) + for( i = 0; i < KAT_LENGTH; ++i ) buf[i] = ( uint8_t )i; - for( size_t i = 0; i < KAT_LENGTH; ++i ) + for( i = 0; i < KAT_LENGTH; ++i ) { uint8_t hash[BLAKE2B_OUTBYTES]; blake2b( hash, buf, key, BLAKE2B_OUTBYTES, i, BLAKE2B_KEYBYTES ); diff --git a/ref/blake2bp-ref.c b/ref/blake2bp-ref.c index 28855e6..b3a3467 100644 --- a/ref/blake2bp-ref.c +++ b/ref/blake2bp-ref.c @@ -27,7 +27,7 @@ #define PARALLELISM_DEGREE 4 -BLAKE2_LOCAL_INLINE(int) blake2bp_init_leaf( blake2b_state *S, uint8_t outlen, uint8_t keylen, uint64_t offset ) +static int blake2bp_init_leaf( blake2b_state *S, uint8_t outlen, uint8_t keylen, uint64_t offset ) { blake2b_param P[1]; P->digest_length = outlen; @@ -44,7 +44,7 @@ BLAKE2_LOCAL_INLINE(int) blake2bp_init_leaf( blake2b_state *S, uint8_t outlen, u return blake2b_init_param( S, P ); } -BLAKE2_LOCAL_INLINE(int) blake2bp_init_root( blake2b_state *S, uint8_t outlen, uint8_t keylen ) +static int blake2bp_init_root( blake2b_state *S, uint8_t outlen, uint8_t keylen ) { blake2b_param P[1]; P->digest_length = outlen; @@ -64,6 +64,8 @@ BLAKE2_LOCAL_INLINE(int) blake2bp_init_root( blake2b_state *S, uint8_t outlen, u int blake2bp_init( blake2bp_state *S, const uint8_t outlen ) { + size_t i; + if( !outlen || outlen > BLAKE2B_OUTBYTES ) return -1; memset( S->buf, 0, sizeof( S->buf ) ); @@ -72,7 +74,7 @@ int blake2bp_init( blake2bp_state *S, const uint8_t outlen ) if( blake2bp_init_root( S->R, outlen, 0 ) < 0 ) return -1; - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) if( blake2bp_init_leaf( S->S[i], outlen, 0, i ) < 0 ) return -1; S->R->last_node = 1; @@ -82,6 +84,8 @@ int blake2bp_init( blake2bp_state *S, const uint8_t outlen ) int blake2bp_init_key( blake2bp_state *S, const uint8_t outlen, const void *key, const uint8_t keylen ) { + size_t i; + if( !outlen || outlen > BLAKE2B_OUTBYTES ) return -1; if( !key || !keylen || keylen > BLAKE2B_KEYBYTES ) return -1; @@ -92,7 +96,7 @@ int blake2bp_init_key( blake2bp_state *S, const uint8_t outlen, const void *key, if( blake2bp_init_root( S->R, outlen, keylen ) < 0 ) return -1; - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) if( blake2bp_init_leaf( S->S[i], outlen, keylen, i ) < 0 ) return -1; S->R->last_node = 1; @@ -102,7 +106,7 @@ int blake2bp_init_key( blake2bp_state *S, const uint8_t outlen, const void *key, memset( block, 0, BLAKE2B_BLOCKBYTES ); memcpy( block, key, keylen ); - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2b_update( S->S[i], block, BLAKE2B_BLOCKBYTES ); secure_zero_memory( block, BLAKE2B_BLOCKBYTES ); /* Burn the key from stack */ @@ -115,12 +119,13 @@ int blake2bp_update( blake2bp_state *S, const uint8_t *in, uint64_t inlen ) { size_t left = S->buflen; size_t fill = sizeof( S->buf ) - left; + size_t i; if( left && inlen >= fill ) { memcpy( S->buf + left, in, fill ); - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2b_update( S->S[i], S->buf + i * BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES ); in += fill; @@ -132,19 +137,19 @@ int blake2bp_update( blake2bp_state *S, const uint8_t *in, uint64_t inlen ) #pragma omp parallel shared(S), num_threads(PARALLELISM_DEGREE) #else - for( size_t id__ = 0; id__ < PARALLELISM_DEGREE; ++id__ ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) #endif { #if defined(_OPENMP) - size_t id__ = omp_get_thread_num(); + size_t i = omp_get_thread_num(); #endif uint64_t inlen__ = inlen; const uint8_t *in__ = ( const uint8_t * )in; - in__ += id__ * BLAKE2B_BLOCKBYTES; + in__ += i * BLAKE2B_BLOCKBYTES; while( inlen__ >= PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES ) { - blake2b_update( S->S[id__], in__, BLAKE2B_BLOCKBYTES ); + blake2b_update( S->S[i], in__, BLAKE2B_BLOCKBYTES ); in__ += PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES; inlen__ -= PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES; } @@ -163,8 +168,9 @@ int blake2bp_update( blake2bp_state *S, const uint8_t *in, uint64_t inlen ) int blake2bp_final( blake2bp_state *S, uint8_t *out, const uint8_t outlen ) { uint8_t hash[PARALLELISM_DEGREE][BLAKE2B_OUTBYTES]; + size_t i; - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) { if( S->buflen > i * BLAKE2B_BLOCKBYTES ) { @@ -178,10 +184,9 @@ int blake2bp_final( blake2bp_state *S, uint8_t *out, const uint8_t outlen ) blake2b_final( S->S[i], hash[i], BLAKE2B_OUTBYTES ); } - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2b_update( S->R, hash[i], BLAKE2B_OUTBYTES ); - return blake2b_final( S->R, out, outlen ); } @@ -190,6 +195,7 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin uint8_t hash[PARALLELISM_DEGREE][BLAKE2B_OUTBYTES]; blake2b_state S[PARALLELISM_DEGREE][1]; blake2b_state FS[1]; + size_t i; /* Verify parameters */ if ( NULL == in && inlen > 0 ) return -1; @@ -202,7 +208,7 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin if( keylen > BLAKE2B_KEYBYTES ) return -1; - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) if( blake2bp_init_leaf( S[i], outlen, keylen, i ) < 0 ) return -1; S[PARALLELISM_DEGREE - 1]->last_node = 1; /* mark last node */ @@ -213,7 +219,7 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin memset( block, 0, BLAKE2B_BLOCKBYTES ); memcpy( block, key, keylen ); - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2b_update( S[i], block, BLAKE2B_BLOCKBYTES ); secure_zero_memory( block, BLAKE2B_BLOCKBYTES ); /* Burn the key from stack */ @@ -223,31 +229,31 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin #pragma omp parallel shared(S,hash), num_threads(PARALLELISM_DEGREE) #else - for( size_t id__ = 0; id__ < PARALLELISM_DEGREE; ++id__ ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) #endif { #if defined(_OPENMP) - size_t id__ = omp_get_thread_num(); + size_t i = omp_get_thread_num(); #endif uint64_t inlen__ = inlen; const uint8_t *in__ = ( const uint8_t * )in; - in__ += id__ * BLAKE2B_BLOCKBYTES; + in__ += i * BLAKE2B_BLOCKBYTES; while( inlen__ >= PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES ) { - blake2b_update( S[id__], in__, BLAKE2B_BLOCKBYTES ); + blake2b_update( S[i], in__, BLAKE2B_BLOCKBYTES ); in__ += PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES; inlen__ -= PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES; } - if( inlen__ > id__ * BLAKE2B_BLOCKBYTES ) + if( inlen__ > i * BLAKE2B_BLOCKBYTES ) { - const size_t left = inlen__ - id__ * BLAKE2B_BLOCKBYTES; + const size_t left = inlen__ - i * BLAKE2B_BLOCKBYTES; const size_t len = left <= BLAKE2B_BLOCKBYTES ? left : BLAKE2B_BLOCKBYTES; - blake2b_update( S[id__], in__, len ); + blake2b_update( S[i], in__, len ); } - blake2b_final( S[id__], hash[id__], BLAKE2B_OUTBYTES ); + blake2b_final( S[i], hash[i], BLAKE2B_OUTBYTES ); } if( blake2bp_init_root( FS, outlen, keylen ) < 0 ) @@ -255,7 +261,7 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin FS->last_node = 1; /* Mark as last node */ - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2b_update( FS, hash[i], BLAKE2B_OUTBYTES ); return blake2b_final( FS, out, outlen );; @@ -264,18 +270,19 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin #if defined(BLAKE2BP_SELFTEST) #include <string.h> #include "blake2-kat.h" -int main( int argc, char **argv ) +int main( void ) { uint8_t key[BLAKE2B_KEYBYTES]; uint8_t buf[KAT_LENGTH]; + size_t i; - for( size_t i = 0; i < BLAKE2B_KEYBYTES; ++i ) + for( i = 0; i < BLAKE2B_KEYBYTES; ++i ) key[i] = ( uint8_t )i; - for( size_t i = 0; i < KAT_LENGTH; ++i ) + for( i = 0; i < KAT_LENGTH; ++i ) buf[i] = ( uint8_t )i; - for( size_t i = 0; i < KAT_LENGTH; ++i ) + for( i = 0; i < KAT_LENGTH; ++i ) { uint8_t hash[BLAKE2B_OUTBYTES]; blake2bp( hash, buf, key, BLAKE2B_OUTBYTES, i, BLAKE2B_KEYBYTES ); diff --git a/ref/blake2s-ref.c b/ref/blake2s-ref.c index 0e246c3..e24183c 100644 --- a/ref/blake2s-ref.c +++ b/ref/blake2s-ref.c @@ -40,25 +40,25 @@ static const uint8_t blake2s_sigma[10][16] = { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 } , }; -BLAKE2_LOCAL_INLINE(int) blake2s_set_lastnode( blake2s_state *S ) +static int blake2s_set_lastnode( blake2s_state *S ) { S->f[1] = -1; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_clear_lastnode( blake2s_state *S ) +static int blake2s_clear_lastnode( blake2s_state *S ) { S->f[1] = 0; return 0; } /* Some helper functions, not necessarily useful */ -BLAKE2_LOCAL_INLINE(int) blake2s_is_lastblock( const blake2s_state *S ) +static int blake2s_is_lastblock( const blake2s_state *S ) { return S->f[0] != 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_set_lastblock( blake2s_state *S ) +static int blake2s_set_lastblock( blake2s_state *S ) { if( S->last_node ) blake2s_set_lastnode( S ); @@ -66,7 +66,7 @@ BLAKE2_LOCAL_INLINE(int) blake2s_set_lastblock( blake2s_state *S ) return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_clear_lastblock( blake2s_state *S ) +static int blake2s_clear_lastblock( blake2s_state *S ) { if( S->last_node ) blake2s_clear_lastnode( S ); @@ -74,7 +74,7 @@ BLAKE2_LOCAL_INLINE(int) blake2s_clear_lastblock( blake2s_state *S ) return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_increment_counter( blake2s_state *S, const uint32_t inc ) +static int blake2s_increment_counter( blake2s_state *S, const uint32_t inc ) { S->t[0] += inc; S->t[1] += ( S->t[0] < inc ); @@ -82,65 +82,66 @@ BLAKE2_LOCAL_INLINE(int) blake2s_increment_counter( blake2s_state *S, const uint } /* Parameter-related functions */ -BLAKE2_LOCAL_INLINE(int) blake2s_param_set_digest_length( blake2s_param *P, const uint8_t digest_length ) +static int blake2s_param_set_digest_length( blake2s_param *P, const uint8_t digest_length ) { P->digest_length = digest_length; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_param_set_fanout( blake2s_param *P, const uint8_t fanout ) +static int blake2s_param_set_fanout( blake2s_param *P, const uint8_t fanout ) { P->fanout = fanout; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_param_set_max_depth( blake2s_param *P, const uint8_t depth ) +static int blake2s_param_set_max_depth( blake2s_param *P, const uint8_t depth ) { P->depth = depth; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_param_set_leaf_length( blake2s_param *P, const uint32_t leaf_length ) +static int blake2s_param_set_leaf_length( blake2s_param *P, const uint32_t leaf_length ) { store32( &P->leaf_length, leaf_length ); return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_param_set_node_offset( blake2s_param *P, const uint64_t node_offset ) +static int blake2s_param_set_node_offset( blake2s_param *P, const uint64_t node_offset ) { store48( P->node_offset, node_offset ); return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_param_set_node_depth( blake2s_param *P, const uint8_t node_depth ) +static int blake2s_param_set_node_depth( blake2s_param *P, const uint8_t node_depth ) { P->node_depth = node_depth; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_param_set_inner_length( blake2s_param *P, const uint8_t inner_length ) +static int blake2s_param_set_inner_length( blake2s_param *P, const uint8_t inner_length ) { P->inner_length = inner_length; return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_param_set_salt( blake2s_param *P, const uint8_t salt[BLAKE2S_SALTBYTES] ) +static int blake2s_param_set_salt( blake2s_param *P, const uint8_t salt[BLAKE2S_SALTBYTES] ) { memcpy( P->salt, salt, BLAKE2S_SALTBYTES ); return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_param_set_personal( blake2s_param *P, const uint8_t personal[BLAKE2S_PERSONALBYTES] ) +static int blake2s_param_set_personal( blake2s_param *P, const uint8_t personal[BLAKE2S_PERSONALBYTES] ) { memcpy( P->personal, personal, BLAKE2S_PERSONALBYTES ); return 0; } -BLAKE2_LOCAL_INLINE(int) blake2s_init0( blake2s_state *S ) +static int blake2s_init0( blake2s_state *S ) { + int i; memset( S, 0, sizeof( blake2s_state ) ); - for( int i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i]; + for( i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i]; return 0; } @@ -148,12 +149,13 @@ BLAKE2_LOCAL_INLINE(int) blake2s_init0( blake2s_state *S ) /* init2 xors IV with input parameter block */ int blake2s_init_param( blake2s_state *S, const blake2s_param *P ) { + size_t i; const uint32_t *p = ( const uint32_t * )( P ); blake2s_init0( S ); /* IV XOR ParamBlock */ - for( size_t i = 0; i < 8; ++i ) + for( i = 0; i < 8; ++i ) S->h[i] ^= load32( &p[i] ); return 0; @@ -218,11 +220,12 @@ static int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCK { uint32_t m[16]; uint32_t v[16]; + size_t i; - for( size_t i = 0; i < 16; ++i ) + for( i = 0; i < 16; ++i ) m[i] = load32( block + i * sizeof( m[i] ) ); - for( size_t i = 0; i < 8; ++i ) + for( i = 0; i < 8; ++i ) v[i] = S->h[i]; v[ 8] = blake2s_IV[0]; @@ -266,7 +269,7 @@ static int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCK ROUND( 8 ); ROUND( 9 ); - for( size_t i = 0; i < 8; ++i ) + for( i = 0; i < 8; ++i ) S->h[i] = S->h[i] ^ v[i] ^ v[i + 8]; #undef G @@ -308,6 +311,7 @@ int blake2s_update( blake2s_state *S, const uint8_t *in, uint64_t inlen ) int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen ) { uint8_t buffer[BLAKE2S_OUTBYTES] = {0}; + int i; if( out == NULL || outlen == 0 || outlen > BLAKE2S_OUTBYTES ) return -1; @@ -329,9 +333,9 @@ int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen ) memset( S->buf + S->buflen, 0, 2 * BLAKE2S_BLOCKBYTES - S->buflen ); /* Padding */ blake2s_compress( S, S->buf ); - for( int i = 0; i < 8; ++i ) /* Output full hash to temp buffer */ + for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */ store32( buffer + sizeof( S->h[i] ) * i, S->h[i] ); - + memcpy( out, buffer, outlen ); return 0; } @@ -375,18 +379,19 @@ int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen #if defined(BLAKE2S_SELFTEST) #include <string.h> #include "blake2-kat.h" -int main( int argc, char **argv ) +int main( void ) { uint8_t key[BLAKE2S_KEYBYTES]; uint8_t buf[KAT_LENGTH]; + size_t i; - for( size_t i = 0; i < BLAKE2S_KEYBYTES; ++i ) + for( i = 0; i < BLAKE2S_KEYBYTES; ++i ) key[i] = ( uint8_t )i; - for( size_t i = 0; i < KAT_LENGTH; ++i ) + for( i = 0; i < KAT_LENGTH; ++i ) buf[i] = ( uint8_t )i; - for( size_t i = 0; i < KAT_LENGTH; ++i ) + for( i = 0; i < KAT_LENGTH; ++i ) { uint8_t hash[BLAKE2S_OUTBYTES]; blake2s( hash, buf, key, BLAKE2S_OUTBYTES, i, BLAKE2S_KEYBYTES ); diff --git a/ref/blake2sp-ref.c b/ref/blake2sp-ref.c index 3775a2d..05d17f6 100644 --- a/ref/blake2sp-ref.c +++ b/ref/blake2sp-ref.c @@ -26,7 +26,7 @@ #define PARALLELISM_DEGREE 8 -BLAKE2_LOCAL_INLINE(int) blake2sp_init_leaf( blake2s_state *S, uint8_t outlen, uint8_t keylen, uint64_t offset ) +static int blake2sp_init_leaf( blake2s_state *S, uint8_t outlen, uint8_t keylen, uint64_t offset ) { blake2s_param P[1]; P->digest_length = outlen; @@ -42,7 +42,7 @@ BLAKE2_LOCAL_INLINE(int) blake2sp_init_leaf( blake2s_state *S, uint8_t outlen, u return blake2s_init_param( S, P ); } -BLAKE2_LOCAL_INLINE(int) blake2sp_init_root( blake2s_state *S, uint8_t outlen, uint8_t keylen ) +static int blake2sp_init_root( blake2s_state *S, uint8_t outlen, uint8_t keylen ) { blake2s_param P[1]; P->digest_length = outlen; @@ -61,6 +61,8 @@ BLAKE2_LOCAL_INLINE(int) blake2sp_init_root( blake2s_state *S, uint8_t outlen, u int blake2sp_init( blake2sp_state *S, const uint8_t outlen ) { + size_t i; + if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1; memset( S->buf, 0, sizeof( S->buf ) ); @@ -69,7 +71,7 @@ int blake2sp_init( blake2sp_state *S, const uint8_t outlen ) if( blake2sp_init_root( S->R, outlen, 0 ) < 0 ) return -1; - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) if( blake2sp_init_leaf( S->S[i], outlen, 0, i ) < 0 ) return -1; S->R->last_node = 1; @@ -79,6 +81,8 @@ int blake2sp_init( blake2sp_state *S, const uint8_t outlen ) int blake2sp_init_key( blake2sp_state *S, const uint8_t outlen, const void *key, const uint8_t keylen ) { + size_t i; + if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1; if( !key || !keylen || keylen > BLAKE2S_KEYBYTES ) return -1; @@ -89,7 +93,7 @@ int blake2sp_init_key( blake2sp_state *S, const uint8_t outlen, const void *key, if( blake2sp_init_root( S->R, outlen, keylen ) < 0 ) return -1; - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) if( blake2sp_init_leaf( S->S[i], outlen, keylen, i ) < 0 ) return -1; S->R->last_node = 1; @@ -99,7 +103,7 @@ int blake2sp_init_key( blake2sp_state *S, const uint8_t outlen, const void *key, memset( block, 0, BLAKE2S_BLOCKBYTES ); memcpy( block, key, keylen ); - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2s_update( S->S[i], block, BLAKE2S_BLOCKBYTES ); secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */ @@ -112,12 +116,13 @@ int blake2sp_update( blake2sp_state *S, const uint8_t *in, uint64_t inlen ) { size_t left = S->buflen; size_t fill = sizeof( S->buf ) - left; + size_t i; if( left && inlen >= fill ) { memcpy( S->buf + left, in, fill ); - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2s_update( S->S[i], S->buf + i * BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES ); in += fill; @@ -128,20 +133,19 @@ int blake2sp_update( blake2sp_state *S, const uint8_t *in, uint64_t inlen ) #if defined(_OPENMP) #pragma omp parallel shared(S), num_threads(PARALLELISM_DEGREE) #else - - for( size_t id__ = 0; id__ < PARALLELISM_DEGREE; ++id__ ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) #endif { #if defined(_OPENMP) - size_t id__ = omp_get_thread_num(); + size_t i = omp_get_thread_num(); #endif uint64_t inlen__ = inlen; const uint8_t *in__ = ( const uint8_t * )in; - in__ += id__ * BLAKE2S_BLOCKBYTES; + in__ += i * BLAKE2S_BLOCKBYTES; while( inlen__ >= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES ) { - blake2s_update( S->S[id__], in__, BLAKE2S_BLOCKBYTES ); + blake2s_update( S->S[i], in__, BLAKE2S_BLOCKBYTES ); in__ += PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES; inlen__ -= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES; } @@ -161,8 +165,9 @@ int blake2sp_update( blake2sp_state *S, const uint8_t *in, uint64_t inlen ) int blake2sp_final( blake2sp_state *S, uint8_t *out, const uint8_t outlen ) { uint8_t hash[PARALLELISM_DEGREE][BLAKE2S_OUTBYTES]; + size_t i; - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) { if( S->buflen > i * BLAKE2S_BLOCKBYTES ) { @@ -176,7 +181,7 @@ int blake2sp_final( blake2sp_state *S, uint8_t *out, const uint8_t outlen ) blake2s_final( S->S[i], hash[i], BLAKE2S_OUTBYTES ); } - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2s_update( S->R, hash[i], BLAKE2S_OUTBYTES ); return blake2s_final( S->R, out, outlen ); @@ -188,6 +193,7 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin uint8_t hash[PARALLELISM_DEGREE][BLAKE2S_OUTBYTES]; blake2s_state S[PARALLELISM_DEGREE][1]; blake2s_state FS[1]; + size_t i; /* Verify parameters */ if ( NULL == in && inlen > 0 ) return -1; @@ -200,7 +206,7 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin if( keylen > BLAKE2S_KEYBYTES ) return -1; - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) if( blake2sp_init_leaf( S[i], outlen, keylen, i ) < 0 ) return -1; S[PARALLELISM_DEGREE - 1]->last_node = 1; /* mark last node */ @@ -211,7 +217,7 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin memset( block, 0, BLAKE2S_BLOCKBYTES ); memcpy( block, key, keylen ); - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2s_update( S[i], block, BLAKE2S_BLOCKBYTES ); secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */ @@ -221,31 +227,31 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin #pragma omp parallel shared(S,hash), num_threads(PARALLELISM_DEGREE) #else - for( size_t id__ = 0; id__ < PARALLELISM_DEGREE; ++id__ ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) #endif { #if defined(_OPENMP) - size_t id__ = omp_get_thread_num(); + size_t i = omp_get_thread_num(); #endif uint64_t inlen__ = inlen; const uint8_t *in__ = ( const uint8_t * )in; - in__ += id__ * BLAKE2S_BLOCKBYTES; + in__ += i * BLAKE2S_BLOCKBYTES; while( inlen__ >= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES ) { - blake2s_update( S[id__], in__, BLAKE2S_BLOCKBYTES ); + blake2s_update( S[i], in__, BLAKE2S_BLOCKBYTES ); in__ += PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES; inlen__ -= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES; } - if( inlen__ > id__ * BLAKE2S_BLOCKBYTES ) + if( inlen__ > i * BLAKE2S_BLOCKBYTES ) { - const size_t left = inlen__ - id__ * BLAKE2S_BLOCKBYTES; + const size_t left = inlen__ - i * BLAKE2S_BLOCKBYTES; const size_t len = left <= BLAKE2S_BLOCKBYTES ? left : BLAKE2S_BLOCKBYTES; - blake2s_update( S[id__], in__, len ); + blake2s_update( S[i], in__, len ); } - blake2s_final( S[id__], hash[id__], BLAKE2S_OUTBYTES ); + blake2s_final( S[i], hash[i], BLAKE2S_OUTBYTES ); } if( blake2sp_init_root( FS, outlen, keylen ) < 0 ) @@ -253,7 +259,7 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin FS->last_node = 1; - for( size_t i = 0; i < PARALLELISM_DEGREE; ++i ) + for( i = 0; i < PARALLELISM_DEGREE; ++i ) blake2s_update( FS, hash[i], BLAKE2S_OUTBYTES ); return blake2s_final( FS, out, outlen ); @@ -264,18 +270,19 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin #if defined(BLAKE2SP_SELFTEST) #include <string.h> #include "blake2-kat.h" -int main( int argc, char **argv ) +int main( void ) { uint8_t key[BLAKE2S_KEYBYTES]; uint8_t buf[KAT_LENGTH]; + size_t i; - for( size_t i = 0; i < BLAKE2S_KEYBYTES; ++i ) + for( i = 0; i < BLAKE2S_KEYBYTES; ++i ) key[i] = ( uint8_t )i; - for( size_t i = 0; i < KAT_LENGTH; ++i ) + for( i = 0; i < KAT_LENGTH; ++i ) buf[i] = ( uint8_t )i; - for( size_t i = 0; i < KAT_LENGTH; ++i ) + for( i = 0; i < KAT_LENGTH; ++i ) { uint8_t hash[BLAKE2S_OUTBYTES]; blake2sp( hash, buf, key, BLAKE2S_OUTBYTES, i, BLAKE2S_KEYBYTES ); diff --git a/sse/blake2-impl.h b/sse/blake2-impl.h index bbe3c0f..8314380 100644 --- a/sse/blake2-impl.h +++ b/sse/blake2-impl.h @@ -1,5 +1,5 @@ /* - BLAKE2 reference source code package - optimized C implementations + BLAKE2 reference source code package - reference C implementations Copyright 2012, Samuel Neves <sneves@dei.uc.pt>. You may use this under the terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at @@ -19,7 +19,7 @@ #include <stdint.h> #include <string.h> -BLAKE2_LOCAL_INLINE(uint32_t) load32( const void *src ) +static uint32_t load32( const void *src ) { #if defined(NATIVE_LITTLE_ENDIAN) uint32_t w; @@ -27,15 +27,14 @@ BLAKE2_LOCAL_INLINE(uint32_t) load32( const void *src ) return w; #else const uint8_t *p = ( const uint8_t * )src; - uint32_t w = *p++; - w |= ( uint32_t )( *p++ ) << 8; - w |= ( uint32_t )( *p++ ) << 16; - w |= ( uint32_t )( *p++ ) << 24; - return w; + return (( uint32_t )( p[0] ) << 0) | + (( uint32_t )( p[1] ) << 8) | + (( uint32_t )( p[2] ) << 16) | + (( uint32_t )( p[3] ) << 24) ; #endif } -BLAKE2_LOCAL_INLINE(uint64_t) load64( const void *src ) +static uint64_t load64( const void *src ) { #if defined(NATIVE_LITTLE_ENDIAN) uint64_t w; @@ -43,93 +42,91 @@ BLAKE2_LOCAL_INLINE(uint64_t) load64( const void *src ) return w; #else const uint8_t *p = ( const uint8_t * )src; - uint64_t w = *p++; - w |= ( uint64_t )( *p++ ) << 8; - w |= ( uint64_t )( *p++ ) << 16; - w |= ( uint64_t )( *p++ ) << 24; - w |= ( uint64_t )( *p++ ) << 32; - w |= ( uint64_t )( *p++ ) << 40; - w |= ( uint64_t )( *p++ ) << 48; - w |= ( uint64_t )( *p++ ) << 56; - return w; + return (( uint64_t )( p[0] ) << 0) | + (( uint64_t )( p[1] ) << 8) | + (( uint64_t )( p[2] ) << 16) | + (( uint64_t )( p[3] ) << 24) | + (( uint64_t )( p[4] ) << 32) | + (( uint64_t )( p[5] ) << 40) | + (( uint64_t )( p[6] ) << 48) | + (( uint64_t )( p[7] ) << 56) ; #endif } -BLAKE2_LOCAL_INLINE(void) store32( void *dst, uint32_t w ) +static void store32( void *dst, uint32_t w ) { #if defined(NATIVE_LITTLE_ENDIAN) memcpy(dst, &w, sizeof w); #else uint8_t *p = ( uint8_t * )dst; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; + p[0] = (uint8_t)(w >> 0); + p[1] = (uint8_t)(w >> 8); + p[2] = (uint8_t)(w >> 16); + p[3] = (uint8_t)(w >> 24); #endif } -BLAKE2_LOCAL_INLINE(void) store64( void *dst, uint64_t w ) +static void store64( void *dst, uint64_t w ) { #if defined(NATIVE_LITTLE_ENDIAN) memcpy(dst, &w, sizeof w); #else uint8_t *p = ( uint8_t * )dst; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; + p[0] = (uint8_t)(w >> 0); + p[1] = (uint8_t)(w >> 8); + p[2] = (uint8_t)(w >> 16); + p[3] = (uint8_t)(w >> 24); + p[4] = (uint8_t)(w >> 32); + p[5] = (uint8_t)(w >> 40); + p[6] = (uint8_t)(w >> 48); + p[7] = (uint8_t)(w >> 56); #endif } -BLAKE2_LOCAL_INLINE(uint64_t) load48( const void *src ) +static uint64_t load48( const void *src ) { const uint8_t *p = ( const uint8_t * )src; - uint64_t w = *p++; - w |= ( uint64_t )( *p++ ) << 8; - w |= ( uint64_t )( *p++ ) << 16; - w |= ( uint64_t )( *p++ ) << 24; - w |= ( uint64_t )( *p++ ) << 32; - w |= ( uint64_t )( *p++ ) << 40; - return w; + return (( uint64_t )( p[0] ) << 0) | + (( uint64_t )( p[1] ) << 8) | + (( uint64_t )( p[2] ) << 16) | + (( uint64_t )( p[3] ) << 24) | + (( uint64_t )( p[4] ) << 32) | + (( uint64_t )( p[5] ) << 40) ; } -BLAKE2_LOCAL_INLINE(void) store48( void *dst, uint64_t w ) +static void store48( void *dst, uint64_t w ) { uint8_t *p = ( uint8_t * )dst; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; w >>= 8; - *p++ = ( uint8_t )w; + p[0] = (uint8_t)(w >> 0); + p[1] = (uint8_t)(w >> 8); + p[2] = (uint8_t)(w >> 16); + p[3] = (uint8_t)(w >> 24); + p[4] = (uint8_t)(w >> 32); + p[5] = (uint8_t)(w >> 40); } -BLAKE2_LOCAL_INLINE(uint32_t) rotl32( const uint32_t w, const unsigned c ) +static uint32_t rotl32( const uint32_t w, const unsigned c ) { return ( w << c ) | ( w >> ( 32 - c ) ); } -BLAKE2_LOCAL_INLINE(uint64_t) rotl64( const uint64_t w, const unsigned c ) +static uint64_t rotl64( const uint64_t w, const unsigned c ) { return ( w << c ) | ( w >> ( 64 - c ) ); } -BLAKE2_LOCAL_INLINE(uint32_t) rotr32( const uint32_t w, const unsigned c ) +static uint32_t rotr32( const uint32_t w, const unsigned c ) { return ( w >> c ) | ( w << ( 32 - c ) ); } -BLAKE2_LOCAL_INLINE(uint64_t) rotr64( const uint64_t w, const unsigned c ) +static uint64_t rotr64( const uint64_t w, const unsigned c ) { return ( w >> c ) | ( w << ( 64 - c ) ); } /* prevents compiler optimizing out memset() */ -BLAKE2_LOCAL_INLINE(void) secure_zero_memory(void *v, size_t n) +static void secure_zero_memory(void *v, size_t n) { static void *(*const volatile memset_v)(void *, int, size_t) = &memset; memset_v(v, 0, n); diff --git a/sse/blake2.h b/sse/blake2.h index 1a9fdf4..31b5022 100644 --- a/sse/blake2.h +++ b/sse/blake2.h @@ -148,10 +148,8 @@ extern "C" { int blake2sp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); int blake2bp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); - static inline int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ) - { - return blake2b( out, in, key, outlen, inlen, keylen ); - } + /* This is simply an alias for blake2b */ + int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); #if defined(__cplusplus) } diff --git a/sse/blake2b.c b/sse/blake2b.c index f9090a1..be465b1 100644 --- a/sse/blake2b.c +++ b/sse/blake2b.c @@ -410,6 +410,10 @@ int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen return 0; } +int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ) { + return blake2b(out, in, key, outlen, inlen, keylen); +} + #if defined(SUPERCOP) int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen ) { |