Asterisk - The Open Source Telephony Project  21.4.1
Macros | Functions | Variables
sha1.c File Reference

Based on the RFC 6234. More...

#include <asterisk/sha1.h>

Go to the source code of this file.

Macros

#define SHA1_ROTL(bits, word)   (((word) << (bits)) | ((word) >> (32-(bits))))
 
#define SHA1AddLength(context, length)
 

Functions

int SHA1FinalBits (SHA1Context *context, uint8_t message_bits, unsigned int length)
 SHA1FinalBits Add in any final bits of the message. More...
 
static void SHA1Finalize (SHA1Context *context, uint8_t Pad_Byte)
 This helper function finishes off the digest calculations. More...
 
int SHA1Input (SHA1Context *context, const uint8_t *message_array, unsigned length)
 SHA1Input. More...
 
static void SHA1PadMessage (SHA1Context *context, uint8_t Pad_Byte)
 Pad message to be 512 bits. More...
 
static void SHA1ProcessMessageBlock (SHA1Context *context)
 Process the next 512 bits of the message stored in the Message_Block array. More...
 
int SHA1Reset (SHA1Context *context)
 SHA1Reset. More...
 
int SHA1Result (SHA1Context *context, uint8_t Message_Digest[SHA1HashSize])
 SHA1Result Returns the resulting 160-bit digest. More...
 

Variables

static uint32_t addTemp
 

Detailed Description

Based on the RFC 6234.

Copyright (c) 2011 IETF Trust and the persons identified as authors of the code. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description: This file implements the Secure Hash Algorithm SHA-1 as defined in the U.S. National Institute of Standards and Technology Federal Information Processing Standards Publication (FIPS PUB) 180-3 published in October 2008 and formerly defined in its predecessors, FIPS PUB 180-1 and FIP PUB 180-2.

A combined document showing all algorithms is available at http://csrc.nist.gov/publications/fips/ fips180-3/fips180-3_final.pdf

The SHA-1 algorithm produces a 160-bit message digest for a given data stream that can serve as a means of providing a "fingerprint" for a message.

Portability Issues: SHA-1 is defined in terms of 32-bit "words". This code uses <stdint.h> (included via "sha.h") to define 32- and 8-bit unsigned integer types. If your C compiler does not support 32-bit unsigned integers, this code is not appropriate.

Caveats: SHA-1 is designed to work with messages less than 2^64 bits long. This implementation uses SHA1Input() to hash the bits that are a multiple of the size of an 8-bit octet, and then optionally uses SHA1FinalBits() to hash the final few bits of the input.

Definition in file sha1.c.

Macro Definition Documentation

#define SHA1_ROTL (   bits,
  word 
)    (((word) << (bits)) | ((word) >> (32-(bits))))

Define the SHA1 circular left shift macro

Definition at line 74 of file sha1.c.

Referenced by SHA1ProcessMessageBlock().

#define SHA1AddLength (   context,
  length 
)
Value:
(addTemp = (context)->Length_Low, \
(context)->Corrupted = \
(((context)->Length_Low += (length)) < addTemp) && \
(++(context)->Length_High == 0) ? shaInputTooLong \
: (context)->Corrupted )

Definition at line 82 of file sha1.c.

Function Documentation

int SHA1FinalBits ( SHA1Context context,
uint8_t  message_bits,
unsigned int  length 
)

SHA1FinalBits Add in any final bits of the message.

Parameters
[in,out]contextThe SHA context to update.
[in]message_bitsThe final bits of the message, in the upper portion of the byte. (Use 0b###00000 instead of 0b00000### to input the three bits ###.)
[in]lengthThe number of bits in message_bits, between 1 and 7.
Returns
sha Error Code.

Definition at line 179 of file sha1.c.

References SHA1Finalize().

181 {
182  static uint8_t masks[8] = {
183  /* 0 0b00000000 */ 0x00, /* 1 0b10000000 */ 0x80,
184  /* 2 0b11000000 */ 0xC0, /* 3 0b11100000 */ 0xE0,
185  /* 4 0b11110000 */ 0xF0, /* 5 0b11111000 */ 0xF8,
186  /* 6 0b11111100 */ 0xFC, /* 7 0b11111110 */ 0xFE
187  };
188 
189  static uint8_t markbit[8] = {
190  /* 0 0b10000000 */ 0x80, /* 1 0b01000000 */ 0x40,
191  /* 2 0b00100000 */ 0x20, /* 3 0b00010000 */ 0x10,
192  /* 4 0b00001000 */ 0x08, /* 5 0b00000100 */ 0x04,
193  /* 6 0b00000010 */ 0x02, /* 7 0b00000001 */ 0x01
194  };
195 
196  if (!context)
197  return shaNull;
198  if (!length)
199  return shaSuccess;
200  if (context->Corrupted)
201  return context->Corrupted;
202  if (context->Computed)
203  return context->Corrupted = shaStateError;
204  if (length >= 8)
205  return context->Corrupted = shaBadParam;
206 
207  SHA1AddLength(context, length);
208  SHA1Finalize(context,
209  (uint8_t) ((message_bits & masks[length]) |
210  markbit[length]));
211 
212  return context->Corrupted;
213 }
static void SHA1Finalize(SHA1Context *context, uint8_t Pad_Byte)
This helper function finishes off the digest calculations.
Definition: sha1.c:344
static void SHA1Finalize ( SHA1Context context,
uint8_t  Pad_Byte 
)
static

This helper function finishes off the digest calculations.

Parameters
[in,out]contextThe context to pad.
[in]Pad_ByteThe last byte to add to the message block before the 0-padding and length. This will contain the last bits of the message followed by another single bit. If the message was an exact multiple of 8-bits long, Pad_Byte will be 0x80.

Definition at line 344 of file sha1.c.

References SHA1PadMessage().

Referenced by SHA1FinalBits(), and SHA1Result().

345 {
346  int i;
347  SHA1PadMessage(context, Pad_Byte);
348  /* message may be sensitive, clear it out */
349  for (i = 0; i < SHA1_Message_Block_Size; ++i) {
350  context->Message_Block[i] = 0;
351  }
352  context->Length_High = 0; /* and clear length */
353  context->Length_Low = 0;
354  context->Computed = 1;
355 }
static void SHA1PadMessage(SHA1Context *context, uint8_t Pad_Byte)
Pad message to be 512 bits.
Definition: sha1.c:370
int SHA1Input ( SHA1Context context,
const uint8_t *  message_array,
unsigned  length 
)

SHA1Input.

Parameters
[in,out]contextThe SHA context to update
[in]message_arrayAn array of characters representing the next portion of the message.
[in]lengthThe length of the message in message_array. This function accepts an array of octets as the next portion of the message.
Returns
sha Error Code.

Definition at line 133 of file sha1.c.

References SHA1ProcessMessageBlock().

Referenced by ast_sha1_hash(), and ast_sha1_hash_uint().

135 {
136  if (!context) {
137  return shaNull;
138  }
139  if (!length) {
140  return shaSuccess;
141  }
142  if (!message_array) {
143  return shaNull;
144  }
145 
146  if (context->Computed) {
147  context->Corrupted = shaStateError;
148  return shaStateError;
149  }
150 
151  if (context->Corrupted) {
152  return context->Corrupted;
153  }
154 
155  while (length--) {
156  context->Message_Block[context->Message_Block_Index++] =
157  *message_array;
158 
159  if ((SHA1AddLength(context, 8) == shaSuccess) &&
160  (context->Message_Block_Index == SHA1_Message_Block_Size))
161  SHA1ProcessMessageBlock(context);
162 
163  message_array++;
164  }
165 
166  return context->Corrupted;
167 }
static void SHA1ProcessMessageBlock(SHA1Context *context)
Process the next 512 bits of the message stored in the Message_Block array.
Definition: sha1.c:259
static void SHA1PadMessage ( SHA1Context context,
uint8_t  Pad_Byte 
)
static

Pad message to be 512 bits.

Parameters
[in,out]contextThe context to pad.
[in]Pad_ByteLast padding byte.

According to the standard, the message must be padded to the next even multiple of 512 bits. The first padding bit must be a '1'. The last 64 bits represent the length of the original message. All bits in between should be 0. This helper function will pad the message according to those rules by filling the Message_Block array accordingly. When it returns, it can be assumed that the message digest has been computed.

Definition at line 370 of file sha1.c.

References SHA1ProcessMessageBlock().

Referenced by SHA1Finalize().

371 {
372  /*
373  * Check to see if the current message block is too small to hold
374  * the initial padding bits and length. If so, we will pad the
375  * block, process it, and then continue padding into a second
376  * block.
377  */
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;
382  }
383 
384  SHA1ProcessMessageBlock(context);
385  } else
386  context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
387 
388  while (context->Message_Block_Index < (SHA1_Message_Block_Size - 8)) {
389  context->Message_Block[context->Message_Block_Index++] = 0;
390  }
391 
392  /*
393  * Store the message length as the last 8 octets
394  */
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);
403 
404  SHA1ProcessMessageBlock(context);
405 }
static void SHA1ProcessMessageBlock(SHA1Context *context)
Process the next 512 bits of the message stored in the Message_Block array.
Definition: sha1.c:259
static void SHA1ProcessMessageBlock ( SHA1Context context)
static

Process the next 512 bits of the message stored in the Message_Block array.

Parameters
[in,out]contextThe SHA context to update
Note
Many of the variable names in this code, especially the single character names, were used because those were the names used in the publication.

Definition at line 259 of file sha1.c.

References SHA1_ROTL.

Referenced by SHA1Input(), and SHA1PadMessage().

260 {
261  /* Constants defined in FIPS 180-3, section 4.2.1 */
262  const uint32_t K[4] = {
263  0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6
264  };
265  int t; /* Loop counter */
266  uint32_t temp; /* Temporary word value */
267  uint32_t W[80]; /* Word sequence */
268  uint32_t A, B, C, D, E; /* Word buffers */
269 
270  /*
271  * Initialize the first 16 words in the array W
272  */
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]);
278  }
279 
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]);
282  }
283 
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];
289 
290  for (t = 0; t < 20; t++) {
291  temp = SHA1_ROTL(5, A) + SHA_Ch(B, C, D) + E + W[t] + K[0];
292  E = D;
293  D = C;
294  C = SHA1_ROTL(30, B);
295  B = A;
296  A = temp;
297  }
298 
299  for (t = 20; t < 40; t++) {
300  temp = SHA1_ROTL(5, A) + SHA_Parity(B, C, D) + E + W[t] + K[1];
301  E = D;
302  D = C;
303  C = SHA1_ROTL(30, B);
304  B = A;
305  A = temp;
306  }
307 
308  for (t = 40; t < 60; t++) {
309  temp = SHA1_ROTL(5, A) + SHA_Maj(B, C, D) + E + W[t] + K[2];
310  E = D;
311  D = C;
312  C = SHA1_ROTL(30, B);
313  B = A;
314  A = temp;
315  }
316 
317  for (t = 60; t < 80; t++) {
318  temp = SHA1_ROTL(5, A) + SHA_Parity(B, C, D) + E + W[t] + K[3];
319  E = D;
320  D = C;
321  C = SHA1_ROTL(30, B);
322  B = A;
323  A = temp;
324  }
325 
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;
331 
332  context->Message_Block_Index = 0;
333 }
#define SHA1_ROTL(bits, word)
Definition: sha1.c:74
int SHA1Reset ( SHA1Context context)

SHA1Reset.

Parameters
contextthe context to be reset. This function will initialize the SHA1Context in preparation for computing a new SHA1 message digest.
Returns
sha Error Code.

Definition at line 101 of file sha1.c.

Referenced by ast_sha1_hash(), and ast_sha1_hash_uint().

102 {
103  if (!context) {
104  return shaNull;
105  }
106 
107  context->Length_High = context->Length_Low = 0;
108  context->Message_Block_Index = 0;
109 
110  /* Initial Hash Values: FIPS 180-3 section 5.3.1 */
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;
116 
117  context->Computed = 0;
118  context->Corrupted = shaSuccess;
119 
120  return shaSuccess;
121 }
int SHA1Result ( SHA1Context context,
uint8_t  Message_Digest[SHA1HashSize] 
)

SHA1Result Returns the resulting 160-bit digest.

Parameters
[in,out]contextThe SHA context to update.
[out]Message_DigestWhere the digest is returned.

This function will return the 160-bit message digest into the Message_Digest array provided by the caller.

Note
The first octet of hash is stored in the element with index 0, the last octet of hash in the element with index 19.
Returns
sha Error Code.

Definition at line 226 of file sha1.c.

References SHA1Finalize().

Referenced by ast_sha1_hash(), and ast_sha1_hash_uint().

227 {
228  int i;
229 
230  if (!context) {
231  return shaNull;
232  }
233  if (!Message_Digest) {
234  return shaNull;
235  }
236  if (context->Corrupted) {
237  return context->Corrupted;
238  }
239 
240  if (!context->Computed) {
241  SHA1Finalize(context, 0x80);
242  }
243 
244  for (i = 0; i < SHA1HashSize; ++i) {
245  Message_Digest[i] = (uint8_t) (context->Intermediate_Hash[i >> 2]
246  >> (8 * (3 - (i & 0x03))));
247  }
248 
249  return shaSuccess;
250 }
static void SHA1Finalize(SHA1Context *context, uint8_t Pad_Byte)
This helper function finishes off the digest calculations.
Definition: sha1.c:344