Fixes build issues C4242, C4244 and C4334 caused by loss of data bugs due to data...

diff --git a/arch/arm/slide_hash_armv6.c b/arch/arm/slide_hash_armv6.c
index 07f71b59eb822a8720dc3de9f3d49e4308b22907..da4f51e0afc8240f4d372f8c3be6019b74753015 100644 (file)
--- a/arch/arm/slide_hash_armv6.c
+++ b/arch/arm/slide_hash_armv6.c
@@ -39,7 +39,8 @@ static inline void slide_hash_chain(Pos *table, uint32_t entries, uint16_t wsize
 }
 
 Z_INTERNAL void slide_hash_armv6(deflate_state *s) {
-    unsigned int wsize = s->w_size;
+    Assert(s->w_size <= UINT16_MAX, "w_size should fit in uint16_t");
+    uint16_t wsize = (uint16_t)s->w_size;
 
     slide_hash_chain(s->head, HASH_SIZE, wsize);
     slide_hash_chain(s->prev, wsize, wsize);

diff --git a/arch/arm/slide_hash_neon.c b/arch/arm/slide_hash_neon.c
index a601e6099ad7cc4394950c0ef09656f2d9e47b36..f319f987908a224f60fc106cb0c4fce29a945d57 100644 (file)
--- a/arch/arm/slide_hash_neon.c
+++ b/arch/arm/slide_hash_neon.c
@@ -38,7 +38,8 @@ static inline void slide_hash_chain(Pos *table, uint32_t entries, uint16_t wsize
 }
 
 Z_INTERNAL void slide_hash_neon(deflate_state *s) {
-    unsigned int wsize = s->w_size;
+    Assert(s->w_size <= UINT16_MAX, "w_size should fit in uint16_t");
+    uint16_t wsize = (uint16_t)s->w_size;
 
     slide_hash_chain(s->head, HASH_SIZE, wsize);
     slide_hash_chain(s->prev, wsize, wsize);

diff --git a/arch/generic/crc32_braid_c.c b/arch/generic/crc32_braid_c.c
index e94d91a7a9fef62152d6305c62037ba19e2cbadf..f80071042d77c601e11aaf096beea66c846de606 100644 (file)
--- a/arch/generic/crc32_braid_c.c
+++ b/arch/generic/crc32_braid_c.c
@@ -192,6 +192,7 @@ Z_INTERNAL uint32_t PREFIX(crc32_braid)(uint32_t crc, const uint8_t *buf, size_t
 #endif
 #endif
         words += N;
+        Assert(comb <= UINT32_MAX, "comb should fit in uint32_t");
         c = (uint32_t)ZSWAPWORD(comb);
 
         /* Update the pointer to the remaining bytes to process. */

diff --git a/arch/power/slide_ppc_tpl.h b/arch/power/slide_ppc_tpl.h
index 5c17e38fb31036e1450b1c28399eadfdb3495adf..680a7f8e2af4076f2b654fb865dca361514a7549 100644 (file)
--- a/arch/power/slide_ppc_tpl.h
+++ b/arch/power/slide_ppc_tpl.h
@@ -24,7 +24,8 @@ static inline void slide_hash_chain(Pos *table, uint32_t entries, uint16_t wsize
 }
 
 void Z_INTERNAL SLIDE_PPC(deflate_state *s) {
-    uint16_t wsize = s->w_size;
+    Assert(s->w_size <= UINT16_MAX, "w_size should fit in uint16_t");
+    uint16_t wsize = (uint16_t)s->w_size;
 
     slide_hash_chain(s->head, HASH_SIZE, wsize);
     slide_hash_chain(s->prev, wsize, wsize);

diff --git a/arch/riscv/slide_hash_rvv.c b/arch/riscv/slide_hash_rvv.c
index ac28bbd9f26e5ee9b509d5233a835a09aed1fa7c..6f53d7a13ad81b15cc36d347e241603382c7323e 100644 (file)
--- a/arch/riscv/slide_hash_rvv.c
+++ b/arch/riscv/slide_hash_rvv.c
@@ -23,6 +23,7 @@ static inline void slide_hash_chain(Pos *table, uint32_t entries, uint16_t wsize
 }
 
 Z_INTERNAL void slide_hash_rvv(deflate_state *s) {
+    Assert(s->w_size <= UINT16_MAX, "w_size should fit in uint16_t");
     uint16_t wsize = (uint16_t)s->w_size;
 
     slide_hash_chain(s->head, HASH_SIZE, wsize);

diff --git a/arch/x86/slide_hash_avx2.c b/arch/x86/slide_hash_avx2.c
index f49ad3331b8151f8c1ba427ed2e7b9157d2f6d8a..853347323436eb43e14653a44fbee979e2ed8bb7 100644 (file)
--- a/arch/x86/slide_hash_avx2.c
+++ b/arch/x86/slide_hash_avx2.c
@@ -31,6 +31,7 @@ static inline void slide_hash_chain(Pos *table, uint32_t entries, const __m256i
 }
 
 Z_INTERNAL void slide_hash_avx2(deflate_state *s) {
+    Assert(s->w_size <= UINT16_MAX, "w_size should fit in uint16_t");
     uint16_t wsize = (uint16_t)s->w_size;
     const __m256i ymm_wsize = _mm256_set1_epi16((short)wsize);
 

diff --git a/arch/x86/slide_hash_sse2.c b/arch/x86/slide_hash_sse2.c
index cfdf7bee49852b12cc1ec17165b7b8f3d586d103..6900a59d15dfac7cb1879ed999b015cd050a20f1 100644 (file)
--- a/arch/x86/slide_hash_sse2.c
+++ b/arch/x86/slide_hash_sse2.c
@@ -52,6 +52,7 @@ next_chain:
 }
 
 Z_INTERNAL void slide_hash_sse2(deflate_state *s) {
+    Assert(s->w_size <= UINT16_MAX, "w_size should fit in uint16_t");
     uint16_t wsize = (uint16_t)s->w_size;
     const __m128i xmm_wsize = _mm_set1_epi16((short)wsize);
 

diff --git a/deflate.c b/deflate.c
index af0f27bdbc1d479c56ab00f1dd5a36d0d38756d1..630cce2553b9233ac31cd400260c30d6ae7504fb 100644 (file)
--- a/deflate.c
+++ b/deflate.c
@@ -204,7 +204,7 @@ Z_INTERNAL deflate_allocs* alloc_deflate(PREFIX3(stream) *strm, int windowBits,
 
     /* Define sizes */
     int window_size = DEFLATE_ADJUST_WINDOW_SIZE((1 << windowBits) * 2);
-    int prev_size = (1 << windowBits) * sizeof(Pos);
+    int prev_size = (1 << windowBits) * (int)sizeof(Pos);
     int head_size = HASH_SIZE * sizeof(Pos);
     int pending_size = lit_bufsize * LIT_BUFS;
     int state_size = sizeof(deflate_state);

diff --git a/deflate_fast.c b/deflate_fast.c
index 2d0444cd73bbfbb95ed304144297563e216cac8a..e682697d5cc51849e098635c95d5adcc24ce6e7f 100644 (file)
--- a/deflate_fast.c
+++ b/deflate_fast.c
@@ -58,7 +58,9 @@ Z_INTERNAL block_state deflate_fast(deflate_state *s, int flush) {
         }
 
         if (match_len >= WANT_MIN_MATCH) {
-            check_match(s, s->strstart, s->match_start, match_len);
+            Assert(s->strstart <= UINT16_MAX, "strstart should fit in uint16_t");
+            Assert(s->match_start <= UINT16_MAX, "match_start should fit in uint16_t");
+            check_match(s, (Pos)s->strstart, (Pos)s->match_start, match_len);
 
             bflush = zng_tr_tally_dist(s, s->strstart - s->match_start, match_len - STD_MIN_MATCH);
 

diff --git a/deflate_p.h b/deflate_p.h
index 7c74ebf5ad771a41717cc6a9886052dbdd532b69..abcc8b1c7c1255e211d7979afa2fdbcb34eb5fea 100644 (file)
--- a/deflate_p.h
+++ b/deflate_p.h
@@ -78,8 +78,10 @@ static inline int zng_tr_tally_dist(deflate_state* s, uint32_t dist, uint32_t le
     /* dist: distance of matched string */
     /* len: match length-STD_MIN_MATCH */
 #ifdef LIT_MEM
-    s->d_buf[s->sym_next] = dist;
-    s->l_buf[s->sym_next++] = len;
+    Assert(dist <= UINT16_MAX, "dist should fit in uint16_t");
+    Assert(len <= UINT8_MAX, "len should fit in uint8_t");
+    s->d_buf[s->sym_next] = (uint16_t)dist;
+    s->l_buf[s->sym_next++] = (uint8_t)len;
 #else
     s->sym_buf[s->sym_next++] = (uint8_t)(dist);
     s->sym_buf[s->sym_next++] = (uint8_t)(dist >> 8);

diff --git a/deflate_quick.c b/deflate_quick.c
index 5a1937b67990281de7d320438e57f00cd5b31717..91c96ac52ed32d07f088d422cae6fe1f766f42b3 100644 (file)
--- a/deflate_quick.c
+++ b/deflate_quick.c
@@ -102,7 +102,8 @@ Z_INTERNAL block_state deflate_quick(deflate_state *s, int flush) {
                         if (UNLIKELY(match_len > STD_MAX_MATCH))
                             match_len = STD_MAX_MATCH;
 
-                        check_match(s, s->strstart, hash_head, match_len);
+                        Assert(s->strstart <= UINT16_MAX, "strstart should fit in uint16_t");
+                        check_match(s, (Pos)s->strstart, hash_head, match_len);
 
                         zng_tr_emit_dist(s, static_ltree, static_dtree, match_len - STD_MIN_MATCH, (uint32_t)dist);
                         s->lookahead -= match_len;

diff --git a/deflate_rle.c b/deflate_rle.c
index ee442141bea0d37b5b497b329f795615a2b77623..e8e501b1d229f963dd970088bdf6cfa793b99cc3 100644 (file)
--- a/deflate_rle.c
+++ b/deflate_rle.c
@@ -58,7 +58,8 @@ Z_INTERNAL block_state deflate_rle(deflate_state *s, int flush) {
 
         /* Emit match if have run of STD_MIN_MATCH or longer, else emit literal */
         if (match_len >= STD_MIN_MATCH) {
-            check_match(s, s->strstart, s->strstart - 1, match_len);
+            Assert(s->strstart <= UINT16_MAX, "strstart should fit in uint16_t");
+            check_match(s, (Pos)s->strstart, (Pos)(s->strstart - 1), match_len);
 
             bflush = zng_tr_tally_dist(s, 1, match_len - STD_MIN_MATCH);
 

diff --git a/deflate_slow.c b/deflate_slow.c
index de70cc1bba0bb4c0d96ef6f925f0000badcfbe9a..4165eea2afe72a767c81b905d0c85bef41c5047b 100644 (file)
--- a/deflate_slow.c
+++ b/deflate_slow.c
@@ -78,7 +78,8 @@ Z_INTERNAL block_state deflate_slow(deflate_state *s, int flush) {
             unsigned int max_insert = s->strstart + s->lookahead - STD_MIN_MATCH;
             /* Do not insert strings in hash table beyond this. */
 
-            check_match(s, s->strstart-1, s->prev_match, s->prev_length);
+            Assert((s->strstart-1) <= UINT16_MAX, "strstart-1 should fit in uint16_t");
+            check_match(s, (Pos)(s->strstart - 1), s->prev_match, s->prev_length);
 
             bflush = zng_tr_tally_dist(s, s->strstart -1 - s->prev_match, s->prev_length - STD_MIN_MATCH);