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