git.sesse.net Git - ffmpeg/blob - libavutil/ripemd.c

   1 /*
   2  * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
   3  * Copyright (C) 2013 James Almer
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <string.h>
  23
  24 #include "attributes.h"
  25 #include "avutil.h"
  26 #include "bswap.h"
  27 #include "intreadwrite.h"
  28 #include "ripemd.h"
  29 #include "mem.h"
  30
  31 /** hash context */
  32 typedef struct AVRIPEMD {
  33     uint8_t  digest_len;  ///< digest length in 32-bit words
  34     uint64_t count;       ///< number of bytes in buffer
  35     uint8_t  buffer[64];  ///< 512-bit buffer of input values used in hash updating
  36     uint32_t state[10];   ///< current hash value
  37     uint8_t  ext;         ///< extension (0 for 128 and 160, 1 for 256 and 320)
  38     /** function used to update hash for 512-bit input block */
  39     void     (*transform)(uint32_t *state, const uint8_t buffer[64], int ext);
  40 } AVRIPEMD;
  41
  42 const int av_ripemd_size = sizeof(AVRIPEMD);
  43
  44 struct AVRIPEMD *av_ripemd_alloc(void)
  45 {
  46     return av_mallocz(sizeof(struct AVRIPEMD));
  47 }
  48
  49 static const uint32_t KA[4] = {
  50     0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e
  51 };
  52
  53 static const uint32_t KB[4] = {
  54     0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9
  55 };
  56
  57 static const int ROTA[80] = {
  58     11, 14, 15, 12,  5,  8,  7 , 9, 11, 13, 14, 15,  6,  7,  9,  8,
  59      7 , 6,  8, 13, 11,  9,  7, 15,  7, 12, 15,  9, 11,  7, 13, 12,
  60     11, 13,  6,  7, 14,  9, 13, 15, 14,  8, 13,  6,  5, 12,  7,  5,
  61     11, 12, 14, 15, 14, 15,  9,  8,  9, 14,  5,  6,  8,  6,  5, 12,
  62      9, 15,  5, 11,  6,  8, 13, 12,  5, 12, 13, 14, 11,  8,  5,  6
  63 };
  64
  65 static const int ROTB[80] = {
  66      8,  9,  9, 11, 13, 15, 15,  5,  7,  7,  8, 11, 14, 14, 12,  6,
  67      9, 13, 15,  7, 12,  8,  9, 11,  7,  7, 12,  7,  6, 15, 13, 11,
  68      9,  7, 15, 11,  8,  6,  6, 14, 12, 13,  5, 14, 13, 13,  7,  5,
  69     15,  5,  8, 11, 14, 14,  6, 14,  6,  9, 12,  9, 12,  5, 15,  8,
  70      8,  5, 12,  9, 12,  5, 14,  6,  8, 13,  6,  5, 15, 13, 11, 11
  71 };
  72
  73 static const int WA[80] = {
  74      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  75      7,  4, 13,  1, 10,  6, 15,  3, 12,  0,  9,  5,  2, 14, 11,  8,
  76      3, 10, 14,  4,  9, 15,  8,  1,  2,  7,  0,  6, 13, 11,  5, 12,
  77      1,  9, 11, 10,  0,  8, 12,  4, 13,  3,  7, 15, 14,  5,  6,  2,
  78      4,  0,  5,  9,  7, 12,  2, 10, 14,  1,  3,  8, 11,  6, 15, 13
  79 };
  80
  81 static const int WB[80] = {
  82      5, 14,  7,  0,  9,  2, 11,  4, 13,  6, 15,  8,  1, 10,  3, 12,
  83      6, 11,  3,  7,  0, 13,  5, 10, 14, 15,  8, 12,  4,  9,  1,  2,
  84     15,  5,  1,  3,  7, 14,  6,  9, 11,  8, 12,  2, 10,  0,  4, 13,
  85      8,  6,  4,  1,  3, 11, 15,  0,  5, 12,  2, 13,  9,  7, 10, 14,
  86     12, 15, 10,  4,  1,  5,  8,  7,  6,  2, 13, 14,  0,  3,  9, 11
  87 };
  88
  89 #define rol(value, bits) ((value << bits) | (value >> (32 - bits)))
  90
  91 #define SWAP(a,b) if (ext) { t = a; a = b; b = t; }
  92
  93 #define ROUND128_0_TO_15(a,b,c,d,e,f,g,h)                               \
  94     a = rol(a + ((  b ^ c  ^ d)      + block[WA[n]]),         ROTA[n]); \
  95     e = rol(e + ((((f ^ g) & h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]); \
  96     n++
  97
  98 #define ROUND128_16_TO_31(a,b,c,d,e,f,g,h)                              \
  99     a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]); \
 100     e = rol(e + (((~g | f) ^ h)      + block[WB[n]] + KB[1]), ROTB[n]); \
 101     n++
 102
 103 #define ROUND128_32_TO_47(a,b,c,d,e,f,g,h)                              \
 104     a = rol(a + (((~c | b) ^ d)      + block[WA[n]] + KA[1]), ROTA[n]); \
 105     e = rol(e + ((((g ^ h) & f) ^ h) + block[WB[n]] + KB[2]), ROTB[n]); \
 106     n++
 107
 108 #define ROUND128_48_TO_63(a,b,c,d,e,f,g,h)                              \
 109     a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]); \
 110     e = rol(e + ((  f ^ g  ^ h)      + block[WB[n]]),         ROTB[n]); \
 111     n++
 112
 113 static void ripemd128_transform(uint32_t *state, const uint8_t buffer[64], int ext)
 114 {
 115     uint32_t a, b, c, d, e, f, g, h, t;
 116     uint32_t block[16];
 117     int n;
 118
 119     if (ext) {
 120         a = state[0]; b = state[1]; c = state[2]; d = state[3];
 121         e = state[4]; f = state[5]; g = state[6]; h = state[7];
 122     } else {
 123         a = e = state[0];
 124         b = f = state[1];
 125         c = g = state[2];
 126         d = h = state[3];
 127     }
 128
 129     for (n = 0; n < 16; n++)
 130         block[n] = AV_RL32(buffer + 4 * n);
 131     n = 0;
 132
 133 #if CONFIG_SMALL
 134     for (; n < 16;) {
 135         ROUND128_0_TO_15(a,b,c,d,e,f,g,h);
 136         t = d; d = c; c = b; b = a; a = t;
 137         t = h; h = g; g = f; f = e; e = t;
 138     }
 139     SWAP(a,e)
 140
 141     for (; n < 32;) {
 142         ROUND128_16_TO_31(a,b,c,d,e,f,g,h);
 143         t = d; d = c; c = b; b = a; a = t;
 144         t = h; h = g; g = f; f = e; e = t;
 145     }
 146     SWAP(b,f)
 147
 148     for (; n < 48;) {
 149         ROUND128_32_TO_47(a,b,c,d,e,f,g,h);
 150         t = d; d = c; c = b; b = a; a = t;
 151         t = h; h = g; g = f; f = e; e = t;
 152     }
 153     SWAP(c,g)
 154
 155     for (; n < 64;) {
 156         ROUND128_48_TO_63(a,b,c,d,e,f,g,h);
 157         t = d; d = c; c = b; b = a; a = t;
 158         t = h; h = g; g = f; f = e; e = t;
 159     }
 160     SWAP(d,h)
 161 #else
 162
 163 #define R128_0                         \
 164     ROUND128_0_TO_15(a,b,c,d,e,f,g,h); \
 165     ROUND128_0_TO_15(d,a,b,c,h,e,f,g); \
 166     ROUND128_0_TO_15(c,d,a,b,g,h,e,f); \
 167     ROUND128_0_TO_15(b,c,d,a,f,g,h,e)
 168
 169     R128_0; R128_0; R128_0; R128_0;
 170     SWAP(a,e)
 171
 172 #define R128_16                         \
 173     ROUND128_16_TO_31(a,b,c,d,e,f,g,h); \
 174     ROUND128_16_TO_31(d,a,b,c,h,e,f,g); \
 175     ROUND128_16_TO_31(c,d,a,b,g,h,e,f); \
 176     ROUND128_16_TO_31(b,c,d,a,f,g,h,e)
 177
 178     R128_16; R128_16; R128_16; R128_16;
 179     SWAP(b,f)
 180
 181 #define R128_32                         \
 182     ROUND128_32_TO_47(a,b,c,d,e,f,g,h); \
 183     ROUND128_32_TO_47(d,a,b,c,h,e,f,g); \
 184     ROUND128_32_TO_47(c,d,a,b,g,h,e,f); \
 185     ROUND128_32_TO_47(b,c,d,a,f,g,h,e)
 186
 187     R128_32; R128_32; R128_32; R128_32;
 188     SWAP(c,g)
 189
 190 #define R128_48                         \
 191     ROUND128_48_TO_63(a,b,c,d,e,f,g,h); \
 192     ROUND128_48_TO_63(d,a,b,c,h,e,f,g); \
 193     ROUND128_48_TO_63(c,d,a,b,g,h,e,f); \
 194     ROUND128_48_TO_63(b,c,d,a,f,g,h,e)
 195
 196     R128_48; R128_48; R128_48; R128_48;
 197     SWAP(d,h)
 198 #endif
 199
 200     if (ext) {
 201         state[0] += a; state[1] += b; state[2] += c; state[3] += d;
 202         state[4] += e; state[5] += f; state[6] += g; state[7] += h;
 203     } else {
 204         h += c + state[1];
 205         state[1] = state[2] + d + e;
 206         state[2] = state[3] + a + f;
 207         state[3] = state[0] + b + g;
 208         state[0] = h;
 209     }
 210 }
 211
 212 #define ROTATE(x,y) \
 213     x = rol(x, 10); \
 214     y = rol(y, 10); \
 215     n++
 216
 217 #define ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j)                               \
 218     a = rol(a + ((  b ^ c  ^ d)      + block[WA[n]]),         ROTA[n]) + e; \
 219     f = rol(f + (((~i | h) ^ g)      + block[WB[n]] + KB[0]), ROTB[n]) + j; \
 220     ROTATE(c,h)
 221
 222 #define ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j)                              \
 223     a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]) + e; \
 224     f = rol(f + ((((g ^ h) & i) ^ h) + block[WB[n]] + KB[1]), ROTB[n]) + j; \
 225     ROTATE(c,h)
 226
 227 #define ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j)                              \
 228     a = rol(a + (((~c | b) ^ d)      + block[WA[n]] + KA[1]), ROTA[n]) + e; \
 229     f = rol(f + (((~h | g) ^ i)      + block[WB[n]] + KB[2]), ROTB[n]) + j; \
 230     ROTATE(c,h)
 231
 232 #define ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j)                              \
 233     a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]) + e; \
 234     f = rol(f + ((((h ^ i) & g) ^ i) + block[WB[n]] + KB[3]), ROTB[n]) + j; \
 235     ROTATE(c,h)
 236
 237 #define ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j)                              \
 238     a = rol(a + (((~d | c) ^ b)      + block[WA[n]] + KA[3]), ROTA[n]) + e; \
 239     f = rol(f + ((  g ^ h  ^ i)      + block[WB[n]]),         ROTB[n]) + j; \
 240     ROTATE(c,h)
 241
 242 static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64], int ext)
 243 {
 244     uint32_t a, b, c, d, e, f, g, h, i, j, t;
 245     uint32_t block[16];
 246     int n;
 247
 248     if (ext) {
 249         a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4];
 250         f = state[5]; g = state[6]; h = state[7]; i = state[8]; j = state[9];
 251     } else {
 252         a = f = state[0];
 253         b = g = state[1];
 254         c = h = state[2];
 255         d = i = state[3];
 256         e = j = state[4];
 257     }
 258
 259     for (n = 0; n < 16; n++)
 260         block[n] = AV_RL32(buffer + 4 * n);
 261     n = 0;
 262
 263 #if CONFIG_SMALL
 264     for (; n < 16;) {
 265         ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
 266         t = e; e = d; d = c; c = b; b = a; a = t;
 267         t = j; j = i; i = h; h = g; g = f; f = t;
 268     }
 269     SWAP(b,g)
 270
 271     for (; n < 32;) {
 272         ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j);
 273         t = e; e = d; d = c; c = b; b = a; a = t;
 274         t = j; j = i; i = h; h = g; g = f; f = t;
 275     }
 276     SWAP(d,i)
 277
 278     for (; n < 48;) {
 279         ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j);
 280         t = e; e = d; d = c; c = b; b = a; a = t;
 281         t = j; j = i; i = h; h = g; g = f; f = t;
 282     }
 283     SWAP(a,f)
 284
 285     for (; n < 64;) {
 286         ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j);
 287         t = e; e = d; d = c; c = b; b = a; a = t;
 288         t = j; j = i; i = h; h = g; g = f; f = t;
 289     }
 290     SWAP(c,h)
 291
 292     for (; n < 80;) {
 293         ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j);
 294         t = e; e = d; d = c; c = b; b = a; a = t;
 295         t = j; j = i; i = h; h = g; g = f; f = t;
 296     }
 297     SWAP(e,j)
 298 #else
 299
 300 #define R160_0                             \
 301     ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j); \
 302     ROUND160_0_TO_15(e,a,b,c,d,j,f,g,h,i); \
 303     ROUND160_0_TO_15(d,e,a,b,c,i,j,f,g,h); \
 304     ROUND160_0_TO_15(c,d,e,a,b,h,i,j,f,g); \
 305     ROUND160_0_TO_15(b,c,d,e,a,g,h,i,j,f)
 306
 307     R160_0; R160_0; R160_0;
 308     ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
 309     SWAP(a,f)
 310
 311 #define R160_16                             \
 312     ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i); \
 313     ROUND160_16_TO_31(d,e,a,b,c,i,j,f,g,h); \
 314     ROUND160_16_TO_31(c,d,e,a,b,h,i,j,f,g); \
 315     ROUND160_16_TO_31(b,c,d,e,a,g,h,i,j,f); \
 316     ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j)
 317
 318     R160_16; R160_16; R160_16;
 319     ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i);
 320     SWAP(b,g)
 321
 322 #define R160_32                             \
 323     ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h); \
 324     ROUND160_32_TO_47(c,d,e,a,b,h,i,j,f,g); \
 325     ROUND160_32_TO_47(b,c,d,e,a,g,h,i,j,f); \
 326     ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j); \
 327     ROUND160_32_TO_47(e,a,b,c,d,j,f,g,h,i)
 328
 329     R160_32; R160_32; R160_32;
 330     ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h);
 331     SWAP(c,h)
 332
 333 #define R160_48                             \
 334     ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g); \
 335     ROUND160_48_TO_63(b,c,d,e,a,g,h,i,j,f); \
 336     ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j); \
 337     ROUND160_48_TO_63(e,a,b,c,d,j,f,g,h,i); \
 338     ROUND160_48_TO_63(d,e,a,b,c,i,j,f,g,h)
 339
 340     R160_48; R160_48; R160_48;
 341     ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g);
 342     SWAP(d,i)
 343
 344 #define R160_64                             \
 345     ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f); \
 346     ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j); \
 347     ROUND160_64_TO_79(e,a,b,c,d,j,f,g,h,i); \
 348     ROUND160_64_TO_79(d,e,a,b,c,i,j,f,g,h); \
 349     ROUND160_64_TO_79(c,d,e,a,b,h,i,j,f,g)
 350
 351     R160_64; R160_64; R160_64;
 352     ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f);
 353     SWAP(e,j)
 354 #endif
 355
 356     if (ext) {
 357         state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e;
 358         state[5] += f; state[6] += g; state[7] += h; state[8] += i; state[9] += j;
 359     } else {
 360         i += c + state[1];
 361         state[1] = state[2] + d + j;
 362         state[2] = state[3] + e + f;
 363         state[3] = state[4] + a + g;
 364         state[4] = state[0] + b + h;
 365         state[0] = i;
 366     }
 367 }
 368
 369 av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
 370 {
 371     ctx->digest_len = bits >> 5;
 372     switch (bits) {
 373     case 128: // RIPEMD-128
 374         ctx->state[0] = 0x67452301;
 375         ctx->state[1] = 0xEFCDAB89;
 376         ctx->state[2] = 0x98BADCFE;
 377         ctx->state[3] = 0x10325476;
 378         ctx->transform = ripemd128_transform;
 379         ctx->ext = 0;
 380         break;
 381     case 160: // RIPEMD-160
 382         ctx->state[0] = 0x67452301;
 383         ctx->state[1] = 0xEFCDAB89;
 384         ctx->state[2] = 0x98BADCFE;
 385         ctx->state[3] = 0x10325476;
 386         ctx->state[4] = 0xC3D2E1F0;
 387         ctx->transform = ripemd160_transform;
 388         ctx->ext = 0;
 389         break;
 390     case 256: // RIPEMD-256
 391         ctx->state[0] = 0x67452301;
 392         ctx->state[1] = 0xEFCDAB89;
 393         ctx->state[2] = 0x98BADCFE;
 394         ctx->state[3] = 0x10325476;
 395         ctx->state[4] = 0x76543210;
 396         ctx->state[5] = 0xFEDCBA98;
 397         ctx->state[6] = 0x89ABCDEF;
 398         ctx->state[7] = 0x01234567;
 399         ctx->transform = ripemd128_transform;
 400         ctx->ext = 1;
 401         break;
 402     case 320: // RIPEMD-320
 403         ctx->state[0] = 0x67452301;
 404         ctx->state[1] = 0xEFCDAB89;
 405         ctx->state[2] = 0x98BADCFE;
 406         ctx->state[3] = 0x10325476;
 407         ctx->state[4] = 0xC3D2E1F0;
 408         ctx->state[5] = 0x76543210;
 409         ctx->state[6] = 0xFEDCBA98;
 410         ctx->state[7] = 0x89ABCDEF;
 411         ctx->state[8] = 0x01234567;
 412         ctx->state[9] = 0x3C2D1E0F;
 413         ctx->transform = ripemd160_transform;
 414         ctx->ext = 1;
 415         break;
 416     default:
 417         return -1;
 418     }
 419     ctx->count = 0;
 420     return 0;
 421 }
 422
 423 void av_ripemd_update(AVRIPEMD* ctx, const uint8_t* data, unsigned int len)
 424 {
 425     unsigned int i, j;
 426
 427     j = ctx->count & 63;
 428     ctx->count += len;
 429 #if CONFIG_SMALL
 430     for (i = 0; i < len; i++) {
 431         ctx->buffer[j++] = data[i];
 432         if (64 == j) {
 433             ctx->transform(ctx->state, ctx->buffer, ctx->ext);
 434             j = 0;
 435         }
 436     }
 437 #else
 438     if ((j + len) > 63) {
 439         memcpy(&ctx->buffer[j], data, (i = 64 - j));
 440         ctx->transform(ctx->state, ctx->buffer, ctx->ext);
 441         for (; i + 63 < len; i += 64)
 442             ctx->transform(ctx->state, &data[i], ctx->ext);
 443         j = 0;
 444     } else
 445         i = 0;
 446     memcpy(&ctx->buffer[j], &data[i], len - i);
 447 #endif
 448 }
 449
 450 void av_ripemd_final(AVRIPEMD* ctx, uint8_t *digest)
 451 {
 452     int i;
 453     uint64_t finalcount = av_le2ne64(ctx->count << 3);
 454
 455     av_ripemd_update(ctx, "\200", 1);
 456     while ((ctx->count & 63) != 56)
 457         av_ripemd_update(ctx, "", 1);
 458     av_ripemd_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
 459     for (i = 0; i < ctx->digest_len; i++)
 460         AV_WL32(digest + i*4, ctx->state[i]);
 461 }
 462
 463 #ifdef TEST
 464 #include <stdio.h>
 465
 466 int main(void)
 467 {
 468     int i, j, k;
 469     AVRIPEMD ctx;
 470     unsigned char digest[40];
 471     static const int lengths[4] = { 128, 160, 256, 320 };
 472
 473     for (j = 0; j < 4; j++) {
 474         printf("Testing RIPEMD-%d\n", lengths[j]);
 475         for (k = 0; k < 3; k++) {
 476             av_ripemd_init(&ctx, lengths[j]);
 477             if (k == 0)
 478                 av_ripemd_update(&ctx, "abc", 3);
 479             else if (k == 1)
 480                 av_ripemd_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
 481             else
 482                 for (i = 0; i < 1000*1000; i++)
 483                     av_ripemd_update(&ctx, "a", 1);
 484             av_ripemd_final(&ctx, digest);
 485             for (i = 0; i < lengths[j] >> 3; i++)
 486                 printf("%02X", digest[i]);
 487             putchar('\n');
 488         }
 489         switch (j) { //test vectors (from ISO:IEC 10118-3 (2004) and http://homes.esat.kuleuven.be/~bosselae/ripemd160.html)
 490         case 0:
 491             printf("c14a1219 9c66e4ba 84636b0f 69144c77\n"
 492                    "a1aa0689 d0fafa2d dc22e88b 49133a06\n"
 493                    "4a7f5723 f954eba1 216c9d8f 6320431f\n");
 494             break;
 495         case 1:
 496             printf("8eb208f7 e05d987a 9b044a8e 98c6b087 f15a0bfc\n"
 497                    "12a05338 4a9c0c88 e405a06c 27dcf49a da62eb2b\n"
 498                    "52783243 c1697bdb e16d37f9 7f68f083 25dc1528\n");
 499             break;
 500         case 2:
 501             printf("afbd6e22 8b9d8cbb cef5ca2d 03e6dba1 0ac0bc7d cbe4680e 1e42d2e9 75459b65\n"
 502                    "38430455 83aac6c8 c8d91285 73e7a980 9afb2a0f 34ccc36e a9e72f16 f6368e3f\n"
 503                    "ac953744 e10e3151 4c150d4d 8d7b6773 42e33399 788296e4 3ae4850c e4f97978\n");
 504             break;
 505         case 3:
 506             printf("de4c01b3 054f8930 a79d09ae 738e9230 1e5a1708 5beffdc1 b8d11671 3e74f82f a942d64c dbc4682d\n"
 507                    "d034a795 0cf72202 1ba4b84d f769a5de 2060e259 df4c9bb4 a4268c0e 935bbc74 70a969c9 d072a1ac\n"
 508                    "bdee37f4 371e2064 6b8b0d86 2dda1629 2ae36f40 965e8c85 09e63d1d bddecc50 3e2b63eb 9245bb66\n");
 509             break;
 510         }
 511     }
 512
 513     return 0;
 514 }
 515 #endif