www.pudn.com > DestTest.rar > TripleTest.java
package com.des.test;
import java.io.IOException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
public class TripleTest
{
public static void main(String[] args)
{
TripleTest tripleTest = new TripleTest();
String key_string = "123400000000000000000000";
String src_string = "12345678";
String des_string = "";
String information = "DESEDE";// "DESEDE/ECB/PKCS5Padding";
String information2 = "DESEDE/CBC/PKCS5Padding";
try
{
SecretKey key = tripleTest.getDESKey(key_string);
SecureRandom random = new SecureRandom();
byte[] iv = new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
(byte) 0x00 };
iv = new byte[] { (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0 };
byte[] vi = new byte[8];
byte[] tt = new byte[8];
int COUNT = 0;
// while (!"Brsl0etq4fQ1fVmYgeeVdw==".equals(des_string))
// {
System.out.println("**********************" + (++COUNT)
+ "***********************");
random.nextBytes(vi);
IvParameterSpec iv_param_spec = new IvParameterSpec(iv);
// 加密
Cipher cipher1 = Cipher.getInstance(information);
cipher1.init(Cipher.ENCRYPT_MODE, key);
byte[] des_byte = cipher1.doFinal(src_string.getBytes());
System.out.println("src_string.getBytes()"
+ src_string.getBytes().length + "\n加密后数组长度des_byte："
+ des_byte.length);
des_string = tripleTest.encodeBase64(des_byte);
System.out.println("des_string:" + des_string);
if ("Brsl0etq4fQ1fVmYgeeVdw==".equals(des_string))
{
System.out.println("找到正确答案了!!!!!!!!!!!!!!");
for (int i = 0; i < vi.length; i++)
{
System.out.println("vi[" + i + "]:" + vi[i]);
}
}
// CBC加密
Cipher cipher3 = Cipher.getInstance(information2);
cipher3.init(Cipher.ENCRYPT_MODE, key, iv_param_spec);
byte[] des_byte_cbc = cipher3.doFinal(src_string.getBytes());
/*
* String ttt = StringBytesTransformUtils
* .bytesToHexString(des_byte_cbc); System.out.println("tttttttt:" +
* ttt); byte[] ss =
* StringBytesTransformUtils.hexStringToBytes(ttt);
* System.out.println("ss" + new String(ss));
*/
System.out.println(des_byte_cbc.length);
String des_string_cbc = tripleTest.encodeBase64(des_byte_cbc);
System.out.println("des_string_cbc:" + des_string_cbc);
// 解密
cipher1.init(Cipher.DECRYPT_MODE, key);
des_byte = tripleTest.decodeBase64(des_string);
byte[] src_byte = cipher1.doFinal(des_byte);
src_string = new String(src_byte);
System.out.println("src_string:" + src_string);
String tripe = tripleTest.encryptString(src_string, key_string
+ "00000000000000000000");
System.out.println("tripe:::" + tripe);
// }
} catch (InvalidKeyException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchAlgorithmException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvalidKeySpecException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchPaddingException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalStateException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalBlockSizeException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (BadPaddingException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvalidAlgorithmParameterException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static String encodeBase64(byte[] src_byte)
{
BASE64Encoder base64Encoder = new BASE64Encoder();
try
{
// 经过BASE64加密后的密文
String base64String = base64Encoder.encodeBuffer(src_byte);
String a = base64Encoder.encodeBuffer(src_byte);
String b = base64Encoder.encode(src_byte);
System.out.println("a:" + a + "b:" + b);
return base64String;
} catch (Exception e)
{
e.printStackTrace();
return null;
}
}
public static byte[] decodeBase64(String base64_string)
{
BASE64Decoder base64Decoder = new BASE64Decoder();
try
{
// 将BASE64转码过的字符串进行解码,获取明文
byte[] src_byte = base64Decoder.decodeBuffer(base64_string);
return src_byte;
} catch (Exception e)
{
e.printStackTrace();
return null;
}
}
public SecretKey getKey(String key_String) throws InvalidKeyException,
NoSuchAlgorithmException, InvalidKeySpecException
{
SecretKey key = null;
byte[] key_chars = key_String.getBytes();
int key_length = 0;
byte[] newchars = new byte[24];
if (key_chars.length < 24)
{
key_length = 24;
for (int i = 0; i < key_chars.length; i++)
{
newchars[i] = key_chars[i];
}
for (int j = key_chars.length; j < key_length; j++)
{
newchars[j] = '0';
}
}
DESedeKeySpec dks = new DESedeKeySpec(newchars);
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");
key = keyFactory.generateSecret(dks);
return key;
}
public static SecretKey getDESKey(String key_string)
throws InvalidKeyException, NoSuchAlgorithmException,
InvalidKeySpecException
{
SecretKey key = null;
byte[] key_byte = null;
// 判断密钥的长度,如果不是24位,则以"0"补齐
String zeros = "000000000000000000000000";
if (key_string != null)
{
int keylength = key_string.getBytes().length;
if (keylength < 24)
{
key_string += zeros.substring(keylength);
}
} else
{
return null;
}
char[] gg = key_string.toCharArray();
for (int i = 0; i < gg.length; i++)
{
// gg[i] -= 18;
System.out.println((byte) gg[i]);
}
System.out.println("gg[i]:" + new String(gg));
// key_string = encodeBase64(key_string.getBytes());
key_byte = key_string.getBytes();
for (int i = 0; i < key_byte.length; i++)
{
key_byte[i] -= 18;
System.out.println(key_byte[i]);
}
byte[] kkey_byte = new byte[] { (byte) 0x49, (byte) 0x50, (byte) 0x51,
(byte) 0x52, (byte) 0x48, (byte) 0x48, (byte) 0x48,
(byte) 0x48, (byte) 0x48, (byte) 0x48, (byte) 0x48,
(byte) 0x48, (byte) 0x48, (byte) 0x48, (byte) 0x48,
(byte) 0x48, (byte) 0x48, (byte) 0x48, (byte) 0x48,
(byte) 0x48, (byte) 0x48, (byte) 0x48, (byte) 0x48,
(byte) 0x48, (byte) 0x48, (byte) 0x48, (byte) 0x48 };
key_byte = new byte[] { (byte) 0x01, (byte) 0x02, (byte) 0x03,
(byte) 0x04, (byte) 0x00, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };
key_byte = new byte[] { (byte) 0x31, (byte) 0x32, (byte) 0x33,
(byte) 0x34, (byte) 0x30, (byte) 0x30, (byte) 0x30,
(byte) 0x30, (byte) 0x30, (byte) 0x30, (byte) 0x30,
(byte) 0x30, (byte) 0x30, (byte) 0x30, (byte) 0x30,
(byte) 0x30, (byte) 0x30, (byte) 0x30, (byte) 0x30,
(byte) 0x30, (byte) 0x30, (byte) 0x30, (byte) 0x30,
(byte) 0x30, };
System.out.println("new key_string::" + new String(key_byte));
String base_keystring = encodeBase64(key_string.getBytes());
System.out.println("base_keystring:" + base_keystring);
byte[] base_keybyte = base_keystring.getBytes();
System.out.println("base_keybyte.length:" + base_keybyte.length);
for (int i = 0; i < base_keybyte.length; i++)
{
System.out.println("base_keybyte[" + i + "]" + base_keybyte[i]);
}
DESedeKeySpec dks = new DESedeKeySpec(key_string.getBytes());
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");
key = keyFactory.generateSecret(dks);
return key;
}
public String encryptString(String rawStr, String rawKey)
throws InvalidKeyException, NoSuchAlgorithmException,
InvalidKeySpecException, NoSuchPaddingException,
BadPaddingException, IllegalBlockSizeException,
IllegalStateException, IOException
{
byte rawStrData[] = rawStr.getBytes();
byte rawKeyData[] = rawKey.getBytes();
byte encryptData[] = encryptString(rawStrData, rawKeyData);
String encryptStr = (new BASE64Encoder()).encode(encryptData);
System.out.println("encryptStr:" + encryptStr);
byte c[] = encryptStr.getBytes();
StringBuffer strBuf = new StringBuffer();
for (int i = 0; i < c.length; i++)
{
int t = c[i];
String str = Integer.toHexString(t);
if (str.length() == 1)
strBuf.append(0);
strBuf.append(Integer.toHexString(t));
}
return strBuf.toString();
}
private byte[] encryptString(byte data[], byte rawKeyData[])
throws InvalidKeyException, NoSuchAlgorithmException,
InvalidKeySpecException, NoSuchPaddingException,
BadPaddingException, IllegalBlockSizeException,
IllegalStateException
{
DESedeKeySpec dks = new DESedeKeySpec(rawKeyData);
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESEDE");
javax.crypto.SecretKey key = keyFactory.generateSecret(dks);
Cipher cipher = Cipher.getInstance("DESEDE/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, key);
byte encryptedData[] = cipher.doFinal(data);
return encryptedData;
}
}