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

package/test/hmac-sha512-test.js

@@ -0,0 +1,59 @@
+YUI.add('algo-hmac-sha512-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'HMAC SHA512',
+
+        testVector1: function () {
+            Y.Assert.areEqual('7641c48a3b4aa8f887c07b3e83f96affb89c978fed8c96fcbbf4ad596eebfe496f9f16da6cd080ba393c6f365ad72b50d15c71bfb1d6b81f66a911786c6ce932', C.HmacSHA512('Hi There', C.enc.Hex.parse('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b')).toString());
+        },
+
+        testVector2: function () {
+            Y.Assert.areEqual('164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737', C.HmacSHA512('what do ya want for nothing?', 'Jefe').toString());
+        },
+
+        testVector3: function () {
+            Y.Assert.areEqual('ad9b5c7de72693737cd5e9d9f41170d18841fec1201c1c1b02e05cae116718009f771cad9946ddbf7e3cde3e818d9ae85d91b2badae94172d096a44a79c91e86', C.HmacSHA512(C.enc.Hex.parse('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd'), C.enc.Hex.parse('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')).toString());
+        },
+
+        testVector4: function () {
+            Y.Assert.areEqual('a303979f7c94bb39a8ab6ce05cdbe28f0255da8bb305263e3478ef7e855f0242729bf1d2be55398f14da8e63f0302465a8a3f76c297bd584ad028d18ed7f0195', C.HmacSHA512('ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'A').toString());
+        },
+
+        testVector5: function () {
+            Y.Assert.areEqual('8c2d56f7628325e62124c0a870ad98d101327fc42696899a06ce0d7121454022fae597e42c25ac3a4c380fd514f553702a5b0afaa9b5a22050902f024368e9d9', C.HmacSHA512('abcdefghijklmnopqrstuvwxyz', 'A').toString());
+        },
+
+        testUpdate: function () {
+            var hmac = C.algo.HMAC.create(C.algo.SHA512, C.enc.Hex.parse('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'));
+            hmac.update(C.enc.Hex.parse('dddddddddddddddddddddddddddddddddddd'));
+            hmac.update(C.enc.Hex.parse('dddddddddddddddddddddddddddddddd'));
+            hmac.update(C.enc.Hex.parse('dddddddddddddddddddddddddddddddd'));
+
+            Y.Assert.areEqual(C.HmacSHA512(C.enc.Hex.parse('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd'), C.enc.Hex.parse('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')).toString(), hmac.finalize().toString());
+        },
+
+        testInputIntegrity: function () {
+            var message = C.lib.WordArray.create([0x12345678]);
+            var key = C.lib.WordArray.create([0x12345678]);
+
+            var expectedMessage = message.toString();
+            var expectedKey = key.toString();
+
+            C.HmacSHA512(message, key);
+
+            Y.Assert.areEqual(expectedMessage, message.toString());
+            Y.Assert.areEqual(expectedKey, key.toString());
+        },
+
+        testRespectKeySigBytes: function () {
+            var key = C.lib.WordArray.random(8);
+            key.sigBytes = 4;
+
+            var keyClamped = key.clone();
+            keyClamped.clamp();
+
+            Y.Assert.areEqual(CryptoJS.HmacSHA512("Message", keyClamped).toString(), CryptoJS.HmacSHA512("Message", key).toString());
+        }
+    }));
+}, '$Rev$');

package/test/kdf-openssl-test.js

@@ -0,0 +1,15 @@
+YUI.add('kdf-openssl-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'OpenSSLKdf',
+
+        testVector: function () {
+            var derivedParams = C.kdf.OpenSSL.execute('password', 256/32, 128/32, C.enc.Hex.parse('0a9d8620cf7219f1'));
+
+            Y.Assert.areEqual('50f32e0ec9408e02ff42364a52aac95c3694fc027256c6f488bf84b8e60effcd', derivedParams.key.toString());
+            Y.Assert.areEqual('81381e39b94fd692dff7e2239a298cb6', derivedParams.iv.toString());
+            Y.Assert.areEqual('0a9d8620cf7219f1', derivedParams.salt.toString());
+        }
+    }));
+}, '$Rev$');

package/test/lib-base-test.js

@@ -0,0 +1,92 @@
+YUI.add('lib-base-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'Base',
+
+        setUp: function () {
+            this.data = {};
+
+            this.data.overrides = {
+                init: function (arg) {
+                    this.initFired = true;
+                    this.initArg = arg;
+                },
+
+                toString: function () {
+                }
+            };
+
+            this.data.mixins = {
+                mixinMethod: function () {
+                }
+            };
+
+            this.data.Obj = C.lib.Base.extend(this.data.overrides);
+
+            this.data.Obj.mixIn(this.data.mixins);
+
+            this.data.obj = this.data.Obj.create('argValue');
+
+            this.data.objClone = this.data.obj.clone();
+        },
+
+        testExtendInheritance: function () {
+            Y.Assert.areEqual(C.lib.Base.extend, this.data.Obj.extend);
+            Y.Assert.isFalse(this.data.Obj.hasOwnProperty('extend'));
+        },
+
+        testExtendSuper: function () {
+            Y.Assert.areEqual(C.lib.Base, this.data.Obj.$super);
+        },
+
+        testExtendOverrideInit: function () {
+            Y.Assert.areEqual(this.data.overrides.init, this.data.Obj.init);
+            Y.Assert.isTrue(this.data.Obj.hasOwnProperty('init'));
+        },
+
+        testExtendOverrideToString: function () {
+            Y.Assert.areEqual(this.data.overrides.toString, this.data.Obj.toString);
+            Y.Assert.isTrue(this.data.Obj.hasOwnProperty('toString'));
+        },
+
+        testCreateInheritanceFromBase: function () {
+            Y.Assert.areEqual(C.lib.Base.extend, this.data.obj.extend);
+            Y.Assert.isFalse(this.data.obj.hasOwnProperty('extend'));
+        },
+
+        testCreateSuper: function () {
+            Y.Assert.areEqual(this.data.Obj, this.data.obj.$super);
+        },
+
+        testCreateInit: function () {
+            Y.Assert.isTrue(this.data.obj.initFired);
+            Y.Assert.areEqual('argValue', this.data.obj.initArg);
+        },
+
+        testMixIn: function () {
+            Y.Assert.areEqual(this.data.mixins.mixinMethod, this.data.Obj.mixinMethod);
+            Y.Assert.isTrue(this.data.Obj.hasOwnProperty('mixinMethod'));
+        },
+
+        testCloneDistinct: function () {
+            Y.Assert.areNotEqual(this.data.obj, this.data.objClone);
+        },
+
+        testCloneCopy: function () {
+            Y.Assert.areEqual(this.data.obj.initArg, this.data.objClone.initArg);
+        },
+
+        testCloneIndependent: function () {
+            this.data.obj.initArg = 'newValue';
+
+            Y.Assert.areNotEqual(this.data.obj.initArg, this.data.objClone.initArg);
+        },
+
+        testCloneLeavesOriginalInitPrototypeUnchanged: function() {
+            Y.Assert.areEqual(this.data.obj, this.data.obj.init.prototype);
+            Y.Assert.areEqual(this.data.objClone, this.data.objClone.init.prototype);
+            Y.Assert.areNotEqual(this.data.obj.init.prototype, this.data.objClone.init.prototype);
+        }
+    }));
+}, '$Rev$');

package/test/lib-cipherparams-test.js

@@ -0,0 +1,59 @@
+YUI.add('lib-cipherparams-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'CipherParams',
+
+        setUp: function () {
+            this.data = {};
+
+            this.data.ciphertext = C.enc.Hex.parse('000102030405060708090a0b0c0d0e0f');
+            this.data.key = C.enc.Hex.parse('101112131415161718191a1b1c1d1e1f');
+            this.data.iv = C.enc.Hex.parse('202122232425262728292a2b2c2d2e2f');
+            this.data.salt = C.enc.Hex.parse('0123456789abcdef');
+            this.data.algorithm = C.algo.AES;
+            this.data.mode = C.mode.CBC;
+            this.data.padding = C.pad.PKCS7;
+            this.data.blockSize = this.data.algorithm.blockSize;
+            this.data.formatter = C.format.OpenSSL;
+
+            this.data.cipherParams = C.lib.CipherParams.create({
+                ciphertext: this.data.ciphertext,
+                key: this.data.key,
+                iv: this.data.iv,
+                salt: this.data.salt,
+                algorithm: this.data.algorithm,
+                mode: this.data.mode,
+                padding: this.data.padding,
+                blockSize: this.data.blockSize,
+                formatter: this.data.formatter
+            });
+        },
+
+        testInit: function () {
+            Y.Assert.areEqual(this.data.ciphertext, this.data.cipherParams.ciphertext);
+            Y.Assert.areEqual(this.data.key, this.data.cipherParams.key);
+            Y.Assert.areEqual(this.data.iv, this.data.cipherParams.iv);
+            Y.Assert.areEqual(this.data.salt, this.data.cipherParams.salt);
+            Y.Assert.areEqual(this.data.algorithm, this.data.cipherParams.algorithm);
+            Y.Assert.areEqual(this.data.mode, this.data.cipherParams.mode);
+            Y.Assert.areEqual(this.data.padding, this.data.cipherParams.padding);
+            Y.Assert.areEqual(this.data.blockSize, this.data.cipherParams.blockSize);
+            Y.Assert.areEqual(this.data.formatter, this.data.cipherParams.formatter);
+        },
+
+        testToString0: function () {
+            Y.Assert.areEqual(C.format.OpenSSL.stringify(this.data.cipherParams), this.data.cipherParams.toString());
+        },
+
+        testToString1: function () {
+            var JsonFormatter = {
+                stringify: function (cipherParams) {
+                    return '{ ct: ' + cipherParams.ciphertext + ', iv: ' + cipherParams.iv + ' }';
+                }
+            };
+
+            Y.Assert.areEqual(JsonFormatter.stringify(this.data.cipherParams), this.data.cipherParams.toString(JsonFormatter));
+        }
+    }));
+}, '$Rev$');

package/test/lib-passwordbasedcipher-test.js

@@ -0,0 +1,25 @@
+YUI.add('lib-passwordbasedcipher-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'PasswordBasedCipher',
+
+        testEncrypt: function () {
+            // Compute actual
+            var actual = C.lib.PasswordBasedCipher.encrypt(C.algo.AES, 'Hello, World!', 'password');
+
+            // Compute expected
+            var aes = C.algo.AES.createEncryptor(actual.key, { iv: actual.iv });
+            var expected = aes.finalize('Hello, World!');
+
+            Y.Assert.areEqual(expected.toString(), actual.ciphertext.toString());
+        },
+
+        testDecrypt: function () {
+            var ciphertext = C.lib.PasswordBasedCipher.encrypt(C.algo.AES, 'Hello, World!', 'password');
+            var plaintext = C.lib.PasswordBasedCipher.decrypt(C.algo.AES, ciphertext, 'password');
+
+            Y.Assert.areEqual('Hello, World!', plaintext.toString(C.enc.Utf8));
+        }
+    }));
+}, '$Rev$');

package/test/lib-serializablecipher-test.js

@@ -0,0 +1,51 @@
+YUI.add('lib-serializablecipher-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'SerializableCipher',
+
+        setUp: function () {
+            this.data = {};
+
+            this.data.message = C.lib.WordArray.create([0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f]);
+            this.data.key = C.lib.WordArray.create([0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f]);
+            this.data.iv = C.lib.WordArray.create([0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f]);
+        },
+
+        testEncrypt: function () {
+            // Compute expected
+            var aes = C.algo.AES.createEncryptor(this.data.key, { iv: this.data.iv });
+            var ciphertext = aes.finalize(this.data.message);
+            var expected = C.lib.CipherParams.create({
+                ciphertext: ciphertext,
+                key: this.data.key,
+                iv: this.data.iv,
+                algorithm: C.algo.AES,
+                mode: aes.cfg.mode,
+                padding: aes.cfg.padding,
+                blockSize: aes.blockSize,
+                formatter: C.format.OpenSSL
+            });
+
+            // Compute actual
+            var actual = C.lib.SerializableCipher.encrypt(C.algo.AES, this.data.message, this.data.key, { iv: this.data.iv });
+
+            // Test
+            Y.Assert.areEqual(expected.toString(), actual.toString());
+            Y.Assert.areEqual(expected.ciphertext.toString(), actual.ciphertext.toString());
+            Y.Assert.areEqual(expected.key.toString(), actual.key.toString());
+            Y.Assert.areEqual(expected.iv.toString(), actual.iv.toString());
+            Y.Assert.areEqual(expected.algorithm, actual.algorithm);
+            Y.Assert.areEqual(expected.mode, actual.mode);
+            Y.Assert.areEqual(expected.padding, actual.padding);
+            Y.Assert.areEqual(expected.blockSize, actual.blockSize);
+        },
+
+        testDecrypt: function () {
+            var encrypted = C.lib.SerializableCipher.encrypt(C.algo.AES, this.data.message, this.data.key, { iv: this.data.iv }) + '';
+            var decrypted = C.lib.SerializableCipher.decrypt(C.algo.AES, encrypted, this.data.key, { iv: this.data.iv });
+
+            Y.Assert.areEqual(this.data.message.toString(), decrypted.toString());
+        }
+    }));
+}, '$Rev$');

package/test/lib-typedarrays-test.js

@@ -0,0 +1,57 @@
+YUI.add('lib-wordarray-test', function (Y) {
+    var C = CryptoJS;
+
+    if (typeof ArrayBuffer != 'undefined') {
+        Y.Test.Runner.add(new Y.Test.Case({
+            name: 'TypedArrays',
+
+            setUp: function () {
+                this.data = {};
+
+                this.data.buffer = new ArrayBuffer(8);
+
+                var uint8View = new Uint8Array(this.data.buffer);
+                uint8View[0] = 0x01;
+                uint8View[1] = 0x23;
+                uint8View[2] = 0x45;
+                uint8View[3] = 0x67;
+                uint8View[4] = 0x89;
+                uint8View[5] = 0xab;
+                uint8View[6] = 0xcd;
+                uint8View[7] = 0xef;
+            },
+
+            testInt8Array: function () {
+                Y.Assert.areEqual('0123456789abcdef', C.lib.WordArray.create(new Int8Array(this.data.buffer)).toString());
+            },
+
+            testUint8Array: function () {
+                Y.Assert.areEqual('0123456789abcdef', C.lib.WordArray.create(new Uint8Array(this.data.buffer)).toString());
+            },
+
+            testUint8ClampedArray: function () {
+                Y.Assert.areEqual('0123456789abcdef', C.lib.WordArray.create(new Uint8ClampedArray(this.data.buffer)).toString());
+            },
+
+            testInt16Array: function () {
+                Y.Assert.areEqual('0123456789abcdef', C.lib.WordArray.create(new Int16Array(this.data.buffer)).toString());
+            },
+
+            testUint16Array: function () {
+                Y.Assert.areEqual('0123456789abcdef', C.lib.WordArray.create(new Uint16Array(this.data.buffer)).toString());
+            },
+
+            testInt32Array: function () {
+                Y.Assert.areEqual('0123456789abcdef', C.lib.WordArray.create(new Int32Array(this.data.buffer)).toString());
+            },
+
+            testUint32Array: function () {
+                Y.Assert.areEqual('0123456789abcdef', C.lib.WordArray.create(new Uint32Array(this.data.buffer)).toString());
+            },
+
+            testPartialView: function () {
+                Y.Assert.areEqual('456789ab', C.lib.WordArray.create(new Int16Array(this.data.buffer, 2, 2)).toString());
+            }
+        }));
+    }
+}, '$Rev$');

package/test/lib-wordarray-test.js

@@ -0,0 +1,85 @@
+YUI.add('lib-wordarray-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'WordArray',
+
+        testInit0: function () {
+            Y.Assert.areEqual('', C.lib.WordArray.create().toString());
+        },
+
+        testInit1: function () {
+            Y.Assert.areEqual('12345678', C.lib.WordArray.create([0x12345678]).toString());
+        },
+
+        testInit2: function () {
+            Y.Assert.areEqual('1234', C.lib.WordArray.create([0x12345678], 2).toString());
+        },
+
+        testToStringPassedEncoder: function () {
+            Y.Assert.areEqual('\x12\x34\x56\x78', C.lib.WordArray.create([0x12345678]).toString(C.enc.Latin1));
+        },
+
+        testToStringDefaultEncoder: function () {
+            Y.Assert.areEqual('12345678', C.lib.WordArray.create([0x12345678]).toString());
+        },
+
+        testConcat3: function () {
+            var wordArray1 = C.lib.WordArray.create([0x12345678], 3);
+            var wordArray2 = C.lib.WordArray.create([0x12345678], 3);
+
+            Y.Assert.areEqual('123456123456', wordArray1.concat(wordArray2).toString());
+            Y.Assert.areEqual('123456123456', wordArray1.toString());
+        },
+
+        testConcat4: function () {
+            var wordArray1 = C.lib.WordArray.create([0x12345678], 4);
+            var wordArray2 = C.lib.WordArray.create([0x12345678], 3);
+
+            Y.Assert.areEqual('12345678123456', wordArray1.concat(wordArray2).toString());
+            Y.Assert.areEqual('12345678123456', wordArray1.toString());
+        },
+
+        testConcat5: function () {
+            var wordArray1 = C.lib.WordArray.create([0x12345678], 5);
+            var wordArray2 = C.lib.WordArray.create([0x12345678], 3);
+
+            Y.Assert.areEqual('1234567800123456', wordArray1.concat(wordArray2).toString());
+            Y.Assert.areEqual('1234567800123456', wordArray1.toString());
+        },
+
+        testConcatLong: function () {
+            var wordArray1 = C.lib.WordArray.create();
+
+            var wordArray2 = C.lib.WordArray.create();
+            var wordArray3 = C.lib.WordArray.create();
+            for (var i = 0; i < 500000; i++) {
+                wordArray2.words[i] = i;
+                wordArray3.words[i] = i;
+            }
+            wordArray2.sigBytes = wordArray3.sigBytes = 500000;
+
+            Y.Assert.areEqual(wordArray2.toString() + wordArray3.toString(), wordArray1.concat(wordArray2.concat(wordArray3)).toString());
+        },
+
+        testClamp: function () {
+            var wordArray = C.lib.WordArray.create([0x12345678, 0x12345678], 3);
+            wordArray.clamp();
+
+            Y.Assert.areEqual([0x12345600].toString(), wordArray.words.toString());
+        },
+
+        testClone: function () {
+            var wordArray = C.lib.WordArray.create([0x12345678]);
+            var clone = wordArray.clone();
+            clone.words[0] = 0;
+
+            Y.Assert.areNotEqual(wordArray.toString(), clone.toString());
+        },
+
+        testRandom: function () {
+            Y.Assert.areNotEqual(C.lib.WordArray.random(8).toString(), C.lib.WordArray.random(8).toString());
+            Y.Assert.areEqual(8, C.lib.WordArray.random(8).sigBytes);
+        }
+    }));
+}, '$Rev$');

package/test/md5-profile.js

@@ -0,0 +1,24 @@
+YUI.add('algo-md5-profile', function (Y) {
+    var C = CryptoJS;
+
+    Y.Profiler.add({
+        name: 'MD5',
+
+        profileSinglePartMessage: function () {
+            var singlePartMessage = '';
+            for (var i = 0; i < 500; i++) {
+                singlePartMessage += '12345678901234567890123456789012345678901234567890';
+            }
+
+            C.algo.MD5.create().finalize(singlePartMessage) + '';
+        },
+
+        profileMultiPartMessage: function () {
+            var md5 = C.algo.MD5.create();
+            for (var i = 0; i < 500; i++) {
+                md5.update('12345678901234567890123456789012345678901234567890');
+            }
+            md5.finalize() + '';
+        }
+    });
+}, '$Rev$');

package/test/md5-test.js

@@ -0,0 +1,70 @@
+YUI.add('algo-md5-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'MD5',
+
+        testVector1: function () {
+            Y.Assert.areEqual('d41d8cd98f00b204e9800998ecf8427e', C.MD5('').toString());
+        },
+
+        testVector2: function () {
+            Y.Assert.areEqual('0cc175b9c0f1b6a831c399e269772661', C.MD5('a').toString());
+        },
+
+        testVector3: function () {
+            Y.Assert.areEqual('900150983cd24fb0d6963f7d28e17f72', C.MD5('abc').toString());
+        },
+
+        testVector4: function () {
+            Y.Assert.areEqual('f96b697d7cb7938d525a2f31aaf161d0', C.MD5('message digest').toString());
+        },
+
+        testVector5: function () {
+            Y.Assert.areEqual('c3fcd3d76192e4007dfb496cca67e13b', C.MD5('abcdefghijklmnopqrstuvwxyz').toString());
+        },
+
+        testVector6: function () {
+            Y.Assert.areEqual('d174ab98d277d9f5a5611c2c9f419d9f', C.MD5('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789').toString());
+        },
+
+        testVector7: function () {
+            Y.Assert.areEqual('57edf4a22be3c955ac49da2e2107b67a', C.MD5('12345678901234567890123456789012345678901234567890123456789012345678901234567890').toString());
+        },
+
+        testUpdateAndLongMessage: function () {
+            var md5 = C.algo.MD5.create();
+            for (var i = 0; i < 100; i++) {
+                md5.update('12345678901234567890123456789012345678901234567890');
+            }
+
+            Y.Assert.areEqual('7d017545e0268a6a12f2b507871d0429', md5.finalize().toString());
+        },
+
+        testClone: function () {
+            var md5 = C.algo.MD5.create();
+
+            Y.Assert.areEqual(C.MD5('a').toString(), md5.update('a').clone().finalize().toString());
+            Y.Assert.areEqual(C.MD5('ab').toString(), md5.update('b').clone().finalize().toString());
+            Y.Assert.areEqual(C.MD5('abc').toString(), md5.update('c').clone().finalize().toString());
+        },
+
+        testInputIntegrity: function () {
+            var message = C.lib.WordArray.create([0x12345678]);
+
+            var expected = message.toString();
+
+            C.MD5(message);
+
+            Y.Assert.areEqual(expected, message.toString());
+        },
+
+        testHelper: function () {
+            Y.Assert.areEqual(C.algo.MD5.create().finalize('').toString(), C.MD5('').toString());
+        },
+
+        testHmacHelper: function () {
+            Y.Assert.areEqual(C.algo.HMAC.create(C.algo.MD5, C.enc.Hex.parse('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b')).finalize('Hi There').toString(), C.HmacMD5('Hi There', C.enc.Hex.parse('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b')).toString());
+        }
+    }));
+}, '$Rev$');

package/test/mode-cbc-test.js

@@ -0,0 +1,49 @@
+YUI.add('mode-cbc-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'CBC',
+
+        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 IV, then encrypted
+            for (var i = 0; i < 4; i++) {
+                expected.words[i] ^= this.data.iv.words[i];
+            }
+            aes.encryptBlock(expected.words, 0);
+
+            // Subsequent blocks XORed with previous crypted block, then encrypted
+            for (var i = 4; i < 8; i++) {
+                expected.words[i] ^= expected.words[i - 4];
+            }
+            aes.encryptBlock(expected.words, 4);
+
+            // Compute actual
+            var actual = C.AES.encrypt(this.data.message, this.data.key, { iv: this.data.iv, mode: C.mode.CBC, 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.CBC, padding: C.pad.NoPadding });
+            var decrypted = C.AES.decrypt(encrypted, this.data.key, { iv: this.data.iv, mode: C.mode.CBC, padding: C.pad.NoPadding });
+
+            Y.Assert.areEqual(this.data.message.toString(), decrypted.toString());
+        }
+    }));
+}, '$Rev$');

package/test/mode-cfb-test.js

@@ -0,0 +1,51 @@
+YUI.add('mode-cfb-test', function (Y) {
+    var C = CryptoJS;
+
+    Y.Test.Runner.add(new Y.Test.Case({
+        name: 'CFB',
+
+        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 crypted block
+            var keystream = expected.words.slice(0, 4);
+            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.CFB, 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.CFB, padding: C.pad.NoPadding });
+            var decrypted = C.AES.decrypt(encrypted, this.data.key, { iv: this.data.iv, mode: C.mode.CFB, padding: C.pad.NoPadding });
+
+            Y.Assert.areEqual(this.data.message.toString(), decrypted.toString());
+        }
+    }));
+}, '$Rev$');