Browse Source

Initial working local attestation commit with the sdk library - version 2.1

dettanym 5 years ago
commit
812ae31801

+ 807 - 0
App/App.cpp

@@ -0,0 +1,807 @@
+/*
+ * Copyright (C) 2011-2017 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.challa
+ *
+ */
+
+#define SGX_DH_MAC_SIZE 16
+#define SGX_TARGET_INFO_RESERVED1_BYTES 4
+#define SGX_TARGET_INFO_RESERVED2_BYTES 456
+#define SGX_ECP256_KEY_SIZE 32
+#define SGX_CPUSVN_SIZE 16
+#define SGX_REPORT_DATA_SIZE 64
+#define SGX_MAC_SIZE 16 /* Message Authentication Code - 16 bytes */
+#define SGX_KEYID_SIZE 32
+#define SGX_HASH_SIZE 32 /* SHA256 */
+
+#define SGX_REPORT_BODY_RESERVED1 28
+#define SGX_REPORT_BODY_RESERVED2 32
+#define SGX_REPORT_BODY_RESERVED3 96
+#define SGX_REPORT_BODY_RESERVED4 60
+
+// App.cpp : Defines the entry point for the console application.
+#include <stdio.h>
+#include <map>
+#include "../Decryptor/Decryptor_u.h"
+#include "sgx_eid.h"
+#include "sgx_urts.h"
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+#include<unistd.h>
+// for sealing - sgx_calc_sealed_data_size
+#include "sgx_tseal.h"
+
+// For socket programming
+#include <sys/socket.h>
+#include <stdlib.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <errno.h>
+#include<unistd.h>
+
+// For reading from/writing to file -sealing.
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+// For google proto buffers
+#include "dhmsgs.pb.h"
+#include <inttypes.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+#include "SgxProtobufLATransforms_initiator.h"
+using namespace google::protobuf::io;
+
+
+
+//#define UNUSED(val) (void)(val)
+#define TCHAR   char
+#define _TCHAR  char
+#define _T(str) str
+#define scanf_s scanf
+
+// Not sure if I need this later - as such, I (decryptor app) will only ever need to talk to 1 enclave at a time - verifier enclave first and then the apache enclave.
+//extern std::map<sgx_enclave_id_t, uint32_t>g_enclave_id_map;
+
+sgx_enclave_id_t e2_enclave_id = 0;
+#define Decryptor_PATH "libDecryptor.so"
+////////////////////////////////////////////////// 
+
+
+
+
+// For google proto buffers
+#include "dhmsgs.pb.h"
+#include <inttypes.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+using namespace google::protobuf::io;
+#include <stdio.h>
+//#include "sgx_eid.h"
+//#include "sgx_urts.h"
+
+
+
+int fit_32_into_uint8_t(google::protobuf::uint32 temp32, uint8_t* temp8)
+{
+ if(temp32 > UINT8_MAX)
+	 return -1;
+ else
+ {
+	 //		 *temp8 = *(uint8_t*)&temp32; // Probably works irrespective of endianness but not sure.
+	 *temp8 = (uint8_t)temp32;
+	 return 0;
+ }
+}
+
+int fit_32_into_uint16_t(google::protobuf::uint32 temp32, uint16_t* temp16)
+{
+ if(temp32 > UINT16_MAX)
+	 return -1;
+ else
+ {
+	 //		 *temp8 = *(uint8_t*)&temp32; // Probably works irrespective of endianness but not sure.
+	 *temp16 = (uint16_t)temp32;
+	 return 0;
+ }
+}
+
+void encode_ec256_public_key_to_protobuf(protobuf_sgx_ec256_public_t* protobuf_g_a , sgx_ec256_public_t* g_a)
+{
+	int counter; google::protobuf::uint32 temp32;
+	for(counter=0;counter<SGX_ECP256_KEY_SIZE;counter++)
+	{
+		temp32 = g_a->gx[counter];
+		protobuf_g_a->add_gx(temp32);
+		temp32 = g_a->gy[counter];
+		protobuf_g_a->add_gy(temp32);
+	}
+}
+
+int decode_ec256_public_key_from_protobuf(protobuf_sgx_ec256_public_t* protobuf_g_a , sgx_ec256_public_t* g_a)
+{
+  printf("\n ec256 pub key\n");
+	int counter; google::protobuf::uint32 temp32;
+	for(counter=0;counter<SGX_ECP256_KEY_SIZE;counter++)
+	{
+		temp32 = protobuf_g_a->gx(counter);
+		if(fit_32_into_uint8_t(temp32, &(g_a->gx[counter]))!=0)
+		 return -1;
+    printf("%d ",g_a->gx[counter]);
+		temp32 = protobuf_g_a->gy(counter);
+		if(fit_32_into_uint8_t(temp32, &(g_a->gy[counter]))!=0)
+		 return -1;
+    printf("%d ",g_a->gy[counter]);
+	}
+  return 0;
+}
+
+void encode_attributes_to_protobuf(protobuf_sgx_attributes_t* protobuf_attributes, sgx_attributes_t* attributes)
+{
+	protobuf_attributes->set_flags(attributes->flags); // 64 bit
+	protobuf_attributes->set_xfrm(attributes->xfrm); // 64 bit
+}
+
+int decode_attributes_from_protobuf(protobuf_sgx_attributes_t* protobuf_attributes, sgx_attributes_t* attributes)
+{
+	attributes->flags = protobuf_attributes->flags();
+  printf("\n flags %" PRIu64 " \n", attributes->flags);
+	attributes->xfrm = protobuf_attributes->xfrm();
+  printf("\n xfrm %" PRIu64 " \n", attributes->xfrm);
+	return 0;
+}
+
+void encode_report_to_protobuf(protobuf_sgx_report_t* protobuf_report, sgx_report_t* report)
+{
+	int counter; google::protobuf::uint32 temp32;
+	for(counter=0;counter<SGX_KEYID_SIZE;counter++)
+	{
+		temp32=report->key_id.id[counter];
+		protobuf_report->add_key_id(temp32);
+	}
+
+	for(counter=0;counter<SGX_MAC_SIZE;counter++)
+	{
+		temp32=report->mac[counter];
+		protobuf_report->add_mac(temp32);
+	}
+
+	protobuf_report->mutable_body()->set_misc_select(report->body.misc_select); // 32 bit
+	protobuf_report->mutable_body()->set_isv_svn(report->body.isv_svn); // 16 bit
+	protobuf_report->mutable_body()->set_isv_prod_id(report->body.isv_prod_id); // 16 bit
+	encode_attributes_to_protobuf(protobuf_report->mutable_body()->mutable_attributes(), &(report->body.attributes));
+
+	for(counter=0;counter<SGX_CPUSVN_SIZE;counter++)
+	{
+		temp32=report->body.cpu_svn.svn[counter];
+		protobuf_report->mutable_body()->add_cpu_svn(temp32);
+	}
+
+	for(counter=0;counter<SGX_REPORT_BODY_RESERVED1;counter++)
+	{
+		temp32=report->body.reserved1[counter]; // TODO: Could be optimized out - if these are determined to be 0s.
+		protobuf_report->mutable_body()->add_reserved1(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_REPORT_BODY_RESERVED2;counter++)
+	{
+		temp32=report->body.reserved2[counter]; // TODO: Could be optimized out - if these are determined to be 0s.
+		protobuf_report->mutable_body()->add_reserved2(temp32);
+	}
+
+	for(counter=0;counter<SGX_REPORT_BODY_RESERVED3;counter++)
+	{
+		temp32=report->body.reserved3[counter]; // TODO: Could be optimized out - if these are determined to be 0s.
+		protobuf_report->mutable_body()->add_reserved3(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_REPORT_BODY_RESERVED4;counter++)
+	{
+		temp32=report->body.reserved4[counter]; // TODO: Could be optimized out - if these are determined to be 0s.
+		protobuf_report->mutable_body()->add_reserved4(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_HASH_SIZE;counter++)
+	{
+		temp32=report->body.mr_enclave.m[counter];
+		protobuf_report->mutable_body()->add_mr_enclave(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_HASH_SIZE;counter++)
+	{
+		temp32=report->body.mr_signer.m[counter];
+		protobuf_report->mutable_body()->add_mr_signer(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_REPORT_DATA_SIZE;counter++)
+	{
+		temp32=report->body.report_data.d[counter];
+		protobuf_report->mutable_body()->add_report_data(temp32);
+ 	}
+}
+
+int decode_report_from_protobuf(protobuf_sgx_report_t* protobuf_report, sgx_report_t* report)
+{
+  int counter; google::protobuf::uint32 temp32;
+
+  printf("\nreport body keyid\n");
+  for(counter=0;counter<SGX_KEYID_SIZE;counter++)
+  {
+    temp32=protobuf_report->key_id(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->key_id.id[counter]))!=0)
+		  return -1;
+    printf("%d ", report->key_id.id[counter]);
+  }
+
+  printf("\nreport mac\n");
+  for(counter=0;counter<SGX_MAC_SIZE;counter++)
+  {
+    temp32=protobuf_report->mac(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->mac[counter]))!=0)
+      return -1;
+    printf("%d ", report->mac[counter]);
+  }
+
+  report->body.misc_select=protobuf_report->mutable_body()->misc_select(); // 32 bit
+  temp32=protobuf_report->mutable_body()->isv_svn();
+  if(fit_32_into_uint16_t(temp32, &(report->body.isv_svn))!=0)
+   return -1;
+  printf("\nmisc select %d \n", report->body.misc_select);
+
+  temp32=protobuf_report->mutable_body()->isv_prod_id();
+   if(fit_32_into_uint16_t(temp32, &(report->body.isv_prod_id))!=0)
+    return -1;
+  printf("\nprod id %d \n", report->body.isv_prod_id);
+
+  decode_attributes_from_protobuf(protobuf_report->mutable_body()->mutable_attributes(), &(report->body.attributes));
+
+  printf("\n cpu svn\n");
+  for(counter=0;counter<SGX_CPUSVN_SIZE;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->cpu_svn(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.cpu_svn.svn[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.cpu_svn.svn[counter]);
+
+  }
+
+  printf("\n reserved1 \n");
+  for(counter=0;counter<SGX_REPORT_BODY_RESERVED1;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->reserved1(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.reserved1[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.reserved1[counter]);
+  }
+
+  printf("\n reserved2 \n");
+  for(counter=0;counter<SGX_REPORT_BODY_RESERVED2;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->reserved2(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.reserved2[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.reserved2[counter]);
+  }
+
+  printf("\n reserved3 \n");
+  for(counter=0;counter<SGX_REPORT_BODY_RESERVED3;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->reserved3(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.reserved3[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.reserved3[counter]);
+  }
+
+  printf("\n reserved4 \n");
+  for(counter=0;counter<SGX_REPORT_BODY_RESERVED4;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->reserved4(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.reserved4[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.reserved4[counter]);
+
+  }
+
+  printf("\n mrenclave \n");
+  for(counter=0;counter<SGX_HASH_SIZE;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->mr_enclave(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.mr_enclave.m[counter]))!=0)
+      return -1;
+    printf("%x ", report->body.mr_enclave.m[counter]);
+  }
+
+  printf("\n mrsigner \n");
+  for(counter=0;counter<SGX_HASH_SIZE;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->mr_signer(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.mr_signer.m[counter]))!=0)
+      return -1;
+    printf("%x ", report->body.mr_signer.m[counter]);
+  }
+
+  printf("\n report data\n");
+  for(counter=0;counter<SGX_REPORT_DATA_SIZE;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->report_data(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.report_data.d[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.report_data.d[counter]);
+  }
+	return 0;
+}
+
+void encode_msg1_to_protobuf( protobuf_sgx_dh_msg1_t& protobuf_dhmsg1, sgx_dh_msg1_t* native_dhmsg1)
+{
+   int counter; google::protobuf::uint32 temp32; // google::protobuf::uint64 temp64;
+
+   encode_ec256_public_key_to_protobuf(protobuf_dhmsg1.mutable_g_a(), &(native_dhmsg1->g_a));
+
+   for(counter=0;counter<SGX_HASH_SIZE;counter++)
+   {
+     temp32=native_dhmsg1->target.mr_enclave.m[counter];
+     protobuf_dhmsg1.mutable_target()->add_mr_enclave(temp32);
+   }
+
+   for(counter=0;counter<SGX_TARGET_INFO_RESERVED1_BYTES;counter++)
+   {
+     temp32=native_dhmsg1->target.reserved1[counter];
+     protobuf_dhmsg1.mutable_target()->add_reserved1(temp32);
+   }
+
+   for(counter=0;counter<SGX_TARGET_INFO_RESERVED2_BYTES;counter++)
+   {
+     temp32=native_dhmsg1->target.reserved2[counter];
+     protobuf_dhmsg1.mutable_target()->add_reserved2(temp32);
+   }
+
+   encode_attributes_to_protobuf(protobuf_dhmsg1.mutable_target()->mutable_attributes(), &(native_dhmsg1->target.attributes));
+
+   temp32=native_dhmsg1->target.misc_select ;
+   protobuf_dhmsg1.mutable_target()->set_misc_select(temp32);
+}
+
+void encode_msg3_to_protobuf(protobuf_sgx_dh_msg3_t& protobuf_dhmsg3, sgx_dh_msg3_t* native_dhmsg3)
+{
+  int counter; google::protobuf::uint32 temp32;
+  for(counter=0;counter<SGX_DH_MAC_SIZE;counter++)
+	{
+		temp32=native_dhmsg3->cmac[counter];
+		protobuf_dhmsg3.add_cmac(temp32);
+	}
+
+  encode_report_to_protobuf(protobuf_dhmsg3.mutable_msg3_body()->mutable_report(), &(native_dhmsg3->msg3_body.report));
+  int max_counter=native_dhmsg3->msg3_body.additional_prop_length;
+  unsigned char*temp;
+  for(counter=0,temp=native_dhmsg3->msg3_body.additional_prop;counter<max_counter;counter++,temp++)
+  {
+    protobuf_dhmsg3.mutable_msg3_body()->add_additional_prop(*temp);
+  }
+}
+
+int decode_msg2_from_protobuf(protobuf_sgx_dh_msg2_t& protobuf_dhmsg2, sgx_dh_msg2_t* native_dhmsg2)
+{
+  int counter; google::protobuf::uint32 temp32; //google::protobuf::uint64 temp64;
+  printf("\ncmac\n");
+  for(counter=0;counter<SGX_DH_MAC_SIZE;counter++)
+  {
+    temp32=protobuf_dhmsg2.cmac(counter);
+    if(fit_32_into_uint8_t(temp32, &(native_dhmsg2->cmac[counter]))!=0)
+     return -1;
+    printf("%d ",native_dhmsg2->cmac[counter]);
+  }
+
+  if(decode_ec256_public_key_from_protobuf(protobuf_dhmsg2.mutable_g_b(), &(native_dhmsg2->g_b)) !=0)
+	return -1;
+
+  if(decode_report_from_protobuf(protobuf_dhmsg2.mutable_report(), &(native_dhmsg2->report)) !=0)
+	return -1;
+
+  return 0;
+}
+
+int print_initialized_msg1( protobuf_sgx_dh_msg1_t& protobuf_dhmsg1, sgx_dh_msg1_t* native_dhmsg1)
+{
+   int counter;
+	 printf("gx\n");
+   for(counter=0;counter<SGX_ECP256_KEY_SIZE;counter++)
+   {
+      printf("%d ", protobuf_dhmsg1.g_a().gx(counter));
+      printf("%d ", native_dhmsg1->g_a.gx[counter]);
+   }
+   printf("\ngy\n");
+   for(counter=0;counter<SGX_ECP256_KEY_SIZE;counter++)
+   {
+      printf("%d ", protobuf_dhmsg1.g_a().gy(counter));
+      printf("%d ", native_dhmsg1->g_a.gy[counter]);
+   }
+
+   printf("\nmrenclave in target\n");
+   for(counter=0;counter<SGX_HASH_SIZE;counter++)
+   {
+      printf("%" PRIu32 " ", protobuf_dhmsg1.target().mr_enclave(counter));
+      printf("%d ", native_dhmsg1->target.mr_enclave.m[counter]);
+
+   }
+   printf("\nreserved1 in target\n");
+   for(counter=0;counter<SGX_TARGET_INFO_RESERVED1_BYTES;counter++)
+   {
+      printf("%" PRIu32 " ", protobuf_dhmsg1.target().reserved1(counter));
+      printf("%d ", native_dhmsg1->target.reserved1[counter]);
+
+   }
+   printf("\nreserved2 in target\n");
+   for(counter=0;counter<SGX_TARGET_INFO_RESERVED2_BYTES;counter++)
+   {
+      printf("%" PRIu32 " ", protobuf_dhmsg1.target().reserved2(counter));
+      printf("%d ", native_dhmsg1->target.reserved2[counter]);
+   }
+
+   printf("\n %" PRIu64 "\n", native_dhmsg1->target.attributes.flags);
+   printf("\n %" PRIu64 "\n", protobuf_dhmsg1.target().attributes().flags());
+   printf("\n %" PRIu64 "\n", native_dhmsg1->target.attributes.xfrm);
+   printf("\n %" PRIu64 "\n", protobuf_dhmsg1.target().attributes().xfrm());
+   printf("\n %" PRIu32 "\n", native_dhmsg1->target.misc_select);
+   printf("\n %" PRIu32 "\n", protobuf_dhmsg1.target().misc_select());
+
+	return 0;
+}
+
+int read_protobuf_msg_from_fd(int accept_fd, google::protobuf::MessageLite& message)
+{
+  ZeroCopyInputStream* raw_input;
+  CodedInputStream* coded_input;
+  uint32_t size;
+  CodedInputStream::Limit limit;
+  raw_input = new FileInputStream(accept_fd);
+  coded_input = new CodedInputStream(raw_input);
+  if(!coded_input->ReadVarint32(&size))
+  {
+    printf("Error in reading size of msg");
+    fflush(stdout);
+    return -1;
+  }
+  //printf("size of msg was read to be %" PRIu32 " \n", size);
+  fflush(stdout);
+  limit = coded_input->PushLimit(size);
+  if(!message.ParseFromCodedStream(coded_input))
+  {
+    printf("Error in parsing msg");
+    fflush(stdout);
+    return -1;
+  }
+  coded_input->PopLimit(limit);
+  return 0;
+}
+
+int write_protobuf_msg_to_fd(int accept_fd, google::protobuf::MessageLite& message)
+{
+  ZeroCopyOutputStream* raw_output = new FileOutputStream(accept_fd);
+  CodedOutputStream* coded_output  = new CodedOutputStream(raw_output);
+  coded_output->WriteVarint32(message.ByteSize());
+  if(!message.SerializeToCodedStream(coded_output))
+  {
+    printf("SerializeToCodedStream failed");
+    fflush(stdout);
+    return -1;
+  }
+  // As per this - https://stackoverflow.com/questions/22881876/protocol-buffers-how-to-serialize-and-deserialize-multiple-messages-into-a-file?noredirect=1&lq=1
+  // TODO: There may be a better way to do this - 1) this happens with every accept now and 2) make it happen on the stack vs heap - destructor will be called on return from this function (main) and the items will then be written out. (We probably don't want that, actually)
+  delete coded_output;
+  delete raw_output;
+  fflush(stdout);
+  return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+///////////// TRY TO INCLUDE RIGHT SGX HEADERS IN SGX_PROTOBUF CPP
+
+
+
+
+
+
+
+
+
+
+
+uint32_t write_to_fd(int fd, uint8_t* msg, uint32_t* expected_msg_length)
+{
+  ssize_t bytes_written; 
+  bytes_written = write(fd, msg, *expected_msg_length);
+  if(bytes_written <= 0)
+    return 0xFFFFFFFF;
+
+  fsync(fd);
+  *expected_msg_length = bytes_written;
+  return 0;
+}
+
+uint32_t read_from_fd(int fd, uint8_t* msg, uint32_t* expected_msg_length)
+{
+  ssize_t bytes_read;
+  lseek(fd, 0, SEEK_SET);
+  bytes_read = read(fd, msg, *expected_msg_length);
+  if(bytes_read <= 0)
+    return 0xFFFFFFFF;
+  return 0;
+}
+
+// Sets up a socket to bind and listen to the given port. Returns FD of the socket on success, -1 on failure (and prints a msg to stdout with the errno)
+int set_up_socket(int port,   sockaddr_in* address)
+{
+  int server_fd = 0;
+
+  // Creating socket file descriptor for listening for attestation requests.
+  server_fd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
+  if (server_fd == -1)
+  {
+     printf("Error in creating a socket - %d", errno);
+      return -1;
+  }
+
+  // Preparing the address struct for binding
+  address->sin_family = AF_INET;
+  address->sin_addr.s_addr = INADDR_ANY; // Todo: should this be localhost?
+  address->sin_port = htons(port);
+  //  memset(address->sin_zero,0,sizeof(address->sin_zero));
+
+  socklen_t addrlen = sizeof(*address);
+  // Binding
+  if (bind(server_fd, (sockaddr*)address, addrlen)<0)
+  {
+      printf("Error in binding %d - port was %d - ", errno, port);
+      return -1;
+  }
+
+  // Listening
+  if (listen(server_fd, 128) < 0)
+  {
+      printf("Error in listening %d", errno);
+      return -1;
+  }
+
+  return server_fd;
+}
+
+int local_attestation_initiator(__attribute__((unused))   uint8_t* expected_mr_signer)
+{
+  // declare msg1, msg2, msg3 protobuf objects and native SGX structs
+  protobuf_sgx_dh_msg1_t protobuf_msg1;
+  protobuf_sgx_dh_msg2_t protobuf_msg2;
+  protobuf_sgx_dh_msg3_t protobuf_msg3;
+  // For sgx - ecalls and storing msgs rcvd from pipes for processing.
+  uint32_t session_id;
+  sgx_dh_msg1_t dh_msg1;            //Diffie-Hellman Message 1
+  sgx_dh_msg2_t dh_msg2;            //Diffie-Hellman Message 2
+  sgx_dh_msg3_t dh_msg3;            //Diffie-Hellman Message 3
+  sgx_key_128bit_t dh_aek;        // Session Key
+  // initializing native sgx structs
+  memset(&dh_aek,0, sizeof(sgx_key_128bit_t));
+  memset(&dh_msg1, 0, sizeof(sgx_dh_msg1_t));
+  memset(&dh_msg2, 0, sizeof(sgx_dh_msg2_t));
+  memset(&dh_msg3, 0, sizeof(sgx_dh_msg3_t));
+
+  // For socket to listen to the Apache enclave.
+      int apache_port = 3825; int server_fd=0; int accept_fd = 0;
+      struct sockaddr_in own_addr;
+      struct sockaddr_storage apache_addr; socklen_t apache_addr_size = sizeof(apache_addr);
+    //  int counter;
+
+      server_fd=set_up_socket(apache_port, &own_addr);
+      if(server_fd==-1)
+        return -1;
+      printf("Successfully set up a socket to communicate with the Apache enclave.");
+      fflush(stdout);
+
+      uint32_t ret_status;
+      Decryptor_session_request(e2_enclave_id, &ret_status, &dh_msg1, &session_id); // TODO: Check Return status
+      if(ret_status != SGX_SUCCESS) 
+      {
+	printf("session request returned failure\n");  fflush(stdout); return 0xffffffff;
+      }
+      encode_msg1_to_protobuf(protobuf_msg1, &dh_msg1);
+      print_initialized_msg1(protobuf_msg1, &dh_msg1);
+      printf("Done initialization");
+      fflush(stdout);
+
+      int no_of_msgs_xchanged=0;
+      accept_fd = accept(server_fd, (struct sockaddr *)&apache_addr,&apache_addr_size);
+      if (accept_fd <0)
+      {
+        printf("Error in accepting %d", errno);
+        return -1;
+      }
+      do
+      {
+        if(no_of_msgs_xchanged==0){
+          if(write_protobuf_msg_to_fd(accept_fd, protobuf_msg1)!=0)
+  		      return -1;
+        }
+        else
+        {
+          printf("about to read msg2\n");
+  	      fflush(stdout);
+          // read msg2 -
+          if(read_protobuf_msg_from_fd(accept_fd, protobuf_msg2)!=0)
+  		      return -1;
+          if(decode_msg2_from_protobuf(protobuf_msg2, &dh_msg2)!=0)
+  		      return -1;
+          printf("Done reading and decoding msg2\n");
+          // process msg2 and generate msg3
+          Decryptor_exchange_report(e2_enclave_id, &ret_status, &dh_msg2, &dh_msg3, &session_id);
+          if(ret_status!=SGX_SUCCESS)
+  	      {
+            fflush(stdout);
+            printf("exchange report failed:%x\n", ret_status);
+            fflush(stdout);
+            return -1;
+          }
+          printf("return status %d", ret_status);
+          fflush(stdout);
+          // convert msg3 sgx_dh_msg3_t object to a protobuf msg3 object.
+          encode_msg3_to_protobuf(protobuf_msg3, &dh_msg3);
+          printf("about to write msg3\n");
+          fflush(stdout);
+          // write msg3 -
+          if(write_protobuf_msg_to_fd(accept_fd, protobuf_msg3)!=0)
+            return -1;
+          no_of_msgs_xchanged+=1;
+        }
+        no_of_msgs_xchanged++;
+      }
+      while(no_of_msgs_xchanged!=3);
+  	printf("Out of while loop\n");
+  	fflush(stdout);
+	return 0;
+}
+/*
+uint32_t unseal_signing_key_pair_from_disk(int fd, __attribute__((unused))  sgx_ec256_public_t* pub_key, uint32_t* actual_sealed_msg_length)
+{
+  uint32_t ret_status;
+  uint8_t* sgx_sealed_msg;
+  sgx_sealed_msg = (uint8_t*) malloc(*actual_sealed_msg_length);
+  ret_status = read_from_fd(fd, sgx_sealed_msg, actual_sealed_msg_length);
+  if(ret_status != 0)
+  {
+    free(sgx_sealed_msg);
+    return 0xFFFFFFFF;
+  }
+   
+  Decryptor_unseal_and_restore_sealed_signing_key_pair(e2_enclave_id, &ret_status, pub_key, sgx_sealed_msg, actual_sealed_msg_length);
+  free(sgx_sealed_msg);
+  return ret_status;
+}
+
+uint32_t create_and_seal_signing_key_pair_to_disk(int fd, sgx_ec256_public_t* pub_key, uint32_t* actual_sealed_msg_length)
+{
+  uint32_t ret_status;
+  // Generating a signing ECDSA key to sign the encryption key.
+  
+  Decryptor_calculate_sealed_data_size(e2_enclave_id, 3*SGX_ECP256_KEY_SIZE, actual_sealed_msg_length); // sgx_calc_sealed_data_size(0,3*SGX_ECP256_KEY_SIZE);
+  if(*actual_sealed_msg_length == 0xFFFFFFFF)
+    return 0xFFFFFFFF;
+  printf("%x bytes for sealed msg\n", *actual_sealed_msg_length); fflush(stdout); 
+  uint8_t* sealed_data=(uint8_t*) malloc(*actual_sealed_msg_length);
+  printf("Made call to sgx_calc_sealed_data_size\n");  fflush(stdout); 
+  Decryptor_create_and_seal_ecdsa_signing_key_pair(e2_enclave_id, &ret_status, (sgx_ec256_public_t*)pub_key, actual_sealed_msg_length, sealed_data);
+  if(ret_status != SGX_SUCCESS)
+  {
+    printf("create_and_seal called returned an error: %x", ret_status); 
+    free(sealed_data);
+    return 0xFFFFFFFF;
+  }
+  printf("It returned sgx_success\n"); fflush(stdout); 
+  ret_status = write_to_fd(fd, sealed_data, actual_sealed_msg_length);
+  free(sealed_data);
+  return ret_status;
+}
+*/
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[])
+{
+    uint32_t ret_status;
+    sgx_status_t status;
+    // For sgx setup
+    int launch_token_updated;
+    sgx_launch_token_t launch_token;
+//    uint8_t* pub_key = (uint8_t*) malloc(2*SGX_ECP256_KEY_SIZE);
+//    sgx_ec256_public_t pub_key; 
+    
+
+  //  uint32_t actual_sealed_msg_length;
+    status = sgx_create_enclave(Decryptor_PATH, SGX_DEBUG_FLAG, &launch_token, &launch_token_updated, &e2_enclave_id, NULL);
+    if(status != SGX_SUCCESS)
+    {
+        printf("\nLoad Enclave Failure");
+        return -1;
+    }
+    printf("\nDecryptor - EnclaveID %" PRIx64, e2_enclave_id);
+    fflush(stdout);
+    ret_status=local_attestation_initiator(NULL); 
+    if(ret_status!=0)
+    {
+	printf("local attestation did not successfully return: %x\n", ret_status); fflush(stdout); return 0xFFFFFFFF; 
+
+    }
+/*    int sealed_signing_key_fd = open("sealed_signing_key.txt", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+    if(sealed_signing_key_fd == -1)
+    {
+      perror("\nError in opening the file sealed_signing_key.txt - ");
+      fflush(stderr);
+      return 0xFFFFFFFF;
+    }
+    printf("\nSuccessfully opened a file to seal the signing key pair for the client.\n");
+    fflush(stdout);
+    int start = lseek(sealed_signing_key_fd, 0, SEEK_CUR);
+    int end = lseek(sealed_signing_key_fd, 0, SEEK_END);
+    if(start == end && start != -1)
+    {
+      // TODO: file is empty. create signing key pair.
+      start = lseek(sealed_signing_key_fd, 0, SEEK_CUR);
+      ret_status = create_and_seal_signing_key_pair_to_disk(sealed_signing_key_fd, &pub_key, &actual_sealed_msg_length);
+      if(ret_status != 0)
+      {
+        printf("\n error in generating the ecdsa signing key pair \n");
+        fflush(stdout);
+        return 0xFFFFFFFF;
+      }
+	fflush(stdout);
+      printf("\n Generated the ecdsa key pair successfully - gx, gy\n");
+      fflush(stdout);
+    }
+    else {
+      start = lseek(sealed_signing_key_fd, 0, SEEK_CUR);
+      if(actual_sealed_msg_length == 0)
+        actual_sealed_msg_length = end - start;
+      ret_status = unseal_signing_key_pair_from_disk(sealed_signing_key_fd, &pub_key, &actual_sealed_msg_length);
+      if(ret_status != SGX_SUCCESS)
+      {
+        printf("\n error in unsealing the ecdsa signing key pair:%d \n", ret_status);
+        fflush(stdout);
+        return 0xFFFFFFFF;
+      }
+      printf("\n Recovered the ecdsa key pair successfully - gx, gy\n");
+      fflush(stdout);
+    }
+*/
+
+    // TODO: Continue with other msgs - send sign(enc | verifier mr_enclave)
+    sgx_destroy_enclave(e2_enclave_id);
+
+    return 0;
+}

+ 692 - 0
App/App_old.txt

@@ -0,0 +1,692 @@
+/*
+ * Copyright (C) 2011-2017 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.challa
+ *
+ */
+
+#define SGX_DH_MAC_SIZE 16
+#define SGX_TARGET_INFO_RESERVED1_BYTES 4
+#define SGX_TARGET_INFO_RESERVED2_BYTES 456
+#define SGX_ECP256_KEY_SIZE 32
+#define SGX_CPUSVN_SIZE 16
+#define SGX_REPORT_DATA_SIZE 64
+#define SGX_MAC_SIZE 16 /* Message Authentication Code - 16 bytes */
+#define SGX_KEYID_SIZE 32
+#define SGX_HASH_SIZE 32 /* SHA256 */
+
+#define SGX_REPORT_BODY_RESERVED1 28
+#define SGX_REPORT_BODY_RESERVED2 32
+#define SGX_REPORT_BODY_RESERVED3 96
+#define SGX_REPORT_BODY_RESERVED4 60
+
+// App.cpp : Defines the entry point for the console application.
+#include <stdio.h>
+#include <map>
+#include "../Decryptor/Decryptor_u.h"
+#include "sgx_eid.h"
+#include "sgx_urts.h"
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+#include<unistd.h>
+
+// For ecdsa signing key generation 
+#include "sgx_tcrypto.h"
+
+// For socket programming
+#include <sys/socket.h>
+#include <stdlib.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <errno.h>
+#include<unistd.h>
+
+// For google proto buffers
+#include "dhmsgs.pb.h"
+#include <inttypes.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+using namespace google::protobuf::io;
+
+#define UNUSED(val) (void)(val)
+#define TCHAR   char
+#define _TCHAR  char
+#define _T(str) str
+#define scanf_s scanf
+#define _tmain  main
+
+// Not sure if I need this later - as such, I (decryptor app) will only ever need to talk to 1 enclave at a time - verifier enclave first and then the apache enclave.
+//extern std::map<sgx_enclave_id_t, uint32_t>g_enclave_id_map;
+
+sgx_enclave_id_t e2_enclave_id = 0;
+#define Decryptor_PATH "libDecryptor.so"
+
+int fit_32_into_uint8_t(google::protobuf::uint32 temp32, uint8_t* temp8)
+{
+ if(temp32 > UINT8_MAX)
+	 return -1;
+ else
+ {
+	 //		 *temp8 = *(uint8_t*)&temp32; // Probably works irrespective of endianness but not sure.
+	 *temp8 = (uint8_t)temp32;
+	 return 0;
+ }
+}
+
+int fit_32_into_uint16_t(google::protobuf::uint32 temp32, uint16_t* temp16)
+{
+ if(temp32 > UINT16_MAX)
+	 return -1;
+ else
+ {
+	 //		 *temp8 = *(uint8_t*)&temp32; // Probably works irrespective of endianness but not sure.
+	 *temp16 = (uint16_t)temp32;
+	 return 0;
+ }
+}
+// Sets up a socket to bind and listen to the given port. Returns FD of the socket on success, -1 on failure (and prints a msg to stdout with the errno)
+int set_up_socket(int port,   sockaddr_in* address)
+{
+  int server_fd = 0;
+
+  // Creating socket file descriptor for listening for attestation requests.
+  server_fd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
+  if (server_fd == -1)
+  {
+     printf("Error in creating a socket - %d", errno);
+      return -1;
+  }
+
+  // Preparing the address struct for binding
+  address->sin_family = AF_INET;
+  address->sin_addr.s_addr = INADDR_ANY; // Todo: should this be localhost?
+  address->sin_port = htons(port);
+  //  memset(address->sin_zero,0,sizeof(address->sin_zero));
+
+  socklen_t addrlen = sizeof(*address);
+  // Binding
+  if (bind(server_fd, (sockaddr*)address, addrlen)<0)
+  {
+      printf("Error in binding %d - port was %d - ", errno, port);
+      return -1;
+  }
+
+  // Listening
+  if (listen(server_fd, 128) < 0)
+  {
+      printf("Error in listening %d", errno);
+      return -1;
+  }
+
+  return server_fd;
+}
+
+void encode_ec256_public_key_to_protobuf(protobuf_sgx_ec256_public_t* protobuf_g_a , sgx_ec256_public_t* g_a)
+{
+	int counter; google::protobuf::uint32 temp32;
+	for(counter=0;counter<SGX_ECP256_KEY_SIZE;counter++)
+	{
+		temp32 = g_a->gx[counter];
+		protobuf_g_a->add_gx(temp32);
+		temp32 = g_a->gy[counter];
+		protobuf_g_a->add_gy(temp32);
+	}
+}
+
+int decode_ec256_public_key_from_protobuf(protobuf_sgx_ec256_public_t* protobuf_g_a , sgx_ec256_public_t* g_a)
+{
+  printf("\n ec256 pub key\n");
+	int counter; google::protobuf::uint32 temp32;
+	for(counter=0;counter<SGX_ECP256_KEY_SIZE;counter++)
+	{
+		temp32 = protobuf_g_a->gx(counter);
+		if(fit_32_into_uint8_t(temp32, &(g_a->gx[counter]))!=0)
+		 return -1;
+    printf("%d ",g_a->gx[counter]);
+		temp32 = protobuf_g_a->gy(counter);
+		if(fit_32_into_uint8_t(temp32, &(g_a->gy[counter]))!=0)
+		 return -1;
+    printf("%d ",g_a->gy[counter]);
+	}
+  return 0;
+}
+
+void encode_attributes_to_protobuf(protobuf_sgx_attributes_t* protobuf_attributes, sgx_attributes_t* attributes)
+{
+	protobuf_attributes->set_flags(attributes->flags); // 64 bit
+	protobuf_attributes->set_xfrm(attributes->xfrm); // 64 bit
+}
+
+int decode_attributes_from_protobuf(protobuf_sgx_attributes_t* protobuf_attributes, sgx_attributes_t* attributes)
+{
+	attributes->flags = protobuf_attributes->flags();
+  printf("\n flags %" PRIu64 " \n", attributes->flags);
+	attributes->xfrm = protobuf_attributes->xfrm();
+  printf("\n xfrm %" PRIu64 " \n", attributes->xfrm);
+	return 0; 
+}
+
+void encode_report_to_protobuf(protobuf_sgx_report_t* protobuf_report, sgx_report_t* report)
+{
+	int counter; google::protobuf::uint32 temp32;
+	for(counter=0;counter<SGX_KEYID_SIZE;counter++)
+	{
+		temp32=report->key_id.id[counter];
+		protobuf_report->add_key_id(temp32);
+	}
+
+	for(counter=0;counter<SGX_MAC_SIZE;counter++)
+	{
+		temp32=report->mac[counter];
+		protobuf_report->add_mac(temp32);
+	}
+
+	protobuf_report->mutable_body()->set_misc_select(report->body.misc_select); // 32 bit
+	protobuf_report->mutable_body()->set_isv_svn(report->body.isv_svn); // 16 bit
+	protobuf_report->mutable_body()->set_isv_prod_id(report->body.isv_prod_id); // 16 bit
+	encode_attributes_to_protobuf(protobuf_report->mutable_body()->mutable_attributes(), &(report->body.attributes));
+
+	for(counter=0;counter<SGX_CPUSVN_SIZE;counter++)
+	{
+		temp32=report->body.cpu_svn.svn[counter];
+		protobuf_report->mutable_body()->add_cpu_svn(temp32);
+	}
+
+	for(counter=0;counter<SGX_REPORT_BODY_RESERVED1;counter++)
+	{
+		temp32=report->body.reserved1[counter]; // TODO: Could be optimized out - if these are determined to be 0s.
+		protobuf_report->mutable_body()->add_reserved1(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_REPORT_BODY_RESERVED2;counter++)
+	{
+		temp32=report->body.reserved2[counter]; // TODO: Could be optimized out - if these are determined to be 0s.
+		protobuf_report->mutable_body()->add_reserved2(temp32);
+	}
+
+	for(counter=0;counter<SGX_REPORT_BODY_RESERVED3;counter++)
+	{
+		temp32=report->body.reserved3[counter]; // TODO: Could be optimized out - if these are determined to be 0s.
+		protobuf_report->mutable_body()->add_reserved3(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_REPORT_BODY_RESERVED4;counter++)
+	{
+		temp32=report->body.reserved4[counter]; // TODO: Could be optimized out - if these are determined to be 0s.
+		protobuf_report->mutable_body()->add_reserved4(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_HASH_SIZE;counter++)
+	{
+		temp32=report->body.mr_enclave.m[counter];
+		protobuf_report->mutable_body()->add_mr_enclave(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_HASH_SIZE;counter++)
+	{
+		temp32=report->body.mr_signer.m[counter];
+		protobuf_report->mutable_body()->add_mr_signer(temp32);
+ 	}
+
+	for(counter=0;counter<SGX_REPORT_DATA_SIZE;counter++)
+	{
+		temp32=report->body.report_data.d[counter];
+		protobuf_report->mutable_body()->add_report_data(temp32);
+ 	}
+}
+
+int decode_report_from_protobuf(protobuf_sgx_report_t* protobuf_report, sgx_report_t* report)
+{
+  int counter; google::protobuf::uint32 temp32;
+
+  printf("\nreport body keyid\n");
+  for(counter=0;counter<SGX_KEYID_SIZE;counter++)
+  {
+    temp32=protobuf_report->key_id(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->key_id.id[counter]))!=0)
+		  return -1;
+    printf("%d ", report->key_id.id[counter]);
+  }
+
+  printf("\nreport mac\n");
+  for(counter=0;counter<SGX_MAC_SIZE;counter++)
+  {
+    temp32=protobuf_report->mac(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->mac[counter]))!=0)
+      return -1;
+    printf("%d ", report->mac[counter]);
+  }
+
+  report->body.misc_select=protobuf_report->mutable_body()->misc_select(); // 32 bit
+  temp32=protobuf_report->mutable_body()->isv_svn();
+  if(fit_32_into_uint16_t(temp32, &(report->body.isv_svn))!=0)
+   return -1;
+  printf("\nmisc select %d \n", report->body.misc_select);
+
+  temp32=protobuf_report->mutable_body()->isv_prod_id();
+   if(fit_32_into_uint16_t(temp32, &(report->body.isv_prod_id))!=0)
+    return -1;
+  printf("\nprod id %d \n", report->body.isv_prod_id);
+
+  decode_attributes_from_protobuf(protobuf_report->mutable_body()->mutable_attributes(), &(report->body.attributes));
+
+  printf("\n cpu svn\n");
+  for(counter=0;counter<SGX_CPUSVN_SIZE;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->cpu_svn(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.cpu_svn.svn[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.cpu_svn.svn[counter]);
+
+  }
+
+  printf("\n reserved1 \n");
+  for(counter=0;counter<SGX_REPORT_BODY_RESERVED1;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->reserved1(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.reserved1[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.reserved1[counter]);
+  }
+
+  printf("\n reserved2 \n");
+  for(counter=0;counter<SGX_REPORT_BODY_RESERVED2;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->reserved2(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.reserved2[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.reserved2[counter]);
+  }
+
+  printf("\n reserved3 \n");
+  for(counter=0;counter<SGX_REPORT_BODY_RESERVED3;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->reserved3(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.reserved3[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.reserved3[counter]);
+  }
+
+  printf("\n reserved4 \n");
+  for(counter=0;counter<SGX_REPORT_BODY_RESERVED4;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->reserved4(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.reserved4[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.reserved4[counter]);
+
+  }
+
+  printf("\n mrenclave \n");
+  for(counter=0;counter<SGX_HASH_SIZE;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->mr_enclave(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.mr_enclave.m[counter]))!=0)
+      return -1;
+    printf("%x ", report->body.mr_enclave.m[counter]);
+  }
+
+  printf("\n mrsigner \n");
+  for(counter=0;counter<SGX_HASH_SIZE;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->mr_signer(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.mr_signer.m[counter]))!=0)
+      return -1;
+    printf("%x ", report->body.mr_signer.m[counter]);
+  }
+
+  printf("\n report data\n");
+  for(counter=0;counter<SGX_REPORT_DATA_SIZE;counter++)
+  {
+    temp32=protobuf_report->mutable_body()->report_data(counter);
+    if(fit_32_into_uint8_t(temp32, &(report->body.report_data.d[counter]))!=0)
+      return -1;
+    printf("%d ", report->body.report_data.d[counter]);
+  }
+	return 0;
+}
+
+void encode_msg1_to_protobuf( protobuf_sgx_dh_msg1_t& protobuf_dhmsg1, sgx_dh_msg1_t* native_dhmsg1)
+{
+   int counter; google::protobuf::uint32 temp32; // google::protobuf::uint64 temp64;
+
+   encode_ec256_public_key_to_protobuf(protobuf_dhmsg1.mutable_g_a(), &(native_dhmsg1->g_a));
+
+   for(counter=0;counter<SGX_HASH_SIZE;counter++)
+   {
+     temp32=native_dhmsg1->target.mr_enclave.m[counter];
+     protobuf_dhmsg1.mutable_target()->add_mr_enclave(temp32);
+   }
+
+   for(counter=0;counter<SGX_TARGET_INFO_RESERVED1_BYTES;counter++)
+   {
+     temp32=native_dhmsg1->target.reserved1[counter];
+     protobuf_dhmsg1.mutable_target()->add_reserved1(temp32);
+   }
+
+   for(counter=0;counter<SGX_TARGET_INFO_RESERVED2_BYTES;counter++)
+   {
+     temp32=native_dhmsg1->target.reserved2[counter];
+     protobuf_dhmsg1.mutable_target()->add_reserved2(temp32);
+   }
+
+   encode_attributes_to_protobuf(protobuf_dhmsg1.mutable_target()->mutable_attributes(), &(native_dhmsg1->target.attributes));
+
+   temp32=native_dhmsg1->target.misc_select ;
+   protobuf_dhmsg1.mutable_target()->set_misc_select(temp32);
+}
+
+void encode_msg3_to_protobuf(protobuf_sgx_dh_msg3_t& protobuf_dhmsg3, sgx_dh_msg3_t* native_dhmsg3)
+{
+  int counter; google::protobuf::uint32 temp32;
+  for(counter=0;counter<SGX_DH_MAC_SIZE;counter++)
+	{
+		temp32=native_dhmsg3->cmac[counter];
+		protobuf_dhmsg3.add_cmac(temp32);
+	}
+
+  encode_report_to_protobuf(protobuf_dhmsg3.mutable_msg3_body()->mutable_report(), &(native_dhmsg3->msg3_body.report));
+  int max_counter=native_dhmsg3->msg3_body.additional_prop_length;
+  unsigned char*temp;
+  for(counter=0,temp=native_dhmsg3->msg3_body.additional_prop;counter<max_counter;counter++,temp++)
+  {
+    protobuf_dhmsg3.mutable_msg3_body()->add_additional_prop(*temp);
+  }
+}
+
+int decode_msg2_from_protobuf(protobuf_sgx_dh_msg2_t& protobuf_dhmsg2, sgx_dh_msg2_t* native_dhmsg2)
+{
+  int counter; google::protobuf::uint32 temp32; //google::protobuf::uint64 temp64;
+  printf("\ncmac\n");
+  for(counter=0;counter<SGX_DH_MAC_SIZE;counter++)
+  {
+    temp32=protobuf_dhmsg2.cmac(counter);
+    if(fit_32_into_uint8_t(temp32, &(native_dhmsg2->cmac[counter]))!=0)
+     return -1;
+    printf("%d ",native_dhmsg2->cmac[counter]);
+  }
+
+  if(decode_ec256_public_key_from_protobuf(protobuf_dhmsg2.mutable_g_b(), &(native_dhmsg2->g_b)) !=0)
+	return -1;
+
+  if(decode_report_from_protobuf(protobuf_dhmsg2.mutable_report(), &(native_dhmsg2->report)) !=0)
+	return -1;
+
+  return 0;
+}
+
+int print_initialized_msg1( protobuf_sgx_dh_msg1_t& protobuf_dhmsg1, sgx_dh_msg1_t* native_dhmsg1)
+{
+   int counter;
+	 printf("gx\n");
+   for(counter=0;counter<SGX_ECP256_KEY_SIZE;counter++)
+   {
+      printf("%d ", protobuf_dhmsg1.g_a().gx(counter));
+      printf("%d ", native_dhmsg1->g_a.gx[counter]);
+   }
+   printf("\ngy\n");
+   for(counter=0;counter<SGX_ECP256_KEY_SIZE;counter++)
+   {
+      printf("%d ", protobuf_dhmsg1.g_a().gy(counter));
+      printf("%d ", native_dhmsg1->g_a.gy[counter]);
+   }
+
+   printf("\nmrenclave in target\n");
+   for(counter=0;counter<SGX_HASH_SIZE;counter++)
+   {
+      printf("%" PRIu32 " ", protobuf_dhmsg1.target().mr_enclave(counter));
+      printf("%d ", native_dhmsg1->target.mr_enclave.m[counter]);
+
+   }
+   printf("\nreserved1 in target\n");
+   for(counter=0;counter<SGX_TARGET_INFO_RESERVED1_BYTES;counter++)
+   {
+      printf("%" PRIu32 " ", protobuf_dhmsg1.target().reserved1(counter));
+      printf("%d ", native_dhmsg1->target.reserved1[counter]);
+
+   }
+   printf("\nreserved2 in target\n");
+   for(counter=0;counter<SGX_TARGET_INFO_RESERVED2_BYTES;counter++)
+   {
+      printf("%" PRIu32 " ", protobuf_dhmsg1.target().reserved2(counter));
+      printf("%d ", native_dhmsg1->target.reserved2[counter]);
+   }
+
+   printf("\n %" PRIu64 "\n", native_dhmsg1->target.attributes.flags);
+   printf("\n %" PRIu64 "\n", protobuf_dhmsg1.target().attributes().flags());
+   printf("\n %" PRIu64 "\n", native_dhmsg1->target.attributes.xfrm);
+   printf("\n %" PRIu64 "\n", protobuf_dhmsg1.target().attributes().xfrm());
+   printf("\n %" PRIu32 "\n", native_dhmsg1->target.misc_select);
+   printf("\n %" PRIu32 "\n", protobuf_dhmsg1.target().misc_select());
+
+	return 0;
+}
+
+int read_protobuf_msg_from_fd(int accept_fd, google::protobuf::MessageLite& message)
+{
+  ZeroCopyInputStream* raw_input;
+  CodedInputStream* coded_input;
+  uint32_t size;
+  CodedInputStream::Limit limit;
+  raw_input = new FileInputStream(accept_fd);
+  coded_input = new CodedInputStream(raw_input);
+  if(!coded_input->ReadVarint32(&size))
+  {
+    printf("Error in reading size of msg");
+    fflush(stdout);
+    return -1;
+  }
+  //printf("size of msg was read to be %" PRIu32 " \n", size);
+  fflush(stdout);
+  limit = coded_input->PushLimit(size);
+  if(!message.ParseFromCodedStream(coded_input))
+  {
+    printf("Error in parsing msg");
+    fflush(stdout);
+    return -1;
+  }
+  coded_input->PopLimit(limit);
+  return 0;
+}
+
+int write_protobuf_msg_to_fd(int accept_fd, google::protobuf::MessageLite& message)
+{
+  ZeroCopyOutputStream* raw_output = new FileOutputStream(accept_fd);
+  CodedOutputStream* coded_output  = new CodedOutputStream(raw_output);
+  coded_output->WriteVarint32(message.ByteSize());
+  if(!message.SerializeToCodedStream(coded_output))
+  {
+    printf("SerializeToCodedStream failed");
+    fflush(stdout);
+    return -1;
+  }
+  // As per this - https://stackoverflow.com/questions/22881876/protocol-buffers-how-to-serialize-and-deserialize-multiple-messages-into-a-file?noredirect=1&lq=1
+  // TODO: There may be a better way to do this - 1) this happens with every accept now and 2) make it happen on the stack vs heap - destructor will be called on return from this function (main) and the items will then be written out. (We probably don't want that, actually)
+  delete coded_output;
+  delete raw_output;
+  fflush(stdout);
+  return 0;
+}
+
+int _tmain(int argc, _TCHAR* argv[])
+{
+    uint32_t ret_status;
+    sgx_status_t status;
+    // For sgx setup
+    int launch_token_updated;
+    sgx_launch_token_t launch_token;
+    // declare msg1, msg2, msg3 protobuf objects and native SGX structs
+    protobuf_sgx_dh_msg1_t protobuf_msg1;
+    protobuf_sgx_dh_msg2_t protobuf_msg2;
+    protobuf_sgx_dh_msg3_t protobuf_msg3;
+    // For sgx - ecalls and storing msgs rcvd from pipes for processing.
+    uint32_t session_id;
+    sgx_dh_msg1_t dh_msg1;            //Diffie-Hellman Message 1
+    sgx_dh_msg2_t dh_msg2;            //Diffie-Hellman Message 2
+    sgx_dh_msg3_t dh_msg3;            //Diffie-Hellman Message 3
+    sgx_key_128bit_t dh_aek;        // Session Key
+    // initializing native sgx structs
+    memset(&dh_aek,0, sizeof(sgx_key_128bit_t));
+    memset(&dh_msg1, 0, sizeof(sgx_dh_msg1_t));
+    memset(&dh_msg2, 0, sizeof(sgx_dh_msg2_t));
+    memset(&dh_msg3, 0, sizeof(sgx_dh_msg3_t));
+    // For socket to listen to the Apache enclave.
+    int apache_port = 3825; int server_fd=0; int accept_fd = 0;
+    struct sockaddr_in own_addr;
+    struct sockaddr_storage apache_addr; socklen_t apache_addr_size = sizeof(apache_addr);
+    int counter;
+    UNUSED(argc);
+    UNUSED(argv);
+
+    server_fd=set_up_socket(apache_port, &own_addr);
+    if(server_fd==-1)
+      return -1;
+    printf("Successfully set up a socket to communicate with the Apache enclave.");
+    fflush(stdout);
+
+    status = sgx_create_enclave(Decryptor_PATH, SGX_DEBUG_FLAG, &launch_token, &launch_token_updated, &e2_enclave_id, NULL);
+    if(status != SGX_SUCCESS)
+    {
+        printf("\nLoad Enclave Failure");
+        close(server_fd);
+        return -1;
+    }
+    printf("\nDecryptor - EnclaveID %" PRIx64, e2_enclave_id);
+    fflush(stdout);
+
+    // Generating a signing ECDSA key to sign the encryption key. 
+    sgx_ec256_public_t pub_key; 
+    Decryptor_create_ecdsa_signing_key_pair(e2_enclave_id, &ret_status, &pub_key);
+    if(ret_status != SGX_SUCCESS) 
+    {
+	printf("\n error in generating the ecdsa signing key pair \n"); 
+	fflush(stdout); 
+	return 0xFFFFFFFF;
+    }
+    printf("\n Generated the ecdsa key pair successfully - gx, gy\n"); 
+    fflush(stdout); 
+    for(counter=0; counter<SGX_ECP256_KEY_SIZE; counter++) 
+    {
+	printf("%x ", pub_key.gx[counter]); 
+    }
+    printf("\n"); fflush(stdout); 
+    for(counter=0; counter<SGX_ECP256_KEY_SIZE; counter++) 
+    {
+        printf("%x ", pub_key.gy[counter]); 
+    }
+    printf("\n"); fflush(stdout);  
+
+    Decryptor_session_request(e2_enclave_id, &ret_status, &dh_msg1, &session_id); // TODO: Check Return status 
+    encode_msg1_to_protobuf(protobuf_msg1, &dh_msg1);
+    print_initialized_msg1(protobuf_msg1, &dh_msg1);
+    printf("Done initialization");
+    fflush(stdout);
+    //
+    int no_of_msgs_xchanged=0;
+//    do
+//    {
+      // accept incoming connection
+    accept_fd = accept(server_fd, (struct sockaddr *)&apache_addr,&apache_addr_size);
+    if (accept_fd <0)
+    {
+      printf("Error in accepting %d", errno);
+      return -1;
+    }
+    printf("Accepted the fd");
+    do
+    {
+      // read msg(none,2) and then write(1,3)
+      if(no_of_msgs_xchanged==0){
+        // call SerializeToFileDescriptor on msg1 object, accept_fd.
+        if(write_protobuf_msg_to_fd(accept_fd, protobuf_msg1)!=0)
+		return -1; 
+      }
+      else
+      {
+	       printf("about to read msg2\n");
+	        fflush(stdout);
+        // read msg2 -
+        if(read_protobuf_msg_from_fd(accept_fd, protobuf_msg2)!=0)
+		return -1;
+
+        if(decode_msg2_from_protobuf(protobuf_msg2, &dh_msg2)!=0)
+		return -1; 
+	printf("Done decoding msg2\n"); 
+        // TODO: call fn to generate msg3 for the responder.
+	Decryptor_exchange_report(e2_enclave_id, &ret_status, &dh_msg2, &dh_msg3, &session_id);
+	if(ret_status!=SGX_SUCCESS)
+	{
+		fflush(stdout);
+		printf("exchange report failed:%x\n", ret_status);
+		fflush(stdout);
+		return -1;
+	}
+	printf("return status %d", ret_status);
+	fflush(stdout);
+        // convert msg3 sgx_dh_msg3_t object to a protobuf msg3 object.
+        encode_msg3_to_protobuf(protobuf_msg3, &dh_msg3);
+	printf("about to write msg3\n");
+	fflush(stdout);
+        // write msg3 -
+        if(write_protobuf_msg_to_fd(accept_fd, protobuf_msg3)!=0)
+		return -1; 
+        no_of_msgs_xchanged+=1;
+      }
+      no_of_msgs_xchanged++;
+
+    }
+    while(no_of_msgs_xchanged!=3);
+	printf("Out of while loop\n");
+	fflush(stdout);
+    // TODO: Continue with other msgs.
+//    sleep(500);
+    sgx_destroy_enclave(e2_enclave_id);
+
+    return 0;
+}
+
+/*
+// Reads from a server fd that is set up successfully for accept, into a buffer buf and upto the length len.
+// Returns the number of characters read on success and -1 on error. Also, on error, prints the errno for the accept system call.
+int accept_and_read(int server_fd, char* buf, int len)
+{
+int initialize_msg1( protobuf_sgx_dh_msg1_t& protobuf_dhmsg1, sgx_dh_msg1_t* native_dhmsg1)
+     int accept_fd=0;
+     // accept connections and then forward them to the main enclave.
+     if ((accept_fd = accept(server_fd, (struct sockaddr *)&address,
+                       (socklen_t*)&addrlen))<0)
+    {
+        printf("Error in accepting %d", errno);
+        return -1;
+    }
+    valread = read(accept_fd, buf, len);
+    if(valread == -1)
+        printf("Error in reading %d", errno);
+    return valread;
+}
+*/
+

+ 2997 - 0
App/dhmsgs.pb.cpp

@@ -0,0 +1,2997 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: dhmsgs.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "dhmsgs.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+// @@protoc_insertion_point(includes)
+
+void protobuf_ShutdownFile_dhmsgs_2eproto() {
+  delete protobuf_sgx_attributes_t::default_instance_;
+  delete protobuf_sgx_ec256_public_t::default_instance_;
+  delete protobuf_sgx_report_body_t::default_instance_;
+  delete protobuf_sgx_report_t::default_instance_;
+  delete protobuf_sgx_target_info_t::default_instance_;
+  delete protobuf_sgx_dh_msg1_t::default_instance_;
+  delete protobuf_sgx_dh_msg2_t::default_instance_;
+  delete protobuf_sgx_dh_msg3_body_t::default_instance_;
+  delete protobuf_sgx_dh_msg3_t::default_instance_;
+}
+
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+void protobuf_AddDesc_dhmsgs_2eproto_impl() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#else
+void protobuf_AddDesc_dhmsgs_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#endif
+  protobuf_sgx_attributes_t::default_instance_ = new protobuf_sgx_attributes_t();
+  protobuf_sgx_ec256_public_t::default_instance_ = new protobuf_sgx_ec256_public_t();
+  protobuf_sgx_report_body_t::default_instance_ = new protobuf_sgx_report_body_t();
+  protobuf_sgx_report_t::default_instance_ = new protobuf_sgx_report_t();
+  protobuf_sgx_target_info_t::default_instance_ = new protobuf_sgx_target_info_t();
+  protobuf_sgx_dh_msg1_t::default_instance_ = new protobuf_sgx_dh_msg1_t();
+  protobuf_sgx_dh_msg2_t::default_instance_ = new protobuf_sgx_dh_msg2_t();
+  protobuf_sgx_dh_msg3_body_t::default_instance_ = new protobuf_sgx_dh_msg3_body_t();
+  protobuf_sgx_dh_msg3_t::default_instance_ = new protobuf_sgx_dh_msg3_t();
+  protobuf_sgx_attributes_t::default_instance_->InitAsDefaultInstance();
+  protobuf_sgx_ec256_public_t::default_instance_->InitAsDefaultInstance();
+  protobuf_sgx_report_body_t::default_instance_->InitAsDefaultInstance();
+  protobuf_sgx_report_t::default_instance_->InitAsDefaultInstance();
+  protobuf_sgx_target_info_t::default_instance_->InitAsDefaultInstance();
+  protobuf_sgx_dh_msg1_t::default_instance_->InitAsDefaultInstance();
+  protobuf_sgx_dh_msg2_t::default_instance_->InitAsDefaultInstance();
+  protobuf_sgx_dh_msg3_body_t::default_instance_->InitAsDefaultInstance();
+  protobuf_sgx_dh_msg3_t::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_dhmsgs_2eproto);
+}
+
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_dhmsgs_2eproto_once_);
+void protobuf_AddDesc_dhmsgs_2eproto() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_dhmsgs_2eproto_once_,
+                 &protobuf_AddDesc_dhmsgs_2eproto_impl);
+}
+#else
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_dhmsgs_2eproto {
+  StaticDescriptorInitializer_dhmsgs_2eproto() {
+    protobuf_AddDesc_dhmsgs_2eproto();
+  }
+} static_descriptor_initializer_dhmsgs_2eproto_;
+#endif
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int protobuf_sgx_attributes_t::kFlagsFieldNumber;
+const int protobuf_sgx_attributes_t::kXfrmFieldNumber;
+#endif  // !_MSC_VER
+
+protobuf_sgx_attributes_t::protobuf_sgx_attributes_t()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:protobuf_sgx_attributes_t)
+}
+
+void protobuf_sgx_attributes_t::InitAsDefaultInstance() {
+}
+
+protobuf_sgx_attributes_t::protobuf_sgx_attributes_t(const protobuf_sgx_attributes_t& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:protobuf_sgx_attributes_t)
+}
+
+void protobuf_sgx_attributes_t::SharedCtor() {
+  _cached_size_ = 0;
+  flags_ = GOOGLE_ULONGLONG(0);
+  xfrm_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+protobuf_sgx_attributes_t::~protobuf_sgx_attributes_t() {
+  // @@protoc_insertion_point(destructor:protobuf_sgx_attributes_t)
+  SharedDtor();
+}
+
+void protobuf_sgx_attributes_t::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void protobuf_sgx_attributes_t::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const protobuf_sgx_attributes_t& protobuf_sgx_attributes_t::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_dhmsgs_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_dhmsgs_2eproto();
+#endif
+  return *default_instance_;
+}
+
+protobuf_sgx_attributes_t* protobuf_sgx_attributes_t::default_instance_ = NULL;
+
+protobuf_sgx_attributes_t* protobuf_sgx_attributes_t::New() const {
+  return new protobuf_sgx_attributes_t;
+}
+
+void protobuf_sgx_attributes_t::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<protobuf_sgx_attributes_t*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(flags_, xfrm_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool protobuf_sgx_attributes_t::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:protobuf_sgx_attributes_t)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint64 flags = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &flags_)));
+          set_has_flags();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_xfrm;
+        break;
+      }
+
+      // required uint64 xfrm = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_xfrm:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &xfrm_)));
+          set_has_xfrm();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:protobuf_sgx_attributes_t)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:protobuf_sgx_attributes_t)
+  return false;
+#undef DO_
+}
+
+void protobuf_sgx_attributes_t::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:protobuf_sgx_attributes_t)
+  // required uint64 flags = 1;
+  if (has_flags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->flags(), output);
+  }
+
+  // required uint64 xfrm = 2;
+  if (has_xfrm()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->xfrm(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:protobuf_sgx_attributes_t)
+}
+
+int protobuf_sgx_attributes_t::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint64 flags = 1;
+    if (has_flags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->flags());
+    }
+
+    // required uint64 xfrm = 2;
+    if (has_xfrm()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->xfrm());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void protobuf_sgx_attributes_t::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const protobuf_sgx_attributes_t*>(&from));
+}
+
+void protobuf_sgx_attributes_t::MergeFrom(const protobuf_sgx_attributes_t& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_flags()) {
+      set_flags(from.flags());
+    }
+    if (from.has_xfrm()) {
+      set_xfrm(from.xfrm());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void protobuf_sgx_attributes_t::CopyFrom(const protobuf_sgx_attributes_t& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool protobuf_sgx_attributes_t::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void protobuf_sgx_attributes_t::Swap(protobuf_sgx_attributes_t* other) {
+  if (other != this) {
+    std::swap(flags_, other->flags_);
+    std::swap(xfrm_, other->xfrm_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string protobuf_sgx_attributes_t::GetTypeName() const {
+  return "protobuf_sgx_attributes_t";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int protobuf_sgx_ec256_public_t::kGxFieldNumber;
+const int protobuf_sgx_ec256_public_t::kGyFieldNumber;
+#endif  // !_MSC_VER
+
+protobuf_sgx_ec256_public_t::protobuf_sgx_ec256_public_t()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:protobuf_sgx_ec256_public_t)
+}
+
+void protobuf_sgx_ec256_public_t::InitAsDefaultInstance() {
+}
+
+protobuf_sgx_ec256_public_t::protobuf_sgx_ec256_public_t(const protobuf_sgx_ec256_public_t& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:protobuf_sgx_ec256_public_t)
+}
+
+void protobuf_sgx_ec256_public_t::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+protobuf_sgx_ec256_public_t::~protobuf_sgx_ec256_public_t() {
+  // @@protoc_insertion_point(destructor:protobuf_sgx_ec256_public_t)
+  SharedDtor();
+}
+
+void protobuf_sgx_ec256_public_t::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void protobuf_sgx_ec256_public_t::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const protobuf_sgx_ec256_public_t& protobuf_sgx_ec256_public_t::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_dhmsgs_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_dhmsgs_2eproto();
+#endif
+  return *default_instance_;
+}
+
+protobuf_sgx_ec256_public_t* protobuf_sgx_ec256_public_t::default_instance_ = NULL;
+
+protobuf_sgx_ec256_public_t* protobuf_sgx_ec256_public_t::New() const {
+  return new protobuf_sgx_ec256_public_t;
+}
+
+void protobuf_sgx_ec256_public_t::Clear() {
+  gx_.Clear();
+  gy_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool protobuf_sgx_ec256_public_t::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:protobuf_sgx_ec256_public_t)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated uint32 gx = 1 [packed = true];
+      case 1: {
+        if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_gx())));
+        } else if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 10, input, this->mutable_gx())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_gy;
+        break;
+      }
+
+      // repeated uint32 gy = 2 [packed = true];
+      case 2: {
+        if (tag == 18) {
+         parse_gy:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_gy())));
+        } else if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 18, input, this->mutable_gy())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:protobuf_sgx_ec256_public_t)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:protobuf_sgx_ec256_public_t)
+  return false;
+#undef DO_
+}
+
+void protobuf_sgx_ec256_public_t::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:protobuf_sgx_ec256_public_t)
+  // repeated uint32 gx = 1 [packed = true];
+  if (this->gx_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_gx_cached_byte_size_);
+  }
+  for (int i = 0; i < this->gx_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->gx(i), output);
+  }
+
+  // repeated uint32 gy = 2 [packed = true];
+  if (this->gy_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_gy_cached_byte_size_);
+  }
+  for (int i = 0; i < this->gy_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->gy(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:protobuf_sgx_ec256_public_t)
+}
+
+int protobuf_sgx_ec256_public_t::ByteSize() const {
+  int total_size = 0;
+
+  // repeated uint32 gx = 1 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->gx_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->gx(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _gx_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 gy = 2 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->gy_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->gy(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _gy_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void protobuf_sgx_ec256_public_t::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const protobuf_sgx_ec256_public_t*>(&from));
+}
+
+void protobuf_sgx_ec256_public_t::MergeFrom(const protobuf_sgx_ec256_public_t& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  gx_.MergeFrom(from.gx_);
+  gy_.MergeFrom(from.gy_);
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void protobuf_sgx_ec256_public_t::CopyFrom(const protobuf_sgx_ec256_public_t& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool protobuf_sgx_ec256_public_t::IsInitialized() const {
+
+  return true;
+}
+
+void protobuf_sgx_ec256_public_t::Swap(protobuf_sgx_ec256_public_t* other) {
+  if (other != this) {
+    gx_.Swap(&other->gx_);
+    gy_.Swap(&other->gy_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string protobuf_sgx_ec256_public_t::GetTypeName() const {
+  return "protobuf_sgx_ec256_public_t";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int protobuf_sgx_report_body_t::kCpuSvnFieldNumber;
+const int protobuf_sgx_report_body_t::kMiscSelectFieldNumber;
+const int protobuf_sgx_report_body_t::kReserved1FieldNumber;
+const int protobuf_sgx_report_body_t::kAttributesFieldNumber;
+const int protobuf_sgx_report_body_t::kMrEnclaveFieldNumber;
+const int protobuf_sgx_report_body_t::kReserved2FieldNumber;
+const int protobuf_sgx_report_body_t::kMrSignerFieldNumber;
+const int protobuf_sgx_report_body_t::kReserved3FieldNumber;
+const int protobuf_sgx_report_body_t::kIsvProdIdFieldNumber;
+const int protobuf_sgx_report_body_t::kIsvSvnFieldNumber;
+const int protobuf_sgx_report_body_t::kReserved4FieldNumber;
+const int protobuf_sgx_report_body_t::kReportDataFieldNumber;
+#endif  // !_MSC_VER
+
+protobuf_sgx_report_body_t::protobuf_sgx_report_body_t()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:protobuf_sgx_report_body_t)
+}
+
+void protobuf_sgx_report_body_t::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  attributes_ = const_cast< ::protobuf_sgx_attributes_t*>(
+      ::protobuf_sgx_attributes_t::internal_default_instance());
+#else
+  attributes_ = const_cast< ::protobuf_sgx_attributes_t*>(&::protobuf_sgx_attributes_t::default_instance());
+#endif
+}
+
+protobuf_sgx_report_body_t::protobuf_sgx_report_body_t(const protobuf_sgx_report_body_t& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:protobuf_sgx_report_body_t)
+}
+
+void protobuf_sgx_report_body_t::SharedCtor() {
+  _cached_size_ = 0;
+  misc_select_ = 0u;
+  attributes_ = NULL;
+  isv_prod_id_ = 0u;
+  isv_svn_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+protobuf_sgx_report_body_t::~protobuf_sgx_report_body_t() {
+  // @@protoc_insertion_point(destructor:protobuf_sgx_report_body_t)
+  SharedDtor();
+}
+
+void protobuf_sgx_report_body_t::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete attributes_;
+  }
+}
+
+void protobuf_sgx_report_body_t::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const protobuf_sgx_report_body_t& protobuf_sgx_report_body_t::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_dhmsgs_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_dhmsgs_2eproto();
+#endif
+  return *default_instance_;
+}
+
+protobuf_sgx_report_body_t* protobuf_sgx_report_body_t::default_instance_ = NULL;
+
+protobuf_sgx_report_body_t* protobuf_sgx_report_body_t::New() const {
+  return new protobuf_sgx_report_body_t;
+}
+
+void protobuf_sgx_report_body_t::Clear() {
+  if (_has_bits_[0 / 32] & 10) {
+    misc_select_ = 0u;
+    if (has_attributes()) {
+      if (attributes_ != NULL) attributes_->::protobuf_sgx_attributes_t::Clear();
+    }
+  }
+  if (_has_bits_[8 / 32] & 768) {
+    isv_prod_id_ = 0u;
+    isv_svn_ = 0u;
+  }
+  cpu_svn_.Clear();
+  reserved1_.Clear();
+  mr_enclave_.Clear();
+  reserved2_.Clear();
+  mr_signer_.Clear();
+  reserved3_.Clear();
+  reserved4_.Clear();
+  report_data_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool protobuf_sgx_report_body_t::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:protobuf_sgx_report_body_t)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated uint32 cpu_svn = 1 [packed = true];
+      case 1: {
+        if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_cpu_svn())));
+        } else if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 10, input, this->mutable_cpu_svn())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_reserved1;
+        break;
+      }
+
+      // repeated uint32 reserved1 = 2 [packed = true];
+      case 2: {
+        if (tag == 18) {
+         parse_reserved1:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_reserved1())));
+        } else if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 18, input, this->mutable_reserved1())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_mr_enclave;
+        break;
+      }
+
+      // repeated uint32 mr_enclave = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_mr_enclave:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_mr_enclave())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_mr_enclave())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_reserved2;
+        break;
+      }
+
+      // repeated uint32 reserved2 = 4 [packed = true];
+      case 4: {
+        if (tag == 34) {
+         parse_reserved2:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_reserved2())));
+        } else if (tag == 32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 34, input, this->mutable_reserved2())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_mr_signer;
+        break;
+      }
+
+      // repeated uint32 mr_signer = 5 [packed = true];
+      case 5: {
+        if (tag == 42) {
+         parse_mr_signer:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_mr_signer())));
+        } else if (tag == 40) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 42, input, this->mutable_mr_signer())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_reserved3;
+        break;
+      }
+
+      // repeated uint32 reserved3 = 6 [packed = true];
+      case 6: {
+        if (tag == 50) {
+         parse_reserved3:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_reserved3())));
+        } else if (tag == 48) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 50, input, this->mutable_reserved3())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_reserved4;
+        break;
+      }
+
+      // repeated uint32 reserved4 = 7 [packed = true];
+      case 7: {
+        if (tag == 58) {
+         parse_reserved4:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_reserved4())));
+        } else if (tag == 56) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 58, input, this->mutable_reserved4())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_report_data;
+        break;
+      }
+
+      // repeated uint32 report_data = 8 [packed = true];
+      case 8: {
+        if (tag == 66) {
+         parse_report_data:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_report_data())));
+        } else if (tag == 64) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 66, input, this->mutable_report_data())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_misc_select;
+        break;
+      }
+
+      // required uint32 misc_select = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_misc_select:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &misc_select_)));
+          set_has_misc_select();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_attributes;
+        break;
+      }
+
+      // required .protobuf_sgx_attributes_t attributes = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_attributes:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_attributes()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(88)) goto parse_isv_prod_id;
+        break;
+      }
+
+      // required uint32 isv_prod_id = 11;
+      case 11: {
+        if (tag == 88) {
+         parse_isv_prod_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &isv_prod_id_)));
+          set_has_isv_prod_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(96)) goto parse_isv_svn;
+        break;
+      }
+
+      // required uint32 isv_svn = 12;
+      case 12: {
+        if (tag == 96) {
+         parse_isv_svn:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &isv_svn_)));
+          set_has_isv_svn();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:protobuf_sgx_report_body_t)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:protobuf_sgx_report_body_t)
+  return false;
+#undef DO_
+}
+
+void protobuf_sgx_report_body_t::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:protobuf_sgx_report_body_t)
+  // repeated uint32 cpu_svn = 1 [packed = true];
+  if (this->cpu_svn_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_cpu_svn_cached_byte_size_);
+  }
+  for (int i = 0; i < this->cpu_svn_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->cpu_svn(i), output);
+  }
+
+  // repeated uint32 reserved1 = 2 [packed = true];
+  if (this->reserved1_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_reserved1_cached_byte_size_);
+  }
+  for (int i = 0; i < this->reserved1_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->reserved1(i), output);
+  }
+
+  // repeated uint32 mr_enclave = 3 [packed = true];
+  if (this->mr_enclave_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_mr_enclave_cached_byte_size_);
+  }
+  for (int i = 0; i < this->mr_enclave_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->mr_enclave(i), output);
+  }
+
+  // repeated uint32 reserved2 = 4 [packed = true];
+  if (this->reserved2_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_reserved2_cached_byte_size_);
+  }
+  for (int i = 0; i < this->reserved2_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->reserved2(i), output);
+  }
+
+  // repeated uint32 mr_signer = 5 [packed = true];
+  if (this->mr_signer_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_mr_signer_cached_byte_size_);
+  }
+  for (int i = 0; i < this->mr_signer_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->mr_signer(i), output);
+  }
+
+  // repeated uint32 reserved3 = 6 [packed = true];
+  if (this->reserved3_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_reserved3_cached_byte_size_);
+  }
+  for (int i = 0; i < this->reserved3_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->reserved3(i), output);
+  }
+
+  // repeated uint32 reserved4 = 7 [packed = true];
+  if (this->reserved4_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_reserved4_cached_byte_size_);
+  }
+  for (int i = 0; i < this->reserved4_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->reserved4(i), output);
+  }
+
+  // repeated uint32 report_data = 8 [packed = true];
+  if (this->report_data_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(8, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_report_data_cached_byte_size_);
+  }
+  for (int i = 0; i < this->report_data_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->report_data(i), output);
+  }
+
+  // required uint32 misc_select = 9;
+  if (has_misc_select()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->misc_select(), output);
+  }
+
+  // required .protobuf_sgx_attributes_t attributes = 10;
+  if (has_attributes()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      10, this->attributes(), output);
+  }
+
+  // required uint32 isv_prod_id = 11;
+  if (has_isv_prod_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->isv_prod_id(), output);
+  }
+
+  // required uint32 isv_svn = 12;
+  if (has_isv_svn()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(12, this->isv_svn(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:protobuf_sgx_report_body_t)
+}
+
+int protobuf_sgx_report_body_t::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // required uint32 misc_select = 9;
+    if (has_misc_select()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->misc_select());
+    }
+
+    // required .protobuf_sgx_attributes_t attributes = 10;
+    if (has_attributes()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->attributes());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // required uint32 isv_prod_id = 11;
+    if (has_isv_prod_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->isv_prod_id());
+    }
+
+    // required uint32 isv_svn = 12;
+    if (has_isv_svn()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->isv_svn());
+    }
+
+  }
+  // repeated uint32 cpu_svn = 1 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->cpu_svn_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->cpu_svn(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _cpu_svn_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 reserved1 = 2 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->reserved1_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->reserved1(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _reserved1_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 mr_enclave = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->mr_enclave_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->mr_enclave(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _mr_enclave_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 reserved2 = 4 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->reserved2_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->reserved2(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _reserved2_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 mr_signer = 5 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->mr_signer_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->mr_signer(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _mr_signer_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 reserved3 = 6 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->reserved3_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->reserved3(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _reserved3_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 reserved4 = 7 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->reserved4_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->reserved4(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _reserved4_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 report_data = 8 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->report_data_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->report_data(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _report_data_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void protobuf_sgx_report_body_t::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const protobuf_sgx_report_body_t*>(&from));
+}
+
+void protobuf_sgx_report_body_t::MergeFrom(const protobuf_sgx_report_body_t& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  cpu_svn_.MergeFrom(from.cpu_svn_);
+  reserved1_.MergeFrom(from.reserved1_);
+  mr_enclave_.MergeFrom(from.mr_enclave_);
+  reserved2_.MergeFrom(from.reserved2_);
+  mr_signer_.MergeFrom(from.mr_signer_);
+  reserved3_.MergeFrom(from.reserved3_);
+  reserved4_.MergeFrom(from.reserved4_);
+  report_data_.MergeFrom(from.report_data_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_misc_select()) {
+      set_misc_select(from.misc_select());
+    }
+    if (from.has_attributes()) {
+      mutable_attributes()->::protobuf_sgx_attributes_t::MergeFrom(from.attributes());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_isv_prod_id()) {
+      set_isv_prod_id(from.isv_prod_id());
+    }
+    if (from.has_isv_svn()) {
+      set_isv_svn(from.isv_svn());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void protobuf_sgx_report_body_t::CopyFrom(const protobuf_sgx_report_body_t& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool protobuf_sgx_report_body_t::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000030a) != 0x0000030a) return false;
+
+  if (has_attributes()) {
+    if (!this->attributes().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void protobuf_sgx_report_body_t::Swap(protobuf_sgx_report_body_t* other) {
+  if (other != this) {
+    cpu_svn_.Swap(&other->cpu_svn_);
+    std::swap(misc_select_, other->misc_select_);
+    reserved1_.Swap(&other->reserved1_);
+    std::swap(attributes_, other->attributes_);
+    mr_enclave_.Swap(&other->mr_enclave_);
+    reserved2_.Swap(&other->reserved2_);
+    mr_signer_.Swap(&other->mr_signer_);
+    reserved3_.Swap(&other->reserved3_);
+    std::swap(isv_prod_id_, other->isv_prod_id_);
+    std::swap(isv_svn_, other->isv_svn_);
+    reserved4_.Swap(&other->reserved4_);
+    report_data_.Swap(&other->report_data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string protobuf_sgx_report_body_t::GetTypeName() const {
+  return "protobuf_sgx_report_body_t";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int protobuf_sgx_report_t::kBodyFieldNumber;
+const int protobuf_sgx_report_t::kKeyIdFieldNumber;
+const int protobuf_sgx_report_t::kMacFieldNumber;
+#endif  // !_MSC_VER
+
+protobuf_sgx_report_t::protobuf_sgx_report_t()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:protobuf_sgx_report_t)
+}
+
+void protobuf_sgx_report_t::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  body_ = const_cast< ::protobuf_sgx_report_body_t*>(
+      ::protobuf_sgx_report_body_t::internal_default_instance());
+#else
+  body_ = const_cast< ::protobuf_sgx_report_body_t*>(&::protobuf_sgx_report_body_t::default_instance());
+#endif
+}
+
+protobuf_sgx_report_t::protobuf_sgx_report_t(const protobuf_sgx_report_t& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:protobuf_sgx_report_t)
+}
+
+void protobuf_sgx_report_t::SharedCtor() {
+  _cached_size_ = 0;
+  body_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+protobuf_sgx_report_t::~protobuf_sgx_report_t() {
+  // @@protoc_insertion_point(destructor:protobuf_sgx_report_t)
+  SharedDtor();
+}
+
+void protobuf_sgx_report_t::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete body_;
+  }
+}
+
+void protobuf_sgx_report_t::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const protobuf_sgx_report_t& protobuf_sgx_report_t::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_dhmsgs_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_dhmsgs_2eproto();
+#endif
+  return *default_instance_;
+}
+
+protobuf_sgx_report_t* protobuf_sgx_report_t::default_instance_ = NULL;
+
+protobuf_sgx_report_t* protobuf_sgx_report_t::New() const {
+  return new protobuf_sgx_report_t;
+}
+
+void protobuf_sgx_report_t::Clear() {
+  if (has_body()) {
+    if (body_ != NULL) body_->::protobuf_sgx_report_body_t::Clear();
+  }
+  key_id_.Clear();
+  mac_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool protobuf_sgx_report_t::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:protobuf_sgx_report_t)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .protobuf_sgx_report_body_t body = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_body()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_key_id;
+        break;
+      }
+
+      // repeated uint32 key_id = 2 [packed = true];
+      case 2: {
+        if (tag == 18) {
+         parse_key_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_key_id())));
+        } else if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 18, input, this->mutable_key_id())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_mac;
+        break;
+      }
+
+      // repeated uint32 mac = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_mac:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_mac())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_mac())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:protobuf_sgx_report_t)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:protobuf_sgx_report_t)
+  return false;
+#undef DO_
+}
+
+void protobuf_sgx_report_t::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:protobuf_sgx_report_t)
+  // required .protobuf_sgx_report_body_t body = 1;
+  if (has_body()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->body(), output);
+  }
+
+  // repeated uint32 key_id = 2 [packed = true];
+  if (this->key_id_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_key_id_cached_byte_size_);
+  }
+  for (int i = 0; i < this->key_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->key_id(i), output);
+  }
+
+  // repeated uint32 mac = 3 [packed = true];
+  if (this->mac_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_mac_cached_byte_size_);
+  }
+  for (int i = 0; i < this->mac_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->mac(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:protobuf_sgx_report_t)
+}
+
+int protobuf_sgx_report_t::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .protobuf_sgx_report_body_t body = 1;
+    if (has_body()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->body());
+    }
+
+  }
+  // repeated uint32 key_id = 2 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->key_id_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->key_id(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _key_id_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 mac = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->mac_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->mac(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _mac_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void protobuf_sgx_report_t::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const protobuf_sgx_report_t*>(&from));
+}
+
+void protobuf_sgx_report_t::MergeFrom(const protobuf_sgx_report_t& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  key_id_.MergeFrom(from.key_id_);
+  mac_.MergeFrom(from.mac_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_body()) {
+      mutable_body()->::protobuf_sgx_report_body_t::MergeFrom(from.body());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void protobuf_sgx_report_t::CopyFrom(const protobuf_sgx_report_t& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool protobuf_sgx_report_t::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_body()) {
+    if (!this->body().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void protobuf_sgx_report_t::Swap(protobuf_sgx_report_t* other) {
+  if (other != this) {
+    std::swap(body_, other->body_);
+    key_id_.Swap(&other->key_id_);
+    mac_.Swap(&other->mac_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string protobuf_sgx_report_t::GetTypeName() const {
+  return "protobuf_sgx_report_t";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int protobuf_sgx_target_info_t::kMrEnclaveFieldNumber;
+const int protobuf_sgx_target_info_t::kAttributesFieldNumber;
+const int protobuf_sgx_target_info_t::kReserved1FieldNumber;
+const int protobuf_sgx_target_info_t::kMiscSelectFieldNumber;
+const int protobuf_sgx_target_info_t::kReserved2FieldNumber;
+#endif  // !_MSC_VER
+
+protobuf_sgx_target_info_t::protobuf_sgx_target_info_t()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:protobuf_sgx_target_info_t)
+}
+
+void protobuf_sgx_target_info_t::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  attributes_ = const_cast< ::protobuf_sgx_attributes_t*>(
+      ::protobuf_sgx_attributes_t::internal_default_instance());
+#else
+  attributes_ = const_cast< ::protobuf_sgx_attributes_t*>(&::protobuf_sgx_attributes_t::default_instance());
+#endif
+}
+
+protobuf_sgx_target_info_t::protobuf_sgx_target_info_t(const protobuf_sgx_target_info_t& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:protobuf_sgx_target_info_t)
+}
+
+void protobuf_sgx_target_info_t::SharedCtor() {
+  _cached_size_ = 0;
+  attributes_ = NULL;
+  misc_select_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+protobuf_sgx_target_info_t::~protobuf_sgx_target_info_t() {
+  // @@protoc_insertion_point(destructor:protobuf_sgx_target_info_t)
+  SharedDtor();
+}
+
+void protobuf_sgx_target_info_t::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete attributes_;
+  }
+}
+
+void protobuf_sgx_target_info_t::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const protobuf_sgx_target_info_t& protobuf_sgx_target_info_t::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_dhmsgs_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_dhmsgs_2eproto();
+#endif
+  return *default_instance_;
+}
+
+protobuf_sgx_target_info_t* protobuf_sgx_target_info_t::default_instance_ = NULL;
+
+protobuf_sgx_target_info_t* protobuf_sgx_target_info_t::New() const {
+  return new protobuf_sgx_target_info_t;
+}
+
+void protobuf_sgx_target_info_t::Clear() {
+  if (_has_bits_[0 / 32] & 10) {
+    if (has_attributes()) {
+      if (attributes_ != NULL) attributes_->::protobuf_sgx_attributes_t::Clear();
+    }
+    misc_select_ = 0u;
+  }
+  mr_enclave_.Clear();
+  reserved1_.Clear();
+  reserved2_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool protobuf_sgx_target_info_t::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:protobuf_sgx_target_info_t)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated uint32 mr_enclave = 1 [packed = true];
+      case 1: {
+        if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_mr_enclave())));
+        } else if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 10, input, this->mutable_mr_enclave())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_reserved1;
+        break;
+      }
+
+      // repeated uint32 reserved1 = 2 [packed = true];
+      case 2: {
+        if (tag == 18) {
+         parse_reserved1:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_reserved1())));
+        } else if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 18, input, this->mutable_reserved1())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_reserved2;
+        break;
+      }
+
+      // repeated uint32 reserved2 = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_reserved2:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_reserved2())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_reserved2())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attributes;
+        break;
+      }
+
+      // required .protobuf_sgx_attributes_t attributes = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_attributes:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_attributes()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_misc_select;
+        break;
+      }
+
+      // required uint32 misc_select = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_misc_select:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &misc_select_)));
+          set_has_misc_select();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:protobuf_sgx_target_info_t)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:protobuf_sgx_target_info_t)
+  return false;
+#undef DO_
+}
+
+void protobuf_sgx_target_info_t::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:protobuf_sgx_target_info_t)
+  // repeated uint32 mr_enclave = 1 [packed = true];
+  if (this->mr_enclave_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_mr_enclave_cached_byte_size_);
+  }
+  for (int i = 0; i < this->mr_enclave_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->mr_enclave(i), output);
+  }
+
+  // repeated uint32 reserved1 = 2 [packed = true];
+  if (this->reserved1_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_reserved1_cached_byte_size_);
+  }
+  for (int i = 0; i < this->reserved1_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->reserved1(i), output);
+  }
+
+  // repeated uint32 reserved2 = 3 [packed = true];
+  if (this->reserved2_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_reserved2_cached_byte_size_);
+  }
+  for (int i = 0; i < this->reserved2_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->reserved2(i), output);
+  }
+
+  // required .protobuf_sgx_attributes_t attributes = 4;
+  if (has_attributes()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->attributes(), output);
+  }
+
+  // required uint32 misc_select = 5;
+  if (has_misc_select()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->misc_select(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:protobuf_sgx_target_info_t)
+}
+
+int protobuf_sgx_target_info_t::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // required .protobuf_sgx_attributes_t attributes = 4;
+    if (has_attributes()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->attributes());
+    }
+
+    // required uint32 misc_select = 5;
+    if (has_misc_select()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->misc_select());
+    }
+
+  }
+  // repeated uint32 mr_enclave = 1 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->mr_enclave_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->mr_enclave(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _mr_enclave_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 reserved1 = 2 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->reserved1_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->reserved1(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _reserved1_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 reserved2 = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->reserved2_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->reserved2(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _reserved2_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void protobuf_sgx_target_info_t::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const protobuf_sgx_target_info_t*>(&from));
+}
+
+void protobuf_sgx_target_info_t::MergeFrom(const protobuf_sgx_target_info_t& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mr_enclave_.MergeFrom(from.mr_enclave_);
+  reserved1_.MergeFrom(from.reserved1_);
+  reserved2_.MergeFrom(from.reserved2_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_attributes()) {
+      mutable_attributes()->::protobuf_sgx_attributes_t::MergeFrom(from.attributes());
+    }
+    if (from.has_misc_select()) {
+      set_misc_select(from.misc_select());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void protobuf_sgx_target_info_t::CopyFrom(const protobuf_sgx_target_info_t& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool protobuf_sgx_target_info_t::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000000a) != 0x0000000a) return false;
+
+  if (has_attributes()) {
+    if (!this->attributes().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void protobuf_sgx_target_info_t::Swap(protobuf_sgx_target_info_t* other) {
+  if (other != this) {
+    mr_enclave_.Swap(&other->mr_enclave_);
+    std::swap(attributes_, other->attributes_);
+    reserved1_.Swap(&other->reserved1_);
+    std::swap(misc_select_, other->misc_select_);
+    reserved2_.Swap(&other->reserved2_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string protobuf_sgx_target_info_t::GetTypeName() const {
+  return "protobuf_sgx_target_info_t";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int protobuf_sgx_dh_msg1_t::kGAFieldNumber;
+const int protobuf_sgx_dh_msg1_t::kTargetFieldNumber;
+#endif  // !_MSC_VER
+
+protobuf_sgx_dh_msg1_t::protobuf_sgx_dh_msg1_t()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:protobuf_sgx_dh_msg1_t)
+}
+
+void protobuf_sgx_dh_msg1_t::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  g_a_ = const_cast< ::protobuf_sgx_ec256_public_t*>(
+      ::protobuf_sgx_ec256_public_t::internal_default_instance());
+#else
+  g_a_ = const_cast< ::protobuf_sgx_ec256_public_t*>(&::protobuf_sgx_ec256_public_t::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  target_ = const_cast< ::protobuf_sgx_target_info_t*>(
+      ::protobuf_sgx_target_info_t::internal_default_instance());
+#else
+  target_ = const_cast< ::protobuf_sgx_target_info_t*>(&::protobuf_sgx_target_info_t::default_instance());
+#endif
+}
+
+protobuf_sgx_dh_msg1_t::protobuf_sgx_dh_msg1_t(const protobuf_sgx_dh_msg1_t& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:protobuf_sgx_dh_msg1_t)
+}
+
+void protobuf_sgx_dh_msg1_t::SharedCtor() {
+  _cached_size_ = 0;
+  g_a_ = NULL;
+  target_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+protobuf_sgx_dh_msg1_t::~protobuf_sgx_dh_msg1_t() {
+  // @@protoc_insertion_point(destructor:protobuf_sgx_dh_msg1_t)
+  SharedDtor();
+}
+
+void protobuf_sgx_dh_msg1_t::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete g_a_;
+    delete target_;
+  }
+}
+
+void protobuf_sgx_dh_msg1_t::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const protobuf_sgx_dh_msg1_t& protobuf_sgx_dh_msg1_t::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_dhmsgs_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_dhmsgs_2eproto();
+#endif
+  return *default_instance_;
+}
+
+protobuf_sgx_dh_msg1_t* protobuf_sgx_dh_msg1_t::default_instance_ = NULL;
+
+protobuf_sgx_dh_msg1_t* protobuf_sgx_dh_msg1_t::New() const {
+  return new protobuf_sgx_dh_msg1_t;
+}
+
+void protobuf_sgx_dh_msg1_t::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_g_a()) {
+      if (g_a_ != NULL) g_a_->::protobuf_sgx_ec256_public_t::Clear();
+    }
+    if (has_target()) {
+      if (target_ != NULL) target_->::protobuf_sgx_target_info_t::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool protobuf_sgx_dh_msg1_t::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:protobuf_sgx_dh_msg1_t)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .protobuf_sgx_ec256_public_t g_a = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_g_a()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target;
+        break;
+      }
+
+      // required .protobuf_sgx_target_info_t target = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:protobuf_sgx_dh_msg1_t)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:protobuf_sgx_dh_msg1_t)
+  return false;
+#undef DO_
+}
+
+void protobuf_sgx_dh_msg1_t::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:protobuf_sgx_dh_msg1_t)
+  // required .protobuf_sgx_ec256_public_t g_a = 1;
+  if (has_g_a()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->g_a(), output);
+  }
+
+  // required .protobuf_sgx_target_info_t target = 2;
+  if (has_target()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->target(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:protobuf_sgx_dh_msg1_t)
+}
+
+int protobuf_sgx_dh_msg1_t::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .protobuf_sgx_ec256_public_t g_a = 1;
+    if (has_g_a()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->g_a());
+    }
+
+    // required .protobuf_sgx_target_info_t target = 2;
+    if (has_target()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void protobuf_sgx_dh_msg1_t::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const protobuf_sgx_dh_msg1_t*>(&from));
+}
+
+void protobuf_sgx_dh_msg1_t::MergeFrom(const protobuf_sgx_dh_msg1_t& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_g_a()) {
+      mutable_g_a()->::protobuf_sgx_ec256_public_t::MergeFrom(from.g_a());
+    }
+    if (from.has_target()) {
+      mutable_target()->::protobuf_sgx_target_info_t::MergeFrom(from.target());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void protobuf_sgx_dh_msg1_t::CopyFrom(const protobuf_sgx_dh_msg1_t& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool protobuf_sgx_dh_msg1_t::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  if (has_target()) {
+    if (!this->target().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void protobuf_sgx_dh_msg1_t::Swap(protobuf_sgx_dh_msg1_t* other) {
+  if (other != this) {
+    std::swap(g_a_, other->g_a_);
+    std::swap(target_, other->target_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string protobuf_sgx_dh_msg1_t::GetTypeName() const {
+  return "protobuf_sgx_dh_msg1_t";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int protobuf_sgx_dh_msg2_t::kGBFieldNumber;
+const int protobuf_sgx_dh_msg2_t::kReportFieldNumber;
+const int protobuf_sgx_dh_msg2_t::kCmacFieldNumber;
+#endif  // !_MSC_VER
+
+protobuf_sgx_dh_msg2_t::protobuf_sgx_dh_msg2_t()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:protobuf_sgx_dh_msg2_t)
+}
+
+void protobuf_sgx_dh_msg2_t::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  g_b_ = const_cast< ::protobuf_sgx_ec256_public_t*>(
+      ::protobuf_sgx_ec256_public_t::internal_default_instance());
+#else
+  g_b_ = const_cast< ::protobuf_sgx_ec256_public_t*>(&::protobuf_sgx_ec256_public_t::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  report_ = const_cast< ::protobuf_sgx_report_t*>(
+      ::protobuf_sgx_report_t::internal_default_instance());
+#else
+  report_ = const_cast< ::protobuf_sgx_report_t*>(&::protobuf_sgx_report_t::default_instance());
+#endif
+}
+
+protobuf_sgx_dh_msg2_t::protobuf_sgx_dh_msg2_t(const protobuf_sgx_dh_msg2_t& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:protobuf_sgx_dh_msg2_t)
+}
+
+void protobuf_sgx_dh_msg2_t::SharedCtor() {
+  _cached_size_ = 0;
+  g_b_ = NULL;
+  report_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+protobuf_sgx_dh_msg2_t::~protobuf_sgx_dh_msg2_t() {
+  // @@protoc_insertion_point(destructor:protobuf_sgx_dh_msg2_t)
+  SharedDtor();
+}
+
+void protobuf_sgx_dh_msg2_t::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete g_b_;
+    delete report_;
+  }
+}
+
+void protobuf_sgx_dh_msg2_t::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const protobuf_sgx_dh_msg2_t& protobuf_sgx_dh_msg2_t::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_dhmsgs_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_dhmsgs_2eproto();
+#endif
+  return *default_instance_;
+}
+
+protobuf_sgx_dh_msg2_t* protobuf_sgx_dh_msg2_t::default_instance_ = NULL;
+
+protobuf_sgx_dh_msg2_t* protobuf_sgx_dh_msg2_t::New() const {
+  return new protobuf_sgx_dh_msg2_t;
+}
+
+void protobuf_sgx_dh_msg2_t::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_g_b()) {
+      if (g_b_ != NULL) g_b_->::protobuf_sgx_ec256_public_t::Clear();
+    }
+    if (has_report()) {
+      if (report_ != NULL) report_->::protobuf_sgx_report_t::Clear();
+    }
+  }
+  cmac_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool protobuf_sgx_dh_msg2_t::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:protobuf_sgx_dh_msg2_t)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .protobuf_sgx_ec256_public_t g_b = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_g_b()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_report;
+        break;
+      }
+
+      // required .protobuf_sgx_report_t report = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_report:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_report()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_cmac;
+        break;
+      }
+
+      // repeated uint32 cmac = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_cmac:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_cmac())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_cmac())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:protobuf_sgx_dh_msg2_t)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:protobuf_sgx_dh_msg2_t)
+  return false;
+#undef DO_
+}
+
+void protobuf_sgx_dh_msg2_t::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:protobuf_sgx_dh_msg2_t)
+  // required .protobuf_sgx_ec256_public_t g_b = 1;
+  if (has_g_b()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->g_b(), output);
+  }
+
+  // required .protobuf_sgx_report_t report = 2;
+  if (has_report()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->report(), output);
+  }
+
+  // repeated uint32 cmac = 3 [packed = true];
+  if (this->cmac_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_cmac_cached_byte_size_);
+  }
+  for (int i = 0; i < this->cmac_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->cmac(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:protobuf_sgx_dh_msg2_t)
+}
+
+int protobuf_sgx_dh_msg2_t::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .protobuf_sgx_ec256_public_t g_b = 1;
+    if (has_g_b()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->g_b());
+    }
+
+    // required .protobuf_sgx_report_t report = 2;
+    if (has_report()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->report());
+    }
+
+  }
+  // repeated uint32 cmac = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->cmac_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->cmac(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _cmac_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void protobuf_sgx_dh_msg2_t::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const protobuf_sgx_dh_msg2_t*>(&from));
+}
+
+void protobuf_sgx_dh_msg2_t::MergeFrom(const protobuf_sgx_dh_msg2_t& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  cmac_.MergeFrom(from.cmac_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_g_b()) {
+      mutable_g_b()->::protobuf_sgx_ec256_public_t::MergeFrom(from.g_b());
+    }
+    if (from.has_report()) {
+      mutable_report()->::protobuf_sgx_report_t::MergeFrom(from.report());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void protobuf_sgx_dh_msg2_t::CopyFrom(const protobuf_sgx_dh_msg2_t& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool protobuf_sgx_dh_msg2_t::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  if (has_report()) {
+    if (!this->report().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void protobuf_sgx_dh_msg2_t::Swap(protobuf_sgx_dh_msg2_t* other) {
+  if (other != this) {
+    std::swap(g_b_, other->g_b_);
+    std::swap(report_, other->report_);
+    cmac_.Swap(&other->cmac_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string protobuf_sgx_dh_msg2_t::GetTypeName() const {
+  return "protobuf_sgx_dh_msg2_t";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int protobuf_sgx_dh_msg3_body_t::kReportFieldNumber;
+const int protobuf_sgx_dh_msg3_body_t::kAdditionalPropFieldNumber;
+#endif  // !_MSC_VER
+
+protobuf_sgx_dh_msg3_body_t::protobuf_sgx_dh_msg3_body_t()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:protobuf_sgx_dh_msg3_body_t)
+}
+
+void protobuf_sgx_dh_msg3_body_t::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  report_ = const_cast< ::protobuf_sgx_report_t*>(
+      ::protobuf_sgx_report_t::internal_default_instance());
+#else
+  report_ = const_cast< ::protobuf_sgx_report_t*>(&::protobuf_sgx_report_t::default_instance());
+#endif
+}
+
+protobuf_sgx_dh_msg3_body_t::protobuf_sgx_dh_msg3_body_t(const protobuf_sgx_dh_msg3_body_t& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:protobuf_sgx_dh_msg3_body_t)
+}
+
+void protobuf_sgx_dh_msg3_body_t::SharedCtor() {
+  _cached_size_ = 0;
+  report_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+protobuf_sgx_dh_msg3_body_t::~protobuf_sgx_dh_msg3_body_t() {
+  // @@protoc_insertion_point(destructor:protobuf_sgx_dh_msg3_body_t)
+  SharedDtor();
+}
+
+void protobuf_sgx_dh_msg3_body_t::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete report_;
+  }
+}
+
+void protobuf_sgx_dh_msg3_body_t::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const protobuf_sgx_dh_msg3_body_t& protobuf_sgx_dh_msg3_body_t::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_dhmsgs_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_dhmsgs_2eproto();
+#endif
+  return *default_instance_;
+}
+
+protobuf_sgx_dh_msg3_body_t* protobuf_sgx_dh_msg3_body_t::default_instance_ = NULL;
+
+protobuf_sgx_dh_msg3_body_t* protobuf_sgx_dh_msg3_body_t::New() const {
+  return new protobuf_sgx_dh_msg3_body_t;
+}
+
+void protobuf_sgx_dh_msg3_body_t::Clear() {
+  if (has_report()) {
+    if (report_ != NULL) report_->::protobuf_sgx_report_t::Clear();
+  }
+  additional_prop_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool protobuf_sgx_dh_msg3_body_t::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:protobuf_sgx_dh_msg3_body_t)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .protobuf_sgx_report_t report = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_report()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_additional_prop;
+        break;
+      }
+
+      // repeated uint32 additional_prop = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_additional_prop:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 16, input, this->mutable_additional_prop())));
+        } else if (tag == 18) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_additional_prop())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_additional_prop;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:protobuf_sgx_dh_msg3_body_t)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:protobuf_sgx_dh_msg3_body_t)
+  return false;
+#undef DO_
+}
+
+void protobuf_sgx_dh_msg3_body_t::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:protobuf_sgx_dh_msg3_body_t)
+  // required .protobuf_sgx_report_t report = 1;
+  if (has_report()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->report(), output);
+  }
+
+  // repeated uint32 additional_prop = 2;
+  for (int i = 0; i < this->additional_prop_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
+      2, this->additional_prop(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:protobuf_sgx_dh_msg3_body_t)
+}
+
+int protobuf_sgx_dh_msg3_body_t::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .protobuf_sgx_report_t report = 1;
+    if (has_report()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->report());
+    }
+
+  }
+  // repeated uint32 additional_prop = 2;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->additional_prop_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->additional_prop(i));
+    }
+    total_size += 1 * this->additional_prop_size() + data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void protobuf_sgx_dh_msg3_body_t::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const protobuf_sgx_dh_msg3_body_t*>(&from));
+}
+
+void protobuf_sgx_dh_msg3_body_t::MergeFrom(const protobuf_sgx_dh_msg3_body_t& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  additional_prop_.MergeFrom(from.additional_prop_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_report()) {
+      mutable_report()->::protobuf_sgx_report_t::MergeFrom(from.report());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void protobuf_sgx_dh_msg3_body_t::CopyFrom(const protobuf_sgx_dh_msg3_body_t& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool protobuf_sgx_dh_msg3_body_t::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_report()) {
+    if (!this->report().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void protobuf_sgx_dh_msg3_body_t::Swap(protobuf_sgx_dh_msg3_body_t* other) {
+  if (other != this) {
+    std::swap(report_, other->report_);
+    additional_prop_.Swap(&other->additional_prop_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string protobuf_sgx_dh_msg3_body_t::GetTypeName() const {
+  return "protobuf_sgx_dh_msg3_body_t";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int protobuf_sgx_dh_msg3_t::kMsg3BodyFieldNumber;
+const int protobuf_sgx_dh_msg3_t::kCmacFieldNumber;
+#endif  // !_MSC_VER
+
+protobuf_sgx_dh_msg3_t::protobuf_sgx_dh_msg3_t()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:protobuf_sgx_dh_msg3_t)
+}
+
+void protobuf_sgx_dh_msg3_t::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  msg3_body_ = const_cast< ::protobuf_sgx_dh_msg3_body_t*>(
+      ::protobuf_sgx_dh_msg3_body_t::internal_default_instance());
+#else
+  msg3_body_ = const_cast< ::protobuf_sgx_dh_msg3_body_t*>(&::protobuf_sgx_dh_msg3_body_t::default_instance());
+#endif
+}
+
+protobuf_sgx_dh_msg3_t::protobuf_sgx_dh_msg3_t(const protobuf_sgx_dh_msg3_t& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:protobuf_sgx_dh_msg3_t)
+}
+
+void protobuf_sgx_dh_msg3_t::SharedCtor() {
+  _cached_size_ = 0;
+  msg3_body_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+protobuf_sgx_dh_msg3_t::~protobuf_sgx_dh_msg3_t() {
+  // @@protoc_insertion_point(destructor:protobuf_sgx_dh_msg3_t)
+  SharedDtor();
+}
+
+void protobuf_sgx_dh_msg3_t::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete msg3_body_;
+  }
+}
+
+void protobuf_sgx_dh_msg3_t::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const protobuf_sgx_dh_msg3_t& protobuf_sgx_dh_msg3_t::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_dhmsgs_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_dhmsgs_2eproto();
+#endif
+  return *default_instance_;
+}
+
+protobuf_sgx_dh_msg3_t* protobuf_sgx_dh_msg3_t::default_instance_ = NULL;
+
+protobuf_sgx_dh_msg3_t* protobuf_sgx_dh_msg3_t::New() const {
+  return new protobuf_sgx_dh_msg3_t;
+}
+
+void protobuf_sgx_dh_msg3_t::Clear() {
+  if (has_msg3_body()) {
+    if (msg3_body_ != NULL) msg3_body_->::protobuf_sgx_dh_msg3_body_t::Clear();
+  }
+  cmac_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool protobuf_sgx_dh_msg3_t::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:protobuf_sgx_dh_msg3_t)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .protobuf_sgx_dh_msg3_body_t msg3_body = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_msg3_body()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_cmac;
+        break;
+      }
+
+      // repeated uint32 cmac = 2 [packed = true];
+      case 2: {
+        if (tag == 18) {
+         parse_cmac:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_cmac())));
+        } else if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 18, input, this->mutable_cmac())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:protobuf_sgx_dh_msg3_t)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:protobuf_sgx_dh_msg3_t)
+  return false;
+#undef DO_
+}
+
+void protobuf_sgx_dh_msg3_t::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:protobuf_sgx_dh_msg3_t)
+  // required .protobuf_sgx_dh_msg3_body_t msg3_body = 1;
+  if (has_msg3_body()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->msg3_body(), output);
+  }
+
+  // repeated uint32 cmac = 2 [packed = true];
+  if (this->cmac_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_cmac_cached_byte_size_);
+  }
+  for (int i = 0; i < this->cmac_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->cmac(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:protobuf_sgx_dh_msg3_t)
+}
+
+int protobuf_sgx_dh_msg3_t::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .protobuf_sgx_dh_msg3_body_t msg3_body = 1;
+    if (has_msg3_body()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->msg3_body());
+    }
+
+  }
+  // repeated uint32 cmac = 2 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->cmac_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->cmac(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _cmac_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void protobuf_sgx_dh_msg3_t::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const protobuf_sgx_dh_msg3_t*>(&from));
+}
+
+void protobuf_sgx_dh_msg3_t::MergeFrom(const protobuf_sgx_dh_msg3_t& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  cmac_.MergeFrom(from.cmac_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_msg3_body()) {
+      mutable_msg3_body()->::protobuf_sgx_dh_msg3_body_t::MergeFrom(from.msg3_body());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void protobuf_sgx_dh_msg3_t::CopyFrom(const protobuf_sgx_dh_msg3_t& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool protobuf_sgx_dh_msg3_t::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_msg3_body()) {
+    if (!this->msg3_body().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void protobuf_sgx_dh_msg3_t::Swap(protobuf_sgx_dh_msg3_t* other) {
+  if (other != this) {
+    std::swap(msg3_body_, other->msg3_body_);
+    cmac_.Swap(&other->cmac_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string protobuf_sgx_dh_msg3_t::GetTypeName() const {
+  return "protobuf_sgx_dh_msg3_t";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+// @@protoc_insertion_point(global_scope)

+ 2324 - 0
App/dhmsgs.pb.h

@@ -0,0 +1,2324 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: dhmsgs.proto
+
+#ifndef PROTOBUF_dhmsgs_2eproto__INCLUDED
+#define PROTOBUF_dhmsgs_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+// @@protoc_insertion_point(includes)
+
+// Internal implementation detail -- do not call these.
+void  protobuf_AddDesc_dhmsgs_2eproto();
+void protobuf_AssignDesc_dhmsgs_2eproto();
+void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+class protobuf_sgx_attributes_t;
+class protobuf_sgx_ec256_public_t;
+class protobuf_sgx_report_body_t;
+class protobuf_sgx_report_t;
+class protobuf_sgx_target_info_t;
+class protobuf_sgx_dh_msg1_t;
+class protobuf_sgx_dh_msg2_t;
+class protobuf_sgx_dh_msg3_body_t;
+class protobuf_sgx_dh_msg3_t;
+
+// ===================================================================
+
+class protobuf_sgx_attributes_t : public ::google::protobuf::MessageLite {
+ public:
+  protobuf_sgx_attributes_t();
+  virtual ~protobuf_sgx_attributes_t();
+
+  protobuf_sgx_attributes_t(const protobuf_sgx_attributes_t& from);
+
+  inline protobuf_sgx_attributes_t& operator=(const protobuf_sgx_attributes_t& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const protobuf_sgx_attributes_t& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const protobuf_sgx_attributes_t* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(protobuf_sgx_attributes_t* other);
+
+  // implements Message ----------------------------------------------
+
+  protobuf_sgx_attributes_t* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const protobuf_sgx_attributes_t& from);
+  void MergeFrom(const protobuf_sgx_attributes_t& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required uint64 flags = 1;
+  inline bool has_flags() const;
+  inline void clear_flags();
+  static const int kFlagsFieldNumber = 1;
+  inline ::google::protobuf::uint64 flags() const;
+  inline void set_flags(::google::protobuf::uint64 value);
+
+  // required uint64 xfrm = 2;
+  inline bool has_xfrm() const;
+  inline void clear_xfrm();
+  static const int kXfrmFieldNumber = 2;
+  inline ::google::protobuf::uint64 xfrm() const;
+  inline void set_xfrm(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:protobuf_sgx_attributes_t)
+ private:
+  inline void set_has_flags();
+  inline void clear_has_flags();
+  inline void set_has_xfrm();
+  inline void clear_has_xfrm();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 flags_;
+  ::google::protobuf::uint64 xfrm_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_dhmsgs_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_dhmsgs_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_dhmsgs_2eproto();
+  friend void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+  void InitAsDefaultInstance();
+  static protobuf_sgx_attributes_t* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class protobuf_sgx_ec256_public_t : public ::google::protobuf::MessageLite {
+ public:
+  protobuf_sgx_ec256_public_t();
+  virtual ~protobuf_sgx_ec256_public_t();
+
+  protobuf_sgx_ec256_public_t(const protobuf_sgx_ec256_public_t& from);
+
+  inline protobuf_sgx_ec256_public_t& operator=(const protobuf_sgx_ec256_public_t& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const protobuf_sgx_ec256_public_t& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const protobuf_sgx_ec256_public_t* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(protobuf_sgx_ec256_public_t* other);
+
+  // implements Message ----------------------------------------------
+
+  protobuf_sgx_ec256_public_t* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const protobuf_sgx_ec256_public_t& from);
+  void MergeFrom(const protobuf_sgx_ec256_public_t& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated uint32 gx = 1 [packed = true];
+  inline int gx_size() const;
+  inline void clear_gx();
+  static const int kGxFieldNumber = 1;
+  inline ::google::protobuf::uint32 gx(int index) const;
+  inline void set_gx(int index, ::google::protobuf::uint32 value);
+  inline void add_gx(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      gx() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_gx();
+
+  // repeated uint32 gy = 2 [packed = true];
+  inline int gy_size() const;
+  inline void clear_gy();
+  static const int kGyFieldNumber = 2;
+  inline ::google::protobuf::uint32 gy(int index) const;
+  inline void set_gy(int index, ::google::protobuf::uint32 value);
+  inline void add_gy(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      gy() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_gy();
+
+  // @@protoc_insertion_point(class_scope:protobuf_sgx_ec256_public_t)
+ private:
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > gx_;
+  mutable int _gx_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > gy_;
+  mutable int _gy_cached_byte_size_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_dhmsgs_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_dhmsgs_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_dhmsgs_2eproto();
+  friend void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+  void InitAsDefaultInstance();
+  static protobuf_sgx_ec256_public_t* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class protobuf_sgx_report_body_t : public ::google::protobuf::MessageLite {
+ public:
+  protobuf_sgx_report_body_t();
+  virtual ~protobuf_sgx_report_body_t();
+
+  protobuf_sgx_report_body_t(const protobuf_sgx_report_body_t& from);
+
+  inline protobuf_sgx_report_body_t& operator=(const protobuf_sgx_report_body_t& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const protobuf_sgx_report_body_t& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const protobuf_sgx_report_body_t* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(protobuf_sgx_report_body_t* other);
+
+  // implements Message ----------------------------------------------
+
+  protobuf_sgx_report_body_t* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const protobuf_sgx_report_body_t& from);
+  void MergeFrom(const protobuf_sgx_report_body_t& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated uint32 cpu_svn = 1 [packed = true];
+  inline int cpu_svn_size() const;
+  inline void clear_cpu_svn();
+  static const int kCpuSvnFieldNumber = 1;
+  inline ::google::protobuf::uint32 cpu_svn(int index) const;
+  inline void set_cpu_svn(int index, ::google::protobuf::uint32 value);
+  inline void add_cpu_svn(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      cpu_svn() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_cpu_svn();
+
+  // required uint32 misc_select = 9;
+  inline bool has_misc_select() const;
+  inline void clear_misc_select();
+  static const int kMiscSelectFieldNumber = 9;
+  inline ::google::protobuf::uint32 misc_select() const;
+  inline void set_misc_select(::google::protobuf::uint32 value);
+
+  // repeated uint32 reserved1 = 2 [packed = true];
+  inline int reserved1_size() const;
+  inline void clear_reserved1();
+  static const int kReserved1FieldNumber = 2;
+  inline ::google::protobuf::uint32 reserved1(int index) const;
+  inline void set_reserved1(int index, ::google::protobuf::uint32 value);
+  inline void add_reserved1(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      reserved1() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_reserved1();
+
+  // required .protobuf_sgx_attributes_t attributes = 10;
+  inline bool has_attributes() const;
+  inline void clear_attributes();
+  static const int kAttributesFieldNumber = 10;
+  inline const ::protobuf_sgx_attributes_t& attributes() const;
+  inline ::protobuf_sgx_attributes_t* mutable_attributes();
+  inline ::protobuf_sgx_attributes_t* release_attributes();
+  inline void set_allocated_attributes(::protobuf_sgx_attributes_t* attributes);
+
+  // repeated uint32 mr_enclave = 3 [packed = true];
+  inline int mr_enclave_size() const;
+  inline void clear_mr_enclave();
+  static const int kMrEnclaveFieldNumber = 3;
+  inline ::google::protobuf::uint32 mr_enclave(int index) const;
+  inline void set_mr_enclave(int index, ::google::protobuf::uint32 value);
+  inline void add_mr_enclave(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      mr_enclave() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_mr_enclave();
+
+  // repeated uint32 reserved2 = 4 [packed = true];
+  inline int reserved2_size() const;
+  inline void clear_reserved2();
+  static const int kReserved2FieldNumber = 4;
+  inline ::google::protobuf::uint32 reserved2(int index) const;
+  inline void set_reserved2(int index, ::google::protobuf::uint32 value);
+  inline void add_reserved2(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      reserved2() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_reserved2();
+
+  // repeated uint32 mr_signer = 5 [packed = true];
+  inline int mr_signer_size() const;
+  inline void clear_mr_signer();
+  static const int kMrSignerFieldNumber = 5;
+  inline ::google::protobuf::uint32 mr_signer(int index) const;
+  inline void set_mr_signer(int index, ::google::protobuf::uint32 value);
+  inline void add_mr_signer(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      mr_signer() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_mr_signer();
+
+  // repeated uint32 reserved3 = 6 [packed = true];
+  inline int reserved3_size() const;
+  inline void clear_reserved3();
+  static const int kReserved3FieldNumber = 6;
+  inline ::google::protobuf::uint32 reserved3(int index) const;
+  inline void set_reserved3(int index, ::google::protobuf::uint32 value);
+  inline void add_reserved3(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      reserved3() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_reserved3();
+
+  // required uint32 isv_prod_id = 11;
+  inline bool has_isv_prod_id() const;
+  inline void clear_isv_prod_id();
+  static const int kIsvProdIdFieldNumber = 11;
+  inline ::google::protobuf::uint32 isv_prod_id() const;
+  inline void set_isv_prod_id(::google::protobuf::uint32 value);
+
+  // required uint32 isv_svn = 12;
+  inline bool has_isv_svn() const;
+  inline void clear_isv_svn();
+  static const int kIsvSvnFieldNumber = 12;
+  inline ::google::protobuf::uint32 isv_svn() const;
+  inline void set_isv_svn(::google::protobuf::uint32 value);
+
+  // repeated uint32 reserved4 = 7 [packed = true];
+  inline int reserved4_size() const;
+  inline void clear_reserved4();
+  static const int kReserved4FieldNumber = 7;
+  inline ::google::protobuf::uint32 reserved4(int index) const;
+  inline void set_reserved4(int index, ::google::protobuf::uint32 value);
+  inline void add_reserved4(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      reserved4() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_reserved4();
+
+  // repeated uint32 report_data = 8 [packed = true];
+  inline int report_data_size() const;
+  inline void clear_report_data();
+  static const int kReportDataFieldNumber = 8;
+  inline ::google::protobuf::uint32 report_data(int index) const;
+  inline void set_report_data(int index, ::google::protobuf::uint32 value);
+  inline void add_report_data(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      report_data() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_report_data();
+
+  // @@protoc_insertion_point(class_scope:protobuf_sgx_report_body_t)
+ private:
+  inline void set_has_misc_select();
+  inline void clear_has_misc_select();
+  inline void set_has_attributes();
+  inline void clear_has_attributes();
+  inline void set_has_isv_prod_id();
+  inline void clear_has_isv_prod_id();
+  inline void set_has_isv_svn();
+  inline void clear_has_isv_svn();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > cpu_svn_;
+  mutable int _cpu_svn_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > reserved1_;
+  mutable int _reserved1_cached_byte_size_;
+  ::protobuf_sgx_attributes_t* attributes_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > mr_enclave_;
+  mutable int _mr_enclave_cached_byte_size_;
+  ::google::protobuf::uint32 misc_select_;
+  ::google::protobuf::uint32 isv_prod_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > reserved2_;
+  mutable int _reserved2_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > mr_signer_;
+  mutable int _mr_signer_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > reserved3_;
+  mutable int _reserved3_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > reserved4_;
+  mutable int _reserved4_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > report_data_;
+  mutable int _report_data_cached_byte_size_;
+  ::google::protobuf::uint32 isv_svn_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_dhmsgs_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_dhmsgs_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_dhmsgs_2eproto();
+  friend void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+  void InitAsDefaultInstance();
+  static protobuf_sgx_report_body_t* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class protobuf_sgx_report_t : public ::google::protobuf::MessageLite {
+ public:
+  protobuf_sgx_report_t();
+  virtual ~protobuf_sgx_report_t();
+
+  protobuf_sgx_report_t(const protobuf_sgx_report_t& from);
+
+  inline protobuf_sgx_report_t& operator=(const protobuf_sgx_report_t& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const protobuf_sgx_report_t& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const protobuf_sgx_report_t* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(protobuf_sgx_report_t* other);
+
+  // implements Message ----------------------------------------------
+
+  protobuf_sgx_report_t* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const protobuf_sgx_report_t& from);
+  void MergeFrom(const protobuf_sgx_report_t& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .protobuf_sgx_report_body_t body = 1;
+  inline bool has_body() const;
+  inline void clear_body();
+  static const int kBodyFieldNumber = 1;
+  inline const ::protobuf_sgx_report_body_t& body() const;
+  inline ::protobuf_sgx_report_body_t* mutable_body();
+  inline ::protobuf_sgx_report_body_t* release_body();
+  inline void set_allocated_body(::protobuf_sgx_report_body_t* body);
+
+  // repeated uint32 key_id = 2 [packed = true];
+  inline int key_id_size() const;
+  inline void clear_key_id();
+  static const int kKeyIdFieldNumber = 2;
+  inline ::google::protobuf::uint32 key_id(int index) const;
+  inline void set_key_id(int index, ::google::protobuf::uint32 value);
+  inline void add_key_id(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      key_id() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_key_id();
+
+  // repeated uint32 mac = 3 [packed = true];
+  inline int mac_size() const;
+  inline void clear_mac();
+  static const int kMacFieldNumber = 3;
+  inline ::google::protobuf::uint32 mac(int index) const;
+  inline void set_mac(int index, ::google::protobuf::uint32 value);
+  inline void add_mac(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      mac() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_mac();
+
+  // @@protoc_insertion_point(class_scope:protobuf_sgx_report_t)
+ private:
+  inline void set_has_body();
+  inline void clear_has_body();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::protobuf_sgx_report_body_t* body_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > key_id_;
+  mutable int _key_id_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > mac_;
+  mutable int _mac_cached_byte_size_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_dhmsgs_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_dhmsgs_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_dhmsgs_2eproto();
+  friend void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+  void InitAsDefaultInstance();
+  static protobuf_sgx_report_t* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class protobuf_sgx_target_info_t : public ::google::protobuf::MessageLite {
+ public:
+  protobuf_sgx_target_info_t();
+  virtual ~protobuf_sgx_target_info_t();
+
+  protobuf_sgx_target_info_t(const protobuf_sgx_target_info_t& from);
+
+  inline protobuf_sgx_target_info_t& operator=(const protobuf_sgx_target_info_t& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const protobuf_sgx_target_info_t& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const protobuf_sgx_target_info_t* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(protobuf_sgx_target_info_t* other);
+
+  // implements Message ----------------------------------------------
+
+  protobuf_sgx_target_info_t* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const protobuf_sgx_target_info_t& from);
+  void MergeFrom(const protobuf_sgx_target_info_t& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated uint32 mr_enclave = 1 [packed = true];
+  inline int mr_enclave_size() const;
+  inline void clear_mr_enclave();
+  static const int kMrEnclaveFieldNumber = 1;
+  inline ::google::protobuf::uint32 mr_enclave(int index) const;
+  inline void set_mr_enclave(int index, ::google::protobuf::uint32 value);
+  inline void add_mr_enclave(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      mr_enclave() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_mr_enclave();
+
+  // required .protobuf_sgx_attributes_t attributes = 4;
+  inline bool has_attributes() const;
+  inline void clear_attributes();
+  static const int kAttributesFieldNumber = 4;
+  inline const ::protobuf_sgx_attributes_t& attributes() const;
+  inline ::protobuf_sgx_attributes_t* mutable_attributes();
+  inline ::protobuf_sgx_attributes_t* release_attributes();
+  inline void set_allocated_attributes(::protobuf_sgx_attributes_t* attributes);
+
+  // repeated uint32 reserved1 = 2 [packed = true];
+  inline int reserved1_size() const;
+  inline void clear_reserved1();
+  static const int kReserved1FieldNumber = 2;
+  inline ::google::protobuf::uint32 reserved1(int index) const;
+  inline void set_reserved1(int index, ::google::protobuf::uint32 value);
+  inline void add_reserved1(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      reserved1() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_reserved1();
+
+  // required uint32 misc_select = 5;
+  inline bool has_misc_select() const;
+  inline void clear_misc_select();
+  static const int kMiscSelectFieldNumber = 5;
+  inline ::google::protobuf::uint32 misc_select() const;
+  inline void set_misc_select(::google::protobuf::uint32 value);
+
+  // repeated uint32 reserved2 = 3 [packed = true];
+  inline int reserved2_size() const;
+  inline void clear_reserved2();
+  static const int kReserved2FieldNumber = 3;
+  inline ::google::protobuf::uint32 reserved2(int index) const;
+  inline void set_reserved2(int index, ::google::protobuf::uint32 value);
+  inline void add_reserved2(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      reserved2() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_reserved2();
+
+  // @@protoc_insertion_point(class_scope:protobuf_sgx_target_info_t)
+ private:
+  inline void set_has_attributes();
+  inline void clear_has_attributes();
+  inline void set_has_misc_select();
+  inline void clear_has_misc_select();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > mr_enclave_;
+  mutable int _mr_enclave_cached_byte_size_;
+  ::protobuf_sgx_attributes_t* attributes_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > reserved1_;
+  mutable int _reserved1_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > reserved2_;
+  mutable int _reserved2_cached_byte_size_;
+  ::google::protobuf::uint32 misc_select_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_dhmsgs_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_dhmsgs_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_dhmsgs_2eproto();
+  friend void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+  void InitAsDefaultInstance();
+  static protobuf_sgx_target_info_t* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class protobuf_sgx_dh_msg1_t : public ::google::protobuf::MessageLite {
+ public:
+  protobuf_sgx_dh_msg1_t();
+  virtual ~protobuf_sgx_dh_msg1_t();
+
+  protobuf_sgx_dh_msg1_t(const protobuf_sgx_dh_msg1_t& from);
+
+  inline protobuf_sgx_dh_msg1_t& operator=(const protobuf_sgx_dh_msg1_t& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const protobuf_sgx_dh_msg1_t& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const protobuf_sgx_dh_msg1_t* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(protobuf_sgx_dh_msg1_t* other);
+
+  // implements Message ----------------------------------------------
+
+  protobuf_sgx_dh_msg1_t* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const protobuf_sgx_dh_msg1_t& from);
+  void MergeFrom(const protobuf_sgx_dh_msg1_t& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .protobuf_sgx_ec256_public_t g_a = 1;
+  inline bool has_g_a() const;
+  inline void clear_g_a();
+  static const int kGAFieldNumber = 1;
+  inline const ::protobuf_sgx_ec256_public_t& g_a() const;
+  inline ::protobuf_sgx_ec256_public_t* mutable_g_a();
+  inline ::protobuf_sgx_ec256_public_t* release_g_a();
+  inline void set_allocated_g_a(::protobuf_sgx_ec256_public_t* g_a);
+
+  // required .protobuf_sgx_target_info_t target = 2;
+  inline bool has_target() const;
+  inline void clear_target();
+  static const int kTargetFieldNumber = 2;
+  inline const ::protobuf_sgx_target_info_t& target() const;
+  inline ::protobuf_sgx_target_info_t* mutable_target();
+  inline ::protobuf_sgx_target_info_t* release_target();
+  inline void set_allocated_target(::protobuf_sgx_target_info_t* target);
+
+  // @@protoc_insertion_point(class_scope:protobuf_sgx_dh_msg1_t)
+ private:
+  inline void set_has_g_a();
+  inline void clear_has_g_a();
+  inline void set_has_target();
+  inline void clear_has_target();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::protobuf_sgx_ec256_public_t* g_a_;
+  ::protobuf_sgx_target_info_t* target_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_dhmsgs_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_dhmsgs_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_dhmsgs_2eproto();
+  friend void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+  void InitAsDefaultInstance();
+  static protobuf_sgx_dh_msg1_t* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class protobuf_sgx_dh_msg2_t : public ::google::protobuf::MessageLite {
+ public:
+  protobuf_sgx_dh_msg2_t();
+  virtual ~protobuf_sgx_dh_msg2_t();
+
+  protobuf_sgx_dh_msg2_t(const protobuf_sgx_dh_msg2_t& from);
+
+  inline protobuf_sgx_dh_msg2_t& operator=(const protobuf_sgx_dh_msg2_t& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const protobuf_sgx_dh_msg2_t& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const protobuf_sgx_dh_msg2_t* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(protobuf_sgx_dh_msg2_t* other);
+
+  // implements Message ----------------------------------------------
+
+  protobuf_sgx_dh_msg2_t* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const protobuf_sgx_dh_msg2_t& from);
+  void MergeFrom(const protobuf_sgx_dh_msg2_t& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .protobuf_sgx_ec256_public_t g_b = 1;
+  inline bool has_g_b() const;
+  inline void clear_g_b();
+  static const int kGBFieldNumber = 1;
+  inline const ::protobuf_sgx_ec256_public_t& g_b() const;
+  inline ::protobuf_sgx_ec256_public_t* mutable_g_b();
+  inline ::protobuf_sgx_ec256_public_t* release_g_b();
+  inline void set_allocated_g_b(::protobuf_sgx_ec256_public_t* g_b);
+
+  // required .protobuf_sgx_report_t report = 2;
+  inline bool has_report() const;
+  inline void clear_report();
+  static const int kReportFieldNumber = 2;
+  inline const ::protobuf_sgx_report_t& report() const;
+  inline ::protobuf_sgx_report_t* mutable_report();
+  inline ::protobuf_sgx_report_t* release_report();
+  inline void set_allocated_report(::protobuf_sgx_report_t* report);
+
+  // repeated uint32 cmac = 3 [packed = true];
+  inline int cmac_size() const;
+  inline void clear_cmac();
+  static const int kCmacFieldNumber = 3;
+  inline ::google::protobuf::uint32 cmac(int index) const;
+  inline void set_cmac(int index, ::google::protobuf::uint32 value);
+  inline void add_cmac(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      cmac() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_cmac();
+
+  // @@protoc_insertion_point(class_scope:protobuf_sgx_dh_msg2_t)
+ private:
+  inline void set_has_g_b();
+  inline void clear_has_g_b();
+  inline void set_has_report();
+  inline void clear_has_report();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::protobuf_sgx_ec256_public_t* g_b_;
+  ::protobuf_sgx_report_t* report_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > cmac_;
+  mutable int _cmac_cached_byte_size_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_dhmsgs_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_dhmsgs_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_dhmsgs_2eproto();
+  friend void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+  void InitAsDefaultInstance();
+  static protobuf_sgx_dh_msg2_t* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class protobuf_sgx_dh_msg3_body_t : public ::google::protobuf::MessageLite {
+ public:
+  protobuf_sgx_dh_msg3_body_t();
+  virtual ~protobuf_sgx_dh_msg3_body_t();
+
+  protobuf_sgx_dh_msg3_body_t(const protobuf_sgx_dh_msg3_body_t& from);
+
+  inline protobuf_sgx_dh_msg3_body_t& operator=(const protobuf_sgx_dh_msg3_body_t& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const protobuf_sgx_dh_msg3_body_t& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const protobuf_sgx_dh_msg3_body_t* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(protobuf_sgx_dh_msg3_body_t* other);
+
+  // implements Message ----------------------------------------------
+
+  protobuf_sgx_dh_msg3_body_t* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const protobuf_sgx_dh_msg3_body_t& from);
+  void MergeFrom(const protobuf_sgx_dh_msg3_body_t& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .protobuf_sgx_report_t report = 1;
+  inline bool has_report() const;
+  inline void clear_report();
+  static const int kReportFieldNumber = 1;
+  inline const ::protobuf_sgx_report_t& report() const;
+  inline ::protobuf_sgx_report_t* mutable_report();
+  inline ::protobuf_sgx_report_t* release_report();
+  inline void set_allocated_report(::protobuf_sgx_report_t* report);
+
+  // repeated uint32 additional_prop = 2;
+  inline int additional_prop_size() const;
+  inline void clear_additional_prop();
+  static const int kAdditionalPropFieldNumber = 2;
+  inline ::google::protobuf::uint32 additional_prop(int index) const;
+  inline void set_additional_prop(int index, ::google::protobuf::uint32 value);
+  inline void add_additional_prop(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      additional_prop() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_additional_prop();
+
+  // @@protoc_insertion_point(class_scope:protobuf_sgx_dh_msg3_body_t)
+ private:
+  inline void set_has_report();
+  inline void clear_has_report();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::protobuf_sgx_report_t* report_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > additional_prop_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_dhmsgs_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_dhmsgs_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_dhmsgs_2eproto();
+  friend void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+  void InitAsDefaultInstance();
+  static protobuf_sgx_dh_msg3_body_t* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class protobuf_sgx_dh_msg3_t : public ::google::protobuf::MessageLite {
+ public:
+  protobuf_sgx_dh_msg3_t();
+  virtual ~protobuf_sgx_dh_msg3_t();
+
+  protobuf_sgx_dh_msg3_t(const protobuf_sgx_dh_msg3_t& from);
+
+  inline protobuf_sgx_dh_msg3_t& operator=(const protobuf_sgx_dh_msg3_t& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const protobuf_sgx_dh_msg3_t& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const protobuf_sgx_dh_msg3_t* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(protobuf_sgx_dh_msg3_t* other);
+
+  // implements Message ----------------------------------------------
+
+  protobuf_sgx_dh_msg3_t* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const protobuf_sgx_dh_msg3_t& from);
+  void MergeFrom(const protobuf_sgx_dh_msg3_t& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .protobuf_sgx_dh_msg3_body_t msg3_body = 1;
+  inline bool has_msg3_body() const;
+  inline void clear_msg3_body();
+  static const int kMsg3BodyFieldNumber = 1;
+  inline const ::protobuf_sgx_dh_msg3_body_t& msg3_body() const;
+  inline ::protobuf_sgx_dh_msg3_body_t* mutable_msg3_body();
+  inline ::protobuf_sgx_dh_msg3_body_t* release_msg3_body();
+  inline void set_allocated_msg3_body(::protobuf_sgx_dh_msg3_body_t* msg3_body);
+
+  // repeated uint32 cmac = 2 [packed = true];
+  inline int cmac_size() const;
+  inline void clear_cmac();
+  static const int kCmacFieldNumber = 2;
+  inline ::google::protobuf::uint32 cmac(int index) const;
+  inline void set_cmac(int index, ::google::protobuf::uint32 value);
+  inline void add_cmac(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      cmac() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_cmac();
+
+  // @@protoc_insertion_point(class_scope:protobuf_sgx_dh_msg3_t)
+ private:
+  inline void set_has_msg3_body();
+  inline void clear_has_msg3_body();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::protobuf_sgx_dh_msg3_body_t* msg3_body_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > cmac_;
+  mutable int _cmac_cached_byte_size_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_dhmsgs_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_dhmsgs_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_dhmsgs_2eproto();
+  friend void protobuf_ShutdownFile_dhmsgs_2eproto();
+
+  void InitAsDefaultInstance();
+  static protobuf_sgx_dh_msg3_t* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+// protobuf_sgx_attributes_t
+
+// required uint64 flags = 1;
+inline bool protobuf_sgx_attributes_t::has_flags() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void protobuf_sgx_attributes_t::set_has_flags() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void protobuf_sgx_attributes_t::clear_has_flags() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void protobuf_sgx_attributes_t::clear_flags() {
+  flags_ = GOOGLE_ULONGLONG(0);
+  clear_has_flags();
+}
+inline ::google::protobuf::uint64 protobuf_sgx_attributes_t::flags() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_attributes_t.flags)
+  return flags_;
+}
+inline void protobuf_sgx_attributes_t::set_flags(::google::protobuf::uint64 value) {
+  set_has_flags();
+  flags_ = value;
+  // @@protoc_insertion_point(field_set:protobuf_sgx_attributes_t.flags)
+}
+
+// required uint64 xfrm = 2;
+inline bool protobuf_sgx_attributes_t::has_xfrm() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void protobuf_sgx_attributes_t::set_has_xfrm() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void protobuf_sgx_attributes_t::clear_has_xfrm() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void protobuf_sgx_attributes_t::clear_xfrm() {
+  xfrm_ = GOOGLE_ULONGLONG(0);
+  clear_has_xfrm();
+}
+inline ::google::protobuf::uint64 protobuf_sgx_attributes_t::xfrm() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_attributes_t.xfrm)
+  return xfrm_;
+}
+inline void protobuf_sgx_attributes_t::set_xfrm(::google::protobuf::uint64 value) {
+  set_has_xfrm();
+  xfrm_ = value;
+  // @@protoc_insertion_point(field_set:protobuf_sgx_attributes_t.xfrm)
+}
+
+// -------------------------------------------------------------------
+
+// protobuf_sgx_ec256_public_t
+
+// repeated uint32 gx = 1 [packed = true];
+inline int protobuf_sgx_ec256_public_t::gx_size() const {
+  return gx_.size();
+}
+inline void protobuf_sgx_ec256_public_t::clear_gx() {
+  gx_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_ec256_public_t::gx(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_ec256_public_t.gx)
+  return gx_.Get(index);
+}
+inline void protobuf_sgx_ec256_public_t::set_gx(int index, ::google::protobuf::uint32 value) {
+  gx_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_ec256_public_t.gx)
+}
+inline void protobuf_sgx_ec256_public_t::add_gx(::google::protobuf::uint32 value) {
+  gx_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_ec256_public_t.gx)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_ec256_public_t::gx() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_ec256_public_t.gx)
+  return gx_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_ec256_public_t::mutable_gx() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_ec256_public_t.gx)
+  return &gx_;
+}
+
+// repeated uint32 gy = 2 [packed = true];
+inline int protobuf_sgx_ec256_public_t::gy_size() const {
+  return gy_.size();
+}
+inline void protobuf_sgx_ec256_public_t::clear_gy() {
+  gy_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_ec256_public_t::gy(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_ec256_public_t.gy)
+  return gy_.Get(index);
+}
+inline void protobuf_sgx_ec256_public_t::set_gy(int index, ::google::protobuf::uint32 value) {
+  gy_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_ec256_public_t.gy)
+}
+inline void protobuf_sgx_ec256_public_t::add_gy(::google::protobuf::uint32 value) {
+  gy_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_ec256_public_t.gy)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_ec256_public_t::gy() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_ec256_public_t.gy)
+  return gy_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_ec256_public_t::mutable_gy() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_ec256_public_t.gy)
+  return &gy_;
+}
+
+// -------------------------------------------------------------------
+
+// protobuf_sgx_report_body_t
+
+// repeated uint32 cpu_svn = 1 [packed = true];
+inline int protobuf_sgx_report_body_t::cpu_svn_size() const {
+  return cpu_svn_.size();
+}
+inline void protobuf_sgx_report_body_t::clear_cpu_svn() {
+  cpu_svn_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::cpu_svn(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.cpu_svn)
+  return cpu_svn_.Get(index);
+}
+inline void protobuf_sgx_report_body_t::set_cpu_svn(int index, ::google::protobuf::uint32 value) {
+  cpu_svn_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.cpu_svn)
+}
+inline void protobuf_sgx_report_body_t::add_cpu_svn(::google::protobuf::uint32 value) {
+  cpu_svn_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_body_t.cpu_svn)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_body_t::cpu_svn() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_body_t.cpu_svn)
+  return cpu_svn_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_body_t::mutable_cpu_svn() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_body_t.cpu_svn)
+  return &cpu_svn_;
+}
+
+// required uint32 misc_select = 9;
+inline bool protobuf_sgx_report_body_t::has_misc_select() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void protobuf_sgx_report_body_t::set_has_misc_select() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void protobuf_sgx_report_body_t::clear_has_misc_select() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void protobuf_sgx_report_body_t::clear_misc_select() {
+  misc_select_ = 0u;
+  clear_has_misc_select();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::misc_select() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.misc_select)
+  return misc_select_;
+}
+inline void protobuf_sgx_report_body_t::set_misc_select(::google::protobuf::uint32 value) {
+  set_has_misc_select();
+  misc_select_ = value;
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.misc_select)
+}
+
+// repeated uint32 reserved1 = 2 [packed = true];
+inline int protobuf_sgx_report_body_t::reserved1_size() const {
+  return reserved1_.size();
+}
+inline void protobuf_sgx_report_body_t::clear_reserved1() {
+  reserved1_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::reserved1(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.reserved1)
+  return reserved1_.Get(index);
+}
+inline void protobuf_sgx_report_body_t::set_reserved1(int index, ::google::protobuf::uint32 value) {
+  reserved1_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.reserved1)
+}
+inline void protobuf_sgx_report_body_t::add_reserved1(::google::protobuf::uint32 value) {
+  reserved1_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_body_t.reserved1)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_body_t::reserved1() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_body_t.reserved1)
+  return reserved1_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_body_t::mutable_reserved1() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_body_t.reserved1)
+  return &reserved1_;
+}
+
+// required .protobuf_sgx_attributes_t attributes = 10;
+inline bool protobuf_sgx_report_body_t::has_attributes() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void protobuf_sgx_report_body_t::set_has_attributes() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void protobuf_sgx_report_body_t::clear_has_attributes() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void protobuf_sgx_report_body_t::clear_attributes() {
+  if (attributes_ != NULL) attributes_->::protobuf_sgx_attributes_t::Clear();
+  clear_has_attributes();
+}
+inline const ::protobuf_sgx_attributes_t& protobuf_sgx_report_body_t::attributes() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.attributes)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return attributes_ != NULL ? *attributes_ : *default_instance().attributes_;
+#else
+  return attributes_ != NULL ? *attributes_ : *default_instance_->attributes_;
+#endif
+}
+inline ::protobuf_sgx_attributes_t* protobuf_sgx_report_body_t::mutable_attributes() {
+  set_has_attributes();
+  if (attributes_ == NULL) attributes_ = new ::protobuf_sgx_attributes_t;
+  // @@protoc_insertion_point(field_mutable:protobuf_sgx_report_body_t.attributes)
+  return attributes_;
+}
+inline ::protobuf_sgx_attributes_t* protobuf_sgx_report_body_t::release_attributes() {
+  clear_has_attributes();
+  ::protobuf_sgx_attributes_t* temp = attributes_;
+  attributes_ = NULL;
+  return temp;
+}
+inline void protobuf_sgx_report_body_t::set_allocated_attributes(::protobuf_sgx_attributes_t* attributes) {
+  delete attributes_;
+  attributes_ = attributes;
+  if (attributes) {
+    set_has_attributes();
+  } else {
+    clear_has_attributes();
+  }
+  // @@protoc_insertion_point(field_set_allocated:protobuf_sgx_report_body_t.attributes)
+}
+
+// repeated uint32 mr_enclave = 3 [packed = true];
+inline int protobuf_sgx_report_body_t::mr_enclave_size() const {
+  return mr_enclave_.size();
+}
+inline void protobuf_sgx_report_body_t::clear_mr_enclave() {
+  mr_enclave_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::mr_enclave(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.mr_enclave)
+  return mr_enclave_.Get(index);
+}
+inline void protobuf_sgx_report_body_t::set_mr_enclave(int index, ::google::protobuf::uint32 value) {
+  mr_enclave_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.mr_enclave)
+}
+inline void protobuf_sgx_report_body_t::add_mr_enclave(::google::protobuf::uint32 value) {
+  mr_enclave_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_body_t.mr_enclave)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_body_t::mr_enclave() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_body_t.mr_enclave)
+  return mr_enclave_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_body_t::mutable_mr_enclave() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_body_t.mr_enclave)
+  return &mr_enclave_;
+}
+
+// repeated uint32 reserved2 = 4 [packed = true];
+inline int protobuf_sgx_report_body_t::reserved2_size() const {
+  return reserved2_.size();
+}
+inline void protobuf_sgx_report_body_t::clear_reserved2() {
+  reserved2_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::reserved2(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.reserved2)
+  return reserved2_.Get(index);
+}
+inline void protobuf_sgx_report_body_t::set_reserved2(int index, ::google::protobuf::uint32 value) {
+  reserved2_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.reserved2)
+}
+inline void protobuf_sgx_report_body_t::add_reserved2(::google::protobuf::uint32 value) {
+  reserved2_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_body_t.reserved2)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_body_t::reserved2() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_body_t.reserved2)
+  return reserved2_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_body_t::mutable_reserved2() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_body_t.reserved2)
+  return &reserved2_;
+}
+
+// repeated uint32 mr_signer = 5 [packed = true];
+inline int protobuf_sgx_report_body_t::mr_signer_size() const {
+  return mr_signer_.size();
+}
+inline void protobuf_sgx_report_body_t::clear_mr_signer() {
+  mr_signer_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::mr_signer(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.mr_signer)
+  return mr_signer_.Get(index);
+}
+inline void protobuf_sgx_report_body_t::set_mr_signer(int index, ::google::protobuf::uint32 value) {
+  mr_signer_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.mr_signer)
+}
+inline void protobuf_sgx_report_body_t::add_mr_signer(::google::protobuf::uint32 value) {
+  mr_signer_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_body_t.mr_signer)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_body_t::mr_signer() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_body_t.mr_signer)
+  return mr_signer_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_body_t::mutable_mr_signer() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_body_t.mr_signer)
+  return &mr_signer_;
+}
+
+// repeated uint32 reserved3 = 6 [packed = true];
+inline int protobuf_sgx_report_body_t::reserved3_size() const {
+  return reserved3_.size();
+}
+inline void protobuf_sgx_report_body_t::clear_reserved3() {
+  reserved3_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::reserved3(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.reserved3)
+  return reserved3_.Get(index);
+}
+inline void protobuf_sgx_report_body_t::set_reserved3(int index, ::google::protobuf::uint32 value) {
+  reserved3_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.reserved3)
+}
+inline void protobuf_sgx_report_body_t::add_reserved3(::google::protobuf::uint32 value) {
+  reserved3_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_body_t.reserved3)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_body_t::reserved3() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_body_t.reserved3)
+  return reserved3_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_body_t::mutable_reserved3() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_body_t.reserved3)
+  return &reserved3_;
+}
+
+// required uint32 isv_prod_id = 11;
+inline bool protobuf_sgx_report_body_t::has_isv_prod_id() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void protobuf_sgx_report_body_t::set_has_isv_prod_id() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void protobuf_sgx_report_body_t::clear_has_isv_prod_id() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void protobuf_sgx_report_body_t::clear_isv_prod_id() {
+  isv_prod_id_ = 0u;
+  clear_has_isv_prod_id();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::isv_prod_id() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.isv_prod_id)
+  return isv_prod_id_;
+}
+inline void protobuf_sgx_report_body_t::set_isv_prod_id(::google::protobuf::uint32 value) {
+  set_has_isv_prod_id();
+  isv_prod_id_ = value;
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.isv_prod_id)
+}
+
+// required uint32 isv_svn = 12;
+inline bool protobuf_sgx_report_body_t::has_isv_svn() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void protobuf_sgx_report_body_t::set_has_isv_svn() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void protobuf_sgx_report_body_t::clear_has_isv_svn() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void protobuf_sgx_report_body_t::clear_isv_svn() {
+  isv_svn_ = 0u;
+  clear_has_isv_svn();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::isv_svn() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.isv_svn)
+  return isv_svn_;
+}
+inline void protobuf_sgx_report_body_t::set_isv_svn(::google::protobuf::uint32 value) {
+  set_has_isv_svn();
+  isv_svn_ = value;
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.isv_svn)
+}
+
+// repeated uint32 reserved4 = 7 [packed = true];
+inline int protobuf_sgx_report_body_t::reserved4_size() const {
+  return reserved4_.size();
+}
+inline void protobuf_sgx_report_body_t::clear_reserved4() {
+  reserved4_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::reserved4(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.reserved4)
+  return reserved4_.Get(index);
+}
+inline void protobuf_sgx_report_body_t::set_reserved4(int index, ::google::protobuf::uint32 value) {
+  reserved4_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.reserved4)
+}
+inline void protobuf_sgx_report_body_t::add_reserved4(::google::protobuf::uint32 value) {
+  reserved4_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_body_t.reserved4)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_body_t::reserved4() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_body_t.reserved4)
+  return reserved4_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_body_t::mutable_reserved4() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_body_t.reserved4)
+  return &reserved4_;
+}
+
+// repeated uint32 report_data = 8 [packed = true];
+inline int protobuf_sgx_report_body_t::report_data_size() const {
+  return report_data_.size();
+}
+inline void protobuf_sgx_report_body_t::clear_report_data() {
+  report_data_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_body_t::report_data(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_body_t.report_data)
+  return report_data_.Get(index);
+}
+inline void protobuf_sgx_report_body_t::set_report_data(int index, ::google::protobuf::uint32 value) {
+  report_data_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_body_t.report_data)
+}
+inline void protobuf_sgx_report_body_t::add_report_data(::google::protobuf::uint32 value) {
+  report_data_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_body_t.report_data)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_body_t::report_data() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_body_t.report_data)
+  return report_data_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_body_t::mutable_report_data() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_body_t.report_data)
+  return &report_data_;
+}
+
+// -------------------------------------------------------------------
+
+// protobuf_sgx_report_t
+
+// required .protobuf_sgx_report_body_t body = 1;
+inline bool protobuf_sgx_report_t::has_body() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void protobuf_sgx_report_t::set_has_body() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void protobuf_sgx_report_t::clear_has_body() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void protobuf_sgx_report_t::clear_body() {
+  if (body_ != NULL) body_->::protobuf_sgx_report_body_t::Clear();
+  clear_has_body();
+}
+inline const ::protobuf_sgx_report_body_t& protobuf_sgx_report_t::body() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_t.body)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return body_ != NULL ? *body_ : *default_instance().body_;
+#else
+  return body_ != NULL ? *body_ : *default_instance_->body_;
+#endif
+}
+inline ::protobuf_sgx_report_body_t* protobuf_sgx_report_t::mutable_body() {
+  set_has_body();
+  if (body_ == NULL) body_ = new ::protobuf_sgx_report_body_t;
+  // @@protoc_insertion_point(field_mutable:protobuf_sgx_report_t.body)
+  return body_;
+}
+inline ::protobuf_sgx_report_body_t* protobuf_sgx_report_t::release_body() {
+  clear_has_body();
+  ::protobuf_sgx_report_body_t* temp = body_;
+  body_ = NULL;
+  return temp;
+}
+inline void protobuf_sgx_report_t::set_allocated_body(::protobuf_sgx_report_body_t* body) {
+  delete body_;
+  body_ = body;
+  if (body) {
+    set_has_body();
+  } else {
+    clear_has_body();
+  }
+  // @@protoc_insertion_point(field_set_allocated:protobuf_sgx_report_t.body)
+}
+
+// repeated uint32 key_id = 2 [packed = true];
+inline int protobuf_sgx_report_t::key_id_size() const {
+  return key_id_.size();
+}
+inline void protobuf_sgx_report_t::clear_key_id() {
+  key_id_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_t::key_id(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_t.key_id)
+  return key_id_.Get(index);
+}
+inline void protobuf_sgx_report_t::set_key_id(int index, ::google::protobuf::uint32 value) {
+  key_id_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_t.key_id)
+}
+inline void protobuf_sgx_report_t::add_key_id(::google::protobuf::uint32 value) {
+  key_id_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_t.key_id)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_t::key_id() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_t.key_id)
+  return key_id_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_t::mutable_key_id() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_t.key_id)
+  return &key_id_;
+}
+
+// repeated uint32 mac = 3 [packed = true];
+inline int protobuf_sgx_report_t::mac_size() const {
+  return mac_.size();
+}
+inline void protobuf_sgx_report_t::clear_mac() {
+  mac_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_report_t::mac(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_report_t.mac)
+  return mac_.Get(index);
+}
+inline void protobuf_sgx_report_t::set_mac(int index, ::google::protobuf::uint32 value) {
+  mac_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_report_t.mac)
+}
+inline void protobuf_sgx_report_t::add_mac(::google::protobuf::uint32 value) {
+  mac_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_report_t.mac)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_report_t::mac() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_report_t.mac)
+  return mac_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_report_t::mutable_mac() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_report_t.mac)
+  return &mac_;
+}
+
+// -------------------------------------------------------------------
+
+// protobuf_sgx_target_info_t
+
+// repeated uint32 mr_enclave = 1 [packed = true];
+inline int protobuf_sgx_target_info_t::mr_enclave_size() const {
+  return mr_enclave_.size();
+}
+inline void protobuf_sgx_target_info_t::clear_mr_enclave() {
+  mr_enclave_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_target_info_t::mr_enclave(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_target_info_t.mr_enclave)
+  return mr_enclave_.Get(index);
+}
+inline void protobuf_sgx_target_info_t::set_mr_enclave(int index, ::google::protobuf::uint32 value) {
+  mr_enclave_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_target_info_t.mr_enclave)
+}
+inline void protobuf_sgx_target_info_t::add_mr_enclave(::google::protobuf::uint32 value) {
+  mr_enclave_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_target_info_t.mr_enclave)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_target_info_t::mr_enclave() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_target_info_t.mr_enclave)
+  return mr_enclave_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_target_info_t::mutable_mr_enclave() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_target_info_t.mr_enclave)
+  return &mr_enclave_;
+}
+
+// required .protobuf_sgx_attributes_t attributes = 4;
+inline bool protobuf_sgx_target_info_t::has_attributes() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void protobuf_sgx_target_info_t::set_has_attributes() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void protobuf_sgx_target_info_t::clear_has_attributes() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void protobuf_sgx_target_info_t::clear_attributes() {
+  if (attributes_ != NULL) attributes_->::protobuf_sgx_attributes_t::Clear();
+  clear_has_attributes();
+}
+inline const ::protobuf_sgx_attributes_t& protobuf_sgx_target_info_t::attributes() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_target_info_t.attributes)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return attributes_ != NULL ? *attributes_ : *default_instance().attributes_;
+#else
+  return attributes_ != NULL ? *attributes_ : *default_instance_->attributes_;
+#endif
+}
+inline ::protobuf_sgx_attributes_t* protobuf_sgx_target_info_t::mutable_attributes() {
+  set_has_attributes();
+  if (attributes_ == NULL) attributes_ = new ::protobuf_sgx_attributes_t;
+  // @@protoc_insertion_point(field_mutable:protobuf_sgx_target_info_t.attributes)
+  return attributes_;
+}
+inline ::protobuf_sgx_attributes_t* protobuf_sgx_target_info_t::release_attributes() {
+  clear_has_attributes();
+  ::protobuf_sgx_attributes_t* temp = attributes_;
+  attributes_ = NULL;
+  return temp;
+}
+inline void protobuf_sgx_target_info_t::set_allocated_attributes(::protobuf_sgx_attributes_t* attributes) {
+  delete attributes_;
+  attributes_ = attributes;
+  if (attributes) {
+    set_has_attributes();
+  } else {
+    clear_has_attributes();
+  }
+  // @@protoc_insertion_point(field_set_allocated:protobuf_sgx_target_info_t.attributes)
+}
+
+// repeated uint32 reserved1 = 2 [packed = true];
+inline int protobuf_sgx_target_info_t::reserved1_size() const {
+  return reserved1_.size();
+}
+inline void protobuf_sgx_target_info_t::clear_reserved1() {
+  reserved1_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_target_info_t::reserved1(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_target_info_t.reserved1)
+  return reserved1_.Get(index);
+}
+inline void protobuf_sgx_target_info_t::set_reserved1(int index, ::google::protobuf::uint32 value) {
+  reserved1_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_target_info_t.reserved1)
+}
+inline void protobuf_sgx_target_info_t::add_reserved1(::google::protobuf::uint32 value) {
+  reserved1_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_target_info_t.reserved1)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_target_info_t::reserved1() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_target_info_t.reserved1)
+  return reserved1_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_target_info_t::mutable_reserved1() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_target_info_t.reserved1)
+  return &reserved1_;
+}
+
+// required uint32 misc_select = 5;
+inline bool protobuf_sgx_target_info_t::has_misc_select() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void protobuf_sgx_target_info_t::set_has_misc_select() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void protobuf_sgx_target_info_t::clear_has_misc_select() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void protobuf_sgx_target_info_t::clear_misc_select() {
+  misc_select_ = 0u;
+  clear_has_misc_select();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_target_info_t::misc_select() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_target_info_t.misc_select)
+  return misc_select_;
+}
+inline void protobuf_sgx_target_info_t::set_misc_select(::google::protobuf::uint32 value) {
+  set_has_misc_select();
+  misc_select_ = value;
+  // @@protoc_insertion_point(field_set:protobuf_sgx_target_info_t.misc_select)
+}
+
+// repeated uint32 reserved2 = 3 [packed = true];
+inline int protobuf_sgx_target_info_t::reserved2_size() const {
+  return reserved2_.size();
+}
+inline void protobuf_sgx_target_info_t::clear_reserved2() {
+  reserved2_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_target_info_t::reserved2(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_target_info_t.reserved2)
+  return reserved2_.Get(index);
+}
+inline void protobuf_sgx_target_info_t::set_reserved2(int index, ::google::protobuf::uint32 value) {
+  reserved2_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_target_info_t.reserved2)
+}
+inline void protobuf_sgx_target_info_t::add_reserved2(::google::protobuf::uint32 value) {
+  reserved2_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_target_info_t.reserved2)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_target_info_t::reserved2() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_target_info_t.reserved2)
+  return reserved2_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_target_info_t::mutable_reserved2() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_target_info_t.reserved2)
+  return &reserved2_;
+}
+
+// -------------------------------------------------------------------
+
+// protobuf_sgx_dh_msg1_t
+
+// required .protobuf_sgx_ec256_public_t g_a = 1;
+inline bool protobuf_sgx_dh_msg1_t::has_g_a() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void protobuf_sgx_dh_msg1_t::set_has_g_a() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void protobuf_sgx_dh_msg1_t::clear_has_g_a() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void protobuf_sgx_dh_msg1_t::clear_g_a() {
+  if (g_a_ != NULL) g_a_->::protobuf_sgx_ec256_public_t::Clear();
+  clear_has_g_a();
+}
+inline const ::protobuf_sgx_ec256_public_t& protobuf_sgx_dh_msg1_t::g_a() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_dh_msg1_t.g_a)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return g_a_ != NULL ? *g_a_ : *default_instance().g_a_;
+#else
+  return g_a_ != NULL ? *g_a_ : *default_instance_->g_a_;
+#endif
+}
+inline ::protobuf_sgx_ec256_public_t* protobuf_sgx_dh_msg1_t::mutable_g_a() {
+  set_has_g_a();
+  if (g_a_ == NULL) g_a_ = new ::protobuf_sgx_ec256_public_t;
+  // @@protoc_insertion_point(field_mutable:protobuf_sgx_dh_msg1_t.g_a)
+  return g_a_;
+}
+inline ::protobuf_sgx_ec256_public_t* protobuf_sgx_dh_msg1_t::release_g_a() {
+  clear_has_g_a();
+  ::protobuf_sgx_ec256_public_t* temp = g_a_;
+  g_a_ = NULL;
+  return temp;
+}
+inline void protobuf_sgx_dh_msg1_t::set_allocated_g_a(::protobuf_sgx_ec256_public_t* g_a) {
+  delete g_a_;
+  g_a_ = g_a;
+  if (g_a) {
+    set_has_g_a();
+  } else {
+    clear_has_g_a();
+  }
+  // @@protoc_insertion_point(field_set_allocated:protobuf_sgx_dh_msg1_t.g_a)
+}
+
+// required .protobuf_sgx_target_info_t target = 2;
+inline bool protobuf_sgx_dh_msg1_t::has_target() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void protobuf_sgx_dh_msg1_t::set_has_target() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void protobuf_sgx_dh_msg1_t::clear_has_target() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void protobuf_sgx_dh_msg1_t::clear_target() {
+  if (target_ != NULL) target_->::protobuf_sgx_target_info_t::Clear();
+  clear_has_target();
+}
+inline const ::protobuf_sgx_target_info_t& protobuf_sgx_dh_msg1_t::target() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_dh_msg1_t.target)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return target_ != NULL ? *target_ : *default_instance().target_;
+#else
+  return target_ != NULL ? *target_ : *default_instance_->target_;
+#endif
+}
+inline ::protobuf_sgx_target_info_t* protobuf_sgx_dh_msg1_t::mutable_target() {
+  set_has_target();
+  if (target_ == NULL) target_ = new ::protobuf_sgx_target_info_t;
+  // @@protoc_insertion_point(field_mutable:protobuf_sgx_dh_msg1_t.target)
+  return target_;
+}
+inline ::protobuf_sgx_target_info_t* protobuf_sgx_dh_msg1_t::release_target() {
+  clear_has_target();
+  ::protobuf_sgx_target_info_t* temp = target_;
+  target_ = NULL;
+  return temp;
+}
+inline void protobuf_sgx_dh_msg1_t::set_allocated_target(::protobuf_sgx_target_info_t* target) {
+  delete target_;
+  target_ = target;
+  if (target) {
+    set_has_target();
+  } else {
+    clear_has_target();
+  }
+  // @@protoc_insertion_point(field_set_allocated:protobuf_sgx_dh_msg1_t.target)
+}
+
+// -------------------------------------------------------------------
+
+// protobuf_sgx_dh_msg2_t
+
+// required .protobuf_sgx_ec256_public_t g_b = 1;
+inline bool protobuf_sgx_dh_msg2_t::has_g_b() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void protobuf_sgx_dh_msg2_t::set_has_g_b() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void protobuf_sgx_dh_msg2_t::clear_has_g_b() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void protobuf_sgx_dh_msg2_t::clear_g_b() {
+  if (g_b_ != NULL) g_b_->::protobuf_sgx_ec256_public_t::Clear();
+  clear_has_g_b();
+}
+inline const ::protobuf_sgx_ec256_public_t& protobuf_sgx_dh_msg2_t::g_b() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_dh_msg2_t.g_b)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return g_b_ != NULL ? *g_b_ : *default_instance().g_b_;
+#else
+  return g_b_ != NULL ? *g_b_ : *default_instance_->g_b_;
+#endif
+}
+inline ::protobuf_sgx_ec256_public_t* protobuf_sgx_dh_msg2_t::mutable_g_b() {
+  set_has_g_b();
+  if (g_b_ == NULL) g_b_ = new ::protobuf_sgx_ec256_public_t;
+  // @@protoc_insertion_point(field_mutable:protobuf_sgx_dh_msg2_t.g_b)
+  return g_b_;
+}
+inline ::protobuf_sgx_ec256_public_t* protobuf_sgx_dh_msg2_t::release_g_b() {
+  clear_has_g_b();
+  ::protobuf_sgx_ec256_public_t* temp = g_b_;
+  g_b_ = NULL;
+  return temp;
+}
+inline void protobuf_sgx_dh_msg2_t::set_allocated_g_b(::protobuf_sgx_ec256_public_t* g_b) {
+  delete g_b_;
+  g_b_ = g_b;
+  if (g_b) {
+    set_has_g_b();
+  } else {
+    clear_has_g_b();
+  }
+  // @@protoc_insertion_point(field_set_allocated:protobuf_sgx_dh_msg2_t.g_b)
+}
+
+// required .protobuf_sgx_report_t report = 2;
+inline bool protobuf_sgx_dh_msg2_t::has_report() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void protobuf_sgx_dh_msg2_t::set_has_report() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void protobuf_sgx_dh_msg2_t::clear_has_report() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void protobuf_sgx_dh_msg2_t::clear_report() {
+  if (report_ != NULL) report_->::protobuf_sgx_report_t::Clear();
+  clear_has_report();
+}
+inline const ::protobuf_sgx_report_t& protobuf_sgx_dh_msg2_t::report() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_dh_msg2_t.report)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return report_ != NULL ? *report_ : *default_instance().report_;
+#else
+  return report_ != NULL ? *report_ : *default_instance_->report_;
+#endif
+}
+inline ::protobuf_sgx_report_t* protobuf_sgx_dh_msg2_t::mutable_report() {
+  set_has_report();
+  if (report_ == NULL) report_ = new ::protobuf_sgx_report_t;
+  // @@protoc_insertion_point(field_mutable:protobuf_sgx_dh_msg2_t.report)
+  return report_;
+}
+inline ::protobuf_sgx_report_t* protobuf_sgx_dh_msg2_t::release_report() {
+  clear_has_report();
+  ::protobuf_sgx_report_t* temp = report_;
+  report_ = NULL;
+  return temp;
+}
+inline void protobuf_sgx_dh_msg2_t::set_allocated_report(::protobuf_sgx_report_t* report) {
+  delete report_;
+  report_ = report;
+  if (report) {
+    set_has_report();
+  } else {
+    clear_has_report();
+  }
+  // @@protoc_insertion_point(field_set_allocated:protobuf_sgx_dh_msg2_t.report)
+}
+
+// repeated uint32 cmac = 3 [packed = true];
+inline int protobuf_sgx_dh_msg2_t::cmac_size() const {
+  return cmac_.size();
+}
+inline void protobuf_sgx_dh_msg2_t::clear_cmac() {
+  cmac_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_dh_msg2_t::cmac(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_dh_msg2_t.cmac)
+  return cmac_.Get(index);
+}
+inline void protobuf_sgx_dh_msg2_t::set_cmac(int index, ::google::protobuf::uint32 value) {
+  cmac_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_dh_msg2_t.cmac)
+}
+inline void protobuf_sgx_dh_msg2_t::add_cmac(::google::protobuf::uint32 value) {
+  cmac_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_dh_msg2_t.cmac)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_dh_msg2_t::cmac() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_dh_msg2_t.cmac)
+  return cmac_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_dh_msg2_t::mutable_cmac() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_dh_msg2_t.cmac)
+  return &cmac_;
+}
+
+// -------------------------------------------------------------------
+
+// protobuf_sgx_dh_msg3_body_t
+
+// required .protobuf_sgx_report_t report = 1;
+inline bool protobuf_sgx_dh_msg3_body_t::has_report() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void protobuf_sgx_dh_msg3_body_t::set_has_report() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void protobuf_sgx_dh_msg3_body_t::clear_has_report() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void protobuf_sgx_dh_msg3_body_t::clear_report() {
+  if (report_ != NULL) report_->::protobuf_sgx_report_t::Clear();
+  clear_has_report();
+}
+inline const ::protobuf_sgx_report_t& protobuf_sgx_dh_msg3_body_t::report() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_dh_msg3_body_t.report)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return report_ != NULL ? *report_ : *default_instance().report_;
+#else
+  return report_ != NULL ? *report_ : *default_instance_->report_;
+#endif
+}
+inline ::protobuf_sgx_report_t* protobuf_sgx_dh_msg3_body_t::mutable_report() {
+  set_has_report();
+  if (report_ == NULL) report_ = new ::protobuf_sgx_report_t;
+  // @@protoc_insertion_point(field_mutable:protobuf_sgx_dh_msg3_body_t.report)
+  return report_;
+}
+inline ::protobuf_sgx_report_t* protobuf_sgx_dh_msg3_body_t::release_report() {
+  clear_has_report();
+  ::protobuf_sgx_report_t* temp = report_;
+  report_ = NULL;
+  return temp;
+}
+inline void protobuf_sgx_dh_msg3_body_t::set_allocated_report(::protobuf_sgx_report_t* report) {
+  delete report_;
+  report_ = report;
+  if (report) {
+    set_has_report();
+  } else {
+    clear_has_report();
+  }
+  // @@protoc_insertion_point(field_set_allocated:protobuf_sgx_dh_msg3_body_t.report)
+}
+
+// repeated uint32 additional_prop = 2;
+inline int protobuf_sgx_dh_msg3_body_t::additional_prop_size() const {
+  return additional_prop_.size();
+}
+inline void protobuf_sgx_dh_msg3_body_t::clear_additional_prop() {
+  additional_prop_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_dh_msg3_body_t::additional_prop(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_dh_msg3_body_t.additional_prop)
+  return additional_prop_.Get(index);
+}
+inline void protobuf_sgx_dh_msg3_body_t::set_additional_prop(int index, ::google::protobuf::uint32 value) {
+  additional_prop_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_dh_msg3_body_t.additional_prop)
+}
+inline void protobuf_sgx_dh_msg3_body_t::add_additional_prop(::google::protobuf::uint32 value) {
+  additional_prop_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_dh_msg3_body_t.additional_prop)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_dh_msg3_body_t::additional_prop() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_dh_msg3_body_t.additional_prop)
+  return additional_prop_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_dh_msg3_body_t::mutable_additional_prop() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_dh_msg3_body_t.additional_prop)
+  return &additional_prop_;
+}
+
+// -------------------------------------------------------------------
+
+// protobuf_sgx_dh_msg3_t
+
+// required .protobuf_sgx_dh_msg3_body_t msg3_body = 1;
+inline bool protobuf_sgx_dh_msg3_t::has_msg3_body() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void protobuf_sgx_dh_msg3_t::set_has_msg3_body() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void protobuf_sgx_dh_msg3_t::clear_has_msg3_body() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void protobuf_sgx_dh_msg3_t::clear_msg3_body() {
+  if (msg3_body_ != NULL) msg3_body_->::protobuf_sgx_dh_msg3_body_t::Clear();
+  clear_has_msg3_body();
+}
+inline const ::protobuf_sgx_dh_msg3_body_t& protobuf_sgx_dh_msg3_t::msg3_body() const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_dh_msg3_t.msg3_body)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return msg3_body_ != NULL ? *msg3_body_ : *default_instance().msg3_body_;
+#else
+  return msg3_body_ != NULL ? *msg3_body_ : *default_instance_->msg3_body_;
+#endif
+}
+inline ::protobuf_sgx_dh_msg3_body_t* protobuf_sgx_dh_msg3_t::mutable_msg3_body() {
+  set_has_msg3_body();
+  if (msg3_body_ == NULL) msg3_body_ = new ::protobuf_sgx_dh_msg3_body_t;
+  // @@protoc_insertion_point(field_mutable:protobuf_sgx_dh_msg3_t.msg3_body)
+  return msg3_body_;
+}
+inline ::protobuf_sgx_dh_msg3_body_t* protobuf_sgx_dh_msg3_t::release_msg3_body() {
+  clear_has_msg3_body();
+  ::protobuf_sgx_dh_msg3_body_t* temp = msg3_body_;
+  msg3_body_ = NULL;
+  return temp;
+}
+inline void protobuf_sgx_dh_msg3_t::set_allocated_msg3_body(::protobuf_sgx_dh_msg3_body_t* msg3_body) {
+  delete msg3_body_;
+  msg3_body_ = msg3_body;
+  if (msg3_body) {
+    set_has_msg3_body();
+  } else {
+    clear_has_msg3_body();
+  }
+  // @@protoc_insertion_point(field_set_allocated:protobuf_sgx_dh_msg3_t.msg3_body)
+}
+
+// repeated uint32 cmac = 2 [packed = true];
+inline int protobuf_sgx_dh_msg3_t::cmac_size() const {
+  return cmac_.size();
+}
+inline void protobuf_sgx_dh_msg3_t::clear_cmac() {
+  cmac_.Clear();
+}
+inline ::google::protobuf::uint32 protobuf_sgx_dh_msg3_t::cmac(int index) const {
+  // @@protoc_insertion_point(field_get:protobuf_sgx_dh_msg3_t.cmac)
+  return cmac_.Get(index);
+}
+inline void protobuf_sgx_dh_msg3_t::set_cmac(int index, ::google::protobuf::uint32 value) {
+  cmac_.Set(index, value);
+  // @@protoc_insertion_point(field_set:protobuf_sgx_dh_msg3_t.cmac)
+}
+inline void protobuf_sgx_dh_msg3_t::add_cmac(::google::protobuf::uint32 value) {
+  cmac_.Add(value);
+  // @@protoc_insertion_point(field_add:protobuf_sgx_dh_msg3_t.cmac)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+protobuf_sgx_dh_msg3_t::cmac() const {
+  // @@protoc_insertion_point(field_list:protobuf_sgx_dh_msg3_t.cmac)
+  return cmac_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+protobuf_sgx_dh_msg3_t::mutable_cmac() {
+  // @@protoc_insertion_point(field_mutable_list:protobuf_sgx_dh_msg3_t.cmac)
+  return &cmac_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_dhmsgs_2eproto__INCLUDED

+ 12 - 0
Decryptor/Decryptor.config.xml

@@ -0,0 +1,12 @@
+<EnclaveConfiguration> 
+  <ProdID>0</ProdID> 
+  <ISVSVN>0</ISVSVN> 
+  <StackMaxSize>0x40000</StackMaxSize> 
+  <HeapMaxSize>0x100000</HeapMaxSize> 
+  <TCSNum>1</TCSNum> 
+  <TCSPolicy>1</TCSPolicy>
+  <!-- Recommend changing 'DisableDebug' to 1 to make the enclave undebuggable for enclave release -->
+  <DisableDebug>0</DisableDebug>
+  <MiscSelect>0</MiscSelect>
+  <MiscMask>0xFFFFFFFF</MiscMask>
+</EnclaveConfiguration>

+ 387 - 0
Decryptor/Decryptor.cpp

@@ -0,0 +1,387 @@
+/*
+ * Copyright (C) 2011-2017 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 "sgx_tcrypto.h"
+#include "Decryptor_t.h"
+#include "EnclaveMessageExchange.h"
+#include "error_codes.h"
+#include "Utility_Decryptor.h"
+#include "sgx_thread.h"
+#include "sgx_dh.h"
+#include <map>
+
+#define UNUSED(val) (void)(val)
+/*
+std::map<sgx_enclave_id_t, dh_session_t>g_src_session_info_map;
+
+static uint32_t e2_foo1_wrapper(ms_in_msg_exchange_t *ms, size_t param_lenth, char** resp_buffer, size_t* resp_length);
+
+//Function pointer table containing the list of functions that the enclave exposes
+const struct {
+    size_t num_funcs;
+    const void* table[1];
+} func_table = {
+    1,
+    {
+        (const void*)e2_foo1_wrapper,
+    }
+};
+*/
+/*
+//Makes use of the sample code function to establish a secure channel with the destination enclave
+uint32_t test_create_session(sgx_enclave_id_t src_enclave_id,
+                          sgx_enclave_id_t dest_enclave_id)
+{
+    ATTESTATION_STATUS ke_status = SUCCESS;
+    dh_session_t dest_session_info;
+    //Core reference code function for creating a session
+    ke_status = create_session(src_enclave_id, dest_enclave_id,&dest_session_info);
+    if(ke_status == SUCCESS)
+    {
+        //Insert the session information into the map under the corresponding destination enclave id
+        g_src_session_info_map.insert(std::pair<sgx_enclave_id_t, dh_session_t>(dest_enclave_id, dest_session_info));
+    }
+    memset(&dest_session_info, 0, sizeof(dh_session_t));
+    return ke_status;
+}
+
+//Makes use of the sample code function to do an enclave to enclave call (Test Vector)
+uint32_t test_enclave_to_enclave_call(sgx_enclave_id_t src_enclave_id,
+                                          sgx_enclave_id_t dest_enclave_id)
+{
+    ATTESTATION_STATUS ke_status = SUCCESS;
+    param_struct_t *p_struct_var, struct_var;
+    uint32_t target_fn_id, msg_type;
+    char* marshalled_inp_buff;
+    size_t marshalled_inp_buff_len;
+    char* out_buff;
+    size_t out_buff_len;
+    dh_session_t *dest_session_info;
+    size_t max_out_buff_size;
+    char* retval;
+
+    max_out_buff_size = 50;
+    target_fn_id = 0;
+    msg_type = ENCLAVE_TO_ENCLAVE_CALL;
+
+    struct_var.var1 = 0x3;
+    struct_var.var2 = 0x4;
+    p_struct_var = &struct_var;
+
+    //Marshals the input parameters for calling function foo1 in Enclave3 into a input buffer
+    ke_status = marshal_input_parameters_e3_foo1(target_fn_id, msg_type, p_struct_var, &marshalled_inp_buff, &marshalled_inp_buff_len);
+    if(ke_status != SUCCESS)
+    {
+        return ke_status;
+    }
+
+    //Search the map for the session information associated with the destination enclave id passed in
+    std::map<sgx_enclave_id_t, dh_session_t>::iterator it = g_src_session_info_map.find(dest_enclave_id);
+    if(it != g_src_session_info_map.end())
+    {
+         dest_session_info = &it->second;
+    }
+    else
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        return INVALID_SESSION;
+    }
+
+    //Core Reference Code function
+    ke_status = send_request_receive_response(src_enclave_id, dest_enclave_id, dest_session_info, marshalled_inp_buff,
+                                               marshalled_inp_buff_len, max_out_buff_size, &out_buff, &out_buff_len);
+
+    if(ke_status != SUCCESS)
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        SAFE_FREE(out_buff);
+        return ke_status;
+    }
+
+    //Un-marshal the return value and output parameters from foo1 of Enclave3
+    ke_status = unmarshal_retval_and_output_parameters_e3_foo1(out_buff, p_struct_var, &retval);
+    if(ke_status != SUCCESS)
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        SAFE_FREE(out_buff);
+        return ke_status;
+    }
+
+    SAFE_FREE(marshalled_inp_buff);
+    SAFE_FREE(out_buff);
+    SAFE_FREE(retval);
+
+    return SUCCESS;
+}
+
+//Makes use of the sample code function to do a generic secret message exchange (Test Vector)
+uint32_t test_message_exchange(sgx_enclave_id_t src_enclave_id,
+                               sgx_enclave_id_t dest_enclave_id)
+{
+    ATTESTATION_STATUS ke_status = SUCCESS;
+    uint32_t target_fn_id, msg_type;
+    char* marshalled_inp_buff;
+    size_t marshalled_inp_buff_len;
+    char* out_buff;
+    size_t out_buff_len;
+    dh_session_t *dest_session_info;
+    size_t max_out_buff_size;
+    char* secret_response;
+    uint32_t secret_data;
+
+    target_fn_id = 0;
+    msg_type = MESSAGE_EXCHANGE;
+    max_out_buff_size = 50;
+    secret_data = 0x12345678; //Secret Data here is shown only for purpose of demonstration.
+
+    //Marshals the secret data into a buffer
+    ke_status = marshal_message_exchange_request(target_fn_id, msg_type, secret_data, &marshalled_inp_buff, &marshalled_inp_buff_len);
+    if(ke_status != SUCCESS)
+    {
+        return ke_status;
+    }
+    //Search the map for the session information associated with the destination enclave id passed in
+    std::map<sgx_enclave_id_t, dh_session_t>::iterator it = g_src_session_info_map.find(dest_enclave_id);
+    if(it != g_src_session_info_map.end())
+    {
+           dest_session_info = &it->second;
+    }
+    else
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        return INVALID_SESSION;
+    }
+
+    //Core Reference Code function
+    ke_status = send_request_receive_response(src_enclave_id, dest_enclave_id, dest_session_info, marshalled_inp_buff,
+                                                marshalled_inp_buff_len, max_out_buff_size, &out_buff, &out_buff_len);
+    if(ke_status != SUCCESS)
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        SAFE_FREE(out_buff);
+        return ke_status;
+    }
+
+    //Un-marshal the secret response data
+    ke_status = umarshal_message_exchange_response(out_buff, &secret_response);
+    if(ke_status != SUCCESS)
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        SAFE_FREE(out_buff);
+        return ke_status;
+    }
+
+    SAFE_FREE(marshalled_inp_buff);
+    SAFE_FREE(out_buff);
+    SAFE_FREE(secret_response);
+    return SUCCESS;
+}
+
+
+//Makes use of the sample code function to close a current session
+uint32_t test_close_session(sgx_enclave_id_t src_enclave_id,
+                                sgx_enclave_id_t dest_enclave_id)
+{
+    dh_session_t dest_session_info;
+    ATTESTATION_STATUS ke_status = SUCCESS;
+    //Search the map for the session information associated with the destination enclave id passed in
+    std::map<sgx_enclave_id_t, dh_session_t>::iterator it = g_src_session_info_map.find(dest_enclave_id);
+    if(it != g_src_session_info_map.end())
+    {
+         dest_session_info = it->second;
+    }
+    else
+    {
+        return NULL;
+    }
+    //Core reference code function for closing a session
+    ke_status = close_session(src_enclave_id, dest_enclave_id);
+
+    //Erase the session information associated with the destination enclave id
+    g_src_session_info_map.erase(dest_enclave_id)
+  return ke_status;
+}
+*/
+//Function that is used to verify the trust of the other enclave
+//Each enclave can have its own way verifying the peer enclave identity
+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;
+    }
+//  sgx_measurement_t actual_mr_enclave = peer_enclave_identity->mr_enclave;
+  sgx_measurement_t actual_mr_signer = peer_enclave_identity->mr_signer;
+    // verifier's mrsigner 
+    uint8_t expected_mr_signer[32] ={0xdf, 0xd7, 0x3b, 0x93, 0xea, 0x39, 0x02, 0x02, 0x3c, 0xd0, 0x52, 0x1a, 0xbd, 0x00, 0xaf, 0xb9, 0xa6, 0x54, 0x57, 0x3e, 0xe5, 0xef, 0x36, 0xf4, 0x8c, 0xc2, 0x4d, 0x92, 0x70, 0xae, 0xd4, 0x7c}; 
+    int count;
+    for(count=0; count<SGX_HASH_SIZE; count++)
+  {
+/*    if( actual_mr_enclave.m[count] != expected_mr_enclave[count] )
+    {
+        return ENCLAVE_TRUST_ERROR;
+    }*/
+    if( actual_mr_signer.m[count] != expected_mr_signer[count] )
+    {
+        return ENCLAVE_TRUST_ERROR; // TODO: Different error here.
+    }
+  }
+//#include "stdlib.h"
+//#include "string"
+//#include "sgx_tcrypto.h"
+//int create_rsa_key_pair_for_signing_manifest(/*std::string& priv_key, std::string& pub_key*/) 
+//{
+        uint32_t ret_sgx;
+        uint8_t* n=(uint8_t*)malloc(384); 
+        uint8_t* d=(uint8_t*)malloc(384); 
+        uint8_t* p=(uint8_t*)malloc(192); 
+        uint8_t* q=(uint8_t*)malloc(192); 
+        uint8_t* dmp1=(uint8_t*)malloc(192); 
+        uint8_t* dmq1=(uint8_t*)malloc(192); 
+        uint8_t* iqmp=(uint8_t*)malloc(192); 
+        int e=3;
+
+        ret_sgx=sgx_create_rsa_key_pair(384, 4, n, d, (unsigned char*)&e, p, q, dmp1, dmq1, iqmp);
+        free(n); free(d); free(p); free(q); free(dmp1); free(dmq1); free(iqmp);
+        return ret_sgx;
+//}
+
+
+
+ /*   if(peer_enclave_identity->isv_prod_id != 0 || !(peer_enclave_identity->attributes.flags & SGX_FLAGS_INITTED))
+    {
+        return ENCLAVE_TRUST_ERROR;
+    }
+    else
+    {
+        return SUCCESS;
+    }*/
+return SUCCESS; //ENCLAVE_TRUST_ERROR;
+}
+/*
+//Dispatch function that calls the approriate enclave function based on the function id
+//Each enclave can have its own way of dispatching the calls from other enclave
+extern "C" uint32_t enclave_to_enclave_call_dispatcher(char* decrypted_data,
+                                                       size_t decrypted_data_length,
+                                                       char** resp_buffer,
+                                                       size_t* resp_length)
+{
+    ms_in_msg_exchange_t *ms;
+    uint32_t (*fn1)(ms_in_msg_exchange_t *ms, size_t, char**, size_t*);
+    if(!decrypted_data || !resp_length)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    ms = (ms_in_msg_exchange_t *)decrypted_data;
+    if(ms->target_fn_id >= func_table.num_funcs)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    fn1 = (uint32_t (*)(ms_in_msg_exchange_t*, size_t, char**, size_t*))func_table.table[ms->target_fn_id];
+    return fn1(ms, decrypted_data_length, resp_buffer, resp_length);
+ return 1; 
+}
+
+//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;
+ return 0x1; 
+}
+
+//Generates the response from the request message
+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;
+
+}
+
+static uint32_t e2_foo1(uint32_t var1, uint32_t var2)
+{
+    return(var1 + var2);
+}
+
+//Function which is executed on request from the source enclave
+static uint32_t e2_foo1_wrapper(ms_in_msg_exchange_t *ms,
+                    size_t param_lenth,
+                    char** resp_buffer,
+                    size_t* resp_length)
+{
+   UNUSED(param_lenth);
+
+    uint32_t var1,var2,ret;
+    if(!ms || !resp_length)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    if(unmarshal_input_parameters_e2_foo1(&var1, &var2, ms) != SUCCESS)
+        return ATTESTATION_ERROR;
+
+    ret = e2_foo1(var1, var2);
+
+    if(marshal_retval_and_output_parameters_e2_foo1(resp_buffer, resp_length, ret) != SUCCESS )
+        return MALLOC_ERROR; //can set resp buffer to null here
+
+    return SUCCESS;
+}
+*/
+
+uint32_t foo()
+{
+return 0;
+}

+ 44 - 0
Decryptor/Decryptor.edl

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2011-2017 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.
+ *
+ */
+
+
+enclave {
+    include "sgx_eid.h"
+    from "../LocalAttestationCode/LocalAttestationCode.edl" import *;
+    from "sgx_tstdc.edl" import *;
+    trusted{
+		public uint32_t foo(); 
+//              public uint32_t test_create_session(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+//            public uint32_t test_enclave_to_enclave_call(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+//            public uint32_t test_message_exchange(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+//            public uint32_t test_close_session(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+    };
+};

+ 10 - 0
Decryptor/Decryptor.lds

@@ -0,0 +1,10 @@
+Enclave2.so
+{
+    global:
+        g_global_data_sim;
+        g_global_data;
+        enclave_entry;
+        g_peak_heap_used;
+    local:
+        *;
+};

+ 39 - 0
Decryptor/Decryptor_private.pem

@@ -0,0 +1,39 @@
+-----BEGIN RSA PRIVATE KEY-----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+-----END RSA PRIVATE KEY-----

+ 213 - 0
Decryptor/Utility_Decryptor.cpp

@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2011-2017 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.
+ *
+ */
+
+#include "sgx_eid.h"
+#include "EnclaveMessageExchange.h"
+#include "error_codes.h"
+#include "Utility_Decryptor.h"
+#include "stdlib.h"
+#include "string.h"
+
+uint32_t marshal_input_parameters_e3_foo1(uint32_t target_fn_id, uint32_t msg_type, param_struct_t *p_struct_var, char** marshalled_buff, size_t* marshalled_buff_len)
+{
+    ms_in_msg_exchange_t *ms;
+    size_t param_len, ms_len;
+    char *temp_buff;
+    if(!p_struct_var || !marshalled_buff_len)
+        return INVALID_PARAMETER_ERROR;    
+    param_len = sizeof(param_struct_t);
+    temp_buff = (char*)malloc(param_len);
+    if(!temp_buff)
+        return MALLOC_ERROR;
+    memcpy(temp_buff, p_struct_var, sizeof(param_struct_t)); //can be optimized
+    ms_len = sizeof(ms_in_msg_exchange_t) + param_len;
+    ms = (ms_in_msg_exchange_t *)malloc(ms_len);
+    if(!ms)
+    {
+        SAFE_FREE(temp_buff);
+        return MALLOC_ERROR;
+    }
+    ms->msg_type = msg_type;
+    ms->target_fn_id = target_fn_id;
+    ms->inparam_buff_len = (uint32_t)param_len;
+    memcpy(&ms->inparam_buff, temp_buff, param_len);
+    *marshalled_buff = (char*)ms;
+    *marshalled_buff_len = ms_len;
+    SAFE_FREE(temp_buff);
+    return SUCCESS;
+}
+
+uint32_t unmarshal_retval_and_output_parameters_e3_foo1(char* out_buff, param_struct_t *p_struct_var, char** retval)
+{
+    size_t retval_len;
+    ms_out_msg_exchange_t *ms;
+    if(!out_buff)
+        return INVALID_PARAMETER_ERROR;
+    ms = (ms_out_msg_exchange_t *)out_buff;
+    retval_len = ms->retval_len;
+    *retval = (char*)malloc(retval_len);
+    if(!*retval)
+    {
+        return MALLOC_ERROR;
+    }
+    memcpy(*retval, ms->ret_outparam_buff, retval_len);
+    memcpy(&p_struct_var->var1, (ms->ret_outparam_buff) + retval_len, sizeof(p_struct_var->var1));
+    memcpy(&p_struct_var->var2, (ms->ret_outparam_buff) + retval_len + sizeof(p_struct_var->var1), sizeof(p_struct_var->var2));
+    return SUCCESS;
+}
+
+
+uint32_t unmarshal_input_parameters_e2_foo1(uint32_t* var1, uint32_t* var2, ms_in_msg_exchange_t* ms)
+{
+    char* buff;
+    size_t len;
+    if(!var1 || !var2 || !ms)
+        return INVALID_PARAMETER_ERROR;
+
+    buff = ms->inparam_buff;
+    len = ms->inparam_buff_len;
+
+    if(len != (sizeof(*var1) + sizeof(*var2)))
+        return ATTESTATION_ERROR;
+
+    memcpy(var1, buff, sizeof(*var1));
+    memcpy(var2, buff + sizeof(*var1), sizeof(*var2));
+
+    return SUCCESS;
+}
+
+uint32_t marshal_retval_and_output_parameters_e2_foo1(char** resp_buffer, size_t* resp_length, uint32_t retval)
+{
+    ms_out_msg_exchange_t *ms;
+    size_t ret_param_len, ms_len;
+    char *temp_buff;
+    size_t retval_len;
+    if(!resp_length)
+        return INVALID_PARAMETER_ERROR;
+    retval_len = sizeof(retval);
+    ret_param_len = retval_len; //no out parameters
+    temp_buff = (char*)malloc(ret_param_len);
+    if(!temp_buff)
+        return MALLOC_ERROR;
+
+    memcpy(temp_buff, &retval, sizeof(retval)); 
+    ms_len = sizeof(ms_out_msg_exchange_t) + ret_param_len;
+    ms = (ms_out_msg_exchange_t *)malloc(ms_len);
+    if(!ms)
+    {
+        SAFE_FREE(temp_buff);
+        return MALLOC_ERROR;
+    }
+    ms->retval_len = (uint32_t)retval_len;
+    ms->ret_outparam_buff_len = (uint32_t)ret_param_len;
+    memcpy(&ms->ret_outparam_buff, temp_buff, ret_param_len);
+    *resp_buffer = (char*)ms;
+    *resp_length = ms_len;
+    SAFE_FREE(temp_buff);
+    return SUCCESS;
+}
+
+uint32_t marshal_message_exchange_request(uint32_t target_fn_id, uint32_t msg_type, uint32_t secret_data, char** marshalled_buff, size_t* marshalled_buff_len)
+{
+    ms_in_msg_exchange_t *ms;
+    size_t secret_data_len, ms_len;
+    if(!marshalled_buff_len)
+        return INVALID_PARAMETER_ERROR;    
+    secret_data_len = sizeof(secret_data);
+    ms_len = sizeof(ms_in_msg_exchange_t) + secret_data_len;
+    ms = (ms_in_msg_exchange_t *)malloc(ms_len);
+    if(!ms)
+        return MALLOC_ERROR;
+
+    ms->msg_type = msg_type;
+    ms->target_fn_id = target_fn_id;
+    ms->inparam_buff_len = (uint32_t)secret_data_len;
+    memcpy(&ms->inparam_buff, &secret_data, secret_data_len);
+    *marshalled_buff = (char*)ms;
+    *marshalled_buff_len = ms_len;
+    return SUCCESS;
+}
+
+uint32_t umarshal_message_exchange_request(uint32_t* inp_secret_data, ms_in_msg_exchange_t* ms)
+{
+    char* buff;
+    size_t len;
+    if(!inp_secret_data || !ms)
+        return INVALID_PARAMETER_ERROR;    
+    buff = ms->inparam_buff;
+    len = ms->inparam_buff_len;
+    if(len != sizeof(uint32_t))
+        return ATTESTATION_ERROR;
+
+    memcpy(inp_secret_data, buff, sizeof(uint32_t));
+
+    return SUCCESS;
+}
+
+
+uint32_t marshal_message_exchange_response(char** resp_buffer, size_t* resp_length, uint32_t secret_response)
+{
+    ms_out_msg_exchange_t *ms;
+    size_t secret_response_len, ms_len;
+    size_t retval_len, ret_param_len;
+    if(!resp_length)
+        return INVALID_PARAMETER_ERROR;    
+    secret_response_len = sizeof(secret_response);
+    retval_len = secret_response_len;
+    ret_param_len = secret_response_len;
+    ms_len = sizeof(ms_out_msg_exchange_t) + ret_param_len;
+    ms = (ms_out_msg_exchange_t *)malloc(ms_len);
+    if(!ms)
+        return MALLOC_ERROR;
+    ms->retval_len = (uint32_t)retval_len;
+    ms->ret_outparam_buff_len = (uint32_t)ret_param_len;
+    memcpy(&ms->ret_outparam_buff, &secret_response, secret_response_len);
+    *resp_buffer = (char*)ms;
+    *resp_length = ms_len;
+     return SUCCESS;
+}
+
+uint32_t umarshal_message_exchange_response(char* out_buff, char** secret_response)
+{
+    size_t retval_len;
+    ms_out_msg_exchange_t *ms;
+    if(!out_buff)
+        return INVALID_PARAMETER_ERROR;    
+    ms = (ms_out_msg_exchange_t *)out_buff;
+    retval_len = ms->retval_len;
+    *secret_response = (char*)malloc(retval_len);
+    if(!*secret_response)
+    {
+        return MALLOC_ERROR;
+    }
+    memcpy(*secret_response, ms->ret_outparam_buff, retval_len);
+    return SUCCESS;
+}

+ 59 - 0
Decryptor/Utility_Decryptor.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2011-2017 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.
+ *
+ */
+
+#ifndef UTILITY_E2_H__
+#define UTILITY_E2_H__
+#include "stdint.h"
+
+typedef struct _param_struct_t
+{
+    uint32_t var1;
+    uint32_t var2;
+}param_struct_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint32_t marshal_input_parameters_e3_foo1(uint32_t target_fn_id, uint32_t msg_type, param_struct_t *p_struct_var, char** marshalled_buff, size_t* marshalled_buff_len);
+uint32_t unmarshal_retval_and_output_parameters_e3_foo1(char* out_buff, param_struct_t *p_struct_var, char** retval);
+uint32_t unmarshal_input_parameters_e2_foo1(uint32_t* var1, uint32_t* var2, ms_in_msg_exchange_t* ms);
+uint32_t marshal_retval_and_output_parameters_e2_foo1(char** resp_buffer, size_t* resp_length, uint32_t retval);
+uint32_t marshal_message_exchange_request(uint32_t target_fn_id, uint32_t msg_type, uint32_t secret_data, char** marshalled_buff, size_t* marshalled_buff_len);
+uint32_t umarshal_message_exchange_request(uint32_t* inp_secret_data, ms_in_msg_exchange_t* ms);
+uint32_t marshal_message_exchange_response(char** resp_buffer, size_t* resp_length, uint32_t secret_response);
+uint32_t umarshal_message_exchange_response(char* out_buff, char** secret_response);
+
+#ifdef __cplusplus
+ }
+#endif
+#endif
+

+ 6 - 0
Include/SgxProtobufLATransforms_initiator.h

@@ -0,0 +1,6 @@
+int write_protobuf_msg_to_fd(int accept_fd, google::protobuf::MessageLite& message);
+int read_protobuf_msg_from_fd(int accept_fd, google::protobuf::MessageLite& message);
+int print_initialized_msg1( protobuf_sgx_dh_msg1_t& protobuf_dhmsg1, sgx_dh_msg1_t* native_dhmsg1);
+int decode_msg2_from_protobuf(protobuf_sgx_dh_msg2_t& protobuf_dhmsg2, sgx_dh_msg2_t* native_dhmsg2);
+void encode_msg3_to_protobuf(protobuf_sgx_dh_msg3_t& protobuf_dhmsg3, sgx_dh_msg3_t* native_dhmsg3);
+void encode_msg1_to_protobuf( protobuf_sgx_dh_msg1_t& protobuf_dhmsg1, sgx_dh_msg1_t* native_dhmsg1);

+ 68 - 0
Include/dh_session_protocol.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2011-2017 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.
+ *
+ */
+
+#ifndef _DH_SESSION_PROROCOL_H
+#define _DH_SESSION_PROROCOL_H
+
+#include "sgx_ecp_types.h"
+#include "sgx_key.h"
+#include "sgx_report.h"
+#include "sgx_attributes.h"
+
+#define NONCE_SIZE         16
+#define MAC_SIZE           16
+
+#define MSG_BUF_LEN        sizeof(ec_pub_t)*2
+#define MSG_HASH_SZ        32
+
+
+//Session information structure
+typedef struct _la_dh_session_t
+{
+    uint32_t  session_id; //Identifies the current session
+    uint32_t  status; //Indicates session is in progress, active or closed
+    union
+    {
+        struct
+        {
+			sgx_dh_session_t dh_session;
+        }in_progress;
+
+        struct
+        {
+            sgx_key_128bit_t AEK; //Session Key
+            uint32_t counter; //Used to store Message Sequence Number
+        }active;
+    };
+} dh_session_t;
+
+
+#endif

+ 665 - 0
LocalAttestationCode/EnclaveMessageExchange.cpp

@@ -0,0 +1,665 @@
+/*
+ * Copyright (C) 2011-2017 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.
+ *
+ */
+
+
+#include "sgx_trts.h"
+#include "sgx_utils.h"
+#include "EnclaveMessageExchange.h"
+#include "sgx_eid.h"
+#include "error_codes.h"
+#include "sgx_ecp_types.h"
+#include "sgx_thread.h"
+#include <map>
+#include "dh_session_protocol.h"
+#include "sgx_dh.h"
+#include "sgx_tcrypto.h"
+#include "LocalAttestationCode_t.h"
+#include "sgx_tseal.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint32_t enclave_to_enclave_call_dispatcher(char* decrypted_data, size_t decrypted_data_length, char** resp_buffer, size_t* resp_length);
+uint32_t message_exchange_response_generator(char* decrypted_data, char** resp_buffer, size_t* resp_length);
+uint32_t verify_peer_enclave_trust(sgx_dh_session_enclave_identity_t* peer_enclave_identity);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define MAX_SESSION_COUNT  16
+
+//number of open sessions
+// uint32_t g_session_count = 0;
+
+ATTESTATION_STATUS generate_session_id(uint32_t *session_id);
+ATTESTATION_STATUS end_session();
+sgx_ec256_private_t signing_priv_key;
+sgx_ecc_state_handle_t ecc_state;
+
+ uint32_t session_ids[MAX_SESSION_COUNT];
+
+// Our enclave will not be doing LA with more than 1 decryptor enclave at a time.
+// We should not need this.
+//std::map<int, dh_session_t>g_dest_session_info_map;
+dh_session_t global_session_info;
+// TODO: May be we need to store all previously assigned session IDs instead of just the counter; to prevent replay attacks -
+uint32_t global_session_id=0;
+
+
+//Handle the request from Source Enclave for a session
+ATTESTATION_STATUS session_request(sgx_dh_msg1_t *dh_msg1,
+                          uint32_t *session_id )
+{
+ //   dh_session_t session_info;
+    sgx_dh_session_t sgx_dh_session;
+    sgx_status_t status = SGX_SUCCESS;
+
+    if(!session_id || !dh_msg1)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+
+    //Intialize the session as a session responder
+    status = sgx_dh_init_session(SGX_DH_SESSION_RESPONDER, &sgx_dh_session);
+    if(SGX_SUCCESS != status)
+    {
+        return status;
+    }
+
+    *session_id=1;
+
+    global_session_info.status = IN_PROGRESS;
+
+    //Generate Message1 that will be returned to Source Enclave
+    status = sgx_dh_responder_gen_msg1((sgx_dh_msg1_t*)dh_msg1, &sgx_dh_session);
+    if(SGX_SUCCESS != status)
+    {
+        global_session_id--;
+        // SAFE_FREE(g_session_id_tracker[*session_id]);
+        return status;
+    }
+    memcpy(&global_session_info.in_progress.dh_session, &sgx_dh_session, sizeof(sgx_dh_session_t));
+//    return sgx_seal_data(0, NULL, 0, NULL, 0, NULL); 
+    //Store the session information under the correspoding source enlave id key
+    //    g_dest_session_info_map.insert(std::pair<sgx_enclave_id_t, dh_session_t>(src_enclave_id, session_info));
+
+    return status;
+}
+
+//Verify Message 2, generate Message3 and exchange Message 3 with Source Enclave
+ATTESTATION_STATUS exchange_report(
+                          sgx_dh_msg2_t *dh_msg2,
+                          sgx_dh_msg3_t *dh_msg3,
+                          uint32_t* session_id)
+{
+
+    sgx_key_128bit_t dh_aek;   // Session key
+//    dh_session_t session_info;
+    ATTESTATION_STATUS status = SUCCESS;
+    sgx_dh_session_t sgx_dh_session;
+    sgx_dh_session_enclave_identity_t initiator_identity;
+
+    if(!dh_msg2 || !dh_msg3)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+
+    memset(&dh_aek,0, sizeof(sgx_key_128bit_t));
+// Why is there a do-while loop anyway? It seems like there is no successful exit ... 
+//    do
+//    {
+      // TODO: Make sure that this works - pointers
+//        session_info = global_session_info;
+
+        if(global_session_info.status != IN_PROGRESS)
+        {
+            status = INVALID_SESSION;
+            end_session(); 
+        }
+
+        memcpy(&sgx_dh_session, &global_session_info.in_progress.dh_session, sizeof(sgx_dh_session_t));
+
+        dh_msg3->msg3_body.additional_prop_length = 0;
+        //Process message 2 from source enclave and obtain message 3
+        sgx_status_t se_ret = sgx_dh_responder_proc_msg2(dh_msg2,
+                                                       dh_msg3,
+                                                       &sgx_dh_session,
+                                                       &dh_aek,
+                                                       &initiator_identity);
+        if(SGX_SUCCESS != se_ret)
+        {
+            status = se_ret;
+            end_session();
+        }
+
+        // THIS IS WHERE THE DECRYPTOR VERIFIES THE APACHE'S MRSIGNER IS THE PUBLIC KEY GIVEN AFTER THE LOCAL ATTESTATION WITH THE VERIFIER.
+        //Verify source enclave's trust
+        uint32_t ret = verify_peer_enclave_trust(&initiator_identity);
+        if(ret != SUCCESS)
+        {
+            return ret; //INVALID_SESSION;
+        }
+	
+	// TODO: Verify that these changes will be lost on update. 
+        //save the session ID, status and initialize the session nonce
+        global_session_info.session_id = *session_id;
+        global_session_info.status = ACTIVE;
+        global_session_info.active.counter = 0;
+        memcpy(&global_session_info.active.AEK, &dh_aek, sizeof(sgx_key_128bit_t));
+        memset(&dh_aek,0, sizeof(sgx_key_128bit_t));
+        //g_session_count++;*/
+//    }while(0);
+
+
+    return status;
+}
+/*
+uint32_t create_ecdsa_key_pair( sgx_ec256_public_t* pub_key ) 
+{
+//sgx_ec256_public_t pub_key;
+sgx_status_t se_ret; 
+//create ECC context
+ecc_state = NULL;
+
+se_ret = sgx_ecc256_open_context(&ecc_state);
+if(SGX_SUCCESS != se_ret)
+{
+   return se_ret;
+}
+// generate private key and public key
+se_ret = sgx_ecc256_create_key_pair(&signing_priv_key, pub_key, ecc_state);
+if(SGX_SUCCESS != se_ret)
+  return se_ret; 
+
+se_ret = sgx_ecc256_close_context(ecc_state); 
+// if(SGX_SUCCESS != se_ret)
+//  return se_ret; 
+
+return se_ret; 
+
+}
+*/
+/*
+uint32_t generate_and_seal_signing_private_key(uint8_t* pub_key, )
+{
+    uint32_t ret_status; 
+    ret_status=create_ecdsa_key_pair(pub_key); 
+    if(ret_status!=SGX_SUCCESS) 
+       return ret_status; 
+    uint8_t* public_key_string = (uint8_t*) malloc(2*SGX_ECP256_KEY_SIZE); 
+    uint32_t counter;
+    for(counter=0;counter<SGX_ECP256_KEY_SIZE; counter++)
+    {
+	*(public_key_string+counter)=pub_key->gx[counter];
+    }
+    for(counter=SGX_ECP256_KEY_SIZE;counter<2*SGX_ECP256_KEY_SIZE; counter++)
+    {
+        *(public_key_string+counter)=pub_key->gy[counter];
+    }
+
+    // sgx_seal_data() call 
+    uint32_t expected_sealed_data_length=sgx_calc_sealed_data_size(0,2*ECP256_KEY_SIZE); 
+    if(expected_sealed_data_length == 0xFFFFFFFF)
+	return 0xFFFFFFFF; 
+    uint8_t* sealed_data=(uint8_t*) malloc(expected_sealed_data_length);
+    sgx_sealed_data_t sealed_data; 
+    sgx_seal_data(0, NULL, public_key_string, 2*ECP256_KEY_SIZE, );
+    free(public_key_string); 
+
+}
+*/
+/*
+uint32_t sign_with_signing_private_key(uint8_t* data, uint8_t* length) 
+{
+
+
+
+}
+*/
+// uint32_t create_
+
+
+/*
+//Request for the response size, send the request message to the destination enclave and receive the response message back
+ATTESTATION_STATUS send_request_receive_response(
+                                  sgx_enclave_id_t dest_enclave_id,
+                                  dh_session_t *session_info,
+                                  char *inp_buff,
+                                  size_t inp_buff_len,
+                                  size_t max_out_buff_size,
+                                  char **out_buff,
+                                  size_t* out_buff_len)
+{
+    const uint8_t* plaintext;
+    uint32_t plaintext_length;
+    sgx_status_t status;
+    uint32_t retstatus;
+    secure_message_t* req_message;
+    secure_message_t* resp_message;
+    uint8_t *decrypted_data;
+    uint32_t decrypted_data_length;
+    uint32_t plain_text_offset;
+    uint8_t l_tag[TAG_SIZE];
+    size_t max_resp_message_length;
+    plaintext = (const uint8_t*)(" ");
+    plaintext_length = 0;
+
+    if(!session_info || !inp_buff)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    // TODO: Figure out what this was supposed to be for.
+    //Check if the nonce for the session has not exceeded 2^32-2 if so end session and start a new session
+    if(session_info->active.counter == ((uint32_t) - 2))
+    {
+        close_session(src_enclave_id, dest_enclave_id);
+        create_session(src_enclave_id, dest_enclave_id, session_info);
+    }
+
+    //Allocate memory for the AES-GCM request message
+    req_message = (secure_message_t*)malloc(sizeof(secure_message_t)+ inp_buff_len);
+    if(!req_message)
+    {
+        return MALLOC_ERROR;
+    }
+
+    memset(req_message,0,sizeof(secure_message_t)+ inp_buff_len);
+    const uint32_t data2encrypt_length = (uint32_t)inp_buff_len;
+    //Set the payload size to data to encrypt length
+    req_message->message_aes_gcm_data.payload_size = data2encrypt_length;
+
+    //Use the session nonce as the payload IV
+    memcpy(req_message->message_aes_gcm_data.reserved,&session_info->active.counter,sizeof(session_info->active.counter));
+
+    //Set the session ID of the message to the current session id
+    req_message->session_id = session_info->session_id;
+
+    //Prepare the request message with the encrypted payload
+    status = sgx_rijndael128GCM_encrypt(&session_info->active.AEK, (uint8_t*)inp_buff, data2encrypt_length,
+                reinterpret_cast<uint8_t *>(&(req_message->message_aes_gcm_data.payload)),
+                reinterpret_cast<uint8_t *>(&(req_message->message_aes_gcm_data.reserved)),
+                sizeof(req_message->message_aes_gcm_data.reserved), plaintext, plaintext_length,
+                &(req_message->message_aes_gcm_data.payload_tag));
+
+    if(SGX_SUCCESS != status)
+    {
+        SAFE_FREE(req_message);
+        return status;
+    }
+
+    //Allocate memory for the response payload to be copied
+    *out_buff = (char*)malloc(max_out_buff_size);
+    if(!*out_buff)
+    {
+        SAFE_FREE(req_message);
+        return MALLOC_ERROR;
+    }
+
+    memset(*out_buff, 0, max_out_buff_size);
+
+    //Allocate memory for the response message
+    resp_message = (secure_message_t*)malloc(sizeof(secure_message_t)+ max_out_buff_size);
+    if(!resp_message)
+    {
+        SAFE_FREE(req_message);
+        return MALLOC_ERROR;
+    }
+
+    memset(resp_message, 0, sizeof(secure_message_t)+ max_out_buff_size);
+
+    // TODO: This should not exist.
+    //Ocall to send the request to the Destination Enclave and get the response message back
+    status = send_request_ocall(&retstatus, src_enclave_id, dest_enclave_id, req_message,
+                                (sizeof(secure_message_t)+ inp_buff_len), max_out_buff_size,
+                                resp_message, (sizeof(secure_message_t)+ max_out_buff_size));
+    if (status == SGX_SUCCESS)
+    {
+        if ((ATTESTATION_STATUS)retstatus != SUCCESS)
+        {
+            SAFE_FREE(req_message);
+            SAFE_FREE(resp_message);
+            return ((ATTESTATION_STATUS)retstatus);
+        }
+    }
+    else
+    {
+        SAFE_FREE(req_message);
+        SAFE_FREE(resp_message);
+        return ATTESTATION_SE_ERROR;
+    }
+
+    max_resp_message_length = sizeof(secure_message_t)+ max_out_buff_size;
+
+    if(sizeof(resp_message) > max_resp_message_length)
+    {
+        SAFE_FREE(req_message);
+        SAFE_FREE(resp_message);
+        return INVALID_PARAMETER_ERROR;
+    }
+
+    //Code to process the response message from the Destination Enclave
+
+    decrypted_data_length = resp_message->message_aes_gcm_data.payload_size;
+    plain_text_offset = decrypted_data_length;
+    decrypted_data = (uint8_t*)malloc(decrypted_data_length);
+    if(!decrypted_data)
+    {
+        SAFE_FREE(req_message);
+        SAFE_FREE(resp_message);
+        return MALLOC_ERROR;
+    }
+    memset(&l_tag, 0, 16);
+
+    memset(decrypted_data, 0, decrypted_data_length);
+
+    //Decrypt the response message payload
+    status = sgx_rijndael128GCM_decrypt(&session_info->active.AEK, resp_message->message_aes_gcm_data.payload,
+                decrypted_data_length, decrypted_data,
+                reinterpret_cast<uint8_t *>(&(resp_message->message_aes_gcm_data.reserved)),
+                sizeof(resp_message->message_aes_gcm_data.reserved), &(resp_message->message_aes_gcm_data.payload[plain_text_offset]), plaintext_length,
+                &resp_message->message_aes_gcm_data.payload_tag);
+
+    if(SGX_SUCCESS != status)
+    {
+        SAFE_FREE(req_message);
+        SAFE_FREE(decrypted_data);
+        SAFE_FREE(resp_message);
+        return status;
+    }
+
+    // Verify if the nonce obtained in the response is equal to the session nonce + 1 (Prevents replay attacks)
+    if(*(resp_message->message_aes_gcm_data.reserved) != (session_info->active.counter + 1 ))
+    {
+        SAFE_FREE(req_message);
+        SAFE_FREE(resp_message);
+        SAFE_FREE(decrypted_data);
+        return INVALID_PARAMETER_ERROR;
+    }
+
+        //Update the value of the session nonce in the source enclave
+    session_info->active.counter = session_info->active.counter + 1;
+
+    memcpy(out_buff_len, &decrypted_data_length, sizeof(decrypted_data_length));
+    memcpy(*out_buff, decrypted_data, decrypted_data_length);
+
+    SAFE_FREE(decrypted_data);
+    SAFE_FREE(req_message);
+    SAFE_FREE(resp_message);
+    return SUCCESS;
+
+
+}
+*/
+
+/*
+//Process the request from the Source enclave and send the response message back to the Source enclave
+ATTESTATION_STATUS generate_response(sgx_enclave_id_t src_enclave_id,
+                                     secure_message_t* req_message,
+                                     size_t req_message_size,
+                                     size_t max_payload_size,
+                                     secure_message_t* resp_message,
+                                     size_t resp_message_size)
+{
+    const uint8_t* plaintext;
+    uint32_t plaintext_length;
+    uint8_t *decrypted_data;
+    uint32_t decrypted_data_length;
+    uint32_t plain_text_offset;
+    ms_in_msg_exchange_t * ms;
+    size_t resp_data_length;
+    size_t resp_message_calc_size;
+    char* resp_data;
+    uint8_t l_tag[TAG_SIZE];
+    size_t header_size, expected_payload_size;
+    dh_session_t *session_info;
+    secure_message_t* temp_resp_message;
+    uint32_t ret;
+    sgx_status_t status;
+
+    plaintext = (const uint8_t*)(" ");
+    plaintext_length = 0;
+
+    if(!req_message || !resp_message)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+// TODO: Set session_info from somewhere.
+
+    //Get the session information from the map corresponding to the source enclave id
+    std::map<sgx_enclave_id_t, dh_session_t>::iterator it = g_dest_session_info_map.find(src_enclave_id);
+    if(it != g_dest_session_info_map.end())
+    {
+        session_info = &it->second;
+    }
+    else
+    {
+        return INVALID_SESSION;
+    }
+
+    if(session_info->status != ACTIVE)
+    {
+        return INVALID_SESSION;
+    }
+
+    //Set the decrypted data length to the payload size obtained from the message
+    decrypted_data_length = req_message->message_aes_gcm_data.payload_size;
+
+    header_size = sizeof(secure_message_t);
+    expected_payload_size = req_message_size - header_size;
+
+    //Verify the size of the payload
+    if(expected_payload_size != decrypted_data_length)
+        return INVALID_PARAMETER_ERROR;
+
+    memset(&l_tag, 0, 16);
+    plain_text_offset = decrypted_data_length;
+    decrypted_data = (uint8_t*)malloc(decrypted_data_length);
+    if(!decrypted_data)
+    {
+            return MALLOC_ERROR;
+    }
+
+    memset(decrypted_data, 0, decrypted_data_length);
+
+    //Decrypt the request message payload from source enclave
+    status = sgx_rijndael128GCM_decrypt(&session_info->active.AEK, req_message->message_aes_gcm_data.payload,
+                decrypted_data_length, decrypted_data,
+                reinterpret_cast<uint8_t *>(&(req_message->message_aes_gcm_data.reserved)),
+                sizeof(req_message->message_aes_gcm_data.reserved), &(req_message->message_aes_gcm_data.payload[plain_text_offset]), plaintext_length,
+                &req_message->message_aes_gcm_data.payload_tag);
+
+    if(SGX_SUCCESS != status)
+    {
+        SAFE_FREE(decrypted_data);
+        return status;
+    }
+
+    //Casting the decrypted data to the marshaling structure type to obtain type of request (generic message exchange/enclave to enclave call)
+    ms = (ms_in_msg_exchange_t *)decrypted_data;
+
+
+    // Verify if the nonce obtained in the request is equal to the session nonce
+    if((uint32_t)*(req_message->message_aes_gcm_data.reserved) != session_info->active.counter || *(req_message->message_aes_gcm_data.reserved) > ((2^32)-2))
+    {
+        SAFE_FREE(decrypted_data);
+        return INVALID_PARAMETER_ERROR;
+    }
+
+    if(ms->msg_type == MESSAGE_EXCHANGE)
+    {
+        //Call the generic secret response generator for message exchange
+        ret = message_exchange_response_generator((char*)decrypted_data, &resp_data, &resp_data_length);
+        if(ret !=0)
+        {
+            SAFE_FREE(decrypted_data);
+            SAFE_FREE(resp_data);
+            return INVALID_SESSION;
+        }
+    }
+    else if(ms->msg_type == ENCLAVE_TO_ENCLAVE_CALL)
+    {
+        //Call the destination enclave's dispatcher to call the appropriate function in the destination enclave
+        ret = enclave_to_enclave_call_dispatcher((char*)decrypted_data, decrypted_data_length, &resp_data, &resp_data_length);
+        if(ret !=0)
+        {
+            SAFE_FREE(decrypted_data);
+            SAFE_FREE(resp_data);
+            return INVALID_SESSION;
+        }
+    }
+    else
+    {
+        SAFE_FREE(decrypted_data);
+        return INVALID_REQUEST_TYPE_ERROR;
+    }
+
+
+    if(resp_data_length > max_payload_size)
+    {
+        SAFE_FREE(resp_data);
+        SAFE_FREE(decrypted_data);
+        return OUT_BUFFER_LENGTH_ERROR;
+    }
+
+    resp_message_calc_size = sizeof(secure_message_t)+ resp_data_length;
+
+    if(resp_message_calc_size > resp_message_size)
+    {
+        SAFE_FREE(resp_data);
+        SAFE_FREE(decrypted_data);
+        return OUT_BUFFER_LENGTH_ERROR;
+    }
+
+    //Code to build the response back to the Source Enclave
+    temp_resp_message = (secure_message_t*)malloc(resp_message_calc_size);
+    if(!temp_resp_message)
+    {
+            SAFE_FREE(resp_data);
+            SAFE_FREE(decrypted_data);
+            return MALLOC_ERROR;
+    }
+
+    memset(temp_resp_message,0,sizeof(secure_message_t)+ resp_data_length);
+    const uint32_t data2encrypt_length = (uint32_t)resp_data_length;
+    temp_resp_message->session_id = session_info->session_id;
+    temp_resp_message->message_aes_gcm_data.payload_size = data2encrypt_length;
+
+    //Increment the Session Nonce (Replay Protection)
+    session_info->active.counter = session_info->active.counter + 1;
+
+    //Set the response nonce as the session nonce
+    memcpy(&temp_resp_message->message_aes_gcm_data.reserved,&session_info->active.counter,sizeof(session_info->active.counter));
+
+    //Prepare the response message with the encrypted payload
+    status = sgx_rijndael128GCM_encrypt(&session_info->active.AEK, (uint8_t*)resp_data, data2encrypt_length,
+                reinterpret_cast<uint8_t *>(&(temp_resp_message->message_aes_gcm_data.payload)),
+                reinterpret_cast<uint8_t *>(&(temp_resp_message->message_aes_gcm_data.reserved)),
+                sizeof(temp_resp_message->message_aes_gcm_data.reserved), plaintext, plaintext_length,
+                &(temp_resp_message->message_aes_gcm_data.payload_tag));
+
+    if(SGX_SUCCESS != status)
+    {
+        SAFE_FREE(resp_data);
+        SAFE_FREE(decrypted_data);
+        SAFE_FREE(temp_resp_message);
+        return status;
+    }
+
+    memset(resp_message, 0, sizeof(secure_message_t)+ resp_data_length);
+    memcpy(resp_message, temp_resp_message, sizeof(secure_message_t)+ resp_data_length);
+
+    SAFE_FREE(decrypted_data);
+    SAFE_FREE(resp_data);
+    SAFE_FREE(temp_resp_message);
+
+    return SUCCESS;
+}
+*/
+/*
+//Close a current session
+ATTESTATION_STATUS close_session(sgx_enclave_id_t src_enclave_id,
+                        sgx_enclave_id_t dest_enclave_id)
+{
+    sgx_status_t status;
+
+    uint32_t retstatus;
+
+    //Ocall to ask the destination enclave to end the session
+    status = end_session_ocall(&retstatus, src_enclave_id, dest_enclave_id);
+    if (status == SGX_SUCCESS)
+    {
+        if ((ATTESTATION_STATUS)retstatus != SUCCESS)
+            return ((ATTESTATION_STATUS)retstatus);
+    }
+    else
+    {
+        return ATTESTATION_SE_ERROR;
+    }
+    return SUCCESS;
+}
+*/
+// TODO: Fix this.
+//Respond to the request from the Source Enclave to close the session
+ATTESTATION_STATUS end_session(/**/)
+{
+  return SUCCESS;
+}
+/*
+// Session_id is set to the first index of the pointer array that is non-null.(Not sure how it is ensured that all of them point to NULL at the start)
+// Why can't it just keep a counter that is incremented? What are the values of g_session_id_tracker array?
+//Returns a new sessionID for the source destination session
+ATTESTATION_STATUS generate_session_id(uint32_t *session_id)
+{
+    ATTESTATION_STATUS status = SUCCESS;
+
+    if(!session_id)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    //if the session structure is untintialized, set that as the next session ID
+    for (int i = 0; i < MAX_SESSION_COUNT; i++)
+    {
+        if (g_session_id_tracker[i] == NULL)
+        {
+            *session_id = i;
+            return status;
+        }
+    }
+
+    status = NO_AVAILABLE_SESSION_ERROR;
+
+    return status;
+*/
+  // *session_id=++global_session_id;
+//}
+
+

+ 54 - 0
LocalAttestationCode/EnclaveMessageExchange.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2011-2017 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.
+ *
+ */
+
+
+#include "datatypes.h"
+#include "sgx_eid.h"
+#include "sgx_trts.h"
+#include <map>
+#include "dh_session_protocol.h"
+
+#ifndef LOCALATTESTATION_H_
+#define LOCALATTESTATION_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint32_t SGXAPI create_session(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id, dh_session_t *p_session_info);
+uint32_t SGXAPI send_request_receive_response(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id, dh_session_t *p_session_info, char *inp_buff, size_t inp_buff_len, size_t max_out_buff_size, char **out_buff, size_t* out_buff_len);
+uint32_t SGXAPI close_session(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

+ 53 - 0
LocalAttestationCode/LocalAttestationCode.edl

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2011-2017 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.
+ *
+ */
+
+enclave  {
+    include "sgx_eid.h"
+    include "datatypes.h"
+    include "../Include/dh_session_protocol.h"
+    trusted{
+        public uint32_t session_request([out] sgx_dh_msg1_t *dh_msg1, [out] uint32_t *session_id);
+        public uint32_t exchange_report([in] sgx_dh_msg2_t *dh_msg2, [out] sgx_dh_msg3_t *dh_msg3, [in] uint32_t *session_id);
+//	public uint32_t create_ecdsa_signing_key_pair(); 
+//	public uint32_t create_ecdsa_signing_key_pair([in, out]sgx_ec256_public_t* pub_key);
+
+        // public uint32_t generate_response([in, size = req_message_size] secure_message_t* req_message, size_t req_message_size, size_t max_payload_size, [out, size=resp_message_size] secure_message_t* resp_message, size_t resp_message_size );
+        public uint32_t end_session();
+    };
+    untrusted{
+    /*
+        uint32_t session_request_ocall(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id, [out] sgx_dh_msg1_t *dh_msg1,[out] uint32_t *session_id);
+        uint32_t exchange_report_ocall(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id, [in] sgx_dh_msg2_t *dh_msg2, [out] sgx_dh_msg3_t *dh_msg3, uint32_t session_id);
+        uint32_t send_request_ocall(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id, [in, size = req_message_size] secure_message_t* req_message, size_t req_message_size, size_t max_payload_size, [out, size=resp_message_size] secure_message_t* resp_message, size_t resp_message_size);
+        uint32_t end_session_ocall(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+    */
+    };
+};

+ 105 - 0
LocalAttestationCode/datatypes.h

@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2011-2017 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.
+ *
+ */
+
+#include "sgx_report.h"
+#include "sgx_eid.h"
+#include "sgx_ecp_types.h"
+#include "sgx_dh.h"
+#include "sgx_tseal.h"
+
+#ifndef DATATYPES_H_
+#define DATATYPES_H_
+
+#define DH_KEY_SIZE        20
+#define NONCE_SIZE         16
+#define MAC_SIZE           16
+#define MAC_KEY_SIZE       16
+#define PADDING_SIZE       16
+
+#define TAG_SIZE        16
+#define IV_SIZE            12
+
+#define DERIVE_MAC_KEY      0x0
+#define DERIVE_SESSION_KEY  0x1
+#define DERIVE_VK1_KEY      0x3
+#define DERIVE_VK2_KEY      0x4
+
+#define CLOSED 0x0
+#define IN_PROGRESS 0x1
+#define ACTIVE 0x2
+
+#define MESSAGE_EXCHANGE 0x0
+#define ENCLAVE_TO_ENCLAVE_CALL 0x1
+
+#define INVALID_ARGUMENT                   -2   ///< Invalid function argument
+#define LOGIC_ERROR                        -3   ///< Functional logic error
+#define FILE_NOT_FOUND                     -4   ///< File not found
+
+#define SAFE_FREE(ptr)     {if (NULL != (ptr)) {free(ptr); (ptr)=NULL;}}
+
+#define VMC_ATTRIBUTE_MASK  0xFFFFFFFFFFFFFFCB
+
+typedef uint8_t dh_nonce[NONCE_SIZE];
+typedef uint8_t cmac_128[MAC_SIZE];
+
+#pragma pack(push, 1)
+
+//Format of the AES-GCM message being exchanged between the source and the destination enclaves
+typedef struct _secure_message_t
+{
+    uint32_t session_id; //Session ID identifyting the session to which the message belongs
+    sgx_aes_gcm_data_t message_aes_gcm_data;    
+}secure_message_t;
+
+//Format of the input function parameter structure
+typedef struct _ms_in_msg_exchange_t {
+    uint32_t msg_type; //Type of Call E2E or general message exchange
+    uint32_t target_fn_id; //Function Id to be called in Destination. Is valid only when msg_type=ENCLAVE_TO_ENCLAVE_CALL
+    uint32_t inparam_buff_len; //Length of the serialized input parameters
+    char inparam_buff[]; //Serialized input parameters
+} ms_in_msg_exchange_t;
+
+//Format of the return value and output function parameter structure
+typedef struct _ms_out_msg_exchange_t {
+    uint32_t retval_len; //Length of the return value
+    uint32_t ret_outparam_buff_len; //Length of the serialized return value and output parameters
+    char ret_outparam_buff[]; //Serialized return value and output parameters
+} ms_out_msg_exchange_t;
+
+//Session Tracker to generate session ids
+typedef struct _session_id_tracker_t
+{
+    uint32_t          session_id;
+}session_id_tracker_t;
+
+#pragma pack(pop)
+
+#endif

+ 53 - 0
LocalAttestationCode/error_codes.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2011-2017 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.
+ *
+ */
+
+#ifndef ERROR_CODES_H_
+#define ERROR_CODES_H_
+
+typedef uint32_t ATTESTATION_STATUS;
+
+#define SUCCESS                          0x00
+#define INVALID_PARAMETER                0xE1
+#define VALID_SESSION                    0xE2
+#define INVALID_SESSION                  0xE3
+#define ATTESTATION_ERROR                0xE4
+#define ATTESTATION_SE_ERROR             0xE5
+#define IPP_ERROR                        0xE6
+#define NO_AVAILABLE_SESSION_ERROR       0xE7
+#define MALLOC_ERROR                     0xE8
+#define ERROR_TAG_MISMATCH               0xE9
+#define OUT_BUFFER_LENGTH_ERROR          0xEA
+#define INVALID_REQUEST_TYPE_ERROR       0xEB
+#define INVALID_PARAMETER_ERROR          0xEC
+#define ENCLAVE_TRUST_ERROR              0xED
+#define ENCRYPT_DECRYPT_ERROR            0xEE
+#define DUPLICATE_SESSION                0xEF
+#endif

+ 287 - 0
Makefile

@@ -0,0 +1,287 @@
+#
+# Copyright (C) 2011-2017 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.
+#
+#
+
+######## SGX SDK Settings ########
+
+SGX_SDK ?= /home/m2mazmud/sgx2.1_original/sgxsdk
+SGX_MODE ?= HW
+SGX_ARCH ?= x64
+SGX_DEBUG ?= 1
+
+ifeq ($(shell getconf LONG_BIT), 32)
+	SGX_ARCH := x86
+else ifeq ($(findstring -m32, $(CXXFLAGS)), -m32)
+	SGX_ARCH := x86
+endif
+
+ifeq ($(SGX_ARCH), x86)
+	SGX_COMMON_CFLAGS := -m32
+	SGX_LIBRARY_PATH := $(SGX_SDK)/lib
+	SGX_ENCLAVE_SIGNER := $(SGX_SDK)/bin/x86/sgx_sign
+	SGX_EDGER8R := $(SGX_SDK)/bin/x86/sgx_edger8r
+else
+	SGX_COMMON_CFLAGS := -m64
+	SGX_LIBRARY_PATH := $(SGX_SDK)/lib64
+	SGX_ENCLAVE_SIGNER := $(SGX_SDK)/bin/x64/sgx_sign
+	SGX_EDGER8R := $(SGX_SDK)/bin/x64/sgx_edger8r
+endif
+
+ifeq ($(SGX_DEBUG), 1)
+ifeq ($(SGX_PRERELEASE), 1)
+$(error Cannot set SGX_DEBUG and SGX_PRERELEASE at the same time!!)
+endif
+endif
+
+ifeq ($(SGX_DEBUG), 1)
+	SGX_COMMON_CFLAGS += -O0 -g
+else
+	SGX_COMMON_CFLAGS += -O2
+endif
+
+######## Library Settings ########
+
+#PHPTrust_Lib_Name := libPHPLocalAttestation_Trusted.a
+#PHPTrustLib_Cpp_Files := $(wildcard PHPLocalAttestationCode/*.cpp)
+#PHPTrustLib_Cpp_Objects := $(PHPTrustLib_Cpp_Files:.cpp=.o)
+#PHPTrustLib_Include_Paths := -I$(SGX_SDK)/include -I$(SGX_SDK)/include/tlibc -I$(SGX_SDK)/include/libcxx -I$(SGX_SDK)/include/epid -I./Include
+#PHPTrustLib_Compile_Flags := $(SGX_COMMON_CFLAGS) -nostdinc -fvisibility=hidden -fpie -fstack-protector  $(TrustLib_Include_Paths)
+#PHPTrustLib_Compile_Cxx_Flags :=  -std=c++11 -nostdinc++
+
+
+
+Trust_Lib_Name := libLocalAttestation_Trusted.a
+TrustLib_Cpp_Files := $(wildcard LocalAttestationCode/*.cpp)
+TrustLib_Cpp_Objects := $(TrustLib_Cpp_Files:.cpp=.o)
+TrustLib_Include_Paths := -I$(SGX_SDK)/include -I$(SGX_SDK)/include/tlibc -I$(SGX_SDK)/include/libcxx -I$(SGX_SDK)/include/epid -I./Include
+TrustLib_Compile_Flags := $(SGX_COMMON_CFLAGS) -nostdinc -fvisibility=hidden -fpie -fstack-protector  $(TrustLib_Include_Paths) -Wall -Wextra -Werror
+TrustLib_Compile_Cxx_Flags :=  -std=c++11 -nostdinc++
+
+#UnTrustLib_Name := libLocalAttestation_unTrusted.a
+#UnTrustLib_Cpp_Files := $(wildcard Untrusted_LocalAttestation/*.cpp)
+#UnTrustLib_Cpp_Objects := $(UnTrustLib_Cpp_Files:.cpp=.o)
+#UnTrustLib_Include_Paths := -I$(SGX_SDK)/include -I$(SGX_SDK)/include/ippcp -I./Include -I./LocalAttestationCode
+#UnTrustLib_Compile_Flags := $(SGX_COMMON_CFLAGS) -fPIC -Wno-attributes -std=c++11 $(UnTrustLib_Include_Paths)
+
+######## App Settings ########
+
+ifneq ($(SGX_MODE), HW)
+	Urts_Library_Name := sgx_urts_sim
+else
+	Urts_Library_Name := sgx_urts
+endif
+
+App_Cpp_Files := $(wildcard App/*.cpp)
+App_Include_Paths := -I$(SGX_SDK)/include -I$(SGX_SDK)/include/ippcp -I./Include -I./LocalAttestationCode
+
+App_Compile_Flags := $(SGX_COMMON_CFLAGS) -fPIC -Wno-attributes $(App_Include_Paths) -Wall -Wextra -Werror
+# Three configuration modes - Debug, prerelease, release
+#   Debug - Macro DEBUG enabled.
+#   Prerelease - Macro NDEBUG and EDEBUG enabled.
+#   Release - Macro NDEBUG enabled.
+ifeq ($(SGX_DEBUG), 1)
+	App_Compile_Flags += -DDEBUG -UNDEBUG -UEDEBUG
+else ifeq ($(SGX_PRERELEASE), 1)
+	App_Compile_Flags += -DNDEBUG -DEDEBUG -UDEBUG
+else
+	App_Compile_Flags += -DNDEBUG -UEDEBUG -UDEBUG
+endif
+
+App_Link_Flags := $(SGX_COMMON_CFLAGS) -L$(SGX_LIBRARY_PATH) -l$(Urts_Library_Name) -L. -lpthread -lprotobuf
+
+ifneq ($(SGX_MODE), HW)
+	App_Link_Flags += -lsgx_uae_service_sim
+else
+	App_Link_Flags += -lsgx_uae_service
+endif
+
+App_Cpp_Objects := $(App_Cpp_Files:.cpp=.o)
+App_Name := app
+
+######## Enclave Settings ########
+
+Decryptor_Version_Script := Decryptor/Decryptor.lds
+
+ifneq ($(SGX_MODE), HW)
+	Trts_Library_Name := sgx_trts_sim
+	Service_Library_Name := sgx_tservice_sim
+else
+	Trts_Library_Name := sgx_trts
+	Service_Library_Name := sgx_tservice
+endif
+Crypto_Library_Name := sgx_tcrypto
+
+Enclave_Cpp_Files_2 := $(wildcard Decryptor/*.cpp)
+Enclave_Include_Paths := -I$(SGX_SDK)/include -I$(SGX_SDK)/include/tlibc -I$(SGX_SDK)/include/libcxx -I./LocalAttestationCode -I./Include
+
+CC_BELOW_4_9 := $(shell expr "`$(CC) -dumpversion`" \< "4.9")
+ifeq ($(CC_BELOW_4_9), 1)
+	Enclave_Compile_Flags := $(SGX_COMMON_CFLAGS) -nostdinc -fvisibility=hidden -fpie -ffunction-sections -fdata-sections -fstack-protector -Wall -Wextra -Werror
+else
+	Enclave_Compile_Flags := $(SGX_COMMON_CFLAGS) -nostdinc -fvisibility=hidden -fpie -ffunction-sections -fdata-sections -fstack-protector-strong -Wall -Wextra -Werror
+endif
+
+Enclave_Compile_Flags += $(Enclave_Include_Paths)
+
+# To generate a proper enclave, it is recommended to follow below guideline to link the trusted libraries:
+#    1. Link sgx_trts with the `--whole-archive' and `--no-whole-archive' options,
+#       so that the whole content of trts is included in the enclave.
+#    2. For other libraries, you just need to pull the required symbols.
+#       Use `--start-group' and `--end-group' to link these libraries.
+# Do NOT move the libraries linked with `--start-group' and `--end-group' within `--whole-archive' and `--no-whole-archive' options.
+# Otherwise, you may get some undesirable errors.
+Common_Enclave_Link_Flags := $(SGX_COMMON_CFLAGS) -Wl,--no-undefined -nostdlib -nodefaultlibs -nostartfiles -L$(SGX_LIBRARY_PATH) \
+	-Wl,--whole-archive -l$(Trts_Library_Name) -Wl,--no-whole-archive \
+	-Wl,--start-group -lsgx_tstdc -lsgx_tcxx -l$(Crypto_Library_Name) -L. -lLocalAttestation_Trusted -l$(Service_Library_Name) -Wl,--end-group \
+	-Wl,-Bstatic -Wl,-Bsymbolic -Wl,--no-undefined \
+	-Wl,-pie,-eenclave_entry -Wl,--export-dynamic  \
+	-Wl,--defsym,__ImageBase=0 -Wl,--gc-sections
+Decryptor_Link_Flags := $(Common_Enclave_Link_Flags) -Wl,--version-script=$(Decryptor_Version_Script)
+Enclave_Cpp_Objects_2 := $(Enclave_Cpp_Files_2:.cpp=.o)
+Enclave_Name_2 := libDecryptor.so
+
+
+ifeq ($(SGX_MODE), HW)
+ifeq ($(SGX_DEBUG), 1)
+	Build_Mode = HW_DEBUG
+else ifeq ($(SGX_PRERELEASE), 1)
+	Build_Mode = HW_PRERELEASE
+else
+	Build_Mode = HW_RELEASE
+endif
+else
+ifeq ($(SGX_DEBUG), 1)
+	Build_Mode = SIM_DEBUG
+else ifeq ($(SGX_PRERELEASE), 1)
+	Build_Mode = SIM_PRERELEASE
+else
+	Build_Mode = SIM_RELEASE
+endif
+endif
+
+ifeq ($(Build_Mode), HW_RELEASE)
+all: .config_$(Build_Mode)_$(SGX_ARCH) $(Trust_Lib_Name)  $(UnTrustLib_Name) Decryptor.so $(App_Name)
+	@echo "The project has been built in release hardware mode."
+	@echo "Please sign the enclaves (PHP.so, Decryptor.so, Enclave3.so) first with your signing keys before you run the $(App_Name) to launch and access the enclave."
+	@echo "To sign the enclaves use the following commands:"
+	@echo "   $(SGX_ENCLAVE_SIGNER) sign -key <key1> -enclave PHP.so -out <$(Enclave_Name_1)> -config PHP/PHP.config.xml"
+	@echo "   $(SGX_ENCLAVE_SIGNER) sign -key <key2> -enclave Decryptor.so -out <$(Enclave_Name_2)> -config Decryptor/Decryptor.config.xml"
+#	@echo "   $(SGX_ENCLAVE_SIGNER) sign -key <key3> -enclave Enclave3.so -out <$(Enclave_Name_3)> -config Enclave3/Enclave3.config.xml"
+	@echo "You can also sign the enclaves using an external signing tool."
+	@echo "To build the project in simulation mode set SGX_MODE=SIM. To build the project in prerelease mode set SGX_PRERELEASE=1 and SGX_MODE=HW."
+else
+all: .config_$(Build_Mode)_$(SGX_ARCH) $(Trust_Lib_Name) $(UnTrustLib_Name) $(Enclave_Name_2) $(App_Name)
+ifeq ($(Build_Mode), HW_DEBUG)
+	@echo "The project has been built in debug hardware mode."
+else ifeq ($(Build_Mode), SIM_DEBUG)
+	@echo "The project has been built in debug simulation mode."
+else ifeq ($(Build_Mode), HW_PRERELEASE)
+	@echo "The project has been built in pre-release hardware mode."
+else ifeq ($(Build_Mode), SIM_PRERELEASE)
+	@echo "The project has been built in pre-release simulation mode."
+else
+	@echo "The project has been built in release simulation mode."
+endif
+endif
+
+.config_$(Build_Mode)_$(SGX_ARCH):
+	@rm -rf .config_* $(App_Name) *.so *.a App/*.o Decryptor/*.o Decryptor/*_t.* Decryptor/*_u.* LocalAttestationCode/*.o LocalAttestationCode/*_t.* #Enclave3/*.o Enclave3/*_t.* Enclave3/*_u.*
+	@touch .config_$(Build_Mode)_$(SGX_ARCH)
+
+######## Library Objects ########
+
+LocalAttestationCode/LocalAttestationCode_t.c LocalAttestationCode/LocalAttestationCode_t.h : $(SGX_EDGER8R) LocalAttestationCode/LocalAttestationCode.edl
+	@cd LocalAttestationCode && $(SGX_EDGER8R) --trusted ../LocalAttestationCode/LocalAttestationCode.edl --search-path $(SGX_SDK)/include
+	@echo "GEN  =>  $@"
+
+LocalAttestationCode/LocalAttestationCode_t.o: LocalAttestationCode/LocalAttestationCode_t.c
+	@$(CC) $(TrustLib_Compile_Flags) -c $< -o $@
+	@echo "CC   <=  $<"
+
+LocalAttestationCode/%.o: LocalAttestationCode/%.cpp LocalAttestationCode/LocalAttestationCode_t.h
+	@$(CXX) $(TrustLib_Compile_Flags) $(TrustLib_Compile_Cxx_Flags) -c $< -o $@
+	@echo "CC   <= $<"
+
+$(Trust_Lib_Name): LocalAttestationCode/LocalAttestationCode_t.o $(TrustLib_Cpp_Objects)
+	@$(AR) rcs $@ $^
+	@echo "GEN  =>  $@"
+
+#Untrusted_LocalAttestation/%.o: Untrusted_LocalAttestation/%.cpp
+#	@$(CXX) $(UnTrustLib_Compile_Flags) -c $< -o $@
+#	@echo "CC   <=  $<"
+
+#$(UnTrustLib_Name): $(UnTrustLib_Cpp_Objects)
+#	@$(AR) rcs $@ $^
+#	@echo "GEN  =>  $@"
+
+######## App Objects ########
+Decryptor/Decryptor_u.c Decryptor/Decryptor_u.h: $(SGX_EDGER8R) Decryptor/Decryptor.edl
+	@cd Decryptor && $(SGX_EDGER8R) --use-prefix --untrusted ../Decryptor/Decryptor.edl --search-path $(SGX_SDK)/include
+	@echo "GEN  =>  $@"
+
+App/Decryptor_u.o: Decryptor/Decryptor_u.c
+	@$(CC) $(App_Compile_Flags) -c $< -o $@
+	@echo "CC   <=  $<"
+
+App/%.o: App/%.cpp Decryptor/Decryptor_u.h #Enclave3/Enclave3_u.h
+	@$(CXX) $(App_Compile_Flags) -c $< -o $@
+	@echo "CXX  <=  $<"
+
+$(App_Name): App/Decryptor_u.o $(App_Cpp_Objects)# $(UnTrustLib_Name)
+	@$(CXX) $^ -o $@ $(App_Link_Flags)
+	@echo "LINK =>  $@"
+
+
+######## Enclave Objects ########
+Decryptor/Decryptor_t.c: $(SGX_EDGER8R) Decryptor/Decryptor.edl
+	@cd Decryptor && $(SGX_EDGER8R)  --use-prefix --trusted ../Decryptor/Decryptor.edl --search-path $(SGX_SDK)/include
+	@echo "GEN  =>  $@"
+
+Decryptor/Decryptor_t.o: Decryptor/Decryptor_t.c
+	@$(CC) $(Enclave_Compile_Flags) -c $< -o $@
+	@echo "CC   <=  $<"
+
+Decryptor/%.o: Decryptor/%.cpp
+	@$(CXX) -std=c++11 -nostdinc++ $(Enclave_Compile_Flags) -c $< -o $@
+	@echo "CXX  <=  $<"
+
+Decryptor.so: Decryptor/Decryptor_t.o $(Enclave_Cpp_Objects_2) $(Trust_Lib_Name)
+	@$(CXX) --verbose Decryptor/Decryptor_t.o $(Enclave_Cpp_Objects_2) -o $@ $(Decryptor_Link_Flags)
+	@echo "LINK =>  $@"
+
+$(Enclave_Name_2): Decryptor.so
+	@$(SGX_ENCLAVE_SIGNER) sign -key Decryptor/Decryptor_private.pem -enclave Decryptor.so -out $@ -config Decryptor/Decryptor.config.xml
+	@echo "SIGN =>  $@"
+
+######## Clean ########
+.PHONY: clean
+
+clean:
+	@rm -rf .config_* $(App_Name) *.so *.a App/*.o Decryptor/*.o Decryptor/*_t.* Decryptor/*_u.* LocalAttestationCode/*.o LocalAttestationCode/*_t.* 

+ 9 - 0
generate_mrsigner.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+#modulus="f357fd12f0287bd924ae74d602136d1b50565bc764d591d42f1866200bd671034df1e6b253d63e12046ad0b558d69bd422b7f8248723465c9bb771285659b4c9dc9f7070079134dab01f013e772322334cd72f10156243859cd6444ef1609496772b94928970ffb7e2957ae483c72a36dd223ebf9cf1eb95ff5b03f959676baab18c2aefa0c523f711775cbba872793cb35249f5ab69b248f4e6d73807afb920d2b44d616bde4ab42e0f7aa412d3ab719c55ee37c4bd0192cbcac055c80665b655d5776b014ef53d872639dfdb4e62109aa839771936bd0cb5b79e5bfb5f6deb71bbf28b165ba5091a0a4f3703e0c946be379e2f6dc39e74271d439ceb531bc206bbe0b85ff34e22667df2d5b7401e192f41e327b1a7a8f6f2d36cc757fc64e7094996462b133ece8c4c376689f72223f0258365cf987c985d279adf3e2b20fcc0978f171330ab0a596f713033c1ca22230a72bf00997e81c86e6602d9a2d694ae95418d1f5e6a32d6f946252d9366d2e925d915178f6543f6fd23fb82a883ae"
+#echo -n $modulus | xxd -r -p | openssl dgst -sha256
+
+#Extract modulus from private key
+modulus_bigendian=$(openssl rsa -noout -modulus -in $1 | cut -d'=' -f2)
+modulus_littleendian=$(printf %s "$modulus_bigendian" | dd conv=swab 2> /dev/null | rev)
+echo -n $modulus_littleendian | xxd -r -p | openssl dgst -sha256
+