[webcrypto] Remove RSA-ES support (2 of 3)

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 535 matching lines @@
     size_t reverse_i = data_size - i - 1;
 
     if (reverse_i >= sizeof(unsigned long) && data[i])
       return false;  // Too large for a long.
 
     *result |= data[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;
-}
-
 bool CreatePublicKeyAlgorithm(const blink::WebCryptoAlgorithm& algorithm,
                               SECKEYPublicKey* key,
                               blink::WebCryptoKeyAlgorithm* key_algorithm) {
   // TODO(eroman): What about other key types rsaPss, rsaOaep.
   if (!key || key->keyType != rsaKey)
     return false;
 
   unsigned int modulus_length_bits = SECKEY_PublicKeyStrength(key) * 8;
   CryptoData public_exponent(key->u.rsa.publicExponent.data,
                              key->u.rsa.publicExponent.len);
 
   switch (algorithm.paramsType()) {
     case blink::WebCryptoAlgorithmParamsTypeRsaHashedImportParams:
     case blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams:
       *key_algorithm = blink::WebCryptoKeyAlgorithm::createRsaHashed(
           algorithm.id(),
           modulus_length_bits,
           public_exponent.bytes(),
           public_exponent.byte_length(),
           GetInnerHashAlgorithm(algorithm).id());
       return true;
-    case blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams:
-    case blink::WebCryptoAlgorithmParamsTypeNone:
-      *key_algorithm = blink::WebCryptoKeyAlgorithm::createRsa(
-          algorithm.id(),
-          modulus_length_bits,
-          public_exponent.bytes(),
-          public_exponent.byte_length());
-      return true;
     default:
       return false;
   }
 }
 
 bool CreatePrivateKeyAlgorithm(const blink::WebCryptoAlgorithm& algorithm,
                                SECKEYPrivateKey* key,
                                blink::WebCryptoKeyAlgorithm* key_algorithm) {
   crypto::ScopedSECKEYPublicKey public_key(SECKEY_ConvertToPublicKey(key));
   return CreatePublicKeyAlgorithm(algorithm, public_key.get(), key_algorithm);
@@ skipping 379 matching lines @@
                    crypto::NSSDestroyer<CERTSubjectPublicKeyInfo,
                                         SECKEY_DestroySubjectPublicKeyInfo> >
     ScopedCERTSubjectPublicKeyInfo;
 
 // Validates an NSS KeyType against a WebCrypto import algorithm.
 bool ValidateNssKeyTypeAgainstInputAlgorithm(
     KeyType key_type,
     const blink::WebCryptoAlgorithm& algorithm) {
   switch (key_type) {
     case rsaKey:
-      return IsAlgorithmRsa(algorithm);
+      return IsAlgorithmRsa(algorithm.id());
     case dsaKey:
     case ecKey:
     case rsaPssKey:
     case rsaOaepKey:
       // TODO(padolph): Handle other key types.
       break;
     default:
       break;
   }
   return false;
@@ skipping 106 matching lines @@
   AssignVectorFromSecItem(key_props.exponent2, exponent2);
   AssignVectorFromSecItem(key_props.coefficient, coefficient);
 
   return Status::Success();
 }
 
 Status ExportKeyPkcs8(PrivateKey* key,
                       const blink::WebCryptoKeyAlgorithm& key_algorithm,
                       std::vector<uint8>* buffer) {
   // TODO(eroman): Support other RSA key types as they are added to Blink.
-  if (key_algorithm.id() != blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5 &&
-      key_algorithm.id() != blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 &&
+  if (key_algorithm.id() != blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 &&
       key_algorithm.id() != blink::WebCryptoAlgorithmIdRsaOaep)
     return Status::ErrorUnsupported();
 
 // TODO(rsleevi): Implement OAEP support according to the spec.
 
 #if defined(USE_NSS)
   // PK11_ExportDERPrivateKeyInfo isn't available. Use our fallback code.
   const SECOidTag algorithm = SEC_OID_PKCS1_RSA_ENCRYPTION;
   const int kPrivateKeyInfoVersion = 0;
 
@@ skipping 131 matching lines @@
                           &signature_item,
                           &data_item) != SECSuccess) {
     return Status::OperationError();
   }
 
   DCHECK_EQ(buffer->size(), signature_item.len);
   return Status::Success();
 }
 
 // -----------------------------------
-// RsaEsPkcs1v1_5
-// -----------------------------------
-
-Status EncryptRsaEsPkcs1v1_5(PublicKey* key,
-                             const CryptoData& data,
-                             std::vector<uint8>* buffer) {
-  const unsigned int encrypted_length_bytes =
-      SECKEY_PublicKeyStrength(key->key());
-
-  // RSAES can operate on messages up to a length of k - 11, where k is the
-  // octet length of the RSA modulus.
-  if (encrypted_length_bytes < 11 ||
-      encrypted_length_bytes - 11 < data.byte_length())
-    return Status::ErrorDataTooLarge();
-
-  buffer->resize(encrypted_length_bytes);
-  unsigned char* const buffer_data = Uint8VectorStart(buffer);
-
-  if (PK11_PubEncryptPKCS1(key->key(),
-                           buffer_data,
-                           const_cast<unsigned char*>(data.bytes()),
-                           data.byte_length(),
-                           NULL) != SECSuccess) {
-    return Status::OperationError();
-  }
-  return Status::Success();
-}
-
-Status DecryptRsaEsPkcs1v1_5(PrivateKey* key,
-                             const CryptoData& data,
-                             std::vector<uint8>* buffer) {
-  const int modulus_length_bytes = PK11_GetPrivateModulusLen(key->key());
-  if (modulus_length_bytes <= 0)
-    return Status::ErrorUnexpected();
-  const unsigned int max_output_length_bytes = modulus_length_bytes;
-
-  buffer->resize(max_output_length_bytes);
-  unsigned char* const buffer_data = Uint8VectorStart(buffer);
-
-  unsigned int output_length_bytes = 0;
-  if (PK11_PrivDecryptPKCS1(key->key(),
-                            buffer_data,
-                            &output_length_bytes,
-                            max_output_length_bytes,
-                            const_cast<unsigned char*>(data.bytes()),
-                            data.byte_length()) != SECSuccess) {
-    return Status::OperationError();
-  }
-  DCHECK_LE(output_length_bytes, max_output_length_bytes);
-  buffer->resize(output_length_bytes);
-  return Status::Success();
-}
-
-// -----------------------------------
 // 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();
@@ skipping 171 matching lines @@
 
 // -----------------------------------
 // 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) {
   if (algorithm.id() == blink::WebCryptoAlgorithmIdRsaOaep &&
       !g_nss_runtime_support.Get().IsRsaOaepSupported()) {
     return Status::ErrorUnsupported();
   }
 
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   if (!slot)
     return Status::OperationError();
 
   unsigned long public_exponent_long;
   if (!BigIntegerToLong(public_exponent.bytes(),
                         public_exponent.byte_length(),
                         &public_exponent_long) ||
       !public_exponent_long) {
     return Status::ErrorGenerateKeyPublicExponent();
   }
 
   PK11RSAGenParams rsa_gen_params;
   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:
       operation_flags = CKF_SIGN | CKF_VERIFY;
       break;
     default:
       NOTREACHED();
       return Status::ErrorUnexpected();
   }
@@ skipping 374 matching lines @@
   if (PK11_ExtractKeyValue(decrypted.get()) != SECSuccess)
     return Status::OperationError();
   const SECItem* const key_data = PK11_GetKeyData(decrypted.get());
   if (!key_data)
     return Status::OperationError();
   buffer->assign(key_data->data, key_data->data + key_data->len);
 
   return Status::Success();
 }
 
-Status WrapSymKeyRsaEs(SymKey* key,
-                       PublicKey* wrapping_key,
-                       std::vector<uint8>* buffer) {
-  // Check the raw length of the key to be wrapped against the max size allowed
-  // by the RSA wrapping key. With PKCS#1 v1.5 padding used in this function,
-  // the maximum data length that can be encrypted is the wrapping_key's modulus
-  // byte length minus eleven bytes.
-  const unsigned int input_length_bytes = PK11_GetKeyLength(key->key());
-  const unsigned int modulus_length_bytes =
-      SECKEY_PublicKeyStrength(wrapping_key->key());
-  if (modulus_length_bytes < 11 ||
-      modulus_length_bytes - 11 < input_length_bytes)
-    return Status::ErrorDataTooLarge();
-
-  buffer->resize(modulus_length_bytes);
-  SECItem wrapped_key_item = MakeSECItemForBuffer(CryptoData(*buffer));
-
-  if (SECSuccess !=
-      PK11_PubWrapSymKey(
-          CKM_RSA_PKCS, wrapping_key->key(), key->key(), &wrapped_key_item)) {
-    return Status::OperationError();
-  }
-  if (wrapped_key_item.len != modulus_length_bytes)
-    return Status::ErrorUnexpected();
-
-  return Status::Success();
-}
-
-Status UnwrapSymKeyRsaEs(const CryptoData& wrapped_key_data,
-                         PrivateKey* wrapping_key,
-                         const blink::WebCryptoAlgorithm& algorithm,
-                         bool extractable,
-                         blink::WebCryptoKeyUsageMask usage_mask,
-                         blink::WebCryptoKey* key) {
-  // Verify wrapped_key_data size does not exceed the modulus of the RSA key.
-  const int modulus_length_bytes =
-      PK11_GetPrivateModulusLen(wrapping_key->key());
-  if (modulus_length_bytes <= 0)
-    return Status::ErrorUnexpected();
-  if (wrapped_key_data.byte_length() >
-      static_cast<unsigned int>(modulus_length_bytes))
-    return Status::ErrorDataTooLarge();
-
-  // Determine the proper NSS key properties from the input algorithm.
-  CK_MECHANISM_TYPE mechanism;
-  CK_FLAGS flags;
-  Status status =
-      WebCryptoAlgorithmToNssMechFlags(algorithm, &mechanism, &flags);
-  if (status.IsError())
-    return status;
-
-  SECItem wrapped_key_item = MakeSECItemForBuffer(wrapped_key_data);
-
-  crypto::ScopedPK11SymKey unwrapped_key(
-      PK11_PubUnwrapSymKeyWithFlagsPerm(wrapping_key->key(),
-                                        &wrapped_key_item,
-                                        mechanism,
-                                        CKA_DECRYPT,
-                                        0,
-                                        flags,
-                                        false));
-  if (!unwrapped_key)
-    return Status::OperationError();
-
-  const unsigned int key_length = PK11_GetKeyLength(unwrapped_key.get());
-
-  blink::WebCryptoKeyAlgorithm key_algorithm;
-  if (!CreateSecretKeyAlgorithm(algorithm, key_length, &key_algorithm))
-    return Status::ErrorUnexpected();
-
-  scoped_ptr<SymKey> key_handle;
-  status = SymKey::Create(unwrapped_key.Pass(), &key_handle);
-  if (status.IsError())
-    return status;
-
-  *key = blink::WebCryptoKey::create(key_handle.release(),
-                                     blink::WebCryptoKeyTypeSecret,
-                                     extractable,
-                                     key_algorithm,
-                                     usage_mask);
-  return Status::Success();
-}
-
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content