Статья Разработка эксплойтов ядра Linux - Среда (arm)

[Azrv3l]

Содержание

• Настройка среды
• Установка QEMU
• Компиляция ядра
  • ARM
• Компиляция buildroot
  • Добавляем пользователей
  • Добавляем модули ядра
  • Доделываем
• Тестируем среду
  • Компилируем бинарные файлы
    • Отлаживаем бинарные файлы
  • Отлаживаем ядро
    • Компилируем модули
    • Отлаживаем модули ядра
    • Снапшоты
    • Ориентируемся в коде ядра
    • SystemTap
• Ubuntu initramfs
  • ARM

Идея этого поста - настроить среду для игры с ядром Linux. Этот пост является своеобразной заметкой о проделаном процессе.

Настройка среды
Чтобы создать минималистичную и настраиваемую среду, я решил собрать ядро из исходного кода (kernel.org) и скомпилировать свои собственные initramfs, используя buildroot (buildroot.org) с поддержкой busybox (busybox.net). Для эмуляции всей системы я решил использовать QEMU (QEMU.org).

Следующие переменные должны быть установлены, чтобы следовать этому руководству:

export BUILD_PATH="/your/path/build/environment"
mkdir -p $BUILD_PATH

Установка QEMU
Просто следуйте командной строке, соответствующей вашему дистрибутиву, здесь.

Компиляция ядра
Чтобы загрузить исходный код ядра, перейдите на kernel.org и найдите нужную версию. В этом посте я буду использовать 4.20 (ссылка).

После извлечения архива для минимальной конфигурации используйте make правило allnoconfig. В этом случае я собираюсь использовать опцию defconfig, чтобы получить полностью работающее ядро, а затем добавить некоторые пользовательские настройки.

cd $BUILD_PATH
wget -O- https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.20.tar.gz | tar -xzv
mv linux-4.20 linux
cd linux
ARCH=x86_64 make defconfig
#
# конфигурация записанная в .config
#
make menuconfig

Затем включите следующие параметры:

Чтобы легко ориентироваться, нажмите первую букву параметра. Для поиска нажмите / и введите свой шаблон поиска. Когда появятся результаты, нажмите номер, показанный слева от параметра, чтобы перейти к нему.

# Debugging
Kernel hacking ---> Compile-time checks and compiler options ---> Compile the kernel with debug info ---> yes
Kernel hacking ---> Compile-time checks and compiler options ---> Provide GDB scripts for kernel debugging ---> yes
General setup ---> Configure standard kernel features ---> yes
General setup ---> Configure standard kernel features ---> Load all symbols for debugging/ksymoops ---> yes
General setup ---> Configure standard kernel features ---> Include all symbols in kallsyms ---> yes

# Only if 64 bits is selected
Binary Emulations ---> IA32 a.out support ---> yes
Binary Emulations ---> IA32 ABI for 64-bit mode ---> yes

# Make sure the following options are enabled:
General setup ---> Initial RAM filesystem and RAM disk (initramfs/initrd) support ---> yes
General setup ---> Configure standard kernel features ---> Multiple users, groups and capabilities support ---> yes
General setup ---> Configure standard kernel features ---> Sysfs syscall support ---> yes
Device Drivers ---> Generic Driver Options ---> Maintain a devtmpfs filesystem to mount at /dev ---> yes
Device Drivers ---> Generic Driver Options ---> Automount devtmpfs at /dev, after the kernel mounted the rootfs ---> yes
Device Drivers ---> Character devices ---> Enable TTY ---> yes
Device Drivers ---> Character devices ---> Serial drivers ---> 8250/16550 and compatible serial support ---> yes
Device Drivers ---> Character devices ---> Serial drivers ---> Console on 8250/16550 and compatible serial port ---> yes
File systems ---> Pseudo filesystems ---> /proc file system support ---> yes
File systems ---> Pseudo filesystems ---> sysfs file system support ---> yes

Я рекомендовал компилировать ядро с опцией KASan и без нее для отладки. Kernel hacking ---> Memory Debugging ---> KASan: runtime memory debugger ---> yes

В зависимости от эксплойта или того, что мы хотим протестировать на этом ядре, вы можете отключить следующие контрмеры:

# Allocations at NULL to allow nullptr de-reference
Memory Management options ---> Low address space to protect from user allocation ---> 0
# SMAP disabled
Processor type and features ---> Supervisor Mode Access Prevention ---> no
# KASL, can be disabled by setting nokaslr in the bootloader cmdline
Processor type and features ---> Build a relocatable kernel ---> no
# Canary disabled
General architecture-dependent options ---> Stack Protector buffer overflow detection ---> no

После того, как конфигурация установлена и настроена так, как вы хотите, скомпилируйте ядро:

nproc
8
time ARCH=x86_64 make -j 8
(...)
real    2m52.923s
user    2m32.595s
sys 0m20.537s

Теперь протестируйте новое скомпилированное ядро с помощью QEMU, используя следующую строку (<Ctrl>a + x для выхода):

qemu-system-x86_64 -kernel arch/x86_64/boot/bzImage -nographic -append "console=ttyS0" -enable-kvm
(...)
[    1.991148] Kernel Offset: 0x5a00000 from 0xc1000000 (relocation range: 0xc0000000-0xc87dffff)
[    1.991649] ---[ end Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0) ]---

Эта kernel panic является нормальным явлением, поскольку нам не хватает процесса init в initramfs или корневой файловой системе.

ARM
Ядро может быть скомпилировано для любой архитектуры, включая ARM, с использованием цепочки инструментов, это включает в себя экспорт следующих переменных перед компиляцией ядра (возможно, вам придется настроить цепочку инструментов):

$ ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-

Компиляция buildroot
Пришло время скомпилировать initramfs с помощью некоторых утилит bin/sbin, включая gdbserver и python:

cd $BUILD_PATH
wget -O- https://buildroot.org/downloads/buildroot-2019.02.2.tar.gz | tar -xzv
mv buildroot-2019.02.2 buildroot
cd buildroot
make menuconfig

Установите следующие параметры:

# General
Target options ---> Target Architecture ---> x86_64
Build options ---> Enable compiler cache ---> yes
Build options ---> Compiler cache location ---> $(BUILD_PATH)/.buildroot-ccache

# It should be greater or equal than your kernel version
Toolchain ---> Kernel Headers ---> Linux 4.20.x kernel headers
Toolchain ---> C library ---> glibc
Toolchain ---> Enable C++ support ---> yes
System configuration ---> Run a getty (login prompt) after boot ---> TTY port ---> ttyS0
System configuration ---> Network interface to configure through DHCP ---> eth0
System configuration ---> Root filesystem overlay directories ---> $(BUILD_PATH)/buildroot/overlay
Target packages ---> Debugging, profiling and benchmark ---> gdb
Target packages ---> Interpreter languages and scripting ---> python
Target packages ---> Networking applications ---> dropbear ---> yes
Filesystem images ---> cpio the root filesystem (for use as an initial RAM filesystem) ---> yes
Filesystem images ---> ext2/3/4 root filesystem ---> ext2/3/4 variant ---> ext4

# Optional
System configuration ---> System hostname ---> nullbyte
System configuration ---> System banner ---> Welcome to nullbyte.cat

Я рекомендовал скомпилировать buildroot с параметром ext2/3/4, а также с параметром cpio. Таким образом, у нас будет файловая система только для чтения, а также постоянная файловая система, в которой мы можем хранить файлы, которые будут сохраняться при перезагрузке.

Создайте каталог overlay. Все хранящиеся там файлы будут скопированы в корень файловой системы. Добавьте к нему минимальный скрипт инициализации:

mkdir $BUILD_PATH/buildroot/overlay
cat $BUILD_PATH/buildroot/overlay/init
chmod +x $BUILD_PATH/buildroot/overlay/init

#!/bin/sh
# devtmpfs does not get automounted for initramfs
/bin/mount -t devtmpfs devtmpfs /dev
exec 0</dev/console
exec 1>/dev/console
exec 2>/dev/console

exec /sbin/init "$@"

Добавляем пользователей
В текущей конфигурации будет создан только пользователь root без пароля. Чтобы создать обычного пользователя и обновить пароль root, нам нужно создать файлы /etc/passwd и /etc/shadow:

mkdir $BUILD_PATH/buildroot/overlay/etc/
cat $BUILD_PATH/buildroot/overlay/etc/shadow
root:$5$AQRgXbdJ$eCko6aRPrhOBegsJGLy36fmmrheNtfkUMBjlKPWEXW9:10000:0:99999:7:::
daemon:*:10933:0:99999:7:::
bin:*:10933:0:99999:7:::
sys:*:10933:0:99999:7:::
sync:*:10933:0:99999:7:::
mail:*:10933:0:99999:7:::
www-data:*:10933:0:99999:7:::
operator:*:10933:0:99999:7:::
nobody:*:10933:0:99999:7:::
user:$5$QAucgwIL$onnijv2MwdMD.Jze4LgPx7z3kksIjU18y3jffH2urv3:10000:0:99999:7:::

Пароли, соответствующие предыдущим хешам: root:root и user:user (user:password).

Если вы хотите сгенерировать собственный хеш для нового пользователя или изменить предыдущих, используйте следующую команду:

python -c "import random,string,crypt;
randomsalt = ''.join(random.sample(string.ascii_letters,8));
print crypt.crypt('PASSWORD', '\$5\$%s\$' % randomsalt)"

Соответственно обновите /etc/passwd:

cat $BUILD_PATH/buildroot/overlay/etc/passwd
root:x:0:0:root:/root:/bin/sh
daemon:x:1:1:daemon:/usr/sbin:/bin/false
bin:x:2:2:bin:/bin:/bin/false
sys:x:3:3:sys:/dev:/bin/false
sync:x:4:100:sync:/bin:/bin/sync
mail:x:8:8:mail:/var/spool/mail:/bin/false
www-data:x:33:33:www-data:/var/www:/bin/false
operator:x:37:37:Operator:/var:/bin/false
nobody:x:65534:65534:nobody:/home:/bin/false
user:x:1000:1000:Linux User,,,:/home/user:/bin/sh

Наконец, создайте домашнюю страницу пользователя и установите разрешения для таблицы устройств.

mkdir -p $BUILD_PATH/buildroot/overlay/home/user
echo -e '/home/user\td\t755\t1000\t100\t-\t-\t-\t-\t-' >> $BUILD_PATH/buildroot/system/device_table.txt

Добавляем модули ядра
Чтобы добавить модули, скомпилированные на этапе ядра, в файловую систему, мы можем использовать каталог overlay в качестве места назначения:

cd $BUILD_PATH/linux
make modules_install INSTALL_MOD_PATH=$BUILD_PATH/buildroot/overlay
(...)
DEPMOD  4.20.0

Доделываем
Как только все будет готово, скомпилируйте bootroot (первая компиляция займет несколько минут):

cd $BUILD_PATH/buildroot
make source
nproc
8
make -j 8

Тестируем среду
Как уже упоминалось, если вы скомпилируете buildroot с файловой системой ext2/3/4, у вас будет постоянное хранилище, в которое вы можете передавать файлы через ssh и хранить их. Однако, если вы используете вариант cpio, ключ dropbear будет генерироваться случайным образом при каждой загрузке. Это означает, что сертификат будет недействительным на хосте при каждой перезагрузке.

Чтобы решить эту проблему, у вас есть 2 варианта:

1. Используйте файловую систему ext2.
2. Игнорируйте ~/.ssh/known_host, добавляя команду -o UserKnownHostsFile = /dev/null -o StrictHostKeyChecking=no к клиенту ssh.

Чтобы использовать ssh на машине, нам нужно перенаправить порт на хост, мы можем сделать это, добавив hostfwd=tcp::2222-:22 к опции -net user. (Мы можем добавить столько, сколько нам нужно). Я перенаправлю 3 порта, 9999 для пользовательского пространства gdbserver, с 22 по 2222 для ssh и 8000 в качестве дополнительных. Таким образом, полная команда с использованием ext2 выглядит так:

cd $BUILD_PATH
qemu-system-x86_64 -kernel linux/arch/x86_64/boot/bzImage \
-drive file=buildroot/output/images/rootfs.ext2,format=raw \
-net nic -net user,hostfwd=tcp::2222-:22,hostfwd=tcp::9999-:9999,hostfwd=tcp::8000-:8000 \
-nographic -append "root=/dev/sda console=ttyS0" -enable-kvm

Если вы хотите использовать временную систему, замените строку -drive на -initrd buildroot/output/images/rootfs.cpio и удалите root=/dev/sda из -append.

После запуска ядра мы можем подключиться к нему с помощью root или user и соответствующего пароля через ssh.

ssh -p 2222 root@localhost
ssh -p 2222 user@localhost
# Чтобы включить ssh без пароля, скопируйте ключи (используйте только в постоянной системе)
ssh-copy-id -p 2222 root@localhost
ssh-copy-id -p 2222 user@localhost

Компилируем бинарные файлы
Поскольку мы указали glibc в конфигурации buildroot в качестве набора инструментов, мы можем использовать наш собственный системный компилятор. Если вы ориентируетесь на другую архитектуру, используйте компилятор gcc из $BUILD_PATH/buildroo/output/host/usr/bin.

После того, как вы скомпилировали двоичный файл, вы можете загрузить его через scp. (Не забудьте использовать файловую систему ext2 для обеспечения устойчивости).

Отлаживаем бинарные файлы
Мы можем использовать gdbserver для отладки двоичных файлов пользователя в QEMU, прослушивая один из перенаправленных портов QEMU.

scp -P 2222 binary user@localhost
ssh -p 2222 user@localhost 'gdbserver localhost:9999 ./binary'

gdb binary
target remote localhost:9999

Отлаживаем ядро
Для отладки ядра мы можем добавить -s (сокращение для -gdb tcp::1234) и -S (не запускать процессор при запуске).

cd $BUILD_PATH
qemu-system-x86_64 -kernel linux/arch/x86_64/boot/bzImage \
-drive file=buildroot/output/images/rootfs.ext2,format=raw \
-net nic -net user,hostfwd=tcp::2222-:22,hostfwd=tcp::9999-:9999,hostfwd=tcp::8000-:8000 \
-nographic -append "root=/dev/sda console=ttyS0" -s -S -enable-kvm

Затем на хосте мы можем загрузить двоичный файл vmlinux и присоединиться к gdb заглушке QEMU.

cd $BUILD_PATH/linux
gdb vmlinux
target remote localhost:1234

Если мы запустим gdb из каталога исходного кода linux, мы сможем перечислить исходный код и разбить его на b mm/slub.c:3770. Если это не так, мы можем указать каталог исходного кода ядра внутри gdb с помощью команды dir <source-path> .

Компилируем модули
Используйте следующий Makefile для компиляции модуля с именем module.c

obj-m += module.o

all:
    make -C $BUILD_PATH/linux M=$(PWD) modules

clean:
    make -C $BUILD_PATH/linux M=$(PWD) clean```

Затем мы можем загрузить скомпилированный module.ko через scp как root и установить его с помощью insmod или modprobe. Другой вариант - добавить модуль в overlay каталог buildroot и загрузить его с помощью сценария инициализации.

Отлаживаем модули ядра
Как только ядро загружено (подтвердите это с помощью lsmod как гость), мы можем получить его адрес с помощью cat /proc/modules | grep <имя-модуля> или в cat /sys/module/<module>/sections/.text.

Затем мы можем сопоставить модуль с сеансом gdb, который мы подключили к заглушке QEMU, следующим образом:

 add-symbols-file <module.ko> <address>

Мы также можем указать сегменты, вручную взятые из /sys/module/<module>/section/.<segment>

 add-symbols-file <module.ko> -s .text <.text-addr> -s .data <.data-addr>

Снапшоты
Чтобы быстро восстановить состояние vm (полезно при тестировании эксплойта ядра), нам нужно преобразовать наш образ ext2 в qcow2:

cd $BUILD_PATH/buildroot/output/images/
qemu-img convert -O qcow2 rootfs.ext2 rootfs.qcow2 -enable-kvm

Чтобы управлять виртуальной машиной, нам нужно добавить флаг монитора QEMU и изменить файл диска на image.qcow2:

cd $BUILD_PATH
qemu-system-x86_64 -kernel linux/arch/x86_64/boot/bzImage \
-drive file=buildroot/output/images/rootfs.qcow2 \
-net nic -net user,hostfwd=tcp::2222-:22,hostfwd=tcp::9999-:9999,hostfwd=tcp::8000-:8000 \
-nographic -append "root=/dev/sda console=ttyS0" -monitor telnet:127.0.0.1:55555,server,nowait -enable-kvm

После добавления этих параметров мы можем подключиться к монитору QEMU через порт nc localhost 55555 и отправить консольные команды, такие как следующие:

• info snapshot: Список всех снимков
• savevm: Создает новый снимок
• loadvm <tag>: Загружает снимок <tag>
• delvm <tag>: Удаляет снимок <tag>

Мы можем оставить заглушку QEMU gdb работающей и выдать loadvm <tag>, позволяющую нам вернуться в состояние перед запуском эксплойта.

Если вы используете -S вместе с -monitor, не забудьте ввести команду c (continue) для монитора, иначе виртуальная машина не запустится.

Ориентируемся в коде ядра
Более простой способ - создать файл ctags с тегами make внутри пути $BUILD_PATH/linux и перемещаться по нему с помощью vim и команды :tag <tag> (vim wiki).

Дополние:
Теперь я использую cscope вместе с vim, так как это позволяет улучшить перекрестные ссылки, вы можете создать базу данных, используя make cscope и перемещаться как ctags, добавив set cscopetag в ваш .vimrc. (Взгляните на этот плагин, который делает это и автоматически загружает базу данных cscope.out).

SystemTap
Вы можете кросс-скомпилировать stap с вашего хоста и загрузить его в виртуальную машину, выполнив следующие действия:

sudo stap -a x86_64 -p 4 -v -m stap.ko --sysroot $BUILD_PATH/linux -r $BUILD_PATH/linux  stap.stp

Вам нужно будет установить на гостевой машине staprun. Я рекомендую следовать следующему разделу и устанавливать его с помощью apt install systemtap.

Ubuntu initramfs​

Чтобы создать загрузочный образ Ubuntu qcow2 для использования с нашим собственным ядром, мы можем создать загрузочную программу с помощью следующей команды:

sudo debootstrap \
    --include linux-image-generic \
    xenial \
    debootstrap \
    http://archive.ubuntu.com/ubuntu

Чтобы установить модули make modules_install INSTALL_MOD_PATH=debootstrap/

Затем мы можем выполнить chroot к нему и создать нашего пользователя и изменить пароль root, нам также нужно перемонтировать корневую файловую систему как rw и включить службу DHCP при загрузке:

sudo chroot debootstrap
echo -e 'root\nroot' passwd
/usr/sbin/adduser user
exit
# Remount the root filesystem as rw.
cat << EOF | sudo tee "debootstrap/etc/fstab"
/dev/sda / ext4 errors=remount-ro,acl 0 1
EOF
# Automaticaly start networking.
cat << EOF | sudo tee debootstrap/etc/systemd/system/dhclient.service
[Unit]
Description=DHCP Client
Documentation=man:dhclient(8)
Wants=network.target
Before=network.target
[Service]
Type=forking
PIDFile=/var/run/dhclient.pid
ExecStart=/sbin/dhclient -4 -q
[Install]
WantedBy=multi-user.target
EOF
sudo ln -sf debootstrap/etc/systemd/system/dhclient.service \
    debootstrap/etc/systemd/system/multi-user.target.wants/dhclient.service

И, наконец, создайте образ qcow2:

Если вам нужно больше места на диске, измените + 1G (этот образ не следует использовать для компиляции, только для тестирования).

sudo virt-make-fs \
    --format qcow2 \
    --size +1G \
    --type ext2 \
    debootstrap \
    xenial-debootstrap.ext2.qcow2

Вы всегда можете изменить его размер позже:

qemu-img resize xenial-debootstrap.ext2.qcow2 +5G
# Inside the QEMU vm as root:
resize2fs /dev/sda

Запустите наше скомпилированное ядро с загрузкой Ubuntu:

qemu-system-x86_64 -kernel linux/arch/x86_64/boot/bzImage \
-drive file=xenial-debootstrap.ext2.qcow2 \
-net nic -net user,hostfwd=tcp::2222-:22,hostfwd=tcp::9999-:9999,hostfwd=tcp::8000-:8000 \
-nographic -append "root=/dev/sda console=ttyS0" -monitor telnet:127.0.0.1:55555,server,nowait -enable-kvm

Теперь у вас есть полностью работающее настраиваемое ядро Linux с менеджером пакетов и некоторыми другими инструментами.

Если во время загрузки отображаются ошибки, это связано с несоответствием конфигурации ядра. Вы можете получить конфигурацию из debootstrap/config-* и make oldconfig.

Вы также можете скомпилировать ядро ubuntu, используя этот метод вики и загрузив нужную версию ядра из основного репозитория здесь.

ARM
Для ARM процесс аналогичен:

sudo debootstrap \
    --arch armhf xenial \
    debootstrap \
    http://ports.ubuntu.com/ubuntu-ports

Нам нужно проделать те же шаги, что описаны в обычном ubuntu. На этот раз для chroot в загрузочную среду нам понадобится qemu-user и соответствующая библиотека libc для архитектуры, на которую мы нацелены. Нам нужно будет настроить binfmt и создать символическую ссылку на библиотеки, чтобы мы могли прозрачно выполнять arm:

sudo ln -s /usr/arm-linux-gnueabihf /etc/qemu-binfmt/armhf

Теперь мы можем выполнить chroot к нему и создать нашего пользователя и изменить пароль root, нам также необходимо перемонтировать корневую файловую систему как rw и включить службу DHCP при загрузке, как это было сделано в версии x86_64.

Обратите внимание, как на этот раз vda указывается как корневой раздел, а не sda, поскольку мы собираемся использовать виртуальную машину.

sudo chroot debootstrap
echo -e 'root\nroot' passwd
/usr/sbin/adduser user
exit
# Remount the root filesystem as rw.
cat << EOF | sudo tee "debootstrap/etc/fstab"
/dev/vda / ext4 errors=remount-ro,acl 0 1
EOF
# Automaticaly start networking.
cat << EOF | sudo tee debootstrap/etc/systemd/system/dhclient.service
[Unit]
Description=DHCP Client
Documentation=man:dhclient(8)
Wants=network.target
Before=network.target
[Service]
Type=forking
PIDFile=/var/run/dhclient.pid
ExecStart=/sbin/dhclient -4 -q
[Install]
WantedBy=multi-user.target
EOF
sudo ln -sf debootstrap/etc/systemd/system/dhclient.service \
    debootstrap/etc/systemd/system/multi-user.target.wants/dhclient.service

И, наконец, создайте образ qcow2:

Если вам нужно больше места на диске, измените + 1G (этот образ не следует использовать для компиляции, только для тестирования).

sudo virt-make-fs \
    --format qcow2 \
    --size +1G \
    --type ext2 \
    debootstrap \
    xenial-debootstrap-arm.ext2.qcow2

Вы всегда можете изменить его размер позже:

qemu-img resize xenial-debootstrap.ext2.qcow2 +5G
# Inside the QEMU vm as root:
resize2fs /dev/sda

Запустите наше скомпилированное ядро с помощью начальной загрузки Ubuntu ARM (я рекомендую использовать более одного процессора с -smp <n>, поскольку эмуляция процессора медленная):

qemu-system-arm \
  -M virt -kernel linux/arch/arm/boot/zImage -M virt -smp 4 \
  -append 'root=/dev/vda console=ttyAMA0' \
  -drive if=none,file=xenial-debootstrap-arm.ext2.qcow2,format=qcow2,id=hd \
  -device virtio-blk-device,drive=hd \
  -device virtio-net-device,netdev=net0 \
  -netdev user,id=net0,hostfwd=tcp::2222-:22,hostfwd=tcp::9999-:9999 \
  -monitor telnet:127.0.0.1:55555,server,nowait \
  -nographic

От ТС
Эта статья статья, является переводом. Оригинал доступен тут
Тема эксплуатации ядра линукса для меня новая, поэтому в переводе могут быть ошибки. Кроме того, я давно ничего не переводил для форума

Перевод:
Azrv3l cпециально для xss.pro