Ups, ich habe ein Feature entwickelt und eine Open-Redirect-Schwachstelle in einer Deno-App geschaffen

Wir richten Schritt für Schritt eine einfache Deno-Webanwendung mit „Hello World“ ein. Deno ist eine zunehmend beliebte Laufzeitumgebung für JavaScript und TypeScript. Konkret:

Wir erstellen eine Deno-Webanwendung, die einen Redirect-Query-Parameter unterstützt, und erfahren, wie Entwickler versehentlich Sicherheitslücken schaffen können, wenn sie Roadmap-Pläne umsetzen und Features entwickeln.

Erste Schritte mit einem Deno-Code-Tutorial zu „Hello World“

Stellen Sie zunächst sicher, dass Sie Zugriff auf eine Deno-Webentwicklungsumgebung mit den erforderlichen Tools haben, um Deno-Projekte auszuführen und mit der Webanwendung zu interagieren.

Führen Sie die folgenden Schritte aus, um Ihre Deno-Anwendung mit „Hello World“ zu erstellen:

1. Installieren Sie Deno in Ihrer Entwicklungsumgebung. Falls Sie das noch nicht getan haben, finden Sie die Installationsanleitung auf der [offiziellen Deno-Website](https://deno.land/#installation).

2. Erstellen Sie ein neues Deno-Projekt. Legen Sie dazu ein neues Verzeichnis an und initialisieren Sie es mit einer deps.ts-Datei. In dieser Datei werden unsere Abhängigkeiten gespeichert. Da es sich um eine einfache Anwendung handelt, benötigen wir allerdings keine.

   ```bash
    mkdir deno-hello-world
    cd deno-hello-world
    echo "" > deps.ts
    ```

3. Erstellen Sie eine neue server.ts-Datei. Diese Datei enthält unsere Serverlogik. Importieren Sie darin die Funktion serve aus dem Modul std/http, richten Sie einen Server ein und warten Sie auf eingehende Anfragen.

4. Fügen Sie die Serverlogik hinzu. Ergänzen Sie den folgenden Code in der Datei server.ts:

    ```typescript
import { serve } from "https://deno.land/std/http/server.ts";

const httpHandler = async (request: Request): Promise<Response> => {

    let bodyContent = 'Hello World';

    return new Response(bodyContent, {
        status: 200,
        headers: {
            "content-type": "text/html"
        }
    })
};

serve(httpHandler, { hostname: "0.0.0.0", port: 8080 });
console.log("HTTP server is running on http://localhost:8080/");
```

5. Starten Sie den Server. Speichern Sie die Datei server.ts und starten Sie den Server, indem Sie den folgenden Befehl im Terminal ausführen:

    ```bash
    deno run --allow-net server.ts
    ```

Das war’s! Sie haben jetzt eine einfache Deno-Webanwendung, die „Hello World!“ anzeigt.

Weiterleitung von Anfragen in einer Deno-Anwendung

Aktualisieren wir den oben gezeigten funktionierenden Code so, dass er einen Query-Parameter von der Hauptindexroute / zur Route /user unterstützt, die die Details des Benutzers anzeigt.

Fügen Sie zunächst die zweite Route /user hinzu. Um keine umfangreichen Abhängigkeiten oder Web-Frameworks einzuführen, verwenden wir eine einfache bedingte Prüfung des angefragten Pfads.

Aktualisieren Sie den Code für httpHandler wie folgt:

```typescript
const httpHandler = async (request: Request): Promise<Response> => {
    let bodyContent = 'Hello World';

    const requestURL = new URL(request.url);
    if (requestURL.pathname === "/user") {
        bodyContent = `
        <h1> User: admin </h1>
        <ul>
          <li> Name: Roberto </li>
          <li> Email: roberto@example.com </li>
        </ul>
        `
        return new Response(bodyContent, {
            status: 200,
            headers: {
                "content-type": "text/html"
            }
        })
    } else {
        return new Response(bodyContent, {
            status: 200,
            headers: {
                "content-type": "text/html"
            }
        })
    }
};
```

Jetzt können wir eine Redirect-Funktion implementieren. Wenn Anfragen an /?redirect=/user gesendet werden, analysiert unsere Webanwendung den Query-Parameter redirect und leitet die Anfrage an die Seite mit den Benutzerdetails weiter.

Erweitern wir am Anfang unserer Funktion httpHandler die Variable requestURL um eine bedingte Prüfung des Redirect-Query-Parameters. Je nach Ergebnis antworten wir mit einer HTTP-Antwort, die einen Location-Redirect-Header enthält:

```js
    const requestURL = new URL(request.url);
    const redirectTo = requestURL.searchParams.get('redirect');
    if (redirectTo) {
        return new Response(null, {
            status: 302,
            headers: {
                'location': redirectTo
            }
        })
    }
```

Um zu testen, ob unsere Redirect-Funktion wie erwartet funktioniert, leiten Sie von der Hauptindexseite zur Seite mit den Benutzerdetails weiter, indem Sie die Seite /?redirect=/user aufrufen. So funktioniert es mit curl:

```bash
@lirantal ➜ /workspaces/deno-open-redirect-vulnerability-blog-post (main) $ curl "http://localhost:8080/?redirect=/user" -vv
v
*   Trying ::1:8080...
* connect to ::1 port 8080 failed: Connection refused
*   Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080 (#0)
> GET /?redirect=/user HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.74.0
> Accept: */*
> 
* Mark bundle as not supporting multiuse
< HTTP/1.1 302 Found
< location: /user
< vary: Accept-Encoding
< content-length: 0
< date: Mon, 06 Nov 2023 14:19:36 GMT
< 
* Connection #0 to host localhost left intact
```

Bereit für den Produktivbetrieb?

Vielleicht sollten Sie sich das genauer ansehen …

Open-Redirect-Sicherheitsschwachstelle in einer Deno-Anwendung

Eine Open-Redirect-Schwachstelle, auch als nicht validierte Weiterleitungen und Weiterleitungen bekannt, ist ein erhebliches Sicherheitsproblem, das häufig in Webanwendungen auftritt. Sie kann schwerwiegende Cybersicherheitsprobleme wie Phishing-Angriffe, den Diebstahl von Zugangsdaten und die Verbreitung schädlicher Inhalte verursachen.

Ich empfehle Ihnen dringend, die Snyk Learn-Lektion zu Open Redirect aufzurufen, um mehr über sichere Programmierpraktiken in JavaScript und anderen Programmiersprachen wie Java, Python usw. zu erfahren.

Was ist eine Open-Redirect-Schwachstelle?

Eine Open-Redirect-Schwachstelle tritt auf, wenn eine Anwendung einen Parameter entgegennimmt und einen Benutzer ohne vorherige Validierung an dessen Wert weiterleitet. Angreifer können diese Schwachstelle ausnutzen, um Opfer von der ursprünglichen Website auf eine schädliche Website ihrer Wahl umzuleiten. Hier ein einfaches Beispiel dafür, wie ein Open Redirect in einer Node.js-Anwendung aussehen kann:

```javascript
app.get('/dashboard, function(req, res){
    var redirect = req.query.redirect;
    res.redirect(redirect);
});
```

In einem Deno-Projekt sieht es ähnlich aus:

```javascript
const httpHandler = async (request: Request): Promise<Response> => {
    const requestURL = new URL(request.url);
    const redirectTo = requestURL.searchParams.get('redirect');
    if (redirectTo) {
        return new Response(null, {
            status: 302,
            headers: {
                'location': redirectTo
            }
        })
    }
});

serve(httpHandler);
```

Im obigen Code leitet die Anwendung den Benutzer zu der URL im Query-Parameter redirect weiter. Ein Angreifer könnte dies ausnutzen, indem er eine schädliche URL als Ziel angibt und den Benutzer so an einen unbeabsichtigten Ort weiterleitet.

Ein vollständiges, funktionsfähiges Beispiel des Deno-Anwendungscodes, den wir erstellt haben, finden Sie hier: https://github.com/snyk-snippets/deno-open-redirect-vulnerability-blog-post

Ausnutzung einer Open-Redirect-Schwachstelle

In unserer einfachen Deno-Webanwendung kann ein böswilliger Benutzer die Redirect-Funktion ausnutzen, indem er einen Link wie diesen erstellt:

```
https://example.com/?dummyParameter1=value1&dummyParameter2=value2&redirect=https://attacker.com/
```

Die Verwendung eines Dummy-Query-Parameters wie dummyParameter1 hat keine Auswirkungen auf den eigentlichen Deno-Anwendungscode, erzeugt aber eine längere URL. Dadurch erkennen Benutzer den Redirect-Parameter und seinen Wert, die Warnsignale darstellen, schwerer.

Darüber hinaus können böswillige Benutzer ihre Absichten mithilfe von URL-Kürzungsdiensten verschleiern. Arglose Benutzer würden die URL wahrscheinlich nicht entpacken, um herauszufinden, zu welcher URL sie weitergeleitet werden.

So erkennt Snyk eine Open-Redirect-Schwachstelle in Ihrer Deno-Web-App

Snyk ist ein leistungsstarkes, entwicklerorientiertes Sicherheitstool, das dabei helfen kann, Schwachstellen in Ihrer Codebasis und Ihren Open-Source-Abhängigkeiten zu erkennen und zu beheben. Es eignet sich besonders gut, um Sicherheitslücken wie Open-Redirect-Schwachstellen aufzuspüren.

Snyk unterstützt derzeit TypeScript- und Node.js-Projekte, jedoch nicht speziell Deno. Wenn Sie Apps mit JavaScript entwickeln, sollten Sie sowohl Ihre Datei package.json auf anfällige Open-Source-Abhängigkeiten als auch Ihren eigenen JavaScript-Code auf Sicherheitslücken untersuchen, die durch den Code entstehen können – wie diese Open-Redirect-Schwachstelle.

Um eine Open-Redirect-Schwachstelle in einer JavaScript-Anwendung mit Snyk zu erkennen, müssen Sie Snyk in Ihre Entwicklungs- und Deployment-Pipeline integrieren. Installieren Sie dazu die Snyk CLI und führen Sie den Snyk-Test für Ihre JavaScript-, TypeScript- oder Node.js-Anwendung aus. So geht’s:

1. Installieren Sie die Snyk CLI global:

```bash
npm install -g snyk
```

2. Führen Sie den Snyk-Test in Ihrem Anwendungsverzeichnis aus:

```bash
snyk code test
```

Snyk scannt anschließend Ihren Anwendungscode und meldet alle gefundenen Schwachstellen, darunter auch Open-Redirect-Schwachstellen. Außerdem erhalten Sie detaillierte Informationen zur Behebung der Schwachstellen. Damit ist Snyk ein unverzichtbares Tool, um die Sicherheit Ihrer Anwendung zu gewährleisten.

Tatsächlich kann Snyk unsichere Code-Schwachstellen direkt in der IDE finden, während Sie den Code schreiben. Im folgenden Node.js-Webanwendungscode, der mit der Express-Bibliothek und einer Controller-Middleware geschrieben wurde, um den Benutzer nach der Anmeldung des Administrators weiterzuleiten, sehen wir, dass Snyk mehrere Sicherheitslücken findet. Eine davon ist eine Open-Redirect-Schwachstelle.

Im rechten Bereich sehen Sie die Informationen von Snyk zur Open-Redirect-Schwachstelle:

1. Es wird erläutert, wie nicht bereinigte Eingaben zwischen verschiedenen Dateien und Codepfaden fließen. Zudem wird die konkrete anfällige Codezeile angegeben.

2. Es wird ein Link mit Informationen zu dieser Open-Redirect-Schwachstelle bereitgestellt (hier finden Sie die Snyk-Lektion!)

3. Es werden mehrere Codebeispiele dazu gezeigt, wie diese Open-Redirect-Schwachstelle in anderen Open-Source-Projekten behoben wurde, einschließlich der entsprechenden Code-Diffs.

Denken Sie daran: Vorbeugen ist immer besser als Heilen, insbesondere im Bereich Cybersicherheit. Wenn Sie die Open-Redirect-Schwachstelle verstehen und Tools wie Snyk verwenden, können Sie dafür sorgen, dass Ihre Webanwendungen sicher und vertrauenswürdig bleiben.

Deno-Dev-Container konfigurieren

In diesem Abschnitt sehen wir uns die Konfiguration des Deno-Entwicklungscontainers in GitHub Codespaces an. Dazu ändern wir bestimmte Konfigurationen wie postCreateCommand und forwardedPorts in der Datei devcontainer.json. Während des gesamten Abschnitts zeigen wir praktische Beispiele und geben Ihnen Empfehlungen, damit Sie eine funktionierende Deno-Webanwendung in Ihrer Entwicklungsumgebung einrichten können.

Die postCreateCommand-Konfiguration eines Dev-Containers verwenden

Bei postCreateCommand in der Datei devcontainer.json handelt es sich um einen oder mehrere Befehle, die ausgeführt werden, nachdem der Entwicklungscontainer erstellt und gestartet wurde. Diese Konfiguration ist wichtig, da Sie damit Aufgaben automatisieren können, die Sie normalerweise bei jedem Start des Containers manuell erledigen.

So können Sie mit postCreateCommand beispielsweise Projektabhängigkeiten installieren, Ihr Projekt erstellen oder Ihren Anwendungsserver starten.

Bei einem Deno-Projekt können Sie mit postCreateCommand die Webanwendung automatisch im Entwicklungscontainer starten. Ihre postCreateCommand-Konfiguration könnte beispielsweise so aussehen:

```json
{
  "postCreateCommand": "deno run --allow-net server.ts"
}
```

Konfiguration weitergeleiteter Ports in Deno

Da es sich nicht nur um ein Deno-Kommandozeilenprogramm, sondern um eine echte Webanwendung handelt, müssen wir die Ports freigeben, über die der Dev-Container Anfragen entgegennimmt und auf die die Hostumgebung zugreifen können soll. Hier kommt die Konfiguration für weitergeleitete Ports eines Dev-Containers ins Spiel.

Die Konfiguration forwardedPorts in der Datei devcontainer.json legt fest, welche Ports im Container für den Hostcomputer freigegeben werden sollen.

Die in diesem Artikel beschriebene Deno-Webanwendung lauscht beispielsweise auf Port 8080. Daher müssen wir diesen Port mithilfe der Konfiguration forwardedPorts an den Hostcomputer weiterleiten.

Um die Weiterleitung eines Ports für Ihre Deno-Web-App einzurichten, ergänzen Sie die Konfiguration forwardedPorts in der Datei devcontainer.json. Hier ein Beispiel:

```json
{
  "forwardedPorts": [8080]
}
```

Ihre Deno-Webanwendung läuft jetzt auf Port 8080 im Container und ist auf Ihrem Hostcomputer unter http://localhost:8080 erreichbar. Wenn Sie die Anwendung in einer Remote-Cloud-Umgebung wie GitHub Codespaces ausführen, müssen Sie über die URL des Codespace selbst darauf zugreifen, zum Beispiel https://orange-invention-pe8918638bd1nf81-8080.app.github.dev/

Wie geht es weiter?

Wir haben Deno und Dev-Container kennengelernt und vor allem erfahren, wie Sie beim Entwickeln eines Features das Entstehen einer Sicherheitslücke vermeiden. Puh, das war eine Menge!

Den vollständigen, funktionsfähigen Code aus diesem Artikel finden Sie im Snyk-Snippets-Code-Repository auf GitHub: https://github.com/snyk-snippets/deno-open-redirect-vulnerability-blog-post