lib/libmd/md2c.c

   1 /* MD2C.C - RSA Data Security, Inc., MD2 message-digest algorithm
   2  * $FreeBSD: src/lib/libmd/md2c.c,v 1.11 2006/01/17 15:35:56 phk Exp $
   3  * $DragonFly: src/lib/libmd/md2c.c,v 1.4 2008/09/30 16:57:05 swildner Exp $
   4  */
   5
   6 /* Copyright (C) 1990-2, RSA Data Security, Inc. Created 1990. All
   7    rights reserved.
   8
   9    License to copy and use this software is granted for
  10    non-commercial Internet Privacy-Enhanced Mail provided that it is
  11    identified as the "RSA Data Security, Inc. MD2 Message Digest
  12    Algorithm" in all material mentioning or referencing this software
  13    or this function.
  14
  15    RSA Data Security, Inc. makes no representations concerning either
  16    the merchantability of this software or the suitability of this
  17    software for any particular purpose. It is provided "as is"
  18    without express or implied warranty of any kind.
  19
  20    These notices must be retained in any copies of any part of this
  21    documentation and/or software.
  22  */
  23
  24 #include <sys/types.h>
  25 #include <string.h>
  26 #include "md2.h"
  27
  28
  29 typedef unsigned char *POINTER;
  30 typedef u_int16_t UINT2;
  31 typedef u_int32_t UINT4;
  32
  33 #define PROTO_LIST(list) list
  34
  35 static void MD2Transform PROTO_LIST
  36   ((unsigned char [16], unsigned char [16], const unsigned char [16]));
  37
  38 /* Permutation of 0..255 constructed from the digits of pi. It gives a
  39    "random" nonlinear byte substitution operation.
  40  */
  41 static unsigned char PI_SUBST[256] = {
  42   41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
  43   19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
  44   76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
  45   138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
  46   245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
  47   148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
  48   39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
  49   181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
  50   150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
  51   112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
  52   96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
  53   85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
  54   234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
  55   129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
  56   8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
  57   203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
  58   166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
  59   31, 26, 219, 153, 141, 51, 159, 17, 131, 20
  60 };
  61
  62 static unsigned char *PADDING[] = {
  63   (unsigned char *)"",
  64   (unsigned char *)"\001",
  65   (unsigned char *)"\002\002",
  66   (unsigned char *)"\003\003\003",
  67   (unsigned char *)"\004\004\004\004",
  68   (unsigned char *)"\005\005\005\005\005",
  69   (unsigned char *)"\006\006\006\006\006\006",
  70   (unsigned char *)"\007\007\007\007\007\007\007",
  71   (unsigned char *)"\010\010\010\010\010\010\010\010",
  72   (unsigned char *)"\011\011\011\011\011\011\011\011\011",
  73   (unsigned char *)"\012\012\012\012\012\012\012\012\012\012",
  74   (unsigned char *)"\013\013\013\013\013\013\013\013\013\013\013",
  75   (unsigned char *)"\014\014\014\014\014\014\014\014\014\014\014\014",
  76   (unsigned char *)
  77     "\015\015\015\015\015\015\015\015\015\015\015\015\015",
  78   (unsigned char *)
  79     "\016\016\016\016\016\016\016\016\016\016\016\016\016\016",
  80   (unsigned char *)
  81     "\017\017\017\017\017\017\017\017\017\017\017\017\017\017\017",
  82   (unsigned char *)
  83     "\020\020\020\020\020\020\020\020\020\020\020\020\020\020\020\020"
  84 };
  85
  86 /* MD2 initialization. Begins an MD2 operation, writing a new context.
  87  */
  88 int
  89 MD2Init (MD2_CTX *context)
  90 {
  91   context->count = 0;
  92   memset ((POINTER)context->state, 0, sizeof (context->state));
  93   memset
  94     ((POINTER)context->checksum, 0, sizeof (context->checksum));
  95   return 1;
  96 }
  97
  98 /* MD2 block update operation. Continues an MD2 message-digest
  99      operation, processing another message block, and updating the
 100      context.
 101  */
 102 void
 103 MD2Update (MD2_CTX *context, const void *in, unsigned int inputLen)
 104 {
 105   unsigned int i, idx, partLen;
 106   const unsigned char *input = in;
 107
 108   /* Update number of bytes mod 16 */
 109   idx = context->count;
 110   context->count = (idx + inputLen) & 0xf;
 111
 112   partLen = 16 - idx;
 113
 114   /* Transform as many times as possible.
 115     */
 116   if (inputLen >= partLen) {
 117     memcpy
 118       ((POINTER)&context->buffer[idx], (POINTER)input, partLen);
 119     MD2Transform (context->state, context->checksum, context->buffer);
 120
 121     for (i = partLen; i + 15 < inputLen; i += 16)
 122       MD2Transform (context->state, context->checksum, &input[i]);
 123
 124     idx = 0;
 125   }
 126   else
 127     i = 0;
 128
 129   /* Buffer remaining input */
 130   memcpy
 131     ((POINTER)&context->buffer[idx], (POINTER)&input[i],
 132      inputLen-i);
 133 }
 134
 135 /* MD2 padding.
 136  */
 137 void
 138 MD2Pad (MD2_CTX *context)
 139 {
 140   unsigned int idx, padLen;
 141
 142   /* Pad out to multiple of 16.
 143    */
 144   idx = context->count;
 145   padLen = 16 - idx;
 146   MD2Update (context, PADDING[padLen], padLen);
 147
 148   /* Extend with checksum */
 149   MD2Update (context, context->checksum, 16);
 150 }
 151
 152 /* MD2 finalization. Ends an MD2 message-digest operation, writing the
 153      message digest and zeroizing the context.
 154  */
 155 void
 156 MD2Final (unsigned char digest[16], MD2_CTX *context)
 157 {
 158   /* Do padding */
 159   MD2Pad (context);
 160
 161   /* Store state in digest */
 162   memcpy ((POINTER)digest, (POINTER)context->state, 16);
 163
 164   /* Zeroize sensitive information.
 165    */
 166   memset ((POINTER)context, 0, sizeof (*context));
 167 }
 168
 169 /* MD2 basic transformation. Transforms state and updates checksum
 170      based on block.
 171  */
 172 static void
 173 MD2Transform (unsigned char state[16], unsigned char checksum[16],
 174     const unsigned char block[16])
 175 {
 176   unsigned int i, j, t;
 177   unsigned char x[48];
 178
 179   /* Form encryption block from state, block, state ^ block.
 180    */
 181   memcpy ((POINTER)x, (POINTER)state, 16);
 182   memcpy ((POINTER)x+16, (POINTER)block, 16);
 183   for (i = 0; i < 16; i++)
 184     x[i+32] = state[i] ^ block[i];
 185
 186   /* Encrypt block (18 rounds).
 187    */
 188   t = 0;
 189   for (i = 0; i < 18; i++) {
 190     for (j = 0; j < 48; j++)
 191       t = x[j] ^= PI_SUBST[t];
 192     t = (t + i) & 0xff;
 193   }
 194
 195   /* Save new state */
 196   memcpy ((POINTER)state, (POINTER)x, 16);
 197
 198   /* Update checksum.
 199    */
 200   t = checksum[15];
 201   for (i = 0; i < 16; i++)
 202     t = checksum[i] ^= PI_SUBST[block[i] ^ t];
 203
 204   /* Zeroize sensitive information.
 205    */
 206   memset ((POINTER)x, 0, sizeof (x));
 207 }