Talksy
Topic 01 — Environment Setup & Fundamentals
Read aloud in class. Orange words are auxiliary verbs — notice each one as you speak.

Today, I am going to start with the very first topic of this course — Environment Setup and Fundamentals. This is the most important topic because everything else we will learn in this course is built on top of what we are going to cover today. If you don't get this right, you will struggle with every single topic that comes after. So please pay very close attention to every detail I am about to share with you. I have taught this course many times, and I can tell you that the students who struggle later are always the ones who didn't set up their environment properly at the beginning. Don't be that student. Let us build a strong foundation together.

The first tool we are going to talk about is Burp Suite. If you don't already know what Burp Suite is, that is completely fine — many students have started this course without knowing anything about it. Burp Suite is a professional web security testing tool made by a company called PortSwigger. It is used by security researchers, penetration testers, and bug bounty hunters all around the world. Every single person who is serious about web application security has Burp Suite installed on their machine. It is the industry standard — if you are working in this field and you don't have Burp Suite, you are working with one hand tied behind your back. You cannot do this work properly without it. If you haven't installed it yet, you should stop right now, go to the PortSwigger website, and download the Community edition. It is completely free. The Community edition does have some limitations compared to the Professional version, but for everything we are going to cover in this course, the Community edition is more than enough. The Pro version does cost money — around four hundred dollars per year — so we won't require it here. You can always upgrade later when you are earning bounties and the investment will make sense for you.

Now, once you have downloaded and installed Burp Suite, the very first thing you must do is configure your browser to use it as a proxy. This is how Burp Suite works — it is a proxy tool, which means it sits between your browser and the web server, capturing all the traffic that goes back and forth. Without this configuration, Burp Suite cannot see any of your requests, and you won't be able to do anything useful with it. So let me explain exactly how the proxy setup works, step by step, because this is something you must understand at a deep level, not just follow mechanically.

When you are setting up the proxy, you will need to tell your browser to send all its traffic through the address 127.0.0.1 on port 8080. The address 127.0.0.1 is your own computer — it is what we call the loopback address or localhost. Port 8080 is the default port that Burp Suite is listening on. By telling your browser to use 127.0.0.1:8080 as the proxy, you are essentially saying to the browser: "Instead of sending your requests directly to the internet, send them to Burp Suite first." Burp Suite then will forward the request to the actual web server, receive the response, and show it all to you so you can analyze it, modify it, and understand it. This is the fundamental mechanism that makes everything possible in web application security testing. Without understanding this, you would not understand why any of the other techniques we will learn actually work.

I would recommend using Firefox for your testing because Firefox has its own built-in proxy settings that are very easy to configure independently from the rest of your system. Chrome and other browsers usually use the system proxy settings, which can sometimes cause issues with other applications on your computer. Firefox doesn't have this problem. In Firefox, you can go to Settings, then scroll down to Network Settings, click on the Settings button, and choose "Manual proxy configuration." There you will enter 127.0.0.1 in the HTTP Proxy field and 8080 in the port field. You should also check the box that says "Also use this proxy for HTTPS." After you have done this, all your Firefox traffic will go through Burp Suite. You might also want to use the FoxyProxy extension, which is a popular browser extension that allows you to quickly switch between using the proxy and not using it. Many professional bug bounty hunters use FoxyProxy because it is faster than going into the settings manually every time.

But wait — there is one more step you must not skip, and I have seen many beginners miss this and then wonder why things aren't working. When you try to visit an HTTPS website through Burp Suite for the first time, your browser will show you a scary warning saying that the connection is not secure or that the certificate is not trusted. This is because Burp Suite is intercepting your HTTPS traffic by acting as a "man in the middle." To fix this, you have to install Burp Suite's CA certificate into your browser. The CA certificate tells your browser: "This certificate is trusted. Don't show me scary warnings anymore." To get the certificate, while your proxy is configured and Burp Suite is running, you should visit the special address http://burpsuite in your browser. Burp Suite will respond with a page where you can download the certificate. After you have downloaded it, you will need to import it into Firefox's certificate store. Go to Firefox Settings, search for certificates, click "View Certificates," go to the "Authorities" tab, and click "Import." Select the certificate file you just downloaded, check the box that says "Trust this CA to identify websites," and click OK. Once you have done this, Burp Suite will be able to intercept all your HTTPS traffic without any browser warnings. This is absolutely essential — if you don't install this certificate, you won't be able to test HTTPS websites properly, and almost every real-world application runs on HTTPS these days. You couldn't do serious bug bounty work without this step.

Now that our browser is configured and our CA certificate is installed, let us look at the main features of Burp Suite that we will be using throughout this entire course. The first and most important feature is the Proxy tab, specifically the Intercept feature. When you have Intercept turned on, every single request your browser makes will be stopped and shown to you in Burp Suite before it is sent to the server. This means you can see exactly what your browser is sending, and you can modify it before it goes. You can change parameters, add headers, modify values — absolutely anything you want. Then when you are ready, you click "Forward" and the modified request will be sent to the server. This is incredibly powerful because it means you can test how the application responds to unexpected or manipulated input.

When Intercept is turned off, Burp Suite will still capture all your traffic — it just won't stop it. All requests and responses will flow through Burp Suite and they will be recorded in the HTTP History tab. The HTTP History is one of the most useful features you will use as a bug bounty hunter. It is a complete log of every single request your browser has made during your testing session. You can scroll through it, search it, filter it by domain, and click on any request to see its full details. I have found many bugs just by browsing a website normally with Intercept off and then going back through the HTTP History to look for interesting endpoints and parameters. You should always browse the entire target application first with Intercept off, so the application feels natural and responds as it normally would for a real user. Don't start sending malicious payloads immediately — first understand the application.

The next feature I want to talk about is Scope. The Scope feature in Burp Suite is extremely important, especially when you are working on a real bug bounty program. Every bug bounty program has a defined scope — a list of domains, subdomains, and IP addresses that you are allowed to test. If you go outside the scope and test domains that aren't in the program, you could get banned from the platform, your account could get suspended, or in serious cases, you could face legal consequences. This is not something to take lightly. In Burp Suite, you can define your scope by going to the Target tab and then the Scope sub-tab. You should add all the in-scope domains there before you start any testing session. I always set the scope before I start any testing session. It must become your habit too.

Another incredibly useful feature is Match and Replace. Match and Replace allows you to automatically modify every request or response that passes through Burp Suite according to rules you define. For example, if you have found a session token in a cookie and you want to test what happens when you replace your session with another user's session, you can set up a Match and Replace rule that will automatically replace your cookie value in every single request. Without Match and Replace, you would have to manually edit every single request, which would be extremely tedious. With Match and Replace, testing that would take an hour can be done in minutes.

Now let us talk about Repeater. Repeater is one of the tools I have used most frequently throughout my career. When you have captured a request in Burp Suite, you can right-click on it and select "Send to Repeater." Repeater allows you to send the same request multiple times with different modifications. You can change a parameter value, click "Send," and see the response immediately. This is how we test for SQL injection, IDOR, and many other vulnerabilities. I have probably used Repeater in 90% of all the bugs I have ever found. You should get very comfortable using Repeater as quickly as possible — treat it like your best friend in this work.

Related to Repeater is Intruder. While Repeater is for manual testing one request at a time, Intruder is for automated testing with many payloads. With Intruder, you can take a request, mark certain positions in it, and tell Burp Suite to send that request hundreds of times, each time replacing the marked position with a different value from a wordlist. However, I must warn you — the Community edition of Burp Suite throttles Intruder to run very slowly. This is one of the main limitations of the free version. If you need fast automated scanning, you will either need the Pro version or use a command-line tool like ffuf. Don't be surprised when Intruder in the Community edition seems very slow — that is by design.

Now, we must talk about HTTP methods — specifically GET and POST. These are the two most common HTTP request methods, and you will see them in every single request you capture. A GET request is used to retrieve data from the server. When you type a URL in your browser and press enter, your browser is making a GET request. The key characteristic of a GET request is that the parameters are included in the URL itself, after a question mark. GET parameters are always visible in the URL, stored in browser history, and in server logs. Because of this, sensitive data like passwords and tokens should never be sent as GET parameters. A POST request is different — POST requests are used to send data in the request body, not the URL. When you fill in a login form and click Submit, your browser is making a POST request. The key point is that POST parameters are NOT truly hidden. When you are using Burp Suite as a proxy, you can see and modify them just as easily as GET parameters. Security doesn't come from hiding parameters — it must come from proper server-side validation.

Now, every request you make will receive a response with an HTTP status code. You must learn these codes because they will guide your testing strategy. Status 200 means "OK" — the request was successful. Status 301/302 means a redirect — the resource has moved. Status 400 means "Bad Request" — the server couldn't understand your request. Status 401 means "Unauthorized" — you aren't authenticated and must log in first. Status 403 means "Forbidden" — you are authenticated but don't have permission. Status 404 means "Not Found" — the resource doesn't exist. Status 500 means "Internal Server Error" — something went wrong on the server, which might mean you have triggered a vulnerability. Status codes 401 and 403 are very interesting because they tell you a resource exists but is protected — sometimes these protections can be bypassed.

The last thing we need to cover is your testing environment — WSL and VPS. WSL stands for Windows Subsystem for Linux. If you are using Windows, you will need WSL to run Linux tools because the best security tools were written for Linux and they don't work natively on Windows. WSL allows you to run a full Linux environment inside Windows. I would recommend installing Ubuntu inside WSL, as it is the most widely used Linux distribution in the security community. Once you have WSL set up, you will have access to tools like curl, wget, nmap, and ffuf that you will need in this course.

A VPS — Virtual Private Server — is a server you rent from a cloud provider. You might wonder why you would need your own server. The answer is that for vulnerabilities like SSRF, the target server is making requests to external systems. To prove the server is really making those requests, you need a server accessible from the internet that you control, that can receive and log incoming connections. Without a VPS, you couldn't prove this kind of vulnerability. You can get a basic VPS for as little as five dollars per month. When you are testing for SSRF, blind XXE, or other server-side vulnerabilities, you will set up a listener on your VPS and try to make the target server send a request to it. If you receive a request from the target on your VPS, it means you have confirmed the vulnerability. This is a technique every serious bug bounty hunter must know.

Let me summarize everything we have covered today. We have learned about Burp Suite and why it is the most important tool in our toolbox. We have learned how to configure it as a proxy at 127.0.0.1:8080, and how to install the CA certificate so we can intercept HTTPS traffic. We have explored Intercept, HTTP History, Scope, Match and Replace, Repeater, and Intruder. We have learned the difference between GET and POST requests and why that difference is important for security. We have gone through the most important HTTP status codes. And we have discussed why WSL and a VPS are important parts of your testing environment. This is your foundation. Make sure you have Burp Suite installed, your proxy is configured, your CA certificate is installed, and your WSL environment is set up. These are the minimum requirements you must have before we can move on. I will see you in the next topic!

Topic 02 — How to Find Self-Hosted Programs
Read aloud in class. Orange words are auxiliary verbs — notice each one as you speak.

Today, we are going to cover one of the most underrated skills in the entire bug bounty world — how to find self-hosted programs. Most beginners don't even know what a self-hosted program is, and because of that, they are missing out on thousands of programs that have less competition and sometimes better payouts than the ones listed on the big platforms. I have personally found many amazing self-hosted programs that almost nobody else was testing, simply because they weren't listed anywhere obvious. So let me explain everything about this topic from the very beginning, and by the end of this lesson, you will know exactly how to find programs that most hunters don't even know exist. This knowledge is going to separate you from the average bug bounty hunter, so please pay very close attention to everything I am about to share with you.

Before we can talk about self-hosted programs, we must first understand what bug bounty platforms are and how they work. The major platforms in the industry today are HackerOne, Bugcrowd, Intigriti, Yeswehack, HackenProof, and ComOlho. These platforms are essentially marketplaces that connect companies with security researchers. A company that wants to run a bug bounty program can come to one of these platforms, create a program, define their scope and rules, and then thousands of hunters from all over the world will start testing their application. The platform handles the communication between the hunter and the company, the payment process, the dispute resolution, and the reporting interface. For many companies, using a platform like HackerOne or Bugcrowd is the easiest and most convenient option because they don't have to build any of that infrastructure themselves. If you are new to bug bounty, you should know all of these platforms by name, because you will spend a lot of time working with them throughout your career.

Now, here is where it gets interesting. Not every company that has a bug bounty program uses one of these platforms. Many companies — especially larger enterprises, financial institutions, and technology companies — have decided to run their programs directly on their own websites. These are called self-hosted programs, and they are exactly what they sound like — the company is hosting the program themselves without relying on a third-party platform. When a company self-hosts its bug bounty program, it has full control over everything — the design of the page, the rules, the response process, and the payment method. Some companies would rather use PayPal or bank transfers directly instead of going through a platform's payment system, which can sometimes take a cut of the bounty. So self-hosting gives them more flexibility. You must understand this distinction because the way you find self-hosted programs is completely different from the way you find platform-based programs. You can't just go to HackerOne and browse the list — you have to actively search for them yourself using techniques like Google dorking.

Now I want to explain something that many beginners get confused about — the difference between a VDP and a BBP. These are two completely different types of programs and you should know the difference before you start hunting. A VDP — which stands for Vulnerability Disclosure Program — is a program where the company invites you to report security vulnerabilities, but they are NOT promising to pay you money for it. VDPs are about responsible disclosure only. The company wants to know about bugs so they can fix them, but there is no bounty involved. Many companies that have never offered bug bounties before will start with a VDP. A BBP — which stands for Bug Bounty Program — is a program where the company has committed to paying you money if you find a valid vulnerability within their defined scope. The reward can range from a few hundred dollars to tens of thousands of dollars depending on the severity and the company. When you are hunting, you should always check whether the program is a VDP or a BBP before you spend hours testing it. If it is a VDP and you are hunting for money, you would be wasting your time. That said, VDPs are excellent for beginners because you can practice without worrying about the pressure of competition. Some hunters have started their careers almost entirely on VDP programs just to build experience.

Now let us talk about the most powerful technique for finding self-hosted programs — Google dorking. If you haven't used Google dorks before, the concept is very simple. Google has special search operators that let you filter and find exactly what you are looking for. By combining these operators in clever ways, you can find bug bounty and responsible disclosure pages that are hidden from the main platform listings. The first category of dorks we will look at is the intitle dorks. The intitle: operator tells Google to only show you pages where the title of the page contains your search term. So if you search for intitle:"Bug Bounty Program" you will get a list of webpages whose titles literally say "Bug Bounty Program." This is incredibly powerful because almost every company that runs a self-hosted program has a dedicated page for it, and that page almost always has those keywords in the title. Some of the most useful intitle dorks you should try are: intitle:"Bug Bounty Program", intitle:"Responsible Disclosure Policy", intitle:"Security Reward Program", intitle:"Vulnerability Disclosure Policy", and intitle:"Report a Security Bug". Each one of these will give you a completely different set of results, and many of the programs in those results will be programs that nobody else has found yet. I have discovered programs offering two thousand, five thousand, even ten thousand dollar rewards just by running simple intitle dorks. It is that powerful if you use it correctly.

The second category of important dorks is the inurl dorks. The inurl: operator tells Google to only show you pages where the URL itself contains your search term. This is useful because many companies follow a naming convention when they create their security pages. For example, a company might put their bug bounty page at /security, or /responsible-disclosure, or /bug-bounty. So when you search for inurl:/responsible-disclosure/, Google will find every page on the internet whose URL contains that path. Some very effective inurl dorks you should add to your arsenal are: inurl:/bug-bounty, inurl:/security, inurl:security.txt, inurl:/responsible-disclosure/, and inurl:security "reward". That last one is particularly clever — it combines inurl with the word "reward" in the page content, which means you will only see security pages where the word "reward" or "bounty" actually appears. That filter is very effective at separating VDPs from BBPs. You can also try variations like inurl:/responsible-disclosure/ reward, inurl:/responsible-disclosure/ bounty, or inurl:/responsible-disclosure/ swag — yes, some programs don't pay money but they will send you a t-shirt or hoodie as a reward, and those can still be great programs for building your reputation, especially when you are starting out.

There is another extremely important dork that every bug bounty hunter must know about — the security.txt file. The security.txt standard is a proposed internet standard that says companies should place a file called security.txt at the path /.well-known/security.txt on their domain. This file contains information about how to report security vulnerabilities — things like the contact email, the disclosure policy page, and sometimes the bug bounty program link. Many companies that have a responsible disclosure policy or a bug bounty program will place a security.txt file on their domain. So when you search inurl:security.txt on Google, you will get a list of thousands of companies that have made their security contact information publicly discoverable. I would estimate that at least sixty percent of companies with security.txt files have some form of bug bounty or responsible disclosure program linked inside. This is one of the most efficient ways I have found to discover programs quickly. When you are trying to find new programs, always check for a security.txt file on any domain you are interested in. You can do this manually by visiting example.com/.well-known/security.txt, or you can use the inurl dork to find hundreds at once.

Now let me talk about something that is very important and that most beginners completely ignore — the exclude keywords. When you are using dorks to find self-hosted programs, you don't want your results to include programs that are already listed on the major platforms, because those are platform-based programs, not self-hosted ones. The way you exclude these results is by adding negative keywords to your dork. The keyword string you should add to every dork you run is: -hackerone -bugcrowd -intigriti -yeswehack -hackenproof -openbugbounty. By adding these at the end of your search query, you are telling Google: "Show me bug bounty pages that do NOT mention any of these platforms." This will filter out all the results that are just linking to or powered by the major platforms, and you will be left with only the truly self-hosted programs. This single trick will save you enormous amounts of time. I couldn't imagine doing dork-based hunting without it. So whenever you run any dork for finding programs, always append those exclude keywords at the end. Make it a habit — every single time, without exception.

Let me also teach you some more advanced dorks that can help you find programs in specific regions or specific types of companies. For example, if you want to find bug bounty programs in Europe, you can use responsible disclosure europe or responsible disclosure r=h:eu or site:.eu responsible disclosure. These will give you programs from European companies that might operate under different rules — for example, in the Netherlands, many companies have had a government-encouraged responsible disclosure culture for many years, so there are many self-hosted Dutch programs. You can target them specifically with site:.nl responsible disclosure or site:*.*.nl intext:security report reward. Similarly, if you are interested in government programs — which are becoming more common as governments around the world recognize the importance of security research — you can try site:*.gov.* "responsible disclosure". Many universities also have responsible disclosure programs, which you can find with responsible disclosure university. These academic programs are often less competitive because most hunters don't target them. Each of these regional and sector-specific dorks will open doors to programs that most hunters haven't even thought to look for.

There are also some very clever dorks that target specific platform integrations. For example, the dork powered by bugcrowd -site:bugcrowd.com will find pages that mention "powered by Bugcrowd" but are NOT on the bugcrowd.com domain. This might seem strange — why would a page mention Bugcrowd if it isn't on the Bugcrowd website? The answer is that many companies embed the Bugcrowd widget directly onto their own website. So the program is technically powered by Bugcrowd in the backend, but the company has put it on their own domain. This means it won't appear in a normal Bugcrowd listing, but this dork will find it. The same logic applies to intext:"Powered by Bugcrowd" -site:bugcrowd.com and powered by synack for finding Synack programs. Another great dork is intext:"we take security very seriously" — many companies use this exact phrase on their security pages, and many of them have programs that aren't listed anywhere. The combination of all these dorks means you have essentially an endless supply of new programs to discover. You would never run out of targets if you are using dorks consistently and creatively.

Now I want to tell you about two tools that will make your program discovery much more efficient. The first is programs.krazeplanet.com, which is a program aggregator that has collected hundreds of self-hosted and platform programs in one place. Instead of running dozens of dorks one by one, you can check this tool to find programs that have already been discovered and verified. The second tool is BountyWatch, available at the GitHub link github.com/rix4uni/BountyWatch. BountyWatch is a tool that has been designed to monitor bug bounty programs for changes — things like scope additions, bounty increases, and new programs being added. This is incredibly valuable because the best time to test a program is right when it launches or right when it expands its scope. When a company has just added a new subdomain to their scope, most hunters haven't tested it yet, which means the attack surface is fresh and there are likely many bugs waiting to be found. If you are using BountyWatch to monitor program changes, you will always be ahead of other hunters. You should add monitoring for all the programs you are interested in and check the alerts regularly. This is how professional hunters stay consistently productive.

Let me also talk about the concept of scope when you are working with self-hosted programs, because this is something that is very different from platform programs. On HackerOne or Bugcrowd, the scope is clearly defined with in-scope and out-of-scope tables that are very structured. But many self-hosted programs have their scope described in plain English on their disclosure page, and it can sometimes be vague or incomplete. I have seen programs that simply say "any asset owned by our company is in scope" — which sounds great, but it also means you must do more research to understand what assets the company actually owns. This is where tools like Crunchbase become useful — you can look up the company and find all their subsidiaries and acquired companies. You should always read the disclosure policy very carefully before you start testing. Understand what is in scope, what is out of scope, what the responsible disclosure timeline is — meaning how long you must wait before you can publish your findings publicly — and what the payment terms are. Some self-hosted programs pay very quickly, while others might take months. Knowing this in advance will help you decide whether a program is worth your time right now.

Now I want to give you a complete strategy for how you should approach finding and evaluating self-hosted programs. First, you should run a set of your best dorks — maybe ten or fifteen different ones — and collect all the results into a list. Don't evaluate them while you are collecting. Just collect as many program URLs as you can in one session. Second, you should go through each one and quickly assess it — is it a BBP or a VDP? What is the scope? Does it mention any reward amounts? Has it been active recently? Third, you should prioritize programs that have broad scope, have offered recent payouts, and aren't well known. These are your golden targets. Programs that have never appeared on any public list and have broad scope could be sitting on hundreds of unreported vulnerabilities. Fourth, check if the company has recently been acquired by a larger company — acquisitions often mean that old, poorly-maintained systems have been brought under a new company's scope. These legacy systems haven't been audited in years and are often full of vulnerabilities. This acquisition angle is one of my favorite strategies and I have found critical bugs this way multiple times.

One more thing I must emphasize before we wrap up this topic. When you find a self-hosted program, please take the time to read every single word of their policy. I know that might sound tedious, but I have seen hunters get banned from programs — and in extreme cases face legal threats — because they didn't read the policy carefully. Some programs explicitly state that you must not test on production databases, or that you should not access any user data even accidentally, or that you must report within 24 hours of finding a vulnerability. If you aren't aware of these rules, you could violate them without realizing it. The policy also often tells you how to contact the security team, what format they want the report in, and whether they have a specific tool they use for receiving reports. Some companies might want you to email the report, some might have a custom form, and some might redirect you to their HackerOne or Bugcrowd page even if the main policy page is self-hosted. You wouldn't want to send a report to the wrong place and have it get lost. Take the policy seriously. The hunters who have built great reputations in this field are always the ones who were professional, thorough, and respectful of the rules.

To summarize everything we have covered today, bug bounty programs come in two main types — platform-based programs on sites like HackerOne, Bugcrowd, Intigriti, Yeswehack, HackenProof, and ComOlho, and self-hosted programs that companies run directly on their own websites. Within those, you will encounter VDPs, which don't pay money but are great for practice, and BBPs, which do offer monetary rewards. To find self-hosted programs, we use Google dorks — specifically intitle dorks, inurl dorks, and intext dorks — combined with exclude keywords to filter out already-known platform programs. We have learned about the security.txt standard as a quick discovery method. We have also discussed tools like programs.krazeplanet.com and BountyWatch that can save you a lot of discovery time. And we have discussed how to evaluate programs, understand scope, and read policies carefully. I want you to go and run at least five different dorks after this class and find three self-hosted programs you have never seen before. If you do that exercise today, you will understand this topic at a deep level. The hunters who consistently find bugs on self-hosted programs are the ones who have mastered this research skill. I will see you in Topic 03!

Topic 03 — Subdomain Enumeration
Read aloud in class. Orange words are auxiliary verbs — notice each one as you speak.

Welcome to Topic 03 — Subdomain Enumeration. This topic is one of the most critical skills you will ever learn as a bug bounty hunter. I am not exaggerating when I say that your entire attack surface depends on how well you can enumerate subdomains. Let me explain why. When a company has a large website like dell.com or paypal.com, that main domain is not the only place where their infrastructure lives. They have dozens, sometimes hundreds, sometimes even thousands of subdomains — things like api.dell.com, admin.dell.com, staging.dell.com, dev.dell.com, vpn.dell.com, and so on. Each one of these subdomains is a separate application running its own code, often maintained by a different team. These subdomains might be much less secure than the main website because the team that runs the main site has more resources and security reviews, while the team running a small internal tool on a subdomain might not. I have found critical vulnerabilities — things like SQL injection and remote code execution — on subdomains that were completely forgotten by the company and hadn't been updated in years. Subdomain enumeration is how you find those forgotten corners of a company's infrastructure where the bugs are hiding. If you don't enumerate properly, you will miss the majority of the attack surface and end up competing with everyone else on the same obvious endpoints.

Before we can start enumerating subdomains, we must talk about scope. Scope is everything in bug bounty hunting — it defines what you are and aren't allowed to test. There are three types of scope that you will encounter in this course. The first is large scope, also called wildcard scope or "any asset" scope. An example of a large scope would be a program that says something like "Any KrazePlanet asset is in scope." This means the company is allowing you to test absolutely anything they own — every domain, every subdomain, every IP address, every mobile app. This is the most exciting type of scope because the attack surface is enormous. When you are working with a large-scope program, you will need to do significantly more research to understand what the company actually owns. The second type is medium scope, which typically looks like *.krazeplanet.com. The asterisk means "any subdomain of krazeplanet.com." So api.krazeplanet.com, dev.krazeplanet.com, and admin.krazeplanet.com would all be in scope, but a completely separate domain like krazeplanet.io would not be. This is the most common type of scope you will encounter. The third type is small scope, which specifies a single domain like admin.krazeplanet.com. With small scope, you can only test that one specific domain and nothing else. Don't make the mistake of testing things outside the defined scope — it could get you banned from the program and in serious cases it could even lead to legal consequences.

Now, when you are working with a large-scope program, the first thing you should do is research the company on Crunchbase. Crunchbase is a business database that has information about companies — their funding, their leadership, and most importantly for us, their acquisitions and subsidiaries. When a large company has acquired smaller companies, those smaller companies often have their own domains and subdomains that now fall under the parent company's bug bounty scope. For example, if the program says "any FIS asset is in scope" and FIS has acquired twenty different companies over the years, then all of those acquired companies' domains might be in scope too. I have found that acquired companies are some of the best targets because their security practices were often not as mature as the parent company, and the acquisition might mean their infrastructure hasn't been reviewed since the acquisition took place. The KrazePlanet Crunchbase dork tool at dorks.krazeplanet.com/crunchbase.html can help you quickly research which companies are connected to your target. After you have your list of domains, you can also use tldscan — available at github.com/rix4uni/tldscan — to enumerate all the top-level domain variations. For example, if the company owns krazeplanet.com, they might also own krazeplanet.net, krazeplanet.org, krazeplanet.co, krazeplanet.in, and so on. Some of those alternative TLDs might be in scope, and they could have completely different vulnerabilities than the main .com domain.

Now let us talk about how to actually enumerate subdomains. There are two completely different approaches — passive enumeration and active enumeration — and a professional bug bounty hunter must use both. Let me explain what each one is and why it matters. Passive enumeration means collecting subdomains from sources that have already discovered and indexed them, without sending any traffic directly to the target company's servers. When you are doing passive enumeration, you are essentially asking third-party databases "what subdomains have you seen for this domain?" These databases include DNS certificate transparency logs, threat intelligence feeds, search engine indices, and historical DNS records. The key advantage of passive enumeration is that it is completely silent — the target company won't see any requests from you because you aren't sending anything to their servers. This is important in some programs that have rules against active scanning without permission. It is also important in the early stages of reconnaissance because you want to gather as much information as possible before you start making noise.

The main tool we will use for passive enumeration is subdog, developed by rix4uni and available at github.com/rix4uni/subdog. Subdog is a passive subdomain discovery tool that queries dozens of different data sources simultaneously — certificate transparency logs, DNS databases, security feeds, and more — to build a comprehensive list of subdomains. It is fast, it is accurate, and it has become my go-to tool for the passive phase. Another excellent tool you should know is subfinder from ProjectDiscovery, available at github.com/projectdiscovery/subfinder. Subfinder is one of the most widely used passive subdomain tools in the industry and it has integrations with many different data sources including Shodan, SecurityTrails, VirusTotal, and many more. Some of these sources require API keys — you should register for free API keys on as many of these platforms as you can because the more API keys you have configured, the more results subfinder will return. The third passive tool you should know is amass from OWASP, available at github.com/owasp-amass/amass. Amass is considered one of the most powerful and comprehensive subdomain enumeration tools ever built. It can do both passive and active enumeration and it has many advanced features for large-scope recon. I would recommend using all three tools together — subdog, subfinder, and amass — because each one has access to slightly different data sources, and combining their results will give you the most complete picture possible.

Once you have run all your passive tools and collected their output, you will likely have a lot of duplicate entries. The same subdomain might appear three or four times if multiple tools found it. This is where unew comes in. Unew is a deduplication tool, also by rix4uni, available at github.com/rix4uni/unew. It is designed to append new unique entries to an existing file without adding duplicates. When you are running multiple tools and piping their output into the same file, unew will make sure your final list is clean and contains only unique entries. The workflow looks like this — you run subdog and pipe the output through unew into a file called subs.txt, then you run subfinder and pipe its output through unew into the same subs.txt, then you run amass and do the same. Because unew checks for duplicates before writing, your final subs.txt will have all the unique subdomains from all three tools with no repetition. This might seem like a small detail, but when you are working with programs that have thousands of subdomains, deduplication is absolutely essential. Without it, you would end up with a list that has the same subdomain appearing dozens of times and your subsequent processing steps would be very slow.

Now let us talk about active enumeration, which is the second major approach. Active enumeration means you are directly sending DNS queries or HTTP requests to try to discover subdomains that haven't been indexed by any passive source. The most common active technique is DNS brute-forcing, also called subdomain fuzzing. In this approach, you take a wordlist of common subdomain names — things like api, admin, dev, staging, test, mail, vpn, cdn, app, dashboard — and you try each one against the target domain to see which ones actually resolve to real IP addresses. For example, you would try api.dell.com, admin.dell.com, dev.dell.com, and so on, until you have tried every word in your wordlist. Any subdomain that has a valid DNS record is a live subdomain. This technique can discover subdomains that were never indexed anywhere passively because they might be brand new, or they might be intentionally obscure names that no source has documented. The tool we will use for DNS brute-forcing is ffuf, available at github.com/ffuf/ffuf. The command looks like this: ffuf -c -u https://FUZZ.dell.com -w 2m-best-dns-wordlist.txt. Here, FUZZ is the placeholder where ffuf will substitute each word from the wordlist. The wordlist 2m-best-dns-wordlist.txt contains two million of the most commonly found subdomain names, so the coverage is excellent.

There are also more specialized active tools you should know. The first is subdomainfuzz, available at github.com/rix4uni/subdomainfuzz. This tool is built on top of ffuf specifically for subdomain fuzzing and it has some convenient features that make it even easier to use than raw ffuf. For example, the command echo "https://outlet.dell.com" | subdomainfuzz -silent -d dell.com -ffuf -w 2m-best-dns-wordlist.txt will take a known subdomain, extract the target domain, and run a fuzzing attack against it automatically. The second tool is whoxysubs, available at github.com/rix4uni/whoxysubs. Whoxysubs works by looking at WHOIS data — when a domain has been registered, it has registration records that sometimes reveal other domains registered by the same person or organization. By querying these records, you can discover domains and subdomains that would never appear in passive subdomain databases. The third active tool is alterx from ProjectDiscovery, available at github.com/projectdiscovery/alterx. Alterx is a subdomain permutation and alteration tool. What this means is that it takes a list of known subdomains and generates hundreds of variations of each one. For example, if you have discovered that api.dell.com exists, alterx would generate variations like api-v2.dell.com, api-dev.dell.com, api-prod.dell.com, api-staging.dell.com, and many more. It then tries to resolve each variation to see if any of them are real. This technique is extremely effective at discovering subdomain patterns that a standard wordlist would never find.

Now I want to teach you about hidden subdomains — subdomains that cannot be discovered by traditional passive or active methods because they are not indexed anywhere and they don't follow a predictable naming pattern. There are two clever techniques for finding these. The first technique uses favicon hashing with a tool called favinfo, available at github.com/rix4uni/favinfo. Every website has a favicon — that small icon that appears in the browser tab. Many subdomains that are running the same application will share the same favicon file. When you have found one subdomain of a target, you can use favinfo to calculate the hash of its favicon. Then you can search Shodan for other servers on the internet that have that exact same favicon hash. This will reveal other servers — often hidden subdomains or even completely separate domains — that are running the same application. I have discovered subdomains this way that hadn't appeared in any passive tool and weren't guessable by any wordlist. The second hidden subdomain technique uses SSL certificate analysis with certinfo, available at github.com/rix4uni/certinfo. When a server has an SSL certificate, that certificate contains something called a Subject Alternative Name (SAN), which lists all the domain names the certificate is valid for. A single SSL certificate might cover dozens of subdomains. By analyzing these certificates, you can discover subdomains that were never indexed anywhere because the company simply didn't make them public — they just quietly added them to an SSL certificate.

I also want to make sure you understand Golang installation because almost every tool I have mentioned so far — subdog, unew, subdomainfuzz, whoxysubs, favinfo, certinfo, and alterx — is written in the Go programming language. If you don't have Go installed on your system, none of these tools will work. The installation guide you should follow is at github.com/rix4uni/golang, which has a simple step-by-step guide. Installing Go on Ubuntu inside WSL is straightforward — you download the Go archive, extract it, and add it to your PATH. Once Go is installed, you can install any Go-based tool by running go install with the tool's import path. I would strongly recommend setting up Go first before you try to install any of these tools, because without it you won't be able to run them. Many students have made the mistake of trying to install a tool before setting up Go and they couldn't understand why it wasn't working. Don't make that same mistake. Set up your environment completely — Go installed, PATH configured, tools installed and tested — before you start any real reconnaissance work. Having a properly set-up environment will save you enormous amounts of frustration during actual hunting sessions.

Now let me walk you through the recommended workflow for a real subdomain enumeration session, step by step. When you are starting on a new target, the first step is passive enumeration. Run subdog, subfinder, and amass against the target domain and pipe all results through unew into a file called subs.txt. This should give you a solid base list to work from. The second step is active enumeration — run ffuf or subdomainfuzz against the target with a good wordlist. Any newly found subdomains should also be piped through unew into subs.txt so they are added to your growing list. The third step is running alterx on your existing subs.txt to generate permutations and try to discover more subdomains through pattern variations. The fourth step is running favinfo and certinfo on selected subdomains to try to find hidden ones. By the time you have completed all four steps, you will have the most comprehensive subdomain list possible for your target. After subs.txt is ready, the typical next step in the workflow is port scanning with naabu, then httpx to check which subdomains are alive and running web servers, and then URL crawling — but those are topics we will cover in the next two topics. For now, understand that subs.txt is the foundation that everything else is built on.

One topic I must not skip is out-of-scope handling. When you are working with a program that has a large scope but also has specific exclusions, you need a way to filter your subdomain list so that you don't accidentally test something that is out of scope. The tool for this is oosexclude, available at github.com/rix4uni/oosexclude. This tool takes your subs.txt and a list of out-of-scope patterns and removes any subdomains that match the excluded patterns. For example, if the program says that api.dell.com is explicitly out of scope even though the wildcard *.dell.com is in scope, you can pass that exclusion to oosexclude and it will remove it from your list automatically. This is not just a convenience — it is a matter of professionalism and responsibility. As a hunter you must respect the boundaries the company has set. Testing out-of-scope assets could cause problems for the company, could potentially impact real users, and would almost certainly get your report marked as out-of-scope, which means all your work would be wasted. Always run oosexclude before you start testing. It should be a mandatory step in your workflow.

Let me also mention something that is important about large versus medium versus small scope programs in terms of strategy. If you are new to bug bounty hunting, you might think that large scope programs are always better because they have more attack surface. And while that is true, large scope programs also require much more time and much more sophisticated tooling to cover properly. If you haven't set up your enumeration workflow yet, you would probably do better starting with a medium-scope program where the target is well-defined and manageable. Once you have practiced your workflow on medium-scope targets and you feel comfortable with subdog, subfinder, amass, ffuf, and the other tools, then you should move up to large-scope programs. For small-scope programs — a single domain — subdomain enumeration is less critical because you can't go wider than that one domain. But even on a single domain you should still enumerate subdomains if the program allows it, because admin.krazeplanet.com and api.admin.krazeplanet.com might both be in scope. Never assume that one domain means zero subdomains — always check.

To wrap everything up, subdomain enumeration is not a step you can skip or rush. The quality of your subdomain list directly determines the quality of your hunting. I have had sessions where I had a mediocre subdomain list and found almost nothing, and sessions where I had an excellent list and found multiple critical vulnerabilities on subdomains that nobody else had even looked at. The difference was always the enumeration. In this topic we have covered Golang installation, which you must do first; the three types of scope — large, medium, and small — and how they affect your approach; passive enumeration with subdog, subfinder, and amass; deduplication with unew; active enumeration with ffuf, subdomainfuzz, whoxysubs, and alterx; hidden subdomain discovery with favinfo and certinfo; and out-of-scope filtering with oosexclude. For large-scope programs, we have also discussed Crunchbase research and TLD scanning with tldscan. The recommended workflow is: subdog → subfinder → amass → ffuf/subdomainfuzz → alterx → favinfo/certinfo → oosexclude — and then you are ready for port scanning and httpx in the next topic. Install Go today, install all these tools, and practice running them against a real program. You will be amazed at how many subdomains you can find that most other hunters have completely missed. I will see you in Topic 04!

Topic 04 — Network Reconnaissance

Welcome to Topic 04 — Network Reconnaissance. In the previous topic we were learning how to find subdomains, and by now your subs.txt file should have hundreds or even thousands of subdomains ready to analyze. But having a list of subdomain names is not enough. A subdomain name on its own doesn't tell you anything about what services are running on that server, what ports are open, what software versions are in use, or how to reach the application. Network reconnaissance is the bridge between your subdomain list and your actual attack surface. It is the process of actively probing each discovered subdomain to understand exactly what is running on it, on which ports, and what that software is. I cannot stress how important this step is. Without network reconnaissance, you would only be testing the most obvious HTTP and HTTPS services on ports 80 and 443 — and you would completely miss everything else. Many critical vulnerabilities are found not on the main website but on unusual ports that most hunters never even check. Network reconnaissance is how you find those opportunities.

To understand network reconnaissance properly, you first need to understand what ports are. Think of a server like a large building. That building has thousands of doors, each numbered from 0 to 65535. Each door is a port, and different services listen on different port numbers. The server doesn't just run one service — it can run many services simultaneously, each one listening on a different port number. When you are trying to connect to a web application, your browser automatically connects to port 443 for HTTPS or port 80 for HTTP. But there are many other well-known ports you should know about. Port 80 is HTTP — regular, unencrypted web traffic. Port 443 is HTTPS — secure, encrypted web traffic, and this is the most important one you will test as a web bug bounty hunter. Port 22 is SSH — Secure Shell, the protocol used to remotely log in to a Linux server. If SSH is exposed on a subdomain, that means someone can remotely access that server over the internet. This could indicate a misconfiguration or an outdated server that the company has forgotten about. Port 21 is FTP — File Transfer Protocol, used for uploading and downloading files. An exposed FTP port on a company's subdomain might indicate an older server that could have misconfigurations like anonymous login enabled. Port 25 is SMTP — Simple Mail Transfer Protocol, used for sending email. These are just the most common examples — servers can run web applications or admin panels on completely non-standard ports like 8080, 8443, 8888, or even something unusual like port 9200 which is ElasticSearch. By scanning all ports on each subdomain rather than just 80 and 443, you will discover many more entry points into the target's infrastructure.

Now let me explain service fingerprinting, because this is where port scanning becomes truly powerful for bug bounty hunters. Service fingerprinting is the process of identifying exactly what software and version is running on an open port. A port being open doesn't tell you much on its own — but knowing that port 443 is running Apache 2.4.49 specifically is extremely valuable information. Why? Because Apache 2.4.49 has a critical publicly known Remote Code Execution vulnerability — CVE-2021-41773 — that allows an unauthenticated attacker to execute commands on the server. The moment you can fingerprint that version, you know that server is likely vulnerable. This exact scenario — scanning a port, identifying the version, finding it matches a CVE, and exploiting it — has been reported as a critical bug bounty finding many times. I have seen hunters earn thousands of dollars from exactly this workflow. The key insight is that large companies often have so many servers across so many subdomains that some of them inevitably fall behind on updates. The company's main website might be perfectly patched, but some old server on a forgotten subdomain might still be running software from two years ago. Network reconnaissance and service fingerprinting are how you find those forgotten, unpatched servers.

The primary tool we will use for port scanning is naabu from ProjectDiscovery, available at github.com/projectdiscovery/naabu. Naabu is a fast port scanning tool built specifically for the kind of large-scale scanning that bug bounty hunters need to do. Unlike traditional port scanners that can be very slow, naabu is optimized to scan many hosts quickly. The basic usage is very straightforward — you pipe a subdomain into naabu and it will tell you which ports are open. For example: echo "jira.nirvanasolutions.com" | naabu -duc -silent. Here, -duc means "disable update check" so naabu doesn't waste time checking for updates every time you run it, and -silent means it will only output the results without any verbose status messages. The output will look something like jira.nirvanasolutions.com:443 and jira.nirvanasolutions.com:8080 — meaning ports 443 and 8080 are open on that server. Another example: echo "ssodev.sunjin.com" | naabu -duc -silent — when you run this, naabu will scan for open ports on that specific subdomain and return whatever it finds. The result might show something unexpected like port 8080 open, which then becomes your next investigation target. For mass scanning across your entire subs.txt file, the command would be: cat subs.txt | naabu -duc -silent — naabu will handle the full list automatically.

The output from naabu is a file of host:port pairs — things like host-111-103.txlacolo.clients.pavlovmedia.net and host-111-103.txlacolo.clients.pavlovmedia.net:8080. This is your naabu.txt file. It contains every live host with every open port combination. But naabu only tells you which ports are open — it doesn't tell you what application is running on those ports, what the HTTP title is, what status codes they return, or which ones are actually serving web content. That is the job of httpx. Httpx is another ProjectDiscovery tool, available at github.com/projectdiscovery/httpx. It takes a list of hosts and ports and probes each one to gather rich information about the HTTP response — the status code, the page title, the content length, the content type, and much more. The recommended command is: cat naabu.txt | httpx -duc -silent -nc -sc -title -cl -ct | sort -t'[' -k3,3nr | unew -el -i httpx.txt. Let me walk you through what each flag does. The -duc flag disables update checks, same as with naabu. The -silent flag suppresses verbose output. The -nc flag disables color output so the results are clean text. The -sc flag shows the HTTP status code of each URL. The -title flag shows the HTML page title. The -cl flag shows the content length. The -ct flag shows the content type. The sort -t'[' -k3,3nr part sorts the output by content length in descending order, so the most interesting pages with the most content appear at the top. Finally, unew -el -i httpx.txt appends only new unique entries to httpx.txt, deduplicating as it goes.

There is also a newer, more convenient alternative to httpx called vyre, available at github.com/rix4uni/vyre. The equivalent vyre command is: cat naabu.txt | vyre -sc --title -cl -ct -best. The -best flag tells vyre to intelligently select the best representation of each host — if a URL redirects, it follows it and shows you where it ends up, which is often more useful than seeing a 301 redirect on the original URL. The key advantage of vyre over httpx is that it has been designed with the bug bounty workflow in mind and its output format is often cleaner and more immediately actionable. That said, httpx is more widely used and battle-tested, so you should know both and you can decide which one you prefer. Some hunters use httpx for large-scale scanning and vyre for quick checks on specific targets. Both tools will produce output that contains everything you need to know about what is running on each port.

Now let me talk about the recommended workflow, because understanding the right order of operations is just as important as knowing the individual tools. The recommended workflow is: subdog → naabu → httpx → urls. Let me explain why this order matters. You start with subdog (or your full passive+active enumeration from Topic 03) to get your complete subs.txt. Then you run naabu against subs.txt to discover which ports are open on each subdomain, which produces naabu.txt. Then you run httpx against naabu.txt to identify which of those ports are serving web content and what that content is, which produces httpx.txt. Only then, with httpx.txt, do you proceed to URL crawling, fuzzing, and vulnerability scanning. The reason you should run naabu before httpx is that if you run httpx directly on subs.txt without port scanning first, httpx will only check ports 80 and 443. You would completely miss any application running on port 8080, 8443, 8888, or any other non-standard port. By running naabu first, you discover all open ports, and then httpx can check every single one of them. This is why the recommended workflow includes naabu as a mandatory step.

Now, there is also a "not recommended but sometimes used" workflow: subdog → httpx → urls. Some hunters use this shortcut when they don't have time for a full port scan. When you are working on a quick target or you need results fast, you can skip naabu and run httpx directly on subs.txt with just ports 80 and 443. This is faster but incomplete — you will miss anything running on non-standard ports. I would not recommend this as your default approach, but it is useful to know about for situations where speed is more important than thoroughness. For example, if you are participating in a time-limited live hacking event, you might choose to skip the port scan and move faster. But in a normal hunting session where you have plenty of time, always run naabu. The extra step takes some time but it will find opportunities that you would otherwise completely miss.

Let me also explain what the httpx.txt output looks like and how you will use it. After running httpx, your httpx.txt will have entries that look something like: https://api.target.com [200] [API Dashboard] [45823] [text/html]. Each line contains the URL, the status code in brackets, the page title in brackets, the content length in brackets, and the content type in brackets. The sort command you ran earlier has already sorted these by content length from largest to smallest. This is useful because pages with more content are generally more interesting — an empty page with 0 bytes probably has nothing on it, while a page with 50,000 bytes of content likely has a full application running. By looking at the top results in your httpx.txt, you can quickly identify the most promising targets. A title like "Dashboard [Jenkins]" or "Kibana" or "Grafana" is extremely exciting because those applications often have known vulnerabilities or default credentials. A title like "Index of /" means directory listing is enabled — a potential information disclosure vulnerability. Even seemingly boring titles like "Login" or "Admin" might be worth investigating. Your httpx.txt is your roadmap for what to investigate next.

One real-world scenario that you should understand deeply is how port scanning reveals vulnerable server versions. Imagine you have a subdomain like legacy-api.targetcompany.com in your subs.txt. When you run naabu, it shows that port 443 is open. When you run httpx on that result, the page title comes back as something generic. But then in your URL crawling phase, you might discover that the server header reveals "Apache/2.4.49." At this point, you would search for "Apache 2.4.49 CVE" and immediately find CVE-2021-41773 — a critical path traversal and RCE vulnerability. You can then verify it with a simple curl command. If confirmed, that is a critical bug bounty report worth potentially thousands of dollars, found entirely through the naabu → httpx workflow. This is not a hypothetical scenario — hunters have reported exactly this kind of finding against real programs. The same logic applies to any technology: if naabu reveals port 9200 open, that might be ElasticSearch with unauthenticated access. If it shows port 5601, that might be Kibana. If it shows port 8080 with a Jenkins title, that could be an unauthenticated Jenkins instance with RCE via the script console. Every open port is a potential finding.

To summarize everything we have covered in Topic 04 — Network Reconnaissance is the step that transforms your subdomain list into a true attack surface map. We started by understanding ports and what common port numbers mean: 80 for HTTP, 443 for HTTPS, 22 for SSH, 21 for FTP, and 25 for SMTP, among many others. We then talked about service fingerprinting — the practice of identifying the exact software version running on each open port — and why it is so valuable for finding CVE-based vulnerabilities. We learned about naabu as our port scanning tool and how to use it in simple single-host mode or against an entire subs.txt file. We covered httpx and all its flags, understanding what each one does and why the sort and unew pipeline makes our output more actionable. We discussed vyre as an alternative to httpx that has some nice quality-of-life improvements. Most importantly, we established the recommended workflow: subdog → naabu → httpx → urls. Never skip the naabu step in a real hunting session — always port scan before you run httpx so you don't miss applications on non-standard ports. Your httpx.txt is the final deliverable of this phase and will be the input for the URL crawling, fuzzing, and technology-based CVE hunting topics that follow. Install naabu and httpx today, run them against a practice target, and get comfortable reading the output. I will see you in Topic 05!

Topic 05 — Technology-Based CVE Hunting

Welcome to Topic 05 — Technology-Based CVE Hunting. By this point in the course, you have your subs.txt from subdomain enumeration and your httpx.txt from network reconnaissance. You have a comprehensive map of every accessible web application running across your target's attack surface, complete with page titles, status codes, and content types. Now the question is: what do you do with all of that? Technology-based CVE hunting is the answer. This technique is one of the highest-return approaches in modern bug bounty hunting because it allows you to systematically find critical vulnerabilities — things like unauthenticated remote code execution, authentication bypass, and sensitive data exposure — across hundreds of targets simultaneously using automation. The core idea is simple: identify what technology is running on each target, then check whether that specific version has a known CVE, and if it does, verify and report it. When done correctly and at scale, this workflow can produce multiple critical findings from a single hunting session. I have seen hunters discover five or six critical CVEs in a single afternoon using exactly the technique we will cover in this topic.

Before we can understand CVE hunting, we need to understand what a CVE is. CVE stands for Common Vulnerabilities and Exposures. It is a publicly maintained database of known security vulnerabilities in software. Each CVE has a unique identifier like CVE-2021-41773 — the Apache 2.4.49 path traversal vulnerability we discussed in Topic 04. When a security researcher discovers a vulnerability in a software product, they report it to the CVE program, and after the vendor has had a chance to issue a patch, the vulnerability is published publicly with a CVE number. The CVE database is accessible at cve.mitre.org and also through NIST's National Vulnerability Database at nvd.nist.gov. Each CVE entry includes a description of the vulnerability, the affected software versions, the CVSS score (which rates how severe it is), and links to public exploits and patches. For bug bounty hunters, the CVE database is an enormous library of verified, documented vulnerabilities that you can check against the technology you discover on your targets. The key insight is that many companies run outdated software that has publicly known CVEs but hasn't been patched — either because the security team doesn't know about those instances, or because patching takes time and resources that the company hasn't allocated yet.

Now let me introduce the most powerful tool for technology-based CVE hunting: nuclei from ProjectDiscovery, available at github.com/projectdiscovery/nuclei. Nuclei is a template-based vulnerability scanner. This means that nuclei itself is just the engine — it reads YAML template files that describe how to detect a specific vulnerability, and then it runs those checks against your targets. ProjectDiscovery maintains a massive public repository of nuclei templates at github.com/projectdiscovery/nuclei-templates that currently contains thousands of templates covering CVEs, misconfigurations, exposed panels, default credentials, and much more. These templates are written by security researchers from all over the world and are constantly being updated as new CVEs are disclosed. When you install nuclei, you can update your template library with nuclei -update-templates to make sure you have all the latest checks. The community around nuclei is extremely active, and new templates for newly disclosed CVEs often appear within hours or days of the CVE being published. This means that if you are running a large-scope program and a critical new CVE comes out for a popular technology, you can immediately scan your entire httpx.txt to see if any of your target's subdomains are running that vulnerable version — before the company even knows about it.

The core command for technology-based CVE hunting is: cat httpx.txt | sort -t'[' -k3,3nr | grep "\[200\]" | awk '{print $1}' | nuclei -duc -silent -severity critical,high,medium -tags $nucleitags. Let me walk through every part of this command so you understand exactly what is happening. We start with cat httpx.txt — this reads your httpx output file, which contains all the URLs you discovered in Topic 04 along with their status codes, titles, and content lengths. The sort -t'[' -k3,3nr part sorts the results by content length in descending order, so the most content-rich pages come first. This is useful because larger pages generally are more complex applications with more potential attack surface. The grep "\[200\]" part filters the list to only include URLs that returned a 200 OK status code. You might wonder — why filter to 200 only? The reason is that you generally want to focus your CVE hunting on pages that are actually serving content. A 403 Forbidden page might still be worth testing but it is less likely to have an exploitable CVE than a fully accessible application. The awk '{print $1}' part extracts just the URL from each line, stripping away the status code, title, and other metadata so that nuclei receives a clean list of URLs to test. Finally, the nuclei command itself runs against that URL list.

Now let us look at the nuclei flags in detail. The -duc flag disables update checks — you should always pass this in your commands so that nuclei doesn't stop to check for updates mid-scan. The -silent flag suppresses all informational output and only shows actual findings — this makes your output much cleaner when you are scanning hundreds of URLs. The -severity critical,high,medium flag tells nuclei to only run templates rated as critical, high, or medium severity. By default nuclei would run all templates including informational ones — but informational findings like "this server has X header missing" are generally not worth bounties. By filtering to medium and above, you are ensuring that nuclei focuses on the findings that actually matter. The -tags $nucleitags part uses a shell variable called $nucleitags. This variable is something you define based on the technology you have identified on your targets. For example, if httpx showed you that several subdomains are running Jenkins, you would set nucleitags=jenkins and nuclei would only run templates tagged with "jenkins." If you have identified multiple technologies, you can set it to something like nucleitags="jenkins,apache,jira,confluence" and nuclei will run all templates matching any of those tags. This tag-based filtering is extremely important for efficiency — if you were to run all nuclei templates against hundreds of URLs, the scan would take many hours. By filtering to relevant technology tags, you can complete a focused scan in minutes.

The question then becomes: how do you identify what technologies are running on each target so you can set the right nuclei tags? There are several methods you can use. The first and most reliable method is reading your httpx.txt output carefully. The page titles that httpx collected often reveal the technology directly — a title like "Dashboard [Jenkins]" obviously means Jenkins is running. "Kibana" in the title means Kibana. "GitLab" means GitLab. Many enterprise applications include their product name in the page title by default. The second method is using a technology detection tool called techfinder, available at github.com/rix4uni/techfinder. Techfinder analyzes HTTP response headers, HTML content, JavaScript file names, and other signals to identify what technology stack is running on each URL. The command is: cat httpx.txt | techfinder -mode best -silent. This will produce output showing each URL alongside the detected technologies. The third method is looking at response headers directly in Burp Suite or via curl. Many web servers reveal their software and version in headers like Server: Apache/2.4.49, X-Powered-By: PHP/7.4.3, or X-Generator: Drupal 9. Even if the page title doesn't tell you much, the response headers often do. The fourth method is using Shodan and FOFA — if a subdomain has been indexed by those platforms, they often have technology information already collected. All of these methods work together to build a comprehensive picture of what technologies are running across your target.

Let me give you some concrete examples of what technology-based CVE hunting looks like in practice. Suppose you are working on a large-scope program and your httpx.txt has 500 URLs. You run techfinder on the list and it identifies that 15 of those URLs are running GitLab. You then set nucleitags=gitlab and run the nuclei command. Nuclei will check each of those 15 GitLab instances for all known GitLab CVEs. If even one of those instances hasn't been updated recently, nuclei might find that it is running a version vulnerable to CVE-2021-22205 — a critical GitLab RCE vulnerability that was widely unpatched when it first came out. That would be an immediate critical bug bounty report worth potentially $10,000 or more. Another example: your techfinder output shows that several subdomains are running Confluence. You set nucleitags=confluence and nuclei identifies that one of those instances is vulnerable to CVE-2022-26134 — the critical Confluence Server RCE via OGNL injection. Again, an immediate critical finding. The same workflow applies to Jira, Kibana, Grafana, Jenkins, WordPress, Drupal, Magento, and hundreds of other enterprise applications. Every technology that has known CVEs is a target, and nuclei has templates for most of them.

Now let me talk about custom nuclei templates, because this is where advanced hunters can get a significant edge. The public nuclei template repository is excellent, but it has limitations — there might be a gap between when a CVE is published and when a public template is written for it. If you can write your own nuclei template for a newly disclosed CVE, you will be able to scan for it before most other hunters even know the template exists. The KrazePlanet course resource at github.com/rix4uni/custom-nuclei-templates has examples of custom templates specifically designed for bug bounty hunting — including error-based-sqli.yaml and error-based-sqli-replace.yaml for SQL injection detection. Writing a nuclei template is not difficult — it is YAML format and each template essentially says "send this HTTP request to this URL and if the response contains this string or matches this regex, flag it as a finding." Once you have learned the basic YAML structure, you can write a template for any new CVE in under 30 minutes. This is a skill that will make you significantly more productive as a hunter, and I would strongly encourage you to explore the template syntax documentation at the ProjectDiscovery website after completing this course.

There is one important practical consideration when you are running nuclei at scale: rate limiting and being a responsible tester. When you have hundreds of URLs and you are running nuclei with many templates, the tool can generate a significant amount of traffic to the target's servers. You should always use the -rl flag (rate limit) to control how many requests per second nuclei sends. For example, -rl 50 limits nuclei to 50 requests per second, which is generally reasonable for most programs. Some programs explicitly prohibit automated scanning, so always read the program policy before running nuclei. If the program says "no automated scanning," then nuclei-based CVE hunting is not allowed on that program, even if it would produce valid findings. Most large-scope programs do allow automated scanning, but always check first. Additionally, when nuclei finds a potential vulnerability, you should always manually verify it before submitting a report. Nuclei templates can produce false positives, especially for more complex detection logic. I have seen reports get marked as duplicates or invalid because the hunter submitted a nuclei finding without manually verifying it first. Take the extra 10 minutes to manually confirm that the vulnerability is real before you write your report.

Let me also talk about severity levels and how to prioritize your findings. When nuclei produces output, each finding has a severity level: critical, high, medium, low, or informational. Critical findings — things like unauthenticated RCE, authentication bypass affecting all users, or access to production databases — are your top priority. These are the findings that companies will pay the highest bounties for and will respond to fastest. High findings — like stored XSS in an authenticated context, SQL injection requiring authentication, or SSRF — are also very valuable. Medium findings might include things like reflected XSS, open redirects that can be chained with other issues, or sensitive information disclosure. When you are working a hunting session, you should triage your nuclei output from most severe to least severe and focus your manual verification time on the critical and high findings first. A critical nuclei finding that you have manually verified and written a clear report for is worth far more of your time than ten informational findings. The -severity critical,high,medium flag in the command we covered earlier already handles this filtering for you at the scan level, ensuring you are not wasting processing time on low-impact checks.

To bring everything together — in Topic 05 we have covered one of the most high-impact techniques in the entire course. Technology-based CVE hunting is powerful because it scales — a single well-tuned nuclei command can check hundreds of URLs for dozens of CVEs in minutes. The workflow is: take your httpx.txt from Topic 04, sort and filter it to 200 OK responses, extract the clean URLs, then pipe them through nuclei with the appropriate severity filter and technology tags. Technology identification can be done by reading httpx titles, running techfinder, examining response headers, or querying Shodan and FOFA. The $nucleitags variable is your most important tuning parameter — always set it based on what you have actually identified running on your targets rather than running all templates blindly. For even deeper coverage, custom nuclei templates let you check for newly published CVEs before public templates exist. Always rate-limit your scans, always check the program policy on automated tools, and always manually verify findings before submitting reports. The hunters who are consistently earning critical bounties from CVE hunting are the ones who have built this workflow into their daily routine — they watch the CVE feeds, they update their nuclei templates constantly, and they move fast when a new critical CVE drops. That is the mindset I want you to develop. I will see you in Topic 06!

Topic 06 — IIS Windows Server Reconnaissance

Welcome to Topic 06 — IIS Windows Server Reconnaissance. This topic is one of the most unique and specialized techniques in the entire course, and it is one that the majority of bug bounty hunters completely overlook. Most hunters are focused on Linux-based web servers running Apache or Nginx, but Microsoft's IIS — Internet Information Services — powers a significant portion of enterprise web applications worldwide, particularly in large corporations, government agencies, and financial institutions. IIS has its own unique set of vulnerabilities and misconfigurations that simply do not exist on other web server types, and because so few hunters understand them, the competition on IIS targets is dramatically lower. I have seen hunters find critical vulnerabilities on IIS servers that had been running for years without anyone ever checking, simply because those hunters knew what to look for and others didn't. In this topic, we will cover how to identify IIS servers at scale, how to exploit the famous IIS short filename vulnerability using shortscan, and how to turn a short filename disclosure into a real finding worth submitting.

First, let me explain what IIS is and why it is so common in enterprise environments. IIS is Microsoft's web server software that comes bundled with Windows Server. When a company has chosen to build their infrastructure on Windows Server — which is extremely common in large enterprises, healthcare, banking, and government — their web applications are very likely running on IIS. These companies often have deeply complex internal applications built on technologies like ASP.NET, C#, and .NET that only run on Windows IIS. When you are doing reconnaissance on a large company and you notice that some of their subdomains are returning an IIS-specific page, that is a signal that you are dealing with their Windows infrastructure. IIS servers tend to be older and less frequently updated than their Linux counterparts in many organizations — the reason is that Windows Server licensing, update management, and application compatibility testing can make patching more complex and time-consuming. This means you will often encounter IIS servers that are running outdated versions with known vulnerabilities. The default IIS error page has changed across versions, but many organizations still show the classic "IIS Windows Server" welcome page — and that page is your first indicator that an IIS server is present.

To find IIS servers at scale, we use dorking across three major platforms: Google, Shodan, and FOFA. On Google, the dork is intitle:"IIS Windows Server". This will return pages that have the IIS welcome message in their page title, which means those servers are running the default IIS configuration without any custom application hosted on the root path. On Shodan, the equivalent query is title:"IIS Windows Server". On FOFA, it is title="IIS Windows Server". These dorks are useful for finding IIS servers that belong to your target organization when you already know what company you are hunting on. For example, if you are working on a Dell bug bounty program, you would search Shodan for title:"IIS Windows Server" org:"Dell Inc." to find IIS servers specifically within Dell's infrastructure. When you are working with httpx.txt from your reconnaissance workflow, you can also identify IIS servers from your existing data. Many IIS servers return response headers like Server: Microsoft-IIS/10.0 which httpx can collect. The techfinder tool we discussed in Topic 05 also detects IIS. The mass IIS hunting command from the syllabus is: cat subs.txt | techfinder -mode best -silent | grep -aE "IIS|IIS Windows Server|Microsoft-IIS|Windows Server" | awk '{print $1}' | unew httpx.txt. This command pipes your subs.txt through techfinder to detect technologies, then filters for any line that mentions IIS or Windows Server, then extracts just the URL and appends it to your httpx.txt. This gives you a targeted list of confirmed IIS servers to attack.

Now let me explain the most important IIS-specific vulnerability you will learn in this topic: the IIS short filename vulnerability, also known as the "8.3 filename disclosure" or the "tilde vulnerability." To understand this, you first need to understand a little bit of Windows history. Early versions of Windows — Windows 3.1, Windows 95, Windows 98 — used a file naming convention called the "8.3 format" because it only allowed filenames of up to 8 characters for the name and 3 characters for the extension. For example, a file named WEBREPORT.ZIP would have had an 8.3 name of WEBREP~1.ZIP. The tilde character followed by a number was how Windows resolved filename conflicts when the full name was too long. Even though modern versions of Windows Server fully support long filenames, they still maintain these 8.3 short names for backward compatibility. The critical security implication is this: IIS has a vulnerability that allows an unauthenticated attacker to enumerate these short filenames by sending specific HTTP requests using wildcard characters. Even if a file or directory is not directly accessible via its full name, IIS might reveal that it exists by responding differently to requests using the tilde format. This means you can discover the existence of sensitive files — ZIP archives, SQL backups, configuration files, PDF documents — that were never meant to be publicly accessible.

The tool we will use to exploit this vulnerability is shortscan, available at github.com/rix4uni/shortscan. Shortscan is a modern, fast implementation of the IIS short filename scanner that has been specifically optimized for bug bounty use. The basic command is very simple: echo "https://charakpath.com/" | shortscan --parallel 10. The --parallel 10 flag tells shortscan to run 10 parallel requests, which speeds up the scan significantly. Here are some more examples from the syllabus: echo "https://policemdl.112.up.gov.in:72/" | shortscan --parallel 10 and echo "https://citizen.mahapolice.gov.in/" | shortscan --parallel 10. Notice that government websites are included as examples — government agencies often run old IIS infrastructure that hasn't been updated in years, and the IIS short filename vulnerability has been around since 2010. Many of these sites still haven't disabled the feature that allows this enumeration. When shortscan finds short filenames, the output will show you entries like WEBREP~1.ZIP — a short filename pointing to some ZIP archive on the server. That disclosure alone is already a valid finding — it confirms that the IIS short filename vulnerability exists on the server. But the real value comes from figuring out what the full filename actually is.

Once shortscan has given you a short filename like WEBREP~1.ZIP, you need to figure out the full original filename so you can try to access the actual file. The 8.3 format gives you the first 6 characters of the filename — in this case "WEBREP" — plus the extension "ZIP". So you know the full filename starts with "WEBREP" and ends with ".ZIP". Your goal now is to find the complete name. There are two approaches to this. The first approach is GitHub reconnaissance — you search GitHub for the target company's repositories and look for any references to ZIP files that start with "WEBREP". Developers often commit documentation, scripts, or configuration files that mention filenames used in the application's deployment. If a developer has ever referenced "WEBREPORT.ZIP" in a commit message, a README, a deployment script, or any other file in a public repository, you will find it with a GitHub search. The second approach is wordlist-based fuzzing — you take the information you have (starts with "WEBREP", ends with ".ZIP") and you use ffuf to brute-force the remaining characters. You would search your wordlists for all entries that match the pattern WEBREP*.ZIP, then run ffuf against the target with that filtered wordlist. The command would look something like: ffuf -c -u https://target.com/FUZZ.ZIP -w filtered-webrep-wordlist.txt. When ffuf finds the correct filename and the server responds with 200, you have discovered an accessible file that was never meant to be public.

Let me walk through why the full file access matters and what kinds of findings you can get from it. If that WEBREPORT.ZIP file is accessible and you can download it, you might find source code, database backups, configuration files with credentials, internal reports, or any number of sensitive items depending on what the company has stored there. Even if the file itself is not downloadable — if the server returns a 403 Forbidden on the full URL — the short filename disclosure alone can be reported as an information disclosure vulnerability, because it reveals the existence of files that the company might not want exposed. Some bug bounty programs specifically list IIS short filename disclosure as a valid finding. I have seen reports of this vulnerability accepted on programs at large enterprise companies — particularly at companies like Strabag, ABB, OpenText, and others listed in the syllabus like cmsapp.strabag.com, stsint.abb.com, and webapp.opentext.com — where the IIS infrastructure is old enough that the tilde enumeration feature has never been disabled. The vulnerability has been publicly known for over a decade but it still appears on enterprise systems regularly, which makes it a great target for hunters who know how to look for it.

For mass IIS hunting across your full httpx.txt, the workflow is straightforward. After you have identified your IIS targets using techfinder, you run shortscan across all of them: cat httpx.txt | shortscan --parallel 10 --maxtime 120. The --maxtime 120 flag tells shortscan to give up on each host after 120 seconds if it hasn't finished, which prevents the scan from hanging indefinitely on slow or unresponsive servers. When you are running this against a large httpx.txt, the scan might take a while depending on how many IIS servers you have. But the results can be extremely valuable — a single scan across a large-scope program's IIS infrastructure might reveal dozens of short filenames across multiple subdomains, each one a potential information disclosure finding. You should save the shortscan output to a file so you can analyze it systematically. For each discovered short filename, you will then follow the GitHub search and wordlist fuzzing approach to try to resolve the full filename and access the actual file.

There is one more important detail about the shortscan technique that you should understand: the vulnerability affects both files and directories. When shortscan runs, it can discover both short file names (like WEBREP~1.ZIP) and short directory names (like ADMINI~1 which might map to a directory called ADMINISTRATION). A short directory name disclosure can be just as valuable as a file disclosure — if you can determine the full directory name, you can then run a directory fuzzing scan inside it and potentially find more sensitive files or admin panels. The technique chains naturally with the directory fuzzing approach we will cover in Topic 08. And importantly, the IIS short filename vulnerability often coexists with other IIS-specific issues. If a server is running an old enough version of IIS that it has the short filename vulnerability enabled, it might also be running an outdated ASP.NET version with its own CVEs. The shortscan disclosure gives you a reason to look deeper at that specific server's configuration and version history.

To summarize everything we have covered in Topic 06 — IIS Windows Server Reconnaissance is a niche but high-value specialization that most bug bounty hunters completely overlook. We started by understanding what IIS is, why it is so common in enterprise environments, and why those environments often have outdated, unpatched IIS servers. We learned three different dorking approaches — Google intitle:"IIS Windows Server", Shodan title:"IIS Windows Server", and FOFA title="IIS Windows Server" — to find IIS servers either in a targeted search for a specific company or at scale. We learned how to use techfinder with grep to extract IIS targets from your existing subs.txt or httpx.txt. We covered the IIS short filename vulnerability in depth: what 8.3 filenames are, why Windows still generates them for backward compatibility, how IIS exposes them through tilde enumeration, and what the security impact is. We learned to use shortscan for both single-host and mass scanning scenarios, including the --parallel and --maxtime flags. And we covered the full post-disclosure workflow: take a discovered short name like WEBREP~1.ZIP, search GitHub for the full filename, grep your wordlists, and use ffuf to confirm and access the file. Add IIS reconnaissance to every large-scope hunting session — the hunters who check for it regularly find things that everyone else has walked right past. I will see you in Topic 07!

Topic 07 — Historical Analysis & Crawling

Welcome to Topic 07 — Historical Analysis and Crawling. By this point in the course, you have your subs.txt from subdomain enumeration, your naabu.txt from port scanning, and your httpx.txt with all the live web applications your target is running. The next critical step is URL collection — building the most complete possible list of every URL endpoint your target has ever exposed. URL collection is the foundation for almost everything that comes after: parameter-based vulnerability testing, directory fuzzing, JavaScript analysis, and manual application review all depend on having a rich set of URLs to work from. If your URL list is incomplete, you will miss entire sections of the application and potentially skip the exact endpoint where the vulnerability is hiding. In this topic we will cover two completely different approaches to URL collection — passive historical analysis and active crawling — and you will learn when and how to use each one. By the end of this topic, your urls.txt file will have thousands of URLs ready for the next phase of hunting.

Let me start by explaining the difference between passive and active URL collection, because this distinction is fundamental to understanding why we need both. Passive URL collection means gathering URLs from third-party sources that have already crawled and indexed the target in the past. These sources include web archives, search engine caches, threat intelligence feeds, and security scan databases. The key advantage of passive collection is that you are not sending any traffic to the target — you are just querying external databases. This makes it completely silent and safe even on programs with strict rules against active scanning. The other advantage is that passive sources often have historical data — URLs that were accessible months or years ago and may no longer be linked from the current website. Those old, forgotten endpoints can be goldmines because they might still be live and running but haven't received any security attention since they were removed from navigation. Active crawling, on the other hand, means visiting the target website yourself and following links to discover URLs. Active crawling finds current endpoints that are accessible right now, including endpoints that were never indexed by any passive source. For the best coverage, you should always do both.

The four main passive sources for extracting URLs are the Wayback Machine, Common Crawl, AlienVault OTX, and URLScan. Let me explain what each one is. The Wayback Machine at web.archive.org is the Internet Archive's web crawler, which has been indexing the web since 1996. It has snapshots of billions of web pages going back decades, and it maintains a CDX API that allows you to programmatically query all the URLs it has ever seen for a given domain. When you query the Wayback Machine for a domain like dell.com, it might return millions of URLs that were accessible at various points in time. Some of those URLs might lead to old admin panels, old API endpoints, old file uploads, or old features that the company thought they had taken down but haven't actually removed from the server. Common Crawl at commoncrawl.org is another massive web crawl project that makes its data freely available. It has crawled petabytes of web content and maintains indexes of discovered URLs, JavaScript files, and API endpoints. AlienVault OTX is a threat intelligence platform that has collected URL data from security researchers monitoring malicious infrastructure — it often contains URLs that security teams have flagged for investigation. URLScan.io is a service where security researchers can submit URLs for analysis, and all results are publicly searchable. It often has detailed data about API calls, JavaScript files, and subdomains discovered during those scans. All four of these sources together give you an extraordinarily comprehensive historical picture of what has ever been accessible on your target.

The primary tool for passive URL collection is waymore, developed by xnl-h4ck3r and available at github.com/xnl-h4ck3r/waymore. Waymore is specifically designed to query all major passive URL sources simultaneously and return a deduplicated combined result. There is one very important thing you need to know about waymore: it takes a root domain as input, not a subdomain list. This is actually a major advantage. When you give waymore just the root domain — for example dell.com — it automatically queries for all subdomains too, acting as a wildcard. This means you do not need to pipe your entire subs.txt through it one domain at a time. The command from the syllabus is: echo "dell.com" | waymore -mode U -lr 3 -lcc 3 -f --stream | unew urls.txt. Let me explain each flag. The -mode U flag tells waymore to operate in URL mode — it will return URLs rather than trying to download page content. The -lr 3 flag limits the response size to 3 megabytes per source, which prevents waymore from spending too long on any single data source. The -lcc 3 flag limits the Common Crawl results to the 3 most recent crawl indexes, which keeps the results current and manageable. The -f flag enables filtering to remove duplicate and low-quality URLs automatically. The --stream flag tells waymore to stream results as they come in rather than waiting for all sources to finish before showing output — this means you can start seeing results almost immediately. Finally, piping through unew urls.txt appends all new unique URLs to your urls.txt file without duplicates.

When waymore finishes, you might have anywhere from a few thousand to millions of URLs in urls.txt depending on how large the target is. The Wayback Machine alone for a large company like dell.com might return hundreds of thousands of archived URLs. This is both exciting and overwhelming — the volume of historical data can be enormous. I want you to understand that not every URL in this list will still be live. Many of them might return 404 errors because the pages no longer exist. But a significant portion of them will still be accessible, and within that accessible portion, you will find some extremely interesting endpoints. I have seen hunters find SQL injection in URL parameters that were discovered entirely through Wayback Machine historical data — the endpoint hadn't been linked anywhere on the current website for years but it was still live and still vulnerable. Historical analysis is how you find those endpoints that everyone else has overlooked because they only tested what is currently visible in the navigation.

Now let us move on to active crawling. Where passive analysis gives you the history, active crawling gives you the present. The primary tool for active crawling is katana from ProjectDiscovery, available at github.com/projectdiscovery/katana. Katana is a next-generation web crawler that can handle both regular HTML links and JavaScript-rendered pages. This is extremely important because modern web applications are heavily JavaScript-based — many of the most interesting API endpoints and routes are only discoverable by executing the JavaScript, not just reading the HTML. The command for crawling a single URL is: echo "https://www.dell.com" | katana -duc -silent -nc -jc -concurrency 10 -parallelism 10 -depth 7 -timeout 30 -aff | unew urls.txt. For crawling your entire httpx.txt list of discovered subdomains, the command becomes: cat httpx.txt | katana -duc -silent -nc -jc -concurrency 10 -parallelism 10 -depth 7 -timeout 30 -aff | unew urls.txt. Let me explain the important flags. The -duc and -silent and -nc flags you already know from previous tools — disable update check, suppress output, disable colors. The -jc flag is crucial — it enables JavaScript crawling, which means katana will parse JavaScript files and extract API endpoints and URL patterns embedded in the code. The -concurrency 10 flag controls how many concurrent HTTP requests katana makes, and -parallelism 10 controls how many URLs from your input list are processed simultaneously. The -depth 7 flag tells katana to follow links up to 7 levels deep from the starting URL. The -aff flag enables "auto form fill" — katana will automatically fill in and submit forms it encounters, which allows it to discover URLs that only become accessible after a form is submitted.

The second active crawling tool you should know is urlflux, available at github.com/rix4uni/urlflux. Urlflux is a fast URL extractor that takes a URL as input and crawls it to discover more URLs. It is lighter and faster than katana, making it useful when you want a quick surface-level crawl rather than a deep recursive one. The commands are simple: for a single URL, echo "https://www.dell.com" | urlflux --silent | unew urls.txt, and for multiple URLs from a file, cat urls.txt | urlflux --silent | unew urls.txt. Notice that in the second command, you are feeding urls.txt back into urlflux — this means you can first collect URLs from waymore and katana into urls.txt, then run urlflux on that entire list to extract even more URLs from every page you have already found. This is sometimes called a "snowball" approach — each tool feeds its output into the next tool, and your URL list grows larger with each pass. The combination of waymore + katana + urlflux together will give you one of the most comprehensive URL lists you can possibly build on a target.

Once you have your raw urls.txt with potentially hundreds of thousands of URLs, you need to process it before you can start testing. The raw list will contain many duplicates — the same URL with slightly different query string values, for example. It will also contain many URLs that are clearly not interesting for vulnerability testing — static image files, CSS files, font files, and so on. This is where deduplication and filtering tools come in. The key tool for deduplication is urldedupe, available at github.com/ameenmaali/urldedupe. Urldedupe intelligently deduplicates URLs by treating URLs with different parameter values but the same parameter names as duplicates. For example, https://target.com/search?id=1 and https://target.com/search?id=2 and https://target.com/search?id=3 all represent the same endpoint with the same parameter — you only need one of them to test for injection. Urldedupe will keep one and discard the rest. The command from the syllabus is: cat urls.txt | grep -a "://\(www\.\)\?gladia\.io" | grep -a "=" | urldedupe -s | urlfilter --silent | unew finalurls.txt. Let me walk through this. First, grep -a "://\(www\.\)\?gladia\.io" filters the URL list to only keep URLs belonging to your target domain — this is important because crawlers sometimes follow external links and add third-party URLs to your list. Second, grep -a "=" keeps only URLs that have at least one URL parameter — the equal sign in a URL indicates a parameter, and parameters are where most injection vulnerabilities are found. Third, urldedupe -s deduplicates using smart mode. Fourth, urlfilter --silent applies additional filtering to remove noise. The result, written via unew to finalurls.txt, is a clean, deduplicated list of parameterized URLs ready for vulnerability testing.

There is one more tool from the syllabus that you need to know about: gf, available at github.com/rix4uni/gf. Gf stands for "grep for" and it is a tool that lets you apply pre-defined patterns to your URL list to extract specific categories of potentially vulnerable endpoints. For example, the gf pattern for XSS will search your URL list for parameters that are commonly vulnerable to cross-site scripting, like ?search=, ?q=, ?redirect=. The gf pattern for SQL injection will find parameters like ?id=, ?user=, ?select=. The gf pattern for open redirects will find parameters like ?url=, ?next=, ?return=. Using gf patterns on your finalurls.txt allows you to quickly segment your URL list into topic-specific testing queues. Instead of manually reviewing thousands of URLs looking for interesting parameters, gf does the classification work for you. The workflow would be: cat finalurls.txt | gf xss | unew xss-candidates.txt for XSS candidates, cat finalurls.txt | gf sqli | unew sqli-candidates.txt for SQL injection candidates, and so on. Each output file then becomes a targeted testing queue for that specific vulnerability class. This segmented approach is much more efficient than testing everything for everything — you can focus your Burp Suite testing on the most likely candidates for each vulnerability type.

Let me also talk about an often-underestimated aspect of historical analysis: JavaScript file analysis. When waymore or katana crawls a target, they discover JavaScript files that are loaded by the application. These JS files can contain hardcoded API endpoints, authentication tokens, internal URLs, AWS S3 bucket names, and sometimes even credentials or API keys that developers accidentally committed. Many critical findings on modern web applications have come from analyzing JavaScript files that were collected during the crawling phase. When you are reviewing your urls.txt after running your crawling tools, you should filter for .js files specifically and examine them for sensitive information. Tools like trufflehog and secretfinder can automate this process by scanning JavaScript files for patterns that look like secrets — API keys, tokens, passwords. The URLs you collect in this topic are not just for injection testing — they are also your map to all the JavaScript the application loads, and those JavaScript files might contain information that is as valuable as a direct vulnerability.

To bring everything together — in Topic 07 we have covered Historical Analysis and Crawling, the step that transforms your httpx.txt map of live applications into a comprehensive list of testable URL endpoints. We started with the distinction between passive and active collection. For passive collection, we covered the four main sources — Wayback Machine, Common Crawl, AlienVault OTX, and URLScan — and the waymore tool that queries all of them simultaneously. The important waymore insight is that it takes a root domain and handles all subdomains automatically — you do not need to run it per-subdomain. For active crawling, we covered katana with its JavaScript crawling capability via the -jc flag, and urlflux as a lightweight alternative that can also be fed your existing urls.txt for a second pass. For post-processing, we covered urldedupe for smart deduplication, urlfilter for noise removal, and the pipeline that produces a clean finalurls.txt of parameterized target URLs. We also covered gf for segmenting that final list into vulnerability-specific testing queues. The recommended workflow is: waymore → katana on httpx.txt → urlflux → urldedupe + urlfilter → gf patterns → vulnerability-specific testing queues. With a well-built urls.txt and finalurls.txt, you will have everything you need for the deep vulnerability testing topics that follow. I will see you in Topic 08!

Topic 08 — Content Discovery & Directory Fuzzing

Welcome to Topic 08 — Content Discovery and Directory Fuzzing. We have now built a comprehensive picture of our target's attack surface through subdomain enumeration, port scanning, HTTP probing, and URL crawling. But there is an entire category of content that none of those techniques will find — directories, files, and endpoints that exist on the server but are never linked from anywhere. A developer might have created a backup file called backup.zip and uploaded it to the web root by mistake. An old admin panel might still be accessible at /admin-old/ even though no link points to it anymore. A configuration file might have been accidentally left accessible at /config.php. A debug endpoint might be reachable at /debug. None of these would appear in any crawl or historical URL source because they are not linked. Content discovery through directory fuzzing is how you find them. It is the technique of systematically guessing file and directory names against a target server using a wordlist, and checking which ones exist. If you do not fuzz, you will miss an entire class of vulnerabilities that are hiding in plain sight.

Before we can fuzz effectively, we need a good wordlist — and the quality of your wordlist directly determines the quality of your fuzzing results. A wordlist is simply a text file containing one word or path per line, like admin, backup, config, api, login, dashboard, and so on. When ffuf runs, it takes each line from the wordlist and substitutes it into the URL at the FUZZ placeholder, sending a request for each one. The more comprehensive your wordlist, the more likely you are to find something interesting. There are two approaches to building your wordlist — using pre-built community wordlists and generating custom target-specific wordlists. A professional hunter should use both. The pre-built wordlists you should know about from the syllabus include: all.txt from the rix4uni WordList repository, which contains a large general-purpose collection; onelistforallshort.txt and onelistforallmicro.txt from the six2dez OneListForAll repository, which are curated "best of" lists that balance coverage with speed; and admin-panel-paths.txt from rix4uni's WordList, which specifically targets common admin panel paths across dozens of different technologies. Each of these wordlists has been built from real-world findings by security researchers and contains paths that have actually been found on production systems.

Now let me explain the custom wordlist generation approach, which is one of the most powerful techniques you will learn in this topic. A generic wordlist contains common paths across all technologies, but a target-specific wordlist contains paths that are specifically relevant to the technologies your target is running. If you have identified from your httpx.txt and techfinder output that the target is running WordPress, PHP, and MySQL, then your wordlist should emphasize WordPress-specific paths like /wp-admin/, /wp-content/uploads/, /wp-json/, PHP-specific files like phpinfo.php, config.php, db.php, and MySQL-related backup file patterns. If instead the target is running Jenkins, Swagger UI, IIS, and Kibana, then your wordlist should focus on paths specific to those technologies — things like /jenkins/script/, /swagger-ui/, /api-docs/, /kibana/. The way to generate these custom wordlists is to use an AI assistant — you can describe the technology stack to Claude or ChatGPT and ask it to generate a targeted 500-entry wordlist of sensitive paths, backup patterns, and admin interfaces for those specific technologies. For example, the syllabus shows custom wordlist prompts like: "MySQL, Nginx, PHP, WordPress — write a custom 500+ wordlist for directory fuzzing" and "Jenkins, Swagger UI, IIS Windows Server, Kibana — write a custom 500+ wordlist." You can also ask for lists focused on specific file extensions like those ending in .log, .zip, .sql, or .old — these extensions are associated with backup files and log files that might have been accidentally left accessible.

There are also two automated tools for generating target-specific wordlists. The first is thorfinn, available at github.com/rix4uni/thorfinn. Thorfinn analyzes a target website and generates a wordlist from the words and paths it finds in the page source, JavaScript files, CSS files, and other loaded resources. The command is: echo "https://www.nasa.gov" | thorfinn --silent | unew wordlist.txt. When you run thorfinn on a target, it visits the page, parses everything it can find — comments, variable names, function names, URL fragments — and outputs all unique words as wordlist candidates. Because these words come directly from the target application's own code and content, they are far more likely to match actual file and directory names than a generic wordlist would be. For example, if the application's JavaScript contains a reference to reportingModule, thorfinn will add "reportingModule" to the wordlist, and when you fuzz with it you might discover a directory called /reportingModule/ that wasn't linked anywhere. The second approach from the syllabus uses subdomain names as wordlist entries: echo "krazeplanet.com" | subdog --silent --all | tr '.' '\n' | unew wordlist.txt. This command takes all subdomains of the target, splits each subdomain on the dot character to get individual words, and adds them to the wordlist. The logic is that if a company has a subdomain called payments.krazeplanet.com, they might also have a directory called /payments/ on other subdomains. Developer naming conventions tend to be consistent within a company, so their subdomain names often predict their directory names.

Now let us cover the actual fuzzing tools. The primary directory fuzzing tool throughout this course is ffuf, available at github.com/ffuf/ffuf. We have already seen ffuf in Topic 03 for subdomain fuzzing. The same tool handles directory fuzzing by placing the FUZZ keyword in the URL path instead of the subdomain position. A basic directory fuzz command would look like: ffuf -c -u https://target.com/FUZZ -w all.txt. For even easier mass fuzzing, we have ffufscan, available at github.com/rix4uni/ffufscan. Ffufscan is a wrapper around ffuf that handles many of the common configuration choices automatically, making it faster to launch a scan. The command is as simple as: echo "https://sagadb.org" | ffufscan --wordlist all.txt. Ffufscan will automatically set appropriate timeouts, threads, and output formats while running ffuf against the target. One critically important point from the syllabus that you must remember: always fuzz all HTTP status codes — 403, 302, 301, 404, and 200. Many hunters make the mistake of only looking at 200 responses, thinking that 403 means "forbidden and inaccessible" and therefore not interesting. This is wrong. A 403 response means the directory or file does exist on the server — the server is just refusing to show it to you. A 403 on a path like /admin/ is actually a very interesting finding because it confirms the admin panel exists. You can then try bypass techniques — adding headers, modifying the path with URL encoding, or using HTTP method overrides — to access it. Similarly, 301 and 302 redirects often point to something interesting, and even a 404 from a specific path might indicate the path was once valid and the resource has just been moved.

Now let me explain a technique that is often overlooked by beginners: hidden parameter discovery. Even when you have a URL that appears to work without any parameters — like https://target.com/search — that endpoint might actually accept hidden parameters that change its behavior in ways you cannot see from the URL itself. These hidden parameters might enable debug mode, change the output format, bypass authentication checks, or expose additional functionality. For example, appending ?debug=true to a URL might reveal verbose error messages that expose database queries and stack traces. Appending ?admin=1 might enable an admin view. Appending ?export=csv might enable a data export feature. These parameters are not documented publicly and are not linked from anywhere — they can only be discovered through parameter fuzzing. The primary tool for this is x8, available at github.com/Sh1Yo/x8. X8 sends requests with many different parameter names simultaneously and analyzes the responses to identify which parameter names cause a different behavior in the application. If the response changes in size, status code, or content when a particular parameter is added, that parameter likely has meaning to the application. The command is: x8 -u https://kzlabs.in/subdomains/hide/index.php -X GET --disable-progress-bar --reflected-only -w params.txt. Here, -X GET specifies the HTTP method, --reflected-only tells x8 to only report parameters whose values are reflected in the response (useful for finding XSS candidates), and -w params.txt specifies the parameter names wordlist from raw.githubusercontent.com/rix4uni/WordList/refs/heads/main/params.txt.

For even simpler parameter scanning, there is x8scan, available at github.com/rix4uni/x8scan. This tool is a wrapper around x8 that handles configuration automatically and accepts input via pipe. The commands are: echo "https://kzlabs.in/subdomains/hide/index.php" | x8scan -w params.txt for a single URL and echo "https://hide.pwnedbox.site/" | x8scan -w params.txt for another. You can also pipe your entire list of PHP pages through x8scan for mass parameter discovery. Speaking of PHP pages — this is another important technique. When you are looking for parameter-based vulnerabilities like SQL injection, you should focus specifically on server-side script files rather than static pages. The file extensions that indicate server-side processing are: .php, .asp, .aspx, .jsp, .jspx, .xml, and .html (when the server is configured to process HTML dynamically). You can extract PHP pages from your URL list with: cat urls.txt | grep -a ".php$". This gives you a focused list of PHP endpoints that are very likely to have database interactions and therefore are prime candidates for SQL injection testing. The same grep pattern works for other extensions: grep -a ".asp$" for ASP, grep -a ".aspx$" for ASPX, and so on. By running your parameter scanners specifically against these server-side script files rather than your entire URL list, you will be much more efficient with your testing time.

There is also msarjun, available at github.com/rix4uni/msarjun, which is another parameter discovery tool focused on mass scanning. When you have hundreds of target URLs, running x8 against each one individually would be extremely slow. Msarjun is designed to handle parameter fuzzing at scale across many URLs simultaneously. And finally, paramfilter, available at github.com/rix4uni/paramfilter, helps you filter your discovered parameters to focus on the most interesting ones. After running parameter discovery tools, you might end up with hundreds of potential parameters — paramfilter applies rules to identify which ones are most likely to be interesting for specific vulnerability types. Together, x8, x8scan, msarjun, and paramfilter form a complete parameter discovery and prioritization pipeline that feeds directly into your vulnerability testing phases.

Let me bring together the full content discovery workflow so you have a clear picture of how everything connects. Step one is wordlist preparation — you should combine a good pre-built wordlist (all.txt or onelistforallshort.txt) with a custom target-specific list generated by thorfinn and the subdomain-word-extraction technique. Step two is directory fuzzing using ffufscan or ffuf against each live URL in your httpx.txt. Remember to pay attention to 403 and redirect responses as well as 200 responses. Step three is extension-based filtering — after fuzzing, run your URL list through grep filters to extract server-side script files by extension. Step four is hidden parameter discovery using x8scan on your filtered list of server-side script URLs. Step five is output filtering using paramfilter to prioritize the most interesting discovered parameters. At the end of this workflow, you will have discovered content that no passive tool or crawler would have found — hidden admin panels, backup files, forgotten endpoints, debug parameters, and much more. Each of these discoveries becomes a fresh target for the vulnerability-specific testing topics that follow in this course. Content discovery is not glamorous work, but it is how professional hunters consistently find things in places that look empty to everyone else. I will see you in Topic 09!

Topic 09 — Advanced Dorking & OSINT Recon

Welcome to Topic 09 — Advanced Dorking and OSINT Recon. Everything we have covered so far — subdomain enumeration, port scanning, URL crawling, directory fuzzing — has been about methodically mapping what a company has exposed on their own servers. But there is another dimension to reconnaissance entirely: searching the public internet for information that the company has exposed without realizing it. This is what dorking and OSINT are about. OSINT stands for Open Source Intelligence — the practice of gathering information from publicly available sources rather than directly probing a target. Dorking is the technique of using advanced search engine operators to find specific types of content that normal search results would never surface. Together, dorking and OSINT can reveal exposed admin panels, sensitive files, login pages, vulnerable technologies, server infrastructure details, and even origin IP addresses behind content delivery networks and WAFs. I want you to treat this topic as a complete recon phase on its own — in many bug bounty sessions, a well-crafted dork on Shodan or Google has led directly to a critical finding faster than hours of subdomain enumeration and fuzzing could. The KrazePlanet dork collection at dorks.krazeplanet.com and the Google-specific dork page at dorks.krazeplanet.com/google.html are your starting resources for this topic.

Let us begin with Google dorking, which is the practice of using Google's advanced search operators to find specific content that is indexed by Google but not easily discoverable through normal browsing. There are five core operators you must master. The site: operator limits search results to a specific domain — for example, site:dell.com will only show Google results from dell.com and its subdomains. The inurl: operator searches for a specific string in the URL of a page — inurl:admin will find pages where the word "admin" appears in the URL path. The intitle: operator searches the page title — intitle:"Admin Login" finds pages whose title contains "Admin Login." The intext: operator searches the body content of pages — intext:"Index of" finds pages containing that phrase, which often indicates directory listing is enabled. The filetype: operator searches for specific file types — filetype:php inurl:"login" finds PHP login pages. These operators can be combined in powerful ways. For example, site:*.com filetype:php inurl:"login" finds PHP login pages across all .com domains — useful when you are looking for programs to hunt on. intitle:"Dashboard [Jenkins]" finds exposed Jenkins dashboards. intitle:"Script Console [Jenkins]" finds Jenkins script consoles specifically — these are RCE-ready when unauthenticated. intitle:"Werkzeug" finds exposed Python Flask debug consoles, which are essentially fully unauthenticated RCE.

Custom dorks are where you can get really creative. The syllabus shows two examples that illustrate how to construct dorks for file exposure findings. The first is intext:"Index of" intext:"database.sql" — this searches for pages that have directory listing enabled AND contain a file called database.sql. If a server has both conditions, you might be looking at a publicly downloadable database backup. That would be an instant critical finding. The second is intext:"Index of" intext:"admin.tar.gz" — same logic but looking for a compressed admin directory archive. The pattern here is that you combine a directory listing indicator with a sensitive filename pattern. You can apply this to any file type you are hunting for: replace "admin.tar.gz" with "backup.zip" or "config.json" or "credentials.txt" or "id_rsa" and you will find different categories of sensitive exposures. The intitle:"Admin Login" dork is another powerful one — it finds admin panel login pages that are indexed by Google, which means they are publicly accessible and potentially testable for credential stuffing, default passwords, or authentication bypass. I would also recommend exploring the GitHub Tampermonkey scripts at github.com/rix4uni/Bug-Bounty-Tampermonkey-Scripts — these are browser scripts that enhance the Google search interface with bug bounty-specific features, making dorking sessions significantly more efficient.

Now let me introduce Shodan, which is arguably the most powerful tool in a bug bounty hunter's OSINT arsenal. Shodan is a search engine specifically for internet-connected devices and services. While Google indexes web pages and their content, Shodan indexes servers, their open ports, their SSL certificates, their HTTP response headers, their page titles, and their banner information. Shodan continuously scans the entire internet and stores detailed information about every accessible service it finds. For bug bounty hunters, Shodan is valuable for two main reasons. First, it can find servers that belong to your target company but that you might never discover through subdomain enumeration — servers on unusual ports, servers with no DNS records, or servers using IP addresses that are not associated with any domain name. Second, and perhaps most importantly, Shodan can reveal origin IP addresses that are hidden behind WAFs and CDNs. This concept is so important that it deserves a dedicated explanation.

When a company uses a WAF (Web Application Firewall) or CDN (Content Delivery Network) like Cloudflare, Akamai, or Fastly, the DNS record for their domain points to the WAF's IP address, not the actual server. The WAF sits in front of the real server, filters malicious requests, and passes legitimate traffic through. This means that if you are testing https://target.com, you are actually sending your requests to Cloudflare's servers, not to the company's real web server. The WAF will block many of your attack payloads before they even reach the application. However, the company's origin server still has a real IP address, and that origin server often has its own direct internet access — it doesn't just accept connections through the WAF. If you can find the origin IP, you can connect directly to the real server, bypassing the WAF entirely. Shodan is one of the best ways to find these origin IPs because it has indexed the server's SSL certificate, page content, and headers from when it was directly scanned, before the WAF was put in front of it, or through direct IP scanning that bypasses the WAF's filtering. Origin IP equals no WAF — this is one of the most valuable things Shodan can give you.

When you find an IP address in Shodan that you think might belong to your target, you need to verify it. There are five verification methods from the syllabus. The first is the website page — when you visit the IP address directly in your browser (using http://IP_ADDRESS), if the company's application loads, you have confirmed the origin IP. The second is checking the favicon — both the IP address and the official domain should serve the same favicon if they are the same server. You can compare favicon hashes to confirm. The third is SSL certificate inspection — the SSL certificate served on the IP address often contains the company's domain name in the Subject or Subject Alternative Names fields. If the certificate says dell.com, you have confirmed this IP belongs to Dell. The fourth is trademark — the HTML content of the page served from the IP often contains copyright notices, brand names, and trademark symbols that confirm the company's identity. The fifth is WHOIS — running a WHOIS lookup on the IP address will show which organization owns that IP range. If the WHOIS record shows Dell Inc. as the owner, you have confirmed it.

Now let me walk through the most important Shodan dork patterns you should know. The org: operator searches by company name as registered in WHOIS records — for example, org:"Dell Inc." returns all servers Shodan has indexed that belong to Dell's registered IP ranges. The ssl: operator searches SSL certificate contents — ssl:"dell.com" finds all servers whose SSL certificates mention dell.com, including servers that are not directly reachable via DNS. This is one of the best origin IP discovery techniques because companies often use their domain in their SSL certificates even on servers they haven't put behind a WAF yet. The hostname: operator searches by DNS hostname — hostname:"sqrx.com" finds servers whose reverse DNS records include that domain. Beyond these basic org/ssl/hostname queries, there are technology-specific dorks that reveal vulnerable or interesting services. ssl:"target.com" http.title:"Dashboard" finds servers belonging to target.com that are running some kind of dashboard — a very interesting combination. http.favicon.hash:"1163764264" finds all servers with that specific favicon hash, which can be used to find servers running the same application as a known vulnerable or interesting target. html:"There isn't a GitHub Pages site here." finds misconfigured GitHub Pages domains that might be susceptible to subdomain takeover.

Some of the most valuable Shodan dorks for finding vulnerable technologies are: port:"9200" for ElasticSearch instances (which are often unauthenticated and expose all indexed data publicly), product:"nginx" for Nginx servers, http.title:"kibana" for Kibana dashboards (often running without authentication on internal networks accidentally exposed to the internet), title:"Swagger UI" for Swagger API documentation pages (which reveal all API endpoints and sometimes allow direct API testing), title:"Grafana" for Grafana dashboards, and http.title:"GeoServer" for GeoServer instances. The http.favicon.hash:892542951 dork is associated with CVE-2022-24255 — when you know a vulnerability affects a specific product, you can search for that product's favicon hash to find all instances of it on the internet. You can also target by port and title combination — for example, port:"2080,2082,2083,2086" finds servers running cPanel's alternative ports, and ssl:"target.com" http.title:'index of/' finds servers belonging to your target that have directory listing enabled. For filtering out noise, you can exclude specific titles: ssl:comcast.com -http.title:'Invalid URL' removes results that match the exclusion pattern. After collecting Shodan IPs, the ipfinder tool at github.com/rix4uni/ipfinder helps you do further analysis and facet examination of the discovered IP addresses.

The third major platform in this topic is FOFA, available at fofa.info. FOFA is a Chinese-developed internet intelligence platform similar to Shodan but with its own independent dataset, its own scanning infrastructure, and some unique search capabilities. Because FOFA has crawled the internet independently, it often has servers that Shodan hasn't indexed, and vice versa. Using both Shodan and FOFA together gives you significantly better coverage than either one alone. The FOFA syntax is slightly different from Shodan. For title searches: title="GeoServer", title="Dashboard [Jenkins]", title="Script Console [Jenkins]", title="Werkzeug". For SSL/certificate searches: cert="dell.com" — this searches for servers whose SSL certificates contain that domain name, similar to Shodan's ssl: operator. FOFA also supports complex boolean queries: cert="paypal.com" || domain="paypal.com" || host="paypal.com" finds all servers related to paypal.com through any of three different matching criteria. You can add status code filtering: (cert="paypal.com" || domain="paypal.com" || host="paypal.com") && status_code="200" limits results to servers that are currently returning 200 OK. You can also add date range filtering: (cert="paypal.com" || domain="paypal.com" || host="paypal.com") && after="2019-01-01" && before="2026-10-05" which lets you find servers that were active within a specific time window. For mass FOFA scanning, the fofascan tool at github.com/rix4uni/fofascan lets you automate FOFA queries from the command line.

There is one final topic in this section of the syllabus that I must address: the course assignment. Each student in the KrazePlanet KPWAPT course must report at least 10 different bug types on any bug bounty program. I want you to understand why this requirement exists and why it is so valuable to your development as a hunter. When you report a bug, you are not just submitting a finding — you are practicing the entire communication and documentation process that makes bug bounty hunting a profession rather than just a hobby. You are learning how to write clear reproduction steps, how to assess severity, how to describe impact, and how to format your report in a way that the security team can understand and act on quickly. The first few reports you write will feel awkward and uncertain, but by the time you have written 10, you will have developed a consistent, professional reporting style that will serve you for your entire hunting career. Report writing is a skill that many technically excellent hunters have never developed — they find great vulnerabilities but write terrible reports, and sometimes those reports get rejected or rated lower than they deserve because the security team couldn't understand the impact. Don't be that hunter. The 10-bug requirement is your foundation for professional reporting.

To bring everything together — in Topic 09 we have covered Advanced Dorking and OSINT Recon, the techniques that let you find what companies have accidentally exposed to the public internet. We started with Google's five core operators — site:, inurl:, intitle:, intext:, filetype: — and learned how to combine them into powerful custom dorks for finding Jenkins consoles, Werkzeug debuggers, directory listings, exposed admin panels, and sensitive files. We covered Shodan in depth: what it is, why origin IP discovery is so critical (origin IP equals no WAF), how to verify that an IP belongs to your target using five methods (page, favicon, SSL, trademark, whois), and the most important dork patterns including org:, ssl:, hostname:, favicon hash, title, and port operators. We covered FOFA as an independent alternative dataset to Shodan with its own query syntax and boolean filtering capabilities. We also discussed the 10-bug assignment and why it is essential for developing professional reporting skills. The recommended OSINT workflow is: Google dorks for indexed pages → Shodan for infrastructure discovery and WAF bypass via origin IP → FOFA for additional coverage → ipfinder and fofascan for automation. This recon layer, combined with everything from Topics 01 through 08, gives you one of the most comprehensive reconnaissance frameworks in professional bug bounty hunting. I will see you in Topic 10!

Topic 10 — Creating an End-to-End Methodology

Welcome to Topic 10 — Creating an End-to-End Methodology. This topic is the most important one in the entire reconnaissance section of the course, because it is where everything we have learned in Topics 01 through 09 comes together into a single repeatable system. Having individual tools and techniques is valuable, but knowing how to chain them together in the right order, against the right targets, with the right priorities — that is what separates hunters who earn consistently from hunters who struggle. I have seen students who know every tool we have covered but still don't make money because they don't have a methodology — they just open random tools, run a few commands, and then don't know what to do next. I have also seen students who were less technically skilled but had a clear, systematic approach and were finding bounties within weeks of starting. The methodology is your competitive advantage. If you follow the system we will build in this topic, you will have a clear set of steps to follow on every single target, and you will never again sit in front of your terminal not knowing what to do next.

The first decision in your methodology is program selection — choosing which bug bounty program to hunt on. Not all programs are equal, and your choice of program will significantly affect your results. When you are selecting a program, there are several factors you should consider. First, look at the scope. Programs with large scope — "Any FIS asset is in scope" — give you the most attack surface and the most opportunity. As we covered in Topic 03, large scope means you can do Crunchbase research to find all acquired companies, run tldscan to enumerate all TLDs, and effectively test an enormous amount of infrastructure. These programs are ideal once you have your full methodology set up. Second, look at the bounty table. Programs that pay well for critical findings — $5,000 to $20,000+ for critical — are worth more of your time per finding than programs that pay $500 for a critical. Third, look at the program's response time and history. The KrazePlanet programs resource at programs.krazeplanet.com and the BountyWatch tool at github.com/rix4uni/BountyWatch help you monitor program changes and find new programs as they launch. New programs are particularly valuable because they often have vulnerabilities that nobody has reported yet — the first hunter in gets everything. Fourth, consider the technology stack. If you have just learned IIS short filename techniques, hunting programs that heavily use Windows Server infrastructure will give you a natural advantage.

Now let me walk you through the full methodology for a large-scope program, using "Any FIS asset is in scope" as the example from the syllabus. FIS is a large financial technology company, and their large-scope program means you can test anything they own. The first step, before you even open a terminal, is Crunchbase research. You should go to Crunchbase and search for FIS to find every company they have acquired. Each acquisition might mean additional domains and infrastructure that falls under "any FIS asset." You should build a list of all parent and subsidiary company names. Second, run tldscan against the main FIS domain to discover all TLD variations they own. Add all discovered domains to your master scope list. Third — subdomain enumeration. Run your full passive + active enumeration workflow from Topic 03: subdog, subfinder, amass all piped through unew into subs.txt. Then run alterx for permutations, favinfo for favicon hashing, and certinfo for SSL certificate analysis. Apply oosexclude to remove any explicitly out-of-scope domains. Fourth — port scanning. Run cat subs.txt | naabu -duc -silent to produce naabu.txt. This step is mandatory for large scope programs because you absolutely cannot afford to miss applications running on non-standard ports across potentially thousands of subdomains. Fifth — HTTP probing. Run cat naabu.txt | httpx -duc -silent -nc -sc -title -cl -ct | sort -t'[' -k3,3nr | unew -el -i httpx.txt to produce your httpx.txt. At this point you have a comprehensive map of every live web service across the entire FIS empire.

Continuing the large-scope workflow — step six is URL crawling. Run waymore with the root domains you discovered (not the subs.txt) to get historical URLs: echo "fisglobal.com" | waymore -mode U -lr 3 -lcc 3 -f --stream | unew urls.txt. Then run katana across your httpx.txt for active crawling: cat httpx.txt | katana -duc -silent -nc -jc -concurrency 10 -parallelism 10 -depth 7 -timeout 30 -aff | unew urls.txt. Follow up with urlflux on the growing urls.txt. Run urldedupe and urlfilter to produce finalurls.txt. Apply gf patterns to segment into xss-candidates.txt, sqli-candidates.txt, and other vulnerability-specific queues. Step seven is directory fuzzing. Run ffufscan with all.txt against each live URL in httpx.txt, paying attention to 403 and redirect responses as well as 200. Run x8scan on your PHP/ASP/JSP pages for hidden parameter discovery. Step eight is technology-based CVE hunting. Run techfinder on httpx.txt to identify all technologies, then run the nuclei command: cat httpx.txt | sort -t'[' -k3,3nr | grep "\[200\]" | awk '{print $1}' | nuclei -duc -silent -severity critical,high,medium -tags $nucleitags with appropriate tags for the technologies you have found. Step nine is IIS reconnaissance — filter your httpx.txt for IIS servers using techfinder and run shortscan on them. Step ten is OSINT and dorking — run Shodan and FOFA queries using the company name, SSL certificates, and favicon hashes to find any servers you might have missed through direct enumeration, especially any origin IPs hiding behind WAFs.

The last component in the large-scope methodology is JavaScript analysis, which appears in the syllabus as a distinct step in every scope type. We touched on this briefly in Topic 07, but let me explain it more fully here. Modern web applications often load dozens of JavaScript files, and those files frequently contain sensitive information that developers accidentally embedded. The categories of sensitive data you should look for in JS files include: hardcoded API keys and tokens (AWS, Stripe, Twilio, SendGrid, Google Maps, and many others), internal API endpoint URLs that are not exposed in any other way, S3 bucket names that might be misconfigured for public access, GraphQL schema endpoints, internal service URLs and IP addresses, and sometimes even username and password strings that developers left in during testing. When you are doing JavaScript analysis, you first need to collect all the JS file URLs from your urls.txt — filter with grep "\.js$". Then download each one and run secret-scanning tools over them. The combination of automated secret scanning plus manual review of the most interesting files can be extremely productive. I have seen hunters find valid AWS access keys in production JavaScript files that were giving full S3 bucket access — a critical finding worth thousands of dollars found in minutes.

Now let me explain the methodology for a medium-scope program, using *.fisglobal.com as the example. The key difference from large scope is that you no longer need to do Crunchbase research or tldscan — your target is explicitly defined as any subdomain of fisglobal.com. The methodology starts directly at subdomain enumeration: run subdog, subfinder, and amass against fisglobal.com and pipe results through unew. Run the active enumeration tools — ffuf for DNS brute-forcing, alterx for permutations. Apply oosexclude if the program has specific subdomain exclusions. Then the workflow is identical to large scope from that point forward: naabu → httpx → waymore → katana + urlflux → urldedupe + gf → ffufscan + x8scan → nuclei → shortscan → Shodan/FOFA → JS analysis. The only difference is scope boundary — you must stay within *.fisglobal.com at every step. When waymore finds historical URLs, you should filter them to ensure they all belong to fisglobal.com subdomains before adding them to your testing queue. When techfinder or Shodan finds IP addresses, verify they belong to fisglobal.com infrastructure specifically. Medium-scope programs are actually excellent targets for hunters who are building their methodology because the scope is well-defined — you know exactly what you can and cannot test — but the attack surface can still be enormous. A large company might have hundreds of subdomains under a single wildcard scope.

The methodology for a small-scope program, like admin.fisglobal.com, is the most straightforward but still follows the same logical structure. Because you cannot go wider than that one domain, you skip the subdomain enumeration phase entirely. Your methodology starts at port scanning: echo "admin.fisglobal.com" | naabu -duc -silent. Then httpx: echo "admin.fisglobal.com" | httpx -duc -silent -nc -sc -title -cl -ct. Then URL crawling: waymore against admin.fisglobal.com and katana against the httpx output. Then fuzzing: ffufscan and x8scan. Then nuclei with appropriate tags. Then Shodan and FOFA for infrastructure discovery. Then JavaScript analysis. Notice that even with a single-domain scope, the full methodology still applies — you might discover that admin.fisglobal.com is running on a non-standard port that you would have missed without naabu, or that it has a hidden directory full of sensitive files you would have missed without ffufscan, or that its JavaScript contains a hardcoded API key you would have missed without JS analysis. Even a single domain has depth — your methodology is how you explore that depth systematically rather than randomly.

One of the most important skills you will develop as you apply this methodology is triage and prioritization. When you are working a large-scope program, your tools will produce enormous amounts of data — thousands of subdomains, tens of thousands of URLs, hundreds of potential findings from nuclei and x8scan. You cannot manually investigate everything, so you need to be smart about what you investigate first. The general prioritization rule is severity first, effort second. Any critical nuclei finding should be your first priority — verify it immediately and write the report while it is fresh. High-value httpx titles like "Dashboard [Jenkins]", "Script Console", "Kibana", and "Index of /" should be your second priority. Interesting fuzzing results (especially 403 responses on paths like /admin/, /backup/, /config/) should be your third priority. Parameter-based testing of your gf-segmented URL lists should follow. The key insight is that you should always be moving toward the most likely high-value findings rather than grinding through everything in order. A hunter who follows this prioritization approach will find and report critical vulnerabilities much faster than one who methodically works through every low-value item first.

Time management is another critical component of a professional methodology. When you start a new hunting session, you should set a rough time allocation for each phase. As a guideline, reconnaissance phases — subdomain enumeration, port scanning, httpx — can often run as background tasks while you are doing other things, since they are mostly automated. URL crawling and fuzzing similarly can run in the background. The phases that require your active attention are triage (reviewing httpx.txt for interesting targets), manual investigation of flagged findings, JavaScript analysis, and report writing. I would recommend setting up your automation to run overnight or while you are doing other work, then reviewing the results in a focused session. Many hunters have their entire reconnaissance pipeline scripted so that they can start it with a single command and come back a few hours later to triage. This is the ideal state — your tools are working while you are sleeping, and you are spending your focused time on the high-value judgment work that only a human can do.

To bring everything together — Topic 10 is your complete reference for end-to-end methodology. The KrazePlanet approach has three tracks based on scope type. For large scope: Crunchbase → tldscan → subdog + subfinder + amass + alterx + favinfo + certinfo + oosexclude → naabu → httpx → waymore + katana + urlflux → urldedupe + gf → ffufscan + x8scan → nuclei → shortscan → Shodan + FOFA → JS analysis. For medium scope: subdog + subfinder + amass + active enumeration + oosexclude → naabu → httpx → waymore + katana + urlflux → urldedupe + gf → ffufscan + x8scan → nuclei → shortscan → Shodan + FOFA → JS analysis. For small scope: naabu → httpx → waymore + katana + urlflux → urldedupe + gf → ffufscan + x8scan → nuclei → shortscan → Shodan + FOFA → JS analysis. The only thing that changes between scope types is how the top of the funnel is defined — large scope starts with business intelligence research, medium scope starts with subdomain enumeration, and small scope starts directly with port scanning. Everything downstream is identical. This uniformity is the power of having a methodology — once you have internalized this sequence, you will never feel lost on any new target. You will always know what step you are on and what step comes next. This is how professional hunters operate, and this is how you will operate from now on. I will see you in Topic 11!

Topic 11 — Authentication Bypass

Welcome to Topic 11 — Authentication Bypass. We are now entering the vulnerability-specific portion of the course, where every topic focuses on a distinct class of security weakness. Authentication bypass is one of the most exciting topics in bug bounty hunting because it deals with the fundamental question of identity — the question of who is allowed to access what. Authentication is the process of verifying that you are who you claim to be. When an application asks for your username and password, that is authentication. When it sends an OTP to your phone and asks you to enter it, that is two-factor authentication. When it checks whether your session token is valid before showing you the dashboard, that is authentication. An authentication bypass vulnerability means that an attacker can defeat one of these mechanisms and gain access to an account, a feature, or a dashboard without providing the correct credentials. These vulnerabilities can be critical — an authentication bypass on a login page means anyone can access any account on the platform without knowing the password. The technique we will focus on most heavily in this topic is response manipulation, which is one of the most elegant and surprisingly effective authentication bypass techniques, and yet it is one that many developers have never even considered as a vulnerability class.

To understand response manipulation, you first need to understand how many modern web applications handle authentication on the client side. In older web applications, the server would always make all authorization decisions — if you weren't authenticated, the server simply would not return the protected page. Modern single-page applications and mobile applications have changed this model. In many modern apps, the flow looks like this: the client (your browser) sends credentials to the server, the server responds with a JSON object containing a status field like "status": true or "code": "valid", and then the client-side JavaScript reads that JSON response and decides what to show next — if the status is true, redirect to the dashboard; if it is false, show an error message. The critical vulnerability is that this decision-making logic lives in the client's browser, not on the server. If you can intercept the server's response using Burp Suite and change the status field from false to true before the JavaScript reads it, the client-side code will think authentication was successful and will redirect you to the dashboard. The server never explicitly confirmed you were authenticated — it said "no" but you changed its answer to "yes" before the client could read it. This is response manipulation, and it works far more often than you might expect.

Now let me walk through the most common response patterns you should look for and how to manipulate each one. The first category is boolean fields. When you see a JSON response with "authenticated": false, change it to "authenticated": true. When you see "verify": false, change it to "verify": true. When you see "email_verified": false, change it to "email_verified": true. The pattern is always the same — any boolean false value that represents a failed authentication check should be flipped to true. The same applies to "is_admin": false → "is_admin": true, "logged_in": false → "logged_in": true, "success": false → "success": true, "allowed": false → "allowed": true, "verified": 0 → "verified": 1, "isVerified": false → "isVerified": true, and "login": "failed" → "login": "success". The second category is status code fields embedded in the JSON body — not the HTTP status code header, but a status code value inside the JSON response itself. "status": 401 → "status": 200, "status": 400 → "status": 200, "code": 404 → "code": 200. The third category is string status values: "code": "invalid" → "code": "valid", "status": "0" → "status": "1", ":INVALID" → ":VERIFIED", "response": "invalid code" → "response": "success", "error": "Invalid code" → "success": "valid code".

There are even more manipulation patterns you should know. When a response contains a message indicating a specific failure, you can try replacing the entire message string: "message": "Please enter the valid OTP" → "message": "valid OTP". The key insight is that the client-side JavaScript often checks the message string directly — if the message contains "valid" or "success" or some positive keyword, the app treats it as a successful operation. You can also manipulate more complex nested structures. Consider a response like {"status": "0"} — you would change it to {"status": "1", "user_type": "admin"}, adding an entirely new field that might trigger admin access in the client-side code. Or {"admin": false, "admin_id": 0} → {"admin": true, "admin_id": 1}. The pattern of role manipulation is also worth knowing: "role": "user" → "role": "admin", "user_role": "guest" → "user_role": "admin", "permission": "read" → "permission": "all", "access": "denied" → "access": "granted", "account_status": "inactive" → "account_status": "active", "two_factor": true → "two_factor": false, and "otp_required": true → "otp_required": false. The last two are particularly interesting because they can disable two-factor authentication requirements by telling the client that 2FA is not needed.

Now let me explain the OTP bypass scenario, which is one of the most common and reproducible applications of response manipulation. Many applications use a multi-step authentication flow where you first enter your username and password (Step 1), then receive an OTP via SMS or email and enter it (Step 2), and then arrive at the dashboard (Step 3). The vulnerability exists when the OTP verification step relies on client-side response manipulation rather than a server-side session check. Here is how the attack works. You enter the correct username and password in Step 1, and the application sends an OTP to your phone. In Step 2, you type any random 6-digit number that you know is wrong — something like 000000 or 123456. You have Burp Suite's proxy running and intercepting responses. When you submit the wrong OTP, the server responds with something like {"status": false, "message": "Invalid OTP"}. Before this response reaches your browser, Burp Suite intercepts it. You change "status": false to "status": true and "message": "Invalid OTP" to "message": "valid OTP". You forward the modified response. The client-side JavaScript reads the modified response, sees that status is true, and redirects you to the dashboard. You are now logged in without ever knowing the correct OTP. This three-step flow — Login → Manipulate OTP response → Dashboard — has been reported and accepted on dozens of bug bounty programs.

The technique for intercepting and modifying responses in Burp Suite is important to understand clearly. Normally, Burp Suite's proxy intercepts requests (what your browser sends to the server), not responses (what the server sends back to your browser). To intercept responses, you need to enable response interception in Burp Suite. Go to Proxy → Options → Intercept Server Responses and enable "Intercept responses based on the following rules." You can set it to intercept responses to specific URLs, or simply intercept all responses during your testing session. Once response interception is enabled, when you submit the wrong OTP, Burp will catch the server's response before it reaches your browser, and you can edit the response body directly. After editing, click Forward to send the modified response to the browser. Another approach that is sometimes more convenient is using Burp Suite's Match and Replace feature, which we covered in Topic 01. You can set up an automatic rule that replaces "status":false with "status":true in every response — this means you do not need to manually intercept each response, Burp will make the modification automatically on every matching response. This is more efficient when you are testing multiple authentication flows on the same application.

Let me also explain where to look for authentication bypass vulnerabilities beyond the OTP flow. The registration flow is another prime target. When you register a new account, the application often sends a verification email and requires you to verify your email before you can use all features. If the email verification check happens client-side, you might be able to bypass it by manipulating "email_verified": false → "email_verified": true. The password reset flow is another target — if you enter the wrong reset token or OTP, the response might say "status": "failed" and you can try changing it to "status": "success". The login flow itself is worth testing even before the OTP step — if you enter an incorrect password, the response might say "authenticated": false and you can try flipping it. Social login flows — the "Login with Google" or "Login with Facebook" buttons — sometimes have their own response manipulation vulnerabilities where the callback response can be manipulated. Admin panel access is worth testing too — if you have a regular user account and the application checks "role": "user" in a response, changing it to "role": "admin" might give you admin-level access. Everywhere the application makes a decision based on a value in a JSON response, that value is potentially manipulatable.

Now let me explain how to systematically test for response manipulation vulnerabilities. When you are testing any authentication or verification flow, your process should be: First, turn on Burp Suite and set your browser to proxy through it. Second, go through the normal authentication flow carefully and observe every response in Burp Suite's HTTP history. You are looking for JSON responses that contain status fields, boolean values, or string values that seem to indicate success or failure. Third, for each promising response, repeat the request with an incorrect credential (wrong OTP, wrong password) and check if the failure response contains any of the patterns we covered. Fourth, if you find a promising pattern, enable response interception and try the manipulation. Fifth, verify the bypass by confirming you have access to content that you shouldn't — if you manipulated an OTP response and arrived at the dashboard, check that you can actually access account features, not just that you were redirected to the dashboard URL. This last verification step is important because sometimes the dashboard URL loads but then checks authentication server-side and either shows nothing or redirects you back to login. If that happens, the vulnerability probably doesn't exist — the client-side manipulation only affected the redirect, not the actual session state. But if you can access real account data, the bypass is confirmed and reportable.

The impact assessment for authentication bypass findings is worth discussing because it directly affects how you will rate and report the vulnerability. An OTP bypass where you can access any user's account without knowing their OTP is typically a critical or high severity finding because it completely undermines two-factor authentication — a security feature users specifically rely on to protect their accounts even if their password has been compromised. A bypass that only allows you to skip email verification for your own newly registered account is typically lower severity — perhaps medium or low — because the impact is limited to your own account. An admin panel access bypass that gives you admin functionality through response manipulation would be critical because of the elevated privilege level. When you are writing your report, you should clearly explain what the vulnerability is (response manipulation), where it occurs (the specific endpoint and flow), how to reproduce it step by step (with exact request and response shown), and what the impact is (what an attacker can do with the bypass). The HackerOne reports linked in the syllabus — including reports 1490470, 1406471, 1709881, 2337427, 418767, and others — are excellent references for how experienced hunters have written these reports. I would strongly recommend reading several of them to understand how impact is articulated and how reproduction steps are written for authentication bypass findings.

To summarize everything we have covered in Topic 11 — Authentication Bypass through response manipulation is a vulnerability class that exists because modern web applications often make security decisions in client-side JavaScript based on server response values, rather than enforcing all authentication checks server-side. The attack technique is to intercept the server's response in Burp Suite before the browser reads it, and to modify the JSON values so that the application believes authentication was successful even when it wasn't. The most common patterns to manipulate include boolean fields (false → true), HTTP-like status codes in JSON bodies (401/400/404 → 200), string status values ("invalid" → "valid"), role values ("user" → "admin"), and 2FA flags (true → false). The most impactful scenario is OTP bypass: enter any random OTP, intercept the failure response, change the status to success, and gain access to the account without ever knowing the real OTP. The testing workflow is to proxy all traffic through Burp Suite, observe authentication flows, identify response patterns, and test manipulations against incorrect credentials. The platforms to practice on include the live hunting session target at taskbear.com.au. For every finding you discover using this technique, verify that you can actually access real account content — not just be redirected — before reporting. I will see you in Topic 12!

Topic 12 — Business Logic Errors

Welcome to Topic 12 — Business Logic Errors. This topic is one of the most intellectually fascinating in the entire course because business logic errors are fundamentally different from every other vulnerability class we have covered so far. With SQL injection, XSS, or CVE-based vulnerabilities, there is always a technical flaw — a piece of code that handles input unsafely, a library with a known bug, a misconfigured server. Business logic errors are different. They occur when the application's code works exactly as the developer intended, but the developer's intention itself was flawed. The code does what it was designed to do — the problem is that what it was designed to do creates unintended consequences when users interact with the system in ways the developer didn't anticipate. This is why business logic errors are so hard to find with automated tools — no scanner can tell you that a coupon should only be used once if the developer never enforced that rule. Only a human tester who understands how the business is supposed to work can recognize when the technical implementation has created a logical gap that can be exploited. This is your competitive advantage in this topic — your understanding of how businesses and their financial systems work is your testing tool, not any piece of software.

The first and most common category of business logic errors is coupon abuse. Almost every e-commerce platform has discount coupons, and almost every implementation has at least one logic flaw if you know how to look. The most basic coupon vulnerability is that a coupon that should only be usable once can be used multiple times. This happens when the application checks whether the coupon has been used at the beginning of the checkout process but doesn't mark it as used until the end, or when the used-status check happens in the client-side JavaScript that you can bypass. To test for this, you first apply a coupon code during checkout in Burp Suite, then capture the HTTP request. After the first successful use, you try to replay the same coupon application request — if it succeeds again, the coupon can be used multiple times. Another coupon vulnerability involves negative discount values. When a coupon applies a fixed amount discount — say, $10 off — you can try intercepting the request and changing the discount value to a negative number, like -$10, to see if the application adds $10 to the final price (which is not exploitable) or if you can set the discount to an amount larger than the product price, potentially making the order cost zero or negative. You should also test whether a coupon can be applied to items that are explicitly excluded — if the coupon says "not valid on sale items" but you can apply it to sale items by manipulating the cart state in Burp Suite, that is a business logic flaw.

Wallet manipulation is the second major category. Many platforms — food delivery apps, ride-sharing services, gaming platforms, digital marketplaces — have a virtual wallet or credit system where users can store balance and use it to make purchases. These wallets can be vulnerable to several logic flaws. The most impactful is negative balance exploitation. If you have $10 in your wallet and you purchase something for $15, the application should reject the transaction because your balance is insufficient. But what if you can manipulate the purchase amount in the request? If you can change "amount": 15 to "amount": -15 in the payment request, some systems will add $15 to your wallet instead of subtracting it. Another common wallet flaw involves concurrent transactions — if you initiate two purchases simultaneously using Burp Suite's race condition feature (sending both requests at the exact same millisecond), the application might process both before it has had a chance to deduct the balance from the first one. This is sometimes called a race condition in wallet systems, though it falls under business logic when the root cause is that the application doesn't use proper database locking. Wallet-to-wallet transfer manipulation is another variant — if you can transfer money to your own wallet from your own wallet, or transfer a negative amount, these flaws can be used to generate unlimited credits.

Loyalty point abuse represents the third category. Loyalty programs — frequent flyer miles, cashback points, reward credits — are a staple of consumer platforms, and they contain their own set of logic vulnerabilities. The fundamental flaw in many loyalty systems is that points are awarded based on a transaction value that the user can influence. If you earn 1 point per dollar spent and the application calculates your points based on the original price before a discount is applied, you might be able to manipulate the discount to get a large purchase for free while still earning points as if you paid full price. Another variant: if a platform awards points for completing certain actions — reviewing a product, logging in daily, referring a friend — and those actions can be triggered repeatedly, you might be able to generate unlimited points by automating those actions. I have seen hunters find vulnerabilities where they could earn an unlimited number of points by repeatedly triggering a "first purchase bonus" that was supposed to trigger only once per account but was never properly rate-limited. Points with real monetary value — cashback that can be redeemed for cash, miles that can be redeemed for flights — make these findings much more impactful from a business perspective and therefore more likely to receive a substantial bounty.

Referral abuse is closely related to loyalty abuse and is one of the most widely exploited business logic flaws in consumer-facing platforms. Almost every modern platform has a referral program — "invite your friends and both of you get $10 credit." These programs are designed to drive organic growth, but they can be abused when the application doesn't properly validate who qualifies as a unique new user. The simplest attack is self-referral — creating multiple accounts with different email addresses and using your own referral code on each new account. If the platform only checks that the email address is new and doesn't check device fingerprints, IP addresses, or payment methods for uniqueness, you can generate unlimited referral credits. A more sophisticated attack involves finding the moment when referral credit is awarded and testing whether it can be triggered multiple times. If the referral credit is awarded when the referred user makes their first purchase, and that "first purchase" event can be triggered multiple times by manipulating the order state in Burp Suite, you might earn referral credit repeatedly from a single referred account. When you are testing referral systems, always map out the complete flow — when referral credit is awarded, what conditions must be met, and whether any of those conditions can be manipulated or bypassed.

Inventory manipulation is a category of business logic errors specific to e-commerce and marketplace platforms. These vulnerabilities involve manipulating quantities, prices, or stock states in ways the developer didn't intend. The most common example is negative quantity ordering — if you add a product to your cart and then manipulate the quantity from 1 to -1 in the request, some systems will calculate the total as a negative price and either award you money back or allow you to place an order that generates a refund without an original purchase. Zero-price manipulation is another variant — by intercepting the add-to-cart or checkout request and changing the item price from its real value to 0, some systems will accept the modified price and process the order for free. This happens when price validation only occurs on the frontend (in JavaScript) rather than being re-validated server-side during checkout. Free item manipulation through stock errors is another pattern — if an item shows as "out of stock" but you can force it into a cart by directly crafting an add-to-cart request, some platforms will still allow the checkout to proceed, potentially giving you a free or discounted item that wasn't supposed to be available. When testing any e-commerce platform, you should treat every numeric value — price, quantity, discount amount, shipping cost — as a potential manipulation target.

Banking logic flaws are the most severe category of business logic errors because they can involve real money. These occur in financial platforms, payment processors, lending applications, and anything else that handles monetary transactions programmatically. Transaction amount manipulation is the most critical — if you can change the amount in a payment request from $100 to $0.01, and the server doesn't re-verify the amount against the original order before processing, you might be able to pay $0.01 for a $100 item. Rounding errors are another class of banking logic flaw — financial systems that round fractions of cents in predictable ways can sometimes be exploited by making many small transactions that each take advantage of a rounding direction. Currency conversion manipulation can occur when a platform supports multiple currencies and the conversion rate is calculated client-side — by manipulating the currency parameter, you might be able to pay in a weaker currency while the system records the transaction in a stronger one. It is important to note that when you are testing banking logic flaws on real financial platforms, you should always use test environments, test accounts with minimal real funds, and you should stop as soon as you have confirmed the vulnerability concept — you should not exploit the vulnerability to actually transfer real money or cause real financial harm. The goal is to demonstrate the vulnerability exists and report it, not to profit from it.

Now let me explain the mindset and methodology for finding business logic errors. The key difference from other vulnerability testing is that you need to deeply understand how the application is supposed to work before you can find where it doesn't work correctly. I would recommend spending time as a regular user of the application before you start testing — create an account, make a purchase, use the coupon system, earn some loyalty points, make a referral. Understand the intended user journey. Then, with that understanding, start asking "what happens if I do this in a different order?" or "what happens if I do this twice?" or "what happens if I provide a negative value here?" The golden question for business logic testing is always: "what was the developer assuming would never happen, and what happens if I make that assumption false?" Every time a developer creates a rule — "this coupon can only be used once," "you can't order more than the available stock," "you can't pay less than the item price" — there is a potential vulnerability if that rule is not properly enforced at every point in the system where it should be checked.

When you have found a business logic error, writing a clear and compelling report is especially important. Business logic vulnerabilities are sometimes harder for security teams to triage because they require understanding the business context. Your report should clearly explain what the intended behavior is (a coupon should only be usable once), what the actual behavior is (the coupon can be applied unlimited times), and what the financial or business impact is (an attacker could receive unlimited discounts, costing the company money on every order). Whenever possible, include a concrete financial impact estimate. If a coupon gives $10 off and can be applied to any purchase, say "an attacker could purchase $10 items for free in unlimited quantities, with each transaction costing the company $10." This concreteness makes the severity immediately clear to the security team and increases the likelihood of a good bounty rating. The HackerOne reports in the syllabus — including reports 3591764, 672487, 1675674, 63729, 364843, 2450215, and many more — cover all these categories. I would strongly recommend reading at least five or six of them before you start testing to understand what well-written business logic vulnerability reports look like and what kinds of impact have been accepted on major programs.

To bring everything together — in Topic 12 we have covered Business Logic Errors, the class of vulnerabilities that exist not because code is broken but because the design allows unintended behavior. We covered coupon abuse (single-use coupons used multiple times, negative discount values, applying coupons to excluded items), wallet manipulation (negative amounts, race conditions, self-transfers), loyalty point abuse (earning points without paying full price, unlimited point generation), referral abuse (self-referral with multiple accounts, triggering referral rewards repeatedly), inventory manipulation (negative quantities, zero-price ordering, out-of-stock bypasses), and banking logic flaws (transaction amount manipulation, rounding exploitation, currency conversion abuse). The methodology for finding these vulnerabilities is to deeply understand the intended user flows first, then systematically ask what happens when assumptions are violated — wrong order, repeated actions, manipulated numeric values. No automated tool can replace your understanding of how a business is supposed to work. The hunters who consistently find business logic errors are the ones who think like both a user and an attacker simultaneously — they use the application genuinely, and while they do, they notice every assumption the system is making. I will see you in Topic 13!

Topic 13 — Improper Access Control

Welcome to Topic 13 — Improper Access Control. The syllabus gives us the clearest possible definition of this vulnerability, and I want to read it to you exactly as written because it is that precise: improper access control is a security flaw that happens when an app or website successfully verifies who you are (Authentication), but completely fails to check what you are allowed to do (Authorization). Read that again slowly, because the distinction between Authentication and Authorization is the entire foundation of this topic. Authentication answers the question "who are you?" — it verifies your identity through passwords, OTPs, biometrics, or tokens. Authorization answers the question "what are you allowed to do?" — it checks whether you have permission to access a specific resource or perform a specific action. These two things are completely separate concerns, and many developers correctly implement one while completely forgetting the other. An application might have perfect authentication — an unbreakable login system — but then, once you are logged in, it never checks whether the resource you are requesting actually belongs to you. That failure is improper access control, and it is one of the most prevalent vulnerability classes in modern web applications. It consistently appears in OWASP's Top 10 list of the most critical web application security risks, and finding it has earned hunters thousands of dollars on programs across every industry.

To understand improper access control concretely, let me give you a simple example. Imagine you are logged into an e-commerce platform as a user with account ID 1001. When you visit your orders page, the URL looks like https://shop.com/orders?user_id=1001. The server has verified that you are logged in — authentication passed. But when it serves the orders for user_id=1001, it doesn't check whether user_id=1001 actually matches the currently logged-in session. So if you change the URL to https://shop.com/orders?user_id=1002, the server might happily return user 1002's order history without any complaint. You are authenticated as user 1001, but you can access user 1002's data. This is improper access control — the application knew who you were but never checked whether you were authorized to see that specific data. This type of vulnerability — where you can access another user's data at the same privilege level by changing a user identifier — is called horizontal privilege escalation. The word "horizontal" means you are moving sideways across the same privilege level, from your account to another user's account of equivalent privilege. It is one of the most common and impactful access control vulnerabilities because it effectively gives an attacker access to every user's data on the platform.

The second type of access control vulnerability is vertical privilege escalation, where you move upward in privilege level — from a regular user to an admin, or from a read-only user to a user with write permissions. This happens when the application has admin-only endpoints or actions that don't properly verify the caller's privilege level. For example, imagine there is an admin API endpoint at https://app.com/api/admin/users that returns a list of all users on the platform. This endpoint should only be accessible to administrators. But if the developer only hid the link to this endpoint from regular users without actually checking on the server side whether the requesting user has admin privileges, any authenticated user who discovers the URL can access it. This is vertical privilege escalation — a regular user can perform an admin action. The same vulnerability can appear in features like "delete any user," "modify any user's email or password," "export all customer data," "access billing information for all accounts," or "execute server commands." Any functionality that was designed for elevated users but lacks proper server-side authorization checks is vulnerable to vertical privilege escalation. When you are hunting, you should always keep an eye out for admin-related URL paths, parameter names like admin=1 or role=admin, and any functionality in your httpx.txt or URL list that seems like it should require elevated access.

Now let me explain the most practical and systematic way to test for improper access control: the two-account method. This technique requires you to create two separate accounts on the target application — let us call them Account A and Account B. These accounts should be at the same privilege level unless you are specifically testing vertical escalation, in which case one should be a regular user and one should be an admin. With both accounts ready, you open two browser sessions — ideally one in a normal window and one in an incognito window — each logged into a different account. Using Burp Suite, you map all the actions and requests that Account A can perform, paying special attention to any request that contains an identifier — a user ID, an order ID, a document ID, a message ID — that belongs to Account A. For each such request, you then take the same request but change the identifier to one that belongs to Account B. The critical question is: does the server return Account B's data? If it does, you have found horizontal access control vulnerability. This method is systematic and reliable. I would recommend using Burp Suite's "Match and Replace" or the "Authorize" extension to automate this process — the Authorize extension automatically retries all requests from Account A's session using Account B's cookie, flagging any responses that return data the lower-privileged account shouldn't be able to see.

There are many specific places in a web application where access control vulnerabilities commonly exist, and you should prioritize testing each of them. User profile endpoints are one of the most common — requests like GET /api/users/1001/profile or PUT /api/users/1001/email often fail to verify that the requesting user is actually user 1001. Order and transaction history endpoints are another rich target — GET /api/orders/ORDER_ID might return anyone's order if the ORDER_ID is guessable or sequential. File and document download endpoints are very high value — GET /api/documents/DOC_ID/download might allow any authenticated user to download any document, exposing sensitive files, contracts, or personal data. Messaging and inbox endpoints — GET /api/messages/CONVERSATION_ID — might expose private conversations between other users. Admin API endpoints that don't check the caller's role are the highest severity — anything under /api/admin/, /internal/, or /management/ paths should be tested thoroughly. Payment and billing endpoints can be critical — if you can view or modify another user's payment methods or subscription details, the impact is significant. When you are working through your URL list from Topic 07 and your fuzzing results from Topic 08, you should specifically flag any URL containing what looks like a user-specific identifier — numeric IDs, UUIDs, hashes — as a priority access control testing target.

JWT (JSON Web Token) manipulation is a specialized form of access control testing that deserves its own explanation. Many modern applications use JWTs as their session tokens. A JWT is a base64-encoded token with three parts: a header, a payload, and a signature. The payload contains claims about the user — things like {"user_id": 1001, "role": "user"}. The signature is generated by the server using a secret key and is meant to prevent tampering. However, some JWT implementations are vulnerable to access control issues in several ways. First, the "none" algorithm attack: if the application accepts JWTs with "alg": "none" in the header, you can forge any JWT without a valid signature. You would change the payload to {"user_id": 1002, "role": "admin"}, set the algorithm to "none," and send the token without a signature. Second, algorithm confusion attacks: if the application uses an asymmetric algorithm like RS256 and you can get the public key, you might be able to sign tokens using the public key with HS256, tricking the server into accepting your forged tokens. Third, weak secret keys: if the JWT is signed with a weak or guessable secret like "secret" or "password," you can brute-force the secret and then forge arbitrary tokens. Burp Suite's JWT editor extension makes all of these attacks straightforward to test, and you should add JWT analysis to your testing whenever you see a token that looks like a JWT (three base64 segments separated by dots) in cookies, headers, or response bodies.

API authorization testing is another critical dimension of access control that has become increasingly important as more applications move to API-first architectures. Modern applications often have a rich API that powers both the web frontend and mobile apps, and APIs tend to have weaker access controls than traditional web interfaces because they were originally designed for internal use. When you are testing an API, there are several specific access control checks you should perform. First, test HTTP method variations — if GET /api/users/1001 returns a user's profile, try DELETE /api/users/1001 or PUT /api/users/1001 with a modified body. Sometimes only the read method has proper access controls while the write methods do not. Second, test with no authentication at all — remove your session cookie or Authorization header entirely and retry the request. Many APIs are misconfigured to allow unauthenticated access to what should be authenticated endpoints. Third, test with a low-privilege token for high-privilege endpoints — log in as a regular user and try to access endpoints that should require admin access. Fourth, check for mass assignment vulnerabilities — if you can send a PUT or PATCH request with additional fields in the JSON body beyond what the application normally accepts (fields like "role": "admin" or "is_admin": true), some APIs will blindly update all provided fields including ones that should be protected.

When you are testing for access control vulnerabilities on any application, there are some practical patterns that make discovery faster. Sequential numeric IDs in URLs are one of the clearest signals — if you see /invoice/10045 in your URL list, the fact that it uses sequential numbering means you can try 10046, 10044, and other nearby numbers to access other users' invoices. UUIDs (long random strings like 550e8400-e29b-41d4-a716-446655440000) are sometimes considered "secure by obscurity" — they are hard to guess, so developers assume they are safe. But obscurity is not security. If you can get the UUID for another user's resource through any other means — another vulnerability, an error message, or through the application's normal flow — then the fact that the UUID was hard to guess provides no protection. Parameter pollution is another technique — sometimes adding a duplicate parameter tricks the server into using one value for authentication and another for authorization. For example, if the server takes the user_id from the URL for display purposes but uses the user_id from the session for authorization, adding a duplicate user_id parameter might make the authorization check use your legitimate ID while the display logic uses another user's ID. The Burp Suite Repeater tab is your primary tool for all of this testing — capture a request, modify the identifier or parameter, and replay it to see what the server returns.

The impact of improper access control vulnerabilities varies enormously based on what data or actions are accessible. A vulnerability that lets you read another user's public profile might be low severity or even informational. A vulnerability that lets you read another user's private messages, financial data, or personal identification information would typically be high severity. A vulnerability that lets you modify or delete another user's data, or that gives you admin-level access to the platform, would typically be critical. When you are assessing the severity of an access control finding, always ask: what data can be read or what actions can be performed, and how many users are affected? A vulnerability affecting all users on a large platform (potentially millions of people) is more impactful than one affecting only a small subset. A vulnerability that exposes financial data or personal health information carries additional regulatory and compliance weight. The HackerOne reports in the syllabus — 837256, 1587246, 223434, 921717, 1084638, 2516250, and many more — cover access control findings across a wide range of contexts and severity levels, and reading them will give you an excellent sense of how to both find and report these vulnerabilities effectively.

To bring everything together — in Topic 13 we have covered Improper Access Control, which occurs when an application correctly identifies who you are but fails to verify what you are allowed to do. The core distinction is Authentication (identity) versus Authorization (permissions) — many developers implement one and forget the other. We covered the two main types: horizontal privilege escalation (accessing another user's data at the same privilege level) and vertical privilege escalation (accessing admin-level functionality from a regular user account). The two-account testing method is your primary tool — create two accounts, map all identifiers in Account A's requests, and replay them from Account B's session. High-priority targets include user profile endpoints, order/transaction history, file downloads, messaging systems, admin API paths, and payment endpoints. We also covered JWT manipulation (none algorithm, algorithm confusion, weak secrets), API-specific access control issues (method variations, missing auth checks, mass assignment), and practical discovery techniques (sequential IDs, UUIDs, parameter pollution). The Burp Suite Authorize extension can automate much of the two-account testing. Severity ranges from low (reading public data) through high (reading private PII) to critical (admin access or platform-wide data exposure). Access control vulnerabilities are everywhere in modern applications because authorization is hard to test with normal QA methods — it requires a security mindset. I will see you in Topic 14!

Topic 14 — Cross Site Scripting (XSS)

Welcome to Topic 14 — Cross Site Scripting, which is universally shortened to XSS. XSS is one of the most well-known and widely exploited vulnerability classes in web security, and it has been on the OWASP Top 10 list for over a decade. At its core, XSS is a vulnerability where an attacker can inject malicious JavaScript code into a web page that then executes in another user's browser. The key insight is that the attack targets the application's users rather than the server itself — when your script runs in someone's browser, you can read their cookies, steal their session tokens, redirect them to phishing pages, perform actions on their behalf, log their keystrokes, or take complete control of their account. The severity can range from low (self-XSS that only affects the user themselves) to critical (stored XSS on an admin panel that can compromise every user on the platform). In the KPWAPT course there are five types of XSS you must understand: Reflected XSS, Stored XSS, Blind XSS, DOM XSS, and Self XSS. Each has its own attack surface, its own testing methodology, and its own impact profile. We will cover all five in this topic, and by the end you should be able to identify and test for each type systematically in any bug bounty program.

The first type is Reflected XSS. The syllabus defines it clearly: Reflected XSS usually appears in URL parameters and instant responses. This means the application takes your input from a URL parameter, includes it in the HTML of the page it returns to you, and your browser renders that HTML — including any script tags or event handlers you injected. The simplest example is a search bar: when you search for "hello" on a vulnerable site, the page might display "You searched for: hello" — and if the application doesn't sanitize the input, searching for <script>alert(1)</script> would cause the page to display "You searched for:" followed by an alert box. The URL parameters you should prioritize for reflected XSS testing are: ?search=, ?q=, ?keyword=, ?query=, ?name=, ?message=, ?redirect=, ?url=, and ?return=. Beyond URL parameters, you should test website search bars, product search fields, blog search, documentation search, category filters, price filters, and sorting parameters — anywhere the application takes user input and reflects it back in the response. The key characteristic of Reflected XSS is that it doesn't persist — the payload only executes for someone who visits the crafted URL, which means you typically need to trick a victim into clicking a malicious link to exploit it.

Reflected XSS testing requires a good payload strategy. You should start with simple tag-breaking tests like a single quote ' or angle bracket < to see how the application handles special characters. If those are reflected without encoding, try basic payloads like <script>alert(1)</script> and event handler payloads like "><img src=x onerror=alert(1)>. If the application is filtering or encoding, you will need to escalate to bypass payloads. The wordlist at the syllabus reference for xss tags contains hundreds of tag combinations that have been proven effective against different WAF and sanitization configurations. The xss-payloads-generator tool can generate full combinations of tags and event handlers automatically, which is useful for automated scanning. For automation at scale, xssrecon is the tool listed in the syllabus — it can test multiple URLs from your url list for reflected XSS without manual effort. The store also has VulneraXSS, which is another automation tool for XSS detection. When you are working through the URLs from your Historical Analysis and Content Discovery stages, you should prioritize any URL that contains a parameter whose value appears in the page response — those are your highest-probability targets for Reflected XSS.

The second type is Stored XSS, which is more impactful because it persists. The syllabus definition: Stored XSS appears where data is saved and later displayed. When a vulnerable application stores your injected payload in a database and then renders it for every user who views that piece of content, your payload executes in every one of their browsers — without anyone needing to click a specially crafted URL. The attack surfaces for Stored XSS are everywhere user-generated content is accepted and later displayed: comments sections, profile bios, usernames and display names, job titles, support ticket systems, chat messaging systems, email templates, blog comments, product reviews, forum posts, and inbox messages. Any field where you can type or submit text and later see that text displayed on a page is a Stored XSS candidate. The testing approach is identical to Reflected XSS in terms of payloads — the difference is in the submission mechanism. You submit your payload through the input form, then navigate to whatever page renders the saved data. If the payload executes, you have Stored XSS. The impact is significantly higher than Reflected XSS because exploitation doesn't require tricking a user into clicking anything — it automatically executes for anyone who views the affected page. A Stored XSS in a username field on a platform with millions of users is a critical finding.

The third type is Blind XSS, which occurs when your payload executes in a part of the application you can't directly see — typically an admin panel. The syllabus definition: Blind XSS happens when the payload executes later in the admin panel. The attack surfaces for Blind XSS are specifically the forms and input points that feed into administrative views: contact us pages, feedback forms, support request forms, report issue forms, submit bug forms, customer support tickets, help desk systems, and ticket support interfaces. The logic is that you submit a payload through one of these forms, an administrator later reviews your submission in their admin panel, and your payload executes in the admin's browser. Since you can't directly observe whether the payload executed (you don't have access to the admin panel), you need an out-of-band callback server. The tool listed in the syllabus for this is xss.report — you register there and get a unique callback URL. You then embed this URL in your XSS payload so that when it executes, it makes a request to your callback server, which notifies you. The bxssreplace tool can automatically replace a standard XSS payload list with your callback server URL, and you can combine it with curl to send your blind payload to any form field. When you receive a callback notification, you know the payload executed — you then can escalate to steal the admin's cookie, capture a screenshot of their session, or perform other actions in their browser context.

The fourth type is DOM XSS, and this one is fundamentally different from the others. The syllabus draws a sharp distinction: Reflected XSS goes through the server — input enters the server, the server reflects it in the HTML response, and the browser renders and executes it. DOM XSS never touches the server at all — the payload stays entirely in the browser, manipulated by JavaScript running on the client side. The flow for DOM XSS is: input enters via a source, JavaScript processes it and passes it to a sink, the sink executes it. Sources are the places where attacker-controlled data enters the browser's JavaScript: location.search (the query string), location.hash (the fragment after #), location.href (the whole URL), document.URL, and document.referrer. Sinks are the dangerous JavaScript functions and properties where data becomes executable: innerHTML (which renders raw HTML), document.write() (which writes raw HTML), eval() (which executes a string as JavaScript code), location.href = (which can use the javascript: protocol), and element.src = (which sets an image or script source). To find DOM XSS, you must read the JavaScript source code of the target application, looking for cases where data from a source flows unvalidated into a sink. Because the payload never appears in the server's HTTP response, scanners and WAFs that operate on the response body often miss DOM XSS entirely — it requires manual JS analysis or specialized browser-based tooling.

The fifth type is Self XSS. The syllabus notes: Self XSS requires the user to paste the payload themselves. This is technically the same vulnerability mechanism as Reflected XSS, but it only executes in the context of the user who typed or pasted the payload — no other user is affected. For example, if a profile bio field reflects your input back to you on a preview page, but that preview page is only visible to you while you are editing your profile, then the XSS is self-only. Bug bounty programs generally consider pure Self XSS to be low severity or even out of scope, because exploitation requires socially engineering the victim into injecting the payload themselves — something that doesn't scale. However, Self XSS can become much more impactful when chained with other vulnerabilities. If you can find a CSRF vulnerability that allows you to inject content into another user's profile from an external page, what was Self XSS becomes Stored XSS from the perspective of the victim. This chaining technique is worth noting whenever you encounter what initially appears to be Self XSS — always ask yourself whether any other vulnerability could turn your self-only payload into one that affects other users.

Speaking of chaining, the syllabus specifically covers how to chain XSS with other vulnerabilities for maximum impact. The most common and impactful chain is XSS leading to account takeover. The classic payload for this uses the document.cookie property to exfiltrate the victim's session cookie to your own server. When your XSS payload executes in the victim's browser, it can silently make a request to a Burp Collaborator URL with the cookie value appended. The specific payload pattern in the syllabus uses document.write to create an img tag whose src attribute points to your Burp Collaborator endpoint with the cookie as a path parameter. When the browser tries to load that image, it sends the cookie value in a GET request to your Collaborator server, which records the incoming request. You then take that stolen session cookie, set it in your own browser using the developer tools, and refresh the page — if the application trusts the cookie without additional verification, you are now logged in as the victim. This chain — XSS to cookie theft to session hijacking to account takeover — is one of the most common critical-severity finding chains in bug bounty, and programs generally will accept it at high or critical severity when the impacted user has elevated privileges.

The XSS task targets in the syllabus give you real-world practice sites to test against: probiologists.com, hydra.as.utexas.edu, zeals.ai, motion.recruitonline.ai, and dash.free2host.eu.org. When you are approaching any of these targets, your workflow should follow a consistent pattern. First, map all input points — search bars, URL parameters, form fields, profile settings. Second, test each for Reflected XSS by injecting simple payloads and observing what gets returned in the response. Third, look for persistent storage points — anywhere you can save data — and test those for Stored XSS. Fourth, check any forms that feed into an administrative workflow (contact, feedback, support) for Blind XSS using your xss.report payload. Fifth, view the page's JavaScript source for any sinks that are fed from URL parameters or hash values, and test those for DOM XSS. For the HackerOne reports in the syllabus — 1818163, 751870, 1940245, 149855, 1309237 for Reflected; 485748, 1147433, 1084183 for Stored; 1558010, 1010466, 948929 for Blind; 474656, 324303, 396493 for DOM — reading them will show you exactly how hunters found, exploited, and reported each type in real programs.

To bring everything together — in Topic 14 we have covered Cross Site Scripting, one of the most common and impactful vulnerability classes in bug bounty. XSS occurs when an attacker can inject JavaScript into a page that executes in another user's browser. The five types are: Reflected XSS (input reflected immediately via URL parameters), Stored XSS (input saved and later rendered for all users), Blind XSS (payload executes in an admin panel you can't see), DOM XSS (client-side JS processes attacker data from sources into dangerous sinks), and Self XSS (payload only executes for the user who typed it, unless chained). Key testing surfaces include search bars, URL parameters, profile fields, comment sections, support forms, and any JavaScript that reads from location.search or location.hash. Tools covered include xssrecon for automation, bxssreplace for blind XSS delivery, and xss.report as a callback server. The most impactful chain is XSS → cookie theft → account takeover via document.cookie exfiltration to Burp Collaborator. When you are hunting, every URL parameter, every input field, and every piece of user-controlled content that appears on a page is a potential XSS entry point — and finding even one can turn into a critical account takeover when properly chained. I will see you in Topic 15!

Topic 15 — HTML Injection

Welcome to Topic 15 — HTML Injection. The syllabus gives us a clear and precise definition: HTML Injection occurs when an attacker can inject HTML code or HTML tags into a webpage, and the application renders it without sanitization. This is a vulnerability that sits just below XSS in terms of severity, and understanding it deeply will help you understand why XSS is so dangerous. The key difference between HTML Injection and XSS is what gets rendered. In HTML Injection, you are injecting HTML markup that the browser displays visually — headings, links, images, iframes, styled text. In XSS, you are injecting JavaScript that the browser executes. Both require the same underlying failure: the application accepts user-controlled input and places it inside HTML without properly encoding or sanitizing it first. If the application is not encoding your angle brackets into &lt; and &gt;, then it is likely vulnerable to both HTML Injection and XSS — HTML Injection is often the first indicator that XSS might also be possible. Many hunters will find HTML Injection first, then escalate their testing to confirm whether full JavaScript execution is possible in the same location. Even if XSS is not achievable, HTML Injection by itself can be a valid bug bounty finding — particularly when it allows content spoofing, phishing attacks via injected links, or iframe injection that loads malicious external content.

The testing methodology for HTML Injection is straightforward and should always start with the most basic tags. The syllabus specifically recommends beginning with <h1>HTML Injection</h1> — this is your canary. If you submit this string into an input field and the response renders a large bold heading that says "HTML Injection" rather than displaying the literal text <h1>HTML Injection</h1>, the application is vulnerable. You can test other basic tags to confirm: <b>Bold Text</b> should render bold text if vulnerable, <i>Italic Text</i> should render in italics, and <u>Underline</u> should render underlined text. The rule is simple: if the tags are rendered by the browser rather than displayed as literal text, the application is not encoding its output correctly, and HTML Injection is confirmed. These simple tests are very low-risk and should be the first thing you do whenever you encounter a text input that later appears in the application's output. Even before you think about XSS payloads with script tags or event handlers, these basic structural HTML tags will tell you immediately whether the application is performing output encoding at all.

Once you have confirmed basic HTML Injection, you can escalate your payloads to demonstrate real impact. The syllabus provides several impactful examples. The first is a styled heading: <h1 style="color:red">HACKED</h1>. This renders a large red heading that says "HACKED" on the vulnerable page — a visually dramatic proof of concept that program triage will immediately understand. The second is an anchor tag: <a href="https://bing.com">Click me</a>. This injects a clickable hyperlink into the page that leads to an external domain — this is content spoofing, and in the right context (a user's inbox, a support chat, an email notification) it can facilitate convincing phishing attacks where the victim believes they are clicking a legitimate application link. The third and most impactful payload is an iframe: <iframe src="https://krazeplanet.com" style="width:100vw; height:100vh; border:none; display:block;"></iframe>. This injects a full-screen invisible-bordered iframe that loads a completely different website inside the vulnerable page. From the user's perspective, they are looking at what appears to be the legitimate application — but the entire viewport is filled with content from an attacker-controlled page. This can be used for phishing, clickjacking-style attacks, and credential harvesting at scale.

It is important to understand why HTML Injection happens at a technical level, so that you can explain it clearly in your bug reports. When a web application receives user input and later includes it in an HTML response, it should perform output encoding — converting special characters like <, >, ", and & into their HTML entity equivalents (&lt;, &gt;, &quot;, &amp;). These entities tell the browser to display those characters as literal text rather than to interpret them as HTML markup. When the application fails to do this encoding, the browser parses the user-supplied markup as actual HTML, which is the vulnerability. This failure can happen at any output context: a reflection in a search results page, a value displayed in a user's profile, an error message that includes user-submitted text, a custom field shown on an invoice or document, or anything else where the application takes your input and puts it back on a page. The same failure that allows HTML Injection will typically also allow XSS once you find the right payload to bypass whatever partial filtering might be in place — so when you confirm HTML Injection, always continue testing for the XSS escalation rather than stopping at the HTML level.

When you are hunting for HTML Injection in a bug bounty program, the input fields you should prioritize are the same ones you would target for Stored XSS — profile bios, usernames, display names, comment sections, review text, support tickets, and any other field where user-controlled content is saved and later displayed. The difference from XSS testing is that you are specifically looking at whether structural HTML markup like headings, links, and iframes renders, not just whether script execution is possible. URL parameters that reflect in the response are also excellent targets — a parameter like ?message= or ?error= that displays your value in a notification or alert box on the page might render HTML tags even when it has partial filtering against script payloads. This is worth noting: some applications specifically filter or block <script> tags but forget to filter other HTML tags — in those cases HTML Injection will succeed even when simple XSS has been blocked. The live hunting session target in the syllabus is placer.ai — when practicing, approach it by systematically testing every visible input field with the basic HTML tag canaries before escalating to more advanced payloads.

The impact of HTML Injection varies based on context. At the lower end, HTML Injection in a field only visible to the submitting user might be low severity or informational. The impact increases significantly when the injected content is visible to other users. A Stored HTML Injection in a user's public profile that renders for everyone who views that profile allows content spoofing on behalf of the platform — an attacker can inject misleading official-looking text, phishing links, or iframes that trick other users into thinking the malicious content comes from the legitimate application. When HTML Injection appears in an admin panel or in content that administrators review, the impact escalates further — an injected iframe in a support ticket that an admin opens could load content that performs actions in the admin's browser context or displays a fake login form over the real interface. The HackerOne reports for HTML Injection in the syllabus — 3079966, 57914, 2210038, 2076019, 833470, 358001, 1257767, 1374017, 502926, and 1443567 — cover a range of impacts and contexts, and reading them will give you a strong sense of how programs evaluate HTML Injection severity and what makes a report stand out.

When you are writing your bug report for HTML Injection, the key elements are a clear reproduction case, a demonstration of rendered HTML in your screenshot or recording, and an explanation of what an attacker could do with the injection. A screenshot showing a rendered heading or an injected link is far more persuasive than text alone. For the PoC, you should use a payload that clearly demonstrates the rendering — the red <h1 style="color:red">HACKED</h1> payload is visually impactful and immediately obvious. For severity justification, explain what an attacker could realistically do: if the injection is in a field visible to other users, explain the phishing or content spoofing vector. If an iframe can be injected, explain that an attacker could load a full-screen fake login page over the legitimate application. If the injection appears in an admin-visible context, note that it could be used for phishing targeted at platform administrators. Always mention whether you tested for XSS escalation and what the result was — if full script execution was not possible despite HTML rendering, say so, as this helps the program understand the boundary of the vulnerability. Reports that combine a clear PoC, real-world impact explanation, and an honest assessment of the escalation potential tend to be resolved and rewarded much faster than those that only show the technical finding without the attack narrative.

To bring everything together — in Topic 15 we have covered HTML Injection, which occurs when user-controlled input is placed in an HTML response without output encoding, allowing an attacker to inject and render arbitrary HTML markup in the browser. The core test is submitting <h1>HTML Injection</h1> — if it renders as a heading, the vulnerability is confirmed. Escalation payloads include styled headings, anchor tags to external domains, and full-screen iframes that load attacker-controlled content. HTML Injection is closely related to XSS — both share the same root cause (missing output encoding), and HTML Injection is often the first indicator that XSS might be achievable in the same location. Priority testing surfaces are profile fields, comment sections, URL parameters that reflect in error or notification messages, and any user-controlled content that appears on a page viewed by others. Impact ranges from low (self-only injection) to high (injected content visible to all users, or in admin-reviewed contexts). The HackerOne reports in the syllabus cover ten real examples to study. I will see you in Topic 16!

Topic 16 — Open Redirect

Welcome to Topic 16 — Open Redirect. The syllabus gives us this definition: an Open Redirect happens when a web application redirects users to a URL controlled by user input without proper validation. Let me break that down in plain language. Many web applications need to redirect users after certain actions — after logging in, the app might redirect you back to whatever page you were trying to access; after a password reset, it might redirect you to the login page; after making a payment, it might redirect you to an order confirmation. To make these redirects dynamic and flexible, developers often accept the destination URL as a parameter in the request itself — something like /login?next=https://app.com/dashboard. The application then reads that next parameter and redirects the user there after completing the action. If the application doesn't validate that the destination URL belongs to its own domain, an attacker can substitute any URL they want — including a phishing page they control. The victim sees a legitimate URL in their browser that belongs to a trusted application, they complete the action (like logging in), and then they are silently redirected to the attacker's page without realizing anything has gone wrong. This is why Open Redirect is considered a valid security finding — it weaponizes the trust users have in a legitimate domain to deliver them to malicious content.

The common parameters to look for when hunting Open Redirect are listed in the syllabus, and you should memorize them because they appear across virtually every web application you will ever test. The highest-priority ones are: ?url=, ?redirect=, ?next=, ?return=, ?returnTo=, ?continue=, ?dest=, ?destination=, and ?callback=. Any parameter with one of these names is a strong signal that the application might be performing a redirect with user-controlled destination. You should also look for variations — ?returnUrl=, ?redirectUrl=, ?goto=, ?forward=, ?to= — because developers name these differently across codebases. When you find one of these parameters in a URL from your Historical Analysis or Content Discovery stages, the first test is simple: replace the parameter value with an external URL you control and observe whether the application redirects you there. The syllabus example is https://google.com/redirect?url=https://google.com.xyz — if it redirects to google.com.xyz instead of staying on the legitimate domain, the vulnerability is confirmed. This basic test should always be your first step.

The places in a web application where Open Redirect is most commonly found are very specific, and the syllabus lists them clearly. Login and logout pages are the most common — after a successful login, the application typically needs to send the user somewhere, and that destination is often controllable. Signup pages can also have post-registration redirect parameters. Password reset flows frequently use redirect parameters to take the user back to whatever they were doing before they initiated the reset. OAuth and SSO (Single Sign-On) flows are particularly rich targets — the OAuth protocol itself uses a redirect_uri parameter that specifies where the authorization server should send the authorization code after authentication, and misconfigured OAuth implementations can allow that parameter to be set to external domains. Payment gateway redirect flows — where the application sends you to a payment processor and then receives you back via a callback URL — are another target. Email verification links can also contain redirect parameters that control where the user lands after clicking the verification link. When you are mapping an application's flows in Burp Suite, pay close attention to any HTTP 301, 302, or 303 response — whenever you see a redirect, check whether the Location header value comes from a user-controlled parameter.

Now let me explain the bypass payloads, because a straight substitution like ?redirect=https://evil.com will often be caught by basic validation. Many applications try to validate redirect destinations by checking whether the value starts with their own domain, or by checking for the presence of their domain name anywhere in the URL. These checks are easy to bypass with the right payload construction, and the syllabus provides an extensive list of techniques. Protocol-relative URLs like //bing.com might bypass checks that only look for https:// as a prefix. Path traversal in the redirect destination like https://bing.com/%2f.. or https://bing.com/%2e%2e can confuse URL parsers that try to normalize the path. URL encoding tricks — encoding characters like / as %2f, %252f (double encoded), or %5c (backslash) — can bypass filters that operate on the raw string before decoding. CRLF injection in the path using %0A, %0D, or %09 before the external domain can sometimes trick redirect parsers. Domain confusion using constructions like https://bing.com\@evil.com or bing.com\@evil.com exploits the ambiguity between the userinfo part of a URL and the host — some parsers read the host as bing.com while others read it as evil.com. Each of these techniques represents a different assumption a developer made about what constitutes a "valid" URL, and testing all of them systematically is how professional hunters find open redirects on hardened applications.

The impact of Open Redirect is primarily about trust weaponization. By itself, redirecting a user to an external site might seem low impact — after all, the user could just navigate away themselves. But the power of Open Redirect lies in the legitimacy of the initial URL. A phishing email that contains a link to https://paypal.com/login?next=https://evil.com/phish is far more convincing than one containing a direct link to evil.com, because security-conscious users will check the domain before clicking and will see a trusted name. After the user completes the legitimate action on paypal.com, they are silently redirected to the phishing page, which might look identical to the real site and ask them to log in again due to a "session timeout." Open Redirect also has significant impact when chained with other vulnerabilities. In OAuth flows, an Open Redirect on the authorization server can sometimes be used to steal authorization codes — if the OAuth server allows a redirect_uri that passes through an Open Redirect on the target domain, the authorization code might end up at the attacker's server instead of the legitimate callback endpoint. This chain — Open Redirect in OAuth → authorization code theft → account takeover — has been responsible for critical bug bounty findings across major platforms. The 24 HackerOne reports in the syllabus (504751, 311330, 2812583, 159522, 1788006, 111968, and many more) cover the full range of open redirect findings from low-severity standalone reports to critical OAuth chains.

Automation is useful for Open Redirect hunting because the vulnerability is highly pattern-driven — if you know the common parameter names and the common bypass techniques, you can test thousands of URLs efficiently. When you are working through your url list from the Historical Analysis stage, the workflow is: filter for URLs that contain any of the redirect parameter names (url=, redirect=, next=, return=, returnTo=, continue=, dest=, destination=, callback=), then replay each with a modified destination value using Burp Suite Intruder or a custom script. Watch the response status codes — a 301 or 302 to your substituted domain confirms the redirect. The syllabus regex patterns — Location:\s*.*bing\.com and the case-insensitive match pattern — can be used in Burp's match-and-extract rules to automatically flag any response where the Location header contains your test domain. The live hunting session targets from the syllabus — aan.com, autoemali.com, and lnks.io — are worth practicing on. Lnks.io is particularly interesting because URL shortener services by their nature perform redirects, and their redirect destination controls might have validation weaknesses. When you are testing these targets, combine manual review of redirect flows with automated URL parameter fuzzing to maximize coverage.

When you are writing a bug report for Open Redirect, the key elements are the vulnerable URL with the injected parameter, a clear demonstration that the redirect actually occurs to your destination (a screenshot or screen recording of the browser's address bar landing on your domain), and an impact explanation that goes beyond just "it redirects." Programs that have seen many Open Redirect reports are sometimes skeptical of the severity if the report only says "it redirects to another site." You should explicitly describe the phishing scenario — how an attacker would craft a legitimate-looking URL to deliver to a victim, what page the attacker would host at the redirect destination, and how the victim would be deceived. If the redirect occurs after a sensitive action like login or payment, that context should be in your report because it increases the realistic impact. If you can chain the Open Redirect with another vulnerability — particularly in an OAuth flow — that chain should absolutely be demonstrated in the report, as it transforms a medium-severity finding into a potential critical. For the bypass payloads you used, always document both the payload and the reason it worked — explaining that the developer's filter was checking for a string prefix but missed URL encoding tricks gives the program the context they need to fix it properly rather than patching only the specific payload you reported.

To bring everything together — in Topic 16 we have covered Open Redirect, which occurs when an application redirects users to a URL supplied by user input without properly validating that the destination belongs to a trusted domain. The core mechanism is that redirect parameters like ?url=, ?redirect=, ?next=, ?return=, and others are accepted without domain restriction. The most common locations are login/logout flows, signup pages, password reset, OAuth/SSO, payment gateways, and email verification links. Bypass techniques include protocol-relative URLs, URL encoding, double encoding, CRLF injection, backslash tricks, and domain confusion with the userinfo prefix. The impact ranges from medium (phishing via trusted domain) to critical (OAuth authorization code theft leading to account takeover). Automation using Burp Suite match rules and parameter filtering from your URL list is the most efficient hunting approach. Reading the 24 HackerOne reports in the syllabus will show you the full range of how this vulnerability manifests and is reported across real programs. I will see you in Topic 17!

Topic 17 — No Rate Limiting

Welcome to Topic 17 — No Rate Limiting. This vulnerability is one of the most accessible and beginner-friendly findings in bug bounty, and it appears in a surprising number of real-world applications even today. At its core, No Rate Limiting means that the application does not restrict how many times a user can perform a specific action within a given time period. Rate limiting is a defensive mechanism that says "you can try this action at most N times per minute or per hour." Without it, an attacker can repeat an action thousands or millions of times without restriction — using automation tools like Burp Suite Intruder, Turbo Intruder, or custom scripts to send requests as fast as the network allows. The impact depends entirely on what action lacks rate limiting. If a login endpoint has no rate limiting, an attacker can brute-force passwords. If an OTP (one-time password) verification endpoint has no rate limiting, an attacker can try all possible 6-digit codes (1,000,000 combinations) in a matter of minutes. If a registration endpoint has no rate limiting, an attacker can register thousands of fake accounts. If an invite endpoint has no rate limiting, an attacker can flood another user's inbox with thousands of invitations, which is a form of denial-of-service or spam abuse. Understanding which endpoints should have rate limiting — and testing each of them systematically — is the core skill of this topic.

The five locations where you should always check for No Rate Limiting are listed clearly in the syllabus: Registration, Resend OTP, Change Password, Reset Password, and Invite. Let me explain why each of these matters. Registration endpoints without rate limiting allow mass account creation — an attacker can programmatically generate thousands of accounts, which can be used for review spam, referral abuse, or overwhelming the platform's storage. Resend OTP is arguably the highest-impact target on this list: OTPs are typically 4 to 6 digits, which means there are between 10,000 and 1,000,000 possible values. If you can resend and attempt OTPs without restriction, you can brute-force the correct code and bypass two-factor authentication or account verification entirely. Change Password endpoints without rate limiting allow brute-force attacks on password change forms, particularly when the form also requires the current password — an attacker who has partial knowledge of the target's credentials can cycle through variations rapidly. Reset Password flows without rate limiting allow brute-forcing of password reset tokens or codes that arrive via email or SMS — especially relevant when tokens are short or time-based but predictable. Invite endpoints without rate limiting allow email spam attacks: by sending thousands of invitation emails to a target from a legitimate platform, an attacker can effectively conduct a targeted harassment or inbox flood campaign that appears to come from a legitimate service.

The testing methodology for No Rate Limiting is one of the simplest in all of bug bounty, which is why this topic is accessible even to hunters who are early in their journey. The workflow is: find the endpoint, capture the request in Burp Suite, and send it to Intruder or Repeater. In Intruder, you set up a simple null payload attack — a payload type that sends the same request repeatedly without changing any value. You set the number of repetitions to something meaningful (100 to 500 times) and start the attack. If every response returns a 200 OK with the same success message, the endpoint has no rate limiting. If after some number of attempts the server starts returning 429 Too Many Requests, or a message like "you have exceeded the limit" or "please try again later," then rate limiting is in place and the endpoint is not vulnerable. For OTP brute-force testing specifically, you would use a numeric payload list (0000 through 9999 for a 4-digit OTP, or 000000 through 999999 for a 6-digit OTP) and test whether the server allows you to exhaust the full keyspace without locking out the account or throttling the requests. Burp Intruder can do this automatically, and the results will clearly show which response code and body indicates a successful OTP match.

There are several important nuances to No Rate Limiting testing that you should be aware of. First, some applications implement rate limiting at the IP address level rather than at the account or session level. This means the endpoint does have rate limiting, but it can be bypassed by rotating IP addresses — a technique often achieved in real attacks using proxies or cloud functions, but which is generally out of scope for demonstration in a bug bounty report. When you are testing, test from a single IP first; if you receive a rate limit response after some attempts, note that in your report and mention whether IP rotation would bypass it. Second, some applications implement rate limiting via the account's email or username rather than the IP — meaning you can bypass it simply by rotating between different account identifiers. Third, some applications use header-based rate limit bypasses — sending a header like X-Forwarded-For: 127.0.0.1 or X-Real-IP: 127.0.0.1 might trick the rate limiter into treating each request as coming from a different IP. If you find that a basic null payload test hits a rate limit, always try these bypass headers before concluding the endpoint is fully protected. A rate limit that can be bypassed with a simple header is itself a vulnerability, often reportable at the same severity as having no rate limit at all.

The severity of No Rate Limiting findings depends heavily on the endpoint and what can be achieved through unrestricted repetition. OTP brute-force on a login flow is typically high severity because it allows complete authentication bypass — an attacker who can try all possible OTP codes can take over any account that uses that two-factor verification step. Password brute-force via a login or change-password endpoint is also high severity. Email enumeration via different error responses between existing and non-existing email addresses at an unlimited rate is medium severity — it allows harvesting valid email addresses from the platform's user base. Mass registration and invite flood are typically low to medium severity — they represent abuse vectors but don't directly compromise user accounts or data. When you are assessing the severity of a No Rate Limiting finding, always think about what an attacker can realistically accomplish by sending the request thousands of times. The more directly it leads to account compromise or data exposure, the higher the severity should be in your report. The 14 HackerOne reports in the syllabus — 1708824, 1322243, 410451, 905692, 658089, 1202408, 224927, 1166069, 862681, 1206004, 128777, 1166066, 774050, and 1060541 — span a wide range of No Rate Limiting findings and will give you a strong sense of how programs evaluate this vulnerability class.

One common mistake beginners make with No Rate Limiting reports is submitting a finding without clearly demonstrating impact. Saying "this endpoint has no rate limiting" is not enough — you need to show the program what an attacker would actually do with that unrestricted access. For OTP brute-force, your PoC should show a Burp Intruder attack cycling through a range of OTP values, and ideally it should show which response indicates a successful match so the triage team understands that the attack would succeed. For password brute-force, your PoC should demonstrate that the same incorrect password can be submitted hundreds of times without any lockout or throttle. For email flood via invite, demonstrate that the same email address receives multiple invitation emails in quick succession. Screenshots of the Burp Intruder results showing 100+ successful responses with no rate limit errors are compelling evidence. The task target in the syllabus is at the internal address used in class, and practicing the full Intruder workflow on a test endpoint will cement the methodology in your muscle memory so that when you encounter it on a real target, you know exactly what steps to follow.

Combining No Rate Limiting with other vulnerabilities is a powerful technique for elevating severity. The most impactful chain involves No Rate Limiting on a password reset or OTP endpoint combined with Username/Email Enumeration (Topic 20). If you can first enumerate which email addresses are registered on the platform (from Topic 20's techniques), you then have a list of valid targets for the brute-force attack. For each valid email, you can trigger a password reset or OTP, then brute-force the token or code using the unrestricted endpoint. The result is a full account takeover chain: enumerate accounts, then take over accounts via OTP/token brute-force. This chain — Username Enumeration → No Rate Limiting OTP Brute-force → Account Takeover — has been responsible for critical bug bounty findings across a large number of programs, and whenever you find No Rate Limiting on a sensitive endpoint, you should immediately check whether enumeration of target accounts is also possible. Even if you can't complete the full account takeover chain in a safe demonstration, explaining the chain in your report and showing each individual component will significantly increase the perceived severity and the likelihood of a meaningful reward.

To bring everything together — in Topic 17 we have covered No Rate Limiting, which occurs when an application fails to restrict how many times a user can perform an action in a given time period. The five priority testing locations are Registration, Resend OTP, Change Password, Reset Password, and Invite. The testing methodology is straightforward: capture the request in Burp Suite, send it to Intruder with a null payload, and observe whether the server throttles or blocks after repeated attempts. OTP brute-force on login flows is the highest-impact variant — it allows complete 2FA bypass. Rate limit bypass headers (X-Forwarded-For, X-Real-IP) should always be tested when basic requests are throttled. Severity ranges from low (invite flood) through medium (email enumeration) to high (OTP or password brute-force). The most powerful chain is Email Enumeration + No Rate Limiting → Account Takeover. Reports must demonstrate actual impact, not just the absence of rate limiting. The 14 HackerOne reports in the syllabus cover real examples across this spectrum. I will see you in Topic 18!

Topic 18 — Race Condition

Welcome to Topic 18 — Race Condition. Race Condition is a vulnerability that is closely related to No Rate Limiting, but it operates on a fundamentally different principle. The syllabus gives us the key insight directly: if you see anywhere any kind of limitation — like "you can resend OTP only 3 times" — that is your signal to test for Race Condition. Rate limiting protects against repeated requests sent one after another, in sequence. Race Condition exploits the brief window between when a check is performed and when the action is executed — by sending multiple requests simultaneously, in parallel, at the exact same millisecond, an attacker can sometimes bypass limits that would correctly stop sequential requests. The underlying technical cause is a Time-of-Check to Time-of-Use (TOCTOU) problem. The server checks whether the action is allowed (for example, "has this coupon already been used?"), and then it executes the action (for example, "apply the discount"). If two requests arrive simultaneously, both checks may pass before either action has completed, meaning both requests will execute even though only one should have been allowed. The result can be coupon codes applied multiple times, votes cast multiple times, accounts created beyond their limit, OTPs that were supposed to expire after three tries remaining valid, or rewards credited more than once. Race Condition has produced some of the most creative and impactful bug bounty reports across all vulnerability classes.

The nine locations where the syllabus tells us to check for Race Condition are: Resend OTP, Reset Password, Invite, Coupon Code, Likes, Feedback, Comments, Poll vote, and Create Team or Workspace. Let me walk through each of these and explain the specific attack scenario. Resend OTP is the overlap with Topic 17 — if the application limits you to resending the OTP three times, sending three requests simultaneously might bypass that limit and get you more OTP attempts than the application intended. Reset Password is similar — if there is a limit on how many password reset emails can be triggered, a simultaneous burst might produce multiple valid reset tokens at once. Invite has the same logic — sending invites simultaneously might exceed the per-account invite limit. Coupon Code is a high-impact target: if a coupon code should only be usable once, applying it simultaneously from multiple threads can sometimes apply the discount multiple times before the first application has been recorded as "used." Likes, Feedback, Comments, and Poll votes represent a category of "one-per-action" limits — a user should only be able to like a post once, vote once, leave one review. Race Condition might allow multiple likes or votes to be recorded simultaneously. Create Team or Workspace is interesting because many platforms have a tier-based limit on how many teams or workspaces a free account can create — bypassing this via Race Condition is a business logic violation that can have real financial impact on the platform.

The technical tool for exploiting Race Conditions in Burp Suite is Turbo Intruder, which is a Burp extension specifically designed for high-speed, synchronized request sending. The standard Burp Intruder is not suitable for Race Condition testing because it sends requests sequentially, one at a time, with a delay between each. Turbo Intruder can send multiple requests simultaneously using HTTP/2 single-packet attacks, which means all requests arrive at the server in a single TCP packet and are processed at virtually the same instant. This is the key: for a Race Condition to succeed, your requests must arrive within the server's processing window for the vulnerable check — often just a few milliseconds. Network jitter can spread your requests across time and cause them to be processed sequentially rather than simultaneously. The HTTP/2 single-packet technique eliminates this jitter by grouping all requests into one packet, which is why Burp Suite's newer Race Condition testing features specifically use this approach. When you are testing for Race Condition, your Turbo Intruder script should set up 10 to 50 simultaneous requests (depending on the target's response time and the action being tested) and fire them all at once. If the Race Condition is present, you will see multiple success responses — multiple "coupon applied" messages, multiple "OTP sent" messages, or multiple "created successfully" responses — when only one should have been possible.

Coupon code abuse via Race Condition is worth discussing in depth because it has produced some of the highest-severity business logic findings in bug bounty history. Many e-commerce and SaaS platforms offer promotional discount codes that should only be applied once per account or once per order. The database logic typically looks like this: check if the coupon has been used by this user; if not, apply the discount and mark it as used. The window between the check and the mark is where the Race Condition lives. By sending 20 checkout requests simultaneously, all with the same coupon code, an attacker might get the discount applied to 10 or 15 of those orders because all 20 checks ran before any of the marks were written. On platforms where coupons represent significant monetary value — particularly in fintech, travel booking, or enterprise SaaS — this can translate to real financial losses for the company. When you are calculating the impact of a coupon Race Condition, always estimate the realistic financial value that could be extracted. A coupon worth $50 that can be applied 20 times in one Race Condition attack represents $1,000 in fraudulent discounts per exploitation attempt — a figure that immediately justifies a high-severity classification.

OTP Race Condition deserves special attention because of how directly it connects to authentication bypass. Many applications implement OTP verification with a small attempt limit — typically 3 to 5 tries — before the OTP expires or the account gets temporarily locked. This limit is meant to prevent brute-force of the OTP keyspace. But if the OTP verification endpoint is vulnerable to Race Condition, you can bypass that attempt limit by sending your guesses simultaneously. For a 4-digit OTP, you only need to try up to 10,000 codes, but with a limit of 3 attempts per session, brute-force seems impossible. If Race Condition allows you to submit 100 or more guesses in a single burst, the limit is effectively bypassed, and with enough parallel bursts you can eventually cover the entire keyspace. Even more impactfully, some applications have Race Condition on the OTP invalidation itself — a code that should become invalid after one use might remain valid if two simultaneous requests both verify it before either invalidation has been written to the database. This means a single OTP can be used twice, which in a two-factor authentication context means an attacker who observes or intercepts a victim's OTP once can replay it in a second session before the first use has registered.

The connection between Race Condition and No Rate Limiting is important to understand clearly, because they are sometimes confused. No Rate Limiting (Topic 17) means the application does not limit repetition at all — you can send 1,000 sequential requests and all will succeed. Race Condition means the application does have a limit — it will stop you after a certain number of sequential attempts — but that limit can be bypassed by sending requests simultaneously. The key signal that should make you switch from Rate Limiting testing to Race Condition testing is exactly what the syllabus states: if you see any kind of explicit limitation in the application's behavior. If the UI says "you can resend OTP only 3 times," that is not a reason to give up — it is a reason to try Race Condition. If you try to apply a coupon code twice sequentially and the second attempt says "coupon already used," that is not a reason to move on — it is a reason to try applying it simultaneously. Any time an application explicitly or implicitly tells you a limit exists, you should ask: is that limit enforced with proper database locking, transactions, or atomic operations? Or is it only enforced at the application layer, where simultaneous requests might slip through before the state has been updated?

The 11 HackerOne reports in the syllabus — 165570, 1285538, 488985, 429026, 454949, 801743, 152717, 1913309, 146845, 927384, and 3104355 — cover Race Condition findings across a wide variety of contexts. Reading them will show you how hunters identified the vulnerable window, what tool they used to send simultaneous requests, what the impact was, and how they presented it to the program. Race Condition reports tend to require more technical depth than simpler findings because you must explain the underlying TOCTOU flaw — why the check and the state update are not atomic — and demonstrate it reproducibly. A good Race Condition PoC includes a screenshot or recording of the Turbo Intruder results showing multiple success responses in the same burst, proof that the effect actually persisted in the application (for example, a coupon balance that was debited more than once), and a clear explanation of the fix — typically that the check and update operations need to be wrapped in a database transaction with appropriate locking so that simultaneous requests are serialized rather than running concurrently.

To bring everything together — in Topic 18 we have covered Race Condition, which exploits the Time-of-Check to Time-of-Use window to bypass limits that are correctly enforced against sequential requests but fail under simultaneous load. The key signal is any explicit limit in the application — "only 3 OTP attempts," "coupon can only be used once," "one vote per user." The nine target locations are Resend OTP, Reset Password, Invite, Coupon Code, Likes, Feedback, Comments, Poll vote, and Create Team or Workspace. The primary tool is Burp Suite's Turbo Intruder using HTTP/2 single-packet attacks to eliminate network jitter and ensure simultaneous arrival. Coupon code abuse can produce high-severity financial impact findings. OTP Race Condition can bypass two-factor authentication. The distinction from No Rate Limiting is that Rate Limiting is absent in Topic 17, while in Race Condition it is present but has an atomic enforcement gap. The fix is database-level locking or transactions — not just application-layer checks. The 11 HackerOne reports in the syllabus cover the range of Race Condition findings to study. I will see you in Topic 19!

Topic 19 — Information Disclosure

Welcome to Topic 19 — Information Disclosure. Information Disclosure is a broad vulnerability category that covers any situation where a web application or server unintentionally reveals sensitive information to users who should not have access to it. The information that gets disclosed can range from relatively low-impact details like software version numbers, to medium-impact content like internal paths, usernames, or configuration values, to high-impact secrets like API keys, database credentials, source code, or private user data. What makes Information Disclosure particularly valuable in bug bounty hunting is that it often provides the building blocks for other, higher-severity vulnerabilities. A version disclosure might reveal that the server is running software with a known CVE. A directory listing might expose backup files containing database dumps or configuration files with credentials. An exposed .git directory might contain the entire application source code, including hardcoded secrets. An error message that reveals a stack trace gives an attacker an understanding of the internal architecture that they can use to craft more targeted attacks. This is why finding Information Disclosure should never be dismissed as "just an info finding" — it is often the first step in a chain that leads to something far more serious. The syllabus focuses primarily on directory listing as the main vector for Information Disclosure, combined with the indextree tool and Google, Shodan, and FOFA dorks for discovery at scale.

The highest-signal form of Information Disclosure in the syllabus context is the open directory listing, identifiable by the classic "Index of /" page title. When a web server has directory listing enabled, browsing to a directory URL that does not have an index file (like index.html or index.php) causes the server to display a formatted list of all files and subdirectories in that folder. This was once a convenient feature for file sharing, but has become a significant security risk — many servers have it accidentally enabled in directories that contain sensitive files. The three dorks in the syllabus let you find these exposed directories at scale: intitle:"Index of /" for Google, http.title:"Index of /" for Shodan, and title="Index of /" for FOFA. When you combine one of these dorks with site: or ssl: targeting, you can quickly find open directory listings on a specific company's domains. For example, site:target.com intitle:"Index of /" in Google will return every publicly indexed open directory on that company's domain. What you find inside these directories is what determines the severity — a directory listing of only publicly available assets has little impact, but one that contains database backups, log files, configuration files, uploaded user documents, or source code represents a significant finding.

The syllabus lists the indextree tool for Information Disclosure hunting. Indextree is designed to crawl and enumerate the contents of open directory listings recursively — when you give it a URL that has an "Index of /" page, it walks through all subdirectories and builds a complete tree of everything that is accessible. This is far more efficient than manually clicking through nested directories in a browser, and it gives you a comprehensive view of everything exposed. The example URLs in the syllabus show the kind of open directories that exist in the wild: quickxpert.com/courses/, spdf.gsfc.nasa.gov/pub/, moycor.com/wp-content/plugins/, and others. These range from course files and plugins to raw data files at a NASA endpoint. Each of these represents a real server where someone forgot to disable directory listing, and the contents of these directories might include things the administrators never intended to be public. The /wp-content/plugins/ path is particularly interesting on WordPress sites because it reveals exactly which plugins are installed, which is valuable intelligence for technology-based CVE hunting (Topic 05) — if you can see that a WordPress site is running a specific plugin version, you can immediately check whether that version has known vulnerabilities.

Beyond directory listings, there are several other high-value Information Disclosure vectors you should know. Exposed .git directories are one of the most critical — if a developer deployed their application by copying the entire project folder to the server, the .git directory might be accessible at https://target.com/.git/. If directory listing is enabled there, or if you can access .git/config, .git/HEAD, and .git/COMMIT_EDITMSG directly, you can potentially reconstruct the entire source code using git tools. Backup files in public directories are another critical vector — from the Content Discovery topic (Topic 08), you know to fuzz for extensions like .zip, .sql, .old, and .bak. Finding a file like database.sql or backup.zip in a web-accessible directory can immediately expose the entire database, all user credentials, and all application logic. Environment files like .env, config.php, wp-config.php, appsettings.json, and similar files are another prime target — these often contain database connection strings, API keys, AWS credentials, and other secrets that would allow complete compromise of the application infrastructure. Stack traces and verbose error messages can also disclose technology stack details, internal file paths, and sometimes even fragments of source code — always trigger errors deliberately (by sending malformed input, missing parameters, or invalid data types) and inspect the error responses carefully.

Log files are another extremely high-value Information Disclosure target. Web server log files, application log files, and debug log files are sometimes placed in web-accessible directories without restriction. These files can contain an enormous amount of sensitive information: full request URLs including query parameters with sensitive data, session tokens that appeared in GET requests, email addresses and usernames from authentication events, internal IP addresses, error stack traces, and sometimes even plaintext passwords submitted by users who were using them in incorrect fields. A log file from even a few hours of traffic can contain thousands of valid session tokens, depending on how the application handles authentication. The example in the syllabus showing https://www.vcebhopal.ac.in/a/-/-/etc/passwd demonstrates path traversal leading to /etc/passwd disclosure — another form of Information Disclosure that overlaps with Local File Inclusion (Topic 26). The key lesson here is that any file that contains sensitive data and is accessible without authentication represents an Information Disclosure finding, regardless of whether it arrives via directory listing, path traversal, a misconfigured bucket, or a public CDN URL that someone assumed was unlisted.

Google dorking for Information Disclosure has a specific pattern that has proven very effective for hunters. The combination of intext:"Index of" with specific file extensions or directory names lets you hunt for particular types of sensitive files at scale. For example, intext:"Index of" intext:"database.sql" finds open directories that contain SQL database dumps. intext:"Index of" intext:"admin.tar.gz" finds open directories with admin directory archives. These custom dorks were shown in Topic 09 of the syllabus, and they represent the intersection of OSINT Dorking and Information Disclosure — using search engines to locate specific types of sensitive files that are accidentally exposed. Combining these dorks with site: targeting against a specific program's domain is one of the fastest ways to find high-impact Information Disclosure findings on programs you are hunting. The syllabus report examples from X.com — posts by winteri3coming, Tismayil1, Hammad7361, tun4hunt, 0x_rood, and 7h3h4ckv157 — show real hunters finding and reporting these types of disclosures in the wild, and studying their posts gives you a sense of how quickly accessible these findings can be when you know the right dork patterns.

When you are assessing the severity of an Information Disclosure finding and writing your bug report, the most important factor is what specifically was disclosed and what an attacker could do with it. Version numbers, technology stack details, and internal path disclosures are typically low severity on their own — they provide useful reconnaissance information but don't directly compromise anything. User data disclosures — email addresses, usernames, account IDs — are typically medium severity. API keys, database credentials, session tokens, and private encryption keys are high to critical, because they enable direct access to protected systems. Source code disclosure is high severity because it allows an attacker to perform detailed source code review to find additional vulnerabilities that would otherwise require black-box testing. Database dumps are critical when they contain plaintext or weakly hashed passwords, PII, financial data, or health information. The 25-plus HackerOne reports in the syllabus — 1703733, 188719, 975047, 1886143, 290930, 1826141, 3000510, 143064, 3403450, 378122, 1070081, 1801427, 200079, 159526, 1397788, 674757, 2097377, 1365076, 182358, 605608, 2421796, 1860905, 1448218, 1072893, and 667032 — span the full severity range and will calibrate your expectations for what programs consider reportable versus out of scope for Information Disclosure findings.

To bring everything together — in Topic 19 we have covered Information Disclosure, which encompasses any unintentional exposure of sensitive data through misconfigured servers or applications. The primary focus from the syllabus is open directory listings ("Index of /") found through Google, Shodan, and FOFA dorks, combined with the indextree tool for recursive enumeration of their contents. High-value targets within exposed directories include database backups (.sql, .zip), configuration files (.env, wp-config.php), log files, and exposed .git directories. Beyond directory listings, Information Disclosure also covers stack traces, version disclosures, API keys in public files, and path traversal to sensitive server files. Severity ranges from low (version numbers) through medium (user data) to critical (credentials, source code, database dumps). Information Disclosure is often the first step in a chain — a disclosed API key might lead to full infrastructure compromise, and disclosed plugin versions might lead to CVE exploitation. The 25-plus HackerOne reports cover the full severity spectrum. I will see you in Topic 20!

Topic 20 — Username & Email Enumeration

Welcome to Topic 20 — Username and Email Enumeration. This vulnerability is one of the most foundational reconnaissance findings in bug bounty, and it is valuable not just as a standalone submission but as the first link in a chain that can lead directly to account takeover. Username and Email Enumeration occurs when a web application responds differently depending on whether the identifier you submitted — a username or email address — actually exists in its user database. The vulnerability is in the information the application leaks through its responses. A well-designed application should always return the same response whether the identifier exists or not, so that an attacker cannot tell the difference. A poorly designed one might say "No account found with that email" for a non-existent address and "Password incorrect" for an existing one — the different messages reveal which addresses are registered. Once an attacker has a list of valid email addresses or usernames on the platform, they can use that list for targeted phishing attacks, password brute-force attacks, OTP brute-force via No Rate Limiting (Topic 17), or account takeover via Race Condition on OTP verification (Topic 18). The connection between this topic and the previous two is direct and intentional — the KPWAPT methodology builds each topic on the ones before it, and Username Enumeration + No Rate Limiting + Race Condition together form one of the most complete account takeover chains in the entire course.

The primary location where the syllabus tells us to check for Username and Email Enumeration is the Reset Password endpoint. This is the most common and reliable location for this vulnerability because password reset flows almost always need to take an email address as input, and many developers write different error messages for the "email not found" case versus the "email found, reset link sent" case without realizing they are leaking information. When you visit a Reset Password page and enter an email that doesn't exist, a vulnerable application might say "We couldn't find an account with that email address" or "No user with that email exists." When you enter an email that does exist, it might say "A password reset link has been sent to your email" or simply "Check your inbox." These are two different responses, and an attacker with a large list of email addresses can test each one against this endpoint and sort them into "exists on this platform" and "does not exist" buckets with perfect accuracy. Using Burp Suite Intruder with a wordlist of email addresses, this enumeration can be automated completely — after the attack has run, you compare the response lengths or response bodies to separate the hits from the misses.

Beyond the Reset Password endpoint, there are several other common locations where Username and Email Enumeration can appear. The Registration endpoint is a frequent target — when you try to register with an email that is already taken, many applications will say "This email address is already registered" or "An account with this email already exists." A registration flow that gives a different error for a duplicate email versus a genuinely new email is leaking registration status, allowing enumeration of the entire user base simply by trying to register with candidate email addresses. The Login endpoint can also leak this information — some applications return "Email not found" for a non-existent address and "Incorrect password" for an existing one with the wrong password. This is arguably more severe than the Reset Password case because the login page is the entry point an attacker would target first. The Username Search or Autocomplete feature is another vector — many platforms have a search or @-mention system that suggests usernames as you type, and if that endpoint doesn't require authentication or has weak access controls, it can be used to enumerate all registered usernames. The OTP Verification endpoint can sometimes enumerate phone numbers — if the application responds differently when you request an OTP for a phone number that is not registered versus one that is, that difference is enumeration.

Timing-based enumeration is a more subtle variant that you should be aware of, because some applications try to return identical response messages regardless of whether the account exists, but fail to handle the timing consistently. The difference in response time between an existing and non-existing account can be measurable. When an email exists, the application runs additional logic — it fetches the user record, generates a token, sends an email — which takes more time. When the email doesn't exist, the application immediately returns a response (even if the response message is identical to the success case). A consistent timing difference of even 100 to 200 milliseconds between the two cases can be enough to reliably enumerate accounts, particularly when tested at scale where the timing signal accumulates. Burp Suite's Intruder records response times for every request in an attack, so you can sort results by response time to identify which addresses likely exist even when the response bodies are identical. This timing oracle technique has been used to find enumeration vulnerabilities on applications that were otherwise considered well-hardened against this class of issue. If you notice that identical response bodies nevertheless have consistent timing differences across your test cases, that is worth noting in your report even if the response-based enumeration doesn't work.

The impact of Username and Email Enumeration scales with the platform and what else is possible. On a small internal tool, enumerating usernames might be low severity. On a large consumer platform with millions of users — a healthcare app, a financial services platform, a mental health application — the fact that an attacker can determine whether a specific person has an account has significant privacy implications. Knowing that a person has an account on a mental health app, an HIV support forum, or an addiction recovery platform is sensitive personal health information even if the attacker never accesses their account. Programs in regulated industries often treat enumeration that reveals membership in a sensitive category as high severity precisely because of these privacy implications. For bug bounty purposes, always consider what the platform is about when you assess severity. Beyond standalone privacy impact, the attack chain value is significant: a confirmed list of valid email addresses enables all of the following downstream attacks — password brute-force using common password lists, credential stuffing attacks using leaked password databases, targeted spear-phishing with platform-specific lures, OTP brute-force on two-factor authentication flows, and social engineering attacks that leverage insider knowledge of a victim's account existence.

When you are testing for Username and Email Enumeration in practice, your Burp Suite workflow should follow a structured approach. First, visit the Reset Password page and manually test two cases: an email address you know doesn't exist (like random_nonexistent@test.com) and your own test email address that is registered. Compare the two responses carefully — response body, response code, response length, and response time. If any of these differ between the two cases, you have confirmed enumeration. Second, to demonstrate scale in your PoC, capture the Reset Password request in Burp Suite and send it to Intruder. Set the email parameter as the injection point and use a small wordlist of test email addresses (10 to 20) where you know some are registered (your test accounts) and some are not. Run the attack and show in a screenshot that the responses clearly differ between the two groups. This demonstrates the vulnerability conclusively without requiring you to enumerate thousands of real users, which would be both unnecessary and potentially outside the scope of safe testing. Third, in your report, describe exactly how the responses differ, what an attacker would do with the resulting list of valid addresses, and what the downstream impact could be — especially if you have also identified No Rate Limiting or Race Condition on the same endpoint.

The fix for Username and Email Enumeration is well-understood and straightforward to explain in a bug report: the application should always return the same response — same message, same HTTP status code, same response time — regardless of whether the submitted identifier exists in the database. The standard secure message for a password reset form is something like "If an account with that email exists, a reset link has been sent." This message is identical whether the account exists or not, so an attacker learns nothing from the response. Achieving consistent response timing requires more careful implementation — the developer needs to ensure that the "account not found" code path takes approximately the same time as the "account found" path, often by performing a dummy database lookup or inserting an artificial delay so that the two paths execute in similar time. Explaining this fix clearly in your report — including the timing-side-channel mitigation — demonstrates that you understand the vulnerability at a technical depth that programs appreciate. The 12 HackerOne reports in the syllabus — 666722, 1166054, 223531, 806151, 280509, 123496, 90308, 1439026, 209008, 2032716, 187714, and 2586616 — cover enumeration findings across a range of endpoints and applications, and studying how those hunters structured their reports will directly improve your own.

To bring everything together — in Topic 20 we have covered Username and Email Enumeration, which occurs when an application leaks whether a submitted identifier exists in its user database through different response messages, status codes, response lengths, or response times. The primary testing location is the Reset Password endpoint, though Registration, Login, OTP verification, and Username Search endpoints can all exhibit this vulnerability. Testing methodology involves manually comparing responses for known-existing versus known-nonexistent identifiers, then automating with Burp Intruder to demonstrate scale. Timing-based enumeration applies when response bodies are identical but timing differs. Severity scales with platform sensitivity — health, financial, and other regulated platforms treat enumeration as higher impact due to privacy implications. The chain value is significant: enumerated valid accounts feed directly into No Rate Limiting brute-force and Race Condition OTP bypass for full account takeover. The fix is identical responses regardless of account existence, with timing equalization. The 12 HackerOne reports in the syllabus cover real examples across multiple endpoint types. I will see you in Topic 21!

Topic 21 — Exploiting Default Credentials

Welcome to Topic 21 — Exploiting Default Credentials. This topic is one of the most practically impactful in the entire KPWAPT course because the technique is straightforward, the findings can be critical severity, and the attack surface is far larger than most hunters initially expect. Default credentials are usernames and passwords that come pre-configured in software systems — routers, cameras, admin panels, content management systems, monitoring dashboards, database management tools, and web frameworks all commonly ship with default login credentials that administrators are supposed to change on first use but frequently don't. Beyond factory defaults, this topic also covers a related and very common scenario: applications that have administrator or staff accounts where the password was set to something predictable based on the company name, product name, or domain. The methodology in the syllabus is built around a two-phase attack: first, collect the email addresses associated with the login page you are targeting, using the emailextractor tool; second, attempt to authenticate using a wordlist of likely passwords constructed from the company's own branding. This approach turns OSINT — publicly visible email addresses and company names — into targeted credential guesses that are far more likely to succeed than generic wordlists. When it works, you are looking at critical severity: full administrative access to the application, with no further exploitation required.

The emailextractor tool is the first tool in the syllabus workflow for this topic. Its job is to scan a website and extract all email addresses it finds — in page content, in contact pages, in privacy policies, in responsible disclosure pages, in source code, and in meta tags. The syllabus example shows running emailextractor against moviexchange.com and immediately finding seven unique email addresses across multiple pages: privacy-related contacts, a DPO address, a security contact, and a marketing address. This is significant because those email addresses are the most likely candidates for active admin accounts on the platform. An address like security@moviexchange.com or admin@moviexchange.com might be used by the security team or IT administrators who have access to the application's admin panel. If you find a login page at film.moviexchange.com/login that asks for email and password, your first credential attempts should use the email addresses you collected from the main site. This is not a blind attack — you are targeting accounts that very likely exist and belong to people who actually manage the platform.

Once you have your target email addresses, the password wordlist strategy is what separates a professional approach from a generic brute-force attempt. The syllabus gives a concrete example for moviexchange.com: the natural password candidates are variations of the company name and domain — moviexchange123, moviexchange1234, moviexchange@123, moviexchange@1234. Many non-technical administrators set passwords following a simple pattern: the company or product name, followed by a number or symbol combination. This reflects a very common human tendency to choose memorable passwords that are easy to type but feel secure because they contain a capital letter or number. Beyond the company-name pattern, the syllabus recommends using the thorfinn tool to generate a custom wordlist. Thorfinn was introduced in Topic 08 for generating fuzzing wordlists from website content, and the same logic applies here — it crawls the target site and extracts words, names, and phrases that are semantically associated with the target. Product names, service names, taglines, and proper nouns from the site become candidates for the password wordlist. A 500-word custom list built from the target's own content will frequently outperform a generic million-entry password list because it targets the specific vocabulary administrators at that organization are most likely to use.

When the login page uses a username field rather than an email field, the default credential strategy shifts to well-known generic defaults. The syllabus lists the three most universal default credential pairs: admin:admin, admin:password, and root:root. These are the defaults shipped with an enormous number of web applications, router firmware, database management interfaces, and content management systems. Jenkins, for instance, historically had no authentication at all by default — discovered Jenkins instances at the URLs in Topic 27 (the RCE topic) are sometimes completely open. phpMyAdmin instances are sometimes accessible with root and no password. Kibana dashboards were famously open by default for years, requiring no credentials at all. When you find any administrative interface — via your directory fuzzing from Topic 08, your historical URL analysis from Topic 07, or through the dorking from Topic 09 — the first thing you should do before anything else is try these default credential pairs. The time investment is seconds, and the potential reward is full admin access. It is one of the highest return-on-investment checks in all of bug bounty, and skipping it even once has caused hunters to miss critical findings they would have found in under a minute.

The automation workflow for Default Credentials testing at scale uses Burp Suite Intruder in a cluster bomb or pitchfork mode — testing multiple username and password combinations simultaneously. The syllabus instructs you to collect email addresses first, then brute-force passwords in Burp Suite. In practice, you capture the login request, send it to Intruder, and set both the username and password fields as injection points. You then load your email list as the first payload and your company-name password wordlist as the second. Cluster bomb mode tests every combination of username and password — if you have five email addresses and ten password candidates, it will make 50 requests, each with a different combination. You then look for responses with a significantly different length or status code — a successful login will typically return a redirect (302) to the dashboard, while failed attempts return a 200 with the login form again. Some applications also return a session cookie only on successful login, which will be visible in the response headers in Intruder's results view. Always ensure the application doesn't have account lockout before running this — a few manual attempts first will tell you whether failed logins are tracked. If lockout is present, you may need to limit attempts per account or use the Race Condition technique from Topic 18 to compress your attempts within a small time window.

The responsible disclosure page is worth checking specifically because it often contains the security team's email address — people who by definition have administrative access and are likely to use their work email for the admin account. The syllabus references moviexchange.com/responsible-disclosure-policy explicitly, noting that the security contact email security@movieXchange.com was found there by emailextractor. This is not a coincidence — the syllabus workflow intentionally starts with the responsible disclosure page because that page is reliably public and reliably contains at least one contact email that belongs to someone with elevated platform access. Privacy policy pages, terms of service pages, and "About Us" pages are similarly reliable sources of contact email addresses. For the admin panel login at hpwwma.org.in/AdminLogin.aspx, the same logic applies — you would first run emailextractor against the main domain to find likely admin email addresses, then construct a password wordlist from the organization name, and then test those combinations using Burp Suite Intruder. The .aspx extension also tells you this is an ASP.NET application, which might suggest additional default credential patterns from Microsoft-based systems.

Exploiting Default Credentials findings are typically critical severity when they succeed, because the impact is full administrative access rather than a theoretical vulnerability. When you are writing the bug report, you must be careful about how you document proof without overstepping ethical boundaries — you should show that login succeeded (a screenshot of the dashboard URL and the session you were granted) but you should not take any further actions in the admin panel, access user data, or make any changes. The report should include which credential pair worked, which login URL it was tested against, a screenshot demonstrating successful authentication, and an explanation of what access was granted. For programs that have a responsible disclosure or bug bounty policy, this is among the most valuable reports you can submit, and the 13 HackerOne reports in the syllabus — 2160178, 1415241, 1938693, 1267174, 1397786, 753602, 1297480, 1063298, 1700896, 1677047, 2262365, 684758, and 1839012 — show exactly how hunters reported and were rewarded for this type of finding across a range of programs and contexts.

To bring everything together — in Topic 21 we have covered Exploiting Default Credentials, a critical-severity vulnerability class that occurs when applications retain factory-default or easily guessable passwords on administrative accounts. The workflow has two phases: phase one uses the emailextractor tool to collect email addresses from the target's public pages (especially responsible disclosure, privacy, and contact pages); phase two uses those emails with a custom company-name password wordlist (generated partly with thorfinn) to attempt login via Burp Suite Intruder. For username-based login panels, universal defaults — admin:admin, admin:password, root:root — must always be tried first before any other technique. Many administrative interfaces (Jenkins, Kibana, phpMyAdmin, router admin panels, monitoring dashboards) have well-known defaults that remain unchanged in real deployments. The return on investment is among the highest of any technique in the course — seconds of effort for potential critical findings. Reports should demonstrate successful authentication without accessing or modifying any data. The 13 HackerOne reports in the syllabus cover real successful finds across a variety of application types. I will see you in Topic 22!

Topic 22 — SQL Injection

Welcome to Topic 22 — SQL Injection, one of the oldest, most studied, and still most impactful vulnerability classes in web security. SQL Injection has been on the OWASP Top 10 list since its very first edition, and despite decades of awareness, it continues to be found in production applications around the world every single day. The core concept is that many web applications build database queries by directly concatenating user-supplied input into SQL query strings, without properly separating data from code. When an application takes your input and places it directly into a query like SELECT * FROM users WHERE id = {user_input}, and you supply a value like 1' (1 followed by a single quote), the resulting query becomes SELECT * FROM users WHERE id = 1' — which is syntactically broken SQL that causes the database to throw an error. If that error appears in the response, you have confirmed that the application is not sanitizing its database queries and SQL Injection is likely possible. The two most common types in the syllabus are Error-based SQLi and Time-based SQLi. Error-based SQLi means the database error message appears directly in the HTTP response, confirming injection immediately. Time-based SQLi means the application doesn't show errors, but you can inject a time-delay payload like SLEEP(5) and measure whether the response takes 5 seconds longer than normal — the delay confirms injection even when no visible output is available.

The URL parameters where SQL Injection most commonly appears form a long and important list in the syllabus, and you should recognize all of them on sight. The highest-priority parameters are id=, cat=, select=, report=, role=, update=, query=, user=, name=, sort=, where=, search=, params=, process=, row=, view=, table=, from=, sel=, results=, sleep=, fetch=, order=, keyword=, column=, field=, delete=, string=, number=, filter=, and location-related parameters like longitude=, city_id=, item_id=, comment_id=, and last_content_id=. Any parameter name that suggests it is used for database filtering, sorting, or retrieval is worth testing. The simple test is appending a single quote ' to the parameter value. If the response changes — an error page, a blank page, a different result set, or a database error message — that change confirms the input is reaching the database without sanitization. For your URL list from Topic 07, you should filter specifically for URLs that contain these parameter names and prioritize them for SQL Injection testing before moving on to other vulnerability classes.

The locations beyond URL parameters where SQL Injection commonly hides are listed clearly in the syllabus: Signup pages, Login pages, Forgot Password, Reset Password, Recovery Forms, and Create Ticket. These are form-based POST request endpoints rather than GET request URL parameters, and they are worth testing specifically because they tend to receive less scrutiny from developers who are focused on protecting "data display" endpoints. A signup form that accepts a username, email, and password might query the database to check whether the username is already taken — and that check query might not be parameterized. A login form that accepts email and password might construct a query like SELECT * FROM users WHERE email='{email}' AND password='{password}' — a classic SQL Injection target where injecting ' OR '1'='1 as the email might bypass authentication entirely. The forgot password and reset password flows take email or username as input and query the database to find the user record — another injection point that is often overlooked because it doesn't seem like a "dangerous" endpoint. Support ticket creation can also store user input in a database in ways that later get read back by an admin interface, potentially enabling second-order SQL Injection — where your payload is stored safely but then executed unsafely when it is retrieved and used in a later database query.

HTTP headers are another SQL Injection surface that many hunters miss entirely, and the syllabus explicitly calls them out. The headers to test are Cookie, User-Agent, Referer, and X-Forwarded-For. Many applications log or store these header values in the database — for analytics, security monitoring, or personalization. If a developer wrote a query like INSERT INTO visits (user_agent, ip) VALUES ('{user_agent}', '{x_forwarded_for}') and stored those values directly from the request headers, then injecting a single quote or SQL payload into those headers can cause a SQL error or time delay. The syllabus example shows injecting into Cookie: with id=1' and into X-Forwarded-For with just '. When you capture any interesting request in Burp Suite, try appending a single quote to the Cookie value, the User-Agent string, the Referer header, and the X-Forwarded-For header one at a time and watch for error responses or timing delays. This is low-effort and high-reward — these injection points are so often overlooked that many applications that have perfectly parameterized their URL parameters and form fields remain vulnerable through header injection, since the developers never considered those headers as user-controlled input reaching the database.

The detection payloads for SQL Injection are listed in the syllabus: a single quote ', two single quotes '', a double quote ", combinations like '" and \", arithmetic operators + and -, a wildcard *, square brackets [], and closing parenthesis combinations like '), ')), '"))), ')-, and the escape sequence \\\". The semicolon ; is also listed as a detection character. These payloads work by injecting characters that have special meaning in SQL — if the application doesn't escape them, they break the query syntax and produce an error or unexpected behavior. The philosophy of detection testing is: inject characters that would cause a syntax error in SQL, then observe whether the application's response changes in any way — a different HTTP status code, a different response body, an error message, or a different response time. Any of those changes indicates that your input reached the database query and affected its execution. The reference wordlist in the syllabus for time-based SQLi payloads contains the more specific exploitation payloads you would use after confirming injection, targeting various database systems including MySQL, PostgreSQL, MSSQL, and SQLite with their respective time-delay functions.

Sqlmap and Ghauri are the two primary automation tools for SQL Injection in the syllabus. Sqlmap is the industry-standard open-source tool that has been maintained for over 15 years and supports virtually every SQL Injection technique and database system. The key flags in the syllabus command are --random-agent (to avoid detection based on the user-agent), --level 5 (the highest testing level, which tests more injection points including headers), --risk 3 (the highest risk level, which uses heavier payloads that might affect data), --dbs (to enumerate all databases), --time-sec=12 (setting the time delay threshold for time-based detection), and --flush-session (to start fresh rather than using cached results). Ghauri is a newer alternative to sqlmap that uses similar syntax and is sometimes faster or more reliable on specific targets. Both tools accept either a URL with the -u flag or a saved request file with the -r flag — saving the request in Burp Suite and passing it to sqlmap with -r req.txt is the most reliable method because it ensures all headers, cookies, and POST data are preserved exactly. For targets protected by IP-based blocking, proxychains can route sqlmap requests through SOCKS proxies to rotate the source IP between requests.

The five additional injection techniques in the syllabus cover less obvious SQLi vectors. Injecting the SQL payload as part of the parameter name rather than the value — changing artist=1 to artistSQLPAYLOAD=1 — exploits cases where the query uses the parameter name directly. Injecting into .php, .aspx, .asp, .jsp filename segments themselves — changing /login.php to /SQLPAYLOAD.php — targets path-based query construction. The User-Agent injection technique references HackerOne report 297478 specifically, where a hunter found SQL Injection via the User-Agent header. Injecting a wildcard * as the User-Agent value and injecting into X-Forwarded-For are both explicitly listed. Putting payloads in all visible input fields on a form — not just the ones that seem most likely — is the final instruction. The automation tools sqlifinder and gosqli can test URL lists at scale for SQL Injection indicators, and the two custom nuclei templates in the syllabus (error-based-sqli.yaml and error-based-sqli-replace.yaml) integrate SQLi detection into the nuclei scanning workflow you already learned in Topic 05. These templates let you run SQL Injection checks across your entire httpx.txt list simultaneously, dramatically expanding your coverage per unit of time.

To bring everything together — in Topic 22 we have covered SQL Injection, which occurs when unsanitized user input is concatenated into database queries rather than passed as parameterized values. The two primary types are Error-based (visible database errors confirm injection) and Time-based (SLEEP payloads confirm blind injection). URL parameters are the main surface — 30-plus parameter names from the syllabus signal database interaction. Form-based endpoints (signup, login, password reset, ticket creation) are the second major surface. HTTP headers — Cookie, User-Agent, Referer, X-Forwarded-For — are the most overlooked surface and should always be tested. Detection begins with a single quote; confirmation uses time-delay payloads. Sqlmap and Ghauri automate exploitation with the -r req.txt flag preserving all request details; proxychains rotates IPs against rate-limited targets. Five additional techniques — parameter-name injection, filename injection, all-fields testing, header injection — expand coverage. Sqlifinder, gosqli, and nuclei templates bring SQL Injection testing to pipeline scale. The 28-plus HackerOne reports in the syllabus cover the full range. I will see you in Topic 23!

Topic 23 — Cross-Site Request Forgery (CSRF)

Welcome to Topic 23 — Cross-Site Request Forgery, almost always shortened to CSRF. The syllabus gives us a sharp and precise definition: CSRF happens when an attacker tricks a logged-in user into performing an action without their consent. The attack chain is: user is logged in, attacker sends a malicious link, action is executed. Let me unpack why this works at a technical level, because understanding the mechanism is essential for both finding and explaining CSRF vulnerabilities. When you are logged into a web application, your browser holds a session cookie that the server uses to identify you. Every time your browser makes a request to that application's domain — whether you initiated that request or not — your browser automatically attaches the session cookie to the request. This is how HTTP works by design. CSRF exploits this behavior: an attacker hosts a page on a completely different domain (say, evil.com) that contains a hidden form targeting the victim application. When the logged-in victim visits evil.com (by clicking a link in an email, a social media post, or a chat message), their browser automatically submits the hidden form to the victim application, and because their session cookie is automatically included, the application believes the action was intentionally performed by the legitimate user. The server cannot tell the difference between a request the user meant to make and one the attacker forced them to make — both carry the same valid session cookie.

The actions where CSRF is most impactful are specifically the ones that change something sensitive about a user's account. The syllabus lists six high-priority targets: Change Password, Change Email, Update Profile, Add or Delete Users, API Key Generation, and Enable or Disable Two-Factor Authentication. Think carefully about why each of these matters. If an attacker can force a victim to change their email address to one the attacker controls, the attacker then has access to the password reset flow for that account — a chain that leads directly to account takeover. If an attacker can force the victim to disable their two-factor authentication, the attacker can then use a stolen or guessed password to log in without needing the second factor. If an attacker can force the victim to generate a new API key while simultaneously capturing that key (which the attacker's page might be able to read via a cross-origin resource sharing misconfiguration), the attacker has programmatic access to the victim's account via the API. CSRF on account deletion or user removal can be weaponized for sabotage — forcing an admin to delete other users or critical data. Each of these targets represents a scenario where forcing a single authenticated action produces lasting damage to the victim's account or organization.

The vulnerable request structure in the syllabus is a POST request to /change-email that carries only the Cookie header for authentication and the new email address in the POST body. The key observation is: if the server accepts this request and changes the email based solely on the session cookie — without any additional token proving the request was intentionally generated by the legitimate application's own form — then the endpoint is CSRF vulnerable. The standard defense against CSRF is a CSRF token: a secret, random, unpredictable value that is embedded in the HTML form by the server and must be submitted with every state-changing request. Because the CSRF token is tied to the user's session and is not accessible to other origins (thanks to the browser's Same-Origin Policy), an attacker's page on evil.com cannot read the legitimate form's CSRF token and therefore cannot forge a valid request. When you are testing for CSRF, the first thing you look for in a POST request to a sensitive action endpoint is whether there is a CSRF token in the request body or headers. If there is no such token, the endpoint is likely vulnerable. If there is a token, you should test whether it is actually validated — sometimes developers add the token field but forget to check it on the server side.

The Proof of Concept HTML for CSRF in the syllabus is elegantly simple and should be in every hunter's toolkit. The structure is: an HTML form with action set to the vulnerable endpoint, method="POST", and hidden input fields containing the malicious values. A JavaScript snippet immediately below the form calls document.forms[0].submit() to auto-submit the form as soon as the page loads. The victim visits the page, sees nothing (the form is invisible), and within milliseconds their browser has submitted a POST request to the target application with the attacker's desired values. This PoC format is important for your bug reports because it makes the vulnerability immediately reproducible and visually clear to triage — the reviewer can open your HTML file in a browser while logged into the target, and they will see the action execute in front of them. When you are building a CSRF PoC, always replace the action URL with the full absolute URL including the protocol and domain, set the hidden input names and values to match the actual request you captured in Burp Suite, and host the PoC file locally (via a local HTTP server) so it executes from a different origin than the target — this ensures you are actually demonstrating a cross-origin attack rather than a same-origin form submission.

CSRF testing methodology in Burp Suite follows a consistent workflow. For every POST request to a sensitive endpoint that you capture in HTTP History, right-click and select "Engagement Tools → Generate CSRF PoC." Burp Suite will automatically generate a complete HTML PoC file for that request, including all parameter names and values. You then open that file in a browser while logged into the target, and you observe whether the action executes successfully. If it does, you have confirmed CSRF. If the endpoint has a CSRF token, Burp Suite's PoC generator will include that token's current value in the form — to properly test whether the token is truly required, you need to remove the token field from the PoC and test whether the request still succeeds without it. If removing the token does not break the action, the token is not actually being validated. You should also test whether a token from one user's session is accepted for another user's session, whether an entirely empty token value is accepted, and whether a token that was generated in a previous session but never used remains valid — each of these represents a broken implementation of an otherwise-present CSRF protection.

There are important limitations and edge cases that affect CSRF exploitability, and you need to understand them to write accurate reports. SameSite cookie attributes have significantly reduced the exploitability of CSRF in modern browsers. When a cookie has the SameSite=Strict or SameSite=Lax attribute, browsers will not send it on cross-site requests, which effectively prevents traditional CSRF attacks. If the target application's session cookie has SameSite=Strict, CSRF is not exploitable in modern browsers even without a CSRF token, because the session cookie won't be sent. If it has SameSite=Lax, POST-based CSRF is still prevented, but GET-based state changes might still be vulnerable (since top-level navigations with GET do carry Lax cookies). If the cookie has no SameSite attribute or SameSite=None, the application is fully relying on CSRF tokens or other controls for protection. When you are testing, always check the Set-Cookie response header to see which SameSite value is used, and note it in your report. A CSRF finding on an endpoint where the session cookie has no SameSite attribute and no CSRF token is more impactful than one where SameSite=Lax is set, since the former affects all browsers while the latter only affects older browsers or specific navigation scenarios.

CSRF can also be chained with other vulnerabilities for compounded impact. The most common chain is CSRF combined with XSS — if you find a stored XSS vulnerability in a user-visible field on the same application, you can use the XSS payload to exfiltrate the victim's CSRF token and then use that token to forge a valid CSRF-protected request. This chain has been responsible for critical account takeover findings on well-secured platforms that had proper CSRF tokens but had not addressed XSS in content fields. CSRF combined with clickjacking is another chain — if the target site can be embedded in an iframe, an attacker can trick a victim into clicking what they believe is a game or survey button while they are actually clicking the "Delete Account" or "Transfer Funds" button on the overlaid application page. The 8 HackerOne reports in the syllabus — 834366, 339352, 1122408, 177508, 1890310, 2712857, 1668489, and 1118521 — cover CSRF findings across a range of sensitive endpoints and will show you how hunters structured their PoCs and what impact levels were assigned for different target actions.

To bring everything together — in Topic 23 we have covered Cross-Site Request Forgery, which exploits the browser's automatic attachment of session cookies to force a logged-in user to perform actions without their consent. The mechanism relies on the browser's Same-Origin behavior for cookies — the server cannot distinguish a user-initiated request from an attacker-forced one when both carry the same session cookie. The six highest-impact targets are Change Password, Change Email, Update Profile, Add or Delete Users, API Key Generation, and Enable or Disable 2FA. Testing methodology uses Burp Suite's "Generate CSRF PoC" feature to quickly produce and test self-submitting HTML forms against sensitive endpoints. Token validation should always be probed — tokens that exist but aren't actually checked are common. SameSite cookie attributes affect exploitability in modern browsers and must be noted in your report. CSRF chains with XSS for token exfiltration and with clickjacking for invisible interaction produce compounded impact. The 8 HackerOne reports in the syllabus cover the range. I will see you in Topic 24!

Topic 24 — Insecure Direct Object Reference (IDOR)

Welcome to Topic 24 — Insecure Direct Object Reference, universally known as IDOR. IDOR is a specific and extremely common subcategory of the Improper Access Control vulnerability we covered in Topic 13, and it deserves its own dedicated topic because it has a distinct discovery pattern, a distinct attack surface, and has produced more bug bounty payouts across more programs than almost any other vulnerability class. The name tells you everything about the mechanism: "Insecure Direct Object Reference" means the application uses a user-supplied value — typically a numeric ID, a UUID, a filename, or some other object identifier — to directly reference a database record or file, and it does not properly verify whether the requesting user is authorized to access that specific object. When you are logged into an application and you access your own invoice at /invoices/5847, that 5847 is a direct reference to an object in the database. If you change 5847 to 5848 and the application returns someone else's invoice without asking "does the requesting user own invoice 5848?", that is IDOR. The critical insight that separates IDOR from other access control issues is that the identifier itself is user-controlled and directly references a backend object — the access control check is missing at the point where the object is fetched. This makes IDOR both easy to find (you can test it by simply changing a number in a URL) and very common (developers often forget to add ownership checks when they know their own UI only ever sends valid IDs).

It is important to understand the relationship between IDOR and Improper Access Control so you can discuss both accurately. All IDOR is Improper Access Control, but not all Improper Access Control is IDOR. Improper Access Control (Topic 13) is the broad category — it includes horizontal escalation (accessing other users' resources at the same privilege level), vertical escalation (accessing admin functionality from a regular account), API authorization gaps, and JWT manipulation. IDOR is specifically the horizontal escalation variant where the attack vector is manipulating an object identifier in the request. The identifier can appear anywhere in the request: in the URL path (/messages/9012), in a query parameter (?order_id=5847), in a POST body field ({"user_id": 1001}), in a JSON API request body ({"document_id": "abc-123"}), in a form field (<input name="account_id" value="77">), or even in a request header. Wherever a request contains an identifier that maps to a specific database object, and wherever the server uses that identifier directly without verifying the requesting user's ownership, IDOR is potentially present. This means IDOR testing is not just a URL-scanning exercise — you must examine every request that contains any kind of identifier, including POST bodies and JSON payloads.

The types of identifiers you will encounter in IDOR testing vary widely, and each has its own implications. Sequential integers — like id=5847 — are the most common and the easiest to exploit because you can simply increment or decrement the value to access adjacent records. The fact that IDs are sequential also means you can determine roughly how many records exist in the database and enumerate them systematically. UUIDs (Universally Unique Identifiers, like 550e8400-e29b-41d4-a716-446655440000) are sometimes considered "secure by obscurity" because they are hard to guess — but as we discussed in Topic 13, obscurity is not security. If the UUID appears in a URL, in another user's shared link, in an API response you can access, or through any other information disclosure channel, you can test it for IDOR. Base64-encoded identifiers — where the ID looks like dXNlcl9pZD0xMDAx — are another common pattern. These are not encrypted and not signed; they are just the identifier encoded in a different format. Decoding a base64 value in Burp Suite's Decoder tab often reveals a plain integer or a simple key-value string that you can modify and re-encode for testing. Hashed IDs — where the identifier appears to be an MD5 or SHA hash — might be generated from a predictable value like a sequential integer, in which case you can compute the hash of nearby integers and test those.

The Google dork in the syllabus — inurl:"id=1" — is a simple but effective way to find web applications with sequential numeric ID parameters that are potentially vulnerable to IDOR. Searching for inurl:"id=1" on Google returns pages whose URLs contain the string id=1 — these are applications that use a numeric id parameter to identify a specific database record. When combined with a site: modifier targeting a specific program's domain, this dork instantly surfaces candidate IDOR endpoints on that target. The same logic applies to other parameter names — you can substitute user_id=, order_id=, invoice_id=, account_id=, or any of the other parameter names from Topic 22's SQLi list to find additional IDOR candidates. Any URL that contains a parameter whose value looks like a sequential integer or a UUID is a potential IDOR target, and when you are working through your URL list from Topic 07, you should filter specifically for these patterns as a first-pass IDOR prioritization. The URLs in your list that contain id=, _id=, user=, account=, or document= followed by a number should all go into an IDOR testing queue before you move on to other vulnerability types.

The highest-value IDOR targets are those that expose or modify private data belonging to other users. File download endpoints are among the most impactful — a request like GET /api/documents/DOC_ID/download that returns the file content without verifying ownership can expose private contracts, medical records, financial statements, or personal identification documents. Order and invoice history endpoints — GET /orders/ORDER_ID — can reveal purchase history, home addresses, payment method details, and pricing information. User profile endpoints — GET /users/USER_ID/profile — can expose private profile data including contact information, date of birth, payment details, and account metadata. Messaging endpoints — GET /conversations/CONV_ID or GET /messages/MSG_ID — can expose private communications between other users. Administrative or staff-visible records — support ticket content, user account details, internal notes — can sometimes be accessed via IDOR on API endpoints intended only for admin use. Write IDORs — where changing an ID allows you to modify or delete someone else's data — are even higher severity than read IDORs, because they allow active harm: deleting another user's content, modifying their profile information, changing their account settings, or canceling their orders.

The two-account testing method from Topic 13 applies directly and completely to IDOR testing. You create two accounts — Account A and Account B — and you use Account A to perform actions and generate objects (place orders, upload documents, send messages, create tickets). Each of these actions produces identifiers in the application's responses that belong to Account A. You then switch to Account B's session in Burp Suite and try to access those same identifiers. If the application returns Account A's data to Account B's requests, IDOR is confirmed. The Burp Suite Authorize extension automates this process — it intercepts all requests from Account A's session and automatically retries them using Account B's cookie, flagging responses that differ from what Account B should be able to see. For testing write operations — modifying or deleting another user's object — always use objects that belong to your own test Account A and test modification from Account B, so that if the IDOR allows the modification to succeed, you are only affecting your own test data. Never test write IDORs on real user objects in a live program — always use objects you created and own in both test accounts.

IDOR in API responses is worth its own discussion because modern applications frequently embed identifiers in API responses that are then used in subsequent requests. When you intercept an API response in Burp Suite, look carefully for any fields that contain integers, UUIDs, or hashes that look like they might reference database objects. These might be user IDs, resource IDs, relationship IDs, or internal reference numbers. When you see these in a response, the natural follow-up question is: is there an API endpoint that accepts this ID as input and returns more data about the referenced object? If you can find that endpoint and access objects by substituting IDs from other users' records, you have IDOR. IDOR in GraphQL APIs deserves special mention — GraphQL queries often take IDs as arguments, and each object type in a GraphQL schema typically has its own resolver that might not consistently check authorization. Testing IDOR across all object types in a GraphQL schema by substituting IDs between accounts can surface findings that simpler tools would miss entirely. The 24 HackerOne reports in the syllabus — 2487889, 3154983, 950881, 3401612, 2528293, 1403176, 1592596, 1323406, 2028450, 2374730, 291721, 1372216, 2483666, 156537, 1695454, 974222, 2207248, 1608735, 1272478, 2586641, 287789, 2218334, 1182465, and 2442008 — cover IDOR findings across a remarkable range of endpoints, data types, and severity levels, and studying them will cement your intuition for where these vulnerabilities hide.

To bring everything together — in Topic 24 we have covered Insecure Direct Object Reference, a subcategory of Improper Access Control where user-controlled identifiers directly reference backend objects without ownership verification. Identifiers can appear in URL paths, query parameters, POST bodies, JSON payloads, and form fields. Types include sequential integers (most exploitable), UUIDs (exploitable when obtainable), base64-encoded values (decodable and modifiable), and hashed IDs (sometimes predictable). The Google dork inurl:"id=1" surfaces candidate endpoints at scale. High-value targets are file downloads, orders and invoices, user profiles, messages, and admin-visible records. Write IDORs (modify or delete other users' objects) are higher severity than read IDORs. The two-account method with Burp Suite Authorize automates systematic testing. IDOR in API responses and GraphQL schemas requires reading responses carefully for embedded identifiers. Never test write IDORs on objects you don't own. The 24 HackerOne reports in the syllabus span the full range of IDOR findings across different platforms and contexts. I will see you in Topic 25!

Topic 25 — Privilege Escalation

Welcome to Topic 25 — Privilege Escalation. If you have been following the KPWAPT course in order, this topic will feel deeply familiar because we have already touched on it in Topic 13 (Improper Access Control) and Topic 24 (IDOR). Privilege Escalation is the overarching concept that ties those topics together and gives them their attack narrative. Where Topic 13 introduced horizontal and vertical escalation as properties of access control failures, and where Topic 24 showed how object reference manipulation achieves horizontal escalation specifically, this topic goes deeper into the full spectrum of privilege escalation techniques — particularly vertical escalation, where you move from a low-privilege account to a high-privilege one. Privilege Escalation in the web context means gaining access to functionality, data, or actions that your current account level should not be able to reach. The two types are always the same: horizontal escalation means accessing another user's data or actions at the same privilege level (what IDOR exploits), and vertical escalation means accessing admin-level functionality or data from a regular user account. This topic focuses on the techniques, signals, and tools that specifically target vertical escalation — the highest-impact flavor of privilege escalation, where a successful attack gives you full administrative control over the platform.

The first and most direct technique for vertical privilege escalation is parameter tampering — looking for role or privilege-related values in HTTP requests and manipulating them. Many applications pass user role information in ways that the client can control, which is a fundamental design mistake. When you are intercepting requests in Burp Suite, you should look for parameters like role=user, user_type=standard, is_admin=false, admin=0, permission=read, or account_type=free. Any parameter whose value encodes your privilege level is a target for tampering — change role=user to role=admin, is_admin=false to is_admin=true, admin=0 to admin=1. If the server accepts these values and grants elevated access based on them without verifying against its own authoritative record of your privilege level, you have confirmed vertical privilege escalation. These parameters can appear in GET parameters, POST bodies, JSON request bodies, and form fields. They can also appear in cookies — some applications store role information in a cookie value that the browser sends with every request, and if that value is not cryptographically signed or verified, changing it in Burp Suite's Match and Replace rule or in the Cookie editor might grant admin access.

Mass assignment vulnerabilities are a closely related technique that specifically targets API endpoints that accept JSON or form data for updating user records. The concept is that many web frameworks — Rails, Laravel, Django, Spring — have features that automatically map incoming request parameters to model attributes. When a developer creates a user update endpoint and forgets to restrict which attributes can be set via the API, an attacker can include extra parameters in the request body beyond what the form normally sends. If a PUT request to /api/users/1001 normally only accepts {"name": "Alice", "email": "alice@example.com"}, but the underlying user model also has a role field or an is_admin field, then including {"name": "Alice", "email": "alice@example.com", "role": "admin"} in the request body might silently update your role to admin if the developer forgot to whitelist which fields are allowed to be updated via this endpoint. This is why mass assignment has been responsible for critical privilege escalation findings on many major platforms — the vulnerable code path is not obvious from reading the documentation, and the extra field simply gets written alongside the legitimate ones without any error. Testing for mass assignment means systematically adding role and privilege-related fields to every update request you can find and observing whether your privilege level changes.

Hidden admin endpoints are another major vertical escalation surface. Many applications have admin panels, management interfaces, staff dashboards, and internal APIs that were never intended to be publicly accessible but are reachable by any authenticated user because the developer relied on "security through obscurity" — hiding the link rather than enforcing authorization at the server. Your directory fuzzing from Topic 08 (using admin-panel-paths.txt and similar wordlists) is specifically designed to find these hidden endpoints. Paths like /admin, /admin/users, /management, /staff, /internal, /superadmin, /api/admin, /dashboard/admin, /control, /cms, /operator, and /backdoor all represent likely admin paths that should be in your fuzzing wordlist. When you discover a path that returns a 200 or a 302 (redirect to login) rather than a 403 or 404, you know the endpoint exists. If it returns a 200 with admin content while you are logged in as a regular user — without asking for additional credentials — that is a critical vertical privilege escalation. Even a 403 is worth probing further: some applications check the role only on the initial page load but fail to check it on the API calls that power the admin panel's features, so you might find that the HTML is blocked but the underlying API endpoints at /api/admin/users or /api/admin/settings are accessible.

JWT (JSON Web Token) manipulation for vertical privilege escalation was introduced in Topic 13, and it deserves reinforcement here because it is one of the most elegant privilege escalation techniques when it works. The core attack is modifying the JWT payload to change your role claim — from "role": "user" to "role": "admin" — and then either removing the signature (the "none" algorithm attack), forging the signature using a weak secret you brute-forced, or exploiting an algorithm confusion between RS256 and HS256. Burp Suite's JWT Editor extension makes all of these attacks straightforward through its "Attack" menu. The key workflows are: for the none algorithm attack, change the alg header to "none" and remove the signature portion of the token; for weak secret brute-force, use Hashcat or jwt-cracker with a password list against the token's HMAC-SHA256 signature; for algorithm confusion, check whether the application uses RS256 (you can tell from the alg header) and try signing a modified token with the RS256 public key using HS256. If the server accepts your modified token with an escalated role claim, the application is vulnerable. JWT privilege escalation is particularly high-severity because the attack allows arbitrary role selection — you don't just get access to one admin feature, you effectively become the application's superuser.

Role-based access control (RBAC) misconfigurations represent a category of privilege escalation that appears specifically in multi-tier applications where different user roles exist — for example, a platform where roles include "viewer," "editor," "manager," and "admin." These applications often have invitation or account creation flows where a user with the "manager" role can invite new members and assign them roles, but only up to their own privilege level. If the invitation API doesn't properly enforce this ceiling, a manager might be able to invite a user with the "admin" role — escalating beyond their own permissions. Similarly, in some applications a user can change their own role or the roles of users they manage, and if the role-assignment API accepts arbitrary role values without checking whether the requesting user is authorized to assign that specific role, privilege escalation is possible. Testing this means mapping all role assignment flows — user invitation, team management, permission settings — and testing whether you can assign roles higher than your own current level. The two-account method from Topics 13 and 24 applies directly: use Account A (manager-level) to try to invite or promote Account B to admin-level, and check whether Account B actually receives admin capabilities.

Privilege escalation through account registration edge cases is worth mentioning as well, because some applications have admin account creation flows that are inadequately secured. Some applications use a special registration URL or invite token to create admin accounts, and if that URL or token has been exposed (through Information Disclosure, through Historical Analysis of old URLs, or through guessable patterns), you can register a full admin account directly. Some applications check whether any admin account exists and, if not, grant admin status to the first registered user — if you can reset that flag through some other vulnerability or access the initial setup page (which developers sometimes forget to disable after deployment), you can register as admin. Combining the directory fuzzing from Topic 08 with the Historical Analysis from Topic 07 often surfaces setup pages, first-run wizards, and admin bootstrap endpoints that would never be accessible through normal navigation but that still respond when visited directly. When you find any endpoint at a path like /setup, /install, /admin/create, /admin/bootstrap, or /first-run, it should immediately go to the top of your testing queue regardless of what HTTP status code the directory fuzzer reported.

To bring everything together — in Topic 25 we have covered Privilege Escalation, the overarching concept that unifies horizontal and vertical attacks across the access control topic cluster. Horizontal escalation (accessing other users' data at the same level) was covered in depth in Topics 13 and 24. This topic focused on vertical escalation — moving from a regular user to admin. The five primary techniques are: parameter tampering (role/admin/is_admin parameters in requests), mass assignment (injecting role fields into JSON update bodies), hidden admin endpoint discovery via directory fuzzing, JWT manipulation (none algorithm, weak secret, algorithm confusion), and RBAC misconfiguration testing (role assignment ceiling bypass). Registration edge cases — setup pages, first-run wizards, admin bootstrap endpoints — also deserve attention and are found through the Historical Analysis and directory fuzzing techniques from earlier topics. Vertical privilege escalation is consistently critical severity because a successful attack gives full administrative control. Everything in this course — the URL lists, the JWT tokens, the parameter fuzzing, the directory enumeration — feeds into finding privilege escalation, which is why this topic sits near the end of the curriculum as a synthesis of what came before. I will see you in Topic 26!

Topic 26 — Local File Inclusion (LFI)

Welcome to Topic 26 — Local File Inclusion, universally shortened to LFI. The syllabus definition is precise: LFI happens when an application includes files from the server using user input without proper validation. This means the application has a feature that reads a file from the server's filesystem and serves its contents — and it accepts the filename or file path as a parameter that you can control. When a PHP application, for example, uses a parameter like ?page=home to decide which template file to include — with code like include($_GET['page'] . '.php') — it is trusting the user to supply a filename that should be within the application's own directory. If you replace home with a path traversal sequence like ../../../../etc/passwd, and the application does not validate that the resulting path stays within its intended directory, the server will include and return the contents of /etc/passwd — a system file that contains all the usernames on the Linux server. This is why LFI is considered a critical vulnerability: it allows an attacker to read arbitrary files from the server's filesystem, including application source code, configuration files with database credentials, SSH private keys, and system files that reveal server architecture. In severe cases — when the included file contains attacker-controlled content, or when the application supports PHP wrappers — LFI can escalate to Remote Code Execution (Topic 27).

The common parameters where LFI vulnerabilities appear are listed in the syllabus, and you should recognize all of them. The highest-priority ones are ?page=, ?file=, ?path=, ?include=, ?template=, ?view=, ?load=, ?module=, and ?doc=. Each of these parameter names suggests that the application is reading a file or template based on the parameter value. Additionally, language and template parameters like ?lang=en and ?template=default are worth testing — these often map to files like en.php or default.html in a language directory, and if you can traverse out of that directory, you can read arbitrary files. When you are working through your URL list from Topic 07, you should filter specifically for URLs containing any of these parameter names and prioritize them for LFI testing. The same logic applies to your fuzzing results from Topic 08 — any endpoint you discovered that accepts a file or path parameter goes immediately into your LFI testing queue. These parameters are so reliably associated with LFI that finding one on any application justifies immediate focused testing before you move on to anything else.

The technologies where LFI most commonly appears are listed in the syllabus: PHP, ASP.NET, JSP/Java, Python web frameworks, Node.js, and Ruby on Rails. This is essentially all major web technologies — LFI is not language-specific. Any language that allows developers to open or include files based on user input can be affected. In PHP, the vulnerable pattern uses functions like include(), require(), include_once(), and file_get_contents() with user-supplied paths. In Python, it might involve open() with a user-controlled filename. In Node.js, it might use fs.readFile() or require() with a user-controlled path. The specific file inclusion functions differ by language, but the vulnerable pattern is always the same: take user input, use it to construct a file path, read that file without restricting the path to a safe directory. The file viewing features listed in the syllabus — Download file, View file, Open document, Export report — are particularly high-value LFI targets because they are explicitly designed to read files and return their contents to the user. Any "download" or "export" feature that takes a filename or path as input should immediately receive LFI payloads. CMS admin panel features like page editors, theme loaders, and plugin loaders are similarly high-value because they need to read template files and configuration files from the filesystem as part of their normal operation.

The path traversal sequence is the core of every LFI payload. On Linux and Unix systems, ../ means "go up one directory level." To get from a web application's document root (typically something like /var/www/html/) to the filesystem root (/), you need to traverse up enough levels. The basic payload ../../../../etc/passwd uses four levels of traversal, which will work if the application is located four or fewer directories deep from the root. If four levels doesn't work, you should try more — ../../../../../../../../etc/passwd with eight or ten levels of traversal. Linux path traversal always uses forward slashes and the two-dot-slash sequence ../. Windows path traversal uses either backslashes ..\..\ or forward slashes, and the target files are different — the syllabus lists ..\..\..\..\windows\win.ini and ..\..\..\..\windows\system32\drivers\etc\hosts as Windows-specific payloads. win.ini is a small configuration file that has existed since early Windows versions; its presence in the response confirms Windows LFI the same way /etc/passwd confirms Linux LFI. When you are testing any application, always check whether the server is Windows or Linux first (from the response headers, from techfinder output, or from the URL patterns) and use the appropriate payload style.

The three essential Linux files to target in your basic LFI payloads are listed in the syllabus: /etc/passwd, /etc/hosts, and /proc/self/environ. /etc/passwd is the classic LFI confirmation target — it contains one line per user account on the system, and every line starts with the username followed by a colon. Its presence in the response unambiguously confirms LFI. /etc/hosts contains the system's hostname-to-IP mappings and is useful for understanding the server's network context — internal hostnames and IP addresses visible here might reveal additional targets like internal services, databases, or admin interfaces not accessible from the public internet. /proc/self/environ is a Linux virtual filesystem file that contains the environment variables of the current process — this can expose API keys, database passwords, AWS credentials, and other secrets that were passed to the application via environment variables, which is a common practice in containerized and cloud deployments. The syllabus tip for Burp Intruder matching is important: use a Grep-Match rule with the pattern root:[^:]*: or simply root: to automatically flag responses that contain a successful /etc/passwd read, so Intruder highlights the successful payload immediately without you having to read each response manually.

LFI in POST requests is as important as LFI in GET parameters and should not be overlooked. Forms, JSON APIs, and file upload features can all contain LFI vulnerabilities when the POST body includes a path or filename parameter. The syllabus example shows a JSON POST body {"page": "../../../../../etc/passwd"} — the same path traversal payload that works in URL parameters can equally work in a JSON field if the application reads that field and uses it to construct a file path. File upload features that allow you to specify a destination path for the uploaded file might also accept traversal sequences to place the file outside the intended upload directory. When you are testing any form that contains a field whose name suggests a file or path — especially in content management systems, document editors, and file management interfaces — always try path traversal payloads in those fields in addition to the standard URL parameter testing. The lfifinder tool listed in the syllabus automates the process of testing a list of URLs for LFI across all common parameter names simultaneously, and the LFI payload wordlist at the syllabus reference contains hundreds of path traversal variations including encoding bypasses for applications that filter the basic ../ sequence.

Encoding bypasses are important for LFI when basic path traversal is filtered. Some applications check whether the input contains ../ and reject it if found. These filters can often be bypassed using URL encoding — %2e%2e%2f represents ../ in URL encoding, %2e%2e/ uses partial encoding, and double encoding %252e%252e%252f targets applications that decode once before filtering and once again before using the value. Null byte injection — appending %00 to the payload — was historically used in PHP to terminate strings early, bypassing file extension checks (for example, turning ../../../../etc/passwd%00 into a path that ignores any .php suffix the application was appending), though this technique is less effective in modern PHP versions. Path normalization bypasses like ....//....//etc/passwd (double dots with extra slashes that collapse to ../ after normalization) can also defeat simple string replacement filters. The LFI payload wordlist in the syllabus contains all of these variants, and running it through Burp Intruder with a grep-match rule for root: will surface the successful bypass payload automatically even across dozens of encoding variations. The 8 HackerOne reports in the syllabus — 1542734, 1626210, 2778380, 1427086, 1419213, 1639364, 497771, and 895972 — document real LFI findings and will show you the specific bypass techniques that worked against different target configurations.

To bring everything together — in Topic 26 we have covered Local File Inclusion, which occurs when an application uses user-controlled input to construct a file path and reads that file without restricting the path to a safe directory. The core mechanism is path traversal: injecting ../../../../ to climb out of the web root and reach arbitrary filesystem files. The nine highest-priority parameters are ?page=, ?file=, ?path=, ?include=, ?template=, ?view=, ?load=, ?module=, and ?doc=. The three essential Linux target files are /etc/passwd (confirms LFI), /etc/hosts (reveals network topology), and /proc/self/environ (exposes environment variables and credentials). Windows targets are win.ini and system32/drivers/etc/hosts. LFI appears in GET parameters, POST bodies, and JSON fields equally. Burp Intruder with a root: grep-match rule automates payload testing. Encoding bypasses (%2e%2e%2f, double encoding, null bytes, path normalization) defeat basic filters. The lfifinder tool and the LFI payload wordlist bring testing to pipeline scale. LFI can escalate to RCE via PHP wrappers or log poisoning, which connects directly to Topic 27. I will see you in Topic 27!

Topic 27 — Remote Code Execution (RCE)

Welcome to Topic 27 — Remote Code Execution, universally abbreviated to RCE. RCE is the highest-severity vulnerability class in web security — when you find RCE, you have the ability to run arbitrary commands on the server. This means you can read any file on the filesystem, access environment variables and credentials, connect to internal databases and services, exfiltrate all application data, install backdoors, pivot to other systems on the same network, or completely take over the server. RCE findings are always critical severity, and they consistently earn the highest possible payouts on every major bug bounty platform. The syllabus lists four primary locations where RCE is most commonly found: File Upload, Technology-Based (such as Jenkins), Source Code Review, and Chain with Other Vulnerability. Each of these represents a fundamentally different discovery path, and understanding all four is what separates hunters who regularly find RCE from those who never do. RCE via File Upload is the most directly testable and the most commonly found on web applications. Technology-Based RCE through exposed services like Jenkins has produced some of the most dramatic and reproducible findings in bug bounty history. Source Code Review RCE requires reading actual application code to find dangerous function calls. Chained RCE — where you reach RCE by combining two or more lower-severity vulnerabilities — is the most creative and often the highest-rewarded category.

RCE via file upload is the most accessible entry point and the one the syllabus covers in the most detail. The attack works when an application allows users to upload files and then serves those files in a web-accessible directory, without properly restricting which file types can be uploaded. If you can upload a PHP file — even one disguised with a different extension — and the server executes it when accessed via a URL, you have RCE. The classic PHP webshell payload in the syllabus is <?php if (isset($_GET['cmd'])) { system($_GET['cmd']); } ?>. This one-liner reads a URL parameter called cmd and passes it to PHP's system() function, which executes it as a shell command. Once your webshell is uploaded and accessible at a URL like https://target.com/uploads/xyz.php, you can run any command by visiting https://target.com/uploads/xyz.php?cmd=id — the server will return the output of the id command, confirming code execution as the web server user. For bug bounty purposes, the safest and most standard PoC commands are id (shows current user), whoami (shows username), hostname (shows server hostname), and uname -a (shows OS version) — these confirm RCE conclusively without touching any files or damaging anything on the server.

File upload filter bypass is the core technical challenge of file-upload RCE, and the syllabus provides an extensive list of bypass extensions. The critical insight is that many applications try to restrict uploads by checking the file extension — if the extension is not in an allowlist (jpg, png, gif) or is in a blocklist (php, exe), the upload is rejected. These checks can often be bypassed. Double extensions like .jpeg.php, .jpg.php, and .png.php exploit servers that process the last recognized extension rather than the last extension overall — if Apache is configured to parse .php files but the validation code only checks that the filename ends with a valid image extension, shell.php.jpg might pass the validation but execute as PHP. Alternative PHP extensions like .php3, .php4, .php5, .php7, .php8, .pht, .phar, .phpt, .pgif, .phtml, and .phtm may all be executed as PHP by the server depending on its configuration, while only .php is in the blocklist. Null byte injection — using .php%00.gif or .php\x00.gif — exploits the C string termination behavior in some older PHP and system call implementations, where the string terminates at the null byte, making the server see only .php while the validation code sees .php.gif. The .inc extension is another bypass that sometimes works on servers where PHP has been configured to execute .inc files. Systematically testing each of these extensions — using Burp Suite Intruder with the extension as the payload position — is the most reliable approach.

Technology-based RCE through Jenkins is one of the most historically impactful categories in bug bounty and deserves detailed attention. Jenkins is a popular open-source CI/CD automation server, and it has a built-in Groovy Script Console at /script that allows arbitrary Groovy code execution on the server. When Jenkins is deployed without authentication (which was unfortunately common for years, especially on internal networks accidentally exposed to the internet) or with default credentials, the Script Console provides direct RCE. The syllabus live hunting session targets — Jenkins instances at specific IP addresses and domains — demonstrate that exposed Jenkins servers are real and common in the wild. When you find a Jenkins instance during your subdomain enumeration or Shodan/FOFA dorking (the dork http.title:"Dashboard [Jenkins]" from Topic 09 specifically surfaces them), the first thing to try is browsing to /script without any credentials. If you can access the Script Console, you have confirmed unauthenticated RCE. The nuclei workflow in the syllabus automates this check: piping a URL to nuclei -tags jenkins -severity critical,high,medium runs all Jenkins-specific nuclei templates against that target, checking for the Script Console, known CVEs, and other Jenkins vulnerabilities simultaneously. This is why Topics 05 and 09 — technology identification and dorking — feed directly into RCE discovery: identifying which servers are running Jenkins (or other script-execution services) is the prerequisite for technology-based RCE.

When you have RCE on a Linux server, one of the first things you will likely need to do for your PoC is read sensitive files to demonstrate impact. The syllabus includes an entire section on what to do when cat is blocked — a situation that arises when the server has command filtering or a WAF that blocks specific commands. The list of cat alternatives in the syllabus is extensive and worth memorizing: tac (reverse cat), less, more, head -n 100, tail -n 100, nl, grep . /etc/passwd, awk '{print}', sed -n 'p', cut -c 1-, xxd, hexdump -C, od -c, strings, php -f, rev, fold, tee, cp /etc/passwd /dev/stdout, dd if=/etc/passwd, and language-based alternatives like python3 -c 'print(open("/etc/passwd").read())', perl -ne 'print' /etc/passwd, and node -e "console.log(require('fs').readFileSync('/etc/passwd','utf8'))". The base64 trick — base64 /etc/passwd | base64 -d — encodes and immediately decodes the file, which is useful when the output encoding is causing display issues. The obfuscated path payload /???/???/c?t$IFS/???/p?s?w? uses shell wildcards and the Internal Field Separator variable to execute /bin/cat /etc/passwd without typing those words literally — this bypasses WAFs that do simple string matching on command names. Having these alternatives ready means you are never stuck when standard commands are blocked.

Chained RCE — reaching code execution by combining multiple vulnerabilities — is the most creative and often highest-rewarded category. The most common and powerful chain in web bug bounty is LFI to RCE via log poisoning. The technique works like this: you find LFI on a PHP application (Topic 26), and you also know the path to the web server's access log (typically /var/log/apache2/access.log or /var/log/nginx/access.log). Web servers log the User-Agent header of every incoming request. If you send a request with a PHP webshell as your User-Agent — <?php system($_GET['cmd']); ?> — the server writes that PHP code into the access log. Then when you use LFI to include the access log file, the PHP interpreter executes the code that was written into the log, and you have RCE. Another common chain is SSRF to RCE — where Server-Side Request Forgery allows you to reach an internal service (like a metadata endpoint, an internal Jenkins instance, or a Redis server) that can then be used for code execution. File upload to SSRF to RCE is another documented chain. The principle is that many systems that are not directly vulnerable to RCE on their own become vulnerable when combined with another vulnerability that gives you a different perspective — access to an internal network, the ability to write arbitrary content to a file, or the ability to control an execution context.

Source code review for RCE requires you to read the application's code and identify dangerous function calls that receive user-controlled input. In PHP, the dangerous functions include system(), exec(), passthru(), shell_exec(), popen(), proc_open(), and eval() — if any of these receive a value that ultimately comes from a request parameter without sanitization, RCE is present. In Python, os.system(), subprocess.call(), eval(), and exec() with user input are the dangerous patterns. In Node.js, child_process.exec() and eval() with user input are the primary targets. Source code review RCE typically requires access to the source code — either through an exposed .git directory (Topic 19), through an LFI vulnerability that lets you read the source files, through a public GitHub repository, or through disclosed backup archives. When source code review is possible, it is among the most reliable ways to find RCE because you are looking at the actual vulnerable code path rather than testing blindly. The 19 HackerOne reports in the syllabus — 861744, 365271, 1072832, 227880, 1164452, 1200647, 343726, 55431, 1418891, 2248328, 1332433, 591295, 1154542, 632721, 403417, 733072, 358049, 1102067, and 1069105 — cover RCE findings across all four discovery paths and will cement your understanding of how these vulnerabilities look in real programs.

To bring everything together — in Topic 27 we have covered Remote Code Execution, the highest-severity vulnerability class in web security. The four discovery paths are File Upload (bypass extension filters, upload PHP webshell, access via URL), Technology-Based (Jenkins Script Console via unauthenticated access, nuclei automation), Source Code Review (dangerous function calls receiving user input), and Chained RCE (LFI + log poisoning, SSRF to internal services). The PHP webshell <?php if (isset($_GET['cmd'])) { system($_GET['cmd']); } ?> is the standard PoC payload. The 19 bypass extensions — from .php3 through null byte tricks to .phtml — defeat blocklist-based upload filters. When commands are blocked, the full list of cat alternatives — tac, python3 -c, obfuscated wildcard paths — keeps you unblocked. The safe PoC commands for reports are id, whoami, hostname, and uname -a. Everything in the course — subdomain enumeration, technology fingerprinting, dorking, LFI, SSRF — can feed into RCE discovery. The 19 HackerOne reports span all four discovery paths. I will see you in Topic 28!

Topic 28 — Server-Side Template Injection (SSTI)

Welcome to Topic 28 — Server-Side Template Injection, universally abbreviated as SSTI. SSTI is a vulnerability that occurs when an application uses a template engine to render dynamic content and allows user input to be processed as template syntax rather than plain text. Template engines are designed to take a template with placeholders — like Hello {{username}} — and replace those placeholders with real values. The problem arises when the application passes user-controlled data directly into the template as code rather than as data. If the template engine then evaluates that input, an attacker can inject template directives that execute on the server. The classic detection test is {{7*7}} — if the response contains 49 instead of {{7*7}}, the application is evaluating your input as template code, which confirms SSTI. SSTI is significant because, unlike most injection vulnerabilities that operate within database queries or HTML output, SSTI operates at the level of the application's server-side code execution environment — meaning it can very often be escalated directly to Remote Code Execution. For this reason, SSTI is consistently rated critical severity and earns top payouts on most programs. The syllabus covers detection across five major template engines — FreeMarker, Twig, ERB, Tornado, and Jinja2 — along with the hunting locations and all RCE payloads per engine.

Template engines are very commonly used in web applications because they make dynamic content generation easy and clean. FreeMarker is a Java-based template engine frequently found in enterprise Java applications. Twig is the most popular PHP template engine, used heavily in Symfony-based applications and many CMSes. ERB (Embedded Ruby) is used in Ruby on Rails applications — it is the default templating system for Rails views. Tornado is a Python web framework with its own template engine. Jinja2 is the most widely used Python template engine, used in Flask, Ansible, and many other Python applications. Each engine has its own syntax — the double curly brace {{ is common to Twig and Jinja2, while FreeMarker uses ${}, ERB uses <%= %>, and Tornado uses {{}}. This diversity in syntax means that the same payload will not work across all engines — you need to identify which engine is running before you can craft an effective RCE payload. The detection payloads in the syllabus serve double duty: they both confirm SSTI and fingerprint which engine is in use, since different engines produce different outputs for the same test input.

SSTI detection is done by systematically testing which mathematical expression syntax gets evaluated. For FreeMarker (Java), ${7*7} returns 49 and #{7*7} also returns 49, while {{7*7}} is not evaluated. For Twig (PHP), {{7*7}} returns 49 and {{7*'7'}} also returns 49, while ${7*7} is not evaluated. For ERB (Ruby), neither {{7*7}} nor ${7*7} are evaluated — only <%= 7*7 %> returns 49. For Tornado (Python), {{7*7}} returns 49 and {{7*'7'}} returns the string 7777777 (the character 7 repeated). For Jinja2 (Python), {{7*7}} returns an error, but {{7*'7'}} also returns 7777777. The unique fingerprint for Jinja2 is that large multiplication like {{7*77777}} returns 544439 — this specific result has become a reliable way to confirm Jinja2. By running all five detection payloads in a quick Intruder session, you can very quickly identify which engine is present and move to the matching RCE payload. The key insight is that the detection output is your roadmap — it not only tells you that SSTI is present, it tells you exactly which language and engine you are dealing with.

Once SSTI is confirmed and the template engine is identified, escalating to RCE follows a well-known path for each engine. For FreeMarker (Java), the RCE payload uses FreeMarker's ability to instantiate Java classes: <#assign ex="freemarker.template.utility.Execute"?new()> ${ex("id")} — this creates an instance of FreeMarker's built-in Execute class and runs the id command. For Twig (PHP), the most common RCE path goes through object injection in Twig's filter system, though direct command execution has been achieved through various payload chains depending on the Twig version. For ERB (Ruby), the payload is elegantly simple: <%= %x(id) %> — the %x() syntax in Ruby executes a shell command and returns its output. For Tornado (Python), the RCE payload imports the os module directly within the template: {% import os %}{{ os.popen("id").read() }}. For Jinja2 (Python), direct import os is not allowed in the template context, so the RCE payload traverses Python's object hierarchy to reach the os module indirectly: {{ cycler.__init__.__globals__.os.popen('id').read() }} — this accesses the os module through the global namespace of the cycler object's __init__ function. All of these RCE payloads are in the syllabus, and understanding how each one works at the language level is what makes you effective at SSTI.

Knowing where to look for SSTI is as important as knowing the payloads. The syllabus identifies three primary hunting categories. First, input fields — anywhere user-controlled text is rendered back to the user: search bars, contact forms, feedback forms, profile name fields, and username fields. Any place where you type something and the application displays it back to you in a rendered context is worth testing. Second, template-based features — email templates, notification systems, report generation, and invoice generation. These features are particularly high-risk because developers often write them quickly using template engines and assume user input will only be used as a simple data value inside the template, not realizing that the template engine will evaluate template syntax in that data. Third, CMS and admin panels — theme editors, template editors, and page builders. When an application gives users (or even admins) the ability to write template content, there is often a path to SSTI if the template engine is not sandboxed. Admin panels are in scope on many bug bounty programs, and finding SSTI in a template editor is a valid critical finding — the fact that it requires admin access does not necessarily make it out of scope.

SSTI can be found in both GET and POST requests, and you should test both. In a GET request, the most common injection point is a URL parameter that reflects into a template — for example, https://example.com/index.php?name={{7*7}}. If the application was using the name parameter to fill a template like Hello {{name}}, your injection would be processed as Hello {{7*7}} and would return Hello 49 if vulnerable. In a POST request, the same logic applies to JSON body fields — submitting {"name": "{{7*7}}"} and checking whether the response contains 49. The practical workflow in Burp Suite is: intercept a request where user input is reflected in the response, send it to Repeater, replace the value with {{7*7}} and each of the five detection payloads in sequence, and look for 49 or 7777777 in the response. The key behavioral indicator is that the application renders your math expression as a computed result rather than displaying it literally. When you find that behavior, the application has confirmed that your input is being passed into a template context and evaluated.

The relationship between SSTI and RCE is why SSTI is considered so severe. In practice, SSTI and RCE are often the same vulnerability at different stages — SSTI is the discovery that server-side code evaluation is happening, and RCE is the confirmation that you can run arbitrary operating-system commands. The same cat alternative commands from Topic 27 apply here too — if you have SSTI-to-RCE via FreeMarker and the cat command is blocked, you can substitute any of the alternatives like tac, python3 -c, or the obfuscated wildcard path directly inside the FreeMarker Execute payload. The syllabus provides the full translated list — every cat alternative wrapped in the FreeMarker, ERB, Tornado, and Jinja2 RCE payload syntax — so you will never be stuck when commands are filtered. The safe PoC commands remain id, whoami, hostname, and uname -a. These confirm RCE conclusively in your report without touching any files. The 6 HackerOne reports in the syllabus — 1104349, 125980, 423541, 164224, 942103, and 3031518 — are real SSTI findings across different technologies and will cement your understanding of how SSTI is reported in practice.

To bring everything together — in Topic 28 we have covered Server-Side Template Injection, a vulnerability that occurs when user input is processed as template code rather than plain data. The five engines covered are FreeMarker (Java, ${7*7}), Twig (PHP, {{7*7}}), ERB (Ruby, <%= 7*7 %>), Tornado (Python, {{7*7}}), and Jinja2 (Python, {{7*'7'}}). The {{7*7}} = 49 detection test is your starting point. The RCE payloads per engine — FreeMarker Execute, ERB %x(), Tornado {% import os %}, Jinja2 cycler.__init__.__globals__ — are your escalation path. The hunting locations are input fields that reflect user data, template-based features like email and reports, and CMS template editors. SSTI is testable in GET and POST requests using Burp Repeater. The 6 HackerOne reports span multiple template engines and programs. SSTI is regularly found in the wild and pays critical bounties because it leads directly to RCE. I will see you in Topic 29!

Topic 29 — Server-Side Request Forgery (SSRF)

Welcome to Topic 29 — Server-Side Request Forgery, universally abbreviated as SSRF. SSRF is a vulnerability that occurs when an application fetches a URL based on user-controlled input and allows an attacker to make requests from the server itself rather than from the attacker's browser. The key distinction is that the request comes from the server — not from you. This means the server can reach resources that your browser cannot: internal network hosts, services running on localhost, cloud provider metadata endpoints, and internal admin panels that are firewalled from the public internet. The classic detection test is finding a parameter that accepts a URL — something like ?url=https://example.com — and replacing it with an internal address like ?url=http://127.0.0.1. If the server makes that request and the response changes — a different response body, a different status code, or a timing difference — SSRF is confirmed. SSRF is rated high to critical severity because its impact goes far beyond just reading internal pages: it can lead to cloud credential theft, internal service access, data exfiltration, and even Remote Code Execution through chaining. The 14 HackerOne reports in the syllabus — 514224, 1220688, 341876, 530974, 326040, 1300585, 3165242, 386292, 508459, 228377, 1736390, 643622, 2301565, and 1189367 — span a wide range of SSRF types and programs.

Knowing where to hunt for SSRF is everything, because SSRF requires the application to actually make server-side HTTP requests. The syllabus organizes hunting locations into three categories. URL fetching features are the most obvious: image upload via URL (where you give the app a URL and it downloads the image server-side), file import via URL, PDF generators (the app fetches a URL and renders it as PDF), screenshot tools, webhooks (where the app sends data to a URL you supply), and link preview features that fetch metadata from a URL. Each of these features is explicitly designed to make server-side requests, so they are perfect SSRF candidates. API features are the second category: external API fetch endpoints, payment integrations (where the server calls a payment gateway URL that you can sometimes influence), and OAuth callbacks. The third category is admin features: backup restore, data import, and report generation — features where an admin can specify a source URL that the server then fetches. All three categories share the same underlying pattern: the application takes a URL as input and the server makes an HTTP request to that URL. Finding that pattern anywhere in the application means you should test for SSRF.

The first and most fundamental SSRF payload is targeting internal IP addresses. When you replace a URL parameter with http://127.0.0.1, http://localhost, or http://0.0.0.0, you are asking the server to make a request to itself. If the server has any web service running on localhost that is not exposed to the public internet — like an internal admin panel, a development server, a database management interface, or an API endpoint that only trusts requests from 127.0.0.1 — you can now access it through the SSRF vulnerability. The port scanning technique builds on this: by testing URLs like http://127.0.0.1:22/, http://127.0.0.1:3306/, http://127.0.0.1:8080/, http://127.0.0.1:3000/, and http://127.0.0.1:6379/, you can map which services are running internally based on response timing and content. Port 22 (SSH) will often return an SSH banner. Port 3306 (MySQL) may return garbled binary data. Port 8080 often hosts Tomcat or Jenkins admin interfaces. Port 6379 (Redis) returns -ERR on invalid input. Port 3000 often belongs to a Node.js development server. All of these responses confirm that the internal service is reachable and give you an inventory of the internal network that would otherwise be completely hidden from an external attacker.

Cloud metadata access via SSRF is one of the most critical and highest-impact SSRF scenarios. When an application is hosted on a cloud provider like AWS, Google Cloud, or Azure, the server has access to a special non-routable IP address — 169.254.169.254 — that serves instance metadata. On AWS EC2 instances, the metadata endpoint at http://169.254.169.254/latest/meta-data/ returns a list of metadata keys. The most dangerous endpoint is http://169.254.169.254/latest/meta-data/iam/security-credentials/ROLE_NAME — if the EC2 instance has an IAM role attached (which is the standard deployment pattern on AWS), this endpoint returns temporary AWS access keys: an AccessKeyId, a SecretAccessKey, and a Token. With these credentials, an attacker can authenticate to the AWS API and access all the AWS services that the IAM role permits — which often includes S3 buckets with sensitive data, RDS databases, and other infrastructure. This single SSRF vulnerability can compromise an entire AWS environment. The two-step workflow is: first hit the base metadata URL to get the IAM role name, then hit the credentials URL with that role name to retrieve the temporary keys. Even if the specific server you are testing is not on AWS, you should always test 169.254.169.254 as part of your SSRF workflow — the finding is so critical that it is worth the two seconds of testing.

Protocol bypass payloads extend SSRF far beyond HTTP. The syllabus covers six alternative protocols. The file:// protocol allows the server to read local files directly — file:///etc/passwd on Linux or file:///C:/Windows/win.ini on Windows — turning SSRF into an LFI-equivalent. The ftp:// protocol allows the server to make FTP connections. The gopher:// protocol is particularly powerful because it allows the attacker to speak raw TCP to any internal service — it can be used to send arbitrary TCP payloads to internal services like MySQL, Redis, and memcached. The dict:// protocol can be used to query memcached instances at dict://127.0.0.1:11211/stat. The ldap:// protocol allows querying internal LDAP directory servers. These alternative protocols are important because they bypass URL allowlist filters that only block HTTP requests to internal IPs — a filter that checks http://127.0.0.1 and blocks it might allow file:///etc/passwd entirely. When you find SSRF with HTTP blocked, always try the protocol bypass list. The syllabus also includes direct file reading targets for Burp Repeater: url=file:///etc/passwd, url=file:///etc/hosts, url=file:///var/www/html/.htaccess, and url=file:///var/log/apache2/access.log.

SSRF chaining is what makes this vulnerability class so versatile. The syllabus lists four chain paths. SSRF → internal scan: you use SSRF to probe internal IP ranges and map the internal network, finding services that are not publicly accessible. SSRF → access admin panel: internal admin panels that only accept requests from 127.0.0.1 are accessible through SSRF since the request comes from the server itself. SSRF → read cloud metadata: as covered above, stealing temporary AWS IAM credentials through the metadata endpoint. SSRF → RCE: this is the most dramatic chain, usually achieved through Gopher-based protocol abuse against internal services — for example, using gopher:// to talk to an internal Redis server and write a webshell to disk, then accessing that webshell via a web request. The impact section in the syllabus summarizes the five consequences of SSRF: internal network access, cloud credential theft, admin panel access, data leakage, and Remote Code Execution. Each of these is itself a critical finding — SSRF is not just a low-impact information disclosure, it is a pathway to the most severe outcomes in web security. I will see you in Topic 30!

Topic 30 — XML External Entity (XXE)

Welcome to Topic 30 — XML External Entity Injection, universally abbreviated as XXE. XXE is a vulnerability that occurs when an application processes XML input and the XML parser has external entity support enabled. To understand XXE, you first need to understand what an XML entity is. In XML, an entity is a named value that can be referenced inside the document using an ampersand and semicolon — like a variable. A simple internal entity looks like this: <!DOCTYPE foo [<!ENTITY search "laptop">]>. When the XML document then uses &search;, the parser replaces it with laptop. An external entity takes this further — instead of defining a fixed value, it tells the parser to fetch the entity's value from an external resource using the SYSTEM keyword and a URI. The critical payload looks like: <!DOCTYPE foo [<!ENTITY payload SYSTEM "file:///etc/passwd">]>. When the document then uses &payload; inside an XML element, a vulnerable parser reads the contents of /etc/passwd from the server's filesystem and inserts that content into the XML response. This turns XXE into server-side file reading, and the same mechanism can be used to reach internal URLs, making XXE an SSRF vector as well. The 14 HackerOne reports in the syllabus — 106797, 500515, 312543, 2573567, 154096, 227880, 248668, 836877, 715949, 106865, 2564265, 1156748, 710654, and 105753 — cover XXE across a wide variety of real-world programs.

Knowing where XML is processed is the prerequisite for finding XXE. The syllabus identifies seven hunting locations. File uploads are the primary entry point — whenever an application allows uploading of XML-based file formats, the server-side XML parser is invoked and may be vulnerable to XXE. SVG images are particularly important because SVG is an XML-based format and is uploaded in many contexts where users can set a profile picture or avatar — a maliciously crafted SVG with an XXE payload can cause the server to read local files when it processes the image. RSS feeds are XML-based and many applications allow users to import or subscribe to RSS feeds — when the server fetches and parses the feed, an attacker-controlled feed can carry an XXE payload. Office documents — DOCX, XLSX, PPTX — are actually ZIP archives containing XML files inside them, so upload features that accept these formats may parse the embedded XML with a vulnerable parser. Android applications often use XML for configuration and data, and their backend APIs may accept XML payloads. Banking systems and government services are specifically called out in the syllabus because they frequently use XML-based SOAP web services — older enterprise technology that heavily relies on XML for all API communication and is among the most common places to find XXE in modern bug bounty programs.

The technical signal for XXE is finding XML being parsed server-side. Bug hunters look for three specific indicators in HTTP requests. The first is the Content-Type header value application/xml — when a request carries this content type, the server is explicitly expecting XML. The second is text/xml — another common XML content type for SOAP and legacy APIs. The third is finding <?xml version="1.0"?> in a request body — the XML declaration that appears at the start of an XML document, which you will often see in SOAP requests. When you find any of these three signals, the workflow is: inject the XXE DOCTYPE declaration at the beginning of the XML body, define an external entity that reads a local file, and reference that entity inside an XML element that appears in the response. The classic working payload is <!DOCTYPE foo [<!ENTITY payload SYSTEM "file:///etc/passwd">]> followed by <text x="10" y="20">&payload;</text>. If the response contains the contents of /etc/passwd, you have confirmed XXE. The same file:// protocol approach that works in SSRF also works in XXE — these two vulnerabilities share the concept of a server being tricked into fetching resources it should not.

Blind XXE is a critically important variant that you will encounter when the application parses your XML but does not reflect the parsed content back in the HTTP response. In classic XXE, you can see the file contents directly in the response. In blind XXE, the application may still be parsing your XML and resolving external entities, but the results are not shown to you. The detection technique for blind XXE is the out-of-band method: instead of pointing your entity at a local file, you point it at a Burp Collaborator URL — <!ENTITY payload SYSTEM "http://YOUR_COLLABORATOR_URL">. If the server is vulnerable, it will make an HTTP request to your Collaborator URL and you will see the interaction in Burp Collaborator, confirming that XXE is present even though nothing appears in the response. This same out-of-band channel can then be used to exfiltrate file contents — by encoding the file content into a URL parameter sent to your Collaborator server. The practical implication for bug bounty is that you should not dismiss an XML endpoint as safe just because &payload; doesn't appear in the response — the blind variant is equally common and equally critical. Always test with Burp Collaborator on any XML endpoint.

XXE through SVG upload deserves its own explanation because it is one of the most practically successful attack paths. SVG (Scalable Vector Graphics) is an XML-based image format, and many web applications allow users to upload SVGs as profile pictures, logos, or attachments. When the server processes the uploaded SVG — either to render it, convert it, or extract metadata — it runs the SVG through an XML parser. If that parser has external entities enabled, your malicious SVG will cause the server to read local files. A minimal malicious SVG looks like this: an SVG root element with the XXE DOCTYPE and entity definition embedded, then a text element that references the entity so its value gets rendered into the SVG graphic. The server reads the entity, inserts the file content, and either returns the SVG to you with the file contents embedded or processes it in a way that leaks the data. DOCX files work similarly — a DOCX file is a ZIP containing word/document.xml and other XML files; you can unzip the DOCX, inject the XXE payload into document.xml, rezip it, and upload it. When the application parses the Word document, the XML parser may resolve your external entity and expose sensitive files.

XXE as an SSRF vector is equally important as XXE as a file-reading vector. Because external entities can reference any URI — not just file:// — you can use http:// URIs to make the server send requests to internal hosts. The payload <!ENTITY payload SYSTEM "http://127.0.0.1/admin"> would cause the XML parser to fetch the internal admin panel and potentially return its contents in the response. The same AWS metadata endpoint from Topic 29 — http://169.254.169.254/latest/meta-data/iam/security-credentials/ROLE_NAME — is equally reachable through XXE SSRF as through a direct SSRF vulnerability. This overlap between XXE and SSRF means that any application feature that parses XML is also a potential SSRF entry point. The impact of XXE therefore spans the full range of SSRF impacts: file reading, internal network access, cloud credential theft, and RCE through chain. For bug bounty, it is important to demonstrate the highest-impact exploitation path you can achieve — if you can read /etc/passwd and can also reach the cloud metadata endpoint, your report should show both. The 14 HackerOne reports in the syllabus will show you exactly how hunters have presented and escalated XXE findings across file reading, SSRF, and blind variants. I will see you in Topic 31!

Topic 31 — HTTP Request Smuggling

Welcome to Topic 31 — HTTP Request Smuggling. HTTP Request Smuggling is one of the most sophisticated and high-impact vulnerability classes in modern web security, and understanding it requires a solid grasp of how HTTP/1.1 connection handling works. Almost every production web application today sits behind a chain of servers: a front-end server (a load balancer, CDN edge node, or reverse proxy like Nginx or HAProxy) that receives requests from the public internet and forwards them to a back-end application server. This front-end and back-end architecture is where HTTP Request Smuggling lives. When both servers in the chain support HTTP/1.1 keep-alive connections, they often reuse the same TCP connection to send multiple HTTP requests in sequence. HTTP/1.1 provides two different mechanisms for the receiver to know where one request ends and the next begins: the Content-Length header and the Transfer-Encoding: chunked header. HTTP Request Smuggling exploits the case where the front-end and back-end servers disagree on which of these two headers takes priority when both are present in the same request. This disagreement causes one server to believe a request has ended while the other server believes more data is still arriving, effectively smuggling a hidden partial request into the connection queue — where it gets prepended to the next legitimate user's request. The impacts are severe: bypassing security controls, stealing other users' requests and credentials, gaining unauthorized access, and in some configurations achieving Remote Code Execution.

To understand why the disagreement happens, you need to understand both headers. Content-Length tells the receiver exactly how many bytes the message body contains — a simple integer. Transfer-Encoding: chunked tells the receiver that the body is sent in chunks, each preceded by its size in hexadecimal, and that the body ends when a chunk of size zero is received (0\r\n\r\n). The HTTP/1.1 specification says that if both headers are present, Transfer-Encoding should take priority and Content-Length should be ignored. But real-world servers do not all follow this rule the same way, particularly when the Transfer-Encoding header is obfuscated. The three classic smuggling variants are named for which server uses which header. CL.TE means the front-end uses Content-Length and the back-end uses Transfer-Encoding — the front-end forwards the full body as defined by Content-Length, while the back-end reads only the first chunk and treats the rest as the beginning of a new request. TE.CL means the front-end uses Transfer-Encoding and the back-end uses Content-Length — the front-end forwards exactly what the chunked encoding specifies, and the back-end expects more bytes because Content-Length is larger. TE.TE means both servers support Transfer-Encoding but one can be confused by an obfuscated form of the header, like Transfer-Encoding: xchunked or a header with extra whitespace.

The CL.TE variant is the most classically explained and worth walking through step by step. In a CL.TE attack, the attacker crafts a request that has both a Content-Length header and a Transfer-Encoding: chunked header. The Content-Length value is set to include the full body the attacker sends. The chunked body is arranged so that the first chunk contains part of the data, then a zero terminator ends the chunked encoding early — but there is still more data after the zero chunk that Content-Length includes. The front-end server, using Content-Length, reads and forwards all the bytes the attacker sent. The back-end server, using Transfer-Encoding, reads up to the zero-chunk terminator and considers the request complete — but it has leftover bytes in its buffer that were sent after the zero chunk. These leftover bytes are now sitting at the front of the back-end's input buffer, waiting for the next request. When the next legitimate user's request arrives, it gets appended to the attacker's leftover bytes. This means the back-end server now processes a combined request — the attacker's smuggled prefix plus the next user's request — as a single HTTP request. The attacker's prefix has effectively hijacked the beginning of another user's request and can force it to be routed to a different endpoint, captured in a parameter, or processed with attacker-controlled headers.

The practical impact of HTTP Request Smuggling is what makes it so valuable to find. The first and most discussed impact is bypassing front-end security controls. Front-end servers are often used as a security layer — they may enforce authentication, block access to restricted paths like /admin, strip sensitive headers, or enforce IP allowlists before forwarding traffic to the back-end. Because the smuggled request is never seen by the front-end's security logic — it was smuggled past it inside the body of a previous request — these controls can be bypassed entirely. If the back-end has an admin interface that the front-end would ordinarily block, smuggling a request to that path may succeed without the front-end ever seeing it. The second major impact is capturing other users' requests. By smuggling a partial request that ends with an open parameter value — the attacker sets up their smuggled prefix to contain a POST body parameter whose value is never closed — the back-end will read the next legitimate user's incoming request and treat it as the continuation of that parameter value. The result is that the next user's full request — including their session cookies, Authorization headers, and request body — gets captured as a value in the attacker's controlled storage location, which the attacker can then retrieve to steal credentials and take over the victim's account.

Detecting HTTP Request Smuggling requires specialized tooling because the standard request-response model does not easily reveal timing or queueing behavior. Burp Suite Professional includes a dedicated HTTP Request Smuggler extension that automates the detection of CL.TE, TE.CL, and TE.TE variants by sending carefully timed probe requests and observing response timing differences. The manual detection technique involves sending a smuggle probe and then sending a normal request immediately after — if the normal request receives an unexpected response (such as a 404, an extra response, or a response intended for a different endpoint), that differential behavior confirms that your previous request was processed in a way that corrupted the queue. The key practical consideration is that HTTP Request Smuggling testing should be done carefully and in controlled conditions on bug bounty programs — because the smuggled bytes sit in the back-end connection buffer and will corrupt the next request to arrive, you can accidentally affect real users' sessions if you are testing against a live application with active traffic. Many programs ask that you use a test account and minimize impact. Burp's extension handles this by using short timeouts and cleaning up the connection state after each probe.

HTTP Request Smuggling was brought into mainstream bug bounty consciousness primarily through the research of James Kettle at PortSwigger, who discovered and documented the technique's application to modern HTTP/1.1 infrastructure at scale. The PortSwigger Web Academy has excellent interactive labs for HTTP Request Smuggling that are specifically recommended for practicing this topic. HTTP/2 has introduced new variants of the attack — HTTP/2 does not have the same ambiguity between Content-Length and Transfer-Encoding, but HTTP/2 downgrade attacks (where an HTTP/2 front-end downgrades to HTTP/1.1 to talk to the back-end) reintroduce the smuggling surface in new ways. The TE.TE obfuscation bypasses — Transfer-Encoding: xchunked, Transfer-Encoding : chunked (with a space before the colon), Transfer-Encoding: chunked\r\nTransfer-Encoding: x — exploit the fact that different parsers handle malformed headers differently: one parser accepts the obfuscated header and uses chunked encoding, while the other parser rejects it and falls back to Content-Length. These edge cases are worth testing because enterprise proxies and legacy load balancers have widely varying levels of spec compliance. The Google search link in the syllabus — HTTP Request Smuggling hackerone — surfaces dozens of publicly disclosed findings across all major programs and is the best way to study real-world impacts and PoC structure before you begin hunting. I will see you in Topic 32!

Topic 32 — Web Cache Poisoning

Welcome to Topic 32 — Web Cache Poisoning. Web Cache Poisoning is a vulnerability that allows an attacker to store a malicious response in a web cache and have it served to other users who request the same resource. To understand why this is so powerful, you first need to understand what web caches do. A web cache — which can be a CDN like Cloudflare or Fastly, a reverse proxy like Varnish or Nginx, or a caching layer built into a framework — sits between users and your application. When a user requests a URL, the cache checks whether it already has a stored response for that URL. If it does, it serves the cached response to every subsequent user who makes the same request, without ever hitting the back-end application server. This is how CDNs scale — the same JavaScript file can be served millions of times per hour from cache without the origin server ever being contacted. Web Cache Poisoning exploits the cache's decision about what makes two requests equivalent — a decision that is based on the cache key. If you can influence the response in a way that uses an input that is not included in the cache key — an unkeyed input — you can cause the cache to store your poisoned response and serve it to every other user. The attack scales from affecting one user (a standard XSS) to affecting every single visitor to that URL — a truly wormable attack surface.

The concept of a cache key is the foundation of Web Cache Poisoning. When a cache decides whether two requests are asking for the same resource, it constructs a cache key from specific parts of the request. By default, most caches use the URL and the Host header as the cache key. This means that GET /home HTTP/1.1\r\nHost: example.com and another identical request will both receive the same cached response. But HTTP requests contain many more headers and inputs that the back-end server may use when generating its response — headers like X-Forwarded-Host, X-Forwarded-For, X-Original-URL, X-Rewrite-URL, Origin, Accept-Language, Accept-Encoding, User-Agent, and many custom headers. If the back-end application reads one of these headers and uses its value in the response — for example, by reflecting it into a JavaScript URL, a redirect target, or a link href — but the cache does not include that header in its cache key, then that header is an unkeyed input. By sending a request with a malicious value in an unkeyed header, you can cause the cache to store a response that contains your injected value. Every subsequent user who requests that URL — without ever sending that header themselves — will receive the poisoned cached response with your injected content already embedded.

The most common and impactful Web Cache Poisoning scenario leads to reflected XSS at scale. Many applications use the X-Forwarded-Host header to construct absolute URLs in their responses — for example, generating script tags like <script src="https://HOST/static/app.js"></script> where HOST comes from the X-Forwarded-Host header. If the cache does not include X-Forwarded-Host in its key, an attacker can send a request with X-Forwarded-Host: evil.com and cause the cache to store a response where the script tag loads from an attacker-controlled domain. Every user who subsequently visits that URL will execute the attacker's JavaScript — without the attacker needing to send them any link. The X-Forwarded-Host, X-Host, and X-Forwarded-Server headers are the most commonly exploited unkeyed inputs for this attack. The Origin header is another frequent unkeyed input that can influence CORS headers in the response — if the cache stores a response with a permissive Access-Control-Allow-Origin header reflecting an attacker's domain, that CORS bypass will be served to everyone. The Accept-Language header can sometimes influence content in a response in ways that enable injection if the language value is not sanitized before being reflected.

Detecting Web Cache Poisoning requires a methodical approach to identify which headers are unkeyed and which influence the response. The workflow is: first, add a cache-buster to your request — a unique query parameter like ?cb=12345 — that forces the cache to treat your request as a cache miss and fetch a fresh response from the back-end without affecting the cached response real users receive. Second, add candidate unkeyed headers one at a time with a distinctive value that you control — like X-Forwarded-Host: test-canary-value.com. Third, check whether your canary value appears anywhere in the response body. If it does, that header is both unkeyed (the cache did not reject the request or vary on it) and reflected (the back-end uses it in the response). Fourth, now that you have found a reflected unkeyed input, craft a payload that exploits the reflection — an XSS payload if it goes into an HTML or JavaScript context, an open redirect if it goes into a URL. Fifth, send the request without the cache-buster, allowing the poisoned response to be cached. Sixth, verify by sending a fresh request without any special headers — if you receive the poisoned response, the cache has stored your attack. Burp Suite Professional's Param Miner extension automates steps one through three and is the standard tool for this workflow.

Web Cache Deception is a related but distinct attack that deserves mentioning alongside Web Cache Poisoning. In Web Cache Deception, the goal is not to poison the cache with attacker-controlled content — it is to trick the cache into storing a response that contains sensitive victim data. The attack works when a cache is configured to cache responses based on file extension rather than Content-Type. If the cache will cache anything with a .css, .js, or .png extension, an attacker can craft a URL like /account/settings/evil.css that the application's router ignores the suffix for and serves the account settings page. The cache, seeing a .css extension, stores that authenticated account page. The attacker then sends the victim a link to that URL — when the victim visits it, their authenticated session data gets cached publicly, and the attacker can then retrieve it. Web Cache Deception has been found on major platforms and was awarded significant bounties because the victim does not need to do anything except click a link, and their private data becomes publicly accessible from the cache afterward.

To bring everything together — in Topic 32 we have covered Web Cache Poisoning, a vulnerability where an attacker uses unkeyed HTTP headers to store a malicious response in a web cache that is then served to all subsequent visitors. The cache key concept is the foundation: inputs the cache ignores but the back-end uses are the attack surface. The most impactful unkeyed headers are X-Forwarded-Host, X-Host, X-Forwarded-Server, Origin, and Accept-Language. The detection workflow — cache-buster, canary header, observe reflection, craft payload, remove cache-buster, verify — is the standard approach. Burp Param Miner automates unkeyed input discovery. Web Cache Poisoning XSS is more impactful than reflected XSS because it affects every user of that URL without any further attacker interaction. Web Cache Deception is the complementary attack where the cache accidentally stores authenticated user data that the attacker then retrieves. The Google search link in the syllabus — Cache Poisoning hackerone — surfaces dozens of real disclosed reports that will show you exactly how hunters have found and reported this vulnerability across different cache configurations. This has been Topic 32, and I will see you in Topic 33!

Topic 33 — Career & Next Steps

Welcome to Topic 33 — Career and Next Steps. This is the final topic of the KPWAPT course, and before we talk about where your career can go from here, I want to take a moment to acknowledge what you have accomplished. You have worked through 33 topics covering the full spectrum of web application penetration testing — from environment setup and subdomain enumeration all the way through SQL injection, CSRF, IDOR, privilege escalation, LFI, RCE, SSTI, SSRF, XXE, HTTP Request Smuggling, and Web Cache Poisoning. You have learned how to set up Burp Suite, configure your proxy, enumerate subdomains, do network reconnaissance, fingerprint technologies, hunt with Shodan and FOFA, crawl for URLs, fuzz for directories and hidden parameters, find programs, and write reports. You have studied real HackerOne reports across every vulnerability class. You now have a methodology and a toolkit that most people who call themselves penetration testers do not have. The question now is what you do with it — and the answer is that this is only the beginning.

The three primary career paths in offensive security that the syllabus identifies are bug bounty hunter, penetration tester, and red team operator — with SOC analyst as an important defensive counterpart. Bug bounty hunting is the most accessible and the most directly connected to the skills you have built in this course. As a bug bounty hunter, you work independently, choose your own programs, set your own hours, and get paid for each valid finding you submit. The platforms — HackerOne, Bugcrowd, Intigriti, Yeswehack, HackenProof — all have public programs where you can start immediately. Bug bounty rewards can range from a few hundred dollars to tens of thousands of dollars for a single critical finding, and top hunters earn well over six figures per year. Penetration testing is the consulting career path — companies hire you on a contract or salaried basis to test their applications, produce professional reports, and present your findings to their security teams. Penetration testing requires stronger report-writing skills and client communication skills than bug bounty, but it also provides stable income and a structured work environment. Red team operations are the most advanced path — red teamers simulate real-world adversaries, combining web application testing with network exploitation, social engineering, and physical access testing to assess an organization's full defensive posture.

The SOC analyst path is the defensive counterpart, and many security professionals move between offensive and defensive roles throughout their careers. A SOC (Security Operations Center) analyst monitors an organization's systems for threats in real time, investigates alerts, triages incidents, and responds to attacks. The skills you have built in this course — understanding how attacks work, what malicious requests look like, how XSS payloads appear in logs, what an SSRF probe to the metadata endpoint looks like in network traffic — make you a significantly better defender. Many of the most effective SOC analysts have offensive backgrounds because they understand what attackers are trying to do and can recognize attack patterns that less experienced analysts would miss. If you find that you enjoy the detection and response side more than the offensive side, the KPSOC certification — KrazePlanet Blue Team SOC Analyst Professional — is the structured path to build those skills. The combination of offensive knowledge from KPWAPT and defensive knowledge from KPSOC is one of the most powerful professional profiles you can develop in cybersecurity.

The KrazePlanet certification path has been designed to take you from beginner to professional in a structured sequence. The KPWAPT — KrazePlanet Advanced Web Application Penetration Testing — is this course. You have covered every topic in the syllabus, and the certification exam will test your ability to apply these skills against a real web application in a controlled lab environment. Having KPWAPT certified on your profile signals to bug bounty programs, security employers, and clients that you have demonstrated practical web application testing skills — not just theoretical knowledge. The KPNET — KrazePlanet Enterprise Network Penetration Testing — extends your skills beyond web applications into network infrastructure, Active Directory, and enterprise environments. Web applications are the entry point for many real-world compromises, but once inside a network, understanding network penetration testing is what separates a web tester from a full-spectrum penetration tester. The KPSOC rounds out the trilogy by giving you the defensive perspective. All three certifications together represent a complete professional profile in cybersecurity.

The mindset that will take you furthest in this field is curiosity combined with persistence. The hunters who find the most critical vulnerabilities are not necessarily the ones who know the most techniques — they are the ones who take the most time to understand how each application works, who ask themselves constantly what would happen if the application received input it was not designed to handle, and who do not give up after the first ten attempts on a target. Every topic in this course represents a category of human error — developers who trusted user input they should not have, who forgot to validate file extensions, who did not know their template engine was evaluating user data, who deployed Jenkins without authentication. These errors are made every day, in every type of organization, at every scale — which means the opportunities for the people who know how to find them are essentially unlimited. Your job is to keep learning, to study every publicly disclosed report you can find, to practice in labs, to participate in CTFs, and to start submitting reports even before you feel completely ready — because the feedback you get from real programs will teach you more than any course alone can.

To bring this entire course together — you have completed all 33 topics of the KPWAPT curriculum. You can now enumerate subdomains, fingerprint technologies, dork for exposed services, crawl and fuzz for attack surface, and test systematically for Authentication Bypass, Business Logic Errors, Improper Access Control, XSS, HTML Injection, Open Redirect, No Rate Limiting, Race Condition, Information Disclosure, Username Enumeration, Default Credentials, SQL Injection, CSRF, IDOR, Privilege Escalation, LFI, RCE, SSTI, SSRF, XXE, HTTP Request Smuggling, and Web Cache Poisoning. You have studied hundreds of real HackerOne reports across all of these categories. You know which tools to use — Burp Suite, sqlmap, ghauri, nuclei, xssrecon, bxssreplace, ffuf, subfinder, naabu, httpx, katana, indextree, emailextractor, thorfinn, lfifinder, sqlifinder, gosqli, and more. You have a complete, end-to-end methodology. The three career paths — bug bounty, penetration testing, and red team — are all within your reach. The three certifications — KPWAPT, KPSOC, and KPNET — are your structured roadmap forward. The community at KrazePlanet is here to support you. Now go find some bugs.

1 / 33
Verb Quick Reference
1HAVEPresent
Use with:
IYouWeTheyPlural nouns
  • I have found a vulnerability.
  • They have a bug bounty program.
Trick: I, You, We, They = HAVE — the "group" words.
2HASPresent
Use with:
HeSheItSingular nouns
  • He has reported 50 bugs.
  • The website has an open redirect.
Trick: He, She, It = HAS. Everyone else = HAVE.
3HADPast — ALL subjects
  • I had access to the admin panel.
  • They had a data breach last year.
Trick: HAD = past. Works with ALL subjects.
1DOPresent
Questions & negatives with:
IYouWeThey
  • Do you understand XSS?
  • What do we report here?
2DOESPresent
Questions & negatives with:
HeSheIt
  • Does he know about SSRF?
  • Does it accept file uploads?
Trick: He/She/It = DOES, everyone else = DO. Verb after DOES has no -s.
3DIDPast — ALL subjects
  • Did you find any vulnerabilities?
  • What did the server respond with?
Trick: DID = past. ALL subjects. Verb after DID stays base form.
1CANPresent Ability
Ability nowPermissionPossibility
  • I can bypass this filter.
  • This payload can execute JavaScript.
CAN = ability or permission right now. Same with every subject.
2COULDPast / Polite / Conditional
Past abilityPolite requestsPossibility
  • I could read admin cookies. (past)
  • This bug could lead to RCE. (possibility)
CAN vs COULD: CAN = now. COULD = past or polite.
1WILLFuture
Future actionsPromisesPredictions
  • I will submit the report today.
  • The company will fix the vulnerability.
2WOULDConditional / Polite
HypotheticalPolite requestsIf...
  • I would report this if I found it.
  • This would allow an attacker to gain access.
WILL vs WOULD: WILL = real future. WOULD = imaginary / polite.
1SHALLFormal / Offers
IWe
  • Shall I explain how XSS works?
  • Shall we begin the class?
SHALL with I/We = "Do you want me to...?" — an offer.
2SHOULDAdvice — ALL subjects
AdviceRecommendationExpectation
  • You should always include a PoC.
  • The report should explain impact clearly.
1MAY~50% Possibility
  • This may be an SSRF vulnerability.
  • We may receive the bounty this week.
MAY = "It is possible" (~50%). More certain than MIGHT.
2MIGHT~30% Possibility
  • This might be a false positive.
  • The server might be vulnerable to RCE.
MAY vs MIGHT: MAY = ~50%. MIGHT = ~30% (less sure).
1MUSTStrong Obligation / Deduction
Strong obligationLogical deduction
  • You must stay in scope at all times.
  • He must be a skilled hacker. (deduction)
MUST = obligation that comes from YOU, or a logical deduction.
2HAVE TOExternal Obligation
I/You/We/They → have toHe/She/It → has to
  • I have to follow the program rules.
  • He has to submit a valid PoC.
MUST vs HAVE TO: MUST = your rule. HAVE TO = someone else's rule.
AM / IS / AREPresent
I → AMHe/She/It → ISYou/We/They → ARE
  • I am a bug bounty hunter.
  • It is a critical severity bug.
  • We are testing the API today.
AM = only I. IS = He/She/It. ARE = You/We/They.
WAS / WEREPast
I/He/She/It → WASYou/We/They → WERE
  • It was a P1 severity issue.
  • We were testing the API endpoints.
WAS vs WERE: WAS = singular past. WERE = plural past.
How Negatives Work

Add NOT after any auxiliary verb. Same subject rules apply. Contraction (don't) = informal. Full form (do not) = formal.

DON'T
I/You/We/They
  • I don't test out of scope.
DOESN'T
He/She/It
  • It doesn't validate input.
DIDN'T
ALL subjects (past)
  • I didn't find anything.
CAN'T
ALL subjects
  • I can't access that endpoint.
COULDN'T
ALL subjects (past)
  • I couldn't reproduce the bug.
WON'T
ALL subjects (future)
  • I won't share this publicly.
WOULDN'T
ALL subjects
  • I wouldn't report without a PoC.
SHOULDN'T
ALL subjects
  • You shouldn't go out of scope.
MUSTN'T
ALL subjects
  • You mustn't attack production.
HAVEN'T
I/You/We/They
  • I haven't finished the report.
HASN'T
He/She/It
  • She hasn't responded yet.
ISN'T / AREN'T
He·She·It / You·We·They
  • It isn't valid. They aren't in scope.
WASN'T / WEREN'T
Singular / Plural past
  • It wasn't a P1. They weren't aware.