From 58666690664b1c8a493a287c8863bc530d765fd3 Mon Sep 17 00:00:00 2001 From: Michael Preisach Date: Tue, 22 Sep 2020 09:56:07 +0200 Subject: [PATCH] added basic lib test and fixed bugs --- CMakeLists.txt | 10 +- common.c | 2 +- common.h | 2 +- daa-test.c | 301 +++++++++++++++++++++++++++++++++++++++++++++++++ daa-test.h | 8 ++ issuer.c | 8 +- verifier.c | 2 +- 7 files changed, 323 insertions(+), 10 deletions(-) create mode 100644 daa-test.c create mode 100644 daa-test.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 504bd21..944d987 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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) diff --git a/common.c b/common.c index 23ab3ab..86e542e 100644 --- a/common.c +++ b/common.c @@ -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); diff --git a/common.h b/common.h index 816f25f..0d89807 100644 --- a/common.h +++ b/common.h @@ -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 diff --git a/daa-test.c b/daa-test.c new file mode 100644 index 0000000..2b249c2 --- /dev/null +++ b/daa-test.c @@ -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; + +} diff --git a/daa-test.h b/daa-test.h new file mode 100644 index 0000000..dad0062 --- /dev/null +++ b/daa-test.h @@ -0,0 +1,8 @@ + +#ifndef ECDAA_ISSUER_MEMBER_H +#define ECDAA_ISSUER_MEMBER_H +#include +#include +#include "server.h" +#include "client.h" +#include "common.h" diff --git a/issuer.c b/issuer.c index ba3ded6..d7ce429 100644 --- a/issuer.c +++ b/issuer.c @@ -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'; diff --git a/verifier.c b/verifier.c index 39578f8..7a82567 100644 --- a/verifier.c +++ b/verifier.c @@ -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 = ¤t[2 * MAX_MSGSIZE]; has_nym = current[0] - '0'; current = ¤t[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);