常用加密算法--对称加密算法

1、DES(Data Encryption Standard）

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

• 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比特。

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

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

• DES的加密与解密 - 图例

代码示例

package main

import (
	"bytes"
	"crypto/cipher"
	"crypto/des"
	"errors"
	"fmt"
)

//加密
func desCbcEncrypt(key, plinText []byte) ([]byte, error) {
	fmt.Printf("开始加密明文：%s\n", plinText)

	block, err := des.NewCipher(key)
	if err != nil {
		fmt.Println("NewCipher err:", err)
		return nil, err
	}
	iv := bytes.Repeat([]byte("1"), block.BlockSize())
	//加密之前调用填充函数
	plinText, err = paddingNumber(plinText, block.BlockSize())
	if err != nil {
		fmt.Println("paddingNumber err  :", err)
		return nil, err
	}
	blockMode := cipher.NewCBCEncrypter(block, iv)
	fmt.Println("iv:", iv)
	fmt.Println("block.Size", block.BlockSize())
	buf := make([]byte, len(plinText))
	blockMode.CryptBlocks(buf, plinText)
	return buf, nil
}

//解密
func desCbcDecrypt(key, ciphertext []byte) ([]byte, error) {

	fmt.Printf("开始解密 密文：%s\n", ciphertext)
	block, err := des.NewCipher(key)
	if err != nil {
		fmt.Println("NewCipher err:", err)
		return nil, err
	}
	vi := bytes.Repeat([]byte("1"), block.BlockSize())

	fmt.Println("vi:", vi)
	fmt.Println("block.Size", block.BlockSize())
	blockMode := cipher.NewCBCDecrypter(block, vi)

	buf := make([]byte, len(ciphertext))
	blockMode.CryptBlocks(buf, ciphertext)
	//解密后调用去填充函数
	buf = unPaddingNumber(buf)
	return buf, nil
}

//填充
func paddingNumber(src []byte, blockSize int) ([]byte, error) {
	fmt.Println("paddingNumber called!!")
	if src == nil {
		return nil, errors.New("数据为空")
	}
	p := len(src) % blockSize
	lastData := blockSize - p
	newSlice := bytes.Repeat([]byte{byte(lastData)}, lastData)
	src = append(src, newSlice...)
	return src, nil

}

//去填充
func unPaddingNumber(src []byte) []byte {
	fmt.Println("unPaddingNumber called!")
	//1. 获取最后一个字符
	lastByte := src[len(src)-1]
	num := int(lastByte)
	// 2. 截取原文
	return src[0 : len(src)-num]
}
func main() {
	key := []byte("12345678")
	plainText := []byte("对称加密算法DES！")//由于使用的CBC密文分组连接模式，需要填充
	ciphertext, err := desCbcEncrypt(key, plainText)
	if err != nil {
		fmt.Println("desCbcEncrypt err :", err)
		return
	}
	fmt.Printf("加密后数据为%s\n", ciphertext)
	plainText, err = desCbcDecrypt(key, ciphertext)
	if err != nil {
		fmt.Println("desCbcDecrypt err :", err)
		return
	}
	fmt.Printf("解密后数据为%s\n", plainText)
}

运行结果

2、三重DES

三重DES（triple-DES)是为了增加DES的强度，== 将DES重复三次所得到的一种密码算法==，通常缩写3DES

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

• 明文经过三次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目前还被银行等机构使用，但其处理速度不高，而且在安全性方面也逐渐显现出了一些问题。

AES（Advanced Encryption Standard）

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

• Rijndael是由比利时密码学家Joan Daemen和Vincent Rijmen设汁的分组密码算法，今后会有越来越多的密码软件支持这种算法。

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

  AES加密和解密图示

加密

解密

代码示例

package main

import (
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"fmt"
)
//加密
func aesCtrEncrypt(key []byte, plainText []byte) ([]byte, error) {
	fmt.Println("开始加密,明文:", string(plainText))
	//创建密码接口
	block, err := aes.NewCipher(key)
	if err != nil {
		fmt.Println("NewCipher err:", err)
		return nil, err
	}
	 iv:= bytes.Repeat([]byte("1"), block.BlockSize())
	fmt.Println("vi:",iv)
	fmt.Println("block.Size", block.BlockSize())
	s := cipher.NewCTR(block, iv)
	dst := make([]byte, len(plainText))
	s.XORKeyStream(dst, plainText)
	return dst, nil

}
//解密
func aesCtrDecrypt(key, cipherText []byte) ([]byte, error) {
	fmt.Println("开始解密,密文:", string(cipherText))
	return aesCtrEncrypt(key, cipherText)

}

func main() {
	key := []byte("1234567890123456")
	plainText := []byte("对称加密算法AES")
	cipherData, err := aesCtrEncrypt(key, plainText)
	if err != nil {
		fmt.Println("加密失败")
		return
	}
	fmt.Printf("加密后的数据为, hex :%x\n", cipherData)
	fmt.Printf("加密后的数据为, string :%s\n", cipherData)
	plainText, err = aesCtrDecrypt(key, cipherData)
	if err != nil {
		fmt.Println("解密失败")
		return
	}
	fmt.Printf("解密后的数据为:%s\n", plainText)
}

运行结果

4、应该选择哪种对称加密

• 最好不要将DES用于新的用途，因为随着计算机技术的进步，现在用暴力破解法已经能够在现实的时间内完成对DES的破译。但是，在某些情况下也需要保持与旧版本软件的兼容性。

• 出于兼容性的因素三重DES在今后还会使用一段时间，但会逐渐被AES所取代。

• 应该使用的算法是AES（Rijndael），因为它安全、快速，而且能够在各种平台上工作。此外，由于全世界的密码学家都在对AES进行不断的验证，因此即便万一发现它有什么缺陷，也会立刻告知全世界并修复这些缺陷。