Fix 32-bit Windows issues related to QUIC Wire functions

Reviewed-by: Hugo Landau <hlandau@openssl.org>
Reviewed-by: Tomas Mraz <tomas@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/19345)

diff --git a/ssl/quic/quic_wire.c b/ssl/quic/quic_wire.c
index 291a1bb0d780342f56ce04309bc780231787cd05..e086834b5e2b4389a77320c14ae8bea734a4ce6c 100644 (file)
--- a/ssl/quic/quic_wire.c
+++ b/ssl/quic/quic_wire.c
@@ -54,7 +54,7 @@ int ossl_quic_wire_encode_frame_ack(WPACKET *pkt,
         return 0;
 
     delay = ossl_time_divide(ossl_time_divide(ack->delay_time, OSSL_TIME_US),
-                             1UL << ack_delay_exponent);
+                             (uint64_t)1 << ack_delay_exponent);
     ack_delay_enc   = ossl_time2ticks(delay);
 
     largest_ackd    = ack->ack_ranges[0].end;
@@ -127,11 +127,12 @@ void *ossl_quic_wire_encode_frame_crypto(WPACKET *pkt,
     unsigned char *p = NULL;
 
     if (!ossl_quic_wire_encode_frame_crypto_hdr(pkt, f)
-            || !WPACKET_allocate_bytes(pkt, f->len, &p))
+            || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */
+            || !WPACKET_allocate_bytes(pkt, (size_t)f->len, &p))
         return NULL;
 
     if (f->data != NULL)
-        memcpy(p, f->data, f->len);
+        memcpy(p, f->data, (size_t)f->len);
 
     return p;
 }
@@ -179,14 +180,15 @@ void *ossl_quic_wire_encode_frame_stream(WPACKET *pkt,
 
     unsigned char *p = NULL;
 
-    if (!ossl_quic_wire_encode_frame_stream_hdr(pkt, f))
+    if (!ossl_quic_wire_encode_frame_stream_hdr(pkt, f)
+            || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */)
         return NULL;
 
-    if (!WPACKET_allocate_bytes(pkt, f->len, &p))
+    if (!WPACKET_allocate_bytes(pkt, (size_t)f->len, &p))
         return NULL;
 
     if (f->data != NULL)
-        memcpy(p, f->data, f->len);
+        memcpy(p, f->data, (size_t)f->len);
 
     return p;
 }
@@ -450,7 +452,7 @@ int ossl_quic_wire_decode_frame_ack(PACKET *pkt,
         ack->delay_time
             = ossl_time_multiply(ossl_ticks2time(OSSL_TIME_US),
                                  safe_mul_uint64_t(ack_delay_raw,
-                                                   1UL << ack_delay_exponent,
+                                                   (uint64_t)1 << ack_delay_exponent,
                                                    &err));
         if (err)
             ack->delay_time = ossl_time_infinite();
@@ -533,7 +535,8 @@ int ossl_quic_wire_decode_frame_crypto(PACKET *pkt,
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_CRYPTO)
             || !PACKET_get_quic_vlint(pkt, &f->offset)
-            || !PACKET_get_quic_vlint(pkt, &f->len))
+            || !PACKET_get_quic_vlint(pkt, &f->len)
+            || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */)
         return 0;
 
     if (PACKET_remaining(pkt) < f->len)
@@ -541,7 +544,7 @@ int ossl_quic_wire_decode_frame_crypto(PACKET *pkt,
 
     f->data = PACKET_data(pkt);
 
-    if (!PACKET_forward(pkt, f->len))
+    if (!PACKET_forward(pkt, (size_t)f->len))
         return 0;
 
     return 1;
@@ -561,9 +564,9 @@ int ossl_quic_wire_decode_frame_new_token(PACKET               *pkt,
         return 0;
 
     *token      = PACKET_data(pkt);
-    *token_len  = token_len_;
+    *token_len  = (size_t)token_len_;
 
-    if (!PACKET_forward(pkt, token_len_))
+    if (!PACKET_forward(pkt, (size_t)token_len_))
         return 0;
 
     return 1;
@@ -600,7 +603,8 @@ int ossl_quic_wire_decode_frame_stream(PACKET *pkt,
 
     f->data = PACKET_data(pkt);
 
-    if (!PACKET_forward(pkt, f->len))
+    if (f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */
+        || !PACKET_forward(pkt, (size_t)f->len))
         return 0;
 
     return 1;
@@ -755,10 +759,11 @@ int ossl_quic_wire_decode_frame_conn_close(PACKET *pkt,
             || reason_len > SIZE_MAX)
         return 0;
 
-    if (!PACKET_get_bytes(pkt, (const unsigned char **)&f->reason, reason_len))
+    if (!PACKET_get_bytes(pkt, (const unsigned char **)&f->reason,
+                          (size_t)reason_len))
         return 0;
 
-    f->reason_len = reason_len;
+    f->reason_len = (size_t)reason_len;
     return 1;
 }
 

diff --git a/ssl/quic/quic_wire_pkt.c b/ssl/quic/quic_wire_pkt.c
index 484a5cc766379ce578ad9beeab5b3c3d7f8b28d0..b2bf90e7b6850d01194a2e699e5ba4a514287a87 100644 (file)
--- a/ssl/quic/quic_wire_pkt.c
+++ b/ssl/quic/quic_wire_pkt.c
@@ -206,7 +206,7 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
         if (!PACKET_copy_bytes(pkt, hdr->dst_conn_id.id, short_conn_id_len))
             return 0;
 
-        hdr->dst_conn_id.id_len = short_conn_id_len;
+        hdr->dst_conn_id.id_len = (unsigned char)short_conn_id_len;
 
         /*
          * Skip over the PN. If this is a partial decode, the PN length field
@@ -334,7 +334,7 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
 
                 if (!PACKET_get_quic_vlint(pkt, &token_len)
                     || token_len > SIZE_MAX
-                    || !PACKET_get_bytes(pkt, &hdr->token, token_len))
+                    || !PACKET_get_bytes(pkt, &hdr->token, (size_t)token_len))
                     return 0;
 
                 hdr->token_len  = (size_t)token_len;
@@ -642,7 +642,7 @@ int ossl_quic_wire_get_pkt_hdr_dst_conn_id(const unsigned char *buf,
         if (buf_len < QUIC_MIN_VALID_PKT_LEN_CRYPTO + short_conn_id_len)
             return 0;
 
-        dst_conn_id->id_len = short_conn_id_len;
+        dst_conn_id->id_len = (unsigned char)short_conn_id_len;
         memcpy(dst_conn_id->id, buf + 1, short_conn_id_len);
         return 1;
     }

diff --git a/test/quic_wire_test.c b/test/quic_wire_test.c
index 07ce4e12faf5be45e9721aa848d3ed12c7e42219..6948e69ef045b392042ab04d5c3ca379900336ec 100644 (file)
--- a/test/quic_wire_test.c
+++ b/test/quic_wire_test.c
@@ -119,9 +119,17 @@ static int encode_case_3_dec(PACKET *pkt, ossl_ssize_t fail)
     if (!TEST_uint64_t_eq(total_ranges, peek_total_ranges))
         return 0;
 
-    if (!TEST_mem_eq(f.ack_ranges, f.num_ack_ranges * sizeof(OSSL_QUIC_ACK_RANGE),
+    if (!TEST_uint64_t_le(f.num_ack_ranges * sizeof(OSSL_QUIC_ACK_RANGE),
+                          SIZE_MAX)
+        || !TEST_uint64_t_le(encode_case_3_f.num_ack_ranges
+                             * sizeof(OSSL_QUIC_ACK_RANGE),
+                             SIZE_MAX))
+        return 0;
+
+    if (!TEST_mem_eq(f.ack_ranges,
+                     (size_t)f.num_ack_ranges * sizeof(OSSL_QUIC_ACK_RANGE),
                      encode_case_3_f.ack_ranges,
-                     encode_case_3_f.num_ack_ranges * sizeof(OSSL_QUIC_ACK_RANGE)))
+                     (size_t)encode_case_3_f.num_ack_ranges * sizeof(OSSL_QUIC_ACK_RANGE)))
         return 0;
 
     if (!TEST_uint64_t_eq(ossl_time2ticks(f.delay_time),
@@ -262,7 +270,11 @@ static int encode_case_6_dec(PACKET *pkt, ossl_ssize_t fail)
     if (!TEST_uint64_t_eq(f.offset, 0x1234))
         return 0;
 
-    if (!TEST_mem_eq(f.data, f.len, encode_case_6_data, sizeof(encode_case_6_data)))
+    if (!TEST_uint64_t_le(f.len, SIZE_MAX))
+        return 0;
+
+    if (!TEST_mem_eq(f.data, (size_t)f.len,
+                     encode_case_6_data, sizeof(encode_case_6_data)))
         return 0;
 
     return 1;
@@ -352,7 +364,10 @@ static int encode_case_8_dec(PACKET *pkt, ossl_ssize_t fail)
     if (fail >= 0)
         return 1;
 
-    if (!TEST_mem_eq(f.data, f.len,
+    if (!TEST_uint64_t_le(f.len, SIZE_MAX))
+        return 0;
+
+    if (!TEST_mem_eq(f.data, (size_t)f.len,
                      encode_case_8_data, sizeof(encode_case_8_data)))
         return 0;
 
@@ -404,7 +419,10 @@ static int encode_case_9_dec(PACKET *pkt, ossl_ssize_t fail)
     if (fail >= 0)
         return 1;
 
-    if (!TEST_mem_eq(f.data, f.len,
+    if (!TEST_uint64_t_le(f.len, SIZE_MAX))
+        return 0;
+
+    if (!TEST_mem_eq(f.data, (size_t)f.len,
                      encode_case_9_data, sizeof(encode_case_9_data)))
         return 0;