ストレージ・プロテクト・キー

ストレージ・プロテクト・キーは、ユーザー・プログラムの信頼性を向上させるメカニズムを提供します。

プロテクト・キーは、メモリー・ページに適用され、細分度のページ・レベルで動作します。これは、1 つ以上のページを読み取りまたは書き込み保護するために使用できる mprotect サブルーチンに似ています。 ただし、ストレージ・キーを使用すると、データのセクションを特定のレベルの読み取りおよび書き込みアクセスの保護に指定することができます。 ストレージ・キーによる保護は、データ・ページだけではなく、スレッド試行のアクセスの機能でもあります。 大規模プログラムでは使用できないデータにアクセスするために特定のコード・パスを使用可能にすることができます。これにより、重要なプログラム・データがカプセル化され、不測の障害から保護することができます。

キーで保護されたページへのアクセスは実行スレッドの属性であるため、このメカニズムはマルチスレッド・アプリケーションまで拡張されますが、1:1 (またはシステム有効範囲) pthreads のみ使用するという制限があります。 mprotect サブルーチン・アプローチは、マルチスレッド環境では確実に機能しません。これは、任意のスレッドへのアクセスを認可したい場合に、すべてのスレッドの保護を除去する必要があるためです。 2 つのメカニズムは同時に使用でき、両方とも完全に実行されるため、プロテクト・キーにより別の方法で許可されていたとしても、ユーザーのプログラムは書き込み保護されたページに書き込むことはできません。

キーによる保護を考慮してアプリケーションを設計することで、デバッグを単純化することができます。 ページのプロテクト・キーの設定とアクティブ・ユーザー・キーセットの設定は両方ともシステム・コールであるため、比較的消費が多い操作です。 プログラムを設計する際は、これらの操作の頻度が過多にならないようにしてください。

ユーザー・プロテクト・キー

ユーザー・プログラムがキーで保護されたデータに、そのアクティブ・ユーザー・キーセットで示されたアクセス権限に違反してアクセスした場合、読み取りまたは書き込み保護されたページに違反した場合のように、プログラムは 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))

/*
 * 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);
}