Question

我希望使用CryptoStream将数据附加到已加密的文件（AES，CBC模式，填充PKCS＃7），而无需读取和写入整个文件。

示例：

旧内容："Hello world..."

新内容："Hello world, with appended text"

当然，我必须阅读单个数据块，然后附加到已存在的块。在上面提到的例子中，我将不得不读取第一个块中存在的字节数（14个字节），并将两个字节附加到第一个块，然后写入其余的附加文本

"Hello world, wi"
"th appended text"

我面临的一个问题是我无法读取数据块中的字节数。有没有办法找出存在的字节数（在例子中，14）？

此外，由于CryptoStreamMode只有读取和写入成员，但没有更新，因此我陷入困境。

有没有办法使用CryptoStream完成我想要的功能？

Answer 1

这有点复杂，但不是太多。请注意，这适用于CBC模式+ PKCS＃7！

三种方法：WriteStringToFile将创建一个新文件，AppendStringToFile将附加到已加密的文件（如果文件丢失/为空，则作为WriteStringToFile使用），{{1}将从文件中读取。

ReadStringFromFile

使用示例：

public static void WriteStringToFile(string fileName, string plainText, byte[] key, byte[] iv)
{
    using (Rijndael algo = Rijndael.Create())
    {
        algo.Key = key;
        algo.IV = iv;
        algo.Mode = CipherMode.CBC;
        algo.Padding = PaddingMode.PKCS7;

        // Create the streams used for encryption.
        using (FileStream file = new FileStream(fileName, FileMode.Create, FileAccess.Write))
        // Create an encryptor to perform the stream transform.
        using (ICryptoTransform encryptor = algo.CreateEncryptor())
        using (CryptoStream cs = new CryptoStream(file, encryptor, CryptoStreamMode.Write))
        using (StreamWriter sw = new StreamWriter(cs))
        {
            // Write all data to the stream.
            sw.Write(plainText);
        }
    }
}

public static void AppendStringToFile(string fileName, string plainText, byte[] key, byte[] iv)
{
    using (Rijndael algo = Rijndael.Create())
    {
        algo.Key = key;
        // The IV is set below
        algo.Mode = CipherMode.CBC;
        algo.Padding = PaddingMode.PKCS7;

        // Create the streams used for encryption.
        using (FileStream file = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
        {
            byte[] previous = null;
            int previousLength = 0;

            long length = file.Length;

            // No check is done that the file is correct!
            if (length != 0)
            {
                // The IV length is equal to the block length
                byte[] block = new byte[iv.Length];

                if (length >= iv.Length * 2)
                {
                    // At least 2 blocks, take the penultimate block
                    // as the IV
                    file.Position = length - iv.Length * 2;
                    file.Read(block, 0, block.Length);
                    algo.IV = block;
                }
                else
                {
                    // A single block present, use the IV given
                    file.Position = length - iv.Length;
                    algo.IV = iv;
                }

                // Read the last block
                file.Read(block, 0, block.Length);

                // And reposition at the beginning of the last block
                file.Position = length - iv.Length;

                // We use a MemoryStream because the CryptoStream
                // will close the Stream at the end
                using (var ms = new MemoryStream(block))
                // Create a decrytor to perform the stream transform.
                using (ICryptoTransform decryptor = algo.CreateDecryptor())
                using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                {
                    // Read all data from the stream. The decrypted last
                    // block can be long up to block length characters
                    // (so up to iv.Length) (this with AES + CBC)
                    previous = new byte[iv.Length];
                    previousLength = cs.Read(previous, 0, previous.Length);
                }
            }
            else
            {
                // Use the IV given
                algo.IV = iv;
            }

            // Create an encryptor to perform the stream transform.
            using (ICryptoTransform encryptor = algo.CreateEncryptor())
            using (CryptoStream cs = new CryptoStream(file, encryptor, CryptoStreamMode.Write))
            using (StreamWriter sw = new StreamWriter(cs))
            {
                // Rewrite the last block, if present. We even skip
                // the case of block present but empty
                if (previousLength != 0)
                {
                    cs.Write(previous, 0, previousLength);
                }

                // Write all data to the stream.
                sw.Write(plainText);
            }
        }
    }
}

public static string ReadStringFromFile(string fileName, byte[] key, byte[] iv)
{
    string plainText;

    using (Rijndael algo = Rijndael.Create())
    {
        algo.Key = key;
        algo.IV = iv;
        algo.Mode = CipherMode.CBC;
        algo.Padding = PaddingMode.PKCS7;

        // Create the streams used for decryption.
        using (FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read))
        // Create a decrytor to perform the stream transform.
        using (ICryptoTransform decryptor = algo.CreateDecryptor())
        using (CryptoStream cs = new CryptoStream(file, decryptor, CryptoStreamMode.Read))
        using (StreamReader sr = new StreamReader(cs))
        {
            // Read all data from the stream.
            plainText = sr.ReadToEnd();
        }
    }

    return plainText;
}

var key = Encoding.UTF8.GetBytes("Simple key"); var iv = Encoding.UTF8.GetBytes("Simple IV"); Array.Resize(ref key, 128 / 8); Array.Resize(ref iv, 128 / 8); if (File.Exists("test.bin")) { File.Delete("test.bin"); } for (int i = 0; i < 100; i++) { AppendStringToFile("test.bin", string.Format("{0},", i), key, iv); } string plainText = ReadStringFromFile("test.bin", key, iv);如何运作？三个案例：

空档案：AppendStringToFile
具有单个块的文件：该块的IV是作为参数传递的IV。该块被解密，然后与传递的WriteStringToFile
具有多个块的文件：最后一个块的IV是倒数第二个块。因此读取倒数第二个块，并将其用作IV（忽略参数时传递的IV）。最后一个块被解密，然后与传递的plainText一起重新加密。为了重新加入最后一个块，使用的IV是倒数第二个块。

将数据附加到加密文件

1 个答案: