Cyberbezpieczeństwo

Two Critical LiteLLM Vulnerabilities Exposed: How Attackers Could Steal AI API Keys, Take Over Admin Accounts and Execute Code

Two Critical LiteLLM Vulnerabilities Exposed: How Attackers Could Steal AI API Keys, Take Over Admin Accounts and Execute Code

A vulnerability in an AI infrastructure component can be more dangerous than a flaw in the AI model itself. Security researchers have uncovered two high-impact vulnerabilities in LiteLLM, a widely used open-source gateway that connects applications to language model providers such as OpenAI, Anthropic and Google. The flaws could allow authenticated low-privileged users to reach administrative functions, read sensitive server files, take over administrator accounts, execute arbitrary code and steal API credentials.

The disclosure is important because LiteLLM is not just another AI application. It frequently sits directly between internal software and external AI providers. It handles model routing, authentication credentials, configuration, usage tracking and other sensitive operations.

An attacker who compromises this layer may not need to attack an AI provider at all. The gateway itself can become the entry point.

The vulnerabilities were disclosed by Check Point Research on October 13, 2026. They are tracked as CVE-2026-35029 and CVE-2026-59823. Both have been fixed in LiteLLM version 1.83.9 and later. Organizations operating earlier versions should treat the disclosure as a reason to investigate their deployments immediately.

LiteLLM: The Infrastructure Sitting Between Your Application and AI

To understand the impact, it is necessary to understand what LiteLLM actually does.

Organizations rarely connect every application directly to every AI provider. A company may use several models simultaneously:

  • OpenAI models for general-purpose assistance;
  • Anthropic models for coding and document analysis;
  • Google models for multimodal processing;
  • locally hosted models for internal workloads;
  • specialized models for classification, extraction or automation.

Managing these integrations separately can become complicated. Each provider has different API conventions, authentication requirements, rate limits and billing mechanisms.

LiteLLM provides a unified interface. Applications send requests to the gateway, which forwards them to the selected model provider.

A simplified architecture looks like this:

Internal Applications
        |
        v
   LiteLLM Gateway
        |
        +------------------+
        |                  |
        v                  v
   OpenAI API         Anthropic API
        |
        +------------------+
        |                  |
        v                  v
    Google API       Local AI Models

This architecture is convenient, but it also concentrates responsibility.

The gateway may hold credentials for multiple providers, control which users can access particular models, manage routing rules and expose administrative configuration endpoints.

That makes it a valuable target.

A compromised gateway can potentially expose much more than a single chatbot conversation. It can give an attacker access to credentials, configuration, internal files and the infrastructure running the AI service.

The Two Vulnerabilities at a Glance

Check Point Research identified two principal security problems during its assessment of LiteLLM version 1.77.7.

Vulnerability Security issue Potential impact
CVE-2026-35029 Missing authorization enforcement Administrative takeover, arbitrary file access and remote code execution
CVE-2026-59823 Server-side request forgery (SSRF) Redirection of AI requests and exposure of provider API keys

The two vulnerabilities affect different parts of the gateway, but both demonstrate the same architectural problem: a component responsible for controlling access to AI infrastructure must enforce strict boundaries between users, configuration and external destinations.

The most important distinction is that the first issue concerns authorization inside the administrative interface, while the second concerns where the gateway sends outbound requests.

These are not vulnerabilities in the underlying language models. They are vulnerabilities in the infrastructure used to operate AI applications.

CVE-2026-35029: A Low-Privileged User Could Reach Administrative Functions

The first vulnerability involved the POST /config/update endpoint.

This endpoint is designed to update the LiteLLM proxy configuration while the service is running. Configuration changes can affect environment variables, model definitions, general settings and other operational parameters.

Such an endpoint must be protected carefully. A user who can modify the gateway configuration may effectively control the service.

The problem identified by Check Point was a missing role-based authorization check.

LiteLLM uses role-based access control (RBAC). In a correctly configured environment, different users receive different levels of permission.

For example:

  • A Proxy Admin can manage the gateway.
  • An internal user can access permitted functionality.
  • A read-only user should be restricted to viewing information.
  • API users should only be able to perform operations allowed by their assigned credentials.

The vulnerable endpoint authenticated requests but did not correctly enforce the required administrator role before processing configuration changes.

In other words, authentication and authorization were not being treated as separate security requirements.

Authentication answers: Who are you? Authorization answers: What are you allowed to do?

A user could possess a valid account and still have no legitimate reason to modify the gateway configuration.

The vulnerability allowed low-privileged authenticated users to cross that boundary.

How the authorization bypass worked

The research identified two connected weaknesses.

First, the /config/update function relied on generic authentication without performing the necessary explicit Proxy Admin role check.

Second, LiteLLM used a route allowlist for certain dashboard sessions. The route matching logic used prefix-based checks.

The /config route was included in the UI route list. Because the implementation relied on prefix matching, a request to /config/update could also match the allowed /config prefix.

This meant that a route intended to support legitimate dashboard functionality could unintentionally permit access to a much more sensitive operation.

The important lesson is that route authorization must distinguish between exact endpoints and their subpaths. Allowing a route prefix is not equivalent to safely authorizing every operation beneath it.

A security check that looks correct at first glance can become dangerous when combined with another permissive condition.

What could an attacker do after reaching the endpoint?

The consequences went beyond changing an ordinary setting.

Check Point demonstrated several exploitation paths in a controlled environment.

1. Arbitrary file access

The configuration endpoint accepted environment variable changes. One of the variables involved was UI_LOGO_PATH, which controls the file served through the /get_image endpoint.

The researchers demonstrated that an attacker could manipulate this value to make the service return a local file accessible to the LiteLLM process.

That turns a configuration weakness into a file disclosure problem.

Depending on the permissions of the service account and the files present on the server, exposed information could include:

  • application configuration;
  • environment settings;
  • service credentials;
  • API keys;
  • internal application data;
  • other files readable by the LiteLLM process.

The exact impact depends on the deployment. A gateway running with unnecessarily broad filesystem permissions creates a much larger exposure than one running inside a tightly restricted environment.

2. Administrative account takeover

The researchers also demonstrated how environment variable manipulation could affect the credentials used by the LiteLLM dashboard.

The relevant variables included UI_USERNAME and UI_PASSWORD.

If an attacker can modify these values through an insufficiently protected configuration endpoint, the attacker may be able to establish credentials that grant administrative access.

This is particularly serious because the attacker does not necessarily need to compromise the original administrator’s password.

The application can be manipulated into accepting attacker-controlled credentials.

3. Remote code execution

The most serious demonstrated consequence was remote code execution.

LiteLLM supports pass-through endpoints that can load custom adapter modules. Some configurations allow modules to be retrieved from remote storage, including S3 or Google Cloud Storage.

The research showed that an attacker who could modify the gateway configuration could register a malicious pass-through endpoint.

During initialization, the gateway could download the specified Python module and load it.

The critical issue was that loading the module resulted in execution of its top-level Python code.

That changes the security impact dramatically.

The attack is no longer limited to reading configuration or modifying a dashboard account. It can potentially execute code with the privileges of the LiteLLM service.

Depending on the environment, this could provide access to:

  • gateway configuration;
  • provider credentials;
  • local files;
  • application data;
  • internal network resources;
  • other services reachable from the compromised host.

Check Point demonstrated this behavior in a controlled environment. It should not be interpreted as proof that every LiteLLM deployment was compromised in the wild.

However, the demonstrated capability is sufficient to justify immediate remediation.

CVE-2026-59823: The Gateway Could Send Credentials to an Attacker-Controlled Server

The second vulnerability is different.

It concerns Server-Side Request Forgery, commonly abbreviated as SSRF.

SSRF occurs when an attacker can influence a server into making network requests to destinations that should not be accessible through that functionality.

This can be particularly dangerous in infrastructure services because the server may have access to internal networks, cloud metadata endpoints or credentials unavailable to ordinary external users.

In LiteLLM, the issue involved the documented Clientside LLM Credentials functionality.

The gateway accepts requests containing a user_config parameter. This parameter can influence the routing configuration used for an individual request.

According to Check Point, the relevant code path created a new router using the supplied configuration without adequately validating the destination.

That allowed an authenticated user to influence the api_base value used for subsequent requests.

The practical consequence was that a request intended for a legitimate AI provider could be redirected to an attacker-controlled server.

Why this matters for API keys

AI gateways frequently store provider credentials in configuration or environment variables.

For example:

OPENAI_API_KEY=...
ANTHROPIC_API_KEY=...
GOOGLE_API_KEY=...

Applications may never receive these secrets directly. They simply authenticate to the internal gateway, which handles communication with the external provider.

This is normally a good security design.

The problem appears when the gateway can be tricked into sending authenticated requests to an unauthorized destination.

The request may carry provider credentials in its headers. If the gateway sends that request to an attacker-controlled endpoint, the credentials can be exposed.

The attacker may then attempt to use those credentials outside the original organization.

Possible consequences include:

  • unauthorized API usage;
  • unexpected billing;
  • abuse of the organization’s AI accounts;
  • access to provider services under the victim’s identity;
  • disruption of legitimate AI applications;
  • additional exposure if the stolen credentials have broad permissions.

The attack does not require compromising OpenAI, Anthropic or Google.

The weakness exists in the intermediary system that manages the connection.

That is what makes this class of vulnerability particularly important.

Why an AI Gateway Is a High-Value Target

A traditional web application may store a database password or a single external API token.

An AI gateway can centralize access to several providers and internal services.

It may also contain information about:

  • which models are used by individual departments;
  • which users can access expensive models;
  • how requests are routed;
  • what limits are applied;
  • which credentials are active;
  • how internal AI applications are configured.

This makes the gateway an attractive target for both direct compromise and credential theft.

Consider a company with ten internal AI applications. Each application uses a different provider or model, but all requests pass through one LiteLLM deployment.

Compromising that gateway may provide access to a central point of control.

The attacker does not need to compromise all ten applications separately.

The gateway becomes the shared dependency.

This is a familiar security problem in a new part of the technology stack: centralized infrastructure creates operational efficiency, but it also concentrates risk.

How to Check Whether Your LiteLLM Deployment Is Vulnerable

The first step is to establish whether LiteLLM is installed and which version is running.

Do not assume that the absence of a dedicated LiteLLM server means the organization is unaffected. The gateway may be deployed as part of a container, internal platform, orchestration environment or another AI application stack.

Step 1: Check the installed Python package

On a system where LiteLLM is installed directly, run:

python -m pip show litellm

Look for the version field:

Name: litellm
Version: 1.77.7

You can also use:

python -c "import litellm; print(litellm.__version__)"

If the installed version is earlier than 1.83.9, treat the deployment as potentially vulnerable.

The relevant fixed release is LiteLLM 1.83.9. Later releases include these fixes according to the vendor and research disclosure.

Step 2: Check Docker deployments

If LiteLLM runs in Docker, list the active containers:

docker ps

Inspect the container configuration:

docker inspect CONTAINER_NAME

Check the image name and tag. Then inspect the running application inside the container:

docker exec CONTAINER_NAME python -m pip show litellm

Replace CONTAINER_NAME with the actual container name or ID.

Do not rely exclusively on the Docker image tag. A custom image may contain a different package version from the one suggested by its tag.

The installed package version is the more useful indicator.

Step 3: Check Kubernetes deployments

For Kubernetes environments, identify workloads that may contain LiteLLM:

kubectl get deployments -A

Inspect the relevant deployment:

kubectl describe deployment DEPLOYMENT_NAME -n NAMESPACE

Review:

  • container image and tag;
  • image digest;
  • environment variables;
  • mounted configuration files;
  • service account;
  • network policies;
  • exposed services and ingress rules.

If LiteLLM is embedded in a larger application, inspect the actual running container rather than relying only on deployment names.

Step 4: Search for indirect installations

A company may not know that LiteLLM is running.

It could be included in:

  • internal AI platforms;
  • model routing services;
  • development environments;
  • Docker images;
  • Kubernetes workloads;
  • applications built by external contractors;
  • experimental AI infrastructure that was never formally documented.

Search package manifests and deployment repositories:

grep -Rni "litellm" .

For Python dependency files, inspect:

requirements.txt
pyproject.toml
poetry.lock
uv.lock
Pipfile.lock

For container-based deployments, inspect Dockerfiles and image build pipelines.

The objective is to establish where LiteLLM runs, which version is installed and what credentials it can access.

Step 5: Determine whether the gateway is exposed

Check whether the LiteLLM proxy is reachable from:

  • the public internet;
  • employee networks;
  • VPN-connected devices;
  • development environments;
  • other application containers;
  • external integration services.

A gateway exposed directly to the internet has a different risk profile from one accessible only through a tightly controlled internal network.

However, an internal deployment should not be considered safe simply because it is not publicly accessible.

A compromised employee account, another vulnerable application or an infected development environment could provide the initial access needed to reach it.

How to Update LiteLLM Safely

The most important remediation is to upgrade to LiteLLM 1.83.9 or later.

For a standard Python installation:

python -m pip install --upgrade "litellm>=1.83.9"

For a controlled production environment, do not blindly upgrade every dependency without testing.

A safer procedure is:

  1. Identify every affected LiteLLM installation.
  2. Record the current package version and configuration.
  3. Back up configuration and deployment manifests.
  4. Test the updated release in a staging environment.
  5. Verify model routing and authentication.
  6. Deploy the fixed version to production.
  7. Confirm the version actually running inside every container or process.
  8. Review logs and credentials for signs of unauthorized access.

For Docker-based deployments, update the image reference to a trusted fixed release, rebuild or pull the image, and recreate the affected containers.

For Kubernetes, update the deployment image and verify that all old pods have been replaced.

A successful package installation is not enough. The running service must actually use the patched version.

What to Do If You May Already Have Been Exposed

Updating the application prevents exploitation of the known vulnerabilities in fixed versions. It does not automatically reverse damage that may have occurred before the update.

If the gateway was running a vulnerable release and accessible to users who should not have had administrative permissions, perform a security review.

1. Review administrative activity

Inspect available LiteLLM logs and surrounding infrastructure logs.

Look for unexpected:

  • configuration updates;
  • changes to model definitions;
  • changes to environment settings;
  • administrator account modifications;
  • new pass-through endpoints;
  • unusual login activity;
  • requests from unfamiliar users or locations.

Pay particular attention to operations involving configuration changes.

An unexpected update to gateway configuration should be investigated even if the service continues to operate normally.

2. Review outbound network connections

For CVE-2026-59823, examine whether the gateway sent requests to destinations that are not part of the approved provider configuration.

Look for:

  • unfamiliar API base URLs;
  • unexpected external IP addresses;
  • unusual DNS queries;
  • connections to internal addresses that the gateway does not normally need;
  • unexpected changes in provider request volume.

The presence of an unusual connection does not automatically prove exploitation. It is a reason to investigate the associated request, user and configuration.

3. Rotate provider API keys

If there is any indication that credentials may have been exposed, revoke and replace them.

Prioritize keys associated with:

  • OpenAI;
  • Anthropic;
  • Google;
  • cloud-hosted model providers;
  • internal inference platforms;
  • other services accessible through the gateway.

Do not simply generate new keys and leave the old ones active.

Revoke the old credentials, update the application configuration and verify that the new keys are being used.

Review provider usage and billing records for unexpected activity.

4. Review administrator accounts

Check whether:

  • unexpected administrator accounts exist;
  • legitimate accounts have changed permissions;
  • credentials were modified;
  • temporary access tokens remain active;
  • unfamiliar sessions are still valid.

Invalidate suspicious sessions and rotate relevant administrative credentials.

5. Investigate the host

If there is evidence of arbitrary code execution, treat the gateway host as potentially compromised.

Review:

  • running processes;
  • recently created files;
  • scheduled tasks;
  • startup services;
  • container changes;
  • unexpected network connections;
  • access to cloud credentials;
  • lateral movement toward other systems.

If the gateway runs inside a container, do not assume that the container boundary eliminates the incident.

Investigate the host and any accessible services as well.

Where compromise is confirmed, rebuild the affected environment from a trusted image rather than relying solely on cleaning suspicious files.

Hardening LiteLLM Beyond the Patch

Patching is essential, but organizations should also reconsider how their AI infrastructure is deployed.

A gateway that stores multiple provider credentials and controls model access deserves the same security treatment as a production identity service or database.

1. Keep the administrative interface private

Do not expose administrative endpoints directly to the public internet unless there is a compelling and properly protected requirement.

Use:

  • VPN access;
  • private network interfaces;
  • authenticated reverse proxies;
  • firewall allowlists;
  • identity-aware access controls.

The dashboard and configuration endpoints should be reachable only by users who genuinely need them.

2. Apply least privilege

Not every authenticated user should be able to modify the gateway.

Separate administrative functions from ordinary model access.

A developer who can submit prompts does not automatically need permission to change provider credentials or routing configuration.

A monitoring account should not be able to create administrator accounts.

A service account used by an application should have only the permissions required for that application.

3. Restrict outbound network traffic

The SSRF vulnerability highlights the importance of controlling where the gateway can connect.

Where practical, use an outbound allowlist containing approved AI provider endpoints and required infrastructure services.

Block unnecessary access to:

  • cloud metadata endpoints;
  • internal management interfaces;
  • private network ranges;
  • arbitrary external hosts;
  • services unrelated to model operation.

Network restrictions should be enforced outside the application as well. An application-level validation check is useful, but it should not be the only barrier.

4. Protect provider credentials

API keys should not be exposed to ordinary users or placed unnecessarily in prompts, logs or application responses.

Use a dedicated secret-management system where possible.

Apply:

  • restricted credential access;
  • regular rotation;
  • separate keys for different applications;
  • usage limits;
  • provider-side monitoring;
  • immediate revocation procedures.

A single shared key used by every internal application makes incident response much harder.

5. Run the gateway with restricted operating-system permissions

LiteLLM should not run as root unless there is a specific, justified requirement.

Limit:

  • filesystem access;
  • container capabilities;
  • mounted host directories;
  • access to Docker sockets;
  • available system tools;
  • access to unrelated secrets.

The objective is to reduce the consequences of code execution if an application-level vulnerability is discovered.

6. Monitor configuration changes

Configuration changes should be treated as security-sensitive events.

Record:

  • who initiated the change;
  • when it happened;
  • which settings were modified;
  • which account performed the operation;
  • whether the change was approved;
  • whether it introduced a new external destination.

Alert on unexpected administrative activity and changes to provider routing.

7. Include AI infrastructure in penetration tests

Traditional security assessments often focus on public websites, APIs, databases and cloud infrastructure.

AI gateways, model routers and agent frameworks should now be included in the same assessment process.

Test:

  • role enforcement;
  • API authentication;
  • configuration endpoints;
  • outbound request validation;
  • secret handling;
  • administrative account management;
  • container isolation;
  • logging and monitoring.

AI infrastructure is still software infrastructure. It should not receive a lower standard of security simply because it is part of a newer technology stack.

Why This Is Bigger Than LiteLLM

The vulnerabilities are important because they expose a broader issue in the AI ecosystem.

Companies are rapidly building infrastructure around language models. They deploy gateways, orchestration frameworks, agent runtimes, tool servers and integrations with internal business systems.

These components often receive access to highly sensitive resources.

A model gateway may hold credentials for several AI providers. An agent framework may have access to a terminal. An MCP server may communicate with databases, cloud services or local files.

The result is a new infrastructure layer that combines traditional software security risks with the operational complexity of AI systems.

LiteLLM demonstrates that a security failure in this layer can have consequences far beyond the model itself.

This is closely related to the broader problem of AI agents receiving excessive permissions. An agent may be designed to perform useful tasks, but the tools and services connected to it determine what it can actually do.

Netbe has examined this issue in more detail in:

The common lesson is that the security of an AI system cannot be evaluated by examining the model alone.

The surrounding infrastructure matters just as much.

Final Verdict: Your AI Gateway May Be More Valuable Than the Model

The LiteLLM vulnerabilities are a reminder that AI infrastructure is now a serious security target.

CVE-2026-35029 demonstrates how missing authorization checks can turn a low-privileged account into a path toward administrative control and remote code execution.

CVE-2026-59823 shows how insufficient validation of outbound destinations can expose credentials belonging to major AI providers.

Neither vulnerability requires breaking the underlying language model. The weaknesses exist in the software that connects applications to AI services.

Organizations running LiteLLM should verify their installed versions, upgrade to 1.83.9 or later, review administrative activity and rotate provider credentials if exposure is suspected.

The larger lesson is even more important: AI infrastructure must be secured like production infrastructure, not treated as an experimental layer that can be trusted by default.

A gateway that controls model access, stores API keys and routes sensitive data is a high-value system. If it is compromised, the consequences can extend far beyond a chatbot.

The model may be the most visible part of an AI deployment.

The gateway may be the part attackers actually want.

Technical Sources

  1. Check Point Research — When LLM Gateways Go Wrong: Findings from LiteLLM (October 13, 2026): https://research.checkpoint.com/2026/when-llm-gateways-go-wrong-findings-from-litellm/
  2. Check Point — High Risk Vulnerabilities in LiteLLM: https://blog.checkpoint.com/security/check-point-research-discovers-high-risk-vulnerabilities-in-litellm-one-of-the-most-widely-used-llm-gateways/
  3. NIST National Vulnerability Database — CVE-2026-35029: https://nvd.nist.gov/vuln/detail/CVE-2026-35029
  4. NIST National Vulnerability Database — CVE-2026-59823: https://nvd.nist.gov/vuln/detail/CVE-2026-59823
  5. LiteLLM project and release information: https://github.com/BerriAI/litellm
Polecane wpisy
Zastosowanie AI i Machine Learning w obronie przed atakami na Androida
Zastosowanie AI i Machine Learning w obronie przed atakami na Androida

🤖 Zastosowanie AI i Machine Learning w obronie przed atakami na Androida 🔍 Wprowadzenie W świecie rosnącej liczby zagrożeń mobilnych Czytaj dalej

Marek "Netbe" Lampart Inżynier informatyki Marek Lampart to doświadczony inżynier informatyki z ponad 25-letnim stażem w zawodzie. Specjalizuje się w systemach Windows i Linux, bezpieczeństwie IT, cyberbezpieczeństwie, administracji serwerami oraz diagnostyce i optymalizacji systemów. Na netbe.pl publikuje praktyczne poradniki, analizy i instrukcje krok po kroku, pomagając administratorom, specjalistom IT oraz zaawansowanym użytkownikom rozwiązywać realne problemy techniczne.