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