CISSP Domain 3: System Vulnerabilities & Hardware Security — Mindmap Review Study Guide
═══════════════════════════════════
PART 1: MERMAID MINDMAP
═══════════════════════════════════
mindmap
root((Vulnerabilities in Systems))
System Reliability
Single Point of Failure
Redundancy
Security Control Bypass
Bypass Controls
Mitigating Controls
Processing and Timing
TOCTOU Race Conditions
TOCTOU Mitigations
Exception handling
Transactions and Concurrency
File locks
Increase re-auth frequency
Emanations and Physical Security
Emanations
Shielding and TEMPEST
Faraday cages
Insulation
Opaque walls
White Noise
Control Zones
Covert Channels and Inference
Covert Channels
Storage Channels
Timing Channels
Analysis and Design
Aggregation and Inference
Polyinstantiation
Mobile Device Vulnerabilities
Mobile Device Risks
Mobile Device Defenses
OWASP Mobile Top 10
M1 Improper Platform Usage
TouchID FaceID Keychain
M2 Insecure Data Storage
PII protection
M3 Insecure Communication
SSL/TLS and Certificates
M4 Insecure Authentication
M5 Insufficient Cryptography
M6 Insecure Authorization
M7 Client Code Quality
Memory leaks Buffer overflows
M8 Code Tampering
M9 Reverse Engineering
Code obfuscation tools
M10 Extraneous Functionality
Manual code review
Web-based Vulnerabilities
Cross Site Scripting XSS
Stored XSS
Reflected XSS
URL exploitation
DOM XSS
Target is Client
Cross Site Request Forgery CSRF
Target is Server
SQL Injection
Input Validation
Client vs Server Side
Allow vs Deny Lists
White and Black lists
Sanitize and Escape characters
═══════════════════════════════════
PART 2: TECHNICAL DEFINITIONS & CONCEPTS
═══════════════════════════════════
System Reliability
Single Point of Failure — Non-redundant parts of a larger system where the failure of that single component causes the entire system to stop working (e.g., a single router or firewall handling all internet traffic).
Redundancy — The implementation of multiple components (hardware, software, services, providers, or people) configured so that the failure of one does not result in total system failure, thereby preventing single points of failure.
Security Control Bypass
Bypass Controls — Methods intentionally built into a system to allow a security control to be bypassed or circumvented for legitimate reasons (e.g., a configuration reset button on a network device), which inherently introduces risk.
Mitigating Controls — Additional security controls implemented to reduce the risk introduced by bypass controls to an acceptable level (e.g., physical security, enhanced logging and monitoring, segregation of duties).
Processing and Timing
TOCTOU (Race Conditions) — Time of Check Time of Use; a vulnerability where an application checks a resource’s state before using it, but the state changes between the check and use, invalidating the check and allowing invalid actions.
TOCTOU Mitigations — Technical methods to reduce race condition risks, including exception handling, transactions (which provide concurrency controls), and file locks. ⚠️ EXAM TIP: For TOCTOU/race conditions, the CISSP exam answer is to increase the frequency of how often a check/re-authentication is performed to reduce the window of time an attacker can exploit.
Emanations and Physical Security
Emanations — Radio waves, electrical signals, light, sounds, or vibrations that radiate from a system and can be intercepted to eavesdrop and leak information.
Shielding — Methods to block emanations from a system so they cannot be detected, such as using faraday cages for electromagnetic fields, insulation for sound, and opaque walls for light.
TEMPEST — A specific type of shielding developed by the military designed specifically to shield devices that emit electromagnetic radiation.
White Noise — Blasting out strong random signals to drown out the weak emanations from a secure device in a sea of noise.
Control Zones — Placing high-value systems in physically secured zones with physical security controls to ensure only authorized individuals can get close enough to detect emanations.
Covert Channels and Inference
Covert Channels — Unintentional communication paths that can unintentionally disclose confidential information.
Storage Channels — One of the two major types of covert channels identified in the transcript.
Timing Channels — The second major type of covert channel identified in the transcript.
Analysis & Design — Addressing covert channel vulnerabilities by carefully analyzing systems and processes to identify unintentional communication paths and designing controls to prevent or mitigate them.
Aggregation — The vulnerability that occurs when a lot of data is collected and centralized in one location, such as a data warehouse, big data, or data lake.
Inference — The risk that someone may be able to figure out (infer) unauthorized information from aggregated data.
Polyinstantiation — A concept to reduce unauthorized inference where different versions of the same information or process exist at different classification levels, ensuring an attacker only sees their specific version while other versions remain invisible.
Mobile Device Vulnerabilities
Mobile Device Risks — Mobile devices are significant vulnerabilities because they contain sensitive information and are easily lost or stolen in various locations (e.g., taxis, trains, airplanes).
Mobile Device Defenses — Strategies to reduce mobile device risks, including clear policies limiting sensitive data storage, training, procedures, encrypted remote access, and endpoint security (strong authentication, whole drive encryption, remote wipe).
OWASP Mobile Top 10 — A list developed by the Open Web Application Security Project detailing the most common security flaws and vulnerabilities in mobile devices.
- M1: Improper Platform Usage — Security functionalities built into the mobile device (like TouchID, FaceID, and Keychain) are not used or are used incorrectly; prevented by secure coding and configuration management.
- M2: Insecure Data Storage — Sensitive data, such as PII, is stored in insecure directories on the mobile device where it can be trivially accessed via physical theft or malware; prevented by not storing sensitive data on the device.
- M3: Insecure Communication — Mobile devices communicating across the internet where data in transit could be intercepted; prevented by encrypting data using protocols like SSL/TLS and authenticating the server with certificates.
- M4: Insecure Authentication — An attacker figures out how the app calls the back-end server and bypasses the app to send requests directly to the server, bypassing app authentication; prevented by performing authentication on the server side.
- M5: Insufficient Cryptography — The mobile device uses a poor encryption algorithm or the algorithm is poorly implemented; prevented by using good algorithms that withstand the test of time and implementing them properly.
- M6: Insecure Authorization — Doing a poor job of determining what functionality a user is allowed to access, potentially allowing attackers to bypass authorization; prevented by performing authorization on the back-end server, not the mobile device.
- M7: Client Code Quality — Software running on the mobile device is vulnerable to common attacks like memory leaks and buffer overflows, exploited via malware or phishing; prevented by developers writing secure code using secure coding practices.
- M8: Code Tampering — An attacker changes or adds new malicious code into a mobile application to perform fraudulent actions like stealing identities; prevented by ensuring mobile applications can detect if their code has been tampered with at runtime.
- M9: Reverse Engineering — An attacker carefully analyzes a mobile app to reveal back-end server info, crypto weaknesses, or steal intellectual property; prevented by using code obfuscation tools.
- M10: Extraneous Functionality — Hidden functionality left behind by a developer that allows an attacker to gain unauthorized access to back-end servers; prevented by removing extraneous functionality before publishing via manual code review.
Web-based Vulnerabilities
Cross Site Scripting (XSS) — Attacks where malicious scripts (like javascript) are injected into benign web sites, causing a visitor’s browser to download and execute the attacker’s script (often embedded in HTML) to exfiltrate data or run code. ⚠️ EXAM TIP: The target of an XSS attack is ultimately the client (the user’s browser).
| XSS Type | Description | Persistence |
|---|---|---|
| Stored (Persistent) XSS | Attacker injects code (e.g., in a comment) that is stored on the server and displayed to every subsequent user’s browser. | Persistent; every subsequent user downloads and executes the code. |
| Reflected XSS | Malicious code is embedded in a URL (e.g., in a phishing email); the server reflects the code from the URL back to the specific user who clicked it. | Not persistent; only reflected back to one specific user. |
| DOM (Document Object Model) XSS | A much more technically complicated and rare way of achieving XSS. | N/A |
⚠️ EXAM TIP: Reflected XSS is the most common form of XSS. ⚠️ EXAM TIP: DOM XSS is rare; do not worry about it for the exam.
Cross Site Request Forgery (CSRF) — An attack where an attacker forces or tricks a user into executing unwanted actions on a web application in which the user is currently authenticated, allowing the attacker to execute authorized commands on the server. ⚠️ EXAM TIP: The target of a CSRF attack is ultimately the server (the attack passes through the user).
SQL Injection — An attack where an attacker sends SQL (Structured Query Language) code via a web form (like username/password) that the web server passes directly to the back-end database without validation, allowing the attacker to control the database.
Input Validation — The primary defense against SQL injection and XSS; the web application must validate all input by sanitizing it (removing or escaping special characters) so user input is never passed directly to the database or executed. ⚠️ EXAM TIP: For highly technical questions on SQL injection or XSS, the correct answer is almost always that the user’s input was validated/sanitized in some way.
| Validation Location | Security Posture | Description |
|---|---|---|
| Client Side Validation | Insecure | Performed on the user’s browser; trivially easy for an attacker to bypass. |
| Server Side Validation | Secure | Performed on the web server; emphatically required for security purposes. |
⚠️ EXAM TIP: Input validation must emphatically be performed on the server side.
| List Type | Security Posture | Description |
|---|---|---|
| Allow Lists | More Secure | Only specific characters are permitted; all other characters are blocked. Far more restrictive. |
| Deny Lists | Less Secure | Only specific characters are blocked/removed; all other characters are allowed. |
⚠️ EXAM TIP: Allow lists are more secure than deny lists because they are far more restrictive. ⚠️ EXAM TIP: You may still see the historical terms “white lists” (equivalent to allow lists) and “black lists” (equivalent to deny lists) on the exam.