CLI: Create ast_cli_completion_vector.
[asterisk/asterisk.git] / include / asterisk / sha1.h
1 /**************************** sha.h ****************************/
2 /***************** See RFC 6234 for details. *******************/
3 /*
4    Copyright (c) 2011 IETF Trust and the persons identified as
5    authors of the code.  All rights reserved.
6
7    Redistribution and use in source and binary forms, with or
8    without modification, are permitted provided that the following
9    conditions are met:
10
11    - Redistributions of source code must retain the above
12      copyright notice, this list of conditions and
13      the following disclaimer.
14
15    - Redistributions in binary form must reproduce the above
16      copyright notice, this list of conditions and the following
17      disclaimer in the documentation and/or other materials provided
18      with the distribution.
19
20    - Neither the name of Internet Society, IETF or IETF Trust, nor
21      the names of specific contributors, may be used to endorse or
22      promote products derived from this software without specific
23      prior written permission.
24
25    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
26    CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
27    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
28    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
29    DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
30    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
32    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
33    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
36    OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
37    EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 */
39 #ifndef _SHA1_H_
40 #define _SHA1_H_
41
42 /*
43  *  Description:
44  *      This file implements the Secure Hash Algorithms
45  *      as defined in the U.S. National Institute of Standards
46  *      and Technology Federal Information Processing Standards
47  *      Publication (FIPS PUB) 180-3 published in October 2008
48  *      and formerly defined in its predecessors, FIPS PUB 180-1
49  *      and FIP PUB 180-2.
50  *
51  *      A combined document showing all algorithms is available at
52  *              http://csrc.nist.gov/publications/fips/
53  *                     fips180-3/fips180-3_final.pdf
54  *
55  *      The five hashes are defined in these sizes:
56  *              SHA-1           20 byte / 160 bit
57  *              SHA-224         28 byte / 224 bit
58  *              SHA-256         32 byte / 256 bit
59  *              SHA-384         48 byte / 384 bit
60  *              SHA-512         64 byte / 512 bit
61  *
62  *  Compilation Note:
63  *    These files may be compiled with two options:
64  *        USE_32BIT_ONLY - use 32-bit arithmetic only, for systems
65  *                         without 64-bit integers
66  *
67  *        USE_MODIFIED_MACROS - use alternate form of the SHA_Ch()
68  *                         and SHA_Maj() macros that are equivalent
69  *                         and potentially faster on many systems
70  *
71  */
72
73 #include <stdint.h>
74 /*
75  * If you do not have the ISO standard stdint.h header file, then you
76  * must typedef the following:
77  *    name              meaning
78  *  uint64_t         unsigned 64-bit integer
79  *  uint32_t         unsigned 32-bit integer
80  *  uint8_t          unsigned 8-bit integer (i.e., unsigned char)
81  *  int_least16_t    integer of >= 16 bits
82  *
83  * See stdint-example.h
84  */
85
86 #ifndef _SHA_enum_
87 #define _SHA_enum_
88 /*
89  *  All SHA functions return one of these values.
90  */
91 enum {
92     shaSuccess = 0,
93     shaNull,            /* Null pointer parameter */
94     shaInputTooLong,    /* input data too long */
95     shaStateError,      /* called Input after FinalBits or Result */
96     shaBadParam         /* passed a bad parameter */
97 };
98 #endif /* _SHA_enum_ */
99
100 /*
101  *  These constants hold size information for each of the SHA
102  *  hashing operations
103  */
104 enum {
105         SHA1_Message_Block_Size = 64, SHA224_Message_Block_Size = 64,
106         SHA256_Message_Block_Size = 64, SHA384_Message_Block_Size = 128,
107         SHA512_Message_Block_Size = 128,
108         USHA_Max_Message_Block_Size = SHA512_Message_Block_Size,
109         SHA1HashSize = 20, SHA224HashSize = 28, SHA256HashSize = 32,
110         SHA384HashSize = 48, SHA512HashSize = 64,
111         USHAMaxHashSize = SHA512HashSize,
112
113         SHA1HashSizeBits = 160, SHA224HashSizeBits = 224,
114         SHA256HashSizeBits = 256, SHA384HashSizeBits = 384,
115         SHA512HashSizeBits = 512, USHAMaxHashSizeBits = SHA512HashSizeBits
116 };
117
118 /*
119  *  These constants are used in the USHA (Unified SHA) functions.
120  */
121 typedef enum SHAversion {
122         SHA1, SHA224, SHA256, SHA384, SHA512
123 } SHAversion;
124
125 /*
126  *  This structure will hold context information for the SHA-1
127  *  hashing operation.
128  */
129 typedef struct SHA1Context {
130         uint32_t Intermediate_Hash[SHA1HashSize/4]; /* Message Digest */
131
132         uint32_t Length_High;               /* Message length in bits */
133         uint32_t Length_Low;                /* Message length in bits */
134
135         int_least16_t Message_Block_Index;  /* Message_Block array index */
136         /* 512-bit message blocks */
137         uint8_t Message_Block[SHA1_Message_Block_Size];
138
139         int Computed;                   /* Is the hash computed? */
140         int Corrupted;                  /* Cumulative corruption code */
141 } SHA1Context;
142
143 /*
144  *  This structure will hold context information for the SHA-256
145  *  hashing operation.
146  */
147 typedef struct SHA256Context {
148     uint32_t Intermediate_Hash[SHA256HashSize/4]; /* Message Digest */
149
150     uint32_t Length_High;               /* Message length in bits */
151     uint32_t Length_Low;                /* Message length in bits */
152
153     int_least16_t Message_Block_Index;  /* Message_Block array index */
154                                         /* 512-bit message blocks */
155     uint8_t Message_Block[SHA256_Message_Block_Size];
156     int Computed;                   /* Is the hash computed? */
157     int Corrupted;                  /* Cumulative corruption code */
158 } SHA256Context;
159
160 /*
161  *  This structure will hold context information for the SHA-512
162  *  hashing operation.
163  */
164 typedef struct SHA512Context {
165 #ifdef USE_32BIT_ONLY
166     uint32_t Intermediate_Hash[SHA512HashSize/4]; /* Message Digest  */
167     uint32_t Length[4];                 /* Message length in bits */
168 #else /* !USE_32BIT_ONLY */
169     uint64_t Intermediate_Hash[SHA512HashSize/8]; /* Message Digest */
170     uint64_t Length_High, Length_Low;   /* Message length in bits */
171 #endif /* USE_32BIT_ONLY */
172
173     int_least16_t Message_Block_Index;  /* Message_Block array index */
174                                         /* 1024-bit message blocks */
175     uint8_t Message_Block[SHA512_Message_Block_Size];
176
177     int Computed;                   /* Is the hash computed?*/
178     int Corrupted;                  /* Cumulative corruption code */
179 } SHA512Context;
180
181 /*
182  *  This structure will hold context information for the SHA-224
183  *  hashing operation.  It uses the SHA-256 structure for computation.
184  */
185 typedef struct SHA256Context SHA224Context;
186
187 /*
188  *  This structure will hold context information for the SHA-384
189  *  hashing operation.  It uses the SHA-512 structure for computation.
190  */
191 typedef struct SHA512Context SHA384Context;
192
193 /*
194  *  This structure holds context information for all SHA
195  *  hashing operations.
196  */
197 typedef struct USHAContext {
198         int whichSha;               /* which SHA is being used */
199         union {
200                 SHA1Context sha1Context;
201                 SHA224Context sha224Context; SHA256Context sha256Context;
202                 SHA384Context sha384Context; SHA512Context sha512Context;
203         } ctx;
204 } USHAContext;
205
206 /*
207  *  This structure will hold context information for the HMAC
208  *  keyed-hashing operation.
209  */
210 typedef struct HMACContext {
211         int whichSha;               /* which SHA is being used */
212         int hashSize;               /* hash size of SHA being used */
213         int blockSize;              /* block size of SHA being used */
214         USHAContext shaContext;     /* SHA context */
215         unsigned char k_opad[USHA_Max_Message_Block_Size];
216         /* outer padding - key XORd with opad */
217         int Computed;               /* Is the MAC computed? */
218         int Corrupted;              /* Cumulative corruption code */
219
220 } HMACContext;
221
222 /*
223  *  This structure will hold context information for the HKDF
224  *  extract-and-expand Key Derivation Functions.
225  */
226 typedef struct HKDFContext {
227         int whichSha;               /* which SHA is being used */
228         HMACContext hmacContext;
229         int hashSize;               /* hash size of SHA being used */
230         unsigned char prk[USHAMaxHashSize];
231         /* pseudo-random key - output of hkdfInput */
232         int Computed;               /* Is the key material computed? */
233         int Corrupted;              /* Cumulative corruption code */
234 } HKDFContext;
235
236 /*
237  *  Function Prototypes
238  */
239
240 /* SHA-1 */
241 extern int SHA1Reset(SHA1Context *);
242 extern int SHA1Input(SHA1Context *, const uint8_t *bytes,
243                      unsigned int bytecount);
244 extern int SHA1FinalBits(SHA1Context *, uint8_t bits,
245                          unsigned int bit_count);
246 extern int SHA1Result(SHA1Context *,
247                       uint8_t Message_Digest[SHA1HashSize]);
248 /* SHA-224 */
249 extern int SHA224Reset(SHA224Context *);
250 extern int SHA224Input(SHA224Context *, const uint8_t *bytes,
251                        unsigned int bytecount);
252 extern int SHA224FinalBits(SHA224Context *, uint8_t bits,
253                            unsigned int bit_count);
254 extern int SHA224Result(SHA224Context *,
255                         uint8_t Message_Digest[SHA224HashSize]);
256
257 /* SHA-256 */
258 extern int SHA256Reset(SHA256Context *);
259 extern int SHA256Input(SHA256Context *, const uint8_t *bytes,
260                        unsigned int bytecount);
261 extern int SHA256FinalBits(SHA256Context *, uint8_t bits,
262                            unsigned int bit_count);
263 extern int SHA256Result(SHA256Context *,
264                         uint8_t Message_Digest[SHA256HashSize]);
265
266 /* SHA-384 */
267 extern int SHA384Reset(SHA384Context *);
268 extern int SHA384Input(SHA384Context *, const uint8_t *bytes,
269                        unsigned int bytecount);
270 extern int SHA384FinalBits(SHA384Context *, uint8_t bits,
271                            unsigned int bit_count);
272 extern int SHA384Result(SHA384Context *,
273                         uint8_t Message_Digest[SHA384HashSize]);
274
275 /* SHA-512 */
276 extern int SHA512Reset(SHA512Context *);
277 extern int SHA512Input(SHA512Context *, const uint8_t *bytes,
278                        unsigned int bytecount);
279 extern int SHA512FinalBits(SHA512Context *, uint8_t bits,
280                            unsigned int bit_count);
281 extern int SHA512Result(SHA512Context *,
282                         uint8_t Message_Digest[SHA512HashSize]);
283
284 /* Unified SHA functions, chosen by whichSha */
285 extern int USHAReset(USHAContext *context, SHAversion whichSha);
286 extern int USHAInput(USHAContext *context,
287                      const uint8_t *bytes, unsigned int bytecount);
288 extern int USHAFinalBits(USHAContext *context,
289                          uint8_t bits, unsigned int bit_count);
290 extern int USHAResult(USHAContext *context,
291                       uint8_t Message_Digest[USHAMaxHashSize]);
292 extern int USHABlockSize(enum SHAversion whichSha);
293 extern int USHAHashSize(enum SHAversion whichSha);
294 extern int USHAHashSizeBits(enum SHAversion whichSha);
295 extern const char *USHAHashName(enum SHAversion whichSha);
296
297 /*
298  * HMAC Keyed-Hashing for Message Authentication, RFC 2104,
299  * for all SHAs.
300  * This interface allows a fixed-length text input to be used.
301  */
302 extern int hmac(SHAversion whichSha, /* which SHA algorithm to use */
303     const unsigned char *text,     /* pointer to data stream */
304     int text_len,                  /* length of data stream */
305     const unsigned char *key,      /* pointer to authentication key */
306     int key_len,                   /* length of authentication key */
307     uint8_t digest[USHAMaxHashSize]); /* caller digest to fill in */
308
309 /*
310  * HMAC Keyed-Hashing for Message Authentication, RFC 2104,
311  * for all SHAs.
312  * This interface allows any length of text input to be used.
313  */
314 extern int hmacReset(HMACContext *context, enum SHAversion whichSha,
315                      const unsigned char *key, int key_len);
316 extern int hmacInput(HMACContext *context, const unsigned char *text,
317                      int text_len);
318 extern int hmacFinalBits(HMACContext *context, uint8_t bits,
319                          unsigned int bit_count);
320 extern int hmacResult(HMACContext *context,
321                       uint8_t digest[USHAMaxHashSize]);
322
323 /*
324  * HKDF HMAC-based Extract-and-Expand Key Derivation Function,
325  * RFC 5869, for all SHAs.
326  */
327 extern int hkdf(SHAversion whichSha, const unsigned char *salt,
328                 int salt_len, const unsigned char *ikm, int ikm_len,
329                 const unsigned char *info, int info_len,
330                 uint8_t okm[ ], int okm_len);
331 extern int hkdfExtract(SHAversion whichSha, const unsigned char *salt,
332                        int salt_len, const unsigned char *ikm,
333                        int ikm_len, uint8_t prk[USHAMaxHashSize]);
334 extern int hkdfExpand(SHAversion whichSha, const uint8_t prk[ ],
335                       int prk_len, const unsigned char *info,
336                       int info_len, uint8_t okm[ ], int okm_len);
337
338 /*
339  * HKDF HMAC-based Extract-and-Expand Key Derivation Function,
340  * RFC 5869, for all SHAs.
341  * This interface allows any length of text input to be used.
342  */
343 extern int hkdfReset(HKDFContext *context, enum SHAversion whichSha,
344                      const unsigned char *salt, int salt_len);
345 extern int hkdfInput(HKDFContext *context, const unsigned char *ikm,
346                      int ikm_len);
347 extern int hkdfFinalBits(HKDFContext *context, uint8_t ikm_bits,
348                          unsigned int ikm_bit_count);
349 extern int hkdfResult(HKDFContext *context,
350                       uint8_t prk[USHAMaxHashSize],
351                       const unsigned char *info, int info_len,
352                       uint8_t okm[USHAMaxHashSize], int okm_len);
353
354 /************************ sha-private.h ************************/
355 /***************** See RFC 6234 for details. *******************/
356 /*
357  * These definitions are defined in FIPS 180-3, section 4.1.
358  * Ch() and Maj() are defined identically in sections 4.1.1,
359  * 4.1.2, and 4.1.3.
360  *
361  * The definitions used in FIPS 180-3 are as follows:
362  */
363
364 #ifndef USE_MODIFIED_MACROS
365 #define SHA_Ch(x,y,z)        (((x) & (y)) ^ ((~(x)) & (z)))
366 #define SHA_Maj(x,y,z)       (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
367 #else /* USE_MODIFIED_MACROS */
368 /*
369  * The following definitions are equivalent and potentially faster.
370  */
371
372 #define SHA_Ch(x, y, z)      (((x) & ((y) ^ (z))) ^ (z))
373 #define SHA_Maj(x, y, z)     (((x) & ((y) | (z))) | ((y) & (z)))
374
375 #endif /* USE_MODIFIED_MACROS */
376
377 #define SHA_Parity(x, y, z)  ((x) ^ (y) ^ (z))
378
379 #endif /* _SHA1_H_ */