dbus/dbus-md5.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-md5.c md5 implementation (based on L Peter Deutsch implementation)
   3  *
   4  * Copyright (C) 2003 Red Hat Inc.
   5  * Copyright (C) 1999, 2000 Aladdin Enterprises.  All rights reserved.
   6  *
   7  * This software is provided 'as-is', without any express or implied
   8  * warranty.  In no event will the authors be held liable for any damages
   9  * arising from the use of this software.
  10  *
  11  * Permission is granted to anyone to use this software for any purpose,
  12  * including commercial applications, and to alter it and redistribute it
  13  * freely, subject to the following restrictions:
  14  *
  15  * 1. The origin of this software must not be misrepresented; you must not
  16  *    claim that you wrote the original software. If you use this software
  17  *    in a product, an acknowledgment in the product documentation would be
  18  *    appreciated but is not required.
  19  * 2. Altered source versions must be plainly marked as such, and must not be
  20  *    misrepresented as being the original software.
  21  * 3. This notice may not be removed or altered from any source distribution.
  22  *
  23  * L. Peter Deutsch
  24  * ghost@aladdin.com
  25  */
  26 /*
  27  * Independent implementation of MD5 (RFC 1321).
  28  *
  29  * This code implements the MD5 Algorithm defined in RFC 1321.
  30  * It is derived directly from the text of the RFC and not from the
  31  * reference implementation.
  32  *
  33  * The original and principal author of md5.c is L. Peter Deutsch
  34  * <ghost@aladdin.com>.
  35  */
  36
  37 #include "dbus-internals.h"
  38 #include "dbus-md5.h"
  39 #include <string.h>
  40
  41 /**
  42  * @defgroup DBusMD5 MD5 implementation
  43  * @ingroup  DBusInternals
  44  * @brief MD5 hash
  45  *
  46  * Types and functions related to computing MD5 sums.
  47  */
  48
  49 /**
  50  * @defgroup DBusMD5Internals MD5 implementation details
  51  * @ingroup  DBusInternals
  52  * @brief Internals of MD5 implementation.
  53  *
  54  * The implementation of MD5 (see http://www.ietf.org/rfc/rfc1321.txt).
  55  * This MD5 implementation was written by L. Peter Deutsch and
  56  * is not derived from the RSA reference implementation in the
  57  * RFC. The version included in D-BUS comes from the Ghostscript
  58  * 7.05 distribution.
  59  *
  60  * @{
  61  */
  62 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  63 /*
  64  * For reference, here is the program that computed the T values.
  65  */
  66 #ifdef COMPUTE_T_VALUES
  67 #include <math.h>
  68 int
  69 main(int argc, char **argv)
  70 {
  71   int i;
  72   for (i = 1; i <= 64; ++i)
  73     {
  74       unsigned long v = (unsigned long)(4294967296.0 * fabs(sin((double)i)));
  75
  76       /*
  77        * The following nonsense is only to avoid compiler warnings about
  78        * "integer constant is unsigned in ANSI C, signed with -traditional".
  79        */
  80       if (v >> 31)
  81         {
  82           printf("#define T%d /* 0x%08lx */ (T_MASK ^ 0x%08lx)\n", i,
  83                  v, (unsigned long)(unsigned int)(~v));
  84         } else {
  85         printf("#define T%d    0x%08lx\n", i, v);
  86       }
  87     }
  88   return 0;
  89 }
  90 #endif /* COMPUTE_T_VALUES */
  91 /*
  92  * End of T computation program.
  93  */
  94
  95 #define T_MASK ((dbus_uint32_t)~0)
  96 #define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
  97 #define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
  98 #define T3    0x242070db
  99 #define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
 100 #define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
 101 #define T6    0x4787c62a
 102 #define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
 103 #define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
 104 #define T9    0x698098d8
 105 #define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
 106 #define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
 107 #define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
 108 #define T13    0x6b901122
 109 #define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
 110 #define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
 111 #define T16    0x49b40821
 112 #define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
 113 #define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
 114 #define T19    0x265e5a51
 115 #define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
 116 #define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
 117 #define T22    0x02441453
 118 #define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
 119 #define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
 120 #define T25    0x21e1cde6
 121 #define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
 122 #define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
 123 #define T28    0x455a14ed
 124 #define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
 125 #define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
 126 #define T31    0x676f02d9
 127 #define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
 128 #define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
 129 #define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
 130 #define T35    0x6d9d6122
 131 #define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
 132 #define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
 133 #define T38    0x4bdecfa9
 134 #define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
 135 #define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
 136 #define T41    0x289b7ec6
 137 #define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
 138 #define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
 139 #define T44    0x04881d05
 140 #define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
 141 #define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
 142 #define T47    0x1fa27cf8
 143 #define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
 144 #define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
 145 #define T50    0x432aff97
 146 #define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
 147 #define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
 148 #define T53    0x655b59c3
 149 #define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
 150 #define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
 151 #define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
 152 #define T57    0x6fa87e4f
 153 #define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
 154 #define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
 155 #define T60    0x4e0811a1
 156 #define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
 157 #define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
 158 #define T63    0x2ad7d2bb
 159 #define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
 160 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 161
 162 static void
 163 md5_process(DBusMD5Context *context, const unsigned char *data /*[64]*/)
 164 {
 165   dbus_uint32_t
 166     a = context->abcd[0], b = context->abcd[1],
 167     c = context->abcd[2], d = context->abcd[3];
 168   dbus_uint32_t t;
 169
 170 #ifdef WORDS_BIGENDIAN
 171   /*
 172    * On big-endian machines, we must arrange the bytes in the right
 173    * order.  (This also works on machines of unknown byte order.)
 174    */
 175   dbus_uint32_t X[16];
 176   const unsigned char *xp = data;
 177   int i;
 178
 179   for (i = 0; i < 16; ++i, xp += 4)
 180     X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
 181
 182 #else  /* !WORDS_BIGENDIAN */
 183   /*
 184    * On little-endian machines, we can process properly aligned data
 185    * without copying it.
 186    */
 187   dbus_uint32_t xbuf[16];
 188   const dbus_uint32_t *X;
 189
 190   if (!((data - (const unsigned char *)0) & 3))
 191     {
 192       /* data are properly aligned */
 193       X = (const dbus_uint32_t *)data;
 194     }
 195   else
 196     {
 197       /* not aligned */
 198       memcpy(xbuf, data, 64);
 199       X = xbuf;
 200     }
 201 #endif
 202
 203 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
 204
 205   /* Round 1. */
 206   /* Let [abcd k s i] denote the operation
 207      a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
 208 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
 209 #define SET(a, b, c, d, k, s, Ti)               \
 210   t = a + F(b,c,d) + X[k] + Ti;                 \
 211   a = ROTATE_LEFT(t, s) + b
 212   /* Do the following 16 operations. */
 213   SET(a, b, c, d,  0,  7,  T1);
 214   SET(d, a, b, c,  1, 12,  T2);
 215   SET(c, d, a, b,  2, 17,  T3);
 216   SET(b, c, d, a,  3, 22,  T4);
 217   SET(a, b, c, d,  4,  7,  T5);
 218   SET(d, a, b, c,  5, 12,  T6);
 219   SET(c, d, a, b,  6, 17,  T7);
 220   SET(b, c, d, a,  7, 22,  T8);
 221   SET(a, b, c, d,  8,  7,  T9);
 222   SET(d, a, b, c,  9, 12, T10);
 223   SET(c, d, a, b, 10, 17, T11);
 224   SET(b, c, d, a, 11, 22, T12);
 225   SET(a, b, c, d, 12,  7, T13);
 226   SET(d, a, b, c, 13, 12, T14);
 227   SET(c, d, a, b, 14, 17, T15);
 228   SET(b, c, d, a, 15, 22, T16);
 229 #undef SET
 230
 231   /* Round 2. */
 232   /* Let [abcd k s i] denote the operation
 233      a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
 234 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
 235 #define SET(a, b, c, d, k, s, Ti)               \
 236   t = a + G(b,c,d) + X[k] + Ti;                 \
 237   a = ROTATE_LEFT(t, s) + b
 238   /* Do the following 16 operations. */
 239   SET(a, b, c, d,  1,  5, T17);
 240   SET(d, a, b, c,  6,  9, T18);
 241   SET(c, d, a, b, 11, 14, T19);
 242   SET(b, c, d, a,  0, 20, T20);
 243   SET(a, b, c, d,  5,  5, T21);
 244   SET(d, a, b, c, 10,  9, T22);
 245   SET(c, d, a, b, 15, 14, T23);
 246   SET(b, c, d, a,  4, 20, T24);
 247   SET(a, b, c, d,  9,  5, T25);
 248   SET(d, a, b, c, 14,  9, T26);
 249   SET(c, d, a, b,  3, 14, T27);
 250   SET(b, c, d, a,  8, 20, T28);
 251   SET(a, b, c, d, 13,  5, T29);
 252   SET(d, a, b, c,  2,  9, T30);
 253   SET(c, d, a, b,  7, 14, T31);
 254   SET(b, c, d, a, 12, 20, T32);
 255 #undef SET
 256
 257   /* Round 3. */
 258   /* Let [abcd k s t] denote the operation
 259      a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
 260 #define H(x, y, z) ((x) ^ (y) ^ (z))
 261 #define SET(a, b, c, d, k, s, Ti)               \
 262   t = a + H(b,c,d) + X[k] + Ti;                 \
 263   a = ROTATE_LEFT(t, s) + b
 264   /* Do the following 16 operations. */
 265   SET(a, b, c, d,  5,  4, T33);
 266   SET(d, a, b, c,  8, 11, T34);
 267   SET(c, d, a, b, 11, 16, T35);
 268   SET(b, c, d, a, 14, 23, T36);
 269   SET(a, b, c, d,  1,  4, T37);
 270   SET(d, a, b, c,  4, 11, T38);
 271   SET(c, d, a, b,  7, 16, T39);
 272   SET(b, c, d, a, 10, 23, T40);
 273   SET(a, b, c, d, 13,  4, T41);
 274   SET(d, a, b, c,  0, 11, T42);
 275   SET(c, d, a, b,  3, 16, T43);
 276   SET(b, c, d, a,  6, 23, T44);
 277   SET(a, b, c, d,  9,  4, T45);
 278   SET(d, a, b, c, 12, 11, T46);
 279   SET(c, d, a, b, 15, 16, T47);
 280   SET(b, c, d, a,  2, 23, T48);
 281 #undef SET
 282
 283   /* Round 4. */
 284   /* Let [abcd k s t] denote the operation
 285      a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
 286 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
 287 #define SET(a, b, c, d, k, s, Ti)               \
 288   t = a + I(b,c,d) + X[k] + Ti;                 \
 289   a = ROTATE_LEFT(t, s) + b
 290   /* Do the following 16 operations. */
 291   SET(a, b, c, d,  0,  6, T49);
 292   SET(d, a, b, c,  7, 10, T50);
 293   SET(c, d, a, b, 14, 15, T51);
 294   SET(b, c, d, a,  5, 21, T52);
 295   SET(a, b, c, d, 12,  6, T53);
 296   SET(d, a, b, c,  3, 10, T54);
 297   SET(c, d, a, b, 10, 15, T55);
 298   SET(b, c, d, a,  1, 21, T56);
 299   SET(a, b, c, d,  8,  6, T57);
 300   SET(d, a, b, c, 15, 10, T58);
 301   SET(c, d, a, b,  6, 15, T59);
 302   SET(b, c, d, a, 13, 21, T60);
 303   SET(a, b, c, d,  4,  6, T61);
 304   SET(d, a, b, c, 11, 10, T62);
 305   SET(c, d, a, b,  2, 15, T63);
 306   SET(b, c, d, a,  9, 21, T64);
 307 #undef SET
 308
 309   /* Then perform the following additions. (That is increment each
 310      of the four registers by the value it had before this block
 311      was started.) */
 312   context->abcd[0] += a;
 313   context->abcd[1] += b;
 314   context->abcd[2] += c;
 315   context->abcd[3] += d;
 316 }
 317
 318 static void
 319 md5_init (DBusMD5Context *context)
 320 {
 321   context->count[0] = context->count[1] = 0;
 322   context->abcd[0] = 0x67452301;
 323   context->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
 324   context->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
 325   context->abcd[3] = 0x10325476;
 326 }
 327
 328 static void
 329 md5_append (DBusMD5Context *context, const unsigned char *data, int nbytes)
 330 {
 331   const unsigned char *p = data;
 332   int left = nbytes;
 333   int offset = (context->count[0] >> 3) & 63;
 334   dbus_uint32_t nbits = (dbus_uint32_t)(nbytes << 3);
 335
 336   if (nbytes <= 0)
 337     return;
 338
 339   /* Update the message length. */
 340   context->count[1] += nbytes >> 29;
 341   context->count[0] += nbits;
 342   if (context->count[0] < nbits)
 343     context->count[1]++;
 344
 345   /* Process an initial partial block. */
 346   if (offset)
 347     {
 348       int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
 349
 350       memcpy(context->buf + offset, p, copy);
 351       if (offset + copy < 64)
 352         return;
 353       p += copy;
 354       left -= copy;
 355       md5_process(context, context->buf);
 356     }
 357
 358   /* Process full blocks. */
 359   for (; left >= 64; p += 64, left -= 64)
 360     md5_process(context, p);
 361
 362   /* Process a final partial block. */
 363   if (left)
 364     memcpy(context->buf, p, left);
 365 }
 366
 367 static void
 368 md5_finish (DBusMD5Context *context, unsigned char digest[16])
 369 {
 370   static const unsigned char pad[64] = {
 371     0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 372     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 373     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 374     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 375   };
 376   unsigned char data[8];
 377   int i;
 378
 379   /* Save the length before padding. */
 380   for (i = 0; i < 8; ++i)
 381     data[i] = (unsigned char)(context->count[i >> 2] >> ((i & 3) << 3));
 382   /* Pad to 56 bytes mod 64. */
 383   md5_append(context, pad, ((55 - (context->count[0] >> 3)) & 63) + 1);
 384   /* Append the length. */
 385   md5_append(context, data, 8);
 386   for (i = 0; i < 16; ++i)
 387     digest[i] = (unsigned char)(context->abcd[i >> 2] >> ((i & 3) << 3));
 388 }
 389
 390 /** @} */ /* End of internals */
 391
 392 /**
 393  * @addtogroup DBusMD5
 394  *
 395  * @{
 396  */
 397
 398 /**
 399  * Initializes the MD5 context.
 400  *
 401  * @param context an uninitialized context, typically on the stack.
 402  */
 403 void
 404 _dbus_md5_init (DBusMD5Context *context)
 405 {
 406   md5_init (context);
 407 }
 408
 409
 410 /**
 411  * Feeds more data into an existing md5sum computation.
 412  *
 413  * @param context the MD5 context
 414  * @param data the additional data to hash
 415  */
 416 void
 417 _dbus_md5_update (DBusMD5Context   *context,
 418                   const DBusString *data)
 419 {
 420   unsigned int inputLen;
 421   unsigned char *input;
 422
 423   _dbus_string_get_const_data (data, (const char**) &input);
 424   inputLen = _dbus_string_get_length (data);
 425
 426   md5_append (context, input, inputLen);
 427 }
 428
 429 /**
 430  * MD5 finalization. Ends an MD5 message-digest operation, writing the
 431  * the message digest and zeroing the context.  The results are
 432  * returned as a raw 16-byte digest, not as the ascii-hex-digits
 433  * string form of the digest.
 434  *
 435  * @param context the MD5 context
 436  * @param results string to append the 16-byte MD5 digest to
 437  * @returns #FALSE if not enough memory to append the digest
 438  *
 439  */
 440 dbus_bool_t
 441 _dbus_md5_final (DBusMD5Context   *context,
 442                  DBusString       *results)
 443 {
 444   unsigned char digest[16];
 445
 446   md5_finish (context, digest);
 447
 448   if (!_dbus_string_append_len (results, digest, 16))
 449     return FALSE;
 450
 451   /* some kind of security paranoia, though it seems pointless
 452    * to me given the nonzeroed stuff flying around
 453    */
 454   memset ((void*)context, '\0', sizeof (DBusMD5Context));
 455
 456   return TRUE;
 457 }
 458
 459 /**
 460  * Computes the ASCII hex-encoded md5sum of the given data and
 461  * appends it to the output string.
 462  *
 463  * @param data input data to be hashed
 464  * @param ascii_output string to append ASCII md5sum to
 465  * @returns #FALSE if not enough memory
 466  */
 467 dbus_bool_t
 468 _dbus_md5_compute (const DBusString *data,
 469                    DBusString       *ascii_output)
 470 {
 471   DBusMD5Context context;
 472   DBusString digest;
 473
 474   _dbus_md5_init (&context);
 475
 476   _dbus_md5_update (&context, data);
 477
 478   if (!_dbus_string_init (&digest))
 479     return FALSE;
 480
 481   if (!_dbus_md5_final (&context, &digest))
 482     goto error;
 483
 484   if (!_dbus_string_hex_encode (&digest, 0, ascii_output,
 485                                 _dbus_string_get_length (ascii_output)))
 486     goto error;
 487
 488   _dbus_string_free (&digest);
 489
 490   return TRUE;
 491
 492  error:
 493   _dbus_string_free (&digest);
 494   return FALSE;
 495 }
 496
 497 /** @} */ /* end of exported functions */
 498
 499 #ifdef DBUS_BUILD_TESTS
 500 #include "dbus-test.h"
 501 #include <stdio.h>
 502
 503 static dbus_bool_t
 504 check_md5_binary (const unsigned char *input,
 505                   int                  input_len,
 506                   const char          *expected)
 507 {
 508   DBusString input_str;
 509   DBusString expected_str;
 510   DBusString results;
 511
 512   _dbus_string_init_const_len (&input_str, input, input_len);
 513   _dbus_string_init_const (&expected_str, expected);
 514
 515   if (!_dbus_string_init (&results))
 516     _dbus_assert_not_reached ("no memory for md5 results");
 517
 518   if (!_dbus_md5_compute (&input_str, &results))
 519     _dbus_assert_not_reached ("no memory for md5 results");
 520
 521   if (!_dbus_string_equal (&expected_str, &results))
 522     {
 523       const char *s;
 524       _dbus_string_get_const_data (&results, &s);
 525       _dbus_warn ("Expected hash %s got %s for md5 sum\n",
 526                   expected, s);
 527       _dbus_string_free (&results);
 528       return FALSE;
 529     }
 530
 531   _dbus_string_free (&results);
 532   return TRUE;
 533 }
 534
 535 static dbus_bool_t
 536 check_md5_str (const char *input,
 537                const char *expected)
 538 {
 539   return check_md5_binary (input, strlen (input), expected);
 540 }
 541
 542 /**
 543  * @ingroup DBusMD5Internals
 544  * Unit test for MD5 computation.
 545  *
 546  * @returns #TRUE on success.
 547  */
 548 dbus_bool_t
 549 _dbus_md5_test (void)
 550 {
 551   unsigned char all_bytes[256];
 552   int i;
 553
 554   i = 0;
 555   while (i < 256)
 556     {
 557       all_bytes[i] = i;
 558       ++i;
 559     }
 560
 561   if (!check_md5_binary (all_bytes, 256,
 562                          "e2c865db4162bed963bfaa9ef6ac18f0"))
 563     return FALSE;
 564
 565 #define CHECK(input,expected) if (!check_md5_str (input, expected)) return FALSE
 566
 567   CHECK ("", "d41d8cd98f00b204e9800998ecf8427e");
 568   CHECK ("a", "0cc175b9c0f1b6a831c399e269772661");
 569   CHECK ("abc", "900150983cd24fb0d6963f7d28e17f72");
 570   CHECK ("message digest", "f96b697d7cb7938d525a2f31aaf161d0");
 571   CHECK ("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b");
 572   CHECK ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 573          "d174ab98d277d9f5a5611c2c9f419d9f");
 574   CHECK ("12345678901234567890123456789012345678901234567890123456789012345678901234567890",
 575          "57edf4a22be3c955ac49da2e2107b67a");
 576
 577   return TRUE;
 578 }
 579
 580 #endif /* DBUS_BUILD_TESTS */