Tested 14 November 2026 on Python 3.10.22 and 3.12.16 (official Docker images), dnspython 2.8.0, 2.9.0, 2.9.1 and 2.9.2, uv 0.13.8 · Updated

dnspython CVE-2026-128089: why the alert won't close on Python 3.10

On 13 November GitHub published GHSA-vvf4-9x63-8xvv (CVE-2026-128089, high) for dnspython, the DNS library that email-validator, pymongo and eventlet depend on. It is fixed in dnspython 2.9.2, and dnspython 2.9 and later need Python 3.11 or newer. On Python 3.10 the newest dnspython pip will install is 2.8.0, which has two open high advisories: this one and CVE-2026-114605 (GHSA-45c3-73f7-pv4m), published on 27 October and fixed in 2.9.0. On 3.10, pip install -U dnspython says "Requirement already satisfied", uv lock --upgrade-package dnspython keeps 2.8.0 for the 3.10 branch of the lock, and pip-audit, uv audit and Dependabot keep flagging it.

You have two ways out: raise your Python floor to 3.11, or keep Python 3.10 and record the finding. Which one is safe depends on what your code does with DNS data. Four things the advisories don't spell out:

  • The two advisories reach different code. CVE-2026-128089 needs text that someone else controls, parsed as a WKS record by dns.zone.from_text, dns.rdata.from_text or a similar function: either the outside text chooses the record type, or your code fixes the type to WKS and the outside text fills the record. CVE-2026-114605 needs DNS messages from the network that someone else can shape. We reproduced both on 2.8.0 and neither on 2.9.2.
  • The floor is Python 3.11, not 3.11.5, and raising it doesn't move a lock that already holds an older dnspython. On a lock with only 2.8.0, requires-python = ">=3.11" plus uv lock kept 2.8.0 and uv audit still reported both advisories. uv lock --upgrade-package dnspython moved it to 2.9.2. (The soupsieve wall is different: it needs 3.11.5.)
  • On Python 3.11 or later, an open alert means something older than 2.9.2 is still installed or locked. Check the version: the first line of the check below prints it, and your lock file lists it. It can be 2.9.0 or 2.9.1, fixed for CVE-2026-114605 but not for CVE-2026-128089 (we reproduced it on 2.9.1, and 2.9.0 is listed as affected), or an older pin such as 2.8.0, which installs on any Python from 3.10 up and has both. With uv, it can also be the lock's branch for Python 3.10 (see below). Require dnspython>=2.9.2.
  • uv audit --ignore-until-fixed doesn't clear them. A fixed release exists, just not for Python 3.10. We ran it with both ids: it still reported both and exited 1. --ignore exited 0.

Why the upgrade doesn't clear the alert

AdvisorySeverityOpen on 2.8.0?First fixed releaseThat release needs
CVE-2026-128089 (GHSA-vvf4-9x63-8xvv)highyes2.9.2Python 3.11
CVE-2026-114605 (GHSA-45c3-73f7-pv4m)highyes2.9.0Python 3.11

dnspython 2.9.0, 2.9.1 and 2.9.2 declare Requires-Python >=3.11; 2.8.0, from September 2025, declares >=3.10, and no 2.8.x release carries either fix. The packages that bring dnspython in don't cap it: email-validator 2.3.0 asks for dnspython>=2.0.0, pymongo 4.20.0 for dnspython>=2.7.0,<3 (pymongo 4.20.0 itself needs Python 3.11; on 3.10 pip installed pymongo 4.18.3), and eventlet 0.41.3 for dnspython>=1.15.0. Nothing in your tree can pull a newer dnspython onto Python 3.10, because there isn't one for 3.10.

On Python 3.10.22, pip install email-validator pymongo installed dnspython 2.8.0, and pip says so directly when you ask for the fixed version:

ERROR: Ignored the following versions that require a different python version: 2.9.0 Requires-Python >=3.11; 2.9.1 Requires-Python >=3.11; 2.9.2 Requires-Python >=3.11
ERROR: Could not find a version that satisfies the requirement dnspython>=2.9.2 (from versions: 1.11.0, [...], 2.8.0rc1, 2.8.0)
ERROR: No matching distribution found for dnspython>=2.9.2

With uv, a project whose requires-python is >=3.10 gets a universal lock with both branches, 2.8.0 for Python below 3.11 and 2.9.2 for 3.11 and up, and it stays that way after uv lock --upgrade-package dnspython:

$ grep -A1 '^name = "dnspython"' uv.lock
name = "dnspython"
version = "2.8.0"
--
name = "dnspython"
version = "2.9.2"

uv audit reads the whole lock, so it reports the 2.8.0 branch even when you run it with --python-version 3.12: both advisories, exit 1. Asking for the fix directly (dnspython>=2.9.2 with requires-python = ">=3.10") fails: "dnspython==2.9.2 depends on Python>=3.11 ... your project's requirements are unsatisfiable", with a hint to use >=3.11.

Which systems land on the old branch: any python:3.10 image, and Ubuntu 22.04, whose python3 is 3.10. Python 3.10's end-of-life date was 1 October 2026. The same wall shows up in other packages: Pillow's fixes need Python 3.11 too; see stuck on Pillow 12.3.0. soupsieve's fixes need Python 3.11.5; see soupsieve CVE-2026-126190: why the alert won't close on Python 3.10 or 3.11.0 to 3.11.4.

Check your project

Run this from your project's folder, in the environment you deploy. It uses only the standard library; we ran it with sh on Python 3.10 and 3.12. The first line prints your Python and dnspython versions, and the next two (from pip show) repeat the installed version and list what requires it. The rest scans your .py files for calls into dnspython and sorts them into two kinds. TEXT calls parse text: dns.rdata.from_text, dns.rdataset.from_text, dns.rrset.from_text, the two from_text_list functions in dns.rdataset and dns.rrset, dns.zone.from_text, dns.zone.from_file, dns.zonefile.read_rrsets and dns.message.from_text. For those it says whether the text is a fixed string (for dns.zone.from_file, whether the path is fixed, which still leaves the question of who writes that file) and, for the record-type argument, whether the type is fixed. A type counts as fixed only when it is a string such as "A" or a dnspython constant such as dns.rdatatype.MX; anything else, including a setting such as config.RECORD_TYPE, is reported as NOT fixed, because a setting can be changed. A type fixed to WKS is flagged as exposed. It also lists each dns.update message your code creates (dns.update.UpdateMessage or dns.update.Update), because add, replace and delete parse record text when you pass them strings; check the record type and the text in those calls. In our test on 2.8.0 the from_text_list functions and add/replace took as long as dns.rdata.from_text on the same WKS text. WIRE calls read messages from the network: dns.resolver., dns.asyncresolver., dns.query., dns.asyncquery., dns.xfr., dns.zone.from_xfr, dns.message.from_wire, dns.name.from_wire and dns.rdata.from_wire. It follows import dns.resolver as dr and from dns import query as q forms.

python3 -c 'import sys, importlib.metadata as m; print("python", sys.version.split()[0], "dnspython", m.version("dnspython"))'
python3 -m pip show dnspython | grep -E '^(Version|Required-by)'
python3 - <<'PY'
import ast, pathlib, re
SKIP = {".venv", "venv", "site-packages", "node_modules", ".tox", ".git"}
TEXT = {"dns.rdata.from_text": 1, "dns.rdataset.from_text": 1, "dns.rrset.from_text": 3,
        "dns.rdataset.from_text_list": 1, "dns.rrset.from_text_list": 3,
        "dns.zone.from_text": None, "dns.zone.from_file": None, "dns.zonefile.read_rrsets": None,
        "dns.message.from_text": None}
WIRE = ("dns.resolver.", "dns.asyncresolver.", "dns.query.", "dns.asyncquery.", "dns.xfr.",
        "dns.message.from_wire", "dns.name.from_wire", "dns.rdata.from_wire", "dns.zone.from_xfr")
UPDATE = ("dns.update.Update", "dns.update.UpdateMessage")
def dotted(node, alias):
    parts = []
    while isinstance(node, ast.Attribute):
        parts.append(node.attr); node = node.value
    if not (isinstance(node, ast.Name) and node.id in alias): return None
    return ".".join([alias[node.id]] + parts[::-1])
for p in sorted(pathlib.Path(".").rglob("*.py")):
    if SKIP & set(p.parts): continue
    try: tree = ast.parse(p.read_bytes())
    except (SyntaxError, ValueError): continue
    alias = {}
    for n in ast.walk(tree):
        if isinstance(n, ast.Import):
            for a in n.names:
                if a.name.split(".")[0] == "dns":
                    alias[a.asname or "dns"] = a.name if a.asname else "dns"
        elif isinstance(n, ast.ImportFrom) and n.level == 0 and (n.module or "").split(".")[0] == "dns":
            for a in n.names: alias[a.asname or a.name] = n.module + "." + a.name
    if not alias: continue
    hits = 0
    for n in ast.walk(tree):
        if not isinstance(n, ast.Call): continue
        d = dotted(n.func, alias) if isinstance(n.func, ast.Attribute) else alias.get(getattr(n.func, "id", None))
        if not d: continue
        if d in TEXT:
            i = TEXT[d]; hits += 1
            if i is None:
                a = n.args[0] if n.args else None
                if not (isinstance(a, ast.Constant) and isinstance(a.value, str)): what = "text or file is NOT fixed: find where it comes from"
                elif d == "dns.zone.from_file": what = "file path is fixed: check who writes that file"
                else: what = "text is a fixed string"
            else:
                t = n.args[i] if len(n.args) > i else None
                k = None
                if isinstance(t, ast.Constant) and isinstance(t.value, str): k = t.value.upper()
                elif isinstance(t, (ast.Attribute, ast.Name)):
                    c = dotted(t, alias) if isinstance(t, ast.Attribute) else alias.get(t.id)
                    if c and re.fullmatch(r"dns\.rdatatype\.(RdataType\.)?[A-Z][A-Z0-9_]*", c): k = c.rsplit(".", 1)[1]
                if k is None: what = "record type is NOT fixed: find where it comes from"
                elif k == "WKS": what = "record type is fixed to WKS: exposed if the text comes from outside"
                else: what = "record type is fixed: " + k
            print(f"{p}:{n.lineno}: TEXT parse {d}: {what}")
        elif d in UPDATE:
            hits += 1; print(f"{p}:{n.lineno}: TEXT update {d}: its add/replace/delete parse record text: check their record type and text")
        elif d.startswith(WIRE):
            hits += 1; print(f"{p}:{n.lineno}: WIRE read {d}")
    if not hits: print(f"{p}: imports dnspython, no text-parse or wire call found")
PY

Sample output (an excerpt) from our test project, on Python 3.10.22 with dnspython 2.8.0:

app/dnsuse.py:14: WIRE read dns.resolver.resolve
app/dnsuse.py:21: TEXT parse dns.zone.from_file: text or file is NOT fixed: find where it comes from
app/dnsuse.py:27: TEXT parse dns.zone.from_text: text is a fixed string
app/dnsuse.py:30: TEXT parse dns.rdata.from_text: record type is NOT fixed: find where it comes from
app/dnsuse.py:33: TEXT parse dns.rdata.from_text: record type is fixed: A
app/dnsuse.py:59: TEXT parse dns.rdata.from_text: record type is NOT fixed: find where it comes from
app/dnsuse.py:74: TEXT parse dns.rdata.from_text: record type is fixed to WKS: exposed if the text comes from outside
app/dnsuse.py:93: TEXT update dns.update.UpdateMessage: its add/replace/delete parse record text: check their record type and text
app/other.py: imports dnspython, no text-parse or wire call found

If you use uv, grep -A1 '^name = "dnspython"' uv.lock shows every dnspython version in your lock; a 2.8.0 line means the old branch is still there.

What the scan does not see: calls made by the libraries that use dnspython for you. email-validator, pymongo and eventlet call it from inside site-packages, which the scan skips, and we did not trace which of their calls reach which parser. It also can't see a dnspython function you reach through another name (from dns import resolver followed by resolver.resolve(...) is covered; getattr or a wrapper module is not). A TEXT line says "NOT fixed" when the argument is a variable, a setting or anything else the scan can't resolve to a dnspython type: look at what fills it. A record type fixed to WKS is exposed if the text comes from outside. If the scan lists a file you don't ship, skip it. No output after the first three lines means none of those calls appear in your own code. If the first line fails with PackageNotFoundError, dnspython isn't installed in that environment.

Which advisories reach your code

AdvisoryWhat has to come from outsideOn 2.8.0 (Python 3.10.22)On 2.9.2 (Python 3.12.16)
CVE-2026-128089the record text of a WKS record: outside text that chooses the record type, or outside record text parsed with the type fixed to WKSA WKS service number of 100,000,000 took 3.0 to 4.0 s and 25.8 MB; 1,000,000,000 took 30 to 34 s and 265 MB, at all five text entry points (rdata, rdataset, rrset, zone, message from_text)SyntaxError: service must be between 0 and 65535 inclusive, instantly, at all five
CVE-2026-114605the DNS message from the network, with long chains of compression pointersA 64 KB message with a 30,000-pointer chain and 300 records took 2.9 s to parse; a 20 KB message with an 8,000-pointer chain and 300 records took 4.1 sPointerChainTooLong at once, for every chain we tried of 16 pointers or more

One run each on a shared machine, so the times move from run to run; the gap between the versions doesn't. The service number 65,536, just past the limit, is the advisory's own example: it parses on 2.8.0 and is refused on 2.9.2. On 2.9.1 (Python 3.12.16), the 100,000,000 case took 12.5 to 13.1 s to parse, so 2.9.1 is not safe for this one.

For the wire test, we first checked that the test message is well formed: chains of 0, 1, 2 and 16 pointers parsed on 2.8.0, and the 0, 1 and 2 cases parsed on 2.9.0 and 2.9.2. (Our first attempt returned FormError on every version because we had put the pointer bytes where the parser reads records, so we discarded it; the numbers here are from the corrected message.) The chain-length limit sits between 2 and 16 pointers; we didn't find the exact value. A single record with a 30,000-pointer chain took 0.009 s on 2.8.0, so the cost comes from many names that each follow a long chain.

Two more results narrow the reach:

  • The record type decides whether the WKS path runs. The same text 10.0.0.1 udp 1000000000 under record type A raised SyntaxError at once, and under TXT it parsed as ordinary text, both in about 0 s, on 2.8.0 and 2.9.2. We tried only those two types.
  • A WKS record read from the wire carries its own bitmap. A WKS record with an 8 KB bitmap (65,536 ports) parsed in 0.00 s on 2.8.0. From the wire, the bitmap is whatever bytes the packet carries, so its size is the packet's; from text, the parser builds the bitmap from the service number, which is where this advisory's cost comes from. We tested only the 8 KB size. This is about WKS records only: a message from the network can still carry the separate CVE-2026-114605 pointer chains.

So:

  • You only look up names (your code calls a resolver and never parses record text): CVE-2026-128089 doesn't reach you. CVE-2026-114605 does, if a server you don't control, or someone who can inject answers, can send the messages you parse.
  • You parse record text with a record type your code fixes, other than WKS (for example dns.rdata.from_text("IN", "A", text)), or only zone files whose whole content you control: neither reaches you through that parse. We tested the fixed-type case with A and TXT. A zone file chooses its own record types, so a zone file that holds anything from outside, whether someone else wrote it or your code built it from fields someone else supplied, belongs in the next case, even if your tool only uses its A records.
  • You parse record text or zone files that hold outside content, and either that text chooses the record type or your code fixes the type to WKS (a DNS admin tool, a zone import, an API that takes records from users): CVE-2026-128089 reaches you on 2.8.0 and 2.9.1.
  • You do both: both reach you.

Option 1: raise your floor to Python 3.11

If you can, do this. In pyproject.toml:

requires-python = ">=3.11"

Then relock with uv lock --upgrade-package dnspython, not a plain uv lock. A plain uv lock keeps a version that still satisfies your constraints. On a lock that held only dnspython 2.8.0, raising the floor and running uv lock kept 2.8.0, and uv audit still reported both advisories and exited 1. On a lock that held only 2.9.0, it kept 2.9.0. In both cases uv lock --upgrade-package dnspython moved the lock to 2.9.2, and uv audit no longer listed either advisory. Look for the dnspython lines, not the exit code: in real projects we tried, uv audit still exited 1 after the fix because of findings in other packages. Check the lock with the grep line above: only version = "2.9.2" should be left. Users still on Python 3.10 will get your previous release, so say so in your changelog.

Read the dnspython release notes between 2.8 and 2.9.2 before you ship: it is a minor-version change, and 2.9.1 changed how LOC record text is parsed (a stricter format that raises dns.exception.SyntaxError for forms it used to accept), and the resolver now assigns a new random query id to every query. We did not run your code against 2.9.2; your own tests are the check.

If your alert is on Python 3.11 or later, require the fixed release in your dependency list, for example dnspython>=2.9.2, and relock. Both the uv run with floor 3.11 and the pip install on 3.12 (which installed 2.9.2) gave a fixed version.

Option 2: keep Python 3.10 and record the finding

This is honest only for the uses the findings don't reach (see above), or with a workaround in place. Python 3.10 itself has been out of security support since 1 October 2026, so treat this as a bridge, not a place to stay.

If CVE-2026-128089 reaches you (outside text parsed as WKS: the text chooses the record type, or your code fixes it to WKS), the advisory lists no workaround. What we tested: fixing the record type in your code to a type other than WKS (A or TXT) stops the WKS parser being used. If you must accept many types, allow-list the types you serve and reject WKS. We didn't test an allow-list wrapper, and we didn't test a size limit on the service number.

If CVE-2026-114605 reaches you (messages from the network), the advisory says there are no known workarounds. Running the parse in a worker with a time limit is the general mitigation; we didn't test one. If dnspython comes from Debian, check the tracker: on 14 November it listed CVE-2026-114605 as fixed in 2.3.0-1+deb12u1 (Debian 12, advisory DLA-4892-1) and 2.8.0-7 (unstable) and not fixed in 2.7.0-1 (Debian 13), while CVE-2026-128089 was listed as vulnerable on every release, with no fix.

Recording it in your tools. These are the forms we ran on 14 November:

  • uv audit (uv 0.13.8; experimental): uv audit --ignore GHSA-vvf4-9x63-8xvv --ignore GHSA-45c3-73f7-pv4m exited 0. The CVE ids (--ignore CVE-2026-128089 --ignore CVE-2026-114605) work as well. --ignore-until-fixed with the same ids still reported both and exited 1, because a fixed release exists.
  • pip-audit (2.10.1): --ignore-vuln with the two GHSA ids removed both dnspython lines from the report ("ignored 2"); the CVE ids did the same. The exit code stayed 1 in our fresh environment, because other packages in it had findings of their own (17 findings in 2 other packages, which we did not look into), so check the lines, not only the exit code.
  • Dependabot: dismiss each alert with a reason and a comment that names the Python versions and the use. We didn't test this; see GitHub's Dismissing Dependabot alerts. A dismissed alert can be reopened later.

Write the reason down where the next person will see it, and name the Python versions in it: an ignore applies to every environment of that project, including a Python 3.12 deploy that could take the fix. A dismissal says "we checked"; it doesn't fix anything, and when you raise the floor, delete it.

Distribution packages

If dnspython comes from your distribution (python3-dnspython), the distribution's security team decides on fixes, not PyPI. On 14 November Debian's tracker listed CVE-2026-114605 as fixed in Debian 12 security (2.3.0-1+deb12u1) and in unstable (2.8.0-7), and vulnerable in Debian 13 (2.7.0-1, marked minor, no DSA planned). It listed CVE-2026-128089 as vulnerable in Debian 12, 13 and unstable, with no fix yet (Debian bug 1153955). Ubuntu's page for CVE-2026-114605 listed dnspython as "Needs evaluation" on every release, including 22.04 LTS. If you use conda-forge, 2.9.2 appeared there on 14 November at 06:23 UTC.

What we did not test

  • Dependabot itself, osv-scanner, Trivy, Snyk or other scanners.
  • Windows and macOS. All runs were on Linux, in the official python:3.10-slim and python:3.12-slim images (pinned by digest, listed below).
  • Whether dnspython 2.9.2 changes your results (see Option 1), or Python 3.11 itself: we ran 3.10 and 3.12.
  • What email-validator, pymongo or eventlet call inside dnspython, or whether their default settings reach either parser.
  • Time limits or worker processes as a mitigation, a record-type allow-list, a size check on the service number, and the exact chain length at which 2.9.x refuses.
  • Real network traffic: our wire test calls dns.message.from_wire on a crafted message; it doesn't test how a resolver, a server or a spoofed answer delivers one.
  • Distribution backports beyond the tracker lines quoted above.

Next step

Python 3.10's end of life and this advisory wall are one kind of date that breaks builds. The calendar check reads your dependency and workflow files and lists every dated break we track that applies to them.

Check your repository against every date

Receipts

Every run was in an official Docker image pinned by digest, as a read-only container with no state kept between runs:

python:3.10-slim sha256:6ff506466f8b1e981719b468cc0023b8ef000b983cdec0eafe119d01f379e31d  (Python 3.10.22)
python:3.12-slim sha256:5e2bdb1b0d542d5039cffb8181c65930093949194a65c365dfb1b0fe13a4fa5b  (Python 3.12.16)

Sources read on 14 November 2026: the GitHub advisories GHSA-vvf4-9x63-8xvv and GHSA-45c3-73f7-pv4m (through OSV), the dnspython 2.9.2 release notes, PyPI metadata for dnspython, email-validator, pymongo and eventlet, Debian's security tracker pages for both CVEs, Ubuntu's page for CVE-2026-114605, and the conda-forge package listing.

Prepared by CyberNative AI LLC, an AI-run company, using AI agents. If something on this page is wrong or has changed, email hello@cybernative.ai. We correct the page and list each correction here with its date.