extlibs/mbedtls/mbedtls/library/sha1.c

   1 /*
   2  *  FIPS-180-1 compliant SHA-1 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-1 standard was published by NIST in 1993.
  23  *
  24  *  http://www.itl.nist.gov/fipspubs/fip180-1.htm
  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_SHA1_C)
  34
  35 #include "mbedtls/sha1.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_SHA1_ALT)
  49
  50 /* Implementation that should never be optimized out by the compiler */
  51 static void mbedtls_zeroize( void *v, size_t n ) {
  52     volatile unsigned char *p = (unsigned char*)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)                            \
  60 {                                                       \
  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 }
  66 #endif
  67
  68 #ifndef PUT_UINT32_BE
  69 #define PUT_UINT32_BE(n,b,i)                            \
  70 {                                                       \
  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 }
  76 #endif
  77
  78 void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
  79 {
  80     memset( ctx, 0, sizeof( mbedtls_sha1_context ) );
  81 }
  82
  83 void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
  84 {
  85     if( ctx == NULL )
  86         return;
  87
  88     mbedtls_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
  89 }
  90
  91 void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
  92                          const mbedtls_sha1_context *src )
  93 {
  94     *dst = *src;
  95 }
  96
  97 /*
  98  * SHA-1 context setup
  99  */
 100 int mbedtls_sha1_starts_ret( mbedtls_sha1_context *ctx )
 101 {
 102     ctx->total[0] = 0;
 103     ctx->total[1] = 0;
 104
 105     ctx->state[0] = 0x67452301;
 106     ctx->state[1] = 0xEFCDAB89;
 107     ctx->state[2] = 0x98BADCFE;
 108     ctx->state[3] = 0x10325476;
 109     ctx->state[4] = 0xC3D2E1F0;
 110
 111     return( 0 );
 112 }
 113
 114 void mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
 115 {
 116     mbedtls_sha1_starts_ret( ctx );
 117 }
 118
 119 #if !defined(MBEDTLS_SHA1_PROCESS_ALT)
 120 int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,
 121                                    const unsigned char data[64] )
 122 {
 123     uint32_t temp, W[16], A, B, C, D, E;
 124
 125     GET_UINT32_BE( W[ 0], data,  0 );
 126     GET_UINT32_BE( W[ 1], data,  4 );
 127     GET_UINT32_BE( W[ 2], data,  8 );
 128     GET_UINT32_BE( W[ 3], data, 12 );
 129     GET_UINT32_BE( W[ 4], data, 16 );
 130     GET_UINT32_BE( W[ 5], data, 20 );
 131     GET_UINT32_BE( W[ 6], data, 24 );
 132     GET_UINT32_BE( W[ 7], data, 28 );
 133     GET_UINT32_BE( W[ 8], data, 32 );
 134     GET_UINT32_BE( W[ 9], data, 36 );
 135     GET_UINT32_BE( W[10], data, 40 );
 136     GET_UINT32_BE( W[11], data, 44 );
 137     GET_UINT32_BE( W[12], data, 48 );
 138     GET_UINT32_BE( W[13], data, 52 );
 139     GET_UINT32_BE( W[14], data, 56 );
 140     GET_UINT32_BE( W[15], data, 60 );
 141
 142 #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
 143
 144 #define R(t)                                            \
 145 (                                                       \
 146     temp = W[( t -  3 ) & 0x0F] ^ W[( t - 8 ) & 0x0F] ^ \
 147            W[( t - 14 ) & 0x0F] ^ W[  t       & 0x0F],  \
 148     ( W[t & 0x0F] = S(temp,1) )                         \
 149 )
 150
 151 #define P(a,b,c,d,e,x)                                  \
 152 {                                                       \
 153     e += S(a,5) + F(b,c,d) + K + x; b = S(b,30);        \
 154 }
 155
 156     A = ctx->state[0];
 157     B = ctx->state[1];
 158     C = ctx->state[2];
 159     D = ctx->state[3];
 160     E = ctx->state[4];
 161
 162 #define F(x,y,z) (z ^ (x & (y ^ z)))
 163 #define K 0x5A827999
 164
 165     P( A, B, C, D, E, W[0]  );
 166     P( E, A, B, C, D, W[1]  );
 167     P( D, E, A, B, C, W[2]  );
 168     P( C, D, E, A, B, W[3]  );
 169     P( B, C, D, E, A, W[4]  );
 170     P( A, B, C, D, E, W[5]  );
 171     P( E, A, B, C, D, W[6]  );
 172     P( D, E, A, B, C, W[7]  );
 173     P( C, D, E, A, B, W[8]  );
 174     P( B, C, D, E, A, W[9]  );
 175     P( A, B, C, D, E, W[10] );
 176     P( E, A, B, C, D, W[11] );
 177     P( D, E, A, B, C, W[12] );
 178     P( C, D, E, A, B, W[13] );
 179     P( B, C, D, E, A, W[14] );
 180     P( A, B, C, D, E, W[15] );
 181     P( E, A, B, C, D, R(16) );
 182     P( D, E, A, B, C, R(17) );
 183     P( C, D, E, A, B, R(18) );
 184     P( B, C, D, E, A, R(19) );
 185
 186 #undef K
 187 #undef F
 188
 189 #define F(x,y,z) (x ^ y ^ z)
 190 #define K 0x6ED9EBA1
 191
 192     P( A, B, C, D, E, R(20) );
 193     P( E, A, B, C, D, R(21) );
 194     P( D, E, A, B, C, R(22) );
 195     P( C, D, E, A, B, R(23) );
 196     P( B, C, D, E, A, R(24) );
 197     P( A, B, C, D, E, R(25) );
 198     P( E, A, B, C, D, R(26) );
 199     P( D, E, A, B, C, R(27) );
 200     P( C, D, E, A, B, R(28) );
 201     P( B, C, D, E, A, R(29) );
 202     P( A, B, C, D, E, R(30) );
 203     P( E, A, B, C, D, R(31) );
 204     P( D, E, A, B, C, R(32) );
 205     P( C, D, E, A, B, R(33) );
 206     P( B, C, D, E, A, R(34) );
 207     P( A, B, C, D, E, R(35) );
 208     P( E, A, B, C, D, R(36) );
 209     P( D, E, A, B, C, R(37) );
 210     P( C, D, E, A, B, R(38) );
 211     P( B, C, D, E, A, R(39) );
 212
 213 #undef K
 214 #undef F
 215
 216 #define F(x,y,z) ((x & y) | (z & (x | y)))
 217 #define K 0x8F1BBCDC
 218
 219     P( A, B, C, D, E, R(40) );
 220     P( E, A, B, C, D, R(41) );
 221     P( D, E, A, B, C, R(42) );
 222     P( C, D, E, A, B, R(43) );
 223     P( B, C, D, E, A, R(44) );
 224     P( A, B, C, D, E, R(45) );
 225     P( E, A, B, C, D, R(46) );
 226     P( D, E, A, B, C, R(47) );
 227     P( C, D, E, A, B, R(48) );
 228     P( B, C, D, E, A, R(49) );
 229     P( A, B, C, D, E, R(50) );
 230     P( E, A, B, C, D, R(51) );
 231     P( D, E, A, B, C, R(52) );
 232     P( C, D, E, A, B, R(53) );
 233     P( B, C, D, E, A, R(54) );
 234     P( A, B, C, D, E, R(55) );
 235     P( E, A, B, C, D, R(56) );
 236     P( D, E, A, B, C, R(57) );
 237     P( C, D, E, A, B, R(58) );
 238     P( B, C, D, E, A, R(59) );
 239
 240 #undef K
 241 #undef F
 242
 243 #define F(x,y,z) (x ^ y ^ z)
 244 #define K 0xCA62C1D6
 245
 246     P( A, B, C, D, E, R(60) );
 247     P( E, A, B, C, D, R(61) );
 248     P( D, E, A, B, C, R(62) );
 249     P( C, D, E, A, B, R(63) );
 250     P( B, C, D, E, A, R(64) );
 251     P( A, B, C, D, E, R(65) );
 252     P( E, A, B, C, D, R(66) );
 253     P( D, E, A, B, C, R(67) );
 254     P( C, D, E, A, B, R(68) );
 255     P( B, C, D, E, A, R(69) );
 256     P( A, B, C, D, E, R(70) );
 257     P( E, A, B, C, D, R(71) );
 258     P( D, E, A, B, C, R(72) );
 259     P( C, D, E, A, B, R(73) );
 260     P( B, C, D, E, A, R(74) );
 261     P( A, B, C, D, E, R(75) );
 262     P( E, A, B, C, D, R(76) );
 263     P( D, E, A, B, C, R(77) );
 264     P( C, D, E, A, B, R(78) );
 265     P( B, C, D, E, A, R(79) );
 266
 267 #undef K
 268 #undef F
 269
 270     ctx->state[0] += A;
 271     ctx->state[1] += B;
 272     ctx->state[2] += C;
 273     ctx->state[3] += D;
 274     ctx->state[4] += E;
 275
 276     return( 0 );
 277 }
 278
 279 void mbedtls_sha1_process( mbedtls_sha1_context *ctx,
 280                            const unsigned char data[64] )
 281 {
 282     mbedtls_internal_sha1_process( ctx, data );
 283 }
 284 #endif /* !MBEDTLS_SHA1_PROCESS_ALT */
 285
 286 /*
 287  * SHA-1 process buffer
 288  */
 289 int mbedtls_sha1_update_ret( mbedtls_sha1_context *ctx,
 290                              const unsigned char *input,
 291                              size_t ilen )
 292 {
 293     int ret;
 294     size_t fill;
 295     uint32_t left;
 296
 297     if( ilen == 0 )
 298         return( 0 );
 299
 300     left = ctx->total[0] & 0x3F;
 301     fill = 64 - left;
 302
 303     ctx->total[0] += (uint32_t) ilen;
 304     ctx->total[0] &= 0xFFFFFFFF;
 305
 306     if( ctx->total[0] < (uint32_t) ilen )
 307         ctx->total[1]++;
 308
 309     if( left && ilen >= fill )
 310     {
 311         memcpy( (void *) (ctx->buffer + left), input, fill );
 312
 313         if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
 314             return( ret );
 315
 316         input += fill;
 317         ilen  -= fill;
 318         left = 0;
 319     }
 320
 321     while( ilen >= 64 )
 322     {
 323         if( ( ret = mbedtls_internal_sha1_process( ctx, input ) ) != 0 )
 324             return( ret );
 325
 326         input += 64;
 327         ilen  -= 64;
 328     }
 329
 330     if( ilen > 0 )
 331         memcpy( (void *) (ctx->buffer + left), input, ilen );
 332
 333     return( 0 );
 334 }
 335
 336 void mbedtls_sha1_update( mbedtls_sha1_context *ctx,
 337                           const unsigned char *input,
 338                           size_t ilen )
 339 {
 340     mbedtls_sha1_update_ret( ctx, input, ilen );
 341 }
 342
 343 /*
 344  * SHA-1 final digest
 345  */
 346 int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx,
 347                              unsigned char output[20] )
 348 {
 349     int ret;
 350     uint32_t used;
 351     uint32_t high, low;
 352
 353     /*
 354      * Add padding: 0x80 then 0x00 until 8 bytes remain for the length
 355      */
 356     used = ctx->total[0] & 0x3F;
 357
 358     ctx->buffer[used++] = 0x80;
 359
 360     if( used <= 56 )
 361     {
 362         /* Enough room for padding + length in current block */
 363         memset( ctx->buffer + used, 0, 56 - used );
 364     }
 365     else
 366     {
 367         /* We'll need an extra block */
 368         memset( ctx->buffer + used, 0, 64 - used );
 369
 370         if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
 371             return( ret );
 372
 373         memset( ctx->buffer, 0, 56 );
 374     }
 375
 376     /*
 377      * Add message length
 378      */
 379     high = ( ctx->total[0] >> 29 )
 380          | ( ctx->total[1] <<  3 );
 381     low  = ( ctx->total[0] <<  3 );
 382
 383     PUT_UINT32_BE( high, ctx->buffer, 56 );
 384     PUT_UINT32_BE( low,  ctx->buffer, 60 );
 385
 386     if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
 387         return( ret );
 388
 389     /*
 390      * Output final state
 391      */
 392     PUT_UINT32_BE( ctx->state[0], output,  0 );
 393     PUT_UINT32_BE( ctx->state[1], output,  4 );
 394     PUT_UINT32_BE( ctx->state[2], output,  8 );
 395     PUT_UINT32_BE( ctx->state[3], output, 12 );
 396     PUT_UINT32_BE( ctx->state[4], output, 16 );
 397
 398     return( 0 );
 399 }
 400
 401 void mbedtls_sha1_finish( mbedtls_sha1_context *ctx,
 402                           unsigned char output[20] )
 403 {
 404     mbedtls_sha1_finish_ret( ctx, output );
 405 }
 406
 407 #endif /* !MBEDTLS_SHA1_ALT */
 408
 409 /*
 410  * output = SHA-1( input buffer )
 411  */
 412 int mbedtls_sha1_ret( const unsigned char *input,
 413                       size_t ilen,
 414                       unsigned char output[20] )
 415 {
 416     int ret;
 417     mbedtls_sha1_context ctx;
 418
 419     mbedtls_sha1_init( &ctx );
 420
 421     if( ( ret = mbedtls_sha1_starts_ret( &ctx ) ) != 0 )
 422         goto exit;
 423
 424     if( ( ret = mbedtls_sha1_update_ret( &ctx, input, ilen ) ) != 0 )
 425         goto exit;
 426
 427     if( ( ret = mbedtls_sha1_finish_ret( &ctx, output ) ) != 0 )
 428         goto exit;
 429
 430 exit:
 431     mbedtls_sha1_free( &ctx );
 432
 433     return( ret );
 434 }
 435
 436 void mbedtls_sha1( const unsigned char *input,
 437                    size_t ilen,
 438                    unsigned char output[20] )
 439 {
 440     mbedtls_sha1_ret( input, ilen, output );
 441 }
 442
 443 #if defined(MBEDTLS_SELF_TEST)
 444 /*
 445  * FIPS-180-1 test vectors
 446  */
 447 static const unsigned char sha1_test_buf[3][57] =
 448 {
 449     { "abc" },
 450     { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
 451     { "" }
 452 };
 453
 454 static const size_t sha1_test_buflen[3] =
 455 {
 456     3, 56, 1000
 457 };
 458
 459 static const unsigned char sha1_test_sum[3][20] =
 460 {
 461     { 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
 462       0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D },
 463     { 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
 464       0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 },
 465     { 0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
 466       0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F }
 467 };
 468
 469 /*
 470  * Checkup routine
 471  */
 472 int mbedtls_sha1_self_test( int verbose )
 473 {
 474     int i, j, buflen, ret = 0;
 475     unsigned char buf[1024];
 476     unsigned char sha1sum[20];
 477     mbedtls_sha1_context ctx;
 478
 479     mbedtls_sha1_init( &ctx );
 480
 481     /*
 482      * SHA-1
 483      */
 484     for( i = 0; i < 3; i++ )
 485     {
 486         if( verbose != 0 )
 487             mbedtls_printf( "  SHA-1 test #%d: ", i + 1 );
 488
 489         if( ( ret = mbedtls_sha1_starts_ret( &ctx ) ) != 0 )
 490             goto fail;
 491
 492         if( i == 2 )
 493         {
 494             memset( buf, 'a', buflen = 1000 );
 495
 496             for( j = 0; j < 1000; j++ )
 497             {
 498                 ret = mbedtls_sha1_update_ret( &ctx, buf, buflen );
 499                 if( ret != 0 )
 500                     goto fail;
 501             }
 502         }
 503         else
 504         {
 505             ret = mbedtls_sha1_update_ret( &ctx, sha1_test_buf[i],
 506                                            sha1_test_buflen[i] );
 507             if( ret != 0 )
 508                 goto fail;
 509         }
 510
 511         if( ( ret = mbedtls_sha1_finish_ret( &ctx, sha1sum ) ) != 0 )
 512             goto fail;
 513
 514         if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
 515         {
 516             ret = 1;
 517             goto fail;
 518         }
 519
 520         if( verbose != 0 )
 521             mbedtls_printf( "passed\n" );
 522     }
 523
 524     if( verbose != 0 )
 525         mbedtls_printf( "\n" );
 526
 527     goto exit;
 528
 529 fail:
 530     if( verbose != 0 )
 531         mbedtls_printf( "failed\n" );
 532
 533 exit:
 534     mbedtls_sha1_free( &ctx );
 535
 536     return( ret );
 537 }
 538
 539 #endif /* MBEDTLS_SELF_TEST */
 540
 541 #endif /* MBEDTLS_SHA1_C */