金融密码键盘解密算法

金融用密码键盘解密算法。和金属键盘加解密效果是一样的

工作密钥用主密钥加密，PIN和卡号符合ISO标准，使用异或运算后加密

/**
 * SecretUtils {3DES加密解密的工具类 }
 * 
 * @author zouhuaqiu
 * @date 2014-08-20
 */
public class SecretUtils {

	// 定义加密算法，有DES、DESede(即3DES)、Blowfish
	public static final String Algorithm3DES = "DESede";// 0
	public static final String AlgorithmDES  = "DES";// 1

	// 主密钥
	private static final byte[] masterKey = { 0x00, 0x01, 0x02, 0x03, 0x04,
			0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
	// 工作密钥

	private static final byte[] workingKey = { 0x12, 0x34, 0x56, 0x78,
			(byte) 0x90, (byte) 0xab, (byte) 0xcd, (byte) 0xef, 0x01, 0x02,
			0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };

	// 卡号
	private static final String card_no = "1234567890123";

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String input_pin = "111111";
		EncryptUnit unit = new EncryptUnit();
		byte[] miwen     = unit.setMasterKey(masterKey).setWorkingKey(workingKey).setString(card_no).inputPIN(input_pin);//模拟密码键盘加密过程
		
		String pin       = unit.decrypt(miwen);//解密过程
		
		System.out.println(pin);
	}
}

<pre name="code" class="java">import java.io.UnsupportedEncodingException;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**
 * @author zouhuaqiu
 * @date 2014-08-21
 * 
 */
public class EncryptUnit {
	
	
	// 定义加密算法，有DES、DESede(即3DES)、Blowfish
	public static final String Algorithm3DES = "DESede";// 0
	public static final String AlgorithmDES  = "DES";// 1
	
	private byte[] masterKey;
	private byte[] workingKey;
	private String card_no;
	
	
	public EncryptUnit setMasterKey(byte[] masterKey){
		
		this.masterKey = masterKey;
		return this;
	}
    public EncryptUnit setWorkingKey(byte[] workingKey){
    	
    	
    	this.workingKey= workingKey; 
    	return this;
    }
    
    public EncryptUnit setString(String card_no){
    	
    	this.card_no =card_no;
    	return this;
    }
    //输入返回密文
    public byte[] inputPIN(String PIN){
    	
        String pin_str  =	builtPINStr(PIN);
    	String card_str =   builtCardStr(card_no);
    	
    	byte[] real_workingKey = decryptMode(workingKey,Algorithm3DES, masterKey);//解出真正的工作密钥
    	
    	byte[] ex 		= exclusive(pin_str,card_str);//异或处理
    	
    	return encryptMode(ex, real_workingKey,Algorithm3DES);//加密
    	
    }
    /**
     * 解密密文
     * @param miwen
     * @return
     */
    public String decrypt(byte[] miwen){
    	
    	byte[] real_workingKey = decryptMode(workingKey,Algorithm3DES, masterKey);//解出真正的工作密钥
    	byte[] src      = decryptMode(miwen, Algorithm3DES,real_workingKey);
    	String card_str =   builtCardStr(card_no);
    	byte[]     tmp  = unexclusive(src,card_str);//异或处理
    	String str      = byte2HexStr(tmp);
    	int length  	= Integer.valueOf(str.substring(0, 2));
    	
    	String pin      =  str.substring(2,length+2);
    	return pin;
    }
    
    private static String builtPINStr(String PIN){
    	
    	int length = PIN.length();//获取长度;
    	String len = String.valueOf(length);
    	len = (len.length()==1)?("0"+len):len;
    	StringBuffer  sb = new StringBuffer();
    	sb.append(len);
    	sb.append(PIN);
    	for(int i=0;sb.length()<16;i++){
    		sb.append("F");
    	}
    	System.out.println("pin:"+sb);
    	
    	return sb.toString();
    	
    }
   private static String builtCardStr(String card_no){
    	
    	StringBuffer  sb = new StringBuffer();
    	sb.append("0000");
    	char[] ch=card_no.toCharArray();
    	for(int i=0;sb.length()<16;i++){
    		sb.append(ch[i]);
    	}
    	System.out.println("card:"+sb);
    	return sb.toString();
    	
    }

	/**
	 * 使用指定密钥的 加密
	 * 
	 * @param src
	 * @param key
	 *            密钥
	 * @param Algorithm
	 *            算法
	 * @return
	 */
	private static byte[] encryptMode(byte[] src, byte[] key, String Algorithm) {
		try {
			SecretKey deskey = new SecretKeySpec(
					Algorithm.equals(Algorithm3DES) ? build3DesKey(key)
							: build3DesKey(key), Algorithm); // 生成密钥
			Cipher c1 = Cipher.getInstance("DESede/ECB/NoPadding");// 实例化负责加密/解密的Cipher工具类
			c1.init(Cipher.ENCRYPT_MODE, deskey); // 初始化为加密模式
			return c1.doFinal(src);
		} catch (java.security.NoSuchAlgorithmException e1) {
			e1.printStackTrace();
		} catch (javax.crypto.NoSuchPaddingException e2) {
			e2.printStackTrace();
		} catch (java.lang.Exception e3) {
			e3.printStackTrace();
		}
		return null;
	}

	/**
	 * 解密函数
	 * 
	 * @param src
	 *            密文的字节数组
	 * @return
	 */
	private static byte[] decryptMode(byte[] src, String Algorithm, byte[] key) {
		try {
			SecretKey deskey = new SecretKeySpec(build3DesKey(key), Algorithm);
			Cipher c1 = Cipher.getInstance("DESede/ECB/NoPadding");
			c1.init(Cipher.DECRYPT_MODE, deskey); // 初始化为解密模式
			return c1.doFinal(src);
		} catch (java.security.NoSuchAlgorithmException e1) {
			e1.printStackTrace();
		} catch (javax.crypto.NoSuchPaddingException e2) {
			e2.printStackTrace();
		} catch (java.lang.Exception e3) {
			e3.printStackTrace();
		}
		return null;
	}
	/*
	 * 根据字符串生成密钥字节数组
	 * 
	 * @param keyStr 密钥字符串
	 * 
	 * @return
	 * 
	 * @throws UnsupportedEncodingException
	 */
	private static byte[] build3DesKey(byte[] temp)
			throws UnsupportedEncodingException {
		byte[] key = new byte[24]; // 声明一个24位的字节数组，默认里面都是0
		System.arraycopy(temp, 0, key, 0, temp.length);
		// 补充的8字节就是16字节密钥的前8位
		for (int i = 0; i < 8; i++) {
			key[16 + i] = temp[i];
		}
		return key;
	}

	/*
	 * 实现字节数组向十六进制的转换方法一
	 */
	public static String byte2HexStr(byte[] b) {
		String hs = "";
		String stmp = "";
		for (int n = 0; n < b.length; n++) {
			stmp = (Integer.toHexString(b[n] & 0XFF));
			if (stmp.length() == 1)
				hs = hs + "0" + stmp;
			else
				hs = hs + stmp;
		}
		return hs.toUpperCase();
	}

	/**
	 * Convert hex string to byte[]
	 * 
	 * @param hexString
	 *            the hex string
	 * @return byte[]
	 */
	public static byte[] hexStringToBytes(String hexString) {
		if (hexString == null || hexString.equals("")) {
			return null;
		}
		hexString = hexString.toUpperCase();
		int length = hexString.length() / 2;
		char[] hexChars = hexString.toCharArray();
		byte[] d = new byte[length];
		for (int i = 0; i < length; i++) {
			int pos = i * 2;
			d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));

		}
		return d;
	}

	/**
	 * Convert char to byte
	 * 
	 * @param c
	 *            char
	 * @return byte
	 */
	private static byte charToByte(char c) {
		return (byte) "0123456789ABCDEF".indexOf(c);
	}
	/**
	 * 
	 * @param PIN
	 * @param card
	 * @return
	 */
	private static byte[] exclusive(String PIN,String card){
		byte[] array = hexStringToBytes(PIN);
		byte[] array2= hexStringToBytes(card);
	        //将用户输入转换成字符数组。
        for(int i=0;i<array.length;i++)
        {
            array[i]=(byte) (array[i]^array2[i]);
           
        }
       return array;
		
	}
    /**
     * 反异或
     * @param miwen
     * @param card
     * @return
     */
	private static byte[] unexclusive(byte[] miwen,String card){
		byte[] array2= hexStringToBytes(card);
		for(int i=0;i<miwen.length;i++)
	    {
			  miwen[i]=(byte) (miwen[i]^array2[i]);
	           
	    }
		return miwen;
	}
}