☁️ OSCP (PEN-200) - Exam-Prep
Free exam-prep for OSCP (PEN-200), signed certificate $5. Learn the modules, pass the 10-question exam, EN/FR, no account.
Last updated: June 2026
For aspiring penetration testers preparing for OffSec's 24-hour hands-on OSCP exam: master enumeration, exploitation, privilege escalation, and Active Directory attacks end-to-end. The course is organized into 13 modules, ending with a final exam (pass mark 70%). It is independent, free exam-preparation training — not an official or accredited review course.
What you'll learn
- Penetration Testing Methodology & Report Writing
- Information Gathering: Passive & Active Enumeration
- Web Application Attacks: SQLi, XSS, Command Injection, Traversal & File Uploads
- Locating, Fixing & Using Public Exploits
- Common Services Enumeration & Exploitation: SMB, FTP, SSH, SNMP
- Password Attacks & Cracking
- Client-Side Attacks
- Linux Privilege Escalation
- Windows Privilege Escalation
- Antivirus Evasion
- Port Redirection, Tunneling & Pivoting
- Active Directory Enumeration & Attacks
- The OSCP Exam: Standalone Machines & the Active Directory Set Methodology
Learning objectives
- Build a methodical penetration testing workflow: passive and active information gathering, enumeration, and scoping.
- Discover and exploit common web application vulnerabilities (SQL injection, XSS, command injection, directory traversal, file uploads).
- Identify network services, locate public exploits, and adapt/fix exploit code to gain initial access.
- Perform Linux and Windows privilege escalation through systematic local enumeration.
- Conduct full Active Directory attacks: enumeration, lateral movement, and domain compromise.
- Apply password attacks, client-side attacks, and antivirus evasion techniques.
- Use port redirection, tunneling, and pivoting to reach internal hosts.
- Document findings and produce a professional, exam-quality penetration test report.
Course facts
- Estimated study time
- about 3 hours
- Final assessment
- 120 questions · Pass mark 70%
- Available in
- English, Français
- Price
- Free. Optional verifiable certificate: $5
- Last updated
- Published by
- AMAADOR ACADEMY
Course content
1. Penetration Testing Methodology & Report Writing
A penetration test is an authorized, goal-driven simulation of a real attacker against an agreed scope. The OSCP body of knowledge treats methodology and documentation as first-class skills: in the exam you must compromise machines and deliver a professional report. Reports submitted late, or that omit required evidence, score zero regardless of how many machines fell. Method and documentation are therefore inseparable.
Why a Repeatable Methodology Matters
Ad-hoc hacking misses attack surface and wastes the clock. A structured cycle ensures coverage, reproducibility, and a clean audit trail. The PEN-200 approach maps loosely to industry standards (PTES, OSSTMM, NIST SP 800-115, the OWASP Testing Guide) but is pragmatic and offensive in flavor.
Exam rule of thumb: spend ~70% of time on enumeration. "Enumerate, enumerate, enumerate" is the unofficial OSCP motto. Most stuck candidates are missing a port, a vhost, or a default credential — not an exploit.
The Enumeration-First Cycle
Every new shell or credential restarts the cycle. After landing on a host, you re-enumerate locally (users, services, scheduled tasks, sudo rights) as if it were a fresh target.
2. Information Gathering: Passive & Active Enumeration
Information gathering is the foundation of every penetration test. In the PEN-200 methodology it is the first technical phase after scoping, and the OSCP exam rewards candidates who enumerate thoroughly before they ever launch an exploit. The mantra repeated throughout the course is blunt: "Enumeration is the key." Roughly 80% of your time on a box should be spent finding attack surface; the actual exploit is often the short part.
Passive vs. Active: the core distinction
The two halves of this chapter differ in one thing — whether you touch the target. Passive information gathering (OSINT) collects data without sending packets to the target's infrastructure; you query third parties (search engines, WHOIS registries, certificate logs, DNS records held by others). Active information gathering sends traffic directly to the target — DNS zone transfers, port scans, banner grabs, service probes — and is therefore noisier and may be logged.
Passive (OSINT)
- No direct contact with target hosts
- WHOIS, Google dorks, Shodan, crt.sh, theHarvester
- Hard to detect; legally lower-risk
Active
- Direct packets to target (scans, probes)
- Nmap, dig AXFR, nbtscan, enum4linux, gobuster
- Generates logs/IDS alerts; needs authorisation
3. Web Application Attacks: SQLi, XSS, Command Injection, Traversal & File Uploads
Web applications dominate the modern attack surface. In a hands-on penetration test, web flaws are frequently the initial foothold that turns an external IP into a shell. This chapter dissects the five input-handling vulnerability classes you must master: SQL injection (SQLi), cross-site scripting (XSS), OS command injection, directory (path) traversal, and insecure file uploads. They share one root cause: untrusted input crossing a trust boundary without proper validation or context-aware encoding.
Methodology first. Always map the app before attacking it: enumerate the technology stack, directories, parameters, forms, cookies, and headers. A directory buster reveals hidden endpoints; an intercepting proxy lets you tamper with every request. Treat every GET/POST parameter, header, and cookie as an injection candidate.
1. SQL Injection (SQLi)
SQLi occurs when user input is concatenated into a SQL query. The classic auth-bypass payload ' OR 1=1-- makes a WHERE clause always true. The trailing space after -- matters in MySQL.
Blind SQLi returns no visible data, so you infer it. Boolean-based blind toggles a true/false condition and watches the page. Time-based blind uses SLEEP(5) (MySQL) or WAITFOR DELAY '0:0:5' (MSSQL) and measures the delay. Always identify the DBMS first — comment syntax and string functions differ.
4. Locating, Fixing & Using Public Exploits
Once enumeration reveals a service, version, or CMS plugin, the next move is finding a matching public exploit, vetting it, repairing it, and firing it safely. On the OSCP exam this skill separates candidates who flag a vulnerability from those who actually land a shell. Most public proof-of-concept (PoC) code is fragile: it targets one specific build, hardcodes an attacker IP, assumes a stale offset, or is written for a different OS. Your job is to read the code, understand what it does, and make it work in your environment.
Where to look
- SearchSploit — the offline mirror of Exploit-DB, pre-installed on Kali. Works without internet, which mirrors exam constraints.
- Exploit-DB (online) — same database with a web UI and the EDB-ID reference number.
- GitHub / GitLab — newer PoCs, often more reliable than aging EDB entries.
- Vendor advisories / CVE pages — confirm affected versions before you waste time.
SearchSploit workflow (worked example)
Search hygiene: SearchSploit does AND matching across terms. Search broadly (searchsploit apache 2.4), not with overly long strings. Use -t to search titles only and cut noise. Strip the patch level when the kernel/app version doesn't match exactly — a 5.8.0 exploit may still work on 5.8.x.
5. Common Services Enumeration & Exploitation: SMB, FTP, SSH, SNMP
Chapter 5 of 13 · Hands-on enumeration of the four services that most often hand you a foothold on the OSCP exam. Practice in a lab you own; this material is for authorized testing only.
Why this chapter matters. On the exam, the difference between a stuck candidate and a passing one is rarely an exotic exploit — it is thorough enumeration. SMB, FTP, SSH and SNMP are the "bread and butter" services. Each leaks information that, chained together, reveals usernames, shares, software versions, and sometimes credentials in clear text. Enumerate before you exploit.
The port map you must memorize
| Service | Port(s) | Proto | Primary leak |
|---|---|---|---|
| SMB / NetBIOS | 445, 139, 137/138 | TCP/UDP | Shares, users, OS, null sessions |
| FTP | 21 (data 20) | TCP | Anonymous access, banners, file read/write |
| SSH | 22 | TCP | Version, auth methods, weak/keys |
| SNMP | 161 (traps 162) | UDP | Community strings → full MIB walk |
SMB (445/139) — the richest target
Start with nmap -p139,445 --script smb-os-discovery,smb-enum-shares,smb-enum-users,smb-protocols TARGET to fingerprint the OS and list shares. Then enumerate interactively:
Exam trap — EternalBlue tunnel vision. Candidates instinctively reach for MS17-010. It is valid only when the version matches (unpatched Windows 7 / Server 2008) and the script confirms it: nmap --script smb-vuln-ms17-010. Do not burn 40 minutes forcing an exploit a patched host will never accept. Confirm vulnerability first.
6. Password Attacks & Cracking
Passwords remain the weakest link in most environments. In a PEN-200 style engagement you will harvest hashes, crack them offline, spray weak credentials online, and reuse recovered material to pivot. This chapter covers the full workflow: the attack surface, hash formats, the tooling (Hydra, John the Ripper, Hashcat), wordlist and rule strategy, and the operational pitfalls that get candidates locked out or flagged.
Online vs offline attacks
The first decision is where the guessing happens. Online attacks send guesses to a live service (SSH, RDP, SMB, HTTP login, FTP). They are slow, noisy, and trip account lockouts. Offline attacks run against captured hashes on your own hardware at millions or billions of guesses per second, with no lockout and no network noise.
Prefer offline
- No lockout policy, no logs on target
- GPU speed: NTLM > 100 GH/s on commodity cards
- Unlimited retries and rule mutations
Online caveats
- Lockout after 3–5 fails (default AD: 5)
- SIEM alerts on auth spikes
- Throttle and target ONE password across many users (spraying)
Exam trap: Brute-forcing many passwords against one account locks it out and can fail the engagement objective. For domain accounts, password spraying (one password, many users, then wait) respects lockout windows. Always read the lockout policy before any online attack.
7. Client-Side Attacks
When a target exposes no reachable network service, the human operating it becomes the attack surface. Client-side attacks trick a user into running attacker code by abusing the applications on their workstation: browsers, Office, PDF readers, media players, and the OS itself. This chapter mirrors how the OSCP body of knowledge frames the topic — reconnaissance of client software, then delivery via documents and other vectors.
Why client-side?
Modern perimeters are hardened: patched, firewalled, minimal services. The realistic foothold is often a phishing email that lands a payload inside an internal user's session. The user's process makes the outbound connection, which sails through egress firewalls that block inbound traffic. This is why client-side tradecraft is a graded skill on the exam — you must be able to weaponize a document and catch a reverse shell.
Core idea: You are not exploiting a server — you are persuading a person. Pretext quality (a believable sender, subject, and lure) matters as much as the payload.
The attack flow
Client information gathering
Before crafting a payload you fingerprint the victim's software. A passive technique is to host a web page and entice the target to visit it — the User-Agent string leaks OS and browser, and embedded resources can probe for installed plugins. Active recon uses pretext emails that request a reply or trigger a tracking pixel.
8. Linux Privilege Escalation
After landing an initial foothold as a low-privileged user (often www-data or a service account), your goal is to reach root (UID 0). Linux privilege escalation is the systematic art of finding a misconfiguration, weak permission, or vulnerable component that lets an unprivileged user execute code or read files in a higher security context. On the exam this is frequently the difference between a foothold and a full proof file.
The golden rule: enumerate before you exploit
Most failed escalations come from skipping enumeration. Always stabilize your shell first (python3 -c 'import pty;pty.spawn("/bin/bash")', then export TERM=xterm), then gather context manually before reaching for automated scripts.
Manual enumeration baseline
id/whoami/groups— current context and group memberships (e.g.docker,lxd,disk,admgroups are escalation vectors).sudo -l— what you can run as another user, often without a password.uname -a/cat /etc/os-release— kernel and distro version for kernel exploits.find / -perm -4000 -type f 2>/dev/null— list SUID binaries.cat /etc/crontab&ls -la /etc/cron.*— scheduled jobs.netstat -tulnp/ss -tulnp— internal services bound to localhost.
9. Windows Privilege Escalation
You landed a low-privilege shell on a Windows host as iis apppool\web or a standard domain user. Windows privilege escalation is the art of turning that foothold into NT AUTHORITY\SYSTEM or a local administrator. The exam rewards methodical enumeration over reflex exploit-firing: most boxes fall to a misconfiguration you can read in plaintext, not a memory-corruption 0-day.
The enumeration-first mindset
Golden rule: enumerate fully before you exploit. Run whoami /priv, whoami /groups, systeminfo, and an automated script (winPEAS, PowerUp, Seatbelt) and read the output. Privilege escalation is a data problem: the path is almost always sitting in the output you already collected.
Token privileges — the fast lane to SYSTEM
The single most exam-relevant check is whoami /priv. Certain privileges held by a service account are effectively a key to SYSTEM regardless of the patch level:
| Privilege | Impact | Typical exploit |
|---|---|---|
SeImpersonatePrivilege | Impersonate clients after authentication | Potato family (JuicyPotato, PrintSpoofer, GodPotato) |
SeAssignPrimaryToken | Assign a primary token to a process | RoguePotato / token tools |
SeBackupPrivilege | Read any file (bypass DACLs) | Dump SAM/SYSTEM/NTDS hives |
SeRestorePrivilege | Write any file / registry key | Overwrite service binaries, DLL hijack |
SeDebugPrivilege | Open any process | Migrate into / dump lsass |
SeTakeOwnership | Take ownership of objects | Hijack protected files/keys |
10. Antivirus Evasion
Antivirus (AV) and Endpoint Detection and Response (EDR) software stand between your payload and a shell. On real engagements and in the exam labs, a perfectly functional Meterpreter binary that gets quarantined the instant it touches disk is worthless. This chapter explains how detection works, the families of evasion you must understand, and a disciplined workflow for getting trusted code execution past a defender without triggering an alert.
Authorization first. Evasion techniques are dual-use. Only run them against systems you are explicitly contracted to test (a signed scope/RoE) or against lab machines you own. Generating and deploying malware outside that boundary is a crime in most jurisdictions.
How AV detection actually works
You cannot evade what you do not understand. Modern endpoint products layer several detection engines, and bypassing one does not bypass the others.
| Engine | What it inspects | Beaten by |
|---|---|---|
| Signature / pattern | Static byte sequences, hashes, known strings | Encoding, encryption, recompiling, unique code |
| Heuristic / static | Suspicious API imports, entropy, packers | Lowering entropy, indirect API resolution |
| Emulation / sandbox | Detonates the file in a virtual CPU | Sleep, environment checks, stalling code |
| Behavioral / dynamic | Runtime API calls, injection, child processes | Living-off-the-land, in-memory execution |
| Cloud / reputation | Telemetry, hash lookup, ML scoring | Fresh artifacts, signed/aged binaries |
11. Port Redirection, Tunneling & Pivoting
Once you compromise a foothold host, you almost never reach the whole network from your attacking box. Internal subnets, firewalled services, and dual-homed machines sit behind that first victim. Pivoting is the art of routing your traffic through a compromised host to reach networks you cannot touch directly. This is one of the most weighted skills on the exam: the lab is explicitly built so that the high-value targets live on segments only reachable after you tunnel through an initial host.
Core Vocabulary
- Port forwarding / redirection: a fixed mapping — one local port carries traffic to one remote host:port.
- Tunneling: wrapping one protocol inside another (often to bypass egress filtering) — e.g. carrying TCP inside SSH or HTTP.
- SOCKS proxy: a dynamic, application-agnostic proxy. One listener can reach any host:port behind the pivot — the gold standard for pivoting.
- Local vs Remote: a local forward opens a port on YOUR machine; a remote forward opens a port on the FAR side.
The mental model: Ask two questions every time. (1) Where does the listener open? (2) Which direction is the connection initiated? Most failures come from confusing the side that listens with the side that connects.
12. Active Directory Enumeration & Attacks
Active Directory (AD) is Microsoft's directory service that centralises authentication and authorisation for Windows networks. On PEN-200 it is the largest single domain in the exam: the lab and the OSCP machine set frequently require you to compromise a domain after a foothold on a single host. AD attacks reward methodical enumeration over noisy exploitation — most domains fall to misconfiguration and credential reuse, not memory-corruption exploits.
Core concepts you must know
- Domain / Forest / OU — the security boundary is the forest, not the domain.
- Domain Controller (DC) — hosts the
NTDS.ditdatabase with every account hash. - Authentication — Kerberos (default) and NTLM (legacy fallback).
- SPN (Service Principal Name) — links a service to an account; central to Kerberoasting.
- krbtgt — the account whose hash signs all TGTs; owning it means a Golden Ticket.
Kerberos in one breath: client asks the KDC (AS-REQ) and gets a TGT encrypted with the krbtgt hash (AS-REP). To reach a service it presents the TGT (TGS-REQ) and gets a service ticket (TGS-REP) encrypted with the service account's hash. That last fact is exactly what makes Kerberoasting work.
13. The OSCP Exam: Standalone Machines & the Active Directory Set Methodology
The OSCP practical exam is a 23 hour 45 minute hands-on penetration test followed by a 24 hour reporting window. The network is split into two scoring blocks: an Active Directory (AD) set worth 40 points and three independent standalone machines worth 20 points each (60 total). You need 70 of 100 points to pass. This chapter gives you the exact methodology to allocate time, harvest points, and avoid the failures that sink otherwise-capable candidates.
Exam Scoring at a Glance
| Block | Components | Points | Partial credit? |
|---|---|---|---|
| AD Set | 2 clients + 1 Domain Controller | 40 | 10 / 10 / 20 (client1, client2, DC) |
| Standalone 1 | local.txt + proof.txt | 20 | 10 local / 10 root |
| Standalone 2 | local.txt + proof.txt | 20 | 10 local / 10 root |
| Standalone 3 | local.txt + proof.txt | 20 | 10 local / 10 root |
The 40-Point Truth About the AD Set
The single most important number on the exam: the AD set is chained. You compromise an initial foothold host, harvest credentials, pivot laterally, and ultimately own the Domain Controller. Current OSCP+ scoring awards points per machine compromised (10 for the first host, 10 for the second, 20 for the DC), so a half-finished AD set still yields points — but a clean 40 is the fastest route to 70.
The full lesson continues in the interactive course on this page.