🔍 Search

CRLF Injection Attack

In this guide you will learn about CRLF injection attack by exploring its types with examples. We will also discuss methods and tools to detect, exploit, and prevent CRLF vulnerabilities in web applications.

What is CRLF Injection?

CRLF (Carriage Return Line Feed) Injection is a web security vulnerability that occurs when an attacker is able to insert CRLF characters into an application's input, allowing them to manipulate the response or execute malicious actions.

CRLF Injection attacks exploit the way applications handle data that includes CR and LF characters. When an application fails to sanitize user input, an attacker can inject CR and LF characters to alter the way the application processes data. This can lead to various security issues such as cross-site scripting (XSS), web cache poisoning, email spoofing, session hijacking, phishing attack, remote code execution, and more.

CRLF Characters Overview

Carriage Return (CR)

It is represented as '\r' in many programming languages and its ASCII value is 13 or 0xD. This returns the cursor to the beginning of the line.

Line Feed (LF)

It is represented as '\n' and has an ASCII value of 10 or 0xA. This moves the cursor to the next line.


Together, '\r\n' signifies the end of a line in many systems, particularly in Windows. In Unix and Linux, '\n' alone signifies a line end.

How CRLF Injection Works?

Here are some common steps taken by an attacker:

  • Step-1: Input Manipulation
    The attacker finds a point of entry where user input is accepted without proper sanitization.
  • Step-2: CRLF Sequence Injection
    The attacker inserts CRLF characters ('%0D%0A' in URL encoding) into this input.
  • Step-3: Exploiting the Injection
    Depending on the context, this injected CRLF sequence can split HTTP headers, alter logs, modify emails, etc.
  • Step-4: Execution of Malicious Intent
    The attacker leverages this injection to carry out actions like stealing cookies, redirecting users, or spreading misinformation.

Types of CRLF Injection Attacks

Some common types of CRPF attacks with examples are given below. Each of these attacks exploits the CRLF vulnerability in different ways, and the severity can vary based on the context and the specific implementation of the application.

1. HTTP Response Splitting

HTTP response splitting attacks occur when an attacker injects CRLF characters into HTTP responses generated by a web application. This can lead to various exploits, such as injecting malicious content into web pages, manipulating headers, or causing the browser to execute malicious scripts.


Suppose a vulnerable web application accepts user input for generating dynamic web pages without proper validation. An attacker can craft a malicious HTTP request like this: GET /vulnerable-page HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0
Referer: http://evil.com%0D%0AContent-Length: 0%0D%0A%0D%0AHTTP/1.1 200 OK%0D%0AContent-Type: text/html%0D%0AContent-Length: 50%0D%0A%0D%0A<html>Malicious Content</html>
In this example, the attacker injects CRLF characters '%0D%0A' to split the HTTP response headers from the malicious content. As a result, the web page displays "Malicious Content" to the user, which can be a phishing form or other harmful content.

2. HTTP Request Smuggling

HTTP Request Smuggling occurs when an attacker manipulates the interpretation of HTTP requests by causing discrepancies between how the front-end proxy server and the back-end server interpret the request.

By injecting CRLF characters strategically, an attacker can trick the systems into processing multiple requests in unintended ways, leading to potential data leakage, session hijacking, or privilege escalation.


Using CRLF to exploit inconsistencies between front-end and back-end servers: POST /path HTTP/1.1\r\nHost: target.com\r\nContent-Length: 10\r\n\r\n0\r\nG\r\n\r\nPOST /malicious HTTP/1.1\r\nHost: target.com\r\nContent-Length: 15\r\n\r\n In this example, the first request is processed by the front-end server as one request, but the back-end server interprets it as two separate requests, potentially allowing the attacker to manipulate the request flow.

3. SMTP Header Injection

SMTP (Simple Mail Transfer Protocol) header injection attacks occur when an attacker injects CRLF characters into email headers. This can lead to email spoofing, allowing attackers to send fraudulent emails that appear to originate from a trusted source.


SMTP header injection attacks allow attackers to send fraudulent emails with malicious payloads. An attacker can craft an email like this: To: victim@example.com%0D%0ABcc: attacker@example.com
Subject: Important Information

This is a malicious email.
In this example, the attacker injects CRLF characters '%0D%0A' into the email headers, adding a Bcc header that forwards a copy of the email to the attacker's address without the victim's knowledge.

4. Log Injection

Log injection attacks involve injecting CRLF characters into log files generated by a web application or server. By doing so, attackers can obscure their actions, avoid detection, or manipulate log entries to deceive administrators or security tools.


Consider a vulnerable web application that logs user actions without proper input validation. An attacker can inject CRLF characters into the application's logs to hide malicious activities or manipulate log entries. For example: User input: /login?user=admin%0D%0AInjected%20Log%20Entry:%20Attacker%20logged%20in In this case, the attacker injects a new log entry "Attacker logged in" by inserting CRLF characters '%0D%0A' into the user input, making it appear as if the attacker successfully logged in.

Prevention and Mitigation

To protect your applications and systems from CRLF injection attacks, consider the following best practices:

1. Input Validation

Ensure that all user input is properly validated and sanitized to prevent the injection of control characters like CR (Carriage Return, %0D) and LF (Line Feed, %0A).

2. Output Encoding

Properly encode all user-generated content before rendering it in HTTP responses, log files, or other output channels to prevent CRLF characters from being interpreted as control characters.

3. Security Headers

Implement security headers like Content Security Policy (CSP) and X-Content-Type-Options to mitigate CRLF attacks.

4. Regular Security Audits

Conduct regular security audits and penetration testing to identify and remediate CRLF Injection vulnerabilities in your application.

5. Use Security Libraries

Use security libraries and frameworks that provide built-in protection against CRLF Injection attacks, such as OWASP's ESAPI or Web Application Firewalls (WAFs).

Like this Article? Please Share & Help Others: