
Chatwoot v4.19.1 - Élevée : 7.1 - À distance, en un clic - intégration inter-locataires - le callback OAuth Slack omet l'état et lie un locataire à l'espace de travail d'un attaquant
Chatwoot construit son URL d'autorisation Slack sans state OAuth, et le callback échange n'importe quel code contre le compte auquel la requête est rattachée. Un attaquant qui lance le flux contre son propre espace de travail Slack peut remettre l'URL de callback à un administrateur victime et lier la boîte de support de ce tenant à son propre Slack.
Classe : omission de state OAuth / liaison de compte
Portée : À distance, interaction de l'administrateur victime
Chatwoot v4.19.1 - caab07a8
| ID | pas encore de CVE |
| Classe | omission de state OAuth / liaison de compte |
| Portée | À distance, un clic par un administrateur connecté |
| CWE | CWE-352 |
| CVSS | Élevé : 7.1 CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:N |
| Produit | Chatwoot |
| Affecté | v4.19.1 caab07a8f00032d5205b5a5d7e2eb0ba2f3d2d82 |
| Auth | l'attaquant a besoin d'un espace de travail Slack, pas d'un compte Chatwoot ; la victime est un administrateur connecté |
| Licence | GNU Affero GPL v3.0 |
| Lab | Docker compose en loopback ; l'échange de jeton Slack est simulé |
Portée de la preuve. Un échange réel nécessite une application Slack enregistrée, donc lab/slack_stub.rb remplace Slack::Web::Client#oauth_v2_access par une réponse fixe de l'espace de travail de l'attaquant. Tout ce que fait Chatwoot est du HTTP réel contre la version épinglée : l'URL d'autorisation remise au navigateur, le point de terminaison d'échange, le hook stocké et le compte dans lequel le hook atterrit. L'aller-retour avec le fournisseur est simulé. La conséquence pour le tenant victime est déduite du hook stocké, non observée dans Slack.
| Privilège | Méthode / sink | Reconnaissance / intégrité / disponibilité | Prouvé en lab ou déduit |
|---|---|---|---|
| Lire l'URL d'autorisation fournie au tenant | GET /api/v1/accounts/:id/integrations/apps | Reconnaissance | Prouvé en lab. state= absent |
Faire échanger un code arbitraire contre le tenant | POST /api/v1/accounts/:id/integrations/slack avec {code} | Intégrité (liaison du tenant) | Prouvé en lab, avec l'échange simulé |
| Lier le tenant à l'espace de travail Slack de l'attaquant | Integrations::Hook.access_token stocké | Intégrité | Prouvé en lab. Le jeton stocké est égal au jeton de l'attaquant |
| Activer l'intégration et recevoir ses notifications | PATCH /integrations/hooks/:id {status: enabled} | Intégrité / confidentialité | Prouvé en lab que le hook s'active ; livraison déduite |
Lire les notifications de nouvelles conversations, et avec two_way répondre dans les fils clients | événements de l'application Slack | Confidentialité / intégrité | Déduit de la conception de l'intégration |
| Prendre le contrôle d'un tenant ayant déjà connecté Slack | allow_multiple_hooks: false | Intégrité | Déduit : le nouveau hook remplace celui du tenant |
| Lire directement les conversations Chatwoot | aucun | n/a | Fermé : le hook ne porte que la portée de l'API Slack |
Reste fermé sur ce reliquat
| Axe | Méthode / sink | Pourquoi c'est fermé |
|---|---|---|
| Reconnaissance | Accès direct aux données Chatwoot | Le justificatif stocké est un jeton de bot Slack |
| Intégrité | Liaison silencieuse sans la victime | La route frontend consomme ?code= dans le navigateur de la victime, donc la victime doit être connectée et ouvrir le lien |
| Intégrité | Rejouer le même code | Les codes Slack sont à usage unique ; le stub ne modélise pas cela |
| Intégrité | Lier à un tenant que l'attaquant ne peut pas nommer | L'URI de redirection est rattachée au compte et le POST nécessite ce compte dans le chemin |
Le catalogue d'intégrations construit un button et une action pour chaque application. Slack fait l'objet d'un traitement particulier :
# 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 est "#{ENV['FRONTEND_URL']}/app/accounts/#{Current.account.id}/settings/integrations/slack". L'identifiant du compte se trouve dans l'URI de redirection, et c'est la seule chose qui relie le callback à un tenant. Il n'y a pas de state, pas de nonce, aucun enregistrement côté serveur de qui a initié le flux.
Le contrôleur échange ensuite le code qui arrive :
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 appelle oauth_v2_access et stocke le jeton renvoyé sur Current.account. La page frontend située à l'URI de redirection lit props.code au montage et le poste. L'attaque est donc la suivante : lancez l'OAuth contre votre propre espace de travail, récupérez le code que Slack émet vers votre redirection, et envoyez à la victime .../settings/integrations/slack?code=<le_vôtre>. Son navigateur le poste avec sa session, et son tenant reçoit le jeton de votre espace de travail.
La comparaison est Linear, qui se trouve dans le même fichier et le fait correctement : encode_state génère un jeton signé portant l'id du compte, et le callback Linear le décode. Slack n'a pas d'équivalent.
Fausses pistes : l'application Slack n'apparaît dans le catalogue que lorsque SLACK_CLIENT_SECRET est défini, et db:chatwoot_prepare insère des lignes vides SLACK_CLIENT_ID / SLACK_CLIENT_SECRET qui masquent ENV, si bien que la première exécution en labo n'a vu aucune application Slack. Le seed écrit désormais ces lignes et vide le cache de configuration. La seconde était le stub lui-même : slack-ruby-client 2.7.0 définit Slack::Web comme un module, et non une classe, donc le réouvrir en tant que classe fait planter Rails au démarrage.
python3 chatwoot-slack-oauth-state-Abraxas-Labs.py
ou :
cd lab
./run.sh
Le lab vérifie que l'URL d'autorisation ne contient pas de state, possède le client_id du lab et porte le redirect_uri limité au compte ; il envoie le code de l'attaquant avec la session admin ; active le hook ; puis lit le token stocké depuis la base de données via rails runner afin que la preuve ne dépende d'aucune réponse 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 démonte la pile à la sortie.