Skip to main content
Les vulnérabilités cryptographiques exposent les données en transit, permettent l’interception du trafic ou permettent aux attaquants de falsifier des jetons d’authentification. La plupart de ces problèmes proviennent d’en-têtes de sécurité manquants, de l’utilisation d’algorithmes dépréciés ou de secrets inclus par inadvertance dans le code côté client.

crypto-mechanism-bypass

Critique

Description

La protection cryptographique est annulée parce que des secrets, des clés ou de la logique d’authentification sont exposés dans le JavaScript ou HTML côté client. Un attaquant qui lit le code source de la page peut contourner entièrement la protection.

Importance

Tout secret placé dans le code côté client est effectivement public. Les clés API, les clés de chiffrement, les mots de passe codés en dur ou les comparaisons de mots de passe côté client n’offrent aucune sécurité — ils sont visibles pour chaque utilisateur qui ouvre les DevTools.

Comment QAOS le détecte

L’agent analyse tout le JavaScript chargé par la page pour détecter des motifs indiquant des secrets exposés :
  • Clés API codées en dur (sk_live_, api_key =, apiKey:, secret =)
  • Comparaisons de mots de passe côté client (if (password === 'admin123'))
  • Clés de chiffrement stockées comme constantes JS
  • Éléments <input> cachés avec des attributs name="secret" ou data-api-key
  • Hachages de mots de passe attendus dans le JavaScript pour comparaison locale

Exemples

// Clé API codée en dur
const stripe = require('stripe')('sk_live_ABC123...')

// Vérification de mot de passe côté client
if (password === 'SuperSecretPassword2024') { allowAccess() }

// Clé de chiffrement dans le source
const encryptionKey = 'my-secret-key-12345'

Comment corriger

Ne placez jamais de secrets dans le code côté client. Toutes les opérations d’authentification et cryptographiques doivent se faire côté serveur. Utilisez des variables d’environnement chargées uniquement côté serveur. Pour les clés API qui doivent être côté client (ex. : clés publiables Stripe), utilisez des clés restreintes et à portée limitée qui ne peuvent pas effectuer d’opérations sensibles.

unencrypted-page-serving

Critique

Description

La page web elle-même est servie via HTTP simple au lieu de HTTPS, ce qui signifie que tout le trafic entre le navigateur de l’utilisateur et le serveur est transmis en clair.

Importance

Le trafic HTTP peut être intercepté, lu et modifié par quiconque sur le chemin réseau — y compris les FAI, les opérateurs de Wi-Fi public et les proxies réseau d’entreprise. Tous les identifiants, cookies de session et données sensibles soumis via HTTP sont exposés.

Comment QAOS le détecte

L’agent vérifie si l’URL de la page actuelle commence par http:// au lieu de https://.

Comment corriger

  1. Obtenez un certificat TLS (gratuit via Let’s Encrypt)
  2. Configurez votre serveur pour servir tout le contenu via HTTPS
  3. Redirigez tout le trafic HTTP vers HTTPS :
server {
  listen 80;
  return 301 https://$host$request_uri;
}
  1. Ajoutez HSTS pour empêcher les futures connexions HTTP (voir misconfigured-security-headers)

weak-crypto-key-generation

Élevé

Description

Le JavaScript côté client utilise Math.random() ou d’autres fonctions non cryptographiques pour générer des jetons de session, des clés ou des identifiants sensibles à la sécurité. Alternativement, des algorithmes dépréciés comme DES, RC4 ou MD5 sont utilisés à des fins cryptographiques.

Importance

Math.random() n’est pas cryptographiquement sécurisé — sa sortie peut être prédite à partir d’un petit nombre de valeurs observées. Les jetons générés avec lui peuvent être forcés par force brute en quelques secondes. Les algorithmes dépréciés ont des vulnérabilités connues qui peuvent être exploitées avec des ressources informatiques modestes.

Comment QAOS le détecte

L’agent analyse le code source JavaScript pour :
  • Math.random() utilisé pour générer des jetons ou des clés
  • CryptoJS.MD5() ou CryptoJS.SHA1() pour la dérivation de clés
  • Génération de clé RSA avec un module < 2048 bits
  • Utilisation de DES, RC4 ou d’autres noms de chiffrements dépréciés

Exemples

// Vulnérable : Math.random() pour la génération de jeton
const sessionToken = Math.random().toString(36).substr(2)

// Vulnérable : MD5 à des fins cryptographiques
const key = CryptoJS.MD5(password).toString()

// Vulnérable : clé RSA courte
const { privateKey } = crypto.generateKeyPairSync('rsa', { modulusLength: 512 })

Comment corriger

// Utiliser l'API Web Crypto pour la génération aléatoire sécurisée
const array = new Uint8Array(32)
crypto.getRandomValues(array)
const token = Array.from(array).map(b => b.toString(16).padStart(2, '0')).join('')

// Node.js
const crypto = require('crypto')
const token = crypto.randomBytes(32).toString('hex')

// RSA : utiliser 2048 bits minimum (4096 recommandé)
const { privateKey } = crypto.generateKeyPairSync('rsa', { modulusLength: 4096 })

unencrypted-sensitive-communication

Élevé

Description

Des formulaires ou des appels JavaScript fetch/XHR soumettent des données sensibles (mots de passe, numéros de carte de crédit, informations personnelles) vers des endpoints http:// au lieu de https://.

Importance

Même si la page elle-même est servie via HTTPS, si les soumissions de formulaires ou les appels API vont vers des endpoints HTTP, les données sensibles sont transmises en clair. C’est particulièrement dangereux pour les formulaires de connexion et les flux de paiement.

Comment QAOS le détecte

L’agent analyse le code source JavaScript et les attributs action des formulaires pour détecter les URLs http:// qui reçoivent des données sensibles (formulaires contenant des champs de mot de passe, des saisies de carte de crédit ou des champs de données personnelles).

Exemples

<!-- Formulaire soumettant des identifiants via HTTP -->
<form action="http://api.example.com/login" method="POST">
  <input type="password" name="password">
</form>
// Fetch envoyant des données via HTTP
fetch('http://api.example.com/login', {
  method: 'POST',
  body: JSON.stringify({ password: userPassword })
})

Comment corriger

Assurez-vous que tous les attributs action des formulaires et les URLs des appels API utilisent https://. Configurez votre serveur pour rejeter les requêtes HTTP sur les endpoints sensibles.

misconfigured-security-headers

Élevé

Description

Les en-têtes de réponse HTTP qui protègent contre les attaques courantes côté navigateur sont manquants ou mal configurés. Cela inclut HSTS, Content-Security-Policy, X-Frame-Options et X-Content-Type-Options.

Importance

Les en-têtes de sécurité sont la dernière ligne de défense du navigateur. Des en-têtes manquants laissent les utilisateurs vulnérables aux attaques de rétrogradation, au clickjacking, au sniffing de type MIME et à l’escalade XSS — même si le code de l’application lui-même est sécurisé.

Comment QAOS le détecte

L’agent vérifie les en-têtes de réponse HTTP pour la présence et l’exactitude des en-têtes de sécurité clés.

En-têtes fréquemment manquants

En-têteRisque si manquant
Strict-Transport-SecurityAttaques de rétrogradation HTTP
Content-Security-PolicyEscalade XSS
X-Frame-OptionsClickjacking
X-Content-Type-OptionsSniffing MIME
Referrer-PolicyFuite d’URL

Comment corriger

Ajoutez ces en-têtes aux réponses de votre serveur :
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Security-Policy: default-src 'self'; script-src 'self'
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Referrer-Policy: strict-origin-when-cross-origin
La plupart des frameworks supportent un middleware pour cela :
// Express.js avec Helmet
const helmet = require('helmet')
app.use(helmet())

weak-hashing-no-salt

Élevé

Description

Les mots de passe ou d’autres valeurs sensibles sont hachés en utilisant des algorithmes faibles (MD5, SHA-1) ou sans un sel aléatoire unique, les rendant vulnérables aux attaques par table arc-en-ciel et aux attaques par dictionnaire.

Importance

Les hachages MD5 ou SHA-1 non salés des mots de passe courants existent dans des tables de correspondance précalculées. Un attaquant qui obtient votre base de données de mots de passe peut instantanément inverser des millions de mots de passe.

Comment QAOS le détecte

L’agent analyse le code source JavaScript pour détecter les appels de hachage utilisant des algorithmes faibles : CryptoJS.MD5(password), CryptoJS.SHA1(data), SHA-256 en une seule passe sans itérations, ou hachage sans sel aléatoire.

Comment corriger

Utilisez une fonction de dérivation de clé (KDF) appropriée conçue pour le hachage de mots de passe :
# Python : bcrypt
import bcrypt
hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))

# Python : Argon2
from argon2 import PasswordHasher
ph = PasswordHasher()
hashed = ph.hash(password)
// Node.js : bcrypt
const bcrypt = require('bcrypt')
const hashed = await bcrypt.hash(password, 12)
N’utilisez jamais MD5, SHA-1 ou SHA-256 brut pour le stockage de mots de passe.

misconfigured-cors

Élevé

Description

Le serveur retourne Access-Control-Allow-Origin: * (ou reflète n’importe quelle origine) sur des endpoints qui retournent des données sensibles, permettant à n’importe quel site web d’effectuer des requêtes cross-origin authentifiées et de lire la réponse.

Importance

Une politique CORS avec caractère générique combinée à Access-Control-Allow-Credentials: true permet à n’importe quel site web malveillant d’effectuer des requêtes vers votre API au nom de vos utilisateurs connectés et de lire la réponse. Cela contourne effectivement la Same-Origin Policy.

Comment QAOS le détecte

L’agent vérifie les en-têtes de réponse HTTP pour Access-Control-Allow-Origin: * ou des valeurs d’origine reflétées sur les endpoints API sensibles.

Exemples

# Vulnérable : CORS avec caractère générique sur une API authentifiée
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true

Comment corriger

Maintenez une liste d’autorisation explicite d’origines de confiance et validez par rapport à elle :
# Middleware CORS FastAPI
from fastapi.middleware.cors import CORSMiddleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://app.example.com"],  # liste explicite, jamais "*"
    allow_credentials=True,
    allow_methods=["GET", "POST"],
)