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
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      .idea/modules.xml
  2. 4
      CMakeLists.txt
  3. 90
      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. 108
      server.c
  13. 19
      server.h
  14. 129
      verifier.c

2
.idea/modules.xml
View File

@ -2,7 +2,7 @@
<project version="4">
<component name="ProjectModuleManager">
<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>
</component>
</project>

4
CMakeLists.txt
View File

@ -4,12 +4,12 @@ project(ecdaa_issuer C)
set(CMAKE_C_STANDARD 11)
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
${ECDAA_AMCL}
)
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
${ECDAA_AMCL}
)

90
client.c
View File

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

17
client.h
View File

@ -8,23 +8,10 @@
#include <string.h>
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
//#include <netinet/in.h>
#include <arpa/inet.h>
#include "connection.h"
#include "common.h"
#define MAX_BUFSIZE 1024
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);
int client_connect(conn_handler handler, char *ip_str, int16_t port);
#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 <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;
#include "issuer.h"
typedef enum issuer_state {
ON,
SETUPDONE,
JOINSTART,
JOINPROCEED,
PUBLISH,
READY
} 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 err = 0;
server_t *server;
server = server_open(&process_issuer, ISSUERPORT);
if (NULL == server) {
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");
if (2 != server_start(&process_issuer, ISSUERPORT)) {
printf("server failed\n");
}
}
printf("shut down server\n");
server_close(server);
return 0;
}
int process_issuer(int connfd) {
char inbuf[MAX_BUFSIZE];
char outbuf[MAX_BUFSIZE];
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);
int process_issuer(char *buffer) {
ssize_t len = 0;
int ret = 0;
printf("> ISSUER: %s\n", buffer);
if (0 == strncmp("OK", inbuf, 2)) {
switch (state) {
case SETUPDONE:
if (0 == strncasecmp("OK", buffer, 2)) {
switch (issuer.state) {
case JOINPROCEED:
case PUBLISH:
state = READY;
issuer.state = READY;
break;
default:
strncpy(outbuf, "ERR\n", 4);
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break;
}
} else if (0 == strncmp("ERR", inbuf, 3)) {
switch (state) {
case SETUPDONE:
} else if (0 == strncasecmp("ERR", buffer, 3)) {
switch (issuer.state) {
case JOINPROCEED:
case PUBLISH:
printf("command failed at client\n");
state = READY;
issuer.state = READY;
break;
default:
printf("invalid instruction\n");
strncpy(outbuf, "ERR\n", 4);
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break;
}
} else if (0 == strncmp("SETUP", inbuf, 5)) {
switch (state) {
} else if (0 == strncasecmp("SETUP", buffer, 5)) {
switch (issuer.state) {
case ON:
printf("setup()\n");
strncpy(outbuf, "SETUPDONE\n", 10);
state = SETUPDONE;
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "SETUPDONE\n", 10);
issuer.state = READY;
break;
default:
strncpy(outbuf, "ERR\n", 4);
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break;
}
} else if (0 == strncmp("JOIN", inbuf, 4)) {
switch (state) {
} else if (0 == strncasecmp("JOIN", buffer, 4)) {
switch (issuer.state) {
case READY:
printf("join()\n");
strncpy(outbuf, "JOINSTART\n", 10);
state = JOINSTART;
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "JOINSTART\n", 10);
issuer.state = JOINSTART;
break;
default:
strncpy(outbuf, "ERR\n", 4);
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break;
}
} else if (0 == strncmp("APPEND", inbuf, 6)) {
switch (state) {
} else if (0 == strncasecmp("APPEND", buffer, 6)) {
switch (issuer.state) {
case JOINSTART:
printf("append()\n");
strncpy(outbuf, "JOINPROCEED\n", 12);
state = JOINPROCEED;
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "JOINPROCEED\n", 12);
issuer.state = READY;
break;
default:
strncpy(outbuf, "ERR\n", 4);
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break;
}
} else if (0 == strncmp("PUBLISH", inbuf, 7)) {
switch (state) {
} else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
switch (issuer.state) {
case READY:
printf("publish()\n");
strncpy(outbuf, "PUBLISH\n", 8);
state = PUBLISH;
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "PUBLISH\n", 8);
issuer.state = READY;
break;
default:
strncpy(outbuf, "ERR\n", 4);
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
break;
}
} else if (0 == strncmp("EXIT", inbuf, 4)) {
} else if (0 == strncasecmp("EXIT", buffer, 4)) {
printf("exit()\n");
strncpy(outbuf, "OK\n", 3);
ret = 0;
} else if (0 == strncmp("SHUTDOWN", inbuf, 8)) {
strncpy(outbuf, "OK\n", 3);
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");
strncpy(outbuf, "ERR\n", 4);
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
ret = 0;
}
printf("< ISSUER: %s\n", outbuf);
write(connfd, outbuf, sizeof(outbuf));
}
return
ret;
printf("< ISSUER: %s", buffer);
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 "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 {
ON,
JOIN,
APPEND,
JOINPROCEED,
JOINED,
ATTEST,
PUBLISH,
SHUTDOWN
}memberstate_t;
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;
int process_member(int connfd);
int member_join(int connfd);
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;
server_t *server;
server = server_open(&process_member, MEMBERPORT);
if (NULL == server) {
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");
}
if (2 != server_start(&process_member, MEMBERPORT)) {
printf("server failed\n");
}
printf("shut down server\n");
server_close(server);
return 0;
}
int process_member(int connfd) {
char inbuf[MAX_BUFSIZE];
char outbuf[MAX_BUFSIZE];
int ret = 2;
while (ret == 2) {
bzero(inbuf, MAX_BUFSIZE);
bzero(outbuf, MAX_BUFSIZE);
int process_member(char *buffer) {
int ret = 0;
if (0 >= read(connfd, inbuf, sizeof(inbuf))) {
printf("process_member: cannot read from socket\n");
ret = -1;
}
printf("> MEMBER: %s\n", inbuf);
printf("> MEMBER: %s\n", buffer);
if (0 == strncmp("ATTEST", inbuf, 6)) {
if (0 == strncasecmp("ATTEST", buffer, 6)) {
printf("attest()\n");
strncpy(outbuf, "OK\n", 3);
}
else if (0 == strncmp("PUBLISH", inbuf, 7)) {
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ATTEST ", 7);
member_attest(buffer);
} else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
printf("publish()\n");
strncpy(outbuf, "OK\n", 3);
}
else if (0 == strncmp("JOIN", inbuf, 4)) {
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "PUBLISH ", 8);
member_publish(buffer);
} else if (0 == strncasecmp("JOIN", buffer, 4)) {
printf("join()\n");
client_t *client;
client = client_open(&member_join);
if(0 != client_connect(client, ISSUERIP, ISSUERPORT)) {
strncpy(outbuf, "ERR\n", 4);
ret = -1;
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 {
if(0 != client_close(client)) {
strncpy(outbuf, "ERR\n", 4);
bzero(buffer, MAX_BUFSIZE);
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;
}
else if (0 == strncmp("SHUTDOWN", inbuf, 8)) {
strncpy(outbuf, "OK\n", 3);
} else if (0 == strncasecmp("EXIT", buffer, 4)) {
printf("exit()\n");
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "OK\n", 3);
ret = 1;
}
else {
} else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "OK\n", 3);
ret = 2;
} else {
printf("error()\n");
strncpy(outbuf, "ERR\n", 4);
ret = -1;
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "ERR\n", 4);
ret = 0;
}
printf("< MEMBER: %s\n", outbuf);
write(connfd, outbuf, sizeof(outbuf));
}
printf("< MEMBER: %s\n", buffer);
return ret;
}
int member_join(int connfd) {
char inbuf[MAX_BUFSIZE];
char outbuf[MAX_BUFSIZE];
int n = 0;
memberstate_t state = JOIN;
int member_join(char *buffer) {
int ret = 0;
for (;;) {
switch(state) {
printf("ISSUER > MEMBER: %s", buffer);
switch (member.state) {
case JOIN:
strncpy(outbuf, "JOIN", 4);
state = APPEND;
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "JOIN\n", 5);
member.state = APPEND;
break;
case APPEND:
if (0 == strncmp("JOINSTART", inbuf, 9)) {
strncpy(outbuf, "APPEND\n", 7);
state = JOINED;
if (0 == strncasecmp("JOINSTART", buffer, 9)) {
bzero(buffer, MAX_BUFSIZE);
strncpy(buffer, "APPEND\n", 7);
member.state = JOINPROCEED;
}
break;
case JOINED:
if (0 == strncmp("JOINPROCEED", inbuf, 11)) {
strncpy(outbuf, "OK\n", 3);
return 0;
case JOINPROCEED:
if (0 == strncasecmp("JOINPROCEED", buffer, 11)) {
bzero(buffer, MAX_BUFSIZE);
member.state = JOINED;
ret = 1;
}
break;
default:
return -1;
ret -1;
}
bzero(outbuf, MAX_BUFSIZE);
printf("ISSUER < MEMBER: %s\n", outbuf);
write(connfd, outbuf, sizeof(outbuf));
bzero(inbuf, MAX_BUFSIZE);
if (0 >= read(connfd, inbuf, sizeof(inbuf))) {
printf("process_issuer: cannot read from socket\n");
return -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;
}

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

108
server.c
View File

@ -1,73 +1,85 @@
#include "server.h"
server_t *server_open(conn_handler handler, int16_t port) {
int server_open(int16_t port) {
struct sockaddr_in servaddr;
server_t *server = malloc(sizeof(server_t));
if(NULL == handler) {
printf("server_open: received empty handler, stopping");
return NULL;
}
if (NULL == server) {
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;
int connfd = 0;
connfd = socket(AF_INET, SOCK_STREAM, 0);
if (-1 == connfd) {
printf("server_open: failed to create endpoint.\n");
return -1;
}
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(port);
if (0 != bind(server->conn->fd, (const struct sockaddr *) &servaddr, sizeof(servaddr))) {
printf("server_listen: failed to bind socket\n");
return NULL;
if (0 != bind(connfd, (const struct sockaddr *) &servaddr, sizeof(servaddr))) {
printf("server_open: failed to bind socket\n");
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;
unsigned int client_len = 0;
int connfd = -1;
int ret = 0;
int connfd = 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)) {
printf("server_accept: listen failed\n");
if(NULL == handler) {
printf("server_start: received empty handler, stopping\n");
return -1;
}
printf("server_accept: listening\n");
client_len = sizeof(client);
connfd = accept(server->conn->fd, (struct sockaddr *) &client, &client_len);
if(0 >= connfd) {
printf("server_accept: connection to client failed, ");
connfd = server_open(port);
if(-1 == connfd) {
printf("server_start: could not open port, stopping\n");
return -1;
} else {
ret = server->handler(connfd);
if(0 != close(connfd)) {
printf("server_accept: failed to close client connection properly");
}
if (0 != listen(connfd, MAX_CLIENTS)) {
printf("server_start: listen failed, stopping\n");
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;
if (0 <= ret && 0 >= write(clientfd, buffer, sizeof(buffer))) {
printf("server_start: cannot write to socket\n");
ret = -1;
}
int server_close(server_t *server) {
int err = 0;
if (NULL == server) {
return 0;
}
if (0 != connection_destroy(server->conn)) {
printf("server_close: closing socket failed\n");
err = -1;
if (0 != close(clientfd)) {
printf("server_start: failed to close client connection properly\n");
ret = -1;
}
free(server);
return err;
}
}
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
#define ECDAA_ISSUER_SERVER_H
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include "connection.h"
#include "common.h"
#define MAX_CLIENTS 10
#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);
int server_start(conn_handler handler, int16_t port);
#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