Skip to main content

Excessive privileges - Temporary Files


Restriction of privileges and access modes for temporary files


  • Usage of Ruby for building dynamic and object-oriented applications
  • Usage of tempfile for creating temporary files and directories


Non compliant code

def create_temp_file
temp_file ='tempfile')
temp_file.write('some sensitive data')

In the above Ruby code, a temporary file is being created using the method. The write method is then used to write some sensitive data to this file. After the data has been written, the close method is used to close the file.

This code is vulnerable because it does not restrict the privileges or access modes of the temporary file. This means that any user or process that has access to the directory where the temporary file is stored can read, write, or delete the file.

For example, an attacker could potentially read the sensitive data, modify it, or delete the file altogether. This could lead to information disclosure, data corruption, or denial of service.

Furthermore, the method generates a unique filename in the form of "tempfile" followed by a random number, but it does not guarantee that the file is created securely. This could potentially lead to a race condition where an attacker could guess the filename and create a symlink with the same name, pointing to a sensitive file. When the application writes data to the temporary file, it would actually be writing to the sensitive file, leading to a privilege escalation attack.

Therefore, it is important to properly manage the privileges and access modes of temporary files to prevent such vulnerabilities.


  • Avoid creating temporary files with sensitive data.
  • If temporary files are necessary, ensure that they are properly restricted in terms of privileges and access modes.
  • Use a secure temporary file location that is only accessible by the application and not by other users or processes.
  • Encrypt sensitive data before writing it to the temporary file.
  • Implement proper file cleanup mechanisms to remove temporary files after they are no longer needed.
  • Regularly review and audit the usage of temporary files in the application to identify any potential vulnerabilities.

Compliant code

require 'securerandom'
require 'fileutils'

def create_temp_file
temp_file_path = File.join(Rails.root, 'tmp', 'secure_temp')
FileUtils.mkdir_p(temp_file_path) unless

temp_file ='tempfile', temp_file_path)
sensitive_data = 'some sensitive data'
encrypted_data = encrypt_data(sensitive_data)


def encrypt_data(data)
cipher =, :CBC)
cipher.key = SecureRandom.random_bytes(32)
encrypted = cipher.update(data) +

The updated code now creates temporary files in a secure directory within the Rails application root directory. This directory is only accessible by the application, reducing the risk of unauthorized access.

The sensitive data is encrypted before being written to the temporary file. This is done using the AES (Advanced Encryption Standard) encryption algorithm with a 256-bit key size in CBC (Cipher Block Chaining) mode. The key is randomly generated for each encryption operation using the SecureRandom module, further enhancing the security of the encryption.

The FileUtils.mkdir_p method is used to ensure that the secure temporary file directory exists. This method will create the directory if it does not exist, and do nothing if it already exists. This ensures that the application does not fail if the directory is not initially present.

Finally, the temporary file is closed after the encrypted data has been written to it. This is a good practice as it releases system resources that were used during the file operation. It also minimizes the time window in which the temporary file is open, reducing the risk of unauthorized access.