1 // SPDX-License-Identifier: Apache-2.0 2 /* 3 * RIPE MD-160 implementation 4 * 5 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); you may 8 * not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 * This file is part of mbed TLS (https://tls.mbed.org) 20 */ 21 22 /* 23 * The RIPEMD-160 algorithm was designed by RIPE in 1996 24 * http://homes.esat.kuleuven.be/~bosselae/mbedtls_ripemd160.html 25 * http://ehash.iaik.tugraz.at/wiki/RIPEMD-160 26 */ 27 28 #if !defined(MBEDTLS_CONFIG_FILE) 29 #include "mbedtls/config.h" 30 #else 31 #include MBEDTLS_CONFIG_FILE 32 #endif 33 34 #if defined(MBEDTLS_RIPEMD160_C) 35 36 #include "mbedtls/ripemd160.h" 37 #include "mbedtls/platform_util.h" 38 #include "mbedtls/error.h" 39 40 #include <string.h> 41 42 #if defined(MBEDTLS_SELF_TEST) 43 #if defined(MBEDTLS_PLATFORM_C) 44 #include "mbedtls/platform.h" 45 #else 46 #include <stdio.h> 47 #define mbedtls_printf printf 48 #endif /* MBEDTLS_PLATFORM_C */ 49 #endif /* MBEDTLS_SELF_TEST */ 50 51 #if !defined(MBEDTLS_RIPEMD160_ALT) 52 53 /* 54 * 32-bit integer manipulation macros (little endian) 55 */ 56 #ifndef GET_UINT32_LE 57 #define GET_UINT32_LE(n,b,i) \ 58 { \ 59 (n) = ( (uint32_t) (b)[(i) ] ) \ 60 | ( (uint32_t) (b)[(i) + 1] << 8 ) \ 61 | ( (uint32_t) (b)[(i) + 2] << 16 ) \ 62 | ( (uint32_t) (b)[(i) + 3] << 24 ); \ 63 } 64 #endif 65 66 #ifndef PUT_UINT32_LE 67 #define PUT_UINT32_LE(n,b,i) \ 68 { \ 69 (b)[(i) ] = (unsigned char) ( ( (n) ) & 0xFF ); \ 70 (b)[(i) + 1] = (unsigned char) ( ( (n) >> 8 ) & 0xFF ); \ 71 (b)[(i) + 2] = (unsigned char) ( ( (n) >> 16 ) & 0xFF ); \ 72 (b)[(i) + 3] = (unsigned char) ( ( (n) >> 24 ) & 0xFF ); \ 73 } 74 #endif 75 76 void mbedtls_ripemd160_init( mbedtls_ripemd160_context *ctx ) 77 { 78 memset( ctx, 0, sizeof( mbedtls_ripemd160_context ) ); 79 } 80 81 void mbedtls_ripemd160_free( mbedtls_ripemd160_context *ctx ) 82 { 83 if( ctx == NULL ) 84 return; 85 86 mbedtls_platform_zeroize( ctx, sizeof( mbedtls_ripemd160_context ) ); 87 } 88 89 void mbedtls_ripemd160_clone( mbedtls_ripemd160_context *dst, 90 const mbedtls_ripemd160_context *src ) 91 { 92 *dst = *src; 93 } 94 95 /* 96 * RIPEMD-160 context setup 97 */ 98 int mbedtls_ripemd160_starts_ret( mbedtls_ripemd160_context *ctx ) 99 { 100 ctx->total[0] = 0; 101 ctx->total[1] = 0; 102 103 ctx->state[0] = 0x67452301; 104 ctx->state[1] = 0xEFCDAB89; 105 ctx->state[2] = 0x98BADCFE; 106 ctx->state[3] = 0x10325476; 107 ctx->state[4] = 0xC3D2E1F0; 108 109 return( 0 ); 110 } 111 112 #if !defined(MBEDTLS_DEPRECATED_REMOVED) 113 void mbedtls_ripemd160_starts( mbedtls_ripemd160_context *ctx ) 114 { 115 mbedtls_ripemd160_starts_ret( ctx ); 116 } 117 #endif 118 119 #if !defined(MBEDTLS_RIPEMD160_PROCESS_ALT) 120 /* 121 * Process one block 122 */ 123 int mbedtls_internal_ripemd160_process( mbedtls_ripemd160_context *ctx, 124 const unsigned char data[64] ) 125 { 126 uint32_t A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, X[16]; 127 128 GET_UINT32_LE( X[ 0], data, 0 ); 129 GET_UINT32_LE( X[ 1], data, 4 ); 130 GET_UINT32_LE( X[ 2], data, 8 ); 131 GET_UINT32_LE( X[ 3], data, 12 ); 132 GET_UINT32_LE( X[ 4], data, 16 ); 133 GET_UINT32_LE( X[ 5], data, 20 ); 134 GET_UINT32_LE( X[ 6], data, 24 ); 135 GET_UINT32_LE( X[ 7], data, 28 ); 136 GET_UINT32_LE( X[ 8], data, 32 ); 137 GET_UINT32_LE( X[ 9], data, 36 ); 138 GET_UINT32_LE( X[10], data, 40 ); 139 GET_UINT32_LE( X[11], data, 44 ); 140 GET_UINT32_LE( X[12], data, 48 ); 141 GET_UINT32_LE( X[13], data, 52 ); 142 GET_UINT32_LE( X[14], data, 56 ); 143 GET_UINT32_LE( X[15], data, 60 ); 144 145 A = Ap = ctx->state[0]; 146 B = Bp = ctx->state[1]; 147 C = Cp = ctx->state[2]; 148 D = Dp = ctx->state[3]; 149 E = Ep = ctx->state[4]; 150 151 #define F1( x, y, z ) ( (x) ^ (y) ^ (z) ) 152 #define F2( x, y, z ) ( ( (x) & (y) ) | ( ~(x) & (z) ) ) 153 #define F3( x, y, z ) ( ( (x) | ~(y) ) ^ (z) ) 154 #define F4( x, y, z ) ( ( (x) & (z) ) | ( (y) & ~(z) ) ) 155 #define F5( x, y, z ) ( (x) ^ ( (y) | ~(z) ) ) 156 157 #define S( x, n ) ( ( (x) << (n) ) | ( (x) >> (32 - (n)) ) ) 158 159 #define P( a, b, c, d, e, r, s, f, k ) \ 160 do \ 161 { \ 162 (a) += f( (b), (c), (d) ) + X[r] + (k); \ 163 (a) = S( (a), (s) ) + (e); \ 164 (c) = S( (c), 10 ); \ 165 } while( 0 ) 166 167 #define P2( a, b, c, d, e, r, s, rp, sp ) \ 168 do \ 169 { \ 170 P( (a), (b), (c), (d), (e), (r), (s), F, K ); \ 171 P( a ## p, b ## p, c ## p, d ## p, e ## p, \ 172 (rp), (sp), Fp, Kp ); \ 173 } while( 0 ) 174 175 #define F F1 176 #define K 0x00000000 177 #define Fp F5 178 #define Kp 0x50A28BE6 179 P2( A, B, C, D, E, 0, 11, 5, 8 ); 180 P2( E, A, B, C, D, 1, 14, 14, 9 ); 181 P2( D, E, A, B, C, 2, 15, 7, 9 ); 182 P2( C, D, E, A, B, 3, 12, 0, 11 ); 183 P2( B, C, D, E, A, 4, 5, 9, 13 ); 184 P2( A, B, C, D, E, 5, 8, 2, 15 ); 185 P2( E, A, B, C, D, 6, 7, 11, 15 ); 186 P2( D, E, A, B, C, 7, 9, 4, 5 ); 187 P2( C, D, E, A, B, 8, 11, 13, 7 ); 188 P2( B, C, D, E, A, 9, 13, 6, 7 ); 189 P2( A, B, C, D, E, 10, 14, 15, 8 ); 190 P2( E, A, B, C, D, 11, 15, 8, 11 ); 191 P2( D, E, A, B, C, 12, 6, 1, 14 ); 192 P2( C, D, E, A, B, 13, 7, 10, 14 ); 193 P2( B, C, D, E, A, 14, 9, 3, 12 ); 194 P2( A, B, C, D, E, 15, 8, 12, 6 ); 195 #undef F 196 #undef K 197 #undef Fp 198 #undef Kp 199 200 #define F F2 201 #define K 0x5A827999 202 #define Fp F4 203 #define Kp 0x5C4DD124 204 P2( E, A, B, C, D, 7, 7, 6, 9 ); 205 P2( D, E, A, B, C, 4, 6, 11, 13 ); 206 P2( C, D, E, A, B, 13, 8, 3, 15 ); 207 P2( B, C, D, E, A, 1, 13, 7, 7 ); 208 P2( A, B, C, D, E, 10, 11, 0, 12 ); 209 P2( E, A, B, C, D, 6, 9, 13, 8 ); 210 P2( D, E, A, B, C, 15, 7, 5, 9 ); 211 P2( C, D, E, A, B, 3, 15, 10, 11 ); 212 P2( B, C, D, E, A, 12, 7, 14, 7 ); 213 P2( A, B, C, D, E, 0, 12, 15, 7 ); 214 P2( E, A, B, C, D, 9, 15, 8, 12 ); 215 P2( D, E, A, B, C, 5, 9, 12, 7 ); 216 P2( C, D, E, A, B, 2, 11, 4, 6 ); 217 P2( B, C, D, E, A, 14, 7, 9, 15 ); 218 P2( A, B, C, D, E, 11, 13, 1, 13 ); 219 P2( E, A, B, C, D, 8, 12, 2, 11 ); 220 #undef F 221 #undef K 222 #undef Fp 223 #undef Kp 224 225 #define F F3 226 #define K 0x6ED9EBA1 227 #define Fp F3 228 #define Kp 0x6D703EF3 229 P2( D, E, A, B, C, 3, 11, 15, 9 ); 230 P2( C, D, E, A, B, 10, 13, 5, 7 ); 231 P2( B, C, D, E, A, 14, 6, 1, 15 ); 232 P2( A, B, C, D, E, 4, 7, 3, 11 ); 233 P2( E, A, B, C, D, 9, 14, 7, 8 ); 234 P2( D, E, A, B, C, 15, 9, 14, 6 ); 235 P2( C, D, E, A, B, 8, 13, 6, 6 ); 236 P2( B, C, D, E, A, 1, 15, 9, 14 ); 237 P2( A, B, C, D, E, 2, 14, 11, 12 ); 238 P2( E, A, B, C, D, 7, 8, 8, 13 ); 239 P2( D, E, A, B, C, 0, 13, 12, 5 ); 240 P2( C, D, E, A, B, 6, 6, 2, 14 ); 241 P2( B, C, D, E, A, 13, 5, 10, 13 ); 242 P2( A, B, C, D, E, 11, 12, 0, 13 ); 243 P2( E, A, B, C, D, 5, 7, 4, 7 ); 244 P2( D, E, A, B, C, 12, 5, 13, 5 ); 245 #undef F 246 #undef K 247 #undef Fp 248 #undef Kp 249 250 #define F F4 251 #define K 0x8F1BBCDC 252 #define Fp F2 253 #define Kp 0x7A6D76E9 254 P2( C, D, E, A, B, 1, 11, 8, 15 ); 255 P2( B, C, D, E, A, 9, 12, 6, 5 ); 256 P2( A, B, C, D, E, 11, 14, 4, 8 ); 257 P2( E, A, B, C, D, 10, 15, 1, 11 ); 258 P2( D, E, A, B, C, 0, 14, 3, 14 ); 259 P2( C, D, E, A, B, 8, 15, 11, 14 ); 260 P2( B, C, D, E, A, 12, 9, 15, 6 ); 261 P2( A, B, C, D, E, 4, 8, 0, 14 ); 262 P2( E, A, B, C, D, 13, 9, 5, 6 ); 263 P2( D, E, A, B, C, 3, 14, 12, 9 ); 264 P2( C, D, E, A, B, 7, 5, 2, 12 ); 265 P2( B, C, D, E, A, 15, 6, 13, 9 ); 266 P2( A, B, C, D, E, 14, 8, 9, 12 ); 267 P2( E, A, B, C, D, 5, 6, 7, 5 ); 268 P2( D, E, A, B, C, 6, 5, 10, 15 ); 269 P2( C, D, E, A, B, 2, 12, 14, 8 ); 270 #undef F 271 #undef K 272 #undef Fp 273 #undef Kp 274 275 #define F F5 276 #define K 0xA953FD4E 277 #define Fp F1 278 #define Kp 0x00000000 279 P2( B, C, D, E, A, 4, 9, 12, 8 ); 280 P2( A, B, C, D, E, 0, 15, 15, 5 ); 281 P2( E, A, B, C, D, 5, 5, 10, 12 ); 282 P2( D, E, A, B, C, 9, 11, 4, 9 ); 283 P2( C, D, E, A, B, 7, 6, 1, 12 ); 284 P2( B, C, D, E, A, 12, 8, 5, 5 ); 285 P2( A, B, C, D, E, 2, 13, 8, 14 ); 286 P2( E, A, B, C, D, 10, 12, 7, 6 ); 287 P2( D, E, A, B, C, 14, 5, 6, 8 ); 288 P2( C, D, E, A, B, 1, 12, 2, 13 ); 289 P2( B, C, D, E, A, 3, 13, 13, 6 ); 290 P2( A, B, C, D, E, 8, 14, 14, 5 ); 291 P2( E, A, B, C, D, 11, 11, 0, 15 ); 292 P2( D, E, A, B, C, 6, 8, 3, 13 ); 293 P2( C, D, E, A, B, 15, 5, 9, 11 ); 294 P2( B, C, D, E, A, 13, 6, 11, 11 ); 295 #undef F 296 #undef K 297 #undef Fp 298 #undef Kp 299 300 C = ctx->state[1] + C + Dp; 301 ctx->state[1] = ctx->state[2] + D + Ep; 302 ctx->state[2] = ctx->state[3] + E + Ap; 303 ctx->state[3] = ctx->state[4] + A + Bp; 304 ctx->state[4] = ctx->state[0] + B + Cp; 305 ctx->state[0] = C; 306 307 return( 0 ); 308 } 309 310 #if !defined(MBEDTLS_DEPRECATED_REMOVED) 311 void mbedtls_ripemd160_process( mbedtls_ripemd160_context *ctx, 312 const unsigned char data[64] ) 313 { 314 mbedtls_internal_ripemd160_process( ctx, data ); 315 } 316 #endif 317 #endif /* !MBEDTLS_RIPEMD160_PROCESS_ALT */ 318 319 /* 320 * RIPEMD-160 process buffer 321 */ 322 int mbedtls_ripemd160_update_ret( mbedtls_ripemd160_context *ctx, 323 const unsigned char *input, 324 size_t ilen ) 325 { 326 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; 327 size_t fill; 328 uint32_t left; 329 330 if( ilen == 0 ) 331 return( 0 ); 332 333 left = ctx->total[0] & 0x3F; 334 fill = 64 - left; 335 336 ctx->total[0] += (uint32_t) ilen; 337 ctx->total[0] &= 0xFFFFFFFF; 338 339 if( ctx->total[0] < (uint32_t) ilen ) 340 ctx->total[1]++; 341 342 if( left && ilen >= fill ) 343 { 344 memcpy( (void *) (ctx->buffer + left), input, fill ); 345 346 if( ( ret = mbedtls_internal_ripemd160_process( ctx, ctx->buffer ) ) != 0 ) 347 return( ret ); 348 349 input += fill; 350 ilen -= fill; 351 left = 0; 352 } 353 354 while( ilen >= 64 ) 355 { 356 if( ( ret = mbedtls_internal_ripemd160_process( ctx, input ) ) != 0 ) 357 return( ret ); 358 359 input += 64; 360 ilen -= 64; 361 } 362 363 if( ilen > 0 ) 364 { 365 memcpy( (void *) (ctx->buffer + left), input, ilen ); 366 } 367 368 return( 0 ); 369 } 370 371 #if !defined(MBEDTLS_DEPRECATED_REMOVED) 372 void mbedtls_ripemd160_update( mbedtls_ripemd160_context *ctx, 373 const unsigned char *input, 374 size_t ilen ) 375 { 376 mbedtls_ripemd160_update_ret( ctx, input, ilen ); 377 } 378 #endif 379 380 static const unsigned char ripemd160_padding[64] = 381 { 382 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 383 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 384 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 385 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 386 }; 387 388 /* 389 * RIPEMD-160 final digest 390 */ 391 int mbedtls_ripemd160_finish_ret( mbedtls_ripemd160_context *ctx, 392 unsigned char output[20] ) 393 { 394 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; 395 uint32_t last, padn; 396 uint32_t high, low; 397 unsigned char msglen[8]; 398 399 high = ( ctx->total[0] >> 29 ) 400 | ( ctx->total[1] << 3 ); 401 low = ( ctx->total[0] << 3 ); 402 403 PUT_UINT32_LE( low, msglen, 0 ); 404 PUT_UINT32_LE( high, msglen, 4 ); 405 406 last = ctx->total[0] & 0x3F; 407 padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last ); 408 409 ret = mbedtls_ripemd160_update_ret( ctx, ripemd160_padding, padn ); 410 if( ret != 0 ) 411 return( ret ); 412 413 ret = mbedtls_ripemd160_update_ret( ctx, msglen, 8 ); 414 if( ret != 0 ) 415 return( ret ); 416 417 PUT_UINT32_LE( ctx->state[0], output, 0 ); 418 PUT_UINT32_LE( ctx->state[1], output, 4 ); 419 PUT_UINT32_LE( ctx->state[2], output, 8 ); 420 PUT_UINT32_LE( ctx->state[3], output, 12 ); 421 PUT_UINT32_LE( ctx->state[4], output, 16 ); 422 423 return( 0 ); 424 } 425 426 #if !defined(MBEDTLS_DEPRECATED_REMOVED) 427 void mbedtls_ripemd160_finish( mbedtls_ripemd160_context *ctx, 428 unsigned char output[20] ) 429 { 430 mbedtls_ripemd160_finish_ret( ctx, output ); 431 } 432 #endif 433 434 #endif /* ! MBEDTLS_RIPEMD160_ALT */ 435 436 /* 437 * output = RIPEMD-160( input buffer ) 438 */ 439 int mbedtls_ripemd160_ret( const unsigned char *input, 440 size_t ilen, 441 unsigned char output[20] ) 442 { 443 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; 444 mbedtls_ripemd160_context ctx; 445 446 mbedtls_ripemd160_init( &ctx ); 447 448 if( ( ret = mbedtls_ripemd160_starts_ret( &ctx ) ) != 0 ) 449 goto exit; 450 451 if( ( ret = mbedtls_ripemd160_update_ret( &ctx, input, ilen ) ) != 0 ) 452 goto exit; 453 454 if( ( ret = mbedtls_ripemd160_finish_ret( &ctx, output ) ) != 0 ) 455 goto exit; 456 457 exit: 458 mbedtls_ripemd160_free( &ctx ); 459 460 return( ret ); 461 } 462 463 #if !defined(MBEDTLS_DEPRECATED_REMOVED) 464 void mbedtls_ripemd160( const unsigned char *input, 465 size_t ilen, 466 unsigned char output[20] ) 467 { 468 mbedtls_ripemd160_ret( input, ilen, output ); 469 } 470 #endif 471 472 #if defined(MBEDTLS_SELF_TEST) 473 /* 474 * Test vectors from the RIPEMD-160 paper and 475 * http://homes.esat.kuleuven.be/~bosselae/mbedtls_ripemd160.html#HMAC 476 */ 477 #define TESTS 8 478 static const unsigned char ripemd160_test_str[TESTS][81] = 479 { 480 { "" }, 481 { "a" }, 482 { "abc" }, 483 { "message digest" }, 484 { "abcdefghijklmnopqrstuvwxyz" }, 485 { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" }, 486 { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" }, 487 { "12345678901234567890123456789012345678901234567890123456789012" 488 "345678901234567890" }, 489 }; 490 491 static const size_t ripemd160_test_strlen[TESTS] = 492 { 493 0, 1, 3, 14, 26, 56, 62, 80 494 }; 495 496 static const unsigned char ripemd160_test_md[TESTS][20] = 497 { 498 { 0x9c, 0x11, 0x85, 0xa5, 0xc5, 0xe9, 0xfc, 0x54, 0x61, 0x28, 499 0x08, 0x97, 0x7e, 0xe8, 0xf5, 0x48, 0xb2, 0x25, 0x8d, 0x31 }, 500 { 0x0b, 0xdc, 0x9d, 0x2d, 0x25, 0x6b, 0x3e, 0xe9, 0xda, 0xae, 501 0x34, 0x7b, 0xe6, 0xf4, 0xdc, 0x83, 0x5a, 0x46, 0x7f, 0xfe }, 502 { 0x8e, 0xb2, 0x08, 0xf7, 0xe0, 0x5d, 0x98, 0x7a, 0x9b, 0x04, 503 0x4a, 0x8e, 0x98, 0xc6, 0xb0, 0x87, 0xf1, 0x5a, 0x0b, 0xfc }, 504 { 0x5d, 0x06, 0x89, 0xef, 0x49, 0xd2, 0xfa, 0xe5, 0x72, 0xb8, 505 0x81, 0xb1, 0x23, 0xa8, 0x5f, 0xfa, 0x21, 0x59, 0x5f, 0x36 }, 506 { 0xf7, 0x1c, 0x27, 0x10, 0x9c, 0x69, 0x2c, 0x1b, 0x56, 0xbb, 507 0xdc, 0xeb, 0x5b, 0x9d, 0x28, 0x65, 0xb3, 0x70, 0x8d, 0xbc }, 508 { 0x12, 0xa0, 0x53, 0x38, 0x4a, 0x9c, 0x0c, 0x88, 0xe4, 0x05, 509 0xa0, 0x6c, 0x27, 0xdc, 0xf4, 0x9a, 0xda, 0x62, 0xeb, 0x2b }, 510 { 0xb0, 0xe2, 0x0b, 0x6e, 0x31, 0x16, 0x64, 0x02, 0x86, 0xed, 511 0x3a, 0x87, 0xa5, 0x71, 0x30, 0x79, 0xb2, 0x1f, 0x51, 0x89 }, 512 { 0x9b, 0x75, 0x2e, 0x45, 0x57, 0x3d, 0x4b, 0x39, 0xf4, 0xdb, 513 0xd3, 0x32, 0x3c, 0xab, 0x82, 0xbf, 0x63, 0x32, 0x6b, 0xfb }, 514 }; 515 516 /* 517 * Checkup routine 518 */ 519 int mbedtls_ripemd160_self_test( int verbose ) 520 { 521 int i, ret = 0; 522 unsigned char output[20]; 523 524 memset( output, 0, sizeof output ); 525 526 for( i = 0; i < TESTS; i++ ) 527 { 528 if( verbose != 0 ) 529 mbedtls_printf( " RIPEMD-160 test #%d: ", i + 1 ); 530 531 ret = mbedtls_ripemd160_ret( ripemd160_test_str[i], 532 ripemd160_test_strlen[i], output ); 533 if( ret != 0 ) 534 goto fail; 535 536 if( memcmp( output, ripemd160_test_md[i], 20 ) != 0 ) 537 { 538 ret = 1; 539 goto fail; 540 } 541 542 if( verbose != 0 ) 543 mbedtls_printf( "passed\n" ); 544 } 545 546 if( verbose != 0 ) 547 mbedtls_printf( "\n" ); 548 549 return( 0 ); 550 551 fail: 552 if( verbose != 0 ) 553 mbedtls_printf( "failed\n" ); 554 555 return( ret ); 556 } 557 558 #endif /* MBEDTLS_SELF_TEST */ 559 560 #endif /* MBEDTLS_RIPEMD160_C */ 561