des.java

DES算法JAVA实现

				for(x=0;x<16;x++)
				{
					ming_make(x);
					
				}
				af_16=after_16();
				ming_string=ming_string+(char)af_16[0]+(char)af_16[1]+(char)af_16[2]+(char)af_16[3];
			}
			cbcjat.setText(ming_string);
			
		}
		
		
		private void ebcje() {
			short [] temp_s=new short [4];
			 int i;                           
			  String screat_string="";
			                
			for(i=0;i< screat.length;)
			{
				temp_s[0]=screat[i];//选取64bit
				temp_s[1]=screat[i+1];
				temp_s[2]=screat[i+2];
				temp_s[3]=screat[i+3];
				i=i+4;
				int x;
				ming(temp_s);//每64bit初始化一次
				for(x=15;x>=0;x--)
				{
					ming_make(x);
					
				}
				short [] af_16;
				af_16=after_16();

				screat_string=screat_string+(char)af_16[0]+(char)af_16[1]+(char)af_16[2]+(char)af_16[3];
			}
			
			ebcjet.setText(screat_string);

			
		}
		private void ebcja() {
			short [] temp_ming=new short [4];//每次输入64BIT的明文
			String ming_string="";//最后作为输出的密文字符
			short [] ming_short;//保存明文的数组
			int leng;//SHORT数组长度

			
			int i=mingword.length()/4;
			if((mingword.length()%4)!=0)
			{
				leng=i*4+4;
			ming_short=new short[leng];
			int t=0;
			for(;t<mingword.length();t++)
				ming_short[t]=(short)mingword.charAt(t);
			}
			else 
				{
				leng=i*4;
				ming_short=new short [leng];
				int t=0;
				for(;t<mingword.length();t++)
					ming_short[t]=(short)mingword.charAt(t);
				}
			                            
			   
			                              
			for(i=0;i<leng;)
			{
				temp_ming[0]=ming_short[i];//选取64bit
				temp_ming[1]=ming_short[i+1];
				temp_ming[2]=ming_short[i+2];
				temp_ming[3]=ming_short[i+3];
				i=i+4;
				int x;
				ming(temp_ming);//每64bit初始化一次
				for(x=0;x<16;x++)
				{
					ming_make(x);
					
				}
				short [] af_16;
				af_16=after_16();
				ming_string=ming_string+(char)af_16[0]+(char)af_16[1]+(char)af_16[2]+(char)af_16[3];
			}
			ebcjat.setText(ming_string);

		}
		
		
		//把字符串对应的每位0或1状态反映到数组bit里
		public static int[] changebit(short [] income,int size) {
			int i=0;
			int [] state=new int[size];
			for(;i<size;i++) 
			{
				if(testbit(income[i/16],bittest[i%16])==true) state[i]=1;
				else state[i]=0;
			}
			
			return state;
		}

		//测试字符某一位是0还是1
		private static boolean testbit(short c,int testnum) {
			if((c&testnum)==0)  return false;
			else return true;
		}
		
		
		//根据所给位状态组装到字符里
		public static short[] shortmaker(int [] state,int size) {
			short [] c=new short[size/16];
			int i=0;
			for(;i<=size-1;i++)
			{
				if(state[i]==1)
				c[i/16]=(short)((c[(i/16)])|(bittest[(i%16)]));
			}
			return c;
		}
		
		
		
		//置换扩展
		public static int[] ip_extend(int [] state,int [] list,int size)
		{
			int i=0;
			int [] temp=new int [size];
			for(;i<size;i++)
			{
				temp[i]=state[list[i]-1];//扩展置换表从1开始，所以要减1
			}
			
			return temp;
		}
		
		
		//S盒选择:输入Short数组，返回32比特的状态
		public static int[] Sbox(short [] income) {
			int [] S_bitState=new int [48];
			int [] Sbit=new int [32];
			S_bitState=changebit(income,48);
			int i=0,row,column,temp;
			for(;i<8;i++)
			{
				row=row(i,S_bitState);
				column=column(i,S_bitState);
				temp=S[i][row][(column)];
				Sbit[i*4+3]=temp%2;
				Sbit[i*4+2]=(temp/2)%2;
				Sbit[i*4+1]=(temp/4)%2;
				Sbit[i*4]=(temp/8)%2;
			}
			return Sbit;
		}
	
		//计算S盒中的行号
		private static int row(int i,int []S_bitState) {
			if((S_bitState[i*6]==0)&(S_bitState[i*6+5]==0)) return 0;
			else if((S_bitState[i*6]==0)&(S_bitState[i*6+5]==1)) return 1;
			else if((S_bitState[i*6]==1)&(S_bitState[i*6+5]==0)) return 2;
			else return 3;
		}
		
		//计算S盒中的列号
		private static int column(int i,int [] S_bitState) {
			int colunm=0,n=0;
			for(n=1;n<5;n++)
			{
				colunm*=2;
				if(S_bitState[i*6+n]==1)	colunm++;
			}
			return colunm;
		}
		
		//左循环移位
		private static int[] move(int [] income,int i)
		{
			int time=Keymove[i];
			int n=0;
			int [] temp=new int[28];
			for(;n<28;n++)
			temp[n]=income[(n+time)%28];
			return temp;
		}
		
		public static int []key_right =new int [28];
		public static int []key_left=new int [28];
		
		//将KEY分解出状态并转换分为左右两部分。
		public static void  key() {
			int [] keystate=new int [64];
			keystate=changebit(keyword,64);//分解为位状态
			keystate=ip_extend(keystate,PC_1,56);//置换
			int n=0;
			for(;n<28;n++)//分左右部分
			{
				key_left[n]=keystate[n];
				key_right[n]=keystate[n+28];
			}
		}
		
		
		//输入第一次产生的左右部分KEY和需要产生的第i轮生成SHORT数组状态的48位KEY
		public static short[]  keymaker(int i) {
			
			int [] key_right_temp =new int [28];
			int [] key_left_temp=new int [28];
			key_right_temp=move(key_right,i);//移位
			key_left_temp=move(key_left,i);//移位
			int [] temp=new int[56];
			int [] temp2=new int [48];
			int n=0;
			for(;n<28;n++)//移位后组合为56BIT
				{
				temp[n]=key_left_temp[n];				
				temp[28+n]=key_right_temp[n];
				}
			
			temp2=ip_extend(temp,PC_2,48);//转换为48BIT
			
			short [] Kshort=new short [3];
			Kshort=shortmaker(temp2,48);//整合成为SHORT数组
			
			return Kshort;
	}
		

		
		public  static int [] m_right_bit =new int [32];
		public  static int [] m_left_bit =new int [32];
		
		public static short [] rightm=new short[2];		
		public static short [] leftm=new short[2];
		
		
		//分解输入的明文，并分为左右部分状态
		public static void ming(short []income) {
			int [] temp=new int [64];
			
			temp=changebit(income,64);// 转换为位状态
			temp=ip_extend(temp,IP,64);//IP转换
			
			int i=0;//分左右部分
			for(;i<32;i++) {
				m_left_bit[i]=temp[i];
				m_right_bit[i]=temp[32+i];
			}		
			
			rightm=shortmaker(m_right_bit,32);
			leftm=shortmaker(m_left_bit,32);
			
		}

		
		//生成每轮的左右密文short数组（修改rigntm,leftm)
		public  void ming_make(int time) {
			short [] temp=new short[2];

			
			short [] lefttemp=new short[2];//备份LEFTM
			lefttemp[0]=leftm[0];
			lefttemp[1]=leftm[1];
			
			
			//leftm=shortmaker(temp,m_right_bit,32);//右变左产生下一次的左部
			leftm[0]=rightm[0];
			leftm[1]=rightm[1];
			
			
			int [] ex=new int[48];
			int [] sbit =new int [32];
			short [] exshort=new short[3];
			
			ex=ip_extend(m_right_bit,Extend,48);//扩展
			
			exshort=shortmaker(ex,48);//转换为Shotr数组方便异或
			int i=0;
			for(;i<3;i++)//与生成的KEY异或
				exshort[i]=(short)(exshort[i]^keymaker(time)[i]);
			
			
			sbit=Sbox(exshort);//s盒选择
			sbit=ip_extend(sbit,P,32);//P置换
			temp=shortmaker(sbit,32);//整合为SHORT数组
			for(i=0;i<2;i++)//与左部分异或产生下一轮的右部
				rightm[i]=(short)(lefttemp[i]^temp[i]);
			
		//更变左右部分的位状态数组
			m_left_bit=changebit(leftm,32);
			m_right_bit=changebit(rightm,32);
		}
		
		
		public short[] after_16() {

			int i=0;
			int [] state=new int [64];
			for(;i<32;i++)
			{
				state[i]=m_right_bit[i];
				state[i+32]=m_left_bit[i];
			}
			state=ip_extend(state,IP_1,64);
			
			short [] ming=new short[4];
			ming=shortmaker(state,64);
			return ming;
			
		}

	}