Quick Overview:
With the immense popularity of .NET Core, more and more organizations are developing and migrating their business applications. Regardless of its scalable architecture and robustness, it offers a highly secure environment to assure data confidentiality, integrity, and availability. In addition, several inbuilt modules, functions, and components are present in the .NET package manager, which precisely aids in allowing data transactions between only authorized users.

UseHttpsRedirection is one component of the .NET framework responsible for ensuring data flow seamlessly and securely. To learn more about the security element, keep reading further and know its basics, along with the configuration procedure.

HTTPS Redirection and .Net Core

When developing an ASP.NET application, developers enable the HTTPS protocol by default for security purposes and to successfully prevent man-in-the-middle attacks, cookie spoofing, stealing, and eavesdropping.

In addition, it is a redirection middleware to ensure that all the data is communicated over a secure network. In simple terms, it enforces the data to redirect from HTTP to HTTPS by using the cryptographic mechanism to maintain data integrity.

When you implement this middleware, it creates a 307 temporary redirect response and links it with the configured HTTPS port to define the path to the endpoint. Additionally, there may be cases where the HTTPS port is not specified, and we evaluate the probability of a privacy breach. To solve this drawback, we upgraded .NET and extended its features to access the port details from an environment variable called “HTTPS_PORT.”

In the ASP.NET application, if both conditions are not specified, the UseHttpsRedirection middleware will display a warning to the user and will not forward any data. Therefore, it is necessary to implement this component in every .NET Core software for a smooth, seamless, and secure experience.

Why is UseHttpsRedirection Necessary?

Let’s examine how enabling this element in the ASP.NET business solution benefits the user.

  • The client and server systems create an encrypted transmission channel to maintain data integrity.
  • Both the client and server systems send acknowledgments before establishing a connection, allowing only authorized users to access the resources.
  • The system prevents potential cyber-attacks, such as eavesdropping and spoofing.
  • The application and organization enhance the user’s trust by transmitting all data securely.
  • The system warns the user to send data over the insecure network if the HTTPS protocol is not enabled.

The Procedure to Enable/Configure HTTPS in ASP.NET Web App

It is essential to know how to configure HTTPS in ASP.NET applications, as providing a secure ecosystem to access resources and perform operations is a top priority of any business solution. You can follow the below-listed process to implement the HTTPS protocol successfully.

The primary element utilized for securing the application in the architecture of ASP.NET is the incorporated class known as UseHttpsRedirection. It redirects a response to the client if the application forwards a request through an insecure or HTTP-configured network.

Additionally, the developer can enable this attribute on both a per-controller and per-action basis, according to the business requirements and the defined project scope. However, enabling it across the entire web application is preferable, which will then force every individual data chunk to pass through the HTTPS channel.

The ASP.NET developer must define the below line code under the RegisterGlobalFilters method placed inside the FilterConfig class.

filters.Add(new RequireHttpsAttribute());

The application starts and calls the RegisterGlobalFilters method, which executes the primary method. By applying this filter function, the application enforces only HTTP requests passed to controllers while still allowing the user to access static files over an insecure communication channel.

How to Fix The Issue in RegisterGlobalFilters?

To overcome the issue in RegisterGlobalFilters, you can use relative links to reference resources from the HTML. Furthermore, absolute URLs can also be used along with HTTPS protocol to assure the security of the overall ASP.NET solution.

Moreover, you can modify the rewrite code and configure data redirection at the reverse proxy level during the implementation of IIS. The implementation will automatically alter the direction of incoming requests to the HTTPS-enabled network. You need to save the Web.config file with the provided code below.

After I compile and add this code to IIS, the ASP.NET application will evaluate and handle every bit of incoming traffic precisely by moving it onto the secure channel.

Securing the .NET Core

Creating a secure environment for transmitting data in a .NET Core app is not a complex task, as it offers an in-built class called RequireHttpsAttribute for preventing cyber threats.

With the aid of this class, you can configure security mechanisms over a single controller, action, or general application. You have to define it under the ConfigureServices method inside the Startup class.

/// <summary>
/// This method gets called by the runtime.
/// Use this method to add services to the container.
/// </summary>
/// <param name="services">The collection of container services</param>
public void ConfigureServices(IServiceCollection services)
    services.AddControllersWithViews(options => 
        options.Filters.Add(new RequireHttpsAttribute()));

Additionally, you can configure an incorporated middleware, HTTPS Redirection, by adding a single line of code in the Configure method of the Startup class.

app.UseHttpsRedirection(); is a single line code you must write under the Configure method to secure .NET Core solutions.

Moreover, you don’t always have to configure this middleware, as most ASP.NET web app templates, such as MVC, come with it by default enabled with it.

Here, the question arises: What makes HTTPS Redirection middleware a preferred choice rather than RequireHttpsAttribute?

The way .NET Core solutions are hosted overall credits for this middleware’s improved and optimized functioning. It provides a higher level of security and redirects requests for static files from HTTP to HTTPS protocol-enabled channels.

Tightening the Security with HSTS

Till now, we have secured an ASP.NET application, but what if someone finds a vulnerable loophole and breaches your data?

To prevent malicious activities over your business solutions, .NET Core offers HSTS, a modular middleware component, which you can implement in a line of code.

HSTS is an acronym for HTTP Strict Transport Security, which experts consider a more secure mechanism than HTTPS.

When an application configures only the RequireHttpsAttribute, the app directly receives client requests and then redirects them to the secure channel that connects to the server. HSTS leads to patching this vulnerability, as it informs the browser to allow app access only over HTTPS-enabled communication channels.

Functioning of HSTS

The response message returns the Strict Transport Security header, which includes the core functioning of HSTS. Furthermore, the browser processes this instruction and ensures that it transmits all upcoming user requests through an HTTPS-configured connection.

As a result, no more redirects are executed, and all the data is security channeled.

In addition, you can also configure HSTS at a reverse proxy level by defining the Outbound Rules. The only condition you must fulfill is running your application on an IIS server.

        <rule name="Add Strict-Transport-Security when HTTPS" enabled="true">
            <match serverVariable="RESPONSE_Strict_Transport_Security" pattern=".*" />
                <add input="{HTTPS}" pattern="on" ignoreCase="true" />
            <action type="Rewrite" value="max-age=31536000" />

You have to write your outbound rules on the Web. config file and your application will be all set with HTTPS for secure data flow.

Implementing Secure Channel for APIs

APIs are an essential component of every application, as they are responsible for maintaining and connecting frontend elements with the backend to provide seamless user experiences.

Here, the question arises: If we have configured RequireHttpsAttribute and HSTS for overall security, what is the requirement to protect APIs? Let’s get onto this straight.

APIs are part of the ASP.NET app, but their architecture and work are pretty different, which disables them from interacting with incorporated security attributes. And for this reason, we have to create and embed our custom classes and methods for preventing cyber-attacks.

You can also refer to the official documentation provided on the Microsoft Website for this purpose. However, you can also refer to the below-provided code snippet to implement HTTPS for APIs.

/// <summary>
/// Called when a process requests authorization.
/// </summary>
/// <param name="actionContext">The action context</param>
public override void OnAuthorization(HttpActionContext actionContext)
    HttpRequestMessage request = actionContext.Request;
    if (request.RequestUri.Scheme != Uri.UriSchemeHttps)
        if (request.Method.Equals(HttpMethod.Get))
            actionContext.Response = request.CreateResponse(HttpStatusCode.Found, "SSL is required");
            // Provide the correct URL to the user via the Location header.
            var uriBuilder = new UriBuilder(request.RequestUri)
                Scheme = Uri.UriSchemeHttps,
                Port   = 443
            actionContext.Response.Headers.Location = uriBuilder.Uri;
        else actionContext.Response = request.CreateResponse(HttpStatusCode.NotFound, "SSL is required");

You can easily understand this code by going through the below points:

  • The class RequireHttpsAttribute derives from…
  • We override the method OnAuthorization.
  • We inform the client system about the correct URL whenever a GET request is received, as we return it in the Location header.
  • For any other user request except GET, we display a message to the client containing the text “SSL is required.”
  • Also, if any client tries to get access through HTTP, it will show a Bad request instead of redirecting the user.

Mainly designed for .NET Core applications, you can create similar code for your ASP.NET solutions by deriving the ApiRequireHttpsAttribute class from the RequireHttpsAttribute class.

Let’s Design the Perfect ASP.NET Application for Your Enterprise Business

Bring your unique software & web application vision to a team of ASP.NET experts for Enterprise business. Our dedicated .NET developers design and build custom .NET app solutions for your needs.


When hiring .NET Core developers, look for those experienced with ASP.NET and its built-in security mechanisms like UseHttpsRedirection to securely enable HTTPS protocol to share data between server and client systems. ASP.NET comprises such features, but a .NET Core developer must change the filter code in the pre-defined classes in the .NET Core architecture to allow Redirection. Knowledgeable .NET Core developers will understand how to properly implement and configure security features like UseHttpsRedirection in ASP.NET applications.

The UseHttpsRedirection middleware is an essential component of any ASP.NET application, and developers can configure it by modifying the filter function and adjusting the rewrite code block in the IIS. Therefore, ASP.NET developers should always focus on this part while developing the solution and test it before the final deployment to ensure data integrity for each user

Parag Mehta

Verified Expert in Software & Web App Engineering

Parag Mehta, the CEO and Founder of Positiwise Software Pvt Ltd has extensive knowledge of the development niche. He is implementing custom strategies to craft highly-appealing and robust applications for its clients and supporting employees to grow and ace the tasks. He is a consistent learner and always provides the best-in-quality solutions, accelerating productivity.

Related Posts