[HackerNotes Ep. 190] Where to Point Your Tokens: Cloud Providers, Auth Bypass, and AI Hacking

Hacker TL;DR

• Point your compute at auth bypass, not RCE. SAML, JWT, mTLS, and default-secret cookies are everywhere, and a full auth bypass gets you straight to privesc and account takeover.

• The biggest bug is also the best paid. Cloud provider admin access or a cross-tenant bug is top impact and top payout at the same time. That means the ecosystem is doing its job.

• In the AI era, pick programs by speed, not size. A report now takes 5 to 10 minutes to write, so how fast a program pays matters more than the bounty amount.

• Build the machine, then hand off the boring parts. Automation that pays the bills in the background is what buys you the freedom to hack what you actually want.

Sponsored by ThreatLocker – Privileged Access Management. Fitting, since auth bypass and privilege escalation are the whole theme here: least privilege plus PAM are exactly what keeps a full auth bypass from turning into game over. Worth a look.

Codex vs. Claude

Joseph has gone full Codex maximalist, and not even the CLI. He's hooked on the Codex desktop app on macOS. The main reason is that Codex keeps trying when things break. Ask Claude to drive your machine and it sometimes gives up with "I can't find the browser, I can't find the plugin." Codex just works through the list: browser plugin, then browser use, then computer use, then its own built-in browser. If something is blocked, it looks for a way around it.

Justin has had the opposite experience and still gets more out of Claude, so take the whole debate with a grain of salt. Tool preference here is noisy and personal, and a lot of the "Codex is cleaner" feeling comes down to running on a Mac. On WSL and Windows it's rougher, with remote connections dropping and a generally messier experience.

Pro Tip: Don't switch your whole setup based on someone else's model preference until you match their environment. A macOS versus WSL gap alone can explain most of the difference. Test on your own machine first.

Where Do You Point an All-Knowing AI?

Here's a useful way to think about compute: if you had an AI that could find a bug in anything, where would you aim it? Ask it twice, once for the most impact on the world and once for the most money. The answer is the same both times, and that's the interesting part.

The answer is cloud providers. A cloud admin panel, a cross-tenant IDOR, an auth bypass, or a sandbox escape that gets you RCE on bare metal is top impact and top payout at once. Everything runs on AWS, GCP, or Azure, so a cross-tenant bug there is about as close to "take over the internet" as bug bounty gets. The fact that it also pays the most is a good sign: bounties are roughly tracking real risk.

Auth Bypass Is the Play

That bug captures the main idea: stop chasing RCE, start chasing auth bypass.

The reasoning is simple. Every app has authentication, but only a few do something reckless enough to give you code execution. A full auth bypass takes you straight to vertical privesc and account takeover, so it's a much more reliable place to spend compute than hunting for RCE. Where to aim it:

• SAML. Auth bypasses in SAML are common on big SaaS and cloud providers, and a full one is huge.

• JWT validation. Same kind of flaw, one layer up: weak signature or claim checks. It shows up in the wild, including on setups built with AWS Cognito.

• mTLS. A badly built mutual-TLS handshake is the same story, just deeper in the stack.

• Any broken auth mechanism. This is the real target. A classic example is cookies signed with default framework secrets, which is exactly the kind of thing a model can grind through at scale if you feed it a list of framework defaults.

Pro Tip: Run Cookie Monster by Ian Carroll on signed cookies to catch known and default secrets. Then feed your AI your own report history. The best prompt you can give an agent is basically "here is where I've found auth bypass and account takeover before," so it hunts your proven patterns instead of starting from zero.

We do subs at $25, $10, and $5, premium subscribers get access to:

– Hackalongs: live bug bounty hacking on real programs, VODs available
– Live data streams, exploits, tools, scripts & un-redacted bug reports

You can also find some hacker swag here.

Need a Pentest? We just launched CTBB Pentests!

Hack full time? Check out the Full-Time Hunter’s Guild!

Some Things Are Just Secure

The reality check against all the AI hype is that some targets just hold. A full pipeline plus years of Google recon pointed at Gmail and Google Drive found nothing. That's not the tooling failing, it's an answer. A mature target with well-separated accounts can genuinely be secure. There might be some deep low-level zero-day in there somewhere, but AI doesn't change the fact that hard targets are hard. What it does change is how fast you get to that answer, so you can move on and dig deeper somewhere the walls are thinner.

Picking Programs When Reports Are Cheap

Now flip it around: forget the one internet-melting bug, if you wanted to farm a hundred highs and criticals instead, how do you pick the program? It comes down to three simple rules.

Go for programs that pay fast, not programs that pay big

When a report takes 5 to 10 minutes to write, the bounty amount matters much less than how fast and how often you get paid. The move is to look across every program you have access to and find the ones with the best stats for paying out quickly, then work those first. When each report costs you a coffee break, fast beats big.

Pick targets that are easy for AI to hack

Some targets are just easier for agents to grind on for a long time:

• Lots of API endpoints. More documented endpoints give the agent room to explore and chain bugs.

• CLI-driven targets. Cloud hacking is surprisingly good here, because tools like the gcloud and aws CLIs let the model spin up and tear down its own resources and manage its own environment. Meta's SPDL is another example of a target-specific language you can hand a model, and you can build your own too.

• Related apps that share code. A company with many similar apps is ideal, because running them in one session lets the agent reuse ideas across shared APIs and auth. Think of a vendor with thirty-odd Android apps built by the same teams.

Hack horizontally

The common thread is horizontal over vertical: take one bug class or one new technique and run it across many similar apps, instead of going deep on a single target. That plays to what agents are good at.

Inside the Hackbots

A few build details worth stealing from real hacking pipelines.

The coolest one is self-tooling. A manager agent watches what the worker agents are doing, spots a useful action they keep repeating, and spins up a tooling agent to build a reusable tool. That tool is then shared with every other agent and improved over time as it breaks and gets fixed. The bots don't just hack, they build their own tools.

False positives turn out to be mostly a model problem, not a pipeline problem. A system built on Opus can be noisy enough to eat a full day of triage. A system tuned differently can have almost every bug reach the validation stage and come back valid, to the point you worry it's filtering too hard and missing real ones. That gap follows the model version closely, so rebuilds are worth it now that Opus 5 is out.

The hardest bugs take real time. Codex grinding on V8 RCEs will often surface a contrived multi-step chain no real user would ever hit, so you have to ask for realistic paths, something like "cloud-to-local RCE with normal user behavior." When it works, it's great: a clean RCE in a 3D printer vendor's software, where opening a print file and saving an edit is enough to pop calc. Same theme with a recent Next.js RCE hidden in a file-format converter. Anything that parses images or video is a great place for a model to find code execution.

Build the Machine, Then Get Out of the Way

One last angle: what does the ideal workday actually look like?

The first version is having something running in the background that reliably brings in money, the way a run of Route 53 subdomain takeovers can pay for a couple of carefree years abroad. A steady automated income is what lets you take the engagements you want and go deep on the tech you actually care about, instead of grinding for rent.

The second version is protecting focus: keeping even two to four hours of uninterrupted time while agents work in the background. Most of the stress in this job comes from having things you need to finish and no clear space to finish them. So defending your focus time is the real win, not adding more hours.

Both land on the same move: hand off the boring parts. Accounting is a no-brainer, outsource it. Triage is the more interesting one: give your hackbot's triage to friends who are learning to hack, for a cut. It hits every goal at once. You pour into the community, they get real income and real practice, and you drop the mental load. It also compounds. Bring people in, let them catch a real bug, and they stick. Get three of your four closest friends hacking, and suddenly you have a local crew who all landed bugs this year and none of whom hacked before.

Resources

• Cookie Monster, Ian Carroll: catch cookies signed with known or default secrets.

• Web Fuzzing for Hackers, Intigriti: a practical fuzzing guide.

• Interview with Ryan Bonner, Intigriti: going full-time and the mindset behind it.

• Steve's Maturity Framework: grading security maturity.

That's it for the week, keep hacking!