doxygen: prevent GPL license block from being parsed as doxygen comment.
[blender.git] / source / blender / imbuf / intern / md5.c
1 /* md5.c - Functions to compute MD5 message digest of files or memory blocks
2    according to the definition of MD5 in RFC 1321 from April 1992.
3    Copyright (C) 1995 Software Foundation, Inc.
4
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 2, or (at your option)
8    any later version.
9
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
18
19 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>.  */
20
21 #include <sys/types.h>
22
23 # include <stdlib.h>
24 # include <string.h>
25
26 #include "md5.h"
27
28 #ifdef WORDS_BIGENDIAN
29 # define SWAP(n)                                                        \
30         (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
31 #else
32 # define SWAP(n) (n)
33 #endif
34
35
36 /* This array contains the bytes used to pad the buffer to the next
37    64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
38 static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
39
40
41 /* Initialize structure containing state of computation.
42    (RFC 1321, 3.3: Step 3)  */
43 void
44 md5_init_ctx (ctx)
45          struct md5_ctx *ctx;
46 {
47   ctx->A = 0x67452301;
48   ctx->B = 0xefcdab89;
49   ctx->C = 0x98badcfe;
50   ctx->D = 0x10325476;
51 }
52
53 /* Put result from CTX in first 16 bytes following RESBUF.  The result must
54    be in little endian byte order.  */
55 void *
56 md5_read_ctx (ctx, resbuf)
57          const struct md5_ctx *ctx;
58          void *resbuf;
59 {
60   ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
61   ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
62   ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C);
63   ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D);
64
65   return resbuf;
66 }
67
68 /* Compute MD5 message digest for bytes read from STREAM.  The
69    resulting message digest number will be written into the 16 bytes
70    beginning at RESBLOCK.  */
71 int
72 md5_stream (stream, resblock)
73          FILE *stream;
74          void *resblock;
75 {
76   /* Important: BLOCKSIZE must be a multiple of 64.  */
77 #define BLOCKSIZE 4096
78   struct md5_ctx ctx;
79   md5_uint32 len[2];
80   char buffer[BLOCKSIZE + 72];
81   size_t pad, sum;
82
83   /* Initialize the computation context.  */
84   md5_init_ctx (&ctx);
85
86   len[0] = 0;
87   len[1] = 0;
88
89   /* Iterate over full file contents.  */
90   while (1)
91         {
92           /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
93          computation function processes the whole buffer so that with the
94          next round of the loop another block can be read.  */
95           size_t n;
96           sum = 0;
97
98           /* Read block.  Take care for partial reads.  */
99           do
100         {
101           n = fread (buffer, 1, BLOCKSIZE - sum, stream);
102
103           sum += n;
104         }
105           while (sum < BLOCKSIZE && n != 0);
106           if (n == 0 && ferror (stream))
107                 return 1;
108
109           /* RFC 1321 specifies the possible length of the file up to 2^64 bits.
110          Here we only compute the number of bytes.  Do a double word
111                  increment.  */
112           len[0] += sum;
113           if (len[0] < sum)
114         ++len[1];
115
116           /* If end of file is reached, end the loop.  */
117           if (n == 0)
118         break;
119
120           /* Process buffer with BLOCKSIZE bytes.  Note that
121                         BLOCKSIZE % 64 == 0
122            */
123           md5_process_block (buffer, BLOCKSIZE, &ctx);
124         }
125
126   /* We can copy 64 byte because the buffer is always big enough.  FILLBUF
127          contains the needed bits.  */
128   memcpy (&buffer[sum], fillbuf, 64);
129
130   /* Compute amount of padding bytes needed.  Alignment is done to
131                 (N + PAD) % 64 == 56
132          There is always at least one byte padded.  I.e. even the alignment
133          is correctly aligned 64 padding bytes are added.  */
134   pad = sum & 63;
135   pad = pad >= 56 ? 64 + 56 - pad : 56 - pad;
136
137   /* Put the 64-bit file length in *bits* at the end of the buffer.  */
138   *(md5_uint32 *) &buffer[sum + pad] = SWAP (len[0] << 3);
139   *(md5_uint32 *) &buffer[sum + pad + 4] = SWAP ((len[1] << 3)
140                                                  | (len[0] >> 29));
141
142   /* Process last bytes.  */
143   md5_process_block (buffer, sum + pad + 8, &ctx);
144
145   /* Construct result in desired memory.  */
146   md5_read_ctx (&ctx, resblock);
147   return 0;
148 }
149
150 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
151    result is always in little endian byte order, so that a byte-wise
152    output yields to the wanted ASCII representation of the message
153    digest.  */
154 void *
155 md5_buffer (buffer, len, resblock)
156          const char *buffer;
157          size_t len;
158          void *resblock;
159 {
160   struct md5_ctx ctx;
161   char restbuf[64 + 72];
162   size_t blocks = len & ~63;
163   size_t pad, rest;
164
165   /* Initialize the computation context.  */
166   md5_init_ctx (&ctx);
167
168   /* Process whole buffer but last len % 64 bytes.  */
169   md5_process_block (buffer, blocks, &ctx);
170
171   /* REST bytes are not processed yet.  */
172   rest = len - blocks;
173   /* Copy to own buffer.  */
174   memcpy (restbuf, &buffer[blocks], rest);
175   /* Append needed fill bytes at end of buffer.  We can copy 64 byte
176          because the buffer is always big enough.  */
177   memcpy (&restbuf[rest], fillbuf, 64);
178
179   /* PAD bytes are used for padding to correct alignment.  Note that
180          always at least one byte is padded.  */
181   pad = rest >= 56 ? 64 + 56 - rest : 56 - rest;
182
183   /* Put length of buffer in *bits* in last eight bytes.  */
184   *(md5_uint32 *) &restbuf[rest + pad] = (md5_uint32) SWAP (len << 3);
185   *(md5_uint32 *) &restbuf[rest + pad + 4] = (md5_uint32) SWAP (len >> 29);
186
187   /* Process last bytes.  */
188   md5_process_block (restbuf, rest + pad + 8, &ctx);
189
190   /* Put result in desired memory area.  */
191   return md5_read_ctx (&ctx, resblock);
192 }
193
194
195 /* These are the four functions used in the four steps of the MD5 algorithm
196    and defined in the RFC 1321.  The first function is a little bit optimized
197    (as found in Colin Plumbs public domain implementation).  */
198 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
199 #define FF(b, c, d) (d ^ (b & (c ^ d)))
200 #define FG(b, c, d) FF (d, b, c)
201 #define FH(b, c, d) (b ^ c ^ d)
202 #define FI(b, c, d) (c ^ (b | ~d))
203
204 /* Process LEN bytes of BUFFER, accumulating context into CTX.
205    It is assumed that LEN % 64 == 0.  */
206
207 void
208 md5_process_block (buffer, len, ctx)
209          const void *buffer;
210          size_t len;
211          struct md5_ctx *ctx;
212 {
213   md5_uint32 correct_words[16];
214   const md5_uint32 *words = buffer;
215   size_t nwords = len / sizeof (md5_uint32);
216   const md5_uint32 *endp = words + nwords;
217   md5_uint32 A = ctx->A;
218   md5_uint32 B = ctx->B;
219   md5_uint32 C = ctx->C;
220   md5_uint32 D = ctx->D;
221
222   /* Process all bytes in the buffer with 64 bytes in each round of
223          the loop.  */
224   while (words < endp)
225         {
226           md5_uint32 *cwp = correct_words;
227           md5_uint32 A_save = A;
228           md5_uint32 B_save = B;
229           md5_uint32 C_save = C;
230           md5_uint32 D_save = D;
231
232           /* First round: using the given function, the context and a constant
233          the next context is computed.  Because the algorithms processing
234          unit is a 32-bit word and it is determined to work on words in
235          little endian byte order we perhaps have to change the byte order
236          before the computation.  To reduce the work for the next steps
237          we store the swapped words in the array CORRECT_WORDS.  */
238
239 #define OP(a, b, c, d, s, T)                                            \
240           do                                                            \
241                 {                                                               \
242           a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
243           ++words;                                                      \
244           CYCLIC (a, s);                                                \
245           a += b;                                                       \
246                 }                                                               \
247           while (0)
248
249           /* It is unfortunate that C does not provide an operator for
250          cyclic rotation.  Hope the C compiler is smart enough.  */
251 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
252
253           /* Before we start, one word to the strange constants.
254          They are defined in RFC 1321 as
255
256          T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
257            */
258
259           /* Round 1.  */
260           OP (A, B, C, D,  7, 0xd76aa478);
261           OP (D, A, B, C, 12, 0xe8c7b756);
262           OP (C, D, A, B, 17, 0x242070db);
263           OP (B, C, D, A, 22, 0xc1bdceee);
264           OP (A, B, C, D,  7, 0xf57c0faf);
265           OP (D, A, B, C, 12, 0x4787c62a);
266           OP (C, D, A, B, 17, 0xa8304613);
267           OP (B, C, D, A, 22, 0xfd469501);
268           OP (A, B, C, D,  7, 0x698098d8);
269           OP (D, A, B, C, 12, 0x8b44f7af);
270           OP (C, D, A, B, 17, 0xffff5bb1);
271           OP (B, C, D, A, 22, 0x895cd7be);
272           OP (A, B, C, D,  7, 0x6b901122);
273           OP (D, A, B, C, 12, 0xfd987193);
274           OP (C, D, A, B, 17, 0xa679438e);
275           OP (B, C, D, A, 22, 0x49b40821);
276
277           /* For the second to fourth round we have the possibly swapped words
278          in CORRECT_WORDS.  Redefine the macro to take an additional first
279          argument specifying the function to use.  */
280 #undef OP
281 #define OP(f, a, b, c, d, k, s, T)                                      \
282           do                                                            \
283         {                                                               \
284           a += f (b, c, d) + correct_words[k] + T;                      \
285           CYCLIC (a, s);                                                \
286           a += b;                                                       \
287         }                                                               \
288           while (0)
289
290           /* Round 2.  */
291           OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
292           OP (FG, D, A, B, C,  6,  9, 0xc040b340);
293           OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
294           OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
295           OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
296           OP (FG, D, A, B, C, 10,  9, 0x02441453);
297           OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
298           OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
299           OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
300           OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
301           OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
302           OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
303           OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
304           OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
305           OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
306           OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
307
308           /* Round 3.  */
309           OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
310           OP (FH, D, A, B, C,  8, 11, 0x8771f681);
311           OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
312           OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
313           OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
314           OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
315           OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
316           OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
317           OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
318           OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
319           OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
320           OP (FH, B, C, D, A,  6, 23, 0x04881d05);
321           OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
322           OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
323           OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
324           OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
325
326           /* Round 4.  */
327           OP (FI, A, B, C, D,  0,  6, 0xf4292244);
328           OP (FI, D, A, B, C,  7, 10, 0x432aff97);
329           OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
330           OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
331           OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
332           OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
333           OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
334           OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
335           OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
336           OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
337           OP (FI, C, D, A, B,  6, 15, 0xa3014314);
338           OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
339           OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
340           OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
341           OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
342           OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
343
344           /* Add the starting values of the context.  */
345           A += A_save;
346           B += B_save;
347           C += C_save;
348           D += D_save;
349         }
350
351   /* Put checksum in context given as argument.  */
352   ctx->A = A;
353   ctx->B = B;
354   ctx->C = C;
355   ctx->D = D;
356 }
357