BrassCoders പരിശോധിച്ച പതിനഞ്ച് AI-ജനറേറ്റഡ് പൈത്തൺ സ്ക്രിപ്റ്റുകളിൽ രണ്ടിൽ ഹാർഡ്-കോഡഡ് സീക്രട്ടുകൾ (hard-coded secrets) കണ്ടെത്തി. ഇത് ലാർജ് ലാംഗ്വേജ് മോഡലുകളിൽ (LLM) നിന്ന് കോഡ് നേരിട്ട് കോപ്പി-പേസ്റ്റ് ചെയ്യുന്ന ഡെവലപ്പർമാർക്ക് വലിയൊരു സുരക്ഷാ ഭീഷണി ഉയർത്തുന്നു. ഒരു ചെറിയ കീ അല്ലെങ്കിൽ പാസ്‌വേഡ് തെറ്റായി ഉൾപ്പെടുത്തിയാൽ പോലും, അത് വെർഷൻ കൺട്രോൾ (version control), പ്രൊഡക്ഷൻ എൻവയോൺമെന്റുകൾ എന്നിവയിലൂടെ വിവരങ്ങൾ ചോരാൻ കാരണമായേക്കാം എന്ന് ഈ കണ്ടെത്തലുകൾ വ്യക്തമാക്കുന്നു.

പരിശോധനയിൽ വെളിപ്പെട്ട കാര്യങ്ങൾ

ആദ്യത്തെ സ്ക്രിപ്റ്റ്, token_check.py, സെഷൻ ടോക്കണുകൾ സൈൻ ചെയ്യുന്നതിനും ഒരു “ഉപയോഗിക്കാവുന്ന ഉദാഹരണം” (usable example) ഉൾപ്പെടുത്തുന്നതിനുമുള്ള ഒരു പ്രോംപ്റ്റിൽ നിന്നാണ് നിർമ്മിച്ചത്. കോഡ് പ്രവർത്തിപ്പിക്കാൻ എളുപ്പമാക്കുന്നതിനായി, മോഡൽ ഒരു HMAC സൈനിംഗ് കീ നേരിട്ട് സോഴ്സ് ഫയലിൽ തന്നെ ഉൾപ്പെടുത്തി.

  • പ്രശ്നം: സീക്രട്ട് കീ കോഡ് ബേസിനുള്ളിൽ തന്നെ നിലനിൽക്കുന്നു.
  • റിസ്ക്: റെപ്പോസിറ്ററിയിൽ റീഡ് ആക്സസ് ഉള്ള ആർക്കും ഈ കീ കാണാൻ കഴിയും, കൂടാതെ ഈ ഫയൽ ഉപയോഗിക്കുന്ന ഏതൊരു ഡിപ്ലോയ്മെന്റും ഈ സീക്രട്ട് സ്വീകരിക്കുന്നു.
  • പരിണതഫലം: കീ കൈക്കലാക്കുന്ന ഒരു അറ്റാക്കർക്ക് സാധുവായ സെഷൻ ടോക്കണുകൾ നിർമ്മിക്കാനും (forge) ഓതന്റിക്കേഷൻ പരിശോധനകളെ മറികടക്കാനും കഴിയും.

രണ്ടാമത്തെ സ്ക്രിപ്റ്റ്, email_sender.py, SMTP വഴി ഇമെയിൽ അയക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ ആവശ്യപ്പെട്ടതിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഉദാഹരണം പെട്ടെന്ന് പ്രവർത്തിക്കാൻ വേണ്ടി മോഡൽ വീണ്ടും ഒരു പാസ്‌വേഡ് നേരിട്ട് നൽകി.

  • പ്രശ്നം: ഫംഗ്ഷൻ കോളിൽ പാസ്‌വേഡ് ഒരു പ്ലെയിൻ-ടെക്സ്റ്റ് സ്ട്രിംഗ് ആയി കാണപ്പെടുന്നു.
  • റിസ്ക്: പാസ്‌വേഡ് മാറ്റണമെങ്കിൽ (rotating) കോഡിൽ മാറ്റം വരുത്തുകയും പുതിയൊരു ഡിപ്ലോയ്മെന്റ് നടത്തുകയും വേണം, കൂടാതെ ഈ ക്രെഡൻഷ്യൽ ഫയൽ ഉപയോഗിക്കുന്ന എല്ലാ എൻവയോൺമെന്റുകളിലേക്കും വ്യാപിക്കുന്നു.
  • പരിണതഫലം: സോഴ്സ് കൺട്രോൾ, ലോഗുകൾ അല്ലെങ്കിൽ കംപൈൽ ചെയ്ത പാക്കേജുകൾ എന്നിവയിൽ നിന്ന് പാസ്‌വേഡ് ചോർത്താൻ സാധിക്കും, ഇത് മെയിൽ സെർവറിലേക്ക് അനധികൃതമായ പ്രവേശനം നൽകുന്നു.

എന്തുകൊണ്ടാണ് AI സീക്രട്ടുകൾ നൽകുന്നത്?

ലാർജ് ലാംഗ്വേജ് മോഡലുകൾ പ്രോംപ്റ്റ് പൂർത്തിയാക്കുന്നതിലൂടെയാണ് ടെക്സ്റ്റ് നിർമ്മിക്കുന്നത്. ഒരു ഉപയോക്താവ് “ഉപയോഗിക്കാവുന്ന ഉദാഹരണം” ആവശ്യപ്പെടുമ്പോൾ, മോഡൽ അതിനെ “അധിക സെറ്റപ്പുകൾ ഇല്ലാതെ പ്രവർത്തിക്കുന്ന കോഡ്” എന്നാണ് മനസ്സിലാക്കുന്നത്. അതിനാൽ, API കീകൾ, പാസ്‌വേഡുകൾ, ടോക്കണുകൾ തുടങ്ങിയ വിട്ടുപോയ മൂല്യങ്ങൾ അനുമാനിക്കാവുന്ന പ്ലേസ്‌ഹോൾഡറുകൾ (placeholders) ഉപയോഗിച്ച് അത് പൂരിപ്പിക്കുന്നു. പ്രോംപ്റ്റിൽ പ്രത്യേകം പരാമർശിച്ചില്ലെങ്കിൽ സീക്രട്ട് മാനേജ്‌മെന്റ് രീതികളെക്കുറിച്ച് മോഡലിന് അറിവുണ്ടാകില്ല.

AI-ജനറേറ്റഡ് കോഡിനെക്കുറിച്ചുള്ള വെരാകോഡിന്റെ (Veracode) സമീപകാല വിശകലനം അനുസരിച്ച്, 45% സ്നിപ്പറ്റുകളിലും OWASP Top 10-ൽ ഉൾപ്പെട്ട കുറഞ്ഞത് ഒരു സുരക്ഷാ വീഴ്ചയെങ്കിലും കണ്ടെത്തിയിട്ടുണ്ട്, ഇതിൽ ക്രെഡൻഷ്യൽ എക്സ്പോഷർ (credential exposure) വലിയൊരു പങ്കാണ് വഹിക്കുന്നത്. ഈ പ്രശ്നം ഏതാനും ഉദാഹരണങ്ങളിൽ മാത്രം ഒതുങ്ങുന്നതല്ലെന്നും, മറിച്ച് ഈ മോഡലുകൾ പരിശീലിപ്പിക്കുന്ന രീതിയുടെയും പ്രോംപ്റ്റ് നൽകുന്ന രീതിയുടെയും ഒരു വ്യവസ്ഥാപിത ഫലമാണെന്നും ഈ കണക്കുകൾ വ്യക്തമാക്കുന്നു.

ഡെവലപ്പർമാർക്ക് ഇപ്പോൾ സ്വീകരിക്കാവുന്ന പ്രതിരോധ നടപടികൾ

ഏറ്റവും ലളിതമായ പ്രതിരോധം ഏതൊരു സീക്രറ്റും കോഡ് ഫയലിന് പുറത്ത് സൂക്ഷിക്കുക എന്നതാണ്. എൻവയോൺമെന്റ് വേരിയബിളുകൾ (Environment variables) ആണ് ഇതിനായി ഉപയോഗിക്കുന്ന ഏറ്റവും സാധാരണവും ലാംഗ്വേജ്-അഗ്നോസ്റ്റിക് ആയതുമായ രീതി:

# token_check.py – secure version
import os
import hmac
import hashlib

SECRET_KEY = os.environ["HMAC_SECRET_KEY"]

def sign_token(data: bytes) -> str:
    return hmac.new(SECRET_KEY.encode(), data, hashlib.sha256).hexdigest()

# email_sender.py – secure version
import os
import smtplib

smtp_password = os.environ["SMTP_PASSWORD"]
server = smtplib.SMTP("smtp.example.com", 587)
server.starttls()
server.login("noreply@example.com", smtp_password)

os.environ ഉപയോഗിക്കുന്നത് റൺടൈം എൻവയോൺമെന്റിൽ നിന്ന് മൂല്യം എടുക്കാൻ സഹായിക്കുന്നു, ഇത് കോഡ് വെർഷൻ കൺട്രോളിൽ നിന്ന് ഒഴിവാക്കാനും സോഴ്സ് ഫയലുകളിൽ മാറ്റം വരുത്താതെ തന്നെ പാസ്‌വേഡുകൾ മാറ്റാനും (rotation) അനുവദിക്കുന്നു. കമ്മറ്റുകളിൽ നിന്ന് ഒഴിവാക്കിയ കൺഫിഗറേഷൻ ഫയലുകൾ, സീക്രട്ട് മാനേജ്‌മെന്റ് സേവനങ്ങൾ, അല്ലെങ്കിൽ കണ്ടെയ്നർ-ഓർക്കസ്ട്രേറ്റഡ് സീക്രട്ടുകൾ എന്നിവയിലൂടെയും ഇതേ രീതി ഉപയോഗിക്കാം.

അധിക സുരക്ഷാ മാർഗങ്ങൾ

  • കോഡ് റിവ്യൂകൾ (Code reviews): സാധാരണ സീക്രട്ട് പാറ്റേണുകളുമായി (ഉദാഹരണത്തിന് നീളമുള്ള അൽഫാന്യൂമെറിക് സീക്വൻസുകൾ) സാമ്യമുള്ള സ്ട്രിംഗുകളെ തിരിച്ചറിയുക.
  • സ്റ്റാറ്റിക് അനാലിസിസ് ടൂളുകൾ (Static analysis tools): പുതുതായി ചേർക്കുന്ന ഫയലുകളിൽ ഹാർഡ്-കോഡഡ് ക്രെഡൻഷ്യലുകൾ കണ്ടെത്താൻ സഹായിക്കുന്ന ടൂളുകൾ ഉപയോഗിക്കുക.
  • പ്രോംപ്റ്റ് എഞ്ചിനീയറിംഗ് (Prompt engineering): “എല്ലാ സീക്രട്ടുകൾക്കും എൻവയോൺമെന്റ് വേരിയബിളുകൾ ഉപയോഗിക്കുക” അല്ലെങ്കിൽ “യഥാർത്ഥ ക്രെഡൻഷ്യലുകൾ ഒഴിവാക്കുക” എന്ന് മോഡലിനോട് പ്രത്യേകം ആവശ്യപ്പെടുക.
  • പോസ്റ്റ്-ജനറേഷൻ ലിന്റിംഗ് (Post-generation linting): കോഡ് പ്രോജക്റ്റിലേക്ക് കോപ്പി ചെയ്യുന്നതിന് മുമ്പ് സംശയാസ്പദമായ സ്ട്രിംഗുകൾക്കായി ഒരു സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് പരിശോധിക്കുക.

ഒരു തിരുത്തൽ: ഇതിനർത്ഥം AI കോഡ് സുരക്ഷിതമല്ല എന്നാണോ?

ഹാർഡ്-കോഡഡ് സീക്രട്ടുകളുടെ സാന്നിധ്യം AI-ജനറേറ്റഡ് കോഡ് എല്ലായ്പ്പോഴും സുരക്ഷിതമല്ല എന്ന് അർത്ഥമാക്കുന്നില്ല. പല സാഹചര്യങ്ങളിലും, വികസന പ്രക്രിയ വേഗത്തിലാക്കാൻ സഹായിക്കുന്ന മികച്ച ലോജിക് ആണ് മോഡലുകൾ നൽകുന്നത്. സുരക്ഷാ പരിശോധനകൾ (security audit) നടത്താതെ ഡെവലപ്പർമാർ ഈ ഔട്ട്പുട്ടിനെ പ്രൊഡക്ഷൻ റെഡി (production-ready) ആയി കണക്കാക്കുമ്പോഴാണ് അപകടസാധ്യത ഉണ്ടാകുന്നത്. AI-യെ ഒരു ഡ്രാഫ്റ്റിംഗ് അസിസ്റ്റന്റായി മാത്രം കാണുക, നിലവിലുള്ള സുരക്ഷാ രീതികൾക്ക് പകരക്കാരനായി കാണരുത്.

ഇനി ശ്രദ്ധിക്കേണ്ട കാര്യങ്ങൾ

  • ടൂളിംഗ് അപ്‌ഡേറ്റുകൾ (Tooling updates): സീക്രട്ടുകൾക്ക് പകരം പ്ലേസ്‌ഹോൾഡറുകൾ ഉപയോഗിക്കുന്ന സുരക്ഷാ ഫിൽട്ടറുകൾ AI പ്ലാറ്റ്‌ഫോമുകൾ ഉൾപ്പെടുത്താൻ തുടങ്ങിയിട്ടുണ്ട്. ഇവ നിരീക്ഷിക്കുന്നത് അപകടസാധ്യത കുറയ്ക്കാൻ സഹായിക്കും.
  • പോളിസി മാറ്റങ്ങൾ (Policy shifts): AI-അസിസ്റ്റഡ് കോഡിംഗിനായി സ്ഥാപനങ്ങൾ മാർഗ്ഗനിർദ്ദേശങ്ങൾ രൂപീകരിക്കുകയും CI പൈപ്പ്‌ലൈനിന്റെ ഭാഗമായി സീക്രട്ട് മാനേജ്‌മെന്റ് പരിശോധനകൾ നിർബന്ധമാക്കുകയും ചെയ്തേക്കാം.
  • കമ്മ്യൂണിറ്റി പാറ്റേണുകൾ (Community patterns): ഡെവലപ്പർമാർ കൂടുതൽ “സുരക്ഷിതമായ പ്രോംപ്റ്റുകൾ” പങ്കുവെക്കുമ്പോൾ, ടോക്കൺ സൈനിംഗ് അല്ലെങ്കിൽ ഇമെയിൽ ഡെലിവറി പോലുള്ള സാധാരണ ജോലികൾക്കായി മികച്ച രീതിയിലുള്ള ടെംപ്ലേറ്റുകൾ ഡിഫോൾട്ട് ഔട്ട്പുട്ടായി മാറാൻ സാധ്യതയുണ്ട്.

പ്രധാന പാഠം: AI-ക്ക് നിമിഷങ്ങൾക്കുള്ളിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന കോഡ് നിർമ്മിക്കാൻ സാധിക്കും, എന്നാൽ ഡെവലപ്പർമാർ secret-management അച്ചടക്കം പാലിച്ചില്ലെങ്കിൽ, ഈ സൗകര്യം ഒരു മറഞ്ഞിരിക്കുന്ന വിലയുമായി വരുന്നു—ഒരു മുഴുവൻ സിസ്റ്റത്തെയും അപകടത്തിലാക്കാൻ സാധ്യതയുള്ള വെളിപ്പെട്ട credentials. ഓരോ snippet-ഉം ഒരു draft ആയി പരിഗണിക്കുക, അവയിൽ നിന്ന് നേരിട്ടുള്ള secrets ഒഴിവാക്കുക, commit ചെയ്യുന്നതിന് മുമ്പ് അവ environment variables വഴിയോ അല്ലെങ്കിൽ ഒരു dedicated vault വഴിയോ ഉൾപ്പെടുത്തുക.