Skip to main content

Perl DBI EUVDEUVD-2026-59745

| CVE-2026-73194 CRITICAL
Improper Validation of Specified Quantity in Input (CWE-1284)
2026-08-15 CPANSec
Critical
Disputed · 9.1 Vendor: CPANSec
View

Attack ChainAIDerived

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

  1. Access
    Submit statement with ':2147483648' placeholder
  2. Delivery
    Reach preparse with ':pN' return style
  3. Exploit
    atoi wraps binder counter negative
  4. Execution
    Negative counter bypasses 99999 limit
  5. Persist
    Trailing '?' expand to oversized ':p-2147483648'
  6. Impact
    Heap out-of-bounds write corrupts adjacent memory

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Input size validation
Exploitation Conditions

Exploitation requires that the target application call DBI's preparse() on attacker-influenced statement text using the ':N'/':pN' named-to-numbered return style (DBIpp_ph_cn), and that the poisoned numeric placeholder (e.g. ':2147483648', a value that wraps negative via atoi on glibc) be followed by one or more '?' marks - the overflow size grows with the number of trailing '?'. Limiting factors: applications using the '?' or '%s' return styles are NOT affected because those styles validate the parsed number against the expected sequence and error out; the wrap-to-negative behavior depends on atoi/glibc semantics; and the flow only reaches unsafe expansion because the 1.650 placeholder cap checks only against 99,999. This is therefore not a default-configuration remote flaw for every DBI user - it is gated on a specific, opt-in preparse usage pattern with untrusted input.

Impact

The signals are mixed and should temper the 9.1 headline. CVSS is AV:N/AC:L/PR:N/UI:N, implying trivial remote unauthenticated exploitation, but that only holds if an application actually feeds untrusted input through preparse() using the ':pN'/':N' return style - a real but far-from-universal usage pattern, since the '?' and '%s' return styles validate the sequence and are explicitly unaffected. EPSS is low (0.20%, 10th percentile), the CVE is not in CISA KEV, and no public exploit is identified, so there is no evidence of active or imminent mass exploitation. Turning a heap out-of-bounds write into reliable code execution requires heap grooming and is allocator-dependent, which raises real-world attack complexity above what AC:L suggests. The provided NVD-style vector rates C:H/I:N/A:H, which is atypical for a pure write primitive (a memory-write flaw usually implies an integrity impact, not primarily confidentiality) - verify the impact metrics with the vendor advisory. Net assessment: prioritize patching wherever DBI preparse handles externally influenced statements, since the fix is a clean library upgrade and the downside of a heap write is severe, but for deployments that never route untrusted SQL through the named-placeholder preparse path the practical urgency is lower than the CVSS number alone implies.

Exploit ScenarioDerived

An application uses DBI's preparse() with the named-to-numbered (':pN') return style to normalize SQL that incorporates externally supplied text; an attacker submits a statement containing ':2147483648' followed by several '?' placeholders. The poisoned negative binder counter bypasses the 99,999 limit, and each following '?' expands to the oversized ':p-2147483648' string, writing past the heap buffer to corrupt adjacent allocations - a foothold an attacker could attempt to develop toward code execution. No public proof-of-concept is identified at this time.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
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 – Aug 17, 2026

Heap out-of-bounds write in the Perl DBI module before version 1.652 lets an attacker who reaches the preparse() routine with attacker-controlled SQL corrupt heap memory when the ':pN' / ':N' (named-to-numbered) placeholder return style is used. A numeric placeholder such as ':2147483648' is parsed with atoi() and stored in the binder counter with no range check; on glibc it wraps negative, and each following '?' then expands to a 14-byte ':p-2147483648' string into a buffer that budgeted only 7 bytes per input byte. Exploitation status: no public exploit identified at time of analysis; EPSS is low (0.20%, 10th percentile), and it is not in CISA KEV.

RemediationAI

Vendor-released patch: upgrade DBI to 1.652 or later (fix commit 29b72ae7d2a8114a734a55840bf1c45b89207809), which forces the placeholder limit onto the ':#' and ':p#' branches by rejecting any parsed value that is >99999 or <=0 before expansion. If you cannot upgrade immediately, the concrete compensating control is to avoid the vulnerable return style: do not call preparse with the ':pN'/DBIpp_ph_cn (named-to-numbered) return style on untrusted statements, and instead use the '?' or '%s' return styles, which validate the placeholder number against the expected sequence and error out (side effect: application code that depends on numbered ':pN' output must be adjusted). Alternatively, ensure any statement text passed to preparse is fully application-controlled or strictly validated to reject numeric placeholders outside 1-99999 (side effect: added input-validation logic and possible false rejections of legitimately large-but-valid placeholder numbers). Consult the advisory at https://github.com/perl5-dbi/dbi/security/advisories/GHSA-623j-hfpc-mrc4 for authoritative guidance.

Affected ProductsAI

Perl DBI (perl5-dbi/dbi) at all versions before 1.652 is affected; version 1.652 (released 2026-08-11) contains the fix. The vulnerable code path is the ':N'/':pN' placeholder handling in DBI.xs preparse(), and the placeholder-limit regression was introduced with the cap added in 1.650. No CPE strings were supplied in the intelligence, so exact packaged-distribution ranges are not enumerated here. The authoritative advisory is GHSA-623j-hfpc-mrc4 (https://github.com/perl5-dbi/dbi/security/advisories/GHSA-623j-hfpc-mrc4), with corroborating write-ups at https://seclists.org/oss-sec/2026/q3/502 and https://vuldb.com/vuln/390752, and EU tracking under EUVD-2026-59745.

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

DBI is the standard database-access abstraction layer for Perl, and preparse() is its internal statement-rewriting helper that normalizes placeholder syntax between the ':name', ':N', '?', and '%s' conventions before handing SQL to a driver. The buffer sizing assumes the worst-case expansion of a numbered placeholder is ':p99999' (seven bytes), so it allocates seven output bytes per input byte. The root cause is CWE-1284 (Improper Validation of Specified Quantity in Input): the ':N' branch takes the integer from atoi(src) and assigns it directly to the binder counter with no bounds or sign validation. Because the placeholder cap added in 1.650 only compares the counter against 99,999, a counter that wrapped to a large negative value (INT_MIN via atoi overflow on glibc) silently passes the check, and the subsequent sprintf(start, ":p%d", idx++) writes far more bytes than the buffer reserved. This CVE has no CPE list in the provided data, but the affected component is unambiguously the DBI.xs core of the perl5-dbi/dbi project.

Know when the next one hits your stack

  • 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

Sources disagree (Medium–Critical)
Vendor (CPANSec) PRIMARY 9.1 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H
ENISA EUVD HIGH
vuln.today AI 7.4 HIGH

Heap write reachable via untrusted preparse input (AV:N, PR:N), but requires the specific ':pN' return style and allocator-dependent grooming for control, so AC:H; a write primitive yields I:H/A:H with no direct confidentiality impact.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:H
4.0 AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:H/VA:H/SC:N/SI:N/SA:N
SUSE MEDIUM
Red Hat 7.3 HIGH

vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.

CVSS VectorVendor: CPANSec

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

Lifecycle Timeline

3
CVSS changed
Aug 17, 2026 - 21:22 NVD
9.1 (CRITICAL)
CVE Published
Aug 15, 2026 - 12:09 cve.org
CRITICAL 9.1
CVE Published
Aug 15, 2026 - 12:09 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

DBI versions before 1.652 for Perl allow a heap out-of-bounds write via an unvalidated numeric placeholder that sets the binder counter in preparse.

preparse reserves seven output bytes per input byte, the width of the longest ':p99999' expansion. The ':N' branch parses the number with atoi(src) and assigns it to the binder counter with no range check, so a statement containing ':2147483648' leaves the counter negative (-2147483648 with glibc, where atoi wraps). Each following '?' then expands through sprintf(start, ":p%d", idx++) to ':p-2147483648', 14 bytes with the terminating NUL where the buffer budgets 7. The placeholder limit added in 1.650 tests the counter against 99,999, which a negative counter passes.

Any caller that preparses an untrusted statement into ':pN' style placeholders gets a heap out-of-bounds write that grows with the number of '?' marks following the poisoned placeholder. The '?' and '%s' return styles compare the parsed number against the expected sequence and error out, and are unaffected.

Executive ViewAI

Why It Matters

Perl DBI module before version 1.652 contains a critical heap out-of-bounds write vulnerability in SQL placeholder parsing that could enable memory corruption attacks on applications using database connectivity. Organizations running Perl-based database applications must prioritize immediate patching, though no public exploit has been identified and real-world exploitation likelihood remains low at 0.2% EPSS.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 90% exploitable
Prevalence
High
DBI is the de-facto database interface bundled across nearly all Perl deployments
Threat Intel
2
1 sources
Data Quality
9 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment NCSC-NL NEWS MSRC Vendor GitHub VulDB

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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Performance Computing 12 Not-Affected
SUSE Linux Enterprise High Performance Computing 15 SP7 Affected
SUSE Linux Enterprise Module for Basesystem 15 SP7 Affected
SUSE Linux Enterprise Server 15 SP7 Affected

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