Debian Codegraph @

core/libs/dngwriter/extra/md5/XMP_MD5.cpp

raw
1 #if AdobePrivate
2 // (c) Copyright 1999. Adobe Systems, Incorporated. All rights reserved.
3 // $Id: $
4
5 // Win can't see directives placed before pre-comp headers
6 #endif
7
8 #include "XMP_MD5.h"
9
10 #include <cassert>
11 #include <cstring>
12
13 using namespace std;
14
15 /******************************************************************************/
16
17 /*
18 MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
19
20 Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights
21 reserved.
22
23 License to copy and use this software is granted provided that it is
24 identified as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm" in
25 all material mentioning or referencing this software or this function.
26
27 License is also granted to make and use derivative works provided that such
28 works are identified as "derived from the RSA Data Security, Inc. MD5
29 Message-Digest Algorithm" in all material mentioning or referencing the
30 derived work.
31
32 RSA Data Security, Inc. makes no representations concerning either the
33 merchantability of this software or the suitability of this software for
34 any particular purpose. It is provided "as is" without express or implied
35 warranty of any kind.
36
37 These notices must be retained in any copies of any part of this
38 documentation and/or software.
39 */
40
41 /******************************************************************************/
42
43 /* Constants for MD5Transform routine. */
44
45 #define S11 7
46 #define S12 12
47 #define S13 17
48 #define S14 22
49 #define S21 5
50 #define S22 9
51 #define S23 14
52 #define S24 20
53 #define S31 4
54 #define S32 11
55 #define S33 16
56 #define S34 23
57 #define S41 6
58 #define S42 10
59 #define S43 15
60 #define S44 21
61
62 static void MD5Transform (XMP_Uns32 [4], XMP_Uns8 [64]);
63 static void Encode (XMP_Uns8 *, XMP_Uns32 *, XMP_Uns32);
64 static void Decode (XMP_Uns32 *, XMP_Uns8 *, XMP_Uns32);
65
66 static XMP_Uns8 PADDING[64] =
67 {
68 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
69 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
70 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
71 };
72
73 /* F, G, H and I are basic MD5 functions.
74
75 */
76
77 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
78 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
79 #define H(x, y, z) ((x) ^ (y) ^ (z))
80 #define I(x, y, z) ((y) ^ ((x) | (~z)))
81
82 /* ROTATE_LEFT rotates x left n bits.
83
84 */
85
86 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
87
88 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
89 Rotation is separate from addition to prevent recomputation.
90
91 */
92
93 #define FF(a, b, c, d, x, s, ac) { \
94 (a) += F ((b), (c), (d)) + (x) + (XMP_Uns32)(ac); \
95 (a) = ROTATE_LEFT ((a), (s)); \
96 (a) += (b); \
97 }
98 #define GG(a, b, c, d, x, s, ac) { \
99 (a) += G ((b), (c), (d)) + (x) + (XMP_Uns32)(ac); \
100 (a) = ROTATE_LEFT ((a), (s)); \
101 (a) += (b); \
102 }
103 #define HH(a, b, c, d, x, s, ac) { \
104 (a) += H ((b), (c), (d)) + (x) + (XMP_Uns32)(ac); \
105 (a) = ROTATE_LEFT ((a), (s)); \
106 (a) += (b); \
107 }
108 #define II(a, b, c, d, x, s, ac) { \
109 (a) += I ((b), (c), (d)) + (x) + (XMP_Uns32)(ac); \
110 (a) = ROTATE_LEFT ((a), (s)); \
111 (a) += (b); \
112 }
113
114 /* MD5 initialization. Begins an MD5 operation, writing a new context.
115
116 */
117
118 void MD5Init (MD5_CTX * context)
119 {
120 context->count[0] = context->count[1] = 0;
121
122 /* Load magic initialization constants.
123
124 */
125 context->state[0] = 0x67452301;
126 context->state[1] = 0xefcdab89;
127 context->state[2] = 0x98badcfe;
128 context->state[3] = 0x10325476;
129 }
130
131 /* MD5 block update operation. Continues an MD5 message-digest
132 operation, processing another message block, and updating the context.
133
134 */
135
136 void MD5Update ( MD5_CTX *context, /* context */
137 XMP_Uns8 *input, /* input block */
138 XMP_Uns32 inputLen) /* length of input block */
139 {
140 using namespace std;
141
142 XMP_Uns32 i, index, partLen;
143
144 /* Compute number of bytes mod 64 */
145 index = (XMP_Uns32)((context->count[0] >> 3) & 0x3F);
146
147 /* Update number of bits */
148 if ((context->count[0] += ((XMP_Uns32)inputLen << 3))
149 < ((XMP_Uns32)inputLen << 3))
150 context->count[1]++;
151 context->count[1] += ((XMP_Uns32)inputLen >> 29);
152
153 partLen = 64 - index;
154
155 /* Transform as many times as possible.
156
157 */
158 if (inputLen >= partLen) {
159 std::memcpy (&context->buffer[index], input, partLen); // AUDIT: From public MD5 code, assumed safe.
160 MD5Transform (context->state, context->buffer);
161
162 for (i = partLen; i + 63 < inputLen; i += 64)
163 MD5Transform (context->state, &input[i]);
164
165 index = 0;
166 }
167 else
168 i = 0;
169
170 /* Buffer remaining input */
171 std::memcpy (&context->buffer[index], &input[i], inputLen-i); // AUDIT: From public MD5 code, assumed safe.
172
173 }
174
175 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
176 the message digest and zeroizing the context.
177
178 */
179
180 void MD5Final ( XMP_Uns8 digest[16], /* message digest */
181 MD5_CTX *context /* context */)
182 {
183 XMP_Uns8 bits[8];
184 XMP_Uns32 index, padLen;
185
186 /* Save number of bits */
187 Encode (bits, context->count, 8);
188
189 /* Pad out to 56 mod 64.
190
191 */
192 index = (XMP_Uns32)((context->count[0] >> 3) & 0x3f);
193 padLen = (index < 56) ? (56 - index) : (120 - index);
194 MD5Update (context, PADDING, padLen);
195
196 /* Append length (before padding) */
197 MD5Update (context, bits, 8);
198 /* Store state in digest */
199 Encode (digest, context->state, 16);
200
201 /* Zeroize sensitive information.
202
203 */
204 assert ( sizeof(*context) == sizeof(MD5_CTX) );
205 memset ( context, 0, sizeof (*context) ); // AUDIT: Safe, using sizeof destination.
206 }
207
208 /* MD5 basic transformation. Transforms state based on block.
209
210 */
211
212 static void MD5Transform ( XMP_Uns32 state[4],
213 XMP_Uns8 block[64])
214 {
215 XMP_Uns32 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
216
217 Decode (x, block, 64);
218
219 /* Round 1 */
220 FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
221 FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
222 FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
223 FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
224 FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
225 FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
226 FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
227 FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
228 FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
229 FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
230 FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
231 FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
232 FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
233 FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
234 FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
235 FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
236
237 /* Round 2 */
238 GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
239 GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
240 GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
241 GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
242 GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
243 GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
244 GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
245 GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
246 GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
247 GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
248 GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
249 GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
250 GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
251 GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
252 GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
253 GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
254
255 /* Round 3 */
256 HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
257 HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
258 HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
259 HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
260 HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
261 HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
262 HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
263 HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
264 HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
265 HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
266 HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
267 HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
268 HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
269 HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
270 HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
271 HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
272
273 /* Round 4 */
274 II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
275 II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
276 II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
277 II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
278 II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
279 II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
280 II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
281 II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
282 II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
283 II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
284 II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
285 II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
286 II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
287 II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
288 II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
289 II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
290
291 state[0] += a;
292 state[1] += b;
293 state[2] += c;
294 state[3] += d;
295
296 /* Zeroize sensitive information.
297 */
298 memset (x, 0, sizeof (x));
299 }
300
301 /* Encodes input (XMP_Uns32) into output (XMP_Uns8). Assumes len is
302 a multiple of 4.
303
304 */
305
306 static void Encode ( XMP_Uns8 *output,
307 XMP_Uns32 *input,
308 XMP_Uns32 len)
309 {
310 XMP_Uns32 i, j;
311
312 for (i = 0, j = 0; j < len; i++, j += 4) {
313 output[j] = (XMP_Uns8)(input[i] & 0xff);
314 output[j+1] = (XMP_Uns8)((input[i] >> 8) & 0xff);
315 output[j+2] = (XMP_Uns8)((input[i] >> 16) & 0xff);
316 output[j+3] = (XMP_Uns8)((input[i] >> 24) & 0xff);
317 }
318 }
319
320 /* Decodes input (XMP_Uns8) into output (XMP_Uns32). Assumes len is
321 a multiple of 4.
322
323 */
324
325 static void Decode ( XMP_Uns32 *output,
326 XMP_Uns8 *input,
327 XMP_Uns32 len)
328 {
329 XMP_Uns32 i, j;
330
331 for (i = 0, j = 0; j < len; i++, j += 4)
332 output[i] = ((XMP_Uns32)input[j]) | (((XMP_Uns32)input[j+1]) << 8) |
333 (((XMP_Uns32)input[j+2]) << 16) | (((XMP_Uns32)input[j+3]) << 24);
334 }