¿Es más seguro lo que nadie más usa? Seguridad por oscuridad en tiempos de IA
Circula la idea de que, si la IA encuentra fallos leyendo código, lo más seguro es escribir tu propio servidor y no enseñarlo. Tiene una parte de verdad, pero la conclusión no se sostiene. Qué te da lo que nadie más usa, qué no te da y en qué capa sí compensa hacerlo a medida.
En este artículo 7 secciones
Circula una idea que suena a sentido común: si la IA encuentra fallos leyendo código, que no tenga código que leer. Deja de usar el servidor web que usa medio internet, escribe el tuyo en un lenguaje seguro y no lo enseñes a nadie. Sin código público no hay 0days públicos, y sin 0days no hay que parchear cada semana.
Tiene una parte de verdad, y por eso convence. Pero la conclusión no se sostiene, y la pregunta de fondo —¿es más seguro lo que nadie más usa?— me la hacen a menudo con otras palabras: «¿una web a medida es más segura que un WordPress?». Así que vale la pena separar lo que es cierto de lo que no.

Ilustración generada con IA para este artículo; no representa ningún servidor ni sistema real.
Lo que tiene de cierto
La monocultura es un riesgo real. Cuando millones de máquinas ejecutan el mismo programa, un solo fallo puede afectar a muchísimas de ellas a la vez. No es una idea nueva: en 1988 el gusano de Morris se extendió precisamente porque miles de máquinas Unix ejecutaban el mismo sendmail y el mismo fingerd. Hoy pasa igual con los plugins de WordPress: sale un fallo en uno popular y en cuestión de horas hay robots probándolo en todas las webs que lo tienen.
Lo que no usas no te lo pueden atacar con ese fallo. Quien escanea internet en masa con un exploit concreto busca el producto que lo tiene. Si tu web no lo usa, ese barrido le pasa de largo. Para una pyme, que sufre sobre todo ataques oportunistas y no dirigidos, eso cuenta.
La IA abarata buscar fallos en código público. No es una suposición. Los dos equipos que encontraron PHP2Shell en octubre contaron que buena parte de la búsqueda y del exploit la hicieron con modelos de IA.
Un lenguaje con seguridad de memoria es mejor que C. Rust y Go reducen mucho una familia entera de fallos —desbordamientos de búfer, memoria usada después de liberarla— que son justo los que más vulnerabilidades críticas han dado en los servidores escritos en C.
Hasta aquí, todo bien. El problema está en el salto que viene después.
Lo que no te da
| La idea | Lo que pasa en la práctica |
|---|---|
| «No tendrá 0days conocidos» | No tener fallos publicados no demuestra que el programa se haya revisado ni que sea seguro. |
| «Sin código, una IA no puede analizarlo» | Muchos fallos de HTTP se encuentran desde fuera, sin ver el código. |
| «En Rust o Go no habrá fallos» | El lenguaje reduce mucho los fallos de memoria, pero no evita los de lógica. |
| «Así no hay que parchear cada semana» | Hay que parchear igual todo lo que hay debajo, y además mantener lo tuyo. |
| «El problema es el servidor web» | No es la única puerta: la aplicación también lo es, y cambiar de servidor no la cierra. |
Sin fallos publicados no es lo mismo que sin fallos. Un servidor web popular tiene muchísimos ojos encima, fuzzing continuo y un proceso para avisar y publicar parches. Uno propio tiene a las dos o tres personas que lo escribieron. Que de un programa no se conozca ningún fallo puede querer decir que es bueno o que nadie lo ha mirado, y desde fuera no hay forma de distinguirlo.
El código no hace falta para atacar. El request smuggling, que James Kettle volvió a poner en primer plano en 2019, se descubre con pruebas desde fuera: se envían peticiones ambiguas y se observa cómo las interpretan los distintos servidores de la cadena. La IA abarata ese trabajo igual que abarata leer código. Y el binario no siempre se queda dentro: una copia de seguridad o una imagen de Docker publicada por error bastan para que deje de ser secreto.
El lenguaje no conoce el protocolo. HTTP está lleno de casos límite que no tienen nada que ver con la memoria: dos cabeceras que dicen cosas distintas sobre la longitud del cuerpo, rutas con ../ codificado de varias formas, conexiones que se reutilizan. En octubre de 2023, el ataque Rapid Reset contra HTTP/2 afectó a distintas implementaciones del protocolo, incluida la de Go. Era un fallo de diseño del protocolo, no del lenguaje. Y Rust o Go tampoco blindan del todo la memoria cuando entra código unsafe, una librería en C o una dependencia con fallos.
Construir sobre hyper o net/http es razonable; justificarlo por el secreto, no. Un servicio en Go o en Rust que atiende HTTP con esas librerías no está reinventando un servidor web, y puede ser una buena decisión por muchos motivos. Pero esas librerías son públicas y la IA las lee igual. Lo que no se sostiene es elegirlas, o escribir tu propio servidor, porque así el código será secreto: lo único secreto será la capa tuya, que es la que menos revisión tiene.
El servidor web no es la única puerta. La aplicación también puede ser la puerta de entrada: una inyección, un permiso mal comprobado, un formulario que deja subir lo que no debe, una contraseña reutilizada. Cambiar de servidor no toca nada de eso.
Kerckhoffs ya lo dijo en 1883
Auguste Kerckhoffs, un lingüista y criptógrafo holandés, publicó en 1883 una lista de condiciones para que un sistema de cifrado militar fuera fiable. La segunda dice, más o menos, que el sistema no debe exigir el secreto y que tiene que poder caer en manos del enemigo sin que eso sea un problema. El secreto tiene que estar en la clave, no en el mecanismo.
Eso no significa que esconder cosas sea malo. Significa que tu seguridad no puede depender de que no se sepan. Ocultar la versión del servidor, no anunciar qué tecnología usas o que tu aplicación sea única son capas extra, y suman. El problema empieza cuando son la estrategia: el día que alguien vea dentro —y alguien acaba viendo dentro—, no queda nada detrás.
La IA no cambia este principio, y no solo juega en un lado. El 1 de noviembre de 2024, Google anunció que su agente Big Sleep había encontrado un fallo explotable en SQLite. Lo encontró en el código de desarrollo, y se corrigió antes de que llegara a ninguna versión publicada. Es la otra cara: la misma IA que busca fallos en el código público ayuda a quien lo mantiene a cerrarlos antes. Esa misma ayuda puedes usarla con tu código privado, pero tienes que meterla tú en el proceso de revisión.
Dónde sí tiene sentido lo propio
La pregunta útil no es «estándar o propio», sino en qué capa.
En la infraestructura, lo estándar suele ser la mejor opción. Servidor web, TLS, criptografía, sistema operativo, el propio lenguaje. Son piezas muy difíciles de hacer bien, que no te diferencian de nadie y en las que un fallo lo expone todo. Ahí lo que quieres es lo más usado, lo más revisado y lo más fácil de actualizar, con lo mínimo cargado.
En la aplicación, lo propio puede tener ventaja. Una web hecha a medida no está expuesta cuando sale el fallo de un plugin que tienen cien mil webs, porque no tiene ese plugin. Es un argumento real a favor del desarrollo a medida, y lo uso con clientes, pero con tres matices que hay que decir siempre:
- No te saca del radar. Los robots no solo prueban fallos de productos concretos: también prueban inyecciones SQL genéricas, rutas expuestas como
/.envo/backup.zip, contraseñas débiles y dependencias comunes. Todo eso le llega igual a una web a medida. - Lo a medida se apoya en algo estándar. Un framework, PHP, el servidor web, las librerías. Esa base hay que actualizarla igual: PHP2Shell no distinguía entre un WordPress y una web a medida, porque el fallo estaba en PHP.
- Lo que hagas mal es solo tuyo. Con un plugin popular, cuando aparece un fallo hay un proceso de avisos y actualizaciones. Con tu código, organizar las revisiones y tener un canal para que te avisen depende de ti. Lo a medida reduce la exposición a los exploits de productos que no usas, pero te obliga a revisar tu código como si alguien fuera a mirarlo.
En casa
Esta web está hecha a medida, sobre CodeIgniter y PHP, y no la cambiaría por un gestor de contenidos genérico. Pero el servidor web que la sirve es uno de los de siempre, y cuando salió PHP2Shell me tocó actualizar exactamente igual que a cualquiera con WordPress. Lo propio está arriba, donde está lo que hace distinta a la web. Lo de abajo es lo más aburrido y más mantenido que he encontrado.
Qué hacer, en corto
Si te ha tentado la idea de librarte del servidor web, lo que de verdad reduce el riesgo es esto:
- Quita lo que no usas. Módulos cargados por defecto, versiones antiguas de PHP instaladas «por si acaso», plugins desactivados que siguen en el disco. Lo que no está, no se puede atacar.
- Ten un proceso para actualizar. Que los parches de seguridad del sistema lleguen solos, y que esté claro quién actualiza el resto. Es lo de «No necesito mantenimiento web»: una web no se rompe un día concreto, se va quedando atrás.
- Pon delante un servicio de protección, bien configurado. Un WAF que filtre el escaneo masivo antes de que llegue a tu servidor. No lo para todo —lo poco que se cuela también hay que aguantarlo, como conté con un DDoS visto desde PHP-FPM—, pero quita de en medio la mayor parte del ruido.
- Revisa la aplicación, que es por donde entran. Permisos, formularios, subidas de archivos, contraseñas y accesos. Ahí es donde lo propio necesita más ojos, no menos.
- Usa la oscuridad como capa, nunca como muro. No anunciar versiones está bien. Contar con que nadie va a mirar, no.
Y si alguien te propone escribir tu propio servidor web para estar más seguro, pregúntale quién lo va a mantener dentro de cinco años.
Si necesitas una mano
Si estás decidiendo entre una web a medida y un gestor de contenidos, o tienes una web y no sabes bien qué tiene cargado, quién la actualiza o por dónde podría entrar alguien, puedo ayudarte. Llevo más de veinte años haciendo y manteniendo webs, a medida y en WordPress, y la respuesta casi nunca es «todo propio» ni «todo estándar», sino saber qué va en cada capa. Escríbeme y lo vemos.
Preguntas frecuentes
¿Es más segura una web a medida que un WordPress?
Frente a los exploits de productos concretos, suele estar menos expuesta: cuando sale un fallo en un plugin popular, los robots lo prueban en todas las webs que lo tienen, y una web a medida no lo tiene. Pero no queda fuera del radar: los ataques automáticos también prueban inyecciones, rutas expuestas y contraseñas débiles, y revisar sus propios fallos depende de quien la mantiene. Y las dos dependen de una base común, como PHP o el servidor web, que hay que actualizar igual.
¿Qué es la seguridad por oscuridad?
Confiar en que un sistema es seguro porque nadie sabe cómo funciona por dentro. Como capa extra suma, por ejemplo no anunciar la versión del servidor. Como estrategia falla, porque el día que alguien ve dentro no queda nada detrás. El principio de Kerckhoffs, de 1883, dice que un sistema tiene que poder caer en manos del enemigo sin que eso sea un problema.
¿Puede una IA encontrar fallos en un programa sin tener su código?
Sí. Muchos fallos de los servidores web se encuentran desde fuera, enviando peticiones ambiguas o malformadas y observando cómo responde el servidor. El request smuggling se descubre así. La IA abarata ese trabajo igual que abarata leer código.
¿Escribir el servidor en Rust o Go lo hace seguro?
Reduce mucho los fallos de memoria, que son muchos de los más graves en programas escritos en C, aunque no los elimina del todo si entra código unsafe o una librería en C. Lo que no evita son los fallos de lógica del protocolo: el ataque Rapid Reset contra HTTP/2, en 2023, afectó también a la implementación de Go.
¿Te ha resultado útil o quieres comentar algo?
Hablemos →