/

CVE-2026-15062

Severity:

CRITICAL RISK

(9.6)

SQL Injection (CWE-89) in Snowflake Snowpark Python SDK

CVE-2026-15062

Awaiting Analysis

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Privilege escalation and unauthorized data access in Snowflake environments

Severity:

CRITICAL RISK

(9.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

SQL injection flaws in the Snowflake Snowpark Python SDK allow crafted inputs to break out of intended query scopes and execute arbitrary SQL under the caller's session.

When authenticated low-privilege users control column names, export paths, or location parameters, they can potentially escalate privileges, redirect data operations, and access data beyond their authorization.

Affected context

These vulnerabilities arise in applications using the Snowflake Snowpark Python SDK (snowpark-python) in ways that expose query construction to user-controlled or upstream data values.

Risk is higher where:

  • DataFrameReader.dbapi() is used with database metadata (such as column names) originating from untrusted or semi-trusted sources
  • DataFrameWriter write methods accept a location parameter that can be influenced by lower-privileged users or external data
  • DataFrame.to_csv() export paths are derived from user input or dynamically generated strings without robust validation

In such contexts, the SDK's query-building and path-normalization logic can be subverted to inject SQL into COPY INTO or other statements.

Exploit preconditions

  • Attack surface: Application code that relies on the Snowpark Python SDK to construct and execute SQL or COPY INTO statements.
  • Required access: Authenticated access to a Snowflake session with at least low-privilege roles, plus the ability to influence column names, export paths, or location parameters through application inputs or upstream data.
  • Trigger points:
  • Use of DataFrameReader.dbapi() where SQL is built from database metadata containing crafted column names.
  • Invocation of DataFrameWriter write methods with a location parameter that is treated as a source for COPY INTO, enabling redirection to an arbitrary query.
  • Calls to DataFrame.to_csv() with an export path containing a backslash-single-quote sequence that bypasses normalize_path() sanitization and gets embedded into SQL.
  • Why exploitation is possible: The SDK's SQL construction routines insufficiently isolate data values from SQL syntax, allowing attacker-controlled strings to alter the structure of generated queries instead of being safely treated as literals.

Why this happens

The underlying bug class is classic SQL injection: application logic composes SQL statements by concatenating or interpolating values that are not strictly treated as data.

In this case, Snowpark Python's APIs (such as dbapi() and write/to_csv() flows) rely on string manipulation and partial sanitization to embed column names, file paths, or locations into SQL, but they do not consistently enforce quoting, escaping, or parameterization.

This maps directly to CWE-89: Improper Neutralization of Special Elements used in an SQL Command, where meta-characters and sequences (like backslash-single-quote or crafted identifiers) are allowed to change the intended query structure and authorization boundaries.

Potential impact

  • Authenticated users may execute SQL beyond their intended permission scope using injected payloads.
  • Attackers could escalate privileges within a Snowflake account by abusing COPY INTO redirection or metadata-driven queries.
  • Source databases connected to Snowflake can be compromised via injected queries that read or manipulate underlying data.
  • Cross-tenant data exfiltration may occur if injected SQL can reference data belonging to other tenants in multi-tenant deployments.
  • Unauthorized reads of Snowflake account metadata and sensitive tables can be performed under the compromised session's context.
  • Further abuse of misconfigured roles and grants may lead to broader account takeover or persistent data tampering.

General mitigation guidance

Mitigation focuses on removing direct string-based query composition and tightening how application inputs reach Snowpark APIs.

Recommended patterns include:

  • Treat all column names, file paths, and location parameters as data, not SQL, and ensure they are passed through APIs that enforce proper quoting or parameterization rather than manual string concatenation.
  • Introduce strict validation and allowlists for identifiers, export paths, and data locations so only expected formats and known-safe patterns are accepted.
  • Centralize SQL construction in well-reviewed helper functions that separate query structure from external values and apply consistent escaping.
  • Reduce the privileges granted to roles used by Snowpark-based applications so that even if injection occurs, the blast radius is limited.
  • Prefer secure-by-default abstractions (e.g., ORM-like or high-level data operations) over constructing raw SQL or relying on implicit translation of strings to SQL.
  • Avoid deriving Snowpark locations or export paths directly from user input; instead, map user choices to predefined, vetted configuration entries.

How teams detect issues like this

Organizations can detect and manage these SQL injection risks through multiple layers:

  • Static analysis rules targeting string-based SQL construction patterns in Python code, especially where Snowpark DataFrameReader.dbapi(), DataFrameWriter write methods, or DataFrame.to_csv() receive dynamic strings.
  • Code review checklists that flag use of unvalidated identifiers, paths, or locations in query-building logic and insist on allowlists or parameterization.
  • Secure coding policies that prohibit mixing SQL syntax with user-controlled values and require the use of safe query builders or prepared-statement-like APIs.
  • Logging and monitoring of Snowflake query activity, looking for anomalous patterns such as unexpected COPY INTO sources, unusual path or identifier structures, or queries accessing out-of-scope schemas.
  • Optional use of automated code review tools and SAST platforms configured to recognize CWE-89 patterns and Snowpark-specific API misuse.

Sources

SourceLink
github.comgithub.com/snowflakedb/snowpark-python/blob/main/CHANGELOG.md

Frequently asked

questions

Exploitation requires authenticated access to a Snowflake session and control over certain inputs used by the Snowpark Python SDK. In environments where low-privilege users or upstream data can influence column names, paths, or location parameters, the issue can be broadly exploitable within those authorization boundaries.

An attacker typically needs low-privilege authenticated access and the ability to manipulate application inputs or metadata that feed into Snowpark APIs. They do not need administrative rights, but their session must be able to run the affected operations for injected SQL to succeed.

The safest pattern is to eliminate any direct string concatenation or interpolation that mixes SQL syntax with external values. Use APIs that treat all inputs as data, apply strict validation and allowlists for identifiers and paths, and encapsulate query construction in hardened helper functions that enforce consistent quoting and escaping.

Establish secure coding standards around database access: never build SQL by hand with untrusted input, prefer structured query builders or parameterized constructs, validate all identifiers and paths, and maintain least-privilege roles for application sessions. Incorporate automated checks and targeted code reviews for Snowpark-related data access logic to catch injection patterns early in development.

Find out what's already
exploitable in your codebase.