<?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 Entit_y on Medium]]></title>
        <description><![CDATA[Stories by Entit_y on Medium]]></description>
        <link>https://medium.com/@entit_y?source=rss-7e61242b7a49------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*5hCE-FddZWFVFSMx8Eeu3g.jpeg</url>
            <title>Stories by Entit_y on Medium</title>
            <link>https://medium.com/@entit_y?source=rss-7e61242b7a49------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 00:03:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@entit_y/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[“Contextual Hacking”: A Guide To Active Reconnaissance & Vulnerability Exploitation]]></title>
            <link>https://medium.com/@entit_y/contextual-hacking-a-guide-to-active-reconnaissance-vulnerability-exploitation-41b266516a5a?source=rss-7e61242b7a49------2</link>
            <guid isPermaLink="false">https://medium.com/p/41b266516a5a</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[web-hacking]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[ethical-hacking]]></category>
            <dc:creator><![CDATA[Entit_y]]></dc:creator>
            <pubDate>Fri, 12 Dec 2025 23:04:17 GMT</pubDate>
            <atom:updated>2025-12-16T21:21:25.644Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>Bug bounty hunting isn’t easy. If you entered this field thinking you’d make quick cash, you’ve probably learned this fact the hard way — just like I did. Facing this difficulty, the community has hyper-focused on the most automatable &amp; mostly simple first step: <strong>reconnaissance </strong>(recon).</p><p>It makes sense. Finding subdomains, endpoints, and secrets with tools is straightforward, creating a comforting illusion of progress. But this has reduced “recon” to mostly <strong>passive data collection</strong>.<br>The true challenge — the <strong>active process</strong> of understanding a target to find vulnerabilities — is often treated as a separate, individual problem (which I guess it Kinda is). This leaves a critical gap: you get a map, but no strategy to navigate the terrain.</p><p>This blog is about closing that gap. It’s a methodology to move from passive listing to active hacking, connecting what you find to how you exploit it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v1JqU5VM84o0zQ9qBkQCLg.jpeg" /><figcaption>Viktor The Saviour</figcaption></figure><p><strong>Recon falls into two categories:</strong></p><h4>Passive Recon</h4><p>This is where most guides focus: using the latest scanning tools or subdomain finders. It means gathering info about the target without <strong>you</strong> actually touching it directly.</p><h4>Active Recon</h4><p><strong>Educators often gloss over this because it requires an adaptable methodology</strong>, not just a tool command. They might say “understand the app” or “click every button,” but that’s practically vague.<br>Active recon means interacting with the target to learn more about it.</p><p>Most bug hunters mix both types. A typical process looks like this:</p><ul><li>Find subdomains</li><li>Map out the architecture</li><li>Fingerprint technologies</li><li>Brute-force endpoints</li><li>Grep for secrets in JavaScript</li></ul><p>Here’s the problem: <strong>You’re not the only one doing this</strong>. As a beginner, you’re using tools others built and shared. Think you’re the only one? I promise you’re not , everyone from newbies to pros is doing the same. You’re not gaining an edge; <strong>you’re just wasting time</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iwkZvxZMXAlFW4XXHzVaeA.png" /></figure><p>Don’t get me wrong, <strong>passive recon is extremely useful</strong>. But it’s pointless if you don’t know what to do next. You’ve found subdomains? Great. Now hack them. In this blog, I’ll share a <strong>framework </strong>to help you do just that.</p><h3>Part 1: The Methodology Gap in Bug Bounty</h3><p>If you’ve tried going beyond basic <strong>passive recon</strong>, you’ve likely faced this:</p><ul><li>Scattered notes everywhere</li><li>Disconnected bits of knowledge</li><li>Bookmarked write-ups on Twitter you promise to read later (you never do lol)</li><li>Frustration from forgetting where you saw a technique for a specific scenario (buried in bookmarks)</li><li>Trouble applying PortSwigger lab skills to real apps</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*28t1IRHTfOY4-Uf5Sc2N2g.png" /><figcaption>Messy System Of Hacking</figcaption></figure><p>You’re not alone. I call this the “<strong>Methodology Gap</strong>” — a systemic flaw in how bug bounty education is structured. It’s like trying to build a house with a pile of random bricks, nails, and wood scattered across a field: you have the materials, but no blueprint to connect them into something functional. This gap arises from the fragmented nature of learning resources — tutorials, videos, and blogs that teach isolated techniques without showing <strong>how they fit into a larger, adaptable process</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W9E__3RZgSjUaF3eSVubYw.png" /></figure><p>Why does this happen? The root cause lies in the current educational model, which emphasizes memorizing individual vulnerabilities or tools in silos. For instance, you might watch a video on SQL injection that dives deep into payloads and syntax but skips how to identify the right context in a real app, like spotting vulnerable database interactions where database interactions <strong>most likely</strong> exist.</p><p>This model is caused by the sheer volume of information available; educators, often experts themselves, assume learners can connect the dots. But for beginners, it leads to a cognitive overload.<br>Knowledge feels like puzzle pieces from different boxes, making it impossible to assemble.</p><p>This disconnected approach directly fuels what I call “<strong>Single-Vulnerability Tunnel Vision</strong>.” Here’s how it unfolds: Standard advice in bug bounty communities is to “<strong>pick one vulnerability class and start hunting for it</strong>”, like focusing solely on XSS or IDOR.</p><p>This is well-intentioned — it aims to reduce cognitive overload mentioned earlier by letting beginners master one thing at a time without drowning in the vast sea of hacking concepts. For example, a newbie learns about XSS, memorizes payloads like &lt;script&gt;alert(1)&lt;/script&gt;, and then starts testing every input field they see, hoping to trigger a pop-up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ituoQeh8nB9MsciQNMAZ8Q.png" /><figcaption>Single Vulnerability Tunnel Vision 1</figcaption></figure><p>This approach seems like the best way at first, but it backfires because it encourages viewing every vector (like a URL parameter or form field) as a potential pathway to that specific vuln, <strong>without considering context</strong>. Suddenly, a harmless search bar becomes “the perfect spot for XSS” in their mind, even if the app sanitizes inputs perfectly or doesn’t behave in the required ways to enable XSS. This tunnel vision leads to beginners missing other potential or more viable vulnerabilities in the application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1kVeXIuirFGMeg8kRXkIZA.png" /><figcaption>Single Vulnerability Tunnel Vision 2</figcaption></figure><p>While sticking to one vuln class is a good starting point for building confidence, the advice falls short because it doesn’t append the crucial step: <strong>extracting the context that enables the vuln</strong>. The current model treats attacks as atomic — <strong><em>self-contained events that exist in isolation</em></strong>— which simply isn’t true.</p><p>Vulnerabilities don’t appear out of thin air; they’re born from specific interactions in an app’s environment. The advice ‘pick one vulnerability class and master it’ is sound — but it’s often misunderstood.<br>Beginners hear ‘master XSS’ and think that means memorizing payloads like &lt;script&gt;alert(1)&lt;/script&gt;, then testing every input field hoping for a pop-up. The advice should evolve to: ‘Pick one vulnerability class, but learn to recognize the <strong>context </strong>that enables it’.</p><p>What is that context? It’s the interplay of <strong>technologies</strong>, <strong>functionalities</strong>, <strong>gadgets</strong>, <strong>vectors</strong> &amp; <strong>quirks</strong>— elements we’ll map out in Part 3.<br>By understanding this, you bridge the <strong>knowledge-doing gap</strong>, turning fragmented learning into a cohesive methodology that lets you adapt to <strong>any target</strong>.</p><p>I was stuck in this loop myself, and from my research and conversations with others, it’s a common trap. Breaking free requires shifting from technique obsession to context awareness, which we’ll explore next.</p><h3>Part 2: Be A Context Hunter, Not A Vulnerability Hunter</h3><p>This revelation changed my approach to bug bunting: <strong>Every vulnerability depends on context</strong>.</p><p>Let’s break that down with simple examples.<br>An OAuth flaw isn’t lurking in every login system — it’s only exploitable where <strong>OAuth exists &amp; is misconfigured</strong>.<br>like when a redirect URI isn’t properly validated, allowing attackers to steal tokens during authentication flows.</p><p>A race condition? It emerges only in scenarios where <strong>asynchronous processing</strong> (like multiple users updating a shared resource simultaneously) <strong>collides with critical state changes</strong>, such as in a banking app where two withdrawals hit the same account balance at once.</p><p>Or take SSRF: It’s not universal; it thrives in apps that make <strong>outbound requests based on user input</strong>, like a URL fetcher that doesn’t whitelist domains.</p><p>Why is hunting context the optimal way? It directly addresses the Methodology Gap from Part 1 by replacing scattered, isolated knowledge with a structured map of an app’s “<em>personality</em>”.<br>Instead of forcing techniques onto targets (which leads to frustration and wasted time), you let the app reveal its weak points naturally. This reduces tunnel vision because you’re not hyper-focused on one vuln; you’re building a holistic view that highlights multiple potential paths.<br><em>Hunting for context lets the </em><strong><em>vulnerabilities find you</em></strong>.</p><p>For beginners, it turns discouragement into discovery — time spent learning isn’t “wasted” if a vuln isn’t present; instead, you’ve gained <strong>reusable insights</strong> into app behaviours which can be used to exploit a different &amp; more appropriate vulnerability for that context.</p><p>To make this clearer, let’s use an <strong>analogy</strong>:<br>Think of bug hunting like dating. The current “vulnerability hunting” mindset is like that pushy guy forcing their way into every conversation, ignoring signals — which gives off “<strong>desperate</strong>” or “creepy” vibes and gets you nowhere (or blocked).<br>You <strong>can’t </strong>and <strong>shouldn’t</strong> force a vulnerability onto an application, just like you shouldn’t force yourself onto someone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jhI_wydVKOkTnvwufxDEtA.png" /><figcaption>You</figcaption></figure><p>Instead, <strong><em>be the thoughtful wingman </em></strong>(or matchmaker on a dating app). The asset (<strong>your target app</strong>) is like a person you’re getting to know —what are their interests (<strong>functionalities</strong>), background (<strong>technologies</strong>), and personal quirks (<strong>behaviours</strong>)? Then, figure out their preferred channels for conversation (<strong>vectors</strong>) and the <strong>gadgets</strong> or apps they rely on in daily life.</p><p>By mapping these, you identify what their “type” is, then match them with compatible “partners” (<strong>vulnerabilities</strong>) that align naturally.</p><p>For example, if the app uses AWS S3 for file storage (technology) with a public upload feature (functionality), you don’t blast XSS everywhere; you probe for misconfigurations like open buckets that could lead to data exposure. This approach is respectful, efficient, and yields better results because <strong>it adapts to the app’s unique context</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*B1YgSrBPWnLnMMLp3gbcig.png" /><figcaption>Thoughtful Wingman</figcaption></figure><p><em>A good wingman listens, observes, and makes an introduction </em><strong><em>only when there’s a clear, mutual fit</em></strong><em>. That’s the essence of context hunting.</em></p><p>Experienced hunters do this instinctively: They map context first, letting attack paths appear organically. Beginners, stuck in the cycle of learning one technique and hunting it everywhere, get discouraged. Experts, by contrast, perform general recon, analyze for patterns, and select techniques based on evidence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uw33QWht_9r49ckXwbezUQ.png" /><figcaption>Beginner Vs Expert</figcaption></figure><p>The goal isn’t finding bugs — <strong>it’s finding the context that enables them</strong>. So, what is this “context,” and how do you find it?</p><h3>Part 3: Build Your Vulnerability Knowledge Graph</h3><p>I critiqued recon earlier, but that was more aimed at passive recon — easy to automate, so beginners overdo it. Active recon deserves more attention; it directly leads to bugs.</p><p>For me, active recon means mapping an app’s context — the key pieces for hacking. I call them “Asset Components.” Think of these as the ingredients in a recipe: Just as a cake needs flour, eggs, sugar, and baking powder to rise (and quirks like oven temperature to succeed), an app’s vulnerabilities emerge from the mix of these components:</p><h4>Technologies</h4><p>These are the foundational building blocks — <strong><em>what the app is built with or runs on</em></strong>. Examples: React for frontend, Node.js for backend, Cloudflare WAF for security, AWS for hosting, or even databases like MongoDB. In the context of an application, technologies define the “skeleton” — they influence how data is processed, stored, and secured. For hacking, they’re relevant because many vulns are tech-specific; e.g., a deserialization bug might exploit Java’s object handling, while a GraphQL app could have introspection enabled, revealing schema details.<br>Technologies are like the car’s engine and frame — they determine speed, handling, and potential breakdowns (vulns).</p><p><strong>Discovery:</strong> Use tools like Wappalyzer (CLI or browser extension). Automate it for scale across subdomains (You probably already do this).</p><h4>Functionalities</h4><p>These are the user-facing features — <strong><em>what the app lets you do</em></strong>. Examples: File uploads (uploading images or docs), login forms (authenticating users), password resets (emailing recovery links), payment gateways (processing credit cards), or search bars (querying data). In an app’s context, functionalities are the “<strong>actions</strong>” or doors users walk through, often where data enters and exits. For hacking, they’re goldmines because vulns hide in misuse; e.g., a file upload without validation could allow malware, or a search function might enable SQL injection.<br>Functionalities are like rooms in a house — each has a purpose (kitchen for cooking, bedroom for sleeping), but poor locks (weak security) invite burglars.</p><p><strong>Discovery: </strong>Tools can’t automate this well yet (though A.I might soon). Manually explore: Click buttons, fill forms <strong>&amp;</strong> <strong>observe </strong>behaviours.</p><h4>Gadgets</h4><p>These are exploit primitives — <strong><em>the chainable mechanisms or weak points you leverage for impact</em></strong>. Examples: DOM sinks like InnerHTML (where JS inserts HTML), framework injections like Angular’s $sce.trustAsHtml(), browser APIs like Service Workers (for offline caching but abusable for persistence), or even built-in vulns like reflected XSS. In an app’s context, gadgets are the “tools” or levers attackers pull to escalate. For hacking, they’re crucial for chaining attacks; e.g., a postMessage listener could receive malicious messages from a compromised iframe.<br>Gadgets are like Lego bricks in a build — individually simple, but snapped together, they form complex structures (attack chains).</p><p><strong>Discovery:</strong> Use browser dev tools to inspect code. Extensions like “Fancy Tracker” spot specifics, like event listeners. Websites like <a href="https://gmsgadget.com/">GMSGadget</a> provide an extensive list of JS gadgets for bypassing XSS mitigations.</p><h4>Vectors</h4><p>Vectors are the <strong><em>specialized conduits</em></strong> within an application — each defined by both the <strong>pathway data takes <em>and</em> the specific type of data it carries</strong>.<br>They are identifiable channels that serve a particular purpose: a Session Cookie (carrying authentication tokens), an SVG File Upload (carrying SVG markup), or an OAuth Authorization Code (carrying temporary grant codes) or even a URL parameter (carrying user input).<br>In an app’s context, vectors are the labeled, purpose-built pipelines for moving data. For hacking, they represent precise attack surfaces: a tainted SVG File Upload could lead to XSS, while a hijacked Session Cookie could mean account takeover.<br>Vectors are like specialized plumbing — a hot water pipe, a gas line, and a sewage pipe are all “pipes,” but each is designed to carry something different and fails in its own way. You don’t test them the same.</p><p><strong>Discovery: </strong>Observe with tools like Burp Suite or browser— inspect requests/responses for headers, params, etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w15GpO0dS3x7jx18Ghai2w.png" /><figcaption>4 Core Asset Components</figcaption></figure><h4>Quirks/Behaviours</h4><p>These are observable traits or behaviours of the components — facts from testing, for example “this param <strong>reflects input unsanitized</strong>.” Quirks can either <strong>enable</strong> or <strong>block </strong>vulnerabilities.<br>Think of them as the “flavour notes” in ingredients — too much salt ruins the dish (blocks exploit), but the right spice enhances it (enables vuln).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PiQha8DZaPr4lFpkjb080Q.png" /><figcaption>Quirks</figcaption></figure><p>We’ll cover discovering quirks in the next part.</p><p>The 4 core components (<strong>Tech</strong> x <strong>Func</strong> x <strong>Gadget</strong> x <strong>Vector</strong>) outline an app’s attack surface, while Quirks decide exploitability.</p><h3>Part 4: From Notes to Hands-On Testing</h3><p>Now you know what to map in a target. Time to hack it. This is where effort counts — prove you understand what you’ve learned.</p><p>Remember: “<strong><em>Every vulnerability is context-dependent</em></strong>” This stage proves it.</p><p>Learn from sources: Security research, write-ups, blogs, bug reports, YouTube, talks like NahamCon or DEFCON.</p><p>But <strong>extract context</strong>: Map vulns to components. Ask:</p><ul><li>What <strong>technology enables</strong> this?</li><li>What <strong>functionality hosts</strong> it?</li><li>What <strong>gadgets were chained</strong>?</li><li>What <strong>vectors carried payloads</strong>?</li><li>What quirks <strong>enabled</strong> or <strong>mitigated</strong> the attacks</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O_7EgPNdUq8qMfS8FbweRA.png" /><figcaption>Image is messy but you get the point</figcaption></figure><blockquote>A vulnerability rarely needs all the components — the mix can change every time. It could be enabled by a single “<strong>technology”</strong> (like a critical CVE in a framework such as <strong>React</strong>), or by a “<strong>tech + func”</strong> combo (e.g., exploiting a specific library like `<strong>mmmagic</strong>` to bypass a <strong>file upload </strong>feature).<br>The crucial takeaway is that while the mix of Tech, Func, Gadget, and Vector is virtually limitless, <strong>quirks are the universal component</strong>. Every exploitable scenario <strong>hinges on a specific, observable behavior</strong>.</blockquote><p>You’ll hardly ever get the full story from one source. A write-up might show you how to exploit an XSS flaw but not mention the WAF or CSP that could stop you. Your job is to connect the dots.</p><p><strong>Here’s the method:<br></strong>After you’ve extracted the 4 core components from a writeup etc; identify the <strong>core quirk</strong> that <strong>enables </strong>the vulnerability explained in it. Next, research the standard <strong>mitigations </strong>developers use to block that quirk (these mitigations are also quirks). Finally, learn the <strong>techniques</strong> to <strong>circumvent</strong> those specific defenses. This turns a fragmentary tip into a complete, actionable branch of your knowledge.</p><p>This process of analyzing a quirk — classifying it as an <strong>enabler </strong>or a <strong>blocker </strong>(mitigation) — is what naturally directs you to the right tool in the hunter’s toolkit: <strong>techniques</strong>. An enabling quirk calls for <strong>probing and exploitation techniques</strong>. A blocking quirk demands research into <strong>bypass techniques</strong>.</p><h4>Techniques: Your Toolkit for Testing</h4><p>Techniques are the “how-to” steps within vulnerability exploitation. Some are shared across classes (e.g., fuzzing inputs), others exclusive (e.g., blind SQL time delays). Vulnerabilities and techniques are interlinked — techniques <strong>reveal</strong>, <strong>bypass</strong>, or <strong>exploit</strong> the <strong>vulnerability’s context</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0Vh2S06HgfIPEzlAI9CygQ.png" /><figcaption>Types Of Techniques</figcaption></figure><h4>Probing Techniques</h4><p>These test for quirks, confirming if components suit a vulnerability. They’re key for discovering quirks from Part 3 — empirical tests like sending inputs and observing responses. Example: For XSS, probe by injecting <em>&lt;img src=x onerror=alert(1)&gt;</em>into a vector and check for execution or identify a security mechanism that mitigates it.<br><strong>Probing is like a doctor’s check-up</strong>— poking to see reactions &amp; diagnosing issues.</p><h4>Bypass Techniques</h4><p>These are used when a security mechanism blocks a probe/payload. Example: If a WAF filters XSS, bypass by encoding payloads (e.g., using Unicode) or splitting them. Bypass techniques can be shared across different vulns (e.g., WAF bypasses apply to SQLi too), but some are class-specific.<br><strong>Bypasses are like lockpicks</strong>— tools to evade guards (security mechanisms).<br>There’s tons of different types of bypass techniques, from payload encoding to payload splitting… learn as much as you can!</p><h4>Exploitation Techniques</h4><p>Final Payloads to trigger impact, often post-bypass. Example: After discovering an effective bypass technique, use it to build a full XSS payload for cookie theft.<br><strong>Exploitation is the heist</strong>— using probed intel and bypassed locks to grab the prize.</p><p>This is where pattern matching begins. You align the specific components and quirks you’ve observed with the relevant techniques in your toolkit/knowledge base.</p><h3>Part 5: Building Your Playbooks</h3><p>Now you see how everything connects. <strong>Asset Components</strong> define the landscape. <strong>Quirks</strong> reveal security posture. <strong>Techniques</strong> let you systematically explore both.</p><p>Here’s the full process:</p><p>You discover an asset uses <strong>OAuth</strong> (Technology) for <strong>login</strong> (Functionality), transports authorization codes via <strong>URL parameters</strong> (Vector), and has a <strong>postMessage listener</strong> on the callback page (Gadget).</p><p>Using <strong>probing techniques</strong>, you test: Is the state parameter validated? You send a request without it — <strong>quirk discovered: no validation.</strong> Does the postMessage listener check origin? You send a message from a malicious domain — <strong>quirk discovered: no origin check.</strong></p><p>These quirks match a known pattern: OAuth CSRF + token theft via postMessage = account takeover. You attempt the exploit but hit rate limiting. Using <strong>bypass techniques</strong>, you rotate IPs to circumvent it. Finally, you deploy <strong>exploitation techniques</strong>: a malicious OAuth link that, when clicked, steals the authorization code via the compromised postMessage listener.</p><p><strong>This is context hunting in practice.</strong> You didn’t randomly test OAuth attacks everywhere. You mapped context, discovered enabling quirks, matched patterns, and executed with precision.</p><p>Here are some good sources on each component type to start learning:</p><h4>Tech: NGINX</h4><p>Hacktricks provides some basic tests to identify <strong>Nginx </strong>vulnerabilities:</p><p><a href="https://angelica.gitbook.io/hacktricks/network-services-pentesting/pentesting-web/nginx">Nginx | hacktricks</a></p><h4>Func: User Registration</h4><p><a href="https://medium.com/u/b5e6f179c752">coffinxp</a> Gives an incredibly detailed list of techniques to try when you encounter a <strong>user registration</strong> functionality</p><p><a href="https://infosecwriteups.com/a-comprehensive-guide-to-hunting-bugs-in-user-registration-features-fe8b04dc39b8">A Comprehensive Guide to Hunting Bugs in User Registration Features</a></p><h4>Gadgets</h4><p>Here’s a good deep dive into what <strong>gadgets</strong> are, some examples &amp; how to use them (You should subscribe to this channel):</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FKwacl06tX1I%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DKwacl06tX1I&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FKwacl06tX1I%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/1c5bd61d57ca752004583530ac63ed61/href">https://medium.com/media/1c5bd61d57ca752004583530ac63ed61/href</a></iframe><h4>Vector: Json Web Tokens</h4><p>Intigriti has a playlist covering the PortSwigger labs on <strong>JWT vectors</strong>:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fvideoseries%3Flist%3DPLmqenIp2RQchVCoGLVD61w0zBHQdqSC_8&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fplaylist%3Flist%3DPLmqenIp2RQchVCoGLVD61w0zBHQdqSC_8%26si%3Dh1ufDSxV4CYEC9ij&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FGIq3naOLrTg%2Fhqdefault.jpg%3Fsqp%3D-oaymwEXCOADEI4CSFryq4qpAwkIARUAAIhCGAE%3D%26rs%3DAOn4CLA_3OrYGwMaSDL63bjV7UuG9K5pow%26days_since_epoch%3D20430&amp;type=text%2Fhtml&amp;schema=youtube" width="853" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/a9bc9a54ca86102a0afecaaad287e309/href">https://medium.com/media/a9bc9a54ca86102a0afecaaad287e309/href</a></iframe><h4>Quirk: 403 Responses</h4><p>NahamSec shares some techniques for bypassing 403 response <strong>quirks</strong></p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FPvpXRBor-Jw%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DPvpXRBor-Jw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FPvpXRBor-Jw%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/0212c5bb5c140d89ec7e2a22ede7d9b5/href">https://medium.com/media/0212c5bb5c140d89ec7e2a22ede7d9b5/href</a></iframe><p>You can start with these examples, extract their relevant context and build your knowledge graph.<br>The beauty? <strong>It’s reusable &amp; modular.</strong> Every asset you map builds your pattern library. Next time you see OAuth + URL tokens + postMessage, you’ll instantly recognize the opportunity. You’ve moved from memorizing payloads to learning architectural patterns that repeat across applications!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wE_oq2aqcKVXn24ALDJ-2Q.png" /><figcaption>Context Hunting Cycle</figcaption></figure><p><strong>This is how experts hunt at scale: they recognize context, not individual bugs.</strong></p><h3>Part 6: From Theory to Practice</h3><p>Let’s recap the journey: Move beyond passive recon by mapping your target’s <strong>context</strong> — its Technologies, Functionalities, Gadgets, Vectors, and Quirks. Learn vulnerabilities by extracting their enabling context and the techniques (probing, bypass, exploitation) used to exploit them. Then pattern match: align what you observe with what you know, like a matchmaker finding compatible pairs.</p><p>You now have a complete methodology. The question is: how do you execute it consistently?</p><p>The unfortunate truth? <strong>Understanding a methodology and consistently applying it are two different skills.</strong> You might read this, nod along, then fall back into old habits tomorrow — scattered notes, forgotten patterns, inconsistent testing.</p><p>I know because I lived it. The methodology was clear but my execution was chaos.</p><p>For that reason (and many others), I started building a structured system to help myself stay consistent with this approach. It’s called “<strong>Nimbus Vault</strong>”. It’s still early, but if you’re interested in following that journey, you can follow me on <a href="https://x.com/entit_yy/">X</a> &amp; in my next blog, I will dive into how I’m operationalizing context hunting into an actual workflow.<br>But to give a hint at the core idea:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gmRn_GgknxdEHOnwbs83cw.png" /><figcaption>The Nimbus Cycle</figcaption></figure><p>For now, though, the methodology is what matters. Whether you use Notion, a spreadsheet, or pen and paper — apply it however works for you.</p><p><strong>Map the context. Discover the quirks. Match the patterns.</strong></p><p>Do this consistently, and you’ll find vulnerabilities others miss.</p><h3>Conclusion: The Movement Continues</h3><p><strong>Be a context hunter.</strong> Map components. Discover quirks. Match patterns. Share what you learn.</p><p>If this approach works for you, <strong>spread it</strong>. Write about it. Talk about it.<br>Help others escape the methodology gap.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eOFC0XbOCXpAZ5sX71ueGQ.avif" /><figcaption>It’s Your Turn</figcaption></figure><p><strong><em>Now go hunt some context.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=41b266516a5a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My First Bug Bounty Success: Earning $500 by Uncovering a DoS Vulnerability]]></title>
            <link>https://medium.com/@entit_y/my-first-bug-bounty-success-earning-500-by-uncovering-a-dos-vulnerability-f0456eb72576?source=rss-7e61242b7a49------2</link>
            <guid isPermaLink="false">https://medium.com/p/f0456eb72576</guid>
            <category><![CDATA[bug-bounty-writeup]]></category>
            <category><![CDATA[web-hacking]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[bug-bounty-tips]]></category>
            <dc:creator><![CDATA[Entit_y]]></dc:creator>
            <pubDate>Mon, 31 Mar 2025 17:37:42 GMT</pubDate>
            <atom:updated>2025-03-31T17:57:32.859Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K6zNCEdf6uMyBcUwGNEl3g.jpeg" /><figcaption>Cool hacker image</figcaption></figure><p>When I first started bug bounty hunting, I had no idea how long it would take to find my first real vulnerability. After three years of learning, trying, and failing, I finally landed my first pay-out — $500 for a Denial of Service (DoS) vulnerability!</p><p>In this writeup, I’ll walk you through how I discovered this bug, from basic recon to uncovering a flaw that could allow an attacker to block real customers from using a company’s product. If you’re new to bug bounty hunting, don’t worry — I’ll explain everything in simple terms so you can learn from my experience.</p><p>I began with some recon and subdomain enumeration. During my search, I discovered a subdomain that allowed users to sign up for a free trial. I went through the process — entering my email, password, and payment details — which eventually led me to an endpoint that required a special ID I will be calling the “<strong>required ID</strong>”.</p><p>I did some OSINT on the target to figure out what this ID was. I learned that the <strong>required ID</strong> is found only on the physical product that the company sells. Since I didn’t own the product, I assumed I’d hit a dead end. However, when I started typing random characters into the <strong>required ID</strong> input field, the webpage immediately displayed an error message: “Invalid Required ID.” What caught my attention was that this error appeared as soon as I typed — it didn’t require me to press the register button or reload the page.</p><p>This behaviour suggested that the validation was happening on the client side (in the browser) via JavaScript rather than on the server. With my basic web knowledge, I suspected that the site was using a JavaScript function to check if the ID was valid. I copied the error message (“Invalid Required ID”), opened the browser’s developer tools (pressing F12), navigated to the Sources tab, and searched for any JavaScript file that contained this error message. I figured that file would also handle the validation.</p><p>I found the file that contained the error message and discovered that it wasn’t making any request to an external service or database to check the validity of the ID. Instead, it was simply using a regular expression (regex) to validate the <strong>required ID</strong>. If the entered ID didn’t match the regex pattern, the register button would be disabled, and the “Invalid Required ID” error message would appear. The function that validated the ID with the regex behaved something like this :</p><pre>// Client-side validation for the required ID<br>const requiredIdRegex = /^R[XYZ]\d{7}$/i;<br>if (!requiredIdRegex.test(inputId)) {<br>  alert(&quot;Invalid required ID&quot;);<br>}</pre><p>I copied the function containing the regex and used ChatGPT to help create a JavaScript snippet that could generate a “valid” <strong>required ID </strong>based on the regex pattern<strong>:</strong></p><pre>// Generate a valid required ID (format: R[XYZ] + 7 digits)<br>function generateRequiredId() {<br>  const prefix = &#39;R&#39; + [&#39;X&#39;, &#39;Y&#39;, &#39;Z&#39;][Math.floor(Math.random() * 3)];<br>  const digits = String(Math.floor(Math.random() * 10000000)).padStart(7, &#39;0&#39;);<br>  return prefix + digits;<br>}<br><br>console.log(&#39;Required ID:&#39;, generateRequiredId());</pre><p>I ran the script in my browser console, copied and pasted the generated required ID into the input field and — voilà! — the error didn’t appear, and the register button was enabled. I clicked it, and the registration went through. This confirmed that the server was not performing any validation for the IDs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*R5qe76JQTfDoUuVM-VT3Xg.png" /><figcaption>Generated ID</figcaption></figure><p>After registration, I was directed to a page with a link to download their mobile app. I downloaded the app and logged in with my new account; everything worked as expected.</p><p>At this point, as a beginner, I wasn’t sure if this was a vulnerability worth reporting. I wondered, “So what if I can generate ‘fake’ IDs and have them stored in the database? How is that impactful?” Unsure of the next step, I turned to a <a href="https://discord.gg/4x8TP4cf">Discord</a> server filled with bug hunters of all levels. I described my situation, and the server owner himself provided invaluable advice.</p><p>He suggested checking whether it was possible to cause a Denial of Service (DoS) by registering all the possible combinations of a valid <strong>required ID</strong>. Since the IDs were validated using a regex, there was a finite number of combinations. I went back to the site, attempted to register a new account, but this time I used the <strong>required ID</strong> I already generated earlier, and received a message stating, “ID already registered with an account.” This indicated that each <strong>required ID</strong> could only be used once, confirming the potential for a DoS vulnerability.</p><h3><strong>Attack Scenario &amp; Impact:</strong></h3><p>If an attacker were to write a script that continuously generates valid <strong>required IDs</strong> and registers them, they could eventually exhaust all possible combinations allowed by the regex (roughly 30 million). I further validated the vulnerability by doing more OSINT on the purpose of the <strong>required ID</strong>. I learned that the ID is found on the product’s packaging and is used to “pair” the physical product with the mobile app. Each product has a unique <strong>required ID</strong>, meaning that if an attacker registers all available IDs, new customers would be unable to pair their freshly purchased products with the app — a true DoS attack.</p><p>I quickly reported this as a high-severity finding. Although it was later reduced to medium severity, I was paid $500 for my discovery — my first bounty and vulnerability found since I started bug bounty hunting three years ago (phew!).</p><h3>Takeaways:</h3><p>- <strong>Explore the Client Side</strong>: <br>While tools like Burp Suite are great for intercepting requests, don’t forget to open your browser’s developer tools to understand how a website works without much server communication. Always use this insight wisely and ethically.</p><p>- <strong>Ask for Help</strong>: <br>I wasn’t sure how impactful my finding was until I reached out to the bug hunting community on Discord. Their support helped me see the full potential of the vulnerability. If you’re ever uncertain, ask your peers — they’re usually very welcoming.<br>Here’s an invite link to the discord server I found help at: <a href="https://discord.gg/4x8TP4cf">https://discord.gg/4x8TP4cf</a></p><p>Thank you for reading my first-ever web security writeup. Have a great day (or night)!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0456eb72576" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>