lightweight, extendable hypervisor written in C++ with support for Windows and Linux
C++ HyPhy C Other
Latest commit 3f0086c Jan 17, 2017 @rianquinn rianquinn committed on GitHub Merge pull request #405 from RicoAntonioFelix/master
to_string.h: Add API documentation

README.md




GitHub version Build Status Build Status Coverage Status Coverity Scan Build Status CII Best Practices Join the chat at https://gitter.im/Bareflank-hypervisor/Lobby

Description

The Bareflank Hypervisor is an open source, lightweight hypervisor, lead by Assured Information Security, Inc. that provides the scaffolding needed to rapidly prototype new hypervisors. To ease development, Bareflank is written in C++, and includes support for exceptions and the C++ Standard Template Library (STL) via libc++. With the C++ STL, users can leverage shared pointers, complex data structures (e.g. hash tables, maps, lists, etc…), and several other modern C++ features. Existing open source hypervisors that are written in C are difficult to modify, and spend a considerable amount of time re-writing similar functionality instead of focusing on what matters most: hypervisor technologies. Furthermore, users can leverage inheritance to extend every part of the hypervisor to provide additional functionality above and beyond what is already provided.

To this end, Bareflank's primary goal is to remain simple, and minimalistic, providing only the scaffolding needed to construct more complete/complicated hypervisors including:

The core business logic will remain in the hypervisors that extend Bareflank, and not in Bareflank itself.

To support Bareflank's design approach, the entire project is licensed under the GNU Lesser General Public License v2.1 (LGPL), specifically enabling users of the project to both contribute back to the project, but also create proprietary extensions if so desired.

In addition to Bareflank’s lightweight, modular design, the entire hypervisor has been written using test driven development. As such, all of Bareflank’s code comes complete with a set of unit tests to validate that the provided code works as expected. These tests are validated using Coveralls, and Travis CI has been setup to test styling via Astyle, and static / dynamic analysis via Coverity, Clang Tidy, and Google's Sanitizers. In addition, we adhere to the CII Best Practices, and the C++ Core Guidelines including support for the Guideline Support Library.

Currently we have support for the following 64bit host operating systems on Intel SandyBridge and above hardware:

  • Ubuntu 16.10, 16.04, 14.04
  • Debian Stretch
  • Fedora 25, 24, 23
  • OpenSUSE Leap 42.2
  • Windows 10
  • Windows 8.1

In the future, we would also like to support:

  • macOS
  • BSD
  • UEFI
  • ARM (64bit)

Motivation

Most people think that hypervisors are meant to virtualize servers and provide a means to run Windows on a Mac, but there is a whole field of research where hypervisors are used without guest virtual machines. Since a hypervisor is capable of controlling the host OS running underneath it, (so called "ring -1"), hypervisors have been used for introspection, reverse engineering, anti-virus, containerization, diversity, and even architectural research like the MoRE hypervisor. All of these use cases start the same way, by spending months standing up the hypervisor itself before you can start working on your actual project. Existing open source hypervisors are so focused on supporting virtual machines and burdened with legacy support that they are painful to work with when conducting less traditional hypervisor research.

Bareflank's goal is to provide the scaffolding needed to create any type of hypervisor. To support this, Bareflank leverages C++ not only to provide a clear method for extending the hypervisor via inheritance, but also to provide access to the C++ STL to reduce the time it takes to prototype and implement new technologies. For example, suppose you’re writing an introspection hypervisor that needs to store the different system calls that are being made in a data structure for fast lookups. Doing this in an existing C based hypervisor might require you to create your own data structure. This same implementation is trivial with the STL's existing data structures. With Bareflank's design, you can focus on the goal of your project, and less on implementing the foundation needed to support your project.

Bareflank will always maintain the "bare minimum" needed to stand up a hypervisor. Additional repositories like the Extended APIs repo and the Hyperkernel repo have been created that extend the hypervisor to add additional API support for common research tasks (e.g. VT-x / VT-d APIs and guest support APIs). Long term, it is our hope that others will leverage Bareflank to create hypervisors capable of competing with existing type 1 and type 2 open source hypervisors, but Bareflank itself will remain focused on the bare minimum scaffolding.

Links

Bareflank Hypervisor Website
Bareflank Hypervisor API Documentation

Demo

Checkout the latest demo for how to compile, use and extend the Bareflank Hypervisor

Bareflank Demonstration Video

Additional Videos

CppCon 2016: Making C++ and the STL Work in the Linux / Windows Kernels

CppCon 2016

Compilation Instructions

NOTE: Our master branch is our working, experimental branch and might be unstable. If you would like to use Bareflank, we recommend using a tagged release which has been more thoroughly tested. Of course if you happen to find a bug, please let us know here. These instructions might vary from release to release, so if something doesn't work, please refer to the instructions provided in the tagged version.

Before you can compile, the build environment must be present. If you are on a supported Windows platform, you must first install cygwin, and run a cygwin terminal with admin rights. You must also copy the setup-x86_64.exe to "c:\cygwin64\bin". If you are on a supported Linux platform, all you need is a terminal. Once your setup, you should be able to run the following:

cd ~/
git clone https://github.com/bareflank/hypervisor.git
cd ~/hypervisor
git checkout -b rc1.1.0

./tools/scripts/setup_<platform>.sh

If you are on Windows, there is one additional step that must be taken to turn on test signing. This step can be skipped if you plan to sign the driver with your own signing key.

bcdedit.exe /set testsigning ON
<reboot>

If you are not on a supported platform, you are more than welcome to modify an existing setup_<platform>.sh script to suite your needs. Its likely the hypervisor will work assuming you can get it to compile. Once you have the cross compilers you can run:

make
make test

To run the hypervisor, you need to first compile, and load one of the driver entry points. Bareflank uses the driver entry point to gain kernel level access to the system to load the hypervisor. On Windows and Linux, this is as simple as:

make driver_load
make load
make start

to get status information, use the following:

make status
make dump
ARGS="versions 1" make vmcall

to reverse this:

make stop
make unload
make driver_unload

For more detailed instructions please read the following (based on which OS you are using):

Driver Entry Documentation

Extended APIs / Hyperkernel

Since Bareflank only provides the bare minimum implementation, we have created two other repositories that extend Bareflank to provide additional capabilities that you might find useful. The Extended APIs repo provides additional APIs around Intel's VT-x / VT-d. Likely most users of Bareflank will find these APIs useful. The Hyperkernel leverages the Extended APIs and Bareflank to provide guest support. If your project requires guest support, you might also find this repo useful as well.

Extended APIs:
https://github.com/Bareflank/extended_apis

Hyperkernel:
https://github.com/Bareflank/hyperkernel

Example Extensions

To provide examples of how you might extend Bareflank to provide your own custom functionality, we have provided a couple of examples:

Enable VPID:
https://github.com/Bareflank/hypervisor_example_vpid

CPUID Count:
https://github.com/Bareflank/hypervisor_example_cpuidcount

Extended APIs EPT Hook:
https://github.com/Bareflank/extended_apis_example_hook

Roadmap

The project roadmap can be located here

License

The Bareflank Hypervisor is licensed under the GNU Lesser General Public License v2.1 (LGPL).

Related

If you’re interested in Bareflank, you might also be interested in the following hypervisor projects:

MoRE:
https://github.com/ainfosec/MoRE

SimpleVisor:
https://github.com/ionescu007/SimpleVisor

HyperPlatform:
https://github.com/tandasat/HyperPlatform

HyperBone:
https://github.com/DarthTon/HyperBone