CWE-1318: Missing Support for Security Features in On-chip Fabrics or Buses

What is Missing Support for Security Features in On-chip Fabrics or Buses?

• Overview: Missing Support for Security Features in On-chip Fabrics or Buses refers to the absence or misconfiguration of privilege separation and other security features in the communication protocols within integrated circuits, which can lead to unauthorized access or data leaks.

• Exploitation Methods:

• Attackers can exploit this vulnerability by intercepting or manipulating data as it is transferred across the on-chip fabric or bus.
• Common attack patterns include unauthorized access to sensitive data and privilege escalation by exploiting the lack of security signals and access controls.

• Security Impact:

• Direct consequences of successful exploitation include unauthorized data access, data corruption, and leakage of sensitive information.
• Potential cascading effects could involve compromised system integrity, leading to wider network vulnerabilities.
• Business impact may include data breaches, loss of intellectual property, regulatory non-compliance, and reputational damage.

• Prevention Guidelines:

• Specific code-level fixes include implementing access controls and ensuring privilege separation at the register-transfer-level (RTL) design stage.
• Security best practices involve using secure on-chip fabrics and buses that support necessary security signals and attributes.
• Recommended tools and frameworks include security verification tools for RTL designs and adopting hardware security modules to enforce access controls.

Corgea can automatically detect and fix Missing Support for Security Features in On-chip Fabrics or Buses in your codebase. [Try Corgea free today](https://corgea.app).

Technical Details

Likelihood of Exploit: Not specified

Affected Languages: Not Language-Specific

Affected Technologies: Processor Hardware, Not Technology-Specific

Vulnerable Code Example

// This code simulates a bus controller that does not enforce privilege checks.
// Any module can access and modify the bus data without restrictions.
class BusController {
    constructor() {
        this.busData = {};  // Bus data storage
    }

    writeToBus(module, data) {
        // No privilege checks are made, allowing any module to write data
        this.busData[module] = data;
    }

    readFromBus(module) {
        // Any module can read data without permission checks
        return this.busData[module];
    }
}

const bus = new BusController();
bus.writeToBus('moduleA', 'sensitiveData'); // Unauthorized write
console.log(bus.readFromBus('moduleA')); // Unauthorized read

Explanation:

• Lack of Access Control: The writeToBus and readFromBus methods do not check if a module has the necessary permissions to perform these operations. This allows any module to write to or read from the bus without restriction, leading to potential security breaches.
• Security Risk: Unauthorized modules can manipulate or access sensitive data, which can lead to data leaks or corruption.

How to fix Missing Support for Security Features in On-chip Fabrics or Buses?

To address this vulnerability, we need to implement access control mechanisms that ensure only authorized modules can write to or read from the bus. This involves:

• Assigning roles or permissions to each module that interacts with the bus.
• Implementing checks within the writeToBus and readFromBus methods to verify whether the module has the appropriate permissions before allowing access.
• Logging unauthorized access attempts for audit purposes.

Fixed Code Example

// Fixed code with added access control mechanisms
class BusController {
    constructor() {
        this.busData = {};
        // Permissions map to define which modules have write and read access
        this.permissions = {
            'moduleA': { write: true, read: true },
            'moduleB': { write: false, read: true },
            // More modules and permissions can be added here
        };
    }

    writeToBus(module, data) {
        if (this.permissions[module]?.write) {
            this.busData[module] = data;
        } else {
            console.log(`Unauthorized write attempt by \${module}`);
        }
    }

    readFromBus(module) {
        if (this.permissions[module]?.read) {
            return this.busData[module];
        } else {
            console.log(`Unauthorized read attempt by \${module}`);
            return null;
        }
    }
}

const bus = new BusController();
bus.writeToBus('moduleA', 'sensitiveData'); // Authorized write
console.log(bus.readFromBus('moduleA')); // Authorized read
bus.writeToBus('moduleB', 'sensitiveData'); // Unauthorized write attempt logged
console.log(bus.readFromBus('moduleB')); // Authorized read (no data)

Explanation:

• Permissions Definition: A permissions map is introduced to specify which modules have access to read or write operations.
• Access Control: Before any read or write operation, the code checks if the module has the necessary permission. Unauthorized attempts are logged for auditing.
• Logging: Unauthorized access attempts are logged to alert administrators and help in identifying potential security incidents.
• Best Practices: The code uses optional chaining (?.) to safely access properties, preventing runtime errors if a module is not defined in the permissions map.