[webcrypto] Update to use the KeyAlgorithm.

content/renderer/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/renderer/webcrypto/platform_crypto.h"
 
 #include <cryptohi.h>
 #include <pk11pub.h>
 #include <sechash.h>
 
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "content/renderer/webcrypto/crypto_data.h"
 #include "content/renderer/webcrypto/webcrypto_util.h"
 #include "crypto/nss_util.h"
 #include "crypto/scoped_nss_types.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+#include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
+#endif
 
 #if defined(USE_NSS)
 #include <dlfcn.h>
 #endif
 
 // At the time of this writing:
 //   * Windows and Mac builds ship with their own copy of NSS (3.15+)
 //   * Linux builds use the system's libnss, which is 3.14 on Debian (but 3.15+
 //     on other distros).
 //
@@ skipping 328 matching lines @@
 }
 
 CK_MECHANISM_TYPE WebCryptoAlgorithmToGenMechanism(
     const blink::WebCryptoAlgorithm& algorithm) {
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesKw:
       return CKM_AES_KEY_GEN;
     case blink::WebCryptoAlgorithmIdHmac:
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+      return WebCryptoHashToHMACMechanism(algorithm.hmacKeyGenParams()->hash());
+#else
       return WebCryptoHashToHMACMechanism(algorithm.hmacKeyParams()->hash());
+#endif
     default:
       return CKM_INVALID_MECHANISM;
   }
 }
 
 // Converts a (big-endian) WebCrypto BigInteger, with or without leading zeros,
 // to unsigned long.
-bool BigIntegerToLong(const uint8* data,
-                      unsigned int data_size,
-                      unsigned long* result) {
-  // TODO(padolph): Is it correct to say that empty data is an error, or does it
-  // mean value 0? See https://www.w3.org/Bugs/Public/show_bug.cgi?id=23655
-  if (data_size == 0)
+bool BigIntegerToLong(const CryptoData& data, unsigned long* result) {
+  if (!data.byte_length())
     return false;
 
   *result = 0;
-  for (size_t i = 0; i < data_size; ++i) {
-    size_t reverse_i = data_size - i - 1;
+  for (size_t i = 0; i < data.byte_length(); ++i) {
+    size_t reverse_i = data.byte_length() - i - 1;
 
-    if (reverse_i >= sizeof(unsigned long) && data[i])
+    if (reverse_i >= sizeof(unsigned long) && data.bytes()[i])
       return false;  // Too large for a long.
 
-    *result |= data[i] << 8 * reverse_i;
+    *result |= data.bytes()[i] << 8 * reverse_i;
   }
   return true;
 }
 
 bool IsAlgorithmRsa(const blink::WebCryptoAlgorithm& algorithm) {
   return algorithm.id() == blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5 ||
          algorithm.id() == blink::WebCryptoAlgorithmIdRsaOaep ||
          algorithm.id() == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5;
 }
 
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+bool CreatePublicKeyAlgorithm(const blink::WebCryptoAlgorithm& algorithm,
+                              SECKEYPublicKey* key,
+                              blink::WebCryptoKeyAlgorithm* key_algorithm) {
+  if (!key || key->keyType != rsaKey)

[Ryan Sleevi, 2014/02/25 22:26:26]

rsaPssKey
rsaOaepKey

[eroman, 2014/02/25 23:26:47]

Added a TODO.

I don't want to add that handling until there are corresponding tests that would
exercise it (the current ones do not).

+    return false;
+
+  unsigned int modulus_length_bits = SECKEY_PublicKeyStrength(key) * 8;
+  CryptoData public_exponent(key->u.rsa.publicExponent.data,
+                             key->u.rsa.publicExponent.len);
+
+  if (algorithm.paramsType() ==
+          blink::WebCryptoAlgorithmParamsTypeRsaHashedImportParams ||
+      algorithm.paramsType() ==
+          blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams) {
+    *key_algorithm = blink::WebCryptoKeyAlgorithm::adoptParamsAndCreate(
+        algorithm.id(),
+        new blink::WebCryptoRsaHashedKeyAlgorithmParams(
+            modulus_length_bits,
+            public_exponent.bytes(),
+            public_exponent.byte_length(),
+            GetInnerHashAlgorithm(algorithm)));
+    return true;
+  }
+
+  if (algorithm.paramsType() ==
+          blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams ||
+      algorithm.paramsType() == blink::WebCryptoAlgorithmParamsTypeNone) {

[Ryan Sleevi, 2014/02/25 22:26:26]

Does it make sense to make these a set of switch statements?

[eroman, 2014/02/25 23:26:47]

Yes, that makes more sense.
Done.
Thanks

+    *key_algorithm = blink::WebCryptoKeyAlgorithm::adoptParamsAndCreate(
+        algorithm.id(),
+        new blink::WebCryptoRsaKeyAlgorithmParams(
+            modulus_length_bits,
+            public_exponent.bytes(),
+            public_exponent.byte_length()));
+    return true;
+  }
+
+  return false;
+}
+
+bool CreatePrivateKeyAlgorithm(const blink::WebCryptoAlgorithm& algorithm,
+                               SECKEYPrivateKey* key,
+                               blink::WebCryptoKeyAlgorithm* key_algorithm) {
+  return CreatePublicKeyAlgorithm(
+      algorithm, SECKEY_ConvertToPublicKey(key), key_algorithm);
+}
+#endif
+
 }  // namespace
 
 Status ImportKeyRaw(const blink::WebCryptoAlgorithm& algorithm,
                     const CryptoData& key_data,
                     bool extractable,
                     blink::WebCryptoKeyUsageMask usage_mask,
                     blink::WebCryptoKey* key) {
 
   DCHECK(!algorithm.isNull());
 
   // TODO(bryaneyler): Need to split handling for symmetric and asymmetric keys.
   // Currently only supporting symmetric.
   CK_MECHANISM_TYPE mechanism = CKM_INVALID_MECHANISM;
   // Flags are verified at the Blink layer; here the flags are set to all
   // possible operations for this key type.
   CK_FLAGS flags = 0;
 
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdHmac: {
-      const blink::WebCryptoHmacParams* params = algorithm.hmacParams();
-      if (!params)
-        return Status::ErrorUnexpected();
+      const blink::WebCryptoAlgorithm& hash = GetInnerHashAlgorithm(algorithm);
 
-      mechanism = WebCryptoHashToHMACMechanism(params->hash());
+      mechanism = WebCryptoHashToHMACMechanism(hash);
       if (mechanism == CKM_INVALID_MECHANISM)
         return Status::ErrorUnsupported();
 
       flags |= CKF_SIGN | CKF_VERIFY;
-
       break;
     }
     case blink::WebCryptoAlgorithmIdAesCbc: {
       mechanism = CKM_AES_CBC;
       flags |= CKF_ENCRYPT | CKF_DECRYPT;
       break;
     }
     case blink::WebCryptoAlgorithmIdAesKw: {
       mechanism = CKM_NSS_AES_KEY_WRAP;
       flags |= CKF_WRAP | CKF_WRAP;
@@ skipping 21 matching lines @@
                                  mechanism,
                                  PK11_OriginUnwrap,
                                  CKA_FLAGS_ONLY,
                                  &key_item,
                                  flags,
                                  false,
                                  NULL));
   if (!pk11_sym_key.get())
     return Status::Error();
 
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+  blink::WebCryptoKeyAlgorithm key_algorithm;
+  if (!CreateSecretKeyAlgorithm(
+          algorithm, key_data.byte_length(), &key_algorithm))
+    return Status::ErrorUnexpected();
+#else
+  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
+#endif
+
   *key = blink::WebCryptoKey::create(new SymKey(pk11_sym_key.Pass()),
                                      blink::WebCryptoKeyTypeSecret,
                                      extractable,
-                                     algorithm,
+                                     key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 Status ExportKeyRaw(SymKey* key, blink::WebArrayBuffer* buffer) {
   if (PK11_ExtractKeyValue(key->key()) != SECSuccess)
     return Status::Error();
 
   const SECItem* key_data = PK11_GetKeyData(key->key());
   if (!key_data)
@@ skipping 38 matching lines @@
     default:
       break;
   }
   return blink::WebCryptoAlgorithm::createNull();
 }
 
 }  // namespace
 
 Status ImportKeySpki(const blink::WebCryptoAlgorithm& algorithm_or_null,
                      const CryptoData& key_data,
-                     bool extractable,
                      blink::WebCryptoKeyUsageMask usage_mask,
                      blink::WebCryptoKey* key) {
 
   DCHECK(key);
 
   if (!key_data.byte_length())
     return Status::ErrorImportEmptyKeyData();
   DCHECK(key_data.bytes());
 
   // The binary blob 'key_data' is expected to be a DER-encoded ASN.1 Subject
   // Public Key Info. Decode this to a CERTSubjectPublicKeyInfo.
   SECItem spki_item = MakeSECItemForBuffer(key_data);
   const ScopedCERTSubjectPublicKeyInfo spki(
       SECKEY_DecodeDERSubjectPublicKeyInfo(&spki_item));
   if (!spki)
     return Status::Error();
 
   crypto::ScopedSECKEYPublicKey sec_public_key(
       SECKEY_ExtractPublicKey(spki.get()));
   if (!sec_public_key)
     return Status::Error();
 
   const KeyType sec_key_type = SECKEY_GetPublicKeyType(sec_public_key.get());
   blink::WebCryptoAlgorithm algorithm =
       ResolveNssKeyTypeWithInputAlgorithm(sec_key_type, algorithm_or_null);
   if (algorithm.isNull())
     return Status::Error();
 
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+  blink::WebCryptoKeyAlgorithm key_algorithm;
+  if (!CreatePublicKeyAlgorithm(
+          algorithm, sec_public_key.get(), &key_algorithm))
+    return Status::ErrorUnexpected();
+#else
+  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
+#endif
+
   *key = blink::WebCryptoKey::create(new PublicKey(sec_public_key.Pass()),
                                      blink::WebCryptoKeyTypePublic,
-                                     extractable,
-                                     algorithm,
+                                     true,
+                                     key_algorithm,
                                      usage_mask);
 
   return Status::Success();
 }
 
 Status ExportKeySpki(PublicKey* key, blink::WebArrayBuffer* buffer) {
   const crypto::ScopedSECItem spki_der(
       SECKEY_EncodeDERSubjectPublicKeyInfo(key->key()));
   if (!spki_der)
     return Status::Error();
@@ skipping 37 matching lines @@
   }
   DCHECK(seckey_private_key);
   crypto::ScopedSECKEYPrivateKey private_key(seckey_private_key);
 
   const KeyType sec_key_type = SECKEY_GetPrivateKeyType(private_key.get());
   blink::WebCryptoAlgorithm algorithm =
       ResolveNssKeyTypeWithInputAlgorithm(sec_key_type, algorithm_or_null);
   if (algorithm.isNull())
     return Status::Error();
 
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+  blink::WebCryptoKeyAlgorithm key_algorithm;
+  if (!CreatePrivateKeyAlgorithm(algorithm, private_key.get(), &key_algorithm))
+    return Status::ErrorUnexpected();
+#else
+  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
+#endif
+
   *key = blink::WebCryptoKey::create(new PrivateKey(private_key.Pass()),
                                      blink::WebCryptoKeyTypePrivate,
                                      extractable,
-                                     algorithm,
+                                     key_algorithm,
                                      usage_mask);
 
   return Status::Success();
 }
 
 // -----------------------------------
 // Hmac
 // -----------------------------------
 
 Status SignHmac(SymKey* key,
@@ skipping 193 matching lines @@
       mode, key, data, iv, additional_data, tag_length_bits, buffer);
 }
 
 // -----------------------------------
 // Key generation
 // -----------------------------------
 
 Status GenerateRsaKeyPair(const blink::WebCryptoAlgorithm& algorithm,
                           bool extractable,
                           blink::WebCryptoKeyUsageMask usage_mask,
+                          unsigned int modulus_length_bits,
+                          const CryptoData& public_exponent,
+                          const blink::WebCryptoAlgorithm& hash_or_null,
                           blink::WebCryptoKey* public_key,
                           blink::WebCryptoKey* private_key) {
-  const blink::WebCryptoRsaKeyGenParams* const params =
-      algorithm.rsaKeyGenParams();
-  DCHECK(params);
-
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   if (!slot)
     return Status::Error();
 
-  unsigned long public_exponent;
-  if (!params->modulusLengthBits())
-    return Status::ErrorGenerateRsaZeroModulus();
-
-  if (!BigIntegerToLong(params->publicExponent().data(),
-                        params->publicExponent().size(),
-                        &public_exponent) ||
-      !public_exponent) {
+  unsigned long public_exponent_long;
+  if (!BigIntegerToLong(public_exponent, &public_exponent_long) ||
+      !public_exponent_long) {
     return Status::ErrorGenerateKeyPublicExponent();
   }
 
   PK11RSAGenParams rsa_gen_params;
-  rsa_gen_params.keySizeInBits = params->modulusLengthBits();
-  rsa_gen_params.pe = public_exponent;
+  rsa_gen_params.keySizeInBits = modulus_length_bits;
+  rsa_gen_params.pe = public_exponent_long;
 
   // Flags are verified at the Blink layer; here the flags are set to all
   // possible operations for the given key type.
   CK_FLAGS operation_flags;
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
     case blink::WebCryptoAlgorithmIdRsaOaep:
       operation_flags = CKF_ENCRYPT | CKF_DECRYPT | CKF_WRAP | CKF_UNWRAP;
       break;
     case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
@@ skipping 15 matching lines @@
                                       CKM_RSA_PKCS_KEY_PAIR_GEN,
                                       &rsa_gen_params,
                                       &sec_public_key,
                                       attribute_flags,
                                       operation_flags,
                                       operation_flags_mask,
                                       NULL));
   if (!private_key)
     return Status::Error();
 
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+  blink::WebCryptoKeyAlgorithm key_algorithm;
+  if (!CreatePublicKeyAlgorithm(algorithm, sec_public_key, &key_algorithm))
+    return Status::ErrorUnexpected();
+#else
+  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
+#endif
+
   *public_key = blink::WebCryptoKey::create(
       new PublicKey(crypto::ScopedSECKEYPublicKey(sec_public_key)),
       blink::WebCryptoKeyTypePublic,
       true,
-      algorithm,
+      key_algorithm,
       usage_mask);
   *private_key =
       blink::WebCryptoKey::create(new PrivateKey(scoped_sec_private_key.Pass()),
                                   blink::WebCryptoKeyTypePrivate,
                                   extractable,
-                                  algorithm,
+                                  key_algorithm,
                                   usage_mask);
 
   return Status::Success();
 }
 
 void Init() { crypto::EnsureNSSInit(); }
 
 Status DigestSha(blink::WebCryptoAlgorithmId algorithm,
                  const CryptoData& data,
                  blink::WebArrayBuffer* buffer) {
@@ skipping 40 matching lines @@
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   if (!slot)
     return Status::Error();
 
   crypto::ScopedPK11SymKey pk11_key(
       PK11_KeyGen(slot.get(), mech, NULL, keylen_bytes, NULL));
 
   if (!pk11_key)
     return Status::Error();
 
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+  blink::WebCryptoKeyAlgorithm key_algorithm;
+  if (!CreateSecretKeyAlgorithm(algorithm, keylen_bytes, &key_algorithm))
+    return Status::ErrorUnexpected();
+#else
+  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
+#endif
+
   *key = blink::WebCryptoKey::create(new SymKey(pk11_key.Pass()),
                                      key_type,
                                      extractable,
-                                     algorithm,
+                                     key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 Status ImportRsaPublicKey(const blink::WebCryptoAlgorithm& algorithm,
                           bool extractable,
                           blink::WebCryptoKeyUsageMask usage_mask,
                           const CryptoData& modulus_data,
                           const CryptoData& exponent_data,
                           blink::WebCryptoKey* key) {
@@ skipping 35 matching lines @@
       SEC_ASN1EncodeItem(NULL, NULL, &pubkey_in, rsa_public_key_template));
   if (!pubkey_der)
     return Status::Error();
 
   // Import the DER-encoded public key to create an RSA SECKEYPublicKey.
   crypto::ScopedSECKEYPublicKey pubkey(
       SECKEY_ImportDERPublicKey(pubkey_der.get(), CKK_RSA));
   if (!pubkey)
     return Status::Error();
 
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+  blink::WebCryptoKeyAlgorithm key_algorithm;
+  if (!CreatePublicKeyAlgorithm(algorithm, pubkey.get(), &key_algorithm))
+    return Status::ErrorUnexpected();
+#else
+  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
+#endif
+
   *key = blink::WebCryptoKey::create(new PublicKey(pubkey.Pass()),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
-                                     algorithm,
+                                     key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content