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

content/child/webcrypto/shared_crypto.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/shared_crypto.h"
 
 #include "base/logging.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/platform_crypto.h"
@@ skipping 85 matching lines @@
   return platform::EncryptDecryptAesGcm(
       mode,
       sym_key,
       data,
       CryptoData(params->iv()),
       CryptoData(params->optionalAdditionalData()),
       tag_length_bits,
       buffer);
 }
 
-Status EncryptRsaEsPkcs1v1_5(const blink::WebCryptoAlgorithm& algorithm,
-                             const blink::WebCryptoKey& key,
-                             const CryptoData& data,
-                             std::vector<uint8>* buffer) {
-  platform::PublicKey* public_key;
-  Status status = ToPlatformPublicKey(key, &public_key);
-  if (status.IsError())
-    return status;
-
-  // RSAES encryption does not support empty input
-  if (!data.byte_length())
-    return Status::ErrorDataTooSmall();
-
-  return platform::EncryptRsaEsPkcs1v1_5(public_key, data, buffer);
-}
-
-Status DecryptRsaEsPkcs1v1_5(const blink::WebCryptoAlgorithm& algorithm,
-                             const blink::WebCryptoKey& key,
-                             const CryptoData& data,
-                             std::vector<uint8>* buffer) {
-  platform::PrivateKey* private_key;
-  Status status = ToPlatformPrivateKey(key, &private_key);
-  if (status.IsError())
-    return status;
-
-  // RSAES decryption does not support empty input
-  if (!data.byte_length())
-    return Status::ErrorDataTooSmall();
-
-  return platform::DecryptRsaEsPkcs1v1_5(private_key, data, buffer);
-}
-
 Status EncryptRsaOaep(const blink::WebCryptoAlgorithm& algorithm,
                       const blink::WebCryptoKey& key,
                       const CryptoData& data,
                       std::vector<uint8>* buffer) {
   platform::PublicKey* public_key;
   Status status = ToPlatformPublicKey(key, &public_key);
   if (status.IsError())
     return status;
 
   const blink::WebCryptoRsaOaepParams* params = algorithm.rsaOaepParams();
@@ skipping 126 matching lines @@
 
   NOTREACHED();
   return blink::WebCryptoKeyFormatRaw;
 }
 
 // Converts a KeyAlgorithm into an equivalent Algorithm for import.
 blink::WebCryptoAlgorithm KeyAlgorithmToImportAlgorithm(
     const blink::WebCryptoKeyAlgorithm& algorithm) {
   switch (algorithm.paramsType()) {
     case blink::WebCryptoKeyAlgorithmParamsTypeAes:
-    case blink::WebCryptoKeyAlgorithmParamsTypeRsa:
       return CreateAlgorithm(algorithm.id());
     case blink::WebCryptoKeyAlgorithmParamsTypeHmac:
       return CreateHmacImportAlgorithm(algorithm.hmacParams()->hash().id());
     case blink::WebCryptoKeyAlgorithmParamsTypeRsaHashed:
       return CreateRsaHashedImportAlgorithm(
           algorithm.id(), algorithm.rsaHashedParams()->hash().id());
     case blink::WebCryptoKeyAlgorithmParamsTypeNone:
       break;
+    default:
+      break;
   }
   return blink::WebCryptoAlgorithm::createNull();
 }
 
 // There is some duplicated information in the serialized format used by
 // structured clone (since the KeyAlgorithm is serialized separately from the
 // key data). Use this extra information to further validate what was
 // deserialized from the key data.
 //
 // A failure here implies either a bug in the code, or that the serialized data
 // was corrupted.
 bool ValidateDeserializedKey(const blink::WebCryptoKey& key,
                              const blink::WebCryptoKeyAlgorithm& algorithm,
                              blink::WebCryptoKeyType type) {
   if (algorithm.id() != key.algorithm().id())
     return false;
 
   if (key.type() != type)
     return false;
 
   switch (algorithm.paramsType()) {
     case blink::WebCryptoKeyAlgorithmParamsTypeAes:
       if (algorithm.aesParams()->lengthBits() !=
           key.algorithm().aesParams()->lengthBits())
         return false;
       break;
-    case blink::WebCryptoKeyAlgorithmParamsTypeRsa:
     case blink::WebCryptoKeyAlgorithmParamsTypeRsaHashed:
-      if (algorithm.rsaParams()->modulusLengthBits() !=
-          key.algorithm().rsaParams()->modulusLengthBits())
+      if (algorithm.rsaHashedParams()->modulusLengthBits() !=
+          key.algorithm().rsaHashedParams()->modulusLengthBits())
         return false;
-      if (algorithm.rsaParams()->publicExponent().size() !=
-          key.algorithm().rsaParams()->publicExponent().size())
+      if (algorithm.rsaHashedParams()->publicExponent().size() !=
+          key.algorithm().rsaHashedParams()->publicExponent().size())
         return false;
-      if (memcmp(algorithm.rsaParams()->publicExponent().data(),
-                 key.algorithm().rsaParams()->publicExponent().data(),
-                 key.algorithm().rsaParams()->publicExponent().size()) != 0)
+      if (memcmp(algorithm.rsaHashedParams()->publicExponent().data(),
+                 key.algorithm().rsaHashedParams()->publicExponent().data(),
+                 key.algorithm().rsaHashedParams()->publicExponent().size()) !=
+          0)
         return false;
       break;
     case blink::WebCryptoKeyAlgorithmParamsTypeNone:
     case blink::WebCryptoKeyAlgorithmParamsTypeHmac:
       break;
+    default:
+      return false;
   }
 
   return true;
 }
 
 // Validates the size of data input to AES-KW. AES-KW requires the input data
 // size to be at least 24 bytes and a multiple of 8 bytes.
 Status CheckAesKwInputSize(const CryptoData& aeskw_input_data) {
   if (aeskw_input_data.byte_length() < 24)
     return Status::ErrorDataTooSmall();
@@ skipping 19 matching lines @@
       status = CheckAesKwInputSize(wrapped_key_data);
       if (status.IsError())
         return status;
       return platform::UnwrapSymKeyAesKw(wrapped_key_data,
                                          platform_wrapping_key,
                                          algorithm,
                                          extractable,
                                          usage_mask,
                                          key);
     }
-    case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5: {
-      platform::PrivateKey* platform_wrapping_key;
-      Status status =
-          ToPlatformPrivateKey(wrapping_key, &platform_wrapping_key);
-      if (status.IsError())
-        return status;
-      if (!wrapped_key_data.byte_length())
-        return Status::ErrorDataTooSmall();
-      return platform::UnwrapSymKeyRsaEs(wrapped_key_data,
-                                         platform_wrapping_key,
-                                         algorithm,
-                                         extractable,
-                                         usage_mask,
-                                         key);
-    }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status WrapKeyRaw(const blink::WebCryptoKey& key_to_wrap,
                   const blink::WebCryptoKey& wrapping_key,
                   const blink::WebCryptoAlgorithm& wrapping_algorithm,
                   std::vector<uint8>* buffer) {
   // A raw key is always a symmetric key.
   platform::SymKey* platform_key;
   Status status = ToPlatformSymKey(key_to_wrap, &platform_key);
   if (status.IsError())
     return status;
 
   // TODO(padolph): Handle other wrapping algorithms
   switch (wrapping_algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesKw: {
       platform::SymKey* platform_wrapping_key;
       status = ToPlatformSymKey(wrapping_key, &platform_wrapping_key);
       if (status.IsError())
         return status;
       return platform::WrapSymKeyAesKw(
           platform_key, platform_wrapping_key, buffer);
     }
-    case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5: {
-      platform::PublicKey* platform_wrapping_key;
-      status = ToPlatformPublicKey(wrapping_key, &platform_wrapping_key);
-      if (status.IsError())
-        return status;
-      return platform::WrapSymKeyRsaEs(
-          platform_key, platform_wrapping_key, buffer);
-    }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status DecryptAesKw(const blink::WebCryptoAlgorithm& algorithm,
                     const blink::WebCryptoKey& key,
                     const CryptoData& data,
                     std::vector<uint8>* buffer) {
   platform::SymKey* sym_key;
@@ skipping 10 matching lines @@
                                 const blink::WebCryptoKey& key,
                                 const CryptoData& data,
                                 std::vector<uint8>* buffer) {
   if (algorithm.id() != key.algorithm().id())
     return Status::ErrorUnexpected();
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc:
       return EncryptDecryptAesCbc(DECRYPT, algorithm, key, data, buffer);
     case blink::WebCryptoAlgorithmIdAesGcm:
       return EncryptDecryptAesGcm(DECRYPT, algorithm, key, data, buffer);
-    case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
-      return DecryptRsaEsPkcs1v1_5(algorithm, key, data, buffer);
     case blink::WebCryptoAlgorithmIdRsaOaep:
       return DecryptRsaOaep(algorithm, key, data, buffer);
     case blink::WebCryptoAlgorithmIdAesKw:
       return DecryptAesKw(algorithm, key, data, buffer);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status EncryptDontCheckUsage(const blink::WebCryptoAlgorithm& algorithm,
                              const blink::WebCryptoKey& key,
                              const CryptoData& data,
                              std::vector<uint8>* buffer) {
   if (algorithm.id() != key.algorithm().id())
     return Status::ErrorUnexpected();
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc:
       return EncryptDecryptAesCbc(ENCRYPT, algorithm, key, data, buffer);
     case blink::WebCryptoAlgorithmIdAesGcm:
       return EncryptDecryptAesGcm(ENCRYPT, algorithm, key, data, buffer);
-    case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
-      return EncryptRsaEsPkcs1v1_5(algorithm, key, data, buffer);
     case blink::WebCryptoAlgorithmIdRsaOaep:
       return EncryptRsaOaep(algorithm, key, data, buffer);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status UnwrapKeyDecryptAndImport(
     blink::WebCryptoKeyFormat format,
     const CryptoData& wrapped_key_data,
@@ skipping 132 matching lines @@
       algorithm, extractable, usage_mask, keylen_bytes, key);
 }
 
 Status GenerateKeyPair(const blink::WebCryptoAlgorithm& algorithm,
                        bool extractable,
                        blink::WebCryptoKeyUsageMask usage_mask,
                        blink::WebCryptoKey* public_key,
                        blink::WebCryptoKey* private_key) {
   // TODO(padolph): Handle other asymmetric algorithm key generation.
   switch (algorithm.paramsType()) {
-    case blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams:
-    case blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams: {
-      const blink::WebCryptoRsaKeyGenParams* params = NULL;
-      blink::WebCryptoAlgorithm hash_or_null =
-          blink::WebCryptoAlgorithm::createNull();
-      if (algorithm.rsaHashedKeyGenParams()) {
-        params = algorithm.rsaHashedKeyGenParams();
-        hash_or_null = algorithm.rsaHashedKeyGenParams()->hash();
-      } else {
-        params = algorithm.rsaKeyGenParams();
-      }
+    case blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams: {
+      const blink::WebCryptoRsaHashedKeyGenParams* params =
+          algorithm.rsaHashedKeyGenParams();
 
       if (!params->modulusLengthBits())
         return Status::ErrorGenerateRsaZeroModulus();
 
       CryptoData publicExponent(params->publicExponent());
       if (!publicExponent.byte_length())
         return Status::ErrorGenerateKeyPublicExponent();
 
       return platform::GenerateRsaKeyPair(algorithm,
                                           extractable,
                                           usage_mask,
                                           params->modulusLengthBits(),
                                           publicExponent,
-                                          hash_or_null,
                                           public_key,
                                           private_key);
     }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 // Note that this function may be called from the target Blink thread.
 Status ImportKey(blink::WebCryptoKeyFormat format,
@@ skipping 112 matching lines @@
                const blink::WebCryptoKey& wrapping_key,
                const blink::WebCryptoAlgorithm& wrapping_algorithm,
                std::vector<uint8>* buffer) {
   if (!KeyUsageAllows(wrapping_key, blink::WebCryptoKeyUsageWrapKey))
     return Status::ErrorUnexpected();
   if (wrapping_algorithm.id() != wrapping_key.algorithm().id())
     return Status::ErrorUnexpected();
 
   switch (format) {
     case blink::WebCryptoKeyFormatRaw:
-      if (wrapping_algorithm.id() == blink::WebCryptoAlgorithmIdAesKw ||
-          wrapping_algorithm.id() ==
-              blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5) {
+      if (wrapping_algorithm.id() == blink::WebCryptoAlgorithmIdAesKw) {
         // AES-KW is a special case, due to NSS's implementation only
         // supporting C_Wrap/C_Unwrap with AES-KW
         return WrapKeyRaw(
             key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
       }
       return WrapKeyExportAndEncrypt(
           format, key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
     case blink::WebCryptoKeyFormatJwk:
       return WrapKeyExportAndEncrypt(
           format, key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
@@ skipping 14 matching lines @@
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usage_mask,
                  blink::WebCryptoKey* key) {
   if (!KeyUsageAllows(wrapping_key, blink::WebCryptoKeyUsageUnwrapKey))
     return Status::ErrorUnexpected();
   if (wrapping_algorithm.id() != wrapping_key.algorithm().id())
     return Status::ErrorUnexpected();
 
   switch (format) {
     case blink::WebCryptoKeyFormatRaw:
-      if (wrapping_algorithm.id() == blink::WebCryptoAlgorithmIdAesKw ||
-          wrapping_algorithm.id() ==
-              blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5) {
+      if (wrapping_algorithm.id() == blink::WebCryptoAlgorithmIdAesKw) {
         // AES-KW is a special case, due to NSS's implementation only
         // supporting C_Wrap/C_Unwrap with AES-KW
         return UnwrapKeyRaw(wrapped_key_data,
                             wrapping_key,
                             wrapping_algorithm,
                             algorithm,
                             extractable,
                             usage_mask,
                             key);
       }
@@ skipping 76 matching lines @@
                             platform::PrivateKey** out) {
   *out = static_cast<platform::Key*>(key.handle())->AsPrivateKey();
   if (!*out)
     return Status::ErrorUnexpectedKeyType();
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content