remove windows-style line endings
authorRussell Bryant <russell@russellbryant.com>
Sat, 4 Feb 2006 16:32:27 +0000 (16:32 +0000)
committerRussell Bryant <russell@russellbryant.com>
Sat, 4 Feb 2006 16:32:27 +0000 (16:32 +0000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@9150 65c4cc65-6c06-0410-ace0-fbb531ad65f3

include/asterisk/sha1.h
sha1.c

index 016556e..5bf4d5b 100644 (file)
@@ -1,82 +1,82 @@
-/*\r
- *  sha1.h\r
- *\r
- *  Description:\r
- *      This is the header file for code which implements the Secure\r
- *      Hashing Algorithm 1 as defined in FIPS PUB 180-1 published\r
- *      April 17, 1995.\r
- *\r
- *      Many of the variable names in this code, especially the\r
- *      single character names, were used because those were the names\r
- *      used in the publication.\r
- *\r
- *      Please read the file sha1.c for more information.\r
- *\r
- */\r
-\r
-\r
-#ifndef _SHA1_H_\r
-#define _SHA1_H_\r
-\r
-\r
-\r
-#if defined(__OpenBSD__) || defined( __FreeBSD__)\r
-#include <inttypes.h>\r
-#else\r
-#include <stdint.h>\r
-#endif\r
-\r
-/*\r
- * If you do not have the ISO standard stdint.h header file, then you\r
- * must typdef the following:\r
- *    name              meaning\r
- *  uint32_t         unsigned 32 bit integer\r
- *  uint8_t          unsigned 8 bit integer (i.e., unsigned char)\r
- *  int_least16_t    integer of >= 16 bits\r
- *\r
- */\r
-\r
-#ifndef _SHA_enum_\r
-#define _SHA_enum_\r
-enum\r
-{\r
-    shaSuccess = 0,\r
-    shaNull,            /* Null pointer parameter */\r
-    shaInputTooLong,    /* input data too long */\r
-    shaStateError       /* called Input after Result */\r
-};\r
-#endif\r
-#define SHA1HashSize 20\r
-\r
-/*\r
- *  This structure will hold context information for the SHA-1\r
- *  hashing operation\r
- */\r
-typedef struct SHA1Context\r
-{\r
-    uint32_t Intermediate_Hash[SHA1HashSize/4]; /* Message Digest  */\r
-\r
-    uint32_t Length_Low;            /* Message length in bits      */\r
-    uint32_t Length_High;           /* Message length in bits      */\r
-\r
-                               /* Index into message block array   */\r
-    int_least16_t Message_Block_Index;\r
-    uint8_t Message_Block[64];      /* 512-bit message blocks      */\r
-\r
-    int Computed;               /* Is the digest computed?         */\r
-    int Corrupted;             /* Is the message digest corrupted? */\r
-} SHA1Context;\r
-\r
-/*\r
- *  Function Prototypes\r
- */\r
-\r
-\r
-int SHA1Reset(  SHA1Context *);\r
-int SHA1Input(  SHA1Context *,\r
-                const uint8_t *,\r
-                unsigned int);\r
-int SHA1Result( SHA1Context *,\r
-                uint8_t Message_Digest[SHA1HashSize]);\r
-\r
-#endif\r
+/*
+ *  sha1.h
+ *
+ *  Description:
+ *      This is the header file for code which implements the Secure
+ *      Hashing Algorithm 1 as defined in FIPS PUB 180-1 published
+ *      April 17, 1995.
+ *
+ *      Many of the variable names in this code, especially the
+ *      single character names, were used because those were the names
+ *      used in the publication.
+ *
+ *      Please read the file sha1.c for more information.
+ *
+ */
+
+
+#ifndef _SHA1_H_
+#define _SHA1_H_
+
+
+
+#if defined(__OpenBSD__) || defined( __FreeBSD__)
+#include <inttypes.h>
+#else
+#include <stdint.h>
+#endif
+
+/*
+ * If you do not have the ISO standard stdint.h header file, then you
+ * must typdef the following:
+ *    name              meaning
+ *  uint32_t         unsigned 32 bit integer
+ *  uint8_t          unsigned 8 bit integer (i.e., unsigned char)
+ *  int_least16_t    integer of >= 16 bits
+ *
+ */
+
+#ifndef _SHA_enum_
+#define _SHA_enum_
+enum
+{
+    shaSuccess = 0,
+    shaNull,            /* Null pointer parameter */
+    shaInputTooLong,    /* input data too long */
+    shaStateError       /* called Input after Result */
+};
+#endif
+#define SHA1HashSize 20
+
+/*
+ *  This structure will hold context information for the SHA-1
+ *  hashing operation
+ */
+typedef struct SHA1Context
+{
+    uint32_t Intermediate_Hash[SHA1HashSize/4]; /* Message Digest  */
+
+    uint32_t Length_Low;            /* Message length in bits      */
+    uint32_t Length_High;           /* Message length in bits      */
+
+                               /* Index into message block array   */
+    int_least16_t Message_Block_Index;
+    uint8_t Message_Block[64];      /* 512-bit message blocks      */
+
+    int Computed;               /* Is the digest computed?         */
+    int Corrupted;             /* Is the message digest corrupted? */
+} SHA1Context;
+
+/*
+ *  Function Prototypes
+ */
+
+
+int SHA1Reset(  SHA1Context *);
+int SHA1Input(  SHA1Context *,
+                const uint8_t *,
+                unsigned int);
+int SHA1Result( SHA1Context *,
+                uint8_t Message_Digest[SHA1HashSize]);
+
+#endif
diff --git a/sha1.c b/sha1.c
index a135bea..f81096a 100644 (file)
--- a/sha1.c
+++ b/sha1.c
-/*\r
- *\r
- * Based on the RFC 3174\r
- * \r
- * Full Copyright Statement\r
- *\r
- *  Copyright (C) The Internet Society (2001).  All Rights Reserved.\r
- *\r
- *  This document and translations of it may be copied and furnished to\r
- *  others, and derivative works that comment on or otherwise explain it\r
- *  or assist in its implementation may be prepared, copied, published\r
- *  and distributed, in whole or in part, without restriction of any\r
- *  kind, provided that the above copyright notice and this paragraph are\r
- *  included on all such copies and derivative works.  However, this\r
- *  document itself may not be modified in any way, such as by removing\r
- *  the copyright notice or references to the Internet Society or other\r
- *  Internet organizations, except as needed for the purpose of\r
- *  developing Internet standards in which case the procedures for\r
- *  copyrights defined in the Internet Standards process must be\r
- *  followed, or as required to translate it into languages other than\r
- *  English.\r
- *\r
- *  The limited permissions granted above are perpetual and will not be\r
- *  revoked by the Internet Society or its successors or assigns.\r
-\r
- *  This document and the information contained herein is provided on an\r
- *  "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING\r
- *  TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING\r
- *  BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION\r
- *  HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF\r
- *  MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.\r
- *\r
- *\r
- * \r
- *  Description:\r
- *       This file implements the Secure Hashing Algorithm 1 as\r
- *       defined in FIPS PUB 180-1 published April 17, 1995.\r
- *\r
- *       The SHA-1, produces a 160-bit message digest for a given\r
- *       data stream.  It should take about 2**n steps to find a\r
- *       message with the same digest as a given message and\r
- *       2**(n/2) to find any two messages with the same digest,\r
- *       when n is the digest size in bits.  Therefore, this\r
- *       algorithm can serve as a means of providing a\r
- *       "fingerprint" for a message.\r
- *\r
- *  Portability Issues:\r
- *       SHA-1 is defined in terms of 32-bit "words".  This code\r
- *       uses <stdint.h> (included via "sha1.h" to define 32 and 8\r
- *       bit unsigned integer types.  If your C compiler does not\r
- *       support 32 bit unsigned integers, this code is not\r
- *       appropriate.\r
- *\r
- *  Caveats:\r
- *       SHA-1 is designed to work with messages less than 2^64 bits\r
- *       long.  Although SHA-1 allows a message digest to be generated\r
- *       for messages of any number of bits less than 2^64, this\r
- *       implementation only works with messages with a length that is\r
- *       a multiple of the size of an 8-bit character.\r
- *\r
- */\r
-\r
-\r
-#include "asterisk/sha1.h"\r
-\r
-/*\r
- *  Define the SHA1 circular left shift macro\r
- */\r
-#define SHA1CircularShift(bits,word) \\r
-                        (((word) << (bits)) | ((word) >> (32-(bits))))\r
-\r
-/* Local Function Prototyptes */\r
-void SHA1PadMessage(SHA1Context *);\r
-void SHA1ProcessMessageBlock(SHA1Context *);\r
-\r
-/*\r
- *  SHA1Reset\r
- *\r
- *  Description:\r
- *       This function will initialize the SHA1Context in preparation\r
- *       for computing a new SHA1 message digest.\r
- *\r
- *  Parameters:\r
- *       context: [in/out]\r
- *                The context to reset.\r
- *\r
- *  Returns:\r
- *       sha Error Code.\r
- *\r
- */\r
-int SHA1Reset(SHA1Context *context)\r
-{\r
-       if (!context)\r
-       {\r
-                return shaNull;\r
-       }\r
-\r
-       context->Length_Low               = 0;\r
-       context->Length_High             = 0;\r
-       context->Message_Block_Index     = 0;\r
-\r
-       context->Intermediate_Hash[0]   = 0x67452301;\r
-       context->Intermediate_Hash[1]   = 0xEFCDAB89;\r
-       context->Intermediate_Hash[2]   = 0x98BADCFE;\r
-       context->Intermediate_Hash[3]   = 0x10325476;\r
-       context->Intermediate_Hash[4]   = 0xC3D2E1F0;\r
-\r
-       context->Computed       = 0;\r
-       context->Corrupted  = 0;\r
-\r
-       return shaSuccess;\r
-}\r
-\r
-/*\r
- *  SHA1Result\r
- *\r
- *  Description:\r
- *       This function will return the 160-bit message digest into the\r
- *       Message_Digest array  provided by the caller.\r
- *       NOTE: The first octet of hash is stored in the 0th element,\r
- *                  the last octet of hash in the 19th element.\r
- *\r
- *  Parameters:\r
- *       context: [in/out]\r
- *                The context to use to calculate the SHA-1 hash.\r
- *       Message_Digest: [out]\r
- *                Where the digest is returned.\r
- *\r
- *  Returns:\r
- *       sha Error Code.\r
- *\r
- */\r
-int SHA1Result( SHA1Context *context,\r
-                        uint8_t Message_Digest[SHA1HashSize])\r
-{\r
-       int i;\r
-\r
-       if (!context || !Message_Digest)\r
-       {\r
-                return shaNull;\r
-       }\r
-\r
-       if (context->Corrupted)\r
-       {\r
-                return context->Corrupted;\r
-       }\r
-\r
-       if (!context->Computed)\r
-       {\r
-                SHA1PadMessage(context);\r
-                for(i=0; i<64; ++i)\r
-                {\r
-                    /* message may be sensitive, clear it out */\r
-                    context->Message_Block[i] = 0;\r
-                }\r
-                context->Length_Low = 0;    /* and clear length */\r
-                context->Length_High = 0;\r
-                context->Computed = 1;\r
-\r
-       }\r
-\r
-       for(i = 0; i < SHA1HashSize; ++i)\r
-       {\r
-                Message_Digest[i] = context->Intermediate_Hash[i>>2]\r
-                                    >> 8 * ( 3 - ( i & 0x03 ) );\r
-       }\r
-\r
-       return shaSuccess;\r
-}\r
-\r
-/*\r
- *  SHA1Input\r
- *\r
- *  Description:\r
- *       This function accepts an array of octets as the next portion\r
- *       of the message.\r
- *\r
- *  Parameters:\r
- *       context: [in/out]\r
- *                The SHA context to update\r
- *       message_array: [in]\r
- *                An array of characters representing the next portion of\r
- *                the message.\r
- *       length: [in]\r
- *                The length of the message in message_array\r
- *\r
- *  Returns:\r
- *       sha Error Code.\r
- *\r
- */\r
-int SHA1Input( SHA1Context      *context,\r
-                          const uint8_t  *message_array,\r
-                          unsigned       length)\r
-{\r
-       if (!length)\r
-       {\r
-                return shaSuccess;\r
-       }\r
-\r
-       if (!context || !message_array)\r
-       {\r
-                return shaNull;\r
-       }\r
-\r
-       if (context->Computed)\r
-       {\r
-                context->Corrupted = shaStateError;\r
-                return shaStateError;\r
-       }\r
-\r
-       if (context->Corrupted)\r
-       {\r
-                 return context->Corrupted;\r
-       }\r
-       while(length-- && !context->Corrupted)\r
-       {\r
-       context->Message_Block[context->Message_Block_Index++] =\r
-                            (*message_array & 0xFF);\r
-\r
-       context->Length_Low += 8;\r
-       if (context->Length_Low == 0)\r
-       {\r
-                context->Length_High++;\r
-                if (context->Length_High == 0)\r
-                {\r
-                    /* Message is too long */\r
-                    context->Corrupted = 1;\r
-                }\r
-       }\r
-\r
-       if (context->Message_Block_Index == 64)\r
-       {\r
-                SHA1ProcessMessageBlock(context);\r
-       }\r
-\r
-       message_array++;\r
-       }\r
-\r
-       return shaSuccess;\r
-}\r
-\r
-/*\r
- *  SHA1ProcessMessageBlock\r
- *\r
- *  Description:\r
- *       This function will process the next 512 bits of the message\r
- *       stored in the Message_Block array.\r
- *\r
- *  Parameters:\r
- *       None.\r
- *\r
- *  Returns:\r
- *       Nothing.\r
- *\r
- *  Comments:\r
- *       Many of the variable names in this code, especially the\r
- *       single character names, were used because those were the\r
- *       names used in the publication.\r
- *\r
- *\r
- */\r
-void SHA1ProcessMessageBlock(SHA1Context *context)\r
-{\r
-       const uint32_t K[] =     {       /* Constants defined in SHA-1   */\r
-                                    0x5A827999,\r
-                                    0x6ED9EBA1,\r
-                                    0x8F1BBCDC,\r
-                                    0xCA62C1D6\r
-                                    };\r
-       int             t;                 /* Loop counter                */\r
-       uint32_t           temp;              /* Temporary word value        */\r
-       uint32_t           W[80];             /* Word sequence               */\r
-       uint32_t           A, B, C, D, E;     /* Word buffers                */\r
-\r
-       /*\r
-        *  Initialize the first 16 words in the array W\r
-        */\r
-       for(t = 0; t < 16; t++)\r
-       {\r
-                W[t] = context->Message_Block[t * 4] << 24;\r
-                W[t] |= context->Message_Block[t * 4 + 1] << 16;\r
-                W[t] |= context->Message_Block[t * 4 + 2] << 8;\r
-                W[t] |= context->Message_Block[t * 4 + 3];\r
-       }\r
-\r
-       for(t = 16; t < 80; t++)\r
-       {\r
-               W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);\r
-       }\r
-\r
-       A = context->Intermediate_Hash[0];\r
-       B = context->Intermediate_Hash[1];\r
-       C = context->Intermediate_Hash[2];\r
-       D = context->Intermediate_Hash[3];\r
-       E = context->Intermediate_Hash[4];\r
-\r
-       for(t = 0; t < 20; t++)\r
-       {\r
-                temp =  SHA1CircularShift(5,A) +\r
-                        ((B & C) | ((~B) & D)) + E + W[t] + K[0];\r
-                E = D;\r
-                D = C;\r
-                C = SHA1CircularShift(30,B);\r
-                B = A;\r
-                A = temp;\r
-       }\r
-\r
-       for(t = 20; t < 40; t++)\r
-       {\r
-                temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];\r
-                E = D;\r
-                D = C;\r
-                C = SHA1CircularShift(30,B);\r
-                B = A;\r
-                A = temp;\r
-       }\r
-\r
-       for(t = 40; t < 60; t++)\r
-       {\r
-                temp = SHA1CircularShift(5,A) +\r
-                       ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];\r
-                E = D;\r
-                D = C;\r
-                C = SHA1CircularShift(30,B);\r
-                B = A;\r
-                A = temp;\r
-       }\r
-\r
-       for(t = 60; t < 80; t++)\r
-       {\r
-                temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];\r
-                E = D;\r
-                D = C;\r
-                C = SHA1CircularShift(30,B);\r
-                B = A;\r
-                A = temp;\r
-       }\r
-\r
-       context->Intermediate_Hash[0] += A;\r
-       context->Intermediate_Hash[1] += B;\r
-       context->Intermediate_Hash[2] += C;\r
-       context->Intermediate_Hash[3] += D;\r
-       context->Intermediate_Hash[4] += E;\r
-\r
-       context->Message_Block_Index = 0;\r
-}\r
-\r
-\r
-/*\r
- *  SHA1PadMessage\r
- *\r
- *  Description:\r
- *       According to the standard, the message must be padded to an even\r
- *       512 bits.  The first padding bit must be a '1'.  The last 64\r
- *       bits represent the length of the original message.  All bits in\r
- *       between should be 0.  This function will pad the message\r
- *       according to those rules by filling the Message_Block array\r
- *       accordingly.  It will also call the ProcessMessageBlock function\r
- *       provided appropriately.  When it returns, it can be assumed that\r
- *       the message digest has been computed.\r
- *\r
- *  Parameters:\r
- *       context: [in/out]\r
- *                The context to pad\r
- *       ProcessMessageBlock: [in]\r
- *                The appropriate SHA*ProcessMessageBlock function\r
- *  Returns:\r
- *       Nothing.\r
- *\r
- */\r
-\r
-void SHA1PadMessage(SHA1Context *context)\r
-{\r
-       /*\r
-        *  Check to see if the current message block is too small to hold\r
-        *  the initial padding bits and length.  If so, we will pad the\r
-        *  block, process it, and then continue padding into a second\r
-        *  block.\r
-        */\r
-       if (context->Message_Block_Index > 55)\r
-       {\r
-                context->Message_Block[context->Message_Block_Index++] = 0x80;\r
-                while(context->Message_Block_Index < 64)\r
-                {\r
-                    context->Message_Block[context->Message_Block_Index++] = 0;\r
-                }\r
-\r
-                SHA1ProcessMessageBlock(context);\r
-\r
-                while(context->Message_Block_Index < 56)\r
-                {\r
-                    context->Message_Block[context->Message_Block_Index++] = 0;\r
-                }\r
-       }\r
-       else\r
-       {\r
-                context->Message_Block[context->Message_Block_Index++] = 0x80;\r
-                while(context->Message_Block_Index < 56)\r
-                {\r
-                    context->Message_Block[context->Message_Block_Index++] = 0;\r
-                }\r
-       }\r
-\r
-       /*\r
-        *  Store the message length as the last 8 octets\r
-        */\r
-       context->Message_Block[56] = context->Length_High >> 24;\r
-       context->Message_Block[57] = context->Length_High >> 16;\r
-       context->Message_Block[58] = context->Length_High >> 8;\r
-       context->Message_Block[59] = context->Length_High;\r
-       context->Message_Block[60] = context->Length_Low >> 24;\r
-       context->Message_Block[61] = context->Length_Low >> 16;\r
-       context->Message_Block[62] = context->Length_Low >> 8;\r
-       context->Message_Block[63] = context->Length_Low;\r
-\r
-       SHA1ProcessMessageBlock(context);\r
-}\r
+/*
+ *
+ * Based on the RFC 3174
+ * 
+ * Full Copyright Statement
+ *
+ *  Copyright (C) The Internet Society (2001).  All Rights Reserved.
+ *
+ *  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.
+ *
+ *  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.
+ *
+ *
+ * 
+ *  Description:
+ *       This file implements the Secure Hashing Algorithm 1 as
+ *       defined in FIPS PUB 180-1 published April 17, 1995.
+ *
+ *       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.
+ *
+ *  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.
+ *
+ *  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.
+ *
+ */
+
+
+#include "asterisk/sha1.h"
+
+/*
+ *  Define the SHA1 circular left shift macro
+ */
+#define SHA1CircularShift(bits,word) \
+                        (((word) << (bits)) | ((word) >> (32-(bits))))
+
+/* Local Function Prototyptes */
+void SHA1PadMessage(SHA1Context *);
+void SHA1ProcessMessageBlock(SHA1Context *);
+
+/*
+ *  SHA1Reset
+ *
+ *  Description:
+ *       This function will initialize the SHA1Context in preparation
+ *       for computing a new SHA1 message digest.
+ *
+ *  Parameters:
+ *       context: [in/out]
+ *                The context to reset.
+ *
+ *  Returns:
+ *       sha Error Code.
+ *
+ */
+int SHA1Reset(SHA1Context *context)
+{
+       if (!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;
+}
+
+/*
+ *  SHA1Result
+ *
+ *  Description:
+ *       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.
+ *
+ *  Parameters:
+ *       context: [in/out]
+ *                The context to use to calculate the SHA-1 hash.
+ *       Message_Digest: [out]
+ *                Where the digest is returned.
+ *
+ *  Returns:
+ *       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;
+       }
+
+       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;
+
+       }
+
+       for(i = 0; i < SHA1HashSize; ++i)
+       {
+                Message_Digest[i] = context->Intermediate_Hash[i>>2]
+                                    >> 8 * ( 3 - ( i & 0x03 ) );
+       }
+
+       return shaSuccess;
+}
+
+/*
+ *  SHA1Input
+ *
+ *  Description:
+ *       This function accepts an array of octets as the next portion
+ *       of the message.
+ *
+ *  Parameters:
+ *       context: [in/out]
+ *                The SHA context to update
+ *       message_array: [in]
+ *                An array of characters representing the next portion of
+ *                the message.
+ *       length: [in]
+ *                The length of the message in message_array
+ *
+ *  Returns:
+ *       sha Error Code.
+ *
+ */
+int SHA1Input( SHA1Context      *context,
+                          const uint8_t  *message_array,
+                          unsigned       length)
+{
+       if (!length)
+       {
+                return shaSuccess;
+       }
+
+       if (!context || !message_array)
+       {
+                return shaNull;
+       }
+
+       if (context->Computed)
+       {
+                context->Corrupted = shaStateError;
+                return shaStateError;
+       }
+
+       if (context->Corrupted)
+       {
+                 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;
+                }
+       }
+
+       if (context->Message_Block_Index == 64)
+       {
+                SHA1ProcessMessageBlock(context);
+       }
+
+       message_array++;
+       }
+
+       return shaSuccess;
+}
+
+/*
+ *  SHA1ProcessMessageBlock
+ *
+ *  Description:
+ *       This function will process the next 512 bits of the message
+ *       stored in the Message_Block array.
+ *
+ *  Parameters:
+ *       None.
+ *
+ *  Returns:
+ *       Nothing.
+ *
+ *  Comments:
+ *       Many of the variable names in this code, especially the
+ *       single character names, were used because those were the
+ *       names used in the publication.
+ *
+ *
+ */
+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                */
+
+       /*
+        *  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];
+       }
+
+       for(t = 16; t < 80; t++)
+       {
+               W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
+       }
+
+       A = context->Intermediate_Hash[0];
+       B = context->Intermediate_Hash[1];
+       C = context->Intermediate_Hash[2];
+       D = context->Intermediate_Hash[3];
+       E = context->Intermediate_Hash[4];
+
+       for(t = 0; t < 20; t++)
+       {
+                temp =  SHA1CircularShift(5,A) +
+                        ((B & C) | ((~B) & D)) + E + W[t] + K[0];
+                E = D;
+                D = C;
+                C = SHA1CircularShift(30,B);
+                B = A;
+                A = temp;
+       }
+
+       for(t = 20; t < 40; t++)
+       {
+                temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
+                E = D;
+                D = C;
+                C = SHA1CircularShift(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];
+                E = D;
+                D = C;
+                C = SHA1CircularShift(30,B);
+                B = A;
+                A = temp;
+       }
+
+       for(t = 60; t < 80; t++)
+       {
+                temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
+                E = D;
+                D = C;
+                C = SHA1CircularShift(30,B);
+                B = A;
+                A = temp;
+       }
+
+       context->Intermediate_Hash[0] += A;
+       context->Intermediate_Hash[1] += B;
+       context->Intermediate_Hash[2] += C;
+       context->Intermediate_Hash[3] += D;
+       context->Intermediate_Hash[4] += E;
+
+       context->Message_Block_Index = 0;
+}
+
+
+/*
+ *  SHA1PadMessage
+ *
+ *  Description:
+ *       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.
+ *
+ *  Parameters:
+ *       context: [in/out]
+ *                The context to pad
+ *       ProcessMessageBlock: [in]
+ *                The appropriate SHA*ProcessMessageBlock function
+ *  Returns:
+ *       Nothing.
+ *
+ */
+
+void SHA1PadMessage(SHA1Context *context)
+{
+       /*
+        *  Check to see if the current message block is too small to hold
+        *  the initial padding bits and length.  If so, we will pad the
+        *  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)
+                {
+                    context->Message_Block[context->Message_Block_Index++] = 0;
+                }
+
+                SHA1ProcessMessageBlock(context);
+
+                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;
+                }
+       }
+
+       /*
+        *  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;
+
+       SHA1ProcessMessageBlock(context);
+}