Skip to main content

Insecure session management - CSRF Fixation

Need​

Secure session management and protection against CSRF Fixation

Context​

  • Usage of C# 7.1 for developing applications with advanced language features and improvements
  • Usage of Microsoft.AspNetCore.Mvc for building web applications using the ASP.NET Core MVC framework
  • Usage of Microsoft.AspNetCore.Authorization for implementing authorization and access control in ASP.NET Core applications
  • Usage of Microsoft.AspNetCore.Http for handling HTTP requests and responses in ASP.NET Core applications
  • Usage of System.Threading.Tasks for asynchronous programming in .NET

Description​

Non compliant code​

[HttpPost]
[Route("api/transaction")]
public async Task<IActionResult> ProcessTransaction([FromBody] TransactionRequest request)
{
    var authorizationHeader = Request.Headers["Authorization"];
    
    if (string.IsNullOrWhiteSpace(authorizationHeader))
    {
        return Unauthorized();
    }
    
    var transactionResult = await _transactionService.ProcessTransaction(request);
    
    if (transactionResult == null)
    {
        return BadRequest();
    }
    
    return Ok(transactionResult);
}

This code represents a simple API endpoint in an ASP.NET Core application that processes a transaction. The endpoint accepts a POST request at the route /api/transaction and expects a TransactionRequest object in the request body.

The vulnerability lies in the way the application handles the Authorization header. The Authorization header is used to authenticate the user and authorize the transaction. However, this header's value is a public key that remains the same for all payment links. This means that an attacker could potentially intercept this public key, create a malicious button with the content of a request, trick a user into clicking the button, and then complete the transaction on behalf of the user.

This is a classic example of a Cross-Site Request Forgery (CSRF) fixation attack, where an attacker tricks a victim into executing actions of the attacker's choosing while authenticated. The fact that the Authorization header is a static public key makes this attack possible because the attacker can predict the value of the Authorization header and use it to craft a malicious request.

Steps​

  • Implement a secure session management mechanism, such as using anti-CSRF tokens.
  • Generate a unique token for each user session and include it in the request.
  • Verify the token on the server-side to ensure it matches the user's session.
  • Ensure that the token is not predictable or guessable.
  • Use HTTPS to encrypt the communication between the client and the server to prevent eavesdropping and tampering.
  • Regularly review and update the session management mechanism to address any new vulnerabilities or best practices.

Compliant code​

[HttpPost]
[Route("api/transaction")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> ProcessTransaction([FromBody] TransactionRequest request, string csrfToken)
{
    var authorizationHeader = Request.Headers["Authorization"];
    
    if (string.IsNullOrWhiteSpace(authorizationHeader))
    {
        return Unauthorized();
    }

    // Get the CSRF token from the user's session
    var sessionCsrfToken = HttpContext.Session.GetString("CSRFToken");

    // Check if the CSRF token from the request matches the one in the user's session
    if (csrfToken != sessionCsrfToken)
    {
        return BadRequest("Invalid CSRF token.");
    }
    
    var transactionResult = await _transactionService.ProcessTransaction(request);
    
    if (transactionResult == null)
    {
        return BadRequest();
    }
    
    return Ok(transactionResult);
}

The updated code includes a CSRF token in the transaction request. This token is generated for each user session and stored in the session. When a transaction request is made, the CSRF token from the request is compared with the one stored in the user's session. If they do not match, the request is rejected with a "Bad Request" response.

This approach ensures that even if an attacker manages to trick a user into making a transaction request, they would not be able to guess or predict the CSRF token, and the request would be rejected.

In addition, the [ValidateAntiForgeryToken] attribute is added to the action method to automatically validate the CSRF token in the request. This attribute works in conjunction with the anti-forgery services configured in the Startup.cs file.

Finally, it is recommended to use HTTPS for all communication between the client and the server. This encrypts the data in transit and prevents eavesdropping and tampering.

Regularly review and update the session management mechanism to address any new vulnerabilities or best practices.

References​

Last updated on