为什么即使数据长度是块大小的倍数，PKCS#7 也总是需要填充

Question

我刚刚发现我的 PKCS#5 不符合标准，因为如果数据长度是块大小的倍数，则不会添加填充，除非所有最后一个块字节都等于块大小（最后一个块就像一个填充块）。我看到标准行为是在数据大小是块长度的倍数时添加块大小的填充块，无论最后一个块内容如何。

我很困惑，因为我的实现只是在工作，并且在数据大小对齐时保存了额外的填充，那么为什么标准中有这个要求？

这是一些关于 aes 块大小（16 字节）的测试代码：

#include <iostream>
#include <array>
#include <vector>
#include <cassert>

template<size_t block_length>
inline size_t calc_existing_padding_size(const uint8_t* buff, size_t size)
{
    assert(size && size % block_length == 0);

    uint8_t last_byte = buff[size - 1];
    if (last_byte > block_length || !last_byte)
        return 0;

    auto end = buff + size;
    auto start = end - last_byte;

    while (start != end)
    {
        if (*start != last_byte)
            return 0;
        ++start;
    }

    return last_byte;
}

template<size_t block_length>
inline size_t calc_required_padding_size(const uint8_t* buff, size_t size)
{
    assert(buff && size);

    if (size < block_length)
        return block_length - size;

    if ((size == block_length) || (size % block_length == 0))
    {
        if (calc_existing_padding_size<block_length>(buff, size))
            return block_length;
        return 0;
    }

    return block_length - (size % block_length);
}

template<size_t block_length>
void add_padding(std::vector<uint8_t>& data)
{
    auto padding_size = calc_required_padding_size<block_length>(data.data(), data.size());
    data.resize(padding_size + data.size(), static_cast<uint8_t>(padding_size));
}

template<size_t block_length>
void remove_padding(std::vector<uint8_t>& data)
{
     auto padding_size = calc_existing_padding_size<block_length>(data.data(), data.size());
     data.resize(data.size() - padding_size);
}

struct test_entry
{
    std::vector<uint8_t> data;
    std::vector<uint8_t> padded_data;
    std::vector<uint8_t> unpadded_data;

    test_entry(std::vector<uint8_t> test_data, std::vector<uint8_t> after_padding) 
    : data(std::move(test_data)), padded_data(std::move(after_padding))
    {
        unpadded_data = data;

    }
};

int main()
{
    constexpr size_t block_length = 16;

    std::vector<test_entry> tests;

    auto make_test_entry = [](size_t data_size, uint8_t fill_byte)
    {
        assert(data_size <= block_length);

        std::vector<uint8_t> data(data_size, fill_byte);
        std::vector<uint8_t> padded_data = data;
        padded_data.resize(block_length, static_cast<uint8_t>(block_length - data_size ));
        return test_entry(std::move(data), std::move(padded_data));
    };

    for (size_t i = 0; i < block_length - 1; ++i)
    {
        tests.emplace_back(make_test_entry(i + 1, static_cast<uint8_t>(i + 1)));
    }

    tests.emplace_back(make_test_entry(block_length, '5'));

    {
        std::vector<uint8_t> data(block_length, static_cast<uint8_t>(block_length));
        auto padded_data = data;
        padded_data.resize(padded_data.size() + block_length, static_cast<uint8_t>(block_length));
        tests.emplace_back(std::move(data), std::move(padded_data));
    }

    std::cout << "[*] performing " << tests.size() << " tests" << std::endl;

    for (size_t i = 0; i < tests.size(); ++i)
    {

        add_padding<block_length>(tests[i].data);
        
        if (tests[i].data.size() != tests[i].padded_data.size()
        || ! std::equal(tests[i].data.begin(), tests[i].data.end(), tests[i].padded_data.begin()))
        {
            std::cout << "[!] test [" << i << "] failed in adding padding !" << std::endl;
            continue;
        }

        remove_padding<block_length>(tests[i].data);
        
        if (tests[i].data.size() != tests[i].unpadded_data.size()
        || ! std::equal(tests[i].data.begin(), tests[i].data.end(), tests[i].unpadded_data.begin()))
        {
            std::cout << "[!] test [" << i << "] failed in removing padding !" << std::endl;
            continue;
        }

        std::cout << "[*] test [" << i << "] passed" << std::endl;
    }
}

Answer 1

这是必要的，因此解密算法可以确定 确定最后一个块的最后一个字节是否是填充字节 指示添加的填充字节数或明文的一部分 信息。考虑一个纯文本消息，它是 B 的整数倍 明文最后一个字节为 01 的字节。没有额外的 信息，解密算法将无法确定 最后一个字节是明文字节还是填充字节。然而，由 在 01 明文字节之后添加 B 个字节，每个 B 值， 解密算法总是可以将最后一个字节视为填充字节，并且 从末尾剥离适当数量的填充字节 密文；所述的字节数基于值被剥离 最后一个字节。 https://en.wikipedia.org/wiki/Padding_(cryptography)

如果您知道消息将始终是块大小的倍数，您可以指定不应用填充的密码，或使用 cmets 中提到的不需要填充的密码模式。