Revision control
Copy as Markdown
Other Tools
/*
* Copyright (C) 2014 - David Goulet <dgoulet@ev0ke.net>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License, version 2 only, as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc., 51
* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#define _GNU_SOURCE
#include <assert.h>
#include <ctype.h>
#include <gcrypt.h>
#include <getopt.h>
#include <inttypes.h>
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>
#include <syscall.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <sys/un.h>
#include <unistd.h>
#include <context.h>
#include <privkey.h>
#include <proto.h>
#include <message.h>
#include <tap/tap.h>
#define zmalloc(x) calloc(1, x)
GCRY_THREAD_OPTION_PTHREAD_IMPL;
/* Global OTR user state. */
static OtrlUserState user_state;
/* Getopt options. */
static struct option long_opts[] = {
{ "load-instag", 1, NULL, 'i' },
{ "load-key", 1, NULL, 'k' },
{ "load-fp", 1, NULL, 'f' },
{ "timeout", 1, NULL, 't' },
{ "max-msg", 1, NULL, 'm' },
{ "disconnect", 0, NULL, 'd' },
{ "auth", 0, NULL, 'a' },
{ "fragment", 0, NULL, 'F' },
/* Closure. */
{ NULL, 0, NULL, 0 }
};
static char *opt_instag_path;
static char *opt_key_path;
static char *opt_key_fp_path;
static unsigned int opt_max_num_msg;
static int opt_disconnect;
static int opt_auth;
static int opt_fragment;
/* Currently, the message size sent is between 1 and 600 len so 100 is a good
* middle ground. */
static const int fragment_size = 100;
/* By default, don't send frag. */
static OtrlFragmentPolicy fragPolicy = OTRL_FRAGMENT_SEND_SKIP;
static const char *protocol = "otr-test";
static const char *alice_name = "alice";
static const char *bob_name = "bob";
static const char *unix_sock_bob_path = "/tmp/otr-test-bob.sock";
static const char *unix_sock_alice_path = "/tmp/otr-test-alice.sock";
static const char *auth_question = "What is NSA?";
static const char *auth_secret = "No Sugar Added";
/* Alice and Bob thread's socket. */
static int alice_sock;
static int bob_sock;
/* Declare it global because we use it multiple times. */
static struct sockaddr_un alice_sun;
static struct sockaddr_un bob_sun;
static int timeout_max = 1000;
static unsigned int num_recv_msg;
static unsigned int session_disconnected;
static int quit_pipe[2] = { -1, -1 };
/*
* For now not really do much more but if we want to use the OK condition at
* some point to do something else, that will ease our life :).
*/
#define OK(cond, fmt, args...) \
do { \
ok(cond, fmt, ## args); \
} while (0)
/*
* Used to pass OTR message between threads. This contains the cipher and
* plaintext so we are able to validate what's expected in both threads.
*/
struct otr_msg {
size_t plaintext_len;
size_t ciphertext_len;
char *plaintext;
char *ciphertext;
};
struct otr_info {
const char *user;
int sock;
unsigned int gone_secure;
unsigned int auth_done;
};
/* Stub */
static int send_otr_msg(int sock, const char *to, const char *from,
struct otr_info *oinfo, const char *message);
static OtrlPolicy ops_policy(void *opdata, ConnContext *context)
{
return OTRL_POLICY_DEFAULT;
}
static void ops_inject_msg(void *opdata, const char *accountname,
const char *protocol, const char *recipient, const char *message)
{
ssize_t ret;
struct otr_info *oinfo = opdata;
struct otr_msg *msg;
msg = zmalloc(sizeof(*msg));
if (!msg) {
perror("zmalloc inject");
return;
}
msg->ciphertext = strdup(message);
msg->ciphertext_len = strlen(message);
ret = send(oinfo->sock, &msg, sizeof(msg), 0);
if (ret < 0) {
perror("send msg");
}
}
static void ops_gone_secure(void *opdata, ConnContext *context)
{
struct otr_info *oinfo = opdata;
session_disconnected = 0;
oinfo->gone_secure = 1;
/* XXX: gone_insecure is never called ref bug #40 so this will always be
* true. */
OK(oinfo->gone_secure, "Gone secure for %s",
oinfo->user);
}
static void ops_gone_insecure(void *opdata, ConnContext *context)
{
struct otr_info *oinfo = opdata;
OK(oinfo->gone_secure, "Gone insecure for %s",
oinfo->user);
oinfo->gone_secure = 0;
}
static int ops_max_message_size(void *opdata, ConnContext *context)
{
if (opt_fragment) {
return fragment_size;
}
return 0;
}
static const char *ops_otr_error_message(void *opdata, ConnContext *context,
OtrlErrorCode code)
{
char *msg = NULL;
switch (code) {
case OTRL_ERRCODE_NONE:
break;
case OTRL_ERRCODE_ENCRYPTION_ERROR:
msg = strdup("OTRL_ERRCODE_ENCRYPTION_ERROR");
break;
case OTRL_ERRCODE_MSG_NOT_IN_PRIVATE:
msg = strdup("OTRL_ERRCODE_MSG_NOT_IN_PRIVATE");
break;
case OTRL_ERRCODE_MSG_UNREADABLE:
msg = strdup("OTRL_ERRCODE_MSG_UNREADABLE");
break;
case OTRL_ERRCODE_MSG_MALFORMED:
msg = strdup("OTRL_ERRCODE_MSG_MALFORMED");
break;
}
return msg;
}
static void ops_otr_error_message_free(void *opdata, const char *err_msg)
{
free((char *) err_msg);
}
static void ops_handle_msg_event(void *opdata, OtrlMessageEvent msg_event,
ConnContext *context, const char *message, gcry_error_t err)
{
//char* msg = "";
struct otr_info *oinfo = opdata;
switch(msg_event) {
case OTRL_MSGEVENT_NONE:
//msg = "OTRL_MSGEVENT_NONE";
break;
case OTRL_MSGEVENT_ENCRYPTION_REQUIRED:
//msg = "OTRL_MSGEVENT_ENCRYPTION_REQUIRED";
break;
case OTRL_MSGEVENT_ENCRYPTION_ERROR:
//msg = "OTRL_MSGEVENT_ENCRYPTION_ERROR";
break;
case OTRL_MSGEVENT_CONNECTION_ENDED:
//msg = "OTRL_MSGEVENT_CONNECTION_ENDED";
oinfo->gone_secure = 0;
break;
case OTRL_MSGEVENT_SETUP_ERROR:
//msg = "OTRL_MSGEVENT_SETUP_ERROR";
break;
case OTRL_MSGEVENT_MSG_REFLECTED:
//msg = "OTRL_MSGEVENT_MSG_REFLECTED";
break;
case OTRL_MSGEVENT_MSG_RESENT:
//msg = "OTRL_MSGEVENT_MSG_RESENT";
break;
case OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE:
//msg = "OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE";
break;
case OTRL_MSGEVENT_RCVDMSG_UNREADABLE:
//msg = "OTRL_MSGEVENT_RCVDMSG_UNREADABLE";
break;
case OTRL_MSGEVENT_RCVDMSG_MALFORMED:
//msg = "OTRL_MSGEVENT_RCVDMSG_MALFORMED";
break;
case OTRL_MSGEVENT_LOG_HEARTBEAT_RCVD:
//msg = "OTRL_MSGEVENT_LOG_HEARTBEAT_RCVD";
break;
case OTRL_MSGEVENT_LOG_HEARTBEAT_SENT:
//msg = "OTRL_MSGEVENT_LOG_HEARTBEAT_SENT";
break;
case OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR:
//msg = "OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR";
break;
case OTRL_MSGEVENT_RCVDMSG_UNENCRYPTED:
//msg = "OTRL_MSGEVENT_RCVDMSG_UNENCRYPTED";
break;
case OTRL_MSGEVENT_RCVDMSG_UNRECOGNIZED:
//msg = "OTRL_MSGEVENT_RCVDMSG_UNRECOGNIZED";
break;
case OTRL_MSGEVENT_RCVDMSG_FOR_OTHER_INSTANCE:
//msg = "OTRL_MSGEVENT_RCVDMSG_FOR_OTHER_INSTANCE";
break;
default:
//msg = "Unknown OTRL message event";
break;
}
}
static void ops_create_instag(void *opdata, const char *accountname,
const char *protocol)
{
otrl_instag_generate(user_state, "/dev/null", accountname,
protocol);
}
static int ops_is_logged_in(void *opdata, const char *accountname,
const char *protocol, const char *recipient)
{
/* Always logged in or else we don't receive a disconnected TLV. */
return 1;
}
static void ops_create_privkey(void *opdata, const char *accountname,
const char *protocol)
{
/* XXX: We should gen. our own key each time at some point? */
return;
}
static void ops_update_context_list(void *opdata)
{
return;
}
static void ops_new_fingerprint(void *opdata, OtrlUserState us,
const char *accountname, const char *protocol,
const char *username, unsigned char fingerprint[20])
{
return;
}
static void ops_write_fingerprints(void *opdata)
{
return;
}
static void ops_still_secure(void *opdata, ConnContext *context, int is_reply)
{
struct otr_info *oinfo = opdata;
OK(oinfo->gone_secure, "OP still secure");
}
static void ops_received_symkey(void *opdata, ConnContext *context,
unsigned int use, const unsigned char *usedata,
size_t usedatalen, const unsigned char *symkey)
{
return;
}
static const char *ops_resent_msg_prefix(void *opdata, ConnContext *context)
{
/* Just so we can test resent_msg_prefix_free */
char *prefix = zmalloc(32);
strncpy(prefix, "[such resent]", 32);
return prefix;
}
static void ops_resent_msg_prefix_free(void *opdata, const char *prefix)
{
free((char *) prefix);
}
static void ops_convert_msg(void *opdata, ConnContext *context,
OtrlConvertType convert_type, char ** dest, const char *src)
{
switch (convert_type) {
case OTRL_CONVERT_SENDING:
case OTRL_CONVERT_RECEIVING:
break;
default:
OK(0, "OP convert_msg, got a unknown type %d", convert_type);
break;
}
*dest = NULL;
}
static void ops_convert_free(void *opdata, ConnContext *context, char *dest)
{
return;
}
/* Stub */
static void ops_handle_smp_event(void *opdata, OtrlSMPEvent smp_event,
ConnContext *context, unsigned short progress_percent, char *question);
static void ops_timer_control(void *opdata, unsigned int interval);
/* OTR message operations. */
static OtrlMessageAppOps ops = {
ops_policy,
ops_create_privkey,
ops_is_logged_in,
ops_inject_msg,
ops_update_context_list,
ops_new_fingerprint,
ops_write_fingerprints,
ops_gone_secure,
ops_gone_insecure,
ops_still_secure,
ops_max_message_size,
NULL, /* account_name - NOT USED */
NULL, /* account_name_free - NOT USED */
ops_received_symkey,
ops_otr_error_message,
ops_otr_error_message_free,
ops_resent_msg_prefix,
ops_resent_msg_prefix_free,
ops_handle_smp_event,
ops_handle_msg_event,
ops_create_instag,
ops_convert_msg,
ops_convert_free,
ops_timer_control,
};
static void ops_timer_control(void *opdata, unsigned int interval)
{
otrl_message_poll(user_state, &ops, NULL);
}
static void ops_handle_smp_event(void *opdata, OtrlSMPEvent smp_event,
ConnContext *context, unsigned short progress_percent, char *question)
{
struct otr_info *oinfo = opdata;
switch (smp_event) {
case OTRL_SMPEVENT_ASK_FOR_SECRET:
OK(!oinfo->auth_done &&
!strncmp(oinfo->user, alice_name, strlen(alice_name)),
"SMP Event, %s asking for secret", alice_name);
break;
case OTRL_SMPEVENT_ASK_FOR_ANSWER:
OK(!oinfo->auth_done &&
!strncmp(oinfo->user, bob_name, strlen(bob_name)) &&
!strncmp(auth_question, question, strlen(auth_question)),
"SMP Event, %s asking for answer", bob_name);
/*
* Directly respond to the SMP auth here. Much more easy instead of in
* bob's thread.
*/
otrl_message_respond_smp(user_state, &ops, opdata, context,
(unsigned char *) auth_secret, strlen(auth_secret));
break;
case OTRL_SMPEVENT_IN_PROGRESS:
OK(!oinfo->auth_done &&
!strncmp(oinfo->user, alice_name, strlen(alice_name)),
"SMP Event, %s asking for secret", alice_name);
break;
case OTRL_SMPEVENT_SUCCESS:
oinfo->auth_done = 1;
OK(oinfo->auth_done, "SMP authentication success for %s", oinfo->user);
break;
case OTRL_SMPEVENT_ABORT:
case OTRL_SMPEVENT_FAILURE:
case OTRL_SMPEVENT_CHEATED:
case OTRL_SMPEVENT_ERROR:
default:
OK(0, "SMP auth failed with event %d", smp_event);
break;
}
}
static void cleanup(void)
{
ssize_t ret;
/* Wake up threads. */
ret = write(quit_pipe[1], "42", 2);
if (ret < 0) {
perror("write quit pipe");
}
/* Cleanup residual Unix socket path. */
unlink(alice_sun.sun_path);
unlink(bob_sun.sun_path);
}
static void update_msg_counter(void)
{
num_recv_msg++;
if (num_recv_msg == opt_max_num_msg) {
cleanup();
}
}
/*
* Generate random string and stores it in out of size len.
*/
static void gen_random_string(char *out, size_t len)
{
size_t i;
static const char alphanum[] =
"0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
for (i = 0; i < len; i++) {
out[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
}
out[len - 1] = '\0';
}
static int send_otr_msg(int sock, const char *to, const char *from,
struct otr_info *oinfo, const char *message)
{
char *new_msg = NULL;
ssize_t ret;
gcry_error_t err;
struct otr_msg *omsg;
omsg = zmalloc(sizeof(*omsg));
if (!omsg) {
perror("zmalloc send otr msg");
goto error;
}
if (!message) {
size_t len = rand() % 600;
char *msg = zmalloc(len);
if (!msg) {
perror("random msg");
goto error;
}
gen_random_string(msg, len);
omsg->plaintext = msg;
omsg->plaintext_len = strlen(msg);
} else {
omsg->plaintext = strdup(message);
omsg->plaintext_len = strlen(message);
}
err = otrl_message_sending(user_state, &ops, oinfo, from, protocol, to,
OTRL_INSTAG_BEST, omsg->plaintext, NULL, &new_msg,
fragPolicy, NULL, NULL, NULL);
if (err) {
goto error;
}
if (new_msg) {
free(omsg->ciphertext);
omsg->ciphertext = strdup(new_msg);
omsg->ciphertext_len = strlen(omsg->ciphertext);
otrl_message_free(new_msg);
}
ret = send(sock, &omsg, sizeof(omsg), 0);
if (ret < 0) {
perror("send OTR msg");
goto error;
}
return 0;
error:
if(omsg){
free(omsg->plaintext);
free(omsg->ciphertext);
free(omsg);
}
return -1;
}
static int recv_otr_msg(int sock, const char *to, const char *from,
struct otr_info *oinfo)
{
int err;
ssize_t ret;
char *new_msg = NULL;
struct otr_msg *omsg;
OtrlTLV *tlvs = NULL;
ret = recv(sock, &omsg, sizeof(omsg), 0);
if (ret < 0) {
goto error;
}
err = otrl_message_receiving(user_state, &ops, oinfo, to, protocol, from,
omsg->ciphertext, &new_msg, &tlvs, NULL, NULL, NULL);
if (!err) {
if (new_msg) {
OK(strncmp(omsg->plaintext, new_msg, omsg->plaintext_len) == 0,
"Message exchanged is valid");
update_msg_counter();
}
} else {
OK(err == 1, "Internal OTR message valid");
}
free(omsg->plaintext);
free(omsg->ciphertext);
free(omsg);
OtrlTLV *tlv = otrl_tlv_find(tlvs, OTRL_TLV_DISCONNECTED);
/*
* XXX: Somehow you can end up with a disconnected TLV in a gone secure
* session (see #54). This is probably a bug but since the gone_insecure is
* never called (see bug #48) we have no reliable way of knowing the state
* of the session at this point.
*/
if (tlv && !oinfo->gone_secure) {
OK(session_disconnected, "Disconnected TLV confirmed");
}
otrl_tlv_free(tlvs);
return 0;
error:
return -1;
}
static int add_sock_to_pollset(int epfd, int sock, uint32_t req_ev)
{
int ret;
struct epoll_event ev;
memset(&ev, 0, sizeof(ev));
ev.events = req_ev;
ev.data.fd = sock;
ret = epoll_ctl(epfd, EPOLL_CTL_ADD, sock, &ev);
if (ret < 0) {
perror("epoll_ctl add");
}
return ret;
}
static void *alice_thread(void *data)
{
int sock_to_bob, sock_from_bob = 0, epfd, ret;
unsigned int auth_started = 0;
struct otr_info oinfo;
memset(&oinfo, 0, sizeof(oinfo));
/* Poll size is ignored since 2.6.8 */
epfd = epoll_create(42);
if (epfd < 0) {
perror("epoll_create Bob");
goto error;
}
sock_to_bob = socket(PF_UNIX, SOCK_STREAM, 0);
if (sock_to_bob < 0) {
perror("Bob socket to Alice");
goto sock_error;
}
oinfo.sock = sock_to_bob;
oinfo.user = alice_name;
if (!opt_auth) {
/* We are not going to SMP auth for this session so indicate it's
* completed so we can go forward with random disconnect.
*/
oinfo.auth_done = 1;
}
ret = connect(sock_to_bob, (struct sockaddr *) &bob_sun,
sizeof(bob_sun));
if (ret < 0) {
perror("connect to Alice");
goto end;
}
/* Add quit pipe to pollset trigger by a cleanup. */
ret = add_sock_to_pollset(epfd, quit_pipe[0], EPOLLIN);
if (ret < 0) {
goto end;
}
/* Add our socket to epoll set. */
ret = add_sock_to_pollset(epfd, alice_sock,
EPOLLIN | EPOLLRDHUP);
if (ret < 0) {
goto end;
}
while (1) {
int i, nb_fd, timeout;
struct epoll_event ev[3];
memset(ev, 0, sizeof(ev));
/*
* Set random timeout and when we do timeout, use that to send message
* to Alice.
*/
timeout = (rand() % (timeout_max - 1));
ret = epoll_wait(epfd, ev, sizeof(ev), timeout);
if (ret < 0) {
perror("epoll_wait Alice");
goto end;
}
nb_fd = ret;
/* Each timeout to 10 finishes the OTR session. */
if (!(timeout % 3) && opt_disconnect && oinfo.auth_done) {
session_disconnected = 1;
oinfo.gone_secure = 0;
otrl_message_disconnect(user_state, &ops, &oinfo,
alice_name, protocol, bob_name, OTRL_INSTAG_BEST);
OK(!oinfo.gone_secure, "OTR message disconnect");
}
/* Start authentication with Bob. */
if (opt_auth && !auth_started && oinfo.gone_secure) {
ConnContext *ctx;
/* We have to find our context before auth. */
ctx = otrl_context_find(user_state, bob_name, alice_name,
protocol, OTRL_INSTAG_BEST, 0, NULL, NULL, &oinfo);
OK(ctx, "Alice context found for SMP auth");
otrl_message_initiate_smp_q(user_state, &ops, &oinfo, ctx,
auth_question, (unsigned char *) auth_secret,
strlen(auth_secret));
auth_started = 1;
}
/* No event thus timeout, send message to Alice. */
if (nb_fd == 0) {
(void) send_otr_msg(sock_to_bob, bob_name, alice_name, &oinfo,
NULL);
continue;
}
for (i = 0; i < nb_fd; i++) {
int fd;
uint32_t event;
fd = ev[i].data.fd;
event = ev[i].events;
if (fd == quit_pipe[0]) {
/* Time to leave. */
goto end;
} else if (fd == alice_sock) {
if (event & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
goto end;
} else if (event & EPOLLIN) {
socklen_t len;
struct sockaddr_un sun;
/* Connection from Bob, accept it so we can handle it. */
sock_from_bob = accept(fd, (struct sockaddr *) &sun,
&len);
ret = add_sock_to_pollset(epfd, sock_from_bob,
EPOLLIN | EPOLLERR | EPOLLHUP);
if (ret < 0) {
goto end;
}
}
continue;
} else if (fd == sock_from_bob) {
if (event & (EPOLLERR | EPOLLHUP)) {
/* Stop since Bob's thread just shut us down. */
goto end;
} else if (event & EPOLLIN) {
(void) recv_otr_msg(sock_from_bob, alice_name, bob_name,
&oinfo);
}
continue;
} else {
goto end;
}
}
}
end:
if (sock_from_bob) {
(void) close(sock_from_bob);
}
(void) close(sock_to_bob);
sock_error:
(void) close(epfd);
error:
(void) close(alice_sock);
return NULL;
}
static void *bob_thread(void *data)
{
int sock_to_alice, sock_from_alice = 0, epfd, ret;
struct otr_info oinfo;
memset(&oinfo, 0, sizeof(oinfo));
/* Poll size is ignored since 2.6.8 */
epfd = epoll_create(42);
if (epfd < 0) {
perror("epoll_create Bob");
goto error;
}
sock_to_alice = socket(PF_UNIX, SOCK_STREAM, 0);
if (sock_to_alice < 0) {
perror("Bob socket to Alice");
goto sock_error;
}
oinfo.sock = sock_to_alice;
oinfo.user = bob_name;
ret = connect(sock_to_alice, (struct sockaddr *) &alice_sun,
sizeof(alice_sun));
if (ret < 0) {
perror("connect to Alice");
goto end;
}
/* Add quit pipe to pollset trigger by a cleanup. */
ret = add_sock_to_pollset(epfd, quit_pipe[0], EPOLLIN);
if (ret < 0) {
goto end;
}
/* Add our socket to epoll set. */
ret = add_sock_to_pollset(epfd, bob_sock,
EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP);
if (ret < 0) {
goto end;
}
while (1) {
int i, timeout = 500, nb_fd;
struct epoll_event ev[3];
memset(ev, 0, sizeof(ev));
/*
* Set random timeout and when we do timeout, use that to send message
* to Alice.
*/
timeout = (rand() % (timeout_max - 1));
ret = epoll_wait(epfd, ev, sizeof(ev), timeout);
if (ret < 0) {
perror("epoll_wait Bob");
goto end;
}
nb_fd = ret;
/* No event thus timeout, send message to Alice. */
if (nb_fd == 0) {
(void) send_otr_msg(sock_to_alice, alice_name, bob_name, &oinfo,
NULL);
continue;
}
for (i = 0; i < nb_fd; i++) {
int fd;
uint32_t event;
fd = ev[i].data.fd;
event = ev[i].events;
if (fd == quit_pipe[0]) {
/* Time to leave. */
goto end;
} else if (fd == bob_sock) {
if (event & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
goto end;
} else if (event & (EPOLLIN | EPOLLHUP)) {
socklen_t len;
struct sockaddr_un sun;
/* Connection from Alice, accept it so we can handle it. */
sock_from_alice = accept(fd, (struct sockaddr *) &sun,
&len);
ret = add_sock_to_pollset(epfd, sock_from_alice,
EPOLLIN | EPOLLERR | EPOLLHUP);
if (ret < 0) {
goto end;
}
}
continue;
} else if (fd == sock_from_alice) {
if (event & (EPOLLERR | EPOLLHUP)) {
goto end;
} else if (event & EPOLLIN) {
(void) recv_otr_msg(sock_from_alice, bob_name,
alice_name, &oinfo);
}
continue;
} else {
goto end;
}
}
}
end:
if (sock_from_alice) {
(void) close(sock_from_alice);
}
(void) close(sock_to_alice);
sock_error:
(void) close(epfd);
error:
(void) close(bob_sock);
return NULL;
}
static void run(void)
{
int ret;
void *status;
pthread_t alice_th, bob_th;
/* Init quit pipe. */
ret = pipe(quit_pipe);
if (ret < 0) {
perror("pipe quit pipe");
goto end;
}
ret = pthread_create(&alice_th, NULL, alice_thread, NULL);
if (ret) {
fail("pthread_create sender thread failed (errno: %d)", errno);
goto end;
}
ret = pthread_create(&bob_th, NULL, bob_thread, NULL);
if (ret) {
fail("pthread_create receiver thread failed (errno: %d)", errno);
goto exit_receiver;
}
(void) pthread_join(bob_th, &status);
exit_receiver:
(void) pthread_join(alice_th, &status);
end:
/* Get rid of the quit pipe. */
close(quit_pipe[0]);
close(quit_pipe[1]);
return;
}
/*
* Load OTR instag using the given opt argument.
*/
static void load_instag(void)
{
int ret;
gcry_error_t err;
ret = access(opt_instag_path, R_OK);
if (ret < 0) {
fail("Instag file %s is not readable", opt_instag_path);
return;
}
err = otrl_instag_read(user_state, opt_instag_path);
OK(err == GPG_ERR_NO_ERROR, "Loading instag from given file");
}
/*
* Load private key file using the given opt argument.
*/
static void load_key(void)
{
int ret;
gcry_error_t err;
ret = access(opt_key_path, R_OK);
if (ret < 0) {
fail("Key file %s is not readable", opt_key_path);
return;
}
err = otrl_privkey_read(user_state, opt_key_path);
OK(err == GPG_ERR_NO_ERROR, "Loading key from given file");
}
/*
* Load private key fingerprint file using the given opt argument.
*/
static void load_key_fp(void)
{
int ret;
gcry_error_t err;
ret = access(opt_key_fp_path, R_OK);
if (ret < 0) {
fail("Key fingerprints file %s is not readable", opt_key_fp_path);
return;
}
err = otrl_privkey_read_fingerprints(user_state, opt_key_fp_path, NULL,
NULL);
OK(err == GPG_ERR_NO_ERROR, "Loading key fingerprints from given file");
}
static int create_unix_socket(const char *pathname,
struct sockaddr_un *sun)
{
int sock, ret;
/* Create both Unix socket. */
if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
ret = -errno;
perror("Unix socket");
goto error;
}
memset(sun, 0, sizeof(struct sockaddr_un));
sun->sun_family = AF_UNIX;
strncpy(sun->sun_path, pathname, sizeof(sun->sun_path));
sun->sun_path[sizeof(sun->sun_path) - 1] = '\0';
ret = bind(sock, (struct sockaddr *) sun, sizeof(struct sockaddr_un));
if (ret < 0) {
perror("bind unix sock");
goto error;
}
ret = listen(sock, 10);
if (ret < 0) {
perror("listen unix sock");
goto error;
}
return sock;
error:
return ret;
}
/*
* Bootstrap client by initializing the OTR library and creating an OTR user
* state.
*
* Return 0 on success else a negative value on error.
*/
static int init_client(void)
{
int ret;
/* Init libgcrypt threading system. */
gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
/* Init OTR library. */
OTRL_INIT;
OK(1, "OTR library initialization done.");
user_state = otrl_userstate_create();
OK(user_state, "OTR userstate creation done.");
if (!user_state) {
fail("Out of memory on userstate create");
ret = -ENOMEM;
goto error;
}
/* Seed the prng. */
srand(time(NULL));
/* Cleanup Unix socket file before creating them. */
unlink(unix_sock_alice_path);
unlink(unix_sock_bob_path);
alice_sock = create_unix_socket(unix_sock_alice_path, &alice_sun);
bob_sock = create_unix_socket(unix_sock_bob_path, &bob_sun);
if (alice_sock < 0 || bob_sock < 0) {
ret = -EINVAL;
goto error;
}
if (opt_fragment) {
fragPolicy = OTRL_FRAGMENT_SEND_ALL;
}
return 0;
error:
return ret;
}
static void sighandler(int sig)
{
switch (sig) {
case SIGPIPE:
case SIGINT:
case SIGTERM:
cleanup();
break;
default:
break;
}
}
/*
* main entry point.
*/
int main(int argc, char **argv)
{
int ret, opt;
struct sigaction sa;
sigset_t sigset;
plan_no_plan();
if ((ret = sigemptyset(&sigset)) < 0) {
perror("sigemptyset");
goto error;
}
sa.sa_handler = sighandler;
sa.sa_mask = sigset;
sa.sa_flags = 0;
if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
perror("sigaction");
goto error;
}
if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
perror("sigaction");
goto error;
}
if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
perror("sigaction");
goto error;
}
while ((opt = getopt_long(argc, argv, "+i:k:f:t:m:daF", long_opts, NULL)) != -1) {
switch (opt) {
case 'i':
opt_instag_path = strdup(optarg);
break;
case 'k':
opt_key_path = strdup(optarg);
break;
case 'f':
opt_key_fp_path = strdup(optarg);
break;
case 't':
timeout_max = atoi(optarg);
break;
case 'm':
opt_max_num_msg = atoi(optarg);
break;
case 'd':
opt_disconnect = 1;
break;
case 'a':
opt_auth = 1;
break;
case 'F':
opt_fragment = 1;
break;
default:
goto error;
}
}
if (!opt_key_path) {
fail("No key file, failing");
goto error;
}
/* Running OTR tests. */
ret = init_client();
if (ret < 0) {
goto error;
}
if (opt_instag_path) {
load_instag();
}
if (opt_key_fp_path) {
load_key_fp();
}
load_key();
run();
return exit_status();
error:
return -1;
}