| Name |
Using Meta-characters in E-mail Headers to Inject Malicious Payloads |
|
| Likelyhood of attack |
Typical severity |
| High |
High |
|
| Summary |
This type of attack involves an attacker leveraging meta-characters in email headers to inject improper behavior into email programs. Email software has become increasingly sophisticated and feature-rich. In addition, email applications are ubiquitous and connected directly to the Web making them ideal targets to launch and propagate attacks. As the user demand for new functionality in email applications grows, they become more like browsers with complex rendering and plug in routines. As more email functionality is included and abstracted from the user, this creates opportunities for attackers. Virtually all email applications do not list email header information by default, however the email header contains valuable attacker vectors for the attacker to exploit particularly if the behavior of the email client application is known. Meta-characters are hidden from the user, but can contain scripts, enumerations, probes, and other attacks against the user's system. |
| Prerequisites |
This attack targets most widely deployed feature rich email applications, including web based email programs. |
| Execution Flow |
| Step |
Phase |
Description |
Techniques |
| 1 |
Experiment |
[Identify and characterize metacharacter-processing vulnerabilities in email headers] An attacker creates emails with headers containing various metacharacter-based malicious payloads in order to determine whether the target application processes the malicious content and in what manner it does so. |
- Use an automated tool (fuzzer) to create malicious emails headers containing metacharacter-based payloads.
- Manually tampering email headers to inject malicious metacharacter-based payload content in them.
|
| 2 |
Exploit |
An attacker leverages vulnerabilities identified during the Experiment Phase to inject malicious email headers and cause the targeted email application to exhibit behavior outside of its expected constraints. |
- Send emails with specifically-constructed, metacharacter-based malicious payloads in the email headers to targeted systems running email processing applications identified as vulnerable during the Experiment Phase.
|
|
| Solutions | Design: Perform validation on email header data Implementation: Implement email filtering solutions on mail server or on MTA, relay server. Implementation: Mail servers that perform strict validation may catch these attacks, because metacharacters are not allowed in many header variables such as dns names |
| Related Weaknesses |
|
CWE ID
|
Description
|
| CWE-88 |
Improper Neutralization of Argument Delimiters in a Command ('Argument Injection') |
| CWE-150 |
Improper Neutralization of Escape, Meta, or Control Sequences |
| CWE-697 |
Incorrect Comparison |
| CWE-713 |
OWASP Top Ten 2007 Category A2 - Injection Flaws |
|
| Related CAPECS |
|
CAPEC ID
|
Description
|
| CAPEC-134 |
An attacker manipulates the headers and content of an email message by injecting data via the use of delimiter characters native to the protocol. Many applications allow users to send email messages by filling in fields. For example, a web site may have a link to "share this site with a friend" where the user provides the recipient's email address and the web application fills out all the other fields, such as the subject and body. In this pattern, an attacker adds header and body information to an email message by injecting additional content in an input field used to construct a header of the mail message. This attack takes advantage of the fact that RFC 822 requires that headers in a mail message be separated by a carriage return. As a result, an attacker can inject new headers or content simply by adding a delimiting carriage return and then supplying the new heading and body information. This attack will not work if the user can only supply the message body since a carriage return in the body is treated as a normal character. |
| CAPEC-242 |
An adversary exploits a weakness in input validation on the target to inject new code into that which is currently executing. This differs from code inclusion in that code inclusion involves the addition or replacement of a reference to a code file, which is subsequently loaded by the target and used as part of the code of some application. |
|