function run_test() { var subtle = self.crypto.subtle; // Change to test prefixed implementations // When are all these tests really done? When all the promises they use have resolved. var all_promises = []; // Source file aes_XXX_vectors.js provides the getTestVectors method // for the AES-XXX algorithm that drives these tests. var vectors = getTestVectors(); var passingVectors = vectors.passing; var failingVectors = vectors.failing; var decryptionFailingVectors = vectors.decryptionFailing; // Check for successful encryption. passingVectors.forEach(function(vector) { var promise = importVectorKey(vector, ["encrypt", "decrypt"]) .then(function(vector) { promise_test(function(test) { return subtle.encrypt(vector.algorithm, vector.key, vector.plaintext) .then(function(result) { assert_true(equalBuffers(result, vector.result), "Should return expected result"); }, function(err) { assert_unreached("encrypt error for test " + vector.name + ": " + err.message); }); }, vector.name); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step: " + vector.name); }); all_promises.push(promise); }); // Check for successful encryption even if the buffer is changed after calling encrypt. passingVectors.forEach(function(vector) { var plaintext = copyBuffer(vector.plaintext); var promise = importVectorKey(vector, ["encrypt", "decrypt"]) .then(function(vector) { promise_test(function(test) { var operation = subtle.encrypt(vector.algorithm, vector.key, plaintext) .then(function(result) { assert_true(equalBuffers(result, vector.result), "Should return expected result"); }, function(err) { assert_unreached("encrypt error for test " + vector.name + ": " + err.message); }); plaintext[0] = 255 - plaintext[0]; return operation; }, vector.name + " with altered plaintext"); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step: " + vector.name + " with altered plaintext"); }); all_promises.push(promise); }); // Check for successful decryption. passingVectors.forEach(function(vector) { var promise = importVectorKey(vector, ["encrypt", "decrypt"]) .then(function(vector) { promise_test(function(test) { return subtle.decrypt(vector.algorithm, vector.key, vector.result) .then(function(result) { assert_true(equalBuffers(result, vector.plaintext), "Should return expected result"); }, function(err) { assert_unreached("decrypt error for test " + vector.name + ": " + err.message); }); }, vector.name + " decryption"); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step for decryption: " + vector.name); }); all_promises.push(promise); }); // Check for successful decryption even if ciphertext is altered. passingVectors.forEach(function(vector) { var ciphertext = copyBuffer(vector.result); var promise = importVectorKey(vector, ["encrypt", "decrypt"]) .then(function(vector) { promise_test(function(test) { var operation = subtle.decrypt(vector.algorithm, vector.key, ciphertext) .then(function(result) { assert_true(equalBuffers(result, vector.plaintext), "Should return expected result"); }, function(err) { assert_unreached("decrypt error for test " + vector.name + ": " + err.message); }); ciphertext[0] = 255 - ciphertext[0]; return operation; }, vector.name + " decryption with altered ciphertext"); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step for decryption: " + vector.name + " with altered ciphertext"); }); all_promises.push(promise); }); // Everything that succeeded should fail if no "encrypt" usage. passingVectors.forEach(function(vector) { // Don't want to overwrite key being used for success tests! var badVector = Object.assign({}, vector); badVector.key = null; var promise = importVectorKey(badVector, ["decrypt"]) .then(function(vector) { promise_test(function(test) { return subtle.encrypt(vector.algorithm, vector.key, vector.plaintext) .then(function(result) { assert_unreached("should have thrown exception for test " + vector.name); }, function(err) { assert_equals(err.name, "InvalidAccessError", "Should throw an InvalidAccessError instead of " + err.message) }); }, vector.name + " without encrypt usage"); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step: " + vector.name + " without encrypt usage"); }); all_promises.push(promise); }); // Encryption should fail if algorithm of key doesn't match algorithm of function call. passingVectors.forEach(function(vector) { var algorithm = Object.assign({}, vector.algorithm); if (algorithm.name === "AES-CBC") { algorithm.name = "AES-CTR"; algorithm.counter = new Uint8Array(16); algorithm.length = 64; } else { algorithm.name = "AES-CBC"; algorithm.iv = new Uint8Array(16); // Need syntactically valid parameter to get to error being checked. } var promise = importVectorKey(vector, ["encrypt", "decrypt"]) .then(function(vector) { promise_test(function(test) { return subtle.encrypt(algorithm, vector.key, vector.plaintext) .then(function(result) { assert_unreached("encrypt succeeded despite mismatch " + vector.name + ": " + err.message); }, function(err) { assert_equals(err.name, "InvalidAccessError", "Mismatch should cause InvalidAccessError instead of " + err.message); }); }, vector.name + " with mismatched key and algorithm"); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step: " + vector.name + " with mismatched key and algorithm"); }); all_promises.push(promise); }); // Everything that succeeded decrypting should fail if no "decrypt" usage. passingVectors.forEach(function(vector) { // Don't want to overwrite key being used for success tests! var badVector = Object.assign({}, vector); badVector.key = null; var promise = importVectorKey(badVector, ["encrypt"]) .then(function(vector) { promise_test(function(test) { return subtle.decrypt(vector.algorithm, vector.key, vector.result) .then(function(result) { assert_unreached("should have thrown exception for test " + vector.name); }, function(err) { assert_equals(err.name, "InvalidAccessError", "Should throw an InvalidAccessError instead of " + err.message) }); }, vector.name + " without decrypt usage"); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step: " + vector.name + " without decrypt usage"); }); all_promises.push(promise); }); // Check for OperationError due to data lengths. failingVectors.forEach(function(vector) { var promise = importVectorKey(vector, ["encrypt", "decrypt"]) .then(function(vector) { promise_test(function(test) { return subtle.encrypt(vector.algorithm, vector.key, vector.plaintext) .then(function(result) { assert_unreached("should have thrown exception for test " + vector.name); }, function(err) { assert_equals(err.name, "OperationError", "Should throw an OperationError instead of " + err.message) }); }, vector.name); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step: " + vector.name); }); all_promises.push(promise); }); // Check for OperationError due to data lengths for decryption, too. failingVectors.forEach(function(vector) { var promise = importVectorKey(vector, ["encrypt", "decrypt"]) .then(function(vector) { promise_test(function(test) { return subtle.decrypt(vector.algorithm, vector.key, vector.result) .then(function(result) { assert_unreached("should have thrown exception for test " + vector.name); }, function(err) { assert_equals(err.name, "OperationError", "Should throw an OperationError instead of " + err.message) }); }, vector.name + " decryption"); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step: decryption " + vector.name); }); all_promises.push(promise); }); // Check for decryption failing for algorithm-specific reasons (such as bad // padding for AES-CBC). decryptionFailingVectors.forEach(function(vector) { var promise = importVectorKey(vector, ["encrypt", "decrypt"]) .then(function(vector) { promise_test(function(test) { return subtle.decrypt(vector.algorithm, vector.key, vector.result) .then(function(result) { assert_unreached("should have thrown exception for test " + vector.name); }, function(err) { assert_equals(err.name, "OperationError", "Should throw an OperationError instead of " + err.message) }); }, vector.name); }, function(err) { // We need a failed test if the importVectorKey operation fails, so // we know we never tested encryption promise_test(function(test) { assert_unreached("importKey failed for " + vector.name); }, "importKey step: decryption " + vector.name); }); all_promises.push(promise); }); promise_test(function() { return Promise.all(all_promises) .then(function() {done();}) .catch(function() {done();}) }, "setup"); // A test vector has all needed fields for encryption, EXCEPT that the // key field may be null. This function replaces that null with the Correct // CryptoKey object. // // Returns a Promise that yields an updated vector on success. function importVectorKey(vector, usages) { if (vector.key !== null) { return new Promise(function(resolve, reject) { resolve(vector); }); } else { return subtle.importKey("raw", vector.keyBuffer, {name: vector.algorithm.name}, false, usages) .then(function(key) { vector.key = key; return vector; }); } } // Returns a copy of the sourceBuffer it is sent. function copyBuffer(sourceBuffer) { var source = new Uint8Array(sourceBuffer); var copy = new Uint8Array(sourceBuffer.byteLength) for (var i=0; i