డెవలపర్‌కు కనిపించని కోడ్‌లో మార్పులను పరిచయం చేయడానికి ట్రోజన్ సోర్స్ దాడి

కేంబ్రిడ్జ్ విశ్వవిద్యాలయానికి చెందిన పరిశోధకులు పీర్-రివ్యూడ్ సోర్స్ కోడ్‌లో హానికరమైన కోడ్‌ను నిశ్శబ్దంగా చొప్పించే సాంకేతికతను ప్రచురించారు. సిద్ధం చేసిన దాడి పద్ధతి (CVE-2021-42574) ట్రోజన్ సోర్స్ పేరుతో ప్రదర్శించబడుతుంది మరియు కంపైలర్/వ్యాఖ్యాత మరియు కోడ్‌ని వీక్షించే వ్యక్తికి భిన్నంగా కనిపించే టెక్స్ట్ నిర్మాణంపై ఆధారపడి ఉంటుంది. C, C++ (gcc మరియు క్లాంగ్), C#, JavaScript (Node.js), Java (OpenJDK 16), రస్ట్, గో మరియు పైథాన్‌లకు సరఫరా చేయబడిన వివిధ కంపైలర్‌లు మరియు వ్యాఖ్యాతల కోసం ఈ పద్ధతి యొక్క ఉదాహరణలు ప్రదర్శించబడ్డాయి.

ద్వి దిశాత్మక వచనం యొక్క ప్రదర్శన క్రమాన్ని మార్చే కోడ్ వ్యాఖ్యలలో ప్రత్యేక యూనికోడ్ అక్షరాలను ఉపయోగించడంపై పద్ధతి ఆధారపడి ఉంటుంది. అటువంటి నియంత్రణ అక్షరాల సహాయంతో, టెక్స్ట్ యొక్క కొన్ని భాగాలు ఎడమ నుండి కుడికి ప్రదర్శించబడతాయి, మరికొన్ని - కుడి నుండి ఎడమకు. రోజువారీ ఆచరణలో, అటువంటి నియంత్రణ అక్షరాలను ఉపయోగించవచ్చు, ఉదాహరణకు, హీబ్రూ లేదా అరబిక్‌లోని కోడ్ లైన్‌లను ఫైల్‌లోకి చొప్పించడానికి. కానీ మీరు ఒక లైన్‌లో వేర్వేరు వచన దిశలతో పంక్తులను మిళితం చేస్తే, పేర్కొన్న అక్షరాలను ఉపయోగించి, కుడి నుండి ఎడమకు ప్రదర్శించబడే టెక్స్ట్ యొక్క గద్యాలై ఎడమ నుండి కుడికి ప్రదర్శించబడే ప్రస్తుత సాధారణ వచనాన్ని అతివ్యాప్తి చేయవచ్చు.

ఈ పద్ధతిని ఉపయోగించి, మీరు కోడ్‌కు హానికరమైన నిర్మాణాన్ని జోడించవచ్చు, అయితే కోడ్‌ను వీక్షించేటప్పుడు ఈ నిర్మాణంతో ఉన్న వచనాన్ని కనిపించకుండా చేయండి, కింది వ్యాఖ్యలో లేదా కుడి నుండి ఎడమకు చూపిన అక్షరార్థ అక్షరాల లోపల జోడించడం ద్వారా, ఇది పూర్తిగా దారి తీస్తుంది హానికరమైన చొప్పించడంపై విభిన్న అక్షరాలు అతిక్రమించబడ్డాయి. ఇటువంటి కోడ్ అర్థపరంగా సరైనది, కానీ విభిన్నంగా అన్వయించబడుతుంది మరియు ప్రదర్శించబడుతుంది.

కోడ్‌ని సమీక్షిస్తున్నప్పుడు, డెవలపర్‌కు అక్షరాల దృశ్యమాన క్రమాన్ని ఎదుర్కొంటారు మరియు ఆధునిక టెక్స్ట్ ఎడిటర్, వెబ్ ఇంటర్‌ఫేస్ లేదా IDEలో అనుమానాస్పద వ్యాఖ్యను చూస్తారు, అయితే కంపైలర్ మరియు ఇంటర్‌ప్రెటర్ అక్షరాల తార్కిక క్రమాన్ని ఉపయోగిస్తారు మరియు వ్యాఖ్యలలోని ద్వి దిశాత్మక వచనంపై దృష్టి పెట్టకుండా, హానికరమైన చొప్పింపును అలాగే ప్రాసెస్ చేయండి. సమస్య వివిధ ప్రసిద్ధ కోడ్ ఎడిటర్‌లను (VS కోడ్, ఇమాక్స్, ఆటమ్), అలాగే రిపోజిటరీలలో (GitHub, Gitlab, BitBucket మరియు అన్ని అట్లాసియన్ ఉత్పత్తులు) కోడ్‌ని వీక్షించడానికి ఇంటర్‌ఫేస్‌లను ప్రభావితం చేస్తుంది.

హానికరమైన చర్యలను అమలు చేయడానికి పద్ధతిని ఉపయోగించడానికి అనేక మార్గాలు ఉన్నాయి: దాచిన "రిటర్న్" వ్యక్తీకరణను జోడించడం, ఇది సమయానికి ముందే ఫంక్షన్ పూర్తి చేయడానికి దారితీస్తుంది; సాధారణంగా చెల్లుబాటు అయ్యే నిర్మాణాలుగా కనిపించే వ్యక్తీకరణలను వ్యాఖ్యానించడం (ఉదాహరణకు, ముఖ్యమైన తనిఖీలను నిలిపివేయడం); స్ట్రింగ్ ధ్రువీకరణ వైఫల్యాలకు దారితీసే ఇతర స్ట్రింగ్ విలువలను కేటాయించడం.

ఉదాహరణకు, దాడి చేసే వ్యక్తి ఈ లైన్‌ను కలిగి ఉన్న మార్పును ప్రతిపాదించవచ్చు: if access_level != "user{U+202E} {U+2066}// అడ్మిన్{U+2069} {U+2066} అని తనిఖీ చేయండి" {

ఇది రివ్యూ ఇంటర్‌ఫేస్‌లో access_level లాగా ప్రదర్శించబడుతుంది != “user” { // అడ్మిన్ కాదా అని తనిఖీ చేయండి

అదనంగా, మరొక దాడి రూపాంతరం ప్రతిపాదించబడింది (CVE-2021-42694), హోమోగ్లిఫ్‌ల వాడకంతో అనుబంధించబడింది, రూపాన్ని పోలి ఉండే అక్షరాలు, కానీ అర్థంలో విభిన్నంగా ఉంటాయి మరియు విభిన్న యూనికోడ్ కోడ్‌లను కలిగి ఉంటాయి (ఉదాహరణకు, “ɑ” అక్షరం “ని పోలి ఉంటుంది. a”, “ɡ” - “g”, “ɩ” - “l”). డెవలపర్‌లను తప్పుదారి పట్టించడానికి ఫంక్షన్‌లు మరియు వేరియబుల్స్ పేర్లలో ఇలాంటి అక్షరాలు కొన్ని భాషల్లో ఉపయోగించబడతాయి. ఉదాహరణకు, వేరు చేయలేని పేర్లతో రెండు విధులు వేర్వేరు చర్యలను నిర్వచించవచ్చు. వివరణాత్మక విశ్లేషణ లేకుండా, ఈ రెండు ఫంక్షన్లలో ఏది నిర్దిష్ట ప్రదేశంలో పిలువబడుతుందో వెంటనే స్పష్టంగా తెలియదు.

భద్రతా చర్యగా, యూనికోడ్ అక్షరాలకు మద్దతిచ్చే కంపైలర్‌లు, ఇంటర్‌ప్రెటర్‌లు మరియు అసెంబ్లీ సాధనాలు కామెంట్‌లు, స్ట్రింగ్ లిటరల్స్ లేదా అవుట్‌పుట్ దిశను మార్చే ఐడెంటిఫైయర్‌లలో జత చేయని నియంత్రణ అక్షరాలు ఉంటే లోపం లేదా హెచ్చరికను ప్రదర్శించాలని సిఫార్సు చేయబడింది (U+202A, U+202B, U +202C, U+202D, U+202E, U+2066, U+2067, U+2068, U+2069, U+061C, U+200E మరియు U+200F). ఇటువంటి అక్షరాలు ప్రోగ్రామింగ్ లాంగ్వేజ్ స్పెసిఫికేషన్‌లలో కూడా స్పష్టంగా నిషేధించబడాలి మరియు కోడ్ ఎడిటర్‌లు మరియు రిపోజిటరీ ఇంటర్‌ఫేస్‌లలో గౌరవించబడాలి.

అనుబంధం 1: GCC, LLVM/Clang, Rust, Go, Python మరియు binutils కోసం వల్నరబిలిటీ ప్యాచ్‌లు సిద్ధం చేయబడ్డాయి. GitHub, Bitbucket మరియు Jira కూడా సమస్యను పరిష్కరించాయి. GitLab కోసం పరిష్కారం ప్రోగ్రెస్‌లో ఉంది. సమస్యాత్మక కోడ్‌ని గుర్తించడానికి, ఆదేశాన్ని ఉపయోగించమని సూచించబడింది: grep -r $'[\u061C\u200E\u200F\u202A\u202B\u202C\u202D\u202E\u2066\u2067\u2068\u2069\uXNUMX]' మూలం

అనుబంధం 2: ప్లాన్ 9 OS మరియు గో ప్రోగ్రామింగ్ లాంగ్వేజ్ డెవలపర్‌లలో ఒకరైన రస్ కాక్స్, వివరించిన దాడి పద్ధతిపై అధిక శ్రద్ధను విమర్శించాడు, ఇది చాలా కాలంగా తెలుసు (గో, రస్ట్, C++, రూబీ) మరియు దానిని తీవ్రంగా పరిగణించలేదు. . కాక్స్ ప్రకారం, సమస్య ప్రధానంగా కోడ్ ఎడిటర్‌లు మరియు వెబ్ ఇంటర్‌ఫేస్‌లలో సమాచారం యొక్క సరైన ప్రదర్శనకు సంబంధించినది, సమీక్ష సమయంలో సరైన సాధనాలు మరియు కోడ్ ఎనలైజర్‌లను ఉపయోగించడం ద్వారా దీనిని పరిష్కరించవచ్చు. అందువల్ల, ఊహాజనిత దాడులపై దృష్టిని ఆకర్షించే బదులు, కోడ్ మరియు డిపెండెన్సీ సమీక్ష ప్రక్రియలను మెరుగుపరచడంపై దృష్టి పెట్టడం మరింత సముచితంగా ఉంటుంది.

కంపైలర్ స్థాయిలో ప్రమాదకరమైన చిహ్నాలను నిషేధించడం ద్వారా కంపైలర్‌లు సరైన స్థలం కాదని రాస్ కాక్స్ విశ్వసించారు, ఎందుకంటే ఈ చిహ్నాల ఉపయోగం ఆమోదయోగ్యమైన బిల్డ్ సిస్టమ్‌లు, అసెంబ్లర్‌లు వంటి సాధనాల యొక్క భారీ పొర మిగిలి ఉంది. ప్యాకేజీ నిర్వాహకులు మరియు వివిధ కాన్ఫిగరేషన్ పార్సర్‌లు మరియు డేటా. ఒక ఉదాహరణగా, రస్ట్ ప్రాజెక్ట్ ఇవ్వబడింది, ఇది కంపైలర్‌లో LTR/RTL కోడ్‌ని ప్రాసెస్ చేయడాన్ని నిషేధించింది, కానీ కార్గో ప్యాకేజీ మేనేజర్‌కు పరిష్కారాన్ని జోడించలేదు, ఇది Cargo.toml ఫైల్ ద్వారా ఇదే విధమైన దాడిని అనుమతిస్తుంది. అదేవిధంగా, BUILD.bazel, CMakefile, Cargo.toml, Dockerfile, GNUmakefile, Makefile, go.mod, package.json, pom.xml మరియు requirements.txt వంటి ఫైల్‌లు దాడులకు మూలాలుగా మారవచ్చు.

మూలం: opennet.ru