如何派生IV和密钥到crypto.createcipheriv进行解密？

Question

我已经看到了其他一些关于创建加密的初始化向量(IV)的问题，似乎使用随机值是一种选择。然而，我需要生成用于解密的IV，所以我必须使用基于一些salt的数据加密的相同的数据。

node.js加密函数createDecipher表示：

crypto.createdecipher（）的实现使用OpenSSL函数EVP_BytesToKey派生密钥，摘要算法设置为MD5，一次迭代，没有salt。

好的，听起来不错。我需要解密的数据是使用EVP_BytesToKey加密的，以获得密钥和IV，所以我需要与之兼容。

无论如何，crypto.pbkdf2函数似乎获得了我需要的所有参数，但问题是，它似乎没有创建初始化向量。

需要与之兼容的进行解密的相应C代码如下所示：

// parameters to function:
// unsigned char *decrypt_salt
// int nrounds
// unsigned char *decrypt_key_data  <- the password
//  int decrypt_key_data_len <- password length

// the following is not initialized before the call to EVP_BytesToKey
unsigned char decrypt_key[32], decrypt_iv[32];

EVP_BytesToKey(EVP_aes_256_cbc(), EVP_md5(), decrypt_salt, decrypt_key_data,
                   decrypt_key_data_len, nrounds, decrypt_key, decrypt_iv);

crypto.pbkdf2(password, salt, nrounds, 32, "md5", (err, derivedKey) => {
    if (err) throw err
    console.log(derivedKey.toString("hex"))
})

Answer 1

首先，您没有得到所需结果的原因是，您的C代码使用evp_bytestokey，而NodeJS代码使用PBKDF2。我想您可能误解了OpenSSL的推荐。他们推荐PBKDF2，不是作为产生相同结果的更好方法，而是作为解决问题的更好方法。PBKDF2只是一个更好的键派生函数，但它不会产生与evp_bytestokey相同的结果。

此外，你处理第四代的方式首先是相当糟糕的。使用KDF来生成密钥是非常好的，做得很好。坦率地说，使用KDF生成IV是一个非常糟糕的想法。你的初步读数是正确的，你发现随机产生静脉注射是一个好主意。所有IV/NONCE应随机生成。总是。这里要记住的重要事情是静脉注射不是秘密。你可以公开通过。

大多数实现将随机生成一个IV，然后将其前缀到密文。然后，当涉及到解密时，您可以简单地删除第一个128位(AES)值的字节，并将其用作IV。这涵盖了你所有的基础，意味着你不必从与关键材料相同的地方获得你的IV（这很恶心）。

const crypto = require("crypto");

const ALGORITHM_NAME = "aes-128-gcm";
const ALGORITHM_NONCE_SIZE = 12;
const ALGORITHM_TAG_SIZE = 16;
const ALGORITHM_KEY_SIZE = 16;
const PBKDF2_NAME = "sha256";
const PBKDF2_SALT_SIZE = 16;
const PBKDF2_ITERATIONS = 32767;

function encryptString(plaintext, password) {
    // Generate a 128-bit salt using a CSPRNG.
    let salt = crypto.randomBytes(PBKDF2_SALT_SIZE);

    // Derive a key using PBKDF2.
    let key = crypto.pbkdf2Sync(new Buffer(password, "utf8"), salt, PBKDF2_ITERATIONS, ALGORITHM_KEY_SIZE, PBKDF2_NAME);

    // Encrypt and prepend salt.
    let ciphertextAndNonceAndSalt = Buffer.concat([ salt, encrypt(new Buffer(plaintext, "utf8"), key) ]);

    // Return as base64 string.
    return ciphertextAndNonceAndSalt.toString("base64");
}

function decryptString(base64CiphertextAndNonceAndSalt, password) {
    // Decode the base64.
    let ciphertextAndNonceAndSalt = new Buffer(base64CiphertextAndNonceAndSalt, "base64");

    // Create buffers of salt and ciphertextAndNonce.
    let salt = ciphertextAndNonceAndSalt.slice(0, PBKDF2_SALT_SIZE);
    let ciphertextAndNonce = ciphertextAndNonceAndSalt.slice(PBKDF2_SALT_SIZE);

    // Derive the key using PBKDF2.
    let key = crypto.pbkdf2Sync(new Buffer(password, "utf8"), salt, PBKDF2_ITERATIONS, ALGORITHM_KEY_SIZE, PBKDF2_NAME);

    // Decrypt and return result.
    return decrypt(ciphertextAndNonce, key).toString("utf8");
}

function encrypt(plaintext, key) {
    // Generate a 96-bit nonce using a CSPRNG.
    let nonce = crypto.randomBytes(ALGORITHM_NONCE_SIZE);

    // Create the cipher instance.
    let cipher = crypto.createCipheriv(ALGORITHM_NAME, key, nonce);

    // Encrypt and prepend nonce.
    let ciphertext = Buffer.concat([ cipher.update(plaintext), cipher.final() ]);

    return Buffer.concat([ nonce, ciphertext, cipher.getAuthTag() ]);
}

function decrypt(ciphertextAndNonce, key) {
    // Create buffers of nonce, ciphertext and tag.
    let nonce = ciphertextAndNonce.slice(0, ALGORITHM_NONCE_SIZE);
    let ciphertext = ciphertextAndNonce.slice(ALGORITHM_NONCE_SIZE, ciphertextAndNonce.length - ALGORITHM_TAG_SIZE);
    let tag = ciphertextAndNonce.slice(ciphertext.length + ALGORITHM_NONCE_SIZE);

    // Create the cipher instance.
    let cipher = crypto.createDecipheriv(ALGORITHM_NAME, key, nonce);

    // Decrypt and return result.
    cipher.setAuthTag(tag);
    return Buffer.concat([ cipher.update(ciphertext), cipher.final() ]);
}