
Chatwoot v4.19.1 - Alta: 7.1 - Remoto, un clic - integrazione cross-tenant - il callback OAuth di Slack omette lo state e associa un tenant a un workspace dell'attaccante
Chatwoot costruisce la propria URL di autorizzazione Slack senza un state OAuth, e il callback riscatta qualsiasi code nell'account a cui la richiesta è associata. Un attaccante che avvia il flusso verso il proprio workspace Slack può consegnare l'URL di callback a un amministratore vittima e vincolare la casella di supporto di quel tenant allo Slack dell'attaccante.
Classe: omissione di state OAuth / binding dell'account
Portata: remota, interazione dell'amministratore vittima
Chatwoot v4.19.1 - caab07a8
| ID | nessuna CVE al momento |
| Classe | omissione di state OAuth / binding dell'account |
| Portata | Remota, un clic da parte di un amministratore autenticato |
| CWE | CWE-352 |
| CVSS | Alto: 7.1 CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:N |
| Prodotto | Chatwoot |
| Affetto | v4.19.1 caab07a8f00032d5205b5a5d7e2eb0ba2f3d2d82 |
| Auth | l'attaccante necessita di un workspace Slack, non di un account Chatwoot; la vittima è un amministratore autenticato |
| Licenza | GNU Affero GPL v3.0 |
| Lab | Docker compose su loopback; lo scambio del token Slack è simulato |
Ambito della prova. Uno scambio reale richiede un'app Slack registrata, quindi lab/slack_stub.rb sostituisce Slack::Web::Client#oauth_v2_access con una risposta fissa del workspace dell'attaccante. Tutto ciò che Chatwoot fa è HTTP reale verso la build fissata: l'URL di autorizzazione che consegna al browser, l'endpoint di riscatto, l'hook che memorizza e l'account in cui l'hook finisce. Il round-trip con il fornitore è simulato. La conseguenza per il tenant vittima è dedotta dall'hook memorizzato, non osservata in Slack.
| Privilegio | Metodo / sink | Recon / integrità / disponibilità | Provato in lab o dedotto |
|---|---|---|---|
| Leggere l'URL di autorizzazione fornita al tenant | GET /api/v1/accounts/:id/integrations/apps | Recon | Provato in lab. state= assente |
Far riscattare un code arbitrario nel tenant | POST /api/v1/accounts/:id/integrations/slack con {code} | Integrità (binding del tenant) | Provato in lab, con lo scambio simulato |
| Vincolare il tenant al workspace Slack dell'attaccante | Integrations::Hook.access_token memorizzato | Integrità | Provato in lab. Il token memorizzato è uguale al token dell'attaccante |
| Abilitare l'integrazione e riceverne le notifiche | PATCH /integrations/hooks/:id {status: enabled} | Integrità / riservatezza | Provato in lab che l'hook si abilita; consegna dedotta |
Leggere le notifiche di nuove conversazioni e, con two_way, rispondere nei thread dei clienti | eventi dell'app Slack | Riservatezza / integrità | Dedotto dal design dell'integrazione |
| Prendere il controllo di un tenant che aveva già Slack connesso | allow_multiple_hooks: false | Integrità | Dedotto: il nuovo hook sostituisce quello del tenant |
| Leggere direttamente le conversazioni di Chatwoot | nessuno | n/d | Escluso: l'hook porta solo lo scope dell'API Slack |
Resta escluso con questo residuo
| Asse | Metodo / sink | Perché è escluso |
|---|---|---|
| Recon | Accesso diretto ai dati di Chatwoot | La credenziale memorizzata è un token bot Slack |
| Integrità | Binding silenzioso senza la vittima | La route frontend consuma ?code= nel browser della vittima, quindi la vittima deve essere autenticata e aprire il link |
| Integrità | Rigiocare lo stesso code | I code Slack sono monouso; lo stub non lo modella |
| Integrità | Binding a un tenant che l'attaccante non può nominare | La redirect URI è limitata all'account e la POST richiede quell'account nel percorso |
Il catalogo delle integrazioni costruisce un button e un'action per ogni app. Slack è gestito come caso speciale:
# app/models/integrations/app.rb
when 'slack'
client_id = GlobalConfigService.load('SLACK_CLIENT_ID', nil)
"#{params[:action]}&client_id=#{client_id}&redirect_uri=#{self.class.slack_integration_url}"
slack_integration_url è "#{ENV['FRONTEND_URL']}/app/accounts/#{Current.account.id}/settings/integrations/slack". L'id dell'account è nel redirect URI, ed è l'unica cosa che lega il callback a un tenant. Non c'è state, nessun nonce, nessuna registrazione lato server di chi ha avviato il flusso.
Il controller scambia poi qualunque code arrivi:
def create
hook_builder = Integrations::Slack::HookBuilder.new(
account: Current.account, code: params[:code], inbox_id: params[:inbox_id]
)
@hook = hook_builder.perform
end
HookBuilder chiama oauth_v2_access e memorizza il token restituito su Current.account. La pagina frontend all'URI di reindirizzamento legge props.code al mount e lo invia. Quindi l'attacco è: avviare OAuth contro il proprio workspace, prendere il code che Slack emette verso il tuo redirect e inviare alla vittima .../settings/integrations/slack?code=<tuo>. Il suo browser lo invia con la sua sessione, e il suo tenant ottiene il token del tuo workspace.
Il confronto è Linear, che si trova nello stesso file e lo fa correttamente: encode_state genera un token firmato che trasporta l'id dell'account, e il callback di Linear lo decodifica. Slack non ha un equivalente.
Vicoli ciechi: l'app Slack compare nel catalogo solo quando SLACK_CLIENT_SECRET è impostato, e db:chatwoot_prepare inserisce righe vuote di SLACK_CLIENT_ID / SLACK_CLIENT_SECRET che oscurano ENV, quindi la prima esecuzione del lab non vedeva alcuna app Slack. Ora il seed scrive quelle righe e svuota la cache della configurazione. Il secondo era lo stub stesso: slack-ruby-client 2.7.0 definisce Slack::Web come modulo, non come classe, quindi riaprirlo come classe manda in crash Rails all'avvio.
python3 chatwoot-slack-oauth-state-Abraxas-Labs.py
o:
cd lab
./run.sh
Il lab verifica che l'URL di autorizzazione non abbia state, abbia il client_id del lab e porti il redirect_uri con ambito account; invia il codice dell'attaccante con la sessione admin; abilita l'hook; quindi legge il token memorizzato dal database tramite rails runner in modo che la prova non dipenda da alcuna risposta HTTP.
IOC authorize_url=https://slack.com/oauth/v2/authorize?scope=commands,chat:write,...&client_id=lab-slack-client-id&redirect_uri=http://127.0.0.1:28230/app/accounts/1/settings/integrations/slack
IOC state_param_present=false redirect_uri=/app/accounts/1/settings/integrations/slack
IOC redeemed code='lab-attacker-issued-code' hook_id=1 status=False account=1
IOC stored_hook hook_id=1 account=1 status=enabled token='xoxb-lab-attacker-workspace'
IOC tenant_enabled=true hook_bound_to_attacker_workspace=true
SUCCESS CHATWOOT-F3-SLACK-OAUTH-STATE account=1 hook=1 state_absent=true redeemed_without_session=true stored_token=xoxb-lab-attacker-workspace xoxb-lab-attacker-workspace
run.sh smonta lo stack all'uscita.
Genera uno state casuale per ogni avvio, memorizzalo lato server associato all'account e all'utente che ha avviato il flusso, e richiedilo indietro nella callback prima di scambiare il codice. encode_state di Linear nello stesso file è il modello da seguire. Rifiuta una callback il cui state manca o non corrisponde all'account nel percorso.