Prevent Repeated Requests Using ActionFilters In ASP.NET MVC

Wherever there is a form or page that allows a user to post up information, there is an opportunity for repeat postings and spam. No one really enjoys being spammed or seeing hundreds of the same comments strewn across their forum, blog or other areas of discussion and this article aims to help curb that.

Using a Custom ActionFilter within ASP.NET MVC, we can create a reusable and flexible solution that will allow you to place time-limit constraints on the Requests being sent to your controllers that will assist in deterring spammers from bombarding you with duplicate items.

The Problem

A user with malicious intent decides that they want to spam your form and that you should have hundreds of duplicate messages decorating your forum, database or anything else you might be using as fast as the spammer can submit your form.

The Solution

To help prevent these multiple submission attempts, we will need to create a Custom ActionFilter that will keep track of the source of the Request (to ensure that it isn’t the same person), a delay value (to indicate the duration between attempts) and possibly some additional information such as error handling.

But first, let’s start with the ActionFilter itself:

  1. public class PreventSpamAttribute: ActionFilterAttribute  
  2. {  
  3.     public override void OnActionExecuting(ActionExecutingContext filterContext)  
  4.     {  
  5.         base.OnActionExecuting(filterContext);  
  6.     }  
  7. }  
This is a very basic implementation of an ActionFilter that will override the OnActionExecuting method and allow the addition of our extra spam-deterrent features. Now we can begin adding some of the features that we will need to help accomplish our mission, which includes:

 

  • A property to handle the delay between Requests.
  • A mechanism to uniquely identify the user making the Request (and their target).
  • A mechanism to store this information so that it is accessible when a Request occurs.
  • Properties to handle the output of ModelState information to display errors.

Let’s begin with adding the delay, which will just be an integer value that will indicate (in seconds) the minimum delay allowed between making Requests to a specific Controller Action along with some additional properties that will store information to handle displaying errors and redirecting invalid requests:

  1. public class PreventSpamAttribute: ActionFilterAttribute  
  2. {  
  3.     // This stores the time between Requests (in seconds)  
  4.     public int DelayRequest = 10;  
  5.     // The Error Message that will be displayed in case of   
  6.     // excessive Requests  
  7.     public string ErrorMessage = "Excessive Request Attempts Detected.";  
  8.     // This will store the URL to Redirect errors to  
  9.     public string RedirectURL;  
  10.     public override void OnActionExecuting(ActionExecutingContext filterContext)  
  11.     {  
  12.         base.OnActionExecuting(filterContext);  
  13.     }  
  14. }  
Identify the Requesting User and their Target

Next, we will need a method to store current information about the User and where their Request is originating from so that we can properly identify them. One method to do this would be to get some identifying information about the user (such as their IP Address) using the HTTP_X_FORWARDED_FOR header (and if that doesn’t exist, falling back on the REMOTE_ADDR header value) and possibly appending the User Agent (using the USER_AGENT header) in as well to further hone in on our User.
  1. public override void OnActionExecuting(ActionExecutingContext filterContext)  
  2. {  
  3.     // Store our HttpContext (for easier reference and code brevity)  
  4.     var request = filterContext.HttpContext.Request;  
  5.     // Grab the IP Address from the originating Request (example)  
  6.     var originationInfo = request.ServerVariables["HTTP_X_FORWARDED_FOR"] ? ? request.UserHostAddress;  
  7.     // Append the User Agent  
  8.     originationInfo += request.UserAgent;  
  9.     // Now we just need the target URL Information  
  10.     var targetInfo = request.RawUrl + request.QueryString;  
  11.     base.OnActionExecuting(filterContext);  
  12. }  
Generate a Hash to Uniquely Identify the Request

Now that we have the unique Request information for our User and their target, we can use this to generate a hash that will be stored and used to determine if later and possibly spammed requests are valid.

For this we will use the System.Security.Cryptography namespace to create a simple MD5 hash of your string values, so you will need to include the appropriate using statement where your ActionFilter is being declared:

using System.Security.Cryptography;

We can leverage LINQ to perform a short little single line conversion of our strings to a hashed string using this line from this previous post:
  1. // Generate a hash for your strings (appends each of the bytes of   
  2. // the value into a single hashed string)  
  3. var hashValue = string.Join("", MD5.Create().ComputeHash(Encoding.ASCII.GetBytes(originationInfo + targetInfo)).Select(s => s.ToString("x2")));   
Storing the Hash within the Cache

We can use the hashed string as a key that will be stored within the Cache to determine if a Request that is coming through is a duplicate and handle it accordingly.
  1. public override void OnActionExecuting(ActionExecutingContext filterContext)  
  2. {  
  3.     // Store our HttpContext (for easier reference and code brevity)  
  4.     var request = filterContext.HttpContext.Request;  
  5.     // Store our HttpContext.Cache (for easier reference and code brevity)  
  6.     var cache = filterContext.HttpContext.Cache;  
  7.     // Grab the IP Address from the originating Request (example)  
  8.     var originationInfo = request.ServerVariables["HTTP_X_FORWARDED_FOR"] ? ? request.UserHostAddress;  
  9.     // Append the User Agent  
  10.     originationInfo += request.UserAgent;  
  11.     // Now we just need the target URL Information  
  12.     var targetInfo = request.RawUrl + request.QueryString;  
  13.     // Generate a hash for your strings (appends each of the bytes of  
  14.     // the value into a single hashed string  
  15.     var hashValue = string.Join("", MD5.Create().ComputeHash(Encoding.ASCII.GetBytes(originationInfo + targetInfo)).Select(s => s.ToString("x2")));  
  16.     // Checks if the hashed value is contained in the Cache (indicating a repeat request)  
  17.     if (cache[hashValue] != null)  
  18.     {  
  19.         // Adds the Error Message to the Model and Redirect  
  20.         filterContext.Controller.ViewData.ModelState.AddModelError("ExcessiveRequests", ErrorMessage);  
  21.     }  
  22.     else  
  23.     {  
  24.         // Adds an empty object to the cache using the hashValue  
  25.         // to a key (This sets the expiration that will determine  
  26.         // if the Request is valid or not)  
  27.         cache.Add(hashValue, nullnull, DateTime.Now.AddSeconds(DelayRequest), Cache.NoSlidingExpiration, CacheItemPriority.Default, null);  
  28.     }  
  29.     base.OnActionExecuting(filterContext);  
  30. }  
Decorating your Methods

In order to apply this functionality to one of your existing methods, you’ll just need to decorate the method with your newly created [PreventSpam] attribute:
  1. // Displays your form initially  
  2. public ActionResult YourPage()  
  3. {  
  4.     return View(new TestModel());  
  5. }  
  6. [HttpPost]  
  7. [PreventSpam]  
  8. public ActionResult YourPage(TestModel yourModel)  
  9. {  
  10.     // If your Model was valid - output that it was successful!  
  11.     if (ModelState.IsValid)  
  12.     {  
  13.         return Content("Success!");  
  14.     }  
  15.     // Otherwise return the model to the View  
  16.     else  
  17.     {  
  18.         return View(yourModel);  
  19.     }  
  20. }  
Now when you visit your Controller Action, you’ll be presented with a very simple form:

model

Which after submitting will output a quick “Success!” message letting you know that the POST was performed properly.

However, if you decide to get an itchy trigger finger and go back any try to submit your form a few more times within the delay that was set within your attribute, you’ll be met with this guy:

// Displays your form initially public ActionResult YourPage()   {        return View(new TestModel()); }  [HttpPost] [PreventSpam] public ActionResult YourPage(TestModel yourModel)   {        // If your Model was valid - output that it was successful!        if (ModelState.IsValid)        {               return Content("Success!");        }        // Otherwise return the model to the View        else        {               return View(yourModel);        } }

Since the properties within your ActionFilter are public, they can be accessed within the actual [PreventSpam] attribute if you wanted to change the required delay, error message or add any other additional properties that you desire.

 

  1. // This action can only be accessed every 60 seconds and   
  2. // any additional requests within that timespan will   
  3. // notify the user with a custom message.   
  4. [PreventSpam(DelayRequest=60,ErrorMessage="You can only create a new widget every 60 seconds.")]  
  5. public ActionResult YourActionName(YourModel model)   
  6. {  
  7.    // Your Code Here  
  8. }  
Summary

While I have no doubts that this is not any kind of airtight solution to the issue of spamming in MVC applications, it does provide a method to help mitigate it. This ActionFilter-based solution is also highly flexible and can be easily extended to add some additional functionality and features if your needs required it.

Hopefully this post provides a bit more insight into the wonderful world of ActionFilters and some of the functionality that they can provide to help solve all kinds of issues.