November 13, 2026
Eight Flaws, One Chain: My Review of the CWL Web RTA
My take on CyberWarfare Labs’ Web-RTA: how a chain of small flaws across two apps turns into a full account takeover, and what the exam…

By f4nt0n1
6 min read
My take on CyberWarfare Labs' Web-RTA: how a chain of small flaws across two apps turns into a full account takeover, and what the exam taught me.
What the exam is
Web-RTA is CyberWarfare Labs' web application security certification. The final challenge is a practical, hands-on test: two linked web applications that together make up a fictional uptime and outage-alerting platform. The whole point is chaining, and I had to connect eight distinct vulnerabilities, starting from an authentication bypass with no credentials and ending at the exfiltration of another user's sensitive data.
That is the mindset the exam wants to build. No flaw on its own gets you to the goal. Each one hands you the input the next one needs, a credential, an endpoint, a privilege level. It is a systemic break of trust between components, and seeing that chain form is the real lesson.
The two apps are not independent. The first one is where you break in and find the thread that leads to the second. If you treat them as separate targets, you miss the bridge that connects them.
Recon
I started with directory enumeration and HTTP fingerprinting. The stack came back as a Python/Flask application, which matters because it tells you what kind of flaws and what kind of libraries you are likely dealing with later.
bash
# directory enumeration to map the attack surface
gobuster dir -u http://<target>/ -w <wordlist>
# fingerprint the server and framework from the response headers
curl -sI http://<target>/# directory enumeration to map the attack surface
gobuster dir -u http://<target>/ -w <wordlist>
# fingerprint the server and framework from the response headers
curl -sI http://<target>/The key observation came from the session cookie. Capturing a request to the login page, I found two tokens: a JWT and the usual Flask session cookie. I decoded the JWT and that is where the first flaw showed up.
The habit that pays off here is the same one that pays off in any exam like this: look closely at what the application hands you before you start throwing payloads at it.
The first door: a JWT with no signature
The JWT used the alg: none algorithm. If you have not seen this before, it means the token carries no cryptographic signature at all. The server was accepting a token that nobody actually signed, which means I could rewrite the payload freely and it would still be trusted.
bash
# decode the token to read its header and payload
echo '<jwt>' | cut -d. -f1,2 | base64 -d 2>/dev/null# decode the token to read its header and payload
echo '<jwt>' | cut -d. -f1,2 | base64 -d 2>/dev/nullI forged a few variations, changing the sub and role fields, to test for privilege escalation. The interesting twist was that forcing role: admin did not work. The application's logic expected the role user, and that was the one that unlocked the dashboard. A good reminder that escalation is not always "set yourself to admin", sometimes it is about matching the value the application actually expects.
From the dashboard I pulled two things I would need later: an event name and the username of the administrative account. In classification terms, this is a broken authentication issue. The fix is to reject alg: none outright and only allow a proper signing algorithm.
SQL Injection to bypass the login
With the admin username in hand, I turned to the login form, and it concatenated user input straight into the SQL query with no parameterization. Classic error-based SQL injection.
Because I already knew the admin username, I did not even need to extract anything. I just commented out the rest of the query so the password check was never evaluated:
text
username: <admin-username>'--
password: anythingusername: <admin-username>'--
password: anythingThe single quote closes the string, and the -- turns the password comparison into a comment. The server authenticated me on the username alone. This is OWASP A03 Injection (CWE-89), and the fix is the one everyone knows and too many skip: parameterized queries, never string concatenation.
SSRF, and bypassing a filter
Inside the app there was a "fetch status" feature where the server makes an HTTP request to a URL you provide and returns the content. That is Server-Side Request Forgery, and it let me reach internal services that are not exposed to the outside world.
There was a filter trying to block requests to localhost, and a direct request to the loopback address came back rejected. But the filter was doing a string comparison on the host, so I bypassed it by URL-encoding the dots in the IP address:
text
http://127%2E0%2E0%2E1:8000/http://127%2E0%2E0%2E1:8000/To the filter, that string did not look like localhost. To the server resolving it, it was exactly localhost. With the bypass, I reached an internal endpoint and pulled out a hidden value. This is OWASP A10 SSRF (CWE-918). The real lesson is that blocklists built on string matching almost always lose to encoding tricks. The right defense is an allowlist, plus validating the IP after it is normalized.
Sensitive data that was only encoded, not encrypted
The internal value I pulled from the SSRF looked scrambled, but it was not encrypted, it was merely encoded, in a few stacked layers (hex, then ASCII, then base64). Encoding is reversible by design, so anyone who gets the value can trivially turn it back into plaintext.
bash
echo '<encoded-blob>' | tr -d ' ' | xxd -r -p | base64 -decho '<encoded-blob>' | tr -d ' ' | xxd -r -p | base64 -dOut came a credential pair, a client ID and a secret, and that was precisely the input I needed to log into the second application. This is a cryptographic failure / sensitive data exposure (CWE-312). The takeaway worth internalizing early: base64 and hex are not security. If a secret can be reversed with a one-line command, it is not protected.
XXE, and a hint hidden in plain sight
One feature accepted XML input and parsed it with external entities enabled. That is XML External Entity injection, and it let me read local files from the server using the file:// scheme.
The idea is simple. In the document type definition of the XML, you declare an external entity that points to a local file path through the file:// scheme. Then you reference that entity inside a field the application echoes back, such as the event title. When the parser expands the entity, the content of the file comes back to you in the response. In the exam, pointing it at a world-readable system file is what returned the data.
A limitation I hit, and one worth knowing: in-band XXE like this only reads clean text files. Files with XML-special characters or null bytes break the parser, so source files and process environment files did not come through, but world-readable system files did.
The trick the exam pulled here was that reading the password file revealed a hint planted in a user's description field, pointing me toward the login flow of the second application. It was a reminder that even a boring system file can carry the next step.
Crossing over: OAuth scope elevation
The second application exposes an OAuth login. Using the credential pair I exfiltrated earlier, I logged in and received two tokens. I tried tampering with them directly in the URL, and it did not work, because the resource server validated the signature and the scope granted at issue time. That told me something useful: the weak point was not in consuming the token, it was in the authorization flow that issues it.
So I re-ran the login and intercepted the authorization request in Burp, then changed the requested scope from read to admin. The server accepted the higher scope without checking whether that client was actually allowed to have it.
The token itself can be perfectly signed and still be wrong, if the server handed out a privilege it never should have granted. Accepting the elevated scope did not finish the job on its own, it pushed me into a one-time-password step.
A 3-digit OTP with no rate limiting
The OTP gate used a code of only three digits. That is a space of exactly one thousand possibilities, from 000 to 999, and the server put no rate limiting or lockout in front of it. A thousand tries is nothing for an automated tool.
bash
# a thousand-line wordlist is all the brute force needs
seq -w 000 999 > otp.txt# a thousand-line wordlist is all the brute force needs
seq -w 000 999 > otp.txtI fed that list into Burp Intruder and the correct code fell out quickly, completing the elevation to admin. This is an identification and authentication failure (CWE-307, improper restriction of excessive authentication attempts). Two things were broken at once here: the code was far too short, and nothing stopped me from trying every value. A real OTP needs more digits, a short expiry, and rate limiting with a lockout.
The final step: IDOR on the admin resource
With admin privilege, a protected resource exposed the sensitive data of other users. The object was referenced by a predictable identifier, and nothing checked whether that object actually belonged to me, which is an IDOR flaw.
Sensitive data belonging to another user was sitting behind an identifier I could simply change.