Merge pull request #29 from kosmas-valianos/moreMisc

kosmas-valianos · web-flow · commit 1cb55f089907 · 2026-03-23T15:42:37.000+01:00
Miscellaneous fixes
diff --git a/Makefile b/Makefile
@@ -16,7 +16,7 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-CFLAGS := -Wall -Wextra -Wshadow -Wimplicit-fallthrough=0 -ansi -fshort-enums -fpic
+CFLAGS := -Wall -Wextra -Wshadow -ansi -fshort-enums -fpic
 
 all: build tests example
 
diff --git a/src/proxy_protocol.c b/src/proxy_protocol.c
@@ -217,7 +217,7 @@ static uint8_t parse_port(const char *value, uint16_t *usport)
 {
     char *endptr = NULL;
     uint64_t port = strtoul(value, &endptr, 10);
-    if (endptr == value || port > UINT16_MAX)
+    if (endptr == value || *endptr != '\0' || *value == '+' || port > UINT16_MAX)
     {
         return 0;
     }
@@ -286,7 +286,12 @@ static uint8_t tlv_array_append_tlv_new(tlv_array_t *tlv_array, uint8_t type, ui
 
 static uint8_t tlv_array_append_tlv_new_usascii(tlv_array_t *tlv_array, uint8_t type, uint16_t length, const void *value)
 {
-    pp2_tlv_t *tlv = tlv_new(type, length + 1, value);
+    pp2_tlv_t *tlv;
+    if (length == UINT16_MAX)
+    {
+        return 0;
+    }
+    tlv = tlv_new(type, length + 1, value);
     if (!tlv)
     {
         return 0;
@@ -409,20 +414,42 @@ uint8_t pp_info_add_ssl(pp_info_t *pp_info, const char *version, const char *cip
 
 uint8_t pp_info_add_netns(pp_info_t *pp_info, const char *netns)
 {
-    return tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, PP2_TYPE_NETNS, (uint16_t) strlen(netns), netns);
+    size_t netns_len;
+    if (!netns)
+    {
+        return 0;
+    }
+    netns_len = strlen(netns);
+    if (netns_len > UINT16_MAX)
+    {
+        return 0;
+    }
+    return tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, PP2_TYPE_NETNS, (uint16_t) netns_len, netns);
 }
 
 uint8_t pp_info_add_aws_vpce_id(pp_info_t *pp_info, const char *vpce_id)
 {
-    uint16_t length = sizeof_pp2_tlv_aws_t + (uint16_t) strlen(vpce_id);
-    pp2_tlv_aws_t *pp2_tlv_aws = malloc(length);
+    size_t vpce_id_len;
+    uint16_t length;
+    pp2_tlv_aws_t *pp2_tlv_aws;
     uint8_t rc;
+    if (!vpce_id)
+    {
+        return 0;
+    }
+    vpce_id_len = strlen(vpce_id);
+    if (vpce_id_len > UINT16_MAX - sizeof_pp2_tlv_aws_t)
+    {
+        return 0;
+    }
+    length = (uint16_t)(sizeof_pp2_tlv_aws_t + vpce_id_len);
+    pp2_tlv_aws = malloc(length);
     if (!pp2_tlv_aws)
     {
         return 0;
     }
     pp2_tlv_aws->type = PP2_SUBTYPE_AWS_VPCE_ID;
-    memcpy(pp2_tlv_aws->value, vpce_id, strlen(vpce_id));
+    memcpy(pp2_tlv_aws->value, vpce_id, vpce_id_len);
     rc = tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, PP2_TYPE_AWS, length, pp2_tlv_aws);
     free(pp2_tlv_aws);
     return rc;
@@ -674,7 +701,8 @@ static uint32_t crc32c(const uint8_t* buf, uint32_t len)
 static uint8_t *pp2_create_hdr(const pp_info_t *pp_info, uint16_t *pp2_hdr_len, int32_t *error)
 {
     proxy_hdr_v2_t proxy_hdr_v2 = { PP2_SIG, '\x21', 0, 0 };
-    uint16_t proxy_addr_len, len, padding_bytes, index;
+    uint16_t proxy_addr_len, padding_bytes, index;
+    uint32_t len;
     proxy_addr_t proxy_addr;
     const tlv_array_t *tlv_array;
     uint32_t i;
@@ -755,7 +783,12 @@ static uint8_t *pp2_create_hdr(const pp_info_t *pp_info, uint16_t *pp2_hdr_len,
     {
         len += sizeof_pp2_tlv_t + sizeof(uint32_t);
     }
-    *pp2_hdr_len = sizeof(proxy_hdr_v2_t) + len;
+    if (sizeof(proxy_hdr_v2_t) + len > UINT16_MAX)
+    {
+        *error = -ERR_PP2_LENGTH;
+        return NULL;
+    }
+    *pp2_hdr_len = (uint16_t)(sizeof(proxy_hdr_v2_t) + len);
     if (pp_info->pp2_info.alignment_power > 1)
     {
         uint16_t alignment = 1 << pp_info->pp2_info.alignment_power;
@@ -767,13 +800,13 @@ static uint8_t *pp2_create_hdr(const pp_info_t *pp_info, uint16_t *pp2_hdr_len,
             {
                 pp2_hdr_len_padded += alignment;
             }
-            padding_bytes = pp2_hdr_len_padded - sizeof(proxy_hdr_v2_t) - len - sizeof_pp2_tlv_t;
+            padding_bytes = pp2_hdr_len_padded - (uint16_t)sizeof(proxy_hdr_v2_t) - (uint16_t)len - sizeof_pp2_tlv_t;
 
             *pp2_hdr_len = pp2_hdr_len_padded;
-            len = pp2_hdr_len_padded - sizeof(proxy_hdr_v2_t);
+            len = pp2_hdr_len_padded - (uint32_t)sizeof(proxy_hdr_v2_t);
         }
     }
-    proxy_hdr_v2.len = htons(len);
+    proxy_hdr_v2.len = htons((uint16_t)len);
 
     /* Create the PROXY protocol header */
     pp2_hdr = malloc(*pp2_hdr_len);
@@ -795,7 +828,7 @@ static uint8_t *pp2_create_hdr(const pp_info_t *pp_info, uint16_t *pp2_hdr_len,
         memcpy(pp2_hdr + index, tlv_array->tlvs[i], tlv_len);
         index += tlv_len;
     }
-    if (pp_info->pp2_info.alignment_power > 1)
+    if (pp_info->pp2_info.alignment_power > 1 && padding_bytes > 0)
     {
         pp2_tlv_t tlv = { 0 };
         tlv.type = PP2_TYPE_NOOP;
@@ -884,7 +917,7 @@ static uint8_t *pp1_create_hdr(const pp_info_t *pp_info, uint16_t *pp1_hdr_len,
         }
         memcpy(src_addr, pp_info->src_addr, sizeof(src_addr));
         memcpy(dst_addr, pp_info->dst_addr, sizeof(dst_addr));
-        *pp1_hdr_len = _sprintf(block, "PROXY %s %s %s %hu %hu"CRLF, fam, src_addr, dst_addr, pp_info->src_port, pp_info->dst_port);
+        *pp1_hdr_len = (uint16_t)_sprintf(block, "PROXY %s %s %s %hu %hu"CRLF, fam, src_addr, dst_addr, pp_info->src_port, pp_info->dst_port);
     }
     else
     {
@@ -1055,12 +1088,12 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     }
 
     /* TLVs */
-    /* Any TLV vector must be at least 3 bytes */
-    while (tlv_vectors_len > sizeof_pp2_tlv_t)
+    /* Any TLV vector must be at least 3 bytes (sizeof_pp2_tlv_t) */
+    while (tlv_vectors_len >= sizeof_pp2_tlv_t)
     {
         const pp2_tlv_t *pp2_tlv = (const pp2_tlv_t*) buffer;
         uint16_t pp2_tlv_len = pp2_tlv->length_hi << 8 | pp2_tlv->length_lo;
-        uint16_t pp2_tlv_offset = sizeof_pp2_tlv_t + pp2_tlv_len;
+        uint32_t pp2_tlv_offset = (uint32_t) sizeof_pp2_tlv_t + pp2_tlv_len;
         if (pp2_tlv_offset > tlv_vectors_len)
         {
             return -ERR_PP2_TLV_LENGTH;
@@ -1094,7 +1127,7 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
              * Instead of zeroing the field in the buffer, compute CRC in 3 segments:
              * before the checksum value, 4 zero bytes, after the checksum value. */
             total_hdr_len = sizeof(proxy_hdr_v2_t) + len;
-            offset_to_chksum_value = (const uint8_t*)pp2_tlv->value - pp2_hdr;
+            offset_to_chksum_value = (uint32_t)((const uint8_t*)pp2_tlv->value - pp2_hdr);
             after_chksum_offset = offset_to_chksum_value + sizeof(uint32_t);
 
             crc = crc32c_continue(0xffffffff, pp2_hdr, offset_to_chksum_value);
@@ -1129,25 +1162,39 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
             break;
         case PP2_TYPE_SSL:
         {
-            const pp2_tlv_ssl_t *pp2_tlv_ssl = (const pp2_tlv_ssl_t*) pp2_tlv->value;
+            const pp2_tlv_ssl_t *pp2_tlv_ssl;
             uint16_t pp2_tlvs_ssl_len = 0, pp2_sub_tlv_offset = 0;
             uint8_t tlv_ssl_version_found = 0;
 
+            if (pp2_tlv_len < sizeof(((pp2_tlv_ssl_t*)0)->client) + sizeof(((pp2_tlv_ssl_t*)0)->verify))
+            {
+                return -ERR_PP2_TYPE_SSL;
+            }
+
+            pp2_tlv_ssl = (const pp2_tlv_ssl_t*) pp2_tlv->value;
+
             /* Set the pp2_ssl_info */
             pp_info->pp2_info.pp2_ssl_info.ssl = !!(pp2_tlv_ssl->client & PP2_CLIENT_SSL);
             pp_info->pp2_info.pp2_ssl_info.cert_in_connection = !!(pp2_tlv_ssl->client & PP2_CLIENT_CERT_CONN);
             pp_info->pp2_info.pp2_ssl_info.cert_in_session = !!(pp2_tlv_ssl->client & PP2_CLIENT_CERT_SESS);
             pp_info->pp2_info.pp2_ssl_info.cert_verified = !pp2_tlv_ssl->verify;
 
             pp2_tlvs_ssl_len = pp2_tlv_len - sizeof(pp2_tlv_ssl->client) - sizeof(pp2_tlv_ssl->verify);
-            while (pp2_sub_tlv_offset < pp2_tlvs_ssl_len)
+            while (pp2_sub_tlv_offset + sizeof_pp2_tlv_t <= pp2_tlvs_ssl_len)
             {
                 const pp2_tlv_t *pp2_sub_tlv_ssl = (const pp2_tlv_t*) ((const uint8_t*) pp2_tlv_ssl->sub_tlv + pp2_sub_tlv_offset);
                 uint16_t pp2_sub_tlv_ssl_len = pp2_sub_tlv_ssl->length_hi << 8 | pp2_sub_tlv_ssl->length_lo;
+                if ((uint32_t) sizeof_pp2_tlv_t + pp2_sub_tlv_ssl_len > (uint32_t)(pp2_tlvs_ssl_len - pp2_sub_tlv_offset))
+                {
+                    return -ERR_PP2_TYPE_SSL;
+                }
+                if (pp2_sub_tlv_ssl->type == PP2_SUBTYPE_SSL_VERSION)
+                {
+                    tlv_ssl_version_found = 1;
+                }
                 switch (pp2_sub_tlv_ssl->type)
                 {
                 case PP2_SUBTYPE_SSL_VERSION: /* US-ASCII */
-                    tlv_ssl_version_found = 1;
                 case PP2_SUBTYPE_SSL_CIPHER:  /* US-ASCII */
                 case PP2_SUBTYPE_SSL_SIG_ALG: /* US-ASCII */
                 case PP2_SUBTYPE_SSL_KEY_ALG: /* US-ASCII */
@@ -1171,7 +1218,7 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
 
                 pp2_sub_tlv_offset += sizeof_pp2_tlv_t + pp2_sub_tlv_ssl_len;
             }
-            if (pp2_sub_tlv_offset > pp2_tlvs_ssl_len || (pp_info->pp2_info.pp2_ssl_info.ssl && !tlv_ssl_version_found))
+            if (pp2_sub_tlv_offset != pp2_tlvs_ssl_len || (pp_info->pp2_info.pp2_ssl_info.ssl && !tlv_ssl_version_found))
             {
                 return -ERR_PP2_TYPE_SSL;
             }
@@ -1213,8 +1260,7 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
             /* Connection is done through Private Link service */
             if (pp2_tlv_azure->type == PP2_SUBTYPE_AZURE_PRIVATEENDPOINT_LINKID) /* 32-bit number */
             {
-                pp2_tlv_t *tlv = tlv_new(pp2_tlv->type, pp2_tlv_len, pp2_tlv->value);
-                if (!tlv || !tlv_array_append_tlv(&pp_info->pp2_info.tlv_array, tlv))
+                if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
                 {
                     return -ERR_HEAP_ALLOC;
                 }
@@ -1248,15 +1294,15 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     char src_port_str[6] = { 0 };
     char dst_port_str[6] = { 0 };
 
-    memcpy(block, buffer, buffer_length < PP1_MAX_LENGTH ? buffer_length : PP1_MAX_LENGTH);
+    memcpy(block, buffer, buffer_length < PP1_MAX_LENGTH - 1 ? buffer_length : PP1_MAX_LENGTH - 1);
 
     block_end = strstr(block, CRLF);
     if (!block_end)
     {
         return -ERR_PP1_CRLF;
     }
     block_end += strlen(CRLF);
-    pp1_hdr_len = block_end - block;
+    pp1_hdr_len = (int32_t)(block_end - block);
 
     /* PROXY */
     if (memcmp(block, "PROXY", 5))
@@ -1277,7 +1323,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     if (!inet_family)
     {
         /* Unknown connection (short form) */
-        if (pp1_hdr_len == 15 || !memcmp(ptr, "UNKNOWN", 7))
+        if (pp1_hdr_len == 15 && !memcmp(ptr, "UNKNOWN", 7))
         {
             pp_info->address_family = ADDR_FAMILY_UNSPEC;
             pp_info->transport_protocol = TRANSPORT_PROTOCOL_UNSPEC;
@@ -1324,7 +1370,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     {
         return sa_family == AF_INET ? -ERR_PP1_IPV4_SRC_IP : -ERR_PP1_IPV6_SRC_IP;
     }
-    src_address_length = src_address_end - ptr;
+    src_address_length = (uint16_t)(src_address_end - ptr);
     memcpy(pp_info->src_addr, ptr, src_address_length);
     if (inet_pton(sa_family, pp_info->src_addr, &src_sin_addr) != 1)
     {
@@ -1345,7 +1391,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     {
         return sa_family == AF_INET ? -ERR_PP1_IPV4_DST_IP : -ERR_PP1_IPV6_DST_IP;
     }
-    dst_address_length = dst_address_end - ptr;
+    dst_address_length = (uint16_t)(dst_address_end - ptr);
     memcpy(pp_info->dst_addr, ptr, dst_address_length);
     if (inet_pton(sa_family, pp_info->dst_addr, &dst_sin_addr) != 1)
     {
@@ -1366,7 +1412,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     {
         return -ERR_PP1_SRC_PORT;
     }
-    src_port_length = src_port_end - ptr;
+    src_port_length = (uint16_t)(src_port_end - ptr);
     if (src_port_length == 0 || src_port_length > 5)
     {
         return -ERR_PP1_SRC_PORT;
@@ -1391,7 +1437,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     {
         return -ERR_PP1_DST_PORT;
     }
-    dst_port_length = dst_port_end - ptr;
+    dst_port_length = (uint16_t)(dst_port_end - ptr);
     if (dst_port_length == 0 || dst_port_length > 5)
     {
         return -ERR_PP1_DST_PORT;
diff --git a/tests/test.c b/tests/test.c

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`	`# along with this program. If not, see <https://www.gnu.org/licenses/>.`
`17`	`17`	`#`
`18`	`18`
`19`		`-CFLAGS := -Wall -Wextra -Wshadow -Wimplicit-fallthrough=0 -ansi -fshort-enums -fpic`
	`19`	`+CFLAGS := -Wall -Wextra -Wshadow -ansi -fshort-enums -fpic`
`20`	`20`
`21`	`21`	`all: build tests example`
`22`	`22`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ static uint8_t parse_port(const char value, uint16_t usport)`
`217`	`217`	`{`
`218`	`218`	`char *endptr = NULL;`
`219`	`219`	`uint64_t port = strtoul(value, &endptr, 10);`
`220`		`- if (endptr == value \|\| port > UINT16_MAX)`
	`220`	`+ if (endptr == value \|\| endptr != '\0' \|\| value == '+' \|\| port > UINT16_MAX)`
`221`	`221`	`{`
`222`	`222`	`return 0;`
`223`	`223`	`}`
`@@ -286,7 +286,12 @@ static uint8_t tlv_array_append_tlv_new(tlv_array_t *tlv_array, uint8_t type, ui`
`286`	`286`
`287`	`287`	`static uint8_t tlv_array_append_tlv_new_usascii(tlv_array_t tlv_array, uint8_t type, uint16_t length, const void value)`
`288`	`288`	`{`
`289`		`- pp2_tlv_t *tlv = tlv_new(type, length + 1, value);`
	`289`	`+ pp2_tlv_t *tlv;`
	`290`	`+ if (length == UINT16_MAX)`
	`291`	`+ {`
	`292`	`+ return 0;`
	`293`	`+ }`
	`294`	`+ tlv = tlv_new(type, length + 1, value);`
`290`	`295`	`if (!tlv)`
`291`	`296`	`{`
`292`	`297`	`return 0;`
`@@ -409,20 +414,42 @@ uint8_t pp_info_add_ssl(pp_info_t pp_info, const char version, const char *cip`
`409`	`414`
`410`	`415`	`uint8_t pp_info_add_netns(pp_info_t pp_info, const char netns)`
`411`	`416`	`{`
`412`		`- return tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, PP2_TYPE_NETNS, (uint16_t) strlen(netns), netns);`
	`417`	`+ size_t netns_len;`
	`418`	`+ if (!netns)`
	`419`	`+ {`
	`420`	`+ return 0;`
	`421`	`+ }`
	`422`	`+ netns_len = strlen(netns);`
	`423`	`+ if (netns_len > UINT16_MAX)`
	`424`	`+ {`
	`425`	`+ return 0;`
	`426`	`+ }`
	`427`	`+ return tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, PP2_TYPE_NETNS, (uint16_t) netns_len, netns);`
`413`	`428`	`}`
`414`	`429`
`415`	`430`	`uint8_t pp_info_add_aws_vpce_id(pp_info_t pp_info, const char vpce_id)`
`416`	`431`	`{`
`417`		`- uint16_t length = sizeof_pp2_tlv_aws_t + (uint16_t) strlen(vpce_id);`
`418`		`- pp2_tlv_aws_t *pp2_tlv_aws = malloc(length);`
	`432`	`+ size_t vpce_id_len;`
	`433`	`+ uint16_t length;`
	`434`	`+ pp2_tlv_aws_t *pp2_tlv_aws;`
`419`	`435`	`uint8_t rc;`
	`436`	`+ if (!vpce_id)`
	`437`	`+ {`
	`438`	`+ return 0;`
	`439`	`+ }`
	`440`	`+ vpce_id_len = strlen(vpce_id);`
	`441`	`+ if (vpce_id_len > UINT16_MAX - sizeof_pp2_tlv_aws_t)`
	`442`	`+ {`
	`443`	`+ return 0;`
	`444`	`+ }`
	`445`	`+ length = (uint16_t)(sizeof_pp2_tlv_aws_t + vpce_id_len);`
	`446`	`+ pp2_tlv_aws = malloc(length);`
`420`	`447`	`if (!pp2_tlv_aws)`
`421`	`448`	`{`
`422`	`449`	`return 0;`
`423`	`450`	`}`
`424`	`451`	`pp2_tlv_aws->type = PP2_SUBTYPE_AWS_VPCE_ID;`
`425`		`- memcpy(pp2_tlv_aws->value, vpce_id, strlen(vpce_id));`
	`452`	`+ memcpy(pp2_tlv_aws->value, vpce_id, vpce_id_len);`
`426`	`453`	`rc = tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, PP2_TYPE_AWS, length, pp2_tlv_aws);`
`427`	`454`	`free(pp2_tlv_aws);`
`428`	`455`	`return rc;`
`@@ -674,7 +701,8 @@ static uint32_t crc32c(const uint8_t* buf, uint32_t len)`
`674`	`701`	`static uint8_t pp2_create_hdr(const pp_info_t pp_info, uint16_t pp2_hdr_len, int32_t error)`
`675`	`702`	`{`
`676`	`703`	`proxy_hdr_v2_t proxy_hdr_v2 = { PP2_SIG, '\x21', 0, 0 };`
`677`		`- uint16_t proxy_addr_len, len, padding_bytes, index;`
	`704`	`+ uint16_t proxy_addr_len, padding_bytes, index;`
	`705`	`+ uint32_t len;`
`678`	`706`	`proxy_addr_t proxy_addr;`
`679`	`707`	`const tlv_array_t *tlv_array;`
`680`	`708`	`uint32_t i;`
`@@ -755,7 +783,12 @@ static uint8_t pp2_create_hdr(const pp_info_t pp_info, uint16_t *pp2_hdr_len,`
`755`	`783`	`{`
`756`	`784`	`len += sizeof_pp2_tlv_t + sizeof(uint32_t);`
`757`	`785`	`}`
`758`		`- *pp2_hdr_len = sizeof(proxy_hdr_v2_t) + len;`
	`786`	`+ if (sizeof(proxy_hdr_v2_t) + len > UINT16_MAX)`
	`787`	`+ {`
	`788`	`+ *error = -ERR_PP2_LENGTH;`
	`789`	`+ return NULL;`
	`790`	`+ }`
	`791`	`+ *pp2_hdr_len = (uint16_t)(sizeof(proxy_hdr_v2_t) + len);`
`759`	`792`	`if (pp_info->pp2_info.alignment_power > 1)`
`760`	`793`	`{`
`761`	`794`	`uint16_t alignment = 1 << pp_info->pp2_info.alignment_power;`
`@@ -767,13 +800,13 @@ static uint8_t pp2_create_hdr(const pp_info_t pp_info, uint16_t *pp2_hdr_len,`
`767`	`800`	`{`
`768`	`801`	`pp2_hdr_len_padded += alignment;`
`769`	`802`	`}`
`770`		`- padding_bytes = pp2_hdr_len_padded - sizeof(proxy_hdr_v2_t) - len - sizeof_pp2_tlv_t;`
	`803`	`+ padding_bytes = pp2_hdr_len_padded - (uint16_t)sizeof(proxy_hdr_v2_t) - (uint16_t)len - sizeof_pp2_tlv_t;`
`771`	`804`
`772`	`805`	`*pp2_hdr_len = pp2_hdr_len_padded;`
`773`		`- len = pp2_hdr_len_padded - sizeof(proxy_hdr_v2_t);`
	`806`	`+ len = pp2_hdr_len_padded - (uint32_t)sizeof(proxy_hdr_v2_t);`
`774`	`807`	`}`
`775`	`808`	`}`
`776`		`- proxy_hdr_v2.len = htons(len);`
	`809`	`+ proxy_hdr_v2.len = htons((uint16_t)len);`
`777`	`810`
`778`	`811`	`/* Create the PROXY protocol header */`
`779`	`812`	`pp2_hdr = malloc(*pp2_hdr_len);`
`@@ -795,7 +828,7 @@ static uint8_t pp2_create_hdr(const pp_info_t pp_info, uint16_t *pp2_hdr_len,`
`795`	`828`	`memcpy(pp2_hdr + index, tlv_array->tlvs[i], tlv_len);`
`796`	`829`	`index += tlv_len;`
`797`	`830`	`}`
`798`		`- if (pp_info->pp2_info.alignment_power > 1)`
	`831`	`+ if (pp_info->pp2_info.alignment_power > 1 && padding_bytes > 0)`
`799`	`832`	`{`
`800`	`833`	`pp2_tlv_t tlv = { 0 };`
`801`	`834`	`tlv.type = PP2_TYPE_NOOP;`
`@@ -884,7 +917,7 @@ static uint8_t pp1_create_hdr(const pp_info_t pp_info, uint16_t *pp1_hdr_len,`
`884`	`917`	`}`
`885`	`918`	`memcpy(src_addr, pp_info->src_addr, sizeof(src_addr));`
`886`	`919`	`memcpy(dst_addr, pp_info->dst_addr, sizeof(dst_addr));`
`887`		`- *pp1_hdr_len = _sprintf(block, "PROXY %s %s %s %hu %hu"CRLF, fam, src_addr, dst_addr, pp_info->src_port, pp_info->dst_port);`
	`920`	`+ *pp1_hdr_len = (uint16_t)_sprintf(block, "PROXY %s %s %s %hu %hu"CRLF, fam, src_addr, dst_addr, pp_info->src_port, pp_info->dst_port);`
`888`	`921`	`}`
`889`	`922`	`else`
`890`	`923`	`{`
`@@ -1055,12 +1088,12 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1055`	`1088`	`}`
`1056`	`1089`
`1057`	`1090`	`/* TLVs */`
`1058`		`- /* Any TLV vector must be at least 3 bytes */`
`1059`		`- while (tlv_vectors_len > sizeof_pp2_tlv_t)`
	`1091`	`+ /* Any TLV vector must be at least 3 bytes (sizeof_pp2_tlv_t) */`
	`1092`	`+ while (tlv_vectors_len >= sizeof_pp2_tlv_t)`
`1060`	`1093`	`{`
`1061`	`1094`	`const pp2_tlv_t pp2_tlv = (const pp2_tlv_t) buffer;`
`1062`	`1095`	`uint16_t pp2_tlv_len = pp2_tlv->length_hi << 8 \| pp2_tlv->length_lo;`
`1063`		`- uint16_t pp2_tlv_offset = sizeof_pp2_tlv_t + pp2_tlv_len;`
	`1096`	`+ uint32_t pp2_tlv_offset = (uint32_t) sizeof_pp2_tlv_t + pp2_tlv_len;`
`1064`	`1097`	`if (pp2_tlv_offset > tlv_vectors_len)`
`1065`	`1098`	`{`
`1066`	`1099`	`return -ERR_PP2_TLV_LENGTH;`
`@@ -1094,7 +1127,7 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1094`	`1127`	`* Instead of zeroing the field in the buffer, compute CRC in 3 segments:`
`1095`	`1128`	`* before the checksum value, 4 zero bytes, after the checksum value. */`
`1096`	`1129`	`total_hdr_len = sizeof(proxy_hdr_v2_t) + len;`
`1097`		`- offset_to_chksum_value = (const uint8_t*)pp2_tlv->value - pp2_hdr;`
	`1130`	`+ offset_to_chksum_value = (uint32_t)((const uint8_t*)pp2_tlv->value - pp2_hdr);`
`1098`	`1131`	`after_chksum_offset = offset_to_chksum_value + sizeof(uint32_t);`
`1099`	`1132`
`1100`	`1133`	`crc = crc32c_continue(0xffffffff, pp2_hdr, offset_to_chksum_value);`
`@@ -1129,25 +1162,39 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1129`	`1162`	`break;`
`1130`	`1163`	`case PP2_TYPE_SSL:`
`1131`	`1164`	`{`
`1132`		`- const pp2_tlv_ssl_t pp2_tlv_ssl = (const pp2_tlv_ssl_t) pp2_tlv->value;`
	`1165`	`+ const pp2_tlv_ssl_t *pp2_tlv_ssl;`
`1133`	`1166`	`uint16_t pp2_tlvs_ssl_len = 0, pp2_sub_tlv_offset = 0;`
`1134`	`1167`	`uint8_t tlv_ssl_version_found = 0;`
`1135`	`1168`
	`1169`	`+ if (pp2_tlv_len < sizeof(((pp2_tlv_ssl_t)0)->client) + sizeof(((pp2_tlv_ssl_t)0)->verify))`
	`1170`	`+ {`
	`1171`	`+ return -ERR_PP2_TYPE_SSL;`
	`1172`	`+ }`
	`1173`	`+`
	`1174`	`+ pp2_tlv_ssl = (const pp2_tlv_ssl_t*) pp2_tlv->value;`
	`1175`	`+`
`1136`	`1176`	`/* Set the pp2_ssl_info */`
`1137`	`1177`	`pp_info->pp2_info.pp2_ssl_info.ssl = !!(pp2_tlv_ssl->client & PP2_CLIENT_SSL);`
`1138`	`1178`	`pp_info->pp2_info.pp2_ssl_info.cert_in_connection = !!(pp2_tlv_ssl->client & PP2_CLIENT_CERT_CONN);`
`1139`	`1179`	`pp_info->pp2_info.pp2_ssl_info.cert_in_session = !!(pp2_tlv_ssl->client & PP2_CLIENT_CERT_SESS);`
`1140`	`1180`	`pp_info->pp2_info.pp2_ssl_info.cert_verified = !pp2_tlv_ssl->verify;`
`1141`	`1181`
`1142`	`1182`	`pp2_tlvs_ssl_len = pp2_tlv_len - sizeof(pp2_tlv_ssl->client) - sizeof(pp2_tlv_ssl->verify);`
`1143`		`- while (pp2_sub_tlv_offset < pp2_tlvs_ssl_len)`
	`1183`	`+ while (pp2_sub_tlv_offset + sizeof_pp2_tlv_t <= pp2_tlvs_ssl_len)`
`1144`	`1184`	`{`
`1145`	`1185`	`const pp2_tlv_t pp2_sub_tlv_ssl = (const pp2_tlv_t) ((const uint8_t*) pp2_tlv_ssl->sub_tlv + pp2_sub_tlv_offset);`
`1146`	`1186`	`uint16_t pp2_sub_tlv_ssl_len = pp2_sub_tlv_ssl->length_hi << 8 \| pp2_sub_tlv_ssl->length_lo;`
	`1187`	`+ if ((uint32_t) sizeof_pp2_tlv_t + pp2_sub_tlv_ssl_len > (uint32_t)(pp2_tlvs_ssl_len - pp2_sub_tlv_offset))`
	`1188`	`+ {`
	`1189`	`+ return -ERR_PP2_TYPE_SSL;`
	`1190`	`+ }`
	`1191`	`+ if (pp2_sub_tlv_ssl->type == PP2_SUBTYPE_SSL_VERSION)`
	`1192`	`+ {`
	`1193`	`+ tlv_ssl_version_found = 1;`
	`1194`	`+ }`
`1147`	`1195`	`switch (pp2_sub_tlv_ssl->type)`
`1148`	`1196`	`{`
`1149`	`1197`	`case PP2_SUBTYPE_SSL_VERSION: /* US-ASCII */`
`1150`		`- tlv_ssl_version_found = 1;`
`1151`	`1198`	`case PP2_SUBTYPE_SSL_CIPHER: /* US-ASCII */`
`1152`	`1199`	`case PP2_SUBTYPE_SSL_SIG_ALG: /* US-ASCII */`
`1153`	`1200`	`case PP2_SUBTYPE_SSL_KEY_ALG: /* US-ASCII */`
`@@ -1171,7 +1218,7 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1171`	`1218`
`1172`	`1219`	`pp2_sub_tlv_offset += sizeof_pp2_tlv_t + pp2_sub_tlv_ssl_len;`
`1173`	`1220`	`}`
`1174`		`- if (pp2_sub_tlv_offset > pp2_tlvs_ssl_len \|\| (pp_info->pp2_info.pp2_ssl_info.ssl && !tlv_ssl_version_found))`
	`1221`	`+ if (pp2_sub_tlv_offset != pp2_tlvs_ssl_len \|\| (pp_info->pp2_info.pp2_ssl_info.ssl && !tlv_ssl_version_found))`
`1175`	`1222`	`{`
`1176`	`1223`	`return -ERR_PP2_TYPE_SSL;`
`1177`	`1224`	`}`
`@@ -1213,8 +1260,7 @@ static int32_t pp2_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1213`	`1260`	`/* Connection is done through Private Link service */`
`1214`	`1261`	`if (pp2_tlv_azure->type == PP2_SUBTYPE_AZURE_PRIVATEENDPOINT_LINKID) /* 32-bit number */`
`1215`	`1262`	`{`
`1216`		`- pp2_tlv_t *tlv = tlv_new(pp2_tlv->type, pp2_tlv_len, pp2_tlv->value);`
`1217`		`- if (!tlv \|\| !tlv_array_append_tlv(&pp_info->pp2_info.tlv_array, tlv))`
	`1263`	`+ if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
`1218`	`1264`	`{`
`1219`	`1265`	`return -ERR_HEAP_ALLOC;`
`1220`	`1266`	`}`
`@@ -1248,15 +1294,15 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1248`	`1294`	`char src_port_str[6] = { 0 };`
`1249`	`1295`	`char dst_port_str[6] = { 0 };`
`1250`	`1296`
`1251`		`- memcpy(block, buffer, buffer_length < PP1_MAX_LENGTH ? buffer_length : PP1_MAX_LENGTH);`
	`1297`	`+ memcpy(block, buffer, buffer_length < PP1_MAX_LENGTH - 1 ? buffer_length : PP1_MAX_LENGTH - 1);`
`1252`	`1298`
`1253`	`1299`	`block_end = strstr(block, CRLF);`
`1254`	`1300`	`if (!block_end)`
`1255`	`1301`	`{`
`1256`	`1302`	`return -ERR_PP1_CRLF;`
`1257`	`1303`	`}`
`1258`	`1304`	`block_end += strlen(CRLF);`
`1259`		`- pp1_hdr_len = block_end - block;`
	`1305`	`+ pp1_hdr_len = (int32_t)(block_end - block);`
`1260`	`1306`
`1261`	`1307`	`/* PROXY */`
`1262`	`1308`	`if (memcmp(block, "PROXY", 5))`
`@@ -1277,7 +1323,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1277`	`1323`	`if (!inet_family)`
`1278`	`1324`	`{`
`1279`	`1325`	`/* Unknown connection (short form) */`
`1280`		`- if (pp1_hdr_len == 15 \|\| !memcmp(ptr, "UNKNOWN", 7))`
	`1326`	`+ if (pp1_hdr_len == 15 && !memcmp(ptr, "UNKNOWN", 7))`
`1281`	`1327`	`{`
`1282`	`1328`	`pp_info->address_family = ADDR_FAMILY_UNSPEC;`
`1283`	`1329`	`pp_info->transport_protocol = TRANSPORT_PROTOCOL_UNSPEC;`
`@@ -1324,7 +1370,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1324`	`1370`	`{`
`1325`	`1371`	`return sa_family == AF_INET ? -ERR_PP1_IPV4_SRC_IP : -ERR_PP1_IPV6_SRC_IP;`
`1326`	`1372`	`}`
`1327`		`- src_address_length = src_address_end - ptr;`
	`1373`	`+ src_address_length = (uint16_t)(src_address_end - ptr);`
`1328`	`1374`	`memcpy(pp_info->src_addr, ptr, src_address_length);`
`1329`	`1375`	`if (inet_pton(sa_family, pp_info->src_addr, &src_sin_addr) != 1)`
`1330`	`1376`	`{`
`@@ -1345,7 +1391,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1345`	`1391`	`{`
`1346`	`1392`	`return sa_family == AF_INET ? -ERR_PP1_IPV4_DST_IP : -ERR_PP1_IPV6_DST_IP;`
`1347`	`1393`	`}`
`1348`		`- dst_address_length = dst_address_end - ptr;`
	`1394`	`+ dst_address_length = (uint16_t)(dst_address_end - ptr);`
`1349`	`1395`	`memcpy(pp_info->dst_addr, ptr, dst_address_length);`
`1350`	`1396`	`if (inet_pton(sa_family, pp_info->dst_addr, &dst_sin_addr) != 1)`
`1351`	`1397`	`{`
`@@ -1366,7 +1412,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1366`	`1412`	`{`
`1367`	`1413`	`return -ERR_PP1_SRC_PORT;`
`1368`	`1414`	`}`
`1369`		`- src_port_length = src_port_end - ptr;`
	`1415`	`+ src_port_length = (uint16_t)(src_port_end - ptr);`
`1370`	`1416`	`if (src_port_length == 0 \|\| src_port_length > 5)`
`1371`	`1417`	`{`
`1372`	`1418`	`return -ERR_PP1_SRC_PORT;`
`@@ -1391,7 +1437,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1391`	`1437`	`{`
`1392`	`1438`	`return -ERR_PP1_DST_PORT;`
`1393`	`1439`	`}`
`1394`		`- dst_port_length = dst_port_end - ptr;`
	`1440`	`+ dst_port_length = (uint16_t)(dst_port_end - ptr);`
`1395`	`1441`	`if (dst_port_length == 0 \|\| dst_port_length > 5)`
`1396`	`1442`	`{`
`1397`	`1443`	`return -ERR_PP1_DST_PORT;`