Buffer Overflow

  • November 2019
  • PDF

This document was uploaded by user and they confirmed that they have the permission to share it. If you are author or own the copyright of this book, please report to us by using this DMCA report form. Report DMCA


Overview

Download & View Buffer Overflow as PDF for free.

More details

  • Words: 2,203
  • Pages: 7
‫( ﭼﻴﺴﺖ ؟‬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‬‬

Related Documents

Buffer Overflow
November 2019 22
Buffer Overflow
October 2019 24
Buffer Overflow
May 2020 7
Buffer Overflow
November 2019 14