FAILED: patch "[PATCH] tls: rx: restore msg_iter before TLS 1.3 optimistic retry" failed to apply to 6.12-stable tree
Subsystems (4)
[email protected]
maintainerThe patch below does not apply to the 6.12-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-6.12.y
git checkout FETCH_HEAD
git cherry-pick -x 1c8629651cb54f7b51db8fc0b1a9944e4a4b0f5e
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026081717-verbalize-stylist-2627@gregkh' --subject-prefix 'PATCH 6.12.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 1c8629651cb54f7b51db8fc0b1a9944e4a4b0f5e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=A9my=20Jean?= <[email protected]>
Date: Tue, 4 Aug 2026 12:55:28 +0000
Subject: [PATCH] tls: rx: restore msg_iter before TLS 1.3 optimistic retry
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
tls_decrypt_sg() advances msg->msg_iter when it maps user pages for the optimistic TLS 1.3 zero-copy path. If the decrypted record turns out not to be unpadded application data, tls_decrypt_sw() retries into a kernel skb, but leaves the iterator advanced.
The subsequent copy from the skb then writes decrypted bytes again at a later point in the caller iovecs while recvmsg() reports only the post-retry length. A TLS peer can trigger this after the receiver enables TLS_RX_EXPECT_NO_PAD.
Revert the iterator by the number of bytes consumed by the optimistic mapping before retrying without zero-copy.
Add a selftest which sends a TLS 1.3 control record with TLS_RX_EXPECT_NO_PAD enabled and verifies that recvmsg() does not overwrite later iovecs beyond the returned length.
net/tls/tls_sw.c +2 -0
@@ -1456,6 +1456,8 @@ tls_decrypt_sw(struct sock *sk, struct tls_context *tls_ctx,/* If opportunistic TLS 1.3 ZC failed retry without ZC */ if (unlikely (darg->zc && prot->version ==TLS_1_3_VERSION && darg->tail !=TLS_RECORD_TYPE_DATA )) { +iov_iter_revert (&msg->msg_iter,strp_msg (darg->skb)->full_len - + prot->overhead_size); darg->zc = false;if (!darg->tail)TLS_INC_STATS (sock_net (sk),LINUX_MIB_TLSRXNOPADVIOL );
tools/testing/selftests/net/tls.c +57 -0
63 lines not on this page · raw message
Sasha Levin
maintainerPATCH 1/2 selftests: tls: add rekey tests
From: Sabrina Dubroca <[email protected]>
[ Upstream commit 555f0edb9ff043196655a5b7cc65f67dfd05b530 ]
Test the kernel's ability to:
- update the key (but not the version or cipher), only for TLS1.3
- pause decryption after receiving a KeyUpdate message, until a new RX key has been provided
- reflect the pause/non-readable socket in poll()
Stable-dep-of: 1c8629651cb5 ("tls: rx: restore msg_iter before TLS 1.3 optimistic retry")
--- tools/testing/selftests/net/tls.c | 458 ++++++++++++++++++++++++++++++ 1 file changed, 458 insertions(+)
tools/testing/selftests/net/tls.c +458 -0
@@ -1649,6 +1649,464 @@ TEST_F(tls, recv_efault)EXPECT_EQ (memcmp (rec2, recv_mem +9 , ret -9 ),0 ); } +#define TLS_RECORD_TYPE_HANDSHAKE 0x16 +/* key_update, length 1, update_not_requested */ +static const char key_update_msg[] ="\x18\x00\x00\x01\x00" ; +static void tls_send_keyupdate (struct __test_metadata *_metadata,int fd) +{ +size_t len =sizeof (key_update_msg); + +EXPECT_EQ (tls_send_cmsg (fd,TLS_RECORD_TYPE_HANDSHAKE , + (char *)key_update_msg, len,0 ), + len); +} + +static void tls_recv_keyupdate (struct __test_metadata *_metadata,int fd,int flags) +{ +char buf[100 ]; + +EXPECT_EQ (tls_recv_cmsg (_metadata, fd,TLS_RECORD_TYPE_HANDSHAKE , buf,sizeof (buf), flags), +sizeof (key_update_msg)); +EXPECT_EQ (memcmp (buf, key_update_msg,sizeof (key_update_msg)),0 ); +} + +/* set the key to 0 then 1 for RX, immediately to 1 for TX */ +TEST_F(tls_basic, rekey_rx) +{ +struct tls_crypto_info_keys tls12_0, tls12_1; +char const *test_str ="test_message" ; +int send_len =strlen (test_str) +1 ; +char buf[20 ]; +int ret; + +if (self->notls) +return ; + +tls_crypto_info_init (TLS_1_3_VERSION ,TLS_CIPHER_AES_GCM_128 , + &tls12_0,0 ); +tls_crypto_info_init (TLS_1_3_VERSION ,TLS_CIPHER_AES_GCM_128 , + &tls12_1,1 ); + + ret =setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12_1, tls12_1.len); +ASSERT_EQ (ret,0 ); + + ret =setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12_0, tls12_0.len); +ASSERT_EQ (ret,0 ); + + ret =setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12_1, tls12_1.len); +EXPECT_EQ (ret,0 ); + +EXPECT_EQ (send (self->fd, test_str, send_len,0 ), send_len); +EXPECT_EQ (recv (self->cfd, buf, send_len,0 ), send_len); +EXPECT_EQ (memcmp (buf, test_str, send_len),0 ); +} + +/* set the key to 0 then 1 for TX, immediately to 1 for RX */ +TEST_F(tls_basic, rekey_tx) +{ +struct tls_crypto_info_keys tls12_0, tls12_1; +char const *test_str ="test_message" ; +int send_len =strlen (test_str) +1 ; +char buf[20 ]; +int ret; + +if (self->notls) +return ; + +tls_crypto_info_init (TLS_1_3_VERSION ,TLS_CIPHER_AES_GCM_128 , + &tls12_0,0 ); +tls_crypto_info_init (TLS_1_3_VERSION ,TLS_CIPHER_AES_GCM_128 , + &tls12_1,1 ); + + ret =setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12_0, tls12_0.len); +ASSERT_EQ (ret,0 ); + + ret =setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12_1, tls12_1.len); +ASSERT_EQ (ret,0 ); + + ret =setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12_1, tls12_1.len); +EXPECT_EQ (ret,0 ); + +EXPECT_EQ (send (self->fd, test_str, send_len,0 ), send_len); +EXPECT_EQ (recv (self->cfd, buf, send_len,0 ), send_len); +EXPECT_EQ (memcmp (buf, test_str, send_len),0 ); +} + +TEST_F(tls, rekey) +{ +char const *test_str_1 ="test_message_before_rekey" ; +char const *test_str_2 ="test_message_after_rekey" ; +struct tls_crypto_info_keys tls12; +int send_len; +char buf[100 ]; + +if (variant->tls_version !=TLS_1_3_VERSION ) +return ; + +/* initial send/recv */ + send_len =strlen (test_str_1) +1 ; +EXPECT_EQ (send (self->fd, test_str_1, send_len,0 ), send_len); +EXPECT_EQ (recv (self->cfd, buf, send_len,0 ), send_len); +EXPECT_EQ (memcmp (buf, test_str_1, send_len),0 ); + +/* update TX key */ +tls_send_keyupdate (_metadata, self->fd); +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),0 ); + +/* send after rekey */ + send_len =strlen (test_str_2) +1 ; +EXPECT_EQ (send (self->fd, test_str_2, send_len,0 ), send_len); + +/* can't receive the KeyUpdate without a control message */ +EXPECT_EQ (recv (self->cfd, buf, send_len,0 ),-1 ); + +/* get KeyUpdate */ +tls_recv_keyupdate (_metadata, self->cfd,0 ); + +/* recv blocking -> -EKEYEXPIRED */ +EXPECT_EQ (recv (self->cfd, buf,sizeof (buf),0 ),-1 ); +EXPECT_EQ (errno,EKEYEXPIRED ); + +/* recv non-blocking -> -EKEYEXPIRED */ +EXPECT_EQ (recv (self->cfd, buf,sizeof (buf),MSG_DONTWAIT ),-1 ); +EXPECT_EQ (errno,EKEYEXPIRED ); + +/* update RX key */ +EXPECT_EQ (setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12, tls12.len),0 ); + +/* recv after rekey */ +EXPECT_NE (recv (self->cfd, buf, send_len,0 ),-1 ); +EXPECT_EQ (memcmp (buf, test_str_2, send_len),0 ); +} + +TEST_F(tls, rekey_fail) +{ +char const *test_str_1 ="test_message_before_rekey" ; +char const *test_str_2 ="test_message_after_rekey" ; +struct tls_crypto_info_keys tls12; +int send_len; +char buf[100 ]; + +/* initial send/recv */ + send_len =strlen (test_str_1) +1 ; +EXPECT_EQ (send (self->fd, test_str_1, send_len,0 ), send_len); +EXPECT_EQ (recv (self->cfd, buf, send_len,0 ), send_len); +EXPECT_EQ (memcmp (buf, test_str_1, send_len),0 ); + +/* update TX key */ +tls_send_keyupdate (_metadata, self->fd); + +if (variant->tls_version !=TLS_1_3_VERSION ) { +/* just check that rekey is not supported and return */ +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),-1 ); +EXPECT_EQ (errno,EBUSY ); +return ; + } + +/* successful update */ +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),0 ); + +/* invalid update: change of version */ +tls_crypto_info_init (TLS_1_2_VERSION , variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),-1 ); +EXPECT_EQ (errno,EINVAL ); + +/* invalid update (RX socket): change of version */ +tls_crypto_info_init (TLS_1_2_VERSION , variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12, tls12.len),-1 ); +EXPECT_EQ (errno,EINVAL ); + +/* invalid update: change of cipher */ +if (variant->cipher_type ==TLS_CIPHER_AES_GCM_256 ) +tls_crypto_info_init (variant->tls_version,TLS_CIPHER_CHACHA20_POLY1305 , &tls12,1 ); +else +tls_crypto_info_init (variant->tls_version,TLS_CIPHER_AES_GCM_256 , &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),-1 ); +EXPECT_EQ (errno,EINVAL ); + +/* send after rekey, the invalid updates shouldn't have an effect */ + send_len =strlen (test_str_2) +1 ; +EXPECT_EQ (send (self->fd, test_str_2, send_len,0 ), send_len); + +/* can't receive the KeyUpdate without a control message */ +EXPECT_EQ (recv (self->cfd, buf, send_len,0 ),-1 ); + +/* get KeyUpdate */ +tls_recv_keyupdate (_metadata, self->cfd,0 ); + +/* recv blocking -> -EKEYEXPIRED */ +EXPECT_EQ (recv (self->cfd, buf,sizeof (buf),0 ),-1 ); +EXPECT_EQ (errno,EKEYEXPIRED ); + +/* recv non-blocking -> -EKEYEXPIRED */ +EXPECT_EQ (recv (self->cfd, buf,sizeof (buf),MSG_DONTWAIT ),-1 ); +EXPECT_EQ (errno,EKEYEXPIRED ); + +/* update RX key */ +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12, tls12.len),0 ); + +/* recv after rekey */ +EXPECT_NE (recv (self->cfd, buf, send_len,0 ),-1 ); +EXPECT_EQ (memcmp (buf, test_str_2, send_len),0 ); +} + +TEST_F(tls, rekey_peek) +{ +char const *test_str_1 ="test_message_before_rekey" ; +struct tls_crypto_info_keys tls12; +int send_len; +char buf[100 ]; + +if (variant->tls_version !=TLS_1_3_VERSION ) +return ; + + send_len =strlen (test_str_1) +1 ; +EXPECT_EQ (send (self->fd, test_str_1, send_len,0 ), send_len); + +/* update TX key */ +tls_send_keyupdate (_metadata, self->fd); +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),0 ); + +EXPECT_EQ (recv (self->cfd, buf,sizeof (buf),MSG_PEEK ), send_len); +EXPECT_EQ (memcmp (buf, test_str_1, send_len),0 ); + +EXPECT_EQ (recv (self->cfd, buf, send_len,0 ), send_len); +EXPECT_EQ (memcmp (buf, test_str_1, send_len),0 ); + +/* can't receive the KeyUpdate without a control message */ +EXPECT_EQ (recv (self->cfd, buf, send_len,MSG_PEEK ),-1 ); + +/* peek KeyUpdate */ +tls_recv_keyupdate (_metadata, self->cfd,MSG_PEEK ); + +/* get KeyUpdate */ +tls_recv_keyupdate (_metadata, self->cfd,0 ); + +/* update RX key */ +EXPECT_EQ (setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12, tls12.len),0 ); +} + +TEST_F(tls, splice_rekey) +{ +int send_len =TLS_PAYLOAD_MAX_LEN /2 ; +char mem_send[TLS_PAYLOAD_MAX_LEN ]; +char mem_recv[TLS_PAYLOAD_MAX_LEN ]; +struct tls_crypto_info_keys tls12; +int p[2 ]; + +if (variant->tls_version !=TLS_1_3_VERSION ) +return ; + +memrnd (mem_send,sizeof (mem_send)); + +ASSERT_GE (pipe (p),0 ); +EXPECT_EQ (send (self->fd, mem_send, send_len,0 ), send_len); + +/* update TX key */ +tls_send_keyupdate (_metadata, self->fd); +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),0 ); + +EXPECT_EQ (send (self->fd, mem_send, send_len,0 ), send_len); + +EXPECT_EQ (splice (self->cfd,NULL , p[1 ],NULL ,TLS_PAYLOAD_MAX_LEN ,0 ), send_len); +EXPECT_EQ (read (p[0 ], mem_recv, send_len), send_len); +EXPECT_EQ (memcmp (mem_send, mem_recv, send_len),0 ); + +/* can't splice the KeyUpdate */ +EXPECT_EQ (splice (self->cfd,NULL , p[1 ],NULL ,TLS_PAYLOAD_MAX_LEN ,0 ),-1 ); +EXPECT_EQ (errno,EINVAL ); + +/* peek KeyUpdate */ +tls_recv_keyupdate (_metadata, self->cfd,MSG_PEEK ); + +/* get KeyUpdate */ +tls_recv_keyupdate (_metadata, self->cfd,0 ); + +/* can't splice before updating the key */ +EXPECT_EQ (splice (self->cfd,NULL , p[1 ],NULL ,TLS_PAYLOAD_MAX_LEN ,0 ),-1 ); +EXPECT_EQ (errno,EKEYEXPIRED ); + +/* update RX key */ +EXPECT_EQ (setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12, tls12.len),0 ); + +EXPECT_EQ (splice (self->cfd,NULL , p[1 ],NULL ,TLS_PAYLOAD_MAX_LEN ,0 ), send_len); +EXPECT_EQ (read (p[0 ], mem_recv, send_len), send_len); +EXPECT_EQ (memcmp (mem_send, mem_recv, send_len),0 ); +} + +TEST_F(tls, rekey_peek_splice) +{ +char const *test_str_1 ="test_message_before_rekey" ; +struct tls_crypto_info_keys tls12; +int send_len; +char buf[100 ]; +char mem_recv[TLS_PAYLOAD_MAX_LEN ]; +int p[2 ]; + +if (variant->tls_version !=TLS_1_3_VERSION ) +return ; + +ASSERT_GE (pipe (p),0 ); + + send_len =strlen (test_str_1) +1 ; +EXPECT_EQ (send (self->fd, test_str_1, send_len,0 ), send_len); + +/* update TX key */ +tls_send_keyupdate (_metadata, self->fd); +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),0 ); + +EXPECT_EQ (recv (self->cfd, buf,sizeof (buf),MSG_PEEK ), send_len); +EXPECT_EQ (memcmp (buf, test_str_1, send_len),0 ); + +EXPECT_EQ (splice (self->cfd,NULL , p[1 ],NULL ,TLS_PAYLOAD_MAX_LEN ,0 ), send_len); +EXPECT_EQ (read (p[0 ], mem_recv, send_len), send_len); +EXPECT_EQ (memcmp (mem_recv, test_str_1, send_len),0 ); +} + +TEST_F(tls, rekey_getsockopt) +{ +struct tls_crypto_info_keys tls12; +struct tls_crypto_info_keys tls12_get; +socklen_t len; + +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,0 ); + + len = tls12.len; +EXPECT_EQ (getsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12_get, &len),0 ); +EXPECT_EQ (len, tls12.len); +EXPECT_EQ (memcmp (&tls12_get, &tls12, tls12.len),0 ); + + len = tls12.len; +EXPECT_EQ (getsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12_get, &len),0 ); +EXPECT_EQ (len, tls12.len); +EXPECT_EQ (memcmp (&tls12_get, &tls12, tls12.len),0 ); + +if (variant->tls_version !=TLS_1_3_VERSION ) +return ; + +tls_send_keyupdate (_metadata, self->fd); +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),0 ); + +tls_recv_keyupdate (_metadata, self->cfd,0 ); +EXPECT_EQ (setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12, tls12.len),0 ); + + len = tls12.len; +EXPECT_EQ (getsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12_get, &len),0 ); +EXPECT_EQ (len, tls12.len); +EXPECT_EQ (memcmp (&tls12_get, &tls12, tls12.len),0 ); + + len = tls12.len; +EXPECT_EQ (getsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12_get, &len),0 ); +EXPECT_EQ (len, tls12.len); +EXPECT_EQ (memcmp (&tls12_get, &tls12, tls12.len),0 ); +} + +TEST_F(tls, rekey_poll_pending) +{ +char const *test_str ="test_message_after_rekey" ; +struct tls_crypto_info_keys tls12; +struct pollfd pfd = { }; +int send_len; +int ret; + +if (variant->tls_version !=TLS_1_3_VERSION ) +return ; + +/* update TX key */ +tls_send_keyupdate (_metadata, self->fd); +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),0 ); + +/* get KeyUpdate */ +tls_recv_keyupdate (_metadata, self->cfd,0 ); + +/* send immediately after rekey */ + send_len =strlen (test_str) +1 ; +EXPECT_EQ (send (self->fd, test_str, send_len,0 ), send_len); + +/* key hasn't been updated, expect cfd to be non-readable */ + pfd.fd = self->cfd; + pfd.events =POLLIN ; +EXPECT_EQ (poll (&pfd,1 ,0 ),0 ); + + ret =fork (); +ASSERT_GE (ret,0 ); + +if (ret) { +int pid2, status; + +/* wait before installing the new key */ +sleep (1 ); + +/* update RX key while poll() is sleeping */ +EXPECT_EQ (setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12, tls12.len),0 ); + + pid2 =wait (&status); +EXPECT_EQ (pid2, ret); +EXPECT_EQ (status,0 ); + }else { + pfd.fd = self->cfd; + pfd.events =POLLIN ; +EXPECT_EQ (poll (&pfd,1 ,5000 ),1 ); + +exit (!__test_passed (_metadata)); + } +} + +TEST_F(tls, rekey_poll_delay) +{ +char const *test_str ="test_message_after_rekey" ; +struct tls_crypto_info_keys tls12; +struct pollfd pfd = { }; +int send_len; +int ret; + +if (variant->tls_version !=TLS_1_3_VERSION ) +return ; + +/* update TX key */ +tls_send_keyupdate (_metadata, self->fd); +tls_crypto_info_init (variant->tls_version, variant->cipher_type, &tls12,1 ); +EXPECT_EQ (setsockopt (self->fd,SOL_TLS ,TLS_TX , &tls12, tls12.len),0 ); + +/* get KeyUpdate */ +tls_recv_keyupdate (_metadata, self->cfd,0 ); + + ret =fork (); +ASSERT_GE (ret,0 ); + +if (ret) { +int pid2, status; + +/* wait before installing the new key */ +sleep (1 ); + +/* update RX key while poll() is sleeping */ +EXPECT_EQ (setsockopt (self->cfd,SOL_TLS ,TLS_RX , &tls12, tls12.len),0 ); + +sleep (1 ); + send_len =strlen (test_str) +1 ; +EXPECT_EQ (send (self->fd, test_str, send_len,0 ), send_len); + + pid2 =wait (&status); +EXPECT_EQ (pid2, ret); +EXPECT_EQ (status,0 ); + }else { + pfd.fd = self->cfd; + pfd.events =POLLIN ; +EXPECT_EQ (poll (&pfd,1 ,5000 ),1 ); +exit (!__test_passed (_metadata)); + } +} +FIXTURE (tls_err) {int fd, cfd;
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/2 tls: rx: restore msg_iter before TLS 1.3 optimistic retry
From: Jérémy Jean <[email protected]>
[ Upstream commit 1c8629651cb54f7b51db8fc0b1a9944e4a4b0f5e ]
tls_decrypt_sg() advances msg->msg_iter when it maps user pages for the optimistic TLS 1.3 zero-copy path. If the decrypted record turns out not to be unpadded application data, tls_decrypt_sw() retries into a kernel skb, but leaves the iterator advanced.
The subsequent copy from the skb then writes decrypted bytes again at a later point in the caller iovecs while recvmsg() reports only the post-retry length. A TLS peer can trigger this after the receiver enables TLS_RX_EXPECT_NO_PAD.
Revert the iterator by the number of bytes consumed by the optimistic mapping before retrying without zero-copy.
Add a selftest which sends a TLS 1.3 control record with TLS_RX_EXPECT_NO_PAD enabled and verifies that recvmsg() does not overwrite later iovecs beyond the returned length.
--- net/tls/tls_sw.c | 2 ++ tools/testing/selftests/net/tls.c | 57 +++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+)
net/tls/tls_sw.c +2 -0
@@ -1727,6 +1727,8 @@ tls_decrypt_sw(struct sock *sk, struct tls_context *tls_ctx,/* If opportunistic TLS 1.3 ZC failed retry without ZC */ if (unlikely (darg->zc && prot->version ==TLS_1_3_VERSION && darg->tail !=TLS_RECORD_TYPE_DATA )) { +iov_iter_revert (&msg->msg_iter,strp_msg (darg->skb)->full_len - + prot->overhead_size); darg->zc = false;if (!darg->tail)TLS_INC_STATS (sock_net (sk),LINUX_MIB_TLSRXNOPADVIOL );
tools/testing/selftests/net/tls.c +57 -0
63 lines not on this page · raw message
Signature · 1 line
2.53.0
Sabrina Dubroca
maintainerRe: [PATCH 6.12.y 1/2] selftests: tls: add rekey tests
In reply to Sasha LevinQuoted 10 lines · Sasha Levin
From: Sabrina Dubroca <[email protected]>
[ Upstream commit
555f0edb9ff043196655a5b7cc65f67dfd05b530]Test the kernel's ability to:
- update the key (but not the version or cipher), only for TLS1.3
- pause decryption after receiving a KeyUpdate message, until a new RX key has been provided
- reflect the pause/non-readable socket inpoll()
Quoted 7 lines
Signed-off-by Sabrina Dubroca <[email protected]>Signed-off-by David S. Miller <[email protected]>Stable-dep-of:
1c8629651cb5("tls: rx: restoremsg_iterbefore TLS 1.3 optimistic retry")Signed-off-by Sasha Levin <[email protected]>--- tools/testing/selftests/net/tls.c | 458 ++++++++++++++++++++++++++++++ 1 file changed, 458 insertions(+)
All of those rekey tests are going to fail if you don't take the rekey implementation as well (which I hope isn't getting backported to any stable kernels). You probably don't want that.
Signature · 1 line
Sabrina
Sasha Levin
maintainerRe: [PATCH 6.12.y 1/2] selftests: tls: add rekey tests
Quoted 3 lines · Sabrina Dubroca
All of those rekey tests are going to fail if you don't take the rekey implementation as well (which I hope isn't getting backported to any stable kernels). You probably don't want that.
You're right, and thanks for catching it.
To be unambiguous about what this actually affected: the 6.12.y series you're replying to here was never queued, so there was nothing to drop on 6.12. The same selftest had, however, already been queued for 6.6 from a separate 6.6.y posting, and that is what I've now dropped. Three patches came out of the 6.6 queue:
- selftests: tls: add rekey tests (555f0edb9ff0)
- selftests: tls: add test with a partially invalid iov (dc54b813df63)
- tls: rx: restore msg_iter before TLS 1.3 optimistic retry (1c8629651cb5)
On 6.6 it's worse than the tests failing - the selftest doesn't even build. tls_crypto_info_init() only grew its key_generation argument in b2e584aa3c71, which isn't in 6.6, so the ~20 four-argument call sites the rekey patch adds fail to compile, and __test_passed() (69fe8ec4f673, v6.9) is missing from 6.6's kselftest_harness.h. And of course the rekey implementation itself (0471b1093e3a, 47069594e67e, 510128b30f2d) isn't there, so tls_main.c still returns -EBUSY on the second setsockopt() that every rekey test expects to succeed.
Signature · 2 lines
Thanks, Sasha
Sabrina Dubroca
maintainerRe: [PATCH 6.12.y 1/2] selftests: tls: add rekey tests
Quoted 11 lines · Sasha Levin
Quoted 3 lines · Sabrina Dubroca
All of those rekey tests are going to fail if you don't take the rekey implementation as well (which I hope isn't getting backported to any stable kernels). You probably don't want that.
You're right, and thanks for catching it.
To be unambiguous about what this actually affected: the 6.12.y series you're replying to here was never queued, so there was nothing to drop on 6.12. The same selftest had, however, already been queued for 6.6 from a separate 6.6.y posting, and that is what I've now dropped. Three
Right. I saw something for 6.6 and kind of assumed that replying to 6.12 would be enough since it should be the exact same situation there. I won't assume next time.
Quoted 5 lines
patches came out of the 6.6 queue:
- selftests: tls: add rekey tests (
555f0edb9ff0)
- selftests: tls: add test with a partially invalid iov (dc54b813df63)
- tls: rx: restoremsg_iterbefore TLS 1.3 optimistic retry (1c8629651cb5)
Sounds ok. I guess you could still backport the retry fix, you would just get a trivial conflict on the selftest because the context changed, but it's a minor behavioral bug.
Quoted 3 lines
On 6.6 it's worse than the tests failing - the selftest doesn't even build.
tls_crypto_info_init()only grew itskey_generationargument inb2e584aa3c71, which isn't in 6.6, so the ~20 four-argument call sites
Yes, that was also part of the rekey series.
Quoted 5 lines
the rekey patch adds fail to compile, and
__test_passed()(69fe8ec4f673, v6.9) is missing from 6.6'skselftest_harness.h. And of course the rekey implementation itself (0471b1093e3a,47069594e67e,510128b30f2d) isn't there, sotls_main.cstill returns-EBUSYon the secondsetsockopt()that every rekey test expects to succeed.
Thanks.
Signature · 1 line
Sabrina