Merge NSS_3_14_2_RTM.

mozilla/security/nss/lib/freebl/rijndael.c

 /* 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/. */
-/* $Id: rijndael.c,v 1.28 2012/09/28 22:46:32 rrelyea%redhat.com Exp $ */
+/* $Id: rijndael.c,v 1.30 2013/01/25 18:02:53 rrelyea%redhat.com Exp $ */
 
 #ifdef FREEBL_NO_DEPEND
 #include "stubs.h"
 #endif
 
 #include "prinit.h"
 #include "prerr.h"
 #include "secerr.h"
 
 #include "prtypes.h"
 #include "blapi.h"
 #include "rijndael.h"
 
 #include "cts.h"
 #include "ctr.h"
 #include "gcm.h"
 
 #if USE_HW_AES
+#include "intel-gcm.h"
 #include "intel-aes.h"
 #include "mpi.h"
+
+static int has_intel_aes = 0;
+static int has_intel_avx = 0;
+static int has_intel_clmul = 0;
+static PRBool use_hw_aes = PR_FALSE;
+static PRBool use_hw_avx = PR_FALSE;
+static PRBool use_hw_gcm = PR_FALSE;
 #endif
 
 /*
  * There are currently five ways to build this code, varying in performance
  * and code size.
  *
  * RIJNDAEL_INCLUDE_TABLES         Include all tables from rijndael32.tab
  * RIJNDAEL_GENERATE_TABLES        Generate tables on first 
  *                                 encryption/decryption, then store them;
  *                                 use the function gfm
@@ skipping 928 matching lines @@
 /*
 ** Initialize a new AES context suitable for AES encryption/decryption in
 ** the ECB or CBC mode.
 **      "mode" the mode of operation, which must be NSS_AES or NSS_AES_CBC
 */
 static SECStatus   
 aes_InitContext(AESContext *cx, const unsigned char *key, unsigned int keysize, 
                 const unsigned char *iv, int mode, unsigned int encrypt,
                 unsigned int blocksize)
 {
-#if USE_HW_AES
-    static int has_intel_aes;
-    PRBool use_hw_aes = PR_FALSE;
-#endif
     unsigned int Nk;
     /* According to Rijndael AES Proposal, section 12.1, block and key
      * lengths between 128 and 256 bits are supported, as long as the
      * length in bytes is divisible by 4.
      */
     if (key == NULL || 
         keysize < RIJNDAEL_MIN_BLOCKSIZE   || 
         keysize > RIJNDAEL_MAX_BLOCKSIZE   || 
         keysize % 4 != 0 ||
         blocksize < RIJNDAEL_MIN_BLOCKSIZE || 
@@ skipping 15 matching lines @@
         return SECFailure;
     }
 #if USE_HW_AES
     if (has_intel_aes == 0) {
         unsigned long eax, ebx, ecx, edx;
         char *disable_hw_aes = getenv("NSS_DISABLE_HW_AES");
 
         if (disable_hw_aes == NULL) {
             freebl_cpuid(1, &eax, &ebx, &ecx, &edx);
             has_intel_aes = (ecx & (1 << 25)) != 0 ? 1 : -1;
+            has_intel_clmul = (ecx & (1 << 1)) != 0 ? 1 : -1;
+            has_intel_avx = (ecx & (1 << 28)) != 0 ? 1 : -1;
         } else {
             has_intel_aes = -1;
+            has_intel_avx = -1;
+            has_intel_clmul = -1;
         }
     }
     use_hw_aes = (PRBool)
                 (has_intel_aes > 0 && (keysize % 8) == 0 && blocksize == 16);
+    use_hw_gcm = (PRBool)
+                (use_hw_aes && has_intel_avx>0 && has_intel_clmul>0);
 #endif
     /* Nb = (block size in bits) / 32 */
     cx->Nb = blocksize / 4;
     /* Nk = (key size in bits) / 32 */
     Nk = keysize / 4;
     /* Obtain number of rounds from "table" */
     cx->Nr = RIJNDAEL_NUM_ROUNDS(Nk, cx->Nb);
     /* copy in the iv, if neccessary */
     if (mode == NSS_AES_CBC) {
         memcpy(cx->iv, iv, blocksize);
@@ skipping 65 matching lines @@
     switch (mode) {
     case NSS_AES_CTS:
         basemode = NSS_AES_CBC;
         break;
     case NSS_AES_GCM:
     case NSS_AES_CTR:
         basemode = NSS_AES;
         baseencrypt = PR_TRUE;
         break;
     }
+    /* make sure enough is initializes so we can safely call Destroy */
+    cx->worker_cx = NULL;
+    cx->destroy = NULL;
     rv = aes_InitContext(cx, key, keysize, iv, basemode, 
                                         baseencrypt, blocksize);
     if (rv != SECSuccess) {
-        AES_DestroyContext(cx, PR_TRUE);
+        AES_DestroyContext(cx, PR_FALSE);
         return rv;
     }
 
     /* finally, set up any mode specific contexts */
     switch (mode) {
     case NSS_AES_CTS:
         cx->worker_cx = CTS_CreateContext(cx, cx->worker, iv, blocksize);
         cx->worker = (freeblCipherFunc) 
                         (encrypt ?  CTS_EncryptUpdate : CTS_DecryptUpdate);
         cx->destroy = (freeblDestroyFunc) CTS_DestroyContext;
         cx->isBlock = PR_FALSE;
         break;
     case NSS_AES_GCM:
+#if USE_HW_AES
+        if(use_hw_gcm) {
+                cx->worker_cx = intel_AES_GCM_CreateContext(cx, cx->worker, iv, blocksize);
+                cx->worker = (freeblCipherFunc)
+                        (encrypt ? intel_AES_GCM_EncryptUpdate : intel_AES_GCM_DecryptUpdate);
+                cx->destroy = (freeblDestroyFunc) intel_AES_GCM_DestroyContext;
+                cx->isBlock = PR_FALSE;
+        } else
+#endif
+        {
         cx->worker_cx = GCM_CreateContext(cx, cx->worker, iv, blocksize);
         cx->worker = (freeblCipherFunc)
                         (encrypt ? GCM_EncryptUpdate : GCM_DecryptUpdate);
         cx->destroy = (freeblDestroyFunc) GCM_DestroyContext;
         cx->isBlock = PR_FALSE;
+        }
         break;
     case NSS_AES_CTR:
         cx->worker_cx = CTR_CreateContext(cx, cx->worker, iv, blocksize);
         cx->worker = (freeblCipherFunc) CTR_Update ;
         cx->destroy = (freeblDestroyFunc) CTR_DestroyContext;
         cx->isBlock = PR_FALSE;
         break;
     default:
         /* everything has already been set up by aes_InitContext, just
          * return */
         return SECSuccess;
     }
     /* check to see if we succeeded in getting the worker context */
     if (cx->worker_cx == NULL) {
         /* no, just destroy the existing context */
         cx->destroy = NULL; /* paranoia, though you can see a dozen lines */
                             /* below that this isn't necessary */
-        AES_DestroyContext(cx, PR_TRUE);
+        AES_DestroyContext(cx, PR_FALSE);
         return SECFailure;
     }
     return SECSuccess;
 }
 
 /* AES_CreateContext
  *
  * create a new context for Rijndael operations
  */
 AESContext *
@@ skipping 15 matching lines @@
 
 /*
  * AES_DestroyContext
  * 
  * Zero an AES cipher context.  If freeit is true, also free the pointer
  * to the context.
  */
 void 
 AES_DestroyContext(AESContext *cx, PRBool freeit)
 {
-/*  memset(cx, 0, sizeof *cx); */
     if (cx->worker_cx && cx->destroy) {
         (*cx->destroy)(cx->worker_cx, PR_TRUE);
+        cx->worker_cx = NULL;
+        cx->destroy = NULL;
     }
     if (freeit)
         PORT_Free(cx);
 }
 
 /*
  * AES_Encrypt
  *
  * Encrypt an arbitrary-length buffer.  The output buffer must already be
  * allocated to at least inputLen.
@@ skipping 46 matching lines @@
         return SECFailure;
     }
     if (maxOutputLen < inputLen) {
         PORT_SetError(SEC_ERROR_OUTPUT_LEN);
         return SECFailure;
     }
     *outputLen = inputLen;
     return (*cx->worker)(cx->worker_cx, output, outputLen, maxOutputLen,        
                              input, inputLen, blocksize);
 }