Python code coverage for Modules/_blake2/impl/blake2b-ref.c

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