Skip to main content

Microsoft .NET MVC ReDoS (Denial of Service) Vulnerability - CVE-2015-2526 (MS15-101)

Microsoft released a security bulletin (MS15-101) describing a .NET MVC Denial of Service vulnerability (CVE-2015-2526) that I reported back in April. This blog post analyses the vulnerability in details, starting from the theory and then providing a PoC exploit against a MVC web application developed with Visual Studio 2013.
For those of you who want to see the bug, you can directly skip to the last part of this post or watch the video directly... ;-)

A bit of theory

The .NET framework (4.5 tested version) uses backtracking regular expression matcher when performing a match against an expression. Backtracking is based on the NFA (non-deterministic finite automata) algorithm engine which is designed to validate all input states. By providing an “evil” regex expression – an expression for which the engine can be forced to calculate an exponential number of states - it is possible to force the engine to calculate an exponential number of states, leading to a condition defined such as “catastrophic backtracking” aka ReDoS.

The vulnerability

In .NET Framework (4.5), “evil” regular expressions are used by default in three classes (EmailAddressAttribute, PhoneAttribute, UrlAttribute) which are part of System.CompontentModel.DataAnnotations .NET library.

These classes provide the default validation mechanism for email address, phone number and URL input types in web forms. Furthermore, these three classes do not enforce a regex match timeout.

The following screen shots show the evil regex and the lack of match timeout:

EmailAddressAttribute Source code 

PhoneAttribute Source Code

UrlAttribute Source Code

As a consequence, an attacker can craft a malicious payload to force the .NET regex engine to perform a large number of computations and cause a Denial of Service against the targeted controller (e.g. login form) which uses default validation mechanism provided by .NET framework.

The Denial of Service condition is only specific to the target class controller (e.g. login form, registration form, contact form, etc.). Users can still potentially navigate the site but they are prevented from using parts of it.

As an example, the .NET email address regex is analyzed. Its regex expression is considered an “evil” regex, due to its complexity, repetition, nesting and recursion. The regex is reported in the screen shot below. The software RegexBuddy was used to analyze it.

The theory of the attack is demonstrated below, with the help of RegexBuddy and its built-in debugger (set for C# - .NET 2.0-4.5) - with payload (in the table below) which will never match the above regex:


An extract of the last 26 operations (stopped by RegexBuddy) can be found below, from the Debugger view:

This shows the “catastrophic backtracking” condition reached by the matcher. In this case, RegexBuddy stops calculations after one million steps, however, the vulnerable class – EmailAddressAttribute - does not enforce a match timeout and therefore the .NET regex engine continues to compute steps, leading the w3wp.exe process (IIS Worker Pool) on the web server to reach a 99% CPU starvation condition for an extended amount of time, which can last various hours to days, depending on the payload used.

The payload can be constructed in different ways, providing the attacker with the capability to bypass IDS/IPS signature based controls. The attacker can set scripts to automatically attack vulnerable forms on a regular time basis.

The exploit

The exploitation consists in sending a crafted HTTP POST request against a web form using a vulnerable class (e.g. EmailAddressAttribute). As an example, the attack is demonstrated against a .NET MVC web application developed with the Visual Studio 2013. The application provides a login form which uses the default email address validation mechanism in .NET framework. The screen shot below shows the login page:

An attacker can bypass client-side validation in .NET by sending the request via script or proxy and manipulating the request, as shown below:

POST /Account/Login HTTP/1.1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:36.0) Gecko/20100101 Firefox/36.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Cookie: __RequestVerificationToken=FkLGrc6-XD2IBVU9g1nPycs0GTu3jWiK2QEyvR8IsowXAJU3C5fHlHvQvwGgB0VcN1FTa_hB9KZ6Pi8SeI5EKpvz_EeOqD7y_FnipWJWqOU1
Connection: keep-alive
Content-Type: application/x-www-form-urlencoded
Content-Length: 239


Below, an extract of the source code used for the validation of the EmailAddress field:

AccountModelView.cs - use of [EmailAddress] default class in .NET

   public class LoginViewModel
        [Display(Name = "Email")]
        public string Email { get; set; }

AccountController.cs – ModelState is validated when  the POST request occurs

// POST: /Account/Login
        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
            if (!ModelState.IsValid)
                return View(model);

            // This doesn't count login failures towards account lockout
            // To enable password failures to trigger account lockout, change to shouldLockout: true
            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)

The table below shows the DoS condition on the web server, after the request has been issued.

Following the request, the Denial of Service occurs against the /Account/Login controller class. At this stage, no other users can use /Account/Login form controller class, while the w3wp.exe process is at 99% CPU starvation.

The w3wp.exe process needs to be terminated in order to recover the application from the attack. After few manual recoveries, the application becomes unusable, and the server needs to be restarted.

Below a video that demonstrates the attack in action:

The table below includes valid and tested attack patterns which result in a successful ReDoS attack against .NET applications:

Malicious Payload



  1. "Backtracking is based on the NFA non-finite-algorithm".
    Did you mean "Non-deterministic Finite Automaton"?

  2. Yes, thx for the comment, rectified in the article.

  3. Dinis Cruz's blog on the same topic...


Post a Comment

Popular posts from this blog

TrendMicro ScanMail for Microsoft Exchange (SMEX) predictable session token - CVE-2015-3326

It's time for another advisory ( CVE-2015-3326 ), a simple one, for a vulnerability which can be found quickly and trivially. For those of you who just want to give a glance at the post, I suggest to directly watch the picture which says it all! The following vulnerability was discovered on TrendMicro SMEX (ScanMail for Microsoft Exchange) 10 SP2 but it affects other versions as well. While surfing the SMEX web administrative interface using a web proxy, I have noticed something in the HTTP request - the session token itself and its format, a number. After observing a significant number of logins, the session token was always represented with an number composed of minimum 4 digits and maximum 5 digits, as shown in the screen shot below:   Although the observed session tokens were never generated sequentially, the lack of a cryptographically strong PRNG for the session identifier, allows a malicious user to trivially guess the token. This attack can be easily automated.

Alcatel Lucent Omnivista or: How I learned GIOP and gained Unauthenticated Remote Code Execution (CVE-2016-9796)

It is time for another advisory or better a blog post about Alcatel Lucent Omnivista  and its vulnerabilities. Omnivista is a central management network tool and it is typically used in medium/large organisation with a complex VoIP/SIP infrastructure. Interestingly enough, this software belongs to the niche of "undownloadable" software and it requires a license to work as well. My "luck" came during an engagement where it was already installed and this post documents one of the many 0days discovered during such audit. The reasons why I wanted to dedicate a single blog post on this vulnerability are several. First, remote code execution (RCE) is always a sweet bug to show. Second, I strongly believe that documenting vulnerabilities in applications using old protocols and standards, respectively GIOP and CORBA, can be beneficial for the infosec community, since no many examples of vulnerabilities in such applications are available or published on the Interne