Een blik op het misbruiken van kwetsbaarheden

Aangezien ik ernaar uitkeek dit onderwerp verder te bespreken, wil ik u wat geschiedenis, theorie en praktijk over kwetsbaarheden vertellen. We hebben inmiddels allemaal gehoord dat beveiligingsfouten veel kunnen kosten, we weten allemaal dat we onze software up-to-date moeten houden, we weten allemaal dat veel updates worden veroorzaakt door beveiligingsfouten. Maar vandaag zal ik je een beetje vertellen over hoe deze fouten worden gevonden en misbruikt 🙂 Maar voordat we dit doen, gaan we enkele details verduidelijken om een ​​beter overzicht te krijgen.

Voordat je begint

Allereerst wil ik je vertellen dat we ons gaan concentreren op de eerste kwetsbaarheid die ik heb leren exploiteren, de bekende Buffer loopt over, in deze kwetsbaarheid profiteren we van een gebrek aan geheugenverificatie om leuke dingen te doen 🙂 Maar laten we er wat meer over verduidelijken.

Dit wordt geen realistisch scenario

Ik kan het me niet veroorloven om ze te leren om welk programma dan ook dat ze zien te breken - ten eerste omdat het gevaarlijk is voor hun computers, ten tweede omdat daar meer voor nodig zou zijn dan mijn gebruikelijke quotum aan woorden.

We gaan op reis naar de jaren 80

Wat ik je ga laten zien, kan ik doen op mijn laptop, maar het betekent niet dat het vandaag op een eenvoudige manier kan worden gedaan 🙂 veel van deze concepten zijn al zo vaak benut dat nieuwe beschermingsmethoden en nieuwe methoden om te ontwijken ze zijn tevoorschijn gekomen 😛 maar dat brengt ons terug naar dezelfde plek, er is geen ruimte om dat allemaal te vertellen 🙂

Het werkt mogelijk niet op uw processor

Hoewel ik een heel eenvoudig voorbeeld ga gebruiken, wil ik dat het vanaf het begin heel duidelijk is dat de details hiervan zo talrijk en zo gevarieerd zijn dat, net zoals het eruit kan komen als ik, het gewenste effect misschien ook niet wordt bereikt als je het wilt proberen 🙂 Maar je kunt je voorstellen dat ik dat in deze ruimte niet kan uitleggen, vooral omdat ik met deze inleiding al meer dan 300 woorden heb opgenomen, dus we komen meteen ter zake.

Wat is een Bufferoverloop

Om dit te beantwoorden moeten we eerst de eerste helft van deze combinatie begrijpen.

buffers

Omdat alles draait om geheugen op een computer, is het logisch dat er een soort informatiecontainer moet zijn. Als we erover praten ingangen o uitgangen, komen we direct bij het concept van buffers. Om het kort te houden, een buffer Het is een geheugenruimte met een gedefinieerde grootte waarin we een hoeveelheid informatie gaan opslaan, eenvoudig 🙂

Overflows treden op, zoals de naam al aangeeft, wanneer een buffer wordt gevuld met meer informatie dan hij aankan. Maar waarom is dit belangrijk?

Opstapelen

Ook wel bekend als stacks, ze zijn een abstract gegevenstype waarin we dat kunnen stapel informatie, hun belangrijkste kenmerk is dat ze een ordening hebben LIFO (Laatst in, eerst uit). Laten we even nadenken over een stapel borden, we leggen ze een voor een bovenop, en dan halen we ze er een voor een uit van boven, hierdoor is het laatste bord dat we hebben gelegd (het bord dat bovenaan staat) het eerste bord die we gaan halen, uiteraard als we er maar één bord tegelijk uit kunnen halen en we besluiten het in die volgorde te doen: P.

Nu u deze twee concepten kent, moeten we ze ordenen. Stapels zijn belangrijk omdat elk programma dat we uitvoeren zijn eigen programma heeft executiestapel. Maar deze stapel heeft een bijzonder kenmerk, groeit naar beneden. Het enige dat u hierover moet weten, is dat terwijl een programma wordt uitgevoerd, wanneer een functie wordt aangeroepen, de stapel van een nummer X in het geheugen naar een nummer (Xn) gaat. Maar om door te gaan, moeten we nog een concept begrijpen.

Aanwijzers

Dit is een concept dat veel programmeurs gek maakt als ze beginnen in de wereld van C, in feite is de grote kracht van C-programmering deels te danken aan het gebruik van pointers. Om het simpel te houden, een aanwijzer wijst naar een geheugenadres. Dit klinkt ingewikkeld, maar het is niet zo ingewikkeld, we hebben allemaal RAM in onze machines toch? Nou, dit kan worden gedefinieerd als een opeenvolgende rangschikking van blokkenworden deze locaties normaal gesproken uitgedrukt in hexadecimale getallen (van 0 tot 9 en vervolgens van A tot F, zoals 0x0, 0x1, 0x6, 0xA, 0xF, 0x10). Hier als een merkwaardige opmerking, 0x10 NEE is gelijk aan 10 😛 als we het converteren naar een decimale volgorde, zou het hetzelfde zijn als 15 zeggen. Dit is iets dat in eerste instantie ook meer dan één verwart, maar laten we erop ingaan.

Records

De processors werken met een aantal archief, die werken om locaties van fysiek geheugen naar de processor te verzenden, voor architecturen die 64-bits gebruiken, is het aantal registers hier groot en moeilijk te beschrijven, maar om het idee te krijgen, zijn de registers als pointers, ze geven onder andere aan dingen, een geheugenruimte (locatie).

Oefen nu

Ik weet dat het tot nu toe veel informatie is geweest om te verwerken, maar in werkelijkheid zijn het ietwat complexe problemen die ik op een heel eenvoudige manier probeer uit te leggen, we gaan een klein programma zien dat buffers gebruikt en we gaan het breken om dit te begrijpen over overflows, dit is duidelijk niet Het is een echt programma en we gaan veel van de tegenmaatregelen die tegenwoordig worden gebruikt 'ontwijken', gewoon om te laten zien hoe de dingen eerder werden gedaan 🙂 en omdat sommige van deze principes nodig zijn om complexere dingen te leren 😉

GDB

Een geweldig programma dat ongetwijfeld een van de meest gebruikte is door C-programmeurs. Een van de vele deugden is het feit dat het ons in staat stelt om dit alles te zien waarover we tot nu toe hebben gesproken, registers, de stapel, buffers, enz. 🙂 Laten we eens kijken het programma dat we gaan gebruiken voor ons voorbeeld.

retinput. c

Dit is een vrij eenvoudig programma, we gaan de bibliotheek gebruiken stdio.h om informatie te kunnen verkrijgen en weer te geven in een terminal. We kunnen een functie zien genaamd return_input die een buffer riep reeks, die een lengte heeft van 30 bytes (het char-gegevenstype is 1 byte lang).

De functie gets(array); informatie opvragen via console en functie printf() geeft de inhoud van de array terug en geeft deze weer op het scherm.

Elk programma geschreven in C begint met de functie main(), dit is alleen verantwoordelijk voor het aanroepen van return_input, nu gaan we het programma compileren.

Laten we een beetje nemen van wat ik net deed. De optie -ggdb vertelt gcc om het programma te compileren met informatie voor gdb om correct te kunnen debuggen. -fno-stack-protector Het is een optie die we uiteraard niet zouden moeten gebruiken, maar die we gaan gebruiken omdat het anders mogelijk zou zijn om de bufferoverflow in de stack te genereren. Uiteindelijk heb ik het resultaat getest. ./a.out het voert gewoon uit wat ik zojuist heb gecompileerd, het vraagt ​​om informatie en geeft het terug. Hardlopen 🙂

XNUMX% में antocianosios

Nog een opmerking hier. Kunt u de waarschuwingen zien? het is duidelijk iets om rekening mee te houden als we met code werken of compileren, dit is een beetje voor de hand liggend en er zijn maar weinig programma's die tegenwoordig de functie hebben gets() In de code. Een voordeel van Gentoo is dat door het compileren van elk programma, ik kan zien wat er mis zou kunnen zijn, een "ideaal" programma zou ze niet moeten hebben, maar het zou je verbazen hoeveel grote programma's deze waarschuwingen hebben, omdat ze gewoon ZEER groot zijn en het is moeilijk om deze gevaarlijke functies bij te houden als er veel waarschuwingen tegelijkertijd zijn. Als we nu doorgaan

Debuggen van het programma

Nu kan dit deel een beetje verwarrend zijn, maar aangezien ik al behoorlijk wat heb geschreven, kan ik het me niet veroorloven alles uit te leggen, dus sorry als je ziet dat ik te snel ga 🙂

De code uitschakelen

Laten we beginnen met het bekijken van ons gecompileerde machinetaalprogramma.

Dit is de code van onze hoofdfunctie in bijeenkomst, dit is wat onze processor begrijpt, de lijn aan de linkerkant is het fysieke adres in het geheugen, de <+ n> het staat bekend als compenseren, in feite de afstand vanaf het begin van de functie (hoofd) tot die instructie (bekend als opcode). Dan zien we het type instructie (push / mov / callq…) en een of meer registers. Samengevat kunnen we zeggen dat het de aanduiding is gevolgd door de bron / herkomst en de bestemming. <return_input> verwijst naar onze tweede functie, laten we eens kijken.

return_input

Dit is een beetje ingewikkelder, maar ik wil dat je een paar dingen controleert, er is een tag genaamd <gets@plt> en een laatste opcode genaamd retq geeft het einde van de functie aan. We gaan een paar breekpunten plaatsen, een in de functie gets en een ander in de retq.

lopen

Nu gaan we het programma uitvoeren om te zien hoe de actie begint.

We kunnen zien dat er een kleine pijl verschijnt die de opcode aangeeft waar we zijn, ik wil dat ze rekening houden met de richting 0x000055555555469b, dit is het adres na de oproep naar return_input in functie main , dit is belangrijk omdat dit is waar het programma moet terugkeren wanneer u klaar bent met het ontvangen van het invoer, laten we naar de functie gaan. Nu gaan we het geheugen controleren voordat we de functie openen gets.

Ik heb de hoofdfunctie voor je teruggezet en ik heb de code gemarkeerd waarnaar ik verwees, zoals je kunt zien, vanwege de endianness is opgedeeld in twee segmenten, ik wil dat ze rekening houden met de richting 0x7fffffffdbf0 (de eerste van links na het commando x/20x $rsp) aangezien dit de locatie is die we moeten gebruiken om de resultaten van krijgt te controleren, gaan we verder:

Het programma verbreken

Ik heb die gemarkeerd 0x44444444omdat ze de vertegenwoordiging zijn van onze Ds 🙂 nu zijn we begonnen met toevoegen invoer naar het programma, en zoals u kunt zien, zijn we slechts twee regels verwijderd van ons gewenste adres, we gaan het vullen totdat we net voor de adressen zijn die we in de vorige stap hebben gemarkeerd.

Het retourpad wijzigen

Nu we erin geslaagd zijn om dit gedeelte van de code in te voeren waar het de terugkeer van de functie aangeeft, laten we eens kijken wat er gebeurt als we het adres 🙂 wijzigen in plaats van naar de locatie van de opcode te gaan die volgt op degene die we zojuist hadden, wat denk je als we teruggaan naar return_input? Maar hiervoor is het nodig om het adres dat we willen in binair formaat te schrijven, we gaan het doen met de functie printf van bash 🙂

Nu hebben we de informatie twee keer ontvangen 😀 het programma is daar zeker niet voor gemaakt, maar we zijn erin geslaagd de code te breken en het iets te laten herhalen dat het niet had moeten doen.

Reflecties

Deze eenvoudige wijziging kan worden beschouwd als een exploiteren erg basic 🙂 hij is erin geslaagd het programma te doorbreken en iets te doen wat we willen dat hij doet.

Dit is slechts de eerste stap in een bijna oneindige lijst van dingen om te zien en toe te voegen, er zijn manieren om meer dingen toe te voegen dan simpelweg een bestelling te herhalen, maar deze keer heb ik veel geschreven en alles gerelateerd aan shellcodering Het is een onderwerp om meer te schrijven dan alleen artikelen, complete boeken zou ik zeggen. Sorry als ik niet wat meer heb kunnen verdiepen in onderwerpen die ik leuk had gevonden, maar er zal zeker een kans zijn 🙂 Groeten en bedankt dat je hier bent.