Is there a way to discriminate a specific System.Web.HttpException?

Question

I've some "bad boys" users which call my website using controller that doesn't exist. Such as www.myapp.com/.svn/, or www.myapp.com/wp-admin/.

The app basically throw a System.Web.HttpException, which this ExceptionMessage: The controller for path '...' was not found or does not implement IController.

Is there a way to exactly catch this "sub" System.Web.HttpException in a robust way? (not comparing the string of ExceptionMessage, of course).

Any sub InnerException type and/or some "code" which indicate that exact exception?

Answer 1

You might create a custom IControllerFactory, e.g. by deriving from DefaultControllerFactory.

Its GetControllerInstance method will be called with a null value for the controllerType argument, when no matching controller could be resolved.
At this point, you are ahead of the Exception.

IController GetControllerInstance(RequestContext requestContext, Type controllerType)

Here you decide how to handle the request, like e.g. logging and/or handling the request by a specific controller.

The example below shows how the ErrorController is being used as fallback, executing its Index action method.

class CustomControllerFactory : DefaultControllerFactory
{
    protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
    {
        if (controllerType == null)
        {
            var routeData = requestContext.RouteData;
            routeData.Values["controller"] = "Error";
            routeData.Values["action"] = "Index";
            controllerType = typeof(ErrorController);
        }

        return base.GetControllerInstance(requestContext, controllerType);
    }
}

A custom controller factory gets installed from within e.g. Application_Start in Global.asax.cs using:

ControllerBuilder.Current.SetControllerFactory(new CustomControllerFactory());

---

Note that this doesn't guard you from a related exception in case the contoller does exist, but the action doesn't.

E.g. given a HomeController without an Ufo action method, the url www.myapp.com/home/ufo results in an Exception "A public action method 'ufo' was not found on controller '...HomeController".

A simple solution to handle such scenario is by overriding HandleUnknownAction in a custom base controller of which all your controllers inherit.

The example below shows how a shared Error view (Shared\Error.cshtml) gets executed.

public abstract class BaseController : Controller
{
    protected override void HandleUnknownAction(string actionName)
    {
        View("Error").ExecuteResult(ControllerContext);
    }
}

Answer 2

The problem as you have stated seems like a routing problem.

Have you tried a catch all route?... That is a route that is executed when no other route matches the request's path. The catch all route is defined last and seems like:

// Specific routes here...

routes.MapRoute(
    "Default",
    "{controller}/{action}/{id}",
    new { controller = "Home", action = "Index", id = UrlParameter.Optional }
);

routes.MapRoute(
    "Catch-All",
    "{*controller}",
    new { controller = "Home", action = "Index" }
);

I tested with .NET Core MVC

// This is how it is configured in .NET Core MMVC
app.UseEndpoints(endpoints =>
{
   endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
   endpoints.MapControllerRoute(
            name: "catch-all",
            pattern: "{*controller}",
            defaults: new { controller="Home", action="Index" });
});

I think that managing the excepion, as sugested in previous answers, is a good practice, but does not solve the routing problem you are facing.

You might want to take a look to this discussion regarding similiar problem with ASP.NET MVC: ASP.NET MVC - Catch All Route And Default Route

Answer 3

Like @Amirhossein mentioned, since you are using .net 4.6 framework you can have a global exception catch inside the Global.asax file something like:

 protected void Application_Error(object sender, EventArgs e)
 { 
        var ex = Server.GetLastError();

        Debug.WriteLine(ex);

        var httpEx = ex as HttpException;
        var statusCode = httpEx?.GetHttpCode() ?? 500;

        Server.ClearError();
        ...
  }

or you can address this issue via IIS (since I presume you host your application on IIS) by adding a mapping rule (which in turn can be done in the web.config) or by adding a filter, or even a firewall rule (since by my account those kind of probing scans are not worth to be logged in your application - I believe they should be handled on another level)