Skip to main content

Insecure generation of random numbers

Need​

Secure generation of random numbers

Context​

  • Usage of Java 8 for developing applications with enhanced features and performance
  • Usage of java.util.Random for generating random numbers in Java
  • Usage of javax.servlet.http.HttpServlet for handling HTTP requests in Java Servlets
  • Usage of javax.servlet.http.HttpServletRequest for handling HTTP requests in Java servlets
  • Usage of HttpServletResponse for handling HTTP responses in Java Servlets

Description​

Non compliant code​

import java.util.Random;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class InsecureRandomServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        Random random = new Random();
        int randomNumber = random.nextInt(100);
        // Use the insecure random number in some way
    }
}

The above code is a simple servlet that generates a random number between 0 and 100. The vulnerability lies in the use of java.util.Random to generate the random number. This is a pseudo-random number generator that is not suitable for generating numbers where predictability is a concern.

The Random class in Java uses a Linear Congruential Generator (LCG) for generating random numbers, which is not cryptographically secure. The sequence of numbers it generates can be predicted if an attacker can observe enough outputs.

In other words, an attacker who can guess the next output of the random number generator can predict all future outputs. In this case, if an attacker can guess the next random number, they could potentially manipulate the application's behavior in a way that benefits them.

This is a major security risk if the random number is used in security-critical contexts, such as generating session IDs, tokens, or cryptographic keys. It's also a problem if the random number is used in any context where its predictability could be exploited by an attacker, such as in a lottery system or a game.

Steps​

  • Replace the usage of insecure random number generation functions with secure random number generation functions.
  • Use a cryptographically secure random number generator that provides sufficient entropy.
  • Ensure that the random number generator is properly seeded with a high-quality source of randomness.
  • Consider using a library or framework that provides secure random number generation functionality.
  • Regularly update and patch the random number generation library or framework to ensure any vulnerabilities are addressed.
  • Perform thorough testing and validation to ensure the secure random number generation implementation is functioning correctly.

Compliant code​

import java.security.SecureRandom;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class SecureRandomServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        SecureRandom secureRandom = new SecureRandom();
        int secureRandomNumber = secureRandom.nextInt(100);
        // Use the secure random number in some way
    }
}

The original code was using java.util.Random to generate random numbers. This class is not suitable for security-sensitive applications, as it is predictable and can be easily guessed by an attacker.

The revised code uses java.security.SecureRandom instead. This class provides a cryptographically strong random number generator (RNG). Unlike java.util.Random, SecureRandom generates random numbers in a way that is safe for cryptographic use. This means that the numbers are highly unpredictable and cannot be feasibly guessed.

The SecureRandom class is properly seeded with a high-quality source of randomness, which is typically provided by the operating system. This ensures that even if an attacker can predict the sequence of random numbers, they cannot predict the initial seed value, making the sequence of random numbers secure.

It's important to keep the Java runtime environment (JRE) up to date to ensure that any vulnerabilities in the SecureRandom class are addressed. Additionally, thorough testing and validation should be performed to ensure the secure random number generation implementation is functioning correctly.

References​

Last updated on