Next round of fixing all kinds of spelling mistakes.
[dragonfly.git] / lib / libmd / sha1c.c
1 /* crypto/sha/sha1dgst.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  *
58  * $DragonFly: src/lib/libmd/sha1c.c,v 1.3 2004/10/25 19:38:45 drhodus Exp $
59  */
60
61 #include <sys/types.h>
62
63 #include <stdio.h>
64 #include <string.h>
65
66 #include <machine/endian.h>
67
68 #undef  SHA_0
69 #define SHA_1
70 #include "sha.h"
71 #include "sha_locl.h"
72
73 /*
74  * The assembly-language code is not position-independent, so don't
75  * try to use it in a shared library.
76  */
77 #ifdef PIC
78 #undef SHA1_ASM
79 #endif
80
81 char *SHA1_version="SHA1 part of SSLeay 0.9.0b 11-Oct-1998";
82
83 /* Implemented from SHA-1 document - The Secure Hash Algorithm
84  */
85
86 #define INIT_DATA_h0 (unsigned long)0x67452301L
87 #define INIT_DATA_h1 (unsigned long)0xefcdab89L
88 #define INIT_DATA_h2 (unsigned long)0x98badcfeL
89 #define INIT_DATA_h3 (unsigned long)0x10325476L
90 #define INIT_DATA_h4 (unsigned long)0xc3d2e1f0L
91
92 #define K_00_19 0x5a827999L
93 #define K_20_39 0x6ed9eba1L
94 #define K_40_59 0x8f1bbcdcL
95 #define K_60_79 0xca62c1d6L
96
97 #ifndef NOPROTO
98 #  ifdef SHA1_ASM
99      void sha1_block_x86(SHA_CTX *c, const u_int32_t *p, int num);
100 #    define sha1_block sha1_block_x86
101 #  else
102      void sha1_block(SHA_CTX *c, const u_int32_t *p, int num);
103 #  endif
104 #else
105 #  ifdef SHA1_ASM
106      void sha1_block_x86();
107 #    define sha1_block sha1_block_x86
108 #  else
109      void sha1_block();
110 #  endif
111 #endif
112
113
114 #if BYTE_ORDER == LITTLE_ENDIAN && defined(SHA1_ASM)
115 #  define       M_c2nl          c2l
116 #  define       M_p_c2nl        p_c2l
117 #  define       M_c2nl_p        c2l_p
118 #  define       M_p_c2nl_p      p_c2l_p
119 #  define       M_nl2c          l2c
120 #else
121 #  define       M_c2nl          c2nl
122 #  define       M_p_c2nl        p_c2nl
123 #  define       M_c2nl_p        c2nl_p
124 #  define       M_p_c2nl_p      p_c2nl_p
125 #  define       M_nl2c          nl2c
126 #endif
127
128 void SHA1_Init(c)
129 SHA_CTX *c;
130         {
131         c->h0=INIT_DATA_h0;
132         c->h1=INIT_DATA_h1;
133         c->h2=INIT_DATA_h2;
134         c->h3=INIT_DATA_h3;
135         c->h4=INIT_DATA_h4;
136         c->Nl=0;
137         c->Nh=0;
138         c->num=0;
139         }
140
141 void
142 SHA1_Update(c, data, len)
143         SHA_CTX *c;
144         const unsigned char *data;
145         size_t len;
146 {
147         u_int32_t *p;
148         int ew,ec,sw,sc;
149         u_int32_t l;
150
151         if (len == 0) return;
152
153         l=(c->Nl+(len<<3))&0xffffffffL;
154         if (l < c->Nl) /* overflow */
155                 c->Nh++;
156         c->Nh+=(len>>29);
157         c->Nl=l;
158
159         if (c->num != 0)
160                 {
161                 p=c->data;
162                 sw=c->num>>2;
163                 sc=c->num&0x03;
164
165                 if ((c->num+len) >= SHA_CBLOCK)
166                         {
167                         l= p[sw];
168                         M_p_c2nl(data,l,sc);
169                         p[sw++]=l;
170                         for (; sw<SHA_LBLOCK; sw++)
171                                 {
172                                 M_c2nl(data,l);
173                                 p[sw]=l;
174                                 }
175                         len-=(SHA_CBLOCK-c->num);
176
177                         sha1_block(c,p,64);
178                         c->num=0;
179                         /* drop through and do the rest */
180                         }
181                 else
182                         {
183                         c->num+=(int)len;
184                         if ((sc+len) < 4) /* ugly, add char's to a word */
185                                 {
186                                 l= p[sw];
187                                 M_p_c2nl_p(data,l,sc,len);
188                                 p[sw]=l;
189                                 }
190                         else
191                                 {
192                                 ew=(c->num>>2);
193                                 ec=(c->num&0x03);
194                                 l= p[sw];
195                                 M_p_c2nl(data,l,sc);
196                                 p[sw++]=l;
197                                 for (; sw < ew; sw++)
198                                         { M_c2nl(data,l); p[sw]=l; }
199                                 if (ec)
200                                         {
201                                         M_c2nl_p(data,l,ec);
202                                         p[sw]=l;
203                                         }
204                                 }
205                         return;
206                         }
207                 }
208         /* We can only do the following code for assember, the reason
209          * being that the sha1_block 'C' version changes the values
210          * in the 'data' array.  The assember code avoids this and
211          * copies it to a local array.  I should be able to do this for
212          * the C version as well....
213          */
214 #if 1
215 #if BYTE_ORDER == BIG_ENDIAN || defined(SHA1_ASM)
216         if ((((unsigned int)data)%sizeof(u_int32_t)) == 0)
217                 {
218                 sw=len/SHA_CBLOCK;
219                 if (sw)
220                         {
221                         sw*=SHA_CBLOCK;
222                         sha1_block(c,(u_int32_t *)data,sw);
223                         data+=sw;
224                         len-=sw;
225                         }
226                 }
227 #endif
228 #endif
229         /* we now can process the input data in blocks of SHA_CBLOCK
230          * chars and save the leftovers to c->data. */
231         p=c->data;
232         while (len >= SHA_CBLOCK)
233                 {
234 #if BYTE_ORDER == BIG_ENDIAN || BYTE_ORDER == LITTLE_ENDIAN
235                 if (p != (u_int32_t *)data)
236                         memcpy(p,data,SHA_CBLOCK);
237                 data+=SHA_CBLOCK;
238 #  if BYTE_ORDER == LITTLE_ENDIAN
239 #    ifndef SHA1_ASM /* Will not happen */
240                 for (sw=(SHA_LBLOCK/4); sw; sw--)
241                         {
242                         Endian_Reverse32(p[0]);
243                         Endian_Reverse32(p[1]);
244                         Endian_Reverse32(p[2]);
245                         Endian_Reverse32(p[3]);
246                         p+=4;
247                         }
248                 p=c->data;
249 #    endif
250 #  endif
251 #else
252                 for (sw=(SHA_BLOCK/4); sw; sw--)
253                         {
254                         M_c2nl(data,l); *(p++)=l;
255                         M_c2nl(data,l); *(p++)=l;
256                         M_c2nl(data,l); *(p++)=l;
257                         M_c2nl(data,l); *(p++)=l;
258                         }
259                 p=c->data;
260 #endif
261                 sha1_block(c,p,64);
262                 len-=SHA_CBLOCK;
263                 }
264         ec=(int)len;
265         c->num=ec;
266         ew=(ec>>2);
267         ec&=0x03;
268
269         for (sw=0; sw < ew; sw++)
270                 { M_c2nl(data,l); p[sw]=l; }
271         M_c2nl_p(data,l,ec);
272         p[sw]=l;
273         }
274
275 void SHA1_Transform(c,b)
276 SHA_CTX *c;
277 unsigned char *b;
278         {
279         u_int32_t p[16];
280 #if BYTE_ORDER != BIG_ENDIAN
281         u_int32_t *q;
282         int i;
283 #endif
284
285 #if BYTE_ORDER == BIG_ENDIAN || BYTE_ORDER == LITTLE_ENDIAN
286         memcpy(p,b,64);
287 #if BYTE_ORDER == LITTLE_ENDIAN
288         q=p;
289         for (i=(SHA_LBLOCK/4); i; i--)
290                 {
291                 Endian_Reverse32(q[0]);
292                 Endian_Reverse32(q[1]);
293                 Endian_Reverse32(q[2]);
294                 Endian_Reverse32(q[3]);
295                 q+=4;
296                 }
297 #endif
298 #else
299         q=p;
300         for (i=(SHA_LBLOCK/4); i; i--)
301                 {
302                 u_int32_t l;
303                 c2nl(b,l); *(q++)=l;
304                 c2nl(b,l); *(q++)=l;
305                 c2nl(b,l); *(q++)=l;
306                 c2nl(b,l); *(q++)=l; 
307                 } 
308 #endif
309         sha1_block(c,p,64);
310         }
311
312 #ifndef SHA1_ASM
313
314 void 
315 sha1_block(c, W, num)
316         SHA_CTX *c;
317         const u_int32_t *W;
318         int num;
319 {
320         u_int32_t A,B,C,D,E,T;
321         u_int32_t X[16];
322
323         A=c->h0;
324         B=c->h1;
325         C=c->h2;
326         D=c->h3;
327         E=c->h4;
328
329         for (;;)
330                 {
331         BODY_00_15( 0,A,B,C,D,E,T,W);
332         BODY_00_15( 1,T,A,B,C,D,E,W);
333         BODY_00_15( 2,E,T,A,B,C,D,W);
334         BODY_00_15( 3,D,E,T,A,B,C,W);
335         BODY_00_15( 4,C,D,E,T,A,B,W);
336         BODY_00_15( 5,B,C,D,E,T,A,W);
337         BODY_00_15( 6,A,B,C,D,E,T,W);
338         BODY_00_15( 7,T,A,B,C,D,E,W);
339         BODY_00_15( 8,E,T,A,B,C,D,W);
340         BODY_00_15( 9,D,E,T,A,B,C,W);
341         BODY_00_15(10,C,D,E,T,A,B,W);
342         BODY_00_15(11,B,C,D,E,T,A,W);
343         BODY_00_15(12,A,B,C,D,E,T,W);
344         BODY_00_15(13,T,A,B,C,D,E,W);
345         BODY_00_15(14,E,T,A,B,C,D,W);
346         BODY_00_15(15,D,E,T,A,B,C,W);
347         BODY_16_19(16,C,D,E,T,A,B,W,W,W,W);
348         BODY_16_19(17,B,C,D,E,T,A,W,W,W,W);
349         BODY_16_19(18,A,B,C,D,E,T,W,W,W,W);
350         BODY_16_19(19,T,A,B,C,D,E,W,W,W,X);
351
352         BODY_20_31(20,E,T,A,B,C,D,W,W,W,X);
353         BODY_20_31(21,D,E,T,A,B,C,W,W,W,X);
354         BODY_20_31(22,C,D,E,T,A,B,W,W,W,X);
355         BODY_20_31(23,B,C,D,E,T,A,W,W,W,X);
356         BODY_20_31(24,A,B,C,D,E,T,W,W,X,X);
357         BODY_20_31(25,T,A,B,C,D,E,W,W,X,X);
358         BODY_20_31(26,E,T,A,B,C,D,W,W,X,X);
359         BODY_20_31(27,D,E,T,A,B,C,W,W,X,X);
360         BODY_20_31(28,C,D,E,T,A,B,W,W,X,X);
361         BODY_20_31(29,B,C,D,E,T,A,W,W,X,X);
362         BODY_20_31(30,A,B,C,D,E,T,W,X,X,X);
363         BODY_20_31(31,T,A,B,C,D,E,W,X,X,X);
364         BODY_32_39(32,E,T,A,B,C,D,X);
365         BODY_32_39(33,D,E,T,A,B,C,X);
366         BODY_32_39(34,C,D,E,T,A,B,X);
367         BODY_32_39(35,B,C,D,E,T,A,X);
368         BODY_32_39(36,A,B,C,D,E,T,X);
369         BODY_32_39(37,T,A,B,C,D,E,X);
370         BODY_32_39(38,E,T,A,B,C,D,X);
371         BODY_32_39(39,D,E,T,A,B,C,X);
372
373         BODY_40_59(40,C,D,E,T,A,B,X);
374         BODY_40_59(41,B,C,D,E,T,A,X);
375         BODY_40_59(42,A,B,C,D,E,T,X);
376         BODY_40_59(43,T,A,B,C,D,E,X);
377         BODY_40_59(44,E,T,A,B,C,D,X);
378         BODY_40_59(45,D,E,T,A,B,C,X);
379         BODY_40_59(46,C,D,E,T,A,B,X);
380         BODY_40_59(47,B,C,D,E,T,A,X);
381         BODY_40_59(48,A,B,C,D,E,T,X);
382         BODY_40_59(49,T,A,B,C,D,E,X);
383         BODY_40_59(50,E,T,A,B,C,D,X);
384         BODY_40_59(51,D,E,T,A,B,C,X);
385         BODY_40_59(52,C,D,E,T,A,B,X);
386         BODY_40_59(53,B,C,D,E,T,A,X);
387         BODY_40_59(54,A,B,C,D,E,T,X);
388         BODY_40_59(55,T,A,B,C,D,E,X);
389         BODY_40_59(56,E,T,A,B,C,D,X);
390         BODY_40_59(57,D,E,T,A,B,C,X);
391         BODY_40_59(58,C,D,E,T,A,B,X);
392         BODY_40_59(59,B,C,D,E,T,A,X);
393
394         BODY_60_79(60,A,B,C,D,E,T,X);
395         BODY_60_79(61,T,A,B,C,D,E,X);
396         BODY_60_79(62,E,T,A,B,C,D,X);
397         BODY_60_79(63,D,E,T,A,B,C,X);
398         BODY_60_79(64,C,D,E,T,A,B,X);
399         BODY_60_79(65,B,C,D,E,T,A,X);
400         BODY_60_79(66,A,B,C,D,E,T,X);
401         BODY_60_79(67,T,A,B,C,D,E,X);
402         BODY_60_79(68,E,T,A,B,C,D,X);
403         BODY_60_79(69,D,E,T,A,B,C,X);
404         BODY_60_79(70,C,D,E,T,A,B,X);
405         BODY_60_79(71,B,C,D,E,T,A,X);
406         BODY_60_79(72,A,B,C,D,E,T,X);
407         BODY_60_79(73,T,A,B,C,D,E,X);
408         BODY_60_79(74,E,T,A,B,C,D,X);
409         BODY_60_79(75,D,E,T,A,B,C,X);
410         BODY_60_79(76,C,D,E,T,A,B,X);
411         BODY_60_79(77,B,C,D,E,T,A,X);
412         BODY_60_79(78,A,B,C,D,E,T,X);
413         BODY_60_79(79,T,A,B,C,D,E,X);
414         
415         c->h0=(c->h0+E)&0xffffffffL; 
416         c->h1=(c->h1+T)&0xffffffffL;
417         c->h2=(c->h2+A)&0xffffffffL;
418         c->h3=(c->h3+B)&0xffffffffL;
419         c->h4=(c->h4+C)&0xffffffffL;
420
421         num-=64;
422         if (num <= 0) break;
423
424         A=c->h0;
425         B=c->h1;
426         C=c->h2;
427         D=c->h3;
428         E=c->h4;
429
430         W+=16;
431                 }
432         }
433 #endif
434
435 void SHA1_Final(md, c)
436 unsigned char *md;
437 SHA_CTX *c;
438         {
439         int i,j;
440         u_int32_t l;
441         u_int32_t *p;
442         static unsigned char end[4]={0x80,0x00,0x00,0x00};
443         unsigned char *cp=end;
444
445         /* c->num should definitly have room for at least one more byte. */
446         p=c->data;
447         j=c->num;
448         i=j>>2;
449 #ifdef PURIFY
450         if ((j&0x03) == 0) p[i]=0;
451 #endif
452         l=p[i];
453         M_p_c2nl(cp,l,j&0x03);
454         p[i]=l;
455         i++;
456         /* i is the next 'undefined word' */
457         if (c->num >= SHA_LAST_BLOCK)
458                 {
459                 for (; i<SHA_LBLOCK; i++)
460                         p[i]=0;
461                 sha1_block(c,p,64);
462                 i=0;
463                 }
464         for (; i<(SHA_LBLOCK-2); i++)
465                 p[i]=0;
466         p[SHA_LBLOCK-2]=c->Nh;
467         p[SHA_LBLOCK-1]=c->Nl;
468 #if BYTE_ORDER == LITTLE_ENDIAN && defined(SHA1_ASM)
469         Endian_Reverse32(p[SHA_LBLOCK-2]);
470         Endian_Reverse32(p[SHA_LBLOCK-1]);
471 #endif
472         sha1_block(c,p,64);
473         cp=md;
474         l=c->h0; nl2c(l,cp);
475         l=c->h1; nl2c(l,cp);
476         l=c->h2; nl2c(l,cp);
477         l=c->h3; nl2c(l,cp);
478         l=c->h4; nl2c(l,cp);
479
480         /* clear stuff, sha1_block may be leaving some stuff on the stack
481          * but I'm not worried :-) */
482         c->num=0;
483 /*      memset((char *)&c,0,sizeof(c));*/
484         }
485