November 13, 2026
From $1,000 to $10,000: How I Turned a "Limited" XXE Into a Critical Redis Session Store Exposure
الحمد لله، له الشكر والثناء كله. 🤲

By ALR
5 min read
لم يكن أي من هذا ممكناً لولا توفيق الله ونعمه؛ فالحمد لله.
Introduction
I'm grateful to share this journey, where a seemingly limited XXE vulnerability turned into a much more impactful security finding, ultimately increasing the bounty from $1,000 to $10,000.
Discovery
While mapping the target's attack surface, I came across several DLL and EXE files. I usually decompile these binaries and look for anything the application might reveal, such as hardcoded endpoints or internal implementation details. This time, I handed the files over to my AI-powered hackbot for the first pass.
About an hour later, it surfaced an interesting endpoint that accepted XML. The code it analyzed contained a client-side implementation of XML-RPC and revealed several methods the client could call on the server.
The individual methods could have been worth reviewing for issues like SQL injection or information disclosure, but what caught my attention was the endpoint itself. Since it accepted XML, I wanted to see how the server's parser handled external entities. I added the endpoint to my notes and made XML External Entity injection (XXE) my first test.
Initial Impact
My first test was a simple control. I wanted to see whether the XML-RPC parser would process a DTD and expand an internal entity. I defined tiny as ALR-CONTROL and referenced it in the <methodName> field.
<?xml version="1.0"?>
<!DOCTYPE methodCall [
<!ENTITY tiny "ALR-CONTROL">
]>
<methodCall>
<methodName>&tiny;</methodName>
<params></params>
</methodCall><?xml version="1.0"?>
<!DOCTYPE methodCall [
<!ENTITY tiny "ALR-CONTROL">
]>
<methodCall>
<methodName>&tiny;</methodName>
<params></params>
</methodCall>The server returned an XML-RPC fault containing the expanded value.
<member>
<name>faultString</name>
<value>
<string>No such method `ALR-CONTROL'</string>
</value>
</member><member>
<name>faultString</name>
<value>
<string>No such method `ALR-CONTROL'</string>
</value>
</member>The error showed that the server tried to look up ALR-CONTROLas a method name. That confirmed the parser processed the DTD and expanded the internal entity before method lookup. The next question was whether the parser would resolve external entities as well.
With internal entity expansion confirmed, I moved on to test whether the parser would resolve an external entity. I used /etc/passwd as a recognizable local file and looked for its contents in the XML-RPC fault response. If the response contained those contents, it would confirm that the parser could read a local file and expose it to the caller.
After confirming that the XML-RPC endpoint disclosed the contents of /etc/passwd, I submitted the report. I suspected the issue might expose other files readable by the application. At that point, /etc/passwd was the only file I had verified.
The team assessed the impact as more limited than I had expected. They pointed out that the vulnerability could not read /proc/self/environ and awarded me $1,000 for the impact I had demonstrated. Their response prompted me to take a closer look at what else the vulnerability could expose.
After submitting the initial report, I got curious about what else the XML-RPC server could reach. Could the same XXE issue make server-side requests to services on the internal network? If so, it could expose resources that were inaccessible from the internet, including AWS metadata services, depending on how the environment was configured.
I started with the server's loopback address. The response contained the contents of its robots.txt file, confirming that the request originated from the server and reached a local web service. I explained to the team that this behavior could potentially be used to probe internal IP addresses and check which ports were reachable from the server.
I also reached an AWS container metadata endpoint on a link-local address and received a metadata response. That was as far as I could verify at this stage. I sent the team an update with both results. The original report had demonstrated a local file read. The new evidence showed that the same vulnerability could also reach internal services and return their responses.
The team told me they hadn't realized the vulnerability could reach internal services. They still considered the impact limited. In their assessment, the server could only make GET requests, and the only metadata path I had shown to be accessible was /v2/metadata. Even so, they raised the bounty from $1,000 to $2,000.
I read their response as an opening. If I could demonstrate a greater impact, they might reassess the bounty again. That's when things got interesting.
Escalating the Impact
After inventorying the internal IP addresses, I reviewed /proc/net/tcp to identify the endpoints, ports, and socket states. One entry stood out. It showed a connection to port 6379, the default Redis port, with a socket state of 01.
Socket stateMeaning01 (ESTABLISHED)The TCP connection was active when the table was captured.
Redis uses its own protocol over TCP, so an HTTP external entity was unsuitable for testing whether the service accepted Redis commands. The entity handler needed to communicate with Redis directly over TCP.
I kept the first Gopher test deliberately simple. It timed out, and that timeout turned out to be a clue. LWP's Gopher handler reads until it reaches end-of-file (EOF), while Redis kept the TCP connection open after responding. The XML-RPC request was still waiting for the socket to close.
In the follow-up test, the connection closed cleanly. LWP reached EOF, and the XML-RPC faultString returned the Redis replies:
+PONG
+OK+PONG
+OK
That response changed the direction of the investigation. The XML-RPC server could reach the internal Redis instance, and Redis processed the test commands without requiring AUTH.
After reaching the Redis instance and confirming that it accepted the tested commands without authentication, I used the payload shown below to retrieve server information, including its operating mode, port, and uptime. This provided concrete evidence of access for the security team.
<!ENTITY xxe SYSsTEM "gopher://172.31.56.127:6379/0INFO%20server%0d%0aQUIT%0d%0a"><!ENTITY xxe SYSsTEM "gopher://172.31.56.127:6379/0INFO%20server%0d%0aQUIT%0d%0a">The server returned the Redis information shown in the following screenshot.
At this point, I believed I had demonstrated the impact by interacting directly with Redis without authentication. I also sent the team additional evidence showing that I could retrieve session data and determine the number of keys stored in Redis using the following payloads.
<?xml version="1.0"?>
<!DOCTYPE methodCall [
<!ENTITY XXE SYSsTEM "gopher://172.31.56.127:6379/0SCAN%200%20COUNT%2020%0d%0aQUIT%0d%0a">
]>
<methodCall><methodName>&xxe;</methodName><params></params></methodCall>
<!ENTITY xxe SYSsTEM "gopher://172.31.56.127:6379/0INFO%20keyspace%0d%0aQUIT%0d%0a"><?xml version="1.0"?>
<!DOCTYPE methodCall [
<!ENTITY XXE SYSsTEM "gopher://172.31.56.127:6379/0SCAN%200%20COUNT%2020%0d%0aQUIT%0d%0a">
]>
<methodCall><methodName>&xxe;</methodName><params></params></methodCall>
<!ENTITY xxe SYSsTEM "gopher://172.31.56.127:6379/0INFO%20keyspace%0d%0aQUIT%0d%0a">
After I clearly demonstrated the impact to the security team, they increased my bounty to $10,000 — the highest reward I had ever received in my bug bounty journey. In just 10 days, what began as a $1,000 bounty had grown to $10,000.
Thank you to the team for this bounty, their strong commitment to security, and their recognition and appreciation of researchers' work and efforts.
Contact Me
x: https://x.com/00xalr ,
instagram: https://www.instagram.com/0xalr ,