sha512.c

00001 /*
00002  *  FIPS-180-2 compliant SHA-384/512 implementation
00003  *
00004  *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
00005  *  SPDX-License-Identifier: Apache-2.0
00006  *
00007  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
00008  *  not use this file except in compliance with the License.
00009  *  You may obtain a copy of the License at
00010  *
00011  *  http://www.apache.org/licenses/LICENSE-2.0
00012  *
00013  *  Unless required by applicable law or agreed to in writing, software
00014  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
00015  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00016  *  See the License for the specific language governing permissions and
00017  *  limitations under the License.
00018  *
00019  *  This file is part of mbed TLS (https://tls.mbed.org)
00020  */
00021 /*
00022  *  The SHA-512 Secure Hash Standard was published by NIST in 2002.
00023  *
00024  *  http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
00025  */
00026 
00027 #if !defined(MBEDTLS_CONFIG_FILE)
00028 #include "mbedtls/config.h"
00029 #else
00030 #include MBEDTLS_CONFIG_FILE
00031 #endif
00032 
00033 #if defined(MBEDTLS_SHA512_C)
00034 
00035 #include "mbedtls/sha512.h"
00036 #include "mbedtls/platform_util.h"
00037 
00038 #if defined(_MSC_VER) || defined(__WATCOMC__)
00039   #define UL64(x) x##ui64
00040 #else
00041   #define UL64(x) x##ULL
00042 #endif
00043 
00044 #include <string.h>
00045 
00046 #if defined(MBEDTLS_SELF_TEST)
00047 #if defined(MBEDTLS_PLATFORM_C)
00048 #include "mbedtls/platform.h"
00049 #else
00050 #include <stdio.h>
00051 #include <stdlib.h>
00052 #define mbedtls_printf printf
00053 #define mbedtls_calloc    calloc
00054 #define mbedtls_free       free
00055 #endif /* MBEDTLS_PLATFORM_C */
00056 #endif /* MBEDTLS_SELF_TEST */
00057 
00058 #if !defined(MBEDTLS_SHA512_ALT)
00059 
00060 /*
00061  * 64-bit integer manipulation macros (big endian)
00062  */
00063 #ifndef GET_UINT64_BE
00064 #define GET_UINT64_BE(n,b,i)                            \
00065 {                                                       \
00066     (n) = ( (uint64_t) (b)[(i)    ] << 56 )       \
00067         | ( (uint64_t) (b)[(i) + 1] << 48 )       \
00068         | ( (uint64_t) (b)[(i) + 2] << 40 )       \
00069         | ( (uint64_t) (b)[(i) + 3] << 32 )       \
00070         | ( (uint64_t) (b)[(i) + 4] << 24 )       \
00071         | ( (uint64_t) (b)[(i) + 5] << 16 )       \
00072         | ( (uint64_t) (b)[(i) + 6] <<  8 )       \
00073         | ( (uint64_t) (b)[(i) + 7]       );      \
00074 }
00075 #endif /* GET_UINT64_BE */
00076 
00077 #ifndef PUT_UINT64_BE
00078 #define PUT_UINT64_BE(n,b,i)                            \
00079 {                                                       \
00080     (b)[(i)    ] = (unsigned char) ( (n) >> 56 );       \
00081     (b)[(i) + 1] = (unsigned char) ( (n) >> 48 );       \
00082     (b)[(i) + 2] = (unsigned char) ( (n) >> 40 );       \
00083     (b)[(i) + 3] = (unsigned char) ( (n) >> 32 );       \
00084     (b)[(i) + 4] = (unsigned char) ( (n) >> 24 );       \
00085     (b)[(i) + 5] = (unsigned char) ( (n) >> 16 );       \
00086     (b)[(i) + 6] = (unsigned char) ( (n) >>  8 );       \
00087     (b)[(i) + 7] = (unsigned char) ( (n)       );       \
00088 }
00089 #endif /* PUT_UINT64_BE */
00090 
00091 void mbedtls_sha512_init( mbedtls_sha512_context *ctx )
00092 {
00093     memset( ctx, 0, sizeof( mbedtls_sha512_context ) );
00094 }
00095 
00096 void mbedtls_sha512_free( mbedtls_sha512_context *ctx )
00097 {
00098     if( ctx == NULL )
00099         return;
00100 
00101     mbedtls_platform_zeroize( ctx, sizeof( mbedtls_sha512_context ) );
00102 }
00103 
00104 void mbedtls_sha512_clone( mbedtls_sha512_context *dst,
00105                            const mbedtls_sha512_context *src )
00106 {
00107     *dst = *src;
00108 }
00109 
00110 /*
00111  * SHA-512 context setup
00112  */
00113 int mbedtls_sha512_starts_ret( mbedtls_sha512_context *ctx, int is384 )
00114 {
00115     ctx->total [0] = 0;
00116     ctx->total [1] = 0;
00117 
00118     if( is384 == 0 )
00119     {
00120         /* SHA-512 */
00121         ctx->state [0] = UL64(0x6A09E667F3BCC908);
00122         ctx->state [1] = UL64(0xBB67AE8584CAA73B);
00123         ctx->state [2] = UL64(0x3C6EF372FE94F82B);
00124         ctx->state [3] = UL64(0xA54FF53A5F1D36F1);
00125         ctx->state [4] = UL64(0x510E527FADE682D1);
00126         ctx->state [5] = UL64(0x9B05688C2B3E6C1F);
00127         ctx->state [6] = UL64(0x1F83D9ABFB41BD6B);
00128         ctx->state [7] = UL64(0x5BE0CD19137E2179);
00129     }
00130     else
00131     {
00132         /* SHA-384 */
00133         ctx->state [0] = UL64(0xCBBB9D5DC1059ED8);
00134         ctx->state [1] = UL64(0x629A292A367CD507);
00135         ctx->state [2] = UL64(0x9159015A3070DD17);
00136         ctx->state [3] = UL64(0x152FECD8F70E5939);
00137         ctx->state [4] = UL64(0x67332667FFC00B31);
00138         ctx->state [5] = UL64(0x8EB44A8768581511);
00139         ctx->state [6] = UL64(0xDB0C2E0D64F98FA7);
00140         ctx->state [7] = UL64(0x47B5481DBEFA4FA4);
00141     }
00142 
00143     ctx->is384  = is384;
00144 
00145     return( 0 );
00146 }
00147 
00148 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00149 void mbedtls_sha512_starts( mbedtls_sha512_context *ctx,
00150                             int is384 )
00151 {
00152     mbedtls_sha512_starts_ret( ctx, is384 );
00153 }
00154 #endif
00155 
00156 #if !defined(MBEDTLS_SHA512_PROCESS_ALT)
00157 
00158 /*
00159  * Round constants
00160  */
00161 static const uint64_t K[80] =
00162 {
00163     UL64(0x428A2F98D728AE22),  UL64(0x7137449123EF65CD),
00164     UL64(0xB5C0FBCFEC4D3B2F),  UL64(0xE9B5DBA58189DBBC),
00165     UL64(0x3956C25BF348B538),  UL64(0x59F111F1B605D019),
00166     UL64(0x923F82A4AF194F9B),  UL64(0xAB1C5ED5DA6D8118),
00167     UL64(0xD807AA98A3030242),  UL64(0x12835B0145706FBE),
00168     UL64(0x243185BE4EE4B28C),  UL64(0x550C7DC3D5FFB4E2),
00169     UL64(0x72BE5D74F27B896F),  UL64(0x80DEB1FE3B1696B1),
00170     UL64(0x9BDC06A725C71235),  UL64(0xC19BF174CF692694),
00171     UL64(0xE49B69C19EF14AD2),  UL64(0xEFBE4786384F25E3),
00172     UL64(0x0FC19DC68B8CD5B5),  UL64(0x240CA1CC77AC9C65),
00173     UL64(0x2DE92C6F592B0275),  UL64(0x4A7484AA6EA6E483),
00174     UL64(0x5CB0A9DCBD41FBD4),  UL64(0x76F988DA831153B5),
00175     UL64(0x983E5152EE66DFAB),  UL64(0xA831C66D2DB43210),
00176     UL64(0xB00327C898FB213F),  UL64(0xBF597FC7BEEF0EE4),
00177     UL64(0xC6E00BF33DA88FC2),  UL64(0xD5A79147930AA725),
00178     UL64(0x06CA6351E003826F),  UL64(0x142929670A0E6E70),
00179     UL64(0x27B70A8546D22FFC),  UL64(0x2E1B21385C26C926),
00180     UL64(0x4D2C6DFC5AC42AED),  UL64(0x53380D139D95B3DF),
00181     UL64(0x650A73548BAF63DE),  UL64(0x766A0ABB3C77B2A8),
00182     UL64(0x81C2C92E47EDAEE6),  UL64(0x92722C851482353B),
00183     UL64(0xA2BFE8A14CF10364),  UL64(0xA81A664BBC423001),
00184     UL64(0xC24B8B70D0F89791),  UL64(0xC76C51A30654BE30),
00185     UL64(0xD192E819D6EF5218),  UL64(0xD69906245565A910),
00186     UL64(0xF40E35855771202A),  UL64(0x106AA07032BBD1B8),
00187     UL64(0x19A4C116B8D2D0C8),  UL64(0x1E376C085141AB53),
00188     UL64(0x2748774CDF8EEB99),  UL64(0x34B0BCB5E19B48A8),
00189     UL64(0x391C0CB3C5C95A63),  UL64(0x4ED8AA4AE3418ACB),
00190     UL64(0x5B9CCA4F7763E373),  UL64(0x682E6FF3D6B2B8A3),
00191     UL64(0x748F82EE5DEFB2FC),  UL64(0x78A5636F43172F60),
00192     UL64(0x84C87814A1F0AB72),  UL64(0x8CC702081A6439EC),
00193     UL64(0x90BEFFFA23631E28),  UL64(0xA4506CEBDE82BDE9),
00194     UL64(0xBEF9A3F7B2C67915),  UL64(0xC67178F2E372532B),
00195     UL64(0xCA273ECEEA26619C),  UL64(0xD186B8C721C0C207),
00196     UL64(0xEADA7DD6CDE0EB1E),  UL64(0xF57D4F7FEE6ED178),
00197     UL64(0x06F067AA72176FBA),  UL64(0x0A637DC5A2C898A6),
00198     UL64(0x113F9804BEF90DAE),  UL64(0x1B710B35131C471B),
00199     UL64(0x28DB77F523047D84),  UL64(0x32CAAB7B40C72493),
00200     UL64(0x3C9EBE0A15C9BEBC),  UL64(0x431D67C49C100D4C),
00201     UL64(0x4CC5D4BECB3E42B6),  UL64(0x597F299CFC657E2A),
00202     UL64(0x5FCB6FAB3AD6FAEC),  UL64(0x6C44198C4A475817)
00203 };
00204 
00205 int mbedtls_internal_sha512_process( mbedtls_sha512_context *ctx,
00206                                      const unsigned char data[128] )
00207 {
00208     int i;
00209     uint64_t temp1, temp2, W[80];
00210     uint64_t A, B, C, D, E, F, G, H;
00211 
00212 #define  SHR(x,n) (x >> n)
00213 #define ROTR(x,n) (SHR(x,n) | (x << (64 - n)))
00214 
00215 #define S0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^  SHR(x, 7))
00216 #define S1(x) (ROTR(x,19) ^ ROTR(x,61) ^  SHR(x, 6))
00217 
00218 #define S2(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
00219 #define S3(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
00220 
00221 #define F0(x,y,z) ((x & y) | (z & (x | y)))
00222 #define F1(x,y,z) (z ^ (x & (y ^ z)))
00223 
00224 #define P(a,b,c,d,e,f,g,h,x,K)                  \
00225 {                                               \
00226     temp1 = h + S3(e) + F1(e,f,g) + K + x;      \
00227     temp2 = S2(a) + F0(a,b,c);                  \
00228     d += temp1; h = temp1 + temp2;              \
00229 }
00230 
00231     for( i = 0; i < 16; i++ )
00232     {
00233         GET_UINT64_BE( W[i], data, i << 3 );
00234     }
00235 
00236     for( ; i < 80; i++ )
00237     {
00238         W[i] = S1(W[i -  2]) + W[i -  7] +
00239                S0(W[i - 15]) + W[i - 16];
00240     }
00241 
00242     A = ctx->state [0];
00243     B = ctx->state [1];
00244     C = ctx->state [2];
00245     D = ctx->state [3];
00246     E = ctx->state [4];
00247     F = ctx->state [5];
00248     G = ctx->state [6];
00249     H = ctx->state [7];
00250     i = 0;
00251 
00252     do
00253     {
00254         P( A, B, C, D, E, F, G, H, W[i], K[i] ); i++;
00255         P( H, A, B, C, D, E, F, G, W[i], K[i] ); i++;
00256         P( G, H, A, B, C, D, E, F, W[i], K[i] ); i++;
00257         P( F, G, H, A, B, C, D, E, W[i], K[i] ); i++;
00258         P( E, F, G, H, A, B, C, D, W[i], K[i] ); i++;
00259         P( D, E, F, G, H, A, B, C, W[i], K[i] ); i++;
00260         P( C, D, E, F, G, H, A, B, W[i], K[i] ); i++;
00261         P( B, C, D, E, F, G, H, A, W[i], K[i] ); i++;
00262     }
00263     while( i < 80 );
00264 
00265     ctx->state [0] += A;
00266     ctx->state [1] += B;
00267     ctx->state [2] += C;
00268     ctx->state [3] += D;
00269     ctx->state [4] += E;
00270     ctx->state [5] += F;
00271     ctx->state [6] += G;
00272     ctx->state [7] += H;
00273 
00274     return( 0 );
00275 }
00276 
00277 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00278 void mbedtls_sha512_process( mbedtls_sha512_context *ctx,
00279                              const unsigned char data[128] )
00280 {
00281     mbedtls_internal_sha512_process( ctx, data );
00282 }
00283 #endif
00284 #endif /* !MBEDTLS_SHA512_PROCESS_ALT */
00285 
00286 /*
00287  * SHA-512 process buffer
00288  */
00289 int mbedtls_sha512_update_ret( mbedtls_sha512_context *ctx,
00290                                const unsigned char *input,
00291                                size_t ilen )
00292 {
00293     int ret;
00294     size_t fill;
00295     unsigned int left;
00296 
00297     if( ilen == 0 )
00298         return( 0 );
00299 
00300     left = (unsigned int) (ctx->total [0] & 0x7F);
00301     fill = 128 - left;
00302 
00303     ctx->total [0] += (uint64_t) ilen;
00304 
00305     if( ctx->total [0] < (uint64_t) ilen )
00306         ctx->total [1]++;
00307 
00308     if( left && ilen >= fill )
00309     {
00310         memcpy( (void *) (ctx->buffer  + left), input, fill );
00311 
00312         if( ( ret = mbedtls_internal_sha512_process( ctx, ctx->buffer  ) ) != 0 )
00313             return( ret );
00314 
00315         input += fill;
00316         ilen  -= fill;
00317         left = 0;
00318     }
00319 
00320     while( ilen >= 128 )
00321     {
00322         if( ( ret = mbedtls_internal_sha512_process( ctx, input ) ) != 0 )
00323             return( ret );
00324 
00325         input += 128;
00326         ilen  -= 128;
00327     }
00328 
00329     if( ilen > 0 )
00330         memcpy( (void *) (ctx->buffer  + left), input, ilen );
00331 
00332     return( 0 );
00333 }
00334 
00335 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00336 void mbedtls_sha512_update( mbedtls_sha512_context *ctx,
00337                             const unsigned char *input,
00338                             size_t ilen )
00339 {
00340     mbedtls_sha512_update_ret( ctx, input, ilen );
00341 }
00342 #endif
00343 
00344 /*
00345  * SHA-512 final digest
00346  */
00347 int mbedtls_sha512_finish_ret( mbedtls_sha512_context *ctx,
00348                                unsigned char output[64] )
00349 {
00350     int ret;
00351     unsigned used;
00352     uint64_t high, low;
00353 
00354     /*
00355      * Add padding: 0x80 then 0x00 until 16 bytes remain for the length
00356      */
00357     used = ctx->total [0] & 0x7F;
00358 
00359     ctx->buffer [used++] = 0x80;
00360 
00361     if( used <= 112 )
00362     {
00363         /* Enough room for padding + length in current block */
00364         memset( ctx->buffer  + used, 0, 112 - used );
00365     }
00366     else
00367     {
00368         /* We'll need an extra block */
00369         memset( ctx->buffer  + used, 0, 128 - used );
00370 
00371         if( ( ret = mbedtls_internal_sha512_process( ctx, ctx->buffer  ) ) != 0 )
00372             return( ret );
00373 
00374         memset( ctx->buffer , 0, 112 );
00375     }
00376 
00377     /*
00378      * Add message length
00379      */
00380     high = ( ctx->total [0] >> 61 )
00381          | ( ctx->total [1] <<  3 );
00382     low  = ( ctx->total [0] <<  3 );
00383 
00384     PUT_UINT64_BE( high, ctx->buffer , 112 );
00385     PUT_UINT64_BE( low,  ctx->buffer , 120 );
00386 
00387     if( ( ret = mbedtls_internal_sha512_process( ctx, ctx->buffer  ) ) != 0 )
00388         return( ret );
00389 
00390     /*
00391      * Output final state
00392      */
00393     PUT_UINT64_BE( ctx->state [0], output,  0 );
00394     PUT_UINT64_BE( ctx->state [1], output,  8 );
00395     PUT_UINT64_BE( ctx->state [2], output, 16 );
00396     PUT_UINT64_BE( ctx->state [3], output, 24 );
00397     PUT_UINT64_BE( ctx->state [4], output, 32 );
00398     PUT_UINT64_BE( ctx->state [5], output, 40 );
00399 
00400     if( ctx->is384  == 0 )
00401     {
00402         PUT_UINT64_BE( ctx->state [6], output, 48 );
00403         PUT_UINT64_BE( ctx->state [7], output, 56 );
00404     }
00405 
00406     return( 0 );
00407 }
00408 
00409 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00410 void mbedtls_sha512_finish( mbedtls_sha512_context *ctx,
00411                             unsigned char output[64] )
00412 {
00413     mbedtls_sha512_finish_ret( ctx, output );
00414 }
00415 #endif
00416 
00417 #endif /* !MBEDTLS_SHA512_ALT */
00418 
00419 /*
00420  * output = SHA-512( input buffer )
00421  */
00422 int mbedtls_sha512_ret( const unsigned char *input,
00423                     size_t ilen,
00424                     unsigned char output[64],
00425                     int is384 )
00426 {
00427     int ret;
00428     mbedtls_sha512_context ctx;
00429 
00430     mbedtls_sha512_init( &ctx );
00431 
00432     if( ( ret = mbedtls_sha512_starts_ret( &ctx, is384 ) ) != 0 )
00433         goto exit;
00434 
00435     if( ( ret = mbedtls_sha512_update_ret( &ctx, input, ilen ) ) != 0 )
00436         goto exit;
00437 
00438     if( ( ret = mbedtls_sha512_finish_ret( &ctx, output ) ) != 0 )
00439         goto exit;
00440 
00441 exit:
00442     mbedtls_sha512_free( &ctx );
00443 
00444     return( ret );
00445 }
00446 
00447 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00448 void mbedtls_sha512( const unsigned char *input,
00449                      size_t ilen,
00450                      unsigned char output[64],
00451                      int is384 )
00452 {
00453     mbedtls_sha512_ret( input, ilen, output, is384 );
00454 }
00455 #endif
00456 
00457 #if defined(MBEDTLS_SELF_TEST)
00458 
00459 /*
00460  * FIPS-180-2 test vectors
00461  */
00462 static const unsigned char sha512_test_buf[3][113] =
00463 {
00464     { "abc" },
00465     { "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
00466       "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" },
00467     { "" }
00468 };
00469 
00470 static const size_t sha512_test_buflen[3] =
00471 {
00472     3, 112, 1000
00473 };
00474 
00475 static const unsigned char sha512_test_sum[6][64] =
00476 {
00477     /*
00478      * SHA-384 test vectors
00479      */
00480     { 0xCB, 0x00, 0x75, 0x3F, 0x45, 0xA3, 0x5E, 0x8B,
00481       0xB5, 0xA0, 0x3D, 0x69, 0x9A, 0xC6, 0x50, 0x07,
00482       0x27, 0x2C, 0x32, 0xAB, 0x0E, 0xDE, 0xD1, 0x63,
00483       0x1A, 0x8B, 0x60, 0x5A, 0x43, 0xFF, 0x5B, 0xED,
00484       0x80, 0x86, 0x07, 0x2B, 0xA1, 0xE7, 0xCC, 0x23,
00485       0x58, 0xBA, 0xEC, 0xA1, 0x34, 0xC8, 0x25, 0xA7 },
00486     { 0x09, 0x33, 0x0C, 0x33, 0xF7, 0x11, 0x47, 0xE8,
00487       0x3D, 0x19, 0x2F, 0xC7, 0x82, 0xCD, 0x1B, 0x47,
00488       0x53, 0x11, 0x1B, 0x17, 0x3B, 0x3B, 0x05, 0xD2,
00489       0x2F, 0xA0, 0x80, 0x86, 0xE3, 0xB0, 0xF7, 0x12,
00490       0xFC, 0xC7, 0xC7, 0x1A, 0x55, 0x7E, 0x2D, 0xB9,
00491       0x66, 0xC3, 0xE9, 0xFA, 0x91, 0x74, 0x60, 0x39 },
00492     { 0x9D, 0x0E, 0x18, 0x09, 0x71, 0x64, 0x74, 0xCB,
00493       0x08, 0x6E, 0x83, 0x4E, 0x31, 0x0A, 0x4A, 0x1C,
00494       0xED, 0x14, 0x9E, 0x9C, 0x00, 0xF2, 0x48, 0x52,
00495       0x79, 0x72, 0xCE, 0xC5, 0x70, 0x4C, 0x2A, 0x5B,
00496       0x07, 0xB8, 0xB3, 0xDC, 0x38, 0xEC, 0xC4, 0xEB,
00497       0xAE, 0x97, 0xDD, 0xD8, 0x7F, 0x3D, 0x89, 0x85 },
00498 
00499     /*
00500      * SHA-512 test vectors
00501      */
00502     { 0xDD, 0xAF, 0x35, 0xA1, 0x93, 0x61, 0x7A, 0xBA,
00503       0xCC, 0x41, 0x73, 0x49, 0xAE, 0x20, 0x41, 0x31,
00504       0x12, 0xE6, 0xFA, 0x4E, 0x89, 0xA9, 0x7E, 0xA2,
00505       0x0A, 0x9E, 0xEE, 0xE6, 0x4B, 0x55, 0xD3, 0x9A,
00506       0x21, 0x92, 0x99, 0x2A, 0x27, 0x4F, 0xC1, 0xA8,
00507       0x36, 0xBA, 0x3C, 0x23, 0xA3, 0xFE, 0xEB, 0xBD,
00508       0x45, 0x4D, 0x44, 0x23, 0x64, 0x3C, 0xE8, 0x0E,
00509       0x2A, 0x9A, 0xC9, 0x4F, 0xA5, 0x4C, 0xA4, 0x9F },
00510     { 0x8E, 0x95, 0x9B, 0x75, 0xDA, 0xE3, 0x13, 0xDA,
00511       0x8C, 0xF4, 0xF7, 0x28, 0x14, 0xFC, 0x14, 0x3F,
00512       0x8F, 0x77, 0x79, 0xC6, 0xEB, 0x9F, 0x7F, 0xA1,
00513       0x72, 0x99, 0xAE, 0xAD, 0xB6, 0x88, 0x90, 0x18,
00514       0x50, 0x1D, 0x28, 0x9E, 0x49, 0x00, 0xF7, 0xE4,
00515       0x33, 0x1B, 0x99, 0xDE, 0xC4, 0xB5, 0x43, 0x3A,
00516       0xC7, 0xD3, 0x29, 0xEE, 0xB6, 0xDD, 0x26, 0x54,
00517       0x5E, 0x96, 0xE5, 0x5B, 0x87, 0x4B, 0xE9, 0x09 },
00518     { 0xE7, 0x18, 0x48, 0x3D, 0x0C, 0xE7, 0x69, 0x64,
00519       0x4E, 0x2E, 0x42, 0xC7, 0xBC, 0x15, 0xB4, 0x63,
00520       0x8E, 0x1F, 0x98, 0xB1, 0x3B, 0x20, 0x44, 0x28,
00521       0x56, 0x32, 0xA8, 0x03, 0xAF, 0xA9, 0x73, 0xEB,
00522       0xDE, 0x0F, 0xF2, 0x44, 0x87, 0x7E, 0xA6, 0x0A,
00523       0x4C, 0xB0, 0x43, 0x2C, 0xE5, 0x77, 0xC3, 0x1B,
00524       0xEB, 0x00, 0x9C, 0x5C, 0x2C, 0x49, 0xAA, 0x2E,
00525       0x4E, 0xAD, 0xB2, 0x17, 0xAD, 0x8C, 0xC0, 0x9B }
00526 };
00527 
00528 /*
00529  * Checkup routine
00530  */
00531 int mbedtls_sha512_self_test( int verbose )
00532 {
00533     int i, j, k, buflen, ret = 0;
00534     unsigned char *buf;
00535     unsigned char sha512sum[64];
00536     mbedtls_sha512_context ctx;
00537 
00538     buf = mbedtls_calloc( 1024, sizeof(unsigned char) );
00539     if( NULL == buf )
00540     {
00541         if( verbose != 0 )
00542             mbedtls_printf( "Buffer allocation failed\n" );
00543 
00544         return( 1 );
00545     }
00546 
00547     mbedtls_sha512_init( &ctx );
00548 
00549     for( i = 0; i < 6; i++ )
00550     {
00551         j = i % 3;
00552         k = i < 3;
00553 
00554         if( verbose != 0 )
00555             mbedtls_printf( "  SHA-%d test #%d: ", 512 - k * 128, j + 1 );
00556 
00557         if( ( ret = mbedtls_sha512_starts_ret( &ctx, k ) ) != 0 )
00558             goto fail;
00559 
00560         if( j == 2 )
00561         {
00562             memset( buf, 'a', buflen = 1000 );
00563 
00564             for( j = 0; j < 1000; j++ )
00565             {
00566                 ret = mbedtls_sha512_update_ret( &ctx, buf, buflen );
00567                 if( ret != 0 )
00568                     goto fail;
00569             }
00570         }
00571         else
00572         {
00573             ret = mbedtls_sha512_update_ret( &ctx, sha512_test_buf[j],
00574                                              sha512_test_buflen[j] );
00575             if( ret != 0 )
00576                 goto fail;
00577         }
00578 
00579         if( ( ret = mbedtls_sha512_finish_ret( &ctx, sha512sum ) ) != 0 )
00580             goto fail;
00581 
00582         if( memcmp( sha512sum, sha512_test_sum[i], 64 - k * 16 ) != 0 )
00583         {
00584             ret = 1;
00585             goto fail;
00586         }
00587 
00588         if( verbose != 0 )
00589             mbedtls_printf( "passed\n" );
00590     }
00591 
00592     if( verbose != 0 )
00593         mbedtls_printf( "\n" );
00594 
00595     goto exit;
00596 
00597 fail:
00598     if( verbose != 0 )
00599         mbedtls_printf( "failed\n" );
00600 
00601 exit:
00602     mbedtls_sha512_free( &ctx );
00603     mbedtls_free( buf );
00604 
00605     return( ret );
00606 }
00607 
00608 #endif /* MBEDTLS_SELF_TEST */
00609 
00610 #endif /* MBEDTLS_SHA512_C */