6.  Computing the Message Digest

   The output of each of the secure hash functions, after being applied
   to a message of N blocks, is the hash quantity H(N).  For SHA-224 and
   SHA-256, H(i) can be considered to be eight 32-bit words, H(i)0,
   H(i)1, ... H(i)7.  For SHA-384 and SHA-512, it can be considered to
   be eight 64-bit words, H(i)0, H(i)1, ..., H(i)7.

   As described below, the hash words are initialized, modified as each
   message block is processed, and finally concatenated after processing
   the last block to yield the output.  For SHA-256 and SHA-512, all of
   the H(N) variables are concatenated while the SHA-224 and SHA-384
   hashes are produced by omitting some from the final concatenation.

6.1.  SHA-224 and SHA-256 Initialization

   For SHA-224, the initial hash value, H(0), consists of the following
   32-bit words in hex:

      H(0)0 = c1059ed8
      H(0)1 = 367cd507
      H(0)2 = 3070dd17
      H(0)3 = f70e5939
      H(0)4 = ffc00b31
      H(0)5 = 68581511
      H(0)6 = 64f98fa7
      H(0)7 = befa4fa4

   For SHA-256, the initial hash value, H(0), consists of the following
   eight 32-bit words, in hex.  These words were obtained by taking the
   first 32 bits of the fractional parts of the square roots of the
   first eight prime numbers.

      H(0)0 = 6a09e667
      H(0)1 = bb67ae85
      H(0)2 = 3c6ef372
      H(0)3 = a54ff53a
      H(0)4 = 510e527f
      H(0)5 = 9b05688c
      H(0)6 = 1f83d9ab
      H(0)7 = 5be0cd19

6.2.  SHA-224 and SHA-256 Processing

   SHA-224 and SHA-256 perform identical processing on message blocks
   and differ only in how H(0) is initialized and how they produce their
   final output.  They may be used to hash a message, M, having a length
   of L bits, where 0 <= L < 2^64.  The algorithm uses (1) a message
   schedule of sixty-four 32-bit words, (2) eight working variables of
   32 bits each, and (3) a hash value of eight 32-bit words.

   The words of the message schedule are labeled W0, W1, ..., W63.  The
   eight working variables are labeled a, b, c, d, e, f, g, and h.  The
   words of the hash value are labeled H(i)0, H(i)1, ..., H(i)7, which
   will hold the initial hash value, H(0), replaced by each successive
   intermediate hash value (after each message block is processed),
   H(i), and ending with the final hash value, H(N), after all N blocks
   are processed.  They also use two temporary words, T1 and T2.

   The input message is padded as described in Section 4.1 above, then
   parsed into 512-bit blocks that are considered to be composed of
   sixteen 32-bit words M(i)0, M(i)1, ..., M(i)15.  The following
   computations are then performed for each of the N message blocks.
   All addition is performed modulo 2^32.

   For i = 1 to N

      1. Prepare the message schedule W:
         For t = 0 to 15
            Wt = M(i)t
         For t = 16 to 63
            Wt = SSIG1(W(t-2)) + W(t-7) + SSIG0(w(t-15)) + W(t-16)

      2. Initialize the working variables:
         a = H(i-1)0
         b = H(i-1)1
         c = H(i-1)2
         d = H(i-1)3
         e = H(i-1)4
         f = H(i-1)5
         g = H(i-1)6
         h = H(i-1)7

      3. Perform the main hash computation:
         For t = 0 to 63
            T1 = h + BSIG1(e) + CH(e,f,g) + Kt + Wt
            T2 = BSIG0(a) + MAJ(a,b,c)
            h = g
            g = f
            f = e
            e = d + T1
            d = c
            c = b
            b = a
            a = T1 + T2

      4. Compute the intermediate hash value H(i)
         H(i)0 = a + H(i-1)0
         H(i)1 = b + H(i-1)1
         H(i)2 = c + H(i-1)2
         H(i)3 = d + H(i-1)3
         H(i)4 = e + H(i-1)4
         H(i)5 = f + H(i-1)5
         H(i)6 = g + H(i-1)6
         H(i)7 = h + H(i-1)7

   After the above computations have been sequentially performed for all
   of the blocks in the message, the final output is calculated.  For
   SHA-256, this is the concatenation of all of H(N)0, H(N)1, through
   H(N)7.  For SHA-224, this is the concatenation of H(N)0, H(N)1,
   through H(N)6.

6.3.  SHA-384 and SHA-512 Initialization

   For SHA-384, the initial hash value, H(0), consists of the following
   eight 64-bit words, in hex.  These words were obtained by taking the
   first 64 bits of the fractional parts of the square roots of the
   ninth through sixteenth prime numbers.

         H(0)0 = cbbb9d5dc1059ed8
         H(0)1 = 629a292a367cd507
         H(0)2 = 9159015a3070dd17
         H(0)3 = 152fecd8f70e5939
         H(0)4 = 67332667ffc00b31
         H(0)5 = 8eb44a8768581511
         H(0)6 = db0c2e0d64f98fa7
         H(0)7 = 47b5481dbefa4fa4

   For SHA-512, the initial hash value, H(0), consists of the following
   eight 64-bit words, in hex.  These words were obtained by taking the
   first 64 bits of the fractional parts of the square roots of the
   first eight prime numbers.

         H(0)0 = 6a09e667f3bcc908
         H(0)1 = bb67ae8584caa73b
         H(0)2 = 3c6ef372fe94f82b
         H(0)3 = a54ff53a5f1d36f1
         H(0)4 = 510e527fade682d1
         H(0)5 = 9b05688c2b3e6c1f
         H(0)6 = 1f83d9abfb41bd6b
         H(0)7 = 5be0cd19137e2179

6.4.  SHA-384 and SHA-512 Processing

   SHA-384 and SHA-512 perform identical processing on message blocks
   and differ only in how H(0) is initialized and how they produce their
   final output.  They may be used to hash a message, M, having a length
   of L bits, where 0 <= L < 2^128.  The algorithm uses (1) a message
   schedule of eighty 64-bit words, (2) eight working variables of 64
   bits each, and (3) a hash value of eight 64-bit words.

   The words of the message schedule are labeled W0, W1, ..., W79.  The
   eight working variables are labeled a, b, c, d, e, f, g, and h.  The
   words of the hash value are labeled H(i)0, H(i)1, ..., H(i)7, which
   will hold the initial hash value, H(0), replaced by each successive
   intermediate hash value (after each message block is processed),
   H(i), and ending with the final hash value, H(N) after all N blocks
   are processed.

   The input message is padded as described in Section 4.2 above, then
   parsed into 1024-bit blocks that are considered to be composed of
   sixteen 64-bit words M(i)0, M(i)1, ..., M(i)15.  The following
   computations are then performed for each of the N message blocks.
   All addition is performed modulo 2^64.

   For i = 1 to N

      1. Prepare the message schedule W:
         For t = 0 to 15
            Wt = M(i)t
         For t = 16 to 79
            Wt = SSIG1(W(t-2)) + W(t-7) + SSIG0(W(t-15)) + W(t-16)

      2. Initialize the working variables:
         a = H(i-1)0
         b = H(i-1)1
         c = H(i-1)2
         d = H(i-1)3
         e = H(i-1)4
         f = H(i-1)5
         g = H(i-1)6
         h = H(i-1)7

      3. Perform the main hash computation:
         For t = 0 to 79
            T1 = h + BSIG1(e) + CH(e,f,g) + Kt + Wt
            T2 = BSIG0(a) + MAJ(a,b,c)
            h = g
            g = f
            f = e
            e = d + T1
            d = c
            c = b
            b = a
            a = T1 + T2

         4. Compute the intermediate hash value H(i)
            H(i)0 = a + H(i-1)0
            H(i)1 = b + H(i-1)1
            H(i)2 = c + H(i-1)2
            H(i)3 = d + H(i-1)3
            H(i)4 = e + H(i-1)4
            H(i)5 = f + H(i-1)5
            H(i)6 = g + H(i-1)6
            H(i)7 = h + H(i-1)7

   After the above computations have been sequentially performed for all
   of the blocks in the message, the final output is calculated.  For
   SHA-512, this is the concatenation of all of H(N)0, H(N)1, through
   H(N)7.  For SHA-384, this is the concatenation of H(N)0, H(N)1,
   through H(N)5.

7.  HKDF- and SHA-Based HMACs

   Below are brief descriptions and pointers to more complete
   descriptions and code for (1) SHA-based HMACs and (2) an HMAC-based
   extract-and-expand key derivation function.  Both HKDF and HMAC were
   devised by Hugo Krawczyk.

7.1.  SHA-Based HMACs

   HMAC is a method for computing a keyed MAC (Message Authentication
   Code) using a hash function as described in [RFC2104].  It uses a key
   to mix in with the input text to produce the final hash.

   Sample code is also provided, in Section 8.3 below, to perform HMAC
   based on any of the SHA algorithms described herein.  The sample code
   found in [RFC2104] was written in terms of a specified text size.
   Since SHA is defined in terms of an arbitrary number of bits, the
   sample HMAC code has been written to allow the text input to HMAC to
   have an arbitrary number of octets and bits.  A fixed-length
   interface is also provided.

7.2.  HKDF

   HKDF is a specific Key Derivation Function (KDF), that is, a function
   of initial keying material from which the KDF derives one or more
   cryptographically strong secret keys.  HKDF, which is described in
   [RFC5869], is based on HMAC.

   Sample code for HKDF is provided in Section 8.4 below.

8.  C Code for SHAs, HMAC, and HKDF

   Below is a demonstration implementation of these secure hash
   functions in C.  Section 8.1 contains the header file sha.h that
   declares all constants, structures, and functions used by the SHA and
   HMAC functions.  It includes conditionals based on the state of
   definition of USE_32BIT_ONLY that, if that symbol is defined at
   compile time, avoids 64-bit operations.  It also contains sha-
   private.h that provides some declarations common to all the SHA
   functions.  Section 8.2 contains the C code for sha1.c, sha224-256.c,
   sha384-512.c, and usha.c.  Section 8.3 contains the C code for the
   HMAC functions, and Section 8.4 contains the C code for HKDF.
   Section 8.5 contains a test driver to exercise the code.

   For each of the digest lengths $$$, there is the following set of
   constants, a structure, and functions:

   Constants:
      SHA$$$HashSize      number of octets in the hash
      SHA$$$HashSizeBits  number of bits in the hash
      SHA$$$_Message_Block_Size
                          number of octets used in the intermediate
                          message blocks
      Most functions return an enum value that is one of:
        shaSuccess(0)      on success
        shaNull(1)         when presented with a null pointer parameter
        shaInputTooLong(2)  when the input data is too long
        shaStateError(3)   when SHA$$$Input is called after
                          SHA$$$FinalBits or SHA$$$Result

   Structure:
      typedef SHA$$$Context
                          an opaque structure holding the complete state
                          for producing the hash

   Functions:
      int SHA$$$Reset(SHA$$$Context *context);
            Reset the hash context state.
      int SHA$$$Input(SHA$$$Context *context, const uint8_t *octets,
                  unsigned int bytecount);
            Incorporate bytecount octets into the hash.
      int SHA$$$FinalBits(SHA$$$Context *, const uint8_t octet,
                  unsigned int bitcount);
            Incorporate bitcount bits into the hash.  The bits are in
            the upper portion of the octet.  SHA$$$Input() cannot be
            called after this.
      int SHA$$$Result(SHA$$$Context *,
                  uint8_t Message_Digest[SHA$$$HashSize]);
            Do the final calculations on the hash and copy the value
            into Message_Digest.

   In addition, functions with the prefix USHA are provided that take a
   SHAversion value (SHA$$$) to select the SHA function suite.  They add
   the following constants, structure, and functions:

   Constants:
      shaBadParam(4)      constant returned by USHA functions when
                          presented with a bad SHAversion (SHA$$$)
                          parameter or other illegal parameter values
      USAMaxHashSize      maximum of the SHA hash sizes
      SHA$$$              SHAversion enumeration values, used by USHA,
                          HMAC, and HKDF functions to select the SHA
                          function suite

   Structure:
      typedef USHAContext
                          an opaque structure holding the complete state
                          for producing the hash

   Functions:
      int USHAReset(USHAContext *context, SHAversion whichSha);
            Reset the hash context state.
      int USHAInput(USHAContext context*,
                  const uint8_t *bytes, unsigned int bytecount);
            Incorporate bytecount octets into the hash.
      int USHAFinalBits(USHAContext *context,
                  const uint8_t bits, unsigned int bitcount);
            Incorporate bitcount bits into the hash.
      int USHAResult(USHAContext *context,
                  uint8_t Message_Digest[USHAMaxHashSize]);
            Do the final calculations on the hash and copy the value
            into Message_Digest.  Octets in Message_Digest beyond
            USHAHashSize(whichSha) are left untouched.
      int USHAHashSize(enum SHAversion whichSha);
            The number of octets in the given hash.
      int USHAHashSizeBits(enum SHAversion whichSha);
            The number of bits in the given hash.
      int USHABlockSize(enum SHAversion whichSha);
            The internal block size for the given hash.
      const char *USHAHashName(enum SHAversion whichSha);
            This function will return the name of the given SHA
            algorithm as a string.

   The HMAC functions follow the same pattern to allow any length of
   text input to be used.

   Structure:
      typedef HMACContext an opaque structure holding the complete state
                          for producing the keyed message digest (MAC)

   Functions:
      int hmacReset(HMACContext *ctx, enum SHAversion whichSha,
                  const unsigned char *key, int key_len);
            Reset the MAC context state.
      int hmacInput(HMACContext *ctx, const unsigned char *text,
                  int text_len);
            Incorporate text_len octets into the MAC.
      int hmacFinalBits(HMACContext *ctx, const uint8_t bits,
                  unsigned int bitcount);
            Incorporate bitcount bits into the MAC.
      int hmacResult(HMACContext *ctx,
                  uint8_t Message_Digest[USHAMaxHashSize]);

            Do the final calculations on the MAC and copy the value into
            Message_Digest.  Octets in Message_Digest beyond
            USHAHashSize(whichSha) are left untouched.

   In addition, a combined interface is provided, similar to that shown
   in [RFC2104], that allows a fixed-length text input to be used.

      int hmac(SHAversion whichSha,
                  const unsigned char *text, int text_len,
                  const unsigned char *key, int key_len,
                  uint8_t Message_Digest[USHAMaxHashSize]);
            Calculate the given digest for the given text and key, and
            return the resulting MAC.  Octets in Message_Digest beyond
            USHAHashSize(whichSha) are left untouched.

   The HKDF functions follow the same pattern to allow any length of
   text input to be used.

   Structure:
      typedef HKDFContext an opaque structure holding the complete state
                          for producing the keying material
   Functions:
      int hkdfReset(HKDFContext *context, enum SHAversion whichSha,
                  const unsigned char *salt, int salt_len)
            Reset the key derivation state and initialize it with the
            salt_len octets of the optional salt.
      int hkdfInput(HKDFContext *context, const unsigned char *ikm,
                  int ikm_len)
            Incorporate ikm_len octets into the entropy extractor.
      int hkdfFinalBits(HKDFContext *context, uint8_t ikm_bits,
                  unsigned int ikm_bit_count)
            Incorporate ikm_bit_count bits into the entropy extractor.
      int hkdfResult(HKDFContext *context,
                  uint8_t prk[USHAMaxHashSize],
                  const unsigned char *info, int info_len,
                  uint8_t okm[ ], int okm_len)
            Finish the HKDF extraction and perform the final HKDF
            expansion, storing the okm_len octets into output keying
            material (okm).  Optionally store the pseudo-random key
            (prk) that is generated internally.

   In addition, combined interfaces are provided, similar to that shown
   in [RFC5869], that allows a fixed-length text input to be used.

      int hkdfExtract(SHAversion whichSha,
                  const unsigned char *salt, int salt_len,
                  const unsigned char *ikm, int ikm_len,
                  uint8_t prk[USHAMaxHashSize])

            Perform HKDF extraction, combining the salt_len octets of
            the optional salt with the ikm_len octets of the input
            keying material (ikm) to form the pseudo-random key prk.
            The output prk must be large enough to hold the octets
            appropriate for the given hash type.

      int hkdfExpand(SHAversion whichSha,
                  const uint8_t prk[ ], int prk_len,
                  const unsigned char *info, int info_len,
                  uint8_t okm[ ], int okm_len)
            Perform HKDF expansion, combining the prk_len octets of the
            pseudo-random key prk with the info_len octets of info to
            form the okm_len octets stored in okm.

      int hkdf(SHAversion whichSha,
                  const unsigned char *salt, int salt_len,
                  const unsigned char *ikm, int ikm_len,
                  const unsigned char *info, int info_len,
                  uint8_t okm[ ], int okm_len)
            This combined interface performs both HKDF extraction and
            expansion.  The variables are the same as in hkdfExtract()
            and hkdfExpand().

8.1.  The Header Files

8.1.1.  The .h file

   The following sha.h file, as stated in the comments within the file,
   assumes that <stdint.h> is available on your system.  If it is not,
   you should change to including <stdint-example.h>, provided in
   Section 8.1.2, or the like.

/**************************** sha.h ****************************/
/***************** See RFC 6234 for details. *******************/
/*
   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:

   - Redistributions of source code must retain the above
     copyright notice, this list of conditions and
     the following disclaimer.

   - 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.
*/
#ifndef _SHA_H_
#define _SHA_H_

/*
 *  Description:
 *      This file implements the Secure Hash Algorithms
 *      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 five hashes are defined in these sizes:
 *              SHA-1           20 byte / 160 bit
 *              SHA-224         28 byte / 224 bit
 *              SHA-256         32 byte / 256 bit
 *              SHA-384         48 byte / 384 bit
 *              SHA-512         64 byte / 512 bit
 *

 *  Compilation Note:
 *    These files may be compiled with two options:
 *        USE_32BIT_ONLY - use 32-bit arithmetic only, for systems
 *                         without 64-bit integers
 *
 *        USE_MODIFIED_MACROS - use alternate form of the SHA_Ch()
 *                         and SHA_Maj() macros that are equivalent
 *                         and potentially faster on many systems
 *
 */

#include <stdint.h>
/*
 * If you do not have the ISO standard stdint.h header file, then you
 * must typedef the following:
 *    name              meaning
 *  uint64_t         unsigned 64-bit integer
 *  uint32_t         unsigned 32-bit integer
 *  uint8_t          unsigned 8-bit integer (i.e., unsigned char)
 *  int_least16_t    integer of >= 16 bits
 *
 * See stdint-example.h
 */

#ifndef _SHA_enum_
#define _SHA_enum_
/*
 *  All SHA functions return one of these values.
 */
enum {
    shaSuccess = 0,
    shaNull,            /* Null pointer parameter */
    shaInputTooLong,    /* input data too long */
    shaStateError,      /* called Input after FinalBits or Result */
    shaBadParam         /* passed a bad parameter */
};
#endif /* _SHA_enum_ */

/*
 *  These constants hold size information for each of the SHA
 *  hashing operations
 */
enum {
    SHA1_Message_Block_Size = 64, SHA224_Message_Block_Size = 64,
    SHA256_Message_Block_Size = 64, SHA384_Message_Block_Size = 128,
    SHA512_Message_Block_Size = 128,
    USHA_Max_Message_Block_Size = SHA512_Message_Block_Size,

    SHA1HashSize = 20, SHA224HashSize = 28, SHA256HashSize = 32,
    SHA384HashSize = 48, SHA512HashSize = 64,
    USHAMaxHashSize = SHA512HashSize,

    SHA1HashSizeBits = 160, SHA224HashSizeBits = 224,
    SHA256HashSizeBits = 256, SHA384HashSizeBits = 384,
    SHA512HashSizeBits = 512, USHAMaxHashSizeBits = SHA512HashSizeBits
};

/*
 *  These constants are used in the USHA (Unified SHA) functions.
 */
typedef enum SHAversion {
    SHA1, SHA224, SHA256, SHA384, SHA512
} SHAversion;

/*
 *  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_High;               /* Message length in bits */
    uint32_t Length_Low;                /* Message length in bits */

    int_least16_t Message_Block_Index;  /* Message_Block array index */
                                        /* 512-bit message blocks */
    uint8_t Message_Block[SHA1_Message_Block_Size];

    int Computed;                   /* Is the hash computed? */
    int Corrupted;                  /* Cumulative corruption code */
} SHA1Context;

/*
 *  This structure will hold context information for the SHA-256
 *  hashing operation.
 */
typedef struct SHA256Context {
    uint32_t Intermediate_Hash[SHA256HashSize/4]; /* Message Digest */

    uint32_t Length_High;               /* Message length in bits */
    uint32_t Length_Low;                /* Message length in bits */

    int_least16_t Message_Block_Index;  /* Message_Block array index */
                                        /* 512-bit message blocks */
    uint8_t Message_Block[SHA256_Message_Block_Size];

    int Computed;                   /* Is the hash computed? */
    int Corrupted;                  /* Cumulative corruption code */
} SHA256Context;

/*
 *  This structure will hold context information for the SHA-512
 *  hashing operation.
 */
typedef struct SHA512Context {
#ifdef USE_32BIT_ONLY
    uint32_t Intermediate_Hash[SHA512HashSize/4]; /* Message Digest  */
    uint32_t Length[4];                 /* Message length in bits */
#else /* !USE_32BIT_ONLY */
    uint64_t Intermediate_Hash[SHA512HashSize/8]; /* Message Digest */
    uint64_t Length_High, Length_Low;   /* Message length in bits */
#endif /* USE_32BIT_ONLY */

    int_least16_t Message_Block_Index;  /* Message_Block array index */
                                        /* 1024-bit message blocks */
    uint8_t Message_Block[SHA512_Message_Block_Size];

    int Computed;                   /* Is the hash computed?*/
    int Corrupted;                  /* Cumulative corruption code */
} SHA512Context;

/*
 *  This structure will hold context information for the SHA-224
 *  hashing operation.  It uses the SHA-256 structure for computation.
 */
typedef struct SHA256Context SHA224Context;

/*
 *  This structure will hold context information for the SHA-384
 *  hashing operation.  It uses the SHA-512 structure for computation.
 */
typedef struct SHA512Context SHA384Context;

/*
 *  This structure holds context information for all SHA
 *  hashing operations.
 */
typedef struct USHAContext {
    int whichSha;               /* which SHA is being used */
    union {
      SHA1Context sha1Context;
      SHA224Context sha224Context; SHA256Context sha256Context;
      SHA384Context sha384Context; SHA512Context sha512Context;
    } ctx;

} USHAContext;

/*
 *  This structure will hold context information for the HMAC
 *  keyed-hashing operation.
 */
typedef struct HMACContext {
    int whichSha;               /* which SHA is being used */
    int hashSize;               /* hash size of SHA being used */
    int blockSize;              /* block size of SHA being used */
    USHAContext shaContext;     /* SHA context */
    unsigned char k_opad[USHA_Max_Message_Block_Size];
                        /* outer padding - key XORd with opad */
    int Computed;               /* Is the MAC computed? */
    int Corrupted;              /* Cumulative corruption code */

} HMACContext;

/*
 *  This structure will hold context information for the HKDF
 *  extract-and-expand Key Derivation Functions.
 */
typedef struct HKDFContext {
    int whichSha;               /* which SHA is being used */
    HMACContext hmacContext;
    int hashSize;               /* hash size of SHA being used */
    unsigned char prk[USHAMaxHashSize];
                        /* pseudo-random key - output of hkdfInput */
    int Computed;               /* Is the key material computed? */
    int Corrupted;              /* Cumulative corruption code */
} HKDFContext;

/*
 *  Function Prototypes
 */

/* SHA-1 */
extern int SHA1Reset(SHA1Context *);
extern int SHA1Input(SHA1Context *, const uint8_t *bytes,
                     unsigned int bytecount);
extern int SHA1FinalBits(SHA1Context *, uint8_t bits,
                         unsigned int bit_count);
extern int SHA1Result(SHA1Context *,
                      uint8_t Message_Digest[SHA1HashSize]);

/* SHA-224 */
extern int SHA224Reset(SHA224Context *);
extern int SHA224Input(SHA224Context *, const uint8_t *bytes,
                       unsigned int bytecount);
extern int SHA224FinalBits(SHA224Context *, uint8_t bits,
                           unsigned int bit_count);
extern int SHA224Result(SHA224Context *,
                        uint8_t Message_Digest[SHA224HashSize]);

/* SHA-256 */
extern int SHA256Reset(SHA256Context *);
extern int SHA256Input(SHA256Context *, const uint8_t *bytes,
                       unsigned int bytecount);
extern int SHA256FinalBits(SHA256Context *, uint8_t bits,
                           unsigned int bit_count);
extern int SHA256Result(SHA256Context *,
                        uint8_t Message_Digest[SHA256HashSize]);

/* SHA-384 */
extern int SHA384Reset(SHA384Context *);
extern int SHA384Input(SHA384Context *, const uint8_t *bytes,
                       unsigned int bytecount);
extern int SHA384FinalBits(SHA384Context *, uint8_t bits,
                           unsigned int bit_count);
extern int SHA384Result(SHA384Context *,
                        uint8_t Message_Digest[SHA384HashSize]);

/* SHA-512 */
extern int SHA512Reset(SHA512Context *);
extern int SHA512Input(SHA512Context *, const uint8_t *bytes,
                       unsigned int bytecount);
extern int SHA512FinalBits(SHA512Context *, uint8_t bits,
                           unsigned int bit_count);
extern int SHA512Result(SHA512Context *,
                        uint8_t Message_Digest[SHA512HashSize]);

/* Unified SHA functions, chosen by whichSha */
extern int USHAReset(USHAContext *context, SHAversion whichSha);
extern int USHAInput(USHAContext *context,
                     const uint8_t *bytes, unsigned int bytecount);
extern int USHAFinalBits(USHAContext *context,
                         uint8_t bits, unsigned int bit_count);
extern int USHAResult(USHAContext *context,
                      uint8_t Message_Digest[USHAMaxHashSize]);
extern int USHABlockSize(enum SHAversion whichSha);
extern int USHAHashSize(enum SHAversion whichSha);
extern int USHAHashSizeBits(enum SHAversion whichSha);
extern const char *USHAHashName(enum SHAversion whichSha);

/*
 * HMAC Keyed-Hashing for Message Authentication, RFC 2104,
 * for all SHAs.
 * This interface allows a fixed-length text input to be used.
 */
extern int hmac(SHAversion whichSha, /* which SHA algorithm to use */
    const unsigned char *text,     /* pointer to data stream */
    int text_len,                  /* length of data stream */
    const unsigned char *key,      /* pointer to authentication key */
    int key_len,                   /* length of authentication key */
    uint8_t digest[USHAMaxHashSize]); /* caller digest to fill in */

/*
 * HMAC Keyed-Hashing for Message Authentication, RFC 2104,
 * for all SHAs.
 * This interface allows any length of text input to be used.
 */
extern int hmacReset(HMACContext *context, enum SHAversion whichSha,
                     const unsigned char *key, int key_len);
extern int hmacInput(HMACContext *context, const unsigned char *text,
                     int text_len);
extern int hmacFinalBits(HMACContext *context, uint8_t bits,
                         unsigned int bit_count);
extern int hmacResult(HMACContext *context,
                      uint8_t digest[USHAMaxHashSize]);

/*
 * HKDF HMAC-based Extract-and-Expand Key Derivation Function,
 * RFC 5869, for all SHAs.
 */
extern int hkdf(SHAversion whichSha, const unsigned char *salt,
                int salt_len, const unsigned char *ikm, int ikm_len,
                const unsigned char *info, int info_len,
                uint8_t okm[ ], int okm_len);
extern int hkdfExtract(SHAversion whichSha, const unsigned char *salt,
                       int salt_len, const unsigned char *ikm,
                       int ikm_len, uint8_t prk[USHAMaxHashSize]);
extern int hkdfExpand(SHAversion whichSha, const uint8_t prk[ ],
                      int prk_len, const unsigned char *info,
                      int info_len, uint8_t okm[ ], int okm_len);

/*
 * HKDF HMAC-based Extract-and-Expand Key Derivation Function,
 * RFC 5869, for all SHAs.
 * This interface allows any length of text input to be used.
 */
extern int hkdfReset(HKDFContext *context, enum SHAversion whichSha,
                     const unsigned char *salt, int salt_len);

extern int hkdfInput(HKDFContext *context, const unsigned char *ikm,
                     int ikm_len);
extern int hkdfFinalBits(HKDFContext *context, uint8_t ikm_bits,
                         unsigned int ikm_bit_count);
extern int hkdfResult(HKDFContext *context,
                      uint8_t prk[USHAMaxHashSize],
                      const unsigned char *info, int info_len,
                      uint8_t okm[USHAMaxHashSize], int okm_len);
#endif /* _SHA_H_ */

8.1.2.  stdint-example.h

If your system does not have <stdint.h>, the following should be
adequate as a substitute for compiling the other code in this document.

/*********************** stdint-example.h **********************/
/**** Use this file if your system does not have a stdint.h. ***/
/***************** See RFC 6234 for details. *******************/
#ifndef STDINT_H
#define STDINT_H

typedef unsigned long long uint64_t;    /* unsigned 64-bit integer */
typedef unsigned int       uint32_t;    /* unsigned 32-bit integer */
typedef unsigned char      uint8_t;     /* unsigned 8-bit integer */
                                        /* (i.e., unsigned char) */
typedef int int_least32_t;              /* integer of >= 32 bits */
typedef short int_least16_t;            /* integer of >= 16 bits */

#endif /* STDINT_H */

8.1.3.  sha-private.h

   The sha-private.h header file contains definitions that should only
   be needed internally in the other code in this document.  These
   definitions should not be needed in application code calling the code
   provided in this document.

/************************ sha-private.h ************************/
/***************** See RFC 6234 for details. *******************/
#ifndef _SHA_PRIVATE__H
#define _SHA_PRIVATE__H
/*
 * These definitions are defined in FIPS 180-3, section 4.1.
 * Ch() and Maj() are defined identically in sections 4.1.1,
 * 4.1.2, and 4.1.3.
 *
 * The definitions used in FIPS 180-3 are as follows:
 */

#ifndef USE_MODIFIED_MACROS
#define SHA_Ch(x,y,z)        (((x) & (y)) ^ ((~(x)) & (z)))
#define SHA_Maj(x,y,z)       (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#else /* USE_MODIFIED_MACROS */
/*
 * The following definitions are equivalent and potentially faster.
 */

#define SHA_Ch(x, y, z)      (((x) & ((y) ^ (z))) ^ (z))
#define SHA_Maj(x, y, z)     (((x) & ((y) | (z))) | ((y) & (z)))

#endif /* USE_MODIFIED_MACROS */

#define SHA_Parity(x, y, z)  ((x) ^ (y) ^ (z))

#endif /* _SHA_PRIVATE__H */