Added [SecureContext] to the subtle attribute

third_party/WebKit/Source/modules/crypto/SubtleCrypto.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 40 matching lines @@
                            WebCryptoOperation op,
                            WebCryptoAlgorithm& algorithm,
                            CryptoResult* result) {
   AlgorithmError error;
   bool success = NormalizeAlgorithm(raw, op, algorithm, &error);
   if (!success)
     result->CompleteWithError(error.error_type, error.error_details);
   return success;
 }
 
-static bool CanAccessWebCrypto(ScriptState* script_state,
-                               CryptoResult* result) {
-  String error_message;
-  if (!ExecutionContext::From(script_state)
-           ->IsSecureContext(error_message,
-                             ExecutionContext::kWebCryptoSecureContextCheck)) {
-    result->CompleteWithError(kWebCryptoErrorTypeNotSupported, error_message);
-    return false;
-  }
-
-  if (!ExecutionContext::From(script_state)->IsSecureContext()) {
-    Deprecation::CountDeprecation(
-        ExecutionContext::From(script_state),
-        UseCounter::kSubtleCryptoOnlyStrictSecureContextCheckFailed);
-  }
-
-  return true;
-}
-
 static bool CopyStringProperty(const char* property,
                                const Dictionary& source,
                                JSONObject* destination) {
   String value;
   if (!DictionaryHelper::Get(source, property, value))
     return false;
   destination->SetString(property, value);
   return true;
 }
 
@@ skipping 93 matching lines @@
 ScriptPromise SubtleCrypto::encrypt(ScriptState* script_state,
                                     const AlgorithmIdentifier& raw_algorithm,
                                     CryptoKey* key,
                                     const BufferSource& raw_data) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-encrypt
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   // 14.3.1.2: Let data be the result of getting a copy of the bytes held by
   //           the data parameter passed to the encrypt method.
   WebVector<uint8_t> data = CopyBytes(raw_data);
 
   // 14.3.1.3: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to "encrypt".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationEncrypt,
                       normalized_algorithm, result))
     return promise;
@@ skipping 18 matching lines @@
 ScriptPromise SubtleCrypto::decrypt(ScriptState* script_state,
                                     const AlgorithmIdentifier& raw_algorithm,
                                     CryptoKey* key,
                                     const BufferSource& raw_data) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-decrypt
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   // 14.3.2.2: Let data be the result of getting a copy of the bytes held by
   //           the data parameter passed to the decrypt method.
   WebVector<uint8_t> data = CopyBytes(raw_data);
 
   // 14.3.2.3: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to "decrypt".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationDecrypt,
                       normalized_algorithm, result))
     return promise;
@@ skipping 18 matching lines @@
 ScriptPromise SubtleCrypto::sign(ScriptState* script_state,
                                  const AlgorithmIdentifier& raw_algorithm,
                                  CryptoKey* key,
                                  const BufferSource& raw_data) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-sign
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   // 14.3.3.2: Let data be the result of getting a copy of the bytes held by
   //           the data parameter passed to the sign method.
   WebVector<uint8_t> data = CopyBytes(raw_data);
 
   // 14.3.3.3: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to "sign".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationSign,
                       normalized_algorithm, result))
     return promise;
@@ skipping 20 matching lines @@
     const AlgorithmIdentifier& raw_algorithm,
     CryptoKey* key,
     const BufferSource& raw_signature,
     const BufferSource& raw_data) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-verify
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   // 14.3.4.2: Let signature be the result of getting a copy of the bytes
   //           held by the signature parameter passed to the verify method.
   WebVector<uint8_t> signature = CopyBytes(raw_signature);
 
   // 14.3.4.3: Let data be the result of getting a copy of the bytes held by
   //           the data parameter passed to the verify method.
   WebVector<uint8_t> data = CopyBytes(raw_data);
 
   // 14.3.4.4: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to "verify".
@@ skipping 22 matching lines @@
 
 ScriptPromise SubtleCrypto::digest(ScriptState* script_state,
                                    const AlgorithmIdentifier& raw_algorithm,
                                    const BufferSource& raw_data) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-digest
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   // 14.3.5.2: Let data be the result of getting a copy of the bytes held
   //              by the data parameter passed to the digest method.
   WebVector<uint8_t> data = CopyBytes(raw_data);
 
   // 14.3.5.3: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to "digest".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationDigest,
                       normalized_algorithm, result))
     return promise;
 
   HistogramAlgorithm(ExecutionContext::From(script_state),
                      normalized_algorithm);
   Platform::Current()->Crypto()->Digest(normalized_algorithm, std::move(data),
                                         result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::generateKey(
     ScriptState* script_state,
     const AlgorithmIdentifier& raw_algorithm,
     bool extractable,
     const Vector<String>& raw_key_usages) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-generateKey
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   WebCryptoKeyUsageMask key_usages;
   if (!CryptoKey::ParseUsageMask(raw_key_usages, key_usages, result))
     return promise;
 
   // 14.3.6.2: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to
   //           "generateKey".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationGenerateKey,
                       normalized_algorithm, result))
@@ skipping 16 matching lines @@
     const ArrayBufferOrArrayBufferViewOrDictionary& raw_key_data,
     const AlgorithmIdentifier& raw_algorithm,
     bool extractable,
     const Vector<String>& raw_key_usages) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-importKey
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   WebCryptoKeyFormat format;
   if (!CryptoKey::ParseFormat(raw_format, format, result))
     return promise;
 
   WebCryptoKeyUsageMask key_usages;
   if (!CryptoKey::ParseUsageMask(raw_key_usages, key_usages, result))
     return promise;
 
   // In the case of JWK keyData will hold the UTF8-encoded JSON for the
   // JsonWebKey, otherwise it holds a copy of the BufferSource.
@@ skipping 61 matching lines @@
 
 ScriptPromise SubtleCrypto::exportKey(ScriptState* script_state,
                                       const String& raw_format,
                                       CryptoKey* key) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-exportKey
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   WebCryptoKeyFormat format;
   if (!CryptoKey::ParseFormat(raw_format, format, result))
     return promise;
 
   // 14.3.10.6: If the [[extractable]] internal slot of key is false, then
   //            throw an InvalidAccessError.
   if (!key->extractable()) {
     result->CompleteWithError(kWebCryptoErrorTypeInvalidAccess,
                               "key is not extractable");
     return promise;
@@ skipping 10 matching lines @@
     const String& raw_format,
     CryptoKey* key,
     CryptoKey* wrapping_key,
     const AlgorithmIdentifier& raw_wrap_algorithm) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-wrapKey
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   WebCryptoKeyFormat format;
   if (!CryptoKey::ParseFormat(raw_format, format, result))
     return promise;
 
   // 14.3.11.2: Let normalizedAlgorithm be the result of normalizing an
   //            algorithm, with alg set to algorithm and op set to "wrapKey".
   //
   // 14.3.11.3: If an error occurred, let normalizedAlgorithm be the result
   //            of normalizing an algorithm, with alg set to algorithm and op
   //            set to "encrypt".
@@ skipping 42 matching lines @@
     const AlgorithmIdentifier& raw_unwrap_algorithm,
     const AlgorithmIdentifier& raw_unwrapped_key_algorithm,
     bool extractable,
     const Vector<String>& raw_key_usages) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-unwrapKey
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   WebCryptoKeyFormat format;
   if (!CryptoKey::ParseFormat(raw_format, format, result))
     return promise;
 
   WebCryptoKeyUsageMask key_usages;
   if (!CryptoKey::ParseUsageMask(raw_key_usages, key_usages, result))
     return promise;
 
   // 14.3.12.2: Let wrappedKey be the result of getting a copy of the bytes
   //            held by the wrappedKey parameter passed to the unwrapKey
@@ skipping 49 matching lines @@
 ScriptPromise SubtleCrypto::deriveBits(ScriptState* script_state,
                                        const AlgorithmIdentifier& raw_algorithm,
                                        CryptoKey* base_key,
                                        unsigned length_bits) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-deriveBits
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   // 14.3.8.2: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to
   //           "deriveBits".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationDeriveBits,
                       normalized_algorithm, result))
     return promise;
 
   // 14.3.8.7: If the name member of normalizedAlgorithm is not equal to the
   //           name attribute of the [[algorithm]] internal slot of baseKey
@@ skipping 18 matching lines @@
     CryptoKey* base_key,
     const AlgorithmIdentifier& raw_derived_key_type,
     bool extractable,
     const Vector<String>& raw_key_usages) {
   // Method described by:
   // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-deriveKey
 
   CryptoResultImpl* result = CryptoResultImpl::Create(script_state);
   ScriptPromise promise = result->Promise();
 
-  if (!CanAccessWebCrypto(script_state, result))
-    return promise;
-
   WebCryptoKeyUsageMask key_usages;
   if (!CryptoKey::ParseUsageMask(raw_key_usages, key_usages, result))
     return promise;
 
   // 14.3.7.2: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to
   //           "deriveBits".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationDeriveBits,
                       normalized_algorithm, result))
@@ skipping 38 matching lines @@
                            normalized_algorithm, base_key->Key());
   HistogramAlgorithm(ExecutionContext::From(script_state),
                      normalized_derived_key_algorithm);
   Platform::Current()->Crypto()->DeriveKey(
       normalized_algorithm, base_key->Key(), normalized_derived_key_algorithm,
       key_length_algorithm, extractable, key_usages, result->Result());
   return promise;
 }
 
 }  // namespace blink