vault backup: 2023-04-17 16:38:57

Informationssicherheit/Ueb2/Ueb2.md

@@ -149,9 +149,8 @@ sql_injection_advance_5()
 
 ```
 
-
-
 Output:
+```
 t
 th
 thi
@@ -175,6 +174,7 @@ thisisasecretfortomo
 thisisasecretfortomon
 thisisasecretfortomonl
 thisisasecretfortomonly
+```
 
 ### 3
 1. What is the difference between a prepared statement and a statement?
@@ -257,13 +257,42 @@ def sql_injection_mitigation_10():
   
 sql_injection_mitigation_10()
 ```
+
 Output: 
 ```
 webgoat-prd IP: 104.130.219.202
 ```
 
 ## Aufgaben
+
 ### a
+Bei einer SQL-Injection nutzt der Angreifer Sicherheitslücken in Webanwendungen aus, die keine ausreichenden Eingabevalidierungen oder Escaping-Mechanismen implementieren. Dadurch kann der Angreifer die Kontrolle über die SQL-Anfragen erlangen, die von der Anwendung an die Datenbank gesendet werden. Das kann zu unerlaubtem Zugriff auf vertrauliche Daten, Manipulation von Daten, Verlust von Datenintegrität oder sogar Systemkompromittierung führen.
+
+### b
+Um SQL-Injection-Angriffe zu verhindern, können Entwickler verschiedene Maßnahmen ergreifen.
+1. Prepared Statements (Parameterisierte Abfragen): 
+	- vorab kompiliert und die Platzhalter werden anschließend durch die tatsächlichen Werte ersetzt. 
+2. Stored Procedures: 
+	- im Datenbank-System gespeicherte, vorkompilierte Anweisungen, die bei Bedarf aufgerufen werden können. 
+3. Escaping von Benutzereingaben: 
+	- Benutzereingaben werden alle potenziell gefährlichen Zeichen in der Eingabe neutralisiert, bevor sie in die SQL-Abfrage eingefügt werden.
+4. Eingabevalidierung und Whitelisting: 
+	- Eingabevalidierung hilft dabei, unerwünschte Eingaben zu erkennen und abzulehnen. 
+	- Whitelisting hingegen erlaubt nur bestimmte Eingaben und blockiert alles andere.
+5. Verwendung von Least Privilege-Prinzip: 
+	- Benutzerkonten und Anwendungen erhalten nur die minimalen Berechtigungen , die sie für die Durchführung ihrer Aufgaben benötigen. 
+6. Fehlerbehandlung und -logging: 
+	 - Durch eine sorgfältige Fehlerbehandlung und -logging können Entwickler verdächtige Aktivitäten erkennen und darauf reagieren. 
+
+### c
+Das Prinzip des Least Privilege (Minimalberechtigung) ist ein grundlegendes Sicherheitskonzept, bei dem Benutzer und Anwendungen nur die minimal notwendigen Berechtigungen erhalten, um ihre Aufgaben auszuführen. Die Idee dahinter ist, die potenzielle Angriffsfläche zu verringern und die Auswirkungen eines Sicherheitsvorfalls zu begrenzen. Im Kontext von SQL-Injections bedeutet dies, dass die Berechtigungen für Datenbankzugriffe eingeschränkt werden, um die Wahrscheinlichkeit eines erfolgreichen Angriffs zu reduzieren.
+
+Einige der Least Privilege-Maßnahmen, die im Zusammenhang mit SQL-Injections angewendet werden können, sind:
+- Eingeschränkte Benutzerkonten
+- Trennung von Aufgaben
+- Objektberechtigungen
+- Einsatz von Views
+- Einschränkung der SQL-Anweisungen
 
 
 # 2.3
@@ -275,3 +304,134 @@ alert(document.cookie)
 - JSESSIONID=WAoLCuHqYVKBPATEYnT23tGJaJPRHR9xRbDfnd2C
 
 ### 2
+```
+<script>alert()</script>
+```
+
+### 3 
+
+goatApp.js
+```js
+/*
+ * This JavaScript is used to load a Backbone router which is defined by GoatRouter.js
+ */
+
+define(['jquery',
+        'underscore',
+        'backbone',
+        'polyglot',
+        'goatApp/view/GoatRouter',
+        'goatApp/support/goatAsyncErrorHandler'],
+    function ($,
+         _,
+         Backbone,
+         Polyglot,
+         Router,
+         asyncErrorHandler) {
+        'use strict'
+        return {
+            initApp: function () {
+                var locale = localStorage.getItem('locale') || 'en';
+                $.getJSON('service/labels.mvc', function(data) {
+                    window.polyglot = new Polyglot({phrases: data});//i18n polyglot labels
+                    asyncErrorHandler.init();
+                    console.log('about to create app router');//default js
+                    var goatRouter = new Router();//backbone router
+                });//jquery
+
+            }
+        };
+    });
+```
+
+- goatApp/view/GoatRouter sieht wichtig aus
+
+goatApp/view/GoatRouter
+```js
+...
+ var GoatAppRouter = Backbone.Router.extend({
+
+         routes: {
+            'welcome': 'welcomeRoute',
+            'lesson/:name': 'lessonRoute',
+            'lesson/:name/:pageNum': 'lessonPageRoute',
+            'test/:param': 'testRoute',
+            'reportCard': 'reportCard'
+        },
+...
+```
+- test/:param
+	- start.mvc#test/
+
+### 4 
+```
+http://127.0.0.1:8080/WebGoat/start.mvc#test/<script>webgoat.customjs.phoneHome();
+```
+
+ ![[2023-04-17_15-55.png]]
+- sogt dafür, dass die Seite in der Console den output von webgoat.customjs.phoneHome(); ausführt
+- Output:
+```
+phone home said {"lessonCompleted":true,"feedback":"Congratulations. You have successfully completed the assignment.","output":"phoneHome Response is -1941012131","assignment":"DOMCrossSiteScripting","attemptWasMade":true}
+```
+- Antwort: -1941012131
+
+### 5
+
+1. Are trusted websites immune to XSS attacks?
+	- Solution 4: No because the browser trusts the website if it is acknowledged trusted, then the browser does not know that the script is malicious.
+2. When do XSS attacks occur?
+	- Solution 3: The data is included in dynamic content that is sent to a web user without being validated for malicious content.
+3. What are Stored XSS attacks?
+	- Solution 1: The script is permanently stored on the server and the victim gets the malicious script when requesting information from the server.
+4. What are Reflected XSS attacks?
+	- Solution 2: They reflect the injected script off the web server. That occurs when input sent to the web server is part of the request.
+5. Is JavaScript the only way to perform XSS attacks?
+	- Solution 4: No there are many other ways. Like HTML, Flash or any other type of code that the browser executes.
+
+## Aufgaben
+### a
+- XSS eine Art von Sicherheitslücke in Webanwendungen, die es einem Angreifer ermöglicht, bösartige Skripte in die Inhalte einer anderen Benutzerseite einzufügen. XSS-Angriffe treten auf, wenn eine Webanwendung Benutzereingaben ohne ausreichende Validierung in HTML-Code einfügt.
+### b
+- XSS Schwachstellen sind vorallem in Formularen zu finden wenn die Eingaben auf der Website angezeigt werden z.B. Kommentarfunktion oder Blogs
+ 
+### c
+- Zugriff auf vertrauliche Informationen: Ein Angreifer kann durch XSS-Angriffe auf vertrauliche Informationen wie Benutzerdaten, Passwörter, Kreditkarteninformationen, Cookies und Sitzungstoken zugreifen.
+- Identitätsdiebstahl: Durch XSS-Angriffe kann ein Angreifer die Kontrolle über die Sitzung eines Benutzers erlangen und sich als dieser ausgeben, um sensible Aktionen wie Geldtransfers oder den Zugriff auf geschützte Ressourcen durchzuführen.
+- Verbreitung von Malware: Ein Angreifer kann schädlichen Code in eine Website einschleusen, der dann von ahnungslosen Benutzern heruntergeladen und ausgeführt wird, was zur Installation von Malware auf ihren Geräten führen kann.
+ 
+### d
+- Reflected XSS:
+Reflektiertes XSS tritt auf, wenn der Angreifer eine URL oder einen Link erstellt, der schädlichen JavaScript-Code enthält. Wenn ein Benutzer diesen Link anklickt, wird der Schadcode in die Benutzeranfrage an die Webanwendung eingefügt und anschließend vom Server zurück an den Browser gesendet, wo er ausgeführt wird. Da dieser Angriff direkt auf den Benutzer abzielt, ist er häufig in Phishing-E-Mails oder Social-Engineering-Angriffen zu finden.
+ 
+- Persistiend XSS:
+Im Gegensatz zum reflcted XSS wird der schädliche Code in diesem Fall auf dem Webserver gespeichert, z. B. in einem Kommentarbereich, einer Datenbank oder einem Forum. Wenn andere Benutzer die infizierte Seite besuchen, wird der schädliche Code in deren Browser ausgeführt. Persistierendes XSS ist gefährlicher als reflektiertes XSS, da es mehrere Benutzer gleichzeitig betreffen kann und nicht auf Social-Engineering-Angriffe angewiesen ist.
+ 
+- DOM-based XSS:
+DOM-based XSS findet auf der Client-Seite (im Browser) statt und resultiert aus einer unsicheren Manipulation des Document Object Model (DOM). Der Angreifer injiziert schädlichen Code in die Seite, der dann im Browser des Benutzers ausgeführt wird, ohne dass die Webanwendung selbst betroffen ist. Das bedeutet, dass der Angriff nicht vom Webserver, sondern von der Client-Seite kommt, was die Erkennung und Vorbeugung schwieriger macht.
+ 
+### e
+ 
+- Input-Validierung:
+    - Überprüfen von Datenformaten: Sicherstellen dass Daten wie E-Mail-Adressen, Telefonnummern und Postleitzahlen im richtigen Format vorliegen.
+    
+    - Vermeiden von Sonderzeichen: Filtern spezieller Zeichen wie Anführungszeichen und Schrägstriche.
+    
+    - Verwendung von Whitelists: Whitelists von erwarteten Werten, um sicherzustellen, dass nur gültige Daten in der Anwendung akzeptiert werden.
+ 
+- Output-Encoding:
+    - HTML-Entitäten: HTML-Entitäten werden verwendet, um Zeichen wie "<" und ">" in ihrer kodierten Form "<" und ">" anzuzeigen, anstatt sie als Teil des HTML-Codes zu interpretieren. 
+    
+    - JavaScript-Encoding: JavaScript-Encoding wird verwendet, um JavaScript-Code zu codieren, um Skript-Injektions-Angriffe zu verhindern. Zum Beispiel kann "alert('Hello World!')" als "alert(\u0027Hello World!\u0027)" codiert werden.
+    
+    - URL-Encoding: URL-Encoding wird verwendet, um spezielle Zeichen in URLs zu kodieren, um sie sicher anzuzeigen. Zum Beispiel wird ein Leerzeichen in "%20" kodiert.
+    
+    - CSS-Encoding: CSS-Encoding wird verwendet, um CSS-Code zu codieren, um Skript-Injektions-Angriffe zu verhindern. Zum Beispiel kann "background-image: url('image.jpg')" als "background-image: url(\27 image.jpg\27 )" codiert werden.
+    
+    - Sicherheits-Header: Es können Sicherheits-Header wie Content-Security-Policy (CSP) oder X-XSS-Protection verwendet werden, um sicherzustellen, dass nur vertrauenswürdige Ressourcen auf einer Seite geladen werden und um das Risiko von XSS-Angriffen zu verringern.
+ 
+- Content-Security-Policy:
+ 
+- HTTP-Only-Cookies:
+ 
+- Bibliotheken etc. Aktualisieren: