source: otr.c @ 6d9f0ba

Last change on this file since 6d9f0ba was 6d9f0ba, checked in by unknown <pesco@…>, at 2013-08-02T11:15:21Z

implement otr_error_message callback
  • Property mode set to 100644
File size: 51.5 KB
Line 
1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2012 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/*
8  OTR support (cf. http://www.cypherpunks.ca/otr/)
9 
10  (c) 2008-2011,2013 Sven Moritz Hallberg <pesco@khjk.org>
11  funded by stonedcoder.org
12   
13  files used to store OTR data:
14    <configdir>/<nick>.otr_keys
15    <configdir>/<nick>.otr_fprints
16   
17  top-level todos: (search for TODO for more ;-))
18    integrate otr_load/otr_save with existing storage backends
19    per-account policy settings
20    per-user policy settings
21*/
22
23/*
24  This program is free software; you can redistribute it and/or modify
25  it under the terms of the GNU General Public License as published by
26  the Free Software Foundation; either version 2 of the License, or
27  (at your option) any later version.
28
29  This program is distributed in the hope that it will be useful,
30  but WITHOUT ANY WARRANTY; without even the implied warranty of
31  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
32  GNU General Public License for more details.
33
34  You should have received a copy of the GNU General Public License with
35  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
36  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
37  Suite 330, Boston, MA  02111-1307  USA
38*/
39
40#include "bitlbee.h"
41#include "irc.h"
42#include "otr.h"
43#include <sys/types.h>
44#include <sys/wait.h>
45#include <unistd.h>
46#include <assert.h>
47#include <signal.h>
48
49
50/** OTR interface routines for the OtrlMessageAppOps struct: **/
51
52OtrlPolicy op_policy(void *opdata, ConnContext *context);
53
54void op_create_privkey(void *opdata, const char *accountname, const char *protocol);
55
56int op_is_logged_in(void *opdata, const char *accountname, const char *protocol,
57        const char *recipient);
58
59void op_inject_message(void *opdata, const char *accountname, const char *protocol,
60        const char *recipient, const char *message);
61
62void op_new_fingerprint(void *opdata, OtrlUserState us, const char *accountname,
63        const char *protocol, const char *username, unsigned char fingerprint[20]);
64
65void op_write_fingerprints(void *opdata);
66
67void op_gone_secure(void *opdata, ConnContext *context);
68
69void op_gone_insecure(void *opdata, ConnContext *context);
70
71void op_still_secure(void *opdata, ConnContext *context, int is_reply);
72
73void op_log_message(void *opdata, const char *message);
74
75int op_max_message_size(void *opdata, ConnContext *context);
76
77const char *op_account_name(void *opdata, const char *account, const char *protocol);
78
79void op_convert_msg(void *opdata, ConnContext *ctx, OtrlConvertType typ,
80        char **dst, const char *src);
81void op_convert_free(void *opdata, ConnContext *ctx, char *msg);
82
83void op_handle_smp_event(void *opdata, OtrlSMPEvent ev, ConnContext *ctx,
84        unsigned short percent, char *question);
85
86void op_handle_msg_event(void *opdata, OtrlMessageEvent ev, ConnContext *ctx,
87        const char *message, gcry_error_t err);
88
89const char *op_otr_error_message(void *opdata, ConnContext *ctx,
90        OtrlErrorCode err_code);
91
92/** otr sub-command handlers: **/
93
94static void cmd_otr(irc_t *irc, char **args);
95void cmd_otr_connect(irc_t *irc, char **args);
96void cmd_otr_disconnect(irc_t *irc, char **args);
97void cmd_otr_reconnect(irc_t *irc, char **args);
98void cmd_otr_smp(irc_t *irc, char **args);
99void cmd_otr_smpq(irc_t *irc, char **args);
100void cmd_otr_trust(irc_t *irc, char **args);
101void cmd_otr_info(irc_t *irc, char **args);
102void cmd_otr_keygen(irc_t *irc, char **args);
103void cmd_otr_forget(irc_t *irc, char **args);
104
105const command_t otr_commands[] = {
106        { "connect",     1, &cmd_otr_connect,    0 },
107        { "disconnect",  1, &cmd_otr_disconnect, 0 },
108        { "reconnect",   1, &cmd_otr_reconnect,  0 },
109        { "smp",         2, &cmd_otr_smp,        0 },
110        { "smpq",        3, &cmd_otr_smpq,       0 },
111        { "trust",       6, &cmd_otr_trust,      0 },
112        { "info",        0, &cmd_otr_info,       0 },
113        { "keygen",      1, &cmd_otr_keygen,     0 },
114        { "forget",      2, &cmd_otr_forget,     0 },
115        { NULL }
116};
117
118typedef struct {
119        void *fst;
120        void *snd;
121} pair_t;       
122
123static OtrlMessageAppOps otr_ops;   /* collects interface functions required by OTR */
124
125
126/** misc. helpers/subroutines: **/
127
128/* check whether we are already generating a key for a given account */
129int keygen_in_progress(irc_t *irc, const char *handle, const char *protocol);
130
131/* start background process to generate a (new) key for a given account */
132void otr_keygen(irc_t *irc, const char *handle, const char *protocol);
133
134/* main function for the forked keygen slave */
135void keygen_child_main(OtrlUserState us, int infd, int outfd);
136
137/* mainloop handler for when a keygen finishes */
138gboolean keygen_finish_handler(gpointer data, gint fd, b_input_condition cond);
139
140/* copy the contents of file a to file b, overwriting it if it exists */
141void copyfile(const char *a, const char *b);
142
143/* read one line of input from a stream, excluding trailing newline */
144void myfgets(char *s, int size, FILE *stream);
145
146/* some yes/no handlers */
147void yes_keygen(void *data);
148void yes_forget_fingerprint(void *data);
149void yes_forget_context(void *data);
150void yes_forget_key(void *data);
151
152/* helper to make sure accountname and protocol match the incoming "opdata" */
153struct im_connection *check_imc(void *opdata, const char *accountname,
154        const char *protocol);
155
156/* determine the nick for a given handle/protocol pair
157   returns "handle/protocol" if not found */
158const char *peernick(irc_t *irc, const char *handle, const char *protocol);
159
160/* turn a hexadecimal digit into its numerical value */
161int hexval(char a);
162
163/* determine the irc_user_t for a given handle/protocol pair
164   returns NULL if not found */
165irc_user_t *peeruser(irc_t *irc, const char *handle, const char *protocol);
166
167/* show an otr-related message to the user */
168void display_otr_message(void *opdata, ConnContext *ctx, const char *fmt, ...);
169
170/* write an otr-related message to the system log */
171void log_otr_message(void *opdata, const char *fmt, ...);
172
173/* combined handler for the 'otr smp' and 'otr smpq' commands */
174void otr_smp_or_smpq(irc_t *irc, const char *nick, const char *question,
175                const char *secret);
176
177/* update flags within the irc_user structure to reflect OTR status of context */
178void otr_update_uflags(ConnContext *context, irc_user_t *u);
179
180/* update op/voice flag of given user according to encryption state and settings
181   returns 0 if neither op_buddies nor voice_buddies is set to "encrypted",
182   i.e. msgstate should be announced seperately */
183int otr_update_modeflags(irc_t *irc, irc_user_t *u);
184
185/* show general info about the OTR subsystem; called by 'otr info' */
186void show_general_otr_info(irc_t *irc);
187
188/* show info about a given OTR context */
189void show_otr_context_info(irc_t *irc, ConnContext *ctx);
190
191/* show the list of fingerprints associated with a given context */
192void show_fingerprints(irc_t *irc, ConnContext *ctx);
193
194/* find a fingerprint by prefix (given as any number of hex strings) */
195Fingerprint *match_fingerprint(irc_t *irc, ConnContext *ctx, const char **args);
196
197/* find a private key by fingerprint prefix (given as any number of hex strings) */
198OtrlPrivKey *match_privkey(irc_t *irc, const char **args);
199
200/* check whether a string is safe to use in a path component */
201int strsane(const char *s);
202
203/* functions to be called for certain events */
204static const struct irc_plugin otr_plugin;
205
206
207/*** routines declared in otr.h: ***/
208
209#ifdef OTR_BI
210#define init_plugin otr_init
211#endif
212
213void init_plugin(void)
214{
215        OTRL_INIT;
216       
217        /* fill global OtrlMessageAppOps */
218        otr_ops.policy = &op_policy;
219        otr_ops.create_privkey = &op_create_privkey;
220        otr_ops.is_logged_in = &op_is_logged_in;
221        otr_ops.inject_message = &op_inject_message;
222        otr_ops.update_context_list = NULL;
223        otr_ops.new_fingerprint = &op_new_fingerprint;
224        otr_ops.write_fingerprints = &op_write_fingerprints;
225        otr_ops.gone_secure = &op_gone_secure;
226        otr_ops.gone_insecure = &op_gone_insecure;
227        otr_ops.still_secure = &op_still_secure;
228        otr_ops.max_message_size = &op_max_message_size;
229        otr_ops.account_name = &op_account_name;
230        otr_ops.account_name_free = NULL;
231
232        /* stuff added with libotr 4.0.0 */
233        otr_ops.received_symkey = NULL;         /* we don't use the extra key */
234        otr_ops.otr_error_message = &op_otr_error_message;
235        otr_ops.otr_error_message_free = NULL;
236        otr_ops.resent_msg_prefix = NULL;       /* default: [resent] */
237        otr_ops.resent_msg_prefix_free = NULL;
238        otr_ops.handle_smp_event = &op_handle_smp_event;
239        otr_ops.handle_msg_event = &op_handle_msg_event;
240        otr_ops.create_instag = NULL;    // XXX
241        otr_ops.convert_msg = &op_convert_msg;
242        otr_ops.convert_free = &op_convert_free;
243        otr_ops.timer_control = NULL;    // XXX call otrl_message_poll reg'ly
244               
245        root_command_add( "otr", 1, cmd_otr, 0 );
246        register_irc_plugin( &otr_plugin );
247}
248
249gboolean otr_irc_new(irc_t *irc)
250{
251        set_t *s;
252        GSList *l;
253       
254        irc->otr = g_new0(otr_t, 1);
255        irc->otr->us = otrl_userstate_create();
256       
257        s = set_add( &irc->b->set, "otr_color_encrypted", "true", set_eval_bool, irc );
258       
259        s = set_add( &irc->b->set, "otr_policy", "opportunistic", set_eval_list, irc );
260        l = g_slist_prepend( NULL, "never" );
261        l = g_slist_prepend( l, "opportunistic" );
262        l = g_slist_prepend( l, "manual" );
263        l = g_slist_prepend( l, "always" );
264        s->eval_data = l;
265
266        s = set_add( &irc->b->set, "otr_does_html", "true", set_eval_bool, irc );
267       
268        return TRUE;
269}
270
271void otr_irc_free(irc_t *irc)
272{
273        otr_t *otr = irc->otr;
274        otrl_userstate_free(otr->us);
275        if(otr->keygen) {
276                kill(otr->keygen, SIGTERM);
277                waitpid(otr->keygen, NULL, 0);
278                /* TODO: remove stale keygen tempfiles */
279        }
280        if(otr->to)
281                fclose(otr->to);
282        if(otr->from)
283                fclose(otr->from);
284        while(otr->todo) {
285                kg_t *p = otr->todo;
286                otr->todo = p->next;
287                g_free(p);
288        }
289        g_free(otr);
290}
291
292void otr_load(irc_t *irc)
293{
294        char s[512];
295        account_t *a;
296        gcry_error_t e;
297        gcry_error_t enoent = gcry_error_from_errno(ENOENT);
298        int kg=0;
299
300        if(strsane(irc->user->nick)) {
301                g_snprintf(s, 511, "%s%s.otr_keys", global.conf->configdir, irc->user->nick);
302                e = otrl_privkey_read(irc->otr->us, s);
303                if(e && e!=enoent) {
304                        irc_rootmsg(irc, "otr load: %s: %s", s, gcry_strerror(e));
305                }
306                g_snprintf(s, 511, "%s%s.otr_fprints", global.conf->configdir, irc->user->nick);
307                e = otrl_privkey_read_fingerprints(irc->otr->us, s, NULL, NULL);
308                if(e && e!=enoent) {
309                        irc_rootmsg(irc, "otr load: %s: %s", s, gcry_strerror(e));
310                }
311        }
312       
313        /* check for otr keys on all accounts */
314        for(a=irc->b->accounts; a; a=a->next) {
315                kg = otr_check_for_key(a) || kg;
316        }
317        if(kg) {
318                irc_rootmsg(irc, "Notice: "
319                        "The accounts above do not have OTR encryption keys associated with them, yet. "
320                        "These keys are now being generated in the background. "
321                        "You will be notified as they are completed. "
322                        "It is not necessary to wait; "
323                        "BitlBee can be used normally during key generation. "
324                        "You may safely ignore this message if you don't know what OTR is. ;)");
325        }
326}
327
328void otr_save(irc_t *irc)
329{
330        char s[512];
331        gcry_error_t e;
332
333        if(strsane(irc->user->nick)) {
334                g_snprintf(s, 511, "%s%s.otr_fprints", global.conf->configdir, irc->user->nick);
335                e = otrl_privkey_write_fingerprints(irc->otr->us, s);
336                if(e) {
337                        irc_rootmsg(irc, "otr save: %s: %s", s, gcry_strerror(e));
338                }
339                chmod(s, 0600);
340        }
341}
342
343void otr_remove(const char *nick)
344{
345        char s[512];
346       
347        if(strsane(nick)) {
348                g_snprintf(s, 511, "%s%s.otr_keys", global.conf->configdir, nick);
349                unlink(s);
350                g_snprintf(s, 511, "%s%s.otr_fprints", global.conf->configdir, nick);
351                unlink(s);
352        }
353}
354
355void otr_rename(const char *onick, const char *nnick)
356{
357        char s[512], t[512];
358       
359        if(strsane(nnick) && strsane(onick)) {
360                g_snprintf(s, 511, "%s%s.otr_keys", global.conf->configdir, onick);
361                g_snprintf(t, 511, "%s%s.otr_keys", global.conf->configdir, nnick);
362                rename(s,t);
363                g_snprintf(s, 511, "%s%s.otr_fprints", global.conf->configdir, onick);
364                g_snprintf(t, 511, "%s%s.otr_fprints", global.conf->configdir, nnick);
365                rename(s,t);
366        }
367}
368
369int otr_check_for_key(account_t *a)
370{
371        irc_t *irc = a->bee->ui_data;
372        OtrlPrivKey *k;
373       
374        /* don't do OTR on certain (not classic IM) protocols, e.g. twitter */
375        if(a->prpl->options & OPT_NOOTR) {
376                return 0;
377        }
378       
379        k = otrl_privkey_find(irc->otr->us, a->user, a->prpl->name);
380        if(k) {
381                irc_rootmsg(irc, "otr: %s/%s ready", a->user, a->prpl->name);
382                return 0;
383        } if(keygen_in_progress(irc, a->user, a->prpl->name)) {
384                irc_rootmsg(irc, "otr: keygen for %s/%s already in progress", a->user, a->prpl->name);
385                return 0;
386        } else {
387                irc_rootmsg(irc, "otr: starting background keygen for %s/%s", a->user, a->prpl->name);
388                otr_keygen(irc, a->user, a->prpl->name);
389                return 1;
390        }
391}
392
393char *otr_filter_msg_in(irc_user_t *iu, char *msg, int flags)
394{
395        int ignore_msg;
396        char *newmsg = NULL;
397        OtrlTLV *tlvs = NULL;
398        irc_t *irc = iu->irc;
399        struct im_connection *ic = iu->bu->ic;
400       
401        /* don't do OTR on certain (not classic IM) protocols, e.g. twitter */
402        if(ic->acc->prpl->options & OPT_NOOTR) {
403                return msg;
404        }
405       
406        ignore_msg = otrl_message_receiving(irc->otr->us, &otr_ops, ic,
407                ic->acc->user, ic->acc->prpl->name, iu->bu->handle, msg, &newmsg,
408                &tlvs, NULL, NULL, NULL);
409
410        if(ignore_msg) {
411                /* this was an internal OTR protocol message */
412                return NULL;
413        } else if(!newmsg) {
414                /* this was a non-OTR message */
415                return msg;
416        } else {
417                /* we're done with the original msg, which will be caller-freed. */
418                return newmsg;
419        }
420}
421
422char *otr_filter_msg_out(irc_user_t *iu, char *msg, int flags)
423{       
424        int st;
425        char *otrmsg = NULL;
426        char *emsg = msg;           /* the message as we hand it to libotr */
427        ConnContext *ctx = NULL;
428        irc_t *irc = iu->irc;
429        struct im_connection *ic = iu->bu->ic;
430        otrl_instag_t instag = OTRL_INSTAG_MASTER; // XXX?
431
432        /* don't do OTR on certain (not classic IM) protocols, e.g. twitter */
433        if(ic->acc->prpl->options & OPT_NOOTR) {
434                return msg;
435        }
436
437        st = otrl_message_sending(irc->otr->us, &otr_ops, ic,
438                ic->acc->user, ic->acc->prpl->name, iu->bu->handle, instag,
439                emsg, NULL, &otrmsg, OTRL_FRAGMENT_SEND_ALL, &ctx, NULL, NULL);
440        /* in libotr 4.0.0 with OTRL_FRAGMENT_SEND_ALL, otrmsg must be passed
441         * but the value it gets carries no meaning. it can be set even though
442         * the message has been injected. */
443
444        if(emsg != msg) {
445                g_free(emsg);   /* we're done with this one */
446        }
447        if(st) {
448                /* TODO: Error reporting? */
449        }
450       
451        return NULL;
452}
453
454static const struct irc_plugin otr_plugin =
455{
456        otr_irc_new,
457        otr_irc_free,
458        otr_filter_msg_out,
459        otr_filter_msg_in,
460        otr_load,
461        otr_save,
462        otr_remove,
463};
464
465static void cmd_otr(irc_t *irc, char **args)
466{
467        const command_t *cmd;
468       
469        if(!args[0])
470                return;
471       
472        if(!args[1])
473                return;
474       
475        for(cmd=otr_commands; cmd->command; cmd++) {
476                if(strcmp(cmd->command, args[1]) == 0)
477                        break;
478        }
479       
480        if(!cmd->command) {
481                irc_rootmsg(irc, "%s: unknown subcommand \"%s\", see \x02help otr\x02",
482                        args[0], args[1]);
483                return;
484        }
485       
486        if(!args[cmd->required_parameters+1]) {
487                irc_rootmsg(irc, "%s %s: not enough arguments (%d req.)",
488                        args[0], args[1], cmd->required_parameters);
489                return;
490        }
491       
492        cmd->execute(irc, args+1);
493}
494
495
496/*** OTR "MessageAppOps" callbacks for global.otr_ui: ***/
497
498OtrlPolicy op_policy(void *opdata, ConnContext *context)
499{
500        struct im_connection *ic = check_imc(opdata, context->accountname, context->protocol);
501        irc_t *irc = ic->bee->ui_data;
502        const char *p;
503       
504        /* policy override during keygen: if we're missing the key for context but are currently
505           generating it, then that's as much as we can do. => temporarily return NEVER. */
506        if(keygen_in_progress(irc, context->accountname, context->protocol) &&
507           !otrl_privkey_find(irc->otr->us, context->accountname, context->protocol))
508                return OTRL_POLICY_NEVER;
509
510        p = set_getstr(&ic->bee->set, "otr_policy");
511        if(!strcmp(p, "never"))
512                return OTRL_POLICY_NEVER;
513        if(!strcmp(p, "opportunistic"))
514                return OTRL_POLICY_OPPORTUNISTIC;
515        if(!strcmp(p, "manual"))
516                return OTRL_POLICY_MANUAL;
517        if(!strcmp(p, "always"))
518                return OTRL_POLICY_ALWAYS;
519       
520        return OTRL_POLICY_OPPORTUNISTIC;
521}
522
523void op_create_privkey(void *opdata, const char *accountname,
524        const char *protocol)
525{
526        struct im_connection *ic = check_imc(opdata, accountname, protocol);
527        irc_t *irc = ic->bee->ui_data;
528       
529        /* will fail silently if keygen already in progress */
530        otr_keygen(irc, accountname, protocol);
531}
532
533int op_is_logged_in(void *opdata, const char *accountname,
534        const char *protocol, const char *recipient)
535{
536        struct im_connection *ic = check_imc(opdata, accountname, protocol);
537        bee_user_t *bu;
538
539        /* lookup the irc_user_t for the given recipient */
540        bu = bee_user_by_handle(ic->bee, ic, recipient);
541        if(bu) {
542                if(bu->flags & BEE_USER_ONLINE)
543                        return 1;
544                else
545                        return 0;
546        } else {
547                return -1;
548        }
549}
550
551void op_inject_message(void *opdata, const char *accountname,
552        const char *protocol, const char *recipient, const char *message)
553{
554        struct im_connection *ic = check_imc(opdata, accountname, protocol);
555        irc_t *irc = ic->bee->ui_data;
556
557        if (strcmp(accountname, recipient) == 0) {
558                /* huh? injecting messages to myself? */
559                irc_rootmsg(irc, "note to self: %s", message);
560        } else {
561                /* need to drop some consts here :-( */
562                /* TODO: get flags into op_inject_message?! */
563                ic->acc->prpl->buddy_msg(ic, (char *)recipient, (char *)message, 0);
564                /* ignoring return value :-/ */
565        }
566}
567
568void op_new_fingerprint(void *opdata, OtrlUserState us,
569        const char *accountname, const char *protocol,
570        const char *username, unsigned char fingerprint[20])
571{
572        struct im_connection *ic = check_imc(opdata, accountname, protocol);
573        irc_t *irc = ic->bee->ui_data;
574        irc_user_t *u = peeruser(irc, username, protocol);
575        char hunam[45];         /* anybody looking? ;-) */
576       
577        otrl_privkey_hash_to_human(hunam, fingerprint);
578        if(u) {
579                irc_usernotice(u, "new fingerprint: %s", hunam);
580        } else {
581                /* this case shouldn't normally happen */
582                irc_rootmsg(irc, "new fingerprint for %s/%s: %s",
583                        username, protocol, hunam);
584        }
585}
586
587void op_write_fingerprints(void *opdata)
588{
589        struct im_connection *ic = (struct im_connection *)opdata;
590        irc_t *irc = ic->bee->ui_data;
591
592        otr_save(irc);
593}
594
595void op_gone_secure(void *opdata, ConnContext *context)
596{
597        struct im_connection *ic =
598                check_imc(opdata, context->accountname, context->protocol);
599        irc_user_t *u;
600        irc_t *irc = ic->bee->ui_data;
601
602        u = peeruser(irc, context->username, context->protocol);
603        if(!u) {
604                log_message(LOGLVL_ERROR,
605                        "BUG: otr.c: op_gone_secure: irc_user_t for %s/%s/%s not found!",
606                        context->username, context->protocol, context->accountname);
607                return;
608        }
609       
610        otr_update_uflags(context, u);
611        if(!otr_update_modeflags(irc, u)) {
612                char *trust = u->flags & IRC_USER_OTR_TRUSTED ? "trusted" : "untrusted!";
613                irc_usernotice(u, "conversation is now off the record (%s)", trust);
614        }
615}
616
617void op_gone_insecure(void *opdata, ConnContext *context)
618{
619        struct im_connection *ic =
620                check_imc(opdata, context->accountname, context->protocol);
621        irc_t *irc = ic->bee->ui_data;
622        irc_user_t *u;
623
624        u = peeruser(irc, context->username, context->protocol);
625        if(!u) {
626                log_message(LOGLVL_ERROR,
627                        "BUG: otr.c: op_gone_insecure: irc_user_t for %s/%s/%s not found!",
628                        context->username, context->protocol, context->accountname);
629                return;
630        }
631        otr_update_uflags(context, u);
632        if(!otr_update_modeflags(irc, u))
633                irc_usernotice(u, "conversation is now in cleartext");
634}
635
636void op_still_secure(void *opdata, ConnContext *context, int is_reply)
637{
638        struct im_connection *ic =
639                check_imc(opdata, context->accountname, context->protocol);
640        irc_t *irc = ic->bee->ui_data;
641        irc_user_t *u;
642
643        u = peeruser(irc, context->username, context->protocol);
644        if(!u) {
645                log_message(LOGLVL_ERROR,
646                        "BUG: otr.c: op_still_secure: irc_user_t for %s/%s/%s not found!",
647                        context->username, context->protocol, context->accountname);
648                return;
649        }
650
651        otr_update_uflags(context, u);
652        if(!otr_update_modeflags(irc, u)) {
653                char *trust = u->flags & IRC_USER_OTR_TRUSTED ? "trusted" : "untrusted!";
654                irc_usernotice(u, "otr connection has been refreshed (%s)", trust);
655        }
656}
657
658int op_max_message_size(void *opdata, ConnContext *context)
659{
660        /* libotr 4.0.0 has a bug where it doesn't set opdata */
661        if(!opdata) {
662                /* crude fallback */
663                return 800;
664        }
665
666        struct im_connection *ic =
667                check_imc(opdata, context->accountname, context->protocol);
668 
669        return ic->acc->prpl->mms;
670}
671
672const char *op_account_name(void *opdata, const char *account, const char *protocol)
673{
674        struct im_connection *ic = (struct im_connection *)opdata;
675        irc_t *irc = ic->bee->ui_data;
676
677        return peernick(irc, account, protocol);
678}
679
680void op_convert_msg(void *opdata, ConnContext *ctx, OtrlConvertType typ,
681        char **dst, const char *src)
682{
683        struct im_connection *ic =
684                check_imc(opdata, ctx->accountname, ctx->protocol);
685        irc_t *irc = ic->bee->ui_data;
686        irc_user_t *iu = peeruser(irc, ctx->username, ctx->protocol);
687
688        if(typ == OTRL_CONVERT_RECEIVING) {
689                char *msg = g_strdup(src);
690
691                /* HTML decoding */
692                if(set_getbool(&ic->bee->set, "otr_does_html") &&
693                   !(ic->flags & OPT_DOES_HTML) &&
694                   set_getbool(&ic->bee->set, "strip_html")) {
695                        strip_html(msg);
696                        *dst = msg;
697                }
698
699                /* coloring */
700                if(set_getbool(&ic->bee->set, "otr_color_encrypted")) {
701                        int color;                /* color according to f'print trust */
702                        char *pre="", *sep="";    /* optional parts */
703                        const char *trust = ctx->active_fingerprint->trust;
704
705                        if(trust && trust[0] != '\0')
706                                color=3;   /* green */
707                        else
708                                color=5;   /* red */
709
710                        /* in a query window, keep "/me " uncolored at the beginning */
711                        if(g_strncasecmp(msg, "/me ", 4) == 0
712                           && irc_user_msgdest(iu) == irc->user->nick) {
713                                msg += 4;  /* skip */
714                                pre = "/me ";
715                        }
716
717                        /* comma in first place could mess with the color code */
718                        if(msg[0] == ',') {
719                            /* insert a space between color spec and message */
720                            sep = " ";
721                        }
722
723                        *dst = g_strdup_printf("%s\x03%.2d%s%s\x0F", pre,
724                                color, sep, msg);
725                        g_free(msg);
726                }
727        } else {
728                /* HTML encoding */
729                /* consider OTR plaintext to be HTML if otr_does_html is set */
730                if(ctx && ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED &&
731                   set_getbool(&ic->bee->set, "otr_does_html") &&
732                   (g_strncasecmp(src, "<html>", 6) != 0)) {
733                        *dst = escape_html(src);
734                }
735        }
736}
737
738void op_convert_free(void *opdata, ConnContext *ctx, char *msg)
739{
740        g_free(msg);
741}
742       
743/* Socialist Millionaires' Protocol */
744void op_handle_smp_event(void *opdata, OtrlSMPEvent ev, ConnContext *ctx,
745        unsigned short percent, char *question)
746{
747        struct im_connection *ic =
748                check_imc(opdata, ctx->accountname, ctx->protocol);
749        irc_t *irc = ic->bee->ui_data;
750        OtrlUserState us = irc->otr->us;
751        irc_user_t *u = peeruser(irc, ctx->username, ctx->protocol);
752
753        if(!u) return;
754
755        switch(ev) {
756        case OTRL_SMPEVENT_ASK_FOR_SECRET:
757                irc_rootmsg(irc, "smp: initiated by %s"
758                        " - respond with \x02otr smp %s <secret>\x02",
759                        u->nick, u->nick);
760                break;
761        case OTRL_SMPEVENT_ASK_FOR_ANSWER:
762                irc_rootmsg(irc, "smp: initiated by %s with question: \x02\"%s\"\x02", u->nick,
763                        question);
764                irc_rootmsg(irc, "smp: respond with \x02otr smp %s <answer>\x02",
765                        u->nick);
766                break;
767        case OTRL_SMPEVENT_CHEATED:
768                irc_rootmsg(irc, "smp %s: opponent violated protocol, aborting",
769                        u->nick);
770                otrl_message_abort_smp(us, &otr_ops, u->bu->ic, ctx);
771                otrl_sm_state_free(ctx->smstate);
772                break;
773        case OTRL_SMPEVENT_NONE:
774                break;
775        case OTRL_SMPEVENT_IN_PROGRESS:
776                break;
777        case OTRL_SMPEVENT_SUCCESS:
778                if(ctx->smstate->received_question) {
779                        irc_rootmsg(irc, "smp %s: correct answer, you are trusted",
780                                u->nick);
781                } else {
782                        irc_rootmsg(irc, "smp %s: secrets proved equal, fingerprint trusted",
783                                u->nick);
784                }
785                otrl_sm_state_free(ctx->smstate);
786                break;
787        case OTRL_SMPEVENT_FAILURE:
788                if(ctx->smstate->received_question) {
789                        irc_rootmsg(irc, "smp %s: wrong answer, you are not trusted",
790                                u->nick);
791                } else {
792                        irc_rootmsg(irc, "smp %s: secrets did not match, fingerprint not trusted",
793                                u->nick);
794                }
795                otrl_sm_state_free(ctx->smstate);
796                break;
797        case OTRL_SMPEVENT_ABORT:
798                irc_rootmsg(irc, "smp: received abort from %s", u->nick);
799                otrl_sm_state_free(ctx->smstate);
800                break;
801        case OTRL_SMPEVENT_ERROR:
802                irc_rootmsg(irc, "smp %s: protocol error, aborting",
803                        u->nick);
804                otrl_message_abort_smp(us, &otr_ops, u->bu->ic, ctx);
805                otrl_sm_state_free(ctx->smstate);
806                break;
807        }
808}
809
810void op_handle_msg_event(void *opdata, OtrlMessageEvent ev, ConnContext *ctx,
811        const char *message, gcry_error_t err)
812{
813        switch(ev) {
814        case OTRL_MSGEVENT_ENCRYPTION_REQUIRED:
815                display_otr_message(opdata, ctx,
816                        "policy requires encryption - message not sent");
817                break;
818        case OTRL_MSGEVENT_ENCRYPTION_ERROR:
819                display_otr_message(opdata, ctx,
820                        "error during encryption - message not sent");
821                break;
822        case OTRL_MSGEVENT_CONNECTION_ENDED:
823                display_otr_message(opdata, ctx,
824                        "other end has disconnected OTR - "
825                        "close connection or reconnect!");
826                break;
827        case OTRL_MSGEVENT_SETUP_ERROR:
828                display_otr_message(opdata, ctx,
829                        "OTR connection failed: %s", gcry_strerror(err));
830                break;
831        case OTRL_MSGEVENT_MSG_REFLECTED:
832                display_otr_message(opdata, ctx,
833                        "received our own OTR message (!?)");
834                break;
835        case OTRL_MSGEVENT_MSG_RESENT:
836                display_otr_message(opdata, ctx,
837                        "the previous message was resent");
838                break;
839        case OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE:
840                display_otr_message(opdata, ctx,
841                        "unexpected encrypted message received");
842                break;
843        case OTRL_MSGEVENT_RCVDMSG_UNREADABLE:
844                display_otr_message(opdata, ctx,
845                        "unreadable encrypted message received");
846                break;
847        case OTRL_MSGEVENT_RCVDMSG_MALFORMED:
848                display_otr_message(opdata, ctx,
849                        "malformed OTR message received");
850                break;
851        case OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR:
852                display_otr_message(opdata, ctx,
853                        "OTR error message received: %s", message);
854                break;
855        case OTRL_MSGEVENT_RCVDMSG_UNENCRYPTED:
856                display_otr_message(opdata, ctx,
857                        "unencrypted message received: %s", message);
858                break;
859        case OTRL_MSGEVENT_RCVDMSG_UNRECOGNIZED:
860                display_otr_message(opdata, ctx,
861                        "unrecognized OTR message received");
862                break;
863        default:
864                /* ignore  XXX log? */
865                break;
866        }
867}
868
869const char *op_otr_error_message(void *opdata, ConnContext *ctx,
870        OtrlErrorCode err_code)
871{
872        switch(err_code) {
873        case OTRL_ERRCODE_ENCRYPTION_ERROR:
874                return "i failed to encrypt a message";
875        case OTRL_ERRCODE_MSG_NOT_IN_PRIVATE:
876                return "you sent an encrypted message i didn't expect";
877        case OTRL_ERRCODE_MSG_UNREADABLE:
878                return "could not read encrypted message";
879        case OTRL_ERRCODE_MSG_MALFORMED:
880                return "you sent a malformed OTR message";
881        default:
882                return "i suffered an unexpected OTR error";
883        }
884}
885
886
887
888/*** OTR sub-command handlers ***/
889
890void cmd_otr_reconnect(irc_t *irc, char **args)
891{
892        cmd_otr_disconnect(irc, args);
893        cmd_otr_connect(irc, args);
894}
895
896void cmd_otr_disconnect(irc_t *irc, char **args)
897{
898        irc_user_t *u;
899
900        u = irc_user_by_name(irc, args[1]);
901        if(!u || !u->bu || !u->bu->ic) {
902                irc_rootmsg(irc, "%s: unknown user", args[1]);
903                return;
904        }
905       
906        /* XXX we disconnect all instances; is that what we want? */
907        otrl_message_disconnect_all_instances(irc->otr->us, &otr_ops,
908                u->bu->ic, u->bu->ic->acc->user, u->bu->ic->acc->prpl->name, u->bu->handle);
909       
910        /* for some reason, libotr (4.0.0) doesn't do this itself: */
911        if(!(u->flags & IRC_USER_OTR_ENCRYPTED))
912                return;
913
914        ConnContext *ctx, *p;
915        ctx = otrl_context_find(irc->otr->us, u->bu->handle, u->bu->ic->acc->user,
916                u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);
917        if(!ctx) { /* huh? */
918                u->flags &= ( IRC_USER_OTR_ENCRYPTED | IRC_USER_OTR_TRUSTED );
919                return;
920        }
921
922        for(p=ctx; p && p->m_context == ctx->m_context; p=p->next)
923                op_gone_insecure(u->bu->ic, p);
924}
925
926void cmd_otr_connect(irc_t *irc, char **args)
927{
928        irc_user_t *u;
929
930        u = irc_user_by_name(irc, args[1]);
931        if(!u || !u->bu || !u->bu->ic) {
932                irc_rootmsg(irc, "%s: unknown user", args[1]);
933                return;
934        }
935        if(!(u->bu->flags & BEE_USER_ONLINE)) {
936                irc_rootmsg(irc, "%s is offline", args[1]);
937                return;
938        }
939       
940        bee_user_msg(irc->b, u->bu, "?OTR?v2?", 0);
941}
942
943void cmd_otr_smp(irc_t *irc, char **args)
944{
945        otr_smp_or_smpq(irc, args[1], NULL, args[2]);   /* no question */
946}
947
948void cmd_otr_smpq(irc_t *irc, char **args)
949{
950        otr_smp_or_smpq(irc, args[1], args[2], args[3]);
951}
952
953void cmd_otr_trust(irc_t *irc, char **args)
954{
955        irc_user_t *u;
956        ConnContext *ctx;
957        unsigned char raw[20];
958        Fingerprint *fp;
959        int i,j;
960       
961        u = irc_user_by_name(irc, args[1]);
962        if(!u || !u->bu || !u->bu->ic) {
963                irc_rootmsg(irc, "%s: unknown user", args[1]);
964                return;
965        }
966       
967        ctx = otrl_context_find(irc->otr->us, u->bu->handle,
968                u->bu->ic->acc->user, u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);  // XXX
969        if(!ctx) {
970                irc_rootmsg(irc, "%s: no otr context with user", args[1]);
971                return;
972        }
973       
974        /* convert given fingerprint to raw representation */
975        for(i=0; i<5; i++) {
976                for(j=0; j<4; j++) {
977                        char *p = args[2+i]+(2*j);
978                        char *q = p+1;
979                        int x, y;
980                       
981                        if(!*p || !*q) {
982                                irc_rootmsg(irc, "failed: truncated fingerprint block %d", i+1);
983                                return;
984                        }
985                       
986                        x = hexval(*p);
987                        y = hexval(*q);
988                        if(x<0) {
989                                irc_rootmsg(irc, "failed: %d. hex digit of block %d out of range", 2*j+1, i+1);
990                                return;
991                        }
992                        if(y<0) {
993                                irc_rootmsg(irc, "failed: %d. hex digit of block %d out of range", 2*j+2, i+1);
994                                return;
995                        }
996
997                        raw[i*4+j] = x*16 + y;
998                }
999        }
1000        fp = otrl_context_find_fingerprint(ctx, raw, 0, NULL);
1001        if(!fp) {
1002                irc_rootmsg(irc, "failed: no such fingerprint for %s", args[1]);
1003        } else {
1004                char *trust = args[7] ? args[7] : "affirmed";
1005                otrl_context_set_trust(fp, trust);
1006                irc_rootmsg(irc, "fingerprint match, trust set to \"%s\"", trust);
1007                if(u->flags & IRC_USER_OTR_ENCRYPTED)
1008                        u->flags |= IRC_USER_OTR_TRUSTED;
1009                otr_update_modeflags(irc, u);
1010        }
1011}
1012
1013void cmd_otr_info(irc_t *irc, char **args)
1014{
1015        if(!args[1]) {
1016                show_general_otr_info(irc);
1017        } else {
1018                char *arg = g_strdup(args[1]);
1019                char *myhandle, *handle=NULL, *protocol;
1020                ConnContext *ctx;
1021               
1022                /* interpret arg as 'user/protocol/account' if possible */
1023                protocol = strchr(arg, '/');
1024                myhandle = NULL;
1025                if(protocol) {
1026                        *(protocol++) = '\0';
1027                        myhandle = strchr(protocol, '/');
1028                }
1029                if(protocol && myhandle) {
1030                        *(myhandle++) = '\0';
1031                        handle = arg;
1032                        ctx = otrl_context_find(irc->otr->us, handle, myhandle, protocol, 0, OTRL_INSTAG_MASTER, NULL, NULL, NULL);  // XXX
1033                        if(!ctx) {
1034                                irc_rootmsg(irc, "no such context");
1035                                g_free(arg);
1036                                return;
1037                        }
1038                } else {
1039                        irc_user_t *u = irc_user_by_name(irc, args[1]);
1040                        if(!u || !u->bu || !u->bu->ic) {
1041                                irc_rootmsg(irc, "%s: unknown user", args[1]);
1042                                g_free(arg);
1043                                return;
1044                        }
1045                        ctx = otrl_context_find(irc->otr->us, u->bu->handle, u->bu->ic->acc->user,
1046                                u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);  // XXX
1047                        if(!ctx) {
1048                                irc_rootmsg(irc, "no otr context with %s", args[1]);
1049                                g_free(arg);
1050                                return;
1051                        }
1052                }
1053       
1054                /* show how we resolved the (nick) argument, if we did */
1055                if(handle!=arg) {
1056                        irc_rootmsg(irc, "%s is %s/%s; we are %s/%s to them", args[1],
1057                                ctx->username, ctx->protocol, ctx->accountname, ctx->protocol);
1058                }
1059                show_otr_context_info(irc, ctx);
1060                g_free(arg);
1061        }
1062}
1063
1064void cmd_otr_keygen(irc_t *irc, char **args)
1065{
1066        int i, n;
1067        account_t *a;
1068       
1069        n = atoi(args[1]);
1070        if(n<0 || (!n && strcmp(args[1], "0"))) {
1071                irc_rootmsg(irc, "%s: invalid account number", args[1]);
1072                return;
1073        }
1074       
1075        a = irc->b->accounts;
1076        for(i=0; i<n && a; i++, a=a->next);
1077        if(!a) {
1078                irc_rootmsg(irc, "%s: no such account", args[1]);
1079                return;
1080        }
1081       
1082        if(keygen_in_progress(irc, a->user, a->prpl->name)) {
1083                irc_rootmsg(irc, "keygen for account %d already in progress", n);
1084                return;
1085        }
1086       
1087        if(otrl_privkey_find(irc->otr->us, a->user, a->prpl->name)) {
1088                char *s = g_strdup_printf("account %d already has a key, replace it?", n);
1089                query_add(irc, NULL, s, yes_keygen, NULL, NULL, a);
1090                g_free(s);
1091        } else {
1092                otr_keygen(irc, a->user, a->prpl->name);
1093        }
1094}
1095
1096void yes_forget_fingerprint(void *data)
1097{
1098        pair_t *p = (pair_t *)data;
1099        irc_t *irc = (irc_t *)p->fst;
1100        Fingerprint *fp = (Fingerprint *)p->snd;
1101
1102        g_free(p);
1103       
1104        if(fp == fp->context->active_fingerprint) {
1105                irc_rootmsg(irc, "that fingerprint is active, terminate otr connection first");
1106                return;
1107        }
1108               
1109        otrl_context_forget_fingerprint(fp, 0);
1110}
1111
1112void yes_forget_context(void *data)
1113{
1114        pair_t *p = (pair_t *)data;
1115        irc_t *irc = (irc_t *)p->fst;
1116        ConnContext *ctx = (ConnContext *)p->snd;
1117
1118        g_free(p);
1119       
1120        if(ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED) {
1121                irc_rootmsg(irc, "active otr connection with %s, terminate it first",
1122                        peernick(irc, ctx->username, ctx->protocol));
1123                return;
1124        }
1125               
1126        if(ctx->msgstate == OTRL_MSGSTATE_FINISHED)
1127                otrl_context_force_plaintext(ctx);
1128        otrl_context_forget(ctx);
1129}
1130
1131void yes_forget_key(void *data)
1132{
1133        OtrlPrivKey *key = (OtrlPrivKey *)data;
1134       
1135        otrl_privkey_forget(key);
1136        /* Hm, libotr doesn't seem to offer a function for explicitly /writing/
1137           keyfiles. So the key will be back on the next load... */
1138        /* TODO: Actually erase forgotten keys from storage? */
1139}
1140
1141void cmd_otr_forget(irc_t *irc, char **args)
1142{
1143        if(!strcmp(args[1], "fingerprint"))
1144        {
1145                irc_user_t *u;
1146                ConnContext *ctx;
1147                Fingerprint *fp;
1148                char human[54];
1149                char *s;
1150                pair_t *p;
1151               
1152                if(!args[3]) {
1153                        irc_rootmsg(irc, "otr %s %s: not enough arguments (2 req.)", args[0], args[1]);
1154                        return;
1155                }
1156               
1157                /* TODO: allow context specs ("user/proto/account") in 'otr forget fingerprint'? */
1158                u = irc_user_by_name(irc, args[2]);
1159                if(!u || !u->bu || !u->bu->ic) {
1160                        irc_rootmsg(irc, "%s: unknown user", args[2]);
1161                        return;
1162                }
1163               
1164                ctx = otrl_context_find(irc->otr->us, u->bu->handle, u->bu->ic->acc->user,
1165                        u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);  // XXX
1166                if(!ctx) {
1167                        irc_rootmsg(irc, "no otr context with %s", args[2]);
1168                        return;
1169                }
1170               
1171                fp = match_fingerprint(irc, ctx, ((const char **)args)+3);
1172                if(!fp) {
1173                        /* match_fingerprint does error messages */
1174                        return;
1175                }
1176               
1177                if(fp == ctx->active_fingerprint) {
1178                        irc_rootmsg(irc, "that fingerprint is active, terminate otr connection first");
1179                        return;
1180                }
1181               
1182                otrl_privkey_hash_to_human(human, fp->fingerprint);
1183                s = g_strdup_printf("about to forget fingerprint %s, are you sure?", human);
1184                p = g_malloc(sizeof(pair_t));
1185                if(!p)
1186                        return;
1187                p->fst = irc;
1188                p->snd = fp;
1189                query_add(irc, NULL, s, yes_forget_fingerprint, NULL, NULL, p);
1190                g_free(s);
1191        }
1192       
1193        else if(!strcmp(args[1], "context"))
1194        {
1195                irc_user_t *u;
1196                ConnContext *ctx;
1197                char *s;
1198                pair_t *p;
1199               
1200                /* TODO: allow context specs ("user/proto/account") in 'otr forget contex'? */
1201                u = irc_user_by_name(irc, args[2]);
1202                if(!u || !u->bu || !u->bu->ic) {
1203                        irc_rootmsg(irc, "%s: unknown user", args[2]);
1204                        return;
1205                }
1206               
1207                ctx = otrl_context_find(irc->otr->us, u->bu->handle, u->bu->ic->acc->user,
1208                        u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);  // XXX
1209                if(!ctx) {
1210                        irc_rootmsg(irc, "no otr context with %s", args[2]);
1211                        return;
1212                }
1213               
1214                if(ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED) {
1215                        irc_rootmsg(irc, "active otr connection with %s, terminate it first", args[2]);
1216                        return;
1217                }
1218               
1219                s = g_strdup_printf("about to forget otr data about %s, are you sure?", args[2]);
1220                p = g_malloc(sizeof(pair_t));
1221                if(!p)
1222                        return;
1223                p->fst = irc;
1224                p->snd = ctx;
1225                query_add(irc, NULL, s, yes_forget_context, NULL, NULL, p);
1226                g_free(s);
1227        }
1228       
1229        else if(!strcmp(args[1], "key"))
1230        {
1231                OtrlPrivKey *key;
1232                char *s;
1233               
1234                key = match_privkey(irc, ((const char **)args)+2);
1235                if(!key) {
1236                        /* match_privkey does error messages */
1237                        return;
1238                }
1239               
1240                s = g_strdup_printf("about to forget the private key for %s/%s, are you sure?",
1241                        key->accountname, key->protocol);
1242                query_add(irc, NULL, s, yes_forget_key, NULL, NULL, key);
1243                g_free(s);
1244        }
1245       
1246        else
1247        {
1248                irc_rootmsg(irc, "otr %s: unknown subcommand \"%s\", see \x02help otr forget\x02",
1249                        args[0], args[1]);
1250        }
1251}
1252
1253
1254/*** local helpers / subroutines: ***/
1255
1256void log_otr_message(void *opdata, const char *fmt, ...)
1257{
1258        va_list va;
1259
1260        va_start(va, fmt);
1261        char *msg = g_strdup_vprintf(fmt, va);
1262        va_end(va);
1263       
1264        log_message(LOGLVL_INFO, "otr: %s", msg);
1265}
1266
1267void display_otr_message(void *opdata, ConnContext *ctx, const char *fmt, ...)
1268{
1269        struct im_connection *ic =
1270                check_imc(opdata, ctx->accountname, ctx->protocol);
1271        irc_t *irc = ic->bee->ui_data;
1272        irc_user_t *u = peeruser(irc, ctx->username, ctx->protocol);
1273        va_list va;
1274
1275        va_start(va, fmt);
1276        char *msg = g_strdup_vprintf(fmt, va);
1277        va_end(va);
1278
1279        if(u) {
1280                /* display as a notice from this particular user */
1281                irc_usernotice(u, "%s", msg);
1282        } else {
1283                irc_rootmsg(irc, "[otr] %s", msg);
1284        }
1285
1286        g_free(msg);
1287}
1288
1289/* combined handler for the 'otr smp' and 'otr smpq' commands */
1290void otr_smp_or_smpq(irc_t *irc, const char *nick, const char *question,
1291                const char *secret)
1292{
1293        irc_user_t *u;
1294        ConnContext *ctx;
1295
1296        u = irc_user_by_name(irc, nick);
1297        if(!u || !u->bu || !u->bu->ic) {
1298                irc_rootmsg(irc, "%s: unknown user", nick);
1299                return;
1300        }
1301        if(!(u->bu->flags & BEE_USER_ONLINE)) {
1302                irc_rootmsg(irc, "%s is offline", nick);
1303                return;
1304        }
1305       
1306        ctx = otrl_context_find(irc->otr->us, u->bu->handle,
1307                u->bu->ic->acc->user, u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);  // XXX
1308        if(!ctx || ctx->msgstate != OTRL_MSGSTATE_ENCRYPTED) {
1309                irc_rootmsg(irc, "smp: otr inactive with %s, try \x02otr connect"
1310                                " %s\x02", nick, nick);
1311                return;
1312        }
1313
1314        if(ctx->smstate->nextExpected != OTRL_SMP_EXPECT1) {
1315                log_message(LOGLVL_INFO,
1316                        "SMP already in phase %d, sending abort before reinitiating",
1317                        ctx->smstate->nextExpected+1);
1318                otrl_message_abort_smp(irc->otr->us, &otr_ops, u->bu->ic, ctx);
1319                otrl_sm_state_free(ctx->smstate);
1320        }
1321
1322        if(question) {
1323                /* this was 'otr smpq', just initiate */
1324                irc_rootmsg(irc, "smp: initiating with %s...", u->nick);
1325                otrl_message_initiate_smp_q(irc->otr->us, &otr_ops, u->bu->ic, ctx,
1326                        question, (unsigned char *)secret, strlen(secret));
1327                /* smp is now in EXPECT2 */
1328        } else {
1329                /* this was 'otr smp', initiate or reply */
1330                /* warning: the following assumes that smstates are cleared whenever an SMP
1331                   is completed or aborted! */ 
1332                if(ctx->smstate->secret == NULL) {
1333                        irc_rootmsg(irc, "smp: initiating with %s...", u->nick);
1334                        otrl_message_initiate_smp(irc->otr->us, &otr_ops,
1335                                u->bu->ic, ctx, (unsigned char *)secret, strlen(secret));
1336                        /* smp is now in EXPECT2 */
1337                } else {
1338                        /* if we're still in EXPECT1 but smstate is initialized, we must have
1339                           received the SMP1, so let's issue a response */
1340                        irc_rootmsg(irc, "smp: responding to %s...", u->nick);
1341                        otrl_message_respond_smp(irc->otr->us, &otr_ops,
1342                                u->bu->ic, ctx, (unsigned char *)secret, strlen(secret));
1343                        /* smp is now in EXPECT3 */
1344                }
1345        }
1346}
1347
1348/* helper to assert that account and protocol names given to ops below always
1349   match the im_connection passed through as opdata */
1350struct im_connection *check_imc(void *opdata, const char *accountname,
1351        const char *protocol)
1352{
1353        struct im_connection *ic = (struct im_connection *)opdata;
1354
1355        if (strcmp(accountname, ic->acc->user) != 0) {
1356                log_message(LOGLVL_WARNING,
1357                        "otr: internal account name mismatch: '%s' vs '%s'",
1358                        accountname, ic->acc->user);
1359        }
1360        if (strcmp(protocol, ic->acc->prpl->name) != 0) {
1361                log_message(LOGLVL_WARNING,
1362                        "otr: internal protocol name mismatch: '%s' vs '%s'",
1363                        protocol, ic->acc->prpl->name);
1364        }
1365       
1366        return ic;
1367}
1368
1369irc_user_t *peeruser(irc_t *irc, const char *handle, const char *protocol)
1370{
1371        GSList *l;
1372       
1373        for(l=irc->b->users; l; l = l->next) {
1374                bee_user_t *bu = l->data;
1375                struct prpl *prpl;
1376                if(!bu->ui_data || !bu->ic || !bu->handle)
1377                        continue;
1378                prpl = bu->ic->acc->prpl;
1379                if(strcmp(prpl->name, protocol) == 0
1380                        && prpl->handle_cmp(bu->handle, handle) == 0) {
1381                        return bu->ui_data;
1382                }
1383        }
1384       
1385        return NULL;
1386}
1387
1388int hexval(char a)
1389{
1390        int x=tolower(a);
1391       
1392        if(x>='a' && x<='f')
1393                x = x - 'a' + 10;
1394        else if(x>='0' && x<='9')
1395                x = x - '0';
1396        else
1397                return -1;
1398       
1399        return x;
1400}
1401
1402const char *peernick(irc_t *irc, const char *handle, const char *protocol)
1403{
1404        static char fallback[512];
1405       
1406        irc_user_t *u = peeruser(irc, handle, protocol);
1407        if(u) {
1408                return u->nick;
1409        } else {
1410                g_snprintf(fallback, 511, "%s/%s", handle, protocol);
1411                return fallback;
1412        }
1413}
1414
1415void otr_update_uflags(ConnContext *context, irc_user_t *u)
1416{
1417        const char *trust;
1418
1419        if(context->active_fingerprint) {
1420                u->flags |= IRC_USER_OTR_ENCRYPTED;
1421
1422                trust = context->active_fingerprint->trust;
1423                if(trust && trust[0])
1424                        u->flags |= IRC_USER_OTR_TRUSTED;
1425                else
1426                        u->flags &= ~IRC_USER_OTR_TRUSTED;
1427        } else {
1428                u->flags &= ~IRC_USER_OTR_ENCRYPTED;
1429        }
1430}
1431
1432int otr_update_modeflags(irc_t *irc, irc_user_t *u)
1433{
1434        return 0;
1435}
1436
1437void show_fingerprints(irc_t *irc, ConnContext *ctx)
1438{
1439        char human[45];
1440        Fingerprint *fp;
1441        const char *trust;
1442        int count=0;
1443       
1444        for(fp=&ctx->fingerprint_root; fp; fp=fp->next) {
1445                if(!fp->fingerprint)
1446                        continue;
1447                count++;
1448                otrl_privkey_hash_to_human(human, fp->fingerprint);
1449                if(!fp->trust || fp->trust[0] == '\0') {
1450                        trust="untrusted";
1451                } else {
1452                        trust=fp->trust;
1453                }
1454                if(fp == ctx->active_fingerprint) {
1455                        irc_rootmsg(irc, "    \x02%s (%s)\x02", human, trust);
1456                } else {
1457                        irc_rootmsg(irc, "    %s (%s)", human, trust);
1458                }
1459        }
1460        if(count==0)
1461                irc_rootmsg(irc, "    (none)");
1462}
1463
1464Fingerprint *match_fingerprint(irc_t *irc, ConnContext *ctx, const char **args)
1465{
1466        Fingerprint *fp, *fp2;
1467        char human[45];
1468        char prefix[45], *p;
1469        int n;
1470        int i,j;
1471       
1472        /* assemble the args into a prefix in standard "human" form */
1473        n=0;
1474        p=prefix;
1475        for(i=0; args[i]; i++) {
1476                for(j=0; args[i][j]; j++) {
1477                        char c = toupper(args[i][j]);
1478                       
1479                        if(n>=40) {
1480                                irc_rootmsg(irc, "too many fingerprint digits given, expected at most 40");
1481                                return NULL;
1482                        }
1483                       
1484                        if( (c>='A' && c<='F') || (c>='0' && c<='9') ) {
1485                                *(p++) = c;
1486                        } else {
1487                                irc_rootmsg(irc, "invalid hex digit '%c' in block %d", args[i][j], i+1);
1488                                return NULL;
1489                        }
1490                       
1491                        n++;
1492                        if(n%8 == 0)
1493                                *(p++) = ' ';
1494                }
1495        }
1496        *p = '\0';
1497       
1498        /* find first fingerprint with the given prefix */
1499        n = strlen(prefix);
1500        for(fp=&ctx->fingerprint_root; fp; fp=fp->next) {
1501                if(!fp->fingerprint)
1502                        continue;
1503                otrl_privkey_hash_to_human(human, fp->fingerprint);
1504                if(!strncmp(prefix, human, n))
1505                        break;
1506        }
1507        if(!fp) {
1508                irc_rootmsg(irc, "%s: no match", prefix);
1509                return NULL;
1510        }
1511       
1512        /* make sure the match, if any, is unique */
1513        for(fp2=fp->next; fp2; fp2=fp2->next) {
1514                if(!fp2->fingerprint)
1515                        continue;
1516                otrl_privkey_hash_to_human(human, fp2->fingerprint);
1517                if(!strncmp(prefix, human, n))
1518                        break;
1519        }
1520        if(fp2) {
1521                irc_rootmsg(irc, "%s: multiple matches", prefix);
1522                return NULL;
1523        }
1524       
1525        return fp;
1526}
1527
1528OtrlPrivKey *match_privkey(irc_t *irc, const char **args)
1529{
1530        OtrlPrivKey *k, *k2;
1531        char human[45];
1532        char prefix[45], *p;
1533        int n;
1534        int i,j;
1535       
1536        /* assemble the args into a prefix in standard "human" form */
1537        n=0;
1538        p=prefix;
1539        for(i=0; args[i]; i++) {
1540                for(j=0; args[i][j]; j++) {
1541                        char c = toupper(args[i][j]);
1542                       
1543                        if(n>=40) {
1544                                irc_rootmsg(irc, "too many fingerprint digits given, expected at most 40");
1545                                return NULL;
1546                        }
1547                       
1548                        if( (c>='A' && c<='F') || (c>='0' && c<='9') ) {
1549                                *(p++) = c;
1550                        } else {
1551                                irc_rootmsg(irc, "invalid hex digit '%c' in block %d", args[i][j], i+1);
1552                                return NULL;
1553                        }
1554                       
1555                        n++;
1556                        if(n%8 == 0)
1557                                *(p++) = ' ';
1558                }
1559        }
1560        *p = '\0';
1561       
1562        /* find first key which matches the given prefix */
1563        n = strlen(prefix);
1564        for(k=irc->otr->us->privkey_root; k; k=k->next) {
1565                p = otrl_privkey_fingerprint(irc->otr->us, human, k->accountname, k->protocol);
1566                if(!p) /* gah! :-P */
1567                        continue;
1568                if(!strncmp(prefix, human, n))
1569                        break;
1570        }
1571        if(!k) {
1572                irc_rootmsg(irc, "%s: no match", prefix);
1573                return NULL;
1574        }
1575       
1576        /* make sure the match, if any, is unique */
1577        for(k2=k->next; k2; k2=k2->next) {
1578                p = otrl_privkey_fingerprint(irc->otr->us, human, k2->accountname, k2->protocol);
1579                if(!p) /* gah! :-P */
1580                        continue;
1581                if(!strncmp(prefix, human, n))
1582                        break;
1583        }
1584        if(k2) {
1585                irc_rootmsg(irc, "%s: multiple matches", prefix);
1586                return NULL;
1587        }
1588       
1589        return k;
1590}
1591
1592void show_general_otr_info(irc_t *irc)
1593{
1594        ConnContext *ctx;
1595        OtrlPrivKey *key;
1596        char human[45];
1597        kg_t *kg;
1598
1599        /* list all privkeys (including ones being generated) */
1600        irc_rootmsg(irc, "\x1fprivate keys:\x1f");
1601        for(key=irc->otr->us->privkey_root; key; key=key->next) {
1602                const char *hash;
1603               
1604                switch(key->pubkey_type) {
1605                case OTRL_PUBKEY_TYPE_DSA:
1606                        irc_rootmsg(irc, "  %s/%s - DSA", key->accountname, key->protocol);
1607                        break;
1608                default:
1609                        irc_rootmsg(irc, "  %s/%s - type %d", key->accountname, key->protocol,
1610                                key->pubkey_type);
1611                }
1612
1613                /* No, it doesn't make much sense to search for the privkey again by
1614                   account/protocol, but libotr currently doesn't provide a direct routine
1615                   for hashing a given 'OtrlPrivKey'... */
1616                hash = otrl_privkey_fingerprint(irc->otr->us, human, key->accountname, key->protocol);
1617                if(hash) /* should always succeed */
1618                        irc_rootmsg(irc, "    %s", human);
1619        }
1620        if(irc->otr->sent_accountname) {
1621                irc_rootmsg(irc, "  %s/%s - DSA", irc->otr->sent_accountname,
1622                        irc->otr->sent_protocol);
1623                irc_rootmsg(irc, "    (being generated)");
1624        }
1625        for(kg=irc->otr->todo; kg; kg=kg->next) {
1626                irc_rootmsg(irc, "  %s/%s - DSA", kg->accountname, kg->protocol);
1627                irc_rootmsg(irc, "    (queued)");
1628        }
1629        if(key == irc->otr->us->privkey_root &&
1630           !irc->otr->sent_accountname &&
1631           kg == irc->otr->todo)
1632                irc_rootmsg(irc, "  (none)");
1633
1634        /* list all contexts */
1635        irc_rootmsg(irc, "%s", "");
1636        irc_rootmsg(irc, "\x1f" "connection contexts:\x1f (bold=currently encrypted)");
1637        for(ctx=irc->otr->us->context_root; ctx; ctx=ctx->next) {\
1638                irc_user_t *u;
1639                char *userstring;
1640               
1641                u = peeruser(irc, ctx->username, ctx->protocol);
1642                if(u)
1643                        userstring = g_strdup_printf("%s/%s/%s (%s)",
1644                                ctx->username, ctx->protocol, ctx->accountname, u->nick);
1645                else
1646                        userstring = g_strdup_printf("%s/%s/%s",
1647                                ctx->username, ctx->protocol, ctx->accountname);
1648               
1649                if(ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED) {
1650                        irc_rootmsg(irc, "  \x02%s\x02", userstring);
1651                } else {
1652                        irc_rootmsg(irc, "  %s", userstring);
1653                }
1654               
1655                g_free(userstring);
1656        }
1657        if(ctx == irc->otr->us->context_root)
1658                irc_rootmsg(irc, "  (none)");
1659}
1660
1661void show_otr_context_info(irc_t *irc, ConnContext *ctx)
1662{
1663        switch(ctx->otr_offer) {
1664        case OFFER_NOT:
1665                irc_rootmsg(irc, "  otr offer status: none sent");
1666                break;
1667        case OFFER_SENT:
1668                irc_rootmsg(irc, "  otr offer status: awaiting reply");
1669                break;
1670        case OFFER_ACCEPTED:
1671                irc_rootmsg(irc, "  otr offer status: accepted our offer");
1672                break;
1673        case OFFER_REJECTED:
1674                irc_rootmsg(irc, "  otr offer status: ignored our offer");
1675                break;
1676        default:
1677                irc_rootmsg(irc, "  otr offer status: %d", ctx->otr_offer);
1678        }
1679
1680        switch(ctx->msgstate) {
1681        case OTRL_MSGSTATE_PLAINTEXT:
1682                irc_rootmsg(irc, "  connection state: cleartext");
1683                break;
1684        case OTRL_MSGSTATE_ENCRYPTED:
1685                irc_rootmsg(irc, "  connection state: encrypted (v%d)", ctx->protocol_version);
1686                break;
1687        case OTRL_MSGSTATE_FINISHED:
1688                irc_rootmsg(irc, "  connection state: shut down");
1689                break;
1690        default:
1691                irc_rootmsg(irc, "  connection state: %d", ctx->msgstate);
1692        }
1693
1694        irc_rootmsg(irc, "  fingerprints: (bold=active)");     
1695        show_fingerprints(irc, ctx);
1696}
1697
1698int keygen_in_progress(irc_t *irc, const char *handle, const char *protocol)
1699{
1700        kg_t *kg;
1701       
1702        if(!irc->otr->sent_accountname || !irc->otr->sent_protocol)
1703                return 0;
1704
1705        /* are we currently working on this key? */
1706        if(!strcmp(handle, irc->otr->sent_accountname) &&
1707           !strcmp(protocol, irc->otr->sent_protocol))
1708                return 1;
1709       
1710        /* do we have it queued for later? */
1711        for(kg=irc->otr->todo; kg; kg=kg->next) {
1712                if(!strcmp(handle, kg->accountname) &&
1713                   !strcmp(protocol, kg->protocol))
1714                        return 1;
1715        }
1716       
1717        return 0;
1718}
1719
1720void otr_keygen(irc_t *irc, const char *handle, const char *protocol)
1721{
1722        /* do nothing if a key for the requested account is already being generated */
1723        if(keygen_in_progress(irc, handle, protocol))
1724                return;
1725
1726        /* see if we already have a keygen child running. if not, start one and put a
1727           handler on its output. */
1728        if(!irc->otr->keygen || waitpid(irc->otr->keygen, NULL, WNOHANG)) {
1729                pid_t p;
1730                int to[2], from[2];
1731                FILE *tof, *fromf;
1732               
1733                if(pipe(to) < 0 || pipe(from) < 0) {
1734                        irc_rootmsg(irc, "otr keygen: couldn't create pipe: %s", strerror(errno));
1735                        return;
1736                }
1737               
1738                tof = fdopen(to[1], "w");
1739                fromf = fdopen(from[0], "r");
1740                if(!tof || !fromf) {
1741                        irc_rootmsg(irc, "otr keygen: couldn't streamify pipe: %s", strerror(errno));
1742                        return;
1743                }
1744               
1745                p = fork();
1746                if(p<0) {
1747                        irc_rootmsg(irc, "otr keygen: couldn't fork: %s", strerror(errno));
1748                        return;
1749                }
1750               
1751                if(!p) {
1752                        /* child process */
1753                        signal(SIGTERM, exit);
1754                        keygen_child_main(irc->otr->us, to[0], from[1]);
1755                        exit(0);
1756                }
1757               
1758                irc->otr->keygen = p;
1759                irc->otr->to = tof;
1760                irc->otr->from = fromf;
1761                irc->otr->sent_accountname = NULL;
1762                irc->otr->sent_protocol = NULL;
1763                irc->otr->todo = NULL;
1764                b_input_add(from[0], B_EV_IO_READ, keygen_finish_handler, irc);
1765        }
1766       
1767        /* is the keygen slave currently working? */
1768        if(irc->otr->sent_accountname) {
1769                /* enqueue our job for later transmission */
1770                kg_t **kg = &irc->otr->todo;
1771                while(*kg)
1772                        kg=&((*kg)->next);
1773                *kg = g_new0(kg_t, 1);
1774                (*kg)->accountname = g_strdup(handle);
1775                (*kg)->protocol = g_strdup(protocol);
1776        } else {
1777                /* send our job over and remember it */
1778                fprintf(irc->otr->to, "%s\n%s\n", handle, protocol);
1779                fflush(irc->otr->to);
1780                irc->otr->sent_accountname = g_strdup(handle);
1781                irc->otr->sent_protocol = g_strdup(protocol);
1782        }
1783}
1784
1785void keygen_child_main(OtrlUserState us, int infd, int outfd)
1786{
1787        FILE *input, *output;
1788        char filename[128], accountname[512], protocol[512];
1789        gcry_error_t e;
1790        int tempfd;
1791       
1792        input = fdopen(infd, "r");
1793        output = fdopen(outfd, "w");
1794       
1795        while(!feof(input) && !ferror(input) && !feof(output) && !ferror(output)) {
1796                myfgets(accountname, 512, input);
1797                myfgets(protocol, 512, input);
1798               
1799                strncpy(filename, "/tmp/bitlbee-XXXXXX", 128);
1800                tempfd = mkstemp(filename);
1801                close(tempfd);
1802
1803                e = otrl_privkey_generate(us, filename, accountname, protocol);
1804                if(e) {
1805                        fprintf(output, "\n");  /* this means failure */
1806                        fprintf(output, "otr keygen: %s\n", gcry_strerror(e));
1807                        unlink(filename);
1808                } else {
1809                        fprintf(output, "%s\n", filename);
1810                        fprintf(output, "otr keygen for %s/%s complete\n", accountname, protocol);
1811                }
1812                fflush(output);
1813        }
1814       
1815        fclose(input);
1816        fclose(output);
1817}
1818
1819gboolean keygen_finish_handler(gpointer data, gint fd, b_input_condition cond)
1820{
1821        irc_t *irc = (irc_t *)data;
1822        char filename[512], msg[512];
1823
1824        myfgets(filename, 512, irc->otr->from);
1825        myfgets(msg, 512, irc->otr->from);
1826       
1827        irc_rootmsg(irc, "%s", msg);
1828        if(filename[0]) {
1829                if(strsane(irc->user->nick)) {
1830                        char *kf = g_strdup_printf("%s%s.otr_keys", global.conf->configdir, irc->user->nick);
1831                        char *tmp = g_strdup_printf("%s.new", kf);
1832                        copyfile(filename, tmp);
1833                        unlink(filename);
1834                        rename(tmp,kf);
1835                        otrl_privkey_read(irc->otr->us, kf);
1836                        g_free(kf);
1837                        g_free(tmp);
1838                } else {
1839                        otrl_privkey_read(irc->otr->us, filename);
1840                        unlink(filename);
1841                }
1842        }
1843       
1844        /* forget this job */
1845        g_free(irc->otr->sent_accountname);
1846        g_free(irc->otr->sent_protocol);
1847        irc->otr->sent_accountname = NULL;
1848        irc->otr->sent_protocol = NULL;
1849       
1850        /* see if there are any more in the queue */
1851        if(irc->otr->todo) {
1852                kg_t *p = irc->otr->todo;
1853                /* send the next one over */
1854                fprintf(irc->otr->to, "%s\n%s\n", p->accountname, p->protocol);
1855                fflush(irc->otr->to);
1856                irc->otr->sent_accountname = p->accountname;
1857                irc->otr->sent_protocol = p->protocol;
1858                irc->otr->todo = p->next;
1859                g_free(p);
1860                return TRUE;   /* keep watching */
1861        } else {
1862                /* okay, the slave is idle now, so kill him */
1863                fclose(irc->otr->from);
1864                fclose(irc->otr->to);
1865                irc->otr->from = irc->otr->to = NULL;
1866                kill(irc->otr->keygen, SIGTERM);
1867                waitpid(irc->otr->keygen, NULL, 0);
1868                irc->otr->keygen = 0;
1869                return FALSE;  /* unregister ourselves */
1870        }
1871}
1872
1873void copyfile(const char *a, const char *b)
1874{
1875        int fda, fdb;
1876        int n;
1877        char buf[1024];
1878       
1879        fda = open(a, O_RDONLY);
1880        fdb = open(b, O_WRONLY | O_CREAT | O_TRUNC, 0600);
1881       
1882        while((n=read(fda, buf, 1024)) > 0)
1883                write(fdb, buf, n);
1884       
1885        close(fda);
1886        close(fdb);     
1887}
1888
1889void myfgets(char *s, int size, FILE *stream)
1890{
1891        if(!fgets(s, size, stream)) {
1892                s[0] = '\0';
1893        } else {
1894                int n = strlen(s);
1895                if(n>0 && s[n-1] == '\n')
1896                        s[n-1] = '\0';
1897        }
1898}
1899
1900void yes_keygen(void *data)
1901{
1902        account_t *acc = (account_t *)data;
1903        irc_t *irc = acc->bee->ui_data;
1904       
1905        if(keygen_in_progress(irc, acc->user, acc->prpl->name)) {
1906                irc_rootmsg(irc, "keygen for %s/%s already in progress",
1907                        acc->user, acc->prpl->name);
1908        } else {
1909                irc_rootmsg(irc, "starting background keygen for %s/%s",
1910                        acc->user, acc->prpl->name);
1911                irc_rootmsg(irc, "you will be notified when it completes");
1912                otr_keygen(irc, acc->user, acc->prpl->name);
1913        }
1914}
1915
1916/* check whether a string is safe to use in a path component */
1917int strsane(const char *s)
1918{
1919        return strpbrk(s, "/\\") == NULL;
1920}
1921
1922/* vim: set noet ts=4 sw=4: */
Note: See TracBrowser for help on using the repository browser.