Skip to main content

Insecure temporary files

Need​

Secure handling of temporary files

Context​

  • Usage of Java for building cross-platform applications
  • Usage of java.io.* for input/output operations in Java
  • Usage of javax.servlet for building Java web applications with Servlet technology
  • Usage of javax.servlet.http.* for handling HTTP requests and responses in Java Servlets

Description​

Non compliant code​

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class VulnerableServlet extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        // Create a temporary file to store sensitive data
        File temp = File.createTempFile("tempfile", ".tmp");
        BufferedWriter bw = new BufferedWriter(new FileWriter(temp));

        // Write sensitive data to the file
        String sensitiveData = "This is some sensitive data";
        bw.write(sensitiveData);
        bw.close();

        // Send the temporary file to the client
        ServletOutputStream sos = response.getOutputStream();
        FileInputStream fis = new FileInputStream(temp);
        byte[] buffer = new byte[4096];
        int bytesRead;
        while ((bytesRead = fis.read(buffer)) != -1) {
            sos.write(buffer, 0, bytesRead);
        }
        fis.close();

        // Delete the temporary file
        temp.delete();
    }
}

The above code represents a servlet in a Java backend application that uses the javax.servlet package. The servlet creates a temporary file and writes some sensitive data to it. The temporary file is then sent to the client.

The vulnerability here is that the sensitive data is stored in a temporary file. Temporary files are generally insecure because they can be accessed by other processes or users on the same system. If an attacker can access the temporary file before it is deleted, they can read the sensitive data.

Furthermore, the temporary file is sent to the client. If the client is malicious, they can save the file and have permanent access to the sensitive data. Even if the file is deleted from the server side, the client still has a copy.

Finally, while the code does attempt to delete the temporary file, there is no guarantee that the deletion will be successful. If the deletion fails, the temporary file with the sensitive data will remain on the system, where it can be accessed by an attacker.

Steps​

  • Avoid storing sensitive information in temporary files
  • If sensitive information needs to be stored temporarily, consider using secure methods such as encryption or hashing
  • Avoid deploying sensitive temporary files to the production environment
  • Ensure proper file handling practices, such as securely deleting temporary files after use
  • Consider using in-memory storage or secure databases instead of temporary files for sensitive data

Compliant code​

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class SecureServlet extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        // Generate a secret key for encryption
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(128);
        SecretKey secretKey = keyGen.generateKey();

        // Create a cipher instance and initialize it with the secret key
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);

        // Encrypt the sensitive data
        String sensitiveData = "This is some sensitive data";
        byte[] encryptedData = cipher.doFinal(sensitiveData.getBytes());

        // Send the encrypted data to the client
        ServletOutputStream sos = response.getOutputStream();
        sos.write(encryptedData);
    }
}

The updated code avoids the use of temporary files for storing sensitive data. Instead, it uses encryption to securely handle the sensitive data.

The sensitive data is encrypted using the Advanced Encryption Standard (AES) algorithm. A secret key is generated for the encryption process. The KeyGenerator class is used to generate a secret key for AES encryption. The key size is set to 128 bits, which is a secure size for AES.

The Cipher class is used to perform the encryption. It is initialized with the secret key and set to encryption mode. The sensitive data is then encrypted using the doFinal method of the Cipher class.

The encrypted data is sent to the client through the ServletOutputStream. This ensures that the sensitive data is securely handled and not stored in a temporary file.

This approach ensures that sensitive data is not exposed in temporary files, reducing the risk of data leakage. It also avoids deploying sensitive temporary files to the production environment.

References​

Last updated on