[Pkg-sssd-devel] [Git][sssd-team/sssd][master] 19 commits: debian/patches: Add CVE-2026-80048-{1, 2, 3, 4}.diff.

Mike Gabriel (@sunweaver) gitlab at salsa.debian.org
Tue Nov 10 09:47:47 GMT 2026



Mike Gabriel pushed to branch master at Debian SSSD packaging / sssd


Commits:
3d9c9617 by Mike Gabriel at 2026-11-06T08:55:01+01:00
debian/patches: Add CVE-2026-80048-{1,2,3,4}.diff.

CVE-2026-80048: Fix flaw in sssd-kcm where a user with access to the
`sssd-kcm` UNIX socket has been able to cause the system to preallocate
significant memory by sending a large request length header, leading to
memory exhaustion, and thus ending in a DoS.

(Closes: #1150238)

- - - - -
def79f74 by Mike Gabriel at 2026-11-06T09:02:41+01:00
debian/patches: Add CVE-2026-87853.diff.

- - - - -
f99aba1f by Mike Gabriel at 2026-11-06T09:04:23+01:00
debian/patches: Add CVE-2026-88252.diff.

CVE-2026-88252:  Fix flaw in sssd where a local user has been able to
cause a Denial of Service (DoS) by exhausting the responder service's
available file descriptors (system handles used for open connections).

(Closes: #1150238)

- - - - -
e0728519 by Mike Gabriel at 2026-11-06T09:05:48+01:00
debian/patches: Add CVE-2026-90462.diff.

CVE-2026-90462: LDAP: fix fail-open in ppolicy access check on zero
results. Don't incorrectly return success and cache an allow decision,
permitting continued authorization for a deleted or deprovisioned user.

(Closes: #1148827)

- - - - -
a77a80e6 by Mike Gabriel at 2026-11-06T09:19:28+01:00
debian/patches: Add CVE-2026-90994.diff.

CVE-2026-90994: Fix a flaw in sssd's PAM responder's protocol v1 parser,
where a local client with access to the PAM responder's UNIX socket as
been able to send an empty or truncated PAM request body, triggering an
out-of-bounds read, leading to a denial of service.

(Closes: #1148324)

- - - - -
0c689894 by Mike Gabriel at 2026-11-06T10:21:51+01:00
debian/patches: Add CVE-2026-90996.diff.

CVE-2026-90996: Fix a flaw in sssd where a local unprivileges user has
been able to send a specially crafted request with a zero-length body to
the Network Security Service (NSS) responder. This could have lead to a
denial-of-service condition, causing the NSS responder to become
unstable or terminate.

(Closes: #1148326)

- - - - -
35ef88b5 by Mike Gabriel at 2026-11-06T10:22:22+01:00
debian/patches: Add CVE-2026-90463-{1,2}.diff.

CVE-2026-90463: Fix input validation vulnerability in sssd's NSS
responder: The vulnerability has allowed a local attacker to cause an
out-of-bounds read by sending specially crafted service lookup requests
to the NSS responder's UNIX socket, leading to crashes of the NSS
responder process.

(Closes: #1148452)

- - - - -
212c1086 by Mike Gabriel at 2026-11-10T08:44:47+00:00
debian/patches: Add CVE-2026-90995.diff.

CVE-2026-90995: PAM: avoid NULL deref when service item is missing.

(Closes: #1148325).

- - - - -
26c10cdd by Mike Gabriel at 2026-11-10T08:47:27+00:00
debian/patches: Add CVE-2026-104031.diff.

CVE-2026-104031: autofs: free per-request context on successful replies.

(Closes: #1150238).

- - - - -
2c3cacbb by Mike Gabriel at 2026-11-10T08:49:28+00:00
debian/patches: Add CVE-2026-104032.diff.

CVE-2026-104032: autofs: add 'allowed_uids' option to the autofs
responder. Prevent unprivileged local users from repeatedly requesting
master automount map updates through the autofs responder due to missing
authorization checks.

(Closes: #1150238).

- - - - -
392d910a by Mike Gabriel at 2026-11-10T08:55:56+00:00
debian/patches: Add CVE-2026-104033.diff.

CVE-2026-104033: Treat shadowExpire=0 correctly. shadowExpire can be set
to 0, representing the beginning of the Unix epoch. An account with
shadowExpire set to 0 should be treated as expired.

(Closes: #1150238).

- - - - -
a626cc7d by Mike Gabriel at 2026-11-10T08:58:38+00:00
debian/patches: Add CVE-2026-104036.diff.

CVE-2026-104036: nfs idmap: error out if buffer is too small. Prevent
denial-of-service caused by out-of-bounds writes when requesting
identity lookups that resolve to oversized cached entries.

(Closes: #1150238).

- - - - -
e7a616e7 by Mike Gabriel at 2026-11-10T09:05:55+00:00
debian/patches: Add CVE-2026-104038.diff.

CVE-2026-104038: certmap: check that SID exists in certificate. Prevent
from attachers being able to cause denial-of-services by certmap: check
that SID exists in certificate.

(Closes: #1150238).

- - - - -
f1f04f02 by Mike Gabriel at 2026-11-10T09:11:21+00:00
CVE-2026-104039: Add CVE-2026-104039.diff.

CVE-2026-104039: PAM: clear state pointer before freeing state itself.
When handling Generic Security Services Application Programming
Interface (GSSAPI) authentication in the Pluggable Authentication Module
(PAM) responder, cached connection state was freed upon completion
without clearing the reference pointer. This could have lead to
attackers being able to exploit this by sending an additional request
over the same connection, causing the service to access invalid memory
and unexpectedly terminate.

(Closes: #1150238).

- - - - -
296a864e by Mike Gabriel at 2026-11-10T10:27:01+01:00
debian/patches: Add CVE-2026-104042.diff.

CVE-2026-104042: pam: Guard against zero-length string auth tokens.
Prevent crash in PAM responder by input validation when (crafted)
Pluggable Authentication Module (PAM) requests containing a zero-length
authentication token gets sent to the responder socket.

(Closes: #1150238).

- - - - -
3f4fa0dd by Mike Gabriel at 2026-11-10T10:30:40+01:00
debian/patches: Add CVE-2026-104043.diff.

CVE-2026-104043: nss: guard against length underflow in packet. Prevent
from out-of-bounds memory read during packet parsing, crashing the
responder process and resulting in a Denial of Service (DoS), in case a
local attacker with access to the Name Service Switch (NSS) responder
UNIX socket triggers an integer underflow by sending a specially crafted
request with an undersized packet header.

(Closes: #1150238).

- - - - -
260f9195 by Mike Gabriel at 2026-11-10T10:41:29+01:00
debian/patches: Add CVE-2026-104044-pre.diff and CVE-2026-104044.diff.

CVE-2026-104044: pam: prevent null dereference in kerberos passkey flow.
Prevent local attackers from being able to trigger a Denial of Service
(DoS) by sending a specially crafted Pluggable Authentication Module
(PAM) request when passkey authentication is enabled.

The additional patch CVE-2026-104044-pre.diff fixes potential memory
leaks and is required for CVE-2026-104044.diff to apply cleanly.

(Closes: #1150238).

- - - - -
706bf078 by Mike Gabriel at 2026-11-10T10:43:48+01:00
debian/patches: Add CVE-2026-104045.diff.

CVE-2026-104045: autofs: avoid leaked enumeration contexts after map. By
repeatedly sending concurrent map enumeration and invalidation requests,
an attacker has been able to cause memory to leak, leading to excessive
memory consumption that could disrupt or crash the autofs service.

(Closes: #1150238).

- - - - -
4044244d by Mike Gabriel at 2026-11-10T10:46:15+01:00
debian/patches: Add CVE-2026-104046.diff.

CVE-2026-104046: IDP: Clean old items from open_request_table. When
Identity Provider (IdP) authentication had been enabled,
pre-authentication requests retained state in memory without being
cleared or timed out. A local attacker could have repeatedly initiated
authentication flows without completing them, causing unbounded memory
consumption. This memory exhaustion could have lead to a Denial of
Service (DoS) by degrading or terminating SSSD authentication services.

(Closes: #1150238).

- - - - -


25 changed files:

- + debian/patches/CVE-2026-104031.diff
- + debian/patches/CVE-2026-104032.diff
- + debian/patches/CVE-2026-104033.diff
- + debian/patches/CVE-2026-104036.diff
- + debian/patches/CVE-2026-104038.diff
- + debian/patches/CVE-2026-104039.diff
- + debian/patches/CVE-2026-104042.diff
- + debian/patches/CVE-2026-104043.diff
- + debian/patches/CVE-2026-104044-pre.diff
- + debian/patches/CVE-2026-104044.diff
- + debian/patches/CVE-2026-104045.diff
- + debian/patches/CVE-2026-104046.diff
- + debian/patches/CVE-2026-80048-1.diff
- + debian/patches/CVE-2026-80048-2.diff
- + debian/patches/CVE-2026-80048-3.diff
- + debian/patches/CVE-2026-80048-4.diff
- + debian/patches/CVE-2026-87853.diff
- + debian/patches/CVE-2026-88252.diff
- + debian/patches/CVE-2026-90462.diff
- + debian/patches/CVE-2026-90463-1.diff
- + debian/patches/CVE-2026-90463-2.diff
- + debian/patches/CVE-2026-90994.diff
- + debian/patches/CVE-2026-90995.diff
- + debian/patches/CVE-2026-90996.diff
- debian/patches/series


Changes:

=====================================
debian/patches/CVE-2026-104031.diff
=====================================
@@ -0,0 +1,45 @@
+From 7b50db5032cb4f9c17581a9710654a56a20dd527 Mon Sep 17 00:00:00 2001
+From: Alexey Tikhonov <atikhono at redhat.com>
+Date: Thu, 15 Oct 2026 19:13:08 +0200
+Subject: [PATCH] autofs: free per-request context on successful replies
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+:fixes: CVE-2026-104031
+
+Reviewed-by: Alejandro López <allopez at redhat.com>
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/responder/autofs/autofssrv_cmd.c | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+--- a/src/responder/autofs/autofssrv_cmd.c
++++ b/src/responder/autofs/autofssrv_cmd.c
+@@ -514,7 +514,7 @@
+         return;
+     }
+ 
+-    sss_cmd_done(cmd_ctx->cli_ctx, NULL);
++    sss_cmd_done(cmd_ctx->cli_ctx, cmd_ctx);
+ }
+ 
+ static int
+@@ -724,7 +724,7 @@
+         return;
+     }
+ 
+-    sss_cmd_done(cmd_ctx->cli_ctx, NULL);
++    sss_cmd_done(cmd_ctx->cli_ctx, cmd_ctx);
+ }
+ 
+ static errno_t
+@@ -924,7 +924,7 @@
+         return;
+     }
+ 
+-    sss_cmd_done(cmd_ctx->cli_ctx, NULL);
++    sss_cmd_done(cmd_ctx->cli_ctx, cmd_ctx);
+ }
+ 
+ struct cli_protocol_version *register_cli_protocol_version(void)


=====================================
debian/patches/CVE-2026-104032.diff
=====================================
@@ -0,0 +1,119 @@
+From 5d127f22ae8cadf7846ae5ab0b27efa5e732bb6f Mon Sep 17 00:00:00 2001
+From: Alexey Tikhonov <atikhono at redhat.com>
+Date: Thu, 15 Oct 2026 19:54:08 +0200
+Subject: [PATCH] autofs: add 'allowed_uids' option to the autofs responder
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+and make its default to be "0" so that only automount can connect
+
+:fixes: CVE-2026-104032
+:config: 'autofs' responder now supports `allowed_uids` config option that defaults to "0"
+
+Assisted-By: Claude Code (Opus 4.8)
+Reviewed-by: Pavel Březina <pbrezina at redhat.com>
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/config/cfg_rules.ini         |  1 +
+ src/config/etc/sssd.api.conf     |  1 +
+ src/man/sssd.conf.5.xml          | 23 +++++++++++++++++++++++
+ src/responder/autofs/autofssrv.c | 21 +++++++++++++++++++++
+ 4 files changed, 46 insertions(+)
+
+--- a/src/config/cfg_rules.ini
++++ b/src/config/cfg_rules.ini
+@@ -186,6 +186,7 @@
+ option = cache_first
+ 
+ # autofs service
++option = allowed_uids
+ option = autofs_negative_timeout
+ 
+ [rule/allowed_ssh_options]
+--- a/src/config/etc/sssd.api.conf
++++ b/src/config/etc/sssd.api.conf
+@@ -97,6 +97,7 @@
+ 
+ [autofs]
+ # autofs service
++allowed_uids = str, None, false
+ autofs_negative_timeout = int, None, false
+ 
+ [ssh]
+--- a/src/man/sssd.conf.5.xml
++++ b/src/man/sssd.conf.5.xml
+@@ -2018,6 +2018,29 @@
+             </para>
+             <variablelist>
+                 <varlistentry>
++                    <term>allowed_uids (string)</term>
++                    <listitem>
++                        <para>
++                            Specifies the comma-separated list of UID values or
++                            user names that are allowed to access the autofs
++                            responder. User names are resolved to UIDs at
++                            startup.
++                        </para>
++                        <para>
++                            Default: 0 (only the root user is allowed to access
++                            the autofs responder)
++                        </para>
++                        <para>
++                            Please note that although the UID 0 is used as the
++                            default it will be overwritten with this option. If
++                            you still want to allow the root user to access the
++                            autofs responder, which would be the typical case,
++                            you have to add 0 to the list of allowed UIDs as
++                            well.
++                        </para>
++                    </listitem>
++                </varlistentry>
++                <varlistentry>
+                     <term>autofs_negative_timeout (integer)</term>
+                     <listitem>
+                         <para>
+--- a/src/responder/autofs/autofssrv.c
++++ b/src/responder/autofs/autofssrv.c
+@@ -30,6 +30,9 @@
+ #include "sss_iface/sss_iface_async.h"
+ #include "util/sss_ptr_hash.h"
+ 
++/* 'automount' runs under root */
++#define DEFAULT_ALLOWED_UIDS "0"
++
+ static errno_t
+ autofs_get_config(struct autofs_ctx *actx,
+                   struct confdb_ctx *cdb)
+@@ -102,6 +105,7 @@
+     struct resp_ctx *rctx;
+     struct sss_cmd_table *autofs_cmds;
+     struct autofs_ctx *autofs_ctx;
++    char *uid_str;
+     int ret;
+ 
+     autofs_cmds = get_autofs_cmds();
+@@ -133,6 +137,23 @@
+     autofs_ctx->rctx = rctx;
+     autofs_ctx->rctx->pvt_ctx = autofs_ctx;
+ 
++    ret = confdb_get_string(autofs_ctx->rctx->cdb, autofs_ctx->rctx,
++                            CONFDB_AUTOFS_CONF_ENTRY, CONFDB_SERVICE_ALLOWED_UIDS,
++                            DEFAULT_ALLOWED_UIDS, &uid_str);
++    if (ret != EOK) {
++        DEBUG(SSSDBG_FATAL_FAILURE, "Failed to get allowed UIDs.\n");
++        goto fail;
++    }
++
++    ret = csv_string_to_uid_array(autofs_ctx->rctx, uid_str,
++                                  &autofs_ctx->rctx->allowed_uids_count,
++                                  &autofs_ctx->rctx->allowed_uids);
++    talloc_free(uid_str);
++    if (ret != EOK) {
++        DEBUG(SSSDBG_FATAL_FAILURE, "Failed to set allowed UIDs.\n");
++        goto fail;
++    }
++
+     /* Create the lookup table for setautomntent results */
+     autofs_ctx->maps = sss_ptr_hash_create(autofs_ctx,
+                                            autofs_maps_delete_cb,


=====================================
debian/patches/CVE-2026-104033.diff
=====================================
@@ -0,0 +1,30 @@
+From 69fde641a59e91abf2fbad6c0821579b866e40d5 Mon Sep 17 00:00:00 2001
+From: Tomas Halman <thalman at redhat.com>
+Date: Mon, 12 Oct 2026 16:20:27 +0200
+Subject: [PATCH] Treat shadowExpire=0 correctly
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+shadowExpire can be set to 0, representing the beginning of the Unix
+epoch. An account with shadowExpire set to 0 should be treated as
+expired.
+
+:fixes: CVE-2026-104033
+
+Reviewed-by: Alejandro López <allopez at redhat.com>
+---
+ src/providers/ldap/sdap_access.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/src/providers/ldap/sdap_access.c
++++ b/src/providers/ldap/sdap_access.c
+@@ -417,7 +417,7 @@
+     }
+ 
+     today = (long) (time(NULL) / (60 * 60 * 24));
+-    if (sp_expire > 0 && today >= sp_expire) {
++    if (sp_expire >= 0 && today >= sp_expire) {
+ 
+         ret = pam_add_response(pd, SSS_PAM_SYSTEM_INFO,
+                                sizeof(SHADOW_EXPIRE_MSG),


=====================================
debian/patches/CVE-2026-104036.diff
=====================================
@@ -0,0 +1,37 @@
+From 671d224106b98952cfd1f26176759629a859509d Mon Sep 17 00:00:00 2001
+From: Sumit Bose <sbose at redhat.com>
+Date: Wed, 7 Oct 2026 13:04:24 +0200
+Subject: [PATCH] nfs idmap: error out if buffer is too small
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Although SSSD's NFS idmap plugin checks the buffer size it does not
+error out immediately if the buffer is too small. This patch fixes
+this.
+
+:fixes: CVE-2026-104036
+
+Reviewed-by: Alejandro López <allopez at redhat.com>
+---
+ src/sss_client/nfs/sss_nfs_client.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+--- a/src/sss_client/nfs/sss_nfs_client.c
++++ b/src/sss_client/nfs/sss_nfs_client.c
+@@ -180,6 +180,7 @@
+             IDMAP_LOG(0, ("%s: reply too long; pw_name_len=%lu, len=%lu",
+                           __func__, pw_name_len, len));
+             rc = ENOBUFS;
++            goto done;
+         }
+         IDMAP_LOG(1, ("found uid %i in memcache", uid));
+         memcpy(name, pwd.pw_name, pw_name_len);
+@@ -221,6 +222,7 @@
+             IDMAP_LOG(0, ("%s: reply too long; gr_name_len=%lu, len=%lu",
+                           __func__, gr_name_len, len));
+             rc = ENOBUFS;
++            goto done;
+         }
+         IDMAP_LOG(1, ("found gid %i in memcache", gid));
+         memcpy(name, grp.gr_name, gr_name_len);


=====================================
debian/patches/CVE-2026-104038.diff
=====================================
@@ -0,0 +1,99 @@
+From db521e9e3156309256b764261ebb0343fb4a6bfd Mon Sep 17 00:00:00 2001
+From: Tomas Halman <thalman at redhat.com>
+Date: Thu, 8 Oct 2026 12:35:30 +0200
+Subject: [PATCH] certmap: check that SID exists in certificate
+
+We have to check that SID is not NULL before using
+it in mapping rule.
+
+:fixes: CVE-2026-104038
+
+Reviewed-by: Alexey Tikhonov <atikhono at redhat.com>
+Reviewed-by: Sumit Bose <sbose at redhat.com>
+---
+ src/lib/certmap/sss_certmap.c   |  4 ++++
+ src/tests/cmocka/test_certmap.c | 36 ++++++++++++++++++++++++++++++---
+ 2 files changed, 37 insertions(+), 3 deletions(-)
+
+diff --git a/src/lib/certmap/sss_certmap.c b/src/lib/certmap/sss_certmap.c
+index 3584ca45764..f0b7ebad528 100644
+--- a/src/lib/certmap/sss_certmap.c
++++ b/src/lib/certmap/sss_certmap.c
+@@ -580,6 +580,10 @@ static int expand_sid(struct sss_certmap_ctx *ctx, const char *attr_name,
+     char *exp;
+     const char *sep;
+ 
++    if (sid == NULL) {
++        CM_DEBUG(ctx, "SID is missing.");
++        return EINVAL;
++    }
+     if (attr_name == NULL) {
+         exp = talloc_strdup(ctx, sid);
+     } else if (strcasecmp(attr_name, "rid") == 0) {
+diff --git a/src/tests/cmocka/test_certmap.c b/src/tests/cmocka/test_certmap.c
+index c75fc47fe34..09208cb99db 100644
+--- a/src/tests/cmocka/test_certmap.c
++++ b/src/tests/cmocka/test_certmap.c
+@@ -831,6 +831,26 @@ const uint8_t test_cert3_der[] = {
+     "d+GO2zfbNX8oS/LjZ5f/Vpmiu04VPdiifdYAbfCQez3bevYBQn4D/bq/xVHoHSLY" \
+     "x0N7c7iPuFTCbg+OVrkH3OtPuRT/4kTn"
+ 
++#define TEST_CERT_WITHOUT_SID_EXT \
++    "MIIDSzCCAjOgAwIBAgIUOue9814XTdiAqheGZjzrkrdhooAwDQYJKoZIhvcNAQEL" \
++    "BQAwGDEWMBQGA1UEAwwNcm9vdC1kYy5hZC52bTAeFw0yNjEwMDgxNTEyMzBaFw0y" \
++    "NzEwMDgxNTEyMzBaMBgxFjAUBgNVBAMMDXJvb3QtZGMuYWQudm0wggEiMA0GCSqG" \
++    "SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDxRgOYuKIudmsg25qT787h+daIBu5wMDIY" \
++    "Auy5goiXObVmf6H5mcR4QxupA7Js39Wts70Yhaupl1AANqXjl/Di0B0B3LJ69bqn" \
++    "Bv4J4zYdXdjyR7XBzbJVAExr8smomOqVUjC2MpPb2yTkSpVYQyTdUdCCc6EJBQoP" \
++    "IJrjxZHwH+pGInQDupCycia9MlawLWQFFZ8rIaspsIDTjbsww9k9pIQUgVQNHHl+" \
++    "0MBNV70Bn4L5rvb2yeyEV8PrmX0ql9mfoJaXZ+JMbQwLe5cSk/NviO/d0iqCWB9c" \
++    "CQhac4cmXBwkY4tRPt7IsTNWdlj/vni80QYlhy7+dBr9kQRm+TKnAgMBAAGjgYww" \
++    "gYkwHQYDVR0OBBYEFMKwt+h2D1upXwnl7n+RbNKUNbxaMB8GA1UdIwQYMBaAFMKw" \
++    "t+h2D1upXwnl7n+RbNKUNbxaMA4GA1UdDwEB/wQEAwIFoDAdBgNVHSUEFjAUBggr" \
++    "BgEFBQcDAgYIKwYBBQUHAwEwGAYDVR0RBBEwD4INcm9vdC1kYy5hZC52bTANBgkq" \
++    "hkiG9w0BAQsFAAOCAQEA52V9wY6MGzVusbxLKSdeIv6zTHzOSC2W18nzqgsz6GEv" \
++    "adQEqf3B43dQOjK0llqxebqoBJkV5dlnoCeMNf50Q328w6abeAW5cl0S9yOHvNEi" \
++    "BU1Z6PrsMBH23RaMh5e8eKN3iCYGwA5YP+GlEFu0JocuU+wj+44auwUnnAw7bqLj" \
++    "9QW5kHBIvs5WoJM1RGDMKSIJ6LkWF09eBjSiLqW2fo7JGqZuqkjoU0C2gxdKi9C8" \
++    "d7WEzXRqZW+VZ6Ia9sLI/G5LLH241JiyM7VcR02cfmBJO9MAFRYmFE9jmh2JIqgA" \
++    "Zp+ZRX9+wWtunLMj8Oa8b6qXMG0OJLoMAYRzmSYnIg=="
++
+ void test_sss_cert_get_content(void **state)
+ {
+     int ret;
+@@ -2813,15 +2833,20 @@ static void test_sss_certmap_ldapu1_sid(void **state)
+ 
+     uint8_t *der;
+     size_t der_size;
+-
+-    der = sss_base64_decode(NULL, TEST_CERT_WITH_SID_EXT, &der_size);
+-    assert_non_null(der);
++    uint8_t *der_no_sid;
++    size_t der_no_sid_size;
+ 
+     ret = sss_certmap_init(NULL, ext_debug, NULL, &ctx);
+     assert_int_equal(ret, EOK);
+     assert_non_null(ctx);
+     assert_null(ctx->prio_list);
+ 
++    der = sss_base64_decode(ctx, TEST_CERT_WITH_SID_EXT, &der_size);
++    assert_non_null(der);
++
++    der_no_sid = sss_base64_decode(ctx, TEST_CERT_WITHOUT_SID_EXT, &der_no_sid_size);
++    assert_non_null(der_no_sid);
++
+     /* full sid */
+     ret = sss_certmap_add_rule(ctx, 100,
+                             "KRB5:<ISSUER>.*",
+@@ -2882,6 +2907,11 @@ static void test_sss_certmap_ldapu1_sid(void **state)
+     assert_string_equal(filter, "rule98=1001");
+     assert_null(domains);
+ 
++    /*  SID is not present in certificate, must fail but not crash */
++    ret = sss_certmap_expand_mapping_rule(ctx, der_no_sid, der_no_sid_size,
++                                          &filter, &domains);
++    assert_int_not_equal(ret, 0);
++
+     sss_certmap_free_ctx(ctx);
+ }
+ 


=====================================
debian/patches/CVE-2026-104039.diff
=====================================
@@ -0,0 +1,24 @@
+From f3e65b06ccbe083dd569a6ccf8e6ad6405862852 Mon Sep 17 00:00:00 2001
+From: Tomas Halman <thalman at redhat.com>
+Date: Fri, 9 Oct 2026 12:04:19 +0200
+Subject: [PATCH] PAM: clear state pointer before freeing state itself
+
+:fixes: CVE-2026-104039
+---
+ src/responder/pam/pamsrv_gssapi.c | 3 +++
+ 1 file changed, 3 insertions(+)
+
+diff --git a/src/responder/pam/pamsrv_gssapi.c b/src/responder/pam/pamsrv_gssapi.c
+index ae2ca9ca8f3..33a9731b668 100644
+--- a/src/responder/pam/pamsrv_gssapi.c
++++ b/src/responder/pam/pamsrv_gssapi.c
+@@ -835,6 +835,9 @@ int gssapi_state_destructor(struct gssapi_state *state)
+     OM_uint32 minor;
+ 
+     gss_delete_sec_context(&minor, &state->ctx, NULL);
++    if (state->cli_ctx != NULL && state->cli_ctx->state_ctx == state) {
++        state->cli_ctx->state_ctx = NULL;
++    }
+ 
+     return 0;
+ }


=====================================
debian/patches/CVE-2026-104042.diff
=====================================
@@ -0,0 +1,30 @@
+From 115e745149fcfa4d08e8a6242acf1c0350d24989 Mon Sep 17 00:00:00 2001
+From: Justin Stephenson <jstephen at redhat.com>
+Date: Mon, 12 Oct 2026 14:21:49 -0400
+Subject: [PATCH] pam: guard against zero-length string auth tokens
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+:fixes: CVE-2026-104042
+
+Reviewed-by: Alexey Tikhonov <atikhono at redhat.com>
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/responder/pam/pamsrv_cmd.c | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+--- a/src/responder/pam/pamsrv_cmd.c
++++ b/src/responder/pam/pamsrv_cmd.c
+@@ -214,6 +214,11 @@
+     case SSS_AUTHTOK_TYPE_PASSKEY_KRB:
+     case SSS_AUTHTOK_TYPE_PASSKEY_REPLY:
+     case SSS_AUTHTOK_TYPE_PAM_STACKED:
++        if (auth_token_length == 0) {
++            DEBUG(SSSDBG_TRACE_FUNC, "Zero-length auth [%s] type token, returning EINVAL\n",
++                                     sss_authtok_type_to_str(auth_token_type));
++            return EINVAL;
++        }
+         ret = sss_authtok_set(tok, auth_token_type,
+                               auth_token_data, auth_token_length);
+         break;


=====================================
debian/patches/CVE-2026-104043.diff
=====================================
@@ -0,0 +1,32 @@
+From df9116178c8da462406a4e9cd21b75bb9a9a95df Mon Sep 17 00:00:00 2001
+From: Justin Stephenson <jstephen at redhat.com>
+Date: Tue, 13 Oct 2026 14:39:48 -0400
+Subject: [PATCH] nss: guard against length underflow in packet
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+:fixes: CVE-2026-104043
+
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/responder/common/responder_packet.c | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+diff --git a/src/responder/common/responder_packet.c b/src/responder/common/responder_packet.c
+index db74cc13d32..28e1149f50d 100644
+--- a/src/responder/common/responder_packet.c
++++ b/src/responder/common/responder_packet.c
+@@ -215,6 +215,12 @@ int sss_packet_recv(struct sss_packet *packet, int fd)
+     }
+ 
+     new_len = sss_packet_get_len(packet);
++    if (new_len < SSS_NSS_HEADER_SIZE) {
++        DEBUG(SSSDBG_OP_FAILURE,
++              "Refusing undersized packet from fd %d (length %zu bytes)\n",
++              fd, new_len);
++        return EINVAL;
++    }
+     if (new_len > packet->memsize) {
+         enum sss_cli_command cmd = sss_packet_get_cmd(packet);
+         size_t max_recv_size;


=====================================
debian/patches/CVE-2026-104044-pre.diff
=====================================
@@ -0,0 +1,78 @@
+From 043de0435f09451fcf7c065711a418d448621939 Mon Sep 17 00:00:00 2001
+From: tong_1001 <sxt1001 at qq.com>
+Date: Fri, 4 Sep 2026 08:50:05 +0800
+Subject: [PATCH] fix potential memory leak
+
+Reviewed-by: Justin Stephenson <jstephen at redhat.com>
+Reviewed-by: Sumit Bose <sbose at redhat.com>
+---
+ src/responder/ifp/ifp_users.c      | 5 +++--
+ src/responder/ifp/ifpsrv_cmd.c     | 1 +
+ src/responder/pam/pamsrv_passkey.c | 3 ++-
+ src/tools/sssctl/sssctl_cache.c    | 3 ++-
+ 4 files changed, 8 insertions(+), 4 deletions(-)
+
+diff --git a/src/responder/ifp/ifp_users.c b/src/responder/ifp/ifp_users.c
+index dda53bd25..78110f077 100644
+--- a/src/responder/ifp/ifp_users.c
++++ b/src/responder/ifp/ifp_users.c
+@@ -1642,13 +1642,14 @@ ifp_users_user_get_groups(TALLOC_CTX *mem_ctx,
+ 
+     ret = ifp_users_user_get(tmp_ctx, sbus_req, ifp_ctx, &domain, &user);
+     if (ret != EOK) {
+-        return ret;
++        goto done;
+     }
+ 
+     username = ldb_msg_find_attr_as_string(user, SYSDB_NAME, NULL);
+     if (username == NULL) {
+         DEBUG(SSSDBG_CRIT_FAILURE, "User name is empty!\n");
+-        return ERR_INTERNAL;
++        ret = ERR_INTERNAL;
++        goto done;
+     }
+ 
+     /* Run initgroups. */
+diff --git a/src/responder/ifp/ifpsrv_cmd.c b/src/responder/ifp/ifpsrv_cmd.c
+index 8cf1ec84c..b74959494 100644
+--- a/src/responder/ifp/ifpsrv_cmd.c
++++ b/src/responder/ifp/ifpsrv_cmd.c
+@@ -430,6 +430,7 @@ ifp_user_get_groups_build_reply(TALLOC_CTX *mem_ctx,
+     num = res->count;
+     groupnames = talloc_zero_array(mem_ctx, const char *, num + 1);
+     if (groupnames == NULL) {
++        talloc_free(tmp_ctx);
+         return ENOMEM;
+     }
+ 
+diff --git a/src/responder/pam/pamsrv_passkey.c b/src/responder/pam/pamsrv_passkey.c
+index b25122e0a..6836c69bb 100644
+--- a/src/responder/pam/pamsrv_passkey.c
++++ b/src/responder/pam/pamsrv_passkey.c
+@@ -1181,7 +1181,8 @@ errno_t save_passkey_data(TALLOC_CTX *mem_ctx,
+      * takes care of automatically removing it from the hash table then */
+     pctx->pk_table_data = talloc_zero(tmp_ctx, struct pam_passkey_table_data);
+     if (pctx->pk_table_data == NULL) {
+-        return ENOMEM;
++        ret = ENOMEM;
++        goto done;
+     }
+ 
+     if (pctx->pk_table_data->table == NULL) {
+diff --git a/src/tools/sssctl/sssctl_cache.c b/src/tools/sssctl/sssctl_cache.c
+index 2e72d9968..95c31d9f4 100644
+--- a/src/tools/sssctl/sssctl_cache.c
++++ b/src/tools/sssctl/sssctl_cache.c
+@@ -1146,7 +1146,8 @@ errno_t sssctl_gpo_remove(struct sss_cmdline *cmdline,
+ 
+     if (opts.domain == NULL) {
+         ERROR("%s\n", extended_help);
+-        return EINVAL;
++        ret = EINVAL;
++        goto done;
+     }
+ 
+     attr = SYSDB_NAME;
+-- 
+2.47.3
+


=====================================
debian/patches/CVE-2026-104044.diff
=====================================
@@ -0,0 +1,135 @@
+From ed02f9d3559eb306d4a0a7bd4b117ade7aa9c48f Mon Sep 17 00:00:00 2001
+From: Justin Stephenson <jstephen at redhat.com>
+Date: Mon, 12 Oct 2026 14:27:15 -0400
+Subject: [PATCH] pam: prevent null dereference in kerberos passkey flow
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+:fixes: CVE-2026-104044
+
+Reviewed-by: Alexey Tikhonov <atikhono at redhat.com>
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/responder/common/responder.h   |  3 +++
+ src/responder/pam/pamsrv.h         |  1 -
+ src/responder/pam/pamsrv_passkey.c | 38 +++++++++++++++++++-----------
+ 3 files changed, 27 insertions(+), 15 deletions(-)
+
+diff --git a/src/responder/common/responder.h b/src/responder/common/responder.h
+index df0c63a4b48..dc71bd0e280 100644
+--- a/src/responder/common/responder.h
++++ b/src/responder/common/responder.h
+@@ -127,6 +127,7 @@ struct resp_ctx {
+ };
+ 
+ struct cli_creds;
++struct pam_passkey_table_data;
+ 
+ struct cli_ctx {
+     struct tevent_context *ev;
+@@ -146,6 +147,8 @@ struct cli_ctx {
+     struct tevent_timer *idle;
+     time_t last_request_time;
+     uint32_t client_id_num;
++
++    struct pam_passkey_table_data *pk_table_data;
+ };
+ 
+ struct sss_cmd_table {
+diff --git a/src/responder/pam/pamsrv.h b/src/responder/pam/pamsrv.h
+index 162bfe1a435..25f0402c6d1 100644
+--- a/src/responder/pam/pamsrv.h
++++ b/src/responder/pam/pamsrv.h
+@@ -76,7 +76,6 @@ struct pam_ctx {
+     char **gssapi_indicators_apply;
+     bool gssapi_check_upn;
+     bool passkey_auth;
+-    struct pam_passkey_table_data *pk_table_data;
+     char **json_services;
+ };
+ 
+diff --git a/src/responder/pam/pamsrv_passkey.c b/src/responder/pam/pamsrv_passkey.c
+index b0f631166e3..8cf81e81138 100644
+--- a/src/responder/pam/pamsrv_passkey.c
++++ b/src/responder/pam/pamsrv_passkey.c
+@@ -144,7 +144,13 @@ errno_t passkey_kerberos(struct pam_ctx *pctx,
+         return EIO;
+     }
+ 
+-    data = sss_ptr_hash_lookup(pctx->pk_table_data->table, key,
++    if (preq->cctx->pk_table_data == NULL || preq->cctx->pk_table_data->table == NULL) {
++        DEBUG(SSSDBG_OP_FAILURE,
++              "Passkey KRB state table missing (pre-auth state not initialized).\n");
++        return EIO;
++    }
++
++    data = sss_ptr_hash_lookup(preq->cctx->pk_table_data->table, key,
+                                struct pk_child_user_data);
+     if (data == NULL) {
+         DEBUG(SSSDBG_OP_FAILURE,
+@@ -1170,6 +1176,7 @@ errno_t save_passkey_data(TALLOC_CTX *mem_ctx,
+     char *pk_key;
+     errno_t ret;
+     TALLOC_CTX *tmp_ctx;
++    struct cli_ctx *cctx = preq->cctx;
+ 
+     tmp_ctx = talloc_new(NULL);
+     if (tmp_ctx == NULL) {
+@@ -1178,17 +1185,21 @@ errno_t save_passkey_data(TALLOC_CTX *mem_ctx,
+ 
+     /* Passkey data (pk_table_data) is stolen onto client ctx, it will
+      * be freed when the client closes, and the sss_ptr_hash interface
+-     * takes care of automatically removing it from the hash table then */
+-    pctx->pk_table_data = talloc_zero(tmp_ctx, struct pam_passkey_table_data);
+-    if (pctx->pk_table_data == NULL) {
+-        ret = ENOMEM;
+-        goto done;
++     * takes care of automatically removing it from the hash table then.
++     * This persists across PREAUTH and AUTHENTICATE requests. */
++    if (cctx->pk_table_data == NULL) {
++        DEBUG(SSSDBG_TRACE_FUNC, "Allocating pk_table_data for client\n");
++        cctx->pk_table_data = talloc_zero(cctx, struct pam_passkey_table_data);
++        if (cctx->pk_table_data == NULL) {
++            ret = ENOMEM;
++            goto done;
++        }
+     }
+ 
+-    if (pctx->pk_table_data->table == NULL) {
+-        pctx->pk_table_data->table = sss_ptr_hash_create(pctx->pk_table_data,
++    if (cctx->pk_table_data->table == NULL) {
++        cctx->pk_table_data->table = sss_ptr_hash_create(cctx->pk_table_data,
+                                                          NULL, NULL);
+-        if (pctx->pk_table_data->table == NULL) {
++        if (cctx->pk_table_data->table == NULL) {
+             ret = ENOMEM;
+             goto done;
+         }
+@@ -1200,13 +1211,13 @@ errno_t save_passkey_data(TALLOC_CTX *mem_ctx,
+         goto done;
+     }
+ 
+-    pctx->pk_table_data->key = talloc_strdup(pctx->pk_table_data, pk_key);
+-    if (pctx->pk_table_data->key == NULL) {
++    cctx->pk_table_data->key = talloc_strdup(cctx->pk_table_data, pk_key);
++    if (cctx->pk_table_data->key == NULL) {
+         ret = ENOMEM;
+         goto done;
+     }
+ 
+-    ret = sss_ptr_hash_add(pctx->pk_table_data->table, pk_key, data,
++    ret = sss_ptr_hash_add(cctx->pk_table_data->table, pk_key, data,
+                            struct pk_child_user_data);
+     if (ret == EEXIST) {
+         DEBUG(SSSDBG_TRACE_FUNC, "pk_table key [%s] already exists\n",
+@@ -1218,8 +1229,7 @@ errno_t save_passkey_data(TALLOC_CTX *mem_ctx,
+         goto done;
+     }
+ 
+-    talloc_steal(mem_ctx, pctx->pk_table_data);
+-    pctx->pk_table_data->data = talloc_steal(mem_ctx, data);
++    cctx->pk_table_data->data = talloc_steal(cctx, data);
+ 
+     ret = EOK;
+ 


=====================================
debian/patches/CVE-2026-104045.diff
=====================================
@@ -0,0 +1,35 @@
+From 3dbcfe3458798e056e22b74a63562c288e7de0eb Mon Sep 17 00:00:00 2001
+From: Justin Stephenson <jstephen at redhat.com>
+Date: Tue, 13 Oct 2026 14:47:35 -0400
+Subject: [PATCH] autofs: avoid leaked enumeration contexts after map
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+:fixes: CVE-2026-104045
+
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/responder/autofs/autofssrv_cmd.c | 9 ++++++++-
+ 1 file changed, 8 insertions(+), 1 deletion(-)
+
+diff --git a/src/responder/autofs/autofssrv_cmd.c b/src/responder/autofs/autofssrv_cmd.c
+index 7c80909939b..63caa0d6efd 100644
+--- a/src/responder/autofs/autofssrv_cmd.c
++++ b/src/responder/autofs/autofssrv_cmd.c
+@@ -351,7 +351,14 @@ static void autofs_setent_done(struct tevent_req *subreq)
+     state->enum_ctx->ready = true;
+ 
+     /* Make the enumeration context disappear with maps table. */
+-    talloc_steal(state->autofs_ctx->maps, state->enum_ctx);
++    if (sss_ptr_hash_has_key(state->autofs_ctx->maps, state->enum_ctx->key)) {
++        talloc_steal(state->autofs_ctx->maps, state->enum_ctx);
++    } else {
++        DEBUG(SSSDBG_TRACE_FUNC,
++              "Key [%s] was orphaned during async operation, "
++              "skipping reparent to avoid leak\n",
++              state->enum_ctx->key);
++    }
+ 
+     setent_notify_done(&state->enum_ctx->notify_list);
+     tevent_req_done(req);


=====================================
debian/patches/CVE-2026-104046.diff
=====================================
@@ -0,0 +1,161 @@
+From 7c1cbce7a7156c8126176fec9d64f3ce1efec795 Mon Sep 17 00:00:00 2001
+From: Tomas Halman <thalman at redhat.com>
+Date: Thu, 15 Oct 2026 14:44:12 +0200
+Subject: [PATCH] IDP: Clean old items from open_request_table
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+:fixes: cve-2026-104046
+
+AI: Claude Opus 4.6
+Co-authored-by: Claude Code <noreply at anthropic.com>
+Reviewed-by: Pavel Březina <pbrezina at redhat.com>
+Reviewed-by: Sumit Bose <sbose at redhat.com>
+---
+ src/providers/idp/idp_auth.h      |  1 +
+ src/providers/idp/idp_auth_eval.c |  6 +++
+ src/providers/idp/idp_init.c      | 74 +++++++++++++++++++++++++++++++
+ src/providers/idp/idp_private.h   |  1 +
+ 4 files changed, 82 insertions(+)
+
+diff --git a/src/providers/idp/idp_auth.h b/src/providers/idp/idp_auth.h
+index 962823635b5..d6c5c8376b8 100644
+--- a/src/providers/idp/idp_auth.h
++++ b/src/providers/idp/idp_auth.h
+@@ -34,6 +34,7 @@ struct idp_auth_ctx {
+     struct idp_init_ctx *init_ctx;
+     struct dp_option *idp_options;
+     hash_table_t *open_request_table;
++    struct be_ptask *cleanup_task;
+ 
+     const char *idp_type;
+     const char *client_id;
+diff --git a/src/providers/idp/idp_auth_eval.c b/src/providers/idp/idp_auth_eval.c
+index f6340b402d1..6ac720e6628 100644
+--- a/src/providers/idp/idp_auth_eval.c
++++ b/src/providers/idp/idp_auth_eval.c
+@@ -88,6 +88,12 @@ errno_t eval_device_auth_buf(struct idp_auth_ctx *idp_auth_ctx,
+         goto done;
+     }
+ 
++    open_req->created_at = time(NULL);
++    if (open_req->created_at == (time_t)-1) {
++        DEBUG(SSSDBG_MINOR_FAILURE, "Failed to get request timestampt.\n");
++        open_req->created_at = 0;
++    }
++
+     ret = sss_ptr_hash_add(idp_auth_ctx->open_request_table,
+                            user_data->user_code,
+                            open_req, struct idp_open_req_data);
+diff --git a/src/providers/idp/idp_init.c b/src/providers/idp/idp_init.c
+index 7b1d32a09f5..6e8416177ae 100644
+--- a/src/providers/idp/idp_init.c
++++ b/src/providers/idp/idp_init.c
+@@ -28,6 +28,8 @@
+ #include "src/providers/idp/idp_opts.h"
+ #include "src/providers/idp/idp_id.h"
+ #include "src/providers/idp/idp_auth.h"
++#include "src/providers/idp/idp_private.h"
++#include "providers/be_ptask.h"
+ #include "lib/idmap/sss_idmap.h"
+ #include "util/util_sss_idmap.h"
+ 
+@@ -320,6 +322,62 @@ errno_t sssm_idp_id_init(TALLOC_CTX *mem_ctx,
+     return ret;
+ }
+ 
++#define IDP_OPEN_REQ_CLEANUP_PERIOD  180  /* 3 minutes */
++#define IDP_OPEN_REQ_MAX_AGE         300  /* 5 minutes */
++
++static errno_t
++idp_open_request_cleanup(TALLOC_CTX *mem_ctx,
++                         struct tevent_context *ev,
++                         struct be_ctx *be_ctx,
++                         struct be_ptask *be_ptask,
++                         void *pvt)
++{
++    struct idp_auth_ctx *auth_ctx = talloc_get_type(pvt, struct idp_auth_ctx);
++    hash_entry_t *entries = NULL;
++    unsigned long count;
++    unsigned long i;
++    int hret;
++    time_t now;
++    struct idp_open_req_data *open_req;
++
++    now = time(NULL);
++    if (now == (time_t)-1) {
++        DEBUG(SSSDBG_MINOR_FAILURE, "Could not get current time.\n");
++        return EOK;
++    }
++
++    hret = hash_entries(auth_ctx->open_request_table, &count, &entries);
++    if (hret != HASH_SUCCESS) {
++        DEBUG(SSSDBG_MINOR_FAILURE,
++              "Could not get open request table entries.\n");
++        return EOK;
++    }
++
++    if (count == 0) {
++        talloc_free(entries);
++        return EOK;
++    }
++
++    for (i = 0; i < count; i++) {
++        open_req = sss_ptr_get_value(&entries[i].value,
++                                     struct idp_open_req_data);
++        if (open_req == NULL) {
++            continue;
++        }
++
++        if (now - open_req->created_at > IDP_OPEN_REQ_MAX_AGE) {
++            DEBUG(SSSDBG_TRACE_FUNC,
++                  "Removing expired open request [%s].\n",
++                  entries[i].key.str);
++            sss_ptr_hash_delete(auth_ctx->open_request_table,
++                                entries[i].key.str, true);
++        }
++    }
++
++    talloc_free(entries);
++    return EOK;
++}
++
+ errno_t sssm_idp_auth_init(TALLOC_CTX *mem_ctx,
+                            struct be_ctx *be_ctx,
+                            void *module_data,
+@@ -354,6 +412,22 @@ errno_t sssm_idp_auth_init(TALLOC_CTX *mem_ctx,
+         goto done;
+     }
+ 
++    ret = be_ptask_create_sync(auth_ctx, be_ctx,
++                               IDP_OPEN_REQ_CLEANUP_PERIOD,
++                               IDP_OPEN_REQ_CLEANUP_PERIOD,
++                               IDP_OPEN_REQ_CLEANUP_PERIOD,
++                               0, IDP_OPEN_REQ_CLEANUP_PERIOD, 0,
++                               idp_open_request_cleanup, auth_ctx,
++                               "IDP open request table cleanup",
++                               BE_PTASK_OFFLINE_EXECUTE,
++                               &auth_ctx->cleanup_task);
++    if (ret != EOK) {
++        DEBUG(SSSDBG_CRIT_FAILURE,
++              "Failed to create open request cleanup task [%d]: %s\n",
++              ret, sss_strerror(ret));
++        goto done;
++    }
++
+     if (dp_opt_get_bool(init_ctx->opts, IDP_AUTO_REFRESH)) {
+         auth_ctx->token_refresh_table = sss_ptr_hash_create(auth_ctx,
+                                                   token_refresh_table_delete_cb,
+diff --git a/src/providers/idp/idp_private.h b/src/providers/idp/idp_private.h
+index 9b14f85a4e5..62ded52bd31 100644
+--- a/src/providers/idp/idp_private.h
++++ b/src/providers/idp/idp_private.h
+@@ -52,6 +52,7 @@ errno_t eval_group_buf(struct idp_id_ctx *idp_id_ctx,
+  */
+ struct idp_open_req_data {
+     char *device_code_data;
++    time_t created_at;
+ };
+ 
+ /** @brief Evaluate Device Authorization reply, if valid create a pam_data


=====================================
debian/patches/CVE-2026-80048-1.diff
=====================================
@@ -0,0 +1,109 @@
+From d5f68d90381ac6f39e0fe972f59baf7996687203 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Pavel=20B=C5=99ezina?= <pbrezina at redhat.com>
+Date: Thu, 1 Oct 2026 15:05:43 +0200
+Subject: [PATCH] KCM: set the client fd non-blocking to avoid event-loop hangs
+
+The listening socket fd is non-blocking, but accept() does not propagate
+that flag to the accepted connection. KCM issues several I/O syscalls
+within a single tevent callback (read the length header then the body in
+kcm_recv_data(); write the length, retcode and payload in
+kcm_send_data()). A tevent event only guarantees the first syscall can
+make progress without blocking, so on a blocking fd a client that sends
+the 4-byte length header and withholds the body blocks readv() and hangs
+the entire single-threaded KCM responder event loop.
+
+Set the accepted fd non-blocking in kcm_connection_setup() so an
+incomplete transfer surfaces as EAGAIN and is retried on the next event.
+
+:fixes: CVE-2026-80048
+
+Assisted-By: Claude Code (Opus 4.8)
+Reviewed-by: Alexey Tikhonov <atikhono at redhat.com>
+Reviewed-by: Sumit Bose <sbose at redhat.com>
+---
+ src/responder/kcm/kcmsrv_cmd.c | 60 +++++++++++++++++++++-------------
+ 1 file changed, 38 insertions(+), 22 deletions(-)
+
+--- a/src/responder/kcm/kcmsrv_cmd.c
++++ b/src/responder/kcm/kcmsrv_cmd.c
+@@ -59,34 +59,35 @@
+     ssize_t len;
+     struct iovec iov[1];
+ 
+-    iov[0].iov_base = kiov->kiov_base + kiov->nprocessed;
+-    iov[0].iov_len = kiov->kiov_len - kiov->nprocessed;
+-    if (iov[0].iov_len == 0) {
+-        /* This iovec is full (read) or depleted (write), proceed to the next one */
+-        return EOK;
+-    }
+-
+-    if (do_read) {
+-        len = readv(fd, iov, 1);
+-    } else {
+-        len = writev(fd, iov, 1);
+-    }
+-
+-    if (len == -1) {
+-        if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {
+-            return EAGAIN;
++    while (kiov->nprocessed < kiov->kiov_len) {
++        iov[0].iov_base = kiov->kiov_base + kiov->nprocessed;
++        iov[0].iov_len = kiov->kiov_len - kiov->nprocessed;
++
++        if (do_read) {
++            len = readv(fd, iov, 1);
+         } else {
+-            return errno;
++            len = writev(fd, iov, 1);
++        }
++
++        if (len == -1) {
++            if (errno == EINTR) {
++                /* Op was interupted but data may still be available. */
++                continue;
++            } else if (errno == EAGAIN || errno == EWOULDBLOCK) {
++                return EAGAIN;
++            } else {
++                return errno;
++            }
+         }
+-    }
+ 
+-    if (len == 0) {
+-        /* Read event on fd that doesn't yield data? error */
+-        return ENODATA;
++        if (len == 0) {
++            /* Peer closed the connection (read side); nothing more to do. */
++            return ENODATA;
++        }
++
++        kiov->nprocessed += len;
+     }
+ 
+-    /* Decrease the amount of available free space in the iovec */
+-    kiov->nprocessed += len;
+     return EOK;
+ }
+ 
+@@ -629,6 +630,21 @@
+ 
+ int kcm_connection_setup(struct cli_ctx *cctx)
+ {
++    errno_t ret;
++
++    /* KCM reads the length header and then the message body, and writes
++     * the reply length, retcode and payload, all within a single tevent
++     * callback. A tevent event only guarantees the first I/O will make
++     * progress without blocking; the later ones must be non-blocking, or
++     * a client that withholds the body (or does not drain the reply)
++     * would block the entire responder event loop. */
++    ret = sss_fd_nonblocking(cctx->cfd);
++    if (ret != EOK) {
++        DEBUG(SSSDBG_CRIT_FAILURE,
++              "Failed to set the KCM client fd non-blocking\n");
++        return ret;
++    }
++
+     cctx->cfd_handler = kcm_fd_handler;
+     return EOK;
+ }


=====================================
debian/patches/CVE-2026-80048-2.diff
=====================================
@@ -0,0 +1,84 @@
+From 2c8f6382c6f1c49f38b883117c1614e25354d015 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Pavel=20B=C5=99ezina?= <pbrezina at redhat.com>
+Date: Thu, 1 Oct 2026 15:10:25 +0200
+Subject: [PATCH] KCM: allocate body buffer only once
+
+Now that kcm_iovec_op() correctly returns EAGAIN on a partial body read,
+kcm_recv_data() is re-entered to resume the transfer. It re-allocated the
+body buffer on every entry, pointing v_msg.kiov_base at the new allocation
+while leaving nprocessed untouched: the previous partially-filled buffer
+was orphaned (a per-retry leak) and the already-read prefix of the new
+buffer was left uninitialized, corrupting the assembled message.
+
+Allocate the buffer only when kiov_base is still NULL, so re-entries keep
+filling the same allocation.
+
+Related to: CVE-2026-80048
+
+Assisted-By: Claude Code (Opus 4.8)
+Reviewed-by: Alexey Tikhonov <atikhono at redhat.com>
+Reviewed-by: Sumit Bose <sbose at redhat.com>
+---
+ src/responder/kcm/kcmsrv_cmd.c | 48 ++++++++++++++++++----------------
+ 1 file changed, 25 insertions(+), 23 deletions(-)
+
+--- a/src/responder/kcm/kcmsrv_cmd.c
++++ b/src/responder/kcm/kcmsrv_cmd.c
+@@ -423,32 +423,34 @@
+     uint32_t msglen;
+     errno_t ret;
+ 
+-    ret = kcm_read_iovec(fd, &reqbuf->v_len);
+-    if (ret != EOK) {
+-        /* Not all errors are fatal, hence we don't print DEBUG messages
+-         * here, but in the caller
+-         */
+-        return ret;
+-    }
++    if (reqbuf->v_msg.kiov_base == NULL) {
++        ret = kcm_read_iovec(fd, &reqbuf->v_len);
++        if (ret != EOK) {
++            /* Not all errors are fatal, hence we don't print DEBUG messages
++            * here, but in the caller
++            */
++            return ret;
++        }
+ 
+-    msglen = kcm_input_get_payload_len(&reqbuf->v_len);
+-    if (msglen > KCM_PACKET_MAX_SIZE) {
+-        DEBUG(SSSDBG_CRIT_FAILURE,
+-              "Request exceeds the KCM protocol limit, aborting\n");
+-        return E2BIG;
+-    }
++        msglen = kcm_input_get_payload_len(&reqbuf->v_len);
++        if (msglen > KCM_PACKET_MAX_SIZE) {
++            DEBUG(SSSDBG_CRIT_FAILURE,
++                  "Request exceeds the KCM protocol limit, aborting\n");
++            return E2BIG;
++        }
+ 
+-    msg = talloc_array(mem_ctx, uint8_t, msglen);
+-    if (msg == NULL) {
+-        DEBUG(SSSDBG_CRIT_FAILURE,
+-              "Failed to allocate memory for the message\n");
+-        return ENOMEM;
+-    }
+-    talloc_set_destructor((void *) msg, sss_erase_talloc_mem_securely);
++        msg = talloc_array(mem_ctx, uint8_t, msglen);
++        if (msg == NULL) {
++            DEBUG(SSSDBG_CRIT_FAILURE,
++                  "Failed to allocate memory for the message\n");
++            return ENOMEM;
++        }
++        talloc_set_destructor((void *) msg, sss_erase_talloc_mem_securely);
+ 
+-    /* Set the buffer and its expected len to receive the data */
+-    reqbuf->v_msg.kiov_base = msg;
+-    reqbuf->v_msg.kiov_len = msglen;
++        /* Set the buffer and its expected len to receive the data */
++        reqbuf->v_msg.kiov_base = msg;
++        reqbuf->v_msg.kiov_len = msglen;
++    }
+ 
+     ret = kcm_read_iovec(fd, &reqbuf->v_msg);
+     if (ret != EOK) {


=====================================
debian/patches/CVE-2026-80048-3.diff
=====================================
@@ -0,0 +1,47 @@
+From 4a7e9ac4a1c2c019511876f44579bfd0aebb21f8 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Pavel=20B=C5=99ezina?= <pbrezina at redhat.com>
+Date: Thu, 1 Oct 2026 15:11:08 +0200
+Subject: [PATCH] KCM: reject request bodies smaller than the protocol header
+
+kcm_recv_data() validated only the upper bound of the attacker-controlled
+body length, accepting any value down to zero. A body shorter than the
+4-byte protocol header (major, minor, opcode) can never be a valid KCM
+message, yet it was allocated, read, and only rejected deep in
+kcm_input_parse().
+
+Reject msglen < KCM_MSG_HEADER_SIZE up front, before any allocation.
+The SAFEALIGN_*_CHECK macros already prevent out-of-bounds reads, so this
+is defense-in-depth and earlier, cheaper rejection.
+
+Assisted-By: Claude Code (Opus 4.8)
+Reviewed-by: Alexey Tikhonov <atikhono at redhat.com>
+Reviewed-by: Sumit Bose <sbose at redhat.com>
+---
+ src/responder/kcm/kcmsrv_cmd.c | 9 +++++++++
+ 1 file changed, 9 insertions(+)
+
+--- a/src/responder/kcm/kcmsrv_cmd.c
++++ b/src/responder/kcm/kcmsrv_cmd.c
+@@ -34,6 +34,10 @@
+ /* The return code is 32bits */
+ #define KCM_RETCODE_SIZE 4
+ 
++/* A valid request body carries at least the protocol header:
++ * major (uint8) + minor (uint8) + opcode (uint16). */
++#define KCM_MSG_HEADER_SIZE (2 * sizeof(uint8_t) + sizeof(uint16_t))
++
+ /* KCM operation, its raw input and raw output and result */
+ struct kcm_op_io {
+     struct kcm_op *op;
+@@ -433,6 +437,11 @@
+         }
+ 
+         msglen = kcm_input_get_payload_len(&reqbuf->v_len);
++        if (msglen < KCM_MSG_HEADER_SIZE) {
++            DEBUG(SSSDBG_CRIT_FAILURE, "Request body is too short, aborting\n");
++            return EBADMSG;
++        }
++
+         if (msglen > KCM_PACKET_MAX_SIZE) {
+             DEBUG(SSSDBG_CRIT_FAILURE,
+                   "Request exceeds the KCM protocol limit, aborting\n");


=====================================
debian/patches/CVE-2026-80048-4.diff
=====================================
@@ -0,0 +1,154 @@
+From 0721b661f1d44c0d57831f9881463fa047220db1 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Pavel=20B=C5=99ezina?= <pbrezina at redhat.com>
+Date: Fri, 23 Oct 2026 18:03:19 +0200
+Subject: [PATCH] KCM: add kcm_recv_timeout to avoid stuck requests
+
+This adds a new undocumented kcm "recv_timeout" option (defaults to 5s)
+and a timer on incoming request - the request payload must be read
+within the given time, otherwise the client connection is killed.
+
+Note that we can not just shorten the client_idle_timeout as that would
+prevent client reconnecting on interactive cli applications. See:
+00ae18dc9fd05a0dd12043d50a7fc0f1123bbc85
+
+Related to: CVE-2026-80048
+
+Reviewed-by: Alexey Tikhonov <atikhono at redhat.com>
+Reviewed-by: Sumit Bose <sbose at redhat.com>
+---
+ src/confdb/confdb.h            |  1 +
+ src/config/cfg_rules.ini       |  1 +
+ src/responder/kcm/kcm.c        | 13 +++++++++++++
+ src/responder/kcm/kcmsrv_cmd.c | 33 ++++++++++++++++++++++++++++++++-
+ src/responder/kcm/kcmsrv_pvt.h |  1 +
+ 5 files changed, 48 insertions(+), 1 deletion(-)
+
+--- a/src/confdb/confdb.h
++++ b/src/confdb/confdb.h
+@@ -285,6 +285,7 @@
+ #define CONFDB_KCM_KRB5_VALIDATE "krb5_validate"
+ #define CONFDB_KCM_KRB5_CANONICALIZE "krb5_canonicalize"
+ #define CONFDB_KCM_KRB5_AUTH_TIMEOUT "krb5_auth_timeout"
++#define CONFDB_KCM_RECV_TIMEOUT "recv_timeout" /* Undocumented on purpose */
+ 
+ /* Certificate mapping rules */
+ #define CONFDB_CERTMAP_BASEDN "cn=certmap,cn=config"
+--- a/src/config/cfg_rules.ini
++++ b/src/config/cfg_rules.ini
+@@ -271,6 +271,7 @@
+ option = socket_path
+ option = ccache_storage
+ option = responder_idle_timeout
++option = recv_timeout
+ option = max_ccaches
+ option = max_uid_ccaches
+ option = max_ccache_size
+--- a/src/responder/kcm/kcm.c
++++ b/src/responder/kcm/kcm.c
+@@ -34,6 +34,7 @@
+ 
+ #define DEFAULT_KCM_FD_LIMIT 2048
+ #define DEFAULT_KCM_CLI_IDLE_TIMEOUT 300
++#define DEFAULT_KCM_RECV_TIMEOUT 5
+ 
+ #ifndef SSS_KCM_SOCKET_NAME
+ #define SSS_KCM_SOCKET_NAME DEFAULT_KCM_SOCKET_PATH
+@@ -151,6 +152,18 @@
+         kctx->rctx->client_idle_timeout = 10;
+     }
+ 
++    ret = confdb_get_int(kctx->rctx->cdb,
++                         kctx->rctx->confdb_service_path,
++                         CONFDB_KCM_RECV_TIMEOUT,
++                         DEFAULT_KCM_RECV_TIMEOUT,
++                         &kctx->recv_timeout);
++    if (ret != EOK) {
++        DEBUG(SSSDBG_OP_FAILURE,
++              "Cannot get the kcm recv timeout [%s] [%d]: %s\n",
++               CONFDB_KCM_RECV_TIMEOUT, ret, sss_strerror(ret));
++        goto done;
++    }
++
+     ret = confdb_get_string(kctx->rctx->cdb,
+                             kctx->rctx,
+                             kctx->rctx->confdb_service_path,
+--- a/src/responder/kcm/kcmsrv_cmd.c
++++ b/src/responder/kcm/kcmsrv_cmd.c
+@@ -344,6 +344,9 @@
+     struct kcm_ctx *kctx;
+ 
+     struct kcm_op_io op_io;
++
++    /* cancel kcm_recv if data is not received in time */
++    struct tevent_timer *recv_timeout;
+ };
+ 
+ static void kcm_send_reply(struct kcm_req_ctx *req_ctx)
+@@ -472,6 +475,20 @@
+     return EOK;
+ }
+ 
++static void
++kcm_recv_timeout(struct tevent_context *ev,
++                 struct tevent_timer *te,
++                 struct timeval current_time,
++                 void *ptr)
++{
++    struct kcm_req_ctx *req = talloc_get_type(ptr, struct kcm_req_ctx);
++
++    DEBUG(SSSDBG_OP_FAILURE,
++          "Client %p did not send data in time, killing it\n", req->cctx);
++
++    talloc_free(req->cctx);
++}
++
+ /* Mind that kcm_new_req() does not take a mem_ctx argument on purpose as we
+  * really want the cctx to be the memory context here so that if the client
+  * disconnects, the request goes away. */
+@@ -479,6 +496,7 @@
+                                        struct kcm_ctx *kctx)
+ {
+     struct kcm_req_ctx *req;
++    struct timeval tv;
+ 
+     req = talloc_zero(cctx, struct kcm_req_ctx);
+     if (req == NULL) {
+@@ -497,6 +515,18 @@
+     req->cctx = cctx;
+     req->kctx = kctx;
+ 
++    if (kctx->recv_timeout > 0) {
++        tv = tevent_timeval_current_ofs(kctx->recv_timeout, 0);
++        req->recv_timeout = tevent_add_timer(cctx->ev, req, tv, kcm_recv_timeout,
++                                             req);
++        if (req->recv_timeout == NULL) {
++            DEBUG(SSSDBG_CRIT_FAILURE, "Cannot setup kcm_recv timeout\n");
++            talloc_free(req);
++            return NULL;
++        }
++    }
++
++
+     return req;
+ }
+ 
+@@ -541,7 +571,8 @@
+         DEBUG(SSSDBG_TRACE_ALL, "Retry later\n");
+         return;
+     case EOK:
+-        /* all fine */
++        /* all data have been received */
++        talloc_zfree(req->recv_timeout);
+         break;
+     default:
+         DEBUG(SSSDBG_FATAL_FAILURE,
+--- a/src/responder/kcm/kcmsrv_pvt.h
++++ b/src/responder/kcm/kcmsrv_pvt.h
+@@ -71,6 +71,7 @@
+ struct kcm_ctx {
+     struct resp_ctx *rctx;
+     int fd_limit;
++    int recv_timeout;
+     char *socket_path;
+     enum kcm_ccdb_be cc_be;
+     struct kcm_ops_queue_ctx *qctx;


=====================================
debian/patches/CVE-2026-87853.diff
=====================================
@@ -0,0 +1,27 @@
+From 8180e70a2708dbf8ac6f089119922dec81fcc503 Mon Sep 17 00:00:00 2001
+From: Alexey Tikhonov <atikhono at redhat.com>
+Date: Wed, 9 Sep 2026 17:18:02 +0200
+Subject: [PATCH] IDP: fix user matching in `eval_access_token_buf()`
+
+Make sure it is exact, not merely a prefix match.
+
+:fixes: CVE-2026-87853
+
+Reviewed-by: Sumit Bose <sbose at redhat.com>
+(cherry picked from commit f3a324918c1a35bd0195a1de5b17897a0d3b6274)
+---
+ src/providers/idp/idp_auth_eval.c | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+--- a/src/providers/idp/idp_auth_eval.c
++++ b/src/providers/idp/idp_auth_eval.c
+@@ -294,7 +294,8 @@
+         goto done;
+     }
+ 
+-    if (strncmp(uuid, (char *) user_reply, user_reply_len) != 0) {
++    if ((strlen(uuid) != user_reply_len) ||
++        (strncmp(uuid, (char *) user_reply, user_reply_len) != 0)) {
+         DEBUG(SSSDBG_OP_FAILURE,
+               "UUID [%s] of user [%s] and input [%.*s] do not match.\n",
+               uuid, user, (int) user_reply_len, user_reply);


=====================================
debian/patches/CVE-2026-88252.diff
=====================================
@@ -0,0 +1,150 @@
+From a44d7358b21256b8c1da99d99a3ea7ad7ba42e07 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Pavel=20B=C5=99ezina?= <pbrezina at redhat.com>
+Date: Tue, 13 Oct 2026 14:08:52 +0200
+Subject: [PATCH] responder: back off accept() on fd exhaustion to stop
+ busy-spin
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+accept_fd_handler() did not inspect errno on accept() failure. When
+accept() failed with EMFILE/ENFILE (process/system out of file
+descriptors), the persistently registered listening fd (rctx->lfde)
+stayed readable and, with a non-empty listen backlog, the event loop
+re-fired the handler immediately, failing again forever. This busy-spin
+pegs a CPU and stalls the responder, a local DoS reachable by any user
+via the NSS/PAM sockets.
+
+On EMFILE/ENFILE, disable readability on the listening fd
+(TEVENT_FD_NOT_READABLE) and schedule a one-shot tevent timer (parented
+under accept_fd_ctx, guarded against double-scheduling) that re-enables
+it (TEVENT_FD_READABLE) after a bounded exponential backoff (200ms,
+doubling, capped at 5s, reset on the next successful accept). If the
+timer cannot be allocated, readability is re-enabled immediately so the
+listener never becomes permanently deaf. errno is saved before DEBUG().
+Other accept() errors and the successful path are unchanged.
+
+:fixes: CVE-2026-88252
+
+Assisted-By: Claude Code (Opus 4.8)
+Reviewed-by: Alexey Tikhonov <atikhono at redhat.com>
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/responder/common/responder_common.c | 78 ++++++++++++++++++++++++-
+ 1 file changed, 77 insertions(+), 1 deletion(-)
+
+--- a/src/responder/common/responder_common.c
++++ b/src/responder/common/responder_common.c
+@@ -492,9 +492,21 @@
+     return 0;
+ }
+ 
++/* When accept() fails because the process or the system ran out of file
++ * descriptors (EMFILE/ENFILE), the listening fd stays readable and the event
++ * loop would immediately re-fire the accept handler, busy-spinning the
++ * responder. In that case we temporarily disable readability on the listening
++ * fd and re-enable it after a backoff. The backoff grows exponentially (so we
++ * do not hammer the CPU while fd pressure persists) up to a cap, and is reset
++ * to the base value on the next successful accept(). */
++#define ACCEPT_RESUME_BACKOFF_BASE_US (200 * 1000)        /* 200 ms */
++#define ACCEPT_RESUME_BACKOFF_MAX_US  (5 * 1000 * 1000)   /* 5 s */
++
+ struct accept_fd_ctx {
+     struct resp_ctx *rctx;
+     connection_setup_t connection_setup;
++    struct tevent_timer *resume_accept_timer;
++    uint32_t accept_backoff_us;
+ };
+ 
+ /*
+@@ -517,6 +529,56 @@
+     return;
+ }
+ 
++static void accept_resume_timer(struct tevent_context *ev,
++                                struct tevent_timer *te,
++                                struct timeval current_time,
++                                void *data)
++{
++    struct accept_fd_ctx *accept_ctx;
++
++    accept_ctx = talloc_get_type(data, struct accept_fd_ctx);
++
++    accept_ctx->resume_accept_timer = NULL;
++    TEVENT_FD_READABLE(accept_ctx->rctx->lfde);
++}
++
++/* Handle an accept() failure caused by file descriptor exhaustion by pausing
++ * accept() for a bounded, exponentially growing backoff instead of letting the
++ * event loop busy-spin on the still-readable listening fd. */
++static void accept_fd_backoff(struct accept_fd_ctx *accept_ctx)
++{
++    struct resp_ctx *rctx = accept_ctx->rctx;
++    struct timeval tv;
++
++    if (accept_ctx->resume_accept_timer != NULL) {
++        return;
++    }
++
++    tv = tevent_timeval_current_ofs(accept_ctx->accept_backoff_us / 1000000,
++                                    accept_ctx->accept_backoff_us % 1000000);
++
++    accept_ctx->resume_accept_timer = tevent_add_timer(rctx->ev, accept_ctx, tv,
++                                                       accept_resume_timer,
++                                                       accept_ctx);
++    if (accept_ctx->resume_accept_timer == NULL) {
++        DEBUG(SSSDBG_CRIT_FAILURE,
++              "Failed to schedule accept() resume timer, keeping the fd readable\n");
++        return;
++    }
++
++    DEBUG(SSSDBG_IMPORTANT_INFO,
++          "Out of file descriptors, pausing accept() for %u ms\n",
++          accept_ctx->accept_backoff_us / 1000);
++
++    TEVENT_FD_NOT_READABLE(rctx->lfde);
++
++    /* Grow the backoff for the next consecutive failure, up to the cap. */
++    accept_ctx->accept_backoff_us *= 2;
++    if (accept_ctx->accept_backoff_us > ACCEPT_RESUME_BACKOFF_MAX_US) {
++        accept_ctx->accept_backoff_us = ACCEPT_RESUME_BACKOFF_MAX_US;
++    }
++}
++
+ static void accept_fd_handler(struct tevent_context *ev,
+                               struct tevent_fd *fde,
+                               uint16_t flags, void *ptr)
+@@ -547,11 +609,24 @@
+     len = sizeof(cctx->addr);
+     cctx->cfd = accept(rctx->lfd, (struct sockaddr *)&cctx->addr, &len);
+     if (cctx->cfd == -1) {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Accept failed [%s]\n", strerror(errno));
++        ret = errno;
++
++        DEBUG(SSSDBG_CRIT_FAILURE, "Accept failed [%s]\n", strerror(ret));
+         talloc_free(cctx);
++
++        /* On file descriptor exhaustion the listening fd stays readable and
++         * the event loop would busy-spin re-entering this handler. Back off
++         * instead. Other errors (e.g. ECONNABORTED/EINTR/EPROTO) are transient
++         * and handled by simply returning. */
++        if (ret == EMFILE || ret == ENFILE) {
++            accept_fd_backoff(accept_ctx);
++        }
+         return;
+     }
+ 
++    /* Successful accept: reset the fd-exhaustion backoff to its base value. */
++    accept_ctx->accept_backoff_us = ACCEPT_RESUME_BACKOFF_BASE_US;
++
+     ret = get_client_cred(cctx);
+     if (ret != EOK) {
+         DEBUG(SSSDBG_CRIT_FAILURE, "get_client_cred() failed\n");
+@@ -779,6 +854,7 @@
+         if(!accept_ctx) goto failed;
+         accept_ctx->rctx = rctx;
+         accept_ctx->connection_setup = conn_setup;
++        accept_ctx->accept_backoff_us = ACCEPT_RESUME_BACKOFF_BASE_US;
+ 
+         rctx->lfde = tevent_add_fd(rctx->ev, rctx, rctx->lfd,
+                                    TEVENT_FD_READ, accept_fd_handler,


=====================================
debian/patches/CVE-2026-90462.diff
=====================================
@@ -0,0 +1,54 @@
+From 42db412156eeae2fe47b5a76519cd79d6ecf61d1 Mon Sep 17 00:00:00 2001
+From: Alexey Tikhonov <atikhono at redhat.com>
+Date: Wed, 23 Sep 2026 17:20:47 +0200
+Subject: [PATCH] LDAP: fix fail-open in ppolicy access check on zero results
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+In `sdap_access_ppolicy_step_done()` a base-scoped ppolicy search that
+returned zero entries logged "Denying access" but left `locked` as
+false, so the common tail returned EOK and cached an "allow" decision.
+This let a deleted or deprovisioned but cached on the host user keep
+passing access checks.
+
+Set `locked = true` for the num_results < 1 case so the request is
+denied and the deny decision is cached, consistent with
+the analogous handling in `sdap_access_filter_done()`.
+
+:fixes: CVE-2026-90462
+
+Commit message Assisted-By: Claude Code (Opus 4.8)
+
+Reviewed-by: Alejandro López <allopez at redhat.com>
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/providers/ldap/sdap_access.c | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/src/providers/ldap/sdap_access.c b/src/providers/ldap/sdap_access.c
+index bbfa2620d04..4f4711e6fce 100644
+--- a/src/providers/ldap/sdap_access.c
++++ b/src/providers/ldap/sdap_access.c
+@@ -1912,11 +1912,11 @@ is_account_locked(const char *pwdAccountLockedTime,
+ static void sdap_access_ppolicy_step_done(struct tevent_req *subreq)
+ {
+     int ret, tret, dp_error;
+-    size_t num_results;
++    size_t num_results = 0;
+     bool locked = false;
+     const char *pwdAccountLockedTime;
+     const char *pwdAccountLockedDurationTime;
+-    struct sysdb_attrs **results;
++    struct sysdb_attrs **results = NULL;
+     struct tevent_req *req;
+     struct sdap_access_ppolicy_req_ctx *state;
+ 
+@@ -1954,6 +1954,7 @@ static void sdap_access_ppolicy_step_done(struct tevent_req *subreq)
+         DEBUG(SSSDBG_CONF_SETTINGS,
+               "User [%s] was not found with the specified filter. "
+               "Denying access.\n", state->username);
++        locked = true;
+     } else if (results == NULL) {
+         DEBUG(SSSDBG_CRIT_FAILURE, "num_results > 0, but results is NULL\n");
+         ret = ERR_INTERNAL;


=====================================
debian/patches/CVE-2026-90463-1.diff
=====================================
@@ -0,0 +1,281 @@
+From 79821dc9ab9fb04f6e6b6fa09cb5474f0ec11685 Mon Sep 17 00:00:00 2001
+From: Alexey Tikhonov <atikhono at redhat.com>
+Date: Wed, 23 Sep 2026 14:56:19 +0200
+Subject: [PATCH] NSS: factor request body validation into a helper
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Replace the copy&pasted "get body, reject empty/short, check NULL
+termination" preamble in the NSS request parsers with a single
+`sss_nss_get_input_body()` helper taking a minimum length and a
+terminator flag.
+Used by `parse_name()`, `parse_name_ex()`, `parse_svc_name()`,
+`parse_svc_port()`, `parse_cert()`, `parse_sid()` and `parse_addr()`;
+the exact-length parsers `parse_id()`/`parse_id_ex()` keep their own
+checks.
+
+Implementation assisted-by: Claude Code (Opus 4.8)
+
+Reviewed-by: Alejandro López <allopez at redhat.com>
+Reviewed-by: Pavel Březina <pbrezina at redhat.com>
+---
+ src/responder/nss/nss_protocol.c | 141 +++++++++++++------------------
+ 1 file changed, 59 insertions(+), 82 deletions(-)
+
+diff --git a/src/responder/nss/nss_protocol.c b/src/responder/nss/nss_protocol.c
+index 890d4d71184..a921061141c 100644
+--- a/src/responder/nss/nss_protocol.c
++++ b/src/responder/nss/nss_protocol.c
+@@ -101,11 +101,14 @@ void sss_nss_protocol_reply(struct cli_ctx *cli_ctx,
+     sss_nss_protocol_done(cli_ctx, ret);
+ }
+ 
+-errno_t
+-sss_nss_protocol_parse_name(struct cli_ctx *cli_ctx, const char **_rawname)
++static errno_t
++sss_nss_get_input_body(struct cli_ctx *cli_ctx,
++                       size_t min_len,
++                       bool require_terminator,
++                       uint8_t **_body,
++                       size_t *_blen)
+ {
+     struct cli_protocol *pctx;
+-    const char *rawname;
+     uint8_t *body;
+     size_t blen;
+ 
+@@ -113,18 +116,39 @@ sss_nss_protocol_parse_name(struct cli_ctx *cli_ctx, const char **_rawname)
+ 
+     sss_packet_get_body(pctx->creq->in, &body, &blen);
+ 
+-    /* If the body is empty fail. */
+-    if (blen == 0) {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
++    if (require_terminator && min_len < 1) {
++        min_len = 1;
++    }
++
++    if (blen < min_len) {
++        DEBUG(SSSDBG_CRIT_FAILURE, "Body too short!\n");
+         return EINVAL;
+     }
+ 
+-    /* If not terminated fail. */
+-    if (body[blen - 1] != '\0') {
++    if (require_terminator && body[blen - 1] != '\0') {
+         DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated!\n");
+         return EINVAL;
+     }
+ 
++    *_body = body;
++    *_blen = blen;
++
++    return EOK;
++}
++
++errno_t
++sss_nss_protocol_parse_name(struct cli_ctx *cli_ctx, const char **_rawname)
++{
++    const char *rawname;
++    uint8_t *body;
++    size_t blen;
++    errno_t ret;
++
++    ret = sss_nss_get_input_body(cli_ctx, 1, true, &body, &blen);
++    if (ret != EOK) {
++        return ret;
++    }
++
+     /* If the body isn't valid UTF-8, fail */
+     if (!sss_utf8_check(body, blen - 1)) {
+         DEBUG(SSSDBG_CRIT_FAILURE, "Body is not UTF-8 string!\n");
+@@ -146,20 +170,19 @@ errno_t
+ sss_nss_protocol_parse_name_ex(struct cli_ctx *cli_ctx, const char **_rawname,
+                            uint32_t *_flags)
+ {
+-    struct cli_protocol *pctx;
+     const char *rawname;
+     uint8_t *body;
+     size_t blen;
+     uint8_t *p;
+     uint32_t flags;
++    errno_t ret;
+ 
+-    pctx = talloc_get_type(cli_ctx->protocol_ctx, struct cli_protocol);
+-
+-    sss_packet_get_body(pctx->creq->in, &body, &blen);
+-
+-    if (blen < 1 + sizeof(uint32_t)) {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Body too short!\n");
+-        return EINVAL;
++    /* The trailing uint32_t flags follow the NUL-terminated name, so the
++     * terminator is not the last byte; check its position ourselves below. */
++    ret = sss_nss_get_input_body(cli_ctx, 1 + sizeof(uint32_t), false,
++                                 &body, &blen);
++    if (ret != EOK) {
++        return ret;
+     }
+ 
+     /* If first argument not terminated fail. */
+@@ -264,7 +287,6 @@ sss_nss_protocol_parse_svc_name(struct cli_ctx *cli_ctx,
+                             const char **_name,
+                             const char **_protocol)
+ {
+-    struct cli_protocol *pctx;
+     const char *protocol;
+     const char *name;
+     size_t protocol_len;
+@@ -272,21 +294,11 @@ sss_nss_protocol_parse_svc_name(struct cli_ctx *cli_ctx,
+     uint8_t *body;
+     size_t blen;
+     int i;
++    errno_t ret;
+ 
+-    pctx = talloc_get_type(cli_ctx->protocol_ctx, struct cli_protocol);
+-
+-    sss_packet_get_body(pctx->creq->in, &body, &blen);
+-
+-    /* If the body is empty fail. */
+-    if (blen == 0) {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
+-        return EINVAL;
+-    }
+-
+-    /* If not terminated fail. */
+-    if (body[blen - 1] != '\0') {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated\n");
+-        return EINVAL;
++    ret = sss_nss_get_input_body(cli_ctx, 1, true, &body, &blen);
++    if (ret != EOK) {
++        return ret;
+     }
+ 
+     /* Calculate service name length. */
+@@ -327,28 +339,17 @@ sss_nss_protocol_parse_svc_port(struct cli_ctx *cli_ctx,
+                             uint16_t *_port,
+                             const char **_protocol)
+ {
+-    struct cli_protocol *pctx;
+     const char *protocol;
+     size_t protocol_len;
+     uint16_t port;
+     uint8_t *body;
+     size_t blen;
+     int i;
++    errno_t ret;
+ 
+-    pctx = talloc_get_type(cli_ctx->protocol_ctx, struct cli_protocol);
+-
+-    sss_packet_get_body(pctx->creq->in, &body, &blen);
+-
+-    /* If the body is empty fail. */
+-    if (blen == 0) {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
+-        return EINVAL;
+-    }
+-
+-    /* If not terminated fail. */
+-    if (body[blen - 1] != '\0') {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated\n");
+-        return EINVAL;
++    ret = sss_nss_get_input_body(cli_ctx, 1, true, &body, &blen);
++    if (ret != EOK) {
++        return ret;
+     }
+ 
+     SAFEALIGN_COPY_UINT16(&port, body, NULL);
+@@ -379,7 +380,6 @@ errno_t
+ sss_nss_protocol_parse_cert(struct cli_ctx *cli_ctx,
+                         const char **_derb64)
+ {
+-    struct cli_protocol *pctx;
+     const char *derb64;
+     size_t pem_size;
+     char *pem_cert;
+@@ -387,20 +387,9 @@ sss_nss_protocol_parse_cert(struct cli_ctx *cli_ctx,
+     size_t blen;
+     errno_t ret;
+ 
+-    pctx = talloc_get_type(cli_ctx->protocol_ctx, struct cli_protocol);
+-
+-    sss_packet_get_body(pctx->creq->in, &body, &blen);
+-
+-    /* If the body is empty fail. */
+-    if (blen == 0) {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
+-        return EINVAL;
+-    }
+-
+-    /* If not terminated fail. */
+-    if (body[blen - 1] != '\0') {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated\n");
+-        return EINVAL;
++    ret = sss_nss_get_input_body(cli_ctx, 1, true, &body, &blen);
++    if (ret != EOK) {
++        return ret;
+     }
+ 
+     derb64 = (const char *)body;
+@@ -427,7 +416,6 @@ errno_t
+ sss_nss_protocol_parse_sid(struct cli_ctx *cli_ctx,
+                        const char **_sid)
+ {
+-    struct cli_protocol *pctx;
+     struct sss_nss_ctx *nss_ctx;
+     const char *sid;
+     uint8_t *bin_sid;
+@@ -435,22 +423,13 @@ sss_nss_protocol_parse_sid(struct cli_ctx *cli_ctx,
+     uint8_t *body;
+     size_t blen;
+     enum idmap_error_code err;
++    errno_t ret;
+ 
+-    pctx = talloc_get_type(cli_ctx->protocol_ctx, struct cli_protocol);
+     nss_ctx = talloc_get_type(cli_ctx->rctx->pvt_ctx, struct sss_nss_ctx);
+ 
+-    sss_packet_get_body(pctx->creq->in, &body, &blen);
+-
+-    /* If the body is empty fail. */
+-    if (blen == 0) {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
+-        return EINVAL;
+-    }
+-
+-    /* If not terminated fail. */
+-    if (body[blen - 1] != '\0') {
+-        DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated\n");
+-        return EINVAL;
++    ret = sss_nss_get_input_body(cli_ctx, 1, true, &body, &blen);
++    if (ret != EOK) {
++        return ret;
+     }
+ 
+     sid = (const char *)body;
+@@ -479,7 +458,6 @@ sss_nss_protocol_parse_addr(struct cli_ctx *cli_ctx,
+                         uint32_t *_addrlen,
+                         uint8_t **_addr)
+ {
+-    struct cli_protocol *pctx;
+     uint8_t *body;
+     size_t blen;
+     uint32_t af;
+@@ -487,13 +465,12 @@ sss_nss_protocol_parse_addr(struct cli_ctx *cli_ctx,
+     socklen_t addrlen;
+     char buf[INET6_ADDRSTRLEN];
+     const char *addrstr = NULL;
++    errno_t ret;
+ 
+-    pctx = talloc_get_type(cli_ctx->protocol_ctx, struct cli_protocol);
+-
+-    sss_packet_get_body(pctx->creq->in, &body, &blen);
+-
+-    if (blen < sizeof(uint32_t) * 2) {
+-        return EINVAL;
++    ret = sss_nss_get_input_body(cli_ctx, sizeof(uint32_t) * 2, false,
++                                 &body, &blen);
++    if (ret != EOK) {
++        return ret;
+     }
+ 
+     SAFEALIGN_COPY_UINT32(&af, body, NULL);


=====================================
debian/patches/CVE-2026-90463-2.diff
=====================================
@@ -0,0 +1,107 @@
+From e83a030e335044ef143f88b9593204e39e6f94b8 Mon Sep 17 00:00:00 2001
+From: Alexey Tikhonov <atikhono at redhat.com>
+Date: Wed, 23 Sep 2026 16:39:58 +0200
+Subject: [PATCH] NSS: bound service parser reads to the request body length
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+`sss_nss_protocol_parse_svc_port()` and `sss_nss_protocol_parse_svc_name()`
+only required a single terminating NULL, then read past it: svc_port
+copied an 8-byte header and scanned the protocol string without
+ensuring the body was that long, and svc_name scanned the protocol
+field with no upper bound when the body held no second terminator. A
+crafted GETSERVBYPORT/GETSERVBYNAME request from a local client could
+therefore read beyond the packet body and crash the NSS responder.
+
+Require the full fixed header plus the protocol terminator in svc_port,
+and bound the protocol scan by blen in svc_name. Also correct the stale
+GETSERVBYPORT request layout comment (the header is 8 bytes, not 16).
+
+:fixes: CVE-2026-90463
+
+Assisted-By: Claude Code (Opus 4.8)
+Reviewed-by: Alejandro López <allopez at redhat.com>
+Reviewed-by: Pavel Březina <pbrezina at redhat.com>
+---
+ src/responder/nss/nss_protocol.c | 27 +++++++++++++++++++++------
+ src/sss_client/nss_services.c    |  7 ++++---
+ 2 files changed, 25 insertions(+), 9 deletions(-)
+
+diff --git a/src/responder/nss/nss_protocol.c b/src/responder/nss/nss_protocol.c
+index a921061141c..1b7be31f6f7 100644
+--- a/src/responder/nss/nss_protocol.c
++++ b/src/responder/nss/nss_protocol.c
+@@ -293,7 +293,7 @@ sss_nss_protocol_parse_svc_name(struct cli_ctx *cli_ctx,
+     size_t name_len;
+     uint8_t *body;
+     size_t blen;
+-    int i;
++    size_t i;
+     errno_t ret;
+ 
+     ret = sss_nss_get_input_body(cli_ctx, 1, true, &body, &blen);
+@@ -301,17 +301,25 @@ sss_nss_protocol_parse_svc_name(struct cli_ctx *cli_ctx,
+         return ret;
+     }
+ 
+-    /* Calculate service name length. */
++    /* Calculate service name length. The trailing NULL guaranteed by
++     * sss_nss_get_input_body() bounds this scan. */
+     for (i = 0, name_len = 0; body[i] != '\0'; i++) {
+         name_len++;
+     }
+ 
+-    /* Calculate protocol name length, use index from previous cycle. */
+-    for (protocol_len = 0; body[i + 1] != '\0'; i++) {
++    if (name_len == 0) {
++        return EINVAL;
++    }
++
++    /* Calculate protocol name length. The protocol field follows the service
++     * name's NULL terminator; bound the scan by blen so a request without a
++     * second terminator cannot read past the packet body. */
++    for (i = name_len + 1, protocol_len = 0; i < blen && body[i] != '\0'; i++) {
+         protocol_len++;
+     }
+ 
+-    if (name_len == 0) {
++    if (i >= blen) {
++        DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated\n");
+         return EINVAL;
+     }
+ 
+@@ -347,7 +355,14 @@ sss_nss_protocol_parse_svc_port(struct cli_ctx *cli_ctx,
+     int i;
+     errno_t ret;
+ 
+-    ret = sss_nss_get_input_body(cli_ctx, 1, true, &body, &blen);
++    /* The request body is an 8-byte fixed header followed by a NUL-terminated
++     * protocol string: bytes 0-1 hold the 16-bit port (network byte order),
++     * bytes 2-3 and 4-7 are zero padding (a uint16 then a uint32), and the
++     * protocol string starts at byte 8. Require the whole header plus at least
++     * the protocol's terminating NUL. */
++    ret = sss_nss_get_input_body(cli_ctx,
++                                 2 * sizeof(uint16_t) + sizeof(uint32_t) + 1,
++                                 true, &body, &blen);
+     if (ret != EOK) {
+         return ret;
+     }
+diff --git a/src/sss_client/nss_services.c b/src/sss_client/nss_services.c
+index 6ca48443ee5..855a55ae023 100644
+--- a/src/sss_client/nss_services.c
++++ b/src/sss_client/nss_services.c
+@@ -59,9 +59,10 @@ static void sss_nss_getservent_data_clean(void) {
+  * Protocol may be zero-length to imply "any"
+  *
+  * GETSERVBYPORT Request:
+- * 0-3: 16-bit port number in network byte order
+- * 4-15: Reserved/padding
+- * 16-X: Zero-terminated string (protocol)
++ * 0-1: 16-bit port number in network byte order
++ * 2-3: 16-bit reserved/padding
++ * 4-7: 32-bit reserved/padding
++ * 8-X: Zero-terminated string (protocol)
+  * Protocol may be zero-length to imply "any"
+  *
+  * Replies:


=====================================
debian/patches/CVE-2026-90994.diff
=====================================
@@ -0,0 +1,74 @@
+From 8dbdcf9987363d734faef25be76cc0f51180f5c6 Mon Sep 17 00:00:00 2001
+From: Alexey Tikhonov <atikhono at redhat.com>
+Date: Wed, 23 Sep 2026 10:58:23 +0200
+Subject: [PATCH] PAM: fix out-of-bounds read in v1 request parser
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+pam_parse_in_data() computed "last = blen - 1" before validating blen,
+so an empty body (blen == 0) underflowed last to SIZE_MAX and the string
+parsing loops read past the buffer. A truncated body could likewise
+advance "end" to blen, making the next "body[end++]" terminator check
+read one byte out of bounds. A local client negotiating protocol v1 could
+send such a malformed request and crash the PAM responder (local DoS).
+
+Reject bodies smaller than the v1 minimum up front (matching the style of
+pam_parse_in_data_v2()) and bounds-check "end" before each terminator
+dereference.
+
+:fixes: CVE-2026-90994
+
+Assisted-By: Claude Code (Opus 4.8)
+Reviewed-by: Alejandro López <allopez at redhat.com>
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/responder/pam/pamsrv_cmd.c | 20 +++++++++++++++-----
+ 1 file changed, 15 insertions(+), 5 deletions(-)
+
+--- a/src/responder/pam/pamsrv_cmd.c
++++ b/src/responder/pam/pamsrv_cmd.c
+@@ -482,28 +482,38 @@
+     size_t last;
+     int ret;
+ 
++    /* A valid v1 request holds five NUL-terminated strings (user, service,
++     * tty, ruser, rhost) followed by two auth tokens. Each string needs at
++     * least its terminator and each auth token needs a type+length header,
++     * so anything smaller is malformed.
++     */
++    if (blen < (5 + 2*2*sizeof(uint32_t))) {
++        DEBUG(SSSDBG_CRIT_FAILURE, "Received data is invalid.\n");
++        return EINVAL;
++    }
++
+     last = blen - 1;
+     end = 0;
+ 
+     /* user name */
+     for (start = end; end < last; end++) if (body[end] == '\0') break;
+-    if (body[end++] != '\0') return EINVAL;
++    if (end >= blen || body[end++] != '\0') return EINVAL;
+     pd->logon_name = (char *) &body[start];
+ 
+     for (start = end; end < last; end++) if (body[end] == '\0') break;
+-    if (body[end++] != '\0') return EINVAL;
++    if (end >= blen || body[end++] != '\0') return EINVAL;
+     pd->service = (char *) &body[start];
+ 
+     for (start = end; end < last; end++) if (body[end] == '\0') break;
+-    if (body[end++] != '\0') return EINVAL;
++    if (end >= blen || body[end++] != '\0') return EINVAL;
+     pd->tty = (char *) &body[start];
+ 
+     for (start = end; end < last; end++) if (body[end] == '\0') break;
+-    if (body[end++] != '\0') return EINVAL;
++    if (end >= blen || body[end++] != '\0') return EINVAL;
+     pd->ruser = (char *) &body[start];
+ 
+     for (start = end; end < last; end++) if (body[end] == '\0') break;
+-    if (body[end++] != '\0') return EINVAL;
++    if (end >= blen || body[end++] != '\0') return EINVAL;
+     pd->rhost = (char *) &body[start];
+ 
+     ret = extract_authtok_v1(pd->authtok, body, blen, &end);


=====================================
debian/patches/CVE-2026-90995.diff
=====================================
@@ -0,0 +1,64 @@
+From 00b51c155a208eb90454d82b320069dfc74f631d Mon Sep 17 00:00:00 2001
+From: Alexey Tikhonov <atikhono at redhat.com>
+Date: Wed, 23 Sep 2026 12:17:49 +0200
+Subject: [PATCH] PAM: avoid NULL deref when service item is missing
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+SSS_PAM_ITEM_SERVICE is optional in the v2/v3 client protocol, so
+pd->service may be NULL. A crafted request omitting it triggered a
+NULL dereference in get_domain_request_type() when pam_app_services
+is configured, crashing the PAM responder (local DoS). Return the
+POSIX default when service is unset, and guard the debug log too.
+
+:fixes: CVE-2026-90995
+
+Assisted-By: Claude Code (Opus 4.8)
+Reviewed-by: Alejandro López <allopez at redhat.com>
+Reviewed-by: Tomáš Halman <thalman at redhat.com>
+---
+ src/responder/pam/pam_prompting_config.c |  2 +-
+ src/responder/pam/pamsrv_cmd.c           | 13 +++++++++++--
+ 2 files changed, 12 insertions(+), 3 deletions(-)
+
+--- a/src/responder/pam/pam_prompting_config.c
++++ b/src/responder/pam/pam_prompting_config.c
+@@ -205,7 +205,7 @@
+ 
+ 
+     dummy = talloc_asprintf(tmp_ctx, "%s/%s", section_path,
+-                                              service_name);
++                            service_name ? service_name : "-");
+     for (c = 0; c < num_sections; c++) {
+         if (strcmp(sections[c], section_path) == 0) {
+             global = true;
+--- a/src/responder/pam/pamsrv_cmd.c
++++ b/src/responder/pam/pamsrv_cmd.c
+@@ -983,8 +983,10 @@
+     }
+ 
+     DEBUG(SSSDBG_TRACE_ALL, "Authentication types for user [%s] and service "
+-                            "[%s]:%s%s%s%s%s\n", pd->user, pd->service,
+-                            types.password_auth ? " password": "",
++                            "[%s]:%s%s%s%s%s\n",
++                            pd->user ? pd->user : "-",
++                            pd->service ? pd->service : "-",
++                            types.password_auth ? " password" : "",
+                             types.otp_auth ? " two-factor" : "",
+                             types.passkey_auth ? " passkey" : "",
+                             types.oauth2_auth ? " oauth2" : "",
+@@ -1879,6 +1881,13 @@
+     /* By default, only POSIX domains are to be contacted */
+     req_dom_type = CACHE_REQ_POSIX_DOM;
+ 
++    /* SSS_PAM_ITEM_SERVICE is optional in the client protocol, so the service
++     * may be unset. Without a service name it can never match a configured
++     * application service, so fall back to the POSIX default. */
++    if (preq->pd->service == NULL) {
++        return req_dom_type;
++    }
++
+     for (int i = 0; pctx->app_services[i]; i++) {
+         if (strcmp(pctx->app_services[i], preq->pd->service) == 0) {
+             req_dom_type = CACHE_REQ_APPLICATION_DOM;


=====================================
debian/patches/CVE-2026-90996.diff
=====================================
@@ -0,0 +1,94 @@
+From c7f1b8a3d506e38af3949eed19e034eb6a005bbf Mon Sep 17 00:00:00 2001
+From: Alexey Tikhonov <atikhono at redhat.com>
+Date: Wed, 23 Sep 2026 14:43:57 +0200
+Subject: [PATCH] NSS: reject empty request body before body[blen - 1] access
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Header-only NSS requests yield blen == 0, causing a size_t underflow
+in the request parsers that read body[blen - 1]. Guard `parse_name()`,
+`parse_svc_name()`, `parse_svc_port()`, `parse_cert()` and `parse_sid()`
+against an empty body.
+
+:fixes: CVE-2026-90996
+
+Assisted-By: Claude Code (Opus 4.8)
+Reviewed-by: Alejandro López <allopez at redhat.com>
+Reviewed-by: Pavel Březina <pbrezina at redhat.com>
+---
+ src/responder/nss/nss_protocol.c | 30 ++++++++++++++++++++++++++++++
+ 1 file changed, 30 insertions(+)
+
+diff --git a/src/responder/nss/nss_protocol.c b/src/responder/nss/nss_protocol.c
+index aa9eca371..890d4d711 100644
+--- a/src/responder/nss/nss_protocol.c
++++ b/src/responder/nss/nss_protocol.c
+@@ -113,6 +113,12 @@ sss_nss_protocol_parse_name(struct cli_ctx *cli_ctx, const char **_rawname)
+ 
+     sss_packet_get_body(pctx->creq->in, &body, &blen);
+ 
++    /* If the body is empty fail. */
++    if (blen == 0) {
++        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
++        return EINVAL;
++    }
++
+     /* If not terminated fail. */
+     if (body[blen - 1] != '\0') {
+         DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated!\n");
+@@ -271,6 +277,12 @@ sss_nss_protocol_parse_svc_name(struct cli_ctx *cli_ctx,
+ 
+     sss_packet_get_body(pctx->creq->in, &body, &blen);
+ 
++    /* If the body is empty fail. */
++    if (blen == 0) {
++        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
++        return EINVAL;
++    }
++
+     /* If not terminated fail. */
+     if (body[blen - 1] != '\0') {
+         DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated\n");
+@@ -327,6 +339,12 @@ sss_nss_protocol_parse_svc_port(struct cli_ctx *cli_ctx,
+ 
+     sss_packet_get_body(pctx->creq->in, &body, &blen);
+ 
++    /* If the body is empty fail. */
++    if (blen == 0) {
++        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
++        return EINVAL;
++    }
++
+     /* If not terminated fail. */
+     if (body[blen - 1] != '\0') {
+         DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated\n");
+@@ -373,6 +391,12 @@ sss_nss_protocol_parse_cert(struct cli_ctx *cli_ctx,
+ 
+     sss_packet_get_body(pctx->creq->in, &body, &blen);
+ 
++    /* If the body is empty fail. */
++    if (blen == 0) {
++        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
++        return EINVAL;
++    }
++
+     /* If not terminated fail. */
+     if (body[blen - 1] != '\0') {
+         DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated\n");
+@@ -417,6 +441,12 @@ sss_nss_protocol_parse_sid(struct cli_ctx *cli_ctx,
+ 
+     sss_packet_get_body(pctx->creq->in, &body, &blen);
+ 
++    /* If the body is empty fail. */
++    if (blen == 0) {
++        DEBUG(SSSDBG_CRIT_FAILURE, "Empty body!\n");
++        return EINVAL;
++    }
++
+     /* If not terminated fail. */
+     if (body[blen - 1] != '\0') {
+         DEBUG(SSSDBG_CRIT_FAILURE, "Body is not null terminated\n");
+-- 
+2.47.3
+


=====================================
debian/patches/series
=====================================
@@ -10,3 +10,27 @@ CVE-2026-68742.diff
 CVE-2026-68743.diff
 CVE-2026-68744.diff
 gdm-51-pam-extension-macros-compat.diff
+CVE-2026-80048-1.diff
+CVE-2026-80048-2.diff
+CVE-2026-80048-3.diff
+CVE-2026-80048-4.diff
+CVE-2026-87853.diff
+CVE-2026-88252.diff
+CVE-2026-90462.diff
+CVE-2026-90994.diff
+CVE-2026-90996.diff
+CVE-2026-90463-1.diff
+CVE-2026-90463-2.diff
+CVE-2026-90995.diff
+CVE-2026-104031.diff
+CVE-2026-104032.diff
+CVE-2026-104033.diff
+CVE-2026-104036.diff
+CVE-2026-104038.diff
+CVE-2026-104039.diff
+CVE-2026-104042.diff
+CVE-2026-104043.diff
+CVE-2026-104044-pre.diff
+CVE-2026-104044.diff
+CVE-2026-104045.diff
+CVE-2026-104046.diff



View it on GitLab: https://salsa.debian.org/sssd-team/sssd/-/compare/12dd5186bb350568fe9161a77d0c5562b2261de4...4044244d710a494e575e67c186db90055d9ed3f2

-- 
View it on GitLab: https://salsa.debian.org/sssd-team/sssd/-/compare/12dd5186bb350568fe9161a77d0c5562b2261de4...4044244d710a494e575e67c186db90055d9ed3f2
You're receiving this email because of your account on salsa.debian.org. Manage all notifications: https://salsa.debian.org/-/profile/notifications | Help: https://salsa.debian.org/help


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://alioth-lists.debian.net/pipermail/pkg-sssd-devel/attachments/20261110/3d13cec4/attachment-0001.htm>


More information about the Pkg-sssd-devel mailing list