位元組碼加密
㈠ 密碼學基礎（二）：對稱加密
加密和解密使用相同的秘鑰稱為對稱加密。
DES：已經淘汰
3DES：相對於DES有所加強，但是仍然存在較大風險
AES：全新的對稱加密演算法。
特點決定使用場景，對稱加密擁有如下特點：
速度快，可用於頻率很高的加密場景。
使用同一個秘鑰進行加密和解密。
可選按照128、192、256位為一組的加密方式，加密後的輸出值為所選分組位數的倍數。密鑰的長度不同，推薦加密輪數也不同，加密強度也更強。
例如：
AES加密結果的長度由原字元串長度決定：一個字元為1byte=4bit，一個字元串為n+1byte，因為最後一位為' '，所以當字元串長度小於等於15時，AES128得到的16進制結果為32位，也就是32 4=128byte，當長度超過15時，就是64位為128 2byte。
因為對稱加密速度快的特點，對稱加密被廣泛運用在各種加密場所中。但是因為其需要傳遞秘鑰，一旦秘鑰被截獲或者泄露，其加密就會玩完全破解，所以AES一般和RSA一起使用。
因為RSA不用傳遞秘鑰，加密速度慢，所以一般使用RSA加密AES中鎖使用的秘鑰後，再傳遞秘鑰，保證秘鑰的安全。秘鑰安全傳遞成功後，一直使用AES對會話中的信息進行加密，以此來解決AES和RSA的缺點並完美發揮兩者的優點，其中相對經典的例子就是HTTPS加密，後文會專門研究。
本文針對ECB模式下的AES演算法進行大概講解，針對每一步的詳細演算法不再該文討論范圍內。
128位的明文被分成16個位元組的明文矩陣，然後將明文矩陣轉化成狀態矩陣，以「abcdefghijklmnop」的明文為例：
同樣的，128位密鑰被分成16組的狀態矩陣。與明文不同的是，密文會以列為單位，生成最初的4x8x4=128的秘鑰，也就是一個組中有4個元素，每個元素由每列中的4個秘鑰疊加而成，其中矩陣中的每個秘鑰為1個位元組也就是8位。
生成初始的w[0]、w[1]、w[2]、w[3]原始密鑰之後，通過密鑰編排函數，該密鑰矩陣被擴展成一個44個組成的序列W[0],W[1], … ,W[43]。該序列的前4個元素W[0],W[1],W[2],W[3]是原始密鑰，用於加密運算中的初始密鑰加，後面40個字分為10組，每組4個32位的欄位組成，總共為128位，分別用於10輪加密運算中的輪密鑰加密，如下圖所示：
之所以把這一步單獨提出來，是因為ECB和CBC模式中主要的區別就在這一步。
ECB模式中，初始秘鑰擴展後生成秘鑰組後(w0-w43)，明文根據當前輪數取出w[i,i+3]進行加密操作。
CBC模式中，則使用前一輪的密文(明文加密之後的值)和當前的明文進行異或操作之後再進行加密操作。如圖所示：
根據不同位數分組，官方推薦的加密輪數：
輪操作加密的第1輪到第9輪的輪函數一樣，包括4個操作：位元組代換、行位移、列混合和輪密鑰加。最後一輪迭代不執行列混合。
當第一組加密完成時，後面的組循環進行加密操作知道所有的組都完成加密操作。
一般會將結果轉化成base64位，此時在iOS中應該使用base64編碼的方式進行解碼操作，而不是UTF-8。
base64是一種編碼方式，常用語傳輸8bit位元組碼。其編碼原理如下所示：
將原數據按照3個位元組取為一組，即為3x8=24位
將3x8=24的數據分為4x6=24的數據，也就是分為了4組
將4個組中的數據分別在高位補上2個0，也就成了8x4=32，所以原數據增大了三分之一。
根據base64編碼表對數據進行轉換，如果要編碼的二進制數據不是3的倍數，最後會剩下1個或2個位元組怎麼辦，Base64用x00位元組在末尾補足後，再在編碼的末尾加上1個或2個=號，表示補了多少位元組，解碼的時候，會自動去掉。
舉個栗子：Man最後的結果就是TWFu。
計算機中所有的數據都是以0和1的二進制來存儲，而所有的文字都是通過ascii表轉化而來進而顯示成對應的語言。但是ascii表中存在許多不可見字元，這些不可見字元在數據傳輸時，有可能經過不同硬體上各種類型的路由，在轉義時容易發生錯誤，所以規定了64個可見字元（a-z、A-Z、0-9、+、/）,通過base64轉碼之後，所有的二進制數據都是可見的。
ECB和CBC是兩種加密工作模式。其相同點都是在開始輪加密之前，將明文和密文按照128/192/256進行分組。以128位為例，明文和密文都分為16組，每組1個位元組為8位。
ECB工作模式中，每一組的明文和密文相互獨立，每一組的明文通過對應該組的密文加密後生成密文，不影響其他組。
CBC工作模式中，後一組的明文在加密之前先使用前一組的密文進行異或運算後再和對應該組的密文進行加密操作生成密文。
為簡單的分組加密。將明文和密文分成若干組後，使用密文對明文進行加密生成密文
CBC
加密：
解密：
㈡ 開發中常見的加密方式及應用
開發中常見的加密方式及應用
一、base64
簡述：Base64是網路上最常見的用於傳輸8Bit 位元組碼 的編碼方式之一，Base64就是一種基於64個可列印字元來表示二進制數據的方法。所有的數據都能被編碼為並只用65個字元就能表示的文本文件。( 65字元：A~Z a~z 0~9 + / = )編碼後的數據~=編碼前數據的4/3，會大1/3左右（圖片轉化為base64格式會比原圖大一些）。
應用：Base64編碼是從二進制到字元的過程，可用於在 HTTP 環境下傳遞較長的標識信息。例如，在java Persistence系統Hibernate中，就採用了Base64來將一個較長的唯一 標識符 （一般為128-bit的UUID）編碼為一個字元串，用作HTTP 表單 和HTTP GET URL中的參數。在其他應用程序中，也常常需要把二進制 數據編碼 為適合放在URL（包括隱藏 表單域 ）中的形式。此時，採用Base64編碼具有不可讀性，需要解碼後才能閱讀。
命令行進行Base64編碼和解碼
編碼：base64 123.png -o 123.txt
解碼：base64 123.txt -o test.png -D Base64編碼的原理
原理：
1)將所有字元轉化為ASCII碼;
2)將ASCII碼轉化為8位二進制;
3)將二進制3個歸成一組(不足3個在後邊補0)共24位，再拆分成4組，每組6位;
4)統一在6位二進制前補兩個0湊足8位;
5)將補0後的二進制轉為十進制;
6)從Base64編碼表獲取十進制對應的Base64編碼;
Base64編碼的說明：
a.轉換的時候，將三個byte的數據，先後放入一個24bit的緩沖區中，先來的byte占高位。
b.數據不足3byte的話，於緩沖區中剩下的bit用0補足。然後，每次取出6個bit，按照其值選擇查表選擇對應的字元作為編碼後的輸出。
c.不斷進行，直到全部輸入數據轉換完成。
d.如果最後剩下兩個輸入數據，在編碼結果後加1個「=」;
e.如果最後剩下一個輸入數據，編碼結果後加2個「=」;
f.如果沒有剩下任何數據，就什麼都不要加，這樣才可以保證資料還原的正確性。
二、HASH加密/單向散列函數
簡述：Hash演算法特別的地方在於它是一種單向演算法，用戶可以通過Hash演算法對目標信息生成一段特定長度（32個字元）的唯一的Hash值，卻不能通過這個Hash值重新獲得目標信息。對用相同數據，加密之後的密文相同。 常見的Hash演算法有MD5和SHA。由於加密結果固定，所以基本上原始的哈希加密已經不再安全，於是衍生出了加鹽的方式。加鹽：先對原始數據拼接固定的字元串再進行MD5加密。
特點：
1) 加密 後密文的長度是定長(32個字元的密文)的
2)如果明文不一樣，那麼散列後的結果一定不一樣
3)如果明文一樣，那麼加密後的密文一定一樣(對相同數據加密，加密後的密文一樣)
4)所有的加密演算法是公開的
5)不可以逆推反算(不能根據密文推算出明文)，但是可以暴力 破解 ，碰撞監測
原理：MD5消息摘要演算法，屬Hash演算法一類。MD5演算法對輸入任意長度的消息進行運行，產生一個128位的消息摘要。
1)數據填充
對消息進行數據填充，使消息的長度對512取模得448，設消息長度為X，即滿足X mod 512=448。根據此公式得出需要填充的數據長度。
填充方法：在消息後面進行填充，填充第一位為1，其餘為0。
2)添加信息長度
在第一步結果之後再填充上原消息的長度，可用來進行的存儲長度為64位。如果消息長度大於264，則只使用其低64位的值，即（消息長度 對264取模）。
在此步驟進行完畢後，最終消息長度就是512的整數倍。
3)數據處理
准備需要用到的數據：
4個常數：A = 0x67452301, B = 0x0EFCDAB89, C = 0x98BADCFE, D = 0x10325476;
4個函數：F(X,Y,Z)=(X & Y) | ((~X) & Z);G(X,Y,Z)=(X & Z) | (Y & (~Z));H(X,Y,Z)=X ^ Y ^ Z;I(X,Y,Z)=Y ^ (X | (~Z));
把消息分以512位為一分組進行處理，每一個分組進行4輪變換，以上面所說4個常數為起始變數進行計算，重新輸出4個變數，以這4個變數再進行下一分組的運算，如果已經是最後一個分組，則這4個變數為最後的結果，即MD5值。
三、對稱加密
經典演算法：
1)DES數據加密標准
DES演算法的入口參數有三個：Key、Data、Mode。其中Key為8個位元組共64位，是DES演算法的工作密鑰；Data也為8個位元組64位，是要被加密或被解密的數據；Mode為DES的工作方式，有兩種：加密或解密。
DES演算法是這樣工作的：如Mode為加密，則用Key去把數據Data進行加密， 生成Data的密碼形式（64位）作為DES的輸出結果；如Mode為解密，則用Key去把密碼形式的數據Data解密，還原為Data的明碼形式（64位）作為DES的輸出結果。在通信網路的兩端，雙方約定一致的Key，在通信的源點用Key對核心數據進行DES加密，然後以密碼形式在公共通信網（如電話網）中傳輸到通信網路的終點，數據到達目的地後，用同樣的Key對密碼數據進行解密，便再現了明碼形式的核心數據。這樣，便保證了核心數據（如PIN、MAC等）在公共通信網中傳輸的安全性和可靠性。
2)3DES使用3個密鑰，對消息進行(密鑰1·加密)+(密鑰2·解密)+(密鑰3·加密)
3)AES高級加密標准
如圖，加密/解密使用相同的密碼，並且是可逆的
四、非對稱加密
特點：
1)使用公鑰加密，使用私鑰解密
2)公鑰是公開的，私鑰保密
3)加密處理安全，但是性能極差
經典演算法RSA:
1)RSA原理
(1)求N，准備兩個質數p和q,N = p x q
(2)求L,L是p-1和q-1的最小公倍數。L = lcm(p-1,q-1)
(3)求E，E和L的最大公約數為1(E和L互質)
(4)求D，E x D mode L = 1
五、數字簽名
原理以及應用場景:
1)數字簽名的應用場景
需要嚴格驗證發送方身份信息情況
2)數字簽名原理
(1)客戶端處理
對"消息"進行HASH得到"消息摘要"
發送方使用自己的私鑰對"消息摘要"加密(數字簽名)
把數字簽名附著在"報文"的末尾一起發送給接收方
(2)服務端處理
對"消息" HASH得到"報文摘要"
使用公鑰對"數字簽名"解密
對結果進行匹配
六、數字證書
簡單說明:
證書和駕照很相似，裡面記有姓名、組織、地址等個人信息，以及屬於此人的公鑰，並有認證機構施加數字簽名,只要看到公鑰證書，我們就可以知道認證機構認證該公鑰的確屬於此人。
數字證書的內容：
1)公鑰
2)認證機構的數字簽名
證書的生成步驟：
1)生成私鑰openssl genrsa -out private.pem 1024
2)創建證書請求openssl req -new -key private.pem -out rsacert.csr
3)生成證書並簽名，有效期10年openssl x509 -req -days 3650 -in rsacert.csr -signkey private.pem -out rsacert.crt
4)將PEM格式文件轉換成DER格式openssl x509 -outform der -in rsacert.crt -out rsacert.der
5)導出P12文件openssl pkcs12 -export -out p.p12 -inkey private.pem -in rsacert.crt
iOS開發中的注意點：
1)在iOS開發中，不能直接使用PEM格式的證書，因為其內部進行了Base64編碼，應該使用的是DER的證書，是二進制格式的；
2)OpenSSL默認生成的都是PEM格式的證書。
七、https
HTTPS和HTTP的區別：
超文本傳輸協議HTTP協議被用於在Web瀏覽器和網站伺服器之間傳遞信息。HTTP協議以明文方式發送內容，不提供任何方式的數據加密，如果攻擊者截取了Web瀏覽器和網站伺服器之間的傳輸報文，就可以直接讀懂其中的信息，因此HTTP協議不適合傳輸一些敏感信息，比如信用卡號、密碼等。
為了解決HTTP協議的這一缺陷，需要使用另一種協議：安全套接字層超文本傳輸協議HTTPS。為了數據傳輸的安全，HTTPS在HTTP的基礎上加入了SSL協議，SSL依靠證書來驗證伺服器的身份，並為瀏覽器和伺服器之間的通信加密。
HTTPS和HTTP的區別主要為以下四點：
1)https協議需要到ca申請證書，一般免費證書很少，需要交費。
2)http是 超文本傳輸協議 ，信息是明文傳輸，https則是具有 安全性 的 ssl 加密傳輸協議。
3)http和https使用的是完全不同的連接方式，用的埠也不一樣，前者是80，後者是443。
4)http的連接很簡單，是無狀態的；HTTPS協議是由SSL+HTTP協議構建的可進行加密傳輸、身份認證的 網路協議 ，比http協議安全。
5)SSL：Secure Sockets Layer安全套接字層;用數據加密(Encryption)技術，可確保數據在網路上傳輸過程中不會被截取及竊聽。目前一般通用之規格為40 bit之安全標准，美國則已推出128 bit之更高安全標准，但限制出境。只要3.0版本以上之I.E.或Netscape 瀏覽器 即可支持SSL。目前版本為3.0。SSL協議位於TCP/IP協議與各種應用層協議之間，為數據通訊提供安全支持。SSL協議可分為兩層：SSL記錄協議(SSL Record Protocol)：它建立在可靠的傳輸協議(如TCP)之上，為高層協議提供數據封裝、壓縮、加密等基本功能的支持。SSL握手協議(SSL Handshake Protocol)：它建立在SSL記錄協議之上，用於在實際的數據傳輸開始前，通訊雙方進行身份認證、協商加密演算法、交換加密密鑰等。
㈢ java密碼加密與解密
以下兩個類可以很方便的完成字元串的加密和解密
加密 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
㈣ 加密後的字元串最後有兩個「==」是什麼加密演算法
Base64是網路上最常見的用於傳輸8Bit位元組碼的編碼方式之一，Base64就是一種基於64個可列印字元來表示二進制數據的方法。
1，Base64使用US-ASCII子集的64個字元,即大小寫的26個英文字母，0－9，＋，/。
2，編碼總是基於3個字元，每個字元用8位二進製表示，因此一共24位，再分為4四組，每組6位，表示一個Base64的值。
3，Base64值為0就是A，為27的就是b。這樣，每3個字元產生4位的Base64字元。如果被加密的字元串每3個一組，還剩1或2個字元，使用特殊字元"="補齊Base64的4字。
(4)位元組碼加密擴展閱讀：
應用
Base64編碼可用於在HTTP環境下傳遞較長的標識信息。例如，在Java Persistence系統Hibernate中，就採用了Base64來將一個較長的一個標識符（一般為128-bit的UUID）編碼為一個字元串，用作HTTP表單和HTTP GET URL中的參數。
在其他應用程序中，也常常需要把二進制數據編碼為適合放在URL（包括隱藏表單域）中的形式。此時，採用Base64編碼不僅比較簡短，同時也具有不可讀性，即所編碼的數據不會被人用肉眼所直接看到。
然而，標準的Base64並不適合直接放在URL里傳輸，因為URL編碼器會把標准Base64中的「/」和「+」字元變為形如「%XX」的形式，而這些「%」號在存入資料庫時還需要再進行轉換。
因為ANSI SQL中已將「%」號用作通配符。
為解決此問題，可採用一種用於URL的改進Base64編碼，它不僅在末尾去掉填充的'='號，並將標准Base64中的「+」和「/」分別改成了「-」和「_」。
這樣就免去了在URL編解碼和資料庫存儲時所要作的轉換，避免了編碼信息長度在此過程中的增加，並統一了資料庫、表單等處對象標識符的格式。
另有一種用於正則表達式的改進Base64變種，它將「+」和「/」改成了「!」和「-」，因為「+」,「/」以及前面在IRCu中用到的「[」和「]」在正則表達式中都可能具有特殊含義。
此外還有一些變種，它們將「+/」改為「_-」或「._」（用作編程語言中的標識符名稱）或「.-」（用於XML中的Nmtoken）甚至「_:」（用於XML中的Name）。
㈤ java加密解密代碼
package com.cube.limail.util;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;/**
* 加密解密類
*/
public class Eryptogram
{
private static String Algorithm ="DES";
private String key="CB7A92E3D3491964";
//定義 加密演算法,可用 DES,DESede,Blowfish
static boolean debug = false ;
/**
* 構造子註解.
*/
public Eryptogram ()
{
} /**
* 生成密鑰
* @return byte[] 返回生成的密鑰
* @throws exception 扔出異常.
*/
public static byte [] getSecretKey () throws Exception
{
KeyGenerator keygen = KeyGenerator.getInstance (Algorithm );
SecretKey deskey = keygen.generateKey ();
System.out.println ("生成密鑰:"+bytesToHexString (deskey.getEncoded ()));
if (debug ) System.out.println ("生成密鑰:"+bytesToHexString (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 ("加密前的二進串:"+byte2hex (input ));
System.out.println ("加密前的字元串:"+new String (input ));
} Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.ENCRYPT_MODE ,deskey );
byte [] cipherByte =c1.doFinal (input );
if (debug ) System.out.println ("加密後的二進串:"+byte2hex (cipherByte ));
return cipherByte ;
} /**
* 將給定的已加密的數據通過指定的密鑰進行解密
* @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 ("解密前的信息:"+byte2hex (input ));
Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.DECRYPT_MODE ,deskey );
byte [] clearByte =c1.doFinal (input );
if (debug )
{
System.out.println ("解密後的二進串:"+byte2hex (clearByte ));
System.out.println ("解密後的字元串:"+(new String (clearByte )));
} return clearByte ;
} /**
* 位元組碼轉換成16進制字元串
* @param byte[] b 輸入要轉換的位元組碼
* @return String 返回轉換後的16進制字元串
*/
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 ();
}
/**
* 字元串轉成位元組數組.
* @param hex 要轉化的字元串.
* @return byte[] 返回轉化後的字元串.
*/
public static byte[] hexStringToByte(String hex) {
int len = (hex.length() / 2);
byte[] result = new byte[len];
char[] achar = hex.toCharArray();
for (int i = 0; i < len; i++) {
int pos = i * 2;
result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
}
return result;
}
private static byte toByte(char c) {
byte b = (byte) "0123456789ABCDEF".indexOf(c);
return b;
}
/**
* 位元組數組轉成字元串.
* @param String 要轉化的字元串.
* @return 返回轉化後的位元組數組.
*/
public static final String bytesToHexString(byte[] bArray) {
StringBuffer sb = new StringBuffer(bArray.length);
String sTemp;
for (int i = 0; i < bArray.length; i++) {
sTemp = Integer.toHexString(0xFF & bArray[i]);
if (sTemp.length() < 2)
sb.append(0);
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}
/**
* 從資料庫中獲取密鑰.
* @param deptid 企業id.
* @return 要返回的位元組數組.
* @throws Exception 可能拋出的異常.
*/
public static byte[] getSecretKey(long deptid) throws Exception {
byte[] key=null;
String value=null;
//CommDao =new CommDao();
// List list=.getRecordList("from Key k where k.deptid="+deptid);
//if(list.size()>0){
//value=((com.csc.sale.bean.Key)list.get(0)).getKey();
value = "CB7A92E3D3491964";
key=hexStringToByte(value);
//}
if (debug)
System.out.println("密鑰:" + value);
return key;
}
public String encryptData2(String data) {
String en = null;
try {
byte[] key=hexStringToByte(this.key);
en = bytesToHexString(encryptData(data.getBytes(),key));
} catch (Exception e) {
e.printStackTrace();
}
return en;
}
public String decryptData2(String data) {
String de = null;
try {
byte[] key=hexStringToByte(this.key);
de = new String(decryptData(hexStringToByte(data),key));
} catch (Exception e) {
e.printStackTrace();
}
return de;
}
} 加密使用： byte[] key=Eryptogram.getSecretKey(deptid); //獲得鑰匙（位元組數組）
byte[] tmp=Eryptogram.encryptData(password.getBytes(), key); //傳入密碼和鑰匙，獲得加密後的位元組數組的密碼
password=Eryptogram.bytesToHexString(tmp); //將位元組數組轉化為字元串，獲得加密後的字元串密碼解密與之差不多
㈥ 如何對java的class類進行加密
可以使用Virbox Protector Standalone 加殼工具對java的class類進行加密，支持各種開發語言的程序加密。可防止代碼反編譯，更安全，更方便
產品簡介
Virbox Protector Standalone提供了強大的代碼虛擬化、高級混淆與智能壓縮技術，保護您的程序免受逆向工程和非法修改。
Virbox Protector Standalone 將被保護的程序代碼轉換為虛擬機代碼，程序運行時，虛擬機將模擬程序執行，進入和離開虛擬機都有高級代碼混淆。虛擬機配合代碼混淆可以達到很好的保護效果，尤其是開發者的私有邏輯。高級混淆利用花指令和代碼非等價變形等技術，將程序的代碼，轉換成一種功能上等價，但是難於閱讀和理解的代碼，可充分干擾靜態分析。應用程序的解壓縮含有動態密碼，讓一切自動脫殼工具失效，有效的阻止.Net、PE 程序的直接反編譯。
特點
多種加密策略：代碼虛擬化、高級混淆、智能壓縮
性能分析：智能分析引擎，一鍵分析各個函數模塊調用的次數
支持多種開發語言：多種開發語言加殼支持
源碼級保護：保護到匯編級別，c#保護IL級別
免費更新：免費版本升級