Habang hinahanap ko ang patuloy na pagtalakay sa paksang ito, hayaan mong sabihin ko sa iyo ang kaunting kasaysayan, teorya at kasanayan sa mga kahinaan. Narinig nating lahat sa ngayon na ang mga bahid sa seguridad ay maaaring gastos ng malaki, alam nating lahat na dapat nating panatilihing napapanahon ang aming software, alam nating lahat na maraming mga pag-update ang sanhi ng mga error sa seguridad. Ngunit ngayon sasabihin ko sa iyo ng kaunti tungkol sa kung paano natagpuan at pinagsamantalahan ang mga error na ito 🙂 Ngunit bago ito ay linilinaw namin ang ilang mga detalye upang magkaroon ng isang mas mahusay na pangkalahatang ideya.
Bago ka magsimula
Una nais kong sabihin sa iyo na magtutuon kami sa unang kahinaan na natutunan kong samantalahin, ang alam Umapaw ang Buffer, sa kahinaan na ito sinasamantala namin ang isang kakulangan ng pag-verify sa memorya upang makagawa ng mga nakakatuwang bagay 🙂 Ngunit linawin natin nang kaunti pa tungkol dito.
Hindi ito magiging isang tunay na senaryo sa mundo
Hindi ko kayang turuan silang sirain ang anumang program na nakikita nila 🙂 sapagkat mapanganib para sa kanilang mga computer, pangalawa sapagkat tatagal ito kaysa sa aking karaniwang quota ng mga salita.
Pumunta kami sa isang paglalakbay sa 80s
Ang ipapakita ko sa iyo na magagawa ko sa aking laptop, ngunit hindi ito nangangahulugan na magagawa ito ngayon sa isang simpleng paraan 🙂 marami sa mga konseptong ito ay napagsamantalahan nang maraming beses na ang mga bagong pamamaraan ng proteksyon at mga bagong pamamaraan upang maiwasan ang mga ito ay lumitaw 😛 ngunit na magbabalik sa amin sa parehong lugar, walang puwang upang masabi ang lahat ng iyon 🙂
Maaaring hindi ito gumana sa iyong processor
Kahit na gagamit ako ng isang napakasimpleng halimbawa, nais kong maging malinaw mula sa simula na ang mga detalye nito ay napakarami at iba-iba na tulad ng paglabas nito ng pareho sa akin, kung nais mong subukan ito, ang nais na epekto ay maaaring hindi rin makamit 🙂 Ngunit maiisip mo na hindi ko maipaliwanag sa puwang na ito, lalo na dahil sa pagpapakilala na ito ay kumuha na ako ng higit sa 300 mga salita, kaya't dumidiretso kami sa aming punto.
Ano ang a Overflow ng Buffer
Upang sagutin ito kailangan muna nating maunawaan ang unang kalahati ng kombinasyong ito.
Buffers
Dahil ang lahat ay tungkol sa memorya sa isang computer, lohikal na dapat mayroong ilang uri ng lalagyan ng impormasyon. Kapag pinag-uusapan natin input o output, direkta kaming nakarating sa konsepto ng buffers. Upang mapanatili itong maikli, a nagpapahina ng lakas Ito ay isang puwang ng memorya ng tinukoy na laki kung saan mag-iimbak kami ng isang dami ng impormasyon, simpleng 🙂
Nagaganap ang mga pag-apaw, tulad ng ipinahihiwatig ng pangalan, kapag ang isang buffer ay pinunan ng maraming impormasyon kaysa sa mahawakan nito. Ngunit bakit ito mahalaga?
Magtalaksan
Kilala rin bilang mga stack, ang mga ito ay isang abstract na uri ng data kung saan maaari naming salansan impormasyon, ang kanilang pangunahing katangian ay mayroon silang pag-order LIFO (Huling In First Out). Pag-isipan natin nang isang segundo ang tungkol sa isang salansan ng mga plato, inilalagay namin ito sa isa-isa, at pagkatapos ay inilabas namin ito isa-isa mula sa itaas, ginagawa nito ang huling plato na inilagay namin (ang isa sa tuktok) ay ang unang plato na ilalabas namin, malinaw kung makakakuha lamang kami ng isang plato nang paisa-isa at nagpasya kaming gawin ito sa pagkakasunud-sunod:
Ngayong alam mo na ang dalawang konseptong ito, kailangan nating ayusin ang mga ito. Mahalaga ang mga stack dahil ang bawat programa na pinapatakbo namin ay may kanya-kanyang pagpapatupad ng stack. Ngunit ang stack na ito ay mayroong partikular na katangian, lumalaki. Ang tanging bagay na kailangan mong malaman tungkol dito ay habang ang isang programa ay tumatakbo, kapag ang isang function ay tinawag, ang stack ay napupunta mula sa isang numero X sa memorya sa isang numero (Xn). Ngunit upang magpatuloy kailangan nating maunawaan ang isa pang konsepto.
Mga pahiwatig
Ito ay isang konsepto na nagpapabaliw sa maraming mga programmer kapag nagsimula sila sa mundo ng C, sa katunayan ang dakilang lakas ng C program ay sanhi sa bahagi ng paggamit ng mga payo. Upang mapanatili itong simple, isang pointer tumuturo sa isang address ng memorya. Ito ay kumplikado, ngunit ito ay hindi masyadong kumplikado, lahat tayo ay may RAM sa aming mga machine di ba? Sa gayon, maaari itong tukuyin bilang isang magkasunod na pag-aayos ng mga bloke, ang mga lokasyon na ito ay karaniwang ipinahayag sa mga hexadecimal na numero (mula 0 hanggang 9 at pagkatapos ay mula A hanggang F, tulad ng 0x0, 0x1, 0x6, 0xA, 0xF, 0x10). Dito bilang isang usisero na tala, 0x10 HINDI ay katumbas ng 10 😛 kung iko-convert natin ito sa decimal order magiging pareho ito sa pagsasabi ng 15. Ito ay isang bagay na nalilito din higit sa isa sa una, ngunit bumaba tayo rito.
Records
Gumagana ang mga processor sa isang bilang ng mga tala, na gumagana upang magpadala ng mga lokasyon mula sa pisikal na memorya sa processor, para sa mga arkitektura na gumagamit ng 64-bit, ang bilang ng mga rehistro ay malaki at mahirap ilarawan dito, ngunit upang makuha ang ideya, ang mga rehistro ay tulad ng mga payo, ipinahiwatig nila bukod sa iba pa mga bagay, isang puwang ng memorya (lokasyon).
Ngayon magpraktis
Alam ko na naging maraming impormasyon upang maproseso hanggang ngayon, ngunit sa totoo lang ang mga ito ay medyo kumplikadong mga isyu na sinubukan kong ipaliwanag sa isang napaka-simpleng paraan, makakakita kami ng isang maliit na programa na gumagamit ng mga buffer at masisira natin ito upang maunawaan ito tungkol sa mga pag-apaw, malinaw naman na ang isang ito ay hindi Ito ay isang totoong programa, at "iiwasan" natin ang maraming mga countermeasure na ginagamit ngayon, upang maipakita lamang kung paano nagawa ang mga bagay bago 🙂 at dahil ang ilan sa mga prinsipyong ito ay kinakailangan upang matuto ng mas kumplikadong mga bagay 😉
GDB
Isang mahusay na programa na walang alinlangan na isa sa pinaka ginagamit ng mga programmer C. Kasama sa maraming mga birtud mayroon kaming katotohanang pinapayagan kaming makita ang lahat ng ito na pinag-uusapan natin sa ngayon, mga rehistro, stack, buffer, atbp. See Tingnan natin ang programa na gagamitin namin bilang aming halimbawa.
retinput.c
Pagmamay-ari Christopher Diaz Riveros
Ito ay isang medyo simpleng programa, gagamitin namin ang library stdio.h upang makakuha ng impormasyon at ipakita ito sa isang terminal. Maaari naming makita ang isang function na tinatawag return_input na bumubuo ng a nagpapahina ng lakas tinatawag na ayos, na may haba na 30 bytes (ang uri ng data ng char ay 1 byte ang haba).
Ang pag-andar gets(array); humiling ng impormasyon sa pamamagitan ng console at pagpapaandar printf() ibabalik ang nilalaman ng array at ipinapakita ito sa screen.
Ang bawat programa na nakasulat sa C ay nagsisimula sa pagpapaandar main(), magiging responsable lamang ito sa pagtawag sa return_input, ngayon ay isasama namin ang programa.
Pagmamay-ari Christopher Diaz Riveros
Kunin natin ang kaunting ginawa ko. Ang pagpipilian -ggdb Sinasabi sa gcc na ipagsama ang programa sa impormasyon para sa gdb upang makapag-debug nang maayos. -fno-stack-protector Ito ay isang pagpipilian na malinaw na hindi namin dapat ginagamit, ngunit gagamitin namin dahil kung hindi posible na makabuo ng buffer overflow sa stack. Sa huli nasubukan ko na ang resulta. ./a.out pinapatakbo lang nito ang naipon ko lang, humihingi ito sa akin ng impormasyon at ibinalik ito. Tumatakbo 🙂
Mga Babala
Isa pang tala dito. Nakikita mo ba ang mga babala? malinaw na ito ay isang bagay na isasaalang-alang kapag nagtatrabaho kami sa code o sumulat, medyo halata ito at may ilang mga programa na ngayon ang may function gets() Sa code. Ang isang bentahe ng Gentoo ay sa pamamagitan ng pag-iipon ng bawat programa, nakikita ko kung ano ang maaaring mali, ang isang "perpektong" programa ay hindi dapat magkaroon ng mga ito, ngunit magulat ka kung gaano karaming malalaking programa ang may mga babalang ito sapagkat ang mga ito ay SOBRANG malaki at mahirap subaybayan ang mga ito. mapanganib na pag-andar kapag maraming mga babala nang sabay. Ngayon kung magpapatuloy tayo
Pagde-debug ng programa
Pagmamay-ari Christopher Diaz Riveros
Ngayon ang bahaging ito ay maaaring maging medyo nakalilito, ngunit dahil nakasulat na ako ng sapat, hindi ko kayang ipaliwanag ang lahat, kaya paumanhin kung nakita mo na napakabilis kong pagpunta 🙂
Disarmahan ang code
Magsimula tayo sa pamamagitan ng pagtingin sa aming naipon na programa ng wika ng makina.
Pagmamay-ari Christopher Diaz Riveros
Ito ang code ng aming pangunahing pagpapaandar sa Pagpupulong, ito ang naiintindihan ng aming processor, ang linya sa kaliwa ay ang pisikal na address sa memorya, ang <+ n> ay kilala bilang ginalaw, karaniwang ang distansya mula sa simula ng pagpapaandar (pangunahing) hanggang sa pahayag na iyon (kilala bilang opcode). Pagkatapos ay nakikita namin ang uri ng tagubilin (push / Mov / callq…) at isa o higit pang mga rehistro. Sa kabuuan masasabi nating ito ang pahiwatig na sinusundan ng pinagmulan / pinagmulan at patutunguhan. <return_input> ay tumutukoy sa aming pangalawang pagpapaandar, tingnan natin.
return_input
Pagmamay-ari Christopher Diaz Riveros
Ito ay medyo mas kumplikado, ngunit nais ko lamang na suriin mo ang ilang mga bagay, may isang tawaging tag <gets@plt> at isang huling opcode ang tinawag retq na nagpapahiwatig ng pagtatapos ng pagpapaandar. Ilalagay namin ang isang pares ng mga breakpoint, isa sa pagpapaandar gets at isa pa sa retq.
Pagmamay-ari Christopher Diaz Riveros
Tumakbo
Ngayon ay tatakbo namin ang programa upang makita kung paano nagsisimula ang pagkilos.
Pagmamay-ari Christopher Diaz Riveros
Maaari naming makita na lumilitaw ang isang maliit na arrow na nagpapahiwatig ng opcode kung nasaan tayo, nais kong isaalang-alang nila ang direksyon 0x000055555555469b, ito ang address pagkatapos ng tawag sa return_input sa pagpapaandar main , mahalaga ito dahil dito dapat bumalik ang programa kapag natapos mo na ang pagtanggap input, tara na sa pagpapaandar. Ngayon susuriin namin ang memorya bago ipasok ang pagpapaandar gets.
Pagmamay-ari Christopher Diaz Riveros
Inilagay ko ang pangunahing pagpapaandar para sa iyo, at na-highlight ang code na tinukoy ko, tulad ng nakikita mo, dahil sa katatagan ay pinaghiwalay sa dalawang mga segment, nais kong isaalang-alang nila ang direksyon 0x7fffffffdbf0 (ang una mula sa kaliwa pagkatapos ng commando x/20x $rsp) dahil ito ang lokasyon na dapat nating gamitin upang suriin ang mga resulta ng nakakakuha, ipagpatuloy natin:
Paglabag sa programa
Pagmamay-ari Christopher Diaz Riveros
Na-highlight ko ang mga iyon 0x44444444dahil sila ang representasyon ng ating Ds s ngayon nagsimula na kaming magdagdag input sa programa, at tulad ng nakikita mo, dalawa lamang kaming linya mula sa aming nais na address, pupunan namin ito hanggang sa bago namin ang mga address na na-highlight namin sa nakaraang hakbang.
Pagbabago ng landas sa pagbabalik
Ngayon na nagawa naming ipasok ang seksyon na ito ng code kung saan ipinapahiwatig nito ang pagbabalik ng pagpapaandar, tingnan natin kung ano ang mangyayari kung babaguhin natin ang address 🙂 sa halip na pumunta sa lokasyon ng opcode na sumusunod sa mayroon kaming ilang sandali, ano sa palagay mo kung babalikan natin return_input? Ngunit para dito, kinakailangan upang isulat ang address na gusto namin sa binary, gagawin namin ito sa pagpapaandar printf mula sa bash 🙂
Pagmamay-ari Christopher Diaz Riveros
Ngayon natanggap namin ang impormasyon nang dalawang beses 😀 tiyak na ang programa ay hindi ginawa para doon, ngunit nagawa naming sirain ang code at gawin itong ulitin ang isang bagay na hindi dapat gawin.
Mga Repleksyon
Ang simpleng pagbabago na ito ay maaaring isaalang-alang a katapangang-gawa napaka-basic 🙂 nagawa niyang masira ang programa at gumawa ng isang bagay na nais naming gawin niya.
Ito lamang ang unang hakbang sa isang halos walang katapusang listahan ng mga bagay upang makita at maidagdag, may mga paraan upang magdagdag ng maraming bagay kaysa sa simpleng paulit-ulit na isang order, ngunit sa oras na ito marami na akong nasulat at lahat ng nauugnay sa shell coding ito ay isang paksa upang magsulat ng higit sa mga artikulo, kumpletong mga libro na nais kong sabihin. Paumanhin kung hindi ako nakapagtuklas ng kaunti pa sa mga paksang nais ko, ngunit tiyak na magkakaroon ng pagkakataon 🙂 Pagbati at salamat sa pagpunta rito.
Maging mas direkta. Sumulat ng mas kaunti at ituon ang mahalaga
Kumusta, salamat sa komento.
Upang sabihin ang totoo pinutol ko ang isang mahusay na bahagi ng mga ideya, ngunit kahit na sa tingin ko na iniwan ang pinakamaliit upang ang isang tao na walang kaalaman sa programa ay maaaring makakuha ng isang ideya.
Regards
Ang problema ay ang mga walang kaalaman sa pagprogram na hindi malalaman ang tungkol sa anumang bagay sapagkat ito ay masyadong kumplikado upang magsimula, ngunit ang mga nakakaalam kung paano mag-program ay pinahahalagahan ang pagiging mas direkta.
Sa palagay ko hindi mo maabot ang lahat, kailangan mong pumili, at sa kasong ito ay nagkasala ka na nais mong sakupin nang marami.
Sa pamamagitan ng paraan, sasabihin ko sa iyo bilang isang nakabubuo na pagpuna, gusto ko ang mga paksang ito at nais kong magpatuloy ka sa pagsulat ng mga artikulo, binabati kita!
Sa tingin ko ang parehong bagay.
Maraming salamat sa pareho !! Tiyak na mahirap maunawaan kung paano maabot ang target na madla kung ang totoo ay ang bilang ng mga tao na may advanced na antas ng programa na basahin ang mga artikulong ito ay kaunti (hindi bababa sa maaari itong mapag-isipan batay sa mga komento)
Tiyak na nagkasala ako mula sa pagnanais na gawing simple ang isang bagay na nangangailangan ng isang malawak na kaalaman base upang maunawaan. Inaasahan kong naiintindihan mo na dahil nagsisimula pa lang ako sa pag-blog, hindi ko pa natutuklasan ang eksaktong punto kung saan alam at nauunawaan ng aking mga mambabasa ang sinasabi ko. Gawin itong mas madali upang sabihin ang totoo 🙂
Susubukan kong maging mas maikli kung karapat-dapat nang hindi depersonalizing ang format, dahil ang paghihiwalay ng paraan ng pagsulat mula sa nilalaman ay medyo mas kumplikado kaysa sa maaaring isipin ng isa, kahit papaano naiugnay ako, ngunit sa palagay ko sa huli ay makakapagdagdag ako ng mga linya sa sa halip na pagputol ng nilalaman.
Regards
Saan mo malalaman ang tungkol sa paksa? May inirekumendang libro?
Ang halimbawa ay kinuha mula sa The Shellcoderer's Handbook nina Chris Anley, John Heasman, Felix Linder at Gerardo Richarte, ngunit upang maisagawa ang 64-bit na pagsasalin kailangan kong malaman ang tungkol sa aking arkitektura, ang intel na manwal ng developer, ang mga volume 2 at 3 ay isang medyo maaasahang mapagkukunan para diyan. Mahusay din na basahin ang dokumentasyon ng GDB, na kasama ng utos na 'info gdb', Upang malaman ang Assembly at C maraming mga napakahusay na libro, maliban na ang mga libro ng Assembly ay medyo luma na kaya may puwang upang punan ang isa pang uri dokumentasyon
Ang shellcode mismo ay hindi na epektibo sa mga araw na ito para sa iba't ibang mga kadahilanan, ngunit nakakainteres pa ring malaman ang mga bagong diskarte.
Sana makatulong ito ng kaunti 🙂 Mga pagbati
Magandang artikulo, lumang blog desdelinux ay muling ipinanganak muli =)
Kapag sinabi mong ang remote shell ay hindi gaanong epektibo, nangangahulugan ka ng mga countermeasure na idinisenyo upang pagaanin ang mga pag-atake, tinawag nila itong nakakasakit na seguridad.
Pagbati at panatilihin ito
Maraming salamat Franz 🙂 napakabait na mga salita, talagang sinadya ko na ang Shellcoding ngayon ay mas kumplikado kaysa sa nakikita natin dito. Mayroon kaming ASLR (random generator ng lokasyon ng memorya) ang tagapagtanggol ng stack, ang iba't ibang mga hakbang at countermeasure na naglilimita sa bilang ng mga opcode na maaaring ma-injected sa isang programa, at ito ay nagsisimula pa lamang.
saludos,
Kumusta, gagawa ka ba ng isa pang bahagi sa pagpapalawak ng paksa? Nakakainteres
Kamusta, ang paksa ay tiyak na kagiliw-giliw, ngunit ang antas ng pagiging kumplikado na kukunin namin ay magiging napakataas, marahil ay nagsasangkot ng isang malaking bilang ng mga post upang ipaliwanag ang iba't ibang mga kinakailangan upang maunawaan ang iba. Marahil ay susulat ako tungkol dito, ngunit hindi ito ang mga sumusunod na post, nais kong magsulat ng ilang mga paksa bago magpatuloy sa ito.
Pagbati, at salamat sa pagbabahagi
Napakahusay che! Nag-aambag ka ng magagaling na mga post! Isang tanong, sinisimulan ko ang bagay na IT Security sa pamamagitan ng pagbabasa ng isang libro na tinawag na "Tinitiyak ang seguridad sa pamamagitan ng pagsubok sa pen." Inirekomenda ba ang librong ito? Paano mo iminungkahi na magsimula akong magtanong tungkol sa mga isyung ito?
Kumusta cactus, ito ay isang buong uniberso tungkol sa mga kahinaan, at iba pa, upang sabihin ang katotohanan na depende ito sa kung ano ang nakakakuha ng iyong pansin, at ang mga pangangailangan na mayroon ka, ang isang IT manager ay hindi kailangang malaman ang kapareho ng isang pen-tester, O isang investigator ng kahinaan, o isang forensic analyst, ang isang koponan sa pagbawi ng sakuna ay may ibang-ibang hanay ng mga kasanayan. Malinaw na ang bawat isa sa kanila ay nangangailangan ng iba't ibang antas ng kaalamang panteknikal, inirerekumenda kong simulan mong tuklasin kung ano mismo ang gusto mo, at simulang ubusin ang mga libro, artikulo, at iba pa, at higit sa lahat, pagsasanay ang lahat ng iyong nabasa, kahit na ito ay wala na sa panahon , iyon ay magkakaroon ng pagkakaiba sa huli.
saludos,
Hello.
Maraming salamat sa pagpapaliwanag ng paksang ito, pati na rin ang pagbibigay ng puna na para sa labis na impormasyon mayroon kaming "Ang Handbook ng Shellcoder". Meron na akong nakabinbing pagbabasa 😉