Esempio n. 1
0
		public static byte[] decrypt(byte[] data, byte[] key)
		{
			if (key == null || data == null || key.Length != 32)
			{
				throw new Exception("Invalid arguments!");
			}
			CryptoEngineAES cryptoEngineAES = new CryptoEngineAES(CryptoEngineAES.KeySize.Bits256, key);
			byte[] array = new byte[data.Length];
			byte[] array2 = new byte[16];
			byte[] array3 = new byte[16];
			for (int i = 0; i < data.Length; i += 16)
			{
				Array.Copy(data, i, array2, 0, 16);
				cryptoEngineAES.InvCipher(array2, array3);
				Array.Copy(array3, 0, array, i, 16);
			}
			return array;
		}
Esempio n. 2
0
 private void InvMixColumns()
 {
     byte[,] buffer = new byte[4, 4];
     for (int i = 0; i < 4; i++)
     {
         for (int num2 = 0; num2 < 4; num2++)
         {
             buffer[i, num2] = this.State[i, num2];
         }
     }
     for (int num2 = 0; num2 < 4; num2++)
     {
         this.State[0, num2] = (CryptoEngineAES.gfmultby0e(buffer[0, num2]) ^ CryptoEngineAES.gfmultby0b(buffer[1, num2]) ^ CryptoEngineAES.gfmultby0d(buffer[2, num2]) ^ CryptoEngineAES.gfmultby09(buffer[3, num2]));
         this.State[1, num2] = (CryptoEngineAES.gfmultby09(buffer[0, num2]) ^ CryptoEngineAES.gfmultby0e(buffer[1, num2]) ^ CryptoEngineAES.gfmultby0b(buffer[2, num2]) ^ CryptoEngineAES.gfmultby0d(buffer[3, num2]));
         this.State[2, num2] = (CryptoEngineAES.gfmultby0d(buffer[0, num2]) ^ CryptoEngineAES.gfmultby09(buffer[1, num2]) ^ CryptoEngineAES.gfmultby0e(buffer[2, num2]) ^ CryptoEngineAES.gfmultby0b(buffer[3, num2]));
         this.State[3, num2] = (CryptoEngineAES.gfmultby0b(buffer[0, num2]) ^ CryptoEngineAES.gfmultby0d(buffer[1, num2]) ^ CryptoEngineAES.gfmultby09(buffer[2, num2]) ^ CryptoEngineAES.gfmultby0e(buffer[3, num2]));
     }
 }
Esempio n. 3
0
		public static byte[] decrypt(byte[] data, byte[] key)
		{
			if (key == null || data == null || key.Length != 32)
			{
				throw new Exception("Invalid arguments!");
			}
			CryptoEngineAES _aesFunct = new CryptoEngineAES(CryptoEngineAES.KeySize.Bits256, key);
			byte[] destinationArray = new byte[data.Length];
			byte[] buffer2 = new byte[16];
			byte[] output = new byte[16];
			for (int i = 0; i < data.Length; i += 16)
			{
				Array.Copy(data, i, buffer2, 0, 16);
				_aesFunct.InvCipher(buffer2, output);
				Array.Copy(output, 0, destinationArray, i, 16);
			}
			return destinationArray;
		}
Esempio n. 4
0
		public static byte[] encrypt(byte[] data, byte[] key)
		{
			if (key == null || data == null || key.Length != 32)
			{
				throw new Exception("Invalid arguments!");
			}
			int num = ((data.Length - 1) / 16 + 1) * 16;
			byte[] array = new byte[num];
			CryptoEngineAES cryptoEngineAES = new CryptoEngineAES(CryptoEngineAES.KeySize.Bits256, key);
			int arg_38_0 = data.Length;
			byte[] array2 = new byte[16];
			byte[] array3 = new byte[16];
			byte[] array4 = new byte[num];
			Array.Copy(data, array4, data.Length);
			for (int i = 0; i < array4.Length; i += 16)
			{
				Array.Copy(array4, i, array2, 0, 16);
				cryptoEngineAES.Cipher(array2, array3);
				Array.Copy(array3, 0, array, i, 16);
			}
			return array;
		}
Esempio n. 5
0
 private static byte gfmultby0e(byte b)
 {
     return(CryptoEngineAES.gfmultby02(CryptoEngineAES.gfmultby02(CryptoEngineAES.gfmultby02(b))) ^ CryptoEngineAES.gfmultby02(CryptoEngineAES.gfmultby02(b)) ^ CryptoEngineAES.gfmultby02(b));
 }
Esempio n. 6
0
 private static byte gfmultby03(byte b)
 {
     return(CryptoEngineAES.gfmultby02(b) ^ b);
 }
 private static byte gfmultby09(byte b)
 {
     return((byte)(CryptoEngineAES.gfmultby02(CryptoEngineAES.gfmultby02(CryptoEngineAES.gfmultby02(b))) ^ b));
 }
		private void SetNbNkNr(CryptoEngineAES.KeySize keySize)
		{
			this.Nb = 4;
			if (keySize == CryptoEngineAES.KeySize.Bits128)
			{
				this.Nk = 4;
				this.Nr = 10;
				return;
			}
			if (keySize == CryptoEngineAES.KeySize.Bits192)
			{
				this.Nk = 6;
				this.Nr = 12;
				return;
			}
			if (keySize == CryptoEngineAES.KeySize.Bits256)
			{
				this.Nk = 8;
				this.Nr = 14;
			}
		}
		public CryptoEngineAES(CryptoEngineAES.KeySize keySize, byte[] keyBytes)
		{
			this.SetNbNkNr(keySize);
			this.key = new byte[this.Nk * 4];
			keyBytes.CopyTo(this.key, 0);
			this.Sbox = new byte[,]
			{

				{
					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
				}
			};
			this.iSbox = new byte[,]
			{

				{
					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
				}
			};
			this.Rcon = new byte[,]
			{

				{
					0,
					0,
					0,
					0
				},

				{
					1,
					0,
					0,
					0
				},

				{
					2,
					0,
					0,
					0
				},

				{
					4,
					0,
					0,
					0
				},

				{
					8,
					0,
					0,
					0
				},

				{
					16,
					0,
					0,
					0
				},

				{
					32,
					0,
					0,
					0
				},

				{
					64,
					0,
					0,
					0
				},

				{
					128,
					0,
					0,
					0
				},

				{
					27,
					0,
					0,
					0
				},

				{
					54,
					0,
					0,
					0
				}
			};
			this.KeyExpansion();
		}