[457] | 1 | // Copyright (c) Microsoft. All rights reserved.
|
---|
| 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
---|
| 3 |
|
---|
| 4 | /**************************** sha.h ****************************/
|
---|
| 5 | /******************* See RFC 4634 for details ******************/
|
---|
| 6 | #ifndef _SHA_H_
|
---|
| 7 | #define _SHA_H_
|
---|
| 8 |
|
---|
| 9 | /*
|
---|
| 10 | * Description:
|
---|
| 11 | * This file implements the Secure Hash Signature Standard
|
---|
| 12 | * algorithms as defined in the National Institute of Standards
|
---|
| 13 | * and Technology Federal Information Processing Standards
|
---|
| 14 | * Publication (FIPS PUB) 180-1 published on April 17, 1995, 180-2
|
---|
| 15 | * published on August 1, 2002, and the FIPS PUB 180-2 Change
|
---|
| 16 | * Notice published on February 28, 2004.
|
---|
| 17 | *
|
---|
| 18 | * A combined document showing all algorithms is available at
|
---|
| 19 | * http://csrc.nist.gov/publications/fips/
|
---|
| 20 | * fips180-2/fips180-2withchangenotice.pdf
|
---|
| 21 | *
|
---|
| 22 | * The five hashes are defined in these sizes:
|
---|
| 23 | * SHA-1 20 byte / 160 bit
|
---|
| 24 | * SHA-224 28 byte / 224 bit
|
---|
| 25 | * SHA-256 32 byte / 256 bit
|
---|
| 26 | * SHA-384 48 byte / 384 bit
|
---|
| 27 | * SHA-512 64 byte / 512 bit
|
---|
| 28 | */
|
---|
| 29 |
|
---|
| 30 | #ifdef __cplusplus
|
---|
| 31 | #include <cstdint>
|
---|
| 32 | #else
|
---|
| 33 | #include <stdint.h>
|
---|
| 34 | #endif
|
---|
| 35 |
|
---|
| 36 | /*
|
---|
| 37 | * If you do not have the ISO standard stdint.h header file, then you
|
---|
| 38 | * must typedef the following:
|
---|
| 39 | * name meaning
|
---|
| 40 | * uint64_t unsigned 64 bit integer
|
---|
| 41 | * uint32_t unsigned 32 bit integer
|
---|
| 42 | * uint8_t unsigned 8 bit integer (i.e., unsigned char)
|
---|
| 43 | * int_least16_t integer of >= 16 bits
|
---|
| 44 | *
|
---|
| 45 | */
|
---|
| 46 |
|
---|
| 47 | #ifdef __cplusplus
|
---|
| 48 | extern "C"
|
---|
| 49 | {
|
---|
| 50 | #endif
|
---|
| 51 |
|
---|
| 52 | #ifndef _SHA_enum_
|
---|
| 53 | #define _SHA_enum_
|
---|
| 54 | /*
|
---|
| 55 | * All SHA functions return one of these values.
|
---|
| 56 | */
|
---|
| 57 | enum {
|
---|
| 58 | shaSuccess = 0,
|
---|
| 59 | shaNull, /* Null pointer parameter */
|
---|
| 60 | shaInputTooLong, /* input data too long */
|
---|
| 61 | shaStateError, /* called Input after FinalBits or Result */
|
---|
| 62 | shaBadParam /* passed a bad parameter */
|
---|
| 63 | };
|
---|
| 64 | #endif /* _SHA_enum_ */
|
---|
| 65 |
|
---|
| 66 | /*
|
---|
| 67 | * These constants hold size information for each of the SHA
|
---|
| 68 | * hashing operations
|
---|
| 69 | */
|
---|
| 70 | enum {
|
---|
| 71 | SHA1_Message_Block_Size = 64, SHA224_Message_Block_Size = 64,
|
---|
| 72 | SHA256_Message_Block_Size = 64, SHA384_Message_Block_Size = 128,
|
---|
| 73 | SHA512_Message_Block_Size = 128,
|
---|
| 74 | USHA_Max_Message_Block_Size = SHA512_Message_Block_Size,
|
---|
| 75 |
|
---|
| 76 | SHA1HashSize = 20, SHA224HashSize = 28, SHA256HashSize = 32,
|
---|
| 77 | SHA384HashSize = 48, SHA512HashSize = 64,
|
---|
| 78 | USHAMaxHashSize = SHA512HashSize,
|
---|
| 79 |
|
---|
| 80 | SHA1HashSizeBits = 160, SHA224HashSizeBits = 224,
|
---|
| 81 | SHA256HashSizeBits = 256, SHA384HashSizeBits = 384,
|
---|
| 82 | SHA512HashSizeBits = 512, USHAMaxHashSizeBits = SHA512HashSizeBits
|
---|
| 83 | };
|
---|
| 84 |
|
---|
| 85 | /*
|
---|
| 86 | * These constants are used in the USHA (unified sha) functions.
|
---|
| 87 | */
|
---|
| 88 | typedef enum SHAversion {
|
---|
| 89 | SHA1, SHA224, SHA256, SHA384, SHA512
|
---|
| 90 | } SHAversion;
|
---|
| 91 |
|
---|
| 92 | /*
|
---|
| 93 | * This structure will hold context information for the SHA-1
|
---|
| 94 | * hashing operation.
|
---|
| 95 | */
|
---|
| 96 | typedef struct SHA1Context {
|
---|
| 97 | uint32_t Intermediate_Hash[SHA1HashSize/4]; /* Message Digest */
|
---|
| 98 |
|
---|
| 99 | uint32_t Length_Low; /* Message length in bits */
|
---|
| 100 | uint32_t Length_High; /* Message length in bits */
|
---|
| 101 |
|
---|
| 102 | int_least16_t Message_Block_Index; /* Message_Block array index */
|
---|
| 103 | /* 512-bit message blocks */
|
---|
| 104 | uint8_t Message_Block[SHA1_Message_Block_Size];
|
---|
| 105 |
|
---|
| 106 | int Computed; /* Is the digest computed? */
|
---|
| 107 | int Corrupted; /* Is the digest corrupted? */
|
---|
| 108 | } SHA1Context;
|
---|
| 109 |
|
---|
| 110 | /*
|
---|
| 111 | * This structure will hold context information for the SHA-256
|
---|
| 112 | * hashing operation.
|
---|
| 113 | */
|
---|
| 114 | typedef struct SHA256Context {
|
---|
| 115 | uint32_t Intermediate_Hash[SHA256HashSize/4]; /* Message Digest */
|
---|
| 116 |
|
---|
| 117 | uint32_t Length_Low; /* Message length in bits */
|
---|
| 118 | uint32_t Length_High; /* Message length in bits */
|
---|
| 119 |
|
---|
| 120 | int_least16_t Message_Block_Index; /* Message_Block array index */
|
---|
| 121 | /* 512-bit message blocks */
|
---|
| 122 | uint8_t Message_Block[SHA256_Message_Block_Size];
|
---|
| 123 |
|
---|
| 124 | int Computed; /* Is the digest computed? */
|
---|
| 125 | int Corrupted; /* Is the digest corrupted? */
|
---|
| 126 | } SHA256Context;
|
---|
| 127 |
|
---|
| 128 | /*
|
---|
| 129 | * This structure will hold context information for the SHA-512
|
---|
| 130 | * hashing operation.
|
---|
| 131 | */
|
---|
| 132 | typedef struct SHA512Context {
|
---|
| 133 | #ifdef USE_32BIT_ONLY
|
---|
| 134 | uint32_t Intermediate_Hash[SHA512HashSize/4]; /* Message Digest */
|
---|
| 135 | uint32_t Length[4]; /* Message length in bits */
|
---|
| 136 | #else /* !USE_32BIT_ONLY */
|
---|
| 137 | uint64_t Intermediate_Hash[SHA512HashSize/8]; /* Message Digest */
|
---|
| 138 | uint64_t Length_Low, Length_High; /* Message length in bits */
|
---|
| 139 | #endif /* USE_32BIT_ONLY */
|
---|
| 140 |
|
---|
| 141 | int_least16_t Message_Block_Index; /* Message_Block array index */
|
---|
| 142 | /* 1024-bit message blocks */
|
---|
| 143 | uint8_t Message_Block[SHA512_Message_Block_Size];
|
---|
| 144 |
|
---|
| 145 | int Computed; /* Is the digest computed?*/
|
---|
| 146 | int Corrupted; /* Is the digest corrupted? */
|
---|
| 147 | } SHA512Context;
|
---|
| 148 |
|
---|
| 149 | /*
|
---|
| 150 | * This structure will hold context information for the SHA-224
|
---|
| 151 | * hashing operation. It uses the SHA-256 structure for computation.
|
---|
| 152 | */
|
---|
| 153 | typedef struct SHA256Context SHA224Context;
|
---|
| 154 |
|
---|
| 155 | /*
|
---|
| 156 | * This structure will hold context information for the SHA-384
|
---|
| 157 | * hashing operation. It uses the SHA-512 structure for computation.
|
---|
| 158 | */
|
---|
| 159 | typedef struct SHA512Context SHA384Context;
|
---|
| 160 |
|
---|
| 161 | /*
|
---|
| 162 | * This structure holds context information for all SHA
|
---|
| 163 | * hashing operations.
|
---|
| 164 | */
|
---|
| 165 | typedef struct USHAContext {
|
---|
| 166 | int whichSha; /* which SHA is being used */
|
---|
| 167 | union {
|
---|
| 168 | SHA1Context sha1Context;
|
---|
| 169 | SHA224Context sha224Context; SHA256Context sha256Context;
|
---|
| 170 | SHA384Context sha384Context; SHA512Context sha512Context;
|
---|
| 171 | } ctx;
|
---|
| 172 | } USHAContext;
|
---|
| 173 |
|
---|
| 174 | /*
|
---|
| 175 | * This structure will hold context information for the HMAC
|
---|
| 176 | * keyed hashing operation.
|
---|
| 177 | */
|
---|
| 178 | typedef struct HMACContext {
|
---|
| 179 | int whichSha; /* which SHA is being used */
|
---|
| 180 | int hashSize; /* hash size of SHA being used */
|
---|
| 181 | int blockSize; /* block size of SHA being used */
|
---|
| 182 | USHAContext shaContext; /* SHA context */
|
---|
| 183 | unsigned char k_opad[USHA_Max_Message_Block_Size];
|
---|
| 184 | /* outer padding - key XORd with opad */
|
---|
| 185 | } HMACContext;
|
---|
| 186 |
|
---|
| 187 |
|
---|
| 188 | /*
|
---|
| 189 | * Function Prototypes
|
---|
| 190 | */
|
---|
| 191 |
|
---|
| 192 | /* SHA-1 */
|
---|
| 193 | int SHA1Reset(SHA1Context *);
|
---|
| 194 | int SHA1Input(SHA1Context *, const uint8_t *bytes, unsigned int bytecount);
|
---|
| 195 | int SHA1FinalBits(SHA1Context *, const uint8_t bits, unsigned int bitcount);
|
---|
| 196 | int SHA1Result(SHA1Context *, uint8_t Message_Digest[SHA1HashSize]);
|
---|
| 197 |
|
---|
| 198 | /* SHA-224 */
|
---|
| 199 | int SHA224Reset(SHA224Context *);
|
---|
| 200 | int SHA224Input(SHA224Context *, const uint8_t *bytes, unsigned int bytecount);
|
---|
| 201 | int SHA224FinalBits(SHA224Context *, const uint8_t bits, unsigned int bitcount);
|
---|
| 202 | int SHA224Result(SHA224Context *, uint8_t Message_Digest[SHA224HashSize]);
|
---|
| 203 |
|
---|
| 204 | /* SHA-256 */
|
---|
| 205 | int SHA256Reset(SHA256Context *);
|
---|
| 206 | int SHA256Input(SHA256Context *, const uint8_t *bytes, unsigned int bytecount);
|
---|
| 207 | int SHA256FinalBits(SHA256Context *, const uint8_t bits, unsigned int bitcount);
|
---|
| 208 | int SHA256Result(SHA256Context *, uint8_t Message_Digest[SHA256HashSize]);
|
---|
| 209 |
|
---|
| 210 | /* SHA-384 */
|
---|
| 211 | int SHA384Reset(SHA384Context *);
|
---|
| 212 | int SHA384Input(SHA384Context *, const uint8_t *bytes, unsigned int bytecount);
|
---|
| 213 | int SHA384FinalBits(SHA384Context *, const uint8_t bits, unsigned int bitcount);
|
---|
| 214 | int SHA384Result(SHA384Context *, uint8_t Message_Digest[SHA384HashSize]);
|
---|
| 215 |
|
---|
| 216 | /* SHA-512 */
|
---|
| 217 | int SHA512Reset(SHA512Context *);
|
---|
| 218 | int SHA512Input(SHA512Context *, const uint8_t *bytes, unsigned int bytecount);
|
---|
| 219 | int SHA512FinalBits(SHA512Context *, const uint8_t bits, unsigned int bitcount);
|
---|
| 220 | int SHA512Result(SHA512Context *, uint8_t Message_Digest[SHA512HashSize]);
|
---|
| 221 |
|
---|
| 222 | /* Unified SHA functions, chosen by whichSha */
|
---|
| 223 | int USHAReset(USHAContext *, SHAversion whichSha);
|
---|
| 224 | int USHAInput(USHAContext *, const uint8_t *bytes, unsigned int bytecount);
|
---|
| 225 | int USHAFinalBits(USHAContext *, const uint8_t bits, unsigned int bitcount);
|
---|
| 226 | int USHAResult(USHAContext *, uint8_t Message_Digest[USHAMaxHashSize]);
|
---|
| 227 | int USHABlockSize(enum SHAversion whichSha);
|
---|
| 228 | int USHAHashSize(enum SHAversion whichSha);
|
---|
| 229 | int USHAHashSizeBits(enum SHAversion whichSha);
|
---|
| 230 |
|
---|
| 231 | /*
|
---|
| 232 | * HMAC Keyed-Hashing for Message Authentication, RFC2104,
|
---|
| 233 | * for all SHAs.
|
---|
| 234 | * This interface allows a fixed-length text input to be used.
|
---|
| 235 | */
|
---|
| 236 | int hmac(SHAversion whichSha, /* which SHA algorithm to use */
|
---|
| 237 | const unsigned char *text, /* pointer to data stream */
|
---|
| 238 | int text_len, /* length of data stream */
|
---|
| 239 | const unsigned char *key, /* pointer to authentication key */
|
---|
| 240 | int key_len, /* length of authentication key */
|
---|
| 241 | uint8_t digest[USHAMaxHashSize]); /* caller digest to fill in */
|
---|
| 242 |
|
---|
| 243 | /*
|
---|
| 244 | * HMAC Keyed-Hashing for Message Authentication, RFC2104,
|
---|
| 245 | * for all SHAs.
|
---|
| 246 | * This interface allows any length of text input to be used.
|
---|
| 247 | */
|
---|
| 248 | int hmacReset(HMACContext *ctx, enum SHAversion whichSha, const unsigned char *key, int key_len);
|
---|
| 249 | int hmacInput(HMACContext *ctx, const unsigned char *text, int text_len);
|
---|
| 250 |
|
---|
| 251 | int hmacFinalBits(HMACContext *ctx, const uint8_t bits, unsigned int bitcount);
|
---|
| 252 | int hmacResult(HMACContext *ctx, uint8_t digest[USHAMaxHashSize]);
|
---|
| 253 |
|
---|
| 254 |
|
---|
| 255 | #ifdef __cplusplus
|
---|
| 256 | }
|
---|
| 257 | #endif
|
---|
| 258 |
|
---|
| 259 | #endif /* _SHA_H_ */
|
---|
| 260 |
|
---|