"Fossies" - the Fresh Open Source Software Archive

Member "tin-2.6.1/libcanlock/src/hmac.c" (23 Aug 2021, 7835 Bytes) of package /linux/misc/tin-2.6.1.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "hmac.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 2.4.5_vs_2.6.0.

    1 /**************************** hmac.c ***************************/
    2 /***************** See RFC 6234 for details. *******************/
    3 /* Copyright (c) 2011 IETF Trust and the persons identified as */
    4 /* authors of the code.  All rights reserved.                  */
    5 /* See sha.h for terms of use and redistribution.              */
    6 
    7 /*
    8  *  Description:
    9  *      This file implements the HMAC algorithm (Keyed-Hashing for
   10  *      Message Authentication, [RFC 2104]), expressed in terms of
   11  *      the various SHA algorithms.
   12  *
   13  *  Note:
   14  *      Prefix for internal API changed from "hmac" to "RFC2104Hmac"
   15  *      because of namespace clash with NetBSD libc.
   16  */
   17 
   18 #include "canlock-private.h"
   19 #include "sha.h"
   20 
   21 /*
   22  *  RFC2104Hmac
   23  *
   24  *  Description:
   25  *      This function will compute an HMAC message digest.
   26  *
   27  *  Parameters:
   28  *      whichSha: [in]
   29  *          One of SHA1, SHA224, SHA256, SHA384, SHA512
   30  *      message_array[ ]: [in]
   31  *          An array of octets representing the message.
   32  *          Note: in RFC 2104, this parameter is known
   33  *          as 'text'.
   34  *      length: [in]
   35  *          The length of the message in message_array.
   36  *      key[ ]: [in]
   37  *          The secret shared key.
   38  *      key_len: [in]
   39  *          The length of the secret shared key.
   40  *      digest[ ]: [out]
   41  *          Where the digest is to be returned.
   42  *          NOTE: The length of the digest is determined by
   43  *              the value of whichSha.
   44  *
   45  *  Returns:
   46  *      sha Error Code.
   47  *
   48  */
   49 int RFC2104Hmac(SHAversion whichSha,
   50                 const unsigned char *message_array, int length,
   51                 const unsigned char *key, int key_len,
   52                 uint8_t digest[USHAMaxHashSize])
   53 {
   54   int res;
   55   HMACContext context;  /* Security review: Location L1 */
   56 
   57   res = RFC2104HmacReset(&context, whichSha, key, key_len) ||
   58         RFC2104HmacInput(&context, message_array, length) ||
   59         RFC2104HmacResult(&context, digest);
   60   cl_clear_secret((void *) &context, sizeof(HMACContext), sizeof(HMACContext));
   61   return res;
   62 }
   63 
   64 /*
   65  *  RFC2104HmacReset
   66  *
   67  *  Description:
   68  *      This function will initialize the hmacContext in preparation
   69  *      for computing a new HMAC message digest.
   70  *
   71  *  Parameters:
   72  *      context: [in/out]
   73  *          The context to reset.
   74  *      whichSha: [in]
   75  *          One of SHA1, SHA224, SHA256, SHA384, SHA512
   76  *      key[ ]: [in]
   77  *          The secret shared key.
   78  *      key_len: [in]
   79  *          The length of the secret shared key.
   80  *
   81  *  Returns:
   82  *      sha Error Code.
   83  *
   84  */
   85 int RFC2104HmacReset(HMACContext *context, enum SHAversion whichSha,
   86                      const unsigned char *key, int key_len)
   87 {
   88   int i, blocksize, hashsize, ret;
   89 
   90   /* inner padding - key XORd with ipad */
   91   /* Security review: Location L3 */
   92   unsigned char k_ipad[USHA_Max_Message_Block_Size];
   93 
   94   /* temporary buffer when keylen > blocksize */
   95   unsigned char tempkey[USHAMaxHashSize];
   96 
   97   if (!context) return shaNull;
   98   context->Computed = 0;
   99   context->Corrupted = shaSuccess;
  100 
  101   blocksize = context->blockSize = USHABlockSize(whichSha);
  102   hashsize = context->hashSize = USHAHashSize(whichSha);
  103   context->whichSha = whichSha;
  104 
  105   /*
  106    * If key is longer than the hash blocksize,
  107    * reset it to key = HASH(key).
  108    */
  109   if (key_len > blocksize) {
  110     USHAContext tcontext;  /* Security review: Location L2 */
  111     int err = USHAReset(&tcontext, whichSha) ||
  112               USHAInput(&tcontext, key, key_len) ||
  113               USHAResult(&tcontext, tempkey);
  114     if (err != shaSuccess) return err;
  115 
  116     key = tempkey;
  117     key_len = hashsize;
  118     /* tcontext contains a buffer to which key is copied by USHAInput() */
  119     cl_clear_secret((void *) &tcontext,
  120                     sizeof(USHAContext), sizeof(USHAContext));
  121   }
  122 
  123   /*
  124    * The HMAC transform looks like:
  125    *
  126    * SHA(K XOR opad, SHA(K XOR ipad, text))
  127    *
  128    * where K is an n byte key, 0-padded to a total of blocksize bytes,
  129    * ipad is the byte 0x36 repeated blocksize times,
  130    * opad is the byte 0x5c repeated blocksize times,
  131    * and text is the data being protected.
  132    */
  133 
  134   /* store key into the pads, XOR'd with ipad and opad values */
  135   for (i = 0; i < key_len; i++) {
  136     k_ipad[i] = key[i] ^ 0x36;
  137     context->k_opad[i] = key[i] ^ 0x5c;
  138   }
  139   /* remaining pad bytes are '\0' XOR'd with ipad and opad values */
  140   for ( ; i < blocksize; i++) {
  141     k_ipad[i] = 0x36;
  142     context->k_opad[i] = 0x5c;
  143   }
  144 
  145   /* perform inner hash */
  146   /* init context for 1st pass */
  147   ret = USHAReset(&context->shaContext, whichSha) ||
  148         /* and start with inner pad */
  149         USHAInput(&context->shaContext, k_ipad, blocksize);
  150   cl_clear_secret((void *) k_ipad, sizeof(k_ipad), sizeof(k_ipad));
  151   return context->Corrupted = ret;
  152 }
  153 
  154 /*
  155  *  RFC2104HmacInput
  156  *
  157  *  Description:
  158  *      This function accepts an array of octets as the next portion
  159  *      of the message.  It may be called multiple times.
  160  *
  161  *  Parameters:
  162  *      context: [in/out]
  163  *          The HMAC context to update.
  164  *      text[ ]: [in]
  165  *          An array of octets representing the next portion of
  166  *          the message.
  167  *      text_len: [in]
  168  *          The length of the message in text.
  169  *
  170  *  Returns:
  171  *      sha Error Code.
  172  *
  173  */
  174 int RFC2104HmacInput(HMACContext *context, const unsigned char *text,
  175                      int text_len)
  176 {
  177   if (!context) return shaNull;
  178   if (context->Corrupted) return context->Corrupted;
  179   if (context->Computed) return context->Corrupted = shaStateError;
  180   /* then text of datagram */
  181   return context->Corrupted =
  182     USHAInput(&context->shaContext, text, text_len);
  183 }
  184 
  185 /*
  186  * RFC2104HmacFinalBits
  187  *
  188  * Description:
  189  *   This function will add in any final bits of the message.
  190  *
  191  * Parameters:
  192  *   context: [in/out]
  193  *     The HMAC context to update.
  194  *   message_bits: [in]
  195  *     The final bits of the message, in the upper portion of the
  196  *     byte.  (Use 0b###00000 instead of 0b00000### to input the
  197  *     three bits ###.)
  198  *   length: [in]
  199  *     The number of bits in message_bits, between 1 and 7.
  200  *
  201  * Returns:
  202  *   sha Error Code.
  203  */
  204 int RFC2104HmacFinalBits(HMACContext *context,
  205                          uint8_t bits, unsigned int bit_count)
  206 {
  207   if (!context) return shaNull;
  208   if (context->Corrupted) return context->Corrupted;
  209   if (context->Computed) return context->Corrupted = shaStateError;
  210   /* then final bits of datagram */
  211   return context->Corrupted =
  212     USHAFinalBits(&context->shaContext, bits, bit_count);
  213 }
  214 
  215 /*
  216  * RFC2104HmacResult
  217  *
  218  * Description:
  219  *   This function will return the N-byte message digest into the
  220  *   Message_Digest array provided by the caller.
  221  *
  222  * Parameters:
  223  *   context: [in/out]
  224  *     The context to use to calculate the HMAC hash.
  225  *   digest[ ]: [out]
  226  *     Where the digest is returned.
  227  *     NOTE 2: The length of the hash is determined by the value of
  228  *      whichSha that was passed to hmacReset().
  229  *
  230  * Returns:
  231  *   sha Error Code.
  232  *
  233  */
  234 int RFC2104HmacResult(HMACContext *context, uint8_t *digest)
  235 {
  236   int ret;
  237   if (!context) return shaNull;
  238   if (context->Corrupted) return context->Corrupted;
  239   if (context->Computed) return context->Corrupted = shaStateError;
  240 
  241   /* finish up 1st pass */
  242   /* (Use digest here as a temporary buffer.) */
  243   ret =
  244     USHAResult(&context->shaContext, digest) ||
  245          /* perform outer SHA */
  246          /* init context for 2nd pass */
  247          USHAReset(&context->shaContext, context->whichSha) ||
  248 
  249          /* start with outer pad */
  250          USHAInput(&context->shaContext, context->k_opad,
  251                    context->blockSize) ||
  252 
  253          /* then results of 1st hash */
  254          USHAInput(&context->shaContext, digest, context->hashSize) ||
  255          /* finish up 2nd pass */
  256          USHAResult(&context->shaContext, digest);
  257 
  258   context->Computed = 1;
  259   return context->Corrupted = ret;
  260 }