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() {
    if (2 != server_start(&process_issuer, ISSUERPORT)) {
        printf("server failed\n");
    }
/*
    uint8_t buffer[1024], result[1024];
    uint8_t *current = buffer;
    char send[1024];
    bzero(buffer, 1024);
    bzero(result, 1024);
    bzero(send,1024);

    buffer[0] = 0x01;
    buffer[1] = 0x02;
    buffer[2] = 0x04;
    buffer[3] = 0x08;
    buffer[4] = 0x10;
    buffer[5] = 0x20;
    buffer[6] = 0x40;
    buffer[7] = 0x80;
    buffer[8] = 0x11;
    buffer[9] = 0x22;
    buffer[10] = 0x44;
    buffer[11] = 0x88;
    buffer[12] = 0x11;
    buffer[13] = 0x21;
    buffer[14] = 0x41;
    buffer[15] = 0x81;

    ecdaa_bintohex(buffer, 16, send);
    for(int i = 0; i < 32; i++) {
        printf("%c", send[i]);
    }
    ecdaa_hextobin(send, result, 16);

    for(int i = 0; i < 1024; i++) {
        if(buffer[i] != result[i]) {
            printf("buffer[%i] = %X, result[%i] = %X\n", i, buffer[i], i, result[i]);
        }
    }

    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(buffer, &issuer.ipk);
    int ret = ecdaa_issuer_public_key_FP256BN_deserialize(&key, buffer);
    printf("ret = %i\n",ret);
    ecdaa_bintohex(current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH, send);
    printf("%s\n", send);

    ecdaa_hextobin(send, result, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
    ret = ecdaa_issuer_public_key_FP256BN_deserialize(&key, result);
    printf("ret = %i\n",ret);

    for(int i = 0; i < 1024; i++) {
        if(buffer[i] != result[i]) {
            printf("buffer[%i] = %X, result[%i] = %X\n", i, buffer[i], i, result[i]);
        }
    }
*/
    return 0;
}

int process_issuer(char *buffer) {
    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) {
    ecdaa_rand(issuer.nonce, NONCE_SIZE);
    char* current;
    bzero(buffer, MAX_BUFSIZE);
    strncpy(buffer, "JOINSTART ", 10);
    current = &buffer[10];
    ecdaa_bintohex(issuer.nonce, NONCE_SIZE, current);
    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);
    int ret = 0;

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

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

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

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

    buffer[2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1 + 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) {
    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;
}