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