chiark / gitweb /
Merge branches 'cleanup' and 'services'
[tripe] / proxy / tripe-mitm.c
1 /* -*-c-*-
2  *
3  * $Id$
4  *
5  * An evil proxy for TrIPE
6  *
7  * (c) 2001 Straylight/Edgeware
8  */
9
10 /*----- Licensing notice --------------------------------------------------* 
11  *
12  * This file is part of Trivial IP Encryption (TrIPE).
13  *
14  * TrIPE is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  * 
19  * TrIPE is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  * 
24  * You should have received a copy of the GNU General Public License
25  * along with TrIPE; if not, write to the Free Software Foundation,
26  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27  */
28
29 /*----- Header files ------------------------------------------------------*/
30
31 #include "config.h"
32
33 #include <assert.h>
34 #include <errno.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <time.h>
39
40 #include <sys/types.h>
41 #include <sys/time.h>
42 #include <unistd.h>
43 #include <fcntl.h>
44
45 #include <sys/socket.h>
46 #include <netinet/in.h>
47 #include <arpa/inet.h>
48 #include <netdb.h>
49
50 #include <mLib/alloc.h>
51 #include <mLib/dstr.h>
52 #include <mLib/fdflags.h>
53 #include <mLib/mdwopt.h>
54 #include <mLib/quis.h>
55 #include <mLib/report.h>
56 #include <mLib/sel.h>
57 #include <mLib/sub.h>
58 #include <mLib/tv.h>
59
60 #include <catacomb/buf.h>
61
62 #include <catacomb/key.h>
63
64 #include <catacomb/mp.h>
65 #include <catacomb/mprand.h>
66 #include <catacomb/dh.h>
67
68 #include <catacomb/noise.h>
69 #include <catacomb/rand.h>
70 #include <catacomb/rc4.h>
71
72 /*----- Data structures ---------------------------------------------------*/
73
74 typedef struct peer {
75   sel_file sf;
76   dh_pub kpub;
77   const char *name;
78   struct filter *f;
79 } peer;
80
81 typedef struct filter {
82   struct filter *next;
83   peer *p_from, *p_to;
84   void (*func)(struct filter */*f*/, const octet */*buf*/, size_t /*sz*/);
85   void *state;
86 } filter;
87
88 typedef struct qnode {
89   octet *buf;
90   size_t sz;
91 } qnode;
92
93 /*----- Static variables --------------------------------------------------*/
94
95 #define PKBUFSZ 65536
96
97 static sel_state sel;
98 static peer peers[2];
99 static unsigned npeer = 0;
100 static key_file keys;
101 static grand *rng;
102
103 #define PASS(f, buf, sz) ((f) ? (f)->func((f), (buf), (sz)) : (void)0)
104 #define RND(i) (rng->ops->range(rng, (i)))
105
106 /*----- Peer management ---------------------------------------------------*/
107
108 static void dopacket(int fd, unsigned mode, void *vv)
109 {
110   octet buf[PKBUFSZ];
111   peer *p = vv;
112   int r = read(fd, buf, sizeof(buf));
113   if (r >= 0) {
114     printf("recv from `%s'\n", p->name);
115     PASS(p->f, buf, r);
116   }
117 }
118
119 static void addpeer(unsigned ac, char **av)
120 {
121   key_packstruct kps[DH_PUBFETCHSZ];
122   key_packdef *kp;
123   struct hostent *h;
124   struct sockaddr_in sin;
125   int len = PKBUFSZ;
126   peer *p;
127   int fd;
128   int e;
129
130   if (ac != 4)
131     die(1, "syntax: peer:NAME:PORT:ADDR:PORT");
132   if (npeer >= 2)
133     die(1, "enough peers already");
134   p = &peers[npeer++];
135   p->name = xstrdup(av[0]);
136   kp = key_fetchinit(dh_pubfetch, kps, &p->kpub);
137   e = key_fetchbyname(kp, &keys, av[0]);
138   key_fetchdone(kp);
139   if (e)
140     die(1, "key_fetch `%s': %s", av[0], key_strerror(e));
141   if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
142     die(1, "socket: %s", strerror(errno));
143   fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
144   memset(&sin, 0, sizeof(sin));
145   sin.sin_family = AF_INET;
146   sin.sin_addr.s_addr = INADDR_ANY;
147   sin.sin_port = htons(atoi(av[1]));
148   if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)))
149     die(1, "bind: %s", strerror(errno));
150   memset(&sin, 0, sizeof(sin));
151   sin.sin_family = AF_INET;
152   if ((h = gethostbyname(av[2])) == 0)
153     die(1, "gethostbyname `%s'", av[2]);
154   if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len)) ||
155       setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &len, sizeof(len)))
156     die(1, "setsockopt: %s", strerror(errno));
157   memcpy(&sin.sin_addr, h->h_addr, sizeof(sin.sin_addr));
158   sin.sin_port = htons(atoi(av[3]));
159   if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)))
160     die(1, "connect: %s", strerror(errno));
161   sel_initfile(&sel, &p->sf, fd, SEL_READ, dopacket, p);
162   sel_addfile(&p->sf);
163 }
164
165 /*----- Fork filter -------------------------------------------------------*/
166
167 typedef struct forknode {
168   struct forknode *next;
169   filter *f;
170 } forknode;
171
172 typedef struct forkfilt {
173   const char *name;
174   forknode *fn;
175 } forkfilt;
176
177 static void dofork(filter *f, const octet *buf, size_t sz)
178 {
179   forkfilt *ff = f->state;
180   forknode *fn;
181   unsigned i = 0;
182
183   ff = f->state;
184   for (fn = ff->fn; fn; fn = fn->next) {
185     printf("fork branch %u of fork `%s'\n", i++, ff->name);
186     PASS(fn->f, buf, sz);
187   }
188   printf("fork branch %u of fork `%s'\n", i++, ff->name);
189   PASS(f->next, buf, sz);
190 }
191
192 static void addfork(filter *f, unsigned ac, char **av)
193 {
194   forkfilt *ff;
195   if (ac != 1)
196     die(1, "syntax: filt:fork:NAME");
197   ff = CREATE(forkfilt);
198   ff->name = xstrdup(av[0]);
199   ff->fn = 0;
200   f->func = dofork;
201   f->state = ff;
202 }
203
204 static void nextfork(unsigned ac, char **av)
205 {
206   unsigned i, j;
207   filter *f;
208   forkfilt *ff;
209   forknode *fn, **ffn;
210   peer *p;
211
212   if (ac < 1)
213     die(1, "syntax: next:NAME:...");
214   for (i = 0; i < 2; i++) {
215     p = &peers[i];
216     for (f = p->f; f; f = f->next) {
217       if (f->func != dofork)
218         continue;
219       ff = f->state;
220       for (j = 0; j < ac; j++) {
221         if (strcmp(av[j], ff->name) == 0)
222           goto match;
223       }
224       continue;
225     match:
226       fn = CREATE(forknode);
227       for (ffn = &ff->fn; *ffn; ffn = &(*ffn)->next)
228         ;
229       fn->f = f->next;
230       f->next = 0;
231       fn->next = 0;
232       *ffn = fn;
233     }
234   }
235 }
236
237 /*----- Corrupt filter ----------------------------------------------------*/
238
239 typedef struct corrupt {
240   unsigned p_corrupt;
241 } corrupt;
242
243 static void docorrupt(filter *f, const octet *buf, size_t sz)
244 {
245   corrupt *c = f->state;
246   octet b[PKBUFSZ];
247   memcpy(b, buf, sz);
248
249   while (!RND(c->p_corrupt)) {
250     puts("corrupt packet");
251     b[RND(sz)] ^= RND(256);
252   }
253   PASS(f->next, b, sz);
254 }
255
256 static void addcorrupt(filter *f, unsigned ac, char **av)
257 {
258   corrupt *c;
259   if (ac > 1)
260     die(1, "syntax: filt:corrupt[:PCORRUPT]");
261   c = CREATE(corrupt);
262   if (ac > 0)
263     c->p_corrupt = atoi(av[0]);
264   else
265     c->p_corrupt = 5;
266   f->state = c;
267   f->func = docorrupt;
268 }
269
270 /*----- Delay filter ------------------------------------------------------*/
271
272 typedef struct delaynode {
273   unsigned flag;
274   sel_timer tm;
275   unsigned i;
276   struct delay *d;
277   octet *buf;
278   size_t sz;
279   unsigned seq;
280 } delaynode;
281
282 typedef struct delay {
283   unsigned max, n;
284   unsigned long t;
285   unsigned p_replay;
286   filter *f;
287   delaynode *q;
288 } delay;
289
290 static void dtimer(struct timeval *tv, void *vv);
291
292 static void dinsert(delaynode *dn)
293 {
294   struct timeval tv;
295   sel_timer *ta, *tb;
296   unsigned long tdelta = RND(dn->d->t);
297   gettimeofday(&tv, 0);
298   TV_ADDL(&tv, &tv, 0, tdelta);
299   assert(!dn->flag);
300   sel_addtimer(&sel, &dn->tm, &tv, dtimer, dn);
301   dn->flag = 1;
302   for (ta = tb = sel.timers; ta; ta = ta->next) {
303     ta = ta->next; if (!ta) break; assert(ta != tb);
304     ta = ta->next; if (!ta) break; assert(ta != tb);
305     tb = tb->next;
306   }
307   printf(" delay %lu usecs", tdelta);
308 }
309
310 static void dsend(delaynode *dn, unsigned force)
311 {
312   delay *d = dn->d;
313   delaynode *ddn;
314   fputs(" send...\n", stdout);
315   assert(dn->buf);
316   PASS(d->f->next, dn->buf, dn->sz);
317   fputs("delay ...", stdout);
318   if (!force)
319     dinsert(dn);
320   else {
321     xfree(dn->buf);
322     dn->buf = 0;
323     d->n--;
324     if (dn->i < d->n) {
325       ddn = &d->q[d->n];
326       sel_rmtimer(&ddn->tm);
327       sel_addtimer(&sel, &dn->tm, &ddn->tm.tv, dtimer, dn);
328       dn->flag = 1;
329       dn->buf = ddn->buf;
330       dn->sz = ddn->sz;
331       dn->seq = ddn->seq;
332       ddn->buf = 0;
333       ddn->flag = 0;
334       printf(" move id %u from slot %u to slot %u", ddn->seq, ddn->i, dn->i);
335     }
336     { unsigned i; for (i = 0; i < d->n; i++) assert(d->q[i].buf); }
337     fputs(" remove", stdout);
338   }
339 }
340
341 static void dtimer(struct timeval *tv, void *vv)
342 {
343   delaynode *dn = vv;
344   printf("delay timer peer `%s' id %u slot %u",
345          dn->d->f->p_from->name, dn->seq, dn->i);
346   dn->flag = 0;
347   dsend(dn, RND(dn->d->p_replay));
348   fputc('\n', stdout);
349 }
350
351 static void dodelay(filter *f, const octet *buf, size_t sz)
352 {
353   delay *d = f->state;
354   delaynode *dn;
355   static unsigned seq = 0;
356
357   fputs("delay", stdout);
358   if (d->n == d->max) {
359     dn = &d->q[RND(d->n)];
360     printf(" force uid %u", dn->seq);
361     sel_rmtimer(&dn->tm);
362     dn->flag = 0;
363     dsend(dn, 1);
364     fputc(';', stdout);
365   }
366   dn = &d->q[d->n++];
367   dn->seq = seq++;
368   printf(" new id %u in slot %u", dn->seq, dn->i);
369   dn->buf = xmalloc(sz);
370   dn->sz = sz;
371   memcpy(dn->buf, buf, sz);
372   dinsert(dn);
373   fputc('\n', stdout);
374 }
375
376 static void adddelay(filter *f, unsigned ac, char **av)
377 {
378   delay *d;
379   unsigned i;
380
381   if (ac < 1 || ac > 3)
382     die(1, "syntax: filt:delay:QLEN[:MILLIS:PREPLAY]");
383   d = CREATE(delay);
384   d->max = atoi(av[0]);
385   if (ac > 1)
386     d->t = strtoul(av[1], 0, 10);
387   else
388     d->t = 100;
389   d->t *= 1000;
390   if (ac > 2)
391     d->p_replay = atoi(av[2]);
392   else
393     d->p_replay = 20;
394   d->n = 0;
395   d->q = xmalloc(d->max * sizeof(delaynode));
396   d->f = f;
397   f->state = d;
398   f->func = dodelay;
399   for (i = 0; i < d->max; i++) {
400     d->q[i].d = d;
401     d->q[i].i = i;
402     d->q[i].buf = 0;
403     d->q[i].flag = 0;
404   }
405 }
406
407 /*----- Filters -----------------------------------------------------------*/
408
409 static void dosend(filter *f, const octet *buf, size_t sz)
410 {
411   printf("send to `%s'\n", f->p_to->name);
412   write(f->p_to->sf.fd, buf, sz);
413 }
414
415 static void addsend(filter *f, unsigned ac, char **av)
416 {
417   if (ac)
418     die(1, "syntax: filt:send");
419   f->func = dosend;
420 }
421
422 const struct filtab {
423   const char *name;
424   void (*func)(filter */*f*/, unsigned /*ac*/, char **/*av*/);
425 } filtab[] = {
426   { "send",     addsend },
427   { "fork",     addfork },
428   { "delay",    adddelay },
429   { "corrupt",  addcorrupt },
430   { 0,          0 }
431 };
432
433 static void dofilter(peer *from, peer *to, unsigned ac, char **av)
434 {
435   filter **ff, *f = CREATE(filter);
436   const struct filtab *ft;
437   if (ac < 1)
438     die(1, "syntax: {l,r,}filt:NAME:...");
439   f->next = 0;
440   f->p_from = from;
441   f->p_to = to;
442   f->state = 0;
443   for (ff = &from->f; *ff; ff = &(*ff)->next)
444     ;
445   *ff = f;
446   for (ft = filtab; ft->name; ft++) {
447     if (strcmp(av[0], ft->name) == 0) {
448       ft->func(f, ac - 1, av + 1);
449       return;
450     }
451   }
452   die(1, "unknown filter `%s'", av[0]);
453 }
454
455 /*----- Flooding ----------------------------------------------------------*/
456
457 typedef struct flood {
458   peer *p;
459   unsigned type;
460   size_t sz;
461   unsigned long t;
462   sel_timer tm;
463 } flood;
464
465 static void setflood(flood *f);
466
467 static void floodtimer(struct timeval *tv, void *vv)
468 {
469   flood *f = vv;
470   octet buf[PKBUFSZ];
471   size_t sz;
472
473   sz = RND(f->sz);
474   sz += RND(f->sz);
475   sz += RND(f->sz);
476   sz += RND(f->sz);
477   sz /= 2;
478
479   rng->ops->fill(rng, buf, sz);
480   if (f->type < 0x100)
481     buf[0] = f->type;
482   puts("flood packet");
483   PASS(f->p->f, buf, sz);
484   setflood(f);
485 }
486   
487 static void setflood(flood *f)
488 {
489   struct timeval tv;
490   gettimeofday(&tv, 0);
491   TV_ADDL(&tv, &tv, 0, RND(f->t));
492   sel_addtimer(&sel, &f->tm, &tv, floodtimer, f);
493 }
494
495 static void doflood(peer *p, unsigned ac, char **av)
496 {
497   flood *f;
498   if (ac > 3)
499     die(1, "syntax: flood[:TYPE:MILLIS:SIZE]");
500   f = CREATE(flood);
501   f->p = p;
502   if (ac > 0)
503     f->type = strtoul(av[0], 0, 16);
504   else
505     f->type = 0x100;
506   if (ac > 1)
507     f->t = atoi(av[1]);
508   else
509     f->t = 10;
510   if (ac > 2)
511     f->sz = atoi(av[2]);
512   else
513     f->sz = 128;
514   f->t *= 1000;
515   setflood(f);
516 }
517
518 /*----- Configuration commands --------------------------------------------*/
519
520 static void parse(char *p);
521
522 static void addflood(unsigned ac, char **av) {
523   doflood(&peers[0], ac, av);
524   doflood(&peers[1], ac, av);
525 }
526 static void addlflood(unsigned ac, char **av) {
527   doflood(&peers[0], ac, av);
528 }
529 static void addrflood(unsigned ac, char **av) {
530   doflood(&peers[1], ac, av);
531 }
532
533 static void addfilter(unsigned ac, char **av) {
534   dofilter(&peers[0], &peers[1], ac, av);
535   dofilter(&peers[1], &peers[0], ac, av);
536 }
537 static void addlfilter(unsigned ac, char **av) {
538   dofilter(&peers[0], &peers[1], ac, av);
539 }
540 static void addrfilter(unsigned ac, char **av) {
541   dofilter(&peers[1], &peers[0], ac, av);
542 }
543
544 static void include(unsigned ac, char **av)
545 {
546   FILE *fp;
547   dstr d = DSTR_INIT;
548   if (!ac)
549     die(1, "syntax: include:FILE:...");
550   while (*av) {
551     if ((fp = fopen(*av, "r")) == 0)
552       die(1, "fopen `%s': %s", *av, strerror(errno));
553     while (dstr_putline(&d, fp) != EOF) {
554       parse(d.buf);
555       DRESET(&d);
556     }
557     fclose(fp);
558     av++;
559   }
560 }
561
562 const struct cmdtab {
563   const char *name;
564   void (*func)(unsigned /*ac*/, char **/*av*/);
565 } cmdtab[] = {
566   { "peer",     addpeer },
567   { "include",  include },
568   { "filt",     addfilter },
569   { "lfilt",    addlfilter },
570   { "rfilt",    addrfilter },
571   { "next",     nextfork },
572   { "flood",    addflood },
573   { "lflood",   addlflood },
574   { "rflood",   addrflood },
575   { 0,          0 }
576 };
577
578 #define AVMAX 16
579
580 static void parse(char *p)
581 {
582   char *v[AVMAX];
583   unsigned c = 0;
584   const struct cmdtab *ct;
585
586   p = strtok(p, ":");
587   if (!p || *p == '#')
588     return;
589   do {
590     v[c++] = p;
591     p = strtok(0, ":");
592   } while (p && c < AVMAX - 1);
593   v[c] = 0;
594   for (ct = cmdtab; ct->name; ct++) {
595     if (strcmp(ct->name, v[0]) == 0) {
596       ct->func(c - 1, v + 1);
597       return;
598     }
599   }
600   die(1, "unknown command `%s'", v[0]);
601 }
602
603 /*----- Main driver -------------------------------------------------------*/
604
605 static void version(FILE *fp)
606   { pquis(fp, "$, TrIPE version " VERSION "\n"); }
607
608 static void usage(FILE *fp)
609   { pquis(fp, "Usage: $ [-k KEYRING] DIRECTIVE...\n"); }
610
611 static void help(FILE *fp)
612 {
613   version(fp);
614   putc('\n', fp);
615   usage(fp);
616   fputs("\n\
617 Options:\n\
618 \n\
619 -h, --help              Show this help text.\n\
620 -v, --version           Show the version number.\n\
621 -u, --usage             Show terse usage summary.\n\
622 \n\
623 -k, --keyring=FILE      Fetch keys from FILE.\n\
624 \n\
625 Directives:\n\
626   peer:NAME:LOCAL-PORT:REMOTE-ADDR:REMOTE-PORT\n\
627   include:FILE\n\
628   {,l,r}filt:FILTER:ARGS:...\n\
629   next:TAG\n\
630   {,l,r}flood:TYPE:MILLIS:SIZE\n\
631 \n\
632 Filters:\n\
633   send\n\
634   fork:TAG\n\
635   delay:QLEN[:MILLIS:P-REPLAY]\n\
636   corrupt[:P-CORRUPT]\n",
637         fp);
638 }
639
640 int main(int argc, char *argv[])
641 {
642   const char *kfname = "keyring.pub";
643   int i;
644   unsigned f = 0;
645   char buf[16];
646
647 #define f_bogus 1u
648
649   ego(argv[0]);
650   for (;;) {
651     static const struct option opt[] = {
652       { "help",         0,              0,      'h' },
653       { "version",      0,              0,      'v' },
654       { "usage",        0,              0,      'u' },
655       { "keyring",      OPTF_ARGREQ,    0,      'k' },
656       { 0,              0,              0,      0 }
657     };
658     if ((i = mdwopt(argc, argv, "hvuk:", opt, 0, 0, 0)) < 0)
659       break;
660     switch (i) {
661       case 'h':
662         help(stdout);
663         exit(0);
664       case 'v':
665         version(stdout);
666         exit(0);
667       case 'u':
668         usage(stdout);
669         exit(0);
670       case 'k':
671         kfname = optarg;
672         break;
673       default:
674         f |= f_bogus;
675         break;
676     }
677   }
678   if (f & f_bogus) {
679     usage(stderr);
680     exit(1);
681   }
682   rand_noisesrc(RAND_GLOBAL, &noise_source);
683   rand_seed(RAND_GLOBAL, 160);
684   rand_get(RAND_GLOBAL, buf, sizeof(buf));
685   rng = rc4_rand(buf, sizeof(buf));
686   sel_init(&sel);
687   if (key_open(&keys, kfname, KOPEN_READ, key_moan, 0))
688     die(1, "couldn't open `%s': %s", kfname, strerror(errno));
689   for (i = optind; i < argc; i++)
690     parse(argv[i]);
691   if (npeer != 2)
692     die(1, "need two peers");
693   for (;;)
694     sel_select(&sel);
695
696 #undef f_bogus
697 }
698
699 /*----- That's all, folks -------------------------------------------------*/