src/src/pdkim/sha2.c

   1 /* $Cambridge: exim/src/src/pdkim/sha2.c,v 1.1.2.1 2009/02/24 13:13:47 tom Exp $ */
   2 /*
   3  *  FIPS-180-2 compliant SHA-256 implementation
   4  *
   5  *  Based on XySSL: Copyright (C) 2006-2008  Christophe Devine
   6  *
   7  *  Copyright (C) 2009  Paul Bakker <polarssl_maintainer at polarssl dot org>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License along
  20  *  with this program; if not, write to the Free Software Foundation, Inc.,
  21  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  22  */
  23 /*
  24  *  The SHA-256 Secure Hash Standard was published by NIST in 2002.
  25  *
  26  *  http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
  27  */
  28
  29 #include "sha2.h"
  30
  31 #include <string.h>
  32 #include <stdio.h>
  33
  34 /*
  35  * 32-bit integer manipulation macros (big endian)
  36  */
  37 #ifndef GET_ULONG_BE
  38 #define GET_ULONG_BE(n,b,i)                             \
  39 {                                                       \
  40     (n) = ( (unsigned long) (b)[(i)    ] << 24 )        \
  41         | ( (unsigned long) (b)[(i) + 1] << 16 )        \
  42         | ( (unsigned long) (b)[(i) + 2] <<  8 )        \
  43         | ( (unsigned long) (b)[(i) + 3]       );       \
  44 }
  45 #endif
  46
  47 #ifndef PUT_ULONG_BE
  48 #define PUT_ULONG_BE(n,b,i)                             \
  49 {                                                       \
  50     (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
  51     (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
  52     (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
  53     (b)[(i) + 3] = (unsigned char) ( (n)       );       \
  54 }
  55 #endif
  56
  57 /*
  58  * SHA-256 context setup
  59  */
  60 void sha2_starts( sha2_context *ctx, int is224 )
  61 {
  62     ctx->total[0] = 0;
  63     ctx->total[1] = 0;
  64
  65     if( is224 == 0 )
  66     {
  67         /* SHA-256 */
  68         ctx->state[0] = 0x6A09E667;
  69         ctx->state[1] = 0xBB67AE85;
  70         ctx->state[2] = 0x3C6EF372;
  71         ctx->state[3] = 0xA54FF53A;
  72         ctx->state[4] = 0x510E527F;
  73         ctx->state[5] = 0x9B05688C;
  74         ctx->state[6] = 0x1F83D9AB;
  75         ctx->state[7] = 0x5BE0CD19;
  76     }
  77     else
  78     {
  79         /* SHA-224 */
  80         ctx->state[0] = 0xC1059ED8;
  81         ctx->state[1] = 0x367CD507;
  82         ctx->state[2] = 0x3070DD17;
  83         ctx->state[3] = 0xF70E5939;
  84         ctx->state[4] = 0xFFC00B31;
  85         ctx->state[5] = 0x68581511;
  86         ctx->state[6] = 0x64F98FA7;
  87         ctx->state[7] = 0xBEFA4FA4;
  88     }
  89
  90     ctx->is224 = is224;
  91 }
  92
  93 static void sha2_process( sha2_context *ctx, unsigned char data[64] )
  94 {
  95     unsigned long temp1, temp2, W[64];
  96     unsigned long A, B, C, D, E, F, G, H;
  97
  98     GET_ULONG_BE( W[ 0], data,  0 );
  99     GET_ULONG_BE( W[ 1], data,  4 );
 100     GET_ULONG_BE( W[ 2], data,  8 );
 101     GET_ULONG_BE( W[ 3], data, 12 );
 102     GET_ULONG_BE( W[ 4], data, 16 );
 103     GET_ULONG_BE( W[ 5], data, 20 );
 104     GET_ULONG_BE( W[ 6], data, 24 );
 105     GET_ULONG_BE( W[ 7], data, 28 );
 106     GET_ULONG_BE( W[ 8], data, 32 );
 107     GET_ULONG_BE( W[ 9], data, 36 );
 108     GET_ULONG_BE( W[10], data, 40 );
 109     GET_ULONG_BE( W[11], data, 44 );
 110     GET_ULONG_BE( W[12], data, 48 );
 111     GET_ULONG_BE( W[13], data, 52 );
 112     GET_ULONG_BE( W[14], data, 56 );
 113     GET_ULONG_BE( W[15], data, 60 );
 114
 115 #define  SHR(x,n) ((x & 0xFFFFFFFF) >> n)
 116 #define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
 117
 118 #define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^  SHR(x, 3))
 119 #define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^  SHR(x,10))
 120
 121 #define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
 122 #define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
 123
 124 #define F0(x,y,z) ((x & y) | (z & (x | y)))
 125 #define F1(x,y,z) (z ^ (x & (y ^ z)))
 126
 127 #define R(t)                                    \
 128 (                                               \
 129     W[t] = S1(W[t -  2]) + W[t -  7] +          \
 130            S0(W[t - 15]) + W[t - 16]            \
 131 )
 132
 133 #define P(a,b,c,d,e,f,g,h,x,K)                  \
 134 {                                               \
 135     temp1 = h + S3(e) + F1(e,f,g) + K + x;      \
 136     temp2 = S2(a) + F0(a,b,c);                  \
 137     d += temp1; h = temp1 + temp2;              \
 138 }
 139
 140     A = ctx->state[0];
 141     B = ctx->state[1];
 142     C = ctx->state[2];
 143     D = ctx->state[3];
 144     E = ctx->state[4];
 145     F = ctx->state[5];
 146     G = ctx->state[6];
 147     H = ctx->state[7];
 148
 149     P( A, B, C, D, E, F, G, H, W[ 0], 0x428A2F98 );
 150     P( H, A, B, C, D, E, F, G, W[ 1], 0x71374491 );
 151     P( G, H, A, B, C, D, E, F, W[ 2], 0xB5C0FBCF );
 152     P( F, G, H, A, B, C, D, E, W[ 3], 0xE9B5DBA5 );
 153     P( E, F, G, H, A, B, C, D, W[ 4], 0x3956C25B );
 154     P( D, E, F, G, H, A, B, C, W[ 5], 0x59F111F1 );
 155     P( C, D, E, F, G, H, A, B, W[ 6], 0x923F82A4 );
 156     P( B, C, D, E, F, G, H, A, W[ 7], 0xAB1C5ED5 );
 157     P( A, B, C, D, E, F, G, H, W[ 8], 0xD807AA98 );
 158     P( H, A, B, C, D, E, F, G, W[ 9], 0x12835B01 );
 159     P( G, H, A, B, C, D, E, F, W[10], 0x243185BE );
 160     P( F, G, H, A, B, C, D, E, W[11], 0x550C7DC3 );
 161     P( E, F, G, H, A, B, C, D, W[12], 0x72BE5D74 );
 162     P( D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE );
 163     P( C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7 );
 164     P( B, C, D, E, F, G, H, A, W[15], 0xC19BF174 );
 165     P( A, B, C, D, E, F, G, H, R(16), 0xE49B69C1 );
 166     P( H, A, B, C, D, E, F, G, R(17), 0xEFBE4786 );
 167     P( G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6 );
 168     P( F, G, H, A, B, C, D, E, R(19), 0x240CA1CC );
 169     P( E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F );
 170     P( D, E, F, G, H, A, B, C, R(21), 0x4A7484AA );
 171     P( C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC );
 172     P( B, C, D, E, F, G, H, A, R(23), 0x76F988DA );
 173     P( A, B, C, D, E, F, G, H, R(24), 0x983E5152 );
 174     P( H, A, B, C, D, E, F, G, R(25), 0xA831C66D );
 175     P( G, H, A, B, C, D, E, F, R(26), 0xB00327C8 );
 176     P( F, G, H, A, B, C, D, E, R(27), 0xBF597FC7 );
 177     P( E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3 );
 178     P( D, E, F, G, H, A, B, C, R(29), 0xD5A79147 );
 179     P( C, D, E, F, G, H, A, B, R(30), 0x06CA6351 );
 180     P( B, C, D, E, F, G, H, A, R(31), 0x14292967 );
 181     P( A, B, C, D, E, F, G, H, R(32), 0x27B70A85 );
 182     P( H, A, B, C, D, E, F, G, R(33), 0x2E1B2138 );
 183     P( G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC );
 184     P( F, G, H, A, B, C, D, E, R(35), 0x53380D13 );
 185     P( E, F, G, H, A, B, C, D, R(36), 0x650A7354 );
 186     P( D, E, F, G, H, A, B, C, R(37), 0x766A0ABB );
 187     P( C, D, E, F, G, H, A, B, R(38), 0x81C2C92E );
 188     P( B, C, D, E, F, G, H, A, R(39), 0x92722C85 );
 189     P( A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1 );
 190     P( H, A, B, C, D, E, F, G, R(41), 0xA81A664B );
 191     P( G, H, A, B, C, D, E, F, R(42), 0xC24B8B70 );
 192     P( F, G, H, A, B, C, D, E, R(43), 0xC76C51A3 );
 193     P( E, F, G, H, A, B, C, D, R(44), 0xD192E819 );
 194     P( D, E, F, G, H, A, B, C, R(45), 0xD6990624 );
 195     P( C, D, E, F, G, H, A, B, R(46), 0xF40E3585 );
 196     P( B, C, D, E, F, G, H, A, R(47), 0x106AA070 );
 197     P( A, B, C, D, E, F, G, H, R(48), 0x19A4C116 );
 198     P( H, A, B, C, D, E, F, G, R(49), 0x1E376C08 );
 199     P( G, H, A, B, C, D, E, F, R(50), 0x2748774C );
 200     P( F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5 );
 201     P( E, F, G, H, A, B, C, D, R(52), 0x391C0CB3 );
 202     P( D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A );
 203     P( C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F );
 204     P( B, C, D, E, F, G, H, A, R(55), 0x682E6FF3 );
 205     P( A, B, C, D, E, F, G, H, R(56), 0x748F82EE );
 206     P( H, A, B, C, D, E, F, G, R(57), 0x78A5636F );
 207     P( G, H, A, B, C, D, E, F, R(58), 0x84C87814 );
 208     P( F, G, H, A, B, C, D, E, R(59), 0x8CC70208 );
 209     P( E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA );
 210     P( D, E, F, G, H, A, B, C, R(61), 0xA4506CEB );
 211     P( C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7 );
 212     P( B, C, D, E, F, G, H, A, R(63), 0xC67178F2 );
 213
 214     ctx->state[0] += A;
 215     ctx->state[1] += B;
 216     ctx->state[2] += C;
 217     ctx->state[3] += D;
 218     ctx->state[4] += E;
 219     ctx->state[5] += F;
 220     ctx->state[6] += G;
 221     ctx->state[7] += H;
 222 }
 223
 224 /*
 225  * SHA-256 process buffer
 226  */
 227 void sha2_update( sha2_context *ctx, unsigned char *input, int ilen )
 228 {
 229     int fill;
 230     unsigned long left;
 231
 232     if( ilen <= 0 )
 233         return;
 234
 235     left = ctx->total[0] & 0x3F;
 236     fill = 64 - left;
 237
 238     ctx->total[0] += ilen;
 239     ctx->total[0] &= 0xFFFFFFFF;
 240
 241     if( ctx->total[0] < (unsigned long) ilen )
 242         ctx->total[1]++;
 243
 244     if( left && ilen >= fill )
 245     {
 246         memcpy( (void *) (ctx->buffer + left),
 247                 (void *) input, fill );
 248         sha2_process( ctx, ctx->buffer );
 249         input += fill;
 250         ilen  -= fill;
 251         left = 0;
 252     }
 253
 254     while( ilen >= 64 )
 255     {
 256         sha2_process( ctx, input );
 257         input += 64;
 258         ilen  -= 64;
 259     }
 260
 261     if( ilen > 0 )
 262     {
 263         memcpy( (void *) (ctx->buffer + left),
 264                 (void *) input, ilen );
 265     }
 266 }
 267
 268 static const unsigned char sha2_padding[64] =
 269 {
 270  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 271     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 272     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 273     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 274 };
 275
 276 /*
 277  * SHA-256 final digest
 278  */
 279 void sha2_finish( sha2_context *ctx, unsigned char output[32] )
 280 {
 281     unsigned long last, padn;
 282     unsigned long high, low;
 283     unsigned char msglen[8];
 284
 285     high = ( ctx->total[0] >> 29 )
 286          | ( ctx->total[1] <<  3 );
 287     low  = ( ctx->total[0] <<  3 );
 288
 289     PUT_ULONG_BE( high, msglen, 0 );
 290     PUT_ULONG_BE( low,  msglen, 4 );
 291
 292     last = ctx->total[0] & 0x3F;
 293     padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
 294
 295     sha2_update( ctx, (unsigned char *) sha2_padding, padn );
 296     sha2_update( ctx, msglen, 8 );
 297
 298     PUT_ULONG_BE( ctx->state[0], output,  0 );
 299     PUT_ULONG_BE( ctx->state[1], output,  4 );
 300     PUT_ULONG_BE( ctx->state[2], output,  8 );
 301     PUT_ULONG_BE( ctx->state[3], output, 12 );
 302     PUT_ULONG_BE( ctx->state[4], output, 16 );
 303     PUT_ULONG_BE( ctx->state[5], output, 20 );
 304     PUT_ULONG_BE( ctx->state[6], output, 24 );
 305
 306     if( ctx->is224 == 0 )
 307         PUT_ULONG_BE( ctx->state[7], output, 28 );
 308 }
 309
 310 /*
 311  * output = SHA-256( input buffer )
 312  */
 313 void sha2( unsigned char *input, int ilen,
 314            unsigned char output[32], int is224 )
 315 {
 316     sha2_context ctx;
 317
 318     sha2_starts( &ctx, is224 );
 319     sha2_update( &ctx, input, ilen );
 320     sha2_finish( &ctx, output );
 321
 322     memset( &ctx, 0, sizeof( sha2_context ) );
 323 }
 324
 325 /*
 326  * output = SHA-256( file contents )
 327  */
 328 int sha2_file( char *path, unsigned char output[32], int is224 )
 329 {
 330     FILE *f;
 331     size_t n;
 332     sha2_context ctx;
 333     unsigned char buf[1024];
 334
 335     if( ( f = fopen( path, "rb" ) ) == NULL )
 336         return( 1 );
 337
 338     sha2_starts( &ctx, is224 );
 339
 340     while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
 341         sha2_update( &ctx, buf, (int) n );
 342
 343     sha2_finish( &ctx, output );
 344
 345     memset( &ctx, 0, sizeof( sha2_context ) );
 346
 347     if( ferror( f ) != 0 )
 348     {
 349         fclose( f );
 350         return( 2 );
 351     }
 352
 353     fclose( f );
 354     return( 0 );
 355 }
 356
 357 /*
 358  * SHA-256 HMAC context setup
 359  */
 360 void sha2_hmac_starts( sha2_context *ctx, unsigned char *key, int keylen,
 361                        int is224 )
 362 {
 363     int i;
 364     unsigned char sum[32];
 365
 366     if( keylen > 64 )
 367     {
 368         sha2( key, keylen, sum, is224 );
 369         keylen = ( is224 ) ? 28 : 32;
 370         key = sum;
 371     }
 372
 373     memset( ctx->ipad, 0x36, 64 );
 374     memset( ctx->opad, 0x5C, 64 );
 375
 376     for( i = 0; i < keylen; i++ )
 377     {
 378         ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
 379         ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
 380     }
 381
 382     sha2_starts( ctx, is224 );
 383     sha2_update( ctx, ctx->ipad, 64 );
 384
 385     memset( sum, 0, sizeof( sum ) );
 386 }
 387
 388 /*
 389  * SHA-256 HMAC process buffer
 390  */
 391 void sha2_hmac_update( sha2_context *ctx, unsigned char *input, int ilen )
 392 {
 393     sha2_update( ctx, input, ilen );
 394 }
 395
 396 /*
 397  * SHA-256 HMAC final digest
 398  */
 399 void sha2_hmac_finish( sha2_context *ctx, unsigned char output[32] )
 400 {
 401     int is224, hlen;
 402     unsigned char tmpbuf[32];
 403
 404     is224 = ctx->is224;
 405     hlen = ( is224 == 0 ) ? 32 : 28;
 406
 407     sha2_finish( ctx, tmpbuf );
 408     sha2_starts( ctx, is224 );
 409     sha2_update( ctx, ctx->opad, 64 );
 410     sha2_update( ctx, tmpbuf, hlen );
 411     sha2_finish( ctx, output );
 412
 413     memset( tmpbuf, 0, sizeof( tmpbuf ) );
 414 }
 415
 416 /*
 417  * output = HMAC-SHA-256( hmac key, input buffer )
 418  */
 419 void sha2_hmac( unsigned char *key, int keylen,
 420                 unsigned char *input, int ilen,
 421                 unsigned char output[32], int is224 )
 422 {
 423     sha2_context ctx;
 424
 425     sha2_hmac_starts( &ctx, key, keylen, is224 );
 426     sha2_hmac_update( &ctx, input, ilen );
 427     sha2_hmac_finish( &ctx, output );
 428
 429     memset( &ctx, 0, sizeof( sha2_context ) );
 430 }