mirror of
https://github.com/intel/linux-sgx
synced 2026-06-08 14:49:32 +00:00
Guilhem Niot
123 lines
4.8 KiB
C++
123 lines
4.8 KiB
C++
/*
|
|
* Copyright (C) 2011-2020 Intel Corporation. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* * Neither the name of Intel Corporation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
|
|
// Enclave2.cpp : Defines the exported functions for the DLL application
|
|
#include "sgx_eid.h"
|
|
#include "EnclaveResponder_t.h"
|
|
#include "EnclaveMessageExchange.h"
|
|
#include "error_codes.h"
|
|
#include "Utility_E2.h"
|
|
#include "sgx_dh.h"
|
|
#include "sgx_utils.h"
|
|
#include <map>
|
|
|
|
#define UNUSED(val) (void)(val)
|
|
|
|
std::map<sgx_enclave_id_t, dh_session_t>g_src_session_info_map;
|
|
|
|
// this is expected initiator's MRSIGNER for demonstration purpose
|
|
sgx_measurement_t g_initiator_mrsigner = {
|
|
{
|
|
0xc3, 0x04, 0x46, 0xb4, 0xbe, 0x9b, 0xaf, 0x0f, 0x69, 0x72, 0x84, 0x23, 0xea, 0x61, 0x3e, 0xf8,
|
|
0x1a, 0x63, 0xe7, 0x2a, 0xcf, 0x74, 0x39, 0xfa, 0x05, 0x49, 0x00, 0x1f, 0xd5, 0x48, 0x28, 0x35
|
|
}
|
|
};
|
|
|
|
/* Function Description:
|
|
* this is to verify peer enclave's identity
|
|
* For demonstration purpose, we verify below points:
|
|
* 1. peer enclave's MRSIGNER is as expected
|
|
* 2. peer enclave's PROD_ID is as expected
|
|
* 3. peer enclave's attribute is reasonable that it should be INITIALIZED and without DEBUG attribute (except the project is built with DEBUG option)
|
|
* */
|
|
extern "C" uint32_t verify_peer_enclave_trust(sgx_dh_session_enclave_identity_t* peer_enclave_identity)
|
|
{
|
|
if(!peer_enclave_identity)
|
|
return INVALID_PARAMETER_ERROR;
|
|
|
|
// check peer enclave's MRSIGNER
|
|
if (memcmp((uint8_t *)&peer_enclave_identity->mr_signer, (uint8_t*)&g_initiator_mrsigner, sizeof(sgx_measurement_t)))
|
|
return ENCLAVE_TRUST_ERROR;
|
|
|
|
if(peer_enclave_identity->isv_prod_id != 0 || !(peer_enclave_identity->attributes.flags & SGX_FLAGS_INITTED))
|
|
return ENCLAVE_TRUST_ERROR;
|
|
|
|
// check the enclave isn't loaded in enclave debug mode, except that the project is built for debug purpose
|
|
#if defined(NDEBUG)
|
|
if (peer_enclave_identity->attributes.flags & SGX_FLAGS_DEBUG)
|
|
return ENCLAVE_TRUST_ERROR;
|
|
#endif
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
/* Function Description: Operates on the input secret and generates the output secret */
|
|
uint32_t get_message_exchange_response(uint32_t inp_secret_data)
|
|
{
|
|
uint32_t secret_response;
|
|
|
|
//User should use more complex encryption method to protect their secret, below is just a simple example
|
|
secret_response = inp_secret_data & 0x11111111;
|
|
|
|
return secret_response;
|
|
|
|
}
|
|
|
|
/* Function Description: Generates the response from the request message
|
|
* Parameter Description:
|
|
* [input] decrtyped_data: pointer to decrypted data
|
|
* [output] resp_buffer: pointer to response message, which is allocated in this function
|
|
* [output] resp_length: this is response length */
|
|
extern "C" uint32_t message_exchange_response_generator(char* decrypted_data,
|
|
char** resp_buffer,
|
|
size_t* resp_length)
|
|
{
|
|
ms_in_msg_exchange_t *ms;
|
|
uint32_t inp_secret_data;
|
|
uint32_t out_secret_data;
|
|
|
|
if(!decrypted_data || !resp_length)
|
|
return INVALID_PARAMETER_ERROR;
|
|
|
|
ms = (ms_in_msg_exchange_t *)decrypted_data;
|
|
|
|
if(umarshal_message_exchange_request(&inp_secret_data,ms) != SUCCESS)
|
|
return ATTESTATION_ERROR;
|
|
|
|
out_secret_data = get_message_exchange_response(inp_secret_data);
|
|
|
|
if(marshal_message_exchange_response(resp_buffer, resp_length, out_secret_data) != SUCCESS)
|
|
return MALLOC_ERROR;
|
|
|
|
return SUCCESS;
|
|
}
|