TeaSpeak/tomcrypt
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

clang-format

Browse Source
This commit is contained in:
Kelvin Sherlock 2017-04-08 15:43:38 -04:00
parent 7c5fef9b71
commit 6f6e2d30a8
1 changed files with 137 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

291
src/hashes/blake2b.c
View File

@ -27,18 +27,15 @@
#ifdef LTC_BLAKE2B #ifdef LTC_BLAKE2B
enum blake2b_constant enum blake2b_constant {
{ BLAKE2B_BLOCKBYTES = 128,
BLAKE2B_BLOCKBYTES = 128, BLAKE2B_OUTBYTES = 64,
BLAKE2B_OUTBYTES = 64, BLAKE2B_KEYBYTES = 64,
BLAKE2B_KEYBYTES = 64, BLAKE2B_SALTBYTES = 16,
BLAKE2B_SALTBYTES = 16, BLAKE2B_PERSONALBYTES = 16
BLAKE2B_PERSONALBYTES = 16 };
};
struct blake2b_param {
struct blake2b_param
{
unsigned char digest_length; unsigned char digest_length;
unsigned char key_length; unsigned char key_length;
unsigned char fanout; unsigned char fanout;
@ -138,75 +135,68 @@ static const unsigned char blake2b_sigma[12][16] =
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }
}; };
static void blake2b_set_lastnode(hash_state *md) { md->blake2b.f[1] = CONST64(0xffffffffffffffff); }
static void blake2b_set_lastnode( hash_state *md )
{
md->blake2b.f[1] = CONST64(0xffffffffffffffff);
}
/* Some helper functions, not necessarily useful */ /* Some helper functions, not necessarily useful */
static int blake2b_is_lastblock( const hash_state *md ) static int blake2b_is_lastblock(const hash_state *md) { return md->blake2b.f[0] != 0; }
static void blake2b_set_lastblock(hash_state *md)
{ {
return md->blake2b.f[0] != 0; if (md->blake2b.last_node)
blake2b_set_lastnode(md);
md->blake2b.f[0] = CONST64(0xffffffffffffffff);
} }
static void blake2b_set_lastblock( hash_state *md ) static void blake2b_increment_counter(hash_state *md, ulong64 inc)
{ {
if( md->blake2b.last_node ) blake2b_set_lastnode( md ); md->blake2b.t[0] += inc;
md->blake2b.t[1] += (md->blake2b.t[0] < inc);
md->blake2b.f[0] = CONST64(0xffffffffffffffff);
} }
static void blake2b_increment_counter( hash_state *md, ulong64 inc ) static void blake2b_init0(hash_state *md)
{ {
md->blake2b.t[0] += inc; unsigned long i;
md->blake2b.t[1] += ( md->blake2b.t[0] < inc ); XMEMSET(&md->blake2b, 0, sizeof(md->blake2b));
}
static void blake2b_init0( hash_state *md ) for (i = 0; i < 8; ++i)
{ md->blake2b.h[i] = blake2b_IV[i];
unsigned long i;
XMEMSET( &md->blake2b, 0, sizeof( md->blake2b ) );
for( i = 0; i < 8; ++i ) md->blake2b.h[i] = blake2b_IV[i];
} }
/* init xors IV with input parameter block */ /* init xors IV with input parameter block */
int blake2b_init_param( hash_state *md, const struct blake2b_param *P ) int blake2b_init_param(hash_state *md, const struct blake2b_param *P)
{ {
const unsigned char *p = ( const unsigned char * )( P ); const unsigned char *p = (const unsigned char *)(P);
unsigned long i; unsigned long i;
blake2b_init0( md ); blake2b_init0(md);
/* IV XOR ParamBlock */ /* IV XOR ParamBlock */
for( i = 0; i < 8; ++i ) { for (i = 0; i < 8; ++i) {
ulong64 tmp; ulong64 tmp;
LOAD64L(tmp, p + sizeof( md->blake2b.h[i] ) * i ); LOAD64L(tmp, p + sizeof(md->blake2b.h[i]) * i);
md->blake2b.h[i] ^= tmp; md->blake2b.h[i] ^= tmp;
} }
md->blake2b.outlen = P->digest_length; md->blake2b.outlen = P->digest_length;
return CRYPT_OK; return CRYPT_OK;
} }
int blake2b_init(hash_state *md, unsigned long outlen)
int blake2b_init( hash_state *md, unsigned long outlen )
{ {
struct blake2b_param P; struct blake2b_param P;
LTC_ARGCHK(md != NULL); LTC_ARGCHK(md != NULL);
if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) if ((!outlen) || (outlen > BLAKE2B_OUTBYTES))
return CRYPT_INVALID_ARG; return CRYPT_INVALID_ARG;
XMEMSET(&P, 0, sizeof(P)); XMEMSET(&P, 0, sizeof(P));
P.digest_length = (unsigned char)outlen; P.digest_length = (unsigned char)outlen;
P.fanout = 1; P.fanout = 1;
P.depth = 1; P.depth = 1;
return blake2b_init_param( md, &P ); return blake2b_init_param(md, &P);
} }
int blake2b_160_init(hash_state *md) { return blake2b_init(md, 20); } int blake2b_160_init(hash_state *md) { return blake2b_init(md, 20); }
@ -217,32 +207,29 @@ int blake2b_384_init(hash_state *md) { return blake2b_init(md, 48); }
int blake2b_512_init(hash_state *md) { return blake2b_init(md, 64); } int blake2b_512_init(hash_state *md) { return blake2b_init(md, 64); }
#define G(r, i, a, b, c, d) \
do { \
a = a + b + m[blake2b_sigma[r][2 * i + 0]]; \
d = ROR64(d ^ a, 32); \
c = c + d; \
b = ROR64(b ^ c, 24); \
a = a + b + m[blake2b_sigma[r][2 * i + 1]]; \
d = ROR64(d ^ a, 16); \
c = c + d; \
b = ROR64(b ^ c, 63); \
} while (0)
#define ROUND(r) \
do { \
#define G(r,i,a,b,c,d) \ G(r, 0, v[0], v[4], v[8], v[12]); \
do { \ G(r, 1, v[1], v[5], v[9], v[13]); \
a = a + b + m[blake2b_sigma[r][2*i+0]]; \ G(r, 2, v[2], v[6], v[10], v[14]); \
d = ROR64(d ^ a, 32); \ G(r, 3, v[3], v[7], v[11], v[15]); \
c = c + d; \ G(r, 4, v[0], v[5], v[10], v[15]); \
b = ROR64(b ^ c, 24); \ G(r, 5, v[1], v[6], v[11], v[12]); \
a = a + b + m[blake2b_sigma[r][2*i+1]]; \ G(r, 6, v[2], v[7], v[8], v[13]); \
d = ROR64(d ^ a, 16); \ G(r, 7, v[3], v[4], v[9], v[14]); \
c = c + d; \ } while (0)
b = ROR64(b ^ c, 63); \
} while(0)
#define ROUND(r) \
do { \
G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
G(r,2,v[ 2],v[ 6],v[10],v[14]); \
G(r,3,v[ 3],v[ 7],v[11],v[15]); \
G(r,4,v[ 0],v[ 5],v[10],v[15]); \
G(r,5,v[ 1],v[ 6],v[11],v[12]); \
G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
} while(0)
#ifdef LTC_CLEAN_STACK #ifdef LTC_CLEAN_STACK
static int _blake2b_compress(hash_state *md, const unsigned char *buf) static int _blake2b_compress(hash_state *md, const unsigned char *buf)
@ -250,44 +237,44 @@ static int _blake2b_compress(hash_state *md, const unsigned char *buf)
static int blake2b_compress(hash_state *md, const unsigned char *buf) static int blake2b_compress(hash_state *md, const unsigned char *buf)
#endif #endif
{ {
ulong64 m[16]; ulong64 m[16];
ulong64 v[16]; ulong64 v[16];
unsigned long i; unsigned long i;
for( i = 0; i < 16; ++i ) { for (i = 0; i < 16; ++i) {
LOAD64L(m[i], buf + i * sizeof( m[i] ) ); LOAD64L(m[i], buf + i * sizeof(m[i]));
} }
for( i = 0; i < 8; ++i ) { for (i = 0; i < 8; ++i) {
v[i] = md->blake2b.h[i]; v[i] = md->blake2b.h[i];
} }
v[ 8] = blake2b_IV[0]; v[8] = blake2b_IV[0];
v[ 9] = blake2b_IV[1]; v[9] = blake2b_IV[1];
v[10] = blake2b_IV[2]; v[10] = blake2b_IV[2];
v[11] = blake2b_IV[3]; v[11] = blake2b_IV[3];
v[12] = blake2b_IV[4] ^ md->blake2b.t[0]; v[12] = blake2b_IV[4] ^ md->blake2b.t[0];
v[13] = blake2b_IV[5] ^ md->blake2b.t[1]; v[13] = blake2b_IV[5] ^ md->blake2b.t[1];
v[14] = blake2b_IV[6] ^ md->blake2b.f[0]; v[14] = blake2b_IV[6] ^ md->blake2b.f[0];
v[15] = blake2b_IV[7] ^ md->blake2b.f[1]; v[15] = blake2b_IV[7] ^ md->blake2b.f[1];
ROUND( 0 ); ROUND(0);
ROUND( 1 ); ROUND(1);
ROUND( 2 ); ROUND(2);
ROUND( 3 ); ROUND(3);
ROUND( 4 ); ROUND(4);
ROUND( 5 ); ROUND(5);
ROUND( 6 ); ROUND(6);
ROUND( 7 ); ROUND(7);
ROUND( 8 ); ROUND(8);
ROUND( 9 ); ROUND(9);
ROUND( 10 ); ROUND(10);
ROUND( 11 ); ROUND(11);
for( i = 0; i < 8; ++i ) { for (i = 0; i < 8; ++i) {
md->blake2b.h[i] = md->blake2b.h[i] ^ v[i] ^ v[i + 8]; md->blake2b.h[i] = md->blake2b.h[i] ^ v[i] ^ v[i + 8];
} }
return CRYPT_OK; return CRYPT_OK;
} }
#undef G #undef G
@ -303,63 +290,60 @@ static int blake2b_compress(hash_state *md, const unsigned char *buf)
} }
#endif #endif
int blake2b_process( hash_state *md, const unsigned char *in, unsigned long inlen ) int blake2b_process(hash_state *md, const unsigned char *in, unsigned long inlen)
{ {
if( inlen > 0 ) if (inlen > 0) {
{ unsigned long left = md->blake2b.curlen;
unsigned long left = md->blake2b.curlen; unsigned long fill = BLAKE2B_BLOCKBYTES - left;
unsigned long fill = BLAKE2B_BLOCKBYTES - left; if (inlen > fill) {
if( inlen > fill ) md->blake2b.curlen = 0;
{ XMEMCPY(md->blake2b.buf + left, in, fill); /* Fill buffer */
md->blake2b.curlen = 0; blake2b_increment_counter(md, BLAKE2B_BLOCKBYTES);
XMEMCPY( md->blake2b.buf + left, in, fill ); /* Fill buffer */ blake2b_compress(md, md->blake2b.buf); /* Compress */
blake2b_increment_counter( md, BLAKE2B_BLOCKBYTES ); in += fill;
blake2b_compress( md, md->blake2b.buf ); /* Compress */ inlen -= fill;
in += fill; inlen -= fill; while (inlen > BLAKE2B_BLOCKBYTES) {
while(inlen > BLAKE2B_BLOCKBYTES) { blake2b_increment_counter(md, BLAKE2B_BLOCKBYTES);
blake2b_increment_counter(md, BLAKE2B_BLOCKBYTES); blake2b_compress(md, in);
blake2b_compress( md, in ); in += BLAKE2B_BLOCKBYTES;
in += BLAKE2B_BLOCKBYTES; inlen -= BLAKE2B_BLOCKBYTES;
inlen -= BLAKE2B_BLOCKBYTES; }
} }
} XMEMCPY(md->blake2b.buf + md->blake2b.curlen, in, inlen);
XMEMCPY( md->blake2b.buf + md->blake2b.curlen, in, inlen ); md->blake2b.curlen += inlen;
md->blake2b.curlen += inlen; }
} return CRYPT_OK;
return CRYPT_OK;
} }
int blake2b_done( hash_state *md, unsigned char *out) int blake2b_done(hash_state *md, unsigned char *out)
{ {
unsigned char buffer[BLAKE2B_OUTBYTES] = {0}; unsigned char buffer[BLAKE2B_OUTBYTES] = { 0 };
unsigned long i; unsigned long i;
LTC_ARGCHK(md != NULL); LTC_ARGCHK(md != NULL);
LTC_ARGCHK(out != NULL); LTC_ARGCHK(out != NULL);
/* if(md->blakebs.outlen != outlen) return CRYPT_INVALID_ARG; */ /* if(md->blakebs.outlen != outlen) return CRYPT_INVALID_ARG; */
if (blake2b_is_lastblock(md))
return CRYPT_ERROR;
if( blake2b_is_lastblock( md ) ) blake2b_increment_counter(md, md->blake2b.curlen);
return CRYPT_ERROR; blake2b_set_lastblock(md);
XMEMSET(md->blake2b.buf + md->blake2b.curlen, 0, BLAKE2B_BLOCKBYTES - md->blake2b.curlen); /* Padding */
blake2b_compress(md, md->blake2b.buf);
blake2b_increment_counter( md, md->blake2b.curlen ); for (i = 0; i < 8; ++i) /* Output full hash to temp buffer */
blake2b_set_lastblock( md ); STORE64L(md->blake2b.h[i], buffer + sizeof(md->blake2b.h[i]) * i);
XMEMSET( md->blake2b.buf + md->blake2b.curlen, 0, BLAKE2B_BLOCKBYTES - md->blake2b.curlen ); /* Padding */
blake2b_compress( md, md->blake2b.buf );
for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */ XMEMCPY(out, buffer, md->blake2b.outlen);
STORE64L( md->blake2b.h[i], buffer + sizeof( md->blake2b.h[i] ) * i );
XMEMCPY( out, buffer, md->blake2b.outlen );
#ifdef LTC_CLEAN_STACK #ifdef LTC_CLEAN_STACK
zeromem(buffer, sizeof(buffer)); zeromem(buffer, sizeof(buffer));
zeromem(md, sizeof(hash_state)); zeromem(md, sizeof(hash_state));
#endif #endif
return CRYPT_OK; return CRYPT_OK;
} }
/** /**
Self-test the hash Self-test the hash
@return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
@ -542,5 +526,4 @@ int blake2b_160_test(void)
#endif #endif
} }
#endif #endif