Skip to main content

Traceability loss

Need​

Improved traceability and logging capabilities

Context​

  • Usage of Java for building cross-platform applications
  • 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 web applications

Description​

Non compliant code​

import javax.servlet.*;
import javax.servlet.http.*;

public class TraceabilityLossServlet extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        try {
            String param = request.getParameter("param");
            if (param.equals("invalid")) {
                throw new Exception("Invalid parameter");
            }
            // processing the request...
        } catch (Exception e) {
            // Exception is caught but not logged or tracked
        }
    }
}

The above code snippet is a simple servlet that gets a request parameter and processes it. If an invalid parameter is passed, an exception is thrown. However, the catch block is empty and does not log or track the exception in any way.

This is a clear example of traceability loss vulnerability. In this case, if an invalid parameter is passed and an exception is thrown, we lose all information about this event. This makes it difficult to detect and diagnose possible security issues.

This is particularly problematic in the context of security, because malicious users could be passing invalid parameters in an attempt to cause unexpected behaviour, exploit vulnerabilities, or even cause denial of service. Without proper logging and tracking of these events, it becomes much harder to detect these attempts, let alone trace back the source and take appropriate action.

To fix this vulnerability, we should log the exception using a logging framework like Log4j or SLF4J, and ideally also track these events in some way, for example by sending an alert, or storing the event information in a database for later analysis.

Steps​

  • Implement proper error handling and logging mechanisms
  • Ensure that all critical actions and exceptional events are properly tracked
  • Use a centralized logging system to store and analyze logs
  • Implement a monitoring system to detect and alert on security events
  • Regularly review and analyze logs to identify potential security issues

Compliant code​

import javax.servlet.*;
import javax.servlet.http.*;
import java.util.logging.*;

public class TraceabilityLossServlet extends HttpServlet {

    private static final Logger LOGGER = Logger.getLogger(TraceabilityLossServlet.class.getName());

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        try {
            String param = request.getParameter("param");
            if (param.equals("invalid")) {
                throw new Exception("Invalid parameter");
            }
            // processing the request...
        } catch (Exception e) {
            // Exception is caught and logged
            LOGGER.log(Level.SEVERE, "Exception caught", e);
        }
    }
}

The code above fixes the traceability loss vulnerability by implementing proper error handling and logging mechanisms.

In the updated code, we have imported the java.util.logging.* package which provides the logging capabilities in Java. We have created a Logger instance, LOGGER, which is used to log messages for specific system or application component.

In the doGet method, when an exception is caught, instead of being ignored, it is now logged using LOGGER.log(Level.SEVERE, "Exception caught", e);. This ensures that all critical actions and exceptional events are properly tracked.

This log can then be sent to a centralized logging system to store and analyze logs. A monitoring system can be implemented to detect and alert on security events based on these logs. Regularly reviewing and analyzing these logs can help identify potential security issues.

References​

Last updated on