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

added basic lib test and fixed bugs

master
Michael Preisach 5 years ago
parent
8c7f7e955f
commit
5866669066
7 changed files with 323 additions and 10 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. 10
      CMakeLists.txt
  2. 2
      common.c
  3. 2
      common.h
  4. 301
      daa-test.c
  5. 8
      daa-test.h
  6. 8
      issuer.c
  7. 2
      verifier.c

10
CMakeLists.txt
View File

@ -23,12 +23,16 @@ target_include_directories(ecdaa_member_tpm PUBLIC
)
target_link_libraries(ecdaa_member_tpm /usr/lib/x86_64-linux-gnu/libecdaa.so)
target_link_libraries(ecdaa_member_tpm /usr/lib/x86_64-linux-gnu/libecdaa-tpm.so)
# target_link_libraries(ecdaa_member_tpm /usr/lib/x86_64-linux-gnu/libxaptum-tpm.so)
# target_link_libraries(ecdaa_member_tpm /usr/lib/x86_64-linux-gnu/libtss2-esys.so)
add_executable(ecdaa_verifier verifier.c common.h common.c server.h server.c client.h client.c)
target_include_directories(ecdaa_verifier PUBLIC
${ECDAA_AMCL}
)
target_link_libraries(ecdaa_verifier /usr/lib/x86_64-linux-gnu/libecdaa.so)
# target_link_libraries(ecdaa_verifier /usr/lib/x86_64-linux-gnu/libecdaa-tpm.so)
add_executable(ecdaa_test daa-test.c common.h common.c client.h client.c server.h server.c)
target_include_directories(ecdaa_test PUBLIC
${ECDAA_AMCL}
)
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)

2
common.c
View File

@ -28,7 +28,7 @@ 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, char *out_hex, size_t inlen) {
for (size_t i = 0, j = 0; i < inlen; i++, j+=2) {
out_hex[j] = bin2hex(in_bin[i]);
out_hex[j+1] = bin2hex(in_bin[i] >> 4);

2
common.h
View File

@ -29,6 +29,6 @@ void ecdaa_rand(void *buffer, size_t buflen);
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, char *out_hex, size_t inlen);
#endif //ECDAA_ISSUER_COMMON_H

301
daa-test.c
View File

@ -0,0 +1,301 @@
#include daa-test.h
int test1();
int test2();
int test3();
int main(int argc, char **argv) {
if(0 != test1()) {
printf("test1 failed\n");
return 0;
} else {
printf("test1 succeeded\n");
}
int test1() {
struct ecdaa_issuer_public_key_FP256BN ipk;
struct ecdaa_issuer_secret_key_FP256BN isk;
struct ecdaa_member_public_key_FP256BN mpk;
struct ecdaa_member_secret_key_FP256BN msk;
uint8_t nonce[NONCE_SIZE];
struct ecdaa_credential_FP256BN cred;
struct ecdaa_credential_FP256BN_signature cred_sig;
struct ecdaa_issuer_public_key_FP256BN ipk;
uint8_t bsn[MAX_BSNSIZE];
size_t bsn_len = 0;
uint8_t msg[MAX_MSGSIZE];
size_t msg_len = 0;
struct ecdaa_revocations_FP256BN revocations;
bzero(bsn, MAX_BSNSIZE);
bzero(msg, MAX_MSGSIZE);
if(0 != ecdaa_issuer_key_pair_FP256BN_generate(&ipk, &isk, ecdaa_rand)) {
printf("generate issuer key pair failed\n");
return 1;
}
ecdaa_rand(nonce, NONCE_SIZE);
if(0 != ecdaa_member_key_pair_FP256BN_generate(&mpk, &msk, nonce, NONCE_SIZE, ecdaa_rand)) {
printf("generate member key pair failed\n");
return 1;
}
if(0 != ecdaa_credential_FP256BN_generate(&cred, &cred_sig, &isk, &mpk, ecdaa_rand)) {
printf("generate credential failed\n");
return 1;
}
strncpy(msg, "test message\n", 13);
msg_len = strlen(msg);
if(0 != ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, bsn, bsn_len, &msk, &cred, ecdaa_rand)) {
printf("signing message failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_verify(&sig, &ipk.gpk, &revocations, msg, msg_len, bsn, bsn_len)) {
printf("verify message with bsn failed\n");
return 1;
}
strncpy(bsn, "test basename", 13);
bsn_len = strlen(bsn);
if(0 != ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, bsn, bsn_len, &msk, &cred, ecdaa_rand)) {
printf("signing message with bsn failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_verify(&sig, &gpk, &revocations, msg, msg_len, bsn, bsn_len)) {
printf("verify signature with bsn failed\n");
return 1;
}
return 0;
}
int test2() {
struct ecdaa_issuer_public_key_FP256BN ipk;
struct ecdaa_issuer_secret_key_FP256BN isk;
struct ecdaa_member_public_key_FP256BN mpk;
struct ecdaa_member_secret_key_FP256BN msk;
struct ecdaa_credential_FP256BN cred;
struct ecdaa_credential_FP256BN_signature cred_sig;
uint8_t nonce[NONCE_SIZE];
struct ecdaa_issuer_public_key_FP256BN ipk2;
struct ecdaa_issuer_secret_key_FP256BN isk2;
struct ecdaa_member_public_key_FP256BN mpk2;
struct ecdaa_member_secret_key_FP256BN msk2;
struct ecdaa_credential_FP256BN cred2;
struct ecdaa_credential_FP256BN_signature cred_sig2;
uint8_t bsn[MAX_BSNSIZE];
size_t bsn_len = 0;
uint8_t msg[MAX_MSGSIZE];
size_t msg_len = 0;
struct ecdaa_revocations_FP256BN revocations;
uint8_t binbuf[MAX_BUFSIZE];
char buffer[MAX_BUFSIZE];
bzero(binbuf,MAX_BUFSIZE);
bzero(buffer,MAX_BUFSIZE);
bzero(bsn, MAX_BSNSIZE);
bzero(msg, MAX_MSGSIZE);
if(0 != ecdaa_issuer_key_pair_FP256BN_generate(&ipk, &isk, ecdaa_rand)) {
printf("generate issuer key pair failed\n");
return 1;
}
if(0 != ecdaa_issuer_public_key_FP256BN_serialize_file("ipktest.bin", &ipk) ||
0 != ecdaa_issuer_secret_key_FP256BN_serialize_file("isktest.bin", &isk)) {
printf("saving issuer key-pair to disk failed\n");
return 1;
}
if(0 != ecdaa_issuer_public_key_FP256BN_deserialize_file(&ipk2, "ipktest.bin") ||
0 != ecdaa_issuer_secret_key_FP256BN_deserialize_file(&isk2, "isktest.bin")) {
printf("loading issuer key pair failed\n");
return 1;
}
ecdaa_rand(nonce, NONCE_SIZE);
if(0 != ecdaa_member_key_pair_FP256BN_generate(&mpk, &msk, nonce, NONCE_SIZE, ecdaa_rand)) {
printf("generate member key pair failed\n");
return 1;
}
if(0 != ecdaa_member_public_key_FP256BN_serialize_file("mpktest.bin", &mpk) ||
0 != ecdaa_member_secret_key_FP256BN_serialize_file("msktest.bin", &msk)) {
printf("saving member key-pair to disk failed\n");
return 1;
}
if(0 != ecdaa_member_public_key_FP256BN_deserialize_file(&mpk2, "mpktest.bin") ||
0 != ecdaa_member_secret_key_FP256BN_deserialize_file(&msk2, "msktest.bin")) {
printf("loading member key pair failed\n");
return 1;
}
if(0 != ecdaa_credential_FP256BN_generate(&cred, &cred_sig, &isk2, &mpk2, ecdaa_rand)) {
printf("generate credential failed\n");
return 1;
}
if(0 != ecdaa_credential_FP256BN_serialize_file("credtest.bin", &cred)) {
printf("saving credential to disk failed\n");
}
if(0 != ecdaa_credential_FP256BN_deserialize_file(&cred2, "credtest.bin")) {
printf("loading credential failed\n");
}
strncpy(msg, "test message\n", 13);
msg_len = strlen(msg);
if(0 != ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, bsn, bsn_len, &msk2, &cred2, ecdaa_rand)) {
printf("signing message failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_serialize_file("sigtest.bin", &sig)) {
printf("saving signature to disk failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_deserialize_file(&sig2, "sigtest.bin")) {
printf("loading signature failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_verify(&sig2, &ipk2.gpk, &revocations, msg, msg_len, bsn, bsn_len)) {
printf("verify message with bsn failed\n");
return 1;
}
strncpy(bsn, "test basename", 13);
bsn_len = strlen(bsn);
if(0 != ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, bsn, bsn_len, &msk2, &cred2, ecdaa_rand)) {
printf("signing message with bsn failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_serialize_file("sigtest.bin", &sig)) {
printf("saving signature to disk failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_deserialize_file(&sig2, "sigtest.bin")) {
printf("loading signature failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_verify(&sig2, &ipk2.gpk, &revocations, msg, msg_len, bsn, bsn_len)) {
printf("verify signature with bsn failed\n");
return 1;
}
return 0;
}
int test3() {
struct ecdaa_issuer_public_key_FP256BN ipk;
struct ecdaa_issuer_secret_key_FP256BN isk;
struct ecdaa_member_public_key_FP256BN mpk;
struct ecdaa_member_secret_key_FP256BN msk;
struct ecdaa_credential_FP256BN cred;
struct ecdaa_credential_FP256BN_signature cred_sig;
uint8_t nonce[NONCE_SIZE];
struct ecdaa_issuer_public_key_FP256BN ipk2;
struct ecdaa_issuer_secret_key_FP256BN isk2;
struct ecdaa_member_public_key_FP256BN mpk2;
struct ecdaa_member_secret_key_FP256BN msk2;
struct ecdaa_credential_FP256BN cred2;
struct ecdaa_credential_FP256BN_signature cred_sig2;
uint8_t bsn[MAX_BSNSIZE];
size_t bsn_len = 0;
uint8_t msg[MAX_MSGSIZE];
size_t msg_len = 0;
struct ecdaa_revocations_FP256BN revocations;
uint8_t binbuf[MAX_BUFSIZE];
char buffer[MAX_BUFSIZE];
bzero(binbuf,MAX_BUFSIZE);
bzero(buffer,MAX_BUFSIZE);
bzero(bsn, MAX_BSNSIZE);
bzero(msg, MAX_MSGSIZE);
char *current = buffer;
if(0 != ecdaa_issuer_key_pair_FP256BN_generate(&ipk, &isk, ecdaa_rand)) {
printf("generate issuer key pair failed\n");
return 1;
}
if(0 != ecdaa_issuer_public_key_FP256BN_serialize(binbuf, &ipk)) {
printf("serialize issuers public key failed");
return 1;
}
ecdaa_bintohex(binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH, current);
if(0 != ecdaa_issuer_public_key_FP256BN_deserialize_file(&ipk2, "ipktest.bin") ||
0 != ecdaa_issuer_secret_key_FP256BN_deserialize_file(&isk2, "isktest.bin")) {
printf("loading issuer key pair failed\n");
return 1;
}
ecdaa_rand(nonce, NONCE_SIZE);
if(0 != ecdaa_member_key_pair_FP256BN_generate(&mpk, &msk, nonce, NONCE_SIZE, ecdaa_rand)) {
printf("generate member key pair failed\n");
return 1;
}
if(0 != ecdaa_member_public_key_FP256BN_serialize_file("mpktest.bin", &mpk) ||
0 != ecdaa_member_secret_key_FP256BN_serialize_file("msktest.bin", &msk)) {
printf("saving member key-pair to disk failed\n");
return 1;
}
if(0 != ecdaa_member_public_key_FP256BN_deserialize_file(&mpk2, "mpktest.bin") ||
0 != ecdaa_member_secret_key_FP256BN_deserialize_file(&msk2, "msktest.bin")) {
printf("loading member key pair failed\n");
return 1;
}
if(0 != ecdaa_credential_FP256BN_generate(&cred, &cred_sig, &isk2, &mpk2, ecdaa_rand)) {
printf("generate credential failed\n");
return 1;
}
if(0 != ecdaa_credential_FP256BN_serialize_file("credtest.bin", &cred)) {
printf("saving credential to disk failed\n");
}
if(0 != ecdaa_credential_FP256BN_deserialize_file(&cred2, "credtest.bin")) {
printf("loading credential failed\n");
}
strncpy(msg, "test message\n", 13);
msg_len = strlen(msg);
if(0 != ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, bsn, bsn_len, &msk2, &cred2, ecdaa_rand)) {
printf("signing message failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_serialize_file("sigtest.bin", &sig)) {
printf("saving signature to disk failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_deserialize_file(&sig2, "sigtest.bin")) {
printf("loading signature failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_verify(&sig2, &ipk2.gpk, &revocations, msg, msg_len, bsn, bsn_len)) {
printf("verify message with bsn failed\n");
return 1;
}
strncpy(bsn, "test basename", 13);
bsn_len = strlen(bsn);
if(0 != ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, bsn, bsn_len, &msk2, &cred2, ecdaa_rand)) {
printf("signing message with bsn failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_serialize_file("sigtest.bin", &sig)) {
printf("saving signature to disk failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_deserialize_file(&sig2, "sigtest.bin")) {
printf("loading signature failed\n");
return 1;
}
if(0 != ecdaa_signature_FP256BN_verify(&sig2, &ipk2.gpk, &revocations, msg, msg_len, bsn, bsn_len)) {
printf("verify signature with bsn failed\n");
return 1;
}
return 0;
}

8
daa-test.h
View File

@ -0,0 +1,8 @@
#ifndef ECDAA_ISSUER_MEMBER_H
#define ECDAA_ISSUER_MEMBER_H
#include <ecdaa.h>
#include <ecdaa.h>
#include "server.h"
#include "client.h"
#include "common.h"

8
issuer.c
View File

@ -149,7 +149,7 @@ int issuer_joinstart(char *buffer) {
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "JOINSTART ", 10);
current = &buffer[10];
ecdaa_bintohex(issuer.nonce, NONCE_SIZE, current);
ecdaa_bintohex(issuer.nonce, current, NONCE_SIZE);
buffer[2 * NONCE_SIZE + 10] = '\n';
return 0;
}
@ -185,12 +185,12 @@ int issuer_joinproceed(char *buffer) {
current = &buffer[12];
bzero(binbuf, MAX_BUFSIZE);
ecdaa_credential_FP256BN_serialize(binbuf, &issuer.cred);
ecdaa_bintohex(binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH, current);
ecdaa_bintohex(binbuf, current, ECDAA_CREDENTIAL_FP256BN_LENGTH);
current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1];
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, current, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);
buffer[2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1 + 2 * ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH + 12] = '\n';
return 0;
@ -248,7 +248,7 @@ int issuer_publish(char *buffer) {
current = &buffer[8];
bzero(binbuf, MAX_BUFSIZE);
ecdaa_issuer_public_key_FP256BN_serialize(binbuf, &issuer.ipk);
ecdaa_bintohex(binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH, current);
ecdaa_bintohex(binbuf, current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
buffer[2 * ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH + 8] = '\n';

2
verifier.c
View File

@ -213,7 +213,6 @@ int verifier_checkattest(char *buffer) {
bzero(msg, MAX_MSGSIZE);
ecdaa_hextobin(current, msg, MAX_MSGSIZE);
msg_len = strlen(msg);
//strncpy(msg, current, MAX_MSGSIZE);
current = &current[2 * MAX_MSGSIZE];
has_nym = current[0] - '0';
current = &current[1];
@ -229,6 +228,7 @@ int verifier_checkattest(char *buffer) {
sig_len = ecdaa_signature_FP256BN_length();
}
bzero(binbuf, MAX_BUFSIZE);
ecdaa_hextobin(current, binbuf, sig_len);
ret = ecdaa_signature_FP256BN_deserialize(&sig, binbuf, has_nym);

Write Preview
Loading…
Cancel
Save