javadescbc加密
以下兩個類可以很方便的完成字元串的加密和解密
加密 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
② java des 默認採用什麼加密模式
JAVA和.NET的系統類庫里都有封裝DES對稱加密的實現方式，但是對外暴露的介面卻各不相同，甚至有時會讓自己難以解決其中的問題，比如JAVA加密後的結果在.NET中解密不出來等，由於最近項目有跨JAVA和.NET的加解密，經過我的分析調試，終於讓它們可以互相加密解密了。
DES加密
DES是一種對稱加密(Data Encryption Standard)演算法，以前我寫過一篇文章：.NET中加密解密相關知識，有過簡單描述。
DES演算法一般有兩個關鍵點，第一個是加密演算法，第二個是數據補位。
加密演算法常見的有ECB模式和CBC模式：
③ Des加密解密方法 用java C#和C++三種方式實現
Solaris下的系統，有一個用C做的加密工具，調用Sunwcry的des(1)對文件進行加密，然後在java中對文件進行解密。java中用的是標準的DES/CBC/NoPadding演算法，可是解密後發現開頭有8byte的數據出錯了，請高人指點一下。
cbc_encrypt.c ： 加密用的C程序
cbc_decrypt.c：解密用的C程序
TestDescbc.java：解密用的java程序
Test01.dat原始文件
Test03.dat cbc_encrypt加密後的文件
Test05.dat cbc_decrypt解密後的文件
Test06.dat TestDescbc解密後的文件
④ 如何使用JAVA實現對字元串的DES加密和解密
/**
*ECB模式的des加密，以base64的編碼輸出
*@parammessage
*@paramkey
*@return
*@throwsException
*/
publicstaticStringdesEncrypt(Stringmessage,Stringkey)throwsException{
//DES/ECBCBCCFBOFB/PKCS5PaddingNoPadding加密/模式/填充
Ciphercipher=Cipher.getInstance("DES");//默認就是DES/ECB/PKCS5Padding
DESKeySpecdesKeySpec=newDESKeySpec(key.getBytes());
SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance("DES");
SecretKeysecretKey=keyFactory.generateSecret(desKeySpec);
cipher.init(1,secretKey);
returnnewBASE64Encoder().encode(cipher.doFinal(message.getBytes("UTF-8")));
}
/**
*ECB模式的des解密
*@parammessage
*@paramkey
*@return
*@throwsException
*/
publicstaticStringdesDecrypt(Stringmessage,Stringkey)throwsException{
Ciphercipher=Cipher.getInstance("DES");
DESKeySpecdesKeySpec=newDESKeySpec(key.getBytes());
SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance("DES");
SecretKeysecretKey=keyFactory.generateSecret(desKeySpec);
cipher.init(2,secretKey);
returnnewString(cipher.doFinal(Base64.decode(message)),"UTF-8");
}
你自己寫main方法測試一下，應該是沒問題的
⑤ C#加密Java解密
DES加密 java與 C# 可以相互加密解密
這里的KEY採用Base64編碼，便用分發，因為Java的Byte范圍為-128至127，c#的Byte范圍是0-255
核心是確定Mode和Padding，關於這兩個的意思可以搜索3DES演算法相關文章
一個是C#採用CBC Mode，PKCS7 Padding,Java採用CBC Mode，PKCS5Padding Padding,
另一個是C#採用ECB Mode，PKCS7 Padding,Java採用ECB Mode，PKCS5Padding Padding,
Java的ECB模式不需要IV
對字元加密時，雙方採用的都是UTF-8編碼
C# 代碼
/// <summary>
/// DES3加密解密
/// </summary>
public class Des3
{
#region CBC模式**
/// <summary>
/// DES3 CBC模式加密
/// </summary>
/// <param name="key">密鑰</param>
/// <param name="iv">IV</param>
/// <param name="data">明文的byte數組</param>
/// <returns>密文的byte數組</returns>
public static byte[] Des3EncodeCBC( byte[] key, byte[] iv, byte[] data )
{
//復制於MSDN
try
{
// Create a MemoryStream.
MemoryStream mStream = new MemoryStream();
tdsp = new ();
tdsp.Mode = CipherMode.CBC; //默認值
tdsp.Padding = PaddingMode.PKCS7; //默認值
// Create a CryptoStream using the MemoryStream
// and the passed key and initialization vector (IV).
CryptoStream cStream = new CryptoStream( mStream,
tdsp.CreateEncryptor( key, iv ),
CryptoStreamMode.Write );
// Write the byte array to the crypto stream and flush it.
cStream.Write( data, 0, data.Length );
cStream.FlushFinalBlock();
// Get an array of bytes from the
// MemoryStream that holds the
// encrypted data.
byte[] ret = mStream.ToArray();
// Close the streams.
cStream.Close();
mStream.Close();
// Return the encrypted buffer.
return ret;
}
catch ( CryptographicException e )
{
Console.WriteLine( "A Cryptographic error occurred: {0}", e.Message );
return null;
}
}
/// <summary>
/// DES3 CBC模式解密
/// </summary>
/// <param name="key">密鑰</param>
/// <param name="iv">IV</param>
/// <param name="data">密文的byte數組</param>
/// <returns>明文的byte數組</returns>
public static byte[] Des3DecodeCBC( byte[] key, byte[] iv, byte[] data )
{
try
{
// Create a new MemoryStream using the passed
// array of encrypted data.
MemoryStream msDecrypt = new MemoryStream( data );
tdsp = new ();
tdsp.Mode = CipherMode.CBC;
tdsp.Padding = PaddingMode.PKCS7;
// Create a CryptoStream using the MemoryStream
// and the passed key and initialization vector (IV).
CryptoStream csDecrypt = new CryptoStream( msDecrypt,
tdsp.CreateDecryptor( key, iv ),
CryptoStreamMode.Read );
// Create buffer to hold the decrypted data.
byte[] fromEncrypt = new byte[data.Length];
// Read the decrypted data out of the crypto stream
// and place it into the temporary buffer.
csDecrypt.Read( fromEncrypt, 0, fromEncrypt.Length );
//Convert the buffer into a string and return it.
return fromEncrypt;
}
catch ( CryptographicException e )
{
Console.WriteLine( "A Cryptographic error occurred: {0}", e.Message );
return null;
}
}
#endregion
#region ECB模式
/// <summary>
/// DES3 ECB模式加密
/// </summary>
/// <param name="key">密鑰</param>
/// <param name="iv">IV(當模式為ECB時，IV無用)</param>
/// <param name="str">明文的byte數組</param>
/// <returns>密文的byte數組</returns>
public static byte[] Des3EncodeECB( byte[] key, byte[] iv, byte[] data )
{
try
{
// Create a MemoryStream.
MemoryStream mStream = new MemoryStream();
tdsp = new ();
tdsp.Mode = CipherMode.ECB;
tdsp.Padding = PaddingMode.PKCS7;
// Create a CryptoStream using the MemoryStream
// and the passed key and initialization vector (IV).
CryptoStream cStream = new CryptoStream( mStream,
tdsp.CreateEncryptor( key, iv ),
CryptoStreamMode.Write );
// Write the byte array to the crypto stream and flush it.
cStream.Write( data, 0, data.Length );
cStream.FlushFinalBlock();
// Get an array of bytes from the
// MemoryStream that holds the
// encrypted data.
byte[] ret = mStream.ToArray();
// Close the streams.
cStream.Close();
mStream.Close();
// Return the encrypted buffer.
return ret;
}
catch ( CryptographicException e )
{
Console.WriteLine( "A Cryptographic error occurred: {0}", e.Message );
return null;
}
}
/// <summary>
/// DES3 ECB模式解密
/// </summary>
/// <param name="key">密鑰</param>
/// <param name="iv">IV(當模式為ECB時，IV無用)</param>
/// <param name="str">密文的byte數組</param>
/// <returns>明文的byte數組</returns>
public static byte[] Des3DecodeECB( byte[] key, byte[] iv, byte[] data )
{
try
{
// Create a new MemoryStream using the passed
// array of encrypted data.
MemoryStream msDecrypt = new MemoryStream( data );
tdsp = new ();
tdsp.Mode = CipherMode.ECB;
tdsp.Padding = PaddingMode.PKCS7;
// Create a CryptoStream using the MemoryStream
// and the passed key and initialization vector (IV).
CryptoStream csDecrypt = new CryptoStream( msDecrypt,
tdsp.CreateDecryptor( key, iv ),
CryptoStreamMode.Read );
// Create buffer to hold the decrypted data.
byte[] fromEncrypt = new byte[data.Length];
// Read the decrypted data out of the crypto stream
// and place it into the temporary buffer.
csDecrypt.Read( fromEncrypt, 0, fromEncrypt.Length );
//Convert the buffer into a string and return it.
return fromEncrypt;
}
catch ( CryptographicException e )
{
Console.WriteLine( "A Cryptographic error occurred: {0}", e.Message );
return null;
}
}
#endregion
/// <summary>
/// 類測試
/// </summary>
public static void Test()
{
System.Text.Encoding utf8 = System.Text.Encoding.UTF8;
//key為abcdefghijklmnopqrstuvwx的Base64編碼
byte[] key = Convert.FromBase64String( "" );
byte[] iv = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; //當模式為ECB時，IV無用
byte[] data = utf8.GetBytes( "中國ABCabc123" );
System.Console.WriteLine( "ECB模式:" );
byte[] str1 = Des3.Des3EncodeECB( key, iv, data );
byte[] str2 = Des3.Des3DecodeECB( key, iv, str1 );
System.Console.WriteLine( Convert.ToBase64String( str1 ) );
System.Console.WriteLine( System.Text.Encoding.UTF8.GetString( str2 ) );
System.Console.WriteLine();
System.Console.WriteLine( "CBC模式:" );
byte[] str3 = Des3.Des3EncodeCBC( key, iv, data );
byte[] str4 = Des3.Des3DecodeCBC( key, iv, str3 );
System.Console.WriteLine( Convert.ToBase64String( str3 ) );
System.Console.WriteLine( utf8.GetString( str4 ) );
System.Console.WriteLine();
}
}
java 代碼：
import java.security.Key;
import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
public class Des3 {
public static void main(String[] args) throws Exception {
byte[] key=new BASE64Decoder().decodeBuffer("");
byte[] keyiv = { 1, 2, 3, 4, 5, 6, 7, 8 };
byte[] data="中國ABCabc123".getBytes("UTF-8");
System.out.println("ECB加密解密");
byte[] str3 = des3EncodeECB(key,data );
byte[] str4 = ees3DecodeECB(key, str3);
System.out.println(new BASE64Encoder().encode(str3));
System.out.println(new String(str4, "UTF-8"));
System.out.println();
System.out.println("CBC加密解密");
byte[] str5 = des3EncodeCBC(key, keyiv, data);
byte[] str6 = des3DecodeCBC(key, keyiv, str5);
System.out.println(new BASE64Encoder().encode(str5));
System.out.println(new String(str6, "UTF-8"));
}
/**
* ECB加密,不要IV
* @param key 密鑰
* @param data 明文
* @return Base64編碼的密文
* @throws Exception
*/
public static byte[] des3EncodeECB(byte[] key, byte[] data)
throws Exception {
Key deskey = null;
DESedeKeySpec spec = new DESedeKeySpec(key);
SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
deskey = keyfactory.generateSecret(spec);
Cipher cipher = Cipher.getInstance("desede" + "/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, deskey);
byte[] bOut = cipher.doFinal(data);
return bOut;
}
/**
* ECB解密,不要IV
* @param key 密鑰
* @param data Base64編碼的密文
* @return 明文
* @throws Exception
*/
public static byte[] ees3DecodeECB(byte[] key, byte[] data)
throws Exception {
Key deskey = null;
DESedeKeySpec spec = new DESedeKeySpec(key);
SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
deskey = keyfactory.generateSecret(spec);
Cipher cipher = Cipher.getInstance("desede" + "/ECB/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, deskey);
byte[] bOut = cipher.doFinal(data);
return bOut;
}
/**
* CBC加密
* @param key 密鑰
* @param keyiv IV
* @param data 明文
* @return Base64編碼的密文
* @throws Exception
*/
public static byte[] des3EncodeCBC(byte[] key, byte[] keyiv, byte[] data)
throws Exception {
Key deskey = null;
DESedeKeySpec spec = new DESedeKeySpec(key);
SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
deskey = keyfactory.generateSecret(spec);
Cipher cipher = Cipher.getInstance("desede" + "/CBC/PKCS5Padding");
IvParameterSpec ips = new IvParameterSpec(keyiv);
cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
byte[] bOut = cipher.doFinal(data);
return bOut;
}
/**
* CBC解密
* @param key 密鑰
* @param keyiv IV
* @param data Base64編碼的密文
* @return 明文
* @throws Exception
*/
public static byte[] des3DecodeCBC(byte[] key, byte[] keyiv, byte[] data)
throws Exception {
Key deskey = null;
DESedeKeySpec spec = new DESedeKeySpec(key);
SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
deskey = keyfactory.generateSecret(spec);
Cipher cipher = Cipher.getInstance("desede" + "/CBC/PKCS5Padding");
IvParameterSpec ips = new IvParameterSpec(keyiv);
cipher.init(Cipher.DECRYPT_MODE, deskey, ips);
byte[] bOut = cipher.doFinal(data);
return bOut;
}
}
⑥ Java和.NET使用DES對稱加密的區別
沒有區別，DES只是加密的一種演算法，Java與.NET語言中只是對這種演算法的實現，所以兩者是沒有任何區別的。演算法與密鑰本來就是分開的，演算法本來就是公開的，語言只是對這種演算法的實現而已，在這種情況下DES與語言沒有任何相關性，只有自己的演算法標准。
但很多人反映的Java中的DES/TDES與.NET中的DES/TDES不通用，其實並不存在這樣的問題的。兩者是幾乎完全通用的。所以沒有存在不通用的情況的。
由於語言的實現基於自己的習慣與理解上的不同，不同的語言採用了不同的默認參數（默認值），當然，就算在同種語言下，這些參數不同的時加密與解密也會有所不同的（只會默認默認參數就認為不通用的那些人，真想不通這個問題怎麼提出來的）。
事實上DES除了一個key與iv（初始向量）必須保證相同外，還有對加密的不同解釋參數，如mode與paddingmode。DES加密是是塊加密的一種，在處理塊級與未尾塊級時，有不同的方式（mode)如電子密碼本（CBC)之類的，每個參數有不同的加密行為與意義，當然這只是DES加密標準的一部分，並不能獨立出去的。paddingMode則是則塊加密當最後一個塊不足時的填充方式。而在java與net實現加密或解密時都遵從標准，實現了不同的填充方式以供選擇。但由於每個語言的默認值不同，如net中cbc是默認值，而Java中則是另外一個，填充方式的默認值也不相同，所以會出現不設計這兩個參數時，在java與net通信時無法正確解密。所謂的不Java與net中DES不同，僅僅只是默認參數不同，如果你能正確設置這兩個參數，幾乎任何語言中DES加密與解密都是通用的（部分語言中並沒有全部實現DES中的標准，所以可能會出現特定語言的某種加密方式無法在另一種語言中解析）。
所以，DES本身沒有任何區別，他只是一個標准（你家交流電與他家交流電有什麼區別？），對於不同的實現必須依賴於此標准實現，所以DES標准本身而言是相同的。如果說DES在Java與NET中的類庫實現有什麼區別，那麼兩種語言類庫完全沒可比性（兩個人有什麼區別，一張嘴兩隻眼睛的標准外，怕是沒有相同之處了），而對於DES實現支持上，兩者也是幾乎相同，Java與net均實現了DES標准全部的規范。
最後想說的是，加密學中只介紹DES，並不說在不同語言中的實現，因為任何語言實現都依賴於相同的DES加解密演算法。我覺得這個問題應該問成「在DES在java中與NET中實現的類庫默認值有什麼不同」才對。
⑦ JAVA和.NET使用DES對稱加密的區別
如果我說沒有區別你會信嗎？
但答案還真是這樣，兩者沒有任何區別的，只不過實現的語言代碼不同而已。
那麼java與dot net之間的DES是否可以通用？答案也是完全通用。無論是Java的DES加密還是dot net的DES回密，均可以使用另一種語言且不限於Java或dot net解密。夠明白嗎？
DES其實只是一個演算法，加密與解密我們都知道演算法與密碼是分離的。演算法是公開的，都可以用，而密碼是獨立於演算法的。所以DES在不同的語言中實現的演算法根本就是一樣的——也正是因為如此不管何種語言都是通用的（除非偽DES，要知道DES演算法網上本身能搜到而且是一個標准，最先是由美國安全部門公開的）
再說一下，為什麼有人「通」用不起來的原因。DES其實有CBC之類的參數的，也就是針對加密塊選用的不同的加密手段。正是這個參數的原因，不同的語言中使用不同的參數做為默認值，所以使用默認的方式進行讓兩個串進行加解密肯定是不同的。DES使用一種模式（方法）加密，用另一種模式(方法）進行解密能得到正確的結果嗎？一些人不怪自己的學藝不精，反說是兩種語言的DES不通用（這也就是為什麼網路上會出現諸多說java和dot net的DES加密方法不通用的原因）。
即便是自己使用的DES加密的代碼也是通用的（前提你要遵守DES分開演算法），但不要「重復實現已經實現的東西（專業術語叫造輪子）」。
附：
DES.Model屬性取值
CBC 密碼塊鏈 (CBC) 模式引入了反饋。每個純文本塊在加密前，通過按位「異或」操作與前一個塊的密碼文本結合。這樣確保了即使純文本包含許多相同的塊，這些塊中的每一個也會加密為不同的密碼文本塊。在加密塊之前，初始化向量通過按位「異或」操作與第一個純文本塊結合。如果密碼文本塊中有一個位出錯，相應的純文本塊也將出錯。此外，後面的塊中與原出錯位的位置相同的位也將出錯。
ECB 電子密碼本 (ECB) 模式分別加密每個塊。這意味著任何純文本塊只要相同並且在同一消息中，或者在用相同的密鑰加密的不同消息中，都將被轉換成同樣的密碼文本塊。如果要加密的純文本包含大量重復的塊，則逐塊破解密碼文本是可行的。另外，隨時准備攻擊的對手可能在您沒有察覺的情況下替代和交換個別的塊。如果密碼文本塊中有一個位出錯，相應的整個純文本塊也將出錯。
OFB 輸出反饋 (OFB) 模式將少量遞增的純文本處理成密碼文本，而不是一次處理整個塊。此模式與 CFB 相似；這兩種模式的唯一差別是移位寄存器的填充方式不同。如果密碼文本中有一個位出錯，純文本中相應的位也將出錯。但是，如果密碼文本中有多餘或者缺少的位，則那個位之後的純文本都將出錯。
CFB 密碼反饋 (CFB) 模式將少量遞增的純文本處理成密碼文本，而不是一次處理整個塊。該模式使用在長度上為一個塊且被分為幾部分的移位寄存器。例如，如果塊大小為 8 個位元組，並且每次處理一個位元組，則移位寄存器被分為 8 個部分。如果密碼文本中有一個位出錯，則一個純文本位出錯，並且移位寄存器損壞。這將導致接下來若干次遞增的純文本出錯，直到出錯位從移位寄存器中移出為止。
CTS 密碼文本竊用 (CTS) 模式處理任何長度的純文本並產生長度與純文本長度匹配的密碼文本。除了最後兩個純文本塊外，對於所有其他塊，此模式與 CBC 模式的行為相同。
DES.Padding屬性的取值
None 不填充。
PKCS7 PKCS #7 填充字元串由一個位元組序列組成，每個位元組填充該位元組序列的長度。
Zeros 填充字元串由設置為零的位元組組成。
ANSIX923 ANSIX923 填充字元串由一個位元組序列組成，此位元組序列的最後一個位元組填充位元組序列的長度，其餘位元組均填充數字零。
ISO10126 ISO10126 填充字元串由一個位元組序列組成，此位元組序列的最後一個位元組填充位元組序列的長度，其餘位元組填充隨機數據。
當Mode不同時，解密的內密內容能與相同嗎？PaddingMode不同時，解密的內容的結尾部分能相同嗎（填充結果只涉及到最後的一個塊）.所以當不管何種語言使用相同的Mode及PaddingMode時，加解密的結果是相同的（當然不排除部分語言不實現全部的Mode和PaddingMode)但，基本的都是實現了的，所以基本上任何兩種語言之間的DES都可以實現相同的加解密結果！而java和dot net中的DES顯然指的是演算法，兩者是相同的，可以隨意使用（Java中dot net中的Mode默認值是不同的，一定要設置相同的Mode和PaddingMode才可以的，不要雙方都採用默認值，那樣真的通不起來）
⑧ 這段JAVA代碼什麼意思
javax.crypto.Cipher類提供加密和解密功能，該類是JCE框架的核心。
一，與所有的引擎類一樣，可以通過調用Cipher類中的getInstance靜態工廠方法得到Cipher對象。
public static Cipher getInstance(String transformation);
public static Cipher getInstance(String transformation,String provider);
參數transformation是一個字元串，它描述了由指定輸入產生輸出所進行的操作或操作集合。
參數transformation總是包含密碼學演算法名稱，比如DES，也可以在後麵包含模式和填充方式。
參數transformation可以是下列兩種形式之一：
「algorithm/mode/padding」
「algorithm」
例如下面的例子就是有效的transformation形式：
"DES/CBC/PKCS5Padding"
"DES"
如 果沒有指定模式或填充方式，就使用特定提供者指定的默認模式或默認填充方式。蠢陸例如，SunJCE提供者使用ECB作為DES、DES-EDE和 Blowfish等Cipher的默認模式，並使用PKCS5Padding作為它們默認的填充方案。這意味著在SunJCE提供者中，下列形式的聲明是 等價的：Cipher c1=Cipher.getInstance("DES/ECB/PKCS5Padding");
Cipher c1=Cipher.getInstance("DES");
當 以流加密方式請求以塊劃分的cipher時，可以在模式名後面跟上一次運算需要操作的bit數目，例如採用"DES/CFB8/NoPadding"和 "DES/OFB32/PKCS5Padding"形式的transformation參數塵備。如果沒有指定數目，則使用提供者指定的默認值（例如 SunJCE提供者使用的默認值是64bit）。
getInstance工廠方法返回的對象沒有派檔毀進行初始化，因此在使用前必須進行初始化。
通過getInstance得到的Cipher對象必須使用下列四個模式之一進行初始化，這四個模式在Cipher類中被定義為final integer常數，我們可以使用符號名來引用這些模式：
ENCRYPT_MODE,加密數據
DECRYPT_MODE,解密數據
WRAP_MODE,將一個Key封裝成位元組，可以用來進行安全傳輸
UNWRAP_MODE,將前述已封裝的密鑰解開成java.security.Key對象
每個Cipher初始化方法使用一個模式參數opmod，並用此模式初始化Cipher對象。此外還有其他參數，包括密鑰key、包含密鑰的證書certificate、演算法參數params和隨機源random。
我們可以調用以下的init方法之一來初始化Cipher對象：
public void init(int opmod,Key key);
public void init(int opmod,Certificate certificate);
public void init(int opmod,Key key,SecureRandom random);
public void init(int opmod,Certificate certificate,SecureRandom random);
public void init(int opmod,Key key,AlgorithmParameterSpec params);
public void init(int opmod,Key key,AlgorithmParameterSpec params,SecureRandom random);
public void init(int opmod,Key key,AlgorithmParameters params);
public void init(int opmod,Key key,AlgorithmParameters params,SecureRandom random);
必須指出的是，加密和解密必須使用相同的參數。當Cipher對象被初始化時，它將失去以前得到的所有狀態。即，初始化Cipher對象與新建一個Cipher實例然後將它初始化是等價的。
二，可以調用以下的doFinal（）方法之一完成單步的加密或解密數據：
public byte[] doFinal(byte[] input);
public byte[] doFinal(byte[] input,int inputOffset,int inputLen);
public int doFinal(byte[] input,int inputOffset,int inputLen,byte[] output);
public int doFinal(byte[] input,int inputOffset,int inputLen,byte[] output,int outputOffset);
在多步加密或解密數據時，首先需要一次或多次調用update方法，用以提供加密或解密的所有數據：
public byte[] update(byte[] input);
public byte[] update(byte[] input,int inputOffset,int inputLen);
public int update(byte[] input,int inputOffset,int inputLen,byte[] output);
public int update(byte[] input,int inputOffset,int inputLen,byte[] output,int outputOffset);
如果還有輸入數據，多步操作可以使用前面提到的doFinal方法之一結束。如果沒有數據，多步操作可以使用下面的doFinal方法之一結束：
public byte[] doFinal();
public int doFinal(byte[] output,int outputOffset);
如果在transformation參數部分指定了padding或unpadding方式，則所有的doFinal方法都要注意所用的padding或unpadding方式。
調用doFinal方法將會重置Cipher對象到使用init進行初始化時的狀態，就是說，Cipher對象被重置，使得可以進行更多數據的加密或解密，至於這兩種模式，可以在調用init時進行指定。
三，包裹wrap密鑰必須先使用WRAP_MODE初始化Cipher對象，然後調用以下方法：
public final byte[] wrap(Key key);
如果將調用wrap方法的結果（wrap後的密鑰位元組）提供給解包裹unwrap的人使用，必須給接收者發送以下額外信息：
（1）密鑰演算法名稱:
密鑰演算法名稱可以調用Key介面提供的getAlgorithm方法得到：
public String getAlgorithm();
（2）被包裹密鑰的類型（Cipher.SECRET_KEY,Cipher.PRIVATE_KEY,Cipher.PUBLIC_KEY)
sourcelink: http://bbs.s.e.cn/pc/pccon.php?id=1292&nid=41716&order=&tid=
為了對調用wrap方法返回的位元組進行解包，必須先使用UNWRAP_MODE模式初始化Cipher對象，然後調用以下方法 ：
public final Key unwrap(byte[] wrappedKey,String wrappedKeyAlgorithm,int wrappedKeyType));
其 中，參數wrappedKey是調用wrap方法返回的位元組，參數wrappedKeyAlgorithm是用來包裹密鑰的演算法，參數 wrappedKeyType是被包裹密鑰的類型，該類型必須是Cipher.SECRET_KEY,Cipher.PRIVATE_KEY, Cipher.PUBLIC_KEY三者之一。
四，SunJCE提供者實現的cipher演算法使用如下參數：
（1）採用CBC、CFB、OFB、PCBC模式的DES、DES-EDE和Blowfish演算法。，它們使用初始化向量IV作為參數。可以使用javax.crypto.spec.IvParameterSpec類並使用給定的IV參數來初始化Cipher對象。
（2）PBEWithMD5AndDES使用的參數是一個由鹽值和迭代次數組成的參數集合。可以使用javax.crypto.spec.PBEParameterSpec類並利用給定鹽值和迭代次數來初始化Cipher對象。
注意：如果使用SealedObject類，就不必為解密運算參數的傳遞和保存擔心。這個類在加密對象內容中附帶了密封和加密的參數，可以使用相同的參數對其進行解封和解密。
Cipher 中的某些update和doFinal方法允許調用者指定加密或解密數據的輸出緩存。此時，保證指定的緩存足夠大以容納加密或解密運算的結果是非常重要 的
⑨ JAVA中Given final block not properly padded怎麼辦
獲取Cipher對象時必須要寫成：Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");
不能寫成：Cipher cipher = Cipher.getInstance("DES");
否則解密時候報錯：Given final block not properly padded
原因：Cipher cipher = Cipher.getInstance("DES");與Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
等同，填充方式錯誤，加密的時候會得到16長度的位元組數組。
解密時報錯：javax.crypto.BadPaddingException: Given final block not properly padded
仔細分析一下，不難發現，該異常是在解密的時候拋出的，加密的方法沒有問題。
但是兩個方法的唯一差別是Cipher對象的模式不一樣，這就排除了程序寫錯的可能性。再看一下異常的揭示信息，大概的意思是：提供的字塊不符合填補的。
原來在用DES加密的時候，最後一位長度不足64的，它會自動填補到64，那麼在我們進行位元組數組到字串的轉化過程中，可以把它填補的不可見字元改變了，所以引發系統拋出異常。
為了方便使用，我們再寫一個新的方法封裝一下原來的方法：
public static String DataEncrypt(String str, byte[] key) {
String encrypt = null;
try {
byte[] ret = encode(str.getBytes("UTF-8"),key);
encrypt = new String(Base64.encode(ret));
}
catch(Exception e){
System.out.print(e); encrypt = str;
}
return encrypt;
}
public static String DataDecrypt(String str, byte[] key) {
String decrypt = null;
try {
byte[] ret = decode(Base64.decode(str),key);
decrypt = new String(ret,"UTF-8");
}
catch(Exception e) {
System.out.print(e);
decrypt = str;
}
return decrypt;
}
(9)javadescbc加密擴展閱讀：
java中的Cipher類
位於javax.crypto包下，聲明為 public classCipherextends Object
此類為加密和解密提供密碼功能。它構成了 Java Cryptographic Extension (JCE) 框架的核心。
為創建 Cipher 對象，應用程序調用 Cipher 的getInstance方法並將所請求轉換的名稱傳遞給它。還可以指定提供者的名稱（可選）。
轉換是一個字元串，它描述為產生某種輸出而在給定的輸入上執行的操作（或一組操作）。轉換始終包括加密演算法的名稱（例如，DES），後面可能跟有一個反饋模式和填充方案。
轉換具有以下形式：
「演算法/模式/填充」或「演算法」
（後一種情況下，使用模式和填充方案特定於提供者的默認值）。例如，以下是有效的轉換：
Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
使用CFB和OFB之類的模式，Cipher 塊可以加密單元中小於該 Cipher 的實際塊大小的數據。請求這樣一個模式時，可以指定一次處理的位數（可選）：將此數添加到模式名稱中，正如 "DES/CFB8/NoPadding" 和 "DES/OFB32/PKCS5Padding" 轉換所示。
如果未指定該數，則將使用特定於提供者的默認值。（例如，SunJCE 提供者對 DES 使用默認的 64 位）。因此，通過使用如 CFB8 或 OFB8 的 8 位模式，Cipher 塊可以被轉換為面向位元組的 Cipher 流。
1、欄位
public static final intENCRYPT_MODE 用於將 Cipher 初始化為加密模式的常量。
public static final int DECRYPT_MODE 用於將 Cipher 初始化為解密模式的常量。
public static final int WRAP_MODE 用於將 Cipher 初始化為密鑰包裝模式的常量。
public static final int UNWRAP_MODE 用於將 Cipher 初始化為密鑰解包模式的常量。
public static final int PUBLIC_KEY 用於表示要解包的密鑰為「公鑰」的常量。
public static final int PRIVATE_KEY 用於表示要解包的密鑰為「私鑰」的常量。
public static final int SECRET_KEY 用於表示要解包的密鑰為「秘密密鑰」的常量。