feat: As an user I want to have the latest Testing Guide (4.2) information

security-c4po-angular/src/app/header/header.component.html

@@ -19,6 +19,8 @@
       </nb-action>
       <!--OWASP Action-->
       <nb-action>
+        <!-- Latest: https://owasp.org/www-project-web-security-testing-guide/latest/ -->
+        <!-- Stable: https://owasp.org/www-project-web-security-testing-guide/stable/ -->
         <fa-icon title="OWASP Testing Guide"
                  (click)="onClickGoToLink('https://owasp.org/www-project-web-security-testing-guide/v42/')"
                  [icon]="fa.faFileInvoice" class="action-element-icon fa-2x">

security-c4po-angular/src/app/objective-overview/objective-categories/objective-categories.component.ts

@@ -1,14 +1,11 @@
 import {Component, OnDestroy, OnInit} from '@angular/core';
 import {NbMenuItem, NbMenuService} from '@nebular/theme';
-import {of, Subject} from 'rxjs';
 import {Store} from '@ngxs/store';
 import {ChangeCategory} from '@shared/stores/project-state/project-state.actions';
 import {Category} from '@shared/models/category.model';
 import {untilDestroyed} from 'ngx-take-until-destroy';
 import {TranslateService} from '@ngx-translate/core';
 import {ProjectState} from '@shared/stores/project-state/project-state';
-import {catchError, switchMap, tap} from 'rxjs/operators';
-import {Pentest, transformPentestsToObjectiveEntries} from '@shared/models/pentest.model';
 import {UntilDestroy} from '@ngneat/until-destroy';
 
 @Component({

security-c4po-angular/src/app/objective-overview/objective-table/objective-table.component.ts

@@ -45,7 +45,7 @@ export class ObjectiveTableComponent implements OnInit {
   getters: NbGetters<ObjectiveEntry, ObjectiveEntry> = {
     dataGetter: (node: ObjectiveEntry) => node,
     childrenGetter: (node: ObjectiveEntry) => node.childEntries || undefined,
-    expandedGetter: (node: ObjectiveEntry) => !!node.expanded,
+    expandedGetter: (node: ObjectiveEntry) => !!node.expanded
   };
 
   constructor(

security-c4po-angular/src/assets/i18n/de-DE.json

@@ -197,7 +197,8 @@
     "ERROR_HANDLING": "Fehlerbehandlung",
     "CRYPTOGRAPHY": "Kryptographie",
     "BUSINESS_LOGIC_TESTING": "Business-Logik-Testing",
-    "CLIENT_SIDE_TESTING": "Clientseitiges-Testing"
+    "CLIENT_SIDE_TESTING": "Clientseitiges-Testing",
+    "API_TESTING": "API Testing"
   },
   "finding": {
     "findingId": "Fund Id",
@@ -351,20 +352,21 @@
       "001": "Netzwerk-/Infrastrukturkonfiguration testen",
       "002": "Testen Sie die Konfiguration der Anwendungsplattform",
       "003": "Testen der Behandlung von Dateierweiterungen für vertrauliche Informationen",
-      "004": "Backup und nicht referenzierte Dateien für sensible Informationen",
+      "004": "Prüfen von Backups und Dateien für sensible Informationen",
       "005": "Aufzählen der Infrastruktur- und Anwendungsverwaltungsschnittstellen",
       "006": "HTTP-Methoden testen",
       "007": "Testen Sie HTTP Strict Transport Security",
-      "008": "Testen der domänenübergreifende RIA-Richtlinie"
+      "008": "Testen der domänenübergreifende RIA-Richtlinie",
+      "009": "Dateiberechtigung testen",
+      "010": "Test auf Subdomain-Übernahme",
+      "011": "Cloud-Speicher testen"
     },
     "ident": {
       "001": "Rollendefinitionen testen",
       "002": "Registrierungsprozess testen",
       "003": "Konto-Bereitstellungsprozess testen",
       "004": "Testen auf Kontoaufzählung und erratbares Benutzerkonto",
-      "005": "Test auf schwache oder nicht erzwungene Richtlinie für Benutzernamen",
-      "006": "Testberechtigungen von Gast-/Schulungskonten",
-      "007": "Sperrung/Wiederaufnahme des Kontos testen"
+      "005": "Test auf schwache oder nicht erzwungene Richtlinie für Benutzernamen"
     },
     "authn": {
       "001": "Testen auf Anmeldeinformationen, die über einen verschlüsselten Kanal transportiert werden",
@@ -392,11 +394,12 @@
       "005": "Prüfung auf Cross-Site-Request-Forgery",
       "006": "Testen der Abmeldefunktion",
       "007": "Testen der Sitzungszeitüberschreitung",
-      "008": "Testen auf Session-Rätsel"
+      "008": "Testen auf Session-Puzzle",
+      "009": "Testen auf Session Hijacking"
     },
     "inpval": {
-      "001": "Testen auf reflektiertes Cross-Site-Scripting",
-      "002": "Testen auf konserviertes Cross Site Scripting",
+      "001": "Testen auf Reflected Cross-Site-Scripting",
+      "002": "Testen auf Stored Cross-Site-Scripting",
       "003": "Testen auf HTTP-Verb-Manipulation",
       "004": "Prüfung auf HTTP-Parameterverschmutzung",
       "005": "Testen auf SQL-Injection",
@@ -406,31 +409,34 @@
       "005_4": "Testen von PostgreSQL",
       "005_5": "MS-Access-Tests",
       "005_6": "Testen auf NoSQL-Injection",
+      "005_7": "Testen auf ORM-Injection",
+      "005_8": "Testen für Clientseite",
       "006": "Testen auf LDAP-Injection",
-      "007": "Prüfung auf ORM-Injection",
-      "008": "Testen auf XML-Injection",
-      "009": "Prüfung auf SSI-Injection",
-      "010": "Testen auf XPath-Injection",
-      "011": "IMAP/SMTP-Injection",
-      "012": "Testen auf Code-Injection",
-      "012_1": "Testen der lokalen Dateieinbindung",
-      "012_2": "Testen der Remote-Dateieinbindung",
-      "013": "Testen auf BefehlInjection",
-      "014": "Test auf Pufferüberlauf",
-      "014_1": "Test auf Heap-Überlauf",
-      "014_2": "Test auf Stack-Überlauf",
-      "014_3": "Testen auf Formatzeichenfolge",
-      "015": "Testen auf inkubierte Schwachstellen",
-      "016": "Testen auf HTTP-Splitting/-Schmuggel"
+      "007": "Testen auf XML-Injection",
+      "008": "Prüfung auf SSI-Injection",
+      "009": "Testen auf XPath-Injection",
+      "010": "IMAP/SMTP-Injection",
+      "011": "Testen auf Code-Injection",
+      "011_1": "Testen der lokalen Dateieinbindung",
+      "011_2": "Testen der Remote-Dateieinbindung",
+      "012": "Testen auf Command Injection",
+      "013": "Testen auf Format-String-Injection",
+      "014": "Testen auf bestehende Schwachstellen",
+      "015": "Testen auf HTTP-Splitting/-Smuggling",
+      "016": "Testen auf eingehende HTTP-Anfragen",
+      "017": "Testen auf Host-Header-Injection",
+      "018": "Testen auf serverseitige Template-Injection",
+      "019": "Testen auf serverseitige Request Forgery"
     },
     "err": {
       "001": "Analyse von Fehlercodes",
       "002": "Analyse von Stack-Traces"
     },
     "crypst": {
-      "001": "Testen auf schwache SSL/TSL-Chiffren, unzureichenden Transportschichtschutz",
+      "001": "Testen auf schwache SSL/TLS-Chiffren, unzureichenden Transportschichtschutz",
       "002": "Testen für Padding Oracle",
-      "003": "Prüfung auf sensible Informationen, die über unverschlüsselte Kanäle gesendet werden"
+      "003": "Prüfung auf sensible Informationen, die über unverschlüsselte Kanäle gesendet werden",
+      "004": "Testing auf Schwache Verschlüsselung"
     },
     "buslogic": {
       "001": "Testen Sie die Datenvalidierung der Geschäftslogik",
@@ -455,7 +461,11 @@
       "009": "Test auf Clickjacking",
       "010": "Testen von WebSockets",
       "011": "Testen von Web-Messaging",
-      "012": "Lokalen Speicher testen"
+      "012": "Lokalen Speicher testen",
+      "013": "Testen auf Cross-Site-Script-Integration"
+    },
+    "api": {
+      "001": "Testen von GraphQL"
     }
   },
   "objectives": {
@@ -479,16 +489,17 @@
       "005": "Administratorschnittstellen können in der Anwendung oder auf dem Anwendungsserver vorhanden sein, um bestimmten Benutzern zu ermöglichen, privilegierte Aktivitäten auf der Website durchzuführen. Es sollten Tests durchgeführt werden, um festzustellen, ob und wie diese privilegierte Funktionalität von einem nicht autorisierten oder normalen Benutzer abgerufen werden kann.\n\nEine Anwendung erfordert möglicherweise eine Administratorschnittstelle, um einem privilegierten Benutzer den Zugriff auf Funktionen zu ermöglichen, die Änderungen an der Funktionsweise der Site vornehmen können.\nSolche Änderungen können Folgendes umfassen:\n• Bereitstellung von Benutzerkonten\n• Website-Design und -Layout\n• Datenmanipulation\n• Konfigurationsänderungen\n\nIm Folgenden werden Vektoren beschrieben, die zum Testen auf das Vorhandensein von Verwaltungsschnittstellen verwendet werden können:\n• Verzeichnis- und Dateiaufzählung\n• Brute-Forcing-Tools wie THC-HYDRA\n• Kommentare und Links im Quellcode\n• Überprüfung der Server- und Anwendungsdokumentation\n• Öffentlich zugängliche Informationen (z. B. Standardpasswörter)\n• Alternativer Serverport\n• Manipulation von Parametern",
       "006": "Um diesen Test durchzuführen, muss der Tester irgendwie herausfinden, welche HTTP-Methoden werden vom untersuchten Webserver unterstützt. Die HTTP-Methode OPTIONS bietet dem Tester am meisten direkter und effektiver Weg, dies zu tun. RFC 2616 besagt: „Die OPTIONS-Methode stellt eine Anfrage nach Informationen über die verfügbaren Kommunikationsoptionen in der Anfrage-/Antwortkette dar, die durch den Request-URI identifiziert wird“.\n\n Einige der HTTP-Methoden können potenziell ein Sicherheitsrisiko für eine Webanwendung darstellen, da sie es einem Angreifer ermöglichen, die auf dem Webserver gespeicherten Dateien zu ändern und in einigen Szenarien die Anmeldeinformationen legitimer Benutzer zu stehlen. Genauer gesagt, die Methoden, die deaktiviert werden sollten, sind die folgenden:\n• PUT: Ermöglicht dem Client, Dateien auf den Webserver hochzuladen\n• DELETE: Allwas-Client zum Löschen von Dateien vom Webserver\n• CONNECT: ermöglicht dem Client, den Webserver als Proxy zu verwenden\n• TRACE: Gibt an den Client zurück, was er an den Server gesendet hat",
       "007": "Die HTTP Strict Transport Security (HSTS)-Funktion ermöglicht es einer Webanwendung, den Browser durch die Verwendung eines speziellen Antwortheaders darüber zu informieren, dass er niemals eine Verbindung zu den angegebenen Domänenservern über HTTP herstellen sollte.\n\n Der strenge HTTP-Transportsicherheitsheader verwendet zwei Anweisungen:\n• max-age\n• includeSubDomain\n\nDas Testen auf das Vorhandensein des HSTS-Headers kann durchgeführt werden, indem das Vorhandensein des HSTS-Headers in der Antwort des Servers in einem Interception-Proxy überprüft wird, oder indem curl verwendet wird.",
-      "008": "Rich Internet Applications (RIA) haben die crossdomain.xml-Richtliniendateien von Adobe übernommen, um einen kontrollierten domänenübergreifenden Zugriff auf Daten und Dienstnutzung mit Technologien wie Oracle Java, Silverlight und Adobe Flash zu ermöglichen. Daher kann eine Domäne den Fernzugriff auf ihre Dienste von einer anderen Domäne aus gewähren.\nOft sind die Richtliniendateien, die die Zugriffsbeschränkungen beschreiben, jedoch schlecht konfiguriert. Eine schlechte Konfiguration der Richtliniendateien ermöglicht Cross-Site Request Forgery-Angriffe.\n\n Um die Schwäche der RIA-Richtliniendatei zu testen, sollte der Tester versuchen, die Richtliniendateien crossdomain.xml und clientaccesspolicy.xml aus dem Stammverzeichnis der Anwendung und aus jedem gefundenen Ordner abzurufen."
+      "008": "Rich Internet Applications (RIA) haben die crossdomain.xml-Richtliniendateien von Adobe übernommen, um einen kontrollierten domänenübergreifenden Zugriff auf Daten und Dienstnutzung mit Technologien wie Oracle Java, Silverlight und Adobe Flash zu ermöglichen. Daher kann eine Domäne den Fernzugriff auf ihre Dienste von einer anderen Domäne aus gewähren.\nOft sind die Richtliniendateien, die die Zugriffsbeschränkungen beschreiben, jedoch schlecht konfiguriert. Eine schlechte Konfiguration der Richtliniendateien ermöglicht Cross-Site Request Forgery-Angriffe.\n\n Um die Schwäche der RIA-Richtliniendatei zu testen, sollte der Tester versuchen, die Richtliniendateien crossdomain.xml und clientaccesspolicy.xml aus dem Stammverzeichnis der Anwendung und aus jedem gefundenen Ordner abzurufen.",
+      "009": "Wenn einer Ressource eine Berechtigungseinstellung zugewiesen wird, die einem größeren Spektrum an Akteuren als erforderlich Zugriff gewährt, kann dies zur Offenlegung vertraulicher Informationen oder zur Änderung dieser Ressource durch unbeabsichtigte Parteien führen. Dies ist besonders gefährlich, wenn die Ressource mit der Programmkonfiguration, der Ausführung oder vertraulichen Benutzerdaten zusammenhängt.\n\nEin klares Beispiel ist eine Ausführungsdatei, die von nicht autorisierten Benutzern ausgeführt werden kann. Ein weiteres Beispiel: Kontoinformationen oder ein Token-Wert für den Zugriff auf eine API – was zunehmend in modernen Webdiensten oder Microservices vorkommt – können in einer Konfigurationsdatei gespeichert werden, deren Berechtigungen bei der Installation standardmäßig auf weltweit lesbar eingestellt sind. Solche sensiblen Daten können durch interne böswillige Akteure des Hosts oder durch einen Remote-Angreifer offengelegt werden, der den Dienst durch andere Schwachstellen kompromittiert, sich aber nur normale Benutzerrechte verschafft hat.\n\nZu den Dateien und Verzeichnissen, die einen Dateiberechtigungstest erfordern, gehören unter anderem:\n• Webdateien/Verzeichnis\n• Konfigurationsdateien/Verzeichnis\n• Sensible Dateien (verschlüsselte Daten, Passwort, Schlüssel)/Verzeichnis\n• Protokolldateien (Sicherheitsprotokolle, Betriebsprotokolle, Administratorprotokolle)/Verzeichnis\n• Ausführbare Dateien (Skripte, EXE, JAR, Klasse, PHP, ASP)/Verzeichnis\n• Datenbankdateien/Verzeichnis\n• Temporäre Dateien/Verzeichnis\n• Dateien/Verzeichnis hochladen",
+      "010": "Eine erfolgreiche Ausnutzung dieser Art von Schwachstelle ermöglicht es einem Gegner, die Subdomain des Opfers zu beanspruchen und die Kontrolle über sie zu übernehmen.\nDieser Angriff beruht auf Folgendem:\n\n1. Der externe DNS-Server-Subdomain-Eintrag des Opfers ist so konfiguriert, dass er auf eine nicht vorhandene oder nicht aktive Ressource/einen externen Dienst/Endpunkt verweist. Die Verbreitung von XaaS-Produkten (Anything as a Service) und öffentlichen Cloud-Diensten bietet viele potenzielle Ziele, die es zu berücksichtigen gilt.\n\n2. Der Dienstanbieter, der die Ressource/den externen Dienst/den Endpunkt hostet, führt die Überprüfung des Subdomain-Eigentums nicht ordnungsgemäß durch.\n\nWenn die Subdomain-Übernahme erfolgreich ist, sind vielfältige Angriffe möglich (Bereitstellung bösartiger Inhalte, Phishing, Diebstahl von Benutzersitzungscookies, Anmeldeinformationen usw.). Diese Schwachstelle könnte für eine Vielzahl von DNS-Ressourceneinträgen ausgenutzt werden, darunter: A, CNAME, MX, NS, TXT usw. In Bezug auf die Angriffsschwere hat eine NS-Subdomänenübernahme (wenn auch weniger wahrscheinlich) die größte Auswirkung, da ein erfolgreicher Angriff dies könnte Dies führt zu vollständiger Kontrolle über die gesamte DNS-Zone und die Domäne des Opfers.\n\nTestziele:\n• Zählen Sie alle möglichen Domänen auf (vorherige und aktuelle).\n• Identifizieren Sie vergessene oder falsch konfigurierte Domänen",
+      "011": "Cloud-Speicherdienste ermöglichen Webanwendungen und -diensten das Speichern und Zugreifen auf Objekte im Speicherdienst. Eine unsachgemäße Konfiguration der Zugriffskontrolle kann jedoch dazu führen, dass vertrauliche Informationen offengelegt werden, Daten manipuliert werden oder unbefugter Zugriff erfolgt.\n\nEin bekanntes Beispiel ist die Fehlkonfiguration eines Amazon S3-Buckets, obwohl auch die anderen Cloud-Speicherdienste ähnlichen Risiken ausgesetzt sein können. Standardmäßig sind alle S3-Buckets privat und können nur von Benutzern aufgerufen werden, denen explizit Zugriff gewährt wurde. Benutzer können öffentlichen Zugriff sowohl auf den Bucket selbst als auch auf einzelne in diesem Bucket gespeicherte Objekte gewähren. Dies kann dazu führen, dass ein unbefugter Benutzer neue Dateien hochladen, gespeicherte Dateien ändern oder lesen kann.\n\nIdentifizieren Sie zunächst die URL für den Zugriff auf die Daten im Speicherdienst und ziehen Sie dann die folgenden Tests in Betracht:\n• Die nicht autorisierten Daten lesen\n• Laden Sie eine neue beliebige Datei hoch\n\nTestziele:\n• Stellen Sie sicher, dass die Zugriffskontrollkonfiguration für die Speicherdienste ordnungsgemäß vorhanden ist"
     },
     "ident": {
-      "001": "Das Ziel besteht darin, die in der Anwendung definierten Systemrollen zu validieren, um jedes System und jede Geschäftsrolle ausreichend zu definieren und zu trennen, um den angemessenen Zugriff auf Systemfunktionen und -informationen zu verwalten.\n\n In modernen Unternehmen ist es üblich, Systemrollen zu definieren, um Benutzer und Berechtigungen für Systemressourcen zu verwalten.\nDenken Sie daran, dass die kalte, harte Autorisierung nicht die einzige Möglichkeit ist, den Zugriff auf Systemobjekte zu verwalten. In vertrauenswürdigeren Umgebungen, in denen die Vertraulichkeit nicht kritisch ist, können weichere Kontrollen wie Anwendungsworkflow und Audit-Protokollierung die Anforderungen an die Datenintegrität unterstützen, ohne den Benutzerzugriff auf Funktionen einzuschränken.\n\n Entwickeln Sie entweder mit oder ohne Hilfe der Systementwickler oder Administratoren eine Rollen-Berechtigungs-Matrix. Die Matrix sollte alle Rollen auflisten, die bereitgestellt werden können, und die zulässigen Berechtigungen untersuchen.",
+      "001": "Das Ziel besteht darin, die in der Anwendung definierten Systemrollen zu validieren, jedes System und jede Geschäftsrolle ausreichend zu definieren und zu trennen, um den angemessenen Zugriff auf Systemfunktionen und -informationen zu verwalten.\n\nAnwendungen verfügen über verschiedene Arten von Funktionalitäten und Diensten und diese erfordern Zugriffsberechtigungen, die auf den Bedürfnissen des Benutzers basieren. Dieser Benutzer könnte sein:\n• ein Administrator, der die Anwendungsfunktionen verwaltet.\n• ein Wirtschaftsprüfer, der die Antragstransaktionen überprüft und einen detaillierten Bericht erstellt.\n• ein Support-Techniker, der Kunden beim Debuggen und Beheben von Problemen in ihren Konten unterstützt.\n• ein Kunde, der mit der Anwendung interagiert und von deren Diensten profitiert.\n\nIn vertrauenswürdigeren Umgebungen, in denen die Vertraulichkeit keine entscheidende Rolle spielt, können sanftere Kontrollen wie Anwendungsworkflow und Audit-Protokollierung die Anforderungen an die Datenintegrität unterstützen, ohne den Benutzerzugriff auf Funktionen einzuschränken. Entwickeln Sie mit oder ohne Hilfe der Systementwickler oder Administratoren eine Rollen-Berechtigungs-Matrix. Die Matrix sollte alle Rollen auflisten, die bereitgestellt werden können, und die zulässigen Berechtigungen untersuchen.\n\nTestziele:\n• Identifizieren und dokumentieren Sie die von der Anwendung verwendeten Rollen.\n• Versuchen Sie, eine andere Rolle zu wechseln, zu ändern oder darauf zuzugreifen.\n• Überprüfen Sie die Granularität der Rollen und die Anforderungen hinter den erteilten Berechtigungen",
       "002": "Einige Websites bieten einen Benutzerregistrierungsprozess an, der die Bereitstellung des Systemzugriffs für Benutzer automatisiert (oder halbautomatisiert). Die Identitätsanforderungen für den Zugriff variieren von positiver Identifizierung bis zu überhaupt keiner, abhängig von den Sicherheitsanforderungen des Systems.\n\n Schritt 1:\n Stellen Sie sicher, dass die Identitätsanforderungen für die Benutzerregistrierung mit den Geschäfts- und Sicherheitsanforderungen abgestimmt sind.\n\n Schritt 2:\n Bestätigen Sie den Registrierungsprozess.\n\n Stellen Sie sicher, dass die Identitätsanforderungen für die Benutzerregistrierung mit den Geschäfts- und Sicherheitsanforderungen abgestimmt sind:\n• Kann sich jeder für den Zugang registrieren?\n• Werden Registrierungen von einem Menschen überprüft?\n• Kann sich dieselbe Person oder Identität mehrmals registrieren?\n• Können sich Benutzer für verschiedene Rollen oder Berechtigungen registrieren?\n• Welcher Identitätsnachweis ist für eine Anmeldung erforderlich?\n• Werden registrierte Identitäten verifiziert?\n\n Bestätigen Sie den Registrierungsprozess:\n • Können Identitätsinformationen leicht gefälscht oder gefälscht werden?\n • Kann der Austausch von Identitätsinformationen manipuliert werden?",
-      "003": "Überprüfen Sie, welche Konten andere Konten bereitstellen können und welchen Typs.\n\n Die Bereitstellung von Konten bietet einem Angreifer die Möglichkeit, ein gültiges Konto zu erstellen, ohne den ordnungsgemäßen Identifizierungs- und Autorisierungsprozess anzuwenden.\nBestimmen Sie, welche Rollen Benutzer bereitstellen können und welche Art von Konten sie bereitstellen können.",
-      "004": "Der Zweck dieses Tests besteht darin, zu überprüfen, ob es möglich ist, eine Reihe gültiger Benutzernamen zu sammeln, indem mit dem Authentifizierungsmechanismus der Anwendung interagiert wird.\nDieser Test ist für Brute-Force-Tests nützlich, bei denen der Tester überprüft, ob es möglich ist, bei einem gültigen Benutzernamen das entsprechende Passwort zu finden.\n\nIn einigen Fällen wird eine Nachricht empfangen, die anzeigt, ob die bereitgestellten Anmeldeinformationen falsch sind, weil ein ungültiger Benutzername oder ein ungültiges Passwort verwendet wurde. Manchmal können Tester die vorhandenen Benutzer aufzählen, indem sie einen Benutzernamen und ein leeres Passwort senden.\n Wenn die Anwendung angreifbar ist, erhält der Tester eine Antwortnachricht, die direkt oder indirekt einige nützliche Informationen zum Aufzählen von Benutzern enthält.",
-      "005": "Das Ziel besteht darin, festzustellen, ob eine konsistente Kontonamenstruktur die Anwendung anfällig für eine Kontoaufzählung macht. Stellen Sie fest, ob die Fehlermeldungen der Anwendung eine Kontoaufzählung zulassen.\n\n Benutzerkontonamen sind oft stark strukturiert (z. B. lautet der Kontoname von Joe Bloggs jbloggs und der Kontoname von Fred Nurks fnurks) und gültige Kontonamen können leicht erraten werden.\n • Bestimmen Sie die Struktur von Kontonamen.\n• Bewerten Sie die Antwort der Anwendung auf gültige und ungültige Kontonamen.\n• Verwenden Sie unterschiedliche Antworten auf gültige und ungültige Kontonamen, um gültige Kontonamen aufzuzählen.\n• Verwenden Sie Wörterbücher für Kontonamen, um gültige Kontonamen aufzuzählen.",
-      "006": "Gast- und Schulungskonten sind nützliche Möglichkeiten, potenzielle Benutzer mit den Systemfunktionen vertraut zu machen, bevor sie den für den Zugriff erforderlichen Autorisierungsprozess abschließen. \n\n Bewerten Sie die Konsistenz zwischen Zugriffsrichtlinie und Zugriffsberechtigungen für Gast-/Schulungskonten.",
-      "007": "Überprüfen Sie, ob die Identitätsanforderungen für die Benutzerregistrierung mit den Geschäfts-/Sicherheitsanforderungen übereinstimmen.\n\nBestätigen Sie den Registrierungsprozess."
+      "003": "Überprüfen Sie, welche Konten andere Konten bereitstellen können und welchen Typs.\n\nDie Bereitstellung von Konten bietet einem Angreifer die Möglichkeit, ein gültiges Konto zu erstellen, ohne den ordnungsgemäßen Identifizierungs- und Autorisierungsprozess anzuwenden.\n\nSo testen Sie\n\nBestimmen Sie, welche Rollen Benutzer bereitstellen können und welche Art von Konten sie bereitstellen können:\n• Gibt es eine Überprüfung, Prüfung und Autorisierung von Bereitstellungsanfragen?\n• Gibt es eine Überprüfung, Prüfung und Autorisierung von De-Provisioning-Anfragen?\n• Kann ein Administrator andere Administratoren oder nur Benutzer bereitstellen?\n• Kann ein Administrator oder ein anderer Benutzer Konten mit Berechtigungen versehen, die über ihre eigenen hinausgehen?\n• Kann ein Administrator oder Benutzer die Bereitstellung selbst aufheben?\n• Wie werden die Dateien oder Ressourcen verwaltet, die dem deprovisionierten Benutzer gehören? Werden sie gelöscht? Wird der Zugriff übertragen?",
+      "004": "Der Zweck dieses Tests besteht darin, zu überprüfen, ob es möglich ist, durch Interaktion mit dem Authentifizierungsmechanismus der Anwendung einen Satz gültiger Benutzernamen zu sammeln. Dieser Test ist für Brute-Force-Tests nützlich, bei denen der Tester überprüft, ob es bei einem gültigen Benutzernamen möglich ist, das entsprechende Passwort zu finden.\n\nIn manchen Fällen wird eine Meldung empfangen, die Aufschluss darüber gibt, ob die angegebenen Anmeldeinformationen falsch sind, weil ein ungültiger Benutzername oder ein ungültiges Passwort verwendet wurde. Manchmal können Tester die vorhandenen Benutzer aufzählen, indem sie einen Benutzernamen und ein leeres Passwort senden. Wenn die Anwendung angreifbar ist, erhält der Tester eine Antwortnachricht, die direkt oder indirekt einige Informationen enthält, die für die Enumeration von Benutzern nützlich sind.\n\nTestziele\n• Überprüfen Sie Prozesse, die sich auf die Benutzeridentifizierung beziehen (z. B. Registrierung, Anmeldung usw.).\n• Erfassen Sie Benutzer nach Möglichkeit mithilfe einer Antwortanalyse",
+      "005": "Das Ziel besteht darin, festzustellen, ob eine konsistente Kontonamenstruktur die Anwendung anfällig für die Kontoaufzählung macht. Stellen Sie fest, ob die Fehlermeldungen der Anwendung eine Kontoaufzählung zulassen.\n\nTestziele\n• Stellen Sie fest, ob eine konsistente Kontonamenstruktur die Anwendung anfällig für die Kontoaufzählung macht.\n• Stellen Sie fest, ob die Fehlermeldungen der Anwendung eine Kontoaufzählung zulassen.\n\nBenutzerkontonamen sind häufig stark strukturiert (z. B. lautet der Kontoname von Joe Bloggs jbloggs und der Kontoname von Fred Nurk lautet fnurks), und gültige Kontonamen können leicht erraten werden.\n\nSo testen Sie\n• Bestimmen Sie die Struktur von Kontonamen.\n• Bewerten Sie die Reaktion der Anwendung auf gültige und ungültige Kontonamen.\n• Verwenden Sie unterschiedliche Antworten auf gültige und ungültige Kontonamen, um gültige Kontonamen aufzulisten.\n• Verwenden Sie Kontonamenwörterbücher, um gültige Kontonamen aufzulisten."
     },
     "authn": {
       "001": "Die Analyse konzentriert sich einfach darauf, zu verstehen, ob die Daten unverschlüsselt vom Webbrowser zum Server übertragen werden oder ob die Webanwendung mithilfe eines Protokolls wie HTTPS die geeigneten Sicherheitsmaßnahmen ergreift.\n\n Das Testen auf den Transport von Anmeldeinformationen bedeutet, dass überprüft wird, ob die des Benutzers\nAuthentifizierungsdaten werden über einen verschlüsselten Kanal übertragen, um zu verhindern, dass sie von böswilligen Benutzern abgefangen werden.\n\n Sie können WebScarab oder einen beliebigen Web-Proxy verwenden, um Paket-Header zu erfassen und zu untersuchen.\n Überprüfen Sie, ob HTTPS in jeder sensiblen Anfrage verwendet wird, wie z. B. in Anmeldeseiten, um zu verhindern, dass unbefugte Benutzer die Daten abfangen.",
@@ -516,7 +527,8 @@
       "005": "CSRF ist ein Angriff, der einen Endbenutzer dazu zwingt, unerwünschte Aktionen auf einer Webanwendung auszuführen, in der er/sie gerade authentifiziert ist.\nEin erfolgreicher CSRF-Exploit kann die Daten und den Betrieb von Endbenutzern gefährden, wenn er auf einen normalen Benutzer abzielt. Wenn der Zielbenutzer das Administratorkonto ist, kann ein CSRF-Angriff die gesamte Webanwendung gefährden.\n CSRF stützt sich auf Folgendes:\n\n Punkt 1:\n Verhalten des Webbrowsers in Bezug auf den Umgang mit sitzungsbezogenen Informationen wie Cookies und HTTP-Authentifizierungsinformationen;\n\n Punkt 2:\n Kenntnis des Angreifers von gültigen Webanwendungs-URLs;\n\n Punkt 3:\n Anwendungssitzungsverwaltung, die sich nur auf Informationen stützt, die dem Browser bekannt sind;\n\n Punkt 4:\n Vorhandensein von HTML-Tags, deren Vorhandensein einen sofortigen Zugriff auf eine http[s]-Ressource bewirkt; zum Beispiel das Image-Tag img\n\n Der Tester muss URLs im eingeschränkten (authentifizierten) Bereich kennen. Wenn sie über gültige Anmeldeinformationen verfügen, können sie beide Rollen einnehmen – Angreifer und Opfer. In diesem Fall kennen Tester die zu testenden URLs, indem sie sich einfach umsehen.\n\n  Wenn sich die Sitzungsverwaltung nur auf clientseitige Werte stützt (Informationen, die dem Browser zur Verfügung stehen), ist die Anwendung anfällig.\n Damit eine Anwendung nicht anfällig ist, muss sie sitzungsbezogene Informationen in der URL enthalten, und zwar in einer Form, die für den Benutzer nicht identifizierbar oder unvorhersehbar ist.",
       "006": "Die Sitzungsbeendigung ist ein wichtiger Teil des Sitzungslebenszyklus. Das Verkürzen der Lebensdauer der Sitzungstoken auf ein Minimum verringert die Wahrscheinlichkeit eines erfolgreichen Sitzungs-Hijacking-Angriffs. Dies kann als Kontrolle gegen andere Angriffe wie Cross Site Scripting und Cross Site Request Forgery angesehen werden. Es ist bekannt, dass solche Angriffe darauf beruhen, dass ein Benutzer eine authentifizierte Sitzung hat.\n\n Eine sichere Sitzungsbeendigung erfordert mindestens die folgenden Komponenten:\n • Verfügbarkeit von Steuerelementen der Benutzeroberfläche, mit denen sich der Benutzer manuell abmelden kann\n • Sitzungsbeendigung nach einer bestimmten Zeit ohne Aktivität (Session-Timeout)\n • Ordnungsgemäße Invalidierung des serverseitigen Sitzungsstatus\n\n Der richtige Wert für das Sitzungs-Timeout hängt vom Zweck der Anwendung ab und sollte ein Gleichgewicht zwischen Sicherheit und Benutzerfreundlichkeit darstellen.",
       "007": "In dieser Phase überprüfen Tester, ob die Anwendung einen Benutzer automatisch abmeldet, wenn dieser Benutzer eine bestimmte Zeit lang inaktiv war, um sicherzustellen, dass dieselbe Sitzung nicht „wiederverwendet“ werden kann und dass keine sensiblen Daten im Browser-Cache gespeichert bleiben .\n\n Das Leerlaufzeitlimit schränkt die Wahrscheinlichkeit ein, dass ein Angreifer eine gültige Sitzungs-ID eines anderen Benutzers erraten und verwenden muss, und könnte unter bestimmten Umständen öffentliche Computer vor der Wiederverwendung von Sitzungen schützen. Verwaltung und Ablauf von Sitzungszeitüberschreitungen müssen serverseitig erzwungen werden. Wenn einige Daten unter der Kontrolle des Clients verwendet werden, um das Sitzungs-Timeout zu erzwingen, könnte ein Angreifer diese manipulieren, um die Sitzungsdauer zu verlängern.\n\n Schritt 1:\nTester müssen prüfen, ob ein Timeout vorliegt, indem sie sich beispielsweise anmelden und auf das Auslösen des Timeout-Logouts warten. Wie bei der Abmeldefunktion sollten nach Ablauf des Timeouts alle Sitzungstoken zerstört oder unbrauchbar sein.\n\n Schritt 2:\n Wenn das Timeout konfiguriert ist, müssen Tester verstehen, ob das Timeout vom Client oder vom Server erzwungen wird.\n\n Generell sollte serverseitig alles überprüft werden und es sollte nicht möglich sein, durch Zurücksetzen der Session-Cookies auf vorherige Werte wieder auf die Anwendung zuzugreifen.",
-      "008": "Das Überladen von Sitzungsvariablen (Session Puzzling) ist eine Schwachstelle auf Anwendungsebene, die es einem Angreifer ermöglichen kann, eine Vielzahl von böswilligen Aktionen auszuführen, einschließlich, aber nicht beschränkt auf ...\n.. effiziente Mechanismen zur Durchsetzung der Authentifizierung umgehen und sich als legitime Benutzer ausgeben.\n.. erhöhen der Rechte eines böswilligen Benutzerkontos in einer Umgebung, die ansonsten als narrensicher gelten würde.\n.. Qualifizierungsphasen in mehrphasigen Prozessen überspringen, selbst wenn der Prozess Einschränkungen auf Codeebene enthält.\n.. serverseitige Werte mit indirekten Methoden manipulieren, die nicht vorhergesagt oder erkannt werden können.\n.. herkömmliche Angriffe an Orten ausführen, die zuvor unerreichbar waren oder sogar als sicher galten.\n\n Diese Schwachstelle tritt auf, wenn eine Anwendung dieselbe Sitzungsvariable für mehr als einen Zweck verwendet. Es kann erkannt und ausgenutzt werden, indem alle Sitzungsvariablen, die von der Anwendung verwendet werden, und in welchem \u200B\u200BKontext sie gültig sind, aufgelistet werden. Dies ist insbesondere möglich, indem auf eine Folge von Einstiegspunkten zugegriffen und dann Ausstiegspunkte untersucht werden."
+      "008": "Das Überladen von Sitzungsvariablen (Session Puzzling) ist eine Schwachstelle auf Anwendungsebene, die es einem Angreifer ermöglichen kann, eine Vielzahl von böswilligen Aktionen auszuführen, einschließlich, aber nicht beschränkt auf ...\n.. effiziente Mechanismen zur Durchsetzung der Authentifizierung umgehen und sich als legitime Benutzer ausgeben.\n.. erhöhen der Rechte eines böswilligen Benutzerkontos in einer Umgebung, die ansonsten als narrensicher gelten würde.\n.. Qualifizierungsphasen in mehrphasigen Prozessen überspringen, selbst wenn der Prozess Einschränkungen auf Codeebene enthält.\n.. serverseitige Werte mit indirekten Methoden manipulieren, die nicht vorhergesagt oder erkannt werden können.\n.. herkömmliche Angriffe an Orten ausführen, die zuvor unerreichbar waren oder sogar als sicher galten.\n\n Diese Schwachstelle tritt auf, wenn eine Anwendung dieselbe Sitzungsvariable für mehr als einen Zweck verwendet. Es kann erkannt und ausgenutzt werden, indem alle Sitzungsvariablen, die von der Anwendung verwendet werden, und in welchem \u200B\u200BKontext sie gültig sind, aufgelistet werden. Dies ist insbesondere möglich, indem auf eine Folge von Einstiegspunkten zugegriffen und dann Ausstiegspunkte untersucht werden.",
+      "009": "Ein Angreifer, der Zugriff auf Benutzersitzungscookies erhält, kann sich durch die Bereitstellung solcher Cookies als diese ausgeben. Dieser Angriff wird als Session-Hijacking bezeichnet. Betrachtet man Netzwerkangreifer, d. h. Angreifer, die das vom Opfer verwendete Netzwerk kontrollieren, können Sitzungscookies dem Angreifer über HTTP unangemessen zugänglich gemacht werden. Um dies zu verhindern, sollten Sitzungscookies mit dem Attribut „Sicher“ gekennzeichnet werden, sodass sie nur über HTTPS kommuniziert werden.\n\nTestziele\n• Identifizieren Sie anfällige Sitzungscookies.\n• Kapern Sie anfällige Cookies und bewerten Sie das Risikoniveau.\n\nSo testen Sie\nHier sind die Schritte zur Durchführung dieses Tests:\n1. Melden Sie sich als Opfer auf der Website an und gelangen Sie zu einer beliebigen Seite, die eine sichere Funktion bietet, die eine Authentifizierung erfordert.\n2. Löschen Sie alle Cookies aus der Keksdose, die eine der folgenden Bedingungen erfüllen.\n• Falls keine HSTS-Übernahme erfolgt: Das Secure-Attribut ist gesetzt.\n• bei teilweiser HSTS-Einführung: Das Secure-Attribut ist gesetzt oder das Domain-Attribut ist nicht gesetzt.\n3. Speichern Sie einen Schnappschuss der Keksdose.\n4. Lösen Sie die in Schritt 1 identifizierte sichere Funktion aus.\n5. Beobachten Sie, ob der Vorgang in Schritt 4 erfolgreich durchgeführt wurde. Wenn ja, war der Angriff erfolgreich.\n6. Leeren Sie die Keksdose, melden Sie sich als Angreifer an und gelangen Sie zur Seite bei Schritt 1.\n7. Schreiben Sie die in Schritt 3 gespeicherten Kekse nacheinander in die Keksdose.\n8. Lösen Sie die in Schritt 1 identifizierte Sicherheitsfunktion erneut aus.\n9. Leeren Sie die Keksdose und melden Sie sich erneut als Opfer an.\n10. Beobachten Sie, ob der Vorgang in Schritt 8 im Konto des Opfers erfolgreich durchgeführt wurde. Wenn ja, war der Angriff erfolgreich; andernfalls ist die Site vor Session-Hijacking geschützt.\n\nBeachten Sie, dass das Secure-Attribut auch verwendet werden sollte, wenn die Webanwendung vollständig über HTTPS bereitgestellt wird, da sonst der folgende Cookie-Diebstahl-Angriff möglich ist. Gehen Sie davon aus, dass example.com vollständig über HTTPS bereitgestellt wird, seine Sitzungscookies jedoch nicht als „sicher“ markiert.\n\nFolgende Angriffsschritte sind möglich:\n1. Das Opfer sendet eine Anfrage an http://another-site.com.\n2. Der Angreifer manipuliert die entsprechende Antwort, sodass eine Anfrage an http://example.com ausgelöst wird.\n3. Der Browser versucht nun, auf http://example.com zuzugreifen.\n4. Obwohl die Anfrage fehlschlägt, werden die Sitzungscookies im Klartext über HTTP weitergegeben.\n\nWenn das Domänenattribut festgelegt ist, können Sitzungscookies über Subdomänen hinweg gemeinsam genutzt werden. Die Verwendung von HTTP mit Subdomains sollte vermieden werden, um die Offenlegung unverschlüsselter, über HTTP gesendeter Cookies zu verhindern. Um diese Sicherheitslücke zu veranschaulichen, gehen wir davon aus, dass die Website example.com HSTS ohne die Option includeSubDomains aktiviert. Die Website gibt Sitzungscookies aus, wobei das Domain-Attribut auf example.com festgelegt ist.\n\nFolgender Angriff ist möglich:\n1. Das Opfer sendet eine Anfrage an http://another-site.com.\n2. Der Angreifer manipuliert die entsprechende Antwort, sodass eine Anfrage an http://fake.example.com ausgelöst wird.\n3. Der Browser versucht nun, auf http://fake.example.com zuzugreifen, was die HSTS-Konfiguration zulässt.\n4. Da die Anfrage an eine Unterdomäne von example.com mit festgelegtem Domänenattribut gesendet wird, enthält sie die Sitzungscookies, die im Klartext über HTTP durchgesickert sind."
     },
     "inpval": {
       "001": "Reflected Cross-Site Scripting (XSS) tritt auf, wenn ein Angreifer ausführbaren Browsercode in eine einzelne HTTP-Antwort einfügt.\nDer eingeschleuste Angriff wird nicht in der Anwendung selbst gespeichert; Es ist nicht dauerhaft und wirkt sich nur auf Benutzer aus, die einen in böser Absicht erstellten Link oder eine Webseite eines Drittanbieters öffnen.\nDie Angriffszeichenfolge ist Teil der präparierten URI- oder HTTP-Parameter, wird von der Anwendung nicht ordnungsgemäß verarbeitet und an das Opfer zurückgegeben. Eine der Hauptschwierigkeiten beim Verhindern von XSS-Schwachstellen ist die richtige Zeichencodierung.\n In einigen Fällen filtert der Webserver oder die Webanwendung möglicherweise einige Zeichencodierungen nicht, sodass die Webanwendung beispielsweise „<script>“ herausfiltert, aber nicht %3cscript%3e filtert, das einfach eine andere Codierung enthält von Tags. Ein Test umfasst mindestens drei Phasen:\n\n Phase 1:\nEingabevektoren erkennen. Für jede Webseite muss der Tester alle benutzerdefinierten Variablen der Webanwendung und deren Eingabe bestimmen. Dazu gehören versteckte oder nicht offensichtliche Eingaben wie HTTP-Parameter, POST-Daten, versteckte Formularfeldwerte und vordefinierte Radio- oder Auswahlwerte. In der Regel werden HTML-Editoren im Browser oder Web-Proxys verwendet, um diese versteckten Variablen anzuzeigen.\n\n Phase 2:\n Analysieren Sie jeden Eingabevektor, um potenzielle Schwachstellen zu erkennen. dUm eine XSS-Schwachstelle zu erkennen, verwendet der Tester normalerweise speziell gestaltete Eingabedaten mit jedem Eingabevektor. Solche Eingabedaten sind in der Regel harmlos, lösen jedoch Reaktionen des Webbrowsers aus, der die Schwachstelle manifestiert. Testdaten können mithilfe eines Webanwendungs-Fuzzers, einer automatisierten vordefinierten Liste bekannter Angriffszeichenfolgen oder manuell generiert werden.\n\n Phase 3:\n Für jede Testeingabe, die in der vorherigen Phase versucht wurde, analysiert der Tester das Ergebnis und bestimmt, ob es sich um eine Schwachstelle handelt, die realistische Auswirkungen auf die Sicherheit der Webanwendung hat. Dazu muss der HTML-Code der resultierenden Webseite untersucht und nach der Testeingabe gesucht werden. Einmal gefunden, identifiziert der Tester alle Sonderzeichen, die nicht richtig codiert, ersetzt oder herausgefiltert wurden.",
@@ -530,22 +542,24 @@
       "005_4": "Wenn eine SQL-Injection gefunden wurde, müssen Sie die Backend-Datenbank-Engine sorgfältig mit einem Fingerabdruck versehen. Sie können feststellen, dass die Back-End-Datenbank-Engine PostgreSQL ist, indem Sie den :: cast-Operator verwenden.\n Außerdem kann die Funktion version() verwendet werden, um das PostgreSQL-Banner abzurufen. Dies zeigt auch den Typ und die Version des zugrunde liegenden Betriebssystems an.\n\n SQL-Injection-Techniken für PostgreSQL haben die folgenden Merkmale:\n • PHP Connector ermöglicht die Ausführung mehrerer Anweisungen mit ; als Anweisungstrenner\n • SQL-Anweisungen können durch Anhängen des Kommentarzeichens abgeschnitten werden: --\n • LIMIT und OFFSET können in einer SELECT-Anweisung verwendet werden, um einen Teil der von der Abfrage generierten Ergebnismenge abzurufen\n\n Bei blinden SQL-Injection-Angriffen sollten Sie die folgenden integrierten Funktionen berücksichtigen:\n • Zeichenfolgenlänge - LENGTH(str)\n • Einen Teilstring aus einem gegebenen String extrahieren – SUBSTR(str,index,offset)\n • Zeichenfolgendarstellung ohne einfache Anführungszeichen – CHR(101)||CHR(108)||CHR(111)",
       "005_5": "Microsoft Access kann bestimmte Features für SQL-Injection-Techniken nutzen.\n Leider unterstützt MS Access keine typischen Operatoren, die traditionell bei SQL-Injection-Tests verwendet werden, einschließlich:\n• Keine Kommentarzeichen\n• Keine gestapelten Abfragen\n• Kein LIMIT-Operator\n• Keine SLEEP- oder BENCHMARK-ähnlichen Operatoren\n• und viele andere\n\n Es gibt jedoch auch viele andere Funktionen, die beim Testen der SQL-Injection verwendet werden können, einschließlich, aber nicht beschränkt auf:\n • ASC: Ruft den ASCII-Wert eines als Eingabe übergebenen Zeichens ab\n • CHR: Ruft das Zeichen des als Eingabe übergebenen ASCII-Werts ab\n • LEN: Gibt die Länge des als Parameter übergebenen Strings zurück\n • IIF: Ist das IF-Konstrukt, z. IIF(1=1, 'a', 'b') gibt 'a' zurück\n • MID: Mit dieser Funktion können Sie Teilstrings extrahieren\n • TOP: Mit dieser Funktion können Sie die max. Anzahl der Ergebnisse\n • LAST: Diese Funktion wird verwendet, um nur die letzte Zeile eines Satzes auszuwählen\n\n In MS Access sind standardmäßig verschiedene Systemtabellen vorhanden, die möglicherweise zum Abrufen von Tabellennamen und Spalten verwendet werden können.\n Leider sind diese Tabellen in der Standardkonfiguration neuerer Versionen von MS Access-Datenbanken nicht zugänglich. Trotzdem ist es immer einen Versuch wert:\n • MSysObjects\n • MSysACEs\n • MSysAccessXML",
       "005_6": "NoSQL-Datenbanken bieten lockerere Konsistenzbeschränkungen als herkömmliche SQL-Datenbanken. Da weniger relationale Einschränkungen und Konsistenzprüfungen erforderlich sind, bieten NoSQL-Datenbanken häufig Leistungs- und Skalierungsvorteile.\n Da diese NoSQL-Injection-Angriffe jedoch in einer prozeduralen Sprache und nicht in der deklarativen SQL-Sprache ausgeführt werden können, sind die potenziellen Auswirkungen größer als bei herkömmlicher SQL-Injection.\n\n NoSQL-Datenbankaufrufe werden in der Programmiersprache der Anwendung, einem benutzerdefinierten API-Aufruf oder gemäß einer gängigen Konvention (z. B. XML, JSON, LINQ usw.) formatiert.\n\n Typischerweise werden NoSQL-Injection-Angriffe ausgeführt, bei denen die Angriffszeichenfolge analysiert, ausgewertet oder zu einem NoSQL-API-Aufruf verkettet wird.\n Zusätzliche Timing-Angriffe können für das Fehlen von Parallelitätsprüfungen innerhalb einer NoSQL-Datenbank relevant sein. Diese werden nicht von Injektionstests abgedeckt.\n\n Mittlerweile sind über 150 NoSQL-Datenbanken verfügbar, aber zum Zeitpunkt der Erstellung dieses Artikels ist MongoDB die am weitesten verbreitete NoSQL-Datenbank.\n\n Die MongoDB-API erwartet BSON-Aufrufe (Binary JSON) und enthält ein sicheres Tool zum Zusammenstellen von BSON-Abfragen. Laut MongoDB-Dokumentation sind jedoch deserialisierte JSON- und JavaScript-Ausdrücke in mehreren alternativen Abfrageparametern zulässig.\n Wenn ein Angreifer beispielsweise in der Lage wäre, die an den $where-Operator übergebenen Daten zu manipulieren, könnte dieser Angreifer willkürliches JavaScript einbinden, das als Teil der MongoDB-Abfrage ausgewertet wird.",
+      "005_7": "ORM Injection ist ein Angriff mit SQL Injection gegen ein ORM-generiertes Datenzugriffsobjektmodell. Aus Sicht eines Testers ist dieser Angriff praktisch identisch mit einem SQL-Injection-Angriff.\nDie Injection-Schwachstelle existiert jedoch in Code, der vom ORM-Tool generiert wird.\n\n Ein ORM ist ein objektrelationales Mapping-Tool.\nEs wird verwendet, um die objektorientierte Entwicklung innerhalb der Datenzugriffsschicht von Softwareanwendungen, einschließlich Webanwendungen, zu beschleunigen. Zu den Vorteilen der Verwendung eines ORM-Tools gehören die schnelle Generierung einer Objektschicht zur Kommunikation mit einer relationalen Datenbank, standardisierte Codevorlagen für diese Objekte und normalerweise eine Reihe sicherer Funktionen zum Schutz vor SQL-Injection-Angriffen. Von ORM generierte Objekte können SQL oder in einigen Fällen eine Variante von SQL verwenden, um CRUD-Operationen auf einer Datenbank auszuführen.\n\n Zu den ORM-Tools gehören Hibernate für Java, NHibernate für .NET, ActiveRecord für Ruby on Rails, EZPDO für PHP und viele andere.\n\n ORM-Injection-Schwachstellen sind identisch mit SQL-Injection-Tests. In den meisten Fällen ist die Schwachstelle in der ORM-Schicht das Ergebnis von benutzerdefiniertem Code, der Eingabeparameter nicht ordnungsgemäß validiert.\n Die meisten ORM-Tools bieten sichere Funktionen, um Benutzereingaben zu umgehen.\nWenn diese Funktionen jedoch nicht verwendet werden und der Entwickler benutzerdefinierte Funktionen verwendet, die Benutzereingaben akzeptieren, kann es möglich sein, einen SQL-Injection-Angriff auszuführen.\n\n Zu den Mustern, nach denen im Code gesucht werden muss, gehören:\n • Mit SQL-Strings verkettete Eingabeparameter",
+      "005_8": "Clientseitige SQL-Injection tritt auf, wenn eine Anwendung die Web-SQL-Datenbanktechnologie implementiert und die Eingabe nicht ordnungsgemäß validiert oder ihre Abfragevariablen nicht parametrisiert. Diese Datenbank wird mithilfe von JavaScript (JS)-API-Aufrufen manipuliert, z. B. openDatabase() , wodurch eine vorhandene Datenbank erstellt oder geöffnet wird.\n\nDas folgende Testszenario überprüft, ob eine ordnungsgemäße Eingabevalidierung durchgeführt wird. Wenn die Implementierung angreifbar ist, kann der Angreifer in der Datenbank gespeicherte Informationen lesen, ändern oder löschen.\n\nWenn die getestete Anwendung die Web SQL DB implementiert, werden im clientseitigen Kern die folgenden drei Aufrufe verwendet:\n• openDatabase()\n• transaction()\n• executeSQL()",
       "006": "Das Lightweight Directory Access Protocol (LDAP) wird verwendet, um Informationen über Benutzer, Hosts und viele andere Objekte zu speichern. Die LDAP-Injection ist ein serverseitiger Angriff, bei dem sensible Informationen über Benutzer und Hosts, die in einer LDAP-Struktur dargestellt sind, offengelegt, geändert oder eingefügt werden können. Dies erfolgt durch Manipulieren von Eingabeparametern, die anschließend an interne Such-, Hinzufügungs- und Änderungsfunktionen übergeben werden.\n Eine Webanwendung könnte LDAP verwenden, damit sich Benutzer innerhalb einer Unternehmensstruktur authentifizieren oder die Informationen anderer Benutzer durchsuchen können.\n\n Das Ziel von LDAP-Injection-Angriffen besteht darin, Metazeichen von LDAP-Suchfiltern in eine Abfrage einzufügen, die von der Anwendung ausgeführt wird.\n [Rfc2254] definiert eine Grammatik zum Aufbau eines Suchfilters auf LDAPv3 und erweitert [Rfc1960] (LDAPv2).\nEin LDAP-Suchfilter wird in polnischer Schreibweise erstellt, die auch als [Präfixschreibweise] bekannt ist.\n\n Eine erfolgreiche Ausnutzung einer LDAP-Injection-Schwachstelle könnte dem Tester Folgendes ermöglichen:\n • Greifen Sie auf nicht autorisierte Inhalte zu\n • Anwendungseinschränkungen umgehen\n • Sammeln Sie nicht autorisierte Informationen\n • Hinzufügen oder Ändern von Objekten innerhalb der LDAP-Baumstruktur",
-      "007": "ORM Injection ist ein Angriff mit SQL Injection gegen ein ORM-generiertes Datenzugriffsobjektmodell. Aus Sicht eines Testers ist dieser Angriff praktisch identisch mit einem SQL-Injection-Angriff.\nDie Injection-Schwachstelle existiert jedoch in Code, der vom ORM-Tool generiert wird.\n\n Ein ORM ist ein objektrelationales Mapping-Tool.\nEs wird verwendet, um die objektorientierte Entwicklung innerhalb der Datenzugriffsschicht von Softwareanwendungen, einschließlich Webanwendungen, zu beschleunigen. Zu den Vorteilen der Verwendung eines ORM-Tools gehören die schnelle Generierung einer Objektschicht zur Kommunikation mit einer relationalen Datenbank, standardisierte Codevorlagen für diese Objekte und normalerweise eine Reihe sicherer Funktionen zum Schutz vor SQL-Injection-Angriffen. Von ORM generierte Objekte können SQL oder in einigen Fällen eine Variante von SQL verwenden, um CRUD-Operationen auf einer Datenbank auszuführen.\n\n Zu den ORM-Tools gehören Hibernate für Java, NHibernate für .NET, ActiveRecord für Ruby on Rails, EZPDO für PHP und viele andere.\n\n ORM-Injection-Schwachstellen sind identisch mit SQL-Injection-Tests. In den meisten Fällen ist die Schwachstelle in der ORM-Schicht das Ergebnis von benutzerdefiniertem Code, der Eingabeparameter nicht ordnungsgemäß validiert.\n Die meisten ORM-Tools bieten sichere Funktionen, um Benutzereingaben zu umgehen.\nWenn diese Funktionen jedoch nicht verwendet werden und der Entwickler benutzerdefinierte Funktionen verwendet, die Benutzereingaben akzeptieren, kann es möglich sein, einen SQL-Injection-Angriff auszuführen.\n\n Zu den Mustern, nach denen im Code gesucht werden muss, gehören:\n • Mit SQL-Strings verkettete Eingabeparameter",
-      "008": "Beim XML-Injektionstest versucht ein Tester, ein XML-Dokument in die Anwendung einzufügen. Wenn der XML-Parser die Daten nicht kontextbezogen validieren kann, ergibt der Test ein positives Ergebnis.\n\n Schritt 1:\n Um eine Anwendung auf das Vorhandensein einer XML-Injection-Schwachstelle zu testen, besteht der Versuch, XML-Metazeichen einzufügen.\n\n XML-Metazeichen sind:\n • Einfaches Anführungszeichen: ‘ \n • Doppeltes Anführungszeichen: “ \n • Spitze Klammern: > und <\n • Kommentar-Tag: <!--/-->\n • Et-Zeichen: &\n • Trennzeichen für CDATA-Abschnitte: <![CDATA[ / ]]>\n\n Ein weiterer Test bezieht sich auf das CDATA-Tag. Angenommen, das XML-Dokument wird verarbeitet, um eine HTML-Seite zu generieren. In diesem Fall können die CDATA-Abschnittsbegrenzer einfach eliminiert werden, ohne ihren Inhalt weiter zu prüfen. Dann ist es möglich, HTML-Tags einzufügen, die in die generierte Seite eingefügt werden, wobei vorhandene Bereinigungsroutinen vollständig umgangen werden.\n\n Schritt 2:\n Sobald der erste Schritt abgeschlossen ist, verfügt der Tester über einige Informationen über die Struktur des XML-Dokuments. Anschließend kann versucht werden, XML-Daten und -Tags einzufügen (Tag Injection).",
-      "009": "Webserver geben Entwicklern normalerweise die Möglichkeit, kleine Teile dynamischen Codes in statische HTML-Seiten einzufügen. Diese Funktion wird durch die Server-Side Includes (SSI) verkörpert.\nBeim SSI-Injection-Test testen wir, ob es möglich ist, Daten in die Anwendung einzuspeisen, die von SSI-Mechanismen interpretiert werden. Eine erfolgreiche Ausnutzung dieser Schwachstelle ermöglicht es einem Angreifer, Code in HTML-Seiten einzuschleusen oder sogar eine Remotecodeausführung durchzuführen.\n\n In Bezug auf die SSI-Injektion könnte der Angreifer Eingaben bereitstellen, die, wenn sie von der Anwendung (oder vielleicht direkt vom Server) in eine dynamisch generierte Seite eingefügt würden, als eine oder mehrere SSI-Anweisungen geparst würden.\n\n Schritt 1:\n Was wir herausfinden müssen, ist, ob der Webserver tatsächlich SSI-Anweisungen unterstützt. Um das herauszufinden, müssen wir nur herausfinden, welche Art von Webserver auf unserem Ziel läuft.\n Hinweis: Wenn die Site .shtml-Dateien enthält, werden wahrscheinlich SSI unterstützt, da diese Erweiterung verwendet wird, um Seiten zu identifizieren, die diese Anweisungen enthalten.\n\n Schritt 2:\n Der nächste Schritt besteht darin, festzustellen, ob ein SSI-Injection-Angriff tatsächlich möglich ist und wenn ja, über welche Eingabepunkte können wir unseren Schadcode einschleusen.\n Wir müssen jede Seite finden, auf der der Benutzer Eingaben vornehmen darf, und überprüfen, ob die Anwendung die übermittelten Eingaben korrekt validiert.\n Wenn die Bereinigung unzureichend ist, müssen wir testen, ob wir Daten bereitstellen können, die unverändert angezeigt werden.\n Neben den üblichen vom Benutzer bereitgestellten Daten sind HTTP-Anforderungsheader und Cookie-Inhalte Eingabevektoren, die immer berücksichtigt werden sollten.\n\n Schritt 3:\n Sobald wir eine Liste möglicher Injektionspunkte haben, können wir überprüfen, wie die Eingabe behandelt wird, welche Art von Filterung durchgeführt wird, welche Zeichen die Anwendung nicht durchlässt und wie viele Codierungsarten berücksichtigt werden.",
-      "010": "Webanwendungen verwenden Datenbanken stark zum Speichern und Zugreifen auf die Daten, die sie für ihren Betrieb benötigen.\n So wie auf relationale Datenbanken über die SQL-Sprache zugegriffen wird, verwenden XML-Datenbanken XPath als Standardabfragesprache.\n\n XPath ist eine Sprache, die hauptsächlich entworfen und entwickelt wurde, um Teile eines XML-Dokuments zu adressieren. Beim XPath-Injection-Test testen wir, ob es möglich ist, XPath-Syntax in eine von der Anwendung interpretierte Anfrage einzufügen, sodass ein Angreifer benutzergesteuerte XPath-Abfragen ausführen kann.\n XPath ist sogar noch leistungsfähiger als Standard-SQL, da seine gesamte Leistungsfähigkeit bereits in seinen Spezifikationen vorhanden ist, während eine große Anzahl der Techniken, die bei einem SQL-Injection-Angriff verwendet werden können, von den Eigenschaften des SQL-Dialekts abhängen, der von der Zieldatenbank verwendet wird.\n\n Das XPath-Angriffsmuster ist der üblichen SQL-Injektion sehr ähnlich, und wie bei einem gewöhnlichen SQL-Injection-Angriff besteht der erste Schritt bei der XPath-Injektion darin, ein einfaches Anführungszeichen (') in das zu testende Feld einzufügen, wodurch ein Syntaxfehler in das Feld eingeführt wird abzufragen und zu prüfen, ob die Anwendung eine Fehlermeldung zurückgibt.",
-      "011": "Diese Bedrohung betrifft alle Anwendungen, die mit Mailservern (IMAP/SMTP) kommunizieren, im Allgemeinen Webmail-Anwendungen. Das Ziel dieses Tests besteht darin, die Fähigkeit zu überprüfen, beliebige IMAP/SMTP-Befehle in die Mailserver einzufügen, da Eingabedaten nicht ordnungsgemäß bereinigt werden.\n\n Eine IMAP/SMTP-Injection ermöglicht den Zugriff auf einen Mailserver, der sonst nicht direkt aus dem Internet erreichbar wäre. In einigen Fällen verfügen diese internen Systeme nicht über das gleiche Maß an Infrastruktursicherheit und Härtung, das auf die Front-End-Webserver angewendet wird. Daher sind Mailserver-Ergebnisse möglicherweise anfälliger für Angriffe durch Endbenutzer.\n\n Die Standardangriffsmuster sind:\n • Identifizieren anfälliger Parameter\n • Verstehen des Datenflusses und der Bereitstellungsstruktur des Clients\n • IMAP/SMTP-Befehlsinjektion\n\n Diese letzte Phase hat zwei mögliche Ergebnisse:\n\n Ergebnis 1:\n Die Injektion ist in einem nicht authentifizierten Zustand möglich: Die betroffene Funktionalität erfordert keine Authentifizierung des Benutzers.\n Die verfügbaren injizierten (IMAP)-Befehle sind beschränkt auf: \nCAPABILITY, NOOP, AUTHENTICATE, LOGIN und LOGOUT.\n\n Ergebnis 2:\n Die Injektion ist nur in einem authentifizierten Zustand möglich: Die erfolgreiche Ausnutzung erfordert, dass der Benutzer vollständig authentifiziert ist, bevor der Test fortgesetzt werden kann.\n\n In jedem Fall sieht der typische Aufbau einer IMAP/SMTP-Injection wie folgt aus:\n • Header: Ende des erwarteten Befehls;\n • Body: Injektion des neuen Befehls;\n • Footer: Anfang des erwarteten Befehls.",
-      "012": "Beim Code-Injection-Test übermittelt ein Tester Eingaben, die vom Webserver als dynamischer Code oder als eingebundene Datei verarbeitet werden. Diese Tests können auf verschiedene serverseitige Scripting-Engines abzielen, z. B. ASP oder PHP. Zum Schutz vor diesen Angriffen müssen eine ordnungsgemäße Eingabevalidierung und sichere Codierungspraktiken angewendet werden.\n\n Testen auf PHP-Injection-Schwachstellen\n Unter Verwendung der Abfragezeichenfolge kann der Tester Code einfügen, der als Teil der enthaltenen Datei verarbeitet werden soll. Die schädliche URL wird als Parameter für die PHP-Seite akzeptiert, die später den Wert in einer eingebundenen Datei verwendet.\n\n Testen auf ASP-Code-Injection-Schwachstellen\n Untersuchen Sie den ASP-Code auf Benutzereingaben, die in Ausführungsfunktionen verwendet werden.\nKann der Benutzer Befehle in das Dateneingabefeld eingeben?",
-      "012_1": "Die Schwachstelle „File Inclusion“ ermöglicht es einem Angreifer, eine Datei einzufügen, wobei er normalerweise einen „dynamischen Dateieinschluss“-Mechanismus ausnutzt, der in der Zielanwendung implementiert ist. Die Sicherheitsanfälligkeit tritt aufgrund der Verwendung von Benutzereingaben ohne ordnungsgemäße Überprüfung auf.\n\n Dies kann dazu führen, dass der Inhalt der Datei ausgegeben wird, aber je nach Schweregrad kann es auch zu Folgendem führen:\n • Codeausführung auf dem Webserver\n • Code-Ausführung auf der Client-Seite wie JavaScript, was zu anderen Angriffen wie Cross-Site-Scripting (XSS) führen kann.\n • Dienstverweigerung (DoS)\n • Offenlegung sensibler Informationen\n\n Local File Inclusion (auch bekannt als LFI) ist der Prozess des Einschließens von Dateien, die bereits lokal auf dem Server vorhanden sind, durch Ausnutzung von angreifbaren Einschlussverfahren.\n Da LFI auftritt, wenn Pfade, die an „include“-Anweisungen übergeben werden, nicht ordnungsgemäß bereinigt werden, sollten wir in einem Blackbox-Testansatz nach Skripten suchen, die Dateinamen als Parameter verwenden.",
-      "012_2": "Die Schwachstelle „File Inclusion“ ermöglicht es einem Angreifer, eine Datei einzufügen, wobei er normalerweise einen „dynamischen Dateieinschluss“-Mechanismus ausnutzt, der in der Zielanwendung implementiert ist. Die Sicherheitsanfälligkeit tritt aufgrund der Verwendung von Benutzereingaben ohne ordnungsgemäße Überprüfung auf.\n\n Dies kann dazu führen, dass der Inhalt der Datei ausgegeben wird, aber je nach Schweregrad kann es auch zu Folgendem führen:\n • Codeausführung auf dem Webserver\n • Code-Ausführung auf der Client-Seite wie JavaScript, was zu anderen Angriffen wie Cross-Site-Scripting (XSS) führen kann.\n • Dienstverweigerung (DoS)\n • Offenlegung sensibler Informationen\n\n Remote File Inclusion (auch bekannt als RFI) ist der Prozess des Einschließens von Remote-Dateien durch die Ausnutzung von anfälligen Einschlussverfahren.\n\n Da RFI auftritt, wenn Pfade, die an „include“-Anweisungen übergeben werden, nicht ordnungsgemäß bereinigt werden, sollten wir in einem Blackbox-Testansatz nach Skripten suchen, die Dateinamen als Parameter verwenden.",
-      "013": "OS Command Injection ist eine Technik, die über eine Webschnittstelle verwendet wird, um OS-Befehle auf einem Webserver auszuführen. Der Benutzer liefert Betriebssystembefehle über eine Webschnittstelle, um OS-Befehle auszuführen. Jede nicht ordnungsgemäß bereinigte Weboberfläche ist von diesem Exploit betroffen.\n\n Beim Anzeigen einer Datei in einer Webanwendung wird der Dateiname häufig in der URL angezeigt. Perl ermöglicht die Weiterleitung von Daten aus einem Prozess in eine offene Anweisung. Der Benutzer kann einfach das Pipe-Symbol „|“ anhängen. am Ende des Dateinamens.\n Das Anhängen eines Semikolons an das Ende einer URL für eine .PHP-Seite, gefolgt von einem Betriebssystembefehl, führt den Befehl aus. %3B ist URL-kodiert und wird in Semikolon dekodiert.",
-      "014": "Verschiedene Arten von Pufferüberlauf-Schwachstellen haben unterschiedliche Testmethoden. Hier sind die Testmethoden für die häufigsten Arten von Pufferüberlauf-Schwachstellen.\n\n • Testen auf Heap-Overflow-Schwachstelle\n • Testen auf Stack-Overflow-Schwachstellen\n • Testen auf Sicherheitslücken bei Format-Strings",
-      "014_1": "Bei diesem Test überprüft der Penetrationstester, ob er einen Heap-Überlauf erzeugen kann, der ein Speichersegment ausnutzt.\n\n Heap ist ein Speichersegment, das zum Speichern dynamisch zugewiesener Daten und globaler Variablen verwendet wird. Jeder Speicherblock im Heap besteht aus Begrenzungs-Tags, die Speicherverwaltungsinformationen enthalten.\n\n Wenn ein Heap-basierter Puffer überläuft, werden die Steuerinformationen in diesen Tags überschrieben. Wenn die Heap-Verwaltungsroutine den Puffer freigibt, findet ein Überschreiben der Speicheradresse statt, was zu einer Zugriffsverletzung führt. Wenn der Überlauf auf kontrollierte Weise ausgeführt wird, würde die Schwachstelle es einem Angreifer ermöglichen, einen gewünschten Speicherplatz mit einem benutzergesteuerten Wert zu überschreiben.\n\n Es gibt zahlreiche Varianten der Schwachstelle Heap Overflow (Heap Corruption), die vom Überschreiben von Funktionszeigern bis zum Ausnutzen von Speicherverwaltungsstrukturen für die Ausführung willkürlichen Codes alles ermöglichen kann.\n\n Der Schlüssel liegt darin, als Eingabezeichenfolgen bereitzustellen, die länger als erwartet sind. Obwohl der Testprozess derselbe bleibt, unterscheiden sich die in einem Debugger sichtbaren Ergebnisse erheblich. Während im Fall eines Stapelüberlaufs ein Befehlszeiger oder ein SEH-Überschreiben offensichtlich wäre, gilt dies nicht für einen Stapelüberlaufzustand.\n Beim Debuggen eines Windows-Programms kann ein Heap-Überlauf in verschiedenen Formen auftreten, wobei die häufigste Form ein Zeigeraustausch ist, der stattfindet, nachdem die Heap-Verwaltungsroutine in Aktion tritt.\n\n Statische Code-Analyse-Tools können auch dabei helfen, Heap-bezogene Schwachstellen wie „Double Free“ usw. zu lokalisieren. Eine Vielzahl von Tools wie RATS, Flawfinder und ITS4 stehen zur Analyse von Sprachen im C-Stil zur Verfügung.",
-      "014_2": "Stack-überläufe treten auf, wenn Daten mit variabler Größe in Puffer mit fester Länge kopiert werden, die sich auf dem Programmstapel befinden, ohne dass eine Begrenzungsprüfung erfolgt.\n Schwachstellen dieser Klasse werden im Allgemeinen als hochgradig eingestuft, da ihre Ausnutzung meist die Ausführung willkürlichen Codes oder Denial of Service ermöglichen würde. In interpretierten Plattformen selten anzutreffen, ist Code, der in C und ähnlichen Sprachen geschrieben wurde, oft mit Instanzen dieser Schwachstelle gespickt.\n\n  Tatsächlich ist fast jede Plattform anfällig für Stack-überläufe, mit den folgenden bemerkenswerten Ausnahmen:\n • J2EE – solange keine nativen Methoden oder Systemaufrufe aufgerufen werden\n • .NET – solange /unsafe oder nicht verwalteter Code nicht aufgerufen wird\n • PHP – solange externe Programme und angreifbare Erweiterungen nicht aufgerufen werden\n\n Stack-überlauf-Schwachstellen ermöglichen es einem Angreifer häufig, direkt die Kontrolle über den Befehlszeiger zu übernehmen und somit die Ausführung des Programms zu ändern und beliebigen Code auszuführen.\n\n Der Schlüssel zum Testen einer Anwendung auf Stack-überlauf-Schwachstellen liegt darin, im Vergleich zu dem, was erwartet wird, übermäßig große Eingabedaten bereitzustellen.\n Es reicht jedoch nicht aus, die Anwendung beliebig großen Datenmengen auszusetzen. Es wird notwendig, den Ausführungsablauf und die Antworten der Anwendung zu überprüfen, um festzustellen, ob tatsächlich ein Überlauf ausgelöst wurde oder nicht.\n Daher wären die erforderlichen Schritte zum Auffinden und Validieren von Stack-überläufen, einen Debugger an die Zielanwendung oder den Zielprozess anzuhängen, fehlerhafte Eingaben für die Anwendung zu generieren, die Anwendung fehlerhaften Eingaben auszusetzen und Antworten in einem Debugger zu untersuchen.",
-      "014_3": "Verschiedene Sprachen im C-Stil bieten die Formatierung der Ausgabe mittels Funktionen wie printf( ), fprintf( ) usw. Die Formatierung wird durch einen Parameter für diese Funktionen geregelt, der als Formattypbezeichner bezeichnet wird, typischerweise %s, %c usw.\n Die Schwachstelle entsteht, wenn Formatierungsfunktionen mit unzureichender Parametervalidierung und benutzergesteuerten Daten aufgerufen werden.\n\n Ein einfaches Beispiel wäre printf(argv[1]). In diesem Fall wurde der Typbezeichner nicht explizit deklariert, sodass ein Benutzer Zeichen wie %s, %n, %x mithilfe des Befehlszeilenarguments argv[1] an die Anwendung übergeben kann.\n\n Diese Situation wird tendenziell prekär, da ein Benutzer, der Formatbezeichner bereitstellen kann, die folgenden böswilligen Aktionen ausführen kann:\n • Prozessstapel aufzählen\n • Steuerungsausführungsablauf\n • Denial of Service\n\n Der Schlüssel zum Testen von Sicherheitslücken in Formatzeichenfolgen ist die Bereitstellung von Formattypbezeichnern in der Anwendungseingabe.\n\n Sicherheitslücken im Format-String treten hauptsächlich in Webservern, Anwendungsservern oder Webanwendungen auf, die C/C++-basierten Code oder in C geschriebene CGI-Skripte verwenden. In den meisten dieser Fälle wurde eine Fehlerberichterstattungs- oder Protokollierungsfunktion wie syslog( ) unsicher aufgerufen.\n Beim Testen von CGI-Skripten auf Sicherheitslücken im Formatstring können die Eingabeparameter so manipuliert werden, dass sie die Typbezeichner %x oder %n enthalten.\n\n Bei der Durchführung von Code-Reviews können fast alle Sicherheitslücken in Format-Strings mithilfe statischer Code-Analyse-Tools erkannt werden.\n Die Funktionen, die hauptsächlich für Sicherheitslücken in Formatzeichenfolgen verantwortlich sind, behandeln Formatbezeichner als optional. Daher kann bei der manuellen Überprüfung von Code der Schwerpunkt auf Funktionen gelegt werden wie:\n • printf\n • fprintf\n • sprintf\n • snprintf\n • vfprintf\n • vprintf",
-      "015": "Inkubationstests werden auch oft als dauerhafte Angriffe bezeichnet und sind eine komplexe Testmethode, die mehr als eine Schwachstelle zur Datenvalidierung benötigt, um zu funktionieren.\n Inkubierte Schwachstellen werden normalerweise verwendet, um „Watering Hole“-Angriffe gegen Benutzer legitimer Webanwendungen durchzuführen.\n\n Inkubierte Schwachstellen haben die folgenden Merkmale:\n\n Zuerst:\n Der Angriffsvektor muss in erster Linie persistiert werden, er muss in der Persistenzschicht gespeichert werden, und dies würde nur auftreten, wenn eine schwache Datenvalidierung vorhanden wäre oder die Daten über einen anderen Kanal wie eine Verwaltungskonsole oder direkt in das System gelangen über einen Backend-Batch-Prozess.\n\n Zweitens:\n  Sobald der Angriffsvektor „zurückgerufen“ wurde, musste der Vektor erfolgreich ausgeführt werden. Beispielsweise würde ein inkubierter XSS-Angriff eine schwache Ausgabevalidierung erfordern, damit das Skript in seiner ausführbaren Form an den Client geliefert wird.\n\n Die Ausnutzung einiger Schwachstellen oder sogar Funktionsmerkmale einer Webanwendung ermöglicht es einem Angreifer, Daten einzuschleusen, die später abgerufen werden.\n In einem Penetrationstest können inkubierte Angriffe verwendet werden, um die Kritikalität bestimmter Fehler zu bewerten, die normalerweise verwendet werden, um eine große Anzahl von Opfern gleichzeitig anzugreifen.\n\n Diese Art von asynchronen Angriffen deckt ein großes Spektrum an Angriffsvektoren ab, darunter die folgenden:\n • Datei-Upload-Komponenten in einer Webanwendung\n • Cross-Site-Scripting-Probleme in öffentlichen Forenbeiträgen\n • SQL/XPATH-Injection, die es dem Angreifer ermöglicht, Inhalte in eine Datenbank hochzuladen\n • Falsch konfigurierte Server, die die Installation von Paketen oder Komponenten ermöglichen\n\n Schritt 1:\n Überprüfen Sie den Inhaltstyp, der zum Hochladen in die Webanwendung zugelassen ist, und die resultierende URL für die hochgeladene Datei.\n\n Schritt 2:\n Laden Sie eine Datei hoch, die eine Komponente auf der lokalen Benutzerarbeitsstation ausnutzt, wenn sie vom Benutzer angezeigt oder heruntergeladen wird.\n\n Schritt 3:\n Senden Sie Ihrem Opfer eine E-Mail oder eine andere Art von Benachrichtigung, um ihn/sie dazu zu bringen, die Seite zu durchsuchen.\n\n Das erwartete Ergebnis ist, dass der Exploit ausgelöst wird, wenn der Benutzer die resultierende Seite durchsucht oder die Datei von der vertrauenswürdigen Site herunterlädt und ausführt.",
-      "016": "Es gibt zwei verschiedene Angriffe, die auf bestimmte HTTP-Header abzielen:\n• HTTP-Splitting\n• HTTP-Smuggling\n\n Der erste Angriff nutzt einen Mangel an Eingabebereinigung aus, wodurch ein Eindringling CR- und LF-Zeichen in die Header der Anwendungsantwort einfügen und diese Antwort in zwei verschiedene HTTP-Nachrichten „aufteilen“ kann.\n Das Ziel des Angriffs kann von Cache-Poisoning bis hin zu Cross-Site-Scripting reichen.\n\n Beim zweiten Angriff nutzt der Angreifer die Tatsache aus, dass einige speziell gestaltete HTTP-Nachrichten je nach Agent, der sie empfängt, auf unterschiedliche Weise analysiert und interpretiert werden können.\nHTTP-Schmuggel erfordert ein gewisses Maß an Wissen über die verschiedenen Agenten, die die HTTP-Nachrichten verarbeiten (Webserver, Proxy, Firewall).\n\n HTTP-Splitting\n Einige Webanwendungen verwenden einen Teil der Benutzereingaben, um die Werte einiger Header ihrer Antworten zu generieren. Das einfachste Beispiel sind Umleitungen, bei denen die Ziel-URL von einem vom Benutzer übermittelten Wert abhängt.\n Die Header, die die wahrscheinlichsten Kandidaten für diesen Angriff sind, sind:\n• Location\n• Set-Cookie\n\n  HTTP-Smuggling\n Dies nutzt die verschiedenen Möglichkeiten, wie eine speziell gestaltete HTTP-Nachricht von verschiedenen Agenten (Browsern, Webcaches, Anwendungsfirewalls) analysiert und interpretiert werden kann."
+      "007": "Beim XML-Injektionstest versucht ein Tester, ein XML-Dokument in die Anwendung einzufügen. Wenn der XML-Parser die Daten nicht kontextbezogen validieren kann, ergibt der Test ein positives Ergebnis.\n\n Schritt 1:\n Um eine Anwendung auf das Vorhandensein einer XML-Injection-Schwachstelle zu testen, besteht der Versuch, XML-Metazeichen einzufügen.\n\n XML-Metazeichen sind:\n • Einfaches Anführungszeichen: ‘ \n • Doppeltes Anführungszeichen: “ \n • Spitze Klammern: > und <\n • Kommentar-Tag: <!--/-->\n • Et-Zeichen: &\n • Trennzeichen für CDATA-Abschnitte: <![CDATA[ / ]]>\n\n Ein weiterer Test bezieht sich auf das CDATA-Tag. Angenommen, das XML-Dokument wird verarbeitet, um eine HTML-Seite zu generieren. In diesem Fall können die CDATA-Abschnittsbegrenzer einfach eliminiert werden, ohne ihren Inhalt weiter zu prüfen. Dann ist es möglich, HTML-Tags einzufügen, die in die generierte Seite eingefügt werden, wobei vorhandene Bereinigungsroutinen vollständig umgangen werden.\n\n Schritt 2:\n Sobald der erste Schritt abgeschlossen ist, verfügt der Tester über einige Informationen über die Struktur des XML-Dokuments. Anschließend kann versucht werden, XML-Daten und -Tags einzufügen (Tag Injection).",
+      "008": "Webserver geben Entwicklern normalerweise die Möglichkeit, kleine Teile dynamischen Codes in statische HTML-Seiten einzufügen. Diese Funktion wird durch die Server-Side Includes (SSI) verkörpert.\nBeim SSI-Injection-Test testen wir, ob es möglich ist, Daten in die Anwendung einzuspeisen, die von SSI-Mechanismen interpretiert werden. Eine erfolgreiche Ausnutzung dieser Schwachstelle ermöglicht es einem Angreifer, Code in HTML-Seiten einzuschleusen oder sogar eine Remotecodeausführung durchzuführen.\n\n In Bezug auf die SSI-Injektion könnte der Angreifer Eingaben bereitstellen, die, wenn sie von der Anwendung (oder vielleicht direkt vom Server) in eine dynamisch generierte Seite eingefügt würden, als eine oder mehrere SSI-Anweisungen geparst würden.\n\n Schritt 1:\n Was wir herausfinden müssen, ist, ob der Webserver tatsächlich SSI-Anweisungen unterstützt. Um das herauszufinden, müssen wir nur herausfinden, welche Art von Webserver auf unserem Ziel läuft.\n Hinweis: Wenn die Site .shtml-Dateien enthält, werden wahrscheinlich SSI unterstützt, da diese Erweiterung verwendet wird, um Seiten zu identifizieren, die diese Anweisungen enthalten.\n\n Schritt 2:\n Der nächste Schritt besteht darin, festzustellen, ob ein SSI-Injection-Angriff tatsächlich möglich ist und wenn ja, über welche Eingabepunkte können wir unseren Schadcode einschleusen.\n Wir müssen jede Seite finden, auf der der Benutzer Eingaben vornehmen darf, und überprüfen, ob die Anwendung die übermittelten Eingaben korrekt validiert.\n Wenn die Bereinigung unzureichend ist, müssen wir testen, ob wir Daten bereitstellen können, die unverändert angezeigt werden.\n Neben den üblichen vom Benutzer bereitgestellten Daten sind HTTP-Anforderungsheader und Cookie-Inhalte Eingabevektoren, die immer berücksichtigt werden sollten.\n\n Schritt 3:\n Sobald wir eine Liste möglicher Injektionspunkte haben, können wir überprüfen, wie die Eingabe behandelt wird, welche Art von Filterung durchgeführt wird, welche Zeichen die Anwendung nicht durchlässt und wie viele Codierungsarten berücksichtigt werden.",
+      "009": "Webanwendungen verwenden Datenbanken stark zum Speichern und Zugreifen auf die Daten, die sie für ihren Betrieb benötigen.\n So wie auf relationale Datenbanken über die SQL-Sprache zugegriffen wird, verwenden XML-Datenbanken XPath als Standardabfragesprache.\n\n XPath ist eine Sprache, die hauptsächlich entworfen und entwickelt wurde, um Teile eines XML-Dokuments zu adressieren. Beim XPath-Injection-Test testen wir, ob es möglich ist, XPath-Syntax in eine von der Anwendung interpretierte Anfrage einzufügen, sodass ein Angreifer benutzergesteuerte XPath-Abfragen ausführen kann.\n XPath ist sogar noch leistungsfähiger als Standard-SQL, da seine gesamte Leistungsfähigkeit bereits in seinen Spezifikationen vorhanden ist, während eine große Anzahl der Techniken, die bei einem SQL-Injection-Angriff verwendet werden können, von den Eigenschaften des SQL-Dialekts abhängen, der von der Zieldatenbank verwendet wird.\n\n Das XPath-Angriffsmuster ist der üblichen SQL-Injektion sehr ähnlich, und wie bei einem gewöhnlichen SQL-Injection-Angriff besteht der erste Schritt bei der XPath-Injektion darin, ein einfaches Anführungszeichen (') in das zu testende Feld einzufügen, wodurch ein Syntaxfehler in das Feld eingeführt wird abzufragen und zu prüfen, ob die Anwendung eine Fehlermeldung zurückgibt.",
+      "010": "Diese Bedrohung betrifft alle Anwendungen, die mit Mailservern (IMAP/SMTP) kommunizieren, im Allgemeinen Webmail-Anwendungen. Das Ziel dieses Tests besteht darin, die Fähigkeit zu überprüfen, beliebige IMAP/SMTP-Befehle in die Mailserver einzufügen, da Eingabedaten nicht ordnungsgemäß bereinigt werden.\n\n Eine IMAP/SMTP-Injection ermöglicht den Zugriff auf einen Mailserver, der sonst nicht direkt aus dem Internet erreichbar wäre. In einigen Fällen verfügen diese internen Systeme nicht über das gleiche Maß an Infrastruktursicherheit und Härtung, das auf die Front-End-Webserver angewendet wird. Daher sind Mailserver-Ergebnisse möglicherweise anfälliger für Angriffe durch Endbenutzer.\n\n Die Standardangriffsmuster sind:\n • Identifizieren anfälliger Parameter\n • Verstehen des Datenflusses und der Bereitstellungsstruktur des Clients\n • IMAP/SMTP-Befehlsinjektion\n\n Diese letzte Phase hat zwei mögliche Ergebnisse:\n\n Ergebnis 1:\n Die Injektion ist in einem nicht authentifizierten Zustand möglich: Die betroffene Funktionalität erfordert keine Authentifizierung des Benutzers.\n Die verfügbaren injizierten (IMAP)-Befehle sind beschränkt auf: \nCAPABILITY, NOOP, AUTHENTICATE, LOGIN und LOGOUT.\n\n Ergebnis 2:\n Die Injektion ist nur in einem authentifizierten Zustand möglich: Die erfolgreiche Ausnutzung erfordert, dass der Benutzer vollständig authentifiziert ist, bevor der Test fortgesetzt werden kann.\n\n In jedem Fall sieht der typische Aufbau einer IMAP/SMTP-Injection wie folgt aus:\n • Header: Ende des erwarteten Befehls;\n • Body: Injektion des neuen Befehls;\n • Footer: Anfang des erwarteten Befehls.",
+      "011": "Beim Code-Injection-Test übermittelt ein Tester Eingaben, die vom Webserver als dynamischer Code oder als eingebundene Datei verarbeitet werden. Diese Tests können auf verschiedene serverseitige Scripting-Engines abzielen, z. B. ASP oder PHP. Zum Schutz vor diesen Angriffen müssen eine ordnungsgemäße Eingabevalidierung und sichere Codierungspraktiken angewendet werden.\n\n Testen auf PHP-Injection-Schwachstellen\n Unter Verwendung der Abfragezeichenfolge kann der Tester Code einfügen, der als Teil der enthaltenen Datei verarbeitet werden soll. Die schädliche URL wird als Parameter für die PHP-Seite akzeptiert, die später den Wert in einer eingebundenen Datei verwendet.\n\n Testen auf ASP-Code-Injection-Schwachstellen\n Untersuchen Sie den ASP-Code auf Benutzereingaben, die in Ausführungsfunktionen verwendet werden.\nKann der Benutzer Befehle in das Dateneingabefeld eingeben?",
+      "011_1": "Die Schwachstelle „File Inclusion“ ermöglicht es einem Angreifer, eine Datei einzufügen, wobei er normalerweise einen „dynamischen Dateieinschluss“-Mechanismus ausnutzt, der in der Zielanwendung implementiert ist. Die Sicherheitsanfälligkeit tritt aufgrund der Verwendung von Benutzereingaben ohne ordnungsgemäße Überprüfung auf.\n\n Dies kann dazu führen, dass der Inhalt der Datei ausgegeben wird, aber je nach Schweregrad kann es auch zu Folgendem führen:\n • Codeausführung auf dem Webserver\n • Code-Ausführung auf der Client-Seite wie JavaScript, was zu anderen Angriffen wie Cross-Site-Scripting (XSS) führen kann.\n • Dienstverweigerung (DoS)\n • Offenlegung sensibler Informationen\n\n Local File Inclusion (auch bekannt als LFI) ist der Prozess des Einschließens von Dateien, die bereits lokal auf dem Server vorhanden sind, durch Ausnutzung von angreifbaren Einschlussverfahren.\n Da LFI auftritt, wenn Pfade, die an „include“-Anweisungen übergeben werden, nicht ordnungsgemäß bereinigt werden, sollten wir in einem Blackbox-Testansatz nach Skripten suchen, die Dateinamen als Parameter verwenden.",
+      "011_2": "Die Schwachstelle „File Inclusion“ ermöglicht es einem Angreifer, eine Datei einzufügen, wobei er normalerweise einen „dynamischen Dateieinschluss“-Mechanismus ausnutzt, der in der Zielanwendung implementiert ist. Die Sicherheitsanfälligkeit tritt aufgrund der Verwendung von Benutzereingaben ohne ordnungsgemäße Überprüfung auf.\n\n Dies kann dazu führen, dass der Inhalt der Datei ausgegeben wird, aber je nach Schweregrad kann es auch zu Folgendem führen:\n • Codeausführung auf dem Webserver\n • Code-Ausführung auf der Client-Seite wie JavaScript, was zu anderen Angriffen wie Cross-Site-Scripting (XSS) führen kann.\n • Dienstverweigerung (DoS)\n • Offenlegung sensibler Informationen\n\n Remote File Inclusion (auch bekannt als RFI) ist der Prozess des Einschließens von Remote-Dateien durch die Ausnutzung von anfälligen Einschlussverfahren.\n\n Da RFI auftritt, wenn Pfade, die an „include“-Anweisungen übergeben werden, nicht ordnungsgemäß bereinigt werden, sollten wir in einem Blackbox-Testansatz nach Skripten suchen, die Dateinamen als Parameter verwenden.",
+      "012": "OS Command Injection ist eine Technik, die über eine Webschnittstelle verwendet wird, um OS-Befehle auf einem Webserver auszuführen. Der Benutzer liefert Betriebssystembefehle über eine Webschnittstelle, um OS-Befehle auszuführen. Jede nicht ordnungsgemäß bereinigte Weboberfläche ist von diesem Exploit betroffen.\n\n Beim Anzeigen einer Datei in einer Webanwendung wird der Dateiname häufig in der URL angezeigt. Perl ermöglicht die Weiterleitung von Daten aus einem Prozess in eine offene Anweisung. Der Benutzer kann einfach das Pipe-Symbol „|“ anhängen. am Ende des Dateinamens.\n Das Anhängen eines Semikolons an das Ende einer URL für eine .PHP-Seite, gefolgt von einem Betriebssystembefehl, führt den Befehl aus. %3B ist URL-kodiert und wird in Semikolon dekodiert.",
+      "013": "Eine Format String ist eine mit Null endende Zeichenfolge, die auch Konvertierungsspezifizierer enthält, die zur Laufzeit interpretiert oder konvertiert werden. Wenn serverseitiger Code die Eingabe eines Benutzers mit einer Formatzeichenfolge verkettet, kann ein Angreifer zusätzliche Konvertierungsspezifizierer anhängen, um einen Laufzeitfehler, die Offenlegung von Informationen oder einen Pufferüberlauf zu verursachen.\n\nBewerten Sie, ob das Einfügen von Konvertierungsspezifizierern für Formatzeichenfolgen in benutzergesteuerte Felder zu unerwünschtem Verhalten der Anwendung führt.\n\nDer schlimmste Fall von Sicherheitslücken bei Formatzeichenfolgen tritt in Sprachen auf, die keine Argumente prüfen und außerdem einen %n-Spezifizierer enthalten, der in den Speicher schreibt. Wenn diese Funktionen von einem Angreifer ausgenutzt werden, der eine Formatzeichenfolge ändert, kann dies zur Offenlegung von Informationen und zur Codeausführung führen:\n• C und C++ printf und ähnliche Methoden fprintf, sprintf, snprintf\n• Perl printf und sprintf\n\nDiese Formatzeichenfolgenfunktionen können nicht in den Speicher schreiben, Angreifer können jedoch dennoch die Offenlegung von Informationen verursachen, indem sie Formatzeichenfolgen so ändern, dass sie Werte ausgeben, die die Entwickler nicht senden wollten.\nDie folgenden Format String Funktionen können Laufzeitfehler verursachen, wenn der Angreifer Konvertierungsspezifizierer hinzufügt:\n• Java String.format und PrintStream.format\n• PHP printf\n\nZu den Tests gehören die Analyse des Codes und das Einfügen von Konvertierungsspezifizierern als Benutzereingabe in die zu testende Anwendung.",
+      "014": "Inkubationstests werden auch oft als dauerhafte Angriffe bezeichnet und sind eine komplexe Testmethode, die mehr als eine Schwachstelle zur Datenvalidierung benötigt, um zu funktionieren.\n Inkubierte Schwachstellen werden normalerweise verwendet, um „Watering Hole“-Angriffe gegen Benutzer legitimer Webanwendungen durchzuführen.\n\n Inkubierte Schwachstellen haben die folgenden Merkmale:\n\n Zuerst:\n Der Angriffsvektor muss in erster Linie persistiert werden, er muss in der Persistenzschicht gespeichert werden, und dies würde nur auftreten, wenn eine schwache Datenvalidierung vorhanden wäre oder die Daten über einen anderen Kanal wie eine Verwaltungskonsole oder direkt in das System gelangen über einen Backend-Batch-Prozess.\n\n Zweitens:\n  Sobald der Angriffsvektor „zurückgerufen“ wurde, musste der Vektor erfolgreich ausgeführt werden. Beispielsweise würde ein inkubierter XSS-Angriff eine schwache Ausgabevalidierung erfordern, damit das Skript in seiner ausführbaren Form an den Client geliefert wird.\n\n Die Ausnutzung einiger Schwachstellen oder sogar Funktionsmerkmale einer Webanwendung ermöglicht es einem Angreifer, Daten einzuschleusen, die später abgerufen werden.\n In einem Penetrationstest können inkubierte Angriffe verwendet werden, um die Kritikalität bestimmter Fehler zu bewerten, die normalerweise verwendet werden, um eine große Anzahl von Opfern gleichzeitig anzugreifen.\n\n Diese Art von asynchronen Angriffen deckt ein großes Spektrum an Angriffsvektoren ab, darunter die folgenden:\n • Datei-Upload-Komponenten in einer Webanwendung\n • Cross-Site-Scripting-Probleme in öffentlichen Forenbeiträgen\n • SQL/XPATH-Injection, die es dem Angreifer ermöglicht, Inhalte in eine Datenbank hochzuladen\n • Falsch konfigurierte Server, die die Installation von Paketen oder Komponenten ermöglichen\n\n Schritt 1:\n Überprüfen Sie den Inhaltstyp, der zum Hochladen in die Webanwendung zugelassen ist, und die resultierende URL für die hochgeladene Datei.\n\n Schritt 2:\n Laden Sie eine Datei hoch, die eine Komponente auf der lokalen Benutzerarbeitsstation ausnutzt, wenn sie vom Benutzer angezeigt oder heruntergeladen wird.\n\n Schritt 3:\n Senden Sie Ihrem Opfer eine E-Mail oder eine andere Art von Benachrichtigung, um ihn/sie dazu zu bringen, die Seite zu durchsuchen.\n\n Das erwartete Ergebnis ist, dass der Exploit ausgelöst wird, wenn der Benutzer die resultierende Seite durchsucht oder die Datei von der vertrauenswürdigen Site herunterlädt und ausführt.",
+      "015": "Es gibt zwei verschiedene Angriffe, die auf bestimmte HTTP-Header abzielen:\n• HTTP-Splitting\n• HTTP-Smuggling\n\n Der erste Angriff nutzt einen Mangel an Eingabebereinigung aus, wodurch ein Eindringling CR- und LF-Zeichen in die Header der Anwendungsantwort einfügen und diese Antwort in zwei verschiedene HTTP-Nachrichten „aufteilen“ kann.\n Das Ziel des Angriffs kann von Cache-Poisoning bis hin zu Cross-Site-Scripting reichen.\n\n Beim zweiten Angriff nutzt der Angreifer die Tatsache aus, dass einige speziell gestaltete HTTP-Nachrichten je nach Agent, der sie empfängt, auf unterschiedliche Weise analysiert und interpretiert werden können.\nHTTP-Schmuggel erfordert ein gewisses Maß an Wissen über die verschiedenen Agenten, die die HTTP-Nachrichten verarbeiten (Webserver, Proxy, Firewall).\n\n HTTP-Splitting\n Einige Webanwendungen verwenden einen Teil der Benutzereingaben, um die Werte einiger Header ihrer Antworten zu generieren. Das einfachste Beispiel sind Umleitungen, bei denen die Ziel-URL von einem vom Benutzer übermittelten Wert abhängt.\n Die Header, die die wahrscheinlichsten Kandidaten für diesen Angriff sind, sind:\n• Location\n• Set-Cookie\n\n  HTTP-Smuggling\n Dies nutzt die verschiedenen Möglichkeiten, wie eine speziell gestaltete HTTP-Nachricht von verschiedenen Agenten (Browsern, Webcaches, Anwendungsfirewalls) analysiert und interpretiert werden kann.",
+      "016": "In diesem Abschnitt wird beschrieben, wie Sie alle eingehenden/ausgehenden HTTP-Anfragen sowohl auf der Client- als auch auf der Serverseite überwachen. Der Zweck dieser Tests besteht darin, zu überprüfen, ob im Hintergrund unnötige oder verdächtige HTTP-Anfragen gesendet werden.\n\nDie meisten Web-Sicherheitstesttools (z. B. AppScan, BurpSuite, ZAP) fungieren als HTTP-Proxy. Dies erfordert Änderungen des Proxys in der clientseitigen Anwendung oder im Browser. Die unten aufgeführten Testtechniken konzentrieren sich in erster Linie darauf, wie wir HTTP-Anfragen ohne Änderungen auf der Clientseite überwachen können, was eher dem Produktionsszenario entspricht.\n\nTestziele\n• Überwachen Sie alle eingehenden und ausgehenden HTTP-Anfragen an den Webserver, um verdächtige Anfragen zu untersuchen.\n• Überwachen Sie den HTTP-Verkehr ohne Änderungen am Browser-Proxy des Endbenutzers oder an der clientseitigen Anwendung.\n\nSo testen Sie\nEs gibt eine Situation, in der wir alle eingehenden HTTP-Anfragen auf dem Webserver überwachen möchten, aber die Konfiguration auf der Browser- oder Anwendungsclientseite nicht ändern können. In diesem Szenario können wir auf der Webserverseite einen Reverse-Proxy einrichten, um alle eingehenden/ausgehenden Anfragen auf dem Webserver zu überwachen:\n• Für die Windows-Plattform wird Fiddler empfohlen.\n• Für die Linux-Plattform kann Charles Web Debugging Proxy verwendet werden.\n\nDie Testschritte:\n1. Installieren Sie Fiddler oder Charles auf dem Webserver\n2. Konfigurieren Sie den Fiddler oder Charles als Reverse Proxy\n3. Erfassen Sie den HTTP-Verkehr\n4. Untersuchen Sie den HTTP-Verkehr\n5. Ändern Sie HTTP-Anforderungen und spielen Sie die geänderten Anforderungen zum Testen erneut ab",
+      "017": "Ein Webserver hostet üblicherweise mehrere Webanwendungen unter derselben IP-Adresse und verweist über den virtuellen Host auf jede Anwendung. Bei einer eingehenden HTTP-Anfrage leiten Webserver die Anfrage häufig basierend auf dem im Host-Header bereitgestellten Wert an den virtuellen Zielhost weiter. Ohne ordnungsgemäße Validierung des Header-Werts kann der Angreifer ungültige Eingaben liefern, die den Webserver dazu veranlassen:\n• Senden Sie Anfragen an den ersten virtuellen Host in der Liste\n• eine Weiterleitung zu einer vom Angreifer kontrollierten Domäne verursachen\n• Web-Cache-Poisoning durchführen\n• die Funktionalität zum Zurücksetzen des Passworts manipulieren\n\nTestziele\n• Bewerten Sie, ob der Host-Header in der Anwendung dynamisch analysiert wird.\n• Umgehen Sie Sicherheitskontrollen, die auf dem Header basieren\n\nSo testen Sie\nDer erste Test ist so einfach wie die Angabe einer anderen Domain (z. B. attacker.com ) im Host-Header-Feld. Die Art und Weise, wie der Webserver den Header-Wert verarbeitet, bestimmt die Auswirkung. Der Angriff ist gültig, wenn der Webserver die Eingabe verarbeitet, um die Anforderung an einen vom Angreifer kontrollierten Host zu senden, der sich in der angegebenen Domäne befindet, und nicht an einen internen virtuellen Host, der sich auf dem Webserver befindet.\n\nWeitere Angriffe\n• X-Forwarded-Host-Header-Bypass\n• Web-Cache-Poisoning\n• Passwort-Reset-Poisoning",
+      "018": "Webanwendungen nutzen üblicherweise serverseitige Template-Technologien (Jinja2, Twig, FreeMaker usw.), um dynamische HTML-Antworten zu generieren. Serverseitige Template-Injection-Schwachstellen (SSTI) treten auf, wenn Benutzereingaben auf unsichere Weise in eine Vorlage eingebettet werden und zur Remote-Codeausführung auf dem Server führen.\n\nAlle Funktionen, die erweitertes, vom Benutzer bereitgestelltes Markup unterstützen, können für SSTI anfällig sein, einschließlich Wiki-Seiten, Rezensionen, Marketinganwendungen, CMS-Systeme usw. Einige Template-Engines verwenden verschiedene Mechanismen (z. B. Sandbox, Zulassungsliste usw.), um vor SSTI zu schützen.\n\nTestziele\n• Erkennen Sie Schwachstellen bei der Template-Injection.\n• Identifizieren Sie die Template-Engine.\n• Erstellen Sie den Exploit.\n\nSo testen Sie\n• Identifizieren Sie die Schwachstelle durch Template-Injection\n• Identifizieren Sie die Templating Engine\n• Erstellen Sie den RCE-Exploit",
+      "019": "Webanwendungen interagieren häufig mit internen oder externen Ressourcen. Während Sie davon ausgehen können, dass nur die vorgesehene Ressource die von Ihnen gesendeten Daten verarbeitet, kann eine unsachgemäße Verarbeitung der Daten dazu führen, dass Injektionsangriffe möglich sind. Eine Art von Injektionsangriff wird als Server-side Request Forgery (SSRF) bezeichnet.\n\nEin erfolgreicher SSRF-Angriff kann dem Angreifer Zugriff auf eingeschränkte Aktionen, interne Dienste oder interne Dateien innerhalb der Anwendung oder der Organisation gewähren. In einigen Fällen kann es sogar zu Remote Code Execution (RCE) kommen.\n\nTestziele\n• Identifizieren Sie SSRF-Injektionspunkte.\n• Testen Sie, ob die Einspritzpunkte ausnutzbar sind.\n• Bewertet den Schweregrad der Schwachstelle.\n\nSo testen Sie\n• Laden Sie den Inhalt einer Datei\n• Greifen Sie auf eine eingeschränkte Seite zu\n• Holen Sie sich eine lokale Datei\n\nÜbliche Filterumgehung\nManchmal lässt die Anwendung Eingaben zu, die einem bestimmten Ausdruck entsprechen, z. B. einer Domäne. Dies kann umgangen werden, wenn der URL-Schema-Parser nicht ordnungsgemäß implementiert ist, was zu Angriffen führt, die semantischen Angriffen ähneln.\n• Verwenden des @-Zeichens zur Trennung zwischen Benutzerinformationen und Host: https://expected-domain@attackerdomain\n• URL-Fragmentierung mit dem #-Zeichen: https://attacker-domain#expected-domain\n• URL-Kodierung\n• Fuzzing\n• Kombinationen aus allen oben genannten"
     },
     "err": {
       "001": "Während eines Penetrationstests für Webanwendungen stoßen wir häufig auf viele Fehlercodes, die von Anwendungen oder Webservern generiert werden.\n Es ist möglich, dass diese Fehler angezeigt werden, indem bestimmte Anfragen verwendet werden, die entweder speziell mit Tools erstellt oder manuell erstellt wurden. Diese Codes sind für Penetrationstester bei ihren Aktivitäten sehr nützlich, da sie viele Informationen über Datenbanken, Fehler und andere technologische Komponenten preisgeben, die direkt mit Webanwendungen verknüpft sind.\n\n  Eine gute Sammlung von Fehlerinformationen kann die Bewertungseffizienz verbessern, indem die Gesamtzeit für die Durchführung des Penetrationstests verkürzt wird.\n Angreifer verwenden manchmal Suchmaschinen, um Fehler zu finden, die Informationen preisgeben. Es können Suchvorgänge durchgeführt werden, um fehlerhafte Websites als zufällige Opfer zu finden, oder es ist möglich, mit den Filterwerkzeugen der Suchmaschine nach Fehlern auf einer bestimmten Website zu suchen.\n\n Nachfolgend sind einige Bereiche aufgeführt, die dem Benutzer detaillierte Fehlermeldungen zurückgeben könnten. Jeder der Bereiche enthält spezifische Informationen über das Betriebssystem, die Anwendungsversion usw.\n • Webserverfehler (HTTP-Antworten)\n • Anwendungsserverfehler (Framework-Meldungen)\n • Datenbankfehler (Datenbanksystemmeldungen)",
@@ -554,7 +568,8 @@
     "crypst": {
       "001": "Sensible Daten müssen geschützt werden, wenn sie durch das Netzwerk übertragen werden. \nAls Faustregel gilt: Wenn Daten bei der Speicherung geschützt werden müssen, müssen sie auch während der Übertragung geschützt werden.\n\n Verschiedene Arten von zu schützenden Informationen können auch im Klartext übertragen werden. Es kann überprüft werden, ob diese Informationen über HTTP statt HTTPS übertragen werden.\n\n HTTP ist ein Klartextprotokoll und wird normalerweise über einen SSL/TLS-Tunnel gesichert, was zu HTTPS-Datenverkehr führt. Server werden mit digitalen Zertifikaten authentifiziert, und es ist auch möglich, Client-Zertifikate für die gegenseitige Authentifizierung zu verwenden.\n Selbst wenn heute hochwertige Chiffren unterstützt und normalerweise verwendet werden, kann eine Fehlkonfiguration im Server dazu verwendet werden, die Verwendung einer schwachen Chiffre – oder schlimmstenfalls gar keine Verschlüsselung – zu erzwingen, die es einem Angreifer ermöglicht, Zugang zu dem vermeintlich sicheren Kommunikationskanal zu erhalten.\n\n Häufige Probleme:\n Wenn der SSL/TLS-Dienst vorhanden ist, ist er gut, aber er erhöht die Angriffsfläche und die folgenden Schwachstellen bestehen:\n • SSL/TLS-Protokolle, Chiffren, Schlüssel und Neuverhandlung müssen ordnungsgemäß konfiguriert sein\n • Zertifikatsgültigkeit muss gewährleistet sein\n • Offengelegte Software muss aufgrund möglicher bekannter Schwachstellen aktualisiert werden\n • Verwendung des Secure-Flags für Sitzungscookies\n • Verwendung von HTTP Strict Transport Security (HSTS)\n • Das Vorhandensein von HTTP und HTTPS, die zum Abfangen von Datenverkehr verwendet werden können\n • Das Vorhandensein gemischter HTTPS- und HTTP-Inhalte auf derselben Seite, die zum Leaking von Informationen verwendet werden können \n\n Prüfung auf sensible Daten, die im Klartext übertragen werden\n Ein typisches Beispiel ist die Verwendung der Basisauthentifizierung über HTTP, da bei der Basisauthentifizierung die Anmeldeinformationen nach der Anmeldung in HTTP-Header codiert – und nicht verschlüsselt – werden.\n\n Testen auf schwache SSL/TLS-Chiffren/Protokolle/Schlüssel-Schwachstellen\n Die große Anzahl verfügbarer Cipher Suites und der schnelle Fortschritt in der Kryptoanalyse machen das Testen eines SSL-Servers zu einer nicht trivialen Aufgabe. Zum Zeitpunkt des Schreibens sind diese Kriterien eine allgemein anerkannte Checkliste:\n • Schwache Chiffren dürfen nicht verwendet werden (z. B. weniger als 128 Bit)\n • Keine NULL-Ciphers-Suite, da keine Verschlüsselung verwendet wird\n • Schwache Protokolle müssen deaktiviert werden (z. B. muss SSLv2 deaktiviert werden)\n • Die Neuverhandlung muss ordnungsgemäß konfiguriert sein (z. B. muss die unsichere Neuverhandlung deaktiviert sein).\n • Keine Verschlüsselungssammlungen auf Exportebene (EXP), da diese leicht geknackt werden können\n • Die Schlüssellänge von X.509-Zertifikaten muss stark sein\n • X.509-Zertifikate dürfen nur mit sicheren Hash-Algorithmen signiert werden\n • Schlüssel müssen mit der richtigen Entropie generiert werden\n • Sichere Neuverhandlung sollte aktiviert sein.\n • MD5 sollte aufgrund bekannter Kollisionsangriffe nicht verwendet werden\n • RC4 sollte wegen kryptoanalytischer Angriffe nicht verwendet werden\n • Der Server sollte vor BEAST-Angriffen geschützt werden\n • Der Server sollte vor CRIME-Angriffen geschützt werden, die TLS-Komprimierung muss deaktiviert werden\n • Der Server sollte Forward Secrecy unterstützen",
       "002": "Ein Padding-Oracle ist eine Funktion einer Anwendung, die vom Client bereitgestellte verschlüsselte Daten entschlüsselt, z. interner Sitzungsstatus, der auf dem Client gespeichert ist, und gibt den Status der Gültigkeit der Auffüllung nach der Entschlüsselung preis.\n\n Die Existenz eines Padding-Oracles ermöglicht es einem Angreifer, verschlüsselte Daten zu entschlüsseln und willkürliche Daten zu verschlüsseln, ohne den Schlüssel zu kennen, der für diese kryptografischen Operationen verwendet wird.\n\n Blockchiffren verschlüsseln Daten nur in Blöcken bestimmter Größe. Die von gängigen Chiffren verwendeten Blockgrößen sind 8 und 16 Bytes. Daten, deren Größe nicht mit einem Vielfachen der Blockgröße der verwendeten Chiffre übereinstimmt, müssen auf bestimmte Weise aufgefüllt werden, damit der Entschlüsseler die Auffüllung entfernen kann.\n\n Der Padding-Oracle-Angriff ermöglicht es einem Angreifer, verschlüsselte Daten ohne Kenntnis des Verschlüsselungsschlüssels und der verwendeten Chiffre zu entschlüsseln, indem er geschickt manipulierte Chiffriertexte an das Padding-Oracle sendet und die von ihm zurückgegebenen Ergebnisse beobachtet. Dies führt zu einem Verlust der Vertraulichkeit der verschlüsselten Daten.\n Ein Padding-Oracle-Angriff ermöglicht es einem Angreifer auch, beliebige Klartexte ohne Kenntnis des verwendeten Schlüssels und der Chiffre zu verschlüsseln.\n\n Zunächst müssen die möglichen Eingabepunkte für ein Padding-Oracle identifiziert werden. Generell müssen folgende Bedingungen erfüllt sein:\n\n Bedingung 1:\n Die Daten sind verschlüsselt. Gute Kandidaten sind Werte, die zufällig erscheinen.\n\n Bedingung 2:\n Es wird eine Blockchiffre verwendet. Die Länge des decodierten (z. B. Base64) Chiffriertextes ist ein Vielfaches der üblichen Chiffrierblockgrößen wie 8 oder 16 Bytes. Verschiedene Chiffriertexte haben einen gemeinsamen Teiler in der Länge.\n\n Wenn ein solcher Eingabewertkandidat identifiziert wird, sollte das Verhalten der Anwendung gegenüber einer bitweisen Manipulation des verschlüsselten Werts überprüft werden.\n Die Tests und der Basiswert sollten mindestens drei verschiedene Zustände während und nach der Entschlüsselung bewirken:\n • Geheimtext wird entschlüsselt, Ergebnisdaten sind korrekt\n • Chiffrierter Text wird entschlüsselt, resultierende Daten werden verstümmelt und verursachen eine Ausnahme- oder Fehlerbehandlung in der Anwendungslogik\n • Die Chiffretext-Entschlüsselung schlägt aufgrund von Padding-Fehlern fehl\n\n Suchen Sie insbesondere nach Ausnahmen und Meldungen, die besagen, dass etwas mit dem Padding nicht stimmt. Wenn die drei oben beschriebenen unterschiedlichen Zustände implizit beobachtbar sind (unterschiedliche Fehlermeldungen, Timing-Seitenkanäle), liegt mit hoher Wahrscheinlichkeit an dieser Stelle ein Padding-Oracle vor. Beispiele:\n • ASP.NET löst „System.Security.Cryptography.Cryptographic Exception: Padding is invalid and can not be remove“ aus.\n • In Java wird in diesem Fall eine javax.crypto.BadPaddingException geworfen\n • Entschlüsselungsfehler oder ähnliches können mögliche padding oracles sein",
-      "003": "Sensible Daten müssen geschützt werden, wenn sie durch das Netzwerk übertragen werden. Wenn Daten über HTTPS übertragen oder auf andere Weise verschlüsselt werden, darf der Schutzmechanismus keine Einschränkungen oder Schwachstellen aufweisen.\n\n Als Faustregel gilt: Wenn Daten bei der Speicherung geschützt werden müssen, müssen diese Daten auch bei der Übertragung geschützt werden. \n Einige Beispiele für sensible Daten sind:\n • Bei der Authentifizierung verwendete Informationen (z. B. Anmeldeinformationen, PINs, Tokens, Cookies …)\n • Informationen, die durch Gesetze, Vorschriften oder spezifische Unternehmensrichtlinien geschützt sind (z. B. Kreditkarten, Kundendaten)\n\n Verschiedene Arten von Informationen, die geschützt werden müssen, könnten von der Anwendung im Klartext übertragen werden. Es kann überprüft werden, ob diese Informationen über HTTP statt HTTPS übertragen werden oder ob schwache Chiffren verwendet werden.\n\n 1. Basisauthentifizierung über HTTP\n Ein typisches Beispiel ist die Verwendung von Basic Authentication über HTTP. Bei Verwendung der Standardauthentifizierung werden Benutzeranmeldeinformationen codiert und nicht verschlüsselt und als HTTP-Header gesendet.\n\n 2. Formularbasierte Authentifizierung über HTTP durchgeführt\n Ein weiteres typisches Beispiel sind Authentifizierungsformulare, die Anmeldeinformationen zur Benutzerauthentifizierung über HTTP übertragen. Es ist möglich, dieses Problem zu sehen, indem Sie den HTTP-Datenverkehr mit einem Interception-Proxy untersuchen.\n\n 3. Cookie mit Sitzungs-ID, das über HTTP gesendet wird\n Das Session-ID-Cookie muss über geschützte Kanäle übertragen werden. Wenn für das Cookie kein sicheres Flag gesetzt ist, ist es der Anwendung gestattet, es unverschlüsselt zu übertragen."
+      "003": "Sensible Daten müssen geschützt werden, wenn sie durch das Netzwerk übertragen werden. Wenn Daten über HTTPS übertragen oder auf andere Weise verschlüsselt werden, darf der Schutzmechanismus keine Einschränkungen oder Schwachstellen aufweisen.\n\n Als Faustregel gilt: Wenn Daten bei der Speicherung geschützt werden müssen, müssen diese Daten auch bei der Übertragung geschützt werden. \n Einige Beispiele für sensible Daten sind:\n • Bei der Authentifizierung verwendete Informationen (z. B. Anmeldeinformationen, PINs, Tokens, Cookies …)\n • Informationen, die durch Gesetze, Vorschriften oder spezifische Unternehmensrichtlinien geschützt sind (z. B. Kreditkarten, Kundendaten)\n\n Verschiedene Arten von Informationen, die geschützt werden müssen, könnten von der Anwendung im Klartext übertragen werden. Es kann überprüft werden, ob diese Informationen über HTTP statt HTTPS übertragen werden oder ob schwache Chiffren verwendet werden.\n\n 1. Basisauthentifizierung über HTTP\n Ein typisches Beispiel ist die Verwendung von Basic Authentication über HTTP. Bei Verwendung der Standardauthentifizierung werden Benutzeranmeldeinformationen codiert und nicht verschlüsselt und als HTTP-Header gesendet.\n\n 2. Formularbasierte Authentifizierung über HTTP durchgeführt\n Ein weiteres typisches Beispiel sind Authentifizierungsformulare, die Anmeldeinformationen zur Benutzerauthentifizierung über HTTP übertragen. Es ist möglich, dieses Problem zu sehen, indem Sie den HTTP-Datenverkehr mit einem Interception-Proxy untersuchen.\n\n 3. Cookie mit Sitzungs-ID, das über HTTP gesendet wird\n Das Session-ID-Cookie muss über geschützte Kanäle übertragen werden. Wenn für das Cookie kein sicheres Flag gesetzt ist, ist es der Anwendung gestattet, es unverschlüsselt zu übertragen.",
+      "004": "Die falsche Verwendung von Verschlüsselungsalgorithmen kann zur Offenlegung vertraulicher Daten, zum Verlust von Schlüsseln, zur fehlerhaften Authentifizierung, zu unsicheren Sitzungen und zu Spoofing-Angriffen führen. Es gibt einige Verschlüsselungs- oder Hash-Algorithmen, von denen bekannt ist, dass sie schwach sind und deren Verwendung nicht empfohlen wird, beispielsweise MD5 und RC4.\n\nNeben der richtigen Auswahl sicherer Verschlüsselungs- oder Hash-Algorithmen ist auch die richtige Verwendung von Parametern für das Sicherheitsniveau von Bedeutung. Beispielsweise wird der ECB-Modus (Electronic Code Book) nicht für die Verwendung bei der asymmetrischen Verschlüsselung empfohlen.\n\nTestziele\n• Bereitstellung einer Richtlinie zur Identifizierung schwacher Verschlüsselungs- oder Hashing-Anwendungen und -Implementierungen.\n\nGrundlegende Sicherheitscheckliste\n• Bei Verwendung von AES128 oder AES256 muss der IV (Initialisierungsvektor) zufällig und unvorhersehbar sein.\n• Für asymmetrische Verschlüsselung verwenden Sie vorzugsweise Elliptic Curve Cryptography (ECC) mit einer sicheren Kurve wie Curve25519.\n• Bei Verwendung von RSA in der Signatur wird PSS-Padding empfohlen.\n• Schwache Hash-/Verschlüsselungsalgorithmen wie MD5, RC4, DES, Blowfish, SHA1 sollten nicht verwendet werden.\n• Passwort-Hashing: PBKDF2, Scrypt, Bcrypt\n• Verwendungen von SSH, CBC-Modus sollten nicht verwendet werden.\n• Wenn ein symmetrischer Verschlüsselungsalgorithmus verwendet wird, sollte der ECB-Modus (Electronic Code Book) nicht verwendet werden.\n• Wenn PBKDF2 zum Hashen von Passwörtern verwendet wird, wird empfohlen, dass der Iterationsparameter über 10.000 liegt."
     },
     "buslogic": {
       "001": "Die Anwendung muss sicherstellen, dass nur logisch gültige Daten sowohl am Frontend als auch direkt auf der Serverseite eines Anwendungssystems eingegeben werden können. Daten nur lokal zu verifizieren, kann Anwendungen anfällig für Serverinjektionen durch Proxys oder bei Übergaben an andere Systeme machen. Dies unterscheidet sich von der einfachen Durchführung einer Boundary Value Analysis (Grenzwertanalyse) dadurch, dass sie schwieriger ist und in den meisten Fällen nicht einfach am Eingangspunkt überprüft werden kann, sondern normalerweise die Überprüfung eines anderen Systems erfordert.\n\n Schwachstellen im Zusammenhang mit der Geschäftsdatenvalidierung sind insofern einzigartig, als sie anwendungsspezifisch sind und sich von den Schwachstellen im Zusammenhang mit gefälschten Anforderungen darin unterscheiden, dass sie sich mehr um logische Daten kümmern, anstatt einfach den Arbeitsablauf der Geschäftslogik zu unterbrechen.\n\n Das Front-End und das Back-End der Anwendung sollten überprüfen und validieren, dass die Daten, die sie hat, verwendet und weitergibt, logisch gültig sind. Selbst wenn der Benutzer einer Anwendung gültige Daten bereitstellt, kann die Geschäftslogik dazu führen, dass sich die Anwendung je nach Daten oder Umständen anders verhält.\n\n Generische Testmethode\n • Überprüfen Sie die Projektdokumentation und verwenden Sie explorative Tests, um nach Dateneingangspunkten oder Übergabepunkten zwischen Systemen oder Software zu suchen\n • Versuchen Sie, einmal gefundene logisch ungültige Daten in die Anwendung/das System einzufügen\n\n Spezifische Testmethode\n • Führen Sie funktional gültige Front-End-GUI-Tests für die Anwendung durch, um sicherzustellen, dass nur „gültige“ Werte akzeptiert werden.\n • Beobachten Sie bei Verwendung eines abfangenden Proxys HTTP POST/GET und suchen Sie nach Stellen, an denen Variablen wie Kosten und Qualität übergeben werden. Suchen Sie insbesondere nach „Übergaben“ zwischen Anwendungen/Systemen, bei denen möglicherweise Manipulationspunkte injiziert werden.\n • Sobald Variablen gefunden wurden, beginnen Sie damit, das Feld mit logisch „ungültigen“ Daten abzufragen, wie z. B. Sozialversicherungsnummern oder eindeutige Kennungen, die nicht existieren oder die nicht zur Geschäftslogik passen.\n Dieser Test überprüft, ob der Server ordnungsgemäß funktioniert und keine logisch ungültigen Daten akzeptiert.",
@@ -579,7 +594,11 @@
       "009": "„Clickjacking“ (das eine Teilmenge des „UI-Redressing“ ist) ist eine bösartige Technik, die darin besteht, einen Webbenutzer dazu zu verleiten, mit etwas zu interagieren, das anders ist als das, womit der Benutzer glaubt, dass er interagiert.\n Diese Art von Angriff, der allein oder in Kombination mit anderen Angriffen verwendet werden kann, könnte möglicherweise nicht autorisierte Befehle senden oder vertrauliche Informationen preisgeben, während das Opfer auf scheinbar harmlosen Webseiten interagiert.\n\n Ein Clickjacking-Angriff verwendet scheinbar harmlose Funktionen von HTML und Javascript, um das Opfer zu unerwünschten Aktionen zu zwingen, wie z. B. das Klicken auf eine Schaltfläche, die scheinbar eine andere Operation ausführt.\n\n Um diese Art von Technik auszuführen, muss der Angreifer eine scheinbar harmlose Webseite erstellen, die die Zielanwendung durch die Verwendung eines Iframes lädt.\n Sobald dies geschehen ist, könnte der Angreifer das Opfer dazu bringen, mit seiner fiktiven Webseite zu interagieren.\nSobald das Opfer auf der fiktiven Webseite surft, denkt es, dass es mit der sichtbaren Benutzeroberfläche interagiert, tatsächlich führt es jedoch Aktionen auf der versteckten Seite aus.\n\nDiese Art von Angriff ist häufig darauf ausgelegt, einer angreifenden Website zu ermöglichen, Benutzeraktionen auf der Ziel-Website zu veranlassen, selbst wenn Anti-CSRF-Token verwendet werden. . Daher ist es wichtig, wie beim CSRF-Angriff, Webseiten der Zielseite so zu kennzeichnen, dass sie Eingaben des Benutzers entgegennehmen.\n\nWir müssen herausfinden, ob die Website, die wir testen, keinen Schutz vor Clickjacking-Angriffen hat oder, ob die Entwickler Schutzmaßnahmen implementiert haben, ob diese Techniken umgangen werden können.\nMethoden zum Schutz einer Webseite vor Clickjacking können in zwei Makrokategorien unterteilt werden:\n • Clientseitiger Schutz: Frame Busting\n • Serverseitiger Schutz: X-Frame-Optionen\n\n Einige Frame-Busting-Techniken versuchen, Frames zu unterbrechen, indem sie dem Attribut „parent.location“ in der „counter-action“-Anweisung einen Wert zuweisen. Solche Aktionen sind zum Beispiel:\n • self.parent.location = document.location\n • parent.location.href = self.location\n • parent.location = self.location",
       "010": "Traditionell erlaubt das HTTP-Protokoll nur eine Anfrage/Antwort pro TCP-Verbindung. Asynchronous JavaScript and XML (AJAX) ermöglicht es Clients, Daten asynchron an den Server zu senden und zu empfangen, AJAX erfordert jedoch, dass der Client die Anforderungen initiiert und auf die Serverantworten wartet (Halbduplex).\n\n HTML5-WebSockets ermöglichen es dem Client/Server, „Vollduplex“-Kommunikationskanäle (zwei Wege) zu erstellen, sodass Client und Server wirklich asynchron kommunizieren können. WebSockets führen ihren anfänglichen „Upgrade“-Handshake über HTTP durch und von da an wird die gesamte Kommunikation über TCP-Kanäle unter Verwendung von Frames ausgeführt.\n\n 1: Identifizieren Sie, dass die Anwendung WebSockets verwendet\n • Untersuchen Sie den clientseitigen Quellcode auf das URI-Schema ws:// oder wss://\n • Verwenden Sie Browser Developer Tools, um die Netzwerk-WebSocket-Kommunikation anzuzeigen\n • Verwenden Sie die WebSocket-Registerkarte von OWASP Zed Attack Proxy (ZAP).\n\n 2: Ursprung\n • Versuchen Sie mithilfe eines WebSocket-Clients, eine Verbindung zum Remote-WebSocket-Server herzustellen\n • Wenn eine Verbindung hergestellt wird, überprüft der Server möglicherweise nicht den Ursprungsheader des WebSocket-Handshakes\n\n 3: Vertraulichkeit und Integrität\n • Überprüfen Sie, ob die WebSocket-Verbindung SSL verwendet, um vertrauliche Informationen zu übertragen (wss://)\n • Überprüfen Sie die SSL-Implementierung auf Sicherheitsprobleme (gültiges Zertifikat, BEAST, CRIME, RC4 usw.).\n\n 4: Authentifizierung\n • WebSockets führen keine Authentifizierung durch, es sollten normale Blackbox-Authentifizierungstests durchgeführt werden\n\n 5: Autorisierung\n • WebSockets behandeln keine Autorisierung, es sollten normale Blackbox-Autorisierungstests durchgeführt werden\n\n 6: Eingangsbereinigung\n • Verwenden Sie die WebSocket-Registerkarte von OWASP Zed Attack Proxy (ZAP), um WebSocket-Anforderungen und -Antworten wiederzugeben und zu fuzzen",
       "011": "Web Messaging (auch bekannt als Cross Document Messaging) ermöglicht Anwendungen, die auf verschiedenen Domänen ausgeführt werden, auf sichere Weise zu kommunizieren.\n Diese Einschränkung im Browser dient dazu, eine böswillige Website daran zu hindern, vertrauliche Daten von anderen iFrames, Registerkarten usw. zu lesen. Es gibt jedoch einige legitime Fälle, in denen zwei vertrauenswürdige Websites Daten untereinander austauschen müssen. Um diesem Bedarf gerecht zu werden, wurde Cross Document Messaging innerhalb der WHATWG-HTML5-Entwurfsspezifikation eingeführt und in allen gängigen Browsern implementiert.\n Es ermöglicht eine sichere Kommunikation zwischen mehreren Ursprüngen über iFrames, Registerkarten und Fenster hinweg.\n\n Die Messaging-API führte die Methode postMessage() ein, mit der Klartext-Nachrichten ursprungsübergreifend versendet werden können. Es besteht aus zwei Parametern, Nachricht und Domäne.\n\n Es gibt einige Sicherheitsbedenken bei der Verwendung von „*“ als Domain, die wir unten besprechen. Um dann Nachrichten zu empfangen, muss die empfangende Website einen neuen Event-Handler hinzufügen und hat die folgenden Attribute:\n • data: Der Inhalt der eingehenden Nachricht\n • Herkunft: Die Herkunft des Absenderdokuments\n • Quelle: Quellfenster\n\nEs müssen manuelle Tests durchgeführt und der JavaScript-Code analysiert werden, um herauszufinden, wie Web Messaging implementiert ist.\nInsbesondere sollte uns interessieren, wie die Website Nachrichten von nicht vertrauenswürdigen Domänen einschränkt und wie die Daten selbst für vertrauenswürdige Domänen gehandhabt werden.",
-      "012": "Lokaler Speicher, auch als Webspeicher oder Offlinespeicher bekannt, ist ein Mechanismus zum Speichern von Daten als Schlüssel/Wert-Paare, die an eine Domäne gebunden sind und durch dieselbe Ursprungsrichtlinie (SOP) erzwungen werden.\n Es gibt zwei Objekte, localStorage, das persistent ist und Neustarts des Browsers/Systems überstehen soll, und sessionStorage, das temporär ist und nur existiert, bis das Fenster oder die Registerkarte geschlossen wird.\n Im Durchschnitt erlauben Browser in diesem Speicher etwa 5 MB pro Domain zu speichern, was im Vergleich zu den 4 KB Cookies ein großer Unterschied ist, aber der Hauptunterschied aus Sicherheitsperspektive besteht darin, dass die in diesen beiden Objekten gespeicherten Daten im Client und niemals gespeichert werden an den Server gesendet.\n\n Zunächst müssen wir prüfen, ob der Local Storage verwendet wird. Dies kann überprüft werden, wenn Sie das Browser-Tool verwenden, und dann unter Ressourcen zu „Lokaler Speicher“ und „Webspeicher“ gehen.\n\n Als nächstes müssen manuelle Tests durchgeführt werden, um festzustellen, ob die Website sensible Daten im Speicher speichert, die ein Risiko darstellen und die Auswirkungen eines Informationslecks dramatisch erhöhen werden.\n Überprüfen Sie auch den Code, der den Speicher verarbeitet, um festzustellen, ob er anfällig für Injektionsangriffe ist, ein häufiges Problem, wenn der Code der Eingabe oder Ausgabe nicht entkommt."
+      "012": "Lokaler Speicher, auch als Webspeicher oder Offlinespeicher bekannt, ist ein Mechanismus zum Speichern von Daten als Schlüssel/Wert-Paare, die an eine Domäne gebunden sind und durch dieselbe Ursprungsrichtlinie (SOP) erzwungen werden.\n Es gibt zwei Objekte, localStorage, das persistent ist und Neustarts des Browsers/Systems überstehen soll, und sessionStorage, das temporär ist und nur existiert, bis das Fenster oder die Registerkarte geschlossen wird.\n Im Durchschnitt erlauben Browser in diesem Speicher etwa 5 MB pro Domain zu speichern, was im Vergleich zu den 4 KB Cookies ein großer Unterschied ist, aber der Hauptunterschied aus Sicherheitsperspektive besteht darin, dass die in diesen beiden Objekten gespeicherten Daten im Client und niemals gespeichert werden an den Server gesendet.\n\n Zunächst müssen wir prüfen, ob der Local Storage verwendet wird. Dies kann überprüft werden, wenn Sie das Browser-Tool verwenden, und dann unter Ressourcen zu „Lokaler Speicher“ und „Webspeicher“ gehen.\n\n Als nächstes müssen manuelle Tests durchgeführt werden, um festzustellen, ob die Website sensible Daten im Speicher speichert, die ein Risiko darstellen und die Auswirkungen eines Informationslecks dramatisch erhöhen werden.\n Überprüfen Sie auch den Code, der den Speicher verarbeitet, um festzustellen, ob er anfällig für Injektionsangriffe ist, ein häufiges Problem, wenn der Code der Eingabe oder Ausgabe nicht entkommt.",
+      "013": "Die XSSI-Schwachstelle (Cross Site Script Inclusion) ermöglicht den Verlust vertraulicher Daten über Ursprungs- oder Domänengrenzen hinweg. Zu den sensiblen Daten können authentifizierungsbezogene Daten (Anmeldestatus, Cookies, Authentifizierungstoken, Sitzungs-IDs usw.) oder persönliche oder sensible personenbezogene Daten des Benutzers (E-Mail-Adressen, Telefonnummern, Kreditkartendaten, Sozialversicherungsnummern usw.) gehören. XSSI ist ein clientseitiger Angriff, der Cross Site Request Forgery (CSRF) ähnelt, jedoch einen anderen Zweck verfolgt.\n\nWährend CSRF den authentifizierten Benutzerkontext verwendet, um bestimmte zustandsverändernde Aktionen innerhalb der Seite eines Opfers auszuführen (z. B. Geld auf das Konto des Angreifers überweisen, Berechtigungen ändern, Passwort zurücksetzen usw.), verwendet XSSI stattdessen JavaScript auf der Clientseite, um vertrauliche Daten preiszugeben aus authentifizierten Sitzungen.\n\nTestziele\n• Lokalisieren Sie vertrauliche Daten im gesamten System.\n• Bewerten Sie den Verlust sensibler Daten mithilfe verschiedener Techniken.\n\nSo testen Sie\n• Sammeln Sie Daten mithilfe authentifizierter und nicht authentifizierter Benutzersitzungen\n• Stellen Sie fest, ob die sensiblen Daten mithilfe von JavaScript verloren gehen können\n• Überprüfen Sie, ob über globale Variablen vertrauliche Daten verloren gehen\n• Überprüfen Sie mithilfe globaler Funktionsparameter, ob vertrauliche Daten verloren gehen\n• Suchen Sie nach Lecks sensibler Daten durch JavaScript-Laufzeitfehler\n• Prüfen Sie mithilfe von „this“ auf sensible Datenlecks durch Prototypenverkettung."
+    },
+    "api": {
+      "001": "GraphQL ist in modernen APIs sehr beliebt geworden. Es bietet Einfachheit und verschachtelte Objekte, die eine schnellere Entwicklung ermöglichen. Obwohl jede Technologie Vorteile bietet, kann sie die Anwendung auch neuen Angriffsflächen aussetzen. Der Zweck dieses Szenarios besteht darin, einige häufige Fehlkonfigurationen und Angriffsvektoren für Anwendungen bereitzustellen, die GraphQL verwenden.\n\nTestziele:\n• Beurteilen Sie, dass eine sichere und produktionsbereite Konfiguration bereitgestellt wird.\n• Beurteilen Sie, dass eine sichere und produktionsbereite Konfiguration bereitgestellt wird.\n• Stellen Sie sicher, dass ordnungsgemäße Zugangskontrollen angewendet werden.\n\nDas Testen von GraphQL-Knoten unterscheidet sich nicht wesentlich vom Testen anderer API-Technologien.\nIntrospektionsabfragen sind die Methode, mit der GraphQL Sie fragen lässt, welche Abfragen unterstützt werden, welche Datentypen verfügbar sind und viele weitere Details, die Sie benötigen, wenn Sie sich einem Test einer GraphQL-Bereitstellung nähern.\nEin Tool wie GraphQL Voyager kann verwendet werden, um ein besseres Verständnis des GraphQL-Endpunkts zu erhalten. Dieses Tool erstellt eine ERD-Darstellung (Entity Relationship Diagram) des GraphQL-Schemas, sodass Sie einen besseren Einblick in die beweglichen Teile des Systems erhalten, das Sie testen.\n\nDie Introspektion ist der erste Ort, um nach Autorisierungsproblemen zu suchen. Wie bereits erwähnt, sollte der Zugang zur Introspektion eingeschränkt werden, da sie die Datenextraktion und Datenerfassung ermöglicht. Sobald ein Tester Zugriff auf das Schema und Kenntnisse über die zu extrahierenden vertraulichen Informationen hat, sollte er Abfragen senden, die nicht aufgrund unzureichender Berechtigungen blockiert werden. GraphQL erzwingt standardmäßig keine Berechtigungen, daher liegt es an der Anwendung, die Autorisierungsdurchsetzung durchzuführen.\nDas Testen der Autorisierungsimplementierung variiert von Bereitstellung zu Bereitstellung, da jedes Schema unterschiedliche vertrauliche Informationen und daher unterschiedliche Ziele aufweist, auf die es sich konzentrieren muss.\n\nGraphQL ist die Implementierung der API-Schicht einer Anwendung und leitet als solche die Anforderungen normalerweise direkt an eine Back-End-API oder die Datenbank weiter. Dadurch können Sie jede zugrunde liegende Schwachstelle wie SQL-Injection, Command-Injection, Cross-Site-Scripting usw. ausnutzen. Die Verwendung von GraphQL ändert lediglich den Eintrittspunkt der bösartigen Nutzlast.\n\nGraphQL kann zur Laufzeit auf unerwartete Fehler stoßen. Wenn ein solcher Fehler auftritt, sendet der Server möglicherweise eine Fehlerantwort, die interne Fehlerdetails oder Anwendungskonfigurationen oder -daten offenlegen kann. Dadurch kann ein böswilliger Benutzer an weitere Informationen über die Anwendung gelangen. Im Rahmen des Tests sollten Fehlermeldungen durch das Senden unerwarteter Daten überprüft werden, ein Vorgang, der als Fuzzing bezeichnet wird. Die Antworten sollten nach potenziell sensiblen Informationen durchsucht werden, die mit dieser Technik offengelegt werden könnten."
     },
     "no_info": "Kein Informationen für die gegebene Referenznummer gefunden."
   }

security-c4po-angular/src/assets/i18n/en-US.json

@@ -197,7 +197,8 @@
     "ERROR_HANDLING": "Error Handling",
     "CRYPTOGRAPHY": "Cryptography",
     "BUSINESS_LOGIC_TESTING": "Business Logic Testing",
-    "CLIENT_SIDE_TESTING": "Client Side Testing"
+    "CLIENT_SIDE_TESTING": "Client Side Testing",
+    "API_TESTING": "API Testing"
   },
   "finding": {
     "findingId": "Finding Id",
@@ -351,20 +352,21 @@
       "001": "Test Network/Infrastructure Configuration",
       "002": "Test Application Platform Configuration",
       "003": "Test File Extensions Handling for Sensitive Information",
-      "004": "Backup and Unreferenced Files for Sensitive Information",
+      "004": "Review Backups and Unreferenced Files for Sensitive Information",
       "005": "Enumerate Infrastructure and Application Admin Interfaces",
       "006": "Test HTTP Methods",
       "007": "Test HTTP Strict Transport Security",
-      "008": "Test RIA cross domain policy"
+      "008": "Test RIA cross domain policy",
+      "009": "Test File Permission",
+      "010": "Test for Subdomain Takeover",
+      "011": "Test Cloud Storage"
     },
     "ident": {
       "001": "Test Role Definitions",
       "002": "Test User Registration Process",
       "003": "Test Account Provisioning Process",
       "004": "Testing for Account Enumeration and Guessable User Account",
-      "005": "Testing for Weak or unenforced username policy",
-      "006": "Test Permissions of Guest/Training Accounts",
-      "007": "Test Account Suspension/Resumption Process"
+      "005": "Testing for Weak or unenforced username policy"
     },
     "authn": {
       "001": "Testing for Credentials Transported over an Encrypted Channel",
@@ -392,7 +394,8 @@
       "005": "Testing for Cross Site Request Forgery",
       "006": "Testing for logout functionality",
       "007": "Test Session Timeout",
-      "008": "Testing for Session puzzling"
+      "008": "Testing for Session puzzling",
+      "009": "Testing for Session Hijacking"
     },
     "inpval": {
       "001": "Testing for Reflected Cross Site Scripting",
@@ -406,31 +409,34 @@
       "005_4": "Testing PostgreSQL",
       "005_5": "MS Access Testing",
       "005_6": "Testing for NoSQL Injection",
+      "005_7": "Testing for ORM Injection",
+      "005_8": "Testing for Client-side",
       "006": "Testing for LDAP Injection",
-      "007": "Testing for ORM Injection",
-      "008": "Testing for XML Injection",
-      "009": "Testing for SSI Injection",
-      "010": "Testing for XPath Injection",
-      "011": "IMAP/SMTP Injection",
-      "012": "Testing for Code Injection",
-      "012_1": "Testing Local File Inclusion",
-      "012_2": "Testing Remote File Inclusion",
-      "013": "Testing for Command Injection",
-      "014": "Testing for Buffer overflow",
-      "014_1": "Testing for Heap overflow",
-      "014_2": "Testing for Stack overflow",
-      "014_3": "Testing for Format string",
-      "015": "Testing for incubated vulnerabilities",
-      "016": "Testing for HTTP Splitting/Smuggling"
+      "007": "Testing for XML Injection",
+      "008": "Testing for SSI Injection",
+      "009": "Testing for XPath Injection",
+      "010": "IMAP/SMTP Injection",
+      "011": "Testing for Code Injection",
+      "011_1": "Testing Local File Inclusion",
+      "011_2": "Testing Remote File Inclusion",
+      "012": "Testing for Command Injection",
+      "013": "Testing for Format String Injection",
+      "014": "Testing for incubated vulnerabilities",
+      "015": "Testing for HTTP Splitting/Smuggling",
+      "016": "Testing for HTTP Incoming Requests",
+      "017": "Testing for Host Header Injection",
+      "018": "Testing for Server-side Template Injection",
+      "019": "Testing for Server-side Request Forgery"
     },
     "err": {
       "001": "Analysis of Error Codes",
       "002": "Analysis of Stack Traces"
     },
     "crypst": {
-      "001": "Testing for Weak SSL/TSL Ciphers, Insufficient Transport Layer Protection",
+      "001": "Testing for Weak SSL/TLS Ciphers, Insufficient Transport Layer Protection",
       "002": "Testing for Padding Oracle",
-      "003": "Testing for Sensitive information sent via unencrypted channels"
+      "003": "Testing for Sensitive information sent via unencrypted channels",
+      "004": "Testing for Weak Encryption"
     },
     "buslogic": {
       "001": "Test Business Logic Data Validation",
@@ -455,7 +461,11 @@
       "009": "Testing for Clickjacking",
       "010": "Testing WebSockets",
       "011": "Test Web Messaging",
-      "012": "Test Local Storage"
+      "012": "Test Local Storage",
+      "013": "Testing for Cross Site Script Inclusion"
+    },
+    "api": {
+      "001": "Testing GraphQL"
     }
   },
   "objectives": {
@@ -479,16 +489,17 @@
       "005": "Administrator interfaces may be present in the application or on the application server to allow certain users to undertake privileged activities on the site. Tests should be undertaken to reveal if and how this privileged functionality can be accessed by an unauthorized or standard user.\n\nAn application may require an administrator interface to enable a privileged user to access functionality that may make changes to how the site functions. \nSuch changes may include: \n• user account provisioning\n• site design and layout \n• data manipulation\n• configuration changes\n\nThe following describes vectors that may be used to test for the presence of administrative interfaces: \n• Directory and file enumeration \n• Brute forcing tools like THC-HYDRA \n• Comments and links in source code \n• Reviewing server and application documentation \n• Publicly available information (e.g. default passwords) \n• Alternative server port \n• Parameter tampering",
       "006": "To perform this test, the tester needs some way to figure out which HTTP methods are supported by the web server that is being examined. The OPTIONS HTTP method provides the tester with the most direct and effective way to do that. RFC 2616 states that, “The OPTIONS method represents a request for information about the communication options available on the request/response chain identified by the Request-URI”.\n\n Some of the HTTP methods can potentially pose a security risk for a web application, as they allow an attacker to modify the files stored on the web server and, in some scenarios, steal the credentials of legitimate users. More specifically, the methods that should be disabled are the following: \n• PUT: allows client to upload files to web server \n• DELETE: allwas client to delete files from web server \n• CONNECT: allows client to use web server as proxy \n• TRACE: echoes back to client whatever he sent to server",
       "007": "The HTTP Strict Transport Security (HSTS) feature lets a web application to inform the browser, through the use of a special response header, that it should never establish a connection to the the specified domain servers using HTTP.\n\n The HTTP strict transport security header uses two directives: \n• max-age  \n• includeSubDomains \n\nTesting for the presence of HSTS header can be done by checking for the existence of the HSTS header in the server’s response in an interception proxy, or by using curl.",
-      "008": "Rich Internet Applications (RIA) have adopted Adobe’s crossdomain.xml policy files to allow for controlled cross domain access to data and service consumption using technologies such as Oracle Java, Silverlight, and Adobe Flash. Therefore, a domain can grant remote access to its services from a different domain. \nHowever, often the policy files that describe the access restrictions are poorly configured. Poor configuration of the policy files enables Cross-site Request Forgery attacks. \n\n To test for RIA policy file weakness the tester should try to retrieve the policy files crossdomain.xml and clientaccesspolicy.xml from the application’s root, and from every folder found."
+      "008": "Rich Internet Applications (RIA) have adopted Adobe’s crossdomain.xml policy files to allow for controlled cross domain access to data and service consumption using technologies such as Oracle Java, Silverlight, and Adobe Flash. Therefore, a domain can grant remote access to its services from a different domain. \nHowever, often the policy files that describe the access restrictions are poorly configured. Poor configuration of the policy files enables Cross-site Request Forgery attacks. \n\n To test for RIA policy file weakness the tester should try to retrieve the policy files crossdomain.xml and clientaccesspolicy.xml from the application’s root, and from every folder found.",
+      "009": "When a resource is given a permissions setting that provides access to a wider range of actors than required, it could lead to the exposure of sensitive information, or the modification of that resource by unintended parties. This is especially dangerous when the resource is related to program configuration, execution, or sensitive user data. \n\nA clear example is an execution file that is executable by unauthorized users. For another example, account information or a token value to access an API - increasingly seen in modern web services or microservices - may be stored in a configuration file whose permissions are set to world-readable from the installation by default. Such sensitive data can be exposed by internal malicious actors of the host or by a remote attacker who compromised the service with other vulnerabilities but obtained only a normal user privilege.\n\nThe files and directories that require file permission testing include but are not limited to: \n• Web files/directory\n• Configuration files/directory \n• Sensitive files (encrypted data, password, key)/directory \n• Log files (security logs, operation logs, admin logs)/directory \n• Executables (scripts, EXE, JAR, class, PHP, ASP)/directory \n• Database files/directory\n• Temp files /directory \n• Upload files/directory",
+      "010": "A successful exploitation of this kind of vulnerability allows an adversary to claim and take control of the victim’s subdomain.\nThis attack relies on the following: \n\n1. The victim’s external DNS server subdomain record is configured to point to a non-existing or non-active resource/external service/endpoint. The proliferation of XaaS (Anything as a Service) products and public cloud services offer a lot of potential targets to consider. \n\n2. The service provider hosting the resource/external service/endpoint does not handle subdomain ownership verification properly.\n\nIf the subdomain takeover is successful a wide variety of attacks are possible (serving malicious content, phising, stealing user session cookies, credentials, etc.). This vulnerability could be exploited for a wide variety of DNS resource records including: A , CNAME , MX , NS , TXT etc. In terms of the attack severity an NS subdomain takeover (although less likely) has the highest impact because a successful attack could result in full control over the whole DNS zone and the victim’s domain.\n\nTest Objectives:\n• Enumerate all possible domains (previous and current). \n• Identify forgotten or misconfigured domains\n",
+      "011": "Cloud storage services facilitate web application and services to store and access objects in the storage service. Improper access control configuration, however, may result in sensitive information exposure, data being tampered, or unauthorized access. \n\nA known example is where an Amazon S3 bucket is misconfigured, although the other cloud storage services may also be exposed to similar risks. By default, all S3 buckets are private and can be accessed only by users that are explicitly granted access. Users can grant public access to both the bucket itself and to individual objects stored within that bucket. This may lead to an unauthorized user being able to upload new files, modify or read stored files.\n\nFirst identify the URL to access the data in the storage service, and then consider the following tests: \n• read the unauthorized data\n• upload a new arbitrary file\n\nTest Objectives:\n• Assess that the access control configuration for the storage services is properly in place"
     },
     "ident": {
-      "001": "The objective is to validate the system roles defined within the application sufficiently define and separate each system and business role to manage appropriate access to system functionality and information. \n\n It is common in modern enterprises to define system roles to manage users and authorization to system resources. \nImportant to remember is that cold, hard authorization isn’t the only way to manage access to system objects. In more trusted environments where confidentiality is not critical, softer controls such as application workflow and audit logging can support data integrity requirements while not restricting user access to functionality.\n\n Either with or without the help of the system developers or administrators, develop an role versus permission matrix. The matrix should enumerate all the roles that can be provisioned and explore the permissions that are allowed.",
+      "001": "The objective is to validate the system roles defined within the application sufficiently define and separate each system and business role to manage appropriate access to system functionality and information. \n\nApplications have several types of functionalities and services, and those require access permissions based on the needs of the user. That user could be: \n• an administrator, where they manage the application functionalities. \n• an auditor, where they review the application transactions and provide a detailed report. \n• a support engineer, where they help customers debug and fix issues on their accounts. \n• a customer, where they interact with the application and benefit from its services.\n\nIn more trusted environments where confidentiality is not critical, softer controls such as application workflow and audit logging can support data integrity requirements while not restricting user access to functionality. Either with or without the help of the system developers or administrators, develop a role versus permission matrix. The matrix should enumerate all the roles that can be provisioned and explore the permissions that are allowed.\n\nTest Objectives:\n• Identify and document roles used by the application. \n• Attempt to switch, change, or access another role. \n• Review the granularity of the roles and the needs behind the permissions given",
       "002": "Some websites offer a user registration process that automates (or semi-automates) the provisioning of system access to users. The identity requirements for access vary from positive identification to none at all, depending on the security requirements of the system. \n\n Step 1: \n Verify that the identity requirements for user registration are aligned with business and security requirements. \n\n Step 2: \n Validate the registration process. \n\n Verify that the identity requirements for user registration are aligned with business and security requirements: \n• Can anyone register for access? \n• Are registrations vetted by a human? \n• Can the same person or identity register multiple times? \n• Can users register for different roles or permissions? \n• What proof of identity is required for a registration? \n• Are registered identities verified? \n\n Validate the registration process: \n • Can identity information be easily forged or faked? \n • Can the exchange of identity information be manipulated?",
-      "003": "Verify which accounts may provision other accounts and of what type. \n\n The provisioning of accounts presents an opportunity for an attacker to create a valid account without application of the proper identification and authorization process.\nDetermine which roles are able to provision users and what sort of accounts they can provision.",
-      "004": "The scope of this test is to verify if it is possible to collect a set of valid usernames by interacting with the authentication mechanism of the application. \nThis test will be useful for brute force testing, in which the tester verifies if, given a valid username, it is possible to find the corresponding password. \n\nIn some cases, a message is received that reveals if the provided credentials are wrong because an invalid username or an invalid password was used. Sometimes, testers can enumerate the existing users by sending a username and an empty password. \n If the application is vulnerable, the tester receives a response message that reveals, directly or indirectly, some information useful for enumerating users.",
-      "005": "The objective is to determine whether a consistent account name structure renders the application vulnerable to account enumeration. Determine whether the application’s error messages permit account enumeration. \n\n User account names are often highly structured (e.g. Joe Bloggs account name is jbloggs and Fred Nurks account name is fnurks) and valid account names can easily be guessed. \n • Determine the structure of account names.\n• Evaluate the application’s response to valid and invalid account names.\n• Use different responses to valid and invalid account names to enumerate valid account names.\n• Use account name dictionaries to enumerate valid account names.",
-      "006": "Guest and Training accounts are useful ways to acquaint potential users with system functionality prior to them completing the authorisation process required for access. \n Evaluate consistency between access policy and guest/training account access permissions.",
-      "007": "Verify the identity requirements for user registration align with business/security requirements. \n\nValidate the registration process."
+      "003": "Verify which accounts may provision other accounts and of what type. \n\nThe provisioning of accounts presents an opportunity for an attacker to create a valid account without application of the proper identification and authorization process. \n\nHow to Test\n\nDetermine which roles are able to provision users and what sort of accounts they can provision:\n• Is there any verification, vetting and authorization of provisioning requests?\n• Is there any verification, vetting and authorization of de-provisioning requests? \n• Can an administrator provision other administrators or just users? \n• Can an administrator or other user provision accounts with privileges greater than their own? \n• Can an administrator or user de-provision themselves? \n• How are the files or resources owned by the de-provisioned user managed? Are they deleted? Is access transferred?",
+      "004": "The scope of this test is to verify if it is possible to collect a set of valid usernames by interacting with the authentication mechanism of the application. This test will be useful for brute force testing, in which the tester verifies if, given a valid username, it is possible to find the corresponding password. \n\nIn some cases, a message is received that reveals if the provided credentials are wrong because an invalid username or an invalid password was used. Sometimes, testers can enumerate the existing users by sending a username and an empty password. If the application is vulnerable, the tester receives a response message that reveals, directly or indirectly, some information useful for enumerating users.\n\nTest Objectives \n• Review processes that pertain to user identification (e.g. registration, login, etc.). \n• Enumerate users where possible through response analysis",
+      "005": "The objective is to determine whether a consistent account name structure renders the application vulnerable to account enumeration. Determine whether the application’s error messages permit account enumeration. \n\nTest Objectives \n• Determine whether a consistent account name structure renders the application vulnerable to account enumeration.\n• Determine whether the application’s error messages permit account enumeration.\n\nUser account names are often highly structured (e.g. Joe Bloggs account name is jbloggs and Fred Nurks account name is fnurks) and valid account names can easily be guessed.\n\nHow to Test\n• Determine the structure of account names.\n• Evaluate the application’s response to valid and invalid account names.\n• Use different responses to valid and invalid account names to enumerate valid account names.\n• Use account name dictionaries to enumerate valid account names."
     },
     "authn": {
       "001": "The analysis focuses simply on trying to understand if the data travels unencrypted from the web browser to the server, or if the web application takes the appropriate security measures using a protocol like HTTPS. \n\n Testing for credentials transport means verifying that the user’s\nauthentication data are transferred via an encrypted channel to avoid being intercepted by malicious users. \n\n You can use WebScarab or any web proxy in order to capture packet headers and to inspect them. \n Check  if HTTPS is used in every sensitive request, like those in log in pages, to prevent unauthorized users to intercept the data.",
@@ -516,7 +527,8 @@
       "005": "CSRF is an attack which forces an end user to execute unwanted actions on a web application in which he/she is currently authenticated.\nA successful CSRF exploit can compromise end user data and operation, when it targets a normal user. If the targeted end user is the administrator account, a CSRF attack can compromise the entire web application. \n CSRF relies on the following: \n\n Point 1: \n Web browser behavior regarding the handling of session-related information such as cookies and http authentication information; \n\n Point 2: \n Knowledge by the attacker of valid web application URLs; \n\n Point 3: \n Application session management relying only on information which is known by the browser; \n\n Point 4: \n Existence of HTML tags whose presence cause immediate access to an http[s] resource; for example the image tag img  \n\n The tester must know URLs in the restricted (authenticated) area. If they possess valid credentials, they can assume both roles – the attacker and the victim. In this case, testers know the URLs to be tested just by browsing around. \n\n  If session management relies only on client side values (information available to the browser), then the application is vulnerable. \n For an application to not be vulnerable, it must include session-related information in the URL, in a form of unidentifiable or unpredictable by the user.",
       "006": "Session termination is an important part of the session lifecycle. Reducing to a minimum the lifetime of the session tokens decreases the likelihood of a successful session hijacking attack. This can be seen as a control against preventing other attacks like Cross Site Scripting and Cross Site Request Forgery. Such attacks have been known to rely on a user having an authenticated session present. \n\n A secure session termination requires at least the following components: \n • Availability of user interface controls that allow the user to manually log out \n • Session termination after a given amount of time without activity (session timeout) \n • Proper invalidation of server-side session state \n\n The proper value for the session timeout depends on the purpose of the application and should be a balance of security and usability.",
       "007": "In this phase testers check that the application automatically logs out a user when that user has been idle for a certain amount of time, ensuring that it is not possible to “reuse” the same session and that no sensitive data remains stored in the browser cache. \n\n The idle timeout limits the chances that an attacker has to guess and use a valid session ID from another user, and under certain circumstances could protect public computers from session reuse. Session timeout management and expiration must be enforced server-side. If some data under the control of the client is used to enforce the session timeout, an attacker could manipulate these to extend the session duration. \n\n Step 1: \nTesters have to check whether a timeout exists, for instance, by logging in and waiting for the timeout log out to be triggered. As in the log out function, after the timeout has passed, all session tokens should be destroyed or be unusable. \n\n Step 2: \n If the timeout is configured, testers need to understand whether the timeout is enforced by the client or by the server. \n\n As a general rule, everything should be checked server-side and it should not be possible, by re-setting the session cookies to previous values, to access the application again.",
-      "008": "Session Variable Overloading (Session Puzzling) is an application level vulnerability which can enable an attacker to perform a variety of malicious actions, including by not limited to.. \n.. bypass efficient authentication enforcement mechanisms, and impersonate legitimate users. \n.. elevate the privileges of a malicious user account, in an environment that would otherwise be considered foolproof. \n.. skip over qualifying phases in multi-phase processes, even if the process includes code level restrictions.  \n.. manipulate server-side values in indirect methods that cannotbe predicted or detected. \n.. execute traditional attacks in locations that were previously unreachable, or even considered secure. \n\n This vulnerability occurs when an application uses the same session variable for more than one purpose. It can be detected and exploited by enumerating all of the session variables used by the application and in which context they are valid. In particular this is possible by accessing a sequence of entry points and then examining exit points."
+      "008": "Session Variable Overloading (Session Puzzling) is an application level vulnerability which can enable an attacker to perform a variety of malicious actions, including by not limited to.. \n.. bypass efficient authentication enforcement mechanisms, and impersonate legitimate users. \n.. elevate the privileges of a malicious user account, in an environment that would otherwise be considered foolproof. \n.. skip over qualifying phases in multi-phase processes, even if the process includes code level restrictions.  \n.. manipulate server-side values in indirect methods that cannotbe predicted or detected. \n.. execute traditional attacks in locations that were previously unreachable, or even considered secure. \n\n This vulnerability occurs when an application uses the same session variable for more than one purpose. It can be detected and exploited by enumerating all of the session variables used by the application and in which context they are valid. In particular this is possible by accessing a sequence of entry points and then examining exit points.",
+      "009": "An attacker who gets access to user session cookies can impersonate them by presenting such cookies. This attack is known as session hijacking. When considering network attackers, i.e., attackers who control the network used by the victim, session cookies can be unduly exposed to the attacker over HTTP. To prevent this, session cookies should be marked with the “Secure” attribute so that they are only communicated over HTTPS.\n\nTest Objectives \n• Identify vulnerable session cookies. \n• Hijack vulnerable cookies and assess the risk level.\n\nHow to Test\nHere are the steps for executing this test: \n1. Login to the website as the victim and reach any page offering a secure function requiring authentication. \n2. Delete from the cookie jar all the cookies which satisfy any of the following conditions. \n• in case there is no HSTS adoption: the Secure attribute is set. \n• in case there is partial HSTS adoption: the Secure attribute is set or the Domain attribute is not set. \n3. Save a snapshot of the cookie jar. \n4. Trigger the secure function identified at step 1. \n5. Observe whether the operation at step 4 has been performed successfully. If so, the attack was successful. \n6. Clear the cookie jar, login as the attacker and reach the page at step 1. \n7. Write in the cookie jar, one by one, the cookies saved at step 3. \n8. Trigger again the secure function identified at step 1. \n9. Clear the cookie jar and login again as the victim. \n10. Observe whether the operation at step 8 has been performed successfully in the victim’s account. If so, the attack was successful; otherwise, the site is secure against session hijacking.\n\nNote that the Secure attribute should also be used when the web application is entirely deployed over HTTPS, otherwise the following cookie theft attack is possible. Assume that example.com is entirely deployed over HTTPS, but does not mark its session cookies as “Secure”. \n\nThe following attack steps are possible:\n1. The victim sends a request to http://another-site.com . \n2. The attacker corrupts the corresponding response so that it triggers a request to http://example.com . \n3. The browser now tries to access http://example.com . \n4. Though the request fails, the session cookies are leaked in the clear over HTTP.\n\nWith the Domain attribute set, session cookies can be shared across sub-domains. Use of HTTP with sub-domains should be avoided to prevent the disclosure of unencrypted cookies sent over HTTP. To exemplify this security flaw, assume that the website example.com activates HSTS without the includeSubDomains option. The website issues session cookies with the Domain attribute set to example.com. \n\nThe following attack is possible:\n1. The victim sends a request to http://another-site.com. \n2. The attacker corrupts the corresponding response so that it triggers a request to http://fake.example.com. \n3. The browser now tries to access http://fake.example.com , which is permitted by the HSTS configuration. \n4. Since the request is sent to a sub-domain of example.com with the Domain attribute set, it includes the session cookies, which are leaked in the clear over HTTP."
     },
     "inpval": {
       "001": "Reflected Cross-site Scripting (XSS) occur when an attacker injects browser executable code within a single HTTP response. \nThe injected attack is not stored within the application itself; it is non-persistent and only impacts users who open a maliciously crafted link or third-party web page. \nThe attack string is included as part of the crafted URI or HTTP parameters, improperly processed by the application, and returned to the victim. One of the primary difficulties in preventing XSS vulnerabilities is proper character encoding. \n In some cases, the web server or the web application could not be filtering some encodings of characters, so, for example, the web application might filter out “<script>”, but might not filter %3cscript%3e which simply includes another encoding of tags. A test will include at least three phases: \n\n Phase 1: \nDetect input vectors. For each web page, the tester must determine all the web application’s user-defined variables and how to input them. This includes hidden or non-obvious inputs such as HTTP parameters, POST data, hidden form field values, and predefined radio or selection values. Typically in-browser HTML editors or web proxies are used to view these hidden variables. \n\n Phase 2: \n Analyze each input vector to detect potential vulnerabilities.  dTo detect an XSS vulnerability, the tester will typically use specially crafted input data with each input vector. Such input data is typically harmless, but trigger responses from the web browser that manifests the vulnerability. Testing data can be generated by using a web application fuzzer, an automated predefined list of known attack strings, or manually. \n\n Phase 3: \n For each test input attempted in the previous phase, the tester will analyze the result and determine if it represents a vulnerability that has a realistic impact on the web application’s security. This requires examining the resulting web page HTML and searching for the test input. Once found, the tester identifies any special characters that were not properly encoded, replaced, or filtered out.",
@@ -530,22 +542,24 @@
       "005_4": "When a SQL Injection has been found, you need to carefully fingerprint the backend database engine. You can determine that the backend database engine is PostgreSQL by using the :: cast operator. \n In addition, the function version() can be used to grab the PostgreSQL banner. This will also show the underlying operating system type and version. \n\n SQL Injection techniques for PostgreSQL have the following characteristics: \n • PHP Connector allows multiple statements to be executed by using ; as a statement separator \n • SQL Statements can be truncated by appending the comment char: -- \n • LIMIT and OFFSET can be used in a SELECT statement to retrieve a portion of the result set generated by the query \n\n For blind SQL injection attacks, you should take into consideration the following built-in functions: \n • String Length - LENGTH(str)  \n • Extract a substring from a given string - SUBSTR(str,index,offset)  \n • String representation with no single quotes - CHR(101)||CHR(108)||CHR(111)",
       "005_5": "Microsoft Access can utilize specific features for SQL injection techniques. \n Unfortunately, MS Access doesn’t support typical operators that are traditionally used during SQL injection testing, including: \n• No comments characters\n• No stacked queries\n• No LIMIT operator\n• No SLEEP or BENCHMARK alike operators\n• and many others \n\n Still, there are also many other functions that can be used while testing SQL injection, including but not limited to: \n • ASC: Obtain the ASCII value of a character passed as input  \n • CHR: Obtain the character of the ASCII value passed as input \n • LEN: Return the length of the string passed as parameter \n • IIF: Is the IF construct, e.g. IIF(1=1, ‘a’, ‘b’) return ‘a’ \n • MID: This function allows you to extract substring \n • TOP: This function allows you to specify the max. number of results \n •  LAST: This function is used to select only the last row of a set \n\n Various system tables exist by default in MS Access that can be potentially used to obtain table names and columns. \n Unfortunately, in the default configuration of recent MS Access database releases, these tables are not accessible. Nevertheless, it is always worth trying: \n • MSysObjects \n • MSysACEs \n • MSysAccessXML",
       "005_6": "NoSQL databases provide looser consistency restrictions than traditional SQL databases. By requiring fewer relational constraints and consistency checks, NoSQL databases often offer performance and scaling benefits. \n But because these NoSQL injection attacks may execute within a procedural language , rather than in the declarative SQL language, the potential impacts are greater than traditional SQL injection. \n\n NoSQL database calls are written in the application’s programming language, a custom API call, or formatted according to a common convention (such as XML, JSON, LINQ, etc). \n\n Typically NoSQL injection attacks will execute where the attack string is parsed, evaluated, or concatenated into a NoSQL API call. \n Additional timing attacks may be relevant to the lack of concurrency checks within a NoSQL database. These are not covered under injection testing. \n\n There are now over 150 NoSQL databases available, but at the time of writing MongoDB is the most widely used NoSQL database. \n\n The MongoDB API expects BSON (Binary JSON) calls, and includes a secure BSON query assembly tool. However, according to MongoDB documentation - unserialized JSON and JavaScript expressions are permitted in several alternative query parameters. \n For example if an attacker were able to manipulate the data passed into the $where operator, that attacker could include arbitrary JavaScript to be evaluated as part of the MongoDB query.",
+      "005_7": "ORM Injection is an attack using SQL Injection against an ORM generated data access object model. From the point of view of a tester, this attack is virtually identical to a SQL Injection attack. However, the injection vulnerability exists in code generated by the ORM tool.\n\nAn ORM is an Object Relational Mapping tool. \nIt is used to expedite object oriented development within the data access layer of software applications, including web applications. The benefits of using an ORM tool include quick generation of an object layer to communicate to a relational database, standardized code templates for these objects, and usually a set of safe functions to protect against SQL Injection attacks. ORM generated objects can use SQL or in some cases, a variant of SQL, to perform CRUD operations on a database.\n\nORM tools include Hibernate for Java, NHibernate for .NET, ActiveRecord for Ruby on Rails, EZPDO for PHP and many others.\n\nORM Injection vulnerabilities is identical to SQL Injection testing. In most cases, the vulnerability in the ORM layer is a result of customized code that does not properly validate input parameters. \nMost ORM tools provide safe functions to escape user input. However, if these functions are not used, and the developer uses custom functions that accept user input, it may be possible to execute a SQL injection attack.\n\nPatterns to look for in code include: \n• Input parameters concatenated with SQL strings",
+      "005_8": "Client-side SQL injection occurs when an application implements the Web SQL Database technology and doesn’t properly validate the input nor parametrize its query variables. This database is manipulated by using JavaScript (JS) API calls, such as openDatabase() , which creates or opens an existing database.\n\nThe following test scenario will validate that proper input validation is conducted. If the implementation is vulnerable, the attacker can read, modify, or delete information stored within the database.\n\nIf the tested application implements the Web SQL DB, the following three calls will be used in the client-side core:\n• openDatabase() \n• transaction() \n• executeSQL()",
       "006": "The Lightweight Directory Access Protocol (LDAP) is used to store information about users, hosts, and many other objects. LDAP injection is a server side attack, which could allow sensitive information about users and hosts represented in an LDAP structure to be disclosed, modified, or inserted. This is done by manipulating input parameters afterwards passed to internal search, add, and modify functions. \n A web application could use LDAP in order to let users authenticate or search other users’ information inside a corporate structure. \n\n The goal of LDAP injection attacks is to inject LDAP search filters metacharacters in a query which will be executed by the application.\n [Rfc2254] defines a grammar on how to build a search filter on LDAPv3 and extends [Rfc1960] (LDAPv2). \nAn LDAP search filter is constructed in Polish notation, also known as [prefix notation]. \n\n A successful exploitation of an LDAP injection vulnerability could allow the tester to: \n • Access unauthorized content \n • Evade application restrictions \n • Gather unauthorized informations \n • Add or modify Objects inside LDAP tree structure",
-      "007": "ORM Injection is an attack using SQL Injection against an ORM generated data access object model. From the point of view of a tester, this attack is virtually identical to a SQL Injection attack.\nHowever, the injection vulnerability exists in code generated by the ORM tool. \n\n An ORM is an Object Relational Mapping tool.\nIt is used to expedite object oriented development within the data access layer of software applications, including web applications. The benefits of using an ORM tool include quick generation of an object layer to communicate to a relational database, standardized code templates for these objects, and usually a set of safe functions to protect against SQL Injection attacks. ORM generated objects can use SQL or in some cases, a variant of SQL, to perform CRUD operations on a database. \n\n ORM tools include Hibernate for Java, NHibernate for .NET, ActiveRecord for Ruby on Rails, EZPDO for PHP and many others. \n\n ORM Injection vulnerabilities is identical to SQL Injection testing. In most cases, the vulnerability in the ORM layer is a result of customized code that does not properly validate input parameters. \n Most ORM tools provide safe functions to escape user input.\nHowever, if these functions are not used, and the developer uses custom functions that accept user input, it may be possible to execute a SQL injection attack. \n\n Patterns to look for in code include: \n • Input parameters concatenated with SQL strings",
-      "008": "XML Injection testing is when a tester tries to inject an XML doc to the application. If the XML parser fails to contextually validate data, then the test will yield a positive result. \n\n Step 1: \n In order to test an application for the presence of a XML Injection vulnerability consists of trying to insert XML metacharacters. \n\n XML metacharacters are: \n • Single quote: ‘ \n • Double quote: “ \n • Angular parentheses: > and < \n • Comment tag: <!--/--> \n • Ampersand: & \n • CDATA section delimiters: <![CDATA[ / ]]>  \n\n Another test is related to CDATA tag. Suppose that the XML document is processed to generate an HTML page. In this case, the CDATA section delimiters may be simply eliminated, without further inspecting their contents. Then, it is possible to inject HTML tags, which will be included in the generated page, completely bypassing existing sanitization routines.  \n\n Step 2: \n Once the first step is accomplished, the tester will have some information about the structure of the XML document. Then, it is possible to try to inject XML data and tags (Tag Injection).",
-      "009": "Web servers usually give developers the ability to add small pieces of dynamic code inside static HTML pages. This feature is incarnated by the Server-Side Includes (SSI). \nIn SSI injection testing, we test if it is possible to inject into the application data that will be interpreted by SSI mechanisms. A successful exploitation of this vulnerability allows an attacker to inject code into HTML pages or even perform remote code execution. \n\n With regard to SSI injection, the attacker could provide input that, if inserted by the application (or maybe directly by the server) into a dynamically generated page, would be parsed as one or more SSI directives. \n\n Step 1: \n What we need find is if the web server actually supports SSI directives. To find out we just need to discover which kind of web server is running on our target. \n Hint: If the site contains .shtml files, then SSI are probably supported, as this extension is used to identify pages containing these directives. \n\n Step 2: \n The next step consists of determining if an SSI injection attack is actually possible and, if so, what are the input points that we can use to inject our malicious code. \n We need to find every page where the user is allowed to submit some kind of input, and verify whether the application is correctly validating the submitted input. \n If sanitization is insufficient, we need to test if we can provide data that is going to be displayed unmodified. \n Besides common user-supplied data, input vectors that should always be considered are HTTP request headers and cookies content. \n\n Step 3: \n Once we have a list of potential injection points, we can check how the input is handled, what kind of filtering is performed, what characters the application is not letting through, and how many types of encoding are taken into account.",
-      "010": "Web applications heavily use databases to store and access the data they need for their operations. \n Just like relational databases are accessed via SQL language, XML databases use XPath as their standard query language. \n\n XPath is a language that has been designed and developed primarily to address parts of an XML document. In XPath injection testing, we test if it is possible to inject XPath syntax into a request interpreted by the application, allowing an attacker to execute user-controlled XPath queries. \n XPath is even more powerful than standard SQL, as its whole power is already present in its specifications, whereas a large number of the techniques that can be used in a SQL Injection attack depend on the characteristics of the SQL dialect used by the target database. \n\n The XPath attack pattern is very similar to the usual SQL Injection and as in a common SQL Injection attack, with XPath injection, the first step is to insert a single quote (‘) in the field to be tested, introducing a syntax error in the query, and to check whether the application returns an error message.",
-      "011": "This threat affects all applications that communicate with mail servers (IMAP/SMTP), generally webmail applications. The aim of this test is to verify the capacity to inject arbitrary IMAP/SMTP commands into the mail servers, due to input data not being properly sanitized. \n\n An IMAP/SMTP Injection makes it possible to access a mail server which otherwise would not be directly accessible from the Internet. In some cases, these internal systems do not have the same level of infrastructure security and hardening that is applied to the front-end web servers.Therefore, mail server results may be more vulnerable to attacks by end users. \n\n The standard attack patterns are: \n • Identifying vulnerable parameters \n • Understanding the data flow and deployment structure of the client \n • IMAP/SMTP command injection \n\n This last stage has two possible outcomes: \n\n Outcome 1: \n The injection is possible in an unauthenticated state: The affected functionality does not require the user to be authenticated. \n The injected (IMAP) commands available are limited to: \nCAPABILITY, NOOP, AUTHENTICATE, LOGIN, and LOGOUT.  \n\n Outcome 2: \n The injection is only possible in an authenticated state: the successful exploitation requires the user to be fully authenticated before testing can continue. \n\n In any case, the typical structure of an IMAP/SMTP Injection is as follows: \n • Header: ending of the expected command; \n • Body: injection of the new command; \n • Footer: beginning of the expected command.",
-      "012": "In Code Injection testing, a tester submits input that is processed by the web server as dynamic code or as an included file. These tests can target various server-side scripting engines, e.g.., ASP or PHP. Proper input validation and secure coding practices need to be employed to protect against these attacks. \n\n Testing for PHP Injection vulnerabilities \n Using the querystring, the tester can inject code to be processed as part of the included file. The malicious URL is accepted as a parameter for the PHP page, which will later use the value in an included file. \n\n Testing for ASP Code Injection vulnerabilities \n Examine ASP code for user input used in execution functions.\nCan the user enter commands into the Data input field?",
-      "012_1": "The File Inclusion vulnerability allows an attacker to include a file, usually exploiting a “dynamic file inclusion” mechanisms implemented in the target application. The vulnerability occurs due to the use of user-supplied input without proper validation. \n\n This can lead to something as outputting the contents of the file, but depending on the severity, it can also lead to:  \n • Code execution on the web server \n •  Code execution on the client-side such as JavaScript which can lead to other attacks such as cross site scripting (XSS) \n • Denial of Service (DoS) \n • Sensitive Information Disclosure \n\n Local File Inclusion (also known as LFI) is the process of including files, that are already locally present on the server, through the exploiting of vulnerable inclusion procedures. \n Since LFI occurs when paths passed to “include” statements are not properly sanitized, in a blackbox testing approach, we should look for scripts which take filenames as parameters.",
-      "012_2": "The File Inclusion vulnerability allows an attacker to include a file, usually exploiting a “dynamic file inclusion” mechanisms implemented in the target application. The vulnerability occurs due to the use of user-supplied input without proper validation. \n\n This can lead to something as outputting the contents of the file, but depending on the severity, it can also lead to: \n • Code execution on the web server \n • Code execution on the client-side such as JavaScript which can lead to other attacks such as cross site scripting (XSS) \n • Denial of Service (DoS) \n • Sensitive Information Disclosure \n\n Remote File Inclusion (also known as RFI) is the process of including remote files through the exploiting of vulnerable inclusion procedures. \n\n Since RFI occurs when paths passed to “include” statements are not properly sanitized, in a blackbox testing approach, we should look for scripts which take filenames as parameters.",
-      "013": "OS command injection is a technique used via a web interface in order to execute OS commands on a web server. The user supplies operating system commands through a web interface in order to execute OS commands. Any web interface that is not properly sanitized s subject to this exploit. \n\n When viewing a file in a web application, the file name is often shown in the URL. Perl allows piping data from a process into an open statement. The user can simply append the Pipe symbol “|” onto the end of the file name. \n Appending a semicolon to the end of a URL for a .PHP page followed by an operating system command, will execute the command. %3B is url encoded and decodes to semicolon.",
-      "014": "Different types of buffer overflow vulnerabilities have different testing methods. Here are the testing methods for the common types of buffer overflow vulnerabilities. \n\n • Testing for heap overflow vulnerability \n • Testing for stack overflow vulnerability \n • Testing for format string vulnerability",
-      "014_1": "In this test the penetration tester checks whether a they can make a Heap overflow that exploits a memory segment. \n\n Heap is a memory segment that is used for storing dynamically allocated data and global variables. Each chunk of memory in heap consists of boundary tags that contain memory management information. \n\n When a heap-based buffer is overflowed the control information in these tags is overwritten. When the heap management routine frees the buffer, a memory address overwrite takes place leading to an access violation. When the overflow is executed in a controlled fashion, the vulnerability would allow an adversary to overwrite a desired memory location with a user-controlled value. \n\n There are numerous variants of the heap overflow (heap corruption) vulnerability that can allow anything from overwriting function pointers to exploiting memory management structures for arbitrary code execution. \n\n The key is to supply as input strings that are longer than expected. Although the test process remains the same, the results that are visible in a debugger are significantly different. While in the case of a stack overflow, an instruction pointer or SEH overwrite would be apparent, this does not hold true for a heap overflow condition. \n When debugging a windows program, a heap overflow can appear in several different forms, the most common one being a pointer exchange taking place after the heap management routine comes into action. \n\n Static code analysis tools can also help in locating heap related vulnerabilities such as “double free” etc. A variety of tools like RATS, Flawfinder and ITS4 are available for analyzing C-style languages.",
-      "014_2": "Stack overflows occur when variable size data is copied into fixed length buffers located on the program stack without any bounds checking. \n Vulnerabilities of this class are generally considered to be of high severity since their exploitation would mostly permit arbitrary code execution or Denial of Service. Rarely found in interpreted platforms, code written in C and similar languages is often ridden with instances of this vulnerability. \n\n  In fact almost every platform is vulnerable to stack overflows with the following notable exceptions:  \n • J2EE – as long as native methods or system calls are not invoked \n • .NET – as long as /unsafe or unmanaged code is not invoked \n • PHP – as long as external programs and vulnerable extensions are not called \n\n Stack overflow vulnerabilities often allow an attacker to directly take control of the instruction pointer and, therefore, alter the execution of the program and execute arbitrary code. \n\n The key to testing an application for stack overflow vulnerabilities is supplying overly large input data as compared to what is expected. \n However, subjecting the application to arbitrarily large data is not sufficient. It becomes necessary to inspect the application’s execution flow and responses to ascertain whether an overflow has actually been triggered or not. \n Therefore, the steps required to locate and validate stack overflows would be to attach a debugger to the target application or process, generate malformed input for the application, subject the application to malformed input, and inspect responses in a debugger.",
-      "014_3": "Various C-Style languages provision formatting of output by means of functions like printf( ), fprintf( ) etc. Formatting is governed by a parameter to these functions termed as format type specifier, typically %s, %c etc. \n The vulnerability arises when format functions are called with inadequate parameters validation and user controlled data. \n\n A simple example would be printf(argv[1]). In this case the type specifier has not been explicitly declared, allowing a user to pass characters such as %s, %n, %x to the application by means of command line argument argv[1]. \n\n This situation tends to become precarious since a user who can supply format specifiers can perform the following malicious actions:\n • Enumerate Process Stack \n • Control Execution Flow \n • Denial of Service \n\n The key to testing format string vulnerabilities is supplying format type specifiers in application input. \n\n Format string vulnerabilities manifest mainly in web servers, application servers, or web applications utilizing C/C++ based code or CGI scripts written in C. In most of these cases, an error reporting or logging function like syslog( ) has been called insecurely. \n When testing CGI scripts for format string vulnerabilities, the input parameters can be manipulated to include %x or %n type specifiers. \n\n While performing code reviews, nearly all format string vulnerabilities can be detected by use of static code analysis tools. \n The functions that are primarily responsible for format string vulnerabilities are ones that treat format specifiers as optional. Therefore when manually reviewing code, emphasis can be given to functions such as: \n • printf \n • fprintf  \n • sprintf \n • snprintf \n • vfprintf \n • vprintf \n • vsprintf \n • vsnprintf",
-      "015": "Also often refered to as persistent attacks, incubated testing is a complex testing method that needs more than one data validation vulnerability to work. \n Incubated vulnerabilities are typically used to conduct “watering hole” attacks against users of legitimate web applications. \n\n Incubated vulnerabilities have the following characteristics: \n\n Firstly: \n The attack vector needs to be persisted in the first place, it needs to be stored in the persistence layer, and this would only occur if weak data validation was present or the data arrived into the system via another channel such as an admin console or directly via a backend batch process. \n\n Secondly: \n  Once the attack vector was “recalled” the vector would need to be executed successfully. For example, an incubated XSS attack would require weak output validation so the script would be delivered to the client in its executable form. \n\n Exploitation of some vulnerabilities, or even functional features of a web application, will allow an attacker to plant a piece of data that will later be retrieved. \n In a penetration test, incubated attacks can be used to assess the criticality of certain bugs that usually will be used to target a large number of victims at the same time. \n\n This type of asynchronous attack covers a great spectrum of attack vectors, among them the following: \n • File upload components in a web application \n • Cross-site scripting issues in public forums posts \n •  SQL/XPATH Injection allowing the attacker to upload content to a database \n • Misconfigured servers allowing installation of packages or components \n\n Step 1: \n Verify the content type allowed to upload to the web application and the resultant URL for the uploaded file.  \n\n Step 2: \n Upload a file that will exploit a component in the local user workstation when viewed or downloaded by the user. \n\n Step 3: \n Send your victim an email or other kind of alert in order to lead him/her to browse the page. \n\n The expected result is the exploit will be triggered when the user browses the resultant page or downloads and executes the file from the trusted site.",
-      "016": "There are two different attacks that target specific HTTP headers:\n• HTTP splitting\n• HTTP smuggling \n\n The first attack exploits a lack of input sanitization which allows an intruder to insert CR and LF characters into the headers of the application response and to ‘split’ that answer into two different HTTP messages. \n The goal of the attack can vary from a cache poisoning to cross site scripting. \n\n In the second attack, the attacker exploits the fact that some specially crafted HTTP messages can be parsed and interpreted in different ways depending on the agent that receives them.\nHTTP smuggling requires some level of knowledge about the different agents that are handling the HTTP messages (web server, proxy, firewall). \n\n HTTP Splitting \n Some web applications use part of the user input to generate the values of some headers of their responses. The most straightforward example is provided by redirections in which the target URL depends on some user-submitted value. \n The headers that are the most likely candidates for this attack are:\n• Location\n• Set-Cookie \n\n  HTTP Smuggling\n This leverages the different ways that a particularly crafted HTTP message can be parsed and interpreted by different agents (browsers, web caches, application firewalls)."
+      "007": "XML Injection testing is when a tester tries to inject an XML doc to the application. If the XML parser fails to contextually validate data, then the test will yield a positive result. \n\n Step 1: \n In order to test an application for the presence of a XML Injection vulnerability consists of trying to insert XML metacharacters. \n\n XML metacharacters are: \n • Single quote: ‘ \n • Double quote: “ \n • Angular parentheses: > and < \n • Comment tag: <!--/--> \n • Ampersand: & \n • CDATA section delimiters: <![CDATA[ / ]]>  \n\n Another test is related to CDATA tag. Suppose that the XML document is processed to generate an HTML page. In this case, the CDATA section delimiters may be simply eliminated, without further inspecting their contents. Then, it is possible to inject HTML tags, which will be included in the generated page, completely bypassing existing sanitization routines.  \n\n Step 2: \n Once the first step is accomplished, the tester will have some information about the structure of the XML document. Then, it is possible to try to inject XML data and tags (Tag Injection).",
+      "008": "Web servers usually give developers the ability to add small pieces of dynamic code inside static HTML pages. This feature is incarnated by the Server-Side Includes (SSI). \nIn SSI injection testing, we test if it is possible to inject into the application data that will be interpreted by SSI mechanisms. A successful exploitation of this vulnerability allows an attacker to inject code into HTML pages or even perform remote code execution. \n\n With regard to SSI injection, the attacker could provide input that, if inserted by the application (or maybe directly by the server) into a dynamically generated page, would be parsed as one or more SSI directives. \n\n Step 1: \n What we need find is if the web server actually supports SSI directives. To find out we just need to discover which kind of web server is running on our target. \n Hint: If the site contains .shtml files, then SSI are probably supported, as this extension is used to identify pages containing these directives. \n\n Step 2: \n The next step consists of determining if an SSI injection attack is actually possible and, if so, what are the input points that we can use to inject our malicious code. \n We need to find every page where the user is allowed to submit some kind of input, and verify whether the application is correctly validating the submitted input. \n If sanitization is insufficient, we need to test if we can provide data that is going to be displayed unmodified. \n Besides common user-supplied data, input vectors that should always be considered are HTTP request headers and cookies content. \n\n Step 3: \n Once we have a list of potential injection points, we can check how the input is handled, what kind of filtering is performed, what characters the application is not letting through, and how many types of encoding are taken into account.",
+      "009": "Web applications heavily use databases to store and access the data they need for their operations. \n Just like relational databases are accessed via SQL language, XML databases use XPath as their standard query language. \n\n XPath is a language that has been designed and developed primarily to address parts of an XML document. In XPath injection testing, we test if it is possible to inject XPath syntax into a request interpreted by the application, allowing an attacker to execute user-controlled XPath queries. \n XPath is even more powerful than standard SQL, as its whole power is already present in its specifications, whereas a large number of the techniques that can be used in a SQL Injection attack depend on the characteristics of the SQL dialect used by the target database. \n\n The XPath attack pattern is very similar to the usual SQL Injection and as in a common SQL Injection attack, with XPath injection, the first step is to insert a single quote (‘) in the field to be tested, introducing a syntax error in the query, and to check whether the application returns an error message.",
+      "010": "This threat affects all applications that communicate with mail servers (IMAP/SMTP), generally webmail applications. The aim of this test is to verify the capacity to inject arbitrary IMAP/SMTP commands into the mail servers, due to input data not being properly sanitized. \n\n An IMAP/SMTP Injection makes it possible to access a mail server which otherwise would not be directly accessible from the Internet. In some cases, these internal systems do not have the same level of infrastructure security and hardening that is applied to the front-end web servers.Therefore, mail server results may be more vulnerable to attacks by end users. \n\n The standard attack patterns are: \n • Identifying vulnerable parameters \n • Understanding the data flow and deployment structure of the client \n • IMAP/SMTP command injection \n\n This last stage has two possible outcomes: \n\n Outcome 1: \n The injection is possible in an unauthenticated state: The affected functionality does not require the user to be authenticated. \n The injected (IMAP) commands available are limited to: \nCAPABILITY, NOOP, AUTHENTICATE, LOGIN, and LOGOUT.  \n\n Outcome 2: \n The injection is only possible in an authenticated state: the successful exploitation requires the user to be fully authenticated before testing can continue. \n\n In any case, the typical structure of an IMAP/SMTP Injection is as follows: \n • Header: ending of the expected command; \n • Body: injection of the new command; \n • Footer: beginning of the expected command.",
+      "011": "In Code Injection testing, a tester submits input that is processed by the web server as dynamic code or as an included file. These tests can target various server-side scripting engines, e.g.., ASP or PHP. Proper input validation and secure coding practices need to be employed to protect against these attacks. \n\n Testing for PHP Injection vulnerabilities \n Using the querystring, the tester can inject code to be processed as part of the included file. The malicious URL is accepted as a parameter for the PHP page, which will later use the value in an included file. \n\n Testing for ASP Code Injection vulnerabilities \n Examine ASP code for user input used in execution functions.\nCan the user enter commands into the Data input field?",
+      "011_1": "The File Inclusion vulnerability allows an attacker to include a file, usually exploiting a “dynamic file inclusion” mechanisms implemented in the target application. The vulnerability occurs due to the use of user-supplied input without proper validation. \n\n This can lead to something as outputting the contents of the file, but depending on the severity, it can also lead to:  \n • Code execution on the web server \n •  Code execution on the client-side such as JavaScript which can lead to other attacks such as cross site scripting (XSS) \n • Denial of Service (DoS) \n • Sensitive Information Disclosure \n\n Local File Inclusion (also known as LFI) is the process of including files, that are already locally present on the server, through the exploiting of vulnerable inclusion procedures. \n Since LFI occurs when paths passed to “include” statements are not properly sanitized, in a blackbox testing approach, we should look for scripts which take filenames as parameters.",
+      "011_2": "The File Inclusion vulnerability allows an attacker to include a file, usually exploiting a “dynamic file inclusion” mechanisms implemented in the target application. The vulnerability occurs due to the use of user-supplied input without proper validation. \n\n This can lead to something as outputting the contents of the file, but depending on the severity, it can also lead to: \n • Code execution on the web server \n • Code execution on the client-side such as JavaScript which can lead to other attacks such as cross site scripting (XSS) \n • Denial of Service (DoS) \n • Sensitive Information Disclosure \n\n Remote File Inclusion (also known as RFI) is the process of including remote files through the exploiting of vulnerable inclusion procedures. \n\n Since RFI occurs when paths passed to “include” statements are not properly sanitized, in a blackbox testing approach, we should look for scripts which take filenames as parameters.",
+      "012": "OS command injection is a technique used via a web interface in order to execute OS commands on a web server. The user supplies operating system commands through a web interface in order to execute OS commands. Any web interface that is not properly sanitized s subject to this exploit. \n\n When viewing a file in a web application, the file name is often shown in the URL. Perl allows piping data from a process into an open statement. The user can simply append the Pipe symbol “|” onto the end of the file name. \n Appending a semicolon to the end of a URL for a .PHP page followed by an operating system command, will execute the command. %3B is url encoded and decodes to semicolon.",
+      "013": "A format string is a null-terminated character sequence that also contains conversion specifiers interpreted or converted at runtime. If server-side code concatenates a user’s input with a format string, an attacker can append additional conversion specifiers to cause a runtime error, information disclosure, or buffer overflow. \n\nAssess whether injecting format string conversion specifiers into user-controlled fields causes undesired behaviour from the application.\n\nThe worst case for format strings vulnerabilities occur in languages that don’t check arguments and also include a %n specifier that writes to memory. These functions, if exploited by an attacker modifying a format string, could cause information disclosure and code execution:\n• C and C++ printf and similar methods fprintf, sprintf, snprintf \n• Perl printf and sprintf\n\nThese format string functions cannot write to memory, but attackers can still cause information disclosure by changing format strings to output values the developers did not intend to send.\nThe following format string functions can cause runtime errors if the attacker adds conversion specifiers: \n• Java String.format and PrintStream.format\n• PHP printf\n\nTests include analysis of the code and injecting conversion specifiers as user input to the application under test.",
+      "014": "Also often refered to as persistent attacks, incubated testing is a complex testing method that needs more than one data validation vulnerability to work. \n Incubated vulnerabilities are typically used to conduct “watering hole” attacks against users of legitimate web applications. \n\n Incubated vulnerabilities have the following characteristics: \n\n Firstly: \n The attack vector needs to be persisted in the first place, it needs to be stored in the persistence layer, and this would only occur if weak data validation was present or the data arrived into the system via another channel such as an admin console or directly via a backend batch process. \n\n Secondly: \n  Once the attack vector was “recalled” the vector would need to be executed successfully. For example, an incubated XSS attack would require weak output validation so the script would be delivered to the client in its executable form. \n\n Exploitation of some vulnerabilities, or even functional features of a web application, will allow an attacker to plant a piece of data that will later be retrieved. \n In a penetration test, incubated attacks can be used to assess the criticality of certain bugs that usually will be used to target a large number of victims at the same time. \n\n This type of asynchronous attack covers a great spectrum of attack vectors, among them the following: \n • File upload components in a web application \n • Cross-site scripting issues in public forums posts \n •  SQL/XPATH Injection allowing the attacker to upload content to a database \n • Misconfigured servers allowing installation of packages or components \n\n Step 1: \n Verify the content type allowed to upload to the web application and the resultant URL for the uploaded file.  \n\n Step 2: \n Upload a file that will exploit a component in the local user workstation when viewed or downloaded by the user. \n\n Step 3: \n Send your victim an email or other kind of alert in order to lead him/her to browse the page. \n\n The expected result is the exploit will be triggered when the user browses the resultant page or downloads and executes the file from the trusted site.",
+      "015": "There are two different attacks that target specific HTTP headers:\n• HTTP splitting\n• HTTP smuggling \n\n The first attack exploits a lack of input sanitization which allows an intruder to insert CR and LF characters into the headers of the application response and to ‘split’ that answer into two different HTTP messages. \n The goal of the attack can vary from a cache poisoning to cross site scripting. \n\n In the second attack, the attacker exploits the fact that some specially crafted HTTP messages can be parsed and interpreted in different ways depending on the agent that receives them.\nHTTP smuggling requires some level of knowledge about the different agents that are handling the HTTP messages (web server, proxy, firewall). \n\n HTTP Splitting \n Some web applications use part of the user input to generate the values of some headers of their responses. The most straightforward example is provided by redirections in which the target URL depends on some user-submitted value. \n The headers that are the most likely candidates for this attack are:\n• Location\n• Set-Cookie \n\n  HTTP Smuggling\n This leverages the different ways that a particularly crafted HTTP message can be parsed and interpreted by different agents (browsers, web caches, application firewalls).",
+      "016": "This section describes how to monitor all incoming/outgoing HTTP requests on both client-side or server-side. The purpose of this testing is to verify if there is unnecessary or suspicious HTTP request sending in the background. \n\nMost of Web security testing tools (i.e. AppScan, BurpSuite, ZAP) act as HTTP Proxy. This will require changes of proxy on client-side application or browser. The testing techniques listed below is primary focused on how we can monitor HTTP requests without changes of client-side which will be more close to production usage scenario.\n\nTest Objectives \n• Monitor all incoming and outgoing HTTP requests to the Web Server to inspect any suspicious requests. \n• Monitor HTTP traffic without changes of end user Browser proxy or client-side application.\n\nHow to Test\nThere is situation that we would like to monitor all HTTP incoming requests on web server but we can’t change configuration on the browser or application client-side. In this scenario, we can setup a reverse proxy on web server end to monitor all incoming/outgoing requests on web server:\n• For windows platform, Fiddler is recommended.\n• For Linux platform, Charles Web Debugging Proxy may be used.\n\nThe testing steps: \n1. Install Fiddler or Charles on Web Server \n2. Configure the Fiddler or Charles as Reverse Proxy \n3. Capture the HTTP traffic \n4. Inspect HTTP traffic \n5. Modify HTTP requests and replay the modified requests for testing",
+      "017": "A web server commonly hosts several web applications on the same IP address, referring to each application via the virtual host. In an incoming HTTP request, web servers often dispatch the request to the target virtual host based on the value supplied in the Host header. Without proper validation of the header value, the attacker can supply invalid input to cause the web server to:\n• dispatch requests to the first virtual host on the list \n• cause a redirect to an attacker-controlled domain \n• perform web cache poisoning \n• manipulate password reset functionality \n\nTest Objectives \n• Assess if the Host header is being parsed dynamically in the application. \n• Bypass security controls that rely on the header\n\nHow to Test\nInitial testing is as simple as supplying another domain (i.e. attacker.com ) into the Host header field. It is how the web server processes the header value that dictates the impact. The attack is valid when the web server processes the input to send the request to an attacker-controlled host that resides at the supplied domain, and not to an internal virtual host that resides on the web server.\n\nFurther Attacks\n• X-Forwarded Host Header Bypass\n• Web Cache Poisoning\n• Password Reset Poisoning",
+      "018": "Web applications commonly use server-side templating technologies (Jinja2, Twig, FreeMaker, etc.) to generate dynamic HTML responses. Server-side Template Injection vulnerabilities (SSTI) occur when user input is embedded in a template in an unsafe manner and results in remote code execution on the server. \n\nAny features that support advanced user-supplied markup may be vulnerable to SSTI including wiki-pages, reviews, marketing applications, CMS systems etc. Some template engines employ various mechanisms (eg. sandbox, allow listing, etc.) to protect against SSTI.\n\nTest Objectives \n• Detect template injection vulnerability points. \n• Identify the templating engine. \n• Build the exploit.\n\nHow to Test \n• Identify Template Injection Vulnerability\n• Identify the Templating Engine\n• Build the RCE Exploit",
+      "019": "Web applications often interact with internal or external resources. While you may expect that only the intended resource will be handling the data you send, improperly handled data may create a situation where injection attacks are possible. One type of injection attack is called Server-side Request Forgery (SSRF). \n\nA successful SSRF attack can grant the attacker access to restricted actions, internal services, or internal files within the application or the organization. In some cases, it can even lead to Remote Code Execution (RCE).\n\nTest Objectives \n• Identify SSRF injection points. \n• Test if the injection points are exploitable. \n• Asses the severity of the vulnerability.\n\nHow to Test\n• Load the Contents of a File\n• Access a Restricted Page\n• Fetch a Local File\n\nCommon Filter Bypass\nSometimes the application allows input that matches a certain expression, like a domain. That can be circumvented if the URL schema parser is not properly implemented, resulting in attacks similar to semantic attacks.\n• Using the @ character to separate between the userinfo and the host: https://expected-domain@attackerdomain \n• URL fragmentation with the # character: https://attacker-domain#expected-domain \n• URL encoding \n• Fuzzing \n• Combinations of all of the above"
     },
     "err": {
       "001": "Often, during a penetration test on web applications, we come up against many error codes generated from applications or web servers.\n It’s possible to cause these errors to be displayed by using a particular requests, either specially crafted with tools or created manually. These codes are very useful to penetration testers during their activities, because they reveal a lot of information about databases, bugs, and other technological components directly linked with web applications. \n\n  A good collection of error information can facilitate assessment efficiency by decreasing the overall time taken to perform the penetration test. \n Attackers sometimes use search engines to locate errors that disclose information. Searches can be performed to find any erroneous sites as random victims, or it is possible to search for errors in a specific site using the search engine filtering tools. \n\n Below are some areas listed that could return detailed error messages to the user. Each of the areas has specific information about the operating system, application version, etc.  \n • Web Server Errors (HTTP Responses) \n • Application Server Errors (Framework messages) \n • Database Errors (Database System messages)",
@@ -554,7 +568,8 @@
     "crypst": {
       "001": "Sensitive data must be protected when it is transmitted through the network. \nAs a rule of thumb, if data must be protected when it is stored, it must be protected also during transmission. \n\n Various types of information which must be protected can be also transmitted in clear text. It is possible to check if this information is transmitted over HTTP instead of HTTPS. \n\n HTTP is a clear-text protocol and it is normally secured via an SSL/TLS tunnel, resulting in HTTPS traffic. Servers are authenticated using digital certificates and it is also possible to use client certificate for mutual authentication. \n Even if high grade ciphers are today supported and normally used, some misconfiguration in the server can be used to force the use of a weak cipher - or at worst no encryption - permitting to an attacker to gain access to the supposed secure communication channel. \n\n Common Issues: \n When the SSL/TLS service is present it is good but it increments the attack surface and the following vulnerabilities exist: \n • SSL/TLS protocols, ciphers, keys and renegotiation must be properly configured \n • Certificate validity must be ensured  \n • Software exposed must be updated due to possibility of known vulnerabilities  \n • Usage of Secure flag for Session Cookies  \n • Usage of HTTP Strict Transport Security (HSTS)  \n • The presence of HTTP and HTTPS both, which can be used to intercept traffic \n • The presence of mixed HTTPS and HTTP content in the same page, which can be used to Leak information \n\n Testing for sensitive data transmitted in clear-text \n A typical example is the usage of Basic Authentication over HTTP because with Basic Authentication, after log in, credentials are encoded - and not encrypted - into HTTP Headers. \n\n Testing for Weak SSL/TLS Ciphers/Protocols/Keys vulnerabilities \n The large number of available cipher suites and quick progress in cryptanalysis makes testing an SSL server a non-trivial task. At the time of writing these criteria are widely recognized a checklist: \n • Weak ciphers must not be used (e.g. less than 128 bits) \n • No NULL ciphers suite, due to no encryption used \n • Weak protocols must be disabled (e.g. SSLv2 must be disabled) \n • Renegotiation must be properly configured (e.g. Insecure Renegotiation must be disabled) \n • No Export (EXP) level cipher suites, due to can be easly broken \n • X.509 certificates key length must be strong \n • X.509 certificates must be signed only with secure hashing algoritms \n • Keys must be generated with proper entropy \n • Secure Renegotiation should be enabled. \n • MD5 should not be used, due to known collision attacks \n •  RC4 should not be used, due to crypto-analytical attacks \n • Server should be protected from BEAST Attack \n • Server should be protected from CRIME attack, TLS compression must be disabled \n • Server should support Forward Secrecy",
       "002": "A padding oracle is a function of an application which decrypts encrypted data provided by the client, e.g. internal session state stored on the client, and leaks the state of the validity of the padding after decryption. \n\n The existence of a padding oracle allows an attacker to decrypt encrypted data and encrypt arbitrary data without knowledge of the key used for these cryptographic operations. \n\n Block ciphers encrypt data only in blocks of certain sizes. Block sizes used by common ciphers are 8 and 16 bytes. Data where the size doesn’t match a multiple of the block size of the used cipher has to be padded in a specific manner so the decryptor is able to strip the padding. \n\n The padding oracle attack enables an attacker to decrypt encrypted data without knowledge of the encryption key and used cipher by sending skillful manipulated cipher texts to the padding oracle and observing of the results returned by it. This causes loss of confidentiality of the encrypted data. \n A padding oracle attack also enables an attacker to encrypt arbitrary plain texts without knowledge of the used key and cipher. \n\n First the possible input points for padding oracles must be identified. Generally the following conditions must be met:  \n\n Condition 1: \n The data is encrypted. Good candidates are values which appear to be random. \n\n Condition 2: \n A block cipher is used. The length of the decoded (e.g. Base64) cipher text is a multiple of common cipher block sizes like 8 or 16 bytes. Different cipher texts  share a common divisor in the length. \n\n If such an input value candidate is identified, the behavior of the application to bit-wise tampering of the encrypted value should be verified. \n The tests and the base value should at least cause three different states while and after decryption:  \n • Cipher text gets decrypted, resulting data is correct  \n • Cipher text gets decrypted, resulting data is garbled and causes some exception or error handling in the application logic \n • Cipher text decryption fails due to padding errors \n\n Search especially for exceptions and messages which state that something is wrong with the padding. If the three different states described above are observable implicitly (different error messages, timing side-channels), there is a high probability that there is a padding oracle present at this point. Examples: \n • ASP.NET throws “System.Security.Cryptography.Cryptographic Exception: Padding is invalid and cannot be removed.” \n •  In Java a javax.crypto.BadPaddingException is thrown in this case \n • Decryption errors or similar can be possible padding oracles",
-      "003": "Sensitive data must be protected when it is transmitted through the network. If data is transmitted over HTTPS or encrypted in another way the protection mechanism must not have limitations or vulnerabilities. \n\n As a rule of thumb if data must be protected when it is stored, this data must also be protected during transmission. \n Some examples for sensitive data are: \n • Information used in authentication (e.g. Credentials, PINs, Tokens, Cookies…) \n • Information protected by laws, regulations or specific organizational policy (e.g. Credit Cards, Customers data) \n\n Various types of information that must be protected, could be transmitted by the application in clear text. It is possible to check if this information is transmitted over HTTP instead of HTTPS, or whether weak cyphers are used. \n\n 1. Basic Authentication over HTTP \n A typical example is the usage of Basic Authentication over HTTP. When using Basic Authentication, user credentials are encoded rather than encrypted, and are sent as HTTP headers. \n\n 2. Form-Based Authentication Performed over HTTP \n Another typical example is authentication forms which transmit user authentication credentials over HTTP.  It is possible to see this issue by examining the HTTP traffic with an interception proxy. \n\n 3. Cookie Containing Session ID Sent over HTTP \n The Session ID Cookie must be transmitted over protected channels. If the cookie does not have the secure flag set it is permitted for the application to transmit it unencrypted."
+      "003": "Sensitive data must be protected when it is transmitted through the network. If data is transmitted over HTTPS or encrypted in another way the protection mechanism must not have limitations or vulnerabilities. \n\n As a rule of thumb if data must be protected when it is stored, this data must also be protected during transmission. \n Some examples for sensitive data are: \n • Information used in authentication (e.g. Credentials, PINs, Tokens, Cookies…) \n • Information protected by laws, regulations or specific organizational policy (e.g. Credit Cards, Customers data) \n\n Various types of information that must be protected, could be transmitted by the application in clear text. It is possible to check if this information is transmitted over HTTP instead of HTTPS, or whether weak cyphers are used. \n\n 1. Basic Authentication over HTTP \n A typical example is the usage of Basic Authentication over HTTP. When using Basic Authentication, user credentials are encoded rather than encrypted, and are sent as HTTP headers. \n\n 2. Form-Based Authentication Performed over HTTP \n Another typical example is authentication forms which transmit user authentication credentials over HTTP.  It is possible to see this issue by examining the HTTP traffic with an interception proxy. \n\n 3. Cookie Containing Session ID Sent over HTTP \n The Session ID Cookie must be transmitted over protected channels. If the cookie does not have the secure flag set it is permitted for the application to transmit it unencrypted.",
+      "004": "Incorrect uses of encryption algorithms may result in sensitive data exposure, key leakage, broken authentication, insecure session, and spoofing attacks. There are some encryption or hash algorithms known to be weak and are not suggested for use such as MD5 and RC4. \n\nIn addition to the right choices of secure encryption or hash algorithms, the right uses of parameters also matter for the security level. For example, ECB (Electronic Code Book) mode is not suggested for use in asymmetric encryption.\n\nTest Objectives \n• Provide a guideline for the identification weak encryption or hashing uses and implementations.\n\nBasic Security Checklist\n• When using AES128 or AES256, the IV (Initialization Vector) must be random and unpredictable.\n• For asymmetric encryption, use Elliptic Curve Cryptography (ECC) with a secure curve like Curve25519 preferred.\n• When uses of RSA in signature, PSS padding is recommended.\n• Weak hash/encryption algorithms should not be used such MD5, RC4, DES, Blowfish, SHA1.\n• Password Hashing: PBKDF2, Scrypt, Bcrypt\n• Uses of SSH, CBC mode should not be used.\n• When symmetric encryption algorithm is used, ECB (Electronic Code Book) mode should not be used.\n• When PBKDF2 is used to hash password, the parameter of iteration is recommended to be over 10000."
     },
     "buslogic": {
       "001": "The application must ensure that only logically valid data can be entered at the front end as well as directly to the server side of an application of system. Only verifying data locally may leave applications vulnerable to server injections through proxies or at handoffs with other systems. This is different from simply performing Boundary Value Analysis (BVA) in that it is more difficult and in most cases cannot be simply verified at the entry point, but usually requires checking some other system. \n\n Vulnerabilities related to business data validation is unique in that they are application specific and different from the vulnerabilities related to forging requests in that they are more concerned about logical data as opposed to simply breaking the business logic workflow. \n\n The front end and the back end of the application should be verifying and validating that the data it has, is using and is passing along is logically valid. Even if the user provides valid data to an application the business logic may make the application behave differently depending on data or circumstances. \n\n Generic Test Method  \n • Review the project documentation and use exploratory testing looking for data entry points or hand off points between systems or software \n • Once found try to insert logically invalid data into the application/system \n\n Specific Testing Method \n • Perform front-end GUI Functional Valid testing on the application to ensure that the only “valid” values are accepted. \n • Using an intercepting proxy observe the HTTP POST/GET looking for places that variables such as cost and quality are passed. Specifically, look for “hand-offs” between application/systems that may be possible injection of tamper points. \n • Once variables are found start interrogating the field with logically “invalid” data, such as social security numbers or unique identifiers that do not exist or that do not fit the business logic. \n This testing verifies that the server functions properly and does not accept logically invalid data them.",
@@ -579,7 +594,11 @@
       "009": "“Clickjacking” (which is a subset of the “UI redressing”) is a malicious technique that consists of deceiving a web user into interacting with something different to what the user believes they are interacting with. \n This type of attack, that can be used alone or in combination with other attacks, could potentially send unauthorized commands or reveal confidential information while the victim is interacting on seemingly harmless web pages. \n\n A Clickjacking attack uses seemingly innocuous features of HTML and Javascript to force the victim to perform undesired actions, such as clicking on a button that appears to perform another operation. \n\n To carry out this type of technique the attacker has to create a seemingly harmless web page that loads the target application through the use of an iframe. \n Once this is done, the attacker could induce the victim to interact with his fictitious web page.\nOnce the victim is surfing on the fictitious web page, he thinks that he is interacting with the visible user interface, but effectively he is performing actions on the hidden page.\n\nThis type of attack is often designed to allow an attacker site to induce user’s actions on the target site even if anti-CSRF tokens are being used. . So it’s important, like for the CSRF attack, to individuate web pages of the target site that it take input from the user.\n\nWe have to discover if the website that we are testing has no protections against clickjacking attacks or, if the developers have implemented some forms of protection, if these techniques are liable to bypass. \nMethods to protect a web page from clickjacking can be divided in two macro-categories: \n • Client side protection: Frame Busting \n • Server side protection: X-Frame-Options \n\n Some frame busting techniques try to break frame by assigning a value to the “parent.location” attribute in the “counter-action” statement. Such actions are, for example: \n • self.parent.location = document.location \n • parent.location.href = self.location \n • parent.location = self.location",
       "010": "Traditionally the HTTP protocol only allows one request/response per TCP connection. Asynchronous JavaScript and XML (AJAX) allows clients to send and receive data asynchronously  to the server, however, AJAX requires the client to initiate the requests and wait for the server responses (half-duplex). \n\n HTML5 WebSockets allow the client/server to create a ‘full-duplex’ (two-way) communication channels, allowing the client and server to truly communicate asynchronously. WebSockets conduct their initial ‘upgrade’ handshake over HTTP and from then on all communication is carried out over TCP channels by use of frames. \n\n 1: Identify that the application is using WebSockets \n • Inspect the client-side source code for the ws:// or wss:// URI scheme\n • Use Browser Developer Tools to view the Network WebSocket communication \n • Use OWASP Zed Attack Proxy (ZAP)’s WebSocket tab \n\n 2: Origin \n • Using a WebSocket client attempt to connect to the remote WebSocket server \n • If a connection is established the server may not be checking the origin header of the WebSocket handshake \n\n 3: Confidentiality and Integrity \n • Check that the WebSocket connection is using SSL to transport sensitive information (wss://) \n • Check the SSL Implementation for security issues s (Valid Certificate, BEAST, CRIME, RC4, etc). \n\n 4: Authentication \n • WebSockets do not handle authentication, normal black box authentication tests should be carried out \n\n 5: Authorization \n • WebSockets do not handle authorization, normal black-box authorization tests should be carried out \n\n 6: Input Sanitization \n • Use OWASP Zed Attack Proxy (ZAP)’s WebSocket tab to replay and fuzz WebSocket request and responses",
       "011": "Web Messaging (also known as Cross Document Messaging) allows applications running on different domains to communicate in a secure manner. \n This restriction within the browser is in place to restrict a malicious website to read confidential data from other iframes, tabs, etc, however there are some legitimate cases where two trusted websites need to exchange data between each other. To meet this need Cross Document Messaging was introduced within he WHATWG HTML5 draft specification and implemented in all major browsers. \n It enables secure communication between multiple origins across iframes, tabs and windows. \n\n The Messaging API introduced the postMessage() method, with which plain-text messages can be sent cross-origin. It consists of two parameters, message and domain. \n\n There are some security concerns when using ‘*’ as the domain that we discuss below. Then, in order to receive messages the receiving website needs to add a new event handler, and has the following attributes: \n • data: The content of the incoming message \n • origin: The origin of the sender document \n • source: source window \n\nManual testing needs to be conducted and the JavaScript code analyzed looking for how Web Messaging is implemented. \nIn particular we should be interested in how the website is restricting messages from untrusted domain and how the data is handled even for trusted domains.",
-      "012": "Local Storage also known as Web Storage or Offline Storage is a mechanism to store data as key/value pairs tied to a domain and enforced by the same origin policy (SOP). \n There are two objects, localStorage that is persistent and is intended to survive browser/system reboots and sessionStorage that is temporary and will only exists until the window or tab is closed. \n On average browsers allow to store in this storage around 5MB per domain, that compared to the 4KB of cookies is a big difference, but the key difference from the security perspective is that the data stored in these two objects is kept in the client and never sent to the server. \n\n First of all, we need to check whether the Local Storage is used. This can be checked when using the Browser Tool and then go under Resources you will see ‘Local Storage’ and ‘Web Storage’. \n\n Next manual testing needs to be conducted in order to determine whether the website is storing sensitive data in the storage that represents a risk and will increase dramatically the impact of a information leak. \n Also check the code handling the Storage to determine if it is vulnerable to injection attacks, common issue when the code does not escape the input or output."
+      "012": "Local Storage also known as Web Storage or Offline Storage is a mechanism to store data as key/value pairs tied to a domain and enforced by the same origin policy (SOP). \n There are two objects, localStorage that is persistent and is intended to survive browser/system reboots and sessionStorage that is temporary and will only exists until the window or tab is closed. \n On average browsers allow to store in this storage around 5MB per domain, that compared to the 4KB of cookies is a big difference, but the key difference from the security perspective is that the data stored in these two objects is kept in the client and never sent to the server. \n\n First of all, we need to check whether the Local Storage is used. This can be checked when using the Browser Tool and then go under Resources you will see ‘Local Storage’ and ‘Web Storage’. \n\n Next manual testing needs to be conducted in order to determine whether the website is storing sensitive data in the storage that represents a risk and will increase dramatically the impact of a information leak. \n Also check the code handling the Storage to determine if it is vulnerable to injection attacks, common issue when the code does not escape the input or output.",
+      "013": "Cross Site Script Inclusion (XSSI) vulnerability allows sensitive data leakage across-origin or cross-domain boundaries. Sensitive data could include authentication-related data (login states, cookies, auth tokens, session IDs, etc.) or user’s personal or sensitive personal data (email addresses, phone numbers, credit card details, social security numbers, etc.). XSSI is a client-side attack similar to Cross Site Request Forgery (CSRF) but has a different purpose. \n\nWhere CSRF uses the authenticated user context to execute certain state-changing actions inside a victim’s page (e.g. transfer money to the attacker’s account, modify privileges, reset password, etc.), XSSI instead uses JavaScript on the client-side to leak sensitive data from authenticated sessions.\n\nTest Objectives \n• Locate sensitive data across the system. \n• Assess the leakage of sensitive data through various techniques.\n\nHow to Test\n• Collect Data Using Authenticated and Unauthenticated User Sessions\n• Determine Whether the Sensitive Data Can Be Leaked Using JavaScript\n• Check for Sensitive Data Leakage via Global Variables\n• Check for Sensitive Data Leakage via Global Function Parameters\n• Check for Sensitive Data Leakage via JavaScript Runtime Errors\n• Check for Sensitive Data Leakage via Prototype Chaining Using “this”"
+    },
+    "api": {
+      "001": "GraphQL has become very popular in modern APIs. It provides simplicity and nested objects, which facilitate faster development. While every technology has advantages, it can also expose the application to new attack surfaces. The purpose of this scenario is to provide some common misconfigurations and attack vectors on applications that utilize GraphQL.\n\nTest Objectives:\n• Assess that a secure and production-ready configuration is deployed.\n• Assess that a secure and production-ready configuration is deployed.\n• Ensure that proper access controls are applied.\n\nTesting GraphQL nodes is not very different than testing other API technologies.\nIntrospection queries are the method by which GraphQL lets you ask what queries are supported, which data types are available, and many more details you will need when approaching a test of a GraphQL deployment.\nA tool such as GraphQL Voyager can be used to get a better understanding of the GraphQL endpoint. This tool creates an Entity Relationship Diagram (ERD) representation of the GraphQL schema, allowing you to get a better look into the moving parts of the system you’re testing.\n\nIntrospection is the first place to look for authorization problems. As noted, access to introspection should be restricted as it allows for data extraction and data gathering. Once a tester has access to the schema and knowledge of the sensitive information there is to extract, they should then send queries that will not be blocked due to insufficient privileges. GraphQL does not enforce permissions by default, and so it is up to the application to perform authorization enforcement.\nTesting the authorization implementation varies from deployment to deployment since each schema will have different sensitive information, and hence, different targets to focus on.\n\nGraphQL is the implementation of the API layer of an application, and as such, it usually forwards the requests to a back end API or the database directly. This allows you to utilize any underlying vulnerability such as SQL injection, command injection, cross-site scripting, etc. Using GraphQL just changes the entry point of the malicious payload.\n\nGraphQL can encounter unexpected errors during runtime. When such an error occurs, the server may send an error response that may reveal internal error details or application configurations or data. This allows a malicious user to acquire more information about the application. As part of testing, error messages should be checked by sending unexpected data, a process known as fuzzing. The responses should be searched for potentially sensitive information that may be revealed using this technique."
     },
     "no_info": "No information for given reference number found."
   }

security-c4po-angular/src/shared/config/global-variables.ts

@@ -1,4 +1,4 @@
 export const GlobalTitlesVariables = {
   SECURITYC4PO_TITLE: 'Security C4PO',
-  TOTAL_OWASP_OBJECTIVES: 95
+  TOTAL_OWASP_OBJECTIVES: 107 // Old: 95
 };

security-c4po-angular/src/shared/functions/categories/APIIT/pentests.function.ts

@@ -0,0 +1,14 @@
+import {Pentest} from '@shared/models/pentest.model';
+import {Category} from '@shared/models/category.model';
+import {PentestStatus} from '@shared/models/pentest-status.model';
+
+export function getAPI_Pentests(): Pentest[] {
+  return [
+    {
+      category: Category.API_TESTING,
+      refNumber: 'OTG-API-001',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
+    },
+  ];
+}

security-c4po-angular/src/shared/functions/categories/CLIENT/pentests.function.ts

@@ -75,6 +75,12 @@ export function getCLIENT_Pentests(): Pentest[] {
       refNumber: 'OTG-CLIENT-012',
       status: PentestStatus.NOT_STARTED,
       enabled: true
+    },
+    {
+      category: Category.CLIENT_SIDE_TESTING,
+      refNumber: 'OTG-CLIENT-013',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
     }
   ];
 }

security-c4po-angular/src/shared/functions/categories/CONFIG/pentests.function.ts

@@ -51,6 +51,24 @@ export function getCONFIG_Pentests(): Pentest[] {
       refNumber: 'OTG-CONFIG-008',
       status: PentestStatus.NOT_STARTED,
       enabled: true
+    },
+    {
+      category: Category.CONFIGURATION_AND_DEPLOY_MANAGEMENT_TESTING,
+      refNumber: 'OTG-CONFIG-009',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
+    },
+    {
+      category: Category.CONFIGURATION_AND_DEPLOY_MANAGEMENT_TESTING,
+      refNumber: 'OTG-CONFIG-010',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
+    },
+    {
+      category: Category.CONFIGURATION_AND_DEPLOY_MANAGEMENT_TESTING,
+      refNumber: 'OTG-CONFIG-011',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
     }
   ];
 }

security-c4po-angular/src/shared/functions/categories/CRYPST/pentests.function.ts

@@ -21,6 +21,12 @@ export function getCRYPST_Pentests(): Pentest[] {
       refNumber: 'OTG-CRYPST-003',
       status: PentestStatus.NOT_STARTED,
       enabled: true
+    },
+    {
+      category: Category.CRYPTOGRAPHY,
+      refNumber: 'OTG-CRYPST-004',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
     }
   ];
 }

security-c4po-angular/src/shared/functions/categories/IDENT/pentests.function.ts

@@ -33,18 +33,6 @@ export function getIDENT_Pentests(): Pentest[] {
       refNumber: 'OTG-IDENT-005',
       status: PentestStatus.NOT_STARTED,
       enabled: true
-    },
-    {
-      category: Category.IDENTITY_MANAGEMENT_TESTING,
-      refNumber: 'OTG-IDENT-006',
-      status: PentestStatus.NOT_STARTED,
-      enabled: true
-    },
-    {
-      category: Category.IDENTITY_MANAGEMENT_TESTING,
-      refNumber: 'OTG-IDENT-007',
-      status: PentestStatus.NOT_STARTED,
-      enabled: true
     }
   ];
 }

security-c4po-angular/src/shared/functions/categories/INPVAL/pentests.function.ts

@@ -70,6 +70,18 @@ export function getINPVAL_Pentests(): Pentest[] {
           status: PentestStatus.NOT_STARTED,
           enabled: true
         },
+        {
+          category: Category.INPUT_VALIDATION_TESTING,
+          refNumber: 'OTG-INPVAL-005_7',
+          status: PentestStatus.NOT_STARTED,
+          enabled: true
+        },
+        {
+          category: Category.INPUT_VALIDATION_TESTING,
+          refNumber: 'OTG-INPVAL-005_8',
+          status: PentestStatus.NOT_STARTED,
+          enabled: true
+        }
       ]
     },
     {
@@ -106,27 +118,27 @@ export function getINPVAL_Pentests(): Pentest[] {
       category: Category.INPUT_VALIDATION_TESTING,
       refNumber: 'OTG-INPVAL-011',
       status: PentestStatus.NOT_STARTED,
-      enabled: true
+      enabled: true,
+      childEntries: [
+        {
+          category: Category.INPUT_VALIDATION_TESTING,
+          refNumber: 'OTG-INPVAL-011_1',
+          status: PentestStatus.NOT_STARTED,
+          enabled: true
+        },
+        {
+          category: Category.INPUT_VALIDATION_TESTING,
+          refNumber: 'OTG-INPVAL-011_2',
+          status: PentestStatus.NOT_STARTED,
+          enabled: true
+        }
+      ]
     },
     {
       category: Category.INPUT_VALIDATION_TESTING,
       refNumber: 'OTG-INPVAL-012',
       status: PentestStatus.NOT_STARTED,
       enabled: true,
-      childEntries: [
-        {
-          category: Category.INPUT_VALIDATION_TESTING,
-          refNumber: 'OTG-INPVAL-012_1',
-          status: PentestStatus.NOT_STARTED,
-          enabled: true
-        },
-        {
-          category: Category.INPUT_VALIDATION_TESTING,
-          refNumber: 'OTG-INPVAL-012_2',
-          status: PentestStatus.NOT_STARTED,
-          enabled: true
-        }
-      ]
     },
     {
       category: Category.INPUT_VALIDATION_TESTING,
@@ -139,26 +151,6 @@ export function getINPVAL_Pentests(): Pentest[] {
       refNumber: 'OTG-INPVAL-014',
       status: PentestStatus.NOT_STARTED,
       enabled: true,
-      childEntries: [
-        {
-          category: Category.INPUT_VALIDATION_TESTING,
-          refNumber: 'OTG-INPVAL-014_1',
-          status: PentestStatus.NOT_STARTED,
-          enabled: true
-        },
-        {
-          category: Category.INPUT_VALIDATION_TESTING,
-          refNumber: 'OTG-INPVAL-014_2',
-          status: PentestStatus.NOT_STARTED,
-          enabled: true
-        },
-        {
-          category: Category.INPUT_VALIDATION_TESTING,
-          refNumber: 'OTG-INPVAL-014_3',
-          status: PentestStatus.NOT_STARTED,
-          enabled: true
-        }
-      ]
     },
     {
       category: Category.INPUT_VALIDATION_TESTING,
@@ -172,5 +164,23 @@ export function getINPVAL_Pentests(): Pentest[] {
       status: PentestStatus.NOT_STARTED,
       enabled: true
     },
+    {
+      category: Category.INPUT_VALIDATION_TESTING,
+      refNumber: 'OTG-INPVAL-017',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
+    },
+    {
+      category: Category.INPUT_VALIDATION_TESTING,
+      refNumber: 'OTG-INPVAL-018',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
+    },
+    {
+      category: Category.INPUT_VALIDATION_TESTING,
+      refNumber: 'OTG-INPVAL-019',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
+    }
   ];
 }

security-c4po-angular/src/shared/functions/categories/SESS/pentests.function.ts

@@ -51,6 +51,12 @@ export function getSESS_Pentests(): Pentest[] {
       refNumber: 'OTG-SESS-008',
       status: PentestStatus.NOT_STARTED,
       enabled: true
+    },
+    {
+      category: Category.SESSION_MANAGEMENT_TESTING,
+      refNumber: 'OTG-SESS-009',
+      status: PentestStatus.NOT_STARTED,
+      enabled: true
     }
   ];
 }

security-c4po-angular/src/shared/functions/categories/get-temp-pentests-for-category.function.ts

@@ -12,6 +12,7 @@ import {getERR_Pentests} from '@shared/functions/categories/ERR/pentests.functio
 import {getCRYPST_Pentests} from '@shared/functions/categories/CRYPST/pentests.function';
 import {getBUSLOGIC_Pentests} from '@shared/functions/categories/BUSLOGIC/pentests.function';
 import {getCLIENT_Pentests} from '@shared/functions/categories/CLIENT/pentests.function';
+import {getAPI_Pentests} from '@shared/functions/categories/APIIT/pentests.function';
 
 export function getTempPentestsForCategory(requestedCategory: Category): Pentest[] {
   let pentests: Pentest[];
@@ -60,6 +61,10 @@ export function getTempPentestsForCategory(requestedCategory: Category): Pentest
       pentests = getCLIENT_Pentests();
       break;
     }
+    case Category.API_TESTING: {
+      pentests = getAPI_Pentests();
+      break;
+    }
     default: {
       pentests = [];
       console.error('Invalid categories: ', requestedCategory);

security-c4po-angular/src/shared/functions/categories/get-title-key-for-ref-number.function.ts

@@ -53,6 +53,10 @@ export function getTitleKeyForRefNumber(refNumber: string): string {
       translationKey += 'client.' + refNumberKey;
       break;
     }
+    case refNumber.includes('API'): {
+      translationKey += 'api.' + refNumberKey;
+      break;
+    }
     default: {
       translationKey = 'pentest.categories.translation';
       console.error('Invalid category number: ', refNumber.slice(4 - refNumber.length));

security-c4po-angular/src/shared/functions/infos/get-pentest-info-for-objective.ts

@@ -54,6 +54,10 @@ export function getPentestInfoForObjective(refNumber: string): string {
       translationKey += 'client.' + refNumberKey;
       break;
     }
+    case refNumber.includes('API'): {
+      translationKey += 'api.' + refNumberKey;
+      break;
+    }
     default: {
       translationKey = 'objectives.no_info';
       console.error('Invalid category number: ', refNumber.slice(4 - refNumber.length));

security-c4po-angular/src/shared/models/category.model.ts

@@ -9,7 +9,8 @@ export enum Category {
   ERROR_HANDLING,
   CRYPTOGRAPHY,
   BUSINESS_LOGIC_TESTING,
-  CLIENT_SIDE_TESTING
+  CLIENT_SIDE_TESTING,
+  API_TESTING
 }
 
 export class CategoryDetails {

security-c4po-angular/src/shared/modules/finding-dialog/finding-dialog.component.html

@@ -134,10 +134,10 @@
                     type="text" required fullWidth
                     id="{{formArray[5].fieldName}}" nbInput
                     class="form-field form-textarea"
-                    rows="{{formArray[5].controlsConfig[0].value !== '' ? formArray[5].controlsConfig[0].value.split(getRowsFromString).length + 1 : 2}}"
+                    rows="{{formArray[5].controlsConfig[0].value !== '' ? formArray[5].controlsConfig[0].value.split(getRowsFromString).length + 2 : 2}}"
                     [status]="findingFormGroup.get(formArray[5].fieldName).dirty ? (findingFormGroup.get(formArray[5].fieldName).invalid  ? 'danger' : 'basic') : 'basic'"
                     placeholder="{{formArray[5].placeholder | translate}} *">
-            </textarea>
+          </textarea>
           <!-- FIXME: when the bug (https://github.com/angular/components/issues/7739) is fixed -->
           <ng-template ngFor let-error [ngForOf]="formArray[5].errors"
                        *ngIf="findingFormGroup.get(formArray[5].fieldName).dirty">
@@ -156,10 +156,10 @@
                     type="text" fullWidth
                     id="{{formArray[6].fieldName}}" nbInput
                     class="form-field form-textarea"
-                    rows="{{formArray[6].controlsConfig[0].value !== '' ? formArray[6].controlsConfig[0].value.split(getRowsFromString).length + 1 : 2}}"
+                    rows="{{formArray[6].controlsConfig[0].value !== '' ? formArray[6].controlsConfig[0].value.split(getRowsFromString).length + 2 : 2}}"
                     [status]="findingFormGroup.get(formArray[6].fieldName).dirty ? (findingFormGroup.get(formArray[6].fieldName).invalid  ? 'danger' : 'basic') : 'basic'"
                     placeholder="{{formArray[6].placeholder | translate}}">
-            </textarea>
+          </textarea>
           <!-- FIXME: when the bug (https://github.com/angular/components/issues/7739) is fixed -->
           <ng-template ngFor let-error [ngForOf]="formArray[6].errors"
                        *ngIf="findingFormGroup.get(formArray[6].fieldName).dirty">

security-c4po-angular/src/shared/modules/finding-dialog/finding-dialog.component.scss

@@ -31,7 +31,7 @@
 
   .form-textarea {
     width: 30rem !important;
-    height: 8rem;
+    min-height: 8rem;
   }
 
   .additionalUrl {

security-c4po-angular/src/shared/services/api/pentest.service.ts

@@ -25,7 +25,7 @@ export class PentestService {
    * Load Pentests
    * @param category the categories of which the pentests should be requested
    */
-  // ToDo: Should be refactored to be less ugly fr
+  // ToDo: Should be refactored to be less ugly
   public loadPentests(category: Category): Observable<Pentest[]> {
     return this.store.select(ProjectState.project).pipe(
       switchMap(project => this.getPentestByProjectIdAndCategory(project.id, category)),

security-c4po-api/src/main/kotlin/com/securityc4po/api/pentest/PentestCategory.kt

@@ -11,5 +11,6 @@ enum class PentestCategory {
     ERROR_HANDLING,
     CRYPTOGRAPHY,
     BUSINESS_LOGIC_TESTING,
-    CLIENT_SIDE_TESTING
+    CLIENT_SIDE_TESTING,
+    API_TESTING
 }

security-c4po-api/src/main/kotlin/com/securityc4po/api/project/ProjectController.kt

@@ -29,8 +29,6 @@ class ProjectController(private val projectService: ProjectService, private val
     fun getProjects(
         @AuthenticationPrincipal user: Appuser
     ): Mono<ResponseEntity<List<ResponseBody>>> {
-
-        println("controller " + user.getSub())
         return projectService.getProjects(user.getSub()).map { projectList ->
             projectList.map {
                 it.toProjectResponseBody()

security-c4po-api/src/main/resources/application-TEST.properties

@@ -1,5 +1,7 @@
 ## IdentityProvider (Keycloak) ##
-keycloak.client.url=http://localhost:9999
+spring.security.oauth2.resourceserver.jwt.issuer-uri=http://localhost:8080/auth/realms/c4po_realm_local
+keycloakhost=localhost
+keycloak.client.url=http://localhost:8080/
 keycloak.client.realm.path=auth/realms/c4po_realm_local/
 
 ## Database (MONGODB) Config ##

security-c4po-api/src/main/resources/application.properties

@@ -32,6 +32,6 @@ keycloakhost=localhost
 keycloak.client.url=http://localhost:8080
 keycloak.client.realm.path=auth/realms/c4po_realm_local/
 
-## Total number of pentests / objectives listet in the OWASP testing guide
-## https://owasp.org/www-project-web-security-testing-guide/assets/archive/OWASP_Testing_Guide_v4.pdf
-owasp.web.objectives=95
+## Total number of pentests / objectives listed in the OWASP testing guide
+## https://owasp.org/www-project-web-security-testing-guide/v42/
+owasp.web.objectives=107

security-c4po-api/src/test/kotlin/com/securityc4po/api/BaseContainerizedTest.kt

@@ -63,6 +63,7 @@ abstract class BaseContainerizedTest {
                 Wait.forHttp("/auth")
             )
 
+
         @DynamicPropertySource
         @JvmStatic
         fun jwtValidationProperties(registry: DynamicPropertyRegistry) {

security-c4po-reporting/src/main/kotlin/com/securityc4po/reporting/remote/APIService.kt

@@ -23,7 +23,8 @@ class APIService(private val apiClient: APIClient) {
         "ERROR_HANDLING",
         "CRYPTOGRAPHY",
         "BUSINESS_LOGIC_TESTING",
-        "CLIENT_SIDE_TESTING"
+        "CLIENT_SIDE_TESTING",
+        "API_TESTING"
     )
 
     /**

security-c4po-reporting/src/main/kotlin/com/securityc4po/reporting/remote/model/api/PentestCategory.kt

@@ -11,5 +11,6 @@ enum class PentestCategory {
     ERROR_HANDLING,
     CRYPTOGRAPHY,
     BUSINESS_LOGIC_TESTING,
-    CLIENT_SIDE_TESTING
+    CLIENT_SIDE_TESTING,
+    API_TESTING
 }

security-c4po-reporting/src/main/kotlin/com/securityc4po/reporting/report/ReportService.kt

@@ -261,7 +261,8 @@ class ReportService {
                 CategoryPieData("ERROR_HANDLING", 0),
                 CategoryPieData("CRYPTOGRAPHY", 0),
                 CategoryPieData("BUSINESS_LOGIC_TESTING", 0),
-                CategoryPieData("CLIENT_SIDE_TESTING", 0)
+                CategoryPieData("CLIENT_SIDE_TESTING", 0),
+                CategoryPieData("API_TESTING", 0)
             )
             // Fill data for CategoryPieDataSet
             for (i in 0 until projectReportCollection.projectPentestReport.size) {
@@ -303,11 +304,15 @@ class ReportService {
                     }
 
                     "BUSINESS_LOGIC_TESTING" -> {
-                        categoryFindings[9].numberOfFindings += projectReportCollection.projectPentestReport[i].findings.size - 1
+                        categoryFindings[9].numberOfFindings += projectReportCollection.projectPentestReport[i].findings.size
                     }
 
                     "CLIENT_SIDE_TESTING" -> {
-                        categoryFindings[10].numberOfFindings += projectReportCollection.projectPentestReport[i].findings.size - 1
+                        categoryFindings[10].numberOfFindings += projectReportCollection.projectPentestReport[i].findings.size
+                    }
+
+                    "API_TESTING" -> {
+                        categoryFindings[11].numberOfFindings += projectReportCollection.projectPentestReport[i].findings.size
                     }
 
                     else -> {
@@ -347,7 +352,6 @@ class ReportService {
                         "CRITICAL" -> {
                             severityFindings[3].numberOfFindings += 1
                         }
-
                         else -> {
                             severityFindings.add(
                                 SeverityPieData(

security-c4po-reporting/src/main/resources/application.properties

@@ -24,9 +24,9 @@ keycloak.client.url=http://localhost:8080
 keycloak.client.realm.path=auth/realms/c4po_realm_local/
 
 ## Total number of pentests listet in the OWASP testing guide
-## https://owasp.org/www-project-web-security-testing-guide/assets/archive/OWASP_Testing_Guide_v4.pdf
+## https://owasp.org/www-project-web-security-testing-guide/v42/
 # ToDo: Disabled objectives are not excluded as of now
-owasp.web.pentests=95
+owasp.web.pentests=107
 
 ## Jasper ##
 reportCoverDesignTemplate=/jasper/reports/c4po_cover.jrxml

security-c4po-reporting/src/main/resources/jasper/localization/labels_de.properties

@@ -41,7 +41,7 @@ title.risk_matrix=Risiko Matrix
 text.risk_matrix=Die Risikomatrix wird verwendet, um den potenziellen Schaden einer Gefahr basierend auf den Faktoren Wahrscheinlichkeit und Schweregrad zu bewerten. Die Wahrscheinlichkeits- und Schweregradbewertungen werden multipliziert, um einen Bewertungswert zu erhalten. Diese Punktzahl wird in den Risikobereichen nachgeschlagen, um das Risikoniveau zu bestimmen. Ein Beispiel für eine Gefahren-Risiko-Matrix ist unten angegeben:
 example.risk_matrix=Beispiel: Wenn Wahrscheinlichkeit = Möglich (3) und Schweregrad = Erheblich (4), wird die Risikostufe durch Schweregrad * Wahrscheinlichkeit bestimmt, was 3*4 = 12 ist. Die Punktzahl 12 fällt in den Risikobereich 'High'.
 # Risk Matrix Table Properties
-risk_score=Risiko-Score
+risk_score=Risiko
 to=bis
 risk_level_cat=Risikostufen
 #

security-c4po-reporting/src/main/resources/jasper/subReports/CommentsSubreport.jrxml

@@ -62,14 +62,14 @@
 				</graphicElement>
 			</ellipse>
 			<textField textAdjust="StretchHeight">
-				<reportElement x="80" y="-12" width="480" height="32" forecolor="#FFFFFF" uuid="f3b19575-bca9-450c-93bf-f9abbfe15bde"/>
+				<reportElement x="100" y="-12" width="460" height="32" forecolor="#FFFFFF" uuid="f3b19575-bca9-450c-93bf-f9abbfe15bde"/>
 				<textElement verticalAlignment="Middle">
 					<font size="14" isBold="true"/>
 				</textElement>
 				<textFieldExpression><![CDATA[$F{id}]]></textFieldExpression>
 			</textField>
 			<textField>
-				<reportElement x="0" y="-12" width="80" height="32" forecolor="#FFFFFF" uuid="e3a73731-aebe-4f52-b965-c33e63c03dac"/>
+				<reportElement x="0" y="-12" width="100" height="32" forecolor="#FFFFFF" uuid="e3a73731-aebe-4f52-b965-c33e63c03dac"/>
 				<textElement verticalAlignment="Middle">
 					<font size="14" isBold="true"/>
 				</textElement>