Información blog

Linux, tutoriales, noticias, sistemas, redes y seguridad informática, entre otras cosas.

lunes, 26 de enero de 2015

TOR: The Onion Router

La privacidad es algo que obsesiona más y más a los usuarios, especialmente cuando cada día vemos escándalos de cyberespionaje mundial. Por ello mucha gente ha buscado formas de intentar navegar por Internet de forma anónima y aunque ningún método es infalible, hay uno de ellos especialmente famoso: Hablo claro está, de la red TOR.

La red TOR tiene cómo objetivo ocultar la ip del usuario además de proteger la información y la integridad de ésta. Este sistema de protección de integridad de datos, aunque ha demostrado ser eficaz tiene sus deficiencias, considerándose un método que no ha logrado del todo su objetivo de anonimato total. A diferencia del uso normal de Internet, ésta no es una red entre iguales sino que por un lado está el usuario de la red y por otro lado están los encaminadores que son los encargados de gestionar y administrar el acceso a los usuarios de esa red. Aunque la red TOR protege al usuario en muchos sentidos, si no se toman medidas de seguridad tales cómo la deshabilitación de cookies o la deshabilitación del historial, la navegación siempre dejaría restos que TOR no puede ocultar; También es recomendable usar el protocolo https para darle una capa más de protección a nuestra navegación.

La red TOR está compuesta por dos tipos de elemento:

  • OR(Onion Router): Hace de DNS y encaminador de red que se encarga de dirigir el paquete a su destino. Usan conexiones TLS entre sí y con los módulos OP, además siempre tienen sus conexiones abiertas y activas.
  • OP(Onion Point): Es el cliente TOR, el cual se encarga de enviar y recibir los mensajes a través de los puntos OR. Esto sería lo que usa el usuario final mediante la aplicación que se descarga desde la propia página del proyecto.
La conexión siempre empieza desde el OP, el cual calcula los puntos OR más adecuados por los que tiene que pasar para llegar a su destino. Una vez realizado dicho calculo, negocia la clave de cifrado entre cada uno de los puntos OR que van a proteger el paquete, creando tantas claves de cifrado cómo puntos OR; A partir de dicha negociación el paquete de datos que se va a enviar se va a cifrar primero con la clave negociada con el último punto OR, luego con el penúltimo y así sucesivamente cubriendo el paquete con distintas "capas" de cifrado que solo pueden ser quitadas por los OR correspondientes. El termino Onion (cebolla) nace del concepto de las capas que cubren dicho paquete.

Después sólo queda enviar el paquete al primer OR, el cual quitaría la última capa que se ha puesto, ya que se trata de la capa externa que cubre el paquete. Tras quitar esa capa, enviaría el paquete al siguiente OR que quitaría la siguiente y así hasta llegar al último OR, el cual quitaría la última capa que dejaría el paquete "desnudo" y legible para su destinatario, aunque con la peculiaridad de que éste no posee información alguna sobre el usuario que ha enviado el paquete en cuestión. He aquí un esquema muy simplificado de su funcionamiento:



Aún así, debido al gran revuelo que ha causado esta tecnología debido al amplio uso que tiene por parte de todo tipo de gente (desde ciberdelincuentes a gente que simplemente quiere sentirse menos vigilado), se han hecho numerosos estudios sobre ésta y se ha visto que hay modos de comprometer las comunicaciones, aunque estos requieren que se tome el control de varios encaminadores. TOR solo hace anónimo el tráfico TCP, cosa que consigue gracias al cliente TOR disponible en la página del proyecto, el cual hace la comunicación con los routers de forma transparente al usuario. De todas formas para tener una navegación segura por navegador, es recomendable usar firefox para redirigir el tráfico http y dns a SOCKS, ya que el resto de navegadores no incluyen dicha opción por defecto y se requieren herramientas de terceros para conseguirlo.


Un uso adicional que tiene la red TOR, es el acceso a la Deep Web, que es lo que denominaríamos cómo el lado oscuro de internet. Es la parte más oculta de internet que no se puede acceder desde buscadores cómo google, lo cual hace que sea el sitio preferido para alojar contenido poco cuestionable. De por sí, “Deep Web” no implica ilegalidad. Se define como profunda u oscura a toda aquella fracción de Internet que, por su “profundidad” en la estructura de los sitios web, o bien por su inaccesibilidad, resulta desconocida para los buscadores. TOR no posee relación directa con la esta parte oculta de internet, pero debido a que este sitio es el escondite favorito de aquellos que quieren vivir al margen de la la ley, el uso de TOR se ha hecho imprescindible en estos sitios. Eso por desgracia ha hecho que el proyecto haya recibido duras criticas y que los gobiernos hayan generado varios movimientos para intentar tener mayor control sobre esta red.

Dejando de lado la teoría, pasemos a un enfoque práctico. Imaginemos que queremos usar TOR, cómo lo hacemos? Lo primero que habría que hace sería dirigirse a la página del proyecto cuyo enlace dejo a continuación:


En la página en cuestión habría que descargarse el cliente TOR, el cual está disponible para Windows, Linux y MAC. En mi caso en particular lo he aplicado en Windows, pero el proceso para el resto de sistemas operativos es bastante parecido. Tras finalizar la instalación y ejecutar la aplicación debe aparecer algo cómo esto:


En la mayoría de los casos bastaría con darle al botón de "Conectar" aunque en caso de que haya un proxy y/o firewall, habría que contactar con el ISP o administrador de red. Una vez conectados tendría que aparecer una pantalla cómo la siguiente:



Cómo se puede ver es un firefox perfectamente configurado para funcionar con TOR; Ya tiene todo preconfigurado y ya podemos empezar a navegar por él. Ahora bien, cómo podemos saber si realmente navegamos anónimamente? Lo más fácil sería escribir en el buscador "What is my ip" y entrar en cualquier página que te aparezca en el buscador, la cual te mostrará una ip y una localización completamente distintas a las reales. Por ejemplo en mi caso:


Cómo os podréis imaginar no vivo en Dinamarca con lo que se puede decir que el uso del cliente TOR ha sido un exito. 

Ahora bien, ¿Deberían existir este tipo de herramientas de doble filo? Evidentemente es una herramienta que puede hacer que uno navegue con más tranquilidad, pero el saber que esta herramienta puede ser usada para cometer delitos hace que TOR sea bastante polémico. Japón por ejemplo ha bloqueado el acceso a dicha red mediante los propios proveedores de Internet, para que la gente no pueda cometer delitos con tanta facilidad, ¿Pero acaso sólo es una vía para realizar acciones ilícitas? Claramente no aunque dé la oportunidad a ello. Es por eso que cada uno que navegue por esta red debe hacerlo bajo su responsabilidad y sus propios principios éticos y morales.

martes, 20 de enero de 2015

Instalando y configurando owncloud en una raspberry pi nueva.

El proyecto raspberry pi es un fenómeno cuya popularidad ha ido creciendo hasta llegar a límites insospechados; Su crecimiento no parece que vaya a menguar a corto plazo, es más todo lo contrario y su precio, tamaño y funciones parecen haber a atraído a un amplio abanico de personas. Tras tanto hablar de dicho proyecto, es inevitable que uno no sienta curiosidad y finalmente adquiera una raspberri pi b+ con carcasa incluida.

Mi primera impresión de la placa es que su diseño y sus dimensiones la convierten en un objeto que se puede colocar prácticamente donde uno quiera, haciendo que pueda desempeñar más de una función dependiendo del momento y la necesidad. De momento, el sistema operativo que más me llama la atención por su flexibilidad, por la posibilidad de instalarle owncloud y por que está basado en Debian; es RASPBIAN. Aún así, los amantes de soluciones basadas en red hat tienen PIDORA cómo alternativa si lo desean. 

La descarga y grabación de la imagen apenas toma tiempo. En mi caso en pocos minutos ya tenía todo preparado para probar la distribución y se me presentaban dos opciones: 

La primera era acceder a su contenido mediante un teclado y ratón USB más una pantalla HDMI. Esta opción no es demasiado atractiva por el hecho de que el objetivo es poder acceder al dispositivo cómo si fuese un servidor, no un equipo de sobremesa, con lo para este caso es mucho más conveniente decantarse por la segunda opción, el acceso por ssh. 

El acceso por SSH es bien sencillo: Tan sólo es necesario encender la placa, tener la raspberry accesible en red y una herramienta para poder acceder por ssh. Desde la consola de cualquier distribución de Linux o mediante la herramienta putty desde Windows, se puede lograr dicho acceso. Para este caso en particular lo primero que habría que hacerle sería ponerle una ip estática a la placa para que ésta no dependa de un servidor DHCP para su correcto funcionamiento; Además con una ip fija siempre sabremos a qué dirección apuntar cuando queramos acceder a nuestra nube personal. Una vez preparada la base del entorno, comenzaría el proceso de instalación. 

Instalación

Desde la consola habría que hacer lo siguiente: 

Primero tocaría añadir los repositorios para instalar owncloud. Se puede instalar owncloud a mano, pero personalmente me ha parecido más eficiente este método.


  1. echo 'deb http://download.opensuse.org/repositories/isv:/ownCloud:/community/Debian_7.0/ /' >> /etc/apt/source.list.d/owncloud.list

Al ser una repositorio que no viene por defecto en raspbian, cada vez que queramos hacer una operación con los repositorios nos aparecerá un aviso en el que nos dirá que el repositorio no tiene clave. Para solucionar dicho problema, nos descargamos la clave del repositorio y lo añadimos al gestor de paquetes APT.

  1. wget http://downloads.opensuse.org/repositories/isv:owncloud:community/Debian_7.0/Release.key

apt-key add -<Release.key

Por supuesto, para que nuestro gestor de paquetes sepa qué paquetes hay disponibles con este repositorio, hay que actualizar dicho gestor mediante el comando:

apt-get update

Ahora que la lista de paquetes disponibles está actualizada, simplemente habría que escribir

apt-get install owncloud

Tras una pequeña espera, ya estaría el mini servidor owncloud listo, tan sólo a falta de instalarle la base de datos, pero antes de eso, yo recomiendo añadirle una pequeña capa de seguridad que cuesta muy poco tiempo y que puede ser de ayuda; Me refiero a habilitar el acceso por https a owncloud y que éste sea el protocolo de acceso por defecto, es decir, que no permita acceder por http a secas.

Este proceso es tan sencillo cómo escribir lo siguiente:

sudo a2enmod ssl
sudo a2ensite default-ssl
sudo service apache2 reload

Con esto ya estaría el protocolo https listo para ser usado, pero actualmente es posible acceder de las dos maneras a owncloud, por http y https. Para permitir tan sólo el acceso por https habría que entrar en la carpeta /var/www/owncloud. Allí editaremos un archivo de configuración que está oculto a primera vista; Si se hace un ls a secas no se verá, en cambio si se hace un ls -la veremos un fichero llamado .htaccess.

Dentro de éste fichero debería haber una sección llamada IfModule mod_rewrite.c tal que así:
<IfModule mod_rewrite.c>
RewriteEngine on
RewriteRule .* - [env=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
...
</IfModule>

En él, justo antes de </IfModule>, habría que añadir las siguientes líneas:

RewriteCond %{HTTPS} off
RewriteRule (.*) https://ip_del_servidor/owncloud/

Quedando algo cómo esto:

<IfModule mod_rewrite.c>
RewriteEngine on
RewriteRule .* - [env=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
...
...
RewriteCond %{HTTPS} off
RewriteRule (.*) https://192.168.10.5/owncloud/
</IfModule>


Una vez guardados los cambios y reiniciado el servidor apache, habría escribir en el navegador: ip_servidor/owncloud



Pantalla de inicio owncloud


Cómo veis no hay que poner https ni nada, ya que el servidor se encarga de automatizar esa parte. Ahora lo único que faltaría sería poner un usuario y una contraseña sólida y clickar el botón "Completar instalación" para que instale la base de datos. Esta parte tarda algo de tiempo debido a las limitaciones de la placa, tras finalizar el proceso tendría que aparecer la siguiente pantalla:

Pantalla de bienvenida postinstalación de base de datos

Simplemente es una pantalla que te anima a instalarte owncloud en otros dispositivos; Con tan solo cerrarla ya tendríamos nuestra pequeña nube lista para ser usada. Evidentemente hablamos de un dispositivo con ciertas limitaciones dadas sus dimensiones, pero es una herramienta útil para hacer pequeños experimentos. En este caso en particular, al hablar de una nube que por lo general estará encendida durante largos periodos de tiempo, yo recomiendo instalar disipadores a la placa (a poder se de cobre que la diferencia de precio de los de aluminio no es muy grande y compensa) y a ser posible un pequeño ventilador, ya que en caso contrario el procesador va a estar trabajando a temperaturas demasiado altas, haciendo que el tiempo de vida de la placa mengüe.

jueves, 15 de enero de 2015

Google no va a desarrollar más parches de seguridad para las versiones inferiores a la 4.4 'KitKat'




Sí, así es, Google no va a publicar por su cuenta más parches de seguridad para las versiones inferiores a ésta a menos de que la persona que reporte la vulnerabilidad les dé el correspondiente parche para solventarla. Eso de por sí podría no sonar muy escandalizador si no fuese por que más del 60% del mercado está dentro del colectivo que de un día para otro se han quedado sin soporte alguno. Android, indiscutible numero 1 de los sistemas operativos para móviles, ha dejado expuestos a alrededor de 900 millones de dispositivos sin siquiera molestarse en realizar un comunicado oficial al respecto. Esta información se ha dado a conocer gracias a un grupo de investigadores independientes que reportaron un fallo de seguridad en WebView (el componente gracias al cual se veían ver páginas web en chrome hasta Android 4.3). Este grupo recibió la siguiente respuesta:

“Si la versión afectada de WebView es anterior a 4.4 no desarrollamos parches de seguridad, aunque sí consideramos aceptar parches externos junto a los informes. Además de notificar a los OEMs no estaremos capacitados para realizar ninguna acción o tener en cuenta informes de seguridad que afecten a versiones anteriores a 4.4, si estos no están acompañados de un parche”
.

Esa noticia ha supuesto un grave descenso en la confianza puesta en Android. Dejando de lado la sensación de abandono que pueden sentir usuarios de a pie que pertenecen a dicho 60%, el sector corporativo se encuentra en un grave problema: Imaginemos que un empleado posee una tablet de dos años de antigüedad con información sensible (estadisticas, clientes, contactos, etc…). Las limitaciones del hardware de dicho dispositivos nos impiden actualizar su sistema operativo, ya que éste no podría ni arrancar siquiera y en caso de hacerlo apenas podría ejecutar operación alguna debido al gran consumo de recursos que poseen de base las últimas versiones de Android. ¿Qué puede hacer dicha persona frente a semejante situación? ¿Vivir bajo la premisa “No creo que me hackeen, eso solo les pasa a los que usan su dispositivo descuidadamente”? ¿Cambiar de tablet con su consiguiente gasto? Hay que tener en cuenta que las empresas grandes realizan importantes desembolsos económicos cada vez que cambian de Ordenadores, tablets, etc…

Dejando de lado el mundo empresarial, pongámonos en la piel de cualquier persona que no pertenezca al sector técnico. Una persona que usa el móvil para hablar por Whatsap, navegar por Internet y descargarse alguna que otra aplicación y/o juego. Posee un móvil relativamente nuevo (un año por ejemplo) con Android 4.2 y su hardware sí que puede soportar Android 4.4 sin ningún problema. Ahora acércate a dicha persona y dile que tiene que instalarse Android 4.4 y que el proceso no es tan simple cómo darle un botón y volver a la media hora con la nueva versión instalada y que además el instalar el nuevo sistema operativo supone la pérdida de la garantía; Probablemente esta persona te conteste que no se va a molestar en actualizar el móvil “¿Total quien me va a hackear a mí?”. Esa pregunta retórica, es formulada por una ingente cantidad de personas que, a pesar de ver todos los días en las noticias que el malware en dispositivos móviles (especialmente Android) está creciendo a un ritmo insospechado, piensan que eso nunca les va a pasar a ellos…

La verdad es que aunque seguramente esta noticia no llegue a muchas personas, Android acaba de de dejar en el olvido a más de la mitad de sus clientes; Clientes que han depositado su confianza en ellos. Para empezar dicha información debería haber sido divulgada en un comunicado oficial, y lo ideal (y lo correcto) habría sido que informasen de que en una fecha señalada, dejarían de desarrollar parches para versiones inferiores a la 4.4; Algo parecido a lo que hizo Microsoft con el fin del soporte de Windows XP.

Aún así, de todo esto puede llegar a salir algo bueno: Esto puede servir cómo toque de atención a los fabricantes de móviles (que ganan dinero por el hardware, no por el software); Fabricantes que a día de hoy venden muchos móviles con versiones obsoletas de Android en los móviles de gama media/baja que podrían soportar versiones superiores. Cierto, muchos móviles no serían capaces de soportar KitKat, pero al menos el hecho de que empiecen a usar versiones más actuales sería una señal de que vamos por el buen camino. Ahora bien, ¿Dichos fabricantes harán algo? Personalmente tengo mis dudas.


Visto lo visto tal vez no sea un disparate plantearse otras opciones con un soporte (en apariencia) más extendido, tales cómo Windows Phone, Tizen, Firefox Os o el inminente Ubuntu Touch cuyo éxito dependerá en su capacidad de adaptación a los mercados. 

miércoles, 14 de enero de 2015

Tunel inverso SSH

En ocasiones uno puede tener la necesidad de que le administren remotamente el equipo o servidor pero se carece de VPN alguna o de una redirección de puertos desde el router con la que dejar que la otra persona pueda entrar directamente al servidor. También puedes toparte con que el firewall esté bloqueando las conexiones entrantes al puerto ssh y que por cuestiones de seguridad no se abra bajo ninguna circunstancia.

A todos estos problemas existe una solución llamada túnel inverso por ssh el cual requiere que el servidor al que queremos acceder tenga openssh instalado y una servidor ssh al que tanto el servidor que se quiere administrar cómo la persona que quiere entrar en éste, tengan acceso. 

El túnel inverso consiste en conectar dos equipos entre sí por ssh con la peculiaridad de que requiere que el equipo al que se quiere tener acceso, sea el que se encargue de facilitar el acceso al otro. Es decir que si el equipo cliente no da el paso inicial, es imposible conectarse remotamente. Eso puede parecer poco práctico, pero puede evitar dificultades en muchas situaciones, ya que es muy habitual en la mayoría de los sitios que se tengan muy restringidas las conexiones desde exterior pero que haya vía libre para todas las conexiones salientes.

Lo ideal sería que el servidor ssh tuviese un usuario “enjaulado” para esta tarea. Dicho usuario solamente permitiría que se logueen con él pero no podría realizar acción alguna (el mero hecho de conectarse al otro equipo aún sin poder hacer acción alguna es suficiente para crear el túnel). En caso de no tener ningún usuario con esas características y no querer crear uno no pasaría nada, el túnel se puede realizar con cualquier tipo de usuario. De todas formas, lo que si que recomendaría encarecidamente sería que se usase un usuario sin permisos de super usuario para esta operación.

El proceso del túnel inverso solo requiere dos pasos muy sencillos. 
  • Paso 1:
Lo primero que tenemos que hacer es especificar desde el equipo final que abra una conexión inversa (-R) al puerto 10000 (o el que se quiera) hacia el localhost del equipo al que sí podemos acceder vía ssh, mediante el puerto que tengan habilitado para dicha conexión. Luego habría que poner un usuario valido del servidor ssh y su dirección ip (@ip). El puerto 10000 o el que se especifique en –R tiene que estar libre, ya que en caso contrario tendremos problemas. 

comando linux: 


ssh –R <source port>:<host destino>:<puerto destino> user@host

ejemplo: ssh -R 10000:127.0.0.1:22 tunel@<ip_servidor_ssh>

En caso de tener interfaz gráfica, para aquellos que prefieran utilizar putty debido a su amigable interfaz o debido al miedo a la consola, habría que hacer lo siguiente:

En la sección sesión que aparece por defecto habría que poner la ip del servidor ssh y su puerto.


Para crear el tunel remoto habría que acceder a la sección connection --> SSH --> Tunnels. Allí habría que poner cómo Source port, el puerto del equipo al que accederemos por ssh. En Destination simplemente habría que poner la ip localhost (127.0.0.1) y el puerto que tenemos habilitado para el acceso por ssh (por defecto el 22) separado con dos puntos, quedando así 127.0.0.1:22. Muy importante pulsar el botón Add antes de clickar en aceptar, ya que en caso contrario no se crearía el túnel.


  • Paso 2: 
Desde el servidor ssh habría que escribir simplemente lo siguiente

comando linux: 

ssh <user>@<localhost> –p <puerto usado para el tunel>

ejemplo: ssh root@127.0.0.1 –p 10000

Si tuviese interfaz gráfica y tuviésemos también miedo a la consola del servidor ssh, habrá que rellenar los parámetros tal y cómo aparecen en la siguiente pantalla y clickar en Open.




Y con esto ya estaríamos dentro del servidor que hasta ahora estaba “aislado” y sin posibilidades de gestionarlo remotamente; Requiere tener a una persona al otro lado para poder acceder al servidor, pero es una buena forma de evitar que configuren el firewall o el router para atender una necesidad puntual.


lunes, 12 de enero de 2015

Sencillo cortafuegos linux escrito en bash

He aquí un sencillo, pero funcional script de iptables llamado que permite que se pueda crear y modificar reglas de filtrado de iptables. Las variables que aparecen en el inicio serían las que almacenarían los puertos que se quieren abrir, ya que la política por defecto es que todo que sea INPUT se bloquee. En caso de que a uno le de miedo modificar a mano el script, puede ver/modificar las reglas de entrada/salida mediante "nombre_script.sh" change. Este script está preparado para funcionar en distribuciones basadas en Debian (Ubuntu, Elementary OS...), con lo que en caso de querer usarlo para distribuciones Red Hat habría que modificarlo un poco.

Espero que les sea útil. Por supuesto son libres de copiar, compartir y modificar el código.

  1. #!/bin/bash
  2. ### BEGIN INIT INFO
  3. # Provides:          iptables.sh
  4. # Required-Start:    $local_fs $remote_fs $network $syslog $named
  5. # Required-Stop:     $local_fs $remote_fs $network $syslog $named
  6. # Default-Start:     2 3 4 5
  7. # Default-Stop:      0 1 6
  8. ### END INIT INFO
  9. ###REGLAS APLICADAS AL KERNEL /etc/sysctl.conf###
  10. #net.ipv6.conf.all.disable_ipv6=1#
  11. #net.ipv4.ip_forward=1#
  12. #net.ipv4.tcp_syncookies=1#
  13. #net.ipv4.icmp_echo_ignore_broadcasts=1#
  14. #net.ipv4.conf.all.rp_filter=1#
  15. #net.ipv4.conf.all.accept_redirects=0#
  16. #net.ipv4.conf.all.log_martians=1#
  17. ######################################VARIABLES###################################
  18. ##VARIABLES MENU##
  19. OUTPUT=/tmp/output.tx$$
  20. INPUT=/tmp/input.sh$$
  21. >$OUTPUT
  22. trap "rm $INPUT; rm $OUTPUT; exit" SIGHUP SIGINT SIGTERM
  23. ##BLOQUEOS INPUT##
  24. #PUERTOS TCP DESTINO INPUT
  25. INTCPPORTD=(  )
  26. #PUERTOS TCP ORIGEN INPUT
  27. INTCPPORTS=( 20 21 22 80 443 )
  28. #PUERTOS UDP DESTINO INPUT
  29. INUDPPORTD=( 123 )
  30. #PUERTOS UDP ORIGEN INPUT
  31. INUDPPORTS=( 53 123 )
  32. ##BLOQUEOS OUTPUT##
  33. #PUERTOS TCP ORIGEN OUTPUT
  34. OTCPPORTS=( 31337 31338 31339 31340 )
  35. #PUERTOS UDP ORIGEN OUTPUT
  36. OUDPPORTS=(31337 31338 31339 31340)
  37. ##VARIABLES EXTRA
  38. #CONTADOR INTERFACES
  39. INTERFACES=$(ifconfig |grep eth |wc -l)
  40. #INTEFAZ
  41. I=0
  42. ##DATOS RED
  43. IP=0
  44. MASCARA=0
  45. ################################START############################
  46. Arrancar_cortafuegos()
  47. {
  48. ###POLITICAS GENERALES###
  49. iptables -F
  50. iptables -t nat -F
  51. iptables -t mangle -F
  52. iptables -P INPUT DROP
  53. iptables -P FORWARD DROP
  54. iptables -P OUTPUT ACCEPT
  55. #############################FILTER#########################
  56. INTERFACES=$((INTERFACES-1))
  57. while [ ${I} -le ${INTERFACES} ]
  58. do
  59. if [ $(cat /etc/issue |awk '{print $1}') == "Debian" ];
  60. then
  61.         IP=$(ifconfig eth${I} |grep "inet " |awk {'print $2'} |cut -d ":" -f 2)
  62.         MASCARA=$(ifconfig eth${I} |grep "inet " |awk {'print $4'} |cut -d ":" -f 2)
  63. else
  64.         IP=$(ifconfig eth${I} |grep "inet:" |awk {'print $2'} |cut -d ":" -f 2)
  65.         MASCARA=$(ifconfig eth${I} |grep "inet " |awk {'print $4'} |cut -d ":" -f 2)
  66. fi
  67. ###INPUT ACCEPT INTERNAL###
  68. iptables -A INPUT -p icmp --icmp-type echo-reply -m state --state ESTABLISHED -j ACCEPT
  69. #TCP INPUT
  70. if [ -n "${INTCPPORTD}" ];
  71. then
  72.         for i in "${INTCPPORTD[@]}"
  73.         do
  74.                 iptables -A INPUT -s ${IP}/${MASCARA} -p tcp --dport $i -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
  75.         done
  76. fi
  77. if [ -n "${INTCPPORTS}" ];
  78. then
  79.         for i in "${INTCPPORTS[@]}"
  80.         do
  81.                 iptables -A INPUT -p tcp --sport $i -m state --state ESTABLISHED,RELATED -j ACCEPT
  82.         done
  83. fi
  84. #UDP INPUT
  85. if [ -n "${INUDPPORTD}" ];
  86. then
  87.         for i in "${INUDPPORTD[@]}"
  88.         do
  89.                 iptables -A INPUT -s ${IP}/${MASCARA} -p udp --dport $i -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
  90.         done
  91. fi
  92. if [ -n "${INUDPPORTS}" ];
  93. then
  94.         for i in "${INUDPPORTS[@]}"
  95.         do
  96.                 iptables -A INPUT -p udp --sport $i -m state --state ESTABLISHED,RELATED -j ACCEPT
  97.         done
  98. fi
  99. ###OUTPUT BLOCK###
  100. #TCP OUTPUT
  101. if [ -n "${OTCPPORTS}" ];
  102. then
  103.         for i in "${OTCPPORTS[@]}"
  104.         do
  105.                 iptables -A OUTPUT -p tcp --sport $i -m state --state ESTABLISHED,RELATED -j DROP
  106.         done
  107. fi
  108. #UDP OUTPUT
  109. if [ -n "${OUDPPORTS}" ];
  110. then
  111.         for i in "${OUDPPORTS[@]}"
  112.         do
  113.                 iptables -A OUTPUT -p udp --sport $i -m state --state ESTABLISHED,RELATED -j DROP
  114.         done
  115. fi
  116. I=$((I+1))
  117. done
  118. ###REGLAS EXTRA###
  119. #DNS
  120. cat /etc/resolv.conf |awk {'print $2'} > /tmp/dns.txt
  121. while read LINEA
  122. do
  123.         iptables -A INPUT -s ${LINEA} -m state --state NEW,ESTABLISHED,RELATED -p udp --sport 53 -j ACCEPT
  124. done < /tmp/dns.txt
  125. rm /tmp/dns.txt
  126. #LOOPBACK
  127. iptables -A INPUT -i lo -j ACCEPT
  128. }
  129. ################################STOP############################
  130. Parar_cortafuegos()
  131. {
  132. #POLITICAS GENERALES ABIERTAS
  133. iptables -F
  134. iptables -t nat -F
  135. iptables -t mangle -F
  136. iptables -P INPUT ACCEPT
  137. iptables -P FORWARD ACCEPT
  138. iptables -P OUTPUT ACCEPT
  139. }
  140. Modificacion_puertos()
  141. {
  142. FINAL=n
  143. clear
  144. echo "Los puertos actuales seran eliminados y sustituidos por los introducidos ahora:"
  145. while [ ${FINAL} !'y' ];
  146. do
  147.         echo "Introduce un puerto:"
  148.         read PUERTO
  149.         if [ ${PUERTO} -gt 0 ];
  150.         then
  151.                 echo ${PUERTO} >> /tmp/puertos.txt
  152.         else
  153.                 echo "NO ES UN VALOR VALIDO!"
  154.         fi
  155.         echo "Quiere añadir otro puerto?[s/n]"
  156.         read RESPUESTA
  157.         if [ ${RESPUESTA} !'s' ];
  158.         then
  159.                 FINAL='y'
  160.         fi
  161. done
  162. }
  163. ENTRANTES_TCP_DESTINO()
  164. {
  165. dialog --clear \
  166. --title "Puertos TCP de destino ENTRANTES abiertos" \
  167. --menu "" 15 50 4 \
  168. LEER "Consultar puertos configurados" \
  169. MODIFICAR "Modificacion de puertos" \
  170. ATRAS "Volver al menu principal" \
  171. SALIDA "Salir"  2>"${INPUT}"
  172. menuitem=$(<"${INPUT}")
  173. case $menuitem in
  174. LEER)
  175. if [ -n "${INTCPPORTD}" ];
  176. then
  177.         echo "                     LISTADO DE PUERTOS" >> /tmp/temporal.txt
  178.         for i in "${INTCPPORTD[@]}"
  179.         do
  180.         echo "                          PUERTO:${i}" >> /tmp/temporal.txt
  181.         done
  182.         clear
  183.         cat /tmp/temporal.txt
  184.         rm /tmp/temporal.txt
  185.         echo " Pulse cualquier tecla para continuar"
  186.         read
  187. else
  188.         dialog --clear \
  189.         --title "Vacio" \
  190.         --msgbox "No hay puertos configurados" 5 50
  191. fi
  192. ENTRANTES_TCP_DESTINO
  193. ;;
  194. MODIFICAR)
  195. Modificacion_puertos
  196. SENTENCIA="INTCPPORTD=("
  197. while read LINEA
  198. do
  199.         SENTENCIA="${SENTENCIA} ${LINEA}"
  200. done < /tmp/puertos.txt
  201. SENTENCIA="${SENTENCIA} )"
  202. LINEAORIG=$(head -n 30 /etc/init.d/iptables.sh |grep INTCPPORTD)
  203. sed -i "s/${LINEAORIG}/${SENTENCIA}/g" /etc/init.d/iptables.sh
  204. rm /tmp/puertos.txt
  205. dialog --clear \
  206.  --title "Cambios realizados" \
  207.  --msgbox "Cambios implantados, reiniciar cortafuegos para aplicar la nueva config" 5 80
  208. ENTRANTES_TCP_DESTINO
  209. ;;
  210. ATRAS) Cambiar_parametros;;
  211. SALIDA) exit 0;;
  212. esac
  213. }
  214. ENTRANTES_TCP_ORIGEN()
  215. {
  216. dialog --clear \
  217. --title "Puertos TCP de origen ENTRANTES abiertos" \
  218. --menu "" 15 50 4 \
  219. LEER "Consultar puertos configurados" \
  220. MODIFICAR "Modificacion de puertos" \
  221. ATRAS "Volver al menu principal" \
  222. SALIDA "Salir"  2>"${INPUT}"
  223. menuitem=$(<"${INPUT}")
  224. case $menuitem in
  225. LEER)
  226. if [ -n "${INTCPPORTS}" ];
  227. then
  228.         echo "                     LISTADO DE PUERTOS" >> /tmp/temporal.txt
  229.         for i in "${INTCPPORTS[@]}"
  230.         do
  231.         echo "                          PUERTO:${i}" >> /tmp/temporal.txt
  232.         done
  233.         clear
  234.         cat /tmp/temporal.txt
  235.         rm /tmp/temporal.txt
  236.         echo " Pulse cualquier tecla para continuar"
  237.         read
  238. else
  239.         dialog --clear \
  240.         --title "Vacio" \
  241.         --msgbox "No hay puertos configurados" 5 50
  242. fi
  243. ENTRANTES_TCP_ORIGEN
  244. ;;
  245. MODIFICAR)
  246. Modificacion_puertos
  247. SENTENCIA="INTCPPORTS=("
  248. while read LINEA
  249. do
  250.         SENTENCIA="${SENTENCIA} ${LINEA}"
  251. done < /tmp/puertos.txt
  252. SENTENCIA="${SENTENCIA} )"
  253. LINEAORIG=$(head -n 32 /etc/init.d/iptables.sh |grep INTCPPORTS)
  254. sed -i "s/${LINEAORIG}/${SENTENCIA}/g" /etc/init.d/iptables.sh
  255. rm /tmp/puertos.txt
  256. dialog --clear \
  257.  --title "Cambios realizados" \
  258.  --msgbox "Cambios implantados, reiniciar cortafuegos para aplicar la nueva config" 5 80
  259. ENTRANTES_TCP_ORIGEN
  260. ;;
  261. ATRAS) Cambiar_parametros;;
  262. SALIDA) exit 0;;
  263. esac
  264. }
  265. ENTRANTES_UDP_DESTINO()
  266. {
  267. dialog --clear \
  268. --title "Puertos UDP de destino ENTRANTES abiertos" \
  269. --menu "" 15 50 4 \
  270. LEER "Consultar puertos configurados" \
  271. MODIFICAR "Modificacion de puertos" \
  272. ATRAS "Volver al menu principal" \
  273. SALIDA "Salir"  2>"${INPUT}"
  274. menuitem=$(<"${INPUT}")
  275. case $menuitem in
  276. LEER)
  277. if [ -n "${INUDPPORTD}" ];
  278. then
  279.         echo "                     LISTADO DE PUERTOS" >> /tmp/temporal.txt
  280.         for i in "${INUDPPORTD[@]}"
  281.         do
  282.         echo "                          PUERTO:${i}" >> /tmp/temporal.txt
  283.         done
  284.         clear
  285.         cat /tmp/temporal.txt
  286.         rm /tmp/temporal.txt
  287.         echo " Pulse cualquier tecla para continuar"
  288.         read
  289. else
  290.         dialog --clear \
  291.         --title "Vacio" \
  292.         --msgbox "No hay puertos configurados" 5 50
  293. fi
  294. ENTRANTES_UDP_DESTINO
  295. ;;
  296. MODIFICAR)
  297. Modificacion_puertos
  298. SENTENCIA="INUDPPORTD=("
  299. while read LINEA
  300. do
  301.         SENTENCIA="${SENTENCIA} ${LINEA}"
  302. done < /tmp/puertos.txt
  303. SENTENCIA="${SENTENCIA} )"
  304. LINEAORIG=$(head -n 34 /etc/init.d/iptables.sh |grep INUDPPORTD)
  305. sed -i "s/${LINEAORIG}/${SENTENCIA}/g" /etc/init.d/iptables.sh
  306. rm /tmp/puertos.txt
  307. dialog --clear \
  308.  --title "Cambios realizados" \
  309.  --msgbox "Cambios implantados, reiniciar cortafuegos para aplicar la nueva config" 5 80
  310. ENTRANTES_UDP_DESTINO
  311. ;;
  312. ATRAS) Cambiar_parametros;;
  313. SALIDA) exit 0;;
  314. esac
  315. }
  316. ENTRANTES_UDP_ORIGEN()
  317. {
  318. dialog --clear \
  319. --title "Puertos UDP de origen ENTRANTES abiertos" \
  320. --menu "" 15 50 4 \
  321. LEER "Consultar puertos configurados" \
  322. MODIFICAR "Modificacion de puertos" \
  323. ATRAS "Volver al menu principal" \
  324. SALIDA "Salir"  2>"${INPUT}"
  325. menuitem=$(<"${INPUT}")
  326. case $menuitem in
  327. LEER)
  328. if [ -n "${INUDPPORTS}" ];
  329. then
  330.         echo "                     LISTADO DE PUERTOS" >> /tmp/temporal.txt
  331.         for i in "${INUDPPORTS[@]}"
  332.         do
  333.         echo "                          PUERTO:${i}" >> /tmp/temporal.txt
  334.         done
  335.         clear
  336.         cat /tmp/temporal.txt
  337.         rm /tmp/temporal.txt
  338.         echo " Pulse cualquier tecla para continuar"
  339.         read
  340. else
  341.         dialog --clear \
  342.         --title "Vacio" \
  343.         --msgbox "No hay puertos configurados" 5 50
  344. fi
  345. ENTRANTES_UDP_ORIGEN
  346. ;;
  347. MODIFICAR)
  348. Modificacion_puertos
  349. SENTENCIA="INUDPPORTS=("
  350. while read LINEA
  351. do
  352.         SENTENCIA="${SENTENCIA} ${LINEA}"
  353. done < /tmp/puertos.txt
  354. SENTENCIA="${SENTENCIA} )"
  355. LINEAORIG=$(head -n 36 /etc/init.d/iptables.sh |grep INUDPPORTS)
  356. sed -i "s/${LINEAORIG}/${SENTENCIA}/g" /etc/init.d/iptables.sh
  357. rm /tmp/puertos.txt
  358. dialog --clear \
  359.  --title "Cambios realizados" \
  360.  --msgbox "Cambios implantados, reiniciar cortafuegos para aplicar la nueva config" 5 80
  361. ENTRANTES_UDP_ORIGEN
  362. ;;
  363. ATRAS) Cambiar_parametros;;
  364. SALIDA) exit 0;;
  365. esac
  366. }
  367. SALIENTES_TCP_ORIGEN()
  368. {
  369. dialog --clear \
  370. --title "Puertos TCP de origen SALIENTES abiertos" \
  371. --menu "" 15 50 4 \
  372. LEER "Consultar puertos configurados" \
  373. MODIFICAR "Modificacion de puertos" \
  374. ATRAS "Volver al menu principal" \
  375. SALIDA "Salir"  2>"${INPUT}"
  376. menuitem=$(<"${INPUT}")
  377. case $menuitem in
  378. LEER)
  379. if [ -n "${OTCPPORTS}" ];
  380. then
  381.         echo "                     LISTADO DE PUERTOS" >> /tmp/temporal.txt
  382.         for i in "${OTCPPORTS[@]}"
  383.         do
  384.         echo "                          PUERTO:${i}" >> /tmp/temporal.txt
  385.         done
  386.         clear
  387.         cat /tmp/temporal.txt
  388.         rm /tmp/temporal.txt
  389.         echo " Pulse cualquier tecla para continuar"
  390.         read
  391. else
  392.         dialog --clear \
  393.         --title "Vacio" \
  394.         --msgbox "No hay puertos configurados" 5 50
  395. fi
  396. SALIENTES_TCP_ORIGEN
  397. ;;
  398. MODIFICAR)
  399. Modificacion_puertos
  400. SENTENCIA="OTCPPORTS=("
  401. while read LINEA
  402. do
  403.         SENTENCIA="${SENTENCIA} ${LINEA}"
  404. done < /tmp/puertos.txt
  405. SENTENCIA="${SENTENCIA} )"
  406. LINEAORIG=$(head -n 40 /etc/init.d/iptables.sh |grep OTCPPORTS)
  407. sed -i "s/${LINEAORIG}/${SENTENCIA}/g" /etc/init.d/iptables.sh
  408. rm /tmp/puertos.txt
  409. dialog --clear \
  410.  --title "Cambios realizados" \
  411.  --msgbox "Cambios implantados, reiniciar cortafuegos para aplicar la nueva config" 5 80
  412. SALIENTES_TCP_ORIGEN
  413. ;;
  414. ATRAS) Cambiar_parametros;;
  415. SALIDA) exit 0;;
  416. esac
  417. }
  418. SALIENTES_UDP_ORIGEN()
  419. {
  420. dialog --clear \
  421. --title "Puertos UDP de origen SALIENTES abiertos" \
  422. --menu "" 15 50 4 \
  423. LEER "Consultar puertos configurados" \
  424. MODIFICAR "Modificacion de puertos" \
  425. ATRAS "Volver al menu principal" \
  426. SALIDA "Salir"  2>"${INPUT}"
  427. menuitem=$(<"${INPUT}")
  428. case $menuitem in
  429. LEER)
  430. if [ -n "${OUDPPORTS}" ];
  431. then
  432.         echo "                     LISTADO DE PUERTOS" >> /tmp/temporal.txt
  433.         for i in "${OUDPPORTS[@]}"
  434.         do
  435.         echo "                          PUERTO:${i}" >> /tmp/temporal.txt
  436.         done
  437.         clear
  438.         cat /tmp/temporal.txt
  439.         rm /tmp/temporal.txt
  440.         echo " Pulse cualquier tecla para continuar"
  441.         read
  442. else
  443.         dialog --clear \
  444.         --title "Vacio" \
  445.         --msgbox "No hay puertos configurados" 5 50
  446. fi
  447. SALIENTES_UDP_ORIGEN
  448. ;;
  449. MODIFICAR)
  450. Modificacion_puertos
  451. SENTENCIA="OUDPPORTS=("
  452. while read LINEA
  453. do
  454.         SENTENCIA="${SENTENCIA} ${LINEA}"
  455. done < /tmp/puertos.txt
  456. SENTENCIA="${SENTENCIA} )"
  457. LINEAORIG=$(head -n 42 /etc/init.d/iptables.sh |grep OUDPPORTS)
  458. sed -i "s/${LINEAORIG}/${SENTENCIA}/g" /etc/init.d/iptables.sh
  459. rm /tmp/puertos.txt
  460. dialog --clear \
  461.  --title "Cambios realizados" \
  462.  --msgbox "Cambios implantados, reiniciar cortafuegos para aplicar la nueva config" 5 80
  463. SALIENTES_UDP_ORIGEN
  464. ;;
  465. ATRAS) Cambiar_parametros;;
  466. SALIDA) exit 0;;
  467. esac
  468. }
  469. Cambiar_parametros()
  470. {
  471. dialog --clear \
  472. --title "Parametros cortafuegos" \
  473. --menu "" 15 100 7 \
  474. TCPDESTENT "Puertos TCP de destino ENTRANTES" \
  475. TCPORIGENT "Puertos TCP de origen ENTRANTES" \
  476. UDPDESTENT "Puertos UDP de destino ENTRANTES" \
  477. UDPORIGENT "Puertos UDP de origen ENTRANTES" \
  478. TCPORIGSAL "Puertos TCP de origen SALIENTES" \
  479. UDPORIGSAL "Puertos UDP de origen SALIENTES" \
  480. SALIDA "Salir" 2>"${INPUT}"
  481. menuitem=$(<"${INPUT}")
  482. case $menuitem in
  483.         TCPDESTENT) ENTRANTES_TCP_DESTINO;;
  484.         TCPORIGENT) ENTRANTES_TCP_ORIGEN;;
  485.         UDPDESTENT) ENTRANTES_UDP_DESTINO;;
  486.         UDPORIGENT) ENTRANTES_UDP_ORIGEN;;
  487.         TCPORIGSAL) SALIENTES_TCP_ORIGEN;;
  488.         UDPORIGSAL) SALIENTES_UDP_ORIGEN;;
  489.         SALIDA) exit 0;;
  490. esac
  491. }
  492. #SECUENCIA
  493. case $1 in
  494. start)
  495. Arrancar_cortafuegos
  496. ;;
  497. stop)
  498. Parar_cortafuegos
  499. ;;
  500. restart)
  501. $0 stop
  502. $0 start
  503. ;;
  504. change)
  505. Cambiar_parametros
  506. ;;
  507. *)
  508. echo "Usage /etc/init.d/iptables.sh start|stop|restart|change"
  509. ;;
  510. esac
  511. exit 0