preisacm
/
masterthesis-ecdaa-network-wrapper
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

network protocol skeleton of issuer and member finished, missing verifier

master
root 6 years ago
parent
05167ba440
commit
d3ddf576bc
14 changed files with 497 additions and 427 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      .idea/modules.xml
  2. 4
      CMakeLists.txt
  3. 92
      client.c
  4. 17
      client.h
  5. 21
      common.h
  6. 29
      connection.c
  7. 26
      connection.h
  8. 159
      issuer.c
  9. 16
      issuer.h
  10. 182
      member.c
  11. 16
      member.h
  12. 110
      server.c
  13. 19
      server.h
  14. 129
      verifier.c

2
.idea/modules.xml
View File

@ -2,7 +2,7 @@
<project version="4"> <project version="4">
<component name="ProjectModuleManager"> <component name="ProjectModuleManager">
<modules> <modules>
<module fileurl="file://$PROJECT_DIR$/.idea/ecdaa_issuer.iml" filepath="$PROJECT_DIR$/.idea/ecdaa_issuer.iml" /> <module fileurl="file://$PROJECT_DIR$/../ecdaa_net/.idea/ecdaa_issuer.iml" filepath="$PROJECT_DIR$/../ecdaa_net/.idea/ecdaa_issuer.iml" />
</modules> </modules>
</component> </component>
</project> </project>

4
CMakeLists.txt
View File

@ -4,12 +4,12 @@ project(ecdaa_issuer C)
set(CMAKE_C_STANDARD 11) set(CMAKE_C_STANDARD 11)
set(ECDAA_AMCL "/opt/amcl") set(ECDAA_AMCL "/opt/amcl")
add_executable(ecdaa_issuer issuer.c connection.h connection.c server.h server.c) add_executable(ecdaa_issuer issuer.c common.h server.h server.c)
target_include_directories(ecdaa_issuer PUBLIC target_include_directories(ecdaa_issuer PUBLIC
${ECDAA_AMCL} ${ECDAA_AMCL}
) )
target_link_libraries(ecdaa_issuer /usr/local/lib/libecdaa.so) target_link_libraries(ecdaa_issuer /usr/local/lib/libecdaa.so)
add_executable(ecdaa_member member.c connection.h connection.c client.h client.c server.h server.c) add_executable(ecdaa_member member.c common.h client.h client.c server.h server.c issuer.h)
target_include_directories(ecdaa_member PUBLIC target_include_directories(ecdaa_member PUBLIC
${ECDAA_AMCL} ${ECDAA_AMCL}
) )

92
client.c
View File

@ -1,61 +1,67 @@
#include "client.h" #include "client.h"
client_t* client_open(conn_handler handler) { int client_open(char *servip, int16_t port) {
struct sockaddr_in servaddr; struct sockaddr_in servaddr;
client_t *client = malloc(sizeof(client_t)); size_t servaddr_len = 0;
if(NULL == handler) { int connfd = 0;
printf("client_open: received empty handler, stopping");
return NULL;
}
if (NULL == client) {
printf("client_open: malloc failed");
return NULL;
}
client->conn = connection_create(CONN_TYPE_CLIENT);
if (NULL == client->conn) {
free(client);
return NULL;
}
client->handler = handler;
client->conn->fd = socket(AF_INET, SOCK_STREAM, 0);
if (-1 == client->conn->fd) {
printf("client_listen: failed to create endpoint.\n");
return NULL;
}
return client;
}
int client_connect(client_t *client, char *ip_str, int16_t port) { connfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in servaddr; if (-1 == connfd) {
unsigned int servaddr_len = 0; printf("client_listen: failed to create endpoint.\n");
if(client == NULL) {
return -1; return -1;
} }
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET; servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(ip_str); servaddr.sin_addr.s_addr = inet_addr(servip);
servaddr.sin_port = htons(port); servaddr.sin_port = htons(port);
servaddr_len = sizeof(servaddr); servaddr_len = sizeof(servaddr);
if(0 >= connect(client->conn->fd, (const struct sockaddr *) &servaddr, servaddr_len)) { if (0 != connect(connfd, (const struct sockaddr *) &servaddr, servaddr_len)) {
printf("client_accept: connection to server failed\n"); printf("client_accept: connection to server failed\n");
close(connfd);
return -1; return -1;
} else {
client->handler(client->conn->fd);
} }
return 0; return connfd;
} }
int client_close(client_t *client) { int client_connect(conn_handler handler, char *servip, int16_t port) {
int err = 0; struct sockaddr_in servaddr;
if (NULL == client) { unsigned int servaddr_len = 0;
return 0; int connfd = 0;
char buffer[MAX_BUFSIZE];
int ret = 0;
int len = 0;
connfd = client_open(servip, port);
if(0 >= connfd) {
return -1;
} }
if (0 != connection_destroy(client->conn)) { bzero(buffer, MAX_BUFSIZE);
printf("client_close: closing socket failed\n"); for (ret = 0; 0 == ret;) {
err = -1; ret = handler(buffer);
if(0 != ret)
break;
if (0 >= write(connfd, buffer, sizeof(buffer))) {
printf("client_connect: cannot write to socket\n");
ret = -1;
} }
free(client);
return err; bzero(buffer, MAX_BUFSIZE);
len = read(connfd, buffer, sizeof(buffer));
if (0 > len) {
printf("client_connect: cannot read from socket\n");
ret = -1;
} else if (0 == len) {
printf("client_connect: server closed connection\n");
ret = 1;
}
}
if (0 != close(connfd)) {
printf("client_connect: failed to close server connection properly\n");
ret = -1;
}
return ret;
} }

17
client.h
View File

@ -8,23 +8,10 @@
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h> #include <unistd.h>
//#include <netinet/in.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include "connection.h" #include "common.h"
#define MAX_BUFSIZE 1024 int client_connect(conn_handler handler, char *ip_str, int16_t port);
typedef struct client {
connection_t* conn;
conn_handler handler;
}client_t;
client_t* client_open(conn_handler handler);
int client_connect(client_t *client, char *ip_str, int16_t port);
int client_close(client_t* client);
#endif //ECDAA_ISSUER_CLIENT_H #endif //ECDAA_ISSUER_CLIENT_H

21
common.h
View File

@ -0,0 +1,21 @@
//
// Created by root on 10/30/19.
//
#ifndef ECDAA_ISSUER_COMMON_H
#define ECDAA_ISSUER_COMMON_H
#define ISSUERIP "127.0.0.1"
#define ISSUERPORT 6590
#define MEMBERIP "127.0.0.1"
#define MEMBERPORT 6591
#define VERIFIERIP "127.0.0.1"
#define VERIFIERPORT 6592
#define MAX_CLIENTS 10
#define MAX_BUFSIZE 1024
typedef int (*conn_handler)(char* buffer);
#endif //ECDAA_ISSUER_COMMON_H

29
connection.c
View File

@ -1,29 +0,0 @@
#include <unistd.h>
#include "connection.h"
connection_t* connection_create(conntype_e type){
connection_t* conn = malloc(sizeof(connection_t));
if(NULL == conn) {
printf("connection_create: malloc failed\n");
} else {
conn->type = type;
conn->fd = -1;
}
return conn;
}
int connection_destroy(connection_t* conn) {
int err = 0;
if(NULL != conn) {
if(-1 != conn->fd) {
err = close(conn->fd);
if(-1 == err) {
printf("connection_destroy: close connection failed");
}
}
free(conn);
}
return err;
}

26
connection.h
View File

@ -1,26 +0,0 @@
//
// Created by root on 10/30/19.
//
#ifndef ECDAA_ISSUER_CONNECTION_H
#define ECDAA_ISSUER_CONNECTION_H
#include <stdio.h>
#include <stdlib.h>
typedef enum conntype {
CONN_TYPE_SERVER,
CONN_TYPE_CLIENT
}conntype_e;
typedef struct connection {
int fd;
conntype_e type;
} connection_t;
typedef int (*conn_handler)(int fd);
connection_t* connection_create(conntype_e type);
int connection_destroy(connection_t* conn);
#endif //ECDAA_ISSUER_CONNECTION_H

159
issuer.c
View File

@ -1,156 +1,125 @@
#include <stdio.h> #include "issuer.h"
#include <string.h>
#include <ecdaa.h>
#include "server.h"
#include "client.h"
#define ISSUERIP "127.0.0.1"
#define ISSUERPORT 6590
#define MEMBERIP "127.0.0.1"
#define MEMBERPORT 6591
#define VERIFIERIP "127.0.0.1"
#define VERIFIERPORT 6592
typedef struct issuer {
struct ecdaa_issuer_public_key_FP256BN ipk;
struct ecdaa_issuer_secret_key_FP256BN isk;
} issuer_t;
typedef enum issuer_state { typedef enum issuer_state {
ON, ON,
SETUPDONE,
JOINSTART, JOINSTART,
JOINPROCEED, JOINPROCEED,
PUBLISH,
READY READY
} issuerstate_e; } issuerstate_e;
int process_issuer(int connfd); typedef struct issuer {
struct ecdaa_issuer_public_key_FP256BN ipk;
struct ecdaa_issuer_secret_key_FP256BN isk;
issuerstate_e state;
} issuer_t;
issuer_t issuer;
int main() { int main() {
int err = 0; int err = 0;
server_t *server;
server = server_open(&process_issuer, ISSUERPORT);
if (NULL == server) {
printf("listen failed, closing...\n");
}
for (; !err;) { if (2 != server_start(&process_issuer, ISSUERPORT)) {
err = server_accept(server); printf("server failed\n");
if (1 == err) {
printf("graceful shutdown...\n");
} else if (err) {
printf("accept failed, closing...\n");
} }
}
printf("shut down server\n");
server_close(server);
return 0; return 0;
} }
int process_issuer(int connfd) { int process_issuer(char *buffer) {
char inbuf[MAX_BUFSIZE]; ssize_t len = 0;
char outbuf[MAX_BUFSIZE]; int ret = 0;
int ret = 2;
issuerstate_e state = ON;
while (ret == 2) {
bzero(inbuf, MAX_BUFSIZE);
bzero(outbuf, MAX_BUFSIZE);
if (0 >= read(connfd, inbuf, sizeof(inbuf))) {
printf("process_member: cannot read from socket\n");
ret = -1;
}
printf("> ISSUER: %s\n", inbuf);
printf("> ISSUER: %s\n", buffer);
if (0 == strncmp("OK", inbuf, 2)) { if (0 == strncasecmp("OK", buffer, 2)) {
switch (state) { switch (issuer.state) {
case SETUPDONE:
case JOINPROCEED: case JOINPROCEED:
case PUBLISH: issuer.state = READY;
state = READY;
break; break;
default: default:
strncpy(outbuf, "ERR\n", 4); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break; break;
} }
} else if (0 == strncmp("ERR", inbuf, 3)) { } else if (0 == strncasecmp("ERR", buffer, 3)) {
switch (state) { switch (issuer.state) {
case SETUPDONE:
case JOINPROCEED: case JOINPROCEED:
case PUBLISH:
printf("command failed at client\n"); printf("command failed at client\n");
state = READY; issuer.state = READY;
break; break;
default: default:
printf("invalid instruction\n"); bzero(buffer, MAX_BUFSIZE);
strncpy(outbuf, "ERR\n", 4); strncpy(buffer, "ERR\n", 4);
break; break;
} }
} else if (0 == strncmp("SETUP", inbuf, 5)) { } else if (0 == strncasecmp("SETUP", buffer, 5)) {
switch (state) { switch (issuer.state) {
case ON: case ON:
printf("setup()\n"); printf("setup()\n");
strncpy(outbuf, "SETUPDONE\n", 10); bzero(buffer, MAX_BUFSIZE);
state = SETUPDONE; strncpy(buffer, "SETUPDONE\n", 10);
issuer.state = READY;
break; break;
default: default:
strncpy(outbuf, "ERR\n", 4); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break; break;
} }
} else if (0 == strncmp("JOIN", inbuf, 4)) { } else if (0 == strncasecmp("JOIN", buffer, 4)) {
switch (state) { switch (issuer.state) {
case READY: case READY:
printf("join()\n"); printf("join()\n");
strncpy(outbuf, "JOINSTART\n", 10); bzero(buffer, MAX_BUFSIZE);
state = JOINSTART; strncpy(buffer, "JOINSTART\n", 10);
issuer.state = JOINSTART;
break; break;
default: default:
strncpy(outbuf, "ERR\n", 4); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break; break;
} }
} else if (0 == strncmp("APPEND", inbuf, 6)) { } else if (0 == strncasecmp("APPEND", buffer, 6)) {
switch (state) { switch (issuer.state) {
case JOINSTART: case JOINSTART:
printf("append()\n"); printf("append()\n");
strncpy(outbuf, "JOINPROCEED\n", 12); bzero(buffer, MAX_BUFSIZE);
state = JOINPROCEED; strncpy(buffer, "JOINPROCEED\n", 12);
issuer.state = READY;
break; break;
default: default:
strncpy(outbuf, "ERR\n", 4); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break; break;
} }
} else if (0 == strncmp("PUBLISH", inbuf, 7)) { } else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
switch (state) { switch (issuer.state) {
case READY: case READY:
printf("publish()\n"); printf("publish()\n");
strncpy(outbuf, "PUBLISH\n", 8); bzero(buffer, MAX_BUFSIZE);
state = PUBLISH; strncpy(buffer, "PUBLISH\n", 8);
issuer.state = READY;
break; break;
default: default:
strncpy(outbuf, "ERR\n", 4); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break; break;
} }
} else if (0 == strncmp("EXIT", inbuf, 4)) { } else if (0 == strncasecmp("EXIT", buffer, 4)) {
printf("exit()\n"); printf("exit()\n");
strncpy(outbuf, "OK\n", 3); bzero(buffer, MAX_BUFSIZE);
ret = 0; strncpy(buffer, "OK\n", 3);
} else if (0 == strncmp("SHUTDOWN", inbuf, 8)) {
strncpy(outbuf, "OK\n", 3);
ret = 1; ret = 1;
} else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "OK\n", 3);
ret = 2;
} else { } else {
printf("error()\n"); printf("error()\n");
strncpy(outbuf, "ERR\n", 4); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
ret = 0; ret = 0;
} }
printf("< ISSUER: %s\n", outbuf); printf("< ISSUER: %s", buffer);
write(connfd, outbuf, sizeof(outbuf)); return ret;
}
return
ret;
} }

16
issuer.h
View File

@ -0,0 +1,16 @@
//
// Created by root on 11/5/19.
//
#ifndef ECDAA_ISSUER_ISSUER_H
#define ECDAA_ISSUER_ISSUER_H
#include <stdio.h>
#include <string.h>
#include <ecdaa.h>
#include "server.h"
#include "client.h"
#include "common.h"
int process_issuer(char *buffer);
#endif //ECDAA_ISSUER_ISSUER_H

182
member.c
View File

@ -4,148 +4,126 @@
#include "client.h" #include "client.h"
#include "server.h" #include "server.h"
#define ISSUERIP "127.0.0.1"
#define ISSUERPORT 6590
#define MEMBERIP "127.0.0.1"
#define MEMBERPORT 6591
#define VERIFIERIP "127.0.0.1"
#define VERIFIERPORT 6592
typedef struct member {
struct ecdaa_member_public_key_FP256BN mpk;
} member_t;
typedef enum memberstate { typedef enum memberstate {
ON, ON,
JOIN, JOIN,
APPEND, APPEND,
JOINPROCEED,
JOINED, JOINED,
ATTEST, ATTEST,
PUBLISH, PUBLISH
SHUTDOWN } memberstate_e;
}memberstate_t;
typedef struct member {
struct ecdaa_member_public_key_FP256BN mpk;
struct ecdaa_member_public_key_FP256BN msk;
memberstate_e state;
} member_t;
int process_member(int connfd); member_t member;
int member_join(int connfd);
int process_member(char *buffer);
int member_join(char* buffer);
int member_attest(char* buffer);
int member_publish(char* buffer);
int main() { int main() {
int err = 0; int err = 0;
server_t *server;
server = server_open(&process_member, MEMBERPORT); if (2 != server_start(&process_member, MEMBERPORT)) {
if (NULL == server) { printf("server failed\n");
printf("listen failed, closing...\n");
}
for (; !err;) {
err = server_accept(server);
if (1 == err) {
printf("graceful shutdown...\n");
} else if (err) {
printf("accept failed, closing...\n");
}
} }
printf("shut down server\n");
server_close(server);
return 0; return 0;
} }
int process_member(int connfd) { int process_member(char *buffer) {
char inbuf[MAX_BUFSIZE]; int ret = 0;
char outbuf[MAX_BUFSIZE];
int ret = 2;
while (ret == 2) {
bzero(inbuf, MAX_BUFSIZE);
bzero(outbuf, MAX_BUFSIZE);
if (0 >= read(connfd, inbuf, sizeof(inbuf))) { printf("> MEMBER: %s\n", buffer);
printf("process_member: cannot read from socket\n");
ret = -1;
}
printf("> MEMBER: %s\n", inbuf);
if (0 == strncmp("ATTEST", inbuf, 6)) { if (0 == strncasecmp("ATTEST", buffer, 6)) {
printf("attest()\n"); printf("attest()\n");
strncpy(outbuf, "OK\n", 3); bzero(buffer, MAX_BUFSIZE);
} strncpy(buffer, "ATTEST ", 7);
else if (0 == strncmp("PUBLISH", inbuf, 7)) { member_attest(buffer);
} else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
printf("publish()\n"); printf("publish()\n");
strncpy(outbuf, "OK\n", 3); bzero(buffer, MAX_BUFSIZE);
} strncpy(buffer, "PUBLISH ", 8);
else if (0 == strncmp("JOIN", inbuf, 4)) { member_publish(buffer);
} else if (0 == strncasecmp("JOIN", buffer, 4)) {
printf("join()\n"); printf("join()\n");
client_t *client; member.state = JOIN;
client = client_open(&member_join); ret = client_connect(&member_join, ISSUERIP, ISSUERPORT);
if(0 != client_connect(client, ISSUERIP, ISSUERPORT)) { if (0 >= ret || JOINED != member.state) {
strncpy(outbuf, "ERR\n", 4); printf("process_member: issuer connection failed\n");
ret = -1; bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
} else { } else {
if(0 != client_close(client)) { bzero(buffer, MAX_BUFSIZE);
strncpy(outbuf, "ERR\n", 4); strncpy(buffer, "OK\n", 3);
} }
strncpy(outbuf, "OK\n", 3);
}
}
else if (0 == strncmp("EXIT", inbuf, 4)) {
printf("exit()\n");
strncpy(outbuf, "OK\n", 3);
ret = 0; ret = 0;
} } else if (0 == strncasecmp("EXIT", buffer, 4)) {
else if (0 == strncmp("SHUTDOWN", inbuf, 8)) { printf("exit()\n");
strncpy(outbuf, "OK\n", 3); bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "OK\n", 3);
ret = 1; ret = 1;
} } else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
else { bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "OK\n", 3);
ret = 2;
} else {
printf("error()\n"); printf("error()\n");
strncpy(outbuf, "ERR\n", 4); bzero(buffer, MAX_BUFSIZE);
ret = -1; strncpy(buffer, "ERR\n", 4);
ret = 0;
} }
printf("< MEMBER: %s\n", outbuf); printf("< MEMBER: %s\n", buffer);
write(connfd, outbuf, sizeof(outbuf));
}
return ret; return ret;
} }
int member_join(int connfd) { int member_join(char *buffer) {
char inbuf[MAX_BUFSIZE]; int ret = 0;
char outbuf[MAX_BUFSIZE];
int n = 0;
memberstate_t state = JOIN;
for (;;) { printf("ISSUER > MEMBER: %s", buffer);
switch(state) { switch (member.state) {
case JOIN: case JOIN:
strncpy(outbuf, "JOIN", 4); bzero(buffer, MAX_BUFSIZE);
state = APPEND; strncpy(buffer, "JOIN\n", 5);
member.state = APPEND;
break; break;
case APPEND: case APPEND:
if (0 == strncmp("JOINSTART", inbuf, 9)) { if (0 == strncasecmp("JOINSTART", buffer, 9)) {
strncpy(outbuf, "APPEND\n", 7); bzero(buffer, MAX_BUFSIZE);
state = JOINED; strncpy(buffer, "APPEND\n", 7);
member.state = JOINPROCEED;
} }
break; break;
case JOINED: case JOINPROCEED:
if (0 == strncmp("JOINPROCEED", inbuf, 11)) { if (0 == strncasecmp("JOINPROCEED", buffer, 11)) {
strncpy(outbuf, "OK\n", 3); bzero(buffer, MAX_BUFSIZE);
return 0; member.state = JOINED;
ret = 1;
} }
break; break;
default: default:
return -1; ret -1;
}
if(0 == ret) {
printf("ISSUER < MEMBER: %s", buffer);
} }
return ret;
}
bzero(outbuf, MAX_BUFSIZE); int member_attest(char* buffer) {
printf("ISSUER < MEMBER: %s\n", outbuf); strncat(buffer, "<attestval>\n", 13);
write(connfd, outbuf, sizeof(outbuf)); return 0;
}
bzero(inbuf, MAX_BUFSIZE); int member_publish(char* buffer) {
if (0 >= read(connfd, inbuf, sizeof(inbuf))) { strncat(buffer, "<publicval>\n", 12);
printf("process_issuer: cannot read from socket\n"); return 0;
return -1;
}
}
} }

16
member.h
View File

@ -0,0 +1,16 @@
//
// Created by root on 11/5/19.
//
#ifndef ECDAA_ISSUER_MEMBER_H
#define ECDAA_ISSUER_MEMBER_H
#include <stdio.h>
#include <string.h>
#include <ecdaa.h>
#include "server.h"
#include "client.h"
#include "common.h"
int process_member(char *buffer);
#endif //ECDAA_ISSUER_ISSUER_H

110
server.c
View File

@ -1,73 +1,85 @@
#include "server.h" #include "server.h"
server_t *server_open(conn_handler handler, int16_t port) { int server_open(int16_t port) {
struct sockaddr_in servaddr; struct sockaddr_in servaddr;
server_t *server = malloc(sizeof(server_t)); int connfd = 0;
if(NULL == handler) {
printf("server_open: received empty handler, stopping"); connfd = socket(AF_INET, SOCK_STREAM, 0);
return NULL; if (-1 == connfd) {
} printf("server_open: failed to create endpoint.\n");
if (NULL == server) { return -1;
printf("server_open: malloc failed");
return NULL;
}
server->conn = connection_create(CONN_TYPE_SERVER);
if (NULL == server->conn) {
free(server);
return NULL;
}
server->handler = handler;
server->conn->fd = socket(AF_INET, SOCK_STREAM, 0);
if (-1 == server->conn->fd) {
printf("server_listen: failed to create endpoint.\n");
return NULL;
} }
servaddr.sin_family = AF_INET; servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(port); servaddr.sin_port = htons(port);
if (0 != bind(server->conn->fd, (const struct sockaddr *) &servaddr, sizeof(servaddr))) { if (0 != bind(connfd, (const struct sockaddr *) &servaddr, sizeof(servaddr))) {
printf("server_listen: failed to bind socket\n"); printf("server_open: failed to bind socket\n");
return NULL; close(connfd);
return -1;
} }
return server; return connfd;
} }
int server_accept(server_t *server) { int server_start(conn_handler handler, int16_t port) {
struct sockaddr_in client; struct sockaddr_in client;
unsigned int client_len = 0; unsigned int client_len = 0;
int connfd = -1; int connfd = 0;
int ret = 0; int clientfd = 0;
int len = 0;
int ret = 0; //<0 .. failure, 0 .. continue, 1 .. exit, 2 .. shutdown
char buffer[MAX_BUFSIZE];
if (NULL == server || 0 != listen(server->conn->fd, MAX_CLIENTS)) { if(NULL == handler) {
printf("server_accept: listen failed\n"); printf("server_start: received empty handler, stopping\n");
return -1; return -1;
} }
printf("server_accept: listening\n"); connfd = server_open(port);
client_len = sizeof(client); if(-1 == connfd) {
connfd = accept(server->conn->fd, (struct sockaddr *) &client, &client_len); printf("server_start: could not open port, stopping\n");
if(0 >= connfd) {
printf("server_accept: connection to client failed, ");
return -1; return -1;
} else { }
ret = server->handler(connfd); if (0 != listen(connfd, MAX_CLIENTS)) {
if(0 != close(connfd)) { printf("server_start: listen failed, stopping\n");
printf("server_accept: failed to close client connection properly");
return -1; return -1;
} }
printf("server_start: listening\n");
for(ret = 1; 1 == ret;) {
client_len = sizeof(client);
clientfd = accept(connfd, (struct sockaddr *) &client, &client_len);
if (0 >= clientfd) {
printf("server_start: connection to client failed\n");
ret = -1;
} else {
for(ret = 0; 0 == ret;) {
bzero(buffer, MAX_BUFSIZE);
len = read(clientfd, buffer, sizeof(buffer));
if (0 > len) {
printf("server_start: cannot read from socket\n");
ret = -1;
} else if(0 == len) {
printf("server_start: client closed connection\n");
ret = 1;
} else {
ret = handler(buffer);
} }
return ret;
}
int server_close(server_t *server) { if (0 <= ret && 0 >= write(clientfd, buffer, sizeof(buffer))) {
int err = 0; printf("server_start: cannot write to socket\n");
if (NULL == server) { ret = -1;
return 0;
} }
if (0 != connection_destroy(server->conn)) {
printf("server_close: closing socket failed\n");
err = -1;
} }
free(server); if (0 != close(clientfd)) {
return err; printf("server_start: failed to close client connection properly\n");
ret = -1;
}
}
}
printf("server_start: closing connection\n");
if (0 != close(connfd)) {
printf("server_start: failed to close server port properly\n");
ret = -1;
}
return ret;
} }

19
server.h
View File

@ -4,23 +4,14 @@
#ifndef ECDAA_ISSUER_SERVER_H #ifndef ECDAA_ISSUER_SERVER_H
#define ECDAA_ISSUER_SERVER_H #define ECDAA_ISSUER_SERVER_H
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <unistd.h> #include <unistd.h>
#include "connection.h" #include "common.h"
#define MAX_CLIENTS 10 int server_start(conn_handler handler, int16_t port);
#define MAX_BUFSIZE 1024
typedef struct server {
connection_t* conn;
conn_handler handler;
}server_t;
server_t *server_open(conn_handler handler, int16_t port);
int server_accept(server_t *server);
int server_close(server_t* server);
#endif //ECDAA_ISSUER_SERVER_H #endif //ECDAA_ISSUER_SERVER_H

129
verifier.c
View File

@ -0,0 +1,129 @@
#include <stdio.h>
#include <string.h>
#include <ecdaa-tpm.h>
#include "client.h"
#include "server.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_public_key_FP256BN msk;
memberstate_e state;
} member_t;
member_t member;
int process_member(char *buffer);
int member_join(char* buffer);
int member_attest(char* buffer);
int member_publish(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 (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)) {
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "APPEND\n", 7);
member.state = JOINPROCEED;
}
break;
case JOINPROCEED:
if (0 == strncasecmp("JOINPROCEED", buffer, 11)) {
bzero(buffer, MAX_BUFSIZE);
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;
}
int member_publish(char* buffer) {
strncat(buffer, "<publicval>\n", 12);
return 0;
}
Write Preview
Loading…
Cancel
Save