Ключи защиты памяти

Ключи защиты памяти обеспечивают механизм повышения надежности программ.

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

Поскольку доступ к защищенным ключами страницам является атрибутом выполняемой нити, этот механизм естественным образом распространяется на приложения с несколькими нитями, но с ограничением на использование этими приложениями только нитей pthread 1:1 (или области системы). Подход, реализуемый командой mprotect, не обеспечивает надежную работу в среде с несколькими нитями, поскольку приходится удалять защиту для всех нитей, если необходимо предоставить доступ для какой-либо одной нити. Можно одновременно использовать оба механизма; в этом случае, программа не может выполнить запись в защищенную от записи страницу даже если ключ защиты разрешает запись.

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

Пользовательские ключи защиты

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

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

Области, защищенные пользовательскими ключами

Системные предварительные требования для защиты ключами

Предварительные требования к программе для защиты ключами

Функции

Отладка

Сведения об аппаратном обеспечении

Пример программы

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

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <sys/ukeys.h>
#include <sys/syspest.h>
#include <sys/signal.h> 
#include <sys/vminfo.h>

#define ROUND_UP(size,psize)    ((size)+(psize)-1 & ~((psize)-1))

/*
 * Это пример каркаса программы, поддерживающей пользовательские ключи.
 *
 * Структура private_data_1 отображает защищенную ключом область памяти,
 * к которой основная программа имеет свободный доступ, а "незащищенная"
 * команда имеет только права на чтение.
 */
struct private_data_1 {
        int some_data;
};
struct private_data_1 *p1;      /* указатель на структуру защищенных данных */

ukeyset_t keyset1RW;            /* набор ключей для предоставления доступа обработчику сигнала */

/*
 * Незащищенная функция должна успешно прочитать защищенные данные.
 *
 * Если значение счетчика равно 0, оно просто возвращается, так что инициатор может записать
 * увеличенное на единицу значение обратно в защищенное поле.
 *
 * Если значение счетчика равно 1, он пытается самостоятельно обновить защищенное поле.
 * Результатом должно являться SIGSEGV.
 */
int untrusted(struct private_data_1 *p1) {
        int count = p1->some_data;      /* Можно прочитать защищенные данные */
        if (count == 1)
                p1->some_data = count;  /* Однако запись запрещена */
        return count + 1;
}

/*
 * Обработчик сигнала обнаруживает умышленное нарушение защиты в
 * незащищенной функции выше при значении count == 1.
 * Обратите внимание, что обработчик вводится БЕЗ прав доступа к частным данным.
 */
void handler(int signo, siginfo_t *sip, void *ucp) {
        printf("siginfo: signo %d code %d\n", sip->si_signo, sip->si_code);
        (void)ukeyset_activate(keyset1RW, UKA_REPLACE_KEYS);
        exit(1);
}

main() {
        int nkeys;
        int pagesize = 4096;            /* аппаратный размер страницы данных */
        int padded_protsize_1;          /* размер страницы защищенных данных */
        struct vm_page_info page_info;

        ukey_t key1 = UKEY_PRIVATE1;
        ukeyset_t keyset1W, oldset;
        int rc;
        int count = 0;

        struct sigaction sa;

        /*
         * Попытка узнать о пользовательском ключе.
         */
        nkeys = ukey_enable();
        if (nkeys == -1) {
                perror("ukey_enable");
                exit(1);
        }
        assert(nkeys >= 2);

        /*
         * Определяется размер страницы области данных.
         */
        page_info.addr = (long)&p1;             /* адрес в области данных */
        rc = vmgetinfo(&page_info, VM_PAGE_INFO, sizeof(struct vm_page_info));

        if (rc)
                perror("vmgetinfo");
        else
                pagesize = page_info.pagesize;  /* получаем фактический размер страницы */

        /*
         * Необходимо выделить соответствующий странице объем памяти
         * для области, которую необходимо защитить ключом.
         */
        padded_protsize_1 = ROUND_UP(sizeof(struct private_data_1), pagesize);
        rc = posix_memalign((void **)&p1, pagesize, padded_protsize_1);
        if (rc) {
                perror("posix_memalign");
                exit(1);
        }

        /*
         * Инициализация частных данных.
         * Это можно сделать до установки защиты.
         *
         * Обратите внимание, что указатель на частные данные находится в общей памяти.
         * Мы защищаем только сами данные.
         */
        p1->some_data = count;

        /*
         * Создание наборов ключей для применения для доступа к защищенной структуре.
         * Обратите внимание, что эти наборы ключей будут размещены в общей памяти.
         */
        rc = ukeyset_init(&keyset1W, 0);
        if (rc) {
                perror("ukeyset_init");
                exit(1);
        }

        rc = ukeyset_add_key(&keyset1W, key1, UK_WRITE);        /* WRITE */
        if (rc) {
                perror("ukeyset_add_key 1W");
                exit(1);
        }

        keyset1RW = keyset1W;
        rc = ukeyset_add_key(&keyset1RW, key1, UK_READ);        /* R/W */
        if (rc) {
                perror("ukeyset_add_key 1R");
                exit(1);
        }

        /*
         * Доступ к частным данным запрещен с помощью применения частного ключа
         * к содержащей их странице (страницам).
         */
        rc = ukey_protect(p1, padded_protsize_1, key1);
        if (rc) {
                perror("ukey_protect");
                exit(1);
        }

        /*
         * Разрешить всему основному коду ссылаться на чтение/запись защищенных данных.
         */
        oldset = ukeyset_activate(keyset1RW, UKA_ADD_KEYS);
        if (oldset == UKSET_INVALID) {
                printf("ukeyset_activate failed\n");
                exit(1);
        }

        /*
         * Задается обработчик сигнала для SIGSEGV, для обнаружения преднамеренного
         * нарушения ключа в незащищенном коде.
         */
        sa.sa_sigaction = handler;
        SIGINITSET(sa.sa_mask);
        sa.sa_flags = SA_SIGINFO;
        rc = sigaction(SIGSEGV, &sa, 0);
        if (rc) {
                perror("sigaction");
                exit(1);
        }

        /*
         * Основной цикл выполнения программы.
         */
        while (count < 2) {
                /*
                 * Когда необходимо выполнить "незащищенный" код, изменяем права доступа
                 * к частным данным на R/O, удалив права на запись.
                 */
                (void)ukeyset_activate(keyset1W, UKA_REMOVE_KEYS);

                /*
                 * Вызов незащищенной команды.  Она может только читать
                 * переданные ей защищенные данные.
                 */
                count = untrusted(p1);

                /*
                 * Восстанавливается полный доступ к частным данным.
                 */
                (void)ukeyset_activate(keyset1W, UKA_ADD_KEYS);

                p1->some_data = count;
        }
ukey_protect(p1, padded_protsize_1, UKEY_PUBLIC);
        free(p1);
        exit(0);
}