Claude Code को आपके सीक्रेट्स लीक करने से रोकने वाला .env सेटअप (पूर्ण कॉन्फ़िगरेशन शामिल)

Claude Code आपके प्रोजेक्ट को खोलते ही आपकी .env फ़ाइलों को पढ़ लेता है।

आपकी API कुंजियाँ, डेटाबेस पासवर्ड, Stripe टोकन, .env फ़ाइल में सब कुछ मेमोरी में लोड हो जाता है और Anthropic के सर्वर पर भेजे गए कन्वर्सेशन लॉग में समाप्त हो सकता है।

एकमात्र चीज़ जो वास्तव में एक्सेस को ब्लॉक करती है, वह settings.json में एक लाइन है, जिसके बारे में ज़्यादातर लोगों को पता नहीं है और वे इसका उपयोग नहीं करते।

यह रहा पूरा सुरक्षा कॉन्फ़िग 👇

इसमें गोता लगाने से पहले, मैं अपने Telegram चैनल पर AI और वाइब कोडिंग पर दैनिक नोट्स साझा करता हूँ: **https://t.me/zodchixquant** 🧠

CLAUDE.md नियम आपकी रक्षा क्यों नहीं करते

ज़्यादातर लोग अपने CLAUDE.md में ".env फ़ाइलें कभी न पढ़ें" जोड़ते हैं और मान लेते हैं कि वे सुरक्षित हैं (वे नहीं हैं)

CLAUDE.md एक सुझाव है। Claude ज़्यादातर समय इसका पालन करता है, लेकिन दबाव में (जटिल कार्य, लंबा संदर्भ, अस्पष्ट निर्देश) यह सलाहकार नियमों को अनदेखा कर सकता है और करता भी है।

अप्रैल 2026 के एक GitHub मुद्दे ने पुष्टि की: Claude .env सामग्री को पढ़ता है और कन्वर्सेशन में प्रतिध्वनित करता है, भले ही CLAUDE.md स्पष्ट रूप से इसे प्रतिबंधित करता हो।

एकमात्र विश्वसनीय सुरक्षा settings.json में एक डिनाय नियम है। डिनाय नियम सिस्टम स्तर पर लागू किए जाते हैं, इससे पहले कि Claude फ़ाइल को देखे भी।

"कृपया इसे न पढ़ें" और "आप शारीरिक रूप से इसे नहीं पढ़ सकते" के बीच का अंतर।

आपके रहस्य लीक होने के 3 तरीके

यह सिर्फ़ Claude द्वारा सीधे .env पढ़ने के बारे में नहीं है। तीन रास्ते हैं:

1. सीधी फ़ाइल पढ़ना। Claude आपके प्रोजेक्ट को स्कैन करता है, .env खोलता है, और सामग्री कन्वर्सेशन संदर्भ का हिस्सा बन जाती है। यह स्पष्ट है और डिनाय नियमों से रोकना सबसे आसान है।

2. रनटाइम आउटपुट कैप्चर। Claude आपके टेस्ट चलाता है या आपका ऐप शुरू करता है। एक असफल HTTP अनुरोध पूरा Authorization: Bearer sk-live-abc123... हेडर लॉग करता है। एक डेटाबेस टाइमआउट पासवर्ड के साथ कनेक्शन स्ट्रिंग डंप करता है। Claude सभी कमांड आउटपुट कैप्चर करता है। आपके रहस्य अब कन्वर्सेशन में हैं, भले ही Claude ने कभी .env नहीं खोला हो।

3. Grep और खोज उपकरण। Claude आपके कोडबेस में किसी फ़ंक्शन नाम की खोज करने के लिए grep का उपयोग करता है। खोज क्रेडेंशियल वाली एक कॉन्फ़िग फ़ाइल पर पहुँचती है। grep आउटपुट में आपके रहस्यों के साथ मेल खाने वाली पंक्तियाँ शामिल होती हैं।

ज़्यादातर लोग केवल रास्ता 1 से सुरक्षा करते हैं। रास्ता 2 और 3 वह जगह हैं जहाँ वास्तविक नुकसान होता है।

डिनाय नियम जो वास्तव में काम करते हैं

इन्हें हर प्रोजेक्ट के लिए वैश्विक सुरक्षा के लिए ~/.claude/settings.json में जोड़ें:

json

1{
2  "permissions": {
3    "deny": [
4      "Read(**/.env*)",
5      "Read(**/.dev.vars*)",
6      "Read(**/*.pem)",
7      "Read(**/*.key)",
8      "Read(**/secrets/**)",
9      "Read(**/credentials/**)",
10      "Read(**/.aws/**)",
11      "Read(**/.ssh/**)",
12      "Read(**/config/database.yml)",
13      "Read(**/config/credentials.json)",
14      "Read(**/.npmrc)",
15      "Read(**/.pypirc)",
16      "Write(**/.env*)",
17      "Write(**/secrets/**)",
18      "Write(**/.ssh/**)"
19    ]
20  }
21}

यह Claude को किसी भी .env फ़ाइल, PEM कुंजियाँ, SSH कुंजियाँ, AWS कॉन्फ़िग, क्रेडेंशियल फ़ाइलें, और npm/PyPI टोकन पढ़ने या लिखने से रोकता है। ** वाइल्डकार्ड का मतलब है कि यह आपके प्रोजेक्ट के हर उपनिर्देशिका पर लागू होता है।

रनटाइम लीक को रोकना

डिनाय नियम सीधे फ़ाइल पढ़ने को रोकते हैं लेकिन रनटाइम आउटपुट को नहीं। इसके लिए, डमी मानों वाली टेस्ट-विशिष्ट .env फ़ाइलों का उपयोग करें:

1# .env.test — पढ़ने के लिए सुरक्षित, लीक होने पर सुरक्षित
2STRIPE_SECRET_KEY=sk_test_not_a_real_key
3DATABASE_URL=postgres://test:test@localhost:5432/testdb
4OPENAI_API_KEY=sk-test-dummy-key-for-mocking
5AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
6AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

अपने टेस्ट फ्रेमवर्क को .env के बजाय .env.test पर इंगित करें। अब जब Claude आपके टेस्ट चलाता है और आउटपुट कैप्चर करता है, तो दिखाई देने वाली एकमात्र कुंजियाँ डमी हैं।

प्री-कमिट हुक जो सब कुछ पकड़ता है

डिनाय नियमों के बावजूद, गलतियाँ होती हैं। एक git प्री-कमिट हुक जोड़ें जो किसी भी कमिट के आपके रिपो तक पहुँचने से पहले रहस्यों को स्कैन करता है:

bash

1#!/bin/bash
2# .git/hooks/pre-commit — रहस्यों वाले कमिट को ब्लॉक करता है
3
4PATTERNS=(
5  'sk-ant-'           # Anthropic API कुंजियाँ
6  'sk-live-'          # Stripe लाइव कुंजियाँ
7  'sk_live_'          # Stripe लाइव कुंजियाँ (वैकल्पिक प्रारूप)
8  'ghp_'              # GitHub व्यक्तिगत टोकन
9  'gho_'              # GitHub OAuth टोकन
10  'AKIA'              # AWS एक्सेस कुंजियाँ
11  'xox[bpors]-'       # Slack टोकन
12  'SG\.'              # SendGrid कुंजियाँ
13  'eyJ'               # JWT
14  'BEGIN.*PRIVATE KEY' # निजी कुंजी सामग्री
15)
16
17BLOCKED_FILES=('.env' 'credentials.json' 'id_rsa' '*.pem' '*.key')
18
19for pattern in "${PATTERNS[@]}"; do
20  if git diff --cached --diff-filter=ACM | grep -qE "$pattern"; then
21    echo "अवरुद्ध: '$pattern' से मेल खाने वाला संभावित रहस्य मिला"
22    echo "रहस्य हटाएँ और पुनः प्रयास करें।"
23    exit 1
24  fi
25done
26
27for file in "${BLOCKED_FILES[@]}"; do
28  if git diff --cached --name-only | grep -q "$file"; then
29    echo "अवरुद्ध: संवेदनशील फ़ाइल को कमिट करने का प्रयास: $file"
30    exit 1
31  fi
32done
33
34echo "प्री-कमिट सुरक्षा जाँच पास हुई।"
35exit 0

इसे निष्पादन योग्य बनाएँ: chmod +x .git/hooks/pre-commit

यह Anthropic API कुंजियाँ, Stripe कुंजियाँ, GitHub टोकन, AWS कुंजियाँ, Slack टोकन, SendGrid कुंजियाँ, JWT और निजी कुंजी सामग्री को पकड़ता है। यदि इनमें से कोई भी स्टेज की गई फ़ाइल में दिखाई देता है, तो कमिट अवरुद्ध हो जाता है।

कंटेनर आइसोलेशन (परमाणु विकल्प)

अधिकतम सुरक्षा के लिए, Claude Code को एक कंटेनर के अंदर चलाएँ जहाँ .env फ़ाइलें सचमुच मौजूद न हों:

bash

1# .env पर /dev/null माउंट करें ताकि Claude इसे न देख सके
2docker run -v /dev/null:/app/.env:ro your-dev-container

Claude के दृष्टिकोण से, .env एक खाली फ़ाइल है। आपके रहस्य कभी भी कंटेनर फ़ाइलसिस्टम में प्रवेश नहीं करते। यह अधिकांश प्रोजेक्ट के लिए अत्यधिक है, लेकिन प्रोडक्शन क्रेडेंशियल वाले क्लाइंट कार्य के लिए आवश्यक है।

पूर्ण सुरक्षा कॉन्फ़िग (कॉपी-पेस्ट के लिए तैयार)

सभी सुरक्षा सुरक्षा के साथ पूर्ण ~/.claude/settings.json:

json

1{
2  "permissions": {
3    "allow": [
4      "Read",
5      "Glob",
6      "Grep",
7      "LS",
8      "Edit",
9      "MultiEdit",
10      "Write(src/**)",
11      "Write(tests/**)",
12      "Bash(npm run *)",
13      "Bash(npm test *)",
14      "Bash(npx tsc *)",
15      "Bash(git status)",
16      "Bash(git diff *)",
17      "Bash(git log *)",
18      "Bash(git add *)",
19      "Bash(git commit *)"
20    ],
21    "deny": [
22      "Read(**/.env*)",
23      "Read(**/.dev.vars*)",
24      "Read(**/*.pem)",
25      "Read(**/*.key)",
26      "Read(**/secrets/**)",
27      "Read(**/credentials/**)",
28      "Read(**/.aws/**)",
29      "Read(**/.ssh/**)",
30      "Read(**/config/database.yml)",
31      "Read(**/config/credentials.json)",
32      "Read(**/.npmrc)",
33      "Read(**/.pypirc)",
34      "Write(**/.env*)",
35      "Write(**/secrets/**)",
36      "Write(**/.ssh/**)",
37      "Write(.github/workflows/*)",
38      "Bash(rm -rf *)",
39      "Bash(sudo *)",
40      "Bash(git push *)",
41      "Bash(npm publish *)",
42      "Bash(curl * | sh)",
43      "Bash(wget *)",
44      "Bash(chmod *)"
45    ],
46    "defaultMode": "acceptEdits"
47  }
48}

यह मेरे पिछले लेख का settings.json है और इस लेख का हर सुरक्षा नियम है। दैनिक वर्कफ़्लो के लिए अनुमति नियम, रहस्यों और खतरनाक संचालन के लिए डिनाय नियम। एक फ़ाइल, पूर्ण सुरक्षा।

चेकलिस्ट

अपने अगले Claude Code सत्र से पहले:

1. क्या आपके पास settings.json में .env फ़ाइलों के लिए डिनाय नियम हैं?

1. क्या आपके टेस्ट डमी मानों के साथ .env.test का उपयोग करते हैं?

1. क्या रहस्य पैटर्न को स्कैन करने वाला कोई प्री-कमिट हुक है?

1. क्या प्रोडक्शन क्रेडेंशियल एक वॉल्ट में संग्रहीत हैं, सादे टेक्स्ट फ़ाइलों में नहीं?

1. क्या .env आपके .gitignore में है?

1. क्या अतिरिक्त सुरक्षा के लिए .env फ़ाइलें आपकी प्रोजेक्ट निर्देशिका के बाहर हैं?

यदि आपने सभी 6 की जाँच की, तो आपके रहस्य यथासंभव सुरक्षित हैं। यदि आपने 0 की जाँच की, तो आप एक अस्पष्ट Claude प्रॉम्प्ट से दूर हैं जहाँ आपकी API कुंजियाँ Anthropic के सर्वर पर एक कन्वर्सेशन लॉग में दिखाई देंगी।

मैं अपने Telegram चैनल पर AI, वित्त और वाइब कोडिंग पर दैनिक नोट्स साझा करता हूँ: **https://t.me/zodchixquant**

पढ़ने के लिए धन्यवाद 🙏🏼