
English: 
So, we'll talk about something very different today; very different to my normal image filtering videos -
- and that is "buffer overflow exploits" and what they are and how you do them.
Which is kinda fun
I'm obviously somewhat of a geek, I quite like these sort of things - low level memory exploits.
A buffer overflow exploit is a situation where -
- we're using some, probably low-level C function or something to write a string -
- or some other variable - into a piece of memory that is only a certain length.
But we're trying to write something in that's longer than that -
- and it then overwrites the later memory addresses, and that can cause all kinds of problems.
The first thing we should talk about, probably, is roughly what happens in memory with a program when it's run.
Now, we're talking about C programmes in Linux today, just because I happen to have a Linux VM running here and it's easier.
But this will apply to many different languages and many different operating systems.

Turkish: 
 Yani, bugün çok farklı bir şeyden bahsedeceğiz; normal görüntü filtreleme videolarımdan çok farklı - 
 - ve bu "tampon taşması istismarları" dır ve ne oldukları ve onları nasıl yaptığınızdır. 
 Hangisi eğlenceli 
 Belli ki bir inekten bıktım, bu tür şeyleri oldukça seviyorum - düşük seviyeli bellek kullanımları. 
 Bir arabellek taşması istismarı, - 
 - bazı, muhtemelen düşük seviye C işlevlerini veya bir dize yazmak için bir şeyler kullanıyoruz - 
 - ya da başka bir değişken - yalnızca belirli bir uzunlukta olan bir hafızaya. 
 Ama bundan daha uzun bir şey yazmaya çalışıyoruz - 
 - ve daha sonra hafıza adreslerinin üzerine yazar ve bu her türlü soruna neden olabilir. 
 Konuşmamız gereken ilk şey, muhtemelen, kabaca bir program çalıştırıldığında bellekte olan şeydir. 
 Şimdi, bugün Linux'taki C programlarından bahsediyoruz, çünkü burada çalışan bir Linux VM'si var ve daha kolay. 
 Ancak bu, birçok farklı dil ve birçok farklı işletim sistemi için geçerli olacaktır. 

English: 
So, when a programme is run by the operating system... so we're in some shell and we type in a command to run a programme
The operating system will effectively call, as a function, the main method of your code.
But your actual process, your executable, will be held in memory in a very specific way.
And it's consistent between different processes.
So, we have a big block of RAM. We don't know how big our RAM is because it can be varied, but -
- we use something called Virtual Memory Address Translation to say that -
- everything in here, this is 0. 0x000...
This is the bottom of the memory, as it were
And up here is 0xFFF. So, this is the equivalent of "11111111" memory address -
- all the way up to 32 or 64 bits, and this is 0.
Now, when you use this, there are certain areas of this memory that are always allocated to certain things.
So, up here we have kernel things. So, this will be command line parameters that we can pass to our programme -
- and environment variables and so on.
Down here we have something called the text. That's the actual code of our programme.

Turkish: 
 Yani, bir işletim sistemi tarafından bir program çalıştırıldığında ... kabuğumdayız ve bir programı çalıştırmak için bir komut yazıyoruz 
 İşletim sistemi etkin bir şekilde, kodunuzun ana yöntemini çağırır. 
 Ancak gerçek işleminiz, yürütülebilir durumunuz çok özel bir şekilde bellekte tutulacaktır. 
 Ve farklı süreçler arasında tutarlı. 
 Yani, büyük bir RAM bloğumuz var. RAM'imizin ne kadar büyük olduğunu bilmiyoruz, çünkü değişken olabilir, fakat - 
 - bunu söylemek için Sanal Hafıza Adres Çevirisi denilen bir şey kullanıyoruz - 
 - buradaki her şey, bu 0. 
 Bu hafızanın alt kısmıydı. 
 Ve yukarıda 0xFFF. Yani, bu "11111111" hafıza adresinin eşdeğeridir - 
 - 32 ya da 64 bite kadar, ve bu 0'dır. 
 Şimdi, bunu kullandığınızda, bu belleğin daima belirli şeylere tahsis edilmiş belirli alanları vardır. 
 Öyleyse, burada çekirdeğimiz var. Bu programımıza geçirebileceğimiz komut satırı parametreleri olacak - 
 - ve ortam değişkenleri vb. 
 Burada metin denen bir şey var. Programımızın asıl kodu bu. 

Turkish: 
 Derlediğimiz makine talimatları oraya yüklenmiştir. 
 Şimdi bu salt okunur, çünkü orada uğraşıyor olmak istemiyoruz. 
 Burada verilerimiz var. Böylece başlatılmamış ve başlatılmamış değişkenler burada tutulur. 
 Ve sonra bir yığınımız var. Şimdi, yığın zaman zaman belirtilmiş olabilir. 
 Hafızanıza büyük şeyler ayırdığınız yer. 
 Çeşitli şeyler yapmak için devasa parçalar tahsis edebileceğiniz geniş hafıza alanı. 
 Bununla ne yaptığınız elbette programınıza kalmış. 
 Ve sonra burada, belki de en önemli kısım, bazı yönlerden, yığınıdır. 
 Şimdi yığın her bir fonksiyon için yerel değişkenleri tutar - 
 - ve gibi yeni bir işlev çağırdığınızda, "printf" ve sonra bazı parametreler dediğinizi varsayalım. 
 - yığının sonuna konur. 
 Öyleyse, bellek ekledikçe yığın bu yönde büyür ve yığın bu yönde büyür. 
 Şimdi bunu ortaya koyduğum için artık bunun hakkında konuşmayacağız; biz sadece yığına odaklanacağız, çünkü bu arabellek taşmalarının çoğunun gerçekleştiği yer. 
 Başka alanlarda taşma olabilir, ancak bugün onlarla uğraşmayacağız. 

English: 
The machine instructions that we've compiled get loaded in there.
Now that's read-only, because we don't want to be messing about down there.
In here we have data. So, uninitialised and initialised variables get held here.
And then we have the heap. Now, the heap may have been mentioned from time to time.
It's where you allocate large things in your memory.
Big area of memory that you can allocate huge chunks on to do various things.
What you do with that is, of course, up to your programme.
And then up here, perhaps the most important bit, in some ways anyway, is the stack.
Now the stack holds the local variables for each of your functions -
- and when you call a new function like, let's say you say "printf" and then some parameters -
- that gets put on the end of the stack.
So, the heap grows in this direction as you add memory, and the stack grows in this direction.
Now that I've laid that out, we won't talk about it any more; we'll just focus on the stack, because that's where a lot of these buffer overflows happen.
You can have overflows in other areas, but we're not going to be dealing with them today.

English: 
I'm going to turn this sideways, because I think it's a little bit easier to understand. At least that's how I tend to look at it.
This is our memory again, nice and big. This is now our stack area (excuse my programmer's writing).
Up here we have the high memory addresses (0xff...) So, something up here is high...
... and this is 0x000. Now, of course, the stack won't be taking up this whole region but it doesn't matter.
So, there are high memory addresses and low memory addresses.
And the stack grows downwards, so when we add something onto the end of the stack it gets put on this side and moves in this direction.
Of course, I'm talking about a stack without telling you what a stack is.
Professor Brailsford has already talked about this and has probably done a much better job of explaining it than I would!
Brailsford: There's a lot of computer science that depends on stacks. I sometimes think stacks and trees are just about all computer science is about.
So we'll just say that you know how a stack works and then we'll move on!
We have some programme that's calling a function. A function is some area of code that does something and then returns back to where it was before.
So, this is our calling function here..

Turkish: 
 Bunu yana doğru çevireceğim, çünkü anlaşılmasının biraz daha kolay olduğunu düşünüyorum. En azından öyle bakmaya meyilliyim. 
 Bu bizim hafızamız, güzel ve büyük. Bu şimdi bizim yığın alanımız (programcımın yazdığı için özür dilerim). 
 Burada yüksek bellek adreslerine sahibiz (0xff ...) Yani, burada bir şey yüksek ... 
 ... ve bu 0x000. Şimdi, elbette, yığın bu bölgeyi ele geçirmeyecek, ama önemli değil. 
 Dolayısıyla, yüksek bellek adresleri ve düşük bellek adresleri var. 
 Ve yığın aşağıya doğru büyür, bu yüzden yığının sonuna bir şey eklediğimizde bu tarafa geçer ve bu yöne doğru hareket eder. 
 Tabii ki, size bir yığının ne olduğunu söylemeden bir yığından bahsediyorum. 
 Profesör Brailsford bu konu hakkında çoktan konuştu ve muhtemelen benden çok daha iyi bir açıklama yapacak! 
 Brailsford: Yığınlara bağlı bir çok bilgisayar bilimi var. Bazen yığınların ve ağaçların sadece bilgisayar bilimi ile ilgili olduğunu düşünüyorum. 
 Bu yüzden sadece bir yığının nasıl çalıştığını bildiğinizi söyleyeceğiz ve sonra devam edeceğiz! 
 İşlev çağıran bir programımız var. Bir işlev, bir şey yapan ve daha önce olduğu yere geri dönen bir kod alanıdır. 
 İşte buradaki çağrı fonksiyonumuz .. 

Turkish: 
 Çağıran işlev bir şeyi kullanmak istediğinde, yığına geçirdiği parametrelerini ekler. 
 Bu A parametresi olacak ve bu B parametresi olacak ve ters sırayla yığına eklenecektir. 
 Ve sonra bu fonksiyon için Assembler kodu "call" denilen bir şey yapacaktır - 
 - ve bu hafızadaki başka bir yere atlayacak ve bu iki şeyle çalışacaktır. 
 Ve bu yığının doğasında sorun yaşamamıza neden oluyor. 
 Bazı koda bakalım ve sonra nasıl çalıştığını göreceğiz. 
 Kendimi burada çok iyi olmayan bir program var. Ben yazdım 
 Yani, bu bir C kodu parçası, eğer bakarsak ... 
 Yığına bir miktar bellek ayıran ve komut satırından bir dize kopyalayan çok basit bir C kodudur. 
 Bu yüzden burada, C için verilen ve verilen parametrelerin sayısını belirten ana fonksiyonumuz var. 
 Ve hafızamızın çekirdek alanında tutulacaklar. 
 500 karakter uzunluğunda bir tampon ayırdık ve sonra "string copy" (strcopy) adlı bir fonksiyon çağırıyoruz - 
 - komut satırı parametremizi argv'den arabelleğimize kopyalayacaktır. 
 İşlevimiz, strcopy yaptıktan sonra geri dönmemiz gereken kodu değiştiren bir dönüş adresi koyar. 

English: 
When the calling function wants to make use of something, it adds its parameters that it's passing onto the stack.
This will be parameter A and this will be parameter B, and they will be added into the stack in reverse order.
And then the Assembler code for this function will make something called a "call" -
- and that will jump to somewhere else in memory and work with these two things.
And it's the nature of this stack that causes us to have problems.
Let's look at some code and then we'll see how it works.
I've got myself here a program that isn't very good. I wrote it.
So, it's a piece of C code, so if we look at it...
It's a very simple C code that allocates some memory on the stack and then copies a string into it from the command line.
So up here we've got the main function for C that takes the number of parameters given and a pointer to those variables that you've got.
And they'll be held in kernel area of our memory.
We've allocated a buffer that's 500 characters long and then we call a function called "string copy" (strcopy) -
- which will copy our command line parameter from argv into our buffer.
Our function puts on a return address which is replacing the code we need to go back to once we've done strcopy.

English: 
So that's how main knows where to go after it's finished.
And then we put on a reference to the base pointer in our previous function. We won't worry about that too much because it's not relevant particularly to this video.
This is just going to be our EBP base pointer.
This is our allocated space for our buffer, and it's 500 long.
If we write into it something that's longer than 500, we're going to go straight past the buffer, over this, and crucially over our return variable.
And that's where we point back to something we shouldn't be doing.
What I'm going to do is walk through it in the code and then let's see if it works.
So this is my Kali Linux distribution, which has all kinds of slightly dubious password cracking tools and other penetration testing tools.
It's meant for ethical hacking, let's just make that clear!
I've written here a small function that does our copy from the command line.
Now I've compiled it and I can run it. So I can run my vulnerable code with "Hello".
And that will copy "Hello" into this buffer and then simply return, so nothing happens.
It's the most boring programme ever!

Turkish: 
 Demek ana bittikten sonra nereye gideceğini biliyor. 
 Sonra önceki fonksiyonumuzdaki taban göstergesine bir referans koyduk. Bu konuda çok fazla endişe etmeyeceğiz, çünkü bu özellikle bu videoyla alakalı değil. 
 Bu sadece bizim EBP temel işaretçimiz olacak. 
 Bu bizim tamponumuz için ayrılan alanımız ve 500 uzun. 
 Eğer içine 500'den daha uzun bir şey yazarsak, tampondan doğrudan geçeceğiz, bunun üzerinden ve en önemlisi dönüş değişkenimizin üzerinden geçeceğiz. 
 Ve yapmamamız gereken bir şeye döndüğümüz yer orası. 
 Yapacağım şey kodda dolaşmak ve sonra çalışıp çalışmadığını görelim. 
 İşte bu benim her türlü biraz şüpheli şifre kırma aracı ve diğer sızma testi araçlarına sahip Kali Linux dağıtımım. 
 Etik hackleme amaçlı, hadi bunu açıkça ortaya koyalım! 
 Burada kopyasını komut satırından yapan küçük bir fonksiyon yazdım. 
 Şimdi derledim ve çalıştırabilirim. Böylece güvenlik açığı kodumu "Merhaba" ile çalıştırabilirim. 
 Ve bu, "Merhaba" yı bu arabellek içine kopyalayacak ve sonra geri dönecek, böylece hiçbir şey olmuyor. 
 Şimdiye kadarki en sıkıcı program! 

Turkish: 
 [Sean Riley offscreen] Başka bir program oradaki "Merhaba" kopyasına benzer bir şey yapabilir ve şimdi tampondan çıkar ve işleyebilir mi? 
 Evet, belki de her şeyi büyük harf yapan bir fonksiyonun vardır. 
 Böylece "Merhaba" özelliğini kopyalarsınız ve sonra bu yeni kopyayı büyük harf olacak şekilde değiştirirsiniz ve ardından ekrana gönderirsiniz. 
 Ve bu "main ()" olmak zorunda değildir, bu herhangi bir fonksiyon olabilir. 
 Linux komut satırı hata ayıklayıcısı olan GDB adlı bir şeyi çalıştıracağız. 
 Erm ... 
 Çok fazla Meclis görmeyi ve gerçekten düşük seviyeli Linux işleri yapmayı sevmiyorsanız, GDB'yi kullanmanızı tavsiye etmem. 
 [Sean Riley ekran dışı] Şimdi ekranda bir sürü metin var, bu yüzden endişelenmemize gerek yok - [kes] 
 Hayır, buradaki metin sadece garanti bilgisidir. 
 Şimdi "list" yazacağım - 
 - ve fonksiyonumuzun kodunu kullanıyor. Böylece sadece derlenmiş bir fonksiyon olduğunu görebiliriz. 
 Bunu biliyor çünkü derleyici bu bilgiyi çalıştırılabilir ile birlikte içeriyordu. 
 Bunun için makine kodunu da gösterebiliriz, böylece "disas main" diyebiliriz ve "main ()" kodunu görebiliriz. 
 [Sean Riley offscreen] Yani aslında CPU'ya gidecek talimatlar mı? 
 Bunlar çalıştırılacak olan asıl CPU talimatlarıdır. 
 Şimdi bunun üzerinde durmayacağız, çünkü Meclis belki de benden başkası tarafından yapılan bir dizi konuşmadır! 

English: 
[Sean Riley offscreen] Another program might do something like copy "Hello" in there and now it's in the buffer they can go off and process it?
Yeah, I mean maybe you've got a function that makes things all uppercase.
So you copy "Hello" off and then you change this new copy to be all uppercase, and then you output it to the screen.
And this doesn't have to be "main()", this could be any function.
We're going to run something called GDB, which is the Linux command line debugger.
Erm...
I wouldn't advice using GDB unless you really like seeing lots of Assembly and doing really low-level Linux things.
[Sean Riley offscreen] There's a lot of text on the screen now so we don't have to worry about - [cut off]
No, this text here is just warranty information.
So now I'm going to type in "list" -
- and it shows use the code for our function. So we can see it's just a compiled function.
It knows this because the compiler included this information along with the executable.
We can also show the machine code for this so we can say "disas main" and we can see the code for "main()".
[Sean Riley offscreen] So they're the instructions that would actually go to the CPU?
These are the actual CPU instructions that will be run.
Now we won't dwell on much of this, because Assembly is perhaps a whole series of talks by someone other than me!

English: 
Steve Bagley knows a lot about Assembler.
However, a couple of really important things are:
This line here, sub of 0x1f4 from %esp, that's allocating the 500 for the buffer.
That is we're here and we go 500 in this direction and that's where our buffer goes.
So buffer's sitting to the left in this image but is lower in memory than the rest of our variables.
Now...
We can run this programme from GDB- and if it crashes, we can look at the registers and find out what's happened
So we can say "run Hello" and it will start the programme and say "Hello".
And it's exited normally.
Now, we can pass something in a little bit longer than "Hello".
If we pass something that's over 500, then this buffer will go over this base pointer and this return value, and break the code.
[Sean Riley offscreen] So that will just crash your-
It should just crash it. Python, for example, can produce strings based on simple scripts on the command line

Turkish: 
 Steve Bagley Assembler hakkında çok şey biliyor. 
 Ancak, birkaç önemli şey: 
 Buradaki satır,% esp'den 0x1f4'ün alt kısmı, 500'ü arabellek için ayırır. 
 Biz buradayız ve bu yöne 500 gidiyoruz ve tamponumuzun gittiği yer orası. 
 Bu yüzden tampon bu görüntüde sola oturuyor ama bellekteki değişkenlerimizin geri kalanından daha düşük. 
 Şimdi ... 
 Bu programı GDB'den çalıştırabiliriz ve eğer çökerse, kayıtlara bakabilir ve neler olduğunu bulabiliriz. 
 Böylece “Merhaba koş” diyebiliriz ve program başlayacaktır ve “Merhaba” diyecektir. 
 Ve normal olarak çıkıldı. 
 Şimdi, "Merhaba" dan biraz daha uzun bir şey geçirebiliriz. 
 500'ün üzerinde bir şey iletirsek, bu arabellek bu temel işaretçinin ve bu dönüş değerinin üzerinden geçecek ve kodu kıracak. 
 [Sean Riley ekran dışı] Yani bu sadece senin ... 
 Sadece çarpması gerekir. Python, örneğin, komut satırındaki basit komut dosyalarına dayalı dizeler üretebilir 

Turkish: 
 Öyleyse yaptığımız şey "koşmak" diyoruz ve sonra bir Python baskı senaryosunu geçiyoruz ... 41 (bu "bir" karakter "), 506 kez diyelim. 
 Sadece 500'den biraz daha fazla, bu yüzden bir soruna yol açacak ama bir felakete yol açmayacak. [Chuckling] Tamam mı? 
 Ve sonra onu çalıştırırız. 
 Ve bir segmentasyon hatası aldı. Şimdi bir segmentasyon hatası, yapmamanız gereken bellekte bir şeye erişmeye çalıştığınızda bir CPU'nun size geri göndereceği şeydir. 
 Şimdi bu aslında olmadı, çünkü yapmamamız gereken bir yere yazdık; Olanlar dönüş adresinin bu 41'lerin yarısı üzerine yazılmış olması. 
 [Sean Riley ekran dışı] Yani ne olduğunu bilmiyor mu? 
 Evet, 0xb7004141'de bellekte hiçbir şey yok ve varsa, bu işleme ait değildir. İzin verilmiyor, bu yüzden bir segmentasyon hatası alıyor. 
 Yani bunu 508 olarak değiştirirsek, iki byte daha ileri gideceğiz, bu da şimdi dönüş adresimizin tamamının üzerine yazdığımız anlamına geliyor. 
 Bu "ret" in üzerine 41'ler ile yazıyoruz. Şimdi 414141’de bir virüs kodu olsaydı, bu büyük bir problem. Demek burada bununla gideceğiz. 
 Böylece bunu çalıştırıyoruz ve dönüş adresinin şimdi 0x414141 olduğunu görebilirsiniz. 

English: 
So what we do is we say "run" and then we pass it a Python script of print... 41 (that's the "a" character"), let's say 506 times.
Just a little bit more than 500 so it's going to cause somewhat of a problem but not a catastrophe. [Chuckling] Okay?
And then we run that.
And it's received a segmentation fault. Now a segmentation fault is what a CPU will send back to you when you're trying to access something in memory you shouldn't be doing.
Now that's not actually happened because we overwrote somewhere we shouldn't; what's happened is the return address was half overwritten with these 41s.
[Sean Riley offscreen] So it doesn't know what it is?
Yeah, there is nothing in memory at 0xb7004141, and if there is, it doesn't belong to this process. It's not allowed, so it gets a segmentation fault.
So if we change this to 508, we're going two bytes further along, which means we're now overwriting the entirety of our return address.
We're overwriting this "ret" here with 41s. Now if there were some virus code at 414141, that's a big problem. So that's where we're going with this.
So we run this, and you can see the return address is now 0x414141.

Turkish: 
 Size kayıtları gösterebilirim ve inşaat işaretçisinin şimdi 0x414141'i göstermeye çalıştığını görebilirsiniz. 
 Bu, bu dönüş değerini okuduğu ve koddaki o yere geri döndüğü ve çalıştırdığı anlamına gelir, tabii ki yapamaz. 
 Şimdi biraz daha eğlenebiliriz. Kodumuzu kırdık, şimdi ne yapabiliriz? 
 Yapmamız gereken, bu geri dönüş değerini, vermeye çalıştığımız bazı yüklerin olduğu bir yere değiştirmek - üretmeye çalışıyoruz. Tamam? 
 Neyse ki, bu hata ayıklayıcıyı bırakırsam, sadece bu durum için önceden hazırlanmış bazı yüklerim var! 
 Şimdi aslında bu yük, Assembler'da basit, çok kısa bir programdır, bu da istif üzerine bazı değişkenler koyar ve daha sonra bir kabuk çalıştırmasını söylemek için bir sistem çağrısı yürütür. 
 - yeni bir komut satırı çalıştırmak için. 
 Bu kodu, kabuk kodumuzu gösterirsem, bu kod Linux işletim sistemine ve bir Intel CPU mu yoksa başka bir şey mi kullandığınıza bağlı olacaktır. 

English: 
I can actually show you the registers and you can see that the construction pointer is now trying to point to 0x414141.
So that means that it's read this return value and tried to return to that place in the code and run it, and of course it can't.
Now we can have a little bit more fun. We've broken our code, what can we do now?
Well, what we need to do is change this return value to somewhere where we've got some payload we're trying to give- we're trying to produce. Okay?
So luckily, if I quit this debugger, I have some pre-prepared payload just for this occassion!
Now in fact this payload is just a simple, very short programme in Assembler, that puts some variables on the stack and then executes a system call to tell it to run a shell -
- to run a new command line.
If I show this code, our shell code, this code will depend on the Linux operating system and whether you're using an Intel CPU or something else.

Turkish: 
 Bu sadece bir dizi farklı komuttur. En önemlisi, bu xcd / x80 sistem kesintisini atıyor, bu sistem çağrısını çalıştıracağı anlamına geliyor. 
 Bununla ilgili yapacağımız tek şey bu. Bunun gerçekte yapacağı şey, çok fazla korumaya sahip olmayan eski bir kabuk olan ZSH adlı bir şeyi çalıştırmak. 
 Hata ayıklayıcımıza geri dönelim. 
 Ve ... tekrar koşacağız ama bu sefer biraz daha kötü niyetli bir kod parçası çalıştırmaya gideceğiz. 
 508 kez \ x41'lerimizi koyacağız - ve sonra kabuk kodumuzu koyacağız. İşte gidiyoruz tamam mı? 
 Şimdi tüm 41'leri ve ardından bir sürü kötü niyetli kod yapıyoruz. Şimdi bu aslında çok uzun; çok ileri gittik. Ama bir dakika içinde düzelteceğiz, tamam mı? 
 Ve son olarak, eklemek istediğimiz son şey, birazdan özelleştireceğimiz dönüş adresimizdir. 
 Bundan istifade etmek için yapmamız gereken, strkopinin tamponumuza kopyalayacağı gerçeğini hatırlamak. 
 Yani buradan başlayacağız. Kötü niyetli kodumuzu gösteren bir adresle bu geri dönüş adresinin hafızasının üzerine yazmak istiyoruz. 

English: 
This is just a string of different commands. Crucially, this xcd / x80 is throwing a system interrupt, which means that it's going to run the system call.
That's all we're going to do about this. What this will actually do is run something called ZSH, which is an old shell that doesn't have a lot of protections involved.
Let's go back to our debugger.
And... we're going to run again but this time we're going to run a slightly more malicious piece of code.
We're going to put in our \x41s timesed by 508 - and then we're going to put in our shell code. There we go, okay?
So now we're doing all 41s and then a bunch of malicious code. Now that's actually too long; we've gone too far. But we'll fix that in a minute, okay?
And finally, the last thing we want to add in is our return address, which we'll customise in a moment.
To craft an exploit from this, what we need to do is remember the fact that strcopy is going to copy into our buffer.
So we're going to start here. We want to overwrite the memory of this return address with somewhere pointing to our malicious code.

English: 
Now, we can't necessarily know for sure where our malicious code might be stored elsewhere on the disc, so we don't worry about that or memory.
We want to put it in this buffer. So we're going to put some malicious code in here and then we're going to have a return address that points back into it.
Okay... now...
Memory moves around slightly. When you run these programmes, things change slightly, environment variables are added and removed, things move around.
So, we want to try and hedge our bets and get the rough area that this will go in.
In here, we put in something called a No-Op sled. Or, y'know, there's various other words for it.
So this is simply \x90. That is a machine instruction for "just move to the next one". So that's good.
Anywhere we land in that No-Op is going to tick along to our malicious code.
So we have a load of \x90s here... then we have our shell code, right?
That's our malicious payload that runs our shell.
And then we have the return address, right in the right place, that points back right smack in the middle of these \x90s.

Turkish: 
 Şimdi, kötü niyetli kodumuzun diskin başka bir yerinde nerede saklanabileceğini kesin olarak bilemeyiz, bu yüzden bu konuda veya hafızada endişelenmiyoruz. 
 Bu tamponun içine koymak istiyoruz. Bu yüzden buraya bazı kötü amaçlı kodlar koyacağız ve sonra onu tekrar gösteren bir dönüş adresine sahip olacağız. 
 Şimdi tamam... 
 Hafıza hafifçe hareket eder. Bu programları çalıştırdığınızda, işler biraz değişiyor, ortam değişkenleri ekleniyor ve kaldırılıyor, işler dolaşıyor. 
 Bu yüzden bahislerimizden korunmak ve risk almaktan kaçınmak ve bunun gideceği pürüzlü alanı elde etmek istiyoruz. 
 Buraya No-Op kızağı denilen bir şey koyduk. Ya da bilirsin, bunun için çeşitli kelimeler var. 
 Yani bu sadece \ x90. Bu "sadece bir sonrakine geç" için bir makine talimatıdır. Yani bu iyi. 
 No-Op'a girdiğimiz her yerde, kötü niyetli kodumuzu işaretleyeceğiz. 
 Yani burada bir sürü yük var ... sonra kabuk kodumuz var, değil mi? 
 Bu, kabuğumuzu çalıştıran kötü niyetli yükümüz. 
 Ve sonra dönüş adresi, doğru yerde, bu \ x90'ların ortasında doğru smack'i gösteren nokta. 

Turkish: 
 Ve bunun anlamı, biraz hareket etse bile, yine de işe yarayacak. 
 [Sean Riley ekran dışı] Yani neredeyse bir eğim olması gibi, değil mi? 
 Aynen böyle, evet. Buraya girdiğimiz her yer bilgisayar için gerçek bir soruna yol açacak. 
 [Sean Riley offscreen] Bu yüzden bombamız var ya da biz ... Bilmiyorum ... lav çukuru [gülüyor] 
 Evet, bu bir Sarlacc çukuru değil mi ve No-Op kızağınız sizi içeri alıyor ve 10.000 yıldan fazla bir süre sindiriliyorsunuz. 
 Yani yapmamız gereken üç şey var. Bazı \ x90'ları girmemiz gerekiyor, zaten sahip olduğum kabuk kodumuzu ve geri dönüş adresimizi de girmemiz gerekiyor. 
 En son dönüş adresi için endişelen, tamam mı? Yani... 
 Koduma geri dönersek: ilk koyduğumuz \ x41'leri değiştiririz ve 90'a değiştiririz. Bir sürü No-Op işlemi yapıyoruz. 
 Sonra kabuk kodumuzu aldık ve sonunda dönüş adresimiz olacak olanı aldık. 
 Ve bunlardan 10 tanesini koyacağız, çünkü sadece kabuk kodumuz ile hareket eden yığınımız arasında bir miktar dolgunluk olması gerekiyor. 
 Buradaki 508 kişi, insanların farkına varacak, şimdi bu çok büyük, çünkü ekstra bilgi veriyoruz. 
 Yani, 508 bayt yazarsak tam olarak istediğimiz yere gider: dönüş adresimiz üzerinden. 

English: 
And what that means is, even if these move a bit, it'll still work.
[Sean Riley offscreen] So it's like having a slope almost, is it?
It's exactly like that, yes. Anywhere where we land in here is going to cause a real problem for the computer-
[Sean Riley offscreen] So we've got our bomb, or our... I dunno... pit of lava [laughs]
Yep, it's a Sarlacc pit isn't it and your No-Op sled takes you in and you get digested over 10,000 years or whatever it is.
So we've got three things we need to do. We need to put in some \x90s, we need to put in our shell code, which I've already got, and we need to put in our return address.
Worry about the return address last, okay? So...
If we go back to my code: we change the first \x41s that we were putting in, and we change to 90. We're putting in a load of No-Op operations.
Then we've got our shell code and then we've got what will eventually be our return address.
And we'll put in 10 of those because it's just to have a little bit of padding between our shell code and our stack that's moving about.
This 508 here, people will have noticed, now this is too big, because we're putting in extra information.
So, if we write 508 bytes, it goes exactly where we want: over our return address.

English: 
But we've now got 43 bytes of shell code and we've got 40 bytes of return address.
So... -40... -43... is 425. We'll change this 508 to 425, and so now this exploit here that we're looking at is exactly what I hoped it would be here.
Some \x90 no operation sleds, the shell code and then we've got our return address, which is 10 times four bytes.
We run this and we've got a segmentation fault, which is exactly what we hoped we'd get because our return address hasn't been changed yet.
So now let's look at our memory and work out where our return address should go.
So in GDB, it's paused the programme after the segmentation fault, so we can say "list the registers", let's say about 200 of them, at the stack point of -550.
So that's going to be right at the beginning of our buffer. And what we're seeing here is a load of 90s in a row.

Turkish: 
 Ama şimdi 43 baytlık kabuk kodumuz var ve 40 baytlık geri dönüş adresimiz var. 
 Yani ... -40 ... -43 ... 425. Bunu 508'den 425'e değiştireceğiz, ve şimdi burada baktığımız bu istismar tam olarak burada olmasını umduğum şey. 
 Bazı \ x90 işlem kızakları değil, kabuk kodu ve 10 kez dört baytlık dönüş adresimiz var. 
 Bunu biz yürütüyoruz ve bir segmentasyon hatamız var, bu da tam olarak almayı umduğumuz şeydi, çünkü dönüş adresimiz henüz değişmedi. 
 Öyleyse şimdi hafızamıza bakalım ve iade adresimizin nereye gitmesi gerektiğine bakalım. 
 Bu yüzden GDB'de, bölümleme hatasından sonra programı duraklattı, bu yüzden "kayıtları listele" diyebiliriz, yaklaşık 200'ünü -550 yığın noktasında diyelim. 
 Yani tamponumuzun başında bu doğru olacak. Ve burada gördüğümüz şey, arka arkaya 90'lık bir yük. 

Turkish: 
 O yüzden tam ortasından bir hafıza adresi seçmemiz gerekiyor, o zaman şunu seçelim, diyelim ki 0xbffffaba - 
 - ve şunu yaz ki unutmam. 
 Şimdi, bu konuda güzel bir tuhaflık var, bu da Intel CPU'ların küçük ednyalı olduğu anlamına gelir, bu da onu geriye koymak zorunda kalmam anlamına gelir. 
 Öğrenmemiz gereken daha çok şey var, ama sorun değil! 
 bf ... ff ... fa ... Maalesef büyük harflerle kilidimi aç ... İnsanları izleyerek yazı yazamaz! Errrrm ... ve er, ba. 
 Teorik olarak bunu çalıştırdığımda ne olacağını dize kopyalamak onun işini yapacak: bir dize kopyalayacaktır. 
 Ve sonra, geri dönmeye çalıştığında, bu geri dönüş değerini yükler ve bu arabellekte bir yerde olacak olan bu komutu uygular. 
 Ardından kabuk kodumuzu okur ve çalıştırır, bu yüzden bir kabuk almalıyız. 
 Tamam? 
 [Tappity tappity] 
 Ve biz yaptık! 
 Yani bu iyi bir başlangıç, değil mi? Programımızın çalıştığını biliyoruz. Çok az yan etkisi olan bir hata ayıklayıcıda da var. 
 Şimdi soru şu: bu makineye erişmek için bunu alıp komut satırında kullanabilir miyim? 
 Şimdi ... 

English: 
So we just need to pick a memory address right in the middle of them, so let's pick this one, let's say 0xbffffaba -
- and write that down so I don't forget it.
Now, there's a nice quirk in this, which is that Intel CPUs are little ednian, which means I have to put it in backwards.
It's yet more things we have to learn, but it's fine!
b-f... f-f... f-a... Oops, put my caps-lock on... Can't type with people watching! Errrrm... and er, b-a.
Theoretically when I run this, what will happen is string copy will do its thing: it'll copy a string in.
And then, when it tries to return, it will load this return value and execute that instruction, which will be somewhere in this buffer.
Then it will read off and run our shell code, so we should get a shell.
Okay?
[tappity tappity]
And we did!
So that's a good start, right? We know our program works. Albeit in a debugger with very little side effect.
The question now is: can I take this and use it on a command line to gain access to this machine?
Now...

Turkish: 
 Linux, bazı programlardan neler yapılabileceği ve yapılamayacağı konusunda oldukça kısıtlayıcı politikalara sahiptir, ancak şifrenizi değiştirmek gibi bazı programlar SUID adlı bir şey kullanarak çalıştırılır. 
 Yani bunun anlamı, o programı çalıştırmak uğruna, o makineye tam bir kök erişiminiz olmasıdır. 
 Çünkü aksi takdirde, şifre dosyasını nasıl değiştirirsiniz? Normalde okumasına bile izin verilmiyor. 
 Gölge dosyası Yani... 
 Bu tür bir programda bir güvenlik açığı bulursanız ve olması gerektiğini düşündüğümden daha fazlası varsa, o zaman gerçek bir sorun ortaya çıkar. 
 Şimdi açıkçası bu güvenlik açıkları daha da azalıyor, ancak bir tane alırsanız bu felaket olur. 
 Öyleyse bu hata ayıklayıcısını bırakıp güzel net komut satırı ortamımıza geri dönelim. 
 Elimizdeki dosyaları listelesem, bu savunmasız program kırmızı renkle gösterilir, bu onun SUID kökü olduğunu gösterir. 
 Bu, onu çalıştırdığımızda, kök olarak çalışacağını, güvenlik için mükemmel olmadığını gösterir. 
 Bu ve benim ayakkabılı programlam, yani tampon taşmasına karşı savunmasız. 

English: 
Linux has quite restrictive policies on what can and can't be done from certain programmes, but some programmes, such as changing your password, are run using something called SUID.
So what that means is that, for the sake of running that programme, you have complete root access to that machine.
Because otherwise, how could you change the password file? You're not normally allowed to even read it.
The shadow file. So...
If you find a vulnerability in that kind of programme, and there's more than I think there should be, then that's when there's a real problem.
Now obviously these vulnerabilities are getting rarer, but it's catastrophic if you get one.
So, let's leave this debugger and back to our nice clear command line environment.
If I list the files we've got, this vulnerable programme here is shown in red, that shows that it's SUID root.
Which means that when we run it, it will be running as root, which is not great for security.
That and my shoddy programming, which means it's vulnerable to a buffer overflow.

English: 
So, if I copy my exploit... here we go, this is a big moment of truth, where this whole video is going to work.
I've put my code in just like it was in the debugger. I've tried to make it exactly the same so that the memory doesn't move around.
Let's just say "whoami" on Linux, so we can see I am myself. I don't have root access.
So can I, for example, look at the password file? So I can say "cat /etc/shadow".
"Permission denied". No dice, okay. Fair enough. I'm not supposed to be looking at that.
Now I'm on my exploit, so "./envexec", then my vulnerability, with the right address... now we've got a shell.
"whoami"?
Root.
So now can I look at my shadow file? [Sean Riley offscreen] So root is like God for this system?
In Linux, there is nothing you can't do with root.
So I've got my root shell and I'm root, so I can "cat /etc/shadow", and I can see what's in the shadow file.
But the point is that there's nothing I can't do now, I can wipe the machine, or do anything like that myself.
And then I can quit this and then my programme just gracefully exits. Because it now returns to normal code.
And, hopefully, no-one is any the wiser that anything's gone on.

Turkish: 
 Yani, istismarımı kopyalarsam ... işte başlıyoruz, bu tüm videonun çalışacağı büyük bir gerçek. 
 Kodumu tıpkı hata ayıklayıcısındaki gibi koydum. Tam olarak aynı yapmaya çalıştım, böylece hafıza dolaşmaz. 
 Sadece Linux'ta "whoami" diyelim, böylece kendim olduğumu görebiliriz. Kök erişimim yok. 
 Öyleyse, örneğin, şifre dosyasına bakabilir miyim? Böylece "cat / etc / shadow" diyebilirim. 
 "İzin reddedildi". Zar yok, tamam. Yeterince adil. Buna bakmamam gerekiyordu. 
 Şimdi istismardayım, yani "./envexec", sonra kırılganlığım, doğru adresle ... şimdi bir kabuğum var. 
 "ben kimim"? 
 Kök. 
 Şimdi gölge dosyama bakabilir miyim? [Sean Riley ekran dışı] Yani kök bu sistem için Tanrı gibi mi? 
 Linux'ta root ile yapamayacağınız hiçbir şey yoktur. 
 Böylece benim kök kabuğum var ve ben de kökündüm, böylece "cat / etc / shadow" yazabiliyorum ve shadow dosyasında ne olduğunu görebiliyorum. 
 Fakat mesele şu ki, şu anda yapamayacağım hiçbir şey yok, makineyi silebilir ya da kendim gibi bir şey yapabilirim. 
 Ve sonra bunu bırakabilirim ve sonra programım incelikle çıkıyor. Çünkü şimdi normal koda dönüyor. 
 Ve umarım, hiç kimse bir şeyin olup bittiğine dair hiçbir bilge değildir. 

Turkish: 
 Şimdi, işletim sisteminin bunun olmasını engellemek ve denemek için yaptığı şeyler var: bellek düzeninizi rasgele hale getirmek ve hiçbir şey veya işlem yürütmek yok. 
 Bunun etrafında yollar var; Açıkçası farklı bir video için. 
 Ama ... en azından işler kesinlikle daha iyi hale geliyor. 

English: 
Now there are things that the operating system does to try and stop this from happening: randomising your memory layout and no executing of stacks and stuff.
There are ways around this; they're obviously for a different video.
But... at least things are getting definitely better.
