des统计信息代码

这是des报告的代码，一共2个java文件，复制粘贴就可以啦~

//BitsArray.java
package my_src;
import java.io.*;
import java.util.Random;
public class BitsArray {
	/**
	 * 随机生成64位字符串，如01111111...(64位)
	 */
//	public BitsArray(String bits) {
//		super();
//		this.bits = new byte[64];
//	}
//	public static String RandomBits() {
//		String s="";
//		Random random=new Random();
//		int c=random.nextInt();
//		int d=random.nextInt();
//		s+=Integer.toBinaryString(c)+Integer.toBinaryString(d);
//		int total=64-s.length();
//		for(int i=0;i<total;i++) {
//			s="0"+s;
//		}
//		return s;
//	}

	/**
	 * 将字节数组bs输出为16进制串
	 */
	public static String ByteArrayToHex(byte[] bs)
	{
		StringBuilder res = new  StringBuilder();
		for(byte b: bs)
		{
			res.append(String.format("%02X ", new Integer(b & 0xff)));
		}
			
		return res.toString();
	}
	/**
	 * 
	 */
	private static byte binaryToByte(String inHex) {
        return (byte)Integer.parseUnsignedInt(inHex,2);
    }

	/**
	 * 二进制字符串转字节数组
	 */
	public static byte[] binaryToByteArray(String inHex){
        int hexlen = inHex.length();
        byte[] result = null;    
        result = new byte[(hexlen/8)];
        int j=0;
        for (int i = 0; i < hexlen; i+=8){
        	String s=inHex.substring(i,i+8);
            result[j]=binaryToByte(s);
            j++;
        }
        return result;
    }
/**
 * 统计不同的字符个数
 */
	public static int compare(String output1,String output2){
		char[] out1 = output1.toCharArray();
        char[] out2 = output2.toCharArray();
        int count = 0;
        for(int i=0;i<output1.length();i++){
            if(out1[i] != out2[i]) count++;
        }
        return count;
    }
/**
 * 把字节数组转换成字符串
 * @param bs
 * @return
 */
	public static String bitsToString(byte[] bs) {
		String str="";
//		这里的8是因为一位byte有8位
		for(int i=0;i<8;i++)
		{
			if(bs[i]<0) {
				bs[i]+=128;
			}
			String s=Integer.toBinaryString(bs[i]);
			if(s.length()<8) {
				int total=8-s.length();
				for(int j=0;j<total;j++)
					s='0'+s;
			}
			str=str+s;
			s="";
		}
		
		return str;
	}
	/**
	 * 对字符串str随机改变number位
	 */
	public static String toggleStringBit(String str,int number) {
		char[] c=str.toCharArray();
		Random r=new Random();
		int rand=0;
		for(int i=0;i<number;i++) {
			rand=r.nextInt(c.length);
			c[rand]=(char)c[rand]>'0'?'0':'1';
		}
		String s="";
		for(int i=0;i<str.length();i++) {
			s=s+c[i];
		}
		return s;		
	}
}

//des_statics.java
package my_src;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import static my_src.BitsArray.*;

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
public class des_statistic {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Cipher des = null;
		
		// 存放 密钥
		byte[] des_key = new byte[8];
		
		// 存放 明文
		byte[] des_input = new byte[8];
		
		// 存放 加密后的输出
		byte[] des_output = null;
		
		for(int i=0; i < 8; i++)
		{
			des_key[i] = 0x11;
			des_input[i] = 0x11;
		}
		
		SecretKey secretKey = new SecretKeySpec(des_key, "DES");
		
		// 创建des 密码算法对象，指定电码本模式和无填充方式
		try {
			des = Cipher.getInstance("DES/ECB/NoPadding");
		} catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		// 初始化 des 算法
		try {
			des.init(Cipher.ENCRYPT_MODE, secretKey);
		} catch (InvalidKeyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		// 加密
		try {
			des_output = des.doFinal(des_input);
		} catch (IllegalBlockSizeException | BadPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		changeInput(des_key, des_input, des_output);
		changeCipher(des_key, des_input, des_output);
	}
	/**
	 * 通过对des_key随机改变n位，统计输出的密文的改变情况，在这里通过重复执行randtimes次 改变 n 位的密钥，取平均数，作为 改变n位密钥 对 密文 的影响
	 * @param des_key 原来的密钥
	 * @param des_input 原来的明文
	 * @param des_output 原来的密文
	 */
	public static void changeCipher(byte[] des_key,byte[] des_input,byte[] des_output){
		Cipher des=null;
		SecretKey secretKey=null;
		int randtimes=10;
		int deffOnOut=0;
		byte[] randDes_output=null;
		String des_keyString=bitsToString(des_key);
		String des_outputString=bitsToString(des_output);
		String randDes_keyString="";
		String randDes_outputString="";
		byte[] randDes_key=null;
		// 创建des 密码算法对象，指定电码本模式和无填充方式
		try {
			des = Cipher.getInstance("DES/ECB/NoPadding");
		} catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
			e.printStackTrace();
		}
		for(int i=1;i<=64;i++) {
			for(int j=0;j<randtimes;j++) {
//				改变密钥
				String ranDes_keyString=toggleStringBit(des_keyString, i);
				randDes_key=binaryToByteArray(ranDes_keyString);
//				创建密钥
				secretKey = new SecretKeySpec(randDes_key, "DES");
//				初始化DES算法
				try {
					des.init(Cipher.ENCRYPT_MODE, secretKey);
				} catch (InvalidKeyException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
//				加密
				try {
					randDes_output = des.doFinal(des_input);
					randDes_outputString=bitsToString(randDes_output);
				} catch (IllegalBlockSizeException | BadPaddingException e) {
					e.printStackTrace();
				}
//				记录输出的密文不同个数
				deffOnOut+=BitsArray.compare(randDes_outputString, des_outputString);
				
			}
			System.out.println("固定明文，改变密钥情况如下：");
			System.out.println("平均每变化"+i+"位，密文变化"+deffOnOut*1.0/randtimes+"位");
			deffOnOut=0;
			
		}		
	}
	
	/**
	 * 通过对des_input随机改变n位，统计输出的密文的改变情况，在这里通过重复执行randtimes次 改变 n 位的明文，取平均数，作为 改变n位明文 对 密文 的影响
	 * @param des_key 原来的密钥
	 * @param des_input 原来的明文
	 * @param des_output 原来的密文
	 */
	public static void changeInput(byte[] des_key,byte[] des_input,byte[] des_output) {
//		改明文
		SecretKey secretKey = new SecretKeySpec(des_key, "DES");
		
		Cipher des=null;
		byte[] ranDes_output=null;
		int deffOnOut=0;
		String des_outputString=bitsToString(des_output);
		
		String des_inputString=bitsToString(des_input);
		
		System.out.println(des_outputString.length()+","+des_inputString.length());
		// 创建des 密码算法对象，指定电码本模式和无填充方式
		try {
			des = Cipher.getInstance("DES/ECB/NoPadding");
		} catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
			e.printStackTrace();
		}
		
		// 初始化 des 算法
		try {
			des.init(Cipher.ENCRYPT_MODE, secretKey);
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		}
		byte[] ranDes_input=null;
		int randtimes=10;
		for(int i=1;i<=64;i++) {
			for(int j=0;j<randtimes;j++) {
				String ranDes_inputString=toggleStringBit(des_inputString, i);
				ranDes_input=binaryToByteArray(ranDes_inputString);
//				加密
				try {
					ranDes_output = des.doFinal(ranDes_input);
				} catch (IllegalBlockSizeException | BadPaddingException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
//				记录输出的不同位数
				deffOnOut+=BitsArray.compare(bitsToString(ranDes_output), des_outputString);
			}
			System.out.println("改变明文，固定密钥情况如下：");
			System.out.println("平均每变化"+i+"位，密文变化"+deffOnOut*1.0/randtimes+"位");
			deffOnOut=0;
		}
	}
	
}