Skip to contentSkip to conversation

Fix unsigned integer underflow in fd-trans.c

PATCH Applied Shu-Chun Weng 2 participants 6 messages Oct 18, 2019 – Oct 21, 2019

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 Fix unsigned integer underflow in fd-trans.c

In any of these *_for_each_* functions, the last entry in the buffer (so the "remaining length in the buffer" len is equal to the length of the entry nlmsg_len/nla_len/etc) has size that is not a multiple of the alignment, the aligned lengths *_ALIGN(*_len) will be greater than len. Since len is unsigned (size_t), it underflows and the loop will read pass the buffer.

This may manifest as random EINVAL or EOPNOTSUPP error on IO or network system calls.

---
 linux-user/fd-trans.c | 51 +++++++++++++++++++++++++++++++++----------
 1 file changed, 40 insertions(+), 11 deletions(-)
linux-user/fd-trans.c +40 -11
index 60077ce531..9b92386abf 100644
@@ -279,6 +279,7 @@ static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
                                                        (struct nlmsghdr *))
 {
     uint32_t nlmsg_len;
+    uint32_t aligned_nlmsg_len;
     abi_long ret;
 
     while (len > sizeof(struct nlmsghdr)) {
@@ -312,8 +313,13 @@ static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
             break;
         }
         tswap_nlmsghdr(nlh);
-        len -= NLMSG_ALIGN(nlmsg_len);
-        nlh = (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len));
+
+        aligned_nlmsg_len = NLMSG_ALIGN(nlmsg_len);
+        if (aligned_nlmsg_len >= len) {
+            break;
+        }
+        len -= aligned_nlmsg_len;
+        nlh = (struct nlmsghdr *)(((char*)nlh) + aligned_nlmsg_len);
     }
     return 0;
 }
@@ -323,6 +329,7 @@ static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
                                               abi_long (*target_to_host_nlmsg)
                                                        (struct nlmsghdr *))
 {
+    uint32_t aligned_nlmsg_len;
     int ret;
 
     while (len > sizeof(struct nlmsghdr)) {
@@ -349,8 +356,13 @@ static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
                 return ret;
             }
         }
-        len -= NLMSG_ALIGN(nlh->nlmsg_len);
-        nlh = (struct nlmsghdr *)(((char *)nlh) + NLMSG_ALIGN(nlh->nlmsg_len));
+
+        aligned_nlmsg_len = NLMSG_ALIGN(nlh->nlmsg_len);
+        if (aligned_nlmsg_len >= len) {
+            break;
+        }
+        len -= aligned_nlmsg_len;
+        nlh = (struct nlmsghdr *)(((char *)nlh) + aligned_nlmsg_len);
     }
     return 0;
 }
@@ -363,6 +375,7 @@ static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
                                                          void *context))
 {
     unsigned short nla_len;
+    unsigned short aligned_nla_len;
     abi_long ret;
 
     while (len > sizeof(struct nlattr)) {
@@ -377,8 +390,13 @@ static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
         if (ret < 0) {
             return ret;
         }
-        len -= NLA_ALIGN(nla_len);
-        nlattr = (struct nlattr *)(((char *)nlattr) + NLA_ALIGN(nla_len));
+
+        aligned_nla_len = NLA_ALIGN(nla_len);
+        if (aligned_nla_len >= len) {
+            break;
+        }
+        len -= aligned_nla_len;
+        nlattr = (struct nlattr *)(((char *)nlattr) + aligned_nla_len);
     }
     return 0;
 }
@@ -389,6 +407,7 @@ static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
                                                         (struct rtattr *))
 {
     unsigned short rta_len;
+    unsigned short aligned_rta_len;
     abi_long ret;
 
     while (len > sizeof(struct rtattr)) {
@@ -403,8 +422,13 @@ static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
         if (ret < 0) {
             return ret;
         }
-        len -= RTA_ALIGN(rta_len);
-        rtattr = (struct rtattr *)(((char *)rtattr) + RTA_ALIGN(rta_len));
+
+        aligned_rta_len = RTA_ALIGN(rta_len);
+        if (aligned_rta_len >= len) {
+            break;
+        }
+        len -= aligned_rta_len;
+        rtattr = (struct rtattr *)(((char *)rtattr) + aligned_rta_len);
     }
     return 0;
 }
@@ -1058,6 +1082,7 @@ static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
                                                abi_long (*target_to_host_rtattr)
                                                         (struct rtattr *))
 {
+    unsigned short aligned_rta_len;
     abi_long ret;
 
     while (len >= sizeof(struct rtattr)) {
@@ -1071,9 +1096,13 @@ static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
         if (ret < 0) {
             return ret;
         }
-        len -= RTA_ALIGN(rtattr->rta_len);
-        rtattr = (struct rtattr *)(((char *)rtattr) +
-                 RTA_ALIGN(rtattr->rta_len));
+
+        aligned_rta_len = RTA_ALIGN(rtattr->rta_len);
+        if (aligned_rta_len >= len) {
+            break;
+        }
+        len -= aligned_rta_len;
+        rtattr = (struct rtattr *)(((char *)rtattr) + aligned_rta_len);
     }
     return 0;
 }
Signature · 1 line
2.23.0.866.gb869b98d4c-goog
#1 lore raw

Le 18/10/2019 à 02:19, Shu-Chun Weng a écrit :

Quoted 33 lines

In any of these *_for_each_* functions, the last entry in the buffer (so the "remaining length in the buffer" len is equal to the length of the entry nlmsg_len/nla_len/etc) has size that is not a multiple of the alignment, the aligned lengths *_ALIGN(*_len) will be greater than len. Since len is unsigned (size_t), it underflows and the loop will read pass the buffer.

This may manifest as random EINVAL or EOPNOTSUPP error on IO or network system calls.

---
 linux-user/fd-trans.c | 51 +++++++++++++++++++++++++++++++++----------
 1 file changed, 40 insertions(+), 11 deletions(-)
linux-user/fd-trans.c +1 -2
index 60077ce531..9b92386abf 100644
@@ -279,6 +279,7 @@ static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
                                                        (struct nlmsghdr *))
 {
     uint32_t nlmsg_len;
+    uint32_t aligned_nlmsg_len;
     abi_long ret;
 
     while (len > sizeof(struct nlmsghdr)) {
@@ -312,8 +313,13 @@ static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
             break;
         }
         tswap_nlmsghdr(nlh);
-        len -= NLMSG_ALIGN(nlmsg_len);
-        nlh = (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len));

linux-user/fd-trans.c static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh, · line 325

Quoted 10 lines
linux-user/fd-trans.c +7 -0
+
+        aligned_nlmsg_len = NLMSG_ALIGN(nlmsg_len);
+        if (aligned_nlmsg_len >= len) {
+            break;
+        }
+        len -= aligned_nlmsg_len;
+        nlh = (struct nlmsghdr *)(((char*)nlh) + aligned_nlmsg_len);
     }
     return 0;
 }

Nice catch.

But the first "if" in the loop is already here for that, we only need to fix it with something like that in all the for_each functions:

@@ -285,7 +285,7 @@ static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,

         nlmsg_len = nlh->nlmsg_len;
         if (nlmsg_len < sizeof(struct nlmsghdr) ||
-            nlmsg_len > len) {
+            NLMSG_ALIGN(nlmsg_len) > len) {
             break;
         }

Thanks,
Laurent

#2 lore raw

That does prevent the integer underflow, but it also changes the behavior and I don't think the new behavior is desirable.

If the extra payload has a smaller alignment than the header, it makes sense for the user program to generate a nlmsg_len that is not a multiple of the alignment. When it's the last entry, the new condition will it because NLMSG_ALIGN pushes the aligned length over len, yet the single entry processing function won't actually read beyond the buffer as long as it's bounded by nlmsg_len.

Shu-Chun

Quoted 70 lines · Laurent Vivier
Quoted 1 line · Shu-Chun Weng

In any of these *_for_each_* functions, the last entry in the buffer

(so the

Quoted 3 lines

"remaining length in the buffer" len is equal to the length of the entry nlmsg_len/nla_len/etc) has size that is not a multiple of the alignment, the aligned lengths *_ALIGN(*_len) will be greater than

len.

linux-user/fd-trans.c static abi_long host_to_target_for_each_nlmsg(struct

Quoted 16 lines

Since len is unsigned (size_t), it underflows and the loop will read pass the buffer.

This may manifest as random EINVAL or EOPNOTSUPP error on IO or network system calls.

---
 linux-user/fd-trans.c | 51 +++++++++++++++++++++++++++++++++----------
 1 file changed, 40 insertions(+), 11 deletions(-)
linux-user/fd-trans.c +0 -0
index 60077ce531..9b92386abf 100644
@@ -279,6 +279,7 @@ static abi_long host_to_target_for_each_nlmsg(struct

nlmsghdr *nlh,

linux-user/fd-trans.c static abi_long host_to_target_for_each_nlmsg(struct · line 279

Quoted 1 line
linux-user/fd-trans.c +0 -0
                                                        (struct nlmsghdr

*))

linux-user/fd-trans.c static abi_long

Quoted 7 lines
linux-user/fd-trans.c +1 -0
 {
     uint32_t nlmsg_len;
+    uint32_t aligned_nlmsg_len;
     abi_long ret;
 
     while (len > sizeof(struct nlmsghdr)) {
@@ -312,8 +313,13 @@ static abi_long

host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,

linux-user/fd-trans.c static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,

Quoted 5 lines
linux-user/fd-trans.c +0 -2
             break;
         }
         tswap_nlmsghdr(nlh);
-        len -= NLMSG_ALIGN(nlmsg_len);
-        nlh = (struct nlmsghdr *)(((char*)nlh) +

NLMSG_ALIGN(nlmsg_len));

linux-user/fd-trans.c static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh, · line 325

Quoted 10 lines
linux-user/fd-trans.c +7 -0
+
+        aligned_nlmsg_len = NLMSG_ALIGN(nlmsg_len);
+        if (aligned_nlmsg_len >= len) {
+            break;
+        }
+        len -= aligned_nlmsg_len;
+        nlh = (struct nlmsghdr *)(((char*)nlh) + aligned_nlmsg_len);
     }
     return 0;
 }

Nice catch.

But the first "if" in the loop is already here for that, we only need to fix it with something like that in all the for_each functions:

(quoted diff) +1 -1
@@ -285,7 +285,7 @@ static abi_long host_to_target_for_each_nlmsg(struct
 nlmsghdr *nlh,
 
         nlmsg_len = nlh->nlmsg_len;
         if (nlmsg_len < sizeof(struct nlmsghdr) ||
-            nlmsg_len > len) {
+            NLMSG_ALIGN(nlmsg_len) > len) {
             break;
         }

Thanks,
Laurent

#3 lore raw
In reply to Laurent Vivier

(Re-sending to the list because I forgot to turn off HTML before and it was bounced.)

That does prevent the integer underflow, but it also changes the behavior and I don't think the new behavior is desirable.

If the extra payload has a smaller alignment than the header, it makes sense for the user program to generate a nlmsg_len that is not a multiple of the alignment. When it's the last entry, the new condition will it because NLMSG_ALIGN pushes the aligned length over len, yet the single entry processing function won't actually read beyond the buffer as long as it's bounded by nlmsg_len.

Shu-Chun

Quoted 64 lines · Laurent Vivier
Quoted 33 lines · Shu-Chun Weng

In any of these *_for_each_* functions, the last entry in the buffer (so the "remaining length in the buffer" len is equal to the length of the entry nlmsg_len/nla_len/etc) has size that is not a multiple of the alignment, the aligned lengths *_ALIGN(*_len) will be greater than len. Since len is unsigned (size_t), it underflows and the loop will read pass the buffer.

This may manifest as random EINVAL or EOPNOTSUPP error on IO or network system calls.

---
 linux-user/fd-trans.c | 51 +++++++++++++++++++++++++++++++++----------
 1 file changed, 40 insertions(+), 11 deletions(-)
linux-user/fd-trans.c +1 -2
index 60077ce531..9b92386abf 100644
@@ -279,6 +279,7 @@ static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
                                                        (struct nlmsghdr *))
 {
     uint32_t nlmsg_len;
+    uint32_t aligned_nlmsg_len;
     abi_long ret;
 
     while (len > sizeof(struct nlmsghdr)) {
@@ -312,8 +313,13 @@ static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
             break;
         }
         tswap_nlmsghdr(nlh);
-        len -= NLMSG_ALIGN(nlmsg_len);
-        nlh = (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len));

linux-user/fd-trans.c static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh, · line 325

Quoted 10 lines
linux-user/fd-trans.c +7 -0
+
+        aligned_nlmsg_len = NLMSG_ALIGN(nlmsg_len);
+        if (aligned_nlmsg_len >= len) {
+            break;
+        }
+        len -= aligned_nlmsg_len;
+        nlh = (struct nlmsghdr *)(((char*)nlh) + aligned_nlmsg_len);
     }
     return 0;
 }

Nice catch.

But the first "if" in the loop is already here for that, we only need to fix it with something like that in all the for_each functions:

(quoted diff) +1 -1
@@ -285,7 +285,7 @@ static abi_long host_to_target_for_each_nlmsg(struct
 nlmsghdr *nlh,
 
         nlmsg_len = nlh->nlmsg_len;
         if (nlmsg_len < sizeof(struct nlmsghdr) ||
-            nlmsg_len > len) {
+            NLMSG_ALIGN(nlmsg_len) > len) {
             break;
         }

Thanks,
Laurent

Reviewed-by
#4 lore raw

Le 18/10/2019 à 20:27, Shu-Chun Weng a écrit :

Quoted 6 lines

(Re-sending to the list because I forgot to turn off HTML before and it was bounced.)

That does prevent the integer underflow, but it also changes the behavior and I don't think the new behavior is desirable.

Quoted 6 lines

If the extra payload has a smaller alignment than the header, it makes sense for the user program to generate a nlmsg_len that is not a multiple of the alignment. When it's the last entry, the new condition will it because NLMSG_ALIGN pushes the aligned length over len, yet the single entry processing function won't actually read beyond the buffer as long as it's bounded by nlmsg_len.

Yes, you're right.

So I think your patch is correct.

Thanks,
Laurent

#5 lore raw
In reply to Shu-Chun Weng

Le 18/10/2019 à 02:19, Shu-Chun Weng a écrit :

Quoted 131 lines

In any of these *_for_each_* functions, the last entry in the buffer (so the "remaining length in the buffer" len is equal to the length of the entry nlmsg_len/nla_len/etc) has size that is not a multiple of the alignment, the aligned lengths *_ALIGN(*_len) will be greater than len. Since len is unsigned (size_t), it underflows and the loop will read pass the buffer.

This may manifest as random EINVAL or EOPNOTSUPP error on IO or network system calls.

---
 linux-user/fd-trans.c | 51 +++++++++++++++++++++++++++++++++----------
 1 file changed, 40 insertions(+), 11 deletions(-)
linux-user/fd-trans.c +33 -11
index 60077ce531..9b92386abf 100644
@@ -279,6 +279,7 @@ static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
                                                        (struct nlmsghdr *))
 {
     uint32_t nlmsg_len;
+    uint32_t aligned_nlmsg_len;
     abi_long ret;
 
     while (len > sizeof(struct nlmsghdr)) {
@@ -312,8 +313,13 @@ static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
             break;
         }
         tswap_nlmsghdr(nlh);
-        len -= NLMSG_ALIGN(nlmsg_len);
-        nlh = (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len));
+
+        aligned_nlmsg_len = NLMSG_ALIGN(nlmsg_len);
+        if (aligned_nlmsg_len >= len) {
+            break;
+        }
+        len -= aligned_nlmsg_len;
+        nlh = (struct nlmsghdr *)(((char*)nlh) + aligned_nlmsg_len);
     }
     return 0;
 }
@@ -323,6 +329,7 @@ static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
                                               abi_long (*target_to_host_nlmsg)
                                                        (struct nlmsghdr *))
 {
+    uint32_t aligned_nlmsg_len;
     int ret;
 
     while (len > sizeof(struct nlmsghdr)) {
@@ -349,8 +356,13 @@ static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
                 return ret;
             }
         }
-        len -= NLMSG_ALIGN(nlh->nlmsg_len);
-        nlh = (struct nlmsghdr *)(((char *)nlh) + NLMSG_ALIGN(nlh->nlmsg_len));
+
+        aligned_nlmsg_len = NLMSG_ALIGN(nlh->nlmsg_len);
+        if (aligned_nlmsg_len >= len) {
+            break;
+        }
+        len -= aligned_nlmsg_len;
+        nlh = (struct nlmsghdr *)(((char *)nlh) + aligned_nlmsg_len);
     }
     return 0;
 }
@@ -363,6 +375,7 @@ static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
                                                          void *context))
 {
     unsigned short nla_len;
+    unsigned short aligned_nla_len;
     abi_long ret;
 
     while (len > sizeof(struct nlattr)) {
@@ -377,8 +390,13 @@ static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
         if (ret < 0) {
             return ret;
         }
-        len -= NLA_ALIGN(nla_len);
-        nlattr = (struct nlattr *)(((char *)nlattr) + NLA_ALIGN(nla_len));
+
+        aligned_nla_len = NLA_ALIGN(nla_len);
+        if (aligned_nla_len >= len) {
+            break;
+        }
+        len -= aligned_nla_len;
+        nlattr = (struct nlattr *)(((char *)nlattr) + aligned_nla_len);
     }
     return 0;
 }
@@ -389,6 +407,7 @@ static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
                                                         (struct rtattr *))
 {
     unsigned short rta_len;
+    unsigned short aligned_rta_len;
     abi_long ret;
 
     while (len > sizeof(struct rtattr)) {
@@ -403,8 +422,13 @@ static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
         if (ret < 0) {
             return ret;
         }
-        len -= RTA_ALIGN(rta_len);
-        rtattr = (struct rtattr *)(((char *)rtattr) + RTA_ALIGN(rta_len));
+
+        aligned_rta_len = RTA_ALIGN(rta_len);
+        if (aligned_rta_len >= len) {
+            break;
+        }
+        len -= aligned_rta_len;
+        rtattr = (struct rtattr *)(((char *)rtattr) + aligned_rta_len);
     }
     return 0;
 }
@@ -1058,6 +1082,7 @@ static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
                                                abi_long (*target_to_host_rtattr)
                                                         (struct rtattr *))
 {
+    unsigned short aligned_rta_len;
     abi_long ret;
 
     while (len >= sizeof(struct rtattr)) {
@@ -1071,9 +1096,13 @@ static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
         if (ret < 0) {
             return ret;
         }
-        len -= RTA_ALIGN(rtattr->rta_len);
-        rtattr = (struct rtattr *)(((char *)rtattr) +
-                 RTA_ALIGN(rtattr->rta_len));

linux-user/fd-trans.c static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr, · line 1108

Quoted 10 lines
linux-user/fd-trans.c +7 -0
+
+        aligned_rta_len = RTA_ALIGN(rtattr->rta_len);
+        if (aligned_rta_len >= len) {
+            break;
+        }
+        len -= aligned_rta_len;
+        rtattr = (struct rtattr *)(((char *)rtattr) + aligned_rta_len);
     }
     return 0;
 }

Applied to my linux-user branch.

Thanks,
Laurent