preisacm
/
masterthesis-ecdaa-network-wrapper
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

cleaning directory and cmake procedure

master
Michael Preisach 4 years ago
parent
c849b4544b
commit
d5db38dc9a
11 changed files with 81 additions and 99 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      .gitignore
  2. 25
      CMakeLists.txt
  3. 22
      common.h
  4. 12
      issuer.c
  5. 18
      member-tpm-key.c
  6. 8
      member-tpm-key.h
  7. 44
      member-tpm.c
  8. 5
      member-tpm.h
  9. 28
      member.c
  10. 16
      verifier.c
  11. 1
      verifier.h

1
.gitignore
View File

@ -1,4 +1,5 @@
CMakeFiles/
.idea/
CMakeCache.txt
Makefile
cmake_install.cmake

25
CMakeLists.txt
View File

@ -17,7 +17,7 @@ target_include_directories(ecdaa_member PUBLIC
target_link_libraries(ecdaa_member /usr/lib/x86_64-linux-gnu/libecdaa.so)
target_link_libraries(ecdaa_member /usr/lib/x86_64-linux-gnu/libecdaa-tpm.so)
add_executable(ecdaa_member_tpm member-tpm.c common.h common.c client.h client.c server.h server.c amcl-extensions/ecp_FP256BN.c amcl/big_256_56.c amcl/rom_curve_FP256BN.c amcl/ecp_FP256BN.c amcl/fp_FP256BN.c amcl/rom_field_FP256BN.c amcl/rand.c amcl/hash.c member-tpm-key.c)
add_executable(ecdaa_member_tpm member-tpm.c common.h common.c client.h client.c server.h server.c member-tpm-key.h member-tpm-key.c)
target_include_directories(ecdaa_member_tpm PUBLIC
${ECDAA_AMCL}
)
@ -32,26 +32,3 @@ target_include_directories(ecdaa_verifier PUBLIC
)
target_link_libraries(ecdaa_verifier /usr/lib/x86_64-linux-gnu/libecdaa.so)
add_executable(ecdaa_test daa-test.c daa-test.h common.h common.c client.h client.c server.h server.c)
target_include_directories(ecdaa_test PUBLIC
${ECDAA_AMCL}
)
target_link_libraries(ecdaa_test /usr/lib/x86_64-linux-gnu/libecdaa.so)
add_executable(ecdaa_test_tpm daa-test-tpm.c daa-test-tpm.h common.h common.c client.h client.c server.h server.c)
target_include_directories(ecdaa_test_tpm PUBLIC
${ECDAA_AMCL}
)
target_link_libraries(ecdaa_test_tpm /usr/lib/x86_64-linux-gnu/libecdaa.so)
target_link_libraries(ecdaa_test_tpm /usr/lib/x86_64-linux-gnu/libecdaa-tpm.so)
target_link_libraries(ecdaa_test_tpm /usr/lib/x86_64-linux-gnu/libtss2-tcti-device.so)
target_link_libraries(ecdaa_test_tpm /usr/lib/x86_64-linux-gnu/libtss2-sys.so)
add_executable(create_tpm_key member-tpm-key.c)
target_include_directories(create_tpm_key PUBLIC
${ECDAA_AMCL}
)
target_link_libraries(create_tpm_key /usr/lib/x86_64-linux-gnu/libecdaa.so)
target_link_libraries(create_tpm_key /usr/lib/x86_64-linux-gnu/libecdaa-tpm.so)
target_link_libraries(create_tpm_key /usr/lib/x86_64-linux-gnu/libtss2-tcti-device.so)
target_link_libraries(create_tpm_key /usr/lib/x86_64-linux-gnu/libtss2-sys.so)

22
common.h
View File

@ -22,17 +22,17 @@
#define MAX_BSNSIZE 128
#define NONCE_SIZE 384
const char* issuer_public_key_file = "ipk.bin";
const char* issuer_secret_key_file = "isk.bin";
const char* member_tpm_handle_file = "tpmhndl.bin"; //Handle to access tpm key
const char* member_tpm_key_file = "tpmpk.bin"; //public key to access TPM key (!= mpk)
const char* member_secret_key_file = "msk.bin"; //for TPM less members only
const char* member_public_key_file = "mpk.bin";
const char* member_credential_file = "mcred.bin";
const char* member_nonce_file = "mnonce.bin";
const char* verifier_group_pk_file = "gpk.bin";
const char* message_file = "msg.txt"; //Checksum of message in chksum.txt
const char* checksum_file = "chksum.txt"; //Only this file is signed due to 1024 bytes size limit
#define ISSUER_PUBLIC_KEY_FILE "ipk.bin"
#define ISSUER_SECRET_KEY_FILE "isk.bin"
#define MEMBER_TPM_HANDLE_FILE "tpmhndl.bin" //Handle to access tpm key
#define MEMBER_TPM_KEY_FILE "tpmpk.bin" //public key to access TPM key (!= mpk)
#define MEMBER_SECRET_KEY_FILE "msk.bin" //for TPM less members only
#define MEMBER_PUBLIC_KEY_FILE "mpk.bin"
#define MEMBER_CREDENTIAL_FILE "mcred.bin"
#define MEMBER_NONCE_FILE "mnonce.bin"
#define VERIFIER_GROUP_PK_FILE "gpk.bin"
#define MESSAGE_FILE "msg.txt" //Checksum of message in chksum.txt
#define CHECKSUM_FILE "chksum.txt" //Only this file is signed due to 1024 bytes size limit
typedef int (*conn_handler)(char *buffer);

12
issuer.c
View File

@ -211,8 +211,8 @@ int issuer_reset(char *buffer) {
strncpy(buffer, "ERR\n", 4);
return -1;
}
if(0 != ecdaa_issuer_public_key_FP256BN_serialize_file(issuer_public_key_file, &issuer.ipk) ||
0 != ecdaa_issuer_secret_key_FP256BN_serialize_file(issuer_secret_key_file, &issuer.isk)) {
if(0 != ecdaa_issuer_public_key_FP256BN_serialize_file(ISSUER_PUBLIC_KEY_FILE, &issuer.ipk) ||
0 != ecdaa_issuer_secret_key_FP256BN_serialize_file(ISSUER_SECRET_KEY_FILE, &issuer.isk)) {
printf("issuer_reset: Error saving key-pair to disk.\n");
strncpy(buffer, "ERR\n", 4);
return -1;
@ -227,8 +227,8 @@ int issuer_setup() {
#ifdef DEBUG
printf("setup()\n");
#endif
if (0 == ecdaa_issuer_public_key_FP256BN_deserialize_file(&issuer.ipk, issuer_public_key_file)) {
if (0 == ecdaa_issuer_secret_key_FP256BN_deserialize_file(&issuer.isk, issuer_secret_key_file)) {
if (0 == ecdaa_issuer_public_key_FP256BN_deserialize_file(&issuer.ipk, ISSUER_PUBLIC_KEY_FILE)) {
if (0 == ecdaa_issuer_secret_key_FP256BN_deserialize_file(&issuer.isk, ISSUER_SECRET_KEY_FILE)) {
printf("issuer_setup: Loaded keys from disk.\n");
return 0;
}
@ -238,8 +238,8 @@ int issuer_setup() {
printf("issuer_setup: Error generating issuer key-pair.\n");
return -1;
}
if(0 != ecdaa_issuer_public_key_FP256BN_serialize_file(issuer_public_key_file, &issuer.ipk) ||
0 != ecdaa_issuer_secret_key_FP256BN_serialize_file(issuer_secret_key_file, &issuer.isk)) {
if(0 != ecdaa_issuer_public_key_FP256BN_serialize_file(ISSUER_PUBLIC_KEY_FILE, &issuer.ipk) ||
0 != ecdaa_issuer_secret_key_FP256BN_serialize_file(ISSUER_SECRET_KEY_FILE, &issuer.isk)) {
printf("issuer_setup: Error saving key-pair to disk.\n");
return -1;
}

18
member-tpm-key.c
View File

@ -5,7 +5,7 @@ static TPMA_SESSION empty_session_attributes = {0}; // attributes for passwor
struct command_line_args {
char *pub_key_filename;
char *handle_filename;
}
};
struct test_context {
TSS2_SYS_CONTEXT *sapi_ctx;
@ -27,7 +27,7 @@ void parse_cmd_args(struct command_line_args *args_out, int argc, char *argv[])
args_out->pub_key_filename = argv[1];
args_out->handle_filename = argv[2];
printf("Saving public key to %s and handle to %s\n", pub_key_filename, handle_filename);
printf("Saving public key to %s and handle to %s\n", args_out->pub_key_filename, args_out->handle_filename);
}
static void initialize(struct test_context *ctx);
@ -40,13 +40,13 @@ static int load(struct test_context *ctx);
static int save_public_key_info(const struct test_context* ctx, const char* pub_key_filename, const char* handle_filename);
static int evict_control(struct test_context *ctx);
int main(int argc, char *argv[])
{
struct command_line_args args;
parse_cmd_args(&args, argc, argv);
create_key(pub_key_filename, handle_filename);
}
// int main(int argc, char *argv[])
// {
// struct command_line_args args;
// parse_cmd_args(&args, argc, argv);
//
// create_key(args.pub_key_filename, args.handle_filename);
// }
void initialize(struct test_context *ctx)
{

8
member-tpm-key.h
View File

@ -1,8 +1,12 @@
#ifndef ECDAA_MEMBER_TPM_KEY_H
#define ECDAA_MEMBER_TPM_KEY_H
#include <tss2/tss2_sys.h>
#include <tss2/tss2_tcti.h>
#include <tss2/tss2_tcti_device.h>
#include <ecdaa.h>
#include <ecdaa-tpm.h>
#include "common.h"
#include "member-tpm.h"
static int create_key(const char* pub_key_filename, const char* handle_filename);
int create_key(const char* pub_key_filename, const char* handle_filename);
#endif //ECDAA_MEMBER_TPM_KEY_H

44
member-tpm.c
View File

@ -56,10 +56,10 @@ int main(int argc, char *argv[]) {
switch(argc) {
case 3:
if(0 == strncasecmp("--join", argv[1], 6) || 0 == strncasecmp("-j", argv[1], 2)) {
if (0 != read_public_key_from_files(member.pk_in, &sk_handle, member_tpm_key_file, member_tpm_handle_file)) {
printf("Could not load TPM key with '%s' and '%s', trying to create a new key...\n", member_tpm_key_file, member_tpm_handle_file);
if (0 != create_key(member_tpm_key_file, member_tpm_handle_file) || 0 != read_public_key_from_files(member.pk_in, &sk_handle, member_tpm_key_file, member_tpm_handle_file)) {
printf("Error: Creating or Loading TPM key with '%s' and '%s' failed.\n", member_tpm_key_file, member_tpm_handle_file);
if (0 != read_public_key_from_files(member.pk_in, &sk_handle, MEMBER_TPM_KEY_FILE, MEMBER_TPM_HANDLE_FILE)) {
printf("Could not load TPM key with '%s' and '%s', trying to create a new key...\n", MEMBER_TPM_KEY_FILE, MEMBER_TPM_HANDLE_FILE);
if (0 != create_key(MEMBER_TPM_KEY_FILE, MEMBER_TPM_HANDLE_FILE) || 0 != read_public_key_from_files(member.pk_in, &sk_handle, MEMBER_TPM_KEY_FILE, MEMBER_TPM_HANDLE_FILE)) {
printf("Error: Creating or Loading TPM key with '%s' and '%s' failed.\n", MEMBER_TPM_KEY_FILE, MEMBER_TPM_HANDLE_FILE);
return 1;
}
}
@ -77,8 +77,8 @@ int main(int argc, char *argv[]) {
}
printf("Join process was successful.\n");
} else if (0 == strncasecmp("--send", argv[1], 6) || 0 == strncasecmp("-s", argv[1], 2)) {
if (0 != read_public_key_from_files(member.pk_in, &sk_handle, member_tpm_key_file, member_tpm_handle_file)) {
printf("Error: reading in public key files '%s' and '%s' failed\n", member_tpm_key_file, member_tpm_handle_file);
if (0 != read_public_key_from_files(member.pk_in, &sk_handle, MEMBER_TPM_KEY_FILE, MEMBER_TPM_HANDLE_FILE)) {
printf("Error: reading in public key files '%s' and '%s' failed\n", MEMBER_TPM_KEY_FILE, MEMBER_TPM_HANDLE_FILE);
return 1;
}
if (0 != init_tpm()) {
@ -86,22 +86,22 @@ int main(int argc, char *argv[]) {
return 1;
}
printf("Initialized TPM with pubkey and handle.\n");
msg_len = ecdaa_read_from_file(msg, MAX_MSGSIZE, message_file);
msg_len = ecdaa_read_from_file(msg, MAX_MSGSIZE, MESSAGE_FILE);
if (msg_len < 0) {
printf("Could not open message file %s.\n", message_file);
printf("Could not open message file %s.\n", MESSAGE_FILE);
return 1;
}
chksum_len = ecdaa_read_from_file(chksum, MAX_CHKSUMSIZE, checksum_file);
chksum_len = ecdaa_read_from_file(chksum, MAX_CHKSUMSIZE, CHECKSUM_FILE);
if (chksum_len < 0) {
printf("Could not open checksum file %s.\n", checksum_file);
printf("Could not open checksum file %s.\n", CHECKSUM_FILE);
return 1;
}
printf("Loaded message and checksum.\n");
if (0 > ecdaa_read_from_file(member.nonce, NONCE_SIZE, member_nonce_file) ||
0 != ecdaa_member_public_key_FP256BN_deserialize_file(&member.mpk, member_public_key_file, member.nonce, NONCE_SIZE) ||
0 != ecdaa_credential_FP256BN_deserialize_file(&member.cred, member_credential_file)) {
if (0 > ecdaa_read_from_file(member.nonce, NONCE_SIZE, MEMBER_NONCE_FILE) ||
0 != ecdaa_member_public_key_FP256BN_deserialize_file(&member.mpk, MEMBER_PUBLIC_KEY_FILE, member.nonce, NONCE_SIZE) ||
0 != ecdaa_credential_FP256BN_deserialize_file(&member.cred, MEMBER_CREDENTIAL_FILE)) {
printf("Could not import key files. Importing from either %s, %s or %s was not successful.\n",
member_nonce_file, member_public_key_file, member_credential_file);
MEMBER_NONCE_FILE, MEMBER_PUBLIC_KEY_FILE, MEMBER_CREDENTIAL_FILE);
return 1;
}
member.state = JOINED;
@ -118,7 +118,7 @@ int main(int argc, char *argv[]) {
printf("Usage: \n Join an issuer's group: %s --join <issuer's IPv4>\n", argv[0]);
printf("Send a signed message to the verifier: %s --send <verifier's IPv4>\n", argv[0]);
printf("Before sending a DAA-signed message, the member must join a DAA group\n");
printf("%s must not exceed %d Bytes, %s must be smaller than %d Bytes\n", message_file, MAX_MSGSIZE, checksum_file, MAX_CHKSUMSIZE);
printf("%s must not exceed %d Bytes, %s must be smaller than %d Bytes\n", MESSAGE_FILE, MAX_MSGSIZE, CHECKSUM_FILE, MAX_CHKSUMSIZE);
break;
}
return 0;
@ -137,8 +137,8 @@ int init_tpm()
TSS2_TCTI_CONTEXT *tcti_ctx = (TSS2_TCTI_CONTEXT*)member.tcti_buffer;
size_t size;
init_ret = Tss2_Tcti_Device_Init(NULL, &size, device_conf);
if (TSS2_RC_SUCCESS != init_ret) {
ret = Tss2_Tcti_Device_Init(NULL, &size, device_conf);
if (TSS2_RC_SUCCESS != ret) {
printf("Error: Failed to get allocation size for tcti context.\n");
return -1;
}
@ -146,8 +146,8 @@ int init_tpm()
printf("Error: device TCTI context size larger than pre-allocated buffer.\n");
return -1;
}
init_ret = Tss2_Tcti_Device_Init(tcti_ctx, &size, device_conf);
if (TSS2_RC_SUCCESS != init_ret) {
ret = Tss2_Tcti_Device_Init(tcti_ctx, &size, device_conf);
if (TSS2_RC_SUCCESS != ret) {
printf("Error: Unable to initialize device TCTI context.\n");
return -1;
}
@ -302,7 +302,7 @@ int member_joinappend(char *buffer) {
uint8_t binbuf[MAX_BUFSIZE];
int ret = 0;
int bytes = ecdaa_decode(current, member.nonce, NONCE_SIZE);
ecdaa_write_buffer_to_file(member_nonce_file, member.nonce, NONCE_SIZE);
ecdaa_write_buffer_to_file(MEMBER_NONCE_FILE, member.nonce, NONCE_SIZE);
bzero(buffer, MAX_BUFSIZE);
if (0 != (ret = ecdaa_member_key_pair_TPM_FP256BN_generate(&member.mpk, member.pk_in, member.nonce, NONCE_SIZE, &member.ctx))) {
fprintf(stderr, "Error generating member key-pair: ret = %d\n", ret);
@ -341,8 +341,8 @@ int member_joinfinish(char *buffer) {
ret = -1;
}
printf("member_joinfinish: writing public key and credential to disk.\n");
if(0 != ecdaa_member_public_key_FP256BN_serialize_file(member_public_key_file, &member.mpk) ||
0 != ecdaa_credential_FP256BN_serialize_file(member_credential_file, &member.cred)) {
if(0 != ecdaa_member_public_key_FP256BN_serialize_file(MEMBER_PUBLIC_KEY_FILE, &member.mpk) ||
0 != ecdaa_credential_FP256BN_serialize_file(MEMBER_CREDENTIAL_FILE, &member.cred)) {
printf("issuer_setup: Error saving key-pair or credential to disk.\n");
ret = -1;
} else {

5
member-tpm.h
View File

@ -5,13 +5,14 @@
#include <tss2/tss2_tcti_device.h>
#include <ecdaa.h>
#include <ecdaa-tpm.h>
#include "amcl/big_256_56.h"
#include "amcl-extensions/ecp_FP256BN.h"
// #include "amcl/big_256_56.h"
// #include "amcl-extensions/ecp_FP256BN.h"
#include "server.h"
#include "client.h"
#include "common.h"
#include "member-tpm-key.h"
#define ECP_FP256BN_LENGTH 65
int process_member(char *buffer);
#endif //ECDAA_MEMBER_TPM_H

28
member.c
View File

@ -56,23 +56,23 @@ int main(int argc, char **argv) {
printf("Join process was successful.\n");
}
} else if (0 == strncasecmp("--send", argv[1], 6) || 0 == strncasecmp("-s", argv[1], 2)) {
msg_len = ecdaa_read_from_file(msg, MAX_MSGSIZE, message_file);
msg_len = ecdaa_read_from_file(msg, MAX_MSGSIZE, MESSAGE_FILE);
if (msg_len < 0) {
printf("Error: Could not open message file %s.\n", message_file);
printf("Error: Could not open message file %s.\n", MESSAGE_FILE);
return 1;
}
chksum_len = ecdaa_read_from_file(chksum, MAX_CHKSUMSIZE, checksum_file);
chksum_len = ecdaa_read_from_file(chksum, MAX_CHKSUMSIZE, CHECKSUM_FILE);
if (chksum_len < 0) {
printf("Error: Could not open checksum file %s.\n", checksum_file);
printf("Error: Could not open checksum file %s.\n", CHECKSUM_FILE);
return 1;
}
printf("Loaded message and checksum.\n");
if (0 > ecdaa_read_from_file(member.nonce, NONCE_SIZE, member_nonce_file) ||
0 != ecdaa_member_secret_key_FP256BN_deserialize_file(&member.msk, member_secret_key_file) ||
0 != ecdaa_member_public_key_FP256BN_deserialize_file(&member.mpk, member_public_key_file, member.nonce, NONCE_SIZE) ||
0 != ecdaa_credential_FP256BN_deserialize_file(&member.cred, member_credential_file)) {
if (0 > ecdaa_read_from_file(member.nonce, NONCE_SIZE, MEMBER_NONCE_FILE) ||
0 != ecdaa_member_secret_key_FP256BN_deserialize_file(&member.msk, MEMBER_SECRET_KEY_FILE) ||
0 != ecdaa_member_public_key_FP256BN_deserialize_file(&member.mpk, MEMBER_PUBLIC_KEY_FILE, member.nonce, NONCE_SIZE) ||
0 != ecdaa_credential_FP256BN_deserialize_file(&member.cred, MEMBER_CREDENTIAL_FILE)) {
printf("Could not import key files. Importing from either %s, %s, %s or %s was not successful.\n",
member_nonce_file, member_secret_key_file, member_public_key_file, member_credential_file);
MEMBER_NONCE_FILE, MEMBER_SECRET_KEY_FILE, MEMBER_PUBLIC_KEY_FILE, MEMBER_CREDENTIAL_FILE);
return 1;
}
member.state = JOINED;
@ -89,7 +89,7 @@ int main(int argc, char **argv) {
printf("Usage: \n Join an issuer's group: %s --join <issuer's IPv4>\n", argv[0]);
printf("Send a signed message to the verifier: %s --send <verifier's IPv4>\n", argv[0]);
printf("Before sending a DAA-signed message, the member must join a DAA group\n");
printf("%s must not exceed %d Bytes, %s must be smaller than %d Bytes\n", message_file, MAX_MSGSIZE, checksum_file, MAX_CHKSUMSIZE);
printf("%s must not exceed %d Bytes, %s must be smaller than %d Bytes\n", MESSAGE_FILE, MAX_MSGSIZE, CHECKSUM_FILE, MAX_CHKSUMSIZE);
break;
}
return 0;
@ -222,7 +222,7 @@ int member_joinappend(char *buffer) {
char *current = &buffer[10];
uint8_t binbuf[MAX_BUFSIZE];
int bytes = ecdaa_decode(current, member.nonce, NONCE_SIZE);
ecdaa_write_buffer_to_file(member_nonce_file, member.nonce, NONCE_SIZE);
ecdaa_write_buffer_to_file(MEMBER_NONCE_FILE, member.nonce, NONCE_SIZE);
// if (0 != ecdaa_member_key_pair_TPM_FP256BN_generate(&member.mpk, member.nonce, NONCE_SIZE)) {
if (0 != ecdaa_member_key_pair_FP256BN_generate(&member.mpk, &member.msk, member.nonce, NONCE_SIZE, ecdaa_rand)) {
fprintf(stderr, "Error generating member key-pair.\n");
@ -261,9 +261,9 @@ int member_joinfinish(char *buffer) {
ret = -1;
}
printf("member_joinfinish: writing key-pair and credential to disk.\n");
if(0 != ecdaa_member_public_key_FP256BN_serialize_file(member_public_key_file, &member.mpk) ||
0 != ecdaa_member_secret_key_FP256BN_serialize_file(member_secret_key_file, &member.msk) ||
0 != ecdaa_credential_FP256BN_serialize_file(member_credential_file, &member.cred)) {
if(0 != ecdaa_member_public_key_FP256BN_serialize_file(MEMBER_PUBLIC_KEY_FILE, &member.mpk) ||
0 != ecdaa_member_secret_key_FP256BN_serialize_file(MEMBER_SECRET_KEY_FILE, &member.msk) ||
0 != ecdaa_credential_FP256BN_serialize_file(MEMBER_CREDENTIAL_FILE, &member.cred)) {
printf("issuer_joinfinish: Error saving key-pair or credential to disk.\n");
ret = -1;
} else {

16
verifier.c
View File

@ -35,8 +35,8 @@ int main(int argc, char **argv) {
switch(argc) {
case 1:
if (0 != ecdaa_issuer_public_key_FP256BN_deserialize_file(&verifier.ipk, verifier_ipk_file)) {
printf("Could not import key file. Importing from %s was not successful.\n",verifier_ipk_file);
if (0 != ecdaa_issuer_public_key_FP256BN_deserialize_file(&verifier.ipk, VERIFIER_GROUP_PK_FILE)) {
printf("Could not import key file. Importing from %s was not successful.\n",VERIFIER_GROUP_PK_FILE);
return 1;
}
printf("verifier_setup: loaded keys from disk.\n");
@ -50,11 +50,11 @@ int main(int argc, char **argv) {
if (0 >= ret || GOTISSUER != verifier.state) {
printf("Error: connection to issuer failed.\n");
}
if(0 != ecdaa_issuer_public_key_FP256BN_serialize_file(verifier_ipk_file, &verifier.ipk)) {
if(0 != ecdaa_issuer_public_key_FP256BN_serialize_file(VERIFIER_GROUP_PK_FILE, &verifier.ipk)) {
printf("Error saving key-pair to disk.\n");
return -1;
}
printf("verifier_setup: wrote new issuer's public key to %s.\n", verifier_ipk_file);
printf("verifier_setup: wrote new issuer's public key to %s.\n", VERIFIER_GROUP_PK_FILE);
} else {
printf("Error: Arguments invalid.\n");
}
@ -210,9 +210,9 @@ int verifier_verifymsg(char *buffer) {
return -1;
}
printf("writing message to %s\n", message_file);
ecdaa_write_buffer_to_file(message_file, msg, msg_len);
printf("writing checksum to %s\n", checksum_file);
ecdaa_write_buffer_to_file(checksum_file, chksum, chksum_len);
printf("writing message to %s\n", MESSAGE_FILE);
ecdaa_write_buffer_to_file(MESSAGE_FILE, msg, msg_len);
printf("writing checksum to %s\n", CHECKSUM_FILE);
ecdaa_write_buffer_to_file(CHECKSUM_FILE, chksum, chksum_len);
return 0;
}

1
verifier.h
View File

@ -2,7 +2,6 @@
#ifndef ECDAA_VERIFIER_H
#define ECDAA_VERIFIER_H
#include <ecdaa.h>
// #include <ecdaa-tpm.h>
#include "server.h"
#include "client.h"
#include "common.h"

Write Preview
Loading…
Cancel
Save