Addressed copilot's comments

Author: danielinux

src/delta.c

@@ -293,6 +293,7 @@ int wb_diff(WB_DIFF_CTX *ctx, uint8_t *patch, uint32_t len)
                 break;
             if ((memcmp(pa, (ctx->src_b + ctx->off_b), BLOCK_HDR_SIZE) == 0)) {
                 uintptr_t b_start;
+                uint8_t *pa_limit = ctx->src_a + ctx->size_a;
                 /* Identical areas of BLOCK_HDR_SIZE bytes match between the images.
                  * initialize match_len; blk_start is the relative offset within
                  * the src image.
@@ -302,13 +303,13 @@ int wb_diff(WB_DIFF_CTX *ctx, uint8_t *patch, uint32_t len)
                 b_start = ctx->off_b;
                 pa+= BLOCK_HDR_SIZE;
                 ctx->off_b += BLOCK_HDR_SIZE;
-                while (((uintptr_t)(pa - ctx->src_a) < (uintptr_t)ctx->size_a) &&
+                while ((pa < pa_limit) &&
                         (ctx->off_b < ctx->size_b) &&
                         (*pa == *(ctx->src_b + ctx->off_b))) {
                     /* Extend matching block if possible, as long as the
                      * identical sequence continues.
                      */
-                    if ((uint32_t)(pa + 1 - ctx->src_a) >= ctx->size_a) {
+                    if ((pa + 1) >= pa_limit) {
                         /* Stop matching if the source image size limit is hit. */
                         break;
                     }
@@ -337,6 +338,7 @@ int wb_diff(WB_DIFF_CTX *ctx, uint8_t *patch, uint32_t len)
         if (!found) {
             /* Try matching an earlier section in the resulting image */
             uintptr_t pb_end = page_start * wolfboot_sector_size;
+            uint8_t *pb_limit = ctx->src_b + pb_end;
             pb = ctx->src_b;
             while (((uintptr_t)(pb - ctx->src_b) < pb_end) && (p_off < len)) {
                 /* Check image boundary */
@@ -362,7 +364,7 @@ int wb_diff(WB_DIFF_CTX *ctx, uint8_t *patch, uint32_t len)
                     blk_start = pb - ctx->src_b;
                     pb+= BLOCK_HDR_SIZE;
                     ctx->off_b += BLOCK_HDR_SIZE;
-                    while (((uintptr_t)(pb - ctx->src_b) < pb_end) &&
+                    while ((pb < pb_limit) &&
                             (ctx->off_b < ctx->size_b) &&
                             (*pb == *(ctx->src_b + ctx->off_b))) {
                         /* Extend match as long as the areas have the
@@ -372,7 +374,7 @@ int wb_diff(WB_DIFF_CTX *ctx, uint8_t *patch, uint32_t len)
                          * block size.
                          */
                         pb++;
-                        if ((uint32_t)(pb - ctx->src_b) >= pb_end) {
+                        if (pb >= pb_limit) {
                             pb--;
                             break;
                         }

tools/unit-tests/unit-delta.c

@@ -167,11 +167,13 @@ START_TEST(test_wb_diff_self_match_extends_to_src_b_end)
     uint8_t *src_a;
     uint8_t *src_b;
     uint8_t patch[DELTA_BLOCK_SIZE] = {0};
-    uint32_t sector_size;
+    int sector_size_ret;
+    size_t sector_size;
     int ret;
 
-    sector_size = wb_diff_get_sector_size();
-    ck_assert_uint_gt(sector_size, BLOCK_HDR_SIZE);
+    sector_size_ret = wb_diff_get_sector_size();
+    ck_assert_int_gt(sector_size_ret, BLOCK_HDR_SIZE);
+    sector_size = (size_t)sector_size_ret;
 
     src_a = calloc(1, sector_size + BLOCK_HDR_SIZE);
     src_b = calloc(1, sector_size + BLOCK_HDR_SIZE + 1);
@@ -212,16 +214,24 @@ static void initialize_buffers(uint8_t *src_a, uint8_t *src_b, size_t size)
     }
 
     /* Introduce differences */
-    src_b[100] = src_a[100] + 1;
-    src_b[200] = src_a[200] + 2;
+    if (size > 100) {
+        src_b[100] = src_a[100] + 1;
+    }
+    if (size > 200) {
+        src_b[200] = src_a[200] + 2;
+    }
 
     /* 10-bytes difference across two blocks */
-    for (int i = 1020; i < 1040; ++i) {
+    for (int i = 1020; i < 1040 && (size_t)i < size; ++i) {
         src_b[i] = src_a[i] + 3;
     }
 
-    src_a[510] = ESC;
-    src_b[1022] = ESC;
+    if (size > 510) {
+        src_a[510] = ESC;
+    }
+    if (size > 1022) {
+        src_b[1022] = ESC;
+    }
 
 }