Skip to main content

Sensitive information sent insecurely

Need​

Secure transmission of sensitive information

Context​

  • Usage of C# 7.0 for modern and efficient software development
  • Usage of Microsoft.AspNetCore.Mvc for building web applications with ASP.NET Core

Description​

Non compliant code​

public class UserController : Controller
{
    [HttpPost]
    public IActionResult Login(string username, string password)
    {
        // Authenticate user
        var user = AuthenticateUser(username, password);
        
        if (user == null)
        {
            return Unauthorized();
        }
        
        // Sending sensitive user information insecurely
        return Ok(new { Username = user.Username, Password = user.Password });
    }

    private User AuthenticateUser(string username, string password)
    {
        // Logic to authenticate user
    }
}

In the above code, the ASP.NET Core backend application is sending sensitive user information (username and password) insecurely over the network. This happens in the Login method of the UserController class.

After the user is authenticated, the Login method responds with an HTTP 200 OK status and includes the username and password in the response body. This is a major security vulnerability as the sensitive user information is exposed and can be intercepted by malicious attackers.

The sensitive user information should never be sent over the network, even if the user is authenticated. If an attacker intercepts this information, they could potentially gain unauthorized access to the user's account or other sensitive resources.

The risk of this vulnerability can be mitigated by never sending sensitive information like passwords over the network, and by using secure communication channels, such as HTTPS, to encrypt all data transmitted between the client and server.

Steps​

  • Use HTTPS to encrypt the communication channel
  • Avoid sending sensitive information in the response body
  • Implement secure authentication mechanisms
  • Store passwords securely using hashing and salting techniques

Compliant code​

public class UserController : Controller
{
    [HttpPost]
    public IActionResult Login(string username, string password)
    {
        // Authenticate user
        var user = AuthenticateUser(username, password);
        
        if (user == null)
        {
            return Unauthorized();
        }
        
        // Do not send sensitive user information
        return Ok(new { Username = user.Username });
    }

    private User AuthenticateUser(string username, string password)
    {
        // Logic to authenticate user
        // Hash and salt the password before comparing with the stored password
    }
}

The updated code no longer sends sensitive user information (i.e., the password) in the response body. This is a critical change because sending such information can expose it to unauthorized parties, especially if the communication channel is not secure.

In the Login method, after the user is authenticated, only the username is included in the response. The password is excluded to protect its confidentiality.

In the AuthenticateUser method, the password should be hashed and salted before it is compared with the stored password. This is a secure way to store and compare passwords. Hashing transforms the password into a fixed-length string of characters, which is difficult to reverse-engineer. Salting adds an extra layer of security by appending or prepending a random string to the password before hashing it. This makes it harder for attackers to use precomputed tables (i.e., rainbow tables) to crack the password.

Finally, ensure that the communication channel is secure by using HTTPS, which encrypts the data in transit and protects it from eavesdropping or tampering. This is not shown in the code but should be configured in the server settings.

References​

Last updated on