Skip to main content

Restricted fields manipulation

Need​

Prevention of unauthorized access and manipulation of restricted fields in employee registration

Context​

  • Usage of Java for building cross-platform applications
  • Usage of javax.servlet for building Java web applications with servlets
  • Usage of java.io.IOException for handling input/output errors in Java

Description​

Non compliant code​

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

public class EmployeeRegistrationServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String employeeDNI = req.getParameter("employeeDNI");
        String name = req.getParameter("name");
        String email = req.getParameter("email");
        String dob = req.getParameter("dob");
        String address = req.getParameter("address");
        String phoneNumber = req.getParameter("phoneNumber");

        Employee employee = EmployeeDatabase.getEmployeeByDNI(employeeDNI);
        if(employee != null) {
            employee.setName(name);
            employee.setEmail(email);
            employee.setDob(dob);
            employee.setAddress(address);
            employee.setPhoneNumber(phoneNumber);

            EmployeeDatabase.updateEmployee(employee);
        }
    }
}

The above code represents a Servlet that handles the POST request for updating an employee's information. It first retrieves the parameters from the request, which include the employee's DNI (National Identification Number), name, email, date of birth, address, and phone number.

It then retrieves the employee with the corresponding DNI from the database. If such an employee exists, it updates the employee's information with the new values from the request parameters and then updates the employee's record in the database.

The vulnerability here is that the servlet does not check if the authenticated user has the necessary permissions to update the employee's information. As a result, an attacker could potentially send a POST request with a different employee's DNI and other information, effectively overwriting the existing information for that employee.

This could lead to unauthorized modifications and potential data breaches, as sensitive information like names, email addresses, dates of birth, addresses, and phone numbers could be altered or accessed by malicious actors.

Steps​

  • Implement proper authentication and authorization mechanisms to ensure that only authorized users can access and modify employee information.
  • Validate the input parameters to ensure that they are within the expected range and format.
  • Implement access control checks to ensure that an employee can only modify their own information.
  • Use parameterized queries or prepared statements to prevent SQL injection attacks.
  • Implement proper error handling and logging to detect and respond to any unauthorized access attempts or suspicious activities.
  • Regularly update and patch the software to fix any known vulnerabilities.
  • Conduct security testing and code reviews to identify and address any potential security issues.
  • Educate developers and users about secure coding practices and the importance of protecting sensitive information.

Compliant code​

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

public class EmployeeRegistrationServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        Employee loggedInEmployee = (Employee) session.getAttribute("loggedInEmployee");

        String employeeDNI = req.getParameter("employeeDNI");
        String name = req.getParameter("name");
        String email = req.getParameter("email");
        String dob = req.getParameter("dob");
        String address = req.getParameter("address");
        String phoneNumber = req.getParameter("phoneNumber");

        // Check if the logged in employee is trying to modify their own data
        if(loggedInEmployee != null && loggedInEmployee.getDNI().equals(employeeDNI)) {
            Employee employee = EmployeeDatabase.getEmployeeByDNI(employeeDNI);
            if(employee != null) {
                employee.setName(name);
                employee.setEmail(email);
                employee.setDob(dob);
                employee.setAddress(address);
                employee.setPhoneNumber(phoneNumber);

                EmployeeDatabase.updateEmployee(employee);
            }
        } else {
            throw new ServletException("Unauthorized access attempt detected.");
        }
    }
}

The updated code now includes an authentication and authorization mechanism to ensure that only the logged-in employee can modify their own information. This is done by retrieving the loggedInEmployee object from the session and comparing its DNI with the DNI of the employee whose data is being modified.

If the DNIs match, the code proceeds to update the employee's information. If they don't match, a ServletException is thrown, indicating an unauthorized access attempt. This exception can be caught and logged to help detect and respond to any suspicious activities.

In addition, the code should be regularly updated and patched to fix any known vulnerabilities. Security testing and code reviews should be conducted to identify and address any potential security issues. Developers and users should be educated about secure coding practices and the importance of protecting sensitive information.

Please note that this code assumes that the Employee class and EmployeeDatabase class have the appropriate methods for getting and setting the employee's information and for updating the employee's information in the database. Also, it assumes that the session management is properly implemented and the loggedInEmployee object is correctly set in the session after the employee logs in.

References​

Last updated on