
Chatwoot v4.19.1 - Alta: 7.1 - Remoto, um clique - integração entre tenants - o callback do Slack OAuth omite o state e vincula um tenant a um workspace do atacante
O Chatwoot constrói sua URL de autorização do Slack sem um state de OAuth, e o callback resgata qualquer code para a conta à qual a requisição está vinculada. Um atacante que inicia o fluxo contra seu próprio workspace do Slack pode entregar a URL de callback a um administrador vítima e vincular a caixa de entrada de suporte desse tenant ao Slack do atacante.
Classe: omissão de state de OAuth / vinculação de conta
Alcance: Remoto, interação do administrador vítima
Chatwoot v4.19.1 - caab07a8
| ID | ainda sem CVE |
| Classe | omissão de state de OAuth / vinculação de conta |
| Alcance | Remoto, um clique por um administrador autenticado |
| 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 |
| Produto | Chatwoot |
| Afetado | v4.19.1 caab07a8f00032d5205b5a5d7e2eb0ba2f3d2d82 |
| Autenticação | o atacante precisa de um workspace do Slack, não de uma conta no Chatwoot; a vítima é um administrador autenticado |
| Licença | GNU Affero GPL v3.0 |
| Laboratório | Docker compose em loopback; a troca de token do Slack é simulada |
Escopo da prova. Uma troca real exige um app do Slack registrado, então lab/slack_stub.rb substitui Slack::Web::Client#oauth_v2_access por uma resposta fixa do workspace do atacante. Tudo o que o Chatwoot faz é HTTP real contra a build fixada: a URL de autorização que ele entrega ao navegador, o endpoint de resgate, o hook que ele armazena e a conta na qual o hook é gravado. A ida e volta com o fornecedor é simulada. A consequência para o tenant vítima é inferida a partir do hook armazenado, não observada no Slack.
| Privilégio | Método / sink | Reconhecimento / integridade / disponibilidade | Comprovado em laboratório ou inferido |
|---|---|---|---|
| Ler a URL de autorização entregue ao tenant | GET /api/v1/accounts/:id/integrations/apps | Reconhecimento | Comprovado em laboratório. state= ausente |
Fazer um code arbitrário ser resgatado no tenant | POST /api/v1/accounts/:id/integrations/slack com {code} | Integridade (vinculação do tenant) | Comprovado em laboratório, com a troca simulada |
| Vincular o tenant ao workspace do Slack do atacante | Integrations::Hook.access_token armazenado | Integridade | Comprovado em laboratório. O token armazenado é igual ao token do atacante |
| Habilitar a integração e receber suas notificações | PATCH /integrations/hooks/:id {status: enabled} | Integridade / confidencialidade | Comprovado em laboratório que o hook é habilitado; entrega inferida |
Ler notificações de novas conversas e, com two_way, responder em threads de clientes | eventos do app do Slack | Confidencialidade / integridade | Inferido a partir do design da integração |
| Assumir um tenant que já tinha o Slack conectado | allow_multiple_hooks: false | Integridade | Inferido: o novo hook substitui o do próprio tenant |
| Ler conversas do Chatwoot diretamente | nenhum | n/a | Fechado: o hook carrega apenas o escopo da API do Slack |
Permanece fechado neste resíduo
| Eixo | Método / sink | Por que está fechado |
|---|---|---|
| Reconhecimento | Acesso direto aos dados do Chatwoot | A credencial armazenada é um token de bot do Slack |
| Integridade | Vinculação silenciosa sem a vítima | A rota do frontend consome ?code= no navegador da vítima, então a vítima precisa estar autenticada e abrir o link |
| Integridade | Reutilizar o mesmo code | Codes do Slack são de uso único; o stub não modela isso |
| Integridade | Vincular a um tenant que o atacante não consegue nomear | A redirect URI é vinculada à conta e o POST precisa dessa conta no caminho |
O catálogo de integrações constrói um button e uma action para cada app. O Slack é tratado como caso especial:
# 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". O id da conta está no URI de redirecionamento, e é a única coisa que vincula o callback a um tenant. Não há state, nem nonce, nem registro no lado do servidor de quem iniciou o fluxo.
O controller então troca qualquer code que chegue:
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 chama oauth_v2_access e armazena o token retornado em Current.account. A página do frontend na URI de redirecionamento lê props.code na montagem e o envia. Portanto, o ataque é: iniciar o OAuth contra seu próprio workspace, pegar o code que o Slack emite para seu redirecionamento e enviar à vítima .../settings/integrations/slack?code=<seu>. O navegador dela o envia com a sessão dela, e o tenant dela recebe o token do seu workspace.
A comparação é o Linear, que está no mesmo arquivo e faz isso corretamente: encode_state gera um token assinado carregando o id da conta, e o callback do Linear o decodifica. O Slack não tem equivalente.
Caminhos errados: o app do Slack só aparece no catálogo quando SLACK_CLIENT_SECRET está definido, e db:chatwoot_prepare semeia linhas em branco de SLACK_CLIENT_ID / SLACK_CLIENT_SECRET que sobrepõem ENV, então a primeira execução do lab não viu nenhum app do Slack. O seed agora grava essas linhas e limpa o cache de configuração. O segundo foi o próprio stub: slack-ruby-client 2.7.0 define Slack::Web como um módulo, não como uma classe, então reabri-lo como classe derruba o Rails na inicialização.
python3 chatwoot-slack-oauth-state-Abraxas-Labs.py
ou:
cd lab
./run.sh
O laboratório verifica que a URL de autorização não possui state, tem o client_id do laboratório e carrega o redirect_uri com escopo de conta; envia o código do atacante com a sessão de administrador; habilita o hook; em seguida, lê o token armazenado do banco de dados por meio de rails runner, de modo que a prova não depende de nenhuma resposta 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 derruba a stack ao sair.
Gere um state aleatório por iniciação, armazene-o no servidor associado à conta e ao usuário iniciador, e exija-o de volta no callback antes de trocar o código. O encode_state do Linear no mesmo arquivo é o padrão. Rejeite um callback cujo state esteja ausente ou não corresponda à conta no caminho.