BrassCoders એ તેઓએ તપાસેલા પંદરમાંથી બે AI-જનરેટેડ Python સ્ક્રિપ્ટ્સમાં હાર્ડ-કોડેડ સિક્રેટ્સ (hard-coded secrets) શોધી કાઢ્યા છે, જે લાર્જ લેંગ્વેજ મોડલના આઉટપુટમાંથી સીધો કોડ કોપી-પેસ્ટ કરતા ડેવલપર્સ માટે ચોક્કસ જોખમ ઊભું કરે છે. આ તારણો દર્શાવે છે કે એક ખોટી રીતે મૂકેલી કી અથવા પાસવર્ડ એક ઉપયોગી સ્નિપેટને વર્ઝન કંટ્રોલ અને પ્રોડક્શન એન્વાયરમેન્ટ્સમાં ક્રેડેન્શિયલ લીકનું કારણ બનાવી શકે છે.

પરીક્ષણ દ્વારા શું જાણવા મળ્યું

પ્રથમ સ્ક્રિપ્ટ, token_check.py, એક એવા પ્રોમ્પ્ટમાંથી બનાવવામાં આવી હતી જેમાં સેશન ટોકન્સ પર સહી કરવા માટે અને એક "ઉપયોગ કરી શકાય તેવું ઉદાહરણ" (usable example) શામેલ કરવા માટે ફંક્શન માંગવામાં આવ્યું હતું. કોડને રન કરી શકાય તેવો બનાવવા માટે, મોડલે સીધું જ સોર્સ ફાઇલમાં એક લિટરલ HMAC સાઇનિંગ કી ઉમેરી દીધી હતી.

  • સમસ્યા: સિક્રેટ કી કોડ બેઝમાં જ રહેલી છે.
  • જોખમ: રિપોઝિટરીનો રીડ એક્સેસ ધરાવતી કોઈપણ વ્યક્તિ કી જોઈ શકે છે, અને કોઈપણ ડિપ્લોયમેન્ટ જે આ ફાઇલ ખેંચે છે તે આ સિક્રેટને વારસામાં મેળવે છે.
  • પરિણામ: જે હુમલાખોર કી મેળવી લે છે તે માન્ય સેશન ટોકન્સ બનાવી શકે છે, જેનાથી ઓથેન્ટિકેશન ચેક્સને બાયપાસ કરી શકાય છે.

બીજી સ્ક્રિપ્ટ, email_sender.py, SMTP દ્વારા ઇમેઇલ મોકલતા ફંક્શનની વિનંતીનો જવાબ આપતી હતી. મોડલે ફરીથી એક લિટરલ પાસવર્ડ આપ્યો જેથી ઉદાહરણ તરત જ કામ કરી શકે.

  • સમસ્યા: પાસવર્ડ ફંક્શન કોલમાં પ્લેન-ટેક્સ્ટ સ્ટ્રિંગ તરીકે દેખાય છે.
  • જોખમ: પાસવર્ડ બદલવા (rotate કરવા) માટે કોડમાં ફેરફાર અને નવું ડિપ્લોયમેન્ટ જરૂરી છે, અને આ ક્રેડેન્શિયલ દરેક એન્વાયરમેન્ટમાં ફેલાઈ જાય છે જે આ ફાઇલનો ઉપયોગ કરે છે.
  • પરિણામ: પાસવર્ડ સોર્સ કંટ્રોલ, લોગ્સ અથવા કમ્પાઈલ કરેલા પેકેજમાંથી મેળવી શકાય છે, જે દુશ્મનને મેઇલ સર્વર પર અનધિકૃત એક્સેસ આપી શકે છે.

AI સિક્રેટ્સ કેમ આપે છે

લાર્જ લેંગ્વેજ મોડલ્સ પ્રોમ્પ્ટ પૂર્ણ કરીને ટેક્સ્ટ જનરેટ કરે છે. જ્યારે વપરાશકર્તા "ઉપયોગ કરી શકાય તેવું ઉદાહરણ" માંગે છે, ત્યારે મોડલ તેનો અર્થ "એવો કોડ જે વધારાના સેટઅપ વગર ચાલે" એવો કરે છે. તેથી તે ખૂટતી કિંમતો—API કી, પાસવર્ડ, ટોકન્સ—વ્યાજબી પ્લેસહોલ્ડર્સ સાથે ભરી દે છે. જ્યાં સુધી પ્રોમ્પ્ટમાં સ્પષ્ટપણે તેનો ઉલ્લેખ ન કરવામાં આવે ત્યાં સુધી મોડલ પાસે સિક્રેટ-મેનેજમેન્ટની શ્રેષ્ઠ પદ્ધતિઓની કોઈ જાણકારી હોતી નથી.

AI-જનરેટેડ કોડના તાજેતરના Veracode વિશ્લેષણમાં જાણવા મળ્યું છે કે 45% સ્નિપેટ્સમાં OWASP Top 10 માં સૂચિબદ્ધ ઓછામાં ઓછી એક નબળાઈ (vulnerability) છે, જેમાં ક્રેડેન્શિયલ એક્સપોઝરનો મોટો હિસ્સો છે. આ આંકડો ભાર મૂકે છે કે આ સમસ્યા માત્ર થોડા અપવાદો પૂરતી મર્યાદિત નથી; તે આ મોડલ્સને કેવી રીતે તાલીમ આપવામાં આવે છે અને પ્રોમ્પ્ટ આપવામાં આવે છે તેનું સિસ્ટમનું પરિણામ છે.

ડેવલપર્સ અત્યારે કયા નિવારણ પગલાં લઈ શકે છે

સૌથી સરળ બચાવ એ છે કે કોઈપણ સિક્રેટને કોડ ફાઇલમાંથી દૂર રાખવું. એન્વાયરમેન્ટ વેરિયેબલ્સ એ સૌથી સામાન્ય, ભાષા-સ્વતંત્ર (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 પાઇપલાઇનના ભાગ તરીકે સિક્રેટ-મેનેજમેન્ટ ચેક્સ ફરજિયાત બનાવે છે.
  • કોમ્યુનિટી પેટર્ન્સ: જેમ જેમ ડેવલપર્સ વધુ "સિક્યોર પ્રોમ્પ્ટ્સ" શેર કરશે, તેમ તેમ ટોકન સાઇનિંગ અથવા ઇમેઇલ ડિલિવરી જેવા સામાન્ય કાર્યો માટે બેસ્ટ-પ્રૅક્ટિસ ટેમ્પ્લેટ્સ ડિફોલ્ટ આઉટપુટ બની શકે છે.

મુખ્ય સારાંશ: AI સેકન્ડોમાં કાર્યરત કોડ બનાવી શકે છે, પરંતુ જો ડેવલપર્સ સિક્રેટ-મેનેજમેન્ટની શિસ્ત જાળવે નહીં, તો આ સુવિધાની એક છુપી કિંમત હોય છે—એક્સપોઝ્ડ ક્રેડેન્શિયલ્સ જે આખી સિસ્ટમને જોખમમાં મૂકી શકે છે. દરેક સ્નિપેટને એક ડ્રાફ્ટ તરીકે ગણો, તેમાંથી કોઈપણ લિટરલ સિક્રેટ્સ દૂર કરો, અને કમિટ કરતા પહેલા તેને એન્વાયરમેન્ટ વેરિયેબલ્સ અથવા ડેડિકેટેડ વોલ્ટ દ્વારા ઇન્જેક્ટ કરો.