]> git.saurik.com Git - apt.git/blame_incremental - apt-pkg/contrib/md5.cc
* apt-inst/deb/debfile.h:
[apt.git] / apt-pkg / contrib / md5.cc
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3// $Id: md5.cc,v 1.12 2001/05/13 05:15:03 jgg Exp $
4/* ######################################################################
5
6 MD5Sum - MD5 Message Digest Algorithm.
7
8 This code implements the MD5 message-digest algorithm. The algorithm is
9 due to Ron Rivest. This code was written by Colin Plumb in 1993, no
10 copyright is claimed. This code is in the public domain; do with it what
11 you wish.
12
13 Equivalent code is available from RSA Data Security, Inc. This code has
14 been tested against that, and is equivalent, except that you don't need to
15 include two pages of legalese with every copy.
16
17 To compute the message digest of a chunk of bytes, instantiate the class,
18 and repeatedly call one of the Add() members. When finished the Result
19 method will return the Hash and finalize the value.
20
21 Changed so as no longer to depend on Colin Plumb's `usual.h' header
22 definitions; now uses stuff from dpkg's config.h.
23 - Ian Jackson <ijackson@nyx.cs.du.edu>.
24
25 Changed into a C++ interface and made work with APT's config.h.
26 - Jason Gunthorpe <jgg@gpu.srv.ualberta.ca>
27
28 Still in the public domain.
29
30 The classes use arrays of char that are a specific size. We cast those
31 arrays to uint8_t's and go from there. This allows us to advoid using
32 the uncommon inttypes.h in a public header or internally newing memory.
33 In theory if C9x becomes nicely accepted
34
35 ##################################################################### */
36 /*}}}*/
37// Include Files /*{{{*/
38#include <config.h>
39
40#include <apt-pkg/md5.h>
41#include <apt-pkg/strutl.h>
42#include <apt-pkg/macros.h>
43
44#include <string.h>
45#include <unistd.h>
46#include <netinet/in.h> // For htonl
47#include <inttypes.h>
48 /*}}}*/
49
50// byteSwap - Swap bytes in a buffer /*{{{*/
51// ---------------------------------------------------------------------
52/* Swap n 32 bit longs in given buffer */
53#ifdef WORDS_BIGENDIAN
54static void byteSwap(uint32_t *buf, unsigned words)
55{
56 uint8_t *p = (uint8_t *)buf;
57
58 do
59 {
60 *buf++ = (uint32_t)((unsigned)p[3] << 8 | p[2]) << 16 |
61 ((unsigned)p[1] << 8 | p[0]);
62 p += 4;
63 } while (--words);
64}
65#else
66#define byteSwap(buf,words)
67#endif
68 /*}}}*/
69// MD5Transform - Alters an existing MD5 hash /*{{{*/
70// ---------------------------------------------------------------------
71/* The core of the MD5 algorithm, this alters an existing MD5 hash to
72 reflect the addition of 16 longwords of new data. Add blocks
73 the data and converts bytes into longwords for this routine. */
74
75// The four core functions - F1 is optimized somewhat
76// #define F1(x, y, z) (x & y | ~x & z)
77#define F1(x, y, z) (z ^ (x & (y ^ z)))
78#define F2(x, y, z) F1(z, x, y)
79#define F3(x, y, z) (x ^ y ^ z)
80#define F4(x, y, z) (y ^ (x | ~z))
81
82// This is the central step in the MD5 algorithm.
83#define MD5STEP(f,w,x,y,z,in,s) \
84 (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
85
86static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
87{
88 register uint32_t a, b, c, d;
89
90 a = buf[0];
91 b = buf[1];
92 c = buf[2];
93 d = buf[3];
94
95 MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
96 MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
97 MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
98 MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
99 MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
100 MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
101 MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
102 MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
103 MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
104 MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
105 MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
106 MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
107 MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
108 MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
109 MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
110 MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
111
112 MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
113 MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
114 MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
115 MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
116 MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
117 MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
118 MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
119 MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
120 MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
121 MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
122 MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
123 MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
124 MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
125 MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
126 MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
127 MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
128
129 MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
130 MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
131 MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
132 MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
133 MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
134 MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
135 MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
136 MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
137 MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
138 MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
139 MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
140 MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
141 MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
142 MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
143 MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
144 MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
145
146 MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
147 MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
148 MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
149 MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
150 MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
151 MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
152 MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
153 MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
154 MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
155 MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
156 MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
157 MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
158 MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
159 MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
160 MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
161 MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
162
163 buf[0] += a;
164 buf[1] += b;
165 buf[2] += c;
166 buf[3] += d;
167}
168 /*}}}*/
169// MD5Summation::MD5Summation - Initialize the summer /*{{{*/
170// ---------------------------------------------------------------------
171/* This assigns the deep magic initial values */
172MD5Summation::MD5Summation()
173{
174 uint32_t *buf = (uint32_t *)Buf;
175 uint32_t *bytes = (uint32_t *)Bytes;
176
177 buf[0] = 0x67452301;
178 buf[1] = 0xefcdab89;
179 buf[2] = 0x98badcfe;
180 buf[3] = 0x10325476;
181
182 bytes[0] = 0;
183 bytes[1] = 0;
184 Done = false;
185}
186 /*}}}*/
187// MD5Summation::Add - 'Add' a data set to the hash /*{{{*/
188// ---------------------------------------------------------------------
189/* */
190bool MD5Summation::Add(const unsigned char *data,unsigned long long len)
191{
192 if (Done == true)
193 return false;
194
195 uint32_t *buf = (uint32_t *)Buf;
196 uint32_t *bytes = (uint32_t *)Bytes;
197 uint32_t *in = (uint32_t *)In;
198
199 // Update byte count and carry (this could be done with a long long?)
200 uint32_t t = bytes[0];
201 if ((bytes[0] = t + len) < t)
202 bytes[1]++;
203
204 // Space available (at least 1)
205 t = 64 - (t & 0x3f);
206 if (t > len)
207 {
208 memcpy((unsigned char *)in + 64 - t,data,len);
209 return true;
210 }
211
212 // First chunk is an odd size
213 memcpy((unsigned char *)in + 64 - t,data,t);
214 byteSwap(in, 16);
215 MD5Transform(buf,in);
216 data += t;
217 len -= t;
218
219 // Process data in 64-byte chunks
220 while (len >= 64)
221 {
222 memcpy(in,data,64);
223 byteSwap(in,16);
224 MD5Transform(buf,in);
225 data += 64;
226 len -= 64;
227 }
228
229 // Handle any remaining bytes of data.
230 memcpy(in,data,len);
231
232 return true;
233}
234 /*}}}*/
235// MD5Summation::Result - Returns the value of the sum /*{{{*/
236// ---------------------------------------------------------------------
237/* Because this must add in the last bytes of the series it prevents anyone
238 from calling add after. */
239MD5SumValue MD5Summation::Result()
240{
241 uint32_t *buf = (uint32_t *)Buf;
242 uint32_t *bytes = (uint32_t *)Bytes;
243 uint32_t *in = (uint32_t *)In;
244
245 if (Done == false)
246 {
247 // Number of bytes in In
248 int count = bytes[0] & 0x3f;
249 unsigned char *p = (unsigned char *)in + count;
250
251 // Set the first char of padding to 0x80. There is always room.
252 *p++ = 0x80;
253
254 // Bytes of padding needed to make 56 bytes (-8..55)
255 count = 56 - 1 - count;
256
257 // Padding forces an extra block
258 if (count < 0)
259 {
260 memset(p,0,count + 8);
261 byteSwap(in, 16);
262 MD5Transform(buf,in);
263 p = (unsigned char *)in;
264 count = 56;
265 }
266
267 memset(p, 0, count);
268 byteSwap(in, 14);
269
270 // Append length in bits and transform
271 in[14] = bytes[0] << 3;
272 in[15] = bytes[1] << 3 | bytes[0] >> 29;
273 MD5Transform(buf,in);
274 byteSwap(buf,4);
275 Done = true;
276 }
277
278 MD5SumValue V;
279 V.Set((unsigned char *)buf);
280 return V;
281}
282 /*}}}*/