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()

Bueno, pues después de daros la plasta con la parte “teórica”, vamos a ver algo más práctico, para empezar analizaremos el modus-operandi de un rootkit que trabaja en espacio de usuario. Ya se
explicó someramente como trabajan estos, y para ejemplificarlo que mejor que ponernos manos a laobra a despiezar un rootkit de este tipo, en este caso “shv6”.

Para ello nos vamos a servir de una VM con un Ubuntu Server instalado, con el únic oañadido de que contará con tripwire, programa que sirve para comprobar la integridad de los archivos instalados en nuestro sistema y que nos ayudará a ver mejor los cambios que se llevan acabo en el sistema por este tipo de rootkits.