AUR AI Reviewer

Review Results

Version #3170 of openssl-1.1 · commit e479b2d6b356 · status Reviewed

Risk 0/5 · Safe .SRCINFO
Result #6531

Comment

The only change in this diff is a pkgrel bump from 13 to 14 in .SRCINFO. This is metadata-only and does not alter sources, build steps, dependencies, install scripts, or package contents. No security-relevant behavior is introduced by this change.

@@ -1,7 +1,7 @@
 pkgbase = openssl-1.1
 	pkgdesc = The Open Source toolkit for Secure Sockets Layer and Transport Layer Security
 	pkgver = 1.1.1.w
-	pkgrel = 13
+	pkgrel = 14
 	url = https://www.openssl.org
 	arch = aarch64
 	arch = x86_64
Risk 0/5 · Safe .SRCINFO
Result #6532

Comment

The change only updates .SRCINFO metadata: pkgrel bump and reordering/replacement of patch source entries plus corresponding checksum list updates. There is no evidence here of new build logic, network access, privilege escalation, or packaging behavior changes. Security impact appears limited to the integrity of the declared patch set, and the diff itself does not introduce any suspicious sources or executable content. I did not inspect the patch files themselves because this review is scoped to the provided .SRCINFO change only.

@@ -57,9 +57,12 @@ pkgbase = openssl-1.1
 	source = CVE-2026-42766.tar
 	source = CVE-2026-45447-1.patch
 	source = CVE-2026-45447-2.patch
+	source = CVE-2026-35189.patch
+	source = CVE-2026-54872.patch
+	source = CVE-2026-63072.patch
 	source = CVE-2025-69419-1.patch
 	source = CVE-2025-69419-2.patch
-	source = CVE-2026-63072.patch
+	source = CVE-2026-75806.patch
 	source = CVE-2026-84782.patch
 	validpgpkeys = EFC0A467D613CB83C7ED6D30D894E2CE8B3D79F5
 	sha256sums = cf3098950cb4d853ad95c0841f1f9c6d3dc102dccfcacd521d93925208b76ac8
Risk 0/5 · Safe .SRCINFO
Result #6533

Comment

The change only updates .SRCINFO metadata to match the PKGBUILD: pkgrel is bumped from 13 to 14 and the source/checksum ordering is adjusted to include newly added CVE patch files. There is no evidence of malicious behavior, no new build-time network access, and no executable packaging logic changed. Risk is minimal because this is metadata-only and consistent with the package’s existing patch-based maintenance workflow.

@@ -106,9 +109,12 @@ pkgbase = openssl-1.1
 	sha256sums = b03d53705375794da859dbd1287b9356a750fd3f669b74403d3f4619d494eab8
 	sha256sums = f5689d1652045fe14c70e6eb68b080b1a26ad1c49d5308cd7212b417e10f2afc
 	sha256sums = 4fe62fbbce088325f5b62fab3edfe59d4d9a8108ddfd06cf2a53fa1bd758c5b3
+	sha256sums = 6b39f01ffb5502c7a88b8d5f64743d8fc5b888ff4dcf81535336d2726f2acf57
+	sha256sums = 9ee83143e426c801638ad773b7e995b69677b097713c48fd26cbaeb65ef63d67
+	sha256sums = d13b969c692af11b5531c76b25f7e8c21fee79f2fca694f53ba1c6754d1ade3f
 	sha256sums = d89423836be0cb5ca076e173ea373c4deeef3d6ffa17085ca8a0850b364d7d3b
 	sha256sums = 933c61f15a81ac9c50f66f8c6c059d09f94a116d7b4c4d534a41b1c8f0140160
-	sha256sums = d13b969c692af11b5531c76b25f7e8c21fee79f2fca694f53ba1c6754d1ade3f
+	sha256sums = 8579d2180e189eed3891fc10e7ff43ac00dc009e58c6c3e783fa181d3b185f4d
 	sha256sums = f41abfd62f213e489afcc3d4608b034e1c71a8cecc10b2bb81fc3a8ece31cc21
 
 pkgname = openssl-1.1
Risk 0/5 · Safe CVE-2026-35189.patch
Result #6534

Comment

The patch is a targeted OpenSSL backport for CVE-2026-35189 and only changes CRL distribution-point handling. I do not see any supply-chain or packaging red flags: no new network access, no shell execution, no privilege changes, and no install-script or unit-file behavior. The code moves construction of relative CRLDP names from certificate parsing to on-demand CRL matching, which is a plausible security fix for a memory-exhaustion issue. The only notable change is an internal API addition and refactor, but it stays within OpenSSL internals and does not introduce suspicious behavior. Overall this looks safe from a package-security perspective.

@@ -0,0 +1,289 @@
+From 6516bcfeff0b4bd57f0d5dbfdc91bcca3f64a1aa Mon Sep 17 00:00:00 2001
+From: Pavol Zacik <pzacik@redhat.com>
+Date: Mon, 9 Nov 2026 14:29:40 +0100
+Subject: [PATCH] Defer computation of relative CRLDP names
+
+These are derived just-in-time, during any actual CRL processing.
+
+Backport from upstream commit 2b93c73b2c70ddc4c61c5e4bfaaa6bd71379eb84
+
+Fixes CVE-2026-35189.
+
+---
+ crypto/x509/x509_vfy.c  | 80 +++++++++++++++++++++++++++++++++++------
+ crypto/x509v3/v3_crld.c | 49 +++++++++++++++----------
+ crypto/x509v3/v3_purp.c | 30 +++++++---------
+ include/crypto/x509.h   |  4 +++
+ 4 files changed, 116 insertions(+), 47 deletions(-)
+
+diff --git a/crypto/x509/x509_vfy.c b/crypto/x509/x509_vfy.c
+index 4c376c5b31..1311a24c49 100644
+--- a/crypto/x509/x509_vfy.c
++++ b/crypto/x509/x509_vfy.c
+@@ -1349,36 +1349,79 @@ static int check_crl_chain(X509_STORE_CTX *ctx,
+     return 0;
+ }
+ 
++/*
++ * Return the full name of the certificate CRL distribution point dp, whose
++ * distpoint is a nameRelativeToCRLIssuer fragment: the CRL issuer name with
++ * the fragment appended.  The CRL issuer is the directoryName in
++ * dp->CRLissuer if there is one, else the issuer of the certificate.
++ *
++ * The result is a fresh X509_NAME owned by the caller.  It is deliberately
++ * not stored in dp->distpoint->dpname: once its extension cache has been
++ * published a certificate is shared between threads without locking, and
++ * computing the name here rather than when the certificate is parsed keeps
++ * a certificate with many relative distribution points from costing a copy
++ * of the issuer name per entry on every parse.  Returns NULL on error.
++ */
++static X509_NAME *crldp_full_name(X509 *x, const DIST_POINT *dp)
++{
++    X509_NAME *iname = NULL;
++    int i;
++
++    /*
++     * Note that the below way of determining iname is not really compliant
++     * with https://tools.ietf.org/html/rfc5280#section-4.2.1.13
++     * According to it, sk_GENERAL_NAME_num(dp->CRLissuer) MUST be <= 1
++     * and any CRLissuer could be of type different to GEN_DIRNAME.
++     */
++    for (i = 0; i < sk_GENERAL_NAME_num(dp->CRLissuer); i++) {
++        GENERAL_NAME *gen = sk_GENERAL_NAME_value(dp->CRLissuer, i);
++
++        if (gen->type == GEN_DIRNAME) {
++            iname = gen->d.directoryName;
++            break;
++        }
++    }
++    if (iname == NULL)
++        iname = X509_get_issuer_name(x);
++    return ossl_dist_point_name_full(dp->distpoint, iname);
++}
++
+ /*-
+  * Check for match between two dist point names: three separate cases.
+  * 1. Both are relative names and compare X509_NAME types.
+  * 2. One full, one relative. Compare X509_NAME to GENERAL_NAMES.
+  * 3. Both are full names and compare two GENERAL_NAMES.
+  * 4. One is NULL: automatic match.
++ *
++ * a is the certificate's distribution point name and b the CRL's issuing
++ * distribution point name.  When a is a relative name, aname is its full
++ * name as built by crldp_full_name(); a->dpname itself is not consulted.
++ * For b the full name is the cached b->dpname set when the CRL was parsed.
+  */
+ 
+-static int idp_check_dp(DIST_POINT_NAME *a, DIST_POINT_NAME *b)
++static int idp_check_dp(DIST_POINT_NAME *a, const X509_NAME *aname,
++                        DIST_POINT_NAME *b)
+ {
+-    X509_NAME *nm = NULL;
++    const X509_NAME *nm = NULL;
+     GENERAL_NAMES *gens = NULL;
+     GENERAL_NAME *gena, *genb;
+     int i, j;
+     if (!a || !b)
+         return 1;
+     if (a->type == 1) {
+-        if (!a->dpname)
++        if (aname == NULL)
+             return 0;
+         /* Case 1: two X509_NAME */
+         if (b->type == 1) {
+             if (!b->dpname)
+                 return 0;
+-            if (!X509_NAME_cmp(a->dpname, b->dpname))
++            if (!X509_NAME_cmp(aname, b->dpname))
+                 return 1;
+             else
+                 return 0;
+         }
+         /* Case 2: set name and GENERAL_NAMES appropriately */
+-        nm = a->dpname;
++        nm = aname;
+         gens = b->name.fullname;
+     } else if (b->type == 1) {
+         if (!b->dpname)
+@@ -1450,11 +1493,28 @@ static int crl_crldp_check(X509 *x, X509_CRL *crl, int crl_score,
+     *preasons = crl->idp_reasons;
+     for (i = 0; i < sk_DIST_POINT_num(x->crldp); i++) {
+         DIST_POINT *dp = sk_DIST_POINT_value(x->crldp, i);
+-        if (crldp_check_crlissuer(dp, crl, crl_score)) {
+-            if (!crl->idp || idp_check_dp(dp->distpoint, crl->idp->distpoint)) {
+-                *preasons &= dp->dp_reasons;
+-                return 1;
+-            }
++        X509_NAME *dpname = NULL;
++        int match;
++
++        if (!crldp_check_crlissuer(dp, crl, crl_score))
++            continue;
++        if (crl->idp == NULL) {
++            match = 1;
++        } else {
++            /*
++             * A relative distribution point name is only comparable in
++             * full form.  Build it for this one comparison and discard it;
++             * if that fails the entry simply does not match.
++             */
++            if (dp->distpoint != NULL && dp->distpoint->type == 1
++                && (dpname = crldp_full_name(x, dp)) == NULL)
++                continue;
++            match = idp_check_dp(dp->distpoint, dpname, crl->idp->distpoint);
++            X509_NAME_free(dpname);
++        }
++        if (match) {
++            *preasons &= dp->dp_reasons;
++            return 1;
+         }
+     }
+     if ((!crl->idp || !crl->idp->distpoint)
+diff --git a/crypto/x509v3/v3_crld.c b/crypto/x509v3/v3_crld.c
+index 4854748ffb..fcd10e5fb6 100644
+--- a/crypto/x509v3/v3_crld.c
++++ b/crypto/x509v3/v3_crld.c
+@@ -477,30 +477,41 @@ static int i2r_crldp(const X509V3_EXT_METHOD *method, void *pcrldp, BIO *out,
+     return 1;
+ }
+ 
+-int DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, X509_NAME *iname)
++/*
++ * Return a new X509_NAME consisting of iname with the nameRelativeToCRLIssuer
++ * fragment of dpn appended, with its DER encoding already cached.
++ * dpn must be a relative name (type 1).  Returns NULL on error.
++ */
++X509_NAME *ossl_dist_point_name_full(const DIST_POINT_NAME *dpn,
++                                     X509_NAME *iname)
+ {
+     int i;
+-    STACK_OF(X509_NAME_ENTRY) *frag;
++    STACK_OF(X509_NAME_ENTRY) *frag = dpn->name.relativename;
+     X509_NAME_ENTRY *ne;
+-    if (!dpn || (dpn->type != 1))
+-        return 1;
+-    frag = dpn->name.relativename;
+-    dpn->dpname = X509_NAME_dup(iname);
+-    if (!dpn->dpname)
+-        return 0;
++    X509_NAME *dpname = X509_NAME_dup(iname);
++
++    if (dpname == NULL)
++        return NULL;
+     for (i = 0; i < sk_X509_NAME_ENTRY_num(frag); i++) {
+         ne = sk_X509_NAME_ENTRY_value(frag, i);
+-        if (!X509_NAME_add_entry(dpn->dpname, ne, -1, i ? 0 : 1)) {
+-            X509_NAME_free(dpn->dpname);
+-            dpn->dpname = NULL;
+-            return 0;
+-        }
++        if (!X509_NAME_add_entry(dpname, ne, -1, i ? 0 : 1))
++            goto err;
+     }
+     /* generate cached encoding of name */
+-    if (i2d_X509_NAME(dpn->dpname, NULL) < 0) {
+-        X509_NAME_free(dpn->dpname);
+-        dpn->dpname = NULL;
+-        return 0;
+-    }
+-    return 1;
++    if (i2d_X509_NAME(dpname, NULL) >= 0)
++        return dpname;
++
++ err:
++    X509_NAME_free(dpname);
++    return NULL;
++}
++
++/* Append any nameRelativeToCRLIssuer in dpn to iname, set in dpn->dpname */
++int DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, X509_NAME *iname)
++{
++    if (dpn == NULL || dpn->type != 1)
++        return 1;
++    X509_NAME_free(dpn->dpname); /* just in case it was already set */
++    dpn->dpname = ossl_dist_point_name_full(dpn, iname);
++    return dpn->dpname != NULL;
+ }
+diff --git a/crypto/x509v3/v3_purp.c b/crypto/x509v3/v3_purp.c
+index a1aeb4e4c6..3cdf5474bc 100644
+--- a/crypto/x509v3/v3_purp.c
++++ b/crypto/x509v3/v3_purp.c
+@@ -303,11 +303,17 @@ int X509_supported_extension(X509_EXTENSION *ex)
+     return 0;
+ }
+ 
+-static int setup_dp(X509 *x, DIST_POINT *dp)
++/*
++ * The full name of a nameRelativeToCRLIssuer distribution point is not
++ * computed here.  Doing so for every parsed certificate cost an
++ * X509_NAME_dup() of the issuer name per relative distribution point,
++ * which a certificate with many such entries could turn into hundreds of
++ * megabytes of heap on a plain TLS handshake, while the result is only
++ * needed when a CRL is actually being matched against the certificate.
++ * That name is now built on demand in the CRL checking code instead.
++ */
++static int setup_dp(DIST_POINT *dp)
+ {
+-    X509_NAME *iname = NULL;
+-    int i;
+-
+     if (dp->reasons) {
+         if (dp->reasons->length > 0)
+             dp->dp_reasons = dp->reasons->data[0];
+@@ -316,19 +322,7 @@ static int setup_dp(X509 *x, DIST_POINT *dp)
+         dp->dp_reasons &= CRLDP_ALL_REASONS;
+     } else
+         dp->dp_reasons = CRLDP_ALL_REASONS;
+-    if (!dp->distpoint || (dp->distpoint->type != 1))
+-        return 1;
+-    for (i = 0; i < sk_GENERAL_NAME_num(dp->CRLissuer); i++) {
+-        GENERAL_NAME *gen = sk_GENERAL_NAME_value(dp->CRLissuer, i);
+-        if (gen->type == GEN_DIRNAME) {
+-            iname = gen->d.directoryName;
+-            break;
+-        }
+-    }
+-    if (!iname)
+-        iname = X509_get_issuer_name(x);
+-
+-    return DIST_POINT_set_dpname(dp->distpoint, iname);
++    return 1;
+ }
+ 
+ static int setup_crldp(X509 *x)
+@@ -339,7 +333,7 @@ static int setup_crldp(X509 *x)
+     if (x->crldp == NULL && i != -1)
+         return 0;
+     for (i = 0; i < sk_DIST_POINT_num(x->crldp); i++) {
+-        if (!setup_dp(x, sk_DIST_POINT_value(x->crldp, i)))
++        if (!setup_dp(sk_DIST_POINT_value(x->crldp, i)))
+             return 0;
+     }
+     return 1;
+diff --git a/include/crypto/x509.h b/include/crypto/x509.h
+index b53c2b03c3..2161700deb 100644
+--- a/include/crypto/x509.h
++++ b/include/crypto/x509.h
+@@ -8,8 +8,9 @@
+  */
+ 
+ #include "internal/refcount.h"
+ #include <openssl/x509.h>
++#include <openssl/x509v3.h>
+ #include <openssl/conf.h>
+ 
+ /* Internal X509 structures and functions: not for application use */
+ 
+@@ -284,6 +285,9 @@ int a2i_ipadd(unsigned char *ipout, const char *ipasc);
+ int x509_set1_time(ASN1_TIME **ptm, const ASN1_TIME *tm);
+ 
+ void x509_init_sig_info(X509 *x);
+
+ int x509v3_add_len_value_uchar(const char *name, const unsigned char *value,
+                                size_t vallen, STACK_OF(CONF_VALUE) **extlist);
++
++X509_NAME *ossl_dist_point_name_full(const DIST_POINT_NAME *dpn,
++                                     X509_NAME *iname);
+-- 
+2.56.0
+
Risk 0/5 · Safe CVE-2026-54872.patch
Result #6535

Comment

The patch is a security fix for constant-time behavior in OpenSSL EC scalar multiplication, and the added helper is narrowly scoped. I did not find supply-chain red flags, network access, privilege escalation, or packaging-time execution. The new code only adjusts BIGNUM top handling and uses a value barrier to avoid secret-dependent branching/looping. One thing to note is that the helper relies on careful arithmetic around `i - a->top`, but it is used only to derive a mask and is accompanied by bounds checks and comments explaining the constant-time intent. Overall this looks like a legitimate hardening change rather than a malicious modification.

@@ -0,0 +1,174 @@
+From cad03914a07550cac84f058de0c50973d32b9b40 Mon Sep 17 00:00:00 2001
+From: Igor Ustinov <igus@openssl.foundation>
+Date: Tue, 28 Jul 2026 22:09:29 +0200
+Subject: [PATCH] ec: make ossl_ec_scalar_mul_ladder() scalar padding constant
+ time
+
+Fixes CVE-2026-54872
+
+Assisted-by: Claude:claude-opus-4-8
+Reviewed-by: Alicja Kario <hkario@redhat.com>
+Reviewed-by: Viktor Dukhovni <viktor@openssl.org>
+Merge-date: Tue Sep 29 11:25:41 2026
+---
+ crypto/bn/bn_intern.c            | 38 ++++++++++++++++++++++++++++++++
+ crypto/ec/ec_mult.c              | 38 ++++++++++++++++++++++++++++++++
+ include/crypto/bn.h              |  1 +
+ include/internal/constant_time.h | 13 +++++++++++
+ 4 files changed, 90 insertions(+)
+
+diff --git a/crypto/bn/bn_intern.c b/crypto/bn/bn_intern.c
+index 147b4fa022..5dfbdd80ce 100644
+--- a/crypto/bn/bn_intern.c
++++ b/crypto/bn/bn_intern.c
+@@ -9,6 +9,7 @@
+ 
+ #include "internal/cryptlib.h"
+ #include "bn_local.h"
++#include "internal/constant_time.h"
+ 
+ /*
+  * Determine the modified width-(w+1) Non-Adjacent Form (wNAF) of 'scalar'.
+@@ -156,6 +157,43 @@ void bn_set_all_zero(BIGNUM *a)
+         a->d[i] = 0;
+ }
+ 
++/*
++ * Zero-extend |a| so that it occupies exactly |words| words, flag it
++ * BN_FLG_FIXED_TOP and leave its numeric value unchanged.
++ *
++ * This is a companion to bn_correct_top(): where the latter minimises the top
++ * of a BIGNUM, this one pins the top to a caller-chosen, value-independent
++ * width.  Constant-time code uses it to make the cost of subsequent word-wise
++ * operations (e.g. BN_uadd()/BN_add()) independent of the magnitude of a
++ * secret value.  |words| must be greater than or equal to the current top.
++ *
++ * The routine is itself constant time with respect to the current a->top: it
++ * always sweeps a fixed |words| iterations and selects value-or-zero per word
++ * with an arithmetic mask, rather than looping over the (possibly secret)
++ * a->top..words range.  Masking the high words with zero also launders any
++ * uninitialised padding, so it is safe for the memory sanitiser.
++ */
++int bn_set_top_fixed(BIGNUM *a, int words)
++{
++    size_t i, n = (size_t)words;
++    BN_ULONG mask;
++
++    if (words < a->top)
++        return 0;
++    if (bn_wexpand(a, words) == NULL) {
++        BNerr(BN_F_BN_SET_WORDS, ERR_R_MALLOC_FAILURE);
++        return 0;
++    }
++    for (i = 0; i < n; i++) {
++        /* mask = all ones iff i < a->top, else all zeros */
++        mask = value_barrier_bn((BN_ULONG)0 - ((i - a->top) >> (8 * sizeof(i) - 1)));
++        a->d[i] &= mask;
++    }
++    a->top = words;
++    a->flags |= BN_FLG_FIXED_TOP;
++    return 1;
++}
++
+ int bn_copy_words(BN_ULONG *out, const BIGNUM *in, int size)
+ {
+     if (in->top > size)
+diff --git a/crypto/ec/ec_mult.c b/crypto/ec/ec_mult.c
+index 9a1e3974ed..ffa6031c65 100644
+--- a/crypto/ec/ec_mult.c
++++ b/crypto/ec/ec_mult.c
+@@ -212,6 +212,18 @@ int ec_scalar_mul_ladder(const EC_GROUP *group, EC_POINT *r,
+         goto err;
+     }
+ 
++    /*
++     * Constant-timeness of this copy depends on the caller: BN_copy() moves
++     * scalar->top words unless |scalar| is flagged BN_FLG_CONSTTIME (in which
++     * case scalar->dmax words are moved).  Secret scalars are therefore
++     * expected to arrive either BN_FLG_CONSTTIME or fixed-top, so that their
++     * top is a public, value-independent width and the copy length does not
++     * leak their magnitude.  ECDSA satisfies this via
++     * ossl_bn_priv_rand_range_fixed_top(); the generic SM2 signing path does
++     * not yet (see the sm2_sig_gen() hardening tracked separately).  The
++     * fixed-top pinning below makes the subsequent arithmetic constant time
++     * regardless, but cannot retroactively fix the copy length here.
++     */
+     if (!BN_copy(k, scalar)) {
+         ECerr(EC_F_EC_SCALAR_MUL_LADDER, ERR_R_BN_LIB);
+         goto err;
+@@ -230,10 +242,36 @@ int ec_scalar_mul_ladder(const EC_GROUP *group, EC_POINT *r,
+         }
+     }
+ 
++    /*
++     * |k| may still carry a top that depends on the value of the secret
++     * scalar: callers pass either a fixed-top BIGNUM (e.g. the ECDSA nonce)
++     * or a minimal-top one (e.g. SM2), and BN_copy() above preserves that
++     * top.  Pin |k| to a fixed number of words (matching the group
++     * cardinality) so that the additions below run in constant time,
++     * independently of the bit length of the scalar.  Otherwise the work
++     * done by BN_add()/BN_uadd() depends on the operand tops and leaks the
++     * magnitude of the secret scalar.
++     */
++    if (!bn_set_top_fixed(k, group_top)) {
++        ECerr(EC_F_EC_SCALAR_MUL_LADDER, ERR_R_BN_LIB);
++        goto err;
++    }
++
+     if (!BN_add(lambda, k, cardinality)) {
+         ECerr(EC_F_EC_SCALAR_MUL_LADDER, ERR_R_BN_LIB);
+         goto err;
+     }
++    /*
++     * |lambda| = scalar + cardinality may or may not have produced a carry
++     * into an extra word depending on the secret scalar.  Pin its top to one
++     * word above the group top so that the second addition, which consumes
++     * |lambda|, is likewise constant time and so that the BN_is_bit_set()
++     * below always inspects a defined word.
++     */
++    if (!bn_set_top_fixed(lambda, group_top + 1)) {
++        ECerr(EC_F_EC_SCALAR_MUL_LADDER, ERR_R_BN_LIB);
++        goto err;
++    }
+     BN_set_flags(lambda, BN_FLG_CONSTTIME);
+     if (!BN_add(k, lambda, cardinality)) {
+         ECerr(EC_F_EC_SCALAR_MUL_LADDER, ERR_R_BN_LIB);
+diff --git a/include/crypto/bn.h b/include/crypto/bn.h
+index b5f36fb25a..bd5e1d8318 100644
+--- a/include/crypto/bn.h
++++ b/include/crypto/bn.h
+@@ -17,6 +17,7 @@ BIGNUM *bn_wexpand(BIGNUM *a, int words);
+ BIGNUM *bn_expand2(BIGNUM *a, int words);
+ 
+ void bn_correct_top(BIGNUM *a);
++int bn_set_top_fixed(BIGNUM *a, int words);
+ 
+ /*
+  * Determine the modified width-(w+1) Non-Adjacent Form (wNAF) of 'scalar'.
+diff --git a/include/internal/constant_time.h b/include/internal/constant_time.h
+index 7f0627d726..d4aaba8bff 100644
+--- a/include/internal/constant_time.h
++++ b/include/internal/constant_time.h
+@@ -267,6 +267,19 @@ static ossl_inline size_t value_barrier_s(size_t a)
+     return r;
+ }
+ 
++#ifdef BN_ULONG
++static ossl_inline BN_ULONG value_barrier_bn(BN_ULONG a)
++{
++#if !defined(OPENSSL_NO_ASM) && defined(__GNUC__)
++    BN_ULONG r;
++    __asm__("" : "=r"(r) : "0"(a));
++#else
++    volatile BN_ULONG r = a;
++#endif
++    return r;
++}
++#endif
++
+ static ossl_inline unsigned int constant_time_select(unsigned int mask,
+                                                      unsigned int a,
+                                                      unsigned int b)
+-- 
+2.56.0
+
Risk 0/5 · Safe CVE-2026-75806.patch
Result #6536

Comment

The patch is a straightforward security fix for a denial-of-service issue in OpenSSL record handling. It only changes error handling for undersized AEAD records on the receive path, returning 0 so the caller treats the record as publicly invalid instead of raising an internal error. The added tests exercise TLS 1.2 and DTLS 1.2 behavior and do not introduce network access, privilege changes, or packaging-side execution. No suspicious sources, scripts, or persistence mechanisms are present in this patch.

@@ -0,0 +1,316 @@
+From 3094861849fb2efecebfe9bf92252e5ead73e531 Mon Sep 17 00:00:00 2001
+From: Pavol Zacik <pzacik@redhat.com>
+Date: Mon, 9 Nov 2026 15:42:33 +0100
+Subject: [PATCH] tls1_enc: Do not report a fatal error on undersized AEAD
+ records
+
+This is a simplified backport of upstream commit 04728a2.
+
+In tls1_enc(), the receive path invokes EVP_CTRL_AEAD_TLS1_AAD and
+raises SSL_AD_INTERNAL_ERROR if it fails. This would cause a DoS
+vulnerability where the attacker can terminate a DTLS 1.2 association
+with a single unauthenticated datagram whose encrypted fragment
+is shorther than the AEAD overhead.
+
+Do not raise an internal error on the receive path. Instead, make the
+caller handle the record as a publicly invalid one (DTLS discards it).
+
+Fixes CVE-2026-75806.
+---
+ ssl/record/ssl3_record.c |  12 +++
+ test/build.info          |   2 +-
+ test/recordlentest.c     | 221 +++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 234 insertions(+), 1 deletion(-)
+
+diff --git a/ssl/record/ssl3_record.c b/ssl/record/ssl3_record.c
+index ab5d22aa10..b1f813ef4f 100644
+--- a/ssl/record/ssl3_record.c
++++ b/ssl/record/ssl3_record.c
+@@ -1062,6 +1062,18 @@ int tls1_enc(SSL *s, SSL3_RECORD *recs, size_t n_recs, int sending)
+                 pad = EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_AEAD_TLS1_AAD,
+                                           EVP_AEAD_TLS1_AAD_LEN, buf[ctr]);
+                 if (pad <= 0) {
++                    /*
++                     * On the receive path the AEAD ciphers only reject the
++                     * AAD if the record is too short to even contain the
++                     * mandatory AEAD overhead, i.e. the explicit IV and the
++                     * authentication tag. Such a record is publicly invalid,
++                     * so do not raise an internal error alert here. Returning
++                     * 0 leaves alert handling to the caller, which means TLS
++                     * reports bad_record_mac and DTLS silently discards the
++                     * record.
++                     */
++                    if (!sending)
++                        return 0;
+                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS1_ENC,
+                              ERR_R_INTERNAL_ERROR);
+                     return -1;
+diff --git a/test/build.info b/test/build.info
+index 9e2136ad34..71e0271602 100644
+--- a/test/build.info
++++ b/test/build.info
+@@ -347,7 +347,7 @@ INCLUDE_MAIN___test_libtestutil_OLB = /INCLUDE=MAIN
+   DEPEND[x509_time_test]=../libcrypto libtestutil.a
+ 
+   SOURCE[recordlentest]=recordlentest.c ssltestlib.c
+-  INCLUDE[recordlentest]=../include
++  INCLUDE[recordlentest]=../include ..
+   DEPEND[recordlentest]=../libcrypto ../libssl libtestutil.a
+ 
+   SOURCE[drbgtest]=drbgtest.c
+diff --git a/test/recordlentest.c b/test/recordlentest.c
+index 457335d308..fe0a38e8b9 100644
+--- a/test/recordlentest.c
++++ b/test/recordlentest.c
+@@ -9,6 +9,9 @@
+ 
+ #include <string.h>
+ 
++#include <openssl/evp.h>
++
++#include "internal/nelem.h"
+ #include "ssltestlib.h"
+ #include "testutil.h"
+ 
+@@ -60,6 +63,35 @@ static int write_record(BIO *b, size_t len, int rectype, int recversion)
+     return 1;
+ }
+ 
++#ifndef OPENSSL_NO_DTLS1_2
++static int write_dtls_record(BIO *b, size_t len, int rectype, int recversion,
++                             unsigned int epoch, unsigned long seq)
++{
++    unsigned char record[DTLS1_RT_HEADER_LENGTH + 256];
++    size_t written, i;
++
++    if (len > sizeof(record) - DTLS1_RT_HEADER_LENGTH)
++        return 0;
++
++    memset(record, 0, sizeof(record));
++
++    record[0] = rectype;
++    record[1] = (recversion >> 8) & 0xff;
++    record[2] = recversion & 0xff;
++    record[3] = (epoch >> 8) & 0xff;
++    record[4] = epoch & 0xff;
++    for (i = 0; i < 6; i++) {
++        record[10 - i] = (unsigned char)(seq & 0xff);
++        seq >>= 8;
++    }
++    record[11] = (len >> 8) & 0xff;
++    record[12] = len & 0xff;
++
++    return BIO_write_ex(b, record, DTLS1_RT_HEADER_LENGTH + len, &written)
++           && written == DTLS1_RT_HEADER_LENGTH + len;
++}
++#endif
++
+ static int fail_due_to_record_overflow(int enc)
+ {
+     long err = ERR_peek_error();
+@@ -181,6 +213,188 @@ static int test_record_overflow(int idx)
+     return testresult;
+ }
+ 
++static int write_and_read_app_data(SSL *serverssl, SSL *clientssl)
++{
++    static const unsigned char msg = 0xa5;
++    unsigned char buf = 0;
++    size_t readbytes = 0, written = 0;
++
++    return TEST_true(SSL_write_ex(clientssl, &msg, sizeof(msg), &written))
++           && TEST_size_t_eq(written, sizeof(msg))
++           && TEST_true(SSL_read_ex(serverssl, &buf, sizeof(buf), &readbytes))
++           && TEST_size_t_eq(readbytes, sizeof(msg))
++           && TEST_uchar_eq(buf, msg);
++}
++
++typedef enum {
++    SHORT_AEAD_RECORD_AES,
++    SHORT_AEAD_RECORD_ARIA,
++    SHORT_AEAD_RECORD_CHACHA
++} SHORT_AEAD_RECORD_CIPHER;
++
++typedef struct {
++    const char *cipher;
++    size_t record_len;
++    SHORT_AEAD_RECORD_CIPHER cipher_type;
++} SHORT_AEAD_RECORD_TEST;
++
++#ifndef OPENSSL_NO_TLS1_2
++static const SHORT_AEAD_RECORD_TEST short_aead_record_tests[] = {
++    { TLS1_TXT_RSA_WITH_AES_128_CCM, 0, SHORT_AEAD_RECORD_AES },
++    { TLS1_TXT_RSA_WITH_AES_128_CCM,
++      EVP_CCM_TLS_EXPLICIT_IV_LEN + EVP_CCM_TLS_TAG_LEN - 1,
++      SHORT_AEAD_RECORD_AES },
++    { TLS1_TXT_RSA_WITH_AES_128_CCM_8,
++      EVP_CCM_TLS_EXPLICIT_IV_LEN + EVP_CCM8_TLS_TAG_LEN - 1,
++      SHORT_AEAD_RECORD_AES },
++    { TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256,
++      EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN - 1,
++      SHORT_AEAD_RECORD_AES },
++    { TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256,
++      EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN - 1,
++      SHORT_AEAD_RECORD_ARIA },
++    { TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305,
++      EVP_CHACHAPOLY_TLS_TAG_LEN - 1, SHORT_AEAD_RECORD_CHACHA },
++};
++#endif
++
++static void alert_cb(int write_p, int version, int content_type,
++                     const void *buf, size_t len, SSL *ssl, void *arg)
++{
++    unsigned char *alert = arg;
++    const unsigned char *alert_data = buf;
++
++    if (write_p && content_type == SSL3_RT_ALERT && len == 2) {
++        alert[0] = alert_data[0];
++        alert[1] = alert_data[1];
++    }
++}
++
++#ifndef OPENSSL_NO_TLS1_2
++static int test_tls12_short_aead_record(int idx)
++{
++    const SHORT_AEAD_RECORD_TEST *test = &short_aead_record_tests[idx];
++    SSL_CTX *cctx = NULL, *sctx = NULL;
++    SSL *clientssl = NULL, *serverssl = NULL;
++    int testresult = 0;
++    size_t readbytes;
++    unsigned char buf, alert[2] = { 0 };
++
++# ifdef OPENSSL_NO_ARIA
++    if (test->cipher_type == SHORT_AEAD_RECORD_ARIA) {
++        TEST_info("ARIA is disabled");
++        return 1;
++    }
++# endif
++# if defined(OPENSSL_NO_CHACHA) || defined(OPENSSL_NO_POLY1305) \
++     || defined(OPENSSL_NO_EC)
++    if (test->cipher_type == SHORT_AEAD_RECORD_CHACHA) {
++        TEST_info("ChaCha20-Poly1305 or EC is disabled");
++        return 1;
++    }
++# endif
++
++    if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(),
++                                       TLS_client_method(),
++                                       TLS1_2_VERSION, TLS1_2_VERSION,
++                                       &sctx, &cctx, cert, privkey)))
++        goto end;
++
++    /* CCM-8 is not available at the default security level. */
++    SSL_CTX_set_security_level(sctx, 0);
++    SSL_CTX_set_security_level(cctx, 0);
++
++    if (!TEST_true(SSL_CTX_set_cipher_list(sctx, test->cipher))
++            || !TEST_true(SSL_CTX_set_cipher_list(cctx, test->cipher))
++            || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
++                                             &clientssl, NULL, NULL)))
++        goto end;
++
++    SSL_set_msg_callback(serverssl, alert_cb);
++    SSL_set_msg_callback_arg(serverssl, &alert);
++
++    if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
++            || !TEST_true(write_and_read_app_data(serverssl, clientssl))
++            || !TEST_true(write_record(SSL_get_rbio(serverssl),
++                                       test->record_len,
++                                       SSL3_RT_APPLICATION_DATA,
++                                       TLS1_2_VERSION))
++            || !TEST_false(SSL_read_ex(serverssl, &buf, sizeof(buf),
++                                       &readbytes))
++            || !TEST_uchar_eq(alert[0], SSL3_AL_FATAL)
++            || !TEST_uchar_eq(alert[1], SSL_AD_BAD_RECORD_MAC))
++        goto end;
++
++    testresult = 1;
++ end:
++    SSL_free(serverssl);
++    SSL_free(clientssl);
++    SSL_CTX_free(sctx);
++    SSL_CTX_free(cctx);
++    return testresult;
++}
++#endif
++
++#ifndef OPENSSL_NO_DTLS1_2
++static int test_dtls12_short_aead_record(void)
++{
++    SSL_CTX *cctx = NULL, *sctx = NULL;
++    SSL *clientssl = NULL, *serverssl = NULL;
++    int testresult = 0, ret;
++    size_t readbytes = 0;
++    unsigned char buf = 0, alert[2] = { 0 };
++
++    if (!TEST_true(create_ssl_ctx_pair(DTLS_server_method(),
++                                       DTLS_client_method(),
++                                       DTLS1_2_VERSION, DTLS1_2_VERSION,
++                                       &sctx, &cctx, cert, privkey)))
++        goto end;
++
++    SSL_CTX_set_security_level(sctx, 0);
++    SSL_CTX_set_security_level(cctx, 0);
++
++    if (!TEST_true(SSL_CTX_set_cipher_list(sctx,
++                       TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256))
++            || !TEST_true(SSL_CTX_set_cipher_list(cctx,
++                       TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256))
++            || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
++                                             &clientssl, NULL, NULL)))
++        goto end;
++
++    SSL_set_msg_callback(serverssl, alert_cb);
++    SSL_set_msg_callback_arg(serverssl, &alert);
++
++    /*
++     * The forged record uses the first application-data sequence number. A
++     * valid client write after this must still be accepted.
++     */
++    if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
++            || !TEST_true(write_dtls_record(SSL_get_rbio(serverssl),
++                              EVP_GCM_TLS_EXPLICIT_IV_LEN
++                              + EVP_GCM_TLS_TAG_LEN - 1,
++                              SSL3_RT_APPLICATION_DATA, DTLS1_2_VERSION,
++                              1, 1)))
++        goto end;
++
++    ERR_clear_error();
++    ret = SSL_read_ex(serverssl, &buf, sizeof(buf), &readbytes);
++    if (!TEST_false(ret)
++            || !TEST_int_eq(SSL_get_error(serverssl, ret), SSL_ERROR_WANT_READ)
++            || !TEST_uchar_eq(alert[0], 0)
++            || !TEST_uchar_eq(alert[1], 0)
++            || !TEST_true(write_and_read_app_data(serverssl, clientssl)))
++        goto end;
++
++    testresult = 1;
++ end:
++    SSL_free(serverssl);
++    SSL_free(clientssl);
++    SSL_CTX_free(sctx);
++    SSL_CTX_free(cctx);
++    return testresult;
++}
++#endif
++
+ int setup_tests(void)
+ {
+     if (!TEST_ptr(cert = test_get_argument(0))
+@@ -188,6 +402,13 @@ int setup_tests(void)
+         return 0;
+ 
+     ADD_ALL_TESTS(test_record_overflow, TOTAL_RECORD_OVERFLOW_TESTS);
++#ifndef OPENSSL_NO_TLS1_2
++    ADD_ALL_TESTS(test_tls12_short_aead_record,
++                  OSSL_NELEM(short_aead_record_tests));
++#endif
++#ifndef OPENSSL_NO_DTLS1_2
++    ADD_TEST(test_dtls12_short_aead_record);
++#endif
+     return 1;
+ }
+ 
+-- 
+2.56.0
+
Risk 0/5 · Safe PKGBUILD
Result #6537

Comment

The change only bumps pkgrel from 13 to 14 in PKGBUILD; no sources, build steps, install scripts, dependencies, or packaging behavior changed. This is a metadata-only rebuild with no security-relevant impact visible in the provided diff.

@@ -7,7 +7,7 @@ _pkgname=openssl
 _ver=1.1.1w
 # use a pacman compatible version scheme
 pkgver=${_ver/[a-z]/.${_ver//[0-9.]/}}
-pkgrel=13
+pkgrel=14
 pkgdesc='The Open Source toolkit for Secure Sockets Layer and Transport Layer Security'
 arch=('aarch64' 'x86_64')
 url='https://www.openssl.org'
Risk 0/5 · Safe PKGBUILD
Result #6538

Comment

The PKGBUILD change only reorders and adds/removes patch files in source/sha256sums, with no new build logic, network fetches, privilege changes, or packaging behavior. I reviewed the newly added patches shown in the diff context; they are upstream-style security fixes for OpenSSL with normal source modifications and no obvious supply-chain or persistence red flags. The only risk here is the usual trust in third-party backported patches, but nothing in this change suggests malicious behavior.

@@ -61,9 +61,12 @@ source=(
 	CVE-2026-45447-1.patch
 	CVE-2026-45447-2.patch
 	# https://git.almalinux.org/rpms/openssl/src/branch/c8s
+	CVE-2026-35189.patch
+	CVE-2026-54872.patch
+	CVE-2026-63072.patch
 	CVE-2025-69419-1.patch
 	CVE-2025-69419-2.patch
-	CVE-2026-63072.patch
+	CVE-2026-75806.patch
 	CVE-2026-84782.patch
 )
 sha256sums=('cf3098950cb4d853ad95c0841f1f9c6d3dc102dccfcacd521d93925208b76ac8'
Risk 0/5 · Safe PKGBUILD
Result #6539

Comment

The PKGBUILD change only reorders/updates checksums and adds/removes patch entries; there is no new build logic, network fetch, privilege escalation, or packaging behavior. I inspected the newly added patches referenced by the diff and they are standard upstream/backported security fixes for OpenSSL, with no obvious malicious payloads or install-time persistence mechanisms. The checksum update is consistent with the source list change. Overall this looks like a routine security-update refresh with low risk.

@@ -110,9 +113,12 @@ sha256sums=('cf3098950cb4d853ad95c0841f1f9c6d3dc102dccfcacd521d93925208b76ac8'
             'b03d53705375794da859dbd1287b9356a750fd3f669b74403d3f4619d494eab8'
             'f5689d1652045fe14c70e6eb68b080b1a26ad1c49d5308cd7212b417e10f2afc'
             '4fe62fbbce088325f5b62fab3edfe59d4d9a8108ddfd06cf2a53fa1bd758c5b3'
+            '6b39f01ffb5502c7a88b8d5f64743d8fc5b888ff4dcf81535336d2726f2acf57'
+            '9ee83143e426c801638ad773b7e995b69677b097713c48fd26cbaeb65ef63d67'
+            'd13b969c692af11b5531c76b25f7e8c21fee79f2fca694f53ba1c6754d1ade3f'
             'd89423836be0cb5ca076e173ea373c4deeef3d6ffa17085ca8a0850b364d7d3b'
             '933c61f15a81ac9c50f66f8c6c059d09f94a116d7b4c4d534a41b1c8f0140160'
-            'd13b969c692af11b5531c76b25f7e8c21fee79f2fca694f53ba1c6754d1ade3f'
+            '8579d2180e189eed3891fc10e7ff43ac00dc009e58c6c3e783fa181d3b185f4d'
             'f41abfd62f213e489afcc3d4608b034e1c71a8cecc10b2bb81fc3a8ece31cc21')
 validpgpkeys=(
 	'EFC0A467D613CB83C7ED6D30D894E2CE8B3D79F5'
Risk 0/5 · Safe REUSE.toml
Result #6540

Comment

The change only updates REUSE.toml metadata to include additional patch files in the SPDX annotations list. It does not alter build logic, package scripts, install hooks, or shipped executable content. I checked the referenced patch files for context; they are ordinary security backports from upstream/Red Hat with no obvious supply-chain or persistence red flags. This is a low-risk metadata-only change.

@@ -72,9 +72,12 @@ SPDX-License-Identifier = "OpenSSL"
 
 [[annotations]]
 path = [
+    "CVE-2026-35189.patch",
+    "CVE-2026-54872.patch",
+    "CVE-2026-63072.patch",
     "CVE-2025-69419-1.patch",
     "CVE-2025-69419-2.patch",
-    "CVE-2026-63072.patch",
+    "CVE-2026-75806.patch",
     "CVE-2026-84782.patch",
 ]
 SPDX-FileCopyrightText = "RHEL contributors"