કોડ વેરિફિકેશન, નબળાઈઓ અને AI આઉટપુટના જોખમો

નફો:

• AI આઉટપુટને ત્રણ સ્તરો પર ચકાસવાની ક્ષમતા: ચોકસાઈ, સુરક્ષા અને સ્ત્રોત/લાઈસન્સ
• ઈન્જેક્શન, ભ્રમણા પેકેજો અને સલામત મોલ્ડ અને સાધનો સાથે દફનાવવામાં આવેલા રહસ્યો જેવા જોખમોને આવરી લેવાની ક્ષમતા
• સક્ષમ એન્જિનિયરની મંજૂરી માટે સુરક્ષા-નિર્ણાયક કોડ રજૂ કરવાની ક્ષમતા અને જવાબદારીની બિન-તબદીલીને સમજવાની ક્ષમતા

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

અહીં આપણે ત્રણ સ્તરો પર "માન્યતા" ને ધ્યાનમાં લઈએ છીએ: શુદ્ધતા (શું કોડ ખરેખર કામ કરે છે?), સુરક્ષા (શું તે દૂષિત ઇનપુટનો સામનો કરે છે?), અને ઉત્પત્તિ/લાઈસન્સ (શું મને આ કોડનો ઉપયોગ કરવાનો અધિકાર છે?). દરેક સ્તરના નિયંત્રણના તેના પોતાના માધ્યમો હોય છે, અને તેમાંથી કોઈને પણ "એઆઈએ કહ્યું તે જ" સાથે બાયપાસ કરી શકાતું નથી.

જોખમના ત્રણ સ્તરો

1. ચોકસાઈનું જોખમ (આભાસ). મોડેલ અસ્તિત્વમાં ન હોય તેવા ફંક્શનને કૉલ કરી શકે છે, API નો દુરુપયોગ કરી શકે છે, ચુપચાપ એજ કેસને બાયપાસ કરી શકે છે. કોડ "વાજબી" લાગે છે પરંતુ ખોટો છે. મારણ: સંકલન, પરીક્ષણ, સ્થિર વિશ્લેષણ અને દ્રશ્ય નિરીક્ષણ.

2. સુરક્ષા જોખમ. AI પ્રશિક્ષણ ડેટામાં અસુરક્ષિત પેટર્નને પુનરાવર્તિત કરી શકે છે: SQL ઇન્જેક્શન, અનધિકૃત વપરાશકર્તા ઇનપુટ, નબળા એન્ક્રિપ્શન, અસુરક્ષિત ડીસીરિયલાઇઝેશન, ઓપન રીડાયરેશન માટે સંવેદનશીલ ક્વેરી. કોડ કામ કરે છે પરંતુ હુમલા માટે સંવેદનશીલ છે. મારણ: સુરક્ષા-કેન્દ્રિત સમીક્ષા, સ્વયંસંચાલિત સ્કેનર્સ (SAST), અને જાણીતી સુરક્ષિત પેટર્ન લાદવી.

3. સ્ત્રોત/લાઈસન્સ જોખમ. AI આઉટપુટ ઉત્પન્ન કરી શકે છે જે કૉપિરાઇટ કરેલા અથવા પ્રતિબંધિત લાઇસન્સવાળા કોડને નજીકથી મળતા આવે છે, અથવા તે અયોગ્ય રીતે લાઇસન્સવાળી નિર્ભરતા સૂચવી શકે છે. મારણ: નિર્ભરતા અને લાઇસન્સ તપાસ, મૌલિકતા તપાસ, કોર્પોરેટ નીતિ.

સાવધાન: આ ત્રણ જોખમોમાં સૌથી કપટી છે સુરક્ષા; કારણ કે કોડ પરીક્ષણ પાસ કરી શકે છે, ઉત્પાદનમાં સરળતાથી ચાલી શકે છે અને જ્યારે હુમલાખોર તેને શોધે ત્યારે જ નબળાઈ જાહેર થાય છે. "કામ કરવું" એ "સુરક્ષિત" જેવું નથી.

સ્ટેપ બાય સ્ટેપ: લેયર્ડ ઓથેન્ટિકેશન ગેટ

1. સમજણ સાથે વાંચો. કોડને સ્વીકારતા પહેલા ખરેખર સમજો; તમે સમજી શકતા નથી તેવા કોડને મર્જ કરશો નહીં. જો તમે "તે શા માટે કામ કરે છે" તે સમજાવી શકતા નથી, તો તે હજુ સુધી માન્ય કરવામાં આવ્યું નથી.
2. ચકાસો કે તે અસ્તિત્વમાં છે. ખાતરી કરો કે વપરાયેલ દરેક ફંક્શન, API અને પેકેજ વાસ્તવમાં અસ્તિત્વમાં છે અને તેનો યોગ્ય રીતે ઉપયોગ કરવામાં આવ્યો છે (આભાસ ગેટ).
3. સ્વચાલિત સાધનો ચલાવો. કમ્પાઇલર, લિંટર (શૈલી/એરર સ્કેનર), ટાઇપ ચેકર, યુનિટ ટેસ્ટ અને જો શક્ય હોય તો SAST (સ્ટેટિક એપ્લીકેશન સિક્યુરિટી ટેસ્ટિંગ — ટૂલ જે નબળાઈઓ માટે સોર્સ કોડ સ્કેન કરે છે).
4. તેને સુરક્ષાના દૃષ્ટિકોણથી જુઓ. શું ઇનપુટ માન્ય છે? શું ક્વેરી પેરામીટરાઇઝ્ડ છે? શું રહસ્ય દફનાવવામાં આવ્યું છે? શું અધિકૃતતા નિયંત્રણ છે?
5. સ્ત્રોત અને લાઇસન્સ તપાસો. શું નવી અવલંબન લાઇસન્સ છે? શું આઉટપુટ જાણીતા કોડબેઝ જેવું જ દેખાય છે?
6. જો તે સુરક્ષા માટે મહત્વપૂર્ણ છે, તો નિષ્ણાતની મંજૂરી માટે પૂછો. પ્રમાણીકરણ, ચુકવણી, ક્રિપ્ટોગ્રાફી, એક્સેસ કંટ્રોલ જેવા ક્ષેત્રોમાં સક્ષમ એન્જિનિયર દ્વારા સ્વતંત્ર સમીક્ષા ફરજિયાત છે.

ત્રણ મિની કેસ

કેસ 1 - એસક્યુએલ ઇન્જેક્શન ઇન્સ્પેક્શન ગેટ પર પકડાયું. AI જનરેટેડ કોડ કે જે સર્ચ એન્ડપોઇન્ટ ("... WHERE name = '" + q + "'") માટે સીધા જ એસક્યુએલ ક્વેરી સાથે યુઝર ઇનપુટને જોડે છે. કોડ કામ કરતો હતો અને પરીક્ષા પાસ કરી. સુરક્ષા-કેન્દ્રિત નિરીક્ષણ અને SAST સ્કેનીંગે આ પકડ્યું; તેને પેરામીટરાઇઝ્ડ ક્વેરી (તૈયાર નિવેદન)માં રૂપાંતરિત કરવામાં આવ્યું હતું. જો તે પકડાયો ન હોત, તો તે ક્લાસિક ડેટા લીક નબળાઈ બની હોત.

કેસ 2 - આભાસ પેકેજ. AI એ કાર્ય માટે અવિદ્યમાન npm પેકેજ (ફાસ્ટ-સેફ-પાર્સ) સૂચવ્યું. જ્યારે વિકાસકર્તાએ તેને ઇન્સ્ટોલ કરવાનો પ્રયાસ કર્યો, ત્યારે પેકેજ મળ્યું ન હતું. ખરાબ: કેટલાક કિસ્સાઓમાં, હુમલાખોરો આવા "ભૂત" પેકેજ નામોને વાસ્તવિક, દૂષિત પેકેજો (નિર્ભરતા મૂંઝવણ) સાથે ભરી શકે છે. પાઠ: અધિકૃત રજિસ્ટ્રી અને ડાઉનલોડ/જાળવણી ઇતિહાસ સામે ભલામણ કરેલ દરેક પેકેજની ચકાસણી કરો.

કેસ 3 - લાઇસન્સ અસંગતતા. AI દ્વારા સૂચવવામાં આવેલી નિફ્ટી સાથી લાઇબ્રેરીમાં મજબૂત કોપીલેફ્ટ લાઇસન્સ હતું જે સંસ્થાના ઉત્પાદન લાયસન્સ સાથે અસંગત હતું. નિર્ભરતા લાયસન્સ સ્કેન આની જાણ કરે છે; ટીમે યોગ્ય વિકલ્પ સાથે લાઇસન્સ બદલ્યું. ચકાસણી વિના, ઉત્પાદન વિતરણમાં કાનૂની બોજ ઊભો થશે.

ચાર નકલ કરી શકાય તેવા નમૂનાઓ

પ્રવેશ પૂર્વે સ્વ-તપાસ:

નીચેના AI જનરેટેડ કોડને સ્વીકારતા પહેલા, તપાસો: 1) શું તેનો ઉપયોગ કરે છે તે દરેક ફંક્શન/API/પેકેજ ખરેખર અસ્તિત્વમાં છે? શંકાસ્પદોને ધ્વજાંકિત કરો.2) શું કોઈ અમાન્ય ઇનપુટ, SQL/કમાન્ડ જોડાણ, દફનાવવામાં આવેલા ગુપ્ત, નબળા ક્રિપ્ટો છે? 3) અસંબોધિત બગ્સ/એજ કેસ શું છે? દરેક શોધને "ચોક્કસ/સંભવિત" તરીકે લેબલ કરો અને સુધારાઓ સૂચવો.{{code}}

સુરક્ષા કેન્દ્રિત સમીક્ષા:

સુરક્ષા આંખ સાથે આ કોડની તપાસ કરો. સામાન્ય OWASP શૈલીની નબળાઈઓ માટે જુઓ: ઈન્જેક્શન, તૂટેલા પ્રમાણીકરણ/અધિકૃતતા, સંવેદનશીલ ડેટા ડિસ્ક્લોઝર, અસુરક્ષિત ડીસીરિયલાઈઝેશન, અપ્રમાણિત રીડાયરેક્શન. દરેક શોધ માટે: જોખમ, શોષણનું દૃશ્ય, ઉપાય. આ પ્રારંભિક તપાસ છે; માનવ સુરક્ષા સમીક્ષા માટે મહત્વપૂર્ણ તારણોનો સંદર્ભ લો.{{code}}

નિર્ભરતા અને લાઇસન્સ તપાસ:

આ કોડ દ્વારા ઉમેરવામાં આવેલ/સૂચવેલ નિર્ભરતાઓની સૂચિ બનાવો. દરેક માટે: શું પેકેજ વાસ્તવમાં અસ્તિત્વમાં છે, શું તે જાળવવામાં આવે છે, તેનું લાક્ષણિક લાઇસન્સ શું હશે (ચકાસાયેલ હોવું જોઈએ), અને શું તે ખરેખર પ્રોજેક્ટ માટે જરૂરી છે અથવા તે હાલના ટૂલ વડે કરી શકાય છે?{{code or dependency list}}

સુરક્ષિત ફોર્મવર્ક લાદવું (ઉત્પાદનમાં):

{{task}} માટે કોડ લખો. ફરજિયાત સુરક્ષા નિયમો:- તમામ બાહ્ય ઇનપુટને માન્ય/સેનિટાઇઝ કરો.- ડેટાબેઝ એક્સેસમાં માત્ર પેરામીટરાઇઝ્ડ ક્વેરીનો ઉપયોગ કરો.- કોડમાં રહસ્યો એમ્બેડ કરશો નહીં; એન્વાયર્નમેન્ટ વેરીએબલ/સિક્રેટ મેનેજર ધારો - ભૂલો ગળી જશો નહીં; તેનો અર્થપૂર્ણ વિચાર કરો. 3 વસ્તુઓમાં કોડ આ નિયમોનું કેવી રીતે પાલન કરે છે તે સમજાવો.

નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ

નબળા: "યુઝરનેમ દ્વારા શોધતી ક્વેરી લખો." (ઇન્જેક્શન માટે સંવેદનશીલ કોડ આવી શકે છે.)

સશક્ત: "એક ફંક્શન લખો જે વપરાશકર્તાનામ દ્વારા શોધે છે. વપરાશકર્તાના ઇનપુટને ક્વેરીમાં સ્ટ્રિંગ તરીકે ક્યારેય જોડશો નહીં; પેરામીટરાઇઝ્ડ ક્વેરી (તૈયાર નિવેદન) નો ઉપયોગ કરો. લંબાઈ અને અક્ષર માટે ઇનપુટને માન્ય કરો. 2 વાક્યોમાં સમજાવો કે કોડ ઇન્જેક્શન માટે કેમ બંધ છે."

મજબૂત સંસ્કરણ શરૂઆતથી સુરક્ષિત પેટર્ન લાદે છે; આમ, તે સુનિશ્ચિત કરે છે કે તે પછીથી પકડવાને બદલે નબળાઈ બિલકુલ ન થાય. જો કે, વેરિફિકેશન ગેટ દ્વારા જનરેટ થયેલ કોડ પસાર કરવો જરૂરી છે.

પ્રમાણીકરણ સ્તર

સાધન/પદ્ધતિ

શું "AI કહ્યું" પૂરતું છે?

ચોકસાઈ

સંકલન, પરીક્ષણ, દ્રશ્ય નિરીક્ષણ

ના

API/પેકેજ વાસ્તવિકતા

સત્તાવાર દસ્તાવેજ/રેકોર્ડ નિયંત્રણ

ના

સુરક્ષા

SAST, સુરક્ષા સમીક્ષા

ના

લાઇસન્સ/સ્રોત

અવલંબન અને લાઇસન્સ તપાસ

ના

સુરક્ષા-નિર્ણાયક તર્ક

નિષ્ણાત એન્જિનિયરની મંજૂરી

બિલકુલ નહિ

જવાબદારી ટ્રાન્સફર કરી શકાતી નથી

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

ટીપ: તમારી ટીમ પર એક ટૂંકી ચેકલિસ્ટ બનાવો જેને તમે "AI-જનરેટેડ કોડ માટે માન્યતા ગેટ" કહો છો (બિલ્ડ + ટેસ્ટ + સિક્યુરિટી સ્કેન + વિઝ્યુઅલ ઇન્સ્પેક્શન). એકવાર આ દરવાજો આદત બની જાય પછી, ઝડપનું નુકસાન ન્યૂનતમ અને જોખમમાં ઘટાડો મહત્તમ છે.

સામાન્ય ભૂલો

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

સારાંશમાં

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

એપ્લિકેશન કાર્ય

આ વખતે સલામત પેટર્ન લાદ્યા વિના AI ને જાણીજોઈને સુરક્ષા-સંવેદનશીલ કાર્ય આપો (દા.ત. "એક કાર્ય જે વપરાશકર્તાના ઇનપુટ સાથે ડેટાબેઝને શોધે છે"). ઇનકમિંગ કોડને "પ્રી-એડમિશન સેલ્ફ-ઓડિટ" અને "સિક્યોરિટી-ફોકસ્ડ રિવ્યુ" ટેમ્પ્લેટ્સ દ્વારા પાસ કરો: શું ત્યાં કોઈ ઇન્જેક્શન, દફનાવવામાં આવેલ ગુપ્ત, ભ્રામક પેકેટ અથવા અપ્રમાણિત ઇનપુટ છે? પછી "સુરક્ષિત પેટર્ન ઇમ્પોઝિશન" ટેમ્પ્લેટ સાથે તે જ કાર્યને ફરીથી પૂછો અને બે આઉટપુટની તુલના કરો. જો શક્ય હોય તો, લિંટર/SAST ટૂલ ચલાવો અને AI ના સ્વ-નિયમન સાથે તારણોની તુલના કરો.

ચેકલિસ્ટ

• [ ] હું ત્રણ સ્તરો પર AI આઉટપુટની ચકાસણી કરું છું: ચોકસાઈ, સુરક્ષા અને લાઇસન્સ.
• [ ] હું પુષ્ટિ કરું છું કે વપરાયેલ દરેક ફંક્શન, API અને પેકેજ ખરેખર અસ્તિત્વમાં છે.
• [ ] હું કમ્પાઇલ, ટેસ્ટ, લિંટર અને, જો શક્ય હોય તો, SAST ટૂલ્સ ચલાવું છું.
• [ ] હું શરૂઆતથી સુરક્ષિત પેટર્ન (પેરામીટરાઇઝ્ડ ક્વેરી, ઇનપુટ માન્યતા, ગુપ્ત વ્યવસ્થાપન) લાદું છું.
• [ ] હું નવી અવલંબન માટે લાયસન્સ અને જરૂરિયાત તપાસું છું.
• [ ] હું સક્ષમ એન્જિનિયર દ્વારા મંજૂરી માટે સુરક્ષા-નિર્ણાયક કોડ સબમિટ કરી રહ્યો છું અને હું સમજું છું કે હું જવાબદાર છું.