Il tuo assistente di codifica AI sta perdendo segreti

Come Claude, Copilot, Cursor e altri strumenti di IA memorizzano le credenziali in testo semplice e 8 esempi di come gli attaccanti le sfruttano

Il problema

Le applicazioni desktop AI devono autenticarsi con servizi esterni. Claude Code necessita dei tuoi token OAuth. GitHub Copilot necessita della tua autenticazione GitHub. Continue.dev necessita delle tue chiavi API. I server MCP necessitano di token per Azure DevOps, Slack, database e tutto il resto che hai collegato. Dove vanno tutte queste credenziali? Principalmente in file JSON in chiaro nella tua directory home. Questi file si trovano in posizioni note o prevedibili, rendendoli facili da trovare con accesso in lettura a un sistema.

Quello che ho trovato

Ho esplorato 14 strumenti di intelligenza artificiale popolari (vedi riferimento alla fine del blog) su Windows, macOS e Linux. Queste sono le cose che mi hanno colpito di più.

Claude Code CLI

~/.claude/.credentials.json contiene i tuoi token di accesso e aggiornamento OAuth in JSON in chiaro:

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

Su Linux, il file viene creato con permessi 0600 (lettura/scrittura solo per il proprietario). Su macOS, le credenziali vengono archiviate nel Keychain. Ma su WSL, il file lato Windows eredita i permessi predefiniti 0777 rendendo i tuoi token OAuth di Claude leggibili da chiunque da qualsiasi processo nel sistema. Il token di aggiornamento è quello davvero pericoloso qui. Ha una lunga durata e può generare nuovi token di accesso indefinitamente. Un attaccante che lo ottiene ha accesso persistente al tuo account Claude finché non lo revoci esplicitamente.

Configurazioni del server MCP: il problema dell'aggregazione

I server Model Context Protocol (MCP) consentono agli assistenti AI di connettersi a strumenti esterni. Ogni connessione necessita di autenticazione, e quei token solitamente finiscono in un singolo file di configurazione come questo:

      { 
  "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" } } 
  } 
} 
      

Un file. Molti servizi. Una singola operazione di lettura può comprometterli tutti. Trend Micro ha scoperto che il 48% delle 19.402 implementazioni di server MCP raccomanda la memorizzazione delle credenziali in testo semplice.

Continue.dev: chiavi API in testo normale

Continue.dev memorizza ogni chiave API configurata direttamente in ~/.continue/config.json:

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

La comunità riconosce questo come un problema (issue GitHub #1729). La sostituzione delle variabili d'ambiente è supportata (${VAR_NAME}) ma non è il comportamento predefinito.

Cline: credenziali sincronizzate nel cloud

Le impostazioni MCP di Cline risiedono in un file JSON non crittografato all'interno del globalStorage di VS Code. Il problema è che VS Code Settings Sync carica automaticamente questo file su GitHub. Se hai abilitato Settings Sync, le tue credenziali MCP sono memorizzate nel cloud di GitHub.

La confusione di VS Code SecretStorage

GitHub Copilot, Cline e altre estensioni di VS Code utilizzano l'API SecretStorage, che cripta i segreti in un database SQLite (state.vscdb) usando AES-128-CBC. Questo sembra sicuro finché non ti rendi conto che:

• Le estensioni di VS Code vengono eseguite senza sandboxing
• La chiave di crittografia si trova nel portachiavi del sistema operativo, accessibile da qualsiasi processo a livello utente
• Qualsiasi estensione dannosa può leggere i segreti di altre estensioni
• Il sistema di identificazione delle estensioni è vulnerabile allo spoofing

La crittografia fornisce protezione contro l'accesso offline al disco, ma non contro nessun processo in esecuzione come lo stesso utente.

Esempi di superficie di attacco

Ho identificato 8 scenari di attacco reali che volevo evidenziare, resi possibili dall'esposizione delle credenziali AI.

1. Furto di credenziali tramite malware

I percorsi dei file sono prevedibili e coerenti tra le installazioni:

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

Il malware Infostealer prende di mira già i cookie del browser, le chiavi SSH e le credenziali cloud. Aggiungere alcune vie di strumenti AI alla lista degli obiettivi è banale. Non è necessaria l'escalation dei privilegi; è sufficiente la lettura di file a livello utente standard.

Una singola infezione da malware potrebbe rivelare i token Claude OAuth, tutte le chiavi API in Continue.dev, ogni token del server MCP e le credenziali AWS. I percorsi sono gli stessi in ogni installazione di ogni strumento.

Rischio: CRITICO. Alta probabilità, alto impatto.

2. Dirottamento di una sessione di controllo remoto Claude Code

Questo è lo scenario che dovrebbe spaventarti. Claude Code ha una funzione di Remote Control (claude remote-control) che consente agli utenti di controllare la loro sessione locale di Claude Code da telefono, tablet o browser tramite claude.ai/code. Tutta l'esecuzione del codice rimane sulla macchina locale. Il dispositivo remoto è solo un'interfaccia di controllo.

Ecco il problema: la connessione remota non richiede la riautenticazione. Una volta che una sessione è attiva, chiunque abbia l'URL della sessione può inviare istruzioni. E tutte queste istruzioni vengono eseguite localmente sulla macchina dello sviluppatore.

Ora combina questo con --dangerously-skip-permissions.

Questa opzione disabilita tutti i prompt interattivi di autorizzazione. Scritture su file, comandi shell, richieste di rete, chiamate agli strumenti MCP, tutto viene eseguito automaticamente senza chiedere all'utente. È pensata per contenitori CI/CD isolati, ma a volte gli utenti la usano sulle loro workstation per comodità. Può anche essere impostata come predefinito persistente in settings.json tramite "defaultMode": "bypassPermissions".

La catena di attacco:

1. L'attaccante ruba i token OAuth da ~/.claude/.credentials.json (tramite malware, SSRF o qualsiasi vulnerabilità di lettura file)
2. I token sono portatili, quindi funzionano da qualsiasi macchina
3. Se la vittima ha una sessione Remote Control attiva, l'attaccante si connette e prende il controllo
4. If the victim runs with --dangerously-skip-permissions, the attacker now has unrestricted shell access as the victim's user:
   • Leggere/scrivere qualsiasi file nel sistema
   • Eseguire comandi arbitrari (curl, ssh, docker, gestori di pacchetti, ecc.)
   • Installare backdoor, esfiltrare dati, pivotare su altre macchine
   • Accedi alle chiavi SSH, alle credenziali cloud e a tutti gli altri segreti del sistema
   • Modifica repository git, pipeline CI/CD e configurazioni di deployment

Anche senza --dangerously-skip-permissions, Claude Code in acceptEdits modalità approva automaticamente le modifiche ai file e i comandi comuni del filesystem. Questo può comunque essere pericoloso. Il modello di permessi è stato progettato per proteggere da azioni accidentali, non da un attore malintenzionato che controlla la sessione.

Rischio: CRITICO (con --dangerously-skip-permissions), ALTO (permessi predefiniti).

3. Movimento laterale tramite token Claude OAuth

Un attaccante che ottiene un token di aggiornamento OAuth di Claude da ~/.claude/.credentials.json può:

1. Genera nuovi token di accesso da remoto (i token di accesso scadono in circa 60 minuti, ma il token di aggiornamento ha una lunga durata)
2. Accedi alle conversazioni Claude e ai file dello spazio di lavoro della vittima
3. Usa qualsiasi server MCP che la vittima ha configurato (accedendo ai loro repository GitHub, progetti Azure DevOps, spazi di lavoro Slack e database tramite l'assistente AI come proxy)

I token sono portatili. Copia il file delle credenziali su un altro computer e Claude Code lo utilizzerà. Anthropic implementa la rotazione dei token di aggiornamento, quindi l’uso di un token rubato potrebbe invalidare quello originale, ma l’uso iniziale ha successo e l’attaccante potrebbe ottenere accesso prima che la rotazione abbia effetto.

Rischio: ALTO. Probabilità medio-alta, alto impatto.

4. Aggregazione del token MCP: movimento laterale

Un singolo file di configurazione MCP aggrega token per molteplici servizi esterni. Per esempio, un file potrebbe fornire:

• GITHUB_PERSONAL_ACCESS_TOKEN → repository di codice, PR, CI/CD
• ADO_MCP_AUTH_TOKEN → progetti Azure DevOps
• SLACK_BOT_TOKEN → workspace Slack interno
• Password del database → dati di produzione
• JIRA_API_TOKEN → gestione del progetto, ticket interni

A differenza dell'archiviazione distribuita delle credenziali, dove compromettere un canale espone solo un sottoinsieme di credenziali, il modello di aggregazione di MCP significa che la divulgazione di un singolo file provoca una cascata che compromette tutti i servizi connessi.

Rischio: CRITICO. Alta probabilità, alto impatto.

5. Estensione dannosa di VS Code: esfiltrazione delle credenziali

Le estensioni di VS Code vengono eseguite senza sandboxing. Tutte le estensioni condividono le stesse autorizzazioni di processo. Un'estensione dannosa o compromessa può:

1. Accedi al database SQLite state.vscdb direttamente
2. Recupera la chiave di crittografia dal portachiavi del sistema operativo (accessibile da qualsiasi processo a livello utente)
3. Decrittografa tutti i segreti dell'estensione: token Copilot, chiavi API Cline, credenziali MCP

Il file cline_mcp_settings.json non necessita nemmeno di decrittazione. È testo in chiaro non crittografato in globalStorage di VS Code e viene sincronizzato nel cloud tramite Settings Sync.

I campi publisher e name di package.json che identificano le estensioni sono vulnerabili al spoofing, rendendo possibile impersonare estensioni legittime.

Rischio: ALTO. Probabilità media, alto impatto.

6. Escalation dei permessi WSL

Gli sviluppatori che usano WSL vengono colpiti da entrambi i lati. Gli strumenti AI installati su Windows memorizzano le credenziali in C:\Users\<you>\, che viene montato in WSL come /mnt/c/Users/<you>/ con permessi 0777 per impostazione predefinita. Lo stesso file di credenziali protetto da NTFS sul lato Windows è leggibile da tutti dal lato Linux.

In ambienti WSL multiutente o container compromessi, questo è facile da sfruttare. Qualsiasi processo in esecuzione sul sistema WSL può leggere token Claude OAuth, configurazioni MCP, ecc., memorizzati sul lato Windows.

Rischio: ALTO per gli utenti WSL. Alta probabilità, impatto medio-alto.

7. .mcp.json inviato a git: cresfiltrazione delle credenziali

Il file .mcp.json nella radice del repository è progettato per essere versionato in modo che i team possano condividere le configurazioni del server MCP. Se uno sviluppatore include token inline invece di riferimenti a variabili d'ambiente:

1. I token appaiono nella cronologia di git
2. Anche dopo la rimozione, git log -p .mcp.json li rivela
3. Gli scanner automatici (TruffleHog, GitLeaks, ecc.) possono trovarli su larga scala su GitHub/GitLab

La partnership di scansione segreta tra Anthropic e GitHub rileva alcune chiavi API esposte, ma i token di configurazione MCP per altri servizi (Azure DevOps, Slack, database) non sono coperti dalla scansione automatizzata. Non esiste un pattern di scanner segreto GitHub per ADO_MCP_AUTH_TOKEN o SLACK_BOT_TOKEN incorporati nei blocchi JSON env.

Rischio: MEDIO. Probabilità media, impatto medio-alto.

8. Attacco alla catena di approvvigionamento tramite server MCP

I server MCP sono spesso pacchetti npm. Il rischio della catena di fornitura è lo stesso di qualsiasi dipendenza npm, ma con una differenza critica: I server MCP ricevono le credenziali all'avvio.

1. Il popolare pacchetto server MCP su npm è compromesso (o è stato pubblicato un typosquat)
2. Gli utenti lo configurano nel loro claude_desktop_config.json con token reali nel env blocco
3. Il processo del server MCP ha accesso a tutte le variabili di ambiente passate, inclusi i token
4. Server compromesso esfiltra token all'infrastruttura dell'attaccante

Senza una corretta convalida del pubblico OAuth 2.1 (RFC 8707), un server MCP dannoso potrebbe anche ricevere token di accesso e riprodurli contro altri servizi (attacco di passaggio del token).

La statistica del 48% delle credenziali in testo semplice significa che quasi la metà di tutte le configurazioni dei server MCP consegna le credenziali direttamente al processo del server all'avvio. Se quel processo del server viene compromesso, anche ogni utente che lo ha installato è compromesso.

Rischio: MEDIO. Probabilità da bassa a media, alto impatto.

Bonus: furto del token CI/CD

Il comando claude setup-token genera un token OAuth di un anno (CLAUDE_CODE_OAUTH_TOKEN) per pipeline CI/CD. Questo crea un rischio unico:

• Il token funziona da qualsiasi macchina per un massimo di un anno
• I sistemi CI/CD spesso hanno una gestione debole dei segreti e un isolamento limitato dei lavori
• I log di build possono accidentalmente esporre i valori delle variabili di ambiente
• Un runner CI/CD compromesso concede accesso a lungo termine a Claude con qualunque permesso esegua la pipeline

Se la tua pipeline CI/CD esegue Claude Code con --dangerously-skip-permissions (come molti per l'automazione), un CLAUDE_CODE_OAUTH_TOKEN rubato concede l'esecuzione illimitata della shell su qualsiasi macchina in cui viene utilizzato il token.

Rischio: ALTO. Probabilità media, alto impatto.

Cosa deve cambiare

Per gli utenti (in questo momento)

• Esegui AIHound. Scopri cosa è esposto sulla tua macchina.
• Correggi i permessi: chmod 600 sui file delle credenziali.
• Non usare mai **--dangerously-skip-permissions** su macchine con credenziali reali o accesso alla rete. Se ne hai bisogno, usalo all'interno di un contenitore isolato senza segreti montati.
• Usa riferimenti a variabili d'ambiente nelle configurazioni MCP invece di token inline:

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

• Ruotare i token che sono stati in file leggibili da tutti o nella cronologia git.
• Disabilita la sincronizzazione delle impostazioni di VS Code se usi Cline con server MCP.
• Tratta **CLAUDE_CODE_OAUTH_TOKEN** come una password root. Ruotala regolarmente, non inserirla mai nei log di build e limita i permessi CI/CD al minimo necessario.
• Aggiungi **.mcp.json** a **.gitignore** se contiene segreti inline.

Per sviluppatori di strumenti

• Usa i portachiavi del sistema operativo. macOS Keychain, Windows Credential Manager e Linux libsecret esistono proprio per questo scopo. Non memorizzare mai le credenziali in JSON in chiaro.
• Crea file con **0600** permessi. Non 0644 o 0777.
• Avvisa gli utenti quando rilevi segreti inline nelle configurazioni MCP.
• Non sincronizzare le credenziali sul cloud tramite i meccanismi di sincronizzazione delle impostazioni.
• Implementa OAuth 2.1 con una corretta convalida del pubblico del token per i server MCP remoti.
• Richiedi la riautenticazione per le sessioni di Remote Control. Un URL di sessione non dovrebbe essere un token bearer per l'esecuzione arbitraria di codice.
• Verificare i pacchetti del server MCP prima di consentire l’installazione e supportare la lista consentita del server.

Per l'ecosistema

L'OWASP MCP Top 10 elenca "Gestione errata dei token ed esposizione dei segreti" come MCP01-2025. La partnership tra Anthropic e GitHub per il rilevamento automatico delle chiavi API su GitHub è un ottimo inizio, ma copre solo le chiavi Anthropic nei repository pubblici. I token MCP per Azure DevOps, Slack, database e altri servizi non hanno una protezione equivalente.

Abbiamo bisogno di:

• Scansione dei segreti che copre i modelli di configurazione MCP, non solo i formati delle chiavi API
• Helper per le credenziali per MCP (simile agli helper per le credenziali di git) che recuperano i token dall'archiviazione sicura in fase di esecuzione
• Integrazione obbligatoria del portachiavi OS come predefinito
• Sandboxing per estensioni VS Code
• Controllo remoto con ambito token - Le sessioni remote devono richiedere una propria autenticazione, senza ereditare tutte le capacità della sessione locale

La conclusione

L'ecosistema degli strumenti di AI si è mosso rapidamente per rilasciare funzionalità e ha lasciato la sicurezza delle credenziali un po' in secondo piano. Quasi la metà dei server MCP memorizza le credenziali in testo semplice. Gli assistenti AI conservano i token OAuth in file JSON su disco. Le funzionalità di Remote Control permettono a quei token di diventare esecuzione remota di codice. E --dangerously-skip-permissions trasforma una credenziale rubata in accesso shell completo sulla macchina di qualcun altro. Più strumenti colleghi, maggiore diventa il rischio. Molte credenziali AI non sono memorizzate in modo sicuro, quindi assicurati di implementare le migliori pratiche per l'archiviazione delle credenziali. Strumenti come AIHound possono aiutarti a trovare queste credenziali in testo semplice nei tuoi sistemi.

Posizioni di archiviazione delle credenziali delle applicazioni desktop AI per riferimento

Questo riferimento cataloga ogni posizione in cui alcune delle applicazioni desktop AI più popolari, assistenti di codifica e strumenti CLI memorizzano le credenziali sul disco.

Claude Code CLI

Sviluppatore: Anthropic Metodo di autenticazione: OAuth 2.0 (abbonamento Claude.ai) o chiave API

File di credenziali

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