Buffer Overflow

‫( ﭼﻴﺴﺖ ؟‬Buffer Overflow) ‫ﺳﺮرﯾﺰ ﺑﺎﻓﺮ‬

‫ﻧﻮﯾﺴﻨﺪﻩ ﺑﻬﺮﻧﮓ ﻓﻮﻻدی‬ [email protected] 1382/8/18

www.hat-squad.com Hat-Squad ‫ﮔﺮوﻩ اﻣﻨﻴﺘﯽ‬ (‫)ﻣﺸﺎور و اراﺋﻪ دهﻨﺪﻩ ﺳﺮوﯾﺴﻬﺎی اﻣﻨﻴﺘﯽ‬ [email protected]

Copyright © 2003, Hat-Squad Security Group " ‫" درج ﺗﻤﺎم ﯾﺎ ﻗﺴﻤﺘﯽ از ﻣﻄﺎﻟﺐ اﯾﻦ ﻣﻘﺎﻟﻪ ﺗﻨﻬﺎ ﺑﺎ اﺟﺎزﻩ ﻧﻮﯾﺴﻨﺪﻩ ﺁن ﻣﻘﺪور ﻣﯽ ﺑﺎﺷﺪ‬

1 Of 7 Copyright © 2003, Hat-Squad Security Group

www.hat-squad.com

‫ﺳﺮﻳﺰ ﺑﺎﻓﺮ )‪ (Overflow Buffer‬از ﻗﺪﻳﻤﻴﺘﺮﻳﻦ ﻣﺸﻜﻼت اﻣﻨﻴﺘﻲ ﺳﻴﺴﺘﻤﻬﺎي آﺎﻣﭙﻴﻮﺗﺮي ﺑﻮدﻩ اﺳﺖ‪ .‬در ﺣﺎل ﺣﺎﺿﺮ اﮔﺮ ﺑﻪ ﺿﻌﻔﻬﺎي اﻣﻨﻴﺘﻲ ﻧﺮم‬ ‫اﻓﺰارهﺎي ﻣﺨﺘﻠﻒ آﻪ در ﺳﺎﻳﺘﻬﺎﻳﻲ ﻣﺜﻞ ‪ SecurityFocus‬ﺛﺒﺖ ﺷﺪﻩ اﻧﺪ ‪،‬ﻧﮕﺎهﻲ ﺑﻴﺎﻧﺪازﻳﺪ ‪ ،‬ﻣﺘﻮﺟﻪ ﻣﻲ ﺷﻮﻳﺪ آﻪ ﺣﺪاﻗﻞ ‪ 1/3‬از اﻳﻦ ﺿﻌﻔﻬﺎ ﻣﺮﺑﻮط ﺑﻪ‬ ‫‪ Buffer Overflow‬ﻣﻲ ﺷﻮﻧﺪ‪.‬اﻳﻦ ﻣﺸﻜﻞ در ﺗﻤﺎم ﺳﻴﺴﺘﻢ هﺎي ﻋﺎﻣﻞ دﻳﺪﻩ ﺷﺪﻩ اﺳﺖ‪.‬در اﻳﻦ ﻣﻘﺎﻟﻪ ﺑﺎ ﻳﻚ ﻣﺜﺎل ﺳﺎدﻩ ‪ ،‬ﻣﻮﺿﻮع ‪Buffer Overflow‬‬ ‫و ﭼﮕﻮﻧﮕﻲ اﺳﺘﻔﺎدﻩ ﻧﻔﻮذﮔﺮهﺎ از ﺁن ﺟﻬﺖ ﻧﻔﻮذ ﺑﻪ ﺳﻴﺴﺘﻢ هﺎي آﺎﻣﭙﻴﻮﺗﺮي ﺑﺮرﺳﻲ ﺧﻮاهﺪ ﺷﺪ‪ .‬در ﭘﺎﻳﺎن روﺷﻬﺎﻳﻲ ﺑﺮاي ﺟﻠﻮﮔﻴﺮي از اﻳﻦ ﻧﻮع‬ ‫ﺣﻤﻼت اراﺋﻪ ﺧﻮاهﺪ ﺷﺪ‪.‬ﺑﺮﻧﺎﻣﻪ هﺎي ذآﺮ ﺷﺪﻩ در اﻳﻦ ﻣﻘﺎﻟﻪ ﺑﻪ زﺑﺎن ‪ C‬ﻧﻮﺷﺘﻪ ﺷﺪﻩ اﻧﺪ و ﺑﺎﻳﺪ ﺗﺤﺖ ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ‪ Windows‬آﺎﻣﭙﺎﻳﻞ ﺷﻮﻧﺪ)در‬ ‫اﻳﻦ ﻣﻘﺎﻟﻪ ﺗﻨﻬﺎ ﺳﺮرﻳﺰ ﺑﺎﻓﺮ در ﺑﺮﻧﺎﻣﻪ هﺎي ‪ Win32‬ﻣﻮرد ﻧﻈﺮ اﺳﺖ وﺑﻪ ﺳﻴﺴﺘﻢ هﺎي ﻋﺎﻣﻞ دﻳﮕﺮ ﻣﺜﻞ ‪ Unix/Linux‬اﺷﺎرﻩ ﻧﺨﻮاهﺪ ﺷﺪ(‪.‬‬ ‫ﺑﺮرﺳﻲ ﻣﻮﺿﻮع را ﺑﺎ ﻳﻚ ﺑﺮﻧﺎﻣﻪ آﻮﺗﺎﻩ ﺁﻏﺎز ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫‪--------------------------------------------------------------------------------------------------------------------------------------‬‬‫‪/* big.exe */‬‬ ‫>‪#include <stdio.h‬‬ ‫{ )‪int insecure_func (char *big‬‬ ‫;]‪char insecure_buff[100‬‬ ‫;)‪strcpy(insecure_buff,big‬‬ ‫;‪return 0‬‬ ‫}‬ ‫{ )][‪int main (int argc, char *argv‬‬ ‫;]‪char input_buff[1024‬‬ ‫;)‪gets(input_buff‬‬ ‫;)‪insecure_func(input_buff‬‬ ‫;‪return 0‬‬ ‫}‬ ‫‪----------------------------------------------------------------------------------------------------‬‬‫ﺑﺮﻧﺎﻣﻪ اﺑﺘﺪا رﺷﺘﻪ ورودي از ﺻﻔﺤﻪ آﻠﻴﺪ را در ﺁراﻳﻪ ‪ input_buff‬ﻗﺮار ﻣﻴﺪهﺪ ﺳﭙﺲ هﻨﮕﺎﻣﻲ آﻪ ﺗﺎﺑﻊ ‪ insecure_func‬ﺑﺎ ﻓﺮﺳﺘﺎدن ‪input_buff‬‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﺷﻮد ‪ ،‬اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ﻣﻮﺟﻮد در ‪ input_buff‬رادر ‪ insecure_buff‬آﭙﻲ ﺧﻮاهﺪ آﺮد‪.‬ﻧﻜﺘﻪ اﺻﻠﻲ آﻮﭼﻜﺘﺮ ﺑﻮدن اﻧﺪازﻩ ‪ insecure_buff‬از‬ ‫‪ input_buff‬اﺳﺖ‪ .‬ﺑﻄﻮرﻳﻜﻪ اﮔﺮ ‪ input_buff‬ﺑﻴﺸﺘﺮ از ‪ 100‬آﺎراآﺘﺮ را در ﺧﻮد ﺟﺎي دادﻩ ﺑﺎﺷﺪ ‪ insecure_buff ،‬ﺳﺮرﻳﺰ )‪ (Overflow‬ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫ﺣﺎل ﺑﺮﻧﺎﻣﻪ را آﺎﻣﭙﺎﻳﻞ و اﺟﺮا آﻨﻴﺪ و ﺑﻴﺶ از ‪ 100‬آﺎراآﺘﺮ '‪ 'a‬را ﺑﻪ ﻋﻨﻮان ورودي ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﺑﺪهﻴﺪ‪ .‬ﭘﺲ از زدن آﻠﻴﺪ ‪ Enter‬ﭘﻴﻐﺎم ﺧﻄﺎﻳﻲ ﺷﺒﻴﻪ ﻣﻮرد‬ ‫زﻳﺮ درﻳﺎﻓﺖ ﺧﻮاهﻴﺪ آﺮد‪:‬‬

‫‪www.hat-squad.com‬‬

‫‪2 Of 7‬‬ ‫‪Copyright © 2003, Hat-Squad Security Group‬‬

‫ﭘﻴﻐﺎم ﺧﻄﺎ‬ ‫ﺑﺒﻴﻨﻴﻢ ﭼﻪ اﺗﻔﺎﻗﻲ اﻓﺘﺎدﻩ اﺳﺖ‪ :‬هﺮ ﮔﺎﻩ ﻳﻚ ﺗﺎﺑﻊ از درون ﻳﻚ روال دﻳﮕﺮ ﻓﺮاﺧﻮاﻧﻲ ﻣﻴﺸﻮد ‪ ،‬ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺁدرس ﺑﺮﮔﺸﺖ ﺑﻪ روال ﻓﻌﻠﻲ را در ﻣﺤﻠﻲ‬ ‫از ﺣﺎﻓﻈﻪ ﺑﻪ ﻧﺎم "ﭘﺸﺘﻪ" )ٍ‪ (Stack‬ﻗﺮار دادﻩ و آﻨﺘﺮل را ﺑﻪ روال ﻓﺮاﺧﻮاﻧﻲ ﺷﺪﻩ ﻣﻲ دهﺪ ‪ .‬ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ﭘﺲ از ﭘﺎﻳﺎن روال ﻣﺬآﻮر ‪ ،‬ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺑﺎ‬ ‫ﺑﺎزﻳﺎﺑﻲ ادرس ﺑﺮﮔﺸﺖ از ‪ Stack‬دوﺑﺎرﻩ اﺟﺮاي ﺑﺮﻧﺎﻣﻪ راﻩ ﺑﻪ روال اﺻﻠﻲ ﻣﻲ دهﺪ‪ .‬در ﻣﺜﺎل ﺑﺎﻻ ﺁدرس ﺑﺮﮔﺸﺖ ﻗﺒﻞ از وﻗﻮع ﺳﺮرﻳﺰ )ﭘﻴﺶ از اﺟﺮاي‬ ‫دﺳﺘﻮر ‪ ( strcpy‬ﺑﻪ دﺳﺘﻮر ‪ return 0‬اﺷﺎرﻩ دارد‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﻗﺒﻞ از وﻗﻮع ﺳﺮرﻳﺰ ‪ Stack‬داراي ﺳﺎﺧﺘﺎر زﻳﺮ اﺳﺖ ‪:‬‬

‫___________________‬ ‫|‬ ‫|‬ ‫|___________________|_‬ ‫| |‬ ‫|‬ ‫| |‬ ‫************************* |‬ ‫‪| | insecure_buff‬‬ ‫!!! ‪| !!! stack grows down‬‬ ‫| |‬ ‫************************* |‬ ‫_|___________________|_|‬ ‫|‬ ‫| |‬ ‫‪| return address‬‬ ‫‪| | = 4 bytes‬‬ ‫|_|___________________|‬ ‫|___________________|‬

‫=‬

‫‪100 bytes‬‬

‫ﺳﺎﺧﺘﺎر ‪Stack‬‬ ‫ﭘﺸﺘﻪ )‪ (stack‬هﻤﻴﺸﻪ ﺑﻪ ﺳﻤﺖ ﺁدرﺳﻬﺎي ﭘﺎﻳﻴﻦ ﺗﺮ رﺷﺪ ﻣﻲ آﻨﺪ‪ .‬هﻨﮕﺎم ﺷﺮوع اﺟﺮاي ﺑﺮﻧﺎﻣﻪ‪ ،‬ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ‪ 100‬ﺑﺎﻳﺖ ﺑﺮاي ﺑﺎﻓﺮ‬ ‫‪ insecure_buff‬آﻨﺎر ﻣﻲ ﮔﺬارد‪ .‬واﺿﺢ اﺳﺖ آﻪ اﺟﺮا ﺷﺪن دﺳﺘﻮر ‪ strcpy‬در ﺣﺎﻟﺘﻲ آﻪ اﻧﺪازﻩ رﺷﺘﻪ ﻣﻮﺟﻮد در ‪ big‬ﺑﺰرﮔﺘﺮ از ‪ insecure_buff‬ﺑﺎﺷﺪ‬ ‫‪ ،‬ﺑﺎﻋﺚ ﺗﻐﻴﻴﺮ ﺁدرس ﺑﺮﮔﺸﺖ )‪ (return address‬ﺧﻮاهﺪ ﺷﺪ‪ .‬اﮔﺮ آﻤﻲ دﻗﺖ آﻨﻴﺪ ‪ ،‬ﻣﻲ ﻓﻬﻤﻴﺪ آﻪ ﭼﺮا ﺁدرس ﺑﺮﮔﺸﺖ ﺑﻌﺪ از ﺳﺮﻳﺰ ‪x616161610‬‬ ‫اﺳﺖ ‪ x061.‬آﺪ اﺳﻜﻲ آﺎراآﺘﺮ '‪ 'a‬در ﻣﺒﻨﺎي ‪ 16‬اﺳﺖ آﻪ ﺗﻮﺳﻂ دﺳﺘﻮر ‪ strcpy‬ﻗﺮار ﺑﻮدﻩ ﺑﻪ ﺑﺎﻓﺮ ‪ insecure_buff‬آﭙﻲ ﺷﻮد‪.‬‬ ‫ﺗﺎ اﻳﻨﺠﺎ ﻋﻠﺖ و ﭼﮕﻮﻧﮕﻲ ﺑﺮوز ‪ overflow stack‬ﻣﺸﺨﺺ ﺷﺪ‪ .‬اﻣﺎ ﭼﮕﻮﻧﻪ اﻳﻦ ﻣﺸﻜﻞ ﺑﺮاي ﻧﻔﻮذ ﺑﻪ ﺳﻴﺴﺘﻢ ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﻣﻲ ﮔﻴﺮد؟ ﻣﻲ داﻧﻴﻢ‬ ‫آﻪ ﺗﻤﺎم ﺑﺮﻧﺎﻣﻪ هﺎ و رواﻟﻬﺎﻳﻲ آﻪ روي ﻳﻚ ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ در ﺣﺎل اﺟﺮا هﺴﺘﻨﺪ‪ ،‬در ﺁﺧﺮﻳﻦ ﻻﻳﻪ‪ ،‬ﭼﻴﺰي ﺟﺰ آﺪهﺎي ﻣﺎﺷﻴﻦ ﻧﻴﺴﺘﻨﺪ آﻪ ﭘﺸﺖ ﺳﺮهﻢ‬ ‫ﺧﻮاﻧﺪﻩ و اﺟﺮا ﻣﻲ ﺷﻮﻧﺪ‪ CPU .‬آﺎﻣﭙﻴﻮﺗﺮ ﺁدرس ﺣﺎﻓﻈﻪ ﻣﺮﺑﻮط ﺑﻪ دﺳﺘﻮراﻟﻌﻤﻞ ﺑﻌﺪي را در ﻃﻮل اﺟﺮاي ﺑﺮﻧﺎﻣﻪ از رﺟﻴﺴﺘﺮ ‪ EIP‬ﺧﻮاﻧﺪﻩ و آﻨﺘﺮل اﺟﺮاي‬ ‫ﺑﺮﻧﺎﻣﻪ را ﺑﻪ ﺁن ﺁدرس ﻣﻨﺘﻘﻞ ﻣﻲ آﻨﺪ‪ .‬ﺣﺎل اﮔﺮ ﺑﺘﻮان ﺁدرس ﻣﻮﺟﻮد در اﻳﻦ رﺟﻴﺴﺘﺮ را در هﺮ ﻣﺮﺣﻠﻪ اي از اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻣﻘﺪار دﻳﮕﺮي ﺗﻐﻴﻴﺮ داد‪،‬‬

‫‪www.hat-squad.com‬‬

‫‪3 Of 7‬‬ ‫‪Copyright © 2003, Hat-Squad Security Group‬‬

‫‪ CPU‬ﺑﺪون درﻧﮓ اﺟﺮاي ﺑﻘﻴﻪ ﺑﺮﻧﺎﻣﻪ را از اﻳﻦ ﺁدرس ﺟﺪﻳﺪ اداﻣﻪ ﺧﻮاهﺪ داد‪ .‬ﺗﺼﻮر آﻨﻴﺪ در ﻣﺤﻞ ﺁدرس ﺟﺪﻳﺪ آﺪ ﻳﻚ ‪ backdoor‬ﻳﺎ ﺳﺮوﻳﺲ ﭘﻨﻬﺎﻧﻲ‬ ‫وﻳﺎ هﺮ ﻧﻮع آﺪ ﻣﺨﺮب دﻳﮕﺮي ﻗﺮار داﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﻧﺘﻴﺠﻪ اﻳﻦ ﺧﻮاهﺪ ﺷﺪ آﻪ آﺎﻣﭙﻴﻮﺗﺮ اﻳﻦ آﺪ را ﺑﺠﺎي آﺪ ﺑﺮﻧﺎﻣﻪ اﺻﻠﻲ آﻪ ﻣﺴﻴﺮش ﺗﻮﺳﻂ ﻣﺎ ﻋﻮض‬ ‫ﺷﺪﻩ‪ ،‬اﺟﺮا ﺧﻮاهﺪ ﻧﻤﻮد و ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ﻧﻔﻮذﮔﺮ ﺧﻮاهﺪ ﺗﻮاﻧﺴﺖ ﺑﺎ اﺳﺘﻔﺎدﻩ از ‪ backdoor‬ﻳﺎ آﺪ ﻣﺤﺮب اﺟﺮا ﺷﺪﻩ‪ ،‬آﻨﺘﺮل ﺳﻴﺴﺘﻢ ﻣﺰﺑﻮر را ﺑﺪﺳﺖ‬ ‫ﮔﻴﺮد‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﻧﻔﻮذﮔﺮ ﺑﺮاي رﺳﻴﺪن ﺑﻪ هﺪف ﺧﻮد ﺑﺎﻳﺪ دو ﻣﺴﺎﻟﻪ را ﺣﻞ آﻨﺪ‪ .‬اول ﻳﺎﻓﺘﻦ راهﻲ ﺑﺮاي اﻳﺠﺎد ‪ overflow‬در ﺳﻴﺴﺘﻢ هﺪف ‪ .‬ﺑﺮاي‬ ‫اﻳﻨﻜﺎر ﻧﻔﻮذﮔﺮ ‪ ،‬ﺳﺮوﻳﺴﻬﺎ و ﺑﺮﻧﺎﻣﻪ هﺎي در ﺣﺎل اﺟﺮا روي ﺳﻴﺴﺘﻢ هﺪف ﻣﺎﻧﻨﺪ ‪ Ftp Server ،Mail Server ، Server Web‬و ‪ ...‬را ﺑﺮاي ﻳﺎﻓﺘﻦ روﺷﻲ‬ ‫ﺟﻬﺖ ‪ overflow‬آﺮدن هﺮ آﺪام از ﺁﻧﻬﺎ ﺁزﻣﺎﻳﺶ ﺧﻮاهﺪ ﻧﻤﻮد‪ .‬ﺑﺤﺚ ﻳﺎﻓﺘﻦ ‪ overflow‬هﺎ از ﺣﻮﺻﻠﻪ اﻳﻦ ﻣﻘﺎﻟﻪ ﺧﺎرج اﺳﺖ و ﻧﻤﻲ ﺗﻮان روش‬ ‫اﺳﺘﺎﻧﺪاردي را ﭘﻴﺸﻨﻬﺎد آﺮد و ﺑﻴﺸﺘﺮ روي ﺳﻌﻲ و ﺧﻄﺎ اﺳﺘﻮار اﺳﺖ‪ .‬ﻣﺮﺣﻠﻪ دوم اﺳﺘﻔﺎدﻩ از ﺑﺮﻧﺎﻣﻪ ‪ overflow‬ﺷﺪﻩ ﺑﺮاي اﺟﺮاي آﺪ‬ ‫دﻟﺨﻮاﻩ‪.‬‬ ‫ﺑﺮاي ﻧﺸﺎن دادن روس آﺎر ﻧﻔﻮذﮔﺮ‪ ،‬ﺳﻌﻲ ﻣﻲ آﻨﻴﻢ ﺑﺮﻧﺎﻣﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺑﺮﻧﺎﻣﻪ ‪ big.exe‬آﺪ ﻣﻮرد ﻧﻈﺮ ﺧﻮد را روي ﺳﻴﺴﺘﻢ اﺟﺮا آﻨﻴﻢ‪ .‬رﺷﺘﻪ اي را‬ ‫ﺑﻪ ﻋﻨﻮان ورودي )ﺑﻪ ﺟﺎي ‪ 100‬آﺎراآﺘﺮ ‪ (a‬ﻣﻲ ﺳﺎزﻳﻢ آﻪ ﺷﺎﻣﻞ ﻳﻚ آﺪ آﻮﭼﻚ دﺳﺘﻮرات زﺑﺎن اﺳﻤﺒﻠﻲ )آﻪ اﺻﻄﻼﺣﺎ ‪ exploit‬ﻧﺎﻣﻴﺪﻩ ﻣﻲ ﺷﻮد(‬ ‫اﺳﺖ آﻪ آﺎر ﻣﻮرد ﻧﻈﺮ ﻣﺎرا روي ﺳﻴﺴﺘﻢ اﻧﺠﺎم ﺧﻮاهﺪ داد و ﺑﺎ ﺗﻐﻴﻴﺮ ﺁدرس ﺑﺮﮔﺸﺖ‪ ،‬آﻨﺘﺮل را ﺑﻪ اﻳﻦ آﺪ ﺧﻮدﻣﺎن ﻣﻲ دهﻴﻢ‪ .‬ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ﺑﻪ ﻧﺘﻴﺠﻪ‬ ‫ﻣﻮرد ﻧﻈﺮ ﺧﻮاهﻴﻢ رﺳﻴﺪ‪.‬‬ ‫ﺑﺮاي ﻧﻮﺷﺘﻦ آﺪ ‪ Exploit‬اﺣﺘﻴﺎج دارﻳﻢ ﺗﺎ ﺑﺪاﻧﻴﻢ رﺷﺘﻪ ورودي ﺳﺎﺧﺘﻪ ﺷﺪﻩ ﺗﻮﺳﻂ ﻣﺎ در ﭼﻪ ﻣﺤﻠﻲ روي ﺁدرس ﺑﺮﮔﺸﺖ ذﺧﻴﺮﻩ ﺷﺪﻩ در اﻧﺘﻬﺎي‬ ‫‪ Stack‬ﺧﻮاهﺪ اﻓﺘﺎد‪.‬ﺑﺮای داﻧﺴﺘﻦ اﻳﻦ ﻣﻮﺿﻮع دو راﻩ وﺟﻮد دارد‪.‬روش اول اﺳﺘﻔﺎدﻩ از ﻳﻚ ‪ Disassembler‬ﺑﺮاي ﻳﺎﻓﺘﻦ اﻧﺪازﻩ ﺑﺎﻓﺮ ﺳﺮرﻳﺰ ﺷﺪﻩ اﺳﺖ‪.‬‬ ‫در اﻳﻦ روش ﻣﺠﺒﻮرﻳﻢ ﺑﻪ دﻧﺒﺎل ﺗﺎﺑﻌﻲ ﺑﮕﺮدﻳﻢ آﻪ ﺳﺮرﻳﺰ در ﺁن اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ‪ .‬راﻩ دوم اﻧﺠﺎم ﺁزﻣﻮن و ﺧﻄﺎ اﺳﺖ ‪ ،‬اﺑﺘﺪا ﺑﺎﻳﺪ رﺷﺘﻪ آﺎراآﺘﺮي از آﺪ‬ ‫هﺎي اﺳﻜﻲ ‪ 32‬ﺗﺎ ‪ 255‬ﺑﺴﺎزﻳﻢ ‪ ،‬آﺪ آﻮﭼﻚ زﻳﺮ اﻳﻦ آﺎر را ﺑﺮاﻳﻤﺎن اﻧﺠﺎم ﻣﻲ دهﺪ‪:‬‬ ‫‪------------------------------------------------------------------------------------------------------------------------------‬‬‫‪/* ascii.exe */‬‬ ‫>‪#include <stdio.h‬‬ ‫{ )‪void main(void‬‬ ‫;‪int i‬‬ ‫;)‪for (i=0;i<256;i++) printf("%c",i‬‬ ‫}‬ ‫‪------------------------------------------------------------------------------------------------------------------------------‬‬‫اﻳﻦ ﺳﻮال ﭘﻴﺶ ﻣﻲ ﺁﻳﺪ آﻪ ﭼﺮا آﺎراآﺘﺮ هﺎ ﺑﺎ آﺪ اﺳﻜﻲ ﺑﺰرﮔﺘﺮ از ‪ 32‬را اﻧﺘﺨﺎب آﺮدﻳﻢ‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ رﺷﺘﻪ اي آﻪ ﺑﻪ ﻋﻨﻮان ورودي ﺑﻪ‬ ‫ﺑﺮﻧﺎﻣﻪ هﺪف ﻣﻲ دهﻴﻢ ﻧﺒﺎﻳﺪ ﺣﺎوي آﺪ هﺎي اﺳﻜﻲ آﺎراآﺘﺮهﺎي ‪ LF(0x0a) ، NULL(0x00) ،(EOF(0x1a،(CR(0x0c‬ﺑﺎﺷﺪ ﭼﻮن اﮔﺮ ﺗﺎﺑﻊ ‪strcpy‬‬ ‫هﻨﮕﺎم آﭙﻲ آﺮدن رﺷﺘﻪ آﺎراآﺘﺮي ﺑﻪ ﻳﻜﻲ از اﻳﻦ آﺪهﺎ ﺑﺮﺳﺪ ﺁن را ﺑﻪ ﻋﻨﻮان اﻧﺘﻬﺎي رﺷﺘﻪ ﺗﻠﻘﻲ ﺧﻮاهﺪ آﺮد و ﺑﻘﻴﻪ رﺷﺘﻪ آﭙﻲ ﻧﺨﻮاهﺪ ﺷﺪ‪ .‬ﺑﻪ‬ ‫هﻤﻴﻦ دﻟﻴﻞ اﺳﺖ آﻪ ﻣﺎ ﺑﺎزﻩ ‪ 32‬ﺗﺎ ‪ 255‬را آﻪ ﺷﺎﻣﻞ هﻴﭽﻜﺪام از اﻳﻦ آﺪهﺎ ﻧﻴﺴﺖ اﻧﺘﺨﺎب ﻣﻲ آﻨﻴﻢ‪ .‬ﺣﺎل ﺑﺮﻧﺎﻣﻪ را آﺎﻣﭙﺎﻳﻞ آﺮدﻩ ‪ ،‬ﺑﻪ ﺻﻮرت زﻳﺮ‬ ‫اﺟﺮا ﻣﻲ آﻨﻴﻢ ‪:‬‬ ‫‪C:\> c:\bof\big.exe | ascii.exe‬‬

‫‪www.hat-squad.com‬‬

‫‪4 Of 7‬‬ ‫‪Copyright © 2003, Hat-Squad Security Group‬‬

‫اﻳﻦ ﺑﺎر در ﭘﻴﻐﺎم ﺧﻄﺎ رﺟﻴﺴﺘﺮ ‪ EIP‬ﺣﺎوي ﺁدرس ‪ x8b8a89880‬اﺳﺖ)ﺗﺮﺗﻴﺐ ﻗﺮارﮔﻴﺮي از راﺳﺖ ﺑﻪ ﭼﭗ اﺳﺖ(‪ .‬ﻳﻌﻨﻲ ﺑﺎ ﺷﺮوع از ﻣﺤﻞ ﺻﺪو ﭼﻬﺎرم‬ ‫ﺑﺎﻓﺮ )‪ (x88-0x20=1040‬رﺷﺘﻪ ورودي روي ﺁدرس ﺑﺮﮔﺸﺖ ﻣﻲ اﻓﺘﺪ‪ .‬ﭘﺲ در رﺷﺘﻪ اي آﻪ ﺧﻮاهﻴﻢ ﺳﺎﺧﺖ ﻣﺤﻠﻬﺎي ‪ 104‬ﺗﺎ ‪ 107‬ﺣﺎﻓﻈﻪ )ﺑﻪ ﻃﻮل ‪4‬‬ ‫ﺑﺎﻳﺖ( ﺑﺎﻳﺪ ﺣﺎوي ﺁدرس ﺑﺮﮔﺸﺖ ﺑﻪ آﺪي ﺑﺎﺷﺪ آﻪ ﻣﻲ ﺧﻮاهﻴﻢ اﺟﺮا ﺷﻮد‪.‬‬ ‫ﻣﺸﻜﻞ اول ﺣﻞ ﺷﺪ ‪ ،‬ﺣﺎﻻ ﺑﺎﻳﺪ ﺗﺼﻤﻴﻢ ﺑﮕﺮﻳﺮﻳﻢ آﻪ ﭼﮕﻮﻧﻪ آﺪ ‪ Exploit‬را ﺗﺸﻜﻴﻞ دهﻴﻢ ‪ .‬در اﻳﻦ ﺑﺎرﻩ دو اﻣﻜﺎن وﺟﻮد دارد ‪:‬‬ ‫‪ -1‬ﻗﺮارﮔﻴﺮي آﺪ ‪ Exploit‬از اﺑﺘﺪاي ﺑﺎﻓﺮ ﺗﺎ ﻣﺤﻞ ‪ 104‬ﺑﺎﻓﺮ‬ ‫‪ -2‬ﻗﺮارﮔﻴﺮي آﺪ ‪ Exploit‬از ﻣﺤﻞ ‪ 108‬ﺑﺎﻓﺮ ﺑﻪ ﺑﻌﺪ‬ ‫اﻧﺘﺨﺎب روش اول اﻧﺪازﻩ آﺪ ‪ Exploit‬ﻣﺎراﺑﻪ ‪ 104‬ﺑﺎﻳﺖ ﻣﺤﺪود ﺧﻮاهﺪ آﺮد ‪ ،‬ﺑﻪ هﻤﻴﻦ ﺟﻬﺖ روش دوم را اﻧﺘﺨﺎب ﻣﻲ آﻨﻴﻢ و ﻣﺤﻠﻬﺎي ﺣﺎﻓﻈﻪ ﻗﺒﻞ از‬ ‫ﺁدرس ﺻﺪوﭼﻬﺎرم را ﻧﻴﺰ ﺑﺎ آﺪ دﺳﺘﻮر اﺳﻤﺒﻠﻲ )‪ NOP (No Operand‬ﻳﻌﻨﻲ ‪ x900‬ﭘﺮ ﻣﻲ آﻨﻴﻢ‪.‬‬ ‫ﻣﺴﺎﻟﻪ ﺁﺧﺮ ﺗﻌﻴﻴﻦ ﺁدرس ﻣﺤﻞ ﺣﺎﻓﻈﻪ اﺳﺖ آﻪ ﻣﻲ ﺧﻮاهﻴﻢ ﺑﻪ ﺟﺎي ﺁدرس ﺑﺮﮔﺸﺖ واﻗﻌﻲ ﻗﺮار دهﻴﻢ‪ .‬اﺑﺘﺪا ﺑﻪ ﺑﺮرﺳﻲ وﺿﻌﻴﺖ رﺟﻴﺴﺘﺮهﺎ و‬ ‫ﺳﺎﺧﺘﺎر ﺑﺎﻓﺮ درﺳﺖ ﻗﺒﻞ از اﺟﺮاي دﺳﺘﻮر ‪ RET‬اﺳﻤﺒﻠﻲ )ﺗﻮﻟﻴﺪ ﺷﺪﻩ ﺗﻮﺳﻂ دﺳﺘﻮر ‪ ( return 0‬ﻣﻲ ﭘﺮدازﻳﻢ‪:‬‬

‫___________________‬ ‫|‬ ‫|‬ ‫|___________________|‪0‬‬ ‫|‬ ‫|‬ ‫|‬ ‫************************* |‬ ‫‪| insecure_buff‬‬ ‫!!! ‪| !!! stack grows down‬‬ ‫|‬ ‫************************* |‬ ‫|___________________|‪104‬‬ ‫|‬ ‫‪|<--- ESP‬‬ ‫‪| return address‬‬ ‫|‬ ‫|___________________|‪108‬‬

‫هﻤﺎن ﻃﻮر آﻪ ﻣﻲ ﺑﻴﻨﻴﺪ ‪ ،‬درﺳﺖ ﻗﺒﻞ از اﺟﺮاي دﺳﺘﻮر ‪ RET‬رﺟﻴﺴﺘﺮ ‪ ESP‬ﺑﻪ ﻣﺤﻞ ‪ 104‬ﺣﺎﻓﻈﻪ اﺷﺎرﻩ ﺧﻮاهﺪ آﺮد ‪ ،‬ﭘﺲ اﮔﺮ ﺑﺘﻮاﻧﻴﻢ در اﻳﻦ ﻟﺤﻈﻪ‬ ‫ﻳﻚ دﺳﺘﻮر ‪ jmp esp‬اﺟﺮا آﻨﻴﻢ ‪ ،‬ﭘﺮدازﻧﺪﻩ ﺑﻼﻓﺎﺻﻠﻪ آﻨﺘﺮل را ﺑﻪ ﺁدرس ‪ 4‬ﺑﺎﻳﺘﻲ ﻗﺮار دادﻩ ﺷﺪﻩ در ﻣﺤﻠﻬﺎي ‪ 104‬ﺗﺎ ‪ 107‬ﻣﻲ دهﺪ وﻣﺎ ﺑﻪ ﻣﻨﻈﻮر ﺧﻮد‬ ‫رﺳﻴﺪﻩ اﻳﻢ ‪ .‬اﺑﺘﺪا ﺑﺎﻳﺪ ﺣﺎﻓﻈﻪ ﺳﻴﺴﺘﻢ را ﺑﻪ دﻧﺒﺎل آﺪ دﺳﺘﻮر )‪ jmp esp (0xff0xe4‬ﺟﺴﺘﺠﻮ آﻨﻴﻢ ‪ ،‬ﺁدرس ﺣﺎﻓﻈﻪ ﭘﻴﺪا ﺷﺪﻩ هﻤﺎن ﺁدرﺳﻲ اﺳﺖ‬ ‫آﻪ ﺑﺠﺎي ﺁدرس ﺑﺮﮔﺸﺖ واﻗﻌﻲ در ﻣﺤﻠﻬﺎي ‪ 104‬ﺗﺎ ‪ 107‬ﺑﺎﻓﺮ ﻗﺮار ﻣﻲ ﮔﻴﺮد‪ .‬ﺑﺎ اﻳﻦ ﺣﺴﺎب ﺗﺮﺗﻴﺐ اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت زﻳﺮ در ﺧﻮاهﺪ ﺁﻣﺪ‪:‬‬ ‫‪RET--> JMP ESP--> Our Exploit Code‬‬ ‫ﺗﺮآﻴﺐ ‪ xff0xe40‬را ﻣﻲ ﺗﻮان هﻢ در ﺣﺎﻓﻈﻪ ﺑﺮﻧﺎﻣﻪ ‪ big.exe‬و هﻢ در ﺣﺎﻓﻈﻪ ﻣﺮﺑﻮط ﺑﻪ ‪ DLL‬هﺎي ﻣﺘﺼﻞ ﺑﻪ ﺁن ﺟﺴﺘﺠﻮ آﺮد‪ .‬ﺑﻬﺘﺮﻳﻦ راﻩ ﺟﺴﺘﺠﻮ در‬ ‫‪ DLL‬هﺎي ﻣﺘﺼﻞ ﺑﻪ ﺑﺮﻧﺎﻣﻪ اﺳﺖ )در اﻳﻨﺠﺎ ﻳﻜﻲ دو ﻓﺼﻞ ﻣﺮﺑﻮط ﺑﻪ ﻓﺮﻣﺖ ﻓﺎﻳﻠﻬﺎي ‪ PE‬وﻳﻨﺪوز را رد ﻣﻲ آﻨﻴﻢ و ﻣﻄﺎﻟﻌﻪ ﺁن را ﺑﻪ ﻋﻬﺪﻩ ﺧﻮاﻧﻨﺪﻩ ﻋﻼﻗﻪ‬ ‫ﻣﻨﺪ ﻣﻲ ﮔﺬارﻳﻢ (‪ .‬ﻓﺎﻳﻠﻬﺎي ‪ DLL‬ﺳﻴﺴﺘﻢ در وﻳﻨﺪوز ‪ NT‬ﺑﺎ ﺷﺮوع از ﺁدرس ‪ Image Base‬در ﺣﺎﻓﻈﻪ ‪ Load‬ﻣﻲ ﺷﻮﻧﺪ ﺑﺎ آﻤﻚ ﺑﺮﻧﺎﻣﻪ هﺎي ‪PE‬‬ ‫‪ Analyser‬ﻣﻲ ﺗﻮان ﺑﻪ ﺁﺳﺎﻧﻲ اﻳﻦ ﺁدرس را ﭘﻴﺪا آﺮد‪ .‬در اﻳﻨﺠﺎ از ﺑﺮﻧﺎﻣﻪ ‪ LISTDLLS‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ آﻪ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺁن را از ﺳﺎﻳﺖ ‪sysinternals‬‬ ‫درﻳﺎﻓﺖ آﻨﻴﺪ ‪:‬‬

‫‪www.hat-squad.com‬‬

‫‪5 Of 7‬‬ ‫‪Copyright © 2003, Hat-Squad Security Group‬‬

‫‪C:\bof> listdlls big.exe‬‬

‫‪.‬‬ ‫‪Version‬‬

‫‪Path‬‬

‫‪.‬‬

‫‪.‬‬

‫‪Size‬‬

‫‪Base‬‬

‫‪0x27000‬‬

‫‪0x00400000‬‬

‫‪D:\WINNT\System32\ntdll.dll‬‬

‫‪4.00.1381.0130‬‬

‫‪0x5c000‬‬

‫‪0x77f60000‬‬

‫‪D:\WINNT\system32\KERNEL32.dll‬‬

‫‪4.00.1381.0133‬‬

‫‪0x5e000‬‬

‫‪0x77f00000‬‬

‫‪C:\bof\big.exe‬‬

‫اﻃﻼﻋﺎت راﺟﻊ ﺑﻪ ﻣﺤﻞ ﻗﺮارﮔﻴﺮي ﺑﺮﻧﺎﻣﻪ و ‪ DLL‬هﺎي ﺁن در ﺣﺎﻓﻈﻪ را ﻣﻲ ﺑﻴﻨﻴﻢ‪ .‬ﻣﻲ ﺗﻮاﻧﻴﻢ در ﺣﺎﻓﻈﻪ ﻳﺎ داﺧﻞ هﺮ آﺪام از اﻳﻦ ‪ 3‬ﻓﺎﻳﻞ ﻧﺸﺎن دادﻩ‬ ‫ﺷﺪﻩ ﺑﻪ دﻧﺒﺎل آﺪ دﺳﺘﻮر ‪ jmp esp‬ﺑﮕﺮدﻳﻢ ‪ .‬ﺟﺴﺘﺠﻮ در ﺣﺎﻓﻈﻪ راﺣﺘﺘﺮ اﺳﺖ ﭼﻮن ﻧﻴﺎزي ﺑﻪ ﻣﺤﺎﺳﺒﻪ ‪ Offset‬هﺎ ﺑﺮ ﺧﻼف داﺧﻞ ﻓﺎﻳﻞ ﻧﻴﺴﺖ‪ .‬از ﻳﻚ‬ ‫‪ Debugger‬ﻣﺜﻼ ‪ SoftICE‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ و هﻨﮕﺎم وﻗﻮع ﺳﺮرﻳﺰ آﻪ آﻨﺴﻮل ‪ SoftICE‬ﻇﺎهﺮ ﻣﻲ ﺷﻮد ‪ ،‬دﺳﺘﻮر زﻳﺮ را اﺟﺮا ﻣﻲ آﻨﻴﻢ ‪:‬‬ ‫‪S 1000000 | ffffffff fee4‬‬ ‫ﻳﻌﻨﻲ ﺟﺴﺘﺠﻮي ﺣﺎﻓﻈﻪ از ﺁدرس ‪) x010000000‬اوﻟﻴﻦ ﺁدرﺳﻲ آﻪ ﺑﺎﻳﺖ اول ﻣﺨﺎﻟﻒ ﺻﻔﺮ دارد( ﺗﺎ ﺁﺧﺮﻳﻦ ‪ Offset‬ﺣﺎﻓﻈﻪ ﻳﻌﻨﻲ ‪ . xFFFFFFFF0‬ﻧﺘﻴﺠﻪ‬ ‫زﻳﺮ ﺣﺎﺻﻞ ﺧﻮاهﺪ ﺷﺪ ‪:‬‬ ‫)‪(77f327e5‬‬

‫‪Pattern found at 0023:77f327e5‬‬

‫دﺳﺘﻮر ‪ jmp esp‬در ﻣﺤﻞ ﺁدرس ‪ x77f327e50‬ﭘﻴﺪا ﺷﺪ اﻳﻦ ﺁدرس ﺣﺎوي هﻴﭽﻜﺪام از آﺪهﺎي ‪، NULL(0x00) ،(EOF(0x1a،(CR(0x0c‬‬ ‫)‪ LF(0x0a‬ﻧﻴﺴﺖ و ﺑﺮاﺣﺘﻲ ﻣﻲ ﺗﻮان از ﺁن اﺳﺘﻔﺎدﻩ آﺮد‪.‬‬ ‫ﺗﻮﺟﻪ ‪ :‬ﺁدرس ﻓﻮق ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ورژن ‪ Service Pack‬ﻧﺼﺐ ﺷﺪﻩ روي ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ هﺪف ﻣﻘﺎدﻳﺮ ﻣﺘﻔﺎوﺗﻲ ﺧﻮاهﺪ ﺑﻮد ‪ ،‬ﻳﻪ اﻳﻦ ﺳﺒﺐ در ﻣﻮاردي آﻪ‬ ‫‪ Remote Exploit‬ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﺑﻪ ﻃﺮﻳﻘﻲ از ﺷﻤﺎرﻩ ‪ Service Pack‬ﻧﺼﺐ ﺷﺪﻩ روي آﺎﻣﭙﻴﻮﺗﺮ هﺪف اﻃﻼع ﭘﻴﺪا آﻨﻴﻢ و ﺳﭙﺲ ﺁدرس درﺳﺖ ﺑﺮاي ﺁن‬ ‫‪ Service Pack‬را اﺳﺘﻔﺎدﻩ آﻨﻴﻢ‪ .‬روﺷﻬﺎب ﭘﻴﺸﺮﻓﺘﻪ دﻳﮕﺮي ﺑﺮاي ‪ Exploit‬ﻧﻮﻳﺴﻲ وﺟﻮد دارﻧﺪ آﻪ اﻳﻦ ﻣﺸﻜﻞ را ﺣﻞ ﻣﻲ آﻨﻨﺪ‪.‬‬ ‫در اﻳﻦ ﻣﺮﺣﻠﻪ ﺗﻤﺎم اﻃﻼﻋﺎت ﻻزم را در اﺧﺘﻴﺎر دارﻳﻢ ‪-1 :‬ﻣﺤﻞ ﻗﺮارﮔﻴﺮي آﺪ ‪ Exploit‬ﻣﻌﻠﻮم ﺷﺪﻩ اﺳﺖ ‪-2‬ﺁدرس آﻪ ﺑﺎﻳﺪ ﺑﺠﺎي ﺁدرس ﺑﺮﮔﺸﺖ واﻗﻌﻲ‬ ‫ﻗﺮار دادﻩ ﺷﻮد ‪ ،‬ﻣﻲ داﻧﻴﻢ‪ .‬ﺗﻨﻬﺎ آﺎر ﺑﺎﻗﻴﻤﺎﻧﺪﻩ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ‪ Exploit‬اﺳﺖ آﻪ ﺑﺮ ﺣﺴﺐ ‪ Local‬ﻳﺎ ‪ Remote‬ﺑﻮدن هﺪف ﻣﺘﻔﺎوت ﺧﻮاهﺪ ﺑﻮد‪ .‬در اﻳﻦ‬ ‫زﻣﻴﻨﻪ ﻣﻄﺎﻟﺐ و آﺪهﺎي ﻓﺮاواﻧﻲ روي وب ﻣﻮﺟﻮد هﺴﺘﻨﺪ آﻪ ﺑﺎ ﭘﻴﺶ زﻣﻴﻨﻪ ﻓﻌﻠﻲ ﺑﻪ ﺁﺳﺎﻧﻲ ﻣﻲ ﺗﻮاﻧﻴﺪ از ﺁﻧﻬﺎ اﻳﺪﻩ ﺑﮕﻴﺮﻳﺪ‪.‬‬ ‫ﭼﮕﻮﻧﻪ از ﺣﻤﻼت ‪ Buffer Overflow‬ﭼﻠﻮﮔﻴﺮي آﻨﻴﻢ؟‬ ‫ﺣﻤﻼت ‪ buffer overflow‬از ﺿﻌﻒ ﺣﺎﺻﻞ از ﻋﺪم ﺗﺴﺖ اﻧﺪازﻩ دادﻩ ورودي اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻨﺪ‪ .‬اﮔﺮ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ‪ big.exe‬ﻗﺒﻞ از‬ ‫دﺳﺘﻮر‬

‫;)‪strcpy(insecure_buff,big‬‬

‫اﻧﺪازﻩ‬

‫ورودي‬

‫‪big‬‬

‫را‬

‫ﭼﻚ‬

‫ﻣﻲ‬

‫آﺮد‬

‫ﻳﺎ‬

‫ﺑﺠﺎي‬

‫ﺗﺎﺑﻊ‬

‫‪strcpy‬‬

‫از‬

‫‪strncpy‬‬

‫ﺑﻪ‬

‫ﺻﻮرت‬

‫;)‪ strncpy(insecure_buff,big,100‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﺮد‪ ،‬ﻣﺸﻜﻞ ‪ overflow‬ﺑﺮوز ﻧﻤﻲ آﺮد‪ .‬ﻟﺬا ﻣﻬﻤﺘﺮﻳﻦ اﺻﻞ در ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻳﻚ ﺳﺮوﻳﺲ ﻳﺎ‬ ‫ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎوم در ﺑﺮاﺑﺮ ‪ overflow‬هﺎ ﭼﻚ آﺮدن اﻧﺪازﻩ ﺗﻤﺎم ورودﻳﻬﺎ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻗﺒﻞ از اﻧﺠﺎم هﺮ آﺎري روي دادﻩ هﺎﺳﺖ‪ .‬ﺑﺮاي ﺑﺮﻧﺎﻣﻪ‬ ‫ﻧﻮﻳﺴﺎن ﻣﺤﻴﻂ ‪ linux/unix‬آﺘﺎﺑﺨﺎﻧﻪ هﺎﻳﻲ ﻣﺎﻧﻨﺪ ‪ StackGuard‬وﺟﻮد دارﻧﺪ آﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎ ﻟﻴﻨﻚ آﺮدن اﻳﻦ آﺘﺎﺑﺨﺎﻧﻪ هﺎ ﺑﻪ ﻧﺮم اﻓﺰارش‪،‬‬ ‫ﺟﻠﻮي ﺑﺴﻴﺎري از ‪ overflow‬هﺎ را ﺑﮕﻴﺮد‪.‬‬

‫‪www.hat-squad.com‬‬

‫‪6 Of 7‬‬ ‫‪Copyright © 2003, Hat-Squad Security Group‬‬

‫اﻣﺎ در اآﺜﺮ ﻣﻮارد‪ ،‬ﺑﻪ آﺪ ﺳﻮرس ﺑﺮﻧﺎﻣﻪ ﻳﺎ ﺳﺮوﻳﺲ ﻧﺼﺐ ﺷﺪﻩ روي ﺳﻴﺴﺘﻢ ﺧﻮد دﺳﺘﺮﺳﻲ ﻧﺪارﻳﻢ و ﻗﺎدر ﺑﻪ ﺗﺸﺨﻴﺺ ﺿﻌﻔﻬﺎي اﺣﺘﻤﺎﻟﻲ از ﻃﺮﻳﻖ‬ ‫ﺑﺮرﺳﻲ ﺳﻮرس ﺑﺮﻧﺎﻣﻪ ﻧﻴﺴﺘﻴﻢ هﻤﭽﻨﻴﻦ اﻳﻨﻜﺎر از ﺗﻮان اﻓﺮاد ﻏﻴﺮ ﻣﺘﺨﺼﺺ ﺣﺎرج ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﭼﺎرﻩ اي آﻪ در ﺑﻌﻀﻲ ﺳﻴﺴﺘﻢ هﺎي ﻋﺎﻣﻞ ﻣﺎﻧﻨﺪ‬ ‫‪ Sun/OS‬و ‪ Linux‬اﻧﺪﻳﺸﻴﺪﻩ ﺷﺪﻩ اﺳﺖ‪ ،‬ﻣﻤﺎﻧﻌﺖ از اﺟﺮاي آﺪ در ﻣﺤﻴﻂ ﭘﺸﺘﻪ )‪ (Stack‬اﺳﺖ‪ .‬هﻤﭽﻨﻴﻦ اﻳﻦ روش ﺑﺼﻮرت ﻣﺤﺪودي روي‬ ‫ﺳﻴﺴﺘﻤﻬﺎي وﻳﻨﺪوز ﭘﻴﺎدﻩ ﺷﺪﻩ اﺳﺖ‪ .‬اﻣﺎ ﺑﻬﺘﺮﻳﻦ و راﺣﺘﺘﺮﻳﻦ روش ﺑﺮاي ﻋﻤﻮم ﻧﺼﺐ ﺗﻤﺎم ‪ Patch‬هﺎ و ‪ Fix‬هﺎي اراﺋﻪ ﺷﺪﻩ ﺗﻮﺳﻂ ﺗﻮﻟﻴﺪ آﻨﻨﺪﻩ ﻧﺮم‬ ‫اﻓﺰار اﺳﺖ آﻪ در ‪ %99‬ﻣﻮاﻗﻊ ﻣﻮﺛﺮ ﺧﻮاهﺪ ﺑﻮد‪.‬‬

‫ﺳﻮاﻻت و ﻧﻈﺮات ﺧﻮد را ﺑﻪ ﺁدرس ‪ [email protected]‬ارﺳﺎل ﻧﻤﺎﯾﻴﺪ ‪.‬‬

‫درﯾﺎﻓﺖ اﻃﻼﻋﺎت ﺑﻴﺸﺘﺮ در ﻣﻮرد ‪: PE‬‬ ‫‪http://msdn.microsoft.com/library/en-us/dnwbgen/html/msdn_peeringpe.asp?frame=true‬‬

‫درﯾﺎﻓﺖ ﺑﺮﻧﺎﻣﻪ ‪: LISTDLLS‬‬

‫‪www.hat-squad.com‬‬

‫‪http://www.sysinternals.com/‬‬

‫‪7 Of 7‬‬ ‫‪Copyright © 2003, Hat-Squad Security Group‬‬