Copy data bytes in Web Crypto's importKey() and verify() operations

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 264 matching lines @@
     CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
     ScriptPromise promise = result->promise();
 
     if (!canAccessWebCrypto(scriptState, 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(rawSignature);
 
-    // 14.3.4.3: Let normalizedAlgorithm be the result of normalizing an
+    // 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(rawData);
+
+    // 14.3.4.4: Let normalizedAlgorithm be the result of normalizing an
     //           algorithm, with alg set to algorithm and op set to "verify".
     WebCryptoAlgorithm normalizedAlgorithm;
     if (!parseAlgorithm(rawAlgorithm, WebCryptoOperationVerify, normalizedAlgorithm, result))
         return promise;
 
-    // 14.3.4.5: 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(rawData);
-
     // 14.3.4.9: If the name member of normalizedAlgorithm is not equal to the
     //           name attribute of the [[algorithm]] internal slot of key then throw an
     //           InvalidAccessError.
     //
     // 14.3.4.10: If the [[usages]] internal slot of key does not contain an
     //            entry that is "verify", then throw an InvalidAccessError.
     if (!key->canBeUsedForAlgorithm(normalizedAlgorithm, WebCryptoKeyUsageVerify, result))
         return promise;
 
     histogramAlgorithmAndKey(scriptState->getExecutionContext(), normalizedAlgorithm, key->key());
@@ skipping 67 matching lines @@
         return promise;
 
     WebCryptoKeyFormat format;
     if (!CryptoKey::parseFormat(rawFormat, format, result))
         return promise;
 
     WebCryptoKeyUsageMask keyUsages;
     if (!CryptoKey::parseUsageMask(rawKeyUsages, keyUsages, result))
         return promise;
 
-    // 14.3.9.2: Let normalizedAlgorithm be the result of normalizing an
-    //           algorithm, with alg set to algorithm and op set to
-    //           "importKey".
-    WebCryptoAlgorithm normalizedAlgorithm;
-    if (!parseAlgorithm(rawAlgorithm, WebCryptoOperationImportKey, normalizedAlgorithm, 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.
     WebVector<uint8_t> keyData;
 
     switch (format) {
-    // 14.3.9.6: If format is equal to the string "raw", "pkcs8", or "spki":
+    // 14.3.9.2: If format is equal to the string "raw", "pkcs8", or "spki":
     //
     //  (1) If the keyData parameter passed to the importKey method is a
     //      JsonWebKey dictionary, throw a TypeError.
     //
     //  (2) Let keyData be the result of getting a copy of the bytes held by
     //      the keyData parameter passed to the importKey method.
     case WebCryptoKeyFormatRaw:
     case WebCryptoKeyFormatPkcs8:
     case WebCryptoKeyFormatSpki:
         if (rawKeyData.isArrayBuffer()) {
             keyData = copyBytes(rawKeyData.getAsArrayBuffer());
         } else if (rawKeyData.isArrayBufferView()) {
             keyData = copyBytes(rawKeyData.getAsArrayBufferView());
         } else {
             result->completeWithError(WebCryptoErrorTypeType, "Key data must be a BufferSource for non-JWK formats");
             return promise;
         }
         break;
-    // 14.3.9.6: If format is equal to the string "jwk":
+    // 14.3.9.2: If format is equal to the string "jwk":
     //
     //  (1) If the keyData parameter passed to the importKey method is not a
     //      JsonWebKey dictionary, throw a TypeError.
     //
     //  (2) Let keyData be the keyData parameter passed to the importKey
     //      method.
     case WebCryptoKeyFormatJwk:
         if (rawKeyData.isDictionary()) {
             // TODO(eroman): To match the spec error order, parsing of the
             // JsonWebKey should be done earlier (at the WebIDL layer of
             // parameter checking), regardless of the format being "jwk".
             if (!parseJsonWebKey(rawKeyData.getAsDictionary(), keyData, result))
                 return promise;
         } else {
             result->completeWithError(WebCryptoErrorTypeType, "Key data must be an object for JWK import");
             return promise;
         }
         break;
     }
+
+    // 14.3.9.3: Let normalizedAlgorithm be the result of normalizing an
+    //           algorithm, with alg set to algorithm and op set to
+    //           "importKey".
+    WebCryptoAlgorithm normalizedAlgorithm;
+    if (!parseAlgorithm(rawAlgorithm, WebCryptoOperationImportKey, normalizedAlgorithm, result))
+        return promise;
+
     histogramAlgorithm(scriptState->getExecutionContext(), normalizedAlgorithm);
     Platform::current()->crypto()->importKey(format, std::move(keyData), normalizedAlgorithm, extractable, keyUsages, result->result());
     return promise;
 }
 
 ScriptPromise SubtleCrypto::exportKey(ScriptState* scriptState, const String& rawFormat, CryptoKey* key)
 {
     // Method described by: https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-exportKey
 
     CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
@@ skipping 214 matching lines @@
     // normative requirement is enforced by the platform implementation in the
     // call below.
 
     histogramAlgorithmAndKey(scriptState->getExecutionContext(), normalizedAlgorithm, baseKey->key());
     histogramAlgorithm(scriptState->getExecutionContext(), normalizedDerivedKeyAlgorithm);
     Platform::current()->crypto()->deriveKey(normalizedAlgorithm, baseKey->key(), normalizedDerivedKeyAlgorithm, keyLengthAlgorithm, extractable, keyUsages, result->result());
     return promise;
 }
 
 } // namespace blink