నేను ఒక AI సెక్యూరిటీ స్కానర్ను నిర్మించాను — ఆ తర్వాత నా స్వంత డిటెక్టర్లోనే ఒక బగ్ కనుగొన్నాను
Prompt injection అనేది LLM అప్లికేషన్లకు ఒక ప్రధాన భద్రతా ముప్పు (security risk). మీరు ఒక మోడల్కు దాని అసలు సూచనలను విస్మరించమని చెప్పే టెక్స్ట్ను అందిస్తారు. కొన్నిసార్లు, ఆ మోడల్ దానికి లొంగిపోతుంది.
దీనిని పరీక్షించడానికి నేను AgentProbeను నిర్మించాను. ఇది jailbreaks మరియు data extraction వంటి 8 కేటగిరీలలో 49 అటాక్ ప్రాంప్ట్లను పంపిస్తుంది. ఒక మోడల్ ఎంత తరచుగా విఫలమవుతుందో ఇది నివేదిస్తుంది.
అసలైన పాఠం స్కానర్ గురించి కాదు. అది నా డిటెక్షన్ కోడ్లో ఉన్న ఒక బగ్ గురించి.
కష్టమైన భాగం అటాక్ చేయడం కాదు. కష్టమైన భాగం డిటెక్షన్ చేయడం.
ఒక మోడల్ నిజంగా అటాక్కు లొంగిపోయిందో లేదో మీకు ఎలా తెలుస్తుంది? Keyword matching అనేది సులభమైన పద్ధతి. మీరు "I cannot help" వంటి తిరస్కరించే పదబంధాలను (refusal phrases) లేదా "developer mode" వంటి లొంగిపోయే పదబంధాలను (compliance phrases) వెతుకుతారు.
కానీ మోడల్స్ "hedge-then-comply" పద్ధతిని ఉపయోగిస్తాయి. అవి "I cannot help with that" అని చెబుతాయి, కానీ ఆ తర్వాత నిషేధించబడిన సమాచారాన్ని కూడా అందిస్తాయి. ఇక్కడ refusal phrase ఉన్నందున keyword matching విఫలమవుతుంది.
దీనిని పరిష్కరించడానికి, నేను "LLM-as-judge" సిస్టమ్ను ఉపయోగించాను. టార్గెట్ మోడల్ నిజంగా లొంగిపోయిందో లేదో నిర్ణయించడానికి నేను ఆ సంభాషణను ఒక శక్తివంతమైన మోడల్కు పంపాను. మొదట తక్కువ ఖర్చుతో కూడిన keyword checks ఉపయోగించి, keyword check అస్పష్టంగా ఉన్నప్పుడు మాత్రమే ఖరీదైన judgeను ఉపయోగించాలని నా ప్రణాళిక.
అప్పుడే నేను నా బగ్ను కనుగొన్నాను.
నా keyword detector "hedge-then-comply" ప్యాటర్న్ను కనుగొన్నప్పుడు confidence score 1ని ఇచ్చింది. అయితే, నా కోడ్ confidence 2 లేదా అంతకంటే ఎక్కువగా ఉంటేనే keyword stageను నమ్మేలా ఉంది.
దీని అర్థం నా "చౌకైన" డిటెక్టర్ నిజానికి ఎప్పుడూ నిర్ణయం తీసుకోలేదు. ప్రతి కేసు ఖరీదైన judge వద్దకే వెళ్ళింది. నా ఉచిత సాధనం (free tool) పరిష్కరించాల్సిన సందర్భాల్లో కూడా, నేను ప్రతి కేసు కోసం judge కోసం డబ్బు చెల్లిస్తున్నాను.
ఇతర LLMలను గ్రేడ్ చేయడానికి LLMలను ఉపయోగించడం గురించి ఈ తప్పు నాకు మూడు పాఠాలను నేర్పింది:
- Judge అనేది టార్గెట్ మోడల్ కంటే తెలివైనదిగా ఉండాలి. ఒకవేళ judge మరియు టార్గెట్ ఒకే పరిమాణంలో ఉంటే, రెండింటికీ ఒకే రకమైన లోపాలు (blind spots) ఉంటాయి.
- ఖచ్చితత్వం (Accuracy) మోసం చేయవచ్చు. చాలా మోడల్స్ తిరస్కరిస్తే, ఎప్పుడూ "refused" అని చెప్పే judge ఖచ్చితంగా కనిపిస్తుంది కానీ అది ఏమీ నేర్చుకోదు. అదృష్టాన్ని (luck) పరిగణనలోకి తీసుకోవడానికి Cohen's kappa వంటి మెట్రిక్స్ను ఉపయోగించండి.
- Judge స్థిరంగా (stable) ఉండాలి. ఒకే పరీక్షను ఐదుసార్లు నిర్వహించండి. ఒకవేళ judge తన నిర్ణయాన్ని మార్చుకుంటే, ఆ ఫలితం అస్పష్టంగా ఉన్నట్లు మరియు దానికి మానవ పరిశీలన అవసరమని అర్థం.
మీరు LLMలతో నిర్మిస్తుంటే, ఈ అంశాలను గుర్తుంచుకోండి:
- లొంగిపోవడాన్ని (compliance) ప్రేరేపించడం కంటే, అది జరిగిందో లేదో గుర్తించడం (detecting) కష్టం.
- మొదటి వాక్యంలో తిరస్కరించి, రెండో వాక్యంలో లొంగిపోయే మోడల్స్ పట్ల జాగ్రత్తగా ఉండండి.
- LLM judgeను గుడ్డిగా నమ్మకండి. దాని విశ్వసనీయతను (reliability) కొలవండి.
- మీ బగ్లను పంచుకోండి. నా స్వంత లోపాన్ని కనుగొనడం, ఒక పరిపూర్ణమైన లాంచ్ (perfect launch) కంటే నాకు ఎక్కువ నేర్పింది.
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