diff --git a/test/unit/crypto_spec.js b/test/unit/crypto_spec.js index a3bb84fd8..ce32bb809 100644 --- a/test/unit/crypto_spec.js +++ b/test/unit/crypto_spec.js @@ -36,11 +36,9 @@ describe("crypto", function () { function hex2binary(s) { const digits = "0123456789ABCDEF"; s = s.toUpperCase(); - let n = s.length >> 1, - i, - j; + const n = s.length >> 1; const result = new Uint8Array(n); - for (i = 0, j = 0; i < n; ++i) { + for (let i = 0, j = 0; i < n; ++i) { const d1 = s.charAt(j++); const d2 = s.charAt(j++); const value = (digits.indexOf(d1) << 4) | digits.indexOf(d2); @@ -52,57 +50,50 @@ describe("crypto", function () { // RFC 1321, A.5 Test suite describe("calculateMD5", function () { it("should pass RFC 1321 test #1", function () { - let input, result, expected; - input = stringToBytes(""); - result = calculateMD5(input, 0, input.length); - expected = hex2binary("d41d8cd98f00b204e9800998ecf8427e"); + const input = stringToBytes(""); + const result = calculateMD5(input, 0, input.length); + const expected = hex2binary("d41d8cd98f00b204e9800998ecf8427e"); expect(result).toEqual(expected); }); it("should pass RFC 1321 test #2", function () { - let input, result, expected; - input = stringToBytes("a"); - result = calculateMD5(input, 0, input.length); - expected = hex2binary("0cc175b9c0f1b6a831c399e269772661"); + const input = stringToBytes("a"); + const result = calculateMD5(input, 0, input.length); + const expected = hex2binary("0cc175b9c0f1b6a831c399e269772661"); expect(result).toEqual(expected); }); it("should pass RFC 1321 test #3", function () { - let input, result, expected; - input = stringToBytes("abc"); - result = calculateMD5(input, 0, input.length); - expected = hex2binary("900150983cd24fb0d6963f7d28e17f72"); + const input = stringToBytes("abc"); + const result = calculateMD5(input, 0, input.length); + const expected = hex2binary("900150983cd24fb0d6963f7d28e17f72"); expect(result).toEqual(expected); }); it("should pass RFC 1321 test #4", function () { - let input, result, expected; - input = stringToBytes("message digest"); - result = calculateMD5(input, 0, input.length); - expected = hex2binary("f96b697d7cb7938d525a2f31aaf161d0"); + const input = stringToBytes("message digest"); + const result = calculateMD5(input, 0, input.length); + const expected = hex2binary("f96b697d7cb7938d525a2f31aaf161d0"); expect(result).toEqual(expected); }); it("should pass RFC 1321 test #5", function () { - let input, result, expected; - input = stringToBytes("abcdefghijklmnopqrstuvwxyz"); - result = calculateMD5(input, 0, input.length); - expected = hex2binary("c3fcd3d76192e4007dfb496cca67e13b"); + const input = stringToBytes("abcdefghijklmnopqrstuvwxyz"); + const result = calculateMD5(input, 0, input.length); + const expected = hex2binary("c3fcd3d76192e4007dfb496cca67e13b"); expect(result).toEqual(expected); }); it("should pass RFC 1321 test #6", function () { - let input, result, expected; - input = stringToBytes( + const input = stringToBytes( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" ); - result = calculateMD5(input, 0, input.length); - expected = hex2binary("d174ab98d277d9f5a5611c2c9f419d9f"); + const result = calculateMD5(input, 0, input.length); + const expected = hex2binary("d174ab98d277d9f5a5611c2c9f419d9f"); expect(result).toEqual(expected); }); it("should pass RFC 1321 test #7", function () { - let input, result, expected; - input = stringToBytes( + const input = stringToBytes( "123456789012345678901234567890123456789012345678" + "90123456789012345678901234567890" ); - result = calculateMD5(input, 0, input.length); - expected = hex2binary("57edf4a22be3c955ac49da2e2107b67a"); + const result = calculateMD5(input, 0, input.length); + const expected = hex2binary("57edf4a22be3c955ac49da2e2107b67a"); expect(result).toEqual(expected); }); }); @@ -110,45 +101,40 @@ describe("crypto", function () { // http://www.freemedialibrary.com/index.php/RC4_test_vectors are used describe("ARCFourCipher", function () { it("should pass test #1", function () { - let key, input, result, expected, cipher; - key = hex2binary("0123456789abcdef"); - input = hex2binary("0123456789abcdef"); - cipher = new ARCFourCipher(key); - result = cipher.encryptBlock(input); - expected = hex2binary("75b7878099e0c596"); + const key = hex2binary("0123456789abcdef"); + const input = hex2binary("0123456789abcdef"); + const cipher = new ARCFourCipher(key); + const result = cipher.encryptBlock(input); + const expected = hex2binary("75b7878099e0c596"); expect(result).toEqual(expected); }); it("should pass test #2", function () { - let key, input, result, expected, cipher; - key = hex2binary("0123456789abcdef"); - input = hex2binary("0000000000000000"); - cipher = new ARCFourCipher(key); - result = cipher.encryptBlock(input); - expected = hex2binary("7494c2e7104b0879"); + const key = hex2binary("0123456789abcdef"); + const input = hex2binary("0000000000000000"); + const cipher = new ARCFourCipher(key); + const result = cipher.encryptBlock(input); + const expected = hex2binary("7494c2e7104b0879"); expect(result).toEqual(expected); }); it("should pass test #3", function () { - let key, input, result, expected, cipher; - key = hex2binary("0000000000000000"); - input = hex2binary("0000000000000000"); - cipher = new ARCFourCipher(key); - result = cipher.encryptBlock(input); - expected = hex2binary("de188941a3375d3a"); + const key = hex2binary("0000000000000000"); + const input = hex2binary("0000000000000000"); + const cipher = new ARCFourCipher(key); + const result = cipher.encryptBlock(input); + const expected = hex2binary("de188941a3375d3a"); expect(result).toEqual(expected); }); it("should pass test #4", function () { - let key, input, result, expected, cipher; - key = hex2binary("ef012345"); - input = hex2binary("00000000000000000000"); - cipher = new ARCFourCipher(key); - result = cipher.encryptBlock(input); - expected = hex2binary("d6a141a7ec3c38dfbd61"); + const key = hex2binary("ef012345"); + const input = hex2binary("00000000000000000000"); + const cipher = new ARCFourCipher(key); + const result = cipher.encryptBlock(input); + const expected = hex2binary("d6a141a7ec3c38dfbd61"); expect(result).toEqual(expected); }); it("should pass test #5", function () { - let key, input, result, expected, cipher; - key = hex2binary("0123456789abcdef"); - input = hex2binary( + const key = hex2binary("0123456789abcdef"); + const input = hex2binary( "010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + @@ -166,9 +152,9 @@ describe("crypto", function () { "10101010101010101010101010101010101010101010101010101010101010101010" + "101010101010101010101" ); - cipher = new ARCFourCipher(key); - result = cipher.encryptBlock(input); - expected = hex2binary( + const cipher = new ARCFourCipher(key); + const result = cipher.encryptBlock(input); + const expected = hex2binary( "7595c3e6114a09780c4ad452338e1ffd9a1be9498f813d76" + "533449b6778dcad8c78a8d2ba9ac66085d0e53d59c26c2d1c490c1ebbe0ce66d1b6b" + "1b13b6b919b847c25a91447a95e75e4ef16779cde8bf0a95850e32af9689444fd377" + @@ -189,16 +175,15 @@ describe("crypto", function () { expect(result).toEqual(expected); }); it("should pass test #6", function () { - let key, input, result, expected, cipher; - key = hex2binary("fb029e3031323334"); - input = hex2binary( + const key = hex2binary("fb029e3031323334"); + const input = hex2binary( "aaaa0300000008004500004e661a00008011be640a0001220af" + "fffff00890089003a000080a601100001000000000000204543454a4548454346434" + "550464545494546464343414341434143414341414100002000011bd0b604" ); - cipher = new ARCFourCipher(key); - result = cipher.encryptBlock(input); - expected = hex2binary( + const cipher = new ARCFourCipher(key); + const result = cipher.encryptBlock(input); + const expected = hex2binary( "f69c5806bd6ce84626bcbefb9474650aad1f7909b0f64d5f" + "58a503a258b7ed22eb0ea64930d3a056a55742fcce141d485f8aa836dea18df42c53" + "80805ad0c61a5d6f58f41040b24b7d1a693856ed0d4398e7aee3bf0e2a2ca8f7" @@ -206,14 +191,13 @@ describe("crypto", function () { expect(result).toEqual(expected); }); it("should pass test #7", function () { - let key, input, result, expected, cipher; - key = hex2binary("0123456789abcdef"); - input = hex2binary( + const key = hex2binary("0123456789abcdef"); + const input = hex2binary( "123456789abcdef0123456789abcdef0123456789abcdef012345678" ); - cipher = new ARCFourCipher(key); - result = cipher.encryptBlock(input); - expected = hex2binary( + const cipher = new ARCFourCipher(key); + const result = cipher.encryptBlock(input); + const expected = hex2binary( "66a0949f8af7d6891f7f832ba833c00c892ebe30143ce28740011ecf" ); expect(result).toEqual(expected); @@ -222,21 +206,19 @@ describe("crypto", function () { describe("calculateSHA256", function () { it("should properly hash abc", function () { - let input, result, expected; - input = stringToBytes("abc"); - result = calculateSHA256(input, 0, input.length); - expected = hex2binary( + const input = stringToBytes("abc"); + const result = calculateSHA256(input, 0, input.length); + const expected = hex2binary( "BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD" ); expect(result).toEqual(expected); }); it("should properly hash a multiblock input", function () { - let input, result, expected; - input = stringToBytes( + const input = stringToBytes( "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" ); - result = calculateSHA256(input, 0, input.length); - expected = hex2binary( + const result = calculateSHA256(input, 0, input.length); + const expected = hex2binary( "248D6A61D20638B8E5C026930C3E6039A33CE45964FF2167F6ECEDD419DB06C1" ); expect(result).toEqual(expected); @@ -245,24 +227,22 @@ describe("crypto", function () { describe("calculateSHA384", function () { it("should properly hash abc", function () { - let input, result, expected; - input = stringToBytes("abc"); - result = calculateSHA384(input, 0, input.length); - expected = hex2binary( + const input = stringToBytes("abc"); + const result = calculateSHA384(input, 0, input.length); + const expected = hex2binary( "CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED163" + "1A8B605A43FF5BED8086072BA1E7CC2358BAECA134C825A7" ); expect(result).toEqual(expected); }); it("should properly hash a multiblock input", function () { - let input, result, expected; - input = stringToBytes( + const input = stringToBytes( "abcdefghbcdefghicdefghijdefghijkefghijklfghijklm" + "ghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrs" + "mnopqrstnopqrstu" ); - result = calculateSHA384(input, 0, input.length); - expected = hex2binary( + const result = calculateSHA384(input, 0, input.length); + const expected = hex2binary( "09330C33F71147E83D192FC782CD1B4753111B173B3B05D2" + "2FA08086E3B0F712FCC7C71A557E2DB966C3E9FA91746039" ); @@ -272,10 +252,9 @@ describe("crypto", function () { describe("calculateSHA512", function () { it("should properly hash abc", function () { - let input, result, expected; - input = stringToBytes("abc"); - result = calculateSHA512(input, 0, input.length); - expected = hex2binary( + const input = stringToBytes("abc"); + const result = calculateSHA512(input, 0, input.length); + const expected = hex2binary( "DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA2" + "0A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD" + "454D4423643CE80E2A9AC94FA54CA49F" @@ -283,14 +262,13 @@ describe("crypto", function () { expect(result).toEqual(expected); }); it("should properly hash a multiblock input", function () { - let input, result, expected; - input = stringToBytes( + const input = stringToBytes( "abcdefghbcdefghicdefghijdefghijkefghijklfghijklm" + "ghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrs" + "mnopqrstnopqrstu" ); - result = calculateSHA512(input, 0, input.length); - expected = hex2binary( + const result = calculateSHA512(input, 0, input.length); + const expected = hex2binary( "8E959B75DAE313DA8CF4F72814FC143F8F7779C6EB9F7FA1" + "7299AEADB6889018501D289E4900F7E4331B99DEC4B5433A" + "C7D329EEB6DD26545E96E55B874BE909" @@ -302,28 +280,26 @@ describe("crypto", function () { describe("AES128", function () { describe("Encryption", function () { it("should be able to encrypt a block", function () { - let input, key, result, expected, iv, cipher; - input = hex2binary("00112233445566778899aabbccddeeff"); - key = hex2binary("000102030405060708090a0b0c0d0e0f"); - iv = hex2binary("00000000000000000000000000000000"); - cipher = new AES128Cipher(key); - result = cipher.encrypt(input, iv); - expected = hex2binary("69c4e0d86a7b0430d8cdb78070b4c55a"); + const input = hex2binary("00112233445566778899aabbccddeeff"); + const key = hex2binary("000102030405060708090a0b0c0d0e0f"); + const iv = hex2binary("00000000000000000000000000000000"); + const cipher = new AES128Cipher(key); + const result = cipher.encrypt(input, iv); + const expected = hex2binary("69c4e0d86a7b0430d8cdb78070b4c55a"); expect(result).toEqual(expected); }); }); describe("Decryption", function () { it("should be able to decrypt a block with IV in stream", function () { - let input, key, result, expected, cipher; - input = hex2binary( + const input = hex2binary( "0000000000000000000000000000000069c4e0d86a7b0430d" + "8cdb78070b4c55a" ); - key = hex2binary("000102030405060708090a0b0c0d0e0f"); - cipher = new AES128Cipher(key); - result = cipher.decryptBlock(input); - expected = hex2binary("00112233445566778899aabbccddeeff"); + const key = hex2binary("000102030405060708090a0b0c0d0e0f"); + const cipher = new AES128Cipher(key); + const result = cipher.decryptBlock(input); + const expected = hex2binary("00112233445566778899aabbccddeeff"); expect(result).toEqual(expected); }); }); @@ -332,47 +308,44 @@ describe("crypto", function () { describe("AES256", function () { describe("Encryption", function () { it("should be able to encrypt a block", function () { - let input, key, result, expected, iv, cipher; - input = hex2binary("00112233445566778899aabbccddeeff"); - key = hex2binary( + const input = hex2binary("00112233445566778899aabbccddeeff"); + const key = hex2binary( "000102030405060708090a0b0c0d0e0f101112131415161718" + "191a1b1c1d1e1f" ); - iv = hex2binary("00000000000000000000000000000000"); - cipher = new AES256Cipher(key); - result = cipher.encrypt(input, iv); - expected = hex2binary("8ea2b7ca516745bfeafc49904b496089"); + const iv = hex2binary("00000000000000000000000000000000"); + const cipher = new AES256Cipher(key); + const result = cipher.encrypt(input, iv); + const expected = hex2binary("8ea2b7ca516745bfeafc49904b496089"); expect(result).toEqual(expected); }); }); describe("Decryption", function () { it("should be able to decrypt a block with specified iv", function () { - let input, key, result, expected, cipher, iv; - input = hex2binary("8ea2b7ca516745bfeafc49904b496089"); - key = hex2binary( + const input = hex2binary("8ea2b7ca516745bfeafc49904b496089"); + const key = hex2binary( "000102030405060708090a0b0c0d0e0f101112131415161718" + "191a1b1c1d1e1f" ); - iv = hex2binary("00000000000000000000000000000000"); - cipher = new AES256Cipher(key); - result = cipher.decryptBlock(input, false, iv); - expected = hex2binary("00112233445566778899aabbccddeeff"); + const iv = hex2binary("00000000000000000000000000000000"); + const cipher = new AES256Cipher(key); + const result = cipher.decryptBlock(input, false, iv); + const expected = hex2binary("00112233445566778899aabbccddeeff"); expect(result).toEqual(expected); }); it("should be able to decrypt a block with IV in stream", function () { - let input, key, result, expected, cipher; - input = hex2binary( + const input = hex2binary( "000000000000000000000000000000008ea2b7ca516745bf" + "eafc49904b496089" ); - key = hex2binary( + const key = hex2binary( "000102030405060708090a0b0c0d0e0f101112131415161718" + "191a1b1c1d1e1f" ); - cipher = new AES256Cipher(key); - result = cipher.decryptBlock(input, false); - expected = hex2binary("00112233445566778899aabbccddeeff"); + const cipher = new AES256Cipher(key); + const result = cipher.decryptBlock(input, false); + const expected = hex2binary("00112233445566778899aabbccddeeff"); expect(result).toEqual(expected); }); }); @@ -380,36 +353,50 @@ describe("crypto", function () { describe("PDF17Algorithm", function () { it("should correctly check a user key", function () { - let password, userValidation, userPassword, alg, result; - alg = new PDF17(); - password = new Uint8Array([117, 115, 101, 114]); - userValidation = new Uint8Array([117, 169, 4, 32, 159, 101, 22, 220]); + const alg = new PDF17(); + const password = new Uint8Array([117, 115, 101, 114]); // prettier-ignore - userPassword = new Uint8Array([131, 242, 143, 160, 87, 2, 138, 134, 79, - 253, 189, 173, 224, 73, 144, 241, 190, 81, - 197, 15, 249, 105, 145, 151, 15, 194, 65, - 3, 1, 126, 187, 221]); - result = alg.checkUserPassword(password, userValidation, userPassword); + const userValidation = new Uint8Array([ + 117, 169, 4, 32, 159, 101, 22, 220 + ]); + // prettier-ignore + const userPassword = new Uint8Array([ + 131, 242, 143, 160, 87, 2, 138, 134, 79, + 253, 189, 173, 224, 73, 144, 241, 190, 81, + 197, 15, 249, 105, 145, 151, 15, 194, 65, + 3, 1, 126, 187, 221 + ]); + const result = alg.checkUserPassword( + password, + userValidation, + userPassword + ); expect(result).toEqual(true); }); it("should correctly check an owner key", function () { - let password, ownerValidation, ownerPassword, alg, result, uBytes; - alg = new PDF17(); - password = new Uint8Array([111, 119, 110, 101, 114]); - ownerValidation = new Uint8Array([243, 118, 71, 153, 128, 17, 101, 62]); + const alg = new PDF17(); + const password = new Uint8Array([111, 119, 110, 101, 114]); // prettier-ignore - ownerPassword = new Uint8Array([60, 98, 137, 35, 51, 101, 200, 152, 210, - 178, 226, 228, 134, 205, 163, 24, 204, - 126, 177, 36, 106, 50, 36, 125, 210, 172, - 171, 120, 222, 108, 139, 115]); + const ownerValidation = new Uint8Array([ + 243, 118, 71, 153, 128, 17, 101, 62 + ]); // prettier-ignore - uBytes = new Uint8Array([131, 242, 143, 160, 87, 2, 138, 134, 79, 253, - 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, - 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, - 221, 117, 169, 4, 32, 159, 101, 22, 220, 168, - 94, 215, 192, 100, 38, 188, 40]); - result = alg.checkOwnerPassword( + const ownerPassword = new Uint8Array([ + 60, 98, 137, 35, 51, 101, 200, 152, 210, + 178, 226, 228, 134, 205, 163, 24, 204, + 126, 177, 36, 106, 50, 36, 125, 210, 172, + 171, 120, 222, 108, 139, 115 + ]); + // prettier-ignore + const uBytes = new Uint8Array([ + 131, 242, 143, 160, 87, 2, 138, 134, 79, 253, + 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, + 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, + 221, 117, 169, 4, 32, 159, 101, 22, 220, 168, + 94, 215, 192, 100, 38, 188, 40 + ]); + const result = alg.checkOwnerPassword( password, ownerValidation, uBytes, @@ -419,83 +406,112 @@ describe("crypto", function () { }); it("should generate a file encryption key from the user key", function () { - let password, userKeySalt, expected, alg, result, userEncryption; - alg = new PDF17(); - password = new Uint8Array([117, 115, 101, 114]); - userKeySalt = new Uint8Array([168, 94, 215, 192, 100, 38, 188, 40]); + const alg = new PDF17(); + const password = new Uint8Array([117, 115, 101, 114]); + const userKeySalt = new Uint8Array([168, 94, 215, 192, 100, 38, 188, 40]); // prettier-ignore - userEncryption = new Uint8Array([35, 150, 195, 169, 245, 51, 51, 255, - 158, 158, 33, 242, 231, 75, 125, 190, - 25, 126, 172, 114, 195, 244, 137, 245, - 234, 165, 42, 74, 60, 38, 17, 17]); - result = alg.getUserKey(password, userKeySalt, userEncryption); + const userEncryption = new Uint8Array([ + 35, 150, 195, 169, 245, 51, 51, 255, + 158, 158, 33, 242, 231, 75, 125, 190, + 25, 126, 172, 114, 195, 244, 137, 245, + 234, 165, 42, 74, 60, 38, 17, 17 + ]); + const result = alg.getUserKey(password, userKeySalt, userEncryption); // prettier-ignore - expected = new Uint8Array([63, 114, 136, 209, 87, 61, 12, 30, 249, 1, - 186, 144, 254, 248, 163, 153, 151, 51, 133, - 10, 80, 152, 206, 15, 72, 187, 231, 33, 224, - 239, 13, 213]); + const expected = new Uint8Array([ + 63, 114, 136, 209, 87, 61, 12, 30, 249, 1, + 186, 144, 254, 248, 163, 153, 151, 51, 133, + 10, 80, 152, 206, 15, 72, 187, 231, 33, 224, + 239, 13, 213 + ]); expect(result).toEqual(expected); }); it("should generate a file encryption key from the owner key", function () { - let password, ownerKeySalt, expected, alg, result, ownerEncryption; - let uBytes; - alg = new PDF17(); - password = new Uint8Array([111, 119, 110, 101, 114]); - ownerKeySalt = new Uint8Array([200, 245, 242, 12, 218, 123, 24, 120]); + const alg = new PDF17(); + const password = new Uint8Array([111, 119, 110, 101, 114]); // prettier-ignore - ownerEncryption = new Uint8Array([213, 202, 14, 189, 110, 76, 70, 191, 6, - 195, 10, 190, 157, 100, 144, 85, 8, 62, - 123, 178, 156, 229, 50, 40, 229, 216, - 54, 222, 34, 38, 106, 223]); + const ownerKeySalt = new Uint8Array([ + 200, 245, 242, 12, 218, 123, 24, 120 + ]); // prettier-ignore - uBytes = new Uint8Array([131, 242, 143, 160, 87, 2, 138, 134, 79, 253, - 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, - 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, - 221, 117, 169, 4, 32, 159, 101, 22, 220, 168, - 94, 215, 192, 100, 38, 188, 40]); - result = alg.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption); + const ownerEncryption = new Uint8Array([ + 213, 202, 14, 189, 110, 76, 70, 191, 6, + 195, 10, 190, 157, 100, 144, 85, 8, 62, + 123, 178, 156, 229, 50, 40, 229, 216, + 54, 222, 34, 38, 106, 223 + ]); // prettier-ignore - expected = new Uint8Array([63, 114, 136, 209, 87, 61, 12, 30, 249, 1, - 186, 144, 254, 248, 163, 153, 151, 51, 133, - 10, 80, 152, 206, 15, 72, 187, 231, 33, 224, - 239, 13, 213]); + const uBytes = new Uint8Array([ + 131, 242, 143, 160, 87, 2, 138, 134, 79, 253, + 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, + 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, + 221, 117, 169, 4, 32, 159, 101, 22, 220, 168, + 94, 215, 192, 100, 38, 188, 40 + ]); + const result = alg.getOwnerKey( + password, + ownerKeySalt, + uBytes, + ownerEncryption + ); + // prettier-ignore + const expected = new Uint8Array([ + 63, 114, 136, 209, 87, 61, 12, 30, 249, 1, + 186, 144, 254, 248, 163, 153, 151, 51, 133, + 10, 80, 152, 206, 15, 72, 187, 231, 33, 224, + 239, 13, 213 + ]); expect(result).toEqual(expected); }); }); describe("PDF20Algorithm", function () { it("should correctly check a user key", function () { - let password, userValidation, userPassword, alg, result; - alg = new PDF20(); - password = new Uint8Array([117, 115, 101, 114]); - userValidation = new Uint8Array([83, 245, 146, 101, 198, 247, 34, 198]); + const alg = new PDF20(); + const password = new Uint8Array([117, 115, 101, 114]); // prettier-ignore - userPassword = new Uint8Array([94, 230, 205, 75, 166, 99, 250, 76, 219, - 128, 17, 85, 57, 17, 33, 164, 150, 46, - 103, 176, 160, 156, 187, 233, 166, 223, - 163, 253, 147, 235, 95, 184]); - result = alg.checkUserPassword(password, userValidation, userPassword); + const userValidation = new Uint8Array([ + 83, 245, 146, 101, 198, 247, 34, 198 + ]); + // prettier-ignore + const userPassword = new Uint8Array([ + 94, 230, 205, 75, 166, 99, 250, 76, 219, + 128, 17, 85, 57, 17, 33, 164, 150, 46, + 103, 176, 160, 156, 187, 233, 166, 223, + 163, 253, 147, 235, 95, 184 + ]); + const result = alg.checkUserPassword( + password, + userValidation, + userPassword + ); expect(result).toEqual(true); }); it("should correctly check an owner key", function () { - let password, ownerValidation, ownerPassword, alg, result, uBytes; - alg = new PDF20(); - password = new Uint8Array([111, 119, 110, 101, 114]); - ownerValidation = new Uint8Array([142, 232, 169, 208, 202, 214, 5, 185]); + const alg = new PDF20(); + const password = new Uint8Array([111, 119, 110, 101, 114]); // prettier-ignore - ownerPassword = new Uint8Array([88, 232, 62, 54, 245, 26, 245, 209, 137, - 123, 221, 72, 199, 49, 37, 217, 31, 74, - 115, 167, 127, 158, 176, 77, 45, 163, 87, - 47, 39, 90, 217, 141]); + const ownerValidation = new Uint8Array([ + 142, 232, 169, 208, 202, 214, 5, 185 + ]); // prettier-ignore - uBytes = new Uint8Array([94, 230, 205, 75, 166, 99, 250, 76, 219, 128, - 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, - 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, - 184, 83, 245, 146, 101, 198, 247, 34, 198, 191, - 11, 16, 94, 237, 216, 20, 175]); - result = alg.checkOwnerPassword( + const ownerPassword = new Uint8Array([ + 88, 232, 62, 54, 245, 26, 245, 209, 137, + 123, 221, 72, 199, 49, 37, 217, 31, 74, + 115, 167, 127, 158, 176, 77, 45, 163, 87, + 47, 39, 90, 217, 141 + ]); + // prettier-ignore + const uBytes = new Uint8Array([ + 94, 230, 205, 75, 166, 99, 250, 76, 219, 128, + 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, + 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, + 184, 83, 245, 146, 101, 198, 247, 34, 198, 191, + 11, 16, 94, 237, 216, 20, 175 + ]); + const result = alg.checkOwnerPassword( password, ownerValidation, uBytes, @@ -505,47 +521,59 @@ describe("crypto", function () { }); it("should generate a file encryption key from the user key", function () { - let password, userKeySalt, expected, alg, result, userEncryption; - alg = new PDF20(); - password = new Uint8Array([117, 115, 101, 114]); - userKeySalt = new Uint8Array([191, 11, 16, 94, 237, 216, 20, 175]); + const alg = new PDF20(); + const password = new Uint8Array([117, 115, 101, 114]); + const userKeySalt = new Uint8Array([191, 11, 16, 94, 237, 216, 20, 175]); // prettier-ignore - userEncryption = new Uint8Array([121, 208, 2, 181, 230, 89, 156, 60, 253, - 143, 212, 28, 84, 180, 196, 177, 173, - 128, 221, 107, 46, 20, 94, 186, 135, 51, - 95, 24, 20, 223, 254, 36]); - result = alg.getUserKey(password, userKeySalt, userEncryption); + const userEncryption = new Uint8Array([ + 121, 208, 2, 181, 230, 89, 156, 60, 253, + 143, 212, 28, 84, 180, 196, 177, 173, + 128, 221, 107, 46, 20, 94, 186, 135, 51, + 95, 24, 20, 223, 254, 36 + ]); + const result = alg.getUserKey(password, userKeySalt, userEncryption); // prettier-ignore - expected = new Uint8Array([42, 218, 213, 39, 73, 91, 72, 79, 67, 38, 248, - 133, 18, 189, 61, 34, 107, 79, 29, 56, 59, - 181, 213, 118, 113, 34, 65, 210, 87, 174, 22, - 239]); + const expected = new Uint8Array([ + 42, 218, 213, 39, 73, 91, 72, 79, 67, 38, 248, + 133, 18, 189, 61, 34, 107, 79, 29, 56, 59, + 181, 213, 118, 113, 34, 65, 210, 87, 174, 22, + 239 + ]); expect(result).toEqual(expected); }); it("should generate a file encryption key from the owner key", function () { - let password, ownerKeySalt, expected, alg, result, ownerEncryption; - let uBytes; - alg = new PDF20(); - password = new Uint8Array([111, 119, 110, 101, 114]); - ownerKeySalt = new Uint8Array([29, 208, 185, 46, 11, 76, 135, 149]); + const alg = new PDF20(); + const password = new Uint8Array([111, 119, 110, 101, 114]); + const ownerKeySalt = new Uint8Array([29, 208, 185, 46, 11, 76, 135, 149]); // prettier-ignore - ownerEncryption = new Uint8Array([209, 73, 224, 77, 103, 155, 201, 181, - 190, 68, 223, 20, 62, 90, 56, 210, 5, - 240, 178, 128, 238, 124, 68, 254, 253, - 244, 62, 108, 208, 135, 10, 251]); + const ownerEncryption = new Uint8Array([ + 209, 73, 224, 77, 103, 155, 201, 181, + 190, 68, 223, 20, 62, 90, 56, 210, 5, + 240, 178, 128, 238, 124, 68, 254, 253, + 244, 62, 108, 208, 135, 10, 251 + ]); // prettier-ignore - uBytes = new Uint8Array([94, 230, 205, 75, 166, 99, 250, 76, 219, 128, - 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, - 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, - 184, 83, 245, 146, 101, 198, 247, 34, 198, 191, - 11, 16, 94, 237, 216, 20, 175]); - result = alg.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption); + const uBytes = new Uint8Array([ + 94, 230, 205, 75, 166, 99, 250, 76, 219, 128, + 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, + 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, + 184, 83, 245, 146, 101, 198, 247, 34, 198, 191, + 11, 16, 94, 237, 216, 20, 175 + ]); + const result = alg.getOwnerKey( + password, + ownerKeySalt, + uBytes, + ownerEncryption + ); // prettier-ignore - expected = new Uint8Array([42, 218, 213, 39, 73, 91, 72, 79, 67, 38, 248, - 133, 18, 189, 61, 34, 107, 79, 29, 56, 59, - 181, 213, 118, 113, 34, 65, 210, 87, 174, 22, - 239]); + const expected = new Uint8Array([ + 42, 218, 213, 39, 73, 91, 72, 79, 67, 38, 248, + 133, 18, 189, 61, 34, 107, 79, 29, 56, 59, + 181, 213, 118, 113, 34, 65, 210, 87, 174, 22, + 239 + ]); expect(result).toEqual(expected); }); }); diff --git a/test/unit/murmurhash3_spec.js b/test/unit/murmurhash3_spec.js index 2bd371725..635389228 100644 --- a/test/unit/murmurhash3_spec.js +++ b/test/unit/murmurhash3_spec.js @@ -46,20 +46,18 @@ describe("MurmurHash3_64", function () { it("changes the hash after update without seed", function () { const hash = new MurmurHash3_64(); - let hexdigest1, hexdigest2; hash.update(sourceText); - hexdigest1 = hash.hexdigest(); + const hexdigest1 = hash.hexdigest(); hash.update(sourceText); - hexdigest2 = hash.hexdigest(); + const hexdigest2 = hash.hexdigest(); expect(hexdigest1).not.toEqual(hexdigest2); }); it("changes the hash after update with seed", function () { const hash = new MurmurHash3_64(1); - let hexdigest1, hexdigest2; hash.update(sourceText); - hexdigest1 = hash.hexdigest(); + const hexdigest1 = hash.hexdigest(); hash.update(sourceText); - hexdigest2 = hash.hexdigest(); + const hexdigest2 = hash.hexdigest(); expect(hexdigest1).not.toEqual(hexdigest2); }); }); diff --git a/test/unit/network_spec.js b/test/unit/network_spec.js index 77c34381e..7d186e100 100644 --- a/test/unit/network_spec.js +++ b/test/unit/network_spec.js @@ -38,7 +38,7 @@ describe("network", function () { let len = 0, count = 0; - var read = function () { + const read = function () { return fullReader.read().then(function (result) { if (result.done) { return undefined; @@ -101,7 +101,7 @@ describe("network", function () { const result1 = { value: 0 }, result2 = { value: 0 }; - var read = function (reader, lenResult) { + const read = function (reader, lenResult) { return reader.read().then(function (result) { if (result.done) { return undefined; diff --git a/test/unit/ui_utils_spec.js b/test/unit/ui_utils_spec.js index 204a86dd1..ebfc916af 100644 --- a/test/unit/ui_utils_spec.js +++ b/test/unit/ui_utils_spec.js @@ -301,7 +301,7 @@ describe("ui_utils", function () { eventBus.off("test", listener2); count++; }; - var listener2 = function () { + const listener2 = function () { eventBus.off("test", listener1); count++; };