flawopen.com/Directorio/Referencias

Guías de referencia de seguridad

Consulta estas referencias para revisar supuestos de seguridad en frameworks, ORM, autenticación, aplicaciones serverless y agentes de IA. Cada guía conecta la explicación y la solución con sus detalles técnicos.

• Claude Code MemoryTrap: memoria de agente — flawopen.com

  La divulgación MemoryTrap de Cisco: memoria persistente en Claude Code, corrección en v2.1.50 y controles para agentes.

• Sandbox de agentes IA: contenedores y microVMs

  Compara los límites de aislamiento de contenedores, gVisor y microVM para agentes de IA.

• Ámbito de herramientas IA: mínimo privilegio

  Cómo reducir la agencia excesiva en agentes de IA con herramientas específicas, autorización por usuario y mínimo privilegio.

• Bots de PR con IA: prevenir SSRF — flawopen.com

  Cómo el texto no confiable de una pull request puede influir en herramientas de IA y cómo limitar permisos del bot y acceso a la red.

• Riesgos de seguridad de addJavascriptInterface en Android

  WebView expone métodos nativos a todos los frames. Aprende el riesgo XSS de addJavascriptInterface y a separar páginas no confiables.

• Protección XSS de Angular: valores seguros y APIs de omisión

  Angular escapa la interpolación y sanea los enlaces HTML y URL. Descubre dónde bypassSecurityTrust* desactiva la protección y cómo auditar sinks XSS.

• XSS por MIME sniffing: Content-Type y nosniff

  Descubre cómo MIME sniffing puede convertir cargas en documentos del navegador, qué hace nosniff y cómo servir archivos de forma segura.

• ¿strncpy() es más segura que strcpy()?

  ¿strncpy() es más segura que strcpy() en C? Reduce un riesgo, pero no garantiza el terminador nulo. Aprende a comprobar snprintf y strlcpy.

• CSP y escape de salida: ¿necesitas ambos?

  La codificación de salida previene XSS según el contexto; CSP limita parte del impacto si hay un fallo. Aprende a combinar ambas defensas.

• Token CSRF en GET: ¿cuándo se necesita?

  Un GET seguro no debe cambiar el estado. Aprende cuándo proteger métodos no seguros con tokens CSRF y cómo corregir GET heredados que mutan datos.

• CWE frente a CVE: ¿cuál es la diferencia?

  CWE frente a CVE: ¿cuál es la diferencia?: CWE es la categoría — un tipo de bug, como "inyección SQL" (CWE-89). CVE es la instancia — una aparición concreta y documentada

• ¿Es seguro dangerouslySetInnerHTML en React?

  React escapa el texto JSX, pero dangerouslySetInnerHTML interpreta HTML. Aprende a revisar este punto XSS y mostrar texto enriquecido de forma segura.

• Dependency Confusion: riesgos y defensas

  Cómo la ambigüedad en el origen de paquetes introduce dependencias inesperadas y cómo las políticas de registro y CI reducen el riesgo.

• Django ORM y SQL Injection: patrones seguros

  Los QuerySets de Django parametrizan valores. Aprende a revisar SQL sin procesar, expresiones dinámicas y rutas de consulta.

• Exposición del socket de Docker: riesgos y defensas

  Exponer un socket del daemon de Docker puede conceder autoridad al nivel del daemon. Conoce los límites, los riesgos de capacidades y configuraciones más seguras.

• Inyección SQL en Doctrine ORM: consultas seguras

  Vincula valores DQL/SQL con parámetros. Descubre dónde QueryBuilder sigue siendo vulnerable y cómo permitir ordenación dinámica.

• ¿DOMPurify basta para proteger innerHTML?

  DOMPurify protege el HTML enriquecido en el sink correcto. Conoce sus límites, los cambios posteriores, Trusted Types y controles de producción.

• .NET BinaryFormatter: riesgos y migración

  Microsoft afirma que BinaryFormatter no puede protegerse. Conoce el riesgo, el comportamiento en .NET 9 y cómo migrar.

• ¿XmlReader de .NET es seguro frente a XXE?

  XmlReader prohíbe DTD por defecto. Conoce el cambio de .NET Framework 4.5.2 y cómo proteger el análisis XML.

• EF Core FromSqlRaw: SQL parametrizado seguro

  Usa FromSqlRaw con parámetros separados, no entradas concatenadas. Aprende FromSqlInterpolated, versiones de EF Core y SQL dinámico seguro.

• Node.js exec() vs execFile(): diferencias y seguridad

  Compara exec() y execFile() en Node.js: shell, argumentos, inyección de comandos y cuándo usar cada API.

• FastAPI y SQL Injection: qué protege Pydantic

  FastAPI valida datos, pero la seguridad SQL depende de cómo construyas la consulta. Aprende parámetros SQLAlchemy e identificadores dinámicos seguros.

• SSRF en fetch() de Node.js: cómo obtener URLs con seguridad

  El fetch() del servidor puede alcanzar destinos elegidos por el usuario. Aprende sobre destinos fijos, redirecciones, DNS y límites de salida.

• SSTI en FreeMarker y Velocity: seguridad de plantillas

  Controla el origen de plantillas, limita objetos Java y aísla el renderizado para reducir SSTI en FreeMarker y Velocity.

• Inyección de scripts en GitHub Actions: entradas seguras

  Los valores de GitHub pueden volverse comandos en run. Aprende a usar env, limitar permisos y proteger pull_request_target.

• GORM Raw SQL: evita la inyección SQL en Go

  Usa parámetros enlazados con GORM Raw. Aprende cómo protegen los valores y por qué los identificadores SQL requieren listas permitidas.

• ¿Basta escapar comillas para evitar SQL Injection?

  No. Las consultas parametrizadas separan los datos del SQL; el escape depende de la base de datos y es frágil. Usa listas permitidas para identificadores.

• ¿Basta con usar un ORM para prevenir la inyección SQL?

  ¿Basta con usar un ORM para prevenir la inyección SQL?: para su API de consulta estándar, sí. Todo ORM popular incluye además una vía de escape a SQL en crudo, y esas conllevan

• XXE en Java: ¿DocumentBuilderFactory es segura por defecto?

  Los parsers del JDK limitan algunos ataques, pero no bloquean el acceso externo por defecto. Aprende ajustes seguros y diferencias entre proveedores.

• ObjectInputStream en Java: deserialización segura

  Los datos Java no confiables pueden activar gadgets en readObject(). Aprende sobre filtros, formatos seguros y flujos heredados.

• Java Runtime.exec() y Command Injection: qué cambia

  Runtime.exec(String) no inicia un shell, pero la entrada puede alterar argumentos. Usa ProcessBuilder y valida cada valor.

• ReDoS en Node.js: regex y CVE-2026-83606

  Descubre cómo el backtracking de regex bloquea Node.js, el caso CVE-2026-83606 y sus correcciones.

• ¿Es seguro render_template_string() de Jinja2?

  Usa una plantilla literal y pasa los datos del usuario por el contexto. Aprende sobre SSTI, autoescape y la condición concreta de CVE-2024-56201.

• ¿JSON.parse() causa contaminación de prototipos?

  JSON.parse() no contamina prototipos. Aprende cómo las fusiones inseguras y las claves controladas crean el riesgo.

• ¿JSON.parse() es más seguro que eval()?

  Por qué JSON.parse() trata la entrada como datos, cómo eval() puede ejecutarla y qué implica el callback reviver.

• JWT en localStorage frente a cookies HttpOnly: ¿qué es más seguro? — flawopen.com

  Comparación arquitectónica entre JWT en localStorage y cookies HttpOnly SameSite: robo de token por XSS, contrapartidas de CSRF y arquitecturas de autenticación recomendadas.

• ¿Knex.js es seguro frente a SQL Injection?

  Knex vincula valores. Usa bindings en knex.raw() y listas permitidas para identificadores SQL dinámicos.

• ¿lodash.merge() causa contaminación de prototipos?

  Las correcciones de Lodash varían por función y versión. Consulta los rangos afectados, la versión corregida y cómo validar datos.

• ¿Markdown es seguro frente a XSS?

  Markdown no hace que el HTML sea seguro automáticamente. Aprende cuándo pasa HTML sin procesar y cómo sanear la salida.

• Mass assignment: riesgos y listas seguras de campos

  Mass assignment permite que una solicitud cambie campos que el usuario no debe controlar. Aprende listas permitidas y autorización.

• Seguridad MCP: límites de herramientas | FlawOpen

  Conoce los límites de confianza de MCP y cómo restringir herramientas locales, permisos y consentimiento para evitar la exposición de datos.

• MyBatis ${} vs #{}: evitar SQL Injection

  En MyBatis, #{} vincula valores con JDBC; ${} inserta texto SQL sin procesar. Usa binding seguro y listas permitidas para identificadores.

• MySQLi vs PDO: prepared statements seguros

  MySQLi y PDO pueden prevenir SQL injection con prepared statements. Compara el enlace de valores, los drivers y patrones seguros.

• Newtonsoft.Json TypeNameHandling: ¿configuración segura?

  Json.NET lee nombres CLR de $type. Mantén TypeNameHandling en None para JSON no confiable; en otro caso, valida los tipos con un binder estricto.

• Next.js Server Actions CSRF: Origin y configuración segura

  Cómo Next.js comprueba Origin, riesgos de confianza en el proxy y allowedOrigins, y cómo autorizar cada acción.

• Filtración de estado serverless: aísla datos por solicitud

  Cómo los runtimes serverless reutilizados pueden exponer datos antiguos y cómo aislar la identidad y el estado de cada solicitud.

• ¿NHibernate protege frente a SQL Injection?

  Los parámetros HQL de NHibernate separan los valores de la sintaxis. Aprende los riesgos de interpolar texto e identificadores dinámicos.

• Riesgo de command injection en Node.js exec()

  Node.js exec() usa un shell. Aprende cuándo los datos no confiables permiten command injection y cómo execFile() con validación cambia el flujo.

• ¿Qué es una consulta parametrizada?

  ¿Qué es una consulta parametrizada?: una consulta parametrizada es como rellenar un formulario con campos etiquetados en vez de escribir una carta entera a mano. La base de datos rec

• ¿Prisma $queryRaw es seguro frente a SQL Injection?

  Prisma parametriza valores en tagged templates. Aprende cuándo son seguras las consultas raw y por qué los identificadores SQL necesitan allowlists.

• ¿Es segura la interpolación en where() de Rails?

  Interpolar datos de la solicitud en where() puede causar SQL Injection. Usa condiciones hash o parámetros vinculados.

• Seguridad de agentes IA: herramientas y aislamiento

  Protege herramientas de agentes de IA con autorización por usuario, aprobación de acciones críticas y ejecución aislada. Conoce límites del sandbox.

• ¿Sequelize query() es seguro frente a SQL Injection?

  Las consultas raw de Sequelize requieren parámetros separados. Aprende la diferencia entre replacements, bind e identificadores SQL.

• ¿SQLAlchemy text() es seguro frente a SQL Injection?

  SQLAlchemy text() acepta SQL raw; enlaza valores en execute(). Aprende por qué la interpolación y los identificadores dinámicos requieren revisión.

• SSRF y metadatos cloud: riesgos y defensa

  Cómo SSRF puede alcanzar metadatos cloud y cómo los controles del proveedor, el mínimo privilegio y las reglas de salida reducen el riesgo.

• ¿Svelte protege contra XSS por defecto?

  Svelte escapa las expresiones de texto habituales. Descubre por qué {@html} requiere HTML confiable o saneado y cómo localizarlo.

• ¿El QueryBuilder de TypeORM es seguro frente a SQL Injection?

  TypeORM enlaza los parámetros de QueryBuilder. Aprende por qué hay que revisar condiciones interpoladas, SQL raw e identificadores dinámicos.

• Riesgo de XSS con Vue v-html

  Vue escapa {{ }} por defecto, pero v-html procesa HTML. Aprende sobre XSS, rich text seguro y auditorías de archivos .vue.

• Cosign GHSA-fx35-mq7g-6g98: bypass de bundle legado

  Cómo bundles antiguos de Cosign eludían la identidad keyless, qué versiones lo corrigen y cómo proteger la verificación en CI.

• Inyección NoSQL en MongoDB: filtros seguros

  Aprende cómo objetos JSON sin validar alteran filtros MongoDB, cómo validar tipos y probar la corrección.

• SQL Injection en IDs numéricos: ¿riesgo?

  Incluso los IDs numéricos pueden ser vulnerables si se insertan en la consulta mediante formato de cadenas. Entiende el riesgo y usa parámetros.

• Object.assign() y Prototype Pollution: ¿qué es seguro?

  Object.assign() puede cambiar el prototipo del destino mediante __proto__. Conoce la diferencia con spread y protege las fusiones profundas.

• Node.js path.join() no evita Path Traversal

  path.join() normaliza rutas, pero permite ..; resuelve y comprueba la contención, y evalúa los symlinks.

• PHP include() y rutas controladas por el usuario

  Cuándo include() expone archivos o ejecuta código, por qué RFI depende de la configuración y cómo corregirlo con una lista permitida.

• PHP == y las comparaciones de magic hash

  PHP 8 aún compara numéricamente dos cadenas numéricas, por lo que los hashes 0e pueden coincidir. Valida tipos y usa hash_equals() para secretos.

• PHP unserialize() y datos no confiables

  PHP desaconseja unserialize() con datos no confiables. Usa JSON; autentica los datos serializados confiables antes de analizarlos.

• Corregir path traversal con Python os.path.join()

  Entiende cómo os.path.join() trata rutas absolutas y ..; resuelve la ruta y verifica su contención con commonpath().

• Seguridad de pickle.load() en Python: riesgos de datos no confiables

  El pickle de Python puede ejecutar código al cargar datos. Conoce CWE-502 y reemplaza entradas no confiables por JSON validado.

• Seguridad XXE en XML Python: ElementTree, Expat y lxml

  ¿ElementTree evita XXE? Consulta los riesgos según la versión de Expat, las opciones de lxml y el manejo seguro de XML no confiable.

• ¿Qué es ReDoS (retroceso catastrófico)?

  Cómo las regex ambiguas provocan denegación de servicio y cómo limitar las coincidencias de forma segura.

• ¿Es seguro Ruby YAML.load? Versiones de Psych y safe_load

  Compruebe la versión de Psych, use safe_load y nunca deserialice YAML o Marshal no confiable con APIs inseguras.

• ¿El bloque unsafe de Rust sigue siendo seguro?

  Entiende los límites de unsafe en Rust, soundness y cómo CVE-2021-25900 expuso un fallo de memoria.

• ¿SameSite=Strict sustituye los tokens CSRF?

  Qué protegen SameSite=Strict y Lax, cuáles son sus límites entre subdominios y cuándo combinarlos con tokens CSRF.

• ¿La verificación de consultas de sqlx en compilación evita la inyección SQL?

  Qué comprueba query!, cómo usar parámetros enlazados para evitar inyección SQL y cuándo query().bind() es seguro.

• ¿Qué es la inyección de plantillas del lado del servidor?

  Cómo funciona SSTI, por qué su impacto depende del motor y cómo mantener los datos de usuario fuera del código de plantilla.

• ¿Los procedimientos almacenados evitan la inyección SQL?

  Los procedimientos almacenados solo evitan la inyección SQL si usan parámetros enlazados; aprende a tratar SQL dinámico e identificadores.

• ¿La carga de SVG implica riesgo de XSS?

  Cuándo se ejecutan scripts en SVG y cómo sanear, rasterizar y aislar archivos subidos.

• WKWebView: ¿HTML no confiable seguro?

  WKWebView muestra HTML y scripts recibidos. Aprende cuándo sanitizar el contenido y cómo proteger el puente nativo.

• XSS reflejado, almacenado y basado en DOM: ¿en qué se diferencian?

  Compara las rutas del XSS reflejado, almacenado y basado en DOM y corrige cada fallo en el punto de renderizado.

• ¿Qué es una vulnerabilidad Zip Slip?

  Cómo los nombres manipulados dentro de archivos ZIP pueden escapar del directorio de extracción y cómo validar cada ruta.