host.h

Go to the documentation of this file.

// Copyright (c) Open Enclave SDK contributors.
// Licensed under the MIT License.

#ifndef _OE_HOST_H
#define _OE_HOST_H

#ifdef _OE_ENCLAVE_H
#error "enclave.h and host.h must not be included in the same compilation unit."
#endif

#include <openenclave/bits/asym_keys.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "bits/defs.h"
#include "bits/eeid.h"
#include "bits/evidence.h"
#include "bits/result.h"
#include "bits/types.h"
#include "host_verify.h"

OE_EXTERNC_BEGIN

#ifndef _WIN32
#define _getpid getpid
#define sscanf_s sscanf
#define sprintf_s(buffer, size, format, argument) \
    sprintf(buffer, format, argument)
#define strcat_s(destination, destination_size, source) \
    strcat(destination, source)
#define strcpy_s(destination, destination_size, source) \
    ;                                                   \
    {                                                   \
        (void)(destination_size);                       \
        strcpy(destination, source);                    \
    }
#define _strdup strdup
#define strncat_s(destination, destination_size, source, source_size) \
    strncat(destination, source, source_size)
#endif

#define OE_ENCLAVE_FLAG_DEBUG 0x00000001u

#define OE_ENCLAVE_FLAG_SIMULATE 0x00000002u

#define OE_ENCLAVE_FLAG_RESERVED \
    (~(OE_ENCLAVE_FLAG_DEBUG | OE_ENCLAVE_FLAG_SIMULATE))

typedef void (*oe_ocall_func_t)(
    const uint8_t* input_buffer,
    size_t input_buffer_size,
    uint8_t* output_buffer,
    size_t output_buffer_size,
    size_t* output_bytes_written);

typedef enum _oe_enclave_setting_type
{
    OE_ENCLAVE_SETTING_CONTEXT_SWITCHLESS = 0xdc73a628,
#ifdef OE_WITH_EXPERIMENTAL_EEID
    OE_EXTENDED_ENCLAVE_INITIALIZATION_DATA = 0x976a8f66,
#endif
} oe_enclave_setting_type_t;

typedef struct _oe_enclave_setting_context_switchless
{
    size_t max_host_workers;
    size_t max_enclave_workers;
} oe_enclave_setting_context_switchless_t;

typedef struct _oe_enclave_setting
{
    oe_enclave_setting_type_t setting_type;
    union {
        const oe_enclave_setting_context_switchless_t*
            context_switchless_setting;
#ifdef OE_WITH_EXPERIMENTAL_EEID
        oe_eeid_t* eeid;
#endif
        /* Add new setting types here. */
    } u;
} oe_enclave_setting_t;

oe_result_t oe_create_enclave(
    const char* path,
    oe_enclave_type_t type,
    uint32_t flags,
    const oe_enclave_setting_t* settings,
    uint32_t setting_count,
    const oe_ocall_func_t* ocall_table,
    uint32_t ocall_count,
    oe_enclave_t** enclave);

oe_result_t oe_terminate_enclave(oe_enclave_t* enclave);

#if (OE_API_VERSION < 2)
#error "Only OE_API_VERSION of 2 is supported"
#else
#define oe_get_report oe_get_report_v2
#endif

oe_result_t oe_get_report_v2(
    oe_enclave_t* enclave,
    uint32_t flags,
    const void* opt_params,
    size_t opt_params_size,
    uint8_t** report_buffer,
    size_t* report_buffer_size);

void oe_free_report(uint8_t* report_buffer);

#if (OE_API_VERSION < 2)
#error "Only OE_API_VERSION of 2 is supported"
#else
#define oe_get_target_info oe_get_target_info_v2
#endif

oe_result_t oe_get_target_info_v2(
    const uint8_t* report,
    size_t report_size,
    void** target_info_buffer,
    size_t* target_info_size);

void oe_free_target_info(void* target_info_buffer);

oe_result_t oe_parse_report(
    const uint8_t* report,
    size_t report_size,
    oe_report_t* parsed_report);

oe_result_t oe_verify_report(
    oe_enclave_t* enclave,
    const uint8_t* report,
    size_t report_size,
    oe_report_t* parsed_report);

oe_result_t oe_get_public_key_by_policy(
    oe_enclave_t* enclave,
    oe_seal_policy_t seal_policy,
    const oe_asymmetric_key_params_t* key_params,
    uint8_t** key_buffer,
    size_t* key_buffer_size,
    uint8_t** key_info,
    size_t* key_info_size);

oe_result_t oe_get_public_key(
    oe_enclave_t* enclave,
    const oe_asymmetric_key_params_t* key_params,
    const uint8_t* key_info,
    size_t key_info_size,
    uint8_t** key_buffer,
    size_t* key_buffer_size);

void oe_free_key(
    uint8_t* key_buffer,
    size_t key_buffer_size,
    uint8_t* key_info,
    size_t key_info_size);

OE_EXTERNC_END

#endif /* _OE_HOST_H */