#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,
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,
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),
};
};
+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)
goto fail;
}
- return qjs_promise_result(cx, ret);
+ return ret;
fail:
- return qjs_promise_result(cx, JS_EXCEPTION);
+ return JS_EXCEPTION;
}
}
}
- 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;
}
}
}
- return qjs_promise_result(cx, ret);
+ return ret;
fail:
js_free(cx, k);
- return qjs_promise_result(cx, JS_EXCEPTION);
+ return JS_EXCEPTION;
}
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);
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);
}
return ret;
+
+fail:
+
+ return JS_EXCEPTION;
}
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;
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);
}
goto fail;
}
- return qjs_promise_result(cx, obj);
+ return obj;
fail:
JS_FreeValue(cx, keypub);
JS_FreeValue(cx, obj);
- return qjs_promise_result(cx, JS_EXCEPTION);
+ return JS_EXCEPTION;
}
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;
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);
}
ret = JS_NewBool(cx, rc != 0);
}
- return qjs_promise_result(cx, ret);
+ return ret;
fail:
js_free(cx, dst);
}
- return qjs_promise_result(cx, JS_EXCEPTION);
+ return JS_EXCEPTION;
}
goto fail;
}
- return qjs_promise_result(cx, ret);
+ return ret;
fail:
- return qjs_promise_result(cx, JS_EXCEPTION);
+ return JS_EXCEPTION;
}
goto fail;
}
- return qjs_promise_result(cx, key_value);
+ return key_value;
fail:
- return qjs_promise_result(cx, JS_EXCEPTION);
+ return JS_EXCEPTION;
}
--- /dev/null
+/*---
+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);