મેં એક AI સિક્યુરિટી સ્કેનર બનાવ્યું — અને પછી મારા પોતાના ડિટેક્ટરમાં જ એક બગ (bug) શોધી કાઢ્યો

Prompt injection એ LLM એપ્લિકેશન્સ માટે એક મોટું સુરક્ષા જોખમ છે. તમે મોડેલને એવો ટેક્સ્ટ આપો છો જે તેને તેની મૂળ સૂચનાઓને અવગણવા માટે કહે છે. ક્યારેક, મોડેલ તે વાત માની લે છે.

આનું પરીક્ષણ કરવા માટે મેં AgentProbe બનાવ્યું. તે jailbreaks અને data extraction જેવી 8 કેટેગરીઓમાં 49 એટેક પ્રોમ્પ્ટ્સ મોકલે છે. તે રિપોર્ટ કરે છે કે મોડેલ કેટલી વાર નિષ્ફળ જાય છે.

સાચો પાઠ સ્કેનર વિશે નહોતો. તે મારા ડિટેક્શન કોડમાં રહેલો એક બગ હતો.

અઘરો ભાગ એટેક નથી. અઘરો ભાગ ડિટેક્શન છે.

તમને કેવી રીતે ખબર પડશે કે મોડેલે ખરેખર એટેકનું પાલન કર્યું છે? Keyword matching એ સરળ રસ્તો છે. તમે "I cannot help" જેવા અસ્વીકારના શબ્દો અથવા "developer mode" જેવા પાલન દર્શાવતા શબ્દો શોધો છો.

પરંતુ મોડેલ્સ "hedge-then-comply" પેટર્નનો ઉપયોગ કરે છે. તેઓ કહે છે "I cannot help with that," પરંતુ પછી પણ તેઓ પ્રતિબંધિત માહિતી પૂરી પાડે છે. અહીં keyword matching નિષ્ફળ જાય છે કારણ કે અસ્વીકારનું વાક્ય ત્યાં હાજર હોય છે.

આને સુધારવા માટે, મેં "LLM-as-judge" સિસ્ટમનો ઉપયોગ કર્યો. લક્ષ્ય મોડેલે ખરેખર પાલન કર્યું છે કે નહીં તે નક્કી કરવા માટે મેં તે વાતચીત એક વધુ શક્તિશાળી મોડેલ પાસે મોકલી. મારી યોજના સસ્તી keyword checks નો પહેલા ઉપયોગ કરવાની અને જ્યારે keyword check અનિશ્ચિત હોય ત્યારે જ મોંઘા judge નો ઉપયોગ કરવાની હતી.

પછી મને મારો બગ મળ્યો.

જ્યારે મારા keyword detector ને "hedge-then-comply" પેટર્ન મળી, ત્યારે તેણે 1 નો confidence score આપ્યો. જોકે, મારો કોડ keyword સ્ટેજ પર ત્યારે જ વિશ્વાસ કરતો હતો જો confidence 2 અથવા તેનાથી વધુ હોય.

આનો અર્થ એ થયો કે મારું "સસ્તું" ડિટેક્ટર ક્યારેય ખરેખર નિર્ણય લઈ શકતું નહોતું. દરેક કેસ મોંઘા judge પાસે મોકલવામાં આવતો હતો. હું દરેક કેસ માટે judge ને પેમેન્ટ કરી રહ્યો હતો, ભલે મારે મારા મફત ટૂલ દ્વારા તે હેન્ડલ કરી લેવું જોઈતું હતું.

આ ભૂલ મને અન્ય LLMs ને ગ્રેડ કરવા માટે LLMs નો ઉપયોગ કરવા વિશે ત્રણ પાઠ શીખવી ગઈ:

  • judge એ target કરતા વધુ સ્માર્ટ હોવો જોઈએ. જો judge અને target બંનેનું કદ સમાન હશે, તો તે બંનેમાં એક સરખા જ blind spots હશે.
  • ચોકસાઈ (Accuracy) જૂઠું બોલી શકે છે. જો મોટાભાગના મોડેલ્સ અસ્વીકાર કરે, તો હંમેશા "refused" કહેતો judge સચોટ લાગે છે પરંતુ તે કંઈ શીખતો નથી. નસીબના પરિબળોને ધ્યાનમાં લેવા માટે Cohen's kappa જેવા મેટ્રિક્સનો ઉપયોગ કરો.
  • judge સ્થિર હોવો જોઈએ. એક જ ટેસ્ટ પાંચ વાર ચલાવો. જો judge પોતાનો નિર્ણય બદલે, તો પરિણામ અસ્પષ્ટ છે અને તેમાં માનવીય નિરીક્ષણની જરૂર છે.

જો તમે LLMs સાથે કામ કરો છો, તો આ મુદ્દાઓ યાદ રાખો:

  • પાલન (compliance) કરાવવા કરતાં તેનું ડિટેક્શન કરવું વધુ અઘરું છે.
  • એવા મોડેલ્સ પર ધ્યાન આપો જે પ્રથમ વાક્યમાં અસ્વીકાર કરે છે પરંતુ બીજા વાક્યમાં પાલન કરે છે.
  • LLM judge પર આંધળો વિશ્વાસ ન કરો. તેની વિશ્વસનીયતા માપો.
  • તમારા બગ્સ શેર કરો. મારી પોતાની ખામી શોધવાથી મને એક સંપૂર્ણ લોન્ચ કરતા પણ વધુ શીખવા મળ્યું.

Source: https://dev.to/nar1frames/i-built-an-ai-security-scanner-then-found-a-bug-in-my-own-detector-140a

Optional learning community: https://t.me/GyaanSetuAi