masterthesis-ecdaa-network-wrapper/issuer.c

#include "issuer.h"

typedef enum issuer_state {
    ON,
    JOINSTART,
    JOINPROCEED,
    READY
} issuerstate_e;

typedef struct issuer {
    struct ecdaa_issuer_public_key_FP256BN ipk;
    struct ecdaa_issuer_secret_key_FP256BN isk;
    uint8_t nonce[NONCE_SIZE];
    struct ecdaa_member_public_key_FP256BN mpk;
    issuerstate_e state;
    struct ecdaa_credential_FP256BN cred;
    struct ecdaa_credential_FP256BN_signature cred_sig;
} issuer_t;

issuer_t issuer;

int issuer_setup(char *buffer);
int issuer_joinstart(char *buffer);
int issuer_joinproceed(char *buffer);
int issuer_publish(char *buffer);

int main() {
    int err = 0;

    //if (2 != server_start(&process_issuer, ISSUERPORT)) {
    //    printf("server failed\n");
    //}
    uint8_t buffer[1024];
    uint8_t *current = buffer;
    char send[1024];
    bzero(buffer, 1024);
    bzero(send,1024);

    struct ecdaa_issuer_public_key_FP256BN key;

    ecdaa_issuer_key_pair_FP256BN_generate(&issuer.ipk, &issuer.isk, ecdaa_rand);
    ecdaa_issuer_public_key_FP256BN_serialize(current, &issuer.ipk);
    ecdaa_bintohex((char*)current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH, send);
    printf("%s\n", send);
    bzero(current, 1024);
    ecdaa_hextobin(send, (char*)current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
    int ret = ecdaa_issuer_public_key_FP256BN_deserialize(&key, current);
    printf("%i\n",ret);
    return 0;
}

int process_issuer(char *buffer) {
    ssize_t len = 0;
    int ret = 0;

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

    if (0 == strncasecmp("OK", buffer, 2)) {
        switch (issuer.state) {
            case JOINPROCEED:
                issuer.state = READY;
                break;
            default:
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("ERR", buffer, 3)) {
        switch (issuer.state) {
            case JOINPROCEED:
                printf("command failed at client\n");
                issuer.state = READY;
                break;
            default:
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("SETUP", buffer, 5)) {
        switch (issuer.state) {
            case ON:
                if(0 == issuer_setup(buffer)) {
                    issuer.state = READY;
                }
                break;
            default:
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("JOIN", buffer, 4)) {
        switch (issuer.state) {
            case READY:
                if(0 == issuer_joinstart(buffer)) {
                    issuer.state = JOINSTART;
                }
                break;
            default:
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("APPEND", buffer, 6)) {
        switch (issuer.state) {
            case JOINSTART:
                if(0 == issuer_joinproceed(buffer)) {
                    issuer.state = READY;
                }
                break;
            default:
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
        switch (issuer.state) {
            case READY:
                issuer_publish(buffer);
                issuer.state = READY;
                break;
            default:
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } 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("< ISSUER: %s", buffer);
    return ret;
}

// "JOIN" > "JOINSTART <issuer.nonce>"
int issuer_joinstart(char *buffer) {
    getrandom(issuer.nonce, NONCE_SIZE, GRND_RANDOM);
    char* current;
    bzero(buffer, MAX_BUFSIZE);
    strncpy(buffer, "JOINSTART ", 10);
    current = &buffer[10];
    ecdaa_bintohex(issuer.nonce, NONCE_SIZE, buffer);
    buffer[2 * NONCE_SIZE + 10] = '\n';
    return 0;
}

// "APPEND <member.mpk>" > "JOINPROCEED <member.cred><member.cred_sig>"
int issuer_joinproceed(char *buffer) {
    char *current = &buffer[7];
    uint8_t binbuf[MAX_BUFSIZE];
    bzero(binbuf, MAX_BUFSIZE);

    ecdaa_hextobin(current, binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
    int ret = ecdaa_member_public_key_FP256BN_deserialize(&issuer.mpk, binbuf, issuer.nonce, NONCE_SIZE);
    if(-1 == ret) {
        printf("issuer_joinproceed: member public key is malformed!");
        return -1;
    } else if (-2 == ret) {
        printf("issuer_joinproceed: signature of member public key is invalid");
    }

    if (0 != ecdaa_credential_FP256BN_generate(&issuer.cred, &issuer.cred_sig, &issuer.isk, &issuer.mpk, ecdaa_rand)) {
        printf("issuer_joinproceed: error generating credential\n");
        return -1;
    }
    bzero(buffer, MAX_BUFSIZE);
    strncpy(buffer, "JOINPROCEED ", 12);

    current = &buffer[12];
    ecdaa_credential_FP256BN_serialize(binbuf, &issuer.cred);
    bzero(binbuf, MAX_BUFSIZE);
    ecdaa_bintohex(binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH, current);

    current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH];
    ecdaa_credential_FP256BN_signature_serialize(binbuf, &issuer.cred_sig);
    bzero(binbuf, MAX_BUFSIZE);
    ecdaa_bintohex(binbuf, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH, current);

    buffer[2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 2 * ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH + 12] = '\n';
    return 0;
}

// "SETUP > SETUPDONE"
int issuer_setup(char *buffer) {
    printf("setup()\n");
    if (0 != ecdaa_issuer_key_pair_FP256BN_generate(&issuer.ipk, &issuer.isk, ecdaa_rand)) {
        printf("issuer_setup: Error generating issuer key-pair\n");
        return -1;
    }
    bzero(buffer, MAX_BUFSIZE);
    strncpy(buffer, "SETUPDONE\n", 10);
    return 0;
}

// "PUBLISH" > "PUBLISH <issuer.ipk>"
int issuer_publish(char *buffer) {
    printf("publish()\n");
    char *current;
    uint8_t binbuf[MAX_BUFSIZE];
    bzero(buffer, MAX_BUFSIZE);

    strncpy(buffer, "PUBLISH ", 8);

    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);

    buffer[2 * ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH + 8] = '\n';

    return 0;
}