This Trac instance is not used for development anymore!

We migrated our development workflow to git and Gitea.
To test the future redirection, replace trac by ariadne in the page URL.

source: ps/trunk/build/premake/premake5/contrib/mbedtls/library/sha256.c

Last change on this file was 20366, checked in by Itms, 7 years ago

Alpha 12 version of Premake 5, including prebuilt binary for Windows.
Directly taken from ​https://premake.github.io/.

Refs #3729.
File size: 12.8 KB
Line 
1/*
2 * FIPS-180-2 compliant SHA-256 implementation
3 *
4 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
5 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
8 * not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * This file is part of mbed TLS (https://tls.mbed.org)
20 */
21/*
22 * The SHA-256 Secure Hash Standard was published by NIST in 2002.
23 *
24 * http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
25 */
26
27#if !defined(MBEDTLS_CONFIG_FILE)
28#include "mbedtls/config.h"
29#else
30#include MBEDTLS_CONFIG_FILE
31#endif
32
33#if defined(MBEDTLS_SHA256_C)
34
35#include "mbedtls/sha256.h"
36
37#include <string.h>
38
39#if defined(MBEDTLS_SELF_TEST)
40#if defined(MBEDTLS_PLATFORM_C)
41#include "mbedtls/platform.h"
42#else
43#include <stdio.h>
44#define mbedtls_printf printf
45#endif /* MBEDTLS_PLATFORM_C */
46#endif /* MBEDTLS_SELF_TEST */
47
48#if !defined(MBEDTLS_SHA256_ALT)
49
50/* Implementation that should never be optimized out by the compiler */
51static void mbedtls_zeroize( void *v, size_t n ) {
52 volatile unsigned char *p = v; while( n-- ) *p++ = 0;
53}
54
55/*
56 * 32-bit integer manipulation macros (big endian)
57 */
58#ifndef GET_UINT32_BE
59#define GET_UINT32_BE(n,b,i) \
60do { \
61 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
62 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
63 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
64 | ( (uint32_t) (b)[(i) + 3] ); \
65} while( 0 )
66#endif
67
68#ifndef PUT_UINT32_BE
69#define PUT_UINT32_BE(n,b,i) \
70do { \
71 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
72 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
73 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
74 (b)[(i) + 3] = (unsigned char) ( (n) ); \
75} while( 0 )
76#endif
77
78void mbedtls_sha256_init( mbedtls_sha256_context *ctx )
79{
80 memset( ctx, 0, sizeof( mbedtls_sha256_context ) );
81}
82
83void mbedtls_sha256_free( mbedtls_sha256_context *ctx )
84{
85 if( ctx == NULL )
86 return;
87
88 mbedtls_zeroize( ctx, sizeof( mbedtls_sha256_context ) );
89}
90
91void mbedtls_sha256_clone( mbedtls_sha256_context *dst,
92 const mbedtls_sha256_context *src )
93{
94 *dst = *src;
95}
96
97/*
98 * SHA-256 context setup
99 */
100void mbedtls_sha256_starts( mbedtls_sha256_context *ctx, int is224 )
101{
102 ctx->total[0] = 0;
103 ctx->total[1] = 0;
104
105 if( is224 == 0 )
106 {
107 /* SHA-256 */
108 ctx->state[0] = 0x6A09E667;
109 ctx->state[1] = 0xBB67AE85;
110 ctx->state[2] = 0x3C6EF372;
111 ctx->state[3] = 0xA54FF53A;
112 ctx->state[4] = 0x510E527F;
113 ctx->state[5] = 0x9B05688C;
114 ctx->state[6] = 0x1F83D9AB;
115 ctx->state[7] = 0x5BE0CD19;
116 }
117 else
118 {
119 /* SHA-224 */
120 ctx->state[0] = 0xC1059ED8;
121 ctx->state[1] = 0x367CD507;
122 ctx->state[2] = 0x3070DD17;
123 ctx->state[3] = 0xF70E5939;
124 ctx->state[4] = 0xFFC00B31;
125 ctx->state[5] = 0x68581511;
126 ctx->state[6] = 0x64F98FA7;
127 ctx->state[7] = 0xBEFA4FA4;
128 }
129
130 ctx->is224 = is224;
131}
132
133#if !defined(MBEDTLS_SHA256_PROCESS_ALT)
134static const uint32_t K[] =
135{
136 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
137 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
138 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
139 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
140 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
141 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
142 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
143 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
144 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
145 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
146 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
147 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
148 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
149 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
150 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
151 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2,
152};
153
154#define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
155#define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
156
157#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
158#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
159
160#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
161#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
162
163#define F0(x,y,z) ((x & y) | (z & (x | y)))
164#define F1(x,y,z) (z ^ (x & (y ^ z)))
165
166#define R(t) \
167( \
168 W[t] = S1(W[t - 2]) + W[t - 7] + \
169 S0(W[t - 15]) + W[t - 16] \
170)
171
172#define P(a,b,c,d,e,f,g,h,x,K) \
173{ \
174 temp1 = h + S3(e) + F1(e,f,g) + K + x; \
175 temp2 = S2(a) + F0(a,b,c); \
176 d += temp1; h = temp1 + temp2; \
177}
178
179void mbedtls_sha256_process( mbedtls_sha256_context *ctx, const unsigned char data[64] )
180{
181 uint32_t temp1, temp2, W[64];
182 uint32_t A[8];
183 unsigned int i;
184
185 for( i = 0; i < 8; i++ )
186 A[i] = ctx->state[i];
187
188#if defined(MBEDTLS_SHA256_SMALLER)
189 for( i = 0; i < 64; i++ )
190 {
191 if( i < 16 )
192 GET_UINT32_BE( W[i], data, 4 * i );
193 else
194 R( i );
195
196 P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i], K[i] );
197
198 temp1 = A[7]; A[7] = A[6]; A[6] = A[5]; A[5] = A[4]; A[4] = A[3];
199 A[3] = A[2]; A[2] = A[1]; A[1] = A[0]; A[0] = temp1;
200 }
201#else /* MBEDTLS_SHA256_SMALLER */
202 for( i = 0; i < 16; i++ )
203 GET_UINT32_BE( W[i], data, 4 * i );
204
205 for( i = 0; i < 16; i += 8 )
206 {
207 P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i+0], K[i+0] );
208 P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], W[i+1], K[i+1] );
209 P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], W[i+2], K[i+2] );
210 P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], W[i+3], K[i+3] );
211 P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], W[i+4], K[i+4] );
212 P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], W[i+5], K[i+5] );
213 P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], W[i+6], K[i+6] );
214 P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], W[i+7], K[i+7] );
215 }
216
217 for( i = 16; i < 64; i += 8 )
218 {
219 P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], R(i+0), K[i+0] );
220 P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], R(i+1), K[i+1] );
221 P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], R(i+2), K[i+2] );
222 P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], R(i+3), K[i+3] );
223 P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], R(i+4), K[i+4] );
224 P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], R(i+5), K[i+5] );
225 P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], R(i+6), K[i+6] );
226 P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], R(i+7), K[i+7] );
227 }
228#endif /* MBEDTLS_SHA256_SMALLER */
229
230 for( i = 0; i < 8; i++ )
231 ctx->state[i] += A[i];
232}
233#endif /* !MBEDTLS_SHA256_PROCESS_ALT */
234
235/*
236 * SHA-256 process buffer
237 */
238void mbedtls_sha256_update( mbedtls_sha256_context *ctx, const unsigned char *input,
239 size_t ilen )
240{
241 size_t fill;
242 uint32_t left;
243
244 if( ilen == 0 )
245 return;
246
247 left = ctx->total[0] & 0x3F;
248 fill = 64 - left;
249
250 ctx->total[0] += (uint32_t) ilen;
251 ctx->total[0] &= 0xFFFFFFFF;
252
253 if( ctx->total[0] < (uint32_t) ilen )
254 ctx->total[1]++;
255
256 if( left && ilen >= fill )
257 {
258 memcpy( (void *) (ctx->buffer + left), input, fill );
259 mbedtls_sha256_process( ctx, ctx->buffer );
260 input += fill;
261 ilen -= fill;
262 left = 0;
263 }
264
265 while( ilen >= 64 )
266 {
267 mbedtls_sha256_process( ctx, input );
268 input += 64;
269 ilen -= 64;
270 }
271
272 if( ilen > 0 )
273 memcpy( (void *) (ctx->buffer + left), input, ilen );
274}
275
276static const unsigned char sha256_padding[64] =
277{
278 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
279 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
280 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
281 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
282};
283
284/*
285 * SHA-256 final digest
286 */
287void mbedtls_sha256_finish( mbedtls_sha256_context *ctx, unsigned char output[32] )
288{
289 uint32_t last, padn;
290 uint32_t high, low;
291 unsigned char msglen[8];
292
293 high = ( ctx->total[0] >> 29 )
294 | ( ctx->total[1] << 3 );
295 low = ( ctx->total[0] << 3 );
296
297 PUT_UINT32_BE( high, msglen, 0 );
298 PUT_UINT32_BE( low, msglen, 4 );
299
300 last = ctx->total[0] & 0x3F;
301 padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
302
303 mbedtls_sha256_update( ctx, sha256_padding, padn );
304 mbedtls_sha256_update( ctx, msglen, 8 );
305
306 PUT_UINT32_BE( ctx->state[0], output, 0 );
307 PUT_UINT32_BE( ctx->state[1], output, 4 );
308 PUT_UINT32_BE( ctx->state[2], output, 8 );
309 PUT_UINT32_BE( ctx->state[3], output, 12 );
310 PUT_UINT32_BE( ctx->state[4], output, 16 );
311 PUT_UINT32_BE( ctx->state[5], output, 20 );
312 PUT_UINT32_BE( ctx->state[6], output, 24 );
313
314 if( ctx->is224 == 0 )
315 PUT_UINT32_BE( ctx->state[7], output, 28 );
316}
317
318#endif /* !MBEDTLS_SHA256_ALT */
319
320/*
321 * output = SHA-256( input buffer )
322 */
323void mbedtls_sha256( const unsigned char *input, size_t ilen,
324 unsigned char output[32], int is224 )
325{
326 mbedtls_sha256_context ctx;
327
328 mbedtls_sha256_init( &ctx );
329 mbedtls_sha256_starts( &ctx, is224 );
330 mbedtls_sha256_update( &ctx, input, ilen );
331 mbedtls_sha256_finish( &ctx, output );
332 mbedtls_sha256_free( &ctx );
333}
334
335#if defined(MBEDTLS_SELF_TEST)
336/*
337 * FIPS-180-2 test vectors
338 */
339static const unsigned char sha256_test_buf[3][57] =
340{
341 { "abc" },
342 { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
343 { "" }
344};
345
346static const int sha256_test_buflen[3] =
347{
348 3, 56, 1000
349};
350
351static const unsigned char sha256_test_sum[6][32] =
352{
353 /*
354 * SHA-224 test vectors
355 */
356 { 0x23, 0x09, 0x7D, 0x22, 0x34, 0x05, 0xD8, 0x22,
357 0x86, 0x42, 0xA4, 0x77, 0xBD, 0xA2, 0x55, 0xB3,
358 0x2A, 0xAD, 0xBC, 0xE4, 0xBD, 0xA0, 0xB3, 0xF7,
359 0xE3, 0x6C, 0x9D, 0xA7 },
360 { 0x75, 0x38, 0x8B, 0x16, 0x51, 0x27, 0x76, 0xCC,
361 0x5D, 0xBA, 0x5D, 0xA1, 0xFD, 0x89, 0x01, 0x50,
362 0xB0, 0xC6, 0x45, 0x5C, 0xB4, 0xF5, 0x8B, 0x19,
363 0x52, 0x52, 0x25, 0x25 },
364 { 0x20, 0x79, 0x46, 0x55, 0x98, 0x0C, 0x91, 0xD8,
365 0xBB, 0xB4, 0xC1, 0xEA, 0x97, 0x61, 0x8A, 0x4B,
366 0xF0, 0x3F, 0x42, 0x58, 0x19, 0x48, 0xB2, 0xEE,
367 0x4E, 0xE7, 0xAD, 0x67 },
368
369 /*
370 * SHA-256 test vectors
371 */
372 { 0xBA, 0x78, 0x16, 0xBF, 0x8F, 0x01, 0xCF, 0xEA,
373 0x41, 0x41, 0x40, 0xDE, 0x5D, 0xAE, 0x22, 0x23,
374 0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17, 0x7A, 0x9C,
375 0xB4, 0x10, 0xFF, 0x61, 0xF2, 0x00, 0x15, 0xAD },
376 { 0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8,
377 0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39,
378 0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67,
379 0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1 },
380 { 0xCD, 0xC7, 0x6E, 0x5C, 0x99, 0x14, 0xFB, 0x92,
381 0x81, 0xA1, 0xC7, 0xE2, 0x84, 0xD7, 0x3E, 0x67,
382 0xF1, 0x80, 0x9A, 0x48, 0xA4, 0x97, 0x20, 0x0E,
383 0x04, 0x6D, 0x39, 0xCC, 0xC7, 0x11, 0x2C, 0xD0 }
384};
385
386/*
387 * Checkup routine
388 */
389int mbedtls_sha256_self_test( int verbose )
390{
391 int i, j, k, buflen, ret = 0;
392 unsigned char buf[1024];
393 unsigned char sha256sum[32];
394 mbedtls_sha256_context ctx;
395
396 mbedtls_sha256_init( &ctx );
397
398 for( i = 0; i < 6; i++ )
399 {
400 j = i % 3;
401 k = i < 3;
402
403 if( verbose != 0 )
404 mbedtls_printf( " SHA-%d test #%d: ", 256 - k * 32, j + 1 );
405
406 mbedtls_sha256_starts( &ctx, k );
407
408 if( j == 2 )
409 {
410 memset( buf, 'a', buflen = 1000 );
411
412 for( j = 0; j < 1000; j++ )
413 mbedtls_sha256_update( &ctx, buf, buflen );
414 }
415 else
416 mbedtls_sha256_update( &ctx, sha256_test_buf[j],
417 sha256_test_buflen[j] );
418
419 mbedtls_sha256_finish( &ctx, sha256sum );
420
421 if( memcmp( sha256sum, sha256_test_sum[i], 32 - k * 4 ) != 0 )
422 {
423 if( verbose != 0 )
424 mbedtls_printf( "failed\n" );
425
426 ret = 1;
427 goto exit;
428 }
429
430 if( verbose != 0 )
431 mbedtls_printf( "passed\n" );
432 }
433
434 if( verbose != 0 )
435 mbedtls_printf( "\n" );
436
437exit:
438 mbedtls_sha256_free( &ctx );
439
440 return( ret );
441}
442
443#endif /* MBEDTLS_SELF_TEST */
444
445#endif /* MBEDTLS_SHA256_C */
Note: See TracBrowser for help on using the repository browser.