crypto: fix cross-realm SharedArrayBuffer validation

PR-URL: #57974
Reviewed-By: Jordan Harband <ljharb@gmail.com>
Reviewed-By: Marco Ippolito <marcoippolito54@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>

Author: aduh95

lib/internal/crypto/webidl.js

@@ -25,9 +25,6 @@ const {
  String,
  TypedArrayPrototypeGetBuffer,
  TypedArrayPrototypeGetSymbolToStringTag,
-globalThis: {
- SharedArrayBuffer,
-},
 }=primordials;
 
 const{
@@ -47,7 +44,7 @@ const {
  validateMaxBufferLength,
  kNamedCurveAliases,
 }=require('internal/crypto/util');
-const{ isArrayBuffer }=require('internal/util/types');
+const{ isArrayBuffer, isSharedArrayBuffer}=require('internal/util/types');
 
 // https://tc39.es/ecma262/#sec-tonumber
 functiontoNumber(value,opts=kEmptyObject){
@@ -195,13 +192,6 @@ converters.object = (V, opts) => {
 
 constisNonSharedArrayBuffer=isArrayBuffer;
 
-functionisSharedArrayBuffer(V){
-// SharedArrayBuffers can be disabled with --no-harmony-sharedarraybuffer.
-if(SharedArrayBuffer!==undefined)
-returnObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype,V);
-returnfalse;
-}
-
 converters.Uint8Array=(V,opts=kEmptyObject)=>{
 if(!ArrayBufferIsView(V)||
 TypedArrayPrototypeGetSymbolToStringTag(V)!=='Uint8Array'){

test/parallel/test-crypto-subtle-cross-realm.js

@@ -1,21 +1,18 @@
 'use strict';
-// Flags: --expose-internals
 constcommon=require('../common');
 if(!common.hasCrypto)
 common.skip('missing crypto');
 
 constassert=require('assert');
 const{ subtle }=globalThis.crypto;
 constvm=require('vm');
-const{ isArrayBuffer }=require('internal/util/types');
 
 // Test with same-realm ArrayBuffer
 {
 constsamerealmData=newUint8Array([1,2,3,4]).buffer;
 
 subtle.digest('SHA-256',samerealmData)
 .then(common.mustCall((result)=>{
-assert(isArrayBuffer(result));
 assert.strictEqual(result.byteLength,32);// SHA-256 is 32 bytes
 }));
 }
@@ -35,11 +32,30 @@ const { isArrayBuffer } = require('internal/util/types');
 // This should still work, since we're checking structural type
 subtle.digest('SHA-256',crossrealmBuffer)
 .then(common.mustCall((result)=>{
-assert(isArrayBuffer(result));
 assert.strictEqual(result.byteLength,32);// SHA-256 is 32 bytes
 }));
 }
 
+// Cross-realm SharedArrayBuffer should be handled like any SharedArrayBuffer
+{
+constcontext=vm.createContext({});
+constcrossrealmSAB=vm.runInContext('new SharedArrayBuffer(4)',context);
+assert.notStrictEqual(
+Object.getPrototypeOf(crossrealmSAB),
+SharedArrayBuffer.prototype
+);
+Promise.allSettled([
+subtle.digest('SHA-256',newUint8Array(newSharedArrayBuffer(4))),
+subtle.digest('SHA-256',newUint8Array(crossrealmSAB)),
+]).then(common.mustCall((r)=>{
+assert.partialDeepStrictEqual(r,[
+{status: 'rejected'},
+{status: 'rejected'},
+]);
+assert.strictEqual(r[1].reason.message,r[0].reason.message);
+}));
+}
+
 // Test with both TypedArray buffer methods
 {
 constcontext=vm.createContext({});
@@ -48,14 +64,12 @@ const { isArrayBuffer } = require('internal/util/types');
 // Test the .buffer property
 subtle.digest('SHA-256',crossrealmUint8Array.buffer)
 .then(common.mustCall((result)=>{
-assert(isArrayBuffer(result));
 assert.strictEqual(result.byteLength,32);
 }));
 
 // Test passing the TypedArray directly (should work both before and after the fix)
 subtle.digest('SHA-256',crossrealmUint8Array)
 .then(common.mustCall((result)=>{
-assert(isArrayBuffer(result));
 assert.strictEqual(result.byteLength,32);
 }));
 }
@@ -76,34 +90,32 @@ const { isArrayBuffer } = require('internal/util/types');
 name: 'AES-GCM',
 length: 256
 },true,['encrypt','decrypt'])
-.then(common.mustCall((key)=>{
+.then(async(key)=>{
 // Create an initialization vector
 constiv=crypto.getRandomValues(newUint8Array(12));
 
 // Encrypt using the cross-realm ArrayBuffer
-returnsubtle.encrypt(
+constciphertext=awaitsubtle.encrypt(
 {name: 'AES-GCM', iv },
 key,
 crossRealmBuffer
-).then((ciphertext)=>{
+);
 // Decrypt
-returnsubtle.decrypt(
-{name: 'AES-GCM', iv },
-key,
-ciphertext
-);
-}).then(common.mustCall((plaintext)=>{
+constplaintext=awaitsubtle.decrypt(
+{name: 'AES-GCM', iv },
+key,
+ciphertext
+);
 // Verify the decrypted content matches original
-constdecryptedView=newUint8Array(plaintext);
-for(leti=0;i<dataView.length;i++){
-assert.strictEqual(
-decryptedView[i],
-dataView[i],
-`Byte at position ${i} doesn't match`
-);
-}
-}));
-}));
+constdecryptedView=newUint8Array(plaintext);
+for(leti=0;i<dataView.length;i++){
+assert.strictEqual(
+decryptedView[i],
+dataView[i],
+`Byte at position ${i} doesn't match`
+);
+}
+}).then(common.mustCall());
 }
 
 // Test with AES-GCM using TypedArray view of cross-realm ArrayBuffer
@@ -122,32 +134,31 @@ const { isArrayBuffer } = require('internal/util/types');
 name: 'AES-GCM',
 length: 256
 },true,['encrypt','decrypt'])
-.then(common.mustCall((key)=>{
+.then(async(key)=>{
 // Create an initialization vector
 constiv=crypto.getRandomValues(newUint8Array(12));
 
 // Encrypt using the TypedArray view of cross-realm ArrayBuffer
-returnsubtle.encrypt(
+constciphertext=awaitsubtle.encrypt(
 {name: 'AES-GCM', iv },
 key,
 dataView
-).then((ciphertext)=>{
+);
 // Decrypt
-returnsubtle.decrypt(
-{name: 'AES-GCM', iv },
-key,
-ciphertext
+constplaintext=awaitsubtle.decrypt(
+{name: 'AES-GCM', iv },
+key,
+ciphertext
+);
+
+// Verify the decrypted content matches original
+constdecryptedView=newUint8Array(plaintext);
+for(leti=0;i<dataView.length;i++){
+assert.strictEqual(
+decryptedView[i],
+dataView[i],
+`Byte at position ${i} doesn't match`
 );
-}).then(common.mustCall((plaintext)=>{
-// Verify the decrypted content matches original
-constdecryptedView=newUint8Array(plaintext);
-for(leti=0;i<dataView.length;i++){
-assert.strictEqual(
-decryptedView[i],
-dataView[i],
-`Byte at position ${i} doesn't match`
-);
-}
-}));
-}));
+}
+}).then(common.mustCall());
 }