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