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_ */