javaecb
Java和.NET的系統類庫里都有封裝DES對稱加密的實現方式，但是對外暴露的介面卻各不相同，甚至有時會讓自己難以解決其中的問題
DES加密
DES是一種對稱加密(Data Encryption Standard)演算法，以前我寫過一篇文章：.NET中加密解密相關知識，有過簡單描述。
DES演算法一般有兩個關鍵點，第一個是加密演算法，第二個是數據補位。
加密演算法常見的有ECB模式和CBC模式：
ECB模式：電子密本方式，這是JAVA封裝的DES演算法的默認模式，就是將數據按照8個位元組一段進行DES加密或解密得到一段8個位元組的密文或者明文，最後一段不足8個位元組，則補足8個位元組（注意：這里就涉及到數據補位了）進行計算，之後按照順序將計算所得的數據連在一起即可，各段數據之間互不影響。
CBC模式：密文分組鏈接方式，這是.NET封裝的DES演算法的默認模式，它比較麻煩，加密步驟如下：
1、首先將數據按照8個位元組一組進行分組得到D1D2......Dn（若數據不是8的整數倍，就涉及到數據補位了）
2、第一組數據D1與向量I異或後的結果進行DES加密得到第一組密文C1（注意：這里有向量I的說法，ECB模式下沒有使用向量I）
3、第二組數據D2與第一組的加密結果C1異或以後的結果進行DES加密，得到第二組密文C2
4、之後的數據以此類推，得到Cn
5、按順序連為C1C2C3......Cn即為加密結果。
數據補位一般有NoPadding和PKCS7Padding(JAVA中是PKCS5Padding)填充方式，PKCS7Padding和PKCS5Padding實際只是協議不一樣，根據相關資料說明：PKCS5Padding明確定義了加密塊是8位元組，PKCS7Padding加密快可以是1-255之間。但是封裝的DES演算法默認都是8位元組，所以可以認為他們一樣。數據補位實際是在數據不滿8位元組的倍數，才補充到8位元組的倍數的填充過程。
NoPadding填充方式：演算法本身不填充，比如.NET的padding提供了有None，Zeros方式，分別為不填充和填充0的方式。
PKCS7Padding（PKCS5Padding）填充方式：為.NET和JAVA的默認填充方式，對加密數據位元組長度對8取余為r，如r大於0，則補8-r個位元組，位元組為8-r的值；如果r等於0，則補8個位元組8。比如：
加密字元串為為AAA，則補位為AAA55555;加密字元串為BBBBBB，則補位為BBBBBB22；加密字元串為CCCCCCCC，則補位為CCCCCCCC88888888。
.NET中的DES加密
對於.NET，框架在System.Security.Cryptography命名空間下提供了DESCryptoServiceProvider作為System.Security.Cryptography.DES加密解密的包裝介面，它提供了如下的4個方法：
public override ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgbIV)
public override ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgbIV)
public override void GenerateIV()
public override void GenerateKey()
從.NET類庫封裝情況，加解密需要傳入一個Key和IV向量。而且Key必須為8位元組的數據，否則會直接拋異常出來，當使用ECB模式下，不管傳入什麼IV向量，加密結果都一樣。示例代碼如下：
public static string EncryptWithJava(string key, string str)
{
if (key.Length < 8 || string.IsNullOrEmpty(str))
{
throw new Exception("加密key小於8或者加密字元串為空！");
}
byte[] bKey = Encoding.UTF8.GetBytes(key.Substring(0, 8));
byte[] bIV = IV;
byte[] bStr = Encoding.UTF8.GetBytes(str);
try
{
DESCryptoServiceProvider desc = new DESCryptoServiceProvider();
desc.Padding = PaddingMode.PKCS7;//補位
desc.Mode = CipherMode.ECB;//CipherMode.CBC
using (MemoryStream mStream = new MemoryStream())
{
using (CryptoStream cStream = new CryptoStream(mStream, desc.CreateEncryptor(bKey, bIV),CryptoStreamMode.Write))
{
cStream.Write(bStr, 0, bStr.Length);
cStream.FlushFinalBlock();
StringBuilder ret = new StringBuilder();
byte[] res = mStream.ToArray();
foreach (byte b in res)
{
ret.AppendFormat("{0:x2}", b);
}
return ret.ToString();
}
}
}
catch
{
return string.Empty;
}
}
由於為ECB模式，因此IV這里設置什麼值都是可以的，當為CBC模式下，則需要設置為其他值，比如：public static byte[] IV = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }，才能正常加密解密。
JAVA中的DES加密
JAVA的javax.crypto.Cipher包下，提供了加密解密的功能，它的靜態getInstance方法，可以返回一個Cipher對象，一般有public static final Cipher getInstance(String transformation)方法，transformation為：algorithm/mode/padding，分別表示演算法名稱，比如DES，也可以在後麵包含演算法模式和填充方式，但也可以只是演算法名稱，如為："DES/CBC/PKCS5Padding"，"DES"等。JAVA中默認的演算法為ECB，默認填充方式為PKCS5Padding。Cipher的Init方法用來初始化加密對象，常見的有：
public final void init(int opmode, Key key, AlgorithmParameterSpec params) ，
public final void init(int opmode,Key key, SecureRandom random)，用SecureRandom時，一般用於不需要IV的演算法模式，示例代碼如下：
public static String encrypt2(String src) throws Exception {
SecureRandom sr = new SecureRandom();
DESKeySpec ks = new DESKeySpec(KEY.getBytes("UTF-8"));
SecretKeyFactory skf = SecretKeyFactory.getInstance("DES");
SecretKey sk = skf.generateSecret(ks);
Cipher cip = Cipher.getInstance("DES/CBC/PKCS5Padding");//Cipher.getInstance("DES");
IvParameterSpec iv2 = new IvParameterSpec(IV);
cip.init(Cipher.ENCRYPT_MODE, sk, iv2);//IV的方式
//cip.init(Cipher.ENCRYPT_MODE, sk, sr);//沒有傳遞IV
String dest = byteToHex(cip.doFinal(src.getBytes("UTF-8")));
return dest;
}
當默認用DES，JAVA會用ECB模式，因此這里IV向量沒有作用，這里，但當用CBC模式下，如果還是用SecureRandom，則每次加密的結果都會不一樣，因為JAVA內部會用隨機的IV來初始化Cipher對象，如示例代碼，由於Cipher.getInstance("DES/CBC/PKCS5Padding")使用了CBC，因此我這里用的javax.crypto.spec.IvParameterSpec包下的IvParameterSpec來初始化向量IV：
Private final static byte[] IV = new byte[] {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
總結
對於.NET和JAVA在使用DES對稱加密時，需要大家指定一樣的演算法和填充模式，並且JAVA在寫DES加解密演算法時，還需要根據創建Cipher對象的不同，正確使用IV向量。在不同系統需要互相數據時，必須要明確的是加密演算法，Key和演算法模式，再根據不同模式是否需要IV向量，最後是填充模式
② java的 DES 加密解密方法 求對應php的加密解密方法!!!!急切
DES是一種標準的數據加密演算法，關於這個演算法的詳細介紹可以參考wiki和網路：
php中有一個擴展可以支持DES的加密演算法，是：extension=php_mcrypt.dll
在配置文件中將這個擴展打開還不能夠在windows環境下使用
需要將PHP文件夾下的 libmcrypt.dll 拷貝到系統的 system32 目錄下，這是通過phpinfo可以查看到mcrypt表示這個模塊可以正常試用了。
下面是PHP中使用DES加密解密的一個例子：
//$input-stufftodecrypt
//$key-thesecretkeytouse
functiondo_mencrypt($input,$key)
{
$input=str_replace(""n","",$input);
$input=str_replace(""t","",$input);
$input=str_replace(""r","",$input);
$key=substr(md5($key),0,24);
$td=mcrypt_mole_open('tripledes','','ecb','');
$iv=mcrypt_create_iv(mcrypt_enc_get_iv_size($td),MCRYPT_RAND);
mcrypt_generic_init($td,$key,$iv);
$encrypted_data=mcrypt_generic($td,$input);
mcrypt_generic_deinit($td);
mcrypt_mole_close($td);
returntrim(chop(base64_encode($encrypted_data)));
}
//$input-stufftodecrypt
//$key-thesecretkeytouse
functiondo_mdecrypt($input,$key)
{
$input=str_replace(""n","",$input);
$input=str_replace(""t","",$input);
$input=str_replace(""r","",$input);
$input=trim(chop(base64_decode($input)));
$td=mcrypt_mole_open('tripledes','','ecb','');
$key=substr(md5($key),0,24);
$iv=mcrypt_create_iv(mcrypt_enc_get_iv_size($td),MCRYPT_RAND);
mcrypt_generic_init($td,$key,$iv);
$decrypted_data=mdecrypt_generic($td,$input);
mcrypt_generic_deinit($td);
mcrypt_mole_close($td);
returntrim(chop($decrypted_data));
}
參考自：http://www.cnblogs.com/cocowool/archive/2009/01/07/1371309.html
③ java用3DES加密演算法（ECB/PKCS5Padding）如何計算可以得到下面的結果
3DES需要的輸入明文長度、密文長度都是8的整數倍。
而CBC.CFB都需要初始化向量的參數才能加密、解密、。
④ 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要怎麼實現zeropadding的des解密
packagecom.va.util;
importcom.zoki.util.Charset;
importjava.security.;
importjava.security.InvalidKeyException;
importjava.security.NoSuchAlgorithmException;
importjava.security.spec.InvalidKeySpecException;
importjava.util.logging.Level;
importjava.util.logging.Logger;
importjavax.crypto.BadPaddingException;
importjavax.crypto.spec.DESKeySpec;
importjavax.crypto.SecretKeyFactory;
importjavax.crypto.SecretKey;
importjavax.crypto.Cipher;
importjavax.crypto.IllegalBlockSizeException;
importjavax.crypto.NoSuchPaddingException;
importjavax.crypto.spec.IvParameterSpec;
/**
*注意：DES加密和解密過程中，密鑰長度都必須是8的倍數。<br>
*當默認用DES，JAVA會用ECB模式，因此這里IV向量沒有作用，這里，但當用CBC模式下，如果還是用SecureRandom，
*則每次加密的結果都會不一樣，因為JAVA內部會用隨機的IV來初始化Cipher對象，如示例代碼，
*由於Cipher.getInstance("DES/CBC/PKCS5Padding")使用了CBC，
*因此我這里用的javax.crypto.spec.IvParameterSpec包下的IvParameterSpec來初始化向量IV<br>
*JAVA中默認的演算法為ECB，默認填充方式為PKCS5Padding
*/
publicclassDES{
privateDES(){
}
/**
*加密
*
*@paramsrcbyte[]加密的數據源
*@parampasswordbyte[]加密秘鑰
*@returnbyte[]加密後的數據
*/
publicstaticbyte[]encrypt(byte[]src,byte[]password){
try{
DESKeySpecdesKey=newDESKeySpec(password);
//創建一個密匙工廠，然後用它把DESKeySpec轉換成
SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance("DES");
SecretKeysecurekey=keyFactory.generateSecret(desKey);
//Cipher對象實際完成加密操作
Ciphercipher=Cipher.getInstance("DES/CBC/PKCS5Padding");
//ECB模式下，iv不需要
IvParameterSpeciv=newIvParameterSpec(password);
//用密匙初始化Cipher對象
cipher.init(Cipher.ENCRYPT_MODE,securekey,iv);
//現在，獲取數據並加密
//正式執行加密操作
returncipher.doFinal(src);
}catch(InvalidKeyException|NoSuchAlgorithmException|InvalidKeySpecException|NoSuchPaddingException|IllegalBlockSizeException|BadPaddingException|ex){
Logger.getLogger(DES.class.getName()).log(Level.SEVERE,null,ex);
}
returnnull;
}
/**
*加密
*
*@paramsrcbyte[]加密的數據源
*@parampasswordString加密秘鑰
*@returnbyte[]加密後的數據
*/
publicstaticbyte[]encrypt(byte[]src,Stringpassword){
byte[]keyBytes=password.getBytes(Charset.utf8);
returnencrypt(src,keyBytes);
}
/**
*解密
*
*@paramsrcbyte[]解密的數據源
*@parampasswordbyte[]解密秘鑰
*@returnbyte[]解密後的數據
*/
publicstaticbyte[]decrypt(byte[]src,byte[]password){
try{
//DES演算法要求有一個可信任的隨機數源
//SecureRandomrandom=newSecureRandom();
//創建一個DESKeySpec對象
DESKeySpecdesKey=newDESKeySpec(password);
//創建一個密匙工廠
SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance("DES");
//將DESKeySpec對象轉換成SecretKey對象
SecretKeysecurekey=keyFactory.generateSecret(desKey);
//Cipher對象實際完成解密操作，CBC為加密模式，
Ciphercipher=Cipher.getInstance("DES/CBC/PKCS5Padding");
//ECB模式下，iv不需要
IvParameterSpeciv=newIvParameterSpec(password);
//用密匙初始化Cipher對象
cipher.init(Cipher.DECRYPT_MODE,securekey,iv);
//真正開始解密操作
returncipher.doFinal(src);
}catch(InvalidKeyException|NoSuchAlgorithmException|InvalidKeySpecException|NoSuchPaddingException||IllegalBlockSizeException|BadPaddingExceptionex){
Logger.getLogger(DES.class.getName()).log(Level.SEVERE,null,ex);
}
returnnull;
}
/**
*解密
*
*@paramsrcbyte[]解密的數據源
*@parampasswordString解密秘鑰
*@returnbyte[]解密後的數據
*/
publicstaticbyte[]decrypt(byte[]src,Stringpassword){
byte[]keyBytes=password.getBytes(Charset.utf8);
returndecrypt(src,keyBytes);
}
}
⑥ 如何用Java進行3DES加密解
最近一個合作商提出使用3DES交換數據，本來他們有現成的代碼，可惜只有.net版本，我們的伺服器都是Linux，而且應用都是Java。於是對照他們提供的代碼改了一個Java的版本出來，主要是不熟悉3DES，折騰了一天，終於搞定。
所謂3DES，就是把DES做三次，當然不是簡單地DES DES DES就行了，中途有些特定的排列。這個我可不關心，呵呵，我的目的是使用它。
在網上搜索了一下3DES，找到很少資料。經過朋友介紹，找到GNU Crypto和Bouncy Castle兩個Java擴充包，裡面應該有3DES的實現吧。
從GNU Crypto入手，找到一個TripleDES的實現類，發現原來3DES還有一個名字叫DESede，在網上搜索TripleDES和DESede，呵呵，終於發現更多的資料了。
Java的安全API始終那麼難用，先創建一個cipher看看演算法在不在吧
Cipher cipher = Cipher.getInstance("DESede");
如果沒有拋異常的話，就證明這個演算法是有效的
突然想看看JDK有沒有內置DESede，於是撇開Crypto，直接測試，發現可以正確運行。在jce.jar裡面找到相關的類，JDK內置了。
於是直接用DES的代碼來改&測試，最後代碼變成這樣
SecureRandom sr = new SecureRandom();
DESedeKeySpec dks = new DESedeKeySpec(PASSWORD_CRYPT_KEY.getBytes());
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");
SecretKey securekey = keyFactory.generateSecret(dks);
Cipher cipher = Cipher.getInstance("DESede");
cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
return new String(Hex.encodeHex(cipher.doFinal(str.getBytes())));
需要留意的是，要使用DESede的Spec、Factory和Cipher才行
事情還沒完結，合作商給過來的除了密鑰之外，還有一個IV向量。搜索了一下，發現有一個IvParameterSpec類，於是代碼變成這樣
SecureRandom sr = new SecureRandom();
DESedeKeySpec dks = new DESedeKeySpec(PASSWORD_CRYPT_KEY.getBytes());
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");
SecretKey securekey = keyFactory.generateSecret(dks);
IvParameterSpec iv = new IvParameterSpec(PASSWORD_IV.getBytes());
Cipher cipher = Cipher.getInstance("DESede");
cipher.init(Cipher.ENCRYPT_MODE, securekey, iv, sr);
return new String(Hex.encodeHex(cipher.doFinal(str.getBytes())));
但是，運行報錯了
java.security.: ECB mode cannot use IV
ECB是什麼呢？我的代碼完全沒有寫ECB什麼的
又上網搜索，結果把DES的來龍去脈都搞清楚了
⑦ java des 默認採用什麼加密模式
JAVA和.NET的系統類庫里都有封裝DES對稱加密的實現方式，但是對外暴露的介面卻各不相同，甚至有時會讓自己難以解決其中的問題，比如JAVA加密後的結果在.NET中解密不出來等，由於最近項目有跨JAVA和.NET的加解密，經過我的分析調試，終於讓它們可以互相加密解密了。
DES加密
DES是一種對稱加密(Data Encryption Standard)演算法，以前我寫過一篇文章：.NET中加密解密相關知識，有過簡單描述。
DES演算法一般有兩個關鍵點，第一個是加密演算法，第二個是數據補位。
加密演算法常見的有ECB模式和CBC模式：
⑧ 如何使用javascript進行RSA/ECB/PKCS1Padding演算法加密
javascript rsa加密/java使用Cipher.getInstance("RSA/ECB/PKCS1Padding")解密
1)伺服器端獲得生成密鑰對;
2)javascript使用公鑰加密；
3)java獲得密文使用私鑰解密；
⑨ iOS 純DES 解密的結果 和java 的不一致 是怎麼回事。 java 用的 ("DES/ECB/NoPadding") 這個模式
DES沒試過，試過iOS和java都用AES加密解密，大概的初始化是這樣：
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
估計應該差不多，別用沒有填充的（NoPadding）試試，iOS的實現好像都是有填充的。