crlf-and-header-injection
Skill2 starsChanged 4 months agoMITView on GitHub
SAST detection methodology for CRLF and header injection (CWE-93, CWE-113, CWE-117), including HTTP response splitting, Location/Set-Cookie header injection, log forging, SMTP/email (BCC) header injection, and Host header injection. Use when reviewing code that writes user input into HTTP headers, redirects, log lines, or email envelopes. Writes confirmed findings to findings/08-crlf-and-header-injection.md.
In this repository49 other files it gives its agents.
- authentication-flawsSkill
- broken-access-control-idorSkill
- business-logic-flawsSkill
- cicd-and-pipeline-injectionSkill
- code-injectionSkill
- command-injectionSkill
- cors-misconfigurationSkill
- cross-site-scriptingSkill
- csrfSkill
- dependency-and-supply-chainSkill
- dom-clobbering-and-postmessageSkill
- graphql-injection-and-abuseSkill
- hardcoded-secretsSkill
- http-request-smugglingSkill
- iac-misconfigurationSkill
- information-disclosureSkill
- insecure-deserializationSkill
- insecure-randomnessSkill
- jwt-vulnerabilitiesSkill
- ldap-injectionSkill
- llm-and-ai-application-securitySkill
- mass-assignmentSkill
- memory-safetySkill
- mobile-android-securitySkill
- mobile-ios-securitySkill
- nosql-injectionSkill
- oauth-oidc-saml-flawsSkill
- open-redirectSkill
- path-traversal-and-file-inclusionSkill
- prototype-pollutionSkill
- race-conditions-and-toctouSkill
- redosSkill
- sast-final-reportSkill
- sast-finding-validationSkill
- sast-methodologySkill
- security-logging-and-monitoring-failuresSkill
- security-misconfiguration-and-headersSkill
- server-side-template-injectionSkill
- session-managementSkill
- smart-contract-securitySkill
- sql-injectionSkill
- ssrfSkill
- unrestricted-file-uploadSkill
- unsafe-parsers-and-yamlSkill
- weak-cryptographySkill
- web-cache-poisoning-and-deceptionSkill
- websocket-securitySkill
- xpath-and-xml-injectionSkill
- xxeSkill
The file
We split this skill into the rules it gives an agent
1 rule. About 0 are common, 0 are distinctive, and 1 is very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈0
Distinctive · estimate
This author's own choices. Worth a look.
1
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 42
All HTTP inputs (query/body/path/header/cookie), with headers being a first-class source here: Host, Referer, X-Forwarded-*, User-Agent, …
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
CRLF & Header Injection — SAST Methodology
Class: CRLF / Header Injection · CWE-93 · OWASP: A03 Injection
Findings file: findings/08-crlf-and-header-injection.md
1. Overview
CRLF injection occurs when attacker-controlled data containing carriage-return
(\r, %0d) and line-feed (\n, %0a) sequences reaches a sink that treats
newlines as protocol delimiters — HTTP headers, log lines, or SMTP envelopes.
The core test: does a source value flow into a header/redirect/log/mail sink
without stripping or rejecting \r/\n (and their encoded forms)? A single
injected CRLF lets an attacker append headers, split a response into a second
attacker-controlled response (CWE-113 response splitting), forge log entries
(CWE-117), or inject extra mail recipients.
2. Where it lives
- Redirect helpers seeded from user input:
Location:built from?next=,?url=,?returnTo=. - Cookie writers echoing user data into
Set-Cookie(session, locale, tracking). - Custom header echoes: reflecting
X-Request-Id, filename inContent-Disposition, CORSAccess-Control-Allow-OriginfromOrigin. - Logging pipelines that concatenate raw request fields into a log line.
- Email senders that place user input into
To/From/Subject/Cc/Bcc. - Reverse-proxy / gateway config that forwards
HostorX-Forwarded-Hostinto downstream URLs, password-reset links, or cache keys.
3. Sources (tainted input)
All HTTP inputs (query/body/path/header/cookie), with headers being a
first-class source here: Host, Referer, X-Forwarded-*, User-Agent,
Origin, Content-Disposition filenames. Second-order: a username, display
name, or filename stored earlier and later emitted into a header, redirect, log,
or email. Trace stored values back to their original write source.
4. Sinks (dangerous operations)
// Java — dangerous
response.setHeader("Location", request.getParameter("next")); // response splitting
response.sendRedirect(userUrl); // no CRLF filter (old containers)
response.addCookie(new Cookie("locale", request.getParameter("loc")));
response.addHeader("X-Trace", req.getHeader("X-Request-Id"));
logger.info("login for user=" + username); // CWE-117 log forging// Node — dangerous
res.setHeader('Location', req.query.next); // Node throws on \n since ~v6, but
res.writeHead(302, { Location: req.query.url }); // custom raw writers / old libs don't
res.setHeader('Set-Cookie', 'lang=' + req.query.lang);
logger.info(`request from ${req.headers['user-agent']}`); // log injection# Python — dangerous
self.send_header("Location", environ["QUERY_STRING"]) # raw wsgi/http.server
response['X-Filename'] = request.GET['name'] # Django header from input
logging.info("user %s logged in" % username) # log forging → parser exploits
msg['To'] = request.form['email'] # email header injection// PHP — dangerous
header("Location: " . $_GET['url']); # header() blocks \n since 5.1.2, but
header("X-Lang: " . $_GET['lang']); # older/patched builds and raw fwrite() do not
mail($to, $subject, $body, # $_POST['email'] → Cc/Bcc injection
"From: " . $_POST['email']);Dangerous whenever the value can carry a raw or decoded \r\n. Even where a
runtime blocks bare \n in HTTP headers today, the same value is unsafe in
logs, email envelopes, and any custom/raw socket writer.
5. Sanitizers / safe patterns
Safe: reject or strip all of \r, \n, %0d, %0a, %0D, %0A, and null
bytes before the value reaches the sink; better, allowlist the value (e.g.
resolve ?next= against a fixed set of relative paths, or validate it is a
same-site relative path with no scheme/host). For redirects, prefer a mapping
table (key → known URL) over echoing the raw URL. For Host, validate against a
configured allowlist of expected hostnames. For logs, use structured/JSON logging
so newlines are encoded as data, not row separators. For email, use a library
that builds MIME headers via typed setters (msg['To'] = Address(...)).
Fails / not a real sanitizer:
- Stripping
\nbut not\r(or vice versa) — many parsers accept a lone\ror\nas a line terminator. - Filtering the literal bytes but not the URL-encoded/double-encoded forms
(
%0d,%250a) when the sink decodes later. - Relying on the runtime "already blocks header injection" — true only for the HTTP-header sink on modern versions, not for logs, email, or raw writers.
- Trimming only leading/trailing whitespace (
trim()), which leaves interior CRLF intact. - Allowlisting the redirect host but ignoring userinfo/
\/backslash tricks that some URL parsers treat as host separators.
6. Detection methodology
- Find sinks: grep for header/redirect/cookie/log/mail writers.
rg -n 'setHeader\(|addHeader\(|sendRedirect\(|writeHead\(|send_header|header\s*\(|addCookie\(|Set-Cookie' rg -n 'response\[|res\.setHeader|res\.writeHead|redirect\(|Location' rg -n 'logger\.(info|warn|error|debug)\(|logging\.(info|warning|error)\(|log\.Print' rg -n "mail\(|smtplib|MimeMessage|['\"](To|Cc|Bcc|From|Subject)['\"]\s*[:=]" - Confirm the value is concatenated/interpolated from a variable into the header/redirect/log/mail argument (not a constant).
- Trace the operand to a source: request param, header, cookie, or a stored value (second-order). Stop at a literal/constant.
- Check for a real neutralizer on the path: is
\r/\n(and encoded forms) stripped or the value allowlisted before the sink? Verify it is not one of the broken patterns in §5. - Confirm reachability: exposed route/handler, reachable (pre-auth?).
- Classify the impact: response splitting/header injection (HTTP), log forging (CWE-117), email header injection (BCC), or Host-header poisoning.
7. Modern & niche variants
- HTTP response splitting (CWE-113): injected CRLF plus a second set of headers and a body creates a fully attacker-controlled second response — historically used for cache poisoning and reflected XSS via the split body. Rare on modern app servers but alive in raw socket writers, custom gateways, and legacy containers.
- Location / Set-Cookie header injection: the most common live variant —
next=/%0d%0aSet-Cookie:%20session=attackerfixes a session, or injects aLocationplusContent-Length: 0to split the response. - Log injection / log forging (CWE-117): newlines in a logged field forge
fake log lines (spoof a successful login, hide traces). This is also a pivot
primitive: forged content that a downstream log parser, SIEM rule, or
templating log appender interprets can escalate — e.g. a Log4Shell-style
${jndi:ldap://...}payload landing in a Log4j-formatted message turns log injection into RCE. Flag any path where an unsanitized field reaches a lookup- enabled log formatter. - SMTP / email header injection (BCC injection): a
\nin a user-suppliedFrom/Subjectfield lets an attacker appendBcc:recipients or inject a new body — turning a contact form into an open spam relay or exfiltration channel. PHPmail()additional-headers and hand-built MIME are classic sites. - Host header injection: a forged
Host/X-Forwarded-Hostthat the app reflects into absolute URLs poisons password-reset links (account takeover), web-cache keys, and<base>-derived resource URLs. Especially dangerous when the reset-token email URL is built from the requestHost.
8. Common false positives
- Values written to headers/logs that are server-generated constants or numeric IDs with no newline-carrying charset.
- Redirects whose target is selected from a hard-coded allowlist/map, not echoed.
- Frameworks/runtimes that hard-reject
\r\nin the specific header sink AND the value never reaches a log/email/raw-writer sink. - Structured logging where the field is passed as a typed argument and the formatter encodes newlines.
9. Severity & exploitability
Base Medium for header/log injection. High when it yields session
fixation (Set-Cookie injection), password-reset poisoning via Host header
(→ account takeover), or reflected XSS via response splitting; Critical when
log injection reaches a lookup-enabled formatter enabling RCE (Log4Shell-style).
Email header injection is Medium–High (spam relay / data exfiltration).
Raise for pre-auth reachable, lower for admin-only echoes.
See references/severity-model.md.
10. Remediation
Strip or reject all CR/LF (raw and encoded) before any header/redirect/log/mail
sink; prefer allowlisting redirect targets and Host values. Use framework header
APIs that reject control characters, and structured/JSON logging that encodes
newlines. Build email headers with typed MIME setters, never string concatenation.
Configure a trusted-host allowlist and derive links from configuration, not the
request Host.
11. Output
Append each confirmed finding to findings/08-crlf-and-header-injection.md
using references/finding-template.md. Set Class: CRLF / Header Injection and
CWE: CWE-93 (use CWE-113 for response splitting, CWE-117 for log forging).
In Chain potential note primitives such as response header control (→
session fixation / cache poisoning), reflected content injection (→ XSS via
split response), Host-derived link poisoning (→ account takeover, consumes
nothing / provides the reset-link primitive), and log-content injection (→
feeds a downstream log-parser/Log4Shell chain).
Primitives (controlled): provides HTML_OUTPUT,CACHE_CONTROL (seed); consumes none
References
- CWE-93 CRLF Injection; CWE-113 HTTP Response Splitting; CWE-117 Improper Output Neutralization for Logs; OWASP A03:2021 Injection; OWASP Log Injection and Unvalidated Redirects & Forwards Cheat Sheets.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

