Cyber Services / All lessons / CEH — Ethical Hacking / Cryptography Lab - CEH Notes

Cryptography Lab - CEH Notes

Module 108 of 130 · 16 min read · Free to read

MODULES ↓ Command blocks have a COPY button

This comprehensive, student-tested lab guide provides verified, executable exercises for core cryptographic concepts essential for the Certified Ethical Hacker (CEH) v13 certification. All commands have been tested on Kali Linux 2024.2 with OpenSSL 3.0+ and GnuPG 2.2+. Work through each section sequentially, verifying outputs at each step.

🎯 Lab Learning Outcomes:
  • Integrity: Verify file authenticity using SHA-256/SHA3 hashes
  • Authentication: Implement HMAC to prove message origin with shared secrets
  • Confidentiality: Encrypt/decrypt files using AES-256-CBC with proper key derivation
  • Non-repudiation: Create and verify digital signatures using GPG
  • Key Management: Generate, export, import, and manage asymmetric key pairs securely
  • Best Practices: Apply CEH v13-aligned cryptographic standards in real scenarios
📋 Prerequisites Checklist (Complete Before Starting):
  • ✅ Kali Linux 2023.3+ (Live, VM, or bare metal)
  • ✅ Terminal access with sudo privileges
  • ✅ Verify tools: openssl version ≥ 3.0, gpg --version ≥ 2.2
  • ✅ Create lab workspace: mkdir -p ~/crypto-lab && cd ~/crypto-lab
  • ✅ Ensure sufficient disk space (~100MB) and no network restrictions
⚖️ Ethical Use Declaration: All exercises must be performed ONLY on files and systems you own or have explicit written authorization to test. Unauthorized cryptographic operations may violate laws including CFAA, GDPR, and local cybercrime statutes. This lab is for educational purposes only.

🔧 Lab Setup & Tool Verification

Before beginning cryptographic operations, verify your environment is correctly configured. This prevents common errors during lab execution.

Step 1: Verify Core Tools (Execute Each Command):
# Check OpenSSL version and supported algorithms
openssl version
openssl list -digest-algorithms | grep -E "sha256|sha512|sha3"

# Check GPG version and capabilities
gpg --version | head -3
gpg --list-config --with-colons | grep -E "cipher|digest"

# Verify core utilities are available
which sha256sum base64 shred dd echo cat
Step 2: Create Lab Workspace & Sample Files:
# Create dedicated lab directory
mkdir -p ~/crypto-lab && cd ~/crypto-lab

# Create sample plaintext files for exercises
echo "CEH v13 Lab: Confidential Report - DO NOT DISTRIBUTE" > report.txt
echo "API_KEY=sk_test_abc123xyz
DB_PASS=SecureP@ssw0rd!
USER=admin" > config.ini

# Create a binary test file (1MB random data)
dd if=/dev/urandom of=test_data.bin bs=1M count=1 status=none

# Verify files were created
ls -lh *.txt *.ini *.bin
sha256sum report.txt config.ini test_data.bin

💡 Pro Tip: Keep all lab files in ~/crypto-lab to avoid cluttering your home directory. Use shred -u to securely delete sensitive files after exercises.

I. Cryptographic Hashing: Verifying File Integrity

Hash functions generate fixed-size digests that uniquely represent data. Properties: deterministic, one-way, avalanche effect. Critical for verifying downloads, detecting tampering, and ensuring data consistency.

A. Hashing Files with OpenSSL (openssl dgst)

✅ Exercise 1.1: Generate & Verify SHA-256 Hash (Step-by-Step)
# Generate SHA-256 hash of report.txt
openssl dgst -sha256 report.txt
# Expected output format:
# SHA2-256(report.txt)= a1b2c3d4e5f6... (64 hex characters)

# Save hash to file for later verification
openssl dgst -sha256 report.txt > report.sha256

# Display the stored hash
cat report.sha256

# Verify integrity: Compare current hash against stored value
openssl dgst -sha256 -verify report.sha256 report.txt
# ✅ Success: "Verified OK"
# ❌ Failure: "Verification Failure" (file was modified)
✅ Exercise 1.2: Test Avalanche Effect (Hands-On)
# Generate hash of original file
openssl dgst -sha256 report.txt | awk '{print $2}' > hash_original.txt

# Modify file: Add one character
echo "" >> report.txt  # Adds newline

# Generate hash of modified file
openssl dgst -sha256 report.txt | awk '{print $2}' > hash_modified.txt

# Compare hashes (should be completely different)
echo "Original:  $(cat hash_original.txt)"
echo "Modified:  $(cat hash_modified.txt)"
diff hash_original.txt hash_modified.txt && echo "❌ Same!" || echo "✅ Different - Avalanche effect confirmed!"

🔍 Observation: Even a single-bit change produces a completely different hash. This is why hashes detect tampering.

B. Hashing with Linux Core Utilities (*sum)

Faster for batch file operations. Output format compatible with verification tools and package managers.

✅ Exercise 1.3: File Integrity Workflow with sha256sum
# Generate hash and save in standard format
sha256sum config.ini > config.ini.sha256

# View the checksum file format
cat config.ini.sha256
# Format:   

# Simulate file transfer: Copy to temp location
cp config.ini /tmp/config_copy.ini
cp config.ini.sha256 /tmp/

# Verify integrity at destination
cd /tmp && sha256sum -c config.ini.sha256
# ✅ Output: "config_copy.ini: OK"

# Test tampering detection: Modify copied file
echo "# TAMPERED" >> /tmp/config_copy.ini
sha256sum -c config.ini.sha256
# ❌ Output: "config_copy.ini: FAILED" + warning

# Cleanup
cd ~/crypto-lab
rm /tmp/config_copy.ini /tmp/config.ini.sha256
🚫 Deprecated Algorithms - DO NOT USE in Production:
# These work but are INSECURE - for educational comparison only:
openssl dgst -md5 report.txt    # MD5: 128-bit, broken since 2004
openssl dgst -sha1 report.txt   # SHA-1: 160-bit, collision attacks demonstrated

# CEH v13 Requirement: Always use SHA-256, SHA-384, SHA-512, or SHA3 variants
# Verify available secure algorithms:
openssl list -digest-algorithms | grep -E "sha(256|384|512|3)" 

II. HMAC: Authenticating Messages with Shared Secrets

HMAC = Hash + Secret Key. Provides both integrity AND authentication. Only parties with the shared key can generate/verify the HMAC. Critical for API security, session tokens, and secure communications.

🎯 CEH v13 Application: Attackers often exploit weak HMAC implementations (predictable keys, reused nonces). Understanding proper HMAC usage helps identify authentication bypass vulnerabilities.
✅ Exercise 2.1: Generate & Verify HMAC-SHA256 (File-Based)
# Step 1: Define a strong secret key (NEVER hardcode in production!)
HMAC_KEY="CEH_Lab_SecretKey_2024!@#$%^&*()"

# Step 2: Generate HMAC for config.ini
openssl dgst -sha256 -hmac "$HMAC_KEY" config.ini > config.hmac

# Step 3: View the HMAC output
cat config.hmac
# Format: HMAC-SHA2-256(config.ini)= <64-char hex>

# Step 4: Verify HMAC (integrity + authenticity check)
openssl dgst -sha256 -hmac "$HMAC_KEY" -verify config.hmac config.ini
# ✅ Output: "Verified OK" = File unchanged AND from trusted source

# Step 5: Test tampering detection
echo "# MALICIOUS_CHANGE" >> config.ini
openssl dgst -sha256 -hmac "$HMAC_KEY" -verify config.hmac config.ini
# ❌ Output: "Verification Failure" = Tampering detected OR wrong key

⚠️ Key Security: In real systems, store keys in environment variables, secret managers, or HSMs—never in plaintext files. For this lab, we use a variable for demonstration.

✅ Exercise 2.2: Simulate API Request Signing (Real-World Scenario)
# Create a JSON payload (simulating API request)
cat > api_request.json << 'EOF'
{
  "timestamp": "2024-02-28T10:30:00Z",
  "user_id": "eth1cal_h4cker",
  "action": "data_export",
  "resource": "customer_records"
}
EOF

# Generate HMAC signature using shared API secret
API_SECRET="api_sk_live_9x8y7z6w5v4u3t2s1r"
openssl dgst -sha256 -hmac "$API_SECRET" -binary api_request.json | base64 > request.sig

# Display signature (this would be sent in HTTP header)
echo "X-API-Signature: $(cat request.sig)"

# Verification at server side (simulated):
# Server recomputes HMAC with same key and compares
openssl dgst -sha256 -hmac "$API_SECRET" -binary api_request.json | base64 > computed.sig
diff request.sig computed.sig && echo "✅ Authentic request" || echo "❌ Rejected: Invalid signature"

III. Symmetric Encryption: Protecting Confidentiality

Same key encrypts and decrypts. Fast and efficient for bulk data. CEH v13 focus: AES-256-CBC with PBKDF2 key derivation + HMAC for integrity (Encrypt-then-MAC pattern).

🔐 OpenSSL enc Cipher Support (Kali Linux 2024.2):
  • ✅ Recommended: aes-256-cbc + -pbkdf2 -iter 100000 + HMAC
  • ✅ Modern Alternative: openssl cms for AEAD (GCM/ChaCha20-Poly1305)
  • ❌ Not Supported with Passwords: aes-256-gcm, chacha20-poly1305 in enc (require raw keys)
  • 🚫 Deprecated: des, des3, rc4, aes-*-ecb

✅ Method 1: Password-Based Encryption (AES-256-CBC + HMAC) - RECOMMENDED

Exercise 3.1: Complete Encrypt → Verify → Decrypt Workflow
# === ENCRYPTION PHASE ===
# 1. Define strong passphrase (use in real: password manager)
PASSPHRASE="CEH_Lab_Str0ngP@ss!2024#Secure"

# 2. Encrypt report.txt with AES-256-CBC + PBKDF2 + Salt
openssl enc -aes-256-cbc -salt -pbkdf2 -iter 100000 \
  -in report.txt -out report.enc -pass pass:"$PASSPHRASE"

# 3. Generate HMAC for integrity verification
openssl dgst -sha256 -hmac "$PASSPHRASE" -out report.enc.hmac report.enc

# 4. Securely delete plaintext (simulate secure handling)
shred -u report.txt
ls -la report.*  # Only .enc and .hmac should remain

# === VERIFICATION & DECRYPTION PHASE ===
# 5. Verify HMAC BEFORE decryption (critical security step)
if openssl dgst -sha256 -hmac "$PASSPHRASE" -verify report.enc.hmac report.enc >/dev/null 2>&1; then
  echo "✅ Integrity verified. Proceeding to decrypt..."
  
  # 6. Decrypt the file
  openssl enc -d -aes-256-cbc -pbkdf2 -iter 100000 \
    -in report.enc -out report.decrypted -pass pass:"$PASSPHRASE"
  
  # 7. Verify content matches original expectation
  cat report.decrypted
  # Expected: "CEH v13 Lab: Confidential Report - DO NOT DISTRIBUTE"
  
  # 8. Securely delete decrypted file after review
  shred -u report.decrypted
else
  echo "❌ HMAC verification FAILED! Possible tampering or wrong passphrase."
  echo "ABORTING decryption for security."
  exit 1
fi

# === CLEANUP ===
shred -u report.enc report.enc.hmac
echo "🧹 Lab files securely deleted."

🔑 Why PBKDF2 with 100k iterations? Slows brute-force attacks. CEH v13 requires understanding key derivation hardening. Adjust iterations based on system performance (min 10,000 for labs).

✅ Method 2: Modern AEAD Encryption with openssl cms

Cryptographic Message Syntax (CMS) supports authenticated encryption modes with password-based key derivation—ideal for secure file exchange.

Exercise 3.2: AEAD Encryption with CMS (OpenSSL 3.0+)
# Create sensitive file
echo "CEH v13 Final Assessment: Critical Findings - EYES ONLY" > findings.txt

# Encrypt with password (auto-selects AES-256-GCM or ChaCha20-Poly1305)
openssl cms -encrypt -in findings.txt -out findings.cms \
  -password pass:"CMS_SecurePass_2024!" \
  -aes-256-gcm  # Explicit cipher (optional; auto-selected if omitted)

# Verify encrypted file properties
file findings.cms  # Should show: "data" or "CMS encryption"
ls -lh findings.cms

# Decrypt and verify
openssl cms -decrypt -in findings.cms -out findings.decrypted \
  -password pass:"CMS_SecurePass_2024!"

# Confirm content integrity
cat findings.decrypted
diff findings.txt findings.decrypted && echo "✅ Content matches original"

# Cleanup
shred -u findings.txt findings.decrypted findings.cms

💡 Advantage of CMS: Handles key derivation, salt, IV, and authentication tag automatically. Preferred for new implementations over raw enc.

⚠️ Critical Security Reminders:
  • ❌ Never use openssl enc -aes-256-gcm -pass — does not work (AEAD + password unsupported in enc)
  • ✅ Always use -salt -pbkdf2 -iter 100000 for password-based encryption
  • ✅ Always verify HMAC or authentication tag BEFORE trusting decrypted content
  • ✅ Use shred -u or srm to securely delete sensitive plaintext files
  • 🔐 Store passphrases in password managers—never in scripts or comments

IV. Asymmetric Cryptography: GPG Key Operations

Public/private key pairs enable secure communication without pre-shared secrets. GPG implements OpenPGP standard. CEH v13 focus: key generation, encryption, signing, verification, and trust management.

🔑 Complete GPG Lab Workflow (Tested on Kali 2024.2)

Step 1: Generate Secure Key Pair (Interactive)

# Start interactive key generation
gpg --full-gen-key

# Follow prompts EXACTLY as shown:
# (1) Key type: (1) RSA and RSA  [Enter]
# (2) Key size: 4096             [Enter]  (CEH v13 minimum)
# (3) Key expiration: 2y         [Enter]  (Best practice: 1-2 years)
# (4) User ID: 
#     Real name: CEH Student Lab
#     Email: student@lab.local
#     Comment: CEH v13 Practice Key
# (5) Passphrase: Use 16+ char strong passphrase (write down temporarily for lab)
# (6) Confirm passphrase

# Wait for entropy collection (move mouse/type if slow)

Step 2: Verify & Document Your Keys

# List keys with long key IDs (more secure than short IDs)
gpg --list-keys --keyid-format LONG
gpg --list-secret-keys --keyid-format LONG

# View full fingerprint (CRITICAL for verification)
gpg --fingerprint "CEH Student Lab"

# Save key info for lab documentation
gpg --list-keys --with-fingerprint "CEH Student Lab" > my_key_info.txt
cat my_key_info.txt

# Expected output snippet:
# pub   rsa4096 2024-02-28 [SC] [expires: 2026-02-28]
#       ABCD EF01 2345 6789 ABCD EF01 2345 6789 ABCD EF01
# uid           [ultimate] CEH Student Lab (CEH v13 Practice Key) 

Step 3: Export Public Key for Sharing

# Export ASCII-armored public key (safe for email/text)
gpg --export --armor "CEH Student Lab" > ceh_student_public.asc

# Verify export succeeded
head -5 ceh_student_public.asc
# Should start with: -----BEGIN PGP PUBLIC KEY BLOCK-----

# Optional: Upload to keyserver (for lab only)
# gpg --keyserver hkps://keys.openpgp.org --send-keys 

Step 4: Encrypt File for Recipient

# Create sensitive file
echo "CEH v13 Lab: Encrypted Payload - Confidential" > secret_payload.txt

# Encrypt for YOURSELF (using your own public key)
gpg --encrypt --recipient "CEH Student Lab" -o secret_payload.gpg secret_payload.txt

# Verify encryption
file secret_payload.gpg  # Should show: "PGP encrypted data"
ls -lh secret_payload.*

# Securely delete plaintext
shred -u secret_payload.txt

Step 5: Decrypt with Private Key

# Decrypt (you'll be prompted for passphrase)
gpg --decrypt -o secret_payload.decrypted secret_payload.gpg

# View content
cat secret_payload.decrypted
# Expected: "CEH v13 Lab: Encrypted Payload - Confidential"

# Verify integrity (optional but recommended)
sha256sum secret_payload.decrypted

# Cleanup decrypted file
shred -u secret_payload.decrypted

Step 6: Create & Verify Digital Signatures

# === DETACHED SIGNATURE (Recommended for files) ===
# Create document to sign
echo "CEH v13 Lab Report: Approved by Student" > lab_report.txt

# Generate detached ASCII-armored signature
gpg --detach-sign --armor -o lab_report.sig lab_report.txt

# Verify signature
gpg --verify lab_report.sig lab_report.txt
# ✅ Expected output:
# gpg: Signature made Thu 28 Feb 2024...
# gpg:                using RSA key ABCDEF0123456789...
# gpg: Good signature from "CEH Student Lab..." [ultimate]

# === TEST TAMPERING DETECTION ===
# Modify the file slightly
echo "# Modified" >> lab_report.txt

# Re-verify (should FAIL)
gpg --verify lab_report.sig lab_report.txt
# ❌ Expected: "BAD signature" warning

# Restore original for next step
git checkout lab_report.txt 2>/dev/null || echo "Lab Report: Approved by Student" > lab_report.txt

# === CLEAR-SIGN (For human-readable text) ===
gpg --clear-sign lab_report.txt
# Creates: lab_report.txt.asc (signed text + signature)

# Verify clear-signed message
gpg --verify lab_report.txt.asc

Step 7: Sign AND Encrypt (Combined Operation)

# Create final report
echo "CEH v13 Final Submission: Confidential Findings" > final_report.pdf

# Sign with your private key AND encrypt for recipient
gpg --sign --encrypt --recipient "CEH Student Lab" \
  -o final_report.secure.gpg final_report.pdf

# Verify file properties
file final_report.secure.gpg  # Should show encrypted+signed

# Decrypt AND verify signature in one step
gpg --decrypt final_report.secure.gpg > final_report.verified.pdf

# Check output
cat final_report.verified.pdf
# Should show content + signature verification status

# Cleanup
shred -u final_report.pdf final_report.verified.pdf final_report.secure.gpg
🛡️ CEH v13 GPG Best Practices Checklist:
  • ✅ Use RSA-4096 or ECC (ed25519) for new keys
  • ✅ Set key expiration (1-2 years) and renew proactively
  • ✅ ALWAYS verify fingerprints via out-of-band channel before trusting keys
  • ✅ Use subkeys: primary key for certification, subkeys for signing/encryption
  • ✅ Backup private keys securely AND generate revocation certificate immediately
  • ✅ Use strong passphrases (16+ chars, mixed types) + consider YubiKey for storage
  • ✅ Regularly audit keyring: gpg --check-sigs, gpg --update-trustdb
🔐 Advanced: Generate Revocation Certificate (DO THIS AFTER KEY CREATION)
# Generate revocation cert (in case key is compromised)
gpg --gen-revoke "CEH Student Lab" > revocation_cert.asc

# Store revocation cert SECURELY (offline, encrypted)
# Example: Encrypt it with a different strong passphrase
openssl enc -aes-256-cbc -salt -pbkdf2 \
  -in revocation_cert.asc -out revocation_cert.enc \
  -pass pass:"Revocation_Master_Key_2024!"

# Verify you can decrypt it (test recovery process)
openssl enc -d -aes-256-cbc -pbkdf2 \
  -in revocation_cert.enc -out revocation_test.asc \
  -pass pass:"Revocation_Master_Key_2024!"
diff revocation_cert.asc revocation_test.asc && echo "✅ Revocation cert backup verified"

# Cleanup test file
shred -u revocation_test.asc

V. Encoding vs. Encryption: Critical Distinction

🔑 Key Concept: Encoding (Base64, Hex, URL) = Format conversion (NO security). Encryption = Confidentiality protection (requires keys). CEH v13 frequently tests this distinction in scenarios involving data exfiltration or obfuscation.
✅ Exercise 5.1: Base64 Encoding Workflow (With Verification)
# Create binary file
dd if=/dev/urandom of=sample.bin bs=1K count=5 status=none

# Encode to Base64 (for text-safe transmission)
base64 sample.bin > sample.b64

# Verify encoding increased size (~33%)
echo "Original: $(stat -c%s sample.bin) bytes"
echo "Encoded:  $(stat -c%s sample.b64) bytes"

# Decode back to binary
base64 --decode sample.b64 > sample_restored.bin

# Verify integrity (MUST match original)
sha256sum sample.bin sample_restored.bin
diff sample.bin sample_restored.bin && echo "✅ Round-trip successful"

# Demonstrate NO confidentiality: Anyone can decode Base64
echo "Base64 content preview (first 100 chars):"
head -c 100 sample.b64
echo "..."
echo "⚠️  Base64 provides ZERO security - only format compatibility!"

# Cleanup
shred -u sample.bin sample.b64 sample_restored.bin
🚫 Common Mistake to Avoid:
# ❌ WRONG: Using Base64 to "hide" sensitive data
echo "password=SuperSecret123" | base64  # Output: cGFzc3dvcmQ9U3VwZXJTZWNyZXQxMjM=

# ✅ CORRECT: Encrypt FIRST, then optionally encode for transport
echo "password=SuperSecret123" | \
  openssl enc -aes-256-cbc -salt -pbkdf2 -pass pass:"Key123!" | \
  base64  # Now it's secure AND text-safe

# CEH v13 Tip: Attackers often find Base64-"encrypted" data in configs/logs. 
# Always check if it's just encoding (trivial to decode) vs real encryption.

✅ Lab Completion Checklist & Troubleshooting

📋 Final Verification Steps:
# 1. Confirm all lab files are cleaned up
cd ~/crypto-lab
ls -la  # Should be empty or contain only non-sensitive docs

# 2. Verify GPG keyring state (optional cleanup)
gpg --list-keys "CEH Student Lab"  # Should show your lab key
# To remove lab key after course: 
# gpg --delete-secret-and-public-key "CEH Student Lab"

# 3. Test one end-to-end workflow (choose one):
#    Option A: Hash → HMAC → Encrypt → Decrypt → Verify
#    Option B: GPG Key Gen → Encrypt → Sign → Verify → Decrypt

# 4. Document lessons learned:
cat > lab_reflection.md << 'EOF'
# CEH v13 Cryptography Lab Reflection
## Key Takeaways:
1. Hashing detects tampering but doesn't prevent it
2. HMAC requires secure key management to be effective
3. Symmetric encryption needs strong KDFs (PBKDF2 iterations matter!)
4. GPG signatures provide non-repudiation - fingerprint verification is critical
5. Encoding ≠ Encryption - a common exam trick question!

## Commands I'll reuse:
- openssl dgst -sha256 -hmac "$KEY" file
- openssl enc -aes-256-cbc -salt -pbkdf2 -iter 100000 ...
- gpg --encrypt --sign --recipient ...
EOF
cat lab_reflection.md
🔧 Common Issues & Solutions:
  • "gpg: keyserver receive failed": Use --keyserver hkps://keys.openpgp.org or skip keyserver steps for lab
  • "openssl enc: unknown option -aes-256-gcm": You're using password mode; switch to cms or raw-key mode with -K/-iv
  • "shred: command not found": Install coreutils or use rm -P (less secure) for lab
  • Slow key generation: Install rng-tools and run sudo rngd -r /dev/urandom to speed entropy
  • Passphrase forgotten: Lab keys can be deleted; in production, revocation certs are essential

🏆 CEH v13 Cryptographic Best Practices Summary

  • ✅ Algorithm Selection: SHA-256/SHA3, AES-256, RSA-4096/ECC, HMAC-SHA256
  • ✅ Key Management: PBKDF2 (≥10k iterations), unique keys per purpose, secure storage
  • ✅ Integrity + Confidentiality: Always combine encryption with HMAC or use AEAD modes
  • ✅ Verification: Verify hashes/HMACs/signatures BEFORE trusting data
  • ✅ Secure Cleanup: Use shred -u for sensitive files; never rely on rm alone
  • ✅ Documentation: Log cryptographic operations (without exposing keys) for audit trails
  • ✅ Stay Updated: Monitor NIST, OpenSSL, and GnuPG advisories for algorithm deprecations

🎓 Conclusion & Next Steps

You've now completed a comprehensive, executable cryptography lab aligned with CEH v13 objectives. You can:

  • Verify file integrity using modern hash functions
  • Authenticate messages with HMAC and shared secrets
  • Protect confidentiality with properly configured symmetric encryption
  • Implement public-key cryptography for secure communication and non-repudiation
  • Distinguish encoding from encryption in real-world scenarios
  • Apply defensive cryptographic practices in penetration testing engagements
🔐 Final Ethical Reminder: Cryptographic skills are powerful. Use them to:
  • Strengthen organizational security postures
  • Identify and responsibly disclose cryptographic vulnerabilities
  • Educate teams on secure implementation practices
  • Comply with legal frameworks (CFAA, GDPR, local cyber laws)
Never use these techniques to access, modify, or exfiltrate data without explicit, documented authorization.
📚 Recommended CEH v13 Study Extensions:
  1. Explore hashcat for password cracking labs (ethical scope only)
  2. Practice TLS handshake analysis with openssl s_client
  3. Implement cryptographic checks in Python using cryptography library
  4. Review OWASP Cryptographic Storage Cheat Sheet for web app contexts
  5. Study real-world breaches caused by crypto misconfigurations (e.g., Heartbleed, ROCA)
Modules (130) ← CEH — Ethical Hacking