在 Go 中解密在 Python 中以 CFB 模式使用 AES 加密的内容

golang学习网今天将给大家带来《在 Go 中解密在 Python 中以 CFB 模式使用 AES 加密的内容》，感兴趣的朋友请继续看下去吧！以下内容将会涉及到等等知识点，如果你是正在学习Golang或者已经是大佬级别了，都非常欢迎也希望大家都能给我建议评论哈~希望能帮助到大家！

问题

我希望能够在 go 中解密在 python 中加密的内容。加密/解密函数分别在每种语言中工作，但当我在 python 中加密并在 go 中解密时却不起作用，我猜测编码有问题，因为我得到了乱码输出：

rx����d��i�k|�ap���k��b%f���uv�~d3h�����|�����>�b��b�

python 中的加密/解密

def encrypt(plaintext, key=config.secret, key_salt='', no_iv=false):
    """encrypt shit the right way"""

    # sanitize inputs
    key = sha256.new((key + key_salt).encode()).digest()
    if len(key) not in aes.key_size:
        raise exception()
    if isinstance(plaintext, string_types):
        plaintext = plaintext.encode('utf-8')

    # pad plaintext using pkcs7 padding scheme
    padlen = aes.block_size - len(plaintext) % aes.block_size
    plaintext += (chr(padlen) * padlen).encode('utf-8')

    # generate random initialization vector using csprng
    if no_iv:
        iv = ('\0' * aes.block_size).encode()
    else:
        iv = get_random_bytes(aes.block_size)
    log.info(aes.block_size)
    # encrypt using aes in cfb mode
    ciphertext = aes.new(key, aes.mode_cfb, iv).encrypt(plaintext)

    # prepend iv to ciphertext
    if not no_iv:
        ciphertext = iv + ciphertext
    # return ciphertext in hex encoding
    log.info(ciphertext)
    return ciphertext.hex()


def decrypt(ciphertext, key=config.secret, key_salt='', no_iv=false):
    """decrypt shit the right way"""

    # sanitize inputs
    key = sha256.new((key + key_salt).encode()).digest()
    if len(key) not in aes.key_size:
        raise exception()
    if len(ciphertext) % aes.block_size:
        raise exception()
    try:
        ciphertext = codecs.decode(ciphertext, 'hex')
    except typeerror:
        log.warning("ciphertext wasn't given as a hexadecimal string.")

    # split initialization vector and ciphertext
    if no_iv:
        iv = '\0' * aes.block_size
    else:
        iv = ciphertext[:aes.block_size]
        ciphertext = ciphertext[aes.block_size:]

    # decrypt ciphertext using aes in cfb mode
    plaintext = aes.new(key, aes.mode_cfb, iv).decrypt(ciphertext).decode()

    # validate padding using pkcs7 padding scheme
    padlen = ord(plaintext[-1])
    if padlen < 1 or padlen > aes.block_size:
        raise exception()
    if plaintext[-padlen:] != chr(padlen) * padlen:
        raise exception()
    plaintext = plaintext[:-padlen]

    return plaintext

go 中的加密/解密

// PKCS5Padding adds padding to the plaintext to make it a multiple of the block size
func PKCS5Padding(src []byte, blockSize int) []byte {
    padding := blockSize - len(src)%blockSize
    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(src, padtext...)
}

// Encrypt encrypts the plaintext,the input salt should be a random string that is appended to the plaintext
// that gets fed into the one-way function that hashes it.
func Encrypt(plaintext) string {
    h := sha256.New()
    h.Write([]byte(os.Getenv("SECRET")))
    key := h.Sum(nil)
    plaintextBytes := PKCS5Padding([]byte(plaintext), aes.BlockSize)
    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }
    // The IV needs to be unique, but not secure. Therefore it's common to
    // include it at the beginning of the ciphertext.
    ciphertext := make([]byte, aes.BlockSize+len(plaintextBytes))
    iv := ciphertext[:aes.BlockSize]
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        panic(err)
    }
    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintextBytes)
    // return hexadecimal representation of the ciphertext
    return hex.EncodeToString(ciphertext)
}
func PKCS5UnPadding(src []byte) []byte {
    length := len(src)
    unpadding := int(src[length-1])
    return src[:(length - unpadding)]
}
func Decrypt(ciphertext string) string {

    h := sha256.New()
    // have to check if the secret is hex encoded
    h.Write([]byte(os.Getenv("SECRET")))
    key := h.Sum(nil)
    ciphertext_bytes := []byte(ciphertext)
    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }
    log.Print(aes.BlockSize)
    // The IV needs to be unique, but not secure. Therefore it's common to
    // include it at the beginning of the ciphertext.
    iv := ciphertext_bytes[:aes.BlockSize]
    if len(ciphertext) < aes.BlockSize {
        panic("ciphertext too short")
    }
    ciphertext_bytes = ciphertext_bytes[aes.BlockSize:]
    stream := cipher.NewCFBDecrypter(block, iv)
    stream.XORKeyStream(ciphertext_bytes, ciphertext_bytes)
    plaintext := PKCS5UnPadding(ciphertext_bytes)
    return string(plaintext)
}

正确答案

cfb 模式使用的段大小对应于每个加密步骤加密的位数，请参阅 CFB。

go 只支持 128 位的段大小 (cfb128)，至少没有更深入的修改（第 here 和 here）。相比之下，pycryptodome 中的段大小是可配置的，默认为 8 位 (cfb8)，s。 here。发布的python代码使用这个默认值，因此两个代码不兼容。由于go代码中段大小不可调整，因此必须在python代码中设置为cfb128：

cipher = aes.new(key, aes.mode_cfb, iv, segment_size=128) 

此外，密文在 python 代码中是十六进制编码的，因此必须在 go 代码中对其进行十六进制解码，而这在发布的代码中尚未实现。

通过这两项更改，可以解密使用 python 代码生成的密文。

以下 go 代码中的密文是使用 python 代码使用 128 位大小的段和密码 my 密码 创建的，并成功解密：

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func main() {
    ciphertextHex := "546ddf226c4c556c7faa386940f4fff9b09f7e3a2ccce2ed26f7424cf9c8cd743e826bc8a2854bb574df9f86a94e7b2b1e63886953a6a3eb69eaa5fa03d69ba5" // Fix 1: Apply CFB128 on the Python side
    fmt.Println(Decrypt(ciphertextHex))                                                                                                                 // The quick brown fox jumps over the lazy dog
}

func PKCS5UnPadding(src []byte) []byte {
    length := len(src)
    unpadding := int(src[length-1])
    return src[:(length - unpadding)]
}
func Decrypt(ciphertext string) string {
    h := sha256.New()
    //h.Write([]byte(os.Getenv("SECRET")))
    h.Write([]byte("my passphrase")) // Apply passphrase from Python side
    key := h.Sum(nil)
    //ciphertext_bytes := []byte(ciphertext)
    ciphertext_bytes, _ := hex.DecodeString(ciphertext) // Fix 2. Hex decode ciphertext
    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }
    iv := ciphertext_bytes[:aes.BlockSize]
    if len(ciphertext) < aes.BlockSize {
        panic("ciphertext too short")
    }
    ciphertext_bytes = ciphertext_bytes[aes.BlockSize:]
    stream := cipher.NewCFBDecrypter(block, iv)
    stream.XORKeyStream(ciphertext_bytes, ciphertext_bytes)
    plaintext := PKCS5UnPadding(ciphertext_bytes)
    return string(plaintext)
}

安全性：

• 使用摘要作为密钥派生函数是不安全的。应用专用密钥派生函数，例如 pbkdf2。
• 静态或缺失的盐也是不安全的。对每个加密使用随机生成的盐。将非秘密盐与密文连接起来（类似于 iv），例如salt|iv|密文。
• 变体 no_iv=true 应用静态 iv（零 iv），这是不安全的，不应使用。正确的方法通过变体 no_iv=false 进行描述。
• cfb 是一种流密码模式，因此不需要填充/取消填充，因此可以在两侧删除。

以上就是《在 Go 中解密在 Python 中以 CFB 模式使用 AES 加密的内容》的详细内容，更多关于的资料请关注golang学习网公众号！