diff --git a/common.h b/common.h
index d1cc75d..816f25f 100644
--- a/common.h
+++ b/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
diff --git a/ecdaa_issuer b/ecdaa_issuer
index afb0bd0..c7104b8 100755
Binary files a/ecdaa_issuer and b/ecdaa_issuer differ
diff --git a/ecdaa_member b/ecdaa_member
index 381cfc3..b985f15 100755
Binary files a/ecdaa_member and b/ecdaa_member differ
diff --git a/ecdaa_verifier b/ecdaa_verifier
index b26983b..34f7906 100755
Binary files a/ecdaa_verifier and b/ecdaa_verifier differ
diff --git a/member.c b/member.c
index c39db8c..ee4a8e6 100644
--- a/member.c
+++ b/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;
 }
diff --git a/verifier.c b/verifier.c
index 8bdb3a8..39578f8 100644
--- a/verifier.c
+++ b/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;
 }