masterthesis-ecdaa-network-wrapper/member.c

#include "member.h"

typedef enum memberstate {
    ON,
    JOIN,
    APPEND,
    JOINPROCEED,
    JOINED,
    ATTEST,
    PUBLISH
} memberstate_e;

typedef struct member {
    struct ecdaa_member_public_key_FP256BN mpk;
    struct ecdaa_member_secret_key_FP256BN msk;
    memberstate_e state;
    uint8_t nonce[NONCE_SIZE];
    struct ecdaa_credential_FP256BN cred;
    struct ecdaa_credential_FP256BN_signature cred_sig;
} member_t;

member_t member;

int member_join(char* buffer);
int member_attest(char* buffer);
int member_publish(char* buffer);
int member_joinappend(char* buffer);
int member_joinfinish(char* buffer);

int main() {
    int err = 0;

    if (2 != server_start(&process_member, MEMBERPORT)) {
        printf("server failed\n");
    }
    return 0;
}

int process_member(char *buffer) {
    int ret = 0;

        printf("> MEMBER: %s\n", buffer);

        if (0 == strncasecmp("ATTEST", buffer, 6)) {
            printf("attest()\n");
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "ATTEST ", 7);
            member_attest(buffer);
        } else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
            printf("publish()\n");
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "PUBLISH ", 8);
            member_publish(buffer);
        } else if (member.state != JOINED && 0 == strncasecmp("JOIN", buffer, 4)) {
            printf("join()\n");
            member.state = JOIN;
            ret = client_connect(&member_join, ISSUERIP, ISSUERPORT);
            if (0 >= ret || JOINED != member.state) {
                printf("process_member: issuer connection failed\n");
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
            } else {
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "OK\n", 3);
            }
            ret = 0;
        } else if (0 == strncasecmp("EXIT", buffer, 4)) {
            printf("exit()\n");
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "OK\n", 3);
            ret = 1;
        } else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "OK\n", 3);
            ret = 2;
        } else {
            printf("error()\n");
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "ERR\n", 4);
            ret = 0;
        }

        printf("< MEMBER: %s\n", buffer);
    return ret;
}

int member_join(char *buffer) {
    int ret = 0;

    printf("ISSUER > MEMBER: %s", buffer);
    switch (member.state) {
        case JOIN:
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "JOIN\n", 5);
            member.state = APPEND;
            break;
        case APPEND:
            if (0 == strncasecmp("JOINSTART", buffer, 9)) {
                member_joinappend(buffer);
                member.state = JOINPROCEED;
            }
            break;
        case JOINPROCEED:
            if (0 == strncasecmp("JOINPROCEED", buffer, 11)) {
                member_joinfinish(buffer);
                member.state = JOINED;
                ret = 1;
            }
            break;
        default:
            ret -1;
    }
    if(0 == ret) {
        printf("ISSUER < MEMBER: %s", buffer);
    }
    return ret;
}

int member_attest(char* buffer) {
    strncat(buffer, "<attestval>\n", 13);
    return 0;
}

//"PUBLISH" > "PUBLISH <member.mpk>"
int member_publish(char* buffer) {
    strncat(buffer, "<publicval>\n", 12);
    return 0;
}

//"JOINSTART <issuer.nonce>" > "APPEND <member.mpk>"
int member_joinappend(char* buffer) {
    char *current = &buffer[10];
    uint8_t binbuf[MAX_BUFSIZE];
    ecdaa_hextobin(current, member.nonce, NONCE_SIZE);

    if (0 != ecdaa_member_key_pair_FP256BN_generate(&member.mpk, &member.msk, member.nonce, NONCE_SIZE, ecdaa_rand)) {
        fprintf(stderr, "Error generating member key-pair\n");
        return 1;
    }
    bzero(buffer, MAX_BUFSIZE);
    strncpy(buffer, "APPEND ", 7);

    current = &buffer[7];
    bzero(binbuf, MAX_BUFSIZE);
    ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk);
    ecdaa_bintohex(binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH, current);
    return 0;
}

//"JOINPROCEED <member.cred><member.cred_sig>" > ""
int member_joinfinish(char* buffer) {
    char *current = &buffer[12];
    uint8_t binbuf[MAX_BUFSIZE];
    ecdaa_credential_FP256BN_deserialize(binbuf, &member.cred);
    current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH];
    //ecdaa_credential_FP256BN_signature_deserialize(current, &member.cred_sig);
    bzero(buffer, MAX_BUFSIZE);
    return 0;
}