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