November 6, 2026
How Four Lines of Code Could Delete Any Facebook Photo Album
Real one again, and this time it’s about as clean a textbook IDOR as you’ll ever find written up, which is exactly why it’s worth actually…

By L4ZZ3RJ0D
5 min read
Real one again, and this time it's about as clean a textbook IDOR as you'll ever find written up, which is exactly why it's worth actually sitting with rather than skipping past as "old news." Laxman Muthiyah found this on Facebook back in 2015, got paid $12,500 for it, and Facebook patched it within two hours of his report landing, which tells you something on its own about how serious they treated it despite how simple the actual bug turned out to be. His original writeup is still up, here it is directly: How I Hacked Your Facebook Photos. Worth reading in his own words, what follows is a walk through the reasoning, not a substitute for it.
Facebook's Graph API is the standard way any app, official or third-party, reads and writes data on the platform, photos, posts, pages, all of it. Muthiyah's starting point wasn't a scanner or a tool, it was a question anyone poking at an API with delete-capable endpoints should eventually ask themselves: what actually happens if I try to delete something that isn't mine. Facebook's own documentation was explicit that the Graph API didn't support deleting photo albums at all, officially, through any standard access token.
He tested that claim directly anyway rather than just taking the documentation at face value, firing a DELETE request at his own album's ID using a normal Graph Explorer access token. It failed, exactly as documented. But the part worth lingering on is what he did with that failure, because this is the actual skill underneath the whole bug: he read the wording of the error message closely rather than just logging "confirmed, blocked" and moving on, and the phrasing implied the restriction was tied to which app was asking, not a hard rule the server enforced for every possible caller. Some application, somewhere, had to be allowed to do this, because the Facebook mobile app itself visibly has a "delete album" button sitting right there in its own UI. If the feature exists in an official client, the permission exists somewhere in the API too, the only open question is which token actually carries it.
That's a genuinely reusable instinct worth internalizing on its own, independent of this specific bug. An API returning "not permitted" tells you about the token you tried, not necessarily about the endpoint itself. If a feature visibly exists in any client application, official or not, there's a token type somewhere that unlocks it, and finding which one is often more productive than continuing to poke at the same access level that already failed.
So he went and got a Facebook-for-Android access token instead of the generic Graph Explorer one, the kind issued to Facebook's own official mobile app, and sent the exact same request, down to the same four lines:
DELETE /518171421550249 HTTP/1.1
Host: graph.facebook.com
Content-Length: 245
access_token=<Facebook_for_Android_Access_Token>
Response: trueDELETE /518171421550249 HTTP/1.1
Host: graph.facebook.com
Content-Length: 245
access_token=<Facebook_for_Android_Access_Token>
Response: trueIt worked, against his own album. Confirmation that the mobile token carried a broader delete permission the standard one didn't, exactly as the earlier error message had hinted. On its own, that's already a real finding, a permission boundary that shouldn't exist between officially sanctioned clients and the standard API surface. But it's also, on its own, not actually a vulnerability yet, just an app having elevated access to its own data is expected behavior, Facebook's own mobile client is supposed to be able to manage a user's own albums.
The actual escalation, the moment this stopped being "my app can manage my own stuff" and became a real vulnerability, was the next test, and it's the single most important move in the whole writeup. He took a different album's ID entirely, one belonging to someone else, found simply by looking at the numeric ID sitting in that album's own URL, and sent the identical request again, same Android token, only the ID in the path swapped out. Nothing else about the request changed at all.
DELETE /<victim_album_id> HTTP/1.1
Host: graph.facebook.com
Content-Length: 245
access_token=<Facebook_for_Android_Access_Token>
Response: trueDELETE /<victim_album_id> HTTP/1.1
Host: graph.facebook.com
Content-Length: 245
access_token=<Facebook_for_Android_Access_Token>
Response: trueDeleted. An album with zero connection to his own account, gone, using a token that was only ever supposed to manage his own.
That's the entire root cause laid bare, and it's worth stating plainly because this exact shape shows up constantly across completely unrelated applications: the server correctly verified that the access token belonged to a real, authenticated user who held delete permission on albums in general, but never took the second, equally necessary step of checking whether the specific album ID in that request actually belonged to that token's owner. Authentication was working fine. Authorization, checking not just who you are but whether you're allowed to touch this particular object, was the piece that was missing entirely. That gap between "is this a valid request from a real user" and "does this real user actually own the specific thing they're asking to modify" is the entire definition of an IDOR, and this report is about as pure an example of it as exists in bug bounty history.
Worth being precise about the actual limits here too, because the real impact was serious but not unlimited the way some of the breathless headlines about it implied afterward. Deleting a specific album still required knowing its numeric ID, and critically, still required that Muthiyah himself had permission to view that album based on its own privacy settings, public albums, or ones shared with him specifically. He couldn't delete a stranger's fully private album he'd never been granted view access to, the bug skipped the delete-ownership check but didn't touch the separate, still-functioning view-permission check underneath it. That distinction matters for how you'd actually report and scope severity on a bug like this, the blast radius is everything an attacker can already see, not literally everything that exists on the platform, and getting that boundary right in your own report is exactly the kind of precision that makes a finding credible instead of overstated.
The generalizable lesson sits in exactly that gap, and it's worth carrying into every single object-based endpoint you test from here forward, not just delete actions. Any time an API lets you act on something by ID, delete it, edit it, view it, transfer it, the one test that actually matters is swapping that ID for an object you don't own while keeping your own valid token attached to the request, and watching whether the server stops you or just quietly complies. Muthiyah didn't need a scanner, a chained exploit, or any obscure technique to find this, he needed to actually ask the one question most people stop short of once their own version of the request already works: does this check who I am, or does it check what I'm touching? Here, it only ever checked the first one.
Happy hunting, see you in the next scope :)