CWE-266: Incorrect Privilege Assignment

What is Incorrect Privilege Assignment?

• Overview: Incorrect Privilege Assignment occurs when a system mistakenly grants a specific level of access or control to a user or process that should not have such permissions, leading to unintended control over system resources or data.

• Exploitation Methods:

• Attackers can exploit this vulnerability by gaining unauthorized access to restricted functionalities or data.
• Common attack patterns include privilege escalation, misuse of elevated permissions, and lateral movement within the system using the incorrectly assigned privileges.

• Security Impact:

• Direct consequences include unauthorized access to sensitive data and the ability to perform restricted actions.
• Potential cascading effects involve compromised system integrity, data breaches, and further privilege escalation.
• Business impact can include loss of customer trust, legal consequences, and financial loss due to data breaches or service disruptions.

• Prevention Guidelines:

• Specific code-level fixes include implementing proper access control checks and ensuring privilege assignments are correctly configured.
• Security best practices involve adhering to the principle of least privilege, regularly reviewing and auditing privilege assignments, and employing role-based access control (RBAC) models.
• Recommended tools and frameworks include using automated security testing tools to identify privilege-related vulnerabilities and leveraging security frameworks that emphasize access control, such as OAuth or SAML.

Corgea can automatically detect and fix Incorrect Privilege Assignment in your codebase. [Try Corgea free today](https://corgea.app).

Technical Details

Likelihood of Exploit: Not specified

Affected Languages: Not Language-Specific

Affected Technologies: Not specified

Vulnerable Code Example

class Document:
    def __init__(self, content, owner):
        self.content = content
        self.owner = owner
        self.editors = []

    def add_editor(self, user):
        # Vulnerability: Incorrectly allows any user to be added as an editor
        self.editors.append(user)

    def edit_content(self, user, new_content):
        if user in self.editors:
            self.content = new_content
            return True
        return False

# Usage
doc = Document("Confidential Content", "admin")
doc.add_editor("guest")  # A guest user is incorrectly given edit privileges
doc.edit_content("guest", "Altered Content")  # Guest can edit the content

Explanation:

In this example, the add_editor method allows any user to be added as an editor without checking their privileges. This oversight can lead to unauthorized users being able to modify the document content, posing a security risk.

How to fix Incorrect Privilege Assignment?

To fix this vulnerability, ensure that only users with the proper privileges, such as the document owner or an administrator, can assign editor roles. Implement a privilege check in the add_editor method to verify if the user requesting to add another editor has the necessary permissions.

Fixed Code Example

class Document:
    def __init__(self, content, owner):
        self.content = content
        self.owner = owner
        self.editors = []

    def add_editor(self, current_user, user_to_add):
        # Fix: Ensure only the owner can add editors
        if current_user == self.owner:
            self.editors.append(user_to_add)
        else:
            raise PermissionError("Only the owner can add editors.")

    def edit_content(self, user, new_content):
        if user in self.editors:
            self.content = new_content
            return True
        return False

# Usage
doc = Document("Confidential Content", "admin")
try:
    doc.add_editor("admin", "guest")  # Only the owner can add editors
    doc.edit_content("guest", "Altered Content")  # Now it is safe as privileges are checked
except PermissionError as e:
    print(e)

Explanation:

In the fixed code, the add_editor method now checks if the current_user is the owner of the document before allowing them to add another user as an editor. This ensures that only authorized users can assign editing privileges, thereby preventing unauthorized users from gaining access to sensitive operations.