Claude Code, Cursor మరియు Grok Build వంటి AI కోడింగ్ అసిస్టెంట్లు, డెవలపర్ నమ్మదగని రిపోజిటరీని (untrusted repository) ఓపెన్ చేసిన వెంటనే, ఎటువంటి క్లిక్ లేదా ప్రాంప్ట్ లేకుండానే ఏదైనా కమాండ్‌ను అమలు చేయగలవు. ఈ లోపం ప్రాజెక్ట్ ఫైల్‌లను స్కాన్ చేయడానికి ఈ టూల్స్ Git యొక్క core.fsmonitor ఫీచర్‌ను ఉపయోగించే విధానం వల్ల ఏర్పడుతుంది.

ఈ సమస్య ఇప్పుడు ఎందుకు ముఖ్యమైనది

కోడ్‌ను సూచించడానికి, ఫంక్షన్‌లను రీఫ్యాక్టర్ చేయడానికి లేదా పూర్తి మాడ్యూల్‌లను రాయడానికి కూడా డెవలపర్లు రోజురోజుకూ AI ఏజెంట్లపై ఆధారపడుతున్నారు. ఆ ఏజెంట్లకు వర్క్‌స్పేస్ యొక్క తక్షణ సమాచారం (snapshot) అవసరం, కాబట్టి అవి తెరవెనుక git statusను రన్ చేస్తాయి. Git ఒక రిపోజిటరీ యొక్క .git/config ఫైల్‌ను చదివినప్పుడు, core.fsmonitorకు కేటాయించిన ఏ విలువనైనా Git రన్ చేసే షెల్ కమాండ్‌గా పరిగణిస్తుంది. ఒక దుర్మార్గపు హ్యాకర్ (malicious actor) ఆ కాన్ఫిగరేషన్ ఎంట్రీలో ఒక కమాండ్‌ను ఉంచితే, యూజర్ ఒక్క లైన్ కోడ్ టైప్ చేయకముందే AI బ్యాక్‌గ్రౌండ్ Git కాల్ దానిని ట్రిగ్గర్ చేస్తుంది.

ఈ కోడ్ డెవలపర్ యొక్క స్వంత అధికారాలతో (privileges) రన్ అవుతుంది, దీనివల్ల AI ఏజెంట్ సాధారణంగా పనిచేసే సాండ్‌బాక్స్ (sandbox) బైపాస్ అవుతుంది. వాస్తవానికి, ఒక కంప్రమైజ్ అయిన రిపోజిటరీ మాల్వేర్‌ను ఇన్‌స్టాల్ చేయవచ్చు, క్రెడెన్షియల్స్‌ను దొంగిలించవచ్చు లేదా సోర్స్ ఫైల్‌లను మార్చవచ్చు; ఈ ప్రక్రియ అంతా డెవలపర్ కేవలం అసిస్టెంట్ సూచనలు ఇస్తున్నాడనే నమ్మకంతో జరుగుతుంది.

దాడి ఎలా జరుగుతుంది

  1. సిద్ధం చేయడం (Preparation) – ఒక అటాకర్ .git/configలో core.fsmonitor = /path/to/malicious/script వంటి లైన్ ఉండేలా ఒక రిపోజిటరీని సృష్టిస్తారు.
  2. చేరవేయడం (Delivery) – ఆ రిపోజిటరీని జిప్ ఫైల్‌గా పంపడం, USB స్టిక్ నుండి కాపీ చేయడం, షేర్డ్ డ్రైవ్ ద్వారా సింక్ చేయడం లేదా .git ఫోల్డర్ ఇప్పటికే ఉన్న విధంగా బాధితుడి మెషీన్‌పై ఉంచడం ద్వారా చేరవేస్తారు.
  3. ట్రిగ్గర్ (Trigger) – డెవలపర్ AI-సదుపాయం ఉన్న IDEలో ఆ ఫోల్డర్‌ను ఓపెన్ చేస్తారు. సందర్భాన్ని (context) సేకరించడానికి అసిస్టెంట్ git statusను రన్ చేస్తుంది. Git లోకల్ కాన్ఫిగరేషన్‌ను చదివి, core.fsmonitor కమాండ్‌ను అమలు చేస్తుంది, తద్వారా మాల్వేరియస్ స్క్రిప్ట్ వెంటనే రన్ అవుతుంది.

సాధారణ git clone వల్ల ఈ రిస్క్ ఉండదు, ఎందుకంటే క్లోన్ చేసినప్పుడు కొత్త .git డైరెక్టరీ సృష్టించబడుతుంది, అందులో మార్చబడిన కాన్ఫిగరేషన్ ఉండదు. అటాకర్ ముందే ఉన్న .git ఫోల్డర్‌ను అందించగలిగినప్పుడు మాత్రమే ఈ దాడి పనిచేస్తుంది.

దీని వల్ల కలిగే నష్టాలు

  • వ్యక్తిగత డెవలపర్లు (Individual developers) తమ మెషీన్‌లు కంప్రమైజ్ అయినట్లు తెలియకుండానే డేటాను కోల్పోవచ్చు.
  • టీమ్స్ (Teams) అంతర్గత డ్రైవ్‌లు లేదా కాంట్రాక్టర్ జిప్ ఫైల్‌ల ద్వారా కోడ్‌ను పంచుకున్నప్పుడు, ఈ మాల్వేర్ అనేక వర్క్‌స్టేషన్‌లకు వ్యాపించవచ్చు.
  • టూల్ వెండర్లు (Tool vendors) ఈ భద్రతా లోపం Git వల్ల కాకుండా AI అసిస్టెంట్ వల్ల జరిగిందని వినియోగదారులు భావిస్తే, వారి ప్రతిష్ట దెబ్బతినే ప్రమాదం ఉంది.

ఈ మాల్వేరియస్ కమాండ్ యూజర్ యొక్క అధికారాలను పొందుతుంది కాబట్టి, ఇది డెవలపర్ మార్చగలిగే SSH కీలు, బిల్డ్ స్క్రిప్ట్‌లు లేదా డిప్లాయ్‌మెంట్ క్రెడెన్షియల్స్‌తో సహా ఏ ఫైల్‌నైనా మార్చగలదు.

డెవలపర్లు ఈరోజు తీసుకోవలసిన జాగ్రత్తలు

  • లోకల్ Git సెట్టింగ్‌లను నమ్మవద్దు. AI అసిస్టెంట్ ప్రాజెక్ట్‌ను క్వెరీ చేసిన ప్రతిసారీ రిపోజిటరీ కాన్ఫిగరేషన్ గ్లోబల్ విలువలను ఓవర్‌రైడ్ చేస్తుంది.

  • అసిస్టెంట్‌తో ఫోల్డర్‌ను ఓపెన్ చేసే ముందు core.fsmonitor ఎంట్రీని తనిఖీ చేయండి: 

    git config --get core.fsmonitor

    ఏదైనా విలువ కనిపిస్తే, దానిని అనుమానాస్పదంగా పరిగణించండి.

  • ఈ కమాండ్‌తో ఎంట్రీని తొలగించండి: 

    git config --local --unset core.fsmonitor

  • Git అమలు చేయగల ఇతర రిస్క్ కీలను (risky keys) తనిఖీ చేయండి: hooksPath, sshCommand, pager, editor, filter. ఇవి ఖాళీగా ఉన్నాయో లేదో చూడటానికి అదే git config --get పద్ధతిని ఉపయోగించండి.

  • మీరు AI టూల్‌కు అందించాలనుకుంటున్న ఏ కోడ్‌కైనా క్లీన్ క్లోన్‌లను (clean clones) ప్రాధాన్యత ఇవ్వండి. మీరు జిప్ లేదా ట్రాన్స్‌ఫర్ చేయబడిన ఫోల్డర్‌తో పనిచేయాల్సి వస్తే, దాని .git డైరెక్టరీని తొలగించి రిపోజిటరీని మళ్ళీ ఇనిషియలైజ్ చేయండి లేదా పైన పేర్కొన్న తనిఖీలను ముందుగా చేయండి.

బాధ్యత ఎవరిది

ఈ లోపం Claude Code, Cursor లేదా Grok Build నడిపించే లాంగ్వేజ్ మోడల్స్‌లో ఉన్న లోపం కాదు; ఇది ఆ టూల్స్ ఫైల్ సమాచారాన్ని సేకరించే విధానం వల్ల కలిగే పరిణామం. కొన్ని వెండర్లు Git కాల్స్‌ను మరింత కఠినంగా సాండ్‌బాక్స్ చేయడం ప్రారంభించారు, కానీ డిఫాల్ట్ ప్రవర్తన ఇప్పటికీ లోకల్ రిపోజిటరీ సెట్టింగ్‌లను నమ్ముతుంది. AI ఏజెంట్ వర్క్‌స్పేస్‌ను స్కాన్ చేసేటప్పుడు ప్రమాదకరమైన కాన్ఫిగరేషన్ ఎంట్రీలను తొలగించే లేదా విస్మరించే ప్రమాణాన్ని (standard) పరిశ్రమ స్వీకరించే వరకు, డెవలపర్లు మాత్రమే చివరి రక్షణ కవచంగా ఉండాలి.

తదుపరి ఏం గమనించాలి

  • git statusను పిలవడానికి ముందు Git కాన్ఫిగరేషన్‌ను స్పష్టంగా క్లీన్ చేసే టూల్ అప్‌డేట్‌లు (Tool updates).
  • సురక్షితమైన AI-అసిస్టెడ్ డెవలప్‌మెంట్ కోసం కమ్యూనిటీ ఆధారిత మార్గదర్శకాలు (Community-driven guidelines), వీటిలో ముందస్తు తనిఖీలు (pre-flight checks) ఉండవచ్చు.
  • కోడ్ ఎగ్జిక్యూషన్‌కు కారణమయ్యే అదనపు Git కాన్ఫిగరేషన్ కీలను కనుగొనే సెక్యూరిటీ రీసెర్చ్ (Security research), ఇది పైన పేర్కొన్న ఐదు కీల కంటే ఎక్కువ జాబితాను విస్తరించవచ్చు.

క్లుప్తంగా చెప్పాలంటే: AI అసిస్టెంట్ ఒక సౌకర్యవంతమైన పేర్-ప్రోగ్రామర్ (pair-programmer) కావచ్చు, కానీ రిపోజిటరీ యొక్క Git కాన్ఫిగరేషన్‌లో దాగి ఉన్న ఏ కమాండ్‌నైనా అది సంతోషంగా రన్ చేస్తుంది. అసిస్టెంట్‌ను ఉపయోగించే ముందు వర్క్‌స్పేస్‌ను సరిచూసుకోండి.