Update WebCrypto tests
authorap@apple.com <ap@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 15 Nov 2013 02:50:37 +0000 (02:50 +0000)
committerap@apple.com <ap@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 15 Nov 2013 02:50:37 +0000 (02:50 +0000)
https://bugs.webkit.org/show_bug.cgi?id=124388

Reviewed by Anders Carlsson.

Updated tests for newer common.js. Changed some tests from just dumping results
to comparing them to known expected ones. Fixed a syntax error in
aes-cbc-invalid-length.html, so it now actually runs.

* crypto/subtle/resources/common.js: Update to a new version from Blink, because
it's much nicer than the old one, and it's good to be compatible at test level.
Moved crypto.subtle definition from webkitSubtle here to avoid repeating it in all
tests. Added a quick and dirty Promise.all implementation.

* crypto/subtle/aes-cbc-192-encrypt-decrypt-expected.txt:
* crypto/subtle/aes-cbc-192-encrypt-decrypt.html:
* crypto/subtle/aes-cbc-256-encrypt-decrypt-expected.txt:
* crypto/subtle/aes-cbc-256-encrypt-decrypt.html:
* crypto/subtle/aes-cbc-encrypt-decrypt-expected.txt:
* crypto/subtle/aes-cbc-encrypt-decrypt-with-padding-expected.txt:
* crypto/subtle/aes-cbc-encrypt-decrypt-with-padding.html:
* crypto/subtle/aes-cbc-encrypt-decrypt.html:
* crypto/subtle/aes-cbc-generate-key.html:
* crypto/subtle/aes-cbc-import-jwk-expected.txt:
* crypto/subtle/aes-cbc-import-jwk.html:
* crypto/subtle/aes-cbc-invalid-length-expected.txt:
* crypto/subtle/aes-cbc-invalid-length.html:
* crypto/subtle/aes-cbc-wrong-key-class.html:
* crypto/subtle/aes-export-key-expected.txt:
* crypto/subtle/aes-export-key.html:
* crypto/subtle/argument-conversion-expected.txt:
* crypto/subtle/argument-conversion.html:
* crypto/subtle/hmac-export-key-expected.txt:
* crypto/subtle/hmac-export-key.html:
* crypto/subtle/hmac-generate-key.html:
* crypto/subtle/hmac-import-jwk-expected.txt:
* crypto/subtle/hmac-import-jwk.html:
* crypto/subtle/hmac-sign-verify-empty-key-expected.txt:
* crypto/subtle/hmac-sign-verify-empty-key.html:
* crypto/subtle/hmac-sign-verify-expected.txt:
* crypto/subtle/hmac-sign-verify.html:
* crypto/subtle/import-jwk-expected.txt:
* crypto/subtle/import-jwk.html:
* crypto/subtle/rsassa-pkcs1-v1_5-generate-key-expected.txt:
* crypto/subtle/rsassa-pkcs1-v1_5-generate-key.html:
* crypto/subtle/rsassa-pkcs1-v1_5-import-jwk-expected.txt:
* crypto/subtle/rsassa-pkcs1-v1_5-import-jwk.html:
* crypto/subtle/rsassa-pkcs1-v1_5-sign-verify-expected.txt:
* crypto/subtle/rsassa-pkcs1-v1_5-sign-verify.html:
* crypto/subtle/sha-1-expected.txt:
* crypto/subtle/sha-1.html:
* crypto/subtle/sha-224-expected.txt:
* crypto/subtle/sha-224.html:
* crypto/subtle/sha-256-expected.txt:
* crypto/subtle/sha-256.html:
* crypto/subtle/sha-384-expected.txt:
* crypto/subtle/sha-384.html:
* crypto/subtle/sha-512-expected.txt:
* crypto/subtle/sha-512.html:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@159327 268f45cc-cd09-0410-ab3c-d52691b4dbfc

47 files changed:
LayoutTests/ChangeLog
LayoutTests/crypto/subtle/aes-cbc-192-encrypt-decrypt-expected.txt
LayoutTests/crypto/subtle/aes-cbc-192-encrypt-decrypt.html
LayoutTests/crypto/subtle/aes-cbc-256-encrypt-decrypt-expected.txt
LayoutTests/crypto/subtle/aes-cbc-256-encrypt-decrypt.html
LayoutTests/crypto/subtle/aes-cbc-encrypt-decrypt-expected.txt
LayoutTests/crypto/subtle/aes-cbc-encrypt-decrypt-with-padding-expected.txt
LayoutTests/crypto/subtle/aes-cbc-encrypt-decrypt-with-padding.html
LayoutTests/crypto/subtle/aes-cbc-encrypt-decrypt.html
LayoutTests/crypto/subtle/aes-cbc-generate-key.html
LayoutTests/crypto/subtle/aes-cbc-import-jwk-expected.txt
LayoutTests/crypto/subtle/aes-cbc-import-jwk.html
LayoutTests/crypto/subtle/aes-cbc-invalid-length-expected.txt
LayoutTests/crypto/subtle/aes-cbc-invalid-length.html
LayoutTests/crypto/subtle/aes-cbc-wrong-key-class.html
LayoutTests/crypto/subtle/aes-export-key-expected.txt
LayoutTests/crypto/subtle/aes-export-key.html
LayoutTests/crypto/subtle/argument-conversion-expected.txt
LayoutTests/crypto/subtle/argument-conversion.html
LayoutTests/crypto/subtle/hmac-export-key-expected.txt
LayoutTests/crypto/subtle/hmac-export-key.html
LayoutTests/crypto/subtle/hmac-generate-key.html
LayoutTests/crypto/subtle/hmac-import-jwk-expected.txt
LayoutTests/crypto/subtle/hmac-import-jwk.html
LayoutTests/crypto/subtle/hmac-sign-verify-empty-key-expected.txt
LayoutTests/crypto/subtle/hmac-sign-verify-empty-key.html
LayoutTests/crypto/subtle/hmac-sign-verify-expected.txt
LayoutTests/crypto/subtle/hmac-sign-verify.html
LayoutTests/crypto/subtle/import-jwk-expected.txt
LayoutTests/crypto/subtle/import-jwk.html
LayoutTests/crypto/subtle/resources/common.js
LayoutTests/crypto/subtle/rsassa-pkcs1-v1_5-generate-key-expected.txt
LayoutTests/crypto/subtle/rsassa-pkcs1-v1_5-generate-key.html
LayoutTests/crypto/subtle/rsassa-pkcs1-v1_5-import-jwk-expected.txt
LayoutTests/crypto/subtle/rsassa-pkcs1-v1_5-import-jwk.html
LayoutTests/crypto/subtle/rsassa-pkcs1-v1_5-sign-verify-expected.txt
LayoutTests/crypto/subtle/rsassa-pkcs1-v1_5-sign-verify.html
LayoutTests/crypto/subtle/sha-1-expected.txt
LayoutTests/crypto/subtle/sha-1.html
LayoutTests/crypto/subtle/sha-224-expected.txt
LayoutTests/crypto/subtle/sha-224.html
LayoutTests/crypto/subtle/sha-256-expected.txt
LayoutTests/crypto/subtle/sha-256.html
LayoutTests/crypto/subtle/sha-384-expected.txt
LayoutTests/crypto/subtle/sha-384.html
LayoutTests/crypto/subtle/sha-512-expected.txt
LayoutTests/crypto/subtle/sha-512.html

index 2261c8f..1ba5ec7 100644 (file)
@@ -1,3 +1,65 @@
+2013-11-14  Alexey Proskuryakov  <ap@apple.com>
+
+        Update WebCrypto tests
+        https://bugs.webkit.org/show_bug.cgi?id=124388
+
+        Reviewed by Anders Carlsson.
+
+        Updated tests for newer common.js. Changed some tests from just dumping results
+        to comparing them to known expected ones. Fixed a syntax error in
+        aes-cbc-invalid-length.html, so it now actually runs.
+
+        * crypto/subtle/resources/common.js: Update to a new version from Blink, because
+        it's much nicer than the old one, and it's good to be compatible at test level.
+        Moved crypto.subtle definition from webkitSubtle here to avoid repeating it in all
+        tests. Added a quick and dirty Promise.all implementation.
+
+        * crypto/subtle/aes-cbc-192-encrypt-decrypt-expected.txt:
+        * crypto/subtle/aes-cbc-192-encrypt-decrypt.html:
+        * crypto/subtle/aes-cbc-256-encrypt-decrypt-expected.txt:
+        * crypto/subtle/aes-cbc-256-encrypt-decrypt.html:
+        * crypto/subtle/aes-cbc-encrypt-decrypt-expected.txt:
+        * crypto/subtle/aes-cbc-encrypt-decrypt-with-padding-expected.txt:
+        * crypto/subtle/aes-cbc-encrypt-decrypt-with-padding.html:
+        * crypto/subtle/aes-cbc-encrypt-decrypt.html:
+        * crypto/subtle/aes-cbc-generate-key.html:
+        * crypto/subtle/aes-cbc-import-jwk-expected.txt:
+        * crypto/subtle/aes-cbc-import-jwk.html:
+        * crypto/subtle/aes-cbc-invalid-length-expected.txt:
+        * crypto/subtle/aes-cbc-invalid-length.html:
+        * crypto/subtle/aes-cbc-wrong-key-class.html:
+        * crypto/subtle/aes-export-key-expected.txt:
+        * crypto/subtle/aes-export-key.html:
+        * crypto/subtle/argument-conversion-expected.txt:
+        * crypto/subtle/argument-conversion.html:
+        * crypto/subtle/hmac-export-key-expected.txt:
+        * crypto/subtle/hmac-export-key.html:
+        * crypto/subtle/hmac-generate-key.html:
+        * crypto/subtle/hmac-import-jwk-expected.txt:
+        * crypto/subtle/hmac-import-jwk.html:
+        * crypto/subtle/hmac-sign-verify-empty-key-expected.txt:
+        * crypto/subtle/hmac-sign-verify-empty-key.html:
+        * crypto/subtle/hmac-sign-verify-expected.txt:
+        * crypto/subtle/hmac-sign-verify.html:
+        * crypto/subtle/import-jwk-expected.txt:
+        * crypto/subtle/import-jwk.html:
+        * crypto/subtle/rsassa-pkcs1-v1_5-generate-key-expected.txt:
+        * crypto/subtle/rsassa-pkcs1-v1_5-generate-key.html:
+        * crypto/subtle/rsassa-pkcs1-v1_5-import-jwk-expected.txt:
+        * crypto/subtle/rsassa-pkcs1-v1_5-import-jwk.html:
+        * crypto/subtle/rsassa-pkcs1-v1_5-sign-verify-expected.txt:
+        * crypto/subtle/rsassa-pkcs1-v1_5-sign-verify.html:
+        * crypto/subtle/sha-1-expected.txt:
+        * crypto/subtle/sha-1.html:
+        * crypto/subtle/sha-224-expected.txt:
+        * crypto/subtle/sha-224.html:
+        * crypto/subtle/sha-256-expected.txt:
+        * crypto/subtle/sha-256.html:
+        * crypto/subtle/sha-384-expected.txt:
+        * crypto/subtle/sha-384.html:
+        * crypto/subtle/sha-512-expected.txt:
+        * crypto/subtle/sha-512.html:
+
 2013-11-14  Victor Costan  <costan@gmail.com>
 
         XMLSerializer escapes < > & correctly inside <script> and <style> tags.
index a59751c..34ec38b 100644 (file)
@@ -10,7 +10,7 @@ PASS key.algorithm.name is 'aes-cbc'
 PASS key.algorithm.length is 192
 PASS key.usages is ['encrypt', 'decrypt']
 Using the key to encrypt plaintext...
-PASS byteArrayToHexString(new Uint8Array(encryptionResult)) is '[4f 02 1d b2 43 bc 63 3d 71 78 18 3a 9f a0 71 e8 b4 d9 ad a9 ad 7d ed f4 e5 e7 38 76 3f 69 14 5a 57 1b 24 20 12 fb 7a e0 7f a9 ba ac 3d f1 02 e0 08 b0 e2 79 88 59 88 81 d9 20 a9 e6 4f 56 15 cd 61 2c cd 79 22 4b 35 09 35 d4 5d d6 a9 8f 81 76]'
+PASS bytesToHexString(new Uint8Array(encryptionResult)) is '4f021db243bc633d7178183a9fa071e8b4d9ada9ad7dedf4e5e738763f69145a571b242012fb7ae07fa9baac3df102e008b0e27988598881d920a9e64f5615cd612ccd79224b350935d45dd6a98f8176'
 Decrypting it back...
 PASS new Uint8Array(decryptionResult) is plaintext
 PASS successfullyParsed is true
index ad6f7f9..77a30bc 100644 (file)
@@ -13,12 +13,9 @@ description("Test AES-CBC encrypt and decrypt functions with a 256 bit key.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
-var keyData = hexToArrayBuffer("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b");
-var iv = hexToArrayBuffer("000102030405060708090a0b0c0d0e0f");
-var plaintext = hexToArrayBuffer("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
+var keyData = hexStringToUint8Array("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b");
+var iv = hexStringToUint8Array("000102030405060708090a0b0c0d0e0f");
+var plaintext = hexStringToUint8Array("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
 var extractable = true;
 
 debug("Importing a raw AES key from string literal...");
@@ -34,7 +31,7 @@ crypto.subtle.importKey("raw", keyData, "aes-cbc", extractable, ["encrypt", "dec
     return crypto.subtle.encrypt({name: "aes-cbc", iv: iv}, key, [plaintext]);
 }).then(function(result) {
     encryptionResult = result;
-    shouldBe("byteArrayToHexString(new Uint8Array(encryptionResult))", "'[4f 02 1d b2 43 bc 63 3d 71 78 18 3a 9f a0 71 e8 b4 d9 ad a9 ad 7d ed f4 e5 e7 38 76 3f 69 14 5a 57 1b 24 20 12 fb 7a e0 7f a9 ba ac 3d f1 02 e0 08 b0 e2 79 88 59 88 81 d9 20 a9 e6 4f 56 15 cd 61 2c cd 79 22 4b 35 09 35 d4 5d d6 a9 8f 81 76]'");
+    shouldBe("bytesToHexString(new Uint8Array(encryptionResult))", "'4f021db243bc633d7178183a9fa071e8b4d9ada9ad7dedf4e5e738763f69145a571b242012fb7ae07fa9baac3df102e008b0e27988598881d920a9e64f5615cd612ccd79224b350935d45dd6a98f8176'");
 
     debug("Decrypting it back...");
     return crypto.subtle.decrypt({name: "aes-cbc", iv: iv}, key, [result]);
index 06cdac3..f860041 100644 (file)
@@ -10,7 +10,7 @@ PASS key.algorithm.name is 'aes-cbc'
 PASS key.algorithm.length is 256
 PASS key.usages is ['encrypt', 'decrypt']
 Using the key to encrypt plaintext...
-PASS byteArrayToHexString(new Uint8Array(encryptionResult)) is '[f5 8c 4c 04 d6 e5 f1 ba 77 9e ab fb 5f 7b fb d6 9c fc 4e 96 7e db 80 8d 67 9f 77 7b c6 70 2c 7d 39 f2 33 69 a9 d9 ba cf a5 30 e2 63 04 23 14 61 b2 eb 05 e2 c3 9b e9 fc da 6c 19 07 8c 6a 9d 1b 3f 46 17 96 d6 b0 d6 b2 e0 c2 a7 2b 4d 80 e6 44]'
+PASS bytesToHexString(new Uint8Array(encryptionResult)) is 'f58c4c04d6e5f1ba779eabfb5f7bfbd69cfc4e967edb808d679f777bc6702c7d39f23369a9d9bacfa530e26304231461b2eb05e2c39be9fcda6c19078c6a9d1b3f461796d6b0d6b2e0c2a72b4d80e644'
 Decrypting it back...
 PASS new Uint8Array(decryptionResult) is plaintext
 PASS successfullyParsed is true
index eddc3d3..3e430e6 100644 (file)
@@ -13,12 +13,9 @@ description("Test AES-CBC encrypt and decrypt functions with a 256 bit key.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
-var keyData = hexToArrayBuffer("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4");
-var iv = hexToArrayBuffer("000102030405060708090a0b0c0d0e0f");
-var plaintext = hexToArrayBuffer("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
+var keyData = hexStringToUint8Array("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4");
+var iv = hexStringToUint8Array("000102030405060708090a0b0c0d0e0f");
+var plaintext = hexStringToUint8Array("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
 var extractable = true;
 
 debug("Importing a raw AES key from string literal...");
@@ -34,7 +31,7 @@ crypto.subtle.importKey("raw", keyData, "aes-cbc", extractable, ["encrypt", "dec
     return crypto.subtle.encrypt({name: "aes-cbc", iv: iv}, key, [plaintext]);
 }).then(function(result) {
     encryptionResult = result;
-    shouldBe("byteArrayToHexString(new Uint8Array(encryptionResult))", "'[f5 8c 4c 04 d6 e5 f1 ba 77 9e ab fb 5f 7b fb d6 9c fc 4e 96 7e db 80 8d 67 9f 77 7b c6 70 2c 7d 39 f2 33 69 a9 d9 ba cf a5 30 e2 63 04 23 14 61 b2 eb 05 e2 c3 9b e9 fc da 6c 19 07 8c 6a 9d 1b 3f 46 17 96 d6 b0 d6 b2 e0 c2 a7 2b 4d 80 e6 44]'");
+    shouldBe("bytesToHexString(new Uint8Array(encryptionResult))", "'f58c4c04d6e5f1ba779eabfb5f7bfbd69cfc4e967edb808d679f777bc6702c7d39f23369a9d9bacfa530e26304231461b2eb05e2c39be9fcda6c19078c6a9d1b3f461796d6b0d6b2e0c2a72b4d80e644'");
 
     debug("Decrypting it back...");
     return crypto.subtle.decrypt({name: "aes-cbc", iv: iv}, key, [result]);
index 157ae96..0cb5a85 100644 (file)
@@ -10,7 +10,7 @@ PASS key.algorithm.name is 'aes-cbc'
 PASS key.algorithm.length is 128
 PASS key.usages is ['encrypt', 'decrypt']
 Using the key to encrypt plaintext...
-PASS byteArrayToHexString(new Uint8Array(encryptionResult)) is '[76 49 ab ac 81 19 b2 46 ce e9 8e 9b 12 e9 19 7d 50 86 cb 9b 50 72 19 ee 95 db 11 3a 91 76 78 b2 73 be d6 b8 e3 c1 74 3b 71 16 e6 9e 22 22 95 16 3f f1 ca a1 68 1f ac 09 12 0e ca 30 75 86 e1 a7 8c b8 28 07 23 0e 13 21 d3 fa e0 0d 18 cc 20 12]'
+PASS bytesToHexString(new Uint8Array(encryptionResult)) is '7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a78cb82807230e1321d3fae00d18cc2012'
 Decrypting it back...
 PASS new Uint8Array(decryptionResult) is plaintext
 Testing initialization vector bindings...
index 0cc4f74..412a5d0 100644 (file)
@@ -10,7 +10,7 @@ PASS key.algorithm.name is 'aes-cbc'
 PASS key.algorithm.length is 128
 PASS key.usages is ['encrypt', 'decrypt']
 Using the key to encrypt plaintext...
-    = [63 01 99 c5 f2 02 cc 71 67 bb 84 c6 c7 2b 34 9d]
+PASS bytesToHexString(new Uint8Array(cyphertext)) is '630199c5f202cc7167bb84c6c72b349d'
 Decrypting it back...
 PASS new Uint8Array(decryptionResult) is plaintext
 PASS successfullyParsed is true
index 5b9dc36..735250a 100644 (file)
@@ -13,12 +13,9 @@ description("Test AES-CBC encrypt and decrypt functions on a plaintext that is n
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
-var keyData = hexToArrayBuffer("2b7e151628aed2a6abf7158809cf4f3c");
-var iv = hexToArrayBuffer("000102030405060708090a0b0c0d0e0f");
-var plaintext = asciiToArrayBuffer("test");
+var keyData = hexStringToUint8Array("2b7e151628aed2a6abf7158809cf4f3c");
+var iv = hexStringToUint8Array("000102030405060708090a0b0c0d0e0f");
+var plaintext = asciiToUint8Array("test");
 var extractable = true;
 
 debug("Importing a raw AES key from string literal...");
@@ -33,7 +30,8 @@ crypto.subtle.importKey("raw", keyData, "aes-cbc", extractable, ["encrypt", "dec
     debug("Using the key to encrypt plaintext...");
     return crypto.subtle.encrypt({name: "aes-cbc", iv: iv}, key, [plaintext]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    cyphertext = result;
+    shouldBe("bytesToHexString(new Uint8Array(cyphertext))", "'630199c5f202cc7167bb84c6c72b349d'");
 
     debug("Decrypting it back...");
     return crypto.subtle.decrypt({name: "aes-cbc", iv: iv}, key, [result]);
index c387b6f..1018fd7 100644 (file)
@@ -13,12 +13,9 @@ description("Test AES-CBC encrypt and decrypt functions.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
-var keyData = hexToArrayBuffer("2b7e151628aed2a6abf7158809cf4f3c");
-var iv = hexToArrayBuffer("000102030405060708090a0b0c0d0e0f");
-var plaintext = hexToArrayBuffer("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
+var keyData = hexStringToUint8Array("2b7e151628aed2a6abf7158809cf4f3c");
+var iv = hexStringToUint8Array("000102030405060708090a0b0c0d0e0f");
+var plaintext = hexStringToUint8Array("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
 var extractable = true;
 
 debug("Importing a raw AES key from string literal...");
@@ -34,7 +31,7 @@ crypto.subtle.importKey("raw", keyData, "aes-cbc", extractable, ["encrypt", "dec
     return crypto.subtle.encrypt({name: "aes-cbc", iv: iv}, key, [plaintext]);
 }).then(function(result) {
     encryptionResult = result;
-    shouldBe("byteArrayToHexString(new Uint8Array(encryptionResult))", "'[76 49 ab ac 81 19 b2 46 ce e9 8e 9b 12 e9 19 7d 50 86 cb 9b 50 72 19 ee 95 db 11 3a 91 76 78 b2 73 be d6 b8 e3 c1 74 3b 71 16 e6 9e 22 22 95 16 3f f1 ca a1 68 1f ac 09 12 0e ca 30 75 86 e1 a7 8c b8 28 07 23 0e 13 21 d3 fa e0 0d 18 cc 20 12]'");
+    shouldBe("bytesToHexString(new Uint8Array(encryptionResult))", "'7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a78cb82807230e1321d3fae00d18cc2012'");
 
     debug("Decrypting it back...");
     return crypto.subtle.decrypt({name: "aes-cbc", iv: iv}, key, [result]);
index b35d7ad..3abe34b 100644 (file)
@@ -13,9 +13,6 @@ description("Test generating an AES key using AES-CBC algorithm.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 var extractable = true;
 
 shouldThrow('crypto.subtle.generateKey("aes-cbc", extractable, ["encrypt", "decrypt"])');
index 22c4a4b..59f62cc 100644 (file)
@@ -12,7 +12,7 @@ PASS key.algorithm.length is 192
 PASS key.usages is ["encrypt"]
 
 Using the key to encrypt plaintext...
-PASS byteArrayToHexString(new Uint8Array(encryptionResult)) is '[4f 02 1d b2 43 bc 63 3d 71 78 18 3a 9f a0 71 e8 b4 d9 ad a9 ad 7d ed f4 e5 e7 38 76 3f 69 14 5a 57 1b 24 20 12 fb 7a e0 7f a9 ba ac 3d f1 02 e0 08 b0 e2 79 88 59 88 81 d9 20 a9 e6 4f 56 15 cd 61 2c cd 79 22 4b 35 09 35 d4 5d d6 a9 8f 81 76]'
+PASS bytesToHexString(new Uint8Array(encryptionResult)) is '4f021db243bc633d7178183a9fa071e8b4d9ada9ad7dedf4e5e738763f69145a571b242012fb7ae07fa9baac3df102e008b0e27988598881d920a9e64f5615cd612ccd79224b350935d45dd6a98f8176'
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 1a132a5..30283a4 100644 (file)
@@ -13,13 +13,10 @@ description("Test importing a JWK key for AES-CBC.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 var extractable = true;
 
-var iv = hexToArrayBuffer("000102030405060708090a0b0c0d0e0f");
-var plaintext = hexToArrayBuffer("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
+var iv = hexStringToUint8Array("000102030405060708090a0b0c0d0e0f");
+var plaintext = hexStringToUint8Array("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
 
 var jwkKey = {
     "kty": "oct",
@@ -29,7 +26,7 @@ var jwkKey = {
     "k": "jnOw99oOZFLIEPMrgJB55WL46tJSLGt7"
 };
 
-var jwkKeyAsArrayBuffer = asciiToArrayBuffer(JSON.stringify(jwkKey));
+var jwkKeyAsArrayBuffer = asciiToUint8Array(JSON.stringify(jwkKey));
 
 debug("Importing a key...\n");
 crypto.subtle.importKey("jwk", jwkKeyAsArrayBuffer, null, false, ["encrypt"]).then(function(result) {
@@ -45,7 +42,7 @@ crypto.subtle.importKey("jwk", jwkKeyAsArrayBuffer, null, false, ["encrypt"]).th
     return crypto.subtle.encrypt({name: "aes-cbc", iv: iv}, key, [plaintext]);
 }).then(function(result) {
     encryptionResult = result;
-    shouldBe("byteArrayToHexString(new Uint8Array(encryptionResult))", "'[4f 02 1d b2 43 bc 63 3d 71 78 18 3a 9f a0 71 e8 b4 d9 ad a9 ad 7d ed f4 e5 e7 38 76 3f 69 14 5a 57 1b 24 20 12 fb 7a e0 7f a9 ba ac 3d f1 02 e0 08 b0 e2 79 88 59 88 81 d9 20 a9 e6 4f 56 15 cd 61 2c cd 79 22 4b 35 09 35 d4 5d d6 a9 8f 81 76]'");
+    shouldBe("bytesToHexString(new Uint8Array(encryptionResult))", "'4f021db243bc633d7178183a9fa071e8b4d9ada9ad7dedf4e5e738763f69145a571b242012fb7ae07fa9baac3df102e008b0e27988598881d920a9e64f5615cd612ccd79224b350935d45dd6a98f8176'");
     finishJSTest();
 });
 </script>
index 4fa7214..a1974bd 100644 (file)
@@ -1,5 +1,17 @@
-CONSOLE MESSAGE: line 38: SyntaxError: Unexpected identifier 'finishJSTest'. Expected ')' to end a argument list.
-FAIL successfullyParsed should be true (of type boolean). Was undefined (of type undefined).
+Test an unsupported AES key length.
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+Importing a raw AES key from string literal...
+PASS key.type is 'secret'
+PASS key.extractable is true
+PASS key.algorithm.name is 'aes-cbc'
+PASS key.algorithm.length is 176
+PASS key.usages is ['encrypt', 'decrypt']
+Using the key to encrypt plaintext...
+Failed, as expected. Note that the spec doesn't appear to clearly define which step should fail.
+PASS successfullyParsed is true
 
 TEST COMPLETE
 
index 0a215c2..d8de0bd 100644 (file)
@@ -13,12 +13,9 @@ description("Test an unsupported AES key length.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
-var keyData = hexToArrayBuffer("8e73b0f7da0e6452c810f32b809079e562f8ead2522c");
-var iv = hexToArrayBuffer("000102030405060708090a0b0c0d0e0f");
-var plaintext = hexToArrayBuffer("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
+var keyData = hexStringToUint8Array("8e73b0f7da0e6452c810f32b809079e562f8ead2522c");
+var iv = hexStringToUint8Array("000102030405060708090a0b0c0d0e0f");
+var plaintext = hexStringToUint8Array("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
 var extractable = true;
 
 debug("Importing a raw AES key from string literal...");
@@ -33,7 +30,7 @@ crypto.subtle.importKey("raw", keyData, "aes-cbc", extractable, ["encrypt", "dec
     debug("Using the key to encrypt plaintext...");
     return crypto.subtle.encrypt({name: "aes-cbc", iv: iv}, key, [plaintext]);
 }).then(undefined, function(result) {
-    debug("Failed, as expected. Note that the spec doesn't appear to clearly define which step should fail."
+    debug("Failed, as expected. Note that the spec doesn't appear to clearly define which step should fail.");
 
     finishJSTest();
 });
index eeb733c..94299b4 100644 (file)
@@ -13,12 +13,9 @@ description("Test calling AES-CBC encrypt with a HMAC key.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
-var iv = hexToArrayBuffer("000102030405060708090a0b0c0d0e0f");
-var plaintext = hexToArrayBuffer("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
-var hmacKey = asciiToArrayBuffer('a');
+var iv = hexStringToUint8Array("000102030405060708090a0b0c0d0e0f");
+var plaintext = hexStringToUint8Array("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710");
+var hmacKey = asciiToUint8Array('a');
 var extractable = true;
 
 debug("Importing a raw HMAC key from string literal...");
index 618514c..0082cbf 100644 (file)
@@ -5,7 +5,7 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 Importing a JWK key...
 Exporting the key as raw data...
-PASS byteArrayToHexString(new Uint8Array(exportedData)) is '[8e 73 b0 f7 da 0e 64 52 c8 10 f3 2b 80 90 79 e5 62 f8 ea d2 52 2c 6b 7b]'
+PASS bytesToHexString(new Uint8Array(exportedData)) is '8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b'
 PASS successfullyParsed is true
 
 TEST COMPLETE
index e49c88a..319b86a 100644 (file)
@@ -13,9 +13,6 @@ description("Test exporting an AES key.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 var extractable = true;
 
 var jwkKey = {
@@ -23,7 +20,7 @@ var jwkKey = {
     "k": "jnOw99oOZFLIEPMrgJB55WL46tJSLGt7"
 };
 
-var jwkKeyAsArrayBuffer = asciiToArrayBuffer(JSON.stringify(jwkKey));
+var jwkKeyAsArrayBuffer = asciiToUint8Array(JSON.stringify(jwkKey));
 
 debug("Importing a JWK key...");
 crypto.subtle.importKey("jwk", jwkKeyAsArrayBuffer, "AES-CBC", extractable, []).then(function(result) {
@@ -33,7 +30,7 @@ crypto.subtle.importKey("jwk", jwkKeyAsArrayBuffer, "AES-CBC", extractable, []).
     return crypto.subtle.exportKey("raw", key);
 }).then(function(result) {
     exportedData = result;
-    shouldBe("byteArrayToHexString(new Uint8Array(exportedData))", "'[8e 73 b0 f7 da 0e 64 52 c8 10 f3 2b 80 90 79 e5 62 f8 ea d2 52 2c 6b 7b]'");
+    shouldBe("bytesToHexString(new Uint8Array(exportedData))", "'8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b'");
 
     finishJSTest();
 });
index aa618f7..c219dfa 100644 (file)
@@ -4,7 +4,7 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 
 SHA1 of new Uint8Array([]))
-    = [da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 90 af d8 07 09]
+PASS bytesToHexString(new Uint8Array(digest)) is 'da39a3ee5e6b4b0d3255bfef95601890afd80709'
 
 Passing algorithm name as a string object...
 PASS ...succeeded
index 46a4485..d3f589b 100644 (file)
@@ -13,16 +13,15 @@ description("Test crypto.subtle argument conversion");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 Promise.fulfill(null).then(function() {
     // This looks like invalid input, but it actually isn't - Uint8Array is a sequence too,
     // so it's just an empty sequence, same as passing [].
     debug("SHA1 of new Uint8Array([]))");
     return crypto.subtle.digest('sha-1', new Uint8Array([]));
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'da39a3ee5e6b4b0d3255bfef95601890afd80709'");
+
     debug("\nPassing algorithm name as a string object...");
     return crypto.subtle.digest(new String('sha-1'), []);
 }).then(function(result) {
index b98e6b1..f2cd46d 100644 (file)
@@ -5,7 +5,7 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 Importing a JWK key...
 Exporting the key as raw data...
-PASS byteArrayToHexString(new Uint8Array(exportedData)) is '[6a 18 e4 9f ef f7 f3 b7 e0 9e c8 9b 7f 6d ea b2 f6 a1 8e 49 fe ff 7f 3b 7e 09 ec 89 b7 f6 de ab]'
+PASS bytesToHexString(new Uint8Array(exportedData)) is '6a18e49feff7f3b7e09ec89b7f6deab2f6a18e49feff7f3b7e09ec89b7f6deab'
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 4c82e96..b59568a 100644 (file)
@@ -13,9 +13,6 @@ description("Test exporting an AES key.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 var extractable = true;
 
 var jwkKey = {
@@ -23,7 +20,7 @@ var jwkKey = {
     "k": "ahjkn-_387fgnsibf23qsvahjkn-_387fgnsibf23qs"
 };
 
-var jwkKeyAsArrayBuffer = asciiToArrayBuffer(JSON.stringify(jwkKey));
+var jwkKeyAsArrayBuffer = asciiToUint8Array(JSON.stringify(jwkKey));
 
 debug("Importing a JWK key...");
 crypto.subtle.importKey("jwk", jwkKeyAsArrayBuffer, { name: "HMAC", hash: "SHA-512" }, extractable, ["sign", "verify"]).then(function(result) {
@@ -33,7 +30,7 @@ crypto.subtle.importKey("jwk", jwkKeyAsArrayBuffer, { name: "HMAC", hash: "SHA-5
     return crypto.subtle.exportKey("raw", key);
 }).then(function(result) {
     exportedData = result;
-    shouldBe("byteArrayToHexString(new Uint8Array(exportedData))", "'[6a 18 e4 9f ef f7 f3 b7 e0 9e c8 9b 7f 6d ea b2 f6 a1 8e 49 fe ff 7f 3b 7e 09 ec 89 b7 f6 de ab]'");
+    shouldBe("bytesToHexString(new Uint8Array(exportedData))", "'6a18e49feff7f3b7e09ec89b7f6deab2f6a18e49feff7f3b7e09ec89b7f6deab'");
 
     finishJSTest();
 });
index 0bf261e..ac092e7 100644 (file)
@@ -13,9 +13,6 @@ description("Test generating a HMAC key.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 var extractable = true;
 
 shouldThrow('crypto.subtle.generateKey("hmac", extractable, ["sign", "verify"])');
index 01b0053..758d827 100644 (file)
@@ -12,7 +12,7 @@ PASS key.algorithm.length is 32
 PASS key.usages is ["sign", "verify"]
 
 Using the key to sign message 'foo'...
-PASS byteArrayToHexString(new Uint8Array(signature)) is '[e0 37 36 fe 09 88 92 b2 a2 da 77 81 24 31 f7 c0 14 d3 2e 2f d6 9f 3b cf f8 83 ac 92 3a 8f a2 da]'
+PASS bytesToHexString(new Uint8Array(signature)) is 'e03736fe098892b2a2da77812431f7c014d32e2fd69f3bcff883ac923a8fa2da'
 
 Verifying the signature...
 PASS verificationResult is true
index 8f6f1bb..a9352a0 100644 (file)
@@ -13,9 +13,6 @@ description("Test importing a JWK key for HMAC.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 var extractable = true;
 
 var hmacKey = {
@@ -26,7 +23,7 @@ var hmacKey = {
     "k": "ahjkn-_387fgnsibf23qsvahjkn-_387fgnsibf23qs"
 };
 
-var hmacKeyAsArrayBuffer = asciiToArrayBuffer(JSON.stringify(hmacKey));
+var hmacKeyAsArrayBuffer = asciiToUint8Array(JSON.stringify(hmacKey));
 
 debug("Importing a key...\n");
 crypto.subtle.importKey("jwk", hmacKeyAsArrayBuffer, null, extractable, ["sign", "verify"]).then(function(result) {
@@ -39,13 +36,13 @@ crypto.subtle.importKey("jwk", hmacKeyAsArrayBuffer, null, extractable, ["sign",
     shouldBe("key.usages", '["sign", "verify"]');
 
     debug("\nUsing the key to sign message 'foo'...");
-    return crypto.subtle.sign(key.algorithm, key, [asciiToArrayBuffer('foo')]);
+    return crypto.subtle.sign(key.algorithm, key, [asciiToUint8Array('foo')]);
 }).then(function(result) {
     signature = result;
-    shouldBe("byteArrayToHexString(new Uint8Array(signature))", "'[e0 37 36 fe 09 88 92 b2 a2 da 77 81 24 31 f7 c0 14 d3 2e 2f d6 9f 3b cf f8 83 ac 92 3a 8f a2 da]'");
+    shouldBe("bytesToHexString(new Uint8Array(signature))", "'e03736fe098892b2a2da77812431f7c014d32e2fd69f3bcff883ac923a8fa2da'");
 
     debug("\nVerifying the signature...");
-    return crypto.subtle.verify(key.algorithm, key, result, [asciiToArrayBuffer('foo')]);
+    return crypto.subtle.verify(key.algorithm, key, result, [asciiToUint8Array('foo')]);
 }).then(function(result) {
     verificationResult = result;
     shouldBe("verificationResult", "true");
index efaeffc..4a9afcc 100644 (file)
@@ -11,7 +11,7 @@ PASS key.algorithm.length is 0
 PASS key.algorithm.hash.name is 'sha-1'
 PASS key.usages is ['sign', 'verify']
 Using the key to sign 'foo'...
-PASS byteArrayToHexString(new Uint8Array(signature)) is '[a3 cc 77 0f c0 33 e2 cb 41 9d 42 b6 4e 00 81 a3 bd 3b e3 0e]'
+PASS bytesToHexString(new Uint8Array(signature)) is 'a3cc770fc033e2cb419d42b64e0081a3bd3be30e'
 Verifying the signature...
 PASS verificationResult is true
 PASS successfullyParsed is true
index c6efc76..4cac349 100644 (file)
@@ -13,10 +13,7 @@ description("Test HMAC sign and verify functions with an empty key.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
-var hmacKey = asciiToArrayBuffer('');
+var hmacKey = asciiToUint8Array('');
 var extractable = true;
 
 debug("Importing a raw HMAC key from string literal...");
@@ -30,13 +27,13 @@ crypto.subtle.importKey("raw", hmacKey, {name: 'hmac', hash: {name: 'sha-1'}}, e
     shouldBe("key.usages", "['sign', 'verify']");
 
     debug("Using the key to sign 'foo'...");
-    return crypto.subtle.sign(key.algorithm, key, [asciiToArrayBuffer('foo')]);
+    return crypto.subtle.sign(key.algorithm, key, [asciiToUint8Array('foo')]);
 }).then(function(result) {
     signature = result;
-    shouldBe("byteArrayToHexString(new Uint8Array(signature))", "'[a3 cc 77 0f c0 33 e2 cb 41 9d 42 b6 4e 00 81 a3 bd 3b e3 0e]'");
+    shouldBe("bytesToHexString(new Uint8Array(signature))", "'a3cc770fc033e2cb419d42b64e0081a3bd3be30e'");
 
     debug("Verifying the signature...");
-    return crypto.subtle.verify(key.algorithm, key, result, [asciiToArrayBuffer('foo')]);
+    return crypto.subtle.verify(key.algorithm, key, result, [asciiToUint8Array('foo')]);
 }).then(function(result) {
     verificationResult = result;
     shouldBe("verificationResult", "true");
index 75497a7..299493d 100644 (file)
@@ -11,7 +11,7 @@ PASS key.algorithm.length is 1
 PASS key.algorithm.hash.name is 'sha-1'
 PASS key.usages is ['sign', 'verify']
 Using the key to sign 'foo'...
-    = [be bb c0 2e 46 b0 f8 11 83 f4 0c 25 dc e2 3e 50 45 d6 55 19]
+PASS bytesToHexString(new Uint8Array(signature)) is 'bebbc02e46b0f81183f40c25dce23e5045d65519'
 Verifying the signature...
 PASS verificationResult is true
 PASS successfullyParsed is true
index 705f9ca..422d767 100644 (file)
@@ -13,10 +13,7 @@ description("Test HMAC sign and verify functions.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
-var hmacKey = asciiToArrayBuffer('a');
+var hmacKey = asciiToUint8Array('a');
 var extractable = true;
 
 debug("Importing a raw HMAC key from string literal...");
@@ -30,12 +27,13 @@ crypto.subtle.importKey("raw", hmacKey, {name: 'hmac', hash: {name: 'sha-1'}}, e
     shouldBe("key.usages", "['sign', 'verify']");
 
     debug("Using the key to sign 'foo'...");
-    return crypto.subtle.sign(key.algorithm, key, [asciiToArrayBuffer('foo')]);
+    return crypto.subtle.sign(key.algorithm, key, [asciiToUint8Array('foo')]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    signature = result;
+    shouldBe("bytesToHexString(new Uint8Array(signature))", "'bebbc02e46b0f81183f40c25dce23e5045d65519'");
 
     debug("Verifying the signature...");
-    return crypto.subtle.verify(key.algorithm, key, result, [asciiToArrayBuffer('foo')]);
+    return crypto.subtle.verify(key.algorithm, key, result, [asciiToUint8Array('foo')]);
 }).then(function(result) {
     verificationResult = result;
     shouldBe("verificationResult", "true");
index 90445d0..4ddc332 100644 (file)
@@ -3,27 +3,27 @@ Test error handling for JWK import.
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer(''), null) threw exception TypeError: Invalid JWK serialization.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{'), null) threw exception TypeError: Invalid JWK serialization.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('null'), null) threw exception TypeError: Invalid JWK serialization.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('undefined'), null) threw exception TypeError: Invalid JWK serialization.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{}'), null) threw exception TypeError: Neither key nor function argument has crypto algorithm specified.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{}'), "aes-cbc") threw exception TypeError: Required JWK "kty" member is missing.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "foobar", "alg": "HS256", "use": "sig", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Unsupported JWK key type foobar.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "foobar", "use": "sig", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Unsupported JWK algorithm foobar.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), "aes-cbc") threw exception TypeError: Algorithm specified in key is not compatible with one passed to importKey as argument.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), { name: "hmac", hash: "sha-1" }) threw exception TypeError: Algorithm specified in key is not compatible with one passed to importKey as argument.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "HS256" }'), null) threw exception TypeError: Secret key data is not present is JWK.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "A128CBC" }'), null) threw exception TypeError: Secret key data is not present is JWK.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "1234" }'), null) threw exception TypeError: Key size is not valid for HS256.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "A128CBC", "use": "sig", "extractable": false, "k": "1234" }'), null) threw exception TypeError: Key size is not valid for A128CBC.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "A128CBC", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Key size is not valid for A128CBC.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387f+nsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Cannot decode base64url key data in JWK.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": 1, "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Expected a string value for "kty" JSON key.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": 1, "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Expected a string value for "alg" JSON key.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "HS256", "use": 1, "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Expected a string value for "use" JSON key.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": "false", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Expected a boolean value for "extractable" JSON key.
-PASS crypto.subtle.importKey("jwk", asciiToArrayBuffer('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": 1 }'), null) threw exception TypeError: Expected a string value for "k" JSON key.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array(''), null) threw exception TypeError: Invalid JWK serialization.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{'), null) threw exception TypeError: Invalid JWK serialization.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('null'), null) threw exception TypeError: Invalid JWK serialization.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('undefined'), null) threw exception TypeError: Invalid JWK serialization.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{}'), null) threw exception TypeError: Neither key nor function argument has crypto algorithm specified.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{}'), "aes-cbc") threw exception TypeError: Required JWK "kty" member is missing.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "foobar", "alg": "HS256", "use": "sig", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Unsupported JWK key type foobar.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "foobar", "use": "sig", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Unsupported JWK algorithm foobar.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), "aes-cbc") threw exception TypeError: Algorithm specified in key is not compatible with one passed to importKey as argument.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), { name: "hmac", hash: "sha-1" }) threw exception TypeError: Algorithm specified in key is not compatible with one passed to importKey as argument.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "HS256" }'), null) threw exception TypeError: Secret key data is not present is JWK.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "A128CBC" }'), null) threw exception TypeError: Secret key data is not present is JWK.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "1234" }'), null) threw exception TypeError: Key size is not valid for HS256.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "A128CBC", "use": "sig", "extractable": false, "k": "1234" }'), null) threw exception TypeError: Key size is not valid for A128CBC.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "A128CBC", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Key size is not valid for A128CBC.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387f+nsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Cannot decode base64url key data in JWK.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": 1, "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Expected a string value for "kty" JSON key.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": 1, "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Expected a string value for "alg" JSON key.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "HS256", "use": 1, "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Expected a string value for "use" JSON key.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": "false", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }'), null) threw exception TypeError: Expected a boolean value for "extractable" JSON key.
+PASS crypto.subtle.importKey("jwk", asciiToUint8Array('{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": 1 }'), null) threw exception TypeError: Expected a string value for "k" JSON key.
 PASS successfullyParsed is true
 
 TEST COMPLETE
index af542eb..cf27cf7 100644 (file)
 <script>
 description("Test error handling for JWK import.");
 
-//jsTestIsAsync = true;
-
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'null\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'undefined\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{}\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{}\'), "aes-cbc")')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'null\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'undefined\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{}\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{}\'), "aes-cbc")')
 
 // Unknown/invalid JWK values.
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "foobar", "alg": "HS256", "use": "sig", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "foobar", "use": "sig", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "foobar", "alg": "HS256", "use": "sig", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "foobar", "use": "sig", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
 
 // Algorithm mismatch.
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), "aes-cbc")')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), { name: "hmac", hash: "sha-1" })')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), "aes-cbc")')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), { name: "hmac", hash: "sha-1" })')
 
 // No key data.
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "HS256" }\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "A128CBC" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "HS256" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "A128CBC" }\'), null)')
 
 // Key data length is incorrect, not allowed in JWK.
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "1234" }\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "A128CBC", "use": "sig", "extractable": false, "k": "1234" }\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "A128CBC", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "1234" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "A128CBC", "use": "sig", "extractable": false, "k": "1234" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "A128CBC", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
 
 // Key data is not valid base64url.
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387f+nsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387f+nsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
 
 // Incorrect data types.
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": 1, "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": 1, "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "HS256", "use": 1, "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": "false", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
-shouldThrow('crypto.subtle.importKey("jwk", asciiToArrayBuffer(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": 1 }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": 1, "alg": "HS256", "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": 1, "use": "sig", "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "HS256", "use": 1, "extractable": false, "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": "false", "k": "ahjkn23387fgnsibf23qsvahjkn37387fgnsibf23qs" }\'), null)')
+shouldThrow('crypto.subtle.importKey("jwk", asciiToUint8Array(\'{ "kty": "oct", "alg": "HS256", "use": "sig", "extractable": false, "k": 1 }\'), null)')
 </script>
 
 <script src="../../resources/js-test-post.js"></script>
index 8a40f42..cca5a74 100644 (file)
@@ -1,30 +1,47 @@
 function importTestKeys()
 {
-    var keyFormat = "spki";
-    var data = new Uint8Array([]);
-    var extractable = false;
+    var keyFormat = "raw";
+    var data = asciiToUint8Array("16 bytes of key!");
+    var extractable = true;
     var keyUsages = ['encrypt', 'decrypt', 'sign', 'verify'];
 
     var hmacPromise = crypto.subtle.importKey(keyFormat, data, {name: 'hmac', hash: {name: 'sha-1'}}, extractable, keyUsages);
-    var rsaSsaPromise = crypto.subtle.importKey(keyFormat, data, {name: 'RSASSA-PKCS1-v1_5', hash: {name: 'sha-1'}}, extractable, keyUsages);
     var aesCbcPromise = crypto.subtle.importKey(keyFormat, data, {name: 'AES-CBC'}, extractable, keyUsages);
-    var aesCbcJustDecrypt = crypto.subtle.importKey(keyFormat, data, {name: 'AES-CBC'}, extractable, ['decrypt']);
+    var aesCbcJustDecrypt = crypto.subtle.importKey(keyFormat, data, {name: 'AES-CBC'}, false, ['decrypt']);
 
-    return Promise.every(hmacPromise, rsaSsaPromise, aesCbcPromise, aesCbcJustDecrypt).then(function(results) {
+    return Promise.all([hmacPromise, aesCbcPromise, aesCbcJustDecrypt]).then(function(results) {
         return {
             hmacSha1: results[0],
-            rsaSsaSha1: results[1],
-            aesCbc: results[2],
-            aesCbcJustDecrypt: results[3],
+            aesCbc: results[1],
+            aesCbcJustDecrypt: results[2],
         };
     });
 }
 
-// Builds a hex string representation of any array-like input (array or
-// ArrayBufferView). The output looks like this:
-//    [ab 03 4c 99]
-function byteArrayToHexString(bytes)
+// Verifies that the given "bytes" holds the same value as "expectedHexString".
+// "bytes" can be anything recognized by "bytesToHexString()".
+function bytesShouldMatchHexString(testDescription, expectedHexString, bytes)
 {
+    expectedHexString = "[" + expectedHexString.toLowerCase() + "]";
+    var actualHexString = "[" + bytesToHexString(bytes) + "]";
+
+    if (actualHexString === expectedHexString) {
+        debug("PASS: " + testDescription + " should be " + expectedHexString + " and was");
+    } else {
+        debug("FAIL: " + testDescription + " should be " + expectedHexString + " but was " + actualHexString);
+    }
+}
+
+// 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) {
@@ -34,10 +51,26 @@ function byteArrayToHexString(bytes)
         hexBytes.push(byteString);
     }
 
-    return "[" + hexBytes.join(" ") + "]";
+    return hexBytes.join("");
 }
 
-function asciiToArrayBuffer(str)
+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;
+}
+
+function asciiToUint8Array(str)
 {
     var chars = [];
     for (var i = 0; i < str.length; ++i)
@@ -45,14 +78,11 @@ function asciiToArrayBuffer(str)
     return new Uint8Array(chars);
 }
 
-function hexToArrayBuffer(str)
+function failAndFinishJSTest(error)
 {
-    if (str.length % 2)
-        throw "Hex string length must be even";
-    var chars = [];
-    for (var i = 0; i < str.length; i += 2)
-        chars.push(parseInt(str.substr(i, 2), 16));
-    return new Uint8Array(chars);
+    if (error)
+       debug(error);
+    finishJSTest();
 }
 
 var Base64URL = {
@@ -66,19 +96,23 @@ var Base64URL = {
     }
 };
 
-function printRejectedResult(value)
-{
-    debug("    rejected with value of " + value);
-}
-
-function printAcceptedResult(result)
-{
-    debug("    = " + byteArrayToHexString(new Uint8Array(result)));
+if (!Promise.all) {
+    // A very simple temporary implementation only for WebCrypto tests.
+    Promise.all = function(promises) {
+        var results = [];
+        var resultCount = 0;
+        var resolver;
+        function next(result) {
+            results[resultCount++] = result;
+            if (resultCount < promises.length)
+                promises[resultCount].then(next);
+            else
+                resolver.fulfill(results);
+        }
+        promises[0].then(next, function() { resolver.reject(null) });
+        return new Promise(function(r) { resolver = r; });
+    }
 }
 
-function failAndFinishJSTest(error)
-{
-    if (error)
-       debug(error);
-    finishJSTest();
-}
+if (!crypto.subtle)
+    crypto.subtle = crypto.webkitSubtle;
index fe03780..a50d76e 100644 (file)
@@ -8,12 +8,12 @@ PASS keyPair.toString() is '[object KeyPair]'
 PASS keyPair.publicKey.type is 'public'
 PASS keyPair.publicKey.algorithm.name is 'rsassa-pkcs1-v1_5'
 PASS keyPair.publicKey.algorithm.modulusLength is 2048
-PASS byteArrayToHexString(keyPair.publicKey.algorithm.publicExponent) is '[01 00 01]'
+PASS bytesToHexString(keyPair.publicKey.algorithm.publicExponent) is '010001'
 PASS keyPair.publicKey.algorithm.hash is undefined.
 PASS keyPair.privateKey.type is 'private'
 PASS keyPair.privateKey.algorithm.name is 'rsassa-pkcs1-v1_5'
 PASS keyPair.privateKey.algorithm.modulusLength is 2048
-PASS byteArrayToHexString(keyPair.privateKey.algorithm.publicExponent) is '[01 00 01]'
+PASS bytesToHexString(keyPair.privateKey.algorithm.publicExponent) is '010001'
 PASS keyPair.privateKey.algorithm.hash is undefined.
 
 Testing that custom attributes on keys survive garbage collection...
index 5ba6ccc..fd38a8f 100644 (file)
@@ -13,9 +13,6 @@ description("Test generating an RSA key pair for RSASSA-PKCS1-v1_5.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 var algorithmKeyGen = {
     name: "RSASSA-PKCS1-v1_5",
     // RsaKeyGenParams
@@ -31,12 +28,12 @@ crypto.subtle.generateKey(algorithmKeyGen, extractable, ["sign", "verify"]).then
     shouldBe("keyPair.publicKey.type", "'public'");
     shouldBe("keyPair.publicKey.algorithm.name", "'rsassa-pkcs1-v1_5'");
     shouldBe("keyPair.publicKey.algorithm.modulusLength", "2048");
-    shouldBe("byteArrayToHexString(keyPair.publicKey.algorithm.publicExponent)", "'[01 00 01]'");
+    shouldBe("bytesToHexString(keyPair.publicKey.algorithm.publicExponent)", "'010001'");
     shouldBeUndefined("keyPair.publicKey.algorithm.hash");
     shouldBe("keyPair.privateKey.type", "'private'");
     shouldBe("keyPair.privateKey.algorithm.name", "'rsassa-pkcs1-v1_5'");
     shouldBe("keyPair.privateKey.algorithm.modulusLength", "2048");
-    shouldBe("byteArrayToHexString(keyPair.privateKey.algorithm.publicExponent)", "'[01 00 01]'");
+    shouldBe("bytesToHexString(keyPair.privateKey.algorithm.publicExponent)", "'010001'");
     shouldBeUndefined("keyPair.privateKey.algorithm.hash");
 
     debug("\nTesting that custom attributes on keys survive garbage collection...");
index 963a9ed..1c8dd03 100644 (file)
@@ -9,7 +9,7 @@ PASS publicKey.type is 'public'
 PASS publicKey.usages is ['sign','verify']
 PASS publicKey.algorithm.name is 'rsassa-pkcs1-v1_5'
 PASS publicKey.algorithm.modulusLength is 2048
-PASS byteArrayToHexString(publicKey.algorithm.publicExponent) is '[01 00 01]'
+PASS bytesToHexString(publicKey.algorithm.publicExponent) is '010001'
 PASS publicKey.algorithm.hash.name is 'sha-256'
 
 Importing a private key...
@@ -18,7 +18,7 @@ PASS privateKey.type is 'private'
 PASS privateKey.usages is ['sign','verify']
 PASS privateKey.algorithm.name is 'rsassa-pkcs1-v1_5'
 PASS privateKey.algorithm.modulusLength is 2048
-PASS byteArrayToHexString(privateKey.algorithm.publicExponent) is '[01 00 01]'
+PASS bytesToHexString(privateKey.algorithm.publicExponent) is '010001'
 PASS privateKey.algorithm.hash.name is 'sha-256'
 PASS successfullyParsed is true
 
index 34f7306..7220aa3 100644 (file)
@@ -13,9 +13,6 @@ description("Test importing an RSA key for RSASSA-PKCS1-v1_5.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 var extractable = true;
 
 var publicKeyJSON = {
@@ -39,17 +36,17 @@ var privateKeyJSON = {
 };
 
 debug("Importing a public key...");
-crypto.subtle.importKey("jwk", asciiToArrayBuffer(JSON.stringify(publicKeyJSON)), null, extractable, ["sign", "verify"]).then(function(result) {
+crypto.subtle.importKey("jwk", asciiToUint8Array(JSON.stringify(publicKeyJSON)), null, extractable, ["sign", "verify"]).then(function(result) {
     publicKey = result;
     shouldBe("publicKey.toString()", "'[object Key]'");
     shouldBe("publicKey.type", "'public'");
     shouldBe("publicKey.usages", "['sign','verify']");
     shouldBe("publicKey.algorithm.name", "'rsassa-pkcs1-v1_5'");
     shouldBe("publicKey.algorithm.modulusLength", "2048");
-    shouldBe("byteArrayToHexString(publicKey.algorithm.publicExponent)", "'[01 00 01]'");
+    shouldBe("bytesToHexString(publicKey.algorithm.publicExponent)", "'010001'");
     shouldBe("publicKey.algorithm.hash.name", "'sha-256'");
     debug("\nImporting a private key...");
-    return crypto.subtle.importKey("jwk", asciiToArrayBuffer(JSON.stringify(privateKeyJSON)), null, extractable, ["sign", "verify"]);
+    return crypto.subtle.importKey("jwk", asciiToUint8Array(JSON.stringify(privateKeyJSON)), null, extractable, ["sign", "verify"]);
 }).then(function(result) {
     privateKey = result;
     shouldBe("privateKey.toString()", "'[object Key]'");
@@ -57,7 +54,7 @@ crypto.subtle.importKey("jwk", asciiToArrayBuffer(JSON.stringify(publicKeyJSON))
     shouldBe("privateKey.usages", "['sign','verify']");
     shouldBe("privateKey.algorithm.name", "'rsassa-pkcs1-v1_5'");
     shouldBe("privateKey.algorithm.modulusLength", "2048");
-    shouldBe("byteArrayToHexString(privateKey.algorithm.publicExponent)", "'[01 00 01]'");
+    shouldBe("bytesToHexString(privateKey.algorithm.publicExponent)", "'010001'");
     shouldBe("privateKey.algorithm.hash.name", "'sha-256'");
     finishJSTest();
 });
index 1d036f1..3966c86 100644 (file)
@@ -8,7 +8,7 @@ Importing a public key...
 Importing a private key...
 
 Signing some text...
-PASS byteArrayToHexString(new Uint8Array(signature)) is '[0f d9 a8 ae f4 cc 18 76 c0 b7 62 54 53 36 c6 d1 fb 31 5a e1 6a e4 b5 e4 bf 34 d3 84 d8 58 5e a7 a0 1e 76 ea 09 ee 7f 7e e8 d1 c1 22 e7 dd 15 b7 c9 4a 57 3b 2a a0 72 03 e8 d1 3b c6 fd 16 15 6c d8 e5 f0 c1 5a 15 dc cb 62 d1 52 12 7f ca 09 88 2f b5 3b c3 e6 0a b5 86 d1 5b 95 cf 41 1e 3a ab 4a 1c 23 1a 7e 91 aa b0 9e e3 d4 b1 3d 11 e9 75 05 dd ff 77 68 34 70 da 51 0e e7 6e 8b d5 30 c5 6a 85 f9 01 62 6a 5a 71 0f 71 6f 11 3d fe 9c f6 c4 73 ee 16 fa 24 8a ea 34 80 a1 03 3a be 30 f4 c1 24 32 89 a6 61 e6 4d 78 18 b5 56 98 28 06 88 09 71 35 96 8c 6d 4b 02 94 96 d8 5c ab 2a 67 e4 69 67 37 78 1f 70 e4 39 2c 7d f7 1b bd 6c 92 46 59 47 f0 29 a1 de 48 16 0a ce d1 1b 57 21 b1 cd 25 03 9f e2 c1 6c 2b 38 de 73 df 3b 9a 83 e3 ea 75 5f d0 cf e5 1c a0 6b 61 fa df 6d 84 67 7f 95]'
+PASS bytesToHexString(new Uint8Array(signature)) is '0fd9a8aef4cc1876c0b762545336c6d1fb315ae16ae4b5e4bf34d384d8585ea7a01e76ea09ee7f7ee8d1c122e7dd15b7c94a573b2aa07203e8d13bc6fd16156cd8e5f0c15a15dccb62d152127fca09882fb53bc3e60ab586d15b95cf411e3aab4a1c231a7e91aab09ee3d4b13d11e97505ddff77683470da510ee76e8bd530c56a85f901626a5a710f716f113dfe9cf6c473ee16fa248aea3480a1033abe30f4c1243289a661e64d7818b55698280688097135968c6d4b029496d85cab2a67e4696737781f70e4392c7df71bbd6c92465947f029a1de48160aced11b5721b1cd25039fe2c16c2b38de73df3b9a83e3ea755fd0cfe51ca06b61fadf6d84677f95'
 
 Verifying the signature...
 PASS verificationResult is true
index 7451081..86616ef 100644 (file)
@@ -13,45 +13,42 @@ description("Test importing an RSA key for RSASSA-PKCS1-v1_5.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 var extractable = true;
 
 var publicKeyJSON = {
     kty: "RSA",
     alg: "RS256",
-    n: Base64URL.stringify(hexToArrayBuffer("ADC0940AFECE7351D56A6D432210B3AA49D38566B03A9F102E4F198B2DA9D740728D01426A3A058B2B805A5F91D565D969FE318AD2D1ADA713F5A829CC8CDCF8C6CB4872068164063B6D651A2226CB97ED67E0FC6C702A473DB2D79A730F8738084A2EED74922C3A119D1D101B932C0E10FAB36815F66C0792BB640B1B4C59D062FBBEDAB3CC069A535195D70E4A06432CAF149C24A00353A0B99F7CF5B17273CB4E38421BD315127CF4B3DCB3D20A7C98CFAF1A0E398A55E347FA283CE7B39273259B1B2132DC18B0EB8AAE9F78EE525356B09DF39E090E76D7985B2B71E50AF85CA36CE91F8CCB2ABBD8A529D369890D98A2CA2825C4C2FF8B7FBF09E79C0B")),
-    e: Base64URL.stringify(hexToArrayBuffer("010001")),
+    n: Base64URL.stringify(hexStringToUint8Array("ADC0940AFECE7351D56A6D432210B3AA49D38566B03A9F102E4F198B2DA9D740728D01426A3A058B2B805A5F91D565D969FE318AD2D1ADA713F5A829CC8CDCF8C6CB4872068164063B6D651A2226CB97ED67E0FC6C702A473DB2D79A730F8738084A2EED74922C3A119D1D101B932C0E10FAB36815F66C0792BB640B1B4C59D062FBBEDAB3CC069A535195D70E4A06432CAF149C24A00353A0B99F7CF5B17273CB4E38421BD315127CF4B3DCB3D20A7C98CFAF1A0E398A55E347FA283CE7B39273259B1B2132DC18B0EB8AAE9F78EE525356B09DF39E090E76D7985B2B71E50AF85CA36CE91F8CCB2ABBD8A529D369890D98A2CA2825C4C2FF8B7FBF09E79C0B")),
+    e: Base64URL.stringify(hexStringToUint8Array("010001")),
 };
 
 var privateKeyJSON = {
     kty: "RSA",
     alg: "RS256",
-    n: Base64URL.stringify(hexToArrayBuffer("ADC0940AFECE7351D56A6D432210B3AA49D38566B03A9F102E4F198B2DA9D740728D01426A3A058B2B805A5F91D565D969FE318AD2D1ADA713F5A829CC8CDCF8C6CB4872068164063B6D651A2226CB97ED67E0FC6C702A473DB2D79A730F8738084A2EED74922C3A119D1D101B932C0E10FAB36815F66C0792BB640B1B4C59D062FBBEDAB3CC069A535195D70E4A06432CAF149C24A00353A0B99F7CF5B17273CB4E38421BD315127CF4B3DCB3D20A7C98CFAF1A0E398A55E347FA283CE7B39273259B1B2132DC18B0EB8AAE9F78EE525356B09DF39E090E76D7985B2B71E50AF85CA36CE91F8CCB2ABBD8A529D369890D98A2CA2825C4C2FF8B7FBF09E79C0B")),
-    e: Base64URL.stringify(hexToArrayBuffer("010001")),
-    d: Base64URL.stringify(hexToArrayBuffer("78D2D2DFB682CFB45748D3C3FC3B4B049EA3E53F1C4B17734410A33DA23A59C1AA269D7A96ADD44F0BA80CB02A940F681989B6DFC76C216A6EB9C3FF950B5B59EFBB4A9C6823AFEF99819FED85541EFD7E0C5F6A88E992ACC99DC4C9D53B361763C45A4FAB613E39FF27971F2D5DB123F2F0B2B32D9A9752C8D9605F4CD3521C2DB9A86000A3040A16231F61278C7747C3AB18DBEC00A5D71023B50B134A28E51CDB419A66BA170DF618817342F7861174AA8E7499B974DBFEB9FC643B0E95645C1C4D81104BCE53DA6E6CF31B6A0085F79F2E0626482D68A5A0A45C4EAF45640D58D2F8E5164D64560CDEEA0982138CA867A870CD01A63742847ACF3A516F49")),
-    p: Base64URL.stringify(hexToArrayBuffer("E26893B808CA31E1F9B89E4A077F7B414C216E46048126DC0369A27E64A4BC4DB4D7C81BE79AA40472B5795AF27F5FE6E372CD95CE8EFDA93A81FCDD64866F4B93421A33E5D2AD3DA65529BBCA85392B2907003AEEA187EFA9459592E7FDDE328254BBC1F2EBBB8FF962CF2A2CBB3E0EA54BBE2C29A2C3A7CB25AAC0CE405E9D")),
-    q: Base64URL.stringify(hexToArrayBuffer("C4762BCE48AFB669F3FEC19C867586734ABEA433A42A2729B51A6FDA93052085F19C55F968C7845C866356E8D7B70532D5494520DD866494AFCB9289EFD9AEFD7C8D9C51CCCDE747F80DDE7B7BBC875514AD917EBD4BB5FDEE14FF1EBB34DD5D79DCD448ACA737BA459773A4B9284C056195F9CC3338F75C5407D5B9997150C7")),
-    dp: Base64URL.stringify(hexToArrayBuffer("7C1CC3CD80D40660501A8A7B1E7D1DBDFFD3DBB57A46AA5CB56A34EF809065C15B3F66AD155B4A4A3DEF8964F7C62776547CDC8220C775FA4CDE71159443B5C302289C6092BDD8C610E66288554E8EB640395C40F20B8E8F2C85BEA6D791ED3A5703C8215BDF29E494DB3BA16CFFFFD6DB7A17F7F1A30E0A6F6C689C64F41869")),
-    dq: Base64URL.stringify(hexToArrayBuffer("8E61360E220F761C0380B5C042921A06A43CD5B3B75DF553FCB4542C0C30C3094FB90575E3C1F4E33961F5327A6361991D8A2457553478E0692717E46FB74B62DA49A6E8818D17F8C88504A06964908FD09499C5485AFE62319175F347A96064C6548C64BEFBD11F662004E7746907EF3E71FABF4AC016450B81421B6860FF31")),
-    qi: Base64URL.stringify(hexToArrayBuffer("6025FFA4BC1B3010354E1547D167309A7CADA8D72B3021304E6EC1C80D9E53A9D66D0AD42EF7FB9BDFE4CDF2D4723B27A405650501B924C5CCCB44AAE29B706F2C2C6B9F86F0A00E38E4762F7BF8842F84CACF5FB6014CFF78B4A38D1E7901F86F785A3DB9EDAC878C83C23394EB9560A7FDFB642E283A1679175DECDB1DC539"))
+    n: Base64URL.stringify(hexStringToUint8Array("ADC0940AFECE7351D56A6D432210B3AA49D38566B03A9F102E4F198B2DA9D740728D01426A3A058B2B805A5F91D565D969FE318AD2D1ADA713F5A829CC8CDCF8C6CB4872068164063B6D651A2226CB97ED67E0FC6C702A473DB2D79A730F8738084A2EED74922C3A119D1D101B932C0E10FAB36815F66C0792BB640B1B4C59D062FBBEDAB3CC069A535195D70E4A06432CAF149C24A00353A0B99F7CF5B17273CB4E38421BD315127CF4B3DCB3D20A7C98CFAF1A0E398A55E347FA283CE7B39273259B1B2132DC18B0EB8AAE9F78EE525356B09DF39E090E76D7985B2B71E50AF85CA36CE91F8CCB2ABBD8A529D369890D98A2CA2825C4C2FF8B7FBF09E79C0B")),
+    e: Base64URL.stringify(hexStringToUint8Array("010001")),
+    d: Base64URL.stringify(hexStringToUint8Array("78D2D2DFB682CFB45748D3C3FC3B4B049EA3E53F1C4B17734410A33DA23A59C1AA269D7A96ADD44F0BA80CB02A940F681989B6DFC76C216A6EB9C3FF950B5B59EFBB4A9C6823AFEF99819FED85541EFD7E0C5F6A88E992ACC99DC4C9D53B361763C45A4FAB613E39FF27971F2D5DB123F2F0B2B32D9A9752C8D9605F4CD3521C2DB9A86000A3040A16231F61278C7747C3AB18DBEC00A5D71023B50B134A28E51CDB419A66BA170DF618817342F7861174AA8E7499B974DBFEB9FC643B0E95645C1C4D81104BCE53DA6E6CF31B6A0085F79F2E0626482D68A5A0A45C4EAF45640D58D2F8E5164D64560CDEEA0982138CA867A870CD01A63742847ACF3A516F49")),
+    p: Base64URL.stringify(hexStringToUint8Array("E26893B808CA31E1F9B89E4A077F7B414C216E46048126DC0369A27E64A4BC4DB4D7C81BE79AA40472B5795AF27F5FE6E372CD95CE8EFDA93A81FCDD64866F4B93421A33E5D2AD3DA65529BBCA85392B2907003AEEA187EFA9459592E7FDDE328254BBC1F2EBBB8FF962CF2A2CBB3E0EA54BBE2C29A2C3A7CB25AAC0CE405E9D")),
+    q: Base64URL.stringify(hexStringToUint8Array("C4762BCE48AFB669F3FEC19C867586734ABEA433A42A2729B51A6FDA93052085F19C55F968C7845C866356E8D7B70532D5494520DD866494AFCB9289EFD9AEFD7C8D9C51CCCDE747F80DDE7B7BBC875514AD917EBD4BB5FDEE14FF1EBB34DD5D79DCD448ACA737BA459773A4B9284C056195F9CC3338F75C5407D5B9997150C7")),
+    dp: Base64URL.stringify(hexStringToUint8Array("7C1CC3CD80D40660501A8A7B1E7D1DBDFFD3DBB57A46AA5CB56A34EF809065C15B3F66AD155B4A4A3DEF8964F7C62776547CDC8220C775FA4CDE71159443B5C302289C6092BDD8C610E66288554E8EB640395C40F20B8E8F2C85BEA6D791ED3A5703C8215BDF29E494DB3BA16CFFFFD6DB7A17F7F1A30E0A6F6C689C64F41869")),
+    dq: Base64URL.stringify(hexStringToUint8Array("8E61360E220F761C0380B5C042921A06A43CD5B3B75DF553FCB4542C0C30C3094FB90575E3C1F4E33961F5327A6361991D8A2457553478E0692717E46FB74B62DA49A6E8818D17F8C88504A06964908FD09499C5485AFE62319175F347A96064C6548C64BEFBD11F662004E7746907EF3E71FABF4AC016450B81421B6860FF31")),
+    qi: Base64URL.stringify(hexStringToUint8Array("6025FFA4BC1B3010354E1547D167309A7CADA8D72B3021304E6EC1C80D9E53A9D66D0AD42EF7FB9BDFE4CDF2D4723B27A405650501B924C5CCCB44AAE29B706F2C2C6B9F86F0A00E38E4762F7BF8842F84CACF5FB6014CFF78B4A38D1E7901F86F785A3DB9EDAC878C83C23394EB9560A7FDFB642E283A1679175DECDB1DC539"))
 };
 
-var data = asciiToArrayBuffer("Hello, world!");
+var data = asciiToUint8Array("Hello, world!");
 
 debug("Importing a public key...");
-crypto.subtle.importKey("jwk", asciiToArrayBuffer(JSON.stringify(publicKeyJSON)), null, extractable, ["sign", "verify"]).then(function(result) {
+crypto.subtle.importKey("jwk", asciiToUint8Array(JSON.stringify(publicKeyJSON)), null, extractable, ["sign", "verify"]).then(function(result) {
     publicKey = result;
     debug("\nImporting a private key...");
-    return crypto.subtle.importKey("jwk", asciiToArrayBuffer(JSON.stringify(privateKeyJSON)), null, extractable, ["sign", "verify"]);
+    return crypto.subtle.importKey("jwk", asciiToUint8Array(JSON.stringify(privateKeyJSON)), null, extractable, ["sign", "verify"]);
 }).then(function(result) {
     privateKey = result;
     debug("\nSigning some text...");
     return crypto.subtle.sign({ name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" }, privateKey, [data]);
 }).then(function(result) {
     signature = result;
-    shouldBe("byteArrayToHexString(new Uint8Array(signature))", "'[0f d9 a8 ae f4 cc 18 76 c0 b7 62 54 53 36 c6 d1 fb 31 5a e1 6a e4 b5 e4 bf 34 d3 84 d8 58 5e a7 a0 1e 76 ea 09 ee 7f 7e e8 d1 c1 22 e7 dd 15 b7 c9 4a 57 3b 2a a0 72 03 e8 d1 3b c6 fd 16 15 6c d8 e5 f0 c1 5a 15 dc cb 62 d1 52 12 7f ca 09 88 2f b5 3b c3 e6 0a b5 86 d1 5b 95 cf 41 1e 3a ab 4a 1c 23 1a 7e 91 aa b0 9e e3 d4 b1 3d 11 e9 75 05 dd ff 77 68 34 70 da 51 0e e7 6e 8b d5 30 c5 6a 85 f9 01 62 6a 5a 71 0f 71 6f 11 3d fe 9c f6 c4 73 ee 16 fa 24 8a ea 34 80 a1 03 3a be 30 f4 c1 24 32 89 a6 61 e6 4d 78 18 b5 56 98 28 06 88 09 71 35 96 8c 6d 4b 02 94 96 d8 5c ab 2a 67 e4 69 67 37 78 1f 70 e4 39 2c 7d f7 1b bd 6c 92 46 59 47 f0 29 a1 de 48 16 0a ce d1 1b 57 21 b1 cd 25 03 9f e2 c1 6c 2b 38 de 73 df 3b 9a 83 e3 ea 75 5f d0 cf e5 1c a0 6b 61 fa df 6d 84 67 7f 95]'");
+    shouldBe("bytesToHexString(new Uint8Array(signature))", "'0fd9a8aef4cc1876c0b762545336c6d1fb315ae16ae4b5e4bf34d384d8585ea7a01e76ea09ee7f7ee8d1c122e7dd15b7c94a573b2aa07203e8d13bc6fd16156cd8e5f0c15a15dccb62d152127fca09882fb53bc3e60ab586d15b95cf411e3aab4a1c231a7e91aab09ee3d4b13d11e97505ddff77683470da510ee76e8bd530c56a85f901626a5a710f716f113dfe9cf6c473ee16fa248aea3480a1033abe30f4c1243289a661e64d7818b55698280688097135968c6d4b029496d85cab2a67e4696737781f70e4392c7df71bbd6c92465947f029a1de48160aced11b5721b1cd25039fe2c16c2b38de73df3b9a83e3ea755fd0cfe51ca06b61fadf6d84677f95'");
 
     debug("\nVerifying the signature...");
     return crypto.subtle.verify({ name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" }, publicKey, signature, [data]);
index 297110f..c27dce2 100644 (file)
@@ -4,13 +4,13 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 
 SHA1 of []
-    = [da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 90 af d8 07 09]
+PASS bytesToHexString(new Uint8Array(digest)) is 'da39a3ee5e6b4b0d3255bfef95601890afd80709'
 SHA1 of [0x0]
-    = [5b a9 3c 9d b0 cf f9 3f 52 b5 21 d7 42 0e 43 f6 ed a2 78 4f]
+PASS bytesToHexString(new Uint8Array(digest)) is '5ba93c9db0cff93f52b521d7420e43f6eda2784f'
 SHA1 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    = [2c 7e 7c 38 4f 78 29 69 42 82 b1 e3 a6 21 6d ef 80 82 d0 55]
+PASS bytesToHexString(new Uint8Array(digest)) is '2c7e7c384f7829694282b1e3a6216def8082d055'
 SHA1 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]
-    = [2c 7e 7c 38 4f 78 29 69 42 82 b1 e3 a6 21 6d ef 80 82 d0 55]
+PASS bytesToHexString(new Uint8Array(digest)) is '2c7e7c384f7829694282b1e3a6216def8082d055'
 PASS crypto.subtle.generateKey('sha-1') threw exception Error: NotSupportedError: DOM Exception 9.
 PASS successfullyParsed is true
 
index 467e66c..2166ce8 100644 (file)
@@ -13,30 +13,31 @@ description("Test crypto.subtle.digest.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 Promise.fulfill(null).then(function() {
     debug("SHA1 of []");
     return crypto.subtle.digest('sha-1', [new Uint8Array([])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'da39a3ee5e6b4b0d3255bfef95601890afd80709'");
 
     debug("SHA1 of [0x0]")
     return crypto.subtle.digest({name: 'sha-1'}, [new Uint8Array([0])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'5ba93c9db0cff93f52b521d7420e43f6eda2784f'");
 
     debug("SHA1 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]");
     var data = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
     return crypto.subtle.digest({name: 'sha-1'}, [data]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'2c7e7c384f7829694282b1e3a6216def8082d055'");
 
     debug("SHA1 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]");
     return crypto.subtle.digest({name: 'sha-1'}, [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array([5, 6, 7, 8, 9, 10])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'2c7e7c384f7829694282b1e3a6216def8082d055'");
     // All SHA-1 can do is digest.
     shouldThrow("crypto.subtle.generateKey('sha-1')");
     finishJSTest();
index e2b0cdb..c045c8f 100644 (file)
@@ -4,13 +4,13 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 
 SHA224 of []
-    = [d1 4a 02 8c 2a 3a 2b c9 47 61 02 bb 28 82 34 c4 15 a2 b0 1f 82 8e a6 2a c5 b3 e4 2f]
+PASS bytesToHexString(new Uint8Array(digest)) is 'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f'
 SHA224 of [0x0]
-    = [ff f9 29 2b 42 01 61 7b dc 4d 30 53 fc e0 27 34 16 6a 68 3d 7d 85 8a 7f 5f 59 b0 73]
+PASS bytesToHexString(new Uint8Array(digest)) is 'fff9292b4201617bdc4d3053fce02734166a683d7d858a7f5f59b073'
 SHA224 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    = [76 7d 0c dc 11 07 9b a8 dc a2 76 df 5c 4b 85 50 7d e6 7d ce 47 ed a4 cd 91 96 d3 12]
+PASS bytesToHexString(new Uint8Array(digest)) is '767d0cdc11079ba8dca276df5c4b85507de67dce47eda4cd9196d312'
 SHA224 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]
-    = [76 7d 0c dc 11 07 9b a8 dc a2 76 df 5c 4b 85 50 7d e6 7d ce 47 ed a4 cd 91 96 d3 12]
+PASS bytesToHexString(new Uint8Array(digest)) is '767d0cdc11079ba8dca276df5c4b85507de67dce47eda4cd9196d312'
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 4cb8f71..241a7f5 100644 (file)
@@ -13,30 +13,31 @@ description("Test crypto.subtle.digest.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 Promise.fulfill(null).then(function() {
     debug("SHA224 of []");
     return crypto.subtle.digest('sha-224', [new Uint8Array([])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f'");
 
     debug("SHA224 of [0x0]")
     return crypto.subtle.digest({name: 'sha-224'}, [new Uint8Array([0])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'fff9292b4201617bdc4d3053fce02734166a683d7d858a7f5f59b073'");
 
     debug("SHA224 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]");
     var data = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
     return crypto.subtle.digest({name: 'sha-224'}, [data]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'767d0cdc11079ba8dca276df5c4b85507de67dce47eda4cd9196d312'");
 
     debug("SHA224 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]");
     return crypto.subtle.digest({name: 'sha-224'}, [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array([5, 6, 7, 8, 9, 10])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'767d0cdc11079ba8dca276df5c4b85507de67dce47eda4cd9196d312'");
     finishJSTest();
 });
 </script>
index b98bbf8..54ad551 100644 (file)
@@ -4,13 +4,13 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 
 SHA256 of []
-    = [e3 b0 c4 42 98 fc 1c 14 9a fb f4 c8 99 6f b9 24 27 ae 41 e4 64 9b 93 4c a4 95 99 1b 78 52 b8 55]
+PASS bytesToHexString(new Uint8Array(digest)) is 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
 SHA256 of [0x0]
-    = [6e 34 0b 9c ff b3 7a 98 9c a5 44 e6 bb 78 0a 2c 78 90 1d 3f b3 37 38 76 85 11 a3 06 17 af a0 1d]
+PASS bytesToHexString(new Uint8Array(digest)) is '6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d'
 SHA256 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    = [78 a6 27 31 03 d1 7c 39 a0 b6 12 6e 22 6c ec 70 e3 33 37 f4 bc 6a 38 06 74 01 b5 4a 33 e7 8e ad]
+PASS bytesToHexString(new Uint8Array(digest)) is '78a6273103d17c39a0b6126e226cec70e33337f4bc6a38067401b54a33e78ead'
 SHA256 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]
-    = [78 a6 27 31 03 d1 7c 39 a0 b6 12 6e 22 6c ec 70 e3 33 37 f4 bc 6a 38 06 74 01 b5 4a 33 e7 8e ad]
+PASS bytesToHexString(new Uint8Array(digest)) is '78a6273103d17c39a0b6126e226cec70e33337f4bc6a38067401b54a33e78ead'
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 73b49ee..b13ed84 100644 (file)
@@ -13,30 +13,31 @@ description("Test crypto.subtle.digest.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 Promise.fulfill(null).then(function() {
     debug("SHA256 of []");
     return crypto.subtle.digest('sha-256', [new Uint8Array([])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'");
 
     debug("SHA256 of [0x0]")
     return crypto.subtle.digest({name: 'sha-256'}, [new Uint8Array([0])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d'");
 
     debug("SHA256 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]");
     var data = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
     return crypto.subtle.digest({name: 'sha-256'}, [data]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'78a6273103d17c39a0b6126e226cec70e33337f4bc6a38067401b54a33e78ead'");
 
     debug("SHA256 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]");
     return crypto.subtle.digest({name: 'sha-256'}, [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array([5, 6, 7, 8, 9, 10])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'78a6273103d17c39a0b6126e226cec70e33337f4bc6a38067401b54a33e78ead'");
     finishJSTest();
 });
 </script>
index fcd4942..4ea13f0 100644 (file)
@@ -4,13 +4,13 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 
 SHA384 of []
-    = [38 b0 60 a7 51 ac 96 38 4c d9 32 7e b1 b1 e3 6a 21 fd b7 11 14 be 07 43 4c 0c c7 bf 63 f6 e1 da 27 4e de bf e7 6f 65 fb d5 1a d2 f1 48 98 b9 5b]
+PASS bytesToHexString(new Uint8Array(digest)) is '38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b'
 SHA384 of [0x0]
-    = [be c0 21 b4 f3 68 e3 06 91 34 e0 12 c2 b4 30 70 83 d3 a9 bd d2 06 e2 4e 5f 0d 86 e1 3d 66 36 65 59 33 ec 2b 41 34 65 96 68 17 a9 c2 08 a1 17 17]
+PASS bytesToHexString(new Uint8Array(digest)) is 'bec021b4f368e3069134e012c2b4307083d3a9bdd206e24e5f0d86e13d6636655933ec2b413465966817a9c208a11717'
 SHA384 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    = [89 bf cf 56 9a e4 af 71 85 10 da 78 c6 74 14 10 9f 57 39 bb 5c 40 d5 1c 9c 8c 50 e2 b2 ce e8 6f 2f 80 c8 b9 d6 8f 7c 01 20 1a 07 14 57 2f e6 02]
+PASS bytesToHexString(new Uint8Array(digest)) is '89bfcf569ae4af718510da78c67414109f5739bb5c40d51c9c8c50e2b2cee86f2f80c8b9d68f7c01201a0714572fe602'
 SHA384 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]
-    = [89 bf cf 56 9a e4 af 71 85 10 da 78 c6 74 14 10 9f 57 39 bb 5c 40 d5 1c 9c 8c 50 e2 b2 ce e8 6f 2f 80 c8 b9 d6 8f 7c 01 20 1a 07 14 57 2f e6 02]
+PASS bytesToHexString(new Uint8Array(digest)) is '89bfcf569ae4af718510da78c67414109f5739bb5c40d51c9c8c50e2b2cee86f2f80c8b9d68f7c01201a0714572fe602'
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 9e6fdb1..a33096d 100644 (file)
@@ -13,30 +13,31 @@ description("Test crypto.subtle.digest.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 Promise.fulfill(null).then(function() {
     debug("SHA384 of []");
     return crypto.subtle.digest('sha-384', [new Uint8Array([])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b'");
 
     debug("SHA384 of [0x0]")
     return crypto.subtle.digest({name: 'sha-384'}, [new Uint8Array([0])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'bec021b4f368e3069134e012c2b4307083d3a9bdd206e24e5f0d86e13d6636655933ec2b413465966817a9c208a11717'");
 
     debug("SHA384 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]");
     var data = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
     return crypto.subtle.digest({name: 'sha-384'}, [data]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'89bfcf569ae4af718510da78c67414109f5739bb5c40d51c9c8c50e2b2cee86f2f80c8b9d68f7c01201a0714572fe602'");
 
     debug("SHA384 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]");
     return crypto.subtle.digest({name: 'sha-384'}, [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array([5, 6, 7, 8, 9, 10])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'89bfcf569ae4af718510da78c67414109f5739bb5c40d51c9c8c50e2b2cee86f2f80c8b9d68f7c01201a0714572fe602'");
     finishJSTest();
 });
 </script>
index d7913ad..df15ad1 100644 (file)
@@ -4,13 +4,13 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 
 SHA512 of []
-    = [cf 83 e1 35 7e ef b8 bd f1 54 28 50 d6 6d 80 07 d6 20 e4 05 0b 57 15 dc 83 f4 a9 21 d3 6c e9 ce 47 d0 d1 3c 5d 85 f2 b0 ff 83 18 d2 87 7e ec 2f 63 b9 31 bd 47 41 7a 81 a5 38 32 7a f9 27 da 3e]
+PASS bytesToHexString(new Uint8Array(digest)) is 'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e'
 SHA512 of [0x0]
-    = [b8 24 4d 02 89 81 d6 93 af 7b 45 6a f8 ef a4 ca d6 3d 28 2e 19 ff 14 94 2c 24 6e 50 d9 35 1d 22 70 4a 80 2a 71 c3 58 0b 63 70 de 4c eb 29 3c 32 4a 84 23 34 25 57 d4 e5 c3 84 38 f0 e3 69 10 ee]
+PASS bytesToHexString(new Uint8Array(digest)) is 'b8244d028981d693af7b456af8efa4cad63d282e19ff14942c246e50d9351d22704a802a71c3580b6370de4ceb293c324a8423342557d4e5c38438f0e36910ee'
 SHA512 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    = [8f fa ee 0c cc c1 62 85 1f af 05 1a e3 86 67 ee fd 42 3c 01 64 c5 00 55 f8 ad e0 0a fc 37 05 e3 cd eb 99 00 00 4b 0e 42 6c a6 6a b6 3a a3 b9 9b 07 52 73 f4 4f d3 7c 22 a3 55 5c 6f d1 f3 7c cb]
+PASS bytesToHexString(new Uint8Array(digest)) is '8ffaee0cccc162851faf051ae38667eefd423c0164c50055f8ade00afc3705e3cdeb9900004b0e426ca66ab63aa3b99b075273f44fd37c22a3555c6fd1f37ccb'
 SHA512 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]
-    = [8f fa ee 0c cc c1 62 85 1f af 05 1a e3 86 67 ee fd 42 3c 01 64 c5 00 55 f8 ad e0 0a fc 37 05 e3 cd eb 99 00 00 4b 0e 42 6c a6 6a b6 3a a3 b9 9b 07 52 73 f4 4f d3 7c 22 a3 55 5c 6f d1 f3 7c cb]
+PASS bytesToHexString(new Uint8Array(digest)) is '8ffaee0cccc162851faf051ae38667eefd423c0164c50055f8ade00afc3705e3cdeb9900004b0e426ca66ab63aa3b99b075273f44fd37c22a3555c6fd1f37ccb'
 PASS successfullyParsed is true
 
 TEST COMPLETE
index f01927b..30a7b4c 100644 (file)
@@ -13,30 +13,31 @@ description("Test crypto.subtle.digest.");
 
 jsTestIsAsync = true;
 
-if (!window.subtle)
-    window.crypto.subtle = window.crypto.webkitSubtle;
-
 Promise.fulfill(null).then(function() {
     debug("SHA512 of []");
     return crypto.subtle.digest('sha-512', [new Uint8Array([])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e'");
 
     debug("SHA512 of [0x0]")
     return crypto.subtle.digest({name: 'sha-512'}, [new Uint8Array([0])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'b8244d028981d693af7b456af8efa4cad63d282e19ff14942c246e50d9351d22704a802a71c3580b6370de4ceb293c324a8423342557d4e5c38438f0e36910ee'");
 
     debug("SHA512 of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]");
     var data = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
     return crypto.subtle.digest({name: 'sha-512'}, [data]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'8ffaee0cccc162851faf051ae38667eefd423c0164c50055f8ade00afc3705e3cdeb9900004b0e426ca66ab63aa3b99b075273f44fd37c22a3555c6fd1f37ccb'");
 
     debug("SHA512 of [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array(5, 6, 7, 8, 9, 10])]");
     return crypto.subtle.digest({name: 'sha-512'}, [new Uint8Array([0, 1, 2, 3, 4]), new Uint8Array([5, 6, 7, 8, 9, 10])]);
 }).then(function(result) {
-    printAcceptedResult(result);
+    digest = result;
+    shouldBe("bytesToHexString(new Uint8Array(digest))", "'8ffaee0cccc162851faf051ae38667eefd423c0164c50055f8ade00afc3705e3cdeb9900004b0e426ca66ab63aa3b99b075273f44fd37c22a3555c6fd1f37ccb'");
     finishJSTest();
 });
 </script>