Use labs as the execution layer of your learning plan, then capture the technique in practice and notes.
Real vulnerable web apps. Attack with your browser or Burp Suite.
You need to sign in to start a lab. Progress and XP are saved to your account.
Exploit a vulnerable login form with classic SQL injection. Extract the admin's secret from the database.
The search page reflects the ?q= parameter directly into the HTML response without sanitization.
Inject a persistent script into a comment board. An admin bot reads comments every 30 seconds — steal its cookie.
The account update form has no CSRF token. Craft a forged request that the admin bot executes.
The order API returns any order by ID without checking ownership. Find the admin's private order.
A file download endpoint constructs paths from user input. Escape the web root and read sensitive files.
The password reset flow uses a predictable token. Intercept or brute-force it to take over the admin account.
The API uses JWT for auth but accepts the 'none' algorithm. Forge an admin token without knowing the secret.
The network scanner shells out to a system command with user-controlled input. Inject an extra command to read local files or execute arbitrary shell syntax.
The portal login page accepts a redirect target from the query string and sends the user there without validation after a successful login.
The upload form accepts arbitrary file types and directly serves the uploaded content without checking the extension or MIME type.
A shared edge cache stores content based on a request parameter and does not normalize hostile input, allowing a poisoned response to be served to other users.
The profile update API accepts arbitrary JSON keys and assigns them directly to the user object without a whitelist, allowing privilege escalation via an untrusted field.
The password reset page builds the reset link using the Host header. Supply a malicious host value to generate an attacker-controlled reset URL.
The app accepts a base64-encoded JSON session token, then blindly trusts it and grants admin access when the role field is changed to admin.
A custom response header reflects a user-supplied search query directly without sanitization, exposing unsafe header construction that can be abused to inject extra metadata.
The bank transfer form is not protected by frame-ancestors or X-Frame-Options, so it can be hidden behind a transparent overlay and trick a user into submitting a transfer.
The project listing page exposes project IDs in the URL, and the backend checks only whether the record exists instead of verifying ownership before returning it.
The GraphQL endpoint exposes schema introspection without any authorization checks, revealing internal object fields and secret selections that are normally hidden from clients.
User-supplied settings are merged into a plain object using Object.assign, allowing an attacker to mutate the prototype and influence application logic globally.
The sign-in flow accepts an arbitrary redirect_uri value and forwards the authorization code to that location without validating the target origin or scheme.
The report generator embeds user-controlled title text into the rendered HTML without sanitization, allowing an attacker to trigger expression evaluation in the underlying template engine.
The dashboard API responds with permissive CORS headers and exposes admin-only data to arbitrary browser origins, allowing cross-origin access to sensitive information.
The parser accepts raw XML input and resolves external entities, enabling a crafted payload to access local files or internal secrets and trigger data leakage.
Duplicate query parameters are accepted without canonicalization, allowing an attacker to override the intended role or state by supplying repeated values.
The identity provider accepts JWTs with a weak or attacker-controlled algorithm selection, enabling a forged token to bypass the backend's signature verification logic.
The page reads a token from a global variable, but the DOM can be polluted by attacker-controlled elements that overwrite the expected browser globals and change the runtime behavior.
The redirect endpoint accepts a user-controlled destination and places it into a Location header without neutralizing CRLF characters, creating room for response splitting and header injection.
The authorization flow expects a state parameter, but the application accepts a missing or stale value and completes the login flow without verifying the expected cross-site request correlation.
The proxy middleware trusts ambiguous forwarded headers and accepts conflicting request metadata, opening the door to request smuggling scenarios and unexpected backend routing.
The session cookie is created without secure protections, allowing it to be sent over insecure channels and exposed to client-side scripts or malicious subresources.
The JWT verification code selects a signing key from the kid header without validating that it belongs to the expected issuer or environment, opening a classic key-confusion vector.
The document reader resolves a user-controlled file path with minimal validation, allowing traversal-like input to reach sensitive files on the server and leak privileged content.
The authentication flow accepts a preexisting session ID and does not rotate it after login, allowing an attacker to predefine the victim's session and then hijack it post-authentication.
The application exposes record IDs and uses weak access control checks. A user can enumerate underlying objects and then chain a direct object reference into an admin-only record to reveal sensitive financial data.
A stale DNS record still points at a legacy host that is no longer under the company's control. The app trusts the stale subdomain and allows implicit trust to be hijacked by an attacker-controlled service.
The login routine delays the response when a SQL condition is true, allowing an attacker to infer the result of hidden predicates by measuring response timing instead of reading the database directly.
The application trusts a hostname as a safe origin even after that hostname has been rebound to an internal IP, allowing an attacker to pivot from a public host to an internal service and read sensitive data.
The GraphQL endpoint accepts a batch of operations in one request, but it fails to preserve the effective authorization check for each operation. A user query can be combined with an admin-only query in the same batch and exfiltrate the secret.
The API echoes the request origin and allows credentials on cross-site requests. A malicious site can send a credentialed preflighted fetch to the victim's authenticated session and read the admin profile data.
The authorization callback advertises PKCE protection, but it accepts a code without the expected verifier. An attacker can reuse the authorization code and gain a trusted admin session without the proof-of-possession step.
The API uses refresh tokens as bearer tokens across multiple principals but does not bind them to a specific user or role. An attacker can swap a user refresh token into an admin session and receive the privileged access token.
A URL-fetching endpoint has no validation. Use it to reach an internal metadata service.
A coupon code can be applied multiple times by sending concurrent requests before the use_count increments.
Exploit unsafe SQL construction in a realistic financial portal to bypass authentication and gain administrator access. Then investigate the search functionality and use UNION-based SQL injection to extract backend database information.
An archive import feature extracts entries using the raw filename with no path normalization. Escape the webroot and read the hidden flag file.
A live-chat endpoint trusts the client-supplied role with no Origin check and no CSRF token. Forge an admin message to read the privileged secret.
The admin login is protected by a 5-tries-per-IP rate limit on a 4-digit PIN — but the counter trusts X-Forwarded-For and a debug endpoint clears it.
A login form builds a NoSQL query from user input without sanitization. Inject Mongo-style operators to bypass authentication as administrator.
A product lookup concatenates input into SQL but only reveals found vs not-found. Use boolean conditions to extract the hidden admin secret.
After password login, a predictable 4-digit OTP with no rate limit guards the account - and the verify endpoint trusts a client-side verified flag.