Vanilla copies from axtls
[people/xl0/gpxe.git] / src / crypto / axtls / sha1.c
1 /*
2  *  Copyright(C) 2006 Cameron Rich
3  *
4  *  This library is free software; you can redistribute it and/or modify
5  *  it under the terms of the GNU Lesser General Public License as published by
6  *  the Free Software Foundation; either version 2.1 of the License, or
7  *  (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *  GNU Lesser General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Lesser General Public License
15  *  along with this library; if not, write to the Free Software
16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  */
18
19 /**
20  * SHA1 implementation - as defined in FIPS PUB 180-1 published April 17, 1995.
21  * This code was originally taken from RFC3174
22  */
23
24 #include <string.h>
25 #include "crypto.h"
26
27 /*
28  *  Define the SHA1 circular left shift macro
29  */
30 #define SHA1CircularShift(bits,word) \
31                 (((word) << (bits)) | ((word) >> (32-(bits))))
32
33 /* ----- static functions ----- */
34 static void SHA1PadMessage(SHA1_CTX *ctx);
35 static void SHA1ProcessMessageBlock(SHA1_CTX *ctx);
36
37 /**
38  * Initialize the SHA1 context 
39  */
40 void SHA1Init(SHA1_CTX *ctx)
41 {
42     ctx->Length_Low             = 0;
43     ctx->Length_High            = 0;
44     ctx->Message_Block_Index    = 0;
45     ctx->Intermediate_Hash[0]   = 0x67452301;
46     ctx->Intermediate_Hash[1]   = 0xEFCDAB89;
47     ctx->Intermediate_Hash[2]   = 0x98BADCFE;
48     ctx->Intermediate_Hash[3]   = 0x10325476;
49     ctx->Intermediate_Hash[4]   = 0xC3D2E1F0;
50 }
51
52 /**
53  * Accepts an array of octets as the next portion of the message.
54  */
55 void SHA1Update(SHA1_CTX *ctx, const uint8_t *msg, int len)
56 {
57     while (len--)
58     {
59         ctx->Message_Block[ctx->Message_Block_Index++] = (*msg & 0xFF);
60
61         ctx->Length_Low += 8;
62         if (ctx->Length_Low == 0)
63         {
64             ctx->Length_High++;
65         }
66
67         if (ctx->Message_Block_Index == 64)
68         {
69             SHA1ProcessMessageBlock(ctx);
70         }
71
72         msg++;
73     }
74 }
75
76 /**
77  * Return the 160-bit message digest into the user's array
78  */
79 void SHA1Final(SHA1_CTX *ctx, uint8_t *digest)
80 {
81     int i;
82
83     SHA1PadMessage(ctx);
84     memset(ctx->Message_Block, 0, 64);
85     ctx->Length_Low = 0;    /* and clear length */
86     ctx->Length_High = 0;
87
88     for  (i = 0; i < SHA1_SIZE; i++)
89     {
90         digest[i] = ctx->Intermediate_Hash[i>>2] >> 8 * ( 3 - ( i & 0x03 ) );
91     }
92 }
93
94 /**
95  * Process the next 512 bits of the message stored in the array.
96  */
97 static void SHA1ProcessMessageBlock(SHA1_CTX *ctx)
98 {
99     const uint32_t K[] =    {       /* Constants defined in SHA-1   */
100                             0x5A827999,
101                             0x6ED9EBA1,
102                             0x8F1BBCDC,
103                             0xCA62C1D6
104                             };
105     int        t;                 /* Loop counter                */
106     uint32_t      temp;              /* Temporary word value        */
107     uint32_t      W[80];             /* Word sequence               */
108     uint32_t      A, B, C, D, E;     /* Word buffers                */
109
110     /*
111      *  Initialize the first 16 words in the array W
112      */
113     for  (t = 0; t < 16; t++)
114     {
115         W[t] = ctx->Message_Block[t * 4] << 24;
116         W[t] |= ctx->Message_Block[t * 4 + 1] << 16;
117         W[t] |= ctx->Message_Block[t * 4 + 2] << 8;
118         W[t] |= ctx->Message_Block[t * 4 + 3];
119     }
120
121     for (t = 16; t < 80; t++)
122     {
123        W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
124     }
125
126     A = ctx->Intermediate_Hash[0];
127     B = ctx->Intermediate_Hash[1];
128     C = ctx->Intermediate_Hash[2];
129     D = ctx->Intermediate_Hash[3];
130     E = ctx->Intermediate_Hash[4];
131
132     for (t = 0; t < 20; t++)
133     {
134         temp =  SHA1CircularShift(5,A) +
135                 ((B & C) | ((~B) & D)) + E + W[t] + K[0];
136         E = D;
137         D = C;
138         C = SHA1CircularShift(30,B);
139
140         B = A;
141         A = temp;
142     }
143
144     for (t = 20; t < 40; t++)
145     {
146         temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
147         E = D;
148         D = C;
149         C = SHA1CircularShift(30,B);
150         B = A;
151         A = temp;
152     }
153
154     for (t = 40; t < 60; t++)
155     {
156         temp = SHA1CircularShift(5,A) +
157                ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
158         E = D;
159         D = C;
160         C = SHA1CircularShift(30,B);
161         B = A;
162         A = temp;
163     }
164
165     for (t = 60; t < 80; t++)
166     {
167         temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
168         E = D;
169         D = C;
170         C = SHA1CircularShift(30,B);
171         B = A;
172         A = temp;
173     }
174
175     ctx->Intermediate_Hash[0] += A;
176     ctx->Intermediate_Hash[1] += B;
177     ctx->Intermediate_Hash[2] += C;
178     ctx->Intermediate_Hash[3] += D;
179     ctx->Intermediate_Hash[4] += E;
180     ctx->Message_Block_Index = 0;
181 }
182
183 /*
184  * According to the standard, the message must be padded to an even
185  * 512 bits.  The first padding bit must be a '1'.  The last 64
186  * bits represent the length of the original message.  All bits in
187  * between should be 0.  This function will pad the message
188  * according to those rules by filling the Message_Block array
189  * accordingly.  It will also call the ProcessMessageBlock function
190  * provided appropriately.  When it returns, it can be assumed that
191  * the message digest has been computed.
192  *
193  * @param ctx [in, out] The SHA1 context
194  */
195 static void SHA1PadMessage(SHA1_CTX *ctx)
196 {
197     /*
198      *  Check to see if the current message block is too small to hold
199      *  the initial padding bits and length.  If so, we will pad the
200      *  block, process it, and then continue padding into a second
201      *  block.
202      */
203     if (ctx->Message_Block_Index > 55)
204     {
205         ctx->Message_Block[ctx->Message_Block_Index++] = 0x80;
206         while(ctx->Message_Block_Index < 64)
207         {
208             ctx->Message_Block[ctx->Message_Block_Index++] = 0;
209         }
210
211         SHA1ProcessMessageBlock(ctx);
212
213         while (ctx->Message_Block_Index < 56)
214         {
215             ctx->Message_Block[ctx->Message_Block_Index++] = 0;
216         }
217     }
218     else
219     {
220         ctx->Message_Block[ctx->Message_Block_Index++] = 0x80;
221         while(ctx->Message_Block_Index < 56)
222         {
223
224             ctx->Message_Block[ctx->Message_Block_Index++] = 0;
225         }
226     }
227
228     /*
229      *  Store the message length as the last 8 octets
230      */
231     ctx->Message_Block[56] = ctx->Length_High >> 24;
232     ctx->Message_Block[57] = ctx->Length_High >> 16;
233     ctx->Message_Block[58] = ctx->Length_High >> 8;
234     ctx->Message_Block[59] = ctx->Length_High;
235     ctx->Message_Block[60] = ctx->Length_Low >> 24;
236     ctx->Message_Block[61] = ctx->Length_Low >> 16;
237     ctx->Message_Block[62] = ctx->Length_Low >> 8;
238     ctx->Message_Block[63] = ctx->Length_Low;
239     SHA1ProcessMessageBlock(ctx);
240 }