tor-browser

alghmac.c (5832B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifdef FREEBL_NO_DEPEND
#include "stubs.h"
#endif

#include "secport.h"
#include "hasht.h"
#include "blapit.h"
#include "alghmac.h"
#include "secerr.h"

#define HMAC_PAD_SIZE HASH_BLOCK_LENGTH_MAX

struct HMACContextStr {
   void *hash;
   const SECHashObject *hashobj;
   PRBool wasAllocated;
   unsigned char ipad[HMAC_PAD_SIZE];
   unsigned char opad[HMAC_PAD_SIZE];
};

void
HMAC_Destroy(HMACContext *cx, PRBool freeit)
{
   if (cx == NULL)
       return;

   PORT_Assert(!freeit == !cx->wasAllocated);
   if (cx->hash != NULL) {
       cx->hashobj->destroy(cx->hash, PR_TRUE);
       PORT_Memset(cx, 0, sizeof *cx);
   }
   if (freeit)
       PORT_Free(cx);
}

static SECStatus
hmac_initKey(HMACContext *cx, const unsigned char *secret,
            unsigned int secret_len, PRBool isFIPS)
{
   unsigned int i;
   unsigned char hashed_secret[HASH_LENGTH_MAX];

   /* required by FIPS 198 Section 3 */
   if (isFIPS && secret_len < cx->hashobj->length / 2) {
       PORT_SetError(SEC_ERROR_INVALID_ARGS);
       return SECFailure;
   }

   if (secret_len > cx->hashobj->blocklength) {
       cx->hashobj->begin(cx->hash);
       cx->hashobj->update(cx->hash, secret, secret_len);
       PORT_Assert(cx->hashobj->length <= sizeof hashed_secret);
       cx->hashobj->end(cx->hash, hashed_secret, &secret_len,
                        sizeof hashed_secret);
       if (secret_len != cx->hashobj->length) {
           PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
           goto loser;
       }
       secret = (const unsigned char *)&hashed_secret[0];
   }

   PORT_Memset(cx->ipad, 0x36, cx->hashobj->blocklength);
   PORT_Memset(cx->opad, 0x5c, cx->hashobj->blocklength);

   /* fold secret into padding */
   for (i = 0; i < secret_len; i++) {
       cx->ipad[i] ^= secret[i];
       cx->opad[i] ^= secret[i];
   }
   PORT_Memset(hashed_secret, 0, sizeof hashed_secret);
   return SECSuccess;

loser:
   PORT_Memset(hashed_secret, 0, sizeof hashed_secret);
   return SECFailure;
}

SECStatus
HMAC_Init(HMACContext *cx, const SECHashObject *hash_obj,
         const unsigned char *secret, unsigned int secret_len, PRBool isFIPS)
{
   SECStatus rv;

   if (cx == NULL) {
       PORT_SetError(SEC_ERROR_INVALID_ARGS);
       return SECFailure;
   }
   cx->wasAllocated = PR_FALSE;
   cx->hashobj = hash_obj;
   cx->hash = cx->hashobj->create();
   if (cx->hash == NULL)
       goto loser;

   rv = hmac_initKey(cx, secret, secret_len, isFIPS);
   if (rv != SECSuccess)
       goto loser;

   return rv;
loser:
   if (cx->hash != NULL)
       cx->hashobj->destroy(cx->hash, PR_TRUE);
   return SECFailure;
}

HMACContext *
HMAC_Create(const SECHashObject *hash_obj, const unsigned char *secret,
           unsigned int secret_len, PRBool isFIPS)
{
   SECStatus rv;
   HMACContext *cx = PORT_ZNew(HMACContext);
   if (cx == NULL)
       return NULL;
   rv = HMAC_Init(cx, hash_obj, secret, secret_len, isFIPS);
   cx->wasAllocated = PR_TRUE;
   if (rv != SECSuccess) {
       PORT_Free(cx); /* contains no secret info */
       cx = NULL;
   }
   return cx;
}

/* this allows us to reuse an existing HMACContext with a new key and
* Hash function */
SECStatus
HMAC_ReInit(HMACContext *cx, const SECHashObject *hash_obj,
           const unsigned char *secret, unsigned int secret_len, PRBool isFIPS)
{
   PRBool wasAllocated;
   SECStatus rv;

   /* if we are using the same hash, keep the hash contexts and only
    * init the key */
   if ((cx->hashobj == hash_obj) && (cx->hash != NULL)) {
       return hmac_initKey(cx, secret, secret_len, isFIPS);
   }
   /* otherwise we destroy the contents of the context and
    * initalize it from scratch. We need to preseve the current state
    * of wasAllocated to the final destroy works correctly */
   wasAllocated = cx->wasAllocated;
   cx->wasAllocated = PR_FALSE;
   HMAC_Destroy(cx, PR_FALSE);
   rv = HMAC_Init(cx, hash_obj, secret, secret_len, isFIPS);
   if (rv != SECSuccess) {
       return rv;
   }
   cx->wasAllocated = wasAllocated;
   return SECSuccess;
}

void
HMAC_Begin(HMACContext *cx)
{
   /* start inner hash */
   cx->hashobj->begin(cx->hash);
   cx->hashobj->update(cx->hash, cx->ipad, cx->hashobj->blocklength);
}

void
HMAC_Update(HMACContext *cx, const unsigned char *data, unsigned int data_len)
{
   cx->hashobj->update(cx->hash, data, data_len);
}

SECStatus
HMAC_Finish(HMACContext *cx, unsigned char *result, unsigned int *result_len,
           unsigned int max_result_len)
{
   if (max_result_len < cx->hashobj->length) {
       PORT_SetError(SEC_ERROR_INVALID_ARGS);
       return SECFailure;
   }

   cx->hashobj->end(cx->hash, result, result_len, max_result_len);
   if (*result_len != cx->hashobj->length)
       return SECFailure;

   cx->hashobj->begin(cx->hash);
   cx->hashobj->update(cx->hash, cx->opad, cx->hashobj->blocklength);
   cx->hashobj->update(cx->hash, result, *result_len);
   cx->hashobj->end(cx->hash, result, result_len, max_result_len);
   return SECSuccess;
}

HMACContext *
HMAC_Clone(HMACContext *cx)
{
   HMACContext *newcx;

   newcx = (HMACContext *)PORT_ZAlloc(sizeof(HMACContext));
   if (newcx == NULL)
       goto loser;

   newcx->wasAllocated = PR_TRUE;
   newcx->hashobj = cx->hashobj;
   newcx->hash = cx->hashobj->clone(cx->hash);
   if (newcx->hash == NULL)
       goto loser;
   PORT_Memcpy(newcx->ipad, cx->ipad, cx->hashobj->blocklength);
   PORT_Memcpy(newcx->opad, cx->opad, cx->hashobj->blocklength);
   return newcx;

loser:
   HMAC_Destroy(newcx, PR_TRUE);
   return NULL;
}