Use m_tempfile and better errors msg
[apps/madmutt.git] / lib-hash / sha1.c
1 /*
2  SHA-1 in C
3
4  By Steve Reid <steve@edmweb.com>, with small changes to make it
5  fit into mutt by Thomas Roessler <roessler@does-not-exist.org>.
6
7  100% Public Domain.
8
9  Test Vectors (from FIPS PUB 180-1)
10  "abc"
11  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
12  "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
13  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
14  A million repetitions of "a"
15  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
16 */
17
18 #include <lib-lib/lib-lib.h>
19 #define SHA1HANDSOFF
20
21 #include "sha1.h"
22
23 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
24
25 /* blk0() and blk() perform the initial expand. */
26 /* I got the idea of expanding during the round function from SSLeay */
27 #ifdef WORDS_BIGENDIAN
28 #  define blk0(i) block->l[i]
29 #else
30 #  define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
31                     |(rol(block->l[i],8)&0x00FF00FF))
32 #endif
33
34 #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
35     ^block->l[(i+2)&15]^block->l[i&15],1))
36
37 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
38 #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
39 #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
40 #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
41 #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
42 #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
43
44
45 /* Hash a single 512-bit block. This is the core of the algorithm. */
46
47 void SHA1Transform (uint32_t state[5], const unsigned char buffer[64])
48 {
49   uint32_t a, b, c, d, e;
50   typedef union {
51     unsigned char c[64];
52     uint32_t l[16];
53   } CHAR64LONG16;
54
55 #ifdef SHA1HANDSOFF
56   CHAR64LONG16 block[1];        /* use array to appear as a pointer */
57
58   memcpy (block, buffer, 64);
59 #else
60   /* The following had better never be used because it causes the
61    * pointer-to-const buffer to be cast into a pointer to non-const.
62    * And the result is written through.  I threw a "const" in, hoping
63    * this will cause a diagnostic.
64    */
65   CHAR64LONG16 *block = (const CHAR64LONG16 *) buffer;
66 #endif
67   /* Copy context->state[] to working vars */
68   a = state[0];
69   b = state[1];
70   c = state[2];
71   d = state[3];
72   e = state[4];
73   /* 4 rounds of 20 operations each. Loop unrolled. */
74   R0 (a, b, c, d, e, 0);
75   R0 (e, a, b, c, d, 1);
76   R0 (d, e, a, b, c, 2);
77   R0 (c, d, e, a, b, 3);
78   R0 (b, c, d, e, a, 4);
79   R0 (a, b, c, d, e, 5);
80   R0 (e, a, b, c, d, 6);
81   R0 (d, e, a, b, c, 7);
82   R0 (c, d, e, a, b, 8);
83   R0 (b, c, d, e, a, 9);
84   R0 (a, b, c, d, e, 10);
85   R0 (e, a, b, c, d, 11);
86   R0 (d, e, a, b, c, 12);
87   R0 (c, d, e, a, b, 13);
88   R0 (b, c, d, e, a, 14);
89   R0 (a, b, c, d, e, 15);
90   R1 (e, a, b, c, d, 16);
91   R1 (d, e, a, b, c, 17);
92   R1 (c, d, e, a, b, 18);
93   R1 (b, c, d, e, a, 19);
94   R2 (a, b, c, d, e, 20);
95   R2 (e, a, b, c, d, 21);
96   R2 (d, e, a, b, c, 22);
97   R2 (c, d, e, a, b, 23);
98   R2 (b, c, d, e, a, 24);
99   R2 (a, b, c, d, e, 25);
100   R2 (e, a, b, c, d, 26);
101   R2 (d, e, a, b, c, 27);
102   R2 (c, d, e, a, b, 28);
103   R2 (b, c, d, e, a, 29);
104   R2 (a, b, c, d, e, 30);
105   R2 (e, a, b, c, d, 31);
106   R2 (d, e, a, b, c, 32);
107   R2 (c, d, e, a, b, 33);
108   R2 (b, c, d, e, a, 34);
109   R2 (a, b, c, d, e, 35);
110   R2 (e, a, b, c, d, 36);
111   R2 (d, e, a, b, c, 37);
112   R2 (c, d, e, a, b, 38);
113   R2 (b, c, d, e, a, 39);
114   R3 (a, b, c, d, e, 40);
115   R3 (e, a, b, c, d, 41);
116   R3 (d, e, a, b, c, 42);
117   R3 (c, d, e, a, b, 43);
118   R3 (b, c, d, e, a, 44);
119   R3 (a, b, c, d, e, 45);
120   R3 (e, a, b, c, d, 46);
121   R3 (d, e, a, b, c, 47);
122   R3 (c, d, e, a, b, 48);
123   R3 (b, c, d, e, a, 49);
124   R3 (a, b, c, d, e, 50);
125   R3 (e, a, b, c, d, 51);
126   R3 (d, e, a, b, c, 52);
127   R3 (c, d, e, a, b, 53);
128   R3 (b, c, d, e, a, 54);
129   R3 (a, b, c, d, e, 55);
130   R3 (e, a, b, c, d, 56);
131   R3 (d, e, a, b, c, 57);
132   R3 (c, d, e, a, b, 58);
133   R3 (b, c, d, e, a, 59);
134   R4 (a, b, c, d, e, 60);
135   R4 (e, a, b, c, d, 61);
136   R4 (d, e, a, b, c, 62);
137   R4 (c, d, e, a, b, 63);
138   R4 (b, c, d, e, a, 64);
139   R4 (a, b, c, d, e, 65);
140   R4 (e, a, b, c, d, 66);
141   R4 (d, e, a, b, c, 67);
142   R4 (c, d, e, a, b, 68);
143   R4 (b, c, d, e, a, 69);
144   R4 (a, b, c, d, e, 70);
145   R4 (e, a, b, c, d, 71);
146   R4 (d, e, a, b, c, 72);
147   R4 (c, d, e, a, b, 73);
148   R4 (b, c, d, e, a, 74);
149   R4 (a, b, c, d, e, 75);
150   R4 (e, a, b, c, d, 76);
151   R4 (d, e, a, b, c, 77);
152   R4 (c, d, e, a, b, 78);
153   R4 (b, c, d, e, a, 79);
154   /* Add the working vars back into context.state[] */
155   state[0] += a;
156   state[1] += b;
157   state[2] += c;
158   state[3] += d;
159   state[4] += e;
160   /* Wipe variables */
161   a = b = c = d = e = 0;
162 #ifdef SHA1HANDSOFF
163   memset (block, '\0', sizeof (block));
164 #endif
165 }
166
167
168 /* SHA1Init - Initialize new context */
169
170 void SHA1Init (SHA1_CTX * context)
171 {
172   /* SHA1 initialization constants */
173   context->state[0] = 0x67452301;
174   context->state[1] = 0xEFCDAB89;
175   context->state[2] = 0x98BADCFE;
176   context->state[3] = 0x10325476;
177   context->state[4] = 0xC3D2E1F0;
178   context->count[0] = context->count[1] = 0;
179 }
180
181
182 /* Run your data through this. */
183
184 void SHA1Update (SHA1_CTX * context, const unsigned char *data, uint32_t len)
185 {
186   uint32_t i;
187   uint32_t j;
188
189   j = context->count[0];
190   if ((context->count[0] += len << 3) < j)
191     context->count[1]++;
192   context->count[1] += (len >> 29);
193   j = (j >> 3) & 63;
194   if ((j + len) > 63) {
195     memcpy (&context->buffer[j], data, (i = 64 - j));
196     SHA1Transform (context->state, context->buffer);
197     for (; i + 63 < len; i += 64) {
198       SHA1Transform (context->state, &data[i]);
199     }
200     j = 0;
201   }
202   else
203     i = 0;
204   memcpy (&context->buffer[j], &data[i], len - i);
205 }
206
207
208 /* Add padding and return the message digest. */
209
210 void SHA1Final (unsigned char digest[20], SHA1_CTX * context)
211 {
212   unsigned i;
213   unsigned char finalcount[8];
214   unsigned char c;
215
216   for (i = 0; i < 8; i++) {
217     finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)]
218                                       >> ((3 - (i & 3)) * 8)) & 255);   /* Endian independent */
219   }
220   c = 0200;
221   SHA1Update (context, &c, 1);
222   while ((context->count[0] & 504) != 448) {
223     c = 0000;
224     SHA1Update (context, &c, 1);
225   }
226   SHA1Update (context, finalcount, 8);  /* Should cause a SHA1Transform() */
227   for (i = 0; i < 20; i++) {
228     digest[i] = (unsigned char)
229       ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
230   }
231   /* Wipe variables */
232   memset (context, '\0', sizeof (*context));
233   memset (&finalcount, '\0', sizeof (finalcount));
234 }