1
13
14 import com.sekati.crypt.ICipher;
15
16
19 class com.sekati.crypt.Rijndael implements ICipher {
20
21 private var roundsArray:Array;
22 private var shiftOffsets:Array;
23 private var Nr:Number, Nk:Number, Nb:Number;
24 private var Rcon:Array = [ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc,0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4,0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91 ];
25 private var 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 ];
26 private var SBoxInverse: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 ];
27 public var blockSize:Number = 128;
28 public var keySize:Number = 128;
29
30
33 public function Rijndael(keySize:Number, blockSize:Number) {
34 if (keySize != null) this.keySize = keySize;
35 if (blockSize != null) this.blockSize = blockSize;
36 this.roundsArray = [ 0,0,0,0,[ 0,0,0,0,10,0,12,0,14 ],0,[ 0,0,0,0,12,0,12,0,14 ],0,[ 0,0,0,0,14,0,14,0,14 ] ];
37 this.shiftOffsets = [ 0,0,0,0,[ 0,1,2,3 ],0,[ 0,1,2,3 ],0,[ 0,1,3,4 ] ];
38 this.Nb = blockSize / 32;
39 this.Nk = keySize / 32;
40 this.Nr = this.roundsArray[this.Nk][this.Nb];
41 }
42
43
46 public function encrypt(src:String, key:String, mode:String):String {
47 var ct:Array = new Array( );
48 var aBlock:Array = new Array( );
49 var bpb:Number = this.blockSize / 8;
50 if (mode == "CBC") ct = this.getRandomBytes( bpb );
51 var chars:Array = this.formatPlaintext( strToChars( src ) );
52 var expandedKey:Array = this.keyExpansion( strToChars( key ) );
53 for (var block:Number = 0; block < chars.length / bpb ; block++) {
54 aBlock = chars.slice( block * bpb, (block + 1) * bpb );
55 if (mode == "CBC") {
56 for (var i:Number = 0; i < bpb ; i++) {
57 aBlock[i] ^= ct[block * bpb + i];
58 }
59 }
60 ct = ct.concat( this.encryption( aBlock, expandedKey ) );
61 }
62 return charsToHex( ct );
63 }
64
65
68 public function decrypt(src:String, key:String, mode:String):String {
69 var pt:Array = new Array( );
70 var aBlock:Array = new Array( );
71 var chars:Array = hexToChars( src );
72 var bpb:Number = this.blockSize / 8;
73 var expandedKey:Array = this.keyExpansion( strToChars( key ) );
74 for (var block:Number = (chars.length / bpb) - 1; block > 0 ; block--) {
75 aBlock = decryption( chars.slice( block * bpb, (block + 1) * bpb ), expandedKey );
76 if(mode == "CBC") {
77 for (var i:Number = 0; i < bpb ; i++) {
78 pt[(block - 1) * bpb + i] = aBlock[i] ^ chars[(block - 1) * bpb + i];
79 }
80 }
81 else pt = aBlock.concat( pt );
82 }
83 if (mode == "ECB") {
84 pt = this.decryption( chars.slice( 0, bpb ), expandedKey ).concat( pt );
85 }
86 return charsToStr( pt );
87 }
88
89 private function cyclicShiftLeft(src:Array, pos:Number):Array {
90 var temp:Array = src.slice( 0, pos );
91 src = src.slice( pos ).concat( temp );
92 return src;
93 }
94
95 private function xtime(poly:Number):Number {
96 poly <<= 1;
97 return ((poly & 0x100) ? (poly ^ 0x11B) : (poly));
98 }
99
100 private function mult_GF256(x:Number, y:Number):Number {
101 var result:Number = 0;
102 for (var bit:Number = 1; bit < 256 ; bit *= 2, y = xtime( y )) {
103 if(x & bit) result ^= y;
104 }
105 return result;
106 }
107
108 private function byteSub(state:Array, dir:String):Void {
109 var S:Array;
110 if(dir == "encrypt") S = this.SBox;
111 else S = this.SBoxInverse;
112 for (var i:Number = 0; i < 4 ; i++) {
113 for (var j:Number = 0; j < this.Nb ; j++) state[i][j] = S[state[i][j]];
114 }
115 }
116
117 private function shiftRow(state:Array, dir:String):Void {
118 for (var i:Number = 1; i < 4 ; i++) {
119 if (dir == "encrypt") state[i] = this.cyclicShiftLeft( state[i], this.shiftOffsets[Nb][i] );
120 else state[i] = this.cyclicShiftLeft( state[i], this.Nb - this.shiftOffsets[Nb][i] );
121 }
122 }
123
124 private function mixColumn(state:Array, dir:String):Void {
125 var b:Array = new Array( );
126 var i:Number;
127 for (var j:Number = 0; j < this.Nb ; j++) {
128 for(i = 0; i < 4 ; i++) {
129 if (dir == "encrypt") b[i] = this.mult_GF256( state[i][j], 2 ) ^ this.mult_GF256( state[(i + 1) % 4][j], 3 ) ^ state[(i + 2) % 4][j] ^ state[(i + 3) % 4][j];
130 else b[i] = this.mult_GF256( state[i][j], 0xE ) ^ this.mult_GF256( state[(i + 1) % 4][j], 0xB ) ^ this.mult_GF256( state[(i + 2) % 4][j], 0xD ) ^ this.mult_GF256( state[(i + 3) % 4][j], 9 );
131 }
132 for (i = 0; i < 4 ; i++) {
133 state[i][j] = b[i];
134 }
135 }
136 }
137
138 private function addRoundKey(state:Array, roundKey:Array):Void {
139 for (var j:Number = 0; j < this.Nb ; j++) {
140 state[0][j] ^= (roundKey[j] & 0xFF);
141 state[1][j] ^= ((roundKey[j] >> 8) & 0xFF);
142 state[2][j] ^= ((roundKey[j] >> 16) & 0xFF);
143 state[3][j] ^= ((roundKey[j] >> 24) & 0xFF);
144 }
145 }
146
147 private function keyExpansion(key:Array):Array {
148 var temp:Number = 0;
149 var j:Number;
150 this.Nk = this.keySize / 32;
151 this.Nb = this.blockSize / 32;
152 var expandedKey:Array = new Array( );
153 this.Nr = this.roundsArray[this.Nk][this.Nb];
154 for (j = 0; j < this.Nk ; j++) expandedKey[j] = (key[4 * j]) | (key[4 * j + 1] << 8) | (key[4 * j + 2] << 16) | (key[4 * j + 3] << 24);
155 for (j = this.Nk; j < this.Nb * (this.Nr + 1) ; j++) {
156 temp = expandedKey[j - 1];
157 if (j % this.Nk == 0) temp = ( (this.SBox[(temp >> 8) & 0xFF]) | (this.SBox[(temp >> 16) & 0xFF] << 8) | (this.SBox[(temp >> 24) & 0xFF] << 16) | (this.SBox[temp & 0xFF] << 24) ) ^ this.Rcon[Math.floor( j / this.Nk ) - 1];
158 else if (this.Nk > 6 && j % this.Nk == 4) temp = (this.SBox[(temp >> 24) & 0xFF] << 24) | (this.SBox[(temp >> 16) & 0xFF] << 16) | (this.SBox[(temp >> 8) & 0xFF] << 8) | (this.SBox[temp & 0xFF]);
159 expandedKey[j] = expandedKey[j - this.Nk] ^ temp;
160 }
161 return expandedKey;
162 }
163
164 private function Round(state:Array, roundKey:Array):Void {
165 this.byteSub( state, "encrypt" );
166 this.shiftRow( state, "encrypt" );
167 this.mixColumn( state, "encrypt" );
168 this.addRoundKey( state, roundKey );
169 }
170
171 private function InverseRound(state:Array, roundKey:Array):Void {
172 this.addRoundKey( state, roundKey );
173 this.mixColumn( state, "decrypt" );
174 this.shiftRow( state, "decrypt" );
175 this.byteSub( state, "decrypt" );
176 }
177
178 private function FinalRound(state:Array, roundKey:Array):Void {
179 this.byteSub( state, "encrypt" );
180 this.shiftRow( state, "encrypt" );
181 this.addRoundKey( state, roundKey );
182 }
183
184 private function InverseFinalRound(state:Array, roundKey:Array):Void {
185 this.addRoundKey( state, roundKey );
186 this.shiftRow( state, "decrypt" );
187 this.byteSub( state, "decrypt" );
188 }
189
190 private function encryption(block:Array, expandedKey:Array):Array {
191 block = this.packBytes( block );
192 this.addRoundKey( block, expandedKey );
193 for (var i:Number = 1; i < Nr ; i++) {
194 this.Round( block, expandedKey.slice( this.Nb * i, this.Nb * (i + 1) ) );
195 }
196 this.FinalRound( block, expandedKey.slice( this.Nb * this.Nr ) );
197 return this.unpackBytes( block );
198 }
199
200 private function decryption(block:Array, expandedKey:Array):Array {
201 block = this.packBytes( block );
202 this.InverseFinalRound( block, expandedKey.slice( this.Nb * this.Nr ) );
203 for (var i:Number = Nr - 1; i > 0 ; i--) {
204 this.InverseRound( block, expandedKey.slice( this.Nb * i, this.Nb * (i + 1) ) );
205 }
206 this.addRoundKey( block, expandedKey );
207 return this.unpackBytes( block );
208 }
209
210 private function packBytes(octets:Array):Array {
211 var state:Array = new Array( );
212 state[0] = new Array( );
213 state[1] = new Array( );
214 state[2] = new Array( );
215 state[3] = new Array( );
216 for (var j:Number = 0; j < octets.length ; j += 4) {
217 state[0][j / 4] = octets[j];
218 state[1][j / 4] = octets[j + 1];
219 state[2][j / 4] = octets[j + 2];
220 state[3][j / 4] = octets[j + 3];
221 }
222 return state;
223 }
224
225 private function unpackBytes(packed:Array):Array {
226 var result:Array = new Array( );
227 for (var j:Number = 0; j < packed[0].length ; j++) {
228 result[result.length] = packed[0][j];
229 result[result.length] = packed[1][j];
230 result[result.length] = packed[2][j];
231 result[result.length] = packed[3][j];
232 }
233 return result;
234 }
235
236 private function formatPlaintext(plaintext:Array):Array {
237 var bpb:Number = blockSize / 8;
238 for (var i:Number = bpb - (plaintext.length % bpb); i > 0 && i < bpb ; i--) {
239 plaintext[plaintext.length] = 0;
240 }
241 return plaintext;
242 }
243
244 private function getRandomBytes(howMany:Number):Array {
245 var bytes:Array = new Array( );
246 for (var i:Number = 0; i < howMany ; i++) {
247 bytes[i] = Math.round( Math.random( ) * 255 );
248 }
249 return bytes;
250 }
251
252 private function hexToChars(hex:String):Array {
253 var codes:Array = new Array( );
254 for (var i:Number = (hex.substr( 0, 2 ) == "0x") ? 2 : 0; i < hex.length ; i += 2) {
255 codes.push( parseInt( hex.substr( i, 2 ), 16 ) );
256 }
257 return codes;
258 }
259
260 private function charsToHex(chars:Array):String {
261 var result:String = new String( "" );
262 var hexes:Array = new Array( "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" );
263 for (var i:Number = 0; i < chars.length ; i++) {
264 result += hexes[chars[i] >> 4] + hexes[chars[i] & 0xf];
265 }
266 return result;
267 }
268
269 private function charsToStr(chars:Array):String {
270 var result:String = new String( "" );
271 for (var i:Number = 0; i < chars.length ; i++) {
272 result += String.fromCharCode( chars[i] );
273 }
274 return result;
275 }
276
277 private function strToChars(str:String):Array {
278 var codes:Array = new Array( );
279 for (var i:Number = 0; i < str.length ; i++) {
280 codes.push( str.charCodeAt( i ) );
281 }
282 return codes;
283 }
284 }