mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-19 09:37:50 -05:00
Brought up to date with the private repository (feea4c7)
This commit is contained in:
1 parent
1aa738d692
commit
1b1df1ae48
7925 files changed
+2617237
-20
No files matched your search
@@ -0,0 +1,222 @@
|
||||
package com.hurlant.crypto
|
||||
{
|
||||
import com.hurlant.crypto.hash.HMAC;
|
||||
import com.hurlant.crypto.hash.IHash;
|
||||
import com.hurlant.crypto.hash.MD2;
|
||||
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.crypto.prng.ARC4;
|
||||
import com.hurlant.crypto.rsa.RSAKey;
|
||||
import com.hurlant.crypto.symmetric.AESKey;
|
||||
import com.hurlant.crypto.symmetric.BlowFishKey;
|
||||
import com.hurlant.crypto.symmetric.CBCMode;
|
||||
import com.hurlant.crypto.symmetric.CFB8Mode;
|
||||
import com.hurlant.crypto.symmetric.CFBMode;
|
||||
import com.hurlant.crypto.symmetric.CTRMode;
|
||||
import com.hurlant.crypto.symmetric.DESKey;
|
||||
import com.hurlant.crypto.symmetric.ECBMode;
|
||||
import com.hurlant.crypto.symmetric.ICipher;
|
||||
import com.hurlant.crypto.symmetric.IMode;
|
||||
import com.hurlant.crypto.symmetric.IPad;
|
||||
import com.hurlant.crypto.symmetric.ISymmetricKey;
|
||||
import com.hurlant.crypto.symmetric.IVMode;
|
||||
import com.hurlant.crypto.symmetric.NullPad;
|
||||
import com.hurlant.crypto.symmetric.OFBMode;
|
||||
import com.hurlant.crypto.symmetric.PKCS5;
|
||||
import com.hurlant.crypto.symmetric.SimpleIVMode;
|
||||
import com.hurlant.crypto.symmetric.TripleDESKey;
|
||||
import com.hurlant.crypto.symmetric.XTeaKey;
|
||||
import com.hurlant.util.Base64;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class Crypto
|
||||
{
|
||||
|
||||
private var b64:Base64;
|
||||
|
||||
public function Crypto()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public static function getCipher(param1:String, param2:ByteArray, param3:IPad = null) : ICipher
|
||||
{
|
||||
var _loc4_:ICipher = null;
|
||||
var _loc5_:Array;
|
||||
switch((_loc5_ = param1.split("-"))[0])
|
||||
{
|
||||
case "simple":
|
||||
_loc5_.shift();
|
||||
param1 = _loc5_.join("-");
|
||||
_loc4_ = getCipher(param1,param2,param3);
|
||||
if(_loc4_ is IVMode)
|
||||
{
|
||||
return new SimpleIVMode(_loc4_ as IVMode);
|
||||
}
|
||||
return _loc4_;
|
||||
break;
|
||||
case "aes":
|
||||
case "aes128":
|
||||
case "aes192":
|
||||
case "aes256":
|
||||
break;
|
||||
case "bf":
|
||||
case "blowfish":
|
||||
_loc5_.shift();
|
||||
return getMode(_loc5_[0],new BlowFishKey(param2),param3);
|
||||
case "des":
|
||||
_loc5_.shift();
|
||||
if(_loc5_[0] != "ede" && _loc5_[0] != "ede3")
|
||||
{
|
||||
return getMode(_loc5_[0],new DESKey(param2),param3);
|
||||
}
|
||||
if(_loc5_.length == 1)
|
||||
{
|
||||
_loc5_.push("ecb");
|
||||
}
|
||||
case "3des":
|
||||
case "des3":
|
||||
_loc5_.shift();
|
||||
return getMode(_loc5_[0],new TripleDESKey(param2),param3);
|
||||
case "xtea":
|
||||
_loc5_.shift();
|
||||
return getMode(_loc5_[0],new XTeaKey(param2),param3);
|
||||
case "rc4":
|
||||
_loc5_.shift();
|
||||
return new ARC4(param2);
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
_loc5_.shift();
|
||||
if(param2.length * 8 == _loc5_[0])
|
||||
{
|
||||
_loc5_.shift();
|
||||
}
|
||||
return getMode(_loc5_[0],new AESKey(param2),param3);
|
||||
}
|
||||
|
||||
public static function getKeySize(param1:String) : uint
|
||||
{
|
||||
var _loc2_:Array = param1.split("-");
|
||||
switch(_loc2_[0])
|
||||
{
|
||||
case "simple":
|
||||
_loc2_.shift();
|
||||
return getKeySize(_loc2_.join("-"));
|
||||
case "aes128":
|
||||
return 16;
|
||||
case "aes192":
|
||||
return 24;
|
||||
case "aes256":
|
||||
return 32;
|
||||
case "aes":
|
||||
_loc2_.shift();
|
||||
return parseInt(_loc2_[0]) / 8;
|
||||
case "bf":
|
||||
case "blowfish":
|
||||
break;
|
||||
case "des":
|
||||
_loc2_.shift();
|
||||
switch(_loc2_[0])
|
||||
{
|
||||
case "ede":
|
||||
return 16;
|
||||
case "ede3":
|
||||
return 24;
|
||||
default:
|
||||
return 8;
|
||||
}
|
||||
break;
|
||||
case "3des":
|
||||
case "des3":
|
||||
return 24;
|
||||
case "xtea":
|
||||
return 8;
|
||||
case "rc4":
|
||||
if(parseInt(_loc2_[1]) > 0)
|
||||
{
|
||||
return parseInt(_loc2_[1]) / 8;
|
||||
}
|
||||
return 16;
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
return 16;
|
||||
}
|
||||
|
||||
private static function getMode(param1:String, param2:ISymmetricKey, param3:IPad = null) : IMode
|
||||
{
|
||||
switch(param1)
|
||||
{
|
||||
case "ecb":
|
||||
return new ECBMode(param2,param3);
|
||||
case "cfb":
|
||||
return new CFBMode(param2,param3);
|
||||
case "cfb8":
|
||||
return new CFB8Mode(param2,param3);
|
||||
case "ofb":
|
||||
return new OFBMode(param2,param3);
|
||||
case "ctr":
|
||||
return new CTRMode(param2,param3);
|
||||
case "cbc":
|
||||
}
|
||||
return new CBCMode(param2,param3);
|
||||
}
|
||||
|
||||
public static function getHash(param1:String) : IHash
|
||||
{
|
||||
switch(param1)
|
||||
{
|
||||
case "md2":
|
||||
return new MD2();
|
||||
case "md5":
|
||||
return new MD5();
|
||||
case "sha":
|
||||
case "sha1":
|
||||
break;
|
||||
case "sha224":
|
||||
return new SHA224();
|
||||
case "sha256":
|
||||
return new SHA256();
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
return new SHA1();
|
||||
}
|
||||
|
||||
public static function getHMAC(param1:String) : HMAC
|
||||
{
|
||||
var _loc2_:Array = param1.split("-");
|
||||
if(_loc2_[0] == "hmac")
|
||||
{
|
||||
_loc2_.shift();
|
||||
}
|
||||
var _loc3_:uint = 0;
|
||||
if(_loc2_.length > 1)
|
||||
{
|
||||
_loc3_ = parseInt(_loc2_[1]);
|
||||
}
|
||||
return new HMAC(getHash(_loc2_[0]),_loc3_);
|
||||
}
|
||||
|
||||
public static function getPad(param1:String) : IPad
|
||||
{
|
||||
switch(param1)
|
||||
{
|
||||
case "null":
|
||||
return new NullPad();
|
||||
case "pkcs5":
|
||||
}
|
||||
return new PKCS5();
|
||||
}
|
||||
|
||||
public static function getRSA(param1:String, param2:String) : RSAKey
|
||||
{
|
||||
return RSAKey.parsePublicKey(param2,param1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
package com.hurlant.crypto.hash
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class HMAC
|
||||
{
|
||||
|
||||
private var hash:IHash;
|
||||
|
||||
private var bits:uint;
|
||||
|
||||
public function HMAC(param1:IHash, param2:uint = 0)
|
||||
{
|
||||
super();
|
||||
this.hash = param1;
|
||||
this.bits = param2;
|
||||
}
|
||||
|
||||
public function getHashSize() : uint
|
||||
{
|
||||
if(bits != 0)
|
||||
{
|
||||
return bits / 8;
|
||||
}
|
||||
return hash.getHashSize();
|
||||
}
|
||||
|
||||
public function compute(param1:ByteArray, param2:ByteArray) : ByteArray
|
||||
{
|
||||
var _loc3_:ByteArray = null;
|
||||
var _loc7_:* = 0;
|
||||
if(param1.length > hash.getInputSize())
|
||||
{
|
||||
_loc3_ = hash.hash(param1);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc3_ = new ByteArray();
|
||||
_loc3_.writeBytes(param1);
|
||||
}
|
||||
while(_loc3_.length < hash.getInputSize())
|
||||
{
|
||||
_loc3_[_loc3_.length] = 0;
|
||||
}
|
||||
var _loc8_:ByteArray = new ByteArray();
|
||||
var _loc5_:ByteArray = new ByteArray();
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _loc3_.length)
|
||||
{
|
||||
_loc8_[_loc7_] = _loc3_[_loc7_] ^ 0x36;
|
||||
_loc5_[_loc7_] = _loc3_[_loc7_] ^ 0x5C;
|
||||
_loc7_++;
|
||||
}
|
||||
_loc8_.position = _loc3_.length;
|
||||
_loc8_.writeBytes(param2);
|
||||
var _loc6_:ByteArray = hash.hash(_loc8_);
|
||||
_loc5_.position = _loc3_.length;
|
||||
_loc5_.writeBytes(_loc6_);
|
||||
var _loc4_:ByteArray = hash.hash(_loc5_);
|
||||
if(bits > 0 && bits < 8 * _loc4_.length)
|
||||
{
|
||||
_loc4_.length = bits / 8;
|
||||
}
|
||||
return _loc4_;
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
hash = null;
|
||||
bits = 0;
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "hmac-" + (bits > 0 ? bits + "-" : "") + hash.toString();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
package com.hurlant.crypto.hash
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public interface IHash
|
||||
{
|
||||
|
||||
function getInputSize() : uint;
|
||||
|
||||
function getHashSize() : uint;
|
||||
|
||||
function hash(param1:ByteArray) : ByteArray;
|
||||
|
||||
function toString() : String;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,95 @@
|
||||
package com.hurlant.crypto.hash
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class MD2 implements IHash
|
||||
{
|
||||
|
||||
public static const HASH_SIZE:int = 16;
|
||||
|
||||
private static const S:Array = [41,46,67,201,162,216,124,1,61,54,84,161,236,240,6,19,98,167,5,243,192,199,115,140,152,147,43,217,188,76,130,202,30,155,87,60,253,212,224,22,103,66,111,24,138,23,229,18,190,78,196,214,218,158,222,73,160,251,245,142,187,47,238,122,169,104,121,145,21,178,7,63,148,194,16,137,11,34,95,33,128,127,93,154,90,144,50,39,53,62,204,231,191,247,151,3,255,25,48,179,72,165,181,209,215,94,146,42,172,86,170,198,79,184,56,210,150,164,125,182,118,252,107,226,156,116,4,241,69,157,112,89,100,113,135,32,134,91,207,101,230,45,168,2,27,96,37,173,174,176,185,246,28,70,97,105,52,64,126,15,85,71,163,35,221,81,175,58,195,92,249,206,186,197,234,38,44,83,13,110,133,40,132,9,211,223,205,244,65,129,77,82,106,220,55,200,108,193,171,250,36,225,123,8,12,189,177,74,120,136,149,139,227,99,232,109,233,203,213,254,59,0,29,57,242,239,183,14,102,88,208,228,166,119,114,248,235,117,75,10,49,68,80,180,143,237,31,26,219,153,141,51,159,17,131,20];
|
||||
|
||||
public function MD2()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function getInputSize() : uint
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
|
||||
public function getHashSize() : uint
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
|
||||
public function hash(param1:ByteArray) : ByteArray
|
||||
{
|
||||
var _loc8_:* = 0;
|
||||
var _loc3_:* = 0;
|
||||
var _loc9_:* = 0;
|
||||
var _loc6_:uint = param1.length;
|
||||
var _loc7_:uint = uint(16 - param1.length % 16 || 16);
|
||||
do
|
||||
{
|
||||
param1[param1.length] = _loc7_;
|
||||
}
|
||||
while(param1.length % 16 != 0);
|
||||
var _loc2_:uint = param1.length;
|
||||
var _loc4_:ByteArray = new ByteArray();
|
||||
var _loc10_:uint = 0;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _loc2_)
|
||||
{
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < 16)
|
||||
{
|
||||
var _loc11_:uint = _loc8_;
|
||||
var _loc12_:int = _loc4_[_loc11_] ^ S[param1[_loc7_ + _loc8_] ^ _loc10_];
|
||||
_loc4_[_loc11_] = _loc12_;
|
||||
_loc10_ = uint(_loc12_);
|
||||
_loc8_++;
|
||||
}
|
||||
_loc7_ += 16;
|
||||
}
|
||||
param1.position = param1.length;
|
||||
param1.writeBytes(_loc4_);
|
||||
_loc2_ += 16;
|
||||
var _loc5_:ByteArray = new ByteArray();
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _loc2_)
|
||||
{
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < 16)
|
||||
{
|
||||
_loc5_[32 + _loc8_] = (_loc5_[16 + _loc8_] = param1[_loc7_ + _loc8_]) ^ _loc5_[_loc8_];
|
||||
_loc8_++;
|
||||
}
|
||||
_loc3_ = 0;
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < 18)
|
||||
{
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < 48)
|
||||
{
|
||||
_loc5_[_loc9_] = _loc3_ = uint(_loc5_[_loc9_] ^ S[_loc3_]);
|
||||
_loc9_++;
|
||||
}
|
||||
_loc3_ = uint(_loc3_ + _loc8_ & 0xFF);
|
||||
_loc8_++;
|
||||
}
|
||||
_loc7_ += 16;
|
||||
}
|
||||
_loc5_.length = 16;
|
||||
param1.length = _loc6_;
|
||||
return _loc5_;
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "md2";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,218 @@
|
||||
package com.hurlant.crypto.hash
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class MD5 implements IHash
|
||||
{
|
||||
|
||||
public static const HASH_SIZE:int = 16;
|
||||
|
||||
public function MD5()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function getInputSize() : uint
|
||||
{
|
||||
return 64;
|
||||
}
|
||||
|
||||
public function getHashSize() : uint
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
|
||||
public function hash(param1:ByteArray) : ByteArray
|
||||
{
|
||||
var _loc5_:* = 0;
|
||||
var _loc3_:uint = param1.length * 8;
|
||||
var _loc6_:String = param1.endian;
|
||||
while(param1.length % 4 != 0)
|
||||
{
|
||||
param1[param1.length] = 0;
|
||||
}
|
||||
param1.position = 0;
|
||||
var _loc2_:Array = [];
|
||||
param1.endian = "littleEndian";
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < param1.length)
|
||||
{
|
||||
_loc2_.push(param1.readUnsignedInt());
|
||||
_loc5_ += 4;
|
||||
}
|
||||
var _loc4_:Array = core_md5(_loc2_,_loc3_);
|
||||
var _loc7_:ByteArray = new ByteArray();
|
||||
_loc7_.endian = "littleEndian";
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < 4)
|
||||
{
|
||||
_loc7_.writeUnsignedInt(_loc4_[_loc5_]);
|
||||
_loc5_++;
|
||||
}
|
||||
param1.length = _loc3_ / 8;
|
||||
param1.endian = _loc6_;
|
||||
return _loc7_;
|
||||
}
|
||||
|
||||
private function core_md5(param1:Array, param2:uint) : Array
|
||||
{
|
||||
var _loc8_:* = 0;
|
||||
var _loc10_:* = 0;
|
||||
var _loc11_:* = 0;
|
||||
var _loc7_:* = 0;
|
||||
var _loc9_:* = 0;
|
||||
param1[param2 >> 5] |= 128 << param2 % 32;
|
||||
param1[(param2 + 64 >>> 9 << 4) + 14] = param2;
|
||||
var _loc3_:* = 1732584193;
|
||||
var _loc4_:* = 4023233417;
|
||||
var _loc5_:* = 2562383102;
|
||||
var _loc6_:* = 271733878;
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < param1.length)
|
||||
{
|
||||
var _loc13_:* = _loc8_;
|
||||
param1[_loc13_] ||= 0;
|
||||
var _loc12_:Number = _loc8_ + 1;
|
||||
param1[_loc12_] ||= 0;
|
||||
_loc13_ = _loc8_ + 2;
|
||||
param1[_loc13_] ||= 0;
|
||||
_loc12_ = _loc8_ + 3;
|
||||
param1[_loc12_] ||= 0;
|
||||
_loc13_ = _loc8_ + 4;
|
||||
param1[_loc13_] ||= 0;
|
||||
_loc12_ = _loc8_ + 5;
|
||||
param1[_loc12_] ||= 0;
|
||||
_loc13_ = _loc8_ + 6;
|
||||
param1[_loc13_] ||= 0;
|
||||
_loc12_ = _loc8_ + 7;
|
||||
param1[_loc12_] ||= 0;
|
||||
_loc13_ = _loc8_ + 8;
|
||||
param1[_loc13_] ||= 0;
|
||||
_loc12_ = _loc8_ + 9;
|
||||
param1[_loc12_] ||= 0;
|
||||
_loc13_ = _loc8_ + 10;
|
||||
param1[_loc13_] ||= 0;
|
||||
_loc12_ = _loc8_ + 11;
|
||||
param1[_loc12_] ||= 0;
|
||||
_loc13_ = _loc8_ + 12;
|
||||
param1[_loc13_] ||= 0;
|
||||
_loc12_ = _loc8_ + 13;
|
||||
param1[_loc12_] ||= 0;
|
||||
_loc13_ = _loc8_ + 14;
|
||||
param1[_loc13_] ||= 0;
|
||||
_loc12_ = _loc8_ + 15;
|
||||
param1[_loc12_] ||= 0;
|
||||
_loc10_ = _loc3_;
|
||||
_loc11_ = _loc4_;
|
||||
_loc7_ = _loc5_;
|
||||
_loc9_ = _loc6_;
|
||||
_loc3_ = ff(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 0],7,3614090360);
|
||||
_loc6_ = ff(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 1],12,3905402710);
|
||||
_loc5_ = ff(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 2],17,606105819);
|
||||
_loc4_ = ff(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 3],22,3250441966);
|
||||
_loc3_ = ff(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 4],7,4118548399);
|
||||
_loc6_ = ff(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 5],12,1200080426);
|
||||
_loc5_ = ff(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 6],17,2821735955);
|
||||
_loc4_ = ff(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 7],22,4249261313);
|
||||
_loc3_ = ff(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 8],7,1770035416);
|
||||
_loc6_ = ff(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 9],12,2336552879);
|
||||
_loc5_ = ff(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 10],17,4294925233);
|
||||
_loc4_ = ff(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 11],22,2304563134);
|
||||
_loc3_ = ff(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 12],7,1804603682);
|
||||
_loc6_ = ff(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 13],12,4254626195);
|
||||
_loc5_ = ff(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 14],17,2792965006);
|
||||
_loc4_ = ff(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 15],22,1236535329);
|
||||
_loc3_ = gg(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 1],5,4129170786);
|
||||
_loc6_ = gg(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 6],9,3225465664);
|
||||
_loc5_ = gg(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 11],14,643717713);
|
||||
_loc4_ = gg(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 0],20,3921069994);
|
||||
_loc3_ = gg(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 5],5,3593408605);
|
||||
_loc6_ = gg(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 10],9,38016083);
|
||||
_loc5_ = gg(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 15],14,3634488961);
|
||||
_loc4_ = gg(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 4],20,3889429448);
|
||||
_loc3_ = gg(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 9],5,568446438);
|
||||
_loc6_ = gg(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 14],9,3275163606);
|
||||
_loc5_ = gg(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 3],14,4107603335);
|
||||
_loc4_ = gg(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 8],20,1163531501);
|
||||
_loc3_ = gg(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 13],5,2850285829);
|
||||
_loc6_ = gg(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 2],9,4243563512);
|
||||
_loc5_ = gg(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 7],14,1735328473);
|
||||
_loc4_ = gg(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 12],20,2368359562);
|
||||
_loc3_ = hh(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 5],4,4294588738);
|
||||
_loc6_ = hh(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 8],11,2272392833);
|
||||
_loc5_ = hh(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 11],16,1839030562);
|
||||
_loc4_ = hh(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 14],23,4259657740);
|
||||
_loc3_ = hh(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 1],4,2763975236);
|
||||
_loc6_ = hh(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 4],11,1272893353);
|
||||
_loc5_ = hh(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 7],16,4139469664);
|
||||
_loc4_ = hh(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 10],23,3200236656);
|
||||
_loc3_ = hh(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 13],4,681279174);
|
||||
_loc6_ = hh(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 0],11,3936430074);
|
||||
_loc5_ = hh(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 3],16,3572445317);
|
||||
_loc4_ = hh(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 6],23,76029189);
|
||||
_loc3_ = hh(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 9],4,3654602809);
|
||||
_loc6_ = hh(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 12],11,3873151461);
|
||||
_loc5_ = hh(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 15],16,530742520);
|
||||
_loc4_ = hh(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 2],23,3299628645);
|
||||
_loc3_ = ii(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 0],6,4096336452);
|
||||
_loc6_ = ii(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 7],10,1126891415);
|
||||
_loc5_ = ii(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 14],15,2878612391);
|
||||
_loc4_ = ii(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 5],21,4237533241);
|
||||
_loc3_ = ii(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 12],6,1700485571);
|
||||
_loc6_ = ii(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 3],10,2399980690);
|
||||
_loc5_ = ii(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 10],15,4293915773);
|
||||
_loc4_ = ii(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 1],21,2240044497);
|
||||
_loc3_ = ii(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 8],6,1873313359);
|
||||
_loc6_ = ii(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 15],10,4264355552);
|
||||
_loc5_ = ii(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 6],15,2734768916);
|
||||
_loc4_ = ii(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 13],21,1309151649);
|
||||
_loc3_ = ii(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc8_ + 4],6,4149444226);
|
||||
_loc6_ = ii(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc8_ + 11],10,3174756917);
|
||||
_loc5_ = ii(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc8_ + 2],15,718787259);
|
||||
_loc4_ = ii(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc8_ + 9],21,3951481745);
|
||||
_loc3_ += _loc10_;
|
||||
_loc4_ += _loc11_;
|
||||
_loc5_ += _loc7_;
|
||||
_loc6_ += _loc9_;
|
||||
_loc8_ += 16;
|
||||
}
|
||||
return [_loc3_,_loc4_,_loc5_,_loc6_];
|
||||
}
|
||||
|
||||
private function rol(param1:uint, param2:uint) : uint
|
||||
{
|
||||
return param1 << param2 | param1 >>> 32 - param2;
|
||||
}
|
||||
|
||||
private function cmn(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint) : uint
|
||||
{
|
||||
return rol(param2 + param1 + param4 + param6,param5) + param3;
|
||||
}
|
||||
|
||||
private function ff(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint, param7:uint) : uint
|
||||
{
|
||||
return cmn(param2 & param3 | ~param2 & param4,param1,param2,param5,param6,param7);
|
||||
}
|
||||
|
||||
private function gg(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint, param7:uint) : uint
|
||||
{
|
||||
return cmn(param2 & param4 | param3 & ~param4,param1,param2,param5,param6,param7);
|
||||
}
|
||||
|
||||
private function hh(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint, param7:uint) : uint
|
||||
{
|
||||
return cmn(param2 ^ param3 ^ param4,param1,param2,param5,param6,param7);
|
||||
}
|
||||
|
||||
private function ii(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint, param7:uint) : uint
|
||||
{
|
||||
return cmn(param3 ^ (param2 | ~param4),param1,param2,param5,param6,param7);
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "md5";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
package com.hurlant.crypto.hash
|
||||
{
|
||||
public class SHA1 extends SHABase implements IHash
|
||||
{
|
||||
|
||||
public static const HASH_SIZE:int = 20;
|
||||
|
||||
public function SHA1()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
override public function getHashSize() : uint
|
||||
{
|
||||
return 20;
|
||||
}
|
||||
|
||||
override protected function core(param1:Array, param2:uint) : Array
|
||||
{
|
||||
var _loc9_:* = 0;
|
||||
var _loc13_:* = 0;
|
||||
var _loc14_:* = 0;
|
||||
var _loc8_:* = 0;
|
||||
var _loc10_:* = 0;
|
||||
var _loc11_:* = 0;
|
||||
var _loc12_:* = 0;
|
||||
var _loc15_:* = 0;
|
||||
param1[param2 >> 5] |= 128 << 24 - param2 % 32;
|
||||
param1[(param2 + 64 >> 9 << 4) + 15] = param2;
|
||||
var _loc16_:Array = [];
|
||||
var _loc3_:* = 1732584193;
|
||||
var _loc4_:* = 4023233417;
|
||||
var _loc5_:* = 2562383102;
|
||||
var _loc6_:* = 271733878;
|
||||
var _loc7_:* = 3285377520;
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < param1.length)
|
||||
{
|
||||
_loc13_ = _loc3_;
|
||||
_loc14_ = _loc4_;
|
||||
_loc8_ = _loc5_;
|
||||
_loc10_ = _loc6_;
|
||||
_loc11_ = _loc7_;
|
||||
_loc12_ = 0;
|
||||
while(_loc12_ < 80)
|
||||
{
|
||||
if(_loc12_ < 16)
|
||||
{
|
||||
_loc16_[_loc12_] = param1[_loc9_ + _loc12_] || 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc16_[_loc12_] = rol(_loc16_[_loc12_ - 3] ^ _loc16_[_loc12_ - 8] ^ _loc16_[_loc12_ - 14] ^ _loc16_[_loc12_ - 16],1);
|
||||
}
|
||||
_loc15_ = uint(rol(_loc3_,5) + ft(_loc12_,_loc4_,_loc5_,_loc6_) + _loc7_ + _loc16_[_loc12_] + kt(_loc12_));
|
||||
_loc7_ = _loc6_;
|
||||
_loc6_ = _loc5_;
|
||||
_loc5_ = rol(_loc4_,30);
|
||||
_loc4_ = _loc3_;
|
||||
_loc3_ = _loc15_;
|
||||
_loc12_++;
|
||||
}
|
||||
_loc3_ += _loc13_;
|
||||
_loc4_ += _loc14_;
|
||||
_loc5_ += _loc8_;
|
||||
_loc6_ += _loc10_;
|
||||
_loc7_ += _loc11_;
|
||||
_loc9_ += 16;
|
||||
}
|
||||
return [_loc3_,_loc4_,_loc5_,_loc6_,_loc7_];
|
||||
}
|
||||
|
||||
private function rol(param1:uint, param2:uint) : uint
|
||||
{
|
||||
return param1 << param2 | param1 >>> 32 - param2;
|
||||
}
|
||||
|
||||
private function ft(param1:uint, param2:uint, param3:uint, param4:uint) : uint
|
||||
{
|
||||
if(param1 < 20)
|
||||
{
|
||||
return param2 & param3 | ~param2 & param4;
|
||||
}
|
||||
if(param1 < 40)
|
||||
{
|
||||
return param2 ^ param3 ^ param4;
|
||||
}
|
||||
if(param1 < 60)
|
||||
{
|
||||
return param2 & param3 | param2 & param4 | param3 & param4;
|
||||
}
|
||||
return param2 ^ param3 ^ param4;
|
||||
}
|
||||
|
||||
private function kt(param1:uint) : uint
|
||||
{
|
||||
return param1 < 20 ? 1518500249 : (param1 < 40 ? 1859775393 : (param1 < 60 ? 2400959708 : 3395469782));
|
||||
}
|
||||
|
||||
override public function toString() : String
|
||||
{
|
||||
return "sha1";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
package com.hurlant.crypto.hash
|
||||
{
|
||||
public class SHA224 extends SHA256
|
||||
{
|
||||
|
||||
public function SHA224()
|
||||
{
|
||||
super();
|
||||
_h = [3238371032,914150663,812702999,4144912697,4290775857,1750603025,1694076839,3204075428];
|
||||
}
|
||||
|
||||
override public function getHashSize() : uint
|
||||
{
|
||||
return 28;
|
||||
}
|
||||
|
||||
override public function toString() : String
|
||||
{
|
||||
return "sha224";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
package com.hurlant.crypto.hash
|
||||
{
|
||||
public class SHA256 extends SHABase implements IHash
|
||||
{
|
||||
|
||||
protected static const k:Array = [1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298];
|
||||
|
||||
protected var _h:Array = [1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225];
|
||||
|
||||
public function SHA256()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
override public function getHashSize() : uint
|
||||
{
|
||||
return 32;
|
||||
}
|
||||
|
||||
override protected function core(param1:Array, param2:uint) : Array
|
||||
{
|
||||
var _loc16_:* = 0;
|
||||
var _loc21_:* = 0;
|
||||
var _loc22_:* = 0;
|
||||
var _loc15_:* = 0;
|
||||
var _loc17_:* = 0;
|
||||
var _loc18_:* = 0;
|
||||
var _loc20_:* = 0;
|
||||
var _loc3_:* = 0;
|
||||
var _loc4_:* = 0;
|
||||
var _loc19_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc25_:* = 0;
|
||||
var _loc24_:* = 0;
|
||||
param1[param2 >> 5] |= 128 << 24 - param2 % 32;
|
||||
param1[(param2 + 64 >> 9 << 4) + 15] = param2;
|
||||
var _loc23_:Array = [];
|
||||
var _loc7_:uint = uint(_h[0]);
|
||||
var _loc8_:uint = uint(_h[1]);
|
||||
var _loc9_:uint = uint(_h[2]);
|
||||
var _loc10_:uint = uint(_h[3]);
|
||||
var _loc11_:uint = uint(_h[4]);
|
||||
var _loc12_:uint = uint(_h[5]);
|
||||
var _loc13_:uint = uint(_h[6]);
|
||||
var _loc14_:uint = uint(_h[7]);
|
||||
_loc16_ = 0;
|
||||
while(_loc16_ < param1.length)
|
||||
{
|
||||
_loc21_ = _loc7_;
|
||||
_loc22_ = _loc8_;
|
||||
_loc15_ = _loc9_;
|
||||
_loc17_ = _loc10_;
|
||||
_loc18_ = _loc11_;
|
||||
_loc20_ = _loc12_;
|
||||
_loc3_ = _loc13_;
|
||||
_loc4_ = _loc14_;
|
||||
_loc19_ = 0;
|
||||
while(_loc19_ < 64)
|
||||
{
|
||||
if(_loc19_ < 16)
|
||||
{
|
||||
_loc23_[_loc19_] = param1[_loc16_ + _loc19_] || 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc5_ = uint(rrol(_loc23_[_loc19_ - 15],7) ^ rrol(_loc23_[_loc19_ - 15],18) ^ _loc23_[_loc19_ - 15] >>> 3);
|
||||
_loc6_ = uint(rrol(_loc23_[_loc19_ - 2],17) ^ rrol(_loc23_[_loc19_ - 2],19) ^ _loc23_[_loc19_ - 2] >>> 10);
|
||||
_loc23_[_loc19_] = _loc23_[_loc19_ - 16] + _loc5_ + _loc23_[_loc19_ - 7] + _loc6_;
|
||||
}
|
||||
_loc25_ = uint((rrol(_loc7_,2) ^ rrol(_loc7_,13) ^ rrol(_loc7_,22)) + (_loc7_ & _loc8_ ^ _loc7_ & _loc9_ ^ _loc8_ & _loc9_));
|
||||
_loc24_ = uint(_loc14_ + (rrol(_loc11_,6) ^ rrol(_loc11_,11) ^ rrol(_loc11_,25)) + (_loc11_ & _loc12_ ^ _loc13_ & ~_loc11_) + k[_loc19_] + _loc23_[_loc19_]);
|
||||
_loc14_ = _loc13_;
|
||||
_loc13_ = _loc12_;
|
||||
_loc12_ = _loc11_;
|
||||
_loc11_ = _loc10_ + _loc24_;
|
||||
_loc10_ = _loc9_;
|
||||
_loc9_ = _loc8_;
|
||||
_loc8_ = _loc7_;
|
||||
_loc7_ = _loc24_ + _loc25_;
|
||||
_loc19_++;
|
||||
}
|
||||
_loc7_ += _loc21_;
|
||||
_loc8_ += _loc22_;
|
||||
_loc9_ += _loc15_;
|
||||
_loc10_ += _loc17_;
|
||||
_loc11_ += _loc18_;
|
||||
_loc12_ += _loc20_;
|
||||
_loc13_ += _loc3_;
|
||||
_loc14_ += _loc4_;
|
||||
_loc16_ += 16;
|
||||
}
|
||||
return [_loc7_,_loc8_,_loc9_,_loc10_,_loc11_,_loc12_,_loc13_,_loc14_];
|
||||
}
|
||||
|
||||
protected function rrol(param1:uint, param2:uint) : uint
|
||||
{
|
||||
return param1 << 32 - param2 | param1 >>> param2;
|
||||
}
|
||||
|
||||
override public function toString() : String
|
||||
{
|
||||
return "sha256";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
package com.hurlant.crypto.hash
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class SHABase implements IHash
|
||||
{
|
||||
|
||||
public function SHABase()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function getInputSize() : uint
|
||||
{
|
||||
return 64;
|
||||
}
|
||||
|
||||
public function getHashSize() : uint
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
public function hash(param1:ByteArray) : ByteArray
|
||||
{
|
||||
var _loc7_:* = 0;
|
||||
var _loc6_:uint = param1.length;
|
||||
var _loc8_:String = param1.endian;
|
||||
param1.endian = "bigEndian";
|
||||
var _loc3_:uint = _loc6_ * 8;
|
||||
while(param1.length % 4 != 0)
|
||||
{
|
||||
param1[param1.length] = 0;
|
||||
}
|
||||
param1.position = 0;
|
||||
var _loc2_:Array = [];
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < param1.length)
|
||||
{
|
||||
_loc2_.push(param1.readUnsignedInt());
|
||||
_loc7_ += 4;
|
||||
}
|
||||
var _loc4_:Array = core(_loc2_,_loc3_);
|
||||
var _loc9_:ByteArray = new ByteArray();
|
||||
var _loc5_:uint = getHashSize() / 4;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _loc5_)
|
||||
{
|
||||
_loc9_.writeUnsignedInt(_loc4_[_loc7_]);
|
||||
_loc7_++;
|
||||
}
|
||||
param1.length = _loc6_;
|
||||
param1.endian = _loc8_;
|
||||
return _loc9_;
|
||||
}
|
||||
|
||||
protected function core(param1:Array, param2:uint) : Array
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "sha";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,115 @@
|
||||
package com.hurlant.crypto.prng
|
||||
{
|
||||
import com.hurlant.crypto.symmetric.IStreamCipher;
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class ARC4 implements IPRNG, IStreamCipher
|
||||
{
|
||||
|
||||
private var i:int = 0;
|
||||
|
||||
private var j:int = 0;
|
||||
|
||||
private var S:ByteArray;
|
||||
|
||||
private const psize:uint = 256;
|
||||
|
||||
public function ARC4(param1:ByteArray = null)
|
||||
{
|
||||
super();
|
||||
S = new ByteArray();
|
||||
if(param1)
|
||||
{
|
||||
init(param1);
|
||||
}
|
||||
}
|
||||
|
||||
public function getPoolSize() : uint
|
||||
{
|
||||
return 256;
|
||||
}
|
||||
|
||||
public function init(param1:ByteArray) : void
|
||||
{
|
||||
var _loc3_:int = 0;
|
||||
var _loc4_:int = 0;
|
||||
var _loc2_:int = 0;
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < 256)
|
||||
{
|
||||
S[_loc3_] = _loc3_;
|
||||
_loc3_++;
|
||||
}
|
||||
_loc4_ = 0;
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < 256)
|
||||
{
|
||||
_loc4_ = _loc4_ + S[_loc3_] + param1[_loc3_ % param1.length] & 0xFF;
|
||||
_loc2_ = int(S[_loc3_]);
|
||||
S[_loc3_] = S[_loc4_];
|
||||
S[_loc4_] = _loc2_;
|
||||
_loc3_++;
|
||||
}
|
||||
this.i = 0;
|
||||
this.j = 0;
|
||||
}
|
||||
|
||||
public function next() : uint
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
i = i + 1 & 0xFF;
|
||||
j = j + S[i] & 0xFF;
|
||||
_loc1_ = int(S[i]);
|
||||
S[i] = S[j];
|
||||
S[j] = _loc1_;
|
||||
return S[_loc1_ + S[i] & 0xFF];
|
||||
}
|
||||
|
||||
public function getBlockSize() : uint
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc2_:uint = 0;
|
||||
while(_loc2_ < param1.length)
|
||||
{
|
||||
var _loc3_:uint = _loc2_++;
|
||||
var _loc4_:int = param1[_loc3_] ^ next();
|
||||
param1[_loc3_] = _loc4_;
|
||||
}
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray) : void
|
||||
{
|
||||
encrypt(param1);
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
var _loc1_:uint = 0;
|
||||
if(S != null)
|
||||
{
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < S.length)
|
||||
{
|
||||
S[_loc1_] = Math.random() * 256;
|
||||
_loc1_++;
|
||||
}
|
||||
S.length = 0;
|
||||
S = null;
|
||||
}
|
||||
this.i = 0;
|
||||
this.j = 0;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "rc4";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
package com.hurlant.crypto.prng
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public interface IPRNG
|
||||
{
|
||||
|
||||
function getPoolSize() : uint;
|
||||
|
||||
function init(param1:ByteArray) : void;
|
||||
|
||||
function next() : uint;
|
||||
|
||||
function dispose() : void;
|
||||
|
||||
function toString() : String;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,132 @@
|
||||
package com.hurlant.crypto.prng
|
||||
{
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.system.Capabilities;
|
||||
import flash.system.System;
|
||||
import flash.text.Font;
|
||||
import flash.utils.ByteArray;
|
||||
import flash.utils.getTimer;
|
||||
|
||||
public class Random
|
||||
{
|
||||
|
||||
private var state:IPRNG;
|
||||
|
||||
private var ready:Boolean = false;
|
||||
|
||||
private var pool:ByteArray;
|
||||
|
||||
private var psize:int;
|
||||
|
||||
private var pptr:int;
|
||||
|
||||
private var seeded:Boolean = false;
|
||||
|
||||
public function Random(param1:Class = null)
|
||||
{
|
||||
var _loc2_:* = 0;
|
||||
super();
|
||||
if(param1 == null)
|
||||
{
|
||||
param1 = ARC4;
|
||||
}
|
||||
state = new param1() as IPRNG;
|
||||
psize = state.getPoolSize();
|
||||
pool = new ByteArray();
|
||||
pptr = 0;
|
||||
while(pptr < psize)
|
||||
{
|
||||
_loc2_ = uint(65536 * Math.random());
|
||||
pool[pptr++] = _loc2_ >>> 8;
|
||||
pool[pptr++] = _loc2_ & 0xFF;
|
||||
}
|
||||
pptr = 0;
|
||||
seed();
|
||||
}
|
||||
|
||||
public function seed(param1:int = 0) : void
|
||||
{
|
||||
if(param1 == 0)
|
||||
{
|
||||
param1 = new Date().getTime();
|
||||
}
|
||||
var _loc2_:Number = pptr++;
|
||||
var _loc3_:int = pool[_loc2_] ^ param1 & 0xFF;
|
||||
pool[_loc2_] = _loc3_;
|
||||
pool[pptr++] ^= param1 >> 8 & 0xFF;
|
||||
pool[pptr++] ^= param1 >> 16 & 0xFF;
|
||||
pool[pptr++] ^= param1 >> 24 & 0xFF;
|
||||
pptr %= psize;
|
||||
seeded = true;
|
||||
}
|
||||
|
||||
public function autoSeed() : void
|
||||
{
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc2_.writeUnsignedInt(System.totalMemory);
|
||||
_loc2_.writeUTF(Capabilities.serverString);
|
||||
_loc2_.writeUnsignedInt(getTimer());
|
||||
_loc2_.writeUnsignedInt(new Date().getTime());
|
||||
var _loc1_:Array = Font.enumerateFonts(true);
|
||||
for each(var _loc3_:Font in _loc1_)
|
||||
{
|
||||
_loc2_.writeUTF(_loc3_.fontName);
|
||||
_loc2_.writeUTF(_loc3_.fontStyle);
|
||||
_loc2_.writeUTF(_loc3_.fontType);
|
||||
}
|
||||
_loc2_.position = 0;
|
||||
while(_loc2_.bytesAvailable >= 4)
|
||||
{
|
||||
seed(_loc2_.readUnsignedInt());
|
||||
}
|
||||
}
|
||||
|
||||
public function nextBytes(param1:ByteArray, param2:int) : void
|
||||
{
|
||||
while(param2--)
|
||||
{
|
||||
param1.writeByte(nextByte());
|
||||
}
|
||||
}
|
||||
|
||||
public function nextByte() : int
|
||||
{
|
||||
if(!ready)
|
||||
{
|
||||
if(!seeded)
|
||||
{
|
||||
autoSeed();
|
||||
}
|
||||
state.init(pool);
|
||||
pool.length = 0;
|
||||
pptr = 0;
|
||||
ready = true;
|
||||
}
|
||||
return state.next();
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
var _loc1_:* = 0;
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < pool.length)
|
||||
{
|
||||
pool[_loc1_] = Math.random() * 256;
|
||||
_loc1_++;
|
||||
}
|
||||
pool.length = 0;
|
||||
pool = null;
|
||||
state.dispose();
|
||||
state = null;
|
||||
psize = 0;
|
||||
pptr = 0;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "random-" + state.toString();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,317 @@
|
||||
package com.hurlant.crypto.rsa
|
||||
{
|
||||
import com.hurlant.crypto.prng.Random;
|
||||
import com.hurlant.math.BigInteger;
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class RSAKey
|
||||
{
|
||||
|
||||
public var e:int;
|
||||
|
||||
public var n:BigInteger;
|
||||
|
||||
public var d:BigInteger;
|
||||
|
||||
public var p:BigInteger;
|
||||
|
||||
public var q:BigInteger;
|
||||
|
||||
public var dmp1:BigInteger;
|
||||
|
||||
public var dmq1:BigInteger;
|
||||
|
||||
public var coeff:BigInteger;
|
||||
|
||||
protected var canDecrypt:Boolean;
|
||||
|
||||
protected var canEncrypt:Boolean;
|
||||
|
||||
public function RSAKey(param1:BigInteger, param2:int, param3:BigInteger = null, param4:BigInteger = null, param5:BigInteger = null, param6:BigInteger = null, param7:BigInteger = null, param8:BigInteger = null)
|
||||
{
|
||||
super();
|
||||
this.n = param1;
|
||||
this.e = param2;
|
||||
this.d = param3;
|
||||
this.p = param4;
|
||||
this.q = param5;
|
||||
this.dmp1 = param6;
|
||||
this.dmq1 = param7;
|
||||
this.coeff = param8;
|
||||
canEncrypt = n != null && e != 0;
|
||||
canDecrypt = canEncrypt && d != null;
|
||||
}
|
||||
|
||||
public static function parsePublicKey(param1:String, param2:String) : RSAKey
|
||||
{
|
||||
return new RSAKey(new BigInteger(param1,16),parseInt(param2,16));
|
||||
}
|
||||
|
||||
public static function parsePrivateKey(param1:String, param2:String, param3:String, param4:String = null, param5:String = null, param6:String = null, param7:String = null, param8:String = null) : RSAKey
|
||||
{
|
||||
if(param4 == null)
|
||||
{
|
||||
return new RSAKey(new BigInteger(param1,16),parseInt(param2,16),new BigInteger(param3,16));
|
||||
}
|
||||
return new RSAKey(new BigInteger(param1,16),parseInt(param2,16),new BigInteger(param3,16),new BigInteger(param4,16),new BigInteger(param5,16),new BigInteger(param6,16),new BigInteger(param7),new BigInteger(param8));
|
||||
}
|
||||
|
||||
public static function generate(param1:uint, param2:String) : RSAKey
|
||||
{
|
||||
var _loc8_:BigInteger = null;
|
||||
var _loc6_:BigInteger = null;
|
||||
var _loc4_:BigInteger = null;
|
||||
var _loc5_:BigInteger = null;
|
||||
var _loc9_:Random = new Random();
|
||||
var _loc7_:uint = uint(param1 >> 1);
|
||||
var _loc10_:RSAKey = new RSAKey(null,0,null);
|
||||
_loc10_.e = parseInt(param2,16);
|
||||
var _loc3_:BigInteger = new BigInteger(param2,16);
|
||||
do
|
||||
{
|
||||
do
|
||||
{
|
||||
_loc10_.p = bigRandom(param1 - _loc7_,_loc9_);
|
||||
}
|
||||
while(!(_loc10_.p.subtract(BigInteger.ONE).gcd(_loc3_).compareTo(BigInteger.ONE) == 0 && _loc10_.p.isProbablePrime(10)));
|
||||
do
|
||||
{
|
||||
_loc10_.q = bigRandom(_loc7_,_loc9_);
|
||||
}
|
||||
while(!(_loc10_.q.subtract(BigInteger.ONE).gcd(_loc3_).compareTo(BigInteger.ONE) == 0 && _loc10_.q.isProbablePrime(10)));
|
||||
if(_loc10_.p.compareTo(_loc10_.q) <= 0)
|
||||
{
|
||||
_loc8_ = _loc10_.p;
|
||||
_loc10_.p = _loc10_.q;
|
||||
_loc10_.q = _loc8_;
|
||||
}
|
||||
_loc6_ = _loc10_.p.subtract(BigInteger.ONE);
|
||||
_loc4_ = _loc10_.q.subtract(BigInteger.ONE);
|
||||
}
|
||||
while(_loc5_ = _loc6_.multiply(_loc4_), _loc5_.gcd(_loc3_).compareTo(BigInteger.ONE) != 0);
|
||||
_loc10_.n = _loc10_.p.multiply(_loc10_.q);
|
||||
_loc10_.d = _loc3_.modInverse(_loc5_);
|
||||
_loc10_.dmp1 = _loc10_.d.mod(_loc6_);
|
||||
_loc10_.dmq1 = _loc10_.d.mod(_loc4_);
|
||||
_loc10_.coeff = _loc10_.q.modInverse(_loc10_.p);
|
||||
return _loc10_;
|
||||
}
|
||||
|
||||
protected static function bigRandom(param1:int, param2:Random) : BigInteger
|
||||
{
|
||||
if(param1 < 2)
|
||||
{
|
||||
return BigInteger.nbv(1);
|
||||
}
|
||||
var _loc4_:ByteArray = new ByteArray();
|
||||
param2.nextBytes(_loc4_,param1 >> 3);
|
||||
_loc4_.position = 0;
|
||||
var _loc3_:BigInteger = new BigInteger(_loc4_);
|
||||
_loc3_.primify(param1,1);
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
public function getBlockSize() : uint
|
||||
{
|
||||
return (n.bitLength() + 7) / 8;
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
e = 0;
|
||||
n.dispose();
|
||||
n = null;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray, param2:ByteArray, param3:uint, param4:Function = null) : void
|
||||
{
|
||||
_encrypt(doPublic,param1,param2,param3,param4,2);
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray, param2:ByteArray, param3:uint, param4:Function = null) : void
|
||||
{
|
||||
_decrypt(doPrivate2,param1,param2,param3,param4,2);
|
||||
}
|
||||
|
||||
public function sign(param1:ByteArray, param2:ByteArray, param3:uint, param4:Function = null) : void
|
||||
{
|
||||
_encrypt(doPrivate2,param1,param2,param3,param4,1);
|
||||
}
|
||||
|
||||
public function verify(param1:ByteArray, param2:ByteArray, param3:uint, param4:Function = null) : void
|
||||
{
|
||||
_decrypt(doPublic,param1,param2,param3,param4,1);
|
||||
}
|
||||
|
||||
private function _encrypt(param1:Function, param2:ByteArray, param3:ByteArray, param4:uint, param5:Function, param6:int) : void
|
||||
{
|
||||
var _loc10_:BigInteger = null;
|
||||
var _loc7_:BigInteger = null;
|
||||
if(param5 == null)
|
||||
{
|
||||
param5 = pkcs1pad;
|
||||
}
|
||||
if(param2.position >= param2.length)
|
||||
{
|
||||
param2.position = 0;
|
||||
}
|
||||
var _loc8_:uint = getBlockSize();
|
||||
var _loc9_:int = param2.position + param4;
|
||||
while(param2.position < _loc9_)
|
||||
{
|
||||
_loc10_ = new BigInteger(param5(param2,_loc9_,_loc8_,param6),_loc8_);
|
||||
_loc7_ = param1(_loc10_);
|
||||
_loc7_.toArray(param3);
|
||||
}
|
||||
}
|
||||
|
||||
private function _decrypt(param1:Function, param2:ByteArray, param3:ByteArray, param4:uint, param5:Function, param6:int) : void
|
||||
{
|
||||
var _loc11_:BigInteger = null;
|
||||
var _loc8_:BigInteger = null;
|
||||
var _loc7_:ByteArray = null;
|
||||
if(param5 == null)
|
||||
{
|
||||
param5 = pkcs1unpad;
|
||||
}
|
||||
if(param2.position >= param2.length)
|
||||
{
|
||||
param2.position = 0;
|
||||
}
|
||||
var _loc9_:uint = getBlockSize();
|
||||
var _loc10_:int = param2.position + param4;
|
||||
while(param2.position < _loc10_)
|
||||
{
|
||||
_loc11_ = new BigInteger(param2,param4);
|
||||
_loc8_ = param1(_loc11_);
|
||||
_loc7_ = param5(_loc8_,_loc9_);
|
||||
param3.writeBytes(_loc7_);
|
||||
}
|
||||
}
|
||||
|
||||
private function pkcs1pad(param1:ByteArray, param2:int, param3:uint, param4:uint = 2) : ByteArray
|
||||
{
|
||||
var _loc6_:int = 0;
|
||||
var _loc9_:ByteArray = new ByteArray();
|
||||
var _loc5_:int = int(param1.position);
|
||||
param2 = Math.min(param2,param1.length,_loc5_ + param3 - 11);
|
||||
param1.position = param2;
|
||||
var _loc7_:int = param2 - 1;
|
||||
while(_loc7_ >= _loc5_ && param3 > 11)
|
||||
{
|
||||
_loc9_[--param3] = param1[_loc7_--];
|
||||
}
|
||||
_loc9_[--param3] = 0;
|
||||
var _loc8_:Random = new Random();
|
||||
while(param3 > 2)
|
||||
{
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ == 0)
|
||||
{
|
||||
_loc6_ = int(param4 == 2 ? _loc8_.nextByte() : 255);
|
||||
}
|
||||
_loc9_[--param3] = _loc6_;
|
||||
}
|
||||
_loc9_[--param3] = param4;
|
||||
_loc9_[--param3] = 0;
|
||||
return _loc9_;
|
||||
}
|
||||
|
||||
private function pkcs1unpad(param1:BigInteger, param2:uint, param3:uint = 2) : ByteArray
|
||||
{
|
||||
var _loc4_:ByteArray = param1.toByteArray();
|
||||
var _loc6_:ByteArray = new ByteArray();
|
||||
var _loc5_:int = 0;
|
||||
while(_loc5_ < _loc4_.length && _loc4_[_loc5_] == 0)
|
||||
{
|
||||
_loc5_++;
|
||||
}
|
||||
if(_loc4_.length - _loc5_ != param2 - 1 || _loc4_[_loc5_] > 2)
|
||||
{
|
||||
trace("PKCS#1 unpad: i=" + _loc5_ + ", expected b[i]==[0,1,2], got b[i]=" + _loc4_[_loc5_].toString(16));
|
||||
return null;
|
||||
}
|
||||
_loc5_++;
|
||||
while(_loc4_[_loc5_] != 0)
|
||||
{
|
||||
if(++_loc5_ >= _loc4_.length)
|
||||
{
|
||||
trace("PKCS#1 unpad: i=" + _loc5_ + ", b[i-1]!=0 (=" + _loc4_[_loc5_ - 1].toString(16) + ")");
|
||||
return null;
|
||||
}
|
||||
}
|
||||
while(++_loc5_ < _loc4_.length)
|
||||
{
|
||||
_loc6_.writeByte(_loc4_[_loc5_]);
|
||||
}
|
||||
_loc6_.position = 0;
|
||||
return _loc6_;
|
||||
}
|
||||
|
||||
private function rawpad(param1:ByteArray, param2:int, param3:uint) : ByteArray
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "rsa";
|
||||
}
|
||||
|
||||
public function dump() : String
|
||||
{
|
||||
var _loc1_:String = "N=" + n.toString(16) + "\n" + "E=" + e.toString(16) + "\n";
|
||||
if(canDecrypt)
|
||||
{
|
||||
_loc1_ += "D=" + d.toString(16) + "\n";
|
||||
if(p != null && q != null)
|
||||
{
|
||||
_loc1_ += "P=" + p.toString(16) + "\n";
|
||||
_loc1_ += "Q=" + q.toString(16) + "\n";
|
||||
_loc1_ += "DMP1=" + dmp1.toString(16) + "\n";
|
||||
_loc1_ += "DMQ1=" + dmq1.toString(16) + "\n";
|
||||
_loc1_ += "IQMP=" + coeff.toString(16) + "\n";
|
||||
}
|
||||
}
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
protected function doPublic(param1:BigInteger) : BigInteger
|
||||
{
|
||||
return param1.modPowInt(e,n);
|
||||
}
|
||||
|
||||
protected function doPrivate2(param1:BigInteger) : BigInteger
|
||||
{
|
||||
if(p == null && q == null)
|
||||
{
|
||||
return param1.modPow(d,n);
|
||||
}
|
||||
var _loc3_:BigInteger = param1.mod(p).modPow(dmp1,p);
|
||||
var _loc4_:BigInteger = param1.mod(q).modPow(dmq1,q);
|
||||
while(_loc3_.compareTo(_loc4_) < 0)
|
||||
{
|
||||
_loc3_ = _loc3_.add(p);
|
||||
}
|
||||
return _loc3_.subtract(_loc4_).multiply(coeff).mod(p).multiply(q).add(_loc4_);
|
||||
}
|
||||
|
||||
protected function doPrivate(param1:BigInteger) : BigInteger
|
||||
{
|
||||
if(p == null || q == null)
|
||||
{
|
||||
return param1.modPow(d,n);
|
||||
}
|
||||
var _loc2_:BigInteger = param1.mod(p).modPow(dmp1,p);
|
||||
var _loc3_:BigInteger = param1.mod(q).modPow(dmq1,q);
|
||||
while(_loc2_.compareTo(_loc3_) < 0)
|
||||
{
|
||||
_loc2_ = _loc2_.add(p);
|
||||
}
|
||||
return _loc2_.subtract(_loc3_).multiply(coeff).mod(p).multiply(q).add(_loc3_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,339 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import com.hurlant.crypto.prng.Random;
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class AESKey implements ISymmetricKey
|
||||
{
|
||||
|
||||
private static const Nb:uint = 4;
|
||||
|
||||
private static const _Sbox:Array = [99,124,119,123,242,107,111,197,48,1,103,43,254,215,171,118,202,130,201,125,250,89,71,240,173,212,162,175,156,164,114,192,183,253,147,38,54,63,247,204,52,165,229,241,113,216,49,21,4,199,35,195,24,150,5,154,7,18,128,226,235,39,178,117,9,131,44,26,27,110,90,160,82,59,214,179,41,227,47,132,83,209,0,237,32,252,177,91,106,203,190,57,74,76,88,207,208,239,170,251,67,77,51,133,69,249,2,127,80,60,159,168,81,163,64,143,146,157,56,245,188,182,218,33,16,255,243,210,205,12,19,236,95,151,68,23,196,167,126,61,100,93,25,115,96,129,79,220,34,42,144,136,70,238,184,20,222,94,11,219,224,50,58,10,73,6,36,92,194,211,172,98,145,149,228,121,231,200,55,109,141,213,78,169,108,86,244,234,101,122,174,8,186,120,37,46,28,166,180,198,232,221,116,31,75,189,139,138,112,62,181,102,72,3,246,14,97,53,87,185,134,193,29,158,225,248,152,17,105,217,142,148,155,30,135,233,206,85,40,223,140,161,137,13,191,230,66,104,65,153,45,15,176,84,187,22];
|
||||
|
||||
private static const _InvSbox:Array = [82,9,106,213,48,54,165,56,191,64,163,158,129,243,215,251,124,227,57,130,155,47,255,135,52,142,67,68,196,222,233,203,84,123,148,50,166,194,35,61,238,76,149,11,66,250,195,78,8,46,161,102,40,217,36,178,118,91,162,73,109,139,209,37,114,248,246,100,134,104,152,22,212,164,92,204,93,101,182,146,108,112,72,80,253,237,185,218,94,21,70,87,167,141,157,132,144,216,171,0,140,188,211,10,247,228,88,5,184,179,69,6,208,44,30,143,202,63,15,2,193,175,189,3,1,19,138,107,58,145,17,65,79,103,220,234,151,242,207,206,240,180,230,115,150,172,116,34,231,173,53,133,226,249,55,232,28,117,223,110,71,241,26,113,29,41,197,137,111,183,98,14,170,24,190,27,252,86,62,75,198,210,121,32,154,219,192,254,120,205,90,244,31,221,168,51,136,7,199,49,177,18,16,89,39,128,236,95,96,81,127,169,25,181,74,13,45,229,122,159,147,201,156,239,160,224,59,77,174,42,245,176,200,235,187,60,131,83,153,97,23,43,4,126,186,119,214,38,225,105,20,99,85,33,12,125];
|
||||
|
||||
private static const _Xtime2Sbox:Array = [198,248,238,246,255,214,222,145,96,2,206,86,231,181,77,236,143,31,137,250,239,178,142,251,65,179,95,69,35,83,228,155,117,225,61,76,108,126,245,131,104,81,209,249,226,171,98,42,8,149,70,157,48,55,10,47,14,36,27,223,205,78,127,234,18,29,88,52,54,220,180,91,164,118,183,125,82,221,94,19,166,185,0,193,64,227,121,182,212,141,103,114,148,152,176,133,187,197,79,237,134,154,102,17,138,233,4,254,160,120,37,75,162,93,128,5,63,33,112,241,99,119,175,66,32,229,253,191,129,24,38,195,190,53,136,46,147,85,252,122,200,186,50,230,192,25,158,163,68,84,59,11,140,199,107,40,167,188,22,173,219,100,116,20,146,12,72,184,159,189,67,196,57,49,211,242,213,139,110,218,1,177,156,73,216,172,243,207,202,244,71,16,111,240,74,92,56,87,115,151,203,161,232,62,150,97,13,15,224,124,113,204,144,6,247,28,194,106,174,105,23,153,58,39,217,235,43,34,210,169,7,51,45,60,21,201,135,170,80,165,3,89,9,26,101,215,132,208,130,41,90,30,123,168,109,44];
|
||||
|
||||
private static const _Xtime3Sbox:Array = [165,132,153,141,13,189,177,84,80,3,169,125,25,98,230,154,69,157,64,135,21,235,201,11,236,103,253,234,191,247,150,91,194,28,174,106,90,65,2,79,92,244,52,8,147,115,83,63,12,82,101,94,40,161,15,181,9,54,155,61,38,105,205,159,27,158,116,46,45,178,238,251,246,77,97,206,123,62,113,151,245,104,0,44,96,31,200,237,190,70,217,75,222,212,232,74,107,42,229,22,197,215,85,148,207,16,6,129,240,68,186,227,243,254,192,138,173,188,72,4,223,193,117,99,48,26,14,109,76,20,53,47,225,162,204,57,87,242,130,71,172,231,43,149,160,152,209,127,102,126,171,131,202,41,211,60,121,226,29,118,59,86,78,30,219,10,108,228,93,110,239,166,168,164,55,139,50,67,89,183,140,100,210,224,180,250,7,37,175,142,233,24,213,136,111,114,36,241,199,81,35,124,156,33,221,220,134,133,144,66,196,170,216,5,1,18,163,95,249,208,145,88,39,185,56,19,179,51,187,112,137,167,182,34,146,32,73,255,120,122,143,248,128,23,218,49,198,184,195,176,119,17,203,252,214,58];
|
||||
|
||||
private static const _Xtime2:Array = [0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,230,232,234,236,238,240,242,244,246,248,250,252,254,27,25,31,29,19,17,23,21,11,9,15,13,3,1,7,5,59,57,63,61,51,49,55,53,43,41,47,45,35,33,39,37,91,89,95,93,83,81,87,85,75,73,79,77,67,65,71,69,123,121,127,125,115,113,119,117,107,105,111,109,99,97,103,101,155,153,159,157,147,145,151,149,139,137,143,141,131,129,135,133,187,185,191,189,179,177,183,181,171,169,175,173,163,161,167,165,219,217,223,221,211,209,215,213,203,201,207,205,195,193,199,197,251,249,255,253,243,241,247,245,235,233,239,237,227,225,231,229];
|
||||
|
||||
private static const _Xtime9:Array = [0,9,18,27,36,45,54,63,72,65,90,83,108,101,126,119,144,153,130,139,180,189,166,175,216,209,202,195,252,245,238,231,59,50,41,32,31,22,13,4,115,122,97,104,87,94,69,76,171,162,185,176,143,134,157,148,227,234,241,248,199,206,213,220,118,127,100,109,82,91,64,73,62,55,44,37,26,19,8,1,230,239,244,253,194,203,208,217,174,167,188,181,138,131,152,145,77,68,95,86,105,96,123,114,5,12,23,30,33,40,51,58,221,212,207,198,249,240,235,226,149,156,135,142,177,184,163,170,236,229,254,247,200,193,218,211,164,173,182,191,128,137,146,155,124,117,110,103,88,81,74,67,52,61,38,47,16,25,2,11,215,222,197,204,243,250,225,232,159,150,141,132,187,178,169,160,71,78,85,92,99,106,113,120,15,6,29,20,43,34,57,48,154,147,136,129,190,183,172,165,210,219,192,201,246,255,228,237,10,3,24,17,46,39,60,53,66,75,80,89,102,111,116,125,161,168,179,186,133,140,151,158,233,224,251,242,205,196,223,214,49,56,35,42,21,28,7,14,121,112,107,98,93,84,79,70];
|
||||
|
||||
private static const _XtimeB:Array = [0,11,22,29,44,39,58,49,88,83,78,69,116,127,98,105,176,187,166,173,156,151,138,129,232,227,254,245,196,207,210,217,123,112,109,102,87,92,65,74,35,40,53,62,15,4,25,18,203,192,221,214,231,236,241,250,147,152,133,142,191,180,169,162,246,253,224,235,218,209,204,199,174,165,184,179,130,137,148,159,70,77,80,91,106,97,124,119,30,21,8,3,50,57,36,47,141,134,155,144,161,170,183,188,213,222,195,200,249,242,239,228,61,54,43,32,17,26,7,12,101,110,115,120,73,66,95,84,247,252,225,234,219,208,205,198,175,164,185,178,131,136,149,158,71,76,81,90,107,96,125,118,31,20,9,2,51,56,37,46,140,135,154,145,160,171,182,189,212,223,194,201,248,243,238,229,60,55,42,33,16,27,6,13,100,111,114,121,72,67,94,85,1,10,23,28,45,38,59,48,89,82,79,68,117,126,99,104,177,186,167,172,157,150,139,128,233,226,255,244,197,206,211,216,122,113,108,103,86,93,64,75,34,41,52,63,14,5,24,19,202,193,220,215,230,237,240,251,146,153,132,143,190,181,168,163];
|
||||
|
||||
private static const _XtimeD:Array = [0,13,26,23,52,57,46,35,104,101,114,127,92,81,70,75,208,221,202,199,228,233,254,243,184,181,162,175,140,129,150,155,187,182,161,172,143,130,149,152,211,222,201,196,231,234,253,240,107,102,113,124,95,82,69,72,3,14,25,20,55,58,45,32,109,96,119,122,89,84,67,78,5,8,31,18,49,60,43,38,189,176,167,170,137,132,147,158,213,216,207,194,225,236,251,246,214,219,204,193,226,239,248,245,190,179,164,169,138,135,144,157,6,11,28,17,50,63,40,37,110,99,116,121,90,87,64,77,218,215,192,205,238,227,244,249,178,191,168,165,134,139,156,145,10,7,16,29,62,51,36,41,98,111,120,117,86,91,76,65,97,108,123,118,85,88,79,66,9,4,19,30,61,48,39,42,177,188,171,166,133,136,159,146,217,212,195,206,237,224,247,250,183,186,173,160,131,142,153,148,223,210,197,200,235,230,241,252,103,106,125,112,83,94,73,68,15,2,21,24,59,54,33,44,12,1,22,27,56,53,34,47,100,105,126,115,80,93,74,71,220,209,198,203,232,229,242,255,180,185,174,163,128,141,154,151];
|
||||
|
||||
private static const _XtimeE:Array = [0,14,28,18,56,54,36,42,112,126,108,98,72,70,84,90,224,238,252,242,216,214,196,202,144,158,140,130,168,166,180,186,219,213,199,201,227,237,255,241,171,165,183,185,147,157,143,129,59,53,39,41,3,13,31,17,75,69,87,89,115,125,111,97,173,163,177,191,149,155,137,135,221,211,193,207,229,235,249,247,77,67,81,95,117,123,105,103,61,51,33,47,5,11,25,23,118,120,106,100,78,64,82,92,6,8,26,20,62,48,34,44,150,152,138,132,174,160,178,188,230,232,250,244,222,208,194,204,65,79,93,83,121,119,101,107,49,63,45,35,9,7,21,27,161,175,189,179,153,151,133,139,209,223,205,195,233,231,245,251,154,148,134,136,162,172,190,176,234,228,246,248,210,220,206,192,122,116,102,104,66,76,94,80,10,4,22,24,50,60,46,32,236,226,240,254,212,218,200,198,156,146,128,142,164,170,184,182,12,2,16,30,52,58,40,38,124,114,96,110,68,74,88,86,55,57,43,37,15,1,19,29,71,73,91,85,127,113,99,109,215,217,203,197,239,225,243,253,167,169,187,181,159,145,131,141];
|
||||
|
||||
private static var _Rcon:Array = [0,1,2,4,8,16,32,64,128,27,54];
|
||||
|
||||
private static var Sbox:ByteArray = new ByteArray();
|
||||
|
||||
private static var InvSbox:ByteArray = new ByteArray();
|
||||
|
||||
private static var Xtime2Sbox:ByteArray = new ByteArray();
|
||||
|
||||
private static var Xtime3Sbox:ByteArray = new ByteArray();
|
||||
|
||||
private static var Xtime2:ByteArray = new ByteArray();
|
||||
|
||||
private static var Xtime9:ByteArray = new ByteArray();
|
||||
|
||||
private static var XtimeB:ByteArray = new ByteArray();
|
||||
|
||||
private static var XtimeD:ByteArray = new ByteArray();
|
||||
|
||||
private static var XtimeE:ByteArray = new ByteArray();
|
||||
|
||||
private static var i:uint = 0;
|
||||
|
||||
while(i < 256)
|
||||
{
|
||||
Sbox[i] = _Sbox[i];
|
||||
InvSbox[i] = _InvSbox[i];
|
||||
Xtime2Sbox[i] = _Xtime2Sbox[i];
|
||||
Xtime3Sbox[i] = _Xtime3Sbox[i];
|
||||
Xtime2[i] = _Xtime2[i];
|
||||
Xtime9[i] = _Xtime9[i];
|
||||
XtimeB[i] = _XtimeB[i];
|
||||
XtimeD[i] = _XtimeD[i];
|
||||
XtimeE[i] = _XtimeE[i];
|
||||
i = i + 1;
|
||||
}
|
||||
|
||||
private static var Rcon:ByteArray = new ByteArray();
|
||||
|
||||
i = 0;
|
||||
while(i < _Rcon.length)
|
||||
{
|
||||
Rcon[i] = _Rcon[i];
|
||||
i = i + 1;
|
||||
}
|
||||
|
||||
private var key:ByteArray;
|
||||
|
||||
private var keyLength:uint;
|
||||
|
||||
private var Nr:uint;
|
||||
|
||||
private var state:ByteArray;
|
||||
|
||||
private var tmp:ByteArray;
|
||||
|
||||
public function AESKey(param1:ByteArray)
|
||||
{
|
||||
super();
|
||||
tmp = new ByteArray();
|
||||
state = new ByteArray();
|
||||
keyLength = param1.length;
|
||||
this.key = new ByteArray();
|
||||
this.key.writeBytes(param1);
|
||||
expandKey();
|
||||
}
|
||||
|
||||
private function expandKey() : void
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc1_:* = 0;
|
||||
var _loc2_:* = 0;
|
||||
var _loc7_:* = 0;
|
||||
var _loc4_:* = 0;
|
||||
var _loc6_:uint = key.length / 4;
|
||||
Nr = _loc6_ + 6;
|
||||
_loc4_ = _loc6_;
|
||||
while(_loc4_ < 4 * (Nr + 1))
|
||||
{
|
||||
_loc7_ = uint(key[4 * _loc4_ - 4]);
|
||||
_loc3_ = uint(key[4 * _loc4_ - 3]);
|
||||
_loc5_ = uint(key[4 * _loc4_ - 2]);
|
||||
_loc1_ = uint(key[4 * _loc4_ - 1]);
|
||||
if(!(_loc4_ % _loc6_))
|
||||
{
|
||||
_loc2_ = _loc1_;
|
||||
_loc1_ = uint(Sbox[_loc7_]);
|
||||
_loc7_ = uint(Sbox[_loc3_] ^ Rcon[_loc4_ / _loc6_]);
|
||||
_loc3_ = uint(Sbox[_loc5_]);
|
||||
_loc5_ = uint(Sbox[_loc2_]);
|
||||
}
|
||||
else if(_loc6_ > 6 && _loc4_ % _loc6_ == 4)
|
||||
{
|
||||
_loc7_ = uint(Sbox[_loc7_]);
|
||||
_loc3_ = uint(Sbox[_loc3_]);
|
||||
_loc5_ = uint(Sbox[_loc5_]);
|
||||
_loc1_ = uint(Sbox[_loc1_]);
|
||||
}
|
||||
key[4 * _loc4_ + 0] = key[4 * _loc4_ - 4 * _loc6_ + 0] ^ _loc7_;
|
||||
key[4 * _loc4_ + 1] = key[4 * _loc4_ - 4 * _loc6_ + 1] ^ _loc3_;
|
||||
key[4 * _loc4_ + 2] = key[4 * _loc4_ - 4 * _loc6_ + 2] ^ _loc5_;
|
||||
key[4 * _loc4_ + 3] = key[4 * _loc4_ - 4 * _loc6_ + 3] ^ _loc1_;
|
||||
_loc4_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function getBlockSize() : uint
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
state.position = 0;
|
||||
state.writeBytes(param1,param2,4 * 4);
|
||||
addRoundKey(key,0);
|
||||
_loc3_ = 1;
|
||||
while(_loc3_ < Nr + 1)
|
||||
{
|
||||
if(_loc3_ < Nr)
|
||||
{
|
||||
mixSubColumns();
|
||||
}
|
||||
else
|
||||
{
|
||||
shiftRows();
|
||||
}
|
||||
addRoundKey(key,_loc3_ * 4 * 4);
|
||||
_loc3_++;
|
||||
}
|
||||
param1.position = param2;
|
||||
param1.writeBytes(state);
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
state.position = 0;
|
||||
state.writeBytes(param1,param2,4 * 4);
|
||||
addRoundKey(key,Nr * 4 * 4);
|
||||
invShiftRows();
|
||||
_loc3_ = Nr;
|
||||
while(_loc3_--)
|
||||
{
|
||||
addRoundKey(key,_loc3_ * 4 * 4);
|
||||
if(_loc3_)
|
||||
{
|
||||
invMixSubColumns();
|
||||
}
|
||||
}
|
||||
param1.position = param2;
|
||||
param1.writeBytes(state);
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
var _loc2_:* = 0;
|
||||
var _loc1_:Random = new Random();
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < key.length)
|
||||
{
|
||||
key[_loc2_] = _loc1_.nextByte();
|
||||
_loc2_++;
|
||||
}
|
||||
Nr = _loc1_.nextByte();
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < state.length)
|
||||
{
|
||||
state[_loc2_] = _loc1_.nextByte();
|
||||
_loc2_++;
|
||||
}
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < tmp.length)
|
||||
{
|
||||
tmp[_loc2_] = _loc1_.nextByte();
|
||||
_loc2_++;
|
||||
}
|
||||
key.length = 0;
|
||||
keyLength = 0;
|
||||
state.length = 0;
|
||||
tmp.length = 0;
|
||||
key = null;
|
||||
state = null;
|
||||
tmp = null;
|
||||
Nr = 0;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
protected function shiftRows() : void
|
||||
{
|
||||
var _loc1_:* = 0;
|
||||
state[0] = Sbox[state[0]];
|
||||
state[4] = Sbox[state[4]];
|
||||
state[8] = Sbox[state[8]];
|
||||
state[12] = Sbox[state[12]];
|
||||
_loc1_ = uint(Sbox[state[1]]);
|
||||
state[1] = Sbox[state[5]];
|
||||
state[5] = Sbox[state[9]];
|
||||
state[9] = Sbox[state[13]];
|
||||
state[13] = _loc1_;
|
||||
_loc1_ = uint(Sbox[state[2]]);
|
||||
state[2] = Sbox[state[10]];
|
||||
state[10] = _loc1_;
|
||||
_loc1_ = uint(Sbox[state[6]]);
|
||||
state[6] = Sbox[state[14]];
|
||||
state[14] = _loc1_;
|
||||
_loc1_ = uint(Sbox[state[15]]);
|
||||
state[15] = Sbox[state[11]];
|
||||
state[11] = Sbox[state[7]];
|
||||
state[7] = Sbox[state[3]];
|
||||
state[3] = _loc1_;
|
||||
}
|
||||
|
||||
protected function invShiftRows() : void
|
||||
{
|
||||
var _loc1_:* = 0;
|
||||
state[0] = InvSbox[state[0]];
|
||||
state[4] = InvSbox[state[4]];
|
||||
state[8] = InvSbox[state[8]];
|
||||
state[12] = InvSbox[state[12]];
|
||||
_loc1_ = uint(InvSbox[state[13]]);
|
||||
state[13] = InvSbox[state[9]];
|
||||
state[9] = InvSbox[state[5]];
|
||||
state[5] = InvSbox[state[1]];
|
||||
state[1] = _loc1_;
|
||||
_loc1_ = uint(InvSbox[state[2]]);
|
||||
state[2] = InvSbox[state[10]];
|
||||
state[10] = _loc1_;
|
||||
_loc1_ = uint(InvSbox[state[6]]);
|
||||
state[6] = InvSbox[state[14]];
|
||||
state[14] = _loc1_;
|
||||
_loc1_ = uint(InvSbox[state[3]]);
|
||||
state[3] = InvSbox[state[7]];
|
||||
state[7] = InvSbox[state[11]];
|
||||
state[11] = InvSbox[state[15]];
|
||||
state[15] = _loc1_;
|
||||
}
|
||||
|
||||
protected function mixSubColumns() : void
|
||||
{
|
||||
tmp.length = 0;
|
||||
tmp[0] = Xtime2Sbox[state[0]] ^ Xtime3Sbox[state[5]] ^ Sbox[state[10]] ^ Sbox[state[15]];
|
||||
tmp[1] = Sbox[state[0]] ^ Xtime2Sbox[state[5]] ^ Xtime3Sbox[state[10]] ^ Sbox[state[15]];
|
||||
tmp[2] = Sbox[state[0]] ^ Sbox[state[5]] ^ Xtime2Sbox[state[10]] ^ Xtime3Sbox[state[15]];
|
||||
tmp[3] = Xtime3Sbox[state[0]] ^ Sbox[state[5]] ^ Sbox[state[10]] ^ Xtime2Sbox[state[15]];
|
||||
tmp[4] = Xtime2Sbox[state[4]] ^ Xtime3Sbox[state[9]] ^ Sbox[state[14]] ^ Sbox[state[3]];
|
||||
tmp[5] = Sbox[state[4]] ^ Xtime2Sbox[state[9]] ^ Xtime3Sbox[state[14]] ^ Sbox[state[3]];
|
||||
tmp[6] = Sbox[state[4]] ^ Sbox[state[9]] ^ Xtime2Sbox[state[14]] ^ Xtime3Sbox[state[3]];
|
||||
tmp[7] = Xtime3Sbox[state[4]] ^ Sbox[state[9]] ^ Sbox[state[14]] ^ Xtime2Sbox[state[3]];
|
||||
tmp[8] = Xtime2Sbox[state[8]] ^ Xtime3Sbox[state[13]] ^ Sbox[state[2]] ^ Sbox[state[7]];
|
||||
tmp[9] = Sbox[state[8]] ^ Xtime2Sbox[state[13]] ^ Xtime3Sbox[state[2]] ^ Sbox[state[7]];
|
||||
tmp[10] = Sbox[state[8]] ^ Sbox[state[13]] ^ Xtime2Sbox[state[2]] ^ Xtime3Sbox[state[7]];
|
||||
tmp[11] = Xtime3Sbox[state[8]] ^ Sbox[state[13]] ^ Sbox[state[2]] ^ Xtime2Sbox[state[7]];
|
||||
tmp[12] = Xtime2Sbox[state[12]] ^ Xtime3Sbox[state[1]] ^ Sbox[state[6]] ^ Sbox[state[11]];
|
||||
tmp[13] = Sbox[state[12]] ^ Xtime2Sbox[state[1]] ^ Xtime3Sbox[state[6]] ^ Sbox[state[11]];
|
||||
tmp[14] = Sbox[state[12]] ^ Sbox[state[1]] ^ Xtime2Sbox[state[6]] ^ Xtime3Sbox[state[11]];
|
||||
tmp[15] = Xtime3Sbox[state[12]] ^ Sbox[state[1]] ^ Sbox[state[6]] ^ Xtime2Sbox[state[11]];
|
||||
state.position = 0;
|
||||
state.writeBytes(tmp,0,4 * 4);
|
||||
}
|
||||
|
||||
protected function invMixSubColumns() : void
|
||||
{
|
||||
var _loc1_:* = 0;
|
||||
tmp.length = 0;
|
||||
tmp[0] = XtimeE[state[0]] ^ XtimeB[state[1]] ^ XtimeD[state[2]] ^ Xtime9[state[3]];
|
||||
tmp[5] = Xtime9[state[0]] ^ XtimeE[state[1]] ^ XtimeB[state[2]] ^ XtimeD[state[3]];
|
||||
tmp[10] = XtimeD[state[0]] ^ Xtime9[state[1]] ^ XtimeE[state[2]] ^ XtimeB[state[3]];
|
||||
tmp[15] = XtimeB[state[0]] ^ XtimeD[state[1]] ^ Xtime9[state[2]] ^ XtimeE[state[3]];
|
||||
tmp[4] = XtimeE[state[4]] ^ XtimeB[state[5]] ^ XtimeD[state[6]] ^ Xtime9[state[7]];
|
||||
tmp[9] = Xtime9[state[4]] ^ XtimeE[state[5]] ^ XtimeB[state[6]] ^ XtimeD[state[7]];
|
||||
tmp[14] = XtimeD[state[4]] ^ Xtime9[state[5]] ^ XtimeE[state[6]] ^ XtimeB[state[7]];
|
||||
tmp[3] = XtimeB[state[4]] ^ XtimeD[state[5]] ^ Xtime9[state[6]] ^ XtimeE[state[7]];
|
||||
tmp[8] = XtimeE[state[8]] ^ XtimeB[state[9]] ^ XtimeD[state[10]] ^ Xtime9[state[11]];
|
||||
tmp[13] = Xtime9[state[8]] ^ XtimeE[state[9]] ^ XtimeB[state[10]] ^ XtimeD[state[11]];
|
||||
tmp[2] = XtimeD[state[8]] ^ Xtime9[state[9]] ^ XtimeE[state[10]] ^ XtimeB[state[11]];
|
||||
tmp[7] = XtimeB[state[8]] ^ XtimeD[state[9]] ^ Xtime9[state[10]] ^ XtimeE[state[11]];
|
||||
tmp[12] = XtimeE[state[12]] ^ XtimeB[state[13]] ^ XtimeD[state[14]] ^ Xtime9[state[15]];
|
||||
tmp[1] = Xtime9[state[12]] ^ XtimeE[state[13]] ^ XtimeB[state[14]] ^ XtimeD[state[15]];
|
||||
tmp[6] = XtimeD[state[12]] ^ Xtime9[state[13]] ^ XtimeE[state[14]] ^ XtimeB[state[15]];
|
||||
tmp[11] = XtimeB[state[12]] ^ XtimeD[state[13]] ^ Xtime9[state[14]] ^ XtimeE[state[15]];
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 4 * 4)
|
||||
{
|
||||
state[_loc1_] = InvSbox[tmp[_loc1_]];
|
||||
_loc1_++;
|
||||
}
|
||||
}
|
||||
|
||||
protected function addRoundKey(param1:ByteArray, param2:uint) : void
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < 16)
|
||||
{
|
||||
var _loc4_:uint = _loc3_;
|
||||
var _loc5_:int = state[_loc4_] ^ param1[_loc3_ + param2];
|
||||
state[_loc4_] = _loc5_;
|
||||
_loc3_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "aes" + 8 * keyLength;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,241 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class BlowFishKey implements ISymmetricKey
|
||||
{
|
||||
|
||||
private static const ROUNDS:uint = 16;
|
||||
|
||||
private static const BLOCK_SIZE:uint = 8;
|
||||
|
||||
private static const SBOX_SK:uint = 256;
|
||||
|
||||
private static const P_SZ:uint = 18;
|
||||
|
||||
private static const KP:Array = [608135816,2242054355,320440878,57701188,2752067618,698298832,137296536,3964562569,1160258022,953160567,3193202383,887688300,3232508343,3380367581,1065670069,3041331479,2450970073,2306472731];
|
||||
|
||||
private static const KS0:Array = [3509652390,2564797868,805139163,3491422135,3101798381,1780907670,3128725573,4046225305,614570311,3012652279,134345442,2240740374,1667834072,1901547113,2757295779,4103290238,227898511,1921955416,1904987480,2182433518,2069144605,3260701109,2620446009,720527379,3318853667,677414384,3393288472,3101374703,2390351024,1614419982,1822297739,2954791486,3608508353,3174124327,2024746970,1432378464,3864339955,2857741204,1464375394,1676153920,1439316330,715854006,3033291828,289532110,2706671279,2087905683,3018724369,1668267050,732546397,1947742710,3462151702,2609353502,2950085171,1814351708,2050118529,680887927,999245976,1800124847,3300911131,1713906067,1641548236,4213287313,1216130144,1575780402,4018429277,3917837745,3693486850,3949271944,596196993,3549867205,258830323,2213823033,772490370,2760122372,1774776394,2652871518,566650946,4142492826,1728879713,2882767088,1783734482,3629395816,2517608232,2874225571,1861159788,326777828,3124490320,2130389656,2716951837,967770486
|
||||
,1724537150,2185432712,2364442137,1164943284,2105845187,998989502,3765401048,2244026483,1075463327,1455516326,1322494562,910128902,469688178,1117454909,936433444,3490320968,3675253459,1240580251,122909385,2157517691,634681816,4142456567,3825094682,3061402683,2540495037,79693498,3249098678,1084186820,1583128258,426386531,1761308591,1047286709,322548459,995290223,1845252383,2603652396,3431023940,2942221577,3202600964,3727903485,1712269319,422464435,3234572375,1170764815,3523960633,3117677531,1434042557,442511882,3600875718,1076654713,1738483198,4213154764,2393238008,3677496056,1014306527,4251020053,793779912,2902807211,842905082,4246964064,1395751752,1040244610,2656851899,3396308128,445077038,3742853595,3577915638,679411651,2892444358,2354009459,1767581616,3150600392,3791627101,3102740896,284835224,4246832056,1258075500,768725851,2589189241,3069724005,3532540348,1274779536,3789419226,2764799539,1660621633,3471099624,4011903706,913787905,3497959166,737222580,2514213453,2928710040,3937242737
|
||||
,1804850592,3499020752,2949064160,2386320175,2390070455,2415321851,4061277028,2290661394,2416832540,1336762016,1754252060,3520065937,3014181293,791618072,3188594551,3933548030,2332172193,3852520463,3043980520,413987798,3465142937,3030929376,4245938359,2093235073,3534596313,375366246,2157278981,2479649556,555357303,3870105701,2008414854,3344188149,4221384143,3956125452,2067696032,3594591187,2921233993,2428461,544322398,577241275,1471733935,610547355,4027169054,1432588573,1507829418,2025931657,3646575487,545086370,48609733,2200306550,1653985193,298326376,1316178497,3007786442,2064951626,458293330,2589141269,3591329599,3164325604,727753846,2179363840,146436021,1461446943,4069977195,705550613,3059967265,3887724982,4281599278,3313849956,1404054877,2845806497,146425753,1854211946];
|
||||
|
||||
private static const KS1:Array = [1266315497,3048417604,3681880366,3289982499,2909710000,1235738493,2632868024,2414719590,3970600049,1771706367,1449415276,3266420449,422970021,1963543593,2690192192,3826793022,1062508698,1531092325,1804592342,2583117782,2714934279,4024971509,1294809318,4028980673,1289560198,2221992742,1669523910,35572830,157838143,1052438473,1016535060,1802137761,1753167236,1386275462,3080475397,2857371447,1040679964,2145300060,2390574316,1461121720,2956646967,4031777805,4028374788,33600511,2920084762,1018524850,629373528,3691585981,3515945977,2091462646,2486323059,586499841,988145025,935516892,3367335476,2599673255,2839830854,265290510,3972581182,2759138881,3795373465,1005194799,847297441,406762289,1314163512,1332590856,1866599683,4127851711,750260880,613907577,1450815602,3165620655,3734664991,3650291728,3012275730,3704569646,1427272223,778793252,1343938022,2676280711,2052605720,1946737175,3164576444,3914038668,3967478842,3682934266,1661551462,3294938066,4011595847,840292616
|
||||
,3712170807,616741398,312560963,711312465,1351876610,322626781,1910503582,271666773,2175563734,1594956187,70604529,3617834859,1007753275,1495573769,4069517037,2549218298,2663038764,504708206,2263041392,3941167025,2249088522,1514023603,1998579484,1312622330,694541497,2582060303,2151582166,1382467621,776784248,2618340202,3323268794,2497899128,2784771155,503983604,4076293799,907881277,423175695,432175456,1378068232,4145222326,3954048622,3938656102,3820766613,2793130115,2977904593,26017576,3274890735,3194772133,1700274565,1756076034,4006520079,3677328699,720338349,1533947780,354530856,688349552,3973924725,1637815568,332179504,3949051286,53804574,2852348879,3044236432,1282449977,3583942155,3416972820,4006381244,1617046695,2628476075,3002303598,1686838959,431878346,2686675385,1700445008,1080580658,1009431731,832498133,3223435511,2605976345,2271191193,2516031870,1648197032,4164389018,2548247927,300782431,375919233,238389289,3353747414,2531188641,2019080857,1475708069,455242339,2609103871,448939670
|
||||
,3451063019,1395535956,2413381860,1841049896,1491858159,885456874,4264095073,4001119347,1565136089,3898914787,1108368660,540939232,1173283510,2745871338,3681308437,4207628240,3343053890,4016749493,1699691293,1103962373,3625875870,2256883143,3830138730,1031889488,3479347698,1535977030,4236805024,3251091107,2132092099,1774941330,1199868427,1452454533,157007616,2904115357,342012276,595725824,1480756522,206960106,497939518,591360097,863170706,2375253569,3596610801,1814182875,2094937945,3421402208,1082520231,3463918190,2785509508,435703966,3908032597,1641649973,2842273706,3305899714,1510255612,2148256476,2655287854,3276092548,4258621189,236887753,3681803219,274041037,1734335097,3815195456,3317970021,1899903192,1026095262,4050517792,356393447,2410691914,3873677099,3682840055];
|
||||
|
||||
private static const KS2:Array = [3913112168,2491498743,4132185628,2489919796,1091903735,1979897079,3170134830,3567386728,3557303409,857797738,1136121015,1342202287,507115054,2535736646,337727348,3213592640,1301675037,2528481711,1895095763,1721773893,3216771564,62756741,2142006736,835421444,2531993523,1442658625,3659876326,2882144922,676362277,1392781812,170690266,3921047035,1759253602,3611846912,1745797284,664899054,1329594018,3901205900,3045908486,2062866102,2865634940,3543621612,3464012697,1080764994,553557557,3656615353,3996768171,991055499,499776247,1265440854,648242737,3940784050,980351604,3713745714,1749149687,3396870395,4211799374,3640570775,1161844396,3125318951,1431517754,545492359,4268468663,3499529547,1437099964,2702547544,3433638243,2581715763,2787789398,1060185593,1593081372,2418618748,4260947970,69676912,2159744348,86519011,2512459080,3838209314,1220612927,3339683548,133810670,1090789135,1078426020,1569222167,845107691,3583754449,4072456591,1091646820,628848692,1613405280
|
||||
,3757631651,526609435,236106946,48312990,2942717905,3402727701,1797494240,859738849,992217954,4005476642,2243076622,3870952857,3732016268,765654824,3490871365,2511836413,1685915746,3888969200,1414112111,2273134842,3281911079,4080962846,172450625,2569994100,980381355,4109958455,2819808352,2716589560,2568741196,3681446669,3329971472,1835478071,660984891,3704678404,4045999559,3422617507,3040415634,1762651403,1719377915,3470491036,2693910283,3642056355,3138596744,1364962596,2073328063,1983633131,926494387,3423689081,2150032023,4096667949,1749200295,3328846651,309677260,2016342300,1779581495,3079819751,111262694,1274766160,443224088,298511866,1025883608,3806446537,1145181785,168956806,3641502830,3584813610,1689216846,3666258015,3200248200,1692713982,2646376535,4042768518,1618508792,1610833997,3523052358,4130873264,2001055236,3610705100,2202168115,4028541809,2961195399,1006657119,2006996926,3186142756,1430667929,3210227297,1314452623,4074634658,4101304120,2273951170,1399257539,3367210612,3027628629
|
||||
,1190975929,2062231137,2333990788,2221543033,2438960610,1181637006,548689776,2362791313,3372408396,3104550113,3145860560,296247880,1970579870,3078560182,3769228297,1714227617,3291629107,3898220290,166772364,1251581989,493813264,448347421,195405023,2709975567,677966185,3703036547,1463355134,2715995803,1338867538,1343315457,2802222074,2684532164,233230375,2599980071,2000651841,3277868038,1638401717,4028070440,3237316320,6314154,819756386,300326615,590932579,1405279636,3267499572,3150704214,2428286686,3959192993,3461946742,1862657033,1266418056,963775037,2089974820,2263052895,1917689273,448879540,3550394620,3981727096,150775221,3627908307,1303187396,508620638,2975983352,2726630617,1817252668,1876281319,1457606340,908771278,3720792119,3617206836,2455994898,1729034894,1080033504];
|
||||
|
||||
private static const KS3:Array = [976866871,3556439503,2881648439,1522871579,1555064734,1336096578,3548522304,2579274686,3574697629,3205460757,3593280638,3338716283,3079412587,564236357,2993598910,1781952180,1464380207,3163844217,3332601554,1699332808,1393555694,1183702653,3581086237,1288719814,691649499,2847557200,2895455976,3193889540,2717570544,1781354906,1676643554,2592534050,3230253752,1126444790,2770207658,2633158820,2210423226,2615765581,2414155088,3127139286,673620729,2805611233,1269405062,4015350505,3341807571,4149409754,1057255273,2012875353,2162469141,2276492801,2601117357,993977747,3918593370,2654263191,753973209,36408145,2530585658,25011837,3520020182,2088578344,530523599,2918365339,1524020338,1518925132,3760827505,3759777254,1202760957,3985898139,3906192525,674977740,4174734889,2031300136,2019492241,3983892565,4153806404,3822280332,352677332,2297720250,60907813,90501309,3286998549,1016092578,2535922412,2839152426,457141659,509813237,4120667899,652014361,1966332200,2975202805
|
||||
,55981186,2327461051,676427537,3255491064,2882294119,3433927263,1307055953,942726286,933058658,2468411793,3933900994,4215176142,1361170020,2001714738,2830558078,3274259782,1222529897,1679025792,2729314320,3714953764,1770335741,151462246,3013232138,1682292957,1483529935,471910574,1539241949,458788160,3436315007,1807016891,3718408830,978976581,1043663428,3165965781,1927990952,4200891579,2372276910,3208408903,3533431907,1412390302,2931980059,4132332400,1947078029,3881505623,4168226417,2941484381,1077988104,1320477388,886195818,18198404,3786409000,2509781533,112762804,3463356488,1866414978,891333506,18488651,661792760,1628790961,3885187036,3141171499,876946877,2693282273,1372485963,791857591,2686433993,3759982718,3167212022,3472953795,2716379847,445679433,3561995674,3504004811,3574258232,54117162,3331405415,2381918588,3769707343,4154350007,1140177722,4074052095,668550556,3214352940,367459370,261225585,2610173221,4209349473,3468074219,3265815641,314222801,3066103646,3808782860,282218597,3406013506
|
||||
,3773591054,379116347,1285071038,846784868,2669647154,3771962079,3550491691,2305946142,453669953,1268987020,3317592352,3279303384,3744833421,2610507566,3859509063,266596637,3847019092,517658769,3462560207,3443424879,370717030,4247526661,2224018117,4143653529,4112773975,2788324899,2477274417,1456262402,2901442914,1517677493,1846949527,2295493580,3734397586,2176403920,1280348187,1908823572,3871786941,846861322,1172426758,3287448474,3383383037,1655181056,3139813346,901632758,1897031941,2986607138,3066810236,3447102507,1393639104,373351379,950779232,625454576,3124240540,4148612726,2007998917,544563296,2244738638,2330496472,2058025392,1291430526,424198748,50039436,29584100,3605783033,2429876329,2791104160,1057563949,3255363231,3075367218,3463963227,1469046755,985887462];
|
||||
|
||||
private var S0:Array;
|
||||
|
||||
private var S1:Array;
|
||||
|
||||
private var S2:Array;
|
||||
|
||||
private var S3:Array;
|
||||
|
||||
private var P:Array;
|
||||
|
||||
private var key:ByteArray = null;
|
||||
|
||||
public function BlowFishKey(param1:ByteArray)
|
||||
{
|
||||
super();
|
||||
this.key = param1;
|
||||
setKey(param1);
|
||||
}
|
||||
|
||||
public function getBlockSize() : uint
|
||||
{
|
||||
return 8;
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
decryptBlock(param1,param2,param1,param2);
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
var _loc1_:uint = 0;
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < S0.length)
|
||||
{
|
||||
S0[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < S1.length)
|
||||
{
|
||||
S1[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < S2.length)
|
||||
{
|
||||
S2[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < S3.length)
|
||||
{
|
||||
S3[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < P.length)
|
||||
{
|
||||
P[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
S0 = null;
|
||||
S1 = null;
|
||||
S2 = null;
|
||||
S3 = null;
|
||||
P = null;
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < key.length)
|
||||
{
|
||||
key[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
key.length = 0;
|
||||
key = null;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
encryptBlock(param1,param2,param1,param2);
|
||||
}
|
||||
|
||||
private function F(param1:uint) : uint
|
||||
{
|
||||
return (S0[param1 >>> 24] + S1[param1 >>> 16 & 0xFF] ^ S2[param1 >>> 8 & 0xFF]) + S3[param1 & 0xFF];
|
||||
}
|
||||
|
||||
private function processTable(param1:uint, param2:uint, param3:Array) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc5_:uint = param3.length;
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < _loc5_)
|
||||
{
|
||||
param1 ^= P[0];
|
||||
_loc6_ = 1;
|
||||
while(_loc6_ < 16)
|
||||
{
|
||||
param2 ^= F(param1) ^ P[_loc6_];
|
||||
param1 ^= F(param2) ^ P[_loc6_ + 1];
|
||||
_loc6_ += 2;
|
||||
}
|
||||
param2 ^= P[16 + 1];
|
||||
param3[_loc4_] = param2;
|
||||
param3[_loc4_ + 1] = param1;
|
||||
param2 = param1;
|
||||
param1 = uint(param3[_loc4_]);
|
||||
_loc4_ += 2;
|
||||
}
|
||||
}
|
||||
|
||||
private function setKey(param1:ByteArray) : void
|
||||
{
|
||||
var _loc5_:* = 0;
|
||||
var _loc3_:* = 0;
|
||||
var _loc6_:* = 0;
|
||||
S0 = KS0.concat();
|
||||
S1 = KS1.concat();
|
||||
S2 = KS2.concat();
|
||||
S3 = KS3.concat();
|
||||
P = KP.concat();
|
||||
var _loc2_:uint = param1.length;
|
||||
var _loc4_:uint = 0;
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < 18)
|
||||
{
|
||||
_loc3_ = 0;
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < 4)
|
||||
{
|
||||
_loc3_ = uint(_loc3_ << 8 | param1[_loc4_++] & 0xFF);
|
||||
if(_loc4_ >= _loc2_)
|
||||
{
|
||||
_loc4_ = 0;
|
||||
}
|
||||
_loc6_++;
|
||||
}
|
||||
var _loc7_:uint = _loc5_;
|
||||
var _loc8_:int = P[_loc7_] ^ _loc3_;
|
||||
P[_loc7_] = _loc8_;
|
||||
_loc5_++;
|
||||
}
|
||||
processTable(0,0,P);
|
||||
processTable(P[18 - 2],P[18 - 1],S0);
|
||||
processTable(S0[256 - 2],S0[256 - 1],S1);
|
||||
processTable(S1[256 - 2],S1[256 - 1],S2);
|
||||
processTable(S2[256 - 2],S2[256 - 1],S3);
|
||||
}
|
||||
|
||||
private function encryptBlock(param1:ByteArray, param2:uint, param3:ByteArray, param4:uint) : void
|
||||
{
|
||||
var _loc6_:* = 0;
|
||||
var _loc5_:uint = BytesTo32bits(param1,param2);
|
||||
var _loc7_:uint = BytesTo32bits(param1,param2 + 4);
|
||||
_loc5_ ^= P[0];
|
||||
_loc6_ = 1;
|
||||
while(_loc6_ < 16)
|
||||
{
|
||||
_loc7_ ^= F(_loc5_) ^ P[_loc6_];
|
||||
_loc5_ ^= F(_loc7_) ^ P[_loc6_ + 1];
|
||||
_loc6_ += 2;
|
||||
}
|
||||
_loc7_ ^= P[16 + 1];
|
||||
Bits32ToBytes(_loc7_,param3,param4);
|
||||
Bits32ToBytes(_loc5_,param3,param4 + 4);
|
||||
}
|
||||
|
||||
private function decryptBlock(param1:ByteArray, param2:uint, param3:ByteArray, param4:uint) : void
|
||||
{
|
||||
var _loc6_:* = 0;
|
||||
var _loc5_:uint = BytesTo32bits(param1,param2);
|
||||
var _loc7_:uint = BytesTo32bits(param1,param2 + 4);
|
||||
_loc5_ ^= P[16 + 1];
|
||||
_loc6_ = 16;
|
||||
while(_loc6_ > 0)
|
||||
{
|
||||
_loc7_ ^= F(_loc5_) ^ P[_loc6_];
|
||||
_loc5_ ^= F(_loc7_) ^ P[_loc6_ - 1];
|
||||
_loc6_ -= 2;
|
||||
}
|
||||
_loc7_ ^= P[0];
|
||||
Bits32ToBytes(_loc7_,param3,param4);
|
||||
Bits32ToBytes(_loc5_,param3,param4 + 4);
|
||||
}
|
||||
|
||||
private function BytesTo32bits(param1:ByteArray, param2:uint) : uint
|
||||
{
|
||||
return (param1[param2] & 0xFF) << 24 | (param1[param2 + 1] & 0xFF) << 16 | (param1[param2 + 2] & 0xFF) << 8 | param1[param2 + 3] & 0xFF;
|
||||
}
|
||||
|
||||
private function Bits32ToBytes(param1:uint, param2:ByteArray, param3:uint) : void
|
||||
{
|
||||
param2[param3 + 3] = param1;
|
||||
param2[param3 + 2] = param1 >> 8;
|
||||
param2[param3 + 1] = param1 >> 16;
|
||||
param2[param3] = param1 >> 24;
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "blowfish";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class CBCMode extends IVMode implements IMode
|
||||
{
|
||||
|
||||
public function CBCMode(param1:ISymmetricKey, param2:IPad = null)
|
||||
{
|
||||
super(param1,param2);
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc2_:* = 0;
|
||||
var _loc4_:* = 0;
|
||||
padding.pad(param1);
|
||||
var _loc3_:ByteArray = getIV4e();
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < param1.length)
|
||||
{
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < blockSize)
|
||||
{
|
||||
var _loc5_:Number = _loc2_ + _loc4_;
|
||||
var _loc6_:int = param1[_loc5_] ^ _loc3_[_loc4_];
|
||||
param1[_loc5_] = _loc6_;
|
||||
_loc4_++;
|
||||
}
|
||||
key.encrypt(param1,_loc2_);
|
||||
_loc3_.position = 0;
|
||||
_loc3_.writeBytes(param1,_loc2_,blockSize);
|
||||
_loc2_ += blockSize;
|
||||
}
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc4_:ByteArray = getIV4d();
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < param1.length)
|
||||
{
|
||||
_loc2_.position = 0;
|
||||
_loc2_.writeBytes(param1,_loc3_,blockSize);
|
||||
key.decrypt(param1,_loc3_);
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < blockSize)
|
||||
{
|
||||
var _loc6_:Number = _loc3_ + _loc5_;
|
||||
var _loc7_:int = param1[_loc6_] ^ _loc4_[_loc5_];
|
||||
param1[_loc6_] = _loc7_;
|
||||
_loc5_++;
|
||||
}
|
||||
_loc4_.position = 0;
|
||||
_loc4_.writeBytes(_loc2_,0,blockSize);
|
||||
_loc3_ += blockSize;
|
||||
}
|
||||
padding.unpad(param1);
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return key.toString() + "-cbc";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class CFB8Mode extends IVMode implements IMode
|
||||
{
|
||||
|
||||
public function CFB8Mode(param1:ISymmetricKey, param2:IPad = null)
|
||||
{
|
||||
super(param1,null);
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc4_:ByteArray = getIV4e();
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < param1.length)
|
||||
{
|
||||
_loc2_.position = 0;
|
||||
_loc2_.writeBytes(_loc4_);
|
||||
key.encrypt(_loc4_);
|
||||
param1[_loc3_] ^= _loc4_[0];
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < blockSize - 1)
|
||||
{
|
||||
_loc4_[_loc5_] = _loc2_[_loc5_ + 1];
|
||||
_loc5_++;
|
||||
}
|
||||
_loc4_[blockSize - 1] = param1[_loc3_];
|
||||
_loc3_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
var _loc2_:* = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc5_:ByteArray = getIV4d();
|
||||
var _loc3_:ByteArray = new ByteArray();
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < param1.length)
|
||||
{
|
||||
_loc2_ = uint(param1[_loc4_]);
|
||||
_loc3_.position = 0;
|
||||
_loc3_.writeBytes(_loc5_);
|
||||
key.encrypt(_loc5_);
|
||||
param1[_loc4_] ^= _loc5_[0];
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < blockSize - 1)
|
||||
{
|
||||
_loc5_[_loc6_] = _loc3_[_loc6_ + 1];
|
||||
_loc6_++;
|
||||
}
|
||||
_loc5_[blockSize - 1] = _loc2_;
|
||||
_loc4_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return key.toString() + "-cfb8";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class CFBMode extends IVMode implements IMode
|
||||
{
|
||||
|
||||
public function CFBMode(param1:ISymmetricKey, param2:IPad = null)
|
||||
{
|
||||
super(param1,null);
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc2_:* = 0;
|
||||
var _loc3_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc6_:uint = param1.length;
|
||||
var _loc4_:ByteArray = getIV4e();
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < param1.length)
|
||||
{
|
||||
key.encrypt(_loc4_);
|
||||
_loc3_ = uint(_loc2_ + blockSize < _loc6_ ? blockSize : _loc6_ - _loc2_);
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < _loc3_)
|
||||
{
|
||||
var _loc7_:Number = _loc2_ + _loc5_;
|
||||
var _loc8_:int = param1[_loc7_] ^ _loc4_[_loc5_];
|
||||
param1[_loc7_] = _loc8_;
|
||||
_loc5_++;
|
||||
}
|
||||
_loc4_.position = 0;
|
||||
_loc4_.writeBytes(param1,_loc2_,_loc3_);
|
||||
_loc2_ += blockSize;
|
||||
}
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
var _loc4_:* = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc7_:uint = param1.length;
|
||||
var _loc5_:ByteArray = getIV4d();
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < param1.length)
|
||||
{
|
||||
key.encrypt(_loc5_);
|
||||
_loc4_ = uint(_loc3_ + blockSize < _loc7_ ? blockSize : _loc7_ - _loc3_);
|
||||
_loc2_.position = 0;
|
||||
_loc2_.writeBytes(param1,_loc3_,_loc4_);
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < _loc4_)
|
||||
{
|
||||
var _loc8_:Number = _loc3_ + _loc6_;
|
||||
var _loc9_:int = param1[_loc8_] ^ _loc5_[_loc6_];
|
||||
param1[_loc8_] = _loc9_;
|
||||
_loc6_++;
|
||||
}
|
||||
_loc5_.position = 0;
|
||||
_loc5_.writeBytes(_loc2_);
|
||||
_loc3_ += blockSize;
|
||||
}
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return key.toString() + "-cfb";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,68 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class CTRMode extends IVMode implements IMode
|
||||
{
|
||||
|
||||
public function CTRMode(param1:ISymmetricKey, param2:IPad = null)
|
||||
{
|
||||
super(param1,param2);
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray) : void
|
||||
{
|
||||
padding.pad(param1);
|
||||
var _loc2_:ByteArray = getIV4e();
|
||||
core(param1,_loc2_);
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc2_:ByteArray = getIV4d();
|
||||
core(param1,_loc2_);
|
||||
padding.unpad(param1);
|
||||
}
|
||||
|
||||
private function core(param1:ByteArray, param2:ByteArray) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc3_:ByteArray = new ByteArray();
|
||||
var _loc6_:ByteArray = new ByteArray();
|
||||
_loc3_.writeBytes(param2);
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < param1.length)
|
||||
{
|
||||
_loc6_.position = 0;
|
||||
_loc6_.writeBytes(_loc3_);
|
||||
key.encrypt(_loc6_);
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < blockSize)
|
||||
{
|
||||
var _loc7_:Number = _loc4_ + _loc5_;
|
||||
var _loc8_:int = param1[_loc7_] ^ _loc6_[_loc5_];
|
||||
param1[_loc7_] = _loc8_;
|
||||
_loc5_++;
|
||||
}
|
||||
_loc5_ = uint(blockSize - 1);
|
||||
while(_loc5_ >= 0)
|
||||
{
|
||||
_loc3_[_loc5_]++;
|
||||
if(_loc3_[_loc5_] != 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc5_--;
|
||||
}
|
||||
_loc4_ += blockSize;
|
||||
}
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return key.toString() + "-ctr";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,279 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class DESKey implements ISymmetricKey
|
||||
{
|
||||
|
||||
private static const Df_Key:Array = [1,35,69,103,137,171,205,239,254,220,186,152,118,84,50,16,137,171,205,239,1,35,69,103];
|
||||
|
||||
private static const bytebit:Array = [128,64,32,16,8,4,2,1];
|
||||
|
||||
private static const bigbyte:Array = [8388608,4194304,2097152,1048576,524288,262144,131072,65536,32768,16384,8192,4096,2048,1024,512,256,128,64,32,16,8,4,2,1];
|
||||
|
||||
private static const pc1:Array = [56,48,40,32,24,16,8,0,57,49,41,33,25,17,9,1,58,50,42,34,26,18,10,2,59,51,43,35,62,54,46,38,30,22,14,6,61,53,45,37,29,21,13,5,60,52,44,36,28,20,12,4,27,19,11,3];
|
||||
|
||||
private static const totrot:Array = [1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28];
|
||||
|
||||
private static const pc2:Array = [13,16,10,23,0,4,2,27,14,5,20,9,22,18,11,3,25,7,15,6,26,19,12,1,40,51,30,36,46,54,29,39,50,44,32,47,43,48,38,55,33,52,45,41,49,35,28,31];
|
||||
|
||||
private static const SP1:Array = [16843776,0,65536,16843780,16842756,66564,4,65536,1024,16843776,16843780,1024,16778244,16842756,16777216,4,1028,16778240,16778240,66560,66560,16842752,16842752,16778244,65540,16777220,16777220,65540,0,1028,66564,16777216,65536,16843780,4,16842752,16843776,16777216,16777216,1024,16842756,65536,66560,16777220,1024,4,16778244,66564,16843780,65540,16842752,16778244,16777220,1028,66564,16843776,1028,16778240,16778240,0,65540,66560,0,16842756];
|
||||
|
||||
private static const SP2:Array = [2148565024,2147516416,32768,1081376,1048576,32,2148532256,2147516448,2147483680,2148565024,2148564992,2147483648,2147516416,1048576,32,2148532256,1081344,1048608,2147516448,0,2147483648,32768,1081376,2148532224,1048608,2147483680,0,1081344,32800,2148564992,2148532224,32800,0,1081376,2148532256,1048576,2147516448,2148532224,2148564992,32768,2148532224,2147516416,32,2148565024,1081376,32,32768,2147483648,32800,2148564992,1048576,2147483680,1048608,2147516448,2147483680,1048608,1081344,0,2147516416,32800,2147483648,2148532256,2148565024,1081344];
|
||||
|
||||
private static const SP3:Array = [520,134349312,0,134348808,134218240,0,131592,134218240,131080,134217736,134217736,131072,134349320,131080,134348800,520,134217728,8,134349312,512,131584,134348800,134348808,131592,134218248,131584,131072,134218248,8,134349320,512,134217728,134349312,134217728,131080,520,131072,134349312,134218240,0,512,131080,134349320,134218240,134217736,512,0,134348808,134218248,131072,134217728,134349320,8,131592,131584,134217736,134348800,134218248,520,134348800,131592,8,134348808,131584];
|
||||
|
||||
private static const SP4:Array = [8396801,8321,8321,128,8396928,8388737,8388609,8193,0,8396800,8396800,8396929,129,0,8388736,8388609,1,8192,8388608,8396801,128,8388608,8193,8320,8388737,1,8320,8388736,8192,8396928,8396929,129,8388736,8388609,8396800,8396929,129,0,0,8396800,8320,8388736,8388737,1,8396801,8321,8321,128,8396929,129,1,8192,8388609,8193,8396928,8388737,8193,8320,8388608,8396801,128,8388608,8192,8396928];
|
||||
|
||||
private static const SP5:Array = [256,34078976,34078720,1107296512,524288,256,1073741824,34078720,1074266368,524288,33554688,1074266368,1107296512,1107820544,524544,1073741824,33554432,1074266112,1074266112,0,1073742080,1107820800,1107820800,33554688,1107820544,1073742080,0,1107296256,34078976,33554432,1107296256,524544,524288,1107296512,256,33554432,1073741824,34078720,1107296512,1074266368,33554688,1073741824,1107820544,34078976,1074266368,256,33554432,1107820544,1107820800,524544,1107296256,1107820800,34078720,0,1074266112,1107296256,524544,33554688,1073742080,524288,0,1074266112,34078976,1073742080];
|
||||
|
||||
private static const SP6:Array = [536870928,541065216,16384,541081616,541065216,16,541081616,4194304,536887296,4210704,4194304,536870928,4194320,536887296,536870912,16400,0,4194320,536887312,16384,4210688,536887312,16,541065232,541065232,0,4210704,541081600,16400,4210688,541081600,536870912,536887296,16,541065232,4210688,541081616,4194304,16400,536870928,4194304,536887296,536870912,16400,536870928,541081616,4210688,541065216,4210704,541081600,0,541065232,16,16384,541065216,4210704,16384,4194320,536887312,0,541081600,536870912,4194320,536887312];
|
||||
|
||||
private static const SP7:Array = [2097152,69206018,67110914,0,2048,67110914,2099202,69208064,69208066,2097152,0,67108866,2,67108864,69206018,2050,67110912,2099202,2097154,67110912,67108866,69206016,69208064,2097154,69206016,2048,2050,69208066,2099200,2,67108864,2099200,67108864,2099200,2097152,67110914,67110914,69206018,69206018,2,2097154,67108864,67110912,2097152,69208064,2050,2099202,69208064,2050,67108866,69208066,69206016,2099200,0,2,69208066,0,2099202,69206016,2048,67108866,67110912,2048,2097154];
|
||||
|
||||
private static const SP8:Array = [268439616,4096,262144,268701760,268435456,268439616,64,268435456,262208,268697600,268701760,266240,268701696,266304,4096,64,268697600,268435520,268439552,4160,266240,262208,268697664,268701696,4160,0,0,268697664,268435520,268439552,266304,262144,266304,262144,268701696,4096,64,268697664,4096,266304,268439552,64,268435520,268697600,268697664,268435456,262144,268439616,0,268701760,262208,268435520,268697600,268439552,268439616,0,268701760,266240,266240,4160,4160,262208,268435456,268701696];
|
||||
|
||||
protected var key:ByteArray;
|
||||
|
||||
protected var encKey:Array;
|
||||
|
||||
protected var decKey:Array;
|
||||
|
||||
public function DESKey(param1:ByteArray)
|
||||
{
|
||||
super();
|
||||
this.key = param1;
|
||||
this.encKey = generateWorkingKey(true,param1,0);
|
||||
this.decKey = generateWorkingKey(false,param1,0);
|
||||
}
|
||||
|
||||
public function getBlockSize() : uint
|
||||
{
|
||||
return 8;
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
desFunc(decKey,param1,param2,param1,param2);
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
var _loc1_:uint = 0;
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < encKey.length)
|
||||
{
|
||||
encKey[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < decKey.length)
|
||||
{
|
||||
decKey[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
encKey = null;
|
||||
decKey = null;
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < key.length)
|
||||
{
|
||||
key[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
key.length = 0;
|
||||
key = null;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
desFunc(encKey,param1,param2,param1,param2);
|
||||
}
|
||||
|
||||
protected function generateWorkingKey(param1:Boolean, param2:ByteArray, param3:uint) : Array
|
||||
{
|
||||
var _loc9_:* = 0;
|
||||
var _loc8_:* = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc10_:* = 0;
|
||||
var _loc11_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc7_:* = 0;
|
||||
var _loc4_:Array = [];
|
||||
var _loc12_:ByteArray = new ByteArray();
|
||||
var _loc13_:ByteArray = new ByteArray();
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < 56)
|
||||
{
|
||||
_loc9_ = uint(pc1[_loc8_]);
|
||||
_loc12_[_loc8_] = (param2[param3 + (_loc9_ >>> 3)] & bytebit[_loc9_ & 7]) != 0;
|
||||
_loc8_++;
|
||||
}
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < 16)
|
||||
{
|
||||
if(param1)
|
||||
{
|
||||
_loc10_ = uint(_loc6_ << 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc10_ = uint(15 - _loc6_ << 1);
|
||||
}
|
||||
_loc11_ = uint(_loc10_ + 1);
|
||||
_loc4_[_loc10_] = _loc4_[_loc11_] = 0;
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < 28)
|
||||
{
|
||||
_loc9_ = uint(_loc8_ + totrot[_loc6_]);
|
||||
if(_loc9_ < 28)
|
||||
{
|
||||
_loc13_[_loc8_] = _loc12_[_loc9_];
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc13_[_loc8_] = _loc12_[_loc9_ - 28];
|
||||
}
|
||||
_loc8_++;
|
||||
}
|
||||
_loc8_ = 28;
|
||||
while(_loc8_ < 56)
|
||||
{
|
||||
_loc9_ = uint(_loc8_ + totrot[_loc6_]);
|
||||
if(_loc9_ < 56)
|
||||
{
|
||||
_loc13_[_loc8_] = _loc12_[_loc9_];
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc13_[_loc8_] = _loc12_[_loc9_ - 28];
|
||||
}
|
||||
_loc8_++;
|
||||
}
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < 24)
|
||||
{
|
||||
if(_loc13_[pc2[_loc8_]])
|
||||
{
|
||||
var _loc14_:* = _loc10_;
|
||||
var _loc15_:* = _loc4_[_loc14_] | bigbyte[_loc8_];
|
||||
_loc4_[_loc14_] = _loc15_;
|
||||
}
|
||||
if(_loc13_[pc2[_loc8_ + 24]])
|
||||
{
|
||||
_loc15_ = _loc11_;
|
||||
_loc14_ = _loc4_[_loc15_] | bigbyte[_loc8_];
|
||||
_loc4_[_loc15_] = _loc14_;
|
||||
}
|
||||
_loc8_++;
|
||||
}
|
||||
_loc6_++;
|
||||
}
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ != 32)
|
||||
{
|
||||
_loc5_ = uint(_loc4_[_loc6_]);
|
||||
_loc7_ = uint(_loc4_[_loc6_ + 1]);
|
||||
_loc4_[_loc6_] = (_loc5_ & 0xFC0000) << 6 | (_loc5_ & 0x0FC0) << 10 | (_loc7_ & 0xFC0000) >>> 10 | (_loc7_ & 0x0FC0) >>> 6;
|
||||
_loc4_[_loc6_ + 1] = (_loc5_ & 0x03F000) << 12 | (_loc5_ & 0x3F) << 16 | (_loc7_ & 0x03F000) >>> 4 | _loc7_ & 0x3F;
|
||||
_loc6_ += 2;
|
||||
}
|
||||
return _loc4_;
|
||||
}
|
||||
|
||||
protected function desFunc(param1:Array, param2:ByteArray, param3:uint, param4:ByteArray, param5:uint) : void
|
||||
{
|
||||
var _loc8_:* = 0;
|
||||
var _loc9_:* = 0;
|
||||
var _loc7_:* = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc10_:* = 0;
|
||||
_loc7_ = uint((param2[param3 + 0] & 0xFF) << 24);
|
||||
_loc7_ = uint(_loc7_ | (param2[param3 + 1] & 0xFF) << 16);
|
||||
_loc7_ = uint(_loc7_ | (param2[param3 + 2] & 0xFF) << 8);
|
||||
_loc7_ = uint(_loc7_ | param2[param3 + 3] & 0xFF);
|
||||
_loc9_ = uint((param2[param3 + 4] & 0xFF) << 24);
|
||||
_loc9_ = uint(_loc9_ | (param2[param3 + 5] & 0xFF) << 16);
|
||||
_loc9_ = uint(_loc9_ | (param2[param3 + 6] & 0xFF) << 8);
|
||||
_loc9_ = uint(_loc9_ | param2[param3 + 7] & 0xFF);
|
||||
_loc8_ = uint((_loc7_ >>> 4 ^ _loc9_) & 0x0F0F0F0F);
|
||||
_loc9_ ^= _loc8_;
|
||||
_loc7_ ^= _loc8_ << 4;
|
||||
_loc8_ = uint((_loc7_ >>> 16 ^ _loc9_) & 0xFFFF);
|
||||
_loc9_ ^= _loc8_;
|
||||
_loc7_ ^= _loc8_ << 16;
|
||||
_loc8_ = uint((_loc9_ >>> 2 ^ _loc7_) & 0x33333333);
|
||||
_loc7_ ^= _loc8_;
|
||||
_loc9_ ^= _loc8_ << 2;
|
||||
_loc8_ = uint((_loc9_ >>> 8 ^ _loc7_) & 0xFF00FF);
|
||||
_loc7_ ^= _loc8_;
|
||||
_loc9_ ^= _loc8_ << 8;
|
||||
_loc9_ = uint((_loc9_ << 1 | _loc9_ >>> 31 & 1) & 0xFFFFFFFF);
|
||||
_loc8_ = uint((_loc7_ ^ _loc9_) & 0xAAAAAAAA);
|
||||
_loc7_ ^= _loc8_;
|
||||
_loc9_ ^= _loc8_;
|
||||
_loc7_ = uint((_loc7_ << 1 | _loc7_ >>> 31 & 1) & 0xFFFFFFFF);
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < 8)
|
||||
{
|
||||
_loc8_ = uint(_loc9_ << 28 | _loc9_ >>> 4);
|
||||
_loc8_ = uint(_loc8_ ^ param1[_loc6_ * 4 + 0]);
|
||||
_loc10_ = uint(SP7[_loc8_ & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP5[_loc8_ >>> 8 & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP3[_loc8_ >>> 16 & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP1[_loc8_ >>> 24 & 0x3F]);
|
||||
_loc8_ = uint(_loc9_ ^ param1[_loc6_ * 4 + 1]);
|
||||
_loc10_ |= SP8[_loc8_ & 0x3F];
|
||||
_loc10_ = uint(_loc10_ | SP6[_loc8_ >>> 8 & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP4[_loc8_ >>> 16 & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP2[_loc8_ >>> 24 & 0x3F]);
|
||||
_loc7_ ^= _loc10_;
|
||||
_loc8_ = uint(_loc7_ << 28 | _loc7_ >>> 4);
|
||||
_loc8_ = uint(_loc8_ ^ param1[_loc6_ * 4 + 2]);
|
||||
_loc10_ = uint(SP7[_loc8_ & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP5[_loc8_ >>> 8 & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP3[_loc8_ >>> 16 & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP1[_loc8_ >>> 24 & 0x3F]);
|
||||
_loc8_ = uint(_loc7_ ^ param1[_loc6_ * 4 + 3]);
|
||||
_loc10_ |= SP8[_loc8_ & 0x3F];
|
||||
_loc10_ = uint(_loc10_ | SP6[_loc8_ >>> 8 & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP4[_loc8_ >>> 16 & 0x3F]);
|
||||
_loc10_ = uint(_loc10_ | SP2[_loc8_ >>> 24 & 0x3F]);
|
||||
_loc9_ ^= _loc10_;
|
||||
_loc6_++;
|
||||
}
|
||||
_loc9_ = uint(_loc9_ << 31 | _loc9_ >>> 1);
|
||||
_loc8_ = uint((_loc7_ ^ _loc9_) & 0xAAAAAAAA);
|
||||
_loc7_ ^= _loc8_;
|
||||
_loc9_ ^= _loc8_;
|
||||
_loc7_ = uint(_loc7_ << 31 | _loc7_ >>> 1);
|
||||
_loc8_ = uint((_loc7_ >>> 8 ^ _loc9_) & 0xFF00FF);
|
||||
_loc9_ ^= _loc8_;
|
||||
_loc7_ ^= _loc8_ << 8;
|
||||
_loc8_ = uint((_loc7_ >>> 2 ^ _loc9_) & 0x33333333);
|
||||
_loc9_ ^= _loc8_;
|
||||
_loc7_ ^= _loc8_ << 2;
|
||||
_loc8_ = uint((_loc9_ >>> 16 ^ _loc7_) & 0xFFFF);
|
||||
_loc7_ ^= _loc8_;
|
||||
_loc9_ ^= _loc8_ << 16;
|
||||
_loc8_ = uint((_loc9_ >>> 4 ^ _loc7_) & 0x0F0F0F0F);
|
||||
_loc7_ ^= _loc8_;
|
||||
_loc9_ ^= _loc8_ << 4;
|
||||
param4[param5 + 0] = _loc9_ >>> 24 & 0xFF;
|
||||
param4[param5 + 1] = _loc9_ >>> 16 & 0xFF;
|
||||
param4[param5 + 2] = _loc9_ >>> 8 & 0xFF;
|
||||
param4[param5 + 3] = _loc9_ & 0xFF;
|
||||
param4[param5 + 4] = _loc7_ >>> 24 & 0xFF;
|
||||
param4[param5 + 5] = _loc7_ >>> 16 & 0xFF;
|
||||
param4[param5 + 6] = _loc7_ >>> 8 & 0xFF;
|
||||
param4[param5 + 7] = _loc7_ & 0xFF;
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "des";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class ECBMode implements IMode, ICipher
|
||||
{
|
||||
|
||||
private var key:ISymmetricKey;
|
||||
|
||||
private var padding:IPad;
|
||||
|
||||
public function ECBMode(param1:ISymmetricKey, param2:IPad = null)
|
||||
{
|
||||
super();
|
||||
this.key = param1;
|
||||
if(param2 == null)
|
||||
{
|
||||
param2 = new PKCS5(param1.getBlockSize());
|
||||
}
|
||||
else
|
||||
{
|
||||
param2.setBlockSize(param1.getBlockSize());
|
||||
}
|
||||
this.padding = param2;
|
||||
}
|
||||
|
||||
public function getBlockSize() : uint
|
||||
{
|
||||
return key.getBlockSize();
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
padding.pad(param1);
|
||||
param1.position = 0;
|
||||
var _loc5_:uint = key.getBlockSize();
|
||||
var _loc3_:ByteArray = new ByteArray();
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < param1.length)
|
||||
{
|
||||
_loc3_.length = 0;
|
||||
param1.readBytes(_loc3_,0,_loc5_);
|
||||
key.encrypt(_loc3_);
|
||||
_loc2_.writeBytes(_loc3_);
|
||||
_loc4_ += _loc5_;
|
||||
}
|
||||
param1.length = 0;
|
||||
param1.writeBytes(_loc2_);
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
param1.position = 0;
|
||||
var _loc5_:uint = key.getBlockSize();
|
||||
if(param1.length % _loc5_ != 0)
|
||||
{
|
||||
throw new Error("ECB mode cipher length must be a multiple of blocksize " + _loc5_);
|
||||
}
|
||||
var _loc3_:ByteArray = new ByteArray();
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < param1.length)
|
||||
{
|
||||
_loc3_.length = 0;
|
||||
param1.readBytes(_loc3_,0,_loc5_);
|
||||
key.decrypt(_loc3_);
|
||||
_loc2_.writeBytes(_loc3_);
|
||||
_loc4_ += _loc5_;
|
||||
}
|
||||
padding.unpad(_loc2_);
|
||||
param1.length = 0;
|
||||
param1.writeBytes(_loc2_);
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
key.dispose();
|
||||
key = null;
|
||||
padding = null;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return key.toString() + "-ecb";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public interface ICipher
|
||||
{
|
||||
|
||||
function getBlockSize() : uint;
|
||||
|
||||
function encrypt(param1:ByteArray) : void;
|
||||
|
||||
function decrypt(param1:ByteArray) : void;
|
||||
|
||||
function dispose() : void;
|
||||
|
||||
function toString() : String;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
public interface IMode extends ICipher
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public interface IPad
|
||||
{
|
||||
|
||||
function pad(param1:ByteArray) : void;
|
||||
|
||||
function unpad(param1:ByteArray) : void;
|
||||
|
||||
function setBlockSize(param1:uint) : void;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
public interface IStreamCipher extends ICipher
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public interface ISymmetricKey
|
||||
{
|
||||
|
||||
function getBlockSize() : uint;
|
||||
|
||||
function encrypt(param1:ByteArray, param2:uint = 0) : void;
|
||||
|
||||
function decrypt(param1:ByteArray, param2:uint = 0) : void;
|
||||
|
||||
function dispose() : void;
|
||||
|
||||
function toString() : String;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import com.hurlant.crypto.prng.Random;
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class IVMode
|
||||
{
|
||||
|
||||
protected var key:ISymmetricKey;
|
||||
|
||||
protected var padding:IPad;
|
||||
|
||||
protected var prng:Random;
|
||||
|
||||
protected var iv:ByteArray;
|
||||
|
||||
protected var lastIV:ByteArray;
|
||||
|
||||
protected var blockSize:uint;
|
||||
|
||||
public function IVMode(param1:ISymmetricKey, param2:IPad = null)
|
||||
{
|
||||
super();
|
||||
this.key = param1;
|
||||
blockSize = param1.getBlockSize();
|
||||
if(param2 == null)
|
||||
{
|
||||
param2 = new PKCS5(blockSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
param2.setBlockSize(blockSize);
|
||||
}
|
||||
this.padding = param2;
|
||||
prng = new Random();
|
||||
iv = null;
|
||||
lastIV = new ByteArray();
|
||||
}
|
||||
|
||||
public function getBlockSize() : uint
|
||||
{
|
||||
return key.getBlockSize();
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
var _loc1_:* = 0;
|
||||
if(iv != null)
|
||||
{
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < iv.length)
|
||||
{
|
||||
iv[_loc1_] = prng.nextByte();
|
||||
_loc1_++;
|
||||
}
|
||||
iv.length = 0;
|
||||
iv = null;
|
||||
}
|
||||
if(lastIV != null)
|
||||
{
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < iv.length)
|
||||
{
|
||||
lastIV[_loc1_] = prng.nextByte();
|
||||
_loc1_++;
|
||||
}
|
||||
lastIV.length = 0;
|
||||
lastIV = null;
|
||||
}
|
||||
key.dispose();
|
||||
key = null;
|
||||
padding = null;
|
||||
prng.dispose();
|
||||
prng = null;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
public function set IV(param1:ByteArray) : void
|
||||
{
|
||||
iv = param1;
|
||||
lastIV.length = 0;
|
||||
lastIV.writeBytes(iv);
|
||||
}
|
||||
|
||||
public function get IV() : ByteArray
|
||||
{
|
||||
return lastIV;
|
||||
}
|
||||
|
||||
protected function getIV4e() : ByteArray
|
||||
{
|
||||
var _loc1_:ByteArray = new ByteArray();
|
||||
if(iv)
|
||||
{
|
||||
_loc1_.writeBytes(iv);
|
||||
}
|
||||
else
|
||||
{
|
||||
prng.nextBytes(_loc1_,blockSize);
|
||||
}
|
||||
lastIV.length = 0;
|
||||
lastIV.writeBytes(_loc1_);
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
protected function getIV4d() : ByteArray
|
||||
{
|
||||
var _loc1_:ByteArray = new ByteArray();
|
||||
if(iv)
|
||||
{
|
||||
_loc1_.writeBytes(iv);
|
||||
return _loc1_;
|
||||
}
|
||||
throw new Error("an IV must be set before calling decrypt()");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class NullPad implements IPad
|
||||
{
|
||||
|
||||
public function NullPad()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function unpad(param1:ByteArray) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function pad(param1:ByteArray) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function setBlockSize(param1:uint) : void
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class OFBMode extends IVMode implements IMode
|
||||
{
|
||||
|
||||
public function OFBMode(param1:ISymmetricKey, param2:IPad = null)
|
||||
{
|
||||
super(param1,null);
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc2_:ByteArray = getIV4e();
|
||||
core(param1,_loc2_);
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc2_:ByteArray = getIV4d();
|
||||
core(param1,_loc2_);
|
||||
}
|
||||
|
||||
private function core(param1:ByteArray, param2:ByteArray) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc7_:uint = param1.length;
|
||||
var _loc3_:ByteArray = new ByteArray();
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < param1.length)
|
||||
{
|
||||
key.encrypt(param2);
|
||||
_loc3_.position = 0;
|
||||
_loc3_.writeBytes(param2);
|
||||
_loc5_ = uint(_loc4_ + blockSize < _loc7_ ? blockSize : _loc7_ - _loc4_);
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < _loc5_)
|
||||
{
|
||||
var _loc8_:Number = _loc4_ + _loc6_;
|
||||
var _loc9_:int = param1[_loc8_] ^ param2[_loc6_];
|
||||
param1[_loc8_] = _loc9_;
|
||||
_loc6_++;
|
||||
}
|
||||
param2.position = 0;
|
||||
param2.writeBytes(_loc3_);
|
||||
_loc4_ += blockSize;
|
||||
}
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return key.toString() + "-ofb";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class PKCS5 implements IPad
|
||||
{
|
||||
|
||||
private var blockSize:uint;
|
||||
|
||||
public function PKCS5(param1:uint = 0)
|
||||
{
|
||||
super();
|
||||
this.blockSize = param1;
|
||||
}
|
||||
|
||||
public function pad(param1:ByteArray) : void
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
var _loc2_:uint = blockSize - param1.length % blockSize;
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < _loc2_)
|
||||
{
|
||||
param1[param1.length] = _loc2_;
|
||||
_loc3_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function unpad(param1:ByteArray) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
var _loc3_:* = 0;
|
||||
var _loc2_:uint = param1.length % blockSize;
|
||||
if(_loc2_ != 0)
|
||||
{
|
||||
throw new Error("PKCS#5::unpad: ByteArray.length isn\'t a multiple of the blockSize");
|
||||
}
|
||||
_loc2_ = uint(param1[param1.length - 1]);
|
||||
_loc4_ = _loc2_;
|
||||
while(_loc4_ > 0)
|
||||
{
|
||||
_loc3_ = uint(param1[param1.length - 1]);
|
||||
param1.length--;
|
||||
if(_loc2_ != _loc3_)
|
||||
{
|
||||
throw new Error("PKCS#5:unpad: Invalid padding value. expected [" + _loc2_ + "], found [" + _loc3_ + "]");
|
||||
}
|
||||
_loc4_--;
|
||||
}
|
||||
}
|
||||
|
||||
public function setBlockSize(param1:uint) : void
|
||||
{
|
||||
blockSize = param1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class SimpleIVMode implements IMode, ICipher
|
||||
{
|
||||
|
||||
protected var mode:IVMode;
|
||||
|
||||
protected var cipher:ICipher;
|
||||
|
||||
public function SimpleIVMode(param1:IVMode)
|
||||
{
|
||||
super();
|
||||
this.mode = param1;
|
||||
cipher = param1 as ICipher;
|
||||
}
|
||||
|
||||
public function getBlockSize() : uint
|
||||
{
|
||||
return mode.getBlockSize();
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
mode.dispose();
|
||||
mode = null;
|
||||
cipher = null;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray) : void
|
||||
{
|
||||
cipher.encrypt(param1);
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc2_.writeBytes(mode.IV);
|
||||
_loc2_.writeBytes(param1);
|
||||
param1.position = 0;
|
||||
param1.writeBytes(_loc2_);
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray) : void
|
||||
{
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc2_.writeBytes(param1,0,getBlockSize());
|
||||
mode.IV = _loc2_;
|
||||
_loc2_ = new ByteArray();
|
||||
_loc2_.writeBytes(param1,getBlockSize());
|
||||
cipher.decrypt(_loc2_);
|
||||
param1.length = 0;
|
||||
param1.writeBytes(_loc2_);
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "simple-" + cipher.toString();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class TripleDESKey extends DESKey
|
||||
{
|
||||
|
||||
protected var encKey2:Array;
|
||||
|
||||
protected var encKey3:Array;
|
||||
|
||||
protected var decKey2:Array;
|
||||
|
||||
protected var decKey3:Array;
|
||||
|
||||
public function TripleDESKey(param1:ByteArray)
|
||||
{
|
||||
super(param1);
|
||||
encKey2 = generateWorkingKey(false,param1,8);
|
||||
decKey2 = generateWorkingKey(true,param1,8);
|
||||
if(param1.length > 16)
|
||||
{
|
||||
encKey3 = generateWorkingKey(true,param1,16);
|
||||
decKey3 = generateWorkingKey(false,param1,16);
|
||||
}
|
||||
else
|
||||
{
|
||||
encKey3 = encKey;
|
||||
decKey3 = decKey;
|
||||
}
|
||||
}
|
||||
|
||||
override public function dispose() : void
|
||||
{
|
||||
super.dispose();
|
||||
var _loc1_:uint = 0;
|
||||
if(encKey2 != null)
|
||||
{
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < encKey2.length)
|
||||
{
|
||||
encKey2[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
encKey2 = null;
|
||||
}
|
||||
if(encKey3 != null)
|
||||
{
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < encKey3.length)
|
||||
{
|
||||
encKey3[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
encKey3 = null;
|
||||
}
|
||||
if(decKey2 != null)
|
||||
{
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < decKey2.length)
|
||||
{
|
||||
decKey2[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
decKey2 = null;
|
||||
}
|
||||
if(decKey3 != null)
|
||||
{
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < decKey3.length)
|
||||
{
|
||||
decKey3[_loc1_] = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
decKey3 = null;
|
||||
}
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
override public function encrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
desFunc(encKey,param1,param2,param1,param2);
|
||||
desFunc(encKey2,param1,param2,param1,param2);
|
||||
desFunc(encKey3,param1,param2,param1,param2);
|
||||
}
|
||||
|
||||
override public function decrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
desFunc(decKey3,param1,param2,param1,param2);
|
||||
desFunc(decKey2,param1,param2,param1,param2);
|
||||
desFunc(decKey,param1,param2,param1,param2);
|
||||
}
|
||||
|
||||
override public function toString() : String
|
||||
{
|
||||
return "3des";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
package com.hurlant.crypto.symmetric
|
||||
{
|
||||
import com.hurlant.crypto.prng.Random;
|
||||
import com.hurlant.util.Memory;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class XTeaKey implements ISymmetricKey
|
||||
{
|
||||
|
||||
public const NUM_ROUNDS:uint = 64;
|
||||
|
||||
private var k:Array;
|
||||
|
||||
public function XTeaKey(param1:ByteArray)
|
||||
{
|
||||
super();
|
||||
param1.position = 0;
|
||||
k = [param1.readUnsignedInt(),param1.readUnsignedInt(),param1.readUnsignedInt(),param1.readUnsignedInt()];
|
||||
}
|
||||
|
||||
public static function parseKey(param1:String) : XTeaKey
|
||||
{
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc2_.writeUnsignedInt(parseInt(param1.substr(0,8),16));
|
||||
_loc2_.writeUnsignedInt(parseInt(param1.substr(8,8),16));
|
||||
_loc2_.writeUnsignedInt(parseInt(param1.substr(16,8),16));
|
||||
_loc2_.writeUnsignedInt(parseInt(param1.substr(24,8),16));
|
||||
_loc2_.position = 0;
|
||||
return new XTeaKey(_loc2_);
|
||||
}
|
||||
|
||||
public function getBlockSize() : uint
|
||||
{
|
||||
return 8;
|
||||
}
|
||||
|
||||
public function encrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
param1.position = param2;
|
||||
var _loc5_:uint = param1.readUnsignedInt();
|
||||
var _loc7_:uint = param1.readUnsignedInt();
|
||||
var _loc6_:uint = 0;
|
||||
var _loc3_:Number = 2654435769;
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < 64)
|
||||
{
|
||||
_loc5_ += (_loc7_ << 4 ^ _loc7_ >> 5) + _loc7_ ^ _loc6_ + k[_loc6_ & 3];
|
||||
_loc6_ += _loc3_;
|
||||
_loc7_ += (_loc5_ << 4 ^ _loc5_ >> 5) + _loc5_ ^ _loc6_ + k[_loc6_ >> 11 & 3];
|
||||
_loc4_++;
|
||||
}
|
||||
param1.position -= 8;
|
||||
param1.writeUnsignedInt(_loc5_);
|
||||
param1.writeUnsignedInt(_loc7_);
|
||||
}
|
||||
|
||||
public function decrypt(param1:ByteArray, param2:uint = 0) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
param1.position = param2;
|
||||
var _loc5_:uint = param1.readUnsignedInt();
|
||||
var _loc7_:uint = param1.readUnsignedInt();
|
||||
var _loc3_:Number = 2654435769;
|
||||
var _loc6_:uint = _loc3_ * 64;
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < 64)
|
||||
{
|
||||
_loc7_ -= (_loc5_ << 4 ^ _loc5_ >> 5) + _loc5_ ^ _loc6_ + k[_loc6_ >> 11 & 3];
|
||||
_loc6_ -= _loc3_;
|
||||
_loc5_ -= (_loc7_ << 4 ^ _loc7_ >> 5) + _loc7_ ^ _loc6_ + k[_loc6_ & 3];
|
||||
_loc4_++;
|
||||
}
|
||||
param1.position -= 8;
|
||||
param1.writeUnsignedInt(_loc5_);
|
||||
param1.writeUnsignedInt(_loc7_);
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
var _loc2_:* = 0;
|
||||
var _loc1_:Random = new Random();
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < k.length)
|
||||
{
|
||||
k[_loc2_] = _loc1_.nextByte();
|
||||
delete k[_loc2_];
|
||||
_loc2_++;
|
||||
}
|
||||
k = null;
|
||||
Memory.gc();
|
||||
}
|
||||
|
||||
public function toString() : String
|
||||
{
|
||||
return "xtea";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
package com.hurlant.math
|
||||
{
|
||||
use namespace bi_internal;
|
||||
|
||||
internal class BarrettReduction implements IReduction
|
||||
{
|
||||
|
||||
private var m:BigInteger;
|
||||
|
||||
private var r2:BigInteger;
|
||||
|
||||
private var q3:BigInteger;
|
||||
|
||||
private var mu:BigInteger;
|
||||
|
||||
public function BarrettReduction(param1:BigInteger)
|
||||
{
|
||||
super();
|
||||
r2 = new BigInteger();
|
||||
q3 = new BigInteger();
|
||||
BigInteger.ONE.dlShiftTo(2 * param1.t,r2);
|
||||
mu = r2.divide(param1);
|
||||
this.m = param1;
|
||||
}
|
||||
|
||||
public function revert(param1:BigInteger) : BigInteger
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
|
||||
public function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void
|
||||
{
|
||||
param1.multiplyTo(param2,param3);
|
||||
reduce(param3);
|
||||
}
|
||||
|
||||
public function sqrTo(param1:BigInteger, param2:BigInteger) : void
|
||||
{
|
||||
param1.squareTo(param2);
|
||||
reduce(param2);
|
||||
}
|
||||
|
||||
public function convert(param1:BigInteger) : BigInteger
|
||||
{
|
||||
var _loc2_:BigInteger = null;
|
||||
if(param1.s < 0 || param1.t > 2 * m.t)
|
||||
{
|
||||
return param1.mod(m);
|
||||
}
|
||||
if(param1.compareTo(m) < 0)
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
_loc2_ = new BigInteger();
|
||||
param1.copyTo(_loc2_);
|
||||
reduce(_loc2_);
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public function reduce(param1:BigInteger) : void
|
||||
{
|
||||
var _loc2_:BigInteger = param1 as BigInteger;
|
||||
_loc2_.drShiftTo(m.t - 1,r2);
|
||||
if(_loc2_.t > m.t + 1)
|
||||
{
|
||||
_loc2_.t = m.t + 1;
|
||||
_loc2_.clamp();
|
||||
}
|
||||
mu.multiplyUpperTo(r2,m.t + 1,q3);
|
||||
m.multiplyLowerTo(q3,m.t + 1,r2);
|
||||
while(_loc2_.compareTo(r2) < 0)
|
||||
{
|
||||
_loc2_.dAddOffset(1,m.t + 1);
|
||||
}
|
||||
_loc2_.subTo(r2,_loc2_);
|
||||
while(_loc2_.compareTo(m) >= 0)
|
||||
{
|
||||
_loc2_.subTo(m,_loc2_);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,48 @@
|
||||
package com.hurlant.math
|
||||
{
|
||||
use namespace bi_internal;
|
||||
|
||||
internal class ClassicReduction implements IReduction
|
||||
{
|
||||
|
||||
private var m:BigInteger;
|
||||
|
||||
public function ClassicReduction(param1:BigInteger)
|
||||
{
|
||||
super();
|
||||
this.m = param1;
|
||||
}
|
||||
|
||||
public function convert(param1:BigInteger) : BigInteger
|
||||
{
|
||||
if(param1.s < 0 || param1.compareTo(m) >= 0)
|
||||
{
|
||||
return param1.mod(m);
|
||||
}
|
||||
return param1;
|
||||
}
|
||||
|
||||
public function revert(param1:BigInteger) : BigInteger
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
|
||||
public function reduce(param1:BigInteger) : void
|
||||
{
|
||||
param1.divRemTo(m,null,param1);
|
||||
}
|
||||
|
||||
public function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void
|
||||
{
|
||||
param1.multiplyTo(param2,param3);
|
||||
reduce(param3);
|
||||
}
|
||||
|
||||
public function sqrTo(param1:BigInteger, param2:BigInteger) : void
|
||||
{
|
||||
param1.squareTo(param2);
|
||||
reduce(param2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
package com.hurlant.math
|
||||
{
|
||||
internal interface IReduction
|
||||
{
|
||||
|
||||
function convert(param1:BigInteger) : BigInteger;
|
||||
|
||||
function revert(param1:BigInteger) : BigInteger;
|
||||
|
||||
function reduce(param1:BigInteger) : void;
|
||||
|
||||
function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void;
|
||||
|
||||
function sqrTo(param1:BigInteger, param2:BigInteger) : void;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
package com.hurlant.math
|
||||
{
|
||||
use namespace bi_internal;
|
||||
|
||||
internal class MontgomeryReduction implements IReduction
|
||||
{
|
||||
|
||||
private var m:BigInteger;
|
||||
|
||||
private var mp:int;
|
||||
|
||||
private var mpl:int;
|
||||
|
||||
private var mph:int;
|
||||
|
||||
private var um:int;
|
||||
|
||||
private var mt2:int;
|
||||
|
||||
public function MontgomeryReduction(param1:BigInteger)
|
||||
{
|
||||
super();
|
||||
this.m = param1;
|
||||
mp = param1.invDigit();
|
||||
mpl = mp & 0x7FFF;
|
||||
mph = mp >> 15;
|
||||
um = 32767;
|
||||
mt2 = 2 * param1.t;
|
||||
}
|
||||
|
||||
public function convert(param1:BigInteger) : BigInteger
|
||||
{
|
||||
var _loc2_:BigInteger = new BigInteger();
|
||||
param1.abs().dlShiftTo(m.t,_loc2_);
|
||||
_loc2_.divRemTo(m,null,_loc2_);
|
||||
if(param1.s < 0 && _loc2_.compareTo(BigInteger.ZERO) > 0)
|
||||
{
|
||||
m.subTo(_loc2_,_loc2_);
|
||||
}
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public function revert(param1:BigInteger) : BigInteger
|
||||
{
|
||||
var _loc2_:BigInteger = new BigInteger();
|
||||
param1.copyTo(_loc2_);
|
||||
reduce(_loc2_);
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public function reduce(param1:BigInteger) : void
|
||||
{
|
||||
var _loc2_:int = 0;
|
||||
var _loc3_:int = 0;
|
||||
var _loc4_:int = 0;
|
||||
while(param1.t <= mt2)
|
||||
{
|
||||
param1.a[param1.t++] = 0;
|
||||
}
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < m.t)
|
||||
{
|
||||
_loc3_ = param1.a[_loc2_] & 0x7FFF;
|
||||
_loc4_ = _loc3_ * mpl + ((_loc3_ * mph + (param1.a[_loc2_] >> 15) * mpl & um) << 15) & 0x3FFFFFFF;
|
||||
_loc3_ = _loc2_ + m.t;
|
||||
param1.a[_loc3_] += m.am(0,_loc4_,param1,_loc2_,0,m.t);
|
||||
while(param1.a[_loc3_] >= 1073741824)
|
||||
{
|
||||
var _loc6_:int = _loc3_;
|
||||
var _loc5_:Number = param1.a[_loc6_] - 1073741824;
|
||||
param1.a[_loc6_] = _loc5_;
|
||||
param1.a[++_loc3_]++;
|
||||
}
|
||||
_loc2_++;
|
||||
}
|
||||
param1.clamp();
|
||||
param1.drShiftTo(m.t,param1);
|
||||
if(param1.compareTo(m) >= 0)
|
||||
{
|
||||
param1.subTo(m,param1);
|
||||
}
|
||||
}
|
||||
|
||||
public function sqrTo(param1:BigInteger, param2:BigInteger) : void
|
||||
{
|
||||
param1.squareTo(param2);
|
||||
reduce(param2);
|
||||
}
|
||||
|
||||
public function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void
|
||||
{
|
||||
param1.multiplyTo(param2,param3);
|
||||
reduce(param3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
package com.hurlant.math
|
||||
{
|
||||
use namespace bi_internal;
|
||||
|
||||
public class NullReduction implements IReduction
|
||||
{
|
||||
|
||||
public function NullReduction()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function revert(param1:BigInteger) : BigInteger
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
|
||||
public function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void
|
||||
{
|
||||
param1.multiplyTo(param2,param3);
|
||||
}
|
||||
|
||||
public function sqrTo(param1:BigInteger, param2:BigInteger) : void
|
||||
{
|
||||
param1.squareTo(param2);
|
||||
}
|
||||
|
||||
public function convert(param1:BigInteger) : BigInteger
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
|
||||
public function reduce(param1:BigInteger) : void
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
package com.hurlant.math
|
||||
{
|
||||
public namespace bi_internal = "http://crypto.hurlant.com/BigInteger";
|
||||
}
|
||||
|
||||
@@ -0,0 +1,143 @@
|
||||
package com.hurlant.util
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class Base64
|
||||
{
|
||||
|
||||
private static const _encodeChars:Vector.<int> = _initEncoreChar();
|
||||
|
||||
private static const _decodeChars:Vector.<int> = _initDecodeChar();
|
||||
|
||||
public function Base64()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public static function encode(param1:String) : String
|
||||
{
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
_loc2_.writeUTFBytes(param1);
|
||||
return encodeByteArray(_loc2_);
|
||||
}
|
||||
|
||||
public static function decode(param1:String) : String
|
||||
{
|
||||
var _loc2_:ByteArray = decodeToByteArray(param1);
|
||||
return _loc2_.readUTFBytes(_loc2_.length);
|
||||
}
|
||||
|
||||
public static function encodeByteArray(param1:ByteArray) : String
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
var _loc7_:ByteArray = new ByteArray();
|
||||
_loc7_.length = (2 + param1.length - (param1.length + 2) % 3) * 4 / 3;
|
||||
var _loc6_:int = 0;
|
||||
var _loc2_:int = param1.length % 3;
|
||||
var _loc4_:int = param1.length - _loc2_;
|
||||
var _loc5_:int = 0;
|
||||
while(_loc6_ < _loc4_)
|
||||
{
|
||||
_loc3_ = uint(param1[_loc6_++] << 16 | param1[_loc6_++] << 8 | param1[_loc6_++]);
|
||||
_loc7_[_loc5_++] = _encodeChars[_loc3_ >>> 18];
|
||||
_loc7_[_loc5_++] = _encodeChars[_loc3_ >>> 12 & 0x3F];
|
||||
_loc7_[_loc5_++] = _encodeChars[_loc3_ >>> 6 & 0x3F];
|
||||
_loc7_[_loc5_++] = _encodeChars[_loc3_ & 0x3F];
|
||||
}
|
||||
if(_loc2_ == 1)
|
||||
{
|
||||
_loc3_ = uint(param1[_loc6_]);
|
||||
_loc7_[_loc5_++] = _encodeChars[_loc3_ >>> 2];
|
||||
_loc7_[_loc5_++] = _encodeChars[(_loc3_ & 3) << 4];
|
||||
_loc7_[_loc5_++] = 61;
|
||||
_loc7_[_loc5_++] = 61;
|
||||
}
|
||||
else if(_loc2_ == 2)
|
||||
{
|
||||
_loc3_ = uint(param1[_loc6_++] << 8 | param1[int(_loc6_)]);
|
||||
_loc7_[_loc5_++] = _encodeChars[_loc3_ >>> 10];
|
||||
_loc7_[_loc5_++] = _encodeChars[_loc3_ >>> 4 & 0x3F];
|
||||
_loc7_[_loc5_++] = _encodeChars[(_loc3_ & 0x0F) << 2];
|
||||
_loc7_[_loc5_++] = 61;
|
||||
}
|
||||
return _loc7_.readUTFBytes(_loc7_.length);
|
||||
}
|
||||
|
||||
public static function decodeToByteArray(param1:String) : ByteArray
|
||||
{
|
||||
var _loc8_:int = 0;
|
||||
var _loc9_:int = 0;
|
||||
var _loc2_:int = 0;
|
||||
var _loc3_:int = 0;
|
||||
var _loc7_:int = 0;
|
||||
var _loc4_:int = param1.length;
|
||||
var _loc5_:ByteArray = new ByteArray();
|
||||
_loc5_.writeUTFBytes(param1);
|
||||
var _loc6_:int = 0;
|
||||
while(_loc7_ < _loc4_)
|
||||
{
|
||||
_loc8_ = _decodeChars[int(_loc5_[_loc7_++])];
|
||||
if(_loc8_ == -1)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc9_ = _decodeChars[int(_loc5_[_loc7_++])];
|
||||
if(_loc9_ == -1)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc5_[_loc6_++] = _loc8_ << 2 | (_loc9_ & 0x30) >> 4;
|
||||
_loc2_ = int(_loc5_[_loc7_++]);
|
||||
if(_loc2_ == 61)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc2_ = _decodeChars[_loc2_];
|
||||
if(_loc2_ == -1)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc5_[_loc6_++] = (_loc9_ & 0x0F) << 4 | (_loc2_ & 0x3C) >> 2;
|
||||
_loc3_ = int(_loc5_[_loc7_++]);
|
||||
if(_loc3_ == 61)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc3_ = _decodeChars[_loc3_];
|
||||
if(_loc3_ == -1)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc5_[_loc6_++] = (_loc2_ & 3) << 6 | _loc3_;
|
||||
}
|
||||
_loc5_.length = _loc6_;
|
||||
_loc5_.position = 0;
|
||||
return _loc5_;
|
||||
}
|
||||
|
||||
public static function decodeToByteArrayB(param1:String) : ByteArray
|
||||
{
|
||||
return decodeToByteArray(param1);
|
||||
}
|
||||
|
||||
private static function _initEncoreChar() : Vector.<int>
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
var _loc2_:Vector.<int> = new Vector.<int>(64,true);
|
||||
var _loc3_:String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 64)
|
||||
{
|
||||
_loc2_[_loc1_] = _loc3_.charCodeAt(_loc1_);
|
||||
_loc1_++;
|
||||
}
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
private static function _initDecodeChar() : Vector.<int>
|
||||
{
|
||||
return new <int>[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
package com.hurlant.util
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class Hex
|
||||
{
|
||||
|
||||
public function Hex()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public static function toArray(param1:String) : ByteArray
|
||||
{
|
||||
var _loc3_:* = 0;
|
||||
param1 = param1.replace(/\s|:/gm,"");
|
||||
var _loc2_:ByteArray = new ByteArray();
|
||||
if((param1.length & 1) == 1)
|
||||
{
|
||||
param1 = "0" + param1;
|
||||
}
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < param1.length)
|
||||
{
|
||||
_loc2_[_loc3_ / 2] = parseInt(param1.substr(_loc3_,2),16);
|
||||
_loc3_ += 2;
|
||||
}
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public static function fromArray(param1:ByteArray, param2:Boolean = false) : String
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
var _loc3_:String = "";
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < param1.length)
|
||||
{
|
||||
_loc3_ += ("0" + param1[_loc4_].toString(16)).substr(-2,2);
|
||||
if(param2)
|
||||
{
|
||||
if(_loc4_ < param1.length - 1)
|
||||
{
|
||||
_loc3_ += ":";
|
||||
}
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
public static function toString(param1:String) : String
|
||||
{
|
||||
var _loc2_:ByteArray = toArray(param1);
|
||||
return _loc2_.readUTFBytes(_loc2_.length);
|
||||
}
|
||||
|
||||
public static function fromString(param1:String, param2:Boolean = false) : String
|
||||
{
|
||||
var _loc3_:ByteArray = new ByteArray();
|
||||
_loc3_.writeUTFBytes(param1);
|
||||
return fromArray(_loc3_,param2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
package com.hurlant.util
|
||||
{
|
||||
import flash.net.LocalConnection;
|
||||
import flash.system.System;
|
||||
|
||||
public class Memory
|
||||
{
|
||||
|
||||
public function Memory()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public static function gc() : void
|
||||
{
|
||||
try
|
||||
{
|
||||
new LocalConnection().connect("foo");
|
||||
new LocalConnection().connect("foo");
|
||||
}
|
||||
catch(e:*)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public static function get used() : uint
|
||||
{
|
||||
return System.totalMemory;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user