IDOR Vulnerability Testing

IDOR Vulnerability Testing

Purpose

Provide systematic methodologies for identifying and exploiting Insecure Direct Object Reference (IDOR) vulnerabilities in web applications. This skill covers both database object references and static file references, detection techniques using parameter manipulation and enumeration, exploitation via Burp Suite, and remediation strategies for securing applications against unauthorized access.

Inputs / Prerequisites

Target Web Application: URL of application with user-specific resources

Multiple User Accounts: At least two test accounts to verify cross-user access

Burp Suite or Proxy Tool: Intercepting proxy for request manipulation

Authorization: Written permission for security testing

Understanding of Application Flow: Knowledge of how objects are referenced (IDs, filenames)

Outputs / Deliverables

IDOR Vulnerability Report: Documentation of discovered access control bypasses

Proof of Concept: Evidence of unauthorized data access across user contexts

Affected Endpoints: List of vulnerable API endpoints and parameters

Impact Assessment: Classification of data exposure severity

Remediation Recommendations: Specific fixes for identified vulnerabilities

Core Workflow

1. Understand IDOR Vulnerability Types

Direct Reference to Database Objects

Occurs when applications reference database records via user-controllable parameters:

# Original URL (authenticated as User A)
example.com/user/profile?id=2023
Manipulation attempt (accessing User B's data)

example.com/user/profile?id=2022

Direct Reference to Static Files

Occurs when applications expose file paths or names that can be enumerated:

# Original URL (User A's receipt)
example.com/static/receipt/205.pdf
Manipulation attempt (User B's receipt)

example.com/static/receipt/200.pdf

2. Reconnaissance and Setup

Create Multiple Test Accounts

Account 1: "attacker" - Primary testing account
Account 2: "victim" - Account whose data we attempt to access

Identify Object References

Capture and analyze requests containing:

Numeric IDs in URLs: /api/user/123

Numeric IDs in parameters: ?id=123&action=view

Numeric IDs in request body: {"userId": 123}

File paths: /download/receipt_123.pdf

GUIDs/UUIDs: /profile/a1b2c3d4-e5f6-...

Map User IDs

# Access user ID endpoint (if available)
GET /api/user-id/
Note ID patterns:

- Sequential integers (1, 2, 3...)

- Auto-incremented values

- Predictable patterns

3. Detection Techniques

URL Parameter Manipulation

# Step 1: Capture original authenticated request
GET /api/user/profile?id=1001 HTTP/1.1
Cookie: session=attacker_session
Step 2: Modify ID to target another user

GET /api/user/profile?id=1000 HTTP/1.1
Cookie: session=attacker_session
Vulnerable if: Returns victim's data with attacker's session

Request Body Manipulation

# Original POST request
POST /api/address/update HTTP/1.1
Content-Type: application/json
Cookie: session=attacker_session
{"id": 5, "userId": 1001, "address": "123 Attacker St"}
Modified request targeting victim

{"id": 5, "userId": 1000, "address": "123 Attacker St"}

HTTP Method Switching

# Original GET request may be protected
GET /api/admin/users/1000 → 403 Forbidden
Try alternative methods

POST /api/admin/users/1000 → 200 OK (Vulnerable!)
PUT /api/admin/users/1000 → 200 OK (Vulnerable!)

4. Exploitation with Burp Suite

Manual Exploitation

1. Configure browser proxy through Burp Suite
Login as "attacker" user

Navigate to profile/data page

Enable Intercept in Proxy tab

Capture request with user ID

Modify ID to victim's ID

Forward request

Observe response for victim's data

Automated Enumeration with Intruder

1. Send request to Intruder (Ctrl+I)
Clear all payload positions

Select ID parameter as payload position

Configure attack type: Sniper

Payload settings:

   - Type: Numbers
   - Range: 1 to 10000
   - Step: 1
Start attack

Analyze responses for 200 status codes

Battering Ram Attack for Multiple Positions

# When same ID appears in multiple locations
PUT /api/addresses/§5§/update HTTP/1.1
{"id": §5§, "userId": 3}
Attack Type: Battering Ram
Payload: Numbers 1-1000

5. Common IDOR Locations

API Endpoints

/api/user/{id}
/api/profile/{id}
/api/order/{id}
/api/invoice/{id}
/api/document/{id}
/api/message/{id}
/api/address/{id}/update
/api/address/{id}/delete

File Downloads

/download/invoice_{id}.pdf
/static/receipts/{id}.pdf
/uploads/documents/{filename}
/files/reports/report_{date}_{id}.xlsx

Query Parameters

?userId=123
?orderId=456
?documentId=789
?file=report_123.pdf
?account=user@email.com

Quick Reference

IDOR Testing Checklist

Response Analysis

Common Vulnerable Parameters

Constraints and Limitations

Operational Boundaries

Requires at least two valid user accounts for verification

Some applications use session-bound tokens instead of IDs

GUID/UUID references harder to enumerate but not impossible

Rate limiting may restrict enumeration attempts

Some IDOR requires chained vulnerabilities to exploit

Detection Challenges

Horizontal privilege escalation (user-to-user) vs vertical (user-to-admin)

Blind IDOR where response doesn't confirm access

Time-based IDOR in asynchronous operations

IDOR in websocket communications

Legal Requirements

Only test applications with explicit authorization

Document all testing activities and findings

Do not access, modify, or exfiltrate real user data

Report findings through proper disclosure channels

Examples

Example 1: Basic ID Parameter IDOR

# Login as attacker (userId=1001)
Navigate to profile page
Original request

GET /api/profile?id=1001 HTTP/1.1
Cookie: session=abc123
Response: Attacker's profile data
Modified request (targeting victim userId=1000)

GET /api/profile?id=1000 HTTP/1.1
Cookie: session=abc123
Vulnerable Response: Victim's profile data returned!

Example 2: IDOR in Address Update Endpoint

# Intercept address update request
PUT /api/addresses/5/update HTTP/1.1
Content-Type: application/json
Cookie: session=attacker_session
{
  "id": 5,
  "userId": 1001,
  "street": "123 Main St",
  "city": "Test City"
}
Modify userId to victim's ID

{
  "id": 5,
  "userId": 1000,  # Changed from 1001
  "street": "Hacked Address",
  "city": "Exploit City"
}
If 200 OK: Address created under victim's account

Example 3: Static File IDOR

# Download own receipt
GET /api/download/5 HTTP/1.1
Cookie: session=attacker_session
Response: PDF of attacker's receipt (order #5)
Attempt to access other receipts

GET /api/download/3 HTTP/1.1
Cookie: session=attacker_session
Vulnerable Response: PDF of victim's receipt (order #3)!

Example 4: Burp Intruder Enumeration

# Configure Intruder attack
Target: PUT /api/addresses/§1§/update
Payload Position: Address ID in URL and body
Attack Configuration:
Type: Battering Ram

Payload: Numbers 0-20, Step 1
Body Template:
{
  "id": §1§,
  "userId": 3
}
Analyze results:

- 200 responses indicate successful modification

- Check victim's account for new addresses

Example 5: Horizontal to Vertical Escalation

# Step 1: Enumerate user roles
GET /api/user/1 → {"role": "user", "id": 1}
GET /api/user/2 → {"role": "user", "id": 2}
GET /api/user/3 → {"role": "admin", "id": 3}
Step 2: Access admin functions with discovered ID

GET /api/admin/dashboard?userId=3 HTTP/1.1
Cookie: session=regular_user_session
If accessible: Vertical privilege escalation achieved

Troubleshooting

Issue: All Requests Return 403 Forbidden

Cause: Server-side access control is implemented
Solution:

# Try alternative attack vectors:
HTTP method switching (GET → POST → PUT)

Add X-Original-URL or X-Rewrite-URL headers

Try parameter pollution: ?id=1001&id=1000

URL encoding variations: %31%30%30%30 for "1000"

Case variations for string IDs

Issue: Application Uses UUIDs Instead of Sequential IDs

Cause: Randomized identifiers reduce enumeration risk
Solution:

# UUID discovery techniques:
Check response bodies for leaked UUIDs

Search JavaScript files for hardcoded UUIDs

Check API responses that list multiple objects

Look for UUID patterns in error messages

Try UUID v1 (time-based) prediction if applicable

Issue: Session Token Bound to User

Cause: Application validates session against requested resource
Solution:

# Advanced bypass attempts:
Test for IDOR in unauthenticated endpoints

Check password reset/email verification flows

Look for IDOR in file upload/download

Test API versioning: /api/v1/ vs /api/v2/

Check mobile API endpoints (often less protected)

Issue: Rate Limiting Blocks Enumeration

Cause: Application implements request throttling
Solution:

# Bypass techniques:
Add delays between requests (Burp Intruder throttle)

Rotate IP addresses (proxy chains)

Target specific high-value IDs instead of full range

Use different endpoints for same resources

Test during off-peak hours

Issue: Cannot Verify IDOR Impact

Cause: Response doesn't clearly indicate data ownership
Solution:

# Verification methods:
Create unique identifiable data in victim account

Look for PII markers (name, email) in responses

Compare response lengths between users

Check for timing differences in responses

Use secondary indicators (creation dates, metadata)

Remediation Guidance

Implement Proper Access Control

# Django example - validate ownership
def update_address(request, address_id):
    address = Address.objects.get(id=address_id)
    
    # Verify ownership before allowing update
    if address.user != request.user:
        return HttpResponseForbidden("Unauthorized")
    
    # Proceed with update
    address.update(request.data)

Use Indirect References

# Instead of: /api/address/123
Use: /api/address/current-user/billing
def get_address(request):
    # Always filter by authenticated user
    address = Address.objects.filter(user=request.user).first()
    return address

Server-Side Validation

# Always validate on server, never trust client input
def download_receipt(request, receipt_id):
    receipt = Receipt.objects.filter(
        id=receipt_id,
        user=request.user  # Critical: filter by current user
    ).first()
    
    if not receipt:
        return HttpResponseNotFound()
    
    return FileResponse(receipt.file)