Bueno, pues haciendo el PFC, me ha surgido un obstáculo a la hora de crear/inicializar las VMs, el problema es que para conectarte a una VM (más en concreto un LiveCD DVL) por ssh, hay que tener el servicio levantado, y para levantarlo hace falta conectarte...

Dándole vueltas, se me ocurrió que se podría usar el Servidor VNC que gestiona libvirt a la hora de crear VMs con virsh para simular la pulsación de teclas y así conseguir nuestro propósito, levantar el interfaz de red y el servicio ssh.

Leyendo las especificaciones del protocolo que usa VNC para acceder a las interfaces gráficas (RFB), se ve que es bastante sencillo, así que me he hecho un miniprograma en python que simula pulsaciones de teclado y las manda, y parece que funciona de lujo!

Su uso es sencillo, recibe 3 argumentos: servidor VNC, puerto, y archivo de órdenes
En el archivo de órdenes se le pueden especificar 3 tipos de orden, aquí un ejemplo:

send_string ifconfig eth0 192.168.2.50 netmask 255.255.255.0
sleep 4
send_key Return

En este caso se enviaría el ifconfig eth0..., se esperaría 4 segundos, y finalmente simularía la pulsación de Return

Os dejo el code (seguro que se puede mejorar, pero cumple su propósito):

import socket
import time
import struct
import sys

class RFBClient:
 # usar /usr/include/X11/keysymdef.h
 keycodes = {
  'BackSpace' : 0xff08,
  'Tab' :       0xff09,
  'Return' :    0xff0d,
  'Escape' :    0xff1b,
  'Insert' :    0xff63,
  'Delete' :    0xffff,
  'Home' :      0xff50,
  'End' :       0xff57,
  'PageUp' :    0xff55,
  'PageDown' :  0xff56,
  'Left' :      0xff51,
  'Up' :        0xff52,
  'Right' :     0xff53,
  'Down' :      0xff54,
  'F1' :        0xffbe,
  'F2' :        0xffbf,
  'F3' :        0xffc0,
  'F4' :        0xffc1,
  'F5' :        0xffc2,
  'F6' :        0xffc3,
  'F7' :        0xffc4,
  'F8' :        0xffc5,
  'F9' :        0xffc6,
  'F10' :       0xffc7,
  'F11' :       0xffc8,
  'F12' :       0xffc9,
  'F13' :       0xFFCA,
  'F14' :       0xFFCB,
  'F15' :       0xFFCC,
  'F16' :       0xFFCD,
  'F17' :       0xFFCE,
  'F18' :       0xFFCF,
  'F19' :       0xFFD0,
  'F20' :       0xFFD1,
  'ShiftLeft' : 0xffe1,
  'ShiftRight' : 0xffe2,
  'ControlLeft' : 0xffe3,
  'ControlRight' : 0xffe4,
  'MetaLeft' :  0xffe7,
  'MetaRight' : 0xffe8,
  'AltLeft' :   0xffe9,
  'AltRight' :  0xffea,

  'Scroll_Lock' : 0xFF14,
  'Sys_Req' :   0xFF15,
  'Num_Lock' :  0xFF7F,
  'Caps_Lock' : 0xFFE5,
  'Pause' :     0xFF13,
  'Super_L' :   0xFFEB,
  'Super_R' :   0xFFEC,
  'Hyper_L' :   0xFFED,
  'Hyper_R' :   0xFFEE,

  'KP_0' :      0xFFB0,
  'KP_1' :      0xFFB1,
  'KP_2' :      0xFFB2,
  'KP_3' :      0xFFB3,
  'KP_4' :      0xFFB4,
  'KP_5' :      0xFFB5,
  'KP_6' :      0xFFB6,
  'KP_7' :      0xFFB7,
  'KP_8' :      0xFFB8,
  'KP_9' :      0xFFB9,
  'KP_Enter' :  0xFF8D,
 }

 def __init__(self, address):
  # conectamos
  self.s = s = socket.socket()
  s.connect(address)

  # negociamos version
  version = s.recv(12)
  print version.strip()
  s.sendall(version)

  # negociamos seguridad
  security_types = ord(s.recv(1))
  for i in range(security_types):
   s.recv(1)

  s.sendall(chr(1))
  struct.unpack('!I', s.recv(4))

  # iniciamos cliente (compartido)
  s.sendall(chr(1))

 def __send_keycode(self, keycode):
  self.s.sendall(struct.pack("!BBxxI", 4, 1, keycode))
  time.sleep(0.05)
  self.s.sendall(struct.pack("!BBxxI", 4, 0, keycode))

 def send_string(self, string):
  for c in string:
   self.__send_keycode(ord(c))

 def send_key(self, key):
  self.__send_keycode(self.keycodes[key])


if(len(sys.argv) != 4):
 print "\n\t[+] Uso: " + sys.argv[0] + " servidor_VNC puerto archivo_ordenes\n"
else:
 #abrimos archivo de ordenes
 fd = open(sys.argv[3], "r")
 
 #conectamos con los datos suministrados
 client = RFBClient((sys.argv[1], int(sys.argv[2])))

 #leemos linea por linea y parseamos el tipo de orden
 fileList = fd.readlines()
 for fileLine in fileList:
  parsed=fileLine.partition(' ')
  print "\nComando: " + parsed[0] + " argumento: " + parsed[2]
  if(parsed[0]=="send_string"):
   client.send_string(parsed[2])
  elif(parsed[0]=="send_key"):
   client.send_key(parsed[2].replace('\n',''));
  elif(parsed[0]=="sleep"):
   time.sleep(int(parsed[2]))
  else:
   print "\n\t[!] Comando invalido\n"  
  
 #cerramos el descriptor
 fd.close()

Como soy un poco perro, y escribí el artículo en PDF, por no pasar de nuevo las imágenes y tal he incrustado el documento, ahí va:

Tras casi 8 meses de desarrollo, el día de hoy hemos decidido hacer público el canal IRC de elhacker.net, y en este post me gustaría explicar lo que hay detrás de este.

Hemos tardado tanto, debido a que hemos decidido desarrollar un bot de IRC desde zero, que al mismo tiempo, usará la misma base de datos de otros proyectos. Y debido a que los participantes de este proyecto trabajan o estudian, solo había un par de horas al mes a dedicarle al proyecto.

En primera, explicaré cuales fueron los motivos por los cuales, aun cuando los usuarios lo habian pedido tanto, no se había hecho un canal IRC oficial hasta hoy, cuales fueron nuestros retos, y las soluciones que ideamos para los problemas que encontramos.

Antes que nada, habría que explicar que en el pasado, ya hubo un canal IRC en elhacker.net, pero fue cerrado hace ya varios años, debido a que el canal parecía ser usado para hablar temas que incluso estaban baneados en el foro, y fuera de cualquier cosa, dañaba la reputación que tenia nuestra comunidad. Otro motivo, era la moderación del mismo, cuando personas que no tenían porque ser moderadores, tenían privilegios sobre el canal, y abusaban de tal poder, sin tener a quien rendir cuentas.

Fue así, como tras el fracaso que tuvo ese canal, se decidió no volver a hacer uno.. Sin embargo, tras el entusiasmo de nuestros usuarios, decidimos idear un modelo en el cual se evitaran esos problemas, al mudar su funcionamiento a algo mas transparente.

Los problemas que hemos querido solucionar han sido:

1. Evitar abusos de poder
2. Mejorar la eficacia de los bans
3. Controlar mejor el contenido

Así también, hemos querido utilizar el canal IRC para cosas útiles, en las que podríamos organizar eventos, charlas y entrevistas.

Por lo que decidimos que, a pena de sacrificar tráfico en el canal, se usaría un modelo donde nuestros usuarios habituales del foro, pudieran charlar, y convivir, al mismo tiempo que crearíamos un espacio para organizar eventos simultáneos alrededor del mundo, sin afectar la integridad del canal.

Nuestras metas secundarias para el canal son:

1. Integrarlo con nuestros servicios actuales.
2. Habilitar su uso de forma educativa.

Dicho lo cual, pasaremos a explicar los detalles de la implementación.

Para empezar, el canal esta en una red pública, en un servidor público, lo que hace que este trabaje bajo la supervición y mantenimiento de otro grupo de personas (en nuestro caso Freenode). Hemos decidido Freenode, debido a que cuentan con una red grande de servidores, distribuidos alrededor del mundo, proveen una serie de servicios que requerimos, y están comprometidos a apoyar a grupos y comunidades sin ánimo de lucro como lo es elhacker.net.

El canal sera moderado por nuestro STAFF de forma democrática, es decir, a excepción de los coAdministradores, los colaboradores no podrán banear a un usuario, sino que necesitaran que otros dos colaboradores apoyen el ban, o ademas de el, un moderador global. El objetivo, es que una riña entre un usuario STAFF y un no STAFF no conlleve a un ban del canal.

Otro punto a destacar de los bans, es que un ban no te saca del canal, sino que simplemente te quita la voz, lo que te permite permanecer en el, pero sin la posibilidad de decir nada. Aunque puedes charlar con otros usuarios de forma privada, así como pedir que se quite un ban si el usuario considera fue injusto.

Algo que se debe tomar en cuenta, es que un ban, seria muy poco útil, si permitimos que cualquier usuario pueda simplemente registrar un usuario nuevo y entrar de nuevo al canal, por lo que hemos decidido solo permitir el acceso al canal a los usuarios que tengan cierta antiguedad y mensajes en el foro. Hemos intentado hacer esto de la forma mas justa posible, al simplemente intentar mantener solo a nuestros usuarios habituales del foro.

De esta forma, intentamos que no haya usuarios que se registran en el foro para entrar al canal IRC, sino que, entran al canal IRC por ser usuarios del foro. Una pequeña pero importante diferencia. Ya que el canal IRC es un servicio para nuestros usuarios, y no para nuestros visitantes.

Los visitantes, sin embargo, tendrán acceso libre a leer el contenido del canal de forma perpetua, ya que se guardara y publicara un log del canal. Así creando un repositorio público de todos los mensajes. De esta forma, proveemos un archivo para demostrar de forma transparente lo que se diga o haga en el canal, así como dar la oportunidad a todos de leer de lo que se trata en el mismo.

Otro punto importante en el canal, es la integración con los otros servicios. Con el objetivo de compartir una identidad entre distintos servicios, se ha creado un sistema donde debes asociar una cuenta de elhacker.net con un nickname de IRC. Esto se hace usando nuestro bot llamado "bianc4" (bianca). Bianca se encarga de loguear todo lo que se dice en el canal, asi como dar y quitar privilegios.

Detalles sobre la implementación de bianc4, que será opensource en el futuro, así como la web del archivo público del log del IRC, se explicarán en otro blogpost en otra ocasión. Si deseas entrar YA! al canal IRC, te recomendamos vayas a: http://foro.elhacker.net/irc.html

Si no cuentas con privilegios para entrar al canal, mándanos un correo a irc@elhacker.net =)

Si deseas ver el log público, visita la web de bianc4 en http://bot.elhacker.net/ este contiene un log en vivo, donde puedes ver lo que platica en el canal en tiempo real.

Para una guía completa de como entrar al canal visita http://r.i.elhacker.net/ircDoc

Para poder registrarte en el canal, necesitas registrar tu nickname en Freenode primero, hemos recibido ayuda de nuestros usuarios para crear video tutoriales!





Esperamos entren! Mucha suerte :)

Saludos!!

- Anon

A menudo nos encontramos con noticias sobre fugas de información en empresas tanto de carácter público como privado, la pérdida de un USB, un disco duro "viejo" tirado en la basura como si se tratase de un cleanex, documentos con datos que no se ven pero que están ahí... la mayoría de las veces la información se encuentra a simple vista en los dispositivos, pero que sucede si dicha información ha sido borrada, o mejor aun, el dispositivo ha sido formateado?.
Incluso después del borrado/formateo/reparticionado podemos tener acceso a esta información, existen varias técnicas, tanto hardware como software, pero hoy nos vamos a centrar en una de ellas: File Carving

El File Carving es el proceso de extracción de una serie de datos que se encuentran dentro de otro conjunto mayor de datos. Las técnicas de Data Carving son usadas frecuentemente en Análisis Forense cuando nos encontramos con porciones de datos pertenecientes al Sistema de Archivos que a primera vista no están usados pero que pueden tener sorpresas.

Han pasado apenas unos días desde la salida de un nuevo OS basado en Linux(aun en versión Alpha), Qubes, uno más podríamos pensar... quizás si, pero quizás no.

Este OS está enfocado principalmente a la Seguridad (hasta aquí nada nuevo), y para conseguir esto, uno de los pilares básicos sobre el que se construye es Xen (Software de virtualización muy conocido en ámbitos Linux),  con el que se pretende construir "bloques" en los que los usuarios pueden organizar distintos grupos de aplicaciones. Estas VM's son gestionadas por el hypervisor de Xen (ligeramente modificado en este proyecto, apenas 2500 líneas de código se han añadido), manteniendo a las aplicaciones usadas para la oficina, por ejemplo, separadas de las aplicaciones que se usan en casa.

Como cada año, en este mes se monta un "mini-concurso" para ver quien es el que mejor se maneja en cuanto a programación de malware. Creo que no hacen falta presentaciones, ya que más o menos todos sabéis de que se trata, aqui van las bases y premios del concurso.

• Bases del concurso:
  
  Como cada año, se tienen que presentar las herramientas diseñadas por los participantes. Se puede tratar cualquier tema relacionado con el malware a excepción de DoS/DDoS.
  
  Los proyectos tienen que ser obligatoriamente open source, para que se puedan evaluar mejor las herramientas. Se tiene que presentar el proyecto comprimido con 2 carpetas en su interior, una para el exe (bin) y otra para el código (src), para que este bien presentado y ordenado.
  
  Los vencedores se decidirán por votación popular, es decir, los que se descarguen el proyecto y lo evalúen, votarán su proyecto favorito. Al final de la votación, el que tenga más puntos será el ganador. El 30 de Abril se publicará la lista final con todos los proyectos publicados en este Abril Negro. En esta lista los usuarios votarán su proyecto favorito. Esta lista quedará abierta 2 semanas (hasta el viernes 14 de Mayo).
  
  En caso de empate, miembros del Staff evaluaran los proyectos empatados y se decidirá el ganador según estos aspectos:
  
  
  
  
  • Innovación de la herramienta/código
  • Mejor código
  
  Para publicar los proyectos, se tiene que incluir la etiqueta [Abril Negro] delante del título de cada post.
  
  
• Premios
  
  Los premios de este año, al igual que el anterior, constará de una cuenta @elhacker.net y la publicación en el tablón oficial de la aplicación, pero ya que este año contamos con el blog. Se publicará una entrada en dicho blog en la cual se presentará la aplicación ganadora de Abril Negro.
  
  Al final de dicho concurso, todas los proyectos presentados serán publicados en la lista de recopilatorio de aplicaciones de Abril Negro 2010.
  
  Anímense a participar en este concurso . Mucha suerte a todos los participantes, y que empiece la función!

enlace al post en el foro: http://foro.elhacker.net/analisis_y_diseno_de_malware/abril_negro_2010-t289363.0.html