Просмотр исходного текста страницы Защита памяти и ядра в ОС ROSA

{{Примечание|Статья в процессе написания. Переносится из написанного ранее [http://wiki.rosalab.ru/ru/images/b/b3/Securing_Memory_and_Kernel.pdf документа PDF].}}<br />

== Защита памяти и ядра в ОС ROSA. Свод требований == 

Здесь приведены рекомендации по настройке ядра и опций защиты памяти. Критически важно защищать ядро и системную память. Если допустить, что ядро или память скомпрометированы, то нет никаких гарантий в правильной работе любых механизмов безопасности и системы в целом.

Сводная информация с рекомендуемыми настройками для ядра ОС и проекция к Методическому документу ФСТЭК «Рекомендации по обеспечению безопасной настройки операционных систем Linux» от 25 декабря 2022 г. — приведена в таблице ниже:

{| class="wikitable"
|-
! № п/п !! Параметр и рекомендуемое значение !! Интерфейс !! См. [https://fstec.ru/dokumenty/vse-dokumenty/spetsialnye-normativnye-dokumenty/metodicheskij-dokument-ot-25-dekabrya-2022-g документ ФСТЭК] !! См. раздел !! Значение по умолчанию
|-
| 1 || <code>kernel.dmesg_restrict=1</code> || <code>/etc/sysctl.conf</code> || 2.4.1|| [http://wiki.rosalab.ru/ru/index.php/%D0%97%D0%B0%D1%89%D0%B8%D1%82%D0%B0_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8_%D0%B8_%D1%8F%D0%B4%D1%80%D0%B0_%D0%B2_%D0%9E%D0%A1_ROSA#.D0.9E.D0.B3.D1.80.D0.B0.D0.BD.D0.B8.D1.87.D0.B5.D0.BD.D0.B8.D1.8F_.D0.BD.D0.B0_.D0.BF.D1.80.D0.BE.D1.81.D0.BC.D0.BE.D1.82.D1.80_.D1.81.D0.BE.D0.BE.D0.B1.D1.89.D0.B5.D0.BD.D0.B8.D0.B9_.D1.8F.D0.B4.D1.80.D0.B0 См.] || <code>0</code>
|-
| 2 || <code>kernel.kptr_restrict=2</code> || <code>/etc/sysctl.conf</code> || 2.4.2 || Текст ячейки || <code>0</code>
|-
| 3 || <code>init_on_alloc=1</code> || <code>/etc/default/grub</code> || 2.4.3 || Текст ячейки || Неактивно
|-
| 4 || <code>slab_nomerge</code> || <code>/etc/default/grub</code> || 2.4.4 || Текст ячейки || Неактивно
|-
| 5 || <code>iommu=force</code> <br /> <code>iommu.strict=1</code> <br /> <code>iommu.passthrough=0</code> || <code>/etc/default/grub</code> || 2.4.5 || Текст ячейки || Неактивно
|-
| 6 || <code>randomize_kstack_offset=1</code> || <code>/etc/default/grub</code> || 2.4.6 || Текст ячейки ||
|-
| 7 || <code>mitigations=auto,nosmt</code> || <code>/etc/default/grub</code> || 2.4.7 || Текст ячейки || Неактивно
|-
| 8 || <code>net.core.bpf_jit_harden=2</code> || <code>/etc/sysctl.conf</code> || 2.4.8 || Текст ячейки || <code>0</code>
|-
| 9 || <code>vsyscall=none</code> || <code>/etc/default/grub</code> || 2.5.1 || Текст ячейки || Неактивно
|-
| 10 || <code>kernel.perf_event_paranoid=3</code> || <code>/etc/sysctl.conf</code> || 2.5.2 || Нет || <code>2</code>
|-
| 11 || <code>debugfs=no-mount</code> || <code>/etc/default/grub</code> || 2.5.3 || Текст ячейки || Неактивно
|-
| 12 || <code>kernel.kexec_load_disabled=1</code> || <code>/etc/sysctl.conf</code> || 2.5.4 || Текст ячейки || <code>0</code>
|-
| 13 || <code>user.max_user_namespaces=0</code> || <code>/etc/sysctl.conf</code> || 2.5.5 || Текст ячейки || <code>509894</code>
|-
| 14 || <code>kernel.unprivileged_bpf_disabled=1</code> || <code>/etc/sysctl.conf</code> || 2.5.6 || Текст ячейки || <code>2</code>
|-
| 15 || <code>vm.unprivileged_userfaultfd=0</code> || <code>/etc/sysctl.conf</code> || 2.5.7 || Текст ячейки || <code>1</code>
|-
| 16 || <code>dev.tty.ldisc_autoload=0</code> || <code>/etc/sysctl.conf</code> || 2.5.8 || Текст ячейки || <code>1</code>
|-
| 17 || <code>tsx=off</code> || <code>/etc/default/grub</code> || 2.5.9 || Текст ячейки || Неактивно
|-
| 18 || <code>vm.mmap_min_addr=4096</code> || <code>/etc/sysctl.conf</code> || 2.5.10 || Текст ячейки || <code>65536</code>
|-
| 19 || <code>kernel.randomize_va_space=2</code> || <code>/etc/sysctl.conf</code> || 2.5.11 || Текст ячейки || <code>2</code>
|-
| 20 || <code>kernel.yama.ptrace_scope=3</code> || <code>/etc/sysctl.conf</code> || 2.6.1 || Текст ячейки || <code>1</code>
|}

== Защита памяти и ядра ОС ==

'''В чем опасность?'''

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

'''Что можно сделать для повышения безопасности?'''

Можно активизировать собственные механизмы защиты ядра ОС, направленные на противодействие атакам разного рода, такие как: защита памяти, защита от переполнения буфера, контроль целостности ядра и загружаемых драйверов, ограничить отладку и т. п. Информация о механизмах защиты ядра с пояснениями приведена далее.

Ядро является основным и наиболее критическим компонентом любого дистрибутива операционной системы Linux, в том числе и с точки зрения выполнения функций безопасности. Большинство их сосредоточено именно в ядре, либо так или иначе выполняется при посредничестве ядра ОС.

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

Кроме того, поскольку ядро еще и отслеживает все другие компоненты ОС. Важно, чтобы выполнялось только то ядро, которое является доверенным. Иначе может произойти раскрытие информации, и данные пользователей, а также пароли или ключи шифрования, могут быть скомпрометированы. Кроме того, если не защищать ядро ОС, то нарушитель может попытаться изменить состав модулей (драйверов) ядра. Это может привести к самым непредсказуемым последствиям. Под угрозой окажутся любые обрабатываемые данные и функции безопасности. Так можно преодолеть защиту, отключив важную подсистему ядра ОС Linux, например механизм аудита, функции разграничения доступа (SELinux), выключить защиту памяти или фильтр пакетов. Любым возможностям несанкционированного взаимодействия с ядром необходимо препятствовать.

Подробная информация об известных техниках эксплуатации уязвимостей в ядре ОС Linux приведена по ссылке: https://github.com/xairy/linux-kernel-exploitation

=== Защита от просмотра адресов указателей ===

Переменная ядра ОС, отвечающая за доступ к интерфейсам ядра <code>/proc/kallsyms</code> и <code>/proc/modules</code> — это <code>kernel.kptr_restrict</code>. Просматривая эти файлы, можно получать значения адресации памяти для указателей ядра. То есть можно, например, узнать, на какой адрес в памяти ссылается указатель той или иной программы, или загруженного модуля ядра. Переменная может принимать значения <code>0</code>, <code>1</code> и <code>2</code>. Более подробное описание рисков, связанных с атакой на адреса указателей и прототип эксплойта, демонстрирующий такую возможность, приведены по ссылке:
 
https://kernsec.org/wiki/index.php/Bug_Classes/Kernel_pointer_leak

Если для переменной <code>kernel.kptr_restrict</code> определено значение <code>0</code>, то просматривать значения адресов в памяти может любой пользователь ОС. Если задано значение <code>1</code>, то просматривать адресацию функций может только <code>root</code>. Если значение равно <code>2</code>, то никто не получит информацию об адресации. Рекомендуемое значение — два. При значении единица — отображение адресов заменяется на нули для всех пользователей, кроме <code>root</code>. При значении два — отображение адресов заменяется на нули для всех пользователей, включая <code>root</code>.

Для проверки текущего значения этой переменной выполнить:

<code># sysctl -a | grep kptr</code>
<code>kernel.kptr_restrict = 2</code>

Если значение отличается, то выполнить установку этой переменной:

<code># sysctl -w kernel.kptr_restrict=2</code>

<code># echo 'kernel.kptr_restrict = 2' >> /etc/sysctl.conf</code>

=== Отключение трассировки процессов ===

На первом этапе нужно проверить, есть ли в выполняющемся ядре LSM модуль YAMA. Для этого можно выполнить поиск нужной опции в конфигурационном файле ядра, например:

<code>$ cat /boot/config-5.10.118-generic-2rosa2021.1-x86_64 | grep YAMA</code>

<code>CONFIG_SECURITY_YAMA=y</code>

Если есть, то в ОС может использоваться настройка, позволяющая производить ограничения на трассировку процессов. Если нет (выдано значение <code>CONFIG_SECURITY_YAMA is not set</code>), то можно пропустить эту настройку.

Для проверки текущих значений трассировки выполнить (от имени администратора <code>root</code>):

<code># sysctl -a | grep ptrace</code>

<code>kernel.yama.ptrace_scope = 2</code>

Рекомендуется установить запрет трассировки, используя значение <code>2</code> для переменной <code>kernel.yama.ptrace_scope</code>, или более строгое. Значение <code>2</code> определяет, что трассировку процессов может осуществлять только <code>root</code>. Значение \commandbox{3} полностью отключает трассировку, для всех пользователей, в том числе и для <code>root</code>. В описанной ниже конфигурации трассировка разрешается только пользователю <code>root</code>:

<code># sysctl -w kernel.yama.ptrace_scope=2</code>

<code># echo 'kernel.yama.ptrace_scope = 2' >> /etc/sysctl.conf</code>

=== Ограничения на просмотр сообщений ядра ===

Команда <code>dmesg</code> является очень популярной в ОС Linux. Она выводит на экран сообщения ядра ОС. По умолчанию эту команду может использовать любой пользователь в системе, следовательно её может применять злоумышленник, чтобы получить информацию о системе и некоторых её характеристиках. Соответственно, любой пользователь ОС сможет или напрямую обратиться к этому файлу (<code>$ cat /dev/kmsg</code>), или использовать программы чтения кольцевого буфера аудита ядра, такие как <code>dmesg</code> или <code>rsyslog</code>. Рекомендуется ограничивать пользователей в возможности получать сообщения кольцевого буфера аудита ядра, чтобы снизить вероятность получения информации о работающей системе или ее параметрах.

Переменная ядра ОС <code>kernel.dmesg_restrict</code> отвечает за доступ к интерфейсу кольцевого буфера аудита ядра (файлу <code>/dev/kmsg</code>). По умолчанию доступ пользователей к этому интерфейсу не запрещен. Значение <code>1</code> предписывает, что обращаться к нему может только <code>root</code>. Если установлено значение <code>0</code>, то доступ пользователей к буферу аудита ядра не ограничивается.

Проверить текущее значение политики доступа к интерфейсу кольцевого буфера аудита ядра можно так:

<code># sysctl -a | grep dmesg</code>

<code>kernel.dmesg_restrict = 1</code>

Если при проверке значение отличается от единицы, то нужно выполнить настройку запрета чтения из этого интерфейса всем, кроме <code>root</code>:

# sysctl -w kernel.dmesg_restrict=1

# echo 'kernel.dmesg_restrict = 1' >> /etc/sysctl.conf

=== Противодействие уязвимостям типа Meltdown и Spectre ===

Использование уязвимостей типа Meltdown или Spectre заключается в возможности несанкционированного выполнения кода в пространстве ядра. Например, возникающих при спекулятивном выполнении инструкций процессора (уязвимости типа Meltdown), и/или связанных с особенностями функционирования модуля прогнозирования ветвлений (уязвимости типа Spectre). Эти уязвимости были обнаружены в 2017 году, но все еще продолжают появляться различные их варианты.

Современные процессоры семейства x86 (производства компаний Intel и AMD) предоставляют возможность параллельного использования нескольких «нитей» или «потоков» на каждом процессорном ядре. Такая возможность называется SMT (Symmetric Multi-Threading, симметричная многопоточность). Поскольку «нити» или «потоки» (исходя из конструктивных особенностей ЦП) сохраняют возможности обмена информацией между собой, то это потенциально может привести к несанкционированному обмену информацией между процессами, выполняющимися в разных потоках, но на одном ядре ЦП. Либо может привести к нежелательному раскрытию информации в памяти и т. п. Поэтому в защищаемой системе опции процессора, отвечающие за SMT желательно отключить. При этом настоятельно рекомендуется использовать комплексный подход — отключать поддержку SMT как на уровне системы ввода-вывода, так и на уровне операционной системы. Данный подход обеспечивает бОльшую уверенность в том, что уязвимости, связанные с недостатками SMT не будут проэксплуатированы, например в том случае, если производитель оборудования предоставит ошибочное обновление системы ввода-вывода, повторно включающее SMT после отключения.
	
Уязвимости типа Meltdown и Spectre могут привести к реализации атак, при которых злоумышленник сможет получить доступ к защищенной памяти из программы, не обладающей соответствующими привилегиями (путём анализа данных, записываемых в кэш процессора).

Одним из наиболее эффективных способов противостояния атакам семейств Meltdown и Spectre является отключение SMT (помимо обновлений инструкций самих процессоров и разнообразных патчей к ядру Linux и компиляторам). Для этого ядро ОС Linux имеет нужные параметры, которые позволяют отключить SMT.

С другой стороны, минусом этого решения является снижение производительности. Отключение SMT (любым способом, программным или аппаратным), приведет к тому, что количество виртуальных процессорных ядер (vCPU) уменьшится кратно числу потоков в каждом ядре ЦП (то есть, не менее, чем вдвое). Наличие большого количества ядер vCPU особенно важно при необходимости использовать виртуальные машины.
	
Но если без SMT все же можно обойтись — то лучше отключить эту функциональность. Желательно планировать покупку оборудования с учетом того, что SMT будет отключаться.
	
Для проверки того, используется ли технология SMT, требуется от имени любого пользователя выполнить следующую команду:

<code>$ cat /sys/devices/system/cpu/smt/active</code>

<code>0</code>

Где <code>0</code> свидетельствует об отсутствии поддержки.
	
Иначе, если вывод <code>1</code>, то рекомендуется отключить поддержку SMT, сначала в BIOS/UEFI, если это поддерживается оборудованием. А затем выключить её и в ядре операционной системы.
	
Для отключения поддержки SMT в ОС, требуется от имени <code>root</code> выполнить изменение строки <code>GRUB_CMDLINE_LINUX_DEFAULT</code> конфигурационного файла <code>/etc/default/grub</code>, дописав в ее конец следующие директивы:

<code>GRUB_CMDLINE_LINUX_DEFAULT='splash smem=1 mitigations=auto,nosmt'</code>

После чего нужно обновить конфигурацию загрузчика (<code># update-grub</code>) и перезагрузить ОС.

=== Отключение технологии Intel TSX ===

Технология Intel TSX применялась в процессорах Intel до 8-го поколения. Эта технология была направлена на увеличение производительности вычислений, путем попыток предсказания и слияния данных в памяти процессора. Ядро ОС Linux по умолчанию поддерживает эту технологию. Однако эта технология небезопасная, устаревшая. Даже сама компания Intel её больше не использует, и не рекомендует. Поддержку TSX рекомендуется отключить, если ваш процессор Intel поколения 8 или ниже.

Для отключения поддержки TSX в ОС, требуется от имени <code>root</code> выполнить изменение строки <code>GRUB_CMDLINE_LINUX_DEFAULT</code>} конфигурационного файла <code>/etc/default/grub</code>, дописав в ее конец следующую директиву:

<code>GRUB_CMDLINE_LINUX_DEFAULT='splash smem=1 tsx=off'</code>

После чего нужно обновить конфигурацию загрузчика (<code># update-grub</code>) и перезагрузить ОС.

=== Защита от переполнения буфера ===

Обычно в стеке памяти программы содержится критически важный для безопасности данных адрес, который может привести к выполнению произвольного кода. Им является сохраненный адрес возврата, то есть адрес памяти, по которому выполнение должно продолжиться после завершения выполнения некоей текущей функции. Злоумышленник может перезаписать это значение нужным ему адресом памяти, к которому у него также есть доступ на запись, и в который он помещает свой код. Этот код будет запускаться с полными привилегиями уязвимой программы. Например, он может подставить адрес нужного ему вызова, скажем, POSIX <code>system()</code>, оставив аргументы вызова в стеке. Это часто называют эксплойтом возврата в ''libc'', поскольку злоумышленник обычно заставляет программу во время возврата перейти к интересующей его процедуре в стандартной библиотеке C ''libc''). Другие важные данные, обычно находящиеся в стеке, включают указатели стека и кадра — два значения, которые указывают смещения для вычисления адресов памяти. Изменение этих значений также может использовать злоумышленник для организации деструктивных воздействий на программу. Чтобы этому противостоять рекомендуется использовать все доступные способы защиты от переполнения буфера.

Защиту от переполнения буфера важно использовать как на уровне «железа», так и на уровне операционной системы. Это важно потому, что исполняемые файлы в системе, могут быть скомпилированы без использования техник защиты от переполнения буфера (например, опции компилятора GCC типа <code>fstack-protector</code> не задействовались). Либо некоторые процессоры (особенно старые или дешёвые) могут не иметь соответствующих аппаратных возможностей.

==== Аппаратная защита от переполнения буфера и ее проверка ====

Современные процессоры семейства x86 (производства компаний Intel и AMD) предоставляют возможность запрета выполнения кода в некоторых страницах памяти. У процессоров такая возможность активизируется включением специального бита, который у AMD называется No Execute Bit (NX bit), а у Intel — Execute Disable Bit (XD bit). Включение таких битов процессора — это способ минимизации негативных последствий, вызванных переполнением буфера.
	
Для проверки того, задействованы ли в BIOS или UEFI функции аппаратной защиты от переполнения буфера, требуется выполнить:

<code># journalctl | grep "protection: active"</code>

<code>kernel: NX (Execute Disable) protection: active</code>

В том случае, если вывод отличается от приведенного выше, то требуется включить соответствующие опции в BIOS/UEFI (если такая возможность предоставлена изготовителем оборудования) и перепроверить.

==== Программная защита от переполнения буфера («канарейка») ====

Техника программной защиты от переполнения буфера на жаргоне программистов называется «канарейка» (''canary''). Такое название употребляется по аналогии с канарейками, которые использовались шахтерами в угольных шахтах до появления газоанализаторов. Задача «канарейки» -- умереть прежде шахтера. То есть, в данном случае -- прервать выполнение программы до того, как будет осуществлено какое-то деструктивное воздействие. Для этого небольшое целое число (значение которого случайно выбирается при запуске программы) записывается в память непосредственно перед указателем возврата адреса в стеке, и все дальнейшие обращения к нему отслеживаются. 
	
Это хорошо автоматизируемая техника, и она может быть выполнена не программистом, а прямо компилятором во время сборки исходного кода. Естественно, такая концепция защиты немного влияет на производительность программы. Но влияние это не слишком значительное, и лучше немного пренебречь производительностью во имя защиты. Однако эта защита пока никак не настраивается  прямо в операционной системе. Она, как уже было сказано, осуществляется на этапе сборки прямо в сборочной среде с помощью специальных опций компилятора GCC типа <code>fstack-protector</code>.
	
Проиллюстрировать поведение этой опции можно на следующем примере. Можно подготовить простую программу на языке Си, откомпилировать с нужной опцией <code>fstack-protector</code> и запустить. Так можно убедиться в том, что при сборке программы с такой опцией отслеживается переполнение стека (вследствие контроля к областям оперативной памяти системным вызовом \<code>mprotect()</code>) и выполнение программы прерывается.
	
Пример такой проверочной программы на языке Си указан ниже:

<code>#include <stdio.h></code>

<code>#include <stdlib.h></code>

<code>#include <string.h></code>

<code>struct no_chars {</code>

	<code>unsigned int len;</code>

	<code>unsigned int data;</code>

<code>};</code>

<code>int main(int argc, char * argv[])</code>

<code>{</code>

	<code>struct no_chars info = { };</code>

	<code>if (argc < 3) {</code>

		<code>fprintf(stderr, "Usage: %s LENGTH DATA...\n", argv[0]);</code>

		<code>return 1;</code>

	<code>}</code>

	<code>info.len = atoi(argv[1]);</code>

	<code>memcpy(&info.data, argv[2], info.len);</code>

	<code>return 0;</code>

<code>}</code>

Если эту программу сохранить под именем, например, <code>program1.c</code>, затем откомпилировать с опцией защиты от переполнения буфера и запустить, то можно убедиться в том, что в результате срабатывания защиты, программа прерывается:

<code>$ gcc -O0 -fstack-protector-strong -o ./program1 ./program1.c</code>

<code>$ ./program1 64 AAA</code>

<code>*** stack smashing detected ***: terminated</code>

<code>Aborted</code>

<code>$ echo $?</code>

<code>134</code>

Как видно, программа получила шестой сигнал (128 + 6 = 134) <code>SIGABRT</code>. Для получения списка сигналов можно выполнить <code>$ kill -l</code> или прочесть справку <code>signal(7)</code>.

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

Например, можно посмотреть опции сборки, указанные в метаданных RPM пакета с программой. Допустим, требуется проверить опции сборки для программы <code>/bin/ls</code>. Для этого нужно сделать запрос к менеджеру пакетов <code>rpm</code>, например:

<code># rpm -q --queryformat="%{NAME}: %{OPTFLAGS}\n" binutils</code>

В ответ система сообщит опции сборки, например для пакета <code>binutils</code> (куда входит программа <code>/bin/ls</code>):

<code>binutils: -O2 -fomit-frame-pointer -gdwarf-4 -Wstrict-aliasing=2 -pipe -Wformat</code>

<code>-Werror=format-security -D_FORTIFY_SOURCE=2 -fPIC -fstack-protector-strong</code>

<code>--param=ssp-buffer-size=4 -m64 -mtune=generic -fstack-protector-strong</code>

Как видно из вывода запроса <code>rpm</code>, он содержит нужную для защиты от переполнения буфера опцию <code>-fstack-protector-strong</code>. Некоторым неудобством этого подхода является то, что нужно знать или уметь выяснять, к какому именно пакету относится та, или иная программа. А если нужно проверить несколько программ в одном каталоге, но которые могут принадлежать разным пакетам, задача проверки может стать совсем мучительной без познаний в программировании на языке оболочки.
	
Кроме этого способа существует анализатор опций сборки, который представлен в виде сценария <code>checksec</code>, доступный по ссылке: https://github.com/slimm609/checksec.sh

Этот сценарий проверяет содержимое бинарных файлов и библиотек в соответствующих метаданных ELF формата, и выводит опции сборки. Например, можно посмотреть на его вывод для проверки того же бинарного файла <code>/bin/ls</code>:

<code>$ checksec --output=csv --file=/bin/ls</code>

<code>Partial RELRO,Canary found,NX enabled,PIE enabled,No RPATH,No RUNPATH,No Symbols,Yes,5,17,/bin/ls</code>

Как видно из вывода, для программы найдено применение техники защиты от переполнения буфера, т.н. «канарейка»: <code>Canary found</code>.
	
Есть мнение, что применение этого сценария значительно удобнее, чем получение данных из RPM пакета, так как и результат нагляднее, и проверять можно сразу все файлы в каталоге, и выводить результаты можно еще и в форматах CSV или XML. В любом случае, каждый сам для себя может решить, какой способ проверки защиты от переполнения буфера удобнее использовать.
	
Естественно, что и само ядро ОС тоже компилируется с опциями защиты от переполнения буфера.

=== Защита от выполнения произвольного кода в ядре ===

Современное ядро Linux содержит фильтр eBPF, который когда то был перенесен из ОС семейства BSD, где выполнял функции фильтра пакетов. А сейчас фильтр eBPF в Linux является механизмом ядра, предоставляющим возможности трассировки и профилирования как самого ядра, так и пользовательских приложений. 

Фильтр eBPF имеет встроенный JIT компилятор, и уже давно не является простым фильтром пакетов. Теперь это очень мощная структура в ядре Linux, которая позволяет из непривилегированного пользовательского пространства выполнять произвольный код в ядре, чтобы динамически расширять функциональность ядра. Имеющийся в eBPF JIT компилятор по существу является нарушением принципа «W xor X», поскольку ядро не проверяет код, выполняемый JIT компилятором eBPF.

Несмотря на широчайшие функциональные возможности eBPF, его основным минусом с точки зрения безопасности является то, что этот механизм фактически работает как «песочница» или «виртуальная машина» в пространстве ядра, позволяющая исполнять произвольный код внутри ядра, используя для этого интерфейс из пользовательского пространства. И этот исполняемый код еще и не проверяется на соответствие принципу «W xor X».

Реализация eBPF в ядре Linux пока далека от идеальной. Только за три года (с 2020 по 2022 гг) было  зафиксировано более десятка уязвимостей  в механизме eBPF, большинство из которых имело высокий рейтинг: 

https://nvd.nist.gov/vuln/search/results?form_type=Basic&results_type=overview&query=eBPF&search_type=all&isCpeNameSearch=false

Иногда в сети попадаются эксплойты, демонстрирующие возможности эксплуатации недостатков в eBPF:

https://haxx.in/files/blasty-vs-ebpf.c

Исходя из того, что указано выше, использовать eBPF в защищенной системе не рекомендуется. Ограничить использование eBPF довольно просто. Для проверки того, отключены ли механизмы eBPF, и его JIT компилятор, выполнить:

<code># sysctl -a | grep unprivileged_bpf_disabled</code>

<code>kernel.unprivileged_bpf_disabled = 1</code>

<code># sysctl -a | grep net.core.bpf_jit_harden</code>

<code>net.core.bpf_jit_harden = 2</code>

Переменная <code>kernel.unprivileged_bpf_disabled</code> принимает значения <code>0</code> и <code>1</code>. Значение <code>0</code> разрешает любым пользователям взаимодействие с eBPF. Значение <code>1</code> запрещает пользователям (кроме <code>root</code>) взаимодействовать с eBPF.   

Переменная <code>net.core.bpf_jit_harden</code> принимает значения <code>0</code>, <code>1</code> и <code>2</code>. Значение <code>0</code> не активизирует защиту JIT компилятора eBPF. Значение <code>1</code> не позволяет пользователям (кроме <code>root</code>) использовать JIT компилятор. Значение <code>2</code> не разрешает никому, включая <code>root</code>, использовать JIT компилятор eBPF. Рекомендуется для переменной <code>net.core.bpf_jit_harden</code> устанавливать значение <code>2</code>.

Такие настройки призваны полностью противодействовать атакам типа JIT spraying для eBPF. Подробнее о семействе атак JIT spraying можно узнать по ссылкам:

http://www.ruscrypto.org/resource/archive/rc2010/files/10_sintsov.pdf

https://www.youtube.com/watch?v=LVGw6JFPjhc

http://www.semantiscope.com/research/BHDC2010/BHDC-2010-Paper.pdf

Для установки рекомендуемых значений защиты eBPF выполнить:

<code># sysctl -w 'kernel.unprivileged_bpf_disabled=1'</code>

<code>kernel.unprivileged_bpf_disabled = 1</code>

<code># echo 'kernel.unprivileged_bpf_disabled = 1' >> /etc/sysctl.conf</code>

<code># sysctl -w 'net.core.bpf_jit_harden=2'</code>

<code>net.core.bpf_jit_harden = 2</code>

<code># echo 'net.core.bpf_jit_harden = 2' >> /etc/sysctl.conf</code>

=== Ограничение дисциплины линии ===

Исторически ядро Linux автоматически загружает любой подходящий драйвер подключаемой к системе дисциплины  линии (https://en.wikipedia.org/wiki/Line_discipline). Например, если к серверу в COM-порт подключить COM терминал, то его драйвер будет загружен при подключении. Такое поведение не может гарантировать безопасность. Более того, ранее уже отмечались уязвимости в драйверах дисциплины линии:

https://a13xp0p0v.github.io/2017/03/24/CVE-2017-2636.html

Рекомендуется ограничить автоматические возможности ядра по подключению драйверов дисциплины линии там, где это не требуется. Для установки ограничения используется специальная переменная ядра <code>dev.tty.ldisc_autoload</code>. Эта переменная может принимать значения <code>0</code> и <code>1</code>. Значение <code>1</code> воспрещает автоматическую загрузку драйвера дисциплины линии. Значение <code>1</code> (по умолчанию) -- наоборот, разрешает.

Для проверки текущего значения этой переменной нужно выполнить:

<code># sysctl -a | grep ldisc</code>

<code>dev.tty.ldisc_autoload = 0</code>

Если значение не равно нулю, то установить переменную в безопасное значение:

<code># sysctl -w 'dev.tty.ldisc_autoload=0'</code>

<code># echo 'dev.tty.ldisc_autoload = 0' >> /etc/sysctl.conf</code>

=== Защита алгоритма оптимизации памяти ===

Алгоритм оптимизации памяти (т.н. «slab allocator») в ядре ОС базируется на принципе дефрагментации участков памяти в ядре (кэш страниц, данные, представленные древовидными структурами -- «куча» (heap)), и направлен на повышение эффективности использования памяти (снижение задержек при работе с данными, и т.п.). Основным методом оптимизации является слияние кэшей или повторное использование одних и тех же данных для однотипных объектов. Ранее уже фиксировались уязвимости в этом механизме и использующие особенности алгоритма оптимизации памяти:

https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-42008

https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-0185

И даже были подготовлены эксплойты, демонстрирующие атаку на этот алгоритм, см. например:

https://syst3mfailure.io/sixpack-slab-out-of-bounds

https://www.openwall.com/lists/oss-security/2022/01/25/14

Рекомендуется противодействовать возможной активности нарушителя, направленной на организацию атак алгоритма оптимизации памяти в ядре ОС. Для этого предлагается использовать опцию загрузки ядра <code>slab_nomerge</code>, которая сообщает ядру о том, что слияние кэшей выполнять не нужно, и, таким образом, предотвращается возможность повторного получения данных.

Для отключения слияния кэшей нужно внести изменение в файл <code>/etc/default/grub</code>, добавив в строку параметров загрузки ядра следующее:

<code>GRUB_CMDLINE_LINUX_DEFAULT='splash smem=1 slab_nomerge'</code>

После чего обновить конфигурацию загрузчика (<code># update-grub</code>) и перезагрузить ОС.

=== Принудительная очистка страниц виртуальной памяти и рандомизация их выделения ===

Ядро ОС Linux имеет возможность осуществлять очистку памяти. Причем можно указать, в какое время она выполняется -- либо перед выделением страницы она будет очищена, либо будет очищена после освобождения, но возможно задать и оба этих варианта. 

Это значительно усложняет возможности эксплуатации уязвимостей, основанных на раскрытии информации из страниц памяти, при повторном использовании информации из распределяемых или высвобождаемых страниц, поскольку содержимое этих информационных ресурсов будет обнулено. Подробнее о механизмах очистки памяти, и о потенциально возможных техниках эксплуатации уязвимостей, основанных на доступе к страницам памяти, можно прочесть по ссылке:

https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6471384af2a6530696fc0203bafe4de41a23c9ef

Для включения очистки страниц памяти при распределении страниц -- нужно внести изменение в файл <code>/etc/default/grub</code>, добавив в строку параметров загрузки ядра следующее:

<code>GRUB_CMDLINE_LINUX_DEFAULT='splash smem=1 init_on_alloc=1'</code>

Для включения очистки страниц памяти при высвобождении страниц -- нужно внести такое изменение в файл <code>/etc/default/grub</code>, добавив в строку параметров загрузки ядра следующее:
	
<code>GRUB_CMDLINE_LINUX_DEFAULT='splash smem=1 init_on_free=1'</code>

Для включения очистки страниц памяти при распределении и при высвобождении страниц -- нужно внести оба значения в файл <code>/etc/default/grub</code>, добавив в строку параметров загрузки ядра следующее:

<code>GRUB_CMDLINE_LINUX_DEFAULT='splash smem=1 init_on_alloc=1 init_on_free=1'</code>

Нужно понимать, что поскольку ядро ОС при указанных выше настройках будет обязано производить дополнительные операции по принудительной очистке страниц памяти, все операции со страницами виртуальной памяти будут выполняться дольше. Следовательно, это деградирует производительность при любой обработке данных в операционной системе в целом.

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

Подробнее о рандомизации распределения страниц кэш-памяти можно прочесть по ссылке:

https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e900a918b0984ec8f2eb150b8477a47b75d17692

Для включения динамической рандомизации распределения страниц кэш-памяти, нужно внести следующие изменения в файл \commandbox{/etc/default/grub}, добавив в строку параметров загрузки ядра:

<code>GRUB_CMDLINE_LINUX_DEFAULT='splash smem=1 page_alloc.shuffle=1'</code>

В ОС есть и другие эффективные способы противодействовать атакам на механизмы памяти ядра. Информация о них приведена в разделе, описывающем защиту от уязвимостей типа Meltdown и Spectre.



[[Категория:Безопасность]]