better detection of padlock PHE.

diff --git a/lib/accelerated/x86/aes-padlock.c b/lib/accelerated/x86/aes-padlock.c
index dd62c9dd46544de6ecfb94cf420bec358819fe41..774cc923b32f02499cfd765b60522e119e1aa428 100644 (file)
--- a/lib/accelerated/x86/aes-padlock.c
+++ b/lib/accelerated/x86/aes-padlock.c
@@ -184,7 +184,7 @@ check_phe (void)
 
 /* We are actually checking for SHA512 */
 static int
-check_phe_block (void)
+check_phe_sha512 (void)
 {
   unsigned int edx = padlock_capability ();
 
@@ -209,7 +209,7 @@ check_via (void)
 void
 register_padlock_crypto (void)
 {
-  int ret;
+  int ret, phe;
 
   if (check_via () == 0)
     return;
@@ -217,8 +217,8 @@ register_padlock_crypto (void)
     {
       _gnutls_debug_log ("Padlock AES accelerator was detected\n");
       ret =
-          gnutls_crypto_single_cipher_register
-          (GNUTLS_CIPHER_AES_128_CBC, 80, &aes_padlock_struct);
+        gnutls_crypto_single_cipher_register
+        (GNUTLS_CIPHER_AES_128_CBC, 80, &aes_padlock_struct);
       if (ret < 0)
         {
           gnutls_assert ();
@@ -226,33 +226,32 @@ register_padlock_crypto (void)
 
       /* register GCM ciphers */
       ret =
-          gnutls_crypto_single_cipher_register
-          (GNUTLS_CIPHER_AES_128_GCM, 80, &aes_gcm_padlock_struct);
+        gnutls_crypto_single_cipher_register
+        (GNUTLS_CIPHER_AES_128_GCM, 80, &aes_gcm_padlock_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 #ifdef HAVE_LIBNETTLE
       ret =
-          gnutls_crypto_single_cipher_register (GNUTLS_CIPHER_AES_192_CBC,
-                                                80, &aes_padlock_struct);
+        gnutls_crypto_single_cipher_register (GNUTLS_CIPHER_AES_192_CBC,
+                                              80, &aes_padlock_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 
       ret =
-          gnutls_crypto_single_cipher_register (GNUTLS_CIPHER_AES_256_CBC,
-                                                80, &aes_padlock_struct);
+        gnutls_crypto_single_cipher_register (GNUTLS_CIPHER_AES_256_CBC,
+                                              80, &aes_padlock_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 
       ret =
-          gnutls_crypto_single_cipher_register (GNUTLS_CIPHER_AES_256_GCM,
-                                                80,
-                                                &aes_gcm_padlock_struct);
+        gnutls_crypto_single_cipher_register (GNUTLS_CIPHER_AES_256_GCM,
+                                              80, &aes_gcm_padlock_struct);
       if (ret < 0)
         {
           gnutls_assert ();
@@ -261,116 +260,129 @@ register_padlock_crypto (void)
 #endif
     }
 
-  if (check_phe_block())
-    {
-      ret =
-          gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA1,
-                                             80, &sha_padlock_nano_struct);
-      if (ret < 0)
-        {
-          gnutls_assert ();
-        }
-
-      ret =
-          gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA256,
-                                             80, &sha_padlock_nano_struct);
-      if (ret < 0)
-        {
-          gnutls_assert ();
-        }
+#ifdef HAVE_LIBNETTLE
+  phe = check_phe ();
 
-      ret =
-          gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA1,
-                                             80, &hmac_sha_padlock_nano_struct);
-      if (ret < 0)
+  if (is_padlock_nano () && phe)
+    {
+      if (check_phe_sha512 ())
         {
-          gnutls_assert ();
+          ret =
+            gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA384,
+                                                  80,
+                                                  &sha_padlock_nano_struct);
+          if (ret < 0)
+            {
+              gnutls_assert ();
+            }
+
+          ret =
+            gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA512,
+                                                  80,
+                                                  &sha_padlock_nano_struct);
+          if (ret < 0)
+            {
+              gnutls_assert ();
+            }
+
+          ret =
+            gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA384,
+                                               80,
+                                               &hmac_sha_padlock_nano_struct);
+          if (ret < 0)
+            {
+              gnutls_assert ();
+            }
+
+          ret =
+            gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA512,
+                                               80,
+                                               &hmac_sha_padlock_nano_struct);
+          if (ret < 0)
+            {
+              gnutls_assert ();
+            }
         }
 
       ret =
-          gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA256,
-                                             80, &hmac_sha_padlock_nano_struct);
+        gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA1,
+                                              80, &sha_padlock_nano_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 
       ret =
-          gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA224,
-                                             80, &sha_padlock_nano_struct);
+        gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA224,
+                                              80, &sha_padlock_nano_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 
       ret =
-          gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA384,
-                                             80, &sha_padlock_nano_struct);
+        gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA256,
+                                              80, &sha_padlock_nano_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 
       ret =
-          gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA512,
-                                             80, &sha_padlock_nano_struct);
+        gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA1,
+                                           80, &hmac_sha_padlock_nano_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 
-      ret =
-          gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA384,
-                                             80, &hmac_sha_padlock_nano_struct);
-      if (ret < 0)
-        {
-          gnutls_assert ();
-        }
+      /* we don't register MAC_SHA224 because it is not used by TLS */
 
       ret =
-          gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA512,
-                                             80, &hmac_sha_padlock_nano_struct);
+        gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA256,
+                                           80, &hmac_sha_padlock_nano_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
-
     }
-  else if (check_phe())
+  else if (phe)
     {
+      /* Original padlock PHE. Does not support incremental operations.
+       */
       ret =
-          gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA1,
-                                             80, &sha_padlock_struct);
+        gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA1,
+                                              80, &sha_padlock_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 
       ret =
-          gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA256,
-                                             80, &sha_padlock_struct);
+        gnutls_crypto_single_digest_register (GNUTLS_DIG_SHA256,
+                                              80, &sha_padlock_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 
       ret =
-          gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA1,
-                                             80, &hmac_sha_padlock_struct);
+        gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA1,
+                                           80, &hmac_sha_padlock_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
 
       ret =
-          gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA256,
-                                             80, &hmac_sha_padlock_struct);
+        gnutls_crypto_single_mac_register (GNUTLS_MAC_SHA256,
+                                           80, &hmac_sha_padlock_struct);
       if (ret < 0)
         {
           gnutls_assert ();
         }
     }
-
+#endif
 
   return;
 }

diff --git a/lib/accelerated/x86/aes-padlock.h b/lib/accelerated/x86/aes-padlock.h
index ccb8359af319aa428c2bdbe48ff57f5e8020ef4c..608f5d12d7087a377f270ada5f6a20aadedc1a96 100644 (file)
--- a/lib/accelerated/x86/aes-padlock.h
+++ b/lib/accelerated/x86/aes-padlock.h
@@ -38,6 +38,7 @@ int padlock_aes_cipher_setkey(void *_ctx, const void *userkey, size_t keysize);
 
 /* asm */
 unsigned int padlock_capability(void);
+unsigned int is_padlock_nano(void);
 void padlock_reload_key(void);
 int padlock_ecb_encrypt(void *out, const void *inp,
                         struct padlock_cipher_data *ctx, size_t len);

diff --git a/lib/accelerated/x86/asm/padlock-x86-64.s b/lib/accelerated/x86/asm/padlock-x86-64.s
index e18f7a5a4add472aca623ec55530dcdc19a4a19c..31542ac990681dd2e189d3879a959ad7ddcae068 100644 (file)
--- a/lib/accelerated/x86/asm/padlock-x86-64.s
+++ b/lib/accelerated/x86/asm/padlock-x86-64.s
@@ -36,6 +36,24 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 .text  
+.globl is_padlock_nano
+.type  is_padlock_nano,@function
+.align 16
+is_padlock_nano:
+       xorl    %eax,%eax
+       cpuid
+       movl    $1,%eax
+       cpuid
+       or      $0x000f,%eax
+        cmp     $0x06ff,%eax
+       jne     .Lno_nano
+       mov     $1,%eax
+        ret
+.Lno_nano:
+       xorl    %eax,%eax
+        ret
+.size  is_padlock_nano,.-is_padlock_nano
+
 .globl padlock_capability
 .type  padlock_capability,@function
 .align 16

diff --git a/lib/accelerated/x86/asm/padlock-x86.s b/lib/accelerated/x86/asm/padlock-x86.s
index 16da1998c4830b3995bc6f96abcff687325a5dfc..297f13a7b67ee4a34b7b9033fc73d0820a34d025 100644 (file)
--- a/lib/accelerated/x86/asm/padlock-x86.s
+++ b/lib/accelerated/x86/asm/padlock-x86.s
@@ -37,6 +37,24 @@
 
 .file  "padlock-x86.s"
 .text
+.globl is_padlock_nano
+.type  is_padlock_nano,@function
+.align 16
+is_padlock_nano:
+       xorl    %eax,%eax
+       cpuid
+       movl    $1,%eax
+       cpuid
+       or      $0x000f,%eax
+        cmp     $0x06ff,%eax
+       jne     .Lno_nano
+       mov     $1,%eax
+        ret
+.Lno_nano:
+       xorl    %eax,%eax
+        ret
+.size  is_padlock_nano,.-is_padlock_nano
+
 .globl padlock_capability
 .type  padlock_capability,@function
 .align 16

diff --git a/lib/accelerated/x86/hmac-padlock.c b/lib/accelerated/x86/hmac-padlock.c
index f0497b6831197be1f485de2b517eb134fec5778b..8a4508ce6107a8f6676870bf0e283e7ebd587c77 100644 (file)
--- a/lib/accelerated/x86/hmac-padlock.c
+++ b/lib/accelerated/x86/hmac-padlock.c
@@ -33,7 +33,7 @@
 #include <assert.h>
 #include <sha-padlock.h>
 
-#ifdef ENABLE_NETTLE
+#ifdef HAVE_LIBNETTLE
 
 #define IPAD 0x36
 #define OPAD 0x5c
@@ -370,4 +370,4 @@ const gnutls_crypto_mac_st hmac_sha_padlock_nano_struct = {
     .fast = wrap_padlock_hmac_fast,
 };
 
-#endif /* ENABLE_NETTLE */
+#endif /* HAVE_LIBNETTLE */

diff --git a/lib/accelerated/x86/sha-padlock.c b/lib/accelerated/x86/sha-padlock.c
index 779a2e550574187e3e3a87beaffe34a41583c01a..becaaf96ba1be4ae4ac1bdad5ccafc6e05761294 100644 (file)
--- a/lib/accelerated/x86/sha-padlock.c
+++ b/lib/accelerated/x86/sha-padlock.c
@@ -31,7 +31,7 @@
 #include <assert.h>
 #include <sha-padlock.h>
 
-#ifdef ENABLE_NETTLE
+#ifdef HAVE_LIBNETTLE
 
 typedef void (*update_func) (void *, unsigned, const uint8_t *);
 typedef void (*digest_func) (void *, unsigned, uint8_t *);
@@ -412,4 +412,4 @@ const gnutls_crypto_digest_st sha_padlock_nano_struct = {
   .fast = wrap_padlock_hash_fast,
 };
 
-#endif /* ENABLE_NETTLE */
+#endif /* HAVE_LIBNETTLE */

diff --git a/src/benchmark-cipher.c b/src/benchmark-cipher.c
index 534af75f1cda7efb9d2ff48532f903c24f7a1cae..e9b82e8157187199749774e62527679a7f65828e 100644 (file)
--- a/src/benchmark-cipher.c
+++ b/src/benchmark-cipher.c
@@ -212,13 +212,13 @@ void benchmark_cipher (int init, int debug_level)
       gnutls_rnd( GNUTLS_RND_NONCE, data, sizeof(data));
     }
 
-  cipher_bench ( GNUTLS_CIPHER_AES_128_GCM, 16, 1);
-  cipher_mac_bench ( GNUTLS_CIPHER_AES_128_CBC, GNUTLS_MAC_SHA256, 16);
   cipher_mac_bench ( GNUTLS_CIPHER_AES_128_CBC, GNUTLS_MAC_SHA1, 16);
+  cipher_mac_bench ( GNUTLS_CIPHER_AES_128_CBC, GNUTLS_MAC_SHA256, 16);
+  cipher_bench ( GNUTLS_CIPHER_AES_128_GCM, 16, 1);
 
   mac_bench (GNUTLS_MAC_SHA1, 16);
-
   mac_bench (GNUTLS_MAC_SHA256, 16);
+  mac_bench (GNUTLS_MAC_SHA512, 16);
 
   cipher_bench (GNUTLS_CIPHER_3DES_CBC, 16, 0);