OSCP Certification Guide: How to Prepare and Pass in 2026
At 3:47 AM on day two of my first OSCP attempt, I was staring at a shell that had just died. I had spent 14 hours on a single machine, exhausted, dehydrated, and questioning every life choice that led me to this moment. I failed that attempt with 65 points β just 5 short of passing.
Three months later, I passed on my second attempt with 85 points. The difference wasn't raw technical skill. It was methodology, time management, and report writing discipline.
As a tutor who has now guided over 200 students through the OSCP (PEN-200) journey, I can tell you this: the OSCP is not a test of genius β it is a test of persistence, process, and preparation. The candidates who fail are rarely the least talented. They are the ones who skipped the labs, didn't document their work, or ran out of time because they chased the wrong machines.
This guide is everything I wish I had before my first attempt. It covers the exam structure, a battle-tested 12-week study plan, the Active Directory attack methodology that will secure you 40+ points, report writing templates, and the mental game that separates those who pass from those who burn out.
- Exam Duration: 23 hours 45 minutes (exam) + 24 hours (report)
- Passing Score: 70 points out of 100
- AD Set Requirement: Minimum 20 points from the 40-point AD set
- First-Attempt Pass Rate: Estimated 30-40% (without structured prep)
- With Structured Prep: 75-85% pass rate within 2 attempts
- Average Study Time: 12-16 weeks (15-20 hours/week)
- Course Cost: $1,649 (90-day lab access) to $2,499 (1-year access)
- Exam Retake Cost: $249 per attempt
- Global Recognition: Considered the gold standard for entry-level penetration testing
- What is the OSCP? The reality check
- Exam structure β exactly what you face
- Prerequisites β what you need before starting
- PEN-200 course breakdown β module by module
- The 12-week study plan that works
- Essential tools and your Kali setup
- The enumeration-to-exploitation methodology
- Active Directory attack paths β the 40-point set
- Report writing β where most candidates fail
- Exam day strategy β hour by hour
- Common mistakes that cause failure
- After OSCP β career paths and next certs
- First actions β start today
- Frequently asked questions
1. What is the OSCP? The reality check
The Offensive Security Certified Professional (OSCP) is a hands-on, practical penetration testing certification offered by Offensive Security. Unlike multiple-choice exams, the OSCP requires you to actually hack into machines in a private network, document your process, and write a professional penetration testing report.
It is earned by completing the PEN-200 (Penetration Testing with Kali Linux) course and passing the grueling 24-hour practical exam. The certification is widely considered the gold standard for entry-level penetration testers and is a requirement for many red team, pentest, and security consulting roles.
2. Exam structure β exactly what you face
Understanding the exam structure is non-negotiable. Every minute of your 23 hours 45 minutes must be allocated strategically.
| Component | Points | Details |
|---|---|---|
| AD Set Active Directory Set | 40 points | A multi-machine Active Directory environment. You must compromise the entire domain. Minimum 20 points required from this set β even if you score 100 on standalone machines, you fail without 20 from AD. |
| Standalone 1 | 20 points | Independent machine β typically medium difficulty. Often involves web exploitation, misconfigurations, or known CVEs. |
| Standalone 2 | 20 points | Independent machine β variable difficulty. May involve buffer overflow (if still in exam), or complex privilege escalation. |
| Standalone 3 | 20 points | Independent machine β often the hardest. May require chaining multiple vulnerabilities. |
| Report Penetration Testing Report | Bonus/Critical | You have 24 hours after the exam ends to submit a professional report. A poor report can cause you to fail even with sufficient points. |
3. Prerequisites β what you need before starting
Offensive Security lists no formal prerequisites for the OSCP, but as a tutor, I strongly recommend you have the following before enrolling in PEN-200:
π΄ Non-Negotiable Skills
- Linux Command Line Fluency: You must be comfortable navigating Linux, editing files, managing processes, and scripting in Bash. You will live in the terminal for 23 hours.
- Basic Networking Knowledge: TCP/IP, DNS, HTTP, SMB, common ports (21, 22, 80, 443, 445, 3389), and how to read Nmap output.
- Python or Bash Scripting: You need to read and modify exploits. You don't need to be a developer, but you must understand scripts well enough to adapt them.
- Basic Windows Administration: Active Directory concepts, PowerShell basics, Windows privilege model.
π‘ Recommended Prior Experience
- CompTIA Network+ or equivalent β solid networking foundation
- CompTIA Security+ or eJPT β basic security concepts
- 50+ machines on TryHackMe or HackTheBox β hands-on practice
- Comfortable with Burp Suite, Nmap, Netcat, and Metasploit (limited use)
4. PEN-200 course breakdown β module by module
The PEN-200 course is your primary study material. Here is how the modules map to exam relevance:
| Module | Exam Relevance | Study Priority |
|---|---|---|
| Information Gathering | βββββ | CRITICAL Foundation of every attack |
| Vulnerability Scanning | ββββ | HIGH Identifies attack vectors |
| Web Application Attacks | βββββ | CRITICAL Appears in almost every exam |
| Client-Side Attacks | βββ | MEDIUM Less common now but still tested |
| Locating and Exploiting Automated Security Controls | ββ | LOW Rarely tested directly |
| Antivirus Evasion / EDR Bypass | ββ | LOW Not a focus in current exam |
| Privilege Escalation (Linux & Windows) | βββββ | CRITICAL Required for every machine |
| Active Directory Enumeration and Attacks | βββββ | CRITICAL The 40-point AD set depends on this |
| Password Attacks | ββββ | HIGH Often the initial foothold |
| Port Redirection and Tunneling | ββββ | HIGH Required for pivoting in AD |
| The Metasploit | ββ | LOW Heavily restricted in exam |
| Bypassing Security Controls / Evasion | ββ | LOW Not a primary focus |
| Reporting | βββββ | CRITICAL Your report is graded |
5. The 12-week study plan that works
This plan assumes you have the prerequisites above and are committing 15-20 hours per week. Adjust as needed, but do not compress below 10 weeks.
| Week | Focus | Activities | Lab Target |
|---|---|---|---|
| Week 1-2 | Foundation & Information Gathering | Complete PEN-200 modules on recon, scanning, and basic exploitation. Master Nmap, Gobuster, Burp Suite. | 10 easy lab machines |
| Week 3-4 | Web Application Attacks | SQL injection, XSS, file upload, authentication bypass, command injection. Practice on PortSwigger Academy. | 10 medium lab machines |
| Week 5-6 | Privilege Escalation | Linux (LinPEAS, SUID, cron, kernel exploits) and Windows (WinPEAS, Potato attacks, token impersonation). | 15 lab machines with privesc focus |
| Week 7-8 | Active Directory Attacks | Kerberoasting, AS-REP roasting, delegation attacks, Pass-the-Hash, Golden/Silver tickets, BloodHound. | 3-4 AD sets in labs |
| Week 9-10 | Pivoting & Tunneling | Chisel, Ligolo-ng, SSH tunneling, SOCKS proxies. Practice attacking through compromised hosts. | 5 complex lab machines |
| Week 11 | Mock Exams | Run 2 full 24-hour mock exams using HackTheBox Pro Labs (Dante, RastaLabs, or Offshore). | 2 full mock exams |
| Week 12 | Report Writing & Review | Write reports for all mock exams. Review weak areas. Rest 2 days before the real exam. | 2 polished reports |
6. Essential tools and your Kali setup
Your Kali Linux VM is your weapon. Configure it properly before exam day.
π§ Must-Have Tools
- Nmap: Your primary enumeration tool. Learn every important flag.
- Burp Suite Community/Pro: Web application testing. Learn Intruder, Repeater, and Proxy.
- Netcat / Socat: Reverse shells, port forwarding, file transfer.
- Impacket Suite: Essential for Active Directory attacks (secretsdump.py, psexec.py, GetNPUsers.py).
- BloodHound: AD attack path mapping. Learn it inside out.
- CrackMapExec / NetExec: AD enumeration and lateral movement.
- Chisel / Ligolo-ng: Pivoting and tunneling.
- John the Ripper / Hashcat: Password and hash cracking.
- LinPEAS / WinPEAS: Privilege escalation enumeration.
- Python 3 + pip: For running and modifying exploits.
- Go: Many modern tools (Chisel, Ligolo) are written in Go.
βοΈ Pre-Exam Setup Checklist
# Update everything sudo apt update && sudo apt full-upgrade -y
# Install essential tools sudo apt install -y bloodhound netexec chisel ligolo-ng
# Install Impacket from source (latest version) cd /opt sudo git clone https://github.com/fortra/impacket.git cd impacket sudo pip3 install .
# Set up your reporting template mkdir ~/oscp-report-template
# Copy the official Offensive Security report template here
# Configure your shell aliases for speed cat >> ~/.zshrc << 'EOF' alias nmap-full='nmap -sC -sV -p- -T4 -oN' alias nmap-udp='nmap -sU --top-ports 100 -oN' alias gobuster='gobuster dir -w /usr/share/wordlists/dirb/common.txt -u' alias pyhttp='python3 -m http.server 80' alias pyftp='python3 -m pyftpdlib -p 21' alias lsn='rlwrap nc -lvnp' EOF source ~/.zshrc
# Test your reverse shell one-liners # Have 5-6 variants ready (bash, python, powershell, nc, perl)
7. The enumeration-to-exploitation methodology
Every successful OSCP candidate follows a methodical process. Wing-it hackers fail. Here is the methodology I teach every student:
π Phase 1: Enumeration (40% of your time)
# Step 2: Identify interesting services
# Look for: web servers, SMB, SSH, FTP, RDP, unusual ports
# Step 3: Deep enumeration of each service
# Web: Gobuster/FFUF for directories, check for known CVEs gobuster dir -u http://<target> -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -x php,html,txt
# SMB: Enum4linux, smbclient enum4linux -a <target-ip> smbclient -L //<target-ip> -N
# SNMP: snmpwalk snmpwalk -c public -v1 <target-ip>
# Step 4: Document EVERYTHING in your notes # Use CherryTree, Obsidian, or Notion
π₯ Phase 2: Initial Foothold (30% of your time)
- Try every obvious attack vector from enumeration
- Check for default credentials (admin:admin, root:root)
- Search for exploits on Exploit-DB, GitHub, and searchsploit
- Try public exploits β but read the code first
- Get a reverse shell β have 5+ variants ready
π Phase 3: Privilege Escalation (20% of your time)
- Linux: Run LinPEAS, check SUID binaries, sudo -l, cron jobs, writable /etc/passwd
- Windows: Run WinPEAS, check AlwaysInstallElevated, token impersonation, unquoted service paths
- Both: Check kernel version for known exploits, look for credentials in config files
π Phase 4: Documentation (10% of your time β ongoing)
- Take screenshots constantly β every command, every shell, every proof file
- Use
scriptcommand to log your terminal sessions - Capture proof files (
proof.txt,local.txt) immediately - Write your report sections as you go, not at the end
8. Active Directory attack paths β the 40-point set
The AD set is where most candidates either secure their pass or fail. Here is the attack methodology that will get you 40 points.
π― The AD Kill Chain
# - Web app vulnerability β shell on a domain-joined machine
# - Credential stuffing from found passwords
# - SMB share with credentials
# Step 2: Domain Enumeration
# On the compromised machine, run: powershell -ep bypass Import-Module .\PowerView.ps1 Get-DomainUser | Select samaccountname, description Get-DomainComputer | Select name, operatingsystem Get-DomainGroupMember "Domain Admins"
# Or use BloodHound (preferred) SharpHound.exe -c All -d <domain> --zip
# Step 3: Credential Harvesting
# Kerberoasting - find users with SPNs GetUserSPNs.py -dc-ip <dc-ip> <domain>/<user>:<pass> -request
# AS-REP Roasting - users without Kerberos pre-auth GetNPUsers.py <domain>/ -usersfile users.txt -format hashcat
# Dump hashes with secretsdump secretsdump.py <domain>/<user>:<pass>@<dc-ip>
# Step 4: Lateral Movement # Pass-the-Hash with psexec psexec.py -hashes <lmhash>:<nthash> <domain>/<user>@<target-ip>
# WMI execution wmiexec.py <domain>/<user>:<pass>@<target-ip>
# Step 5: Privilege Escalation to Domain Admin
# - Kerberos delegation attacks
# - ACL abuse (writeDACL, GenericAll)
# - DCSync with rights secretsdump.py -just-dc <domain>/<user>@<dc-ip>
# Step 6: Golden Ticket (persistence) ticketer.py -nthash <krbtgt-hash> -domain-sid <sid> -domain <domain> <user>
π Top 5 AD Attacks You Must Master
| Attack | When to Use | Tool |
|---|---|---|
| Kerberoasting | You have a domain user account | GetUserSPNs.py, Rubeus |
| AS-REP Roasting | Users without Kerberos pre-authentication | GetNPUsers.py, Rubeus |
| Pass-the-Hash | You have NTLM hashes but not plaintext passwords | psexec.py, wmiexec.py |
| ACL Abuse | You have unusual permissions over AD objects | BloodHound, PowerView, aclpwn |
| DCSync | You have rights to replicate directory data | secretsdump.py, mimikatz |
9. Report writing β where most candidates fail
The OSCP report is not an afterthought. It is a graded component of your exam. A poorly written report can fail you even if you compromised every machine.
π Report Structure (Follow This Exactly)
- Executive Summary: 1-page overview for management. No technical jargon.
- Methodology: Describe your approach (enumeration, exploitation, post-exploitation).
- Findings (per machine):
- High-level overview
- Detailed technical steps with every command and every screenshot
- Proof files (content of proof.txt, local.txt)
- Initial shell screenshots (with IP visible)
- Root/system shell screenshots
- Remediation Summary: Specific recommendations per vulnerability.
- Appendix: Additional evidence, tool outputs.
π΄ Critical Report Rules
- Every screenshot must show the target IP β include your Kali IP in the screenshot
- Include the full command AND the output β no screenshots of partial output
- Proof files must be visible β cat proof.txt with the IP in the terminal
- No missing steps β if you ran 20 commands to get root, show all 20
- Use the official Offensive Security template β do not create your own
- Spell-check and grammar-check β typos look unprofessional
10. Exam day strategy β hour by hour
The OSCP is a marathon, not a sprint. Here is how I teach students to allocate their 23 hours 45 minutes.
| Time Block | Activity | Goal |
|---|---|---|
| Hours 0-1 | Initial scan of ALL machines. Full Nmap on everything. | Map the battlefield. Identify easy targets. |
| Hours 1-3 | Attack the easiest standalone machine first. | Secure 20 points early. Build confidence. |
| Hours 3-8 | Focus on the AD set. Get initial foothold, enumerate domain. | Secure at least 20 AD points (mandatory requirement). |
| Hours 8-12 | Continue AD set. Complete domain compromise if possible. | Push for full 40 AD points. |
| Hours 12-14 | SLEEP. Seriously. Take a 90-minute nap. | Reset your brain. You will solve problems you missed. |
| Hours 14-18 | Attack remaining standalone machines. | Secure the remaining points you need. |
| Hours 18-21 | Final push on any stuck machines. Try alternative vectors. | Squeeze out every possible point. |
| Hours 21-23:45 | Finalize report. Ensure all screenshots are in place. | Submit exam before time runs out. |
11. Common mistakes that cause failure
| Mistake | Why It Kills You | The Fix |
|---|---|---|
| Not enough lab time | Theory doesn't translate to exam pressure. You freeze. | Complete 40+ lab machines before scheduling the exam. |
| Ignoring the AD set | You can't pass without 20 AD points, period. | Spend 40% of your study time on AD attacks. |
| Poor documentation | You can't reproduce steps in the report. | Screenshot everything. Use script command. Write as you go. |
| Not sleeping during the exam | Cognitive decline after hour 12. You miss obvious things. | Take a 90-minute nap. Set 3 alarms. Your brain needs it. |
| Tunnel vision on one machine | You waste 8 hours on a hard machine while easy ones sit untouched. | Time-box every machine. 3-4 hours max before switching. |
| Relying on Metasploit | It's restricted. You'll be lost when you need manual exploitation. | Practice manual exploitation on every lab machine. |
| Panic and giving up | You hit a wall and assume you've failed. | Every candidate hits a wall. Take a walk, eat, reset, try again. |
| Submitting a sloppy report | Missing screenshots, incomplete steps = failed exam. | Start the report during the exam. Review it 3 times before submission. |
12. After OSCP β career paths and next certs
Passing the OSCP opens doors. Here is what comes next.
πΌ Job Roles Unlocked by OSCP
- Penetration Tester: $85,000 - $140,000 (US average)
- Red Team Operator: $110,000 - $170,000
- Security Consultant: $95,000 - $150,000
- Vulnerability Researcher: $120,000 - $180,000
- SOC Analyst (Tier 3): $90,000 - $130,000
π Next Certifications After OSCP
| Certification | Focus | Difficulty | Timeline After OSCP |
|---|---|---|---|
| OSEP (PEN-300) | Advanced evasion, red team ops | Very High | 6-12 months |
| OSWE (WEB-300) | Advanced web app, white-box testing | Very High | 6-12 months |
| CRTO (Zero-Point Security) | Red team ops with Cobalt Strike | High | 3-6 months |
| PNPT (TCM Security) | Practical pentesting, great for OSINT | Moderate | 2-4 months |
| CISSP | Security management (with 5 years exp) | Moderate (theory-heavy) | 2-3 years (needs experience) |
β‘ Start your OSCP journey β first five actions
- Assess your baseline this week. Try 5 machines on TryHackMe's "Offensive Pentesting" path. If you can't complete at least 2 without help, spend 4-6 weeks building fundamentals before enrolling in PEN-200.
- Set up your Kali lab today. Install Kali Linux (VM or bare metal), configure your tools, and start building muscle memory. Your Kali environment should feel like an extension of your hands by exam day.
- Enroll in PEN-200 when you're ready. The 90-day lab access is enough for most prepared candidates. If you need more time, the 1-year option is worth the extra cost for peace of mind.
- Start a hacking journal. Document every machine you compromise β tools used, commands run, what worked, what didn't. This becomes your personal reference guide and builds report-writing habits.
- Join the community. The Offensive Security Discord, Reddit r/oscp, and local hacking meetups are invaluable. You will get stuck β having a community to ask questions (without asking for spoilers) is critical.
13. Frequently asked questions
How hard is the OSCP exam?
The OSCP is considered one of the most challenging entry-level penetration testing certifications. The 23-hour 45-minute practical exam tests real-world exploitation skills under extreme time pressure. First-attempt pass rates are estimated at 30-40%, but candidates who follow a structured 12-16 week study plan and complete 40+ lab machines typically pass on their first or second attempt. The difficulty is not the technical content β it is the mental endurance and time management required.
What is the OSCP exam structure in 2026?
The OSCP exam consists of an Active Directory set worth 40 points (you must score at least 20 from this set) and 3 standalone machines worth 20 points each. Total possible score is 100 points, and you need 70 points to pass. You have 23 hours and 45 minutes to complete the exam, followed by 24 hours to submit a professional penetration testing report. The AD set is mandatory β you cannot pass without at least 20 points from it.
Can I pass OSCP without the PEN-200 course?
Technically yes, but it is not recommended. The PEN-200 course material and lab access are specifically designed to prepare you for the exam. While platforms like HackTheBox and TryHackMe can supplement your training, the OSCP requires mastery of specific tools, methodologies, and Active Directory attack paths that are best learned through the official course. The lab environment also mimics the exam network, giving you crucial practice.
How long does it take to prepare for OSCP?
Most candidates with basic IT/security knowledge need 12-16 weeks of dedicated study (15-20 hours per week). Candidates with prior penetration testing experience may need only 6-8 weeks. Complete beginners should invest 20-24 weeks and build foundational skills in networking, Linux, and basic exploitation first. The key metric is not time β it is the number of machines you have successfully compromised (aim for 40-50+).
What is the OSCP report and how important is it?
The OSCP report is a professional penetration testing document you must submit within 24 hours of the exam ending. It is a critical component of your exam and must include detailed findings, screenshots of every exploitation step, proof files, and remediation recommendations. A poorly written report can cause you to fail even if you technically compromised all machines. Treat the report as seriously as the exam itself. Start writing it during the exam, not after.
Is Metasploit allowed in the OSCP exam?
Metasploit is heavily restricted in the OSCP exam. You may only use Metasploit modules against one specific target machine (typically a buffer overflow machine). For all other machines, you must use manual exploitation techniques with tools like Nmap, Burp Suite, Netcat, Python scripts, and custom exploits. This restriction is intentional to test your fundamental exploitation skills. Practice manual exploitation on every lab machine.
What if I fail the OSCP exam?
Don't panic β most successful OSCP holders failed at least once. Analyze your score report, identify which machines you missed, and understand why. Common failure patterns include: not enough lab time, poor AD skills, weak report writing, or time management issues. Address these gaps, book a retake ($249), and go again. The second attempt pass rate is significantly higher than the first.
How much does the OSCP cost?
The PEN-200 course with 90 days of lab access costs $1,649. The 1-year lab access option is $2,499 (recommended for most candidates). The exam attempt is included in the course price. If you fail and need to retake, each additional attempt costs $249. Factor in potential retakes when budgeting β most candidates spend $2,000-$3,000 total to earn the certification.
Written by the HOC Team at Hackers Online Club β a cybersecurity community trusted by penetration testers, red teamers, and security professionals since 2010. Learn more about HOC β