<?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 Pawan Jaiswal on Medium]]></title>
        <description><![CDATA[Stories by Pawan Jaiswal on Medium]]></description>
        <link>https://medium.com/@pawanjswal?source=rss-c31baf823794------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*o5AizEBQ7NqXFnwDaW4vxg.png</url>
            <title>Stories by Pawan Jaiswal on Medium</title>
            <link>https://medium.com/@pawanjswal?source=rss-c31baf823794------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 02:13:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pawanjswal/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[$1,024 for making Discourse choke on one really long draft]]></title>
            <link>https://pawanjswal.medium.com/1-024-for-making-discourse-choke-on-one-really-long-draft-8f9464a6bd28?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f9464a6bd28</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Thu, 20 Aug 2026 05:28:38 GMT</pubDate>
            <atom:updated>2026-08-20T05:28:38.777Z</atom:updated>
            <content:encoded><![CDATA[<p><em>No exploit chain. No auth bypass. Just an 800,000-character comment box nobody thought to check.</em></p><p><em>Based on </em><a href="https://hackerone.com/reports/3400140"><em>HackerOne report #3400140</em></a><em>, disclosed by Discourse. All credit to researcher </em><a href="https://github.com/dpaysm"><em>dpaysm</em></a><em>.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jl6BoNAV10M3X1ZneDlVBg.png" /><figcaption>How a jumbo draft payload took down a Discourse instance — HackerOne report #3400140</figcaption></figure><p>It’s 6am, someone’s poking at try.discourse.org with Burp Suite open, and they’re about to paste roughly 800,000 characters into a draft field. Not a post. A draft. The kind of field nobody rate-limits because who types a novel into a comment box?</p><p>The server chokes, throws a 502, and then — quietly — saves it anyway.</p><h3>So what was actually broken?</h3><p>Discourse has a drafts feature. Every time you start typing a reply or a new topic, the client periodically autosaves your progress to /drafts.json so you don&#39;t lose your half-written rant if your browser crashes.</p><p>The endpoint is meant for small, frequent writes. Nobody expected someone to hand it an 800,000-character blob in one shot.</p><p>Discourse validates the length of an actual forum <em>post</em> before it gets published. Drafts don’t go through that same gate. So a payload big enough to get instantly rejected as a real message sails right through as a draft.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VWY5ED4bCYe1B31Yb_HWJw.png" /><figcaption>The six-step chain from one oversized draft to a stalled instance — report #3400140</figcaption></figure><h3>Root cause walkthrough</h3><p>Here’s the chain, in order:</p><ol><li><strong>Log in</strong> with any regular account on try.discourse.org — no special privileges needed.</li><li><strong>Intercept a draft request.</strong> The report used Burp Suite to catch a normal POST /drafts.json call.</li><li><strong>Swap in a giant payload.</strong> The researcher used a large text file (linked in the <a href="https://github.com/DpaysmX/payload_/blob/main/payload.txt">original report</a>) as the draft content, roughly 800,000 characters.</li><li><strong>Send it.</strong> The server comes back with a 502 Bad Gateway.</li><li><strong>Check anyway.</strong> Pull up the drafts list, or hit the endpoint with a GET request — the oversized draft is sitting there, saved.</li></ol><p>The 502 makes it look like the request failed. It didn’t. That mismatch is the whole bug: the client sees an error, the attacker sees a saved draft, and the backend has already done the expensive part of the work.</p><h3>The PoC steps</h3><p>The report walks through this escalation in stages, each one building on the last:</p><ul><li><strong>Single oversized draft:</strong> proves the save-despite-502 behavior. One request, one 502, one saved draft that shouldn’t have gotten through.</li><li><strong>Nine unique drafts, same payload:</strong> proves this isn’t a one-off fluke. Discourse throws an “already editing” error if you try to reuse the same draft key, so the report used slight variations (unique sequence numbers) to create nine separate large drafts without tripping that guard.</li><li><strong>Response time monitoring:</strong> after the ninth draft, the report clocked response times up to 32.108 seconds on the <em>same</em> account. That’s the resource-exhaustion signal — the server is visibly struggling under the accumulated load.</li><li><strong>Second device, separate account, separate network:</strong> this is the step that mattered most for severity. When the analyst asked whether this affects <em>other</em> users, the researcher came back with a side-by-side video: one device sending the payloads, a completely unrelated account on a different connection watching its own page loads crawl to 32+ seconds or time out entirely.</li></ul><p>That last step is what turned “annoying bug on my own account” into “this can take down the forum for everyone.”</p><h3>Why this was full compromise (of availability)</h3><p>This isn’t a data-leak bug — nothing here exposes credentials or private content. The impact is entirely about uptime, but it’s a serious one:</p><ul><li>A single authenticated account (no special role required) can degrade response times instance-wide.</li><li>The 502-but-saved behavior means the client-side error message actively hides what’s happening from anyone monitoring naively.</li><li>Nine sequential requests were enough to cause 32+ second delays. Nothing about the technique caps out there — the report notes it’s straightforward to script across multiple accounts or IPs for a bigger effect.</li><li>Because the affected resource (backend request processing) is shared, unrelated endpoints and unrelated users suffer the same slowdown, not just the account running the attack.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*niiRj54VeLFo5ekFNJqofQ.png" /><figcaption>One account, nine drafts, one instance stalled for everyone — report #3400140</figcaption></figure><h3>Timeline</h3><p>That’s over two months from submission to a validated severity call, and about four months total to a shipped fix. Not fast, but not unusual for infra-level availability bugs that need a real backend change rather than a quick input filter.</p><h3>The fix</h3><p>The report doesn’t rank multiple remediation options — Discourse’s own commit is the fix, addressing the gap directly: drafts now get checked against the same kind of size constraints that already applied to published posts, closing the loophole that let oversized content bypass validation by going through the draft path instead of the post path.</p><h3>Takeaways for other hunters</h3><ul><li><strong>Autosave and draft endpoints are often the unguarded sibling of a validated one.</strong> If the “real” endpoint has input limits, check whether the “draft” or “autosave” version enforces the same ones.</li><li><strong>A 502 doesn’t mean nothing happened.</strong> Always verify server-side state after an error response, especially on write endpoints. The client’s error message and the backend’s actual behavior can disagree.</li><li><strong>Reproduce impact on a second, unrelated session before you claim it’s site-wide.</strong> The program specifically asked for this, and it’s what got the severity bumped to High. “It’s slow for me” and “it’s slow for a stranger on a different network” are very different claims.</li><li><strong>Small tweaks (unique keys, sequence numbers) can dodge basic anti-abuse checks.</strong> Worth testing whether a system’s duplicate/conflict guard is actually a rate limit or just a naming collision check.</li><li><strong>DoS reports don’t need to be exotic to be High severity.</strong> No auth bypass, no injection, no clever payload — just a missing length check in the wrong place, applied repeatedly.</li></ul><p><em>Original report: </em><a href="https://hackerone.com/reports/3400140"><em>HackerOne #3400140</em></a><em>. All credit to researcher </em><a href="https://github.com/dpaysm"><em>dpaysm</em></a><em> for the find, the patience through a two-month triage cycle, and the cross-device proof that made this a High-severity finding.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f9464a6bd28" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The bug that made a forum grind to 32 seconds a page — for $1,024]]></title>
            <link>https://pawanjswal.medium.com/the-bug-that-made-a-forum-grind-to-32-seconds-a-page-for-1-024-502a3aab85e8?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/502a3aab85e8</guid>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[hacking]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Wed, 19 Aug 2026 03:48:13 GMT</pubDate>
            <atom:updated>2026-08-19T03:48:13.662Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Nine drafts. No admin access. Just an oversized text field nobody thought to check.</em></p><p><em>Report by </em><a href="https://github.com/dpaysm"><em>dpaysm</em></a><em> via HackerOne, disclosed publicly at </em><a href="https://hackerone.com/reports/3400140"><em>hackerone.com/reports/3400140</em></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1P0sIC2ZWYgWrkGt55u7IA.png" /><figcaption>HackerOne report #3400140: uncontrolled resource consumption in Discourse’s drafts endpoint.</figcaption></figure><p>Picture this. You’re logged into a Discourse forum. You open the compose box, but instead of writing a post, you paste in a payload with roughly 800,000 characters. You hit save.</p><p>The server chokes. It throws back a 502 Bad Gateway.</p><p>And then, quietly, it saves the draft anyway.</p><p>That’s the whole bug, in miniature. And it turned into a High severity (7.5) finding with its own CVE.</p><h3>So what was actually broken?</h3><p>The vulnerable spot was /drafts.json, the endpoint Discourse uses to auto-save whatever you&#39;re typing before you post it.</p><p>Regular posts get checked for size. Try to submit an 800,000-character wall of text as an actual forum post, and validation stops you cold.</p><p>Drafts don’t get that check. So the same oversized payload that gets rejected as a post sails right through as a draft.</p><p>The server still has to process it, though. And processing something that big is what causes the 502 in the first place — the request just takes too long and the gateway gives up waiting.</p><p>But “gives up waiting” doesn’t mean “didn’t happen.” The backend finishes the save after the gateway’s already returned an error to the browser. You get a broken response and a successful write, at the same time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3mhPZK0Jvnnio6_ACUuySA.png" /><figcaption>How one oversized draft turns into a 502 that still saves, per #3400140</figcaption></figure><h3>The root cause walkthrough</h3><p>The report lays out the mechanics in five moves:</p><ol><li><strong>Send an oversized draft.</strong> The researcher used a large payload (linked in the report) submitted through POST /drafts.json, intercepted and modified with a proxy like Burp Suite.</li><li><strong>Get a 502, get a save.</strong> The response comes back broken. The draft doesn’t.</li><li><strong>Repeat with unique keys.</strong> Each new draft needs a distinct ID or key so it doesn’t collide with an “already editing” conflict — the report describes using slight variations across nine drafts to dodge that.</li><li><strong>Fire them off.</strong> Sequentially or in parallel, it doesn’t matter much — either way the backend has to chew through nine oversized payloads instead of one.</li><li><strong>Watch the clock.</strong> Response times for later requests climbed past 32 seconds.</li></ol><p>The researcher was direct about why this matters: <em>“the payload cannot be posted as a message (due to validation), but drafts bypass this, allowing abuse.”</em> That’s the entire vulnerability class in one sentence — a size limit enforced in one place and skipped in another.</p><h3>The PoC steps</h3><p>Here’s the proof-of-concept from the report, walked through step by step:</p><ul><li><strong>Log into a test account</strong> on the target instance (the researcher used try.discourse.org, Discourse&#39;s own hosted demo).</li><li><strong>Intercept a draft request</strong> at POST /drafts.json using a proxy tool.</li><li><strong>Swap in the oversized payload</strong> as the draft content.</li><li><strong>Submit and observe</strong> — 502 error on the response, but a successful save underneath it. This step alone proves the validation gap.</li><li><strong>Create eight more unique drafts</strong> with the same payload, using different keys to avoid conflicts.</li><li><strong>Send all nine</strong> in sequence or parallel and time the responses. This is the step that proves it’s not just a one-off slow request — it’s compounding.</li><li><strong>Cross-check from a second device.</strong> After the program asked whether other users were affected, the researcher logged in from a completely separate device and connection, and recorded both screens side by side. Normal actions — loading a topic, writing a post — took 32+ seconds or timed out entirely on that second account too.</li></ul><p>That last step is the one that turned this from “my own requests are slow” into “the whole instance is slow for everyone on it.”</p><h3>Why this was full compromise (of availability)</h3><p>This isn’t a data-leak bug — it’s an availability one. But the cascading part is real:</p><ul><li>One authenticated account, no special privileges, is enough to trigger it.</li><li>The 502 error actively hides that anything succeeded, so the abuse doesn’t show up as an obvious error to the person doing it, or necessarily to anyone watching logs for failed saves.</li><li>The slowdown isn’t scoped to the attacker’s own session — a second account on a different device and connection saw the same 32-second delays.</li><li>The report notes this could scale further with scripting across multiple accounts or IPs, which would push a single-user annoyance toward genuine, forum-wide unresponsiveness.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6YuQI4_sIiJMjS5iwb4fmg.png" /><figcaption>From nine drafts to a stalled forum, as demonstrated in #3400140</figcaption></figure><h3>The fix</h3><p>The report references a public fix commit and a GitHub security advisory (CVE tracked there, no separate CVE number given in the HackerOne report itself). The core remediation, per the disclosure, is applying the same size validation to drafts that already exists for posts — closing the gap that let this payload through in the first place as a draft when it would’ve been rejected as a message.</p><h3>Takeaways for other hunters</h3><ul><li><strong>Check every endpoint that writes the same underlying data, not just the “main” one.</strong> Posts and drafts write similar content, but only one of them was validated.</li><li><strong>A 502 doesn’t mean “nothing happened.”</strong> Gateway timeouts can hide a completed backend operation. Worth checking state after any error response, not just after a 200.</li><li><strong>DoS reports need a second witness.</strong> The jump from “Needs more info” to Triaged happened because the researcher proved impact on a separate account and device — not just their own slow requests.</li><li><strong>Uniqueness constraints (“already editing” locks) aren’t rate limits.</strong> They stop collisions, not abuse. If you can route around a lock with unique keys, that’s worth testing.</li><li><strong>Patience pays.</strong> Nearly two months passed between “Needs more info” and a bounty. The report shows steady, polite follow-ups rather than dropping it.</li></ul><p><em>Report by </em><a href="https://github.com/dpaysm"><em>dpaysm</em></a><em> via HackerOne, disclosed publicly at </em><a href="https://hackerone.com/reports/3400140"><em>hackerone.com/reports/3400140</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=502a3aab85e8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[$12,000 for one GraphQL field: unauthenticated RCE on the servers that build Firefox]]></title>
            <link>https://pawanjswal.medium.com/12-000-for-one-graphql-field-unauthenticated-rce-on-the-servers-that-build-firefox-fc3ec1467fa0?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc3ec1467fa0</guid>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[graphql-security]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Tue, 18 Aug 2026 15:49:38 GMT</pubDate>
            <atom:updated>2026-08-18T15:49:38.834Z</atom:updated>
            <content:encoded><![CDATA[<p><em>No login. No token. No special header. Just a filter argument nobody validated.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/1*8YW_Y9hHocyqLZTwNMre2A.png" /><figcaption>HackerOne report #3782701 — unauthenticated RCE in Taskcluster, $12,000 bounty</figcaption></figure><p><em>This writeup is based on </em><a href="https://hackerone.com/reports/3782701"><em>HackerOne report #3782701</em></a><em>, disclosed by researcher griffinf to Mozilla. All technical credit belongs to griffinf.</em></p><p>Picture the servers that build and ship Firefox. Locked down, right? Internal, authenticated, boring in the good way.</p><p>Now picture running one curl command against them, with no login of any kind, and getting back proof that your code just executed inside their Node.js process.</p><p>That’s what griffinf found in Mozilla’s Taskcluster deployment. And it wasn’t a subtle bug hiding three layers deep. It was a public GraphQL endpoint that happily ran a string as JavaScript.</p><h3>So what was actually broken?</h3><p>Taskcluster is the CI system Mozilla uses to build Firefox. Its web-server exposes a GraphQL API at /graphql, and one of its query arguments, filter, is just... a free-form JSON object.</p><p>That filter gets handed to a JavaScript library called sift, which lets you write MongoDB-style query filters against in-memory arrays. Sift is popular. Sift is also, in this version, dangerous, because it supports a $where operator. And $where doesn&#39;t just filter data. It runs code.</p><p>The report is blunt about the blast radius: reading the server’s environment variables was enough to walk away with database credentials, the deployment’s own access token, OAuth client secrets, and the encryption keys protecting the database. Not partial access. The report calls it total compromise of the instance, including the one running Firefox CI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/1*Qzp5UC6nfL9IGcxUsIa8Mg.png" /><figcaption>The root cause chain from report #3782701, gray (request) to red (compromise).</figcaption></figure><h3>Root cause walkthrough</h3><p>Here’s the chain, piece by piece, straight from the report.</p><p><strong>1. The filter goes straight into sift, unmodified.</strong> From services/web-server/src/utils/sift.js:</p><pre>import sift from &#39;sift&#39;;<br>export default (filter, array) =&gt; {<br>  if (!array) return [];<br>  return filter ? array.filter(sift(filter)) : array;<br>};</pre><p>Whatever JSON the client sends as filter becomes sift(filter) with the default operator set. Nothing gets stripped. Nothing gets validated.</p><p><strong>2. Sift turns a </strong><strong>$where string into actual code.</strong> From sift 17.1.3:</p><pre>const $where = (params, ownerQuery, options) =&gt; {<br>  let test;<br>  if (isFunction(params)) {<br>    test = params;<br>  } else if (!process.env.CSP_ENABLED) {<br>    test = new Function(&quot;obj&quot;, &quot;return &quot; + params);   // &lt;-- string becomes code<br>  } else {<br>    throw new Error(`In CSP mode, sift does not support strings in &quot;$where&quot; condition`);<br>  }<br>  return new EqualsOperation((b) =&gt; test.bind(b)(b), ownerQuery, options);<br>};</pre><p>There’s a safety switch here. CSP_ENABLED is supposed to make sift refuse a string $where outright. But on this deployment, that variable was never set. So instead of throwing, sift wraps whatever string you send in new Function(...) and runs it. Once per element of the array it&#39;s filtering.</p><p><strong>3. You don’t even need to be logged in for the resolver to run.</strong> The credentials layer at services/web-server/src/servers/credentials.js calls next() when there&#39;s no Authorization header. It doesn&#39;t reject the request. It just lets it through as anonymous. The filter argument then flows through the normal resolver and loader path:</p><pre>Query.expandScopes(scopes, filter)<br>  -&gt; loaders/scopes.js : auth.expandScopes({ scopes })  then  sift(filter, expandedScopes)</pre><p>Same pattern shows up for roles, listRoleIds, hookGroups, hooks, and currentScopes. It&#39;s not a one-off. It&#39;s a shape the whole API repeats.</p><p><strong>4. The anonymous role has exactly the scopes needed.</strong> On firefox-ci-tc, the built-in anonymous role grants auth:expand-scopes, auth:list-roles, auth:current-scopes, and hooks:list-hooks:*. That means the upstream call inside the loader succeeds even for a caller who never authenticated. Sift then runs on the result, and the $where function fires.</p><p>The expandScopes query turned out to be the most reliable trigger, because the upstream handler just echoes back whatever scopes you send it. So an attacker doesn&#39;t need any roles or hooks to already exist on the instance. They can guarantee a non-empty array to filter just by asking for something like assume:anonymous back.</p><p>One more detail that made exploitation easy to confirm: the error formatter in services/web-server/src/servers/formatError.js forwards err.message straight to the client. That gave the researcher a clean, readable output channel for whatever the injected function threw.</p><h3>The proof-of-concept steps</h3><p>The report walks through this in three stages, all unauthenticated, all against the live production endpoint.</p><p><strong>Step one proved code execution with something harmless.</strong> The researcher sent a $where payload built to compute a value on the server and throw it back as an error message, something like RCE_ followed by the result of a server-side multiplication, followed by the type of a Node-specific global. The response confirmed the calculation had actually happened on the server, and confirmed the code was running inside an object of type &quot;object&quot;, i.e. Node&#39;s process global. That ruled out any possibility the payload was just being parsed as inert data. It was executing.</p><p><strong>Step two escalated to shell commands.</strong> Using the same $where injection point, the researcher had the server run a shell command and return its output through the same error channel. The response came back as uid=1000(node) gid=1000(node) groups=1000(node), meaning it wasn&#39;t just executing JavaScript, it had access to spawn processes and read the filesystem, confirmed further with a passwd-file read showing the container&#39;s user list.</p><p><strong>Step three read out the process environment.</strong> With write access to arbitrary Node code, reading process.env was trivial. This is where the report stops being &quot;cool bug&quot; and becomes &quot;here&#39;s how you take the whole thing over.&quot; The dump included live Postgres connection strings, the deployment&#39;s own Taskcluster access token, database column-encryption keys, Pulse message queue credentials, and OAuth client secrets for the login flow, plus a session secret that was, verbatim, the placeholder string FIXME, still sitting in production.</p><p>The researcher confirmed the exact same vulnerability on a second instance, community-tc, with its own equivalent set of credentials exposed.</p><h3>Why this was full compromise</h3><ul><li><strong>Database access, both directions.</strong> Live read and write Postgres credentials for the Taskcluster database.</li><li><strong>A deployment-level access token.</strong> Combined with database access, this effectively hands over the entire Taskcluster instance.</li><li><strong>OAuth client secrets.</strong> Auth0 on the Firefox CI instance, GitHub OAuth on the community instance, enough to attack the login flow itself.</li><li><strong>A broken session secret.</strong> SESSION_SECRET was FIXME in production, meaning session cookies could be forged offline, independent of the RCE entirely.</li><li><strong>Database encryption keys.</strong> DB_CRYPTO_KEYS decrypts whatever the app has stored encrypted at the column level.</li><li><strong>Message queue credentials.</strong> Pulse access, which is Taskcluster’s internal event bus.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/1*NeJ15YrhrxbmwrQgYwdE5g.png" /><figcaption>How one leaked environment on report #3782701 branches into DB, API, OAuth, and session</figcaption></figure><p>Stack all of that up and the report’s own framing is accurate: one unauthenticated POST to /graphql led to cluster-level credential access, which led to full compromise of the Taskcluster instance that Firefox&#39;s own CI runs on.</p><h3>The fix</h3><p>The report ranks its own recommendations by preference, strongest first:</p><ol><li><strong>Stop running sift on untrusted input entirely.</strong> Map the GraphQL filter onto an allowlist of fields and comparison operators, and apply filtering directly, or push filtering down into the upstream service instead.</li><li><strong>If sift has to stay, restrict what it can do.</strong> Build the query tester with a restricted operator set that excludes $where, and reject any $-prefixed key that isn&#39;t explicitly supported before sift ever touches it.</li><li><strong>Fix it at the input layer.</strong> Reject $where at validation, and give filter a real, typed GraphQL input instead of an open JSON scalar.</li></ol><p>The report is also clear that setting CSP_ENABLED is not a real fix, just a fragile flag that happens to change sift&#39;s behavior. On top of the core fix, it recommends setting an actual SESSION_SECRET instead of the literal placeholder, and running the web-server under a sandbox that blocks child-process spawning, so a future JS execution bug doesn&#39;t automatically mean shell access too.</p><p>Because the vulnerable pattern lives in Taskcluster’s main branch, the report notes this isn’t a Mozilla-only problem. Any organization running Taskcluster inherited the same exposure, which is why an upstream security advisory accompanied the fix.</p><h3>Takeaways for other hunters</h3><ul><li><strong>A “free-form JSON filter” argument is a red flag by itself.</strong> Anywhere an API accepts open-ended JSON and hands it to a library like sift, mingo, or similar, go check what operators that library supports before assuming it’s just data filtering.</li><li><strong>Check what “unauthenticated” actually returns, not just whether it’s rejected.</strong> The auth middleware here didn’t reject missing tokens, it silently continued as anonymous. That’s a very different failure mode than a 401, and it’s easy to miss if you only test the happy path.</li><li><strong>Anonymous roles deserve their own audit.</strong> The whole exploit chain depended on the anonymous role having real scopes. A default role with real permissions is often more dangerous than a misconfigured authenticated one, because nobody thinks to review it.</li><li><strong>Error messages are a data exfiltration channel.</strong> Forwarding err.message to the client feels harmless until someone controls what gets thrown.</li><li><strong>A placeholder secret in production is its own vulnerability.</strong> SESSION_SECRET=FIXME sitting in a live deployment is worth flagging even when you find it while looking for something else entirely.</li></ul><p><em>Original report: </em><a href="https://hackerone.com/reports/3782701"><em>HackerOne #3782701</em></a><em>, submitted by griffinf to Mozilla. All credit for discovery, exploitation, and responsible disclosure belongs to the researcher.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc3ec1467fa0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A $1,337 bug let anyone forge a session - if they already knew a UUID and a login was live]]></title>
            <link>https://pawanjswal.medium.com/a-1-337-bug-let-anyone-forge-a-session-if-they-already-knew-a-uuid-and-a-login-was-live-b25943b20ffc?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/b25943b20ffc</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[application-security]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Mon, 17 Aug 2026 05:08:18 GMT</pubDate>
            <atom:updated>2026-08-17T05:08:18.969Z</atom:updated>
            <content:encoded><![CDATA[<p><em>One field in a JWT header. That’s all it took to slip past 8x8’s API.</em></p><p><em>Report by </em><a href="https://hackerone.com/kyotozzx"><em>kyotozzx</em></a><em>, disclosed via HackerOne. Full report: </em><a href="https://hackerone.com/reports/3800870"><em>#3800870</em></a><em>.</em></p><p>Picture a login system that checks your ID card, but never checks who issued it. That’s basically what happened here. Someone could hand connect.8x8.com a token signed with the wrong kind of signature, and the server said “close enough” and let it through.</p><p>This is report #3800870, filed against 8x8’s connect.8x8.com v1 API. It’s a classic JWT algorithm confusion bug, and it earned kyotozzx a $1,337 bounty.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*usxWUrJ8U21dQmqSfUoeWA.png" /><figcaption>Report #3800870–8x8’s v1 API didn’t check which algorithm signed your token.</figcaption></figure><h3>So what was actually broken?</h3><p>Here’s the setup. 8x8’s v1 API uses JWTs — JSON Web Tokens — to prove a request is coming from a logged-in user. Normally these tokens are signed with RS256, an asymmetric algorithm. The server has a private key it signs with, and a public key anyone can use to check the signature. That public key is fine to expose. It’s not a secret.</p><p>But there’s a second common way to sign a JWT: HS256, a symmetric algorithm where the same secret both signs and verifies. And here’s the trap. If your verifier isn’t careful, it might use whatever key is provided for verification without checking which algorithm the token actually claims to use.</p><p>So what happens if you take that public RSA key — the one that’s supposed to be safe to hand out — and use it as the HMAC secret for an HS256 token instead? If the server doesn’t pin the algorithm, it just… accepts it. That’s algorithm confusion in a sentence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-xV2QwiDC2wQB2Nzui28CQ.png" /><figcaption>How report #3800870’s forged token made it past the verifier.</figcaption></figure><h3>The technical chain, as far as the disclosure describes it</h3><p>The summary from 8x8 confirms the mechanism directly: the JWT verifier did not enforce algorithm pinning and would accept HS256 tokens signed with the RSA public key used as an HMAC secret.</p><p>That’s the entire root cause in one line, and it’s precise. No algorithm pinning means the server trusts the alg field in the token header rather than enforcing that only RS256 is valid. Once that&#39;s true, anyone holding the public key — which is, by design, not secret — can mint their own valid-looking tokens.</p><p><strong>A note on what’s not in this writeup:</strong> the disclosed HackerOne page doesn’t include the actual comment thread, which is where kyotozzx would have posted the technical writeup and PoC code. Only the summary and timeline are visible in what’s shared here. So there’s no code block to reproduce, and none has been invented. If you want the full technical detail, the original report link above will have it once you’re logged into HackerOne.</p><h3>The PoC, at the level the disclosure confirms</h3><p>The summary tells us what conditions the PoC had to establish, even without giving the exact commands: exploitation required knowledge of a target user’s non-enumerable UUID and an active server-side session for that user. Under those two conditions, forged tokens were accepted by v1 read endpoints for account information retrieval.</p><p>So the proof-of-concept had three things to demonstrate, in order:</p><ol><li>Obtain a target’s UUID (non-enumerable, so this wasn’t just guessable IDs — the researcher needed a real one).</li><li>Confirm there’s a live session for that user, since the exploit depended on server-side session state being active.</li><li>Forge an HS256 token using the public RSA key, send it to a v1 read endpoint, and get account data back.</li></ol><p>That’s what proves the vulnerability is real and not theoretical — a forged token, accepted, returning data it shouldn’t.</p><h3>Why this stayed contained instead of becoming a full takeover</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ArHdIGhZStf1mi0iYgeEKQ.png" /><figcaption>What report #3800870’s forged token could and couldn’t reach.</figcaption></figure><ul><li>Read endpoints trusted the forged token and handed back account information.</li><li>State-changing endpoints had their own, separate check, and all state-changing endpoints independently rejected forged tokens, limiting impact to read-only access without privilege persistence or account takeover.</li><li>No password reset, no profile edit, no session creation — the blast radius stopped at “read what this account can see.”</li><li>The two prerequisites (a real UUID, plus a live session) also meant this wasn’t a walk-up-and-exploit-anyone bug. It needed some prior reconnaissance or targeting.</li></ul><p>That combination — high severity, but bounded impact — probably explains the severity bump without it turning into a critical.</p><h3>The fix</h3><p>Straightforward, and it’s the textbook remediation for this exact bug class: the v1 API verifier now enforces RS256 algorithm pinning, rejecting any tokens using alternative signature algorithms. The fix has been deployed to production and verified effective.</p><p>In plain terms: the server now decides which algorithm is allowed, not the token. That single check closes the whole hole.</p><h3>Takeaways for other hunters</h3><ol><li>Any time an API supports both RS256 and HS256, ask whether the verifier hardcodes the expected algorithm or trusts the token’s own alg header. If it trusts the header, that&#39;s your bug.</li><li>Public keys aren’t secret, but they can still become a secret in the wrong context — like getting reused as an HMAC key. Think about every place a “public” value gets consumed.</li><li>Read-only endpoints and state-changing endpoints don’t have to share a trust boundary. Here, one authorization check caught what another missed — that’s good defense in depth, worth calling out even when reporting a bug.</li><li>A bug can be high severity without being full compromise. Scope your impact claims to what you actually proved, not what feels dramatic.</li><li>Needing a UUID plus an active session is a real precondition — don’t skip stating your prerequisites clearly in a report. It’s exactly what let 8x8 scope this correctly.</li></ol><p><em>Report by </em><a href="https://hackerone.com/kyotozzx"><em>kyotozzx</em></a><em>, disclosed via HackerOne. Full report: </em><a href="https://hackerone.com/reports/3800870"><em>#3800870</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b25943b20ffc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitLab account takeover, no clicks required — $35,000 bounty]]></title>
            <link>https://pawanjswal.medium.com/gitlab-account-takeover-no-clicks-required-35-000-bounty-5eed7fcc467d?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/5eed7fcc467d</guid>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Mon, 10 Aug 2026 15:53:12 GMT</pubDate>
            <atom:updated>2026-08-10T15:53:12.034Z</atom:updated>
            <content:encoded><![CDATA[<p><em>One curl-worthy array in a password reset request, and the researcher was logging in as anyone.</em></p><p><em>Report by </em><a href="https://hackerone.com/asterion04"><em>asterion04</em></a><em> to GitLab, disclosed via </em><a href="https://hackerone.com/reports/2293343"><em>HackerOne #2293343</em></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RoNUj48p4jHwKajsCLsOFg.png" /><figcaption>HackerOne report #2293343 — GitLab account takeover, $35,000 bounty.</figcaption></figure><p>It’s late 2023. Someone’s sitting in Burp Suite, staring at a “forgot your password?” form. Nothing fancy yet — just a normal reset request with one email address in it.</p><p>Then they right-click. Convert to JSON. And swap one string for an array.</p><p>That’s it. That’s the whole exploit.</p><h3>So what was actually broken?</h3><p>GitLab’s password reset flow takes an email address, looks up the matching account, and sends a reset link to that address. Standard stuff.</p><p>The problem: the backend accepted user[email] as an array instead of a single string, and didn&#39;t push back when that array contained more than one address. Convert the request to JSON, list two emails instead of one, and GitLab happily generated a reset token and mailed it to both.</p><p>One of those emails belonged to the victim. The other belonged to whoever was making the request.</p><h3>Root cause walkthrough</h3><p>The report lays out the exact request tampering. Starting point — the normal reset form submission looked like this in the intercepted request:</p><pre>&quot;user[email]&quot;:&quot;victim@gmail.com&quot;</pre><p>The fix (from the attacker’s side, not GitLab’s) was to convert the request to JSON using Burp’s Content-Type Converter extension, then change that single field into an array carrying two addresses:</p><pre>&quot;user&quot; {<br>     &quot;email&quot; [<br>             &quot;victim@gmail.com&quot;,<br>             &quot;attacker@gmail.com&quot;<br>      ]<br> },</pre><p>Forward that, and the backend doesn’t reject the array or split it apart — it just iterates over both entries and treats each one as a valid recipient for the same reset token. No auth check catches this because there’s nothing to authenticate. It’s a public, unauthenticated endpoint. All it needs is knowledge of the target’s email.</p><h3>The PoC steps</h3><p>Walking through what the report actually demonstrated, in order:</p><ol><li>Go to the “Forgot your password?” link on GitLab — no login needed, this is the whole point.</li><li>Enter the victim’s email and intercept the submit request in Burp Suite.</li><li>Use the Content-Type Converter extension to convert the request body to JSON.</li><li>Replace the single user[email] string with an array containing both the victim&#39;s email and the attacker&#39;s own email.</li><li>Forward the modified request.</li><li>Both addresses receive an email containing the exact same password reset link.</li><li>Click the link, set a new password, and log in as the victim.</li></ol><p>Each step proves something specific: steps 1–2 prove the entry point needs zero authentication, step 4 proves the input isn’t validated for type or cardinality, and steps 6–7 prove the token isn’t bound to a single verified recipient.</p><h3>Why this was full compromise</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*czwbh19l9W_hRZEZiQS8cQ.png" /><figcaption>The full request chain from report #2293343 — one array turns a password reset into a takeover.</figcaption></figure><p>The report frames the impact simply: knowing a victim’s email address is enough to fully take over their account, with zero interaction from that victim. No phishing, no social engineering, no MFA bypass tricks — just a malformed request. That’s what pushed the severity to critical.</p><ul><li>The victim never sees anything unusual — the reset email looks completely normal, with a legitimate GitLab-issued token.</li><li>The attacker doesn’t need any prior access to the account, only the email address, which for many orgs is a predictable format (firstname.lastname@company.com).</li><li>Once the password is reset, the attacker inherits whatever that account can reach — private repositories, CI/CD variables, and any linked integrations.</li><li>Because it’s silent, there’s no failed-login alert or suspicious-activity trigger for the victim to notice before it’s too late.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pEQZQr7hJbVFjP7lh-01Lg.png" /><figcaption>How one leaked reset link cascades, per report #2293343’s stated impact.</figcaption></figure><p>Total bounty across both payouts: $35,000. No CVE was assigned to this report.</p><h3>The fix</h3><p>The disclosed report doesn’t include a remediation section or describe GitLab’s actual code fix — so rather than guess at what GitLab shipped, here’s what the underlying flaw calls for in general terms:</p><ul><li>Reject non-string types on the email parameter of the password reset endpoint outright, rather than iterating over whatever the client sends.</li><li>Enforce strict schema validation on all password-reset-adjacent endpoints, not just type checking on the happy path.</li><li>Bind the generated reset token to a single verified recipient at generation time, so even a malformed request can’t fan a token out to multiple addresses.</li></ul><p>If you want GitLab’s specific patch details, they aren’t part of this disclosure — the HackerOne report itself only documents the vulnerability, the timeline, and the bounty.</p><h3>Takeaways for other hunters</h3><ul><li>Content-Type conversion is an underused move. Turning form-encoded params into JSON is often the fastest way to discover a backend never validated types in the first place.</li><li>Arrays are a classic mass-assignment style vector, even outside old Rails-specific bugs — always test whether a “single value” field secretly accepts a list.</li><li>Auth-free endpoints deserve extra scrutiny precisely because there’s no session context to muddy the exploit — password reset, account recovery, and email verification flows are prime targets.</li><li>Silent, no-interaction account takeovers get rated critical for a reason: the victim has no signal anything happened until it’s too late.</li><li>A jump from $1,000 to $34,000 on the same report shows how severity reassessment mid-triage can dramatically change payout — don’t assume the first bounty offer reflects the final impact assessment.</li></ul><p><em>Report by </em><a href="https://hackerone.com/asterion04"><em>asterion04</em></a><em>, disclosed via </em><a href="https://hackerone.com/reports/2293343"><em>HackerOne #2293343</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5eed7fcc467d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The AI Boom Has a Math Problem]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://cybersecuritywriteups.com/the-ai-boom-has-a-math-problem-554cfbaaab75?source=rss-c31baf823794------2"><img src="https://cdn-images-1.medium.com/max/1536/1*bXJ8-Pn28OvG0AYjmuAwBw.png" width="1536"></a></p><p class="medium-feed-snippet">The technology may be impressive. The business model still has to survive contact with reality.</p><p class="medium-feed-link"><a href="https://cybersecuritywriteups.com/the-ai-boom-has-a-math-problem-554cfbaaab75?source=rss-c31baf823794------2">Continue reading on Cyber Security Write-ups »</a></p></div>]]></description>
            <link>https://cybersecuritywriteups.com/the-ai-boom-has-a-math-problem-554cfbaaab75?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/554cfbaaab75</guid>
            <category><![CDATA[tech-economics]]></category>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-boom]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Wed, 10 Jun 2026 10:20:45 GMT</pubDate>
            <atom:updated>2026-06-10T10:20:45.324Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Job Was Never Just Writing Code]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://pawanjswal.medium.com/the-job-was-never-just-writing-code-0b9158c7cced?source=rss-c31baf823794------2"><img src="https://cdn-images-1.medium.com/max/1536/1*GFnancbp37pm2UAP6d1ffQ.png" width="1536"></a></p><p class="medium-feed-snippet">AI is forcing software engineers to ask an uncomfortable question: what part of the work was truly ours?</p><p class="medium-feed-link"><a href="https://pawanjswal.medium.com/the-job-was-never-just-writing-code-0b9158c7cced?source=rss-c31baf823794------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://pawanjswal.medium.com/the-job-was-never-just-writing-code-0b9158c7cced?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/0b9158c7cced</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[tech-leadership]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[futureof-work]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Tue, 09 Jun 2026 17:36:00 GMT</pubDate>
            <atom:updated>2026-06-09T17:36:00.346Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Moment AI Stops Looking Like a Tool]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://osintteam.blog/the-moment-ai-stops-looking-like-a-tool-a7256d4d38af?source=rss-c31baf823794------2"><img src="https://cdn-images-1.medium.com/max/1536/1*5uwGVt1ULVSlDxV0AgPGqw.png" width="1536"></a></p><p class="medium-feed-snippet">We are not shocked by what AI can answer. We are shocked by what it lets ordinary people attempt.</p><p class="medium-feed-link"><a href="https://osintteam.blog/the-moment-ai-stops-looking-like-a-tool-a7256d4d38af?source=rss-c31baf823794------2">Continue reading on OSINT Team »</a></p></div>]]></description>
            <link>https://osintteam.blog/the-moment-ai-stops-looking-like-a-tool-a7256d4d38af?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/a7256d4d38af</guid>
            <category><![CDATA[futureof-work]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[innovation]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Sun, 07 Jun 2026 06:15:56 GMT</pubDate>
            <atom:updated>2026-06-08T02:05:14.839Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Most Dangerous Security Bug Is the One That Feels Like a Feature]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://infosecwriteups.com/the-most-dangerous-security-bug-is-the-one-that-feels-like-a-feature-6339d438b3a5?source=rss-c31baf823794------2"><img src="https://cdn-images-1.medium.com/max/1672/1*YT8aMxB1SJQo2sYR8Fut3g.png" width="1672"></a></p><p class="medium-feed-snippet">A single click should not carry the weight of your entire developer identity.</p><p class="medium-feed-link"><a href="https://infosecwriteups.com/the-most-dangerous-security-bug-is-the-one-that-feels-like-a-feature-6339d438b3a5?source=rss-c31baf823794------2">Continue reading on InfoSec Write-ups »</a></p></div>]]></description>
            <link>https://infosecwriteups.com/the-most-dangerous-security-bug-is-the-one-that-feels-like-a-feature-6339d438b3a5?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/6339d438b3a5</guid>
            <category><![CDATA[devsecops]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[security-engineering]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Sat, 06 Jun 2026 05:42:34 GMT</pubDate>
            <atom:updated>2026-06-07T14:47:27.274Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The AI Security Test We Should All Be Paying Attention To]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://cybersecuritywriteups.com/the-ai-security-test-we-should-all-be-paying-attention-to-f41f9431b97b?source=rss-c31baf823794------2"><img src="https://cdn-images-1.medium.com/max/1536/1*eEtlyzST42jbC9VIMM6ocg.png" width="1536"></a></p><p class="medium-feed-snippet">When an AI system can find a vulnerability, but hesitates to touch it, what exactly are we measuring?</p><p class="medium-feed-link"><a href="https://cybersecuritywriteups.com/the-ai-security-test-we-should-all-be-paying-attention-to-f41f9431b97b?source=rss-c31baf823794------2">Continue reading on Cyber Security Write-ups »</a></p></div>]]></description>
            <link>https://cybersecuritywriteups.com/the-ai-security-test-we-should-all-be-paying-attention-to-f41f9431b97b?source=rss-c31baf823794------2</link>
            <guid isPermaLink="false">https://medium.com/p/f41f9431b97b</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ai-security]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[security-research]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Pawan Jaiswal]]></dc:creator>
            <pubDate>Fri, 05 Jun 2026 16:05:29 GMT</pubDate>
            <atom:updated>2026-06-05T16:08:49.902Z</atom:updated>
        </item>
    </channel>
</rss>