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