mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: "Jérémy Jean" <jeremy.jean@oss.cyber.gouv.fr>
To: Paul Moore <paul@paul-moore.com>
Cc: Bradley Morgan <brads@mainlining.org>,
	Eric Paris <eparis@redhat.com>,
	audit@vger.kernel.org, linux-kernel@vger.kernel.org,
	stable@vger.kernel.org
Subject: Re: [PATCH] audit: fix UAF in kauditd_send_queue()
Date: Tue, 17 Nov 2026 11:36:19 +0100	[thread overview]
Message-ID: <a9f7228c3ab1989bc1b26a0f4e686293@oss.cyber.gouv.fr> (raw)
In-Reply-To: <CAHC9VhQECaSwpjUgSoCgZAgEphEk2jKnZFESn4ivM6JAjrC7HQ@mail.gmail.com>

On 2026-11-16 20:44, Paul Moore wrote:
> On Thu, Nov 5, 2026 at 2:44 PM Jérémy Jean
> <jeremy.jean@oss.cyber.gouv.fr> wrote:
>> On 2026-11-04 21:36, Paul Moore wrote:
>> > On Oct 31, 2026 Bradley Morgan <brads@mainlining.org> wrote:
>> >>
>> >> kauditd_send_queue() grabs an extra reference to the skb header before
>> >> netlink_unicast() since it may need to retry a failed send. If unicast
>> >> delivery reuses that same header, the receive path stores the
>> >> destination socket in skb->sk without taking a socket reference.
>> >> Consequently, after the receiver consumes the skb and closes the
>> >> socket, the extra reference taken on the skb header makes kauditd
>> >> release a header whose skb->sk points to freed socket storage.
>> >>
>> >> KASAN reports a UAF as:
>> >>
>> >>   BUG: KASAN: slab-use-after-free in sock_rfree+0x44/0x140
>> >>   Write of size 4 at addr ffff888004f94140 by task kauditd/31
>> >>
>> >> Clone the header before netlink_unicast(), then use the clone for
>> >> delivery and keep the original skb only for retries. If cloning fails,
>> >> handle it as -EAGAIN so the send can be retried.
>> >>
>> >> Fixes: f3d357b09295 ("Audit: save audit_backlog_limit audit messages
>> >> in case auditd comes back")
>> >> Cc: stable@vger.kernel.org
>> >> Signed-off-by: Jérémy Jean <Jeremy.Jean@oss.cyber.gouv.fr>
>> >> ---
>> >>  kernel/audit.c | 11 +++++++----
>> >>  1 file changed, 7 insertions(+), 4 deletions(-)
>> >>
>> >> diff --git a/kernel/audit.c b/kernel/audit.c
>> >> index 9412af9144bc..5e739fa606be 100644
>> >> --- a/kernel/audit.c
>> >> +++ b/kernel/audit.c
>> >> @@ -790,6 +790,7 @@ static int kauditd_send_queue(struct sock *sk, u32
>> >> portid,
>> >>  {
>> >>      int rc = 0;
>> >>      struct sk_buff *skb = NULL;
>> >> +    struct sk_buff *skb_to_send;
>> >>      struct sk_buff *skb_tail;
>> >>      unsigned int failed = 0;
>> >>
>> >> @@ -810,9 +811,11 @@ static int kauditd_send_queue(struct sock *sk,
>> >> u32 portid,
>> >>              }
>> >>
>> >>  retry:
>> >> -            /* grab an extra skb reference in case of error */
>> >> -            skb_get(skb);
>> >> -            rc = netlink_unicast(sk, skb, portid, 0);
>> >> +            /* Keep the original header unowned for retries. */
>> >> +            skb_to_send = skb_clone(skb, GFP_KERNEL);
>> >
>> > As Bradley pointed out, this appears a little confusing as the existing
>> > approach of skb_get()+netlink_unicast() should end up doing something
>> > very similar to what you are proposing due to netlink_unicast() calling
>> > into netlink_trim() which in this case should always end up doing a
>> > skb_clone().  I'm sure I'm missing something, can you help me
>> > understand
>> > why this proposed patch is different and solves the problem?
>> >
>> > Also, do you have a reproducer for this?
>> 
>> Dear Bradley and Paul,
>> 
>> Thanks for the comments. The fix is closely related to the current
>> code but the main difference is that netlink_trim() does not always
>> reach its skb_shared() clone path. Moving the clone earlier in the
>> execution avoids the UAF.
> 
> Thanks for the detail.  With that in mind, I think doing our own
> clone() is okay, but the ternary operator for error handling is a
> little uglier than I would like in this case.  Removing that, tweaking
> some variable names and comments, how about something like this:
> 
>   /* clone the skb for retries in case of error */
>   skb_clone = skb_clone(...);
>   if (skb_clone)
>     rc = netlink_unicast(...);
>   else
>     rc = -EAGAIN;
>   if (rc < 0) {
>     ...
>   } else {
>     /* consume the clone and continue */
>     consume_skb(skb_clone);
>     failed = 0;
>   }

Hello Paul,

Thanks for the answer and the suggestion. Here is a rework of the
code to follow the overall structure you suggested.

I have added a call to skb_queue_head() on the skb_clone() failure
path to return the unsent skb to its queue to retry sending later.

If this looks good enough to you, I can submit a v2.

Regards,
Jérémy

diff --git a/kernel/audit.c b/kernel/audit.c
index 9412af9..ed050f1 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -790,6 +790,7 @@ static int kauditd_send_queue(struct sock *sk, u32 
portid,
  {
         int rc = 0;
         struct sk_buff *skb = NULL;
+       struct sk_buff *skb_retry;
         struct sk_buff *skb_tail;
         unsigned int failed = 0;

@@ -810,10 +811,24 @@ static int kauditd_send_queue(struct sock *sk, u32 
portid,
                 }

  retry:
-               /* grab an extra skb reference in case of error */
-               skb_get(skb);
-               rc = netlink_unicast(sk, skb, portid, 0);
+               /* clone the skb for retries in case of error */
+               skb_retry = skb_clone(skb, GFP_KERNEL);
+               if (skb_retry)
+                       rc = netlink_unicast(sk, skb, portid, 0);
+               else
+                       rc = -EAGAIN;
                 if (rc < 0) {
+                       if (!skb_retry) {
+                               /* No send was attempted, so return the 
skb for a later pass. */
+                               skb_queue_head(queue, skb);
+                               rc = 0;
+                               break;
+                       }
+
+                       if (skb == skb_tail)
+                               skb_tail = skb_retry;
+                       skb = skb_retry;
+
                         /* send failed - try a few times unless fatal 
error */
                         if (++failed >= retry_limit ||
                             rc == -ECONNREFUSED || rc == -EPERM) {
@@ -827,8 +842,8 @@ retry:
                         } else
                                 goto retry;
                 } else {
-                       /* skb sent - drop the extra reference and 
continue */
-                       consume_skb(skb);
+                       /* consume the clone and continue */
+                       consume_skb(skb_retry);
                         failed = 0;
                 }
         }

      reply	other threads:[~2026-11-17 10:36 UTC|newest]

Thread overview: 7+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-10-31 21:12 Jérémy Jean
2026-10-31 23:56 ` Bradley Morgan
2026-11-04 20:36 ` Paul Moore
2026-11-04 21:05   ` Bradley Morgan
2026-11-05 19:44   ` Jérémy Jean
2026-11-16 19:44     ` Paul Moore
2026-11-17 10:36       ` Jérémy Jean [this message]

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=a9f7228c3ab1989bc1b26a0f4e686293@oss.cyber.gouv.fr \
    --to=jeremy.jean@oss.cyber.gouv.fr \
    --cc=audit@vger.kernel.org \
    --cc=brads@mainlining.org \
    --cc=eparis@redhat.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=paul@paul-moore.com \
    --cc=stable@vger.kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®