വിശ്രമവേളയിൽ ഒരു ഉയർന്ന പ്രിവിലേജ് API കീ എൻക്രിപ്റ്റ് ചെയ്യുക: AI ട്രാൻസ്ക്രിപ്റ്റുകളിൽ നിന്ന് രഹസ്യങ്ങൾ സൂക്ഷിക്കുന്ന ഒരു GPG വോൾട്ട്

മിക്ക ക്രെഡൻഷ്യൽ ചോർച്ചകളും നാടകീയമല്ല. ഹാക്കർ ഇല്ല, ബ്രീച്ച് റിപ്പോർട്ട് ഇല്ല. ആരെങ്കിലും അവരുടെ ഹോം ഡയറക്ടറിയിലെ പ്ലെയിൻ ടെക്സ്റ്റ് ഫയലിൽ ഒരു അക്കൗണ്ട് വൈഡ് API കീ സൂക്ഷിക്കുന്നു, ഒരു ദിവസം ഒരു ബാക്കപ്പ്, ഒരു സ്ക്രീൻ-ഷെയർ, ഒട്ടിച്ച കമാൻഡ് അല്ലെങ്കിൽ ഒരു AI കോഡിംഗ് സെഷൻ അത് നിശബ്ദമായി ഒരിക്കലും പോകാൻ പാടില്ലാത്ത എവിടെയെങ്കിലും കൊണ്ടുപോകുന്നു.

2026 ഓഗസ്റ്റ് മുതൽ, അവസാനത്തെ വെക്റ്ററാണ് ഗണിതത്തെ മാറ്റിയത്. മിക്കവാറും എല്ലാ ഡെവലപ്പർമാരും ഇപ്പോൾ അവർക്ക് വേണ്ടി ഫയലുകൾ വായിക്കുകയും കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്ന ഒരു AI കോഡിംഗ് അസിസ്റ്റൻ്റ് പ്രവർത്തിപ്പിക്കുന്നു. അത്തരമൊരു ഉപകരണം വായിക്കുന്നതെല്ലാം, ഒരു കമാൻഡ് പ്രിൻ്റ് ചെയ്യുന്നതെല്ലാം, ഓരോ ഊഴത്തിലും മോഡൽ പ്രൊവൈഡർക്ക് കൈമാറുന്ന ഒരു സെഷൻ ട്രാൻസ്ക്രിപ്റ്റിൻ്റെ ഭാഗമാകുന്നു. ഒരു പ്ലെയിൻടെക്സ്റ്റ് കീ എപ്പോഴെങ്കിലും പ്രദർശിപ്പിക്കുകയോ സ്‌ക്രീനിലേക്ക് ഡീക്രിപ്റ്റ് ചെയ്യുകയോ സെഷനിൽ പ്രതിധ്വനിക്കുകയോ ചെയ്താൽ, അത് ഇപ്പോൾ നിങ്ങളുടെ നിയന്ത്രണത്തിന് പുറത്ത് ആ ട്രാൻസ്‌ക്രിപ്റ്റിൽ ഇരിക്കുന്നു. ഇത് സാങ്കൽപ്പികമല്ല: തികച്ചും ശ്രദ്ധാലുവായ ഒരു എഞ്ചിനീയർക്ക് സ്പഷ്ടമായി തെറ്റൊന്നും ചെയ്യാതെ ഒരു താക്കോൽ ചോർത്താൻ കഴിയുന്നത് ഇങ്ങനെയാണ്.

ഇത് പരിഹരിക്കുന്നതിനുള്ള പൂർണ്ണവും പൊതുവായതുമായ ഒരു റൺബുക്കാണ് ഈ പോസ്റ്റ്. Cloudflare Global API Key ആണ് ഉദാഹരണം, എന്നാൽ ഉയർന്ന പ്രത്യേകാവകാശമുള്ള ഏത് ക്രെഡൻഷ്യലിനും ഈ സാങ്കേതികവിദ്യ ബാധകമാണ്. ഒന്നാം ഭാഗം ഉപയോഗിക്കുന്നത് gpg കൂടാതെ bash മാത്രമാണ്, മാത്രമല്ല ഏത് Linux അല്ലെങ്കിൽ macOS മെഷീനിലും പ്രവർത്തിക്കുന്നു. ഒരു AI കോഡിംഗ് അസിസ്റ്റൻ്റ് ഉപയോഗിക്കുന്നവർക്കും അതിനുമുകളിൽ കർശനമായ കാവൽ ആഗ്രഹിക്കുന്നവർക്കും മാത്രമുള്ളതാണ് രണ്ടാം ഭാഗം.

എന്തുകൊണ്ട് ഒരു അക്കൗണ്ട് വൈഡ് കീ പ്രത്യേക പരിഗണന അർഹിക്കുന്നു

ഒരു Cloudflare Global API Key അക്കൗണ്ട് വ്യാപകവും അൺസ്കോപ്പ് ചെയ്തതുമാണ്. ആ ഇമെയിലുമായി ബന്ധിപ്പിച്ചിട്ടുള്ള എല്ലാ അക്കൗണ്ടിലെയും എല്ലാ സോണിലും വർക്കറിലും DNS റെക്കോർഡിലും ഇതിന് സ്പർശിക്കാനാകും. ഇത് രണ്ട് വ്യത്യസ്ത അപകടസാധ്യതകൾ സൃഷ്ടിക്കുന്നു:

• വിശ്രമവേളയിൽ. നിങ്ങളുടെ ഫയൽസിസ്റ്റത്തെ സ്പർശിക്കുന്ന ഏത് പ്രോസസ്സിനോ സ്ക്രിപ്റ്റിനോ ബാക്കപ്പിനോ ഒരു ഹോം-ഡയറക്ടറി ഫയലിലെ പ്ലെയിൻടെക്സ്റ്റ് കീ വായിക്കാൻ കഴിയും. ഇത് അശ്രദ്ധമായ ഒരു chmodആണ്, വിശാലമായ ഒരു ബാക്കപ്പ് ജോലിയാണ്, എക്സ്പോഷറിൽ നിന്ന് കടമെടുത്ത ഒരു ലാപ്ടോപ്പാണ്.
• ഒരു AI സെഷനിൽ. ഒരു കോഡിംഗ് അസിസ്റ്റൻ്റ് വായിക്കുന്ന എന്തിനും അല്ലെങ്കിൽ കീ പ്രിൻ്റ് ചെയ്യുന്ന ഏതെങ്കിലും കമാൻഡിനും, പ്രൊവൈഡർക്ക് അയച്ച ട്രാൻസ്ക്രിപ്റ്റിൽ ഇടം ലഭിക്കും. cat ~/.cf, echo $CLOUDFLARE_API_KEY, അല്ലെങ്കിൽ സ്ക്രീനിലേക്ക് ഡമ്പ് ചെയ്യുന്ന ഒരു gpg --decrypt എല്ലാം തൽക്ഷണം ചോർത്തുന്നു.

പരിഹാരത്തിന് മൂന്ന് ഭാഗങ്ങളുണ്ട്: കീ വിശ്രമവേളയിൽ എൻക്രിപ്റ്റ് ചെയ്ത്സൂക്ഷിക്കുക, അത് ഡീക്രിപ്റ്റ് ചെയ്യുക ഒരിക്കലും പ്രിൻ്റ് ചെയ്യാത്ത ഒരു ഹ്രസ്വകാല സബ്പ്രോസസിനുള്ളിൽ മാത്രം, കൂടാതെ — ലൂപ്പിൽ ഒരു AI അസിസ്റ്റൻ്റ് ഉണ്ടെങ്കിൽ — ഒരു കോഡ് എൻഫോഴ്സ് ചെയ്ത ഹാർഡ് ബ്ലോക്ക്ചേർക്കുക, ശ്രദ്ധിക്കണമെന്ന് ഓർത്തുകൊണ്ടല്ല.

നിങ്ങൾ ആരംഭിക്കുന്നതിന് മുമ്പുള്ള ഒരു കുറിപ്പ്: നിങ്ങൾ ഉപയോഗിക്കുന്ന ടൂൾ ഗ്ലോബൽ API കീക്ക് പകരം ഒരു സ്കോപ്പ്ഡ് API ടോക്കൺ പിന്തുണയ്ക്കുന്നുവെങ്കിൽ, ടോക്കൺ ഉപയോഗിക്കുക. ഒരു ടോക്കൺ വ്യക്തിഗതമായി പിൻവലിക്കാൻ കഴിയും, മാത്രമല്ല അതിന് നിയുക്ത സ്കോപ്പിന് പുറത്തുള്ള എന്തിലും എത്തിച്ചേരാനാകില്ല, അതിനാൽ ചോർച്ചയുടെ ബ്ലാസ്റ്റ് റേഡിയസ് ഗ്ലോബൽ കീയുടെ ഒരു ഭാഗമാണ്. താഴെ പറയുന്ന ഘട്ടങ്ങൾ ഒരു ടോക്കണിനും തുല്യമായി ബാധകമാണ്; ഒരു ഇമെയിൽ പ്ലസ് കീ ജോഡിക്ക് പകരം നിങ്ങൾ ഒരൊറ്റ ടോക്കൺ മൂല്യം സൂക്ഷിക്കുന്നു.

ഘട്ടം 1: ക്രെഡൻഷ്യൽ വീണ്ടെടുക്കുകയും കർശനമായ അനുമതികളോടെ അത് സ്റ്റേജ് ചെയ്യുകയും ചെയ്യുക

നിങ്ങളുടെ പ്രൊവൈഡറുടെ ഡാഷ്‌ബോർഡിൽ നിന്ന് കീ നേടുക. ക്ലൗഡ്‌ഫ്ലെയറിന്, അത് എൻ്റെ പ്രൊഫൈൽ, തുടർന്ന് API ടോക്കണുകൾ ടാബ്, തുടർന്ന് ഗ്ലോബൽ API കീയുടെ അടുത്തുള്ള വ്യൂ.

ഒരു പ്രോജക്റ്റ് ഡയറക്‌ടറിയിലെ ഒരു സ്റ്റേജിംഗ് ഫയലിലേക്ക് അത് എഴുതുക, ആദ്യത്തെ ബൈറ്റിൽ നിന്ന് ലോക്ക്-ഡൗൺ ചെയ്ത് സൃഷ്ടിക്കുക:

mkdir -p ~/vault
umask 077                 # new files are created 600, never world-readable
printf '%s\n' "[email protected] REPLACE_WITH_GLOBAL_API_KEY main-account" > ~/vault/.cf
chmod 600 ~/vault/.cf

ദി umask 077 കാര്യങ്ങൾ: പ്ലെയിൻടെക്‌സ്‌റ്റ് സൃഷ്ടിക്കുന്ന സമയത്ത് മറ്റ് ഉപയോക്താക്കൾക്ക് വായിക്കാനാവില്ലെന്ന് ഇത് ഉറപ്പ് നൽകുന്നു, അത് പിന്നീട് റദ്ദാക്കാൻ കഴിയില്ല ഒരു chmod .

ഘട്ടം 2: GPG സിമ്മട്രിക് AES-256 ഉപയോഗിച്ച് ഇത് എൻക്രിപ്റ്റ് ചെയ്യുക

സിമ്മട്രിക്, പാസ്‌ഫ്രെയ്‌സ് അടിസ്ഥാനമാക്കിയുള്ള എൻക്രിപ്ഷനാണ് ഇവിടെ ശരിയായ തിരഞ്ഞെടുപ്പ്. ഒരാൾക്ക് മാത്രമേ ഈ ഫയൽ ഡീക്രിപ്റ്റ് ചെയ്യേണ്ടതുള്ളൂ, അതിനാൽ പബ്ലിക്/പ്രൈവറ്റ് കീപെയർ യാതൊരു പ്രയോജനവുമില്ലാതെ സങ്കീർണ്ണത വർദ്ധിപ്പിക്കും.

gpg --symmetric --cipher-algo AES256 -o ~/vault/.cf.gpg ~/vault/.cf

ഒരു പാസ്‌ഫ്രെയ്‌സ് നൽകാനും സ്ഥിരീകരിക്കാനും GPG നിങ്ങളോട് ആവശ്യപ്പെടുന്നു. ശക്തവും അതുല്യവുമായ എന്തെങ്കിലും തിരഞ്ഞെടുത്ത് ഒരു പാസ്‌വേഡ് മാനേജറിൽ റെക്കോർഡ് ചെയ്യുക, കാരണം നിങ്ങൾ അത് മറന്നാൽ വീണ്ടെടുക്കൽ സാധ്യമല്ല. ഈ ഘട്ടത്തിൽ നിന്ന്, ഫയൽസിസ്റ്റം ആക്‌സസിനും കീയ്ക്കും ഇടയിൽ നിൽക്കുന്ന ഒരേയൊരു കാര്യം ആ പാസ്‌ഫ്രെയ്‌സ് ആണ്.

ഘട്ടം 3: ഒന്നും ഇല്ലാതാക്കുന്നതിന് മുമ്പ് എൻക്രിപ്റ്റ് ചെയ്ത പകർപ്പ് പരിശോധിക്കുക

സൈഫർടെക്‌സ്റ്റ് ഡീക്രിപ്റ്റ് ചെയ്യുന്നത് ബൈറ്റ്-ഫോർ-ബൈറ്റാണെന്ന് തെളിയിക്കുന്നതുവരെ പ്ലെയിൻടെക്‌സ്റ്റ് ഒരിക്കലും ഇല്ലാതാക്കരുത്:

diff <(gpg --quiet --batch --decrypt ~/vault/.cf.gpg) ~/vault/.cf

ഔട്ട്‌പുട്ട് ഇല്ല എന്നതിനർത്ഥം രണ്ടും ഒരുപോലെയാണ്, മുന്നോട്ട് പോകാൻ നിങ്ങൾക്ക് സുരക്ഷിതമാണ് എന്നാണ്. ഏതെങ്കിലും ഔട്ട്‌പുട്ട് അർത്ഥമാക്കുന്നത് എന്തോ കുഴപ്പമുണ്ട് — തെറ്റായ പാസ്‌ഫ്രെയ്‌സ്, തെറ്റായ സൈഫർ, കേടായ ഫയൽ — കൂടാതെ നിങ്ങൾ ഇതുവരെ പ്ലെയിൻടെക്സ്റ്റ് ഡിലീറ്റ് ചെയ്യാൻ പാടില്ല എന്നാണ്.

ഘട്ടം 4: പ്ലെയിൻടെക്സ്റ്റ് സുരക്ഷിതമായി ഡിലീറ്റ് ചെയ്യുക

shred -u ~/vault/.cf
chmod 600 ~/vault/.cf.gpg
ls -la ~/vault/.cf*        # only .cf.gpg should remain

shred അൺലിങ്ക് ചെയ്യുന്നതിന് മുമ്പ് ബൈറ്റുകൾ തിരുത്തിയെഴുതുന്നു, ഇത് rmനേക്കാൾ ശക്തമാണ്. അതിൻ്റെ പരിമിതികളെക്കുറിച്ച് സത്യസന്ധത പുലർത്തുക: SSD-കളിൽ, കോപ്പി-ഓൺ-റൈറ്റ് ഫയൽസിസ്റ്റങ്ങളിൽ, അല്ലെങ്കിൽ എപ്പോഴെങ്കിലും സ്നാപ്പ്ഷോട്ട് ചെയ്തതോ ബാക്കപ്പ് ചെയ്തതോ ആയ ഏതെങ്കിലും ഫയലിൽ, തിരുത്തിയെഴുതൽ ഗ്യാരണ്ടി ദുർബലമാകും. യഥാർത്ഥത്തിൽ വിട്ടുവീഴ്ച ചെയ്യപ്പെട്ട ക്രെഡൻഷ്യലിനെതിരെയുള്ള ഒരേയൊരു യഥാർത്ഥ ഗ്യാരണ്ടി റൊട്ടേഷൻ ആണ്, അല്ലാതെ ഒരു കോപ്പി ഇല്ലാതാക്കുന്നതല്ല.

ഘട്ടം 5: പാസ്‌ഫ്രെയ്‌സ് കാഷെ ചെറുതാക്കുക (ഓപ്ഷണൽ എന്നാൽ ശുപാർശ ചെയ്യുന്നത്)

സ്ഥിരസ്ഥിതിയായി gpg-agent നിങ്ങൾ ടൈപ്പ് ചെയ്ത് പത്ത് മിനിറ്റോ അതിൽ കൂടുതലോ സമയത്തേക്ക് നിങ്ങളുടെ പാസ്‌ഫ്രെയ്‌സ് കാഷെ ചെയ്യുന്നു. ആ വിൻഡോ ചുരുക്കാൻ:

mkdir -p ~/.gnupg && chmod 700 ~/.gnupg
cat >> ~/.gnupg/gpg-agent.conf <<'EOF'
default-cache-ttl 60
max-cache-ttl 120
EOF
chmod 600 ~/.gnupg/gpg-agent.conf
gpg-connect-agent reloadagent /bye

ഇത് 60 മുതൽ 120 സെക്കൻഡ് വരെ കാഷിംഗ് പരിമിതപ്പെടുത്തുന്നു — നിങ്ങൾ ഡീക്രിപ്റ്റ് ചെയ്തതിന് തൊട്ടുപിന്നാലെ ഒരു സ്ക്രിപ്റ്റ് റൺ ചെയ്യാൻ പര്യാപ്തമാണ്, കൂടാതെ ഒരു വാക്ക്-എവേ വോൾട്ട് അൺലോക്ക് ആയി കിടക്കുന്നില്ല എന്ന് ഉറപ്പാക്കാൻ പര്യാപ്തമാണ്.

ഘട്ടം 6: രഹസ്യം ഒരിക്കലും പ്രിൻ്റ് ചെയ്യാത്ത ഡീക്രിപ്റ്റ്-ആൻഡ്-എക്സിക്യൂട്ട് റാപ്പർ ഉണ്ടാക്കുക

കീ ഒരിക്കലും വെളിപ്പെടുത്താതെ വോൾട്ടിനെ അനുദിനം ഉപയോഗയോഗ്യമാക്കുന്ന ഘട്ടമാണിത്. ഇത് ആയി സേവ് ചെയ്യുക ~/vault/cf-run.sh:

#!/usr/bin/env bash
# cf-run.sh — decrypt .cf.gpg and exec a command with CLOUDFLARE_EMAIL /
# CLOUDFLARE_API_KEY set for that one child process only. The decrypted value
# is never printed, written to disk, or returned as this script's output.
#   Usage: ./cf-run.sh npx wrangler deploy
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CREDS_FILE="$SCRIPT_DIR/.cf.gpg"

[ -f "$CREDS_FILE" ] || { echo "cf-run.sh: $CREDS_FILE not found" >&2; exit 1; }
[ "$#" -gt 0 ]       || { echo "usage: cf-run.sh <command> [args...]" >&2; exit 1; }

CREDS="$(gpg --quiet --batch --decrypt "$CREDS_FILE")" || { echo "cf-run.sh: decryption failed" >&2; exit 1; }
CF_EMAIL="$(awk '{print $1}' <<<"$CREDS")"
CF_KEY="$(awk '{print $2}' <<<"$CREDS")"
unset CREDS

exec env CLOUDFLARE_EMAIL="$CF_EMAIL" CLOUDFLARE_API_KEY="$CF_KEY" "$@"

chmod +x ~/vault/cf-run.sh

ഇത് സുരക്ഷിതമായി തുടരുന്നത് എന്തുകൊണ്ട്, ഓരോ വരിയായി:

• ഡീക്രിപ്റ്റ് ചെയ്ത ടെക്സ്റ്റ് നേരിട്ട് കമാൻഡ് സബ്സ്റ്റിറ്റ്യൂഷൻ വഴി ഒരു ഷെൽ വേരിയബിളിലേക്ക് പോകുന്നു — ഒരിക്കലും ടെർമിനലിലേക്കോ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്കോ അല്ല.
• awk ആ വേരിയബിളിൽ നിന്ന് രണ്ട് ഫീൽഡുകൾ വേർതിരിച്ചെടുക്കുന്നു; ഇപ്പോഴും ഒന്നും പ്രിൻ്റ് ചെയ്തിട്ടില്ല.
• unset CREDS കഷണങ്ങൾ പുറത്തെടുത്തയുടനെ സംയോജിപ്പിച്ച വരി മെമ്മറിയിൽ നിന്ന് ഉപേക്ഷിക്കുന്നു.
• exec env VAR=... "$@" നിങ്ങളുടെ ടാർഗെറ്റ് കമാൻഡ് ഉപയോഗിച്ച് റാപ്പറുടെ പ്രോസസ്സിനെ മാറ്റിസ്ഥാപിക്കുന്നു, മൂല്യങ്ങൾ അതിൻ്റെ സ്വന്തം പരിതസ്ഥിതിയിൽ മാത്രം നൽകുന്നു. ഡിസ്കിൽ എഴുതിയിട്ടില്ല, ലോഗിൻ ചെയ്തിട്ടില്ല, അല്ലെങ്കിൽ ഒരു ഘട്ടത്തിലും പ്രതിധ്വനിച്ചിട്ടില്ല.

ഘട്ടം 7: എല്ലാത്തിനും റാപ്പർ ഉപയോഗിക്കുക

ഒരിക്കലും ചെയ്യരുത് CLOUDFLARE_API_KEY=$(cat ...) wrangler deploy വീണ്ടും. റാപ്പറിലൂടെ എല്ലാ കമാൻഡും റൂട്ട് ചെയ്യുക, കൂടാതെ ടാർഗെറ്റ് ടൂളിനെ സ്വന്തം പരിതസ്ഥിതിയിൽ നിന്ന് വേരിയബിളുകൾ വായിക്കാൻ അനുവദിക്കുക:

~/vault/cf-run.sh npx wrangler deploy
~/vault/cf-run.sh curl -s "https://api.cloudflare.com/client/v4/user" \
  -H "X-Auth-Email: $CLOUDFLARE_EMAIL" -H "X-Auth-Key: $CLOUDFLARE_API_KEY"

ഘട്ടം 8 (AI-അസിസ്റ്റൻ്റ് ഉപയോക്താക്കൾ മാത്രം): ഹാർഡ് ഗാർഡ് ഹുക്ക് ചേർക്കുക

ഒരു കോഡിംഗ് അസിസ്റ്റൻ്റ് നിങ്ങളുടെ മെഷീനിൽ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, "കീ പ്രിൻ്റ് ചെയ്യാതിരിക്കാൻ ഓർമ്മിക്കുക" എന്നത് ഒരു നിയന്ത്രണമല്ല. പല സഹായികളും ഒരു ഹുക്ക് സിസ്റ്റം തുറന്നുകാട്ടുന്നു, അത് പ്രവർത്തിക്കുന്നതിന് മുമ്പ് ഒരു കമാൻഡ് പരിശോധിക്കാനും അത് നിരസിക്കാനും കഴിയും. രണ്ട് കാര്യങ്ങൾ തടയുന്ന ഒരു പ്രീ-എക്‌സിക്യൂഷൻ ഗാർഡാണ് ആശയം: വോൾട്ടിൻ്റെ പ്ലെയിൻ ടെക്‌സ്‌റ്റ് ഫോം നേരിട്ട് വായിക്കുക, വോൾട്ട് ഡീക്രിപ്റ്റ് ചെയ്ത് ക്യാപ്‌ചർ ചെയ്‌ത വേരിയബിളിലേക്ക് പകരം സ്‌റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ടിലേക്കോ പൈപ്പിലേക്കോ ഡീക്രിപ്റ്റ് ചെയ്യുക.

ഗാർഡ്, ലളിതമായി പറഞ്ഞാൽ, തീർപ്പുകൽപ്പിക്കാത്ത ഷെൽ കമാൻഡ് പരിശോധിക്കുന്നു ഒപ്പം:

• തടയുന്നു ഒരു റീഡ് കമാൻഡ് (cat, less, head, strings, മുതലായവ) വോൾട്ടിൻ്റെ പ്ലെയിൻടെക്സ്റ്റ് ഫയലിൻ്റെ പേരിന് നേരെ ചൂണ്ടിക്കാണിക്കുന്നു.
• തടയുന്നു ഒരു gpg --decrypt കമാൻഡ് സബ്സ്റ്റിറ്റ്യൂഷനിൽ അതിൻ്റെ ഔട്ട്പുട്ട് ക്യാപ്ചർ ചെയ്തില്ലെങ്കിൽ വോൾട്ടിൻ്റെ X="$(gpg -d ... )".
• അനുവദിക്കുന്നു മറ്റെല്ലാം, നിയമാനുസൃതമായവ ഉൾപ്പെടെ cf-run.sh വിളിക്കൽ.

ഒരു മിനിമൽ പൈത്തൺ ഗാർഡ് എക്‌സിറ്റ് കോഡ് 0 അനുവദിക്കുന്നതിനും എക്‌സിറ്റ് കോഡ് 2 ബ്ലോക്ക് ചെയ്യുന്നതിനും നൽകുന്നു, അസിസ്റ്റൻ്റിന് എന്തുകൊണ്ടാണെന്ന് കാണുന്നതിനായി സ്റ്റാൻഡേർഡ് എററിലേക്ക് കാരണം പ്രിൻ്റ് ചെയ്യുന്നു:

#!/usr/bin/env python3
import json, re, sys

VAULT_HINTS = ("vault/.cf",)                 # add every vault path you protect
READ_CMDS   = r"(cat|less|more|head|tail|strings|xxd|od)"

def main() -> int:
    try:
        cmd = (json.load(sys.stdin).get("tool_input") or {}).get("command", "") or ""
    except Exception:
        return 0                             # never break tooling on a parse error
    # Block reading the plaintext vault directly (matches .cf but not .cf.gpg)
    if re.search(rf"(^|[;&|]\s*){READ_CMDS}\s+[^\n]*vault/\.cf(\s|$)", cmd):
        sys.stderr.write("BLOCKED: reading the plaintext vault would leak it. Use cf-run.sh.\n")
        return 2
    # Only care about decrypting a protected vault
    if re.search(r"gpg\b.{0,60}?(-d\b|--decrypt\b)", cmd) and any(h in cmd for h in VAULT_HINTS):
        if re.search(r"\$\(\s*gpg\b", cmd) or re.search(r"`\s*gpg\b", cmd):
            return 0                         # captured into a variable — safe
        sys.stderr.write("BLOCKED: decrypting to stdout leaks secrets. Capture into a variable.\n")
        return 2
    return 0

if __name__ == "__main__":
    sys.exit(main())

നിങ്ങളുടെ അസിസ്റ്റൻ്റിൻ്റെ പ്രീ-ടൂൾ ഹുക്ക് കോൺഫിഗറേഷനിലേക്ക് ഇത് വയർ ചെയ്യുക, തുടർന്ന് ഒരു ഡീകോയ് ഫയലിനെതിരെ അത് പരീക്ഷിക്കുക — ഒരിക്കലും യഥാർത്ഥ വോൾട്ട് ഉപയോഗിക്കരുത്, കാരണം പരിശോധനയ്ക്കിടെ റൂളിലെ ഒരു ബഗ് യഥാർത്ഥ രഹസ്യം പ്രിൻ്റ് ചെയ്തേക്കാം. ഒരു ദോഷരഹിതവ ഉണ്ടാക്കുക vault/.cf ഒരു ത്രോവേ ഡയറക്‌ടറിക്ക് കീഴിൽ, അസിസ്റ്റൻ്റ് അത് വായിക്കാൻ വിസമ്മതിക്കുന്നുവെന്ന് സ്ഥിരീകരിക്കുക, കൂടാതെ നിയമാനുസൃതമായത് പ്രത്യേകം സ്ഥിരീകരിക്കുക cf-run.sh കമാൻഡ് ഇപ്പോഴും പാസാകുന്നു.

ഉപസംഹാരം

വിശ്രമവേളയിൽ ഒരു ക്രെഡൻഷ്യൽ എൻക്രിപ്റ്റ് ചെയ്യുന്നത് മാത്രം മതിയാകില്ല. മൂല്യം ഒരിക്കലും പുറത്തുവരാത്ത രീതിയിൽ ഡീക്രിപ്റ്റ് ചെയ്യപ്പെടുകയും — AI അസിസ്റ്റൻ്റ് ഉൾപ്പെട്ടിരിക്കുന്നിടത്ത് — അച്ചടക്കത്തേക്കാൾ കോഡ് മുഖേന സുരക്ഷിതമല്ലാത്ത ആക്‌സസ് തടയുകയും ചെയ്താൽ മാത്രമേ മൂല്യം സുരക്ഷിതമായി നിലനിൽക്കൂ. GPG സിമ്മട്രിക് എൻക്രിപ്ഷൻ, ഒരു ഡീക്രിപ്റ്റ്-ആൻഡ്-എക്സിക്യൂട്ട് റാപ്പർ, കൂടാതെ ഒരു പ്രീ-എക്സിക്യൂഷൻ ഗാർഡ് ഹുക്ക് എന്നിവയെല്ലാം ചേർന്ന് നിങ്ങൾക്ക് യഥാർത്ഥ ഉപയോഗയോഗ്യമായതും യഥാർത്ഥത്തിൽ ചോർത്താൻ പ്രയാസമുള്ളതുമായ ഒരു വോൾട്ട് നൽകുന്നു. ഇത് സജ്ജീകരിക്കാൻ പതിനഞ്ച് മിനിറ്റെടുക്കും കൂടാതെ നിശബ്ദവും ലജ്ജാകരവുമായ എല്ലാ എക്സ്പോഷറുകളും ഇല്ലാതാക്കുന്നു.

ഗുണങ്ങൾ

• പോർട്ടബിളും ഡിപൻഡൻസി-ഫ്രീയും: കോർ സജ്ജീകരണത്തിന് മാത്രമേ ആവശ്യമുള്ളൂ gpg കൂടാതെ bash, മിക്കവാറും എല്ലാ യുണിക്സ് മെഷീനിലും ഉണ്ട്.
• സാധാരണ ഉപയോഗ സമയത്ത് രഹസ്യം ഒരിക്കലും അച്ചടിക്കുകയോ ഡിസ്കിൽ എഴുതുകയോ ലോഗ് ചെയ്യുകയോ ചെയ്യുന്നില്ല.
• സിമ്മട്രിക് എൻക്രിപ്ഷൻ ഒരൊറ്റ ഓപ്പറേറ്റർക്കായി മോഡൽ ലളിതമാക്കുന്നു.
• ഓപ്ഷണൽ ഗാർഡ് ഹുക്ക് "ശ്രദ്ധിക്കുക" എന്നത് എൻഫോഴ്സ് ചെയ്ത, കോഡ് ലെവൽ നിയന്ത്രണമാക്കി മാറ്റുന്നു.
• ക്ലൗഡ്‌ഫ്ലെയർ മാത്രമല്ല, ഉയർന്ന പ്രത്യേകാവകാശമുള്ള ഏത് ക്രെഡൻഷ്യലിനും ഇതേ പാറ്റേൺ പ്രവർത്തിക്കുന്നു.

ദോഷങ്ങൾ

• മറന്നുപോയ പാസ്‌ഫ്രെയ്‌സ് എന്നതിനർത്ഥം ശാശ്വതമായ നഷ്ടമാണ്; വീണ്ടെടുക്കൽ പാതയില്ല.
• shred SSD-കൾ, കോപ്പി-ഓൺ-റൈറ്റ് ഫയൽസിസ്റ്റുകൾ, അല്ലെങ്കിൽ മുമ്പ് ബാക്കപ്പ് ചെയ്‌ത ഫയലുകൾ എന്നിവയിൽ പൂർണ്ണമായി ഡിലീറ്റ് ചെയ്യുന്നത് ഉറപ്പ് നൽകാൻ കഴിയില്ല.
• എൻക്രിപ്ഷൻ താക്കോൽ സംരക്ഷിക്കുന്നു, പക്ഷേ പഴയ എക്സ്പോഷർ പഴയപടിയാക്കാൻ ഒന്നും ചെയ്യുന്നില്ല.
• ഗാർഡ് ഹുക്ക് അസിസ്റ്റൻ്റ് നിർദ്ദിഷ്ടമാണ് കൂടാതെ നിങ്ങളുടെ യഥാർത്ഥ വോൾട്ട് പാതകളുമായി സമന്വയിപ്പിച്ചിരിക്കണം.

മുന്നറിയിപ്പ്

ഈ ലേഖനത്തിലെ ഓരോ മൂല്യവും — [email protected], REPLACE_WITH_GLOBAL_API_KEY, main-account, കൂടാതെ ~/vault പാത — ഒരു പ്ലേസ്‌ഹോൾഡറാണ്. നിങ്ങളുടേത് പകരം വയ്ക്കുക, പതിപ്പ് നിയന്ത്രണത്തിന് ഒരിക്കലും പ്ലെയിൻടെക്സ്റ്റ് ക്രെഡൻഷ്യൽ ചെയ്യരുത്. ഒരു യഥാർത്ഥ കീ ഉപയോഗിച്ച് അവരെ വിശ്വസിക്കുന്നതിന് മുമ്പ് ഡീകോയ് ഫയലുകൾക്കെതിരെ റാപ്പറും ഗാർഡും പരീക്ഷിക്കുക, ക്രെഡൻഷ്യൽ വെളിപ്പെട്ടുവെന്ന് നിങ്ങൾ സംശയിക്കുന്ന നിമിഷം തിരിക്കുക. നിങ്ങളുടെ സ്വന്തം ഉത്തരവാദിത്തത്തിൽ തുടരുക; നിങ്ങളുടെ സ്വന്തം ക്രെഡൻഷ്യലുകളുടെയും ഇൻഫ്രാസ്ട്രക്ചറിൻ്റെയും ഉത്തരവാദിത്തം നിങ്ങൾക്കാണ്.

പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ

എന്തുകൊണ്ടാണ് ഒരു പബ്ലിക്/പ്രൈവറ്റ് കീപെയറിന് പകരം GPG സിമ്മട്രിക് എൻക്രിപ്ഷൻ ഉപയോഗിക്കുന്നത്? എൻക്രിപ്റ്ററും ഡീക്രിപ്റ്ററും മാത്രമായ ഒരൊറ്റ ഓപ്പറേറ്റർക്ക്, ഒരു പാസ്‌ഫ്രെയ്‌സ് അധിഷ്‌ഠിത സിമ്മട്രിക് സൈഫർ ലളിതവും ശക്തവുമാണ്. ഒരു കീപെയർ ഈ സാഹചര്യത്തിൽ സുരക്ഷാ നേട്ടങ്ങളൊന്നുമില്ലാതെ കീ മാനേജ്മെൻ്റ് ഓവർഹെഡ് വർദ്ധിപ്പിക്കുന്നു.

എൻക്രിപ്റ്റ് ചെയ്ത .cf.gpg ഫയൽ ഗിറ്റിൽ സൂക്ഷിക്കുന്നത് സുരക്ഷിതമാണോ? സൈഫർടെക്സ്റ്റ് സമർപ്പിക്കാൻ സാങ്കേതികമായി സുരക്ഷിതമാണ്, എന്നാൽ അത് നിങ്ങളുടെ മെഷീനിൽ നിന്ന് പുറത്തുപോകുന്നതിന് യാതൊരു ഗുണവുമില്ല. അത് ലോക്കൽ ആയി സൂക്ഷിക്കുക, പ്ലെയിൻടെക്സ്റ്റ് ഒരിക്കലും, ഒരിക്കലും കമ്മിറ്റ് ചെയ്യരുത്.

ഗ്ലോബൽ API കീക്ക് പകരം ഞാൻ ക്ലൗഡ്‌ഫ്ലെയർ API ടോക്കൺ ഉപയോഗിക്കണമോ? അതെ, ടൂൾ അതിനെ പിന്തുണയ്ക്കുമ്പോഴെല്ലാം. ഒരു സ്കോപ്പ് ചെയ്ത ടോക്കൺ വ്യക്തിഗതമായി പിൻവലിക്കാൻ കഴിയും, മാത്രമല്ല അതിൻ്റെ സ്കോപ്പിന് പുറത്തുള്ള ഉറവിടങ്ങളിൽ എത്തിച്ചേരാനാകില്ല, അതിനാൽ ഒരു ചോർച്ച ചോർന്ന ഗ്ലോബൽ API കീയേക്കാൾ വളരെ കുറച്ച് നാശം വരുത്തും.

ഡീക്രിപ്റ്റ്-ആൻഡ്-എക്സിക്യൂട്ട് റാപ്പർ യഥാർത്ഥത്തിൽ എന്തിൽ നിന്നാണ് സംരക്ഷിക്കുന്നത്? ഡീക്രിപ്റ്റ് ചെയ്ത രഹസ്യം ഒരു ചൈൽഡ് പ്രോസസ്സിൻ്റെ പരിതസ്ഥിതിയിൽ മാത്രമേ ജീവിക്കുന്നുള്ളൂവെന്ന് ഇത് ഉറപ്പാക്കുന്നു. ഇത് ഒരിക്കലും ഒരു ടെർമിനലിലേക്ക് പ്രിൻ്റ് ചെയ്യപ്പെടുകയോ ഷെൽ ചരിത്രത്തിൽ പകർത്തുകയോ ഡിസ്കിൽ എഴുതുകയോ ചെയ്യുന്നില്ല, ഇവ സാധാരണ ആകസ്മിക ചോർച്ച പാതകളാണ്.

ഒരു AI കോഡിംഗ് അസിസ്റ്റൻ്റിലേക്ക് ഒരു രഹസ്യം എങ്ങനെ ചോരും? അസിസ്റ്റൻ്റ് വായിക്കുന്ന അല്ലെങ്കിൽ ഒരു കമാൻഡ് പ്രിൻ്റ് ചെയ്യുന്ന എല്ലാം മോഡൽ പ്രൊവൈഡർക്ക് അയച്ച സെഷൻ ട്രാൻസ്ക്രിപ്റ്റിലേക്ക് ചേർക്കുന്നു. ഒരു പ്ലെയിൻടെക്സ്റ്റ് കീയുടെ ഒരൊറ്റ cat അല്ലെങ്കിൽ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്കുള്ള ഡീക്രിപ്റ്റ്, ട്രാൻസ്ക്രിപ്റ്റിൽ ആ കീ ശാശ്വതമായി സ്ഥാപിക്കുന്നു.

കീ ഇതിനകം ഒരിക്കൽ ചോർന്നതാണെങ്കിൽ അത് എൻക്രിപ്റ്റ് ചെയ്യുന്നത് സഹായിക്കുമോ? ഇല്ല. എൻക്രിപ്ഷൻ കീയെ ഭാവിയിലെ എക്സ്പോഷറിൽ നിന്ന് മാത്രമേ സംരക്ഷിക്കുകയുള്ളൂ. ഒരു കീ എപ്പോഴെങ്കിലും പ്രിൻ്റ് ചെയ്യുകയോ ഒട്ടിക്കുകയോ ട്രാൻസ്ക്രിപ്റ്റിൽ കാണുകയോ ചെയ്തിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ അത് തിരിക്കണം; പഴയ മൂല്യം എൻക്രിപ്റ്റ് ചെയ്യുന്നത് വെളിപ്പെടുത്തിയ ഒന്നിനെക്കുറിച്ച് ഒന്നും മാറ്റില്ല.

എത്ര തവണ ഞാൻ ഒരു ഉയർന്ന പ്രിവിലേജ് കീ തിരിക്കണം? നിങ്ങളുടെ റിസ്ക് ടോളറൻസുമായി പൊരുത്തപ്പെടുന്ന ഒരു ഷെഡ്യൂളിൽ റൊട്ടേറ്റ് ചെയ്യുക, കൂടാതെ ഏതെങ്കിലും സംശയാസ്പദമായ എക്സ്പോഷറിൽ ഉടനടി. ഒരു അക്കൗണ്ട്-വൈഡ് കീയ്ക്കായി, കൂടുതൽ തവണ തിരിയുന്നതിൻ്റെ ഭാഗത്ത് തെറ്റ് ചെയ്യുക, കാരണം അതിൻ്റെ ബ്ലാസ്റ്റ് റേഡിയസ് മുഴുവൻ അക്കൗണ്ടുമാണ്.

AWS, ഡാറ്റാബേസ് അല്ലെങ്കിൽ മറ്റ് ക്രെഡൻഷ്യലുകളുമായി എനിക്ക് ഇത് പൊരുത്തപ്പെടുത്താൻ കഴിയുമോ? അതെ. വിശ്രമവേളയിൽ എൻക്രിപ്റ്റ് ചെയ്യുക, ത്രോവേ സബ്പ്രോസസിലേക്ക് മാത്രം ഡീക്രിപ്റ്റ് ചെയ്യുക, സുരക്ഷിതമല്ലാത്ത റീഡുകൾ തടയുക എന്നീ മൂന്ന് ആശയങ്ങൾ ഏത് രഹസ്യത്തിനും ബാധകമാണ്. ഫീൽഡ് പാഴ്‌സിംഗും റാപ്പറിലെ പരിസ്ഥിതി വേരിയബിൾ പേരുകളും പൊരുത്തപ്പെടുത്തുന്നതിന് ക്രമീകരിക്കുക.

ടാഗുകൾ

#Security #GPG #Encryption #SecretsManagement #Cloudflare #APIKeys #DevOps #DevSecOps #AICoding #Linux