All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH v2 0/2] tpm: Track the response read position internally
@ 2026-11-20 12:16 Rustam Mustafin
  2026-11-20 12:16 ` [PATCH v2 1/2] " Rustam Mustafin
  2026-11-20 12:16 ` [PATCH v2 2/2] selftests: tpm2: test that io_uring reads ignore the file offset Rustam Mustafin
  0 siblings, 2 replies; 6+ messages in thread
From: Rustam Mustafin @ 2026-11-20 12:16 UTC (permalink / raw)
  To: Peter Huewe, Jarkko Sakkinen
  Cc: Jason Gunthorpe, Shuah Khan, Jaewon Yang, linux-integrity,
	linux-kselftest, linux-kernel, Rustam Mustafin

tpm_common_read() uses *off as an index into priv->data_buffer.
nonseekable_open() makes pread() fail, but an IORING_OP_READ request
still reaches tpm_common_read() through loop_rw_iter() with *off set
to sqe->off, and a plain read() racing a write() reaches it with a
stale f_pos. Both allow out-of-bounds reads and zeroing of kernel
memory.

Patch 1 moves the read position into struct file_priv, under
buffer_mutex, and ignores *off.

Patch 2 adds a kselftest: an io_uring read with sqe->off inside the
response buffer must return the whole response from its start.

Blocking io_uring, suggested in the v1 review, is no longer needed for
safety with patch 1; I discuss it in the v1 thread.

Tested in a QEMU guest with swtpm and KASAN: the tpm2 selftests pass
with patch 1, and the new one fails without it.
Claude Opus 5.5 was used in preparing this series.

Changes in v2:
- commit message reworked per review, read()/write() race trace added
- add a kselftest

v1: https://lore.kernel.org/all/20261117104838.2650999-1-rmustafin@cloudlinux.com/

Rustam Mustafin (2):
  tpm: Track the response read position internally
  selftests: tpm2: test that io_uring reads ignore the file offset

 drivers/char/tpm/tpm-dev-common.c        |  11 +-
 drivers/char/tpm/tpm-dev.h               |   1 +
 tools/testing/selftests/tpm2/.gitignore  |   1 +
 tools/testing/selftests/tpm2/Makefile    |   4 +
 tools/testing/selftests/tpm2/tpm_uring.c | 131 +++++++++++++++++++++++
 5 files changed, 143 insertions(+), 5 deletions(-)
 create mode 100644 tools/testing/selftests/tpm2/tpm_uring.c


base-commit: 666539eecdf4db623f5e3c3e55cf9f2dfad24aa4
-- 
2.52.0


^ permalink raw reply	[flat|nested] 6+ messages in thread

* [PATCH v2 1/2] tpm: Track the response read position internally
  2026-11-20 12:16 [PATCH v2 0/2] tpm: Track the response read position internally Rustam Mustafin
@ 2026-11-20 12:16 ` Rustam Mustafin
  2026-11-20 12:27   ` Jarkko Sakkinen
  2026-11-20 12:16 ` [PATCH v2 2/2] selftests: tpm2: test that io_uring reads ignore the file offset Rustam Mustafin
  1 sibling, 1 reply; 6+ messages in thread
From: Rustam Mustafin @ 2026-11-20 12:16 UTC (permalink / raw)
  To: Peter Huewe, Jarkko Sakkinen
  Cc: Jason Gunthorpe, Shuah Khan, Jaewon Yang, linux-integrity,
	linux-kselftest, linux-kernel, Rustam Mustafin, stable

tpm_common_read() indexes data_buffer with the caller supplied *off.
A read issued through io_uring reaches the driver with that offset:
loop_rw_iter() passes &ki_pos to ->read(). This allows out-of-bounds
reads and zeroing of kernel memory:

  BUG: KASAN: slab-out-of-bounds in _copy_to_user+0x4b/0x70
  Read of size 16 by task iou-wrk-148/149
  Call Trace:
   _copy_to_user+0x4b/0x70
   tpm_common_read+0x16e/0x2c0
   loop_rw_iter+0x235/0x5a0
   __io_read+0xc6e/0x11a0
   io_read+0x8a/0x180

A plain read() racing a write() reaches the same access: read()
samples f_pos before taking buffer_mutex, so it can consume a new
response from the offset left by the previous one:

  BUG: KASAN: slab-out-of-bounds in _copy_to_user+0x4b/0x70
  Read of size 75 by task trigger/151
  Call Trace:
   _copy_to_user+0x4b/0x70
   tpm_common_read+0x16e/0x2c0
   vfs_read+0x189/0xc00
   ksys_read+0xf9/0x1d0

Replace *off with a read_pos member of struct file_priv. It is only
accessed under buffer_mutex, so the offset passed by the caller no
longer matters.

Fixes: 9488585b21be ("tpm: add support for partial reads")
Cc: stable@vger.kernel.org
Signed-off-by: Rustam Mustafin <rmustafin@cloudlinux.com>
---
 drivers/char/tpm/tpm-dev-common.c | 11 ++++++-----
 drivers/char/tpm/tpm-dev.h        |  1 +
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/drivers/char/tpm/tpm-dev-common.c b/drivers/char/tpm/tpm-dev-common.c
index ee91f456f975..553fc6aca94d 100644
--- a/drivers/char/tpm/tpm-dev-common.c
+++ b/drivers/char/tpm/tpm-dev-common.c
@@ -107,6 +107,7 @@ static void tpm_timeout_work(struct work_struct *work)
 	mutex_lock(&priv->buffer_mutex);
 	priv->response_read = true;
 	priv->response_length = 0;
+	priv->read_pos = 0;
 	memset(priv->data_buffer, 0, sizeof(priv->data_buffer));
 	mutex_unlock(&priv->buffer_mutex);
 	wake_up_interruptible(&priv->async_wait);
@@ -149,21 +150,21 @@ ssize_t tpm_common_read(struct file *file, char __user *buf,
 			goto out;
 		}
 
-		rc = copy_to_user(buf, priv->data_buffer + *off, ret_size);
+		rc = copy_to_user(buf, priv->data_buffer + priv->read_pos, ret_size);
 		if (rc) {
 			memset(priv->data_buffer, 0, TPM_BUFSIZE);
 			priv->response_length = 0;
 			ret_size = -EFAULT;
 		} else {
-			memset(priv->data_buffer + *off, 0, ret_size);
+			memset(priv->data_buffer + priv->read_pos, 0, ret_size);
 			priv->response_length -= ret_size;
-			*off += ret_size;
+			priv->read_pos += ret_size;
 		}
 	}
 
 out:
 	if (!priv->response_length) {
-		*off = 0;
+		priv->read_pos = 0;
 		timer_delete_sync(&priv->user_read_timer);
 		flush = true;
 	}
@@ -214,7 +215,7 @@ ssize_t tpm_common_write(struct file *file, const char __user *buf,
 
 	priv->response_length = 0;
 	priv->response_read = false;
-	*off = 0;
+	priv->read_pos = 0;
 
 	/*
 	 * If in nonblocking mode schedule an async job to send
diff --git a/drivers/char/tpm/tpm-dev.h b/drivers/char/tpm/tpm-dev.h
index f3742bcc73e3..34efb1ffa491 100644
--- a/drivers/char/tpm/tpm-dev.h
+++ b/drivers/char/tpm/tpm-dev.h
@@ -15,6 +15,7 @@ struct file_priv {
 	struct work_struct async_work;
 	wait_queue_head_t async_wait;
 	ssize_t response_length;
+	size_t read_pos;
 	bool response_read;
 	bool command_enqueued;
 
-- 
2.52.0


^ permalink raw reply related	[flat|nested] 6+ messages in thread

* [PATCH v2 2/2] selftests: tpm2: test that io_uring reads ignore the file offset
  2026-11-20 12:16 [PATCH v2 0/2] tpm: Track the response read position internally Rustam Mustafin
  2026-11-20 12:16 ` [PATCH v2 1/2] " Rustam Mustafin
@ 2026-11-20 12:16 ` Rustam Mustafin
  1 sibling, 0 replies; 6+ messages in thread
From: Rustam Mustafin @ 2026-11-20 12:16 UTC (permalink / raw)
  To: Peter Huewe, Jarkko Sakkinen
  Cc: Jason Gunthorpe, Shuah Khan, Jaewon Yang, linux-integrity,
	linux-kselftest, linux-kernel, Rustam Mustafin

Test that an IORING_OP_READ request on /dev/tpm0 and /dev/tpmrm0
returns the whole pending response from its start, although sqe->off
points past the response header. The offset stays inside
priv->data_buffer, so an unpatched kernel fails the test on the
returned header without an out-of-bounds access.

Signed-off-by: Rustam Mustafin <rmustafin@cloudlinux.com>
---
 tools/testing/selftests/tpm2/.gitignore  |   1 +
 tools/testing/selftests/tpm2/Makefile    |   4 +
 tools/testing/selftests/tpm2/tpm_uring.c | 131 +++++++++++++++++++++++
 3 files changed, 136 insertions(+)
 create mode 100644 tools/testing/selftests/tpm2/tpm_uring.c

diff --git a/tools/testing/selftests/tpm2/.gitignore b/tools/testing/selftests/tpm2/.gitignore
index 6d6165c5e35d..d2324bd0eca2 100644
--- a/tools/testing/selftests/tpm2/.gitignore
+++ b/tools/testing/selftests/tpm2/.gitignore
@@ -1,3 +1,4 @@
 # SPDX-License-Identifier: GPL-2.0-only
 AsyncTest.log
 SpaceTest.log
+tpm_uring
diff --git a/tools/testing/selftests/tpm2/Makefile b/tools/testing/selftests/tpm2/Makefile
index a9bf9459fb25..67f346f4cdef 100644
--- a/tools/testing/selftests/tpm2/Makefile
+++ b/tools/testing/selftests/tpm2/Makefile
@@ -1,4 +1,8 @@
 # SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
+CFLAGS += $(KHDR_INCLUDES) -idirafter ../../../include -Wall
+
+TEST_GEN_PROGS := tpm_uring
+
 include ../lib.mk
 
 TEST_PROGS := test_smoke.sh test_space.sh test_async.sh
diff --git a/tools/testing/selftests/tpm2/tpm_uring.c b/tools/testing/selftests/tpm2/tpm_uring.c
new file mode 100644
index 000000000000..9caa3cba5bf0
--- /dev/null
+++ b/tools/testing/selftests/tpm2/tpm_uring.c
@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
+/*
+ * An io_uring read chooses its own file offset. The TPM character devices
+ * must ignore it and return the response from its start.
+ */
+
+#include <endian.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <io_uring/mini_liburing.h>
+#include "../kselftest.h"
+
+#define RING_ENTRIES	4
+#define BUF_LEN		4096
+#define POLL_TIMEOUT_MS	10000
+#define TPM_VERSION_FILE	"/sys/class/tpm/tpm0/tpm_version_major"
+struct tpm_header {
+	uint16_t tag;
+	uint32_t size;
+	uint32_t return_code;
+} __attribute__((packed));
+
+/* TPM2_GetCapability(TPM_CAP_TPM_PROPERTIES, TPM_PT_FIXED, 1) */
+static const unsigned char cmd[] = {
+	0x80, 0x01,		/* TPM_ST_NO_SESSIONS */
+	0x00, 0x00, 0x00, 0x16,	/* command size */
+	0x00, 0x00, 0x01, 0x7a,	/* TPM_CC_GetCapability */
+	0x00, 0x00, 0x00, 0x06,	/* TPM_CAP_TPM_PROPERTIES */
+	0x00, 0x00, 0x01, 0x00,	/* TPM_PT_FIXED */
+	0x00, 0x00, 0x00, 0x01,	/* property count */
+};
+
+static void test_read(struct io_uring *ring, const char *path)
+{
+	static char buf[BUF_LEN];
+	const struct tpm_header *hdr = (const void *)buf;
+	struct pollfd pfd = { .events = POLLIN };
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int fd, ret, res;
+
+	fd = open(path, O_RDWR);
+	if (fd < 0) {
+		if (errno == ENOENT)
+			ksft_test_result_skip("%s: not present\n", path);
+		else
+			ksft_test_result_fail("%s: open: %s\n", path,
+					      strerror(errno));
+		return;
+	}
+
+	if (write(fd, cmd, sizeof(cmd)) != sizeof(cmd)) {
+		ksft_test_result_fail("%s: write: %s\n", path, strerror(errno));
+		goto out;
+	}
+
+	pfd.fd = fd;
+	if (poll(&pfd, 1, POLL_TIMEOUT_MS) != 1) {
+		ksft_test_result_fail("%s: no response to the command\n", path);
+		goto out;
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	memset(sqe, 0, sizeof(*sqe));
+	sqe->opcode = IORING_OP_READ;
+	sqe->fd = fd;
+	/*
+	 * Inside the response buffer: an unpatched kernel returns the response
+	 * without its header instead of reading out of bounds
+	 */
+	sqe->off = sizeof(*hdr);
+	sqe->addr = (unsigned long)buf;
+	sqe->len = BUF_LEN;
+	ret = io_uring_submit(ring);
+	if (ret != 1) {
+		ksft_test_result_fail("%s: io_uring_submit: %d\n", path, ret);
+		goto out;
+	}
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret) {
+		ksft_test_result_fail("%s: io_uring_wait_cqe: %d\n", path, ret);
+		goto out;
+	}
+	res = cqe->res;
+	io_uring_cqe_seen(ring);
+
+	/* the offset is ignored: the whole response, from its start */
+	ksft_test_result(res >= (int)sizeof(*hdr) &&
+			 be32toh(hdr->size) == res && !hdr->return_code,
+			 "%s: io_uring read %d\n", path, res);
+out:
+	close(fd);
+}
+
+/* the command is TPM2 only; test_smoke.sh skips the same way */
+static int tpm_version_major(void)
+{
+	FILE *f = fopen(TPM_VERSION_FILE, "r");
+	int major = 0;
+
+	if (f) {
+		if (fscanf(f, "%d", &major) != 1)
+			major = 0;
+		fclose(f);
+	}
+	return major;
+}
+
+int main(void)
+{
+	struct io_uring ring;
+
+	ksft_print_header();
+	if (tpm_version_major() != 2)
+		ksft_exit_skip("no TPM 2.0 device\n");
+	if (io_uring_queue_init(RING_ENTRIES, &ring, 0)) {
+		/* not built in, or disabled by kernel.io_uring_disabled */
+		if (errno == ENOSYS || errno == EPERM)
+			ksft_exit_skip("io_uring_setup: %s\n", strerror(errno));
+		ksft_exit_fail_msg("io_uring_queue_init: %s\n", strerror(errno));
+	}
+	ksft_set_plan(2);
+
+	test_read(&ring, "/dev/tpm0");
+	test_read(&ring, "/dev/tpmrm0");
+
+	io_uring_queue_exit(&ring);
+	ksft_finished();
+}
-- 
2.52.0


^ permalink raw reply related	[flat|nested] 6+ messages in thread

* Re: [PATCH v2 1/2] tpm: Track the response read position internally
  2026-11-20 12:16 ` [PATCH v2 1/2] " Rustam Mustafin
@ 2026-11-20 12:27   ` Jarkko Sakkinen
  2026-11-20 14:28     ` Rustam Mustafin
  0 siblings, 1 reply; 6+ messages in thread
From: Jarkko Sakkinen @ 2026-11-20 12:27 UTC (permalink / raw)
  To: Rustam Mustafin
  Cc: Peter Huewe, Jason Gunthorpe, Shuah Khan, Jaewon Yang,
	linux-integrity, linux-kselftest, linux-kernel, stable

On Fri, Nov 20, 2026 at 07:16:13PM +0700, Rustam Mustafin wrote:
> tpm_common_read() indexes data_buffer with the caller supplied *off.
> A read issued through io_uring reaches the driver with that offset:
> loop_rw_iter() passes &ki_pos to ->read(). This allows out-of-bounds
> reads and zeroing of kernel memory:
> 
>   BUG: KASAN: slab-out-of-bounds in _copy_to_user+0x4b/0x70
>   Read of size 16 by task iou-wrk-148/149
>   Call Trace:
>    _copy_to_user+0x4b/0x70
>    tpm_common_read+0x16e/0x2c0
>    loop_rw_iter+0x235/0x5a0
>    __io_read+0xc6e/0x11a0
>    io_read+0x8a/0x180
> 
> A plain read() racing a write() reaches the same access: read()
> samples f_pos before taking buffer_mutex, so it can consume a new
> response from the offset left by the previous one:
> 
>   BUG: KASAN: slab-out-of-bounds in _copy_to_user+0x4b/0x70
>   Read of size 75 by task trigger/151
>   Call Trace:
>    _copy_to_user+0x4b/0x70
>    tpm_common_read+0x16e/0x2c0
>    vfs_read+0x189/0xc00
>    ksys_read+0xf9/0x1d0
> 
> Replace *off with a read_pos member of struct file_priv. It is only
> accessed under buffer_mutex, so the offset passed by the caller no
> longer matters.
> 
> Fixes: 9488585b21be ("tpm: add support for partial reads")
> Cc: stable@vger.kernel.org
> Signed-off-by: Rustam Mustafin <rmustafin@cloudlinux.com>
> ---

So... why does not this block uring? You are implementing a feature
as a bug fix, or so that it appears.

>  drivers/char/tpm/tpm-dev-common.c | 11 ++++++-----
>  drivers/char/tpm/tpm-dev.h        |  1 +
>  2 files changed, 7 insertions(+), 5 deletions(-)
> 
> diff --git a/drivers/char/tpm/tpm-dev-common.c b/drivers/char/tpm/tpm-dev-common.c
> index ee91f456f975..553fc6aca94d 100644
> --- a/drivers/char/tpm/tpm-dev-common.c
> +++ b/drivers/char/tpm/tpm-dev-common.c
> @@ -107,6 +107,7 @@ static void tpm_timeout_work(struct work_struct *work)
>  	mutex_lock(&priv->buffer_mutex);
>  	priv->response_read = true;
>  	priv->response_length = 0;
> +	priv->read_pos = 0;
>  	memset(priv->data_buffer, 0, sizeof(priv->data_buffer));
>  	mutex_unlock(&priv->buffer_mutex);
>  	wake_up_interruptible(&priv->async_wait);
> @@ -149,21 +150,21 @@ ssize_t tpm_common_read(struct file *file, char __user *buf,
>  			goto out;
>  		}
>  
> -		rc = copy_to_user(buf, priv->data_buffer + *off, ret_size);
> +		rc = copy_to_user(buf, priv->data_buffer + priv->read_pos, ret_size);
>  		if (rc) {
>  			memset(priv->data_buffer, 0, TPM_BUFSIZE);
>  			priv->response_length = 0;
>  			ret_size = -EFAULT;
>  		} else {
> -			memset(priv->data_buffer + *off, 0, ret_size);
> +			memset(priv->data_buffer + priv->read_pos, 0, ret_size);
>  			priv->response_length -= ret_size;
> -			*off += ret_size;
> +			priv->read_pos += ret_size;
>  		}
>  	}
>  
>  out:
>  	if (!priv->response_length) {
> -		*off = 0;
> +		priv->read_pos = 0;
>  		timer_delete_sync(&priv->user_read_timer);
>  		flush = true;
>  	}
> @@ -214,7 +215,7 @@ ssize_t tpm_common_write(struct file *file, const char __user *buf,
>  
>  	priv->response_length = 0;
>  	priv->response_read = false;
> -	*off = 0;
> +	priv->read_pos = 0;
>  
>  	/*
>  	 * If in nonblocking mode schedule an async job to send
> diff --git a/drivers/char/tpm/tpm-dev.h b/drivers/char/tpm/tpm-dev.h
> index f3742bcc73e3..34efb1ffa491 100644
> --- a/drivers/char/tpm/tpm-dev.h
> +++ b/drivers/char/tpm/tpm-dev.h
> @@ -15,6 +15,7 @@ struct file_priv {
>  	struct work_struct async_work;
>  	wait_queue_head_t async_wait;
>  	ssize_t response_length;
> +	size_t read_pos;
>  	bool response_read;
>  	bool command_enqueued;
>  
> -- 
> 2.52.0
> 

Br, Jarkko

^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: [PATCH v2 1/2] tpm: Track the response read position internally
  2026-11-20 12:27   ` Jarkko Sakkinen
@ 2026-11-20 14:28     ` Rustam Mustafin
  2026-11-20 14:50       ` Jarkko Sakkinen
  0 siblings, 1 reply; 6+ messages in thread
From: Rustam Mustafin @ 2026-11-20 14:28 UTC (permalink / raw)
  To: Jarkko Sakkinen
  Cc: Peter Huewe, Jason Gunthorpe, Shuah Khan, Jaewon Yang,
	linux-integrity, linux-kselftest, linux-kernel, stable

On Fri, Nov 20, 2026 at 7:27 PM Jarkko Sakkinen <jarkko@kernel.org> wrote:
> On Fri, Nov 20, 2026 at 07:16:13PM +0700, Rustam Mustafin wrote:
[...]
> So... why does not this block uring? You are implementing a feature
> as a bug fix, or so that it appears.

Patch 1 also fixes a plain read() racing a write() (the second trace),
which does not involve io_uring, so blocking io_uring alone would not
cover it. Patch 1 is small, so it might be easier to backport.

The io_uring block is posted on top of this series:
https://lore.kernel.org/all/20261120142116.1630010-1-rmustafin@cloudlinux.com/

It depends on this series, because the new ->read_iter() would let
vfs_iter_read() callers such as Coda reach tpm_common_read() with
their own offset.

Br,
Rustam

^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: [PATCH v2 1/2] tpm: Track the response read position internally
  2026-11-20 14:28     ` Rustam Mustafin
@ 2026-11-20 14:50       ` Jarkko Sakkinen
  0 siblings, 0 replies; 6+ messages in thread
From: Jarkko Sakkinen @ 2026-11-20 14:50 UTC (permalink / raw)
  To: Rustam Mustafin
  Cc: Peter Huewe, Jason Gunthorpe, Shuah Khan, Jaewon Yang,
	linux-integrity, linux-kselftest, linux-kernel, stable

On Fri, Nov 20, 2026 at 09:28:53PM +0700, Rustam Mustafin wrote:
> On Fri, Nov 20, 2026 at 7:27 PM Jarkko Sakkinen <jarkko@kernel.org> wrote:
> > On Fri, Nov 20, 2026 at 07:16:13PM +0700, Rustam Mustafin wrote:
> [...]
> > So... why does not this block uring? You are implementing a feature
> > as a bug fix, or so that it appears.
> 
> Patch 1 also fixes a plain read() racing a write() (the second trace),
> which does not involve io_uring, so blocking io_uring alone would not
> cover it. Patch 1 is small, so it might be easier to backport.
> 
> The io_uring block is posted on top of this series:
> https://lore.kernel.org/all/20261120142116.1630010-1-rmustafin@cloudlinux.com/
> 
> It depends on this series, because the new ->read_iter() would let
> vfs_iter_read() callers such as Coda reach tpm_common_read() with
> their own offset.

My mishap.

Sorry. I'll look into this soon.

> 
> Br,
> Rustam

Br, Jarkko

^ permalink raw reply	[flat|nested] 6+ messages in thread

end of thread, other threads:[~2026-11-20 14:50 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-20 12:16 [PATCH v2 0/2] tpm: Track the response read position internally Rustam Mustafin
2026-11-20 12:16 ` [PATCH v2 1/2] " Rustam Mustafin
2026-11-20 12:27   ` Jarkko Sakkinen
2026-11-20 14:28     ` Rustam Mustafin
2026-11-20 14:50       ` Jarkko Sakkinen
2026-11-20 12:16 ` [PATCH v2 2/2] selftests: tpm2: test that io_uring reads ignore the file offset Rustam Mustafin

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.