Four Years, 15+ Vulnerabilities: How I Found Systemic Auth Failures in a Legacy PHP SMS Platform
A Quick Intro
So this one started as a weekend curiosity back in 2022 and ended four years later with 15+ vulnerabilities, 1000+ exposed sender IDs, and a vendor who officially recognized the responsible disclosure. It’s not a glamorous memory corruption bug. It’s a legacy PHP monolith suffering from systemic broken access control. But it’s mine, I found it, and the vendor eventually retired the entire platform and moved to Next.js because of it.
The report covers 3 Critical vulnerabilities, including unauthenticated password resets and mass financial fraud, alongside an ecosystem-wide issue where the same broken framework was running on 10+ Sri Lankan SMS applications.
Let me walk you through what the platform did, what I found, and how I confirmed it—without ever crossing an ethical line.
Where to find it: - Full Report: Security Assessment Report — Legacy PHP SMS Platform - Vendor Acknowledgment: Publicly endorsed on LinkedIn by the Operations & Business Administration lead.
Tooling I Used
I want to be upfront about the toolchain because I think it matters for reproducibility.
Burp Suite Community and Browser DevTools did the heavy lifting. Because the application was a classic PHP monolith where every action was a separate .php file, intercepting the traffic was straightforward. I spent most of my time mapping the /dist/*.php directory and manipulating parameters.
Python (requests + aiohttp + BeautifulSoup4) was used for respectful, batched endpoint enumeration. Since the IDs were sequential and predictable, I needed a way to safely automate the mapping of the exposed surface without causing a denial of service.
The tools together gave me the full picture: DevTools to see how the JS built the requests, and Burp to manipulate the auth string and IDs that the frontend never expected me to touch.
First, What Is the Legacy PHP SMS Platform?
If you've never touched SMS gateways, here's the short version. This was an OEM SMS management platform (specifically the Ozone Desk Manager) used by resellers and sub-accounts to manage bulk SMS sending, sender IDs, and balance top-ups.
It sat on a /dist/*.php architecture, meaning the application was essentially a collection of standalone scripts. There was no centralized authentication middleware wrapping the routes.
What it actually does:
- Sub-account management: Resellers could create sub-accounts and view their balances.
- Financial top-ups: Allowing resellers to add SMS credits to their downline.
- Sender ID control: Creating, modifying, and toggling the active state of alphanumeric sender IDs (e.g.,
BANK,VOTE,OTP). - SMS sending: Dispatching messages directly to user mobile numbers via the telco networks.
In other words, it's the glue between a business and their customers' phones. That's also why I care about this bug. Every endpoint here was accessible without authentication. It wasn't just one bad page; it was the entire management interface. And because the same framework was deployed across 10+ subdomains serving Sri Lankan apps, the install base wasn't small.
Peeking Inside
The platform sat on top of a very predictable MVC-less structure. If you loaded the dashboard, the Network tab exposed the entire backend.
When I looked at the core endpoints, I found that authorization was completely handled on the client side. The server assumed that if you were calling the endpoint, you must have already logged in to the dashboard.
Here is the object layout for the vulnerable endpoints:
| Endpoint | Function | Auth Required |
|---|---|---|
/dist/pw_update.php | Password Reset | ❌ None |
/dist/sub_account_view.php | View Account Data | ❌ None |
/dist/sub_acc_topup.php | Balance Top-Up | ❌ None |
You can probably guess where this is going.
The Bug
I was looking at pw_update.php in Burp Repeater, and this is what the request looked like:
```http POST /dist/pw_update.php HTTP/1.1 Host:
pw=NewPassword123&userID=100001 ```
There it is. The endpoint accepted userID and pw without any authentication, current-password verification, or reset token. The server just blindly executed the update. An attacker who knows a user ID could reset any user's password and gain full account control.
Same pattern repeats across the other endpoints. The sub_account_view.php endpoint iterated sequential numeric IDs, returning JSON containing emails, phone numbers, API keys, and current balances for every registered sub-account. The top-up endpoint accepted hiddenId and topup_balance and just handed out free SMS credits.
Why the XSS Pivot Matters
Here's the detail I think is most interesting about this platform.
While the unauthenticated API bugs were critical on their own, they only exposed the sub-account level. To get the admin dashboard, I needed a pivot. I found a stored XSS in the sender ID creation endpoint (/dist/sender_add.php).
The sender_id parameter was submitted and reflected back raw on the admin sender list page.
```html POST /dist/sender_add.php HTTP/1.1 Content-Type: application/x-www-form-urlencoded
hidden_cid=100264&sender_id=
When the admin opened the sender management modal, the script fired in their origin.
Why was this so dangerous? Because the session cookies were not HttpOnly, there was no CSP header, and the admin panel was on the same origin. A malicious payload could have silently exfiltrated the admin's session token and handed over full platform control. (I stopped at the alert() and never weaponized it).
Proving It
I wrote a small Python PoC that iterated the sequential IDs to demonstrate the exposure. I stopped at a controlled limit to avoid mass exfiltration, but the impact was clear:
| Endpoint | Payload | Result |
|---|---|---|
| sub_account_view.php | ?id=100264 | 200 OK (Leaked API Keys) |
| sub_acc_topup.php | hiddenId=100264&topup_balance=5000 | 200 OK (Financial Fraud) |
| send_individual_submit.php | clientID=-1&senderId=BANK... | 200 OK (SMS Spoofing) |
The full sweep transcript, including the exact HTTP requests and redacted JSON responses, is in the public Gist.
What I'm Claiming and What I'm Not
I want to be really careful here because I've seen too many reports overstate their findings. Here's where I stand:
Confirmed: - Systemic broken access control. Every core function — password reset, account viewing, balance top-up, SMS sending, sender ID management — was accessible without authentication. - Mass data exposure. Over 1000+ sender IDs and Sri Lankan entity names were exposed across the vulnerable search endpoints. - Ecosystem vulnerability. The exact same framework (identical /dist/*.php paths) was deployed on 10+ separate subdomains serving Sri Lankan apps.
Not established: - I did not exfiltrate real customer data, nor did I commit fraudulent top-ups. - I did not steal a real admin's cookie. I confirmed the exploitability by inspecting my own session cookie flags in the DevTools. - I did not test the 10+ other deployments. They were identified through passive fingerprinting only (identical error pages and paths).
One thing worth mentioning: Early in 2025/26, I noticed automated ID sweeps hitting the same endpoints from unknown IPs. That’s when the report stopped being an academic exercise. Real attackers were already trying to exploit the exact gaps I had documented.
I'd rather be accurate about a systemic flaw than exaggerate a big one.
Fixing It
If you're building on top of a legacy monolith like this, here's the interim mitigation:
Centralize your authentication. Stop relying on the UI to hide endpoints. Every single route must have a middleware check.
For the vendor, the real fix was a complete architectural rewrite:
```php // Before $user = User::find($_GET['id']);
// After $user = User::where('uuid', $_GET['uuid'])->firstOrFail(); if ($current_user->id !== $user->id && !$current_user->is_admin) { http_response_code(403); exit; } ```
And they needed tokenized password resets, schema validation on every input, and strict output encoding to kill the XSS.
To their credit, the vendor took the findings seriously, retired the PHP platform, and migrated the entire stack to Next.js. They bound the sender IDs to the accounts and implemented proper middleware.
Timeline
| Date | What Happened |
|---|---|
| 2022 | Found the first IDOR by accident; started mapping endpoints |
| 2024 - 2025 | Confirmed the XSS pivot and the full unauthenticated attack chain |
| Early 2025 / 2026 | Noticed script kiddies probing the same endpoints; initiated vendor contact |
| Mid 2026 | Vendor acknowledged the report, sent a formal LinkedIn recommendation |
| Late 2026 | PHP platform retired; Next.js migration complete |
References
| Source | Link |
|---|---|
| Full Security Report | GitHub Gist |
| OWASP Top 10 | OWASP |
| CWE | CWE-284 |
| Burp Suite | PortSwigger |
Wrapping Up
This is a systemic access control failure. I know that. It's not going to get me on the news and it's not going to earn a massive bounty. But I found it, I confirmed it safely, I documented it properly, and I disclosed it responsibly after observing active exploitation attempts in the wild.
What I think makes it worth writing about is the shape of the bugs. One unchecked endpoint is a mistake. Three unchecked endpoints chained together into an admin dashboard is an architectural failure. Static scanners will flag the IDOR, but they won't tell you that clientID=-1 lets you spoof the national bank.
And honestly? Over 1000+ sender IDs across 10+ local apps were exposed. It's a massive ecosystem issue. The vendor retired the whole platform, so the advisory, the report, and the vendor's acknowledgment are the deliverable.
If you're building a legacy app: bound your permissions before you pass them in. If you're migrating: don't just port the bugs to Next.js.
Read the full report: Security Assessment Report — Legacy PHP SMS Platform