Checklist SAST manual: sinks y anti-patrones por lenguaje

Enfoque general

Antes de leer código, identifica trust boundaries: parámetros HTTP, headers, cookies, JWT, mensajes de colas, archivos subidos, datos de DB que vienen de input de usuario. Todo lo que cruza ese límite es sospechoso. Prioriza grep por sinks primero, luego valida si hay sanitización efectiva en el path de datos (no solo en un helper cercano).

Comandos útiles de triage rápido:

# Aislar archivos que tocan input + sink en pocas líneas
grep -rEn "(exec|system|popen|Runtime|eval|unserialize|pickle|readObject|child_process|os/exec)" --include="*.php" --include="*.py" --include="*.java" --include="*.js" --include="*.go" .

# Semgrep si está disponible (mucho mejor señal/ruido)
semgrep --config "p/owasp-top-ten" --config "p/command-injection" .

PHP

Sinks críticos

  • Ejecución: exec, shell_exec, system, passthru, popen, proc_open, backticks, pcntl_exec, eval, assert (pre-8.0 con string), preg_replace con /e (legacy), create_function.
  • Inclusión: include/require con variable, include_once $_GET[...].
  • SQL: concatenación en mysqli_query, ->query(), PDO::query.
  • Deserialización: unserialize() sobre input — busca POP chains con __destruct, __wakeup, __toString.
  • SSRF: file_get_contents, curl_exec, fopen con URL controlada.

Anti-patrones auth

// Comparación laxa: "0e123" == "0e456" es true en PHP <8
if ($_POST['otp'] == $stored) { ... }

// Hash débil
md5($password); sha1($password);

// Type juggling en JWT/roles
if (in_array($role, ['admin'])) // si $role es array, bypassea

Python

Sinks

  • os.system, os.popen, subprocess con shell=True, eval, exec, pickle.loads, yaml.load (sin SafeLoader), marshal.loads, dill.loads.
  • Django: extra(), raw(), RawSQL con f-strings; mark_safe sobre input.
  • Flask: render_template_string con input → SSTI.

Patrones inseguros

# Subprocess con shell
subprocess.run(f"ping {host}", shell=True)  # inyectable

# YAML unsafe
yaml.load(data)              # payload: !!python/object/apply:os.system ['id']
yaml.safe_load(data)         # OK

# Pickle sobre red
pickle.loads(request.body)

Auth

  • @app.route sin @login_required; DRF permission_classes = [AllowAny].
  • Comparación con == en vez de hmac.compare_digest para tokens.
  • IDOR por Model.objects.get(pk=id) sin filtrar por request.user.

Java

Sinks

  • Runtime.getRuntime().exec(), ProcessBuilder, Statement.execute* con concatenación, SpEL, OGNL, ScriptEngine.eval.
  • Deserialización: ObjectInputStream.readObject(), XMLDecoder, Jackson con enableDefaultTyping()/@JsonTypeInfo, SnakeYAML sin SafeConstructor, XStream sin allowlist.
  • Plantillas: FreeMarker Template.process con input, Velocity, Thymeleaf con __${...}__ preprocesado.

Auth/anti-patrón

// Path traversal por normalize mal usado
File f = new File(base, userPath);
if (f.getCanonicalPath().startsWith(base)) // solo si base termina en /

// Regex DoS
Pattern.compile(userInput); // catastrophic backtracking

Busca permitAll() en Spring Security, @PreAuthorize ausente en controllers con @RequestMapping, y comparación de roles con equalsIgnoreCase sobre strings mutables.

Node.js

Sinks

  • child_process.exec/execSync con string interpolado; spawn con shell:true.
  • eval, new Function, vm.runInNewContext con input.
  • require() dinámico con variable.
  • Prototype pollution: asignaciones recursivas sobre obj[key] con claves del atacante (__proto__, constructor, prototype). Payload clásico:
{"__proto__": {"isAdmin": true}}
  • Deserialización: node-serialize (_$$ND_FUNC$$_), serialize-javascript sin escape.

Auth

  • JWT: jwt.verify(token, secret, { algorithms: ['none'] }) o no fijar algorithms → alg confusion.
  • app.use(cors({ origin: true, credentials: true })).
  • Middleware ordenado mal: ruta definida antes de authMiddleware.

Go

Sinks

  • os/exec: exec.Command("sh", "-c", userInput); exec.Command(userInput) también es explotable vía PATH.
  • text/template con input → SSTI; usa html/template.
  • SQL con fmt.Sprintf en vez de placeholders $1.
  • gob.NewDecoder(...).Decode() sobre datos no confiables.
  • unsafe, reflect con datos externos.
// malo
db.Query("SELECT * FROM u WHERE id=" + id)
// bien
db.Query("SELECT * FROM u WHERE id=$1", id)

Auth

  • jwt.Parse sin WithValidMethods → alg none.
  • Comparación de tokens con == (timing) en vez de subtle.ConstantTimeCompare.
  • golang.org/x/crypto/bcrypt con cost <10 o uso de md5.

Patrones transversales a todos los lenguajes

  1. Grep de secretos: AKIA[0-9A-Z]{16}, -----BEGIN.*PRIVATE KEY-----, password\s*=\s*["'], api[_-]?key.
  2. AuthZ rota: busca isAdmin, role, tenant_id comparados después de obtener el recurso — preferir query filtrada desde el WHERE.
  3. Mass assignment: req.body pasado directo a Model.create() (Rails/Sequelize/Mongoose), BeanUtils.copyProperties(req, entity) en Java, **request.json en Python frameworks.
  4. Race conditions en check-then-act: if(!exists) { create }, restaurar password, cupones.
  5. Deserialización: cualquier formato con tipos (Java serialized, pickle, PHP serialized, YAML tags, gob) sobre input → tratarlo como RCE potencial hasta probar lo contrario.
  6. Redirecciones abiertas: redirect(request.args['next']) sin allowlist de host.

Flujo recomendado

  1. Enumera entry points (rutas, consumers, jobs).
  2. Por cada uno, traza el data flow hacia sinks con grep dirigido al lenguaje.
  3. Marca hallazgos con archivo:línea y snippet mínimo reproducible.
  4. Valida con PoC local (Docker del target) antes de escalar — evita falsos positivos por sanitización intermedia que no viste en el grep.
  5. Documenta trust boundary y por qué el sink es alcanzable sin auth si aplica.