<?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 Xp10it on Medium]]></title>
        <description><![CDATA[Stories by Xp10it on Medium]]></description>
        <link>https://medium.com/@Xp10it?source=rss-c651876a708b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Xs8chOZmRynihkoTeqZqcg.jpeg</url>
            <title>Stories by Xp10it on Medium</title>
            <link>https://medium.com/@Xp10it?source=rss-c651876a708b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 22:41:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@Xp10it/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[When SQL Injection Hides Behind Encoding — A Blind SQLi That Automation Missed]]></title>
            <link>https://medium.com/@Xp10it/when-sql-injection-hides-behind-encoding-a-blind-sqli-that-automation-missed-2b74f9bb64e7?source=rss-c651876a708b------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b74f9bb64e7</guid>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty-tips]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[bug-bounty-writeup]]></category>
            <dc:creator><![CDATA[Xp10it]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 04:01:02 GMT</pubDate>
            <atom:updated>2026-03-18T04:01:02.537Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YUtQd041JyfC2J9leUrT6Q.gif" /></figure><p>Some vulnerabilities announce themselves immediately.</p><p>This one didn’t.</p><p>No error messages. No stack traces. No SQL syntax warnings.</p><p>Just a response that took longer than it should have.</p><p>During an authorized security assessment, I identified a time-based blind SQL injection vulnerability in a backend API endpoint. Automated tooling missed it entirely on the first pass — not because the vulnerability was sophisticated, but because the application processed input in a way the tool didn’t account for.</p><p>Once that was understood, everything changed.</p><h3>The Entry Point: A Backend API Endpoint</h3><p>The target was a GET-based API endpoint handling parameter validation during a login-related workflow.</p><p>GET /api/v2/clogin?apikey=12334&amp;type=check&amp;u=CXTgnn</p><p>On the surface it looked unremarkable:</p><ul><li>Simple GET request</li><li>Short parameter list</li><li>Fast, consistent responses — 47ms baseline</li></ul><p>Nothing immediately suggested injection. But Burp’s active scanner flagged a possible timing anomaly on one of the parameters.</p><p>That was enough to dig deeper.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vBodYRcZGiD8KWC9A9D-dA.png" /><figcaption><em>Baseline request, 47ms response time.</em></figcaption></figure><h3>Shifting the Testing Mindset</h3><p>The temptation at this point is to hand it straight to sqlmap and move on.</p><p>Instead, I asked a different question:</p><p><em>What is the application actually doing with this input before the backend sees it?</em></p><p>Not what the parameter looks like in the request. What happens to it in transit.</p><p>That question changed the entire approach.</p><h3>The First Signal: 35 Seconds of Silence</h3><p>Before touching any tooling, I validated the timing behaviour manually.</p><p>I crafted a simple delay-based payload and injected it directly into the u parameter:</p><p>CXTgnn&#39;+(select*from(select(sleep(35)))a)+&#39;</p><p>The response came back in <strong>35,054ms</strong>.</p><p>Baseline was 47ms.</p><p>No error. No output. Just a 35-second delay — exactly as instructed.</p><p>The backend was executing injected SQL logic. It just wasn’t returning any output.</p><p>That’s the definition of blind SQL injection.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mrGPFbs6XZbnXpHXTuqCiw.png" /><figcaption><em>URL-decode → base64-decode → plain payload chain</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7gWCDRKdpwato7l2hQm5Qw.png" /><figcaption><em>Same request with encoded payload. Response time: 35,054ms</em></figcaption></figure><h3>Why Naive Automation Would Fail Here</h3><p>Before running any tooling, I understood why a standard sqlmap run would come up empty.</p><p>The u parameter wasn&#39;t consumed as raw input. Looking at the request flow revealed a two-step transformation happening before the backend ever saw the value:</p><ol><li>The plain value was <strong>Base64-encoded</strong></li><li>Then <strong>URL-encoded</strong></li><li>Only then passed to backend logic</li></ol><p>Any tool injecting raw SQL payloads directly into u would be sending input the backend never actually received in that form. The payloads would be decoded into something unrecognizable — and the injection would silently fail.</p><p>The tool needed to speak the application’s language first.</p><h3>Teaching the Tool How the Application Thinks</h3><p>The fix was to tell sqlmap exactly how to transform its payloads before sending them.</p><pre>sqlmap -u &quot;https://[target]/api/v2/clogin?apikey=12334&amp;type=check&amp;u=INJECT_HERE&quot; \<br>--eval=&quot;import urllib.parse, base64; u=urllib.parse.quote(base64.b64encode(u.encode()).decode())&quot; \<br>--technique=T \<br>--batch --level=5 --risk=3 \<br>--dbs</pre><p>The --eval flag instructs sqlmap to run a Python expression against the parameter value before each request — in this case, Base64-encoding then URL-encoding the payload to match exactly what the application expected.</p><p>The behaviour changed immediately.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q9jSXeIjLzqWRJU39xqIKw.png" /><figcaption>sqlmap run with — eval flag showing the Base64 + URL encoding eval expression and technique=T targeting the u parameter.</figcaption></figure><h3>Impact: Full Database Enumeration</h3><p>Despite being entirely blind — no error output, no reflected data, no stack traces — the injection led to:</p><ul><li>Backend DBMS confirmed: <strong>MySQL ≥ 5.0.12</strong></li><li><strong>5 databases</strong> enumerated</li><li><strong>88 tables</strong> retrieved from the target database</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wuxc_dfGy87QMvlaIxVaxw.png" /><figcaption>u parameter confirmed vulnerable. MySQL ≥ 5.0.12 identified. 5 databases enumerated including information_schema, mysql, performance_schema, sys, and redacted target database.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n_Xc8JkVFfTfbV8OfeRaHA.png" /><figcaption>Second sqlmap run targeting specific database with — tables flag.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F8jHgmHVIT1-GYvpohY29A.png" /><figcaption>88 tables retrieved. Table names visible including admin, audit_log_db, chatbot_log, companies, dashboard and more.</figcaption></figure><p>All extracted character by character through timing alone.</p><p>This wasn’t a noisy attack. It was patient, quiet, and reliable.</p><h3>Why Encoding Isn’t Protection</h3><p>The encoding layer on this parameter likely gave a false sense of security.</p><p>From a developer’s perspective, a Base64 + URL-encoded value looks nothing like a SQL payload. It doesn’t trigger naive input validation. It doesn’t match obvious injection signatures.</p><p>But encoding is transformation, not sanitization.</p><p>The backend decoded the value before passing it to the query layer. At that point, the payload was exactly what it was designed to be.</p><p>Encoding delayed discovery. It didn’t prevent exploitation.</p><h3>The Architectural Failure</h3><p>This came down to two missing controls:</p><ul><li>No parameterized queries or prepared statements on the backend</li><li>Input transformation mistaken for input validation</li></ul><p>Security tools don’t fail because they’re weak. They fail when the tester doesn’t adapt them to how the application actually processes input.</p><p>Once the encoding logic was understood and replicated, the vulnerability that appeared invisible became fully exploitable.</p><h3>Final Thought</h3><p>This vulnerability wasn’t about finding a clever bypass.</p><p>It was about reading the application correctly.</p><p>When systems assume that transformation equals protection, blind vulnerabilities don’t disappear — they just wait longer to be found.</p><p>The 47ms baseline told one story. The 35-second delay told the truth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/675/1*XmbemWUnIesILeSDHaMCxg.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b74f9bb64e7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When Deleting One File Deletes Everything: An Unauthenticated BOLA in an AI Analytics Portal]]></title>
            <link>https://medium.com/@Xp10it/when-deleting-one-file-deletes-everything-an-unauthenticated-bola-in-an-ai-analytics-portal-600b3957803e?source=rss-c651876a708b------2</link>
            <guid isPermaLink="false">https://medium.com/p/600b3957803e</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[bug-bounty-tips]]></category>
            <category><![CDATA[bug-bounty-writeup]]></category>
            <dc:creator><![CDATA[Xp10it]]></dc:creator>
            <pubDate>Fri, 06 Mar 2026 03:46:00 GMT</pubDate>
            <atom:updated>2026-03-06T03:46:00.909Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qZxRLc_cIWfmHkieWjDRJw.png" /></figure><p>Most authorization bugs announce themselves loudly.</p><p>This one didn’t.</p><p>There was no error message. No access denied. No permission prompt.</p><p>Just a Delete action that quietly worked — every single time.</p><p>During an authorized security assessment, I identified a Broken Object Level Authorization (BOLA) vulnerability in an AI-powered analytics portal that allowed complete destruction of an administrative document repository — without a single valid credential.</p><h3>The Target: An AI Analytics Dashboard</h3><p>The application was an internal analytics portal used to manage documents related to business requirements, issue tracking, and system configurations.</p><p>It was also AI-backed.</p><p>Documents weren’t just stored here — they fed the system’s decision layer. The AI used them to inform workflows, generate summaries, and drive operational outputs.</p><p>From the surface, nothing looked unusual:</p><ul><li>A login page</li><li>A dashboard listing uploaded documents</li><li>Delete icons next to each file</li></ul><p>Standard admin UI. Nothing that immediately suggested a problem.</p><p>Until I intercepted the request.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8doFVqv167RuJSEM0vuFZw.png" /><figcaption><em>The analytics dashboard. Document list visible, delete icon on test.txt highlighted.</em></figcaption></figure><h3>Shifting the Testing Mindset</h3><p>When approaching admin portals, the temptation is to focus on what’s visible — the login form, the session token, the UI controls.</p><p>Instead, I asked a different question:</p><p><em>What does the server actually verify before it acts?</em></p><p>Not what the UI suggests. Not what the design implies.</p><p>What the backend actually checks.</p><p>That question led directly to the vulnerability.</p><h3>The First Clue: A DELETE Request Without a Session</h3><p>Clicking the delete icon triggered a simple HTTP request:</p><ul><li>Method: DELETE</li><li>Endpoint: /dashboard/documents/168</li><li>Identifier: a predictable numeric value</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QJ__skBkR4h3KGcYYXvHhA.png" /><figcaption><em>Burp intercept of DELETE /dashboard/documents/168, captured before execution. Drop button visible — request has not fired yet.</em></figcaption></figure><p>What stood out immediately was what the request did <em>not</em> contain:</p><ul><li>No authorization header</li><li>No session token</li><li>No ownership check</li><li>No CSRF protection tied to a session</li></ul><p>This raised a straightforward question.</p><p><em>What happens if this request is sent without being logged in at all?</em></p><h3>Removing Authentication Entirely</h3><p>To test this, I started by logging out completely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GRK0fJFGkCr0PepzJ8zzmw.png" /><figcaption><em>Logout button clicked, active session terminated.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*91Ha8VUnn1N8eOfgumizLg.png" /><figcaption><em>Redirected to login page. No active session. No credentials.</em></figcaption></figure><p>With no session in place, I loaded the same DELETE request into Burp Repeater exactly as captured.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jWNwB8tmHheRBZlsSzE-Rw.png" /><figcaption><em>DELETE request loaded in Burp Repeater. Unauthenticated. No session token. Ready to send.</em></figcaption></figure><p>Then I sent it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DGZHtTCK2ckdo9uDWIgzkg.png" /><figcaption><em>HTTP 200 OK. The server accepted and executed a destructive action from an unauthenticated request.</em></figcaption></figure><p>The document was permanently deleted.</p><p>This wasn’t a UI quirk. This wasn’t a race condition. This wasn’t a caching artifact.</p><p>The server had accepted and executed a destructive action from a request with no session, no token, and no identity.</p><h3>Validation: Logging Back In</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gj1ADs2YQMjAllAYCz46KQ.png" /><figcaption><em>Logging back in to verify the deletion.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2-9BZgP1x4l791a_y7WMLQ.png" /><figcaption><em>test.txt is gone. Dashboard reflects the deletion. Red box highlights the missing entry.</em></figcaption></figure><p>The deletion was real. Permanent. Server-confirmed.</p><h3>Escalation: Predictable IDs, Unlimited Scope</h3><p>The document identifiers followed a simple numeric sequence.</p><p>By incrementing the ID value across requests:</p><ul><li>Any document in the repository could be targeted</li><li>Deletion succeeded regardless of who uploaded it</li><li>No role validation was enforced</li><li>No audit barrier existed</li></ul><p>The impact became clear almost immediately.</p><p><strong>Any external actor could wipe the entire document corpus. No credentials required. No brute force. No privilege escalation.</strong></p><p>Just a DELETE request with a predictable number.</p><h3>Why This Is Worse Than Typical BOLA</h3><p>Most BOLA vulnerabilities involve authenticated users accessing objects that belong to other users.</p><p>This was a more fundamental failure.</p><p>The server operated on a single assumption: <em>if the request shape is correct and the object ID exists, the operation is allowed.</em></p><p>There was no verification of who was asking. No check on whether the caller had a session. No ownership validation. No distinction between an authenticated admin and an anonymous external request.</p><p>Authorization had been designed out of the flow entirely.</p><h3>Why the AI Context Makes This Worse</h3><p>In a standard document repository, mass deletion is serious but recoverable — if backups exist.</p><p>In an AI-backed system, the impact is a different category of damage.</p><p>Documents here weren’t passive storage. They were the system’s operational memory:</p><ul><li>They trained and informed the AI’s outputs</li><li>They defined business workflows</li><li>They influenced decisions the system was trusted to make</li></ul><p>Deleting them wasn’t just data loss. It was silent operational sabotage.</p><p>An attacker wouldn’t need persistence. Wouldn’t need stealth. Wouldn’t need to understand the AI layer at all.</p><p>They could simply erase the foundation it relied on — and the system would continue running, quietly operating on nothing.</p><h3>The Architectural Failure</h3><p>This wasn’t a sophisticated bug. It came down to three missing controls:</p><ul><li>No authentication check on destructive endpoints</li><li>No authorization or ownership validation</li><li>Predictable object identifiers with no rate limiting or anomaly detection</li></ul><p>Security didn’t fail because of advanced exploitation.</p><p>It failed because the system never asked who was making the request.</p><h3>Final Thought</h3><p>Authorization vulnerabilities don’t always leak data.</p><p>Sometimes they delete it.</p><p>When systems treat object identifiers as proof of trust — particularly on destructive, irreversible actions — the question is no longer <em>whether</em> something breaks. It’s how much disappears before anyone notices.</p><p>In AI-integrated environments, that question carries even more weight. The data and the intelligence built on top of it are gone together.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=600b3957803e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SSRF via Stored Profile Data in an AI Chatbot — A Real-World Case Study]]></title>
            <link>https://medium.com/@Xp10it/ssrf-via-stored-profile-data-in-an-ai-chatbot-a-real-world-case-study-83355beac933?source=rss-c651876a708b------2</link>
            <guid isPermaLink="false">https://medium.com/p/83355beac933</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Xp10it]]></dc:creator>
            <pubDate>Sun, 22 Feb 2026 03:56:01 GMT</pubDate>
            <atom:updated>2026-02-22T03:56:01.092Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t_9ZbnGYZl3DF397yTvVWw.png" /></figure><p>AI chatbots are often introduced as <em>safe assistants</em>.</p><p>They summarize policies.<br>They guide users through workflows.<br>They answer questions using internal data.</p><p>During this assessment, one such chatbot did exactly that — until it quietly performed a <strong>server-side HTTP request</strong> it should never have made.</p><p>This vulnerability wasn’t caused by a classic SSRF input field.<br>It emerged from <strong>how AI systems interpret stored user context</strong>.</p><blockquote><strong>The Chatbot Looked Low Risk by Design</strong></blockquote><p>The application included an AI-powered chatbot designed for operational assistance:</p><ul><li>Fetching policy details</li><li>Summarizing documents</li><li>Explaining how to complete policy workflows</li><li>Providing instructional text or videos</li></ul><p>There was no visible URL input.<br>No webhook configuration.<br>No feature that obviously allowed outbound requests.</p><p>From a traditional security perspective, this looked harmless.</p><p>But AI systems don’t behave like static forms.</p><p>They <strong>reason over context</strong>.</p><blockquote><strong>Shifting the Testing Mindset</strong></blockquote><p>Instead of asking:</p><p>“What input fields can I inject into?”</p><p>I asked:</p><p>“What data does the AI <em>trust</em>, and when does it act on it?”</p><p>The answer was <strong>stored profile data</strong>.</p><p>User-controlled profile information persisted and later consumed by the chatbot to personalize responses and drive behaviour.</p><p>That persistence mattered.</p><blockquote><strong>Direct Execution Attempts Were Blocked</strong></blockquote><p>Initial direct attempts to introduce executable elements — such as raw iframe payloads or obvious embedded references — were rejected by the chatbot’s safety mechanisms.</p><p>The model correctly refused straightforward execution patterns.</p><p>That indicated guardrails were present.</p><p>The vulnerability did not rely on bypassing those guardrails.</p><p>It emerged when stored contextual data was later interpreted and acted upon indirectly by backend logic.</p><p>That distinction is important.</p><blockquote><strong>Modelling Adversarial Context</strong></blockquote><p>To simulate a realistic adversarial scenario, I crafted a semantically valid instruction aligned with the chatbot’s operational role.</p><p>The input did not look overtly malicious.<br>It resembled configuration or diagnostic guidance.</p><p>It included a controlled external reference (Burp Collaborator) embedded naturally within contextual instructions.</p><p>The prompt was submitted through the normal chatbot interface and stored as profile context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LqU240664Ml13LULrsq41Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WYgA0FwC6A7xiaUTfFYc9g.png" /></figure><p>Nothing happened immediately.</p><p>That delay was critical.</p><blockquote><strong>When Stored Data Became Execution</strong></blockquote><p>Later, when the chatbot processed the stored profile data, it attempted to <strong>interpret and act on that context</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ARTzKLBaHk-ihFRLt92pRQ.png" /></figure><p>At that moment, my Burp Collaborator instance received multiple inbound requests.</p><p>There was:</p><ul><li>No browser fetch</li><li>No client-side JavaScript execution</li><li>No direct user interaction</li></ul><p>The request originated entirely from the <strong>server-side environment</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j1DlGlgdyeu0264Yr_il1A.png" /></figure><p>This confirmed it.</p><p><strong>Server-Side Request Forgery</strong>, triggered indirectly through AI-driven processing of stored data.</p><blockquote><strong>Why This Wasn’t A Traditional SSRF</strong></blockquote><p>This vulnerability didn’t match classic SSRF patterns:</p><ul><li>No URL parameter</li><li>No webhook endpoint</li><li>No fetch API exposed to the user</li></ul><p>The SSRF primitive only emerged because:</p><ol><li>User-controlled data was stored</li><li>An AI system later reinterpreted that data</li><li>The AI system attempted to act on its meaning</li></ol><p>In this design, AI was not just generating text.</p><p>It was influencing system behaviour.</p><p>That shift matters.</p><blockquote><strong>The AI Security Lesson</strong></blockquote><p>This issue was not about “prompt injection” in the typical sense.</p><p>The AI did not reveal secrets.<br>It did not jailbreak.<br>It did not hallucinate sensitive data.</p><p>The failure was architectural.</p><p>Semantic interpretation was allowed to influence execution.</p><p>When AI systems are granted contextual authority without strict execution boundaries, stored text can become action.</p><p>Traditional input validation does not catch that.</p><blockquote><strong>Why This Matters in Real Systems</strong></blockquote><p>As AI systems become embedded in business workflows, new risks emerge:</p><ul><li>Stored data can become delayed execution</li><li>Context reuse introduces time-shifted attacks</li><li>AI models act on meaning, not syntax</li><li>“Read-only” assistants can become active components</li></ul><p>This creates SSRF risk <strong>without ever exposing a URL field</strong>.</p><blockquote><strong>Potential impact</strong></blockquote><p>If exploited beyond proof-of-concept, this class of issue could enable:</p><ul><li>Internal service probing</li><li>Cloud metadata access</li><li>Unauthorized outbound requests</li><li>Chaining into broader compromise</li></ul><p>All triggered by <strong>stored profile content</strong>.</p><blockquote><strong>What Should Have Been Done Differently</strong></blockquote><p>Secure AI-integrated systems should ensure that:</p><ul><li>AI components never implicitly fetch external resources</li><li>Stored user data is treated as untrusted context</li><li>Network access from AI processing layers is restricted</li><li>Prompt interpretation is sandboxed from execution</li><li>Outbound requests are explicitly whitelisted and logged</li></ul><p>AI systems should <strong>describe information</strong>, not <strong>act on it</strong>.</p><blockquote><strong>Final takeaway</strong></blockquote><p>This vulnerability didn’t exploit the AI model itself.</p><p>It exploited the <strong>assumptions made about AI behaviour</strong>.</p><p>When applications allow AI systems to interpret stored user data without boundaries, they don’t just risk hallucinations — they risk execution.</p><blockquote><strong>Security isn’t about what users type. It’s about what systems are willing to act on.</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=83355beac933" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Payment Bypass: When “Payment Successful” Was Just a Suggestion]]></title>
            <link>https://medium.com/@Xp10it/payment-bypass-when-payment-successful-was-just-a-suggestion-262e3c52f470?source=rss-c651876a708b------2</link>
            <guid isPermaLink="false">https://medium.com/p/262e3c52f470</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[fintech]]></category>
            <dc:creator><![CDATA[Xp10it]]></dc:creator>
            <pubDate>Thu, 12 Feb 2026 03:46:01 GMT</pubDate>
            <atom:updated>2026-02-12T03:46:01.050Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-KeAD5gu-_AZqNFPUADsbw.png" /></figure><p>Payment flows are built on trust.</p><p>When a system displays <em>“Payment Successful,”</em> everyone assumes the hardest part is over.<br>Money must have moved.<br>The transaction must be valid.<br>The policy must be real.</p><p>This vulnerability existed because that assumption was wrong.</p><blockquote><strong>A payment flow that looked completely normal</strong></blockquote><p>During an authorized security assessment, I was reviewing an online payment flow used to issue insurance policies.</p><p>From the user’s perspective, the journey was standard:</p><ul><li>A quotation was selected</li><li>The user proceeded to payment</li><li>A third-party payment gateway was used</li><li>A success page confirmed the transaction</li></ul><p>Nothing about the UI looked suspicious.</p><p>But payment security doesn’t live in the UI.<br>It lives in <strong>how the backend decides that a payment actually happened</strong>.</p><p>In this case, the weakness was not in object references or authorization checks — it was in how payment state itself was trusted.</p><blockquote><strong>Ignoring the UI and watching the decision</strong></blockquote><p>I intentionally completed the payment using the simulator in <strong>failure mode</strong>.<br>The gateway clearly returned a failed transaction.<br>The user interface reflected that outcome.</p><p>But I wasn’t interested in the UI — I was interested in how the backend reacted to failure.</p><p>The browser was redirected back with multiple parameters indicating:</p><ul><li>Transaction identifiers</li><li>Payment status</li><li>Quotation and policy references</li></ul><p>Those values were treated as authoritative.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2TLlyzrNh7DMidhzBSJVVQ.png" /><figcaption>Initiated Failed Payment Transaction on Payment Gateway</figcaption></figure><p>At this point, the backend had everything it needed to issue a policy — except proof of payment.</p><p>That’s where the real risk appeared.</p><blockquote><strong>Intercepting the final step</strong></blockquote><p>Even after a failed transaction, the application still exposed the same finalization endpoint.</p><p>I intercepted the request responsible for marking payment status and issuing the policy.<br>The backend appeared to accept status indicators from the request itself — without independently verifying whether the gateway had actually confirmed success.</p><p>This request contained everything needed to move the business state forward:</p><ul><li>Payment identifiers</li><li>Quote or policy numbers</li><li>Flags indicating payment success</li></ul><p>In effect, this single request decided whether a policy would be issued.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HaohtV6zsLunwYD4rsCpKA.png" /><figcaption>Intercepted the Processed Failed Transaction Request</figcaption></figure><p>Crucially, the backend appeared to <strong>trust these incoming values without independent verification</strong>.</p><blockquote><strong>Where trust turned into a vulnerability</strong></blockquote><p>By replaying and slightly modifying this request, a clear pattern emerged:</p><ul><li>The application did not verify payment status server-to-server</li><li>It did not confirm that funds were actually received</li><li>It relied on client-side or redirect-based indicators to mark payment as complete</li></ul><p>Once that trust boundary was identified, the outcome was predictable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SnKvnKdkDyB-U41yQOsW6g.png" /><figcaption>Altered the Parameters of the Failed Request and Forwarded it to the Application</figcaption></figure><p>At this point, I replayed the finalization request, modifying only the payment status indicator — even though the gateway had originally returned a failed transaction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bvpU22Q1WytRzXBE8d0-iA.png" /><figcaption>Observed the Secondary Failed Transaction Request in Queue</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tfSChDQeiwAbzYxMl2MB0Q.png" /><figcaption>Altered the Parameters of the Queued Failed Request and Forwarded it to the Application</figcaption></figure><p>Unlike the earlier IDOR-based case, no identifiers were manipulated.<br>No cross-user access was required.</p><p>The issue existed because the backend trusted externally supplied payment state instead of independently verifying the transaction outcome.</p><blockquote><strong>Policy issued without payment</strong></blockquote><p>After replaying the request with adjusted values, the system behaved exactly as if a real payment had occurred.</p><p>A policy was issued.<br>A confirmation page was shown.<br>Download options became available.</p><p>No payment was ever made.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fH8mFJAC7s5HfekJGnf3CA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FF9pJtvDM6OUfr4QjcG18w.png" /></figure><p>This was not a visual bug.<br>This was a <strong>payment bypass</strong>.</p><blockquote><strong>Why this happened</strong></blockquote><p>This issue was not caused by:</p><ul><li>Weak encryption</li><li>Broken cryptography</li><li>A failure in the payment gateway</li></ul><p>The failure was architectural.</p><p>The backend:</p><ul><li>Trusted redirect parameters and client-controlled values</li><li>Did not verify payment outcomes with the gateway</li><li>Allowed critical state changes based on external input</li></ul><p>In short, <strong>payment success was assumed, not proven</strong>.</p><blockquote><strong>Why this matters</strong></blockquote><p>Payment bypass vulnerabilities have immediate real-world impact:</p><ul><li>Policies issued without payment</li><li>Direct financial loss</li><li>Fraud potential at scale</li><li>Reconciliation and audit failures</li><li>Regulatory exposure in financial systems</li></ul><p>Any attacker who understands the flow could repeat this without attacking the gateway itself.</p><blockquote><strong>What a secure flow requires</strong></blockquote><p>A secure payment design ensures that:</p><ul><li>Payment status is verified server-to-server</li><li>Redirects are treated as informational, not authoritative</li><li>Policy issuance is tied to internal transaction records</li><li>Business state changes occur only after backend validation</li></ul><p>A success page should reflect reality — not create it.</p><blockquote><strong>Final takeaway</strong></blockquote><p>This vulnerability didn’t require breaking encryption.<br>It didn’t require bypassing authentication.<br>It didn’t require exploiting complex logic.</p><p>It succeeded because payment success was assumed — not verified.</p><p><strong>A success page should reflect reality — not create it.</strong></p><blockquote>When critical business decisions rely on unverified external signals, security stops being about attackers and starts being about architecture.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=262e3c52f470" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[IDOR to Payment Bypass: How a Trusted Payment Callback Issued a Policy Without Paying]]></title>
            <link>https://medium.com/@Xp10it/idor-to-payment-bypass-how-a-trusted-payment-callback-issued-a-policy-without-paying-86a2fef0048b?source=rss-c651876a708b------2</link>
            <guid isPermaLink="false">https://medium.com/p/86a2fef0048b</guid>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[payments]]></category>
            <category><![CDATA[payment-gateway]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Xp10it]]></dc:creator>
            <pubDate>Fri, 06 Feb 2026 03:46:00 GMT</pubDate>
            <atom:updated>2026-02-06T03:46:00.848Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_2ETu16sOYnPmOYCOl_zMg.png" /></figure><p><strong>Insecure Direct Object References (IDOR)</strong> are often dismissed as “basic” vulnerabilities.<br>But when an IDOR intersects with <strong>payment workflows and business logic</strong>, the impact can escalate far beyond data exposure.</p><p>In this case, a single object reference change was enough to <strong>bypass payment entirely and issue an insurance policy without any transaction</strong>.</p><p>This wasn’t theoretical.<br>It was a real client engagement.</p><blockquote><strong>From IDOR to Business Logic Abuse</strong></blockquote><p>During a routine security assessment, I was reviewing a <strong>quotation-to-policy flow</strong> in an insurance portal. The application followed a standard pattern:</p><ul><li>A quotation is generated</li><li>The user proceeds to payment</li><li>A third-party payment gateway processes the transaction</li><li>A callback updates the quotation status</li></ul><p>On the surface, everything looked correct.</p><p>But payment flows are <strong>trust boundaries</strong>.<br>And trust boundaries deserve scrutiny.</p><blockquote><strong>A Legitimate Payment Flow (At First)</strong></blockquote><p>I initiated a payment for a valid quotation — <strong>Quote A</strong>.</p><p>The steps were straightforward:</p><ul><li>Selected the quotation</li><li>Chose the configured payment gateway</li><li>Completed the transaction using the gateway’s simulator</li></ul><p>From the UI perspective, this was a normal user journey.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eitJ7vooyLc7p89R3TD0aw.png" /><figcaption>Initiated Payment of 4347 Quotation</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-8ioOHXjWT4WTviRc-QhMA.png" /><figcaption>Selected the Payment Gateway</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Mbc-h9p0i3PbhOcu0I63xA.png" /><figcaption>Initiated the Payment Process</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sCUBYxJVJYit_rF3Bu5kfg.png" /><figcaption>Configured the Payment Status</figcaption></figure><p>Nothing here indicated a vulnerability.</p><p>The real logic lived elsewhere.</p><blockquote><strong>Why Payment Callbacks Matter More Than UI</strong></blockquote><p>Once a payment is completed, the frontend no longer matters.<br>What truly decides the outcome is <strong>how the backend processes the payment callback</strong>.</p><p>So instead of focusing on the UI, I intercepted the request sent by the payment gateway after the simulator reported a successful transaction.</p><p>That request was treated as authoritative.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*js2hrDc7P13kLnsko90dFQ.png" /><figcaption>Intercepted the Payment Gateway Request</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WggSydW7XmY6yRuZR0SPgg.png" /><figcaption>Observed the Payment Success Request for 4347 Quotation</figcaption></figure><p>And that’s where the real issue surfaced.</p><blockquote><strong>Inspecting the “Trusted” Token</strong></blockquote><p>The payment success callback contained a <strong>structured token</strong> carrying transaction context.</p><p>When decoded, it revealed:</p><ul><li>Quotation identifiers</li><li>Order references</li><li>Business-critical attributes used to update payment status</li></ul><p>This immediately raised a red flag.</p><p>The backend was relying on <strong>identifiers inside the callback payload</strong> to decide which quotation had been paid.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XJ1MHC_AqLW-Lp26nPmpgQ.png" /></figure><p>At this point, the question became unavoidable:</p><p>What happens if those identifiers are changed?</p><blockquote><strong>The IDOR That Bypassed Payment</strong></blockquote><p>To answer that, I made a single, controlled modification.</p><p>Inside the token:</p><ul><li>References to <strong>Quote A</strong> were replaced with <strong>Quote B</strong></li></ul><p>No payment amount was changed.<br>No gateway logic was bypassed.<br>Only the <strong>object reference</strong> was altered.</p><p>The modified callback was then replayed to the backend.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BbMoNT2bfX_DnrPyFYEH2g.png" /><figcaption>Replaced the Parameters in the Token from 4347 to 4348 Quote</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*70trxHPPE2AIVjW6_9d3-Q.png" /><figcaption>Replaced the Updated Token with 4348 Quotation Identifiers in the Request &amp; Forwarded to the Portal</figcaption></figure><p>The server accepted it without hesitation.</p><blockquote><strong>Policy Issued. Payment Never Made.</strong></blockquote><p>Moments later, the portal reflected the result.</p><p><strong>Quote B was converted into a policy.</strong></p><p>No payment was ever made for it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_3JkQCMYIT-JE3WAhWYHwQ.png" /></figure><p>At this point, the vulnerability had clearly crossed categories.</p><p>This was no longer just an IDOR.</p><p>It was an <strong>IDOR leading to payment bypass and unauthorized policy issuance</strong>.</p><blockquote><strong>Root Cause: Trusting External Identifiers</strong></blockquote><p>This issue was not caused by:</p><ul><li>Weak encryption</li><li>Token signing failures</li><li>The payment gateway itself</li></ul><p>The root cause was architectural.</p><p>The backend:</p><ul><li>Trusted quotation identifiers received from an external callback</li><li>Did not bind the payment to a server-side transaction record</li><li>Did not verify that the payment actually belonged to the quotation being updated</li></ul><p>In short, <strong>authorization and payment validation were delegated to client-controlled or gateway-controlled data</strong>.</p><blockquote><strong>Why This Is High Impact</strong></blockquote><p>This type of vulnerability has serious consequences:</p><ul><li>Policies issued without payment</li><li>Direct financial loss</li><li>Fraud amplification at scale</li><li>Accounting discrepancies</li><li>Regulatory and compliance exposure</li></ul><p>Any attacker with access to one legitimate payment flow could potentially abuse it to activate multiple unpaid policies.</p><blockquote><strong>How This Should Have Been Designed</strong></blockquote><p>A secure payment workflow should ensure that:</p><ul><li>Payment callbacks are mapped to <strong>server-side transaction records</strong></li><li>Quotation IDs are never trusted from callback payloads alone</li><li>The backend verifies:</li><li>Who initiated the payment</li><li>What amount was paid</li><li>Which quotation the payment was created for</li><li>State transitions occur <strong>only when all validations pass</strong></li></ul><p>Tokens should <strong>describe context</strong>, not <strong>grant authority</strong>.</p><blockquote><strong>Final Takeaway</strong></blockquote><p>This vulnerability didn’t rely on breaking cryptography.<br> It didn’t exploit the payment gateway.<br> It didn’t require advanced techniques.</p><p>It succeeded because <strong>object ownership and payment state were not enforced server-side</strong>.</p><p>If there’s one lesson worth remembering:</p><blockquote><strong>When business logic trusts object identifiers from outside its boundary, IDORs don’t just leak data — they create outcomes.</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=86a2fef0048b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When Encryption Replaced Authorization — and the IDOR Didn’t Go Away]]></title>
            <link>https://medium.com/@Xp10it/when-encryption-replaced-authorization-and-the-idor-didnt-go-away-cca52c7c9b79?source=rss-c651876a708b------2</link>
            <guid isPermaLink="false">https://medium.com/p/cca52c7c9b79</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Xp10it]]></dc:creator>
            <pubDate>Wed, 04 Feb 2026 03:46:01 GMT</pubDate>
            <atom:updated>2026-02-04T03:46:01.328Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>When Encryption Replaced Authorization — and the IDOR Didn’t Go Away</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wjwCur8R7T6JKPYukeZN7Q.png" /></figure><p>Revalidation is usually boring.</p><p>You re-run the same test cases, confirm the fix, mark the issue as <em>resolved</em>, and move on. That’s how most stories end. This one didn’t.</p><p>This was a routine engagement. One of many Applications, one of many endpoints. Nothing fancy. Until it was.</p><blockquote><strong>The endpoint that felt <em>too</em> simple</strong></blockquote><p>During the initial assessment, I was reviewing an endpoint responsible for fetching <strong>policy details</strong>. It was a standard authenticated API call. The request body contained a long numeric string representing a policy identifier.</p><p>At first glance, it looked harmless.</p><p>But experience has taught me that when identifiers are:</p><ul><li>Predictable</li><li>Sequential</li><li>And not clearly tied to the authenticated user</li></ul><p>…they deserve attention.</p><p>I changed <strong>just the last few digits</strong> of the identifier and resent the request.</p><p><strong>HTTP 200.</strong></p><p>Different response. Different user.</p><p>That was my first confirmation:<br> this was a classic <strong>Insecure Direct Object Reference (IDOR)</strong>.</p><blockquote><strong>Confirming the impact (carefully)</strong></blockquote><p>To be sure this wasn’t a fluke, I validated it methodically.</p><p>Using a controlled intruder setup, I iterated over a small numeric range in the identifier.</p><p>Initial request manipulation and identifier testing:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7IjGBs1lsFJU0LdxUVOZYQ.png" /></figure><p>Intruder results showing multiple valid responses:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/999/1*HeY4E20sIG0mwYdFFEUPgw.png" /></figure><p>Different user policy data returned:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qiftknhHJaCppRIXC9Kp9g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/916/1*TIrDNqJ3z0xxb-lsEXXAvw.png" /></figure><p>The results were consistent:</p><ul><li>Multiple successful responses</li><li>Varying response sizes</li><li>Each response containing full policy objects</li></ul><p>The data exposed wasn’t trivial:</p><ul><li>Customer names</li><li>Contact details</li><li>Policy metadata</li></ul><p>This wasn’t just an IDOR — it was <strong>high-impact</strong>.</p><p>I documented everything, reported it, and waited for the fix.</p><blockquote><strong>The fix… at least on the surface</strong></blockquote><p>When the application came back for revalidation, the endpoint looked different.</p><p>The numeric identifier was gone.</p><p>Instead, the request body now contained something like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pr59uocitTYIC2GhcRYsFg.png" /></figure><p>At first glance, this looked promising.<br>The identifier was no longer readable.<br>Brute forcing was no longer trivial.</p><p>Many vulnerabilities die at this stage.</p><p>But one thought kept coming back:</p><p><em>Why is this encryption happening in client-side JavaScript?</em></p><blockquote><strong>Encryption on the client is a trail, not a wall</strong></blockquote><p>Any time encryption is performed in the browser, the logic <strong>must exist somewhere client-side</strong>.</p><p>So instead of attacking the endpoint again, I shifted focus:</p><ul><li>Opened the application’s JavaScript files</li><li>Looked for request preparation logic</li><li>Followed how the encrypted text was generated</li></ul><p>I wasn’t hunting for secrets.<br>I was looking for <strong>patterns</strong>.</p><p>It didn’t take long to confirm that the application was using a <strong>CBC-mode cipher</strong> to transform the policy identifier before sending it to the backend.</p><p>Once you understand <em>how</em> something is encrypted, the encryption itself stops being a barrier.</p><blockquote><strong>Reconstructing the logic</strong></blockquote><p>I didn’t need to reverse the entire application. I only needed to answer one question:</p><p><em>Can I generate a valid ciphertext for a policy that isn’t mine?</em></p><p>Using the observed client-side behaviour and some controlled experimentation, I recreated the transformation logic externally.</p><p>To speed things up, I leaned on modern tooling — including AI-assisted scripting — to build a small helper script that:</p><ul><li>Took a policy identifier as input</li><li>Applied the same CBC-based transformation as the client</li><li>Produced ciphertext the server accepted as legitimate</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*43406PJGgVQNtgglXyj0bg.png" /><figcaption>Encrypting the Plaintext Payload</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TQwbjUlwv3Dcgk7lMS5bSw.png" /><figcaption>Received Encrypted Response</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*Ylo6bT-cxZGR_SFn5wJJMQ.png" /><figcaption>Decrypted Response Body</figcaption></figure><p>No brute force.<br>No guessing.<br>Just replaying what the frontend already knew.</p><blockquote><strong>The moment of truth</strong></blockquote><p>I replaced the encrypted text in the request with ciphertext generated for a <strong>different policy</strong>.</p><p>Sent the request.</p><p><strong>HTTP 200.</strong></p><p>The response came back with full details — for a policy belonging to another user.</p><p>The IDOR was still there.</p><p>The difference was simple:</p><ul><li>Earlier, it was exposed through predictability</li><li>Now, it was hidden behind encryption</li></ul><p>But hidden is not the same as fixed.</p><blockquote><strong>The real root cause</strong></blockquote><p>This wasn’t a cryptography problem.</p><p>It wasn’t even an obfuscation problem.</p><p>It was an <strong>authorization problem</strong>.</p><p>At no point did the server verify:</p><ul><li>Whether the requested policy actually belonged to the authenticated user</li><li>Whether the decrypted identifier was authorized for that session</li></ul><p>The server trusted the client to send a “valid” ciphertext.</p><p>And that’s where things went wrong.</p><blockquote><strong>What should have been done instead</strong></blockquote><p>Encryption can protect <strong>confidentiality in transit</strong>.<br>It cannot enforce <strong>access control</strong>.</p><p>The correct fix was never about hiding the identifier. It was about answering one question on the server:</p><p><em>Is this user allowed to access this object?</em></p><p>That means:</p><ul><li>Binding object IDs to user identity server-side</li><li>Enforcing authorization <strong>after decryption</strong></li><li>Treating client input — encrypted or not — as untrusted</li></ul><p>Anything short of that is cosmetic.</p><blockquote><strong>Final thoughts</strong></blockquote><p>This vulnerability wasn’t sophisticated.<br>It didn’t rely on zero-days.<br>It didn’t require advanced exploitation.</p><p>It survived because:</p><ul><li>The <em>symptom</em> was fixed</li><li>The <em>cause</em> was not</li></ul><p>IDORs are dangerous precisely because they’re simple — and because it’s easy to mistake encryption for security.</p><p>If there’s one takeaway from this engagement, it’s this:</p><blockquote><strong>If authorization lives on the client, it doesn’t exist.</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cca52c7c9b79" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>