Doug Anson / mbedTLSLibrary

mbed TLS library

Dependents:   HTTPClient-SSL WS_SERVER

polarssl/sha512.c@0:137634ff4186, 2015-06-11 (annotated)

Committer:
ansond
Date:
Thu Jun 11 03:27:03 2015 +0000
Revision:
0:137634ff4186
initial commit

Who changed what in which revision?

UserRevisionLine numberNew contents of line
ansond 0:137634ff4186 1 /*
ansond 0:137634ff4186 2 * FIPS-180-2 compliant SHA-384/512 implementation
ansond 0:137634ff4186 3 *
ansond 0:137634ff4186 4 * Copyright (C) 2006-2014, ARM Limited, All Rights Reserved
ansond 0:137634ff4186 5 *
ansond 0:137634ff4186 6 * This file is part of mbed TLS (https://tls.mbed.org)
ansond 0:137634ff4186 7 *
ansond 0:137634ff4186 8 * This program is free software; you can redistribute it and/or modify
ansond 0:137634ff4186 9 * it under the terms of the GNU General Public License as published by
ansond 0:137634ff4186 10 * the Free Software Foundation; either version 2 of the License, or
ansond 0:137634ff4186 11 * (at your option) any later version.
ansond 0:137634ff4186 12 *
ansond 0:137634ff4186 13 * This program is distributed in the hope that it will be useful,
ansond 0:137634ff4186 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ansond 0:137634ff4186 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
ansond 0:137634ff4186 16 * GNU General Public License for more details.
ansond 0:137634ff4186 17 *
ansond 0:137634ff4186 18 * You should have received a copy of the GNU General Public License along
ansond 0:137634ff4186 19 * with this program; if not, write to the Free Software Foundation, Inc.,
ansond 0:137634ff4186 20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
ansond 0:137634ff4186 21 */
ansond 0:137634ff4186 22 /*
ansond 0:137634ff4186 23 * The SHA-512 Secure Hash Standard was published by NIST in 2002.
ansond 0:137634ff4186 24 *
ansond 0:137634ff4186 25 * http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
ansond 0:137634ff4186 26 */
ansond 0:137634ff4186 27
ansond 0:137634ff4186 28 #if !defined(POLARSSL_CONFIG_FILE)
ansond 0:137634ff4186 29 #include "polarssl/config.h"
ansond 0:137634ff4186 30 #else
ansond 0:137634ff4186 31 #include POLARSSL_CONFIG_FILE
ansond 0:137634ff4186 32 #endif
ansond 0:137634ff4186 33
ansond 0:137634ff4186 34 #if defined(POLARSSL_SHA512_C)
ansond 0:137634ff4186 35
ansond 0:137634ff4186 36 #include "polarssl/sha512.h"
ansond 0:137634ff4186 37
ansond 0:137634ff4186 38 #if defined(_MSC_VER) || defined(__WATCOMC__)
ansond 0:137634ff4186 39 #define UL64(x) x##ui64
ansond 0:137634ff4186 40 #else
ansond 0:137634ff4186 41 #define UL64(x) x##ULL
ansond 0:137634ff4186 42 #endif
ansond 0:137634ff4186 43
ansond 0:137634ff4186 44 #include <string.h>
ansond 0:137634ff4186 45
ansond 0:137634ff4186 46 #if defined(POLARSSL_FS_IO)
ansond 0:137634ff4186 47 #include <stdio.h>
ansond 0:137634ff4186 48 #endif
ansond 0:137634ff4186 49
ansond 0:137634ff4186 50 #if defined(POLARSSL_SELF_TEST)
ansond 0:137634ff4186 51 #if defined(POLARSSL_PLATFORM_C)
ansond 0:137634ff4186 52 #include "polarssl/platform.h"
ansond 0:137634ff4186 53 #else
ansond 0:137634ff4186 54 #include <stdio.h>
ansond 0:137634ff4186 55 #define polarssl_printf printf
ansond 0:137634ff4186 56 #endif /* POLARSSL_PLATFORM_C */
ansond 0:137634ff4186 57 #endif /* POLARSSL_SELF_TEST */
ansond 0:137634ff4186 58
ansond 0:137634ff4186 59 /* Implementation that should never be optimized out by the compiler */
ansond 0:137634ff4186 60 static void polarssl_zeroize( void *v, size_t n ) {
ansond 0:137634ff4186 61 volatile unsigned char *p = v; while( n-- ) *p++ = 0;
ansond 0:137634ff4186 62 }
ansond 0:137634ff4186 63
ansond 0:137634ff4186 64 #if !defined(POLARSSL_SHA512_ALT)
ansond 0:137634ff4186 65
ansond 0:137634ff4186 66 /*
ansond 0:137634ff4186 67 * 64-bit integer manipulation macros (big endian)
ansond 0:137634ff4186 68 */
ansond 0:137634ff4186 69 #ifndef GET_UINT64_BE
ansond 0:137634ff4186 70 #define GET_UINT64_BE(n,b,i) \
ansond 0:137634ff4186 71 { \
ansond 0:137634ff4186 72 (n) = ( (uint64_t) (b)[(i) ] << 56 ) \
ansond 0:137634ff4186 73 | ( (uint64_t) (b)[(i) + 1] << 48 ) \
ansond 0:137634ff4186 74 | ( (uint64_t) (b)[(i) + 2] << 40 ) \
ansond 0:137634ff4186 75 | ( (uint64_t) (b)[(i) + 3] << 32 ) \
ansond 0:137634ff4186 76 | ( (uint64_t) (b)[(i) + 4] << 24 ) \
ansond 0:137634ff4186 77 | ( (uint64_t) (b)[(i) + 5] << 16 ) \
ansond 0:137634ff4186 78 | ( (uint64_t) (b)[(i) + 6] << 8 ) \
ansond 0:137634ff4186 79 | ( (uint64_t) (b)[(i) + 7] ); \
ansond 0:137634ff4186 80 }
ansond 0:137634ff4186 81 #endif /* GET_UINT64_BE */
ansond 0:137634ff4186 82
ansond 0:137634ff4186 83 #ifndef PUT_UINT64_BE
ansond 0:137634ff4186 84 #define PUT_UINT64_BE(n,b,i) \
ansond 0:137634ff4186 85 { \
ansond 0:137634ff4186 86 (b)[(i) ] = (unsigned char) ( (n) >> 56 ); \
ansond 0:137634ff4186 87 (b)[(i) + 1] = (unsigned char) ( (n) >> 48 ); \
ansond 0:137634ff4186 88 (b)[(i) + 2] = (unsigned char) ( (n) >> 40 ); \
ansond 0:137634ff4186 89 (b)[(i) + 3] = (unsigned char) ( (n) >> 32 ); \
ansond 0:137634ff4186 90 (b)[(i) + 4] = (unsigned char) ( (n) >> 24 ); \
ansond 0:137634ff4186 91 (b)[(i) + 5] = (unsigned char) ( (n) >> 16 ); \
ansond 0:137634ff4186 92 (b)[(i) + 6] = (unsigned char) ( (n) >> 8 ); \
ansond 0:137634ff4186 93 (b)[(i) + 7] = (unsigned char) ( (n) ); \
ansond 0:137634ff4186 94 }
ansond 0:137634ff4186 95 #endif /* PUT_UINT64_BE */
ansond 0:137634ff4186 96
ansond 0:137634ff4186 97 /*
ansond 0:137634ff4186 98 * Round constants
ansond 0:137634ff4186 99 */
ansond 0:137634ff4186 100 static const uint64_t K[80] =
ansond 0:137634ff4186 101 {
ansond 0:137634ff4186 102 UL64(0x428A2F98D728AE22), UL64(0x7137449123EF65CD),
ansond 0:137634ff4186 103 UL64(0xB5C0FBCFEC4D3B2F), UL64(0xE9B5DBA58189DBBC),
ansond 0:137634ff4186 104 UL64(0x3956C25BF348B538), UL64(0x59F111F1B605D019),
ansond 0:137634ff4186 105 UL64(0x923F82A4AF194F9B), UL64(0xAB1C5ED5DA6D8118),
ansond 0:137634ff4186 106 UL64(0xD807AA98A3030242), UL64(0x12835B0145706FBE),
ansond 0:137634ff4186 107 UL64(0x243185BE4EE4B28C), UL64(0x550C7DC3D5FFB4E2),
ansond 0:137634ff4186 108 UL64(0x72BE5D74F27B896F), UL64(0x80DEB1FE3B1696B1),
ansond 0:137634ff4186 109 UL64(0x9BDC06A725C71235), UL64(0xC19BF174CF692694),
ansond 0:137634ff4186 110 UL64(0xE49B69C19EF14AD2), UL64(0xEFBE4786384F25E3),
ansond 0:137634ff4186 111 UL64(0x0FC19DC68B8CD5B5), UL64(0x240CA1CC77AC9C65),
ansond 0:137634ff4186 112 UL64(0x2DE92C6F592B0275), UL64(0x4A7484AA6EA6E483),
ansond 0:137634ff4186 113 UL64(0x5CB0A9DCBD41FBD4), UL64(0x76F988DA831153B5),
ansond 0:137634ff4186 114 UL64(0x983E5152EE66DFAB), UL64(0xA831C66D2DB43210),
ansond 0:137634ff4186 115 UL64(0xB00327C898FB213F), UL64(0xBF597FC7BEEF0EE4),
ansond 0:137634ff4186 116 UL64(0xC6E00BF33DA88FC2), UL64(0xD5A79147930AA725),
ansond 0:137634ff4186 117 UL64(0x06CA6351E003826F), UL64(0x142929670A0E6E70),
ansond 0:137634ff4186 118 UL64(0x27B70A8546D22FFC), UL64(0x2E1B21385C26C926),
ansond 0:137634ff4186 119 UL64(0x4D2C6DFC5AC42AED), UL64(0x53380D139D95B3DF),
ansond 0:137634ff4186 120 UL64(0x650A73548BAF63DE), UL64(0x766A0ABB3C77B2A8),
ansond 0:137634ff4186 121 UL64(0x81C2C92E47EDAEE6), UL64(0x92722C851482353B),
ansond 0:137634ff4186 122 UL64(0xA2BFE8A14CF10364), UL64(0xA81A664BBC423001),
ansond 0:137634ff4186 123 UL64(0xC24B8B70D0F89791), UL64(0xC76C51A30654BE30),
ansond 0:137634ff4186 124 UL64(0xD192E819D6EF5218), UL64(0xD69906245565A910),
ansond 0:137634ff4186 125 UL64(0xF40E35855771202A), UL64(0x106AA07032BBD1B8),
ansond 0:137634ff4186 126 UL64(0x19A4C116B8D2D0C8), UL64(0x1E376C085141AB53),
ansond 0:137634ff4186 127 UL64(0x2748774CDF8EEB99), UL64(0x34B0BCB5E19B48A8),
ansond 0:137634ff4186 128 UL64(0x391C0CB3C5C95A63), UL64(0x4ED8AA4AE3418ACB),
ansond 0:137634ff4186 129 UL64(0x5B9CCA4F7763E373), UL64(0x682E6FF3D6B2B8A3),
ansond 0:137634ff4186 130 UL64(0x748F82EE5DEFB2FC), UL64(0x78A5636F43172F60),
ansond 0:137634ff4186 131 UL64(0x84C87814A1F0AB72), UL64(0x8CC702081A6439EC),
ansond 0:137634ff4186 132 UL64(0x90BEFFFA23631E28), UL64(0xA4506CEBDE82BDE9),
ansond 0:137634ff4186 133 UL64(0xBEF9A3F7B2C67915), UL64(0xC67178F2E372532B),
ansond 0:137634ff4186 134 UL64(0xCA273ECEEA26619C), UL64(0xD186B8C721C0C207),
ansond 0:137634ff4186 135 UL64(0xEADA7DD6CDE0EB1E), UL64(0xF57D4F7FEE6ED178),
ansond 0:137634ff4186 136 UL64(0x06F067AA72176FBA), UL64(0x0A637DC5A2C898A6),
ansond 0:137634ff4186 137 UL64(0x113F9804BEF90DAE), UL64(0x1B710B35131C471B),
ansond 0:137634ff4186 138 UL64(0x28DB77F523047D84), UL64(0x32CAAB7B40C72493),
ansond 0:137634ff4186 139 UL64(0x3C9EBE0A15C9BEBC), UL64(0x431D67C49C100D4C),
ansond 0:137634ff4186 140 UL64(0x4CC5D4BECB3E42B6), UL64(0x597F299CFC657E2A),
ansond 0:137634ff4186 141 UL64(0x5FCB6FAB3AD6FAEC), UL64(0x6C44198C4A475817)
ansond 0:137634ff4186 142 };
ansond 0:137634ff4186 143
ansond 0:137634ff4186 144 void sha512_init( sha512_context *ctx )
ansond 0:137634ff4186 145 {
ansond 0:137634ff4186 146 memset( ctx, 0, sizeof( sha512_context ) );
ansond 0:137634ff4186 147 }
ansond 0:137634ff4186 148
ansond 0:137634ff4186 149 void sha512_free( sha512_context *ctx )
ansond 0:137634ff4186 150 {
ansond 0:137634ff4186 151 if( ctx == NULL )
ansond 0:137634ff4186 152 return;
ansond 0:137634ff4186 153
ansond 0:137634ff4186 154 polarssl_zeroize( ctx, sizeof( sha512_context ) );
ansond 0:137634ff4186 155 }
ansond 0:137634ff4186 156
ansond 0:137634ff4186 157 /*
ansond 0:137634ff4186 158 * SHA-512 context setup
ansond 0:137634ff4186 159 */
ansond 0:137634ff4186 160 void sha512_starts( sha512_context *ctx, int is384 )
ansond 0:137634ff4186 161 {
ansond 0:137634ff4186 162 ctx->total[0] = 0;
ansond 0:137634ff4186 163 ctx->total[1] = 0;
ansond 0:137634ff4186 164
ansond 0:137634ff4186 165 if( is384 == 0 )
ansond 0:137634ff4186 166 {
ansond 0:137634ff4186 167 /* SHA-512 */
ansond 0:137634ff4186 168 ctx->state[0] = UL64(0x6A09E667F3BCC908);
ansond 0:137634ff4186 169 ctx->state[1] = UL64(0xBB67AE8584CAA73B);
ansond 0:137634ff4186 170 ctx->state[2] = UL64(0x3C6EF372FE94F82B);
ansond 0:137634ff4186 171 ctx->state[3] = UL64(0xA54FF53A5F1D36F1);
ansond 0:137634ff4186 172 ctx->state[4] = UL64(0x510E527FADE682D1);
ansond 0:137634ff4186 173 ctx->state[5] = UL64(0x9B05688C2B3E6C1F);
ansond 0:137634ff4186 174 ctx->state[6] = UL64(0x1F83D9ABFB41BD6B);
ansond 0:137634ff4186 175 ctx->state[7] = UL64(0x5BE0CD19137E2179);
ansond 0:137634ff4186 176 }
ansond 0:137634ff4186 177 else
ansond 0:137634ff4186 178 {
ansond 0:137634ff4186 179 /* SHA-384 */
ansond 0:137634ff4186 180 ctx->state[0] = UL64(0xCBBB9D5DC1059ED8);
ansond 0:137634ff4186 181 ctx->state[1] = UL64(0x629A292A367CD507);
ansond 0:137634ff4186 182 ctx->state[2] = UL64(0x9159015A3070DD17);
ansond 0:137634ff4186 183 ctx->state[3] = UL64(0x152FECD8F70E5939);
ansond 0:137634ff4186 184 ctx->state[4] = UL64(0x67332667FFC00B31);
ansond 0:137634ff4186 185 ctx->state[5] = UL64(0x8EB44A8768581511);
ansond 0:137634ff4186 186 ctx->state[6] = UL64(0xDB0C2E0D64F98FA7);
ansond 0:137634ff4186 187 ctx->state[7] = UL64(0x47B5481DBEFA4FA4);
ansond 0:137634ff4186 188 }
ansond 0:137634ff4186 189
ansond 0:137634ff4186 190 ctx->is384 = is384;
ansond 0:137634ff4186 191 }
ansond 0:137634ff4186 192
ansond 0:137634ff4186 193 void sha512_process( sha512_context *ctx, const unsigned char data[128] )
ansond 0:137634ff4186 194 {
ansond 0:137634ff4186 195 int i;
ansond 0:137634ff4186 196 uint64_t temp1, temp2, W[80];
ansond 0:137634ff4186 197 uint64_t A, B, C, D, E, F, G, H;
ansond 0:137634ff4186 198
ansond 0:137634ff4186 199 #define SHR(x,n) (x >> n)
ansond 0:137634ff4186 200 #define ROTR(x,n) (SHR(x,n) | (x << (64 - n)))
ansond 0:137634ff4186 201
ansond 0:137634ff4186 202 #define S0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x, 7))
ansond 0:137634ff4186 203 #define S1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x, 6))
ansond 0:137634ff4186 204
ansond 0:137634ff4186 205 #define S2(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
ansond 0:137634ff4186 206 #define S3(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
ansond 0:137634ff4186 207
ansond 0:137634ff4186 208 #define F0(x,y,z) ((x & y) | (z & (x | y)))
ansond 0:137634ff4186 209 #define F1(x,y,z) (z ^ (x & (y ^ z)))
ansond 0:137634ff4186 210
ansond 0:137634ff4186 211 #define P(a,b,c,d,e,f,g,h,x,K) \
ansond 0:137634ff4186 212 { \
ansond 0:137634ff4186 213 temp1 = h + S3(e) + F1(e,f,g) + K + x; \
ansond 0:137634ff4186 214 temp2 = S2(a) + F0(a,b,c); \
ansond 0:137634ff4186 215 d += temp1; h = temp1 + temp2; \
ansond 0:137634ff4186 216 }
ansond 0:137634ff4186 217
ansond 0:137634ff4186 218 for( i = 0; i < 16; i++ )
ansond 0:137634ff4186 219 {
ansond 0:137634ff4186 220 GET_UINT64_BE( W[i], data, i << 3 );
ansond 0:137634ff4186 221 }
ansond 0:137634ff4186 222
ansond 0:137634ff4186 223 for( ; i < 80; i++ )
ansond 0:137634ff4186 224 {
ansond 0:137634ff4186 225 W[i] = S1(W[i - 2]) + W[i - 7] +
ansond 0:137634ff4186 226 S0(W[i - 15]) + W[i - 16];
ansond 0:137634ff4186 227 }
ansond 0:137634ff4186 228
ansond 0:137634ff4186 229 A = ctx->state[0];
ansond 0:137634ff4186 230 B = ctx->state[1];
ansond 0:137634ff4186 231 C = ctx->state[2];
ansond 0:137634ff4186 232 D = ctx->state[3];
ansond 0:137634ff4186 233 E = ctx->state[4];
ansond 0:137634ff4186 234 F = ctx->state[5];
ansond 0:137634ff4186 235 G = ctx->state[6];
ansond 0:137634ff4186 236 H = ctx->state[7];
ansond 0:137634ff4186 237 i = 0;
ansond 0:137634ff4186 238
ansond 0:137634ff4186 239 do
ansond 0:137634ff4186 240 {
ansond 0:137634ff4186 241 P( A, B, C, D, E, F, G, H, W[i], K[i] ); i++;
ansond 0:137634ff4186 242 P( H, A, B, C, D, E, F, G, W[i], K[i] ); i++;
ansond 0:137634ff4186 243 P( G, H, A, B, C, D, E, F, W[i], K[i] ); i++;
ansond 0:137634ff4186 244 P( F, G, H, A, B, C, D, E, W[i], K[i] ); i++;
ansond 0:137634ff4186 245 P( E, F, G, H, A, B, C, D, W[i], K[i] ); i++;
ansond 0:137634ff4186 246 P( D, E, F, G, H, A, B, C, W[i], K[i] ); i++;
ansond 0:137634ff4186 247 P( C, D, E, F, G, H, A, B, W[i], K[i] ); i++;
ansond 0:137634ff4186 248 P( B, C, D, E, F, G, H, A, W[i], K[i] ); i++;
ansond 0:137634ff4186 249 }
ansond 0:137634ff4186 250 while( i < 80 );
ansond 0:137634ff4186 251
ansond 0:137634ff4186 252 ctx->state[0] += A;
ansond 0:137634ff4186 253 ctx->state[1] += B;
ansond 0:137634ff4186 254 ctx->state[2] += C;
ansond 0:137634ff4186 255 ctx->state[3] += D;
ansond 0:137634ff4186 256 ctx->state[4] += E;
ansond 0:137634ff4186 257 ctx->state[5] += F;
ansond 0:137634ff4186 258 ctx->state[6] += G;
ansond 0:137634ff4186 259 ctx->state[7] += H;
ansond 0:137634ff4186 260 }
ansond 0:137634ff4186 261
ansond 0:137634ff4186 262 /*
ansond 0:137634ff4186 263 * SHA-512 process buffer
ansond 0:137634ff4186 264 */
ansond 0:137634ff4186 265 void sha512_update( sha512_context *ctx, const unsigned char *input,
ansond 0:137634ff4186 266 size_t ilen )
ansond 0:137634ff4186 267 {
ansond 0:137634ff4186 268 size_t fill;
ansond 0:137634ff4186 269 unsigned int left;
ansond 0:137634ff4186 270
ansond 0:137634ff4186 271 if( ilen == 0 )
ansond 0:137634ff4186 272 return;
ansond 0:137634ff4186 273
ansond 0:137634ff4186 274 left = (unsigned int) (ctx->total[0] & 0x7F);
ansond 0:137634ff4186 275 fill = 128 - left;
ansond 0:137634ff4186 276
ansond 0:137634ff4186 277 ctx->total[0] += (uint64_t) ilen;
ansond 0:137634ff4186 278
ansond 0:137634ff4186 279 if( ctx->total[0] < (uint64_t) ilen )
ansond 0:137634ff4186 280 ctx->total[1]++;
ansond 0:137634ff4186 281
ansond 0:137634ff4186 282 if( left && ilen >= fill )
ansond 0:137634ff4186 283 {
ansond 0:137634ff4186 284 memcpy( (void *) (ctx->buffer + left), input, fill );
ansond 0:137634ff4186 285 sha512_process( ctx, ctx->buffer );
ansond 0:137634ff4186 286 input += fill;
ansond 0:137634ff4186 287 ilen -= fill;
ansond 0:137634ff4186 288 left = 0;
ansond 0:137634ff4186 289 }
ansond 0:137634ff4186 290
ansond 0:137634ff4186 291 while( ilen >= 128 )
ansond 0:137634ff4186 292 {
ansond 0:137634ff4186 293 sha512_process( ctx, input );
ansond 0:137634ff4186 294 input += 128;
ansond 0:137634ff4186 295 ilen -= 128;
ansond 0:137634ff4186 296 }
ansond 0:137634ff4186 297
ansond 0:137634ff4186 298 if( ilen > 0 )
ansond 0:137634ff4186 299 memcpy( (void *) (ctx->buffer + left), input, ilen );
ansond 0:137634ff4186 300 }
ansond 0:137634ff4186 301
ansond 0:137634ff4186 302 static const unsigned char sha512_padding[128] =
ansond 0:137634ff4186 303 {
ansond 0:137634ff4186 304 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
ansond 0:137634ff4186 305 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
ansond 0:137634ff4186 306 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
ansond 0:137634ff4186 307 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
ansond 0:137634ff4186 308 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
ansond 0:137634ff4186 309 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
ansond 0:137634ff4186 310 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
ansond 0:137634ff4186 311 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
ansond 0:137634ff4186 312 };
ansond 0:137634ff4186 313
ansond 0:137634ff4186 314 /*
ansond 0:137634ff4186 315 * SHA-512 final digest
ansond 0:137634ff4186 316 */
ansond 0:137634ff4186 317 void sha512_finish( sha512_context *ctx, unsigned char output[64] )
ansond 0:137634ff4186 318 {
ansond 0:137634ff4186 319 size_t last, padn;
ansond 0:137634ff4186 320 uint64_t high, low;
ansond 0:137634ff4186 321 unsigned char msglen[16];
ansond 0:137634ff4186 322
ansond 0:137634ff4186 323 high = ( ctx->total[0] >> 61 )
ansond 0:137634ff4186 324 | ( ctx->total[1] << 3 );
ansond 0:137634ff4186 325 low = ( ctx->total[0] << 3 );
ansond 0:137634ff4186 326
ansond 0:137634ff4186 327 PUT_UINT64_BE( high, msglen, 0 );
ansond 0:137634ff4186 328 PUT_UINT64_BE( low, msglen, 8 );
ansond 0:137634ff4186 329
ansond 0:137634ff4186 330 last = (size_t)( ctx->total[0] & 0x7F );
ansond 0:137634ff4186 331 padn = ( last < 112 ) ? ( 112 - last ) : ( 240 - last );
ansond 0:137634ff4186 332
ansond 0:137634ff4186 333 sha512_update( ctx, sha512_padding, padn );
ansond 0:137634ff4186 334 sha512_update( ctx, msglen, 16 );
ansond 0:137634ff4186 335
ansond 0:137634ff4186 336 PUT_UINT64_BE( ctx->state[0], output, 0 );
ansond 0:137634ff4186 337 PUT_UINT64_BE( ctx->state[1], output, 8 );
ansond 0:137634ff4186 338 PUT_UINT64_BE( ctx->state[2], output, 16 );
ansond 0:137634ff4186 339 PUT_UINT64_BE( ctx->state[3], output, 24 );
ansond 0:137634ff4186 340 PUT_UINT64_BE( ctx->state[4], output, 32 );
ansond 0:137634ff4186 341 PUT_UINT64_BE( ctx->state[5], output, 40 );
ansond 0:137634ff4186 342
ansond 0:137634ff4186 343 if( ctx->is384 == 0 )
ansond 0:137634ff4186 344 {
ansond 0:137634ff4186 345 PUT_UINT64_BE( ctx->state[6], output, 48 );
ansond 0:137634ff4186 346 PUT_UINT64_BE( ctx->state[7], output, 56 );
ansond 0:137634ff4186 347 }
ansond 0:137634ff4186 348 }
ansond 0:137634ff4186 349
ansond 0:137634ff4186 350 #endif /* !POLARSSL_SHA512_ALT */
ansond 0:137634ff4186 351
ansond 0:137634ff4186 352 /*
ansond 0:137634ff4186 353 * output = SHA-512( input buffer )
ansond 0:137634ff4186 354 */
ansond 0:137634ff4186 355 void sha512( const unsigned char *input, size_t ilen,
ansond 0:137634ff4186 356 unsigned char output[64], int is384 )
ansond 0:137634ff4186 357 {
ansond 0:137634ff4186 358 sha512_context ctx;
ansond 0:137634ff4186 359
ansond 0:137634ff4186 360 sha512_init( &ctx );
ansond 0:137634ff4186 361 sha512_starts( &ctx, is384 );
ansond 0:137634ff4186 362 sha512_update( &ctx, input, ilen );
ansond 0:137634ff4186 363 sha512_finish( &ctx, output );
ansond 0:137634ff4186 364 sha512_free( &ctx );
ansond 0:137634ff4186 365 }
ansond 0:137634ff4186 366
ansond 0:137634ff4186 367 #if defined(POLARSSL_FS_IO)
ansond 0:137634ff4186 368 /*
ansond 0:137634ff4186 369 * output = SHA-512( file contents )
ansond 0:137634ff4186 370 */
ansond 0:137634ff4186 371 int sha512_file( const char *path, unsigned char output[64], int is384 )
ansond 0:137634ff4186 372 {
ansond 0:137634ff4186 373 FILE *f;
ansond 0:137634ff4186 374 size_t n;
ansond 0:137634ff4186 375 sha512_context ctx;
ansond 0:137634ff4186 376 unsigned char buf[1024];
ansond 0:137634ff4186 377
ansond 0:137634ff4186 378 if( ( f = fopen( path, "rb" ) ) == NULL )
ansond 0:137634ff4186 379 return( POLARSSL_ERR_SHA512_FILE_IO_ERROR );
ansond 0:137634ff4186 380
ansond 0:137634ff4186 381 sha512_init( &ctx );
ansond 0:137634ff4186 382 sha512_starts( &ctx, is384 );
ansond 0:137634ff4186 383
ansond 0:137634ff4186 384 while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
ansond 0:137634ff4186 385 sha512_update( &ctx, buf, n );
ansond 0:137634ff4186 386
ansond 0:137634ff4186 387 sha512_finish( &ctx, output );
ansond 0:137634ff4186 388 sha512_free( &ctx );
ansond 0:137634ff4186 389
ansond 0:137634ff4186 390 if( ferror( f ) != 0 )
ansond 0:137634ff4186 391 {
ansond 0:137634ff4186 392 fclose( f );
ansond 0:137634ff4186 393 return( POLARSSL_ERR_SHA512_FILE_IO_ERROR );
ansond 0:137634ff4186 394 }
ansond 0:137634ff4186 395
ansond 0:137634ff4186 396 fclose( f );
ansond 0:137634ff4186 397 return( 0 );
ansond 0:137634ff4186 398 }
ansond 0:137634ff4186 399 #endif /* POLARSSL_FS_IO */
ansond 0:137634ff4186 400
ansond 0:137634ff4186 401 /*
ansond 0:137634ff4186 402 * SHA-512 HMAC context setup
ansond 0:137634ff4186 403 */
ansond 0:137634ff4186 404 void sha512_hmac_starts( sha512_context *ctx, const unsigned char *key,
ansond 0:137634ff4186 405 size_t keylen, int is384 )
ansond 0:137634ff4186 406 {
ansond 0:137634ff4186 407 size_t i;
ansond 0:137634ff4186 408 unsigned char sum[64];
ansond 0:137634ff4186 409
ansond 0:137634ff4186 410 if( keylen > 128 )
ansond 0:137634ff4186 411 {
ansond 0:137634ff4186 412 sha512( key, keylen, sum, is384 );
ansond 0:137634ff4186 413 keylen = ( is384 ) ? 48 : 64;
ansond 0:137634ff4186 414 key = sum;
ansond 0:137634ff4186 415 }
ansond 0:137634ff4186 416
ansond 0:137634ff4186 417 memset( ctx->ipad, 0x36, 128 );
ansond 0:137634ff4186 418 memset( ctx->opad, 0x5C, 128 );
ansond 0:137634ff4186 419
ansond 0:137634ff4186 420 for( i = 0; i < keylen; i++ )
ansond 0:137634ff4186 421 {
ansond 0:137634ff4186 422 ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
ansond 0:137634ff4186 423 ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
ansond 0:137634ff4186 424 }
ansond 0:137634ff4186 425
ansond 0:137634ff4186 426 sha512_starts( ctx, is384 );
ansond 0:137634ff4186 427 sha512_update( ctx, ctx->ipad, 128 );
ansond 0:137634ff4186 428
ansond 0:137634ff4186 429 polarssl_zeroize( sum, sizeof( sum ) );
ansond 0:137634ff4186 430 }
ansond 0:137634ff4186 431
ansond 0:137634ff4186 432 /*
ansond 0:137634ff4186 433 * SHA-512 HMAC process buffer
ansond 0:137634ff4186 434 */
ansond 0:137634ff4186 435 void sha512_hmac_update( sha512_context *ctx,
ansond 0:137634ff4186 436 const unsigned char *input, size_t ilen )
ansond 0:137634ff4186 437 {
ansond 0:137634ff4186 438 sha512_update( ctx, input, ilen );
ansond 0:137634ff4186 439 }
ansond 0:137634ff4186 440
ansond 0:137634ff4186 441 /*
ansond 0:137634ff4186 442 * SHA-512 HMAC final digest
ansond 0:137634ff4186 443 */
ansond 0:137634ff4186 444 void sha512_hmac_finish( sha512_context *ctx, unsigned char output[64] )
ansond 0:137634ff4186 445 {
ansond 0:137634ff4186 446 int is384, hlen;
ansond 0:137634ff4186 447 unsigned char tmpbuf[64];
ansond 0:137634ff4186 448
ansond 0:137634ff4186 449 is384 = ctx->is384;
ansond 0:137634ff4186 450 hlen = ( is384 == 0 ) ? 64 : 48;
ansond 0:137634ff4186 451
ansond 0:137634ff4186 452 sha512_finish( ctx, tmpbuf );
ansond 0:137634ff4186 453 sha512_starts( ctx, is384 );
ansond 0:137634ff4186 454 sha512_update( ctx, ctx->opad, 128 );
ansond 0:137634ff4186 455 sha512_update( ctx, tmpbuf, hlen );
ansond 0:137634ff4186 456 sha512_finish( ctx, output );
ansond 0:137634ff4186 457
ansond 0:137634ff4186 458 polarssl_zeroize( tmpbuf, sizeof( tmpbuf ) );
ansond 0:137634ff4186 459 }
ansond 0:137634ff4186 460
ansond 0:137634ff4186 461 /*
ansond 0:137634ff4186 462 * SHA-512 HMAC context reset
ansond 0:137634ff4186 463 */
ansond 0:137634ff4186 464 void sha512_hmac_reset( sha512_context *ctx )
ansond 0:137634ff4186 465 {
ansond 0:137634ff4186 466 sha512_starts( ctx, ctx->is384 );
ansond 0:137634ff4186 467 sha512_update( ctx, ctx->ipad, 128 );
ansond 0:137634ff4186 468 }
ansond 0:137634ff4186 469
ansond 0:137634ff4186 470 /*
ansond 0:137634ff4186 471 * output = HMAC-SHA-512( hmac key, input buffer )
ansond 0:137634ff4186 472 */
ansond 0:137634ff4186 473 void sha512_hmac( const unsigned char *key, size_t keylen,
ansond 0:137634ff4186 474 const unsigned char *input, size_t ilen,
ansond 0:137634ff4186 475 unsigned char output[64], int is384 )
ansond 0:137634ff4186 476 {
ansond 0:137634ff4186 477 sha512_context ctx;
ansond 0:137634ff4186 478
ansond 0:137634ff4186 479 sha512_init( &ctx );
ansond 0:137634ff4186 480 sha512_hmac_starts( &ctx, key, keylen, is384 );
ansond 0:137634ff4186 481 sha512_hmac_update( &ctx, input, ilen );
ansond 0:137634ff4186 482 sha512_hmac_finish( &ctx, output );
ansond 0:137634ff4186 483 sha512_free( &ctx );
ansond 0:137634ff4186 484 }
ansond 0:137634ff4186 485
ansond 0:137634ff4186 486 #if defined(POLARSSL_SELF_TEST)
ansond 0:137634ff4186 487
ansond 0:137634ff4186 488 /*
ansond 0:137634ff4186 489 * FIPS-180-2 test vectors
ansond 0:137634ff4186 490 */
ansond 0:137634ff4186 491 static const unsigned char sha512_test_buf[3][113] =
ansond 0:137634ff4186 492 {
ansond 0:137634ff4186 493 { "abc" },
ansond 0:137634ff4186 494 { "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
ansond 0:137634ff4186 495 "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" },
ansond 0:137634ff4186 496 { "" }
ansond 0:137634ff4186 497 };
ansond 0:137634ff4186 498
ansond 0:137634ff4186 499 static const int sha512_test_buflen[3] =
ansond 0:137634ff4186 500 {
ansond 0:137634ff4186 501 3, 112, 1000
ansond 0:137634ff4186 502 };
ansond 0:137634ff4186 503
ansond 0:137634ff4186 504 static const unsigned char sha512_test_sum[6][64] =
ansond 0:137634ff4186 505 {
ansond 0:137634ff4186 506 /*
ansond 0:137634ff4186 507 * SHA-384 test vectors
ansond 0:137634ff4186 508 */
ansond 0:137634ff4186 509 { 0xCB, 0x00, 0x75, 0x3F, 0x45, 0xA3, 0x5E, 0x8B,
ansond 0:137634ff4186 510 0xB5, 0xA0, 0x3D, 0x69, 0x9A, 0xC6, 0x50, 0x07,
ansond 0:137634ff4186 511 0x27, 0x2C, 0x32, 0xAB, 0x0E, 0xDE, 0xD1, 0x63,
ansond 0:137634ff4186 512 0x1A, 0x8B, 0x60, 0x5A, 0x43, 0xFF, 0x5B, 0xED,
ansond 0:137634ff4186 513 0x80, 0x86, 0x07, 0x2B, 0xA1, 0xE7, 0xCC, 0x23,
ansond 0:137634ff4186 514 0x58, 0xBA, 0xEC, 0xA1, 0x34, 0xC8, 0x25, 0xA7 },
ansond 0:137634ff4186 515 { 0x09, 0x33, 0x0C, 0x33, 0xF7, 0x11, 0x47, 0xE8,
ansond 0:137634ff4186 516 0x3D, 0x19, 0x2F, 0xC7, 0x82, 0xCD, 0x1B, 0x47,
ansond 0:137634ff4186 517 0x53, 0x11, 0x1B, 0x17, 0x3B, 0x3B, 0x05, 0xD2,
ansond 0:137634ff4186 518 0x2F, 0xA0, 0x80, 0x86, 0xE3, 0xB0, 0xF7, 0x12,
ansond 0:137634ff4186 519 0xFC, 0xC7, 0xC7, 0x1A, 0x55, 0x7E, 0x2D, 0xB9,
ansond 0:137634ff4186 520 0x66, 0xC3, 0xE9, 0xFA, 0x91, 0x74, 0x60, 0x39 },
ansond 0:137634ff4186 521 { 0x9D, 0x0E, 0x18, 0x09, 0x71, 0x64, 0x74, 0xCB,
ansond 0:137634ff4186 522 0x08, 0x6E, 0x83, 0x4E, 0x31, 0x0A, 0x4A, 0x1C,
ansond 0:137634ff4186 523 0xED, 0x14, 0x9E, 0x9C, 0x00, 0xF2, 0x48, 0x52,
ansond 0:137634ff4186 524 0x79, 0x72, 0xCE, 0xC5, 0x70, 0x4C, 0x2A, 0x5B,
ansond 0:137634ff4186 525 0x07, 0xB8, 0xB3, 0xDC, 0x38, 0xEC, 0xC4, 0xEB,
ansond 0:137634ff4186 526 0xAE, 0x97, 0xDD, 0xD8, 0x7F, 0x3D, 0x89, 0x85 },
ansond 0:137634ff4186 527
ansond 0:137634ff4186 528 /*
ansond 0:137634ff4186 529 * SHA-512 test vectors
ansond 0:137634ff4186 530 */
ansond 0:137634ff4186 531 { 0xDD, 0xAF, 0x35, 0xA1, 0x93, 0x61, 0x7A, 0xBA,
ansond 0:137634ff4186 532 0xCC, 0x41, 0x73, 0x49, 0xAE, 0x20, 0x41, 0x31,
ansond 0:137634ff4186 533 0x12, 0xE6, 0xFA, 0x4E, 0x89, 0xA9, 0x7E, 0xA2,
ansond 0:137634ff4186 534 0x0A, 0x9E, 0xEE, 0xE6, 0x4B, 0x55, 0xD3, 0x9A,
ansond 0:137634ff4186 535 0x21, 0x92, 0x99, 0x2A, 0x27, 0x4F, 0xC1, 0xA8,
ansond 0:137634ff4186 536 0x36, 0xBA, 0x3C, 0x23, 0xA3, 0xFE, 0xEB, 0xBD,
ansond 0:137634ff4186 537 0x45, 0x4D, 0x44, 0x23, 0x64, 0x3C, 0xE8, 0x0E,
ansond 0:137634ff4186 538 0x2A, 0x9A, 0xC9, 0x4F, 0xA5, 0x4C, 0xA4, 0x9F },
ansond 0:137634ff4186 539 { 0x8E, 0x95, 0x9B, 0x75, 0xDA, 0xE3, 0x13, 0xDA,
ansond 0:137634ff4186 540 0x8C, 0xF4, 0xF7, 0x28, 0x14, 0xFC, 0x14, 0x3F,
ansond 0:137634ff4186 541 0x8F, 0x77, 0x79, 0xC6, 0xEB, 0x9F, 0x7F, 0xA1,
ansond 0:137634ff4186 542 0x72, 0x99, 0xAE, 0xAD, 0xB6, 0x88, 0x90, 0x18,
ansond 0:137634ff4186 543 0x50, 0x1D, 0x28, 0x9E, 0x49, 0x00, 0xF7, 0xE4,
ansond 0:137634ff4186 544 0x33, 0x1B, 0x99, 0xDE, 0xC4, 0xB5, 0x43, 0x3A,
ansond 0:137634ff4186 545 0xC7, 0xD3, 0x29, 0xEE, 0xB6, 0xDD, 0x26, 0x54,
ansond 0:137634ff4186 546 0x5E, 0x96, 0xE5, 0x5B, 0x87, 0x4B, 0xE9, 0x09 },
ansond 0:137634ff4186 547 { 0xE7, 0x18, 0x48, 0x3D, 0x0C, 0xE7, 0x69, 0x64,
ansond 0:137634ff4186 548 0x4E, 0x2E, 0x42, 0xC7, 0xBC, 0x15, 0xB4, 0x63,
ansond 0:137634ff4186 549 0x8E, 0x1F, 0x98, 0xB1, 0x3B, 0x20, 0x44, 0x28,
ansond 0:137634ff4186 550 0x56, 0x32, 0xA8, 0x03, 0xAF, 0xA9, 0x73, 0xEB,
ansond 0:137634ff4186 551 0xDE, 0x0F, 0xF2, 0x44, 0x87, 0x7E, 0xA6, 0x0A,
ansond 0:137634ff4186 552 0x4C, 0xB0, 0x43, 0x2C, 0xE5, 0x77, 0xC3, 0x1B,
ansond 0:137634ff4186 553 0xEB, 0x00, 0x9C, 0x5C, 0x2C, 0x49, 0xAA, 0x2E,
ansond 0:137634ff4186 554 0x4E, 0xAD, 0xB2, 0x17, 0xAD, 0x8C, 0xC0, 0x9B }
ansond 0:137634ff4186 555 };
ansond 0:137634ff4186 556
ansond 0:137634ff4186 557 /*
ansond 0:137634ff4186 558 * RFC 4231 test vectors
ansond 0:137634ff4186 559 */
ansond 0:137634ff4186 560 static const unsigned char sha512_hmac_test_key[7][26] =
ansond 0:137634ff4186 561 {
ansond 0:137634ff4186 562 { "\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B"
ansond 0:137634ff4186 563 "\x0B\x0B\x0B\x0B" },
ansond 0:137634ff4186 564 { "Jefe" },
ansond 0:137634ff4186 565 { "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
ansond 0:137634ff4186 566 "\xAA\xAA\xAA\xAA" },
ansond 0:137634ff4186 567 { "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10"
ansond 0:137634ff4186 568 "\x11\x12\x13\x14\x15\x16\x17\x18\x19" },
ansond 0:137634ff4186 569 { "\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C"
ansond 0:137634ff4186 570 "\x0C\x0C\x0C\x0C" },
ansond 0:137634ff4186 571 { "" }, /* 0xAA 131 times */
ansond 0:137634ff4186 572 { "" }
ansond 0:137634ff4186 573 };
ansond 0:137634ff4186 574
ansond 0:137634ff4186 575 static const int sha512_hmac_test_keylen[7] =
ansond 0:137634ff4186 576 {
ansond 0:137634ff4186 577 20, 4, 20, 25, 20, 131, 131
ansond 0:137634ff4186 578 };
ansond 0:137634ff4186 579
ansond 0:137634ff4186 580 static const unsigned char sha512_hmac_test_buf[7][153] =
ansond 0:137634ff4186 581 {
ansond 0:137634ff4186 582 { "Hi There" },
ansond 0:137634ff4186 583 { "what do ya want for nothing?" },
ansond 0:137634ff4186 584 { "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
ansond 0:137634ff4186 585 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
ansond 0:137634ff4186 586 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
ansond 0:137634ff4186 587 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
ansond 0:137634ff4186 588 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" },
ansond 0:137634ff4186 589 { "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
ansond 0:137634ff4186 590 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
ansond 0:137634ff4186 591 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
ansond 0:137634ff4186 592 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
ansond 0:137634ff4186 593 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD" },
ansond 0:137634ff4186 594 { "Test With Truncation" },
ansond 0:137634ff4186 595 { "Test Using Larger Than Block-Size Key - Hash Key First" },
ansond 0:137634ff4186 596 { "This is a test using a larger than block-size key "
ansond 0:137634ff4186 597 "and a larger than block-size data. The key needs to "
ansond 0:137634ff4186 598 "be hashed before being used by the HMAC algorithm." }
ansond 0:137634ff4186 599 };
ansond 0:137634ff4186 600
ansond 0:137634ff4186 601 static const int sha512_hmac_test_buflen[7] =
ansond 0:137634ff4186 602 {
ansond 0:137634ff4186 603 8, 28, 50, 50, 20, 54, 152
ansond 0:137634ff4186 604 };
ansond 0:137634ff4186 605
ansond 0:137634ff4186 606 static const unsigned char sha512_hmac_test_sum[14][64] =
ansond 0:137634ff4186 607 {
ansond 0:137634ff4186 608 /*
ansond 0:137634ff4186 609 * HMAC-SHA-384 test vectors
ansond 0:137634ff4186 610 */
ansond 0:137634ff4186 611 { 0xAF, 0xD0, 0x39, 0x44, 0xD8, 0x48, 0x95, 0x62,
ansond 0:137634ff4186 612 0x6B, 0x08, 0x25, 0xF4, 0xAB, 0x46, 0x90, 0x7F,
ansond 0:137634ff4186 613 0x15, 0xF9, 0xDA, 0xDB, 0xE4, 0x10, 0x1E, 0xC6,
ansond 0:137634ff4186 614 0x82, 0xAA, 0x03, 0x4C, 0x7C, 0xEB, 0xC5, 0x9C,
ansond 0:137634ff4186 615 0xFA, 0xEA, 0x9E, 0xA9, 0x07, 0x6E, 0xDE, 0x7F,
ansond 0:137634ff4186 616 0x4A, 0xF1, 0x52, 0xE8, 0xB2, 0xFA, 0x9C, 0xB6 },
ansond 0:137634ff4186 617 { 0xAF, 0x45, 0xD2, 0xE3, 0x76, 0x48, 0x40, 0x31,
ansond 0:137634ff4186 618 0x61, 0x7F, 0x78, 0xD2, 0xB5, 0x8A, 0x6B, 0x1B,
ansond 0:137634ff4186 619 0x9C, 0x7E, 0xF4, 0x64, 0xF5, 0xA0, 0x1B, 0x47,
ansond 0:137634ff4186 620 0xE4, 0x2E, 0xC3, 0x73, 0x63, 0x22, 0x44, 0x5E,
ansond 0:137634ff4186 621 0x8E, 0x22, 0x40, 0xCA, 0x5E, 0x69, 0xE2, 0xC7,
ansond 0:137634ff4186 622 0x8B, 0x32, 0x39, 0xEC, 0xFA, 0xB2, 0x16, 0x49 },
ansond 0:137634ff4186 623 { 0x88, 0x06, 0x26, 0x08, 0xD3, 0xE6, 0xAD, 0x8A,
ansond 0:137634ff4186 624 0x0A, 0xA2, 0xAC, 0xE0, 0x14, 0xC8, 0xA8, 0x6F,
ansond 0:137634ff4186 625 0x0A, 0xA6, 0x35, 0xD9, 0x47, 0xAC, 0x9F, 0xEB,
ansond 0:137634ff4186 626 0xE8, 0x3E, 0xF4, 0xE5, 0x59, 0x66, 0x14, 0x4B,
ansond 0:137634ff4186 627 0x2A, 0x5A, 0xB3, 0x9D, 0xC1, 0x38, 0x14, 0xB9,
ansond 0:137634ff4186 628 0x4E, 0x3A, 0xB6, 0xE1, 0x01, 0xA3, 0x4F, 0x27 },
ansond 0:137634ff4186 629 { 0x3E, 0x8A, 0x69, 0xB7, 0x78, 0x3C, 0x25, 0x85,
ansond 0:137634ff4186 630 0x19, 0x33, 0xAB, 0x62, 0x90, 0xAF, 0x6C, 0xA7,
ansond 0:137634ff4186 631 0x7A, 0x99, 0x81, 0x48, 0x08, 0x50, 0x00, 0x9C,
ansond 0:137634ff4186 632 0xC5, 0x57, 0x7C, 0x6E, 0x1F, 0x57, 0x3B, 0x4E,
ansond 0:137634ff4186 633 0x68, 0x01, 0xDD, 0x23, 0xC4, 0xA7, 0xD6, 0x79,
ansond 0:137634ff4186 634 0xCC, 0xF8, 0xA3, 0x86, 0xC6, 0x74, 0xCF, 0xFB },
ansond 0:137634ff4186 635 { 0x3A, 0xBF, 0x34, 0xC3, 0x50, 0x3B, 0x2A, 0x23,
ansond 0:137634ff4186 636 0xA4, 0x6E, 0xFC, 0x61, 0x9B, 0xAE, 0xF8, 0x97 },
ansond 0:137634ff4186 637 { 0x4E, 0xCE, 0x08, 0x44, 0x85, 0x81, 0x3E, 0x90,
ansond 0:137634ff4186 638 0x88, 0xD2, 0xC6, 0x3A, 0x04, 0x1B, 0xC5, 0xB4,
ansond 0:137634ff4186 639 0x4F, 0x9E, 0xF1, 0x01, 0x2A, 0x2B, 0x58, 0x8F,
ansond 0:137634ff4186 640 0x3C, 0xD1, 0x1F, 0x05, 0x03, 0x3A, 0xC4, 0xC6,
ansond 0:137634ff4186 641 0x0C, 0x2E, 0xF6, 0xAB, 0x40, 0x30, 0xFE, 0x82,
ansond 0:137634ff4186 642 0x96, 0x24, 0x8D, 0xF1, 0x63, 0xF4, 0x49, 0x52 },
ansond 0:137634ff4186 643 { 0x66, 0x17, 0x17, 0x8E, 0x94, 0x1F, 0x02, 0x0D,
ansond 0:137634ff4186 644 0x35, 0x1E, 0x2F, 0x25, 0x4E, 0x8F, 0xD3, 0x2C,
ansond 0:137634ff4186 645 0x60, 0x24, 0x20, 0xFE, 0xB0, 0xB8, 0xFB, 0x9A,
ansond 0:137634ff4186 646 0xDC, 0xCE, 0xBB, 0x82, 0x46, 0x1E, 0x99, 0xC5,
ansond 0:137634ff4186 647 0xA6, 0x78, 0xCC, 0x31, 0xE7, 0x99, 0x17, 0x6D,
ansond 0:137634ff4186 648 0x38, 0x60, 0xE6, 0x11, 0x0C, 0x46, 0x52, 0x3E },
ansond 0:137634ff4186 649
ansond 0:137634ff4186 650 /*
ansond 0:137634ff4186 651 * HMAC-SHA-512 test vectors
ansond 0:137634ff4186 652 */
ansond 0:137634ff4186 653 { 0x87, 0xAA, 0x7C, 0xDE, 0xA5, 0xEF, 0x61, 0x9D,
ansond 0:137634ff4186 654 0x4F, 0xF0, 0xB4, 0x24, 0x1A, 0x1D, 0x6C, 0xB0,
ansond 0:137634ff4186 655 0x23, 0x79, 0xF4, 0xE2, 0xCE, 0x4E, 0xC2, 0x78,
ansond 0:137634ff4186 656 0x7A, 0xD0, 0xB3, 0x05, 0x45, 0xE1, 0x7C, 0xDE,
ansond 0:137634ff4186 657 0xDA, 0xA8, 0x33, 0xB7, 0xD6, 0xB8, 0xA7, 0x02,
ansond 0:137634ff4186 658 0x03, 0x8B, 0x27, 0x4E, 0xAE, 0xA3, 0xF4, 0xE4,
ansond 0:137634ff4186 659 0xBE, 0x9D, 0x91, 0x4E, 0xEB, 0x61, 0xF1, 0x70,
ansond 0:137634ff4186 660 0x2E, 0x69, 0x6C, 0x20, 0x3A, 0x12, 0x68, 0x54 },
ansond 0:137634ff4186 661 { 0x16, 0x4B, 0x7A, 0x7B, 0xFC, 0xF8, 0x19, 0xE2,
ansond 0:137634ff4186 662 0xE3, 0x95, 0xFB, 0xE7, 0x3B, 0x56, 0xE0, 0xA3,
ansond 0:137634ff4186 663 0x87, 0xBD, 0x64, 0x22, 0x2E, 0x83, 0x1F, 0xD6,
ansond 0:137634ff4186 664 0x10, 0x27, 0x0C, 0xD7, 0xEA, 0x25, 0x05, 0x54,
ansond 0:137634ff4186 665 0x97, 0x58, 0xBF, 0x75, 0xC0, 0x5A, 0x99, 0x4A,
ansond 0:137634ff4186 666 0x6D, 0x03, 0x4F, 0x65, 0xF8, 0xF0, 0xE6, 0xFD,
ansond 0:137634ff4186 667 0xCA, 0xEA, 0xB1, 0xA3, 0x4D, 0x4A, 0x6B, 0x4B,
ansond 0:137634ff4186 668 0x63, 0x6E, 0x07, 0x0A, 0x38, 0xBC, 0xE7, 0x37 },
ansond 0:137634ff4186 669 { 0xFA, 0x73, 0xB0, 0x08, 0x9D, 0x56, 0xA2, 0x84,
ansond 0:137634ff4186 670 0xEF, 0xB0, 0xF0, 0x75, 0x6C, 0x89, 0x0B, 0xE9,
ansond 0:137634ff4186 671 0xB1, 0xB5, 0xDB, 0xDD, 0x8E, 0xE8, 0x1A, 0x36,
ansond 0:137634ff4186 672 0x55, 0xF8, 0x3E, 0x33, 0xB2, 0x27, 0x9D, 0x39,
ansond 0:137634ff4186 673 0xBF, 0x3E, 0x84, 0x82, 0x79, 0xA7, 0x22, 0xC8,
ansond 0:137634ff4186 674 0x06, 0xB4, 0x85, 0xA4, 0x7E, 0x67, 0xC8, 0x07,
ansond 0:137634ff4186 675 0xB9, 0x46, 0xA3, 0x37, 0xBE, 0xE8, 0x94, 0x26,
ansond 0:137634ff4186 676 0x74, 0x27, 0x88, 0x59, 0xE1, 0x32, 0x92, 0xFB },
ansond 0:137634ff4186 677 { 0xB0, 0xBA, 0x46, 0x56, 0x37, 0x45, 0x8C, 0x69,
ansond 0:137634ff4186 678 0x90, 0xE5, 0xA8, 0xC5, 0xF6, 0x1D, 0x4A, 0xF7,
ansond 0:137634ff4186 679 0xE5, 0x76, 0xD9, 0x7F, 0xF9, 0x4B, 0x87, 0x2D,
ansond 0:137634ff4186 680 0xE7, 0x6F, 0x80, 0x50, 0x36, 0x1E, 0xE3, 0xDB,
ansond 0:137634ff4186 681 0xA9, 0x1C, 0xA5, 0xC1, 0x1A, 0xA2, 0x5E, 0xB4,
ansond 0:137634ff4186 682 0xD6, 0x79, 0x27, 0x5C, 0xC5, 0x78, 0x80, 0x63,
ansond 0:137634ff4186 683 0xA5, 0xF1, 0x97, 0x41, 0x12, 0x0C, 0x4F, 0x2D,
ansond 0:137634ff4186 684 0xE2, 0xAD, 0xEB, 0xEB, 0x10, 0xA2, 0x98, 0xDD },
ansond 0:137634ff4186 685 { 0x41, 0x5F, 0xAD, 0x62, 0x71, 0x58, 0x0A, 0x53,
ansond 0:137634ff4186 686 0x1D, 0x41, 0x79, 0xBC, 0x89, 0x1D, 0x87, 0xA6 },
ansond 0:137634ff4186 687 { 0x80, 0xB2, 0x42, 0x63, 0xC7, 0xC1, 0xA3, 0xEB,
ansond 0:137634ff4186 688 0xB7, 0x14, 0x93, 0xC1, 0xDD, 0x7B, 0xE8, 0xB4,
ansond 0:137634ff4186 689 0x9B, 0x46, 0xD1, 0xF4, 0x1B, 0x4A, 0xEE, 0xC1,
ansond 0:137634ff4186 690 0x12, 0x1B, 0x01, 0x37, 0x83, 0xF8, 0xF3, 0x52,
ansond 0:137634ff4186 691 0x6B, 0x56, 0xD0, 0x37, 0xE0, 0x5F, 0x25, 0x98,
ansond 0:137634ff4186 692 0xBD, 0x0F, 0xD2, 0x21, 0x5D, 0x6A, 0x1E, 0x52,
ansond 0:137634ff4186 693 0x95, 0xE6, 0x4F, 0x73, 0xF6, 0x3F, 0x0A, 0xEC,
ansond 0:137634ff4186 694 0x8B, 0x91, 0x5A, 0x98, 0x5D, 0x78, 0x65, 0x98 },
ansond 0:137634ff4186 695 { 0xE3, 0x7B, 0x6A, 0x77, 0x5D, 0xC8, 0x7D, 0xBA,
ansond 0:137634ff4186 696 0xA4, 0xDF, 0xA9, 0xF9, 0x6E, 0x5E, 0x3F, 0xFD,
ansond 0:137634ff4186 697 0xDE, 0xBD, 0x71, 0xF8, 0x86, 0x72, 0x89, 0x86,
ansond 0:137634ff4186 698 0x5D, 0xF5, 0xA3, 0x2D, 0x20, 0xCD, 0xC9, 0x44,
ansond 0:137634ff4186 699 0xB6, 0x02, 0x2C, 0xAC, 0x3C, 0x49, 0x82, 0xB1,
ansond 0:137634ff4186 700 0x0D, 0x5E, 0xEB, 0x55, 0xC3, 0xE4, 0xDE, 0x15,
ansond 0:137634ff4186 701 0x13, 0x46, 0x76, 0xFB, 0x6D, 0xE0, 0x44, 0x60,
ansond 0:137634ff4186 702 0x65, 0xC9, 0x74, 0x40, 0xFA, 0x8C, 0x6A, 0x58 }
ansond 0:137634ff4186 703 };
ansond 0:137634ff4186 704
ansond 0:137634ff4186 705 /*
ansond 0:137634ff4186 706 * Checkup routine
ansond 0:137634ff4186 707 */
ansond 0:137634ff4186 708 int sha512_self_test( int verbose )
ansond 0:137634ff4186 709 {
ansond 0:137634ff4186 710 int i, j, k, buflen, ret = 0;
ansond 0:137634ff4186 711 unsigned char buf[1024];
ansond 0:137634ff4186 712 unsigned char sha512sum[64];
ansond 0:137634ff4186 713 sha512_context ctx;
ansond 0:137634ff4186 714
ansond 0:137634ff4186 715 sha512_init( &ctx );
ansond 0:137634ff4186 716
ansond 0:137634ff4186 717 for( i = 0; i < 6; i++ )
ansond 0:137634ff4186 718 {
ansond 0:137634ff4186 719 j = i % 3;
ansond 0:137634ff4186 720 k = i < 3;
ansond 0:137634ff4186 721
ansond 0:137634ff4186 722 if( verbose != 0 )
ansond 0:137634ff4186 723 polarssl_printf( " SHA-%d test #%d: ", 512 - k * 128, j + 1 );
ansond 0:137634ff4186 724
ansond 0:137634ff4186 725 sha512_starts( &ctx, k );
ansond 0:137634ff4186 726
ansond 0:137634ff4186 727 if( j == 2 )
ansond 0:137634ff4186 728 {
ansond 0:137634ff4186 729 memset( buf, 'a', buflen = 1000 );
ansond 0:137634ff4186 730
ansond 0:137634ff4186 731 for( j = 0; j < 1000; j++ )
ansond 0:137634ff4186 732 sha512_update( &ctx, buf, buflen );
ansond 0:137634ff4186 733 }
ansond 0:137634ff4186 734 else
ansond 0:137634ff4186 735 sha512_update( &ctx, sha512_test_buf[j],
ansond 0:137634ff4186 736 sha512_test_buflen[j] );
ansond 0:137634ff4186 737
ansond 0:137634ff4186 738 sha512_finish( &ctx, sha512sum );
ansond 0:137634ff4186 739
ansond 0:137634ff4186 740 if( memcmp( sha512sum, sha512_test_sum[i], 64 - k * 16 ) != 0 )
ansond 0:137634ff4186 741 {
ansond 0:137634ff4186 742 if( verbose != 0 )
ansond 0:137634ff4186 743 polarssl_printf( "failed\n" );
ansond 0:137634ff4186 744
ansond 0:137634ff4186 745 ret = 1;
ansond 0:137634ff4186 746 goto exit;
ansond 0:137634ff4186 747 }
ansond 0:137634ff4186 748
ansond 0:137634ff4186 749 if( verbose != 0 )
ansond 0:137634ff4186 750 polarssl_printf( "passed\n" );
ansond 0:137634ff4186 751 }
ansond 0:137634ff4186 752
ansond 0:137634ff4186 753 if( verbose != 0 )
ansond 0:137634ff4186 754 polarssl_printf( "\n" );
ansond 0:137634ff4186 755
ansond 0:137634ff4186 756 for( i = 0; i < 14; i++ )
ansond 0:137634ff4186 757 {
ansond 0:137634ff4186 758 j = i % 7;
ansond 0:137634ff4186 759 k = i < 7;
ansond 0:137634ff4186 760
ansond 0:137634ff4186 761 if( verbose != 0 )
ansond 0:137634ff4186 762 polarssl_printf( " HMAC-SHA-%d test #%d: ", 512 - k * 128, j + 1 );
ansond 0:137634ff4186 763
ansond 0:137634ff4186 764 if( j == 5 || j == 6 )
ansond 0:137634ff4186 765 {
ansond 0:137634ff4186 766 memset( buf, 0xAA, buflen = 131 );
ansond 0:137634ff4186 767 sha512_hmac_starts( &ctx, buf, buflen, k );
ansond 0:137634ff4186 768 }
ansond 0:137634ff4186 769 else
ansond 0:137634ff4186 770 sha512_hmac_starts( &ctx, sha512_hmac_test_key[j],
ansond 0:137634ff4186 771 sha512_hmac_test_keylen[j], k );
ansond 0:137634ff4186 772
ansond 0:137634ff4186 773 sha512_hmac_update( &ctx, sha512_hmac_test_buf[j],
ansond 0:137634ff4186 774 sha512_hmac_test_buflen[j] );
ansond 0:137634ff4186 775
ansond 0:137634ff4186 776 sha512_hmac_finish( &ctx, sha512sum );
ansond 0:137634ff4186 777
ansond 0:137634ff4186 778 buflen = ( j == 4 ) ? 16 : 64 - k * 16;
ansond 0:137634ff4186 779
ansond 0:137634ff4186 780 if( memcmp( sha512sum, sha512_hmac_test_sum[i], buflen ) != 0 )
ansond 0:137634ff4186 781 {
ansond 0:137634ff4186 782 if( verbose != 0 )
ansond 0:137634ff4186 783 polarssl_printf( "failed\n" );
ansond 0:137634ff4186 784
ansond 0:137634ff4186 785 ret = 1;
ansond 0:137634ff4186 786 goto exit;
ansond 0:137634ff4186 787 }
ansond 0:137634ff4186 788
ansond 0:137634ff4186 789 if( verbose != 0 )
ansond 0:137634ff4186 790 polarssl_printf( "passed\n" );
ansond 0:137634ff4186 791 }
ansond 0:137634ff4186 792
ansond 0:137634ff4186 793 if( verbose != 0 )
ansond 0:137634ff4186 794 polarssl_printf( "\n" );
ansond 0:137634ff4186 795
ansond 0:137634ff4186 796 exit:
ansond 0:137634ff4186 797 sha512_free( &ctx );
ansond 0:137634ff4186 798
ansond 0:137634ff4186 799 return( ret );
ansond 0:137634ff4186 800 }
ansond 0:137634ff4186 801
ansond 0:137634ff4186 802 #endif /* POLARSSL_SELF_TEST */
ansond 0:137634ff4186 803
ansond 0:137634ff4186 804 #endif /* POLARSSL_SHA512_C */
ansond 0:137634ff4186 805