ripemd160.c

00001 /*
00002  *  RIPE MD-160 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 /*
00023  *  The RIPEMD-160 algorithm was designed by RIPE in 1996
00024  *  http://homes.esat.kuleuven.be/~bosselae/mbedtls_ripemd160.html
00025  *  http://ehash.iaik.tugraz.at/wiki/RIPEMD-160
00026  */
00027 
00028 #if !defined(MBEDTLS_CONFIG_FILE)
00029 #include "mbedtls/config.h"
00030 #else
00031 #include MBEDTLS_CONFIG_FILE
00032 #endif
00033 
00034 #if defined(MBEDTLS_RIPEMD160_C)
00035 
00036 #include "mbedtls/ripemd160.h"
00037 
00038 #include <string.h>
00039 
00040 #if defined(MBEDTLS_SELF_TEST)
00041 #if defined(MBEDTLS_PLATFORM_C)
00042 #include "mbedtls/platform.h"
00043 #else
00044 #include <stdio.h>
00045 #define mbedtls_printf printf
00046 #endif /* MBEDTLS_PLATFORM_C */
00047 #endif /* MBEDTLS_SELF_TEST */
00048 
00049 #if !defined(MBEDTLS_RIPEMD160_ALT)
00050 
00051 /*
00052  * 32-bit integer manipulation macros (little endian)
00053  */
00054 #ifndef GET_UINT32_LE
00055 #define GET_UINT32_LE(n,b,i)                            \
00056 {                                                       \
00057     (n) = ( (uint32_t) (b)[(i)    ]       )             \
00058         | ( (uint32_t) (b)[(i) + 1] <<  8 )             \
00059         | ( (uint32_t) (b)[(i) + 2] << 16 )             \
00060         | ( (uint32_t) (b)[(i) + 3] << 24 );            \
00061 }
00062 #endif
00063 
00064 #ifndef PUT_UINT32_LE
00065 #define PUT_UINT32_LE(n,b,i)                                    \
00066 {                                                               \
00067     (b)[(i)    ] = (unsigned char) ( ( (n)       ) & 0xFF );    \
00068     (b)[(i) + 1] = (unsigned char) ( ( (n) >>  8 ) & 0xFF );    \
00069     (b)[(i) + 2] = (unsigned char) ( ( (n) >> 16 ) & 0xFF );    \
00070     (b)[(i) + 3] = (unsigned char) ( ( (n) >> 24 ) & 0xFF );    \
00071 }
00072 #endif
00073 
00074 /* Implementation that should never be optimized out by the compiler */
00075 static void mbedtls_zeroize( void *v, size_t n ) {
00076     volatile unsigned char *p = v; while( n-- ) *p++ = 0;
00077 }
00078 
00079 void mbedtls_ripemd160_init( mbedtls_ripemd160_context *ctx )
00080 {
00081     memset( ctx, 0, sizeof( mbedtls_ripemd160_context ) );
00082 }
00083 
00084 void mbedtls_ripemd160_free( mbedtls_ripemd160_context *ctx )
00085 {
00086     if( ctx == NULL )
00087         return;
00088 
00089     mbedtls_zeroize( ctx, sizeof( mbedtls_ripemd160_context ) );
00090 }
00091 
00092 void mbedtls_ripemd160_clone( mbedtls_ripemd160_context *dst,
00093                         const mbedtls_ripemd160_context *src )
00094 {
00095     *dst = *src;
00096 }
00097 
00098 /*
00099  * RIPEMD-160 context setup
00100  */
00101 int mbedtls_ripemd160_starts_ret( mbedtls_ripemd160_context *ctx )
00102 {
00103     ctx->total [0] = 0;
00104     ctx->total [1] = 0;
00105 
00106     ctx->state [0] = 0x67452301;
00107     ctx->state [1] = 0xEFCDAB89;
00108     ctx->state [2] = 0x98BADCFE;
00109     ctx->state [3] = 0x10325476;
00110     ctx->state [4] = 0xC3D2E1F0;
00111 
00112     return( 0 );
00113 }
00114 
00115 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00116 void mbedtls_ripemd160_starts( mbedtls_ripemd160_context *ctx )
00117 {
00118     mbedtls_ripemd160_starts_ret( ctx );
00119 }
00120 #endif
00121 
00122 #if !defined(MBEDTLS_RIPEMD160_PROCESS_ALT)
00123 /*
00124  * Process one block
00125  */
00126 int mbedtls_internal_ripemd160_process( mbedtls_ripemd160_context *ctx,
00127                                         const unsigned char data[64] )
00128 {
00129     uint32_t A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, X[16];
00130 
00131     GET_UINT32_LE( X[ 0], data,  0 );
00132     GET_UINT32_LE( X[ 1], data,  4 );
00133     GET_UINT32_LE( X[ 2], data,  8 );
00134     GET_UINT32_LE( X[ 3], data, 12 );
00135     GET_UINT32_LE( X[ 4], data, 16 );
00136     GET_UINT32_LE( X[ 5], data, 20 );
00137     GET_UINT32_LE( X[ 6], data, 24 );
00138     GET_UINT32_LE( X[ 7], data, 28 );
00139     GET_UINT32_LE( X[ 8], data, 32 );
00140     GET_UINT32_LE( X[ 9], data, 36 );
00141     GET_UINT32_LE( X[10], data, 40 );
00142     GET_UINT32_LE( X[11], data, 44 );
00143     GET_UINT32_LE( X[12], data, 48 );
00144     GET_UINT32_LE( X[13], data, 52 );
00145     GET_UINT32_LE( X[14], data, 56 );
00146     GET_UINT32_LE( X[15], data, 60 );
00147 
00148     A = Ap = ctx->state [0];
00149     B = Bp = ctx->state [1];
00150     C = Cp = ctx->state [2];
00151     D = Dp = ctx->state [3];
00152     E = Ep = ctx->state [4];
00153 
00154 #define F1( x, y, z )   ( x ^ y ^ z )
00155 #define F2( x, y, z )   ( ( x & y ) | ( ~x & z ) )
00156 #define F3( x, y, z )   ( ( x | ~y ) ^ z )
00157 #define F4( x, y, z )   ( ( x & z ) | ( y & ~z ) )
00158 #define F5( x, y, z )   ( x ^ ( y | ~z ) )
00159 
00160 #define S( x, n ) ( ( x << n ) | ( x >> (32 - n) ) )
00161 
00162 #define P( a, b, c, d, e, r, s, f, k )      \
00163     a += f( b, c, d ) + X[r] + k;           \
00164     a = S( a, s ) + e;                      \
00165     c = S( c, 10 );
00166 
00167 #define P2( a, b, c, d, e, r, s, rp, sp )   \
00168     P( a, b, c, d, e, r, s, F, K );         \
00169     P( a ## p, b ## p, c ## p, d ## p, e ## p, rp, sp, Fp, Kp );
00170 
00171 #define F   F1
00172 #define K   0x00000000
00173 #define Fp  F5
00174 #define Kp  0x50A28BE6
00175     P2( A, B, C, D, E,  0, 11,  5,  8 );
00176     P2( E, A, B, C, D,  1, 14, 14,  9 );
00177     P2( D, E, A, B, C,  2, 15,  7,  9 );
00178     P2( C, D, E, A, B,  3, 12,  0, 11 );
00179     P2( B, C, D, E, A,  4,  5,  9, 13 );
00180     P2( A, B, C, D, E,  5,  8,  2, 15 );
00181     P2( E, A, B, C, D,  6,  7, 11, 15 );
00182     P2( D, E, A, B, C,  7,  9,  4,  5 );
00183     P2( C, D, E, A, B,  8, 11, 13,  7 );
00184     P2( B, C, D, E, A,  9, 13,  6,  7 );
00185     P2( A, B, C, D, E, 10, 14, 15,  8 );
00186     P2( E, A, B, C, D, 11, 15,  8, 11 );
00187     P2( D, E, A, B, C, 12,  6,  1, 14 );
00188     P2( C, D, E, A, B, 13,  7, 10, 14 );
00189     P2( B, C, D, E, A, 14,  9,  3, 12 );
00190     P2( A, B, C, D, E, 15,  8, 12,  6 );
00191 #undef F
00192 #undef K
00193 #undef Fp
00194 #undef Kp
00195 
00196 #define F   F2
00197 #define K   0x5A827999
00198 #define Fp  F4
00199 #define Kp  0x5C4DD124
00200     P2( E, A, B, C, D,  7,  7,  6,  9 );
00201     P2( D, E, A, B, C,  4,  6, 11, 13 );
00202     P2( C, D, E, A, B, 13,  8,  3, 15 );
00203     P2( B, C, D, E, A,  1, 13,  7,  7 );
00204     P2( A, B, C, D, E, 10, 11,  0, 12 );
00205     P2( E, A, B, C, D,  6,  9, 13,  8 );
00206     P2( D, E, A, B, C, 15,  7,  5,  9 );
00207     P2( C, D, E, A, B,  3, 15, 10, 11 );
00208     P2( B, C, D, E, A, 12,  7, 14,  7 );
00209     P2( A, B, C, D, E,  0, 12, 15,  7 );
00210     P2( E, A, B, C, D,  9, 15,  8, 12 );
00211     P2( D, E, A, B, C,  5,  9, 12,  7 );
00212     P2( C, D, E, A, B,  2, 11,  4,  6 );
00213     P2( B, C, D, E, A, 14,  7,  9, 15 );
00214     P2( A, B, C, D, E, 11, 13,  1, 13 );
00215     P2( E, A, B, C, D,  8, 12,  2, 11 );
00216 #undef F
00217 #undef K
00218 #undef Fp
00219 #undef Kp
00220 
00221 #define F   F3
00222 #define K   0x6ED9EBA1
00223 #define Fp  F3
00224 #define Kp  0x6D703EF3
00225     P2( D, E, A, B, C,  3, 11, 15,  9 );
00226     P2( C, D, E, A, B, 10, 13,  5,  7 );
00227     P2( B, C, D, E, A, 14,  6,  1, 15 );
00228     P2( A, B, C, D, E,  4,  7,  3, 11 );
00229     P2( E, A, B, C, D,  9, 14,  7,  8 );
00230     P2( D, E, A, B, C, 15,  9, 14,  6 );
00231     P2( C, D, E, A, B,  8, 13,  6,  6 );
00232     P2( B, C, D, E, A,  1, 15,  9, 14 );
00233     P2( A, B, C, D, E,  2, 14, 11, 12 );
00234     P2( E, A, B, C, D,  7,  8,  8, 13 );
00235     P2( D, E, A, B, C,  0, 13, 12,  5 );
00236     P2( C, D, E, A, B,  6,  6,  2, 14 );
00237     P2( B, C, D, E, A, 13,  5, 10, 13 );
00238     P2( A, B, C, D, E, 11, 12,  0, 13 );
00239     P2( E, A, B, C, D,  5,  7,  4,  7 );
00240     P2( D, E, A, B, C, 12,  5, 13,  5 );
00241 #undef F
00242 #undef K
00243 #undef Fp
00244 #undef Kp
00245 
00246 #define F   F4
00247 #define K   0x8F1BBCDC
00248 #define Fp  F2
00249 #define Kp  0x7A6D76E9
00250     P2( C, D, E, A, B,  1, 11,  8, 15 );
00251     P2( B, C, D, E, A,  9, 12,  6,  5 );
00252     P2( A, B, C, D, E, 11, 14,  4,  8 );
00253     P2( E, A, B, C, D, 10, 15,  1, 11 );
00254     P2( D, E, A, B, C,  0, 14,  3, 14 );
00255     P2( C, D, E, A, B,  8, 15, 11, 14 );
00256     P2( B, C, D, E, A, 12,  9, 15,  6 );
00257     P2( A, B, C, D, E,  4,  8,  0, 14 );
00258     P2( E, A, B, C, D, 13,  9,  5,  6 );
00259     P2( D, E, A, B, C,  3, 14, 12,  9 );
00260     P2( C, D, E, A, B,  7,  5,  2, 12 );
00261     P2( B, C, D, E, A, 15,  6, 13,  9 );
00262     P2( A, B, C, D, E, 14,  8,  9, 12 );
00263     P2( E, A, B, C, D,  5,  6,  7,  5 );
00264     P2( D, E, A, B, C,  6,  5, 10, 15 );
00265     P2( C, D, E, A, B,  2, 12, 14,  8 );
00266 #undef F
00267 #undef K
00268 #undef Fp
00269 #undef Kp
00270 
00271 #define F   F5
00272 #define K   0xA953FD4E
00273 #define Fp  F1
00274 #define Kp  0x00000000
00275     P2( B, C, D, E, A,  4,  9, 12,  8 );
00276     P2( A, B, C, D, E,  0, 15, 15,  5 );
00277     P2( E, A, B, C, D,  5,  5, 10, 12 );
00278     P2( D, E, A, B, C,  9, 11,  4,  9 );
00279     P2( C, D, E, A, B,  7,  6,  1, 12 );
00280     P2( B, C, D, E, A, 12,  8,  5,  5 );
00281     P2( A, B, C, D, E,  2, 13,  8, 14 );
00282     P2( E, A, B, C, D, 10, 12,  7,  6 );
00283     P2( D, E, A, B, C, 14,  5,  6,  8 );
00284     P2( C, D, E, A, B,  1, 12,  2, 13 );
00285     P2( B, C, D, E, A,  3, 13, 13,  6 );
00286     P2( A, B, C, D, E,  8, 14, 14,  5 );
00287     P2( E, A, B, C, D, 11, 11,  0, 15 );
00288     P2( D, E, A, B, C,  6,  8,  3, 13 );
00289     P2( C, D, E, A, B, 15,  5,  9, 11 );
00290     P2( B, C, D, E, A, 13,  6, 11, 11 );
00291 #undef F
00292 #undef K
00293 #undef Fp
00294 #undef Kp
00295 
00296     C             = ctx->state [1] + C + Dp;
00297     ctx->state [1] = ctx->state [2] + D + Ep;
00298     ctx->state [2] = ctx->state [3] + E + Ap;
00299     ctx->state [3] = ctx->state [4] + A + Bp;
00300     ctx->state [4] = ctx->state [0] + B + Cp;
00301     ctx->state [0] = C;
00302 
00303     return( 0 );
00304 }
00305 
00306 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00307 void mbedtls_ripemd160_process( mbedtls_ripemd160_context *ctx,
00308                                 const unsigned char data[64] )
00309 {
00310     mbedtls_internal_ripemd160_process( ctx, data );
00311 }
00312 #endif
00313 #endif /* !MBEDTLS_RIPEMD160_PROCESS_ALT */
00314 
00315 /*
00316  * RIPEMD-160 process buffer
00317  */
00318 int mbedtls_ripemd160_update_ret( mbedtls_ripemd160_context *ctx,
00319                                   const unsigned char *input,
00320                                   size_t ilen )
00321 {
00322     int ret;
00323     size_t fill;
00324     uint32_t left;
00325 
00326     if( ilen == 0 )
00327         return( 0 );
00328 
00329     left = ctx->total [0] & 0x3F;
00330     fill = 64 - left;
00331 
00332     ctx->total [0] += (uint32_t) ilen;
00333     ctx->total [0] &= 0xFFFFFFFF;
00334 
00335     if( ctx->total [0] < (uint32_t) ilen )
00336         ctx->total [1]++;
00337 
00338     if( left && ilen >= fill )
00339     {
00340         memcpy( (void *) (ctx->buffer  + left), input, fill );
00341 
00342         if( ( ret = mbedtls_internal_ripemd160_process( ctx, ctx->buffer  ) ) != 0 )
00343             return( ret );
00344 
00345         input += fill;
00346         ilen  -= fill;
00347         left = 0;
00348     }
00349 
00350     while( ilen >= 64 )
00351     {
00352         if( ( ret = mbedtls_internal_ripemd160_process( ctx, input ) ) != 0 )
00353             return( ret );
00354 
00355         input += 64;
00356         ilen  -= 64;
00357     }
00358 
00359     if( ilen > 0 )
00360     {
00361         memcpy( (void *) (ctx->buffer  + left), input, ilen );
00362     }
00363 
00364     return( 0 );
00365 }
00366 
00367 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00368 void mbedtls_ripemd160_update( mbedtls_ripemd160_context *ctx,
00369                                const unsigned char *input,
00370                                size_t ilen )
00371 {
00372     mbedtls_ripemd160_update_ret( ctx, input, ilen );
00373 }
00374 #endif
00375 
00376 static const unsigned char ripemd160_padding[64] =
00377 {
00378  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00379     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00380     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00381     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
00382 };
00383 
00384 /*
00385  * RIPEMD-160 final digest
00386  */
00387 int mbedtls_ripemd160_finish_ret( mbedtls_ripemd160_context *ctx,
00388                                   unsigned char output[20] )
00389 {
00390     int ret;
00391     uint32_t last, padn;
00392     uint32_t high, low;
00393     unsigned char msglen[8];
00394 
00395     high = ( ctx->total [0] >> 29 )
00396          | ( ctx->total [1] <<  3 );
00397     low  = ( ctx->total [0] <<  3 );
00398 
00399     PUT_UINT32_LE( low,  msglen, 0 );
00400     PUT_UINT32_LE( high, msglen, 4 );
00401 
00402     last = ctx->total [0] & 0x3F;
00403     padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
00404 
00405     ret = mbedtls_ripemd160_update_ret( ctx, ripemd160_padding, padn );
00406     if( ret != 0 )
00407         return( ret );
00408 
00409     ret = mbedtls_ripemd160_update_ret( ctx, msglen, 8 );
00410     if( ret != 0 )
00411         return( ret );
00412 
00413     PUT_UINT32_LE( ctx->state [0], output,  0 );
00414     PUT_UINT32_LE( ctx->state [1], output,  4 );
00415     PUT_UINT32_LE( ctx->state [2], output,  8 );
00416     PUT_UINT32_LE( ctx->state [3], output, 12 );
00417     PUT_UINT32_LE( ctx->state [4], output, 16 );
00418 
00419     return( 0 );
00420 }
00421 
00422 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00423 void mbedtls_ripemd160_finish( mbedtls_ripemd160_context *ctx,
00424                                unsigned char output[20] )
00425 {
00426     mbedtls_ripemd160_finish_ret( ctx, output );
00427 }
00428 #endif
00429 
00430 #endif /* ! MBEDTLS_RIPEMD160_ALT */
00431 
00432 /*
00433  * output = RIPEMD-160( input buffer )
00434  */
00435 int mbedtls_ripemd160_ret( const unsigned char *input,
00436                            size_t ilen,
00437                            unsigned char output[20] )
00438 {
00439     int ret;
00440     mbedtls_ripemd160_context ctx;
00441 
00442     mbedtls_ripemd160_init( &ctx );
00443 
00444     if( ( ret = mbedtls_ripemd160_starts_ret( &ctx ) ) != 0 )
00445         goto exit;
00446 
00447     if( ( ret = mbedtls_ripemd160_update_ret( &ctx, input, ilen ) ) != 0 )
00448         goto exit;
00449 
00450     if( ( ret = mbedtls_ripemd160_finish_ret( &ctx, output ) ) != 0 )
00451         goto exit;
00452 
00453 exit:
00454     mbedtls_ripemd160_free( &ctx );
00455 
00456     return( ret );
00457 }
00458 
00459 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
00460 void mbedtls_ripemd160( const unsigned char *input,
00461                         size_t ilen,
00462                         unsigned char output[20] )
00463 {
00464     mbedtls_ripemd160_ret( input, ilen, output );
00465 }
00466 #endif
00467 
00468 #if defined(MBEDTLS_SELF_TEST)
00469 /*
00470  * Test vectors from the RIPEMD-160 paper and
00471  * http://homes.esat.kuleuven.be/~bosselae/mbedtls_ripemd160.html#HMAC
00472  */
00473 #define TESTS   8
00474 static const unsigned char ripemd160_test_str[TESTS][81] =
00475 {
00476     { "" },
00477     { "a" },
00478     { "abc" },
00479     { "message digest" },
00480     { "abcdefghijklmnopqrstuvwxyz" },
00481     { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
00482     { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" },
00483     { "12345678901234567890123456789012345678901234567890123456789012"
00484       "345678901234567890" },
00485 };
00486 
00487 static const size_t ripemd160_test_strlen[TESTS] =
00488 {
00489     0, 1, 3, 14, 26, 56, 62, 80
00490 };
00491 
00492 static const unsigned char ripemd160_test_md[TESTS][20] =
00493 {
00494     { 0x9c, 0x11, 0x85, 0xa5, 0xc5, 0xe9, 0xfc, 0x54, 0x61, 0x28,
00495       0x08, 0x97, 0x7e, 0xe8, 0xf5, 0x48, 0xb2, 0x25, 0x8d, 0x31 },
00496     { 0x0b, 0xdc, 0x9d, 0x2d, 0x25, 0x6b, 0x3e, 0xe9, 0xda, 0xae,
00497       0x34, 0x7b, 0xe6, 0xf4, 0xdc, 0x83, 0x5a, 0x46, 0x7f, 0xfe },
00498     { 0x8e, 0xb2, 0x08, 0xf7, 0xe0, 0x5d, 0x98, 0x7a, 0x9b, 0x04,
00499       0x4a, 0x8e, 0x98, 0xc6, 0xb0, 0x87, 0xf1, 0x5a, 0x0b, 0xfc },
00500     { 0x5d, 0x06, 0x89, 0xef, 0x49, 0xd2, 0xfa, 0xe5, 0x72, 0xb8,
00501       0x81, 0xb1, 0x23, 0xa8, 0x5f, 0xfa, 0x21, 0x59, 0x5f, 0x36 },
00502     { 0xf7, 0x1c, 0x27, 0x10, 0x9c, 0x69, 0x2c, 0x1b, 0x56, 0xbb,
00503       0xdc, 0xeb, 0x5b, 0x9d, 0x28, 0x65, 0xb3, 0x70, 0x8d, 0xbc },
00504     { 0x12, 0xa0, 0x53, 0x38, 0x4a, 0x9c, 0x0c, 0x88, 0xe4, 0x05,
00505       0xa0, 0x6c, 0x27, 0xdc, 0xf4, 0x9a, 0xda, 0x62, 0xeb, 0x2b },
00506     { 0xb0, 0xe2, 0x0b, 0x6e, 0x31, 0x16, 0x64, 0x02, 0x86, 0xed,
00507       0x3a, 0x87, 0xa5, 0x71, 0x30, 0x79, 0xb2, 0x1f, 0x51, 0x89 },
00508     { 0x9b, 0x75, 0x2e, 0x45, 0x57, 0x3d, 0x4b, 0x39, 0xf4, 0xdb,
00509       0xd3, 0x32, 0x3c, 0xab, 0x82, 0xbf, 0x63, 0x32, 0x6b, 0xfb },
00510 };
00511 
00512 /*
00513  * Checkup routine
00514  */
00515 int mbedtls_ripemd160_self_test( int verbose )
00516 {
00517     int i, ret = 0;
00518     unsigned char output[20];
00519 
00520     memset( output, 0, sizeof output );
00521 
00522     for( i = 0; i < TESTS; i++ )
00523     {
00524         if( verbose != 0 )
00525             mbedtls_printf( "  RIPEMD-160 test #%d: ", i + 1 );
00526 
00527         ret = mbedtls_ripemd160_ret( ripemd160_test_str[i],
00528                                      ripemd160_test_strlen[i], output );
00529         if( ret != 0 )
00530             goto fail;
00531 
00532         if( memcmp( output, ripemd160_test_md[i], 20 ) != 0 )
00533         {
00534             ret = 1;
00535             goto fail;
00536         }
00537 
00538         if( verbose != 0 )
00539             mbedtls_printf( "passed\n" );
00540     }
00541 
00542     if( verbose != 0 )
00543         mbedtls_printf( "\n" );
00544 
00545     return( 0 );
00546 
00547 fail:
00548     if( verbose != 0 )
00549         mbedtls_printf( "failed\n" );
00550 
00551     return( ret );
00552 }
00553 
00554 #endif /* MBEDTLS_SELF_TEST */
00555 
00556 #endif /* MBEDTLS_RIPEMD160_C */