jueves, 29 de diciembre de 2016

Lo mejor del año 2016, por Pablo González

Compartir este artículo:
Otro año más ha pasado. Desde hace unos años hacemos este sano ejercicio de reflejar en unas líneas lo que ha deparado el año en el ámbito profesional, y por qué no, en algunas ocasiones también en lo personal. Al final lo profesional como lo personal va muy ligado, uno no puede dar el 100% en lo profesional, si su mente no está en un equilibrio en lo personal, y viceversa. Por desgracia, no siempre podemos tener ese equilibrio y el rendimiento se ve afectado. 

Comienzo diciendo que 2016 ha mejorado las expectativas, he mejorado en casi todo, pero lo cierro con un sabor agridulce. Recuerdo. Es mi palabra para definir mis últimos días de 2016.

Ahora sí, comienzo mi resumen anual. Telefónica sigue siendo mi casa, dónde puedo innovar junto a grandes compañeros, y dónde puedo hacer pruebas de conceptos, probar ideas locas y dar conferencias y comunicar nuestras ideas, en la mayoría de las ocasiones, locas. Cambié de posición internamente, para centrarme en las pruebas de concepto y la ejecución de ideas innovadores que ayuden a impulsarnos o, simplemente, probar diferentes cosas. Resultados como Wordpress in Paranoid Mode o los esquemas Sappo fueron algunos resultados de esto. 

Telefónica seguirá siendo mi casa, aunque nunca se sabe lo que puede traernos el año 2017, ya que vivimos en un sector de continuos cambios y nosotros no somos inmunes a ellos. Allá por el mes de enero tuve una gran despedida de una idea que cogí en los comienzos de ésta (cuando Miguel y Eduardo nos ofrecieron la dinamización), mi querido hack and beers Madrid. En enero hicimos la V edición e impartí la charla 'How can (bad boys or even u) rule the world?'. Además, tuve la oportunidad de volver a mi segunda casa, mi querida Cantabria, a la II Edición de la Sh3llcon dónde impartí el taller 'Los niños y los pentesters nunca mienten' y la charla 'How can (bad boys or even u) rule the world?'. Por segunda vez, estuve en el evento de la UAH denominado Ciberseg 2016, dónde impartí una charla nueva denominada 'Scanning & Port-Knocking: 1F Authentication + 1F Authorization'. Cómo se puede ver, el comienzo del año fue intenso. Comencé un nuevo año de docencia en la Universidad Europea de Madrid en el Máster de Seguridad. Además, realicé una formación sobre Pentesting con Powershell, de la que tendréis noticias pronto. Para finalizar el mes, me entrevistaron para un artículo en genbeta, denominado:  ¿Cuánto tiempo lleva siendo 123456 la peor contraseña posible y por qué nunca lograremos eliminarla?

En Febrero la cosa no se relajó. 'Vísteme despacio que tengo prisa' fue el nombre de una charla en el Data Science Spain 2016, dónde hablé de Tacyt y las posibilidades del Big Data contra las nuevas amenazas. Me sentí un extranjero que aborda una nueva tierra, gente de la seguridad entrando en el Big Data Land. Creo que les puse bandera ;) Esos mismos días llegó una nueva edición del URJC TechFest, y era la quinta. Impartí una charla junto a mi amigo Rafa Sánchez denominada 'El silencio de los backends' y otra denominada 'OSINT: La verdad está ahí fuera'. Tuve la oportunidad de hablar con prensa de Cataluña sobre el hacking ético, dejo por aquí el enlace. Ese mismo mes, de la mano del amigo Rafa Otal, llegó la Morteruelo CON. Era mi primera vez, y espero que no sea la última. Impartí un taller denominado 'A mi me daban 2: Powershell y Metasploit Mix'. Aproveché para hacer una entrevista con la Tribuna de Cuenca. Hay que recalcar que de todo lo que conté, solo se quedaron con lo de un hacker es un curioso, no es un delincuente, lo cual tampoco fue dicho así, pero aceptamos barco ;)


Además, estuve hablando en la Cadena SER sobre el incidente de los juguetes que podían filtrar datos privados de menores. Viaje a Valencia, otra de mis segundas tierras, muy querida y tremenda paella, para hacer la formación 'Pentesting con Kali' en TAES. Uno de los hechos curiosos de este mes de febrero fue una charla que tuve que dar en la AIE, Asociación de Intérpretes Ejecutantes, dónde coincidí con varios cantantes de grupos famosos de los 80-90. Nacha Pop, Los Secretos o Los Tahúres Zurdos, entre otros, estaban allí. Concienciación para ellos y sus negocios en Internet con la charla 'Reality exceeds fiction!'.


Seguí con mis clases en la Universidad Europea de Madrid y comencé un nuevo Máster de Seguridad Informática en la Universidad Internacional de La Rioja. Además, seguí con los TFM en la UOC y con la asignatura de Seguridad en Sistemas Operativos. Tengo el gran honor de estar en las principales Universidades dónde la temática de Seguridad de la Información se encuentra. Por último, acabé el mes comenzando mi participación con la Universidad de Extremadura y el DTIF, Derecho Tecnológico e Informática Forense, dónde aporté con mi visión sobre el hacking ético y el forense en Linux. Los últimos días de Febrero comenzó una nueva edición, y van 7, de la Rooted CON. Por cuarto año consecutivo tuve un taller, en esta ocasión 'Metasploit on Fire!', dónde los asistentes pueden ir viendo el framework en distintos ámbitos y escenarios. Lab recomendado :D

Llegó marzo. Me puse malo. Justo antes de dar la charla en Rooted CON 'Solo hay que besar un sappo para encontrar un príncipe' junto a Chema Alonso. Los dos estábamos malos, pero no podíamos faltar a la cita, y allí estuvimos.


Mientras en la UEM, seguían mis clases, en esta ocasión sobre seguridad en las comunicaciones. Por otro lado, nos invitaron al IES Virgen de la Paloma a unas Jornadas de Ciberseguridad. La charla fue 'Phishing, rats & bad boys: Navegar seguro está en tu mano'. En marzo finalicé, junto a Felipe Colorado, la novela Got Root: El poder de la mente. Esta ha sido mi primera novela y he de decir que ha sido un trabajo gratificante y muy motivador, poder hablar de ciberseguridad desde otro punto y con unos lectores técnicos y no tan técnicos en el foco.

En abril salió a la luz el caso de los Panamá Papers y me tocó hablar en Capital Radio y en la COPE, en el programa de Carlos Herrera. Fue interesante explicarles la teoría del insider, ante lo que ellos veían un claro ataque externo. El periodista Pipo Serrano me entrevistó para su sección en la televisión catalana, el tema fue uno de los estrella en este 2016, explicar al gran público que era eso del cifrado extremo a extremo en WhatsApp. Junto a mi ex-compañero, y gran tipo, Adolfo Hernández participé en una entrevista para Expansión en la que se nos preguntaban por mitos y verdades sobre las contraseñas a prueba de hackers. La Policía de Alcorcón nos invitó a unas charlas de concienciación en la que pude impartir mi charla 'Reality exceeds fiction!' Fue uno de los momentos del año, ya que nos sentimos como en casa. Grandes! y grande Daniel ;)


Seguimos con las clases en la UEM, nos fuimos a dar un curso a Orense en el Colegio de Ingenieros de Galicia sobre Hardening de sistemas GNU/Linux. Seguimos con las clases de la UNIR y grabamos para Cuatro un reportaje para el programa Infiltrados, el título del reportaje 'La casa de cristal', el cual va sobre la privacidad de los datos en los dispositivos móviles.

En mayo seguimos con las clases en UNIR, UEM y en UCLM dónde soy co-organizador del título propio de Especialista en Seguridad Informática y de la Información. Internamente, participé en una Begeekie, gran concepto de charla, comida y networking dónde hable de Network Packet Manipulation. Publicamos el paper del SAPPO. Por último, participé en el programa de youtube 'Palabra de hacker' sobre seguridad ofensiva.


En junio seguimos con las clases en la UCLM, antes del parón de verano. Publicamos el paper del Wordpress in Paranoid Mode, participé en ElevenPaths Talks Temporada 1 con una charla sobre el Wordpress in Paranoid Mode. Por último, participé en Tilo Motion de la mano de Sonia Frías. Gracias por la invitación.






En julio, impartí un curso sobre Metasploit, el cual tuvo un gran número de inscritos. Además, estuve involucrado como tribunal en los TFM de la URJC y la UEM. Por último, tuve en mis manos, tras meses de revisión e imprenta, mi querido Got Root: El poder de la mente.

En agosto, volví a un programa que aprecio, el cual es 'Aquí Madrid'. He participado varias veces y volvieron a grabarme esta vez para el tema de WhatsApp y las estafas que por aquel mes crecían. También tuve la posibilidad de estar en 'A fondo', programa con el que en el 2015 ya tuve la suerte de colaborar. En esta ocasión el tema era Shodan y las cámaras expuestas en Internet. Por último, por segundo año tuve la oportunidad de estar en Tomatina CON. Gran experiencia y gran paella.


Llegó el mes de septiembre, y como se ha podido ver los meses de verano uno está más parado. En septiembre pude participar en la Bsides Colombia 2016 con la charla 'Cómo los malos pueden conquistar el mundo'. Además, por tercera vez participé en la Rooted Satellite celebrada en valencia. Tercer taller consecutivo, en esta ocasión sobre Ethical Hacking y Pentesting. También impartí la charla 'PSBot: No tools, no problem! with Powershell'. A mediados de septiembre se celebró la segunda edición de Qurtuba, en la que tuve el honor de volver a participar. En esta ocasión, junto a mi amigo Carlos García, dimos un taller sobre Red Team & Blue Team, en definitiva distintas estrategias a seguir. En tema de congresos cerré el mes con mi participación, junto a Rafa Sánchez y Carmen Torrano, en Navaja Negra. Tuve la suerte de impartir una charla denominada 'Hacking devices around world: Playing 'Gallinita Ciega''. Por otro lado, junto a Carmen, impartí el taller 'HSTS y HPKP: Los batman y robin de la seguridad web'. En la parte de comunicación, volví al programa 'Aquí Madrid' de Telemadrid para hablar de espionaje en el móvil. Por último, hablé en el programa de Herrera, con el que estoy colaborando desde las últimas 7 semanas, para hablar de bugs en el iPhone 7.

En octubre hubo que parar un poco, pero aún así arranqué cosas. Comencé por segundo año a dar clases de la asignatura de Seguridad Avanzada en el Máster de Ingeniería Informática de la Universidad Rey Juan Carlos. De nuevo un reto, y de nuevo muy gratificante. Participé en COPE, en el programa de Herrera, hablando de las nuevas funcionalidades de WhatsApp, esta vez como experto tecnológico. Por último, estuve en el Movistar Series Cine para hablar, junto a Angelucho, de Mr.Robot y los paralelismos con la seguridad informática. Interesante experiencia, con gran expectación.

En noviembre, estuve en las IV jornadas de seguridad de Villamuriel de Cerrato con Amador Aparicio y todo el equipo del centro. Gran experiencia. Por otro lado, estuve en una charla para un bufete en Valladolid dónde pude conocer a una ex-ministra de un gobierno anterior. Otra gran experiencia que sumar al saco. Noviembre fue un mes muy ajetreado.


Mientras tanto, seguía participando en la COPE en el programa de herrera hablando de Signal, de la cuenta fake de Messi en twitter o de los selfies como contraseñas. También estuve con Germán 'El gris' en unas jornadas de militares celebradas en Toledo sobre técnicas OSINT. Tuve la oportunidad de estar en el EOI, Escuela de Organización Industrial, la cual es una Escuela de Negocios que lleva más de 60 años con nosotros, para debatir sobre la empleabilidad del sector de la seguridad de la información. Gran experiencia con compañeros de tertulia de lujo.


Además, la gente del canal Non Stop People Tv grabaron un reportaje denominado 'Desmontando a Mr. Robot'. De nuevo, fue entretenido. Viaje a Cáceres para estar en el primer Foro Ciber de la mano de Andrés Caro y todo el equipo de la Universidad. Grandes ponentes como Ruth Sala, Silvia Barrera o el Magistrado Eloy Velasco. Allí hablé de las amenazas a las que estamos expuestos los usuarios de Internet a día de hoy. Además, participé en el telediario del canal Extremadura.



En el mismo año, volví a ser invitado por los amigos del IES Virgen de la Paloma para la II edición de sus jornadas sobre seguridad informática. En esta ocasión hablé de 'Repositorios de código, ¿Fuente de vulnerabilidades potenciales? y participé en la mesa redonda con compañeros como Enrique Serrano y Mónica Valle. En esta mesa hablamos sobre la empleabilidad del sector, de nuevo un tema que interesa a muchos y os recomiendo que echéis un ojo.



Quizá noviembre haya sido uno de los meses con más trabajo y con más actividades por mi parte. Participé con la UPM en un máster orientado a la ciberinteligencia, en el que un grupo que llegó de México para hacer dicho máster participaron. Además, hacia finales de noviembre participé por segundo año en las SecAdmin de Sevilla. Gran evento, han dado un paso al frente y tienen una gran organización. Enhorabuena chicos.


Por último, en este largo mes, participé en un piloto de la UEM para intentar acercar el máster de seguridad a los grados. Impartí mi asignatura de ARD en el título de la UCLM e impartí un seminario en mi casa, la Universidad Rey Juan Carlos, sobre 'Ciberseguridad: Presente y futuro'.

Llegamos al último mes del año. Es un mes que siempre me ha encantado. Me llegaron los 30 y llega la navidad. Este mes no lo olvidaré nunca... Comenzó con mi participación en la COPE hablando sobre cookies, otra semana sobre WhatsApp y los phishing y mi última colaboración sobre Yahoo y el hackeo de más de mil millones de identidades. Llegó el III Cybercamp, esta vez en León. Y por tercera vez consecutiva pude estar en este gran evento de la ciber seguridad en España. Allá nos fuimos, Carmen Torrano y yo teníamos un taller de 2 horas sobre HSTS y HPKP, el cual os dejamos a continuación.


Comencé con mis clases en la UEM, en esta nueva edición del Máster de seguridad. Comencé las clases de Análisis de vulnerabilidades en la UNIR. Me entrevistaron a través de una OpenClass en la UNIR para hablar de Ciberseguridad y el futuro de ésta. Participé en Eleven Paths Talks Temporada 2, con una charla sobre Network Packet Manipulation.


El día 23 de diciembre cerré el año con una tertulia en Radio Internacional sobre ciberseguridad y los riesgos que existen en Internet. Como se puede ver ha sido un año lleno de actividades y de experiencias. He conocido a mucha gente, y gente muy interesante. Por desgracia, seguro que se me olvidan cosas interesantes que me han pasado o actividades que he realizado. Brindaré por esas cosas también el próximo día 31.

He de decir que a los que tengo hace muchos años no los cambio por nada. En este pequeño rincón de Internet dónde hacemos Flu Project tengo a Juan Antonio y él siempre ha sido un gran apoyo, confesor y un tío con visión. Gracias JA. Espero que el año 2017 traiga el mismo número de cosas, aunque os puedo adelantar que alguna sorpresa pronto habrá. Cerramos el año, y damos la bienvenida al año 2017. Felices fiestas. 

Hoy celebramos el 6º aniversario de Flu Project

Compartir este artículo:
Buenas a todos, en el día de hoy celebramos en Flu Project nuestro 6º aniversario, 6 años de vivencias con vosotros en los que nos habéis visto crecer a Pablo y a mí en todos los sentidos.

Desde este post publicado el 29 de Diciembre de 2010:


Hasta el post que hoy estáis viendo, hemos pasado por 1.800 artículos, más de 5.000.000 de visitas, más de 2.000.000 de descargas entre todas nuestras aplicaciones, más de 100.000 descargas de nuestros libros, etc. etc.

Pero al fin y al cabo son solo números, lo que importa de verdad es que en estos 6 años hemos crecido con vosotros, hemos hecho (y seguiremos haciendo) grandes amigos gracias a la seguridad, y hemos pasado muy buenos ratos escribiendo posts, preparando charlas, compartiendo conchas codan y buenas cervezas con vosotros, y eso es lo que importa :)

Muchas gracias a todos por estar ahí, ¡y a por otro año más con todos vosotros!

miércoles, 28 de diciembre de 2016

Construyendo nuestro propio escáner de dispositivos conectados a Internet. Parte 6

Compartir este artículo:
Buenas a todos, en el post de hoy continuaremos con la cadena sobre la construcción de nuestro escáner de dispositivos, añadiendo las funciones oportunas para almacenar la información que obtenemos con nuestro analizador en una base de datos MySQL. Podéis utilizar la tecnología de almacenamiento que consideréis más eficiente para vuestras pruebas de concepto. En nuestro caso, será suficiente con MySQL, el cual en el caso de ser necesario podríamos implementar en modo cluster.

A continuación os compartimos el código del archivo principal del analizador:
import socket
import pygeoip
import MySQLdb
from ports import getcommonports

# Database
DB_HOST = 'localhost'
DB_USER = 'fluscan'
DB_PASS = 'F1u$c4n'
DB_NAME = 'fluscan'

def geo(_file, _ip, _id):
    ''' This function search the geolocation values of an IP address '''
    try:
        geoDb = pygeoip.GeoIP(_file)
        ip_dictionary_values = geoDb.record_by_addr(_ip)
        ip_list_values = ip_dictionary_values.items()
        q = "INSERT INTO t_geo (host, city, region_code, area_code, time_zone, dma_code, metro_code, country_code3, latitude, postal_code, longitude, country_code, country_name, continent) VALUES ('%d', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s') ON DUPLICATE KEY UPDATE city='%s', region_code='%s', area_code='%s', time_zone='%s', dma_code='%s', metro_code='%s', country_code3='%s', latitude='%s', postal_code='%s', longitude='%s', country_code='%s', country_name='%s', continent='%s'" % (_id, ip_list_values[0][1], ip_list_values[1][1], ip_list_values[2][1], ip_list_values[3][1], ip_list_values[4][1], ip_list_values[5][1], ip_list_values[6][1], ip_list_values[7][1], ip_list_values[8][1], ip_list_values[9][1], ip_list_values[10][1], ip_list_values[11][1], ip_list_values[12][1], ip_list_values[0][1], ip_list_values[1][1], ip_list_values[2][1], ip_list_values[3][1], ip_list_values[4][1], ip_list_values[5][1], ip_list_values[6][1], ip_list_values[7][1], ip_list_values[8][1], ip_list_values[9][1], ip_list_values[10][1], ip_list_values[11][1], ip_list_values[12][1])
        run_query(q)
    except:
        pass

def hosts(_ip):
    ''' This function search the hostnames '''
    _host = None
    try:
        hosts_values = socket.gethostbyaddr(_ip)
        _host = str(hosts_values[0])
        if _host:
            run_query("INSERT INTO t_hosts (ip, host, date) VALUES ('%s', '%s', now()) ON DUPLICATE KEY UPDATE host='%s', date=now()" % (_ip, _host, _host))
            return run_query("SELECT id FROM t_hosts WHERE ip='%s'" % _ip)[0][0]
    except:
        return None

def portscan(_host, _port):
    ''' This function execute a port scan '''
    banner = ''
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(0.5)
        result = sock.connect_ex((_host, _port))
        sock.send('GET HTTP/1.1 \r\n')
        banner = sock.recv(1024)
        sock.close()
    except:
        pass
    return result, banner

def ports(_ip, _id):
    ''' This function search open ports '''
    try:
        common_ports = getcommonports()
        for value in common_ports:
            banner_exists, banner = portscan(_ip, value)
            if not banner_exists:
                run_query("INSERT INTO t_ports (host, port, service, banner, date) VALUES ('%d', '%d', '%s', '%s', now()) ON DUPLICATE KEY UPDATE service='%s', banner='%s', date=now()" % (_id, value, str(common_ports[value]), str(banner), str(common_ports[value]), str(banner)))
    except:
        pass

def ip_order(_ip1, _ip2):
    try:
        _ip1_split = _ip1.split('.')
        _ip2_split = _ip2.split('.')
        for i in range(0, 4):
            if _ip2_split[i] < _ip1_split[i]:
                return _ip1, _ip2
            elif _ip2_split[i] > _ip1_split[i]:
                return _ip2, _ip1
        return _ip2, _ip1
    except:
        return _ip1, _ip2

def ip_add(_ip):
    try:
        _ip_split = _ip.split('.')
        if int(_ip_split[3]) < 255:
            return "%s.%s.%s.%d" % (_ip_split[0], _ip_split[1], _ip_split[2], int(_ip_split[3])+1)
        elif int(_ip_split[2]) < 255:
            return "%s.%s.%d.%d" % (_ip_split[0], _ip_split[1], int(_ip_split[2])+1, 0)
        elif int(_ip_split[1]) < 255:
            return "%s.%d.%d.%d" % (_ip_split[0], int(_ip_split[1])+1, 0, 0)
        elif int(_ip_split[0]) < 255:
            return "%d.%d.%d.%d" % (int(_ip_split[0])+1, 0, 0, 0)
        else:
            return _ip
    except:
        return _ip

def run_query(query=''):
    datos = [DB_HOST, DB_USER, DB_PASS, DB_NAME]
    conn = MySQLdb.connect(*datos)
    cursor = conn.cursor()
    cursor.execute(query)
    if query.upper().startswith('SELECT'):
        data = cursor.fetchall()
    else:
        conn.commit()
        data = None
    cursor.close()
    conn.close()
    return data

def main(_ip1,_ip2):
    ''' Main function, launch the main activities '''
    ''' You can download GeoIP databases from here: https://dev.maxmind.com/geoip/legacy/geolite '''
    _ip3 = _ip1
    while _ip3 <> _ip2:
        _ip3 = ip_add(_ip3)
        print _ip3
        try:
            _id = hosts(_ip3)
            if _id:
                geo('GeoIP/GeoLiteCity.dat', _ip3, _id)
                ports(_ip3, _id)
        except:
            print 'Error on: %s' % _ip3

if __name__ == "__main__":
    print 'FluScan, an IPv4 scanner. Created by http://www.flu-project.com\n'
    ip1 = 'X.X.X.X'
    ip2 = 'Y.Y.Y.Y'
    ip2, ip1 = ip_order(ip1, ip2)
    main(ip1, ip2)
Por otro lado, os compartimos el código SQL para generar la BBDD con las tablas necesarias para el funcionamiento del sistema:
CREATE DATABASE IF NOT EXISTS `fluscan` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
USE `fluscan`;

CREATE TABLE `t_geo` (
  `id` int(11) NOT NULL,
  `host` int(11) DEFAULT NULL,
  `city` text,
  `region_code` text,
  `area_code` text,
  `time_zone` text,
  `dma_code` text,
  `metro_code` text,
  `country_code3` text,
  `latitude` text,
  `postal_code` text,
  `longitude` text,
  `country_code` text,
  `country_name` text,
  `continent` text
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

CREATE TABLE `t_hosts` (
  `id` int(11) NOT NULL,
  `ip` varchar(250) DEFAULT NULL,
  `host` text,
  `date` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

CREATE TABLE `t_ports` (
  `id` int(11) NOT NULL,
  `host` int(11) DEFAULT NULL,
  `port` int(11) DEFAULT NULL,
  `service` text,
  `banner` text,
  `date` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

ALTER TABLE `t_geo`
  ADD PRIMARY KEY (`id`),
  ADD UNIQUE KEY `host` (`host`);

ALTER TABLE `t_hosts`
  ADD PRIMARY KEY (`id`),
  ADD UNIQUE KEY `ip` (`ip`);

ALTER TABLE `t_ports`
  ADD PRIMARY KEY (`id`),
  ADD UNIQUE KEY `host` (`host`,`port`);
Con todo esto tendremos lista la base de nuestro escáner.

Saludos!

lunes, 26 de diciembre de 2016

Lo mejor del año 2016, por Juan Antonio Calles (@jantonioCalles)

Compartir este artículo:
¡Muy buenas a todos! como no podía ser de otra manera, al igual que en los anteriores 3 años de Flu Project, Pablo y yo hemos querido hacer un resumen de nuestros respectivos años. Es un importante ejercicio de reflexión que recomendamos a todos, para en el futuro echar un vistazo a estos posts y no olvidar lo que somos, de dónde venimos y a dónde vamos.

En las siguientes líneas podréis acceder a los resúmenes de los últimos años:
Personalmente, para mí 2016 se planteaba como un reto muy grande. En este último año, mi vida ha variado mucho (boda, mudanzas, viajes, etc. etc.). Además, finalmente terminé mi tesis doctoral sobre ciberseguridad, y me doctoré el pasado mes de Febrero. Y como os imaginaréis, compatibilizar todo esto con un trabajo tan exigente como los que tenemos Pablo y yo, es una tarea compleja, pero como me decía Juan Luis, al que aprovecho a felicitar por su ponencia en el último congreso del CCN-CERT, que ha tenido un rotundo éxito, <<Juanan..., al final todo sale>>, y es  una gran verdad. Aprovecharé también para lanzar una caña a Juan Luis, a ver si se anima en este 2017 a dar una charla conmigo.... ;)

Uno de estos grandes retos a los que me refiero, consistía en proseguir con la evolución y lanzamiento del Laboratorio de Ciberseguridad que tengo el placer de liderar en una Big4. Tras la integración de Zink Security, llevamos casi 2 años haciendo un trabajo sobrehumano para llevarlo a puestos líderes a nivel nacional e internacional. Muchos de los que lo conocéis más de cerca, sabéis que hemos recibido ya algún que otro premio y reconocimiento como empresa en materia de ciberseguridad, pero nuestro objetivo es mucho más ambicioso, y el trabajo no va a parar. Pero de esto ya os hablaré en otro blog.

En Flu Project, comenzamos el año cerrando un capítulo muy importante para Pablo y para mí, Hack&Beers, Tras 5 ediciones como dinamizadores de Hack&Beers Madrid, decidimos dejar el testigo a otros profesionales que podrían dedicarle el tiempo que se merece y hacer también un gran trabajo. Nos despedimos por lo alto con un evento en la que fue la primera sede del evento, el vivero de empresas de Móstoles, donde Zink Security tenía su sede. ¡Gracias Miguel y Edu por confiar en nosotros a vuestra criatura durante estos años!

El año prosiguió con 2 eventos universitarios a los que tenemos un cariño muy especial, los congresos URJC TechFest y TASSI (UPM).

En el TechFest tuve 2 intervenciones, una impartiendo una conferencia sobre metodologías de búsqueda OSINT junto a mi compañero de Flu Project, Pablo, y otra junto a mi compañero de KPMG, Álvaro García, sobre análisis de malware en smartphones. Ambas intervenciones fueron grabadas por el grupo de audiovisuales de la Universidad Rey Juan Carlos, y se encuentran accesibles para el público. También en este evento estuvo mi compañero Jesús, con una interesante charla sobre NodeJS.

En las Jornadas TASSI impartí un taller sobre seguridad en Android y análisis del malware, donde presentamos desde un punto de vista práctico las distintas tipologías de malware, técnicas utilizadas, medidas de evasión de sistemas antivirus y metodologías para afrontarlos, a un nivel introductorio. El vídeo completo de la conferencia podréis verlo a continuación:


A finales de Febrero estuve junto a Javier Santos en el Salón Internacional de Seguridad, SICUR, hablando de ciberinteligencia. Fue una charla muy amena, que tuvo lugar en una de las salas habilitadas para conferencias dentro del recinto de Ifema.


Unas semanas más tardes, estuve en el Securmática dando una conferencia sobre la Deep y la Dark web junto a Maica, de Ferrovial. Tenéis bastantes detalles sobre esta charla en la revista SIC, si sois lectores habituales de ella. También podéis ver una completa crónica AQUÍ.


En Marzo estuve por RootedCON, en la edición especial que realizamos de X1RedMasSegura, con el objetivo de llegar al público no técnico que acompañaba a los "hackers" de Rooted :).

Y más adelante, en Abril, tuvimos también otro evento de X1RedMasSegura, en este caso orientado específicamente a familias y del que tenéis mucha información AQUÍ. Fue la primera vez que lo realizamos, y la verdad que tuvo una gran aceptación. Por supuesto agradecer al alma de X1RedMasSegura su implicación contante: Josep, Olga, Longinos, Iván, Ángel, Virtu, Inma, Pat, Merche, Blanca, Fernando,... sois muy grandes.


En este primer semestre del año he participado como ponente en numerosos eventos representando a mi empresa, de los cuales destacaría el evento anual de ciberseguridad de ella, dirigido a CISOs principalmente, y del que tengo un gran recuerdo porque aparte de una organización espectacular, fue el primero que realizamos en nuestras nuevas instalaciones de Torre de Cristal.


Posteriormente, en el mes de Mayo y ¡cómo no podía ser de otra manera!, este año también tuvimos jornadas X1RedMasSegura 2016, con una agenda muy potente:



Podréis ver los vídeos de las Jornadas X1RedMasSegura 2016 a continuación:

VIERNES 20 - JORNADA INAUGURAL



SÁBADO 21 - MAÑANA



SÁBADO 21 - TARDE


Aprovecho para comentaros también que ya nos encontramos preparando las Jornadas del año que viene, por lo que estad atentos, e id reservando las fechas del 19 y 20 de Mayo de 2017 ;)

En el segundo semestre he participado en menos eventos. Necesitaba desconectar un poco, y estuve una temporada fuera de España "de relax". A mi vuelta participé en las Jornadas Palomática, en su segunda edición junto a mi compañero Álvaro García, y de las que tenéis todo el detalle AQUÍ

Por otro lado, tuve el placer de participar en 2 capítulos de la nueva temporada de Mundo Hacker, que fue emitida por la 2 de RTVE, junto a mi compañero de fatigas Angelucho (¡un abrazo desde aquí!):


También he participado con sendos artículos en revistas como SIC, o ONE HACKER, de las que os dejo a continuación un anticipo:




Finalmente, me gustaría destacar algunos posts que han sido bastante significativos en este año:
  1. La cadena de artículos Construyendo nuestro propio escáner de dispositivos conectados a Internet. Una de las más leídas de este año, y que se encuentra en su ecuador actualmente.
  2. La cadena de posts sobre #HSTS. ¿Qué es y cómo lo implanto en mi empresa?. Qué intentaba aportar algo de luz a la manera de implementar esta característica en el mundo empresarial
  3. La cadena de artículos Ataques MITM en IPv6, renovarse o morir. Que estamos arrancando actualmente y también ha sido una de las más leídas.
  4. Y para terminar, el post Una feature de #Jira que puede filtrar nuestros bugs y desarrollos, que sabemos que consiguió el objetivo de concienciar, porque varias compañías que tenían expuestos sus Jira en Google, han resuelto el problema. ¡Gracias por seguirnos!
Ha sido un año bastante completo como veis, por lo que nos vamos a dar unos días de relax y nos iremos a descansar con nuestras familias, que es lo que toca por estas fechas ;). Hemos dejado algunos artículos automatizados, por lo que tendréis dosis de Flu Project para todas las navidades :)

Un abrazo a todos, y ¡que tengáis unas felices fiestas y un próspero año 2017!

domingo, 25 de diciembre de 2016

viernes, 23 de diciembre de 2016

Algunos vídeos que pueden interesar

Compartir este artículo:
Antes de hacer los resúmenes del año, como ya hicimos en 2013, 2014 y 2015, toca mostrar un poco de la última actividad. El día a día es un no parar, pero que engancha y que, por supuesto, nos gusta. También creemos que dejar estas charlas y debates en este artículo puede ayudar a alguien, por lo que es motivo más que de sobra para hacerlo.

A principios de diciembre en León se celebró el Cybercamp 2016, dónde Carmen Torrano y yo tuvimos la suerte de asistir y poder impartir una charla sobre HSTS y HPKP.


En el mes de noviembre me invitaron a un debate sobre cómo llegar a ser un profesional de la seguridad de la información. Este tipo de debates siempre traen cierto interés en todas las personas que luchan por cumplir con sus objetivos y sus sueños. Realmente entretenido, y es un debate en el que se dijeron bastantes verdades.



En el mismo mes de noviembre la EOI, Escuela de Organización Industrial, me invitó a una mesa redonda dónde estuve con otros compañeros del sector en el que hablamos sobre la empleabilidad del sector. De nuevo, un tema apasionante y que pretende arrojar luz a aquellos que ven las cosas difíciles en este sector.


Que paséis felices fiestas!

jueves, 22 de diciembre de 2016

Construyendo nuestro propio escáner de dispositivos conectados a Internet. Parte 5

Compartir este artículo:
Buenas a todos, en el post de hoy de nuestra cadena "Construyendo nuestro propio escáner de dispositivos conectados a Internet", vamos a comenzar el proceso de automatización (sin almacenar aún ningún dato). Para ello, implementaremos algunas nuevas funciones que nos ayudarán a lanzar un escaneo desde una IP inicial (ip1) a una IP final (ip2), pasando por todos las direcciones contenidas en dicho subrango.

Cómo novedades encontraremos las funciones ip_add, que dada una IP nos devolverá la dirección IP siguiente, e ip_order, que dada dos IPs, nos las devuelve ordenadas de mayor a menor. Así mismo, el cuerpo de nuestra función main se ha ampliado en 4 simples líneas que realizarán la automatización. Finalmente también hemos ajustado los tiempos del escaneo de puertos, para que sea lo más ágil posible, pero sin dar muchos falsos positivos.

Os dejamos la nueva versión del código a continuación:

import pygeoip
import socket
from ports import getcommonports

def geo(_file, _ip):
    ''' This function search the geolocation values of an IP address '''
    geoDb = pygeoip.GeoIP(_file)
    ip_dictionary_values = geoDb.record_by_addr(_ip)
    ip_list_values = ip_dictionary_values.items()
    print "*******************"
    print "*** Geolocation ***"
    print "*******************"
    for value in ip_list_values:
        print str(value[0]) + ": " + str(value[1])

def hosts(_ip):
    ''' This function search the hostnames '''
    print "\n*******************"
    print "***    Hosts    ***"
    print "*******************"
    try:
        hosts_values = socket.gethostbyaddr(_ip)
        print str(hosts_values[0])
    except:
        print 'No hosts associate'

def portscan(_host, _port):
    ''' This function execute a port scan '''
    banner = ''
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(0.25)
        result = sock.connect_ex((_host, _port))
        sock.send('GET HTTP/1.1 \r\n')
        banner = sock.recv(1024)
        sock.close()
    except:
        pass
    return result, banner

def ports(_ip):
    ''' This function search open ports '''
    common_ports = getcommonports()
    print "\n*******************"
    print "***    Ports    ***"
    print "*******************"
    for value in common_ports:
        banner_exists, banner = portscan(_ip, value)
        if not banner_exists:
            print 'Port: [' + str(value) + '] Protocol: [' + str(common_ports[value]) + ']'
            print 'Banner: [' + str(banner) + ']'

def ip_order(_ip1, _ip2):
    _ip1_split = _ip1.split('.')
    _ip2_split = _ip2.split('.')
    for i in range(0, 4):
        if _ip2_split[i] < _ip1_split[i]:
            return _ip1, _ip2
        elif _ip2_split[i] > _ip1_split[i]:
            return _ip2, _ip1
    return _ip2, _ip1

def ip_add(_ip):
    _ip_split = _ip.split('.')
    if int(_ip_split[3]) < 255:
        return "%s.%s.%s.%d" % (_ip_split[0], _ip_split[1], _ip_split[2], int(_ip_split[3])+1)
    elif int(_ip_split[2]) < 255:
        return "%s.%s.%d.%d" % (_ip_split[0], _ip_split[1], int(_ip_split[2])+1, 0)
    elif int(_ip_split[1]) < 255:
        return "%s.%d.%d.%d" % (_ip_split[0], int(_ip_split[1])+1, 0, 0)
    elif int(_ip_split[0]) < 255:
        return "%d.%d.%d.%d" % (int(_ip_split[0])+1, 0, 0, 0)
    else:
        return _ip

def main(_ip1,_ip2):
    ''' Main function, launch the main activities '''
    ''' You can download GeoIP databases from here: https://dev.maxmind.com/geoip/legacy/geolite '''
    _ip3 = _ip1
    while _ip3 <> _ip2:
        _ip3 = ip_add(_ip3)
        print "************************"
        print "  IP: %s" % (_ip3)
        print "************************"
        geo('GeoIP/GeoLiteCity.dat', _ip3)
        hosts(_ip3)
        ports(_ip3)

if __name__ == "__main__":
    print 'FluScan, an IPv4 scanner. Created by http://www.flu-project.com\n'
    ip1 = 'X.X.X.X'
    ip2 = 'Y.Y.Y.Y'
    ip2, ip1 = ip_order(ip1, ip2)
    main(ip1, ip2)
Y la salida que daría por pantalla:



Si veis posibles mejoras o ideas para ir evolucionando nuestro escáner compartirlas con nosotros y las publicaremos en próximas entradas.

Saludos!

lunes, 19 de diciembre de 2016

Construyendo nuestro propio escáner de dispositivos conectados a Internet. Parte 4

Compartir este artículo:
Buenas a todos, en el post de hoy sobre nuestro escáner de Internet, vamos a ampliar sus funcionalidades para hacer banner grabbing (https://en.wikipedia.org/wiki/Banner_grabbing). 

En esta ocasión, los cambios los realizaremos sobre las funciones portscan y ports, aprovechando que es el punto exacto donde revisamos si tras los puertos revisados, hay algún servicio operativo. En la variable banner almacenaremos el resultado de la petición GET con la que hemos solicitado la información que nos devolverá el dato que nos interesa, y si detrás se esconde un Windows, Linux, etc. con un IIS, Apache, etc. etc. 

Ni que decir tiene, que no todo lo que dicen los banners es cierto, ya hemos visto en numerosos posts de Flu Project que este dato se puede (y se debe) ocultar y/o alterar: http://www.flu-project.com/2011/02/seguridad-en-los-banner-de-los_1437.html

A continuación os comparto el código completo del archivo principal del proyecto y en el que hemos hecho las nuevas modificaciones:

import pygeoip
import socket
import re
from ports import getcommonports

def geo(_file, _ip):
    ''' This function search the geolocation values of an IP address '''
    geoDb = pygeoip.GeoIP(_file)
    ip_dictionary_values = geoDb.record_by_addr(_ip)
    ip_list_values = ip_dictionary_values.items()
    print "*******************"
    print "*** Geolocation ***"
    print "*******************"
    for value in ip_list_values:
        print str(value[0]) + ": " + str(value[1])

def hosts(_ip):
    ''' This function search the hostnames '''
    print "\n*******************"
    print "***    Hosts    ***"
    print "*******************"
    try:
        hosts_values = socket.gethostbyaddr(_ip)
        print str(hosts_values[0])
    except:
        print 'No hosts associate'

def portscan(_host, _port):
    ''' This function execute a port scan '''
    banner = ''
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(0.10)
        result = sock.connect_ex((_host, _port))
        sock.send('GET HTTP/1.1 \r\n')
        banner = sock.recv(1024)
        sock.close()
    except:
        pass
    return result, banner

def ports(_ip):
    ''' This function search open ports '''
    common_ports = getcommonports()
    print "\n*******************"
    print "***    Ports    ***"
    print "*******************"
    for value in common_ports:
        banner_exists, banner = portscan(_ip, value)
        if not banner_exists:
            print 'Port: [' + str(value) + '] Protocol: [' + str(common_ports[value]) + ']'
            print 'Banner: [' + str(banner) + ']'

def main(_ip):
    ''' Main function, launch the main activities '''
    ''' You can download GeoIP databases from here: https://dev.maxmind.com/geoip/legacy/geolite '''

    # Extract geolocation values
    geo('GeoIP/GeoLiteCity.dat', _ip)
    hosts(_ip)
    ports(_ip)

if __name__ == "__main__":
    print 'FluScan, an IPv4 scanner. Created by http://www.flu-project.com\n'
    main('X.X.X.X')

Y en las siguientes líneas podéis ver un ejemplo de salida por pantalla:

$ python FluScan.py
FluScan, an IPv4 scanner. Created by http://www.flu-project.com

*******************
*** Geolocation ***
*******************
city: Madrid
region_code: 29
area_code: 0
time_zone: Europe/Madrid
dma_code: 0
metro_code: None
country_code3: ESP
latitude: 40.4167
postal_code: 28001
longitude: -3.6838
country_code: ES
country_name: Spain
continent: EU

*******************
***    Hosts    ***
*******************
XXXXX.XXXXX.XXXX.es

*******************
***    Ports    ***
*******************
Port: [80] Protocol: [http]
Banner: [<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>400 Bad Request</title>
</head><body>
<h1>Bad Request</h1>
<p>Your browser sent a request that this server could not understand.<br />
</p>
<hr>
<address>Apache/2.2.22 (Ubuntu) Server at XXXX.XXX.XX.es Port 80</address>
</body></html>
]
La salida de la variable banner la podéis filtrar, para mostrar solo el campo que nos interesa, y que podréis encontrar tras el tag "Server:" en el caso de IIS, <address> en el caso de Apache, etc. etc. Por Internet existen muchos desarrollos hechos por la comunidad que os serán de utilidad para esta tarea.

Saludos!

miércoles, 14 de diciembre de 2016

Construyendo nuestro propio escáner de dispositivos conectados a Internet. Parte 3

Compartir este artículo:
Buenas a todos, en el post de hoy continuaremos con la cadena sobre la construcción de nuestro escáner de dispositivos online, añadiendo dos funcionalidades. La primera de ellas será un analizador de puertos abiertos, que partirá de un listado con los puertos más habituales que se encuentran abiertos en los distintos activos expuestos a Internet. Y por otro lado, otra con la que comprobaremos el hostname asociado.

¡Vamos allá! Vamos a crear un nuevo archivo al que llamaremos ports.py, y que alojaremos en la carpeta raíz del proyecto. En este archivo copiaremos el siguiente código, que contendrá el listado de puertos que utilizaremos para cada escaneo:

COMMON_PORTS = {
    1: 'tcpmux',
    5: 'rje',
    7: 'echo',
    9: 'discard',
    11: 'systat',
    13: 'daytime',
    17: 'qotd',
    18: 'msp',
    19: 'chargen',
    20: 'ftp-data',
    21: 'ftp',
    22: 'ssh',
    23: 'telnet',
    25: 'smtp',
    37: 'time',
    39: 'rlp',
    42: 'nameserver',
    43: 'nicname',
    49: 'tacacs',
    50: 're-mail-ck',
    53: 'domain',
    63: 'whois++',
    67: 'bootps',
    68: 'bootpc',
    69: 'tftp',
    70: 'gopher',
    71: 'netrjs-1',
    72: 'netrjs-2',
    73: 'netrjs-3',
    79: 'finger',
    80: 'http',
    88: 'kerberos',
    95: 'supdup',
    101: 'hostname',
    105: 'csnet-ns',
    106: 'poppassd',
    107: 'rtelnet',
    109: 'pop2',
    110: 'pop3',
    111: 'sunrpc',
    113: 'auth',
    115: 'sftp',
    117: 'uucp-path',
    119: 'nntp',
    123: 'ntp',
    137: 'netbios-ns',
    138: 'netbios-dgm',
    139: 'netbios-ssn',
    143: 'imap',
    161: 'snmp',
    162: 'snmptrap',
    163: 'cmip-man',
    164: 'cmip-agent',
    174: 'mailq',
    177: 'xdmcp',
    178: 'nextstep',
    179: 'bgp',
    191: 'prospero',
    194: 'irc',
    199: 'smux',
    201: 'at-rtmp',
    202: 'at-nbp',
    204: 'at-echo',
    206: 'at-zis',
    209: 'qmtp',
    210: 'z39.50',
    213: 'ipx',
    220: 'imap3',
    245: 'link',
    347: 'fatserv',
    363: 'rsvp_tunnel',
    369: 'rpc2portmap',
    370: 'codaauth2',
    372: 'ulistproc',
    389: 'ldap',
    427: 'svrloc',
    434: 'mobileip-agent',
    435: 'mobilip-mn',
    443: 'https',
    444: 'snpp',
    445: 'microsoft-ds',
    464: 'kpasswd',
    468: 'puertos',
    487: 'saft',
    488: 'gss-http',
    496: 'pim-rp-disc',
    500: 'isakmp',
    515: 'printer spooler',
    519: 'utime unixtime',
    521: 'ripng',
    525: 'timed timeserver',
    532: 'netnews',
    535: 'iiop',
    538: 'gdomap',
    546: 'dhcpv6-client',
    547: 'dhcpv6-server',
    548: 'afpovertcp',
    554: 'puertos',
    556: 'remotefs',
    563: 'nntps',
    565: 'whoami',
    587: 'submission',
    610: 'npmp-local',
    611: 'npmp-gui',
    612: 'hmmp-ind',
    631: 'ipp',
    636: 'ldaps',
    674: 'acap',
    694: 'ha-cluster',
    749: 'kerberos-adm',
    750: 'kerberos-iv',
    751: 'kerberos_master',
    752: 'passwd_server',
    754: 'krb5_prop',
    760: 'krbupdate',
    765: 'webster',
    767: 'phonebook',
    808: 'omirr',
    873: 'rsync',
    953: 'rndc',
    992: 'telnets',
    993: 'imaps',
    994: 'ircs',
    995: 'pop3s',
    1080: 'socks',
    1109: 'kpop',
    1236: 'bvcontrol',
    1300: 'h323hostcallsc',
    1433: 'ms-sql-s',
    1434: 'ms-sql-m',
    1494: 'ica',
    1512: 'wins',
    1524: 'ingreslock',
    1525: 'prospero-np',
    1645: 'datametrics',
    1646: 'sa-msg-port',
    1649: 'kermit',
    1701: 'l2tp',
    1718: 'h323gatedisc',
    1719: 'h323gatestat',
    1720: 'h323hostcall',
    1758: 'tftp-mcast',
    1789: 'hello',
    1812: 'radius',
    1813: 'radius-acct',
    1911: 'mtp',
    1985: 'hsrp',
    1986: 'licensedaemon',
    1997: 'gdp-port',
    2049: 'nfs',
    2053: 'knetd',
    2102: 'zephyr-srv',
    2103: 'zephyr-clt',
    2104: 'zephyr-hm',
    2105: 'eklogin',
    2150: 'ninstall',
    2401: 'cvspserver',
    2600: 'hpstgmgr [zebrasrv]',
    2601: 'discp-client [zebra]',
    2602: 'discp-server [ripd]',
    2603: 'servicemeter [ripngd]',
    2604: 'nsc-ccs [ospfd]',
    2605: 'nsc-posa',
    2606: 'netmon [ospf6d]',
    2809: 'corbaloc',
    2988: 'afbackup',
    3130: 'icpv2',
    3306: 'mysql',
    3346: 'trnsprntproxy',
    3455: 'prsvp',
    4011: 'pxe',
    4321: 'rwhois',
    4444: 'krb524',
    5002: 'rfe',
    5232: 'sgi-dgl',
    5308: 'cfengine',
    5354: 'noclog',
    5355: 'hostmon',
    5432: 'postgres',
    5999: 'cvsup',
    6667: 'ircd',
    7000: 'afs3-fileserver',
    7001: 'afs3-callback',
    7002: 'afs3-prserver',
    7003: 'afs3-vlserver',
    7004: 'afs3-kaserver',
    7005: 'afs3-volser',
    7006: 'afs3-errors',
    7007: 'afs3-bos',
    7008: 'afs3-update',
    7009: 'afs3-rmtsys',
    8008: 'http-alt',
    8080: 'webcache',
    8081: 'tproxy',
    9359: 'mandelspawn mandelbrot',
    9876: 'sd',
    10080: 'amanda',
    10081: 'kamanda',
    11371: 'pgpkeyserver',
    11720: 'h323callsigalt',
    13720: 'bprd',
    13721: 'bpdbm',
    13722: 'bpjava-msvc',
    13724: 'vnetd',
    13782: 'bpcd',
    13783: 'vopied',
    20011: 'isdnlog',
    20012: 'vboxd',
    22273: 'wnn6 wnn4',
    24554: 'binkp',
    26000: 'quake',
    26208: 'wnn6-ds',
    27374: 'asp',
    33434: 'traceroute',
    60177: 'tfido',
    60179: 'fido'
}

def getcommonports():
    return COMMON_PORTS

Nuestro nuevo esquema de archivos quedará tal que así:


Por otro lado, vamos a ampliar el código del programa FluScan.py, modificándolo por el siguiente:

import pygeoip
import socket
from ports import getcommonports

def geo(_file, _ip):
    ''' This function search the geolocation values of an IP address '''
    geoDb = pygeoip.GeoIP(_file)
    ip_dictionary_values = geoDb.record_by_addr(_ip)
    ip_list_values = ip_dictionary_values.items()
    print "*******************"
    print "*** Geolocation ***"
    print "*******************"
    for value in ip_list_values:
        print str(value[0]) + ": " + str(value[1])

def hosts(_ip):
    ''' This function search the hostnames '''
    print "\n*******************"
    print "***    Hosts    ***"
    print "*******************"
    try:
        hosts_values = socket.gethostbyaddr(_ip)
        print str(hosts_values[0])
    except:
        print 'No hosts associate'

def portscan(_host, _port):
    ''' This function execute a port scan '''
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(0.01)
        result = sock.connect_ex((_host, _port))
        sock.close()
    except:
        pass
    return result

def ports(_ip):
    ''' This function search open ports '''
    common_ports = getcommonports()
    print "\n*******************"
    print "***    Ports    ***"
    print "*******************"
    for value in common_ports:
        if not portscan(_ip, value):
            print str(value) + ': ' + str(common_ports[value])

def main(_ip):
    ''' Main function, launch the main activities '''
    ''' You can download GeoIP databases from here: https://dev.maxmind.com/geoip/legacy/geolite '''

    # Extract geolocation values
    geo('GeoIP/GeoLiteCity.dat', _ip)
    hosts(_ip)
    ports(_ip)

if __name__ == "__main__":
    print 'FluScan, an IPv4 scanner. Created by http://www.flu-project.com\n'
    main('X.X.X.X') #Sustituir por la IP de ejemplo a escanear

La ejecución de nuestro programa daría un resultado como el siguiente (como en mi caso se trata de un servidor de prueba, he sanitizado la salida por pantalla):

FluScan, an IPv4 scanner. Created by http://www.flu-project.com

*******************
*** Geolocation ***
*******************
city: XXXXXXXXX
region_code: XX
area_code: XXX
time_zone: XXXXXXX/XXXXXXXXX
dma_code: XXX
metro_code: XXXXXXXXX, XX
country_code3: XXX
latitude: XX.XXXXXXXXXX
postal_code: XXXXX
longitude: -XX.XXXXXXXX
country_code: XX
country_name: Spain
continent: XX

*******************
***    Hosts    ***
*******************
XXXXX-XXX-XX-X.XXXXXXXXXXX.es

*******************
***    Ports    ***
*******************
80: http

Eso es todo por hoy :), en el próximo post de la cadena continuaremos evolucionando nuestro escáner.

Saludos!

domingo, 11 de diciembre de 2016

CPEH de TSS en Diciembre

Compartir este artículo:
El próximo 21 de diciembre da comienzo el curso online de Certificado Profesional en Hacking Ético, de la empresa Security Sentinel. El curso tiene una duración de 9 semanas y es completamente online y grabado, por lo que puedes visualizarlo las veces que quieras. Con el curso se hará entrega de 2 libros: Metasploit para Pentesters y Pentesting con Foca de la editorial 0xWord. El profesor de la formación es Juan Luis Romero. Juan Luis es el CTO de la empresa Security Sentinel.

El precio del curso es de 270 € y tiene como obsequio dos libros de 0xWord comentado anteriormente. Para reservar tu plaza o pedir más información puedes escribir a info-online@thesecuritysentinel.es. A continuación, os dejamos el contenido del curso, no lo dudes y aprovecha esta formación sobre hacking ético. Según me comentaron en Security Sentinel cada tema lleva prácticas y ejercicios para entregar, así como varios retos a lo largo del curso que deberán entregarse. Al finalizar el curso, y aprobar el examen, se te entregará un certificado donde conste la realización del curso, la superación del examen y la nota correspondiente.

1ª Semana:                                                 
 -Introducción
 -Arquitectura de redes
 -Kali Linux

2ª Semana:
 -Recolección de información
 -Escaneo:
       a) Puertos y servicios
       b) Vulnerabilidades

3ª y 4ª  Semana:
 -Intrusión o acceso
 -Escalada de privilegios

5ª Semana:
 -Auditorías WIFI

6ª Semana:
 -Malware:
          a) Moodear hasta el objetivo

7ª Semana:
 -Forense

 8ª Semana:
 -Auditorías móviles
 -Creación de un informe profesional

9ª Semana:
 -Examen


El 10% de la recaudación de los cursos, van para el proyecto Betania. www.proyectobetania.com

jueves, 8 de diciembre de 2016

Construyendo nuestro propio escáner de dispositivos conectados a Internet. Parte 2

Compartir este artículo:
Buenas a todos, en el post de hoy continuaremos construyendo nuestro escáner de dispositivos conectados a Internet.  Hoy, vamos a comenzar el código del analizador, el cual implementaremos con Python por practicidad, potencia y por la cantidad de información existente en Internet, lo cual os ayudará de cara a ampliar sus capacidades en el futuro, reutilizando módulos que ya se encuentren programados.

El desarrollo lo haré con Visual Studio Code, y el módulo PythonVSCode (https://github.com/DonJayamanne/pythonVSCode), que nos facilitará enormemente la revisión del código y la implementación:


Bien, una vez que tengáis vuestro IDE preferido para desarrollar, vamos a crearnos una carpeta para el proyecto, el cual hemos denominado (temporalmente y hasta que lo bauticemos), FluScan. A su vez, dentro crearemos un archivo al que nombraremos como FluScan.py y una subcarpeta, a la que llamaremos GeoIP. En esta carpeta almacenaremos las bases de datos de geolocalización que comentamos en el pasado post. Estas bases de datos las podremos obtener de numerosas fuentes. Sin duda, las mejores son de pago, pero como nuestro objetivo es meramente académico, me he decantado por unas bases de datos "Lite", que podremos descargarnos gratuitamente desde el siguiente sitio web:



Una vez descargadas, deberemos descomprimirlas en la carpeta que hemos creado antes. Ahora solo nos faltará llamarlas desde nuestro código.

Para poder interactuar con estas bases de datos, utilizaremos el módulo de Python, pygeoip:


Este módulo podréis instalarlo con pip:


Si habéis seguido todos los pasos, tendréis el siguiente esquema de archivos:


Y dentro de GeoIP:

¡Perfecto! Con todo ello, hoy veremos un sencillo ejemplo para geolocalizar una dirección IP. Para ello os comparto a continuación el siguiente código python:

import pygeoip

def geo(_file,_ip):
    geoDb = pygeoip.GeoIP(_file)
    print geoDb.record_by_addr(_ip)

def main(_ip):
    ''' You can download GeoIP databases from here: https://dev.maxmind.com/geoip/legacy/geolite '''
    geo('GeoIP/GeoLiteCity.dat', _ip)

if __name__ == "__main__":
    print 'FluScan, an IPv4 scanner. Created by http://www.flu-project.com\n'
    main('8.8.8.8')

El cual tras su ejecución nos dará el siguiente resultado:

administrator@administrator-MacBookPro:~/FluScan$ python FluScan.py
FluScan, an IPv4 scanner. Created by http://www.flu-project.com

{'city': u'Mountain View', 'region_code': u'CA', 'area_code': 650, 'time_zone': 'America/Los_Angeles', 'dma_code': 807, 'metro_code':
'San Francisco, CA', 'country_code3': 'USA', 'latitude': 37.385999999999996, 'postal_code': u'94035', 'longitude': -122.0838, 'country
_code': 'US', 'country_name': 'United States', 'continent': 'NA'}


Pygeoip nos da una gran potencia para jugar con los datos referentes al geoposicionamiento, y nos será de gran utilidad para dotar de nuevas funcionalidades a nuestro escáner, pero eso será para un próximo artículo.

Saludos!

lunes, 5 de diciembre de 2016

Construyendo nuestro propio escáner de dispositivos conectados a Internet. Parte 1

Compartir este artículo:
Buenas a todos, en el post de hoy me gustaría iniciar una cadena de artículos sobre escaneo de dispositivos conectados a Internet, con la idea de que podáis introduciros en el campo del footprint y el fingerprint de activos (al más puro estilo Shodan) y construiros vuestras propias bases de datos de información.

En Internet existen varias aproximaciones de empresas y particulares que han intentado resolver el complejo problema de obtener un listado lo más actualizado posible, con todos los activos conectados a Internet (webcams, impresoras, ftps, servidores web, scadas, etc. etc.), y uno de ellos, Shodan.io, es el que parece haber logrado los mejores resultados, ya que actualmente es el buscador más utilizado para estas tareas. Por ello, lo primero que haremos hoy será aprender de los mejores, y estudiar que tipo de información obtienen, y cómo podríamos obtenerla nosotros.

Tened en cuenta varias cosas antes de meternos en harina. Hay infinidad de formas de obtener la información que vamos a ver en este post, pero nos interesará la más óptima. ¿Por qué? La respuesta es sencilla, ¿os habéis planteado los millones de IPv4 e IPv6 existentes en Internet y el tiempo que tardaríamos en analizarlas todas? ¿Y que cuando acabásemos, es altamente probable que muchos hosts ya no existan, y habrá que volver a escanear? ¿Sí? ¡Me alegro! Es el primer paso para reconocer que no es una labor trivial, y por ello son pocos los servicios existentes en la actualidad.

Por otro lado, tenemos el gran problema del almacenamiento. ¿Dónde almacenaríamos todos estos TB de información? Es por ello que en esta cadena de posts solo veremos una base, con fines académicos, para que podáis aprender a caminar solos, y escanear una parcelita controlada de Internet, que podáis almacenar de forma sencilla en cualquier disco duro que tengáis por casa.

El primero de los grandes proyectos que os quería presentar, es el de dos buenos amigos, Rafa y Fran, Mr looquer. Un buscador de servicios para IPv6, que a mí personalmente me encanta:




Os dejo su cuenta de Twitter para que podáis seguirlos:


Sin embargo, en esta cadena de posts vamos a dejar IPv6 a un lado, ya que cómo recordaréis los que nos seguís habitualmente, estamos dedicando una cadena exclusiva a IPv6 y a sus ataques. Y por ello, vamos a estudiar otro gran proyecto del que os hemos hablado en infinitas ocasiones, Shodan.io, el cual no hará falta introducir.

Si buscamos en shodan por ejemplo, "webcam", encontramos 3.400 resultados:



Haciendo clic en uno de ellos al azar, veremos numerosos datos de cada uno de los activos escaneados, los cuales procedemos a listar a continuación:

  • Country: el primer dato que nos encontramos es el país dónde se encuentra ubicado el dispositivo. Este es un dato que podremos obtener de forma sencilla consultando en un tercero (existen muchos servicios gratuitos con un API, que dada una IP devuelven el detalle sobre su ubicación). Sin embargo hay que tener en cuenta que cómo realicemos muchos escaneos seguidos, acabaremos baneados. Y a menos que utilicemos proxys que automáticamente vayamos balanceando... puede que no sea una buena aproximación. Otra opción será descargarnos una bbdd de direcciones IP, e irla actualizando cada poco tiempo.Si utilizásemos Python como lenguaje para programar nuestro escáner, Pygeoip podría ser un módulo muy útil para ello: https://pypi.python.org/pypi/pygeoip 


  • Organization e ISP: este dato lo podremos obtener de numerosas maneras, las cuales iremos viendo próximamente.
  • Last Update: última fecha a la que el escáner accedió a la dirección IP. Fácil de obtener desde nuestro código.
  • Hostnames: este dato lo podremos obtener de forma simple con nslookup (https://es.wikipedia.org/wiki/Nslookup), disponible en todos los sistemas operativos. A continuación os comparto el resultado para una IP de Facebook:

  • Ports: los puertos abiertos del host escaneado. Hay infinidad de escáneres que podremos utilizar. Pero ¡ojo!. En algunos países un escaneo de puertos es considerado cómo un ataque, por lo que es recomendable limitar los puertos a escanear, y realizar el proceso de la manera más liviana y menos molesta.
  • Services: la verdadera "chicha" de todo el proyecto, el detalle de los servicios que se encuentran escuchando tras los puertos abiertos, y que prestan servicio a los diferentes usuarios de Internet para los que se han publicado.
Si no tenéis tiempo (o ganas) de programar todo esto, y queréis obtener resultados rápidos, siempre podéis hacer uso directo del API de Shodan, que por 499 $ mensuales nos proporciona acceso total al servicio:





Pero... cómo aquí estamos para aprender :), en los próximos posts comenzaremos a trastear con código para sentar las bases de nuestro futuro escáner.

Saludos!