એક ડેવલપર IDE ખોલે છે, સાદા અંગ્રેજીમાં તેમને શું જોઈએ છે તેનું વર્ણન કરે છે, અને AI એજન્ટ કોફી મેળવવા માટે જેટલો સમય લે છે તેમાં ફીચર લખતો જુએ છે. તે કમ્પાઇલ કરે છે. તે મેન્યુઅલ ક્લિક-થ્રુ પસાર કરે છે. તે મોકલે છે. કોઈએ પૂછ્યું નહીં કે તે સુરક્ષિત છે કે નહીં, કારણ કે કોઈએ કંઈપણ પૂછ્યું નહીં. પ્રોમ્પ્ટે બદલ્યું pull request, અને "મેં તેની સમીક્ષા કરી" ને બદલે "તે કામ કરે છે" એ શબ્દો લગાવ્યા. તે વાઇબ કોડિંગ છે, અને તે હવે કોઈ ખાસ આદત નથી. આ રીતે પ્રોડક્શન કોડનો વધતો હિસ્સો વ્યાવસાયિક ટીમો દ્વારા લખવામાં આવે છે, ફક્ત શોખીનો દ્વારા જ નહીં જે સપ્તાહના અંતે એપ્લિકેશનનો પ્રયોગ કરે છે. અને તે જ કારણ છે કે વાઇબ કોડિંગ સુરક્ષા દરેક એન્જિનિયરિંગ અને સુરક્ષા નેતાની વાતચીત બની ગઈ છે, પછી ભલે તેઓએ તેનું નામ આપ્યું હોય કે ન હોય.
"વાઇબ કોડિંગ" નો ખરેખર અર્થ શું છે?
વાઇબ કોડિંગ એ સોફ્ટવેર ડેવલપમેન્ટ છે જ્યાં વ્યક્તિ ઇચ્છિત પરિણામનું કુદરતી ભાષામાં વર્ણન કરે છે અને એક AI મોડેલ, અથવા તેના પર બનેલ એજન્ટ, કાર્યકારી કોડ જનરેટ કરે છે. વ્યક્તિ પરિણામ દ્વારા માર્ગદર્શન આપે છે ("બિલ્ડ એ login "ફ્લો," "CSV નિકાસ ઉમેરો") લખીને અથવા અમલીકરણની લાઇન-બાય-લાઇન સમીક્ષા કરીને નહીં. આ શબ્દ એટલા માટે પકડાયો કારણ કે તે કંઈક વાસ્તવિક કેપ્ચર કરે છે: ડેવલપર એવું વિચારી રહ્યો છે કે આઉટપુટ યોગ્ય છે, કોડના વાંચન પર નહીં.
આ પરિવર્તન આખી વાર્તા છે. કોડ રિવ્યૂ એ સોફ્ટવેર કેવી રીતે લખાય છે તે સમજવા માટે એક ચેકપોઇન્ટ હતો. ડિઝાઇન દ્વારા તેની આસપાસ વાઇબ કોડિંગ રૂટ્સ. ઝડપ વધે છે. "આ ખરેખર શું કરે છે" એવું પૂછવાની ટેવ ઓછી થાય છે.
"તે કામ કરે છે" એ ખોટું બાર કેમ છે?
"તે કામ કરે છે" નો અર્થ એ છે કે કોડે જે પૂછવામાં આવ્યું હતું તે કર્યું, જે પરિદૃશ્યનું પરીક્ષણ કરવામાં આવ્યું હતું. તે કોઈએ પૂછ્યું ન હોય તેવા પરિદૃશ્યોમાં કોડ શું કરે છે તે વિશે કંઈ કહેતું નથી: એક ખોટો ઇનપુટ, એક પ્રમાણિત વપરાશકર્તા જે એન્ડપોઇન્ટની તપાસ કરે છે જેણે તેમના પર ખૂબ વિશ્વાસ કર્યો હતો, એક નિર્ભરતા જે ક્યારેય તપાસવામાં આવી ન હતી, એક હાર્ડકોડેડ રહસ્ય જે સ્પષ્ટ દૃષ્ટિએ બેઠું છે. આ તે છે જ્યાં કોઈને કોઈ સમસ્યા છે તે ધ્યાનમાં આવે તે પહેલાં જ વાઇબ કોડિંગ સુરક્ષા તૂટી જાય છે.
AI કોડિંગ મોડેલોને પ્રોમ્પ્ટના ઉદ્દેશ્ય સાથે મેળ ખાતા કાર્યાત્મક આઉટપુટ ઉત્પન્ન કરવા માટે તાલીમ આપવામાં આવે છે. સુરક્ષા એ ઉદ્દેશ્ય કાર્ય નથી. "આ વિનંતીને સંતોષે છે" માટે ઑપ્ટિમાઇઝ કરતું મોડેલ ખુશીથી પેરામીટર્સને બદલે સ્ટ્રિંગ કોન્કેટેનેશન સાથે બનેલ ક્વેરી જનરેટ કરશે, કોઈ ઍક્સેસ નિયંત્રણ વિનાનો એન્ડપોઇન્ટ કારણ કે પ્રોમ્પ્ટમાં ક્યારેય ઉલ્લેખ કરવામાં આવ્યો નથી કે કોની પાસે ઍક્સેસ ન હોવી જોઈએ, અથવા એક API કૉલ જે તે પ્રતિભાવ પર વિશ્વાસ કરે છે જે તેને માન્ય કરવો જોઈએ. તે કમ્પાઇલ કરે છે. તે કાર્ય કરે છે. તે એ જ નબળાઈ વર્ગો પણ રજૂ કરે છે જે AppSec ટીમોએ વિકાસકર્તાઓને તાલીમ આપવામાં એક દાયકા વિતાવ્યા છે, જે ગતિએ જનરેટ થાય છે જેથી કોઈ મેન્યુઅલ સમીક્ષા પ્રક્રિયા મેચ ન થાય.
AI-જનરેટેડ કોડ પર આંતરિક સંશોધન વાસ્તવિક આંકડાઓને અંતઃપ્રેરણા પાછળ રાખે છે: એજન્ટિક કોડિંગ ટૂલ્સ જે ઉત્પન્ન કરે છે તેનો એક અર્થપૂર્ણ હિસ્સો કોઈપણ સમીક્ષા થાય તે પહેલાં, પ્રથમ પાસ પર શોષણ કરી શકાય તેવી સુરક્ષા ખામી ધરાવે છે. તે એક મોડેલમાં ખામી નથી. તે "તે ચાલે છે" માટે ઑપ્ટિમાઇઝેશનનું અપેક્ષિત આઉટપુટ છે, "તે પકડી રાખે છે" નહીં, અને તે ચોક્કસ ગેપ છે જે વાઇબ કોડિંગ સુરક્ષાએ બંધ કરવો પડશે.
જોખમની સપાટી કોડ કરતાં પણ પહોળી છે.
વાઇબ કોડિંગ સુરક્ષાને ઘણીવાર એક તરીકે ઘડવામાં આવે છે કોડ-ગુણવત્તા સમસ્યા, પરંતુ એક્સપોઝર સમગ્ર કાર્યપ્રવાહમાં ચાલે છે એજન્ટ સ્પર્શ કરે છે, ફક્ત તેના કાર્યને જ નહીં લખે છે:
પરંપરાગત એપસેક ટૂલિંગ અહીં કેમ પાછળ રહે છે
મોટાભાગની એપ્લિકેશન સુરક્ષા ટૂલિંગ એક લયની આસપાસ બનાવવામાં આવી હતી: કોડ લખવામાં આવે છે, પછી તે સ્કેન થાય છે, CI માં અથવા PR પર. તે લય ધારે છે કે સ્કેનરને નિર્દેશ કરવા માટે એક સ્થિર, માનવ-લેખિત આર્ટિફેક્ટ છે, અને પરિવર્તનનું પ્રમાણ કંઈક એવું છે જે pipeline ઇરાદાપૂર્વક સમીક્ષા કરી શકે છે.
વાઇબ કોડિંગ સમય તોડે છે, અને તે સમયનો તફાવત વાઇબ કોડિંગ સુરક્ષા સમસ્યાનો મુખ્ય ભાગ છે. IDE ની અંદર કોડ સેકન્ડોમાં બદલાઈ જાય છે, ઘણીવાર તે ક્યારેય pull request. એક સ્કેનર જે ફક્ત CI માં ચાલે છે તે સમસ્યાને પકડી લે છે, એકવાર અસુરક્ષિત પેટર્ન પહેલાથી જ મર્જ થઈ જાય પછી, જે પહેલાથી જ આગામી સુવિધાનો ભાગ છે જેના પર કોઈ બીજું નિર્માણ કરી રહ્યું છે. અને એક સ્કેનર જે AI-જનરેટેડ કોડને અન્ય કોઈપણ કોડની જેમ જ વર્તે છે તે જોખમના ભાગોને ચૂકી જાય છે જે તે કેવી રીતે લખવામાં આવ્યું તેના માટે વિશિષ્ટ છે: એજન્ટે તેને વાજબી ઠેરવ્યા વિના પસંદ કરેલું પેકેજ, સૂચના ફાઇલ જે એજન્ટને કહેતી હતી કે માનવીએ ક્યારેય ડિફ જોયો તે પહેલાં શું કરવું.
ખરેખર શું અંતર બંધ કરે છે
આમાં આગળ વધી રહેલી સંસ્થાઓ વાઇબ કોડિંગને ધીમું કરી રહી નથી. તેઓ વર્કફ્લોમાં વાસ્તવિક વાઇબ કોડિંગ સુરક્ષા બનાવી રહ્યા છે: ચેકપોઇન્ટને ત્યાં પાછું ખસેડવું જ્યાં કોડ ખરેખર લખાયેલ છે, અને AI-જનરેટેડ કોડને અન્યથા સાબિત ન થાય ત્યાં સુધી અવિશ્વસનીય ઇનપુટ તરીકે ગણવો:
- ફક્ત CI માં જ નહીં, IDE ની અંદર સ્કેન કરો. જ્યારે એજન્ટ હજુ પણ ફંક્શન જનરેટ કરી રહ્યો હોય ત્યારે અસુરક્ષિત પેટર્ન પકડવી એ ત્રણ વધુ સુવિધાઓ તેના પર આધાર રાખ્યા પછી તેને પકડવા કરતાં અલગ સમસ્યા છે.
- એજન્ટ દ્વારા રજૂ કરાયેલ દરેક નિર્ભરતાને માન્ય કરો, જે રીતે તમે ડેવલપર દ્વારા મેન્યુઅલી ટાઇપ કરેલા પાસવર્ડને ઇન્સ્ટોલ કરતા પહેલા માન્ય કરશો.
- એજન્ટ વાંચે છે તે રૂપરેખાંકન ફાઇલોને કોડ તરીકે ગણો, દસ્તાવેજીકરણ તરીકે નહીં. નિયમો ફાઇલો, કૌશલ્ય ફાઇલો અને MCP સર્વર રૂપરેખાઓમાં એવી સૂચનાઓ હોઈ શકે છે જે એજન્ટ શું કરે છે તે બદલી નાખે છે, અને તેઓ એજન્ટ દ્વારા બનાવેલા કોડની જેમ જ ચકાસણીને પાત્ર છે.
- ફક્ત ધ્વજ જ નહીં, પણ સુધારા માટે માણસને લૂપમાં રાખો. એક ડેવલપર જે જોઈ શકે છે કે કોઈ વસ્તુ શા માટે શોષણક્ષમ છે, ફક્ત એટલું જ નહીં કે તેણે કોઈ નિયમ શરૂ કર્યો, તે ખરેખર આગલી વખતે અલગ રીતે પૂછવાનું અને સમીક્ષા કરવાનું શીખે છે.
- ધારો કે "તે કામ કરે છે" એ ક્યારેય સુરક્ષા બાર નહોતો, અને વાસ્તવિક બારને મેમરીમાં છોડવાને બદલે વર્કફ્લોમાં દૃશ્યમાન બનાવો.
જ્યાં ઝાયજેની બંધબેસે છે
આ બરાબર સીમ છે ઝીજેની'સ ડેવએઆઈ બંધ કરવા માટે બનાવવામાં આવ્યું હતું. DevAI IDE ની અંદર સતત સુરક્ષા સ્તર તરીકે કાર્ય કરે છે, જે માનવ-લેખિત અને AI-જનરેટેડ કોડને ઉત્પન્ન થાય છે તે જુએ છે, તે લેન્ડ થયા પછી નહીં. pull request. તે કોઈ પ્રોમ્પ્ટની રાહ જોતો નથી: તે શોષણ કરી શકાય તેવા પેટર્નને ચિહ્નિત કરે છે, સાદી ભાષામાં વાસ્તવિક હુમલાના માર્ગને સમજાવે છે, અને એક એવો સુધારો પ્રસ્તાવિત કરે છે જેની વિકાસકર્તા સમીક્ષા કરી શકે છે અને તેમના પ્રવાહને છોડ્યા વિના લાગુ કરી શકે છે. સપ્લાય ચેઇન બાજુ પર, MEW (માલવેર પ્રારંભિક ચેતવણી) સહી અસ્તિત્વમાં આવે તે પહેલાં જ દૂષિત પેકેજો પકડી લે છે, જે અહીં સીધું મહત્વનું છે, કારણ કે કોઈ એજન્ટ તમારા વતી નિર્ભરતા પસંદ કરે છે તે જ ક્ષણે એક ઢાળેલું અથવા ચેડા કરાયેલ પેકેજ પ્રવેશ કરે છે.
બંનેની નીચે, CoreAI કોડબેઝ, ડિપેન્ડન્સી અને pipeline એક પ્રાથમિકતાવાળા જોખમ દૃશ્યમાં, અને તે દૃશ્ય મર્યાદિત નથી ક્ષયગેનીસ પોતાના સ્કેન. તે જ લાગુ પડે છે એઆઈ ટ્રાયજ, સમજૂતી, અને ઉપાય અન્ય સ્કેનરોમાંથી મળેલા તારણોને ધ્યાનમાં રાખીને જે પહેલાથી જ કાર્યરત છે, તેથી વાઇબ કોડિંગને સુરક્ષિત કરવાનો અર્થ એ નથી કે પહેલાથી જ કામ કરતા સ્ટેકને ફાડી નાખવો. તેનો અર્થ એ છે કે તેના પર એક સ્તર મૂકવો જે આખરે કોડ લખવાની ગતિએ આગળ વધે.
FAQ
શું વાઇબ કોડિંગ સ્વાભાવિક રીતે અસુરક્ષિત છે?
ના. વાઇબ કોડિંગ એક વિકાસ પદ્ધતિ છે, નબળાઈ નથી. જોખમ એ રીવ્યુ સ્ટેપને છોડી દેવાથી આવે છે જે પહેલા અસુરક્ષિત પેટર્ન પકડવા માટે વપરાય છે, શરૂઆતમાં કોડ લખવા માટે AI નો ઉપયોગ કરવાથી નહીં. એટલા માટે વાઇબ કોડિંગ સુરક્ષા એ વર્કફ્લો શિસ્ત છે, આ પ્રથા ટાળવાનું કારણ નથી.
અસ્તિત્વમાં છે SAST or SCA શું ટૂલ્સ વાઇબ કોડિંગ સુરક્ષા જોખમોને પકડી શકે છે?
તેઓ તેમાંથી કેટલાકને પકડી લે છે, પરંતુ સામાન્ય રીતે કોડ પહેલાથી જ મર્જ થઈ ગયા પછી, કારણ કે મોટાભાગના IDE ની અંદર નહીં પણ CI માં ચાલે છે જ્યાં કોડ જનરેટ થાય છે. તેઓ સામાન્ય રીતે AI એજન્ટના પોતાના વર્તનનું મૂલ્યાંકન પણ કરતા નથી, જેમ કે તે પસંદ કરેલા પેકેજો અથવા તે વાંચતી ગોઠવણી ફાઇલો.
વાઇબ કોડિંગ સુરક્ષા માટે સૌથી વધુ લીવરેજ ફિક્સ શું છે?
ફક્ત પછીના પર આધાર રાખવાને બદલે, જનરેશનના સમયે સુરક્ષા તપાસને IDE માં ખસેડો pipeline સ્કેન. કોઈ સમસ્યા તેના પર બનેલી આગામી ત્રણ સુવિધાઓનો ભાગ બને તે પહેલાં તેને પકડી લેવી એ પછીથી તેને પકડવા કરતાં અલગ સમસ્યા છે.
શું વાઇબ કોડિંગ સુરક્ષિત કરવાનો અર્થ વિકાસકર્તાઓને ધીમું કરવાનો છે?
જો ચેક ઇનલાઇન, IDE માં, સમજૂતી અને તૈયાર સુધારા સાથે થાય તો નહીં. ધ્યેય એ છે કે સ્પીડ વાઇબ કોડિંગ ઓફર કરે છે તે જાળવી રાખીને મેન્યુઅલ સમીક્ષા દ્વારા આપવામાં આવતા નિર્ણયને પુનઃસ્થાપિત કરવામાં આવે.
