AES算法实现_加密 JAVA-优快云博客

本文链接：https://blog.youkuaiyun.com/l799069596/article/details/50280071

AES算法实现_加密 JAVA128位版

项目下载：http://download.youkuaiyun.com/detail/l799069596/9378764

package scr;

/**
 * AES加密核心算法
 * @author laisixiang
 *
 */

public class Encrypt {
	public static int[][] step1(int[][] org,int n){//轮秘钥加换
		int out[][] = new int[4][4];
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				out[i][j]=org[i][j]^KeyExtend.realKey(n)[i][j];
			}
		}
		return out;
	}
	
	public static int[][] step2(int[][] org){//字节替代
		int out[][] = new int[4][4];
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				out[i][j]=Configrations.S[org[i][j]>>>4][org[i][j]-((org[i][j]>>>4)<<4)];
			}
		}
		return out;

	}
	
	public static int[][] step3(int[][] org){//行移位
		int out[][] = new int[4][4];
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				out[i][j]=org[i][(j+i)%4];
			}
		}
		return out;
	}
	
	public static int[][] step4(int[][] org){//列混淆
		int out[][] = new int[4][4];
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				out[i][j]=myMultiply(Configrations.key2[i][0], org[0][j]);
				for(int z=1;z<4;z++){
					out[i][j]^=myMultiply(Configrations.key2[i][z],org[z][j]);
				}
			}
		}
		return out;
	}
	
	public static int myMultiply(int a,int b){//列混淆时用的，在mod下的矩阵间乘法
		int back=0;
		int position=0;
		while(a!=0){
			if(a%2==1){
				back=(b<<position)^back;
			}
			position+=1;
			a=a>>>1;
		}
		
		while(back/256>=1){
			back=(Configrations.myMod<<((back/256)-1))^back;
		}
		return back;
	}
	
	public static int[][] encrypt(int[][] org){//加密
		int time=0;
		int temp[][]= new int[4][4];
		temp=step1(org,time);
		for(int i=0;i<9;i++){
			time=+1;
			temp=step1(step4(step3(step2(temp))),time);
		}
		return step1(step3(step2(temp)),time);
	}
}

package scr;
/**
 * 秘钥扩展
 * @author laisixiang
 *
 */
public class KeyExtend {
	public static int[] transform_32byteToFourWord(int[][] org){//矩阵转变为4个字，纵向
		int temp[] = new int[4];
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				temp[i]+=(org[j][i]<<(8*(3-j)));
			}
		}
		return temp;
	}
	
	public static int g(int org,int n){//G函数
		int temp[] = new int[4];
		//把一个字转化为4个字节
		temp[0]=org>>>24;
		for(int i=1;i<4;i++){
			temp[i]=(org>>>(8*(3-i)))-((org>>>(8*(4-i)))<<8);
		}
		//字循环
		int temp_int=temp[0];
		for(int i=0;i<3;i++){
			temp[i]=temp[i+1];
		}
		temp[3]=temp_int;
		//字节替代
		for(int i=0;i<4;i++){
			temp[i]=Configrations.S[temp[i]>>>4][temp[i]-((temp[i]>>>4)<<4)];
		}
		//Rcon生成
		int rcon=1;
		for(int i=1;i<n;i++){
			rcon=myMultiply(2, rcon);
		}
		//与Rcon异或
		temp[0]^=rcon;
		//把4个字节转化为一个数
		int out=0;
		for(int i=0;i<4;i++){
			out+=temp[i]<<(8*(3-i));
		}

		return out;
	}
	
	public static int[] createKeyInFourWord(int n){//密匙扩展的规则
		int org[] = new int[4];
		int out[] = new int[4];
		org=transform_32byteToFourWord(Configrations.key);

		if(n!=0){
			for(int i=1;i<=n;i++){
				for(int j=0;j<4;j++){
					if(j==0){
						out[j]=org[j]^(g(org[3], i));
					}else{
						out[j]=org[j]^out[j-1];
					}
				}
				org=out;
			}
		}else{
			return org;
		}
		return out;
	}
	
	public static int[][] realKey(int n){//把一维数组转为二维数组，恢复
		int in[] = new int[4];
		in=createKeyInFourWord(n);
		int out[][] = new int[4][4];
		for(int i=0;i<4;i++){
			out[0][i]=in[i]>>>24;
			for(int j=1;j<4;j++){
				out[j][i] = (in[i]>>(8*(3-j)))-(in[i]>>(8*(4-j))<<8);
			}
		}
		return out;
	}
	
	public static int myRcon_before(int n){//求Rcon（n）的核心函数，用回调
		if(n==1)
			return 1;
		return (myMultiply(2, myRcon_before(n-1)));
	}
	public static int myRcon(int n){//求Rcon（n）
		return myRcon_before(n)<<24;
	}
	
	public static int myMultiply(int a,int b){//列混淆时用的，在mod下的矩阵间乘法
		int back=0;
		int position=0;
		while(a!=0){
			if(a%2==1){
				back=(b<<position)^back;
			}
			position+=1;
			a=a>>>1;
		}
		
		while(back/256>=1){
			back=(Configrations.myMod<<((back/256)-1))^back;
		}
		return back;
	}
}

package scr;
/**
 * 各个参数
 * @author laisixiang
 *
 */
public class Configrations {
	public final static int msg[][] = {//原文128位
		{0x0,0x4,0x8,0xC},
		{0x1,0x5,0x9,0xD},
		{0x2,0x6,0xA,0xE},
		{0x3,0x7,0xB,0xF}};

	public final static int key[][] = {//密匙128位
		{0x1,0x1,0x1,0x1},
		{0x1,0x1,0x1,0x1},
		{0x1,0x1,0x1,0x1},
		{0x1,0x1,0x1,0x1}};
	
//	//验证密匙扩展算法的时候用
//	public final static int key[][] = {//密匙128位
//		{0x0f,0x47,0x0C,0xAF},
//		{0x15,0xD9,0xB7,0x7F},
//		{0x71,0xe8,0xad,0x67},
//		{0xC9,0x59,0xD6,0x98}};

	public final static int key2[][] = {//列混淆时用的矩阵
		{0x2,0x3,0x1,0x1},
		{0x1,0x2,0x3,0x1},
		{0x1,0x1,0x2,0x3},
		{0x3,0x1,0x1,0x2}};

	public final static int myMod=283;//列混淆里的Mod

	public final static int S[][] = {//正S盒
		{0X63,0X7C,0X77,0X7B,0XF2,0X6B,0X6F,0XC5,0X30,0X01,0X67,0X2B,0XFE,0XD7,0XAB,0X76},
		{0XCA,0X82,0XC9,0X7D,0XFA,0X59,0X47,0XF0,0XAD,0XD4,0XA2,0XAF,0X9C,0XA4,0X72,0XC0},
		{0XB7,0XFD,0X93,0X26,0X36,0X3F,0XF7,0XCC,0X34,0XA5,0XE5,0XF1,0X71,0XD8,0X31,0X15},
		{0X04,0XF7,0X23,0XC3,0X18,0X96,0X05,0X9A,0X07,0X12,0X80,0XE2,0XEB,0X27,0XB2,0X75},
		{0X09,0X83,0X2C,0X1A,0X1B,0X6E,0X5A,0XA0,0X52,0X3B,0XD6,0XB3,0X29,0XE3,0X2F,0X84},
		{0X53,0XD1,0X00,0XED,0X20,0XFC,0XB1,0X5B,0X6A,0XCB,0XBE,0X39,0X4A,0X4C,0X58,0XCF},
		{0XD0,0XEF,0XAA,0XFB,0X43,0X4D,0X33,0X85,0X45,0XF9,0X02,0X7F,0X50,0X3C,0X9F,0XA8},
		{0X51,0XA3,0X40,0X8F,0X92,0X9D,0X38,0XF5,0XBC,0XB6,0XDA,0X21,0X10,0XFF,0XF3,0XD2},
		{0XCD,0X0C,0X13,0XEC,0X5F,0X97,0X44,0X17,0XC4,0XA7,0X7E,0X3D,0X64,0X5D,0X19,0X73},
		{0X60,0X81,0X4F,0XDC,0X22,0X2A,0X90,0X88,0X46,0XEE,0XB8,0X14,0XDE,0X5E,0X0B,0XDB},
		{0XE0,0X32,0X3A,0X0A,0X49,0X06,0X24,0X5C,0XC2,0XD3,0XAC,0X62,0X91,0X95,0XE4,0X79},
		{0XE7,0XC8,0X37,0X6D,0X8D,0XD5,0X4E,0XA9,0X6C,0X56,0XF4,0XEA,0X65,0X7A,0XAE,0X08},
		{0XBA,0X78,0X25,0X2E,0X1C,0XA6,0XB4,0XC6,0XE8,0XDD,0X74,0X1F,0X4B,0XBD,0X8B,0X8A},
		{0X70,0X3E,0XB5,0X66,0X48,0X03,0XF6,0X0E,0X61,0X35,0X57,0XB9,0X86,0XC1,0X1D,0X9E},
		{0XE1,0XF8,0X98,0X11,0X69,0XD9,0X8E,0X94,0X9B,0X1E,0X87,0XE9,0XCE,0X55,0X28,0XDF},
		{0X8C,0XA1,0X89,0X0D,0XBF,0XE6,0X42,0X68,0X41,0X99,0X2D,0X0F,0XB0,0X54,0XBB,0X16},
	};
	
	
}