對稱加密字元串
主要有DES演算法，3DES演算法，TDEA演算法，Blowfish演算法，RC5演算法，IDEA演算法。
對稱加密演算法的特點是演算法公開、計算量小、加密速度快、加密效率高。優點在於加解密的高速度和使用長密鑰時的難破解性，缺點是交易雙方都使用同樣鑰匙，安全性得不到保證。
對稱演算法的安全性依賴於密鑰，泄漏密鑰就意味著任何人都可以對他們發送或接收的消息解密，所以密鑰的保密性對通信的安全性至關重要。
(1)對稱加密字元串擴展閱讀
常見的加密演算法
DES演算法是密碼體制中的對稱密碼體制，把64位的明文輸入塊變為64位的密文輸出塊，它所使用的密鑰也是64位。
3DES是基於DES的對稱演算法，對一塊數據用三個不同的密鑰進行三次加密，強度更高。
RC2和RC4是對稱演算法，用變長密鑰對大量數據進行加密，比DES快。
IDEA演算法是在DES演算法的基礎上發展出來的，是作為迭代的分組密碼實現的，使用128位的密鑰和8個循環。
RSA是由RSA公司發明，是一個支持變長密鑰的公共密鑰演算法，需要加密的文件塊的長度也是可變的，非對稱演算法。
DSA，即數字簽名演算法，是一種標準的 DSS（數字簽名標准），嚴格來說不算加密演算法。
AES是高級加密標准對稱演算法，是下一代的加密演算法標准，速度快，安全級別高，在21世紀AES 標準的一個實現是 Rijndael演算法。
Blowfish演算法是一個64位分組及可變密鑰長度的對稱密鑰分組密碼演算法，可用來加密64比特長度的字元串。
㈡ 對稱加密演算法以及使用方法
加密的原因：保證數據安全
加密必備要素：1、明文/密文 2、秘鑰 3、演算法
秘鑰：在密碼學中是一個定長的字元串、需要根據加密演算法確定其長度
加密演算法解密演算法一般互逆、也可能相同
常用的兩種加密方式：
對稱加密：秘鑰：加密解密使用同一個密鑰、數據的機密性雙向保證、加密效率高、適合加密於大數據大文件、加密強度不高(相對於非對稱加密)
非對稱加密：秘鑰：加密解密使用的不同秘鑰、有兩個密鑰、需要使用密鑰生成演算法生成兩個秘鑰、數據的機密性只能單向加密、如果想解決這個問題、雙向都需要各自有一對秘鑰、加密效率低、加密強度高
公鑰：可以公開出來的密鑰、公鑰加密私鑰解密
私鑰：需要自己妥善保管、不能公開、私鑰加密公鑰解密
安全程度高：多次加密
按位異或運算
凱撒密碼：加密方式 通過將銘文所使用的字母表按照一定的字數平移來進行加密
mod：取余
加密三要素：明文/密文(字母)、秘鑰(3)、演算法(向右平移3/-3)
安全常識：不要使用自己研發的演算法、不要鑽牛角尖、沒必要研究底層實現、了解怎麼應用；低強度的密碼比不進行任何加密更危險；任何密碼都會被破解；密碼只是信息安全的一部分
保證數據的機密性、完整性、認證、不可否認性
計算機操作對象不是文字、而是由0或1排列而成的比特序列、程序存儲在磁碟是二進制的字元串、為比特序列、將現實的東西映射為比特序列的操作稱為編碼、加密又稱之為編碼、解密稱之為解碼、根據ASCII對照表找到對應的數字、轉換成二進制
三種對稱加密演算法：DES\3DES\ AES
DES：已經被破解、除了用它來解密以前的明文、不再使用
密鑰長度為56bit/8、為7byte、每隔7個bit會設置一個用於錯誤檢查的比特、因此實際上是64bit
分組密碼(以組為單位進行處理)：加密時是按照一個單位進行加密(8個位元組/64bit為一組)、每一組結合秘鑰通過加密演算法得到密文、加密後的長度不變
3DES:三重DES為了增加DES的強度、將DES重復三次所得到的一種加密演算法 密鑰長度24byte、分成三份 加密--解密--加密 目的：為了兼容DES、秘鑰1秘鑰2相同==三個秘鑰相同 ---加密一次 密鑰1秘鑰3相同--加密三次 三個密鑰不相同最好、此時解密相當於加密、中間的一次解密是為了有三個密鑰相同的情況
此時的解密操作與加密操作互逆，安全、效率低
數據先解密後加密可以么？可以、解密相當於加密、加密解密說的是演算法
AES：(首選推薦)底層演算法為Rijndael 分組長度為128bit、密鑰長度為128bit到256bit范圍內就可以 但是在AES中、密鑰長度只有128bit\192bit\256bit 在go提供的介面中、只能是16位元組(128bit)、其他語言中秘鑰可以選擇
目前為止最安全的、效率高
底層演算法
分組密碼的模式：
按位異或、對數據進行位運算、先將數據轉換成二進制、按位異或操作符^、相同為真、不同為假、非0為假 按位異或一次為加密操作、按位異或兩次為解密操作：a和b按位異或一次、結果再和b按位異或
ECB : 如果明文有規律、加密後的密文有規律不安全、go里不提供該介面、明文分組分成固定大小的塊、如果最後一個分組不滿足分組長度、則需要補位
CBC：密碼鏈
問題：如何對字元串進行按位異或？解決了ECB的規律可查缺點、但是他不能並行處理、最後一個明文分組也需要填充 、初始化向量長度與分組長度相同
CFB:密文反饋模式
不需要填充最後一個分組、對密文進行加密
OFB：
不需要對最後一組進行填充
CTR計數器:
不需要對最後一組進行填充、不需要初始化向量
Go中的實現
官方文檔中：
在創建aes或者是des介面時都是調用如下的方法、返回的block為一個介面
func NewCipher(key [] byte ) ( cipher . Block , error )
type Block interface {
// 返回加密位元組塊的大小
BlockSize() int
// 加密src的第一塊數據並寫入dst，src和dst可指向同一內存地址
Encrypt(dst, src []byte)
// 解密src的第一塊數據並寫入dst，src和dst可指向同一內存地址
Decrypt(dst, src []byte)
}
Block介面代表一個使用特定密鑰的底層塊加/解密器。它提供了加密和解密獨立數據塊的能力。
Block的Encrypt/Decrypt也能進行加密、但是只能加密第一組、因為aes的密鑰長度為16、所以進行操作的第一組數據長度也是16
如果分組模式選擇的是cbc
func NewCBCEncrypter(b Block, iv []byte) BlockMode 加密
func NewCBCDecrypter(b Block, iv []byte) BlockMode 解密
加密解密都調用同一個方法CryptBlocks()
並且cbc分組模式都會遇到明文最後一個分組的補充、所以會用到加密位元組的大小
返回一個密碼分組鏈接模式的、底層用b加密的BlockMode介面，初始向量iv的長度必須等於b的塊尺寸。iv自己定義
返回的BlockMode同樣也是一個介面類型
type BlockMode interface {
// 返回加密位元組塊的大小
BlockSize() int
// 加密或解密連續的數據塊，src的尺寸必須是塊大小的整數倍，src和dst可指向同一內存地址
CryptBlocks(dst, src []byte)
}
BlockMode介面代表一個工作在塊模式（如CBC、ECB等）的加/解密器
返回的BlockMode其實是一個cbc的指針類型中的b和iv
# 加密流程:
1. 創建一個底層使用des/3des/aes的密碼介面 "crypto/des" func NewCipher(key []byte) (cipher.Block, error) # -- des func NewTripleDESCipher(key []byte) (cipher.Block, error) # -- 3des "crypto/aes" func NewCipher(key []byte) (cipher.Block, error) # == aes
2. 如果使用的是cbc/ecb分組模式需要對明文分組進行填充
3. 創建一個密碼分組模式的介面對象 - cbc func NewCBCEncrypter(b Block, iv []byte) BlockMode # 加密 - cfb func NewCFBEncrypter(block Block, iv []byte) Stream # 加密 - ofb - ctr
4. 加密, 得到密文
流程：
填充明文：
先求出最後一組中的位元組數、創建新切片、長度為新切片、值也為切片的長度、然後利用bytes.Reapet將長度換成位元組切片、追加到原明文中
//明文補充
func padPlaintText(plaintText []byte,blockSize int)[]byte{
//1、求出需要填充的個數
padNum := blockSize-len(plaintText) % blockSize
//2、對填充的個數進行操作、與原明文進行合並
newPadding := []byte{byte(padNum)}
newPlain := bytes.Repeat(newPadding,padNum)
plaintText = append(plaintText,newPlain...)
return plaintText
}
去掉填充數據：
拿去切片中的最後一個位元組、得到尾部填充的位元組個數、截取返回
//解密後的明文曲調補充的地方
func createPlaintText(plaintText []byte,blockSize int)[]byte{
//1、得到最後一個位元組、並將位元組轉換成數字、去掉明文中此數字大小的位元組
padNum := int(plaintText[len(plaintText)-1])
newPadding := plaintText[:len(plaintText)-padNum]
return newPadding
}
des加密：
1、創建一個底層使用des的密碼介面、參數為秘鑰、返回一個介面
2、對明文進行填充
3、創建一個cbc模式的介面、需要創建iv初始化向量、返回一個blockmode對象
4、加密、調用blockmode中的cryptBlock函數進行加密、參數為目標參數和源參數
//des利用分組模式cbc進行加密
func EncryptoText(plaintText []byte,key []byte)[]byte{
//1、創建des對象
cipherBlock,err := des.NewCipher(key)
if err != nil {
panic(err)
}
//2、對明文進行填充
newText := padPlaintText(plaintText,cipherBlock.BlockSize())
//3、選擇分組模式、其中向量的長度必須與分組長度相同
iv := make([]byte,cipherBlock.BlockSize())
blockMode := cipher.NewCBCEncrypter(cipherBlock,iv)
//4、加密
blockMode.CryptBlocks(newText,newText)
return newText
}
des解密：
1、創建一個底層使用des的密碼介面、參數為秘鑰、返回一個介面
2、創建一個cbc模式的介面、需要創建iv初始化向量，返回一個blockmode對象
3、加密、調用blockmode中的cryptBlock函數進行解密、參數為目標參數和源參數
4、調用去掉填充數據的方法
//des利用分組模式cbc進行解密
func DecryptoText(cipherText []byte, key []byte)[]byte{
//1、創建des對象
cipherBlock,err := des.NewCipher(key)
if err != nil {
panic(err)
}
//2、創建cbc分組模式介面
iv := []byte("12345678")
blockMode := cipher.NewCBCDecrypter(cipherBlock,iv)
//3、解密
blockMode.CryptBlocks(cipherText,cipherText)
//4、將解密後的數據進行去除填充的數據
newText := clearPlaintText(cipherText,cipherBlock.BlockSize())
return newText
}
Main函數調用
func main(){
//需要進行加密的明文
plaintText := []byte("CBC--密文沒有規律、經常使用的加密方式，最後一個分組需要填充，需要初始化向量" +
"(一個數組、數組的長度與明文分組相等、數據來源:負責加密的人提供，加解密使用的初始化向量必須相同)")
//密鑰Key的長度需要與分組長度相同、且加密解密的密鑰相同
key := []byte("1234abcd")
//調用加密函數
cipherText := EncryptoText(plaintText,key)
newPlaintText := DecryptoText(cipherText,key)
fmt.Println(string(newPlaintText))
}
AES加密解密相同、所以只需要調用一次方法就可以加密、調用兩次則解密
推薦是用分組模式：cbc、ctr
aes利用分組模式cbc進行加密
//對明文進行補充
func paddingPlaintText(plaintText []byte , blockSize int ) []byte {
//1、求出分組余數
padNum := blockSize - len(plaintText) % blockSize
//2、將余數轉換為位元組切片、然後利用bytes.Repeat得出有該余數的大小的位元組切片
padByte := bytes.Repeat([]byte{byte(padNum)},padNum)
//3、將補充的位元組切片添加到原明文中
plaintText = append(plaintText,padByte...)
return plaintText
}
//aes加密
func encryptionText(plaintText []byte, key []byte) []byte {
//1、創建aes對象
block,err := aes.NewCipher(key)
if err != nil {
panic(err)
}
//2、明文補充
newText := paddingPlaintText(plaintText,block.BlockSize())
//3、創建cbc對象
iv := []byte("12345678abcdefgh")
blockMode := cipher.NewCBCEncrypter(block,iv)
//4、加密
blockMode.CryptBlocks(newText,newText)
return newText
}
//解密後的去尾
func clearplaintText(plaintText []byte, blockSize int) []byte {
//1、得到最後一個位元組、並轉換成整型數據
padNum := int(plaintText[len(plaintText)-1])
//2、截取明文位元組中去掉得到的整型數據之前的數據、此處出錯、沒有用len-padNum
newText := plaintText[:len(plaintText)-padNum]
return newText
}
//aes解密
func deCryptionText(crypherText []byte, key []byte ) []byte {
//1、創建aes對象
block, err := aes.NewCipher(key)
if err != nil {
panic(err)
}
//2、創建cbc對象
iv := []byte("12345678abcdefgh")
blockMode := cipher.NewCBCDecrypter(block,iv)
//3、解密
blockMode.CryptBlocks(crypherText,crypherText)
//4、去尾
newText := clearplaintText(crypherText,block.BlockSize())
return newText
}
func main(){
//需要進行加密的明文
plaintText := []byte("CBC--密文沒有規律、經常使用的加密方式，最後一個分組需要填充，需要初始化向量")
//密鑰Key的長度需要與分組長度相同、且加密解密的密鑰相同
key := []byte("12345678abcdefgh")
//調用加密函數
cipherText := encryptionText(plaintText,key)
//調用解密函數
newPlaintText := deCryptionText(cipherText,key)
fmt.Println("解密後",string(newPlaintText))
}
//aes--ctr加密
func encryptionCtrText(plaintText []byte, key []byte) []byte {
//1、創建aes對象
block,err := aes.NewCipher(key)
if err != nil {
panic(err)
}
//2、創建ctr對象，雖然ctr模式不需要iv，但是go中使用ctr時還是需要iv
iv := []byte("12345678abcdefgh")
stream := cipher.NewCTR(block,iv)
stream.XORKeyStream(plaintText,plaintText)
return plaintText
}
func main() {
//aes--ctr加密解密、調用兩次即為解密、因為加密解密函數相同stream.XORKeyStream
ctrcipherText := encryptionCtrText(plaintText, key)
ctrPlaintText := encryptionCtrText(ctrcipherText,key)
fmt.Println("aes解密後", string(ctrPlaintText))
}
英文單詞：
明文：plaintext 密文：ciphertext 填充：padding/fill 去掉clear 加密Encryption 解密Decryption
㈢ 對稱加密演算法的加密演算法主要有哪些
1、3DES演算法
3DES（即Triple DES）是DES向AES過渡的加密演算法（1999年，NIST將3-DES指定為過渡的加密標准），加密演算法，其具體實現如下：設Ek()和Dk()代表DES演算法的加密和解密過程，K代表DES演算法使用的密鑰，M代表明文，C代表密文，這樣：
3DES加密過程為：C=Ek3(Dk2(Ek1(M)))
3DES解密過程為：M=Dk1(EK2(Dk3(C)))
2、Blowfish演算法
BlowFish演算法用來加密64Bit長度的字元串。
BlowFish演算法使用兩個「盒」——unsignedlongpbox[18]和unsignedlongsbox[4,256]。
BlowFish演算法中，有一個核心加密函數:BF_En(後文詳細介紹）。該函數輸入64位信息，運算後，以64位密文的形式輸出。用BlowFish演算法加密信息，需要兩個過程：密鑰預處理和信息加密。
分別說明如下：
密鑰預處理：
BlowFish演算法的源密鑰——pbox和sbox是固定的。我們要加密一個信息，需要自己選擇一個key，用這個key對pbox和sbox進行變換，得到下一步信息加密所要用的key_pbox和key_sbox。具體的變化演算法如下：
1)用sbox填充key_sbox
2)用自己選擇的key8個一組地去異或pbox，用異或的結果填充key_pbox。key可以循環使用。
比如說：選的key是"abcdefghijklmn"。則異或過程為：
key_pbox[0]=pbox[0]abcdefgh；
key_pbox[1]=pbox[1]ijklmnab；
…………
…………
如此循環，直到key_pbox填充完畢。
3)用BF_En加密一個全0的64位信息，用輸出的結果替換key_pbox[0]和key_pbox[1],i=0；
4)用BF_En加密替換後的key_pbox,key_pbox[i+1]，用輸出替代key_pbox[i+2]和key_pbox[i+3]；
5)i+2，繼續第4步，直到key_pbox全部被替換；
6)用key_pbox[16]和key_pbox[17]做首次輸入（相當於上面的全0的輸入），用類似的方法，替換key_sbox信息加密。
信息加密就是用函數把待加密信息x分成32位的兩部分:xL,xRBF_En對輸入信息進行變換。
3、RC5演算法
RC5是種比較新的演算法，Rivest設計了RC5的一種特殊的實現方式，因此RC5演算法有一個面向字的結構：RC5-w/r/b，這里w是字長其值可以是16、32或64對於不同的字長明文和密文塊的分組長度為2w位，r是加密輪數，b是密鑰位元組長度。
(3)對稱加密字元串擴展閱讀：
普遍而言，有3個獨立密鑰的3DES（密鑰選項1）的密鑰長度為168位（三個56位的DES密鑰），但由於中途相遇攻擊，它的有效安全性僅為112位。密鑰選項2將密鑰長度縮短到了112位，但該選項對特定的選擇明文攻擊和已知明文攻擊的強度較弱，因此NIST認定它只有80位的安全性。
對密鑰選項1的已知最佳攻擊需要約2組已知明文，2部，2次DES加密以及2位內存（該論文提到了時間和內存的其它分配方案）。
這在現在是不現實的，因此NIST認為密鑰選項1可以使用到2030年。若攻擊者試圖在一些可能的（而不是全部的）密鑰中找到正確的，有一種在內存效率上較高的攻擊方法可以用每個密鑰對應的少數選擇明文和約2次加密操作找到2個目標密鑰中的一個。
㈣ 用C語言編寫一個對稱加密演算法，對字元串加密
/*本問題的關鍵是如何交換ASCII的二進制位，下面提供簡短演算法，並附上VC++6.0環境下的運行結果截圖。
*/
#include<stdio.h>
charswapbit(charc){
chari,num=0,ch[8];
for(i=0;i<8;i++){
ch[i]=c&1;
c=(c>>1);
}
for(i=0;i<8;i++){
num=2*num+ch[i];
}
returnnum;
}
intmain(){
charch;
for(ch='A';ch<='Z';ch++){
printf("%c=%X:%X ",ch,ch,0XFF&swapbit(ch));
}
return0;
}
㈤ 如何使用java實現對字元串的DES加密和解密
java加密字元串可以使用des加密演算法，實例如下：
package test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
/**
* 加密解密
*
* @author shy.qiu
* @since http://blog.csdn.net/qiushyfm
*/
public class CryptTest {
/**
* 進行MD5加密
*
* @param info
* 要加密的信息
* @return String 加密後的字元串
*/
public String encryptToMD5(String info) {
byte[] digesta = null;
try {
// 得到一個md5的消息摘要
MessageDigest alga = MessageDigest.getInstance("MD5");
// 添加要進行計算摘要的信息
alga.update(info.getBytes());
// 得到該摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 將摘要轉為字元串
String rs = byte2hex(digesta);
return rs;
}
/**
* 進行SHA加密
*
* @param info
* 要加密的信息
* @return String 加密後的字元串
*/
public String encryptToSHA(String info) {
byte[] digesta = null;
try {
// 得到一個SHA-1的消息摘要
MessageDigest alga = MessageDigest.getInstance("SHA-1");
// 添加要進行計算摘要的信息
alga.update(info.getBytes());
// 得到該摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 將摘要轉為字元串
String rs = byte2hex(digesta);
return rs;
}
// //////////////////////////////////////////////////////////////////////////
/**
* 創建密匙
*
* @param algorithm
* 加密演算法,可用 DES,DESede,Blowfish
* @return SecretKey 秘密（對稱）密鑰
*/
public SecretKey createSecretKey(String algorithm) {
// 聲明KeyGenerator對象
KeyGenerator keygen;
// 聲明 密鑰對象
SecretKey deskey = null;
try {
// 返回生成指定演算法的秘密密鑰的 KeyGenerator 對象
keygen = KeyGenerator.getInstance(algorithm);
// 生成一個密鑰
deskey = keygen.generateKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 返回密匙
return deskey;
}
/**
* 根據密匙進行DES加密
*
* @param key
* 密匙
* @param info
* 要加密的信息
* @return String 加密後的信息
*/
public String encryptToDES(SecretKey key, String info) {
// 定義 加密演算法,可用 DES,DESede,Blowfish
String Algorithm = "DES";
// 加密隨機數生成器 (RNG),(可以不寫)
SecureRandom sr = new SecureRandom();
// 定義要生成的密文
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密鑰和模式初始化Cipher對象
// 參數:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1.init(Cipher.ENCRYPT_MODE, key, sr);
// 對要加密的內容進行編碼處理,
cipherByte = c1.doFinal(info.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
// 返回密文的十六進制形式
return byte2hex(cipherByte);
}
/**
* 根據密匙進行DES解密
*
* @param key
* 密匙
* @param sInfo
* 要解密的密文
* @return String 返回解密後信息
*/
public String decryptByDES(SecretKey key, String sInfo) {
// 定義 加密演算法,
String Algorithm = "DES";
// 加密隨機數生成器 (RNG)
SecureRandom sr = new SecureRandom();
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密鑰和模式初始化Cipher對象
c1.init(Cipher.DECRYPT_MODE, key, sr);
// 對要解密的內容進行編碼處理
cipherByte = c1.doFinal(hex2byte(sInfo));
} catch (Exception e) {
e.printStackTrace();
}
// return byte2hex(cipherByte);
return new String(cipherByte);
}
// /////////////////////////////////////////////////////////////////////////////
/**
* 創建密匙組，並將公匙，私匙放入到指定文件中
*
* 默認放入mykeys.bat文件中
*/
public void createPairKey() {
try {
// 根據特定的演算法一個密鑰對生成器
KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");
// 加密隨機數生成器 (RNG)
SecureRandom random = new SecureRandom();
// 重新設置此隨機對象的種子
random.setSeed(1000);
// 使用給定的隨機源（和默認的參數集合）初始化確定密鑰大小的密鑰對生成器
keygen.initialize(512, random);// keygen.initialize(512);
// 生成密鑰組
KeyPair keys = keygen.generateKeyPair();
// 得到公匙
PublicKey pubkey = keys.getPublic();
// 得到私匙
PrivateKey prikey = keys.getPrivate();
// 將公匙私匙寫入到文件當中
doObjToFile("mykeys.bat", new Object[] { prikey, pubkey });
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
/**
* 利用私匙對信息進行簽名 把簽名後的信息放入到指定的文件中
*
* @param info
* 要簽名的信息
* @param signfile
* 存入的文件
*/
public void signToInfo(String info, String signfile) {
// 從文件當中讀取私匙
PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);
// 從文件中讀取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);
try {
// Signature 對象可用來生成和驗證數字簽名
Signature signet = Signature.getInstance("DSA");
// 初始化簽署簽名的私鑰
signet.initSign(myprikey);
// 更新要由位元組簽名或驗證的數據
signet.update(info.getBytes());
// 簽署或驗證所有更新位元組的簽名，返回簽名
byte[] signed = signet.sign();
// 將數字簽名,公匙,信息放入文件中
doObjToFile(signfile, new Object[] { signed, mypubkey, info });
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 讀取數字簽名文件 根據公匙，簽名，信息驗證信息的合法性
*
* @return true 驗證成功 false 驗證失敗
*/
public boolean validateSign(String signfile) {
// 讀取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);
// 讀取簽名
byte[] signed = (byte[]) getObjFromFile(signfile, 1);
// 讀取信息
String info = (String) getObjFromFile(signfile, 3);
try {
// 初始一個Signature對象,並用公鑰和簽名進行驗證
Signature signetcheck = Signature.getInstance("DSA");
// 初始化驗證簽名的公鑰
signetcheck.initVerify(mypubkey);
// 使用指定的 byte 數組更新要簽名或驗證的數據
signetcheck.update(info.getBytes());
System.out.println(info);
// 驗證傳入的簽名
return signetcheck.verify(signed);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 將二進制轉化為16進制字元串
*
* @param b
* 二進制位元組數組
* @return String
*/
public 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;
}
}
return hs.toUpperCase();
}
/**
* 十六進制字元串轉化為2進制
*
* @param hex
* @return
*/
public byte[] hex2byte(String hex) {
byte[] ret = new byte[8];
byte[] tmp = hex.getBytes();
for (int i = 0; i < 8; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
/**
* 將兩個ASCII字元合成一個位元組； 如："EF"--> 0xEF
*
* @param src0
* byte
* @param src1
* byte
* @return byte
*/
public static byte uniteBytes(byte src0, byte src1) {
byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 }))
.byteValue();
_b0 = (byte) (_b0 << 4);
byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 }))
.byteValue();
byte ret = (byte) (_b0 ^ _b1);
return ret;
}
/**
* 將指定的對象寫入指定的文件
*
* @param file
* 指定寫入的文件
* @param objs
* 要寫入的對象
*/
public void doObjToFile(String file, Object[] objs) {
ObjectOutputStream oos = null;
try {
FileOutputStream fos = new FileOutputStream(file);
oos = new ObjectOutputStream(fos);
for (int i = 0; i < objs.length; i++) {
oos.writeObject(objs[i]);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 返回在文件中指定位置的對象
*
* @param file
* 指定的文件
* @param i
* 從1開始
* @return
*/
public Object getObjFromFile(String file, int i) {
ObjectInputStream ois = null;
Object obj = null;
try {
FileInputStream fis = new FileInputStream(file);
ois = new ObjectInputStream(fis);
for (int j = 0; j < i; j++) {
obj = ois.readObject();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}
/**
* 測試
*
* @param args
*/
public static void main(String[] args) {
CryptTest jiami = new CryptTest();
// 執行MD5加密"Hello world!"
System.out.println("Hello經過MD5:" + jiami.encryptToMD5("Hello"));
// 生成一個DES演算法的密匙
SecretKey key = jiami.createSecretKey("DES");
// 用密匙加密信息"Hello world!"
String str1 = jiami.encryptToDES(key, "Hello");
System.out.println("使用des加密信息Hello為:" + str1);
// 使用這個密匙解密
String str2 = jiami.decryptByDES(key, str1);
System.out.println("解密後為：" + str2);
// 創建公匙和私匙
jiami.createPairKey();
// 對Hello world!使用私匙進行簽名
jiami.signToInfo("Hello", "mysign.bat");
// 利用公匙對簽名進行驗證。
if (jiami.validateSign("mysign.bat")) {
System.out.println("Success!");
} else {
System.out.println("Fail!");
}
}
}
㈥ 常用的對稱密碼演算法有哪些
對稱加密演算法用來對敏感數據等信息進行加密，常用的演算法包括：
DES（Data Encryption Standard）：數據加密標准，速度較快，適用於加密大量數據的場合。
3DES（Triple DES）：是基於DES，對一塊數據用三個不同的密鑰進行三次加密，強度更高。
AES（Advanced Encryption Standard）：高級加密標准，是下一代的加密演算法標准，速度快，安全級別高；
㈦ 密碼學基礎（二）：對稱加密
加密和解密使用相同的秘鑰稱為對稱加密。
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
加密：
解密：
㈧ 什麼是3DES對稱加密演算法
DES加密經過下面的步驟
1、提供明文和密鑰,將明文按照64bit分塊（對應8個位元組），不足8個位元組的可以進行填充（填充方式多種）,密鑰必須為8個位元組共64bit
填充方式：
當明文長度不為分組長度的整數倍時，需要在最後一個分組中填充一些數據使其湊滿一個分組長度。
* NoPadding
API或演算法本身不對數據進行處理，加密數據由加密雙方約定填補演算法。例如若對字元串數據進行加解密，可以補充\0或者空格，然後trim
* PKCS5Padding
加密前：數據位元組長度對8取余，余數為m，若m>0,則補足8-m個位元組，位元組數值為8-m，即差幾個位元組就補幾個位元組，位元組數值即為補充的位元組數，若為0則補充8個位元組的8
解密後：取最後一個位元組，值為m，則從數據尾部刪除m個位元組，剩餘數據即為加密前的原文。
例如：加密字元串為為AAA，則補位為AAA55555;加密字元串為BBBBBB，則補位為BBBBBB22；加密字元串為CCCCCCCC，則補位為CCCCCCCC88888888。
* PKCS7Padding
PKCS7Padding 的填充方式和PKCS5Padding 填充方式一樣。只是加密塊的位元組數不同。PKCS5Padding明確定義了加密塊是8位元組，PKCS7Padding加密快可以是1-255之間。
2、選擇加密模式
**ECB模式** 全稱Electronic Codebook模式，譯為電子密碼本模式
**CBC模式** 全稱Cipher Block Chaining模式，譯為密文分組鏈接模式
**CFB模式** 全稱Cipher FeedBack模式，譯為密文反饋模式
**OFB模式** 全稱Output Feedback模式，譯為輸出反饋模式。
**CTR模式** 全稱Counter模式，譯為計數器模式。
3、開始加密明文（內部原理--加密步驟，加密演算法實現不做講解）
image
1、將分塊的64bit一組組加密，示列其中一組：將此組進行初始置換（IP置換），目的是將輸入的64位數據塊按位重新組合，並把輸出分為L0、R0兩部分，每部分各長32位。
2、開始Feistel結構的16次轉換，第一次轉換為：右側數據R0和子密鑰經過輪函數f生成用於加密左側數據的比特序列，與左側數據L0異或運算，
運算結果輸出為加密後的左側L0，右側數據則直接輸出為右側R0。由於一次Feistel輪並不會加密右側，因此需要將上一輪輸出後的左右兩側對調後才正式完成一次Feistel加密，
3、DES演算法共計進行16次Feistel輪，最後一輪輸出後左右兩側無需對調，每次加密的子密鑰不相同，子密鑰是通過秘鑰計算得到的。
4、末置換是初始置換的逆過程，DES最後一輪後，左、右兩半部分並未進行交換，而是兩部分合並形成一個分組做為末置換的輸入
DES解密經過下面的步驟
1、拿到密文和加密的密鑰
2、解密：DES加密和解密的過程一致，均使用Feistel網路實現，區別僅在於解密時，密文作為輸入，並逆序使用子密鑰。
3、講解密後的明文去填充 (padding）得到的即為明文
Golang實現DES加密解密
package main
import (
"fmt"
"crypto/des"
"bytes"
"crypto/cipher"
)
func main() {
var miwen,_= DESEncode([]byte("hello world"),[]byte("12345678"))
fmt.Println(miwen) // [11 42 146 232 31 180 156 225 164 50 102 170 202 234 123 129],密文：最後5位是補碼
var txt,_ = DESDecode(miwen,[]byte("12345678"))
fmt.Println(txt) // [104 101 108 108 111 32 119 111 114 108 100]明碼
fmt.Printf("%s",txt) // hello world
}
// 加密函數
func DESEncode(orignData, key []byte)([]byte,error){
// 建立密碼塊
block ,err:=des.NewCipher(key)
if err!=nil{ return nil,err}
// 明文分組，不足的部分加padding
txt := PKCS5Padding(orignData,block.BlockSize())
// 設定加密模式,為了方便，初始向量直接使用key充當了（實際項目中，最好別這么做）
blockMode := cipher.NewCBCEncrypter(block,key)
// 創建密文長度的切片，用來存放密文位元組
crypted :=make([]byte,len(txt))
// 開始加密,將txt作為源，crypted作為目的切片輸入
blockMode.CryptBlocks(crypted,txt)
// 將加密後的切片返回
return crypted,nil
}
// 加密所需padding
func PKCS5Padding(ciphertext []byte,size int)[]byte{
padding := size - len(ciphertext)%size
padTex := bytes.Repeat([]byte{byte(padding)},padding)
return append(ciphertext,padTex...)
}
// 解密函數
func DESDecode(cripter, key []byte) ([]byte,error) {
// 建立密碼塊
block ,err:=des.NewCipher(key)
if err!=nil{ return nil,err}
// 設置解密模式，加密模式和解密模式要一樣
blockMode := cipher.NewCBCDecrypter(block,key)
// 設置切片長度，用來存放明文位元組
originData := make([]byte,len(cripter))
// 使用解密模式解密,將解密後的明文位元組放入originData 切片中
blockMode.CryptBlocks(originData,cripter)
// 去除加密的padding部分
strByt := UnPKCS5Padding(origenData)
return strByt,nil
}
// 解密所需要的Unpadding
func UnPKCS5Padding(origin []byte) []byte{
// 獲取最後一位轉為整型，然後根據這個整型截取掉整型數量的長度
// 若此數為5，則減掉轉換明文後的最後5位，即為我們輸入的明文
var last = int(origin[len(origin)-1])
return origin[:len(origin)-last]
}
注意：在設置加密模式為CBC的時候，我們需要設置一個初始化向量，這個量的意思 在對稱加密演算法中，如果只有一個密鑰來加密數據的話，明文中的相同文字就會也會被加密成相同的密文，這樣密文和明文就有完全相同的結構，容易破解，如果給一個初始化向量，第一個明文使用初始化向量混合並加密，第二個明文用第一個明文的加密後的密文與第二個明文混合加密，這樣加密出來的密文的結構則完全與明文不同，更加安全可靠。CBC模式圖如下
CBC
3DES
DES 的常見變體是三重 DES，使用 168 位的密鑰對資料進行三次加密的一種機制；它通常（但非始終）提供極其強大的安全性。如果三個 56 位的子元素都相同，則三重 DES 向後兼容 DES。
對比DES，發現只是換了NewTripleDESCipher。不過，需要注意的是，密鑰長度必須24byte，否則直接返回錯誤。關於這一點，PHP中卻不是這樣的，只要是8byte以上就行；而Java中，要求必須是24byte以上，內部會取前24byte（相當於就是24byte）。另外，初始化向量長度是8byte（目前各個語言都是如此，不是8byte會有問題）