Update SHA1 code to RFC 6234

RFC 6234 is an update to RFC 3174 from which the code was originally taken.
It has a slightly better code, and a better phrased license (simple 3-clause
BSD).

* main/sha1.c is sha1.c from RFC 6234 with formatting changes only.
* include/asterisk/sha1.h merges sha.h and sha-private.h from RFC 6234.
* Removed unused include of asterisk/sha1.h from main/channels.c

Review: https://reviewboard.asterisk.org/r/1503/

Merge-From: http://svn.asterisk.org/svn/asterisk/branches/1.8@340263

Merge-From: http://svn.asterisk.org/svn/asterisk/branches/10@340280


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@340283 65c4cc65-6c06-0410-ace0-fbb531ad65f3

1 files changed, 247 insertions, 175 deletions

diff --git a/main/sha1.c b/main/sha1.c
index 4226ecf63..9ae3b94c4 100644
--- a/main/sha1.c
+++ b/main/sha1.c
@@ -1,75 +1,95 @@
 /*! \file
  *
- * \brief Based on the RFC 3174
+ * \brief Based on the RFC 6234
  * 
- * Full Copyright Statement
+ * Copyright (c) 2011 IETF Trust and the persons identified as
+ * authors of the code.  All rights reserved.
  *
- *  Copyright (C) The Internet Society (2001).  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 document and translations of it may be copied and furnished to
- *  others, and derivative works that comment on or otherwise explain it
- *  or assist in its implementation may be prepared, copied, published
- *  and distributed, in whole or in part, without restriction of any
- *  kind, provided that the above copyright notice and this paragraph are
- *  included on all such copies and derivative works.  However, this
- *  document itself may not be modified in any way, such as by removing
- *  the copyright notice or references to the Internet Society or other
- *  Internet organizations, except as needed for the purpose of
- *  developing Internet standards in which case the procedures for
- *  copyrights defined in the Internet Standards process must be
- *  followed, or as required to translate it into languages other than
- *  English.
+ * - Redistributions of source code must retain the above
+ *   copyright notice, this list of conditions and
+ *   the following disclaimer.
  *
- *  The limited permissions granted above are perpetual and will not be
- *  revoked by the Internet Society or its successors or assigns.
-
- *  This document and the information contained herein is provided on an
- *  "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
- *  TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
- *  BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
- *  HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
- *  MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
  *
+ * - Neither the name of Internet Society, IETF or IETF Trust, nor
+ *   the names of specific contributors, may be used to endorse or
+ *   promote products derived from this software without specific
+ *   prior written permission.
+ *
+ * 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 Hashing Algorithm 1 as
- *	  defined in FIPS PUB 180-1 published April 17, 1995.
+ *      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, produces a 160-bit message digest for a given
- *	  data stream.  It should take about 2**n steps to find a
- *	  message with the same digest as a given message and
- *	  2**(n/2) to find any two messages with the same digest,
- *	  when n is the digest size in bits.  Therefore, this
- *	  algorithm can serve as a means of providing a
- *	  "fingerprint" for a message.
+ *      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 "sha1.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.
+ *      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.  Although SHA-1 allows a message digest to be generated
- *	  for messages of any number of bits less than 2^64, this
- *	  implementation only works with messages with a length that is
- *	  a multiple of the size of an 8-bit character.
- *
+ *      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.
  */
 
-#include "asterisk.h"
-#include "asterisk/sha1.h"
+#include <asterisk/sha1.h>
 
 /*! Define the SHA1 circular left shift macro */
-#define SHA1CircularShift(bits,word) \
-		         (((word) << (bits)) | ((word) >> (32-(bits))))
+#define SHA1_ROTL(bits,word) \
+                (((word) << (bits)) | ((word) >> (32-(bits))))
 
-/* Local Function Prototyptes */
-void SHA1PadMessage(SHA1Context *);
-void SHA1ProcessMessageBlock(SHA1Context *);
+/*
+ * Add "length" to the length.
+ * Set Corrupted when overflow has occurred.
+ */
+static uint32_t addTemp;
+#define SHA1AddLength(context, length)                     \
+    (addTemp = (context)->Length_Low,                      \
+     (context)->Corrupted =                                \
+        (((context)->Length_Low += (length)) < addTemp) && \
+        (++(context)->Length_High == 0) ? shaInputTooLong  \
+                                        : (context)->Corrupted )
+
+/* Local Function Prototypes */
+static void SHA1ProcessMessageBlock(SHA1Context * context);
+static void SHA1Finalize(SHA1Context * context, uint8_t Pad_Byte);
+static void SHA1PadMessage(SHA1Context * context, uint8_t Pad_Byte);
 
 /*!
  * \brief SHA1Reset
@@ -84,59 +104,18 @@ int SHA1Reset(SHA1Context *context)
 		return shaNull;
 	}
 
-	context->Length_Low             = 0;
-	context->Length_High            = 0;
-	context->Message_Block_Index    = 0;
-
-	context->Intermediate_Hash[0]   = 0x67452301;
-	context->Intermediate_Hash[1]   = 0xEFCDAB89;
-	context->Intermediate_Hash[2]   = 0x98BADCFE;
-	context->Intermediate_Hash[3]   = 0x10325476;
-	context->Intermediate_Hash[4]   = 0xC3D2E1F0;
-
-	context->Computed               = 0;
-	context->Corrupted              = 0;
-
-	return shaSuccess;
-}
-
-/*!
- * \brief SHA1Result
- * \param context [in/out] The context to use to calculate the SHA-1 hash.
- * \param Message_Digest [out] Where 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 0th element, 
- * 	the last octet of hash in the 19th element.
- * \return sha Error Code.
- */
-int SHA1Result( SHA1Context *context,
-		         uint8_t Message_Digest[SHA1HashSize])
-{
-	int i;
-
-	if (!context || !Message_Digest) {
-		return shaNull;
-	}
-
-	if (context->Corrupted) {
-		return context->Corrupted;
-	}
+	context->Length_High = context->Length_Low = 0;
+	context->Message_Block_Index = 0;
 
-	if (!context->Computed) {
-		SHA1PadMessage(context);
-		for (i = 0; i < 64; ++i) {
-			/* message may be sensitive, clear it out */
-			context->Message_Block[i] = 0;
-		}
-		context->Length_Low = 0;    /* and clear length */
-		context->Length_High = 0;
-		context->Computed = 1;
-	}
+	/* Initial Hash Values: FIPS 180-3 section 5.3.1 */
+	context->Intermediate_Hash[0] = 0x67452301;
+	context->Intermediate_Hash[1] = 0xEFCDAB89;
+	context->Intermediate_Hash[2] = 0x98BADCFE;
+	context->Intermediate_Hash[3] = 0x10325476;
+	context->Intermediate_Hash[4] = 0xC3D2E1F0;
 
-	for (i = 0; i < SHA1HashSize; ++i) {
-		Message_Digest[i] = context->Intermediate_Hash[i >> 2] >> 8 * ( 3 - ( i & 0x03 ) );
-	}
+	context->Computed = 0;
+	context->Corrupted = shaSuccess;
 
 	return shaSuccess;
 }
@@ -151,13 +130,16 @@ int SHA1Result( SHA1Context *context,
  *  of the message.
  * \return sha Error Code.
  */
-int SHA1Input(SHA1Context *context, const uint8_t *message_array, unsigned length)
+int SHA1Input(SHA1Context *context,
+			  const uint8_t *message_array, unsigned length)
 {
+	if (!context) {
+		return shaNull;
+	}
 	if (!length) {
 		return shaSuccess;
 	}
-
-	if (!context || !message_array) {
+	if (!message_array) {
 		return shaNull;
 	}
 
@@ -170,25 +152,100 @@ int SHA1Input(SHA1Context *context, const uint8_t *message_array, unsigned lengt
 		return context->Corrupted;
 	}
 
-	while (length-- && !context->Corrupted) {
-		context->Message_Block[context->Message_Block_Index++] = (*message_array & 0xFF);
-
-		context->Length_Low += 8;
-		if (context->Length_Low == 0) {
-			context->Length_High++;
-			if (context->Length_High == 0) {
-				/* Message is too long */
-				context->Corrupted = 1;
-			}
-		}
+	while (length--) {
+		context->Message_Block[context->Message_Block_Index++] =
+			*message_array;
 
-		if (context->Message_Block_Index == 64) {
+		if ((SHA1AddLength(context, 8) == shaSuccess) &&
+			(context->Message_Block_Index == SHA1_Message_Block_Size))
 			SHA1ProcessMessageBlock(context);
-		}
 
 		message_array++;
 	}
 
+	return context->Corrupted;
+}
+
+/*!
+ * \brief SHA1FinalBits Add in any final bits of the message.
+ *
+ * \param context [in/out] The SHA context to update.
+ * \param message_bits [in] The final bits of the message, in the upper portion of the
+ *     byte.  (Use 0b###00000 instead of 0b00000### to input the
+ *     three bits ###.)
+ * \param length [in] *     The number of bits in message_bits, between 1 and 7.
+ * \returns sha Error Code.
+ */
+int SHA1FinalBits(SHA1Context * context, uint8_t message_bits,
+				  unsigned int length)
+{
+	static uint8_t masks[8] = {
+		/* 0 0b00000000 */ 0x00, /* 1 0b10000000 */ 0x80,
+		/* 2 0b11000000 */ 0xC0, /* 3 0b11100000 */ 0xE0,
+		/* 4 0b11110000 */ 0xF0, /* 5 0b11111000 */ 0xF8,
+		/* 6 0b11111100 */ 0xFC, /* 7 0b11111110 */ 0xFE
+	};
+
+	static uint8_t markbit[8] = {
+		/* 0 0b10000000 */ 0x80, /* 1 0b01000000 */ 0x40,
+		/* 2 0b00100000 */ 0x20, /* 3 0b00010000 */ 0x10,
+		/* 4 0b00001000 */ 0x08, /* 5 0b00000100 */ 0x04,
+		/* 6 0b00000010 */ 0x02, /* 7 0b00000001 */ 0x01
+	};
+
+	if (!context)
+		return shaNull;
+	if (!length)
+		return shaSuccess;
+	if (context->Corrupted)
+		return context->Corrupted;
+	if (context->Computed)
+		return context->Corrupted = shaStateError;
+	if (length >= 8)
+		return context->Corrupted = shaBadParam;
+
+	SHA1AddLength(context, length);
+	SHA1Finalize(context,
+				 (uint8_t) ((message_bits & masks[length]) |
+							markbit[length]));
+
+	return context->Corrupted;
+}
+
+/*
+ * \brief SHA1Result Returns the resulting 160-bit digest
+ * \param context [in/out] The SHA context to update.
+ * \param Message_Digest [out] Where 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.
+ */
+int SHA1Result(SHA1Context * context, uint8_t Message_Digest[SHA1HashSize])
+{
+	int i;
+
+	if (!context) {
+		return shaNull;
+	}
+	if (!Message_Digest) {
+		return shaNull;
+	}
+	if (context->Corrupted) {
+		return context->Corrupted;
+	}
+
+	if (!context->Computed) {
+		SHA1Finalize(context, 0x80);
+	}
+
+	for (i = 0; i < SHA1HashSize; ++i) {
+		Message_Digest[i] = (uint8_t) (context->Intermediate_Hash[i >> 2]
+				>> (8 * (3 - (i & 0x03))));
+	}
+
 	return shaSuccess;
 }
 
@@ -200,31 +257,29 @@ int SHA1Input(SHA1Context *context, const uint8_t *message_array, unsigned lengt
  *	  names used in the publication.
  * \returns nothing.
  */
-void SHA1ProcessMessageBlock(SHA1Context *context)
+static void SHA1ProcessMessageBlock(SHA1Context *context)
 {
-	const uint32_t K[] =     {     /* Constants defined in SHA-1  */
-	                         0x5A827999,
-	                         0x6ED9EBA1,
-	                         0x8F1BBCDC,
-	                         0xCA62C1D6
-	                         };
-	int	        t;                 /* Loop counter                */
-	uint32_t    temp;              /* Temporary word value        */
-	uint32_t    W[80];             /* Word sequence               */
-	uint32_t    A, B, C, D, E;     /* Word buffers                */
+	/* Constants defined in FIPS 180-3, section 4.2.1 */
+	const uint32_t K[4] = {
+		0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6
+	};
+	int t;						/* Loop counter */
+	uint32_t temp;				/* Temporary word value */
+	uint32_t W[80];				/* Word sequence */
+	uint32_t A, B, C, D, E;		/* Word buffers */
 
 	/*
-	 *  Initialize the first 16 words in the array W
+	 * Initialize the first 16 words in the array W
 	 */
 	for (t = 0; t < 16; t++) {
-		W[t] = context->Message_Block[t * 4] << 24;
-		W[t] |= context->Message_Block[t * 4 + 1] << 16;
-		W[t] |= context->Message_Block[t * 4 + 2] << 8;
-		W[t] |= context->Message_Block[t * 4 + 3];
+		W[t] = ((uint32_t) context->Message_Block[t * 4]) << 24;
+		W[t] |= ((uint32_t) context->Message_Block[t * 4 + 1]) << 16;
+		W[t] |= ((uint32_t) context->Message_Block[t * 4 + 2]) << 8;
+		W[t] |= ((uint32_t) context->Message_Block[t * 4 + 3]);
 	}
 
 	for (t = 16; t < 80; t++) {
-		W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
+		W[t] = SHA1_ROTL(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]);
 	}
 
 	A = context->Intermediate_Hash[0];
@@ -234,37 +289,37 @@ void SHA1ProcessMessageBlock(SHA1Context *context)
 	E = context->Intermediate_Hash[4];
 
 	for (t = 0; t < 20; t++) {
-		temp = SHA1CircularShift(5,A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
+		temp = SHA1_ROTL(5, A) + SHA_Ch(B, C, D) + E + W[t] + K[0];
 		E = D;
 		D = C;
-		C = SHA1CircularShift(30,B);
+		C = SHA1_ROTL(30, B);
 		B = A;
 		A = temp;
 	}
 
 	for (t = 20; t < 40; t++) {
-		temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
+		temp = SHA1_ROTL(5, A) + SHA_Parity(B, C, D) + E + W[t] + K[1];
 		E = D;
 		D = C;
-		C = SHA1CircularShift(30,B);
+		C = SHA1_ROTL(30, B);
 		B = A;
 		A = temp;
 	}
 
 	for (t = 40; t < 60; t++) {
-		temp = SHA1CircularShift(5,A) + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
+		temp = SHA1_ROTL(5, A) + SHA_Maj(B, C, D) + E + W[t] + K[2];
 		E = D;
 		D = C;
-		C = SHA1CircularShift(30,B);
+		C = SHA1_ROTL(30, B);
 		B = A;
 		A = temp;
 	}
 
 	for (t = 60; t < 80; t++) {
-		temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
+		temp = SHA1_ROTL(5, A) + SHA_Parity(B, C, D) + E + W[t] + K[3];
 		E = D;
 		D = C;
-		C = SHA1CircularShift(30,B);
+		C = SHA1_ROTL(30, B);
 		B = A;
 		A = temp;
 	}
@@ -278,24 +333,45 @@ void SHA1ProcessMessageBlock(SHA1Context *context)
 	context->Message_Block_Index = 0;
 }
 
+/*!
+ * \brief This helper function finishes off the digest calculations.
+ * \param context [in/out]  The context to pad.
+ * \param Pad_byte [in]  The 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.
+ * \returns sha Error Code.
+ */
+static void SHA1Finalize(SHA1Context * context, uint8_t Pad_Byte)
+{
+	int i;
+	SHA1PadMessage(context, Pad_Byte);
+	/* message may be sensitive, clear it out */
+	for (i = 0; i < SHA1_Message_Block_Size; ++i) {
+		context->Message_Block[i] = 0;
+	}
+	context->Length_High = 0;	/* and clear length */
+	context->Length_Low = 0;
+	context->Computed = 1;
+}
 
 /*!
  * \brief Pad message to be 512 bits.
  * \param context [in/out]  The context to pad.
- * 
- * According to the standard, the message must be padded to an even
- *  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 function will pad the message
- *  according to those rules by filling the Message_Block array
- *  accordingly.  It will also call the ProcessMessageBlock function
- *  provided appropriately.  When it returns, it can be assumed that
- *  the message digest has been computed.
+ * \param Pad_byte [in]  Last 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.
  *
  * \returns nothing.
  */
-
-void SHA1PadMessage(SHA1Context *context)
+static void SHA1PadMessage(SHA1Context * context, uint8_t Pad_Byte)
 {
 	/*
 	 *  Check to see if the current message block is too small to hold
@@ -303,35 +379,31 @@ void SHA1PadMessage(SHA1Context *context)
 	 *  block, process it, and then continue padding into a second
 	 *  block.
 	 */
-	if (context->Message_Block_Index > 55) {
-		context->Message_Block[context->Message_Block_Index++] = 0x80;
-		while (context->Message_Block_Index < 64) {
+	if (context->Message_Block_Index >= (SHA1_Message_Block_Size - 8)) {
+		context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
+		while (context->Message_Block_Index < SHA1_Message_Block_Size) {
 			context->Message_Block[context->Message_Block_Index++] = 0;
 		}
 
 		SHA1ProcessMessageBlock(context);
+	} else
+		context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
 
-		while (context->Message_Block_Index < 56) {
-			context->Message_Block[context->Message_Block_Index++] = 0;
-		}
-	} else {
-		context->Message_Block[context->Message_Block_Index++] = 0x80;
-		while (context->Message_Block_Index < 56) {
-			context->Message_Block[context->Message_Block_Index++] = 0;
-		}
+	while (context->Message_Block_Index < (SHA1_Message_Block_Size - 8)) {
+		context->Message_Block[context->Message_Block_Index++] = 0;
 	}
 
 	/*
 	 *  Store the message length as the last 8 octets
 	 */
-	context->Message_Block[56] = context->Length_High >> 24;
-	context->Message_Block[57] = context->Length_High >> 16;
-	context->Message_Block[58] = context->Length_High >> 8;
-	context->Message_Block[59] = context->Length_High;
-	context->Message_Block[60] = context->Length_Low >> 24;
-	context->Message_Block[61] = context->Length_Low >> 16;
-	context->Message_Block[62] = context->Length_Low >> 8;
-	context->Message_Block[63] = context->Length_Low;
+	context->Message_Block[56] = (uint8_t) (context->Length_High >> 24);
+	context->Message_Block[57] = (uint8_t) (context->Length_High >> 16);
+	context->Message_Block[58] = (uint8_t) (context->Length_High >> 8);
+	context->Message_Block[59] = (uint8_t) (context->Length_High);
+	context->Message_Block[60] = (uint8_t) (context->Length_Low >> 24);
+	context->Message_Block[61] = (uint8_t) (context->Length_Low >> 16);
+	context->Message_Block[62] = (uint8_t) (context->Length_Low >> 8);
+	context->Message_Block[63] = (uint8_t) (context->Length_Low);
 
 	SHA1ProcessMessageBlock(context);
 }