71 #include <asterisk/sha1.h>
74 #define SHA1_ROTL(bits,word) \
75 (((word) << (bits)) | ((word) >> (32-(bits))))
81 static uint32_t addTemp;
82 #define SHA1AddLength(context, length) \
83 (addTemp = (context)->Length_Low, \
84 (context)->Corrupted = \
85 (((context)->Length_Low += (length)) < addTemp) && \
86 (++(context)->Length_High == 0) ? shaInputTooLong \
87 : (context)->Corrupted )
107 context->Length_High = context->Length_Low = 0;
108 context->Message_Block_Index = 0;
111 context->Intermediate_Hash[0] = 0x67452301;
112 context->Intermediate_Hash[1] = 0xEFCDAB89;
113 context->Intermediate_Hash[2] = 0x98BADCFE;
114 context->Intermediate_Hash[3] = 0x10325476;
115 context->Intermediate_Hash[4] = 0xC3D2E1F0;
117 context->Computed = 0;
118 context->Corrupted = shaSuccess;
134 const uint8_t *message_array,
unsigned length)
142 if (!message_array) {
146 if (context->Computed) {
147 context->Corrupted = shaStateError;
148 return shaStateError;
151 if (context->Corrupted) {
152 return context->Corrupted;
156 context->Message_Block[context->Message_Block_Index++] =
159 if ((SHA1AddLength(context, 8) == shaSuccess) &&
160 (context->Message_Block_Index == SHA1_Message_Block_Size))
166 return context->Corrupted;
182 static uint8_t masks[8] = {
189 static uint8_t markbit[8] = {
200 if (context->Corrupted)
201 return context->Corrupted;
202 if (context->Computed)
203 return context->Corrupted = shaStateError;
205 return context->Corrupted = shaBadParam;
207 SHA1AddLength(context, length);
209 (uint8_t) ((message_bits & masks[length]) |
212 return context->Corrupted;
233 if (!Message_Digest) {
236 if (context->Corrupted) {
237 return context->Corrupted;
240 if (!context->Computed) {
244 for (i = 0; i < SHA1HashSize; ++i) {
245 Message_Digest[i] = (uint8_t) (context->Intermediate_Hash[i >> 2]
246 >> (8 * (3 - (i & 0x03))));
262 const uint32_t K[4] = {
263 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6
268 uint32_t A, B, C, D, E;
273 for (t = 0; t < 16; t++) {
274 W[t] = ((uint32_t) context->Message_Block[t * 4]) << 24;
275 W[t] |= ((uint32_t) context->Message_Block[t * 4 + 1]) << 16;
276 W[t] |= ((uint32_t) context->Message_Block[t * 4 + 2]) << 8;
277 W[t] |= ((uint32_t) context->Message_Block[t * 4 + 3]);
280 for (t = 16; t < 80; t++) {
281 W[t] =
SHA1_ROTL(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]);
284 A = context->Intermediate_Hash[0];
285 B = context->Intermediate_Hash[1];
286 C = context->Intermediate_Hash[2];
287 D = context->Intermediate_Hash[3];
288 E = context->Intermediate_Hash[4];
290 for (t = 0; t < 20; t++) {
291 temp =
SHA1_ROTL(5, A) + SHA_Ch(B, C, D) + E + W[t] + K[0];
299 for (t = 20; t < 40; t++) {
300 temp =
SHA1_ROTL(5, A) + SHA_Parity(B, C, D) + E + W[t] + K[1];
308 for (t = 40; t < 60; t++) {
309 temp =
SHA1_ROTL(5, A) + SHA_Maj(B, C, D) + E + W[t] + K[2];
317 for (t = 60; t < 80; t++) {
318 temp =
SHA1_ROTL(5, A) + SHA_Parity(B, C, D) + E + W[t] + K[3];
326 context->Intermediate_Hash[0] += A;
327 context->Intermediate_Hash[1] += B;
328 context->Intermediate_Hash[2] += C;
329 context->Intermediate_Hash[3] += D;
330 context->Intermediate_Hash[4] += E;
332 context->Message_Block_Index = 0;
349 for (i = 0; i < SHA1_Message_Block_Size; ++i) {
350 context->Message_Block[i] = 0;
352 context->Length_High = 0;
353 context->Length_Low = 0;
354 context->Computed = 1;
378 if (context->Message_Block_Index >= (SHA1_Message_Block_Size - 8)) {
379 context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
380 while (context->Message_Block_Index < SHA1_Message_Block_Size) {
381 context->Message_Block[context->Message_Block_Index++] = 0;
386 context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
388 while (context->Message_Block_Index < (SHA1_Message_Block_Size - 8)) {
389 context->Message_Block[context->Message_Block_Index++] = 0;
395 context->Message_Block[56] = (uint8_t) (context->Length_High >> 24);
396 context->Message_Block[57] = (uint8_t) (context->Length_High >> 16);
397 context->Message_Block[58] = (uint8_t) (context->Length_High >> 8);
398 context->Message_Block[59] = (uint8_t) (context->Length_High);
399 context->Message_Block[60] = (uint8_t) (context->Length_Low >> 24);
400 context->Message_Block[61] = (uint8_t) (context->Length_Low >> 16);
401 context->Message_Block[62] = (uint8_t) (context->Length_Low >> 8);
402 context->Message_Block[63] = (uint8_t) (context->Length_Low);
static void SHA1ProcessMessageBlock(SHA1Context *context)
Process the next 512 bits of the message stored in the Message_Block array.
int SHA1FinalBits(SHA1Context *context, uint8_t message_bits, unsigned int length)
SHA1FinalBits Add in any final bits of the message.
int SHA1Result(SHA1Context *context, uint8_t Message_Digest[SHA1HashSize])
SHA1Result Returns the resulting 160-bit digest.
int SHA1Reset(SHA1Context *context)
SHA1Reset.
static void SHA1PadMessage(SHA1Context *context, uint8_t Pad_Byte)
Pad message to be 512 bits.
int SHA1Input(SHA1Context *context, const uint8_t *message_array, unsigned length)
SHA1Input.
#define SHA1_ROTL(bits, word)
static void SHA1Finalize(SHA1Context *context, uint8_t Pad_Byte)
This helper function finishes off the digest calculations.