lkml.org 
[lkml]   [2018]   [Feb]   [5]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH] [v2] xen: hypercall: fix out-of-bounds memcpy
Date
The legacy hypercall handlers were originally added with
a comment explaining that "copying the argument structures in
HYPERVISOR_event_channel_op() and HYPERVISOR_physdev_op() into the local
variable is sufficiently safe" and only made sure to not write
past the end of the argument structure, the checks in linux/string.h
disagree with that, when link-time optimizations are used:

In function 'memcpy',
inlined from 'pirq_query_unmask' at drivers/xen/fallback.c:53:2,
inlined from '__startup_pirq' at drivers/xen/events/events_base.c:529:2,
inlined from 'restore_pirqs' at drivers/xen/events/events_base.c:1439:3,
inlined from 'xen_irq_resume' at drivers/xen/events/events_base.c:1581:2:
include/linux/string.h:350:3: error: call to '__read_overflow2' declared with attribute error: detected read beyond size of object passed as 2nd parameter
__read_overflow2();
^
make[3]: *** [ccLujFNx.ltrans15.ltrans.o] Error 1
make[3]: Target 'all' not remade because of errors.
lto-wrapper: fatal error: make returned 2 exit status
compilation terminated.
ld: error: lto-wrapper failed

This changes the functions so that each argument is accessed with
exactly the correct length based on the command code.

Fixes: cf47a83fb06e ("xen/hypercall: fix hypercall fallback code for very old hypervisors")
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
---
[v2] use a table lookup instead of a switch/case statement, after
multiple suggestions.
---
drivers/xen/fallback.c | 94 +++++++++++++++++++++-----------------------------
1 file changed, 39 insertions(+), 55 deletions(-)

diff --git a/drivers/xen/fallback.c b/drivers/xen/fallback.c
index b04fb64c5a91..091d45fa4fe6 100644
--- a/drivers/xen/fallback.c
+++ b/drivers/xen/fallback.c
@@ -5,76 +5,60 @@
#include <asm/hypervisor.h>
#include <asm/xen/hypercall.h>

+static const size_t evtchnop_len[] = {
+ [EVTCHNOP_bind_interdomain] = sizeof(struct evtchn_bind_interdomain),
+ [EVTCHNOP_bind_virq] = sizeof(struct evtchn_bind_virq),
+ [EVTCHNOP_bind_pirq] = sizeof(struct evtchn_bind_pirq),
+ [EVTCHNOP_close] = sizeof(struct evtchn_close),
+ [EVTCHNOP_send] = sizeof(struct evtchn_send),
+ [EVTCHNOP_alloc_unbound] = sizeof(struct evtchn_alloc_unbound),
+ [EVTCHNOP_bind_ipi] = sizeof(struct evtchn_bind_ipi),
+ [EVTCHNOP_status] = sizeof(struct evtchn_status),
+ [EVTCHNOP_bind_vcpu] = sizeof(struct evtchn_bind_vcpu),
+ [EVTCHNOP_unmask] = sizeof(struct evtchn_unmask),
+};
+
int xen_event_channel_op_compat(int cmd, void *arg)
{
- struct evtchn_op op;
+ struct evtchn_op op = { .cmd = cmd, };
+ size_t len;
int rc;

- op.cmd = cmd;
- memcpy(&op.u, arg, sizeof(op.u));
- rc = _hypercall1(int, event_channel_op_compat, &op);
-
- switch (cmd) {
- case EVTCHNOP_close:
- case EVTCHNOP_send:
- case EVTCHNOP_bind_vcpu:
- case EVTCHNOP_unmask:
- /* no output */
- break;
+ if (cmd > ARRAY_SIZE(evtchnop_len))
+ return -ENOSYS;

-#define COPY_BACK(eop) \
- case EVTCHNOP_##eop: \
- memcpy(arg, &op.u.eop, sizeof(op.u.eop)); \
- break
-
- COPY_BACK(bind_interdomain);
- COPY_BACK(bind_virq);
- COPY_BACK(bind_pirq);
- COPY_BACK(status);
- COPY_BACK(alloc_unbound);
- COPY_BACK(bind_ipi);
-#undef COPY_BACK
-
- default:
- WARN_ON(rc != -ENOSYS);
- break;
- }
+ len = evtchnop_len[cmd];
+ memcpy(&op.u, arg, len);
+ rc = _hypercall1(int, event_channel_op_compat, &op);
+ memcpy(arg, &op.u, len);

return rc;
}
EXPORT_SYMBOL_GPL(xen_event_channel_op_compat);

+static const size_t physdevop_len[] = {
+ [PHYSDEVOP_IRQ_UNMASK_NOTIFY] = 0,
+ [PHYSDEVOP_irq_status_query] = sizeof(struct physdev_irq_status_query),
+ [PHYSDEVOP_set_iopl] = sizeof(struct physdev_set_iopl),
+ [PHYSDEVOP_set_iobitmap] = sizeof(struct physdev_set_iobitmap),
+ [PHYSDEVOP_apic_read] = sizeof(struct physdev_apic),
+ [PHYSDEVOP_apic_write] = sizeof(struct physdev_apic),
+ [PHYSDEVOP_ASSIGN_VECTOR] = sizeof(struct physdev_irq),
+};
+
int xen_physdev_op_compat(int cmd, void *arg)
{
- struct physdev_op op;
+ struct physdev_op op = { .cmd = cmd, };
+ size_t len;
int rc;

- op.cmd = cmd;
- memcpy(&op.u, arg, sizeof(op.u));
- rc = _hypercall1(int, physdev_op_compat, &op);
-
- switch (cmd) {
- case PHYSDEVOP_IRQ_UNMASK_NOTIFY:
- case PHYSDEVOP_set_iopl:
- case PHYSDEVOP_set_iobitmap:
- case PHYSDEVOP_apic_write:
- /* no output */
- break;
+ if (cmd > ARRAY_SIZE(physdevop_len))
+ return -ENOSYS;

-#define COPY_BACK(pop, fld) \
- case PHYSDEVOP_##pop: \
- memcpy(arg, &op.u.fld, sizeof(op.u.fld)); \
- break
-
- COPY_BACK(irq_status_query, irq_status_query);
- COPY_BACK(apic_read, apic_op);
- COPY_BACK(ASSIGN_VECTOR, irq_op);
-#undef COPY_BACK
-
- default:
- WARN_ON(rc != -ENOSYS);
- break;
- }
+ len = physdevop_len[cmd];
+ memcpy(&op.u, arg, len);
+ rc = _hypercall1(int, physdev_op_compat, &op);
+ memcpy(arg, &op.u, len);

return rc;
}
--
2.9.0
\
 
 \ /
  Last update: 2018-02-05 16:05    [W:0.105 / U:28.784 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site