Skip to main content

Security controls bypass or absence - Tampering Protection

Need​

Ensuring the integrity and authenticity of the application to prevent tampering and bypassing security controls.

Context​

  • Usage of Ruby for building dynamic and object-oriented applications
  • Usage of ActionController for handling actions and routing in a Ruby on Rails application

Description​

Non compliant code​

class ApplicationController < ActionController::Base
  def check_root
    if current_user.root?
      redirect_to root_path
    end
  end
end

In the above code, there is a method check_root in the ApplicationController that checks if the current user is a root user. If the user is a root user, it redirects them to the root path.

However, this code is vulnerable because there is no mechanism in place to ensure that the application has not been modified and recompiled by a third party. This means that an attacker could potentially modify this method to always return false, allowing them to bypass the root user check and gain unauthorized access to parts of the application that should be restricted to root users only.

Moreover, the absence of tampering protection means it's also possible for an attacker to modify other parts of the application to evade other security controls and validations, potentially compromising the security of the entire application.

Steps​

  • Implement code integrity checks to ensure that the application has not been modified or tampered with.
  • Use cryptographic techniques such as digital signatures or checksums to verify the integrity of the application code.
  • Implement strong authentication mechanisms to prevent unauthorized access to the application.
  • Enforce secure coding practices to minimize the risk of code tampering.
  • Regularly update and patch the application and its dependencies to address any known vulnerabilities.
  • Implement runtime application self-protection (RASP) mechanisms to detect and prevent tampering at runtime.
  • Monitor and log any suspicious activities or attempts to tamper with the application code.
  • Conduct regular security assessments and penetration testing to identify and address any vulnerabilities in the application.
  • Educate developers and maintainers about secure coding practices and the importance of code integrity.

Compliant code​

require 'digest'

class ApplicationController < ActionController::Base
  before_action :check_integrity
  before_action :check_root

  def check_integrity
    file_path = File.expand_path(__FILE__)
    original_checksum = 'original_file_checksum' # Replace with actual checksum
    current_checksum = Digest::SHA256.file(file_path).hexdigest

    if original_checksum != current_checksum
      raise 'Application code has been tampered with!'
    end
  end

  def check_root
    if current_user.root?
      redirect_to root_path
    end
  end
end

The updated code includes a before_action callback check_integrity that runs before every action in the ApplicationController. This callback checks the integrity of the application code by comparing the SHA-256 checksum of the current file with a precomputed checksum. If the checksums do not match, it raises an exception, indicating that the application code has been tampered with.

This approach uses cryptographic techniques to verify the integrity of the application code, which helps prevent unauthorized modifications. However, it is important to note that this is just one layer of defense and should be used in conjunction with other security measures, such as strong authentication mechanisms, secure coding practices, regular updates and patches, runtime application self-protection (RASP) mechanisms, monitoring and logging of suspicious activities, regular security assessments and penetration testing, and developer education about secure coding practices and the importance of code integrity.

References​

Last updated on