/src/qtbase/src/3rdparty/blake2/src/blake2b-ref.c

Source
/*
   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
   your option.  The terms of these licenses can be found at:

   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
   - OpenSSL license   : https://www.openssl.org/source/license.html
   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0

   More information about the BLAKE2 hash function can be found at
   https://blake2.net.
*/

#include <stdint.h>
#include <string.h>
#include <stdio.h>

#include "blake2.h"
#include "blake2-impl.h"

static const uint64_t blake2b_IV[8] =
{
  0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL,
  0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
  0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
  0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
};

static const uint8_t blake2b_sigma[12][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 }
};


static void blake2b_set_lastnode( blake2b_state *S )
{
  S->f[1] = (uint64_t)-1;
}

/* Some helper functions, not necessarily useful */
static int blake2b_is_lastblock( const blake2b_state *S )
{
  return S->f[0] != 0;
}

static void blake2b_set_lastblock( blake2b_state *S )
{
  if( S->last_node ) blake2b_set_lastnode( S );

  S->f[0] = (uint64_t)-1;
}

static void blake2b_increment_counter( blake2b_state *S, const uint64_t inc )
{
  S->t[0] += inc;
  S->t[1] += ( S->t[0] < inc );
}

static void blake2b_init0( blake2b_state *S )
{
  size_t i;
  memset( S, 0, sizeof( blake2b_state ) );

  for( i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i];
}

/* init xors IV with input parameter block */
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( i = 0; i < 8; ++i )
    S->h[i] ^= load64( p + sizeof( S->h[i] ) * i );

  S->outlen = P->digest_length;
  return 0;
}



int blake2b_init( blake2b_state *S, size_t outlen )
{
  blake2b_param P[1];

  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;

  P->digest_length = (uint8_t)outlen;
  P->key_length    = 0;
  P->fanout        = 1;
  P->depth         = 1;
  store32( &P->leaf_length, 0 );
  store32( &P->node_offset, 0 );
  store32( &P->xof_length, 0 );
  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 ) );
  return blake2b_init_param( S, P );
}


int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen )
{
  blake2b_param P[1];

  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;

  if ( !key || !keylen || keylen > BLAKE2B_KEYBYTES ) return -1;

  P->digest_length = (uint8_t)outlen;
  P->key_length    = (uint8_t)keylen;
  P->fanout        = 1;
  P->depth         = 1;
  store32( &P->leaf_length, 0 );
  store32( &P->node_offset, 0 );
  store32( &P->xof_length, 0 );
  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;

  {
    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 ); /* Burn the key from stack */
  }
  return 0;
}

#define G(r,i,a,b,c,d)                      \
  do {                                      \
    a = a + b + m[blake2b_sigma[r][2*i+0]]; \
    d = rotr64(d ^ a, 32);                  \
    c = c + d;                              \
    b = rotr64(b ^ c, 24);                  \
    a = a + b + m[blake2b_sigma[r][2*i+1]]; \
    d = rotr64(d ^ a, 16);                  \
    c = c + d;                              \
    b = rotr64(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)

static void blake2b_compress( blake2b_state *S, const uint8_t block[BLAKE2B_BLOCKBYTES] )
{
  uint64_t m[16];
  uint64_t v[16];
  size_t i;

  for( i = 0; i < 16; ++i ) {
    m[i] = load64( block + i * sizeof( m[i] ) );
  }

  for( i = 0; i < 8; ++i ) {
    v[i] = S->h[i];
  }

  v[ 8] = blake2b_IV[0];
  v[ 9] = blake2b_IV[1];
  v[10] = blake2b_IV[2];
  v[11] = blake2b_IV[3];
  v[12] = blake2b_IV[4] ^ S->t[0];
  v[13] = blake2b_IV[5] ^ S->t[1];
  v[14] = blake2b_IV[6] ^ S->f[0];
  v[15] = blake2b_IV[7] ^ S->f[1];

  ROUND( 0 );
  ROUND( 1 );
  ROUND( 2 );
  ROUND( 3 );
  ROUND( 4 );
  ROUND( 5 );
  ROUND( 6 );
  ROUND( 7 );
  ROUND( 8 );
  ROUND( 9 );
  ROUND( 10 );
  ROUND( 11 );

  for( i = 0; i < 8; ++i ) {
    S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
  }
}

#undef G
#undef ROUND

int blake2b_update( blake2b_state *S, const void *pin, size_t inlen )
{
  const unsigned char * in = (const unsigned char *)pin;
  if( inlen > 0 )
  {
    size_t left = S->buflen;
    size_t fill = BLAKE2B_BLOCKBYTES - left;
    if( inlen > fill )
    {
      S->buflen = 0;
      memcpy( S->buf + left, in, fill ); /* Fill buffer */
      blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
      blake2b_compress( S, S->buf ); /* Compress */
      in += fill; inlen -= fill;
      while(inlen > BLAKE2B_BLOCKBYTES) {
        blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
        blake2b_compress( S, in );
        in += BLAKE2B_BLOCKBYTES;
        inlen -= BLAKE2B_BLOCKBYTES;
      }
    }
    memcpy( S->buf + S->buflen, in, inlen );
    S->buflen += inlen;
  }
  return 0;
}

int blake2b_final( blake2b_state *S, void *out, size_t outlen )
{
  uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
  size_t i;

  if( out == NULL || outlen < S->outlen )
    return -1;

  if( blake2b_is_lastblock( S ) )
    return -1;

  blake2b_increment_counter( S, S->buflen );
  blake2b_set_lastblock( S );
  memset( S->buf + S->buflen, 0, BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */
  blake2b_compress( S, S->buf );

  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, S->outlen );
  secure_zero_memory(buffer, sizeof(buffer));
  return 0;
}

/* inlen, at least, should be uint64_t. Others can be size_t. */
int blake2b( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_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( !outlen || outlen > BLAKE2B_OUTBYTES ) return -1;

  if( keylen > BLAKE2B_KEYBYTES ) return -1;

  if( keylen > 0 )
  {
    if( blake2b_init_key( S, outlen, key, keylen ) < 0 ) return -1;
  }
  else
  {
    if( blake2b_init( S, outlen ) < 0 ) return -1;
  }

  blake2b_update( S, ( const uint8_t * )in, inlen );
  blake2b_final( S, out, outlen );
  return 0;
}

int blake2( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ) {
  return blake2b(out, outlen, in, inlen, key, keylen);
}

#if defined(SUPERCOP)
int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen )
{
  return blake2b( out, BLAKE2B_OUTBYTES, in, inlen, NULL, 0 );
}
#endif

#if defined(BLAKE2B_SELFTEST)
#include <string.h>
#include "blake2-kat.h"
int main( void )
{
  uint8_t key[BLAKE2B_KEYBYTES];
  uint8_t buf[BLAKE2_KAT_LENGTH];
  size_t i, step;

  for( i = 0; i < BLAKE2B_KEYBYTES; ++i )
    key[i] = ( uint8_t )i;

  for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )
    buf[i] = ( uint8_t )i;

  /* Test simple API */
  for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )
  {
    uint8_t hash[BLAKE2B_OUTBYTES];
    blake2b( hash, BLAKE2B_OUTBYTES, buf, i, key, BLAKE2B_KEYBYTES );

    if( 0 != memcmp( hash, blake2b_keyed_kat[i], BLAKE2B_OUTBYTES ) )
    {
      goto fail;
    }
  }

  /* Test streaming API */
  for(step = 1; step < BLAKE2B_BLOCKBYTES; ++step) {
    for (i = 0; i < BLAKE2_KAT_LENGTH; ++i) {
      uint8_t hash[BLAKE2B_OUTBYTES];
      blake2b_state S;
      uint8_t * p = buf;
      size_t mlen = i;
      int err = 0;

      if( (err = blake2b_init_key(&S, BLAKE2B_OUTBYTES, key, BLAKE2B_KEYBYTES)) < 0 ) {
        goto fail;
      }

      while (mlen >= step) {
        if ( (err = blake2b_update(&S, p, step)) < 0 ) {
          goto fail;
        }
        mlen -= step;
        p += step;
      }
      if ( (err = blake2b_update(&S, p, mlen)) < 0) {
        goto fail;
      }
      if ( (err = blake2b_final(&S, hash, BLAKE2B_OUTBYTES)) < 0) {
        goto fail;
      }

      if (0 != memcmp(hash, blake2b_keyed_kat[i], BLAKE2B_OUTBYTES)) {
        goto fail;
      }
    }
  }

  puts( "ok" );
  return 0;
fail:
  puts("error");
  return -1;
}
#endif

Coverage Report

Created: 2026-02-14 07:09

Line	Count	Source
1		/*
2		BLAKE2 reference source code package - reference C implementations
3
4		Copyright 2012, Samuel Neves <sneves@dei.uc.pt>. You may use this under the
5		terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
6		your option. The terms of these licenses can be found at:
7
8		- CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
9		- OpenSSL license : https://www.openssl.org/source/license.html
10		- Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0
11
12		More information about the BLAKE2 hash function can be found at
13		https://blake2.net.
14		*/
15
16		#include <stdint.h>
17		#include <string.h>
18		#include <stdio.h>
19
20		#include "blake2.h"
21		#include "blake2-impl.h"
22
23		static const uint64_t blake2b_IV[8] =
24		{
25		0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL,
26		0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
27		0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
28		0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
29		};
30
31		static const uint8_t blake2b_sigma[12][16] =
32		{
33		{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ,
34		{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } ,
35		{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 } ,
36		{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 } ,
37		{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 } ,
38		{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 } ,
39		{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 } ,
40		{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 } ,
41		{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 } ,
42		{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 } ,
43		{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ,
44		{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }
45		};
46
47
48		static void blake2b_set_lastnode( blake2b_state *S )
49	0	{
50	0	S->f[1] = (uint64_t)-1;
51	0	}
52
53		/* Some helper functions, not necessarily useful */
54		static int blake2b_is_lastblock( const blake2b_state *S )
55	0	{
56	0	return S->f[0] != 0;
57	0	}
58
59		static void blake2b_set_lastblock( blake2b_state *S )
60	0	{
61	0	if( S->last_node ) blake2b_set_lastnode( S );
62
63	0	S->f[0] = (uint64_t)-1;
64	0	}
65
66		static void blake2b_increment_counter( blake2b_state *S, const uint64_t inc )
67	0	{
68	0	S->t[0] += inc;
69	0	S->t[1] += ( S->t[0] < inc );
70	0	}
71
72		static void blake2b_init0( blake2b_state *S )
73	0	{
74	0	size_t i;
75	0	memset( S, 0, sizeof( blake2b_state ) );
76
77	0	for( i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i];
78	0	}
79
80		/* init xors IV with input parameter block */
81		int blake2b_init_param( blake2b_state S, const blake2b_param P )
82	0	{
83	0	const uint8_t p = ( const uint8_t )( P );
84	0	size_t i;
85
86	0	blake2b_init0( S );
87
88		/* IV XOR ParamBlock */
89	0	for( i = 0; i < 8; ++i )
90	0	S->h[i] ^= load64( p + sizeof( S->h[i] ) * i );
91
92	0	S->outlen = P->digest_length;
93	0	return 0;
94	0	}
95
96
97
98		int blake2b_init( blake2b_state *S, size_t outlen )
99	0	{
100	0	blake2b_param P[1];
101
102	0	if ( ( !outlen ) \|\| ( outlen > BLAKE2B_OUTBYTES ) ) return -1;
103
104	0	P->digest_length = (uint8_t)outlen;
105	0	P->key_length = 0;
106	0	P->fanout = 1;
107	0	P->depth = 1;
108	0	store32( &P->leaf_length, 0 );
109	0	store32( &P->node_offset, 0 );
110	0	store32( &P->xof_length, 0 );
111	0	P->node_depth = 0;
112	0	P->inner_length = 0;
113	0	memset( P->reserved, 0, sizeof( P->reserved ) );
114	0	memset( P->salt, 0, sizeof( P->salt ) );
115	0	memset( P->personal, 0, sizeof( P->personal ) );
116	0	return blake2b_init_param( S, P );
117	0	}
118
119
120		int blake2b_init_key( blake2b_state S, size_t outlen, const void key, size_t keylen )
121	0	{
122	0	blake2b_param P[1];
123	0
124	0	if ( ( !outlen ) \|\| ( outlen > BLAKE2B_OUTBYTES ) ) return -1;
125	0
126	0	if ( !key \|\| !keylen \|\| keylen > BLAKE2B_KEYBYTES ) return -1;
127	0
128	0	P->digest_length = (uint8_t)outlen;
129	0	P->key_length = (uint8_t)keylen;
130	0	P->fanout = 1;
131	0	P->depth = 1;
132	0	store32( &P->leaf_length, 0 );
133	0	store32( &P->node_offset, 0 );
134	0	store32( &P->xof_length, 0 );
135	0	P->node_depth = 0;
136	0	P->inner_length = 0;
137	0	memset( P->reserved, 0, sizeof( P->reserved ) );
138	0	memset( P->salt, 0, sizeof( P->salt ) );
139	0	memset( P->personal, 0, sizeof( P->personal ) );
140	0
141	0	if( blake2b_init_param( S, P ) < 0 ) return -1;
142	0
143	0	{
144	0	uint8_t block[BLAKE2B_BLOCKBYTES];
145	0	memset( block, 0, BLAKE2B_BLOCKBYTES );
146	0	memcpy( block, key, keylen );
147	0	blake2b_update( S, block, BLAKE2B_BLOCKBYTES );
148	0	secure_zero_memory( block, BLAKE2B_BLOCKBYTES ); /* Burn the key from stack */
149	0	}
150	0	return 0;
151	0	}
152
153		#define G(r,i,a,b,c,d) \
154	0	do { \
155	0	a = a + b + m[blake2b_sigma[r][2*i+0]]; \
156	0	d = rotr64(d ^ a, 32); \
157	0	c = c + d; \
158	0	b = rotr64(b ^ c, 24); \
159	0	a = a + b + m[blake2b_sigma[r][2*i+1]]; \
160	0	d = rotr64(d ^ a, 16); \
161	0	c = c + d; \
162	0	b = rotr64(b ^ c, 63); \
163	0	} while(0)
164
165		#define ROUND(r) \
166	0	do { \
167	0	G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
168	0	G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
169	0	G(r,2,v[ 2],v[ 6],v[10],v[14]); \
170	0	G(r,3,v[ 3],v[ 7],v[11],v[15]); \
171	0	G(r,4,v[ 0],v[ 5],v[10],v[15]); \
172	0	G(r,5,v[ 1],v[ 6],v[11],v[12]); \
173	0	G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
174	0	G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
175	0	} while(0)
176
177		static void blake2b_compress( blake2b_state *S, const uint8_t block[BLAKE2B_BLOCKBYTES] )
178	0	{
179	0	uint64_t m[16];
180	0	uint64_t v[16];
181	0	size_t i;
182
183	0	for( i = 0; i < 16; ++i ) {
184	0	m[i] = load64( block + i * sizeof( m[i] ) );
185	0	}
186
187	0	for( i = 0; i < 8; ++i ) {
188	0	v[i] = S->h[i];
189	0	}
190
191	0	v[ 8] = blake2b_IV[0];
192	0	v[ 9] = blake2b_IV[1];
193	0	v[10] = blake2b_IV[2];
194	0	v[11] = blake2b_IV[3];
195	0	v[12] = blake2b_IV[4] ^ S->t[0];
196	0	v[13] = blake2b_IV[5] ^ S->t[1];
197	0	v[14] = blake2b_IV[6] ^ S->f[0];
198	0	v[15] = blake2b_IV[7] ^ S->f[1];
199
200	0	ROUND( 0 );
201	0	ROUND( 1 );
202	0	ROUND( 2 );
203	0	ROUND( 3 );
204	0	ROUND( 4 );
205	0	ROUND( 5 );
206	0	ROUND( 6 );
207	0	ROUND( 7 );
208	0	ROUND( 8 );
209	0	ROUND( 9 );
210	0	ROUND( 10 );
211	0	ROUND( 11 );
212
213	0	for( i = 0; i < 8; ++i ) {
214	0	S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
215	0	}
216	0	}
217
218		#undef G
219		#undef ROUND
220
221		int blake2b_update( blake2b_state S, const void pin, size_t inlen )
222	0	{
223	0	const unsigned char * in = (const unsigned char *)pin;
224	0	if( inlen > 0 )
225	0	{
226	0	size_t left = S->buflen;
227	0	size_t fill = BLAKE2B_BLOCKBYTES - left;
228	0	if( inlen > fill )
229	0	{
230	0	S->buflen = 0;
231	0	memcpy( S->buf + left, in, fill ); /* Fill buffer */
232	0	blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
233	0	blake2b_compress( S, S->buf ); /* Compress */
234	0	in += fill; inlen -= fill;
235	0	while(inlen > BLAKE2B_BLOCKBYTES) {
236	0	blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
237	0	blake2b_compress( S, in );
238	0	in += BLAKE2B_BLOCKBYTES;
239	0	inlen -= BLAKE2B_BLOCKBYTES;
240	0	}
241	0	}
242	0	memcpy( S->buf + S->buflen, in, inlen );
243	0	S->buflen += inlen;
244	0	}
245	0	return 0;
246	0	}
247
248		int blake2b_final( blake2b_state S, void out, size_t outlen )
249	0	{
250	0	uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
251	0	size_t i;
252
253	0	if( out == NULL \|\| outlen < S->outlen )
254	0	return -1;
255
256	0	if( blake2b_is_lastblock( S ) )
257	0	return -1;
258
259	0	blake2b_increment_counter( S, S->buflen );
260	0	blake2b_set_lastblock( S );
261	0	memset( S->buf + S->buflen, 0, BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */
262	0	blake2b_compress( S, S->buf );
263
264	0	for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
265	0	store64( buffer + sizeof( S->h[i] ) * i, S->h[i] );
266
267	0	memcpy( out, buffer, S->outlen );
268	0	secure_zero_memory(buffer, sizeof(buffer));
269	0	return 0;
270	0	}
271
272		/* inlen, at least, should be uint64_t. Others can be size_t. */
273		int blake2b( void out, size_t outlen, const void in, size_t inlen, const void *key, size_t keylen )
274	0	{
275	0	blake2b_state S[1];
276	0
277	0	/* Verify parameters */
278	0	if ( NULL == in && inlen > 0 ) return -1;
279	0
280	0	if ( NULL == out ) return -1;
281	0
282	0	if( NULL == key && keylen > 0 ) return -1;
283	0
284	0	if( !outlen \|\| outlen > BLAKE2B_OUTBYTES ) return -1;
285	0
286	0	if( keylen > BLAKE2B_KEYBYTES ) return -1;
287	0
288	0	if( keylen > 0 )
289	0	{
290	0	if( blake2b_init_key( S, outlen, key, keylen ) < 0 ) return -1;
291	0	}
292	0	else
293	0	{
294	0	if( blake2b_init( S, outlen ) < 0 ) return -1;
295	0	}
296	0
297	0	blake2b_update( S, ( const uint8_t * )in, inlen );
298	0	blake2b_final( S, out, outlen );
299	0	return 0;
300	0	}
301
302	0	int blake2( void out, size_t outlen, const void in, size_t inlen, const void *key, size_t keylen ) {
303	0	return blake2b(out, outlen, in, inlen, key, keylen);
304	0	}
305
306		#if defined(SUPERCOP)
307		int crypto_hash( unsigned char out, unsigned char in, unsigned long long inlen )
308		{
309		return blake2b( out, BLAKE2B_OUTBYTES, in, inlen, NULL, 0 );
310		}
311		#endif
312
313		#if defined(BLAKE2B_SELFTEST)
314		#include <string.h>
315		#include "blake2-kat.h"
316		int main( void )
317		{
318		uint8_t key[BLAKE2B_KEYBYTES];
319		uint8_t buf[BLAKE2_KAT_LENGTH];
320		size_t i, step;
321
322		for( i = 0; i < BLAKE2B_KEYBYTES; ++i )
323		key[i] = ( uint8_t )i;
324
325		for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )
326		buf[i] = ( uint8_t )i;
327
328		/* Test simple API */
329		for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )
330		{
331		uint8_t hash[BLAKE2B_OUTBYTES];
332		blake2b( hash, BLAKE2B_OUTBYTES, buf, i, key, BLAKE2B_KEYBYTES );
333
334		if( 0 != memcmp( hash, blake2b_keyed_kat[i], BLAKE2B_OUTBYTES ) )
335		{
336		goto fail;
337		}
338		}
339
340		/* Test streaming API */
341		for(step = 1; step < BLAKE2B_BLOCKBYTES; ++step) {
342		for (i = 0; i < BLAKE2_KAT_LENGTH; ++i) {
343		uint8_t hash[BLAKE2B_OUTBYTES];
344		blake2b_state S;
345		uint8_t * p = buf;
346		size_t mlen = i;
347		int err = 0;
348
349		if( (err = blake2b_init_key(&S, BLAKE2B_OUTBYTES, key, BLAKE2B_KEYBYTES)) < 0 ) {
350		goto fail;
351		}
352
353		while (mlen >= step) {
354		if ( (err = blake2b_update(&S, p, step)) < 0 ) {
355		goto fail;
356		}
357		mlen -= step;
358		p += step;
359		}
360		if ( (err = blake2b_update(&S, p, mlen)) < 0) {
361		goto fail;
362		}
363		if ( (err = blake2b_final(&S, hash, BLAKE2B_OUTBYTES)) < 0) {
364		goto fail;
365		}
366
367		if (0 != memcmp(hash, blake2b_keyed_kat[i], BLAKE2B_OUTBYTES)) {
368		goto fail;
369		}
370		}
371		}
372
373		puts( "ok" );
374		return 0;
375		fail:
376		puts("error");
377		return -1;
378		}
379		#endif