☁️ OSCP (PEN-200) - Exam-Prep
Home › Courses › OSCP (PEN-200) - Exam-Prep

☁️ 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)
Active

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

ServicePort(s)ProtoPrimary leak
SMB / NetBIOS445, 139, 137/138TCP/UDPShares, users, OS, null sessions
FTP21 (data 20)TCPAnonymous access, banners, file read/write
SSH22TCPVersion, auth methods, weak/keys
SNMP161 (traps 162)UDPCommunity 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
Online caveats

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

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:

PrivilegeImpactTypical exploit
SeImpersonatePrivilegeImpersonate clients after authenticationPotato family (JuicyPotato, PrintSpoofer, GodPotato)
SeAssignPrimaryTokenAssign a primary token to a processRoguePotato / token tools
SeBackupPrivilegeRead any file (bypass DACLs)Dump SAM/SYSTEM/NTDS hives
SeRestorePrivilegeWrite any file / registry keyOverwrite service binaries, DLL hijack
SeDebugPrivilegeOpen any processMigrate into / dump lsass
SeTakeOwnershipTake ownership of objectsHijack 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.

EngineWhat it inspectsBeaten by
Signature / patternStatic byte sequences, hashes, known stringsEncoding, encryption, recompiling, unique code
Heuristic / staticSuspicious API imports, entropy, packersLowering entropy, indirect API resolution
Emulation / sandboxDetonates the file in a virtual CPUSleep, environment checks, stalling code
Behavioral / dynamicRuntime API calls, injection, child processesLiving-off-the-land, in-memory execution
Cloud / reputationTelemetry, hash lookup, ML scoringFresh 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

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

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

BlockComponentsPointsPartial credit?
AD Set2 clients + 1 Domain Controller4010 / 10 / 20 (client1, client2, DC)
Standalone 1local.txt + proof.txt2010 local / 10 root
Standalone 2local.txt + proof.txt2010 local / 10 root
Standalone 3local.txt + proof.txt2010 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.

Official reference

Customize this training

Get a certificate — $15$5