ආකෘති නූල් දෝෂයක් යනු කුමක්ද සහ එය තවමත් වැදගත් වන්නේ ඇයි?
A පරිශීලක-පාලිත දත්ත ශ්රිතවල ආකෘති තන්තුව ලෙස ලබා දෙන විට ආකෘති තන්තු දෝෂය ඇතිවේ. printf, fprintf, හෝ syslog, වලංගුකරණයකින් තොරව.
සරළ ව, පරිශීලක ආදානය ආකෘතිකරණ සැකිල්ලක් ලෙස භාවිතා කරන විට ආකෘති තන්තු දෝෂයක් ඇති වන අතර එමඟින් මතකයේ අනපේක්ෂිත කියවීමට හෝ ලිවීමට ඉඩ සලසයි. මෙය විශේෂයෙන් භයානක වන්නේ C / C ++, ආකෘති විශේෂණකාරක කැමති තැන %s, %x, සහ %n ස්ටැක් දත්ත කෙලින්ම හැසිරවිය හැක.
නවීන DevSecOps වල මෙය වැදගත් වන්නේ ඇයි? මෙම දෝෂ තවමත් ක්රියාකාරී කේත පදනම් වල දක්නට ලැබෙන නිසා, විශේෂයෙන්:
- උරුම C කේතය සහිත විවෘත මූලාශ්ර සංරචක
- Python, Go, හෝ Rust හි ස්වදේශීය බන්ධන
- නිෂ්පාදනයේදී ස්වයංක්රීයව ඒකාබද්ධ කරන ලද තෙවන පාර්ශවීය කේතය pipelines
බලපෑම සැබෑ ය: මතක කාන්දුවීම්, ගොඩගැසීම් දූෂණය, සහ පවා දුරස්ථ කේත ක්රියාත්මක කිරීම (RCE)... එහෙත්, බොහෝ කණ්ඩායම් ස්ථිතික ස්කෑනර් විශ්වාස කරන අතර ඒවා පැහැදිලිව පරීක්ෂා නොකරන්නේ නම් මෙම දෝෂ මඟ හැරේ.
කේතයට කෙලින්ම: printf(පරිශීලක_ආදානය) සහ අන්තරාය
අපි පොදු වැරැද්දක් බලමු:
printf(පරිශීලක_ආදානය);
මෙම තනි පේළිය කරදරයට සෘජු මාර්ගයකි. නම් පරිශීලක_ආදානය වැනි දෙයක් අඩංගු වේ %x %x % x% %x, එය උපදෙස් දෙයි printf මතකය නිරාවරණය කරමින්, තොගයෙන් පිටත අගයන් කියවීමට. නරක නම්, %n ඇතුළත් කර ඇත්නම්, ප්රහාරකයාට මතකයට අත්තනෝමතික අගයන් ලිවිය හැකිය.
මෙම රටාව ස්ටැක් දත්ත කාන්දු කිරීම පමණක් නොවේ; එය මතකය දූෂිත කර දුරස්ථ කේත ක්රියාත්මක කිරීම (RCE) දක්වා වර්ධනය විය හැකිය. ප්රායෝගිකව ආකෘති තන්තු අවදානමක් පෙනෙන්නේ මෙයයි. නිශ්චිත ධජ හෝ සනීපාරක්ෂක සක්රීය කර නොමැති නම් මෙම අවදානම් සම්පාදක දෝෂ හෝ අනතුරු ඇඟවීම් මතු නොකරයි. බොහෝ අවස්ථාවන්හිදී, ඒවා එතුමක හෝ උපයෝගිතා ශ්රිතවල තැන්පත් කර ඇති අතර, ඒවා අනියම් කේත සමාලෝචනවලට නොපෙනී යයි.
මතක දූෂණය 101: ඇත්තටම අවදානමේ ඇත්තේ කුමක්ද?
A format string දෝෂය භාවිතා කරන විට, ප්රහාරකයන්ට:
- භාවිතා කරමින් මතක ලිපින සහ ස්ටැක් අගයන් ඩම්ප් කරන්න %x or %s
- ස්ටැක් විචල්යයන් උඩින් ලියන්න හෝ ලිපින ආපසු එවන්න %n
- මතක දූෂණය හරහා කොටස් දෝෂ හෝ තාර්කික දෝෂ ඇති කරන්න
- සම්පූර්ණ RCE දෙසට හැරවීම, විශේෂයෙන් ASLR හෝ ස්ටැක් කැනරි වැනි ආරක්ෂණ වැරදි ලෙස වින්යාස කර ඇත්නම්
ස්ටැක් රාමුව තේරුම් ගැනීම මෙහිදී උපකාරී වේ. printf කොපමණ තර්ක බලාපොරොත්තු විය යුතුදැයි නොදනී; එය සම්පූර්ණයෙන්ම ආකෘති තන්තුව මත රඳා පවතී. ඒ නිසා %x දත්ත හෙළිදරව් කරමින් හෝ හසුරුවමින්, තොගය ඉහළට ගෙන යයි. ප්රතිඵලය සුළු කාන්දුවක සිට උපදෙස් දර්ශකයේ සම්පූර්ණ පාලනය දක්වා විහිදේ.
නවීන කේත පදනම් වල ආකෘති තන්තු දෝෂ සැඟවී ඇති තැන
මෙම අවදානම් උරුම C කේතයට පමණක් සීමා නොවේ. ඒවා නවීන පරිසරවල සැඟවී ඇත:
- Python (ctypes), Rust (FFI), සහ Go (cgo) ස්වදේශීය පුස්තකාල සමඟ අතුරුමුහුණත් වන බන්ධන බොහෝ විට තුනී එතුම් ලෙස ක්රියා කරයි, පරාමිතීන් සෘජුවම අවදානමට ලක්විය හැකි C ශ්රිත වෙත ලබා දෙයි.
- තෙවන පාර්ශවීය CLI මෙවලම් සහ ඩීමන් ප්රමාණවත් සමාලෝචනයකින් තොරව පැරණි C කේත ඒකාබද්ධ කරයි.
- දැව කැපීමේ දවටන වැනි නිදොස්කරණය_ලොගය(පරිශීලක_ආදානය) printf-style ශ්රිත වෙත අභ්යන්තරව මාර්ගය
- උරුම රටා හෝ අවම වලංගුකරණය අඩංගු ස්වයංක්රීයව ඒකාබද්ධ කරන ලද OSS දායකත්වයන්
ස්වදේශීය C ස්ථරයේ දෝෂයක් එහි රැඳී නොසිටින අතර එය ඉහළට පැතිරෙයි. C ශ්රිතයක් මෙන් ලොග්_සිදුවීම(චතුරස්රය *පණිවිඩය) අනාරක්ෂිතයි, එය Python හරහා අමතන්නේ ctypes, මලකඩ හරහා අනාරක්ෂිත බාහිර, හෝ හරහා යන්න සීජීඕ එම ඉහළ මට්ටමේ පරිසරයන් තුළට අවදානම ගෙන එයි.
ගැටලුව? මෙම ඒකාබද්ධ කිරීම් සුලභ වන අතර, DevSecOps බොහෝ විට උපකල්පනය කරන්නේ බන්ධන ආරක්ෂිත වියුක්ත කිරීම් බවයි. ඒවා එසේ නොවේ. තොගයේ එක් ස්ථරයක ඇති ආකෘති නූල් අවදානමක් අතුරුමුහුණත් හරහා නිහඬව ප්රචාරය කළ හැකිය, විශේෂයෙන් ස්වදේශීය මොඩියුල ශක්තිමත් වර්ග බලාත්මක කිරීම හෝ ආදාන සනීපාරක්ෂාවකින් තොරව ඔතා ඇති විට. යටින් පවතින C ශ්රිතය අවදානමට ලක්විය හැකි නම්, ඉහළ මට්ටමේ කේතය ආකෘති නූල් අවදානම උරුම කර ගනී.
CI/CD Pipelines: මෙය ඔබගේ ආරක්ෂක පරීක්ෂාවන් පසුකර යන ආකාරය
නවීන pipelines වේගය සඳහා නිර්මාණය කර ඇත, නමුත් එම වේගය අන්ධ ලප හඳුන්වා දෙයි:
- SAST මෙවලම් දූෂිත දත්ත සොයා ගැනීමට විශේෂයෙන් වින්යාස කර නොමැති නම්, කලාතුරකින් ගතික ආකෘති තන්තු භාවිතය අල්ලා ගනී.
- PR සමාලෝචකයින් අවධානය යොමු කරන්නේ C ශ්රිත හැසිරීමට යටින් පවතින දේ කෙරෙහි නොව තර්කනය හෝ ශෛලිය කෙරෙහි ය.
- CI ඒකාබද්ධ කිරීම් මතුපිටින් හානිකර නොවන ලෙස පෙනෙන අවදානමට ලක්විය හැකි පැකේජ ඇද දමයි.
- යැපුම් ස්කෑනර් බොහෝ විට ස්වදේශීය කේතය හෝ අනාරක්ෂිත ලොග් කිරීමේ තර්කනය නොසලකා හරින්න
Standard SAST අකුරු නොවන ආකෘති තර්ක අල්ලා ගැනීම සඳහා අභිරුචි නීති ක්රියාත්මක නොකළහොත්, මෙවලම් බොහෝ විට ආකෘති නූල් දෝෂ හඳුනා ගැනීමට අසමත් වේ. මෙම සකස් කළ පරීක්ෂාවන් නොමැතිව, ගතික ආකෘති නූල් පහසුවෙන් අනාවරණය නොවූ ඒවා හරහා ලිස්සා යයි.
ආකෘති තන්තු-විශේෂිත නීති ඒකාබද්ධ කිරීම CI/CD මෙම දෝෂ කලින් හඳුනාගෙන නැවැත්වීමට අත්යවශ්ය වේ. මෙයින් අදහස් කරන්නේ:
- විශ්වාස නොකළ යෙදවුම් ආකෘතිකරණ කාර්යයන් කරා ළඟා වන විට කේතය අවහිර කිරීම
- ස්ථිතික විශ්ලේෂණය අතරතුර ගතික ආකෘති තන්තු සලකුණු කිරීම
- ඔබගේ CI ඒකාබද්ධ කිරීමේ ක්රියාවලියේ කොටසක් ලෙස මෙම ප්රතිපත්ති බලාත්මක කිරීම
මෙය නොමැතිව, ඔබේ pipeline කේතය නිෂ්පාදනයට පැමිණීමට බොහෝ කලකට පෙර, මතක දූෂණයට සහ RCE වලට තුඩු දිය හැකි අවදානම් පන්තියකට අන්ධයි.
දෝෂය හඳුනා ගැනීම: GDB සහ ස්ථිතික මෙවලම් සමඟ ප්රායෝගිකව හඳුනාගැනීම
මෙම දෝෂ සොයා ගැනීමට සහ තහවුරු කිරීමට, අතින් නිදොස්කරණය සහ ස්වයංක්රීය ස්ථිතික විශ්ලේෂණයේ සංයෝජනයක් භාවිතා කරන්න.
ආකෘති තන්තු අනිසි භාවිතයක් සැක කරන නමුත් ධාවන වේලාවේදී එය හැසිරෙන ආකාරය තහවුරු කිරීමට අවශ්ය වූ විට GDB විශේෂයෙන් ප්රයෝජනවත් වේ:
- විවේක ගන්න printf හෝ අදාළ කාර්යයන් ඇමතුම් තොගය සහ තර්ක පරීක්ෂා කිරීමට.
- අට්ටියේ අසාමාන්යතා, අනපේක්ෂිත මතක කියවීම්, ආකෘතිකරණය අතරතුර බිඳ වැටීම් හෝ අමුතු අගයන් තිබේදැයි සොයා බලන්න.
- පුනරාවර්තනය වැනි වියුක්ත ආදානය %x or %s ආකෘති තන්තුව තොගය හරහා කෙතරම් ගැඹුරට ගමන් කරනවාද යන්න හඳුනා ගැනීමට උපකාරී වේ.
අත්පොත සිට ස්වයංක්රීයකරණය දක්වා:
ඔබ අතින් අනිසි භාවිතයේ රටාවක් තහවුරු කළ පසු, ඊළඟ පියවර වන්නේ එම අවබෝධය ස්වයංක්රීය රීතියක් බවට පත් කිරීමයි. උදාහරණයක් ලෙස:
- භාවිත grep 'printf(' src/' අමු ආකෘතිකරණ ඇමතුම් සොයා ගැනීමට.
- ඕනෑම භාවිතයක් සලකුණු කිරීමට මෙය ස්ක්රිප්ටින් සමඟ ඒකාබද්ධ කරන්න printf( පළමු තර්කය වන තැන නැත වචනාර්ථ නූලක්.
- ආකෘති තන්තු අගයන් සොයා ගැනීමට, අක්ෂර නොවන මාර්ග ගතිකව හඳුනා ගැනීමට AST-පාදක මෙවලම් භාවිතා කරන්න.
- විශ්වාසනීය නොවන ආදානය යොමු කරන එතුම ශ්රිත වැනි නිතර අතින් සොයාගැනීම්, මෙම අවස්ථා ස්වයංක්රීයව අවහිර කරන CI රීති වලට පරිවර්තනය කරන්න.
CI ඒකාබද්ධ කිරීමේ ඉඟිය: ඔබගේ වින්යාස කරන්න pipeline කිසියම් ආකෘති ශ්රිතයක් එහි ආකෘති තන්තුව ලෙස ගතික ආදානය ලබා ගන්නේ නම් අසාර්ථක වීමට ගොඩනැගීම්. මෙම පරීක්ෂාවන් ඔබ GDB සහ ධාවන කාල නිදොස්කරණයෙන් ඉගෙන ගත් දේ බලාත්මක කරන ෆයර්වෝලයක් ලෙස ක්රියා කරයි.
ඔබේ කේතය දැඩි කිරීම: ආදාන සහ ආරක්ෂිත රටා වලංගු කිරීම
ආකෘති තන්තු අවදානමක් වැළැක්වීම ආරම්භ වන්නේ ආරක්ෂිත කේතීකරණ පුරුදු අනුගමනය කිරීම සහ ඒවා පරිමාණයෙන් බලාත්මක කිරීමෙනි:
- සැමවිටම ස්ථාවර ආකෘති තන්තු භාවිතා කරන්න: printf("%s", පරිශීලක_ආදානය);, කිසි විටෙකත් ආකෘතිය ලෙස අමු ආදානය ලබා නොදෙන්න.
- ආරක්ෂිත ප්රභේදවලට වැඩි කැමැත්තක් දක්වන්න: snprintf, vsnprintf, සහ සමාන කාර්යයන් බෆර ප්රමාණයන් පාලනය කිරීමට සහ ප්රතිදාන ව්යුහය බලාත්මක කිරීමට උපකාරී වේ.
- සියලුම පරිශීලක ආදාන වලංගු කරන්න එය එතුම ශ්රිතවල පවා ලොග් වීම හෝ ආකෘතිකරණ තර්කනයට ඇතුළු විය හැකිය.
ඔබ සක්රීය කළ යුතු ස්වයංක්රීය අවම කිරීම්:
- ලිපිනය සනීපාරක්ෂක (ASAN): බොහෝ විට විකෘති වූ ආකෘති තන්තු මගින් අවුලුවන බෆර පිටාර ගැලීම් සහ ස්ටැක් උල්ලංඝනයන් ඇතුළුව, තත්ය කාලීනව මතක දූෂණය හඳුනා ගනී.
- නිර්වචනය නොකළ හැසිරීම් සනීපාරක්ෂක (UBSan): ආකෘතිකරණ ශ්රිත වෙත නොගැලපෙන හෝ නැතිවූ තර්ක යැවීම වැනි නිර්වචනය නොකළ හැසිරීම් සලකුණු කරයි.
- -D_FORTIFY_SOURCE=2: සම්පාදනය අතරතුර libc ශ්රිතවලට සැහැල්ලු චෙක්පත් එකතු කරයි, අවම කාර්ය සාධන උඩිස් සමඟ ආකෘති තන්තු අනිසි භාවිතය හෝ බෆරය ඉක්මවා යාම අල්ලා ගැනීමට උපකාරී වේ.
මෙම මෙවලම් නැව්ගත කිරීමට පෙර ගැටළු හඳුනා ගැනීම සඳහා සංවර්ධන සහ CI පරිසර දෙකෙහිම සක්රීය කළ යුතුය. ස්ථිතික විශ්ලේෂණය සමඟ ඒකාබද්ධව, ඒවා ශක්තිමත් ආරක්ෂිත දැලක් සාදයි, ධාවන කාලය දක්වා හෝ සූරාකෑමෙන් පසු අවධානයට ලක් නොවිය හැකි අනිසි භාවිතය පිළිබඳව ඔබට අනතුරු අඟවයි.
ඉඟිය: මෙම විෂබීජ නාශක ඔබේ නිර්මාණයේ කොටසක් කරගන්න pipeline අසාර්ථක වීමේ අනතුරු ඇඟවීමේ ප්රතිපත්ති සමඟ. ඕනෑම ආකෘති තන්තු උල්ලංඝනයක් අසාර්ථක පරීක්ෂණයක් ලෙස සලකන්න.
සයිජෙනි නැව්ගත කිරීමට පෙර නූල් දෝෂ ආකෘතිකරණය කිරීම නවත්වන්නේ කෙසේද?
සයිජෙනි ශක්තිමත් වේ CI/CD හඳුනාගැනීම පමණක් නොව, තත්ය කාලීන වැළැක්වීම සමඟ ආකෘති නූල් ආරක්ෂාව බලාත්මක කිරීමෙන්:
- භයානක රටා හඳුනා ගනී මෙන් printf(පරිශීලක_ආදානය) කේතය නිෂ්පාදනයට ළඟා වීමට පෙර
- ස්ථිතික අපවිත්රතා විශ්ලේෂණය යොදයි බහු ස්ථර හෝ එතුම් ඇමතුම් හරහා වුවද, ආකෘතිකරණ කාර්යයන් තුළට විශ්වාසදායක නොවන යෙදවුම් සොයා ගැනීමට
- අනාරක්ෂිත බ්ලොක් ස්වයංක්රීයව ඒකාබද්ධ වේ GitHub, GitLab, Bitbucket සහ Jenkins හි
- පැහැදිලි ප්රතිපෝෂණ සපයයි ඇමතුම් හෝඩුවාවන්, ආදාන සම්භවය සහ පෙර සමඟcisඊ ප්රතිකර්ම යෝජනා
ක්රියාකාරී උදාහරණය: ifa සංවර්ධක commitරේඛාව log_debug(පරිශීලක_ආදානය) සහ ලොග්_නිදොස්කරණය() අභ්යන්තරව අවදානමට ලක්විය හැකි printf, Xygeni ඇමතුම් ප්රස්ථාරය අනුගමනය කරයි, ගතික ආදාන මාර්ගය හඳුනා ගනී, සහ ඒකාබද්ධ කිරීම අවහිර කරයි. සංවර්ධකයා ඔවුන්ගේ ඒකාබද්ධ ඉල්ලීමෙහි ක්ෂණික පණිවිඩයක් දකී:
⚠️ ආකෘති තන්තු අවදානම අනාවරණය විය: පරිශීලක_ආදානය ගලා යයි printf() src/logger.c:42 හිදී. ස්ථාවර ආකෘති තන්තුවක් භාවිතා කර ආදාන වලංගු කරන්න.
මෙම ප්රතිපෝෂණය MR/PR ක්රියාවලියේ කොටසක් ලෙස GitHub, GitLab, Jenkins, හෝ Bitbucket හි සෘජුවම ලබා දෙනු ලැබේ. සංවර්ධකයින්ට එය මග හැරිය නොහැකි අතර, ඔවුන්ට නොපැහැදිලි අනතුරු ඇඟවීමක් පමණක් නොව, ගැටලුව විසඳන්නේ කෙසේද යන්න පිළිබඳ ක්රියාකාරී මග පෙන්වීමක් ලැබේ.
ඒකාබද්ධ කිරීම සුමටයි:
- repo, ශාඛාව හෝ ව්යාපෘතිය අනුව ප්රතිපත්ති නීති වින්යාස කරන්න
- අනාරක්ෂිත ආකෘති භාවිතය සඳහා අවහිර කිරීමේ කොන්දේසි බලාත්මක කරන්න
- C/C++, Python, Go, Rust සහ ඒවායේ ස්වදේශීය බන්ධන හරහා අනාරක්ෂිත යෙදවුම් ස්වයංක්රීයව සොයා ගන්න.
ඔබේ වැඩ ප්රවාහයට ආරක්ෂාව ඇතුළත් කිරීමෙන් සහ සංවර්ධකයාට ප්රථම ප්රතිපෝෂණය ලබා දීමෙන්, Xygeni ආකෘති නූල් දෝෂ කිසි විටෙකත් නිෂ්පාදනයට නොපැමිණෙන බවට සහතික කරයි, ඒවා මතුවන තැනම නතර කරයි.
අවසාන වචනය: ආකෘති තන්තු දෝෂ මිය ගොස් නැත.
නවීන භාෂා මෙවලම් තිබියදීත්, ආකෘති තන්තු දෝෂ තවමත් දක්නට ලැබේ. ඒවා එතුම්, තෙවන පාර්ශවීය පැකේජ සහ අඩු සමාලෝචනය කරන ලද PR හරහා ගමන් කරයි. ඒවායේ බලපෑම සැබෑ ය: මතක දූෂණය, දත්ත කාන්දු වීම සහ විභව RCE.
ඔබේ කේතය විගණනය කරන්න. ඔබේ CI/CD. හඳුනාගැනීමේ නීති ක්රියාත්මක කර ඒවා ක්රියාත්මක කරන්න. මෙය උරුම ගමන් මලු පමණක් නොවේ, එය පැහැදිලිව පෙනෙන පරිදි සැඟවී ඇති ක්රියාකාරී තර්ජනයකි. ගැටළු කලින් හඳුනා ගැනීමට ස්වයංක්රීය මෙවලම්, ස්ථිතික විශ්ලේෂණය සහ ධාවන කාල සනීපාරක්ෂක භාවිතා කරන්න. කේතය සම්පාදනය වූ පමණින් ඔබ ආරක්ෂිත යැයි නොසිතන්න.
