Daily Bug Bounty Reports (@Bug_Breakdown) profile picture

Decoding bug bounty reports from internet

Joined August 2026
Photo by Daily Bug Bounty Reports (@Bug_Breakdown)Photo by Daily Bug Bounty Reports (@Bug_Breakdown)
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
1
1
102
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
1
5
27
768
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
1
1
9
412
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
1
1
23
1,029
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
1
1
13
655
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
1
2
16
550
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
2
1
17
759
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
2
1
22
781
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
2
2
33
1,325
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
2
4
1
28
2,157