Need

Secure handling of temporary files

Context

• Usage of C# for developing robust and scalable applications
• Usage of System.IO for input and output operations in .NET development

Description

Non compliant code

        public void CreateTempFile(string sensitiveData)
{
    string tempFile = Path.GetTempFileName();

    using (StreamWriter sw = new StreamWriter(tempFile))
    {
        sw.Write(sensitiveData);
    }
}
        
        

The above code represents a vulnerability related to insecure temporary files in a C# backend application using ASP.NET Core.

The CreateTempFile function creates a temporary file using the Path.GetTempFileName() function, which generates a unique temporary filename. This file is stored in the system's default temporary directory.

The function then writes sensitive data to this file using a StreamWriter. The StreamWriter is opened on the temporary file, and the sensitive data is written to it.

This code is vulnerable because it writes sensitive data to a temporary file without taking any measures to secure the file or the data. Temporary files are typically stored in a directory that is accessible to all users and processes on the system, meaning that any user or process could potentially read the sensitive data.

Furthermore, the data remains in the file even after the StreamWriter is closed, until the file is explicitly deleted. If the system crashes or the application is terminated unexpectedly, the file may not be deleted, leaving the sensitive data exposed.

Additionally, the Path.GetTempFileName() function could potentially return the same filename to different processes if called simultaneously, leading to a race condition where one process could overwrite the sensitive data written by another. This could result in data corruption or exposure.

Steps

• Avoid storing sensitive information in temporary files.
• If sensitive information needs to be stored temporarily, consider using in-memory storage or encrypted storage.
• Ensure that temporary files are not deployed to the production environment.
• Implement proper file handling and cleanup mechanisms to securely delete temporary files after use.
• Regularly review and update the code to address any new vulnerabilities or best practices related to temporary file handling.

Compliant code

        public void CreateTempFile(string sensitiveData)
{
    // Generate a random key for encryption
    var key = Aes.Create().Key;

    // Convert sensitive data to byte array
    byte[] sensitiveDataBytes = Encoding.UTF8.GetBytes(sensitiveData);

    // Encrypt sensitive data
    byte[] encryptedData = Encrypt(sensitiveDataBytes, key);

    // Store encrypted data in memory instead of a temp file
    var secureStorage = new SecureStorage();
    secureStorage.Store(encryptedData);
}

private byte[] Encrypt(byte[] data, byte[] key)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = key;
        aes.GenerateIV();

        using (ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
        {
            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                {
                    cs.Write(data, 0, data.Length);
                    cs.FlushFinalBlock();
                    return ms.ToArray();
                }
            }
        }
    }
}

public class SecureStorage
{
    private Dictionary storage = new Dictionary();

    public void Store(byte[] data)
    {
        string id = Guid.NewGuid().ToString();
        storage[id] = data;
    }

    // Other methods to retrieve and delete data...
}
        
        

The original code was storing sensitive data in a temporary file, which is a security vulnerability. The new code avoids this by encrypting the sensitive data and storing it in memory instead.

First, a random encryption key is generated using the Aes.Create().Key method. The sensitive data is then converted to a byte array and encrypted using the Encrypt method. This method uses the AES encryption algorithm, which is a secure symmetric encryption algorithm.

The encrypted data is then stored in memory using a SecureStorage class. This class uses a Dictionary to store the data, with a unique ID as the key. This ID can be used to retrieve and delete the data when it is no longer needed.

This approach ensures that sensitive data is not written to disk, reducing the risk of it being accessed by unauthorized users or processes. It also ensures that the data is securely deleted when it is no longer needed, as it is removed from memory when the application is closed or the data is explicitly deleted.

Note that this code does not handle the retrieval and deletion of the data from the SecureStorage class. These methods should be implemented as needed, ensuring that data is securely deleted once it has been used.

References

• 028. Insecure temporary files