密码学之对称加密

时间  2019-11-30
标签 密码学 对称 加密 繁體版
原文   原文链接

本文将介绍比特序列运算中的异或运算，同时简单介绍DES、3DES、AES等对称加密算法，最后给出对应的Golang加密代码。算法

比特序列密码

首先咱们要明白二个概念，一个是计算机编码，咱们都知道计算机操做的对象并非文字图像，而是有0和1排列组成的比特序列；一个是异或运算（XOR）, 二个不一样的比特位异或运算结果是1，不一样的比特位异或运算结果是0。安全

假设咱们将01001100这个比特序列成为A，将10101010这个比特序列成为B，那么A与B的异或运算结果就以下所示：网络

因为二个相同的数进行异或运算的结果是0，所以若是将A与B异或的结果再与B进行异或预算，则结果就会变回A。 app

可能你已经发现了，上面的计算和加密、解密的步骤很是类似。函数

  • 将明文A与秘钥B进行加密运算，获得密文A⊕B
  • 将密文A⊕B用秘钥B进行解密，获得明文A

实际上，主要选择一个合适的B，仅仅使用异或运算就能够实现一个高强度的密码。测试

DES

DES（Data EncryptionStandard） 是1977年美国联邦信息处理标准（FIPS）中所采用的一种对称密码（FIPS46.3）。DES一直以来被美国以及其余国家的政府和银行等普遍使用。然而，随着计算机的进步，如今DES已经可以被暴力破解，强度大不如前了。ui

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了。加密

加密和解密

DES是一种将64比特的明文加密成64比特的密文的对称密码算法， 它的密钥长度是56比特。尽管从规格上来讲，DES的密钥长度是64比特，但因为每隔7比特会设置一个用于错误检查的比特，所以实质上其密钥长度是56比特。spa

DES是以64比特的明文（比特序列）为一个单位来进行加密的，这个64比特的单位称为分组。通常来讲，以分组为单位进行处理的密码算法称为分组密码（blockcipher），DES就是分组密码的一种。

DES每次只能加密64比特的数据，若是要加密的明文比较长，就须要对DES加密进行迭代（反复），而迭代的具体方式就称为模式（mode）（后续文章详细讲解分组密码的模式）。

大B -> bit

小b -> byte

秘钥长度(56bit + 8bit)/8 = 8byte

  • DES的加密与解密 - 图例

Go中对DES的操做

加解密实现思路

  • 加密 - CBC分组模式

    1. 建立并返回一个使用DES算法的cipher.Block接口
      • 秘钥长度为64bit, 即 64/8 = 8字节(byte)
    2. 对最后一个明文分组进行数据填充
      • DES是以64比特的明文（比特序列）为一个单位来进行加密的
      • 最后一组不够64bit, 则须要进行数据填充( 参考第三章)
    3. 建立一个密码分组为连接模式的, 底层使用DES加密的BlockMode接口
    4. 加密连续的数据块

  • 解密

    1. 建立并返回一个使用DES算法的cipher.Block接口
    2. 建立一个密码分组为连接模式的, 底层使用DES解密的BlockMode接口
    3. 数据块解密
    4. 去掉最后一组的填充数据
加解密的代码实现

在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))
}
复制代码

重要的函数说明

  1. 生成一个底层使用DES加/解密的Block接口对象

    函数对应的包: import "crypto/des"
func NewCipher(key []byte) (cipher.Block, error) - 参数 key: des对称加密使用的密码, 密码长度为64bit, 即8byte - 返回值 cipher.Block: 建立出的使用DES加/解密的Block接口对象 复制代码

  2. 建立一个密码分组为CBC模式, 底层使用b加密的BlockMode接口对象

    函数对应的包: import "crypto/cipher"
func NewCBCEncrypter(b Block, iv []byte) BlockMode - 参数 b: 使用des.NewCipher函数建立出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每一个分组为64bit, 即8byte - 返回值: 获得的BlockMode接口对象 复制代码

  3. 使用cipher包的BlockMode接口对象对数据进行加/解密

    接口对应的包: import "crypto/cipher"
type BlockMode interface {
    // 返回加密字节块的大小
    BlockSize() int
    // 加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，src和dst可指向同一内存地址
    CryptBlocks(dst, src []byte)
}
接口中的 CryptBlocks(dst, src []byte) 方法:
    - 参数 dst: 传出参数, 存储加密或解密运算以后的结果 
    - 参数 src: 传入参数, 须要进行加密或解密的数据切片(字符串)
复制代码

  4. 建立一个密码分组为CBC模式, 底层使用b解密的BlockMode接口对象

    函数对应的包: import "crypto/cipher"
func NewCBCDecrypter(b Block, iv []byte) BlockMode - 参数 b: 使用des.NewCipher函数建立出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每一个分组为64bit, 即8byte, 该序列的值须要和NewCBCEncrypter函数的第二个参数iv值相同 - 返回值: 获得的BlockMode接口对象 复制代码

  5. 自定义函数介绍

    对称加密加密须要对数据进行分组, 保证每一个分组的数据长度相等, 若是最后一个分组长度不够, 须要进行填充
func PKCS5Padding(ciphertext []byte, blockSize int) []byte - 参数 ciphertext: 须要加密的原始数据 - 参数 blockSize: 每一个分组的长度, 跟使用的加密算法有关系 * des：64bit， 8byte * 3des：64bit， 8byte * aes： 128bit， 16byte 复制代码

三重DES

如今DES已经能够在现实的时间内被暴力破解，所以咱们须要一种用来替代DES的分组密码，三重DES就是出于这个目的被开发出来的。

三重DES（triple-DES）是为了增长DES的强度，将DES重复3次所获得的一种密码算法，一般缩写为3DES。

三重DES的加密

三重DES的加解密机制以下图所示：

加->解->加 -> 目的是为了兼容DES(若是三个秘钥都同样)

3des秘钥长度24字节 = 1234567a 1234567b 1234567a

明文: 10

秘钥1: 2

秘钥2: 3

秘钥3: 4

加密算法: 明文+秘钥

解密算法: 密文-秘钥

10+2-3+4

)

明文通过三次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）这个流程。

密钥一、密钥二、密钥3所有使用不一样的比特序列的三重DES称为DES-EDE3。

尽管三重DES目前还被银行等机构使用，但其处理速度不高，并且在安全性方面也逐渐显现出了一些问题。

Go中对3DES的操做

加解密实现思路

  • 加密 - CBC分组模式

    1. 建立并返回一个使用3DES算法的cipher.Block接口
      • 秘钥长度为64bit*3=192bit, 即 192/8 = 24字节(byte)
    2. 对最后一个明文分组进行数据填充
      • 3DES是以64比特的明文（比特序列）为一个单位来进行加密的
      • 最后一组不够64bit, 则须要进行数据填充( 参考第三章)
    3. 建立一个密码分组为连接模式的, 底层使用3DES加密的BlockMode接口
    4. 加密连续的数据块

  • 解密

    1. 建立并返回一个使用3DES算法的cipher.Block接口
    2. 建立一个密码分组为连接模式的, 底层使用3DES解密的BlockMode接口
    3. 数据块解密
    4. 去掉最后一组的填充数据
加解密的代码实现

3DES加密代码

// 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解密代码

// 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
}
复制代码

重要的函数说明

  1. 生成一个底层使用3DES加/解密的Block接口对象

    函数对应的包: import "crypto/des"
func NewTripleDESCipher(key []byte) (cipher.Block, error) - 参数 key: 3des对称加密使用的密码, 密码长度为(64*3)bit, 即(8*3)byte - 返回值 cipher.Block: 建立出的使用DES加/解密的Block接口对象 复制代码

  2. 建立一个密码分组为CBC模式, 底层使用b加密的BlockMode接口对象

    函数对应的包: import "crypto/cipher"
func NewCBCEncrypter(b Block, iv []byte) BlockMode - 参数 b: 使用des.NewTripleDESCipher 函数建立出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每一个分组为64bit, 即8byte - 返回值: 获得的BlockMode接口对象 复制代码

  3. 使用cipher包的BlockMode接口对象对数据进行加/解密

    接口对应的包: import "crypto/cipher"
type BlockMode interface {
    // 返回加密字节块的大小
    BlockSize() int
    // 加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，src和dst可指向同一内存地址
    CryptBlocks(dst, src []byte)
}
接口中的 CryptBlocks(dst, src []byte) 方法:
    - 参数 dst: 传出参数, 存储加密或解密运算以后的结果 
    - 参数 src: 传入参数, 须要进行加密或解密的数据切片(字符串)
复制代码

  4. 建立一个密码分组为CBC模式, 底层使用b解密的BlockMode接口对象

    函数对应的包: import "crypto/cipher"
func NewCBCDecrypter(b Block, iv []byte) BlockMode - 参数 b: 使用des.NewTripleDESCipher 函数建立出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每一个分组为64bit, 即8byte, 该序列的值须要和NewCBCEncrypter函数的第二个参数iv值相同 - 返回值: 获得的BlockMode接口对象 复制代码

AES

AES（Advanced Encryption Standard）是取代其前任标准（DES）而成为新标准的一种对称密码算法。全世界的企业和密码学家提交了多个对称密码算法做为AES的候选，最终在2000年从这些候选算法中选出了一种名为Rijndael的对称密码算法，并将其肯定为了AES。

Rijndael的分组长度为128比特，密钥长度能够以32比特为单位在128比特到256比特的范围内进行选择（不过在AES的规格中，密钥长度只有12八、192和256比特三种）。

  • 128bit = 16字节
  • 192bit = 24字节
  • 256bit = 32字节

在go提供的接口中秘钥长度只能是16字节

AES的加密和解密

和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 -- 逆列混淆

Go中对AES的使用

加解密实现思路

  • 加密 - CBC分组模式

    1. 建立并返回一个使用AES算法的cipher.Block接口
      • 秘钥长度为128bit, 即 128/8 = 16字节(byte)
    2. 对最后一个明文分组进行数据填充
      • AES是以128比特的明文（比特序列）为一个单位来进行加密的
      • 最后一组不够128bit, 则须要进行数据填充( 参考第三章)
    3. 建立一个密码分组为连接模式的, 底层使用AES加密的BlockMode接口
    4. 加密连续的数据块

  • 解密

    1. 建立并返回一个使用AES算法的cipher.Block接口
    2. 建立一个密码分组为连接模式的, 底层使用AES解密的BlockMode接口
    3. 数据块解密
    4. 去掉最后一组的填充数据
加解密的代码实现

AES加密代码

// 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解密

// 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
}
复制代码

重要的函数说明

  1. 生成一个底层使用AES加/解密的Block接口对象

    函数对应的包: import "crypto/aes"
func NewCipher(key []byte) (cipher.Block, error) - 参数 key: aes对称加密使用的密码, 密码长度为128bit, 即16byte - 返回值 cipher.Block: 建立出的使用AES加/解密的Block接口对象 复制代码

  2. 建立一个密码分组为CBC模式, 底层使用b加密的BlockMode接口对象

    函数对应的包: import "crypto/cipher"
func NewCBCEncrypter(b Block, iv []byte) BlockMode - 参数 b: 使用aes.NewCipher函数建立出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每一个分组为64bit, 即8byte - 返回值: 获得的BlockMode接口对象 复制代码

  3. 使用cipher包的BlockMode接口对象对数据进行加/解密

    接口对应的包: import "crypto/cipher"
type BlockMode interface {
    // 返回加密字节块的大小
    BlockSize() int
    // 加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，src和dst可指向同一内存地址
    CryptBlocks(dst, src []byte)
}
接口中的 CryptBlocks(dst, src []byte) 方法:
    - 参数 dst: 传出参数, 存储加密或解密运算以后的结果 
    - 参数 src: 传入参数, 须要进行加密或解密的数据切片(字符串)
复制代码

  4. 建立一个密码分组为CBC模式, 底层使用b解密的BlockMode接口对象

    函数对应的包: import "crypto/cipher"
func NewCBCDecrypter(b Block, iv []byte) BlockMode - 参数 b: 使用des.NewCipher函数建立出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每一个分组为128bit, 即16byte, 该序列的值须要和NewCBCEncrypter函数的第二个参数iv值相同 - 返回值: 获得的BlockMode接口对象 复制代码

应选择哪一种对称加密

前面介绍了DES、三重DES和AES等对称密码，那么咱们到底应该使用哪种对称密码算法呢？

  1. 从此最好不要将DES用于新的用途，由于随着计算机技术的进步，如今用暴力破解法已经可以在现实的时间内完成对DES的破译。可是，在某些状况下也须要保持与旧版本软件的兼容性。
  2. 出于兼容性的因素三重DES在从此还会使用一段时间，但会逐渐被AES所取代。
  3. 从此你们应该使用的算法是AES（Rijndael），由于它安全、快速，并且可以在各类平台上工做。此外，因为全世界的密码学家都在对AES进行不断的验证，所以即使万一发现它有什么缺陷，也会马上告知全世界并修复这些缺陷。

通常来讲，咱们不该该使用任何自制的密码算法，而是应该使用AES。由于AES在其选定过程当中，通过了全世界密码学家所进行的高品质的验证工做，而对于自制的密码算法则很难进行这样的验证。

欢迎与我交流

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程