<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ehtesham Ul Haq on Medium]]></title>
        <description><![CDATA[Stories by Ehtesham Ul Haq on Medium]]></description>
        <link>https://medium.com/@ehteshamulhaq198?source=rss-989978ba49fe------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Ol6i1EKzTepUIEn8uE8KJg.png</url>
            <title>Stories by Ehtesham Ul Haq on Medium</title>
            <link>https://medium.com/@ehteshamulhaq198?source=rss-989978ba49fe------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 21:14:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ehteshamulhaq198/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Bug Bounty Grind Changed. Signal Is the Only Currency Left.]]></title>
            <link>https://infosecwriteups.com/the-bug-bounty-grind-changed-signal-is-the-only-currency-left-d28dc1fe4a40?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/d28dc1fe4a40</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[cyber-security-awareness]]></category>
            <category><![CDATA[information-security]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 09:21:44 GMT</pubDate>
            <atom:updated>2026-10-07T09:22:39.098Z</atom:updated>
            <content:encoded><![CDATA[<p>Free Article Link: <a href="https://ehteshamulhaq198.medium.com/the-bug-bounty-grind-changed-signal-is-the-only-currency-left-d28dc1fe4a40?sk=6f228ca8717217cf6d511c0d4a3255c5">Click for free!</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tY4luTNzoJBYz0d2es_Vlg.png" /></figure><h3>The Bug Bounty Grind Changed. Signal Is the Only Currency Left.</h3><p>A year and a half ago I wrote <a href="https://medium.com/bugbountywriteup/bug-hunting-for-real-tools-tactics-and-truths-no-one-talks-about-661f6786d5b3">Bug Hunting for Real: Tools, Tactics, and Truths No One Talks About</a>, about the tools, the platforms and the grind. Most of it still holds. The assumption underneath it doesn’t. That article took for granted that finding bugs was the hard part, and it isn’t the hard part anymore. Being believed is.</p><p>I want to walk through what actually changed, because the numbers are worse than the mood around them, and then talk about where AI sits in my own work now that most of my time goes to contracted engagements rather than public programs. There’s one rule near the end that matters more than anything else here, and it isn’t about tooling.</p><h3>What broke</h3><p>Start with curl, because it’s the clearest signal anyone has sent. On 31 January 2026, Daniel Stenberg ended curl’s bug bounty program after seven years and 87 confirmed vulnerabilities. Not because the budget ran out, but because of the volume of low quality submissions. At one point in January the project took seven reports in a sixteen hour window and none of them were real. His stated reason for closing it was to remove the incentive for people to submit things they hadn’t actually researched. Sit with what that means. A project with a seven year record of paying for real bugs decided the incentive itself had become the problem.</p><p>Two months later, HackerOne paused the Internet Bug Bounty from taking new submissions. The reason wasn’t fraud. It was that submission volume had outrun the capacity of maintainers to fix anything. Bounties fund discovery, not remediation, and discovery had scaled while remediation had not.</p><p>Then Elastic published their numbers in August 2026. More than 1,390 reports in the first half of the year, which is more than 2024 and 2025 put together. Around seventy percent were rejected during analysis. They worked out the cost of simply reading a report, and reproducing it when it looked plausible, and landed near two dollars per report in triage overhead alone. Two dollars. From the other side of the table, every report you send now carries a cost before anyone decides whether it’s worth anything, and the program is counting it.</p><h3>The economics inverted</h3><p>Here’s the shift in one sentence. In 2025 the scarce thing was the ability to find something. In 2026 the scarce thing is the program’s attention. That changes how you should behave.</p><p>When finding was scarce, volume made sense. Submit more, cover more, build reputation through throughput. A good part of my last article rested quietly on that model. Now the triage queue is the bottleneck, and your report competes for attention with hundreds of plausible looking submissions that took seconds to produce and whose authors never read the response they’re reporting on. The program can’t tell the difference at a glance, and that’s the whole problem. A report from someone who spent four hours understanding a flow and a confident report from someone who pasted a response into a model and asked it to find something look very similar in the first thirty seconds.</p><p>So the burden moved onto you to prove, immediately, that you’re the first kind. Not in your conclusion, in your opening. Everything that used to be polish is now load bearing. Reproduction steps that work on the first try. Real evidence instead of a description of evidence. An impact statement that says what an attacker actually gets rather than reciting a severity number. Honesty about what you couldn’t confirm, which now reads as credibility rather than weakness, because nobody producing slop ever admits to being unsure. And here’s a consequence most hunters haven’t absorbed yet: a weak submission now costs you more than nothing. It costs you the benefit of the doubt on your next one.</p><h3>The agents are real, and they are good at exactly one thing</h3><p>In mid 2025 an autonomous system called XBOW reached the top of HackerOne’s US leaderboard and raised seventy five million dollars on the strength of it. That was the moment the question of whether machines could do this stopped being theoretical.</p><p>But look at what it’s good at, because the detail matters more than the headline. Autonomous agents are very effective at bugs that are pattern shaped. Known issues in exposed services, injection in a parameter that behaves predictably, misconfigurations with a signature, reflected cross site scripting, anything where the flaw looks the same across ten thousand applications. That’s a large category, and if it was your hunting ground, it’s gone. Not shrinking, gone. You can’t out enumerate something that enumerates without stopping and never gets bored.</p><p>What they’re still bad at is anything that needs you to understand why a feature exists. An agent can tell you an endpoint returns 200 for an object you don’t own. It can’t tell you that the object is another tenant’s invoice, that the application has a separate notion of organization membership this endpoint forgot to check, and that the same oversight almost certainly sits in the three sibling endpoints the same team shipped in the same sprint. That reasoning means holding a model of the product in your head and asking what the developer assumed.</p><p>Look at what has actually been paying over the last year. <a href="https://infosecwriteups.com/how-a-simple-profile-update-led-to-cross-tenant-data-exposure-b945842678e2">A profile update that leaked across tenants</a>. <a href="https://infosecwriteups.com/how-a-graphql-invitation-flow-exposed-users-at-scale-0dfb2bf3cc59">A GraphQL invitation flow that exposed registered accounts at scale</a>. <a href="https://infosecwriteups.com/from-user-enumeration-to-pii-exposure-chaining-two-apis-into-a-2-000-bug-adb9ed54ab30">Two APIs that were each fine on their own and became a PII disclosure once chained</a>. <a href="https://medium.com/bugbountywriteup/breaking-the-trust-boundary-ssrf-via-a-misconfigured-sentry-tunnel-ed054820b743">An SSRF through a Sentry tunnel</a>, a real feature used the way nobody intended. None of those is pattern shaped. Every one needed me to know what the application was meant to do before I could see where it failed to do it. That ground is still yours, and it’s getting more valuable, not less, because everything next to it is being automated away.</p><h3>Where AI sits in my work now</h3><p>I lean on it, and I want to be honest about where, because I’m mostly on the business side now, working on a contractual basis rather than chasing public programs. I use Claude Code and ChatGPT to understand vulnerabilities and to build proof of concept exploits for flaws I’ve already found by hand. When I’ve located something and I need to turn it into a clean, reliable demonstration, a model saves me real time writing the request chain, the script that proves impact, or the explanation a client’s engineers can follow. It’s very good at taking something I already understand and helping me express it precisely.</p><p>That’s the line, and it’s worth stating plainly. The finding is mine, the understanding is mine, and the judgment about whether a behavior is actually a vulnerability is mine. The model helps me build and explain, after the thinking is done. When I’ve tried to run it the other way around, letting a tool decide what’s interesting, it produces exactly the confident, shallow output that’s currently drowning every triage queue on the planet. I don’t send that, and you shouldn’t either. So use these tools. They’re genuinely part of my workflow and pretending otherwise would be dishonest. Just keep them on the right side of the line. They’re an amplifier for your reasoning, not a replacement for it.</p><h3>The rule that matters more than any of this</h3><p>One thing hasn’t changed and never will, and it sits above every tool and tactic in both of these articles. Never run anything against a company without permission. Not a scan, not a payload, not a clever request you’re curious about, nothing, unless you have explicit authorization and you’re inside a defined scope. A public bug bounty program is that authorization, within the boundaries it sets. A signed contract is that authorization, within the scope it names. Nothing else is.</p><p>And permission is only half of it. You also have to understand what you’re doing. Firing an exploit you found online at a target you don’t understand, on an application you have no authority to touch, isn’t research and it isn’t hunting. It’s the thing that ends careers and starts legal cases. The tools make it easier than ever to do real damage quickly, which means the responsibility sits more heavily on you, not less. I work on a contractual basis now, with scope agreed in writing before anything begins. That isn’t caution for its own sake, it’s the foundation the entire profession stands on. The moment you act without permission you’re not a security researcher anymore, whatever your tooling looks like.</p><h3>Where this leaves you</h3><p>The grind isn’t over, it changed shape. The shallow layer is being eaten by machines and the people pointing machines at everything that moves, and competing there is a losing game now. The durable ground is the part that needs a human who understands the product: business logic, authorization, multi account and multi tenant flows, the chains that only make sense once you see how the pieces fit together.</p><p>Go deep rather than wide. Make every report prove in its first lines that a person who understood the application wrote it. Use AI to sharpen and express your work, never to replace the thinking. And never, ever touch something you don’t have permission to touch. That’s the whole game in 2026. Signal is the only currency left, so spend your time becoming someone whose signal is trusted.</p><p>Thanks for reading. If the last one helped you get started, I hope this one helps you keep going as the ground shifts under all of us. See you in the wild, and hunt responsibly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0LJjOhWCvLZzihitQYl9tQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d28dc1fe4a40" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/the-bug-bounty-grind-changed-signal-is-the-only-currency-left-d28dc1fe4a40">The Bug Bounty Grind Changed. Signal Is the Only Currency Left.</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The API That Returned Every Customer’s Private AI Assistant]]></title>
            <link>https://infosecwriteups.com/the-api-that-returned-every-customers-private-ai-assistant-6bf8fafad17e?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/6bf8fafad17e</guid>
            <category><![CDATA[broken-access-control]]></category>
            <category><![CDATA[bug-bounty-writeup]]></category>
            <category><![CDATA[owasp-top-10]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Sun, 02 Aug 2026 11:26:02 GMT</pubDate>
            <atom:updated>2026-08-02T11:26:25.673Z</atom:updated>
            <content:encoded><![CDATA[<p>Free Article Link: <a href="https://ehteshamulhaq198.medium.com/the-api-that-returned-every-customers-private-ai-assistant-6bf8fafad17e?sk=a2d8838a5cc906033cc341c7b8dc0674">Click for free!</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I_bocTbOXvUxoF3iWpaSZg.png" /><figcaption>For responsible disclosure reasons, I’ll refer to the affected platform as <strong>target.com</strong> throughout this article. The technical concepts remain unchanged, but the company’s identity and sensitive implementation details have been intentionally withheld.</figcaption></figure><p>Artificial intelligence is quickly becoming part of almost every modern SaaS product.</p><p>Companies are adding AI assistants to help users create content, prepare presentations, answer questions, generate voice responses, automate workflows, and communicate with customers. What used to be a basic chatbot is now becoming a much deeper part of how businesses operate.</p><p>Because of that, AI assistants often contain more than a simple name and avatar. They may include internal instructions, carefully developed prompts, voice configurations, presenter settings, unpublished drafts, and business-specific workflows.</p><p>That information can represent weeks or even months of work.</p><p>During one of my recent security assessments on <strong>target.com</strong>, I came across an API that appeared to list AI assistants belonging to the authenticated account.</p><p>At least, that was what I expected it to do.</p><p>Instead, a single request returned thousands of private AI assistant configurations belonging to customers across the entire platform.</p><h3>Why AI Assistant Configurations Matter</h3><p>Before explaining the vulnerability, it is important to understand why this type of information can be sensitive.</p><p>AI assistants are becoming increasingly common because businesses want more personalized and automated experiences. A company may create an assistant to support customers, deliver presentations, guide new employees, answer internal questions, or represent a specific product.</p><p>To make these assistants work properly, teams often provide detailed instructions describing how the assistant should behave.</p><p>These instructions may define its tone, objectives, limitations, preferred responses, workflow, and business context. The configuration may also include voice selections, avatar settings, presenter identifiers, image references, and relationships with other platform resources.</p><p>In many cases, the prompt and instruction design behind an AI assistant becomes part of the company’s intellectual property.</p><p>An unpublished assistant may also represent work that is still being tested, refined, or prepared for a future launch.</p><p>That is why customers using a multi-tenant AI platform should only be able to access assistants belonging to their own organization.</p><h3>The First Request</h3><p>While mapping the API behavior of <strong>target.com</strong>, I found a request responsible for retrieving AI assistants. Nothing about the request looked unusual.</p><p>I was using a newly created, low-privileged account with no special permissions. Based on the functionality, I expected the response to contain either no assistants or a very small number of default assistants associated with my own account.</p><p>Instead, the response reported a total of more than <strong>3,400 AI assistants</strong>. That immediately caught my attention.</p><p>Large platforms sometimes include sample content or publicly available templates, so I did not assume there was a vulnerability based only on the number.</p><p>I started reviewing the returned records more carefully. The data did not look like generic demo content.</p><p>The assistants had different names, unique creation dates, different voice settings, separate presenter references, custom instructions, and varying publication states. Some of them were clearly marked as unpublished.</p><p>At that point, the response started looking much more like a global dataset than a list belonging to my account.</p><h3>Something Did Not Feel Right</h3><p>The most concerning part was not simply that the API returned assistant names. It returned detailed configurations.</p><p>The response included internal instructions describing how assistants should behave, prompt-related information, voice configuration, avatar image references, presenter identifiers, timestamps, cache settings, publication status, and relationships with other platform resources.</p><p>This meant that an authenticated user could potentially study how other customers had designed and configured their AI assistants.</p><p>The presence of unpublished assistants made the issue even clearer.</p><p>Public templates or intentionally shared assistants might reasonably appear in a common listing. Private drafts and unpublished configurations should not.</p><p>Still, I wanted to make sure the behavior was not somehow linked to my account. The easiest way to verify that was to test with another user.</p><h3>Testing With a Second Account</h3><p>I created a completely separate account using a different email address.</p><p>The second account had no relationship with the first one and belonged to a different user context. I authenticated normally and repeated the same request. <strong>The result was identical.</strong></p><p>The second account received the same total number of assistants, the same assistant identifiers, and the same private configurations.</p><p>This confirmed that the API was not filtering results according to the authenticated user or organization. Every authenticated account appeared to receive the same global dataset.</p><p>I then removed authentication from the request entirely.</p><p>Without a valid token, the API correctly returned an unauthorized response. That small test revealed the real problem. Authentication was working. Authorization was not.</p><h3>Authentication Is Not Tenant Isolation</h3><p>This distinction is one of the most important concepts in application security.</p><p>Authentication answers the question:</p><p><strong>Who are you?</strong></p><p>Authorization should answer another:</p><p><strong>What are you allowed to access?</strong></p><p>The API on <strong>target.com</strong> correctly required a logged-in user. Anonymous visitors could not retrieve the assistant data.</p><p>However, once a user authenticated, the application did not appear to ask which assistants belonged to that user or organization.</p><p>It treated authentication as if it automatically granted access to the entire dataset. In a multi-tenant SaaS application, that is a dangerous assumption.</p><p>Every customer may use the same platform and backend infrastructure, but their information should remain isolated. One company should never be able to retrieve the private assistants, prompts, or drafts created by another company.</p><p>The endpoint should have scoped every query to the tenant associated with the authenticated account.</p><p>Instead, it returned assistants from across the platform.</p><h3>What Was Exposed</h3><p>The exposed information went far beyond basic assistant names.</p><p>An authenticated user could review internal instructions, prompt configuration, voice settings, external voice identifiers, avatar images, presenter references, creation and update timestamps, cache-related settings, publication status, and relationships with presentations or other internal resources.</p><p>For a business that has spent time developing a specialized assistant, this information can reveal how its AI system is designed to communicate and operate.</p><p>A competitor could study those configurations for product research or competitive intelligence.</p><p>An attacker could continuously monitor newly created assistants, identify unpublished projects, map which organizations were actively using the AI features, and collect business-specific prompt engineering.</p><p>The issue did not provide direct modification access, but information disclosure alone can still carry meaningful impact.</p><p>Security is not only about preventing someone from changing data.</p><p>It is also about preventing them from learning things they were never supposed to see.</p><h3>Why AI Security Is Becoming More Important</h3><p>The world is rapidly shifting toward AI-powered software. As that happens, companies are storing more business logic inside prompts, model instructions, automated workflows, assistant profiles, and integrations. Developers sometimes treat these configurations as harmless application settings.</p><p>But they may reveal how a company handles customers, how it structures internal processes, what instructions it gives its AI systems, and what products or workflows it is preparing behind the scenes.</p><p>Traditional access control principles still apply. AI data should not receive weaker protection simply because it does not look like a password, credit card number, or customer database.</p><p>Private prompts are still private data. Unpublished assistants are still unpublished assets. Tenant isolation should protect AI configurations in exactly the same way it protects files, presentations, user records, and billing information.</p><h3>A Familiar Root Cause</h3><p>Interestingly, this was not the first cross-tenant authorization issue I had encountered.</p><p>In one of my previous articles, I explained how chaining two APIs together led from user enumeration to large-scale PII exposure.</p><p>In another, I wrote about how modifying a company relationship during a profile update resulted in cross-tenant metadata disclosure.</p><p>The features were different in each case. One involved users. Another involved company relationships. This one involved AI assistant configurations. But the root cause was familiar every time:</p><p><strong>The application knew who the user was, but failed to restrict what belonged to them.</strong></p><p>That is why tenant isolation should not be implemented in only one part of an application. It must be enforced consistently across every endpoint that returns customer-owned resources.</p><h3>Responsible Testing</h3><p>Once I confirmed the behavior using two unrelated accounts, there was no need to collect additional information.</p><p>Although the API made it possible to paginate through thousands of assistant configurations, I intentionally limited my testing to a small sample.</p><p>The objective was to demonstrate that unrelated accounts received the same global dataset and that private, unpublished configurations were included. That was enough to prove the authorization failure without unnecessarily reviewing more customer data.</p><p>Responsible testing is especially important when an issue provides access to information belonging to many organizations. The goal should always be to establish impact while minimizing exposure.</p><h3>Lessons Learned</h3><p>This finding reinforced several important lessons.</p><p>The first is that authentication alone does not make an API secure. Requiring a valid token only prevents anonymous access. It does not automatically ensure that authenticated users receive only the records they own.</p><p>The second is that AI configurations should be treated as sensitive customer assets. Prompts, instructions, voice settings, drafts, and assistant behavior can contain proprietary work and should never be exposed across tenants.</p><p>The third is that global listing endpoints deserve careful attention. Whenever an API returns a collection of objects, it is worth checking whether the backend applies ownership or tenant-based filtering.</p><p>Finally, testing with multiple accounts remains one of the simplest and most effective ways to identify tenant isolation failures. A response may appear normal when tested from one account. Comparing it with a completely unrelated account often reveals whether the data is actually scoped correctly.</p><h3>Conclusion</h3><p>What started as a routine API request on <strong>target.com</strong> turned into a cross-tenant information disclosure affecting thousands of private AI assistant configurations. The endpoint required authentication, but it failed to restrict the response to the authenticated user’s organization. As a result, unrelated accounts could access unpublished assistants, internal instructions, prompt configurations, voice settings, and other proprietary metadata belonging to customers across the platform.</p><p>The report was submitted through a private security program and was ultimately rewarded with a <strong>$1,000 bounty</strong>.</p><p>This finding was another reminder that authentication alone is not enough. Every customer-owned resource must also be protected by proper authorization and tenant isolation.</p><p>If you enjoyed this write-up, you can follow me on Medium for more real-world bug bounty and application security stories: <a href="https://ehteshamulhaq198.medium.com/"><strong><em>My Medium profile</em></strong></a></p><p>-<a href="https://ehteshamulhaq198.medium.com/from-user-enumeration-to-pii-exposure-chaining-two-apis-into-a-2-000-bug-adb9ed54ab30"><strong><em>From User Enumeration to PII Exposure: Chaining Two APIs Into a $2,000 Bug</em></strong></a><strong><em><br></em></strong>-<a href="https://infosecwriteups.com/how-a-simple-profile-update-led-to-cross-tenant-data-exposure-b945842678e2"><strong><em>How a Simple Profile Update Led to Cross-Tenant Data Exposure</em></strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6bf8fafad17e" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/the-api-that-returned-every-customers-private-ai-assistant-6bf8fafad17e">The API That Returned Every Customer’s Private AI Assistant</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How a Simple Profile Update Led to Cross-Tenant Data Exposure]]></title>
            <link>https://infosecwriteups.com/how-a-simple-profile-update-led-to-cross-tenant-data-exposure-b945842678e2?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/b945842678e2</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[ethical-hacking]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[appsec]]></category>
            <category><![CDATA[owasp]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 09:31:41 GMT</pubDate>
            <atom:updated>2026-07-27T09:23:39.788Z</atom:updated>
            <content:encoded><![CDATA[<p>Free Article Link: <a href="https://ehteshamulhaq198.medium.com/how-a-simple-profile-update-led-to-cross-tenant-data-exposure-b945842678e2?sk=0d91e1a19ce25b7714531f9aaacc1426">Click for free!</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nP8AgqjdRWXgWxBN8QtZEw.png" /><figcaption>For responsible disclosure reasons, I’ll refer to the affected application as <strong>target.com</strong> throughout this article. The technical details have been preserved, but the company’s identity and sensitive implementation details have been intentionally withheld.</figcaption></figure><p>One of the biggest misconceptions in application security is that <strong>Broken Access Control</strong> only exists around admin panels or sensitive endpoints.</p><p>In reality, some of the most impactful vulnerabilities begin in places almost nobody pays attention to.</p><p>During one of my recent security assessments on <strong>target.com</strong>, I was exploring what looked like a completely ordinary account settings page. Like most profile pages, it allowed users to update their personal information and preferences. Nothing about it immediately suggested that it could lead to a security issue.</p><p>As I spent more time understanding how the application handled profile updates, that seemingly harmless feature turned into a <strong>cross-tenant Broken Access Control vulnerability</strong> that allowed an authenticated user to associate their account with other organizations and disclose sensitive metadata belonging to completely different customers.</p><p>The report was acknowledged by the security team within just six hours of submission, but more importantly, it reinforced another lesson I’ve learned repeatedly throughout bug hunting:</p><p><strong>Sometimes the most dangerous vulnerabilities are hiding inside the features users interact with every day.</strong></p><h3>Looking Beyond the Profile Update</h3><p>Whenever I’m testing an application, I try not to focus only on what a feature is supposed to do.</p><p>Instead, I ask myself a different question.</p><p><strong>“What assumptions is the application making?”</strong></p><p>Modern SaaS platforms are built around relationships.</p><p>-A user belongs to a company.<br>-A company owns projects.<br>-Projects contain resources.</p><p>Every request depends on those relationships being accurate and trustworthy.</p><p>If one of those relationships can be manipulated without proper authorization, the impact can spread much further than developers expect. That mindset has helped me uncover several interesting vulnerabilities over the years. This assessment turned into another one of them.</p><h3>Understanding Tenant Isolation</h3><p>Before diving deeper, it’s worth understanding why this issue mattered.</p><p>Most modern SaaS applications are <strong>multi-tenant</strong>.</p><p>Think of an apartment building.</p><p>Everyone enters through the same front door, but each resident only has access to their own apartment.</p><p>You shouldn’t be able to walk into your neighbor’s home simply because you know the apartment number.</p><p>Multi-tenant applications work exactly the same way.</p><p>Every customer shares the same platform, but each organization’s information should remain completely isolated from every other organization.</p><p>That separation is called <strong>tenant isolation</strong>, and it forms one of the most fundamental security controls in any SaaS application.</p><p>When that boundary starts breaking — even partially — the consequences can become significant.</p><h3>Something Didn’t Feel Right</h3><p>While reviewing the profile update functionality, I noticed that one of the requests contained information describing the company associated with my account.</p><p>At first, nothing looked particularly unusual.</p><p>The application simply appeared to be updating information about the currently authenticated user.</p><p>Most testers would probably move on at that point.</p><p>Instead, I started wondering whether the application actually validated that relationship on the server.</p><p>More specifically…</p><p><strong>What would happen if I supplied a different company identifier?</strong></p><h3>The Unexpected Response</h3><p>Honestly, I expected the server to reject the request. A proper implementation should either ignore the modified relationship or return an authorization error.</p><p>Instead, the application accepted it. My account was suddenly associated with a different organization. That was the moment I realized I wasn’t looking at a simple profile update anymore.</p><p>I had discovered a potential authorization problem affecting the application’s tenant isolation model.</p><p>To confirm my suspicion, I repeated the same process using several additional company identifiers. The behavior remained consistent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tCqEdB7bhqfmx4Anld0iqg.png" /><figcaption>The application accepted an unauthorized tenant relationship update and returned metadata belonging to another organization.</figcaption></figure><p>The application continued accepting relationships that should never have been authorized.</p><h3>The Real Problem Appeared</h3><p>Changing the relationship alone would already have been concerning. What happened next was even more interesting.</p><p>After accepting the modified company association, the application began returning metadata belonging to the selected organization.</p><p>Although additional authorization controls prevented direct access to sensitive resources such as files and presentations, the response still disclosed valuable information that should never have been visible across tenants.</p><p>The exposed metadata included company names, owner email addresses, organizational statistics, subscription information, usage metrics, assistant counts, creation timestamps, and other internal business details.</p><p>Individually, none of those values might seem particularly dangerous. Together, they painted a surprisingly detailed picture of another customer’s environment. Even more importantly, the behavior wasn’t limited to a single organization.</p><p>Testing multiple identifiers confirmed that the issue affected multiple tenants rather than an isolated edge case.</p><p>At that point, this was no longer a simple metadata disclosure. It had become a clear <strong>Broken Access Control vulnerability</strong> demonstrating a failure of tenant isolation.</p><h3>Why Broken Access Control Matters</h3><p>Broken Access Control has remained one of the most common vulnerabilities in modern web applications because applications often verify <strong>who</strong> a user is but fail to verify <strong>what</strong> that user is actually allowed to do.</p><p>Authentication answers one question:</p><p><strong>“Who are you?”</strong></p><p>Authorization answers another:</p><p><strong>“What are you allowed to access?”</strong></p><p>In this case, the application correctly authenticated the user.</p><p>What it failed to do was verify whether that authenticated user had any legitimate reason to modify the company relationship associated with the account.</p><p>Once that trust was broken, the application’s own responses began revealing information belonging to other organizations.</p><p>The vulnerability didn’t require bypassing authentication.</p><p>It simply relied on the application trusting client-controlled relationships that should always have been enforced on the server.</p><h3>Responsible Testing</h3><p>Whenever I discover an issue like this, I try to keep my testing as limited as possible.</p><p>Although the vulnerability could have been used to enumerate additional organizations and collect considerably more metadata, I intentionally restricted testing to only a small number of companies.</p><p>The goal is never to collect data.</p><p>The goal is to demonstrate impact while minimizing unnecessary exposure.</p><p>Responsible disclosure is just as important as the vulnerability itself.</p><h3>Lessons Learned</h3><p>This assessment reinforced several lessons that continue shaping the way I approach application security.</p><p><em>First, never underestimate relationship fields inside API requests.</em></p><p>Developers often think of them as simple references, but they frequently represent trust boundaries that deserve the same level of protection as any administrative function.</p><p><em>Second, tenant isolation should never depend on values supplied by the client.</em></p><p>No matter how harmless a profile update appears, every relationship affecting authorization must always be validated on the server.</p><p><em>Finally, always stay curious</em>.</p><p>The vulnerabilities that end up having the biggest business impact rarely begin with something obviously critical.</p><p>Sometimes they begin with nothing more than a profile update that behaves just a little differently than expected.</p><h3>Conclusion</h3><p>In this case, what started as a routine review of a profile update endpoint ultimately uncovered a <strong>cross-tenant Broken Access Control vulnerability</strong> that allowed unauthorized manipulation of company relationships and disclosure of sensitive organizational metadata across multiple tenants.</p><p>The security team acknowledged the report within just <strong>six hours</strong>, confirmed the issue, and ultimately rewarded the finding with an <strong>$800 bounty</strong>.</p><p>More importantly, it served as another reminder that security isn’t only about protecting sensitive endpoints. It’s about protecting the trust relationships that hold an entire application together. Sometimes the biggest vulnerabilities aren’t hidden behind admin panels.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b945842678e2" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/how-a-simple-profile-update-led-to-cross-tenant-data-exposure-b945842678e2">How a Simple Profile Update Led to Cross-Tenant Data Exposure</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From User Enumeration to PII Exposure: Chaining Two APIs Into a $2,000 Bug]]></title>
            <link>https://infosecwriteups.com/from-user-enumeration-to-pii-exposure-chaining-two-apis-into-a-2-000-bug-adb9ed54ab30?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/adb9ed54ab30</guid>
            <category><![CDATA[api-security]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[broken-access-control]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Mon, 13 Jul 2026 11:18:23 GMT</pubDate>
            <atom:updated>2026-07-18T09:23:35.850Z</atom:updated>
            <content:encoded><![CDATA[<p>Free Article Link: <a href="https://medium.com/@ehteshamulhaq198/from-user-enumeration-to-pii-exposure-chaining-two-apis-into-a-2-000-bug-adb9ed54ab30?sk=e894290830a0b49da7eb558af5f35c89">Click for free!</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-ED0tETfpGBfpG6b72beVA.png" /></figure><p>One of the biggest mistakes developers make is thinking that if two API endpoints are individually harmless, using them together will also be harmless.</p><p>Unfortunately, that isn’t always true.</p><p>During one of my recent security assessments on <strong>target.com</strong>, I came across what initially looked like a simple user search feature inside the company’s Academy platform. At first glance, there wasn’t anything particularly exciting about it. It behaved exactly as I expected a messaging feature to behave.</p><p>Or so I thought.</p><p>As I spent more time understanding how the application worked, that seemingly harmless feature turned into a chained <strong>Broken Access Control</strong> vulnerability that allowed a low-privileged user to enumerate platform users and expose sensitive personal information at scale.</p><p>This eventually resulted in a <strong>$2,000 bounty</strong>, but more importantly, it reminded me why understanding how APIs interact is often more valuable than looking at them individually.</p><h3>Looking Beyond the First Request</h3><p>When I’m testing an application, I rarely stop after finding a single interesting response.</p><p>Instead, I ask myself one question:</p><p><strong>“Where else can this information be used?”</strong></p><p>Modern applications are built around APIs.</p><p><em>-One API creates data.<br>-Another API consumes it.<br>-A third API may enrich it.</em></p><p>Developers usually think about these endpoints individually. As security researchers, we have to think about how they work together.</p><p>That mindset has helped me find some of my favorite vulnerabilities over the years.</p><p>This assessment was no different.</p><h3>Something Didn’t Feel Right</h3><p>While exploring the Academy platform, I noticed that a normal authenticated user could interact with a feature that returned information about other users on the platform.</p><p><em>-Nothing immediately looked critical.<br>-There were no passwords.<br>-No authentication tokens.<br>-No obvious secrets.</em></p><p>But there was one thing that immediately caught my attention:</p><p><strong>internal user identifiers.</strong></p><p>To many people, those identifiers might not seem particularly valuable. To me, they usually represent the beginning of a much larger story.</p><p><strong>The response itself didn’t look dangerous — but it contained exactly what I needed to keep digging.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gLlUO4ph3bwuS0_Ps3DwRw.png" /><figcaption>The initial API response exposing internal user identifiers that later became the starting point of the access control chain.</figcaption></figure><h3>Following the Trail</h3><p>Instead of treating those identifiers as the end of the discovery, I started asking a different question.</p><p><strong>Where else does the application trust these identifiers?</strong></p><p>Applications often reuse internal IDs across multiple features.</p><p>Sometimes that’s perfectly safe. Sometimes it isn’t.</p><p>After spending some time exploring the application’s API behavior, I discovered another endpoint that accepted those same identifiers.</p><p>At that point, I wasn’t expecting much.</p><ul><li>Maybe a profile picture.</li><li>Maybe a display name.</li><li>Maybe nothing useful at all.</li></ul><p>Instead, the response contained considerably more information than it should have.</p><h3>The Real Problem Appeared</h3><p>The second API trusted those identifiers without properly verifying whether the requesting user was actually authorized to access the associated information.</p><p>That small oversight completely changed the impact of the finding.</p><p>Instead of seeing information related only to my own account, I was able to retrieve sensitive information belonging to other users.</p><p>The exposed information included personal details such as names, email addresses, profile information, and account activity data.</p><p>Even more concerning was that the behavior wasn’t limited to a single user.</p><p>The application allowed requests involving multiple users, making large-scale data extraction possible.</p><p>At that point, this was no longer just a simple user enumeration issue.</p><p>It had become a genuine <strong>Broken Access Control</strong> vulnerability with significant privacy implications.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hdfICB0A70G78s89XkbDyA.png" /><figcaption>Chaining the previously discovered identifiers into another API resulted in exposure of sensitive user information.</figcaption></figure><h3>Why Broken Access Control Matters</h3><p>Broken Access Control has remained one of the most critical security risks in modern web applications for a reason.</p><p>Authentication answers the question:</p><p><strong>“Who are you?”</strong></p><p>Authorization answers a different question:</p><p><strong>“What are you allowed to access?”</strong></p><p>When that second question isn’t enforced correctly, applications start exposing information that should never leave the server.</p><p>Sometimes it’s financial information. Sometimes it’s customer records. Sometimes it’s internal administrative functionality.</p><p>In this case, it was sensitive user information that should only have been accessible under the correct authorization rules. The vulnerability didn’t rely on bypassing authentication.</p><p>It relied on the application trusting requests that should never have been trusted in the first place.</p><h3>A Conversation About Impact</h3><p>When I submitted the report, there was one discussion that stood out.</p><p>Initially, the concern was viewed as something affecting only the Academy environment. On the surface, that sounded reasonable.</p><p>But after looking more closely at how the platform actually worked, it became clear that the Academy wasn’t operating in isolation. The same users authenticated into the company’s primary platform. That meant the exposed information didn’t belong to a separate training environment.</p><p>It belonged to real users. Once that relationship became clear, the overall impact changed significantly.</p><p><strong>That single realization completely changed the severity discussion.</strong></p><p>What initially appeared to be an isolated Academy issue was actually exposing information belonging to users of the company’s primary platform.</p><h3>Responsible Testing</h3><p>One thing I always try to keep in mind during security assessments is limiting unnecessary exposure. Although the issue could have been used to collect significantly more data, I intentionally restricted my testing to a very small sample.</p><p>The objective is always to demonstrate impact — not to expose more information than necessary. Responsible disclosure is just as important as finding the vulnerability itself.</p><h3>Lessons Learned</h3><p>This assessment reinforced several lessons that continue to shape the way I approach application security.</p><p><em>-First, don’t underestimate user identifiers. On their own, they might appear harmless. But once another part of the application trusts them without proper authorization, they can become the foundation for much larger issues.</em></p><p><em>-Second, APIs should never be evaluated in isolation. Some of the most impactful vulnerabilities don’t exist inside a single endpoint. They exist in the relationship between multiple features that developers never expected to be combined.</em></p><p>Finally, always think like an attacker. Not in terms of payloads or automation. But in terms of curiosity.</p><p><em>-Ask what happens next.<br>-Ask where the data goes.<br>-Ask who else trusts it.</em></p><p>Those questions often lead to the most interesting findings.</p><h3>Conclusion</h3><p>One of the things I enjoy most about bug hunting is that the best discoveries rarely begin with something obviously critical. Sometimes they’re hiding behind an ordinary feature that thousands of users interact with every day. In this case, what started as a simple exploration of an Academy portal eventually uncovered a chained Broken Access Control vulnerability that exposed sensitive user information through multiple APIs working together in ways they were never meant to.</p><p>More importantly, it served as another reminder that security isn’t just about finding vulnerable endpoints. It’s about understanding how an entire application behaves. Sometimes the most valuable vulnerabilities aren’t hidden inside a single request.</p><p>They’re hidden in the assumptions developers make when multiple APIs begin trusting each other. And that’s exactly where curiosity often turns into a great bug.</p><p>Every application tells a story. Sometimes, all it takes is connecting two seemingly harmless APIs to uncover the chapter no one expected. If you enjoy real-world bug bounty write-ups and application security research, feel free to follow me here on <a href="https://medium.com/@ehteshamulhaq198">Medium</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=adb9ed54ab30" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/from-user-enumeration-to-pii-exposure-chaining-two-apis-into-a-2-000-bug-adb9ed54ab30">From User Enumeration to PII Exposure: Chaining Two APIs Into a $2,000 Bug</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How a GraphQL Invitation Flow Exposed Users at Scale]]></title>
            <link>https://infosecwriteups.com/how-a-graphql-invitation-flow-exposed-users-at-scale-0dfb2bf3cc59?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/0dfb2bf3cc59</guid>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[information-security]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Mon, 25 May 2026 16:53:49 GMT</pubDate>
            <atom:updated>2026-05-28T11:55:14.801Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8ZY-M3HXh4B44p0m_y8gZA.png" /></figure><h3>A normal invite feature revealed registered accounts, internal GraphQL identifiers, and user metadata through an overly detailed API response.</h3><p>Hello readers,</p><p>I hope you’re all doing great.</p><p>In today’s article, I want to walk you through a real-world vulnerability I found while testing a GraphQL-based invitation feature on target.com. What made this finding interesting was how normal it looked at first.</p><p>It was not a classic XSS. It was not an account takeover. It was not an admin panel bypass. It was not even a hidden endpoint that immediately looked dangerous.</p><p><strong>It was just an invitation feature.</strong></p><p>But sometimes, the most useful bugs are hidden inside normal business workflows. A feature that allows users to invite other people into a workspace, team, class, project, or community can easily become a source of sensitive data exposure if the backend reveals too much information.</p><p>That is exactly what happened here.</p><p>While testing the application, I noticed that the platform allowed an authenticated user to create a community and invite multiple users by email. The functionality itself was expected. What was not expected was the amount of information the GraphQL API returned for every email address submitted.</p><p>Instead of simply saying that invitations were processed, the API revealed whether each email belonged to an existing user. And if the user existed, the response returned their GraphQL user identifier, email address, and full name.</p><p>That small behavior turned the invitation feature into a mass user enumeration endpoint.</p><h3>A Quick Look at GraphQL</h3><p>GraphQL has become very popular in modern web applications because it gives frontend applications a flexible way to request exactly the data they need. Unlike traditional REST APIs, where each endpoint usually returns a fixed response, GraphQL allows the client to define the structure of the response.</p><p>This flexibility is powerful, but it also creates security risks.</p><p>If authorization and response filtering are not handled properly, GraphQL can expose more data than intended. A single query or mutation can return nested objects, internal identifiers, user metadata, relationships, and other sensitive fields.</p><p>This makes GraphQL especially interesting from a security testing perspective because the issue is not always in the endpoint itself. Sometimes, the issue is in what the response allows the client to ask for.</p><p>In this case, the vulnerable functionality was not a public search endpoint. It was a GraphQL mutation used for creating a community and inviting users.</p><h3>Where the Issue Appeared</h3><p>The affected endpoint was:</p><pre>POST https://api.target.com/graphql/</pre><p>The vulnerable GraphQL mutation was related to creating a community object and inviting users by email.</p><p>A simplified and sanitized version of the mutation looked like this:</p><pre>{<br>  &quot;id&quot;: &quot;CreateCommunityMutation&quot;,<br>  &quot;query&quot;: &quot;mutation CreateCommunityMutation($input: CreateCommunityInput!) { createCommunity(input: $input) { community { id displayName invitations { edges { node { id email invitee { id email fullName } } } } } } }&quot;,<br>  &quot;variables&quot;: {<br>    &quot;input&quot;: {<br>      &quot;displayName&quot;: &quot;enum-test&quot;,<br>      &quot;emails&quot;: [<br>        &quot;fake1@example.com&quot;,<br>        &quot;employee@target.com&quot;,<br>        &quot;unknown@example.com&quot;<br>      ]<br>    }<br>  }<br>}</pre><p>At first glance, this looks like a normal invitation request. The user creates a community and provides a list of email addresses to invite.</p><p>The problem appears in the response.</p><h3>What the API Revealed</h3><p>When the submitted email address did not belong to an existing account, the API returned:</p><pre>&quot;invitee&quot;: null</pre><p>But when the email address belonged to a real user, the API returned detailed user information:</p><pre>&quot;invitee&quot;: {<br>  &quot;id&quot;: &quot;VXNlck5vZGU6MQ==&quot;,<br>  &quot;email&quot;: &quot;employee@target.com&quot;,<br>  &quot;fullName&quot;: &quot;Example User&quot;<br>}</pre><p>This difference in response created a reliable user enumeration issue.</p><p>An attacker could submit a list of email addresses and immediately know which ones were registered on the platform. Even worse, for valid users, the API also returned a GraphQL user identifier and profile metadata.</p><p>This means the issue was not only user enumeration. It was also internal identifier disclosure and sensitive metadata exposure.</p><h3>Why This Was More Than Basic Enumeration</h3><p>Basic user enumeration usually tells an attacker whether an account exists. That alone can be useful for phishing, password spraying, and credential stuffing.</p><p>But this case went further.</p><p>The API returned structured user data for valid accounts, including the GraphQL user identifier, email address, and full name. In some cases, these identifiers can be useful for chaining with other vulnerabilities, especially IDOR or broken access control issues.</p><p>For example, if another API endpoint uses user identifiers to fetch user data, update settings, assign roles, or manage relationships, then exposing those identifiers gives an attacker a stronger map of the backend.</p><p>This is why internal or GraphQL identifier disclosure should not always be dismissed as low impact. In modern APIs, identifiers often become the bridge between one bug and a much bigger attack chain.</p><h3>Bulk Enumeration in One Request</h3><p>The most important part of this finding was scalability.</p><p>The API accepted multiple email addresses in a single request. That means an attacker would not need to test one email at a time. They could submit a large list of emails and receive structured results in the response.</p><p>This allowed:</p><ul><li><em>Bulk user enumeration</em></li><li><em>Automated account discovery</em></li><li><em>Internal user mapping</em></li><li><em>Staff identification</em></li><li><em>Large-scale metadata collection</em></li></ul><p>Because the response was clear and predictable, automation would be very easy. An attacker could build a list of possible users, submit them through the invitation mutation, and separate valid users from invalid ones based on whether the invitee object was returned or null.</p><h3>Persistent Exposure Through Stored Invitations</h3><p>Another interesting part was that the enumerated results were not only returned once. The created community and its invitation records could later be queried again through the platform’s GraphQL data structure.</p><p>That means the attacker could build enumeration records over time and re-access previously collected invitation data later.</p><p>This persistence increased the impact because the attacker did not just receive a temporary response. The application stored the invitation objects, and those objects preserved the relationship between submitted emails and resolved users.</p><p>In practical terms, this allowed an attacker to slowly build a database of valid users and revisit that data whenever needed.</p><h3>Steps to Reproduce</h3><p>To reproduce the issue, I started with an authenticated session and captured the normal invitation request being sent to the GraphQL endpoint.</p><pre>POST /graphql/ HTTP/2<br>Host: api.target.com<br>Content-Type: application/json</pre><p>The important part was not only the email value being submitted. The issue was that the GraphQL mutation allowed the client to control the response structure through the selection set.</p><p>So instead of only creating an invitation, I crafted the mutation to also request the nested invitee object and its user fields:</p><pre>{<br>  &quot;id&quot;: &quot;CreateCommunityMutation&quot;,<br>  &quot;query&quot;: &quot;mutation CreateCommunityMutation($input: CreateCommunityInput!) { createCommunity(input: $input) { community { id displayName invitations { edges { node { id email invitee { id email fullName } } } } } } }&quot;,<br>  &quot;variables&quot;: {<br>    &quot;input&quot;: {<br>      &quot;displayName&quot;: &quot;enum-test&quot;,<br>      &quot;emails&quot;: [<br>        &quot;employee@target.com&quot;<br>      ]<br>    }<br>  }<br>}</pre><p>In this request, the submitted email was used as the lookup point. The crafted GraphQL selection set then asked the backend to return additional details about the resolved invited user.</p><p>If the email address did not belong to an existing account, the API returned:</p><pre>&quot;invitee&quot;: null</pre><p>But if the email address belonged to a valid user, the API returned the user object:</p><pre>&quot;invitee&quot;: {<br>  &quot;id&quot;: &quot;VXNlck5vZGU6MQ==&quot;,<br>  &quot;email&quot;: &quot;employee@target.com&quot;,<br>  &quot;fullName&quot;: &quot;Example User&quot;<br>}</pre><p>This confirmed that the API was resolving submitted email addresses against real platform users and exposing user details directly in the GraphQL response.</p><p>To test scalability, the same request could also be expanded with multiple email addresses in the emails array:</p><pre>&quot;emails&quot;: [<br>  &quot;fake1@example.com&quot;,<br>  &quot;employee@target.com&quot;,<br>  &quot;unknown@example.com&quot;<br>]</pre><p>The response returned one result for each submitted email.</p><p>If the email was invalid, the API returned:</p><pre>&quot;invitee&quot;: null</pre><p>If the email belonged to a real user, the API returned the user’s identifier, email address, and full name.</p><p>This made the issue easy to abuse because the same request could be used to test multiple emails and quickly separate valid users from invalid ones.</p><h3>Impact</h3><p>The impact was significant because the API gave attackers a reliable way to identify real users at scale.</p><p>With this, an attacker could collect valid accounts, user identifiers, emails, and full names. This information could then be used for targeted phishing, credential stuffing, employee identification, or further testing against other API endpoints.</p><p>The risk becomes higher because the attack was simple, scalable, and worked through normal authenticated functionality. In the right attack chain, this type of exposure could support IDOR testing, broken access control testing, or even account takeover attempts.</p><h3>Root Cause</h3><p>The root cause was excessive data exposure in the GraphQL response.</p><p>The invitation feature should not have returned full details about existing users during the invite creation process. From a product perspective, the application only needed to accept the email list and create invitation records.</p><p>It did not need to tell the requester whether each email belonged to a real user, and it definitely did not need to return user identifiers, email addresses, and full names.</p><p>This is a common GraphQL mistake. Developers expose nested fields because they are useful for the frontend, but those fields can leak sensitive relationships when accessed from the wrong workflow.</p><p>In this case, the invitee object created the issue.</p><h3>Final Thoughts</h3><p>At first, this looked like a normal invite feature. Nothing flashy, nothing obviously dangerous. But the moment I looked closely at the GraphQL response, the real issue appeared. The API was not just sending invitations. It was quietly revealing which users existed and exposing their details along the way.</p><p>That is the lesson here. In bug bounty, the best findings are not always hidden in complex exploits. Sometimes they are sitting inside simple workflows like invites, teams, workspaces, and collaboration features. So next time you see a normal-looking feature, do not skip it too quickly. Check what the API gives back. Sometimes, the real bug is not in the action itself. It is in the response.</p><p>Thanks for reading, and keep hunting those quiet places. They often reveal the most interesting bugs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dmW3nPU4XMUASNYPcbgSJQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0dfb2bf3cc59" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/how-a-graphql-invitation-flow-exposed-users-at-scale-0dfb2bf3cc59">How a GraphQL Invitation Flow Exposed Users at Scale</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Built The Hidden Finds]]></title>
            <link>https://ehteshamulhaq198.medium.com/why-i-built-the-hidden-finds-a-real-world-approach-to-saas-security-and-bug-bounty-773e31817a4d?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/773e31817a4d</guid>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[cyber-security-awareness]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[the-hidden-finds]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Sun, 19 Apr 2026 11:45:48 GMT</pubDate>
            <atom:updated>2026-10-04T09:51:50.141Z</atom:updated>
            <content:encoded><![CDATA[<p>Free Article Link: <a href="https://ehteshamulhaq198.medium.com/why-i-built-the-hidden-finds-a-real-world-approach-to-saas-security-and-bug-bounty-773e31817a4d?sk=cc12b87c74d1baffe664efc1f014ac06">Click for free!</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Mbi8aufogDbGhpeijlYHYw.png" /></figure><p>Most companies think they are secure until someone proves they are not.</p><p>I have seen it repeatedly while testing real applications. Clean interfaces, modern stacks, well funded startups, and underneath all of it the same gaps. Not nation state exploits. Simple things. An ownership check that was never written. A password reset token that never expires. A business rule that holds right up until someone sends a negative number.</p><p>That is what led me to build <a href="https://thehiddenfinds.com/">The Hidden Finds</a>.</p><h3>Where it started</h3><p>In 2021 I was not trying to build a company. I was deep in bug bounty, testing applications, reading API traffic, breaking flows, and trying to understand how systems actually fail once real people are using them.</p><p>A pattern became obvious fairly quickly. Most of what I found was not advanced. It was overlooked.</p><p>Not because the teams lacked tools, and not because nobody ran a scan. Because the systems were being tested on the surface rather than understood. A scanner can tell you a response was returned. It cannot tell you that the person who asked for it should never have been able to.</p><p>That distinction is the whole foundation of what I do now.</p><h3>The problem that has not gone away</h3><p>Working across different platforms since then, the same three things keep coming up.</p><p><strong>Security gets treated as an event.</strong> A test happens, a report is delivered, fixes go in, and everyone moves on. But the product does not stand still. Every feature, every integration, every new role quietly widens the surface. The test was accurate on the day it was written and slightly less accurate every day after.</p><p><strong>Automation gets trusted beyond what it can do.</strong> Tools are genuinely useful and I use them. They are fast at the things that have a signature. They are structurally blind to anything where the request is perfectly well formed and only the decision behind it is wrong. That is where <a href="https://thehiddenfinds.com/broken-access-control-saas-security/">broken access control</a> lives, and where <a href="https://thehiddenfinds.com/business-logic-vulnerabilities/">business logic flaws</a> live, and between them those two categories account for most of the serious findings I report.</p><p><strong>Nobody knows what they actually own.</strong> Subdomains from projects that shipped two years ago. API hosts built for a mobile client and never added to any review scope. A staging environment somebody stood up for a demo and never took down. All reachable, all part of the <a href="https://thehiddenfinds.com/why-asset-visibility-is-the-biggest-security-gap-in-modern-saas/">attack surface</a>, none of it in the inventory.</p><p>And bug bounty programmes, which can be excellent, are often launched before the team is ready for them. No triage process, no clear scope, no internal owner. The result is noise rather than value, and then the programme gets blamed.</p><h3>How I work</h3><p>The Hidden Finds was never meant to be another <a href="https://thehiddenfinds.com/penetration-testing/">pentesting service</a>.</p><p>It is built on one idea: test the way an attacker actually thinks, which means understanding the system rather than probing it.</p><p>In practice that means I spend most of my time in the places automation cannot reach. <a href="https://thehiddenfinds.com/authorization-testing-saas-guide/">Authorization and object ownership</a>. Tenant isolation in multi tenant products. Authentication and session handling. Business logic. <a href="https://thehiddenfinds.com/api-security-testing/">API security, including GraphQL</a>. These are the areas where real impact lives, and they are the areas a scanner will hand you a clean report on while the flaw sits there untouched.</p><p>The work is manual. Tools map the surface. I decide what matters. Where a team gives me access to the code, I <a href="https://thehiddenfinds.com/source-code-review/">read it line by line</a> rather than running a static analysis tool over it and sending the output.</p><p>I am one person doing this, which I think is worth saying plainly. There is no junior running a scanner and a senior signing off a template. The person who finds the issue is the person who writes it up and the person you talk to about it afterwards. That limits how much work I take on. It also means nothing gets handed down a chain.</p><h3>Beyond finding bugs</h3><p>Over time the work has grown past the testing itself.</p><p>A lot of what I do now is helping teams build better foundations. Improving <a href="https://thehiddenfinds.com/asset-monitoring/">asset visibility</a> so they know what they have exposed. Structuring how vulnerabilities get triaged internally so findings do not sit in a backlog. Preparing companies for bug bounty properly, so the programme produces signal rather than noise.</p><p>Because finding a bug is the easy half. The useful half is leaving the team able to catch the next one themselves.</p><h3>What AI is doing to the attack surface</h3><p>The most interesting shift happening right now is AI inside products.</p><p>Applications are becoming more connected and less predictable. <a href="https://thehiddenfinds.com/ai-agent-security-saas-attack-surface/">An AI feature with tool access is not a chatbot</a>, it is a user with credentials and the ability to act. Every system it can call, every dataset it can read, every action it can take without a human confirming it, all of that is attack surface that did not exist in the architecture diagram last year.</p><p>I am actively working in this area, both in how I test these systems and in helping teams understand what changes when they add one. The biggest risk is not the model. It is misunderstanding what the model is now allowed to do.</p><p>Over the next five to ten years this becomes one of the most important areas in application security. I would rather be building the approach now than catching up later.</p><h3>What I am building</h3><p>The Hidden Finds is still growing and the direction is clear.</p><p>Deeper into real application security. Longer relationships with the companies I work with rather than one off engagements. And continuing to adapt as systems change, particularly with AI.</p><p>The goal is not to be another service provider. It is to be the person a company calls when security actually matters, and to be worth calling.</p><h3>The thing worth remembering</h3><p>If bug bounty and five years of real testing have taught me one thing, it is that the dangerous vulnerabilities are rarely the complicated ones. They are the ones nobody looked for.</p><p>So if you are building a SaaS product, an API, or any modern platform, do not only ask whether your system is secure. Ask what you might be missing.</p><p>If you want to see how I approach this work, or you are building something and want to take security more seriously, <a href="https://thehiddenfinds.com/about/">start here</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wLAj8QajCpTTnxpYAg97fQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=773e31817a4d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Delaying Certifications to Passing eJPT: My Real Journey]]></title>
            <link>https://infosecwriteups.com/from-delaying-certifications-to-passing-ejpt-my-real-journey-5dbebaf5b8c0?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/5dbebaf5b8c0</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[bug-bounty-tips]]></category>
            <category><![CDATA[cybersecurity-training]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[cyber-security-awareness]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Wed, 25 Mar 2026 11:14:34 GMT</pubDate>
            <atom:updated>2026-03-26T08:00:35.689Z</atom:updated>
            <content:encoded><![CDATA[<p>Free Article Link: <a href="https://ehteshamulhaq198.medium.com/from-delaying-certifications-to-passing-ejpt-my-real-journey-5dbebaf5b8c0?sk=d2ab715da169ec0fd683ccb8282daa59">Click for free!</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ch-SQtLpq5g647FGGmvbeA.png" /></figure><p>Let’s be honest — certifications always sound like a good idea… until you actually try to fit them into your daily life. Back in 2024, I started thinking seriously about doing some cybersecurity certifications. Not because everyone was doing them, but because I wanted to build a stronger foundation for myself.</p><p>But there was one problem — work.</p><p>Between freelancing, bug bounty hunting, and managing everything else, it’s honestly not easy to stay consistent with studies. Days pass, weeks pass, and suddenly that “I’ll start soon” turns into months.</p><p>And that’s exactly what happened.</p><h3>Starting Small in 2025</h3><p>In 2025, I finally decided to stop delaying and just start.</p><p>Instead of jumping straight into something big, I began with a few certifications on Coursera, including the Google Cybersecurity Professional Certificate, IBM Cybersecurity courses, and some other beginner-friendly programs.</p><p>I’ve also shared my full experience with the Google certification here:<br><a href="https://medium.com/bugbountywriteup/google-cybersecurity-certificate-and-why-its-the-easiest-way-to-step-into-the-field-4292d2ec1f3a">https://medium.com/bugbountywriteup/google-cybersecurity-certificate-and-why-its-the-easiest-way-to-step-into-the-field-4292d2ec1f3a</a></p><p>These helped me a lot. Not because they made me an expert, but because they helped me <strong>understand how to think in security</strong>. At the same time, I was already doing bug bounty — testing applications, exploring endpoints, finding small issues, and learning in my own way.</p><p>But still, something felt missing. I wanted something more practical. Something that actually tests you.</p><h3>Why I Chose eJPT</h3><p>According to my roadmap, the next step was clear: eJPT.</p><p>I had heard about it before — a practical certification focused on real penetration testing. It felt like the right step forward, especially since I was already exploring bug bounty.</p><p>So I decided to go for it.</p><h3>Preparing for eJPT</h3><p>I didn’t rush into it.</p><p>I spent around <strong>3–4 months preparing</strong> for the exam. Not every day was perfect — some days I studied, some days I didn’t — but I tried to stay consistent. What helped me the most was following the official material properly, watching YouTube reviews, reading other people’s experiences, and collecting as much information as possible before starting seriously.</p><p>That last part really matters.</p><p>Before jumping in, I made sure I understood what the exam looks like, how it works, and what to expect.</p><h3>The Experience (What I Learned)</h3><p>Even though I was already doing bug bounty, this course was honestly an <strong>awakening experience</strong> for me.</p><p>It helped me understand the full penetration testing process in a more structured way. Instead of randomly testing things, I started thinking step by step — recon, enumeration, exploitation — everything with a clear approach.</p><p>It also improved how I look at targets. I became more patient, more methodical, and more aware of small details that I might have ignored before.</p><p>In bug bounty, we sometimes jump straight into testing. But eJPT teaches you to slow down and follow a proper flow.</p><p>And that made a difference for me.</p><h3>The Exam</h3><p>The exam itself is practical.</p><p>You get access to a lab environment where you have to scan, enumerate, exploit, and answer questions based on your findings. You usually get <strong>two attempts</strong>, which gives some peace of mind. For me, I was able to pass on the <strong>first attempt</strong>. Nothing special, honestly. I just followed the material, understood the concepts, and stayed calm during the exam.</p><h3>My Advice (If You’re Planning eJPT)</h3><p>If you’re planning to take eJPT, here are a few simple things that can help:</p><p><em>-Don’t rush the process.<br>-Go through the official material properly.<br>-Watch multiple reviews and walkthroughs.<br>-Understand the exam format before attempting.<br>-Take notes while studying.</em></p><p>The more clarity you have before starting, the smoother your preparation will be.</p><h3>My Certification</h3><p>I successfully completed the <strong>INE Junior Penetration Tester (eJPT)</strong> certification. It covers areas like assessment methodologies, web application penetration testing, host and network testing, and auditing.</p><p>Issued on: February 21, 2026<br>Valid until: February 21, 2029</p><p>You can view my certification here:<br><a href="https://certs.ine.com/e32d53b0-9ef9-446b-a811-d42d12f98571#acc.QlgDM06R">https://certs.ine.com/e32d53b0-9ef9-446b-a811-d42d12f98571#acc.QlgDM06R</a></p><h3>What’s Next?</h3><p>This is just one step in the journey. Moving forward, I’m planning to prepare for <strong>OSCP</strong>, and hopefully attempt it this year. It’s one of the most important certifications in this field, and I’m really looking forward to the challenge.</p><h3>Conclusion</h3><p>Looking back, starting this journey wasn’t easy — especially with a busy schedule and everything else going on. But taking that first step made all the difference. eJPT didn’t magically turn me into an expert, but it gave me something more important — a solid foundation and a better way of thinking. If you’re someone who’s unsure about where to start, or you keep delaying like I did, just begin. Even small progress matters.</p><p>Consistency beats perfection. And if you’re on this path too — just start.</p><p>Thanks for reading. I really appreciate your time.</p><p>If you’re interested in bug bounty, penetration testing, or real-world security learning, feel free to follow — I’ll be sharing more experiences, write-ups, and insights along the way.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5dbebaf5b8c0" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/from-delaying-certifications-to-passing-ejpt-my-real-journey-5dbebaf5b8c0">From Delaying Certifications to Passing eJPT: My Real Journey</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Breaking the Trust Boundary: SSRF via a Misconfigured Sentry Tunnel]]></title>
            <link>https://infosecwriteups.com/breaking-the-trust-boundary-ssrf-via-a-misconfigured-sentry-tunnel-ed054820b743?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed054820b743</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[ssrf]]></category>
            <category><![CDATA[cloud-security]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[infosec]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Tue, 17 Feb 2026 09:51:24 GMT</pubDate>
            <atom:updated>2026-04-21T11:13:58.269Z</atom:updated>
            <content:encoded><![CDATA[<p>Free Article Link: <a href="https://ehteshamulhaq198.medium.com/breaking-the-trust-boundary-ssrf-via-a-misconfigured-sentry-tunnel-ed054820b743">Click for free!</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ev-P-TqW3EviuvaIKZ0gcA.png" /></figure><p>Hello readers,<br>Sometimes the most interesting vulnerabilities are not hiding in login forms, password reset flows, or API endpoints — they hide in the background. This story started with a feature that most testers completely ignore: an error logging endpoint.<br>While testing <strong>target.com</strong>, I noticed a request being sent to an endpoint called:</p><pre>POST /tunnel/</pre><p>At first glance, it looked harmless. Just telemetry. Just logging. Just Sentry doing its thing. But security testing has taught me one important rule:<br>If the server makes a request based on something I control — I look closer. And that’s exactly what happened here.</p><p><em>For more real-world SaaS security research and application security testing insights, explore:<br></em><a href="https://thehiddenfinds.com/blog/"><em>https://thehiddenfinds.com/blog/</em></a></p><h3>Before We Dive In — What Is SSRF?</h3><p>Server-Side Request Forgery (SSRF) happens when an application allows user-controlled input to influence a server-side HTTP request.</p><p>In simple terms:</p><p>Instead of sending requests directly to a system, I trick the server into sending them on my behalf.</p><p>Why does that matter?</p><p>Because servers can access internal services, reach private infrastructure, are trusted within the network, and sometimes can access cloud metadata endpoints.</p><p>SSRF turns the backend into an HTTP client controlled by the attacker.</p><p>And when that happens, things get interesting.</p><h3>Where SSRF Usually Hides</h3><p>In my experience, SSRF often appears in:</p><ul><li>Webhook integrations</li><li>File import features</li><li>URL preview generators</li><li>PDF converters</li><li>API proxies</li><li>Image fetchers</li><li>Analytics relays</li><li>Telemetry forwarding endpoints</li></ul><p>Notice something?</p><p>Most of these are not “core” features.<br> They’re integrations.</p><p>That’s important.</p><h3>The Small Detail That Changed Everything</h3><p>During testing, one request caught my attention. While analyzing requests in an authenticated session, I intercepted:</p><pre>POST /tunnel/</pre><p>Inside the request body, I saw something that made me pause.</p><p>A <strong>DSN parameter</strong>.</p><p>For those unfamiliar, a DSN (Data Source Name) tells Sentry where to send telemetry data. It usually contains a host.</p><p>And here’s the part that mattered:</p><ul><li><em>The DSN was coming from the client.</em></li><li><em>It wasn’t hardcoded server-side.</em></li><li><em>That means I could modify it.</em></li></ul><p>So I did.</p><h3>The Test</h3><p>To confirm exploitation:</p><ol><li>The DSN host was replaced with an attacker-controlled domain.</li><li>The modified request was sent to /tunnel/.</li><li>A server-side HTTP POST request was observed on Burp Collaborator.</li><li>The source IP corresponded to the target’s backend infrastructure.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ci4FV7xdQNgBnhhH-uXY9g.png" /></figure><p>This confirmed that the application was accepting user-controlled input and using it to perform arbitrary outbound HTTP requests — a clear Server-Side Request Forgery vulnerability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5X1Fle6zdWqzLF43ole8fA.png" /></figure><h3>What Actually Happened</h3><p>The backend processed the attacker-controlled DSN value, extracted the host component, and used it to initiate a server-side HTTP POST request. At no point was the destination validated or restricted through an allowlist. As a result, the application effectively behaved as an arbitrary outbound HTTP client. While my proof of concept demonstrated interaction with an external domain, the underlying issue is broader — if external hosts are permitted without validation, the same logic could potentially be applied to internal or sensitive network resources.</p><h3>Why This Is Dangerous</h3><p>When an application performs outbound HTTP requests without validation, it opens the door to:</p><ul><li><em>Arbitrary outbound HTTP interactions</em></li><li><em>Infrastructure abuse</em></li><li><em>Telemetry data exfiltration</em></li><li><em>Potential access to internal services</em></li><li><em>Trust boundary violations</em></li></ul><p>Even if internal network access is restricted, the mere ability to control outbound requests is a serious issue, because the attacker now dictates where the server communicates.</p><p>Security issues like SSRF often emerge from overlooked components such as integrations and telemetry systems. For more breakdowns of similar real-world vulnerabilities, visit:<br><a href="https://thehiddenfinds.com/blog/">https://thehiddenfinds.com/blog/</a></p><h3>The Root Cause</h3><p>The root cause of this issue was the application’s reliance on client-supplied configuration. The DSN value was accepted without proper validation and used directly to determine the destination of server-side requests. This represents a clear trust boundary violation, as user-controlled input was allowed to influence backend routing logic. Telemetry endpoints are intended to forward data to predefined, trusted services — not function as unrestricted HTTP relays</p><h3>How It Was Fixed</h3><p>The proper mitigation was straightforward:</p><ul><li><em>Enforce a strict allowlist (only trusted Sentry domains)</em></li><li><em>Reject arbitrary DSN values</em></li><li><em>Ensure the tunnel endpoint cannot act as a proxy</em></li><li><em>Monitor unexpected outbound destinations</em></li></ul><p>After applying validation, attacker-controlled domains were no longer reachable.</p><h3>Why This Finding Stood Out</h3><p>What makes this case stand out is less the SSRF itself than its context. The vulnerable endpoint was not part of a standard data-processing workflow or a typical API integration; it was a telemetry tunnel used for logging and error reporting. This demonstrates that critical security issues can exist in overlooked components, highlighting the importance of reviewing all paths where user-controlled input might influence backend operations.</p><h3>Conclusion</h3><p>This case reinforced something I’ve learned repeatedly in bug bounty: Never ignore “boring” endpoints. Logging systems, analytics, monitoring integrations, and third-party relays often sit outside the main business logic — and that’s exactly why they are overlooked.<em> </em>SSRF may seem simple, but context matters. A single misconfiguration can turn a helper endpoint into a powerful attack primitive. I hope you enjoyed this walkthrough and found it insightful. If you’re interested in real-world vulnerability research, SaaS security testing, and practical application security insights, explore more here:<br><a href="https://thehiddenfinds.com/blog/">https://thehiddenfinds.com/blog/</a></p><p>Or learn more about The Hidden Finds:<br><a href="https://thehiddenfinds.com/">https://thehiddenfinds.com/</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pbkgdlYZMMV-8T359wpdsw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed054820b743" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/breaking-the-trust-boundary-ssrf-via-a-misconfigured-sentry-tunnel-ed054820b743">Breaking the Trust Boundary: SSRF via a Misconfigured Sentry Tunnel</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Breaking the Same-Origin Policy: A Dive into a CORS Misconfiguration]]></title>
            <link>https://infosecwriteups.com/breaking-the-same-origin-policy-a-dive-into-a-cors-misconfiguration-b6174b0abee6?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6174b0abee6</guid>
            <category><![CDATA[cors]]></category>
            <category><![CDATA[owasp-top-10]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[misconfiguration]]></category>
            <category><![CDATA[api]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Mon, 05 Jan 2026 17:24:11 GMT</pubDate>
            <atom:updated>2026-01-06T05:29:52.486Z</atom:updated>
            <content:encoded><![CDATA[<p>Free Article Link: <a href="https://ehteshamulhaq198.medium.com/breaking-the-same-origin-policy-a-dive-into-a-cors-misconfiguration-b6174b0abee6?sk=9393433964303913047af8f80c4c4d51">Click for free!</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dgQqRhkW47L6-4CLTHcBZA.png" /></figure><h3>Introduction: What Is CORS and Why It Matters</h3><p>Cross-Origin Resource Sharing (CORS) is a browser security mechanism that controls how web applications allow resources to be requested from domains other than their own.</p><p>By default, browsers enforce the <strong>Same-Origin Policy (SOP)</strong>, which prevents a website from reading responses from another domain. This is a foundational security control that protects users from malicious websites stealing sensitive data from authenticated sessions.</p><p>CORS exists to <strong>safely relax</strong> this restriction when cross-origin access is legitimately required — for example, when a frontend application hosted on one domain needs to communicate with an API hosted on another.</p><p>CORS behavior is enforced entirely through <strong>HTTP response headers</strong>, most notably:</p><ul><li>Access-Control-Allow-Origin</li><li>Access-Control-Allow-Credentials</li><li>Access-Control-Allow-Methods</li><li>Access-Control-Allow-Headers</li></ul><p>When implemented correctly, CORS enables secure cross-domain communication.<br> When misconfigured, however, it can turn a user’s browser into a <strong>data exfiltration tool</strong>.</p><h3>Why CORS Misconfigurations Are Dangerous</h3><p>A CORS issue becomes <strong>high-impact</strong> when the following conditions align:</p><ul><li>The endpoint is <strong>authenticated</strong></li><li>The server allows credentials<br> (Access-Control-Allow-Credentials: true)</li><li>The server <strong>reflects or allows untrusted origins</strong></li><li>The response contains <strong>sensitive data</strong></li></ul><p>When this happens, an attacker does not need to bypass authentication, steal passwords, or break encryption.<br> They simply let the browser do the work.</p><h3>How to Test for CORS Vulnerabilities</h3><h3>1. Identify High-Value Endpoints</h3><p>Focus on endpoints that return sensitive or user-specific data, such as:</p><ul><li>User profiles</li><li>Account details</li><li>Subscription or billing information</li><li>Admin or internal APIs</li></ul><p>Common paths to review include:</p><pre>/api<br>/v1<br>/accounts<br>/user<br>/profile</pre><p>Authenticated endpoints should always be treated as <strong>high priority</strong>.</p><h3>2. Inject a Malicious Origin</h3><p>CORS testing starts by manually injecting an Origin header into the request:</p><pre>Origin: https://www.evil.com</pre><p>Even if the original request does <strong>not</strong> include an Origin, modern browsers automatically add it for cross-origin requests — meaning the server must handle it securely.</p><h3>3. Analyze the Response Headers</h3><p>Carefully inspect the response for:</p><ul><li>Access-Control-Allow-Origin</li><li>Access-Control-Allow-Credentials</li></ul><p>🚨 <strong>Red flags include</strong>:</p><ul><li>Origin reflection</li><li>Allowing arbitrary domains</li><li>Using wildcards with credentials</li></ul><h3>4. Confirm Data Exposure</h3><p>Finally, confirm that:</p><ul><li>The request is authenticated (cookies or session included)</li><li>The response contains sensitive data</li><li>The browser allows reading the response</li></ul><p>If all three are true, exploitation is confirmed.</p><h3>Walkthrough: Discovering a Critical CORS Misconfiguration on target.com</h3><h3>Target Overview</h3><ul><li><strong>Masked Domain:</strong> target.com</li><li><strong>Endpoint:</strong> /api/v1/accounts</li><li><strong>Authentication:</strong> Cookie-based session</li><li><strong>Response Type:</strong> JSON (User account data)</li></ul><h3>Step 1: Initial Observation</h3><p>While testing authenticated functionality, I identified an API endpoint (/api/v1/accounts) that returns detailed user account information for logged-in users.</p><p>At first glance, the request did <strong>not</strong> include an Origin header — which is normal for same-origin requests.</p><h3>Step 2: Manual Origin Injection</h3><p>To evaluate CORS behavior, I manually injected a malicious origin into the request:</p><pre>Origin: https://www.evil.com</pre><p>This simulates a realistic attack scenario where a victim is logged into target.com and then visits an attacker-controlled website.</p><h3>Step 3: Server Response Analysis</h3><p>The server responded with the following headers:</p><pre>Access-Control-Allow-Origin: https://www.evil.com<br>Access-Control-Allow-Credentials: true</pre><p>This confirms that:</p><ul><li>An <strong>attacker-controlled origin is trusted</strong></li><li><strong>Credentials are explicitly allowed</strong></li><li>The browser is permitted to read cross-origin responses</li></ul><p>At this point, the CORS policy is already broken.</p><h3>Step 4: Data Exposure Confirmation</h3><p>The response body contained <strong>highly sensitive authenticated user data</strong>, including:</p><ul><li>User ID</li><li>Username</li><li>Email address</li><li>Account and subscription status</li><li>Financial balance details</li><li>Registration metadata</li></ul><p>This confirms full exploitability.</p><h3>The screenshot demonstrates:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sFVSJQZvk1IwjPVp9BgkxA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_99ohh83h2pTc90caUthZA.png" /></figure><ul><li>Manual Origin injection</li><li>Reflected Access-Control-Allow-Origin header</li><li>Access-Control-Allow-Credentials: true</li><li>Exposure of authenticated account data</li></ul><blockquote><em>The actual domain name has been masked for responsible disclosure.</em></blockquote><h3>Proof of Exploitation Scenario</h3><p>An attacker could host the following JavaScript on a malicious website:</p><pre>&lt;script&gt;<br>fetch(&quot;https://target.com/api/v1/accounts&quot;, {<br>  credentials: &quot;include&quot;<br>})<br>.then(res =&gt; res.json())<br>.then(data =&gt; {<br>  // Exfiltrate user data<br>  console.log(data);<br>});<br>&lt;/script&gt;</pre><p>Any logged-in user who visits the attacker’s site would unknowingly leak their account data — with <strong>no prompts, no warnings, and no interaction required</strong>.</p><h3>Severity Assessment</h3><p><strong>Severity: CRITICAL</strong></p><p><strong>Why this matters:</strong></p><ul><li>Authenticated endpoint affected</li><li>Arbitrary origin allowed</li><li>Credentials enabled</li><li>Exposure of PII and financial data</li><li>Silent, scalable exploitation</li></ul><p>This vulnerability enables <strong>browser-level data theft at scale</strong>.</p><h3>Remediation</h3><p><strong>1. Never reflect arbitrary origins</strong></p><pre>Access-Control-Allow-Origin: https://target.com</pre><p><strong>2. Avoid credentials unless strictly required</strong></p><pre>Access-Control-Allow-Credentials: false</pre><p><strong>3. Apply consistent CORS policies</strong></p><ul><li>Across all authenticated API endpoints</li><li>Across subdomains and legacy services</li></ul><p><strong>4. Conduct a full CORS audit</strong></p><ul><li>APIs</li><li>Subdomains</li><li>Internal services</li></ul><h3>Conclusion</h3><p>CORS vulnerabilities are often underestimated because they do not rely on traditional exploitation techniques. However, as shown in this walkthrough, a <strong>single misconfigured response header</strong> can completely bypass browser security boundaries.</p><p>This finding highlights why <strong>manual origin injection, careful header analysis, and authenticated endpoint testing</strong> are essential components of modern security assessments.</p><p><strong>Thank you for reading.</strong><br>If you found this walkthrough useful, feel free to <strong>follow for more real-world vulnerability research and security insights</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WTciZk7E7UYOrdeUS-kWSg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6174b0abee6" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/breaking-the-same-origin-policy-a-dive-into-a-cors-misconfiguration-b6174b0abee6">Breaking the Same-Origin Policy: A Dive into a CORS Misconfiguration</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reflected XSS in OAuth Callback Endpoint]]></title>
            <link>https://infosecwriteups.com/reflected-xss-in-oauth-callback-endpoint-77ef41c0b011?source=rss-989978ba49fe------2</link>
            <guid isPermaLink="false">https://medium.com/p/77ef41c0b011</guid>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[xss-attack]]></category>
            <category><![CDATA[reflected-xss]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Ehtesham Ul Haq]]></dc:creator>
            <pubDate>Wed, 03 Dec 2025 19:23:41 GMT</pubDate>
            <atom:updated>2025-12-15T08:34:55.133Z</atom:updated>
            <content:encoded><![CDATA[<p>Free Article Link: <a href="https://ehteshamulhaq198.medium.com/reflected-xss-in-oauth-callback-endpoint-77ef41c0b011?sk=30704e6650492dec8d0e05565d842bd4">Click for free!</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*I88ahL_CPRdJRNWVuuCQ8A.png" /></figure><p>Hello readers,</p><p>While testing an OAuth implementation on target.com, I came across a <strong>reflected XSS vulnerability</strong> that I found interesting and worth sharing. Even though XSS is one of the older web security issues, it still pops up in modern applications — and when it hits authentication flows like OAuth, it can have serious consequences.</p><p>In this article, I’ll walk you through what I found, why it’s important, and how it could be exploited if left unpatched.</p><h3>Understanding Reflected XSS</h3><p>Reflected cross-site scripting happens when an application takes user-supplied input and includes it in the page without proper validation or encoding. The input is then interpreted by the browser as executable code.</p><p>Unlike stored XSS, which persists on the server, reflected XSS is “instantaneous” — it executes as soon as someone clicks a crafted link. Because it’s often delivered via URLs, it’s especially dangerous in phishing attacks: a malicious URL can appear to be part of a trusted site, tricking users into executing scripts in their browser.</p><p>When this kind of vulnerability appears in sensitive endpoints like OAuth callbacks, attackers could potentially hijack sessions, steal tokens, or even manipulate authentication flows.</p><h3>What I Found</h3><p>During my testing, I noticed that the error parameter in the OAuth callback endpoint on target.com was reflected back into the page without any encoding. In other words, any JavaScript I added to that parameter would execute in the context of the site.</p><p>Here’s a simple example I used for testing:</p><pre>https://target.com/auth/callback?error=1&lt;/script&gt;&lt;script&gt;alert(document.cookie)&lt;/script&gt;</pre><p>Loading this URL in a browser triggers the JavaScript alert, showing the cookies for that session. This is the classic “proof-of-concept” signal for a reflected XSS vulnerability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kioq6VN-rGMJf5TxIXjppA.png" /></figure><h3>Why It Happened</h3><p>This issue typically arises from a few common mistakes:</p><ul><li><strong>No output encoding:</strong> The application was inserting user input directly into the page HTML.</li><li><strong>No parameter validation:</strong> Arbitrary values were accepted for the error parameter.</li><li><strong>No Content Security Policy (CSP):</strong> Inline scripts were allowed, making it easy for injected JavaScript to run.</li><li><strong>Cookies not HttpOnly:</strong> This increases the risk of session theft.</li></ul><p>Combined, these factors made it possible to execute arbitrary JavaScript in a trusted page.</p><h3>Proof-of-Concept</h3><p>For anyone testing in a safe, authorized environment, the following URL demonstrates the vulnerability:</p><pre>https://target.com/auth/callback?error=1&lt;/script&gt;&lt;script&gt;alert(document.cookie)&lt;/script&gt;</pre><p>You can also test encoded versions or inject into attributes depending on how the input is used:</p><ul><li><strong>Encoded URL:</strong></li></ul><pre>https://target.com/auth/callback?error=1&lt;/script&gt;&lt;script&gt;alert(document.cookie)&lt;/script&gt;</pre><ul><li><strong>Attribute injection:</strong></li></ul><pre>https://target.com/auth/callback?error=&quot;onload=alert(1)</pre><p>Even these simple examples show that an attacker could manipulate the page, steal session data, or redirect users to malicious sites.</p><h3>Impact</h3><p>The consequences of this reflected XSS depend on the context, but in this case, the OAuth callback endpoint made it particularly sensitive:</p><ul><li><strong>Session and token theft:</strong> If cookies aren’t HttpOnly, an attacker can grab them via JavaScript.</li><li><strong>Account takeover:</strong> Captured tokens could allow full access to accounts.</li><li><strong>Phishing attacks:</strong> The endpoint could be used to craft links that appear trustworthy.</li><li><strong>OAuth flow manipulation:</strong> Targeted attacks could disrupt authentication or gain unauthorized access.</li></ul><p>Even a “small” reflected XSS can become a serious issue if it’s in a trusted part of the application.</p><h3>Steps to Reproduce</h3><blockquote><strong><em>Important:</em></strong><em> Only test on authorized systems or your own staging environment.</em></blockquote><ol><li>Open a browser with a clean session.</li></ol><p>2. Navigate to:</p><pre>https://target.com/auth/callback?error=1&lt;/script&gt;&lt;script&gt;alert(document.cookie)&lt;/script&gt;</pre><p>3. An alert will show the cookies, indicating script execution.</p><p>Optional: You can simulate the request using curl:</p><pre>curl -i -k &quot;https://target.com/auth/callback?error=1&lt;/script&gt;&lt;script&gt;alert(document.cookie)&lt;/script&gt;&quot;</pre><h3>Recommendations</h3><p>To prevent this kind of XSS, I suggest the following measures:</p><ol><li><strong>Validate input:</strong> Only accept known safe values for error or callback parameters.</li><li><strong>Encode output:</strong> Escape HTML characters before rendering any user input.</li><li><strong>HttpOnly and Secure cookies:</strong> Protect session cookies from JavaScript access.</li><li><strong>Implement CSP:</strong> Use restrictive policies and avoid allowing inline scripts.</li><li><strong>Avoid reflecting debug info:</strong> Never echo user input directly in production pages.</li></ol><h3>Conclusion</h3><p>Reflected XSS remains a common and potentially dangerous vulnerability. In this case, the combination of an unsanitized error parameter and an OAuth callback endpoint made the risk higher than usual. Even small oversights like this can lead to serious consequences if attackers craft targeted links. Proper input validation, output encoding, secure cookie handling, and CSP enforcement are key to keeping applications safe. Responsible testing and reporting help ensure users remain protected and highlight areas developers need to secure.</p><p>If you enjoyed this write-up, check out some of my previous XSS reports:</p><ul><li><a href="https://medium.com/@ehteshamulhaq198">How a Simple Redirect Led to a $550 XSS Vulnerability</a></li><li><a href="https://medium.com/@ehteshamulhaq198">Stored XSS Led to OAuth App Credential Theft and Info Disclosure</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/813/1*TsLsc_ydjLW_KjHB9kQHVQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=77ef41c0b011" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/reflected-xss-in-oauth-callback-endpoint-77ef41c0b011">Reflected XSS in OAuth Callback Endpoint</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>