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

content/child/webcrypto/jwk.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 "jwk.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 
@@ skipping 92 matching lines @@
 //   | "HS256"      | HMAC using SHA-256 hash algorithm                     |
 //   | "HS384"      | HMAC using SHA-384 hash algorithm                     |
 //   | "HS512"      | HMAC using SHA-512 hash algorithm                     |
 //   | "RS1"        | RSASSA using SHA-1 hash algorithm
 //   | "RS256"      | RSASSA using SHA-256 hash algorithm                   |
 //   | "RS384"      | RSASSA using SHA-384 hash algorithm                   |
 //   | "RS512"      | RSASSA using SHA-512 hash algorithm                   |
 //   +--------------+-------------------------------------------------------|
 //   | Key Management Algorithm                                             |
 //   +--------------+-------------------------------------------------------+
-//   | "RSA1_5"     | RSAES-PKCS1-V1_5 [RFC3447]                            |
 //   | "RSA-OAEP"   | RSAES using Optimal Asymmetric Encryption Padding     |
 //   |              | (OAEP) [RFC3447], with the default parameters         |
 //   |              | specified by RFC3447 in Section A.2.1                 |
 //   | "A128KW"     | Advanced Encryption Standard (AES) Key Wrap Algorithm |
 //   |              | [RFC3394] using 128 bit keys                          |
 //   | "A192KW"     | AES Key Wrap Algorithm using 192 bit keys             |
 //   | "A256KW"     | AES Key Wrap Algorithm using 256 bit keys             |
 //   | "A128GCM"    | AES in Galois/Counter Mode (GCM) [NIST.800-38D] using |
 //   |              | 128 bit keys                                          |
 //   | "A192GCM"    | AES GCM using 192 bit keys                            |
@@ skipping 177 matching lines @@
                                           blink::WebCryptoAlgorithmIdSha1>);
     alg_to_info_["RS256"] =
         JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha256>);
     alg_to_info_["RS384"] =
         JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha384>);
     alg_to_info_["RS512"] =
         JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha512>);
-    alg_to_info_["RSA1_5"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateAlgorithm,
-                         blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5>);
     alg_to_info_["RSA-OAEP"] =
         JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaOaepImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha1>);
     alg_to_info_["RSA-OAEP-256"] =
         JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaOaepImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha256>);
     alg_to_info_["RSA-OAEP-384"] =
         JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaOaepImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha384>);
     alg_to_info_["RSA-OAEP-512"] =
@@ skipping 334 matching lines @@
           break;
         case blink::WebCryptoAlgorithmIdSha512:
           jwk_dict->SetString("alg", "HS512");
           break;
         default:
           NOTREACHED();
           return Status::ErrorUnexpected();
       }
       break;
     }
-    case blink::WebCryptoKeyAlgorithmParamsTypeRsa:
-      switch (algorithm.id()) {
-        case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
-          jwk_dict->SetString("alg", "RSA1_5");
-          break;
-        default:
-          NOTREACHED();
-          return Status::ErrorUnexpected();
-      }
-      break;
     case blink::WebCryptoKeyAlgorithmParamsTypeRsaHashed:
       switch (algorithm.id()) {
         case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5: {
           switch (algorithm.rsaHashedParams()->hash().id()) {
             case blink::WebCryptoAlgorithmIdSha1:
               jwk_dict->SetString("alg", "RS1");
               break;
             case blink::WebCryptoAlgorithmIdSha256:
               jwk_dict->SetString("alg", "RS256");
               break;
@@ skipping 35 matching lines @@
       }
       break;
     default:
       return Status::ErrorUnsupported();
   }
   return Status::Success();
 }
 
 bool IsRsaKey(const blink::WebCryptoKey& key) {
   const blink::WebCryptoAlgorithmId algorithm_id = key.algorithm().id();
-  return algorithm_id == blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5 ||
-         algorithm_id == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 ||
+  return algorithm_id == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 ||
          algorithm_id == blink::WebCryptoAlgorithmIdRsaOaep;
 }
 
 Status ImportRsaKey(base::DictionaryValue* dict,
                     const blink::WebCryptoAlgorithm& algorithm,
                     bool extractable,
                     blink::WebCryptoKeyUsageMask usage_mask,
                     blink::WebCryptoKey* key) {
   // An RSA public key must have an "n" (modulus) and an "e" (exponent) entry
   // in the JWK, while an RSA private key must have those, plus at least a "d"
@@ skipping 276 matching lines @@
 
   std::string json;
   base::JSONWriter::Write(&jwk_dict, &json);
   buffer->assign(json.data(), json.data() + json.size());
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content