]> git.kaiwu.me - njs.git/commitdiff
WebCrypto: always return a Promise from QuickJS SubtleCrypto
authorDmitry Volyntsev <xeioex@nginx.com>
Tue, 17 Nov 2026 21:23:22 +0000 (13:23 -0800)
committerDmitry Volyntsev <xeioexception@gmail.com>
Tue, 17 Nov 2026 22:09:33 +0000 (14:09 -0800)
Previously, QuickJS digest() returned an ArrayBuffer directly, while
other SubtleCrypto methods returned Promises but threw many early
validation errors synchronously.  await hid the differences, but
then() chains and Promise.all() did not receive rejected Promises.

Dispatch all methods through one wrapper that converts the result or
pending exception with qjs_promise_result(), as required by Web
Cryptography API section 14.3.  The implementations return a value
or JS_EXCEPTION; no early return can bypass the wrapper.  Check the
direct return value in the digest and method-wide tests.

The issue was introduced in 75ca26f8 (0.8.10).

external/qjs_webcrypto_module.c
test/webcrypto/digest.t.mjs
test/webcrypto/promise.t.mjs [new file with mode: 0644]

index 81c3017090184842f9530e869ca3bacc88972987..41c58d58b8865b6fe318cdd9aef66fe26b1fc3bc 100644 (file)
@@ -9,6 +9,22 @@
 #include <njs_sprintf.h>
 #include "njs_openssl.h"
 
+typedef enum {
+    QJS_SUBTLE_DECRYPT,
+    QJS_SUBTLE_DERIVE_BITS,
+    QJS_SUBTLE_DERIVE_KEY,
+    QJS_SUBTLE_DIGEST,
+    QJS_SUBTLE_ENCRYPT,
+    QJS_SUBTLE_EXPORT_KEY,
+    QJS_SUBTLE_GENERATE_KEY,
+    QJS_SUBTLE_IMPORT_KEY,
+    QJS_SUBTLE_SIGN,
+    QJS_SUBTLE_UNWRAP_KEY,
+    QJS_SUBTLE_VERIFY,
+    QJS_SUBTLE_WRAP_KEY,
+} qjs_webcrypto_subtle_method_t;
+
+
 typedef enum {
     QJS_KEY_FORMAT_RAW          = 1 << 1,
     QJS_KEY_FORMAT_PKCS8        = 1 << 2,
@@ -109,6 +125,8 @@ typedef int (*EVP_PKEY_cipher_init_t)(EVP_PKEY_CTX *ctx);
 typedef int (*EVP_PKEY_cipher_t)(EVP_PKEY_CTX *ctx, unsigned char *out,
     size_t *outlen, const unsigned char *in, size_t inlen);
 
+static JSValue qjs_webcrypto_subtle_call(JSContext *cx, JSValueConst this_val,
+    int argc, JSValueConst *argv, int method);
 static JSValue qjs_webcrypto_cipher(JSContext *cx, JSValueConst this_val,
     int argc, JSValueConst *argv, int encrypt);
 static JSValue qjs_cipher_pkey(JSContext *cx, njs_str_t *data,
@@ -509,18 +527,30 @@ static njs_str_t qjs_webcrypto_alg_aes_name[4][3 + 1] = {
 
 
 static const JSCFunctionListEntry qjs_webcrypto_subtle[] = {
-    JS_CFUNC_DEF("importKey", 5, qjs_webcrypto_import_key),
-    JS_CFUNC_MAGIC_DEF("decrypt", 4, qjs_webcrypto_cipher, 0),
-    JS_CFUNC_MAGIC_DEF("deriveBits", 4, qjs_webcrypto_derive, 0),
-    JS_CFUNC_MAGIC_DEF("deriveKey", 5, qjs_webcrypto_derive, 1),
-    JS_CFUNC_DEF("digest", 3, qjs_webcrypto_digest),
-    JS_CFUNC_MAGIC_DEF("encrypt", 4, qjs_webcrypto_cipher, 1),
-    JS_CFUNC_DEF("exportKey", 3, qjs_webcrypto_export_key),
-    JS_CFUNC_DEF("generateKey", 3, qjs_webcrypto_generate_key),
-    JS_CFUNC_MAGIC_DEF("sign", 4, qjs_webcrypto_sign, 0),
-    JS_CFUNC_DEF("unwrapKey", 7, qjs_webcrypto_unwrap_key),
-    JS_CFUNC_MAGIC_DEF("verify", 4, qjs_webcrypto_sign, 1),
-    JS_CFUNC_DEF("wrapKey", 4, qjs_webcrypto_wrap_key),
+    JS_CFUNC_MAGIC_DEF("importKey", 5, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_IMPORT_KEY),
+    JS_CFUNC_MAGIC_DEF("decrypt", 4, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_DECRYPT),
+    JS_CFUNC_MAGIC_DEF("deriveBits", 4, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_DERIVE_BITS),
+    JS_CFUNC_MAGIC_DEF("deriveKey", 5, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_DERIVE_KEY),
+    JS_CFUNC_MAGIC_DEF("digest", 3, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_DIGEST),
+    JS_CFUNC_MAGIC_DEF("encrypt", 4, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_ENCRYPT),
+    JS_CFUNC_MAGIC_DEF("exportKey", 3, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_EXPORT_KEY),
+    JS_CFUNC_MAGIC_DEF("generateKey", 3, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_GENERATE_KEY),
+    JS_CFUNC_MAGIC_DEF("sign", 4, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_SIGN),
+    JS_CFUNC_MAGIC_DEF("unwrapKey", 7, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_UNWRAP_KEY),
+    JS_CFUNC_MAGIC_DEF("verify", 4, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_VERIFY),
+    JS_CFUNC_MAGIC_DEF("wrapKey", 4, qjs_webcrypto_subtle_call,
+                       QJS_SUBTLE_WRAP_KEY),
 };
 
 
@@ -556,6 +586,67 @@ qjs_module_t  qjs_webcrypto_module = {
 };
 
 
+static JSValue
+qjs_webcrypto_subtle_call(JSContext *cx, JSValueConst this_val, int argc,
+    JSValueConst *argv, int method)
+{
+    JSValue  ret;
+
+    switch (method) {
+    case QJS_SUBTLE_DECRYPT:
+        ret = qjs_webcrypto_cipher(cx, this_val, argc, argv, 0);
+        break;
+
+    case QJS_SUBTLE_DERIVE_BITS:
+        ret = qjs_webcrypto_derive(cx, this_val, argc, argv, 0);
+        break;
+
+    case QJS_SUBTLE_DERIVE_KEY:
+        ret = qjs_webcrypto_derive(cx, this_val, argc, argv, 1);
+        break;
+
+    case QJS_SUBTLE_DIGEST:
+        ret = qjs_webcrypto_digest(cx, this_val, argc, argv);
+        break;
+
+    case QJS_SUBTLE_ENCRYPT:
+        ret = qjs_webcrypto_cipher(cx, this_val, argc, argv, 1);
+        break;
+
+    case QJS_SUBTLE_EXPORT_KEY:
+        ret = qjs_webcrypto_export_key(cx, this_val, argc, argv);
+        break;
+
+    case QJS_SUBTLE_GENERATE_KEY:
+        ret = qjs_webcrypto_generate_key(cx, this_val, argc, argv);
+        break;
+
+    case QJS_SUBTLE_IMPORT_KEY:
+        ret = qjs_webcrypto_import_key(cx, this_val, argc, argv);
+        break;
+
+    case QJS_SUBTLE_SIGN:
+        ret = qjs_webcrypto_sign(cx, this_val, argc, argv, 0);
+        break;
+
+    case QJS_SUBTLE_UNWRAP_KEY:
+        ret = qjs_webcrypto_unwrap_key(cx, this_val, argc, argv);
+        break;
+
+    case QJS_SUBTLE_VERIFY:
+        ret = qjs_webcrypto_sign(cx, this_val, argc, argv, 1);
+        break;
+
+    case QJS_SUBTLE_WRAP_KEY:
+    default:
+        ret = qjs_webcrypto_wrap_key(cx, this_val, argc, argv);
+        break;
+    }
+
+    return qjs_promise_result(cx, ret);
+}
+
+
 static JSValue
 qjs_webcrypto_cipher(JSContext *cx, JSValueConst this_val,
     int argc, JSValueConst *argv, int encrypt)
@@ -608,11 +699,11 @@ qjs_webcrypto_cipher(JSContext *cx, JSValueConst this_val,
         goto fail;
     }
 
-    return qjs_promise_result(cx, ret);
+    return ret;
 
 fail:
 
-    return qjs_promise_result(cx, JS_EXCEPTION);
+    return JS_EXCEPTION;
 }
 
 
@@ -2155,13 +2246,13 @@ qjs_derive_ecdh(JSContext *cx, JSValueConst *argv, int argc, int derive_key,
         }
     }
 
-    return qjs_promise_result(cx, result);
+    return result;
 
 fail:
     JS_FreeValue(cx, public_value);
     JS_FreeValue(cx, result);
 
-    return qjs_promise_result(cx, JS_EXCEPTION);
+    return JS_EXCEPTION;
 }
 
 
@@ -2471,7 +2562,7 @@ free:
         }
     }
 
-    return qjs_promise_result(cx, ret);
+    return ret;
 
 fail:
 
@@ -2479,7 +2570,7 @@ fail:
 
     js_free(cx, k);
 
-    return qjs_promise_result(cx, JS_EXCEPTION);
+    return JS_EXCEPTION;
 }
 
 
@@ -2496,12 +2587,12 @@ qjs_webcrypto_digest(JSContext *cx, JSValueConst this_val, int argc,
 
     ret = qjs_algorithm_hash(cx, argv[0], &hash);
     if (JS_IsException(ret)) {
-        return JS_EXCEPTION;
+        goto fail;
     }
 
     ret = qjs_typed_array_data(cx, argv[1], &data);
     if (JS_IsException(ret)) {
-        return JS_EXCEPTION;
+        goto fail;
     }
 
     md = qjs_algorithm_hash_digest(hash);
@@ -2510,13 +2601,13 @@ qjs_webcrypto_digest(JSContext *cx, JSValueConst this_val, int argc,
     dst = js_malloc(cx, olen);
     if (dst == NULL) {
         JS_ThrowOutOfMemory(cx);
-        return JS_EXCEPTION;
+        goto fail;
     }
 
     if (EVP_Digest(data.start, data.length, dst, &olen, md, NULL) <= 0) {
         js_free(cx, dst);
         qjs_webcrypto_error(cx, "EVP_Digest() failed");
-        return JS_EXCEPTION;
+        goto fail;
     }
 
     ret = qjs_array_buffer_adopt(cx, dst, olen);
@@ -2525,6 +2616,10 @@ qjs_webcrypto_digest(JSContext *cx, JSValueConst this_val, int argc,
     }
 
     return ret;
+
+fail:
+
+    return JS_EXCEPTION;
 }
 
 
@@ -2701,7 +2796,6 @@ static JSValue
 qjs_webcrypto_export_key(JSContext *cx, JSValueConst this_val, int argc,
     JSValueConst *argv)
 {
-    JSValue                     ret;
     qjs_webcrypto_key_t         *key;
     qjs_webcrypto_key_format_t  fmt;
 
@@ -2728,12 +2822,7 @@ qjs_webcrypto_export_key(JSContext *cx, JSValueConst this_val, int argc,
         return JS_EXCEPTION;
     }
 
-    ret = qjs_webcrypto_export_key_raw(cx, key, fmt);
-    if (JS_IsException(ret)) {
-        return qjs_promise_result(cx, JS_EXCEPTION);
-    }
-
-    return qjs_promise_result(cx, ret);
+    return qjs_webcrypto_export_key_raw(cx, key, fmt);
 }
 
 
@@ -3124,7 +3213,7 @@ qjs_webcrypto_generate_key(JSContext *cx, JSValueConst this_val,
         goto fail;
     }
 
-    return qjs_promise_result(cx, obj);
+    return obj;
 
 fail:
 
@@ -3136,7 +3225,7 @@ fail:
     JS_FreeValue(cx, keypub);
     JS_FreeValue(cx, obj);
 
-    return qjs_promise_result(cx, JS_EXCEPTION);
+    return JS_EXCEPTION;
 }
 
 
@@ -4404,7 +4493,7 @@ static JSValue
 qjs_webcrypto_import_key(JSContext *cx, JSValueConst this_val, int argc,
     JSValueConst *argv)
 {
-    JSValue                     ret, key;
+    JSValue                     ret;
     unsigned                    usage;
     qjs_webcrypto_algorithm_t   *alg;
     qjs_webcrypto_key_format_t  fmt;
@@ -4424,13 +4513,8 @@ qjs_webcrypto_import_key(JSContext *cx, JSValueConst this_val, int argc,
         return JS_EXCEPTION;
     }
 
-    key = qjs_webcrypto_import_key_internal(cx, fmt, argv[1], alg, argv[2],
-                                            JS_ToBool(cx, argv[3]), usage);
-    if (JS_IsException(key)) {
-        return qjs_promise_result(cx, JS_EXCEPTION);
-    }
-
-    return qjs_promise_result(cx, key);
+    return qjs_webcrypto_import_key_internal(cx, fmt, argv[1], alg, argv[2],
+                                             JS_ToBool(cx, argv[3]), usage);
 }
 
 
@@ -4964,7 +5048,7 @@ qjs_webcrypto_sign(JSContext *cx, JSValueConst this_val, int argc,
         ret = JS_NewBool(cx, rc != 0);
     }
 
-    return qjs_promise_result(cx, ret);
+    return ret;
 
 fail:
 
@@ -4980,7 +5064,7 @@ fail:
         js_free(cx, dst);
     }
 
-    return qjs_promise_result(cx, JS_EXCEPTION);
+    return JS_EXCEPTION;
 }
 
 
@@ -5082,11 +5166,11 @@ qjs_webcrypto_wrap_key(JSContext *cx, JSValueConst this_val, int argc,
         goto fail;
     }
 
-    return qjs_promise_result(cx, ret);
+    return ret;
 
 fail:
 
-    return qjs_promise_result(cx, JS_EXCEPTION);
+    return JS_EXCEPTION;
 }
 
 
@@ -5197,11 +5281,11 @@ qjs_webcrypto_unwrap_key(JSContext *cx, JSValueConst this_val, int argc,
         goto fail;
     }
 
-    return qjs_promise_result(cx, key_value);
+    return key_value;
 
 fail:
 
-    return qjs_promise_result(cx, JS_EXCEPTION);
+    return JS_EXCEPTION;
 }
 
 
index f07f0346dc7bbea539d6931951dfd9b981633544..513e9a07c04c299d0baaa9776073fb9f24cf04de 100644 (file)
@@ -14,6 +14,32 @@ async function test(params) {
     return 'SUCCESS';
 }
 
+function test_promise(params) {
+    let promise = crypto.subtle.digest(params.name, params.data);
+
+    if (!(promise instanceof Promise)) {
+        throw Error('digest did not return a Promise');
+    }
+
+    return promise.then(digest => {
+        if (params.rejected) {
+            throw Error('digest unexpectedly resolved');
+        }
+
+        if (!(digest instanceof ArrayBuffer)) {
+            throw Error('digest did not resolve with an ArrayBuffer');
+        }
+
+        return 'SUCCESS';
+    }, error => {
+        if (!params.rejected) {
+            throw error;
+        }
+
+        return 'SUCCESS';
+    });
+}
+
 function p(args) {
     let params = Object.assign({}, args);
     params.data = Buffer.from(params.data, "hex");
@@ -55,5 +81,17 @@ let digest_tsuite = {
           expected: "cdea58919606ea9ae078f7595b192b84446f2189" },
 ]};
 
-run([digest_tsuite])
+let digest_promise_tsuite = {
+    name: "SHA digest Promise",
+    skip: () => (!has_buffer() || !has_webcrypto()),
+    T: test_promise,
+    tests: [
+        { name: 'SHA-256', data: new Uint8Array() },
+        { name: 'XXX', data: new Uint8Array(), rejected: true },
+        { name: Symbol.toStringTag, data: new Uint8Array(), rejected: true },
+        { name: 'SHA-256', data: Symbol.toStringTag, rejected: true },
+    ],
+};
+
+run([digest_tsuite, digest_promise_tsuite])
 .then($DONE, $DONE);
diff --git a/test/webcrypto/promise.t.mjs b/test/webcrypto/promise.t.mjs
new file mode 100644 (file)
index 0000000..d00ae38
--- /dev/null
@@ -0,0 +1,80 @@
+/*---
+includes: [compatWebcrypto.js, runTsuite.js]
+flags: [async]
+---*/
+
+async function test(params) {
+    let promise;
+    let key = await crypto.subtle.importKey('raw', new Uint8Array(16),
+                                            'AES-GCM', false,
+                                            ['encrypt', 'decrypt']);
+
+    try {
+        promise = params.call(key);
+
+    } catch (e) {
+        throw Error(`${params.name} threw synchronously: ${e}`);
+    }
+
+    if (!(promise instanceof Promise)) {
+        throw Error(`${params.name} did not return a Promise`);
+    }
+
+    return promise.then(() => {
+        throw Error(`${params.name} unexpectedly resolved`);
+    }, () => 'SUCCESS');
+}
+
+let promise_tsuite = {
+    name: 'SubtleCrypto rejects invalid arguments',
+    skip: () => !has_webcrypto(),
+    T: test,
+    prepare_args: (args) => args,
+    tests: [
+        { name: 'decrypt',
+          call: () => crypto.subtle.decrypt('AES-GCM', {},
+                                            new Uint8Array(16)) },
+        { name: 'decrypt data',
+          call: (key) => crypto.subtle.decrypt({name: 'AES-GCM',
+                                                iv: new Uint8Array(12)},
+                                               key, Symbol.toStringTag) },
+        { name: 'deriveBits',
+          call: () => crypto.subtle.deriveBits('HKDF', {}, 128) },
+        { name: 'deriveKey',
+          call: () => crypto.subtle.deriveKey('HKDF', {},
+                                              {name: 'AES-CBC', length: 128},
+                                              false, ['encrypt']) },
+        { name: 'digest',
+          call: () => crypto.subtle.digest('XXX', new Uint8Array(16)) },
+        { name: 'encrypt',
+          call: () => crypto.subtle.encrypt('AES-GCM', {},
+                                            new Uint8Array(16)) },
+        { name: 'encrypt data',
+          call: (key) => crypto.subtle.encrypt({name: 'AES-GCM',
+                                                iv: new Uint8Array(12)},
+                                               key, Symbol.toStringTag) },
+        { name: 'exportKey',
+          call: () => crypto.subtle.exportKey('XXX', {}) },
+        { name: 'generateKey',
+          call: () => crypto.subtle.generateKey('XXX', false,
+                                                ['encrypt']) },
+        { name: 'importKey',
+          call: () => crypto.subtle.importKey('XXX', new Uint8Array(16),
+                                              'AES-GCM', false,
+                                              ['encrypt']) },
+        { name: 'sign',
+          call: () => crypto.subtle.sign('HMAC', {}, new Uint8Array(16)) },
+        { name: 'unwrapKey',
+          call: () => crypto.subtle.unwrapKey('raw', Symbol.toStringTag,
+                                              {}, 'AES-KW', 'AES-CBC',
+                                              false, ['encrypt']) },
+        { name: 'verify',
+          call: () => crypto.subtle.verify('HMAC', {}, new Uint8Array(16),
+                                           new Uint8Array(16)) },
+        { name: 'wrapKey',
+          call: () => crypto.subtle.wrapKey('raw', {}, {}, 'AES-KW') },
+    ],
+};
+
+run([promise_tsuite])
+.then($DONE, $DONE);