124 · El firewall

El catálogo completo las 124 clases.

Cada clase de gate que el firewall aplica, por categoría — con un ejemplo de detección real para cada una. Todas calibradas a 0 falsos positivos en 5 000+ repos.

Acceso

Cross-tenant · access-control

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

Una consulta sin filtro de org — las filas de cada tenant se filtran en prod.

RLS · SECURITY DEFINER

✗ create view billing as select * … security definer

Una vista definer que salta la seguridad a nivel de fila.

Mass-assignment

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

El cuerpo de la petición ligado directo al modelo — los campos de privilegio pasan.

CORS misconfiguration

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

El Origin de la petición reflejado en CORS — cualquier sitio lee las respuestas autenticadas.

Firebase public-write rules

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

Reglas de Firebase en lectura y escritura públicas.

Inyección

SQL injection

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

Entrada de usuario concatenada en una cadena SQL.

NoSQL injection

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

Entrada de usuario que llega a un operador NoSQL $where.

LDAP injection

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

Entrada de usuario concatenada en un filtro LDAP.

XPath injection

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

Entrada de usuario concatenada en una consulta XPath.

Unrestricted upload

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

Subida sin lista blanca de tipo/extensión en una raíz web escribible.

Command / code

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

Entrada de usuario que llega a un comando de shell.

Template (SSTI)

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

Entrada de usuario renderizada como plantilla — inyección de plantilla en servidor.

Path traversal / LFI

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

Entrada de usuario en una ruta — ../ escapa del directorio.

XSS

✗ el.innerHTML = req.query.q

Entrada de usuario escrita en innerHTML sin escape.

SSRF

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

Un fetch del servidor a una URL controlada por el usuario — alcanza el endpoint de metadatos.

XXE

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

XML parseado con entidades externas activadas.

Open redirect

✗ res.redirect(req.query.next)

Destino de redirección controlado por el usuario — pivote de phishing.

Prototype pollution

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

Fusión profunda de JSON de usuario — __proto__ contamina Object.prototype.

ReDoS

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

Regex con retroceso catastrófico ejecutada sobre la entrada del usuario.

CRLF / header injection

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

Entrada de usuario en una cabecera — CRLF divide la respuesta HTTP.

Log injection

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

Entrada de usuario sin sanear en los logs — líneas de log falsificadas.

PHP variable extraction

✗ extract($_GET);

extract() sobre datos de la petición — sobrescritura arbitraria de variables.

SpEL injection

✗ parser.parseExpression(input).getValue()

Entrada de usuario evaluada como expresión Spring SpEL.

Obfuscated code execution

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

Entrada de usuario decodificada en base64 pasada a eval.

Unsafe reflection

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

Nombre de clase controlado por el usuario instanciado por reflexión.

OGNL injection

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

Entrada de usuario evaluada como expresión OGNL (la clase RCE de Struts).

Script-engine injection

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

Entrada de usuario evaluada por un motor de scripting.

JNDI injection

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

Lookup JNDI controlado por el usuario (la clase Log4Shell).

EL injection

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

Entrada de usuario evaluada como expresión Jakarta EL.

XSLT injection

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

Hoja XSLT proporcionada por el usuario — RCE por función de extensión.

Node vm code injection

✗ vm.runInThisContext(req.body.code)

Entrada de usuario ejecutada en un contexto vm de Node — no es un sandbox.

Node require / import injection

✗ require(req.query.mod)

Ruta require() controlada por el usuario — carga de módulo arbitraria.

Python import injection

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

__import__ controlado por el usuario — carga de módulo Python arbitraria.

LLM insecure code execution

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

Código generado por un modelo ejecutado sin sandbox.

Variantes por lenguaje · Go · .NET 32

Go command injection

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

Go: entrada de usuario que llega a un comando de shell.

.NET command injection

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

.NET: entrada de usuario que llega a un comando de shell.

Go SSRF

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

Go: fetch de servidor a una URL controlada por el usuario.

.NET SSRF

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

.NET: fetch de servidor a una URL controlada por el usuario.

Go SQL injection

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

Go: entrada de usuario concatenada en SQL.

.NET SQL injection

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

.NET: entrada de usuario concatenada en SQL.

Go path traversal / LFI

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

Go: entrada de usuario en una ruta — traversal.

.NET path traversal / LFI

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

.NET: entrada de usuario en una ruta — traversal.

Go open redirect

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

Go: destino de redirección controlado por el usuario.

.NET open redirect

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

.NET: destino de redirección controlado por el usuario.

Go XSS

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

Go: entrada de usuario escrita en HTML sin escape.

.NET XSS

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

.NET: entrada de usuario escrita en HTML sin escape.

Go LDAP injection

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

Go: entrada de usuario en un filtro LDAP.

.NET LDAP injection

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

.NET: entrada de usuario en un filtro LDAP.

Go XPath injection

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

Entrada de usuario concatenada en una consulta XPath (Go).

.NET XPath injection

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

Entrada de usuario concatenada en una consulta XPath (.NET).

Go template (SSTI)

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

Entrada de usuario interpretada como plantilla — SSTI (Go).

.NET template (SSTI)

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

Entrada de usuario renderizada como plantilla — SSTI (.NET).

Go log injection

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

Entrada de usuario sin filtrar en los logs — líneas falsificadas (Go).

.NET log injection

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

Entrada de usuario sin filtrar en los logs — líneas falsificadas (.NET).

Go zip-slip

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

Un nombre de entrada zip con ../ escribe fuera del directorio (Go).

.NET zip-slip

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

Un nombre de entrada zip con ../ escribe fuera del directorio (.NET).

Go weak randomness

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

math/rand usado para generar un token de seguridad (Go).

.NET weak randomness

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

System.Random usado para generar un token de seguridad (.NET).

Go CORS misconfiguration

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

Origin de la petición reflejado en CORS (Go).

.NET CORS misconfiguration

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

Origin de la petición reflejado en CORS (.NET).

Go NoSQL injection

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

Entrada de usuario que llega a un operador NoSQL $where (Go).

.NET NoSQL injection

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

Entrada de usuario que llega a un operador NoSQL $where (.NET).

Go unrestricted upload

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

Subida sin allowlist de tipo/extensión (Go).

.NET unrestricted upload

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

Subida sin allowlist de tipo/extensión (.NET).

Go unsafe reflection

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

Tipo controlado por el usuario instanciado por reflexión (Go).

.NET unsafe reflection

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

Tipo controlado por el usuario instanciado por reflexión (.NET).

Auth

JWT alg-none / bypass

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

Un token aceptado con el algoritmo «none» — falsificable.

JWT algorithm confusion

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

Confusión RS/HS — la clave pública aceptada como secreto HMAC.

JWT secret in code

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

Secreto de firma JWT incrustado en el código.

Hardcoded secrets

✗ const stripe = 'sk_live_4eC39Hq…'

Una clave live commiteada en el código (y el historial git para siempre).

CSRF disabled

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

La protección CSRF desactivada en una ruta mutante.

Insecure session cookie

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

Cookie de sesión sin HttpOnly / Secure / SameSite.

Hardcoded connection credential

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

Cadena de conexión a BD con una contraseña en claro.

Credential in a URL

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

Credenciales en una URL — registradas y cacheadas.

Framework session secret

✗ SECRET_KEY = 'changeme'

Secreto de sesión/firma del framework dejado por defecto.

Variantes por lenguaje · Go · .NET 6

Go JWT secret in code

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

Secreto de firma JWT incrustado en el código (Go).

.NET JWT secret in code

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

Secreto de firma JWT incrustado en el código (.NET).

Go JWT algorithm confusion

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

Confusión RS/HS — clave pública aceptada como secreto HMAC (Go).

.NET JWT algorithm confusion

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

Confusión RS/HS — clave pública aceptada como secreto HMAC (.NET).

Go insecure session cookie

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

Cookie de sesión sin HttpOnly / Secure / SameSite (Go).

.NET insecure session cookie

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

Cookie de sesión sin HttpOnly / Secure / SameSite (.NET).

Cripto

Weak crypto

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

MD5 / SHA-1 donde hace falta un hash de contraseña.

Static / hardcoded IV

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

Un IV reusado / a cero — el mismo texto cifra idéntico.

Hardcoded crypto key

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

Una clave simétrica incrustada en el código.

Committed private key

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

Una clave privada subida al repositorio.

Insecure deserialization

✗ pickle.loads(request.data)

Datos no confiables deserializados — RCE por inyección de objetos.

JSON polymorphic typing

✗ mapper.enableDefaultTyping()

Tipado por defecto de Jackson sobre JSON no confiable — RCE por gadget.

Weak randomness

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

Math.random() usado para generar un token de seguridad.

Zip-slip

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

Un nombre de entrada zip con ../ escribe fuera del directorio destino.

Insecure temp-file

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

Una ruta de archivo temporal predecible — ataque de symlink / carrera.

TLS-verify off

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

La verificación del certificado desactivada en una llamada saliente.

SSH host-key check off

✗ StrictHostKeyChecking=no

Verificación de clave de host SSH desactivada — MITM.

Timing-unsafe MAC compare

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

Comparación de MAC no en tiempo constante — un oráculo temporal.

gRPC cleartext channel

✗ grpc.credentials.createInsecure()

Un canal gRPC sin TLS — en claro por la red.

Obsolete TLS version

✗ minVersion: 'TLSv1'

TLS 1.0 / 1.1 permitido — obsoleto y rompible.

Weak key size (RSA/DSA)

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

Una clave RSA/DSA por debajo de 2048 bits.

Weak elliptic curve

✗ crypto.createECDH('secp160r1')

Una curva elíptica por debajo del suelo de 224 bits.

Weak DH parameters

✗ crypto.createDiffieHellman(512)

Parámetros Diffie–Hellman por debajo de 2048 bits.

Null / no-encryption cipher

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

Una suite de cifrado NULL / sin cifrado — en claro.

Insecure ECB cipher mode

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

El modo ECB filtra patrones del texto claro, bloque a bloque.

Insecure RSA padding

✗ privateDecrypt({ padding: RSA_PKCS1_PADDING }, data)

Relleno RSA PKCS#1 v1.5 — usar OAEP.

Variantes por lenguaje · Go · .NET 6

.NET obsolete TLS version

✗ ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls11

TLS 1.0 / 1.1 permitido — obsoleto (.NET).

.NET gRPC cleartext channel

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

Un canal gRPC sin TLS — en claro (.NET).

.NET hardcoded crypto key

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

Una clave simétrica incrustada en el código (.NET).

.NET static / hardcoded IV

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

Un IV reutilizado / nulo — cifrado idéntico (.NET).

Go weak key size

✗ rsa.GenerateKey(rand.Reader, 1024)

Una clave RSA por debajo de 2048 bits (Go).

.NET weak key size

✗ new RSACryptoServiceProvider(1024)

Una clave RSA por debajo de 2048 bits (.NET).

Supply-chain

Mutable deps · slopsquat

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

Un rango flotante sobre un nombre de paquete typo-squatteado.

CI/CD mutable pins

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

Una acción CI fijada a una rama, no a un SHA — reemplazable en silencio.

Infra

Docker unpinned

✗ FROM node:latest

Una imagen base en :latest — no reproducible, deriva.

IaC open-ingress

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

Un security group abierto a 0.0.0.0/0 en SSH.

K8s privilege

✗ securityContext: { privileged: true }

Un contenedor privilegiado — acceso total al host.

CloudFormation

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

Una política IAM que concede Action:* sobre Resource:*.

Insecure Electron config

✗ webPreferences: { nodeIntegration: true }

Renderer de Electron con integración de Node, sin aislamiento de contexto.

Actuator over-exposure

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

Endpoints actuator de Spring totalmente expuestos.

World-writable permissions

✗ os.chmod(path, 0o777)

Permisos de escritura para todos (0777).

Debug mode in production

✗ DEBUG = True

El modo debug dejado activo en producción.

S3 public-write ACL

✗ ACL: 'public-read-write'

Una ACL de S3 (bucket/objeto) que permite escritura pública.

Azure Blob public access

✗ container.SetAccessPolicy(PublicAccessType.Blob)

Un contenedor Azure Blob en acceso público.

GCS bucket public access

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

Un bucket GCS que concede allUsers en lectura — objetos públicos.

AWS RDS publicly accessible

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

Una instancia RDS accesible desde internet público.

S3 public-access-block off

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

El public-access-block de S3 no está totalmente activado.

Host-header auth off

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

Confiar en la cabecera Host — envenenamiento del restablecimiento de contraseña.

Clickjacking (X-Frame-Options)

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

Sin X-Frame-Options / frame-ancestors — clickjacking.

Protege tus repos — 14 días gratis