]> git.kaiwu.me - njs.git/commitdiff
WebCrypto: validate the export format when wrapping a key
authorDmitry Volyntsev <xeioex@nginx.com>
Wed, 18 Nov 2026 01:16:59 +0000 (17:16 -0800)
committerDmitry Volyntsev <xeioexception@gmail.com>
Thu, 19 Nov 2026 06:07:22 +0000 (22:07 -0800)
wrapKey() uses the same serializer as exportKey(), but it bypasses
its format check. This can route a key to a serializer that expects
a different native key representation. Check the format in the
shared export path before dispatching to a serializer.

The issue was introduced in f42b2683 (0.9.7).

external/njs_webcrypto_module.c
external/qjs_webcrypto_module.c
test/webcrypto/key_format.t.mjs

index 353931650bc77cdf9a22e7984083361063d5c397..7b9e85a703787f0ee19de510d387a2a293e701f5 100644 (file)
@@ -2796,18 +2796,6 @@ njs_ext_export_key(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
         goto fail;
     }
 
-    if (njs_slow_path(!(fmt & key->alg->fmt))) {
-        njs_vm_type_error(vm, "unsupported key fmt \"%V\" for \"%V\" key",
-                          njs_format_string(fmt),
-                          njs_algorithm_string(key->alg));
-        goto fail;
-    }
-
-    if (njs_slow_path(!key->extractable)) {
-        njs_vm_type_error(vm, "provided key cannot be extracted");
-        goto fail;
-    }
-
     ret = njs_webcrypto_export_key_raw(vm, key, fmt, njs_value_arg(&value));
     if (njs_slow_path(ret != NJS_OK)) {
         goto fail;
@@ -5021,6 +5009,18 @@ njs_webcrypto_export_key_raw(njs_vm_t *vm, njs_webcrypto_key_t *key,
     njs_int_t            ret;
     PKCS8_PRIV_KEY_INFO  *pkcs8;
 
+    if (njs_slow_path(!(fmt & key->alg->fmt))) {
+        njs_vm_type_error(vm, "unsupported key fmt \"%V\" for \"%V\" key",
+                          njs_format_string(fmt),
+                          njs_algorithm_string(key->alg));
+        return NJS_ERROR;
+    }
+
+    if (njs_slow_path(!key->extractable)) {
+        njs_vm_type_error(vm, "provided key cannot be extracted");
+        return NJS_ERROR;
+    }
+
     switch (fmt) {
     case NJS_KEY_FORMAT_JWK:
         switch (key->alg->type) {
index 16f5dd8acc040a3f8a86a1c6488753b3e2c3928b..102197eae7c0a43d47663a47ac0b12511b806ce6 100644 (file)
@@ -2648,6 +2648,18 @@ qjs_webcrypto_export_key_raw(JSContext *cx, qjs_webcrypto_key_t *key,
     JSValue              ret;
     PKCS8_PRIV_KEY_INFO  *pkcs8;
 
+    if (!(fmt & key->alg->fmt)) {
+        JS_ThrowTypeError(cx, "unsupported key fmt \"%s\" for \"%s\" key",
+                          qjs_format_string(fmt),
+                          qjs_algorithm_string(key->alg));
+        return JS_EXCEPTION;
+    }
+
+    if (!key->extractable) {
+        JS_ThrowTypeError(cx, "provided key cannot be extracted");
+        return JS_EXCEPTION;
+    }
+
     switch (fmt) {
     case QJS_KEY_FORMAT_JWK:
         switch (key->alg->type) {
@@ -2826,18 +2838,6 @@ qjs_webcrypto_export_key(JSContext *cx, JSValueConst this_val, int argc,
         return JS_EXCEPTION;
     }
 
-    if (!(fmt & key->alg->fmt)) {
-        JS_ThrowTypeError(cx, "unsupported key fmt \"%s\" for \"%s\" key",
-                          qjs_format_string(fmt),
-                          qjs_algorithm_string(key->alg));
-        return JS_EXCEPTION;
-    }
-
-    if (!key->extractable) {
-        JS_ThrowTypeError(cx, "provided key cannot be extracted");
-        return JS_EXCEPTION;
-    }
-
     return qjs_webcrypto_export_key_raw(cx, key, fmt);
 }
 
index a191f183e305e58433be51d594c351e40df03944..27b631f6ab513d2593aa1b826cacd463b4892535 100644 (file)
@@ -19,7 +19,8 @@ async function test(params) {
             break;
 
         case 'wrapKey':
-            await crypto.subtle.wrapKey('JWK', key, wrapping_key, 'AES-KW');
+            await crypto.subtle.wrapKey(params.format || 'JWK', key,
+                                        wrapping_key, 'AES-KW');
             break;
 
         default:
@@ -33,6 +34,10 @@ async function test(params) {
         }
 
     } catch (e) {
+        if (params.format) {
+            return 'SUCCESS';
+        }
+
         if (!(e instanceof TypeError) || !e.message.includes('JWK')) {
             throw Error(`unexpected ${params.op} error: ${e}`);
         }
@@ -40,17 +45,18 @@ async function test(params) {
         return 'SUCCESS';
     }
 
-    throw Error(`${params.op} accepted unknown key format`);
+    throw Error(`${params.op} accepted invalid key format`);
 }
 
 let key_format_tsuite = {
-    name: 'unknown key format',
+    name: 'invalid key format',
     skip: async () => !await has_webcrypto_algorithm('AES-KW', 128),
     T: test,
     tests: [
         {op: 'exportKey'},
         {op: 'wrapKey'},
         {op: 'unwrapKey'},
+        {op: 'wrapKey', format: 'pkcs8'},
     ],
 };