static void server_function(void)
{
uint8_t recv_buf[2048];
ssize_t bytes_received;
if (current_length > 0) {
bytes_received = secure_session_receive((server.session), recv_buf, sizeof(recv_buf));
} else {
/* Nothing to receive. Do nothing */
return;
}
if (bytes_received < 0) {
testsuite_fail_if(bytes_received, "secure_session_receive failed");
return;
}
size_t remote_id_length = 0;
if (THEMIS_BUFFER_TOO_SMALL
!= secure_session_get_remote_id(server.session, NULL, &remote_id_length)) {
testsuite_fail_if(true, "remote id getting failed (length_determination)");
return;
}
uint8_t* remote_id = malloc(remote_id_length);
assert(remote_id);
if (THEMIS_SUCCESS != secure_session_get_remote_id(server.session, remote_id, &remote_id_length)) {
testsuite_fail_if(true, "remote id getting failed");
free(remote_id);
return;
}
testsuite_fail_unless(remote_id_length == strlen(client.id)
&& 0 == memcmp(remote_id, client.id, strlen(client.id)),
"secure_session remote id getting");
free(remote_id);
if (0 == bytes_received) {
/* This was a key agreement packet. Nothing to do */
return;
}
if (bytes_received > 0) {
/* We received some data. Echo it back to the client. */
ssize_t bytes_sent = secure_session_send((server.session), recv_buf, (size_t)bytes_received);
if (bytes_sent == bytes_received) {
/* Check whether data was indeed encrypted (it should not be the same as in
* data_to_send) */
testsuite_fail_if(((size_t)bytes_sent == current_length)
|| (!memcmp(recv_buf, shared_mem, bytes_sent)),
"secure_session server message wrap");
} else {
testsuite_fail_if(true, "secure_session_send failed");
}
}
}
void send(const data_t& data){
ssize_t send_size=secure_session_send(_session, &data[0], data.size());
if(send_size<=0)
throw themispp::exception_t("Secure Session failed sending");
}
void* run_client(void *arg)
{
struct sockaddr_un addr = {0};
themis_status_t status;
int count = 10;
ssize_t bytes_sent;
addr.sun_family = AF_UNIX;
memcpy(addr.sun_path, SOCKET_NAME, strlen(SOCKET_NAME) + 1);
client.sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (-1 == client.sock)
{
return NULL;
}
//unlink(SOCKET_NAME);
status = secure_session_init(&(client.ctx), CLIENT_ID, strlen(CLIENT_ID), client_priv, sizeof(client_priv), &clb);
if (HERMES_SUCCESS != status)
{
return NULL;
}
if (-1 == connect(client.sock, (const struct sockaddr *)&addr, sizeof(addr)))
{
return NULL;
}
status = secure_session_connect(&(client.ctx));
if (HERMES_SUCCESS != status)
{
return NULL;
}
while (count)
{
uint8_t buffer[BUF_SIZE];
ssize_t bytes_received;
const char *message = "This is a test message";
bytes_sent = secure_session_send(&(client.ctx), message, strlen(message));
if (bytes_sent < 0)
{
/* Some error, log and continue */
printf("client send %d %d\n", __LINE__, (int)bytes_sent);
}
/* Wait for response */
bytes_received = secure_session_receive(&(client.ctx), buffer, sizeof(buffer));
if (bytes_received < 0)
{
/* Some error, log and continue */
printf("client receive %d %d\n", __LINE__, (int)bytes_received);
continue;
}
if (bytes_received > 0)
{
if (!memcmp(message, buffer, strlen(message)))
{
puts("client receive valid response");
}
count--;
}
}
/* send "finish" message to server */
bytes_sent = secure_session_send(&(client.ctx), "finish", strlen("finish"));
if (bytes_sent < 0)
{
/* Some error, log and continue */
printf("client send %d %d\n", __LINE__, (int)bytes_sent);
}
close(client.sock);
return NULL;
}
void* run_server(void *arg)
{
struct sockaddr_un addr = {0};
themis_status_t status;
addr.sun_family = AF_UNIX;
memcpy(addr.sun_path, SOCKET_NAME, strlen(SOCKET_NAME) + 1);
server.listen_socket = socket(AF_UNIX, SOCK_STREAM, 0);
if (-1 == server.listen_socket)
{
return NULL;
}
//unlink(SOCKET_NAME);
if (-1 == bind(server.listen_socket, (const struct sockaddr *)&addr, sizeof(addr)))
{
close(server.listen_socket);
return NULL;
}
if (-1 == listen(server.listen_socket, 5))
{
close(server.listen_socket);
return NULL;
}
status = secure_session_init(&(server.ctx), SERVER_ID, strlen(SERVER_ID), server_priv, sizeof(server_priv), &clb);
if (HERMES_SUCCESS != status)
{
return NULL;
}
server.client_socket = accept(server.listen_socket, NULL, NULL);
if (-1 == server.client_socket)
{
close(server.listen_socket);
return NULL;
}
while (1)
{
uint8_t buffer[BUF_SIZE];
ssize_t bytes_received = secure_session_receive(&(server.ctx), buffer, sizeof(buffer));
ssize_t bytes_sent;
if (bytes_received < 0)
{
/* Some error, log and continue */
printf("server receive %d %d\n", __LINE__, (int)bytes_received);
continue;
}
if (bytes_received > 0)
{
/* If we received "finish", then client disconnected */
if (!memcmp(buffer, "finish", bytes_received < strlen("finish") ? bytes_received : strlen("finish")))
{
puts("server receive finish");
break;
}
/* For other messages, just echo them back */
bytes_sent = secure_session_send(&(server.ctx), buffer, bytes_received);
if (bytes_sent < 0)
{
/* Some error, log and continue */
printf("server send %d %d\n", __LINE__, (int)bytes_sent);
}
}
}
close(server.client_socket);
close(server.listen_socket);
return NULL;
}
static int client_function(void)
{
static bool connected = false;
themis_status_t res;
uint8_t recv_buf[2048];
ssize_t bytes_received;
ssize_t bytes_sent;
/* Client is not connected yet. Initiate key agreement */
if (!connected) {
res = secure_session_connect((client.session));
if (THEMIS_SUCCESS == res) {
connected = true;
return TEST_CONTINUE;
}
testsuite_fail_if(res, "secure_session_connect failed");
return TEST_STOP_ERROR;
}
if (secure_session_is_established(client.session)) {
size_t remote_id_length = 0;
if (THEMIS_BUFFER_TOO_SMALL
!= secure_session_get_remote_id(client.session, NULL, &remote_id_length)) {
testsuite_fail_if(true, "remote id getting failed (length_determination)");
return TEST_STOP_ERROR;
}
uint8_t* remote_id = malloc(remote_id_length);
assert(remote_id);
if (THEMIS_SUCCESS
!= secure_session_get_remote_id(client.session, remote_id, &remote_id_length)) {
testsuite_fail_if(true, "remote id getting failed");
free(remote_id);
return TEST_STOP_ERROR;
}
testsuite_fail_unless(remote_id_length == strlen(server.id)
&& 0 == memcmp(remote_id, server.id, strlen(server.id)),
"secure_session remote id getting");
free(remote_id);
static int messages_to_send = MESSAGES_TO_SEND;
/* Connection is already established. */
static uint8_t data_to_send[MAX_MESSAGE_SIZE];
static size_t length_to_send;
/* If there is anything to receive, receive it */
if (current_length) {
bytes_received = secure_session_receive(client.session, recv_buf, sizeof(recv_buf));
if (bytes_received > 0) {
/* The server should echo our previously sent data */
testsuite_fail_unless((length_to_send == (size_t)bytes_received)
&& (!memcmp(recv_buf, data_to_send, bytes_received)),
"secure_session message send/receive");
messages_to_send--;
if (!messages_to_send) {
return TEST_STOP_SUCCESS;
}
} else {
/* We shoud receive something. */
testsuite_fail_if(bytes_received, "secure_session_receive failed");
return TEST_STOP_ERROR;
}
}
length_to_send = rand_int(MAX_MESSAGE_SIZE);
if (THEMIS_SUCCESS != soter_rand(data_to_send, length_to_send)) {
testsuite_fail_if(true, "soter_rand failed");
return TEST_STOP_ERROR;
}
bytes_sent = secure_session_send((client.session), data_to_send, length_to_send);
if (bytes_sent > 0) {
/* Check whether data was indeed encrypted (it should not be the same as in
* data_to_send) */
testsuite_fail_if((length_to_send == current_length)
|| (!memcmp(data_to_send, shared_mem, length_to_send)),
"secure_session client message wrap");
return TEST_CONTINUE;
}
testsuite_fail_if(true, "secure_session_send failed");
return TEST_STOP_ERROR;
}
/* Connection is not established. We should receive some key agreement data. */
bytes_received = secure_session_receive((client.session), recv_buf, sizeof(recv_buf));
/* When key agreement data is received and processed client gets 0 in return value (no data
* for client is received) */
if (bytes_received) {
testsuite_fail_if(bytes_received, "secure_session_receive failed");
return TEST_STOP_ERROR;
}
if (secure_session_is_established((client.session))) {
/* Negotiation completed. Clear the shared memory. */
current_length = 0;
}
return TEST_CONTINUE;
}
