Backport CVE-2024-26583 and CVE-2024-26584 fixes
cover Backport CVE-2024-26583 and CVE-2024-26584 fixes
Backport fix commit ("tls: fix race between async notify and socket close") for CVE-2024-26583 [1]. It's dependent on three tls commits being used to simplify and factor out async waiting. They also benefit backporting fix commit ("net: tls: handle backlogging of crypto requests") for CVE-2024-26584 [2]. Therefore, add them for clean backport:
Jakub Kicinski (4):
tls: rx: simplify async wait
net: tls: factor out tls_*crypt_async_wait()
tls: fix race between async notify and socket close
net: tls: handle backlogging of crypto requests
Sabrina Dubroca (1):
tls: extract context alloc/initialization out of tls_set_sw_offload
Please review and consider applying these patches.
[1] https://lore.kernel.org/all/2024022146-traction-unjustly-f451@gregkh/
[2] https://lore.kernel.org/all/2024022148-showpiece-yanking-107c@gregkh/
include/net/tls.h | 6 -- net/tls/tls_sw.c | 199 ++++++++++++++++++++++++---------------------- 2 files changed, 106 insertions(+), 99 deletions(-)
Signature · 1 line
2.40.1
PATCH 1/5 tls: rx: simplify async wait
From: Jakub Kicinski <[email protected]>
commit 37943f047bfb88ba4dfc7a522563f57c86d088a0 upstream.
Since we are protected from async completions by decrypt_compl_lock we can drop the async_notify and reinit the completion before we start waiting.
Stable-dep-of: aec7961916f3 ("tls: fix race between async notify and socket close")
--- include/net/tls.h | 1 - net/tls/tls_sw.c | 14 ++------------ 2 files changed, 2 insertions(+), 13 deletions(-)
include/net/tls.h +0 -1
@@ -150,7 +150,6 @@ struct tls_sw_context_rx {atomic_t decrypt_pending;/* protect crypto_wait with decrypt_pending*/ spinlock_t decrypt_compl_lock; -bool async_notify; };struct tls_record_info {
net/tls/tls_sw.c +2 -12
@@ -174,7 +174,6 @@ static void tls_decrypt_done(struct crypto_async_request *req, int err)struct scatterlist *sg;struct sk_buff *skb;unsigned int pages; -int pending; skb = (struct sk_buff *)req->data; tls_ctx =tls_get_ctx (skb->sk);
@@ -222,9 +221,7 @@ static void tls_decrypt_done(struct crypto_async_request *req, int err)kfree (aead_req);spin_lock_bh (&ctx->decrypt_compl_lock); - pending =atomic_dec_return (&ctx->decrypt_pending); - -if (!pending && ctx->async_notify) +if (!atomic_dec_return (&ctx->decrypt_pending))complete (&ctx->async_wait.completion);spin_unlock_bh (&ctx->decrypt_compl_lock); }
@@ -1917,7 +1914,7 @@ int tls_sw_recvmsg(struct sock *sk,/* Wait for all previously submitted records to be decrypted */ spin_lock_bh (&ctx->decrypt_compl_lock); - ctx->async_notify = true; +reinit_completion (&ctx->async_wait.completion); pending =atomic_read (&ctx->decrypt_pending);spin_unlock_bh (&ctx->decrypt_compl_lock);if (pending) {
@@ -1929,15 +1926,8 @@ int tls_sw_recvmsg(struct sock *sk, decrypted =0 ; goto end; } - }else { -reinit_completion (&ctx->async_wait.completion); } -/* There can be no concurrent accesses, since we have no -* pending decrypt operations -*/ -WRITE_ONCE (ctx->async_notify, false); -/* Drain records from the rx_list & copy if required */ if (is_peek || is_kvec) err = process_rx_list(ctx, msg, &control, copied,
Signature · 1 line
2.40.1
PATCH 2/5 tls: extract context alloc/initialization out of tls_set_sw_offload
In reply to Shaoying XuFrom: Sabrina Dubroca <[email protected]>
commit 615580cbc99af0da2d1c7226fab43a3d5003eb97 upstream.
Simplify tls_set_sw_offload a bit.
Stable-dep-of: aec7961916f3 ("tls: fix race between async notify and socket close") [v5.15: fixed contextual conflicts from unavailable init_waitqueue_head and skb_queue_head_init calls in tls_set_sw_offload and init_ctx_rx]
--- net/tls/tls_sw.c | 82 +++++++++++++++++++++++++++++------------------- 1 file changed, 49 insertions(+), 33 deletions(-)
net/tls/tls_sw.c +49 -33
@@ -2291,6 +2291,46 @@ void tls_sw_strparser_arm(struct sock *sk, struct tls_context *tls_ctx)strp_check_rcv (&rx_ctx->strp); } +static struct tls_sw_context_tx *init_ctx_tx (struct tls_context *ctx,struct sock *sk) +{ +struct tls_sw_context_tx *sw_ctx_tx; + +if (!ctx->priv_ctx_tx) { + sw_ctx_tx =kzalloc (sizeof (*sw_ctx_tx),GFP_KERNEL ); +if (!sw_ctx_tx) +return NULL ; + }else { + sw_ctx_tx = ctx->priv_ctx_tx; + } + +crypto_init_wait (&sw_ctx_tx->async_wait); +spin_lock_init (&sw_ctx_tx->encrypt_compl_lock); +INIT_LIST_HEAD (&sw_ctx_tx->tx_list); +INIT_DELAYED_WORK (&sw_ctx_tx->tx_work.work, tx_work_handler); + sw_ctx_tx->tx_work.sk = sk; + +return sw_ctx_tx; +} + +static struct tls_sw_context_rx *init_ctx_rx (struct tls_context *ctx) +{ +struct tls_sw_context_rx *sw_ctx_rx; + +if (!ctx->priv_ctx_rx) { + sw_ctx_rx =kzalloc (sizeof (*sw_ctx_rx),GFP_KERNEL ); +if (!sw_ctx_rx) +return NULL ; + }else { + sw_ctx_rx = ctx->priv_ctx_rx; + } + +crypto_init_wait (&sw_ctx_rx->async_wait); +spin_lock_init (&sw_ctx_rx->decrypt_compl_lock); +skb_queue_head_init (&sw_ctx_rx->rx_list); + +return sw_ctx_rx; +} +int tls_set_sw_offload (struct sock *sk,struct tls_context *ctx,int tx) {struct tls_context *tls_ctx =tls_get_ctx (sk);
@@ -2317,46 +2357,22 @@ int tls_set_sw_offload(struct sock *sk, struct tls_context *ctx, int tx) }if (tx) { -if (!ctx->priv_ctx_tx) { - sw_ctx_tx =kzalloc (sizeof (*sw_ctx_tx),GFP_KERNEL ); -if (!sw_ctx_tx) { - rc = -ENOMEM ; - goto out; - } - ctx->priv_ctx_tx = sw_ctx_tx; - }else { - sw_ctx_tx = - (struct tls_sw_context_tx *)ctx->priv_ctx_tx; - } - }else { -if (!ctx->priv_ctx_rx) { - sw_ctx_rx =kzalloc (sizeof (*sw_ctx_rx),GFP_KERNEL ); -if (!sw_ctx_rx) { - rc = -ENOMEM ; - goto out; - } - ctx->priv_ctx_rx = sw_ctx_rx; - }else { - sw_ctx_rx = - (struct tls_sw_context_rx *)ctx->priv_ctx_rx; - } - } + ctx->priv_ctx_tx =init_ctx_tx (ctx, sk); +if (!ctx->priv_ctx_tx) +return -ENOMEM ; -if (tx) { -crypto_init_wait (&sw_ctx_tx->async_wait); -spin_lock_init (&sw_ctx_tx->encrypt_compl_lock); + sw_ctx_tx = ctx->priv_ctx_tx; crypto_info = &ctx->crypto_send.info; cctx = &ctx->tx; aead = &sw_ctx_tx->aead_send; -INIT_LIST_HEAD (&sw_ctx_tx->tx_list); -INIT_DELAYED_WORK (&sw_ctx_tx->tx_work.work, tx_work_handler); - sw_ctx_tx->tx_work.sk = sk; }else { -crypto_init_wait (&sw_ctx_rx->async_wait); -spin_lock_init (&sw_ctx_rx->decrypt_compl_lock); + ctx->priv_ctx_rx =init_ctx_rx (ctx); +if (!ctx->priv_ctx_rx) +return -ENOMEM ; + + sw_ctx_rx = ctx->priv_ctx_rx; crypto_info = &ctx->crypto_recv.info; cctx = &ctx->rx; -skb_queue_head_init (&sw_ctx_rx->rx_list); aead = &sw_ctx_rx->aead_recv; }
Signature · 1 line
2.40.1
PATCH 3/5 net: tls: factor out tls_*crypt_async_wait()
In reply to Shaoying XuFrom: Jakub Kicinski <[email protected]>
commit c57ca512f3b68ddcd62bda9cc24a8f5584ab01b1 upstream.
Factor out waiting for async encrypt and decrypt to finish. There are already multiple copies and a subsequent fix will need more. No functional changes.
Note that crypto_wait_req() returns wait->err
Stable-dep-of: aec7961916f3 ("tls: fix race between async notify and socket close") [v5.15: removed changes in tls_sw_splice_eof and adjusted waiting factor out for async descrypt in tls_sw_recvmsg]
--- net/tls/tls_sw.c | 90 ++++++++++++++++++++++++++---------------------- 1 file changed, 49 insertions(+), 41 deletions(-)
net/tls/tls_sw.c +49 -41
@@ -226,6 +226,20 @@ static void tls_decrypt_done(struct crypto_async_request *req, int err)spin_unlock_bh (&ctx->decrypt_compl_lock); } +static int tls_decrypt_async_wait (struct tls_sw_context_rx *ctx) +{ +int pending; + +spin_lock_bh (&ctx->decrypt_compl_lock); +reinit_completion (&ctx->async_wait.completion); + pending =atomic_read (&ctx->decrypt_pending); +spin_unlock_bh (&ctx->decrypt_compl_lock); +if (pending) +crypto_wait_req (-EINPROGRESS , &ctx->async_wait); + +return ctx->async_wait.err; +} + static int tls_do_decryption(struct sock *sk, struct sk_buff *skb, struct scatterlist *sgin,
@@ -496,6 +510,28 @@ static void tls_encrypt_done(struct crypto_async_request *req, int err)schedule_delayed_work (&ctx->tx_work.work,1 ); } +static int tls_encrypt_async_wait (struct tls_sw_context_tx *ctx) +{ +int pending; + +spin_lock_bh (&ctx->encrypt_compl_lock); + ctx->async_notify = true; + + pending =atomic_read (&ctx->encrypt_pending); +spin_unlock_bh (&ctx->encrypt_compl_lock); +if (pending) +crypto_wait_req (-EINPROGRESS , &ctx->async_wait); +else +reinit_completion (&ctx->async_wait.completion); + +/* There can be no concurrent accesses, since we have no +* pending encrypt operations +*/ +WRITE_ONCE (ctx->async_notify, false); + +return ctx->async_wait.err; +} + static int tls_do_encryption(struct sock *sk, struct tls_context *tls_ctx, struct tls_sw_context_tx *ctx,
@@ -946,7 +982,6 @@ int tls_sw_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)int num_zc =0 ;int orig_size;int ret =0 ; -int pending;if (msg->msg_flags & ~(MSG_MORE |MSG_DONTWAIT |MSG_NOSIGNAL |MSG_CMSG_COMPAT ))
@@ -1115,24 +1150,12 @@ int tls_sw_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)if (!num_async) { goto send_end; }else if (num_zc) { -/* Wait for pending encryptions to get completed */ -spin_lock_bh (&ctx->encrypt_compl_lock); - ctx->async_notify = true; - - pending =atomic_read (&ctx->encrypt_pending); -spin_unlock_bh (&ctx->encrypt_compl_lock); -if (pending) -crypto_wait_req (-EINPROGRESS , &ctx->async_wait); -else -reinit_completion (&ctx->async_wait.completion); - -/* There can be no concurrent accesses, since we have no -* pending encrypt operations -*/ -WRITE_ONCE (ctx->async_notify, false); +int err; -if (ctx->async_wait.err) { - ret = ctx->async_wait.err; +/* Wait for pending encryptions to get completed */ + err =tls_encrypt_async_wait (ctx); +if (err) { + ret = err; copied =0 ; } }
@@ -1910,22 +1933,14 @@ int tls_sw_recvmsg(struct sock *sk, recv_end:if (async) { -int pending; -/* Wait for all previously submitted records to be decrypted */ -spin_lock_bh (&ctx->decrypt_compl_lock); -reinit_completion (&ctx->async_wait.completion); - pending =atomic_read (&ctx->decrypt_pending); -spin_unlock_bh (&ctx->decrypt_compl_lock); -if (pending) { - err =crypto_wait_req (-EINPROGRESS , &ctx->async_wait); -if (err) { -/* one of async decrypt failed */ -tls_err_abort (sk, err); - copied =0 ; - decrypted =0 ; - goto end; - } + err =tls_decrypt_async_wait (ctx); +if (err) { +/* one of async decrypt failed */ +tls_err_abort (sk, err); + copied =0 ; + decrypted =0 ; + goto end; }/* Drain records from the rx_list & copy if required */
@@ -2144,16 +2159,9 @@ void tls_sw_release_resources_tx(struct sock *sk)struct tls_context *tls_ctx =tls_get_ctx (sk);struct tls_sw_context_tx *ctx =tls_sw_ctx_tx (tls_ctx);struct tls_rec *rec, *tmp; -int pending;/* Wait for any pending async encryptions to complete */ -spin_lock_bh (&ctx->encrypt_compl_lock); - ctx->async_notify = true; - pending =atomic_read (&ctx->encrypt_pending); -spin_unlock_bh (&ctx->encrypt_compl_lock); - -if (pending) -crypto_wait_req (-EINPROGRESS , &ctx->async_wait); +tls_encrypt_async_wait (ctx);tls_tx_records (sk,-1 );
Signature · 1 line
2.40.1
PATCH 4/5 tls: fix race between async notify and socket close
In reply to Shaoying XuFrom: Jakub Kicinski <[email protected]>
commit aec7961916f3f9e88766e2688992da6980f11b8d upstream.
The submitting thread (one which called recvmsg/sendmsg) may exit as soon as the async crypto handler calls complete() so any code past that point risks touching already freed data.
Try to avoid the locking and extra flags altogether. Have the main thread hold an extra reference, this way we can depend solely on the atomic ref counter for synchronization.
Don't futz with reiniting the completion, either, we are now tightly controlling when completion fires.
[v5.15: fixed contextual conflicts in struct tls_sw_context_rx and func init_ctx_rx; replaced DEBUG_NET_WARN_ON_ONCE with BUILD_BUG_ON_INVALID since they're equivalent when DEBUG_NET is not defined]
--- include/net/tls.h | 5 ----- net/tls/tls_sw.c | 43 ++++++++++--------------------------------- 2 files changed, 10 insertions(+), 38 deletions(-)
include/net/tls.h +0 -5
@@ -128,9 +128,6 @@ struct tls_sw_context_tx {struct tls_rec *open_rec;struct list_head tx_list;atomic_t encrypt_pending; -/* protect crypto_wait with encrypt_pending */ -spinlock_t encrypt_compl_lock; -int async_notify; u8 async_capable:1;#define BIT_TX_SCHEDULED 0
@@ -148,8 +145,6 @@ struct tls_sw_context_rx {struct sk_buff *recv_pkt; u8 async_capable:1;atomic_t decrypt_pending; -/* protect crypto_wait with decrypt_pending*/ -spinlock_t decrypt_compl_lock; };struct tls_record_info {
net/tls/tls_sw.c +10 -33
99 lines not on this page · raw message
Signature · 1 line
2.40.1
PATCH 5/5 net: tls: handle backlogging of crypto requests
In reply to Shaoying XuFrom: Jakub Kicinski <[email protected]>
commit 8590541473188741055d27b955db0777569438e3 upstream.
Since we're setting the CRYPTO_TFM_REQ_MAY_BACKLOG flag on our requests to the crypto API, crypto_aead_{encrypt,decrypt} can return
-EBUSY instead of -EINPROGRESS in valid situations. For example, when
the cryptd queue for AESNI is full (easy to trigger with an artificially low cryptd.cryptd_max_cpu_qlen), requests will be enqueued to the backlog but still processed. In that case, the async callback will also be called twice: first with err == -EINPROGRESS, which it seems we can just ignore, then with err == 0.
Compared to Sabrina's original patch this version uses the new tls_*crypt_async_wait() helpers and converts the EBUSY to EINPROGRESS to avoid having to modify all the error handling paths. The handling is identical.
--- net/tls/tls_sw.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)
net/tls/tls_sw.c +22 -0
@@ -175,6 +175,17 @@ static void tls_decrypt_done(struct crypto_async_request *req, int err)struct sk_buff *skb;unsigned int pages; +/* If requests get too backlogged crypto API returns -EBUSY and calls +* ->complete(-EINPROGRESS) immediately followed by ->complete(0) +* to make waiting for backlog to flush with crypto_wait_req() easier. +* First wait converts -EBUSY -> -EINPROGRESS, and the second one +* -EINPROGRESS -> 0. +* We have a single struct crypto_async_request per direction, this +* scheme doesn't help us, so just ignore the first ->complete(). +*/ +if (err == -EINPROGRESS ) +return ; + skb = (struct sk_buff *)req->data; tls_ctx =tls_get_ctx (skb->sk); ctx =tls_sw_ctx_rx (tls_ctx);
@@ -273,6 +284,10 @@ static int tls_do_decryption(struct sock *sk, } ret =crypto_aead_decrypt (aead_req); +if (ret == -EBUSY ) { + ret =tls_decrypt_async_wait (ctx); + ret = ret ?: -EINPROGRESS ; + }if (ret == -EINPROGRESS ) {if (darg->async)return 0 ;
@@ -455,6 +470,9 @@ static void tls_encrypt_done(struct crypto_async_request *req, int err)struct tls_rec *rec;bool ready = false; +if (err == -EINPROGRESS )/* see the comment in tls_decrypt_done() */ +return ; + rec = container_of(aead_req, struct tls_rec, aead_req); msg_en = &rec->msg_encrypted;
@@ -551,6 +569,10 @@ static int tls_do_encryption(struct sock *sk,atomic_inc (&ctx->encrypt_pending); rc =crypto_aead_encrypt (aead_req); +if (rc == -EBUSY ) { + rc =tls_encrypt_async_wait (ctx); + rc = rc ?: -EINPROGRESS ; + }if (!rc || rc != -EINPROGRESS ) {atomic_dec (&ctx->encrypt_pending); sge->offset -= prot->prepend_size;
Signature · 1 line
2.40.1
Greg KH
maintainerQuoted 14 lines · Shaoying Xu
Backport fix commit ("tls: fix race between async notify and socket close") for CVE-2024-26583 [1]. It's dependent on three tls commits being used to simplify and factor out async waiting. They also benefit backporting fix commit ("net: tls: handle backlogging of crypto requests") for CVE-2024-26584 [2]. Therefore, add them for clean backport:
Jakub Kicinski (4):
tls: rx: simplify async wait
net: tls: factor out tls_*crypt_async_wait()
tls: fix race between async notify and socket close
net: tls: handle backlogging of crypto requestsSabrina Dubroca (1):
tls: extract context alloc/initialization out oftls_set_sw_offload
Quoted 13 lines
Please review and consider applying these patches.
[1] https://lore.kernel.org/all/2024022146-traction-unjustly-f451@gregkh/
[2] https://lore.kernel.org/all/2024022148-showpiece-yanking-107c@gregkh/include/net/tls.h | 6 -- net/tls/tls_sw.c | 199 ++++++++++++++++++++++++---------------------- 2 files changed, 106 insertions(+), 99 deletions(-)Signature · 1 line
2.40.1
All now queued up, thanks.
greg k-h