javades.txt

用java实现的加密算法

package des;

import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;

public class FileDES{
	private static final boolean enc=true;    //加密
	private static final boolean dec=false;	  //解密
	
	private String srcFileName;
	private String destFileName;
	private String inKey;
	private boolean actionType;
	private File srcFile;
	private File destFile;	
	private Des des;
	
	private void analyzePath(){
		String dirName;
		int pos=srcFileName.lastIndexOf("/");
		dirName=srcFileName.substring(0,pos);
		File dir=new File(dirName);
		if (!dir.exists()){
			System.err.println(dirName+" is not exist");
			System.exit(1);
		}else if(!dir.isDirectory()){
			System.err.println(dirName+" is not a directory");
			System.exit(1);
		}
		
		pos=destFileName.lastIndexOf("/");
		dirName=destFileName.substring(0,pos);
		dir=new File(dirName);
		if (!dir.exists()){
			if(!dir.mkdirs()){
				System.out.println ("can not creat directory:"+dirName);
				System.exit(1);
			}
		}else if(!dir.isDirectory()){
			System.err.println(dirName+" is not a directory");
			System.exit(1);
		}
	}
	
	private static int replenish(FileChannel channel,ByteBuffer buf) throws IOException{
		long byteLeft=channel.size()-channel.position();
		if(byteLeft==0L)
			return -1;
		buf.position(0);
		buf.limit(buf.position()+(byteLeft<8 ? (int)byteLeft :8));
		return channel.read(buf);
	}
	
	private void file_operate(boolean flag){
		des=new Des(inKey);
		FileOutputStream outputFile=null;
		try {
			outputFile=new FileOutputStream(srcFile,true);
	    }catch (java.io.FileNotFoundException e) {
	    	e.printStackTrace(System.err);
	    }
	    FileChannel outChannel=outputFile.getChannel();
	    
	    try{
		    if(outChannel.size()%2!=0){
				ByteBuffer bufTemp=ByteBuffer.allocate(1);
				bufTemp.put((byte)32);
				bufTemp.flip();			
				outChannel.position(outChannel.size());
				outChannel.write(bufTemp);
		    	bufTemp.clear();		
			}
		}catch(Exception ex){
			ex.printStackTrace(System.err);
			System.exit(1);
		}
		FileInputStream inFile=null;
		try{
			inFile=new FileInputStream(srcFile);
		}catch(java.io.FileNotFoundException e){
			e.printStackTrace(System.err);
			//System.exit(1);
		}
		outputFile=null;
		try {
			outputFile=new FileOutputStream(destFile,true);
	    }catch (java.io.FileNotFoundException e) {
	    	e.printStackTrace(System.err);
	    }
	    
	    FileChannel inChannel=inFile.getChannel();
		outChannel=outputFile.getChannel();
		
		
		ByteBuffer inBuf=ByteBuffer.allocate(8);
		ByteBuffer outBuf=ByteBuffer.allocate(8);
		
		try{
			String srcStr;
			String destStr;
			while(true){
			
				if (replenish(inChannel,inBuf)==-1) break;
				srcStr=((ByteBuffer)(inBuf.flip())).asCharBuffer().toString();
				inBuf.clear();
				if (flag)
					destStr=des.enc(srcStr,srcStr.length());
				else
					destStr=des.dec(srcStr,srcStr.length());
			    outBuf.clear();
			    if (destStr.length()==4){
			    	for (int i = 0; i<4; i++) {
	    				outBuf.putChar(destStr.charAt(i));
	    			}
			    	outBuf.flip();
			    }else{
			    	outBuf.position(0);
			    	outBuf.limit(2*destStr.length());
			    	for (int i = 0; i<destStr.length(); i++) {
	    				outBuf.putChar(destStr.charAt(i));
	    			}
			    	outBuf.flip();
			    }
			    
			    try {
	    			outChannel.write(outBuf);
	    			outBuf.clear();
	    		}catch (java.io.IOException ex) {
	    			ex.printStackTrace(System.err);
	    		}
			}
			System.out.println (inChannel.size());
	    	System.out.println (outChannel.size());
			System.out.println ("EoF reached.");
			inFile.close();
			outputFile.close();
		}catch(java.io.IOException e){
			e.printStackTrace(System.err);
			System.exit(1);
		}	
	}

	public FileDES(String srcFileName,String destFileName,String inKey,boolean actionType){
		this.srcFileName=srcFileName;
		this.destFileName=destFileName;		
		this.actionType=actionType;
		analyzePath();
		srcFile=new File(srcFileName);
		destFile=new File(destFileName);		
		this.inKey=inKey;
		if (actionType==enc)
			file_operate(enc);
		else
			file_operate(dec);
	}
	
	
	public static void main(String[] args){
		String file1=System.getProperty("user.dir")+"/111.doc";
		String file2=System.getProperty("user.dir")+"/222.doc";
		String file3=System.getProperty("user.dir")+"/333.doc";
		String passWord="1234ABCD";
		FileDES fileDes=new FileDES(file1,file2,passWord,true);
		FileDES fileDes1=new FileDES(file2,file3,passWord,false);
	}
	
}


package des;

public class SubKey {
  private String inKey;
  private StringBuffer keyBuf;
  private byte[] key=new byte[64];
  /*实验性数据
  private static byte[] key={
  0,0,0,1,0,0,1,1, 0,0,1,1,0,1,0,0, 0,1,0,1,0,1,1,1, 0,1,1,1,1,0,0,1,
  1,0,0,1,1,0,1,1, 1,0,1,1,1,1,0,0, 1,1,0,1,1,1,1,1,1,1,1,1,0,0,0,1
  };
  */
  private byte[] kwork=new byte[56];
  private static byte[] shift={	1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
  protected byte[] k1=new byte[48];
  protected byte[] k2=new byte[48];
  protected byte[] k3=new byte[48];
  protected byte[] k4=new byte[48];
  protected byte[] k5=new byte[48];
  protected byte[] k6=new byte[48];
  protected byte[] k7=new byte[48];
  protected byte[] k8=new byte[48];
  protected byte[] k9=new byte[48];
  protected byte[] k10=new byte[48];
  protected byte[] k11=new byte[48];
  protected byte[] k12=new byte[48];
  protected byte[] k13=new byte[48];
  protected byte[] k14=new byte[48];
  protected byte[] k15=new byte[48];
  protected byte[] k16=new byte[48];  
  protected byte[] kn=new byte[48];
  
  public SubKey(String inKey) {
  	
  	byte j;
  	this.inKey=inKey;
  	int len=inKey.length();
  	
  	//密钥必须是8位，若小于8位不够的补空格 ，大于8位取前8位
  	keyBuf=new StringBuffer(inKey);
  	if (len<8){ 
  		for (int i = 1; i<=8-len; i++)
  			keyBuf.append("?");
	}	
  	inKey=keyBuf.toString();
  	
  	//将8个字符的密钥转换成64位二进制表示
  	for (int i = 0; i<8; i++) {
  		j=(byte)(inKey.charAt(i));
  		key[8*i]=(byte)((j/128)%2);
  		key[8*i+1]=(byte)((j/64)%2);
  		key[8*i+2]=(byte)((j/32)%2);
  		key[8*i+3]=(byte)((j/16)%2);
  		key[8*i+4]=(byte)((j/8)%2);
  		key[8*i+5]=(byte)((j/4)%2);
  		key[8*i+6]=(byte)((j/2)%2);
  		key[8*i+7]=(byte)(j%2);
	}
	/* Initial Permutation of Key */ 
	kwork[ 0] = key[56]; 
	kwork[ 1] = key[48]; 
	kwork[ 2] = key[40]; 
	kwork[ 3] = key[32]; 
	kwork[ 4] = key[24]; 
	kwork[ 5] = key[16]; 
	kwork[ 6] = key[ 8]; 
	kwork[ 7] = key[ 0]; 
	kwork[ 8] = key[57]; 
	kwork[ 9] = key[49]; 
	kwork[10] = key[41]; 
	kwork[11] = key[33]; 
	kwork[12] = key[25]; 
	kwork[13] = key[17]; 
	kwork[14] = key[ 9]; 
	kwork[15] = key[ 1]; 
	kwork[16] = key[58]; 
	kwork[17] = key[50]; 
	kwork[18] = key[42]; 
	kwork[19] = key[34]; 
	kwork[20] = key[26]; 
	kwork[21] = key[18]; 
	kwork[22] = key[10]; 
	kwork[23] = key[ 2]; 
	kwork[24] = key[59]; 
	kwork[25] = key[51]; 
	kwork[26] = key[43]; 
	kwork[27] = key[35]; 
	kwork[28] = key[62]; 
	kwork[29] = key[54]; 
	kwork[30] = key[46]; 
	kwork[31] = key[38]; 
	kwork[32] = key[30]; 
	kwork[33] = key[22]; 
	kwork[34] = key[14]; 
	kwork[35] = key[ 6]; 
	kwork[36] = key[61]; 
	kwork[37] = key[53]; 
	kwork[38] = key[45]; 
	kwork[39] = key[37]; 
	kwork[40] = key[29]; 
	kwork[41] = key[21]; 
	kwork[42] = key[13]; 
	kwork[43] = key[ 5]; 
	kwork[44] = key[60]; 
	kwork[45] = key[52]; 
	kwork[46] = key[44]; 
	kwork[47] = key[36]; 
	kwork[48] = key[28]; 
	kwork[49] = key[20]; 
	kwork[50] = key[12]; 
	kwork[51] = key[ 4]; 
	kwork[52] = key[27]; 
	kwork[53] = key[19]; 
	kwork[54] = key[11]; 
	kwork[55] = key[ 3]; 
	
	/* 子键计算开始*/ 
	byte nbrofshift;
	byte temp1,temp2;
	for (int iter = 0; iter<16; iter++) {
		nbrofshift = shift[iter]; 
		for (int i = 0; i < (int) nbrofshift; i++) { 
			temp1 = kwork[0]; 
			temp2 = kwork[28]; 
			for (int k = 0; k < 27; k++) { 
				kwork[k] = kwork[k+1]; 
				kwork[k+28] = kwork[k+29]; 
			} 
			kwork[27] = temp1; 
			kwork[55] = temp2; 
		} 
		/* Permute kwork - PC2 */ 
		kn[ 0] = kwork[13]; 
		kn[ 1] = kwork[16]; 
		kn[ 2] = kwork[10]; 
		kn[ 3] = kwork[23]; 
		kn[ 4] = kwork[ 0]; 
		kn[ 5] = kwork[ 4]; 
		kn[ 6] = kwork[ 2]; 
		kn[ 7] = kwork[27]; 
		kn[ 8] = kwork[14]; 
		kn[ 9] = kwork[ 5]; 
		kn[10] = kwork[20]; 
		kn[11] = kwork[ 9]; 
		kn[12] = kwork[22]; 
		kn[13] = kwork[18]; 
		kn[14] = kwork[11]; 
		kn[15] = kwork[ 3]; 
		kn[16] = kwork[25]; 
		kn[17] = kwork[ 7]; 
		kn[18] = kwork[15]; 
		kn[19] = kwork[ 6]; 
		kn[20] = kwork[26]; 
		kn[21] = kwork[19]; 
		kn[22] = kwork[12]; 
		kn[23] = kwork[ 1]; 
		kn[24] = kwork[40]; 
		kn[25] = kwork[51]; 
		kn[26] = kwork[30]; 
		kn[27] = kwork[36]; 
		kn[28] = kwork[46]; 
		kn[29] = kwork[54]; 
		kn[30] = kwork[29]; 
		kn[31] = kwork[39]; 
		kn[32] = kwork[50]; 
		kn[33] = kwork[44]; 
		kn[34] = kwork[32]; 
		kn[35] = kwork[47]; 
		kn[36] = kwork[43]; 
		kn[37] = kwork[48]; 
		kn[38] = kwork[38]; 
		kn[39] = kwork[55]; 
		kn[40] = kwork[33]; 
		kn[41] = kwork[52]; 
		kn[42] = kwork[45]; 
		kn[43] = kwork[41]; 
		kn[44] = kwork[49]; 
		kn[45] = kwork[35]; 
		kn[46] = kwork[28]; 
		kn[47] = kwork[31]; 
		/*
		for (int i = 0; i<48; i++) {
			if (i%6==0) System.out.print(" ");
			System.out.print(kn[i]);
	    }
		System.out.println ();
		*/
		switch(iter){
			case 0:
				for (int k = 0; k<48;k++) { k1[k]=kn[k]; }
				break;
			case 1:
				for (int k = 0; k<48;k++) { k2[k]=kn[k]; }
				break;
			case 2:
				for (int k = 0; k<48;k++) { k3[k]=kn[k]; }
				break;
			case 3:
				for (int k = 0; k<48;k++) { k4[k]=kn[k]; }
				break;
			case 4:
				for (int k = 0; k<48;k++) { k5[k]=kn[k]; }
				break;
			case 5:
				for (int k = 0; k<48;k++) { k6[k]=kn[k]; }
				break;
			case 6:
				for (int k = 0; k<48;k++) { k7[k]=kn[k]; }
				break;
			case 7:
				for (int k = 0; k<48;k++) { k8[k]=kn[k]; }
				break;
			case 8:
				for (int k = 0; k<48;k++) { k9[k]=kn[k]; }
				break;
			case 9:
				for (int k = 0; k<48;k++) { k10[k]=kn[k]; }
				break;
			case 10:
				for (int k = 0; k<48;k++) { k11[k]=kn[k]; }
				break;
			case 11:
				for (int k = 0; k<48;k++) { k12[k]=kn[k]; }
				break;
			case 12:
				for (int k = 0; k<48;k++) { k13[k]=kn[k]; }
				break;
			case 13: