[PATCH v4] diff-delta: use safe integer arithmetic

From: Srujith A Poojary <poojarysrujith@gmail.com>

Replace manual multiplication and addition in create_delta_index() with safe integer helpers (st_mult, st_add, st_add3) to prevent potential overflows when computing memory allocation sizes.

For the unpacked index, we allocate hsize instances of hash pointers and
entries instances of struct index_entry:
  - hsize is capped at 2^26.
  - entries is capped at 2^28.
On 32-bit platforms with 4-byte padding for struct unpacked_index_entry,
the calculation size (sizeof(*hash) * hsize + sizeof(*entry) * entries) can
exceed 2^32, making safe integer arithmetic necessary.

Similarly, for the packed index, we compute allocation size across struct index, packed_hash, and entries. Using safe helpers prevents wrap-around across both allocations.

Note that passing (hsize + 1) as an argument to st_add3() is safe from overflow because hsize is capped at 2^26 early in the function.

Signed-off-by: Srujith A Poojary <poojarysrujith@gmail.com>
---
    [Outreachy PATCH] diff-delta: use safe integer arithmetic

Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-2276%2Fpoojarysrujith%2Fc-refactor-target-name-v4
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-2276/poojarysrujith/c-refactor-target-name-v4
Pull-Request: https://github.com/gitgitgadget/git/pull/2276

Range-diff vs v3:

 1:  d288bfe9e3 ! 1:  0d5a729cde diff-delta: use safe integer arithmetic
     @@ Commit message
          with safe integer helpers (st_mult, st_add, st_add3) to prevent potential
          overflows when computing memory allocation sizes.
      
     -    On 32-bit platforms, struct alignment padding could cause the total
     -    allocation size calculation to exceed 2^32, making safe integer arithmetic
     -    necessary. Note that hsize + 1 inside st_add3() is safe from overflow
     -    because hsize is capped at 2^26 early in the function.
     +    For the unpacked index, we allocate hsize instances of hash pointers and
     +    entries instances of struct index_entry:
     +      - hsize is capped at 2^26.
     +      - entries is capped at 2^28.
     +    On 32-bit platforms with 4-byte padding for struct unpacked_index_entry,
     +    the calculation size (sizeof(*hash) * hsize + sizeof(*entry) * entries) can
     +    exceed 2^32, making safe integer arithmetic necessary.
     +
     +    Similarly, for the packed index, we compute allocation size across
     +    struct index, packed_hash, and entries. Using safe helpers prevents
     +    wrap-around across both allocations.
     +
     +    Note that passing (hsize + 1) as an argument to st_add3() is safe from
     +    overflow because hsize is capped at 2^26 early in the function.
      
          Signed-off-by: Srujith A Poojary <poojarysrujith@gmail.com>
      

 diff-delta.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)