no commit message
This commit is contained in:
niandeng
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,57 @@
|
||||
/**
|
||||
* ARC4Test
|
||||
*
|
||||
* A test class for ARC4
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.util.Hex;
|
||||
import flash.utils.ByteArray;
|
||||
import com.hurlant.crypto.prng.ARC4;
|
||||
|
||||
public class ARC4Test extends TestCase
|
||||
{
|
||||
public function ARC4Test(h:ITestHarness)
|
||||
{
|
||||
super(h, "ARC4 Test");
|
||||
runTest(testLameVectors,"ARC4 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sad test vectors pilfered from
|
||||
* http://en.wikipedia.org/wiki/RC4
|
||||
*/
|
||||
public function testLameVectors():void {
|
||||
var keys:Array = [
|
||||
Hex.fromString("Key"),
|
||||
Hex.fromString("Wiki"),
|
||||
Hex.fromString("Secret")];
|
||||
var pts:Array = [
|
||||
Hex.fromString("Plaintext"),
|
||||
Hex.fromString("pedia"),
|
||||
Hex.fromString("Attack at dawn")];
|
||||
var cts:Array = [
|
||||
"BBF316E8D940AF0AD3",
|
||||
"1021BF0420",
|
||||
"45A01F645FC35B383552544B9BF5"];
|
||||
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var rc4:ARC4 = new ARC4(key);
|
||||
rc4.encrypt(pt);
|
||||
var out:String = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+cts[i]+" to "+out, cts[i]==out);
|
||||
// now go back to plaintext
|
||||
rc4.decrypt(pt);
|
||||
out = Hex.fromArray(pt);
|
||||
assert("comparing "+pts[i]+" to "+out, pts[i]==out);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.math.BigInteger;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
public class BigIntegerTest extends TestCase
|
||||
{
|
||||
public function BigIntegerTest(h:ITestHarness)
|
||||
{
|
||||
super(h, "BigInteger Tests");
|
||||
runTest(testAdd, "BigInteger Addition");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
public function testAdd():void {
|
||||
var n1:BigInteger = BigInteger.nbv(25);
|
||||
var n2:BigInteger = BigInteger.nbv(1002);
|
||||
var n3:BigInteger = n1.add(n2);
|
||||
var v:int = n3.valueOf();
|
||||
assert("25+1002 = "+v, 25+1002==v);
|
||||
|
||||
var p:BigInteger = new BigInteger(Hex.toArray("e564d8b801a61f47"));
|
||||
var xp:BigInteger = new BigInteger(Hex.toArray("99246db2a3507fa"));
|
||||
|
||||
xp = xp.add(p);
|
||||
|
||||
assert("xp==eef71f932bdb2741", xp.toString(16)=="eef71f932bdb2741");
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
/**
|
||||
* BlowFishKeyTest
|
||||
*
|
||||
* A test class for BlowFishKey
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.symmetric.BlowFishKey;
|
||||
import com.hurlant.util.Hex;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class BlowFishKeyTest extends TestCase
|
||||
{
|
||||
public function BlowFishKeyTest(h:ITestHarness)
|
||||
{
|
||||
super(h, "BlowFishKey Test");
|
||||
runTest(testECB,"BlowFish ECB Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test vectors from http://www.schneier.com/code/vectors.txt
|
||||
*/
|
||||
public function testECB():void {
|
||||
var keys:Array = [
|
||||
"0000000000000000",
|
||||
"FFFFFFFFFFFFFFFF",
|
||||
"3000000000000000",
|
||||
"1111111111111111",
|
||||
"0123456789ABCDEF",
|
||||
"1111111111111111",
|
||||
"0000000000000000",
|
||||
"FEDCBA9876543210",
|
||||
"7CA110454A1A6E57",
|
||||
"0131D9619DC1376E",
|
||||
"07A1133E4A0B2686",
|
||||
"3849674C2602319E",
|
||||
"04B915BA43FEB5B6",
|
||||
"0113B970FD34F2CE",
|
||||
"0170F175468FB5E6",
|
||||
"43297FAD38E373FE",
|
||||
"07A7137045DA2A16",
|
||||
"04689104C2FD3B2F",
|
||||
"37D06BB516CB7546",
|
||||
"1F08260D1AC2465E",
|
||||
"584023641ABA6176",
|
||||
"025816164629B007",
|
||||
"49793EBC79B3258F",
|
||||
"4FB05E1515AB73A7",
|
||||
"49E95D6D4CA229BF",
|
||||
"018310DC409B26D6",
|
||||
"1C587F1C13924FEF",
|
||||
"0101010101010101",
|
||||
"1F1F1F1F0E0E0E0E",
|
||||
"E0FEE0FEF1FEF1FE",
|
||||
"0000000000000000",
|
||||
"FFFFFFFFFFFFFFFF",
|
||||
"0123456789ABCDEF",
|
||||
"FEDCBA9876543210" ];
|
||||
var pts:Array = [
|
||||
"0000000000000000",
|
||||
"FFFFFFFFFFFFFFFF",
|
||||
"1000000000000001",
|
||||
"1111111111111111",
|
||||
"1111111111111111",
|
||||
"0123456789ABCDEF",
|
||||
"0000000000000000",
|
||||
"0123456789ABCDEF",
|
||||
"01A1D6D039776742",
|
||||
"5CD54CA83DEF57DA",
|
||||
"0248D43806F67172",
|
||||
"51454B582DDF440A",
|
||||
"42FD443059577FA2",
|
||||
"059B5E0851CF143A",
|
||||
"0756D8E0774761D2",
|
||||
"762514B829BF486A",
|
||||
"3BDD119049372802",
|
||||
"26955F6835AF609A",
|
||||
"164D5E404F275232",
|
||||
"6B056E18759F5CCA",
|
||||
"004BD6EF09176062",
|
||||
"480D39006EE762F2",
|
||||
"437540C8698F3CFA",
|
||||
"072D43A077075292",
|
||||
"02FE55778117F12A",
|
||||
"1D9D5C5018F728C2",
|
||||
"305532286D6F295A",
|
||||
"0123456789ABCDEF",
|
||||
"0123456789ABCDEF",
|
||||
"0123456789ABCDEF",
|
||||
"FFFFFFFFFFFFFFFF",
|
||||
"0000000000000000",
|
||||
"0000000000000000",
|
||||
"FFFFFFFFFFFFFFFF" ];
|
||||
var cts:Array = [
|
||||
"4EF997456198DD78",
|
||||
"51866FD5B85ECB8A",
|
||||
"7D856F9A613063F2",
|
||||
"2466DD878B963C9D",
|
||||
"61F9C3802281B096",
|
||||
"7D0CC630AFDA1EC7",
|
||||
"4EF997456198DD78",
|
||||
"0ACEAB0FC6A0A28D",
|
||||
"59C68245EB05282B",
|
||||
"B1B8CC0B250F09A0",
|
||||
"1730E5778BEA1DA4",
|
||||
"A25E7856CF2651EB",
|
||||
"353882B109CE8F1A",
|
||||
"48F4D0884C379918",
|
||||
"432193B78951FC98",
|
||||
"13F04154D69D1AE5",
|
||||
"2EEDDA93FFD39C79",
|
||||
"D887E0393C2DA6E3",
|
||||
"5F99D04F5B163969",
|
||||
"4A057A3B24D3977B",
|
||||
"452031C1E4FADA8E",
|
||||
"7555AE39F59B87BD",
|
||||
"53C55F9CB49FC019",
|
||||
"7A8E7BFA937E89A3",
|
||||
"CF9C5D7A4986ADB5",
|
||||
"D1ABB290658BC778",
|
||||
"55CB3774D13EF201",
|
||||
"FA34EC4847B268B2",
|
||||
"A790795108EA3CAE",
|
||||
"C39E072D9FAC631D",
|
||||
"014933E0CDAFF6E4",
|
||||
"F21E9A77B71C49BC",
|
||||
"245946885754369A",
|
||||
"6B5C5A9C5D9E0A5A" ];
|
||||
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var bf:BlowFishKey = new BlowFishKey(key);
|
||||
bf.encrypt(pt);
|
||||
var out:String = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+cts[i]+" to "+out, cts[i]==out);
|
||||
// now go back to plaintext
|
||||
bf.decrypt(pt);
|
||||
out = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+pts[i]+" to "+out, pts[i]==out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,160 @@
|
||||
/**
|
||||
* CBCModeTest
|
||||
*
|
||||
* A test class for CBCMode
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.symmetric.AESKey;
|
||||
import com.hurlant.crypto.symmetric.CBCMode;
|
||||
import com.hurlant.crypto.symmetric.NullPad;
|
||||
import com.hurlant.crypto.symmetric.XTeaKey;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class CBCModeTest extends TestCase
|
||||
{
|
||||
public function CBCModeTest(h:ITestHarness) {
|
||||
super(h, "CBCMode Test");
|
||||
runTest(testAES,"CBC AES Test Vectors");
|
||||
runTest(testXTea,"CBC XTea Test Vectors");
|
||||
//
|
||||
runTest(testCBC_AES128, "CBC AES-128 Test Vectors");
|
||||
runTest(testCBC_AES192, "CBC AES-192 Test Vectors");
|
||||
runTest(testCBC_AES256, "CBC AES-256 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Hawt NIST Vectors: http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
* Section F.2.1 and below.
|
||||
*/
|
||||
public function testCBC_AES128():void {
|
||||
var key:ByteArray = Hex.toArray("2b7e151628aed2a6abf7158809cf4f3c");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"7649abac8119b246cee98e9b12e9197d" +
|
||||
"5086cb9b507219ee95db113a917678b2" +
|
||||
"73bed6b8e3c1743b7116e69e22229516" +
|
||||
"3ff1caa1681fac09120eca307586e1a7");
|
||||
var cbc:CBCMode = new CBCMode(new AESKey(key), new NullPad);
|
||||
cbc.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
cbc.encrypt(src);
|
||||
assert("CBC_AES128 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
cbc.decrypt(src);
|
||||
assert("CBC_AES128 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
public function testCBC_AES192():void {
|
||||
var key:ByteArray = Hex.toArray("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"4f021db243bc633d7178183a9fa071e8" +
|
||||
"b4d9ada9ad7dedf4e5e738763f69145a" +
|
||||
"571b242012fb7ae07fa9baac3df102e0" +
|
||||
"08b0e27988598881d920a9e64f5615cd");
|
||||
var cbc:CBCMode = new CBCMode(new AESKey(key), new NullPad);
|
||||
cbc.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
cbc.encrypt(src);
|
||||
assert("CBC_AES192 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
cbc.decrypt(src);
|
||||
assert("CBC_AES192 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
public function testCBC_AES256():void {
|
||||
var key:ByteArray = Hex.toArray(
|
||||
"603deb1015ca71be2b73aef0857d7781" +
|
||||
"1f352c073b6108d72d9810a30914dff4");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"f58c4c04d6e5f1ba779eabfb5f7bfbd6" +
|
||||
"9cfc4e967edb808d679f777bc6702c7d" +
|
||||
"39f23369a9d9bacfa530e26304231461" +
|
||||
"b2eb05e2c39be9fcda6c19078c6a9d1b");
|
||||
var cbc:CBCMode = new CBCMode(new AESKey(key), new NullPad);
|
||||
cbc.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
cbc.encrypt(src);
|
||||
assert("CBC_AES256 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
cbc.decrypt(src);
|
||||
assert("CBC_AES256 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* For now the main goal is to show we can decrypt what we encrypt in this mode.
|
||||
* Eventually, this should get correlated with some well known vectors.
|
||||
*/
|
||||
public function testAES():void {
|
||||
var keys:Array = [
|
||||
"00010203050607080A0B0C0D0F101112",
|
||||
"14151617191A1B1C1E1F202123242526"];
|
||||
var cts:Array = [
|
||||
"D8F532538289EF7D06B506A4FD5BE9C94894C5508A8D8E29AB600DB0261F0555A8FA287B89E65C0973F1F8283E70C72863FE1C8F1F782084CE05626E961A67B3",
|
||||
"59AB30F4D4EE6E4FF9907EF65B1FB68C96890CE217689B1BE0C93ED51CF21BB5A0101A8C30714EC4F52DBC9C6F4126067D363F67ABE58463005E679B68F0B496"];
|
||||
var pts:Array = [
|
||||
"506812A45F08C889B97F5980038B8359506812A45F08C889B97F5980038B8359506812A45F08C889B97F5980038B8359",
|
||||
"5C6D71CA30DE8B8B00549984D2EC7D4B5C6D71CA30DE8B8B00549984D2EC7D4B5C6D71CA30DE8B8B00549984D2EC7D4B"];
|
||||
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var aes:AESKey = new AESKey(key);
|
||||
var cbc:CBCMode = new CBCMode(aes);
|
||||
cbc.IV = Hex.toArray("00000000000000000000000000000000");
|
||||
cbc.encrypt(pt);
|
||||
var str:String = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+cts[i]+" to "+str, cts[i]==str);
|
||||
// back to pt
|
||||
cbc.decrypt(pt);
|
||||
str = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+pts[i]+" to "+str, pts[i]==str);
|
||||
}
|
||||
}
|
||||
public function testXTea():void {
|
||||
var keys:Array=[
|
||||
"00000000000000000000000000000000",
|
||||
"2b02056806144976775d0e266c287843"];
|
||||
var cts:Array = [
|
||||
"2dc7e8d3695b0538d8f1640d46dca717790af2ab545e11f3b08e798eb3f17b1744299d4d20b534aa",
|
||||
"790958213819878370eb8251ffdac371081c5a457fc42502c63910306fea150be8674c3b8e675516"];
|
||||
var pts:Array=[
|
||||
"0000000000000000000000000000000000000000000000000000000000000000",
|
||||
"74657374206d652e74657374206d652e74657374206d652e74657374206d652e"];
|
||||
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var tea:XTeaKey = new XTeaKey(key);
|
||||
var cbc:CBCMode = new CBCMode(tea);
|
||||
cbc.IV = Hex.toArray("0000000000000000");
|
||||
cbc.encrypt(pt);
|
||||
var str:String = Hex.fromArray(pt);
|
||||
assert("comparing "+cts[i]+" to "+str, cts[i]==str);
|
||||
// now go back to plaintext.
|
||||
cbc.decrypt(pt);
|
||||
str = Hex.fromArray(pt);
|
||||
assert("comparing "+pts[i]+" to "+str, pts[i]==str);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
* CFB8ModeTest
|
||||
*
|
||||
* A test class for CFB8Mode
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
import com.hurlant.util.Hex;
|
||||
import com.hurlant.crypto.symmetric.CFB8Mode;
|
||||
import com.hurlant.crypto.symmetric.AESKey;
|
||||
import com.hurlant.crypto.symmetric.NullPad;
|
||||
|
||||
public class CFB8ModeTest extends TestCase
|
||||
{
|
||||
public function CFB8ModeTest(h:ITestHarness) {
|
||||
super(h,"CBF8Mode Test");
|
||||
runTest(testCFB8_AES128, "CFB-8 AES-128 Test Vectors");
|
||||
runTest(testCFB8_AES192, "CFB-8 AES-192 Test Vectors");
|
||||
runTest(testCFB8_AES256, "CFB-8 AES-192 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
*/
|
||||
public function testCFB8_AES128():void {
|
||||
var key:ByteArray = Hex.toArray("2b7e151628aed2a6abf7158809cf4f3c");
|
||||
var pt:ByteArray = Hex.toArray("6bc1bee22e409f96e93d7e117393172aae2d");
|
||||
var ct:ByteArray = Hex.toArray("3b79424c9c0dd436bace9e0ed4586a4f32b9");
|
||||
var cfb8:CFB8Mode = new CFB8Mode(new AESKey(key), new NullPad);
|
||||
cfb8.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
cfb8.encrypt(src);
|
||||
assert("CFB8_AES128 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
cfb8.decrypt(src);
|
||||
assert("CFB8_AES128 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
public function testCFB8_AES192():void {
|
||||
var key:ByteArray = Hex.toArray("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b");
|
||||
var pt:ByteArray = Hex.toArray("6bc1bee22e409f96e93d7e117393172aae2d");
|
||||
var ct:ByteArray = Hex.toArray("cda2521ef0a905ca44cd057cbf0d47a0678a");
|
||||
var cfb8:CFB8Mode = new CFB8Mode(new AESKey(key), new NullPad);
|
||||
cfb8.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
cfb8.encrypt(src);
|
||||
assert("CFB8_AES128 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
cfb8.decrypt(src);
|
||||
assert("CFB8_AES128 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
public function testCFB8_AES256():void {
|
||||
var key:ByteArray = Hex.toArray("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4");
|
||||
var pt:ByteArray = Hex.toArray("6bc1bee22e409f96e93d7e117393172aae2d");
|
||||
var ct:ByteArray = Hex.toArray("dc1f1a8520a64db55fcc8ac554844e889700");
|
||||
var cfb8:CFB8Mode = new CFB8Mode(new AESKey(key), new NullPad);
|
||||
cfb8.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
cfb8.encrypt(src);
|
||||
assert("CFB8_AES128 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
cfb8.decrypt(src);
|
||||
assert("CFB8_AES128 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* CFBModeTest
|
||||
*
|
||||
* A test class for CFBMode
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.symmetric.AESKey;
|
||||
import com.hurlant.crypto.symmetric.CFBMode;
|
||||
import com.hurlant.crypto.symmetric.NullPad;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class CFBModeTest extends TestCase
|
||||
{
|
||||
public function CFBModeTest(h:ITestHarness)
|
||||
{
|
||||
super(h, "CFBMode Test");
|
||||
runTest(testCFB_AES128, "CFB AES-128 Test Vectors");
|
||||
runTest(testCFB_AES192, "CFB AES-192 Test Vectors");
|
||||
runTest(testCFB_AES256, "CFB AES-256 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
*/
|
||||
public function testCFB_AES128():void {
|
||||
var key:ByteArray = Hex.toArray("2b7e151628aed2a6abf7158809cf4f3c");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"3b3fd92eb72dad20333449f8e83cfb4a" +
|
||||
"c8a64537a0b3a93fcde3cdad9f1ce58b" +
|
||||
"26751f67a3cbb140b1808cf187a4f4df" +
|
||||
"c04b05357c5d1c0eeac4c66f9ff7f2e6");
|
||||
var cfb:CFBMode = new CFBMode(new AESKey(key), new NullPad);
|
||||
cfb.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
cfb.encrypt(src);
|
||||
assert("CFB_AES128 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
cfb.decrypt(src);
|
||||
assert("CFB_AES128 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
public function testCFB_AES192():void {
|
||||
var key:ByteArray = Hex.toArray("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"cdc80d6fddf18cab34c25909c99a4174" +
|
||||
"67ce7f7f81173621961a2b70171d3d7a" +
|
||||
"2e1e8a1dd59b88b1c8e60fed1efac4c9" +
|
||||
"c05f9f9ca9834fa042ae8fba584b09ff");
|
||||
var cfb:CFBMode = new CFBMode(new AESKey(key), new NullPad);
|
||||
cfb.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
cfb.encrypt(src);
|
||||
assert("CFB_AES192 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
cfb.decrypt(src);
|
||||
assert("CFB_AES192 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
public function testCFB_AES256():void {
|
||||
var key:ByteArray = Hex.toArray(
|
||||
"603deb1015ca71be2b73aef0857d7781" +
|
||||
"1f352c073b6108d72d9810a30914dff4");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"dc7e84bfda79164b7ecd8486985d3860" +
|
||||
"39ffed143b28b1c832113c6331e5407b" +
|
||||
"df10132415e54b92a13ed0a8267ae2f9" +
|
||||
"75a385741ab9cef82031623d55b1e471");
|
||||
var cfb:CFBMode = new CFBMode(new AESKey(key), new NullPad);
|
||||
cfb.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
cfb.encrypt(src);
|
||||
assert("CFB_AES256 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
cfb.decrypt(src);
|
||||
assert("CFB_AES256 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
import com.hurlant.util.Hex;
|
||||
import com.hurlant.crypto.symmetric.CTRMode;
|
||||
import com.hurlant.crypto.symmetric.AESKey;
|
||||
import com.hurlant.crypto.symmetric.NullPad;
|
||||
|
||||
public class CTRModeTest extends TestCase
|
||||
{
|
||||
public function CTRModeTest(h:ITestHarness)
|
||||
{
|
||||
super(h, "CTRMode Test");
|
||||
runTest(testCTR_AES128, "CTR AES-128 Test Vectors");
|
||||
runTest(testCTR_AES192, "CTR AES-192 Test Vectors");
|
||||
runTest(testCTR_AES256, "CTR AES-256 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Vectors from http://csrc.nist.gov/CryptoToolkit/modes/800-38_Series_Publications/SP800-38A.pdf
|
||||
* Section F.5.1 and below.
|
||||
*/
|
||||
public function testCTR_AES128():void {
|
||||
var key:ByteArray = Hex.toArray("2b7e151628aed2a6abf7158809cf4f3c");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"874d6191b620e3261bef6864990db6ce" +
|
||||
"9806f66b7970fdff8617187bb9fffdff" +
|
||||
"5ae4df3edbd5d35e5b4f09020db03eab" +
|
||||
"1e031dda2fbe03d1792170a0f3009cee");
|
||||
var ctr:CTRMode = new CTRMode(new AESKey(key), new NullPad);
|
||||
ctr.IV = Hex.toArray("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
ctr.encrypt(src);
|
||||
var hsrc:String = Hex.fromArray(src);
|
||||
var hct:String = Hex.fromArray(ct);
|
||||
assert("CTR_AES128 test 1: "+hsrc+" != "+hct, hsrc==hct);
|
||||
ctr.decrypt(src);
|
||||
hsrc = Hex.fromArray(src);
|
||||
var hpt:String = Hex.fromArray(pt);
|
||||
assert("CTR_AES128 test 2: "+hsrc+" != "+hpt, hsrc==hpt);
|
||||
}
|
||||
public function testCTR_AES192():void {
|
||||
var key:ByteArray = Hex.toArray("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"1abc932417521ca24f2b0459fe7e6e0b" +
|
||||
"090339ec0aa6faefd5ccc2c6f4ce8e94" +
|
||||
"1e36b26bd1ebc670d1bd1d665620abf7" +
|
||||
"4f78a7f6d29809585a97daec58c6b050");
|
||||
var ctr:CTRMode = new CTRMode(new AESKey(key), new NullPad);
|
||||
ctr.IV = Hex.toArray("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
ctr.encrypt(src);
|
||||
var hsrc:String = Hex.fromArray(src);
|
||||
var hct:String = Hex.fromArray(ct);
|
||||
assert("CTR_AES192 test 1: "+hsrc+" != "+hct, hsrc==hct);
|
||||
ctr.decrypt(src);
|
||||
hsrc = Hex.fromArray(src);
|
||||
var hpt:String = Hex.fromArray(pt);
|
||||
assert("CTR_AES192 test 2: "+hsrc+" != "+hpt, hsrc==hpt);
|
||||
}
|
||||
public function testCTR_AES256():void {
|
||||
var key:ByteArray = Hex.toArray("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"601ec313775789a5b7a7f504bbf3d228" +
|
||||
"f443e3ca4d62b59aca84e990cacaf5c5" +
|
||||
"2b0930daa23de94ce87017ba2d84988d" +
|
||||
"dfc9c58db67aada613c2dd08457941a6");
|
||||
var ctr:CTRMode = new CTRMode(new AESKey(key), new NullPad);
|
||||
ctr.IV = Hex.toArray("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
ctr.encrypt(src);
|
||||
var hsrc:String = Hex.fromArray(src);
|
||||
var hct:String = Hex.fromArray(ct);
|
||||
assert("CTR_AES256 test 1: "+hsrc+" != "+hct, hsrc==hct);
|
||||
ctr.decrypt(src);
|
||||
hsrc = Hex.fromArray(src);
|
||||
var hpt:String = Hex.fromArray(pt);
|
||||
assert("CTR_AES256 test 2: "+hsrc+" != "+hpt, hsrc==hpt);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
/**
|
||||
* DesKeyTest
|
||||
*
|
||||
* A test class for DesKey
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.symmetric.DESKey;
|
||||
import com.hurlant.util.Hex;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class DESKeyTest extends TestCase
|
||||
{
|
||||
public function DESKeyTest(h:ITestHarness)
|
||||
{
|
||||
super(h, "DESKey Test");
|
||||
runTest(testECB,"DES ECB Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test vectors mostly grabbed from
|
||||
* http://csrc.nist.gov/publications/nistpubs/800-17/800-17.pdf
|
||||
* (Appendix A and B)
|
||||
* incomplete.
|
||||
*/
|
||||
public function testECB():void {
|
||||
var keys:Array = [
|
||||
"3b3898371520f75e", // grabbed from the output of some js implementation out there
|
||||
"10316E028C8F3B4A", // appendix A vector
|
||||
"0101010101010101", // appendix B Table 1, round 0
|
||||
"0101010101010101", // round 1
|
||||
"0101010101010101", // 2
|
||||
"0101010101010101",
|
||||
"0101010101010101",
|
||||
"0101010101010101",
|
||||
"0101010101010101",
|
||||
"0101010101010101",
|
||||
"0101010101010101", // round 8
|
||||
"8001010101010101", // app B, tbl 2, round 0
|
||||
"4001010101010101",
|
||||
"2001010101010101",
|
||||
"1001010101010101",
|
||||
"0801010101010101",
|
||||
"0401010101010101",
|
||||
"0201010101010101",
|
||||
"0180010101010101",
|
||||
"0140010101010101", // round 8
|
||||
];
|
||||
var pts:Array = [
|
||||
"0000000000000000", // js
|
||||
"0000000000000000", // App A
|
||||
"8000000000000000", // App B, tbl 1, rnd0
|
||||
"4000000000000000",
|
||||
"2000000000000000",
|
||||
"1000000000000000",
|
||||
"0800000000000000", // rnd 4
|
||||
"0400000000000000",
|
||||
"0200000000000000",
|
||||
"0100000000000000",
|
||||
"0080000000000000", // round 8
|
||||
"0000000000000000", // App B, tbl2, rnd0
|
||||
"0000000000000000",
|
||||
"0000000000000000",
|
||||
"0000000000000000",
|
||||
"0000000000000000",
|
||||
"0000000000000000",
|
||||
"0000000000000000",
|
||||
"0000000000000000",
|
||||
"0000000000000000", // rnd 8
|
||||
];
|
||||
var cts:Array = [
|
||||
"83A1E814889253E0", // js
|
||||
"82DCBAFBDEAB6602", // App A
|
||||
"95F8A5E5DD31D900", // App b, tbl 1, rnd 0
|
||||
"DD7F121CA5015619",
|
||||
"2E8653104F3834EA",
|
||||
"4BD388FF6CD81D4F",
|
||||
"20B9E767B2FB1456",
|
||||
"55579380D77138EF",
|
||||
"6CC5DEFAAF04512F",
|
||||
"0D9F279BA5D87260",
|
||||
"D9031B0271BD5A0A", // rnd 8
|
||||
"95A8D72813DAA94D", // App B, tbl 2, rnd 0
|
||||
"0EEC1487DD8C26D5",
|
||||
"7AD16FFB79C45926",
|
||||
"D3746294CA6A6CF3",
|
||||
"809F5F873C1FD761",
|
||||
"C02FAFFEC989D1FC",
|
||||
"4615AA1D33E72F10",
|
||||
"2055123350C00858",
|
||||
"DF3B99D6577397C8", // rnd 8
|
||||
];
|
||||
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var des:DESKey = new DESKey(key);
|
||||
des.encrypt(pt);
|
||||
var out:String = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+cts[i]+" to "+out, cts[i]==out);
|
||||
// now go back to plaintext
|
||||
des.decrypt(pt);
|
||||
out = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+pts[i]+" to "+out, pts[i]==out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
/**
|
||||
* ECBModeTest
|
||||
*
|
||||
* A test class for ECBMode
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.symmetric.AESKey;
|
||||
import com.hurlant.crypto.symmetric.ECBMode;
|
||||
import com.hurlant.crypto.symmetric.NullPad;
|
||||
import com.hurlant.crypto.symmetric.XTeaKey;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class ECBModeTest extends TestCase
|
||||
{
|
||||
public function ECBModeTest(h:ITestHarness) {
|
||||
super(h, "ECBMode Test");
|
||||
runTest(testAES,"ECB AES Test Vectors");
|
||||
runTest(testXTea,"ECB XTea Test Vectors");
|
||||
runTest(testECB_AES128,"ECB AES-128 Test Vectors");
|
||||
runTest(testECB_AES192,"ECB AES-192 Test Vectors");
|
||||
runTest(testECB_AES256,"ECB AES-256 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
/**
|
||||
* For now the main goal is to show we can decrypt what we encrypt in this mode.
|
||||
* Eventually, this should get correlated with some well known vectors.
|
||||
* yay. found hawt test vectors: http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
*/
|
||||
public function testECB_AES128():void {
|
||||
var key:ByteArray = Hex.toArray("2b7e151628aed2a6abf7158809cf4f3c");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"3ad77bb40d7a3660a89ecaf32466ef97" +
|
||||
"f5d3d58503b9699de785895a96fdbaaf" +
|
||||
"43b1cd7f598ece23881b00e3ed030688" +
|
||||
"7b0c785e27e8ad3f8223207104725dd4");
|
||||
var ecb:ECBMode = new ECBMode(new AESKey(key), new NullPad);
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
ecb.encrypt(src);
|
||||
assert("ECB_AES128 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
ecb.decrypt(src);
|
||||
assert("ECB_AES128 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
public function testECB_AES192():void {
|
||||
var key:ByteArray = Hex.toArray("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"bd334f1d6e45f25ff712a214571fa5cc" +
|
||||
"974104846d0ad3ad7734ecb3ecee4eef" +
|
||||
"ef7afd2270e2e60adce0ba2face6444e" +
|
||||
"9a4b41ba738d6c72fb16691603c18e0e");
|
||||
var ecb:ECBMode = new ECBMode(new AESKey(key), new NullPad);
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
ecb.encrypt(src);
|
||||
assert("ECB_AES192 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
ecb.decrypt(src);
|
||||
assert("ECB_AES192 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
public function testECB_AES256():void {
|
||||
var key:ByteArray = Hex.toArray(
|
||||
"603deb1015ca71be2b73aef0857d7781" +
|
||||
"1f352c073b6108d72d9810a30914dff4");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"f3eed1bdb5d2a03c064b5a7e3db181f8" +
|
||||
"591ccb10d410ed26dc5ba74a31362870" +
|
||||
"b6ed21b99ca6f4f9f153e7b1beafed1d" +
|
||||
"23304b7a39f9f3ff067d8d8f9e24ecc7");
|
||||
var ecb:ECBMode = new ECBMode(new AESKey(key), new NullPad);
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
ecb.encrypt(src);
|
||||
assert("ECB_AES256 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
ecb.decrypt(src);
|
||||
assert("ECB_AES256 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
// crappier, older testing. keeping around for no good reason.
|
||||
public function testAES():void {
|
||||
var keys:Array = [
|
||||
"00010203050607080A0B0C0D0F101112",
|
||||
"14151617191A1B1C1E1F202123242526"];
|
||||
var pts:Array = [
|
||||
"506812A45F08C889B97F5980038B8359506812A45F08C889B97F5980038B8359506812A45F08C889B97F5980038B8359",
|
||||
"5C6D71CA30DE8B8B00549984D2EC7D4B5C6D71CA30DE8B8B00549984D2EC7D4B5C6D71CA30DE8B8B00549984D2EC7D4B"];
|
||||
var cts:Array = [
|
||||
"D8F532538289EF7D06B506A4FD5BE9C9D8F532538289EF7D06B506A4FD5BE9C9D8F532538289EF7D06B506A4FD5BE9C96DE5F607AB7EB8202F3957703B04E8B5",
|
||||
"59AB30F4D4EE6E4FF9907EF65B1FB68C59AB30F4D4EE6E4FF9907EF65B1FB68C59AB30F4D4EE6E4FF9907EF65B1FB68C2993487785CB1CFDA6BB4F0F345F76C7"];
|
||||
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var aes:AESKey = new AESKey(key);
|
||||
var ecb:ECBMode = new ECBMode(aes);
|
||||
ecb.encrypt(pt);
|
||||
var str:String = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+cts[i]+" to "+str, cts[i]==str);
|
||||
// back to pt
|
||||
ecb.decrypt(pt);
|
||||
str = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+pts[i]+" to "+str, pts[i]==str);
|
||||
}
|
||||
}
|
||||
public function testXTea():void {
|
||||
var keys:Array=[
|
||||
"00000000000000000000000000000000",
|
||||
"2b02056806144976775d0e266c287843"];
|
||||
var pts:Array=[
|
||||
"0000000000000000000000000000000000000000000000000000000000000000",
|
||||
"74657374206d652e74657374206d652e74657374206d652e74657374206d652e"];
|
||||
var cts:Array=[
|
||||
"2dc7e8d3695b05382dc7e8d3695b05382dc7e8d3695b05382dc7e8d3695b053820578a874233632d",
|
||||
"79095821381987837909582138198783790958213819878379095821381987830e4dc3c48b2edf32"];
|
||||
// self-fullfilling vectors.
|
||||
// oh well, at least I can decrypt what I produce. :(
|
||||
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var tea:XTeaKey = new XTeaKey(key);
|
||||
var ecb:ECBMode = new ECBMode(tea);
|
||||
ecb.encrypt(pt);
|
||||
var str:String = Hex.fromArray(pt);
|
||||
assert("comparing "+cts[i]+" to "+str, cts[i]==str);
|
||||
// now go back to plaintext.
|
||||
ecb.decrypt(pt);
|
||||
str = Hex.fromArray(pt);
|
||||
assert("comparing "+pts[i]+" to "+str, pts[i]==str);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,184 @@
|
||||
/**
|
||||
* HMACTest
|
||||
*
|
||||
* A test class for HMAC
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.hash.HMAC;
|
||||
import com.hurlant.crypto.hash.MD5;
|
||||
import com.hurlant.crypto.hash.SHA1;
|
||||
import com.hurlant.crypto.hash.SHA224;
|
||||
import com.hurlant.crypto.hash.SHA256;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class HMACTest extends TestCase
|
||||
{
|
||||
public function HMACTest(h:ITestHarness)
|
||||
{
|
||||
super(h, "HMAC Test");
|
||||
runTest(testHMAC_MD5,"HMAC MD5 Test Vectors");
|
||||
runTest(testHMAC_SHA_1,"HMAC SHA-1 Test Vectors");
|
||||
runTest(testHMAC_SHA_2,"HMAC SHA-224/SHA-256 Test Vectors");
|
||||
runTest(testHMAC96_MD5,"HMAC-96 MD5 Test Vectors");
|
||||
runTest(testHMAC96_SHA_1,"HMAC-96 SHA-1 Test Vectors");
|
||||
runTest(testHMAC128_SHA_2,"HMAC-128 SHA-224/SHA-256 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
/**
|
||||
* Test vectors taking from RFC2202
|
||||
* http://tools.ietf.org/html/rfc2202
|
||||
* Yes, it's from an RFC, jefe! Now waddayawant?
|
||||
*/
|
||||
public function testHMAC_SHA_1():void {
|
||||
var keys:Array = [
|
||||
"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
|
||||
Hex.fromString("Jefe"),
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
"0102030405060708090a0b0c0d0e0f10111213141516171819",
|
||||
"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c",
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"];
|
||||
var pts:Array = [
|
||||
Hex.fromString("Hi There"),
|
||||
Hex.fromString("what do ya want for nothing?"),
|
||||
"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
|
||||
"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
|
||||
Hex.fromString("Test With Truncation"),
|
||||
Hex.fromString("Test Using Larger Than Block-Size Key - Hash Key First"),
|
||||
Hex.fromString("Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data")];
|
||||
var cts:Array = [
|
||||
"b617318655057264e28bc0b6fb378c8ef146be00",
|
||||
"effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
|
||||
"125d7342b9ac11cd91a39af48aa17b4f63f175d3",
|
||||
"4c9007f4026250c6bc8414f9bf50c86c2d7235da",
|
||||
"4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
|
||||
"aa4ae5e15272d00e95705637ce8a3b55ed402112",
|
||||
"e8e99d0f45237d786d6bbaa7965c7808bbff1a91"];
|
||||
|
||||
var hmac:HMAC = new HMAC(new SHA1());
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var digest:ByteArray = hmac.compute(key, pt);
|
||||
assert("HMAC-SHA-1 test "+i, Hex.fromArray(digest) == cts[i]);
|
||||
}
|
||||
}
|
||||
public function testHMAC96_SHA_1():void {
|
||||
var hmac:HMAC = new HMAC(new SHA1, 96);
|
||||
var key:ByteArray = Hex.toArray("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c");
|
||||
var pt:ByteArray = Hex.toArray(Hex.fromString("Test With Truncation"));
|
||||
var ct:String = "4c1a03424b55e07fe7f27be1";
|
||||
var digest:ByteArray = hmac.compute(key, pt);
|
||||
assert("HMAC96-SHA-1 test", Hex.fromArray(digest) == ct);
|
||||
}
|
||||
|
||||
public function testHMAC_MD5():void {
|
||||
var keys:Array = [
|
||||
Hex.fromString("Jefe"),
|
||||
"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
"0102030405060708090a0b0c0d0e0f10111213141516171819",
|
||||
"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c",
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"];
|
||||
var pts:Array = [
|
||||
Hex.fromString("what do ya want for nothing?"),
|
||||
Hex.fromString("Hi There"),
|
||||
"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
|
||||
"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
|
||||
Hex.fromString("Test With Truncation"),
|
||||
Hex.fromString("Test Using Larger Than Block-Size Key - Hash Key First"),
|
||||
Hex.fromString("Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data")];
|
||||
var cts:Array = [
|
||||
"750c783e6ab0b503eaa86e310a5db738",
|
||||
"9294727a3638bb1c13f48ef8158bfc9d",
|
||||
"56be34521d144c88dbb8c733f0e8b3f6",
|
||||
"697eaf0aca3a3aea3a75164746ffaa79",
|
||||
"56461ef2342edc00f9bab995690efd4c",
|
||||
"6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd",
|
||||
"6f630fad67cda0ee1fb1f562db3aa53e"];
|
||||
|
||||
var hmac:HMAC = new HMAC(new MD5());
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var digest:ByteArray = hmac.compute(key, pt);
|
||||
assert("HMAC-MD5 test "+i, Hex.fromArray(digest) == cts[i]);
|
||||
}
|
||||
}
|
||||
public function testHMAC96_MD5():void {
|
||||
var hmac:HMAC = new HMAC(new MD5, 96);
|
||||
var key:ByteArray = Hex.toArray("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c");
|
||||
var pt:ByteArray = Hex.toArray(Hex.fromString("Test With Truncation"));
|
||||
var ct:String = "56461ef2342edc00f9bab995";
|
||||
var digest:ByteArray = hmac.compute(key, pt);
|
||||
assert("HMAC96-MD5 test", Hex.fromArray(digest) == ct);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test vectors for HMAC-SHA-2 taken from RFC4231
|
||||
* http://www.ietf.org/rfc/rfc4231.txt
|
||||
* Still the same lame strings, but hidden in hex. why not.
|
||||
*/
|
||||
public function testHMAC_SHA_2():void {
|
||||
var keys:Array = [
|
||||
"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
|
||||
"4a656665",
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
"0102030405060708090a0b0c0d0e0f10111213141516171819",
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"];
|
||||
var pts:Array = [
|
||||
"4869205468657265",
|
||||
"7768617420646f2079612077616e7420666f72206e6f7468696e673f",
|
||||
"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
|
||||
"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
|
||||
"54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374",
|
||||
"5468697320697320612074657374207573696e672061206c6172676572207468616e20626c6f636b2d73697a65206b657920616e642061206c6172676572207468616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565647320746f20626520686173686564206265666f7265206265696e6720757365642062792074686520484d414320616c676f726974686d2e"];
|
||||
var cts224:Array = [
|
||||
"896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22",
|
||||
"a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44",
|
||||
"7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea",
|
||||
"6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a",
|
||||
"95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e",
|
||||
"3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1"];
|
||||
var cts256:Array = [
|
||||
"b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
|
||||
"5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
|
||||
"773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
|
||||
"82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
|
||||
"60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
|
||||
"9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2"];
|
||||
// 384 and 512 will be added. someday. if I ever figure how to do 64bit computations half efficiently in as3
|
||||
|
||||
var hmac224:HMAC = new HMAC(new SHA224);
|
||||
var hmac256:HMAC = new HMAC(new SHA256);
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var digest224:ByteArray = hmac224.compute(key, pt);
|
||||
assert("HMAC-SHA-224 test "+i, Hex.fromArray(digest224) == cts224[i]);
|
||||
var digest256:ByteArray = hmac256.compute(key, pt);
|
||||
assert("HMAC-SHA-256 test "+i, Hex.fromArray(digest256) == cts256[i]);
|
||||
}
|
||||
}
|
||||
public function testHMAC128_SHA_2():void {
|
||||
var hmac224:HMAC = new HMAC(new SHA224,128);
|
||||
var hmac256:HMAC = new HMAC(new SHA256,128);
|
||||
var key:ByteArray = Hex.toArray("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c");
|
||||
var pt:ByteArray = Hex.toArray("546573742057697468205472756e636174696f6e");
|
||||
var ct224:String = "0e2aea68a90c8d37c988bcdb9fca6fa8";
|
||||
var ct256:String = "a3b6167473100ee06e0c796c2955552b";
|
||||
var digest224:ByteArray = hmac224.compute(key, pt);
|
||||
assert("HMAC128-SHA-224 test", Hex.fromArray(digest224) == ct224);
|
||||
var digest256:ByteArray = hmac256.compute(key, pt);
|
||||
assert("HMAC128-SHA-256 test", Hex.fromArray(digest256) == ct256);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
public interface ITestHarness
|
||||
{
|
||||
function beginTestCase(name:String):void;
|
||||
function endTestCase():void;
|
||||
|
||||
function beginTest(name:String):void;
|
||||
function passTest():void;
|
||||
function failTest(msg:String):void;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
/**
|
||||
* MD2Test
|
||||
*
|
||||
* A test class for MD2
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.hash.MD2;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class MD2Test extends TestCase
|
||||
{
|
||||
public function MD2Test(h:ITestHarness)
|
||||
{
|
||||
super(h, "MD2 Test");
|
||||
runTest(testMd2, "MD2 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Vectors grabbed from
|
||||
* http://www.faqs.org/rfcs/rfc1319.html
|
||||
*/
|
||||
public function testMd2():void {
|
||||
var srcs:Array = [
|
||||
"",
|
||||
Hex.fromString("a"),
|
||||
Hex.fromString("abc"),
|
||||
Hex.fromString("message digest"),
|
||||
Hex.fromString("abcdefghijklmnopqrstuvwxyz"),
|
||||
Hex.fromString("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"),
|
||||
Hex.fromString("12345678901234567890123456789012345678901234567890123456789012345678901234567890")
|
||||
];
|
||||
var hashes:Array = [
|
||||
"8350e5a3e24c153df2275c9f80692773",
|
||||
"32ec01ec4a6dac72c0ab96fb34c0b5d1",
|
||||
"da853b0d3f88d99b30283a69e6ded6bb",
|
||||
"ab4f496bfb2a530b219ff33031fe06b0",
|
||||
"4e8ddff3650292ab5a4108c3aa47940b",
|
||||
"da33def2a42df13975352846c30338cd",
|
||||
"d5976f79d83d3a0dc9806c3c66f3efd8"
|
||||
];
|
||||
var md2:MD2 = new MD2;
|
||||
for (var i:uint=0;i<srcs.length;i++) {
|
||||
var src:ByteArray = Hex.toArray(srcs[i]);
|
||||
var digest:ByteArray = md2.hash(src);
|
||||
assert("MD2 Test "+i, Hex.fromArray(digest) == hashes[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* MD5Test
|
||||
*
|
||||
* A test class for MD5
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.hash.MD5;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class MD5Test extends TestCase
|
||||
{
|
||||
public function MD5Test(h:ITestHarness)
|
||||
{
|
||||
super(h, "MD5 Test");
|
||||
runTest(testMd5,"MD5 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Vectors grabbed from
|
||||
* http://www.faqs.org/rfcs/rfc1321.html
|
||||
*/
|
||||
public function testMd5():void {
|
||||
var srcs:Array = [
|
||||
"",
|
||||
Hex.fromString("a"),
|
||||
Hex.fromString("abc"),
|
||||
Hex.fromString("message digest"),
|
||||
Hex.fromString("abcdefghijklmnopqrstuvwxyz"),
|
||||
Hex.fromString("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"),
|
||||
Hex.fromString("12345678901234567890123456789012345678901234567890123456789012345678901234567890")
|
||||
];
|
||||
var hashes:Array = [
|
||||
"d41d8cd98f00b204e9800998ecf8427e",
|
||||
"0cc175b9c0f1b6a831c399e269772661",
|
||||
"900150983cd24fb0d6963f7d28e17f72",
|
||||
"f96b697d7cb7938d525a2f31aaf161d0",
|
||||
"c3fcd3d76192e4007dfb496cca67e13b",
|
||||
"d174ab98d277d9f5a5611c2c9f419d9f",
|
||||
"57edf4a22be3c955ac49da2e2107b67a"
|
||||
];
|
||||
var md5:MD5 = new MD5;
|
||||
for (var i:uint=0;i<srcs.length;i++) {
|
||||
var src:ByteArray = Hex.toArray(srcs[i]);
|
||||
var digest:ByteArray = md5.hash(src);
|
||||
assert("MD5 Test "+i, Hex.fromArray(digest) == hashes[i]);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
/**
|
||||
* OFBModeTest
|
||||
*
|
||||
* A test class for OFBMode
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
import com.hurlant.util.Hex;
|
||||
import com.hurlant.crypto.symmetric.OFBMode;
|
||||
import com.hurlant.crypto.symmetric.AESKey;
|
||||
import com.hurlant.crypto.symmetric.NullPad;
|
||||
|
||||
public class OFBModeTest extends TestCase
|
||||
{
|
||||
public function OFBModeTest(h:ITestHarness)
|
||||
{
|
||||
super(h, "OFBMode Test");
|
||||
runTest(testOFB_AES128,"OFB AES-128 Test Vectors");
|
||||
runTest(testOFB_AES192,"OFB AES-192 Test Vectors");
|
||||
runTest(testOFB_AES256,"OFB AES-256 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Nist Vectors: http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
* Section F.4.1 and below.
|
||||
*/
|
||||
public function testOFB_AES128():void {
|
||||
var key:ByteArray = Hex.toArray("2b7e151628aed2a6abf7158809cf4f3c");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"3b3fd92eb72dad20333449f8e83cfb4a" +
|
||||
"7789508d16918f03f53c52dac54ed825" +
|
||||
"9740051e9c5fecf64344f7a82260edcc" +
|
||||
"304c6528f659c77866a510d9c1d6ae5e");
|
||||
var ofb:OFBMode = new OFBMode(new AESKey(key), new NullPad);
|
||||
ofb.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
ofb.encrypt(src);
|
||||
assert("OFB_AES128 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
ofb.decrypt(src);
|
||||
assert("OFB_AES128 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
|
||||
public function testOFB_AES192():void {
|
||||
var key:ByteArray = Hex.toArray("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"cdc80d6fddf18cab34c25909c99a4174" +
|
||||
"fcc28b8d4c63837c09e81700c1100401" +
|
||||
"8d9a9aeac0f6596f559c6d4daf59a5f2" +
|
||||
"6d9f200857ca6c3e9cac524bd9acc92a");
|
||||
var ofb:OFBMode = new OFBMode(new AESKey(key), new NullPad);
|
||||
ofb.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
ofb.encrypt(src);
|
||||
assert("OFB_AES192 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
ofb.decrypt(src);
|
||||
assert("OFB_AES192 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
|
||||
public function testOFB_AES256():void {
|
||||
var key:ByteArray = Hex.toArray(
|
||||
"603deb1015ca71be2b73aef0857d7781" +
|
||||
"1f352c073b6108d72d9810a30914dff4");
|
||||
var pt:ByteArray = Hex.toArray(
|
||||
"6bc1bee22e409f96e93d7e117393172a" +
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51" +
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef" +
|
||||
"f69f2445df4f9b17ad2b417be66c3710");
|
||||
var ct:ByteArray = Hex.toArray(
|
||||
"dc7e84bfda79164b7ecd8486985d3860" +
|
||||
"4febdc6740d20b3ac88f6ad82a4fb08d" +
|
||||
"71ab47a086e86eedf39d1c5bba97c408" +
|
||||
"0126141d67f37be8538f5a8be740e484");
|
||||
var ofb:OFBMode = new OFBMode(new AESKey(key), new NullPad);
|
||||
ofb.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
|
||||
var src:ByteArray = new ByteArray;
|
||||
src.writeBytes(pt);
|
||||
ofb.encrypt(src);
|
||||
assert("OFB_AES256 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
|
||||
ofb.decrypt(src);
|
||||
assert("OFB_AES256 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.rsa.RSAKey;
|
||||
import flash.utils.ByteArray;
|
||||
import com.hurlant.util.Hex;
|
||||
import com.hurlant.util.der.PEM;
|
||||
|
||||
public class RSAKeyTest extends TestCase
|
||||
{
|
||||
public function RSAKeyTest(h:ITestHarness)
|
||||
{
|
||||
super(h, "RSA Testing");
|
||||
|
||||
runTest(testSmoke,"RSA smoke test");
|
||||
runTest(testGenerate, "RSA Key Generation test");
|
||||
runTest(testPEM, "RSA Private Key PEM parsing");
|
||||
runTest(testPEM2, "RSA Public Key PEM parsing");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
public function testSmoke():void {
|
||||
var N:String ="C4E3F7212602E1E396C0B6623CF11D26204ACE3E7D26685E037AD2507DCE82FC" +
|
||||
"28F2D5F8A67FC3AFAB89A6D818D1F4C28CFA548418BD9F8E7426789A67E73E41";
|
||||
var E:String = "10001";
|
||||
var D:String = "7cd1745aec69096129b1f42da52ac9eae0afebbe0bc2ec89253598dcf454960e" +
|
||||
"3e5e4ec9f8c87202b986601dd167253ee3fb3fa047e14f1dfd5ccd37e931b29d";
|
||||
var P:String = "f0e4dd1eac5622bd3932860fc749bbc48662edabdf3d2826059acc0251ac0d3b";
|
||||
var Q:String = "d13cb38fbcd06ee9bca330b4000b3dae5dae12b27e5173e4d888c325cda61ab3";
|
||||
var DMP1:String = "b3d5571197fc31b0eb6b4153b425e24c033b054d22b9c8282254fe69d8c8c593";
|
||||
var DMQ1:String = "968ffe89e50d7b72585a79b65cfdb9c1da0963cceb56c3759e57334de5a0ac3f";
|
||||
var IQMP:String = "d9bc4f420e93adad9f007d0e5744c2fe051c9ed9d3c9b65f439a18e13d6e3908";
|
||||
// create a key.
|
||||
var rsa:RSAKey = RSAKey.parsePrivateKey(N,E,D, P,Q,DMP1,DMQ1,IQMP);
|
||||
var txt:String = "hello";
|
||||
var src:ByteArray = Hex.toArray(Hex.fromString(txt));
|
||||
var dst:ByteArray = new ByteArray;
|
||||
var dst2:ByteArray = new ByteArray;
|
||||
rsa.encrypt(src, dst, src.length);
|
||||
rsa.decrypt(dst, dst2, dst.length);
|
||||
var txt2:String = Hex.toString(Hex.fromArray(dst2));
|
||||
assert("rsa encrypt+decrypt", txt==txt2);
|
||||
}
|
||||
|
||||
public function testGenerate():void {
|
||||
var rsa:RSAKey = RSAKey.generate(256, "10001");
|
||||
// same lame smoke test here.
|
||||
var txt:String = "hello";
|
||||
var src:ByteArray = Hex.toArray(Hex.fromString(txt));
|
||||
var dst:ByteArray = new ByteArray;
|
||||
var dst2:ByteArray = new ByteArray;
|
||||
rsa.encrypt(src, dst, src.length);
|
||||
rsa.decrypt(dst, dst2, dst.length);
|
||||
var txt2:String = Hex.toString(Hex.fromArray(dst2));
|
||||
assert("rsa encrypt+decrypt", txt==txt2);
|
||||
}
|
||||
|
||||
public function testPEM():void {
|
||||
var pem:String = "-----BEGIN RSA PRIVATE KEY-----\n" +
|
||||
"MGQCAQACEQDJG3bkuB9Ie7jOldQTVdzPAgMBAAECEQCOGqcPhP8t8mX8cb4cQEaR\n" +
|
||||
"AgkA5WTYuAGmH0cCCQDgbrto0i7qOQIINYr5btGrtccCCQCYy4qX4JDEMQIJAJll\n" +
|
||||
"OnLVtCWk\n" +
|
||||
"-----END RSA PRIVATE KEY-----";
|
||||
var rsa:RSAKey = PEM.readRSAPrivateKey(pem);
|
||||
//trace(rsa.dump());
|
||||
|
||||
// obligatory use
|
||||
var txt:String = "hello";
|
||||
var src:ByteArray = Hex.toArray(Hex.fromString(txt));
|
||||
var dst:ByteArray = new ByteArray;
|
||||
var dst2:ByteArray = new ByteArray;
|
||||
rsa.encrypt(src, dst, src.length);
|
||||
rsa.decrypt(dst, dst2, dst.length);
|
||||
var txt2:String = Hex.toString(Hex.fromArray(dst2));
|
||||
assert("rsa encrypt+decrypt", txt==txt2);
|
||||
}
|
||||
public function testPEM2():void {
|
||||
var pem:String = "-----BEGIN PUBLIC KEY-----\n" +
|
||||
"MCwwDQYJKoZIhvcNAQEBBQADGwAwGAIRAMkbduS4H0h7uM6V1BNV3M8CAwEAAQ==\n" +
|
||||
"-----END PUBLIC KEY-----";
|
||||
var rsa:RSAKey = PEM.readRSAPublicKey(pem);
|
||||
//trace(rsa.dump());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
/**
|
||||
* SHA1Test
|
||||
*
|
||||
* A test class for SHA1
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.hash.SHA1;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class SHA1Test extends TestCase
|
||||
{
|
||||
public function SHA1Test(h:ITestHarness)
|
||||
{
|
||||
super(h, "SHA-1 Test");
|
||||
runTest(testSha1,"SHA-1 Test Vectors");
|
||||
runTest(testLongSha1,"SHA-1 Long Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Vectors grabbed from
|
||||
* http://csrc.nist.gov/cryptval/shs.htm
|
||||
*/
|
||||
public function testSha1():void {
|
||||
var srcs:Array = [
|
||||
"",
|
||||
"a8",
|
||||
"3000",
|
||||
"42749e",
|
||||
"9fc3fe08",
|
||||
"b5c1c6f1af",
|
||||
"e47571e5022e",
|
||||
"3e1b28839fb758",
|
||||
"a81350cbb224cb90",
|
||||
"c243d167923dec3ce1",
|
||||
"50ac18c59d6a37a29bf4",
|
||||
"98e2b611ad3b1cccf634f6",
|
||||
"73fe9afb68e1e8712e5d4eec",
|
||||
"9e701ed7d412a9226a2a130e66",
|
||||
"6d3ee90413b0a7cbf69e5e6144ca",
|
||||
"fae24d56514efcb530fd4802f5e71f",
|
||||
"c5a22dd6eda3fe2bdc4ddb3ce6b35fd1",
|
||||
"d98cded2adabf08fda356445c781802d95",
|
||||
"bcc6d7087a84f00103ccb32e5f5487a751a2",
|
||||
"36ecacb1055434190dbbc556c48bafcb0feb0d",
|
||||
"5ff9edb69e8f6bbd498eb4537580b7fba7ad31d0",
|
||||
"c95b441d8270822a46a798fae5defcf7b26abace36",
|
||||
"83104c1d8a55b28f906f1b72cb53f68cbb097b44f860",
|
||||
"755175528d55c39c56493d697b790f099a5ce741f7754b",
|
||||
"088fc38128bbdb9fd7d65228b3184b3faac6c8715f07272f",
|
||||
"a4a586eb9245a6c87e3adf1009ac8a49f46c07e14185016895",
|
||||
"8e7c555270c006092c2a3189e2a526b873e2e269f0fb28245256",
|
||||
"a5f3bfa6bb0ba3b59f6b9cbdef8a558ec565e8aa3121f405e7f2f0",
|
||||
"589054f0d2bd3c2c85b466bfd8ce18e6ec3e0b87d944cd093ba36469",
|
||||
"a0abb12083b5bbc78128601bf1cbdbc0fdf4b862b24d899953d8da0ff3",
|
||||
"82143f4cea6fadbf998e128a8811dc75301cf1db4f079501ea568da68eeb",
|
||||
"9f1231dd6df1ff7bc0b0d4f989d048672683ce35d956d2f57913046267e6f3",
|
||||
"041c512b5eed791f80d3282f3a28df263bb1df95e1239a7650e5670fc2187919",
|
||||
"17e81f6ae8c2e5579d69dafa6e070e7111461552d314b691e7a3e7a4feb3fae418",
|
||||
"d15976b23a1d712ad28fad04d805f572026b54dd64961fda94d5355a0cc98620cf77",
|
||||
"09fce4d434f6bd32a44e04b848ff50ec9f642a8a85b37a264dc73f130f22838443328f",
|
||||
"f17af27d776ec82a257d8d46d2b46b639462c56984cc1be9c1222eadb8b26594a25c709d",
|
||||
"b13ce635d6f8758143ffb114f2f601cb20b6276951416a2f94fbf4ad081779d79f4f195b22",
|
||||
"5498793f60916ff1c918dde572cdea76da8629ba4ead6d065de3dfb48de94d234cc1c5002910",
|
||||
"498a1e0b39fa49582ae688cd715c86fbaf8a81b8b11b4d1594c49c902d197c8ba8a621fd6e3be5",
|
||||
"3a36ae71521f9af628b3e34dcb0d4513f84c78ee49f10416a98857150b8b15cb5c83afb4b570376e",
|
||||
"dcc76b40ae0ea3ba253e92ac50fcde791662c5b6c948538cffc2d95e9de99cac34dfca38910db2678f",
|
||||
"5b5ec6ec4fd3ad9c4906f65c747fd4233c11a1736b6b228b92e90cddabb0c7c2fcf9716d3fad261dff33",
|
||||
"df48a37b29b1d6de4e94717d60cdb4293fcf170bba388bddf7a9035a15d433f20fd697c3e4c8b8c5f590ab",
|
||||
"1f179b3b82250a65e1b0aee949e218e2f45c7a8dbfd6ba08de05c55acfc226b48c68d7f7057e5675cd96fcfc",
|
||||
"ee3d72da3a44d971578972a8e6780ce64941267e0f7d0179b214fa97855e1790e888e09fbe3a70412176cb3b54",
|
||||
"d4d4c7843d312b30f610b3682254c8be96d5f6684503f8fbfbcd15774fc1b084d3741afb8d24aaa8ab9c104f7258",
|
||||
"32c094944f5936a190a0877fb9178a7bf60ceae36fd530671c5b38c5dbd5e6a6c0d615c2ac8ad04b213cc589541cf6",
|
||||
"e5d3180c14bf27a5409fa12b104a8fd7e9639609bfde6ee82bbf9648be2546d29688a65e2e3f3da47a45ac14343c9c02",
|
||||
"e7b6e4b69f724327e41e1188a37f4fe38b1dba19cbf5a7311d6e32f1038e97ab506ee05aebebc1eed09fc0e357109818b9",
|
||||
"bc880cb83b8ac68ef2fedc2da95e7677ce2aa18b0e2d8b322701f67af7d5e7a0d96e9e33326ccb7747cfff0852b961bfd475",
|
||||
"235ea9c2ba7af25400f2e98a47a291b0bccdaad63faa2475721fda5510cc7dad814bce8dabb611790a6abe56030b798b75c944",
|
||||
"07e3e29fed63104b8410f323b975fd9fba53f636af8c4e68a53fb202ca35dd9ee07cb169ec5186292e44c27e5696a967f5e67709",
|
||||
"65d2a1dd60a517eb27bfbf530cf6a5458f9d5f4730058bd9814379547f34241822bf67e6335a6d8b5ed06abf8841884c636a25733f",
|
||||
"dcc86b3bd461615bab739d8daafac231c0f462e819ad29f9f14058f3ab5b75941d4241ea2f17ebb8a458831b37a9b16dead4a76a9b0e",
|
||||
"4627d54f0568dc126b62a8c35fb46a9ac5024400f2995e51635636e1afc4373dbb848eb32df23914230560b82477e9c3572647a7f2bb92",
|
||||
"ba531affd4381168ef24d8b275a84d9254c7f5cc55fded53aa8024b2c5c5c8aa7146fe1d1b83d62b70467e9a2e2cb67b3361830adbab28d7",
|
||||
"8764dcbcf89dcf4282eb644e3d568bdccb4b13508bfa7bfe0ffc05efd1390be22109969262992d377691eb4f77f3d59ea8466a74abf57b2ef4",
|
||||
"497d9df9ddb554f3d17870b1a31986c1be277bc44feff713544217a9f579623d18b5ffae306c25a45521d2759a72c0459b58957255ab592f3be4",
|
||||
"72c3c2e065aefa8d9f7a65229e818176eef05da83f835107ba90ec2e95472e73e538f783b416c04654ba8909f26a12db6e5c4e376b7615e4a25819",
|
||||
"7cc9894454d0055ab5069a33984e2f712bef7e3124960d33559f5f3b81906bb66fe64da13c153ca7f5cabc89667314c32c01036d12ecaf5f9a78de98",
|
||||
"74e8404d5a453c5f4d306f2cfa338ca65501c840ddab3fb82117933483afd6913c56aaf8a0a0a6b2a342fc3d9dc7599f4a850dfa15d06c61966d74ea59",
|
||||
"46fe5ed326c8fe376fcc92dc9e2714e2240d3253b105adfbb256ff7a19bc40975c604ad7c0071c4fd78a7cb64786e1bece548fa4833c04065fe593f6fb10",
|
||||
"836dfa2524d621cf07c3d2908835de859e549d35030433c796b81272fd8bc0348e8ddbc7705a5ad1fdf2155b6bc48884ac0cd376925f069a37849c089c8645",
|
||||
"7e3a4c325cb9c52b88387f93d01ae86d42098f5efa7f9457388b5e74b6d28b2438d42d8b64703324d4aa25ab6aad153ae30cd2b2af4d5e5c00a8a2d0220c6116"];
|
||||
var hashes:Array = [
|
||||
"da39a3ee5e6b4b0d3255bfef95601890afd80709",
|
||||
"99f2aa95e36f95c2acb0eaf23998f030638f3f15",
|
||||
"f944dcd635f9801f7ac90a407fbc479964dec024",
|
||||
"a444319e9b6cc1e8464c511ec0969c37d6bb2619",
|
||||
"16a0ff84fcc156fd5d3ca3a744f20a232d172253",
|
||||
"fec9deebfcdedaf66dda525e1be43597a73a1f93",
|
||||
"8ce051181f0ed5e9d0c498f6bc4caf448d20deb5",
|
||||
"67da53837d89e03bf652ef09c369a3415937cfd3",
|
||||
"305e4ff9888ad855a78573cddf4c5640cce7e946",
|
||||
"5902b77b3265f023f9bbc396ba1a93fa3509bde7",
|
||||
"fcade5f5d156bf6f9af97bdfa9c19bccfb4ff6ab",
|
||||
"1d20fbe00533c10e3cbd6b27088a5de0c632c4b5",
|
||||
"7e1b7e0f7a8f3455a9c03e9580fd63ae205a2d93",
|
||||
"706f0677146307b20bb0e8d6311e329966884d13",
|
||||
"a7241a703aaf0d53fe142f86bf2e849251fa8dff",
|
||||
"400f53546916d33ad01a5e6df66822dfbdc4e9e6",
|
||||
"fac8ab93c1ae6c16f0311872b984f729dc928ccd",
|
||||
"fba6d750c18da58f6e2aab10112b9a5ef3301b3b",
|
||||
"29d27c2d44c205c8107f0351b05753ac708226b6",
|
||||
"b971bfc1ebd6f359e8d74cb7ecfe7f898d0ba845",
|
||||
"96d08c430094b9fcc164ad2fb6f72d0a24268f68",
|
||||
"a287ea752a593d5209e287881a09c49fa3f0beb1",
|
||||
"a06c713779cbd88519ed4a585ac0cb8a5e9d612b",
|
||||
"bff7d52c13a3688132a1d407b1ab40f5b5ace298",
|
||||
"c7566b91d7b6f56bdfcaa9781a7b6841aacb17e9",
|
||||
"ffa30c0b5c550ea4b1e34f8a60ec9295a1e06ac1",
|
||||
"29e66ed23e914351e872aa761df6e4f1a07f4b81",
|
||||
"b28cf5e5b806a01491d41f69bd9248765c5dc292",
|
||||
"60224fb72c46069652cd78bcd08029ef64da62f3",
|
||||
"b72c4a86f72608f24c05f3b9088ef92fba431df7",
|
||||
"73779ad5d6b71b9b8328ef7220ff12eb167076ac",
|
||||
"a09671d4452d7cf50015c914a1e31973d20cc1a0",
|
||||
"e88cdcd233d99184a6fd260b8fca1b7f7687aee0",
|
||||
"010def22850deb1168d525e8c84c28116cb8a269",
|
||||
"aeaa40ba1717ed5439b1e6ea901b294ba500f9ad",
|
||||
"c6433791238795e34f080a5f1f1723f065463ca0",
|
||||
"e21e22b89c1bb944a32932e6b2a2f20d491982c3",
|
||||
"575323a9661f5d28387964d2ba6ab92c17d05a8a",
|
||||
"feb44494af72f245bfe68e86c4d7986d57c11db7",
|
||||
"cff2290b3648ba2831b98dde436a72f9ebf51eee",
|
||||
"9b4efe9d27b965905b0c3dab67b8d7c9ebacd56c",
|
||||
"afedb0ff156205bcd831cbdbda43db8b0588c113",
|
||||
"8deb1e858f88293a5e5e4d521a34b2a4efa70fc4",
|
||||
"95cbdac0f74afa69cebd0e5c7defbc6faf0cbeaf",
|
||||
"f0307bcb92842e5ae0cd4f4f14f3df7f877fbef2",
|
||||
"7b13bb0dbf14964bd63b133ac85e22100542ef55",
|
||||
"c314d2b6cf439be678d2a74e890d96cfac1c02ed",
|
||||
"4d0be361e410b47a9d67d8ce0bb6a8e01c53c078",
|
||||
"e5353431ffae097f675cbf498869f6fbb6e1c9f2",
|
||||
"b8720a7068a085c018ab18961de2765aa6cd9ac4",
|
||||
"b0732181568543ba85f2b6da602b4b065d9931aa",
|
||||
"9c22674cf3222c3ba921672694aafee4ce67b96b",
|
||||
"d128335f4cecca9066cdae08958ce656ff0b4cfc",
|
||||
"0b67c57ac578de88a2ae055caeaec8bb9b0085a0",
|
||||
"c766f912a89d4ccda88e0cce6a713ef5f178b596",
|
||||
"9aa3925a9dcb177b15ccff9b78e70cf344858779",
|
||||
"4811fa30042fc076acf37c8e2274d025307e5943",
|
||||
"6743018450c9730761ee2b130df9b91c1e118150",
|
||||
"71ad4a19d37d92a5e6ef3694ddbeb5aa61ada645",
|
||||
"a7d9dc68dacefb7d6116186048cb355cc548e11d",
|
||||
"142e429f0522ba5abf5131fa81df82d355b96909",
|
||||
"ef72db70dcbcab991e9637976c6faf00d22caae9",
|
||||
"f220a7457f4588d639dc21407c942e9843f8e26b",
|
||||
"ddd2117b6e309c233ede85f962a0c2fc215e5c69",
|
||||
"a3054427cdb13f164a610b348702724c808a0dcc"];
|
||||
// ok. let's loop.
|
||||
var sha1:SHA1 = new SHA1;
|
||||
for (var i:uint=0;i<srcs.length;i++) {
|
||||
var src:ByteArray = Hex.toArray(srcs[i]);
|
||||
var digest:ByteArray = sha1.hash(src);
|
||||
assert("SHA1 Test "+i, Hex.fromArray(digest) == hashes[i]);
|
||||
}
|
||||
|
||||
}
|
||||
/**
|
||||
* A few long SHA-1, from the same page
|
||||
*/
|
||||
public function testLongSha1():void {
|
||||
var srcs:Array = [
|
||||
"ec29561244ede706b6eb30a1c371d74450a105c3f9735f7fa9fe38cf67f304a5736a106e92e17139a6813b1c81a4f3d3fb9546ab4296fa9f722826c066869edacd73b2548035185813e22634a9da44000d95a281ff9f264ecce0a931222162d021cca28db5f3c2aa24945ab1e31cb413ae29810fd794cad5dfaf29ec43cb38d198fe4ae1da2359780221405bd6712a5305da4b1b737fce7cd21c0eb7728d08235a9011",
|
||||
"5fc2c3f6a7e79dc94be526e5166a238899d54927ce470018fbfd668fd9dd97cbf64e2c91584d01da63be3cc9fdff8adfefc3ac728e1e335b9cdc87f069172e323d094b47fa1e652afe4d6aa147a9f46fda33cacb65f3aa12234746b9007a8c85fe982afed7815221e43dba553d8fe8a022cdac1b99eeeea359e5a9d2e72e382dffa6d19f359f4f27dc3434cd27daeeda8e38594873398678065fbb23665aba9309d946135da0e4a4afdadff14db18e85e71dd93c3bf9faf7f25c8194c4269b1ee3d9934097ab990025d9c3aaf63d5109f52335dd3959d38ae485050e4bbb6235574fc0102be8f7a306d6e8de6ba6becf80f37415b57f9898a5824e77414197422be3d36a6080",
|
||||
"0f865f46a8f3aed2da18482aa09a8f390dc9da07d51d1bd10fe0bf5f3928d5927d08733d32075535a6d1c8ac1b2dc6ba0f2f633dc1af68e3f0fa3d85e6c60cb7b56c239dc1519a007ea536a07b518ecca02a6c31b46b76f021620ef3fc6976804018380e5ab9c558ebfc5cb1c9ed2d974722bf8ab6398f1f2b82fa5083f85c16a5767a3a07271d67743f00850ce8ec428c7f22f1cf01f99895c0c844845b06a06cecb0c6cf83eb55a1d4ebc44c2c13f6f7aa5e0e08abfd84e7864279057abc471ee4a45dbbb5774afa24e51791a0eada11093b88681fe30baa3b2e94113dc63342c51ca5d1a6096d0897b626e42cb91761058008f746f35465465540ad8c6b8b60f7e1461b3ce9e6529625984cb8c7d46f07f735be067588a0117f23e34ff57800e2bbe9a1605fde6087fb15d22c5d3ac47566b8c448b0cee40373e5ba6eaa21abee71366afbb27dbbd300477d70c371e7b8963812f5ed4fb784fb2f3bd1d3afe883cdd47ef32beaea",
|
||||
"4893f1c763625f2c6ce53aacf28026f14b3cd8687e1a1d3b60a81e80fcd1e2b038f9145ab64a0718f948f7c3c9ac92e3d86fb669a5257da1a18c776291653688338210a3242120f101788e8acc9110db9258b1554bf3d26602516ea93606a25a7f566c0c758fb39ecd9d876bc5d8abc1c3205095382c2474cb1f8bbdb45c2c0e659cb0fc703ec607a5de6bcc7a28687db1ee1c8f34797bb2441d5706d210df8c2d7d65dbded36414d063c117b52a51f7a4eb9cac0782e008b47459ed5acac0bc1f20121087f992ad985511b33c866d18e63f585478ee5a5e654b19d81231d98683ae3f0533565aba43dce408d7e3c4c6be11d8f05165f29c9dcb2030c4ee31d3a04e7421aa92c3231a1fc07e50e95fea7389a5e65891afaba51cf55e36a9d089bf293accb356d5d06547307d6e41456d4ed146a056179971c56521c83109bf922866186e184a99a96c7bb96df8937e35970e438412a2b8d744cf2ad87cb605d4232e976f9f15169776e4e5b6b786132c966b25fc56d815c56c819af5e159aa39f8a93d38115f5580cda93bc073c30b39920e726fe861b72483a3f886269ab7a8eefe952f35d25c4eb7f443f4f3f26e43d51fb54591e6a6dad25fcdf5142033084e5624bdd51435e77dea86b8",
|
||||
"cf494c18a4e17bf03910631471bca5ba7edea8b9a63381e3463517961749848eb03abefd4ce676dece3740860255f57c261a558aa9c7f11432f549a9e4ce31d8e17c79450ce2ccfc148ad904aedfb138219d7052088520495355dadd90f72e6f69f9c6176d3d45f113f275b7fbc2a295784d41384cd7d629b23d1459a22e45fd5097ec9bf65fa965d3555ec77367903c32141065fc24da5c56963d46a2da3c279e4035fb2fb1c0025d9dda5b9e3443d457d92401a0d3f58b48469ecb1862dc975cdbe75ca099526db8b0329b03928206f084c633c04eef5e8e377f118d30edf592504be9d2802651ec78aeb02aea167a03fc3e23e5fc907c324f283f89ab37e84687a9c74ccf055402db95c29ba2c8d79b2bd4fa96459f8e3b78e07e923b81198267492196ecb71e01c331f8df245ec5bdf8d0e05c91e63bb299f0f6324895304dda721d39410458f117c87b7dd6a0ee734b79fcbe482b2c9e9aa0cef03a39d4b0c86de3bc34b4aadabfa373fd2258f7c40c187744d237080762382f547a36adb117839ca72f8ebbc5a20a07e86f4c8bb923f5787698d278f6db0040e76e54645bb0f97083995b34b9aa445fc424455058795828dd00c32471ec402a307f5aa1b37b1a86d6dae3bcbfbe9ba41cab0beeabf489af0073d4b3837d3f14b815120bc3602d072b5aeefcdec655fe756b660eba7dcf34675acbce317746270599424b9248791a0780449c1eabbb9459cc1e588bfd74df9b1b711c85c09d8aa171b309281947e8f4b6ac438753158f4f36fa"];
|
||||
var hashes:Array = [
|
||||
"970111c4e77bcc88cc20459c02b69b4aa8f58217",
|
||||
"0423dc76a8791107d14e13f5265b343f24cc0f19",
|
||||
"6692a71d73e00f27df976bc56df4970650d90e45",
|
||||
"dc5859dd5163c4354d5d577b855fa98e37f04384",
|
||||
"4c17926feb6e87f5bca7890d8a5cde744f231dab"];
|
||||
// ok. let's loop.
|
||||
var sha1:SHA1 = new SHA1;
|
||||
for (var i:uint=0;i<srcs.length;i++) {
|
||||
var src:ByteArray = Hex.toArray(srcs[i]);
|
||||
var digest:ByteArray = sha1.hash(src);
|
||||
assert("SHA1 Long Test "+i, Hex.fromArray(digest) == hashes[i]);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* SHA224Test
|
||||
*
|
||||
* A test class for SHA224
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.hash.SHA224;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class SHA224Test extends TestCase
|
||||
{
|
||||
public function SHA224Test(h:ITestHarness)
|
||||
{
|
||||
super(h,"SHA-224 Test");
|
||||
runTest(testSha224,"SHA-224 Test Vectors");
|
||||
// takes a few seconds, but uncomment if you must.
|
||||
//runTest(testLongSha224,"SHA-224 Long Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test vectors courtesy of
|
||||
* http://www.ietf.org/rfc/rfc3874.txt
|
||||
*/
|
||||
public function testSha224():void {
|
||||
var srcs:Array = [
|
||||
Hex.fromString("abc"),
|
||||
Hex.fromString("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")];
|
||||
var hashes:Array = [
|
||||
"23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7",
|
||||
"75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525"];
|
||||
|
||||
var sha224:SHA224 = new SHA224;
|
||||
for (var i:uint=0;i<srcs.length;i++) {
|
||||
var src:ByteArray = Hex.toArray(srcs[i]);
|
||||
var digest:ByteArray = sha224.hash(src);
|
||||
assert("SHA224 Test "+i, Hex.fromArray(digest) == hashes[i]);
|
||||
}
|
||||
}
|
||||
public function testLongSha224():void {
|
||||
var src:ByteArray = new ByteArray;
|
||||
var a:uint = "a".charCodeAt(0);
|
||||
for (var i:uint=0;i<1e6;i++) {
|
||||
src[i] = a;
|
||||
}
|
||||
var sha224:SHA224 = new SHA224;
|
||||
var digest:ByteArray = sha224.hash(src);
|
||||
var hash:String = "20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67";
|
||||
assert("SHA224 Long Test", Hex.fromArray(digest) == hash);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* SHA256Test
|
||||
*
|
||||
* A test class for SHA256
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.hash.SHA256;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class SHA256Test extends TestCase
|
||||
{
|
||||
public function SHA256Test(h:ITestHarness)
|
||||
{
|
||||
super(h,"SHA-256 Test");
|
||||
runTest(testSha256,"SHA-256 Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test vectors courtesy of
|
||||
* https://www.cosic.esat.kuleuven.be/nessie/testvectors/hash/sha/Sha-2-256.unverified.test-vectors
|
||||
*/
|
||||
public function testSha256():void {
|
||||
var srcs:Array = [
|
||||
Hex.fromString(""),
|
||||
Hex.fromString("a"),
|
||||
Hex.fromString("abc"),
|
||||
Hex.fromString("message digest"),
|
||||
Hex.fromString("abcdefghijklmnopqrstuvwxyz"),
|
||||
Hex.fromString("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"),
|
||||
Hex.fromString("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"),
|
||||
Hex.fromString("12345678901234567890123456789012345678901234567890123456789012345678901234567890"),
|
||||
];
|
||||
var hashes:Array = [
|
||||
"E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
|
||||
"CA978112CA1BBDCAFAC231B39A23DC4DA786EFF8147C4E72B9807785AFEE48BB",
|
||||
"BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD",
|
||||
"F7846F55CF23E14EEBEAB5B4E1550CAD5B509E3348FBC4EFA3A1413D393CB650",
|
||||
"71C480DF93D6AE2F1EFAD1447C66C9525E316218CF51FC8D9ED832F2DAF18B73",
|
||||
"248D6A61D20638B8E5C026930C3E6039A33CE45964FF2167F6ECEDD419DB06C1",
|
||||
"DB4BFCBD4DA0CD85A60C3C37D3FBD8805C77F15FC6B1FDFE614EE0A7C8FDB4C0",
|
||||
"F371BC4A311F2B009EEF952DD83CA80E2B60026C8E935592D0F9C308453C813E"];
|
||||
|
||||
// loop.
|
||||
var sha256:SHA256 = new SHA256;
|
||||
for (var i:uint=0;i<srcs.length;i++) {
|
||||
var src:ByteArray = Hex.toArray(srcs[i]);
|
||||
var digest:ByteArray = sha256.hash(src);
|
||||
assert("SHA256 Test "+i, Hex.fromArray(digest) == hashes[i].toLowerCase());
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
import com.hurlant.crypto.prng.TLSPRF;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
public class TLSPRFTest extends TestCase
|
||||
{
|
||||
public function TLSPRFTest(h:ITestHarness) {
|
||||
super(h, "TLS-PRF Testing");
|
||||
runTest(testVector, "TLF-PRF Test Vector");
|
||||
h.endTestCase()
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Vector as defined in
|
||||
* http://www.imc.org/ietf-tls/mail-archive/msg01589.html
|
||||
*/
|
||||
private function testVector():void {
|
||||
var secret:ByteArray = new ByteArray;
|
||||
for (var i:uint=0;i<48;i++) {
|
||||
secret[i]= 0xab;
|
||||
}
|
||||
var label:String = "PRF Testvector";
|
||||
var seed:ByteArray = new ByteArray;
|
||||
for (i=0;i<64;i++) {
|
||||
seed[i] = 0xcd;
|
||||
}
|
||||
var prf:TLSPRF = new TLSPRF(secret, label, seed);
|
||||
var out:ByteArray = new ByteArray;
|
||||
prf.nextBytes(out, 104);
|
||||
var expected:String = "D3 D4 D1 E3 49 B5 D5 15 04 46 66 D5 1D E3 2B AB" +
|
||||
"25 8C B5 21 B6 B0 53 46 3E 35 48 32 FD 97 67 54" +
|
||||
"44 3B CF 9A 29 65 19 BC 28 9A BC BC 11 87 E4 EB" +
|
||||
"D3 1E 60 23 53 77 6C 40 8A AF B7 4C BC 85 EF F6" +
|
||||
"92 55 F9 78 8F AA 18 4C BB 95 7A 98 19 D8 4A 5D" +
|
||||
"7E B0 06 EB 45 9D 3A E8 DE 98 10 45 4B 8B 2D 8F" +
|
||||
"1A FB C6 55 A8 C9 A0 13";
|
||||
var expect:String = Hex.fromArray(Hex.toArray(expected));
|
||||
assert("out == expected", Hex.fromArray(out)==expect);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* TestCase
|
||||
*
|
||||
* Embryonic unit test support class.
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
public class TestCase
|
||||
{
|
||||
public var harness:ITestHarness;
|
||||
|
||||
public function TestCase(h:ITestHarness, title:String) {
|
||||
harness = h;
|
||||
harness.beginTestCase(title);
|
||||
}
|
||||
|
||||
|
||||
public function assert(msg:String, value:Boolean):void {
|
||||
if (value) {
|
||||
// TestHarness.print("+ ",msg);
|
||||
return;
|
||||
}
|
||||
throw new Error("Test Failure:"+msg);
|
||||
}
|
||||
|
||||
public function runTest(f:Function, title:String):void {
|
||||
harness.beginTest(title);
|
||||
try {
|
||||
f();
|
||||
} catch (e:Error) {
|
||||
trace("EXCEPTION THROWN: "+e);
|
||||
trace(e.getStackTrace());
|
||||
harness.failTest(e.toString());
|
||||
return;
|
||||
}
|
||||
harness.passTest();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.symmetric.TripleDESKey;
|
||||
import com.hurlant.util.Hex;
|
||||
import flash.utils.ByteArray;
|
||||
import com.hurlant.crypto.symmetric.ICipher;
|
||||
import com.hurlant.crypto.symmetric.ECBMode;
|
||||
|
||||
public class TripleDESKeyTest extends TestCase
|
||||
{
|
||||
public function TripleDESKeyTest(h:ITestHarness)
|
||||
{
|
||||
super(h, "Triped Des Test");
|
||||
runTest(testECB,"Triple DES ECB Test Vectors");
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Lots of vectors at http://csrc.nist.gov/publications/nistpubs/800-20/800-20.pdf
|
||||
* XXX move them in here.
|
||||
*/
|
||||
public function testECB():void {
|
||||
var keys:Array = [
|
||||
"010101010101010101010101010101010101010101010101",
|
||||
"dd24b3aafcc69278d650dad234956b01e371384619492ac4",
|
||||
];
|
||||
var pts:Array = [
|
||||
"8000000000000000",
|
||||
"F36B21045A030303",
|
||||
];
|
||||
var cts:Array = [
|
||||
"95F8A5E5DD31D900",
|
||||
"E823A43DEEA4D0A4",
|
||||
];
|
||||
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var ede:TripleDESKey = new TripleDESKey(key);
|
||||
ede.encrypt(pt);
|
||||
var out:String = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+cts[i]+" to "+out, cts[i]==out);
|
||||
// now go back to plaintext
|
||||
ede.decrypt(pt);
|
||||
out = Hex.fromArray(pt).toUpperCase();
|
||||
assert("comparing "+pts[i]+" to "+out, pts[i]==out);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* XTeaKeyTest
|
||||
*
|
||||
* A test class for XTeaKey
|
||||
* Copyright (c) 2007 Henri Torgemane
|
||||
*
|
||||
* See LICENSE.txt for full license information.
|
||||
*/
|
||||
package com.hurlant.crypto.tests
|
||||
{
|
||||
import com.hurlant.crypto.prng.Random;
|
||||
import com.hurlant.crypto.symmetric.ECBMode;
|
||||
import com.hurlant.crypto.symmetric.XTeaKey;
|
||||
import com.hurlant.util.Hex;
|
||||
|
||||
import flash.utils.ByteArray;
|
||||
import flash.utils.getTimer;
|
||||
|
||||
public class XTeaKeyTest extends TestCase
|
||||
{
|
||||
public function XTeaKeyTest(h:ITestHarness) {
|
||||
super(h, "XTeaKey Test");
|
||||
runTest(testGetBlockSize, "XTea Block Size");
|
||||
runTest(testVectors, "XTea Test Vectors");
|
||||
|
||||
h.endTestCase();
|
||||
}
|
||||
|
||||
public function testGetBlockSize():void {
|
||||
var tea:XTeaKey = new XTeaKey(Hex.toArray("deadbabecafebeefdeadbabecafebeef"));
|
||||
assert("tea blocksize", tea.getBlockSize()==8);
|
||||
}
|
||||
|
||||
public function testVectors():void {
|
||||
// blah.
|
||||
// can't find working test vectors.
|
||||
// algorithms should not get published without vectors :(
|
||||
var keys:Array=[
|
||||
"00000000000000000000000000000000",
|
||||
"2b02056806144976775d0e266c287843"];
|
||||
var pts:Array=[
|
||||
"0000000000000000",
|
||||
"74657374206d652e"];
|
||||
var cts:Array=[
|
||||
"2dc7e8d3695b0538",
|
||||
"7909582138198783"];
|
||||
// self-fullfilling vectors.
|
||||
// oh well, at least I can decrypt what I produce. :(
|
||||
|
||||
for (var i:uint=0;i<keys.length;i++) {
|
||||
var key:ByteArray = Hex.toArray(keys[i]);
|
||||
var pt:ByteArray = Hex.toArray(pts[i]);
|
||||
var tea:XTeaKey = new XTeaKey(key);
|
||||
tea.encrypt(pt);
|
||||
var out:String = Hex.fromArray(pt);
|
||||
assert("comparing "+cts[i]+" to "+out, cts[i]==out);
|
||||
// now go back to plaintext.
|
||||
pt.position=0;
|
||||
tea.decrypt(pt);
|
||||
out = Hex.fromArray(pt);
|
||||
assert("comparing "+pts[i]+" to "+out, pts[i]==out);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user