Annotation of embedaddon/axTLS/crypto/sha1.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (c) 2007, Cameron Rich
3: *
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions are met:
8: *
9: * * Redistributions of source code must retain the above copyright notice,
10: * this list of conditions and the following disclaimer.
11: * * Redistributions in binary form must reproduce the above copyright notice,
12: * this list of conditions and the following disclaimer in the documentation
13: * and/or other materials provided with the distribution.
14: * * Neither the name of the axTLS project nor the names of its contributors
15: * may be used to endorse or promote products derived from this software
16: * without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
22: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25: * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29: */
30:
31: /**
32: * SHA1 implementation - as defined in FIPS PUB 180-1 published April 17, 1995.
33: * This code was originally taken from RFC3174
34: */
35:
36: #include <string.h>
37: #include "os_port.h"
38: #include "crypto.h"
39:
40: /*
41: * Define the SHA1 circular left shift macro
42: */
43: #define SHA1CircularShift(bits,word) \
44: (((word) << (bits)) | ((word) >> (32-(bits))))
45:
46: /* ----- static functions ----- */
47: static void SHA1PadMessage(SHA1_CTX *ctx);
48: static void SHA1ProcessMessageBlock(SHA1_CTX *ctx);
49:
50: /**
51: * Initialize the SHA1 context
52: */
53: void SHA1_Init(SHA1_CTX *ctx)
54: {
55: ctx->Length_Low = 0;
56: ctx->Length_High = 0;
57: ctx->Message_Block_Index = 0;
58: ctx->Intermediate_Hash[0] = 0x67452301;
59: ctx->Intermediate_Hash[1] = 0xEFCDAB89;
60: ctx->Intermediate_Hash[2] = 0x98BADCFE;
61: ctx->Intermediate_Hash[3] = 0x10325476;
62: ctx->Intermediate_Hash[4] = 0xC3D2E1F0;
63: }
64:
65: /**
66: * Accepts an array of octets as the next portion of the message.
67: */
68: void SHA1_Update(SHA1_CTX *ctx, const uint8_t *msg, int len)
69: {
70: while (len--)
71: {
72: ctx->Message_Block[ctx->Message_Block_Index++] = (*msg & 0xFF);
73: ctx->Length_Low += 8;
74:
75: if (ctx->Length_Low == 0)
76: ctx->Length_High++;
77:
78: if (ctx->Message_Block_Index == 64)
79: SHA1ProcessMessageBlock(ctx);
80:
81: msg++;
82: }
83: }
84:
85: /**
86: * Return the 160-bit message digest into the user's array
87: */
88: void SHA1_Final(uint8_t *digest, SHA1_CTX *ctx)
89: {
90: int i;
91:
92: SHA1PadMessage(ctx);
93: memset(ctx->Message_Block, 0, 64);
94: ctx->Length_Low = 0; /* and clear length */
95: ctx->Length_High = 0;
96:
97: for (i = 0; i < SHA1_SIZE; i++)
98: {
99: digest[i] = ctx->Intermediate_Hash[i>>2] >> 8 * ( 3 - ( i & 0x03 ) );
100: }
101: }
102:
103: /**
104: * Process the next 512 bits of the message stored in the array.
105: */
106: static void SHA1ProcessMessageBlock(SHA1_CTX *ctx)
107: {
108: const uint32_t K[] = { /* Constants defined in SHA-1 */
109: 0x5A827999,
110: 0x6ED9EBA1,
111: 0x8F1BBCDC,
112: 0xCA62C1D6
113: };
114: int t; /* Loop counter */
115: uint32_t temp; /* Temporary word value */
116: uint32_t W[80]; /* Word sequence */
117: uint32_t A, B, C, D, E; /* Word buffers */
118:
119: /*
120: * Initialize the first 16 words in the array W
121: */
122: for (t = 0; t < 16; t++)
123: {
124: W[t] = ctx->Message_Block[t * 4] << 24;
125: W[t] |= ctx->Message_Block[t * 4 + 1] << 16;
126: W[t] |= ctx->Message_Block[t * 4 + 2] << 8;
127: W[t] |= ctx->Message_Block[t * 4 + 3];
128: }
129:
130: for (t = 16; t < 80; t++)
131: {
132: W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
133: }
134:
135: A = ctx->Intermediate_Hash[0];
136: B = ctx->Intermediate_Hash[1];
137: C = ctx->Intermediate_Hash[2];
138: D = ctx->Intermediate_Hash[3];
139: E = ctx->Intermediate_Hash[4];
140:
141: for (t = 0; t < 20; t++)
142: {
143: temp = SHA1CircularShift(5,A) +
144: ((B & C) | ((~B) & D)) + E + W[t] + K[0];
145: E = D;
146: D = C;
147: C = SHA1CircularShift(30,B);
148:
149: B = A;
150: A = temp;
151: }
152:
153: for (t = 20; t < 40; t++)
154: {
155: temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
156: E = D;
157: D = C;
158: C = SHA1CircularShift(30,B);
159: B = A;
160: A = temp;
161: }
162:
163: for (t = 40; t < 60; t++)
164: {
165: temp = SHA1CircularShift(5,A) +
166: ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
167: E = D;
168: D = C;
169: C = SHA1CircularShift(30,B);
170: B = A;
171: A = temp;
172: }
173:
174: for (t = 60; t < 80; t++)
175: {
176: temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
177: E = D;
178: D = C;
179: C = SHA1CircularShift(30,B);
180: B = A;
181: A = temp;
182: }
183:
184: ctx->Intermediate_Hash[0] += A;
185: ctx->Intermediate_Hash[1] += B;
186: ctx->Intermediate_Hash[2] += C;
187: ctx->Intermediate_Hash[3] += D;
188: ctx->Intermediate_Hash[4] += E;
189: ctx->Message_Block_Index = 0;
190: }
191:
192: /*
193: * According to the standard, the message must be padded to an even
194: * 512 bits. The first padding bit must be a '1'. The last 64
195: * bits represent the length of the original message. All bits in
196: * between should be 0. This function will pad the message
197: * according to those rules by filling the Message_Block array
198: * accordingly. It will also call the ProcessMessageBlock function
199: * provided appropriately. When it returns, it can be assumed that
200: * the message digest has been computed.
201: *
202: * @param ctx [in, out] The SHA1 context
203: */
204: static void SHA1PadMessage(SHA1_CTX *ctx)
205: {
206: /*
207: * Check to see if the current message block is too small to hold
208: * the initial padding bits and length. If so, we will pad the
209: * block, process it, and then continue padding into a second
210: * block.
211: */
212: if (ctx->Message_Block_Index > 55)
213: {
214: ctx->Message_Block[ctx->Message_Block_Index++] = 0x80;
215: while(ctx->Message_Block_Index < 64)
216: {
217: ctx->Message_Block[ctx->Message_Block_Index++] = 0;
218: }
219:
220: SHA1ProcessMessageBlock(ctx);
221:
222: while (ctx->Message_Block_Index < 56)
223: {
224: ctx->Message_Block[ctx->Message_Block_Index++] = 0;
225: }
226: }
227: else
228: {
229: ctx->Message_Block[ctx->Message_Block_Index++] = 0x80;
230: while(ctx->Message_Block_Index < 56)
231: {
232:
233: ctx->Message_Block[ctx->Message_Block_Index++] = 0;
234: }
235: }
236:
237: /*
238: * Store the message length as the last 8 octets
239: */
240: ctx->Message_Block[56] = ctx->Length_High >> 24;
241: ctx->Message_Block[57] = ctx->Length_High >> 16;
242: ctx->Message_Block[58] = ctx->Length_High >> 8;
243: ctx->Message_Block[59] = ctx->Length_High;
244: ctx->Message_Block[60] = ctx->Length_Low >> 24;
245: ctx->Message_Block[61] = ctx->Length_Low >> 16;
246: ctx->Message_Block[62] = ctx->Length_Low >> 8;
247: ctx->Message_Block[63] = ctx->Length_Low;
248: SHA1ProcessMessageBlock(ctx);
249: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sha1.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / axTLS / crypto