124 · Le firewall

Le catalogue complet les 124 classes.

Chaque classe de gate que le firewall applique, par catégorie — avec, pour chacune, un exemple de détection réel. Toutes calibrées à 0 faux-positif sur 5 000+ repos.

Accès

Cross-tenant · access-control

✗ db.from('invoices').select('*')

Une requête sans filtre d'org — les lignes de chaque tenant fuient en prod.

RLS · SECURITY DEFINER

✗ create view billing as select * … security definer

Une vue definer qui contourne la sécurité au niveau ligne.

Mass-assignment

✗ User.create(req.body) // is_admin passes through

Le corps de requête lié direct au modèle — les champs de privilège passent.

CORS misconfiguration

✗ res.setHeader('Access-Control-Allow-Origin', req.headers.origin)

L'Origin de la requête reflété dans CORS — n'importe quel site lit les réponses authentifiées.

Firebase public-write rules

✗ { ".read": true, ".write": true }

Règles Firebase laissées en lecture et écriture publiques.

Injection

SQL injection

✗ db.query('select * from u where id = ' + req.params.id)

De l'entrée utilisateur concaténée dans une chaîne SQL.

NoSQL injection

✗ db.users.find({ $where: req.body.q })

Entrée utilisateur atteignant un opérateur NoSQL $where.

LDAP injection

✗ client.search('uid=' + req.query.u)

Entrée utilisateur concaténée dans un filtre LDAP.

XPath injection

✗ doc.select("//user[name='" + name + "']")

Entrée utilisateur concaténée dans une requête XPath.

Unrestricted upload

✗ app.post('/up', multer({ dest: './public' }))

Upload sans liste blanche de type/extension dans une racine web inscriptible.

Command / code

✗ exec('convert ' + req.query.file)

De l'entrée utilisateur qui atteint une commande shell.

Template (SSTI)

✗ res.send(ejs.render(req.query.tpl))

Entrée utilisateur rendue comme template — injection de template côté serveur.

Path traversal / LFI

✗ fs.readFile('./files/' + req.params.name)

Entrée utilisateur dans un chemin — ../ sort du dossier.

XSS

✗ el.innerHTML = req.query.q

Entrée utilisateur écrite dans innerHTML sans échappement.

SSRF

✗ fetch(req.query.url) // hits 169.254.169.254

Un fetch serveur vers une URL contrôlée par l'utilisateur — atteint l'endpoint métadonnées.

XXE

✗ libxml.parseXml(body, { noent: true })

Du XML parsé avec les entités externes activées.

Open redirect

✗ res.redirect(req.query.next)

Cible de redirection contrôlée par l'utilisateur — pivot de hameçonnage.

Prototype pollution

✗ merge(target, JSON.parse(req.body))

Fusion profonde de JSON utilisateur — __proto__ pollue Object.prototype.

ReDoS

✗ /^(a+)+$/.test(req.query.s)

Regex à retour arrière catastrophique exécutée sur l'entrée utilisateur.

CRLF / header injection

✗ res.setHeader('X-Id', req.query.id)

Entrée utilisateur dans un en-tête — CRLF scinde la réponse HTTP.

Log injection

✗ logger.info('login ' + req.body.user)

Entrée utilisateur non nettoyée dans les logs — lignes de log falsifiées.

PHP variable extraction

✗ extract($_GET);

extract() sur les données de requête — écrasement de variable arbitraire.

SpEL injection

✗ parser.parseExpression(input).getValue()

Entrée utilisateur évaluée comme expression Spring SpEL.

Obfuscated code execution

✗ eval(atob(req.body.p))

Entrée utilisateur décodée en base64 passée à eval.

Unsafe reflection

✗ Class.forName(req.getParameter("c")).newInstance()

Nom de classe contrôlé par l'utilisateur instancié par réflexion.

OGNL injection

✗ Ognl.getValue(req.getParameter("x"), root)

Entrée utilisateur évaluée comme expression OGNL (la classe RCE de Struts).

Script-engine injection

✗ new ScriptEngineManager().getEngineByName("js").eval(input)

Entrée utilisateur évaluée par un moteur de script.

JNDI injection

✗ ctx.lookup(req.getParameter("url"))

Lookup JNDI contrôlé par l'utilisateur (la classe Log4Shell).

EL injection

✗ factory.createValueExpression(ctx, input, Object.class)

Entrée utilisateur évaluée comme expression Jakarta EL.

XSLT injection

✗ transformer.transform(new StreamSource(userXsl), out)

Feuille XSLT fournie par l'utilisateur — RCE via fonction d'extension.

Node vm code injection

✗ vm.runInThisContext(req.body.code)

Entrée utilisateur exécutée dans un contexte vm de Node — pas un bac à sable.

Node require / import injection

✗ require(req.query.mod)

Chemin require() contrôlé par l'utilisateur — chargement de module arbitraire.

Python import injection

✗ __import__(request.args['m'])

__import__ contrôlé par l'utilisateur — chargement de module Python arbitraire.

LLM insecure code execution

✗ eval(await llm.complete(prompt)) // model output run as code

Code généré par un modèle exécuté sans sandbox.

Variantes par langage · Go · .NET 32

Go command injection

✗ exec.Command("sh", "-c", r.URL.Query().Get("c"))

Go : entrée utilisateur atteignant une commande shell.

.NET command injection

✗ Process.Start("cmd.exe", "/c " + Request["c"])

.NET : entrée utilisateur atteignant une commande shell.

Go SSRF

✗ http.Get(r.URL.Query().Get("url"))

Go : fetch serveur vers une URL contrôlée par l'utilisateur.

.NET SSRF

✗ new HttpClient().GetAsync(Request["url"])

.NET : fetch serveur vers une URL contrôlée par l'utilisateur.

Go SQL injection

✗ db.Query("select * from u where id=" + r.FormValue("id"))

Go : entrée utilisateur concaténée dans du SQL.

.NET SQL injection

✗ new SqlCommand("select * from u where id=" + Request["id"])

.NET : entrée utilisateur concaténée dans du SQL.

Go path traversal / LFI

✗ os.ReadFile("./files/" + r.URL.Query().Get("f"))

Go : entrée utilisateur dans un chemin — traversée.

.NET path traversal / LFI

✗ File.ReadAllText("files\\" + Request["f"])

.NET : entrée utilisateur dans un chemin — traversée.

Go open redirect

✗ http.Redirect(w, r, r.URL.Query().Get("next"), 302)

Go : cible de redirection contrôlée par l'utilisateur.

.NET open redirect

✗ Response.Redirect(Request["next"])

.NET : cible de redirection contrôlée par l'utilisateur.

Go XSS

✗ fmt.Fprintf(w, "<div>%s</div>", r.URL.Query().Get("q"))

Go : entrée utilisateur écrite dans du HTML sans échappement.

.NET XSS

✗ Response.Write("<div>" + Request["q"] + "</div>")

.NET : entrée utilisateur écrite dans du HTML sans échappement.

Go LDAP injection

✗ ldap.NewSearchRequest("(uid=" + r.FormValue("u") + ")")

Go : entrée utilisateur dans un filtre LDAP.

.NET LDAP injection

✗ new DirectorySearcher("(uid=" + Request["u"] + ")")

.NET : entrée utilisateur dans un filtre LDAP.

Go XPath injection

✗ xmlquery.Find(doc, "//user[name='"+r.FormValue("u")+"']")

Entrée utilisateur concaténée dans une requête XPath (Go).

.NET XPath injection

✗ nav.Select("//user[name='" + Request["u"] + "']")

Entrée utilisateur concaténée dans une requête XPath (.NET).

Go template (SSTI)

✗ t, _ := template.New("x").Parse(r.URL.Query().Get("tpl")); t.Execute(w, nil)

Entrée utilisateur interprétée comme template — SSTI (Go).

.NET template (SSTI)

✗ Engine.Razor.RunCompile(Request["tpl"], "k", null, null)

Entrée utilisateur rendue comme template — SSTI (.NET).

Go log injection

✗ log.Println("login " + r.FormValue("user"))

Entrée utilisateur non filtrée dans les logs — lignes falsifiées (Go).

.NET log injection

✗ _logger.LogInformation("login " + Request["user"])

Entrée utilisateur non filtrée dans les logs — lignes falsifiées (.NET).

Go zip-slip

✗ os.WriteFile(filepath.Join(dest, f.Name), buf, 0644)

Un nom d'entrée zip avec ../ écrit hors du dossier cible (Go).

.NET zip-slip

✗ entry.ExtractToFile(Path.Combine(dest, entry.FullName))

Un nom d'entrée zip avec ../ écrit hors du dossier cible (.NET).

Go weak randomness

✗ fmt.Sprintf("%d", rand.Int()) // math/rand as a token

math/rand utilisé pour générer un jeton de sécurité (Go).

.NET weak randomness

✗ new Random().Next().ToString() // as a token

System.Random utilisé pour générer un jeton de sécurité (.NET).

Go CORS misconfiguration

✗ w.Header().Set("Access-Control-Allow-Origin", r.Header.Get("Origin"))

Origin de la requête reflété dans CORS (Go).

.NET CORS misconfiguration

✗ Response.Headers["Access-Control-Allow-Origin"] = Request.Headers["Origin"]

Origin de la requête reflété dans CORS (.NET).

Go NoSQL injection

✗ coll.Find(ctx, bson.M{"$where": r.FormValue("q")})

Entrée utilisateur atteignant un opérateur NoSQL $where (Go).

.NET NoSQL injection

✗ collection.Find("{ $where: '" + Request["q"] + "' }")

Entrée utilisateur atteignant un opérateur NoSQL $where (.NET).

Go unrestricted upload

✗ io.Copy(dst, file) // no type/ext allowlist, web root

Upload sans allowlist de type/extension (Go).

.NET unrestricted upload

✗ file.SaveAs(Server.MapPath("~/public/" + file.FileName))

Upload sans allowlist de type/extension (.NET).

Go unsafe reflection

✗ reflect.New(registry[r.FormValue("t")]).Interface()

Type contrôlé par l'utilisateur instancié par réflexion (Go).

.NET unsafe reflection

✗ Activator.CreateInstance(Type.GetType(Request["t"]))

Type contrôlé par l'utilisateur instancié par réflexion (.NET).

Auth

JWT alg-none / bypass

✗ jwt.verify(t, key, { algorithms: ['none'] })

Un token accepté avec l'algorithme « none » — falsifiable.

JWT algorithm confusion

✗ jwt.verify(t, pubKey) // HS256 signed with the RSA public key

Confusion RS/HS — la clé publique acceptée comme secret HMAC.

JWT secret in code

✗ jwt.sign(payload, 'my-secret-key')

Secret de signature JWT codé en dur dans le source.

Hardcoded secrets

✗ const stripe = 'sk_live_4eC39Hq…'

Une clé live committée dans le code (et l'historique git à jamais).

CSRF disabled

✗ app.use(csrf({ ignoreMethods: ['POST'] }))

La protection CSRF désactivée sur une route mutante.

Insecure session cookie

✗ res.cookie('sid', id, { httpOnly: false })

Cookie de session sans HttpOnly / Secure / SameSite.

Hardcoded connection credential

✗ createConnection('postgres://user:pass@db')

Chaîne de connexion BD avec un mot de passe en clair.

Credential in a URL

✗ fetch('https://user:pass@api.co/x')

Identifiants dans une URL — journalisés et mis en cache.

Framework session secret

✗ SECRET_KEY = 'changeme'

Secret de session/signature du framework laissé par défaut.

Variantes par langage · Go · .NET 6

Go JWT secret in code

✗ token.SignedString([]byte("my-secret-key"))

Secret de signature JWT en dur dans le code (Go).

.NET JWT secret in code

✗ new SymmetricSecurityKey(Encoding.UTF8.GetBytes("my-secret-key"))

Secret de signature JWT en dur dans le code (.NET).

Go JWT algorithm confusion

✗ jwt.Parse(t, func(*jwt.Token) (any, error) { return pubKey, nil })

Confusion RS/HS — clé publique acceptée comme secret HMAC (Go).

.NET JWT algorithm confusion

✗ handler.ValidateToken(t, params, out _) // HS accepts RSA pubkey

Confusion RS/HS — clé publique acceptée comme secret HMAC (.NET).

Go insecure session cookie

✗ http.SetCookie(w, &http.Cookie{Name: "sid", Value: id})

Cookie de session sans HttpOnly / Secure / SameSite (Go).

.NET insecure session cookie

✗ Response.Cookies.Append("sid", id) // no HttpOnly/Secure/SameSite

Cookie de session sans HttpOnly / Secure / SameSite (.NET).

Crypto

Weak crypto

✗ crypto.createHash('md5').update(password)

MD5 / SHA-1 là où il faut un hash de mot de passe.

Static / hardcoded IV

✗ createCipheriv('aes-256-cbc', key, ZERO_IV)

Un IV réutilisé / à zéro — le même clair chiffre à l'identique.

Hardcoded crypto key

✗ const KEY = Buffer.from('0123456789abcdef')

Une clé symétrique codée en dur dans le source.

Committed private key

✗ -----BEGIN RSA PRIVATE KEY-----

Une clé privée committée dans le dépôt.

Insecure deserialization

✗ pickle.loads(request.data)

Données non fiables désérialisées — RCE par injection d'objet.

JSON polymorphic typing

✗ mapper.enableDefaultTyping()

Typage par défaut de Jackson sur du JSON non fiable — RCE par gadget.

Weak randomness

✗ Math.random().toString(36) // as a token

Math.random() utilisé pour générer un jeton de sécurité.

Zip-slip

✗ fs.writeFileSync(dest + entry.name, buf)

Un nom d'entrée zip avec ../ écrit hors du dossier cible.

Insecure temp-file

✗ open('/tmp/app-' + str(os.getpid()))

Un chemin de fichier temporaire prévisible — attaque symlink / course.

TLS-verify off

✗ new https.Agent({ rejectUnauthorized: false })

La vérification du certificat désactivée sur un appel sortant.

SSH host-key check off

✗ StrictHostKeyChecking=no

Vérification de clé d'hôte SSH désactivée — MITM.

Timing-unsafe MAC compare

✗ if (mac === expected) { … }

Comparaison de MAC non à temps constant — oracle temporel.

gRPC cleartext channel

✗ grpc.credentials.createInsecure()

Un canal gRPC sans TLS — en clair sur le réseau.

Obsolete TLS version

✗ minVersion: 'TLSv1'

TLS 1.0 / 1.1 autorisé — obsolète et cassable.

Weak key size (RSA/DSA)

✗ generateKeyPairSync('rsa', { modulusLength: 1024 })

Une clé RSA/DSA sous 2048 bits.

Weak elliptic curve

✗ crypto.createECDH('secp160r1')

Une courbe elliptique sous le plancher de 224 bits.

Weak DH parameters

✗ crypto.createDiffieHellman(512)

Paramètres Diffie–Hellman sous 2048 bits.

Null / no-encryption cipher

✗ tls.connect({ ciphers: 'NULL-MD5' })

Une suite de chiffrement NULL / sans chiffrement — en clair.

Insecure ECB cipher mode

✗ createCipheriv('aes-256-ecb', key, null)

Le mode ECB fuit les motifs du clair, bloc par bloc.

Insecure RSA padding

✗ privateDecrypt({ padding: RSA_PKCS1_PADDING }, data)

Padding RSA PKCS#1 v1.5 — utiliser OAEP.

Variantes par langage · Go · .NET 6

.NET obsolete TLS version

✗ ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls11

TLS 1.0 / 1.1 autorisé — obsolète (.NET).

.NET gRPC cleartext channel

✗ GrpcChannel.ForAddress("http://svc:5000") // cleartext

Un canal gRPC sans TLS — en clair (.NET).

.NET hardcoded crypto key

✗ aes.Key = Encoding.UTF8.GetBytes("0123456789abcdef")

Une clé symétrique en dur dans le code (.NET).

.NET static / hardcoded IV

✗ aes.IV = new byte[16] // zero IV

Un IV réutilisé / nul — chiffré identique (.NET).

Go weak key size

✗ rsa.GenerateKey(rand.Reader, 1024)

Une clé RSA sous 2048 bits (Go).

.NET weak key size

✗ new RSACryptoServiceProvider(1024)

Une clé RSA sous 2048 bits (.NET).

Supply-chain

Mutable deps · slopsquat

✗ "lodahs": "*" // typo'd name, floating range

Une plage flottante sur un nom de package typo-squatté.

CI/CD mutable pins

✗ uses: some/action@main # not a SHA

Une action CI épinglée à une branche, pas un SHA — remplaçable en silence.

Infra

Docker unpinned

✗ FROM node:latest

Une image de base en :latest — non reproductible, elle dérive.

IaC open-ingress

✗ cidr_blocks = ["0.0.0.0/0"] # port 22

Un security group ouvert à 0.0.0.0/0 sur SSH.

K8s privilege

✗ securityContext: { privileged: true }

Un conteneur privilégié — accès complet à l'hôte.

CloudFormation

✗ PolicyDocument: { Action: "*", Resource: "*" }

Une politique IAM accordant Action:* sur Resource:*.

Insecure Electron config

✗ webPreferences: { nodeIntegration: true }

Renderer Electron avec intégration Node, sans isolation de contexte.

Actuator over-exposure

✗ management.endpoints.web.exposure.include=*

Endpoints actuator de Spring entièrement exposés.

World-writable permissions

✗ os.chmod(path, 0o777)

Permissions inscriptibles par tous (0777).

Debug mode in production

✗ DEBUG = True

Le mode debug laissé actif en production.

S3 public-write ACL

✗ ACL: 'public-read-write'

Une ACL S3 (bucket/objet) qui autorise l'écriture publique.

Azure Blob public access

✗ container.SetAccessPolicy(PublicAccessType.Blob)

Un conteneur Azure Blob en accès public.

GCS bucket public access

✗ bucket.iam.set({ allUsers: 'roles/storage.objectViewer' })

Un bucket GCS accordant allUsers en lecture — objets publics.

AWS RDS publicly accessible

✗ new rds.DatabaseInstance(this, 'db', { publiclyAccessible: true })

Une instance RDS accessible depuis l'internet public.

S3 public-access-block off

✗ new s3.Bucket(this, 'b', { blockPublicAccess: BlockPublicAccess.BLOCK_ACLS })

Le public-access-block S3 n'est pas totalement activé.

Host-header auth off

✗ host = req.headers.host // used in the reset link

Faire confiance à l'en-tête Host — empoisonnement du reset de mot de passe.

Clickjacking (X-Frame-Options)

✗ // no X-Frame-Options / frame-ancestors set

Pas de X-Frame-Options / frame-ancestors — clickjacking.

Protège tes repos — 14 jours gratuits