1 编码的概念
将现实世界中的东西映射为比特序列的操作称为编码(encoding)。
计算机的操作对象并不是文字,而是由0和1排列而成的比特序列。
举例:h 转换为比特序列
h ->int 104(十进制ASCII码)->0110 1000
G = 1024m
m = 1024kbyte
byte = 8bit
bit 0/1
加密过程可以称之为编码,解密则是解码。
2 DES -- Data Encryption Standard
现在已经不可靠了!!!
2.1 什么是DES?
DES(Data Encryption Standard)是1977年美国联邦信息处理标准(FIPS)中所采用的一种对称密码(FIPS46.3)。DES一直以来被美国以及其他国家的政府和银行等广泛使用。然而,随着计算机的进步,现在DES已经能够被暴力破解,强度大不如前了。
RSA公司举办过破泽DES密钥的比赛(DESChallenge),我们可以看一看RSA公司官方公布的比赛结果:
-
1997年的DES Challenge1中用了96天破译密钥
-
1998年的DES ChallengeIl-I中用了41天破译密钥
-
1998年的DES ChallengeII-2中用了56小时破译密钥
-
1999年的DES ChallengeIll中只用了22小时15分钟破译密钥
由于DES的密文可以在短时间内被破译,因此除了用它来解密以前的密文以外,现在我们不应该再使用DES了。
2.2 加密和解密
DES是一种将64比特的明文加密成64比特的密文的对称密码算法,它的密钥长度是56比特。尽管从规格上来说,DES的密钥长度是64比特,但由于每隔7比特会设置一个用于错误检查的比特,因此实质上其密钥长度是56比特。
DES是以64比特的明文(比特序列)为一个单位来进行加密的,这个64比特的单位称为分组。一般来说,以分组为单位进行处理的密码算法称为分组密码(blockcipher),DES就是分组密码的一种。
DES每次只能加密64比特的数据,如果要加密的明文比较长,就需要对DES加密进行迭代(反复),而迭代的具体方式就称为模式(mode)。
图例:
注:DES分组长度是8byte = 64bit,共分为8个组,密钥长度是56bit,多出8bit是每组各一个的错误检测标志位。
2.3 DES在go中的操作
该算法现在已经非常容易被破解,大家不要使用该算法,代码部分作为了解原理。
2.3.1 加密解密实现思路
2.3.2 加解密的代码实现
在Go中使用DES需要导入的包:
import (
"crypto/des"
"crypto/cipher"
"fmt"
"bytes"
)
DES加密代码:
// src -> 要加密的明文
// key -> 秘钥, 大小为: 8byte
func DesEncrypt_CBC(src, key []byte) []byte{
// 1. 创建并返回一个使用DES算法的cipher.Block接口
block, err := des.NewCipher(key)
// 2. 判断是否创建成功
if err != nil{
panic(err)
}
// 3. 对最后一个明文分组进行数据填充
src = PKCS5Padding(src, block.BlockSize())
// 4. 创建一个密码分组为链接模式的, 底层使用DES加密的BlockMode接口
// 参数iv的长度, 必须等于b的块尺寸
tmp := []byte("helloAAA")
blackMode := cipher.NewCBCEncrypter(block, tmp)
// 5. 加密连续的数据块
dst := make([]byte, len(src))
blackMode.CryptBlocks(dst, src)
fmt.Println("加密之后的数据: ", dst)
// 6. 将加密数据返回
return dst
}
DES解密代码:
// src -> 要解密的密文
// key -> 秘钥, 和加密秘钥相同, 大小为: 8byte
func DesDecrypt_CBC(src, key []byte) []byte {
// 1. 创建并返回一个使用DES算法的cipher.Block接口
block, err := des.NewCipher(key)
// 2. 判断是否创建成功
if err != nil{
panic(err)
}
// 3. 创建一个密码分组为链接模式的, 底层使用DES解密的BlockMode接口
tmp := []byte("helloAAA")
blockMode := cipher.NewCBCDecrypter(block, tmp)
// 4. 解密数据
dst := src
blockMode.CryptBlocks(src, dst)
// 5. 去掉最后一组填充的数据
dst = PKCS5UnPadding(dst)
// 6. 返回结果
return dst
}
最后一个分组添加填充数据和移除添加数据代码 :
// 使用pks5的方式填充
func PKCS5Padding(ciphertext []byte, blockSize int) []byte{
// 1. 计算最后一个分组缺多少个字节
padding := blockSize - (len(ciphertext)%blockSize)
// 2. 创建一个大小为padding的切片, 每个字节的值为padding
padText := bytes.Repeat([]byte{byte(padding)}, padding)
// 3. 将padText添加到原始数据的后边, 将最后一个分组缺少的字节数补齐
newText := append(ciphertext, padText...)
return newText
}
// 删除pks5填充的尾部数据
func PKCS5UnPadding(origData []byte) []byte{
// 1. 计算数据的总长度
length := len(origData)
// 2. 根据填充的字节值得到填充的次数
number := int(origData[length-1])
// 3. 将尾部填充的number个字节去掉
return origData[:(length-number)]
}
测试函数:
func DESText() {
// 加密
key := []byte("11111111")
result := DesEncrypt_CBC([]byte("床前明月光, 疑是地上霜. 举头望明月, 低头思故乡."), key)
fmt.Println(base64.StdEncoding.EncodeToString(result))
// 解密
result = DesDecrypt_CBC(result, key)
fmt.Println("解密之后的数据: ", string(result))
}
3 三重DES
现在DES已经可以在现实的时间内被暴力破解,因此我们需要一种用来替代DES的分组密码,三重DES就是出于这个目的被开发出来的。
三重DES(triple-DES)是为了增加DES的强度,将DES重复3次所得到的一种密码算法,通常缩写为3DES。
3.1 加密和解密机制
明文经过三次DES处理才能变成最后的密文,由于DES密钥的长度实质上是56比特,因此三重DES的密钥长度就是56×3=168比特, 加上用于错误检测的标志位8x3, 共192bit。
从上图我们可以发现,三重DES并不是进行三次DES加密(加密-->加密-->加密),而是加密-->解密-->加密的过程。在加密算法中加人解密操作让人感觉很不可思议,实际上这个方法是IBM公司设计出来的,目的是为了让三重DES能够兼容普通的DES。
当三重DES中所有的密钥都相同时,三重DES也就等同于普通的DES了。这是因为在前两步加密-->解密之后,得到的就是最初的明文。因此,以前用DES加密的密文,就可以通过这种方式用三重DES来进行解密。也就是说,三重DES对DES具备向下兼容性。
如果密钥1和密钥3使用相同的密钥,而密钥2使用不同的密钥(也就是只使用两个DES密钥),这种三重DES就称为DES-EDE2。EDE表示的是加密(Encryption) -->解密(Decryption)-->加密(Encryption)这个流程。
密钥1、密钥2、密钥3全部使用不同的比特序列的三重DES称为DES-EDE3。
尽管三重DES目前还被银行等机构使用,但其处理速度不高,而且在安全性方面也逐渐显现出了一些问题。
注意:3des是安全的,但是效率低,不推荐使用,是分组密码。它的分组长度是8byte,密钥长度是24字节,在算法内会被平均分成3份。
3.2 3DES在go中的操作
package main
import (
"bytes"
"crypto/cipher"
"crypto/des"
"encoding/base64"
"fmt"
)
func main() {
key := []byte("1234567a1234567b1234567c")
result := TripleDESEncrypt([]byte("知识就是力量!"), key)
fmt.Println(base64.StdEncoding.EncodeToString(result))
result =TripleDESDecrypt(result,key)
fmt.Println(string(result))
}
// 3DES加密
func TripleDESEncrypt(src, key []byte) []byte {
// 1. 创建并返回一个使用3DES算法的cipher.Block接口
block, err := des.NewTripleDESCipher(key)
if err != nil{
panic(err)
}
// 2. 对最后一组明文进行填充
src = PKCS5Padding(src, block.BlockSize())
// 3. 创建一个密码分组为链接模式, 底层使用3DES加密的BlockMode模型
blockMode := cipher.NewCBCEncrypter(block, key[:8])
// 4. 加密数据
dst := src
blockMode.CryptBlocks(dst, src)
return dst
}
// 3DES解密
func TripleDESDecrypt(src, key []byte) []byte {
// 1. 创建3DES算法的Block接口对象
block, err := des.NewTripleDESCipher(key)
if err != nil{
panic(err)
}
// 2. 创建密码分组为链接模式, 底层使用3DES解密的BlockMode模型
blockMode := cipher.NewCBCDecrypter(block, key[:8])
// 3. 解密
dst := src
blockMode.CryptBlocks(dst, src)
// 4. 去掉尾部填充的数据
dst = PKCS5UnPadding(dst)
return dst
}
// 使用pks5的方式填充
func PKCS5Padding(ciphertext []byte, blockSize int) []byte{
// 1. 计算最后一个分组缺多少个字节
padding := blockSize - (len(ciphertext)%blockSize)
// 2. 创建一个大小为padding的切片, 每个字节的值为padding
padText := bytes.Repeat([]byte{byte(padding)}, padding)
// 3. 将padText添加到原始数据的后边, 将最后一个分组缺少的字节数补齐
newText := append(ciphertext, padText...)
return newText
}
// 删除pks5填充的尾部数据
func PKCS5UnPadding(origData []byte) []byte{
// 1. 计算数据的总长度
length := len(origData)
// 2. 根据填充的字节值得到填充的次数
number := int(origData[length-1])
// 3. 将尾部填充的number个字节去掉
return origData[:(length-number)]
}
输出:
4 AES-Rijndael
AES(Advanced Encryption Standard)是取代其前任标准(DES)而成为新标准的一种对称密码算法。全世界的企业和密码学家提交了多个对称密码算法作为AES的候选,最终在2000年从这些候选算法中选出了一种名为Rijndael的对称密码算法,并将其确定为了AES。
Rijndael是由比利时密码学家Joan Daemen和Vincent Rijmen设汁的分组密码算法,今后会有越来越多的密码软件支持这种算法。
Rijndael的分组长度为128比特,密钥长度可以以32比特为单位在128比特到256比特的范围内进行选择(不过在AES的规格中,密钥长度只有128(16字节)、192(24字节)和256(32字节)比特三种)。
注意:AES是安全的,效率高,推荐使用。它是分组密码,分组长度是128bit(16字节),密钥长度有16、24、256字节,但在go提供的接口中密钥的长度只能是16字节。
4.1 加密和解密
和DES—样,AES算法也是由多个轮所构成的,下图展示了每一轮的大致计算步骤。DES使用Feistel网络作为其基本结构,而AES没有使用Feistel网络,而是使用了SPN Rijndael的输人分组为128比特,也就是16字节。首先,需要逐个字节地对16字节的输入数据进行SubBytes处理。所谓SubBytes,就是以每个字节的值(0~255中的任意值)为索引,从一张拥有256个值的替换表(S-Box)中查找出对应值的处理,也是说,将一个1字节的值替换成另一个1字节的值。
SubBytes之后需要进行ShiftRows处理,即将SubBytes的输出以字节为单位进行打乱处理。从下图的线我们可以看出,这种打乱处理是有规律的。
ShiftRows之后需要进行MixCo1umns处理,即对一个4字节的值进行比特运算,将其变为另外一个4字节值。
最后,需要将MixColumns的输出与轮密钥进行XOR,即进行AddRoundKey处理。到这里,AES的一轮就结東了。实际上,在AES中需要重复进行10 ~ 14轮计算。
通过上面的结构我们可以发现输入的所有比特在一轮中都会被加密。和每一轮都只加密一半输人的比特的Feistel网络相比,这种方式的优势在于加密所需要的轮数更少。此外,这种方式还有一个优势,即SubBytes,ShiftRows和MixColumns可以分别按字节、行和列为单位进行并行计算。
SubBytes -- 字节代换
ShiftRows -- 行移位代换
MixColumns -- 列混淆
AddRoundKey -- 轮密钥加
下图展示了AES中一轮的解密过程。从图中我们可以看出,SubBytes、ShiftRows、MixColumns分别存在反向运算InvSubBytes、InvShiftRows、InvMixColumns,这是因为AES不像Feistel网络一样能够用同一种结构实现加密和解密。
InvSubBytes -- 逆字节替代
InvShiftRows -- 逆行移位
InvMixColumns -- 逆列混淆
4.2 AES在go中的操作
加解密代码实现(CBC分组模式):
package main
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"encoding/base64"
"fmt"
)
func main() {
key := []byte("1234567a1234567b1234567c")
result := AESEncrypt([]byte("知识就是力量!"), key)
fmt.Println(base64.StdEncoding.EncodeToString(result))
result =AESDecrypt(result,key)
fmt.Println(string(result))
}
// AES加密
func AESEncrypt(src, key []byte) []byte{
// 1. 创建一个使用AES加密的块对象
block, err := aes.NewCipher(key)
if err != nil{
panic(err)
}
// 2. 最后一个分组进行数据填充
src = PKCS5Padding(src, block.BlockSize())
// 3. 创建一个分组为链接模式, 底层使用AES加密的块模型对象
blockMode := cipher.NewCBCEncrypter(block, key[:block.BlockSize()])
// 4. 加密
dst := src
blockMode.CryptBlocks(dst, src)
return dst
}
// AES解密
func AESDecrypt(src, key []byte) []byte{
// 1. 创建一个使用AES解密的块对象
block, err := aes.NewCipher(key)
if err != nil{
panic(err)
}
// 2. 创建分组为链接模式, 底层使用AES的解密模型对象
blockMode := cipher.NewCBCDecrypter(block, key[:block.BlockSize()])
// 3. 解密
dst := src
blockMode.CryptBlocks(dst, src)
// 4. 去掉尾部填充的字
dst = PKCS5UnPadding(dst)
return dst
}
// 使用pks5的方式填充
func PKCS5Padding(ciphertext []byte, blockSize int) []byte{
// 1. 计算最后一个分组缺多少个字节
padding := blockSize - (len(ciphertext)%blockSize)
// 2. 创建一个大小为padding的切片, 每个字节的值为padding
padText := bytes.Repeat([]byte{byte(padding)}, padding)
// 3. 将padText添加到原始数据的后边, 将最后一个分组缺少的字节数补齐
newText := append(ciphertext, padText...)
return newText
}
// 删除pks5填充的尾部数据
func PKCS5UnPadding(origData []byte) []byte{
// 1. 计算数据的总长度
length := len(origData)
// 2. 根据填充的字节值得到填充的次数
number := int(origData[length-1])
// 3. 将尾部填充的number个字节去掉
return origData[:(length-number)]
}
输出:
加解密代码实现(CTR分组模式):
package main
import (
"crypto/aes"
"crypto/cipher"
"encoding/base64"
"fmt"
)
func main() {
key := []byte("1234567812345678")
str := []byte("你好!")
cipherText := aesEncrypt(str,key)
fmt.Println(base64.StdEncoding.EncodeToString(cipherText))
fmt.Println(string(aesDecrypt(cipherText,key)))
}
//aes加密,分组模式CTR
func aesEncrypt(plainText []byte,key []byte) []byte {
//建立一个底层使用aes的密码接口
block,err := aes.NewCipher(key)
if err!=nil{
panic(err)
}
//创建一个使用CTR分组模式的加密接口
iv := []byte("1234567812345678")
stream := cipher.NewCTR(block,iv)
//加密
dst := plainText
stream.XORKeyStream(dst,plainText)
return dst
}
//aes解密
func aesDecrypt(cipherText []byte,key []byte) []byte {
block,err := aes.NewCipher(key)
if err!=nil {
panic(err)
}
//创建一个使用CTR分组模式的加密接口
iv := []byte("1234567812345678")
stream := cipher.NewCTR(block,iv)
plainText := cipherText
stream.XORKeyStream(plainText,cipherText)
return plainText
}
输出:
其实CTR模式采用了XOR运算,加密和解密的算法代码上是相同的,使用一个即可.
演示:
package main
import (
"crypto/aes"
"crypto/cipher"
"encoding/base64"
"fmt"
)
func main() {
key := []byte("1234567812345678")
str := []byte("我只使用了一个函数喔!!")
cipherText := aesEncryptAndDecrypt(str,key)
fmt.Println(base64.StdEncoding.EncodeToString(cipherText))
fmt.Println(string(aesEncryptAndDecrypt(cipherText,key)))
}
//aes加密解密公用,分组模式CTR
func aesEncryptAndDecrypt(src []byte,key []byte) []byte {
//建立一个底层使用aes的密码接口
block,err := aes.NewCipher(key)
if err!=nil{
panic(err)
}
//创建一个使用CTR分组模式的加密接口
iv := []byte("1234567812345678")
stream := cipher.NewCTR(block,iv)
//加密
dst := src
stream.XORKeyStream(dst,src)
return dst
}