Commit 015a4a2a authored by Benjamin Tissoires's avatar Benjamin Tissoires
Browse files

selftests/hid: add tests for hid_hw_raw_request HID-BPF hooks 

We add 3 new tests:
- first, we make sure we can prevent the raw_request to happen
- second, we make sure that we can detect that a given hidraw client
  was actually doing the request, and for that client only, call ourself
  hid_bpf_hw_request(), returning a custom value
- last, we ensure that we can not loop between hooks for
  hid_hw_raw_request() and manual calls to hid_bpf_hw_request() from that
  hook

Link: https://patch.msgid.link/20240626-hid_hw_req_bpf-v2-6-cfd60fb6c79f@kernel.org


Acked-by: default avatarJiri Kosina <jkosina@suse.com>
Signed-off-by: default avatarBenjamin Tissoires <bentiss@kernel.org>
parent 75839101

tools/testing/selftests/hid/hid_bpf.c

+109 −0
Original line number Diff line number Diff line
@@ -470,6 +470,11 @@ static void detach_bpf(FIXTURE_DATA(hid_bpf) * self) 
		close(self->hidraw_fd);

	self->hidraw_fd = 0;



	if (!self->skel)

		return;



	hid__detach(self->skel);



	for (i = 0; i < ARRAY_SIZE(self->hid_links); i++) {

		if (self->hid_links[i])

			bpf_link__destroy(self->hid_links[i]);
@@ -575,6 +580,8 @@ static void load_programs(const struct test_program programs[], 
							 programs[i].name + 4);

	}



	hid__attach(self->skel);



	self->hidraw_fd = open_hidraw(self->dev_id);

	ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw");

}
@@ -919,6 +926,108 @@ TEST_F(hid_bpf, test_hid_user_raw_request_call) 
	ASSERT_EQ(args.data[1], 2);

}



/*

 * Call hid_hw_raw_request against the given uhid device,

 * check that the program is called and prevents the

 * call to uhid.

 */

TEST_F(hid_bpf, test_hid_filter_raw_request_call)

{

	const struct test_program progs[] = {

		{ .name = "hid_test_filter_raw_request" },

	};

	__u8 buf[10] = {0};

	int err;



	LOAD_PROGRAMS(progs);



	/* first check that we did not attach to device_event */



	/* inject one event */

	buf[0] = 1;

	buf[1] = 42;

	uhid_send_event(_metadata, self->uhid_fd, buf, 6);



	/* read the data from hidraw */

	memset(buf, 0, sizeof(buf));

	err = read(self->hidraw_fd, buf, sizeof(buf));

	ASSERT_EQ(err, 6) TH_LOG("read_hidraw");

	ASSERT_EQ(buf[0], 1);

	ASSERT_EQ(buf[1], 42);

	ASSERT_EQ(buf[2], 0) TH_LOG("leftovers_from_previous_test");



	/* now check that our program is preventing hid_hw_raw_request() */



	/* emit hid_hw_raw_request from hidraw */

	/* Get Feature */

	memset(buf, 0, sizeof(buf));

	buf[0] = 0x1; /* Report Number */

	err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf);

	ASSERT_LT(err, 0) TH_LOG("unexpected success while reading HIDIOCGFEATURE: %d", err);

	ASSERT_EQ(errno, 20) TH_LOG("unexpected error code while reading HIDIOCGFEATURE: %d",

				    errno);



	/* remove our bpf program and check that we can now emit commands */



	/* detach the program */

	detach_bpf(self);



	self->hidraw_fd = open_hidraw(self->dev_id);

	ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw");



	err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf);

	ASSERT_GE(err, 0) TH_LOG("error while reading HIDIOCGFEATURE: %d", err);

}



/*

 * Call hid_hw_raw_request against the given uhid device,

 * check that the program is called and can issue the call

 * to uhid and transform the answer.

 */

TEST_F(hid_bpf, test_hid_change_raw_request_call)

{

	const struct test_program progs[] = {

		{ .name = "hid_test_hidraw_raw_request" },

	};

	__u8 buf[10] = {0};

	int err;



	LOAD_PROGRAMS(progs);



	/* emit hid_hw_raw_request from hidraw */

	/* Get Feature */

	memset(buf, 0, sizeof(buf));

	buf[0] = 0x1; /* Report Number */

	err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf);

	ASSERT_EQ(err, 3) TH_LOG("unexpected returned size while reading HIDIOCGFEATURE: %d", err);



	ASSERT_EQ(buf[0], 2);

	ASSERT_EQ(buf[1], 3);

	ASSERT_EQ(buf[2], 4);

}



/*

 * Call hid_hw_raw_request against the given uhid device,

 * check that the program is not making infinite loops.

 */

TEST_F(hid_bpf, test_hid_infinite_loop_raw_request_call)

{

	const struct test_program progs[] = {

		{ .name = "hid_test_infinite_loop_raw_request" },

	};

	__u8 buf[10] = {0};

	int err;



	LOAD_PROGRAMS(progs);



	/* emit hid_hw_raw_request from hidraw */

	/* Get Feature */

	memset(buf, 0, sizeof(buf));

	buf[0] = 0x1; /* Report Number */

	err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf);

	ASSERT_EQ(err, 3) TH_LOG("unexpected returned size while reading HIDIOCGFEATURE: %d", err);

}



/*

 * Attach hid_insert{0,1,2} to the given uhid device,

 * retrieve and open the matching hidraw node,

tools/testing/selftests/hid/progs/hid.c

+79 −0
Original line number Diff line number Diff line
@@ -306,3 +306,82 @@ SEC(".struct_ops.link") 
struct hid_bpf_ops test_insert3 = {

	.hid_device_event = (void *)hid_test_insert3,

};



SEC("?struct_ops/hid_hw_request")

int BPF_PROG(hid_test_filter_raw_request, struct hid_bpf_ctx *hctx, unsigned char reportnum,

	     enum hid_report_type rtype, enum hid_class_request reqtype, __u64 source)

{

	return -20;

}



SEC(".struct_ops.link")

struct hid_bpf_ops test_filter_raw_request = {

	.hid_hw_request = (void *)hid_test_filter_raw_request,

};



static struct file *current_file;



SEC("fentry/hidraw_open")

int BPF_PROG(hidraw_open, struct inode *inode, struct file *file)

{

	current_file = file;

	return 0;

}



SEC("?struct_ops.s/hid_hw_request")

int BPF_PROG(hid_test_hidraw_raw_request, struct hid_bpf_ctx *hctx, unsigned char reportnum,

	     enum hid_report_type rtype, enum hid_class_request reqtype, __u64 source)

{

	__u8 *data = hid_bpf_get_data(hctx, 0 /* offset */, 3 /* size */);

	int ret;



	if (!data)

		return 0; /* EPERM check */



	/* check if the incoming request comes from our hidraw operation */

	if (source == (__u64)current_file) {

		data[0] = reportnum;



		ret = hid_bpf_hw_request(hctx, data, 2, rtype, reqtype);

		if (ret != 2)

			return -1;

		data[0] = reportnum + 1;

		data[1] = reportnum + 2;

		data[2] = reportnum + 3;

		return 3;

	}



	return 0;

}



SEC(".struct_ops.link")

struct hid_bpf_ops test_hidraw_raw_request = {

	.hid_hw_request = (void *)hid_test_hidraw_raw_request,

};



SEC("?struct_ops.s/hid_hw_request")

int BPF_PROG(hid_test_infinite_loop_raw_request, struct hid_bpf_ctx *hctx, unsigned char reportnum,

	     enum hid_report_type rtype, enum hid_class_request reqtype, __u64 source)

{

	__u8 *data = hid_bpf_get_data(hctx, 0 /* offset */, 3 /* size */);

	int ret;



	if (!data)

		return 0; /* EPERM check */



	/* always forward the request as-is to the device, hid-bpf should prevent

	 * infinite loops.

	 */

	data[0] = reportnum;



	ret = hid_bpf_hw_request(hctx, data, 2, rtype, reqtype);

	if (ret == 2)

		return 3;



	return 0;

}



SEC(".struct_ops.link")

struct hid_bpf_ops test_infinite_loop_raw_request = {

	.hid_hw_request = (void *)hid_test_infinite_loop_raw_request,

};