aniani
/
profanity
mirror of https://github.com/profanity-im/profanity.git
1
0
Fork 0
Code
profanity/src/otr/otr.c

782 lines
22 KiB
C
Raw Blame History

/*
* otr.c
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* This file is part of Profanity.
*
* Profanity is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Profanity 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 Profanity. If not, see <https://www.gnu.org/licenses/>.
*
* In addition, as a special exception, the copyright holders give permission to
* link the code of portions of this program with the OpenSSL library under
* certain conditions as described in each individual source file, and
* distribute linked combinations including the two.
*
* You must obey the GNU General Public License in all respects for all of the
* code used other than OpenSSL. If you modify file(s) with this exception, you
* may extend this exception to your version of the file(s), but you are not
* obligated to do so. If you do not wish to do so, delete this exception
* statement from your version. If you delete this exception statement from all
* source files in the program, then also delete it here.
*
*/
#include "config.h"
#include <libotr/proto.h>
#include <libotr/privkey.h>
#include <libotr/message.h>
#include <libotr/sm.h>
#include <glib.h>
#include "log.h"
#include "database.h"
#include "config/preferences.h"
#include "config/files.h"
#include "otr/otr.h"
#include "otr/otrlib.h"
#include "ui/ui.h"
#include "ui/window_list.h"
#include "xmpp/chat_session.h"
#include "xmpp/roster_list.h"
#include "xmpp/contact.h"
#include "xmpp/xmpp.h"
#define PRESENCE_ONLINE 1
#define PRESENCE_OFFLINE 0
#define PRESENCE_UNKNOWN -1
static OtrlUserState user_state;
static OtrlMessageAppOps ops;
static char* jid;
static gboolean data_loaded;
static GHashTable* smp_initiators;
OtrlUserState
otr_userstate(void)
{
return user_state;
}
OtrlMessageAppOps*
otr_messageops(void)
{
return &ops;
}
GHashTable*
otr_smpinitators(void)
{
return smp_initiators;
}
// ops callbacks
static OtrlPolicy
cb_policy(void* opdata, ConnContext* context)
{
return otrlib_policy();
}
static int
cb_is_logged_in(void* opdata, const char* accountname, const char* protocol, const char* recipient)
{
jabber_conn_status_t conn_status = connection_get_status();
if (conn_status != JABBER_CONNECTED) {
return PRESENCE_OFFLINE;
}
PContact contact = roster_get_contact(recipient);
// not in roster
if (contact == NULL) {
return PRESENCE_ONLINE;
}
// not subscribed
if (p_contact_subscribed(contact) == FALSE) {
return PRESENCE_ONLINE;
}
// subscribed
if (g_strcmp0(p_contact_presence(contact), "offline") == 0) {
return PRESENCE_OFFLINE;
} else {
return PRESENCE_ONLINE;
}
}
static void
cb_inject_message(void* opdata, const char* accountname,
const char* protocol, const char* recipient, const char* message)
{
char* id = message_send_chat_otr(recipient, message, FALSE, NULL);
free(id);
}
static void
cb_write_fingerprints(void* opdata)
{
gcry_error_t err = 0;
gchar* otr_dir = files_get_account_data_path(DIR_OTR, jid);
GString* fpsfilename = g_string_new(otr_dir);
g_string_append(fpsfilename, "/fingerprints.txt");
err = otrl_privkey_write_fingerprints(user_state, fpsfilename->str);
if (err != GPG_ERR_NO_ERROR) {
log_error("Failed to write fingerprints file");
cons_show_error("Failed to create fingerprints file");
}
g_free(otr_dir);
g_string_free(fpsfilename, TRUE);
}
static void
cb_gone_secure(void* opdata, ConnContext* context)
{
ProfChatWin* chatwin = wins_get_chat(context->username);
if (!chatwin) {
chatwin = (ProfChatWin*)wins_new_chat(context->username);
}
chatwin_otr_secured(chatwin, otr_is_trusted(context->username));
}
char*
otr_libotr_version(void)
{
return OTRL_VERSION;
}
char*
otr_start_query(void)
{
return otrlib_start_query();
}
void
otr_init(void)
{
log_info("Initialising OTR");
OTRL_INIT;
jid = NULL;
ops.policy = cb_policy;
ops.is_logged_in = cb_is_logged_in;
ops.inject_message = cb_inject_message;
ops.write_fingerprints = cb_write_fingerprints;
ops.gone_secure = cb_gone_secure;
otrlib_init_ops(&ops);
otrlib_init_timer();
smp_initiators = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
data_loaded = FALSE;
}
void
otr_shutdown(void)
{
if (jid) {
free(jid);
jid = NULL;
}
}
void
otr_poll(void)
{
otrlib_poll();
}
void
otr_on_connect(ProfAccount* account)
{
if (jid) {
free(jid);
}
jid = strdup(account->jid);
log_info("Loading OTR key for %s", jid);
gchar* otr_dir = files_get_account_data_path(DIR_OTR, jid);
if (!mkdir_recursive(otr_dir)) {
log_error("Could not create %s for account %s.", otr_dir, jid);
cons_show_error("Could not create %s for account %s.", otr_dir, jid);
g_free(otr_dir);
return;
}
if (user_state) {
otrl_userstate_free(user_state);
}
user_state = otrl_userstate_create();
gcry_error_t err = 0;
GString* keysfilename = g_string_new(otr_dir);
g_string_append(keysfilename, "/keys.txt");
if (!g_file_test(keysfilename->str, G_FILE_TEST_IS_REGULAR)) {
log_info("No OTR private key file found %s", keysfilename->str);
data_loaded = FALSE;
} else {
log_info("Loading OTR private key %s", keysfilename->str);
err = otrl_privkey_read(user_state, keysfilename->str);
if (err != GPG_ERR_NO_ERROR) {
log_warning("Failed to read OTR private key file: %s", keysfilename->str);
cons_show_error("Failed to read OTR private key file: %s", keysfilename->str);
g_free(otr_dir);
g_string_free(keysfilename, TRUE);
return;
}
OtrlPrivKey* privkey = otrl_privkey_find(user_state, jid, "xmpp");
if (!privkey) {
log_warning("No OTR private key found for account \"%s\", protocol \"xmpp\" in file: %s", jid, keysfilename->str);
cons_show_error("No OTR private key found for account \"%s\", protocol \"xmpp\" in file: %s", jid, keysfilename->str);
g_free(otr_dir);
g_string_free(keysfilename, TRUE);
return;
}
log_info("Loaded OTR private key");
data_loaded = TRUE;
}
GString* fpsfilename = g_string_new(otr_dir);
g_string_append(fpsfilename, "/fingerprints.txt");
if (!g_file_test(fpsfilename->str, G_FILE_TEST_IS_REGULAR)) {
log_info("No OTR fingerprints file found %s", fpsfilename->str);
data_loaded = FALSE;
} else {
log_info("Loading OTR fingerprints %s", fpsfilename->str);
err = otrl_privkey_read_fingerprints(user_state, fpsfilename->str, NULL, NULL);
if (err != GPG_ERR_NO_ERROR) {
log_error("Failed to load OTR fingerprints file: %s", fpsfilename->str);
g_free(otr_dir);
g_string_free(keysfilename, TRUE);
g_string_free(fpsfilename, TRUE);
return;
} else {
log_info("Loaded OTR fingerprints");
data_loaded = TRUE;
}
}
if (data_loaded) {
cons_show("Loaded OTR private key for %s", jid);
}
g_free(otr_dir);
g_string_free(keysfilename, TRUE);
g_string_free(fpsfilename, TRUE);
return;
}
char*
otr_on_message_recv(const char* const barejid, const char* const resource, const char* const message, gboolean* decrypted)
{
prof_otrpolicy_t policy = otr_get_policy(barejid);
char* whitespace_base = strstr(message, OTRL_MESSAGE_TAG_BASE);
// check for OTR whitespace (opportunistic or always)
if (policy == PROF_OTRPOLICY_OPPORTUNISTIC || policy == PROF_OTRPOLICY_ALWAYS) {
if (whitespace_base) {
if (strstr(message, OTRL_MESSAGE_TAG_V2) || strstr(message, OTRL_MESSAGE_TAG_V1)) {
// Remove whitespace pattern for proper display in UI
// Handle both BASE+TAGV1/2(16+8) and BASE+TAGV1+TAGV2(16+8+8)
int tag_length = 24;
if (strstr(message, OTRL_MESSAGE_TAG_V2) && strstr(message, OTRL_MESSAGE_TAG_V1)) {
tag_length = 32;
}
memmove(whitespace_base, whitespace_base + tag_length, tag_length);
char* otr_query_message = otr_start_query();
cons_show("OTR Whitespace pattern detected. Attempting to start OTR session...");
char* id = message_send_chat_otr(barejid, otr_query_message, FALSE, NULL);
free(id);
}
}
}
char* newmessage = otr_decrypt_message(barejid, message, decrypted);
if (!newmessage) { // internal OTR message
return NULL;
}
if (policy == PROF_OTRPOLICY_ALWAYS && *decrypted == FALSE && !whitespace_base) {
char* otr_query_message = otr_start_query();
cons_show("Attempting to start OTR session...");
char* id = message_send_chat_otr(barejid, otr_query_message, FALSE, NULL);
free(id);
}
return newmessage;
}
gboolean
otr_on_message_send(ProfChatWin* chatwin, const char* const message, gboolean request_receipt, const char* const replace_id)
{
char* id = NULL;
prof_otrpolicy_t policy = otr_get_policy(chatwin->barejid);
// Send encrypted message
if (otr_is_secure(chatwin->barejid)) {
char* encrypted = otr_encrypt_message(chatwin->barejid, message);
if (encrypted) {
id = message_send_chat_otr(chatwin->barejid, encrypted, request_receipt, replace_id);
chat_log_otr_msg_out(chatwin->barejid, message, NULL);
log_database_add_outgoing_chat(id, chatwin->barejid, message, replace_id, PROF_MSG_ENC_OTR);
chatwin_outgoing_msg(chatwin, message, id, PROF_MSG_ENC_OTR, request_receipt, replace_id);
otr_free_message(encrypted);
free(id);
return TRUE;
} else {
win_println((ProfWin*)chatwin, THEME_ERROR, "-", "%s", "Failed to encrypt and send message.");
return TRUE;
}
}
// show error if not secure and policy always
if (policy == PROF_OTRPOLICY_ALWAYS) {
win_println((ProfWin*)chatwin, THEME_ERROR, "-", "%s", "Failed to send message. OTR policy set to: always");
return TRUE;
}
// tag and send for policy opportunistic
if (policy == PROF_OTRPOLICY_OPPORTUNISTIC) {
char* otr_tagged_msg = otr_tag_message(message);
id = message_send_chat_otr(chatwin->barejid, otr_tagged_msg, request_receipt, replace_id);
chatwin_outgoing_msg(chatwin, message, id, PROF_MSG_ENC_NONE, request_receipt, replace_id);
chat_log_msg_out(chatwin->barejid, message, NULL);
free(otr_tagged_msg);
free(id);
return TRUE;
}
return FALSE;
}
void
otr_keygen(ProfAccount* account)
{
if (data_loaded) {
cons_show("OTR key already generated.");
return;
}
free(jid);
jid = strdup(account->jid);
log_info("Generating OTR key for %s", jid);
gchar* otr_dir = files_get_account_data_path(DIR_OTR, jid);
if (!mkdir_recursive(otr_dir)) {
log_error("Could not create %s for account %s.", otr_dir, jid);
cons_show_error("Could not create %s for account %s.", otr_dir, jid);
g_free(otr_dir);
return;
}
gcry_error_t err = 0;
GString* keysfilename = g_string_new(otr_dir);
g_string_append(keysfilename, "/keys.txt");
log_debug("Generating private key file %s for %s", keysfilename->str, jid);
cons_show("Generating private key, this may take some time.");
cons_show("Moving the mouse randomly around the screen may speed up the process!");
ui_update();
err = otrl_privkey_generate(user_state, keysfilename->str, account->jid, "xmpp");
if (err != GPG_ERR_NO_ERROR) {
g_free(otr_dir);
g_string_free(keysfilename, TRUE);
log_error("Failed to generate private key");
cons_show_error("Failed to generate private key");
return;
}
log_info("Private key generated");
cons_show("");
cons_show("Private key generation complete.");
GString* fpsfilename = g_string_new(otr_dir);
g_string_append(fpsfilename, "/fingerprints.txt");
log_debug("Generating fingerprints file %s for %s", fpsfilename->str, jid);
err = otrl_privkey_write_fingerprints(user_state, fpsfilename->str);
if (err != GPG_ERR_NO_ERROR) {
g_free(otr_dir);
g_string_free(keysfilename, TRUE);
log_error("Failed to create fingerprints file");
cons_show_error("Failed to create fingerprints file");
return;
}
log_info("Fingerprints file created");
err = otrl_privkey_read(user_state, keysfilename->str);
if (err != GPG_ERR_NO_ERROR) {
g_free(otr_dir);
g_string_free(keysfilename, TRUE);
log_error("Failed to load private key");
data_loaded = FALSE;
return;
}
err = otrl_privkey_read_fingerprints(user_state, fpsfilename->str, NULL, NULL);
if (err != GPG_ERR_NO_ERROR) {
g_free(otr_dir);
g_string_free(keysfilename, TRUE);
log_error("Failed to load fingerprints");
data_loaded = FALSE;
return;
}
data_loaded = TRUE;
g_free(otr_dir);
g_string_free(keysfilename, TRUE);
g_string_free(fpsfilename, TRUE);
return;
}
gboolean
otr_key_loaded(void)
{
return data_loaded;
}
char*
otr_tag_message(const char* const msg)
{
GString* otr_message = g_string_new(msg);
g_string_append(otr_message, OTRL_MESSAGE_TAG_BASE);
g_string_append(otr_message, OTRL_MESSAGE_TAG_V2);
char* result = otr_message->str;
g_string_free(otr_message, FALSE);
return result;
}
gboolean
otr_is_secure(const char* const recipient)
{
ConnContext* context = otrlib_context_find(user_state, recipient, jid);
if (context == NULL) {
return FALSE;
}
if (context->msgstate != OTRL_MSGSTATE_ENCRYPTED) {
return FALSE;
} else {
return TRUE;
}
}
gboolean
otr_is_trusted(const char* const recipient)
{
ConnContext* context = otrlib_context_find(user_state, recipient, jid);
if (context == NULL) {
return FALSE;
}
if (context->msgstate != OTRL_MSGSTATE_ENCRYPTED) {
return TRUE;
}
if (context->active_fingerprint) {
if (context->active_fingerprint->trust == NULL) {
return FALSE;
} else if (context->active_fingerprint->trust[0] == '\0') {
return FALSE;
} else {
return TRUE;
}
}
return FALSE;
}
void
otr_trust(const char* const recipient)
{
ConnContext* context = otrlib_context_find(user_state, recipient, jid);
if (context == NULL) {
return;
}
if (context->msgstate != OTRL_MSGSTATE_ENCRYPTED) {
return;
}
if (context->active_fingerprint) {
if (context->active_fingerprint->trust) {
free(context->active_fingerprint->trust);
}
context->active_fingerprint->trust = strdup("trusted");
cb_write_fingerprints(NULL);
}
return;
}
void
otr_untrust(const char* const recipient)
{
ConnContext* context = otrlib_context_find(user_state, recipient, jid);
if (context == NULL) {
return;
}
if (context->msgstate != OTRL_MSGSTATE_ENCRYPTED) {
return;
}
if (context->active_fingerprint) {
if (context->active_fingerprint->trust) {
free(context->active_fingerprint->trust);
}
context->active_fingerprint->trust = NULL;
cb_write_fingerprints(NULL);
}
return;
}
void
otr_smp_secret(const char* const recipient, const char* secret)
{
ConnContext* context = otrlib_context_find(user_state, recipient, jid);
if (context == NULL) {
return;
}
if (context->msgstate != OTRL_MSGSTATE_ENCRYPTED) {
return;
}
// if recipient initiated SMP, send response, else initialise
ProfChatWin* chatwin = wins_get_chat(recipient);
if (g_hash_table_contains(smp_initiators, recipient)) {
otrl_message_respond_smp(user_state, &ops, NULL, context, (const unsigned char*)secret, strlen(secret));
if (chatwin) {
chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_AUTH, NULL);
}
g_hash_table_remove(smp_initiators, context->username);
} else {
otrl_message_initiate_smp(user_state, &ops, NULL, context, (const unsigned char*)secret, strlen(secret));
if (chatwin) {
chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_AUTH_WAIT, NULL);
}
}
}
void
otr_smp_question(const char* const recipient, const char* question, const char* answer)
{
ConnContext* context = otrlib_context_find(user_state, recipient, jid);
if (context == NULL) {
return;
}
if (context->msgstate != OTRL_MSGSTATE_ENCRYPTED) {
return;
}
otrl_message_initiate_smp_q(user_state, &ops, NULL, context, question, (const unsigned char*)answer, strlen(answer));
ProfChatWin* chatwin = wins_get_chat(recipient);
if (chatwin) {
chatwin_otr_smp_event(chatwin, PROF_OTR_SMP_AUTH_WAIT, NULL);
}
}
void
otr_smp_answer(const char* const recipient, const char* answer)
{
ConnContext* context = otrlib_context_find(user_state, recipient, jid);
if (context == NULL) {
return;
}
if (context->msgstate != OTRL_MSGSTATE_ENCRYPTED) {
return;
}
// if recipient initiated SMP, send response, else initialise
otrl_message_respond_smp(user_state, &ops, NULL, context, (const unsigned char*)answer, strlen(answer));
}
void
otr_end_session(const char* const recipient)
{
otrlib_end_session(user_state, recipient, jid, &ops);
}
char*
otr_get_my_fingerprint(void)
{
char fingerprint[45];
otrl_privkey_fingerprint(user_state, fingerprint, jid, "xmpp");
char* result = strdup(fingerprint);
return result;
}
char*
otr_get_their_fingerprint(const char* const recipient)
{
ConnContext* context = otrlib_context_find(user_state, recipient, jid);
if (context) {
Fingerprint* fingerprint = context->active_fingerprint;
char readable[45];
otrl_privkey_hash_to_human(readable, fingerprint->fingerprint);
return strdup(readable);
} else {
return NULL;
}
}
prof_otrpolicy_t
otr_get_policy(const char* const recipient)
{
char* account_name = session_get_account_name();
ProfAccount* account = accounts_get_account(account_name);
// check contact specific setting
if (g_list_find_custom(account->otr_manual, recipient, (GCompareFunc)g_strcmp0)) {
account_free(account);
return PROF_OTRPOLICY_MANUAL;
}
if (g_list_find_custom(account->otr_opportunistic, recipient, (GCompareFunc)g_strcmp0)) {
account_free(account);
return PROF_OTRPOLICY_OPPORTUNISTIC;
}
if (g_list_find_custom(account->otr_always, recipient, (GCompareFunc)g_strcmp0)) {
account_free(account);
return PROF_OTRPOLICY_ALWAYS;
}
// check default account setting
if (account->otr_policy) {
prof_otrpolicy_t result = PROF_OTRPOLICY_MANUAL;
if (g_strcmp0(account->otr_policy, "manual") == 0) {
result = PROF_OTRPOLICY_MANUAL;
}
if (g_strcmp0(account->otr_policy, "opportunistic") == 0) {
result = PROF_OTRPOLICY_OPPORTUNISTIC;
}
if (g_strcmp0(account->otr_policy, "always") == 0) {
result = PROF_OTRPOLICY_ALWAYS;
}
account_free(account);
return result;
}
account_free(account);
// check global setting
char* pref_otr_policy = prefs_get_string(PREF_OTR_POLICY);
// pref defaults to manual
prof_otrpolicy_t result = PROF_OTRPOLICY_MANUAL;
if (strcmp(pref_otr_policy, "opportunistic") == 0) {
result = PROF_OTRPOLICY_OPPORTUNISTIC;
} else if (strcmp(pref_otr_policy, "always") == 0) {
result = PROF_OTRPOLICY_ALWAYS;
}
g_free(pref_otr_policy);
return result;
}
char*
otr_encrypt_message(const char* const to, const char* const message)
{
char* newmessage = NULL;
gcry_error_t err = otrlib_encrypt_message(user_state, &ops, jid, to, message, &newmessage);
if (err != 0) {
return NULL;
} else {
return newmessage;
}
}
static void
_otr_tlv_free(OtrlTLV* tlvs)
{
if (tlvs) {
otrl_tlv_free(tlvs);
}
}
char*
otr_decrypt_message(const char* const from, const char* const message, gboolean* decrypted)
{
char* newmessage = NULL;
OtrlTLV* tlvs = NULL;
int result = otrlib_decrypt_message(user_state, &ops, jid, from, message, &newmessage, &tlvs);
// internal libotr message
if (result == 1) {
ConnContext* context = otrlib_context_find(user_state, from, jid);
// common tlv handling
OtrlTLV* tlv = otrl_tlv_find(tlvs, OTRL_TLV_DISCONNECTED);
if (tlv) {
if (context) {
otrl_context_force_plaintext(context);
ProfChatWin* chatwin = wins_get_chat(from);
if (chatwin) {
chatwin_otr_unsecured(chatwin);
}
}
}
// library version specific tlv handling
otrlib_handle_tlvs(user_state, &ops, context, tlvs, smp_initiators);
_otr_tlv_free(tlvs);
return NULL;
// message was processed, return to user
} else if (newmessage) {
_otr_tlv_free(tlvs);
if (g_str_has_prefix(message, "?OTR:")) {
*decrypted = TRUE;
}
return newmessage;
// normal non OTR message
} else {
_otr_tlv_free(tlvs);
*decrypted = FALSE;
return strdup(message);
}
}
void
otr_free_message(char* message)
{
otrl_message_free(message);
}
View Git Blame Copy Permalink