金融密码键盘解密算法

/**
* 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
& 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;
}
}