Seu assistente de codificação de IA está vazando segredos

Como Claude, Copilot, Cursor e outras ferramentas de IA armazenam credenciais em texto simples e 8 exemplos de como os atacantes as exploram

O problema

Aplicações de desktop de IA precisam autenticar-se com serviços externos. Claude Code precisa dos seus tokens OAuth. GitHub Copilot precisa da sua autenticação GitHub. Continue.dev precisa das suas chaves API. Servidores MCP precisam de tokens para Azure DevOps, Slack, bancos de dados e tudo o mais que você conectou. Para onde vão todas essas credenciais? Principalmente para arquivos JSON em texto simples no seu diretório pessoal. Esses arquivos estão em locais conhecidos ou previsíveis, tornando-os fáceis de encontrar com acesso de leitura a um sistema.

O que eu encontrei

Explorei 14 ferramentas populares de IA (veja a referência no final do blog) no Windows, macOS e Linux. Estas são as coisas que mais me chamaram a atenção.

Claude Code CLI

~/.claude/.credentials.json contém seus tokens de acesso e atualização OAuth em JSON em texto simples:

      { 
  "claudeAi": { 
    "type": "oauth", 
    "access": "sk-ant-oat01-...", 
    "refresh": "sk-ant-ort01-...", 
    "expires": 1776098433694 
  } 
} 
      

No Linux, o arquivo é criado com permissões 0600 (leitura/gravação apenas para o proprietário). No macOS, as credenciais vão para o Keychain. Mas no WSL, o arquivo do lado do Windows herda as permissões padrão da montagem 0777 tornando seus tokens OAuth Claude legíveis para qualquer processo no sistema. O token de atualização é o realmente perigoso aqui. Ele tem longa duração e pode gerar novos tokens de acesso indefinidamente. Um invasor que o obtiver terá acesso persistente à sua conta Claude até que você o revogue explicitamente.

Configurações do servidor MCP: o problema da agregação

Os servidores Model Context Protocol (MCP) permitem que assistentes de IA se conectem a ferramentas externas. Cada conexão precisa de autenticação, e esses tokens normalmente acabam em um único arquivo de configuração como este:

      { 
  "mcpServers": { 
    "github": { "env": { "GITHUB_TOKEN": "ghp_realToken..." } }, 
    "azure": { "env": { "ADO_MCP_AUTH_TOKEN": "eyJ0eX..." } }, 
    "slack": { "env": { "SLACK_BOT_TOKEN": "xoxb-..." } }, 
    "database": { "env": { "DB_PASSWORD": "prod_password" } } 
  } 
} 
      

Um arquivo. Múltiplos serviços. Uma operação de leitura pode comprometer todos eles. A Trend Micro descobriu que 48% das 19.402 implementações de servidores MCP recomendam o armazenamento de credenciais em texto simples.

Continue.dev: chaves API em texto simples

Continue.dev armazena cada chave API configurada diretamente em ~/.continue/config.json:

      { 
  "models": [{ 
    "provider": "anthropic", 
    "apiKey": "sk-ant-api03-YOUR-ACTUAL-KEY" 
  }] 
} 
      

A comunidade reconhece isso como um problema (issue do GitHub #1729). A substituição de variáveis de ambiente é suportada (${VAR_NAME}) mas não é o comportamento padrão.

Cline: credenciais sincronizadas com a nuvem

As configurações MCP de Cline estão em um arquivo JSON não criptografado dentro do globalStorage do VS Code. O problema é que o VS Code Settings Sync faz o upload automático desse arquivo para o GitHub. Se você ativou o Settings Sync, suas credenciais MCP estão armazenadas na nuvem do GitHub.

A confusão do VS Code SecretStorage

GitHub Copilot, Cline e outras extensões do VS Code usam a API SecretStorage, que criptografa segredos em um banco de dados SQLite (state.vscdb) usando AES-128-CBC. Isso parece seguro até você perceber que:

• As extensões do VS Code são executadas sem sandboxing
• A chave de criptografia está no chaveiro do sistema operacional, acessível por qualquer processo em nível de usuário
• Qualquer extensão maliciosa pode ler os segredos de outras extensões
• O sistema de identificação de extensão é vulnerável a falsificações

A criptografia fornece defesa contra o acesso offline ao disco, mas não contra qualquer processo em execução como o mesmo usuário.

Exemplos de superfície de ataque

Identifiquei 8 cenários de ataque do mundo real que queria destacar, possibilitados pela exposição de credenciais de IA.

1. Roubo de credenciais via malware

Os caminhos dos arquivos são previsíveis e consistentes em todas as instalações:

      ~/.claude/.credentials.json 
~/.continue/config.json 
~/.aws/credentials 
~/.config/gcloud/application_default_credentials.json 
~/Library/Application Support/Claude/claude_desktop_config.json 
~/.claude.json 
      

O malware Infostealer já mira cookies de navegador, chaves SSH e credenciais em nuvem. Adicionar alguns caminhos de ferramentas de IA à lista de alvos é trivial. Não é necessária escalada de privilégios; a leitura de arquivos em nível de usuário padrão é suficiente.

Uma única infecção por malware pode revelar tokens Claude OAuth, todas as chaves API em Continue.dev, todos os tokens de servidor MCP e credenciais AWS. Os caminhos são os mesmos em todas as instalações de todas as ferramentas.

Risco: CRÍTICO. Alta probabilidade, alto impacto.

2. Sequestrar uma sessão de controle remoto Claude Code

Este é o cenário que deveria assustá-lo. Claude Code tem um recurso de Remote Control (claude remote-control) que permite aos usuários controlar sua sessão local do Claude Code a partir de um telefone, tablet ou navegador via claude.ai/code. Toda a execução do código permanece na máquina local. O dispositivo remoto é apenas uma interface de controle.

Aqui está o problema: a conexão remota não requer reautenticação. Uma vez que a sessão está ativa, qualquer pessoa com a URL da sessão pode enviar instruções. E todas essas instruções são executadas localmente na máquina do desenvolvedor.

Agora combine isso com --dangerously-skip-permissions.

Esta flag desativa todos os prompts interativos de permissão. Escritas de arquivos, comandos shell, requisições de rede, chamadas de ferramentas MCP, tudo é executado automaticamente sem perguntar ao usuário. É destinada a contêineres CI/CD isolados, mas às vezes os usuários a utilizam em suas estações de trabalho por conveniência. Também pode ser configurada como padrão persistente em settings.json via "defaultMode": "bypassPermissions".

A cadeia de ataque:

1. O invasor rouba tokens OAuth de ~/.claude/.credentials.json (via malware, SSRF ou qualquer vulnerabilidade de leitura de arquivos)
2. Os tokens são portáteis, portanto funcionam em qualquer máquina
3. Se a vítima tiver uma sessão ativa de Remote Control, o atacante se conecta e assume o controle
4. If the victim runs with --dangerously-skip-permissions, the attacker now has unrestricted shell access as the victim's user:
   • Ler/gravar qualquer arquivo no sistema
   • Executar comandos arbitrários (curl, ssh, docker, gerenciadores de pacotes, etc.)
   • Instalar backdoors, exfiltrar dados, pivotar para outras máquinas
   • Acesse chaves SSH, credenciais na nuvem e todos os outros segredos do sistema
   • Modificar repositórios git, pipelines CI/CD e configurações de implantação

Mesmo sem --dangerously-skip-permissions, Claude Code em acceptEdits modo aprova automaticamente edições de arquivos e comandos comuns do sistema de arquivos. Isso ainda pode ser perigoso. O modelo de permissões foi projetado para proteger contra ações acidentais, não contra um ator malicioso controlando a sessão.

Risco: CRÍTICO (com --dangerously-skip-permissions), ALTO (permissões padrão).

3. Movimento lateral via tokens Claude OAuth

Um invasor que obtiver um token de atualização OAuth Claude de ~/.claude/.credentials.json pode:

1. Gere novos tokens de acesso remotamente (os tokens de acesso expiram em ~60 minutos, mas o token de atualização tem longa duração)
2. Acesse as conversas Claude e os arquivos do espaço de trabalho da vítima
3. Use quaisquer servidores MCP que a vítima tenha configurado (acessando seus repositórios GitHub, projetos Azure DevOps, espaços de trabalho Slack e bancos de dados através do assistente de IA como proxy)

Os tokens são portáteis. Copie o arquivo de credenciais para outra máquina, e Claude Code o usará. A Anthropic implementa a rotação de tokens de atualização, então usar um token roubado pode eventualmente invalidar o original, mas o uso inicial tem sucesso e o invasor pode obter acesso antes que a rotação entre em vigor.

Risco: ALTO. Probabilidade média-alta, alto impacto.

4. Agregação de token MCP: movimento lateral

Um único arquivo de configuração MCP agrega tokens para múltiplos serviços externos. Por exemplo, um arquivo poderia gerar:

• GITHUB_PERSONAL_ACCESS_TOKEN → repositórios de código, PRs, CI/CD
• ADO_MCP_AUTH_TOKEN → projetos Azure DevOps
• SLACK_BOT_TOKEN → espaço de trabalho interno do Slack
• Senhas de banco de dados → dados de produção
• JIRA_API_TOKEN → gestão de projetos, tickets internos

Ao contrário do armazenamento distribuído de credenciais, onde comprometer um canal expõe apenas um subconjunto de credenciais, o padrão de agregação do MCP significa que a divulgação de um único arquivo causa uma cascata que compromete todos os serviços conectados.

Risco: CRÍTICO. Alta probabilidade, alto impacto.

5. Extensão maliciosa do VS Code: exfiltração de credenciais

As extensões do VS Code são executadas sem sandboxing. Todas as extensões compartilham as mesmas permissões de processo. Uma extensão maliciosa ou comprometida pode:

1. Acesse diretamente o banco de dados SQLite state.vscdb
2. Recupere a chave de criptografia do chaveiro do sistema operacional (acessível por qualquer processo em nível de usuário)
3. Descriptografar todos os segredos da extensão: tokens Copilot, chaves API Cline, credenciais MCP

O arquivo cline_mcp_settings.json nem precisa de descriptografia. É texto simples não criptografado no globalStorage do VS Code e é sincronizado para a nuvem via Settings Sync.

Os campos publisher e name do package.json que identificam extensões são vulneráveis a falsificação, tornando possível a personificação de extensões legítimas.

Risco: ALTO. Probabilidade média, alto impacto.

6. Escalada de permissões WSL

Desenvolvedores que usam WSL são afetados de ambos os lados. Ferramentas de IA instaladas no Windows armazenam credenciais em C:\Users\<you>\, que é montado no WSL como /mnt/c/Users/<you>/ com permissões 0777 por padrão. O mesmo arquivo de credenciais protegido por NTFS no lado do Windows é legível por todos do lado Linux.

Em ambientes WSL multiusuário ou contêineres comprometidos, isso é fácil de explorar. Qualquer processo em execução no sistema WSL pode ler tokens Claude OAuth, configurações MCP, etc., armazenados no lado do Windows.

Risco: ALTO para usuários WSL. Alta probabilidade, impacto médio-alto.

7. .mcp.json enviado para git: crexfiltração de credenciais

O arquivo .mcp.json na raiz do repositório é projetado para ser versionado para que as equipes possam compartilhar configurações do servidor MCP. Se um desenvolvedor incluir tokens inline em vez de referências a variáveis de ambiente:

1. Tokens aparecem no histórico do git
2. Mesmo após a remoção, git log -p .mcp.json as revela
3. Scanners automatizados (TruffleHog, GitLeaks, etc.) podem encontrá-los em grande escala no GitHub/GitLab

A parceria de varredura secreta entre Anthropic e GitHub detecta algumas chaves API expostas, mas os tokens de configuração MCP para outros serviços (Azure DevOps, Slack, bancos de dados) não são cobertos pela varredura automatizada. Não existe um padrão de scanner secreto do GitHub para ADO_MCP_AUTH_TOKEN ou SLACK_BOT_TOKEN incorporados em blocos JSON de ambiente.

Risco: MÉDIO. Probabilidade média, impacto médio-alto.

8. Ataque à cadeia de suprimentos via servidores MCP

Os servidores MCP são frequentemente pacotes npm. O risco da cadeia de suprimentos é o mesmo de qualquer dependência npm, mas com uma diferença crítica: Os servidores MCP recebem credenciais na inicialização.

1. Pacote popular de servidor MCP no npm está comprometido (ou um typosquat foi publicado)
2. Os usuários configuram-no no seu claude_desktop_config.json com tokens reais no env bloco
3. O processo do servidor MCP tem acesso a todas as variáveis de ambiente que lhe são passadas, incluindo tokens
4. Servidor comprometido exfiltra tokens para a infraestrutura do atacante

Sem a validação adequada do público OAuth 2.1 (RFC 8707), um servidor MCP malicioso também poderia receber tokens de acesso e reproduzi-los contra outros serviços (ataque de passagem de token).

A estatística de 48% de credenciais em texto simples significa que quase metade de todas as configurações de servidor MCP entrega credenciais diretamente ao processo do servidor na inicialização. Se esse processo do servidor for comprometido, todo usuário que o instalou também estará comprometido.

Risco: MÉDIO. Probabilidade baixa a média, alto impacto.

Bônus: roubo de token CI/CD

O comando claude setup-token gera um token OAuth de um ano (CLAUDE_CODE_OAUTH_TOKEN) para pipelines CI/CD. Isso cria um risco único:

• O token funciona em qualquer máquina por até um ano
• Sistemas CI/CD frequentemente têm gerenciamento fraco de segredos e isolamento limitado de tarefas
• Os logs de build podem expor acidentalmente os valores das variáveis de ambiente
• Um runner de CI/CD comprometido concede acesso prolongado ao Claude com as permissões que o pipeline executa

Se o seu pipeline CI/CD executar Claude Code com --dangerously-skip-permissions (como muitos para automação), um CLAUDE_CODE_OAUTH_TOKEN roubado concede execução irrestrita de shell em qualquer máquina onde o token seja usado.

Risco: ALTO. Probabilidade média, alto impacto.

O que precisa mudar

Para usuários (agora mesmo)

• Execute o AIHound. Saiba o que está exposto na sua máquina.
• Corrija as permissões: chmod 600 nos arquivos de credenciais.
• Nunca use **--dangerously-skip-permissions** em máquinas com credenciais reais ou acesso à rede. Se precisar, use dentro de um contêiner isolado sem segredos montados.
• Use referências de variáveis de ambiente nas configurações MCP em vez de tokens embutidos:

      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" } 
      

• Rotacionar tokens que estiveram em arquivos legíveis mundialmente ou no histórico do git.
• Desative a sincronização das configurações do VS Code se você usar Cline com servidores MCP.
• Trate **CLAUDE_CODE_OAUTH_TOKEN** como uma senha root. Gire-a regularmente, nunca a coloque nos logs de build e limite as permissões de CI/CD ao mínimo necessário.
• Adicione **.mcp.json** ao **.gitignore** se contiver segredos embutidos.

Para desenvolvedores de ferramentas

• Use os keychains do sistema operacional. macOS Keychain, Windows Credential Manager e Linux libsecret existem exatamente para esse propósito. Nunca armazene credenciais em JSON sem criptografia.
• Crie arquivos com **0600** permissões. Não 0644 ou 0777.
• Avisar os usuários quando detectar segredos embutidos nas configurações do MCP.
• Não sincronize credenciais com a nuvem através dos mecanismos de sincronização de configurações.
• Implemente OAuth 2.1 com validação adequada do público do token para servidores MCP remotos.
• Exigir reautenticação para sessões de Remote Control. Uma URL de sessão não deve ser um token bearer para execução arbitrária de código.
• Auditar pacotes de servidor MCP antes de permitir a instalação e suportar a lista de permissões do servidor.

Para o ecossistema

O OWASP MCP Top 10 lista "Má Gestão de Tokens e Exposição de Segredos" como MCP01-2025. A parceria da Anthropic com o GitHub para detecção automática de chaves API no GitHub é um ótimo começo, mas cobre apenas as chaves Anthropic em repositórios públicos. Tokens MCP para Azure DevOps, Slack, bancos de dados e outros serviços não têm proteção equivalente.

Precisamos de:

• Varredura de segredos que cobre padrões de configuração MCP, não apenas formatos de chave API
• Auxiliares de credenciais para MCP (semelhante aos auxiliares de credenciais do git) que recuperam tokens do armazenamento seguro em tempo de execução
• Integração obrigatória do chaveiro do SO como padrão
• Sandboxing para extensões do VS Code
• Controle Remoto com Escopo de Token - Sessões remotas devem exigir sua própria autenticação, não herdando todas as capacidades da sessão local

A conclusão

O ecossistema de ferramentas de IA avançou rapidamente para lançar funcionalidades e deixou a segurança das credenciais como uma reflexão tardia. Quase metade dos servidores MCP armazenam credenciais em texto simples. Assistentes de IA mantêm tokens OAuth em arquivos JSON no disco. Recursos de Remote Control permitem que esses tokens se tornem execução remota de código. E --dangerously-skip-permissions transforma uma credencial roubada em acesso completo ao shell na máquina de outra pessoa. Quanto mais ferramentas você conecta, maior seu risco. Muitas credenciais de IA não são armazenadas com segurança, então certifique-se de implementar as melhores práticas para o armazenamento de credenciais. Ferramentas como AIHound podem ajudar a encontrar essas credenciais em texto simples em seus sistemas.

Locais de armazenamento de credenciais de aplicativos de desktop AI para referência

Esta referência cataloga todas as localizações onde algumas das aplicações de desktop de IA mais populares, assistentes de codificação e ferramentas CLI armazenam credenciais no disco.

Claude Code CLI

Desenvolvedor: Anthropic Método de autenticação: OAuth 2.0 (assinatura Claude.ai) ou chave de API

Arquivos de credenciais

Credential file structure

      { 
  "claudeAi": { 
    "type": "oauth", 
    "access": "sk-ant-oat01-...", 
    "refresh": "sk-ant-ort01-...", 
    "expires": 1776098433694 
  } 
} 
      

Every OAuth connection stores its own entry. The file contains credentials for Claude.ai, Claude API, Azure Auth, Bedrock Auth, and Vertex Auth depending on what the user has configured.

Key finding: On WSL, the Windows-side credential file inherits the mount's default permissions (0777), making it world-readable, which is a CRITICAL risk that doesn't exist on native Linux where the file is created with 0600.

Configuration files with potential secrets

Authentication precedence order

Claude Code checks credentials in this order (first match wins):

1. Cloud provider env vars (CLAUDE_CODE_USE_BEDROCK, CLAUDE_CODE_USE_VERTEX, CLAUDE_CODE_USE_FOUNDRY)
2. ANTHROPIC_AUTH_TOKEN environment variable
3. ANTHROPIC_API_KEY environment variable
4. apiKeyHelper script output (for dynamic/rotating credentials)
5. CLAUDE_CODE_OAUTH_TOKEN environment variable (long-lived, from claude setup-token)
6. OAuth credentials from ~/.claude/.credentials.json or Keychain

Known bug

A documented bug (GitHub issue #36779) shows that OAuth credentials are not properly persisted to macOS Keychain. Only the mcpOAuth field is stored while the primary auth token is missing, forcing re-authentication in new sessions.

Claude Desktop

Developer: Anthropic

Auth method: Claude.ai session (Keychain-backed on macOS)

Configuration files

MSIX virtualization issue (Windows)

On Windows, the MSIX installer creates filesystem virtualization. The "Edit Config" button opens %APPDATA%\Claude\claude_desktop_config.json, but the application may actually read from a virtualized path inside the MSIX container. This means:

• Users may edit the wrong file
• MCP server configurations are silently ignored
• No error messages indicate the problem

Pre-MSIX installations are grandfathered and read from the real AppData path.

What's in the config

The config file primarily holds MCP server definitions:

      { 
  "mcpServers": { 
    "azure-devops": { 
      "command": "npx", 
      "args": ["-y", "@anthropic/azure-devops-mcp"], 
      "env": { 
        "ADO_MCP_AUTH_TOKEN": "actual-token-here" 
      } 
    } 
  } 
} 
      

The env block frequently contains plaintext tokens for external services.

GitHub Copilot

Developer: GitHub / Microsoft Auth method: GitHub OAuth

Credential storage

VS Code extension storage

The state.vscdb file is a SQLite database encrypted with Electron's safeStorage API (AES-128-CBC). However, security research has shown this is vulnerable to malicious VS Code extensions. Any extension can access other extensions' secrets due to lack of sandboxing.

The encryption key is stored in the OS keychain (Code Safe Storage on macOS), accessible by any process with user permissions.

Token types

GitHub CLI auth (also used by Copilot)

Cursor IDE

Developer: Anysphere Auth method: Cursor account + optional API keys

Storage locations

MCP configuration

~/.cursor/mcp.json, which follows the same mcpServers JSON structure as Claude Desktop. May contain inline auth tokens.

Known issues

Cursor stores conversation logs with world-readable permissions. These logs can contain credentials if users paste tokens into the chat interface.

Continue.dev

Developer: Continue (open source) Auth method: Direct API keys per provider

Configuration files

Credential format

      { 
  "models": [ 
    { 
      "title": "Claude 3.5 Sonnet", 
      "provider": "anthropic", 
      "model": "claude-3-5-sonnet-20241022", 
      "apiKey": "sk-ant-api03-ACTUAL-KEY-HERE" 
    } 
  ] 
} 
      

All API keys are stored in plaintext at the user root. This is acknowledged by the Continue.dev community as a security concern (GitHub issue #1729).

Mitigation

Continue.dev supports environment variable substitution:

      "apiKey": "${CONTINUE_ANTHROPIC_API_KEY}" 
      

It checks .env files at the project root and custom locations specified via envFiles. However, the default behavior is plaintext if env vars aren't configured.

Cline (VS Code extension)

Developer: Saoud Rizwan Extension ID: saoudrizwan.claude-dev

MCP settings (plaintext)

Critical: These files are plaintext JSON and are automatically synced to the cloud through VS Code Settings Sync. This means API keys and MCP credentials get uploaded to GitHub if sync is enabled.

API key storage

Cline stores API keys through VS Code's SecretStorage API (the same AES-128-CBC encrypted state.vscdb used by Copilot). Subject to the same malicious extension vulnerability.

Windsurf / Codeium

Developer: Codeium Auth method: Codeium account

Storage locations

Look for config.json, auth.json, credentials.json within this directory.

MCP configuration

~/.codeium/windsurf/mcp_config.json with the same mcpServers structure.

Credential details are not well-documented publicly. Authentication appears to go through Codeium's centralized backend rather than local token storage in many cases.

ChatGPT Desktop

Developer: OpenAI Auth method: OpenAI account session

Storage locations

ChatGPT Desktop primarily uses OS credential stores (Keychain on macOS, Credential Manager on Windows) for session tokens. JSON config files in the app data directory may also contain session data.

Amazon Q Developer / AWS

Developer: Amazon Web Services Auth method: IAM Identity Center / AWS Builder ID / IAM credentials

Credential files

Credential file structure

      [default] 
aws_access_key_id = AKIAIOSFODNN7EXAMPLE 
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY 
aws_session_token = FwoGZXIvYXdzEBY... 
      

Notes

• Amazon Q itself authenticates through IAM Identity Center or Builder ID, not through local file storage
• Default SSO session duration is 90 days (for setups created after April 2024)
• Static credentials in ~/.aws/credentials are the primary risk. Consider using SSO/IAM Identity Center instead

Google Gemini CLI / GCloud

Developer: Google Auth method: Google account OAuth, API key, or service account

API key storage

Application default credentials (ADC)

ADC files contain client_secret, refresh_token, and potentially private_key (for service accounts) in plaintext JSON.

Authentication methods

OpenClaw

Developer: OpenClaw (open source) Auth method: OAuth 2.0 per provider, API keys, channel-specific tokens

Overview

OpenClaw is a local-first AI agent platform that connects to 20+ messaging channels (WhatsApp, Telegram, Slack, Discord) and executes tools on the local machine. It stores credentials for both LLM providers and messaging channels.

Credential files

Auth profile structure

Each agent has its own auth-profiles.json containing provider credentials:

      { 
  "anthropic": { 
    "accessToken": "sk-ant-...", 
    "refreshToken": "sk-ant-ort01-...", 
    "expiresAt": 1776098433694 
  }, 
  "openai": { 
    "apiKey": "sk-proj-..." 
  } 
} 
      

All tokens are stored in plaintext JSON by default. No OS keychain integration.

SecretRef system (opt-in)

OpenClaw supports an opt-in SecretRef system that replaces plaintext values with references to external sources:

Users must run openclaw secrets configure to scrub existing plaintext values and migrate to SecretRefs. The default behavior is plaintext storage.

Gateway authentication

The gateway uses a token for local access control:

      { 
  "gateway": { 
    "auth": { 
      "mode": "token", 
      "token": "long-random-string-here" 
    } 
  } 
} 
      

This token can be a SecretRef but is commonly hardcoded in openclaw.json.

Known security issues

Credential locations summary

All files live under ~/.openclaw/ on all platforms (Linux, macOS, Windows). On WSL, both Linux-native and Windows-mounted paths should be checked.

MCP server configurations

Config file locations

Common MCP auth environment variables

Environment variables

The following environment variables are commonly set by users or tools and contain AI-related secrets:

Anthropic / Claude

OpenAI

Google

GitHub

AWS

Azure

Other AI providers