Twitxy Saved

Harley Kimball

Verified account This account is verified. Learn more

@infinitelogins

Researcher Strategy & Live Hacking @ HackerOne | Community Cultivator | Bug Bounty Hunter | Co-Founder of @BugBountyDEFCON | Founder of Disclosed Newsletter.
Portland OR getdisclosed.com Joined November 2019
1.5K Following 8.3K Followers 2.2K Posts

Latest posts 5

Harley Kimball Verified account @infinitelogins
So much gold in this.
devansh ⚡️ Verified account @0xAsm0d3us Nov 7
some alpha drop for doing inexpensive vuln research.

instead of writing an article on the prompts/process behind this bounty (and more), I am dropping some prompts and the thought process I used as part of this research.

ik you might say prompts don't matter much, frontier models' baseline intelligence can rawdog vuln discovery (and it is true to a good extent), but there is a high chance that you either do not have access to cyber models, or even if you do, they are expensive (and with heavy guardrails). The idea is, these prompts work well with open-weight/less expensive models. Not saying these will outperform the raw intelligence and capabilities of frontier models, but open-weight models perform much better with a bounded/goal-specific approach (where the goal is set, and the search space is massive) rather than open-ended exploration (where the goal is vague, and the search space is massive).

anyway, here are some prompts. I don't need to share much, because you can just create variations of these and apply them wherever you wish.

- find places where the app is supposed to enforce something, but doesn't actually enforce it.

- find security rules that are enforced in one part of the app, but just assumed to be true in another.

- find security assumptions the app relies on, but never actually checks or enforces.

- find places where the app depends on undocumented behavior, and what happens if that behavior changes.

- find operations that are secure on their own, but become vulnerable when you combine or chain them together.

- find cases where the same object can be accessed in different ways, but each way ends up having different permissions.

- find objects whose identity can be changed or rebound to another user, without going through the right checks.

- find requests that get rejected or fail, but still end up changing something or triggering a side effect.

- find security checks that only work if certain events happen in a specific order, and what happens if that order changes.

- find operations where the transaction fails or rolls back, but some of the side effects still happen.

- find things you can still do with an object even after it has been deleted, or access to it has been revoked.

- find state changes that can be reversed or undone by someone who shouldn't have permission to do so.

- find objects that can end up in two contradictory states at the same time, and what operations become possible because of that.

I take such prompts, put it in a mutator (which has threat model of the project I am doing sec engagement), the mutator will mutate the prompts based on the threat model, and spawn swarm of agents, with different starting prompt and a bounded goal, the process repeats till all paths are exhauted, or some new signal is generated, which then feeds back to mutator.

Doing this using a cheap model is very effective and sometimes it might yield you something even expensive models miss, we are just trying to maxximise the search space, from as many angles as possible, and once this process generates enough signals, just use a frontier model to confirm/triage issues, or for finding similar variants of such issues, that's basically it. There is v less moat is making a custom harness (unless you are an elite vuln research who can codify their approach in it or a 100x agentic engineer, I am neither).
View quoted post on X
3 replies 1 reposts 50 likes 5.4K views View on X
Harley Kimball Verified account @infinitelogins
I found a critical unauthenticated account takeover that let me log in as any customer on the platform. No password, no account of my own. It earned a $5,000 bounty.

Quick context: the platform runs unattended devices, and those devices sign in with no human present. So instead of a password, each account has an "auto login key." A device presents the key and gets a session. The key is the credential.

That design is fine right up until a key leaks.

The chain came down to 3 things:

- Keys are the credential: by design, holding an account's auto login key gets you a session for that account, no password.
- Wildcard injection: the lookup endpoints ran input through a SQL `LIKE` query, so a single `%` let me pull any account's key out of the database.
- No rate limiting: I could iterate the whole customer table and lift every key.

Here's how I chained them:

1. Leak accounts with a wildcard

The lookup took a `key` and found it in the database with a `LIKE` query. So I sent:

`GET /autologin/lookup?key=%`

Instead of one record, it returned matching accounts: user IDs, tenant IDs, emails. A single `%` dumped account rows.

2. Pull a victim's real key

A second endpoint resolved a key to an account. Same flaw. I sent a wildcard plus an ID I'd just leaked:

`POST /autologin/resolve?key=%`
`{"user_id": {victim-id}, "tenant_id": {tenant-id}}`

It handed back that victim's actual auto login key.

3. Trade the leaked key for a session

The device endpoint does exactly what it's built to do: present a valid auto login key for an account, get a session token for that account. The catch is the key was the victim's, leaked in the steps above, and should never have been in my hands.

`POST /autologin/devices`
`{"user_id": {victim-id}, "key": "{victim-key}", ...}`

It registered my device under the victim's account and returned a fresh session token for them.

4. Full takeover

`GET /me` with that token returned the victim's full profile. PII, billing identifiers, all of it. No authentication, no account of my own, and no notification to the victim that a new device had appeared.

The wildcard enumerated the entire customer table, there was no rate limiting, so this worked against every account on the platform at scale.

#BugBounty tip:

Any endpoint that takes a secret and looks it up is a candidate for wildcard injection. If `%` returns more than it should, it's a `LIKE` query and you can enumerate the table.
7 replies 29 reposts 351 likes 11K views View on X
Harley Kimball Verified account @infinitelogins
If you're doing bug bounty, you should be storing your recon data in an actual database instead of scattered local txt/md files.

Free services like Supabase make this incredibly easy now, especially with their MCP integration.

Get in the habit of constantly storing everything you discover about your targets:

Endpoints
Parameters
Headers
Request/response structures
Related services

Anything that might be useful later.

The real benefit comes when you give your AI agents access to this data through MCP. You can start asking things like:

"Check our endpoint store for related endpoints and build a custom wordlist for fuzzing."

"What other services have we discovered on this target?"

"What other parameters have we seen on this endpoint?"

"What does a valid request to this endpoint look like?"

Having all your recon in a structured, queryable database makes it so much easier to validate findings, discover related attack surfaces, and find ways to escalate vulnerabilities.

The more recon you collect, the more useful this becomes. And instead of manually digging through old files, your agents can actually use everything you've discovered in previous sessions.

#BugBounty
15 replies 27 reposts 321 likes 11K views View on X
Harley Kimball Verified account @infinitelogins
I found a critical privilege escalation that took a brand new free trial account all the way to platform superadmin, with read access to every customer's data on the platform. It earned a $5,000 bounty.

The chain came down to 3 things:

- Mass assignment: a PUT endpoint let a user write their own `admin_permissions` field, including the superadmin flag.
- MFA bypass: escalating to admin triggered MFA on login, but a separate "auto login" flow handed out session tokens with no MFA at all.
- Broken tenant isolation: a superadmin token could read any user's data in any org on the platform.

Here's how I chained all three together:

1. Escalate my own account

As a new free trial user, I sent:

`PUT /api/admin/{my-user-id}`
`{"admin_permissions":"0000000f"}`

The server accepted it. No check that I was already an admin. My account was now superadmin.

2. The MFA wall

The moment I escalated, the backend started enforcing MFA on my logins:

`POST /token` → MFA challenge

Self-enrollment to MFA was disabled, so I couldn't even complete it. Dead end.

Then I remembered the auto login flow.

3. Why that flow exists

The dashboard has a feature for signing in unattended devices. Things that need a session but have no human to type a password (or MFA code).

You generate an "auto login" key, a base64 blob of `{userId}:{tenantId}:{random}`, and the device authenticates itself, headless. MFA is skipped there by design, because there's nobody at the device to challenge.

So I asked: what's stopping me from logging in as a "device" instead of a user?

4. Bypass MFA with the auto login flow

Before escalating, I'd already generated an auto login key for my own account. I replayed it against the device login endpoint:

`POST /autologin/devices`
`{"access_key":"{my-key}", ...}`

It returned a full session token. No MFA challenge, because this path was never meant to need one. And since my account was now superadmin, that token was a superadmin session.

The order is the whole trick. First I created the device key, then I performed the escalation, then I logged back in through the device flow, bypassing MFA. The key was minted before the MFA wall went up, so it still worked after.

5. What this unlocked

With that token:

`GET /api/users/{any-user-id}`

returned full PII for users in completely different orgs, not just mine. User IDs were sequential, so this exposed records across the entire platform.

#BugBounty tip:

When an app adds a second auth factor, check whether every token issuing path enforces it. One legacy or "convenience" flow, like auto login, device pairing, or an API key, that skips MFA can undo the whole thing.

And always ask: can I grab a credential before a security boundary goes up, then reuse it after?