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)
#define fopen_s(pfp, name, mode) *(pfp) = fopen((name), (mode))
#endif
 
#define OE_ENCLAVE_FLAG_DEBUG 0x00000001u
 
#define OE_ENCLAVE_FLAG_SIMULATE 0x00000002u
 
#define OE_ENCLAVE_FLAG_SGX_KSS 0x00000004u
 
#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_SGX_ENCLAVE_CONFIG_DATA = 0x78b5b41d
} 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_sgx_enclave_setting_config_data
{
    uint8_t config_id[64];
    uint16_t config_svn;
    bool ignore_if_unsupported;
} oe_sgx_enclave_setting_config_data;
 
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
        const oe_sgx_enclave_setting_config_data* config_data;
        /* Add new setting types here. */
    } u;
} oe_enclave_setting_t;
 
typedef struct _oe_ecall_info_t
{
    const char* name;
} oe_ecall_info_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,
    const oe_ecall_info_t* ecall_name_table,
    uint32_t ecall_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 */