Мой первый Android телефон Galaxy Note N7000 был приобретен сразу после анонса в октябре 2011 года. Благодаря одному немецкому умельцу под ником bauner, у меня была возможность использовать последнюю версию CyanogenMod (ныне LineageOS). До тех пор, пока полтора года назад телефон не умер от китайской автомобильной зарядки.
Замену искал долго и остановился на Kyocera (да, они и телефоны выпускают) KC-S701. Он отличается брутальным внешним видом и отсутствием сенсорных кнопок. О root доступе к телефону я тогда даже и не задумывался, полагая, что нынче каждый телефон тем или иным способом имеет возможность получения root. И найдется умелец, который сможет под него портировать CyanogenMod. Я ошибался.
За полтора года было выпущено всего одно обновление — фикс падения ядра от специально сформированного ping пакета. А Android KitKat уже год назад был не первой свежести. Root доступ на этот телефон так никто и не получил, и никакой информации о нем не было. Отмечу, что тоже самое железо используется в американской версии телефона Kyocera Brigadier E6782, в котором по-умолчанию активизирован режим fastboot и нет ограничения на запуск неподписанных ядер (именно запуск, а не прошивку, и только при использовании непропатченного bootloader’а, CVE-2014-4325) и присутствует возможность загружаться в эти режимы путём зажатия кнопок телефона. Стараниями Verizon (а может Kyocera?) версия Android на Brigadier была обновлена до Lollipop.
[ad name=»MiBand2″]
Итак, я решил разобраться с процессом получения root на Android самостоятельно.
Два месяца назад я ничего не знал об устройстве Android (а сейчас я еще больше не знаю). Большую часть знаний пришлось добывать изучением исходных кодов и экспериментами, т.к. информации о взломе Android в интернете очень мало. Последующее описание справедливо для Android 4.4 KitKat, но не исключено, что оно заработает и на более новых версиях.
Хочу обратить ваше внимание на то, что в данном обзоре описан исключительно мой конкретный опыт взлома Android на конкретной модели телефона, поэтому будьте предельно осторожны с его применением в своей практике, если не хотите внезапно получить мертвый телефон. Перед началом исследований я рекомендую забыть о том, что вы пользуетесь взламываемым телефоном в повседневной жизни и сделать backup с последующим hard reset. Это обезопасит ваши данные при совершении ошибки.
В статье описаны не только действия, которые привели к успеху, но и ошибки. Надеюсь, что мои попытки докопаться до истины и многочисленные грабли будут вам интересны.
Все исследования проводились в Linux окружении.
[ad name=»Responbl»]
Простыми словами dirtycow (рабочий эксплойт под Android) позволяет заменить память любого процесса (полезно, если хорошо знаешь ASM) или любой доступный для чтения файл, даже если он находится на readonly файловой системе. Желательно, чтобы подменяемый файл был меньше либо равен по размеру заменяемому. Основная атака в dirtycow для Android — подмена /system/bin/run-as — подобие sudo для отладки приложений. Начиная с API android-19 (таблица соответствия версий API и Android) /system/bin/run-as имеет CAP_SETUID и CAP_SETGID capabilities флаги (в старых версиях используется обычный suid bit — 6755).
$ getcap bin/run-as bin/run-as = cap_setgid,cap_setuid+ep
Если файловая система будет примонтирована в режиме read-write, то всё, что dirtycow подменяет, окажется на файловой системе. Потому необходимо сделать backup оригинального файла и восстановить его после получения доступа, либо не перемонтировать файловую систему в режиме read-write. Как правило раздел /system в Android по умолчанию примонтирован в режиме read-only.
Не зря dirtycow считается одной из серьезнейших уязвимостей, обнаруженных в Linux. И при наличии знаний с помощью dirtycow можно обойти все уровни защиты ядра, в том числе и SELinux.
Для начала можно почитать как работают контексты SELinux. Неплохая статья на wiki Gentoo: https://wiki.gentoo.org/wiki/SELinux/Tutorials/How_does_a_process_get_into_a_certain_context
Если коротко, то:
Единственный доступный способ получения относительно привилегированного shell в production устройствах Android — developer mode. Developer mode запускает демон adbd, который может выступать в том числе и как аналог ssh/telnet. В Android KitKat он находится в initramfs по пути /sbin/adbd и не доступен для чтения для не-root пользователей. Изначально adbd запускается под пользователем root и работает в SELinux контексте/домене init (используется процессом init и как правило имеет больше привилегий, чем другие домены).
Если в /init.rc явно указан контекст процесса, например seclabel u:r:adbd:s0, то процесс запускается сразу в указанном контексте. При инициализации adbd в зависимости от параметров компиляции (user, userdebug или eng и параметров Android (properties) понижает привилегии, а именно меняет текущего пользователя с root на shell, устанавливает SELinux context в shell и урезает все системные capabilities кроме CAP_SETUID и CAP_SETGID (что требуется для отладки приложений через run-as). Так называемый Capability Bounding Set не позволяет дочерним приложениям повышать capabilities, только понижать.
Эти привилегии позволяют делать на телефоне чуть больше, чем ничего. Просмотреть capabilities текущего процесса можно командой cat /proc/self/status | grep CapBnd. А расшифровать их можно с помощью команды capsh (не доступна на Android), например:
$ capsh --decode=0000001fffffffff
Текущий SELinux context можно просмотреть командой id или cat /proc/self/attr/current. Предыдущий контекст процесса можно просмотреть командой cat /proc/self/attr/prev.
Просмотр context’а файлов: ls -Z
Просмотр context’а запущенных процессов: ps -Z
[ad name=»Umi 600×217″]
Первое, что я сделал это использовал dirtycow по прямому назначению — подменил /system/bin/run-as, который задал UID/GID в 0 (тоже самое делает su). Однако монтировать файловую систему я не мог, даже tmpfs. Загружать модули ядра я тоже не мог. Просматривать dmesg — нет. Я даже не мог просматривать директории, которые имели права 700 и принадлежали другим системным пользователям. Я мог лишь читать и писать в блочные устройства, а просмотр файлов или директорий был возможен благодаря заданию UID/GID определенного пользователя (написал свой велосипед — аналог su, который мог задавать selinux context и пользователя/группу).
Первым делом я сделал дамп всей прошивки, boot и recovery:
$ dd if=/dev/block/mmcblk0 of=/storage/sdcard1/mmcblk0.img $ dd if=/dev/block/platform/msm_sdcc.1/by-name/boot of=/storage/sdcard1/boot.img $ dd if=/dev/block/platform/msm_sdcc.1/by-name/recovery of=/storage/sdcard1/recovery.img
Изучить дамп можно утилитами kpartx и unpackbootimg. Команда kpartx -a mmbblk0.img создает виртуальное блочное устройство, доступное по пути /dev/mapper/loop0. С ним можно работать как с любым другим блочным устройством. Дампы разделов boot и recovery распаковал утилитой unpackbootimg.
Потом попробовал записать в recovery /dev/zero, проверить и сразу восстановить из дампа.
Раз я мог писать в блочные устройства, значит я мог записать custom recovery. Нашел TWRP от Brigadier, прошил в recovery и перезагрузился в него adb reboot recovery. TWRP я не увидел, а лишь иконку Android’а с восклицательным знаком. Так выглядит стандартный recovery, а значит TWRP не прошился.
Перезагружаюсь в обычный режим, запускаю эксплойт, проверяю hash recovery раздела — hash соответствует оригинальному. Пробую записать данные опять — hash поменялся! Вспоминаю про page cache, чищу (echo 3 > /proc/sys/vm/drop_caches) — hash старый. Т.е. всё, что я пишу в блочное устройство улетает без ошибок в /dev/null и иногда оседает в Linux cache. Но обновление прошивки ведь как-то происходит? И пользовательские данные как-то записываются во внутреннюю память. Надо копать дальше.
На тот момент я думал, что все ошибки об отсутствии привилегий вызваны SELinux (я полностью забыл о том, что могут быть урезаны capabilities). Логов dmesg я не видел, logcat ничего релевантного не показывал. И я начал думать как отключить SELinux.
Первая зацепка, которую я смог найти:
$ grep -A2 reload_policy boot/ramfs/init.rc
on property:selinux.reload_policy=1
restart ueventd
restart installd Исходники говорят о том, что при изменении этой опции, init перезагружает политики SELinux из файла /sepolicy.
Т.е. я при помощи dirtycow могу перезаписать /sepolicy и командой setprop selinux.reload_policy 1 загрузить обновленную политику.
Для начала нужно выяснить что из себя представляет /sepolicy. Изучить его можно с помощью команды sesearch (пакет setools в Debian).
$ sesearch --allow sepolicy $ sesearch --neverallow sepolicy $ sesearch --auditallow sepolicy $ sesearch --dontaudit sepolicy
В моём случае /sepolicy содержал только allow, что значит — при enforcing режиме SELinux в Android разрешено делать только то, что объявлено в политике. А процессу init разрешалось только загружать политику, но не отключать:
$ sesearch --allow sepolicy | grep 'load_policy' allow init kernel : security load_policy ;
Моей задачей было — разрешить init контексту задать selinux->enforce в permissive (setenforce 0).
Первое, что я сделал — собрал стандартную политику стокового Android, подменил оригинальный /sepolicy, загрузил (под root пользователем setprop selinux.reload_policy 1) и получил сообщение в статусной строке, что телефон находится в незащищенном режиме. После этого телефон отказывался запускать приложения, стал очень задумчив, задать permissive режим мне тоже не удалось и в конечном итоге телефон перезагрузился. Отрицательный результат тоже результат, замена /sepolicy сработала.
Первая же мысль: стоковая политика не подходит этому телефону и он при отсутствии прав начинает тупить.
Я собрал новую политику, в которой просто описал все существующие SELinux context и объявил их permissive. Тоже не помогло.
Потом я решил пересобрать политику и по возможности добавить привилегии для shell контекста.
Я нашел статью, в которой говорится как «декомпилировать» политику. Немного повозившись я смог собрать все зависимости и запустить утилиту sedump. На выходе я получил текстовый файл, который я смог собрать обратно (для KitKat checkpolicy -M -c 26 -o sepolicy.new policy.conf) и даже получить файл с точно таким же размером что и оригинальный sepolicy, но разным hex содержимым. Загрузка новой политики вызвала точно такие же результаты, что и ранее — телефон через какое-то время перезагружался.
Я решил собрать две политики: из policy.conf, который я получил и из policy.conf, в котором добавлены все привилегии для allow init kernel : security, в том числе и setenforce. Сравнить файлы в hex и по аналогии заменить байты в оригинальном sepolicy.
[ad name=»Redmi»]
Как выяснилось две пересобранные политики отличались всего парой байт. Я начал искать похожие совпадения в оригинальном sepolicy, но не нашёл. Затем я просто написал brute force скрипт, который в заданном диапазоне смещений заменяет два байта на «0xFF,0xFF», запускает sesearch --allow | grep "нужный результат". Таким образом я нашел необходимое смещение в оригинальной политике, заменил байты, подменил оригинальную политику и ничего. Отключить selinux опять не удалось.
Чуть позже я нашел утилиту sepolicy-inject, которая добавляет привилегии в уже скомпилированный sepolicy файл. Если правило уже существует, то добавление максимальных привилегий не увеличивает конечный размер политики. К сожалению запуск утилиты добавляет всего одно правило за раз. Написал скрипт, который добавляет максимальные привилегии для каждого правила. Результатом был файл с политикой, в которой каждое правило содержало максимальные привилегии. Размер файла совпадал с оригинальным. И это опять не помогло.
Потом я узнал, что в Android есть команда load_policy, которая перезагружает политику по любому пути. Танцы с бубном оказались лишними.
adb shell run-as /data/local/tmp/run -u system -c u:r:init:s0 load_policy /data/local/tmp/sepolicy.new
Можно было добавить любой permissive домен, загрузить новую политику и работать в контексте этого домена (кстати, supersu от chainfire для новых версий Android так и работает). Но даже это не дало возможности отключить SELinux. Я решил копать в другом направлении.
Проверяю разницу между boot и recovery разделами. Все идентично кроме initramfs. В initramfs раздела recovery изучаю init.rc, в котором описан лишь один сервис, который запускает /sbin/recovery. Изучаю strings sbin/recovery | less, затем исходники оригинального recovery. Как видно, по умолчанию recovery просто отображает логотип Android. А если необходимо что-то сделать, то в штатном режиме в раздел /cache записывается файл /cache/recovery/command, который может содержать параметры запуска recovery. Если в этот файл записать --show_text то мы должны увидеть меню.
Запускаю dirtycow exploit, выставляю UID/GID, записываю файл и запускаю adb reboot recovery. Телефон перезагружается и я попадаю в меню стандартного recovery. Уже что-то. Пробую прошить ZIP файл с supersu через adb sideload. Операция прерывается с ошибкой. Толком не смотрю на ошибку, а лезу в код recovery и ищу место, отвечающее за проверку цифровой подписи ZIP файла.
Выясняю, что initramfs содержит публичный ключ res/keys в формате minicrypt, которым проверяется цифровая подпись ZIP файла. Оказалось это стандартный тестовый ключ Android, и что я могу подписать этим ключём любой архив. Проверить это можно следующим образом:
java -jar dumpkey.jar android/bootable/recovery/testdata/testkey.x509.pem > mykey diff -u mykey res/keys
Попробовал установить ZIP напрямую с sdcard, но в recovery при монтировании sdcard возникала ошибка. Изучил etc/recovery.fstab, оказалось что в режиме recovery sdcard монтируется как vfat:
$ grep mmcblk1 recovery/ramfs/etc/recovery.fstab /dev/block/mmcblk1p1 /sdcard vfat nosuid,nodev,barrier=1,data=ordered,nodelalloc wait
Моя 64Gb флэшка была отформатирована в exfat. Нашел старую sdcard на 2Gb, отформатировал её как vfat, записал ZIP, вставил её в телефон. Recovery в этот раз смог примонтировать карточку и я мог просматривать её содержимое на телефоне. Однако при установке ZIP опять возникла ошибка: E:failed to set up expected mounts for install; aborting.
Команда strings recovery показала, что этот recovery отличается от стокового, по крайней мере там присутствовали строки, относящиеся к Kyocera, и скорее всего к чистке раздела /data. Покопавшись в оригинальных исходниках я выяснил, что интересующая меня ошибка возникает в функции setup_install_mounts в файле roots.cpp.
Т.е. перед тем как применить ZIP, recovery отмонтирует все разделы, но в моём случае что-то идёт не так.
[ad name=»Responbl»]
Лицензия GPL обязывает производителей смартфонов выкладывать исходники ядра. Спасибо Линусу и Столлману за это. Иногда производители выкладывают что-то левое, иногда правильные исходники, но без defconfig файла, иногда правильные и очень редко с инструкцией как их собирать (например LG).
В моём случае были исходники с правильным defconfig но без инструкции. Немного попотев я смог собрать ядро и убедился, что это не полная липа.
Через продолжительное время я остановился на двух файлах:
Kyocera долго не думала, а просто запилила хуки на потенциально опасные операции в Android: mount, umount, insmod (к загрузке разрешен всего один модуль — wlan и только если его загрузит init процесс), и прочее. Вот где крылась проблема recovery. Он не мог отмонтировать файловую систему /system! Эти операции позволялись только init процессу. В том числе я не мог отключить SELinux потому что эта возможность была отключена при компиляции ядра. Обойти эти хуки можно было только, если ядро загружено с определенными параметрами (kcdroidboot.mode=f-ksg или androidboot.mode=kcfactory, о них чуть позже).
Тоже интересный для изучения файл. В нем описываются возможные варианты загрузки телефона:
0x77665500 — hex метка 00556677 в разделе sbl1)0x77665502 — hex метка 02556677 в разделе sbl1)0x6f656d01 — hex метка 016d656f в разделе sbl1). Что происходит во время этого режима устанавливается производителем. Судя по исходникам, в этот режим телефон перезагружается при ошибке аутентификации прошивок из раздела modem.Немного о том, как происходит загрузка на телефонах с процессором Qualcomm:
Встроенный ROM загрузчик Qualcomm (pbl — primary bootloader) загружает раздел sbl1 (secondary bootloader). sbl1 загружает tz (trust zone), затем aboot (android boot, little kernel, lk). Aboot в свою очередь загружает boot, recovery или fota.
Описание разделов, участвующих при загрузке:
Все эти разделы подписаны цепочкой сертификатов.
[ad name=»UMI 600×313″]
В некоторых случаях полезно игнорировать обновления прошивки.
FOTA — firmware over the air. В отличие от boot и recovery, fota — это неофициальный режим загрузки Android. Задача fota — обновить прошивку. В Kyocera для этого используется решение от компании Red Bend, которое в 35Mb умещает обновление не только ядра но и раздела /system. Потому запись в раздел /system запрещена, иначе наложение патча на неправильные данные может окирпичить телефон.
На мой телефон имелось обновление. Отважиться на него я мог потому, что я уже имел возможность писать в /cache и прервать обновление в любой момент.
Изучив исходники отвечающего за обновление Java приложения, мне стало ясно как оно происходит:
/cache/delta/boot_delta.bin, создает файл /cache/delta/Alt-OTA_dlcomplete, подтверждающий успешную загрузку файла, и другие файлы с header’ами.libjnialtota.so происходит модификация раздела fotamng.Перезагрузка происходит не моментально, значит у меня есть возможность удалить файл перед перезагрузкой и посмотреть что происходит с разделом fotamng.
Пишу команду, которая непрерывно делает дамп раздела и переименовывает /cache/delta/boot_delta.bin. Запускаю её сразу после соглашения о перезагрузки телефона. Телефон перезагружается в режим FOTA, рапортует об отсутствии обновления и перезагружается в обычный режим.
Начинаю изучать данные, которые сдампил. В разделе /cache бонусом получаю логи fota, в которых даже есть логи dmseg! Сама перезагрузка в fota инициализируется байтами «1» в разделе fotamng:
$ dd if=/data/local/tmp/one_bit.bin of=/dev/block/platform/msm_sdcc.1/by-name/fotamng seek=16 bs=1 count=1 $ dd if=/data/local/tmp/one_bit.bin of=/dev/block/platform/msm_sdcc.1/by-name/fotamng seek=24 bs=1 count=1 $ dd if=/data/local/tmp/one_bit.bin of=/dev/block/platform/msm_sdcc.1/by-name/fotamng seek=131088 bs=1 count=1 $ dd if=/data/local/tmp/one_bit.bin of=/dev/block/platform/msm_sdcc.1/by-name/fotamng seek=131096 bs=1 count=1
После перезагрузки они обнуляются. В dmesg я обратил внимание на наличие параметра ядра kcdroidboot.mode=f-ksg. Вот оно! Т.е. загрузчик снимает защиту для fota. И чисто теоретически, если я запишу раздел boot в fota и перезагружу телефон в этот режим, то я получу ядро с отключенной защитой Kyocera. Но писать в системные разделы я всё еще не могу.
То, что находится в разделе aboot — загрузчик Android, ванильные исходники которого находятся по адресу: https://source.codeaurora.org/quic/la/kernel/lk/
Там можно найти и информацию как происходит загрузка в некоторые из режимов. Например я нашел информацию о том, что если в раздел misc записать «boot-recovery», то перезагрузиться в recovery можно без adb reboot recovery. При загрузке в recovery эта метка обнуляется. И если recovery загрузиться не может, то телефон попадёт в boot loop и вы его потеряете. Так что будьте осторожны, а лучше избегайте этого варианта перезагрузки.
Там же можно найти код, который переводит системную область emmc в режим read-only. Ответ на вопрос, почему невозможно перезаписать recovery. Эту защиту можно отключить из ядра Linux , если написать соответствующий модуль ядра. Уже всё написано товарищем из страны восходящего солнца, который, похоже, тоже неровно дышит к телефонам компании Kyocera. Модуль с первого раза не сработал, иногда подвешивает mmc в claim mode. Возможно не всё так однозначно и требуется детальное исследование.
Вот так происходит проверка подписи загрузочных разделов: https://source.codeaurora.org/quic/la/kernel/lk/tree/platform/msm_shared/image_verify.c?h=LA.BR.1.3.3_rb2.29
[ad name=»Responbl»]
Google мне помог ответить на вопрос, почему я не могу прочитать логи ядра: /proc/sys/kernel/dmesg_restrict. Значение этого параметра задается в 1 во время загрузки телефона. Если у пользователя нет CAP_SYS_ADMIN capability, то логи ему не доступны.
В моём случае, на удивление, была возможность задать /sys/kernel/uevent_helper. Если в этот параметр записать путь до executable файла (shell script тоже сойдёт), то он с определенным интервалом будет запускаться от процесса init в контексте init и что самое важное с full capabilities.
Я написал скрипт:
#!/system/bin/sh echo 0 > /proc/sys/kernel/dmesg_restrict
Загрузил его на телефон и записал его путь в /sys/kernel/uevent_helper. У меня появилась возможность видеть dmesg!
[ad name=»MiBand2″]
Т.к. мне надоело иметь доступ к урезанной консоли Android, а патчить бинарник adbd мне лень, то я решил собрать свой adbd с блэкджеком и шлюхами. Для этого пришлось скачать 70 Gb исходников Android, чтобы не возиться с каждой зависимостью по отдельности. Убрал проверку при которой происходит урезание capabilities, скомпилировал, подменил /sbin/adbd и получил полноценную root консоль. Теперь я могу монтировать файловые системы, смотреть dmesg без отключения dmesg_restrict, спокойно просматривать и редактировать файлы, которые не принадлежат root и многое другое. Но я пока не могу монтировать /system раздел и загружать модули в ядро.
Кстати, этой процедуры можно избежать, скомпилировав lsh и подставить его путь в /sys/kernel/uevent_helper. Желательно обернув запуск lsh в скрипт, который задаёт PATH environment, иначе придется задавать полный путь к каждой команде.
WiFi в моем телефоне работает через модуль ядра. WiFi включен — модуль загружен. WiFi выключен — модуль выгружен. Если подменить модуль на свой, то при включении WiFi должен загрузиться подставной модуль. На моё счастье цифровая подпись модулей не проверялась. Первое, что я попробовал, это собрать и загрузить модуль, который отключает SELinux путем замены памяти ядра на Amazon Fire Phone: https://github.com/chaosmaster/ford_selinux_permissive
Чтобы собрать модуль, требуется более-менее соответствующие исходники ядра и файл Module.symvers. Если исходники точно соответствуют тому ядру, что используется на телефоне, то Module.symvers, сгенерированный автоматически при сборке ядра должен подойти.
Если при загрузке модуля ядро будет ругаться (disagrees about version of symbol module_layout), то потребуется извлечь Module.symvers из boot раздела. Это можно сделать, используя скрипт https://github.com/glandium/extract-symvers:
$ unpackbootimg -i boot.img -o boot $ extract-symvers.py -e le -B 0xc0008000 boot/boot.img-zImage > %PATH_TO_KERNEL%/Module.symvers
Нельзя просто так взять и собрать свой модуль для телефона Kyocera.
Помните список доступных для загрузки модулей? Модуль должен называться wlan и никак иначе. Решается это просто:
wlan.c на исходник модуля... MODULE_NAME = wlan ...
Модуль на удивление загрузился (память, которую занимает модуль wlan сократилась, проверяется командой lsmod), но SELinux не отключился.
В dmesg не было никакой информации от подставного модуля. А всё потому, что у ядра есть еще один параметр: /proc/sys/kernel/printk, который фильтрует INFO логи, в том числе модулей. Я понизил порог всех логов: echo '8 8 8 8' > /proc/sys/kernel/printk. Перезагрузил модуль и увидел, что модуль просто не нашел требуемой маски, потому отключить SELinux не удалось.
Единственное, что я не уяснил, как программно вызвать отключение и включение WiFi. Мне приходится выключать/включать WiFi вручную через интерфейс Android.
SELinux отключить не удалось, но по аналогии с модулем https://github.com/chaosmaster/ford_selinux_permissive можно попробовать сделать тоже самое, но с Kyocera hooks. Мне нужно лишь задать переменную kc_bootmode или kc_kbfm в единицу.
В ядре Linux есть возможность получить адреса указателей всех функций и переменных: cat /proc/kallsyms. По умолчанию эти адреса отображаются как 0. Это работает очередная защита ядра. Отключить её можно так: echo 0 > /proc/sys/kernel/kptr_restrict.
[ad name=»Responbl»]
Получив адрес нужной функции, я мог передать в неё параметр и функция задаст переменную в 1. Опытным путем выяснил, что не все ядра отображают kallsyms для переменных (тип d или D, регистр говорит глобальная переменная или нет), поэтому в примерах я использую указатели на функции. Возможно это определяется опцией CONFIG_KALLSYMS_ALL при компиляции ядра.
$ adb shell "grep kc_bootmode_setup /proc/kallsyms" c0d19d84 t kc_bootmode_setup
Описываю функцию в модуле:
int (*_kc_bootmode_setup)(char *buf) = (int(*)()) 0xc0d19d84;
И вызываю её:
_kc_bootmode_setup("f-ksg") Можно адреса найти динамически:
_kc_bootmode_setup = (int (*)(char *buf))kallsyms_lookup_name("kc_bootmode_setup"); Загрузка подставного модуля отключила встроенную защиту! Теперь я могу монтировать /system и загружать любой модуль ядра независимо от его имени.
Системная область emmc всё еще доступна только для чтения и не позволяет редактировать /system раздел на постоянной основе. Файлы редактируются, но при очистке cache все возвращается в исходное состояние.
Из спортивного интереса я всё-таки решил отключить SELinux. Заменить defined значение selinux_enabled мы не можем, но мы можем разыменовать структуру с hooks функциями security_ops.
Это делается вызовом функции reset_security_ops:
void (*_reset_security_ops)(void) = NULL;
... ... ...
_reset_security_ops = (void (*)(void))kallsyms_lookup_name("reset_security_ops");
if (_reset_security_ops != NULL) {
_reset_security_ops();
} После этого защита SELinux работать не будет, но система всё еще будет думать, что она включена. Потому возможны некоторые ошибки в работе системы.
int (*_enable_dload_mode)(char *str) = (int(*)()) 0xc0d0cc18;
... ... ...
_enable_dload_mode("dload_mode"); Та же операция работает и с download_mode, о котором я писал выше. После загрузки модуля телефон перезагружается в спец режим, который работает как usb mass storage device. Т.е. я имею доступ ко всем разделам телефона без защиты от чтения! Попробовал записать свой recovery.
Пришлось ограничить скорость записи, иначе телефон отваливается и запись прекращается. Возможно это результат переполнения кэша mass storage загрузчика. Пришлось написать хак:
BS=512
nextblock=0
IMG=my-recovery.img
DEST=/dev/sdb12
# 64 - total amount of 512*512b blocks for 16Mb partition (16Mb*1024*1024/(512*512))
for i in {1..64}; do
echo $i
echo dd if=${IMG} of=${DEST} bs=${BS} seek=${nextblock} skip=${nextblock} count=${BS} oflag=direct
dd if=${IMG} of=${DEST} bs=${BS} seek=${nextblock} skip=${nextblock} count=${BS} oflag=direct
nextblock=$((nextblock+BS))
echo "nextblock = ${nextblock}"
sleep 0.5
done
sync
echo 3 > /proc/sys/vm/drop_caches Загрузил телефон, выполнил adb reboot recovery и ничего. Только вибрация с последующей обычной загрузкой. Помните про раздел misc, не стоит проверять recovery через запись в этот раздел.
При помощи этого же способа я примонтировал /system раздел к компьютеру и вручную записал на него supersu. Первоначальная задача выполнена: перманентный root доступ получен. Осталось автоматизировать загрузку подставного WiFi модуля, который отключает hooks. И хорошо бы, чтобы WiFi после этого оставался работоспособным. А еще лучше разблокировать загрузчик, чтобы загружать своё ядро.
Для начала можно изучить какие средства применялись для разблокировки других телефонов. При беглом поиске я обнаружил лишь следующие два, к тому же устаревшие:
Я пытался выяснить каким публичным ключём подписаны boot образы. Распаковал ключи из aboot (binwalk -e aboot), извлек подписи из образов и прошелся всеми публичными ключами по ним. Выяснил, что все образы подписаны одни ключём. С ходу не разобрался как вычислить смещение подписи у boot разделов, потому я просто перепаковываю образ и использую его размер как смещение. С aboot чуть сложнее. Мне удалось извлечь подпись и расшифровать sha256 образа. А вот понять как самому вычислять sha256, чтобы сравнить с расшифрованным значением, пока не удалось.
#!/bin/bash
# print der certificate:
# openssl x509 -inform der -in 0xff.crt -text -noout
# mkdir boot
# unpackbootimg -i 09-boot.img -o boot
# cd boot
# mkbootimg --kernel 09-boot.img-zImage --ramdisk 09-boot.img-ramdisk.gz --cmdline "`cat 09-boot.img-cmdline`" --base `cat 09-boot.img-base` --pagesize `cat 09-boot.img-pagesize` --dt 09-boot.img-dtb --kernel_offset `cat 09-boot.img-kerneloff` --ramdisk_offset `cat 09-boot.img-ramdiskoff` --tags_offset `cat 09-boot.img-tagsoff` --output mynew.img
# dd if=../09-boot.img of=signature.bin bs=1 count=256 skip=$(ls -la mynew.img | awk '{print $5}')
# cd ..
# binwalk -e 05-aboot.img
# extract aboot signature
# dd if=05-aboot.img of=signature.bin bs=1 count=256 skip=$(od -A d -t x4 05-aboot.img | awk --non-decimal-data '/^0000016/ { i=sprintf("%d\n","0x"$3); print (i+40)}')
# extract base aboot image
# 40 - aboot header size, refer to: https://android.googlesource.com/kernel/lk/+/caf/master/target/msm8226/tools/mkheader.c#160
# dd if=05-aboot.img of=aboot-base.img bs=1 count=$(od -A d -t x4 05-aboot.img | awk --non-decimal-data '/^0000016/ { i=sprintf("%d\n","0x"$3); print (i)}') skip=40
# how sha256 was calculated?
# openssl dgst -sha256 -sign private_key -out signature.bin aboot-base.img ?
NAME=$1
IMG=${NAME}/mynew.img
SIG=${NAME}/signature.bin
#IMG=aboot-base.img
#SIG=signature.bin
CALC_SHA256=$(sha256sum ${IMG} | awk '{print $1}')
for i in `find . -name *.crt`; do
ORIG_SHA256=$(openssl rsautl -inkey <(openssl x509 -pubkey -noout -inform der -in ${i} 2>/dev/null) -pubin -in ${SIG} 2>/dev/null | hexdump -ve '/1 "%02x"')
if [ "${ORIG_SHA256}" != "" ]; then
echo "sha256 was decrypted using ${i} key - ${ORIG_SHA256}"
fi
if [ "${ORIG_SHA256}" = "${CALC_SHA256}" ]; then
echo "sha256 ${ORIG_SHA256}"
echo "$i"
fi
done В качестве эксперимента я попробовал записать boot раздел в раздел fota, зная, что при загрузке fota снимаются все ограничения. Здесь я сильно рисковал, т.к. мог получить bootloop, похожий на bootloop recovery. Метка загрузки в fota записывается в раздел fotamng и если раздел не загрузится, то я получу бесконечную перезагрузку.
К сожалению, boot раздел, записанный в fota не загрузился, а bootloop я, к счастью, не получил. Не понятно почему тогда boot раздел, записанный в recovery успешно загрузился. Толку от этого конечно нет, для recovery используется та же защита, что и для boot. Не знаю чем вызвано подобное поведение. Возможно различными смещениями ramdisk и tags:
[ad name=»UMI 600×313″]
boot/recovery:
ramdisk: 0x01000000 tags: 0x00000100
fota:
ramdisk: 0x02000000 tags: 0x01e00000
В Secure boot whitepaper от Qualcomm говорится о том, что подписывается sha256 hash от sha256 hash’ей нескольких сегментов ELF загрузчика. Количество сегментов определено в Subject’е сертификата. Например OU=05 00002000 SW_SIZE говорит о том, что в подписи содержится sha256 hash от первых 256 hash’ей областей по 32 байта (0x2000/32=256). Сам по себе aboot не содержит ELF заголовка и описание больше подходит к sbl1 (secondary boot loader).
Есть описание работы little kernel от Qualcomm, но и там нет ничего про алгоритм создания подписи aboot. Задача определить алгоритм все еще актуальна.
Для проведения экспериментов я заказал из штатов за символическую сумму Kyocera Brigadier с разбитым экраном.
Я проверил цифровые подписи aboot загрузчиков. Subject’ы сертификатов оказались идентичными, следовательно они могут быть взаимозаменяемыми. Решился на эксперимент: прошить aboot от KC-S701 в Brigadier. Загрузчик заработал. На удивление, защита emmc от записи с этим загрузчиком не включилась и я смог спокойно восстановить загрузчик от Brigadier. Понимая все риски, я решил прошить загрузчик от Brigadier на KC-S701. Я бы получил возможность загружать любое неподписанное ядро и использовать fastboot. В этот раз телефон не загрузился.
Тут история могла бы закончиться, но «телефон не загрузился» — это черный экран. И на моё счастье это был черный экран не Qualcomm QHSUSB__BULK, который требует специального подписанного загрузчика для восстановления телефона, а тот самый download mode, который представляет телефон как USB mass storage. Телефон был восстановлен. На сегодняшний день это последнее, что я предпринял.
Почему boot раздел не грузится из раздела fota? Ведь они подписаны одним ключём. Если бы загрузка произошла, то я бы получил разлоченный телефон, в котором не пришлось бы подменять модули.
Kyocera наряду с android system properties использует свой внутренний механизм properties, который мне тоже не удалось выяснить. Наверняка там хранятся интересные опции, которые могут влиять в том числе и на снятие защиты bootloader’а. В телефоне есть библиотека libkcjprop_jni.so и демон kcjprop_daemon. Библиотеку можно подключить и использовать её функции, но у меня пока не нашлось времени этого сделать.
Опции пишутся на файловую систему, внутри бинарные данные:
$ ls -la /sysprop/kcjprop/rw/8d9d788ddd5fecfdbc6c5f7c5cecfc -rw-rw---- root root 16 1970-01-22 21:01 8d9d788ddd5fecfdbc6c5f7c5cecfc
Kexec позволяет из ядра Linux загрузить другое ядро. По умолчанию в production релизах ядер отключают поддержку Kexec, но его можно включить через модуль ядра. Затем из user-end можно загрузить любое ядро, которое заменит текущее. Это выглядит как хак, но если хочется загружать своё ядро — этот вариант имеет своё место под солнцем.
QSEE — защита в процессорах Qualcomm, в которой недавно уже достаточно давно обнаружили уязвимость. Суть уязвимости — полный доступ к выполнению команд на уровне Trust Zone. Вплоть до загрузки любого ядра.
Пока еще разбираюсь в этом вопросе. Насколько я понял мне необходимо получить доступ к области emmc, называющейся RPMB. Этого можно добиться отправкой специально сформированной SCM командой. В области RPMB (Replay Protected Memory Block) содержатся биты, которые отвечают за lock/unlock статус.
Код модулей, aboot загрузчики и библиотека для работы с Kyocera Propertiies находятся в моём репозитории на github: https://github.com/kayrus/break_free.
[ad name=»Responbl»]
С каждым решением очередной проблемы, процесс всё больше напоминает апорию об Ахиллесе и черепахе. Не знаю на сколько еще хватит моего энтузиазма. Возможно здесь есть знающие люди, которые помогут достичь дна кроличьей норы.
Пользуясь случаем, выражаю благодарность разработчикам из компании Kyocera за прекрасные устройства и их защиту. В противном случае этой статьи бы не было. С другой стороны отсутствие регулярных обновлений сильно огорчает. Если у вас появится модель телефона с возможностью разблокировки загрузчика, я непременно его приобрету.
P.S. Огромное спасибо Николаю Еленкову (Nikolay Elenkov), автору книги Android security internals. Его пояснения о работе bootloader’а помогли понять процесс загрузки Android.
P.P.S. Еще один специалист по мобильной ИБ, Justin Case, сказал, что он знает уязвимость, которой подвержены все современные процессоры Qualcomm, но раскрывать её детали он не будет.
Чтобы взломать сеть Wi-Fi с помощью Kali Linux, вам нужна беспроводная карта, поддерживающая режим мониторинга…
Работа с консолью считается более эффективной, чем работа с графическим интерфейсом по нескольким причинам.Во-первых, ввод…
Конечно, вы также можете приобрести подписку на соответствующую услугу, но наличие SSH-доступа к компьютеру с…
С тех пор как ChatGPT вышел на арену, возросла потребность в поддержке чата на базе…
Если вы когда-нибудь окажетесь в ситуации, когда вам нужно взглянуть на спектр беспроводной связи, будь…
Elastic Security стремится превзойти противников в инновациях и обеспечить защиту от новейших технологий злоумышленников. В…