HmacMd5-old.c

   1 /*
   2  **********************************************************************
   3  ** md5.h -- Header file for implementation of MD5                   **
   4  ** RSA Data Security, Inc. MD5 Message Digest Algorithm             **
   5  ** Created: 2/17/90 RLR                                             **
   6  ** Revised: 12/27/90 SRD,AJ,BSK,JT Reference C version              **
   7  ** Revised (for MD5): RLR 4/27/91                                   **
   8  **   -- G modified to have y&~z instead of y&z                      **
   9  **   -- FF, GG, HH modified to add in last register done            **
  10  **   -- Access pattern: round 2 works mod 5, round 3 works mod 3    **
  11  **   -- distinct additive constant for each step                    **
  12  **   -- round 4 added, working mod 7                                **
  13  **********************************************************************
  14  */
  15
  16 /*
  17  **********************************************************************
  18  ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
  19  **                                                                  **
  20  ** License to copy and use this software is granted provided that   **
  21  ** it is identified as the "RSA Data Security, Inc. MD5 Message     **
  22  ** Digest Algorithm" in all material mentioning or referencing this **
  23  ** software or this function.                                       **
  24  **                                                                  **
  25  ** License is also granted to make and use derivative works         **
  26  ** provided that such works are identified as "derived from the RSA **
  27  ** Data Security, Inc. MD5 Message Digest Algorithm" in all         **
  28  ** material mentioning or referencing the derived work.             **
  29  **                                                                  **
  30  ** RSA Data Security, Inc. makes no representations concerning      **
  31  ** either the merchantability of this software or the suitability   **
  32  ** of this software for any particular purpose.  It is provided "as **
  33  ** is" without express or implied warranty of any kind.             **
  34  **                                                                  **
  35  ** These notices must be retained in any copies of any part of this **
  36  ** documentation and/or software.                                   **
  37  **********************************************************************
  38  */
  39
  40 #include "md5.h"
  41
  42 /* typedef a 32 bit type */
  43 typedef unsigned long int UINT4;
  44
  45 /* Data structure for MD5 (Message Digest) computation */
  46 typedef struct {
  47   UINT4 i[2];                   /* number of _bits_ handled mod 2^64 */
  48   UINT4 buf[4];                                    /* scratch buffer */
  49   unsigned char in[64];                              /* input buffer */
  50   unsigned char digest[16];     /* actual digest after MD5Final call */
  51 } MD5_CTX;
  52
  53 void MD5Init ();
  54 void MD5Update ();
  55 void MD5Final ();
  56
  57 /*
  58  **********************************************************************
  59  ** End of md5.h                                                     **
  60  ******************************* (cut) ********************************
  61  */
  62
  63 /*
  64  **********************************************************************
  65  ** md5.c                                                            **
  66  ** RSA Data Security, Inc. MD5 Message Digest Algorithm             **
  67  ** Created: 2/17/90 RLR                                             **
  68  ** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version                  **
  69  **********************************************************************
  70  */
  71
  72 /*
  73  **********************************************************************
  74  ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
  75  **                                                                  **
  76  ** License to copy and use this software is granted provided that   **
  77  ** it is identified as the "RSA Data Security, Inc. MD5 Message     **
  78  ** Digest Algorithm" in all material mentioning or referencing this **
  79  ** software or this function.                                       **
  80  **                                                                  **
  81  ** License is also granted to make and use derivative works         **
  82  ** provided that such works are identified as "derived from the RSA **
  83  ** Data Security, Inc. MD5 Message Digest Algorithm" in all         **
  84  ** material mentioning or referencing the derived work.             **
  85  **                                                                  **
  86  ** RSA Data Security, Inc. makes no representations concerning      **
  87  ** either the merchantability of this software or the suitability   **
  88  ** of this software for any particular purpose.  It is provided "as **
  89  ** is" without express or implied warranty of any kind.             **
  90  **                                                                  **
  91  ** These notices must be retained in any copies of any part of this **
  92  ** documentation and/or software.                                   **
  93  **********************************************************************
  94  */
  95
  96 /* -- include the following line if the md5.h header file is separate -- */
  97 /* #include "md5.h" */
  98
  99 /* forward declaration */
 100 static void Transform ();
 101
 102 static unsigned char PADDING[64] = {
 103   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 104   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 105   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 106   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 107   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 108   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 109   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 110   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 111 };
 112
 113 /* F, G and H are basic MD5 functions: selection, majority, parity */
 114 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
 115 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
 116 #define H(x, y, z) ((x) ^ (y) ^ (z))
 117 #define I(x, y, z) ((y) ^ ((x) | (~z)))
 118
 119 /* ROTATE_LEFT rotates x left n bits */
 120 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
 121
 122 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
 123 /* Rotation is separate from addition to prevent recomputation */
 124 #define FF(a, b, c, d, x, s, ac) \
 125   {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
 126    (a) = ROTATE_LEFT ((a), (s)); \
 127    (a) += (b); \
 128   }
 129 #define GG(a, b, c, d, x, s, ac) \
 130   {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
 131    (a) = ROTATE_LEFT ((a), (s)); \
 132    (a) += (b); \
 133   }
 134 #define HH(a, b, c, d, x, s, ac) \
 135   {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
 136    (a) = ROTATE_LEFT ((a), (s)); \
 137    (a) += (b); \
 138   }
 139 #define II(a, b, c, d, x, s, ac) \
 140   {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
 141    (a) = ROTATE_LEFT ((a), (s)); \
 142    (a) += (b); \
 143   }
 144
 145 void MD5Init (mdContext)
 146 MD5_CTX *mdContext;
 147 {
 148   mdContext->i[0] = mdContext->i[1] = (UINT4)0;
 149
 150   /* Load magic initialization constants.
 151    */
 152   mdContext->buf[0] = (UINT4)0x67452301;
 153   mdContext->buf[1] = (UINT4)0xefcdab89;
 154   mdContext->buf[2] = (UINT4)0x98badcfe;
 155   mdContext->buf[3] = (UINT4)0x10325476;
 156 }
 157
 158 void MD5Update (mdContext, inBuf, inLen)
 159 MD5_CTX *mdContext;
 160 unsigned char *inBuf;
 161 unsigned int inLen;
 162 {
 163   UINT4 in[16];
 164   int mdi;
 165   unsigned int i, ii;
 166
 167   /* compute number of bytes mod 64 */
 168   mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
 169
 170   /* update number of bits */
 171   if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
 172     mdContext->i[1]++;
 173   mdContext->i[0] += ((UINT4)inLen << 3);
 174   mdContext->i[1] += ((UINT4)inLen >> 29);
 175
 176   while (inLen--) {
 177     /* add new character to buffer, increment mdi */
 178     mdContext->in[mdi++] = *inBuf++;
 179
 180     /* transform if necessary */
 181     if (mdi == 0x40) {
 182       for (i = 0, ii = 0; i < 16; i++, ii += 4)
 183         in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
 184                 (((UINT4)mdContext->in[ii+2]) << 16) |
 185                 (((UINT4)mdContext->in[ii+1]) << 8) |
 186                 ((UINT4)mdContext->in[ii]);
 187       Transform (mdContext->buf, in);
 188       mdi = 0;
 189     }
 190   }
 191 }
 192
 193 void MD5Final (mdContext)
 194 MD5_CTX *mdContext;
 195 {
 196   UINT4 in[16];
 197   int mdi;
 198   unsigned int i, ii;
 199   unsigned int padLen;
 200
 201   /* save number of bits */
 202   in[14] = mdContext->i[0];
 203   in[15] = mdContext->i[1];
 204
 205   /* compute number of bytes mod 64 */
 206   mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
 207
 208   /* pad out to 56 mod 64 */
 209   padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
 210   MD5Update (mdContext, PADDING, padLen);
 211
 212   /* append length in bits and transform */
 213   for (i = 0, ii = 0; i < 14; i++, ii += 4)
 214     in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
 215             (((UINT4)mdContext->in[ii+2]) << 16) |
 216             (((UINT4)mdContext->in[ii+1]) << 8) |
 217             ((UINT4)mdContext->in[ii]);
 218   Transform (mdContext->buf, in);
 219
 220   /* store buffer in digest */
 221   for (i = 0, ii = 0; i < 4; i++, ii += 4) {
 222     mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
 223     mdContext->digest[ii+1] =
 224       (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
 225     mdContext->digest[ii+2] =
 226       (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
 227     mdContext->digest[ii+3] =
 228       (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
 229   }
 230 }
 231
 232 /* Basic MD5 step. Transform buf based on in.
 233  */
 234 static void Transform (buf, in)
 235 UINT4 *buf;
 236 UINT4 *in;
 237 {
 238   UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
 239
 240   /* Round 1 */
 241 #define S11 7
 242 #define S12 12
 243 #define S13 17
 244 #define S14 22
 245   FF ( a, b, c, d, in[ 0], S11, 3614090360); /* 1 */
 246   FF ( d, a, b, c, in[ 1], S12, 3905402710); /* 2 */
 247   FF ( c, d, a, b, in[ 2], S13,  606105819); /* 3 */
 248   FF ( b, c, d, a, in[ 3], S14, 3250441966); /* 4 */
 249   FF ( a, b, c, d, in[ 4], S11, 4118548399); /* 5 */
 250   FF ( d, a, b, c, in[ 5], S12, 1200080426); /* 6 */
 251   FF ( c, d, a, b, in[ 6], S13, 2821735955); /* 7 */
 252   FF ( b, c, d, a, in[ 7], S14, 4249261313); /* 8 */
 253   FF ( a, b, c, d, in[ 8], S11, 1770035416); /* 9 */
 254   FF ( d, a, b, c, in[ 9], S12, 2336552879); /* 10 */
 255   FF ( c, d, a, b, in[10], S13, 4294925233); /* 11 */
 256   FF ( b, c, d, a, in[11], S14, 2304563134); /* 12 */
 257   FF ( a, b, c, d, in[12], S11, 1804603682); /* 13 */
 258   FF ( d, a, b, c, in[13], S12, 4254626195); /* 14 */
 259   FF ( c, d, a, b, in[14], S13, 2792965006); /* 15 */
 260   FF ( b, c, d, a, in[15], S14, 1236535329); /* 16 */
 261
 262   /* Round 2 */
 263 #define S21 5
 264 #define S22 9
 265 #define S23 14
 266 #define S24 20
 267   GG ( a, b, c, d, in[ 1], S21, 4129170786); /* 17 */
 268   GG ( d, a, b, c, in[ 6], S22, 3225465664); /* 18 */
 269   GG ( c, d, a, b, in[11], S23,  643717713); /* 19 */
 270   GG ( b, c, d, a, in[ 0], S24, 3921069994); /* 20 */
 271   GG ( a, b, c, d, in[ 5], S21, 3593408605); /* 21 */
 272   GG ( d, a, b, c, in[10], S22,   38016083); /* 22 */
 273   GG ( c, d, a, b, in[15], S23, 3634488961); /* 23 */
 274   GG ( b, c, d, a, in[ 4], S24, 3889429448); /* 24 */
 275   GG ( a, b, c, d, in[ 9], S21,  568446438); /* 25 */
 276   GG ( d, a, b, c, in[14], S22, 3275163606); /* 26 */
 277   GG ( c, d, a, b, in[ 3], S23, 4107603335); /* 27 */
 278   GG ( b, c, d, a, in[ 8], S24, 1163531501); /* 28 */
 279   GG ( a, b, c, d, in[13], S21, 2850285829); /* 29 */
 280   GG ( d, a, b, c, in[ 2], S22, 4243563512); /* 30 */
 281   GG ( c, d, a, b, in[ 7], S23, 1735328473); /* 31 */
 282   GG ( b, c, d, a, in[12], S24, 2368359562); /* 32 */
 283
 284   /* Round 3 */
 285 #define S31 4
 286 #define S32 11
 287 #define S33 16
 288 #define S34 23
 289   HH ( a, b, c, d, in[ 5], S31, 4294588738); /* 33 */
 290   HH ( d, a, b, c, in[ 8], S32, 2272392833); /* 34 */
 291   HH ( c, d, a, b, in[11], S33, 1839030562); /* 35 */
 292   HH ( b, c, d, a, in[14], S34, 4259657740); /* 36 */
 293   HH ( a, b, c, d, in[ 1], S31, 2763975236); /* 37 */
 294   HH ( d, a, b, c, in[ 4], S32, 1272893353); /* 38 */
 295   HH ( c, d, a, b, in[ 7], S33, 4139469664); /* 39 */
 296   HH ( b, c, d, a, in[10], S34, 3200236656); /* 40 */
 297   HH ( a, b, c, d, in[13], S31,  681279174); /* 41 */
 298   HH ( d, a, b, c, in[ 0], S32, 3936430074); /* 42 */
 299   HH ( c, d, a, b, in[ 3], S33, 3572445317); /* 43 */
 300   HH ( b, c, d, a, in[ 6], S34,   76029189); /* 44 */
 301   HH ( a, b, c, d, in[ 9], S31, 3654602809); /* 45 */
 302   HH ( d, a, b, c, in[12], S32, 3873151461); /* 46 */
 303   HH ( c, d, a, b, in[15], S33,  530742520); /* 47 */
 304   HH ( b, c, d, a, in[ 2], S34, 3299628645); /* 48 */
 305
 306   /* Round 4 */
 307 #define S41 6
 308 #define S42 10
 309 #define S43 15
 310 #define S44 21
 311   II ( a, b, c, d, in[ 0], S41, 4096336452); /* 49 */
 312   II ( d, a, b, c, in[ 7], S42, 1126891415); /* 50 */
 313   II ( c, d, a, b, in[14], S43, 2878612391); /* 51 */
 314   II ( b, c, d, a, in[ 5], S44, 4237533241); /* 52 */
 315   II ( a, b, c, d, in[12], S41, 1700485571); /* 53 */
 316   II ( d, a, b, c, in[ 3], S42, 2399980690); /* 54 */
 317   II ( c, d, a, b, in[10], S43, 4293915773); /* 55 */
 318   II ( b, c, d, a, in[ 1], S44, 2240044497); /* 56 */
 319   II ( a, b, c, d, in[ 8], S41, 1873313359); /* 57 */
 320   II ( d, a, b, c, in[15], S42, 4264355552); /* 58 */
 321   II ( c, d, a, b, in[ 6], S43, 2734768916); /* 59 */
 322   II ( b, c, d, a, in[13], S44, 1309151649); /* 60 */
 323   II ( a, b, c, d, in[ 4], S41, 4149444226); /* 61 */
 324   II ( d, a, b, c, in[11], S42, 3174756917); /* 62 */
 325   II ( c, d, a, b, in[ 2], S43,  718787259); /* 63 */
 326   II ( b, c, d, a, in[ 9], S44, 3951481745); /* 64 */
 327
 328   buf[0] += a;
 329   buf[1] += b;
 330   buf[2] += c;
 331   buf[3] += d;
 332 }
 333
 334 /*
 335  **********************************************************************
 336  ** End of md5.c                                                     **
 337  ******************************* (cut) ********************************
 338  */
 339
 340 /*
 341  **********************************************************************
 342  ** md5driver.c -- sample routines to test                           **
 343  ** RSA Data Security, Inc. MD5 message digest algorithm.            **
 344  ** Created: 2/16/90 RLR                                             **
 345  ** Updated: 1/91 SRD                                                **
 346  **********************************************************************
 347  */
 348
 349 /*
 350  **********************************************************************
 351  ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
 352  **                                                                  **
 353  ** RSA Data Security, Inc. makes no representations concerning      **
 354  ** either the merchantability of this software or the suitability   **
 355  ** of this software for any particular purpose.  It is provided "as **
 356  ** is" without express or implied warranty of any kind.             **
 357  **                                                                  **
 358  ** These notices must be retained in any copies of any part of this **
 359  ** documentation and/or software.                                   **
 360  **********************************************************************
 361  */
 362
 363 #include <stdio.h>
 364 #include <sys/types.h>
 365 #include <time.h>
 366 #include <string.h>
 367 /* -- include the following file if the file md5.h is separate -- */
 368 /* #include "md5.h" */
 369
 370 /* Prints message digest buffer in mdContext as 32 hexadecimal digits.
 371    Order is from low-order byte to high-order byte of digest.
 372    Each byte is printed with high-order hexadecimal digit first.
 373  */
 374 static void MDPrint (mdContext)
 375 MD5_CTX *mdContext;
 376 {
 377   int i;
 378
 379   for (i = 0; i < 16; i++)
 380     printf ("%02x", mdContext->digest[i]);
 381 }
 382
 383 /* size of test block */
 384 #define TEST_BLOCK_SIZE 1000
 385
 386 /* number of blocks to process */
 387 #define TEST_BLOCKS 10000
 388
 389 /* number of test bytes = TEST_BLOCK_SIZE * TEST_BLOCKS */
 390 static long TEST_BYTES = (long)TEST_BLOCK_SIZE * (long)TEST_BLOCKS;
 391
 392 /* A time trial routine, to measure the speed of MD5.
 393    Measures wall time required to digest TEST_BLOCKS * TEST_BLOCK_SIZE
 394    characters.
 395  */
 396 static void MDTimeTrial ()
 397 {
 398   MD5_CTX mdContext;
 399   time_t endTime, startTime;
 400   unsigned char data[TEST_BLOCK_SIZE];
 401   unsigned int i;
 402
 403   /* initialize test data */
 404   for (i = 0; i < TEST_BLOCK_SIZE; i++)
 405     data[i] = (unsigned char)(i & 0xFF);
 406
 407   /* start timer */
 408   printf ("MD5 time trial. Processing %ld characters...\n", TEST_BYTES);
 409   time (&startTime);
 410
 411   /* digest data in TEST_BLOCK_SIZE byte blocks */
 412   MD5Init (&mdContext);
 413   for (i = TEST_BLOCKS; i > 0; i--)
 414     MD5Update (&mdContext, data, TEST_BLOCK_SIZE);
 415   MD5Final (&mdContext);
 416
 417   /* stop timer, get time difference */
 418   time (&endTime);
 419   MDPrint (&mdContext);
 420   printf (" is digest of test input.\n");
 421   printf
 422     ("Seconds to process test input: %ld\n", (long)(endTime-startTime));
 423   printf
 424     ("Characters processed per second: %ld\n",
 425      TEST_BYTES/(endTime-startTime));
 426 }
 427
 428 /* Computes the message digest for string inString.
 429    Prints out message digest, a space, the string (in quotes) and a
 430    carriage return.
 431  */
 432 static void MDString (inString)
 433 char *inString;
 434 {
 435   MD5_CTX mdContext;
 436   unsigned int len = strlen (inString);
 437
 438   MD5Init (&mdContext);
 439   MD5Update (&mdContext, inString, len);
 440   MD5Final (&mdContext);
 441   MDPrint (&mdContext);
 442   printf (" \"%s\"\n\n", inString);
 443 }
 444
 445 /* Computes the message digest for a specified file.
 446    Prints out message digest, a space, the file name, and a carriage
 447    return.
 448  */
 449 static void MDFile (filename)
 450 char *filename;
 451 {
 452   FILE *inFile = fopen (filename, "rb");
 453   MD5_CTX mdContext;
 454   int bytes;
 455   unsigned char data[1024];
 456
 457   if (inFile == NULL) {
 458     printf ("%s can't be opened.\n", filename);
 459     return;
 460   }
 461
 462   MD5Init (&mdContext);
 463   while ((bytes = fread (data, 1, 1024, inFile)) != 0)
 464     MD5Update (&mdContext, data, bytes);
 465   MD5Final (&mdContext);
 466   MDPrint (&mdContext);
 467   printf (" %s\n", filename);
 468   fclose (inFile);
 469 }
 470
 471 /* Writes the message digest of the data from stdin onto stdout,
 472    followed by a carriage return.
 473  */
 474 static void MDFilter ()
 475 {
 476   MD5_CTX mdContext;
 477   int bytes;
 478   unsigned char data[16];
 479
 480   MD5Init (&mdContext);
 481   while ((bytes = fread (data, 1, 16, stdin)) != 0)
 482     MD5Update (&mdContext, data, bytes);
 483   MD5Final (&mdContext);
 484   MDPrint (&mdContext);
 485   printf ("\n");
 486 }
 487
 488 /* Runs a standard suite of test data.
 489  */
 490 static void MDTestSuite ()
 491 {
 492   printf ("MD5 test suite results:\n\n");
 493   MDString ("");
 494   MDString ("a");
 495   MDString ("abc");
 496   MDString ("message digest");
 497   MDString ("abcdefghijklmnopqrstuvwxyz");
 498   MDString
 499     ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
 500   MDString
 501     ("1234567890123456789012345678901234567890\
 502 1234567890123456789012345678901234567890");
 503   /* Contents of file foo are "abc" */
 504   MDFile ("foo");
 505 }
 506
 507 static void MD5 (mdContext, inString)
 508 MD5_CTX * mdContext;
 509 char  * inString;
 510 {
 511   unsigned int len = strlen (inString);
 512
 513   MD5Init (mdContext);
 514   MD5Update (mdContext, inString, len);
 515   MD5Final (mdContext);
 516 }
 517
 518 static void MDPrintDebug (digest)
 519 unsigned char digest[16];
 520 {
 521   int i;
 522
 523   for (i = 0; i < 16; i++)
 524     printf ("%02x", digest[i]);
 525 }
 526
 527 static void MDHmac (key, inString)
 528 unsigned char * key;
 529 unsigned char * inString;
 530 {
 531   mbedtls_md5_context mdContext;
 532   unsigned int keylen;
 533   int pos;
 534   unsigned char ipad[64];
 535   unsigned char opad[64];
 536   unsigned char hash[16];
 537
 538   // Ensure key length is exaclty 16 bytes
 539   keylen = strlen(key);
 540   if (keylen > 64) {
 541     mbedtls_md5(key, keylen, hash);
 542     memcpy(ipad, hash, 16);
 543     memcpy(opad, hash, 16);
 544     keylen = 16;
 545   }
 546   else {
 547     memcpy(ipad, key, keylen);
 548     memcpy(opad, key, keylen);
 549   }
 550   for (pos = keylen; pos < 64; pos++) {
 551     ipad[pos] = '\0';
 552     opad[pos] = '\0';
 553   }
 554
 555   for (pos = 0; pos < 64; pos++) {
 556     ipad[pos] ^= 0x36;
 557     opad[pos] ^= 0x5C;
 558   }
 559
 560   mbedtls_md5_init(& mdContext);
 561   mbedtls_md5_starts(& mdContext);
 562   mbedtls_md5_update(& mdContext, ipad, 64);
 563   mbedtls_md5_update(& mdContext, inString, strlen(inString));
 564   mbedtls_md5_finish(& mdContext, hash);
 565   mbedtls_md5_free(& mdContext);
 566
 567   mbedtls_md5_init(& mdContext);
 568   mbedtls_md5_starts(& mdContext);
 569   mbedtls_md5_update(& mdContext, opad, 64);
 570   mbedtls_md5_update(& mdContext, hash, 16);
 571   mbedtls_md5_finish(& mdContext, hash);
 572   mbedtls_md5_free(& mdContext);
 573
 574   MDPrintDebug (hash);
 575   printf ("\n");
 576 }
 577
 578 static void MDTestHmac ()
 579 {
 580   unsigned char output[16];
 581   mbedtls_md5("Hello", 5, output);
 582   MDPrintDebug(output);
 583   printf ("\n");
 584
 585   MDHmac ("key", "The quick brown fox jumps over the lazy dog");
 586 }
 587
 588 void main (argc, argv)
 589 int argc;
 590 char *argv[];
 591 {
 592   int i;
 593
 594   /* For each command line argument in turn:
 595   ** filename          -- prints message digest and name of file
 596   ** -sstring          -- prints message digest and contents of string
 597   ** -t                -- prints time trial statistics for 1M characters
 598   ** -x                -- execute a standard suite of test data
 599   ** (no args)         -- writes messages digest of stdin onto stdout
 600   */
 601   if (argc == 1)
 602     MDFilter ();
 603   else
 604     for (i = 1; i < argc; i++)
 605       if (argv[i][0] == '-' && argv[i][1] == 's')
 606         MDString (argv[i] + 2);
 607       else if (strcmp (argv[i], "-t") == 0)
 608         MDTimeTrial ();
 609       else if (strcmp (argv[i], "-x") == 0)
 610         MDTestSuite ();
 611       else if (strcmp (argv[i], "-h") == 0)
 612         MDTestHmac ();
 613       else MDFile (argv[i]);
 614 }
 615
 616 /*
 617  **********************************************************************
 618  ** End of md5driver.c                                               **
 619  ******************************* (cut) ********************************
 620  */