Golang AES解密机制只给出另一个密文作为输出

“纵有疾风来，人生不言弃”，这句话送给正在学习Golang的朋友们，也希望在阅读本文《Golang AES解密机制只给出另一个密文作为输出》后，能够真的帮助到大家。我也会在后续的文章中，陆续更新Golang相关的技术文章，有好的建议欢迎大家在评论留言，非常感谢！

我正在尝试在我的 go 应用程序中使用以下解密方法（通过互联网找到）。我拥有的 cipherkey 不是简单的 32 位密钥，但它看起来是 base64 编码的。因此，我先解码然后应用。在整个解密过程中我没有收到任何错误，但是此解密方法的输出看起来是另一个密文。

不确定我是否遗漏了 cipherkey 方面的内容。

func decrypt(key []byte, secure string) (decoded string, err error) {
    //remove base64 encoding:
    ciphertext, err := base64.stdencoding.decodestring(secure)

    //if decodestring failed, exit:
    if err != nil {
        return
    }

    //create a new aes cipher with the key and encrypted message
    block, err := aes.newcipher(key)

    //if newcipher failed, exit:
    if err != nil {
        return
    }

    //if the length of the ciphertext is less than 16 bytes:
    if len(ciphertext) < aes.blocksize {
        err = errors.new("ciphertext block size is too short")
        return
    }

    iv := ciphertext[:aes.blocksize]
    ciphertext = ciphertext[aes.blocksize:]
    fmt.println("before deciphering: ", string(ciphertext))

    //decrypt the message
    stream := cipher.newcfbdecrypter(block, iv)
    stream.xorkeystream(ciphertext, ciphertext)

    return string(ciphertext), err
}

更新原始问题...

我必须解密 go 应用程序中的数据。数据又来自 java 应用程序。以下是相同的片段，

public static final string key_algorithm = "aes";
public static final string aes_algorithm = "aes/cfb8/nopadding";
public static final string digest_algorithm = "md5";
public static final byte[] initial_vector = { -25, 9, -119, 91, -90, 112, 98, -40, 65, -106, -1, 96, 118, -13, 88,
                85 };

package com.crypto;

import static com.cryptoconstant.aes_algorithm;
import static com.cryptoconstant.digest_algorithm;
import static com.cryptoconstant.initial_vector;
import static com.cryptoconstant.key_algorithm;

import java.math.biginteger;
import java.nio.charset.standardcharsets;
import java.security.invalidalgorithmparameterexception;
import java.security.invalidkeyexception;
import java.security.messagedigest;
import java.security.nosuchalgorithmexception;
import java.util.base64;

import javax.crypto.badpaddingexception;
import javax.crypto.cipher;
import javax.crypto.illegalblocksizeexception;
import javax.crypto.nosuchpaddingexception;
import javax.crypto.spec.ivparameterspec;
import javax.crypto.spec.secretkeyspec;

import org.springframework.beans.factory.annotation.value;
import org.springframework.stereotype.component;

import lombok.extern.slf4j.slf4j;


@slf4j
@component
public class messagecrypto {

    /**
     * 
     */
    @value("${design.secret.key}")
    private string designsecretkey;

    /**
     * md 5
     *
     * @param input the input
     * @return the string
     * @throws nosuchalgorithmexception the no such algorithm exception
     */
    private static string md5(final string input) throws nosuchalgorithmexception {
        final messagedigest md = messagedigest.getinstance(digest_algorithm);
        final byte[] messagedigest = md.digest(input.getbytes());
        // convert byte array to a string of hex digits
        final biginteger number = new biginteger(1, messagedigest);
        // the 0 in the mask does the padding, 32 chars and x indicates lower hex
        // digits.
        return string.format("%032x", number);
    }

    /**
     * inits the cipher
     *
     * @param mode the mode
     * @return the cipher
     * @throws nosuchalgorithmexception           the no such algorithm exception
     * @throws nosuchpaddingexception             the no such padding exception
     * @throws invalidkeyexception                the invalid key exception
     * @throws invalidalgorithmparameterexception the invalid algorithm parameter
     *                                            exception
     */
    private cipher initcipher(final int mode) throws nosuchalgorithmexception, nosuchpaddingexception,
            invalidkeyexception, invalidalgorithmparameterexception {

        final secretkeyspec skeyspec = new secretkeyspec(md5(designsecretkey).getbytes(), key_algorithm);
        final ivparameterspec initialvector = new ivparameterspec(initial_vector);
        final cipher cipher = cipher.getinstance(aes_algorithm);
        cipher.init(mode, skeyspec, initialvector);
        return cipher;
    }

    /**
     * encrypt
     * 
     * @param datatoencrypt the data to encrypt
     * @return the string
     */
    public string encrypt(final string datatoencrypt) {
        log.info("processing encrypt...");
        byte[] encrypteddata = {};

        try {

            // initialize the cipher
            final cipher cipher = initcipher(cipher.encrypt_mode);
            // encrypt the data
            final byte[] encryptedbytearray = cipher.dofinal(datatoencrypt.getbytes());
            // encode using base64
            encrypteddata = base64.getencoder().encode(encryptedbytearray);

        } catch (illegalblocksizeexception | badpaddingexception | nosuchalgorithmexception | nosuchpaddingexception
                | invalidalgorithmparameterexception | invalidkeyexception e) {
            log.error("encryption error: {} ", e);
        }
        log.info("processed encrypt...");
        return new string(encrypteddata);
    }

    /**
     * decrypt
     *
     * @param encrypteddata the encrypted data
     * @return the string
     */
    public string decrypt(final string encrypteddata) {
        log.info("processing decrypt...");
        string decrypteddata = "";

        try {

            // initialize the cipher
            final cipher cipher = initcipher(cipher.decrypt_mode);
            // decode using base64
            final byte[] encryptedbytearray = base64.getdecoder().decode(encrypteddata.getbytes());
            // decrypt the data
            final byte[] decryptedbytearray = cipher.dofinal(encryptedbytearray);

            decrypteddata = new string(decryptedbytearray, standardcharsets.utf_8);

        } catch (illegalblocksizeexception | badpaddingexception | nosuchalgorithmexception | nosuchpaddingexception
                | invalidalgorithmparameterexception | invalidkeyexception e) {
            log.error("decryption error: {} ", e);
        }
        log.info("processed decrypt...");
        return decrypteddata;
    }

}

我已经从他们那里收到了密钥和密文。现在我需要在 go 中实现与此 java 等效的东西。我正在尝试使用 cfb 加密/解密机制，这似乎很容易实现。但是，我正在尝试弄清楚如何从提供的密钥中检索实际的密钥。从 java 代码来看，我需要有一些与 md5() 方法在 java 中执行的操作等效的操作。

这是我尝试过的东西，

key := "94k/IwqJQ5wf4Yt5JZmbW85r2x246rI3g3LZbTI80Vo="
key_decr := md5.Sum([]byte(key))
key = hex.EncodeToString(key_decr[:])
log.Println("key:", key)
decrypt(key, secureText)

但是，这不起作用。

正确答案

这两个代码有两点不同：

• java 代码使用 cfb8，go 代码使用 cfb128。
• java 代码在加密过程中不会执行 iv 和密文的串联，但 go 代码会假设这种串联，因此在解密过程中将 iv 和密文分开。

为了使两种代码兼容，必须消除这些差异。由于java代码似乎是参考，因此go代码中需要进行以下更改：

• 将删除加密数据到 iv 和密文的分离。因此，数据必须至少为 16 字节大的约束以及其检查也被省略。将使用 java 代码中的静态 iv（java 代码的负二进制补码整数通过添加 256 转换为无符号整数）：

  iv := []byte{231, 9, 137, 91, 166, 112, 98, 216, 65, 150, 255, 96, 118, 243, 88, 85}
  

• 在 go 代码中将使用 cfb8。 crypto/cipher 包实现了具有固定段大小的 cfb128，因此无法使用。 cfb8 实现的可能替代方案是 github.com/tnze/gomcbot/cfb8 ：

  stream := cfb8.newcfb8decrypt(block, iv)
  

总体（为了简单起见，没有异常处理）：

import (
    "crypto/aes"
    "crypto/md5"
    "encoding/base64"
    "encoding/hex"
    "log"
    "github.com/Tnze/gomcbot/CFB8"
)

func main() {
    key := "94k/IwqJQ5wf4Yt5JZmbW85r2x246rI3g3LZbTI80Vo="
    keyHashed := md5.Sum([]byte(key))
    keyHex := hex.EncodeToString(keyHashed[:])
    cipherText := "h6OpNEE4g8hjyJl5lk5Qm4ZyXP/j3ADWqREolDL8lwb0LuyDqQdrlLGfsg==" // Ciphertext from the Java side (created with AES/CFB8)
    decryptedText, _ := decrypt([]byte(keyHex), cipherText)
    log.Println(decryptedText)
}

func decrypt(key []byte, cipherTextB64 string) (decrypted string, err error) {
    cipherText, _ := base64.StdEncoding.DecodeString(cipherTextB64)                      // Fix 1: don't separate IV and ciphertext
    iv := []byte{231, 9, 137, 91, 166, 112, 98, 216, 65, 150, 255, 96, 118, 243, 88, 85} // Fix 2: apply the static IV from the Java side
    block, _ := aes.NewCipher(key)
    stream := CFB8.NewCFB8Decrypt(block, iv) // Fix 3: apply CFB8
    stream.XORKeyStream(cipherText, cipherText)
    return string(cipherText), nil
}

关于安全：

• 静态 iv 是一个漏洞，因为这会导致密钥/iv 对的重复使用。为了避免这种情况，通常在加密过程中生成一个随机 iv 并与密文连接（注意 iv 不是秘密的）。在解密过程中，两个部分是分开的（顺便说一下，这对应于原始 go 代码中的实现）。
• 通过快速且不安全的摘要（例如 md5）从密码派生密钥是一个漏洞。使用pbkdf2等密钥导出函数更安全。

今天关于《Golang AES解密机制只给出另一个密文作为输出》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！