Stored XSS (Typ 2)
Es werden Daten hinter oder vor den Bereich des Puffers geschrieben.
C /C++
Hoch
Speichermodifikation; DoS: Crash, Beendigung oder Neustart; Ausführen von nicht autorisiertem Code oder Befehlen
int id_sequence[3];
/* Populate the id array. */
id_sequence[0] = 123;
id_sequence[1] = 234;
id_sequence[2] = 345;
id_sequence[3] = 456;int returnChunkSize(void *) {
/* if chunk info is valid, return the size of usable memory,
* else, return -1 to indicate an error
*/
...
}
int main() {
...
memcpy(destBuf, srcBuf, (returnChunkSize(destBuf)-1));
...
}void host_lookup(char *user_supplied_addr){
struct hostent *hp;
in_addr_t *addr;
char hostname[64];
in_addr_t inet_addr(const char *cp); // function prototype
/* routine that ensures user_supplied_addr is in the right format for
conversion */
validate_addr_form(user_supplied_addr);
addr = inet_addr(user_supplied_addr);
hp = gethostbyaddr( addr, sizeof(struct in_addr), AF_INET);
strcpy(hostname, hp->h_name);
}char * copy_input(char *user_supplied_string){
int i, dst_index;
char *dst_buf = (char*)malloc(4*sizeof(char) * MAX_SIZE);
if ( MAX_SIZE <= strlen(user_supplied_string) ) die("string too long");
dst_index = 0;
for ( i = 0; i < strlen(user_supplied_string); i++ ){
if( '&' == user_supplied_string[i] ){
dst_buf[dst_index++] = '&';
dst_buf[dst_index++] = 'a';
dst_buf[dst_index++] = 'm';
dst_buf[dst_index++] = 'p';
dst_buf[dst_index++] = ';';
}
else if ( '<' == user_supplied_string[i] ){ /* encode to < */ }
else dst_buf[dst_index++] = user_supplied_string[i];
}
return dst_buf;
}char* trimTrailingWhitespace(char *strMessage, int length) {
char *retMessage;
char message[length+1]; // copy input string to a
int index; // temporary string
for (index = 0; index < length; index++) { //
message[index] = strMessage[index]; //
} //
message[index] = '\0'; //
int len = index-1; // trim trailing whitespace
while (isspace(message[len])) { //
message[len] = '\0'; //
len--; //
} //
retMessage = message;
return retMessage; // return trimmed string
}
.. solution::
:pwd: Whitespace
Das Problem ist, dass Zeichenketten, die nur aus Whitespace bestehen, nicht korrekt behandelt werden. In diesem Fall kommt es zu einem Buffer-Underflow (d. h. es wird auf den Speicherbereich vor dem Puffer zugegriffen).If an argument (character) passed to the isspace() function is a white-space character, it returns non-zero integer. If not, it returns 0.
int i;
unsigned int numWidgets;
Widget **WidgetList;
numWidgets = GetUntrustedSizeValue();
if ((numWidgets == 0) || (numWidgets > MAX_NUM_WIDGETS)) {
ExitError("Incorrect number of widgets requested!");
}
WidgetList = (Widget **)malloc(numWidgets * sizeof(Widget *));
printf("WidgetList ptr=%p\n", WidgetList);
for(i=0; i<numWidgets; i++) {
WidgetList[i] = InitializeWidget();
}
WidgetList[numWidgets] = NULL;
showWidgets(WidgetList);Verwendung einer sicheren Programmiersprache (Java, ...)
Verwendung von Bibliotheken, die sicherer sind (z. B. strncpy statt strcpy)
Kompilierung mit entsprechenden Flags, die entsprechende Prüfung aktivieren (z. B. -D_FORTIFY_SOURCE=2)
Kompilierung als Position-Independent-Code
Dies löst nicht das Problem, aber es macht es schwerer eine Schwachstelle auszunutzen.
Statische Analyse Werkzeuge
Dynamische Analyse Werkzeuge (z. B. Fuzzing, Fault Injection, ...)
Nutzereingaben werden nicht oder falsch bereinigt, bevor sie in die Ausgabe eingefügt werden, die als Webseite für andere Benutzer verwendet wird.
Hoch
Speichermodifikation; DoS: Crash, Beendigung oder Neustart; Ausführen von nicht autorisiertem Code oder Befehlen
Zugriffskontrolle, Vertraulichkeit
Stored XSS (Typ 2), Reflected XSS (Typ 1), DOM-based XSS (Typ 0)
Durch eine XSS Lücke werden häufig Informationen abgegriffen (z. B. Session Cookies). Allerdings ist es ggf. auch möglich, dass der Angreifer die Session des Nutzers übernimmt und sich als dieser ausgibt.
Reflected XSS ist häufig schwerer auszunutzen, da der Angreifer den Nutzer dazu bringen muss, einen Link zu klicken, der den Angriffsvektor enthält. Bei Stored XSS ist dies nicht notwendig, da der Angriffsvektor bereits auf dem Server gespeichert ist.
Dom-based XSS ist am schwersten Auszunutzen, da der Angreifer den Nutzer dazu bringen muss den Schadcode in die Informationen einzubringen, die von dem Script verarbeitet werden (z. B. durch das Eingeben in ein Formular).
# Rückgabe einer Willkommensnachricht basierend auf dem
# HTTP Get username Parameter
$username = $_GET['username'];
echo '<div class="header"> Welcome, ' . $username . '</div>';<% String eid = request.getParameter("eid");
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("select * from emp where id="+eid);
if (rs != null) {
rs.next();
String name = rs.getString("name");
}
%>
Employee Name: <%= name %>$username = mysql_real_escape_string($username);
$fullName = mysql_real_escape_string($fullName);
$query = sprintf('Insert Into users (uname,pwd,fname) Values ("%s","%s","%s")',
$username,
crypt($password),
$fullName) ;
mysql_query($query);
...Verwendung von geprüften/sicheren APIs
Verringerung der Angriffsfläche mit dem Ziel möglichst wenig Daten in Cookies etc. zu speichern.
Prüfung dass alle Client-seitigen Prüfungen auch Server-seitig vorgenommen werden.
Prüfe jeden Input.
Verwendung von HttpOnly Cookies (d. h. Cookies, die nicht über JavaScript ausgelesen werden können)
Statische Analyse Werkzeuge
Beherzigen von Best Practices (XSS Prevention Cheat Sheet)
Ein SQL-Befehl wird ganz oder teilweise unter Verwendung extern beeinflusster Eingaben von einer vorgelagerten Komponente erzeugt, bereinigt aber spezielle Elemente nicht oder falsch, die den beabsichtigten SQL-Befehl verändern könnten, wenn er an eine nachgelagerte Komponente gesendet wird.
Hoch
Datenbanken
Zugriffskontrolle, Vertraulichkeit, Integrität
SELECT ITEM,PRICE FROM PRODUCT WHERE ITEM_CATEGORY='$user_input' ORDER BY PRICE$id = $_COOKIE["mid"];
mysql_query("SELECT MessageID, Subject FROM messages WHERE MessageID = '$id'");Verwendung von geprüften/sicheren APIs.
Verwendung von Prepared Statements.
Datenbank nur mit den notwendigen Rechten betreiben (Principle of Least Privilege)
Sollte es notwendig sein einen dynamischen SQL Befehl zu erstellen, dann sollten geprüfte Escapefunktionen verwendet werden.
Statische Analyse Werkzeuge
ggf. Application-level Firewall einsetzen
Referenzierung von Speicher nach der Freigabe kann dazu führen, dass ein Programm abstürzt, unerwartete Werte verwendet oder Code ausführt.
Hoch
C, C++
Verfügbarkeit, Vertraulichkeit, Integrität
char* ptr = (char*)malloc (SIZE);
if (err) {
abrt = 1;
free(ptr);
}
...
if (abrt) {
logError("operation aborted before commit", ptr); // Use of ptr after free
}#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define BUFSIZER1 512
int main(int argc, char **argv) {
char *buf1R1, *buf2R1, *buf2R2;
buf1R1 = (char *) malloc(BUFSIZER1);
buf2R1 = (char *) malloc(BUFSIZER1);
printf("buf2R1 -> %p\n",buf2R1);
free(buf2R1);
buf2R2 = (char *) malloc(BUFSIZER1);
strncpy(buf2R1, argv[1], BUFSIZER1-1);
printf("[FREED] %p\n",buf2R1);
printf("buf2R2 -> %p\n",buf2R2);
printf("buf2R2 = %s\n",buf2R2);
free(buf1R1);
free(buf2R2);
}Fragen:
Wird dieses Program bis zum Ende laufen oder abstürzen?
Welche Ausgabe erzeugt das Programm?
Ist die Ausgabe bei jedem Lauf gleich?
// clip_mkip (clip.c):
198 static void clip_push(struct atm_vcc *vcc,struct sk_buff *skb) {
...
234 memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
235 netif_rx(skb);
236 }
...
510 clip_push(vcc,skb);
511 PRIV(skb->dev)->stats.rx_packets--;
512 PRIV(skb->dev)->stats.rx_bytes -= len;
// netif_rx (dev.c):
1392 int netif_rx(struct sk_buff *skb) {
...
1428 kfree_skb(skb); //drop skb
1429 return NET_RX_DROP;Wahl einer sicheren Programmiersprache (z. B. RUST)
explizites NULL setzen, nachdem der Speicherbereich freigegeben wurde
Fuzzing
Statische Analyse Werkzeuge
Empfohlene Lektüre: One day short of a full chain: Real world exploit chains explained (In Teil 1 wird eine UAF Schwachstelle genutzt.)
Alles oder zumindest ein Teil eines Betriebssystembefehls hängt von extern beeinflussten Eingaben ab. Es erfolgt jedoch keine Bereinigung spezieller Elemente, die den beabsichtigten Betriebssystembefehl verändern könnten.
Hoch
Verfügbarkeit, Vertraulichkeit, Integrität
Ein bestimmtes Program wird ausgeführt und die Nutzerdaten werden als Parameter übergeben.
Die Anwendung bestimmt basierend auf den Nutzerdaten welches Program mit welchen Parametern ausgeführt wird.
...
String btype = request.getParameter("backuptype");
String cmd = new String("cmd.exe /K \"
c:\\util\\rmanDB.bat "
+btype+
"&&c:\\utl\\cleanup.bat\"")
System.Runtime.getRuntime().exec(cmd);
...Verwendung von geprüften/sicheren APIs.
Anwendung bzw. Befehl nur mit den notwendigen Rechten betreiben (Principle of Least Privilege) bzw. in einer Sandbox ausführen.
Statische Analyse Werkzeuge
Dynammische Analyse in Kombination mit Fuzzing
Manuelle Code Reviews/Statische Analyse
ggf. Application-level Firewall einsetzen
Empfangene Eingaben oder Daten werden nicht nicht oder falsch validiert in Hinblick darauf, dass die Eingaben die Eigenschaften haben, die für eine sichere und korrekte Verarbeitung der Daten erforderlich sind.
Hoch
Verfügbarkeit, Vertraulichkeit, Integrität
Rohdaten - Strings, Zahlen, Parameter, Dateiinhalte, etc.
Metadaten - Information über die Rohdaten, wie zum Beispiel Header oder Größe
Größen wie Größe, Länge, Häufigkeit, Preis, Rate, Anzahl der Vorgänge, Zeit usw.
implizite oder abgeleitete Größen, wie z. B. die tatsächliche Größe einer Datei anstelle einer angegebenen Größe
Indizes, Offsets oder Positionen in komplexeren Datenstrukturen
Schlüssel von Hashtabellen, assoziativen Feldern usw.
syntaktische Korrektheit - Übereinstimmung mit der erwarteten Syntax
Bestimmung des tatsächlichen Typs der Eingabe (oder das, was die Eingabe zu sein scheint)
Konsistenz zwischen den Rohdaten und Metadaten, zwischen Referenzen usw.
semantische Korrektheit bzw. Konformität mit domänenspezifischen Regeln, z. B. Geschäftslogik
Authentizität von z. B. kryptografischen Signaturen
C:
#define MAX_DIM 100
int m,n, error; /* m,n = board dimensions */
board_square_t *board;
printf("Please specify the board height: \n");
error = scanf("%d", &m);
if ( EOF == error ) die("No integer passed!\n");
printf("Please specify the board width: \n");
error = scanf("%d", &n);
if ( EOF == error ) die("No integer passed!\n");
if ( m > MAX_DIM || n > MAX_DIM ) die("Value too large!\n");
board = (board_square_t*) malloc( m * n * sizeof(board_square_t));
...(begrenzt) Statische Analyse Werkzeuge
Manuelle statische Analyse insbesondere in Hinblick auf die zugrundeliegende Semantik
Dynamische Analyse mit Fuzzing
Daten vor oder nach einem Puffer werden gelesen.
Hoch
C, C++
Vertraulichkeit
Umgehung von Schutzmaßnahmen; Lesen von Speicher
Die Ausnutzung dieser Schwachstelle ist häufig schwierig, da nicht immer bekannt ist welche und wie viele Daten gelesen werden können. Es kann allerdings möglich sein Speicheradressen auszulesen. Dies kann ggf. genutzt werden, um Mechanismen wie ASLR zu umgehen.
C:
int getValueFromArray(int *array, int len, int index) {
int value;
// check that the array index is less than the maximum length of the array
if (index < len) {
// get the value at the specified index of the array
value = array[index];
}
// if array index is invalid then output error message
// and return value indicating error
else {
printf("Value is: %d\n", array[index]);
value = -1;
}
return value;
}eine sichere Programmiersprache verwenden
Fuzzing
Statische Analyse Werkzeuge welche Kontroll- und Datenflussanalyse durchführen
Externe Eingaben werden für die Konstruktion eines Pfadnamens verwendet, der eine Datei oder ein Verzeichnis identifizieren soll, das sich unterhalb eines eingeschränkten übergeordneten Verzeichnisses befindet. Eine Bereinigung spezieller Elemente innerhalb des Pfadnamens erfolgt jedoch nicht ordnungsgemäß, was dazu führen kann, dass der Pfadname zu einem Ort außerhalb des eingeschränkten Verzeichnisses aufgelöst wird.
Hoch
Vertraulichkeit, Integrität, Verfügbarkeit
PHP:
<?php
$file = $_GET['file'];
include("/home/www-data/$file");
?>Perl:
my $Username = GetUntrustedInput();
$Username =~ s/\.\.\///; # Remove ../
my $filename = "/home/user/" . $Username;
ReadAndSendFile($filename);Java:
String path = getInputPath();
if (path.startsWith("/safe_dir/")) {
File f = new File(path);
f.delete()
}Python:
import os
import sys
def main():
filename = sys.argv[1]
path = os.path.join(os.getcwd(),
filename)
try:
with open(path, 'r') as f:
file_data = f.read()
except FileNotFoundError as e:
print("Error - file not found")
# do something with file_dataDokumentation os.path.join:
Join one or more path components intelligently. The return value is the concatenation of path and any members of *paths with exactly one directory separator following each non-empty part except the last, meaning that the result will only end in a separator if the last part is empty.
If a component is an absolute path [...], all previous components are thrown away and joining continues from the absolute path component.
Eingabe vollständig validieren; zum Beispiel über kanonische Pfade
Sandboxen
Umgebung härten
Bei Fehlerausgaben darauf achten, dass keine Informationen über das Dateisystem preisgegeben werden
den Code mit minimalen Rechten ausführen
Die Webanwendung prüft nicht bzw. kann nicht prüfen, ob eine Anfrage absichtlich von dem Benutzer gestellt wurde, von dessen Browser sie übermittelt wurde.
d. h. eine CSRF Schwachstelle nutzt das Vertrauen aus, das eine Webseite in den Browser eines Nutzers hat. Bei einem CSRF-Angriff wird ein legitimer Nutzer von einem Angreifer dazu gebracht, ohne sein Wissen eine Anfrage zu übermitteln, die er nicht beabsichtigt hat und auch nicht bemerkt.
Mittel
Hängt von den Nutzerrechten ab
Vertraulichkeit, Integrität, Verfügbarkeit
Fiber ist ein von Express inspiriertes Web-Framework, das in Go geschrieben wurde. In der Anwendung wurde eine Cross-Site Request Forgery (CSRF)-Schwachstelle entdeckt, die es einem Angreifer ermöglicht, beliebige Werte zu injizieren und bösartige Anfragen im Namen eines Benutzers zu fälschen. Diese Schwachstelle kann es einem Angreifer ermöglichen, beliebige Werte ohne Authentifizierung einzuschleusen oder verschiedene böswillige Aktionen im Namen eines authentifizierten Benutzers durchzuführen, wodurch die Sicherheit und Integrität der Anwendung gefährdet werden kann. Die Schwachstelle wird durch eine unsachgemäße Validierung und Durchsetzung von CSRF-Tokens innerhalb der Anwendung verursacht.
—CVE-2023-45128 (übersetzt mit DeepL)
Identifizierte Schwachstellen: CWE-20 Improper Input Validation, CWE-807 Reliance on Untrusted Inputs in a Security Decision, CWE-565 Reliance on Cookies without Validation and Integrity Checking, CWE-352 Cross-Site Request Forgery
Standardtechniken, die CSRF verhindern sollen:
Same-site Cookies (für Authentifizierung)
CSRF-Tokens, wenn diese die folgenden Eigenschaften haben:
Einmalig pro Nutzersession
Geheim
nicht vorhersagbar (z. B. eine sehr große, sicher erzeugte Zufallszahl)
Validierung des Referer-Header
Custom Request Header, da diese nur vom JavaScript Code gesetzt werden können, der den gleichen Ursprung hat (siehe Same Origin Policy (SOP)).
Auch diese Techniken lassen sich ggf. (alle zusammen) aushebeln, wenn die Anwendung weitere Schwachstellen aufweist. So gibt/gab es Anwendungen, die Anfragen, die nur über ein POST request gestellt werden sollten, auch bei einem GET akzeptiert haben.
In allen Browsern wird in der Zwischenzeit für Cookies die Same-site Policy angewandt mit dem Wert Lax. Dieser Wert hat zur Folge, dass Cookies nur dann gesendet werden, wenn der Nutzer explizit auf einen Link klickt oder sich innerhalb der selben Seite befindet.
Es ist möglich potentiell gefährliche Dateien hochzuladen bzw. zu transferieren, die von der Anwendung automatisch im Kontext der Anwendung verarbeitet werden.
Mittel
Bis hin zur Ausführung von beliebigen Befehlen
Vertraulichkeit, Integrität, Verfügbarkeit
HTML:
<form action="upload_picture.php" method="post" enctype="multipart/form-data">
Choose a file to upload:
<input type="file" name="filename"/>
<br/>
<input type="submit" name="submit" value="Submit"/>
</form>PHP:
// Define the target location where the picture being
// uploaded is going to be saved.
$target = "pictures/" . basename($_FILES['uploadedfile']['name']);
// Move the uploaded file to the new location.
move_uploaded_file($_FILES['uploadedfile']['tmp_name'], $target)Beim Speichern von Dateien niemals den ursprünglichen Dateinamen verwenden sondern einen vom Server generierten.
Speicher die Daten nicht im Kontext der Webanwendung sondern außerhalb des Webroots.
Prüfe die Dateiendung. Prüfe den Inhalt der Datei gegen die Erwartung.
Ausführen der Webanwendung mit minimalen Rechten.
Sandbox.
Ein Pufferüberlauf, bei dem der Puffer, der überschrieben wird, auf dem Heap alloziiert wurde, was im Allgemeinen bedeutet, dass der Puffer mit einer Routine wie malloc() allloziiert wurde.
Hoch
C/C++
Bis hin zur Ausführung von beliebigen Befehlen
Vertraulichkeit, Integrität, Verfügbarkeit, Zugriffskontrolle
Basisbeispiel in C:
#define BUFSIZE 256
int main(int argc, char **argv) {
char *buf;
buf = (char *)malloc(sizeof(char)*BUFSIZE);
strcpy(buf, argv[1]);
}Verwendung einer sicheren Programmiersprache
Verwendung von sicheren APIs
Kompilierung unter Verwendung entsprechender Schutzmechanismen (Position-Independent Executables (PIE), Canaries, ...)
Härtung der Umgebung (z. B. ASLR)
Statische Analyse Werkzeuge
Fuzzing
Nicht vertrauenswürdige Daten werden deserialisiert ohne - je nach Bibliothek notwendige vorhergehende - Prüfung, dass die Daten die erwarteten Eigenschaften haben.
Mittel
Java, Ruby, Python, PHP, JavaScript, ...
Insbesondere: Integrität und Verfügbarkeit (DoS); weitere Effekte sind vom Kontext abhängig.
(Un-)Marshalling, (Un-)Pickling
Bei der Serialisierung werden programminterne Objekte so verpackt, dass die Daten extern gespeichert und/oder übertragen werden können. Die Deserialisierung kehrt diesen Prozess um.
Java
File file = new File("object.obj");
try ( FileInputStream fin = new FileInputStream(file);
ObjectInputStream oin = new ObjectInputStream(fin)
) {
javax.swing.JButton button = (javax.swing.JButton) oin.readObject();
...
}In diesem Beispiel wird ein Objekt aus einer Datei gelesen und in eine Variable vom Typ javax.swing.JButton geschrieben. Der Typ des Objekts wird nicht geprüft. Es ist möglich, dass die Datei ein Objekt enthält, welches vom Typ javax.swing.JButton ist, aber nicht die Eigenschaften hat, die ein Button haben sollte. In diesem Fall wird keine Exception geworfen, aber das Objekt kann nicht wie erwartet verwendet werden bzw. es kommt zur Ausführung von beliebigem Code.
Python
class ExampleProtocol(protocol.Protocol):
def dataReceived(self, data):
# ... parse the incoming data and
# after receiving headers, call confirmAuth() to authenticate
def confirmAuth(self, headers):
try:
token = cPickle.loads(base64.b64decode(headers['AuthToken']))
if not check_hmac(token['signature'], token['data'], getSecretKey()):
raise AuthFail
self.secure_data = token['data']
except:
raise AuthFailggf. Einsatz von Signaturen, um sicherzustellen, dass der serialisierte Code nicht manipuliert wurde
Serialisiere nur Daten, die auch wirklich serialisiert werden müssen
Verwendung von sicheren Formaten (z. B. JSON)
statische Analyse
Empfohlene Lektüre: Deserialization Vulnerabilities
Der Webserver erhält eine URL oder eine ähnliche Anfrage und ruft den Inhalt dieser URL ab, stellt aber nicht sicher, dass die Anfrage an das erwartete Ziel gesendet wird.
Webserver
Vetraulichkeit, Integrität
Wenn der DB4Web-Server so konfiguriert ist, dass er ausführliche Debug-Meldungen verwendet, können entfernte Angreifer DB4Web als Proxy verwenden und über eine Anfrage an eine URL, die die Ziel-IP-Adresse und den Port angibt, TCP-Verbindungen zu anderen Systemen (Port-Scan) versuchen, was einen Verbindungsstatus in der resultierenden Fehlermeldung erzeugt.
Der Hersteller betrachtet die Funktionalität nicht als Fehler, sondern als nützliches Feature für Entwickler. Um die Ausnutzung dieses Features zu verhindern, muss die Standardfehlerseite durch eine benutzerdefinierte Fehlerseite ersetzt werden.
JavaScript:
var base = "http://orange.tw/sandbox/";
var path = req.query.path;
if (path.indexOf("..") == -1) { // check for no directory traversal
http.get(base + path, callback);
}Beispiel URL (U+FF2E Full width Latin capital letter N):
http://orange.tw/sandbox/ＮＮ/passwd≙ http://orange.tw/sandbox/\xFF\x2E\xFF\x2E/passwd≙ http://orange.tw/sandbox/\x2E\x2E/passwd≙ http://orange.tw/sandbox/../passwdPHP (> 7.0.13):
$url = 'http://foo@127.0.0.1⬜@google.com:11211/'; // ⬜ is "just" a space
$parsed = parse_url($url);
var_dump($parsed[host]); // string(10) "google.com"
var_dump($parsed[port]); // int(11211)
curl($url);Ergebnis:
curl fragt die URL 127.0.0.1:11211 abfragen.
Bei Blind SSRF-Schwachstellen werden auch Back-End-HTTP-Anfragen an eine bereitgestellte URL gestellt, die Antwort der Back-End-Anfrage jedoch nicht an die Front-End-Antwort der Anwendung zurückgegeben.
Empfohlene Lektüre: Blind Server-Side Request Forgery (SSRF)
keine (Wieder-)Verwendung der Eingabe URL
sichere APIs
statische Analyse (insbesondere Datenflußanalysen)
Behandlung von Zugriffen von lokalen Maschinen sollte mit der gleichen sorgfalt überprüft werden wie Zugriffe von externen Maschinen; andernfalls können kritische SSRF Angriffe durchgeführt werden
Firewall/Network Policy um Zugriff auf interne Systeme zu verhindern
Eine Anwendung initialisiert eine Ressource mit einem bestimmten Typ (z. B. Zeiger (Pointer), Objekt, etc.). Später wird auf die Ressource (Variable) dann mit einem anderen Typ zugegriffen.
insbesondere (aber nicht ausschließlich) C/C++; im Prinzip in jeder Sprache, die automatische Typkonvertierungen durchführt.
Integrität, Verfügbarkeit, Vertraulichkeit
#define NAME_TYPE 1
#define ID_TYPE 2
struct MessageBuffer {
int msgType;
union {
char *name;
int nameID;
}; };
int main (int argc, char **argv) {
struct MessageBuffer buf;
char *defaultMessage = "Hello World";
buf.msgType = NAME_TYPE;
buf.name = defaultMessage; // printf("*buf.name %p", buf.name);
buf.nameID = (int)(defaultMessage + 1); // printf("*buf.name %p", buf.name);
if (buf.msgType == NAME_TYPE) printf("%s\n", buf.name);
else printf("ID %d\n", buf.nameID);
}my $UserPrivilegeArray = ["user", "user", "admin", "user"];
my $userID = get_current_user_ID();
if ($UserPrivilegeArray eq "user") {
print "Regular user!\n";
}
else {
print "Admin!\n";
}
print "\$UserPrivilegeArray = $UserPrivilegeArray\n";Eine Anwendung führt eine kritische Funktion aus, ohne die Identität des Nutzers zu überprüfen. Kritischer Funktionen sind solche, die entweder signifikante Ressourcen verbrauchen oder nur von privilegierten Nutzern ausgeführt werden sollten.
"alle"
manuelle Code Reviews
statische Analyse (Binärcode und/oder Quellcode)
gemeinnützige Stiftung, die sich für die Verbesserung der Sicherheit von Software einsetzt
2001 gegründet
weltweit tätig
Stellt insbesondere Foren, Dokumente und Werkzeuge bereit
Dokumente, die bei der Entwicklung sicherer Anwendungen unterstützen:
Ausgewählte Projekte:
Benenne die Schwachstelle(n) entsprechend der CWEs (ohne ID).
Identifiziere die für die Schwachstelle(n) relevanten Zeilen im Code.
Gebe - falls möglich - einen Angriffsvektor an.
Skizziere mögliche Auswirkung der Schwachstelle(n) (z. B. Verlust der Vertraulichkeit, Integrität oder Verfügbarkeit; Umgehung der Zugriffskontrolle; beliebige Codeausführung, ...)
1#include <stdio.h>2#include <string.h>3void process(char *str) {4char *buffer = malloc(16);5strcpy(buffer, str);6...7// ... definitively executed in the future: free(buffer);8}9int main(int argc, char *argv[]) {10if (argc < 2) { printf("Usage: %s <string>\n", argv[0]); return 1; }11process(argv[1]);12return 0;13}
Sie analysieren eine REST API die folgendes Verhalten aufweist, wenn man einem Blog einen Kommentar hinzufügen möchte:
POST /post/comment HTTP/1.1
Host: important-website.com
Content-Length: 100
postId=3&comment=This+<post>+was+helpful.&name=Karl+GustavFragt man danach den Webservice nach dem Kommentar, dann erhält man folgendes zurück:
<div class="comment">
<div class="name">Karl Gustav</div>
<div class="comment">This <post> was helpful.</div>
</div>Bewerten Sie die Schwachstelle: CWE Name, problematische Codestelle(n), möglicher Angriffsvektor und mögliche Auswirkung.
Java:
1String query =2"SELECT account_balance FROM user_data WHERE user_name = "3+ request.getParameter("customerName");4try {5Statement statement = connection.createStatement( ... );6ResultSet results = statement.executeQuery( query );7}
Bewerten Sie die Schwachstelle: CWE Name, problematische Codestelle(n), möglicher Angriffsvektor und mögliche Auswirkung.
Sie beobachten folgendes Verhalten einer Webseite:
Anfrage
https://my-website.com/search?
term=This%20is%20a%20%3C%22%3Egift%3C%2F%22%3EAntwort
<div class="search-result">
<div class="title">This is a <">gift</"></div>
</div>Bewerten Sie die Schwachstelle: CWE Name, problematische Codestelle(n), möglicher Angriffsvektor und mögliche Auswirkung.