input/hid: Fix bitmap boundary validation
Subsystems (3)
cover input/hid: Fix bitmap boundary validation
It recently became apparent that some of the low-level input and hid helpers lack some form of input validation when associating an event code with their internal capability bitmap, leading to potential memory corruption.
These two patches address two occurrences of that issue, by masking out the top bits of the event code (all capability bitmaps are conveniently sized as power of twos), and spitting out a warning for further debugging.
Marc Zyngier (2):
Input; Sanitize event code before modifying bitmaps
HID: core; Sanitize event code and type before mapping input
drivers/input/input.c | 16 +++++++++++++++- include/linux/hid.h | 19 +++++++++++++++---- 2 files changed, 30 insertions(+), 5 deletions(-)
Signature · 1 line
2.27.0
PATCH 1/2 Input; Sanitize event code before modifying bitmaps
When calling into input_set_capability(), the passed event code is blindly used to set a bit in a number of bitmaps, without checking whether this actually fits the expected size of the bitmap.
This event code can come from a variety of sources, including devices masquerading as input devices, only a bit more "programmable".
Instead of taking the raw event code, sanitize it to the actual bitmap size and output a warning to let the user know.
These checks are, at least in spirit, in keeping with cb222aed03d7 ("Input: add safety guards to input_set_keycode()").
--- drivers/input/input.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-)
drivers/input/input.c +15 -1
@@ -1974,14 +1974,18 @@ EXPORT_SYMBOL(input_get_timestamp);* In addition to setting up corresponding bit in appropriate capability * bitmap the function also adjusts dev->evbit. */ -void input_set_capability (struct input_dev *dev,unsigned int type,unsigned int code) +void input_set_capability (struct input_dev *dev,unsigned int type,unsigned int raw_code) { +unsigned int code = raw_code; +switch (type) {case EV_KEY : + code &=KEY_MAX ;__set_bit (code, dev->keybit);break ;case EV_REL : + code &=REL_MAX ;__set_bit (code, dev->relbit);break ;
@@ -1990,26 +1994,32 @@ void input_set_capability(struct input_dev *dev, unsigned int type, unsigned intif (!dev->absinfo)return ; + code &=ABS_MAX ;__set_bit (code, dev->absbit);break ;case EV_MSC : + code &=MSC_MAX ;__set_bit (code, dev->mscbit);break ;case EV_SW : + code &=SW_MAX ;__set_bit (code, dev->swbit);break ;case EV_LED : + code &=LED_MAX ;__set_bit (code, dev->ledbit);break ;case EV_SND : + code &=SND_MAX ;__set_bit (code, dev->sndbit);break ;case EV_FF : + code &=FF_MAX ;__set_bit (code, dev->ffbit);break ;
@@ -2023,6 +2033,10 @@ void input_set_capability(struct input_dev *dev, unsigned int type, unsigned intreturn ; } +if (unlikely (code != raw_code)) +pr_warn_ratelimited ("%s: Truncated code %d to %d for type %d\n" , + dev->name, raw_code, code, type); +__set_bit (type, dev->evbit); }EXPORT_SYMBOL (input_set_capability);
Signature · 1 line
2.27.0
Dmitry Torokhov
maintainerRe: [PATCH 1/2] Input; Sanitize event code before modifying bitmaps
Hi Marc,
Quoted 26 lines · Marc Zyngier
When calling into
input_set_capability(), the passed event code is blindly used to set a bit in a number of bitmaps, without checking whether this actually fits the expected size of the bitmap.This event code can come from a variety of sources, including devices masquerading as input devices, only a bit more "programmable".
Instead of taking the raw event code, sanitize it to the actual bitmap size and output a warning to let the user know.
These checks are, at least in spirit, in keeping with
cb222aed03d7("Input: add safety guards toinput_set_keycode()").Signed-off-by Marc Zyngier <[email protected]>--- drivers/input/input.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-)drivers/input/input.c +0
-0@@ -1974,14 +1974,18 @@ EXPORT_SYMBOL(input_get_timestamp);* In addition to setting up corresponding bit in appropriate capability * bitmap the function also adjusts dev->evbit.
drivers/input/input.c EXPORT_SYMBOL(input_get_timestamp); · line 1984
Quoted 10 lines
drivers/input/input.c +4
-1*/ -void input_set_capability (struct input_dev *dev,unsigned int type,unsigned int code) +void input_set_capability (struct input_dev *dev,unsigned int type,unsigned int raw_code) { +unsigned int code = raw_code; +switch (type) {case EV_KEY : + code &=KEY_MAX ;__set_bit (code, dev->keybit);
I would much rather prefer we did not simply set some random bits in this case, but instead complained loudly and refused to alter anything.
The function is not exported directly to userspace, so we expect callers to give us sane inputs, and I believe WARN() splash in case of bad inputs would be the best solution here.
Thanks.
Signature · 1 line
Dmitry
Re: [PATCH 1/2] Input; Sanitize event code before modifying bitmaps
Hi Dmitry,
Quoted 47 lines · Dmitry Torokhov
Hi Marc,
Quoted 33 lines · Marc Zyngier
When calling into
input_set_capability(), the passed event code is blindly used to set a bit in a number of bitmaps, without checking whether this actually fits the expected size of the bitmap.This event code can come from a variety of sources, including devices masquerading as input devices, only a bit more "programmable".
Instead of taking the raw event code, sanitize it to the actual bitmap size and output a warning to let the user know.
These checks are, at least in spirit, in keeping with
cb222aed03d7("Input: add safety guards toinput_set_keycode()").Signed-off-by Marc Zyngier <[email protected]>--- drivers/input/input.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-)drivers/input/input.c +0
-0@@ -1974,14 +1974,18 @@ EXPORT_SYMBOL(input_get_timestamp);* In addition to setting up corresponding bit in appropriate capability
* bitmap the function also adjustsdev->evbit.
*/
-voidinput_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
+voidinput_set_capability(struct input_dev *dev, unsigned int type, unsigned int raw_code)
{drivers/input/input.c EXPORT_SYMBOL(input_get_timestamp); · line 1984
Quoted 6 lines
drivers/input/input.c +3
-0+unsigned int code = raw_code; +switch (type) {case EV_KEY : + code &=KEY_MAX ;__set_bit (code, dev->keybit);I would much rather prefer we did not simply set some random bits in this case, but instead complained loudly and refused to alter anything.
Quoted 3 lines
The function is not exported directly to userspace, so we expect callers to give us sane inputs, and I believe
WARN()splash in case of bad inputs would be the best solution here.
Fair enough. I've moved the checking to the HID layer (using hid_map_usage() as the validation primitive), which makes changing input_set_capability() irrelevant.
I'll post v2 shortly in the form of a single patch.
Thanks,
M.
Signature · 1 line
Jazz is not dead. It just smells funny...
PATCH 2/2 HID: core; Sanitize event code and type before mapping input
In reply to Marc ZyngierWhen calling into hid_map_usage(), the passed event code is blindly stored as is, even if it doesn't fit in the associated bitmap.
This event code can come from a variety of sources, including devices masquerading as input devices, only a bit more "programmable".
Instead of taking the raw event code, sanitize it to the actual bitmap size and output a warning to let the user know.
While we're at it, sanitize the hid_usage structure if the type isn't known, conveniently placing a NULL pointer as the bitmap in order to catch unexpected uses.
--- include/linux/hid.h | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-)
include/linux/hid.h +15 -4
@@ -966,9 +966,6 @@ static inline void hid_map_usage(struct hid_input *hidinput, {struct input_dev *input = hidinput->input; - usage->type = type; - usage->code = c; -switch (type) {case EV_ABS : *bit = input->absbit;
@@ -986,7 +983,20 @@ static inline void hid_map_usage(struct hid_input *hidinput, *bit = input->ledbit; *max =LED_MAX ;break ; +default : + *bit =NULL ; + *max =0 ; + usage->code =0 ; + usage->type =0 ; +return ; } + + usage->type = type; + usage->code = c & *max; + +if (unlikely (usage->code != c)) +pr_warn_ratelimited ("%s: Truncated code %d to %d for type %d\n" , + input->name, c, usage->code, type); }/**
@@ -1000,7 +1010,8 @@ static inline void hid_map_usage_clear(struct hid_input *hidinput, __u8 type, __u16 c) {hid_map_usage (hidinput ,usage ,bit ,max ,type ,c ); -clear_bit (c, *bit); +if (*bit) +clear_bit (usage->code, *bit); }/**
Signature · 1 line
2.27.0