Detta är en mycket specifik typ av utnyttjande som plågar alla typer av programvara.

Use-After-Free (UAF) är en primitiv minneskorruptionssårbarhet som fortsätter att utgöra ett betydande hot mot alla typer av programvara från operativsystem till applikationsprogram. Detta kritiska säkerhetsfel uppstår när en programkomponent försöker komma åt data i en minnesadress som redan har frigjorts, därav namnet – use-after-free.

UAF-sårbarheter kan leda till potentiell exploatering av programvara eller till och med systemkompromiss. Här är vad UAF-sårbarheten är, varför det händer och hur du kan säkra din programvara från en UAF-sårbarhet.

Vad är sårbarheten för användning efter fri (UAF)?

Innan vi dyker in i sårbarheten Use-After-Free, låt oss ta ett steg tillbaka och förstå några grunder för minneshantering. När ett program körs laddas dess data och kod in i minnet.

Minneshantering är processen att hantera hur man lagrar (kallad minnesallokering) och tar bort (kallad minnesdeallokering) data och kod i minnet på ett optimalt sätt. De två primära minnessegmenten där programdata lagras är

instagram viewer
högen och högen.

Program kan tilldelas minnesutrymme statiskt på stacken och dynamiskt på högen. En sårbarhet utan användning uppstår när programmerare inte hanterar dynamisk minnesallokering och avallokering korrekt i sina program. Detta innebär att UAF-klassen av sårbarheter är en typ av heapexploatering. För att förstå denna sårbarhet bättre, hjälper det att ha en stark förståelse för hur pekare fungerar i programmering.

Use-After-Free (UAF) som namnet antyder, är en typ av sårbarhet för primitiv minneskorruption som uppstår när ett objekt som redan har varit avallokerad från minnet nås igen vilket leder till krascher eller oavsiktliga konsekvenser som minnesläckor, Escalation of Privilege (EOP) eller godtycklig kod avrättning. Låt oss lära oss hur detta tillstånd uppstår i första hand och hur det utnyttjas.

Hur utnyttjas Use-After-Free (UAF)?

Use-After-Free (UAF), som namnet antyder, är en primitiv minneskorruptionssårbarhet som uppstår när ett program fortsätter att komma åt minnesplatser som det har frigjort. Låt oss ta en titt på en exempelkod:

#omfatta <stdio.h>
#omfatta <stdlib.h>
inthuvud(){
int *MUO = malloc (storlek på(int));
 *MUO = 69420;
printf("Värde: %d\n", *MUO);
 fri (MUO);
printf("Värde?: %d\n", *MUO);
lämna tillbaka0;
}

Kunde upptäcka sårbarheten? Som du kan se, i den här koden, MUO pekaren avallokeras från minnet med hjälp av fri() funktion, men den anropas igen på nästa rad med hjälp av printf() fungera. Detta resulterar i oväntat programbeteende och beroende på var sårbarheten finns i programvaran kan den utnyttjas för att få privilegieskalering och minnesläckor.

Hur kan man minska användningen-efter-fri?

UAF uppstår på grund av misstag i programmeringen av en applikation. Det finns några försiktighetsåtgärder du kan vidta för att undvika Use-After-Free-sårbarheter i din programvara.

Här är några bästa praxis som du kan använda för att minimera minneskorruption i din programvara:

  • Använda minnessäkra programmeringsspråk som Rust med inbyggda mekanismer för att förhindra primitiva minneskorruptionssårbarheter som UAF, Buffer Overflows, etc. Om du använder programmeringsspråk som C/C++ är det mer sannolikt att du introducerar minnesbuggar i din kod. Av samma anledning migrerar även operativsystem som Windows och Linux långsamt till Rust. Du bör också överväga lära sig om Rust om du skapar lågnivåprogram.
  • Förutom att använda ett minnessäkert språk rekommenderas att du följer bästa praxis som att ställa in en pekare till NULL-värde efter att den har frigjorts för att undvika introduktion av Use-After-Free-sårbarhet.
  • Du kan också implementera tekniker som One Time Allocation (OTA) som förhindrar angripare från att komma åt frigjort minne objekt och en strikt objektlivscykelpolicy, som hjälper till att hålla reda på varje minnesobjekt som är allokerat och omfördelats. Kom dock ihåg att dessa implementeringar kan öka minne och prestanda omkostnader.

Verkliga exempel på sårbarhet efter användning (UAF).

Sårbarheten Use-After-Free (UAF) har upptäckts och utnyttjats i olika verkliga scenarier från webbläsare till Android-kärna till vardagliga applikationer. Detta visar behovet av proaktiva säkerhetsåtgärder. Några verkliga exempel på UAF inkluderar:

  • Webbläsare: UAF-sårbarheter i webbläsare har utnyttjats för att exekvera godtycklig kod, äventyra användarnas integritet och utföra attacker med fjärrkörning av kod. Ett färskt exempel skulle vara CVE-2021-38008, som utnyttjade en UAF-sårbarhet i Google Chrome, vilket gjorde det möjligt för hotaktörer att exekvera godtycklig kod på distans på offrets dator.
  • Operativsystem: UAF-sårbarheter som finns i Windows/Linux/Android-kärnor har gjort det möjligt för angripare att få förhöjda privilegier, kringgå säkerhetsmekanismer och få uthållighet. Det finns en uppsjö av UAF-sårbarheter som har hittats och som fortfarande finns i operativsystemets kärnor till denna dag. När detta skrivs, CVE-2023-3269, släpptes ännu en UAF-sårbarhet i Linux-kärnan som leder till privilegieupptrappning. CVE-2022-23270 är ett exempel på en UAF-sårbarhet i Windows-kärnan.
  • Programvaruapplikationer: UAF-sårbarheter i mjukvaruapplikationer har utnyttjats för att manipulera program beteende, vilket leder till avslöjande av information, exekvering av godtycklig kod, programkrasch och i värsta fall privilegier upptrappning. Flera programvaror har varit och är fortfarande mottagliga för UAF-attacker. Dessa program är mestadels C/C++-program som har utvecklats med ineffektiva och osäkra minneshanteringsmetoder.

För att lära dig mer om Use-After-Free-sårbarheter i verkliga applikationer kan du kontrollera officiella MITER CVE listsida och sortera efter Use-After-Free nyckelord.

Effektiv minnesallokering gör programvaran säker

Optimal och genomtänkt minnesallokering räcker långt för att skydda dina applikationer från att falla offer för vanliga primitiva minneskorruptionssårbarheter.

UAF tillsammans med Time Of Check Time of Use (TOCTOU), tävlingsförhållanden och Buffer Overflows (BOF) är några av de mest utnyttjade minnessårbarheterna. Alla dessa kan undvikas genom att lära dig hur ditt programs minne hanteras av plattformen det körs på. Detta ger dig klarhet i hur operativsystemet allokerar ditt program i minnet och utrustar dig med verktygen för att designa mjukvara för optimal prestanda och säkerhet.

Om du inte redan har gjort det kan du börja med att förstå hur minneshantering går till på Linux, världens mest använda serveroperativsystem.