mirror of
https://github.com/Divested-Mobile/DivestOS-Build.git
synced 2024-10-01 01:35:54 -04:00
245 lines
8.5 KiB
Diff
245 lines
8.5 KiB
Diff
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
|
From: Sadaf Ebrahimi <sadafebrahimi@google.com>
|
|
Date: Wed, 15 Jun 2022 04:14:33 +0000
|
|
Subject: [PATCH] Prevent more integer overflows
|
|
|
|
Bug: http://b/219942275
|
|
Change-Id: I7489f59564e0053a4a46bb8c362f7c36ab0b3c9d
|
|
Merged-In: Ic5c8087ee64e6faafcf013cef9536c042eb8a09d
|
|
(cherry picked from commit 15a1f35dddde9c1a0a626972349a59642abd345a)
|
|
Merged-In: I7489f59564e0053a4a46bb8c362f7c36ab0b3c9d
|
|
---
|
|
lib/xmlparse.c | 152 ++++++++++++++++++++++++++++++++++++++++++++++++-
|
|
1 file changed, 150 insertions(+), 2 deletions(-)
|
|
|
|
diff --git a/lib/xmlparse.c b/lib/xmlparse.c
|
|
index 0e57538a..7b25a0b8 100644
|
|
--- a/lib/xmlparse.c
|
|
+++ b/lib/xmlparse.c
|
|
@@ -2784,18 +2784,54 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
|
|
|
|
/* get the attributes from the tokenizer */
|
|
n = XmlGetAttributes(enc, attStr, attsSize, atts);
|
|
+
|
|
+ /* Detect and prevent integer overflow */
|
|
+ if (n > INT_MAX - nDefaultAtts) {
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+
|
|
if (n + nDefaultAtts > attsSize) {
|
|
int oldAttsSize = attsSize;
|
|
ATTRIBUTE *temp;
|
|
#ifdef XML_ATTR_INFO
|
|
XML_AttrInfo *temp2;
|
|
#endif
|
|
+
|
|
+ /* Detect and prevent integer overflow */
|
|
+ if ((nDefaultAtts > INT_MAX - INIT_ATTS_SIZE)
|
|
+ || (n > INT_MAX - (nDefaultAtts + INIT_ATTS_SIZE))) {
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+
|
|
attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
|
|
+
|
|
+ /* Detect and prevent integer overflow.
|
|
+ * The preprocessor guard addresses the "always false" warning
|
|
+ * from -Wtype-limits on platforms where
|
|
+ * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
|
|
+#if UINT_MAX >= SIZE_MAX
|
|
+ if ((unsigned)attsSize > (size_t)(-1) / sizeof(ATTRIBUTE)) {
|
|
+ attsSize = oldAttsSize;
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+#endif
|
|
+
|
|
temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
|
|
if (temp == NULL)
|
|
return XML_ERROR_NO_MEMORY;
|
|
atts = temp;
|
|
#ifdef XML_ATTR_INFO
|
|
+ /* Detect and prevent integer overflow.
|
|
+ * The preprocessor guard addresses the "always false" warning
|
|
+ * from -Wtype-limits on platforms where
|
|
+ * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
|
|
+#if UINT_MAX >= SIZE_MAX
|
|
+ if ((unsigned)attsSize > (size_t)(-1) / sizeof(XML_AttrInfo)) {
|
|
+ attsSize = oldAttsSize;
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+#endif
|
|
+
|
|
temp2 = (XML_AttrInfo *)REALLOC((void *)attInfo, attsSize * sizeof(XML_AttrInfo));
|
|
if (temp2 == NULL)
|
|
return XML_ERROR_NO_MEMORY;
|
|
@@ -3073,9 +3109,31 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
|
|
tagNamePtr->prefixLen = prefixLen;
|
|
for (i = 0; localPart[i++];)
|
|
; /* i includes null terminator */
|
|
+
|
|
+ /* Detect and prevent integer overflow */
|
|
+ if (binding->uriLen > INT_MAX - prefixLen
|
|
+ || i > INT_MAX - (binding->uriLen + prefixLen)) {
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+
|
|
n = i + binding->uriLen + prefixLen;
|
|
if (n > binding->uriAlloc) {
|
|
TAG *p;
|
|
+
|
|
+ /* Detect and prevent integer overflow */
|
|
+ if (n > INT_MAX - EXPAND_SPARE) {
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+ /* Detect and prevent integer overflow.
|
|
+ * The preprocessor guard addresses the "always false" warning
|
|
+ * from -Wtype-limits on platforms where
|
|
+ * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
|
|
+#if UINT_MAX >= SIZE_MAX
|
|
+ if ((unsigned)(n + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+#endif
|
|
+
|
|
uri = (XML_Char *)MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));
|
|
if (!uri)
|
|
return XML_ERROR_NO_MEMORY;
|
|
@@ -3176,6 +3234,21 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
|
|
if (freeBindingList) {
|
|
b = freeBindingList;
|
|
if (len > b->uriAlloc) {
|
|
+ /* Detect and prevent integer overflow */
|
|
+ if (len > INT_MAX - EXPAND_SPARE) {
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+
|
|
+ /* Detect and prevent integer overflow.
|
|
+ * The preprocessor guard addresses the "always false" warning
|
|
+ * from -Wtype-limits on platforms where
|
|
+ * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
|
|
+#if UINT_MAX >= SIZE_MAX
|
|
+ if ((unsigned)(len + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+#endif
|
|
+
|
|
XML_Char *temp = (XML_Char *)REALLOC(b->uri,
|
|
sizeof(XML_Char) * (len + EXPAND_SPARE));
|
|
if (temp == NULL)
|
|
@@ -3189,6 +3262,21 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
|
|
b = (BINDING *)MALLOC(sizeof(BINDING));
|
|
if (!b)
|
|
return XML_ERROR_NO_MEMORY;
|
|
+
|
|
+ /* Detect and prevent integer overflow */
|
|
+ if (len > INT_MAX - EXPAND_SPARE) {
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+ /* Detect and prevent integer overflow.
|
|
+ * The preprocessor guard addresses the "always false" warning
|
|
+ * from -Wtype-limits on platforms where
|
|
+ * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
|
|
+#if UINT_MAX >= SIZE_MAX
|
|
+ if ((unsigned)(len + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
|
|
+ return XML_ERROR_NO_MEMORY;
|
|
+ }
|
|
+#endif
|
|
+
|
|
b->uri = (XML_Char *)MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));
|
|
if (!b->uri) {
|
|
FREE(b);
|
|
@@ -5441,7 +5529,24 @@ defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
|
|
}
|
|
else {
|
|
DEFAULT_ATTRIBUTE *temp;
|
|
+
|
|
+ /* Detect and prevent integer overflow */
|
|
+ if (type->allocDefaultAtts > INT_MAX / 2) {
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
int count = type->allocDefaultAtts * 2;
|
|
+
|
|
+ /* Detect and prevent integer overflow.
|
|
+ * The preprocessor guard addresses the "always false" warning
|
|
+ * from -Wtype-limits on platforms where
|
|
+ * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
|
|
+#if UINT_MAX >= SIZE_MAX
|
|
+ if ((unsigned)count > (size_t)(-1) / sizeof(DEFAULT_ATTRIBUTE)) {
|
|
+ return 0;
|
|
+ }
|
|
+#endif
|
|
+
|
|
temp = (DEFAULT_ATTRIBUTE *)
|
|
REALLOC(type->defaultAtts, (count * sizeof(DEFAULT_ATTRIBUTE)));
|
|
if (temp == NULL)
|
|
@@ -6070,8 +6175,20 @@ lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
|
|
/* check for overflow (table is half full) */
|
|
if (table->used >> (table->power - 1)) {
|
|
unsigned char newPower = table->power + 1;
|
|
+
|
|
+ /* Detect and prevent invalid shift */
|
|
+ if (newPower >= sizeof(unsigned long) * 8 /* bits per byte */) {
|
|
+ return NULL;
|
|
+ }
|
|
+
|
|
size_t newSize = (size_t)1 << newPower;
|
|
unsigned long newMask = (unsigned long)newSize - 1;
|
|
+
|
|
+ /* Detect and prevent integer overflow */
|
|
+ if (newSize > (size_t)(-1) / sizeof(NAMED *)) {
|
|
+ return NULL;
|
|
+ }
|
|
+
|
|
size_t tsize = newSize * sizeof(NAMED *);
|
|
NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);
|
|
if (!newV)
|
|
@@ -6362,6 +6479,20 @@ nextScaffoldPart(XML_Parser parser)
|
|
if (dtd->scaffCount >= dtd->scaffSize) {
|
|
CONTENT_SCAFFOLD *temp;
|
|
if (dtd->scaffold) {
|
|
+ /* Detect and prevent integer overflow */
|
|
+ if (dtd->scaffSize > UINT_MAX / 2u) {
|
|
+ return -1;
|
|
+ }
|
|
+ /* Detect and prevent integer overflow.
|
|
+ * The preprocessor guard addresses the "always false" warning
|
|
+ * from -Wtype-limits on platforms where
|
|
+ * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
|
|
+#if UINT_MAX >= SIZE_MAX
|
|
+ if (dtd->scaffSize > (size_t)(-1) / 2u / sizeof(CONTENT_SCAFFOLD)) {
|
|
+ return -1;
|
|
+ }
|
|
+#endif
|
|
+
|
|
temp = (CONTENT_SCAFFOLD *)
|
|
REALLOC(dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
|
|
if (temp == NULL)
|
|
@@ -6438,8 +6569,25 @@ build_model (XML_Parser parser)
|
|
XML_Content *ret;
|
|
XML_Content *cpos;
|
|
XML_Char * str;
|
|
- int allocsize = (dtd->scaffCount * sizeof(XML_Content)
|
|
- + (dtd->contentStringLen * sizeof(XML_Char)));
|
|
+ /* Detect and prevent integer overflow.
|
|
+ * The preprocessor guard addresses the "always false" warning
|
|
+ * from -Wtype-limits on platforms where
|
|
+ * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
|
|
+#if UINT_MAX >= SIZE_MAX
|
|
+ if (dtd->scaffCount > (size_t)(-1) / sizeof(XML_Content)) {
|
|
+ return NULL;
|
|
+ }
|
|
+ if (dtd->contentStringLen > (size_t)(-1) / sizeof(XML_Char)) {
|
|
+ return NULL;
|
|
+ }
|
|
+#endif
|
|
+ if (dtd->scaffCount * sizeof(XML_Content)
|
|
+ > (size_t)(-1) - dtd->contentStringLen * sizeof(XML_Char)) {
|
|
+ return NULL;
|
|
+ }
|
|
+
|
|
+ const size_t allocsize = (dtd->scaffCount * sizeof(XML_Content)
|
|
+ + (dtd->contentStringLen * sizeof(XML_Char)));
|
|
|
|
ret = (XML_Content *)MALLOC(allocsize);
|
|
if (!ret)
|