crypto: validate this in all webcrypto methods and getters

PR-URL: #42815
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>

Author: panva

lib/internal/crypto/webcrypto.js

@@ -6,6 +6,7 @@ const {
  JSONStringify,
  ObjectDefineProperties,
  ReflectApply,
+ ReflectConstruct,
  SafeSet,
  SymbolToStringTag,
  StringPrototypeRepeat,
@@ -31,6 +32,7 @@ const { TextDecoder, TextEncoder } = require('internal/encoding');
 
 const{
 codes: {
+ERR_ILLEGAL_CONSTRUCTOR,
 ERR_INVALID_ARG_TYPE,
 ERR_INVALID_THIS,
 }
@@ -70,12 +72,21 @@ const {
 randomUUID: _randomUUID,
 }=require('internal/crypto/random');
 
-constrandomUUID=()=>_randomUUID();
+asyncfunctiondigest(algorithm,data){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
+returnReflectApply(asyncDigest,this,arguments);
+}
+
+functionrandomUUID(){
+if(this!==crypto)thrownewERR_INVALID_THIS('Crypto');
+return_randomUUID();
+}
 
 asyncfunctiongenerateKey(
 algorithm,
 extractable,
 keyUsages){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 algorithm=normalizeAlgorithm(algorithm);
 validateBoolean(extractable,'extractable');
 validateArray(keyUsages,'keyUsages');
@@ -123,6 +134,7 @@ async function generateKey(
 }
 
 asyncfunctionderiveBits(algorithm,baseKey,length){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 algorithm=normalizeAlgorithm(algorithm);
 if(!isCryptoKey(baseKey))
 thrownewERR_INVALID_ARG_TYPE('baseKey','CryptoKey',baseKey);
@@ -194,6 +206,7 @@ async function deriveKey(
 derivedKeyAlgorithm,
 extractable,
 keyUsages){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 algorithm=normalizeAlgorithm(algorithm);
 derivedKeyAlgorithm=normalizeAlgorithm(derivedKeyAlgorithm);
 if(!isCryptoKey(baseKey))
@@ -238,7 +251,11 @@ async function deriveKey(
 throwlazyDOMException('Unrecognized name.');
 }
 
-returnimportKey('raw',bits,derivedKeyAlgorithm,extractable,keyUsages);
+returnReflectApply(
+importKey,
+this,
+['raw',bits,derivedKeyAlgorithm,extractable,keyUsages],
+);
 }
 
 asyncfunctionexportKeySpki(key){
@@ -415,6 +432,7 @@ async function exportKeyJWK(key) {
 }
 
 asyncfunctionexportKey(format,key){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 validateString(format,'format');
 validateOneOf(format,'format',kExportFormats);
 if(!isCryptoKey(key))
@@ -496,6 +514,7 @@ async function importKey(
 algorithm,
 extractable,
 keyUsages){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 validateString(format,'format');
 validateOneOf(format,'format',kExportFormats);
 if(format!=='node.keyObject'&&format!=='jwk')
@@ -557,8 +576,9 @@ async function importKey(
 // subtle.wrapKey() is essentially a subtle.exportKey() followed
 // by a subtle.encrypt().
 asyncfunctionwrapKey(format,key,wrappingKey,algorithm){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 algorithm=normalizeAlgorithm(algorithm);
-letkeyData=awaitexportKey(format,key);
+letkeyData=awaitReflectApply(exportKey,this,[format,key]);
 
 if(format==='jwk'){
 if(keyData==null||typeofkeyData!=='object')
@@ -586,6 +606,7 @@ async function unwrapKey(
 unwrappedKeyAlgo,
 extractable,
 keyUsages){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 wrappedKey=getArrayBufferOrView(wrappedKey,'wrappedKey');
 unwrapAlgo=normalizeAlgorithm(unwrapAlgo);
 letkeyData=awaitcipherOrWrap(
@@ -607,7 +628,11 @@ async function unwrapKey(
 }
 }
 
-returnimportKey(format,keyData,unwrappedKeyAlgo,extractable,keyUsages);
+returnReflectApply(
+importKey,
+this,
+[format,keyData,unwrappedKeyAlgo,extractable,keyUsages],
+);
 }
 
 functionsignVerify(algorithm,key,data,signature){
@@ -654,10 +679,12 @@ function signVerify(algorithm, key, data, signature) {
 }
 
 asyncfunctionsign(algorithm,key,data){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 returnsignVerify(algorithm,key,data);
 }
 
 asyncfunctionverify(algorithm,key,signature,data){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 returnsignVerify(algorithm,key,data,signature);
 }
 
@@ -707,30 +734,39 @@ async function cipherOrWrap(mode, algorithm, key, data, op) {
 }
 
 asyncfunctionencrypt(algorithm,key,data){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 returncipherOrWrap(kWebCryptoCipherEncrypt,algorithm,key,data,'encrypt');
 }
 
 asyncfunctiondecrypt(algorithm,key,data){
+if(this!==subtle)thrownewERR_INVALID_THIS('SubtleCrypto');
 returncipherOrWrap(kWebCryptoCipherDecrypt,algorithm,key,data,'decrypt');
 }
 
 // The SubtleCrypto and Crypto classes are defined as part of the
 // Web Crypto API standard: https://www.w3.org/TR/WebCryptoAPI/
 
-classSubtleCrypto{}
-constsubtle=newSubtleCrypto();
+classSubtleCrypto{
+constructor(){
+thrownewERR_ILLEGAL_CONSTRUCTOR();
+}
+}
+constsubtle=ReflectConstruct(function(){},[],SubtleCrypto);
 
 classCrypto{
+constructor(){
+thrownewERR_ILLEGAL_CONSTRUCTOR();
+}
+
 getsubtle(){
+if(this!==crypto)thrownewERR_INVALID_THIS('Crypto');
 returnsubtle;
 }
 }
-constcrypto=newCrypto();
+constcrypto=ReflectConstruct(function(){},[],Crypto);
 
 functiongetRandomValues(array){
-if(!(thisinstanceofCrypto)){
-thrownewERR_INVALID_THIS('Crypto');
-}
+if(this!==crypto)thrownewERR_INVALID_THIS('Crypto');
 returnReflectApply(_getRandomValues,this,arguments);
 }
 
@@ -799,7 +835,7 @@ ObjectDefineProperties(
 enumerable: true,
 configurable: true,
 writable: true,
-value: asyncDigest,
+value: digest,
 },
 generateKey: {
 enumerable: true,

test/parallel/test-webcrypto-constructors.js

@@ -0,0 +1,159 @@
+// Flags: --experimental-global-webcrypto
+'use strict';
+
+constcommon=require('../common');
+
+if(!common.hasCrypto)
+common.skip('missing crypto');
+
+constassert=require('assert');
+
+// Test CryptoKey constructor
+{
+assert.throws(()=>newCryptoKey(),{
+name: 'TypeError',message: 'Illegal constructor',code: 'ERR_ILLEGAL_CONSTRUCTOR'
+});
+}
+
+// Test SubtleCrypto constructor
+{
+assert.throws(()=>newSubtleCrypto(),{
+name: 'TypeError',message: 'Illegal constructor',code: 'ERR_ILLEGAL_CONSTRUCTOR'
+});
+}
+
+// Test Crypto constructor
+{
+assert.throws(()=>newCrypto(),{
+name: 'TypeError',message: 'Illegal constructor',code: 'ERR_ILLEGAL_CONSTRUCTOR'
+});
+}
+
+constnotCrypto=Reflect.construct(function(){},[],Crypto);
+constnotSubtle=Reflect.construct(function(){},[],SubtleCrypto);
+
+// Test Crypto.prototype.subtle
+{
+assert.throws(()=>notCrypto.subtle,{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+});
+}
+
+// Test Crypto.prototype.randomUUID
+{
+assert.throws(()=>notCrypto.randomUUID(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+});
+}
+
+// Test Crypto.prototype.getRandomValues
+{
+assert.throws(()=>notCrypto.getRandomValues(newUint8Array(12)),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+});
+}
+
+// Test SubtleCrypto.prototype.encrypt
+{
+assert.rejects(()=>notSubtle.encrypt(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.decrypt
+{
+assert.rejects(()=>notSubtle.decrypt(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.sign
+{
+assert.rejects(()=>notSubtle.sign(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.verify
+{
+assert.rejects(()=>notSubtle.verify(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.digest
+{
+assert.rejects(()=>notSubtle.digest(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.generateKey
+{
+assert.rejects(()=>notSubtle.generateKey(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.deriveKey
+{
+assert.rejects(()=>notSubtle.deriveKey(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.deriveBits
+{
+assert.rejects(()=>notSubtle.deriveBits(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.importKey
+{
+assert.rejects(()=>notSubtle.importKey(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.exportKey
+{
+assert.rejects(()=>notSubtle.exportKey(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.wrapKey
+{
+assert.rejects(()=>notSubtle.wrapKey(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+// Test SubtleCrypto.prototype.unwrapKey
+{
+assert.rejects(()=>notSubtle.unwrapKey(),{
+name: 'TypeError',code: 'ERR_INVALID_THIS',
+}).then(common.mustCall());
+}
+
+{
+globalThis.crypto.subtle.importKey(
+'raw',
+globalThis.crypto.getRandomValues(newUint8Array(4)),
+'PBKDF2',
+false,
+['deriveKey'],
+).then((key)=>{
+globalThis.crypto.subtle.importKey=common.mustNotCall();
+returnglobalThis.crypto.subtle.deriveKey({
+name: 'PBKDF2',
+hash: 'SHA-512',
+salt: globalThis.crypto.getRandomValues(newUint8Array()),
+iterations: 5,
+},key,{
+name: 'AES-GCM',
+length: 256
+},true,['encrypt','decrypt']);
+}).then(common.mustCall());
+}