Validate codes vector size in BlockInvertedLists deserialization (#4920)

Summary:
Pull Request resolved: #4920

After READVECTOR reads ids[i] and codes[i] in BlockInvertedListsIOHook::read(),
validate that codes[i].size() matches the expected value computed from
ids[i].size(), n_per_block, and block_size. Uses mul_no_overflow to detect
integer overflow in the n_block * block_size computation, preventing
crafted inputs from bypassing the size check via wraparound.

Without this check, a maliciously crafted serialized BlockInvertedLists could
have inconsistent codes and ids vectors, leading to out-of-bounds memory
access during search or add operations.

Reviewed By: mnorris11

Differential Revision: D96346307

fbshipit-source-id: 43156fa287fa004cc9d178fc558d168b7b3848dc

Author: scsiguy

faiss/invlists/BlockInvertedLists.cpp

@@ -184,6 +184,21 @@ InvertedLists* BlockInvertedListsIOHook::read(IOReader* f, int /* io_flags */)
     for (size_t i = 0; i < il->nlist; i++) {
         READVECTOR(il->ids[i]);
         READVECTOR(il->codes[i]);
+        size_t n_ids = il->ids[i].size();
+        size_t n_block = (n_ids + il->n_per_block - 1) / il->n_per_block;
+        size_t expected_codes_size = mul_no_overflow(
+                n_block, il->block_size, "BlockInvertedLists codes");
+        FAISS_THROW_IF_NOT_FMT(
+                il->codes[i].size() == expected_codes_size,
+                "BlockInvertedLists list %zd: codes size %zd does not "
+                "match expected %zd (ids=%zd, n_per_block=%zd, "
+                "block_size=%zd)",
+                i,
+                il->codes[i].size(),
+                expected_codes_size,
+                n_ids,
+                il->n_per_block,
+                il->block_size);
     }
 
     return il.release();

tests/test_read_index_deserialize.cpp

@@ -721,3 +721,90 @@ TEST(ReadIndexDeserialize, BlockInvertedListsBlockSizeZero) {
 
     expect_invlists_read_throws_with(buf, "block_size");
 }
+
+// -----------------------------------------------------------------------
+// Test: BlockInvertedLists with codes vector size inconsistent with ids
+// size, n_per_block, and block_size.  Without the check, a search or
+// add operation would read/write past the end of the codes buffer.
+// -----------------------------------------------------------------------
+TEST(ReadIndexDeserialize, BlockInvertedListsCodesSizeMismatch) {
+    const size_t n_per_block = 32;
+    const size_t block_size = 128;
+
+    std::vector<uint8_t> buf;
+    push_fourcc(buf, "ilbl");
+    push_val<size_t>(buf, 1);           // nlist = 1
+    push_val<size_t>(buf, 32);          // code_size
+    push_val<size_t>(buf, n_per_block); // n_per_block
+    push_val<size_t>(buf, block_size);  // block_size
+
+    // ids: 10 entries → ceil(10/32) = 1 block → expected codes = 128 bytes
+    std::vector<int64_t> ids(10, 0);
+    push_vector<int64_t>(buf, ids);
+    // codes: 64 bytes (wrong, should be 128)
+    std::vector<uint8_t> codes(64, 0);
+    push_vector<uint8_t>(buf, codes);
+
+    expect_invlists_read_throws_with(buf, "codes size");
+}
+
+// -----------------------------------------------------------------------
+// Test: BlockInvertedLists with n_block * block_size overflow.  Without
+// the mul_no_overflow check, the multiplication wraps around and the
+// size comparison passes spuriously.
+// -----------------------------------------------------------------------
+TEST(ReadIndexDeserialize, BlockInvertedListsCodesOverflow) {
+    // Choose n_per_block=1 and block_size near SIZE_MAX so that
+    // n_block * block_size overflows.
+    const size_t n_per_block = 1;
+    const size_t block_size = (size_t)-1; // SIZE_MAX
+
+    std::vector<uint8_t> buf;
+    push_fourcc(buf, "ilbl");
+    push_val<size_t>(buf, 1);           // nlist = 1
+    push_val<size_t>(buf, 32);          // code_size
+    push_val<size_t>(buf, n_per_block); // n_per_block
+    push_val<size_t>(buf, block_size);  // block_size
+
+    // ids: 2 entries → n_block = 2 → 2 * SIZE_MAX overflows
+    std::vector<int64_t> ids(2, 0);
+    push_vector<int64_t>(buf, ids);
+    // codes: any size, doesn't matter — overflow should be caught first
+    std::vector<uint8_t> codes(0);
+    push_vector<uint8_t>(buf, codes);
+
+    expect_invlists_read_throws_with(buf, "overflow");
+}
+
+// -----------------------------------------------------------------------
+// Test: BlockInvertedLists with valid ids and codes passes validation.
+// -----------------------------------------------------------------------
+TEST(ReadIndexDeserialize, BlockInvertedListsValidCodesSize) {
+    const size_t n_per_block = 32;
+    const size_t block_size = 128;
+    const size_t nlist = 2;
+
+    std::vector<uint8_t> buf;
+    push_fourcc(buf, "ilbl");
+    push_val<size_t>(buf, nlist);       // nlist
+    push_val<size_t>(buf, 32);          // code_size
+    push_val<size_t>(buf, n_per_block); // n_per_block
+    push_val<size_t>(buf, block_size);  // block_size
+
+    // List 0: 10 ids → ceil(10/32)=1 block → 128 bytes
+    std::vector<int64_t> ids0(10, 0);
+    push_vector<int64_t>(buf, ids0);
+    std::vector<uint8_t> codes0(128, 0);
+    push_vector<uint8_t>(buf, codes0);
+
+    // List 1: 0 ids → 0 blocks → 0 bytes
+    std::vector<int64_t> ids1;
+    push_vector<int64_t>(buf, ids1);
+    std::vector<uint8_t> codes1;
+    push_vector<uint8_t>(buf, codes1);
+
+    VectorIOReader reader;
+    reader.data = buf;
+    auto il = read_InvertedLists_up(&reader);
+    EXPECT_NE(il, nullptr);
+}