des.java

java 字符加密系统, 可以对64位的任意字符进行加密解密

				           else if(i==6)
				         yyy[3][0]=(byte)sbox7[m][n];
				           else if(i==7)
				         yyy[3][1]=(byte)sbox8[m][n];
				 }    
				          for(int i=0;i<4;i++)
				        	for(int j=1;j>-1;j--)
		    		        	for(int k=0;k<4;k++){
		    		      xxx[i][3+4*j-k]=(byte)(yyy[i][j]&0x01);
		                              yyy[i][j]>>=1;          
		                        }
				         return xxx;
		}   
//		置换perm
			public byte[][] Perm(byte[][] temp){
			 byte[][]b=new byte[4][8];
			   b[0][0]=temp[1][7];
			   b[0][1]=temp[0][6];
			   b[0][2]=temp[2][3];
			   b[0][3]=temp[2][4];
			   b[0][4]=temp[3][4];
			   b[0][5]=temp[1][3];
			   b[0][6]=temp[3][3];
			   b[0][7]=temp[2][0];
			   
			   b[1][0]=temp[0][0];
			   b[1][1]=temp[1][6];
			   b[1][2]=temp[2][6];
			   b[1][3]=temp[3][1];
			   b[1][4]=temp[0][4];
			   b[1][5]=temp[2][1];
			   b[1][6]=temp[3][6];
			   b[1][7]=temp[1][1];
			   
			   b[2][0]=temp[0][1];
			   b[2][1]=temp[0][7];
			   b[2][2]=temp[2][7];
			   b[2][3]=temp[1][5];
			   b[2][4]=temp[3][7];
			   b[2][5]=temp[3][2];
			   b[2][6]=temp[0][2];
			   b[2][7]=temp[1][0];
			   
			   b[3][0]=temp[2][2];
			   b[3][1]=temp[1][4];
			   b[3][2]=temp[3][5];
			   b[3][3]=temp[0][5];
			   b[3][4]=temp[2][5];
			   b[3][5]=temp[1][2];
			   b[3][6]=temp[0][3];
			   b[3][7]=temp[3][0];
			   
			    return b;
			}
//		XOR2
			public void XOR2(byte[][] b, byte[][] c){
			    for(int i=0;i<4;i++)
				for(int j=0;j<8;j++)
				c[i][j]^=b[i][j];
			}
//		最终置换函数
			public byte[][] IP2(byte[][]b,byte[][]c){
				 byte[][]result=new byte[8][8];
//		 b对应Lpart,c对应Rpart
				result[0][0]=c[0][7];
				result[0][1]=b[0][7];
				result[0][2]=c[1][7];
				result[0][3]=b[1][7];
				result[0][4]=c[2][7];
				result[0][5]=b[2][7];
				result[0][6]=c[3][7];
				result[0][7]=b[3][7];
				
				result[1][0]=c[0][6];
				result[1][1]=b[0][6];
				result[1][2]=c[1][6];
				result[1][3]=b[1][6];
				result[1][4]=c[2][6];
				result[1][5]=b[2][6];
				result[1][6]=c[3][6];
				result[1][7]=b[3][6];
				
		        result[2][0]=c[0][5];
				result[2][1]=b[0][5];
				result[2][2]=c[1][5];
				result[2][3]=b[1][5];
				result[2][4]=c[2][5];
				result[2][5]=b[2][5];
				result[2][6]=c[3][5];
				result[2][7]=b[3][5];
				
		        result[3][0]=c[0][4];
				result[3][1]=b[0][4];
				result[3][2]=c[1][4];
				result[3][3]=b[1][4];
				result[3][4]=c[2][4];
				result[3][5]=b[2][4];
				result[3][6]=c[3][4];
				result[3][7]=b[3][4];
				
		        result[4][0]=c[0][3];
				result[4][1]=b[0][3];
				result[4][2]=c[1][3];
				result[4][3]=b[1][3];
				result[4][4]=c[2][3];
				result[4][5]=b[2][3];
				result[4][6]=c[3][3];
				result[4][7]=b[3][3];

				result[5][0]=c[0][2];
				result[5][1]=b[0][2];
				result[5][2]=c[1][2];
				result[5][3]=b[1][2];
				result[5][4]=c[2][2];
				result[5][5]=b[2][2];
				result[5][6]=c[3][2];
				result[5][7]=b[3][2];
				
				result[6][0]=c[0][1];
				result[6][1]=b[0][1];
				result[6][2]=c[1][1];
				result[6][3]=b[1][1];
				result[6][4]=c[2][1];
				result[6][5]=b[2][1];
				result[6][6]=c[3][1];
				result[6][7]=b[3][1];
				
				result[7][0]=c[0][0];
				result[7][1]=b[0][0];
				result[7][2]=c[1][0];
				result[7][3]=b[1][0];
				result[7][4]=c[2][0];
				result[7][5]=b[2][0];
				result[7][6]=c[3][0];
				result[7][7]=b[3][0];
				
		        return result;
		}
			
//		***************cipherkey处理部分***************
		 //PC1函数
			public byte[][] PC1(byte[][] temp){
				 byte[][]b=new byte[8][7];
				b[0][0]=temp[7][0];       
				b[0][1]=temp[6][0];
				b[0][2]=temp[5][0];
				b[0][3]=temp[4][0];
				b[0][4]=temp[3][0];
				b[0][5]=temp[2][0];
				b[0][6]=temp[1][0];
				
			    b[1][0]=temp[0][0];
				b[1][1]=temp[7][1];
				b[1][2]=temp[6][1];
				b[1][3]=temp[5][1];
				b[1][4]=temp[4][1];
				b[1][5]=temp[3][1];
				b[1][6]=temp[2][1];
				
				b[2][0]=temp[1][1];
				b[2][1]=temp[0][1];
				b[2][2]=temp[7][2];
				b[2][3]=temp[6][2];
				b[2][4]=temp[5][2];
				b[2][5]=temp[4][2];
				b[2][6]=temp[3][2];
				
				b[3][0]=temp[2][2];
				b[3][1]=temp[1][2];
				b[3][2]=temp[0][2];
				b[3][3]=temp[7][3];
				b[3][4]=temp[6][3];
				b[3][5]=temp[5][3];
				b[3][6]=temp[4][3];
				
				b[4][0]=temp[7][6];
				b[4][1]=temp[6][6];
				b[4][2]=temp[5][6];
				b[4][3]=temp[4][6];
				b[4][4]=temp[3][6];
				b[4][5]=temp[2][6];
				b[4][6]=temp[1][6];
				
				b[5][0]=temp[0][6];
				b[5][1]=temp[7][5];
				b[5][2]=temp[6][5];
				b[5][3]=temp[5][5];
				b[5][4]=temp[4][5];
				b[5][5]=temp[3][5];
				b[5][6]=temp[2][5];
				
				b[6][0]=temp[1][5];
				b[6][1]=temp[0][5];
				b[6][2]=temp[7][4];
				b[6][3]=temp[6][4];
				b[6][4]=temp[5][4];
				b[6][5]=temp[4][4];
				b[6][6]=temp[3][4];
				
				b[7][0]=temp[2][4];
				b[7][1]=temp[1][4];
				b[7][2]=temp[0][4];
				b[7][3]=temp[3][3];
				b[7][4]=temp[2][3];
				b[7][5]=temp[1][3];
				b[7][6]=temp[0][3];
				
				return b;
		}
//		LeftShift函数
			public void LS(byte[][]b2){
				byte temp;
				temp=b2[0][0];
				for(int i=0;i<4;i++)
					for(int j=0;j<6;j++){
						b2[i][j]=b2[i][j+1];
					   if(i==3)
						continue;
					   if(j==5)
						b2[i][6]=b2[i+1][0];
					}
				b2[3][6]=temp;
		}
//		PC2函数
		public byte[][] PC2(byte [][]c,byte[][]d){
			    byte[][]result=new byte[8][6];
			     
			 result[0][0]=c[1][6];	
			 result[0][1]=c[2][2];
			 result[0][2]=c[1][3];
			 result[0][3]=c[3][2];
			 result[0][4]=c[0][0];
			 result[0][5]=c[0][4];
			 
			 result[1][0]=c[0][2];
			 result[1][1]=c[3][6];
			 result[1][2]=c[2][0];
			 result[1][3]=c[0][5];
			 result[1][4]=c[2][6];
			 result[1][5]=c[1][2];
			 
			 result[2][0]=c[3][1];
			 result[2][1]=c[2][4];
			 result[2][2]=c[1][4];
			 result[2][3]=c[0][3];
			 result[2][4]=c[3][4];
			 result[2][5]=c[1][0];
			 
			 result[3][0]=c[2][1];
			 result[3][1]=c[0][6];
			 result[3][2]=c[3][5];
			 result[3][3]=c[2][5];
			 result[3][4]=c[1][5];
			 result[3][5]=c[0][1];
			 
			 result[4][0]=d[1][5];
			 result[4][1]=d[3][2];
			 result[4][2]=d[0][2];
			 result[4][3]=d[1][1];
			 result[4][4]=d[2][4];
			 result[4][5]=d[3][5];
			 
			 result[5][0]=d[0][1];
			 result[5][1]=d[1][4];
			 result[5][2]=d[3][1];
			 result[5][3]=d[2][2];
			 result[5][4]=d[0][4];
			 result[5][5]=d[2][5];
			 
			 result[6][0]=d[2][1];
			 result[6][1]=d[2][6]; 
			 result[6][2]=d[1][3];
			 result[6][3]=d[3][6];
			 result[6][4]=d[0][5];
			 result[6][5]=d[3][3];
			 
			 result[7][0]=d[2][3];
			 result[7][1]=d[1][6];
			 result[7][2]=d[3][0];
			 result[7][3]=d[1][0];
			 result[7][4]=d[0][0];
			 result[7][5]=d[0][3];
			
			 return result;
		    }
			
		}