Class: VirtualMachine

Inherits:

Object

• Object
• VirtualMachine

Defined in:

lib/virtualmachine.rb,
ext/virtualmachine/virtualmachine.c

Instance Method Summary

• #initialize(vmname, memsize) ⇒ Object constructor
• #load_asm(program) ⇒ Object
• #load_binary(program) ⇒ Object
• #run ⇒ Object

Constructor Details

#initialize(vmname, memsize) ⇒ Object

# File 'ext/virtualmachine/virtualmachine.c', line 109

VALUE virtualmachine_initialize(VALUE self, VALUE vmname, VALUE memsize)
{
  VALUE vctx;
  struct vmctx *ctx;
  uint64_t *gdt, *pt4, *pt3, *pt2;
  int i;

  vm_create(StringValuePtr(vmname));
  ctx = vm_open(StringValuePtr(vmname));
  vctx = Data_Wrap_Struct(rb_cVMCtx, NULL, vmctx_free, ctx);
  rb_iv_set(self, "@ctx", vctx);
  rb_iv_set(self, "@vmname", vmname);
  rb_iv_set(self, "@memsize", memsize);
  vm_setup_memory(ctx, FIX2INT(memsize) * MB, VM_MMAP_ALL);

  pt4 = vm_map_gpa(ctx, ADDR_PT4, sizeof(uint64_t) * 512);
  pt3 = vm_map_gpa(ctx, ADDR_PT3, sizeof(uint64_t) * 512);
  pt2 = vm_map_gpa(ctx, ADDR_PT2, sizeof(uint64_t) * 512);
  gdt = vm_map_gpa(ctx, ADDR_GDT, sizeof(uint64_t) * 3);

  bzero(pt4, PAGE_SIZE);
  bzero(pt3, PAGE_SIZE);
  bzero(pt2, PAGE_SIZE);

  for (i = 0; i < 512; i++) {
    pt4[i] = (uint64_t)ADDR_PT3;
    pt4[i] |= PG_V | PG_RW | PG_U;
    pt3[i] = (uint64_t)ADDR_PT2;
    pt3[i] |= PG_V | PG_RW | PG_U;
    pt2[i] = i * (2 * 1024 * 1024);
    pt2[i] |= PG_V | PG_RW | PG_PS | PG_U;
  }

  gdt[GUEST_NULL_SEL] = 0;
  gdt[GUEST_CODE_SEL] = 0x0020980000000000;
  gdt[GUEST_DATA_SEL] = 0x0000900000000000;

  vm_set_desc(ctx, 0, VM_REG_GUEST_CS, 0, 0, 0x0000209B);
  vm_set_desc(ctx, 0, VM_REG_GUEST_DS, 0, 0, 0x00000093);
  vm_set_desc(ctx, 0, VM_REG_GUEST_ES, 0, 0, 0x00000093);
  vm_set_desc(ctx, 0, VM_REG_GUEST_FS, 0, 0, 0x00000093);
  vm_set_desc(ctx, 0, VM_REG_GUEST_GS, 0, 0, 0x00000093);
  vm_set_desc(ctx, 0, VM_REG_GUEST_SS, 0, 0, 0x00000093);
  vm_set_desc(ctx, 0, VM_REG_GUEST_TR, 0, 0, 0x0000008b);
  vm_set_desc(ctx, 0, VM_REG_GUEST_LDTR, 0, 0, DESC_UNUSABLE);
  vm_set_desc(ctx, 0, VM_REG_GUEST_GDTR, ADDR_GDT, GUEST_GDTR_LIMIT, 0);

  vm_set_register(ctx, 0, VM_REG_GUEST_CS, GSEL(GUEST_CODE_SEL, SEL_KPL));
  vm_set_register(ctx, 0, VM_REG_GUEST_DS, GSEL(GUEST_DATA_SEL, SEL_KPL));
  vm_set_register(ctx, 0, VM_REG_GUEST_ES, GSEL(GUEST_DATA_SEL, SEL_KPL));
  vm_set_register(ctx, 0, VM_REG_GUEST_FS, GSEL(GUEST_DATA_SEL, SEL_KPL));
  vm_set_register(ctx, 0, VM_REG_GUEST_GS, GSEL(GUEST_DATA_SEL, SEL_KPL));
  vm_set_register(ctx, 0, VM_REG_GUEST_SS, GSEL(GUEST_DATA_SEL, SEL_KPL));
  vm_set_register(ctx, 0, VM_REG_GUEST_TR, 0);
  vm_set_register(ctx, 0, VM_REG_GUEST_LDTR, 0);

  vm_set_register(ctx, 0, VM_REG_GUEST_CR0, CR0_PG | CR0_PE | CR0_NE);
  vm_set_register(ctx, 0, VM_REG_GUEST_CR3, ADDR_PT4);
  vm_set_register(ctx, 0, VM_REG_GUEST_CR4, CR4_PAE | CR4_VMXE);
  vm_set_register(ctx, 0, VM_REG_GUEST_EFER, EFER_LMA | EFER_LME);
  vm_set_register(ctx, 0, VM_REG_GUEST_RFLAGS, 0x2);
  vm_set_register(ctx, 0, VM_REG_GUEST_RSP, ADDR_STACK);

  return self;
}

Instance Method Details

#load_asm(program) ⇒ Object

# File 'lib/virtualmachine.rb', line 5

def load_asm(program)
  edata = Metasm::Shellcode.assemble(Metasm::X64.new, program).encoded
  load_binary(edata.data)
end

#load_binary(program) ⇒ Object

# File 'ext/virtualmachine/virtualmachine.c', line 175

VALUE virtualmachine_load_binary(VALUE self, VALUE program)
{
  VALUE vctx = rb_iv_get(self, "@ctx");
  struct vmctx *ctx;
  unsigned char *entry;

  Data_Get_Struct(vctx, struct vmctx, ctx);
  entry = vm_map_gpa(ctx, ADDR_ENTRY, RSTRING_LEN(program));
  memcpy(entry, StringValuePtr(program), RSTRING_LEN(program));
  vm_set_register(ctx, 0, VM_REG_GUEST_RIP, ADDR_ENTRY);
  return Qnil;
}

#run ⇒ Object

# File 'lib/virtualmachine.rb', line 10

def run
  system("/usr/sbin/bhyve -c 1 -m #{@memsize} -s 0:0,hostbridge -S 31,uart,stdio #{@vmname}")
end