密码学奇妙之旅、02 混合加密系统、AES、RSA标准、Golang代码

CTR 计数器模式

计数器模式CTR是分组密码模式中的一种。通过将逐次累加的计数器进行加密来生成密钥流的流密码。每次加密时会生成一个不同的值来作为计数器的初始值。

• 可以事先进行加密、解密的准备。
• 加密、解密使用相同结构。
• 对包含某些错误比特的密文进行解密时，只有明文中响应的比特会出错。
• 加密和解密均支持并行运算。可以以任意顺序对分组进行加密和解密。

在CTR模式基础上添加认证功能的模式称为GCM模式。生成密文的同时生成用于认证的信息。用于识别主动攻击者发送的伪造的密文。

混合密码系统

混合密码系统能够解决对称密码密钥分配的问题和公钥密码速度慢的问题。使用快速的对称密码来对消息进行加密，再使用公钥密码对对称密码的密钥进行加密，由于对称密码的密钥一般比消息本身要短，因此可以忽略公钥密码速度慢的问题。

会话密钥是对称密码的密钥，同时也是公钥密码的明文。

一个问题

由于会话密钥已经通过公钥密码进行加密，因此会话密钥的长度较短也没有问题。

错！当会话密钥长度较短，当攻击者已知加密方式、分组密码模式的情况下可以通过 brute-force 暴力破解组合消息的后半段部分。增加风险。

RSA-OAEP 最优非对称加密填充

RSA-OAEP 是RSA的改良算法，在加密时会在明文前面填充一些认证信息，包括明文散列值以及一定数量的0。

RSA-OEAP 最大的优点是认证信息。好处是可以防御选择密文攻击（攻击者将任意密文发送给服务器，服务器发送解密提示），服务器可以固定返回错误消息decryption error，而不是将具体的错误内容告知攻击者。

ciphertext, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, &key, []byte(secretMessage), label)

sha256是我们选择的单向散列函数。至于为什么需要rand.Reader，这是OAEP算法需要的，通过随机数使得每次生成的密文呈现不同的排列方式，进一步提高安全性。key 是接收人的公钥。[]byte(secretMessage)是加密信息的字节表现形式。label用于给公钥添加标签，不会被加密。

如果公钥标签不同，假设我们修改下文的RSA_OAEP_Encrypt 、RSA_OAEP_Decrypt 函数中的 label := []byte("标签")。那么当两个函数各自label不同时，会发生如下错误。根据官方文档，如果给定的公钥用于加密两种类型的消息，则可以使用不同的标签值来确保攻击者不能将用于一种目的的密文用于另一种目的。如果不需要，它可以是空的。

crypto/rsa: decryption error
panic: crypto/rsa: decryption error

goroutine 1 [running]:
main.CheckError({0x10092e0, 0xc0000603d0})
        C:/Users/小能喵喵喵/Desktop/Go/Cryptography/对称加密/HybridCryptoSystem/rsa_crypto.go:14 +0x9d
main.RSA_OAEP_Decrypt(0xc00031a4e0?, {0xc00031a4e0?, 0xfe8637?})
        C:/Users/小能喵喵喵/Desktop/Go/Cryptography/对称加密/HybridCryptoSystem/rsa_crypto.go:37 +0x134
main.hybridDecrypt(0x1009360?, {0xc000316fc0?, 0xfe2c44?})
        C:/Users/小能喵喵喵/Desktop/Go/Cryptography/对称加密/HybridCryptoSystem/main.go:56 +0xbd
main.main()
        C:/Users/小能喵喵喵/Desktop/Go/Cryptography/对称加密/HybridCryptoSystem/main.go:35 +0x2dc
exit status 2

任何拥有密文签名、密文消息和公钥的人都可以使用 RSA 验证来确保消息确实来自颁发公钥的一方。如果数据或签名不匹配，则验证过程失败。只有拥有私钥的一方才能签署消息，但拥有公钥的任何人都可以验证它。

msg := []byte("verifiable message")

//在签名之前,我们需要对我们的消息进行哈希处理
msgHash := sha256.New()
_, err = msgHash.Write(msg)
if err != nil {
	panic(err)
}
msgHashSum := msgHash.Sum(nil)

//为了生成签名,我们提供了一个随机数生成器,我们的私钥,我们使用的散列算法和消息的散列信息
signature, err := rsa.SignPSS(rand.Reader, privateKey, crypto.SHA256, msgHashSum, nil)
if err != nil {
	panic(err)
}

//为了验证签名,我们提供了公钥,散列算法,我们消息的哈希和和我们之前生成的签名
//有一个可选的"选项"参数,现在可以省略
err = rsa.VerifyPSS(&publicKey, crypto.SHA256, msgHashSum, signature, nil)
if err != nil {
	fmt.Println("could not verify signature: ", err)
	return
}
//如果我们没有从 `VerifyPSS` 方法中得到任何错误,这意味着我们的签名有效
fmt.Println("signature verified")

代码

aes_crypto.go

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"errors"
	"io"
)

// ^ 生成会话密钥
func AES_Key_Generator() []byte {
	var key []byte = make([]byte, 32)
	_, err := io.ReadFull(rand.Reader, key)
	CheckError(err)
	return key
}

func AES_Encrypt(key []byte, message string) (encoded string, err error) {
	//从输入字符串创建字节切片
	plainText := []byte(message)

	//使用密钥创建新的 AES 密码
	block, err := aes.NewCipher(key)

	//如果 NewCipher 失败，退出：
	CheckError(err)

	// ^ 使密文成为大小为 BlockSize + 消息长度的字节切片,这样传值后修改不会更改底层数组
	cipherText := make([]byte, aes.BlockSize+len(plainText))

	// ^ iv 是初始化向量 (16字节)
	iv := cipherText[:aes.BlockSize]
	if _, err = io.ReadFull(rand.Reader, iv); err != nil {
		return
	}

	// ^ 加密数据,给定加密算法用的密钥,以及初始化向量
	stream := cipher.NewCTR(block, iv)
	stream.XORKeyStream(cipherText[aes.BlockSize:], plainText)

	return base64.RawStdEncoding.EncodeToString(cipherText), err
}

func AES_Decrypt(key []byte, secure string) (decoded string, err error) {
	//删除 base64 编码：
	cipherText, err := base64.RawStdEncoding.DecodeString(secure)

	//如果解码字符串失败，退出：
	CheckError(err)

	//使用密钥和加密消息创建新的 AES 密码
	block, err := aes.NewCipher(key)

	//如果 NewCipher 失败，退出：
	CheckError(err)

	//如果密文的长度小于 16 字节
	if len(cipherText) < aes.BlockSize {
		err = errors.New("密文分组长度太小")
		return
	}

	// ^ iv 是初始化向量 (16字节)
	iv := cipherText[:aes.BlockSize]
	cipherText = cipherText[aes.BlockSize:]

	//解密消息
	stream := cipher.NewCTR(block, iv)
	stream.XORKeyStream(cipherText, cipherText)

	return string(cipherText), err
}

rsa_crypto.go

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"encoding/base64"
	"fmt"
)

func CheckError(e error) {
	if e != nil {
		fmt.Println(e.Error())
		panic(e)
	}
}

// ^ 生成密钥与公钥
func RSA_Generator() (*rsa.PrivateKey, rsa.PublicKey) {
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	CheckError(err)
	return privateKey, privateKey.PublicKey
}

func RSA_OAEP_Encrypt(key rsa.PublicKey, secretMessage string) string {
	label := []byte("标签")
	ciphertext, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, &key, []byte(secretMessage), label)
	CheckError(err)
	return base64.RawStdEncoding.EncodeToString(ciphertext)
}

func RSA_OAEP_Decrypt(privKey *rsa.PrivateKey, cipherText string) string {
	ct, _ := base64.RawStdEncoding.DecodeString(cipherText)
	label := []byte("标签")
	// ^ 解密过程中的 rand.Reader 不是必选的,但一般要提供用来防止 side channel attacks.
	plaintext, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, privKey, ct, label)
	CheckError(err)
	return string(plaintext)
}

main.go

package main

import (
	"bufio"
	"crypto/rsa"
	"encoding/base64"
	"fmt"
	"os"
	"strings"
)

func main() {
	privateKey, publicKey := RSA_Generator()
	fmt.Printf("\n\t共同N: %v\n\t公钥E: %v\n\t私钥D: %v\n", publicKey.N, publicKey.E, privateKey.D)

	reader := bufio.NewReader(os.Stdin)

	var message string

	// 如果没有给运行附加参数
	if len(os.Args) != 2 {
		fmt.Printf("\n\t获取不到程序运行附加参数,手动输入字符串\n")
		fmt.Printf("\t字符串:")
		message, _ = reader.ReadString('\n')
	} else {
		message = os.Args[1]
	}

	encrypted := hybridEncrypt(publicKey, message)

	//打印密钥和密文
	fmt.Printf("\n\t加密后: %s\n", encrypted)

	//解密文本
	decrypted := hybridDecrypt(privateKey, encrypted)

	//打印重新解密的文本：
	fmt.Printf("\t解密后: %s\n\n", decrypted)
}

// ^ 实现混合密码系统加密
func hybridEncrypt(publicKey rsa.PublicKey, message string) string {
	AES_key := AES_Key_Generator()
	encrypted, err := AES_Encrypt(AES_key, message)
	CheckError(err)
	head := RSA_OAEP_Encrypt(publicKey, string(AES_key))
	return base64.RawStdEncoding.EncodeToString([]byte(head + "|组合加密的会话密钥与消息|" + encrypted))
}

// ^ 实现混合密码系统解密
func hybridDecrypt(privateKey *rsa.PrivateKey, message string) string {
	mes, err := base64.RawStdEncoding.DecodeString(message)
	CheckError(err)
	splits := strings.Split(string(mes), "|组合加密的会话密钥与消息|")
	head, encrypted := splits[0], splits[1]
	AES_key := RSA_OAEP_Decrypt(privateKey, head)
	decrypted, err := AES_Decrypt([]byte(AES_key), encrypted)
	CheckError(err)
	return decrypted
}

Console

PS C:\Users\小能喵喵喵\Desktop\Go\Cryptography\HybridCryptoSystem> go run .

        共同N: 27640386706278435101453826167880213380728173376705028554783165783279386289425385951480103560680095783771843646857109485131423632909299132644495753077858557656973966723671714379227388216997874772747942697857840884958167490215992557618790374058240600396830575755231210656224988403861978602412271792545641212145711389619141451899401914724049344335805426393895927923656887621076309994751218768872654198553908831397491866304367960002592041669717397769735292092598621160683203319490180735669006214925366299990837670410127282438512376259066563653513041612145434668849944713663380228178995120226612134278958851534636750809001
        公钥E: 65537
        私钥D: 21389172708682283842260567223157071907527493061928308026852438358469476412838678128832773121746357899720601348098910654110504746067032447503938265671965405062383611126402047618025191776020373515722598134212130559541228073703466172690799911811094069748771879235035946845758125744264465032292267939621163527075589206186236252262969497020056020747918051369037068208691174340727908489331589607362106509257993751131469180199656580210783551516628845816453711183613127441188183231286809500171237776949663326262795200507964067032050374872022735029012264732773085633122224061096049966893027129668814251907555802752863797705473

        获取不到程序运行附加参数,手动输入字符串
        字符串:系统对于不同输入，反馈时间动态变化，利用这个特性获取机密信息的方法称之为时序攻击。

        加密后: ei9MamphdU9KQkVCUS9kYlBVSzNFaXN3UUVaamo2R3loMTRGaXNlamJVd1hFd3dOM0FDMUZYYkIrQlJ6M1pTaG5xeE9admNsNVgyY3dEMG4zVEM2NXA1S1M2a29ha3ZlL2JZV2ZlNlcxSUYyRC92TDZiY3ZSVldZdnJSUEJKc2VtVnV5WE9sdWcyWWlKZ2o2dW85R25IQTYyMS9abUlpM1BrNEhCYUlxT1BYQWp3TGxsSzFqZi9KSUZxSytPZ1NHeUVsMExIMm0vTmxkU1NRV093U1RTK3BVQmtJcXBGMENmbE9RSVRUTUgvREsyUFV3OGRtbjkxWnFYVFN3SnQ2ZjVkTUE4cWd6MUNjaVhaUFRGVVhaU1JVWUFTWWFXZGFHRW9yZndZcnQ0bWg0MTBqV1ZQODl6NnZGNHQyRGlrYi9JNFdlalJvdTB2QU9HWmViSWl0Q1lBfOe7hOWQiOWKoOWvhueahOS8muivneWvhumSpeS4jua2iOaBr3xXeGl3YXRwZWRBT2JWRFRxdm9EQVFMK2pyMkVGU1JGWmRIV0pxSGdMVExRcE0vdmxOcjF1ZEFKMDAzSlVESU4wNkdIbCt4cm1IakhLZHdPL204N1I3VE5YM1Q2cE1FdjV6L3VjMVRwck1yQVN6cEFhc0JEUjJwTGJJVEVocXVEeUIvLzRWZDYzYXVqR2xVY0NDNkk3SlRTQVc1bDBTNExlMHdJbytJaU1kSEt3b2l1TTd1UGlGVEUvYzN0Zw
        解密后: 系统对于不同输入，反馈时间动态变化，利用这个特性获取机密信息的方法称之为时序攻击。

参考资料

rsa package - crypto/rsa - Go Packages

Implementing RSA Encryption and Signing in Golang (With Examples) (sohamkamani.com)