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

issuer and member can exchange keys, verifier ist not yet tested.

master
root 6 years ago
parent
793e8d949b
commit
3fbde2e1cc
5 changed files with 258 additions and 103 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      client.c
  2. 12
      common.c
  3. 88
      issuer.c
  4. 135
      member.c
  5. 63
      verifier.c

3
client.c
View File

@ -25,8 +25,6 @@ int client_open(char *servip, int16_t port) {
} }
int client_connect(conn_handler handler, char *servip, int16_t port) { int client_connect(conn_handler handler, char *servip, int16_t port) {
struct sockaddr_in servaddr;
unsigned int servaddr_len = 0;
int connfd = 0; int connfd = 0;
char buffer[MAX_BUFSIZE]; char buffer[MAX_BUFSIZE];
int ret = 0; int ret = 0;
@ -60,7 +58,6 @@ int client_connect(conn_handler handler, char *servip, int16_t port) {
if (0 != close(connfd)) { if (0 != close(connfd)) {
printf("client_connect: failed to close server connection properly\n"); printf("client_connect: failed to close server connection properly\n");
ret = -1;
} }
return ret; return ret;

12
common.c
View File

@ -1,14 +1,14 @@
#include "common.h" #include "common.h"
void ecdaa_rand(void *buffer, size_t buflen) { void ecdaa_rand(void *buffer, size_t buflen) {
getrandom(buffer, buflen, GRND_RANDOM); getrandom(buffer, buflen, 0);
} }
char bin2hex(uint8_t byte) { char bin2hex(uint8_t byte) {
char word = byte & 0x0f; uint8_t word = byte & 0x0f;
char hex = 0; char hex = 0;
if (byte >= 0 && byte <= 9) hex = word + '0'; if (word >= 0 && word <= 9) hex = word + '0';
else if (byte >= 10 && byte <= 15) hex = word - 10 + 'A'; else if (word >= 10 && word <= 15) hex = word - 10 + 'A';
return hex; return hex;
} }
@ -30,8 +30,8 @@ void ecdaa_hextobin(const char *in_hex, uint8_t *out_bin, size_t outlen) {
void ecdaa_bintohex(const uint8_t *in_bin, size_t inlen, char *out_hex) { void ecdaa_bintohex(const uint8_t *in_bin, size_t inlen, char *out_hex) {
for (size_t i = 0, j = 0; i < inlen; i++, j+=2) { for (size_t i = 0, j = 0; i < inlen; i++, j+=2) {
out_hex[j] = bin2hex(in_bin[i] % 0x0f); out_hex[j] = bin2hex(in_bin[i]);
out_hex[j+1] = bin2hex((in_bin[i] / 16) % 0x0f); out_hex[j+1] = bin2hex(in_bin[i] >> 4);
} }
} }

88
issuer.c
View File

@ -25,32 +25,69 @@ int issuer_joinproceed(char *buffer);
int issuer_publish(char *buffer); int issuer_publish(char *buffer);
int main() { int main() {
int err = 0; if (2 != server_start(&process_issuer, ISSUERPORT)) {
printf("server failed\n");
//if (2 != server_start(&process_issuer, ISSUERPORT)) { }
// printf("server failed\n"); /*
//} uint8_t buffer[1024], result[1024];
uint8_t buffer[1024];
uint8_t *current = buffer; uint8_t *current = buffer;
char send[1024]; char send[1024];
bzero(buffer, 1024); bzero(buffer, 1024);
bzero(result, 1024);
bzero(send,1024); bzero(send,1024);
buffer[0] = 0x01;
buffer[1] = 0x02;
buffer[2] = 0x04;
buffer[3] = 0x08;
buffer[4] = 0x10;
buffer[5] = 0x20;
buffer[6] = 0x40;
buffer[7] = 0x80;
buffer[8] = 0x11;
buffer[9] = 0x22;
buffer[10] = 0x44;
buffer[11] = 0x88;
buffer[12] = 0x11;
buffer[13] = 0x21;
buffer[14] = 0x41;
buffer[15] = 0x81;
ecdaa_bintohex(buffer, 16, send);
for(int i = 0; i < 32; i++) {
printf("%c", send[i]);
}
ecdaa_hextobin(send, result, 16);
for(int i = 0; i < 1024; i++) {
if(buffer[i] != result[i]) {
printf("buffer[%i] = %X, result[%i] = %X\n", i, buffer[i], i, result[i]);
}
}
struct ecdaa_issuer_public_key_FP256BN key; struct ecdaa_issuer_public_key_FP256BN key;
ecdaa_issuer_key_pair_FP256BN_generate(&issuer.ipk, &issuer.isk, ecdaa_rand); ecdaa_issuer_key_pair_FP256BN_generate(&issuer.ipk, &issuer.isk, ecdaa_rand);
ecdaa_issuer_public_key_FP256BN_serialize(current, &issuer.ipk); ecdaa_issuer_public_key_FP256BN_serialize(buffer, &issuer.ipk);
ecdaa_bintohex((char*)current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH, send); int ret = ecdaa_issuer_public_key_FP256BN_deserialize(&key, buffer);
printf("ret = %i\n",ret);
ecdaa_bintohex(current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH, send);
printf("%s\n", send); printf("%s\n", send);
bzero(current, 1024);
ecdaa_hextobin(send, (char*)current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH); ecdaa_hextobin(send, result, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
int ret = ecdaa_issuer_public_key_FP256BN_deserialize(&key, current); ret = ecdaa_issuer_public_key_FP256BN_deserialize(&key, result);
printf("%i\n",ret); printf("ret = %i\n",ret);
for(int i = 0; i < 1024; i++) {
if(buffer[i] != result[i]) {
printf("buffer[%i] = %X, result[%i] = %X\n", i, buffer[i], i, result[i]);
}
}
*/
return 0; return 0;
} }
int process_issuer(char *buffer) { int process_issuer(char *buffer) {
ssize_t len = 0;
int ret = 0; int ret = 0;
printf("> ISSUER: %s\n", buffer); printf("> ISSUER: %s\n", buffer);
@ -145,12 +182,12 @@ int process_issuer(char *buffer) {
// "JOIN" > "JOINSTART <issuer.nonce>" // "JOIN" > "JOINSTART <issuer.nonce>"
int issuer_joinstart(char *buffer) { int issuer_joinstart(char *buffer) {
getrandom(issuer.nonce, NONCE_SIZE, GRND_RANDOM); ecdaa_rand(issuer.nonce, NONCE_SIZE);
char* current; char* current;
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "JOINSTART ", 10); strncpy(buffer, "JOINSTART ", 10);
current = &buffer[10]; current = &buffer[10];
ecdaa_bintohex(issuer.nonce, NONCE_SIZE, buffer); ecdaa_bintohex(issuer.nonce, NONCE_SIZE, current);
buffer[2 * NONCE_SIZE + 10] = '\n'; buffer[2 * NONCE_SIZE + 10] = '\n';
return 0; return 0;
} }
@ -160,17 +197,23 @@ int issuer_joinproceed(char *buffer) {
char *current = &buffer[7]; char *current = &buffer[7];
uint8_t binbuf[MAX_BUFSIZE]; uint8_t binbuf[MAX_BUFSIZE];
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
int ret = 0;
ecdaa_hextobin(current, binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH); ecdaa_hextobin(current, binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
int ret = ecdaa_member_public_key_FP256BN_deserialize(&issuer.mpk, binbuf, issuer.nonce, NONCE_SIZE); bzero(buffer, MAX_BUFSIZE);
ret = ecdaa_member_public_key_FP256BN_deserialize(&issuer.mpk, binbuf, issuer.nonce, NONCE_SIZE);
if(-1 == ret) { if(-1 == ret) {
printf("issuer_joinproceed: member public key is malformed!"); strncpy(buffer, "ERR\n", 4);
printf("issuer_joinproceed: member public key is malformed!\n");
return -1; return -1;
} else if (-2 == ret) { } else if (-2 == ret) {
printf("issuer_joinproceed: signature of member public key is invalid"); strncpy(buffer, "ERR\n", 4);
printf("issuer_joinproceed: signature of member public key is invalid\n");
return -1;
} }
if (0 != ecdaa_credential_FP256BN_generate(&issuer.cred, &issuer.cred_sig, &issuer.isk, &issuer.mpk, ecdaa_rand)) { if (0 != ecdaa_credential_FP256BN_generate(&issuer.cred, &issuer.cred_sig, &issuer.isk, &issuer.mpk, ecdaa_rand)) {
strncpy(buffer, "ERR\n", 4);
printf("issuer_joinproceed: error generating credential\n"); printf("issuer_joinproceed: error generating credential\n");
return -1; return -1;
} }
@ -178,16 +221,16 @@ int issuer_joinproceed(char *buffer) {
strncpy(buffer, "JOINPROCEED ", 12); strncpy(buffer, "JOINPROCEED ", 12);
current = &buffer[12]; current = &buffer[12];
ecdaa_credential_FP256BN_serialize(binbuf, &issuer.cred);
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_credential_FP256BN_serialize(binbuf, &issuer.cred);
ecdaa_bintohex(binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH, current); ecdaa_bintohex(binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH, current);
current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH]; current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1];
ecdaa_credential_FP256BN_signature_serialize(binbuf, &issuer.cred_sig);
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_credential_FP256BN_signature_serialize(binbuf, &issuer.cred_sig);
ecdaa_bintohex(binbuf, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH, current); ecdaa_bintohex(binbuf, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH, current);
buffer[2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 2 * ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH + 12] = '\n'; buffer[2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1 + 2 * ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH + 12] = '\n';
return 0; return 0;
} }
@ -205,7 +248,6 @@ int issuer_setup(char *buffer) {
// "PUBLISH" > "PUBLISH <issuer.ipk>" // "PUBLISH" > "PUBLISH <issuer.ipk>"
int issuer_publish(char *buffer) { int issuer_publish(char *buffer) {
printf("publish()\n");
char *current; char *current;
uint8_t binbuf[MAX_BUFSIZE]; uint8_t binbuf[MAX_BUFSIZE];
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);

135
member.c
View File

@ -2,6 +2,8 @@
typedef enum memberstate { typedef enum memberstate {
ON, ON,
ISSUERPUB,
RCVPUBLIC,
JOIN, JOIN,
APPEND, APPEND,
JOINPROCEED, JOINPROCEED,
@ -17,18 +19,24 @@ typedef struct member {
uint8_t nonce[NONCE_SIZE]; uint8_t nonce[NONCE_SIZE];
struct ecdaa_credential_FP256BN cred; struct ecdaa_credential_FP256BN cred;
struct ecdaa_credential_FP256BN_signature cred_sig; struct ecdaa_credential_FP256BN_signature cred_sig;
struct ecdaa_issuer_public_key_FP256BN ipk;
} member_t; } member_t;
member_t member; member_t member;
int member_join(char* buffer); int member_join(char *buffer);
int member_attest(char* buffer);
int member_publish(char* buffer); int member_attest(char *buffer);
int member_joinappend(char* buffer);
int member_joinfinish(char* buffer); int member_publish(char *buffer);
int member_getpublic(char *buffer);
int member_joinappend(char *buffer);
int member_joinfinish(char *buffer);
int main() { int main() {
int err = 0;
if (2 != server_start(&process_member, MEMBERPORT)) { if (2 != server_start(&process_member, MEMBERPORT)) {
printf("server failed\n"); printf("server failed\n");
@ -41,18 +49,26 @@ int process_member(char *buffer) {
printf("> MEMBER: %s\n", buffer); printf("> MEMBER: %s\n", buffer);
if (0 == strncasecmp("ATTEST", buffer, 6)) { if (member.state == JOINED && 0 == strncasecmp("ATTEST", buffer, 6)) {
printf("attest()\n");
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ATTEST ", 7); strncpy(buffer, "ATTEST ", 7);
member_attest(buffer); member_attest(buffer);
} else if (member.state == ON && 0 == strncasecmp("GETPUBLIC", buffer, 9)) {
bzero(buffer, MAX_BUFSIZE);
ret = client_connect(&member_getpublic, ISSUERIP, ISSUERPORT);
if (0 >= ret || RCVPUBLIC != member.state) {
printf("process_member: issuer connection failed\n");
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
} else {
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "OK\n", 3);
}
ret = 0;
} else if (0 == strncasecmp("PUBLISH", buffer, 7)) { } else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
printf("publish()\n");
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "PUBLISH ", 8);
member_publish(buffer); member_publish(buffer);
} else if (member.state != JOINED && 0 == strncasecmp("JOIN", buffer, 4)) { } else if (member.state == RCVPUBLIC && 0 == strncasecmp("JOIN", buffer, 4)) {
printf("join()\n");
member.state = JOIN; member.state = JOIN;
ret = client_connect(&member_join, ISSUERIP, ISSUERPORT); ret = client_connect(&member_join, ISSUERIP, ISSUERPORT);
if (0 >= ret || JOINED != member.state) { if (0 >= ret || JOINED != member.state) {
@ -65,7 +81,6 @@ int process_member(char *buffer) {
} }
ret = 0; ret = 0;
} else if (0 == strncasecmp("EXIT", buffer, 4)) { } else if (0 == strncasecmp("EXIT", buffer, 4)) {
printf("exit()\n");
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "OK\n", 3); strncpy(buffer, "OK\n", 3);
ret = 1; ret = 1;
@ -74,7 +89,6 @@ int process_member(char *buffer) {
strncpy(buffer, "OK\n", 3); strncpy(buffer, "OK\n", 3);
ret = 2; ret = 2;
} else { } else {
printf("error()\n");
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4); strncpy(buffer, "ERR\n", 4);
ret = 0; ret = 0;
@ -87,7 +101,6 @@ int process_member(char *buffer) {
int member_join(char *buffer) { int member_join(char *buffer) {
int ret = 0; int ret = 0;
printf("ISSUER > MEMBER: %s", buffer);
switch (member.state) { switch (member.state) {
case JOIN: case JOIN:
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
@ -96,46 +109,99 @@ int member_join(char *buffer) {
break; break;
case APPEND: case APPEND:
if (0 == strncasecmp("JOINSTART", buffer, 9)) { if (0 == strncasecmp("JOINSTART", buffer, 9)) {
printf("ISSUER > MEMBER: %s", buffer);
member_joinappend(buffer); member_joinappend(buffer);
member.state = JOINPROCEED; member.state = JOINPROCEED;
} }
break; break;
case JOINPROCEED: case JOINPROCEED:
if (0 == strncasecmp("JOINPROCEED", buffer, 11)) { if (0 == strncasecmp("JOINPROCEED", buffer, 11)) {
printf("ISSUER > MEMBER: %s", buffer);
member_joinfinish(buffer); member_joinfinish(buffer);
member.state = JOINED; member.state = JOINED;
ret = 1; ret = 1;
} }
break; break;
default: default:
ret -1; ret - 1;
} }
if(0 == ret) { if (0 == ret) {
printf("ISSUER < MEMBER: %s", buffer); printf("ISSUER < MEMBER: %s", buffer);
} }
return ret; return ret;
} }
int member_attest(char* buffer) { int member_getpublic(char *buffer) {
int ret = 0;
switch (member.state) {
case ON:
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "PUBLISH\n", 8);
member.state = ISSUERPUB;
break;
case ISSUERPUB:
if (0 == strncasecmp("PUBLISH", buffer, 7)) {
printf("ISSUER > MEMBER: %s", buffer);
uint8_t binbuf[MAX_BUFSIZE];
char *current = &buffer[8];
ecdaa_hextobin(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
ret = ecdaa_issuer_public_key_FP256BN_deserialize(&member.ipk, binbuf);
if (-1 == ret) {
printf("member_getpublic: issuer public key is malformed!\n");
ret = -1;
} else if (-2 == ret) {
printf("member_getpublic: signature of issuer public key is invalid\n");
ret = -1;
} else {
member.state = RCVPUBLIC;
ret = 1;
}
}
break;
default:
ret = -1;
break;
}
if (0 == ret) {
printf("ISSUER < MEMBER: %s", buffer);
}
return ret;
}
//"ATTEST" > "ATTEST <attestval>"
int member_attest(char *buffer) {
strncat(buffer, "<attestval>\n", 13); strncat(buffer, "<attestval>\n", 13);
return 0; return 0;
} }
//"PUBLISH" > "PUBLISH <member.mpk>" //"PUBLISH" > "PUBLISH <member.mpk>"
int member_publish(char* buffer) { int member_publish(char *buffer) {
strncat(buffer, "<publicval>\n", 12); char *current;
uint8_t binbuf[MAX_BUFSIZE];
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "PUBLISH ", 8);
current = &buffer[8];
bzero(binbuf, MAX_BUFSIZE);
ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk);
ecdaa_bintohex(binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH, current);
buffer[2 * ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH + 8] = '\n';
return 0; return 0;
} }
//"JOINSTART <issuer.nonce>" > "APPEND <member.mpk>" //"JOINSTART <issuer.nonce>" > "APPEND <member.mpk>"
int member_joinappend(char* buffer) { int member_joinappend(char *buffer) {
char *current = &buffer[10]; char *current = &buffer[10];
uint8_t binbuf[MAX_BUFSIZE]; uint8_t binbuf[MAX_BUFSIZE];
ecdaa_hextobin(current, member.nonce, NONCE_SIZE); ecdaa_hextobin(current, member.nonce, NONCE_SIZE);
if (0 != ecdaa_member_key_pair_FP256BN_generate(&member.mpk, &member.msk, member.nonce, NONCE_SIZE, ecdaa_rand)) { 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"); fprintf(stderr, "Error generating member key-pair\n");
return 1; return -1;
} }
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "APPEND ", 7); strncpy(buffer, "APPEND ", 7);
@ -148,12 +214,25 @@ int member_joinappend(char* buffer) {
} }
//"JOINPROCEED <member.cred><member.cred_sig>" > "" //"JOINPROCEED <member.cred><member.cred_sig>" > ""
int member_joinfinish(char* buffer) { int member_joinfinish(char *buffer) {
char *current = &buffer[12]; char *current = &buffer[12];
uint8_t *bincur;
uint8_t binbuf[MAX_BUFSIZE]; uint8_t binbuf[MAX_BUFSIZE];
ecdaa_credential_FP256BN_deserialize(binbuf, &member.cred); int ret = 0;
current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH]; bzero(binbuf, MAX_BUFSIZE);
//ecdaa_credential_FP256BN_signature_deserialize(current, &member.cred_sig); ecdaa_hextobin(current, binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH);
bzero(buffer, MAX_BUFSIZE);
return 0; current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1];
bincur = &binbuf[ECDAA_CREDENTIAL_FP256BN_LENGTH];
ecdaa_hextobin(current, bincur, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);
ret = ecdaa_credential_FP256BN_deserialize_with_signature(&member.cred, &member.mpk, &member.ipk.gpk, binbuf, bincur);
if(-1 == ret) {
printf("member_joinfinish: credential is malformed!\n");
ret = -1;
} else if(-2 == ret) {
printf("member_joinfinish: siganture of credential is invalid");
ret = -1;
}
return ret;
} }

63
verifier.c
View File

@ -9,8 +9,9 @@ typedef enum verifierstate {
} verifierstate_e; } verifierstate_e;
typedef struct verifier { typedef struct verifier {
struct ecdaa_issuer_public_key_FP256BN mpk; struct ecdaa_issuer_public_key_FP256BN ipk;
struct ecdaa_member_public_key_FP256BN ipk; struct ecdaa_member_public_key_FP256BN mpk;
struct ecdaa_revocations_FP256BN revocations;
verifierstate_e state; verifierstate_e state;
} verifier_t; } verifier_t;
@ -19,9 +20,12 @@ verifier_t verifier;
int verifier_getissuer(char *buffer); int verifier_getissuer(char *buffer);
int verifier_getmember(char *buffer); int verifier_getmember(char *buffer);
int verifier_attestmember(char *buffer);
int verifier_checklink(char *buffer);
int main() { int main() {
int err = 0; verifier.revocations.sk_list = NULL;
verifier.revocations.bsn_list = NULL;
if (2 != server_start(&process_verifier, VERIFIERPORT)) { if (2 != server_start(&process_verifier, VERIFIERPORT)) {
printf("server failed\n"); printf("server failed\n");
@ -37,7 +41,6 @@ int process_verifier(char *buffer) {
if (0 == strncasecmp("VERIFY", buffer, 6)) { if (0 == strncasecmp("VERIFY", buffer, 6)) {
switch (verifier.state) { switch (verifier.state) {
case GOTMEMBER: case GOTMEMBER:
printf("verify()\n");
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "OK\n", 3); strncpy(buffer, "OK\n", 3);
break; break;
@ -46,9 +49,8 @@ int process_verifier(char *buffer) {
strncpy(buffer, "ERR\n", 4); strncpy(buffer, "ERR\n", 4);
} }
} else if (0 == strncasecmp("LINk", buffer, 4)) { } else if (0 == strncasecmp("LINk", buffer, 4)) {
printf("getpublished()\n");
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "OK\n", 3); verifier_checklink(buffer);
} else if (0 == strncasecmp("GETPUBLISHED", buffer, 12)) { } else if (0 == strncasecmp("GETPUBLISHED", buffer, 12)) {
printf("link()\n"); printf("link()\n");
verifier.state = ON; verifier.state = ON;
@ -92,7 +94,6 @@ int process_verifier(char *buffer) {
int verifier_getissuer(char *buffer) { int verifier_getissuer(char *buffer) {
int ret = 0; int ret = 0;
printf("ISSUER > VERIFIER: %s", buffer);
switch (verifier.state) { switch (verifier.state) {
case ON: case ON:
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
@ -101,13 +102,25 @@ int verifier_getissuer(char *buffer) {
break; break;
case ASKISSUER: case ASKISSUER:
if (0 == strncasecmp("PUBLISH", buffer, 7)) { if (0 == strncasecmp("PUBLISH", buffer, 7)) {
bzero(buffer, MAX_BUFSIZE); printf("ISSUER > VERIFIER: %s", buffer);
uint8_t binbuf[MAX_BUFSIZE];
char *current = &buffer[8];
ecdaa_hextobin(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
ret = ecdaa_issuer_public_key_FP256BN_deserialize(&verifier.ipk, binbuf);
if (-1 == ret) {
printf("verifier_getpublic: member public key is malformed!\n");
ret = -1;
} else if (-2 == ret) {
printf("verifier_getpublic: signature of member public key is invalid\n");
ret = -1;
} else {
verifier.state = GOTISSUER; verifier.state = GOTISSUER;
ret = 1; ret = 1;
} }
}
break; break;
default: default:
ret - 1; ret = -1;
} }
if (0 == ret) { if (0 == ret) {
printf("ISSUER < VERIFIER: %s", buffer); printf("ISSUER < VERIFIER: %s", buffer);
@ -118,7 +131,6 @@ int verifier_getissuer(char *buffer) {
int verifier_getmember(char *buffer) { int verifier_getmember(char *buffer) {
int ret = 0; int ret = 0;
printf("ISSUER > VERIFIER: %s", buffer);
switch (verifier.state) { switch (verifier.state) {
case ON: case ON:
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
@ -127,16 +139,41 @@ int verifier_getmember(char *buffer) {
break; break;
case ASKMEMBER: case ASKMEMBER:
if (0 == strncasecmp("PUBLISH", buffer, 7)) { if (0 == strncasecmp("PUBLISH", buffer, 7)) {
bzero(buffer, MAX_BUFSIZE); printf("MEMBER > VERIFIER: %s", buffer);
uint8_t binbuf[MAX_BUFSIZE];
char *current = &buffer[8];
ecdaa_hextobin(current, binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
ret = ecdaa_member_public_key_FP256BN_deserialize_no_check(&verifier.mpk, binbuf);
if (-1 == ret) {
printf("verifier_getmember: member public key is malformed!\n");
ret = -1;
} else if (-2 == ret) {
printf("verifier_getmember: signature of member public key is invalid\n");
ret = -1;
} else {
verifier.state = GOTMEMBER; verifier.state = GOTMEMBER;
ret = 1; ret = 1;
} }
}
break; break;
default: default:
ret - 1; ret = -1;
} }
if (0 == ret) { if (0 == ret) {
printf("ISSUER < VERIFIER: %s", buffer); printf("MEMBER < VERIFIER: %s", buffer);
} }
return ret; return ret;
} }
//"ATTEST" > "OK"
int verifier_attestmember(char *buffer) {
bzero(buffer, MAX_BUFSIZE);
strncat(buffer, "OK\n", 16);
return 0;
}
//"LINK" > "NOT IMPLEMENTED"
int verifier_checklink(char *buffer) {
strncat(buffer, "NOT_IMPLEMENTED\n", 16);
return 0;
}

Write Preview
Loading…
Cancel
Save