Hacker News Digest

52-летняя магнитная лента, обнаруженная в архивах, может содержать утерянные ранние версии Unix, включая код, предшествовавший официальному релизу в 1971 году. Найденная в коллекции Bell Labs, лента хранит копию версии Unix 0, которая считается "святым Граалем" для историков вычислительной техники. Успешное восстановление данных с этого артефакта позволит проследить эволюцию ключевых компонентов ОС, таких как файловая система и ядро, и заполнить пробелы в истории Unix, повлиявшей на современные операционные системы.

Специалисты из Computer History Museum и Unix Heritage Society ведут сложный процесс восстановления данных с деградированной ленты, используя специализированное оборудование. По словам одного из экспертов, "эта лента — как цифровая Декларация независимости для Unix". Если восстановление пройдет успешно, это станет первым случаем извлечения работающего кода из столь ранней версии Unix, предоставив уникальную возможность изучить "первобытный код", сформировавший основу для Linux, macOS и других систем.

• Обсуждение вращается вокруг архивных лент 1972 года, найденных в лаборатории IBM, и возможности их восстановления.
• Участники обсуждают, что это может означать для сохранения наследия Unix и ранних систем, и какие технические и этические вопросы это поднимает.
• Поднимается вопрос о том, что в будущем может быть трудно оценить значение таких находок, и что это может означать для сохранения истории компьютерной эпохи.
• Обсуждается, какие усилия предпринимаются для сохранения таких артефактов, и какие могут быть последствия для общественного доступа к ним.

Проект linux-wasm добавляет поддержку WebAssembly (Wasm) в ядро Linux, позволяя выполнять Wasm-модули непосредственно на уровне ядра. Это открывает новые возможности для безопасного выполнения кода с производительностью, близкой к нативной, без необходимости в традиционных виртуальных машинах или контейнерах. Поддержка включает базовую инфраструктуру для загрузки и выполнения Wasm-кода, а также интеграцию с существующими подсистемами ядра.

Проект находится на ранней стадии разработки, но уже демонстрирует потенциал для создания более легковесных и безопасных систем. Wasm-модули могут изолированно работать в пространстве ядра, что снижает накладные расходы по сравнению с традиционными процессами. Это особенно ценно для встраиваемых систем, IoT-устройств и сценариев, где критичны безопасность и производительность. Разработчики могут использовать существующие Wasm-инструменты для создания кода, который будет выполняться непосредственно в ядре Linux.

• Проект демонстрирует высокую производительность Linux в WebAssembly, но содержит критические баги (например, ошибки доступа к памяти, паники ядра).
• Потенциальные применения включают облачные терминалы, научные окружения (Jupyter), тестирование дистрибутивов и образовательные цели, но требует оптимизации размера рантайма (<1 МБ).
• Техническое отличие от аналогов (container2wasm, XRSH) — отсутствие эмуляции CPU, компиляция бинарных файлов напрямую в WASM и использование WebWorker для процессов.
• Основные проблемы: отсутствие поддержки сетевых сокетов, сырых сокетов, JIT-компиляции и ограниченная совместимость с инструментами (например, Node.js).
• Участники отмечают образовательную ценность проекта и его влияние на развитие WebAssembly, но скептически оценивают массовое внедрение из-за текущих ограничений.

Linux-ядро может запускаться как обычный процесс в пространстве пользователя без использования традиционного ПО для виртуализации. Эта технология, известная как User Mode Linux (UML), позволяет создавать виртуальные машины без QEMU или прав суперпользователя. UML можно рассматривать как паравиртуализированную конфигурацию ядра, которая использует существующее ядро хоста и его функции пространства пользователя. Вместо прямого доступа к физическому оборудованию, UML использует файлы и сокеты для создания нового экземпляра ядра, способного запускать собственные процессы. Интересно, что драйверы в UML "просветлены" - они осведомлены о работе с виртуализированным оборудованием и могут оптимизировать взаимодействие.

Для сборки UML-ядра требуется платформа x86, где оно может работать поверх существующего x86-ядра. Процесс сборки начинается с команды ARCH=um make menuconfig, где можно настроить специальные опции UML. Важно включить опцию BLK_DEV_UBD, которая позволяет обращаться к файлам хоста как к блочным устройствам. После финализации конфигурации ядро собирается командой ARCH=um make -j16, создавая бинарный файл linux. Интересно, что этот файл является динамически связанным исполняемым файлом с библиотекой C, а не традиционным ядром, работающим напрямую с железом.

• Использ /dev/urandom вместо /dev/zero при инициализации образа диска вызывает вопросы, так как неясно, какой практический смысл в этом есть при отсутствии шифрования.
• UML (User-mode Linux) позволяет запускать ядро как обычный процесс, но ограничен одним CPU и не поддерживает SMP, что ограничивает его практическое применение.
• Появление SKAS (Separate Kernel Address Space) и дальнейшее развитие виртуализации сделали UML менее актуальным, но он всё ещё может быть полезен как промежуточное решение между контейнерами и полноценными VM.

Процесс загрузки Linux начинается с нажатия кнопки питания, после чего процессор переходит в реальный режим (real mode) и выполняет инструкцию по адресу сброса 0xFFFFFFF0. Это приводит к запуску микропрограммы на материнской плате (BIOS или UEFI), которая выполняет самотестирование (POST) и ищет загрузочное устройство. При обнаружении загрузочного сектора (маркеры 0x55 и 0xAA), BIOS копирует его в память по адресу 0x7C00, после чего управление передается загрузчику GRUB. GRUB считывает свою конфигурацию, загружает ядро Linux в память и передает управление программе настройки, которая создает предсказуемую рабочую среду: выравнивает сегментные регистры, создает стек, очищает область BSS и запрашивает информацию о доступной памяти у микропрограммы. В конце концов, вызывается первая функция C с именем main, что标志着 переход к следующей фазе загрузки.

• Обсуждение показало, что статья о процессе загрузки Linux охватывает только самые базовые концепции, что вызвало критику за упрощение и упущение важных деталей, таких как взаимодействие с UEFI, инициализация видео и роль загрузчика.
• Участники подчеркнули, что статья не соответствует уровню подготовки аудитории Hacker News, и что она не раскрывает важные темы, такие как влияние UEFI на процесс загрузки.
• Также было отмечено, что статья не затрагивает такие важные темы, как влияние UEFI на процесс загрузки и не упоминает о таких важных компонентах, как initrd и драйверы.
• Некоторые комментаторы выразили сожаление по поводу того, что статья не затрагивает такие темы, как влияние systemd на процесс загрузки и не упоминает о таких важных компонентах, как initrd и драйверы.
• Также было отмечено, что статья не упоминает о таких важных компонентах, как initrd и драйверы, и не раскрывает влияние systemd на процесс загрузки.

Статья объясняет, как Linux выполняет ELF-бинарные файлы — основной формат программ в современных Linux-системах. Поддержка ELF реализована в файле fs/binfmt_elf.c, где основная функция load_elf_binary() занимает более 400 строк кода — вчетверо больше, чем поддержка старого формата a.out. ELF-файл содержит заголовок ELF и таблицу заголовков программы, из которой ядро извлекает три ключевых типа записей: PT_LOAD (описывающие области памяти программы), PT_INTERP (определяющий компоновщик) и PT_GNU_STACK (указывающий, должен ли стек быть исполняемым).

Процесс загрузки начинается с проверки формата файла и чтения его заголовков. Затем функция вызывает flush_old_exec(), которая очищает состояние ядра, унаследованное от предыдущей программы, убивает другие потоки процесса и очищает обработку сигналов. Это обеспечивает чистый запуск новой программы с одним потоком. Интересно, что BSS-секция (для неинициализированных данных) в ELF-файле хранится только как размер, так как ядро заполняет её нулями при загрузке.

• Пользователи обсуждают, что в детстве изучение формата ELF привело к интересу к Linux и программированию.
• Обсуждается, что обработка исполняемых файлов теперь происходит в пространстве пользователя, что, как предполагается, может уменьшить риск крашей ядра из-за ошибок в формате.
• Участники вспоминают, что когда-то процесс загрузки ELF-файлов назывался "image activation", и что эта терминология исчезла после dot-com краха и появления LLM.
• Несколько человек спорят о том, как именно загружаются статические бинарники: часть считает, что ядро все еще обрабатывает их, другие утверждают, что это не так.

В статье рассматривается создание микро-Linux дистрибутива с нуля, включая сборку ядра Linux и разработку ПО для упаковки. Пример реализован для архитектуры RISC-V (QEMU riscv64 virt), но подход применим и к x86. Автор предупреждает, что это упрощенное представление Linux-дистрибутива, предназначенное для начинающих, и некоторые детали могут быть неточны на 0.1%.

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

• Обсуждение вращается вокруг создания минимальной Linux-системы: от идеи до практических нюансов (UEFI, cloud-init, PXE, initramfs, cpio, u-root, kexec, Gentoo vs LFS vs Buildroot).
• Участники делятся опытом, что «маленькая» сборка может быть полезна как для обучения, так и для практического применения (например, как образ для облачных инстансов).
• Обсуждаются различные инструменты и подходы: от полностью статически слинкованных бинарников до полноценных дистрибутивов, а также варианты с использованием u-root, kexec, initramfs, cpio, PXE и т.д.
• Участники также обсуждают, что такие мини-дистрибутивы могут быть полезны для обучения, отладки и даже как основа для специализированных образов (например, для RPi или как образ для облачных провайдеров).

Rust продолжает развиваться, и новые языковые функции, такие как проекции полей, инициализация на месте и произвольные типы self, становятся важными для разработки ядра Linux. Эти функции упрощают работу с указателями, позволяют избежать двойной инициализации и делают код более выразительным. Рядом с этими изменениями, Rust for Linux активно работает над стабилизацией существующих функций и разработкой новых, чтобы код ядра был не только безопасным, но и элегантным. Разработчики подчеркивают, что сообщество, включая участников Rust for Linux, играет ключевую роль в определении приоритетов разработки языка.

• Обсуждение охватывает вопросы от безопасного доступа к полям структур до сложных вопросов владения памятью в Rust, а также влияние этих обсуждений на разработку ядра Linux и взаимодействие с другими языками программирования.
• Участники обсуждали, что сложность Rust может быть препятствием для новых разработчиков, но также отметили, что сложность C++ может быть еще более запутанной.
• Обсуждались вопросы о том, как влияет на разработку ядра Linux внедрение Rust, и были высказаны мнения, что это может быть экспериментом, который следует проводить в другом месте.
• Также обсуждались вопросы о том, какие функции Rust могут быть полезны для разработки ядра Linux и какие функции Rust могут быть полезны для разработки ядра Linux.
• В конце обсуждение перешло к вопросу о том, какие функции Rust могут быть полезны для разработки ядра Linux и какие функции Rust могут быть полезны для разработки ядра Linux.

Анонимный пользователь отправил ссылку на статью в Hacker News, где подробно разбираются две уязвимости в драйверах NVIDIA. Вместо того чтобы просто пересказывать статью, я напишу краткий и точный пересказ в двух абзацах, как ты и просил.

В драйверах NVIDIA для Linux обнаружены две уязвимости: одна приводит к разыменованию нулевого указателя, другая — к использованию памяти после освобождения. Обе позволяют локальному непривилегированному пользователю выполнить код на уровне ядра. Уязвимости были исправлены NVIDIA в октябре 2025 года.

Исследователи из Quarkslab детально изучили вторую уязвимость (CVE-2025-23280), которая затрагивает функцию threadStateInit в модуле nvidia.ko. Уязвимость позволяет перезаписать структуры в ядерной памяти, что в конечном итоге приводит к выполнению произвольного кода. Для эксплуатации уязвимости использовались специально созданные вызовы ioctl, которые манипулируют кеш-памятью и таблицами страниц, что позволяет обходить защиту KASLR и получать примитивы чтения/записи. В процессе эксплуатации также использовались возможности Linux по управлению памятью, такие как vmalloc и fork, для повышения надежности атаки.

• NVIDIA просит отложить публикацию уязвимостей до января 2026 года, что выходит за рамки стандартного 90-дневного цикла раскрытия.
• Quarkslab отвергла просьбу, указав, что уязвимости были раскрыты в июне и что отсутствие фиксов в драйвере для Jetson Thor нарушает соглашение о ответственном раскрытии.
• Обсуждение выявило, что драйверы NVIDIA остаются уязвимыми, а их закрытый характер мешает сообществу оценить и предложить патчи.
• Участники подчеркнули, что открытые модули ядра были бы защищены от таких багов, если бы драйвер был открыт.
• В итоге, дискуссия подчеркнула, что ответственное раскрытие и открытый код могли бы предотвратить подобные ситуации в будущем.

Агенты ИИ, работающие с файловой системой, представляют угрозу безопасности, особенно в облачных средах. Злоумышленник может обойти защиту на уровне приложения и заставить агента раскрыть конфиденциальные файлы через системные вызовы. Решение — изоляция на уровне ядра, где сам Linux блокирует доступ к нежелательным ресурсам.

Анализ системного вызова open в ядре Linux показывает три точки отказа: do_open (поздний отказ), link_path_walk (средний) и path_init (ранний). Контейнеризация использует эти механизмы, создавая виртуальную файловую систему и пространства имён, чтобы скрыть реальные файлы от процесса. Это надёжнее, чем полагаться на фильтрацию ввода-вывода в приложении.

• Обсуждение методов изоляции и безопасности для AI-агентов, включая контейнеризацию (runc, podman), Landlock и WebAssembly как потенциальные решения.
• Критика предложенного подхода к песочнице как избыточной или неубедительной для экспертов по безопасности, с акцентом на использование существующих проверенных библиотек и методов.
• Уточнение требований к агенту для код-ревью: доступ только к кодовой базе, истории репозитория, диффам, CI/CD логам и системам отслеживания ошибок.
• Обсуждение практических сложностей реализации, таких как неподдерживаемые системные вызовы в gVisor и необходимость баланса между производительностью и безопасностью.
• Скептицизм относительно новизны и точности объяснения автора, с замечаниями, что описанные методы (chroot) не являются полноценной песочницей или контейнеризацией.

В ядре Linux начался процесс отказа от устаревшего метода mmap() в структуре file_operations, который используется с 1992 года. Проблема в том, что он даёт драйверам прямой доступ к критическим структурам управления памятью (VMA), что усложняет обработку ошибок и создаёт риски стабильности. Вместо него введён новый метод mmap_prepare(), вызываемый раньше в процессе маппинга и использующий более безопасный дескриптор vm_area_desc.

Этот подход ограничивает влияние драйверов на внутренние структуры памяти, упрощает откат при ошибках и снижает вероятность багов. Переход будет постепенным: драйверы не могут одновременно использовать старый и новый методы, а сотни существующих реализаций mmap() потребуют адаптации. Это шаг к большей инкапсуляции и надёжности подсистемы управления памятью.

• Обсуждение касается внутренней переработки в ядре Linux, а не удаления системного вызова mmap(), что успокаивает участников.
• Упоминается исторический контекст использования /dev/zero для выделения анонимных страниц памяти и его возможная замена.
• Участники шутливо предлагают создать новые виртуальные устройства, такие как /dev/seven (источник символа ^G) и /dev/yes (бесконечный поток "y\n").
• Подчёркивается консервативность и глубокая интеграция структуры file_operations в API ядра, что делает её изменение значительным событием.
• Обсуждается принцип "We do NOT break userspace" (Мы НЕ ломаем пользовательское пространство) как фундаментальный для разработки ядра Linux.

Встраивание Rust в ядро Linux продвигается с новым API для безопасной обработки ненадёжных данных из пользовательского пространства. Benno Lossin предложил тип Untrusted<T>, который помечает данные как непроверенные и предотвращает их случайное использование в ядре. Этот тип работает на уровне системы типов без накладных расходов в runtime, что делает его эффективным инструментом для маркировки данных из сетевых соединений, съёмных носителей или пользовательских вводов.

API включает утилиты для работы с распространёнными структурами данных, такими как срезы и векторы, и рекомендует интерфейсы вроде read_from_userspace(buf: &mut [Untrusted<u8>]) для безопасного копирования. Для валидации данных введён трейт Validate, хотя его реализация пока требует доработки. Greg Kroah-Hartman предложил добавить пример использования в драйверах, особенно для уязвимых мест вроде ioctl(), где непроверенные данные исторически вызывали переполнения буфера.

• Обсуждаются преимущества строгих типов (например, Untrusted<T>) для повышения безопасности, особенно при обработке пользовательского ввода в веб-приложениях и ядре ОС.
• Отмечается, что подобные подходы уже эффективно реализованы в Rust (для embedded и системного программирования) и Perl ("tainting"), делая код более надежным.
• Подчеркивается, что в C++ также возможна подобная типобезопасность, но она редко используется на практике из-за сложности и инерции сообщества.
• В контексте ядра ОС отмечается, что "ненадежные" данные не только потенциально вредоносны, но и нестабильны (могут меняться конкурентно, быть недоступными).
• Утверждается, что система владения и проверки заимствований (borrowck) в Rust делает подобные API более эргономичными и безопасными по сравнению с C++.

PythonBPF – пишем eBPF-программы на чистом Python
(в 2 раза короче)

---

Что это
Библиотека pip install pythonbpf компилирует Python-код в объектные .o-файлы и загружает их в ядро как обычные eBPF-программы. Репо: GitHub.

---

Было
Встраивали C в многострочные строки, теряя линтеры и подсветку:

from bcc import BPF
prog = """
int hello(void *ctx) {
    bpf_trace_printk("Hello\\n");
    return 0;
}
"""
b = BPF(text=prog)
b.attach_kprobe(event="sys_clone", fn_name="hello")

---

Стало
Тот же функционал — на Python:

from pythonbpf import bpf, section, compile
from pythonbpf.maps import HashMap
from pythonbpf.helpers import ktime
from ctypes import *

@bpf
def last() -> HashMap:          # глобальная BPF-мапа
    return HashMap(c_uint64, c_uint64, 1)

@bpf
@section("tracepoint/syscalls/sys_enter_execve")
def hello(_: c_void_p) -> c_int32:
    print("entered")
    return 0

@bpf
@section("tracepoint/syscalls/sys_exit_execve")
def bye(_: c_void_p) -> c_int64:
    print("exited")
    last().update(0, ktime())
    return 0

@bpf
def LICENSE() -> str:           # лицензия ядра
    return "GPL"

compile()                       # → .o и загрузка

---

Как работает

1. ast → дерево
2. llvmlite → LLVM IR
3. llc → BPF-объект
4. libbpf → загрузка в ядро

• Участники обсуждают инструмент для компиляции Python в eBPF байт-код, который был создан как проект на хакатоне и пока считается «игрушечным».
• Подчеркивается, что использование LLVM для трансляции в eBPF — более перспективный подход, чем прямое преобразование Python-байткода.
• Несколько пользователей отмечают отсутствие четких объяснений, что такое eBPF, и предлагают добавить больше документации и примеров.
• Критикуется идея использования LLM (больших языковых моделей) для генерации eBPF-кода из-за строгой проверки и специфики eBPF.
• Упоминаются существующие аналогичные проекты для других языков (Java, Node.js) и инструменты из мира BCC.
• Автор проекта признает, что код находится на ранней стадии и требует значительной доработки.

• CVE-2025-53136 – утечка адреса ядра Windows 24H2+ через NtQuerySystemInformation(SystemTokenInformation).
• Появилась после неудачного патча CVE-2024-43511: в RtlSidHashInitialize() ядро кладёт указатель на TOKEN→UserAndGroups в пользовательский буфер, и за короткий промежуток его можно считать.
• Уязвимость доступна из Low IL / AppContainer; при победе в гонке выдаёт надёжный KASLR bypass.
• Эксплойт: два потока – один циклично вызывает syscall, второй читает буфер; адрес токена утечёт почти всегда.
• Цепляется с write-what-where → LPE.

• KASLR на x86 считается «мертв» даже с KPTI: EntryBleed и prefetch-эксплойты работают на новых Intel/AMD.
• Утечка через SystemTokenInformation (Win11 24H2) даёт адрес ядра, но раньше KASLR и так легко обходился.
• Баг оказался в NtQueryInformationToken, а не в новом enum; статья уже исправлена.
• Патч KB5063878 (август 2024) закрыл уязвимость; совпадение с «фиаско Phison SSD» – случайность.
• Эксплойт полезен как звено в цепочке, но KASLR всё равно воспринимается лишь «speed bump».

• Увлечение — восстановление данных с кассет QIC-80 90-х гг.
• Драйвер ftape (Linux 2.4) последний раз собирался ~2000 г.; с тех пор приходится держать CentOS 3.5.
• Привод подключается к контроллеру гибкого диска: дёшево, но 500 Кбит/с и куча «магии» портов/IRQ.
• Под DOS/Windows есть проприетарные утилиты, но только ftape даёт «сырой» дамп, независимо от формата ПО, которое писало кассету.

Цель: переписать драйвер под современное ядро без боли.
Инструмент — Claude Code (Claude 3.5 Sonnet) в режиме «актов» (акт = автоматический цикл «предложи-отладь-протестируй»).

Ход работы

1. Запустил claude в каталоге исходников ftape-4.04 (1999 г.).
2. Первый акт: «сделай модуль для ядра 6.10». Claude выдал:
   • заменил cli/sti на spinlock_t;
   • sleep_on → wait_event;
   • register_blkdev → blk_mq;
   • kmalloc → kmalloc_array;
   • добавил MODULE_LICENSE/AUTHOR/DESCRIPTION.
     Собралось с десятком предупреждений.
3. Акт 2: «убери варнинги». Убрал устаревшие ioctl, обернул printk в pr_*, добавил fallthrough;.
4. Акт 3: «проверь на x86_64». Исправил long ↔ int в структурах, выровнял u8/u16 через __packed.
5. Акт 4: «протестируй на железе». Создал QEMU-образ с контроллером FDC, подключил образ кассеты.
   • первый insmod — kernel oops; Claude добавил BUG_ON(!request_region) и проверку IRQ.
   • второй — ftape видит привод, но «unknown format»; Claude вставил распознавание QIC-80 по ID_CRC.
   • третий — успешный дамп 120 Мб за 40 мин.
6. Акт 5: «очисти и оформи». Удалил весь #ifdef LINUX_2_0, добавил README.md, Kconfig, Makefile для in-tree сборки.

Результат

• 2 500 строк C → 1 100; 45 файлов → 12; минус 4 архаичных под-драйвера.
• Собирается как out-of-tree (6.6–6.12) и как in-tree (патч 30 Кб).
• Скорость 470 Кбит/с — предел FDC, но стабильно.
• Поддержаны только QIC-80; QIC-40/3010/3020 выкинуты (никто не просил).

Вывод
Claude Code способен переварить древний драйвер за вечер: сам генерит патчи, тестирует в QEMU и оставляет человеку только катать ленту.

• Claude Code и другие LLM-инструменты превращаются в «силовой множитель» для разработчиков: ускоряют работу в знакомых фреймворках и позволяют быстро осваивать новые.
• Главное — самому понимать, что делаешь: чёткие промты, ключевые слова предметной области и умение сверять результат критически снижают количество багов.
• Примеры успеха: порт драйвера ftape с Linux 2.4 на 6.8, апгрейд Pydantic V1→V2, inline-ASM под Apple, модернизация 15-летнего PHP-кода — всё за часы вместо недель.
• Самые ценные фичи: долгие процессы в терминале, автоматическая проверка своего кода, быстрое написание тестов и бенчмарков «на заказ».
• Безопасность: при работе с sudo-операциями или ядром итерации лучше вести вручную, чтобы LLM не сломала систему.

CVE-2024-50264: кратко о сложнейшей гонке в AF_VSOCK
Уязвимость введена в 2016 г. (ядро 4.8); это race между connect() AF_VSOCK и POSIX-сигналом, приводящий к UAF 80-байтового объекта virtio_vsock_sock. Триггер доступен обычному пользователю без user-ns. Ограничения: объект быстро освобождается, UAF-запись делает kworker, система легко падает. За это баг получил Pwnie 2025 «Best Privilege Escalation».

Управление сигналом без самоубийства процесса
Вместо SIGKILL, который убивает эксплойт, используется «бессмертный» сигнал 33:

sev.sigev_signo = 33;
timer_create(CLOCK_MONOTONIC, &sev, &race_timer);
timer_settime(...);  // точный момент прерывания connect()

Сигнал 33 зарезервирован NPTL, процесс его не видит и не завершается.

kernel-hack-drill: тренажёр для ядерных атак
Проект https://github.com/a13xp0p0v/kernel-hack-drill автоматизирует:

• сборку нужных версий ядра Ubuntu 24.04 (6.11 OEM/HWE) с разными конфигурациями KASLR/KCFI/SLAB_QUARANTINE;
• запуск в KVM с заданным RAM/CPU и ssh-форвардингом;
• однокнопочный запуск PoC и сбор crash-дампов.

Инструмент позволил быстро перебирать стратегии перераспределения kmalloc-96, искать объекты-спрей, тестировать разные техники обхода защит и отлаживать эксплойт без ручной пересборки ядра.

Новый путь эксплуатации
Автор отказался от сложной цепочки @v4bel и @qwerty и применил упрощённую схему:

1. Спрей sendmsg()-controlled объектами размером 96 байт, чтобы перехватить освобождённый virtio_vsock_sock.
2. UAF-запись переписывает поле sk_prot, указывая на поддельную структуру proto в userspace-буфере.
3. При последующем вызове close() ядро переходит по контролируемому указателю и исполняет ROP-цепочку, поднимая shell до root.

kernel-hack-drill сократил время от идеи до рабочего PoC с недель до нескольких часов.

• Участники в восторге от глубокого и единоличного описания use-after-free, но признают, что текст местами труден для чтения из-за «роботизированной» подачи.
• Многие чувствуют себя «бесполезными» на таком низком уровне и восхищаются талантом исследователей уязвимостей.
• Поднимается вопрос о мотивации: исследователи редко чинят баги, потому что это требует других навыков и ломает их инсентивы.
• Обсуждается, поможет ли Rust в ядре Linux: write-after-free технически блокируется, но unsafe-области всё ещё оставляют риски.

32-битные системы устарели, но ядро всё ещё их поддерживает из-за старого «железа» и ПО.
Arnd Bergmann: новые продукты уже 20 лет выходят на 64-битных платформах; встраиваемые устройства постепенно переходят с armv7 (32-бит) на armv8 (64-бит).

• Arm: 90 % встраиваемых систем; лишь три старые архитектуры до-armv7 ещё можно купить, но ядро держит десяток выведенных из производства. Поддержку можно выбрасывать «по половинам», когда исчезнут пользователи.
• Другие 32-битные архитектуры (arc, microblaze, nios2, openrisc, rv32, sparc/leon, xtensa) вытесняются RISC-V.
• nommu (armv7-m, m68k, superh, xtensa) никто не выпускает, их держат лишь ради существующих систем.

Для несовместимых 32-битных приложений — запуск 32-битного userspace на 64-битном ядре: экономит память, не требует 32-битного ядра.

Боль разработчиков:

• Высокая память (highmem) усложняет mm-подсистему; нужна, когда физической памяти > ~800 МБ.
• Ядро пока держит 32-битные машины до 16 ГБ, но таких почти нет; 4 ГБ встречаются (Chromebook), 2 ГБ — чаще, но «глупо»: память дороже CPU.

• Участники обеспокоены удалением поддержки nommu/32-бит: это уменьшает свободу, лишает возможности запускать Linux на старом или простом железе и делает ядро похожим на «дорожную карту» Apple/Windows.
• Некоторые предлагают форк «Linux Legacy» или переход на NetBSD/OpenBSD, которые по-прежнему поддерживают старые архитектуры.
• Для встраиваемых устройств без MMU считают более подходящими Zephyr, NuttX или Contiki, а не полноценный Linux.
• Поддержка big-endian почти мертва, но сохранится, пока IBM вкладывается в s390x.
• Старые ядра и LTS-дистрибутивы ещё десятилетие обеспечат безопасность и работу выброшенного железа.

Почему античиты не работают в Linux

Доля геймеров на Linux растёт благодаря Steam Deck и надоедливым «фичам» Windows. Однако почти все сетевые хиты с античитом не запускаются или не подключаются к серверам: PUBG, Call of Duty, Rust, R6 Siege, EA FC 24, Destiny 2, Valorant, League of Legends и даже FACEIT/ESEA для CS2.

Как работают читы и античиты

Чит либо внешний процесс, читающий/писующий память игры, либо внедрённая DLL. ОС не даёт процессам трогать чужую память благодаря виртуальному адресному пространству: каждая программа «думает», что владеет всей ОЗУ, а процессор и ядро переводят виртуальные адреса в реальные.

Античиты борются с этим двумя путями:

1. Пользовательский режим – сканируют память, читают файлы, ловят подозрительные потоки. Легко обойти, если у чита есть root-доступ.
2. Ядро (kernel) – драйвер внутри ядра Windows имеет полный доступ к железу и памяти, может скрывать свои структуры и блокировать вмешательство. Vanguard, EAC, BattlEye и пр. работают именно так.

Почему это невозможно в Linux

• Linux — открытая система. Любой может собрать своё ядро, поставить патч, изменить ABI.
• Античиту нужен стабильный, неизменяемый и закрытый интерфейс ядра. В Linux этого нет: модуль, собранный под 6.9, не загрузится под 6.10, а пользователь может вообще отключить модульные загрузки.
• Даже если разработчик выпустит проприетарный модуль, сообщество его не примет: безопасность, GPL-лицензия, репутационные риски.
• Попытки «запечатать» Linux (secure boot + immutable образ) противоречат свободе системы и всё равно не гарантируют, что пользователь не пересоберёт ядро без проверок.

Что можно сделать

1. Играть в поддерживаемые игры: Apex, Fortnite, CS2, Elden Ring и др. уже работают через Proton.
2. Двойная загрузка или VFIO-виртуалка – запуск Windows в виртуальной машине с проброской GPU (сложно, но работает).
3. Облачный гейминг – GeForce NOW, Xbox Cloud и т.д.
4. Ждать – пока разработчики не придумают античит, который не требует закрытого ядра (маловероятно).

Вывод: пока Linux остаётся открытой системой, современные kernel-level античиты там жить не смогут.

• Критики считают, что анти-чит на уровне ядра — это по сути rootkit, который подрывает безопасность и конфиденциальность.
• Многие предлагают альтернативы: доверительные сообщества, выделенные игровые машины, серверные проверки или облачные платформы.
• Подчеркивается, что Linux по дизайну даёт пользователю полный контроль, что делает невозможным эффективный, но инвазивный анти-чит.
• Некоторые игроки готовы пожертвовать безопасностью ради «честной» игры, но большинство участников обсуждения считают такой обмен неприемлемым.

AnduinOS — лёгкий, приватный, бесплатный дистрибутив на базе Ubuntu.
ISO 2 ГБ, GNOME-оболочка, Flatpak-приложения, никакого слежения.
Совместим с пакетами Ubuntu, подходит для работы, игр, сервера и обучения.

Версии

• LTS 1.1 (Noble Numbat) — до апреля 2029, GNOME 46, ядро 6.11, стабильность.
• Standard 1.3 (Plucky Puffin) — до января 2026, GNOME 48, ядро 6.14, новейшие функции.

Ссылки

• Скачать | Документация | Исходники | Поддержать

«Переход с Windows прошёл безболезненно, система лёгкая и красивая» — пользователи.

• Многие спутали название «AnduinOS» с «ArduinoOS».
• Это одиночный проект китайского инженера Microsoft: ремикс Ubuntu с GNOME, стилизованным под Windows 11.
• Критика: «distro-дистро-дистро» не заслуживает звания OS, не ясен уникальный посыл по сравнению с Mint/Ubuntu.
• Плюсы: простая установка Flatpak, может помочь консервативным пользователям перейти с Windows.
• Минусы: нет ARM-сборки, в скриншотах замечен сомнительный WPS Office, отсутствует описание отличий от Ubuntu.

Это вторая часть серии о разработке Tyr — современного GPU‑драйвера на Rust для ядра Linux с поддержкой Arm Mali на CSF.

Разберем, как работают GPU‑драйверы, на примере VkCube — простого приложения на Vulkan, рисующего вращающийся куб. Простота сцены помогает понять путь данных и команд от приложения к GPU.

UMD и KMD

• UMD (usermode) реализует API вроде Vulkan/OpenGL/OpenCL и преобразует команды приложений в низкоуровневые команды для GPU. В нашем случае это panvk из Mesa.
• KMD (kernel mode) соединяет UMD с железом: инициализирует устройство, управляет памятью, очередями, планированием и уведомлениями. В нашем случае это Tyr, нацеленный попасть в основное дерево Linux.

Что делает UMD

• Подготавливает данные: геометрию, текстуры, машинный код шейдеров, матрицы трансформаций.
• Просит KMD разместить их в памяти GPU, создает VkCommandBuffer с командами отрисовки, настраивает состояние конвейера, указывает, куда писать результат, и как получать сигнал о завершении.

Про шейдеры

• Это полноценные программы на GPU. Для VkCube им нужны хотя бы геометрия, цвета и матрица вращения, чтобы расположить и раскрасить куб и крутить его.

Что делает KMD

• Выделяет и отображает память, изолируя процессы в отдельных контекстах/VM.
• Принимает работу от UMD, ставит в аппаратные очереди, отслеживает зависимости и завершение.
• Планирует выполнение на массово параллельном, асинхронном железе, соблюдая порядок и справедливое распределение ресурса между клиентами.
• Инициализирует устройство: тактирование, питание, стартовые процедуры; обеспечивает совместный и честный доступ приложений к GPU.

Ключевой вывод

• Основная сложность — в UMD, который переводит высокоуровневые API в команды GPU. Но KMD обязан предоставить надежные примитивы: память, очереди, синхронизацию, планирование и разделение ресурсов, чтобы UMD было реально реализовать.

Интерфейс драйвера

• На основе этих задач KMD экспонирует минимальный набор операций: запрос сведений об устройстве, создание/уничтожение VM, привязка/отвязка памяти к VM, получение состояния VM, отправка работ в очереди и механизмы уведомлений — тот же API, что у C‑драйвера Panthor для того же железа.

• Обсуждение статьи о драйвере GPU: часть читателей хвалит материал, но считает его слишком коротким и ждёт продолжения/второй части.
• Уточняют, что речь идёт о драйвере panthor для Mali CSF (на RK3588), а не panfrost; один из комментаторов отмечал баги в Firefox на RK3588, ему ответили про соответствующий драйвер.
• Спор о фокусе: одни подчёркивают важность того, что это один из первых GPU-драйверов Linux на Rust; другие критикуют кликбейт заголовок и считают, что нужно акцентировать Mali CSF, а не Rust.
• Техническая дискуссия: вопрос о целесообразности uring_cmd вместо ioctl; ответы поясняют, что из-за природы асинхронных очередей GPU дополнительная CPU-очередь мало что даст, а интерфейс драйвера следует ожиданиям Mesa.
• Отмечают, что текущая часть охватывает в основном границу пользователь/ядро и управление очередями/буферами; «основное действие» — выполнение команд GPU — ожидается в следующих частях.
• Дополнительно подчёркивают сложность современных GPU-драйверов и их объём в ядре Linux, что оправдывает выбранные подходы и терминологию.