Skip to main content

Business information leak - Credit Cards


Protection of sensitive business information and customer credit card data


  • Usage of C# for developing robust and efficient software applications
  • Usage of _context for managing state and data in the application


Non compliant code

public IActionResult GetCreditCardInfo(int id)
var creditCard = _context.CreditCards.FirstOrDefault(c => c.Id == id);
if (creditCard == null)
return NotFound();

return Ok(creditCard);

The above code is a method in an ASP.NET Core controller that is used to retrieve credit card information for a given id. The id is passed as a parameter in the HTTP GET request.

The vulnerability exists because the method returns the entire CreditCard object, which includes sensitive information such as the credit card number, expiry date and CVV. This information is then visible in the response to the GET request, which can be intercepted and exploited by malicious users.

Additionally, the method does not check if the user making the request has the necessary permissions to view the requested credit card information. This means that any user, even those without proper authorization, can view the credit card information of any customer.

This can lead to a serious business information leak, compromising customer's credit card data and potentially leading to financial fraud.

To fix this vulnerability, the method should be modified to only return the necessary information and not the entire CreditCard object. Additionally, proper authorization checks should be implemented to ensure that only users with the necessary permissions can access the credit card information.


  • Implement proper authentication and authorization mechanisms to ensure that only authorized users can access the credit card information.
  • Encrypt sensitive data such as credit card numbers to protect them from unauthorized access.
  • Implement input validation to prevent malicious input that could lead to data leakage.
  • Ensure that the credit card information is only returned to authorized users and not included in the response by default.
  • Regularly review and update the access control policies to ensure that only necessary personnel have access to the credit card information.
  • Implement logging and monitoring mechanisms to detect and respond to any unauthorized access attempts or data leakage incidents.

Compliant code

public async Task<IActionResult> GetCreditCardInfo(int id)
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var creditCard = await _context.CreditCards.FirstOrDefaultAsync(c => c.Id == id && c.UserId == userId);

if (creditCard == null)
return NotFound();

var result = new CreditCardDTO
Id = creditCard.Id,
CardHolderName = creditCard.CardHolderName,
ExpiryDate = creditCard.ExpiryDate,
// Encrypt the card number before sending it
CardNumber = Encrypt(creditCard.CardNumber)

return Ok(result);

private string Encrypt(string cardNumber)
// Implement your encryption logic here
return encryptedCardNumber;

The updated code now includes the [Authorize] attribute on the GetCreditCardInfo method, which ensures that only authenticated users can access this method.

The method now also checks that the requested credit card belongs to the authenticated user by comparing the UserId of the credit card with the NameIdentifier claim of the authenticated user. This ensures that users can only access their own credit card information.

The credit card number is now encrypted before it is returned in the response. This is done in the Encrypt method, which should contain your encryption logic. This ensures that even if the response is intercepted, the credit card number cannot be read.

The credit card information is now returned as a CreditCardDTO object, which does not include any sensitive information by default. This ensures that no additional sensitive information is accidentally included in the response.

Remember to implement a strong encryption algorithm in the Encrypt method and to store the encryption key securely. Also, ensure that your application uses HTTPS to protect the data in transit.