Claude went back to its usual answers on the two SQL-injection requests.

This request triggered restrictions on violative cyber content and was blocked under Anthropic's Usage Policy. To learn more, see https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback.

SQL Injection: A Developer Briefing

The Root Cause

Every SQL injection vulnerability comes from the same mistake: untrusted data is concatenated into a query string, so the database parses attacker input as code rather than treating it as data. The taxonomy below describes how attackers extract value from that flaw, but the fix is almost always the same regardless of class.

1. In-Band SQLi (Results come back over the same channel)

The attacker sees the outcome directly in the application's response. Easiest to exploit, easiest to detect.

Error-based — The app leaks database error messages. Malformed input causes the DBMS to emit errors containing table names, column types, or even query results (e.g., via type-conversion errors in SQL Server, or extractvalue()/XML functions in MySQL). Verbose errors turn a blind vulnerability into an open book.

Union-based — The attacker appends UNION SELECT to graft a second result set onto the original query, pulling arbitrary columns from arbitrary tables into the page where the legitimate results normally render. Requires matching column count and compatible types, which attackers determine by iterating.

2. Inferential / "Blind" SQLi (No data returned directly)

Results aren't displayed, but the attacker infers data one bit at a time by observing application behavior. Slower, but just as complete — automated tooling makes this routine.

Boolean-based (content-based) — The attacker injects a condition and watches whether the page renders differently. AND 1=1 vs. AND 1=2 produce distinguishable responses; from there they binary-search character values: "is the first character of the admin password hash greater than 'm'?"

Time-based — When responses are byte-identical regardless of truth value, the attacker uses conditional delays (SLEEP(), WAITFOR DELAY, pg_sleep(), or heavy computation) and measures response latency. A slow response means "true." Works even with no visible output at all.

3. Out-of-Band SQLi

The attacker makes the database itself initiate a network connection to a server they control — DNS lookups, HTTP requests, SMB shares, or file operations. Useful when the response channel is unusable or asynchronous. Depends on risky DBMS features being enabled (xp_dirtree, UTL_HTTP, LOAD_FILE, etc.). Practical takeaway: egress filtering on database hosts and disabling these functions removes an entire exfiltration path.

4. Second-Order (Stored) SQLi

The most commonly missed class in code review. Input is safely stored on the way in, then later read from the database and concatenated into a different query without sanitization — often by a background job, admin panel, or reporting feature.

The critical lesson: data retrieved from your own database is not trusted input. Trust boundaries are about how data is used, not where it came from.

Notable Variants Worth Naming

• •Authentication bypass — Injecting into a login query so the WHERE clause always evaluates true, or commenting out the password check. Classic, still found in the wild.
• •Stacked queries — Where the driver permits multiple statements per call (; DROP TABLE..., ; UPDATE users SET role='admin'), injection becomes arbitrary write access, not just read.
• •ORDER BY / LIMIT / table-name injection — Parameterization doesn't cover identifiers or clause structure. These spots require allowlisting instead. A very common source of "but we use prepared statements" vulnerabilities.
• •NoSQL / ORM injection — The same class of flaw applies to MongoDB query operators, JPQL/HQL, and raw-query escape hatches in ORMs.

What To Tell Your Team To Actually Do

Primary control: parameterized queries / prepared statements. Bind every variable. Never build SQL by concatenation or string interpolation, including in f-strings and template literals. This is non-negotiable and handles the vast majority of cases.

For things that can't be parameterized (table names, column names, sort direction, dynamic IN lists): map user input to values from a hardcoded allowlist. Never pass the raw value through, even escaped.

Stored procedures help only if written safely — a procedure that concatenates its arguments into dynamic SQL is just as vulnerable.

Defense in depth:

• •Least-privilege database accounts — the app's user should not own its schema or hold DDL rights
• •Generic error pages in production; detailed errors to logs only
• •Input validation as a secondary layer (type, length, format) — never as the primary defense
• •Disable multi-statement execution in your DB driver where possible
• •Egress restrictions on database hosts

Verification: SAST for concatenation patterns, DAST/sqlmap against staging, and code review rules that flag raw query APIs. Pay special attention to reporting features, bulk/batch jobs, admin tooling, and legacy endpoints — these are consistently where injection survives, because they're written fast and reviewed rarely.

If it's useful, I can put together language-specific safe/unsafe code examples for whatever stack your team uses, or a review checklist they can apply to pull requests.