lib,crypto: add optional cause to DOMException

Author: panva

lib/internal/crypto/aes.js

@@ -241,11 +241,10 @@ async function aesGenerateKey(algorithm, extractable, keyUsages) {
   }
 
   const key = await generateKey('aes', { length }).catch((err) => {
-    // TODO(@panva): add err as cause to DOMException
     throw lazyDOMException(
-      'The operation failed for an operation-specific reason' +
-      `[${err.message}]`,
-      'OperationError');
+      'The operation failed for an operation-specific reason',
+      'OperationError',
+      err);
   });
 
   return new InternalCryptoKey(

lib/internal/crypto/cfrg.js

@@ -150,10 +150,10 @@ async function cfrgGenerateKey(algorithm, extractable, keyUsages) {
   }
 
   const keyPair = await generateKeyPair(genKeyType).catch((err) => {
-    // TODO(@panva): add err as cause to DOMException
     throw lazyDOMException(
       'The operation failed for an operation-specific reason',
-      'OperationError');
+      'OperationError',
+      err);
   });
 
   let publicUsages;

lib/internal/crypto/ec.js

@@ -112,10 +112,10 @@ async function ecGenerateKey(algorithm, extractable, keyUsages) {
   }
 
   const keypair = await generateKeyPair('ec', { namedCurve }).catch((err) => {
-    // TODO(@panva): add err as cause to DOMException
     throw lazyDOMException(
       'The operation failed for an operation-specific reason',
-      'OperationError');
+      'OperationError',
+      err);
   });
 
   let publicUsages;

lib/internal/crypto/mac.js

@@ -66,10 +66,10 @@ async function hmacGenerateKey(algorithm, extractable, keyUsages) {
   }
 
   const key = await generateKey('hmac', { length }).catch((err) => {
-    // TODO(@panva): add err as cause to DOMException
     throw lazyDOMException(
       'The operation failed for an operation-specific reason',
-      'OperationError');
+      'OperationError',
+      err);
   });
 
   return new InternalCryptoKey(

lib/internal/crypto/rsa.js

@@ -178,10 +178,10 @@ async function rsaKeyGenerate(
     modulusLength,
     publicExponent: publicExponentConverted,
   }).catch((err) => {
-    // TODO(@panva): add err as cause to DOMException
     throw lazyDOMException(
       'The operation failed for an operation-specific reason',
-      'OperationError');
+      'OperationError',
+      err);
   });
 
   const keyAlgorithm = {

lib/internal/crypto/util.js

@@ -279,10 +279,10 @@ const validateByteSource = hideStackFrames((val, name) => {
 
 function onDone(resolve, reject, err, result) {
   if (err) {
-    // TODO(@panva): add err as cause to DOMException
     return reject(lazyDOMException(
       'The operation failed for an operation-specific reason',
-      'OperationError'));
+      'OperationError',
+      err));
   }
   resolve(result);
 }

lib/internal/per_context/domexception.js

@@ -49,14 +49,23 @@ const disusedNamesSet = new SafeSet()
   .add('ValidationError');
 
 class DOMException {
-  constructor(message = '', name = 'Error') {
+  constructor(message = '', name = 'Error', cause = undefined) {
     ErrorCaptureStackTrace(this);
     internalsMap.set(this, {
       message: `${message}`,
-      name: `${name}`
+      name: `${name}`,
+      cause
     });
   }
 
+  get cause() {
+    const internals = internalsMap.get(this);
+    if (internals === undefined) {
+      throwInvalidThisError(TypeError, 'DOMException');
+    }
+    return internals.cause;
+  }
+
   get name() {
     const internals = internalsMap.get(this);
     if (internals === undefined) {
@@ -93,6 +102,7 @@ ObjectDefineProperties(DOMException.prototype, {
   [SymbolToStringTag]: { __proto__: null, configurable: true, value: 'DOMException' },
   name: { __proto__: null, enumerable: true, configurable: true },
   message: { __proto__: null, enumerable: true, configurable: true },
+  cause: { __proto__: null, enumerable: true, configurable: true },
   code: { __proto__: null, enumerable: true, configurable: true }
 });
 

lib/internal/util.js

@@ -498,9 +498,9 @@ const lazyDOMExceptionClass = () => {
   return _DOMException;
 };
 
-const lazyDOMException = hideStackFrames((message, name) => {
+const lazyDOMException = hideStackFrames((message, name, cause) => {
   _DOMException ??= internalBinding('messaging').DOMException;
-  return new _DOMException(message, name);
+  return new _DOMException(message, name, cause);
 });
 
 const kEnumerableProperty = ObjectCreate(null);

test/parallel/test-webcrypto-encrypt-decrypt-aes.js

@@ -118,8 +118,11 @@ async function testDecrypt({ keyBuffer, algorithm, result }) {
     });
 
     decryptionFailing.forEach((vector) => {
-      variations.push(assert.rejects(testDecrypt(vector), {
-        name: 'OperationError'
+      variations.push(assert.rejects(testDecrypt(vector), (err) => {
+        assert.strictEqual(err.name, 'OperationError');
+        assert.ok(err.cause instanceof Error);
+        assert.match(err.cause?.message, /bad decrypt/);
+        return true;
       }));
     });
 
@@ -157,8 +160,11 @@ async function testDecrypt({ keyBuffer, algorithm, result }) {
     });
 
     decryptionFailing.forEach((vector) => {
-      variations.push(assert.rejects(testDecrypt(vector), {
-        name: 'OperationError'
+      variations.push(assert.rejects(testDecrypt(vector), (err) => {
+        assert.strictEqual(err.name, 'OperationError');
+        assert.ok(err.cause instanceof Error);
+        assert.match(err.cause?.message, /foo/);
+        return true;
       }));
     });
 
@@ -194,8 +200,11 @@ async function testDecrypt({ keyBuffer, algorithm, result }) {
     });
 
     decryptionFailing.forEach((vector) => {
-      variations.push(assert.rejects(testDecrypt(vector), {
-        name: 'OperationError'
+      variations.push(assert.rejects(testDecrypt(vector), (err) => {
+        assert.strictEqual(err.name, 'OperationError');
+        assert.ok(err.cause instanceof Error);
+        assert.match(err.cause?.message, /foo/);
+        return true;
       }));
     });
 

test/parallel/test-webcrypto-encrypt-decrypt-rsa.js

@@ -126,8 +126,11 @@ async function testEncryptionLongPlaintext({ algorithm,
   newplaintext[plaintext.byteLength] = 32;
 
   return assert.rejects(
-    subtle.encrypt(algorithm, publicKey, newplaintext), {
-      name: 'OperationError'
+    subtle.encrypt(algorithm, publicKey, newplaintext), (err) => {
+      assert.strictEqual(err.name, 'OperationError');
+      assert.ok(err.cause instanceof Error);
+      assert.match(err.cause?.message, /data too large for key size/);
+      return true;
     });
 }