All guides

Cybersecurity

[DRAFT] AI Gateways With Default Admin Keys

Every team that ships an internal tool makes the same quiet decision somewhere around week two: which credentials from the setup guide get replaced before launch, and which ones survive. Researchers scanning the public internet in February found that nearly one in ten internet-facing LiteLLM gateways they reached still accepted sk-1234, the example admin key printed in LiteLLM's own documentation.

Nobody had to break anything. The password from the manual still worked.

We build this kind of plumbing for a living, and a result like that usually traces back to the same place. A handover that never quite finished.

Why a gateway is worth a key in the first place

LiteLLM is an open-source AI gateway. It sits between a company's own software and the AI providers it pays for, so requests can be routed, usage tracked, and access controlled from one place. It is a reasonable thing to build, and we have recommended the same shape of component to clients.

The trade is that you have now built a chokepoint. The gateway holds the provider tokens your company is billed against. It usually logs the prompts and responses passing through it, which in practice means customer messages, contract text, intake notes, donor records, and whatever else staff paste into an internal tool. It decides which of your applications can reach a model at all. Anyone holding the admin key can read that traffic and change that routing, which puts it closer to a payment system than to an ordinary internal dashboard.

One detail in the research matters more than the rest: these gateways were internet-facing. A tool reachable only from inside a private network is a different object than one that answers to anybody who finds it. Once an admin interface is exposed, scanning does the remaining work automatically.

How the example key survives to launch

It gets in the same way every time. Somebody follows the quickstart to get the thing running on a laptop, pastes the sample key so the first request succeeds, and moves on to the actual problem they were hired to solve. That is correct behavior during a prototype. The failure happens later, at the boundary nobody owns, when the prototype starts serving real traffic without anyone declaring it production.

In a lot of the work we take over, that boundary was never crossed deliberately. There was no launch day. The tool worked, more people started using it, and one Tuesday it was load-bearing.

Nothing in the tooling tells you this happened. No build step fails because a key came from documentation, and no dashboard turns red when an admin panel becomes reachable from the open internet.

What catches it on our projects is showing a working build every week from week two. When a client is looking at a running system that early, the questions get asked while they are still cheap: who can log into this, what happens if that token leaks, who owns it after we hand over. Left until the end, those questions either become a launch blocker or, more often, never get asked at all.

What we do differently on a build

The habit that prevents this is boring: separate credentials per environment from the first commit, not as a cleanup task later. Development, staging, and production get different keys, so a key that leaks anywhere does not open everything. A key that came from a guide never exists outside a laptop.

We also write down the data path before writing the code. What enters the tool, where it is processed, where it is stored, and who can read it. That document is usually one page, and it is the thing that catches the gateway quietly logging prompts into a second copy of your customer data.

Rotation gets designed in rather than discovered later. Replacing a token should be something one person can do on a Tuesday afternoon. If it requires a redeploy nobody has attempted in a year, it will not happen during an incident, which is the only moment it genuinely matters.

When we take over an existing platform, the first thing we ask for is a complete list of the credentials that can reach production. The first list is rarely the real one, and the gap between the first list and the real one is a fair measure of how much cleanup the project needs.

The last piece is ownership. Our clients own 100% of the code, with full IP transfer at handover, because the question "who controls this key" should have an answer that survives any single developer leaving. A gateway installed by a contractor who moved on two years ago is a gateway nobody is watching.

What to ask whoever built yours

If someone else built or installed your AI tooling, this week is a good time to ask four questions and ask for evidence rather than reassurance.

  • Can any admin panel or API on it be reached from the public internet, and if so, why.

  • Are any default, sample, or shared keys still active. The right answer comes from checking, not from memory.

  • Where are the model provider tokens stored, and is that place a shared document.

  • Who holds administrator access today, including contractors whose work finished months ago.

Search the repositories yourself while you are at it. Example keys have a way of surviving in code, environment files, and old deployment scripts long after the person who pasted them has forgotten doing it. Searching for sk-1234 across your own codebase takes a minute and occasionally ruins someone's afternoon.

My own view is that internal AI tools are being held to a standard nobody would accept for a checkout page, mostly because they do not look like money. A gateway has a friendly name, it was set up by one developer in an afternoon, and it sits in the middle of everything. That combination is how it avoids review.

The Bottom Line

The LiteLLM finding is a release process problem wearing a security headline. The fix is procedural and fairly dull: different keys per environment, a written data path, a named owner, and a rule that nothing reaches production carrying a credential that came out of a tutorial.

If you are adding AI to how your business runs and you are not sure any of that is true of your setup, that uncertainty is the finding.

Modernized Mobile has been building and rescuing web and mobile platforms from our Ybor City office since 2017, including custom apps, cybersecurity recovery, and internal AI tools. Tell us what you are running and we will reply within one business day.

What would your project cost?

A ballpark in ten seconds. An exact quote after one short call.

What are you building?

How big is it?

Extras

Typical range$25k–$40k12–16 weeksBallpark only. Fixed quote after we scope it together on a 30 minute call.Get my exact estimate

Ready to put this into practice?

Tell us what you are building and get a free estimate with a reply within one business day.

Modernized Mobile
Modernized Mobile

Modernized
Mobile

Custom mobile apps and web platforms, designed and built in Tampa. Serving Tampa Bay and all of Florida since 2017.

Custom mobile apps and web platforms, designed and built in Tampa. Serving Tampa Bay and all of Florida since 2017.

1600 E 8th Ave A200, Tampa, FL 33605

1600 E 8th Ave A200, Tampa, FL 33605

© 2026 Modernized Mobile. All rights reserved.

© 2026 Modernized Mobile. All rights reserved.

Trust in quality. We deliver.

Trust in quality. We deliver.