From fe08ef4e39c8f2f577a3d559c7c5a583606abb30 Mon Sep 17 00:00:00 2001 From: Tim van der Meij Date: Sun, 25 Oct 2020 16:03:11 +0100 Subject: [PATCH] Fix `var` conversions that ESLint could not do automatically This mainly involves the `crypto_spec.js` file which declared most variables before their usage, which is not really consistent with the rest of the codebase. This also required reformatting some long arrays in that file because otherwise we would exceed the 80 character line limit. Overall, this makes the code more readable. --- test/unit/crypto_spec.js | 510 ++++++++++++++++++---------------- test/unit/murmurhash3_spec.js | 10 +- test/unit/network_spec.js | 4 +- test/unit/ui_utils_spec.js | 2 +- 4 files changed, 276 insertions(+), 250 deletions(-) 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++; };