Skip to main content

Net::IDN::Punycode EUVDEUVD-2026-84292

| CVE-2026-87079 HIGH
Inefficient Algorithmic Complexity (CWE-407)
2026-09-22 CPANSec GHSA-vx57-287r-4h84
7.5
CVSS 3.1 · Vendor: CPANSec
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Craft oversized punycode label
  2. Delivery
    Submit as domain/email/URL input
  3. Exploit
    Reach domain_to_unicode/uts46_to_unicode decoder
  4. Execution
    Trigger quadratic buffer scan
  5. Impact
    Exhaust CPU and deny service

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
Exploitation Conditions

Requires an application that passes attacker-controlled labels to the to-Unicode direction of Net::IDN::Punycode (before 2.590) - specifically domain_to_unicode or uts46_to_unicode - without independently bounding label length, since the 63-byte DNS limit is enforced only in the to-ASCII direction. Both the XS backend (buffer re-scanned per code point) and the pure-Perl backend (when input carries the UTF-8 flag, substr scans from the start on the pre-downgrade copy) are affected. No authentication, no user interaction, and no non-default configuration are needed once such an untrusted decode path exists; the practical limit is simply that the vulnerable function must be reachable with external input.

Impact

The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5 HIGH) is consistent with the description: a CWE-407 algorithmic-complexity flaw that is availability-only (C:N/I:N), triggerable remotely and unauthenticated whenever an application feeds attacker-controlled domain labels to the to-Unicode decoder. The impact is capped at CPU exhaustion (single-request quadratic blow-up, e.g. a ~200,000-char 'a' label per the vendor regression test), not code execution or data exposure, so the practical risk is denial of service against Perl services that decode untrusted IDN/punycode input. No EPSS score, KEV listing, or SSVC decision data is provided, and no public exploit is listed in the input - so there is no public exploit identified at time of analysis, though the trigger is trivial and well-documented in the patch's test file, making reliable exploitation straightforward for anyone who reads the advisory. Key caveat: the raw CVSS assumes the vulnerable decode path is reachable with attacker input; real exposure is gated on the application actually calling domain_to_unicode/uts46_to_unicode on unbounded external input, since the 63-byte DNS length check only applies in the to-ASCII direction. The input Tag 'Information Disclosure' directly contradicts the CVSS impact metrics (C:N/I:N) and the CWE-407 classification - this is a resource-exhaustion/DoS issue, not information disclosure.

Exploit ScenarioDerived

An attacker submits an abnormally long punycode label (e.g. via an email address domain, HTTP Host/URL, or DNS name that a Perl service normalizes with domain_to_unicode/uts46_to_unicode). Because no length bound exists in the to-Unicode direction, decode_punycode performs a quadratic scan of the growing output buffer, pinning a CPU core for seconds to minutes per request and enabling low-volume denial of service. No authentication or user interaction is required and no public weaponized exploit is listed, but the vendor's own regression test ('a' x 200000) demonstrates the trigger.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 22, 2026

CPU exhaustion in Net::IDN::Punycode before 2.590 lets unauthenticated remote attackers pin the CPU of a Perl application by supplying an over-long label to the to-Unicode decoder (domain_to_unicode or uts46_to_unicode), which performs quadratic work as it inserts each decoded code point. The flaw is availability-only (C:N/I:N) and requires no authentication, no user interaction, and no non-default configuration - the only prerequisite is that an application forwards attacker-controlled labels into the to-Unicode direction, since the 63-byte DNS length limit is enforced solely in the to-ASCII direction. A fix is available in the 2.590 release and in two upstream commits (00d7234, 447c6b3); no public exploit code was identified at time of analysis.

RemediationAI

Upgrade to Net::IDN::Punycode 2.590 (released as Net-IDN-Encode-2.590-TRIAL on CPAN per the changes file at https://metacpan.org/release/PJCJ/Net-IDN-Encode-2.590-TRIAL/changes), which is the vendor-released fix for this issue; if you cannot immediately adopt the release, the two upstream patches - https://github.com/robrwo/Net-IDN-Encode/commit/00d723423b66810af26b88c552bedc61975b3078.patch and https://github.com/robrwo/Net-IDN-Encode/commit/447c6b38ef5d4570329fa4f78690f4e14e09ba0c.patch - can be applied to a vendored copy of the module. Because the root cause is an unbounded label length in the to-Unicode direction, an effective compensating control is to validate every label before it reaches domain_to_unicode or uts46_to_unicode and reject or truncate anything longer than the 63-byte DNS limit the library already enforces in the opposite direction; the trade-off is that this duplicates validation logic in every caller and must be applied consistently or the exposure returns. Wrapping the decode in a bounded child process with an alarm/timeout (the approach the upstream regression test itself uses) contains the CPU burn but adds process-fork overhead and can mask legitimate slow input. Avoid relying on input encoding assumptions alone as mitigation: the pure-Perl backend is also affected when the input carries the UTF-8 flag, so forcing byte semantics is not a complete fix. No vendor advisory URL other than the CPAN changes file and the NVD entry was provided in the source data.

Affected ProductsAI

Net::IDN::Punycode versions before 2.590 - that is, the Punycode component of the Net::IDN::Encode distribution as published by PJCJ on CPAN (the fix landed in Net-IDN-Encode-2.590-TRIAL, see https://metacpan.org/release/PJCJ/Net-IDN-Encode-2.590-TRIAL/changes). Both backends shipped in those versions are affected: the XS implementation and the pure-Perl (Net::IDN::Punycode::PP) fallback. Any Perl application, library, or middleware that calls domain_to_unicode or uts46_to_unicode on untrusted input - for example URL/domain normalisation, IDN-aware web frameworks, mail or proxy filtering - inherits the exposure. The advisory is tracked as EUVD-2026-84292 and NVD CVE-2026-87079; no CPE strings were supplied in the source data.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

This is a CWE-407 algorithmic-complexity (quadratic cost) bug in the Punycode decoder of the Net::IDN::Punycode distribution (part of Net::IDN::Encode). In the XS backend, decode_punycode grows a UTF-8 output buffer and, for every decoded code point, locates the insertion point by walking the buffer from the start one character at a time (UTF8SKIP loop); because that scan repeats for each code point, total work is quadratic in label length. The pure-Perl backend downgrades its input to bytes so substr can index directly, but takes its working copy before the downgrade, so whenever the input carries the UTF-8 flag every substr on that copy rescans from the beginning and incurs the same quadratic cost. Nothing bounds label length in the to-Unicode direction - the 63-byte DNS limit is checked only when converting to ASCII. Consequently domain_to_unicode and uts46_to_unicode will happily hand an arbitrarily long attacker-supplied label to the decoder. The upstream patch replaces the byte-level insertion logic with a UV code-point array plus a single UNISKIP pre-pass to compute the exact output size, eliminating the repeated scans; a regression test (t/punycode_quadratic-xs.t) feeds a 200,000-character label and alarms out after 10 seconds.

Know when Perl gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (CPANSec) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Remote unauthenticated single-request CPU exhaustion with no interaction (AV:N/AC:L/PR:N/UI:N); availability-only, so C:N/I:N/A:H and S:U.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (CPANSec).

CVSS VectorVendor: CPANSec

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

3
CVSS changed
Sep 22, 2026 - 13:22 NVD
7.5 (HIGH)
CVE Published
Sep 22, 2026 - 07:24 cve.org
HIGH 7.5
CVE Published
Sep 22, 2026 - 07:24 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

Net::IDN::Punycode versions before 2.590 for Perl allow CPU exhaustion via quadratic insertion cost when decoding a long label in decode_punycode.

The XS backend inserts each decoded code point into a UTF-8 buffer and finds the insertion point by scanning that buffer from the start, one character at a time. The scan runs once per code point over the output built so far, so the cost is quadratic in the label length. The pure-Perl backend downgrades its input to bytes so that substr can index it directly, but takes its working copy before the downgrade, so when the input carries the UTF-8 flag every substr on the copy scans from the start, with the same quadratic cost.

Nothing bounds the label length in the to-Unicode direction. The 63-byte DNS limit is checked only when converting to ASCII, so domain_to_unicode and uts46_to_unicode pass an attacker-supplied label of any length to the decoder.

Executive ViewAI

Why It Matters

Net::IDN::Punycode, a Perl library used to convert internationalized domain names, suffers from a CPU exhaustion flaw (CVE-2026-87079) that can render Perl-based applications unresponsive. Any internet-facing service that routes user-supplied labels into the library's to-Unicode decoding path can be pinned at full processor utilization by a single crafted request, and because the standard 63-byte domain limit is only enforced in the opposite direction, existing input-validation assumptions do not provide protection. A vendor fix is available, so this is a straightforward remediation, but the near-zero attack precondition makes rapid inventory and upgrade a priority for availability-critical services.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Medium
Common IDN encode/decode library in the Perl ecosystem for domain and email processing
Data Quality
6 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
Medium
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

More in Perl

View all
CVE-2012-6329 HIGH POC
7.5 Jan 04

The _compile function in Maketext.pm in the Locale::Maketext implementation in Perl before 5.17.7 does not properly hand

CVE-2017-12814 CRITICAL POC
9.8 Sep 28

Stack-based buffer overflow in the CPerlHost::Add method in win32/perlhost.h in Perl before 5.24.3-RC1 and 5.26.x before

CVE-2015-8608 CRITICAL POC
9.8 Feb 07

The VDir::MapPathA and VDir::MapPathW functions in Perl 5.22 allow remote attackers to cause a denial of service (out-of

CVE-2018-18314 CRITICAL POC
9.8 Dec 07

Perl before 5.26.3 has a buffer overflow via a crafted regular expression that triggers invalid write operations. Rated

CVE-2018-18312 CRITICAL POC
9.8 Dec 05

Perl before 5.26.3 and 5.28.0 before 5.28.1 has a buffer overflow via a crafted regular expression that triggers invalid

CVE-2018-18313 CRITICAL POC
9.1 Dec 07

Perl before 5.26.3 has a buffer over-read via a crafted regular expression that triggers disclosure of sensitive informa

CVE-2016-2381 HIGH
7.5 Apr 08

Perl might allow context-dependent attackers to bypass the taint protection mechanism in a child process via duplicate e

CVE-2023-31484 HIGH POC
8.1 Apr 29

CPAN.pm before 2.35 does not verify TLS certificates when downloading distributions over HTTPS. Rated high severity (CVS

CVE-2016-6185 HIGH POC
7.8 Aug 02

The XSLoader::load method in XSLoader in Perl does not properly locate .so files when called in a string eval, which mig

CVE-2018-12015 HIGH POC
7.5 Jun 07

In Perl through 5.26.2, the Archive::Tar module allows remote attackers to bypass a directory-traversal protection mecha

CVE-2020-10543 HIGH
8.2 Jun 05

Perl before 5.30.3 on 32-bit platforms allows a heap-based buffer overflow because nested regular expression quantifiers

CVE-2015-8853 HIGH
7.5 May 25

The (1) S_reghop3, (2) S_reghop4, and (3) S_reghopmaybe3 functions in regexec.c in Perl before 5.24.0 allow context-depe

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy