The Common Open Research Emulator (CORE) is a tool for building virtual networks. As an emulator, CORE builds a representation of a real computer network that runs in real time, as opposed to simulation, where abstract models are used. The live-running emulation can be connected to physical networks and routers. It provides an environment for running real applications and protocols, taking advantage of virtualization provided by the Linux or FreeBSD operating systems.
Some of its key features are:
CORE is typically used for network and protocol research, demonstrations, application and platform testing, evaluating networking scenarios, security studies, and increasing the size of physical test networks.
For readers who are already familiar with CORE and have read this manual before, below is a list of what changed in version 4.8:
The main components of CORE are shown in CORE Architecture. A CORE daemon (backend) manages emulation sessions. It builds emulated networks using kernel virtualization for virtual nodes and some form of bridging and packet manipulation for virtual networks. The nodes and networks come together via interfaces installed on nodes. The daemon is controlled via the graphical user interface, the CORE GUI (frontend). The daemon uses Python modules that can be imported directly by Python scripts. The GUI and the daemon communicate using a custom, asynchronous, sockets-based API, known as the CORE API. The dashed line in the figure notionally depicts the user-space and kernel-space separation. The components the user interacts with are colored blue: GUI, scripts, or command-line tools.
The system is modular to allow mixing different components. The virtual networks component, for example, can be realized with other network simulators and emulators, such as ns-3 and EMANE. Different types of kernel virtualization are supported. Another example is how a session can be designed and started using the GUI, and continue to run in “headless” operation with the GUI closed. The CORE API is sockets based, to allow the possibility of running different components on different physical machines.
The CORE GUI is a Tcl/Tk program; it is started using the command core-gui. The CORE daemon, named core-daemon, is usually started via the init script (/etc/init.d/core-daemon or core-daemon.service, depending on platform.) The CORE daemon manages sessions of virtual nodes and networks, of which other scripts and utilities may be used for further control.
A CORE node is a lightweight virtual machine. The CORE framework runs on Linux and FreeBSD systems. The primary platform used for development is Linux.
Linux network namespaces (also known as netns, LXC, or Linux containers) is the primary virtualization technique used by CORE. LXC has been part of the mainline Linux kernel since 2.6.24. Recent Linux distributions such as Fedora and Ubuntu have namespaces-enabled kernels out of the box, so the kernel does not need to be patched or recompiled. A namespace is created using the clone() system call. Similar to the BSD jails, each namespace has its own process environment and private network stack. Network namespaces share the same filesystem in CORE.
CORE combines these namespaces with Linux Ethernet bridging to form networks. Link characteristics are applied using Linux Netem queuing disciplines. Ebtables is Ethernet frame filtering on Linux bridges. Wireless networks are emulated by controlling which interfaces can send and receive with ebtables rules.
FreeBSD jails provide an isolated process space, a virtual environment for running programs. Starting with FreeBSD 8.0, a new vimage kernel option extends BSD jails so that each jail can have its own virtual network stack – its own networking variables such as addresses, interfaces, routes, counters, protocol state, socket information, etc. The existing networking algorithms and code paths are intact but operate on this virtualized state.
Each jail plus network stack forms a lightweight virtual machine. These are named jails or virtual images (or vimages) and are created using a the jail or vimage command. Unlike traditional virtual machines, vimages do not feature entire operating systems running on emulated hardware. All of the vimages will share the same processor, memory, clock, and other system resources. Because the actual hardware is not emulated and network packets can be passed by reference through the in-kernel Netgraph system, vimages are quite lightweight and a single system can accommodate numerous instances.
Virtual network stacks in FreeBSD were historically available as a patch to the FreeBSD 4.11 and 7.0 kernels, and the VirtNet project   added this functionality to the mainline 8.0-RELEASE and newer kernels.
The FreeBSD Operating System kernel features a graph-based networking subsystem named Netgraph. The netgraph(4) manual page quoted below best defines this system:
The netgraph system provides a uniform and modular system for the implementation of kernel objects which perform various networking functions. The objects, known as nodes, can be arranged into arbitrarily complicated graphs. Nodes have hooks which are used to connect two nodes together, forming the edges in the graph. Nodes communicate along the edges to process data, implement protocols, etc.
The aim of netgraph is to supplement rather than replace the existing kernel networking infrastructure.
The Tcl/Tk CORE GUI was originally derived from the open source IMUNES project from the University of Zagreb as a custom project within Boeing Research and Technology’s Network Technology research group in 2004. Since then they have developed the CORE framework to use not only FreeBSD but Linux virtualization, have developed a Python framework, and made numerous user- and kernel-space developments, such as support for wireless networks, IPsec, the ability to distribute emulations, simulation integration, and more. The IMUNES project also consists of userspace and kernel components. Originally, one had to download and apply a patch for the FreeBSD 4.11 kernel, but the more recent VirtNet effort has brought network stack virtualization to the more modern FreeBSD 8.x kernel.
CORE has been released by Boeing to the open source community under the BSD license. If you find CORE useful for your work, please contribute back to the project. Contributions can be as simple as reporting a bug, dropping a line of encouragement or technical suggestions to the mailing lists, or can also include submitting patches or maintaining aspects of the tool. For details on contributing to CORE, please visit the wiki.
Besides this manual, there are other additional resources available online:
The CORE wiki is a good place to check for the latest documentation and tips.
These are the Goals of the CORE project; they are similar to what we consider to be the key features.
This is a list of Non-Goals, specific things that people may be interested in but are not areas that we will pursue.