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 "config.h"
00029 #else
00030 #include MBEDTLS_CONFIG_FILE
00031 #endif
00032 
00033 //#if defined(MBEDTLS_SHA512_C)
00034 
00035 #include "sha512.h"
00036 
00037 #if defined(_MSC_VER) || defined(__WATCOMC__)
00038   #define UL64(x) x##ui64
00039 #else
00040   #define UL64(x) x##ULL
00041 #endif
00042 
00043 #include <string.h>
00044 
00045 #if defined(MBEDTLS_SELF_TEST)
00046 #if defined(MBEDTLS_PLATFORM_C)
00047 #include <stdio.h>
00048 #include <stdlib.h>
00049 #define mbedtls_printf printf
00050 #define mbedtls_calloc    calloc
00051 #define mbedtls_free       free
00052 #endif /* MBEDTLS_PLATFORM_C */
00053 #endif /* MBEDTLS_SELF_TEST */
00054 
00055 #if !defined(MBEDTLS_SHA512_ALT)
00056 
00057 /* Implementation that should never be optimized out by the compiler */
00058 static void mbedtls_zeroize( void *v, size_t n ) {
00059     volatile unsigned char *p = v; while( n-- ) *p++ = 0;
00060 }
00061 
00062 /*
00063  * 64-bit integer manipulation macros (big endian)
00064  */
00065 #ifndef GET_UINT64_BE
00066 #define GET_UINT64_BE(n,b,i)                            \
00067 {                                                       \
00068     (n) = ( (uint64_t) (b)[(i)    ] << 56 )       \
00069         | ( (uint64_t) (b)[(i) + 1] << 48 )       \
00070         | ( (uint64_t) (b)[(i) + 2] << 40 )       \
00071         | ( (uint64_t) (b)[(i) + 3] << 32 )       \
00072         | ( (uint64_t) (b)[(i) + 4] << 24 )       \
00073         | ( (uint64_t) (b)[(i) + 5] << 16 )       \
00074         | ( (uint64_t) (b)[(i) + 6] <<  8 )       \
00075         | ( (uint64_t) (b)[(i) + 7]       );      \
00076 }
00077 #endif /* GET_UINT64_BE */
00078 
00079 #ifndef PUT_UINT64_BE
00080 #define PUT_UINT64_BE(n,b,i)                            \
00081 {                                                       \
00082     (b)[(i)    ] = (unsigned char) ( (n) >> 56 );       \
00083     (b)[(i) + 1] = (unsigned char) ( (n) >> 48 );       \
00084     (b)[(i) + 2] = (unsigned char) ( (n) >> 40 );       \
00085     (b)[(i) + 3] = (unsigned char) ( (n) >> 32 );       \
00086     (b)[(i) + 4] = (unsigned char) ( (n) >> 24 );       \
00087     (b)[(i) + 5] = (unsigned char) ( (n) >> 16 );       \
00088     (b)[(i) + 6] = (unsigned char) ( (n) >>  8 );       \
00089     (b)[(i) + 7] = (unsigned char) ( (n)       );       \
00090 }
00091 #endif /* PUT_UINT64_BE */
00092 
00093 void mbedtls_sha512_init( mbedtls_sha512_context *ctx )
00094 {
00095     memset( ctx, 0, sizeof( mbedtls_sha512_context ) );
00096 }
00097 
00098 void mbedtls_sha512_free( mbedtls_sha512_context *ctx )
00099 {
00100     if( ctx == NULL )
00101         return;
00102 
00103     mbedtls_zeroize( ctx, sizeof( mbedtls_sha512_context ) );
00104 }
00105 
00106 void mbedtls_sha512_clone( mbedtls_sha512_context *dst,
00107                            const mbedtls_sha512_context *src )
00108 {
00109     *dst = *src;
00110 }
00111 
00112 /*
00113  * SHA-512 context setup
00114  */
00115 void mbedtls_sha512_starts( mbedtls_sha512_context *ctx, int is384 )
00116 {
00117     ctx->total [0] = 0;
00118     ctx->total [1] = 0;
00119 
00120     if( is384 == 0 )
00121     {
00122         /* SHA-512 */
00123         ctx->state [0] = UL64(0x6A09E667F3BCC908);
00124         ctx->state [1] = UL64(0xBB67AE8584CAA73B);
00125         ctx->state [2] = UL64(0x3C6EF372FE94F82B);
00126         ctx->state [3] = UL64(0xA54FF53A5F1D36F1);
00127         ctx->state [4] = UL64(0x510E527FADE682D1);
00128         ctx->state [5] = UL64(0x9B05688C2B3E6C1F);
00129         ctx->state [6] = UL64(0x1F83D9ABFB41BD6B);
00130         ctx->state [7] = UL64(0x5BE0CD19137E2179);
00131     }
00132     else
00133     {
00134         /* SHA-384 */
00135         ctx->state [0] = UL64(0xCBBB9D5DC1059ED8);
00136         ctx->state [1] = UL64(0x629A292A367CD507);
00137         ctx->state [2] = UL64(0x9159015A3070DD17);
00138         ctx->state [3] = UL64(0x152FECD8F70E5939);
00139         ctx->state [4] = UL64(0x67332667FFC00B31);
00140         ctx->state [5] = UL64(0x8EB44A8768581511);
00141         ctx->state [6] = UL64(0xDB0C2E0D64F98FA7);
00142         ctx->state [7] = UL64(0x47B5481DBEFA4FA4);
00143     }
00144 
00145     ctx->is384  = is384;
00146 }
00147 
00148 #if !defined(MBEDTLS_SHA512_PROCESS_ALT)
00149 
00150 /*
00151  * Round constants
00152  */
00153 static const uint64_t K[80] =
00154 {
00155     UL64(0x428A2F98D728AE22),  UL64(0x7137449123EF65CD),
00156     UL64(0xB5C0FBCFEC4D3B2F),  UL64(0xE9B5DBA58189DBBC),
00157     UL64(0x3956C25BF348B538),  UL64(0x59F111F1B605D019),
00158     UL64(0x923F82A4AF194F9B),  UL64(0xAB1C5ED5DA6D8118),
00159     UL64(0xD807AA98A3030242),  UL64(0x12835B0145706FBE),
00160     UL64(0x243185BE4EE4B28C),  UL64(0x550C7DC3D5FFB4E2),
00161     UL64(0x72BE5D74F27B896F),  UL64(0x80DEB1FE3B1696B1),
00162     UL64(0x9BDC06A725C71235),  UL64(0xC19BF174CF692694),
00163     UL64(0xE49B69C19EF14AD2),  UL64(0xEFBE4786384F25E3),
00164     UL64(0x0FC19DC68B8CD5B5),  UL64(0x240CA1CC77AC9C65),
00165     UL64(0x2DE92C6F592B0275),  UL64(0x4A7484AA6EA6E483),
00166     UL64(0x5CB0A9DCBD41FBD4),  UL64(0x76F988DA831153B5),
00167     UL64(0x983E5152EE66DFAB),  UL64(0xA831C66D2DB43210),
00168     UL64(0xB00327C898FB213F),  UL64(0xBF597FC7BEEF0EE4),
00169     UL64(0xC6E00BF33DA88FC2),  UL64(0xD5A79147930AA725),
00170     UL64(0x06CA6351E003826F),  UL64(0x142929670A0E6E70),
00171     UL64(0x27B70A8546D22FFC),  UL64(0x2E1B21385C26C926),
00172     UL64(0x4D2C6DFC5AC42AED),  UL64(0x53380D139D95B3DF),
00173     UL64(0x650A73548BAF63DE),  UL64(0x766A0ABB3C77B2A8),
00174     UL64(0x81C2C92E47EDAEE6),  UL64(0x92722C851482353B),
00175     UL64(0xA2BFE8A14CF10364),  UL64(0xA81A664BBC423001),
00176     UL64(0xC24B8B70D0F89791),  UL64(0xC76C51A30654BE30),
00177     UL64(0xD192E819D6EF5218),  UL64(0xD69906245565A910),
00178     UL64(0xF40E35855771202A),  UL64(0x106AA07032BBD1B8),
00179     UL64(0x19A4C116B8D2D0C8),  UL64(0x1E376C085141AB53),
00180     UL64(0x2748774CDF8EEB99),  UL64(0x34B0BCB5E19B48A8),
00181     UL64(0x391C0CB3C5C95A63),  UL64(0x4ED8AA4AE3418ACB),
00182     UL64(0x5B9CCA4F7763E373),  UL64(0x682E6FF3D6B2B8A3),
00183     UL64(0x748F82EE5DEFB2FC),  UL64(0x78A5636F43172F60),
00184     UL64(0x84C87814A1F0AB72),  UL64(0x8CC702081A6439EC),
00185     UL64(0x90BEFFFA23631E28),  UL64(0xA4506CEBDE82BDE9),
00186     UL64(0xBEF9A3F7B2C67915),  UL64(0xC67178F2E372532B),
00187     UL64(0xCA273ECEEA26619C),  UL64(0xD186B8C721C0C207),
00188     UL64(0xEADA7DD6CDE0EB1E),  UL64(0xF57D4F7FEE6ED178),
00189     UL64(0x06F067AA72176FBA),  UL64(0x0A637DC5A2C898A6),
00190     UL64(0x113F9804BEF90DAE),  UL64(0x1B710B35131C471B),
00191     UL64(0x28DB77F523047D84),  UL64(0x32CAAB7B40C72493),
00192     UL64(0x3C9EBE0A15C9BEBC),  UL64(0x431D67C49C100D4C),
00193     UL64(0x4CC5D4BECB3E42B6),  UL64(0x597F299CFC657E2A),
00194     UL64(0x5FCB6FAB3AD6FAEC),  UL64(0x6C44198C4A475817)
00195 };
00196 
00197 void mbedtls_sha512_process( mbedtls_sha512_context *ctx, const unsigned char data[128] )
00198 {
00199     int i;
00200     uint64_t temp1, temp2, W[80];
00201     uint64_t A, B, C, D, E, F, G, H;
00202 
00203 #define  SHR(x,n) (x >> n)
00204 #define ROTR(x,n) (SHR(x,n) | (x << (64 - n)))
00205 
00206 #define S0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^  SHR(x, 7))
00207 #define S1(x) (ROTR(x,19) ^ ROTR(x,61) ^  SHR(x, 6))
00208 
00209 #define S2(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
00210 #define S3(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
00211 
00212 #define F0(x,y,z) ((x & y) | (z & (x | y)))
00213 #define F1(x,y,z) (z ^ (x & (y ^ z)))
00214 
00215 #define P(a,b,c,d,e,f,g,h,x,K)                  \
00216 {                                               \
00217     temp1 = h + S3(e) + F1(e,f,g) + K + x;      \
00218     temp2 = S2(a) + F0(a,b,c);                  \
00219     d += temp1; h = temp1 + temp2;              \
00220 }
00221 
00222     for( i = 0; i < 16; i++ )
00223     {
00224         GET_UINT64_BE( W[i], data, i << 3 );
00225     }
00226 
00227     for( ; i < 80; i++ )
00228     {
00229         W[i] = S1(W[i -  2]) + W[i -  7] +
00230                S0(W[i - 15]) + W[i - 16];
00231     }
00232 
00233     A = ctx->state [0];
00234     B = ctx->state [1];
00235     C = ctx->state [2];
00236     D = ctx->state [3];
00237     E = ctx->state [4];
00238     F = ctx->state [5];
00239     G = ctx->state [6];
00240     H = ctx->state [7];
00241     i = 0;
00242 
00243     do
00244     {
00245         P( A, B, C, D, E, F, G, H, W[i], K[i] ); i++;
00246         P( H, A, B, C, D, E, F, G, W[i], K[i] ); i++;
00247         P( G, H, A, B, C, D, E, F, W[i], K[i] ); i++;
00248         P( F, G, H, A, B, C, D, E, W[i], K[i] ); i++;
00249         P( E, F, G, H, A, B, C, D, W[i], K[i] ); i++;
00250         P( D, E, F, G, H, A, B, C, W[i], K[i] ); i++;
00251         P( C, D, E, F, G, H, A, B, W[i], K[i] ); i++;
00252         P( B, C, D, E, F, G, H, A, W[i], K[i] ); i++;
00253     }
00254     while( i < 80 );
00255 
00256     ctx->state [0] += A;
00257     ctx->state [1] += B;
00258     ctx->state [2] += C;
00259     ctx->state [3] += D;
00260     ctx->state [4] += E;
00261     ctx->state [5] += F;
00262     ctx->state [6] += G;
00263     ctx->state [7] += H;
00264 }
00265 #endif /* !MBEDTLS_SHA512_PROCESS_ALT */
00266 
00267 /*
00268  * SHA-512 process buffer
00269  */
00270 void mbedtls_sha512_update( mbedtls_sha512_context *ctx, const unsigned char *input,
00271                     size_t ilen )
00272 {
00273     size_t fill;
00274     unsigned int left;
00275 
00276     if( ilen == 0 )
00277         return;
00278 
00279     left = (unsigned int) (ctx->total [0] & 0x7F);
00280     fill = 128 - left;
00281 
00282     ctx->total [0] += (uint64_t) ilen;
00283 
00284     if( ctx->total [0] < (uint64_t) ilen )
00285         ctx->total [1]++;
00286 
00287     if( left && ilen >= fill )
00288     {
00289         memcpy( (void *) (ctx->buffer  + left), input, fill );
00290         mbedtls_sha512_process( ctx, ctx->buffer  );
00291         input += fill;
00292         ilen  -= fill;
00293         left = 0;
00294     }
00295 
00296     while( ilen >= 128 )
00297     {
00298         mbedtls_sha512_process( ctx, input );
00299         input += 128;
00300         ilen  -= 128;
00301     }
00302 
00303     if( ilen > 0 )
00304         memcpy( (void *) (ctx->buffer  + left), input, ilen );
00305 }
00306 
00307 static const unsigned char sha512_padding[128] =
00308 {
00309  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00310     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00311     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00312     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00313     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00314     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00315     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00316     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
00317 };
00318 
00319 /*
00320  * SHA-512 final digest
00321  */
00322 void mbedtls_sha512_finish( mbedtls_sha512_context *ctx, unsigned char output[64] )
00323 {
00324     size_t last, padn;
00325     uint64_t high, low;
00326     unsigned char msglen[16];
00327 
00328     high = ( ctx->total [0] >> 61 )
00329          | ( ctx->total [1] <<  3 );
00330     low  = ( ctx->total [0] <<  3 );
00331 
00332     PUT_UINT64_BE( high, msglen, 0 );
00333     PUT_UINT64_BE( low,  msglen, 8 );
00334 
00335     last = (size_t)( ctx->total [0] & 0x7F );
00336     padn = ( last < 112 ) ? ( 112 - last ) : ( 240 - last );
00337 
00338     mbedtls_sha512_update( ctx, sha512_padding, padn );
00339     mbedtls_sha512_update( ctx, msglen, 16 );
00340 
00341     PUT_UINT64_BE( ctx->state [0], output,  0 );
00342     PUT_UINT64_BE( ctx->state [1], output,  8 );
00343     PUT_UINT64_BE( ctx->state [2], output, 16 );
00344     PUT_UINT64_BE( ctx->state [3], output, 24 );
00345     PUT_UINT64_BE( ctx->state [4], output, 32 );
00346     PUT_UINT64_BE( ctx->state [5], output, 40 );
00347 
00348     if( ctx->is384  == 0 )
00349     {
00350         PUT_UINT64_BE( ctx->state [6], output, 48 );
00351         PUT_UINT64_BE( ctx->state [7], output, 56 );
00352     }
00353 }
00354 
00355 #endif /* !MBEDTLS_SHA512_ALT */
00356 
00357 /*
00358  * output = SHA-512( input buffer )
00359  */
00360 void mbedtls_sha512( const unsigned char *input, size_t ilen,
00361              unsigned char output[64], int is384 )
00362 {
00363     mbedtls_sha512_context ctx;
00364 
00365     mbedtls_sha512_init( &ctx );
00366     mbedtls_sha512_starts( &ctx, is384 );
00367     mbedtls_sha512_update( &ctx, input, ilen );
00368     mbedtls_sha512_finish( &ctx, output );
00369     mbedtls_sha512_free( &ctx );
00370 }
00371 
00372 #if defined(MBEDTLS_SELF_TEST)
00373 
00374 /*
00375  * FIPS-180-2 test vectors
00376  */
00377 static const unsigned char sha512_test_buf[3][113] =
00378 {
00379     { "abc" },
00380     { "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
00381       "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" },
00382     { "" }
00383 };
00384 
00385 static const int sha512_test_buflen[3] =
00386 {
00387     3, 112, 1000
00388 };
00389 
00390 static const unsigned char sha512_test_sum[6][64] =
00391 {
00392     /*
00393      * SHA-384 test vectors
00394      */
00395     { 0xCB, 0x00, 0x75, 0x3F, 0x45, 0xA3, 0x5E, 0x8B,
00396       0xB5, 0xA0, 0x3D, 0x69, 0x9A, 0xC6, 0x50, 0x07,
00397       0x27, 0x2C, 0x32, 0xAB, 0x0E, 0xDE, 0xD1, 0x63,
00398       0x1A, 0x8B, 0x60, 0x5A, 0x43, 0xFF, 0x5B, 0xED,
00399       0x80, 0x86, 0x07, 0x2B, 0xA1, 0xE7, 0xCC, 0x23,
00400       0x58, 0xBA, 0xEC, 0xA1, 0x34, 0xC8, 0x25, 0xA7 },
00401     { 0x09, 0x33, 0x0C, 0x33, 0xF7, 0x11, 0x47, 0xE8,
00402       0x3D, 0x19, 0x2F, 0xC7, 0x82, 0xCD, 0x1B, 0x47,
00403       0x53, 0x11, 0x1B, 0x17, 0x3B, 0x3B, 0x05, 0xD2,
00404       0x2F, 0xA0, 0x80, 0x86, 0xE3, 0xB0, 0xF7, 0x12,
00405       0xFC, 0xC7, 0xC7, 0x1A, 0x55, 0x7E, 0x2D, 0xB9,
00406       0x66, 0xC3, 0xE9, 0xFA, 0x91, 0x74, 0x60, 0x39 },
00407     { 0x9D, 0x0E, 0x18, 0x09, 0x71, 0x64, 0x74, 0xCB,
00408       0x08, 0x6E, 0x83, 0x4E, 0x31, 0x0A, 0x4A, 0x1C,
00409       0xED, 0x14, 0x9E, 0x9C, 0x00, 0xF2, 0x48, 0x52,
00410       0x79, 0x72, 0xCE, 0xC5, 0x70, 0x4C, 0x2A, 0x5B,
00411       0x07, 0xB8, 0xB3, 0xDC, 0x38, 0xEC, 0xC4, 0xEB,
00412       0xAE, 0x97, 0xDD, 0xD8, 0x7F, 0x3D, 0x89, 0x85 },
00413 
00414     /*
00415      * SHA-512 test vectors
00416      */
00417     { 0xDD, 0xAF, 0x35, 0xA1, 0x93, 0x61, 0x7A, 0xBA,
00418       0xCC, 0x41, 0x73, 0x49, 0xAE, 0x20, 0x41, 0x31,
00419       0x12, 0xE6, 0xFA, 0x4E, 0x89, 0xA9, 0x7E, 0xA2,
00420       0x0A, 0x9E, 0xEE, 0xE6, 0x4B, 0x55, 0xD3, 0x9A,
00421       0x21, 0x92, 0x99, 0x2A, 0x27, 0x4F, 0xC1, 0xA8,
00422       0x36, 0xBA, 0x3C, 0x23, 0xA3, 0xFE, 0xEB, 0xBD,
00423       0x45, 0x4D, 0x44, 0x23, 0x64, 0x3C, 0xE8, 0x0E,
00424       0x2A, 0x9A, 0xC9, 0x4F, 0xA5, 0x4C, 0xA4, 0x9F },
00425     { 0x8E, 0x95, 0x9B, 0x75, 0xDA, 0xE3, 0x13, 0xDA,
00426       0x8C, 0xF4, 0xF7, 0x28, 0x14, 0xFC, 0x14, 0x3F,
00427       0x8F, 0x77, 0x79, 0xC6, 0xEB, 0x9F, 0x7F, 0xA1,
00428       0x72, 0x99, 0xAE, 0xAD, 0xB6, 0x88, 0x90, 0x18,
00429       0x50, 0x1D, 0x28, 0x9E, 0x49, 0x00, 0xF7, 0xE4,
00430       0x33, 0x1B, 0x99, 0xDE, 0xC4, 0xB5, 0x43, 0x3A,
00431       0xC7, 0xD3, 0x29, 0xEE, 0xB6, 0xDD, 0x26, 0x54,
00432       0x5E, 0x96, 0xE5, 0x5B, 0x87, 0x4B, 0xE9, 0x09 },
00433     { 0xE7, 0x18, 0x48, 0x3D, 0x0C, 0xE7, 0x69, 0x64,
00434       0x4E, 0x2E, 0x42, 0xC7, 0xBC, 0x15, 0xB4, 0x63,
00435       0x8E, 0x1F, 0x98, 0xB1, 0x3B, 0x20, 0x44, 0x28,
00436       0x56, 0x32, 0xA8, 0x03, 0xAF, 0xA9, 0x73, 0xEB,
00437       0xDE, 0x0F, 0xF2, 0x44, 0x87, 0x7E, 0xA6, 0x0A,
00438       0x4C, 0xB0, 0x43, 0x2C, 0xE5, 0x77, 0xC3, 0x1B,
00439       0xEB, 0x00, 0x9C, 0x5C, 0x2C, 0x49, 0xAA, 0x2E,
00440       0x4E, 0xAD, 0xB2, 0x17, 0xAD, 0x8C, 0xC0, 0x9B }
00441 };
00442 
00443 /*
00444  * Checkup routine
00445  */
00446 int mbedtls_sha512_self_test( int verbose )
00447 {
00448     int i, j, k, buflen, ret = 0;
00449     unsigned char *buf;
00450     unsigned char sha512sum[64];
00451     mbedtls_sha512_context ctx;
00452 
00453     buf = mbedtls_calloc( 1024, sizeof(unsigned char) );
00454     if( NULL == buf )
00455     {
00456         if( verbose != 0 )
00457             mbedtls_printf( "Buffer allocation failed\n" );
00458 
00459         return( 1 );
00460     }
00461 
00462     mbedtls_sha512_init( &ctx );
00463 
00464     for( i = 0; i < 6; i++ )
00465     {
00466         j = i % 3;
00467         k = i < 3;
00468 
00469         if( verbose != 0 )
00470             mbedtls_printf( "  SHA-%d test #%d: ", 512 - k * 128, j + 1 );
00471 
00472         mbedtls_sha512_starts( &ctx, k );
00473 
00474         if( j == 2 )
00475         {
00476             memset( buf, 'a', buflen = 1000 );
00477 
00478             for( j = 0; j < 1000; j++ )
00479                 mbedtls_sha512_update( &ctx, buf, buflen );
00480         }
00481         else
00482             mbedtls_sha512_update( &ctx, sha512_test_buf[j],
00483                                  sha512_test_buflen[j] );
00484 
00485         mbedtls_sha512_finish( &ctx, sha512sum );
00486 
00487         if( memcmp( sha512sum, sha512_test_sum[i], 64 - k * 16 ) != 0 )
00488         {
00489             if( verbose != 0 )
00490                 mbedtls_printf( "failed\n" );
00491 
00492             ret = 1;
00493             goto exit;
00494         }
00495 
00496         if( verbose != 0 )
00497             mbedtls_printf( "passed\n" );
00498     }
00499 
00500     if( verbose != 0 )
00501         mbedtls_printf( "\n" );
00502 
00503 exit:
00504     mbedtls_sha512_free( &ctx );
00505     mbedtls_free( buf );
00506 
00507     return( ret );
00508 }
00509 
00510 #endif /* MBEDTLS_SELF_TEST */
00511 
00512 //#endif /* MBEDTLS_SHA512_C */