We are thrilled to announce 📢 Kosli is now SOC 2 Type 2 compliant - Read more
New Feature: Kosli Trails is liveCreate comprehensive audit trails for any DevOps activity - Read more
broken access control

What Is Broken-Access Control? Examples and Prevention

Vincent Chosen
Published May 2, 2023 in technology
clock icon 8 min read

Access control is a security mechanism that regulates who has access to sensitive data, resources, and systems. It ensures that only authorized users can access sensitive data and activities while keeping unauthorized users out. Access control is critical for protecting sensitive data such as personally identifiable information (PII), financial information, and intellectual property.

However, access control can fail due to a variety of factors, such as incorrectly configured policies, insufficient testing, and a lack of input validation. Unauthorized access, data breaches, data loss, and other security incidents can occur when access control fails.

Broken access control is a significant issue for organizations of all sizes and industries. It emphasizes the importance of maintaining a strong access control system that is regularly reviewed, tested, and updated to avoid vulnerabilities that attackers could exploit.

This article will define broken access control, discuss its causes and consequences, and provide some examples of broken-access control. We’ll also discuss best practices for preventing broken-access control incidents and keeping an access control system in good working order.

What Is Broken Access Control?

Broken-access control is a vulnerability in web applications that allows users to gain unauthorized access to resources or functionalities that they should not have access to. This can happen as a result of flaws in the design or implementation of access control mechanisms, as well as mistakes in the authentication and authorization processes.

Broken-access control, authentication, and session management are frequently used interchangeably. These three concepts are related, but they serve different purposes in web application security.

Authentication is the process of verifying a user’s identity, typically using a username and password, but also using other authentication mechanisms such as biometric verification or multifactor authentication. The goal of authentication is to ensure that users are who they say they are and to prevent unauthorized access to web application resources and functionality.

Session management, on the other hand, is the process of managing user sessions within a web application. It entails creating and storing session tokens that allow users to stay logged in and continue using the application. Session management’s goal is to keep user sessions secure and to prevent session hijacking and other types of attacks that exploit session vulnerabilities.

To avoid broken-access control, proper access control mechanisms (technologies used to enforce access control policies such as passwords and biometrics) should have been put in place and tested properly before deploying the application. This includes validating user permissions, configuring access control policies correctly, and performing regular security audits to identify and fix any vulnerabilities that may arise.

Examples of Broken Access Control

Here are some real-world examples of broken-access control:

  • Unrestricted URL access: When a web app allows access to restricted pages via unrestricted URLs, it’s broken-access control. This happens when a developer fails to implement proper authentication and authorization controls. It allows anyone with the URL to access restricted pages. Attackers can manipulate URL parameters to access sensitive information.
  • Inadequate authorization checks: Another type of broken-access control occurs when a web application fails to perform proper authorization checks, allowing attackers to access restricted pages or functions. This can happen if an application only checks for authentication rather than authorization. For example, an authenticated user may be able to access pages or functions they should not be able to access. An attacker can take advantage of this flaw to gain unauthorized access to sensitive data or functionality.
  • Insecure direct object reference (IDOR): An IDOR vulnerability enables attackers to access sensitive data by manipulating object references. Attackers modify the URL’s ID parameter to gain access. This vulnerability arises due to inadequate user input validation and access control measures in web applications.
  • Horizontal and vertical access control: These vulnerabilities occur when users have unauthorized access to data or functions based on their role or permission level. This happens when access controls are misconfigured, allowing users to access data or functions beyond their assigned level.
  • Broken session management: Broken session management vulnerabilities occur when a web application fails to properly manage user sessions. As a result, attackers may be able to steal or reuse session tokens, granting them unauthorized access to the web application. For example, if a web application fails to properly invalidate session tokens when a user logs out, an attacker can reenter the application using the session token.

Common Causes of Broken Access Control

There are numerous causes of broken-access control in web applications. Some of the most common causes are as follows:

  • Inadequate authorization checks: Inadequate authorization checks are among the most common causes of broken-access control. This happens when web applications fail to properly validate whether a user has permission to access a resource or functionality. A web application, for example, may only use client-side validation, which a skilled attacker can circumvent.
  • Insecure direct object references: Web apps may expose the internal object reference, creating an insecure direct object reference vulnerability. Attackers can use these references to gain access to resources they should not have. Improper validation of user input can enable URL tampering, exposing sensitive data to attackers.
  • Insufficient authentication: Insufficient authentication occurs when web applications fail to properly authenticate users before granting access to resources or functionality. Weak authentication mechanisms, like easy-to-guess passwords or lack of strong password policies, can compromise web app security.
  • Misconfigured access control: Web applications may have incorrect access control rules or configurations due to human error, insufficient testing, or inadequate documentation. Attackers exploit these flaws to gain unauthorized access to resources or functionality.

Finally, Broken-access control must be addressed to avoid serious consequences for web applications. Developers and security experts must identify common causes of broken-access control and take preventive measures. Thorough testing, secure coding practices, and regular security audits are examples of such measures.

Consequences of Broken-Access Control

Broken-access control can severely affect web applications, leading to unauthorized actions and disclosure, modification, or deletion of sensitive data. Here are some of the possible consequences of broken-access control:

  • Unauthorized data disclosure: When users have access to sensitive data that they should not have, it can lead to data breaches, loss of confidentiality, and violations of privacy laws. For example, if a user has access to another user’s personal or financial information, it can lead to identity theft or fraud.
  • Data modification or deletion: Access to unauthorized data can cause data corruption, loss of integrity, and policy violations. For example, changing another user’s account information or deleting critical records can cause significant harm to the application or organization.
  • Unauthorized functionality execution: Unauthorized execution of functions by users can lead to security breaches, system failures, and downtime. Giving users access to perform admin functions or system commands can result in unauthorized access and control of the system.
  • Regulatory compliance violation: If the application fails to comply with regulatory requirements such as the Health Insurance Portability and Accountability Act (HIPAA), the Payment Card Industry Data Security Standard (PCI-DSS), or the General Data Protection Regulation (GDPR) due to broken-access control, it can result in hefty fines, legal penalties, and reputational damage. Unauthorized access to health or credit card data via the application can violate compliance regulations and result in legal ramifications.

Steps to Take to Prevent Broken-Access Control

Here are the steps to take to prevent broken-access control:

  1. Implement role-based access control (RBAC): RBAC is a type of access control that assigns roles based on the user’s job functions and responsibilities. Each role is provided with a set of permissions that govern what data and functionality they have access to. RBAC ensures that users can only access the resources and functions required for their role.
  2. Use attribute-based access control (ABAC): ABAC is an access control method that uses attributes to determine whether a user may access a resource. User identity, location, time of day, device type, and other relevant factors are examples of attributes. ABAC allows access control policies to be more granular and dynamic, ensuring that users only have access to resources based on certain conditions.
  3. Implement proper authentication and authorization controls: Auth controls ensure proper authentication of users before accessing web app resources or functionality. To prevent unauthorized access, use strong passwords, multifactor authentication, and session timeouts.
  4. Conduct regular access control audits: Auditing access control mechanisms regularly can help identify vulnerabilities and weaknesses. Test all types of access control vulnerabilities during audits, such as IDOR, horizontal and vertical access control, and session management.
  5. Implement best practices for access control: Access control best practices include least privilege, separation of duties, and defense-in-depth techniques. These practices layer policies and have multiple security measures to prevent unauthorized access.
  6. Train employees on access control best practices: This is important for preventing unauthorized access to sensitive data or functionality. Train employees on how to properly manage access control policies, identify and report access control vulnerabilities, and respond to security incidents.

These measures safeguard web apps, ensuring data confidentiality, integrity, and availability and preventing unauthorized access and data breaches.


In conclusion, access control ensures that only authorized users can access sensitive data and activities while preventing unauthorized users from accessing them.

Unauthorized access to data and functionalities can lead to various consequences, including data deletion, identity theft, and fraud. As a result, organizations should consider mechanisms to avoid broken-access control. Check out our blog for more informative content.

This post was written by Vincent Chosen. Vincent is a web developer and technical writer. He has proficient knowledge of JavaScript, ReactJS, NextJS, React Native, Node.js, and Database. Aside from coding, Vincent loves playing chess and discussing tech related topics with other developers.


Published May 2, 2023, in technology


Stay in the loop with the Kosli newsletter

Get the latest updates, tutorials, news and more, delivered right to your inbox
Kosli is committed to protecting and respecting your privacy. By submitting this newsletter request, I consent to Kosli sending me marketing communications via email. I may opt out at any time. For information about our privacy practices, please visit Kosli's privacy policy.
Kosli team reading the newsletter

Got a question about Kosli?

We’re here to help, our customers range from larges fintechs, medtechs and regulated business all looking to streamline their DevOps audit trails

Contact us
Developers using Kosli