Skip to main content

Insecure encryption algorithm - Perfect Forward Secrecy

Need​

Implementation of secure encryption algorithms with Perfect Forward Secrecy

Context​

  • Usage of C# 7.0 for modern and efficient programming in the .NET framework
  • Usage of Microsoft.AspNetCore.Mvc for building web applications with ASP.NET Core
  • Usage of Microsoft.AspNetCore.DataProtection for data protection and encryption in ASP.NET Core applications
  • Usage of Microsoft.AspNetCore.DataProtection.FileSystem for file-based data protection in ASP.NET Core
  • Usage of Microsoft.AspNetCore.DataProtection.Extensions for data protection and encryption in ASP.NET Core
  • Usage of Microsoft.AspNetCore.DataProtection.Abstractions for data protection and encryption in ASP.NET Core applications

Description​

Non compliant code​

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
    services.AddDataProtection()
        .PersistKeysToFileSystem(new DirectoryInfo(@"c:\\temp-keys\\"))
        .SetApplicationName("CustomEncryption")
        .UseCryptographicAlgorithms(new AuthenticatedEncryptorConfiguration()
        {
            EncryptionAlgorithm = EncryptionAlgorithm.AES_256_CBC,
            ValidationAlgorithm = ValidationAlgorithm.HMACSHA256
        });
}

The above code is configuring the data protection system in an ASP.NET Core application. This system is used for encryption and decryption of data in the application.

In this example, the application is using the AES-256-CBC encryption algorithm and the HMACSHA256 validation algorithm. These algorithms are set in the AuthenticatedEncryptorConfiguration class.

The AES-256-CBC is a symmetric encryption algorithm. It uses the same key for both encryption and decryption. This means that if an attacker can get hold of the encryption key, they can decrypt all the data that was encrypted with that key.

The HMACSHA256 is a hash function used for data integrity check. It produces a unique hash value for a given input data. If the data is tampered with, the hash value will change, thus indicating data tampering.

The main vulnerability in this code is the lack of Perfect Forward Secrecy (PFS). PFS is a property of secure communication protocols in which compromise of long-term keys does not compromise past session keys. So, even if the private key is compromised, it won't affect the security of the past communication.

In this code, if an attacker gets hold of the private key, they can decrypt all past and future communication because the same key is used for all the communication. This is a serious security risk as it can lead to exposure of sensitive data.

The application should use a secure communication protocol that supports PFS, such as Diffie-Hellman key exchange or Elliptic Curve Diffie-Hellman. These protocols generate a unique session key for each communication session, thus ensuring that even if the private key is compromised, the past communication remains secure.

Steps​

  • Replace the insecure encryption algorithm with a secure one that supports Perfect Forward Secrecy (PFS).
  • Use a key exchange algorithm that supports PFS, such as Diffie-Hellman (DH) or Elliptic Curve Diffie-Hellman (ECDH).
  • Implement a secure key management system to protect the private keys used for encryption.
  • Regularly rotate the private keys to minimize the impact of key compromise.
  • Ensure that the encryption algorithms and key exchange algorithms used are up-to-date and considered secure by industry standards.
  • Consider using a secure key storage mechanism, such as a Hardware Security Module (HSM), to protect the private keys.
  • Implement strong authentication and access controls to restrict access to the private keys.
  • Regularly monitor and audit the usage of the private keys to detect any unauthorized access or suspicious activities.

Compliant code​

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
    services.AddDataProtection()
        .PersistKeysToFileSystem(new DirectoryInfo(@"c:\\temp-keys\\"))
        .SetApplicationName("CustomEncryption")
        .UseCryptographicAlgorithms(new AuthenticatedEncryptorConfiguration()
        {
            EncryptionAlgorithm = EncryptionAlgorithm.AES_256_GCM,
            ValidationAlgorithm = ValidationAlgorithm.HMACSHA256
        })
        .SetDefaultKeyLifetime(TimeSpan.FromDays(90)); // Rotate keys every 90 days
}

The updated code now uses the AES_256_GCM encryption algorithm, which is currently considered secure by industry standards. This algorithm supports Perfect Forward Secrecy (PFS), which means that even if a private key is compromised, previous communication sessions remain secure.

The SetDefaultKeyLifetime method is used to rotate the private keys every 90 days. This minimizes the impact of a key compromise, as any compromised key will only be valid for a maximum of 90 days.

The private keys are stored in a file system directory specified by the PersistKeysToFileSystem method. This directory should be secured with strong access controls to prevent unauthorized access. Consider using a secure key storage mechanism, such as a Hardware Security Module (HSM), for additional security.

The SetApplicationName method is used to set a unique name for the application's data protection services. This helps to isolate the keys used by this application from those used by other applications.

The UseCryptographicAlgorithms method is used to specify the encryption and validation algorithms used by the data protection services. The validation algorithm is HMACSHA256, which is also currently considered secure by industry standards.

Remember to regularly monitor and audit the usage of the private keys to detect any unauthorized access or suspicious activities. Implement strong authentication and access controls to further restrict access to the private keys.

References​

Last updated on