A $3,500 payout for bypassing an anti-SSRF filter using DNS rebinding! Here is how a researcher tricked GitLab into reading its own internal network:
🚨 BUG: SSRF Mitigation Bypass via DNS
THE FLAW:
• GitLab implemented a security module called url_blocker.rb designed to provide protection against Server-Side Request Forgery (SSRF).
• However, this module suffered from a flawed DNS rebinding protection issue.
• This specific SSRF mitigation bypass allowed attackers to trick the server via DNS.
THE EXPLOIT:
• The researcher exploited the flawed DNS rebinding protection within the url_blocker.rb module.
• By bypassing the mitigation, the attacker was able to send arbitrary requests directly into the local network hosting the GitLab instance.
• The vulnerability ultimately allowed the attacker to read the sensitive responses from internal resources that were supposed to be blocked.
STRATEGIC TAKEAWAY:
• Even when a dedicated anti-SSRF module like url_blocker.rb is in place, it can be bypassed if the DNS rebinding protections are flawed.
• Always ensure that SSRF mitigations safely pin or validate the resolved IP address at the time of the request to prevent DNS-based bypasses from reaching the internal network.
Link to the full report in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
Read the full HackerOne report #632101 here: hackerone.com/reports/632101
27
A $5,000 payout for exploiting a single weird Unicode character! Here is how a researcher turned a Unicode Normalization mismatch into a full Account Takeover (ATO),
🚨 BUG: Unicode Normalization Mismatch / ATO
THE FLAW:
• The target application used different microservices for user registration and password resets.
• The registration service validated emails using a basic .toLowerCase() check before saving them to the database.
• However, the password reset service applied full NFKC Unicode normalization before querying the database for a user's email.
THE EXPLOIT:
• The researcher targeted a victim with the letter "k" in their email (e.g., [email protected]).
• They registered a new account, replacing the standard ASCII "k" with the Unicode Kelvin Sign (U+212A, K).
• The registration service treated this as a unique, unregistered email and successfully created the account in the database.
• The researcher then requested a password reset for their malicious Kalex email.
• The password reset service applied NFKC normalization, which forcefully converted the Unicode Kelvin Sign back into a standard "k".
• This caused the database query to collide with the victim's real account ([email protected]), sending the victim's password reset token directly to the attacker's session or email.
STRATEGIC TAKEAWAY:
• When an application relies on multiple microservices, character encoding discrepancies are highly likely if they use different string handling libraries.
• Always test registration and login flows with non-ASCII Unicode equivalents (like the Kelvin Sign) to see if the backend normalizes them inconsistently downstream.
Link to the full write-up in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
Read the full $5,000 write-up by t4nv1 here: medium.com/@t4nv1/how-an-unh…
1
66
A brilliant CORS misconfiguration chain that leaked PII from a government web portal! Here is how a researcher exploited a trusted localhost origin and a static custom header to silently exfiltrate private data:
🚨 BUG: CORS Misconfiguration / PII Exfiltration
THE FLAW:
• While testing a government portal, the researcher intercepted API responses containing sensitive user data (full names, emails, UUIDs).
• The server's response included highly permissive CORS headers: Access-Control-Allow-Origin: http://localhost:5500 and Access-Control-Allow-Credentials: true.
• To read this data, the API required both an active session cookie and a custom authentication header named mytoken.
THE EXPLOIT:
• Because mytoken was a custom header, cross-origin requests required an OPTIONS preflight check. The permissive backend successfully approved it.
• The researcher spun up a local Python server on port 5500, matching the whitelisted origin exactly.
• By hosting a malicious JavaScript fetch payload on localhost:5500, the attacker's script could make a request to the portal, the browser would automatically attach the victim's session cookies, and the script would successfully read the PII response.
• The Kicker: The researcher discovered the mytoken value was completely static and never rotated after logout. An attacker could intercept it once and exploit the CORS misconfiguration indefinitely.
STRATEGIC TAKEAWAY:
• A trusted localhost origin combined with Access-Control-Allow-Credentials: true is a massive security hole, allowing any local attacker script to read authenticated responses.
• Do not mark a CORS issue as "unexploitable" just because the endpoint requires a custom token. If the preflight check allows the header and the token doesn't rotate, your exploit chain is fully viable.
Link to the full write-up in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
Read the full write-up by 4osp3l here: medium.com/@4osp3l/exploitin…
44
How 0.3 seconds can cost a company $15,000! Here is a breakdown of Race Conditions; one of the most underreported yet highest-paying bugs in bug bounty, and how a limit overrun vulnerability allows attackers to steal money, multiply coupons, and hijack accounts:
🚨 BUG: Race Condition (Limit Overrun / TOCTOU)
THE FLAW:
• A Race Condition occurs when a server checks a condition (e.g., "Is this coupon already used?") and then performs an action (e.g., "Apply discount"), but leaves a tiny time gap between the check and the final state update.
• This is known as a Time-of-Check to Time-of-Use (TOCTOU) vulnerability. If a server lacks proper resource locking (like atomic database transactions), two parallel requests can both pass the initial check before either request updates the final state.
THE EXPLOIT:
• Attackers look for features that promise a "one-time use" limit, such as promo codes, gift card redemptions, password reset links, or Two-Factor Authentication (2FA) OTPs.
• Using Burp Suite's Repeater (Send group in parallel) or the Turbo Intruder extension, an attacker fires 10 to 20 identical requests at the exact same millisecond.
• Because the server processes them simultaneously, multiple requests succeed. For example, a researcher used this exact method on Shopify to withdraw store credit multiple times, earning a $15,000 bounty. Another hunter hit a Starbucks gift card transfer endpoint with 20 parallel requests, duplicating the balance and earning over $6,000.
STRATEGIC TAKEAWAY:
• Race conditions are often missed because developers only test their apps one request at a time.
• Never assume a "single-use" limit actually works. If an endpoint handles money, account downgrades, OTPs, or refer-a-friend bonuses, immediately fire 20 parallel requests at it using a single-packet attack over HTTP/2.
Link to the full guide in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
Read the full guide by Monika here: osintteam.blog/race-conditio…
1
101
A massive $10,000 payout for escalating a "limited" local file read into full internal session theft! Here is how a researcher turned a basic XXE into critical Redis Server compromise:
🚨 BUG: XML External Entity (XXE) / Internal Redis Exposure
THE FLAW:
• The researcher was mapping the target's attack surface and found an endpoint accepting XML-RPC requests.
• They successfully injected an XML External Entity (XXE) payload that returned the contents of /etc/passwd.
• The security team initially assessed this as a limited local file read and paid $1,000.
THE EXPLOIT:
• The researcher kept digging and checked /proc/net/tcp via the XXE to see what internal connections the server was making.
• They spotted an active, established connection on port 6379, the default port for Redis.
• Since Redis uses a custom TCP protocol (not HTTP), the researcher used the gopher:// protocol scheme in their XXE payload to craft direct TCP commands.
• They successfully communicated directly with the internal Redis instance, bypassing authentication, and extracted internal server information, keyspace data, and live session data.
• This direct demonstration of internal session compromise caused the security team to bump the payout from $1,000 to a massive $10,000.
STRATEGIC TAKEAWAY:
• A basic local file read (/etc/passwd) is just the reconnaissance phase of an XXE.
• Always use an initial XXE to read network configuration files like /proc/net/tcp to map internal infrastructure. If you find internal services like Redis, Memcached, or databases, pivot using protocols like gopher:// or dict:// to turn a file read into a critical internal compromise.
Link to the full write-up in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
A step-by-step masterclass on turning a single GraphQL endpoint into a critical account takeover! Here is The XSS Rat's exact workflow for moving from basic introspection to massive business logic impact:
🚨 BUG: GraphQL Recon to Account Takeover (ATO)
THE WORKFLOW:
• Find the Door: Don't just scan for /graphql. Fuzz for variations like /v1/graphql, /query, or /graphiql using a tool like ffuf. An error like {"errors":[{"message":"Must provide query string"}]} confirms you found the endpoint.
• Pull the Blueprint: Run an introspection query. If it works, you have the entire API schema. If introspection is disabled, use a tool like Clairvoyance to rebuild the schema by exploiting the server's "Did you mean..." error suggestions.
• Hunt the Mutations: Ignore the standard read queries (like me or posts). Look for state-changing mutations: updateUser, changeEmail, setRole, or applyCoupon. These are the highest-impact targets.
• Swap the ID (BOLA/IDOR): Request your own user record to see its shape (user(id:"1337")), then change the ID to 1338. If the server returns another user's email or API key, you have a critical Broken Object Level Authorization (BOLA) flaw.
• Alias the Brute-Force: Rate limiters usually count HTTP requests, not internal GraphQL operations. By using GraphQL "aliasing," you can pack 1,000 OTP guesses into a single HTTP POST request, entirely bypassing standard rate limits.
STRATEGIC TAKEAWAY:
• A GraphQL endpoint is not an API; it is a treasure map.
• Developers often place authentication at the front door but forget to add authorization checks to individual objects and fields inside the schema.
Always expand nested objects and explicitly request scary-sounding fields like passwordResetToken to see if the server actually guards them.
Link to the full methodology in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
Read the full deep dive by Wesley (The XSS Rat) here: blog.thexssrat.com/graphql-i…
1
114
A $150 bounty for a brilliant but undervalued Single Sign-On (SSO) bypass! Here is how a researcher exploited a broken 2FA implementation to hijack sessions on a secondary asset,
🚨 BUG: Misconfigured SSO / 2FA Bypass
THE FLAW:
• The target organization linked their main financial application and their secondary forum using Single Sign-On (SSO).
• The main application enforced strict security, requiring users to pass a Two-Factor Authentication (2FA) check after entering their password.
• However, the backend generated an initial authentication token before the 2FA was actually completed.
THE EXPLOIT:
• The researcher logged into the main application using valid credentials and stopped at the 2FA verification page.
• Without entering the OTP, they simply opened a new tab and navigated directly to the connected forum application.
• Because the forum trusted the incomplete SSO session token, the researcher was instantly granted full authenticated access to the forum.
• From the forum, they could add a secondary email and export sensitive user data logs, including API tokens and IP addresses.
STRATEGIC TAKEAWAY:
• In SSO environments, authentication state is often shared across applications with vastly different risk profiles.
• If you get blocked by a 2FA prompt on a highly secure main domain, always check if your "half-authenticated" session is blindly trusted by less critical subdomains connected to the same SSO provider.
Link to the full write-up in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
Read the full write-up by tinopreter here: infosecwriteups.com/easy-150…
1
126
A $6,000 payout for turning a forgotten marketing site into a zero-interaction Account Takeover (ATO)! Here is how a researcher chained a Subdomain Takeover with permissive OAuth wildcards to hijack enterprise sessions,
🚨 BUG: Subdomain Takeover to OAuth ATO
THE FLAW:
• The target enterprise used a centralized OAuth 2.0 Identity Provider (IdP) for authentication across all its services.
• The researcher tested the IdP's redirect_uri validation and discovered it used wildcard matching, accepting any subdomain ending in .target.com.
• Knowing this, the researcher ran a DNS enumeration scan and found a stale CNAME record (promo-2023.target.com) pointing to a deleted AWS S3 bucket.
THE EXPLOIT:
• The researcher claimed the deleted AWS S3 bucket in their own account, achieving a full Subdomain Takeover of the old marketing site.
• They uploaded a malicious JavaScript payload to the claimed bucket designed to capture URL parameters and exfiltrate them.
• The researcher then crafted a legitimate-looking login link pointing to the official IdP, but set the redirect_uri to the hijacked promotional subdomain.
• When a victim clicked the link and logged in, the IdP generated an OAuth authorization code and blindly redirected it to the attacker-controlled subdomain, where the script captured the code for full session hijacking.
STRATEGIC TAKEAWAY:
• A stale CNAME record on an empty subdomain is usually rated as a low-to-medium severity issue.
• However, if the primary authentication provider utilizes wildcard redirect_uri validation, any abandoned subdomain instantly becomes a critical vulnerability. Always test OAuth endpoints to see if they trust forgotten infrastructure.
Link to the full write-up in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
Read the full $6,000 write-up by t4nv1 here: medium.com/@t4nv1/how-i-chai…
112
An $8,000 payout for looking past the usual SSRF payloads! Here is how a researcher escalated a basic SSRF into full Kubernetes infrastructure exposure just by reading the HTTP response headers,
🚨 BUG: Server-Side Request Forgery (SSRF) / Information Disclosure
THE FLAW:
• The researcher found an SSRF vulnerability but hit a wall—standard cloud metadata endpoints (AWS/GCP) and localhost payloads returned nothing useful.
• The breakthrough came from a single, overlooked HTTP response header.
• This hidden header leaked internal Kubernetes infrastructure details, including Pod IPs, workload identifiers, and internal service names.
THE EXPLOIT:
• Realizing the target wasn't a standard cloud instance but a containerized Kubernetes environment with a service mesh, the researcher pivoted.
• Using the leaked naming conventions from the header, they routed the SSRF to hit internal Kubernetes services.
• They discovered exposed internal monitoring interfaces and administrative endpoints, including one that could potentially shut down running service components.
• Instead of taking down production (which is out of bounds), they documented the exposed destructive capability, proving severe impact across Confidentiality, Integrity, and Availability.
STRATEGIC TAKEAWAY:
• Stop blindly throwing AWS metadata payloads at every SSRF.
• A failed metadata request doesn't mean the SSRF is useless; it usually means the target is using a different architecture, like Kubernetes. Always analyze the complete HTTP response, especially the headers, to fingerprint the internal network before you start firing payloads.
Link to the full write-up in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
Read the full $8,000 write-up by Asad Mohsin here: medium.com/@asadmohsin760/th…
3
212
A $3,000 payout for manipulating a single API request! Here is how a researcher exploited a critical business logic flaw to infinitely top-up their account balance without ever completing a payment:
🚨 BUG: Business Logic Flaw / Unauthorized Balance Top-up
THE FLAW:
• The researcher was testing a newly added asset for a private bug bounty program.
• After adding a credit card in the Billing section to access API services, they started monitoring the HTTP traffic.
• They discovered a specific API endpoint (POST /api/credits/top-up) that handled the account recharging process.
• The backend was explicitly trusting the amount and threshold parameters sent directly by the client, instead of securely validating the transaction status from the payment gateway.
THE EXPLOIT:
• The researcher intercepted the top-up request using Burp Suite.
• They modified the amount parameter to a significantly larger value (e.g., 40000) and forwarded the request, completely bypassing the actual payment process.
• The server accepted the tampered values and immediately updated the account balance with the requested credits.
• This allowed any authenticated user to arbitrarily increase their balance and consume paid API services for free, posing a massive financial risk to the company.
STRATEGIC TAKEAWAY:
• Never trust client-side data for financial transactions.
• When hunting, always intercept the exact moment a payment or credit allocation is initiated. If the application is passing the expected top-up amount within the request body, tamper with it—if the backend lacks a secondary payment gateway validation check, you have a critical business logic flaw.
Link to the full write-up in the replies 👇
#BugBounty #AppSec #CyberSecurity #InfoSec #BugBountyTips #BugBountyReports
Read the full $3,000 write-up by 0xSADAT here: medium.com/@0x0sadat/how-i-d…
