hypervisor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d3a9c9ae2e397be3f6b354a4adb17e8922b175061a398b2500f0d38fffcaadaa
+  data.tar.gz: 4c33c8bd868d7f27937c0335f9a3168555ed9d5929a50baa10dc5b1106f705fd
+SHA512:
+  metadata.gz: ce031fd0405934eeb2910c9a55d33580e4538f92458068db1221a574b1231d62e2ed790a7f7cb2186477050c1802e50fca1f97367843d06af5cc4c35f1dd47b7
+  data.tar.gz: 70c68c9640c6631819f1df051fc101568df6f912f5138bb438b4ebf32ae7582dae90481d938f1905e03379624efdb1b0db6f1a9b5f0ccaecfd068b5455a38dbd

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.2

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in hv.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Aurora
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Hypervisor
+
+`hypervisor` is a gem that provides Ruby code access to the hypervisor on macOS.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hv'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hv
+
+## Usage
+
+There's `examples/dos` that is a script that implements the start of a DOS kernel in Ruby.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rawrasaur/hvpervisor.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hv"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/dos

@@ -0,0 +1,226 @@
+#!/usr/bin/env ruby
+
+require "hypervisor"
+
+MEMORY_SIZE = 1 << 20 # 1 MB
+
+class DOSKernel
+  class Stop < StandardError
+    attr_reader :return_value
+
+    def initialize(return_value)
+      @return_value = return_value
+
+      super("Exiting DOS")
+    end
+  end
+
+  def initialize(memory, argv)
+    @memory = memory
+    @argv = argv
+    @dta = 0
+
+    @fds = {
+      0 => $stdin,
+      1 => $stdout,
+      2 => $stderr
+    }
+    
+    @next_fd = 2
+    
+    @memory.put_bytes(0x00, [0xcd, 0x20].pack("c*"))
+    @memory.put_bytes(0x50, [0xcd, 0x21, 0xcb].pack("c*"))
+    @memory.put_bytes(0x5C, [0x01, 0x20].pack("c*"))
+    
+    argv = argv.map { |x| " #{x}" }.join('')
+    
+    @memory.put_bytes(0x80, [argv.bytesize, argv, 0x0d].pack("cA*c"))
+  end
+
+  def dispatch(cpu, int)
+    case int
+    when 0x20
+      interrupt_0x20(cpu)
+    when 0x21
+      interrupt_0x21(cpu)
+    else
+      raise "Unknown interrupt: #{int}"
+    end
+  end
+
+  private def allocate_fd
+    @next_fd += 1
+  end
+
+  private def interrupt_0x20(cpu)
+    raise "Unsupported: int 0x20 / #{cpu.ah.to_s(16)}"
+  end
+
+  private def interrupt_0x21(cpu)
+    case cpu.ah
+    when 0x1a # set dta
+      @dta = cpu.dx
+    when 0x30 # version
+      cpu.write_register(Hypervisor::X86_RAX, 0x0700)
+    when 0x3d # open
+      # TODO: Don't ignore OFLAG
+      fd = File.open(read_string(cpu.ds, cpu.dx))
+      dos_fd = allocate_fd
+
+      @fds[dos_fd] = fd
+
+      cpu.ax = dos_fd
+      cpu.cf = 0
+    when 0x3f # read
+      fd = @fds.fetch(cpu.bx)
+      data = fd.read(cpu.cx)
+
+      if data
+        write_segment(cpu.ds, cpu.dx, data)
+
+        cpu.ax = data.bytesize
+        cpu.cf = 0
+      else
+        cpu.ax = 0
+        cpu.cf = 1
+      end
+    when 0x40 # write
+      fd = @fds.fetch(cpu.bx)
+
+      cpu.ax = fd.write(read_segment(cpu.ds, cpu.dx, cpu.cx))
+      cpu.cf = 0
+    when 0x42 # lseek
+      fd = @fds.fetch(cpu.bx)
+
+      fd.seek(cpu.cx << 16 | cpu.dx, cpu.al)
+    when 0x4c # exit
+      raise Stop.new(cpu.al)
+    else
+      raise "Unsupported: int 0x21 / #{cpu.ah.to_s(16)}"
+    end
+  end
+
+  def read_segment(s, x, length)
+    @memory.get_bytes((s << 4) + x, length)
+  end
+
+  def read_string(s, x)
+    @memory.get_string((s << 4) + x)
+  end
+
+  def write_segment(s, x, value)
+    @memory.put_bytes((s << 4) + x, value)
+  end
+end
+
+def cap(cap, ctrl)
+  (ctrl | (cap & 0xffffffff)) & (cap >> 32)
+end
+
+Hypervisor.create
+
+memory = Hypervisor.allocate(MEMORY_SIZE)
+memory.put_bytes(0x100, File.read(ARGV[0]))
+
+kernel = DOSKernel.new(memory, ARGV[1 .. -1])
+
+Hypervisor.map(memory, 0, MEMORY_SIZE, Hypervisor::MEMORY_READ | Hypervisor::MEMORY_WRITE | Hypervisor::MEMORY_EXEC)
+
+cpu = Hypervisor::VCPU.new
+cpu.write_vmcs(Hypervisor::VMX_CAP_PINBASED, cap(Hypervisor.read_capability(Hypervisor::VMX_CAP_PINBASED), 0))
+cpu.write_vmcs(Hypervisor::VMX_CAP_PROCBASED, cap(Hypervisor.read_capability(Hypervisor::VMX_CAP_PROCBASED), Hypervisor::CPU_BASED_HLT | Hypervisor::CPU_BASED_CR8_LOAD | Hypervisor::CPU_BASED_CR8_STORE))
+cpu.write_vmcs(Hypervisor::VMX_CAP_PROCBASED2, cap(Hypervisor.read_capability(Hypervisor::VMX_CAP_PROCBASED2), 0))
+cpu.write_vmcs(Hypervisor::VMX_CAP_ENTRY, cap(Hypervisor.read_capability(Hypervisor::VMX_CAP_ENTRY), 0))
+cpu.write_vmcs(Hypervisor::VMX_CAP_PREEMPTION_TIMER, cap(Hypervisor.read_capability(Hypervisor::VMX_CAP_PREEMPTION_TIMER), 0))
+
+cpu.write_vmcs(Hypervisor::VMCS_CTRL_EXC_BITMAP, 0xffffffff)
+cpu.write_vmcs(Hypervisor::VMCS_CTRL_CR0_MASK, 0x60000000)
+cpu.write_vmcs(Hypervisor::VMCS_CTRL_CR0_SHADOW, 0)
+cpu.write_vmcs(Hypervisor::VMCS_CTRL_CR4_MASK, 0)
+cpu.write_vmcs(Hypervisor::VMCS_CTRL_CR4_SHADOW, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_CS, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_CS_LIMIT, 0xffff)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_CS_AR, 0x9b)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_CS_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_DS, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_DS_LIMIT, 0xffff)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_DS_AR, 0x93)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_DS_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_ES, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_ES_LIMIT, 0xffff)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_ES_AR, 0x93)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_ES_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_FS, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_FS_LIMIT, 0xffff)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_FS_AR, 0x93)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_FS_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_GS, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_GS_LIMIT, 0xffff)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_GS_AR, 0x93)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_GS_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_SS, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_SS_LIMIT, 0xffff)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_SS_AR, 0x93)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_SS_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_LDTR, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_LDTR_LIMIT, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_LDTR_AR, 0x10000)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_LDTR_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_TR, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_TR_LIMIT, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_TR_AR, 0x83)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_TR_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_GDTR_LIMIT, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_GDTR_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_IDTR_LIMIT, 0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_IDTR_BASE, 0)
+
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_CR0, 0x20)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_CR3, 0x0)
+cpu.write_vmcs(Hypervisor::VMCS_GUEST_CR4, 0x2000)
+
+cpu.write_register(Hypervisor::X86_RIP, 0x100)
+cpu.write_register(Hypervisor::X86_RFLAGS, 0x2)
+cpu.write_register(Hypervisor::X86_RSP, 0x0)
+
+return_value = -1
+
+loop do
+  cpu.run
+
+  case cpu.read_vmcs(Hypervisor::VMCS_RO_EXIT_REASON)
+  when Hypervisor::VMX_REASON_EPT_VIOLATION, Hypervisor::VMX_REASON_IRQ
+    next
+  when Hypervisor::VMX_REASON_HLT
+    break
+  when Hypervisor::VMX_REASON_EXC_NMI
+    n = cpu.read_vmcs(Hypervisor::VMCS_RO_IDT_VECTOR_INFO) & 0xff
+
+    begin
+      kernel.dispatch(cpu, n)
+      cpu.write_register(Hypervisor::X86_RIP, cpu.read_register(Hypervisor::X86_RIP) + 2)
+    rescue DOSKernel::Stop => e
+      return_value = e.return_value
+      break
+    end
+  else
+    $stderr.puts("ERROR: #{cpu.read_vmcs(Hypervisor::VMCS_RO_EXIT_REASON)}")
+    break
+  end
+end
+
+cpu.destroy!
+
+Hypervisor.destroy
+
+exit(return_value)

data/hypervisor.gemspec

@@ -0,0 +1,30 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "hypervisor/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hypervisor"
+  spec.version       = Hypervisor::VERSION
+  spec.authors       = ["Aurora"]
+  spec.email         = ["aurora@aventine.se"]
+
+  spec.summary       = %q{Hypervisor for macOS}
+  spec.description   = %q{A wrapper for Hypervisor.framework on macOS}
+  spec.homepage      = "https://github.com/rawrasaur/hvpervisor"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_runtime_dependency "ffi", "~> 1.9"
+end

data/lib/hypervisor.rb

@@ -0,0 +1,44 @@
+require "hypervisor/version"
+require "hypervisor/constants"
+require "hypervisor/framework"
+require "hypervisor/vcpu"
+
+require 'ffi'
+
+module Hypervisor
+  def self.allocate(n, &block)
+    FFI::AutoPointer.new(Hypervisor::Framework.valloc(n), Hypervisor::Framework.method(:free), &block)
+  end
+
+  def self.create(options = VM_DEFAULT)
+    Framework.return_t(Framework.hv_vm_create(options))
+  end
+
+  def self.destroy
+    Framework.return_t(Framework.hv_vm_destroy)
+  end
+
+  def self.map(uva, gpa, size, flags)
+    Framework.return_t(Framework.hv_vm_map(uva, gpa, size, flags))
+  end
+
+  def self.unmap(gpa, size)
+    Framework.return_t(Framework.hv_vm_unmap(gpa, size))
+  end
+
+  def self.protect(gpa, size, flags)
+    Framework.return_t(Framework.hv_vm_protect(gpa, size, flags))
+  end
+
+  def self.sync_tsc(tsc)
+    Framework.return_t(Framework.hv_vm_sync_tsc(tsc))
+  end
+
+  def self.read_capability(field)
+    FFI::MemoryPointer.new(:uint64_t, 1) do |value|
+      Framework.return_t(Framework.hv_vmx_read_capability(field, value))
+
+      return value.get_uint64(0)
+    end
+  end
+end

data/lib/hypervisor/constants.rb

@@ -0,0 +1,384 @@
+module Hypervisor
+  # hv_error.h
+
+  SUCCESS = 0
+  ERROR = 0xfae94001
+  BUSY = 0xfae94002
+  BAD_ARGUMENT = 0xfae94003
+  NO_RESOURCES = 0xfae94005
+  NO_DEVICE = 0xfae94006
+  UNSUPPORTED = 0xfae9400f
+
+  # hv_types.h
+
+  VM_DEFAULT = 0
+  VM_SPECIFY_MITIGATIONS = 1 << 0
+  VM_MITIGATION_A_ENABLE = 1 << 1
+  VM_MITIGATION_B_ENABLE = 1 << 2
+  VM_MITIGATION_C_ENABLE = 1 << 3
+  VM_MITIGATION_D_ENABLE = 1 << 4
+
+  VCPU_DEFAULT = 0
+
+  MEMORY_READ  = 1 << 0
+  MEMORY_WRITE = 1 << 1
+  MEMORY_EXEC  = 1 << 2
+
+  # hv_arch_x86.h
+
+  X86_RIP       = 0
+  X86_RFLAGS    = 1
+  X86_RAX       = 2
+  X86_RCX       = 3
+  X86_RDX       = 4
+  X86_RBX       = 5
+  X86_RSI       = 6
+  X86_RDI       = 7
+  X86_RSP       = 8
+  X86_RBP       = 9
+  X86_R8        = 10
+  X86_R9        = 11
+  X86_R10       = 12
+  X86_R11       = 13
+  X86_R12       = 14
+  X86_R13       = 15
+  X86_R14       = 16
+  X86_R15       = 17
+  X86_CS        = 18
+  X86_SS        = 19
+  X86_DS        = 20
+  X86_ES        = 21
+  X86_FS        = 22
+  X86_GS        = 23
+  X86_IDT_BASE  = 24
+  X86_IDT_LIMIT = 25
+  X86_GDT_BASE  = 26
+  X86_GDT_LIMIT = 27
+  X86_LDTR      = 28
+  X86_LDT_BASE  = 29
+  X86_LDT_LIMIT = 30
+  X86_LDT_AR    = 31
+  X86_TR        = 32
+  X86_TSS_BASE  = 33
+  X86_TSS_LIMIT = 34
+  X86_TSS_AR    = 35
+  X86_CR0       = 36
+  X86_CR1       = 37
+  X86_CR2       = 38
+  X86_CR3       = 39
+  X86_CR4       = 40
+  X86_DR0       = 41
+  X86_DR1       = 42
+  X86_DR2       = 43
+  X86_DR3       = 44
+  X86_DR4       = 45
+  X86_DR5       = 46
+  X86_DR6       = 47
+  X86_DR7       = 48
+  X86_TPR       = 49
+  X86_XCR0      = 50
+
+  # hv_vmx.h
+
+  VMX_CAP_PINBASED = 0
+  VMX_CAP_PROCBASED = 1
+  VMX_CAP_PROCBASED2 = 2
+  VMX_CAP_ENTRY = 3
+  VMX_CAP_EXIT = 4
+  VMX_CAP_PREEMPTION_TIMER = 32
+
+  # hv_arch_vmx.h
+
+  VMCS_VPID = 0x00000000
+  VMCS_CTRL_POSTED_INT_N_VECTOR = 0x00000002
+  VMCS_CTRL_EPTP_INDEX = 0x00000004
+  VMCS_GUEST_ES = 0x00000800
+  VMCS_GUEST_CS = 0x00000802
+  VMCS_GUEST_SS = 0x00000804
+  VMCS_GUEST_DS = 0x00000806
+  VMCS_GUEST_FS = 0x00000808
+  VMCS_GUEST_GS = 0x0000080a
+  VMCS_GUEST_LDTR = 0x0000080c
+  VMCS_GUEST_TR = 0x0000080e
+  VMCS_GUEST_INT_STATUS = 0x00000810
+  VMCS_HOST_ES = 0x00000c00
+  VMCS_HOST_CS = 0x00000c02
+  VMCS_HOST_SS = 0x00000c04
+  VMCS_HOST_DS = 0x00000c06
+  VMCS_HOST_FS = 0x00000c08
+  VMCS_HOST_GS = 0x00000c0a
+  VMCS_HOST_TR = 0x00000c0c
+  VMCS_CTRL_IO_BITMAP_A = 0x00002000
+  VMCS_CTRL_IO_BITMAP_B = 0x00002002
+  VMCS_CTRL_MSR_BITMAPS = 0x00002004
+  VMCS_CTRL_VMEXIT_MSR_STORE_ADDR = 0x00002006
+  VMCS_CTRL_VMEXIT_MSR_LOAD_ADDR = 0x00002008
+  VMCS_CTRL_VMENTRY_MSR_LOAD_ADDR = 0x0000200a
+  VMCS_CTRL_EXECUTIVE_VMCS_PTR = 0x0000200c
+  VMCS_CTRL_TSC_OFFSET = 0x00002010
+  VMCS_CTRL_VIRTUAL_APIC = 0x00002012
+  VMCS_CTRL_APIC_ACCESS = 0x00002014
+  VMCS_CTRL_POSTED_INT_DESC_ADDR = 0x00002016
+  VMCS_CTRL_VMFUNC_CTRL = 0x00002018
+  VMCS_CTRL_EPTP = 0x0000201a
+  VMCS_CTRL_EOI_EXIT_BITMAP_0 = 0x0000201c
+  VMCS_CTRL_EOI_EXIT_BITMAP_1 = 0x0000201e
+  VMCS_CTRL_EOI_EXIT_BITMAP_2 = 0x00002020
+  VMCS_CTRL_EOI_EXIT_BITMAP_3 = 0x00002022
+  VMCS_CTRL_EPTP_LIST_ADDR = 0x00002024
+  VMCS_CTRL_VMREAD_BITMAP_ADDR = 0x00002026
+  VMCS_CTRL_VMWRITE_BITMAP_ADDR = 0x00002028
+  VMCS_CTRL_VIRT_EXC_INFO_ADDR = 0x0000202a
+  VMCS_CTRL_XSS_EXITING_BITMAP = 0x0000202c
+  VMCS_GUEST_PHYSICAL_ADDRESS = 0x00002400
+  VMCS_GUEST_LINK_POINTER = 0x00002800
+  VMCS_GUEST_IA32_DEBUGCTL = 0x00002802
+  VMCS_GUEST_IA32_PAT = 0x00002804
+  VMCS_GUEST_IA32_EFER = 0x00002806
+  VMCS_GUEST_IA32_PERF_GLOBAL_CTRL = 0x00002808
+  VMCS_GUEST_PDPTE0 = 0x0000280a
+  VMCS_GUEST_PDPTE1 = 0x0000280c
+  VMCS_GUEST_PDPTE2 = 0x0000280e
+  VMCS_GUEST_PDPTE3 = 0x00002810
+  VMCS_HOST_IA32_PAT = 0x00002c00
+  VMCS_HOST_IA32_EFER = 0x00002c02
+  VMCS_HOST_IA32_PERF_GLOBAL_CTRL = 0x00002c04
+  VMCS_CTRL_PIN_BASED = 0x00004000
+  VMCS_CTRL_CPU_BASED = 0x00004002
+  VMCS_CTRL_EXC_BITMAP = 0x00004004
+  VMCS_CTRL_PF_ERROR_MASK = 0x00004006
+  VMCS_CTRL_PF_ERROR_MATCH = 0x00004008
+  VMCS_CTRL_CR3_COUNT = 0x0000400a
+  VMCS_CTRL_VMEXIT_CONTROLS = 0x0000400c
+  VMCS_CTRL_VMEXIT_MSR_STORE_COUNT = 0x0000400e
+  VMCS_CTRL_VMEXIT_MSR_LOAD_COUNT = 0x00004010
+  VMCS_CTRL_VMENTRY_CONTROLS = 0x00004012
+  VMCS_CTRL_VMENTRY_MSR_LOAD_COUNT = 0x00004014
+  VMCS_CTRL_VMENTRY_IRQ_INFO = 0x00004016
+  VMCS_CTRL_VMENTRY_EXC_ERROR = 0x00004018
+  VMCS_CTRL_VMENTRY_INSTR_LEN = 0x0000401a
+  VMCS_CTRL_TPR_THRESHOLD = 0x0000401c
+  VMCS_CTRL_CPU_BASED2 = 0x0000401e
+  VMCS_CTRL_PLE_GAP = 0x00004020
+  VMCS_CTRL_PLE_WINDOW = 0x00004022
+  VMCS_RO_INSTR_ERROR = 0x00004400
+  VMCS_RO_EXIT_REASON = 0x00004402
+  VMCS_RO_VMEXIT_IRQ_INFO = 0x00004404
+  VMCS_RO_VMEXIT_IRQ_ERROR = 0x00004406
+  VMCS_RO_IDT_VECTOR_INFO = 0x00004408
+  VMCS_RO_IDT_VECTOR_ERROR = 0x0000440a
+  VMCS_RO_VMEXIT_INSTR_LEN = 0x0000440c
+  VMCS_RO_VMX_INSTR_INFO = 0x0000440e
+  VMCS_GUEST_ES_LIMIT = 0x00004800
+  VMCS_GUEST_CS_LIMIT = 0x00004802
+  VMCS_GUEST_SS_LIMIT = 0x00004804
+  VMCS_GUEST_DS_LIMIT = 0x00004806
+  VMCS_GUEST_FS_LIMIT = 0x00004808
+  VMCS_GUEST_GS_LIMIT = 0x0000480a
+  VMCS_GUEST_LDTR_LIMIT = 0x0000480c
+  VMCS_GUEST_TR_LIMIT = 0x0000480e
+  VMCS_GUEST_GDTR_LIMIT = 0x00004810
+  VMCS_GUEST_IDTR_LIMIT = 0x00004812
+  VMCS_GUEST_ES_AR = 0x00004814
+  VMCS_GUEST_CS_AR = 0x00004816
+  VMCS_GUEST_SS_AR = 0x00004818
+  VMCS_GUEST_DS_AR = 0x0000481a
+  VMCS_GUEST_FS_AR = 0x0000481c
+  VMCS_GUEST_GS_AR = 0x0000481e
+  VMCS_GUEST_LDTR_AR = 0x00004820
+  VMCS_GUEST_TR_AR = 0x00004822
+  VMCS_GUEST_IGNORE_IRQ = 0x00004824
+  VMCS_GUEST_ACTIVITY_STATE = 0x00004826
+  VMCS_GUEST_SMBASE = 0x00004828
+  VMCS_GUEST_IA32_SYSENTER_CS = 0x0000482a
+  VMCS_GUEST_VMX_TIMER_VALUE = 0x0000482e
+  VMCS_HOST_IA32_SYSENTER_CS = 0x00004c00
+  VMCS_CTRL_CR0_MASK = 0x00006000
+  VMCS_CTRL_CR4_MASK = 0x00006002
+  VMCS_CTRL_CR0_SHADOW = 0x00006004
+  VMCS_CTRL_CR4_SHADOW = 0x00006006
+  VMCS_CTRL_CR3_VALUE0 = 0x00006008
+  VMCS_CTRL_CR3_VALUE1 = 0x0000600a
+  VMCS_CTRL_CR3_VALUE2 = 0x0000600c
+  VMCS_CTRL_CR3_VALUE3 = 0x0000600e
+  VMCS_RO_EXIT_QUALIFIC = 0x00006400
+  VMCS_RO_IO_RCX = 0x00006402
+  VMCS_RO_IO_RSI = 0x00006404
+  VMCS_RO_IO_RDI = 0x00006406
+  VMCS_RO_IO_RIP = 0x00006408
+  VMCS_RO_GUEST_LIN_ADDR = 0x0000640a
+  VMCS_GUEST_CR0 = 0x00006800
+  VMCS_GUEST_CR3 = 0x00006802
+  VMCS_GUEST_CR4 = 0x00006804
+  VMCS_GUEST_ES_BASE = 0x00006806
+  VMCS_GUEST_CS_BASE = 0x00006808
+  VMCS_GUEST_SS_BASE = 0x0000680a
+  VMCS_GUEST_DS_BASE = 0x0000680c
+  VMCS_GUEST_FS_BASE = 0x0000680e
+  VMCS_GUEST_GS_BASE = 0x00006810
+  VMCS_GUEST_LDTR_BASE = 0x00006812
+  VMCS_GUEST_TR_BASE = 0x00006814
+  VMCS_GUEST_GDTR_BASE = 0x00006816
+  VMCS_GUEST_IDTR_BASE = 0x00006818
+  VMCS_GUEST_DR7 = 0x0000681a
+  VMCS_GUEST_RSP = 0x0000681c
+  VMCS_GUEST_RIP = 0x0000681e
+  VMCS_GUEST_RFLAGS = 0x00006820
+  VMCS_GUEST_DEBUG_EXC = 0x00006822
+  VMCS_GUEST_SYSENTER_ESP = 0x00006824
+  VMCS_GUEST_SYSENTER_EIP = 0x00006826
+  VMCS_HOST_CR0 = 0x00006c00
+  VMCS_HOST_CR3 = 0x00006c02
+  VMCS_HOST_CR4 = 0x00006c04
+  VMCS_HOST_FS_BASE = 0x00006c06
+  VMCS_HOST_GS_BASE = 0x00006c08
+  VMCS_HOST_TR_BASE = 0x00006c0a
+  VMCS_HOST_GDTR_BASE = 0x00006c0c
+  VMCS_HOST_IDTR_BASE = 0x00006c0e
+  VMCS_HOST_IA32_SYSENTER_ESP = 0x00006c10
+  VMCS_HOST_IA32_SYSENTER_EIP = 0x00006c12
+  VMCS_HOST_RSP = 0x00006c14
+  VMCS_HOST_RIP = 0x00006c16
+  VMCS_MAX = 0x00006c18
+
+  VMX_BASIC_TRUE_CTLS = 1 << 55
+
+  PIN_BASED_INTR                      = 1 << 0
+  PIN_BASED_NMI                       = 1 << 3
+  PIN_BASED_VIRTUAL_NMI               = 1 << 5
+  PIN_BASED_PREEMPTION_TIMER          = 1 << 6
+  PIN_BASED_POSTED_INTR               = 1 << 7
+
+  CPU_BASED_IRQ_WND                   = 1 << 2
+  CPU_BASED_TSC_OFFSET                = 1 << 3
+  CPU_BASED_HLT                       = 1 << 7
+  CPU_BASED_INVLPG                    = 1 << 9
+  CPU_BASED_MWAIT                     = 1 << 10
+  CPU_BASED_RDPMC                     = 1 << 11
+  CPU_BASED_RDTSC                     = 1 << 12
+  CPU_BASED_CR3_LOAD                  = 1 << 15
+  CPU_BASED_CR3_STORE                 = 1 << 16
+  CPU_BASED_CR8_LOAD                  = 1 << 19
+  CPU_BASED_CR8_STORE                 = 1 << 20
+  CPU_BASED_TPR_SHADOW                = 1 << 21
+  CPU_BASED_VIRTUAL_NMI_WND           = 1 << 22
+  CPU_BASED_MOV_DR                    = 1 << 23
+  CPU_BASED_UNCOND_IO                 = 1 << 24
+  CPU_BASED_IO_BITMAPS                = 1 << 25
+  CPU_BASED_MTF                       = 1 << 27
+  CPU_BASED_MSR_BITMAPS               = 1 << 28
+  CPU_BASED_MONITOR                   = 1 << 29
+  CPU_BASED_PAUSE                     = 1 << 30
+  CPU_BASED_SECONDARY_CTLS            = 1 << 31
+
+  CPU_BASED2_VIRTUAL_APIC             = 1 << 0
+  CPU_BASED2_EPT                      = 1 << 1
+  CPU_BASED2_DESC_TABLE               = 1 << 2
+  CPU_BASED2_RDTSCP                   = 1 << 3
+  CPU_BASED2_X2APIC                   = 1 << 4
+  CPU_BASED2_VPID                     = 1 << 5
+  CPU_BASED2_WBINVD                   = 1 << 6
+  CPU_BASED2_UNRESTRICTED             = 1 << 7
+  CPU_BASED2_APIC_REG_VIRT            = 1 << 8
+  CPU_BASED2_VIRT_INTR_DELIVERY       = 1 << 9
+  CPU_BASED2_PAUSE_LOOP               = 1 << 10
+  CPU_BASED2_RDRAND                   = 1 << 11
+  CPU_BASED2_INVPCID                  = 1 << 12
+  CPU_BASED2_VMFUNC                   = 1 << 13
+  CPU_BASED2_VMCS_SHADOW              = 1 << 14
+  CPU_BASED2_RDSEED                   = 1 << 16
+  CPU_BASED2_EPT_VE                   = 1 << 18
+  CPU_BASED2_XSAVES_XRSTORS           = 1 << 20
+
+  VMX_EPT_VPID_SUPPORT_AD             = 1 << 21
+  VMX_EPT_VPID_SUPPORT_EXONLY         = 1 << 0
+
+  VMEXIT_SAVE_DBG_CONTROLS            = 1 << 2
+  VMEXIT_HOST_IA32E                   = 1 << 9
+  VMEXIT_LOAD_IA32_PERF_GLOBAL_CTRL   = 1 << 12
+  VMEXIT_ACK_INTR                     = 1 << 15
+  VMEXIT_SAVE_IA32_PAT                = 1 << 18
+  VMEXIT_LOAD_IA32_PAT                = 1 << 19
+  VMEXIT_SAVE_EFER                    = 1 << 20
+  VMEXIT_LOAD_EFER                    = 1 << 21
+  VMEXIT_SAVE_VMX_TIMER               = 1 << 22
+
+  VMENTRY_LOAD_DBG_CONTROLS           = 1 << 2
+  VMENTRY_GUEST_IA32E                 = 1 << 9
+  VMENTRY_SMM                         = 1 << 10
+  VMENTRY_DEACTIVATE_DUAL_MONITOR     = 1 << 11
+  VMENTRY_LOAD_IA32_PERF_GLOBAL_CTRL  = 1 << 13
+  VMENTRY_LOAD_IA32_PAT               = 1 << 14
+  VMENTRY_LOAD_EFER                   = 1 << 15
+
+  VMX_REASON_EXC_NMI = 0
+  VMX_REASON_IRQ = 1
+  VMX_REASON_TRIPLE_FAULT = 2
+  VMX_REASON_INIT = 3
+  VMX_REASON_SIPI = 4
+  VMX_REASON_IO_SMI = 5
+  VMX_REASON_OTHER_SMI = 6
+  VMX_REASON_IRQ_WND = 7
+  VMX_REASON_VIRTUAL_NMI_WND = 8
+  VMX_REASON_TASK = 9
+  VMX_REASON_CPUID = 10
+  VMX_REASON_GETSEC = 11
+  VMX_REASON_HLT = 12
+  VMX_REASON_INVD = 13
+  VMX_REASON_INVLPG = 14
+  VMX_REASON_RDPMC = 15
+  VMX_REASON_RDTSC = 16
+  VMX_REASON_RSM = 17
+  VMX_REASON_VMCALL = 18
+  VMX_REASON_VMCLEAR = 19
+  VMX_REASON_VMLAUNCH = 20
+  VMX_REASON_VMPTRLD = 21
+  VMX_REASON_VMPTRST = 22
+  VMX_REASON_VMREAD = 23
+  VMX_REASON_VMRESUME = 24
+  VMX_REASON_VMWRITE = 25
+  VMX_REASON_VMOFF = 26
+  VMX_REASON_VMON = 27
+  VMX_REASON_MOV_CR = 28
+  VMX_REASON_MOV_DR = 29
+  VMX_REASON_IO = 30
+  VMX_REASON_RDMSR = 31
+  VMX_REASON_WRMSR = 32
+  VMX_REASON_VMENTRY_GUEST = 33
+  VMX_REASON_VMENTRY_MSR = 34
+  VMX_REASON_MWAIT = 36
+  VMX_REASON_MTF = 37
+  VMX_REASON_MONITOR = 39
+  VMX_REASON_PAUSE = 40
+  VMX_REASON_VMENTRY_MC = 41
+  VMX_REASON_TPR_THRESHOLD = 43
+  VMX_REASON_APIC_ACCESS = 44
+  VMX_REASON_VIRTUALIZED_EOI = 45
+  VMX_REASON_GDTR_IDTR = 46
+  VMX_REASON_LDTR_TR = 47
+  VMX_REASON_EPT_VIOLATION = 48
+  VMX_REASON_EPT_MISCONFIG = 49
+  VMX_REASON_EPT_INVEPT = 50
+  VMX_REASON_RDTSCP = 51
+  VMX_REASON_VMX_TIMER_EXPIRED = 52
+  VMX_REASON_INVVPID = 53
+  VMX_REASON_WBINVD = 54
+  VMX_REASON_XSETBV = 55
+  VMX_REASON_APIC_WRITE = 56
+  VMX_REASON_RDRAND = 57
+  VMX_REASON_INVPCID = 58
+  VMX_REASON_VMFUNC = 59
+  VMX_REASON_RDSEED = 61
+  VMX_REASON_XSAVES = 63
+  VMX_REASON_XRSTORS = 64
+
+  IRQ_INFO_EXT_IRQ        = 0 << 8
+  IRQ_INFO_NMI            = 2 << 8
+  IRQ_INFO_HARD_EXC       = 3 << 8
+  IRQ_INFO_SOFT_IRQ       = 4 << 8
+  IRQ_INFO_PRIV_SOFT_EXC  = 5 << 8
+  IRQ_INFO_SOFT_EXC       = 6 << 8
+
+  IRQ_INFO_ERROR_VALID    = 1 << 11
+  IRQ_INFO_VALID          = 1 << 31
+end

data/lib/hypervisor/framework.rb

@@ -0,0 +1,62 @@
+require "ffi"
+
+module Hypervisor
+  module Framework
+    extend FFI::Library
+
+    ffi_lib "/System/Library/Frameworks/Hypervisor.framework/Hypervisor"
+
+    attach_function :valloc, [:size_t], :pointer
+    attach_function :free, [:pointer], :void
+
+    attach_function :hv_vm_create, [:uint64_t], :uint
+    attach_function :hv_vm_destroy, [], :uint
+    attach_function :hv_vm_map, [:pointer, :uint64_t, :size_t, :uint64_t], :uint
+    attach_function :hv_vm_unmap, [:uint64_t, :size_t], :uint
+    attach_function :hv_vm_protect, [:uint64_t, :size_t, :uint64_t], :uint
+    attach_function :hv_vm_sync_tsc, [:uint64_t], :uint
+
+    attach_function :hv_vcpu_create, [:pointer, :uint64_t], :uint
+    attach_function :hv_vcpu_destroy, [:uint], :uint
+    attach_function :hv_vcpu_read_register, [:uint, :int, :pointer], :uint
+    attach_function :hv_vcpu_write_register, [:uint, :int, :uint64_t], :uint
+    attach_function :hv_vcpu_read_fpstate, [:uint, :pointer, :size_t], :uint
+    attach_function :hv_vcpu_write_fpstate, [:uint, :pointer, :size_t], :uint
+    attach_function :hv_vcpu_enable_native_msr, [:uint, :uint32_t, :bool], :uint
+    attach_function :hv_vcpu_read_msr, [:uint, :uint32_t, :pointer], :uint
+    attach_function :hv_vcpu_write_msr, [:uint, :uint32_t, :uint64_t], :uint
+    attach_function :hv_vcpu_flush, [:uint], :uint
+    attach_function :hv_vcpu_invalidate_tlb, [:uint], :uint
+    attach_function :hv_vcpu_run, [:uint], :uint, blocking: true
+    attach_function :hv_vcpu_interrupt, [:pointer, :uint], :uint
+    attach_function :hv_vcpu_get_exec_time, [:uint, :pointer], :uint
+
+    attach_function :hv_vmx_vcpu_read_vmcs, [:uint, :uint32_t, :pointer], :uint
+    attach_function :hv_vmx_vcpu_write_vmcs, [:uint, :uint32_t, :uint64_t], :uint
+    attach_function :hv_vmx_read_capability, [:int, :pointer], :uint
+    attach_function :hv_vmx_vcpu_set_apic_address, [:int, :uint64_t], :uint
+
+    def self.return_t(result)
+      unless result == 0
+        case result
+        when SUCCESS
+          return
+        when ERROR
+          raise "Error"
+        when BUSY
+          raise "Busy"
+        when BAD_ARGUMENT
+          raise "Bad Argument"
+        when NO_RESOURCES
+          raise "No Resources"
+        when NO_DEVICE
+          raise "No Device"
+        when UNSUPPORTED
+          raise "Hypervisor.framework is not supported on your computer"
+        else
+          raise "Something went wrong #{result}"
+        end
+      end
+    end
+  end
+end

data/lib/hypervisor/vcpu.rb

@@ -0,0 +1,139 @@
+module Hypervisor
+  class VCPU
+    def initialize(flags = VCPU_DEFAULT)
+      FFI::MemoryPointer.new(:uint, 1) do |vcpu|
+        Framework.return_t(Framework.hv_vcpu_create(vcpu, flags))
+
+        @vcpu = vcpu.get_uint(0)
+      end
+    end
+
+    def destroy!
+      Framework.return_t(Framework.hv_vcpu_destroy(@vcpu))
+    end
+
+    def flush
+      Framework.return_t(Framework.hv_vcpu_flush(@vcpu))
+    end
+
+    def invalidate_tlb
+      Framework.return_t(Framework.hv_vcpu_invalidate_tlb(@vcpu))
+    end
+
+    def run
+      Framework.return_t(Framework.hv_vcpu_run(@vcpu))
+    end
+
+    def read_register(register)
+      FFI::MemoryPointer.new(:uint64_t, 1) do |value|
+        Framework.return_t(Framework.hv_vcpu_read_register(@vcpu, register, value))
+
+        return value.get_uint64(0)
+      end
+    end
+
+    def write_register(register, value)
+      Framework.return_t(Framework.hv_vcpu_write_register(@vcpu, register, value))
+    end
+
+    def read_vmcs(field)
+      FFI::MemoryPointer.new(:uint64_t, 1) do |value|
+        Framework.return_t(Framework.hv_vmx_vcpu_read_vmcs(@vcpu, field, value))
+
+        return value.get_uint64(0)
+      end
+    end
+
+    def write_vmcs(field, value)
+      Framework.return_t(Framework.hv_vmx_vcpu_write_vmcs(@vcpu, field, value))
+    end
+
+    # Helpers
+
+    [:a, :b, :c, :d].each do |register|
+      const = Hypervisor.const_get("X86_R#{register.upcase}X")
+
+      define_method("r#{register}x") do
+        read_register(const)
+      end
+
+      define_method("r#{register}x=") do |value|
+        write_register(const, value)
+      end
+
+      define_method("e#{register}x") do
+        read_register(const) & 0xffffffff
+      end
+
+      define_method("e#{register}x=") do |value|
+        write_register(const, value & 0xffffffff)
+      end
+
+      define_method("#{register}x") do
+        read_register(const) & 0xffff
+      end
+
+      define_method("#{register}x=") do |value|
+        write_register(const, value & 0xffff)
+      end
+
+      define_method("#{register}l") do
+        read_register(const) & 0xff
+      end
+
+      define_method("#{register}l=") do |value|
+        old = read_register(const) & 0xff00
+
+        write_register(const, old | (value & 0xff))
+      end
+
+      define_method("#{register}h") do
+        (read_register(const) & 0xff00) >> 8
+      end
+
+      define_method("#{register}h=") do |value|
+        old = read_register(const) & 0xff
+
+        write_register(const, old | ((value & 0xff) << 8))
+      end
+    end
+    
+    [:cs, :ss, :ds, :es, :fs, :gs].each do |register|
+      const = Hypervisor.const_get("X86_#{register.upcase}")
+
+      define_method(register) do
+        read_register(const)
+      end
+
+      define_method("#{register}=") do |value|
+        write_register(const, value)
+      end
+    end
+
+    def flags
+      read_register(Hypervisor::X86_RFLAGS)
+    end
+
+    def flags=(value)
+      write_register(Hypervisor::X86_RFLAGS, value)
+    end
+
+    { cf: 0, pf: 2, af: 4, zf: 6, sf: 7, tf: 8, if: 9, df: 10, of: 11, rf: 16, vm: 17, ac: 18, vif: 19, vip: 20, id: 21 }.each do |register, offset|
+      define_method(register) do
+        flags[offset]
+      end
+
+      mask = (1 << offset)
+
+      define_method("#{register}=") do |value|
+        old = flags & ~mask
+
+        if value == 0
+          write_register(Hypervisor::X86_RFLAGS, old)
+        else
+          write_register(Hypervisor::X86_RFLAGS, old | mask)
+        end
+      end
+    end
+  end
+end

data/lib/hypervisor/version.rb

@@ -0,0 +1,3 @@
+module Hypervisor
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: hypervisor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aurora
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: A wrapper for Hypervisor.framework on macOS
+email:
+- aurora@aventine.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/dos
+- hypervisor.gemspec
+- lib/hypervisor.rb
+- lib/hypervisor/constants.rb
+- lib/hypervisor/framework.rb
+- lib/hypervisor/vcpu.rb
+- lib/hypervisor/version.rb
+homepage: https://github.com/rawrasaur/hvpervisor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Hypervisor for macOS
+test_files: []