BrassCoders వారు పరిశీలించిన పదిహేను AI-జనరేటెడ్ Python స్క్రిప్ట్‌లలో రెండులో హార్డ్-కోడెడ్ సీక్రెట్స్ (hard-coded secrets) ఉన్నట్లు గుర్తించారు, ఇది లార్జ్ లాంగ్వేజ్ మోడల్ అవుట్‌పుట్‌ల నుండి నేరుగా కోడ్‌ను కాపీ-పేస్ట్ చేసే డెవలపర్‌లకు ఒక స్పష్టమైన ప్రమాదాన్ని తెలియజేస్తోంది. ఒక చిన్న పొరపాటు వల్ల చోటుచేసుకున్న కీ లేదా పాస్‌వర్డ్, ఒక ఉపయోగకరమైన కోడ్ స్నిప్పెట్‌ను వెర్షన్ కంట్రోల్ మరియు ప్రొడక్షన్ ఎన్విరాన్‌మెంట్ల అంతటా క్రెడెన్షియల్ లీక్‌గా మార్చగలదని ఈ పరిశోధనలు చూపుతున్నాయి.

పరీక్షలో తేలిన అంశాలు

మొదటి స్క్రిప్ట్, token_check.py, సెషన్ టోకెన్‌లను సైన్ చేయడానికి మరియు ఒక “usable example”ను చేర్చడానికి అడిగిన ప్రాంప్ట్ ద్వారా రూపొందించబడింది. కోడ్ రన్ అయ్యేలా చేయడానికి, మోడల్ నేరుగా సోర్స్ ఫైల్‌లోనే ఒక HMAC సైనింగ్ కీని చేర్చింది.

  • సమస్య: సీక్రెట్ కీ కోడ్ బేస్‌లోనే ఉంది.
  • రిస్క్: రిపోజిటరీకి రీడ్ యాక్సెస్ ఉన్న ఎవరైనా కీని చూడవచ్చు, మరియు ఆ ఫైల్‌ను ఉపయోగించే ఏ డిప్లాయ్‌మెంట్‌కైనా ఆ సీక్రెట్ అందుబాటులోకి వస్తుంది.
  • పరిణామం: కీని పొందిన దాడి చేసే వ్యక్తి (attacker) చెల్లుబాటు అయ్యే సెషన్ టోకెన్‌లను సృష్టించి, అథెంటికేషన్ చెక్‌లను దాటవేయగలడు.

రెండవ స్క్రిప్ట్, email_sender.py, SMTP ద్వారా ఈమెయిల్ పంపే ఫంక్షన్ కోసం చేసిన అభ్యర్థనకు సమాధానంగా వచ్చింది. ఉదాహరణ వెంటనే పనిచేయడం కోసం మోడల్ మళ్ళీ నేరుగా ఒక పాస్‌వర్డ్‌ను అందించింది.

  • సమస్య: ఫంక్షన్ కాల్‌లో పాస్‌వర్డ్ ప్లెయిన్-టెక్స్ట్ స్ట్రింగ్‌గా కనిపిస్తుంది.
  • రిస్క్: పాస్‌వర్డ్‌ను మార్చాలంటే కోడ్‌లో మార్పు చేసి, కొత్తగా డిప్లాయ్ చేయాల్సి ఉంటుంది, మరియు ఆ క్రెడెన్షియల్ ఆ ఫైల్‌ను ఉపయోగించే ప్రతి ఎన్విరాన్‌మెంట్‌కు వ్యాపిస్తుంది.
  • పరిణామం: సోర్స్ కంట్రోల్, లాగ్స్ లేదా కంపైల్డ్ ప్యాకేజీల నుండి పాస్‌వర్డ్‌ను సేకరించవచ్చు, దీనివల్ల దురాశపరులకు మెయిల్ సర్వర్‌పై అనధికారిక ప్రాప్యత లభిస్తుంది.

AI ఎందుకు సీక్రెట్స్‌ను బయటపెడుతుంది

లార్జ్ లాంగ్వేజ్ మోడల్స్ ప్రాంప్ట్‌ను పూర్తి చేయడం ద్వారా టెక్స్ట్‌ను రూపొందిస్తాయి. వినియోగదారు "usable example" అని అడిగినప్పుడు, మోడల్ దానిని "అదనపు సెటప్ లేకుండా నడిచే కోడ్" అని అర్థం చేసుకుంటుంది. అందువల్ల, అది మిస్ అయిన విలువలను—API కీలు, పాస్‌వర్డ్‌లు, టోకెన్‌లు—అనుమానపడే ప్లేస్‌హోల్డర్‌లతో నింపుతుంది. ప్రాంప్ట్‌లో స్పష్టంగా పేర్కొననంత వరకు, సీక్రెట్-మేనేజ్‌మెంట్ ఉత్తమ పద్ధతుల (best practices) గురించి మోడల్‌కు అవగాహన ఉండదు.

ఇటీవల Veracode చేసిన AI-జనరేటెడ్ కోడ్ విశ్లేషణ ప్రకారం, 45% స్నిప్పెట్‌లలో OWASP Top 10లో పేర్కొన్న కనీసం ఒక వల్నరబిలిటీ (vulnerability) ఉంది, ఇందులో క్రెడెన్షియల్ ఎక్స్‌పోజర్ గణనీయమైన వాటాను కలిగి ఉంది. ఈ గణాంకం ఈ సమస్య కేవలం కొన్ని సందర్భాల్లో మాత్రమే కాకుండా, ఈ మోడల్స్‌ను ఎలా శిక్షణ ఇచ్చారు మరియు ప్రాంప్ట్ చేస్తారు అనే దాని వల్ల కలిగే ఒక వ్యవస్థాగత పరిణామం అని నొక్కి చెబుతోంది.

డెవలపర్లు ఇప్పుడు తీసుకోవలసిన నివారణ చర్యలు

అత్యంత సులభమైన రక్షణ ఏమిటంటే, ఏ రహస్య సమాచారాన్ని కూడా కోడ్ ఫైల్‌లో ఉంచకపోవడం. ఎన్విరాన్‌మెంట్ వేరియబుల్స్ (Environment variables) అత్యంత సాధారణమైన, ఏ ప్రోగ్రామింగ్ లాంగ్వేజ్‌కైనా వర్తించే (language-agnostic) పద్ధతి:

# 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 ఉపయోగించడం ద్వారా రన్‌టైమ్ ఎన్విరాన్‌మెంట్ నుండి విలువను పొందవచ్చు, దీనివల్ల అది వెర్షన్ కంట్రోల్‌కు దూరంగా ఉంటుంది మరియు సోర్స్ ఫైల్‌లను తాకకుండానే పాస్‌వర్డ్‌లను మార్చుకోవడానికి వీలవుతుంది. ఇదే పద్ధతిని కమిట్‌ల నుండి మినహాయించిన కాన్ఫిగరేషన్ ఫైల్‌లు, సీక్రెట్-మేనేజ్‌మెంట్ సర్వీసులు లేదా కంటైనర్-ఆర్కెస్ట్రేటెడ్ సీక్రెట్స్‌తో కూడా ఉపయోగించవచ్చు.

అదనపు రక్షణ చర్యలు

  • కోడ్ రివ్యూలు: సాధారణ సీక్రెట్ ప్యాటర్న్‌లకు (ఉదాహరణకు: పొడవైన ఆల్ఫాన్యూమరిక్ సీక్వెన్స్‌లు) సరిపోయే స్ట్రింగ్‌లను గుర్తించేలా కోడ్ రివ్యూలు నిర్వహించడం.
  • స్టాటిక్ అనాలిసిస్ టూల్స్: కొత్తగా జోడించిన ఫైల్‌లలో హార్డ్-కోడెడ్ క్రెడెన్షియల్స్‌ను గుర్తించడానికి ట్యూన్ చేయబడిన టూల్స్ వాడటం.
  • ప్రాంప్ట్ ఇంజనీరింగ్: "అన్ని సీక్రెట్‌ల కోసం ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ను ఉపయోగించు" లేదా "నిజమైన క్రెడెన్షియల్స్‌ను వదిలేయండి" అని మోడల్‌ను స్పష్టంగా అడగడం.
  • పోస్ట్-జనరేషన్ లింటింగ్: కోడ్‌ను ప్రాజెక్ట్‌లోకి కాపీ చేసే ముందు అనుమానాస్పద స్ట్రింగ్‌ల కోసం వెతికే ఒక చిన్న స్క్రిప్ట్‌ను రన్ చేయడం.

ప్రతివాదన: దీని అర్థం AI కోడ్ సురక్షితం కాదా?

హార్డ్-కోడెడ్ సీక్రెట్స్ ఉండటం వల్ల AI-జనరేటెడ్ కోడ్ అంతా అసురక్షితం అని అర్థం కాదు. చాలా సందర్భాలలో, మోడల్ క్లీన్ మరియు చక్కని లాజిక్‌ను అందిస్తుంది, ఇది డెవలప్‌మెంట్‌ను వేగవంతం చేస్తుంది. డెవలపర్లు సెక్యూరిటీ ఆడిట్ చేయకుండానే అవుట్‌పుట్‌ను నేరుగా ప్రొడక్షన్‌కు సిద్ధంగా ఉన్నదిగా భావించినప్పుడు మాత్రమే రిస్క్ పెరుగుతుంది. AIని ఒక డ్రాఫ్టింగ్ అసిస్టెంట్‌గా మాత్రమే పరిగణించండి, స్థాపించబడిన భద్రతా పద్ధతులకు ప్రత్యామ్నాయంగా కాదు.

తదుపరి గమనించవలసిన అంశాలు

  • టూలింగ్ అప్‌డేట్స్: AI ప్లాట్‌ఫారమ్‌లు సీక్రెట్స్‌ను ప్లేస్‌హోల్డర్‌లతో భర్తీ చేసే సేఫ్టీ ఫిల్టర్లను చేర్చడం ప్రారంభిస్తున్నాయి. వీటిని గమనించడం ద్వారా ప్రమాదాలను తగ్గించవచ్చు.
  • పాలసీ మార్పులు: సంస్థలు AI-అసిస్టెడ్ కోడింగ్ కోసం మార్గదర్శకాలను అధికారికం చేయవచ్చు మరియు CI పైప్‌లైన్‌లో భాగంగా సీక్రెట్-మేనేజ్‌మెంట్ చెక్‌లను తప్పనిసరి చేయవచ్చు.
  • కమ్యూనిటీ ప్యాటర్న్స్: డెవలపర్లు మరింత "secure prompts" (సురక్షితమైన ప్రాంప్ట్‌లు) పంచుకుంటున్న కొద్దీ, టోకెన్ సైనింగ్ లేదా ఈమెయిల్ డెలివరీ వంటి సాధారణ పనుల కోసం ఉత్తమ పద్ధతుల టెంప్లేట్లు డిఫాల్ట్ అవుట్‌పుట్‌గా మారవచ్చు.

సారాంశం: AI సెకన్లలోనే పనిచేసే కోడ్‌ను రూపొందించగలదు, కానీ డెవలపర్లు సీక్రెట్-మేనేజ్‌మెంట్ క్రమశిక్షణను పాటించకపోతే, ఆ సౌలభ్యం ఒక దాగి ఉన్న ఖర్చుతో కూడి ఉంటుంది—అదే మొత్తం వ్యవస్థను ప్రమాదంలోకి నెట్టేసే బహిర్గత క్రెడెన్షియల్స్. ప్రతి స్నిప్పెట్‌ను ఒక డ్రాఫ్ట్‌గా పరిగణించండి, అందులోని సీక్రెట్స్‌ను తొలగించి, కమిట్ చేసే ముందు వాటిని ఎన్విరాన్‌మెంట్ వేరియబుల్స్ లేదా ప్రత్యేకమైన వాల్ట్ ద్వారా ఇంజెక్ట్ చేయండి.