Prueba Salt Code. Obtén tu token gratuito

Industria

Cómo asegurar el código generado por IA

November 19, 2026

Danielle Duhon
Director de Crecimiento

Los asistentes de programación por IA escriben una gran parte del código que los equipos ponen en producción. Informe de seguridad de código GenAI 2026 de Veracode estima que la IA redacta aproximadamente la mitad de todo el código enviado en los equipos que han adoptado estas herramientas. Esa velocidad es valiosa, pero los asistentes están diseñados para producir código funcional, no código seguro, y ninguno conoce tus estándares de seguridad internos. Esta guía presenta un flujo de trabajo práctico para asegurar el código generado por IA: cómo solicitarlo mediante prompts, escanearlo, verificar sus dependencias, revisar los cambios de mayor riesgo, establecer políticas y automatizar su cumplimiento para que la seguridad siga el ritmo del desarrollo a velocidad de máquina.

¿Cuáles son los riesgos de seguridad del código generado por IA?

El código generado por IA tiende a fallar de cuatro formas reconocibles:

  • Paquetes alucinados. Los modelos a veces hacen referencia a bibliotecas que no existen. Los atacantes pueden registrar esos nombres y llenarlos con código malicioso.
  • Secretos codificados (hardcoded). El código de ejemplo a menudo contiene credenciales de ejemplo, y las claves reales terminan enviándose junto con él.
  • Patrones de codificación inseguros. Las fallas de inyección, como el cross-site scripting y la inyección de registros, aparecen porque el modelo no puede ver cómo fluyen los datos no confiables a través de la aplicación en su conjunto.
  • Fallas de diseño y lógica. La autorización rota, los datos expuestos en cadenas de consulta y la falta de límites de tasa pueden compilarse correctamente y aun así superar un escaneo básico.

La investigación es consistente. Informe de seguridad de código GenAI 2026 de Veracode probó más de 100 modelos en cuatro instantáneas. Las tasas de aprobación de sintaxis alcanzaron el 99,9%, pero la tasa promedio de aprobación de seguridad se mantuvo alrededor del 56%. En aproximadamente el 44% de las tareas, los modelos introdujeron una vulnerabilidad detectable del OWASP Top 10. Los resultados variaron ampliamente según el tipo de falla: los modelos manejaron bien la inyección SQL (83% de tasa de aprobación), pero tuvieron un desempeño deficiente en cross-site scripting (15%) e inyección de registros (12%).

Los secretos muestran el mismo patrón. El informe State of Secrets Sprawl 2026 de GitGuardian, tal como lo cubrió SC Media, descubrió que las confirmaciones (commits) públicas coescritas por Claude Code filtraron secretos en un 3,2%, aproximadamente el doble del 1,5% de referencia en todas las confirmaciones públicas de GitHub. También encontró más de 24.000 secretos expuestos en archivos de configuración MCP públicos.

Sobre las dependencias, un Estudio de USENIX Security 2025 sobre 16 LLM generadores de código y 576,000 muestras de código reveló tasas promedio de alucinación de paquetes de al menos un 5.2% para modelos comerciales y un 21.7% para modelos de código abierto, con 205,474 nombres de paquetes alucinados únicos.

La buena noticia es que estos riesgos siguen patrones predecibles. Puede gestionar los riesgos predecibles con un flujo de trabajo repetible, que es lo que cubre el resto de esta guía.

Guíe a la IA con prompts centrados en la seguridad

Los prompts vagos tienden a producir código con brechas de seguridad. Las pruebas de Veracode deliberadamente no proporcionaron a los modelos ninguna guía específica de seguridad porque los desarrolladores suelen centrarse en la funcionalidad y no siempre saben cuándo una solicitud tiene implicaciones de seguridad. En esas condiciones, los modelos eligieron una implementación insegura en casi la mitad de las tareas. Establecer los requisitos de seguridad desde el principio cierra parte de esa brecha.

Un prompt más sólido nombra los controles que espera, no solo la funcionalidad:

  • Débil: "Crea un endpoint de API que elimine a un usuario."
  • Más sólido: "Crea un endpoint de API que elimine a un usuario. Requiere autenticación mediante token bearer en el encabezado Authorization, no en la cadena de consulta. Pasa el ID de usuario en el cuerpo de la solicitud y verifica que quien realiza la llamada esté autorizado para eliminar a ese usuario específico. Valida todas las entradas, utiliza consultas parametrizadas, limita la tasa de solicitudes del endpoint y no codifiques ninguna credencial de forma rígida."

La versión más sólida apunta a las fallas exactas que Salt Code señala en su propia demostración: autorización a nivel de objeto rota (OWASP API1), tokens de autenticación en la cadena de consulta (API2) y filtración de IDs de usuario a través de URLs (API3).

Mantenga una biblioteca compartida de prompts de codificación segura validados para que todo el equipo parta de la misma base. Aun así, la disciplina en los prompts depende de que cada desarrollador recuerde cada requisito en cada solicitud. Por eso los pasos posteriores y la aplicación automatizada son importantes.

Analice cada cambio con herramientas de seguridad automatizadas

Ejecute tres tipos de comprobaciones automatizadas en cada cambio sugerido por la IA, no solo antes de un lanzamiento:

  • Pruebas de seguridad de aplicaciones estáticas (SAST) para detectar patrones de código inseguros, como fallas de inyección.
  • Análisis de composición de software (SCA) para señalar paquetes de terceros vulnerables o sospechosos.
  • Detección de secretos para detener las credenciales antes de que se confirmen. La recomendación de GitGuardian es analizar los cambios de código en busca de secretos antes de confirmarlos.

Implemente estas comprobaciones en dos puntos. En el IDE, ofrecen a los desarrolladores información instantánea mientras el código aún está fresco. En CI, actúan como una puerta que bloquea una fusión cuando una comprobación falla.

El análisis tiene un límite que merece la pena mencionar. Como Salt Code señala, las herramientas SAST y DAST detectan problemas en etapas posteriores, una vez que el código ha sido confirmado, revisado y puesto en cola para su implementación, por lo que cada corrección se convierte en una reescritura. Los datos de Veracode también muestran por qué los escáneres por sí solos no son suficientes para ciertas clases de fallos: detectar secuencias de comandos en sitios cruzados (XSS) y la inyección de registros requiere rastrear cómo fluye la entrada del usuario a través de archivos y funciones, algo que un modelo que genera una sola función no puede ver. Ajuste sus escáneres para los patrones que producen las herramientas de IA y combínelos con la prevención en etapas más tempranas del flujo de trabajo.

Verifique cada dependencia antes de que entre en su base de código

Las herramientas de codificación por IA a veces sugieren paquetes que no existen. El Estudio de USENIX Security 2025 lo describe como una nueva forma de ataque de confusión de paquetes: un atacante registra el nombre alucinado en un registro público como PyPI o npm, publica código malicioso bajo ese nombre y espera a que un desarrollador ejecute el comando de instalación sugerido por la IA. Los investigadores descubrieron que el problema era persistente y sistémico en todos los modelos.

Antes de instalar cualquier paquete que sugiera una herramienta de IA, confirme tres cosas:

  1. Que sea real. Compruebe que el paquete existe en el registro oficial con el nombre exacto y esté atento a errores ortográficos similares a los de bibliotecas populares.
  2. Que tenga mantenimiento activo. Observe el historial de versiones, la actividad del mantenedor y el volumen de descargas. Un paquete nuevo sin historial merece un escrutinio.
  3. Que esté libre de vulnerabilidades conocidas. Ejecútelo a través de su herramienta de análisis de composición de software antes de que llegue a un archivo de bloqueo (lockfile).

Luego, mantenga una lista de materiales de software (SBOM). Un SBOM es una lista de los componentes de código abierto y de terceros en su código, con sus versiones, licencias y estado de parches, tal como el Programa de Seguridad y Privacidad de la Información de los CMS explica. Generarlo en CI le proporciona un registro continuo de cada componente que una herramienta de IA ha introducido, para que pueda responder rápidamente cuando se divulgue una nueva vulnerabilidad.

Reserve la revisión humana para cambios de alto riesgo

Las herramientas automatizadas no pueden detectar todos los fallos de lógica empresarial, y los revisores no pueden leer cada línea generada por IA a la velocidad de una máquina. Centre la revisión humana donde un error resulte más costoso:

  • Autenticación y autorización. El control de acceso merece la mayor atención. El informe de Gartner How to Secure Custom-Built AI Agents concluye que los problemas de control de acceso serán la causa de la mayoría de los fallos de seguridad en agentes.
  • Criptografía. Elección de algoritmos, gestión de claves y generación de números aleatorios.
  • Gestión de datos confidenciales. Cualquier elemento que involucre información de identificación personal (PII), datos de pago o datos de salud, incluyendo dónde se registran dichos datos.
  • Nuevos endpoints externos, herramientas de agentes y servidores MCP. Cada nueva integración de API o MCP amplía su superficie de ataque. Gartner también señala que la mayoría de los servidores MCP publicados carecen de saneamiento de contenido, lo que convierte a los servidores MCP públicos en un vector de ataque importante y subestimado.

Separe a la persona que solicitó un cambio arriesgado de la persona que lo aprueba. Un desarrollador que ha iterado con un asistente de IA hasta que el código funcionó es quien menos probabilidades tiene de detectar los errores cometidos por el asistente.

La revisión tampoco termina con la integración (merge). Como explica Nick Rago de Salt en Su transformación de IA necesita protección en tiempo de ejecución para todo el ecosistema de agentes, un solo prompt puede viajar desde un agente a través de un LLM y servidores MCP hasta las API que hacen funcionar su negocio. Un atacante que descubra una herramienta expuesta puede saltarse al agente por completo y llamar a la API que hay detrás. El código que escriben sus asistentes de IA se convierte en parte de esa ruta, así que valídelo tanto en tiempo de ejecución como durante la revisión.

Establezca una política de gobernanza ligera para las herramientas de programación con IA

Redacte una política breve y práctica en lugar de un extenso documento de cumplimiento. Una política que la gente pueda leer en cinco minutos es una política que la gente sigue. Salt Code expone la alternativa claramente: cuando las políticas residen en archivos PDF, wikis y conocimientos informales, la IA que construye su software no ha leído ninguna de ellas.

Como mínimo, la política debe establecer:

  • Dónde están permitidas las herramientas de IA. Qué asistentes están aprobados, para qué repositorios y si algún código (como módulos criptográficos o de pago) está fuera de los límites.
  • Qué debe ser escaneado. Las comprobaciones de SAST, SCA y secretos que todo cambio asistido por IA debe superar, y dónde se ejecutan.
  • Qué requiere revisión humana. Las categorías de alto riesgo de la sección anterior.
  • Quién es responsable de las excepciones. Un responsable designado que pueda aprobar una desviación y registrar el motivo.

Etiqueta los commits generados por IA para que los equipos puedan rastrear un problema hasta el origen de cómo se creó el código. Los metadatos de los commits son lo que hizo posible los hallazgos de Claude Code de GitGuardian en primer lugar: los investigadores pudieron comparar las tasas de filtración solo porque esos commits llevaban una etiqueta de coautor. El mismo etiquetado permite a tu equipo medir si su código asistido por IA es cada vez más seguro con el paso del tiempo.

Automatiza el cumplimiento con una plataforma de gobernanza de código de IA

Cada paso anterior solo funciona si los desarrolladores recuerdan hacerlo, en cada prompt y bajo la presión de los plazos de entrega. Una plataforma de gobernanza dedicada aplica estos pasos automáticamente. Al evaluar una, busca lo siguiente:

  • Prevención en el punto de generación. Las políticas deben dar forma al código mientras la IA lo escribe, no solo señalar problemas después de realizar el commit.
  • Cobertura en todos tus asistentes. Los desarrolladores utilizan varias herramientas; un modelo de política debería regirlas todas.
  • Cumplimiento en el pipeline y en tiempo de ejecución. Comprobaciones en CI/CD que bloqueen las infracciones antes de la producción, además de la supervisión de cómo se comportan realmente las API, los servidores MCP y los agentes una vez implementados.
  • Priorización basada en la exposición real. Resultados clasificados según lo que es accesible y explotable, para que los equipos resuelvan primero lo que realmente importa.
  • Registros de auditoría claros. Registros de qué políticas se aplicaron a qué código, para el cumplimiento normativo y la respuesta ante incidentes.

Salt Code está diseñado para este flujo de trabajo. Su objetivo es lograr que el código generado por IA cumpla con las normas desde el momento en que se crea, no a posteriori. Salt Code conecta el motor de gobernanza de postura de Salt con las herramientas que los desarrolladores ya utilizan y aplica la seguridad desde el prompt hasta la producción:

  1. Descubra cada API, servidor MCP e integración de agentes de IA en todos los repositorios de código y entornos en la nube.
  2. Aplique durante la generación de código traduciendo las políticas de seguridad en reglas que guían a los asistentes de programación por IA en tiempo real.
  3. Gobierne en el pipeline validando las políticas en CI/CD y en las solicitudes de extracción (pull requests), bloqueando las infracciones antes de llegar a producción.
  4. Valide en tiempo de ejecución monitoreando las API, las integraciones MCP y los agentes en busca de infracciones de políticas, brechas de postura y actividad anómala.
  5. Remedie y mejore incorporando los hallazgos del tiempo de ejecución en los flujos de trabajo de los desarrolladores y en los propios asistentes de IA.

Salt Code incluye más de 140 políticas preconfiguradas que abarcan desde el Top 10 de seguridad de API de OWASP hasta el Top 10 de seguridad de MCP, además de sus propias reglas personalizadas. Funciona con Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, Codex, Gemini CLI, JetBrains y cualquier asistente de programación por IA que admita la configuración de servidores MCP.

Los equipos que deseen comenzar de inmediato pueden utilizar la versión gratuita de Salt Code. Se instala en unos 60 segundos, añade 40 políticas de seguridad que cubren la seguridad de API, seguridad de MCP, seguridad de LLM y cumplimiento de OpenAPI, y está activa desde el siguiente prompt. Según Salt, inyecta contexto de seguridad en la ventana de contexto del agente, por lo que su código nunca sale de su máquina. El plan empresarial añade paquetes de políticas personalizados, gestión a nivel de toda la organización, informes de seguridad en tiempo de prompt y SSO/SCIM.

Para verlo en acción, vea el seminario web bajo demanda Proteja el código escrito por IA antes de su despliegue: Salt Code, que incluye una demostración en vivo de Salt Code aplicando políticas en asistentes de programación por IA en tiempo real.

Preguntas frecuentes

¿Cómo se le pide a la IA que escriba código más seguro?

Indique los requisitos de seguridad en el prompt en lugar de solicitar solo la funcionalidad. Pida explícitamente validación de entradas, consultas parametrizadas, comprobaciones de autenticación y autorización, manejo seguro de tokens e identificadores, y que no se incluyan secretos codificados. Mantenga una biblioteca compartida de prompts validados para que todo el equipo parta de la misma base y utilice una herramienta que inyecte políticas de seguridad automáticamente para que la protección no dependa de la memoria.

¿Sigue siendo necesaria la revisión humana del código generado por IA?

Sí, pero de forma dirigida. Veracode descubrió que incluso el modelo con mejor rendimiento en sus pruebas de 2026 fallaba en una de cada tres tareas de seguridad. Centre la revisión humana en la autenticación y autorización, la criptografía, el manejo de datos sensibles y los nuevos endpoints, herramientas de agentes o servidores MCP, y deje que la automatización se encargue del resto.

¿Qué herramientas ayudan a asegurar el código generado por IA?

Un conjunto de capas: análisis estático (SAST) para detectar patrones inseguros, análisis de composición de software (SCA) para paquetes vulnerables o inexistentes, detección de secretos antes de la confirmación (commit), generación de SBOM para el seguimiento de componentes y una plataforma de gobernanza de código de IA como Salt Code, que aplica políticas dentro del propio asistente de programación.

¿Cómo se evita que los secretos terminen en el código generado por IA?

Nunca pegue credenciales reales en prompts o ejemplos de código. Haga referencia a los secretos desde un almacén o gestor de secretos, ejecute la detección de secretos en el IDE y como comprobación previa al commit y en la integración continua (CI), y audite los archivos de configuración de MCP, que según GitGuardian son una fuente creciente de filtración de credenciales. Si un secreto se filtra, rótelo inmediatamente en lugar de solo eliminarlo del último commit.

¿Debe el código generado por IA pasar por un proceso de revisión distinto al del código escrito por humanos?

Debe cumplir con el mismo estándar de seguridad, con comprobaciones adicionales adaptadas a los fallos comunes de la IA: verificación de paquetes, escaneo de secretos y una revisión más exhaustiva de las categorías de alto riesgo. Etiquetar los commits asistidos por IA hace que esto sea práctico, ya que permite dirigir esos cambios a las comprobaciones adecuadas y medir los resultados a lo largo del tiempo.

Nuestras últimas publicaciones