1 /* md2.c
2 *
3 * The MD2 hash function, described in RFC 1319.
4 *
5 * This code was originally written by M�ller/Sigfridsson for
6 * libnettle. It was altered by B. Poettering to fit the mhash
7 * interface. The original copyright notice follows.
8 */
9
10 /* nettle, low-level cryptographics library
11 *
12 * Copyright (C) 2003 Niels M�ller, Andreas Sigfridsson
13 *
14 * The nettle library is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License as published by
16 * the Free Software Foundation; either version 2.1 of the License, or (at your
17 * option) any later version.
18 *
19 * The nettle library is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
21 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
22 * License for more details.
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * along with the nettle library; see the file COPYING.LIB. If not, write to
26 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
27 * MA 02111-1307, USA.
28 */
29
30 /* This code originates from the Python Cryptography Toolkit, version 1.0.1.
31 Further hacked by Andreas Sigfridsson and Niels M�ller. Original license:
32
33 ===================================================================
34 Distribute and use freely; there are no restrictions on further
35 dissemination and usage except those imposed by the laws of your
36 country of residence. This software is provided "as is" without
37 warranty of fitness for use or suitability for any purpose, express
38 or implied. Use at your own risk or not at all.
39 ===================================================================
40
41 Incorporating the code into commercial products is permitted; you do
42 not have to make source available or contribute your changes back
43 (though that would be nice).
44
45 --amk (www.amk.ca) */
46
47
48 #include "libdefs.h"
49
50 #ifdef ENABLE_MD2
51
52 #include "mhash_md2.h"
53
54 static __const mutils_word8
55 S[256] = {
56 41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
57 19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
58 76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
59 138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
60 245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
61 148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
62 39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
63 181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
64 150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
65 112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
66 96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
67 85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
68 234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
69 129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
70 8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
71 203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
72 166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
73 31, 26, 219, 153, 141, 51, 159, 17, 131, 20
74 };
75
76 static void
md2_transform(struct md2_ctx * ctx,__const mutils_word8 * data)77 md2_transform(struct md2_ctx *ctx, __const mutils_word8 *data)
78 {
79 mutils_word8 i;
80 mutils_word8 j;
81 mutils_word8 t;
82
83 mutils_memcpy(ctx->X + 16, data, MD2_DATA_SIZE);
84
85 for (i = 0, t = ctx->C[15]; i<MD2_DATA_SIZE; i++)
86 {
87 ctx->X[2 * MD2_DATA_SIZE + i]
88 = ctx->X[i] ^ ctx->X[MD2_DATA_SIZE + i];
89 t = (ctx->C[i] ^= S[data[i]^t]);
90 }
91 for (i = t = 0; i< MD2_DATA_SIZE + 2; t = (t + i) & 0xff, i++)
92 {
93 for (j = 0; j < 3 * MD2_DATA_SIZE; j++)
94 t = (ctx->X[j] ^= S[t]);
95 }
96 }
97
98 void
md2_init(struct md2_ctx * ctx)99 md2_init(struct md2_ctx *ctx)
100 {
101 mutils_bzero(ctx, sizeof(*ctx));
102 }
103
104 void
md2_update(struct md2_ctx * ctx,__const mutils_word8 * data,mutils_word32 length)105 md2_update(struct md2_ctx *ctx,
106 __const mutils_word8 *data,
107 mutils_word32 length)
108 {
109 if (ctx->index != 0)
110 {
111 /* Try to fill partial block */
112 mutils_word32 left = MD2_DATA_SIZE - ctx->index;
113 if (length < left)
114 {
115 mutils_memcpy(ctx->buffer + ctx->index, data, length);
116 ctx->index += length;
117 return; /* Finished */
118 }
119 else
120 {
121 mutils_memcpy(ctx->buffer + ctx->index, data, left);
122 md2_transform(ctx, ctx->buffer);
123 data += left;
124 length -= left;
125 }
126 }
127 while (length >= MD2_DATA_SIZE)
128 {
129 md2_transform(ctx, data);
130 data += MD2_DATA_SIZE;
131 length -= MD2_DATA_SIZE;
132 }
133 if ((ctx->index = length) != 0) /* This assignment is intended */
134 /* Buffer leftovers */
135 mutils_memcpy(ctx->buffer, data, length);
136 }
137
138 void
md2_digest(struct md2_ctx * ctx,mutils_word8 * digest)139 md2_digest(struct md2_ctx *ctx, mutils_word8 *digest)
140 {
141 mutils_word8 left;
142
143 left = MD2_DATA_SIZE - ctx->index;
144 mutils_memset(ctx->buffer + ctx->index, left, left);
145 md2_transform(ctx, ctx->buffer);
146
147 md2_transform(ctx, ctx->C);
148 mutils_memcpy(digest, ctx->X, MD2_DIGEST_SIZE);
149 md2_init(ctx);
150 }
151
152 #endif /* ENABLE_MD2 */
153