Minnesåtkomstsäkerhet

Minnesåtkomstsäkerhet  är ett koncept inom mjukvaruutveckling som syftar till att undvika buggar som leder till sårbarheter relaterade till åtkomst till en dators RAM , såsom buffertspill och dinglande pekare .

Programmeringsspråk med låg abstraktionsnivå, såsom C och C++ , som stöder direktåtkomst till datorminne (arbiträr pekarritmetik , minnesallokering och deallokering ) och typcasting , men som inte har automatisk kontroll av arraygränser säkra när det gäller minnesåtkomst [1] [2] . C och C++ tillhandahåller dock verktyg (som smarta pekare ) för att förbättra säkerheten för minnesåtkomst. Minneshanteringstekniker tjänar samma syfte [3] . Men att undvika minnesåtkomstfel, särskilt i komplexa system, är ofta inte möjligt [4] .

Minnesåtkomstsårbarheter

En av de vanligaste klasserna av mjukvarusårbarheter är minnessäkerhetsproblem [5] [6] . Denna typ av sårbarhet har varit känd i över 30 år [7] . Minnessäkerhet innebär att förhindra försök att använda eller modifiera data såvida det inte avsiktligt tillåts av programmeraren när programvaran skapades [8] .

Många prestationskritiska program är implementerade i programmeringsspråk med låg abstraktionsnivå ( C och C++ ), som är benägna att drabbas av denna typ av sårbarhet. Bristen på säkerhet för dessa programmeringsspråk tillåter angripare att få full kontroll över programmet, ändra kontrollflödet och få obehörig tillgång till konfidentiell information [9] . För närvarande har olika lösningar på problem relaterade till minnesåtkomst föreslagits. Skyddsmekanismer måste vara effektiva både vad gäller säkerhet och prestanda [10] .

Minnesfel publicerades först 1972 [11] . Och sedan var de problemet med många mjukvaruprodukter, ett verktyg som låter dig använda exploater . Till exempel använde Morris-masken många sårbarheter, av vilka några var relaterade till minnesfel [12] .

Typer av minnesfel

Det finns flera typer av minnesfel (sårbarheter) som kan uppstå i vissa programmeringsspråk: [13] [14] [15]

• Array Bound Violation -  intervall som angavs när arrayen definierades. Separat utmärker sig en speciell undertyp -felet hos en enhet som inte har redovisats[16]. Förekommer i frånvaro av array- ochstränggränskontroller(C, C++)[17].
  • Buffertspill  - skriv utanför bufferten som är allokerad i minnet. Uppstår när ett försök görs att skriva till en buffert ett datablock som är större än storleken på bufferten. Som ett resultat av ett spill kan data som finns bredvid bufferten [18] skadas , eller så kommer programmet att helt ändra sitt beteende, upp till att tolka den skrivna datan som exekverbar kod [19] . Utnyttjande av denna sårbarhet är en av de mest populära metodernaför att hacka datorsystem [20] .
  • Reading out of buffer bounds  - läsning utanför bufferten som är allokerad i minnet. Konsekvenserna kan vara brott mot systemsäkerheten (förlust av konfidentialitet), instabilt och felaktigt beteende hos programmet, feli minnesåtkomsträttigheter[21]. Denna sårbarhet är inkluderad i listan över de vanligaste och farligaste programvarubuggarna[22].

• Fel vid arbete med dynamiskt minne  - felaktig kassering av dynamiskt allokerat minne och pekare. I det här fallet utförs tilldelningen av minne för objekt under exekveringen av programmet [23] , vilket kan leda till körtidsfel. Denna sårbarhet påverkar programmeringsspråk med en låg abstraktionsnivå som stöder direktåtkomst till datorminne (C, C++) [24] .
  • En dinglande pekare [25]  är en pekare som inte refererar till ett giltigt objekt av motsvarande typ. Den här typen av pekare uppstår när ett objekt har tagits bort (eller flyttats), men pekarens värde inte har ändrats tillnull. I det här fallet pekar den fortfarande på minnesplatsen där det givna objektet fanns. I vissa fall kan detta få en angripare att få konfidentiell information; eller, om systemet redan har omallokerat det adresserbara minnet för ett annat objekt, kan en hängande pekaråtkomst korrumpera data som finns där [26] . En specifik undertyp av fel, använd efter fri (åtkomst till ett frigjort minnesområde), är en vanlig orsak till programfel [27] , såsomwebbläsares sårbarheter [28] .
  • Noll pekaråtkomst . En nollpekare har ett speciellt reserverat värde som indikerar att den givna pekaren inte refererar till ett giltigt objekt [29] . En nollpekare kommer att orsaka ett undantag [30] och krascha programmet.
  • Att frigöra tidigare oallokerat minne  är ett försök att frigöra ett område med RAM som för närvarande inte är allokerat (det vill säga gratis). Oftast visar sig detta i dubbel frigöring [31] , när det görs ett upprepat försök att frigöra minne som redan har frigjorts. Denna åtgärd kan orsaka ett minneshanterarfel [ 32] . I C sker detta när den fria funktionen anropas upprepade gångermed samma pekare, utan mellanliggande minnesallokering.
  • Att använda olika minneshanterare  är ett misstag som bryter länken minnesallokator- deallokator och använder olika verktyg för att arbeta med ett segment. Till exempel i C++ att använda gratis på en minnesbit tilldelad med ny eller på liknande sätt använda delete efter malloc . C++-standarden beskriver inte något samband mellan new / delete och C dynamiska minnesfunktioner, även om new / delete i allmänhet implementeras som malloc / free wrappers [33] [34] . Blandad användning kan orsaka odefinierat beteende [35] .
  • Pekarförlust  är förlusten av adressen till ett tilldelat minnesfragment när det skrivs över med ett nytt värde som refererar till ett annat minnesområde [36] . I detta fall är minnet som adresserats av föregående pekare inte längre tillgängligt. Denna typ av fel resulterar i minnesläckor eftersom det tilldelade minnet inte kan frigöras. I C kan detta hända när du omtilldelar resultatet av malloc till samma pekare, utan att frigöra minnet däremellan.

• Oinitierade variabler  variabler som hardeklareratsmen inte satts till något värde som är känt innan deVariabler kommer att ha ett värde, men i allmänhet svåra att förutsäga. Minnessårbarheter kan uppstå i närvaro avoinitierade ("vilda") pekare[37]. Dessa pekare liknar i sitt beteendehängande pekare, ett försök att komma åt dem kommer i de flesta fall att åtföljas avåtkomstfeleller datakorruption. Det är dock möjligt att få konfidentiell information som kan ha blivit kvar i detta minnesområde efter en tidigare användning[38][39].

• Minnets slut  är problem som uppstår när det inte finns tillräckligt med minne för ett visst program.
  • Stack overflow  - programmet överskrider mängden information som kan finnas isamtalsstacken(pekaren till toppen av stacken går utanför gränserna för det tillåtna området). I det här fallet kraschar programmet [40] . Orsaken till felet kan vara djup (eller oändlig)rekursioneller en stor mängd minnesallokering förlokala variablerpå stacken [41] .
  • heap overflow  ett program att allokera mer minne än vad som är tillgängligt för det. Det är en följd av den frekventa (Java[42]) och ofta felaktiga hanteringen avdynamiskt minne. I händelse av ett fel kommer operativsystemet att avsluta den ur dess synvinkel mest lämpliga processen för denna process (ofta den som orsakade felet, men ibland är det godtyckligt[43]).

Felupptäckt

Möjliga fel att arbeta med minne kan upptäckas både under kompilering av programmet och under exekvering ( debugging ).

Förutom varningar från kompilatorn används statiska kodanalysatorer för att upptäcka fel innan programmet byggs . De låter dig täcka en betydande del av farliga situationer genom att undersöka källkoden mer detaljerat än en ytlig analys av kompilatorn. Statiska analysatorer kan detektera: [44] [45] [46] [47]

• Array utanför gränserna
• Använder dinglande (eller noll eller oinitierade) pekare
• Felaktig användning av biblioteksfunktioner
• Minnesläckor på grund av felhantering av pekare

Under programfelsökning kan speciella minneshanterare användas. I det här fallet skapas "döda" minnesområden runt objekten som tilldelats i högen, och när felsökaren kommer in i dem kan den upptäcka fel [48] . Ett alternativ är specialiserade virtuella maskiner som kontrollerar minnesåtkomst ( Valgrind ). Feldetektering underlättas av kodinstrumenteringssystem , inklusive de som tillhandahålls av kompilatorn (Sanitizer [49] ).

Säkerhetsmetoder

De flesta högnivåspråk löser dessa problem genom att ta bort pekarritmetik från språket, begränsa möjligheten att casta och introducera sophämtning som det enda minneshanteringsschemat [50] . Till skillnad från lågnivåspråk, där hastigheten är viktig, utför högnivåspråk oftast ytterligare kontroller [51] , såsom gränskontroll vid åtkomst till arrayer och objekt [52] .

För att undvika minnes- och resursläckor och garantera undantagssäkerhet använder modern C++ smarta pekare . Vanligtvis är de en klass som efterliknar gränssnittet för en vanlig pekare och lägger till ytterligare funktionalitet [53] , såsom att kontrollera gränserna för arrayer och objekt, automatiskt hantera allokering och avallokering av minne för objektet som används. De hjälper till att implementera Resource Acquisition is Initialization (RAII) programmeringsspråket, där förvärvet av ett objekt är oupplösligt kopplat till dess initialisering, och releasen är oupplösligt kopplad till dess förstörelse [54] .

När du använder biblioteksfunktioner bör du vara uppmärksam på deras returvärden för att upptäcka eventuella överträdelser i deras funktion [55] . Funktioner för att arbeta med dynamiskt minne i C signalerar ett fel (brist på ledigt minne av den begärda storleken) genom att returnera en nollpekare istället för en pekare till ett minnesblock [56] ; C++ använder undantag [57] . Korrekt hantering av dessa situationer gör att du kan undvika felaktig (onormal) avslutning av programmet [58] .

Gränskontroller vid användning av pekare förbättrar säkerheten. Sådana kontroller läggs till vid kompilering och kan sakta ner program; speciella hårdvarutillägg (till exempel Intel MPX [59] ) har utvecklats för att snabba upp dem .

På de lägre abstraktionsnivåerna finns det speciella system som ger minnessäkerhet. På operativsystemnivå är detta en virtuell minneshanterare som separerar tillgängliga minnesområden för individuella processer ( stöd för multitasking ) och synkroniseringsfaciliteter för att stödja multitrådning [60] . Hårdvarulagret tenderar också att inkludera vissa mekanismer som skyddsringar [61] .

Anteckningar

1. ↑ Erik Poll. Föreläsningsanteckningar om språkbaserad säkerhet . - Radboud University Nijmegen, 2016. - 21 januari. / "Språkfunktioner som bryter minnessäkerheten inkluderar..."
2. ↑ Laszlo Szekeres, Mathias Payer, Dawn Song. SoK: Eternal War in Memory . — 2013 IEEE Symposium on Security and Privacy, 2013. / "Buggar med minneskorruption i programvara skrivna på lågnivåspråk som C eller C++ är ett av de äldsta problemen inom datorsäkerhet."
3. ↑ ISO Standard C++ Foundation. C++ FAQ:  Minneshantering . isocpp.org . Hämtad 10 februari 2022. Arkiverad från originalet 10 september 2018.
4. ↑ ISO Standard C++ Foundation. C++ FAQ:  Minneshantering . isocpp.org . Hämtad 10 februari 2022. Arkiverad från originalet 10 september 2018. / "Det är klart, om din kod har nya operationer, raderingsoperationer och pekarritmetik överallt, kommer du att stöka till någonstans och få läckor, avvikande pekare, etc." Detta är sant oberoende av hur samvetsgrann du är med dina tilldelningar: så småningom kommer komplexiteten i koden att övervinna den tid och ansträngning du har råd med."
5. ↑ Victor van der Veen, Nitish dutt-Sharma, Lorenzo Cavallaro, Herbert Bos. Minnesfel: Det förflutna, nuet och framtiden . — RAID'12; Amsterdam, Nederländerna, 2012. - 12-14 september. / "... och fortfarande rankas bland de 3 mest farliga mjukvarufelen."
6. ↑ Dawn Song. Minnessäkerhet - Attacker och försvar . - Berkeley CS161 Computer Security, 2015. - Vår. / "Faktum är att efter konfigurationsfel är implementeringsfel förmodligen den största enskilda klassen av säkerhetsfel som utnyttjas i praktiken."
7. ↑ Laszlo Szekeres, Mathias Payer, Dawn Song. SoK: Eternal War in Memory . — 2013 IEEE Symposium on Security and Privacy, 2013. / «Detta problem har funnits i mer än 30 år …»
8. ↑ Dawn Song. Minnessäkerhet - Attacker och försvar . - Berkeley CS161 Computer Security, 2015. - Vår. / "... förhindrar angripare från att läsa eller skriva till andra minnesplatser än de som programmeraren avsåg."
9. ↑ Laszlo Szekeres, Mathias Payer, Dawn Song. SoK: Eternal War in Memory . — 2013 IEEE Symposium on Security and Privacy, 2013. / Applikationer skrivna på lågnivåspråk som C eller C++ är benägna att den här typen av buggar. Bristen på minnessäkerhet... gör det möjligt för angripare att utnyttja minnesbuggar genom att med uppsåt ändra programmets beteende eller till och med ta full kontroll över kontrollflödet."
10. ↑ Laszlo Szekeres, Mathias Payer, Dawn Song. SoK: Eternal War in Memory . — 2013 IEEE Symposium on Security and Privacy, 2013 .
11. ↑ Victor van der Veen, Nitish dutt-Sharma, Lorenzo Cavallaro, Herbert Bos. Minnesfel: Det förflutna, nuet och framtiden . — RAID'12; Amsterdam, Nederländerna, 2012. - 12-14 september. / "Minnesfel diskuterades först offentligt 1972 av Computer Security Technology Planning Study Panel."
12. ↑ Victor van der Veen, Nitish dutt-Sharma, Lorenzo Cavallaro, Herbert Bos. Minnesfel: Det förflutna, nuet och framtiden . — RAID'12; Amsterdam, Nederländerna, 2012. - 12-14 september. / "Internetmasken utnyttjade ett antal sårbarheter, inklusive minnesfelrelaterade sådana."
13. ↑ Laszlo Szekeres, Mathias Payer, Dawn Song. SoK: Eternal War in Memory . — 2013 IEEE Symposium on Security and Privacy, 2013.
14. ↑ Dawn Song. Minnessäkerhet - Attacker och försvar . - Berkeley CS161 Computer Security, 2015. - Vår.
15. ↑ Katrina Tsipenyuk, Brian Chess, Gary McGraw. Seven Pernicious Kingdoms: A Taxonomy of Software Security Errors . - NIST Workshop om Software Security Assurance Tools, Techniques and Metrics, Long Beach, CA, 2005. - November.
16. ↑ Edsger W. Dijkstra. Varför numrering ska börja på noll (EWD 831) . - Plataanstraat 5, 5671 AL NUENEN, Nederländerna, 1982. - 11 augusti. / "... användningen av de andra tre konventionerna har varit en ständig källa till klumpighet och misstag ..."
17. ↑ Richard Jones och Paul Kelly. Gränskontroll för C . - Imperial College, 1995. - Juli. / "Ett svar på denna analys är att kassera C, eftersom denna brist på effektiv kontroll är ansvarig för många programvarufel."
18. ↑ John Erickson. Dataintrång. Utnyttjandets konst . - St Petersburg. : Symbol-Plus, 2010. - S.  139 . — ISBN 978-5-93286-158-5 .
19. ↑ John Erickson. Dataintrång. Utnyttjandets konst . - St Petersburg. : Symbol-Plus, 2010. - S.  142 . — ISBN 978-5-93286-158-5 .
20. ↑ David A. Wheeler. Säker programmering HOWTO . — Publicerad v3.72. — 2015. / "Buffertspill är ett extremt vanligt och farligt säkerhetsbrist..."
21. ↑ Uppräkning av vanlig svaghet. CWE-126: Buffer Over-read (8 december 2015). Hämtad 24 november 2016. Arkiverad från originalet 27 september 2016.  (obestämd) / "Detta inträffar vanligtvis när pekaren eller dess index inkrementeras till en position utanför buffertens gränser..."
22. ↑ Steve Christey. 2011 CWE/SANS Topp 25 mest farliga programvarufel . MITER (13 september 2011). Hämtad 24 november 2016. Arkiverad från originalet 12 april 2018. (obestämd)
23. ↑ Guy Keren. Unix och C/C++ Runtime Memory Management för programmerare (länk ej tillgänglig) (2001-2002). Hämtad 24 november 2016. Arkiverad från originalet 27 september 2016.  (obestämd)  / "Körtidsmiljön definierar inte bara hur minnet allokeras och frigörs ..."
24. ↑ Robert C. Seacord. Säker kodning i C och C++ . — Addison-Wesley, 2013. — S.  162 . - ISBN 978-0-321-82213-0 .
25. ↑ Jonathan Afek, Adi Sharabani. Dinglar pekare. Slå sönder pekaren för skoj och vinst . — Watchfire Corporation, 2007.
26. ↑ Datortidning. En länk till ingenstans, eller en trasig pekare . Hämtad 24 november 2016. Arkiverad från originalet 22 juni 2018.  (obestämd) / "... sårbarheter som kan orsakas av missbruk av pekare och referenser."
27. ↑ Uppräkning av vanlig svaghet. CWE-416: Använd After Free (8 december 2015). Hämtad 24 november 2016. Arkiverad från originalet 18 juli 2019.  (obestämd) / "Att referera till minne efter att det har frigjorts kan få ett program att krascha, använda oväntade värden eller köra kod."
28. ↑ Juan Caballero, Gustavo Grieco, Mark Marron, Antonio Nappa. Undangle: Tidig upptäckt av dinglande pekare i användning-efter-fri och dubbelfri sårbarheter . — IMDEA Software Institute. Madrid, Spanien. / "Use-efter-free-sårbarheter växer snabbt i popularitet, särskilt för att utnyttja webbläsare."
29. ↑ comp.lang.c. Fråga 5.1 . Hämtad 24 november 2016. Arkiverad från originalet 27 september 2016.  (obestämd) / "Språkdefinitionen anger att för varje pekartyp finns det ett speciellt värde ..."
30. ↑ Oracle. Java Platform, Standard Edition 7 API-specifikation . Hämtad 24 november 2016. Arkiverad från originalet 23 april 2018.  (obestämd) / "Kastas när ett program försöker använda null i ett fall där ett objekt krävs."
31. ↑ Uppräkning av vanlig svaghet. CWE-415: Dubbel gratis (8 december 2015). Hämtad 24 november 2016. Arkiverad från originalet 27 september 2016.  (obestämd) / "När ett program anropar free() två gånger med samma argument..."
32. ↑ Yan Huang. Heap overflows och dubbelfria attacker . Hämtad 24 november 2016. Arkiverad från originalet 17 april 2018.  (obestämd) / "Om free(p) redan har anropats tidigare uppstår ett odefinierat beteende."
33. ↑ Andrei Alexandrescu. Modern C++-design: Generisk programmering och applicerade designmönster . - Addison Wesley, 2001.  (otillgänglig länk) / "... det är vanligtvis implementerat som ett tunt omslag runt C heap allocator ..."
34. ↑ Guy Keren. Unix och C/C++ Runtime Memory Management för programmerare (länk ej tillgänglig) (2001-2002). Hämtad 25 november 2016. Arkiverad från originalet 27 september 2016.  (obestämd)  / "Till exempel, GNU C++-kompilatorns nya operatör anropar faktiskt C runtime malloc()-funktionen."
35. ↑ Minneshantering . Hämtad 25 november 2016. Arkiverad från originalet 10 september 2018.  (obestämd) / "C++-operatörerna nya och radera garanterar korrekt konstruktion och förstörelse ... C-style funktionerna ... garanterar inte det."
36. ↑ OWASP. minnesläcka . Hämtad 25 november 2016. Arkiverad från originalet 23 november 2016. (obestämd)
37. ↑ Frågor relaterade till pekare . Datum för åtkomst: 25 november 2016. Arkiverad från originalet 26 februari 2013.  (obestämd) / "Ingenting är mer störande än "vilda" tips!"
38. ↑ Halvar Flake. Attacker på oinitierade lokala variabler (2006). Hämtad 25 november 2016. Arkiverad från originalet 3 juni 2016.  (obestämd) / "Vi tittar på följande situation då..."
39. ↑ Uppräkning av vanlig svaghet. CWE-457: Användning av oinitierad variabel (8 december 2015). Hämtad 25 november 2016. Arkiverad från originalet 2 oktober 2016.  (obestämd) / "En angripare kan ibland kontrollera eller läsa detta innehåll."
40. ↑ Använda och porta GNU Fortran . James Craig, Burley (1 juni 1991). Datum för åtkomst: 25 november 2016. Arkiverad från originalet den 5 oktober 2012. (obestämd)
41. ↑ Danny Kalev. Förstå Stack Overflow (5 september 2000). Datum för åtkomst: 25 november 2016. Arkiverad från originalet den 5 oktober 2012.  (obestämd) / "De två vanligaste orsakerna till ett stackspill..."
42. ↑ John Boyland. Positionspapper: Hantering av "Minnes slut"-fel . — University of Wisconsin-Milwaukee, USA. Arkiverad från originalet den 22 mars 2016. / "Ett "tomt minne"-fel kan vara katastrofalt för ett program, särskilt ett som är skrivet på ett språk som Java som använder minnesallokering ofta."
43. ↑ Mulyadi Santosa. När minnet tar slut i Linux (2006-11-30). Hämtad 15 november 2016. Arkiverad från originalet 14 april 2018.  (obestämd) / "... du kan inte längre allokera mer minne och kärnan dödar en uppgift (vanligtvis den som körs för närvarande)."
44. ↑ Anders Möller och Michael I. Schwartzbach. Statisk programanalys . - Institutionen för datavetenskap, Aarhus Universitet, 2015. - Maj.
45. ↑ Cppcheck - Ett verktyg för statisk C/C++-kodanalys . Hämtad 25 november 2016. Arkiverad från originalet 18 januari 2016.  (obestämd) / "Detektera olika typer av buggar i din kod..."
46. ↑ Semantiska mönster. Minnessäkerhetsanalys med CheckPointer . Hämtad 25 november 2016. Arkiverad från originalet 18 april 2018.  (obestämd) / "Program med pekare kan begå en mängd olika fel vid åtkomst till minnet..."
47. ↑ PVS-studio. Statisk kodanalys (2015-03-25). Hämtad 25 november 2016. Arkiverad från originalet 25 januari 2018. (obestämd)
48. ↑ Emery D. Berger, Benjamin G. Zorn. DieHard: Probabilistisk minnessäkerhet för osäkra språk . — PLDI'06; Ottawa, Ontario, Kanada, 2006. 11-14 juni.
49. ↑ Konstantin Serebryany, Dmitry Vyukov. Hitta raser och minnesfel med kompilatorinstrumentering . GNU Tools Cauldron (10 juli 2012). Hämtad 25 november 2016. Arkiverad från originalet 12 mars 2016. (obestämd)
50. ↑ Erik Poll. Språkbaserad säkerhet: "säkra" programmeringsspråk (nedlänk) . Radboud Universiteit Nijmegen . Hämtad 25 november 2016. Arkiverad från originalet 5 november 2016.  (obestämd)  / "Manuell minneshantering kan undvikas genom att..."
51. ↑ Dinakar Dhurjati och Vikram Adve. Bakåtkompatibla arraygränser Kontrollerar för C med mycket låg overhead . — Institutionen för datavetenskap University of Illinois i Urbana-Champaign. / "... ett olöst problem trots en lång historia av arbete med att upptäcka överträdelser av arraygränser eller buffertöverskridanden, eftersom de bästa befintliga lösningarna hittills antingen är alldeles för dyra för användning i distribuerad produktionskod..."
52. ↑ Bruce Eckel. Tänker i Java. Fjärde upplagan . / "Både arrayer och behållare garanterar att du inte kan missbruka dem. Oavsett om du använder en array eller en container, får du ett RuntimeException om du överskrider gränserna, vilket indikerar ett programmeringsfel."
53. ↑ David Kieras. Använda C++11s smarta pekare . - EECS-avdelningen, University of Michigan, 2016. - Juni. / "Smarta pekare är klassobjekt som beter sig som inbyggda pekare men som också hanterar objekt som du skapar ..."
54. ↑ Microsoft Developer Network. Smarta pekare (Modern C++) . Hämtad 25 november 2016. Arkiverad från originalet 5 december 2017.  (obestämd) / "De är extremt viktiga för RAII-programmeringsspråket eller Resource Acquisition Is Initialization..."
55. ↑ Uppräkning av vanlig svaghet. CWE-252: Okontrollerat returvärde (8 december 2015). Hämtad 25 november 2016. Arkiverad från originalet 18 juli 2019.  (obestämd) / "Programvaran kontrollerar inte returvärdet från en metod eller funktion, vilket kan förhindra att den upptäcker oväntade tillstånd och förhållanden."
56. ↑ Microsoft Developer Network. malloc . Hämtad 25 november 2016. Arkiverad från originalet 5 oktober 2016.  (obestämd) / "malloc returnerar en otypad pekare till det tilldelade minnesområdet, eller NULL om det inte finns tillräckligt med minne."
57. ↑ operatör ny, operatör ny[ ] . Hämtad 25 november 2016. Arkiverad från originalet 29 mars 2018.  (obestämd) / "kastar std::bad_alloc eller annat undantag som härrör från std::bad_alloc (sedan C++11) vid misslyckande att allokera minne"
58. ↑ Paul och Harvey Deitel. C: hur man programmerar .
59. ↑ Intel Developer Zone. Introduktion till Intel® Memory Protection Extensions (16 juli 2013). Hämtad 25 november 2016. Arkiverad från originalet 5 maj 2019. (obestämd)
60. ↑ Sarah Diesburg. Minnesskydd: kärna och användaradressutrymmen . Hämtad 25 november 2016. Arkiverad från originalet 9 augusti 2017. (obestämd)
61. ↑ Michael D. Schroeder och Jerome H. Saltzer. En hårdvaruarkitektur för implementering av skyddsringar . - Tredje ACM-symposiet om operativsystemsprinciper, Palo Alto, Kalifornien, 1971. - 18-20 oktober.

Litteratur

• Eric Poll. Föreläsningsanteckningar om språkbaserad  säkerhet . - Radboud University Nijmegen, 2016. - 21 januari.
• David A. Wheeler. Säker programmering HOWTO . - v3.72 Edition. — 2015.

Länkar

Allmänna publikationer

• Laszlo Szekeres, Mathias Payer, Tao Wei, Dawn Song. SoK: Eternal War in Memory  (engelska) . - IEEE Computer Society Washington, DC, USA, 2013. - 19-22 maj. — ISBN 978-0-7695-4977-4 . - doi : 10.1109/SP.2013.13 .
• Dawn Song. Minnessäkerhet - Attacker och försvar  (engelska) . - Berkeley CS 161 Computer Security, 2015. - Vår.
• Katrina Tsipenyuk, Brian Chess, Gary McGraw. Seven Pernicious Kingdoms: A Taxonomy of Software Security  Errors . - 2005. - 12 december. — ISSN 1540-7993 . - doi : 10.1109/MSP.2005.159 .
• Emery D. Berger, Benjamin G. Zorn. DieHard: Probabilistisk minnessäkerhet för osäkra  språk . — PLDI '06; Ottawa, Ontario, Kanada, 2006. 11–14 juni. — ISBN 1-59593-320-4 . - doi : 10.1145/1133981.1134000 .
• Eric Poll. Språkbaserad säkerhet: "säkra" programmeringsspråk  (eng.)  (nedlänk) . Radboud Universiteit Nijmegen . Tillträdesdatum: 24 november 2016. Arkiverad från originalet 5 november 2016.
• Victor van der Veen, Nitish dutt-Sharma, Lorenzo Cavallaro, Herbert Bos. Minnesfel: Det förflutna, nuet och  framtiden . — RAID'12; Amsterdam, Nederländerna, 2012. - 12-14 september. - ISBN 978-3-642-33337-8 . - doi : 10.1007/978-3-642-33338-5_5 .

Tematiska publikationer

• Guy Keren. Unix och C/C++ Runtime Memory Management för programmerare  (engelska)  (inte tillgänglig länk) (2001-2002). Hämtad 24 november 2016. Arkiverad från originalet 27 september 2016.
• Jonathan Afek, Adi Sharabani. Dinglar pekare. Slå sönder pekaren för skoj och  vinst . — Watchfire Corporation, 2007.
• Juan Caballero, Gustavo Grieco, Mark Marron, Antonio Nappa. Undangle : Tidig upptäckt av dinglande pekare i användnings-efter-fri och dubbelfri sårbarheter  . — ISSTA 2012; Minneapolis, MN, USA, 2012. - 15-20 juli. — ISBN 978-1-4503-1454-1 . doi : 10.1145 / 2338965.2336769 .
• Yan Huang. Heap overflows och dubbelfria attacker  (engelska) (2016). Tillträdesdatum: 24 november 2016.
• Halvar Flake. Attacker på oinitierade lokala  variabler . Black Hat Federal (2006). Tillträdesdatum: 24 november 2016.
• John Boyland. Positionspapper : Hantering av "Minnes slut"-fel  . — ECOOP 2005 Workshop om exceptionell hantering i objektorienterade system; University of Wisconsin-Milwaukee, USA, 2005. - Juli. Arkiverad från originalet den 22 mars 2016.
• David Kieras. Använder C++11 :s smarta pekare  . - EECS-avdelningen, University of Michigan, 2016. - Juni.
• Dinakar Dhurjati, Vikram Adv. Bakåtkompatibla arraygränser Kontrollerar för C med mycket låg  overhead . — ICSE '06; Shanghai, Kina, 2006. 20-28 maj. — ISBN 1-59593-375-1 . - doi : 10.1145/1134285.1134309 .