以下两个类可以很方便的完成字符串的加密和解密
加密 CryptHelper encrypt（password）
解密 CrypHelper decrypt（password）
代码如下
CryptUtils java
[java]
package gdie lab crypt;
import java io IOException;
import javax crypto Cipher;
import javax crypto KeyGenerator;
import javax crypto SecretKey;
import apache xerces internal impl dv util Base ;
public class CryptUtils {
private static String Algorithm = DES ;
private static byte[] DEFAULT_KEY=new byte[] { };
private static String VALUE_ENCODING= UTF ;
/**
* 生成密钥
*
* @return byte[] 返回生成的密钥
* @throws exception
* 扔出异常
*/
public static byte[] getSecretKey（） throws Exception {
KeyGenerator keygen = KeyGenerator getInstance（Algorithm）
SecretKey deskey = keygen generateKey（）
// if （debug ） System out println （ 生成密钥 +byte hex （deskey getEncoded
// （）））
return deskey getEncoded（）
}
/**
* 将指定的数据根据提供的密钥进行加密
*
* @param input
* 需要加密的数据
* @param key
* 密钥
* @return byte[] 加密后的数据
* @throws Exception
*/
public static byte[] encryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ）
// {
// System out println （ 加密前的二进串 +byte hex （input ））
// System out println （ 加密前的字符串 +new String （input ））
//
// }
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher ENCRYPT_MODE deskey）
byte[] cipherByte = c doFinal（input）
// if （debug ） System out println （ 加密后的二进串 +byte hex （cipherByte ））
return cipherByte;
}
public static byte[] encryptData（byte[] input） throws Exception {
return encryptData（input DEFAULT_KEY）
}
/**
* 将给定的已加密的数据通过指定的密钥进行解密
*
* @param input
* 待解密的数据
* @param key
* 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
public static byte[] decryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ） System out println （ 解密前的信息 +byte hex （input ））
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher DECRYPT_MODE deskey）
byte[] clearByte = c doFinal（input）
// if （debug ）
// {
// System out println （ 解密后的二进串 +byte hex （clearByte ））
// System out println （ 解密后的字符串 +（new String （clearByte ）））
//
// }
return clearByte;
}
public static byte[] decryptData（byte[] input） throws Exception {
return decryptData（input DEFAULT_KEY）
}
/**
* 字节码转换成 进制字符串
*
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的 进制字符串
*/
public static String byte hex（byte[] bytes） {
StringBuilder hs = new StringBuilder（）
for（byte b : bytes）
hs append（String format（ % $ X b））
return hs toString（）
}
public static byte[] hex byte（String content） {
int l=content length（）》 ;
byte[] result=new byte[l];
for（int i= ;i<l;i++） {
int j=i《 ;
String s=content substring（j j+ ）
result[i]=Integer valueOf（s ） byteValue（）
}
return result;
}
/**
* 将字节数组转换为base 编码字符串
* @param buffer
* @return
*/
public static String bytesToBase （byte[] buffer） {
//BASE Encoder en=new BASE Encoder（）
return Base encode（buffer）
// return encoder encode（buffer）
}
/**
* 将base 编码的字符串解码为字节数组
* @param value
* @return
* @throws IOException
*/
public static byte[] base ToBytes（String value） throws IOException {
//return Base decodeToByteArray（value）
// System out println（decoder decodeBuffer（value））
// return decoder decodeBuffer（value）
return Base decode（value）
}
/**
* 加密给定的字符串
* @param value
* @return 加密后的base 字符串
*/
public static String encryptString（String value） {
return encryptString（value DEFAULT_KEY）
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 以BASE 形式存在的密钥
* @return 加密后的base 字符串
* @throws IOException
*/
public static String encryptString（String value String key） throws IOException {
return encryptString（value base ToBytes（key））
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 字节数组形式的密钥
* @return 加密后的base 字符串
*/
public static String encryptString（String value byte[] key） {
try {
byte[] data=value getBytes（VALUE_ENCODING）
data=CryptUtils encryptData（data key）
return bytesToBase （data）
} catch （Exception e） {
// TODO Auto generated catch block
e printStackTrace（）
return null;
}
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @return 明文
*/
public static String decryptString（String value） {
return decryptString（value DEFAULT_KEY）
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key base 形式存在的密钥
* @return 明文
* @throws IOException
*/
public static String decryptString（String value String key） throws IOException {
String s=decryptString（value base ToBytes（key））
return s;
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key 字节数据形式存在的密钥
* @return 明文
*/
public static String decryptString（String value byte[] key） {
try {
byte[] data=base ToBytes（value）
data=CryptUtils decryptData（data key）
return new String（data VALUE_ENCODING）
}catch（Exception e） {
e printStackTrace（）
return null;
}
}
}
package gdie lab crypt;
import java io IOException;
import javax crypto Cipher;
import javax crypto KeyGenerator;
import javax crypto SecretKey;
import apache xerces internal impl dv util Base ;
public class CryptUtils {
private static String Algorithm = DES ;
private static byte[] DEFAULT_KEY=new byte[] { };
private static String VALUE_ENCODING= UTF ;
/**
* 生成密钥
*
* @return byte[] 返回生成的密钥
* @throws exception
* 扔出异常
*/
public static byte[] getSecretKey（） throws Exception {
KeyGenerator keygen = KeyGenerator getInstance（Algorithm）
SecretKey deskey = keygen generateKey（）
// if （debug ） System out println （ 生成密钥 +byte hex （deskey getEncoded
// （）））
return deskey getEncoded（）
}
/**
* 将指定的数据根据提供的密钥进行加密
*
* @param input
* 需要加密的数据
* @param key
* 密钥
* @return byte[] 加密后的数据
* @throws Exception
*/
public static byte[] encryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ）
// {
// System out println （ 加密前的二进串 +byte hex （input ））
// System out println （ 加密前的字符串 +new String （input ））
//
// }
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher ENCRYPT_MODE deskey）
byte[] cipherByte = c doFinal（input）
// if （debug ） System out println （ 加密后的二进串 +byte hex （cipherByte ））
return cipherByte;
}
public static byte[] encryptData（byte[] input） throws Exception {
return encryptData（input DEFAULT_KEY）
}
/**
* 将给定的已加密的数据通过指定的密钥进行解密
*
* @param input
* 待解密的数据
* @param key
* 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
public static byte[] decryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ） System out println （ 解密前的信息 +byte hex （input ））
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher DECRYPT_MODE deskey）
byte[] clearByte = c doFinal（input）
// if （debug ）
// {
// System out println （ 解密后的二进串 +byte hex （clearByte ））
// System out println （ 解密后的字符串 +（new String （clearByte ）））
//
// }
return clearByte;
}
public static byte[] decryptData（byte[] input） throws Exception {
return decryptData（input DEFAULT_KEY）
}
/**
* 字节码转换成 进制字符串
*
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的 进制字符串
*/
public static String byte hex（byte[] bytes） {
StringBuilder hs = new StringBuilder（）
for（byte b : bytes）
hs append（String format（ % $ X b））
return hs toString（）
}
public static byte[] hex byte（String content） {
int l=content length（）》 ;
byte[] result=new byte[l];
for（int i= ;i<l;i++） {
int j=i《 ;
String s=content substring（j j+ ）
result[i]=Integer valueOf（s ） byteValue（）
}
return result;
}
/**
* 将字节数组转换为base 编码字符串
* @param buffer
* @return
*/
public static String bytesToBase （byte[] buffer） {
//BASE Encoder en=new BASE Encoder（）
return Base encode（buffer）
// return encoder encode（buffer）
}
/**
* 将base 编码的字符串解码为字节数组
* @param value
* @return
* @throws IOException
*/
public static byte[] base ToBytes（String value） throws IOException {
//return Base decodeToByteArray（value）
// System out println（decoder decodeBuffer（value））
// return decoder decodeBuffer（value）
return Base decode（value）
}
/**
* 加密给定的字符串
* @param value
* @return 加密后的base 字符串
*/
public static String encryptString（String value） {
return encryptString（value DEFAULT_KEY）
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 以BASE 形式存在的密钥
* @return 加密后的base 字符串
* @throws IOException
*/
public static String encryptString（String value String key） throws IOException {
return encryptString（value base ToBytes（key））
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 字节数组形式的密钥
* @return 加密后的base 字符串
*/
public static String encryptString（String value byte[] key） {
try {
byte[] data=value getBytes（VALUE_ENCODING）
data=CryptUtils encryptData（data key）
return bytesToBase （data）
} catch （Exception e） {
// TODO Auto generated catch block
e printStackTrace（）
return null;
}
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @return 明文
*/
public static String decryptString（String value） {
return decryptString（value DEFAULT_KEY）
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key base 形式存在的密钥
* @return 明文
* @throws IOException
*/
public static String decryptString（String value String key） throws IOException {
String s=decryptString（value base ToBytes（key））
return s;
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key 字节数据形式存在的密钥
* @return 明文
*/
public static String decryptString（String value byte[] key） {
try {
byte[] data=base ToBytes（value）
data=CryptUtils decryptData（data key）
return new String（data VALUE_ENCODING）
}catch（Exception e） {
e printStackTrace（）
return null;
}
}
}
CryptHelper java
[java]
package gdie lab crypt;
import javax crypto Cipher;
import javax crypto SecretKey;
import javax crypto SecretKeyFactory;
import javax crypto spec DESKeySpec;
import javax crypto spec IvParameterSpec;
import springframework util DigestUtils;
public class CryptHelper{
private static String CRYPT_KEY = zhongqian ;
//加密
private static Cipher ecip;
//解密
private static Cipher dcip;
static {
try {
String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）
KEY = KEY substring（ ）
byte[] bytes = KEY getBytes（）
DESKeySpec ks = new DESKeySpec（bytes）
SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）
SecretKey sk = skf generateSecret（ks）
IvParameterSpec iv = new IvParameterSpec（bytes）
ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）
ecip init（Cipher ENCRYPT_MODE sk iv ）
dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）
dcip init（Cipher DECRYPT_MODE sk iv ）
}catch（Exception ex） {
ex printStackTrace（）
}
}
public static String encrypt（String content） throws Exception {
byte[] bytes = ecip doFinal（content getBytes（ ascii ））
return CryptUtils byte hex（bytes）
}
public static String decrypt（String content） throws Exception {
byte[] bytes = CryptUtils hex byte（content）
bytes = dcip doFinal（bytes）
return new String（bytes ascii ）
}
//test
public static void main（String[] args） throws Exception {
String password = gly ;
String en = encrypt（password）
System out println（en）
System out println（decrypt（en））
}
}
package gdie lab crypt;
import javax crypto Cipher;
import javax crypto SecretKey;
import javax crypto SecretKeyFactory;
import javax crypto spec DESKeySpec;
import javax crypto spec IvParameterSpec;
import springframework util DigestUtils;
public class CryptHelper{
private static String CRYPT_KEY = zhongqian ;
//加密
private static Cipher ecip;
//解密
private static Cipher dcip;
static {
try {
String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）
KEY = KEY substring（ ）
byte[] bytes = KEY getBytes（）
DESKeySpec ks = new DESKeySpec（bytes）
SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）
SecretKey sk = skf generateSecret（ks）
IvParameterSpec iv = new IvParameterSpec（bytes）
ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）
ecip init（Cipher ENCRYPT_MODE sk iv ）
dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）
dcip init（Cipher DECRYPT_MODE sk iv ）
}catch（Exception ex） {
ex printStackTrace（）
}
}
public static String encrypt（String content） throws Exception {
byte[] bytes = ecip doFinal（content getBytes（ ascii ））
return CryptUtils byte hex（bytes）
}
public static String decrypt（String content） throws Exception {
byte[] bytes = CryptUtils hex byte（content）
bytes = dcip doFinal（bytes）
return new String（bytes ascii ）
}
//test
public static void main（String[] args） throws Exception {
String password = gly ;
String en = encrypt（password）
System out println（en）
System out println（decrypt（en））
}
lishixin/Article/program/Java/hx/201311/26449
‘贰’ javaDES加密 C 语言DES解密
再用java写一段解密算法就好了。本来数据类型就不一致。或者加密解密就用c写，还是很方便
‘叁’ java生成rsa密钥，c++可以直接使用密钥解密吗
可以的，RSA加密解密有一套规则的，不同的语言都会遵循，只是实现的方式不一样。
用对应的的公钥就可以进行解密
‘肆’ 如何用Java进行3DES加密解密
这里是例子，直接拿来用就可以了。
package com.nnff.des;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
/*字符孝姿耐串册谈 DESede(3DES) 加密
* ECB模式/使用PKCS7方式填充不足位,目前给的密钥是192位
* 3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的
* 加密标准），是DES的一个更安全的巧春变形。它以DES为基本模块，通过组合分组方法设计出分组加
* 密算法，其具体实现如下：设Ek()和Dk()代表DES算法的加密和解密过程，K代表DES算法使用的
* 密钥，P代表明文，C代表密表，这样，
* 3DES加密过程为：C=Ek3(Dk2(Ek1(P)))
* 3DES解密过程为：P=Dk1((EK2(Dk3(C)))
* */
public class ThreeDes {
/**
* @param args在java中调用sun公司提供的3DES加密解密算法时，需要使
* 用到$JAVA_HOME/jre/lib/目录下如下的4个jar包：
*jce.jar
*security/US_export_policy.jar
*security/local_policy.jar
*ext/sunjce_provider.jar
*/
private static final String Algorithm = "DESede"; //定义加密算法,可用 DES,DESede,Blowfish
//keybyte为加密密钥，长度为24字节
//src为被加密的数据缓冲区（源）
public static byte[] encryptMode(byte[] keybyte,byte[] src){
try {
//生成密钥
SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
//加密
Cipher c1 = Cipher.getInstance(Algorithm);
c1.init(Cipher.ENCRYPT_MODE, deskey);
return c1.doFinal(src);//在单一方面的加密或解密
} catch (java.security.NoSuchAlgorithmException e1) {
// TODO: handle exception
e1.printStackTrace();
}catch(javax.crypto.NoSuchPaddingException e2){
e2.printStackTrace();
}catch(java.lang.Exception e3){
e3.printStackTrace();
}
return null;
}
//keybyte为加密密钥，长度为24字节
//src为加密后的缓冲区
public static byte[] decryptMode(byte[] keybyte,byte[] src){
try {
//生成密钥
SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
//解密
Cipher c1 = Cipher.getInstance(Algorithm);
c1.init(Cipher.DECRYPT_MODE, deskey);
return c1.doFinal(src);
} catch (java.security.NoSuchAlgorithmException e1) {
// TODO: handle exception
e1.printStackTrace();
}catch(javax.crypto.NoSuchPaddingException e2){
e2.printStackTrace();
}catch(java.lang.Exception e3){
e3.printStackTrace();
}
return null;
}
//转换成十六进制字符串
public static String byte2Hex(byte[] b){
String hs="";
String stmp="";
for(int n=0; n<b.length; n++){
stmp = (java.lang.Integer.toHexString(b[n]& 0XFF));
if(stmp.length()==1){
hs = hs + "0" + stmp;
}else{
hs = hs + stmp;
}
if(n<b.length-1)hs=hs+":";
}
return hs.toUpperCase();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
//添加新安全算法,如果用JCE就要把它添加进去
Security.addProvider(new com.sun.crypto.provider.SunJCE());
final byte[] keyBytes = {0x11, 0x22, 0x4F, 0x58,
(byte)0x88, 0x10, 0x40, 0x38, 0x28, 0x25, 0x79, 0x51,
(byte)0xCB,
(byte)0xDD, 0x55, 0x66, 0x77, 0x29, 0x74,
(byte)0x98, 0x30, 0x40, 0x36,
(byte)0xE2
}; //24字节的密钥
String szSrc = "This is a 3DES test. 测试";
System.out.println("加密前的字符串:" + szSrc);
byte[] encoded = encryptMode(keyBytes,szSrc.getBytes());
System.out.println("加密后的字符串:" + new String(encoded));
byte[] srcBytes = decryptMode(keyBytes,encoded);
System.out.println("解密后的字符串:" + (new String(srcBytes)));
}
}
‘伍’ javarsa加密c#解密失败
系统bug。当软件javarsa的系统出现系统bug时，就会导致该软件在解密c井的程序的时候出现解密失败的情况，只需要将该软件卸载后重新安装该软件即可。
‘陆’ des解密算法，利用C语言解密JAVA语言加密的密码。。密钥为12345678，加密后的密文为：26d086be3a3a62fc
// C 语言 DES用的是 ECB模式， 没有填充
// 因此Java端要对应， 你的明文是 liubiao 吗？
// 另外 DES已经不安全了， 如果可以改为 3DES或者 AES吧。
public class LearnDes {
public static void main(String[] args) {
try {
System.out.println(encrypt("liubiao", "12345678"));
System.out.println(decrypt("26d086be3a3a62fc", "12345678"));
} catch (Exception e) {
e.printStackTrace();
}
}
public static String encrypt(String message, String key) throws Exception {
//Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
Cipher cipher = Cipher.getInstance("DES/ECB/NOPADDING");
DESKeySpec desKeySpec = new DESKeySpec(key.getBytes("UTF-8"));
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
IvParameterSpec iv = new IvParameterSpec(key.getBytes("UTF-8"));
//cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
cipher.init(Cipher.ENCRYPT_MODE, secretKey );
return toHexString(cipher.doFinal(message.getBytes("UTF-8")));
}
public static String decrypt(String message, String key) throws Exception {
byte[] bytesrc = convertHexString(message);
//Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
Cipher cipher = Cipher.getInstance("DES/ECB/NOPADDING");
DESKeySpec desKeySpec = new DESKeySpec(key.getBytes("UTF-8"));
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
IvParameterSpec iv = new IvParameterSpec(key.getBytes("UTF-8"));
//cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
cipher.init(Cipher.DECRYPT_MODE, secretKey );
byte[] retByte = cipher.doFinal(bytesrc);
return new String(retByte);
}
public static byte[] convertHexString(String ss) {
byte digest[] = new byte[ss.length() / 2];
for (int i = 0; i < digest.length; i++) {
String byteString = ss.substring(2 * i, 2 * i + 2);
int byteValue = Integer.parseInt(byteString, 16);
digest[i] = (byte) byteValue;
}
return digest;
}
public static String toHexString(byte b[]) {
StringBuffer hexString = new StringBuffer();
for (int i = 0; i < b.length; i++) {
String plainText = Integer.toHexString(0xff & b[i]);
if (plainText.length() < 2)
plainText = "0" + plainText;
hexString.append(plainText);
}
return hexString.toString();
}
}