Skip to main content

Business information leak - Credentials

Need​

Protection of business credentials and sensitive information from unauthorized access

Context​

  • Usage of C# for developing robust and scalable applications
  • Usage of System for managing and interacting with the operating system
  • Usage of System.IO for input/output operations in .NET development
  • Usage of Microsoft.AspNetCore.Mvc for building web applications using the MVC pattern

Description​

Non compliant code​

using System;
using System.IO;
using Microsoft.AspNetCore.Mvc;

namespace VulnerableApp.Controllers
{
    public class AccountController : Controller
    {
        [HttpPost]
        public IActionResult Login(string username, string password)
        {
            // Check if the username and password are correct
            if (username == "admin" && password == "password123")
            {
                // If the credentials are correct, log the user in
                return View("Dashboard");
            }
            else
            {
                // If the credentials are incorrect, show an error
                return View("Error");
            }
        }
    }
}

The above code represents a classic example of hard-coded credentials vulnerability, which is a common security issue. The Login method in the AccountController class accepts a username and password as parameters and checks if they match the hard-coded values "admin" and "password123" respectively. If the credentials match, the user is redirected to the dashboard; otherwise, an error view is displayed.

This is a major security flaw as it exposes the system to unauthorized access. If an attacker gets hold of these hard-coded credentials, they can gain full access to the system, leading to a potential data breach. This can lead to leakage of sensitive business information, including customer and employee data, financial records, intellectual property, etc.

Moreover, hard-coded credentials in source code can easily be discovered by attackers through code analysis or reverse engineering. This is especially true if the source code is publicly available or if the attacker has gained access to the application's binary files.

In addition, this approach does not allow for password changes without a code change and redeployment of the application, which is not a practical or secure approach to credential management.

Steps​

  • Avoid hardcoding sensitive information, such as usernames and passwords, directly in the code.
  • Implement a secure authentication mechanism, such as using ASP.NET Core Identity or a third-party authentication provider.
  • Store user credentials securely, such as using salted and hashed passwords.
  • Use strong and complex passwords for user accounts.
  • Implement account lockout mechanisms to prevent brute-force attacks.
  • Implement secure communication protocols, such as HTTPS, to protect the transmission of sensitive information.
  • Regularly update and patch the application and its dependencies to address any security vulnerabilities.
  • Conduct regular security assessments and penetration testing to identify and address any potential vulnerabilities.
  • Educate developers and users about secure coding practices and the importance of protecting sensitive information.

Compliant code​

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Identity;
using VulnerableApp.Models;

namespace VulnerableApp.Controllers
{
    public class AccountController : Controller
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly SignInManager<ApplicationUser> _signInManager;

        public AccountController(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager)
        {
            _userManager = userManager;
            _signInManager = signInManager;
        }

        [HttpPost]
        public async Task<IActionResult> Login(string username, string password)
        {
            var result = await _signInManager.PasswordSignInAsync(username, password, false, lockoutOnFailure: true);

            if (result.Succeeded)
            {
                return View("Dashboard");
            }
            else
            {
                if (result.IsLockedOut)
                {
                    return View("Lockout");
                }
                else
                {
                    return View("Error");
                }
            }
        }
    }
}

The updated code now uses ASP.NET Core Identity for user management and authentication. This provides a secure and scalable way to manage users, and includes built-in features for password hashing, password complexity requirements, and account lockout after failed login attempts.

The UserManager&lt;ApplicationUser> and SignInManager&lt;ApplicationUser> services are injected into the controller through the constructor. These services provide methods for user management and authentication.

The Login method now uses the PasswordSignInAsync method from the SignInManager service to authenticate the user. This method checks the provided username and password against the stored user credentials. If the credentials are correct, the method returns a success result and the user is redirected to the Dashboard view. If the credentials are incorrect, the method returns a failure result and the user is redirected to the Error view.

If the user has made too many failed login attempts, the PasswordSignInAsync method will lock out the user account and return a lockout result. In this case, the user is redirected to the Lockout view.

This approach avoids hardcoding sensitive information in the code, uses a secure authentication mechanism, stores user credentials securely, implements account lockout to prevent brute-force attacks, and uses secure communication protocols to protect the transmission of sensitive information.

References​

Last updated on