Oups, j’ai créé une fonctionnalité et introduit une vulnérabilité de redirection ouverte dans une application Deno

Nous allons procéder étape par étape pour configurer une application web Deno simple affichant « Hello World », avec un environnement d’exécution de plus en plus populaire pour JavaScript et TypeScript. Plus précisément.

Nous allons créer une application web Deno prenant en charge un paramètre de requête de redirection et découvrir comment les développeurs peuvent involontairement créer des failles de sécurité lorsqu’ils suivent une feuille de route et développent des fonctionnalités.

Premiers pas avec un tutoriel de code Deno « Hello World »

Avant de commencer, assurez-vous d’avoir accès à un environnement de développement web Deno disposant des outils nécessaires pour exécuter des projets Deno et interagir avec l’application web.

Suivez ces étapes pour créer votre application Deno « Hello World » :

1. Installez Deno dans votre environnement de développement. Si ce n’est pas déjà fait, consultez les instructions d’installation sur le [site officiel de Deno](https://deno.land/#installation).

2. Créez un projet Deno. Pour cela, créez un nouveau répertoire et initialisez-le avec un fichier deps.ts. Ce fichier contiendra nos dépendances, même si nous n’en aurons aucune puisqu’il s’agit d’une application simple.

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

3. Créez un nouveau fichier server.ts. Il contiendra la logique de notre serveur. Dans ce fichier, nous importerons la fonction serve du module std/http, configurerons un serveur et écouterons les requêtes entrantes.

4. Ajoutez la logique du serveur. Dans le fichier server.ts, ajoutez le code suivant :

    ```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. Lancez le serveur. Enregistrez le fichier server.ts, puis démarrez votre serveur en exécutant la commande suivante dans votre terminal :

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

Et voilà ! Vous disposez maintenant d’une application web Deno simple qui affiche « Hello World! »

Redirection des requêtes dans une application Deno

Modifions le code fonctionnel ci-dessus pour prendre en charge un paramètre de requête permettant de passer de la route d’index principale / à une route /user qui affiche les informations de l’utilisateur.

Commençons par ajouter une deuxième route /user. Pour éviter d’introduire des dépendances importantes ou des frameworks web, nous utiliserons une simple vérification conditionnelle du chemin demandé.

Mettez à jour le code httpHandler comme suit :

```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"
            }
        })
    }
};
```

Nous sommes maintenant prêts à implémenter une fonctionnalité de redirection. Ainsi, lorsque des requêtes vers /?redirect=/user sont envoyées, notre application web analyse le paramètre de requête redirect et redirige la requête vers la page qui gère les informations de l’utilisateur.

Au début de notre fonction httpHandler, développons la variable requestURL afin qu’elle vérifie également la présence du paramètre de requête de redirection et agisse en conséquence en renvoyant une réponse HTTP contenant un en-tête de redirection Location :

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

Pour vérifier que notre fonctionnalité de redirection fonctionne comme prévu, accédez à la page d’informations de l’utilisateur depuis la page d’index principale en demandant la page suivante : /?redirect=/user. Voici le résultat avec 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
```

Prêt à déployer en production ?

Vous devriez peut-être y regarder de plus près…

Vulnérabilité de redirection ouverte dans une application Deno

Une vulnérabilité de redirection ouverte, également appelée redirection et transfert non validés, est une faille de sécurité importante que l’on rencontre fréquemment dans les applications web. Elle peut entraîner de graves problèmes de cybersécurité, comme des attaques de phishing, le vol d’identifiants et la diffusion de contenu malveillant.

Je vous recommande vivement de consulter la leçon Snyk Learn sur les redirections ouvertes pour en savoir plus et découvrir les bonnes pratiques de codage sécurisé en JavaScript et dans d’autres langages tels que Java ou Python.

Qu’est-ce qu’une vulnérabilité de redirection ouverte ?

Une vulnérabilité de redirection ouverte se produit lorsqu’une application récupère un paramètre et redirige un utilisateur vers la valeur de ce paramètre sans la valider. Un cybercriminel peut alors rediriger les victimes du site d’origine vers un site malveillant de son choix. Voici un exemple simple de redirection ouverte dans une application Node.js :

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

Dans un projet Deno, le code est similaire :

```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);
```

Dans le code ci-dessus, l’application redirige l’utilisateur vers l’URL indiquée dans le paramètre de requête redirect. Un attaquant pourrait exploiter ce comportement en fournissant une URL malveillante comme cible, afin de rediriger l’utilisateur vers une destination inattendue.

Vous trouverez ici un exemple complet et fonctionnel du code de l’application Deno que nous avons créé : https://github.com/snyk-snippets/deno-open-redirect-vulnerability-blog-post

Exploitation d’une vulnérabilité de redirection ouverte

Dans notre application web Deno simple, un utilisateur malveillant peut exploiter la fonctionnalité de redirection en créant un lien tel que :

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

L’utilisation d’un paramètre de requête fictif comme dummyParameter1 n’a pas d’incidence sur le code de l’application Deno, mais elle allonge l’URL. Les utilisateurs risquent donc moins de repérer le paramètre de redirection et sa valeur, qui devraient les alerter.

De plus, les utilisateurs malveillants peuvent dissimuler leurs intentions à l’aide de services de raccourcissement d’URL. Les utilisateurs peu méfiants ne dérouleront probablement pas l’URL pour découvrir vers quelle adresse elle redirige.

Comment Snyk détecte les vulnérabilités de redirection ouverte dans votre application web Deno

Snyk est un puissant outil de sécurité conçu pour les développeurs, qui peut vous aider à détecter et à corriger les vulnérabilités dans votre base de code et vos dépendances open source. Il est particulièrement utile pour détecter les failles de sécurité telles que les vulnérabilités de redirection ouverte.

Actuellement, Snyk prend en charge les projets TypeScript et Node.js, mais pas Deno spécifiquement. Cela dit, si vous développez des applications en JavaScript, vous pouvez analyser à la fois votre fichier package.json pour repérer les dépendances open source vulnérables et votre propre code JavaScript, qui peut introduire des failles de sécurité comme cette vulnérabilité de redirection ouverte.

Pour détecter une vulnérabilité de redirection ouverte dans une application JavaScript avec Snyk, vous devez intégrer Snyk à votre pipeline de développement et de déploiement. Pour ce faire, installez Snyk CLI et exécutez la commande Snyk test sur votre application JavaScript, TypeScript ou Node.js. Voici comment procéder :

1. Installez Snyk CLI globalement :

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

2. Exécutez Snyk test dans le répertoire de votre application :

```bash
snyk code test
```

Snyk analysera ensuite le code de votre application et signalera les vulnérabilités détectées, y compris les vulnérabilités de redirection ouverte. L’outil fournit également des informations détaillées sur la façon de corriger ces vulnérabilités, ce qui en fait un outil essentiel pour maintenir la sécurité de votre application.

En fait, Snyk peut détecter les vulnérabilités liées à du code non sécurisé directement dans l’IDE, pendant que vous écrivez votre code. Dans le code de l’application web Node.js ci-dessous, écrit avec la bibliothèque Express et utilisant un middleware de contrôleur pour rediriger l’utilisateur après la connexion de l’administrateur, on constate que Snyk détecte de nombreuses vulnérabilités, dont un problème de sécurité lié à une redirection ouverte.

Dans le volet de droite, vous pouvez voir les informations fournies par Snyk sur la vulnérabilité de redirection ouverte :

1. Explication de la circulation des entrées non assainies entre différents fichiers et chemins de code, avec indication de la ligne de code précise qui est vulnérable.

2. Lien vers des informations sur cette vulnérabilité de redirection ouverte (consultez la leçon Snyk ici !)

3. Plusieurs exemples de code montrant comment cette vulnérabilité de redirection ouverte a été corrigée dans d’autres projets open source, ainsi qu’un diff du code.

N’oubliez pas : mieux vaut prévenir que guérir, surtout en matière de cybersécurité. En comprenant les vulnérabilités de redirection ouverte et en utilisant des outils comme Snyk, vous pouvez garantir la sécurité et la fiabilité de vos applications web.

Configuration du conteneur de développement Deno

Dans cette section, nous allons examiner la configuration du conteneur de développement Deno dans GitHub Codespaces. Nous modifierons des paramètres spécifiques tels que postCreateCommand et forwardedPorts dans le fichier devcontainer.json. Tout au long de cette section, nous vous proposerons des exemples pratiques et des suggestions pour vous aider à configurer une application web Deno fonctionnelle dans votre environnement de développement.

Utiliser une configuration postCreateCommand dans un Dev Container

Dans le fichier devcontainer.json, postCreateCommand correspond à une commande ou à une série de commandes exécutées après la création et le démarrage du conteneur de développement. Ce paramètre est important, car il vous permet d’automatiser les tâches que vous effectuez habituellement manuellement à chaque démarrage du conteneur.

Par exemple, vous pouvez utiliser postCreateCommand pour installer les dépendances du projet, compiler votre projet ou démarrer votre serveur d’application. 

Dans un projet Deno, vous pouvez utiliser postCreateCommand pour démarrer automatiquement l’application web dans le conteneur de développement. Voici à quoi pourrait ressembler votre configuration postCreateCommand :

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

Configuration des ports transférés dans Deno

Comme il ne s’agit pas simplement d’un programme Deno en ligne de commande, mais d’une véritable application web, nous devons exposer les ports sur lesquels le Dev Container reçoit les requêtes et auxquels l’environnement hôte doit pouvoir accéder. C’est là qu’intervient la configuration des ports transférés d’un Dev Container.

Le paramètre forwardedPorts du fichier devcontainer.json indique les ports du conteneur qui doivent être exposés à la machine hôte.

Par exemple, l’application web Deno présentée dans cet article écoute sur le port 8080. Nous devons donc transférer ce port vers la machine hôte à l’aide du paramètre forwardedPorts.

Pour configurer le transfert de ports de votre application web Deno, ajoutez le paramètre forwardedPorts à votre fichier devcontainer.json. Voici un exemple :

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

Votre application web Deno s’exécute maintenant sur le port 8080 du conteneur, et vous pouvez y accéder à l’adresse http://localhost:8080 depuis votre machine hôte. N’oubliez pas que si vous l’exécutez dans un environnement cloud distant tel que GitHub Codespaces, vous devrez y accéder via l’URL du Codespace, par exemple https://orange-invention-pe8918638bd1nf81-8080.app.github.dev/

Et maintenant ?

Nous avons découvert Deno, les Dev Containers et, surtout, comment éviter d’introduire une vulnérabilité de sécurité lors du développement d’une fonctionnalité. Ouf, ça faisait beaucoup !

Vous trouverez le code complet et fonctionnel de cet article dans le dépôt de code Snyk Snippets sur GitHub : https://github.com/snyk-snippets/deno-open-redirect-vulnerability-blog-post