Configuration du contournement d'authentification

Open in QuickMonitoring→ Sites → [Votre site] → Paramètres → Configuration du contournement

Le contournement d'authentification vous permet de fournir des identifiants ou un jeton de session pour que le crawler et l'agent puissent tester les pages authentifiées — sans que ces identifiants n'apparaissent dans les résultats d'analyse.

Pourquoi c'est nécessaire

Les crawlers et agents de test opèrent comme des utilisateurs anonymes par défaut. Si votre site possède des pages accessibles uniquement après connexion (tableau de bord client, espace membre, section administration), ces pages sont invisibles pour le scanner — il ne peut ni les crawler, ni y détecter des erreurs, ni les tester.

La configuration du contournement résout ce problème en injectant un cookie d'authentification valide dans le navigateur du crawler avant qu'il ne commence à analyser votre site. Votre site voit alors le crawler comme un utilisateur connecté, lui accordant l'accès aux pages protégées.

Le mécanisme utilisé est basé sur un jeton HMAC : votre application génère un jeton signé à partir d'une clé secrète partagée, QuickMonitoring injecte ce jeton sous forme de cookie, et votre middleware d'authentification reconnaît le jeton sans nécessiter de paire email/mot de passe.

Ce que vous verrez

La page Configuration du contournement dans les paramètres de votre site contient :

• Une section Clé secrète partagée : une clé que vous générez et copiez dans votre application
• Une section Configuration du middleware : le code à ajouter à votre application pour reconnaître le jeton de contournement
• Un champ Identifiant utilisateur de test : l'ID ou l'email du compte utilisateur à simuler lors des tests
• Un bouton Tester la configuration : pour vérifier que le contournement fonctionne avant de lancer un scan
• L'état du contournement : actif (vert) ou non configuré (gris)

Comment configurer le contournement

Étape 1 — Générer la clé secrète partagée

Dans la section Configuration du contournement, cliquez sur Générer une clé secrète. QuickMonitoring génère une chaîne aléatoire de 64 caractères. Copiez cette clé — vous en aurez besoin dans votre application.

Notez que cette clé est stockée de manière chiffrée et n'apparaît jamais dans les résultats d'analyse ou les logs publics.

Étape 2 — Ajouter le middleware dans votre application

Ajoutez le code suivant dans le middleware d'authentification de votre application. Ce middleware doit s'exécuter avant vos vérifications d'authentification habituelles.

Exemple pour Next.js (middleware.ts) :

import { NextRequest, NextResponse } from 'next/server'
import { createHmac } from 'crypto'

const BYPASS_SECRET = process.env.QUICKMONITORING_BYPASS_SECRET!

export function middleware(request: NextRequest) {
  const bypassToken = request.cookies.get('qm_bypass')?.value

  if (bypassToken) {
    // Vérifier la signature HMAC
    const [userId, timestamp, signature] = bypassToken.split('.')
    const expectedSignature = createHmac('sha256', BYPASS_SECRET)
      .update(`${userId}.${timestamp}`)
      .digest('hex')

    const tokenAge = Date.now() - parseInt(timestamp)
    const TOKEN_MAX_AGE = 3600 * 1000 // 1 heure

    if (signature === expectedSignature && tokenAge < TOKEN_MAX_AGE) {
      // Jeton valide : injecter l'identité utilisateur dans les en-têtes
      const response = NextResponse.next()
      response.headers.set('x-bypass-user-id', userId)
      return response
    }
  }

  // Poursuivre avec l'authentification normale
  return NextResponse.next()
}

Exemple pour Django (middleware Python) :

import hmac
import hashlib
import time

BYPASS_SECRET = settings.QUICKMONITORING_BYPASS_SECRET

class QuickMonitoringBypassMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        bypass_token = request.COOKIES.get('qm_bypass')

        if bypass_token:
            try:
                user_id, timestamp, signature = bypass_token.split('.')
                payload = f"{user_id}.{timestamp}"
                expected_sig = hmac.new(
                    BYPASS_SECRET.encode(),
                    payload.encode(),
                    hashlib.sha256
                ).hexdigest()

                token_age = time.time() - int(timestamp) / 1000
                if hmac.compare_digest(signature, expected_sig) and token_age < 3600:
                    # Authentifier l'utilisateur de test
                    from django.contrib.auth.models import User
                    request.user = User.objects.get(id=user_id)
            except (ValueError, User.DoesNotExist):
                pass

        return self.get_response(request)

Exemple pour Laravel (middleware PHP) :

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class QuickMonitoringBypass
{
    public function handle(Request $request, Closure $next)
    {
        $bypassToken = $request->cookie('qm_bypass');

        if ($bypassToken) {
            [$userId, $timestamp, $signature] = explode('.', $bypassToken);
            $payload = "{$userId}.{$timestamp}";
            $expectedSig = hash_hmac('sha256', $payload, config('services.quickmonitoring.bypass_secret'));
            $tokenAge = (time() * 1000) - (int)$timestamp;

            if (hash_equals($expectedSig, $signature) && $tokenAge < 3600000) {
                $user = \App\Models\User::find($userId);
                if ($user) {
                    auth()->login($user);
                }
            }
        }

        return $next($request);
    }
}

Étape 3 — Configurer la variable d'environnement

Ajoutez la clé secrète générée à l'étape 1 dans les variables d'environnement de votre application :

QUICKMONITORING_BYPASS_SECRET=votre_clé_secrète_générée_ici

Ne committez jamais cette clé dans votre dépôt de code. Utilisez votre système de gestion des secrets (Vault, AWS Secrets Manager, variables d'environnement du serveur, etc.).

Étape 4 — Configurer l'identifiant utilisateur de test

Dans l'interface QuickMonitoring, renseignez l'Identifiant utilisateur de test — il s'agit de l'ID (ou l'email) du compte utilisateur que le crawler doit simuler. Choisissez un compte avec les permissions suffisantes pour accéder aux pages que vous souhaitez tester, sans droits d'administration inutiles.

Étape 5 — Tester la configuration

Cliquez sur Tester la configuration. QuickMonitoring envoie une requête de test à votre site avec le cookie de contournement injecté et vérifie qu'une page protégée est accessible. Si le test réussit, le statut passe à Actif.

Étape 6 — Lancer un scan avec le contournement activé

Une fois le contournement configuré et actif, tous les scans suivants de ce site utiliseront automatiquement le cookie de contournement. Les pages protégées seront crawlées et leurs erreurs détectées comme les pages publiques.

Sécurité du mécanisme

Le jeton de contournement est sécurisé par plusieurs mécanismes :

• Signature HMAC-SHA256 : le jeton est signé avec votre clé secrète, il ne peut pas être forgé
• Horodatage : chaque jeton expire après 1 heure, limitant la fenêtre d'utilisation potentiellement abusive
• Clé rotative : vous pouvez régénérer la clé secrète à tout moment depuis l'interface, invalidant immédiatement les jetons en circulation
• Scope limité : le middleware ne fait que connecter l'utilisateur de test — il n'accorde aucune permission supplémentaire

Condition de réussite

Vous obtenez ce succès lorsque : vous avez configuré le contournement d'authentification, le test de configuration a réussi (statut Actif), et un scan du site a été exécuté en accédant à au moins une page protégée.

Problèmes courants

Le test de configuration échoue avec "Page protégée inaccessible" Vérifiez que le middleware est correctement enregistré et s'exécute avant vos vérifications d'authentification habituelles. Dans Next.js, assurez-vous que le middleware est dans le fichier middleware.ts à la racine du projet et que le matcher inclut les routes protégées.

Le cookie de contournement est ignoré Certains frameworks effacent ou écrasent les cookies lors de l'initialisation de la session. Vérifiez que le middleware de contournement s'exécute bien en premier dans la chaîne de middleware, avant les middlewares de session et d'authentification.

La clé secrète a été exposée accidentellement Régénérez immédiatement la clé depuis l'interface QuickMonitoring (bouton Régénérer la clé) et mettez à jour la variable d'environnement dans votre application. L'ancienne clé est invalidée dès que vous enregistrez la nouvelle.

Je veux tester différents rôles d'utilisateur Créez plusieurs comptes de test avec des rôles différents. La configuration du contournement ne supporte qu'un seul identifiant utilisateur à la fois — pour tester un autre rôle, modifiez temporairement l'identifiant dans les paramètres, lancez le scan, puis rétablissez l'identifiant précédent.