[webcrypto] Give more descriptive error messages on Linux for unsupported functionality.

content/child/webcrypto/platform_crypto_nss.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/child/webcrypto/platform_crypto.h"
 
 #include <cryptohi.h>
 #include <pk11pub.h>
 #include <secerr.h>
 #include <sechash.h>
@@ skipping 259 matching lines @@
   explicit PrivateKey(crypto::ScopedSECKEYPrivateKey key) : key_(key.Pass()) {}
 
   crypto::ScopedSECKEYPrivateKey key_;
   std::vector<uint8> serialized_key_;
 
   DISALLOW_COPY_AND_ASSIGN(PrivateKey);
 };
 
 namespace {
 
+Status NssSupportsAesGcm() {
+  if (g_nss_runtime_support.Get().IsAesGcmSupported())
+    return Status::Success();
+  return Status::ErrorUnsupported(
+      "NSS version doesn't support AES-GCM. Try using version 3.15 or later");
+}
+
+Status NssSupportsRsaOaep() {
+  if (g_nss_runtime_support.Get().IsRsaOaepSupported())
+    return Status::Success();
+  return Status::ErrorUnsupported(
+      "NSS version doesn't support RSA-OAEP. Try using version 3.16.2 or "
+      "later");
+}
+
 // Creates a SECItem for the data in |buffer|. This does NOT make a copy, so
 // |buffer| should outlive the SECItem.
 SECItem MakeSECItemForBuffer(const CryptoData& buffer) {
   SECItem item = {
       siBuffer,
       // NSS requires non-const data even though it is just for input.
       const_cast<unsigned char*>(buffer.bytes()), buffer.byte_length()};
   return item;
 }
 
@@ skipping 151 matching lines @@
 // Helper to either encrypt or decrypt for AES-GCM. The result of encryption is
 // the concatenation of the ciphertext and the authentication tag. Similarly,
 // this is the expectation for the input to decryption.
 Status AesGcmEncryptDecrypt(EncryptOrDecrypt mode,
                             SymKey* key,
                             const CryptoData& data,
                             const CryptoData& iv,
                             const CryptoData& additional_data,
                             unsigned int tag_length_bits,
                             std::vector<uint8>* buffer) {
-  if (!g_nss_runtime_support.Get().IsAesGcmSupported())
-    return Status::ErrorUnsupported();
+  Status status = NssSupportsAesGcm();
+  if (status.IsError())
+    return status;
 
   unsigned int tag_length_bytes = tag_length_bits / 8;
 
   CK_GCM_PARAMS gcm_params = {0};
   gcm_params.pIv = const_cast<unsigned char*>(iv.bytes());
   gcm_params.ulIvLen = iv.byte_length();
 
   gcm_params.pAAD = const_cast<unsigned char*>(additional_data.bytes());
   gcm_params.ulAADLen = additional_data.byte_length();
 
@@ skipping 127 matching lines @@
       *mechanism = CKM_AES_CBC;
       *flags = CKF_ENCRYPT | CKF_DECRYPT;
       return Status::Success();
     }
     case blink::WebCryptoAlgorithmIdAesKw: {
       *mechanism = CKM_NSS_AES_KEY_WRAP;
       *flags = CKF_WRAP | CKF_WRAP;
       return Status::Success();
     }
     case blink::WebCryptoAlgorithmIdAesGcm: {
-      if (!g_nss_runtime_support.Get().IsAesGcmSupported())
-        return Status::ErrorUnsupported();
+      Status status = NssSupportsAesGcm();
+      if (status.IsError())
+        return status;
       *mechanism = CKM_AES_GCM;
       *flags = CKF_ENCRYPT | CKF_DECRYPT;
       return Status::Success();
     }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status DoUnwrapSymKeyAesKw(const CryptoData& wrapped_key_data,
@@ skipping 618 matching lines @@
 
 // -----------------------------------
 // RsaOaep
 // -----------------------------------
 
 Status EncryptRsaOaep(PublicKey* key,
                       const blink::WebCryptoAlgorithm& hash,
                       const CryptoData& label,
                       const CryptoData& data,
                       std::vector<uint8>* buffer) {
-  if (!g_nss_runtime_support.Get().IsRsaOaepSupported())
-    return Status::ErrorUnsupported();
+  Status status = NssSupportsRsaOaep();
+  if (status.IsError())
+    return status;
 
   CK_RSA_PKCS_OAEP_PARAMS oaep_params = {0};
   if (!InitializeRsaOaepParams(hash, label, &oaep_params))
     return Status::ErrorUnsupported();
 
   SECItem param;
   param.type = siBuffer;
   param.data = reinterpret_cast<unsigned char*>(&oaep_params);
   param.len = sizeof(oaep_params);
 
@@ skipping 15 matching lines @@
   DCHECK_LE(output_len, buffer->size());
   buffer->resize(output_len);
   return Status::Success();
 }
 
 Status DecryptRsaOaep(PrivateKey* key,
                       const blink::WebCryptoAlgorithm& hash,
                       const CryptoData& label,
                       const CryptoData& data,
                       std::vector<uint8>* buffer) {
-  if (!g_nss_runtime_support.Get().IsRsaOaepSupported())
-    return Status::ErrorUnsupported();
+  Status status = NssSupportsRsaOaep();
+  if (status.IsError())
+    return status;
 
   CK_RSA_PKCS_OAEP_PARAMS oaep_params = {0};
   if (!InitializeRsaOaepParams(hash, label, &oaep_params))
     return Status::ErrorUnsupported();
 
   SECItem param;
   param.type = siBuffer;
   param.data = reinterpret_cast<unsigned char*>(&oaep_params);
   param.len = sizeof(oaep_params);
 
@@ skipping 127 matching lines @@
 // -----------------------------------
 
 Status GenerateRsaKeyPair(const blink::WebCryptoAlgorithm& algorithm,
                           bool extractable,
                           blink::WebCryptoKeyUsageMask public_key_usage_mask,
                           blink::WebCryptoKeyUsageMask private_key_usage_mask,
                           unsigned int modulus_length_bits,
                           unsigned long public_exponent,
                           blink::WebCryptoKey* public_key,
                           blink::WebCryptoKey* private_key) {
-  if (algorithm.id() == blink::WebCryptoAlgorithmIdRsaOaep &&
-      !g_nss_runtime_support.Get().IsRsaOaepSupported()) {
-    return Status::ErrorUnsupported();
+  if (algorithm.id() == blink::WebCryptoAlgorithmIdRsaOaep) {
+    Status status = NssSupportsRsaOaep();
+    if (status.IsError())
+      return status;
   }
 
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   if (!slot)
     return Status::OperationError();
 
   PK11RSAGenParams rsa_gen_params;
   rsa_gen_params.keySizeInBits = modulus_length_bits;
   rsa_gen_params.pe = public_exponent;
 
@@ skipping 409 matching lines @@
                            std::vector<uint8>* buffer) {
   return mode == ENCRYPT ? EncryptAesKw(wrapping_key, data, buffer)
                          : DecryptAesKw(wrapping_key, data, buffer);
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content