Mundo Informático

Hoy vamos a hablar de una herramienta llamada “hping“. Esta herramienta es un generador y analizador de paquetes TCP/IP. ¿Qué significa esto? Básicamente que podemos generar paquetes TCP/IP manipulados para que lleven la información que nosotros queramos. Normalmente es una herramienta que se utiliza para realizar auditorias de seguridad y testear redes y firewalls.

Como siempre para instalarla, al menos en Ubuntu, simplemente con echas mano de los repositorios tendremos suficiente. En este caso instalaremos “hping3” que es la última versión de esta herramienta, así que teclearemos lo siguiente en la consola:

sudo aptitude install hping3

Como siempre, después de instalarlo, iremos a la página del “man” correspondiente para ojear un poco las posibilidades que nos ofrece. Como se puede ver la página correspondiente nos ofrece varias utilidades como son:

- Probar las reglas de un firewall.
- Escaneo de puertos avanzado.
- Probar el rendimiento de una red utilizando diferentes protocolos, tamaños de paquetes, TOS y fragmentación.
- Descubrir el MTU de un camino.
- Transferir archivos a través incluso de un firewall con unas reglas muy restrictivas.
- Realizar un traceroute con diferentes protocolos.
- Uso como Firewalk.
- Descubrir un sistema operativo remoto.
- Realizar auditorias en la pila TCP/IP.
- Muchos otros.

Supongo que si alguno se ha leído el post anterior sobre NMap, se habrá percatado de que también realiza algunas de estas funciones, lo cual es lógico, ya que NMap es una implementación de todas estas funciones reunidas. Es por así decirlo, como una capa por encima. Pero, la ventaja que nos da bajar al escalón inferior es que hay cosas que podemos hacer con “hping” que no podemos hacer con NMap. A partir de aquí, voy a comentar como hacer varias cosas interesantes con “hping” y veremos como nos sorprende.

El primer uso que le podemos dar es como herramienta “ping“, con alguna pequeña diferencia sobre la información que nos brinda:

ping -c 1 192.168.1.1

PING 192.168.1.1 (192.168.1.1) 56(84) bytes of data.
64 bytes from 192.168.1.1: icmp_seq=1 ttl=255 time=0.631 ms
— 192.168.1.1 ping statistics —
1 packets transmitted, 1 received, 0% packet loss, time 3000ms
rtt min/avg/max/mdev = 0.594 ms

sudo hping3 -c 1 192.168.1.1

HPING 192.168.1.1 (eth0 192.168.1.1): NO FLAGS are set, 40 headers + 0 data bytes
len=46 ip=192.168.1.1 ttl=255 DF id=0 sport=0 flags=RA seq=0 win=0 rtt=0.6 ms
--- 192.168.1.1 hping statistic ---
1 packets transmitted, 1 packets received, 0% packet loss
round-trip min/avg/max = 0.5 ms

Como podéis ver la información es casi la misma, pero si nos fijamos, el “hping” nos devuelve un dato más que es el de “flags” que aunque ahora no sabemos a que corresponde lo vamos a ver más adelante.

El segundo uso que le vamos a dar es como escaner de puertos, es decir, imitando a NMap, y para esto es para lo que nos va a servir el campo “flags” comentado antes. Me temo que aquí para entender este apartado, se necesitan unos pequeños conocimientos sobre el funcionamiento del protocolo TCP. A grandes rasgos para el que no los tenga, solo decir que, TCP es un protocolo para comunicar dos o más máquinas. Es un protocolo orientado a conexión en el que los ordenadores se intercambian mensajes para saber el estado de cada uno y iniciar un intercambio de datos. (A groso modo, no os metáis mucho conmigo aquellos que lo conozcáis.)

Bien, pues algunos posibles mensajes que se intercambian pueden ser, están sacados de la RFC0793 que la tenéis aquí en español:

- URG:  Hace significativo el campo “Puntero urgente“
- ACK:  Hace significativo el campo “Número de acuse de recibo“
- PSH:  Función de “Entregar datos inmediatamente” (‘push’)
- RST:  Reiniciar (‘Reset’) la conexión
- SYN:  Sincronizar (‘Synchronize’) los números de secuencia
- FIN:  Últimos datos del emisor

Pues nada vamos a escanear. Es caso más trivial sería comprobar si un puerto esta abierto:

sudo hping3 -S 127.0.0.1 -p 80

HPING 127.0.0.1 (lo 127.0.0.1): S set, 40 headers + 0 data bytes
len=44 ip=127.0.0.1 ttl=64 DF id=0 sport=80 flags=SA seq=0 win=32792 rtt=0.2 ms

Como podéis ver si tenemos un servidor web lanzado, como es el caso, el valor de “flags” es “SA” lo que significa que ha respondido con un “SYS/ACK” que significa que esta abierto. Si paráramos el servidor veríamos lo siguiente tras ejecutar la misma instrucción:

len=40 ip=127.0.0.1 ttl=64 DF id=0 sport=80 flags=RA seq=0 win=0 rtt=0.1 ms

Aquí el valor de “flags” es “RA“, que es el “RST/ACK” lo que significa que esta cerrado.

Os voy a poner otro ejemplo más que será para escanear un rango de puertos, pero para más tipos os recomiendo que os arremanguéis un poquito y probéis, porque “hping” os ofrece un gran abanico de posibilidades. Sobre todo, aquellos que tengáis unas pequeñas nociones sobre TCP os recomiendo que probéis poniendo vosotros las banderas de los paquetes, es decir, “SYS“, “FIN” o “ACK” para ver como responden vuestros puertos y vuestros firewalls. Ya veréis como es una ventaja poder cambiar esto a vuestro antojo. Ahora, el ejemplo de escaneo de un rango de puertos.

sudo hping3 –scan ‘1-100′ 127.0.0.1

El tercer uso que le podemos dar a “hping” es emplearlo como el comando “traceroute“. que para el que no lo lo sepa, básicamente lo que hace es ver el camino que recorre un paquete desde un origen a un fin, enviando paquetes consecutivos incrementando su TTL o tiempo de vida. Evidentemente, esto es mucho más fácil hacerlo con el comando “traceroute” que con “hping“, ya que esta automatizado y nosotros lo vamos a tener que realizar a mano, pero de nuevo el esfuerzo queda compensado por la posibilidad de asignar las banderas (“flags“) a nuestra elección.

Existen dos formas de realizar esto, con el parámetro “-t” donde especificamos nosotros el valor de TTL que deseamos, o con el parámetro “-z” que que hace que cada vez que pulsemos la combinación de teclas “Ctrl+z” se incremente el TTL. Un ejemplo para realizar las dos ejecuciones sería el siguiente:

sudo hping3 -t 1 192.168.1.3

sudo hping3 -z 192.168.1.3

Y por último, pero no menos importante, enviar paquetes. Alguno pensara, pues vaya, eso se puede hacer con muchos programas. Bien, subamos unas lineas y recordemos como empezaba el post, “…podemos generar paquetes TCP/IP manipulados…“. Hasta ahora hemos manipulado las banderas de estos paquetes, podíamos haber manipulado sus tamaños, pero una de las cosas mas destacables, es que podemos manipular sus ip’s y los puertos de las conexiones, lo cual es muy interesante para falsificar tráfico en la red. Es decir, podemos enviar paquetes a una red donde la dirección de origen no sea la de nuestro ordenador.

Voy a mostraros un ejemplo. Vamos a generar tráfico en la red desde un ordenados con IP = 192.168.1.65, este ordenados no existe realmente, pero vamos a probar. Para comprobar esto, como lo voy a hacer en mi ordenado voy a arrancar el “Wireshark” para capturar paquetes y ver el resultado. También el que quiera puede usar “tcpdump“, el que os sea mas cómodo. Para hacerlo, el interfaz de captura será el de “loopback” o “lo“. Ejecutaremos lo siguiente:

sudo hping3 -a 192.168.1.65 -t 123 -s 100 -p 80 127.0.0.1

-a: Dirección origen.

-t: Valor del TTL.

-s: Puerto origen.

-p: Puerto destino.

<host>: Dirección de destino.

Paquetes falseados

Como se puede ver en la imagen, los paquetes generados no llevan la dirección IP de mi ordenador, que es 192.168.1.2, si no que llevan la que le hemos puesto en “hping“. Ni que decir tiene, que si hacéis esto y analizáis los paquetes más a fondo en el Wiresark, veréis que todas las direcciones MAC están a cero, pero no todos los log’s registran las MAC’s.

Bueno, hasta aquí hemos llegado hoy. Si tenési dudas o comentarios o más ideas interesantes sobre como utilizar la herramienta os animo a comentarlo. Nos vemos.

Hace un mes más o menos os hable de NMap, un escaner de puertos con el cual podíamos comprobar aquellos puertos que teníamos abiertos en nuestras máquinas. Si alguno lo probó, comprobaría que aunque tuviera casi todo cerrado, como debería ser, algunos puertos estaban abiertos, además, si tenía algún servicio corriendo para su uso personal, estos también estarían abiertos. Con NMap sabíamos hasta aquí.

Hoy os traigo una herramienta para conocer más cosas del exterior, es decir, de los que se intentan conectar a nosotros o escanear nuestro ordenador o servidor en busca de una posible entrada. La herramienta se llama “IPPL“, y es una herramienta que crea logs que luego podemos consultar de los intentos de conexión a nuestro ordenador. ¿Por qué puede esto ser interesante? Si tenemos servicios abiertos, por ejemplo, sabremos quien esta intentando conectar con ellos, si nos han realizado un escaneo de puertos y registraremos cualquier intento de conexión. Evidentemente, no hay ni punto de comparación entre las conexiones a un ordenador de escritorio y un servidor, pero para practicar un poco nos servirá uno de escritorio.

Lo primero es hacernos con el programa. Como siempre, yo me remito a Ubuntu, donde el “ippl” forma parte de los repositorios. Así que con una simple instrucción podemos instalarlo:

sudo aptitude install ippl

Tras esto, “ippl” estará instalado en nuestro sistema y solo tendremos que configurarlo a nuestro gusto.

El “ippl” tres opciones básicas:

-h: Muestra la ayuda.

-n: Ejecuta como no demonio.

-c: Para indicar el fichero de configuración.

“Ippl” ya trae una configuración por defecto. El fichero de configuración se encuentra en “/etc/ippl.conf“. Personalmente, prefiero hacerme diferentes ficheros de configuración en vez de modificar el por defecto, de este modo con el parámetro “-c” de “ippl” puedo realizar logs a la medida, aunque evidentemente también se puede realizar uno muy grande en el que estén todas las conexiones y filtrarlos con otras herramientas como “grep” o “tail” o, una tercera opción, establecer filtrados en el fichero de configuración del “ippl“, eso a gusto de cada uno. Para pasarle nuestro propio fichero de configuración a “ippl” al ejecutarlo utilizaríamos la siguiente instrucción:

sudo ippl -c fichero.conf

Ahora vamos a ver un poco el fichero de configuración. Como ya he comentado viene uno por defecto en el que esta escrito casi todo lo necesario, pero en muchos casos comentado. Así que para realizar modificaciones, en muchos de los casos, bastará con descomentar o comentar aquellas lineas que nos sean útiles. Yo me voy a centrar en los puntos más importantes para no aburrir y aquel que este más interesado puede jugar un poco con el fichero de configuración.

La primera sección de la que voy a hablar es la de “Protocols logged“. Aquí señalaremos los protocolos de los que queramos que quede registro. Se nos quedará una linea de la siguiente manera:

run icmp tcp

Creo que es obvio que de este modo quedaría registro de conexiones con paquetes tipo “icmp” y “tcp“, pero no “udp” por ejemplo. Existen cuatro valores posibles para los protocolos, “tcp“, “icmp“, “udp” y “all“. Los tres primeros se corresponden con el nombre y el últimos los engloba a todos.

La siguiente sección que vamos a ver es la de “Log in a file“. Si vamos a utilizar “ippl” en un ordenador con mucho volumen de tráfico es mucho mejor que el log se cree en un fichero y no saliendo por la consola simplemente, sobretodo de cara a analizarlo posteriormente. Para esto bastará con tener descomentada la linea siguiente para indicarle el destino:

log-in all /directorio/fichero.log

Una gran ventaja, es que se pueden clasificar los logs en distintos ficheros, es decir, si estamos capturando varios tipos de protocolos, podemos hacer que cada uno se almacene en un fichero. Por poner un ejemplo con “tcp” y “udp” esto quedaría algo así:

log-in udp /directorio/udp.log

log-in tcp /directorio/tcp.log

Obviamente esto es una gran ventaja a la hora de clasificar y analizar el tráfico. Otra sección que nos ayudará a esto es la de “Logging format“. En esta sección especificaremos el tipo de detalle que tendrá el log. Existen tres tipos:

short: Fecha, hora, protocolo, IP entrante.

normal: Fecha, hora, protocolo, puerto, IP entrante. Esta es la forma por defecto.

detailed: Lo mismo que normal, pero muestra origen y destino de las conexiones y sus puertos.

El modo de poner esto en el fichero de configuración sería:

logformat detailed all

Existen varias opciones más para retocar y especificar más el tipo de tráfico del que queremos dejar constancia, pero no tiene mucho sentido entrar aquí más en detalle. Así que os remito al fichero de configuración por defecto para verlas. Y por supuesto, si tenéis alguna duda podéis preguntar en los comentarios.

Otro detalle más sobre “ippl” es que lo podemos usar como una aplicación normal y corriente o como demonio. La forma más cómoda, obviamente, es como demonio, pero para la pequeña prueba que os voy mostrar a continuación yo lo voy a utilizar como aplicación por practicidad a la hora de pegar los resultados aquí, ya que en este modo saca los resultados por pantalla.

Bueno, empecemos con un pequeña prueba. En ella voy a seguir los siguientes pasos, realizar una conexión al puerto 80, realizar una conexión ftp, realizar un conexión telnet y realizar un escaneado de puertos con NMap.

Las instrucciones que he ejecutado son las siguientes:

sudo ippl -n

links 127.0.0.1
ftp 127.0.0.1
telnet 127.0.0.1
nmap 127.0.0.1

Y el resultado obtenido, excluyendo la gran mayoría del “nmap” por extensión es el siguiente:

Jan 22 13:34:47 IP Protocols Logger: started.
Jan 22 13:35:15 www connection attempt from 127.0.0.1
Jan 22 13:35:29 ftp connection attempt from 127.0.0.1
Jan 22 13:36:00 telnet connection attempt from unknown@localhost [127.0.0.1]
Jan 22 13:36:00 auth connection attempt from 127.0.0.1
Jan 22 13:36:00 last message repeated 1 time(s)
Jan 22 13:36:20 www connection attempt from 127.0.0.1
Jan 22 13:36:20 ssh connection attempt from 127.0.0.1
Jan 22 13:36:20 domain connection attempt from 127.0.0.1
Jan 22 13:36:20 www connection attempt from 127.0.0.1
Jan 22 13:36:20 port 3389 connection attempt from 127.0.0.1
Jan 22 13:36:20 ldaps connection attempt from 127.0.0.1
…

Como se puede ver son fácilmente reconocibles todas las actividades que he realizado.

La única pega que le he encontrado, que por otra parte es normal, es que el escaneo de “nmap” en modo silencioso no deja ningún registro, pero era de esperar.

Bueno, ya sabéis si tenéis alguna duda preguntad .Espero que os sirva aunque solo sea para entreteneros un rato. Nos vemos.

Hoy vamos a hacer una chuleta de como cifrar nuestros documentos y demás utilizando algo que todos aquellos que trabajamos con linux tenemos muy a mano, OpenSSL.

Casi todos lo usuarios de linux, sobre todo aquellos que lo llevéis en un portátil y uséis la conexión wifi, tendréis instalado OpenSLL, pero por lo menos en mi caso,suelo dejar que el sistema lo utilice automáticamente para las conexiones a redes inalámbricas y yo, no lo utilizaba para nada. Pero como la curiosidad a veces nos juega malas pasadas, el otro día me decidí a investigar si servía para algo más y se podía utilizar de forma manual, y vaya si se puede. Se pueden hacer un montón de cosas con él, eso si, todas ellas relacionadas con el cifrado y descifrado. Así que el siguiente artículo es una especie de recetario y de apuntes de como utilizarlo para no tener que llevarlo todo en la cabeza, que no se la vuestra, pero la mía se despista con facilidad. Por supuesto, todo lo que se va a comentar a continuación se va a hacer desde la consola.

Antes de empezar una recomendación, mirad bien lo que escribís porque ,al menos a mi, no me van los cursores para desplazarme sobre lo escrito. así que si tengo que rectificar algo me toca borrar y reescribir.

Acceder a openssl: Tecleamos en la consola

~# openssl

Nos saldrá un promt con el siguiente formato.

OpenSSL>

Salir de openssl:

OpenSSL> quit

OpenSSL> q

OpenSSL> exit

Ayuda:

OpenSSL> ?

Nos mostrará una lista de los comandos disponibles.

– Cifrado simétrico –

Encriptar

DES:

OpenSSL> enc -des -in entrada.txt -pass pass:contraseña -out salidaDes.txt

AES:

OpenSSL> enc -aes128 -in entrada.txt -pass pass:contraseña -out salidaAes.txt

Desencriptar

DES:

OpenSSL> enc -d -des -in salidaDes.txt -pass pass:contraseña -out salidaDes2.txt

AES:

OpenSSL> enc -d -aes128 -in salidaAes.txt -pass pass:contraseña -out salidaAes2.txt

– Cifrado asimétrico –

Generar llave del algoritmo asimétrico RSA: Vamos a generar una llave privada de 1020 bits

OpenSSL> genrsa -out privada1.key 1024

Cifrar la clave privada con DES para evitar su uso fraudulento:

OpenSSL> genrsa -out privada2.key -passout pass:contraseña -des 1024

Se realiza este cifrado porque la clave privada se genera como un fichero de texto que cualquiera podría leer, para evitar esto la ciframos.

Generar claves públicas derivadas:

OpenSSL> rsa in privada1.key -pubout -out publica1.key

OpenSSL> rsa in privada2.key -pubout -out publica2.key -passin pass:contraseña

Encriptar

OpenSSL> rsautl -pubin -encrypt -in entrada.txt -out salidaRsa.txt -inkey publica1.key

Desencriptar:

OpenSSL> rsautl -decrypt -in salidaRsa.txt -out salidaRsa2.txt -inkey privada1.key

– Funciones hash –

Generar:

OpenSSL> dgst -md5 -out entrada.hsh entrada.txt

– Firma digital –

Generar un par de claves RSA como hemos visto anteriormente:

OpenSSL> genrsa -out privada.key 1024

OpenSSL> rsa in privada.key -pubout -out publica.key

Firmar el archivo digitalmente:

OpenSSL> dgst -c -sign privada.key -out firmado.sig entrada.txt

El archivo “firmado.sig” contendrá la firma digital en formato binario.

Verificar firma:

OpenSSL> dgst -c -verify publica.key -signature firmado.sig entrada.txt

OpenSSl mostrará un “Verified OK” si todo ha sido correcto, o un “Verification Failure” si algo ha fallado.

Conversión de firmas binarias a texto: Como ya he dicho antes las firmas generadas tienen un formato binario, con lo cual para su envió por correo, por ejemplo, es interesantes pasarlas a texto. Así que vamos a generar una versión en base64.

OpenSSL> base64 -in firmado.sig -out firmado.b64

Como puedes observar, el fichero generado es legible y fácilmente agregable a cualquier texto.

Conversión de firmas en texto a binarias: Para verificar las firmas que nos han llegado en modo texto tendremos que pasarlas a modo binario antes.

OpenSSL> base64 -d -in firmado.b64 -out firmado1.sig

– Certificados digitales –

Crear certificado y archivo de configuración de la autoridad certificadora (“CA”):

Generar un par de claves RSA como hemos visto anteriormente:

OpenSSL> genrsa -out CAprivada.key 1024

OpenSSL> rsa in CAprivada.key -pubout -out CApublica.key

Crear el archivo de configuración:

Crear el archivo “CAconfig.conf” con el siguiente contenido:

[ req ]
default_bits            =  1024
default_keyfile         =  CAprivada.key
distinguished_name      =  req_distinguished_name
attributes              =  req_attributes
x509_extensions         =  v3_ca
dirstring_type          =  nobmp
[ req_distinguished_name ]
countryName             = Identificador del País (2 letras)
countryName_default     = MX
countryName_min         = 2
countryName_max         = 2
localityName            = Localidad (ej., ciudad)
organizationalUnitName  = Nombre de unidad organizacional (ej., oficina)
commonName              = Nombre común (ej., TU nombre)
commonName_max          = 64
emailAddress            = Dirección de correo electrónico
emailAddress_max        = 40
[ req_attributes ]
challengePassword       = Contraseña para “challenge”
challengePassword_min   = 4
challengePassword_max   = 20
[ v3_ca ]
subjectKeyIdentifier    = hash
authorityKeyIdentifier  = keyid:always,issuer:always
basicConstraints        = CA:true

Crear el certificado de la autoridad:

OpenSSL> req -new -key CApriv.key -out ca.cer -config CAconfig.cnf -x509 -days 3650

Generar claves para un usuario:

OpenSSL> genrsa -out privadaUser.key 1024

OpenSSL> rsa in privadaUser.key -pubout -out publicaUser.key

Generar un requerimiento del certificado para este usuario:

OpenSSL> req -new -key privadaUser.key –out req.pem -config CAconfig.cnf

Firmar el requerimiento y generar el certificado del usuario:

OpenSSL> x509 -inform PEM -outform PEM -keyform PEM -CAform PEM -CAkeyform PEM –in req.pem -out certUser.cer -days 365 -req -CA ca.cer -CAkey CAprivado.key -sha1 –CAcreateserial -text

Bueno, hasta aquí la chuleta de hoy. También debéis saber que OpenSSL permite la creación de de certificados digitales para sitios web, pero como esto da por si solo para un post completo, lo dejaremos para otro día si a alguien le interesa.

Espero que la chuleta os sirva de ayuda. Si alguien tiene alguna duda o algo que aportar, como siempre os animo a dejarlos en los comentarios. Nos vemos.

Leyendo barrapunto, he visto el anuncio de que el creador de NMap Gordon Lyor ha publicado un libro sobre dicha herramienta comentando detalladamente todas las posibilidad, y no son pocas, que ofrece esta herramienta. Para el que no lo sepa la herramienta NMap es uno de los escáneres de seguridad más famosos hasta la fecha. Existen de él tanto versiones para Windows como para sistemas basados en Unix, como son Linux y MacOS. Y es utilizado por multitud de administradores para comprobar la seguridad de sus redes de computadoras.

Con motivo de la salida de este libro, aunque la fecha de publicación oficial es el 1 de Enero del 2009, voy a comentaros un poco el manejo de esta herramienta, para que podáis comprobar la seguridad de vuestra red. Por supuesto voy a hacer una introducción al manejo básico para darla a conocer y no aburriros demasiado. Como siempre si tenéis interes o dudas, se puede hacer otro analizando más a fondo la herramienta.

Para empezar, ¿qué podemos esperar de nmap? Es un escaner de puertos. Tras su ejecución nmap nos devolverá todos aquellos puertos que tengamos abiertos en nuestra máquina. Algunos de ellos es habitual, pero otros pueden pertenecer a programas maliciosos que se han instalado en nuestro ordenador y están a la espera de recibir conexiones desde el exterior. Cada puerto esta asociado a un servicio instalado en nuestra máquina, con lo cual es normal encontrar abiertos puertos como el 25 si tenemos un servidor smtp, el 22 si tenemos un servicio de ssh, 23 si permitimos conexiones a través de telnet, el 21 si tenemos un servidor de ftp, etc… Para el que tenga dudas existen en internet fácilmente accesibles multitud de listas con los puertos y el servicio asociado.

Ahora bien, si tras un escaneo existen puerto abiertos pertenecientes a servicios que no hemos ejecutado nos deberemos empezar a preocupar he investigar algo más porque podrían ser una posible fuente de problemas.

Pero bueno vamos a empezar. Por supuesto, a parte de la información que os dará este artículo, podéis encontrar mucha más en la correspondiente página man.

La ejecución más básica de todas sería esta:

nmap <dirección ip>: nmap 192.168.1.1

Que en el ordenador que estoy probando devolvería lo siguiente:

Starting Nmap 4.62 ( http://nmap.org ) at 2008-12-15 18:27 CET
Interesting ports on mygateway1.ar7 (192.168.1.1):
Not shown: 1711 closed ports
PORT   STATE SERVICE
21/tcp open  ftp
22/tcp open  ssh
23/tcp open  telnet
80/tcp open  http

Nmap done: 1 IP address (1 host up) scanned in 1.989 seconds

Como podéis ver la información es muy fácilmente entendible, básicamente es una lista de puertos y servicios asociados estos.

Otra posibilidad también bastante interesante que nos ofrece es la posibilidad de saber el sistema operativo que esta corriendo la máquina escaneada, que dirección MAC tiene y que tipo de dispositivo es:

sudo nmap -O 192.168.1.1

MAC Address: XX:XX:XX:XX:XX:XX (MARCA)
Device type: broadband router|WAP|media device|VoIP gateway|general purpose
Running: Linux 2.4.X
OS details: Linux 2.4.9 – 2.4.18 (likely embedded)

Como en este caso yo estaba haciéndolo sobre un router nos ha devuelto los datos correspondiente a este. Para un sistema operativo de tipo linux el resultado sería algo similar a esto:

Device type: general purpose
Running: Linux 2.6.X
OS details: Linux 2.6.17 – 2.6.23

Simplemente apuntar que para poder descubrir el sistema operativo, debido a interacciones que tiene que realizar con el kernel, es necesario tener permisos de superusuario.

Otra posibilidad que nos ofrece muy útil si estamos en una red desconocida es la de descubrir las máquinas pertenecientes a un mismo rango IP:

nmap -sP 192.168.1.1-255

Que devolvería un listado completo de los ordenadores en la red.

Host 192.168.1.2 appears to be up.
Host 192.168.1.3 appears to be up.
Host 192.168.1.5 appears to be up.

Hasta aquí serían las utilidades simples y con las que podríamos probar la seguridad de nuestra red.

Al ser una potente herramienta de seguridad, nmap también nos permite realizar diferentes tipos de escaneos para intentar minimizar la detección de estos barridos por parte del sistema escaneado. Alguno se estará echando las manos a la cabeza ya, pensando que da igual dejar rastros si lo que escaneas es tu red. Pero imaginemos por un momento que lo que queremos es probar si podríamos detectar este tipo de escaneos en nuestras máquinas. Pues bien, como ya he dicho nmap nos ofrece esta posibilidad añadiendo unos simples parámetros a su ejecución:

-sT: Sería el método básico de escaneo, nmap intenta abrir conexiones tcp con la máquina escaneada. Problemas, que deja multitud de registros de actividad. Ventaja, cualquier usuario incluso sin privilegios puede realizarlo.

-sS: Este tipo de escaneo solo realizará el intento de conexión tcp con la máquina escaneada, de forma que no llegará a hacer la conexión completa. Problemas, se necesitan permisos de superusuario para poder realizarlo. Ventaja, es detectado por muchas menos máquinas que el anterior.

-sF -sX -sN: Son tres opciones diferentes pero con resultados muy similares, por eso están agrupadas. Esto es lo que se llama el escaneo silencioso, se realiza mediante paquetes tcp, pero sin realizar ningún tipo de conexión. La idea es invertir el proceso anterior, si antes hacíamos un intento de conexión y así sabíamos el estado de un puerto, abierto si aceptaba, cerrado en caso contrario. Ahora, mandando un paquete FIN conseguiremos que los puertos abiertos nos ignores y los cerrados nos respondan con un RST. De este modo no dejaremos señal de nuestro escaneo. Problemas, hace falta ser superusuario.Ventajas, indetectable.

-sU: Este escaneo simplemente realiza un barrido de puertos udp, al contrario que los anteriores que lo realizaban de tcp.

Bueno, yo creo que con esto ya tenéis una pequeña introducción sobre esta fantástica herramienta de seguridad. Os animo a que la probéis en vuestras redes y os entretengáis un rato.

Nos vemos.

¿Qué es?

La inyección de código es una vulnerabilidad que se puede explotar en todas aquellas aplicaciones que trabajen con una base de datos. Esta consiste en la modificación por parte de un usuario de las consultas que se realizan a la base de datos. Por lo general tiene origen en el incorrecto filtrado de los campos a los que tiene acceso el usuario de cara a introducir datos en la BD (base de datos). Una de las particularidades de este tipo de error es que se puede producir en cualquier lenguaje tanto de programación como de script.

Este tipo de vulnerabilidad puede provocar varias consecuencias como por ejemplo la validación correcta de usuarios que no están en nuestro sistema, el acceso por parte de un usuario a datos a los que no se debería tener acceso o problemas del tipo de manipulación y borrado de la BD.

Algunos ejemplos

Para los ejemplos me voy a basar en PHP, pero la mayoría de cosas aquí comentadas se hacen extensibles a otros lenguajes.

Ejemplo 1:

Supongamos que hemos implementado en una web un sistema de identificación de usuarios, nuestra sentencia para crear la consulta sería algo así:

sql_sentencia = “select pass from Usuario where usuario = ‘” . $login_user . “‘;”;

Donde login_user es una variable que tiene un valor proveniente de un formulario de identificación. Pongamos que el usuario que se a identificado es “Pedro”, lo cual haría que la sentencia SQL finalmente terminará así:

select pass from Usuario where usuario = ‘Pedro’;

Hasta aquí todo sería completamente normal. Pero si el usuario no tiene buenas intenciones en vez de introducir “Pedro” como usuario podría introducir lo siguiente:

Pedro’; drop table Usuario;

Esto daría lugar a lo siguiente:

select pass from Usuario where usuari = ‘Pedro’;
drop table Usuario;

El SQL se ejecutaría en orden. La primera sentencia tendría el funcionamiento esperado, pero la segunda nos borraría la tabla “Usuario” de nuestra BD con lo que ya tendríamos nuestro primer desastre.

Ejemplo 2:

Supongamos el mismo caso de implementación de un sistema de identificación, pero esta vez con el siguiente código:

sql_sentencia = “select id from Usuario where nombre = ‘” . $login_nombre . “‘ and pass = ‘” . $pass . “‘;”;

Y para la identificación nos basamos en si la consulta devuelve o no valor. Lo normal sería que el usuario hubiera ingresado su login y su contraseña y que hiciéramos la comprobación, si la select devuelve algún valor lo identificaríamos y si el resultado de la consulta esta vacío no lo haríamos. Ahora bien un usuario avispado podría hacer lo siguiente:

Usuario: Pepe (usuario que sabe que existe porque ha visto antes)
Password: ‘ or ‘a’='a’

El valor de “algo” or “true” como todos sabréis es “true” con lo cual conseguiría identificarse en nuestro sistema.

¿Como solucionarlo?

Para evitar problemas de seguridad con este tipo de ataques la única solución es una buena programación por parte la persona que implemente la aplicación. Para ello el programador debe tener en cuanta esta posibilidad y tratar de evitar que se de una situación adecuada para la inyección de código. En la mayoría de lenguajes de programación utilizados en Web existen formas faciles de evitarlo y poco a poco cambien en los lenguajes de escritorio, aun así si no existe en el lenguaje una forma especifica, siempre lo podemos implementar nosotros a mano.

En PHP por ejemplo para mysql existe la función “mysql_real_escape_string” que se encarga de escapar todos lo caracteres extraños de un parámetro introducido. Para el ejemplo uno, la creación de la sentencia quedaría algo así:

sql_sentencia = “select pass from Usuario where usuario = ‘” . mysql_real_escape_string($login_user) . “‘;”;

Espero que esto os sirva para a partir de ahora mejorar la seguridad de todo lo que programéis. Si alguien tiene algo que aportar o quiere ampliar la información o corregir algo, animaros y dejad vuestros comentarios.