--- title: "Cómo proteger un servidor contra la vulnerabilidad HTTPoxy" description: "HTTPoxy es una vulnerabilidad que fue descubierta el 18 de julio de 2016 a la que, a pesar de todo el tiempo que ha transcurrido, aún no se le ha puesto solución definitiva. HTTPoxy afecta a aplicacio..." url: https://www.stackscale.com/es/blog/proteccion-vulnerabilidad-httpoxy/ date: 2016-07-22 modified: 2023-11-03 author: "Ángel Carrero" image: https://www.stackscale.com/wp-content/uploads/2019/12/httpoxy.png categories: ["Sistemas"] tags: ["Seguridad"] type: post lang: es --- # Cómo proteger un servidor contra la vulnerabilidad HTTPoxy **[HTTPoxy](https://httpoxy.org/) es una vulnerabilidad que fue descubierta el 18 de julio de 2016** a la que, a pesar de todo el tiempo que ha transcurrido, aún no se le ha puesto solución definitiva. HTTPoxy afecta a aplicaciones CGI escritas en PHP, Python y Go, entre otras. Mediante este vulnerabilidad un atacante puede forzar las [aplicaciones CGI](https://www.rfc-editor.org/rfc/rfc3875#section-4.1.18) vulnerables a enviar sus paquetes HTTP a un proxy intermedio controlado por los piratas informáticos. La causa de esta vulnerabilidad es una colisión entre nombres. Si un cliente envía una cabecera «*Proxy*», algunas implementaciones de CGI crean una variable de entorno «*HTTP_PROXY*» que anula la variable real del mismo nombre. Como resultado, si en la cabecera se envía el nombre de un proxy malintencionado, este podría interceptar las conexiones de la aplicación web a otros sistemas y, dependiendo del código, podría llegar incluso a tomar el control del servidor. ## Servidores y aplicaciones vulnerables a este problema HTTPoxy es una vulnerabilidad general que se encuentra en muchas implementaciones CGI. Para que una aplicación sea vulnerable debe cumplir algunos requisitos: - **Utilizar la variable HTTP_PROXY para configurar conexiones proxy**, ya sea en nuestro código o en cualquier librería de terceras personas que utilicemos. - **Hacer peticiones a los servicios utilizando HTTP**. Otras solicitudes realizadas por otros protocolos como HTTPS no serán vulnerables. - **Desarrollos donde se utilizan variables prefijadas con la cadena «HTTP_»**. Si quier saber si una implementación se está viendo afectada, puedes hacerlo mediante [el sitio para realizar estas comprobaciones](https://blog.luke.lol/) creado por Lucas Rehmann. ## Información específica del lenguaje Si hay un lenguaje que tiene más riesgo de ser susceptible a esta vulnerabilidad es, sin duda, PHP. ¿Por qué? Porque es uno de los más utilizados en la actualidad y sus implementaciones CGI son más comunes que en cualquier otro lenguaje. Además nos encontramos el uso del método «*getenv*» en muchas bibliotecas populares utilizadas para el desarrollo de aplicaciones. Otros [lenguajes de programación](https://www.stackscale.com/es/blog/top-10-lenguajes-programacion-2020/) que también pueden verse afectados son Python y Go. En este caso se trata de lenguajes que ofrecen una serie de métodos más seguros que en el caso de PHP. Aún así, si durante el desarrollo de la aplicación, en alguna parte del código leen la variable *HTTP_PROXY*, automáticamente se vuelven vulnerables de sufrir este tipo de problema. ## Cómo derrotar a la vulnerabilidad HTTPoxy Por suerte, HTTPoxy es relativamente fácil de solucionar. Se le puede poner remedio desde diferentes frentes, ya sea desde la capa del servidor o desde el propio código del CGI. - A nivel de las aplicaciones se puede ignorar la variable *HTTP_PROXY* cuando se están ejecutando en un entorno CGI. - Las aplicaciones o bibliotecas pueden utilizar una variable de entorno diferente para configurar las conexiones proxy. - A nivel de servidor se puede desarmar el encabezado Proxy recibido en las peticiones de los clientes. Si estamos utilizando alguna librería vulnerable, tenemos que actuar a nivel de servidor para solucionar el problema. Si, por el contrario, somos propietarios del código y nuestro proyecto se basa en la variable *HTTP_PROXY*, la solución sería utilizar otra variable alternativa que no entre en conflicto cuando se ejecuta en un entorno *CGI*. Por ejemplo, en el caso de Ruby se puede utilizar *CGI_HTTP_PROXY*. Otra solución a nivel de servidor es desactivar la cabecera *HTTP PROXY*. Esta última solución es lo que veremos a continuación. ## Eliminar la cabecera HTTP Proxy en Apache Si estás utilizando un servidor web [Apache](https://www.stackscale.com/es/blog/top-servidores-web/#Apache_HTTP_Server), puedes utilizar *mod_headers* para eliminar el encabezado de todas las peticiones. ### 1 Servidores Ubuntu y Debian Lo primero que hay que hacer es activar `mod_headers`. Para ello ejecutaremos lo siguiente: ``` sudo a2enmod headers ``` Después, abriremos el archivo de configuración: ``` sudo nano /etc/apache2/apache2.conf ``` En la parte inferior añadiremos: ``` RequestHeader unset Proxy early ``` Una vez hecho esto, guardamos los cambios y cerramos el archivo. Después revisaremos la configuración para asegurarnos de que no hay errores de sintaxis. ``` sudo apache2ctl configtest ``` Si no se han reportado errores, reiniciamos Apache. ``` sudo service apache2 restart ``` ### 2 Servidores CentOS y Fedora Bajo estos sistemas operativos el módulo `mod_headers` debería haber sido instalado por defecto cuando se instaló Apache. Para desactivar las cabeceras, hay que abrir el archivo de configuración. ``` sudo nano /etc/httpd/conf/httpd.conf ``` Casi al final del archivo, tenemos que añadir la siguiente línea: ``` RequestHeader unset Proxy early ``` Luego guardamos los cambios y cerramos el archivo. A continuación comprobamos que no se haya producido ningún error de sintaxis. ``` sudo apachectl configtest ``` Si todo ha ido bien, reiniciamos el servidor. ``` sudo service httpd restart ``` ## Eliminar las cabeceras HTTP Proxy con Nginx Después de ver cómo se hace en Apache, vamos a ver como realizar la misma acción en servidores que utilicen [Nginx](https://www.stackscale.com/es/blog/top-servidores-web/#Nginx). ### 1 Servidores con Ubuntu o Debian En estos sistemas operativos, los parámetros FastCGI están incluidos de forma habitual en los ficheros «*fastcgi_params*» o «*fastcgi_conf*». En ambos casos podemos desactivar la cabecera HTTP_PROXY. ``` echo 'fastcgi_param HTTP_PROXY "";' | sudo tee -a /etc/nginx/fastcgi.conf echo 'fastcgi_param HTTP_PROXY "";' | sudo tee -a /etc/nginx/fastcgi_params ``` También es recomendable desactivar esta cabecera cuando usemos Nginx como proxy convencional. En este caso también hay que ejecutar la siguiente instrucción: ``` echo 'proxy_set_header Proxy "";' | sudo tee -a /etc/nginx/proxy_params ``` Una vez realizados los cambios, nos aseguraremos de que no hemos cometido errores de sintaxis. ``` sudo nginx –t ``` Si todo ha ido bien, reiniciaremos el servidor. ``` sudo service nginx restart ``` ### 2 Servidores CentOS, RedHat y Fedora Nginx en sistemas [CentOS](https://www.stackscale.com/es/blog/centos-linux/) y Fedora también utiliza los mismos archivos que Debian y Ubuntu para desactivar estas cabeceras. Para desactivarlo, ejecutaremos lo siguiente: ``` echo 'fastcgi_param HTTP_PROXY "";' | sudo tee -a /etc/nginx/fastcgi.conf echo 'fastcgi_param HTTP_PROXY "";' | sudo tee -a /etc/nginx/fastcgi_params ``` Si usamos Nginx como proxy convencional, también deberíamos eliminar estas cabeceras. Para ello, ejecutaremos lo siguiente: ``` grep -r "proxy_pass" /etc/nginx ``` Como en los casos anteriores, revisaremos que no se hayan producido ningún error de sintaxis. ``` sudo nginx -t ``` Si todo ha ido correctamente, reiniciaremos el servidor. ``` sudo service nginx restart ``` ## Eliminar la cabecera HTTP Proxy con HAProxy Si estamos utilizando HAProxy para dirigir el tráfico de nuestras aplicaciones a los servidores, podemos eliminar esta cabecera antes de realizar el reenvío. Para ello tenemos que editar el archivo *haproxy.cfg*. ``` sudo nano /etc/haproxy/haproxy.cfg ``` Ahí debemos modificar las secciones «*frontend*», «*backend*» y «*listen*». ``` frontend www http-request del-header Proxy . . . backend web-backend http-request del-header Proxy . . . listen appname 0.0.0.0:80 http-request del-header Proxy . . . ``` Guardamos y cerramos el archivo; y revisamos que no se haya producido ningún error de sintaxis. ``` sudo haproxy -c -f /etc/haproxy/haproxy.cfg ``` Si todo ha ido bien, reiniciaremos el servicio. ``` sudo service haproxy restart ``` Solo necesitas seguir estos sencillos pasos para solucionar el problema de la vulnerabilidad HTTPoxy y disfrutar de unas aplicaciones más seguras. Previamente, no te olvides de realizar copia de seguridad de las configuraciones y datos.