1.1.2
by Marek Habersack
Import upstream version 1.14 |
1 |
/* md5-compress.c
|
2 |
*
|
|
3 |
* The compression function for the sha1 hash function.
|
|
4 |
*
|
|
5 |
*/
|
|
6 |
||
7 |
/* nettle, low-level cryptographics library
|
|
8 |
*
|
|
1.5.1
by Magnus Holmgren
Import upstream version 2.5 |
9 |
* Copyright (C) 2001, 2005 Niels Möller
|
1.1.2
by Marek Habersack
Import upstream version 1.14 |
10 |
*
|
11 |
* The nettle library is free software; you can redistribute it and/or modify
|
|
12 |
* it under the terms of the GNU Lesser General Public License as published by
|
|
13 |
* the Free Software Foundation; either version 2.1 of the License, or (at your
|
|
14 |
* option) any later version.
|
|
15 |
*
|
|
16 |
* The nettle library is distributed in the hope that it will be useful, but
|
|
17 |
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
18 |
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
19 |
* License for more details.
|
|
20 |
*
|
|
21 |
* You should have received a copy of the GNU Lesser General Public License
|
|
22 |
* along with the nettle library; see the file COPYING.LIB. If not, write to
|
|
1.5.2
by Magnus Holmgren
Import upstream version 2.6 |
23 |
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
24 |
* MA 02111-1301, USA.
|
|
1.1.2
by Marek Habersack
Import upstream version 1.14 |
25 |
*/
|
26 |
||
27 |
/* Based on public domain code hacked by Colin Plumb, Andrew Kuchling, and
|
|
1.5.1
by Magnus Holmgren
Import upstream version 2.5 |
28 |
* Niels Möller. */
|
1.1.2
by Marek Habersack
Import upstream version 1.14 |
29 |
|
30 |
||
31 |
#if HAVE_CONFIG_H
|
|
32 |
# include "config.h"
|
|
33 |
#endif
|
|
34 |
||
35 |
#ifndef MD5_DEBUG
|
|
36 |
# define MD5_DEBUG 0
|
|
37 |
#endif
|
|
38 |
||
39 |
#if MD5_DEBUG
|
|
40 |
# include <stdio.h>
|
|
41 |
# define DEBUG(i) \
|
|
42 |
fprintf(stderr, "%2d: %8x %8x %8x %8x\n", i, a, b, c, d)
|
|
43 |
#else
|
|
44 |
# define DEBUG(i)
|
|
45 |
#endif
|
|
46 |
||
47 |
#include <assert.h> |
|
48 |
#include <stdlib.h> |
|
49 |
#include <string.h> |
|
50 |
||
51 |
#include "md5.h" |
|
52 |
||
53 |
#include "macros.h" |
|
54 |
||
55 |
/* A block, treated as a sequence of 32-bit words. */
|
|
56 |
#define MD5_DATA_LENGTH 16
|
|
57 |
||
58 |
/* MD5 functions */
|
|
59 |
||
60 |
#define F1(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
|
|
61 |
#define F2(x, y, z) F1((z), (x), (y))
|
|
62 |
#define F3(x, y, z) ((x) ^ (y) ^ (z))
|
|
63 |
#define F4(x, y, z) ((y) ^ ((x) | ~(z)))
|
|
64 |
||
65 |
#define ROUND(f, w, x, y, z, data, s) \
|
|
66 |
( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
|
|
67 |
||
68 |
/* Perform the MD5 transformation on one full block of 16 32-bit
|
|
69 |
* words.
|
|
70 |
*
|
|
71 |
* Compresses 20 (_MD5_DIGEST_LENGTH + MD5_DATA_LENGTH) words into 4
|
|
72 |
* (_MD5_DIGEST_LENGTH) words. */
|
|
73 |
||
74 |
void
|
|
75 |
_nettle_md5_compress(uint32_t *digest, const uint8_t *input) |
|
76 |
{
|
|
77 |
uint32_t data[MD5_DATA_LENGTH]; |
|
78 |
uint32_t a, b, c, d; |
|
79 |
unsigned i; |
|
80 |
||
81 |
for (i = 0; i < MD5_DATA_LENGTH; i++, input += 4) |
|
82 |
data[i] = LE_READ_UINT32(input); |
|
83 |
||
84 |
a = digest[0]; |
|
85 |
b = digest[1]; |
|
86 |
c = digest[2]; |
|
87 |
d = digest[3]; |
|
88 |
||
89 |
DEBUG(-1); |
|
90 |
ROUND(F1, a, b, c, d, data[ 0] + 0xd76aa478, 7); DEBUG(0); |
|
91 |
ROUND(F1, d, a, b, c, data[ 1] + 0xe8c7b756, 12); DEBUG(1); |
|
92 |
ROUND(F1, c, d, a, b, data[ 2] + 0x242070db, 17); |
|
93 |
ROUND(F1, b, c, d, a, data[ 3] + 0xc1bdceee, 22); |
|
94 |
ROUND(F1, a, b, c, d, data[ 4] + 0xf57c0faf, 7); |
|
95 |
ROUND(F1, d, a, b, c, data[ 5] + 0x4787c62a, 12); |
|
96 |
ROUND(F1, c, d, a, b, data[ 6] + 0xa8304613, 17); |
|
97 |
ROUND(F1, b, c, d, a, data[ 7] + 0xfd469501, 22); |
|
98 |
ROUND(F1, a, b, c, d, data[ 8] + 0x698098d8, 7); |
|
99 |
ROUND(F1, d, a, b, c, data[ 9] + 0x8b44f7af, 12); |
|
100 |
ROUND(F1, c, d, a, b, data[10] + 0xffff5bb1, 17); |
|
101 |
ROUND(F1, b, c, d, a, data[11] + 0x895cd7be, 22); |
|
102 |
ROUND(F1, a, b, c, d, data[12] + 0x6b901122, 7); |
|
103 |
ROUND(F1, d, a, b, c, data[13] + 0xfd987193, 12); |
|
104 |
ROUND(F1, c, d, a, b, data[14] + 0xa679438e, 17); |
|
105 |
ROUND(F1, b, c, d, a, data[15] + 0x49b40821, 22); DEBUG(15); |
|
106 |
||
107 |
ROUND(F2, a, b, c, d, data[ 1] + 0xf61e2562, 5); DEBUG(16); |
|
108 |
ROUND(F2, d, a, b, c, data[ 6] + 0xc040b340, 9); DEBUG(17); |
|
109 |
ROUND(F2, c, d, a, b, data[11] + 0x265e5a51, 14); |
|
110 |
ROUND(F2, b, c, d, a, data[ 0] + 0xe9b6c7aa, 20); |
|
111 |
ROUND(F2, a, b, c, d, data[ 5] + 0xd62f105d, 5); |
|
112 |
ROUND(F2, d, a, b, c, data[10] + 0x02441453, 9); |
|
113 |
ROUND(F2, c, d, a, b, data[15] + 0xd8a1e681, 14); |
|
114 |
ROUND(F2, b, c, d, a, data[ 4] + 0xe7d3fbc8, 20); |
|
115 |
ROUND(F2, a, b, c, d, data[ 9] + 0x21e1cde6, 5); |
|
116 |
ROUND(F2, d, a, b, c, data[14] + 0xc33707d6, 9); |
|
117 |
ROUND(F2, c, d, a, b, data[ 3] + 0xf4d50d87, 14); |
|
118 |
ROUND(F2, b, c, d, a, data[ 8] + 0x455a14ed, 20); |
|
119 |
ROUND(F2, a, b, c, d, data[13] + 0xa9e3e905, 5); |
|
120 |
ROUND(F2, d, a, b, c, data[ 2] + 0xfcefa3f8, 9); |
|
121 |
ROUND(F2, c, d, a, b, data[ 7] + 0x676f02d9, 14); |
|
122 |
ROUND(F2, b, c, d, a, data[12] + 0x8d2a4c8a, 20); DEBUG(31); |
|
123 |
||
124 |
ROUND(F3, a, b, c, d, data[ 5] + 0xfffa3942, 4); DEBUG(32); |
|
125 |
ROUND(F3, d, a, b, c, data[ 8] + 0x8771f681, 11); DEBUG(33); |
|
126 |
ROUND(F3, c, d, a, b, data[11] + 0x6d9d6122, 16); |
|
127 |
ROUND(F3, b, c, d, a, data[14] + 0xfde5380c, 23); |
|
128 |
ROUND(F3, a, b, c, d, data[ 1] + 0xa4beea44, 4); |
|
129 |
ROUND(F3, d, a, b, c, data[ 4] + 0x4bdecfa9, 11); |
|
130 |
ROUND(F3, c, d, a, b, data[ 7] + 0xf6bb4b60, 16); |
|
131 |
ROUND(F3, b, c, d, a, data[10] + 0xbebfbc70, 23); |
|
132 |
ROUND(F3, a, b, c, d, data[13] + 0x289b7ec6, 4); |
|
133 |
ROUND(F3, d, a, b, c, data[ 0] + 0xeaa127fa, 11); |
|
134 |
ROUND(F3, c, d, a, b, data[ 3] + 0xd4ef3085, 16); |
|
135 |
ROUND(F3, b, c, d, a, data[ 6] + 0x04881d05, 23); |
|
136 |
ROUND(F3, a, b, c, d, data[ 9] + 0xd9d4d039, 4); |
|
137 |
ROUND(F3, d, a, b, c, data[12] + 0xe6db99e5, 11); |
|
138 |
ROUND(F3, c, d, a, b, data[15] + 0x1fa27cf8, 16); |
|
139 |
ROUND(F3, b, c, d, a, data[ 2] + 0xc4ac5665, 23); DEBUG(47); |
|
140 |
||
141 |
ROUND(F4, a, b, c, d, data[ 0] + 0xf4292244, 6); DEBUG(48); |
|
142 |
ROUND(F4, d, a, b, c, data[ 7] + 0x432aff97, 10); DEBUG(49); |
|
143 |
ROUND(F4, c, d, a, b, data[14] + 0xab9423a7, 15); |
|
144 |
ROUND(F4, b, c, d, a, data[ 5] + 0xfc93a039, 21); |
|
145 |
ROUND(F4, a, b, c, d, data[12] + 0x655b59c3, 6); |
|
146 |
ROUND(F4, d, a, b, c, data[ 3] + 0x8f0ccc92, 10); |
|
147 |
ROUND(F4, c, d, a, b, data[10] + 0xffeff47d, 15); |
|
148 |
ROUND(F4, b, c, d, a, data[ 1] + 0x85845dd1, 21); |
|
149 |
ROUND(F4, a, b, c, d, data[ 8] + 0x6fa87e4f, 6); |
|
150 |
ROUND(F4, d, a, b, c, data[15] + 0xfe2ce6e0, 10); |
|
151 |
ROUND(F4, c, d, a, b, data[ 6] + 0xa3014314, 15); |
|
152 |
ROUND(F4, b, c, d, a, data[13] + 0x4e0811a1, 21); |
|
153 |
ROUND(F4, a, b, c, d, data[ 4] + 0xf7537e82, 6); |
|
154 |
ROUND(F4, d, a, b, c, data[11] + 0xbd3af235, 10); |
|
155 |
ROUND(F4, c, d, a, b, data[ 2] + 0x2ad7d2bb, 15); |
|
156 |
ROUND(F4, b, c, d, a, data[ 9] + 0xeb86d391, 21); DEBUG(63); |
|
157 |
||
158 |
digest[0] += a; |
|
159 |
digest[1] += b; |
|
160 |
digest[2] += c; |
|
161 |
digest[3] += d; |
|
162 |
#if MD5_DEBUG
|
|
163 |
fprintf(stderr, "99: %8x %8x %8x %8x\n", |
|
164 |
digest[0], digest[1], digest[2], digest[3]); |
|
165 |
#endif
|
|
166 |
||
167 |
}
|