Update to NSS 3.16.2 Beta 3.

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/. */
 
 #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"
+#ifdef USE_HW_AES
 #include "intel-aes.h"
 #include "mpi.h"
 
 static int has_intel_aes = 0;
+static PRBool use_hw_aes = PR_FALSE;
+
+#ifdef INTEL_GCM
+#include "intel-gcm.h"
 static int has_intel_avx = 0;
 static int has_intel_clmul = 0;
-static PRBool use_hw_aes = PR_FALSE;
 static PRBool use_hw_gcm = PR_FALSE;
 #endif
+#endif  /* USE_HW_AES */
 
 /*
  * 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
  * RIJNDAEL_GENERATE_TABLES_MACRO  Same as above, but use macros to do
@@ skipping 784 matching lines @@
 
 static SECStatus 
 rijndael_encryptECB(AESContext *cx, unsigned char *output,
                     unsigned int *outputLen, unsigned int maxOutputLen,
                     const unsigned char *input, unsigned int inputLen, 
                     unsigned int blocksize)
 {
     SECStatus rv;
     AESBlockFunc *encryptor;
 
-
     encryptor = (blocksize == RIJNDAEL_MIN_BLOCKSIZE) 
                                   ? &rijndael_encryptBlock128 
                                   : &rijndael_encryptBlock;
     while (inputLen > 0) {
         rv = (*encryptor)(cx, output, input);
         if (rv != SECSuccess)
             return rv;
         output += blocksize;
         input += blocksize;
         inputLen -= blocksize;
@@ skipping 112 matching lines @@
  * BLAPI for the AES cipher, Rijndael.
  *
  ***********************************************************************/
 
 AESContext * AES_AllocateContext(void)
 {
     return PORT_ZNew(AESContext);
 }
 
 
-#if USE_HW_AES
+#ifdef INTEL_GCM
 /*
  * Adapted from the example code in "How to detect New Instruction support in
  * the 4th generation Intel Core processor family" by Max Locktyukhin.
+ *
+ * XGETBV:
+ *   Reads an extended control register (XCR) specified by ECX into EDX:EAX.
  */
 static PRBool
 check_xcr0_ymm()
 {
     PRUint32 xcr0;
 #if defined(_MSC_VER)
+#if defined(_M_IX86)
+    __asm {
+        mov ecx, 0
+        xgetbv
+        mov xcr0, eax
+    }
+#else
     xcr0 = (PRUint32)_xgetbv(0);  /* Requires VS2010 SP1 or later. */
+#endif
 #else
     __asm__ ("xgetbv" : "=a" (xcr0) : "c" (0) : "%edx");
 #endif
     /* Check if xmm and ymm state are enabled in XCR0. */
     return (xcr0 & 6) == 6;
 }
 #endif
 
 /*
 ** Initialize a new AES context suitable for AES encryption/decryption in
@@ skipping 25 matching lines @@
         return SECFailure;
     }
     if (mode == NSS_AES_CBC && iv == NULL) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return SECFailure;
     }
     if (!cx) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return SECFailure;
     }
-#if USE_HW_AES
+#ifdef 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;
+#ifdef INTEL_GCM
             has_intel_clmul = (ecx & (1 << 1)) != 0 ? 1 : -1;
             if ((ecx & (1 << 27)) != 0 && (ecx & (1 << 28)) != 0 &&
                 check_xcr0_ymm()) {
                 has_intel_avx = 1;
             } else {
                 has_intel_avx = -1;
             }
+#endif
         } else {
             has_intel_aes = -1;
+#ifdef INTEL_GCM
             has_intel_avx = -1;
             has_intel_clmul = -1;
+#endif
         }
     }
     use_hw_aes = (PRBool)
                 (has_intel_aes > 0 && (keysize % 8) == 0 && blocksize == 16);
+#ifdef INTEL_GCM
     use_hw_gcm = (PRBool)
                 (use_hw_aes && has_intel_avx>0 && has_intel_clmul>0);
 #endif
+#endif  /* USE_HW_AES */
     /* 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);
-#if USE_HW_AES
+#ifdef USE_HW_AES
         if (use_hw_aes) {
             cx->worker = (freeblCipherFunc)
                                 intel_aes_cbc_worker(encrypt, keysize);
         } else
 #endif
         {
             cx->worker = (freeblCipherFunc) (encrypt
                           ? &rijndael_encryptCBC : &rijndael_decryptCBC);
         }
     } else {
-#if  USE_HW_AES
+#ifdef  USE_HW_AES
         if (use_hw_aes) {
             cx->worker = (freeblCipherFunc) 
                                 intel_aes_ecb_worker(encrypt, keysize);
         } else
 #endif
         {
             cx->worker = (freeblCipherFunc) (encrypt
                           ? &rijndael_encryptECB : &rijndael_decryptECB);
         }
     }
@@ skipping 67 matching lines @@
     /* 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
+#ifdef INTEL_GCM
         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);
@@ skipping 125 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);
 }