@brix-crypto/crypto-js 0.0.1-security → 4.2.1

package/test/mode-ctr-test.js

@@ -0,0 +1,55 @@
+YUI.add('mode-ctr-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'CTR',
+
+        setUp: function () {
+            this.data = {};
+
+            this.data.message = C.lib.WordArray.create([
+                0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f,
+                0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f
+            ]);
+            this.data.key = C.lib.WordArray.create([0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f]);
+            this.data.iv = C.lib.WordArray.create([0x30313233, 0x34353637, 0x38393a3b, 0x3c3d3e3f]);
+        },
+
+        testEncryptor: function () {
+            // Compute expected
+            var expected = this.data.message.clone();
+            var aes = C.algo.AES.createEncryptor(this.data.key);
+
+            // Counter initialized with IV
+            var counter = this.data.iv.words.slice(0);
+
+            // First block XORed with encrypted counter
+            var keystream = counter.slice(0);
+            aes.encryptBlock(keystream, 0);
+            for (var i = 0; i < 4; i++) {
+                expected.words[i] ^= keystream[i];
+            }
+
+            // Subsequent blocks XORed with encrypted incremented counter
+            counter[3]++;
+            var keystream = counter.slice(0);
+            aes.encryptBlock(keystream, 0);
+            for (var i = 4; i < 8; i++) {
+                expected.words[i] ^= keystream[i % 4];
+            }
+
+            // Compute actual
+            var actual = C.AES.encrypt(this.data.message, this.data.key, { iv: this.data.iv, mode: C.mode.CTR, padding: C.pad.NoPadding }).ciphertext;
+
+            // Test
+            Y.Assert.areEqual(expected.toString(), actual.toString());
+        },
+
+        testDecryptor: function () {
+            var encrypted = C.AES.encrypt(this.data.message, this.data.key, { iv: this.data.iv, mode: C.mode.CTR, padding: C.pad.NoPadding });
+            var decrypted = C.AES.decrypt(encrypted, this.data.key, { iv: this.data.iv, mode: C.mode.CTR, padding: C.pad.NoPadding });
+
+            Y.Assert.areEqual(this.data.message.toString(), decrypted.toString());
+        }
+    }));
+}, '$Rev$');

package/test/mode-ecb-test.js

@@ -0,0 +1,38 @@
+YUI.add('mode-ecb-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'ECB',
+
+        setUp: function () {
+            this.data = {};
+
+            this.data.message = C.lib.WordArray.create([
+                0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f,
+                0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f
+            ]);
+            this.data.key = C.lib.WordArray.create([0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f]);
+        },
+
+        testEncryptor: function () {
+            // Compute expected
+            var expected = this.data.message.clone();
+            var aes = C.algo.AES.createEncryptor(this.data.key);
+            aes.encryptBlock(expected.words, 0);
+            aes.encryptBlock(expected.words, 4);
+
+            // Compute actual
+            var actual = C.AES.encrypt(this.data.message, this.data.key, { mode: C.mode.ECB, padding: C.pad.NoPadding }).ciphertext;
+
+            // Test
+            Y.Assert.areEqual(expected.toString(), actual.toString());
+        },
+
+        testDecryptor: function () {
+            var encrypted = C.AES.encrypt(this.data.message, this.data.key, { mode: C.mode.ECB, padding: C.pad.NoPadding });
+            var decrypted = C.AES.decrypt(encrypted, this.data.key, { mode: C.mode.ECB, padding: C.pad.NoPadding });
+
+            Y.Assert.areEqual(this.data.message.toString(), decrypted.toString());
+        }
+    }));
+}, '$Rev$');

package/test/mode-ofb-test.js

@@ -0,0 +1,50 @@
+YUI.add('mode-ofb-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'OFB',
+
+        setUp: function () {
+            this.data = {};
+
+            this.data.message = C.lib.WordArray.create([
+                0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f,
+                0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f
+            ]);
+            this.data.key = C.lib.WordArray.create([0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f]);
+            this.data.iv = C.lib.WordArray.create([0x30313233, 0x34353637, 0x38393a3b, 0x3c3d3e3f]);
+        },
+
+        testEncryptor: function () {
+            // Compute expected
+            var expected = this.data.message.clone();
+            var aes = C.algo.AES.createEncryptor(this.data.key);
+
+            // First block XORed with encrypted IV
+            var keystream = this.data.iv.words.slice(0);
+            aes.encryptBlock(keystream, 0);
+            for (var i = 0; i < 4; i++) {
+                expected.words[i] ^= keystream[i];
+            }
+
+            // Subsequent blocks XORed with encrypted previous keystream
+            aes.encryptBlock(keystream, 0);
+            for (var i = 4; i < 8; i++) {
+                expected.words[i] ^= keystream[i % 4];
+            }
+
+            // Compute actual
+            var actual = C.AES.encrypt(this.data.message, this.data.key, { iv: this.data.iv, mode: C.mode.OFB, padding: C.pad.NoPadding }).ciphertext;
+
+            // Test
+            Y.Assert.areEqual(expected.toString(), actual.toString());
+        },
+
+        testDecryptor: function () {
+            var encrypted = C.AES.encrypt(this.data.message, this.data.key, { iv: this.data.iv, mode: C.mode.OFB, padding: C.pad.NoPadding });
+            var decrypted = C.AES.decrypt(encrypted, this.data.key, { iv: this.data.iv, mode: C.mode.OFB, padding: C.pad.NoPadding });
+
+            Y.Assert.areEqual(this.data.message.toString(), decrypted.toString());
+        }
+    }));
+}, '$Rev$');

package/test/pad-ansix923-test.js

@@ -0,0 +1,28 @@
+YUI.add('pad-ansix923-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'AnsiX923',
+
+        testPad: function () {
+            var data = C.lib.WordArray.create([0xdddddd00], 3);
+            C.pad.AnsiX923.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd00, 0x00000005]).toString(), data.toString());
+        },
+
+        testPadClamp: function () {
+            var data = C.lib.WordArray.create([0xdddddddd, 0xdddddddd], 3);
+            C.pad.AnsiX923.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd00, 0x00000005]).toString(), data.toString());
+        },
+
+        testUnpad: function () {
+            var data = C.lib.WordArray.create([0xdddddd00, 0x00000005]);
+            C.pad.AnsiX923.unpad(data);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd00], 3).toString(), data.toString());
+        }
+    }));
+}, '$Rev$');

package/test/pad-iso10126-test.js

@@ -0,0 +1,50 @@
+YUI.add('pad-iso10126-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'Iso10126',
+
+        setUp: function () {
+            this.data = {};
+
+            // Save original random method
+            this.data.random = C.lib.WordArray.random;
+
+            // Replace random method with one that returns a predictable value
+            C.lib.WordArray.random = function (nBytes) {
+                var words = [];
+                for (var i = 0; i < nBytes; i += 4) {
+                    words.push([0x11223344]);
+                }
+
+                return C.lib.WordArray.create(words, nBytes);
+            };
+        },
+
+        tearDown: function () {
+            // Restore random method
+            C.lib.WordArray.random = this.data.random;
+        },
+
+        testPad: function () {
+            var data = C.lib.WordArray.create([0xdddddd00], 3);
+            C.pad.Iso10126.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd11, 0x22334405]).toString(), data.toString());
+        },
+
+        testPadClamp: function () {
+            var data = C.lib.WordArray.create([0xdddddddd, 0xdddddddd], 3);
+            C.pad.Iso10126.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd11, 0x22334405]).toString(), data.toString());
+        },
+
+        testUnpad: function () {
+            var data = C.lib.WordArray.create([0xdddddd11, 0x22334405]);
+            C.pad.Iso10126.unpad(data);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd00], 3).toString(), data.toString());
+        }
+    }));
+}, '$Rev$');

package/test/pad-iso97971-test.js

@@ -0,0 +1,35 @@
+YUI.add('pad-iso97971-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'Iso97971',
+
+        testPad1: function () {
+            var data = C.lib.WordArray.create([0xdddddd00], 3);
+            C.pad.Iso97971.pad(data, 1);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd80]).toString(), data.toString());
+        },
+
+        testPad2: function () {
+            var data = C.lib.WordArray.create([0xdddddd00], 3);
+            C.pad.Iso97971.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd80, 0x00000000]).toString(), data.toString());
+        },
+
+        testPadClamp: function () {
+            var data = C.lib.WordArray.create([0xdddddddd, 0xdddddddd], 3);
+            C.pad.Iso97971.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd80, 0x00000000]).toString(), data.toString());
+        },
+
+        testUnpad: function () {
+            var data = C.lib.WordArray.create([0xdddddd80, 0x00000000]);
+            C.pad.Iso97971.unpad(data);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd00], 3).toString(), data.toString());
+        }
+    }));
+}, '$Rev$');

package/test/pad-pkcs7-test.js

@@ -0,0 +1,28 @@
+YUI.add('pad-pkcs7-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'Pkcs7',
+
+        testPad: function () {
+            var data = C.lib.WordArray.create([0xdddddd00], 3);
+            C.pad.Pkcs7.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd05, 0x05050505]).toString(), data.toString());
+        },
+
+        testPadClamp: function () {
+            var data = C.lib.WordArray.create([0xdddddddd, 0xdddddddd], 3);
+            C.pad.Pkcs7.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd05, 0x05050505]).toString(), data.toString());
+        },
+
+        testUnpad: function () {
+            var data = C.lib.WordArray.create([0xdddddd05, 0x05050505]);
+            C.pad.Pkcs7.unpad(data);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd00], 3).toString(), data.toString());
+        }
+    }));
+}, '$Rev$');

package/test/pad-zeropadding-test.js

@@ -0,0 +1,28 @@
+YUI.add('pad-zeropadding-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'ZeroPadding',
+
+        testPad: function () {
+            var data = C.lib.WordArray.create([0xdddddd00], 3);
+            C.pad.ZeroPadding.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd00, 0x00000000]).toString(), data.toString());
+        },
+
+        testPadClamp: function () {
+            var data = C.lib.WordArray.create([0xdddddddd, 0xdddddddd], 3);
+            C.pad.ZeroPadding.pad(data, 2);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd00, 0x00000000]).toString(), data.toString());
+        },
+
+        testUnpad: function () {
+            var data = C.lib.WordArray.create([0xdddddd00, 0x00000000]);
+            C.pad.ZeroPadding.unpad(data);
+
+            Y.Assert.areEqual(C.lib.WordArray.create([0xdddddd00], 3).toString(), data.toString());
+        }
+    }));
+}, '$Rev$');

package/test/pbkdf2-profile.js

@@ -0,0 +1,11 @@
+YUI.add('algo-pbkdf2-profile', function (Y) {
+    var C = CryptoJS;
+
+    Y.Profiler.add({
+        name: 'PBKDF2',
+
+        profileKeySize256Iterations20: function () {
+            C.algo.PBKDF2.create({ keySize: 256/32, iterations: 20 }).compute('password', 'ATHENA.MIT.EDUraeburn');
+        }
+    });
+}, '$Rev$');

package/test/pbkdf2-test.js

@@ -0,0 +1,80 @@
+YUI.add('algo-pbkdf2-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'PBKDF2',
+
+        testKeySize128: function () {
+            Y.Assert.areEqual('62929ab995a1111c75c37bc562261ea3', C.PBKDF2('password', 'ATHENA.MIT.EDUraeburn', { keySize: 128/32 }).toString());
+        },
+
+        testKeySize256: function () {
+            Y.Assert.areEqual('62929ab995a1111c75c37bc562261ea3fb3cdc7e725c4ca87c03cec5bb7663e1', C.PBKDF2('password', 'ATHENA.MIT.EDUraeburn', { keySize: 256/32 }).toString());
+        },
+
+        testKeySize128Iterations2: function () {
+            Y.Assert.areEqual('262fb72ea65b44ab5ceba7f8c8bfa781', C.PBKDF2('password', 'ATHENA.MIT.EDUraeburn', { keySize: 128/32, iterations: 2 }).toString());
+        },
+
+        testKeySize256Iterations2: function () {
+            Y.Assert.areEqual('262fb72ea65b44ab5ceba7f8c8bfa7815ff9939204eb7357a59a75877d745777', C.PBKDF2('password', 'ATHENA.MIT.EDUraeburn', { keySize: 256/32, iterations: 2 }).toString());
+        },
+
+        testKeySize128Iterations1200: function () {
+            Y.Assert.areEqual('c76a982415f1acc71dc197273c5b6ada', C.PBKDF2('password', 'ATHENA.MIT.EDUraeburn', { keySize: 128/32, iterations: 1200 }).toString());
+        },
+
+        testKeySize256Iterations1200: function () {
+            Y.Assert.areEqual('c76a982415f1acc71dc197273c5b6ada32f62915ed461718aad32843762433fa', C.PBKDF2('password', 'ATHENA.MIT.EDUraeburn', { keySize: 256/32, iterations: 1200 }).toString());
+        },
+
+        testKeySize128Iterations5: function () {
+            Y.Assert.areEqual('74e98b2e9eeddaab3113c1efc6d82b07', C.PBKDF2('password', C.enc.Hex.parse('1234567878563412'), { keySize: 128/32, iterations: 5 }).toString());
+        },
+
+        testKeySize256Iterations5: function () {
+            Y.Assert.areEqual('74e98b2e9eeddaab3113c1efc6d82b073c4860195b3e0737fa21a4778f376321', C.PBKDF2('password', C.enc.Hex.parse('1234567878563412'), { keySize: 256/32, iterations: 5 }).toString());
+        },
+
+        testKeySize128Iterations1200PassPhraseEqualsBlockSize: function () {
+            Y.Assert.areEqual('c1dfb29a4d2f2fb67c6f78d074d66367', C.PBKDF2('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', 'pass phrase equals block size', { keySize: 128/32, iterations: 1200 }).toString());
+        },
+
+        testKeySize256Iterations1200PassPhraseEqualsBlockSize: function () {
+            Y.Assert.areEqual('c1dfb29a4d2f2fb67c6f78d074d663671e6fd4da1e598572b1fecf256cb7cf61', C.PBKDF2('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', 'pass phrase equals block size', { keySize: 256/32, iterations: 1200 }).toString());
+        },
+
+        testKeySize128Iterations1200PassPhraseExceedsBlockSize: function () {
+            Y.Assert.areEqual('22344bc4b6e32675a8090f3ea80be01d', C.PBKDF2('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', 'pass phrase exceeds block size', { keySize: 128/32, iterations: 1200 }).toString());
+        },
+
+        testKeySize256Iterations1200PassPhraseExceedsBlockSize: function () {
+            Y.Assert.areEqual('22344bc4b6e32675a8090f3ea80be01d5f95126a2cddc3facc4a5e6dca04ec58', C.PBKDF2('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', 'pass phrase exceeds block size', { keySize: 256/32, iterations: 1200 }).toString());
+        },
+
+        testKeySize128Iterations50: function () {
+            Y.Assert.areEqual('44b0781253db3141ac4174af29325818', C.PBKDF2(C.enc.Hex.parse('f09d849e'), 'EXAMPLE.COMpianist', { keySize: 128/32, iterations: 50 }).toString());
+        },
+
+        testKeySize256Iterations50: function () {
+            Y.Assert.areEqual('44b0781253db3141ac4174af29325818584698d507a79f9879033dec308a2b77', C.PBKDF2(C.enc.Hex.parse('f09d849e'), 'EXAMPLE.COMpianist', { keySize: 256/32, iterations: 50 }).toString());
+        },
+
+        testInputIntegrity: function () {
+            var password = C.lib.WordArray.create([0x12345678]);
+            var salt = C.lib.WordArray.create([0x12345678]);
+
+            var expectedPassword = password.toString();
+            var expectedSalt = salt.toString();
+
+            C.PBKDF2(password, salt);
+
+            Y.Assert.areEqual(expectedPassword, password.toString());
+            Y.Assert.areEqual(expectedSalt, salt.toString());
+        },
+
+        testHelper: function () {
+            Y.Assert.areEqual(C.algo.PBKDF2.create({ keySize: 128/32 }).compute('password', 'ATHENA.MIT.EDUraeburn').toString(), C.PBKDF2('password', 'ATHENA.MIT.EDUraeburn', { keySize: 128/32 }).toString());
+        }
+    }));
+}, '$Rev$');