fix: minor bbapi fuzzing results

Small cleanliness. Also, a separate requirement from alpha team wanted a fixed proof size to prevent any malleability concerns from adding 0s. It's easier for us to make sure this buffer is the correct size.

Closes https://linear.app/aztec-labs/issue/A-382 (Investigate issues on malleable tx proofs)

Author: ludamad

barretenberg/cpp/src/barretenberg/bbapi/bbapi_chonk.cpp

@@ -62,6 +62,7 @@ ChonkAccumulate::Response ChonkAccumulate::execute(BBApiRequest& request) &&
         precomputed_vk = nullptr;
     } else if (request.vk_policy == VkPolicy::DEFAULT || request.vk_policy == VkPolicy::CHECK) {
         if (!request.loaded_circuit_vk.empty()) {
+            validate_vk_size<Chonk::MegaVerificationKey>(request.loaded_circuit_vk);
             precomputed_vk = from_buffer<std::shared_ptr<Chonk::MegaVerificationKey>>(request.loaded_circuit_vk);
 
             if (request.vk_policy == VkPolicy::CHECK) {
@@ -132,8 +133,20 @@ ChonkProve::Response ChonkProve::execute(BBApiRequest& request) &&
 ChonkVerify::Response ChonkVerify::execute(const BBApiRequest& /*request*/) &&
 {
     BB_BENCH_NAME(MSGPACK_SCHEMA_NAME);
+
+    using VerificationKey = Chonk::MegaVerificationKey;
+    validate_vk_size<VerificationKey>(vk);
+
     // Deserialize the hiding kernel verification key directly from buffer
-    auto hiding_kernel_vk = std::make_shared<Chonk::MegaVerificationKey>(from_buffer<Chonk::MegaVerificationKey>(vk));
+    auto hiding_kernel_vk = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk));
+
+    // Validate proof size using VK's num_public_inputs before expensive verification
+    const size_t expected_proof_size =
+        static_cast<size_t>(hiding_kernel_vk->num_public_inputs) + ChonkProof::PROOF_LENGTH_WITHOUT_PUB_INPUTS;
+    if (proof.size() != expected_proof_size) {
+        throw_or_abort("proof has wrong size: expected " + std::to_string(expected_proof_size) + ", got " +
+                       std::to_string(proof.size()));
+    }
 
     // Verify the proof using ChonkNativeVerifier
     auto vk_and_hash = std::make_shared<ChonkNativeVerifier::VKAndHash>(hiding_kernel_vk);
@@ -198,6 +211,8 @@ ChonkCheckPrecomputedVk::Response ChonkCheckPrecomputedVk::execute([[maybe_unuse
         throw_or_abort("Missing precomputed VK");
     }
 
+    validate_vk_size<Chonk::MegaVerificationKey>(circuit.verification_key);
+
     // Deserialize directly from buffer
     auto precomputed_vk = from_buffer<std::shared_ptr<Chonk::MegaVerificationKey>>(circuit.verification_key);
 

barretenberg/cpp/src/barretenberg/bbapi/bbapi_shared.hpp

@@ -8,6 +8,7 @@
  */
 
 #include "barretenberg/chonk/chonk.hpp"
+#include "barretenberg/common/throw_or_abort.hpp"
 #include "barretenberg/dsl/acir_format/acir_format.hpp"
 #include "barretenberg/honk/execution_trace/mega_execution_trace.hpp"
 #include <cstdint>
@@ -16,6 +17,21 @@
 
 namespace bb::bbapi {
 
+/**
+ * @brief Validate verification key size before deserialization
+ * @tparam VK The verification key type
+ * @param vk_bytes The serialized verification key bytes
+ * @throws If the size doesn't match the expected size for the VK type
+ */
+template <typename VK> inline void validate_vk_size(const std::vector<uint8_t>& vk_bytes)
+{
+    const size_t expected_size = VK::calc_num_data_types() * sizeof(bb::fr);
+    if (vk_bytes.size() != expected_size) {
+        throw_or_abort("verification key has wrong size: expected " + std::to_string(expected_size) + ", got " +
+                       std::to_string(vk_bytes.size()));
+    }
+}
+
 /**
  * @enum VkPolicy
  * @brief Policy for handling verification keys during IVC accumulation

barretenberg/cpp/src/barretenberg/bbapi/bbapi_ultra_honk.cpp

@@ -138,6 +138,14 @@ bool _verify(const std::vector<uint8_t>& vk_bytes,
     using Transcript = typename Flavor::Transcript;
     using DataType = typename Transcript::DataType;
 
+    // Validate VK size upfront before deserialization
+    const size_t expected_vk_size = VerificationKey::calc_num_data_types() * sizeof(bb::fr);
+    if (vk_bytes.size() != expected_vk_size) {
+        info(
+            "Proof verification failed: invalid VK size. Expected ", expected_vk_size, " bytes, got ", vk_bytes.size());
+        return false;
+    }
+
     std::shared_ptr<VerificationKey> vk = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_bytes));
     auto vk_and_hash = std::make_shared<VKAndHash>(vk);
 
@@ -335,10 +343,13 @@ CircuitVerify::Response CircuitVerify::execute(BB_UNUSED const BBApiRequest& req
 VkAsFields::Response VkAsFields::execute(BB_UNUSED const BBApiRequest& request) &&
 {
     BB_BENCH_NAME(MSGPACK_SCHEMA_NAME);
-    std::vector<bb::fr> fields;
+
+    using VK = UltraFlavor::VerificationKey;
+    validate_vk_size<VK>(verification_key);
 
     // Standard UltraHonk flavors
-    auto vk = from_buffer<UltraFlavor::VerificationKey>(verification_key);
+    auto vk = from_buffer<VK>(verification_key);
+    std::vector<bb::fr> fields;
     fields = vk.to_field_elements();
 
     return { std::move(fields) };
@@ -347,10 +358,13 @@ VkAsFields::Response VkAsFields::execute(BB_UNUSED const BBApiRequest& request)
 MegaVkAsFields::Response MegaVkAsFields::execute(BB_UNUSED const BBApiRequest& request) &&
 {
     BB_BENCH_NAME(MSGPACK_SCHEMA_NAME);
-    std::vector<bb::fr> fields;
+
+    using VK = MegaFlavor::VerificationKey;
+    validate_vk_size<VK>(verification_key);
 
     // MegaFlavor for private function verification keys
-    auto vk = from_buffer<MegaFlavor::VerificationKey>(verification_key);
+    auto vk = from_buffer<VK>(verification_key);
+    std::vector<bb::fr> fields;
     fields = vk.to_field_elements();
 
     return { std::move(fields) };
@@ -360,6 +374,8 @@ CircuitWriteSolidityVerifier::Response CircuitWriteSolidityVerifier::execute(BB_
 {
     BB_BENCH_NAME(MSGPACK_SCHEMA_NAME);
     using VK = UltraKeccakFlavor::VerificationKey;
+    validate_vk_size<VK>(verification_key);
+
     auto vk = std::make_shared<VK>(from_buffer<VK>(verification_key));
 
     std::string contract = settings.disable_zk ? get_honk_solidity_verifier(vk) : get_honk_zk_solidity_verifier(vk);