Inicio/Blog/Investigación de vulnerabilidades
Investigación de vulnerabilidadesPublicado · Actualizado ⚡ 15 min de lectura

Deja de desplegar basura de IA: la checklist de 25 puntos, sin adornos, que de verdad necesitas

Una guía de DevSecOps exhaustiva y sin rodeos para proteger el código generado por LLM antes de que haga saltar por los aires tu entorno de producción.

VG
Vladyslav Gusarov
DevSecOps Lead en Bryxe
La checklist definitiva de seguridad del código generado por IA: 25 cosas que verificar antes de desplegarlo [2026] [Auditoría]

Mira, la IA escribe ya la mitad de tu base de código. Está bien. Es rápida y te quita de encima el boilerplate. Pero dejemos de fingir que sabe cómo es una arquitectura segura. Cuando dejas que un LLM vomite un montón de Node o Python y lo mandas a producción a lo loco, estás construyendo una bomba. ¿Quieres una brecha? Sigue confiando a ciegas en el autocompletado.

Esto no es teoría. Este año he auditado suficiente basura generada por IA como para saber exactamente en qué se equivoca. Hardcodea secretos. Se inventa API que no existen. Ignora por completo las protecciones contra SSRF. En resumen: si no verificas lo que escribió el bot, el que responde cuando llegue el ransomware eres tú.

Esta es la checklist definitiva de seguridad del código generado por IA. 25 cosas que tienes que comprobar sí o sí antes de hacer merge de ese pull request.

Autenticación y autorización (la puerta principal)

A la IA le encanta construir autenticación a medida. No se lo permitas nunca.

1. Credenciales hardcodeadas

La IA suelta las API keys en texto plano sin más. Elimínalas.

pythonCódigo fuente
# Bad
api_key = "sk-live-12345"
# Good
import os
api_key = os.environ.get("API_KEY")

2. Validación de JWT rota

Se salta la verificación de la firma porque es perezosa.

javascriptCódigo fuente
// Bad
const payload = jwt.decode(token);
// Good
const payload = jwt.verify(token, process.env.JWT_SECRET, { algorithms: ['HS256'] });

3. Falta de control de acceso basado en roles

Los endpoints de la IA dejan pasar por defecto a cualquiera que tenga un token.

pythonCódigo fuente
# Bad
@app.route('/admin/delete')
def delete_user():
# Good
@app.route('/admin/delete')
@require_role('ADMIN')
def delete_user():

4. Hashing de contraseñas débil

MD5 está muerto. Dile a la IA que deje de usarlo.

pythonCódigo fuente
# Bad
hash = hashlib.md5(password).hexdigest()
# Good
hash = bcrypt.hashpw(password.encode(), bcrypt.gensalt())

5. Insecure Direct Object Reference (IDOR)

Que conozcan el ID no significa que el registro sea suyo.

javascriptCódigo fuente
// Bad
db.users.find({ id: req.params.id })
// Good
db.users.find({ id: req.params.id, owner_id: req.user.id })

Validación de entrada (no te fíes de nada)

Mira, lo he visto cien veces. Los LLM dan por hecho que los usuarios son buena gente. Los usuarios no son buena gente.

6. SQL injection

Sí, la IA sigue escribiendo strings SQL en crudo en 2026.

javascriptCódigo fuente
// Bad
db.execute(`SELECT * FROM users WHERE name = '${req.body.name}'`);
// Good
db.execute('SELECT * FROM users WHERE name = ?', [req.body.name]);

7. Cross-Site Scripting (XSS)

React suele salvarte, pero dangerouslySetInnerHTML es la forma favorita de la IA de dispararse en el pie.

javascriptCódigo fuente
// Bad
<div dangerouslySetInnerHTML={{ __html: userInput }} />
// Good
import DOMPurify from 'dompurify';
<div dangerouslySetInnerHTML={{ __html: DOMPurify.sanitize(userInput) }} />

8. Command injection

No dejes que la entrada del usuario toque una shell.

pythonCódigo fuente
# Bad
os.system(f"ping {user_ip}")
# Good
subprocess.run(["ping", "-c", "4", user_ip], check=True)

9. Server-Side Request Forgery (SSRF)

La IA hará fetch de cualquier URL que le dé el usuario.

pythonCódigo fuente
# Bad
requests.get(user_provided_url)
# Good
if is_safe_url(user_provided_url):
    requests.get(user_provided_url, timeout=5)

10. Path traversal

Deja de permitirles leer /etc/passwd.

javascriptCódigo fuente
// Bad
fs.readFile(path.join(__dirname, req.query.file));
// Good
const safePath = path.resolve(__dirname, 'public', path.basename(req.query.file));

Protección de datos (deja de filtrar)

11. PII en texto plano

Cifra números de la seguridad social, emails, lo que sea.

pythonCódigo fuente
# Bad
db.save({"ssn": user_ssn})
# Good
db.save({"ssn": encrypt_kms(user_ssn)})

12. Mensajes de error demasiado detallados

No escupas stack traces al frontend.

javascriptCódigo fuente
// Bad
res.status(500).send(err.stack);
// Good
res.status(500).send("Internal Server Error");

13. Secretos en los logs

A la IA le encanta console.log(req.body).

javascriptCódigo fuente
// Bad
console.log("User config:", config);
// Good
const safeConfig = omit(config, ['password', 'token']);
console.log("User config:", safeConfig);

14. Aleatoriedad insegura

Math.random() no sirve para criptografía.

javascriptCódigo fuente
// Bad
const resetToken = Math.random().toString(36);
// Good
const resetToken = crypto.randomBytes(32).toString('hex');

15. Faltan cabeceras de seguridad

Añade HSTS, CSP, todo el paquete.

javascriptCódigo fuente
// Bad
app.use(cors());
// Good
const helmet = require('helmet');
app.use(helmet());

Seguridad de API y red (tapa los agujeros)

16. Sin rate limiting

Las API sin rate limits son simples objetivos de DDoS.

javascriptCódigo fuente
// Bad
app.post('/login', loginHandler);
// Good
const limiter = rateLimit({ windowMs: 15 * 60 * 1000, max: 100 });
app.post('/login', limiter, loginHandler);

17. Deserialización insegura

Pickle y YAML son armas cargadas.

pythonCódigo fuente
# Bad
data = yaml.load(user_input)
# Good
data = yaml.safe_load(user_input)

18. CORS permisivo

* no es un origen aceptable.

javascriptCódigo fuente
// Bad
app.use(cors({ origin: '*' }));
// Good
app.use(cors({ origin: 'https://myapp.com' }));

19. Protocolos en texto claro

Fuerza TLS en todas partes.

pythonCódigo fuente
# Bad
url = "http://api.internal.svc"
# Good
url = "https://api.internal.svc"

20. Introspección de GraphQL

Desactívala en producción o te harán scraping.

javascriptCódigo fuente
// Bad
const server = new ApolloServer({ typeDefs, resolvers });
// Good
const server = new ApolloServer({ typeDefs, resolvers, introspection: false });

Infraestructura y despliegue (ciérralo todo)

21. Contenedores con demasiados privilegios

Root en Docker es un mal chiste.

dockerfileCódigo fuente
# Bad
USER root
# Good
USER appuser

22. Imágenes base desactualizadas

Deja de hacer pull de node:latest.

dockerfileCódigo fuente
# Bad
FROM python:3
# Good
FROM python:3.11-slim@sha256:abcd...

23. Permisos de nube hardcodeados

La IA escribirá Action: "*" en las políticas de IAM.

jsonCódigo fuente
// Bad
{"Effect": "Allow", "Action": "s3:*", "Resource": "*"}
// Good
{"Effect": "Allow", "Action": ["s3:GetObject"], "Resource": "arn:aws:s3:::my-bucket/*"}

24. Puertos de depuración expuestos

No enlaces la depuración a 0.0.0.0.

jsonCódigo fuente
// Bad
"start": "node --inspect=0.0.0.0 index.js"
// Good
"start": "node index.js"

25. Dependencias sin fijar

Yarn o NPM, fija las versiones exactas.

jsonCódigo fuente
// Bad
"express": "^4.0.0"
// Good
"express": "4.18.2"

Deja de hacerlo a mano

Mira, puedes repasar esta checklist de seguridad del código generado por IA a mano en cada PR, pero es un desperdicio de horas de ingeniería. Bryxe automatiza las 25 comprobaciones directamente en tu pipeline de CI. Escanea la salida del LLM, marca el código chapucero y aplica estándares reales de DevSecOps antes de que nada llegue a producción. Deja de confiar en el bot y empieza a verificar los bits.

DEFENSA AUTOMATIZADA

No esperes a un exploit para auditar tu código

Revisa los riesgos de código compatibles, los secretos expuestos y los hallazgos en dependencias con Bryxe Shield. Verifica las correcciones en tu aplicación antes del lanzamiento.

¿Necesitas un siguiente paso práctico? Explora las guías de seguridad o lee nuestra política editorial y de fuentes.

Investigación de seguridad recomendada