Method TestFSChaCha20Poly1305

src/test/crypto_tests.cpp:296–340

}

void TestFSChaCha20Poly1305(const std::string& plain_hex, const std::string& aad_hex, const std::string& key_hex, uint64_t msg_idx, const std::string& cipher_hex)
{
    auto plain = ParseHex<std::byte>(plain_hex);
    auto aad = ParseHex<std::byte>(aad_hex);
    auto key = ParseHex<std::byte>(key_hex);
    auto expected_cipher = ParseHex<std::byte>(cipher_hex);
    std::vector<std::byte> cipher(plain.size() + FSChaCha20Poly1305::EXPANSION);

    for (int it = 0; it < 10; ++it) {
        // During it==0 we use the single-plain Encrypt/Decrypt; others use a split at prefix.
        size_t prefix = it ? m_rng.randrange(plain.size() + 1) : plain.size();
        std::byte dummy_tag[FSChaCha20Poly1305::EXPANSION] = {{}};

        // Do msg_idx dummy encryptions to seek to the correct packet.
        FSChaCha20Poly1305 enc_aead{key, 224};
        for (uint64_t i = 0; i < msg_idx; ++i) {
            enc_aead.Encrypt(std::span{dummy_tag}.first(0), std::span{dummy_tag}.first(0), dummy_tag);
        }

        // Invoke single-plain or plain1/plain2 Encrypt.
        if (it == 0) {
            enc_aead.Encrypt(plain, aad, cipher);
        } else {
            enc_aead.Encrypt(std::span{plain}.first(prefix), std::span{plain}.subspan(prefix), aad, cipher);
        }
        BOOST_CHECK(cipher == expected_cipher);

        // Do msg_idx dummy decryptions to seek to the correct packet.
        FSChaCha20Poly1305 dec_aead{key, 224};
        for (uint64_t i = 0; i < msg_idx; ++i) {
            dec_aead.Decrypt(dummy_tag, std::span{dummy_tag}.first(0), std::span{dummy_tag}.first(0));
        }

        // Invoke single-plain or plain1/plain2 Decrypt.
        std::vector<std::byte> decipher(cipher.size() - AEADChaCha20Poly1305::EXPANSION);
        bool ret{false};
        if (it == 0) {
            ret = dec_aead.Decrypt(cipher, aad, decipher);
        } else {
            ret = dec_aead.Decrypt(cipher, aad, std::span{decipher}.first(prefix), std::span{decipher}.subspan(prefix));
        }
        BOOST_CHECK(ret);
        BOOST_CHECK(decipher == plain);
    }
}

void TestHKDF_SHA256_32(const std::string &ikm_hex, const std::string &salt_hex, const std::string &info_hex, const std::string &okm_check_hex) {
    std::vector<unsigned char> initial_key_material = ParseHex(ikm_hex);