密码学之对称加密

<ul><li>1.密码学简介</li><li>2.对称加密</li><li>3.分组加密模式</li><li>4.非对称加密</li><li>5.单向散列函数</li><li>6.消息认证码</li><li>7.数字签名</li><li>8.证书</li><li>9.SSL/TLS</li></ul>

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

源代码

<h3>比特序列密码</h3>

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

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

<span class="img-wrap"></span>

由于二个相同的数进行异或运算的结果是0，因此如果将A与B异或的结果再与B进行异或预算，则结果就会变回A。
<span class="img-wrap"></span>

可能你已经发现了，上面的计算和加密、解密的步骤非常相似。

<ul><li>将明文A与秘钥B进行加密运算，得到密文A⊕B</li><li>将密文A⊕B用秘钥B进行解密，得到明文A</li></ul>

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

<h3>DES</h3><blockquote>DES（Data EncryptionStandard） 是1977年美国联邦信息处理标准（FIPS）中所采用的一种对称密码（FIPS46.3）。DES一直以来被美国以及其他国家的政府和银行等广泛使用。然而，随着计算机的进步，现在DES已经能够被暴力破解，强度大不如前了。</blockquote>

RSA公司举办过破解DES密钥的比赛（DESChallenge），我们可以看一看RSA公司官方公布的比赛结果：

<ul><li>1997年的DES Challenge1中用了96天破译密钥</li><li>1998年的DES ChallengeIl-I中用了41天破译密钥</li><li>1998年的DES ChallengeII-2中用了56小时破译密钥</li><li>1999年的DES ChallengeIll中只用了22小时15分钟破译密钥</li></ul>

由于DES的密文可以在短时间内被破译，因此除了用它来解密以前的密文以外，现在我们不应该再使用DES了。

<h4>加密和解密</h4>

DES是一种将64比特的明文加密成64比特的密文的对称密码算法， 它的密钥长度是56比特。尽管<font color="red">从规格上来说，DES的密钥长度是64比特，但由于每隔7比特会设置一个用于错误检查的比特，因此实质上其密钥长度是56比特</font>。

<font color="red">DES是以64比特的明文（比特序列）为一个单位来进行加密的</font>，这个64比特的单位称为分组。一般来说，以分组为单位进行处理的密码算法称为分组密码（blockcipher），DES就是分组密码的一种。

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

大B -> bit

小b -> byte

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

<ul><li>DES的加密与解密 - 图例</li></ul>

<span class="img-wrap"></span>

<h4>Go中对DES的操作</h4><h5>加解密实现思路</h5><ul><li>

加密 - CBC分组模式

<blockquote><ol><li>

创建并返回一个使用DES算法的cipher.Block接口

<ul><li>秘钥长度为64bit, 即 64/8 = 8字节(byte)</li></ul></li><li>

对最后一个明文分组进行数据填充

<ul><li>DES是以64比特的明文（比特序列）为一个单位来进行加密的</li><li>最后一组不够64bit, 则需要进行数据填充( 参考第三章)</li></ul></li><li>创建一个密码分组为链接模式的, 底层使用DES加密的BlockMode接口</li><li>加密连续的数据块</li></ol></blockquote></li><li>

解密

<blockquote><ol><li>创建并返回一个使用DES算法的cipher.Block接口</li><li>创建一个密码分组为链接模式的, 底层使用DES解密的BlockMode接口</li><li>数据块解密</li><li>去掉最后一组的填充数据</li></ol></blockquote></li></ul><h5>加解密的代码实现</h5>

在Go中使用DES需要导入的包:

<pre><code class="go">import ( "crypto/des" "crypto/cipher" "fmt" "bytes" )</code></pre>

DES加密代码:

<pre><code class="go">// 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 }</code></pre>

DES解密代码

<pre><code class="go">// 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 }</code></pre>

最后一个分组添加填充数据和移除添加数据代码

<pre><code class="go">// 使用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)] }</code></pre>

测试函数

<pre><code class="go">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)) }</code></pre>

重要的函数说明

<ol><li>

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

<pre><code class="go">函数对应的包: import "crypto/des" func NewCipher(key []byte) (cipher.Block, error) - 参数 key: des对称加密使用的密码, 密码长度为64bit, 即8byte</code></pre></li></ol><pre><code> 2. 创建一个密码分组为CBC模式, 底层使用b加密的BlockMode接口对象 </code></pre>

函数对应的包: import "crypto/cipher"
func NewCBCEncrypter(b Block, iv []byte) BlockMode

<pre><code> - 参数 b: 使用des.NewCipher函数创建出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每个分组为64bit, 即8byte - 返回值: 得到的BlockMode接口对象</code></pre><pre><code> 3. 使用cipher包的BlockMode接口对象对数据进行加/解密 </code></pre>

接口对应的包: import "crypto/cipher"
type BlockMode interface {

<pre><code> // 返回加密字节块的大小 BlockSize() int // 加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，src和dst可指向同一内存地址 CryptBlocks(dst, src []byte)</code></pre>

}
接口中的 CryptBlocks(dst, src []byte) 方法:

<pre><code> - 参数 dst: 传出参数, 存储加密或解密运算之后的结果 - 参数 src: 传入参数, 需要进行加密或解密的数据切片(字符串)</code></pre><pre><code> 4. 创建一个密码分组为CBC模式, 底层使用b解密的BlockMode接口对象 </code></pre>

函数对应的包: import "crypto/cipher"
func NewCBCDecrypter(b Block, iv []byte) BlockMode

<pre><code> - 参数 b: 使用des.NewCipher函数创建出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每个分组为64bit, 即8byte, 该序列的值需要和NewCBCEncrypter函数的第二个参数iv值相同 - 返回值: 得到的BlockMode接口对象</code></pre><pre><code> 5. 自定义函数介绍 </code></pre>

对称加密加密需要对数据进行分组, 保证每个分组的数据长度相等, 如果最后一个分组长度不够, 需要进行填充
func PKCS5Padding(ciphertext []byte, blockSize int) []byte

<pre><code> - 参数 ciphertext: 需要加密的原始数据 - 参数 blockSize: 每个分组的长度, 跟使用的加密算法有关系 * des：64bit， 8byte * 3des：64bit， 8byte * aes： 128bit， 16byte</code></pre><pre><code> ### 三重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比特**，因此<font color="red">三重DES的密钥长度就是56×3=168比特, 加上用于错误检测的标志位8x3, 共192bit</font>。 从上图我们可以发现，三重DES并不是进行三次DES加密（加密-->加密-->加密），而是<font color="red">**加密-->解密-->加密**</font>的过程。在加密算法中加人解密操作让人感觉很不可思议，实际上这个方法是IBM公司设计出来的，目的是为了让三重DES能够兼容普通的DES。 <font color="red">当三重DES中所有的密钥都相同时，三重DES也就等同于普通的DES了</font>。这是因为在前两步加密-->解密之后，得到的就是最初的明文。因此，以前用DES加密的密文，就可以通过这种方式用三重DES来进行解密。也就是说，三重DES对DES具备向下兼容性。 如果密钥1和密钥3使用相同的密钥，而密钥2使用不同的密钥（也就是只使用两个DES密钥），这种三重DES就称为DES-EDE2。EDE表示的是加密（Encryption) -->解密（Decryption)-->加密（Encryption）这个流程。 密钥1、密钥2、密钥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加密代码 </code></pre>

// 3DES加密
func TripleDESEncrypt(src, key []byte) []byte {

<pre><code>// 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</code></pre>

}

<pre><code> 3DES解密代码 </code></pre>

// 3DES解密
func TripleDESDecrypt(src, key []byte) []byte {

<pre><code>// 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</code></pre>

}

<pre><code> 重要的函数说明 1. 生成一个底层使用3DES加/解密的Block接口对象 </code></pre>

函数对应的包: import "crypto/des"
func NewTripleDESCipher(key []byte) (cipher.Block, error)

<pre><code> - 参数 key: 3des对称加密使用的密码, 密码长度为(64*3)bit, 即(8*3)byte - 返回值 cipher.Block: 创建出的使用DES加/解密的Block接口对象</code></pre><pre><code> 2. 创建一个密码分组为CBC模式, 底层使用b加密的BlockMode接口对象 </code></pre>

函数对应的包: import "crypto/cipher"
func NewCBCEncrypter(b Block, iv []byte) BlockMode

<pre><code> - 参数 b: 使用des.NewTripleDESCipher 函数创建出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每个分组为64bit, 即8byte - 返回值: 得到的BlockMode接口对象</code></pre><pre><code> 3. 使用cipher包的BlockMode接口对象对数据进行加/解密 </code></pre>

接口对应的包: import "crypto/cipher"
type BlockMode interface {

<pre><code> // 返回加密字节块的大小 BlockSize() int // 加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，src和dst可指向同一内存地址 CryptBlocks(dst, src []byte)</code></pre>

}
接口中的 CryptBlocks(dst, src []byte) 方法:

<pre><code> - 参数 dst: 传出参数, 存储加密或解密运算之后的结果 - 参数 src: 传入参数, 需要进行加密或解密的数据切片(字符串)</code></pre><pre><code> 4. 创建一个密码分组为CBC模式, 底层使用b解密的BlockMode接口对象 </code></pre>

函数对应的包: import "crypto/cipher"
func NewCBCDecrypter(b Block, iv []byte) BlockMode

<pre><code> - 参数 b: 使用des.NewTripleDESCipher 函数创建出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每个分组为64bit, 即8byte, 该序列的值需要和NewCBCEncrypter函数的第二个参数iv值相同 - 返回值: 得到的BlockMode接口对象</code></pre><pre><code> ### AES >AES（Advanced Encryption Standard）是取代其前任标准（DES）而成为新标准的一种对称密码算法。全世界的企业和密码学家提交了多个对称密码算法作为AES的候选，最终在2000年从这些候选算法中选出了一种名为**Rijndael**的对称密码算法，并将其确定为了AES。 **Rijndael的分组长度为128比特**，密钥长度可以以32比特为单位在128比特到256比特的范围内进行选择（不过**在AES的规格中，密钥长度只有128、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加密代码 </code></pre>

// AES加密
func AESEncrypt(src, key []byte) []byte{

<pre><code>// 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</code></pre>

}

<pre><code> AES解密 </code></pre>

// AES解密
func AESDecrypt(src, key []byte) []byte{

<pre><code>// 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</code></pre>

}

<pre><code> 重要的函数说明 1. 生成一个底层使用AES加/解密的Block接口对象 </code></pre>

函数对应的包: import "crypto/aes"
func NewCipher(key []byte) (cipher.Block, error)

<pre><code> - 参数 key: aes对称加密使用的密码, 密码长度为128bit, 即16byte - 返回值 cipher.Block: 创建出的使用AES加/解密的Block接口对象</code></pre><pre><code> 2. 创建一个密码分组为CBC模式, 底层使用b加密的BlockMode接口对象 </code></pre>

函数对应的包: import "crypto/cipher"
func NewCBCEncrypter(b Block, iv []byte) BlockMode

<pre><code> - 参数 b: 使用aes.NewCipher函数创建出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每个分组为64bit, 即8byte - 返回值: 得到的BlockMode接口对象</code></pre><pre><code> 3. 使用cipher包的BlockMode接口对象对数据进行加/解密 </code></pre>

接口对应的包: import "crypto/cipher"
type BlockMode interface {

<pre><code> // 返回加密字节块的大小 BlockSize() int // 加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，src和dst可指向同一内存地址 CryptBlocks(dst, src []byte)</code></pre>

}
接口中的 CryptBlocks(dst, src []byte) 方法:

<pre><code> - 参数 dst: 传出参数, 存储加密或解密运算之后的结果 - 参数 src: 传入参数, 需要进行加密或解密的数据切片(字符串)</code></pre><pre><code> 4. 创建一个密码分组为CBC模式, 底层使用b解密的BlockMode接口对象 </code></pre>

函数对应的包: import "crypto/cipher"
func NewCBCDecrypter(b Block, iv []byte) BlockMode

<pre><code> - 参数 b: 使用des.NewCipher函数创建出的Block接口对象 - 参数 iv: 事先准备好的一个长度为一个分组长度的比特序列, 每个分组为128bit, 即16byte, 该序列的值需要和NewCBCEncrypter函数的第二个参数iv值相同 - 返回值: 得到的BlockMode接口对象</code></pre><pre><code> ### 应选择哪种对称加密 > 前面介绍了DES、三重DES和AES等对称密码，那么我们到底应该使用哪一种对称密码算法呢？ > > 1. **今后最好不要将DES用于新的用途，因为随着计算机技术的进步，现在用暴力破解法已经能够在现实的时间内完成对DES的破译。但是，在某些情况下也需要保持与旧版本软件的兼容性。** > 2. **出于兼容性的因素三重DES在今后还会使用一段时间，但会逐渐被AES所取代。** > 3. **今后大家应该使用的算法是AES（Rijndael），因为它安全、快速，而且能够在各种平台上工作。此外，由于全世界的密码学家都在对AES进行不断的验证，因此即便万一发现它有什么缺陷，也会立刻告知全世界并修复这些缺陷。** > 一般来说，我们不应该使用任何自制的密码算法，而是应该使用AES。因为AES在其选定过程中，经过了全世界密码学家所进行的高品质的验证工作，而对于自制的密码算法则很难进行这样的验证。 欢迎与我交流</code></pre> 到此这篇关于“密码学之对称加密”的文章就介绍到这了,更多文章或继续浏览下面的相关文章，希望大家以后多多支持JQ教程网！

您可能感兴趣的文章：
密码学之对称加密
PHP 数据加密的方法
有关discuz程序中PHP加密函数的原理分析
PHP中的加密功能
PHP加密扩展库Mcrypt的例子
C#做的一个加密/解密的类
Javascript 到 PHP 加密通讯的简单实现
flask框架下密码的加盐加密和解密
关于Https原理的个人理解分享
php mcrypt启用、加密以及解密的方法介绍