對稱加密模式如何加密

⑴ 對稱加密演算法以及使用方法

加密的原因：保證數據安全

加密必備要素：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

⑵ 密碼學基礎（二）：對稱加密

加密和解密使用相同的秘鑰稱為對稱加密。

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

加密：

解密：

⑶ PHP對稱加密-AES

對稱加解密演算法中，當前最為安全的是 AES 加密演算法（以前應該是是 DES 加密演算法），PHP 提供了兩個可以用於 AES 加密演算法的函數簇： Mcrypt 和 OpenSSL 。

其中 Mcrypt 在 PHP 7.1.0 中被棄用（The Function Mycrypt is Deprecated)，在 PHP 7.2.0 中被移除，所以即可起你應該使用 OpenSSL 來實現 AES 的數據加解密。

在一些場景下，我們不能保證兩套通信系統都使用了相函數簇去實現加密演算法，可能 siteA 使用了最新的 OpenSSL 來實現了 AES 加密，但作為第三方服務的 siteB 可能仍在使用 Mcrypt 演算法，這就要求我們必須清楚 Mcrypt 同 OpenSSL 之間的差異，以便保證數據加解密的一致性。

下文中我們將分別使用 Mcrypt 和 OpenSSL 來實現 AES-128/192/256-CBC 加解密，二者同步加解密的要點為：

協同好以上兩點，就可以讓 Mcrypt 和 OpenSSL 之間一致性的對數據進行加解密。

AES 是當前最為常用的安全對稱加密演算法，關於對稱加密這里就不在闡述了。

AES 有三種演算法，主要是對數據塊的大小存在區別：

AES-128：需要提供 16 位的密鑰 key
AES-192：需要提供 24 位的密鑰 key
AES-256：需要提供 32 位的密鑰 key

AES 是按數據塊大小（128/192/256）對待加密內容進行分塊處理的，會經常出現最後一段數據長度不足的場景，這時就需要填充數據長度到加密演算法對應的數據塊大小。

主要的填充演算法有填充 NUL("0") 和 PKCS7，Mcrypt 默認使用的 NUL("0") 填充演算法，當前已不被推薦，OpenSSL 則默認模式使用 PKCS7 對數據進行填充並對加密後的數據進行了 base64encode 編碼，所以建議開發中使用 PKCS7 對待加密數據進行填充，已保證通用性（alipay sdk 中雖然使用了 Mcrypt 加密簇，但使用 PKCS7 演算法對數據進行了填充，這樣在一定程度上親和了 OpenSSL 加密演算法）。

Mcrypt 的默認填充演算法。NUL 即為 Ascii 表的編號為 0 的元素，即空元素，轉移字元是 ""，PHP 的 pack 打包函數在 'a' 模式下就是以 NUL 字元對內容進行填充的，當然，使用 "" 手動拼接也是可以的。

OpenSSL的默認填充演算法。下面我們給出 PKCS7 填充演算法 PHP 的實現：

默認使用 NUL("") 自動對待加密數據進行填充以對齊加密演算法數據塊長度。

獲取 mcrypt 支持的演算法，這里我們只關注 AES 演算法。

注意：mcrypt 雖然支持 AES 三種演算法，但除 MCRYPT_RIJNDAEL_128 外， MCRYPT_RIJNDAEL_192/256 並未遵循 AES-192/256 標准進行加解密的演算法，即如果你同其他系統通信（java/.net），使用 MCRYPT_RIJNDAEL_192/256 可能無法被其他嚴格按照 AES-192/256 標準的系統正確的數據解密。官方文檔頁面中也有人在 User Contributed Notes 中提及。這里給出如何使用 mcrpyt 做標注的 AES-128/192/256 加解密

即演算法統一使用 MCRYPT_RIJNDAEL_128 ，並通過 key 的位數 來選定是以何種 AES 標准做的加密，iv 是建議添加且建議固定為16位（OpenSSL的 AES加密 iv 始終為 16 位，便於統一對齊），mode 選用的 CBC 模式。

mcrypt 在對數據進行加密處理時，如果發現數據長度與使用的加密演算法的數據塊長度未對齊，則會自動使用 "" 對待加密數據進行填充，但 "" 填充模式已不再被推薦，為了與其他系統有更好的兼容性，建議大家手動對數據進行 PKCS7 填充。

openssl 簇加密方法更為簡單明確，mcrypt 還要將加密演算法分為 cipher + mode 去指定，openssl 則只需要直接指定 method 為 AES-128-CBC，AES-192-CBC，AES-256-CBC 即可。且提供了三種數據處理模式，即 默認模式 0 / OPENSSL_RAW_DATA / OPENSSL_ZERO_PADDING 。

openssl 默認的數據填充方式是 PKCS7，為兼容 mcrpty 也提供處理 "0" 填充的數據的模式，具體為下：

options 參數即為重要，它是兼容 mcrpty 演算法的關鍵：

options = 0 : 默認模式，自動對明文進行 pkcs7 padding，且數據做 base64 編碼處理。
options = 1 : OPENSSL_RAW_DATA，自動對明文進行 pkcs7 padding， 且數據未經 base64 編碼處理。
options = 2 : OPENSSL_ZERO_PADDING，要求待加密的數據長度已按 "0" 填充與加密演算法數據塊長度對齊，即同 mcrpty 默認填充的方式一致，且對數據做 base64 編碼處理。注意，此模式下 openssl 要求待加密數據已按 "0" 填充好，其並不會自動幫你填充數據，如果未填充對齊，則會報錯。

故可以得出 mcrpty簇 與 openssl簇 的兼容條件如下：

建議將源碼復制到本地運行，根據運行結果更好理解。

1.二者使用的何種填充演算法。

2.二者對數據是否有 base64 編碼要求。

3.mcrypt 需固定使用 MCRYPT_RIJNDAEL_128，並通過調整 key 的長度 16, 24，32 來實現 ase-128/192/256 加密演算法。

⑷ 加密技術的對稱加密

任何用戶如果想利用加密技術進行相互通信，首先都需要共有一個的密鑰。密鑰和演算法保密，由通信雙方妥善保管。
使用對稱加密技術對文件進行加密傳輸的實際過程分為三步：
首先，通信雙方利用絕對安全的渠道，協商確定共有密鑰，並妥善保管；
然後，發送方對需要傳輸的文件用自己的密鑰進行加密，然後通過網路把加密後的文件傳輸到接收方；
最後，接收方用自己的密鑰（實際上與發送方的密鑰相同）對收到的密文進行解密，最後得到發送方的明文。

⑸ 對稱密鑰加密是如何進行的

對稱密鑰加密也叫秘密/專用密鑰加密（Secret Key Encryption），即發送和接收數據的雙方必須使用相同的/對稱的密鑰對明文進行加密和解密運算。
非對稱密鑰加密也叫公開密鑰加密（Public Key Encryption），是指每個人都有一對唯一對應的密鑰：公開密鑰和私有密鑰，公鑰對外公開，私鑰由個人秘密保存；用其中一把密鑰來加密，就只能用另一把密鑰來解密。發送數據的一方用另一方的公鑰對發送的信息進行加密，然後由接受者用自己的私鑰進行解密。公開密鑰加密技術解決了密鑰的發布和管理問題，是目前商業密碼的核心。使用公開密鑰技術，進行數據通信的雙方可以安全地確認對方身份和公開密鑰，提供通信的可鑒別性。

⑹ 簡述對稱加密演算法的基本原理

對稱加密是計算機加密領域最古老也是最經典的加密標准。雖然對稱加密被認為不再是安全的加密方式，但是直到現在，還看不到它被淘汰的跡象。在很多非網路化的加密環境中，對稱加密足以滿足人們的需要。

對稱加密採用單密鑰加密方式，不論是加密還是解密都是用同一個密鑰，即「一把鑰匙開一把鎖」。對稱加密的好處在於操作簡單、管理方便、速度快。它的缺點在於密鑰在網路傳輸中容易被竊聽，每個密鑰只能應用一次，對密鑰管理造成了困難。對稱加密的實現形式和加密演算法的公開性使它依賴於密鑰的安全性，而不是演算法的安全性。

一個對稱加密系統由五個部分組成，可以表述為

S={M，C，K，E，D}

各字母的含義如下：

M：明文空間，所有明文的集合。

C：密文空間，全體密文的集合。

K：密鑰空間，全體密鑰的集合。

E：加密演算法。

D：解密演算法。

⑺ 對稱加密的工作過程

下面舉個例子來簡要說明一下對稱加密的工作過程。甲和乙是一對生意搭檔，他們住在不同的城市。由於生意上的需要，他們經常會相互之間郵寄重要的貨物。為了保證貨物的安全，他們商定製作一個保險盒，將物品放入其中。他們打造了兩把相同的鑰匙分別保管，以便在收到包裹時用這個鑰匙打開保險盒，以及在郵寄貨物前用這把鑰匙鎖上保險盒。
上面是一個將重要資源安全傳遞到目的地的傳統方式，只要甲乙小心保管好鑰匙，那麼就算有人得到保險盒，也無法打開。這個思想被用到了現代計算機通信的信息加密中。在對稱加密中，數據發送方將明文（原始數據）和加密密鑰一起經過特殊加密演算法處理後，使其變成復雜的加密密文發送出去。接收方收到密文後，若想解讀原文，則需要使用加密密鑰及相同演算法的逆演算法對密文進行解密，才能使其恢復成可讀明文。在對稱加密演算法中，使用的密鑰只有一個，發收信雙方都使用這個密鑰對數據進行加密和解密。

⑻ 請問以下對稱加密法的加密方法和解密方法是什麼

一、加密方法
一個加密系統S可以用數學符號描述如下：
S={P, C, K, E, D}
其中 :
P——明文空間，表示全體可能出現的明文集合，
C——密文空間，表示全體可能出現的密文集合，
K——密鑰空間，密鑰是加密演算法中的可變參數，
E——加密演算法，由一些公式、法則或程序構成，
D——解密演算法，它是E的逆。
當給定密鑰kÎK時，各符號之間有如下關系：
C = Ek(P), 對明文P加密後得到密文C
P = Dk(C) = Dk(Ek(P)), 對密文C解密後得明文P
如用E-1 表示E的逆，D-1表示D的逆，則有：
Ek = Dk-1且Dk = Ek-1
因此，加密設計主要是確定E，D，K。
二、解密方法

1 實現密鑰的交換，在對稱加密演算法中有這樣一個問題，對方如何獲得密鑰，在這里就可以通過公鑰演算法來實現。即用公鑰加密演算法對密鑰進行加密，再發送給對方就OK了
2 數字簽名。加密可以使用公鑰/私鑰，相對應的就是使用私鑰/公鑰解密。因此若是發送方使用自己的私鑰進行加密，則必須用發送方公鑰進行解密，這樣就證明了發送方的真實性，起到了防抵賴的作用。

⑼ 對稱加密演算法的應用模式

加密模式(英文名稱及簡寫)
中文名稱
Electronic
Code
Book(ECB)
電子密碼本模式
Cipher
Block
Chaining(CBC)
密碼分組鏈接模式
Cipher
Feedback
Mode(CFB)
加密反饋模式
Output
Feedback
Mode(OFB)
輸出反饋模式
ECB：最基本的加密模式，也就是通常理解的加密，相同的明文將永遠加密成相同的密文，無初始向量，容易受到密碼本重放攻擊，一般情況下很少用。
CBC：明文被加密前要與前面的密文進行異或運算後再加密，因此只要選擇不同的初始向量，相同的密文加密後會形成不同的密文，這是目前應用最廣泛的模式。CBC加密後的密文是上下文相關的，但明文的錯誤不會傳遞到後續分組，但如果一個分組丟失，後面的分組將全部作廢(同步錯誤)。
CFB：類似於自同步序列密碼，分組加密後，按8位分組將密文和明文進行移位異或後得到輸出同時反饋回移位寄存器，優點最小可以按位元組進行加解密，也可以是n位的，CFB也是上下文相關的，CFB模式下，明文的一個錯誤會影響後面的密文(錯誤擴散)。
OFB：將分組密碼作為同步序列密碼運行，和CFB相似，不過OFB用的是前一個n位密文輸出分組反饋回移位寄存器，OFB沒有錯誤擴散問題。

⑽ 加密基礎知識二 非對稱加密RSA演算法和對稱加密

上述過程中，出現了公鑰(3233,17)和私鑰(3233,2753)，這兩組數字是怎麼找出來的呢？參考 RSA演算法原理（二）
首字母縮寫說明：E是加密（Encryption）D是解密（Decryption）N是數字（Number）。

1.隨機選擇兩個不相等的質數p和q。
alice選擇了61和53。（實際應用中，這兩個質數越大，就越難破解。）

2.計算p和q的乘積n。
n = 61×53 = 3233
n的長度就是密鑰長度。3233寫成二進制是110010100001，一共有12位，所以這個密鑰就是12位。實際應用中，RSA密鑰一般是1024位，重要場合則為2048位。

3.計算n的歐拉函數φ(n)。稱作L
根據公式φ(n) = (p-1)(q-1)
alice算出φ(3233)等於60×52，即3120。

4.隨機選擇一個整數e，也就是公鑰當中用來加密的那個數字
條件是1< e < φ(n)，且e與φ(n) 互質。
alice就在1到3120之間，隨機選擇了17。（實際應用中，常常選擇65537。）

5.計算e對於φ(n)的模反元素d。也就是密鑰當中用來解密的那個數字
所謂"模反元素"就是指有一個整數d，可以使得ed被φ(n)除的余數為1。ed ≡ 1 (mod φ(n))
alice找到了2753，即17*2753 mode 3120 = 1

6.將n和e封裝成公鑰，n和d封裝成私鑰。
在alice的例子中，n=3233，e=17，d=2753，所以公鑰就是 (3233,17)，私鑰就是（3233, 2753）。

上述故事中，blob為了偷偷地傳輸移動位數6，使用了公鑰做加密，即6^17 mode 3233 = 824。alice收到824之後，進行解密，即824^2753 mod 3233 = 6。也就是說，alice成功收到了blob使用的移動位數。

再來復習一下整個流程：
p=17,q=19
n = 17 19 = 323
L = 16 18 = 144
E = 5(E需要滿足以下兩個條件：1<E<144,E和144互質)
D = 29(D要滿足兩個條件，1<D<144,D mode 144 = 1)
假設某個需要傳遞123，則加密後：123^5 mode 323 = 225
接收者收到225後，進行解密，225^ 29 mode 323 = 123

回顧上面的密鑰生成步驟，一共出現六個數字：
p
q
n
L即φ(n)
e
d
這六個數字之中，公鑰用到了兩個（n和e），其餘四個數字都是不公開的。其中最關鍵的是d，因為n和d組成了私鑰，一旦d泄漏，就等於私鑰泄漏。那麼，有無可能在已知n和e的情況下，推導出d？
（1）ed≡1 (mod φ(n))。只有知道e和φ(n)，才能算出d。
（2）φ(n)=(p-1)(q-1)。只有知道p和q，才能算出φ(n)。
（3）n=pq。只有將n因數分解，才能算出p和q。
結論：如果n可以被因數分解，d就可以算出，也就意味著私鑰被破解。
可是，大整數的因數分解，是一件非常困難的事情。目前，除了暴力破解，還沒有發現別的有效方法。維基網路這樣寫道："對極大整數做因數分解的難度決定了RSA演算法的可靠性。換言之，對一極大整數做因數分解愈困難，RSA演算法愈可靠。假如有人找到一種快速因數分解的演算法，那麼RSA的可靠性就會極度下降。但找到這樣的演算法的可能性是非常小的。今天只有短的RSA密鑰才可能被暴力破解。到2008年為止，世界上還沒有任何可靠的攻擊RSA演算法的方式。只要密鑰長度足夠長，用RSA加密的信息實際上是不能被解破的。"

然而，雖然RSA的安全性依賴於大數的因子分解，但並沒有從理論上證明破譯RSA的難度與大數分解難度等價。即RSA的重大缺陷是無法從理論上把握它的保密性能如何。此外，RSA的缺點還有：
A)產生密鑰很麻煩，受到素數產生技術的限制，因而難以做到一次一密。
B)分組長度太大，為保證安全性，n 至少也要 600bits以上，使運算代價很高，尤其是速度較慢，較對稱密碼演算法慢幾個數量級；且隨著大數分解技術的發展，這個長度還在增加，不利於數據格式的標准化。因此， 使用RSA只能加密少量數據，大量的數據加密還要靠對稱密碼演算法 。

加密和解密是自古就有技術了。經常看到偵探電影的橋段，勇敢又機智的主角，拿著一長串毫無意義的數字苦惱，忽然靈光一閃，翻出一本厚書，將第一個數字對應頁碼數，第二個數字對應行數，第三個數字對應那一行的某個詞。數字變成了一串非常有意義的話：
Eat the beancurd with the peanut. Taste like the ham.

這種加密方法是將原來的某種信息按照某個規律打亂。某種打亂的方式就叫做密鑰(cipher code)。發出信息的人根據密鑰來給信息加密，而接收信息的人利用相同的密鑰，來給信息解密。 就好像一個帶鎖的盒子。發送信息的人將信息放到盒子里，用鑰匙鎖上。而接受信息的人則用相同的鑰匙打開。加密和解密用的是同一個密鑰，這種加密稱為對稱加密（symmetric encryption）。

如果一對一的話，那麼兩人需要交換一個密鑰。一對多的話，比如總部和多個特工的通信，依然可以使用同一套密鑰。 但這種情況下，對手偷到一個密鑰的話，就知道所有交流的信息了。 二戰中盟軍的情報戰成果，很多都來自於破獲這種對稱加密的密鑰。

為了更安全，總部需要給每個特工都設計一個不同的密鑰。如果是FBI這樣龐大的機構，恐怕很難維護這么多的密鑰。在現代社會，每個人的信用卡信息都需要加密。一一設計密鑰的話，銀行怕是要跪了。

對稱加密的薄弱之處在於給了太多人的鑰匙。如果只給特工鎖，而總部保有鑰匙，那就容易了。特工將信息用鎖鎖到盒子里，誰也打不開，除非到總部用唯一的一把鑰匙打開。只是這樣的話，特工每次出門都要帶上許多鎖，太容易被識破身份了。總部老大想了想，乾脆就把造鎖的技術公開了。特工，或者任何其它人，可以就地取材，按照圖紙造鎖，但無法根據圖紙造出鑰匙。鑰匙只有總部的那一把。

上面的關鍵是鎖和鑰匙工藝不同。知道了鎖，並不能知道鑰匙。這樣，銀行可以將「造鎖」的方法公布給所有用戶。 每個用戶可以用鎖來加密自己的信用卡信息。即使被別人竊聽到，也不用擔心：只有銀行才有鑰匙呢！這樣一種加密演算法叫做非對稱加密(asymmetric encryption)。非對稱加密的經典演算法是RSA演算法。它來自於數論與計算機計數的奇妙結合。

1976年，兩位美國計算機學家Whitfield Diffie 和 Martin Hellman，提出了一種嶄新構思，可以在不直接傳遞密鑰的情況下，完成解密。這被稱為"Diffie-Hellman密鑰交換演算法"。這個演算法啟發了其他科學家。人們認識到，加密和解密可以使用不同的規則，只要這兩種規則之間存在某種對應關系即可，這樣就避免了直接傳遞密鑰。這種新的加密模式被稱為"非對稱加密演算法"。

1977年，三位數學家Rivest、Shamir 和 Adleman 設計了一種演算法，可以實現非對稱加密。這種演算法用他們三個人的名字命名，叫做RSA演算法。從那時直到現在，RSA演算法一直是最廣為使用的"非對稱加密演算法"。毫不誇張地說，只要有計算機網路的地方，就有RSA演算法。

1.能「撞」上的保險箱（非對稱/公鑰加密體制，Asymmetric / Public Key Encryption）

數據加密解密和門鎖很像。最開始的時候，人們只想到了那種只能用鑰匙「鎖」數據的鎖。如果在自己的電腦上自己加密數據，當然可以用最開始這種門鎖的形式啦，方便快捷，簡單易用有木有。

但是我們現在是通信時代啊，雙方都想做安全的通信怎麼辦呢？如果也用這種方法，通信就好像互相發送密碼保險箱一樣…而且雙方必須都有鑰匙才能進行加密和解密。也就是說，兩個人都拿著保險箱的鑰匙，你把數據放進去，用鑰匙鎖上發給我。我用同樣的鑰匙把保險箱打開，再把我的數據鎖進保險箱，發送給你。

這樣看起來好像沒什麼問題。但是，這裡面 最大的問題是：我們兩個怎麼弄到同一個保險箱的同一個鑰匙呢？ 好像僅有的辦法就是我們兩個一起去買個保險箱，然後一人拿一把鑰匙，以後就用這個保險箱了。可是，現代通信社會，絕大多數情況下別說一起去買保險箱了，連見個面都難，這怎麼辦啊？

於是，人們想到了「撞門」的方法。我這有個可以「撞上」的保險箱，你那裡自己也買一個這樣的保險箱。通信最開始，我把保險箱打開，就這么開著把保險箱發給你。你把數據放進去以後，把保險箱「撞」上發給我。撞上以後，除了我以外，誰都打不開保險箱了。這就是RSA了，公開的保險箱就是公鑰，但是我有私鑰，我才能打開。

2.數字簽名
這種鎖看起來好像很不錯，但是鎖在運輸的過程中有這么一個嚴重的問題：你怎麼確定你收到的開著的保險箱就是我發來的呢？對於一個聰明人，他完全可以這么干：
(a)裝作運輸工人。我現在把我開著的保險箱運給對方。運輸工人自己也弄這么一個保險箱，運輸的時候把保險箱換成他做的。
(b)對方收到保險箱後，沒法知道這個保險箱是我最初發過去的，還是運輸工人替換的。對方把數據放進去，把保險箱撞上。
(c)運輸工人往回運的時候，用自己的鑰匙打開自己的保險箱，把數據拿走。然後復印也好，偽造也好，弄出一份數據，把這份數據放進我的保險箱，撞上，然後發給我。
從我的角度，從對方的角度，都會覺得這數據傳輸過程沒問題。但是，運輸工人成功拿到了數據，整個過程還是不安全的，大概的過程是這樣：

這怎麼辦啊？這個問題的本質原因是，人們沒辦法獲知，保險箱到底是「我」做的，還是運輸工人做的。那乾脆，我們都別做保險箱了，讓權威機構做保險箱，然後在每個保險箱上用特殊的工具刻上一個編號。對方收到保險箱的時候，在權威機構的「公告欄」上查一下編號，要是和保險箱上的編號一樣，我就知道這個保險箱是「我」的，就安心把數據放進去。大概過程是這樣的：

如何做出刻上編號，而且編號沒法修改的保險箱呢？這涉及到了公鑰體制中的另一個問題：數字簽名。
要知道，刻字這種事情吧，誰都能幹，所以想做出只能自己刻字，還沒法讓別人修改的保險箱確實有點難度。那麼怎麼辦呢？這其實困擾了人們很長的時間。直到有一天，人們發現：我們不一定非要在保險箱上刻規規矩矩的字，我們乾脆在保險箱上刻手寫名字好了。而且，刻字有點麻煩，乾脆我們在上面弄張紙，讓人直接在上面寫，簡單不費事。具體做法是，我們在保險箱上嵌進去一張紙，然後每個出產的保險箱都讓權威機構的CEO簽上自己的名字。然後，CEO把自己的簽名公開在權威機構的「公告欄」上面。比如這個CEO就叫「學酥」，那麼整個流程差不多是這個樣子：

這個方法的本質原理是，每個人都能夠通過筆跡看出保險箱上的字是不是學酥CEO簽的。但是呢，這個字體是學酥CEO唯一的字體。別人很難模仿。如果模仿我們就能自己分辨出來了。要是實在分辨不出來呢，我們就請一個筆跡專家來分辨。這不是很好嘛。這個在密碼學上就是數字簽名。

上面這個簽字的方法雖然好，但是還有一個比較蛋疼的問題。因為簽字的樣子是公開的，一個聰明人可以把公開的簽字影印一份，自己造個保險箱，然後把這個影印的字也嵌進去。這樣一來，這個聰明人也可以造一個相同簽字的保險箱了。解決這個問題一個非常簡單的方法就是在看保險箱上的簽名時，不光看字體本身，還要看字體是不是和公開的字體完全一樣。要是完全一樣，就可以考慮這個簽名可能是影印出來的。甚至，還要考察字體是不是和其他保險櫃上的字體一模一樣。因為聰明人為了欺騙大家，可能不影印公開的簽名，而影印其他保險箱上的簽名。這種解決方法雖然簡單，但是驗證簽名的時候麻煩了一些。麻煩的地方在於我不僅需要對比保險箱上的簽名是否與公開的筆跡一樣，還需要對比得到的簽名是否與公開的筆跡完全一樣，乃至是否和所有發布的保險箱上的簽名完全一樣。有沒有什麼更好的方法呢？

當然有，人們想到了一個比較好的方法。那就是，學酥CEO簽字的時候吧，不光把名字簽上，還得帶上簽字得日期，或者帶上這個保險箱的編號。這樣一來，每一個保險箱上的簽字就唯一了，這個簽字是學酥CEO的簽名+學酥CEO寫上的時間或者編號。這樣一來，就算有人偽造，也只能偽造用過的保險箱。這個問題就徹底解決了。這個過程大概是這么個樣子：

3 造價問題（密鑰封裝機制，Key Encapsulation Mechanism）
解決了上面的各種問題，我們要考慮考慮成本了… 這種能「撞」門的保險箱雖然好，但是這種鎖造價一般來說要比普通的鎖要高，而且鎖生產時間也會變長。在密碼學中，對於同樣「結實」的鎖，能「撞」門的鎖的造價一般來說是普通鎖的上千倍。同時，能「撞」門的鎖一般來說只能安裝在小的保險櫃裡面。畢竟，這么復雜的鎖，裝起來很費事啊！而普通鎖安裝在多大的保險櫃上面都可以呢。如果兩個人想傳輸大量數據的話，用一個大的保險櫃比用一堆小的保險櫃慢慢傳要好的多呀。怎麼解決這個問題呢？人們又想出了一個非常棒的方法：我們把兩種鎖結合起來。能「撞」上的保險櫃裡面放一個普通鎖的鑰匙。然後造一個用普通的保險櫃來鎖大量的數據。這樣一來，我們相當於用能「撞」上的保險櫃發一個鑰匙過去。對方收到兩個保險櫃後，先用自己的鑰匙把小保險櫃打開，取出鑰匙。然後在用這個鑰匙開大的保險櫃。這樣做更棒的一個地方在於，既然對方得到了一個鑰匙，後續再通信的時候，我們就不再需要能「撞」上的保險櫃了啊，在以後一定時間內就用普通保險櫃就好了，方便快捷嘛。

以下參考 數字簽名、數字證書、SSL、https是什麼關系？
4.數字簽名（Digital Signature）
數據在瀏覽器和伺服器之間傳輸時，有可能在傳輸過程中被冒充的盜賊把內容替換了，那麼如何保證數據是真實伺服器發送的而不被調包呢，同時如何保證傳輸的數據沒有被人篡改呢，要解決這兩個問題就必須用到數字簽名，數字簽名就如同日常生活的中的簽名一樣，一旦在合同書上落下了你的大名，從法律意義上就確定是你本人簽的字兒，這是任何人都沒法仿造的，因為這是你專有的手跡，任何人是造不出來的。那麼在計算機中的數字簽名怎麼回事呢？數字簽名就是用於驗證傳輸的內容是不是真實伺服器發送的數據，發送的數據有沒有被篡改過，它就干這兩件事，是非對稱加密的一種應用場景。不過他是反過來用私鑰來加密，通過與之配對的公鑰來解密。
第一步：服務端把報文經過Hash處理後生成摘要信息Digest，摘要信息使用私鑰private-key加密之後就生成簽名，伺服器把簽名連同報文一起發送給客戶端。
第二步：客戶端接收到數據後，把簽名提取出來用public-key解密，如果能正常的解密出來Digest2，那麼就能確認是對方發的。
第三步：客戶端把報文Text提取出來做同樣的Hash處理，得到的摘要信息Digest1，再與之前解密出來的Digist2對比，如果兩者相等，就表示內容沒有被篡改，否則內容就是被人改過了。因為只要文本內容哪怕有任何一點點改動都會Hash出一個完全不一樣的摘要信息出來。

5.數字證書（Certificate Authority）
數字證書簡稱CA，它由權威機構給某網站頒發的一種認可憑證，這個憑證是被大家（瀏覽器）所認可的，為什麼需要用數字證書呢，難道有了數字簽名還不夠安全嗎？有這樣一種情況，就是瀏覽器無法確定所有的真實伺服器是不是真的是真實的，舉一個簡單的例子：A廠家給你們家安裝鎖，同時把鑰匙也交給你，只要鑰匙能打開鎖，你就可以確定鑰匙和鎖是配對的，如果有人把鑰匙換了或者把鎖換了，你是打不開門的，你就知道肯定被竊取了，但是如果有人把鎖和鑰匙替換成另一套表面看起來差不多的，但質量差很多的，雖然鑰匙和鎖配套，但是你卻不能確定這是否真的是A廠家給你的，那麼這時候，你可以找質檢部門來檢驗一下，這套鎖是不是真的來自於A廠家，質檢部門是權威機構，他說的話是可以被公眾認可的（呵呵）。
同樣的， 因為如果有人（張三）用自己的公鑰把真實伺服器發送給瀏覽器的公鑰替換了，於是張三用自己的私鑰執行相同的步驟對文本Hash、數字簽名，最後得到的結果都沒什麼問題，但事實上瀏覽器看到的東西卻不是真實伺服器給的，而是被張三從里到外（公鑰到私鑰）換了一通。那麼如何保證你現在使用的公鑰就是真實伺服器發給你的呢？我們就用數字證書來解決這個問題。數字證書一般由數字證書認證機構（Certificate Authority）頒發，證書裡麵包含了真實伺服器的公鑰和網站的一些其他信息，數字證書機構用自己的私鑰加密後發給瀏覽器，瀏覽器使用數字證書機構的公鑰解密後得到真實伺服器的公鑰。這個過程是建立在被大家所認可的證書機構之上得到的公鑰，所以這是一種安全的方式。

常見的對稱加密演算法有DES、3DES、AES、RC5、RC6。非對稱加密演算法應用非常廣泛，如SSH,
HTTPS, TLS，電子證書，電子簽名，電子身份證等等。
參考 DES/3DES/AES區別