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