mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-07-28 11:49:44 +00:00
LibWeb: Implement ECDH.generateKey
This commit is contained in:
devgianlu
Jelle Raaijmakers
parent
d55caff227
commit
009f328308
Notes:
github-actions[bot]
2024-11-21 10:46:20 +00:00
Author: https://github.com/devgianlu 🔰
Commit: 009f328308
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/2402
Reviewed-by: https://github.com/gmta ✅
13 changed files with 1434 additions and 1 deletions
|
|
@ -0,0 +1,228 @@
|
|||
function run_test(algorithmNames) {
|
||||
var subtle = crypto.subtle; // Change to test prefixed implementations
|
||||
|
||||
setup({explicit_timeout: true});
|
||||
|
||||
// These tests check that generateKey throws an error, and that
|
||||
// the error is of the right type, for a wide set of incorrect parameters.
|
||||
//
|
||||
// Error testing occurs by setting the parameter that should trigger the
|
||||
// error to an invalid value, then combining that with all valid
|
||||
// parameters that should be checked earlier by generateKey, and all
|
||||
// valid and invalid parameters that should be checked later by
|
||||
// generateKey.
|
||||
//
|
||||
// There are a lot of combinations of possible parameters for both
|
||||
// success and failure modes, resulting in a very large number of tests
|
||||
// performed.
|
||||
|
||||
|
||||
// Setup: define the correct behaviors that should be sought, and create
|
||||
// helper functions that generate all possible test parameters for
|
||||
// different situations.
|
||||
|
||||
var allTestVectors = [ // Parameters that should work for generateKey
|
||||
{name: "AES-CTR", resultType: CryptoKey, usages: ["encrypt", "decrypt", "wrapKey", "unwrapKey"], mandatoryUsages: []},
|
||||
{name: "AES-CBC", resultType: CryptoKey, usages: ["encrypt", "decrypt", "wrapKey", "unwrapKey"], mandatoryUsages: []},
|
||||
{name: "AES-GCM", resultType: CryptoKey, usages: ["encrypt", "decrypt", "wrapKey", "unwrapKey"], mandatoryUsages: []},
|
||||
{name: "AES-KW", resultType: CryptoKey, usages: ["wrapKey", "unwrapKey"], mandatoryUsages: []},
|
||||
{name: "HMAC", resultType: CryptoKey, usages: ["sign", "verify"], mandatoryUsages: []},
|
||||
{name: "RSASSA-PKCS1-v1_5", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "RSA-PSS", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "RSA-OAEP", resultType: "CryptoKeyPair", usages: ["encrypt", "decrypt", "wrapKey", "unwrapKey"], mandatoryUsages: ["decrypt", "unwrapKey"]},
|
||||
{name: "ECDSA", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "ECDH", resultType: "CryptoKeyPair", usages: ["deriveKey", "deriveBits"], mandatoryUsages: ["deriveKey", "deriveBits"]},
|
||||
{name: "Ed25519", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "Ed448", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "X25519", resultType: "CryptoKeyPair", usages: ["deriveKey", "deriveBits"], mandatoryUsages: ["deriveKey", "deriveBits"]},
|
||||
{name: "X448", resultType: "CryptoKeyPair", usages: ["deriveKey", "deriveBits"], mandatoryUsages: ["deriveKey", "deriveBits"]},
|
||||
];
|
||||
|
||||
var testVectors = [];
|
||||
if (algorithmNames && !Array.isArray(algorithmNames)) {
|
||||
algorithmNames = [algorithmNames];
|
||||
};
|
||||
allTestVectors.forEach(function(vector) {
|
||||
if (!algorithmNames || algorithmNames.includes(vector.name)) {
|
||||
testVectors.push(vector);
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
function parameterString(algorithm, extractable, usages) {
|
||||
if (typeof algorithm !== "object" && typeof algorithm !== "string") {
|
||||
alert(algorithm);
|
||||
}
|
||||
|
||||
var result = "(" +
|
||||
objectToString(algorithm) + ", " +
|
||||
objectToString(extractable) + ", " +
|
||||
objectToString(usages) +
|
||||
")";
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Test that a given combination of parameters results in an error,
|
||||
// AND that it is the correct kind of error.
|
||||
//
|
||||
// Expected error is either a number, tested against the error code,
|
||||
// or a string, tested against the error name.
|
||||
function testError(algorithm, extractable, usages, expectedError, testTag) {
|
||||
promise_test(function(test) {
|
||||
return crypto.subtle.generateKey(algorithm, extractable, usages)
|
||||
.then(function(result) {
|
||||
assert_unreached("Operation succeeded, but should not have");
|
||||
}, function(err) {
|
||||
if (typeof expectedError === "number") {
|
||||
assert_equals(err.code, expectedError, testTag + " not supported");
|
||||
} else {
|
||||
assert_equals(err.name, expectedError, testTag + " not supported");
|
||||
}
|
||||
});
|
||||
}, testTag + ": generateKey" + parameterString(algorithm, extractable, usages));
|
||||
}
|
||||
|
||||
|
||||
// Given an algorithm name, create several invalid parameters.
|
||||
function badAlgorithmPropertySpecifiersFor(algorithmName) {
|
||||
var results = [];
|
||||
|
||||
if (algorithmName.toUpperCase().substring(0, 3) === "AES") {
|
||||
// Specifier properties are name and length
|
||||
[64, 127, 129, 255, 257, 512].forEach(function(length) {
|
||||
results.push({name: algorithmName, length: length});
|
||||
});
|
||||
} else if (algorithmName.toUpperCase().substring(0, 3) === "RSA") {
|
||||
[new Uint8Array([1]), new Uint8Array([1,0,0])].forEach(function(publicExponent) {
|
||||
results.push({name: algorithmName, hash: "SHA-256", modulusLength: 1024, publicExponent: publicExponent});
|
||||
});
|
||||
} else if (algorithmName.toUpperCase().substring(0, 2) === "EC") {
|
||||
["P-512", "Curve25519"].forEach(function(curveName) {
|
||||
results.push({name: algorithmName, namedCurve: curveName});
|
||||
});
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
|
||||
// Don't create an exhaustive list of all invalid usages,
|
||||
// because there would usually be nearly 2**8 of them,
|
||||
// way too many to test. Instead, create every singleton
|
||||
// of an illegal usage, and "poison" every valid usage
|
||||
// with an illegal one.
|
||||
function invalidUsages(validUsages, mandatoryUsages) {
|
||||
var results = [];
|
||||
|
||||
var illegalUsages = [];
|
||||
["encrypt", "decrypt", "sign", "verify", "wrapKey", "unwrapKey", "deriveKey", "deriveBits"].forEach(function(usage) {
|
||||
if (!validUsages.includes(usage)) {
|
||||
illegalUsages.push(usage);
|
||||
}
|
||||
});
|
||||
|
||||
var goodUsageCombinations = allValidUsages(validUsages, false, mandatoryUsages);
|
||||
|
||||
illegalUsages.forEach(function(illegalUsage) {
|
||||
results.push([illegalUsage]);
|
||||
goodUsageCombinations.forEach(function(usageCombination) {
|
||||
results.push(usageCombination.concat([illegalUsage]));
|
||||
});
|
||||
});
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
|
||||
// Now test for properly handling errors
|
||||
// - Unsupported algorithm
|
||||
// - Bad usages for algorithm
|
||||
// - Bad key lengths
|
||||
|
||||
// Algorithm normalization should fail with "Not supported"
|
||||
var badAlgorithmNames = [
|
||||
"AES",
|
||||
{name: "AES"},
|
||||
{name: "AES", length: 128},
|
||||
{name: "AES-CMAC", length: 128}, // Removed after CR
|
||||
{name: "AES-CFB", length: 128}, // Removed after CR
|
||||
{name: "HMAC", hash: "MD5"},
|
||||
{name: "RSA", hash: "SHA-256", modulusLength: 2048, publicExponent: new Uint8Array([1,0,1])},
|
||||
{name: "RSA-PSS", hash: "SHA", modulusLength: 2048, publicExponent: new Uint8Array([1,0,1])},
|
||||
{name: "EC", namedCurve: "P521"}
|
||||
];
|
||||
|
||||
|
||||
// Algorithm normalization failures should be found first
|
||||
// - all other parameters can be good or bad, should fail
|
||||
// due to NotSupportedError.
|
||||
badAlgorithmNames.forEach(function(algorithm) {
|
||||
allValidUsages(["decrypt", "sign", "deriveBits"], true, []) // Small search space, shouldn't matter because should fail before used
|
||||
.forEach(function(usages) {
|
||||
[false, true, "RED", 7].forEach(function(extractable){
|
||||
testError(algorithm, extractable, usages, "NotSupportedError", "Bad algorithm");
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// Empty algorithm should fail with TypeError
|
||||
allValidUsages(["decrypt", "sign", "deriveBits"], true, []) // Small search space, shouldn't matter because should fail before used
|
||||
.forEach(function(usages) {
|
||||
[false, true, "RED", 7].forEach(function(extractable){
|
||||
testError({}, extractable, usages, "TypeError", "Empty algorithm");
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
// Algorithms normalize okay, but usages bad (though not empty).
|
||||
// It shouldn't matter what other extractable is. Should fail
|
||||
// due to SyntaxError
|
||||
testVectors.forEach(function(vector) {
|
||||
var name = vector.name;
|
||||
|
||||
allAlgorithmSpecifiersFor(name).forEach(function(algorithm) {
|
||||
invalidUsages(vector.usages, vector.mandatoryUsages).forEach(function(usages) {
|
||||
[true].forEach(function(extractable) {
|
||||
testError(algorithm, extractable, usages, "SyntaxError", "Bad usages");
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
// Other algorithm properties should be checked next, so try good
|
||||
// algorithm names and usages, but bad algorithm properties next.
|
||||
// - Special case: normally bad usage [] isn't checked until after properties,
|
||||
// so it's included in this test case. It should NOT cause an error.
|
||||
testVectors.forEach(function(vector) {
|
||||
var name = vector.name;
|
||||
badAlgorithmPropertySpecifiersFor(name).forEach(function(algorithm) {
|
||||
allValidUsages(vector.usages, true, vector.mandatoryUsages)
|
||||
.forEach(function(usages) {
|
||||
[false, true].forEach(function(extractable) {
|
||||
if (name.substring(0,2) === "EC") {
|
||||
testError(algorithm, extractable, usages, "NotSupportedError", "Bad algorithm property");
|
||||
} else {
|
||||
testError(algorithm, extractable, usages, "OperationError", "Bad algorithm property");
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
// The last thing that should be checked is empty usages (disallowed for secret and private keys).
|
||||
testVectors.forEach(function(vector) {
|
||||
var name = vector.name;
|
||||
|
||||
allAlgorithmSpecifiersFor(name).forEach(function(algorithm) {
|
||||
var usages = [];
|
||||
[false, true].forEach(function(extractable) {
|
||||
testError(algorithm, extractable, usages, "SyntaxError", "Empty usages");
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
<!doctype html>
|
||||
<meta charset=utf-8>
|
||||
<title>WebCryptoAPI: generateKey() for Failures</title>
|
||||
<meta name="timeout" content="long">
|
||||
<script>
|
||||
self.GLOBAL = {
|
||||
isWindow: function() { return true; },
|
||||
isWorker: function() { return false; },
|
||||
isShadowRealm: function() { return false; },
|
||||
};
|
||||
</script>
|
||||
<script src="../../resources/testharness.js"></script>
|
||||
<script src="../../resources/testharnessreport.js"></script>
|
||||
<script src="../util/helpers.js"></script>
|
||||
<script src="failures.js"></script>
|
||||
<div id=log></div>
|
||||
<script src="../../WebCryptoAPI/generateKey/failures_ECDH.https.any.js"></script>
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
// META: title=WebCryptoAPI: generateKey() for Failures
|
||||
// META: timeout=long
|
||||
// META: script=../util/helpers.js
|
||||
// META: script=failures.js
|
||||
run_test(["ECDH"]);
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
|
||||
function run_test(algorithmNames, slowTest) {
|
||||
var subtle = crypto.subtle; // Change to test prefixed implementations
|
||||
|
||||
setup({explicit_timeout: true});
|
||||
|
||||
// These tests check that generateKey successfully creates keys
|
||||
// when provided any of a wide set of correct parameters
|
||||
// and that they can be exported afterwards.
|
||||
//
|
||||
// There are a lot of combinations of possible parameters,
|
||||
// resulting in a very large number of tests
|
||||
// performed.
|
||||
|
||||
|
||||
// Setup: define the correct behaviors that should be sought, and create
|
||||
// helper functions that generate all possible test parameters for
|
||||
// different situations.
|
||||
|
||||
var allTestVectors = [ // Parameters that should work for generateKey
|
||||
{name: "AES-CTR", resultType: CryptoKey, usages: ["encrypt", "decrypt", "wrapKey", "unwrapKey"], mandatoryUsages: []},
|
||||
{name: "AES-CBC", resultType: CryptoKey, usages: ["encrypt", "decrypt", "wrapKey", "unwrapKey"], mandatoryUsages: []},
|
||||
{name: "AES-GCM", resultType: CryptoKey, usages: ["encrypt", "decrypt", "wrapKey", "unwrapKey"], mandatoryUsages: []},
|
||||
{name: "AES-KW", resultType: CryptoKey, usages: ["wrapKey", "unwrapKey"], mandatoryUsages: []},
|
||||
{name: "HMAC", resultType: CryptoKey, usages: ["sign", "verify"], mandatoryUsages: []},
|
||||
{name: "RSASSA-PKCS1-v1_5", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "RSA-PSS", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "RSA-OAEP", resultType: "CryptoKeyPair", usages: ["encrypt", "decrypt", "wrapKey", "unwrapKey"], mandatoryUsages: ["decrypt", "unwrapKey"]},
|
||||
{name: "ECDSA", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "ECDH", resultType: "CryptoKeyPair", usages: ["deriveKey", "deriveBits"], mandatoryUsages: ["deriveKey", "deriveBits"]},
|
||||
{name: "Ed25519", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "Ed448", resultType: "CryptoKeyPair", usages: ["sign", "verify"], mandatoryUsages: ["sign"]},
|
||||
{name: "X25519", resultType: "CryptoKeyPair", usages: ["deriveKey", "deriveBits"], mandatoryUsages: ["deriveKey", "deriveBits"]},
|
||||
{name: "X448", resultType: "CryptoKeyPair", usages: ["deriveKey", "deriveBits"], mandatoryUsages: ["deriveKey", "deriveBits"]},
|
||||
];
|
||||
|
||||
var testVectors = [];
|
||||
if (algorithmNames && !Array.isArray(algorithmNames)) {
|
||||
algorithmNames = [algorithmNames];
|
||||
};
|
||||
allTestVectors.forEach(function(vector) {
|
||||
if (!algorithmNames || algorithmNames.includes(vector.name)) {
|
||||
testVectors.push(vector);
|
||||
}
|
||||
});
|
||||
|
||||
function parameterString(algorithm, extractable, usages) {
|
||||
var result = "(" +
|
||||
objectToString(algorithm) + ", " +
|
||||
objectToString(extractable) + ", " +
|
||||
objectToString(usages) +
|
||||
")";
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Test that a given combination of parameters is successful
|
||||
function testSuccess(algorithm, extractable, usages, resultType, testTag) {
|
||||
// algorithm, extractable, and usages are the generateKey parameters
|
||||
// resultType is the expected result, either the CryptoKey object or "CryptoKeyPair"
|
||||
// testTag is a string to prepend to the test name.
|
||||
|
||||
promise_test(function(test) {
|
||||
return subtle.generateKey(algorithm, extractable, usages)
|
||||
.then(function(result) {
|
||||
if (resultType === "CryptoKeyPair") {
|
||||
assert_goodCryptoKey(result.privateKey, algorithm, extractable, usages, "private");
|
||||
assert_goodCryptoKey(result.publicKey, algorithm, true, usages, "public");
|
||||
} else {
|
||||
assert_goodCryptoKey(result, algorithm, extractable, usages, "secret");
|
||||
}
|
||||
return result;
|
||||
}, function(err) {
|
||||
assert_unreached("generateKey threw an unexpected error: " + err.toString());
|
||||
})
|
||||
.then(async function (result) {
|
||||
if (resultType === "CryptoKeyPair") {
|
||||
await Promise.all([
|
||||
subtle.exportKey('jwk', result.publicKey),
|
||||
subtle.exportKey('spki', result.publicKey),
|
||||
result.publicKey.algorithm.name.startsWith('RSA') ? undefined : subtle.exportKey('raw', result.publicKey),
|
||||
...(extractable ? [
|
||||
subtle.exportKey('jwk', result.privateKey),
|
||||
subtle.exportKey('pkcs8', result.privateKey),
|
||||
] : [])
|
||||
]);
|
||||
} else {
|
||||
if (extractable) {
|
||||
await Promise.all([
|
||||
subtle.exportKey('raw', result),
|
||||
subtle.exportKey('jwk', result),
|
||||
]);
|
||||
}
|
||||
}
|
||||
}, function(err) {
|
||||
assert_unreached("exportKey threw an unexpected error: " + err.toString());
|
||||
})
|
||||
}, testTag + ": generateKey" + parameterString(algorithm, extractable, usages));
|
||||
}
|
||||
|
||||
// Test all valid sets of parameters for successful
|
||||
// key generation.
|
||||
testVectors.forEach(function(vector) {
|
||||
allNameVariants(vector.name, slowTest).forEach(function(name) {
|
||||
allAlgorithmSpecifiersFor(name).forEach(function(algorithm) {
|
||||
allValidUsages(vector.usages, false, vector.mandatoryUsages).forEach(function(usages) {
|
||||
[false, true].forEach(function(extractable) {
|
||||
subsetTest(testSuccess, algorithm, extractable, usages, vector.resultType, "Success");
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
<!doctype html>
|
||||
<meta charset=utf-8>
|
||||
<title>WebCryptoAPI: generateKey() Successful Calls</title>
|
||||
<meta name="timeout" content="long">
|
||||
<script>
|
||||
self.GLOBAL = {
|
||||
isWindow: function() { return true; },
|
||||
isWorker: function() { return false; },
|
||||
isShadowRealm: function() { return false; },
|
||||
};
|
||||
</script>
|
||||
<script src="../../resources/testharness.js"></script>
|
||||
<script src="../../resources/testharnessreport.js"></script>
|
||||
<script src="../util/helpers.js"></script>
|
||||
<script src="../../common/subset-tests.js"></script>
|
||||
<script src="successes.js"></script>
|
||||
<div id=log></div>
|
||||
<script src="../../WebCryptoAPI/generateKey/successes_ECDH.https.any.js"></script>
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
// META: title=WebCryptoAPI: generateKey() Successful Calls
|
||||
// META: timeout=long
|
||||
// META: script=../util/helpers.js
|
||||
// META: script=/common/subset-tests.js
|
||||
// META: script=successes.js
|
||||
run_test(["ECDH"]);
|
||||
299
Tests/LibWeb/Text/input/wpt-import/WebCryptoAPI/util/helpers.js
Normal file
299
Tests/LibWeb/Text/input/wpt-import/WebCryptoAPI/util/helpers.js
Normal file
|
|
@ -0,0 +1,299 @@
|
|||
//
|
||||
// helpers.js
|
||||
//
|
||||
// Helper functions used by several WebCryptoAPI tests
|
||||
//
|
||||
|
||||
var registeredAlgorithmNames = [
|
||||
"RSASSA-PKCS1-v1_5",
|
||||
"RSA-PSS",
|
||||
"RSA-OAEP",
|
||||
"ECDSA",
|
||||
"ECDH",
|
||||
"AES-CTR",
|
||||
"AES-CBC",
|
||||
"AES-GCM",
|
||||
"AES-KW",
|
||||
"HMAC",
|
||||
"SHA-1",
|
||||
"SHA-256",
|
||||
"SHA-384",
|
||||
"SHA-512",
|
||||
"HKDF",
|
||||
"PBKDF2",
|
||||
"Ed25519",
|
||||
"Ed448",
|
||||
"X25519",
|
||||
"X448"
|
||||
];
|
||||
|
||||
|
||||
// Treats an array as a set, and generates an array of all non-empty
|
||||
// subsets (which are themselves arrays).
|
||||
//
|
||||
// The order of members of the "subsets" is not guaranteed.
|
||||
function allNonemptySubsetsOf(arr) {
|
||||
var results = [];
|
||||
var firstElement;
|
||||
var remainingElements;
|
||||
|
||||
for(var i=0; i<arr.length; i++) {
|
||||
firstElement = arr[i];
|
||||
remainingElements = arr.slice(i+1);
|
||||
results.push([firstElement]);
|
||||
|
||||
if (remainingElements.length > 0) {
|
||||
allNonemptySubsetsOf(remainingElements).forEach(function(combination) {
|
||||
combination.push(firstElement);
|
||||
results.push(combination);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
|
||||
// Create a string representation of keyGeneration parameters for
|
||||
// test names and labels.
|
||||
function objectToString(obj) {
|
||||
var keyValuePairs = [];
|
||||
|
||||
if (Array.isArray(obj)) {
|
||||
return "[" + obj.map(function(elem){return objectToString(elem);}).join(", ") + "]";
|
||||
} else if (typeof obj === "object") {
|
||||
Object.keys(obj).sort().forEach(function(keyName) {
|
||||
keyValuePairs.push(keyName + ": " + objectToString(obj[keyName]));
|
||||
});
|
||||
return "{" + keyValuePairs.join(", ") + "}";
|
||||
} else if (typeof obj === "undefined") {
|
||||
return "undefined";
|
||||
} else {
|
||||
return obj.toString();
|
||||
}
|
||||
|
||||
var keyValuePairs = [];
|
||||
|
||||
Object.keys(obj).sort().forEach(function(keyName) {
|
||||
var value = obj[keyName];
|
||||
if (typeof value === "object") {
|
||||
value = objectToString(value);
|
||||
} else if (typeof value === "array") {
|
||||
value = "[" + value.map(function(elem){return objectToString(elem);}).join(", ") + "]";
|
||||
} else {
|
||||
value = value.toString();
|
||||
}
|
||||
|
||||
keyValuePairs.push(keyName + ": " + value);
|
||||
});
|
||||
|
||||
return "{" + keyValuePairs.join(", ") + "}";
|
||||
}
|
||||
|
||||
// Is key a CryptoKey object with correct algorithm, extractable, and usages?
|
||||
// Is it a secret, private, or public kind of key?
|
||||
function assert_goodCryptoKey(key, algorithm, extractable, usages, kind) {
|
||||
var correctUsages = [];
|
||||
|
||||
var registeredAlgorithmName;
|
||||
registeredAlgorithmNames.forEach(function(name) {
|
||||
if (name.toUpperCase() === algorithm.name.toUpperCase()) {
|
||||
registeredAlgorithmName = name;
|
||||
}
|
||||
});
|
||||
|
||||
assert_equals(key.constructor, CryptoKey, "Is a CryptoKey");
|
||||
assert_equals(key.type, kind, "Is a " + kind + " key");
|
||||
assert_equals(key.extractable, extractable, "Extractability is correct");
|
||||
|
||||
assert_equals(key.algorithm.name, registeredAlgorithmName, "Correct algorithm name");
|
||||
if (key.algorithm.name.toUpperCase() === "HMAC" && algorithm.length === undefined) {
|
||||
switch (key.algorithm.hash.name.toUpperCase()) {
|
||||
case 'SHA-1':
|
||||
case 'SHA-256':
|
||||
assert_equals(key.algorithm.length, 512, "Correct length");
|
||||
break;
|
||||
case 'SHA-384':
|
||||
case 'SHA-512':
|
||||
assert_equals(key.algorithm.length, 1024, "Correct length");
|
||||
break;
|
||||
default:
|
||||
assert_unreached("Unrecognized hash");
|
||||
}
|
||||
} else {
|
||||
assert_equals(key.algorithm.length, algorithm.length, "Correct length");
|
||||
}
|
||||
if (["HMAC", "RSASSA-PKCS1-v1_5", "RSA-PSS"].includes(registeredAlgorithmName)) {
|
||||
assert_equals(key.algorithm.hash.name.toUpperCase(), algorithm.hash.toUpperCase(), "Correct hash function");
|
||||
}
|
||||
|
||||
if (/^(?:Ed|X)(?:25519|448)$/.test(key.algorithm.name)) {
|
||||
assert_false('namedCurve' in key.algorithm, "Does not have a namedCurve property");
|
||||
}
|
||||
|
||||
// usages is expected to be provided for a key pair, but we are checking
|
||||
// only a single key. The publicKey and privateKey portions of a key pair
|
||||
// recognize only some of the usages appropriate for a key pair.
|
||||
if (key.type === "public") {
|
||||
["encrypt", "verify", "wrapKey"].forEach(function(usage) {
|
||||
if (usages.includes(usage)) {
|
||||
correctUsages.push(usage);
|
||||
}
|
||||
});
|
||||
} else if (key.type === "private") {
|
||||
["decrypt", "sign", "unwrapKey", "deriveKey", "deriveBits"].forEach(function(usage) {
|
||||
if (usages.includes(usage)) {
|
||||
correctUsages.push(usage);
|
||||
}
|
||||
});
|
||||
} else {
|
||||
correctUsages = usages;
|
||||
}
|
||||
|
||||
assert_equals((typeof key.usages), "object", key.type + " key.usages is an object");
|
||||
assert_not_equals(key.usages, null, key.type + " key.usages isn't null");
|
||||
|
||||
// The usages parameter could have repeats, but the usages
|
||||
// property of the result should not.
|
||||
var usageCount = 0;
|
||||
key.usages.forEach(function(usage) {
|
||||
usageCount += 1;
|
||||
assert_in_array(usage, correctUsages, "Has " + usage + " usage");
|
||||
});
|
||||
assert_equals(key.usages.length, usageCount, "usages property is correct");
|
||||
assert_equals(key[Symbol.toStringTag], 'CryptoKey', "has the expected Symbol.toStringTag");
|
||||
}
|
||||
|
||||
|
||||
// The algorithm parameter is an object with a name and other
|
||||
// properties. Given the name, generate all valid parameters.
|
||||
function allAlgorithmSpecifiersFor(algorithmName) {
|
||||
var results = [];
|
||||
|
||||
// RSA key generation is slow. Test a minimal set of parameters
|
||||
var hashes = ["SHA-1", "SHA-256"];
|
||||
|
||||
// EC key generation is a lot faster. Check all curves in the spec
|
||||
var curves = ["P-256", "P-384", "P-521"];
|
||||
|
||||
if (algorithmName.toUpperCase().substring(0, 3) === "AES") {
|
||||
// Specifier properties are name and length
|
||||
[128, 192, 256].forEach(function(length) {
|
||||
results.push({name: algorithmName, length: length});
|
||||
});
|
||||
} else if (algorithmName.toUpperCase() === "HMAC") {
|
||||
[
|
||||
{hash: "SHA-1", length: 160},
|
||||
{hash: "SHA-256", length: 256},
|
||||
{hash: "SHA-384", length: 384},
|
||||
{hash: "SHA-512", length: 512},
|
||||
{hash: "SHA-1"},
|
||||
{hash: "SHA-256"},
|
||||
{hash: "SHA-384"},
|
||||
{hash: "SHA-512"},
|
||||
].forEach(function(hashAlgorithm) {
|
||||
results.push({name: algorithmName, ...hashAlgorithm});
|
||||
});
|
||||
} else if (algorithmName.toUpperCase().substring(0, 3) === "RSA") {
|
||||
hashes.forEach(function(hashName) {
|
||||
results.push({name: algorithmName, hash: hashName, modulusLength: 2048, publicExponent: new Uint8Array([1,0,1])});
|
||||
});
|
||||
} else if (algorithmName.toUpperCase().substring(0, 2) === "EC") {
|
||||
curves.forEach(function(curveName) {
|
||||
results.push({name: algorithmName, namedCurve: curveName});
|
||||
});
|
||||
} else if (algorithmName.toUpperCase().substring(0, 1) === "X" || algorithmName.toUpperCase().substring(0, 2) === "ED") {
|
||||
results.push({ name: algorithmName });
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
|
||||
// Create every possible valid usages parameter, given legal
|
||||
// usages. Note that an empty usages parameter is not always valid.
|
||||
//
|
||||
// There is an optional parameter - mandatoryUsages. If provided,
|
||||
// it should be an array containing those usages of which one must be
|
||||
// included.
|
||||
function allValidUsages(validUsages, emptyIsValid, mandatoryUsages) {
|
||||
if (typeof mandatoryUsages === "undefined") {
|
||||
mandatoryUsages = [];
|
||||
}
|
||||
|
||||
var okaySubsets = [];
|
||||
allNonemptySubsetsOf(validUsages).forEach(function(subset) {
|
||||
if (mandatoryUsages.length === 0) {
|
||||
okaySubsets.push(subset);
|
||||
} else {
|
||||
for (var i=0; i<mandatoryUsages.length; i++) {
|
||||
if (subset.includes(mandatoryUsages[i])) {
|
||||
okaySubsets.push(subset);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
if (emptyIsValid && validUsages.length !== 0) {
|
||||
okaySubsets.push([]);
|
||||
}
|
||||
|
||||
okaySubsets.push(validUsages.concat(mandatoryUsages).concat(validUsages)); // Repeated values are allowed
|
||||
return okaySubsets;
|
||||
}
|
||||
|
||||
function unique(names) {
|
||||
return [...new Set(names)];
|
||||
}
|
||||
|
||||
// Algorithm name specifiers are case-insensitive. Generate several
|
||||
// case variations of a given name.
|
||||
function allNameVariants(name, slowTest) {
|
||||
var upCaseName = name.toUpperCase();
|
||||
var lowCaseName = name.toLowerCase();
|
||||
var mixedCaseName = upCaseName.substring(0, 1) + lowCaseName.substring(1);
|
||||
|
||||
// for slow tests effectively cut the amount of work in third by only
|
||||
// returning one variation
|
||||
if (slowTest) return [mixedCaseName];
|
||||
return unique([upCaseName, lowCaseName, mixedCaseName]);
|
||||
}
|
||||
|
||||
// Builds a hex string representation for an array-like input.
|
||||
// "bytes" can be an Array of bytes, an ArrayBuffer, or any TypedArray.
|
||||
// The output looks like this:
|
||||
// ab034c99
|
||||
function bytesToHexString(bytes)
|
||||
{
|
||||
if (!bytes)
|
||||
return null;
|
||||
|
||||
bytes = new Uint8Array(bytes);
|
||||
var hexBytes = [];
|
||||
|
||||
for (var i = 0; i < bytes.length; ++i) {
|
||||
var byteString = bytes[i].toString(16);
|
||||
if (byteString.length < 2)
|
||||
byteString = "0" + byteString;
|
||||
hexBytes.push(byteString);
|
||||
}
|
||||
|
||||
return hexBytes.join("");
|
||||
}
|
||||
|
||||
function hexStringToUint8Array(hexString)
|
||||
{
|
||||
if (hexString.length % 2 != 0)
|
||||
throw "Invalid hexString";
|
||||
var arrayBuffer = new Uint8Array(hexString.length / 2);
|
||||
|
||||
for (var i = 0; i < hexString.length; i += 2) {
|
||||
var byteValue = parseInt(hexString.substr(i, 2), 16);
|
||||
if (byteValue == NaN)
|
||||
throw "Invalid hexString";
|
||||
arrayBuffer[i/2] = byteValue;
|
||||
}
|
||||
|
||||
return arrayBuffer;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue