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