bbapi.test.cpp

Go to the documentation of this file.

#include "barretenberg/api/file_io.hpp"
#include "barretenberg/bbapi/bbapi_handlers.hpp"
#include "barretenberg/bbapi/bbapi_shared.hpp"
#include "barretenberg/bbapi/generated/bb_types.hpp"
#include "barretenberg/chonk/private_execution_steps.hpp"
#include "barretenberg/common/assert.hpp"
#include "barretenberg/common/serialize.hpp"
#include "barretenberg/common/utils.hpp"
#include "barretenberg/serialize/test_helper.hpp"
#include "msgpack/v3/sbuffer_decl.hpp"
#include <gtest/gtest.h>
 
using namespace bb;
 
namespace {
// Wire (command, response) pairs for the serde roundtrip test below.
template <typename Cmd, typename Resp> struct WirePair {
    using CommandType = Cmd;
    using ResponseType = Resp;
};
} // namespace
 
// Template for testing roundtrip serialization on the codegen-emitted wire
// types. The serde fidelity of every other command pair is covered by the
// ipc-codegen golden + matrix tests; this suite is a sanity check that the
// `SERIALIZATION_FIELDS`-generated msgpack adapter round-trips correctly.
using WirePairs = ::testing::Types<
    WirePair<bbapi::wire::CircuitProve, bbapi::wire::CircuitProveResponse>,
    WirePair<bbapi::wire::CircuitComputeVk, bbapi::wire::CircuitComputeVkResponse>,
    WirePair<bbapi::wire::CircuitStats, bbapi::wire::CircuitInfoResponse>,
    WirePair<bbapi::wire::CircuitVerify, bbapi::wire::CircuitVerifyResponse>,
    WirePair<bbapi::wire::VkAsFields, bbapi::wire::VkAsFieldsResponse>,
    WirePair<bbapi::wire::CircuitWriteSolidityVerifier, bbapi::wire::CircuitWriteSolidityVerifierResponse>,
    WirePair<bbapi::wire::ChonkStart, bbapi::wire::ChonkStartResponse>,
    WirePair<bbapi::wire::ChonkLoad, bbapi::wire::ChonkLoadResponse>,
    WirePair<bbapi::wire::ChonkAccumulate, bbapi::wire::ChonkAccumulateResponse>,
    WirePair<bbapi::wire::ChonkProve, bbapi::wire::ChonkProveResponse>,
    WirePair<bbapi::wire::ChonkComputeVk, bbapi::wire::ChonkComputeVkResponse>,
    WirePair<bbapi::wire::ChonkCheckPrecomputedVk, bbapi::wire::ChonkCheckPrecomputedVkResponse>,
    WirePair<bbapi::wire::ChonkBatchVerify, bbapi::wire::ChonkBatchVerifyResponse>>;
 
template <typename T> class BBApiMsgpack : public ::testing::Test {};
 
TYPED_TEST_SUITE(BBApiMsgpack, WirePairs);
 
TYPED_TEST(BBApiMsgpack, DefaultConstructorRoundtrip)
{
    typename TypeParam::CommandType command{};
    auto [actual_command, expected_command] = msgpack_roundtrip(command);
    EXPECT_EQ(actual_command, expected_command);
 
    typename TypeParam::ResponseType response{};
    auto [actual_response, expected_response] = msgpack_roundtrip(response);
    EXPECT_EQ(actual_response, expected_response);
}
 
// Regression tests for input validation at API boundaries.
// These ensure non-canonical field encodings and trailing bytes are rejected.
 
TEST(BBApiInputValidation, NonCanonicalPublicInputRejected)
{
    using Flavor = UltraFlavor;
    // A value >= BN254 scalar field modulus should be rejected
    uint256_t non_canonical = fr::modulus + 1;
    std::vector<uint256_t> bad_public_inputs = { non_canonical };
    std::vector<uint256_t> proof = { uint256_t(0) };
 
    EXPECT_THROW(bbapi::concatenate_proof<Flavor>(bad_public_inputs, proof), std::runtime_error);
}
 
TEST(BBApiInputValidation, NonCanonicalProofElementRejected)
{
    using Flavor = UltraFlavor;
    // The modulus itself is non-canonical (valid range is [0, modulus))
    uint256_t non_canonical = fr::modulus;
    std::vector<uint256_t> public_inputs = { uint256_t(42) };
    std::vector<uint256_t> bad_proof = { non_canonical };
 
    EXPECT_THROW(bbapi::concatenate_proof<Flavor>(public_inputs, bad_proof), std::runtime_error);
}
 
TEST(BBApiInputValidation, CanonicalValuesAccepted)
{
    using Flavor = UltraFlavor;
    // modulus - 1 is the largest canonical value
    uint256_t max_canonical = fr::modulus - 1;
    std::vector<uint256_t> public_inputs = { uint256_t(0), max_canonical };
    std::vector<uint256_t> proof = { uint256_t(1) };
 
    EXPECT_NO_THROW(bbapi::concatenate_proof<Flavor>(public_inputs, proof));
}
 
TEST(BBApiInputValidation, TrailingBytesInBinaryInputRejected)
{
    // A buffer that is not a multiple of 32 bytes should be rejected
    std::vector<uint8_t> buf(32 + 1, 0); // 33 bytes = 1 field element + 1 trailing byte
    EXPECT_THROW(many_from_buffer_exact<uint256_t>(buf, "test input"), std::runtime_error);
}
 
TEST(BBApiInputValidation, ExactBinaryInputAccepted)
{
    // A buffer that is exactly 2 field elements should parse fine
    std::vector<uint8_t> buf(64, 0);
    EXPECT_NO_THROW(many_from_buffer_exact<uint256_t>(buf, "test input"));
    auto result = many_from_buffer_exact<uint256_t>(buf, "test input");
    EXPECT_EQ(result.size(), 2UL);
}
 
TEST(BBApiInputValidation, VkWithTrailingBytesRejectedOnProveSide)
{
    using VK = UltraFlavor::VerificationKey;
    const size_t expected_size = VK::calc_num_data_types() * sizeof(bb::fr);
    // One extra byte beyond the expected VK size
    std::vector<uint8_t> bad_vk(expected_size + 1, 0);
    EXPECT_THROW(bbapi::validate_vk_size<VK>(bad_vk), std::runtime_error);
}
 
TEST(BBApiInputValidation, VkWithCorrectSizeAccepted)
{
    using VK = UltraFlavor::VerificationKey;
    const size_t expected_size = VK::calc_num_data_types() * sizeof(bb::fr);
    std::vector<uint8_t> good_vk(expected_size, 0);
    EXPECT_NO_THROW(bbapi::validate_vk_size<VK>(good_vk));
}
 
TEST(BBApiInputValidation, ChonkVerifyWrongVkSizeReturnsInvalid)
{
    bbapi::BBApiRequest request;
    auto response = bbapi::handle_chonk_verify(request, bbapi::wire::ChonkVerify{ .proof = {}, .vk = { 0 } });
    EXPECT_FALSE(response.valid);
}
 
TEST(BBApiInputValidation, ChonkVerifyFromFieldsWrongVkSizeReturnsInvalid)
{
    bbapi::BBApiRequest request;
    auto response =
        bbapi::handle_chonk_verify_from_fields(request, bbapi::wire::ChonkVerifyFromFields{ .proof = {}, .vk = { 0 } });
    EXPECT_FALSE(response.valid);
}
 
TEST(BBApiInputValidation, ChonkBatchVerifyWrongVkSizeReturnsInvalid)
{
    bbapi::BBApiRequest request;
    auto response = bbapi::handle_chonk_batch_verify(request,
                                                     bbapi::wire::ChonkBatchVerify{
                                                         .proofs = { bbapi::wire::ChonkProof{} },
                                                         .vks = { { 0 } },
                                                     });
    EXPECT_FALSE(response.valid);
}
 
// Helper: pack a vector of PrivateExecutionStepRaw into a byte buffer via msgpack.
namespace {
std::vector<uint8_t> pack_steps(const std::vector<PrivateExecutionStepRaw>& steps)
{
    std::stringstream ss;
    msgpack::pack(ss, steps);
    const std::string s = ss.str();
    return { s.begin(), s.end() };
}
} // namespace
 
TEST(BBApiInputValidation, MsgpackParseUncompressedAcceptsCleanInput)
{
    PrivateExecutionStepRaw step{
        .bytecode = { 0xCA, 0xFE }, .witness = { 0xBE, 0xEF }, .vk = {}, .function_name = "test_fn"
    };
 
    auto buf = pack_steps({ step });
    auto result = PrivateExecutionStepRaw::parse_uncompressed(buf);
 
    ASSERT_EQ(result.size(), 1);
    EXPECT_EQ(result[0].bytecode, step.bytecode);
    EXPECT_EQ(result[0].witness, step.witness);
    EXPECT_EQ(result[0].function_name, "test_fn");
}
 
TEST(BBApiInputValidation, MsgpackParseUncompressedRejectsTrailingData)
{
    PrivateExecutionStepRaw step{ .bytecode = {}, .witness = {}, .vk = {}, .function_name = "x" };
 
    auto buf = pack_steps({ step });
    buf.push_back(0x00);
 
    EXPECT_THROW(PrivateExecutionStepRaw::parse_uncompressed(buf), std::invalid_argument);
}
 
TEST(BBApiInputValidation, MsgpackLoadAcceptsCleanFile)
{
    PrivateExecutionStepRaw step{ .bytecode = { 1, 2, 3 }, .witness = { 4, 5 }, .vk = {}, .function_name = "file_fn" };
 
    auto buf = pack_steps({ step });
 
    auto tmp = std::filesystem::temp_directory_path() / "bb_test_clean.msgpack";
    std::ofstream out(tmp, std::ios::binary);
    out.write(reinterpret_cast<const char*>(buf.data()), static_cast<std::streamsize>(buf.size()));
    out.close();
 
    auto result = PrivateExecutionStepRaw::load(tmp);
    std::filesystem::remove(tmp);
 
    ASSERT_EQ(result.size(), 1);
    EXPECT_EQ(result[0].function_name, "file_fn");
}
 
TEST(BBApiInputValidation, MsgpackLoadRejectsTrailingData)
{
    PrivateExecutionStepRaw step{ .bytecode = {}, .witness = {}, .vk = {}, .function_name = "x" };
 
    auto buf = pack_steps({ step });
    buf.push_back(0x00);
 
    auto tmp = std::filesystem::temp_directory_path() / "bb_test_tailed.msgpack";
    std::ofstream out(tmp, std::ios::binary);
    out.write(reinterpret_cast<const char*>(buf.data()), static_cast<std::streamsize>(buf.size()));
    out.close();
 
    EXPECT_THROW(PrivateExecutionStepRaw::load(tmp), std::invalid_argument);
    std::filesystem::remove(tmp);
}
 
// Regression tests for AesEncrypt/AesDecrypt input validation.
// Without these guards, a socket client could force a ~4 GB allocation via the
// uint32_t `length` field, or pass `length != plaintext.size()` and silently
// encrypt zero-padded tail bytes.
TEST(BBApiInputValidation, AesEncryptRejectsLengthMismatch)
{
    bbapi::BBApiRequest request{};
    bbapi::wire::AesEncrypt cmd{ .plaintext = std::vector<uint8_t>(16, 0), .iv = {}, .key = {}, .length = 32 };
    EXPECT_THROW_OR_ABORT(bbapi::handle_aes_encrypt(request, std::move(cmd)), ".*length must equal plaintext.*");
}
 
TEST(BBApiInputValidation, AesEncryptRejectsNonBlockAlignedLength)
{
    bbapi::BBApiRequest request{};
    bbapi::wire::AesEncrypt cmd{ .plaintext = std::vector<uint8_t>(17, 0), .iv = {}, .key = {}, .length = 17 };
    EXPECT_THROW_OR_ABORT(bbapi::handle_aes_encrypt(request, std::move(cmd)), ".*multiple of 16.*");
}
 
TEST(BBApiInputValidation, AesDecryptRejectsLengthMismatch)
{
    bbapi::BBApiRequest request{};
    bbapi::wire::AesDecrypt cmd{ .ciphertext = std::vector<uint8_t>(16, 0), .iv = {}, .key = {}, .length = 32 };
    EXPECT_THROW_OR_ABORT(bbapi::handle_aes_decrypt(request, std::move(cmd)), ".*length must equal ciphertext.*");
}
 
TEST(BBApiInputValidation, AesDecryptRejectsNonBlockAlignedLength)
{
    bbapi::BBApiRequest request{};
    bbapi::wire::AesDecrypt cmd{ .ciphertext = std::vector<uint8_t>(17, 0), .iv = {}, .key = {}, .length = 17 };
    EXPECT_THROW_OR_ABORT(bbapi::handle_aes_decrypt(request, std::move(cmd)), ".*multiple of 16.*");
}