Claves de protección de almacenamiento

Las claves de protección de almacenamiento proporcionan un mecanismo para mejorar la fiabilidad de los programas.

Las claves de protección se aplican a las páginas de memoria y funcionan en el nivel de página de granularidad, similar a la subrutina mprotect , que se puede utilizar para proteger una o más páginas de lectura o escritura. Sin embargo, con las claves de almacenamiento puede marcar secciones de los datos para niveles específicos de protección de acceso de lectura y escritura. La protección mediante claves de almacenamiento es una función no sólo de la página de datos, sino también de la hebra que intenta acceder. Puede habilitar determinadas vías de acceso de código bien definidas para acceder a los datos que no están disponibles para el programa más grande, encapsulando así los datos críticos del programa y protegiéndolos contra daños accidentales.

Puesto que el acceso a las páginas protegidas por clave es un atributo de la hebra en ejecución, este mecanismo se amplía de forma natural a las aplicaciones multihebra, pero con la restricción de que estas utilicen solo pthreads 1: 1 (o ámbito del sistema). El enfoque de subrutina mprotect no funciona de forma fiable en un entorno multihebra, ya que debe eliminar la protección de todas las hebras cuando desee otorgar acceso a cualquier hebra. Puede utilizar ambos mecanismos simultáneamente, y ambos se aplican completamente; por lo tanto, el programa no puede escribir en una página protegida contra grabación aunque una clave de protección lo permita de otro modo.

Puede simplificar la depuración diseñando la aplicación teniendo en cuenta la protección de claves. El establecimiento de la clave de protección de una página y el establecimiento del conjunto de claves de usuario activo son llamadas al sistema y, por lo tanto, operaciones relativamente costosas. Debe diseñar el programa para que la frecuencia de estas operaciones no sea excesiva.

Claves de protección de usuario

Si su programa accede a datos protegidos por clave en violación de los derechos de acceso expresados en su conjunto de claves de usuario activo, recibe una señal SIGSEGV , como ya ocurre en el caso de violación de páginas protegidas contra lectura o grabación. Si elige manejar esta señal, tenga en cuenta que los manejadores de señal se invocan sin acceso a las claves privadas. El código de manejo de señales debe añadir los derechos de acceso necesarios al conjunto de claves de usuario activo antes de hacer referencia a los datos protegidos por clave.

Los procesos hijo, creados por la llamada al sistema fork , heredan lógicamente la memoria de su padre y el estado en ejecución. Esto incluye la clave de protección asociada con cada página, así como el conjunto de claves de usuario activo de la hebra padre en el momento de la bifurcación.

Regiones protegidas por claves de usuario

Requisitos previos del sistema para la protección de claves

Requisitos previos de programa para la protección de claves

Subrutinas

Depurar

Detalles de hardware

programa de ejemplo

A continuación se muestra un ejemplo de programa con reconocimiento de claves de usuario:

#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))

/*
 * This is an example skeleton for a user key aware program.
 *
 * The private_data_1 structure will map a malloc'd key protected area
 * which the main program can access freely, while the "untrusted"
 * subroutine will only have read access.
 */
struct private_data_1 {
        int some_data;
};
struct private_data_1 *p1;      /* pointer to structure for protected data */

ukeyset_t keyset1RW;            /* keyset to give signal handler access */

/*
 * The untrusted function here should successfully read protected data.
 *
 * When the count is 0, it will just return so the caller can write
 * the incremented value back to the protected field.
 *
 * When the count is 1, it will try to update the protected field itself.
 * This should result in a SIGSEGV.
 */
int untrusted(struct private_data_1 *p1) {
        int count = p1->some_data;      /* We can read protected data */
        if (count == 1)
                p1->some_data = count;  /* But should not be able to write it */
        return count + 1;
}

/*
 * Signal handler to catch the deliberate protection violation in the
 * untrusted function above when count == 1.
 * Note that the handler is entered with NO access to our private data.
 */
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;            /* hardware data page size */
        int padded_protsize_1;          /* page padded size of protected data */
        struct vm_page_info page_info;

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

        struct sigaction sa;

        /*
         * Attempt to become user key aware.
         */
        nkeys = ukey_enable();
        if (nkeys == -1) {
                perror("ukey_enable");
                exit(1);
        }
        assert(nkeys >= 2);

        /*
         * Determine the data region page size.
         */
        page_info.addr = (long)&p1;             /* address in data region */
        rc = vmgetinfo(&page_info, VM_PAGE_INFO, sizeof(struct vm_page_info));

        if (rc)
                perror("vmgetinfo");
        else
                pagesize = page_info.pagesize;  /* pick up actual page size */

        /*
         * We need to allocate page aligned, page padded storage
         * for any area that is going to be key protected.
         */
        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);
        }

        /*
         * Initialize the private data.
         * We can do this before protecting it if we want.
         *
         * Note that the pointer to the private data is in public storage.
         * We only protect the data itself.
         */
        p1->some_data = count;

        /*
         * Construct keysets to use to access the protected structure.
         * Note that these keysets will be in public storage.
         */
        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);
        }

        /*
         * Restrict access to the private data by applying a private key
         * to the page(s) containing it.
         */
        rc = ukey_protect(p1, padded_protsize_1, key1);
        if (rc) {
                perror("ukey_protect");
                exit(1);
        }

        /*
         * Allow our general code to reference the private data R/W.
         */
        oldset = ukeyset_activate(keyset1RW, UKA_ADD_KEYS);
        if (oldset == UKSET_INVALID) {
                printf("ukeyset_activate failed\n");
                exit(1);
        }

        /*
         * Set up a signal handler for SIGSEGV, to catch the deliberate
         * key violation in the untrusted code.
         */
        sa.sa_sigaction = handler;
        SIGINITSET(sa.sa_mask);
        sa.sa_flags = SA_SIGINFO;
        rc = sigaction(SIGSEGV, &sa, 0);
        if (rc) {
                perror("sigaction");
                exit(1);
        }

        /*
         * Program's main processing loop.
         */
        while (count < 2) {
                /*
                 * When we need to run "untrusted" code, change access
                 * to the private data to R/O by removing write access.
                 */
                (void)ukeyset_activate(keyset1W, UKA_REMOVE_KEYS);

                /*
                 * Call untrusted subroutine here.  It can only read
                 * the protected data passed to it.
                 */
                count = untrusted(p1);

                /*
                 * Restore our full access to private data.
                 */
                (void)ukeyset_activate(keyset1W, UKA_ADD_KEYS);

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