Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/inc/azure_c_shared_utility/sha.h

raw
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