Message transmission works with bsn but not without

common.h

@@ -18,7 +18,7 @@
 #define VERIFIERPORT 6592
 
 #define MAX_CLIENTS 10
-#define MAX_BUFSIZE 2048
+#define MAX_BUFSIZE 20480 
 #define MAX_MSGSIZE ((MAX_BUFSIZE - 1536) / 2)
 #define MAX_BSNSIZE 128
 #define NONCE_SIZE 384

member.c

@@ -38,8 +38,8 @@ int main(int argc, char **argv) {
     char buffer[MAX_BUFSIZE];
     char *remote_ip = argv[2];
     int ret = 0;
-//  strncpy(member.bsn, "mybasename", 10);
-//  member.bsn_len = strlen(member.bsn);
+    //strncpy(member.bsn, "mybasename", 10);
+    //member.bsn_len = strlen(member.bsn);
     switch(argc) {
         case 3:
             if( 0 == strncasecmp("--join", argv[1], 6) || 0 == strncasecmp("-j", argv[1], 2)) {
@@ -171,24 +171,30 @@ int member_verifymsg(char *buffer) {
     ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, member.bsn, member.bsn_len, &member.msk, &member.cred, ecdaa_rand);
 
     bzero(buffer, MAX_BUFSIZE);
-    bzero(binbuf, MAX_BUFSIZE);
     strncpy(current, "VERIFYMSG ", 10);
     current = &current[10];
 
-    strncpy(current, (char*) msg, msg_len);
-    current[MAX_MSGSIZE] = has_nym == 1 ? '1' : '0';
-    current = &current[MAX_MSGSIZE + 1];
+    ecdaa_bintohex(msg, msg_len, current);
+    current = &current[2 * MAX_MSGSIZE];
+    //strncpy(current, (char*) msg, msg_len);
     if(has_nym) {
+        current[0] = '1';
+        current = &current[1];
         strncpy(current, (char *)member.bsn, MAX_BSNSIZE);
         current = &current[MAX_BSNSIZE];
+    } else {
+        current[0] = '0';
+	current = &current[1];
     }
 
+    bzero(binbuf, MAX_BUFSIZE);
     ecdaa_signature_FP256BN_serialize(binbuf, &sig, has_nym);
     ecdaa_bintohex(binbuf, sig_len, current);
     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: bsn: %s, len: %lu\n",(char *)member.bsn, strlen((char *)member.bsn));
-    printf("member_verifymsg: sig: %s\n",current);
+    printf("member_verifymsg: sig: %s, len: %lu\n", current, sig_len);
+
     current[2 * sig_len] = '\n';
     return 0;
 }

verifier.c

@@ -47,10 +47,10 @@ int process_verifier(char *buffer) {
                 ret = verifier_checkattest(&buffer[10]);
                 bzero(buffer, MAX_BUFSIZE);
                 if (-1 == ret) {
-                    printf("verifier_attestmember: member public key is malformed!\n");
+                    printf("process_verifier: member public key is malformed!\n");
                     strncpy(buffer, "ERR\n", 4);
                 } else if (-2 == ret) {
-                    printf("verifier_attestmember: signature of member public key is invalid\n");
+                    printf("process_verifier: signature of member public key is invalid\n");
                     strncpy(buffer, "ERR\n", 4);
                 } else {
                     strncpy(buffer, "OK\n", 3);
@@ -200,32 +200,38 @@ int verifier_attestmember(char *buffer) {
 //"ATTEST <msg>1<signature with bsn>"
 int verifier_checkattest(char *buffer) {
     char *current = buffer; 
-
     char msg[MAX_MSGSIZE];
-    strncpy(msg, current, MAX_MSGSIZE);
-    size_t msg_len = strlen(msg);
-    current = &current[MAX_MSGSIZE];
-
-    int has_nym = current[0] - '0';
-    current = &current[1];
-
+    size_t msg_len = 0;
+    int has_nym = 0;
     char bsn[MAX_BSNSIZE];
-    bzero(bsn, MAX_BSNSIZE);
     size_t bsn_len = 0;
-
     uint8_t binbuf[MAX_BUFSIZE];
-    bzero(binbuf, MAX_BUFSIZE);
+    size_t sig_len = 0;
+    struct ecdaa_signature_FP256BN sig;
+    int ret = 0;
+
+    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];
 
     if (has_nym) {
+        bzero(bsn, MAX_BSNSIZE);
         strncpy(bsn, current, MAX_BSNSIZE);
         bsn_len = strlen(bsn);
         current = &current[MAX_BSNSIZE];
+	sig_len = ecdaa_signature_FP256BN_with_nym_length(); 
+    } else {
+        
+	sig_len = ecdaa_signature_FP256BN_length(); 
+        
     }
-    int sig_len = has_nym ? ECDAA_SIGNATURE_FP256BN_WITH_NYM_LENGTH : ECDAA_SIGNATURE_FP256BN_LENGTH;
     ecdaa_hextobin(current, binbuf, sig_len);
 
-    struct ecdaa_signature_FP256BN sig;
-    int ret = ecdaa_signature_FP256BN_deserialize(&sig, binbuf, has_nym);
+    ret = ecdaa_signature_FP256BN_deserialize(&sig, binbuf, has_nym);
     if (0 != ret) {
         printf("verifier_checkattest: error reading signature\n");
         return -1;
@@ -233,14 +239,13 @@ int verifier_checkattest(char *buffer) {
 
     printf("verifier_checkattest: msg: %s, len: %lu\n",msg, msg_len);
     printf("verifier_checkattest: bsn: %s, len: %lu\n",bsn, bsn_len);
-    printf("verifier_checkattest: sig: %s", current);
+    printf("verifier_checkattest: sig: %s, len: %lu\n", current, sig_len);
     ret = ecdaa_signature_FP256BN_verify(&sig, &verifier.ipk.gpk, &verifier.revocations, (uint8_t *) msg, msg_len,
-                                         (uint8_t *) bsn, bsn_len);
+            (uint8_t *) bsn, bsn_len);
     if (0 != ret) {
         printf("verifier_checkattest: signature not valid, ret = %i\n", ret);
         return -1;
     }
-
     return 0;
 }