static njs_int_t njs_cipher_aes_kw(njs_vm_t *vm, njs_str_t *data,
njs_webcrypto_key_t *key, njs_bool_t encrypt, njs_value_t *retval);
#endif
+static njs_int_t njs_derive_key_length(njs_vm_t *vm,
+ njs_webcrypto_algorithm_t *dalg, int64_t length);
static njs_int_t njs_ext_derive(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t derive_key, njs_value_t *retval);
static njs_int_t njs_ext_digest(njs_vm_t *vm, njs_value_t *args,
#endif
+static njs_int_t
+njs_derive_key_length(njs_vm_t *vm, njs_webcrypto_algorithm_t *dalg,
+ int64_t length)
+{
+ switch (dalg->type) {
+ case NJS_ALGORITHM_AES_GCM:
+ case NJS_ALGORITHM_AES_CTR:
+ case NJS_ALGORITHM_AES_CBC:
+ case NJS_ALGORITHM_AES_KW:
+ if (length != 128 && length != 192 && length != 256) {
+ njs_vm_type_error(vm, "deriveKey \"%V\" length must be "
+ "128, 192, or 256",
+ njs_algorithm_string(dalg));
+ return NJS_ERROR;
+ }
+
+ break;
+
+ case NJS_ALGORITHM_HMAC:
+ if (length < 8) {
+ njs_vm_type_error(vm, "deriveKey \"HMAC\" length must be "
+ "at least 8");
+ return NJS_ERROR;
+ }
+
+ break;
+
+ default:
+ break;
+ }
+
+ return NJS_OK;
+}
+
+
static njs_int_t
njs_ext_derive_ecdh(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t derive_key, njs_webcrypto_key_t *key, njs_value_t *retval)
goto fail;
}
+ if (derive_key) {
+ ret = njs_derive_key_length(vm, dalg, length);
+ if (njs_slow_path(ret != NJS_OK)) {
+ goto fail;
+ }
+ }
+
dkey = NULL;
length /= 8;
goto fail;
}
- dkey = NULL;
- length /= 8;
-
if (derive_key) {
switch (dalg->type) {
case NJS_ALGORITHM_AES_GCM:
case NJS_ALGORITHM_AES_CTR:
case NJS_ALGORITHM_AES_CBC:
case NJS_ALGORITHM_AES_KW:
-
- if (length != 16 && length != 24 && length != 32) {
- njs_vm_type_error(vm, "deriveKey \"%V\" length must be "
- "128, 192, or 256",
- njs_algorithm_string(dalg));
- goto fail;
- }
-
- break;
-
case NJS_ALGORITHM_HMAC:
break;
default:
- njs_vm_internal_error(vm, "not implemented deriveKey: \"%V\"",
- njs_algorithm_string(dalg));
+ njs_vm_type_error(vm, "not implemented deriveKey: \"%V\"",
+ njs_algorithm_string(dalg));
goto fail;
}
+ ret = njs_derive_key_length(vm, dalg, length);
+ if (njs_slow_path(ret != NJS_OK)) {
+ goto fail;
+ }
+ }
+
+ dkey = NULL;
+ length /= 8;
+
+ if (derive_key) {
ret = njs_key_usage(vm, njs_arg(args, nargs, 5), &usage);
if (njs_slow_path(ret != NJS_OK)) {
goto fail;
static JSValue qjs_cipher_aes_kw(JSContext *cx, njs_str_t *data,
qjs_webcrypto_key_t *key, int encrypt);
#endif
+static int qjs_derive_key_length(JSContext *cx,
+ qjs_webcrypto_algorithm_t *dalg, int64_t length);
static JSValue qjs_derive_ecdh(JSContext *cx, JSValueConst *argv, int argc,
int derive_key, qjs_webcrypto_key_t *key);
static JSValue qjs_webcrypto_derive(JSContext *cx, JSValueConst this_val,
}
+static int
+qjs_derive_key_length(JSContext *cx, qjs_webcrypto_algorithm_t *dalg,
+ int64_t length)
+{
+ switch (dalg->type) {
+ case QJS_ALGORITHM_AES_GCM:
+ case QJS_ALGORITHM_AES_CTR:
+ case QJS_ALGORITHM_AES_CBC:
+ case QJS_ALGORITHM_AES_KW:
+ if (length != 128 && length != 192 && length != 256) {
+ JS_ThrowTypeError(cx, "deriveKey \"%s\" length must be "
+ "128, 192, or 256",
+ qjs_algorithm_string(dalg));
+ return -1;
+ }
+
+ break;
+
+ case QJS_ALGORITHM_HMAC:
+ if (length < 8) {
+ JS_ThrowTypeError(cx, "deriveKey \"HMAC\" length must be "
+ "at least 8");
+ return -1;
+ }
+
+ break;
+
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+
static JSValue
qjs_derive_ecdh(JSContext *cx, JSValueConst *argv, int argc, int derive_key,
qjs_webcrypto_key_t *key)
JS_FreeValue(cx, value);
+ if (derive_key && qjs_derive_key_length(cx, dalg, length) < 0) {
+ goto fail;
+ }
+
dkey = NULL;
length /= 8;
JS_FreeValue(cx, ret);
- dkey = NULL;
- length /= 8;
- dkey_value = JS_UNDEFINED;
-
if (derive_key) {
switch (dalg->type) {
case QJS_ALGORITHM_AES_GCM:
case QJS_ALGORITHM_AES_CTR:
case QJS_ALGORITHM_AES_CBC:
case QJS_ALGORITHM_AES_KW:
-
- if (length != 16 && length != 24 && length != 32) {
- JS_ThrowTypeError(cx, "deriveKey \"%s\" length must be "
- "128, 192, or 256",
- qjs_algorithm_string(dalg));
- return JS_EXCEPTION;
- }
-
- break;
-
case QJS_ALGORITHM_HMAC:
break;
return JS_EXCEPTION;
}
+ if (qjs_derive_key_length(cx, dalg, length) < 0) {
+ return JS_EXCEPTION;
+ }
+ }
+
+ dkey = NULL;
+ length /= 8;
+ dkey_value = JS_UNDEFINED;
+
+ if (derive_key) {
ret = qjs_key_usage(cx, argv[4], &usage);
if (JS_IsException(ret)) {
return JS_EXCEPTION;
return "SUCCESS";
}
+/* Error names other engines use for invalid derived key parameters. */
+const invalid = ["TypeError", "OperationError", "NotSupportedError",
+ "DataError", "SyntaxError"];
+
+async function testDerivedKeyLength(params) {
+ let ecdh_pair = await load_key_pair('ec');
+ let peer = await load_key_pair('ec2');
+ let base;
+
+ if (params.base === "ECDH") {
+ base = { algorithm: { name: "ECDH", public: peer.publicKey },
+ key: ecdh_pair.privateKey };
+
+ } else {
+ base = {
+ algorithm: { name: params.base, hash: "SHA-256",
+ salt: new Uint8Array(16), info: new Uint8Array(0),
+ iterations: 1 },
+ key: await crypto.subtle.importKey("raw", new Uint8Array(32),
+ params.base, false,
+ ["deriveKey"]),
+ };
+ }
+
+ let key;
+
+ try {
+ key = await crypto.subtle.deriveKey(base.algorithm, base.key,
+ params.derived, true,
+ params.usage);
+
+ } catch (e) {
+ if (params.error && params.error.indexOf(e.name) !== -1) {
+ return "SUCCESS";
+ }
+
+ throw e;
+ }
+
+ if (params.error) {
+ throw Error(`deriveKey accepted ${JSON.stringify(params.derived)}`);
+ }
+
+ let raw = await crypto.subtle.exportKey("raw", key);
+
+ if (raw.byteLength !== params.bytes) {
+ throw Error(`unexpected key length: ${raw.byteLength}`);
+ }
+
+ return "SUCCESS";
+}
+
+let derived_key_length_tsuite = {
+ name: "deriveKey length",
+ skip: () => (!has_buffer() || !has_webcrypto()),
+ T: testDerivedKeyLength,
+ opts: {
+ usage: ["sign"]
+ },
+ tests: [
+ { base: "ECDH", derived: { name: "AES-GCM", length: 129 },
+ usage: ["encrypt"],
+ error: invalid },
+ { base: "HKDF", derived: { name: "AES-GCM", length: 129 },
+ usage: ["encrypt"],
+ error: invalid },
+ { base: "PBKDF2", derived: { name: "AES-GCM", length: 129 },
+ usage: ["encrypt"],
+ error: invalid },
+ { base: "ECDH",
+ derived: { name: "HMAC", hash: "SHA-256", length: 7 },
+ error: invalid },
+ { base: "HKDF",
+ derived: { name: "HMAC", hash: "SHA-256", length: 0 },
+ error: invalid },
+ { base: "ECDH",
+ derived: { name: "HMAC", hash: "SHA-256", length: 8 },
+ bytes: 1 },
+ { base: "HKDF",
+ derived: { name: "ECDSA", namedCurve: "P-256", length: 256 },
+ error: invalid },
+ ]
+};
+
let ecdh_key_type_tsuite = {
name: "ECDH-DeriveKey type",
skip: () => (!has_buffer() || !has_webcrypto()),
ecdh_bits_tsuite,
ecdh_key_tsuite,
ecdh_key_type_tsuite,
+ derived_key_length_tsuite,
])
.then($DONE, $DONE);