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

move to base64 encoding, testing required

master
Michael Preisach 5 years ago
parent
94cbddb97d
commit
1c476f844f
6 changed files with 37 additions and 40 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. 17
      issuer.c
  2. 6
      issuer.h
  3. 28
      member.c
  4. 9
      member.h
  5. 8
      verifier.c
  6. 9
      verifier.h

17
issuer.c
View File

@ -149,7 +149,7 @@ int issuer_joinstart(char *buffer) {
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, current, NONCE_SIZE); ecdaa_encode(issuer.nonce, current, NONCE_SIZE);
buffer[2 * NONCE_SIZE + 10] = '\n'; buffer[2 * NONCE_SIZE + 10] = '\n';
return 0; return 0;
} }
@ -161,7 +161,7 @@ int issuer_joinproceed(char *buffer) {
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
int ret = 0; int ret = 0;
ecdaa_hextobin(current, binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH); ecdaa_decode(current, binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
ret = ecdaa_member_public_key_FP256BN_deserialize(&issuer.mpk, binbuf, issuer.nonce, NONCE_SIZE); ret = ecdaa_member_public_key_FP256BN_deserialize(&issuer.mpk, binbuf, issuer.nonce, NONCE_SIZE);
if(-1 == ret) { if(-1 == ret) {
@ -185,14 +185,14 @@ int issuer_joinproceed(char *buffer) {
current = &buffer[12]; current = &buffer[12];
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_credential_FP256BN_serialize(binbuf, &issuer.cred); ecdaa_credential_FP256BN_serialize(binbuf, &issuer.cred);
ecdaa_bintohex(binbuf, current, ECDAA_CREDENTIAL_FP256BN_LENGTH); ret = ecdaa_encode(binbuf, current, ECDAA_CREDENTIAL_FP256BN_LENGTH);
current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1]; current = &current[ret];
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_credential_FP256BN_signature_serialize(binbuf, &issuer.cred_sig); ecdaa_credential_FP256BN_signature_serialize(binbuf, &issuer.cred_sig);
ecdaa_bintohex(binbuf, current, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH); ret = ecdaa_encode(binbuf, current, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);
buffer[2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1 + 2 * ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH + 12] = '\n'; current[ret] = '\n';
return 0; return 0;
} }
@ -242,15 +242,16 @@ int issuer_publish(char *buffer) {
char *current; char *current;
uint8_t binbuf[MAX_BUFSIZE]; uint8_t binbuf[MAX_BUFSIZE];
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
int ret = 0;
strncpy(buffer, "PUBLISH ", 8); strncpy(buffer, "PUBLISH ", 8);
current = &buffer[8]; current = &buffer[8];
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_issuer_public_key_FP256BN_serialize(binbuf, &issuer.ipk); ecdaa_issuer_public_key_FP256BN_serialize(binbuf, &issuer.ipk);
ecdaa_bintohex(binbuf, current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH); ret = ecdaa_encode(binbuf, current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
buffer[2 * ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH + 8] = '\n'; current[ret] = '\n';
return 0; return 0;
} }

6
issuer.h
View File

@ -2,8 +2,8 @@
// Created by root on 11/5/19. // Created by root on 11/5/19.
// //
#ifndef ECDAA_ISSUER_ISSUER_H #ifndef ECDAA_ISSUER_H
#define ECDAA_ISSUER_ISSUER_H #define ECDAA_ISSUER_H
#include <ecdaa.h> #include <ecdaa.h>
#include "server.h" #include "server.h"
#include "client.h" #include "client.h"
@ -13,4 +13,4 @@ int process_issuer(char *buffer);
const char* issuer_public_key_file = "ipk.bin"; const char* issuer_public_key_file = "ipk.bin";
const char* issuer_secret_key_file = "isk.bin"; const char* issuer_secret_key_file = "isk.bin";
#endif //ECDAA_ISSUER_ISSUER_H #endif //ECDAA_ISSUER_H

28
member.c
View File

@ -102,7 +102,7 @@ int member_join(char *buffer) {
printf("ISSUER > MEMBER: %s", buffer); printf("ISSUER > MEMBER: %s", buffer);
uint8_t binbuf[MAX_BUFSIZE]; uint8_t binbuf[MAX_BUFSIZE];
char *current = &buffer[8]; char *current = &buffer[8];
ecdaa_hextobin(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH); ecdaa_decode(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
ret = ecdaa_issuer_public_key_FP256BN_deserialize(&member.ipk, binbuf); ret = ecdaa_issuer_public_key_FP256BN_deserialize(&member.ipk, binbuf);
if (-1 == ret) { if (-1 == ret) {
printf("member_getpublic: issuer public key is malformed!\n"); printf("member_getpublic: issuer public key is malformed!\n");
@ -161,6 +161,7 @@ int member_verifymsg(char *buffer) {
uint8_t has_nym = member.bsn_len > 0 ? 1 : 0; uint8_t has_nym = member.bsn_len > 0 ? 1 : 0;
struct ecdaa_signature_FP256BN sig; struct ecdaa_signature_FP256BN sig;
size_t sig_len = has_nym ? ecdaa_signature_FP256BN_with_nym_length() : ecdaa_signature_FP256BN_length(); size_t sig_len = has_nym ? ecdaa_signature_FP256BN_with_nym_length() : ecdaa_signature_FP256BN_length();
int ret = 0;
if (0 == strncasecmp("OK", buffer, 2)) { if (0 == strncasecmp("OK", buffer, 2)) {
return 1; return 1;
@ -173,8 +174,8 @@ int member_verifymsg(char *buffer) {
strncpy(current, "VERIFYMSG ", 10); strncpy(current, "VERIFYMSG ", 10);
current = &current[10]; current = &current[10];
ecdaa_bintohex(msg, current, msg_len); ret = ecdaa_encode(msg, current, msg_len);
current = &current[2 * MAX_MSGSIZE]; current = &current[ret];
if(has_nym) { if(has_nym) {
if (0 != ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, member.bsn, member.bsn_len, &member.msk, &member.cred, ecdaa_rand)) { if (0 != ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, member.bsn, member.bsn_len, &member.msk, &member.cred, ecdaa_rand)) {
printf("member_verifymsg: Signing message failed\n"); printf("member_verifymsg: Signing message failed\n");
@ -193,19 +194,20 @@ int member_verifymsg(char *buffer) {
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_signature_FP256BN_serialize(binbuf, &sig, has_nym); ecdaa_signature_FP256BN_serialize(binbuf, &sig, has_nym);
ecdaa_bintohex(binbuf, current, sig_len); ret = ecdaa_encode(binbuf, current, sig_len);
printf("member_verifymsg: has_nym: %u, sig_len: %lu\n",has_nym, sig_len); printf("member_verifymsg: has_nym: %u, sig_len: %lu\n",has_nym, sig_len);
printf("member_verifymsg: msg: %s, len: %lu\n",msg, msg_len); printf("member_verifymsg: msg: %s, len: %lu\n",msg, msg_len);
printf("member_verifymsg: bsn: %s, len: %lu\n",(char *)member.bsn, strlen((char *)member.bsn)); printf("member_verifymsg: bsn: %s, len: %lu\n",(char *)member.bsn, strlen((char *)member.bsn));
printf("member_verifymsg: sig: %s, len: %lu\n", current, sig_len); printf("member_verifymsg: sig: %s, len: %lu\n", current, sig_len);
current[2 * sig_len] = '\n'; current[ret] = '\n';
return 0; return 0;
} }
//"PUBLISH" > "PUBLISH <member.mpk>" //"PUBLISH" > "PUBLISH <member.mpk>"
int member_publish(char *buffer) { int member_publish(char *buffer) {
char *current; char *current;
int ret = 0;
uint8_t binbuf[MAX_BUFSIZE]; uint8_t binbuf[MAX_BUFSIZE];
bzero(buffer, MAX_BUFSIZE); bzero(buffer, MAX_BUFSIZE);
@ -214,9 +216,9 @@ int member_publish(char *buffer) {
current = &buffer[8]; current = &buffer[8];
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk); ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk);
ecdaa_bintohex(binbuf, current, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH); ret = ecdaa_encode(binbuf, current, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
current[2 * ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH] = '\n'; current[ret] = '\n';
return 0; return 0;
} }
@ -225,7 +227,7 @@ int member_publish(char *buffer) {
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); int ret = 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_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)) { if (0 != ecdaa_member_key_pair_FP256BN_generate(&member.mpk, &member.msk, member.nonce, NONCE_SIZE, ecdaa_rand)) {
@ -238,8 +240,8 @@ int member_joinappend(char *buffer) {
current = &buffer[7]; current = &buffer[7];
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk); ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk);
ecdaa_bintohex(binbuf, current, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH); ret = ecdaa_encode(binbuf, current, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
current[2 * ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH] = '\n'; current[ret] = '\n';
return 0; return 0;
} }
@ -250,11 +252,11 @@ int member_joinfinish(char *buffer) {
uint8_t binbuf[MAX_BUFSIZE]; uint8_t binbuf[MAX_BUFSIZE];
int ret = 0; int ret = 0;
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_hextobin(current, binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH); ret = ecdaa_decode(current, binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH);
current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1]; current = &current[ret];
bincur = &binbuf[ECDAA_CREDENTIAL_FP256BN_LENGTH]; bincur = &binbuf[ECDAA_CREDENTIAL_FP256BN_LENGTH];
ecdaa_hextobin(current, bincur, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH); ecdaa_decode(current, bincur, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);
ret = ecdaa_credential_FP256BN_deserialize_with_signature(&member.cred, &member.mpk, &member.ipk.gpk, binbuf, bincur); ret = ecdaa_credential_FP256BN_deserialize_with_signature(&member.cred, &member.mpk, &member.ipk.gpk, binbuf, bincur);
if(-1 == ret) { if(-1 == ret) {
printf("member_joinfinish: credential is malformed!\n"); printf("member_joinfinish: credential is malformed!\n");

9
member.h
View File

@ -1,9 +1,6 @@
//
// Created by root on 11/5/19.
//
#ifndef ECDAA_ISSUER_MEMBER_H #ifndef ECDAA_MEMBER_H
#define ECDAA_ISSUER_MEMBER_H #define ECDAA_MEMBER_H
#include <ecdaa.h> #include <ecdaa.h>
#include <ecdaa.h> #include <ecdaa.h>
#include "server.h" #include "server.h"
@ -17,4 +14,4 @@ const char* member_secret_key_file = "msk.bin";
const char* member_credential_file = "mcred.bin"; const char* member_credential_file = "mcred.bin";
const char* member_nonce_file = "mnonce.bin"; const char* member_nonce_file = "mnonce.bin";
#endif //ECDAA_ISSUER_ISSUER_H #endif //ECDAA_ISSUER_H

8
verifier.c
View File

@ -131,7 +131,7 @@ int verifier_getissuer(char *buffer) {
printf("ISSUER > VERIFIER: %s", buffer); printf("ISSUER > VERIFIER: %s", buffer);
uint8_t binbuf[MAX_BUFSIZE]; uint8_t binbuf[MAX_BUFSIZE];
char *current = &buffer[8]; char *current = &buffer[8];
ecdaa_hextobin(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH); ecdaa_decode(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
ret = ecdaa_issuer_public_key_FP256BN_deserialize(&verifier.ipk, binbuf); ret = ecdaa_issuer_public_key_FP256BN_deserialize(&verifier.ipk, binbuf);
if (-1 == ret) { if (-1 == ret) {
printf("verifier_getpublic: issuer public key is malformed!\n"); printf("verifier_getpublic: issuer public key is malformed!\n");
@ -211,9 +211,9 @@ int verifier_checkattest(char *buffer) {
int ret = 0; int ret = 0;
bzero(msg, MAX_MSGSIZE); bzero(msg, MAX_MSGSIZE);
ecdaa_hextobin(current, msg, MAX_MSGSIZE); ret = ecdaa_decode(current, msg, MAX_MSGSIZE);
msg_len = strlen(msg); msg_len = strlen(msg);
current = &current[2 * MAX_MSGSIZE]; current = &current[ret];
has_nym = current[0] - '0'; has_nym = current[0] - '0';
current = &current[1]; current = &current[1];
@ -229,7 +229,7 @@ int verifier_checkattest(char *buffer) {
} }
bzero(binbuf, MAX_BUFSIZE); bzero(binbuf, MAX_BUFSIZE);
ecdaa_hextobin(current, binbuf, sig_len); ecdaa_decode(current, binbuf, sig_len);
ret = ecdaa_signature_FP256BN_deserialize(&sig, binbuf, has_nym); ret = ecdaa_signature_FP256BN_deserialize(&sig, binbuf, has_nym);
if (0 != ret) { if (0 != ret) {

9
verifier.h
View File

@ -1,9 +1,6 @@
//
// Created by root on 11/5/19.
//
#ifndef ECDAA_ISSUER_MEMBER_H #ifndef ECDAA_VERIFIER_H
#define ECDAA_ISSUER_MEMBER_H #define ECDAA_VERIFIER_H
#include <ecdaa.h> #include <ecdaa.h>
// #include <ecdaa-tpm.h> // #include <ecdaa-tpm.h>
#include "server.h" #include "server.h"
@ -12,4 +9,4 @@
int process_verifier(char *buffer); int process_verifier(char *buffer);
#endif //ECDAA_ISSUER_ISSUER_H #endif //ECDAA_VERIFIER_H

Write Preview
Loading…
Cancel
Save