Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply overlong table/schema name via application SQL
-
DeliveryDriver quotes name into 128-byte stack buffer
-
ExploitFaulty length check allows 2-byte over-write
-
ExecutionDouble-quote and NUL corrupt adjacent stack
-
ImpactProcess crash or stack corruption
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Stack buffer bounds checking
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires an application that forwards untrusted SQL text to psqlODBC, where the attacker-influenced identifier exceeds the 128-byte stack buffer. Two concrete paths are named: (1) the table name of a statement the driver parses to describe its columns, and (2) the target table of the last INSERT when the driver rewrites SELECT @@IDENTITY - both sourced from the application's SQL text and causing up to a two-byte over-write. A third path requires a malicious or compromised PostgreSQL server to return an overlong column name during the @@IDENTITY rewrite, causing a one-byte over-write. Limiting factors: only a double quote and NUL are written and their content is attacker-uncontrolled; identifiers must be long enough to exceed 128 bytes; the application must actually expose/forward untrusted identifiers; and only versions before psqlODBC 18.00.0006 are affected. The complete fix is upgrading to 18.00.0006 as stated by the vendor. |
| Impact | This is a moderate-severity issue (CVSS 5.9) whose signals point to a defect worth patching on a normal cycle rather than an emergency. The input CVSS vector (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H) describes a network-reachable but high-complexity flaw requiring some privilege (PR:L), with no confidentiality impact, low integrity impact, and high availability impact - consistent with the mechanism described: a bounded overwrite of just two fixed bytes (a double quote and a NUL) past a 128-byte stack buffer, with the attacker controlling the length of a name but not the overwritten content. Because only a quote and NUL are written and the attacker cannot choose those bytes, reliable code execution is unlikely and the realistic outcome is stack corruption and process crash, matching the A:H / I:L weighting. The vuln.today priority is 'this_month', which aligns with medium real-world risk. There is no CISA KEV listing and no EPSS score in the supplied data, so exploitation probability cannot be quantified here; the only reference is the vendor security advisory (GHSA-285r-84w3-xcxv), not a working exploit, so no public exploit identified at time of analysis. One tension to verify: the CVSS marks AV:N, but the description shows the trigger requires either an application that forwards untrusted SQL identifiers to the driver or, for the @@IDENTITY path, a malicious or compromised PostgreSQL server returning a long column name - so real-world reachability depends heavily on how the consuming application exposes SQL text, not on the driver alone. |
| Exploit ScenarioDerived | An attacker who can influence the SQL text an application passes to psqlODBC supplies an overlong schema or table name (exceeding the 128-byte buffer); when the driver quotes that name to describe a statement's columns or to rewrite SELECT @@IDENTITY against the last INSERT target, the flawed length check lets it write a double quote and NUL up to two bytes past the stack buffer, corrupting the stack and likely crashing the process. Alternatively, a malicious or compromised PostgreSQL server can return an overlong column name during the @@IDENTITY rewrite to force a one-byte overflow. No public exploit identified at time of analysis; only the vendor advisory is available. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 02, 2026
Stack buffer over-write in psqlODBC before 18.00.0006 can corrupt an application process that forwards attacker-influenced SQL text to the driver. A schema or table identifier longer than the 128-byte stack buffer can cause up to two bytes past the buffer (a double quote and NUL) via a parsed statement's table name or the last INSERT target during SELECT @@IDENTITY rewriting, and a malicious or compromised PostgreSQL server can add a one-byte over-write through an overlong column name in that rewrite. CVSS 3.1 scores this 5.9 (AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H), exploitation requires the application to expose untrusted identifiers, the supplied priority label is this_month for normal-cycle patching, and the supplied data shows no CISA KEV confirmation or public exploit reference; no public exploit identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade psqlODBC to 18.00.0006 or later, which the vendor identifies as the complete fix; see https://github.com/postgresql-interfaces/psqlodbc/security/advisories/GHSA-285r-84w3-xcxv. If immediate upgrade is not possible, reduce exposure by preventing applications from forwarding untrusted SQL text or attacker-controlled schema and table identifiers to psqlODBC and by enforcing identifier lengths below 128 bytes before the driver parses them; these compensating controls restrict dynamic SQL functionality and do not replace the upgrade.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
psqlODBC is PostgreSQL's ODBC driver; it quotes schema and table identifiers into a fixed 128-byte stack buffer. The root cause is CWE-121 stack-based buffer overflow: the length check does not prevent writing past the end for long identifiers, and the bytes written past the buffer are a double quote and NUL, so the written content is attacker-uncontrolled but stack corruption is possible. The affected inputs are the table name of a statement the driver parses to describe columns and the target table of the last INSERT when the driver rewrites SELECT @@IDENTITY, both taken from the application's SQL text; during the @@IDENTITY rewrite a column name returned by the server can also produce a one-byte over-write. CPE cpe:2.3:a:postgresql:psqlodbc:*:*:*:*:*:*:*:* covers versions before 18.00.0006. The CVSS vector indicates network attack (AV:N), high complexity (AC:H), low privileges (PR:L), no user interaction, no confidentiality impact, low integrity impact and high availability impact.
Know when Psqlodbc 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
AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H
AC:H because the attacker must craft identifiers exceeding 128 bytes with no control over the two overwritten bytes; PR:L as some application-level access to submit SQL is typically required; C:N with A:H since the realistic outcome is stack corruption/crash.
Primary rating from Vendor (PostgreSQL).
CVSS VectorVendor: PostgreSQL
Lifecycle Timeline
1DescriptionCVE.org
When psqlODBC quotes a schema or table name into a 128-byte stack buffer, its length check lets it write up to two bytes past the end of the buffer for a long name. The names come from the application's SQL text: the table of a statement the driver parses to describe its columns, and the target of the last INSERT when the driver rewrites SELECT @@IDENTITY. In the @@IDENTITY rewrite, a column name sent by the server can also write one byte past the buffer. The bytes written past the buffer are a double quote and a NUL. An application that forwards untrusted SQL text to the driver exposes its process to stack corruption. Versions before psqlODBC 18.00.0006 are affected.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
A stack-based buffer overflow occurs when a program writes more data to a buffer located on the stack than it was allocated to hold.
Out-of-bounds reads and writes in psqlODBC before 18.00.0006 arise when a host application forwards untrusted column num
SQL injection in psqlODBC before 18.00.0006 allows an attacker who can influence a table or schema name passed by a host
A stack-based buffer overflow (CWE-121) in the psqlODBC driver, the official PostgreSQL ODBC driver, lets attacker-influ
Heap out-of-bounds write in the psqlODBC driver (CWE-787) affects all versions before 18.00.0006 and is reachable only w
A heap buffer overflow in psqlODBC's large-object read path lets a malicious or man-in-the-middle PostgreSQL server over
SQL injection in psqlODBC before 18.00.0006 can let an authenticated database user who can create a table that an applic
Format-string handling in psqlODBC before 18.00.0006 can crash applications or disclose client memory when an updatable
Heap memory corruption in psqlODBC versions before 18.00.0005 can be triggered when an application binds 32,769 or more
A stack-based buffer overflow in psqlODBC, the PostgreSQL ODBC driver, affects all releases before 18.00.0006 when updat
Client-side crash and limited out-of-bounds read affect psqlODBC before 18.00.0006 when the driver connects to a Postgre
psqlODBC before 18.00.0006 on Unix-like systems can expose query text and data to other local users when logging is enab
EUVD-2026-115376
NVD
CVE.org
Vulnrichment
GitHub
Exploit-DB