chiark / gitweb /
memcmp: Introduce and use consttime_memeq
[secnet.git] / site.c
1 /* site.c - manage communication with a remote network site */
2
3 /* The 'site' code doesn't know anything about the structure of the
4    packets it's transmitting.  In fact, under the new netlink
5    configuration scheme it doesn't need to know anything at all about
6    IP addresses, except how to contact its peer.  This means it could
7    potentially be used to tunnel other protocols too (IPv6, IPX, plain
8    old Ethernet frames) if appropriate netlink code can be written
9    (and that ought not to be too hard, eg. using the TUN/TAP device to
10    pretend to be an Ethernet interface).  */
11
12 /* At some point in the future the netlink code will be asked for
13    configuration information to go in the PING/PONG packets at the end
14    of the key exchange. */
15
16 #include "secnet.h"
17 #include <stdio.h>
18 #include <string.h>
19 #include <limits.h>
20 #include <assert.h>
21 #include <sys/socket.h>
22
23 #include <sys/mman.h>
24 #include "util.h"
25 #include "unaligned.h"
26 #include "magic.h"
27
28 #define SETUP_BUFFER_LEN 2048
29
30 #define DEFAULT_KEY_LIFETIME                  (3600*1000) /* [ms] */
31 #define DEFAULT_KEY_RENEGOTIATE_GAP           (5*60*1000) /* [ms] */
32 #define DEFAULT_SETUP_RETRIES 5
33 #define DEFAULT_SETUP_RETRY_INTERVAL             (2*1000) /* [ms] */
34 #define DEFAULT_WAIT_TIME                       (20*1000) /* [ms] */
35
36 #define DEFAULT_MOBILE_KEY_LIFETIME      (2*24*3600*1000) /* [ms] */
37 #define DEFAULT_MOBILE_KEY_RENEGOTIATE_GAP (12*3600*1000) /* [ms] */
38 #define DEFAULT_MOBILE_SETUP_RETRIES 30
39 #define DEFAULT_MOBILE_SETUP_RETRY_INTERVAL      (1*1000) /* [ms] */
40 #define DEFAULT_MOBILE_WAIT_TIME                (10*1000) /* [ms] */
41
42 #define DEFAULT_MOBILE_PEER_EXPIRY            (2*60)      /* [s] */
43 #define DEFAULT_MOBILE_PEERS_MAX 3 /* send at most this many copies (default) */
44
45 /* Each site can be in one of several possible states. */
46
47 /* States:
48    SITE_STOP         - nothing is allowed to happen; tunnel is down;
49                        all session keys have been erased
50      -> SITE_RUN upon external instruction
51    SITE_RUN          - site up, maybe with valid key
52      -> SITE_RESOLVE upon outgoing packet and no valid key
53          we start name resolution for the other end of the tunnel
54      -> SITE_SENTMSG2 upon valid incoming message 1 and suitable time
55          we send an appropriate message 2
56    SITE_RESOLVE      - waiting for name resolution
57      -> SITE_SENTMSG1 upon successful resolution
58          we send an appropriate message 1
59      -> SITE_SENTMSG2 upon valid incoming message 1 (then abort resolution)
60          we abort resolution and 
61      -> SITE_WAIT on timeout or resolution failure
62    SITE_SENTMSG1
63      -> SITE_SENTMSG2 upon valid incoming message 1 from higher priority end
64      -> SITE_SENTMSG3 upon valid incoming message 2
65      -> SITE_WAIT on timeout
66    SITE_SENTMSG2
67      -> SITE_SENTMSG4 upon valid incoming message 3
68      -> SITE_WAIT on timeout
69    SITE_SENTMSG3
70      -> SITE_SENTMSG5 upon valid incoming message 4
71      -> SITE_WAIT on timeout
72    SITE_SENTMSG4
73      -> SITE_RUN upon valid incoming message 5
74      -> SITE_WAIT on timeout
75    SITE_SENTMSG5
76      -> SITE_RUN upon valid incoming message 6
77      -> SITE_WAIT on timeout
78    SITE_WAIT         - failed to establish key; do nothing for a while
79      -> SITE_RUN on timeout
80    */
81
82 #define SITE_STOP     0
83 #define SITE_RUN      1
84 #define SITE_RESOLVE  2
85 #define SITE_SENTMSG1 3
86 #define SITE_SENTMSG2 4
87 #define SITE_SENTMSG3 5
88 #define SITE_SENTMSG4 6
89 #define SITE_SENTMSG5 7
90 #define SITE_WAIT     8
91
92 static cstring_t state_name(uint32_t state)
93 {
94     switch (state) {
95     case 0: return "STOP";
96     case 1: return "RUN";
97     case 2: return "RESOLVE";
98     case 3: return "SENTMSG1";
99     case 4: return "SENTMSG2";
100     case 5: return "SENTMSG3";
101     case 6: return "SENTMSG4";
102     case 7: return "SENTMSG5";
103     case 8: return "WAIT";
104     default: return "*bad state*";
105     }
106 }
107
108 #define NONCELEN 8
109
110 #define LOG_UNEXPECTED    0x00000001
111 #define LOG_SETUP_INIT    0x00000002
112 #define LOG_SETUP_TIMEOUT 0x00000004
113 #define LOG_ACTIVATE_KEY  0x00000008
114 #define LOG_TIMEOUT_KEY   0x00000010
115 #define LOG_SEC           0x00000020
116 #define LOG_STATE         0x00000040
117 #define LOG_DROP          0x00000080
118 #define LOG_DUMP          0x00000100
119 #define LOG_ERROR         0x00000400
120 #define LOG_PEER_ADDRS    0x00000800
121
122 static struct flagstr log_event_table[]={
123     { "unexpected", LOG_UNEXPECTED },
124     { "setup-init", LOG_SETUP_INIT },
125     { "setup-timeout", LOG_SETUP_TIMEOUT },
126     { "activate-key", LOG_ACTIVATE_KEY },
127     { "timeout-key", LOG_TIMEOUT_KEY },
128     { "security", LOG_SEC },
129     { "state-change", LOG_STATE },
130     { "packet-drop", LOG_DROP },
131     { "dump-packets", LOG_DUMP },
132     { "errors", LOG_ERROR },
133     { "peer-addrs", LOG_PEER_ADDRS },
134     { "default", LOG_SETUP_INIT|LOG_SETUP_TIMEOUT|
135       LOG_ACTIVATE_KEY|LOG_TIMEOUT_KEY|LOG_SEC|LOG_ERROR },
136     { "all", 0xffffffff },
137     { NULL, 0 }
138 };
139
140
141 /***** TRANSPORT PEERS declarations *****/
142
143 /* Details of "mobile peer" semantics:
144    
145    - We record mobile_peers_max peer address/port numbers ("peers")
146      for key setup, and separately mobile_peers_max for data
147      transfer.  If these lists fill up, we retain the newest peers.
148      (For non-mobile peers we only record one of each.)
149
150    - Outgoing packets are sent to every recorded peer in the
151      applicable list.
152
153    - Data transfer peers are straightforward: whenever we successfully
154      process a data packet, we record the peer.  Also, whenever we
155      successfully complete a key setup, we merge the key setup
156      peers into the data transfer peers.
157
158      (For "non-mobile" peers we simply copy the peer used for
159      successful key setup, and don't change the peer otherwise.)
160
161    - Key setup peers are slightly more complicated.
162
163      Whenever we receive and successfully process a key exchange
164      packet, we record the peer.
165
166      Whenever we try to initiate a key setup, we copy the list of data
167      transfer peers and use it for key setup.  But we also look to see
168      if the config supplies an address and port number and if so we
169      add that as a key setup peer (possibly evicting one of the data
170      transfer peers we just copied).
171
172      (For "non-mobile" peers, if we if we have a configured peer
173      address and port, we always use that; otherwise if we have a
174      current data peer address we use that; otherwise we do not
175      attempt to initiate a key setup for lack of a peer address.)
176
177    "Record the peer" means
178     1. expire any peers last seen >120s ("mobile-peer-expiry") ago
179     2. add the peer of the just received packet to the applicable list
180        (possibly evicting older entries)
181    NB that we do not expire peers until an incoming packet arrives.
182
183    */
184
185 #define MAX_MOBILE_PEERS_MAX 5 /* send at most this many copies, compiled max */
186
187 typedef struct {
188     struct timeval last;
189     struct comm_addr addr;
190 } transport_peer;
191
192 typedef struct {
193 /* configuration information */
194 /* runtime information */
195     int npeers;
196     transport_peer peers[MAX_MOBILE_PEERS_MAX];
197 } transport_peers;
198
199 static void transport_peers_clear(struct site *st, transport_peers *peers);
200 static int transport_peers_valid(transport_peers *peers);
201 static void transport_peers_copy(struct site *st, transport_peers *dst,
202                                  const transport_peers *src);
203
204 static void transport_setup_msgok(struct site *st, const struct comm_addr *a);
205 static void transport_data_msgok(struct site *st, const struct comm_addr *a);
206 static bool_t transport_compute_setupinit_peers(struct site *st,
207         const struct comm_addr *configured_addr /* 0 if none or not found */);
208 static void transport_record_peer(struct site *st, transport_peers *peers,
209                                   const struct comm_addr *addr, const char *m);
210
211 static void transport_xmit(struct site *st, transport_peers *peers,
212                            struct buffer_if *buf, bool_t candebug);
213
214  /***** END of transport peers declarations *****/
215
216
217 struct data_key {
218     struct transform_inst_if *transform;
219     uint64_t key_timeout; /* End of life of current key */
220     uint32_t remote_session_id;
221 };
222
223 struct site {
224     closure_t cl;
225     struct site_if ops;
226 /* configuration information */
227     string_t localname;
228     string_t remotename;
229     bool_t peer_mobile; /* Mobile client support */
230     int32_t transport_peers_max;
231     string_t tunname; /* localname<->remotename by default, used in logs */
232     string_t address; /* DNS name for bootstrapping, optional */
233     int remoteport; /* Port for bootstrapping, optional */
234     struct netlink_if *netlink;
235     struct comm_if **comms;
236     int ncomms;
237     struct resolver_if *resolver;
238     struct log_if *log;
239     struct random_if *random;
240     struct rsaprivkey_if *privkey;
241     struct rsapubkey_if *pubkey;
242     struct transform_if *transform;
243     struct dh_if *dh;
244     struct hash_if *hash;
245
246     uint32_t index; /* Index of this site */
247     int32_t setup_retries; /* How many times to send setup packets */
248     int32_t setup_retry_interval; /* Initial timeout for setup packets */
249     int32_t wait_timeout; /* How long to wait if setup unsuccessful */
250     int32_t mobile_peer_expiry; /* How long to remember 2ary addresses */
251     int32_t key_lifetime; /* How long a key lasts once set up */
252     int32_t key_renegotiate_time; /* If we see traffic (or a keepalive)
253                                       after this time, initiate a new
254                                       key exchange */
255
256     uint8_t *setupsig; /* Expected signature of incoming MSG1 packets */
257     int32_t setupsiglen; /* Allows us to discard packets quickly if
258                             they are not for us */
259     bool_t setup_priority; /* Do we have precedence if both sites emit
260                               message 1 simultaneously? */
261     uint32_t log_events;
262
263 /* runtime information */
264     uint32_t state;
265     uint64_t now; /* Most recently seen time */
266
267     /* The currently established session */
268     struct data_key current;
269     struct data_key auxiliary_key;
270     bool_t auxiliary_is_new;
271     uint64_t renegotiate_key_time; /* When we can negotiate a new key */
272     uint64_t auxiliary_renegotiate_key_time;
273     transport_peers peers; /* Current address(es) of peer for data traffic */
274
275     /* The current key setup protocol exchange.  We can only be
276        involved in one of these at a time.  There's a potential for
277        denial of service here (the attacker keeps sending a setup
278        packet; we keep trying to continue the exchange, and have to
279        timeout before we can listen for another setup packet); perhaps
280        we should keep a list of 'bad' sources for setup packets. */
281     uint32_t setup_session_id;
282     transport_peers setup_peers;
283     uint8_t localN[NONCELEN]; /* Nonces for key exchange */
284     uint8_t remoteN[NONCELEN];
285     struct buffer_if buffer; /* Current outgoing key exchange packet */
286     struct buffer_if scratch;
287     int32_t retries; /* Number of retries remaining */
288     uint64_t timeout; /* Timeout for current state */
289     uint8_t *dhsecret;
290     uint8_t *sharedsecret;
291     struct transform_inst_if *new_transform; /* For key setup/verify */
292 };
293
294 static void slog(struct site *st, uint32_t event, cstring_t msg, ...)
295 {
296     va_list ap;
297     char buf[240];
298     uint32_t class;
299
300     va_start(ap,msg);
301
302     if (event&st->log_events) {
303         switch(event) {
304         case LOG_UNEXPECTED: class=M_INFO; break;
305         case LOG_SETUP_INIT: class=M_INFO; break;
306         case LOG_SETUP_TIMEOUT: class=M_NOTICE; break;
307         case LOG_ACTIVATE_KEY: class=M_INFO; break;
308         case LOG_TIMEOUT_KEY: class=M_INFO; break;
309         case LOG_SEC: class=M_SECURITY; break;
310         case LOG_STATE: class=M_DEBUG; break;
311         case LOG_DROP: class=M_DEBUG; break;
312         case LOG_DUMP: class=M_DEBUG; break;
313         case LOG_ERROR: class=M_ERR; break;
314         case LOG_PEER_ADDRS: class=M_DEBUG; break;
315         default: class=M_ERR; break;
316         }
317
318         vsnprintf(buf,sizeof(buf),msg,ap);
319         st->log->log(st->log->st,class,"%s: %s",st->tunname,buf);
320     }
321     va_end(ap);
322 }
323
324 static void set_link_quality(struct site *st);
325 static void delete_keys(struct site *st, cstring_t reason, uint32_t loglevel);
326 static void delete_one_key(struct site *st, struct data_key *key,
327                            const char *reason /* may be 0 meaning don't log*/,
328                            const char *which /* ignored if !reasonn */,
329                            uint32_t loglevel /* ignored if !reasonn */);
330 static bool_t initiate_key_setup(struct site *st, cstring_t reason);
331 static void enter_state_run(struct site *st);
332 static bool_t enter_state_resolve(struct site *st);
333 static bool_t enter_new_state(struct site *st,uint32_t next);
334 static void enter_state_wait(struct site *st);
335 static void activate_new_key(struct site *st);
336
337 static bool_t current_valid(struct site *st)
338 {
339     return st->current.transform->valid(st->current.transform->st);
340 }
341
342 #define CHECK_AVAIL(b,l) do { if ((b)->size<(l)) return False; } while(0)
343 #define CHECK_EMPTY(b) do { if ((b)->size!=0) return False; } while(0)
344 #define CHECK_TYPE(b,t) do { uint32_t type; \
345     CHECK_AVAIL((b),4); \
346     type=buf_unprepend_uint32((b)); \
347     if (type!=(t)) return False; } while(0)
348
349 struct msg {
350     uint8_t *hashstart;
351     uint32_t dest;
352     uint32_t source;
353     int32_t remlen;
354     uint8_t *remote;
355     int32_t loclen;
356     uint8_t *local;
357     uint8_t *nR;
358     uint8_t *nL;
359     int32_t pklen;
360     char *pk;
361     int32_t hashlen;
362     int32_t siglen;
363     char *sig;
364 };
365
366 /* Build any of msg1 to msg4. msg5 and msg6 are built from the inside
367    out using a transform of config data supplied by netlink */
368 static bool_t generate_msg(struct site *st, uint32_t type, cstring_t what)
369 {
370     void *hst;
371     uint8_t *hash;
372     string_t dhpub, sig;
373
374     st->retries=st->setup_retries;
375     BUF_ALLOC(&st->buffer,what);
376     buffer_init(&st->buffer,0);
377     buf_append_uint32(&st->buffer,
378         (type==LABEL_MSG1?0:st->setup_session_id));
379     buf_append_uint32(&st->buffer,st->index);
380     buf_append_uint32(&st->buffer,type);
381     buf_append_string(&st->buffer,st->localname);
382     buf_append_string(&st->buffer,st->remotename);
383     memcpy(buf_append(&st->buffer,NONCELEN),st->localN,NONCELEN);
384     if (type==LABEL_MSG1) return True;
385     memcpy(buf_append(&st->buffer,NONCELEN),st->remoteN,NONCELEN);
386     if (type==LABEL_MSG2) return True;
387
388     if (hacky_par_mid_failnow()) return False;
389
390     dhpub=st->dh->makepublic(st->dh->st,st->dhsecret,st->dh->len);
391     buf_append_string(&st->buffer,dhpub);
392     free(dhpub);
393     hash=safe_malloc(st->hash->len, "generate_msg");
394     hst=st->hash->init();
395     st->hash->update(hst,st->buffer.start,st->buffer.size);
396     st->hash->final(hst,hash);
397     sig=st->privkey->sign(st->privkey->st,hash,st->hash->len);
398     buf_append_string(&st->buffer,sig);
399     free(sig);
400     free(hash);
401     return True;
402 }
403
404 static bool_t unpick_msg(struct site *st, uint32_t type,
405                          struct buffer_if *msg, struct msg *m)
406 {
407     m->hashstart=msg->start;
408     CHECK_AVAIL(msg,4);
409     m->dest=buf_unprepend_uint32(msg);
410     CHECK_AVAIL(msg,4);
411     m->source=buf_unprepend_uint32(msg);
412     CHECK_TYPE(msg,type);
413     CHECK_AVAIL(msg,2);
414     m->remlen=buf_unprepend_uint16(msg);
415     CHECK_AVAIL(msg,m->remlen);
416     m->remote=buf_unprepend(msg,m->remlen);
417     CHECK_AVAIL(msg,2);
418     m->loclen=buf_unprepend_uint16(msg);
419     CHECK_AVAIL(msg,m->loclen);
420     m->local=buf_unprepend(msg,m->loclen);
421     CHECK_AVAIL(msg,NONCELEN);
422     m->nR=buf_unprepend(msg,NONCELEN);
423     if (type==LABEL_MSG1) {
424         CHECK_EMPTY(msg);
425         return True;
426     }
427     CHECK_AVAIL(msg,NONCELEN);
428     m->nL=buf_unprepend(msg,NONCELEN);
429     if (type==LABEL_MSG2) {
430         CHECK_EMPTY(msg);
431         return True;
432     }
433     CHECK_AVAIL(msg,2);
434     m->pklen=buf_unprepend_uint16(msg);
435     CHECK_AVAIL(msg,m->pklen);
436     m->pk=buf_unprepend(msg,m->pklen);
437     m->hashlen=msg->start-m->hashstart;
438     CHECK_AVAIL(msg,2);
439     m->siglen=buf_unprepend_uint16(msg);
440     CHECK_AVAIL(msg,m->siglen);
441     m->sig=buf_unprepend(msg,m->siglen);
442     CHECK_EMPTY(msg);
443     return True;
444 }
445
446 static bool_t check_msg(struct site *st, uint32_t type, struct msg *m,
447                         cstring_t *error)
448 {
449     if (type==LABEL_MSG1) return True;
450
451     /* Check that the site names and our nonce have been sent
452        back correctly, and then store our peer's nonce. */ 
453     if (memcmp(m->remote,st->remotename,strlen(st->remotename)!=0)) {
454         *error="wrong remote site name";
455         return False;
456     }
457     if (memcmp(m->local,st->localname,strlen(st->localname)!=0)) {
458         *error="wrong local site name";
459         return False;
460     }
461     if (memcmp(m->nL,st->localN,NONCELEN)!=0) {
462         *error="wrong locally-generated nonce";
463         return False;
464     }
465     if (type==LABEL_MSG2) return True;
466     if (!consttime_memeq(m->nR,st->remoteN,NONCELEN)!=0) {
467         *error="wrong remotely-generated nonce";
468         return False;
469     }
470     if (type==LABEL_MSG3) return True;
471     if (type==LABEL_MSG4) return True;
472     *error="unknown message type";
473     return False;
474 }
475
476 static bool_t generate_msg1(struct site *st)
477 {
478     st->random->generate(st->random->st,NONCELEN,st->localN);
479     return generate_msg(st,LABEL_MSG1,"site:MSG1");
480 }
481
482 static bool_t process_msg1(struct site *st, struct buffer_if *msg1,
483                            const struct comm_addr *src)
484 {
485     struct msg m;
486
487     /* We've already determined we're in an appropriate state to
488        process an incoming MSG1, and that the MSG1 has correct values
489        of A and B. */
490
491     if (!unpick_msg(st,LABEL_MSG1,msg1,&m)) return False;
492
493     transport_record_peer(st,&st->setup_peers,src,"msg1");
494     st->setup_session_id=m.source;
495     memcpy(st->remoteN,m.nR,NONCELEN);
496     return True;
497 }
498
499 static bool_t generate_msg2(struct site *st)
500 {
501     st->random->generate(st->random->st,NONCELEN,st->localN);
502     return generate_msg(st,LABEL_MSG2,"site:MSG2");
503 }
504
505 static bool_t process_msg2(struct site *st, struct buffer_if *msg2,
506                            const struct comm_addr *src)
507 {
508     struct msg m;
509     cstring_t err;
510
511     if (!unpick_msg(st,LABEL_MSG2,msg2,&m)) return False;
512     if (!check_msg(st,LABEL_MSG2,&m,&err)) {
513         slog(st,LOG_SEC,"msg2: %s",err);
514         return False;
515     }
516     st->setup_session_id=m.source;
517     memcpy(st->remoteN,m.nR,NONCELEN);
518     return True;
519 }
520
521 static bool_t generate_msg3(struct site *st)
522 {
523     /* Now we have our nonce and their nonce. Think of a secret key,
524        and create message number 3. */
525     st->random->generate(st->random->st,st->dh->len,st->dhsecret);
526     return generate_msg(st,LABEL_MSG3,"site:MSG3");
527 }
528
529 static bool_t process_msg3(struct site *st, struct buffer_if *msg3,
530                            const struct comm_addr *src)
531 {
532     struct msg m;
533     uint8_t *hash;
534     void *hst;
535     cstring_t err;
536
537     if (!unpick_msg(st,LABEL_MSG3,msg3,&m)) return False;
538     if (!check_msg(st,LABEL_MSG3,&m,&err)) {
539         slog(st,LOG_SEC,"msg3: %s",err);
540         return False;
541     }
542
543     /* Check signature and store g^x mod m */
544     hash=safe_malloc(st->hash->len, "process_msg3");
545     hst=st->hash->init();
546     st->hash->update(hst,m.hashstart,m.hashlen);
547     st->hash->final(hst,hash);
548     /* Terminate signature with a '0' - cheating, but should be ok */
549     m.sig[m.siglen]=0;
550     if (!st->pubkey->check(st->pubkey->st,hash,st->hash->len,m.sig)) {
551         slog(st,LOG_SEC,"msg3 signature failed check!");
552         free(hash);
553         return False;
554     }
555     free(hash);
556
557     /* Terminate their DH public key with a '0' */
558     m.pk[m.pklen]=0;
559     /* Invent our DH secret key */
560     st->random->generate(st->random->st,st->dh->len,st->dhsecret);
561
562     /* Generate the shared key */
563     st->dh->makeshared(st->dh->st,st->dhsecret,st->dh->len,m.pk,
564                        st->sharedsecret,st->transform->keylen);
565
566     /* Set up the transform */
567     st->new_transform->setkey(st->new_transform->st,st->sharedsecret,
568                               st->transform->keylen);
569
570     return True;
571 }
572
573 static bool_t generate_msg4(struct site *st)
574 {
575     /* We have both nonces, their public key and our private key. Generate
576        our public key, sign it and send it to them. */
577     return generate_msg(st,LABEL_MSG4,"site:MSG4");
578 }
579
580 static bool_t process_msg4(struct site *st, struct buffer_if *msg4,
581                            const struct comm_addr *src)
582 {
583     struct msg m;
584     uint8_t *hash;
585     void *hst;
586     cstring_t err;
587
588     if (!unpick_msg(st,LABEL_MSG4,msg4,&m)) return False;
589     if (!check_msg(st,LABEL_MSG4,&m,&err)) {
590         slog(st,LOG_SEC,"msg4: %s",err);
591         return False;
592     }
593     
594     /* Check signature and store g^x mod m */
595     hash=safe_malloc(st->hash->len, "process_msg4");
596     hst=st->hash->init();
597     st->hash->update(hst,m.hashstart,m.hashlen);
598     st->hash->final(hst,hash);
599     /* Terminate signature with a '0' - cheating, but should be ok */
600     m.sig[m.siglen]=0;
601     if (!st->pubkey->check(st->pubkey->st,hash,st->hash->len,m.sig)) {
602         slog(st,LOG_SEC,"msg4 signature failed check!");
603         free(hash);
604         return False;
605     }
606     free(hash);
607
608     /* Terminate their DH public key with a '0' */
609     m.pk[m.pklen]=0;
610     /* Generate the shared key */
611     st->dh->makeshared(st->dh->st,st->dhsecret,st->dh->len,m.pk,
612                        st->sharedsecret,st->transform->keylen);
613     /* Set up the transform */
614     st->new_transform->setkey(st->new_transform->st,st->sharedsecret,
615                               st->transform->keylen);
616
617     return True;
618 }
619
620 struct msg0 {
621     uint32_t dest;
622     uint32_t source;
623     uint32_t type;
624 };
625
626 static bool_t unpick_msg0(struct site *st, struct buffer_if *msg0,
627                           struct msg0 *m)
628 {
629     CHECK_AVAIL(msg0,4);
630     m->dest=buf_unprepend_uint32(msg0);
631     CHECK_AVAIL(msg0,4);
632     m->source=buf_unprepend_uint32(msg0);
633     CHECK_AVAIL(msg0,4);
634     m->type=buf_unprepend_uint32(msg0);
635     return True;
636     /* Leaves transformed part of buffer untouched */
637 }
638
639 static bool_t generate_msg5(struct site *st)
640 {
641     cstring_t transform_err;
642
643     BUF_ALLOC(&st->buffer,"site:MSG5");
644     /* We are going to add four words to the message */
645     buffer_init(&st->buffer,st->transform->max_start_pad+(4*4));
646     /* Give the netlink code an opportunity to put its own stuff in the
647        message (configuration information, etc.) */
648     buf_prepend_uint32(&st->buffer,LABEL_MSG5);
649     st->new_transform->forwards(st->new_transform->st,&st->buffer,
650                                 &transform_err);
651     buf_prepend_uint32(&st->buffer,LABEL_MSG5);
652     buf_prepend_uint32(&st->buffer,st->index);
653     buf_prepend_uint32(&st->buffer,st->setup_session_id);
654
655     st->retries=st->setup_retries;
656     return True;
657 }
658
659 static bool_t process_msg5(struct site *st, struct buffer_if *msg5,
660                            const struct comm_addr *src,
661                            struct transform_inst_if *transform)
662 {
663     struct msg0 m;
664     cstring_t transform_err;
665
666     if (!unpick_msg0(st,msg5,&m)) return False;
667
668     if (transform->reverse(transform->st,msg5,&transform_err)) {
669         /* There's a problem */
670         slog(st,LOG_SEC,"process_msg5: transform: %s",transform_err);
671         return False;
672     }
673     /* Buffer should now contain untransformed PING packet data */
674     CHECK_AVAIL(msg5,4);
675     if (buf_unprepend_uint32(msg5)!=LABEL_MSG5) {
676         slog(st,LOG_SEC,"MSG5/PING packet contained wrong label");
677         return False;
678     }
679     /* Older versions of secnet used to write some config data here
680      * which we ignore.  So we don't CHECK_EMPTY */
681     return True;
682 }
683
684 static void create_msg6(struct site *st, struct transform_inst_if *transform,
685                         uint32_t session_id)
686 {
687     cstring_t transform_err;
688
689     BUF_ALLOC(&st->buffer,"site:MSG6");
690     /* We are going to add four words to the message */
691     buffer_init(&st->buffer,st->transform->max_start_pad+(4*4));
692     /* Give the netlink code an opportunity to put its own stuff in the
693        message (configuration information, etc.) */
694     buf_prepend_uint32(&st->buffer,LABEL_MSG6);
695     transform->forwards(transform->st,&st->buffer,&transform_err);
696     buf_prepend_uint32(&st->buffer,LABEL_MSG6);
697     buf_prepend_uint32(&st->buffer,st->index);
698     buf_prepend_uint32(&st->buffer,session_id);
699 }
700
701 static bool_t generate_msg6(struct site *st)
702 {
703     create_msg6(st,st->new_transform,st->setup_session_id);
704     st->retries=1; /* Peer will retransmit MSG5 if this packet gets lost */
705     return True;
706 }
707
708 static bool_t process_msg6(struct site *st, struct buffer_if *msg6,
709                            const struct comm_addr *src)
710 {
711     struct msg0 m;
712     cstring_t transform_err;
713
714     if (!unpick_msg0(st,msg6,&m)) return False;
715
716     if (st->new_transform->reverse(st->new_transform->st,
717                                    msg6,&transform_err)) {
718         /* There's a problem */
719         slog(st,LOG_SEC,"process_msg6: transform: %s",transform_err);
720         return False;
721     }
722     /* Buffer should now contain untransformed PING packet data */
723     CHECK_AVAIL(msg6,4);
724     if (buf_unprepend_uint32(msg6)!=LABEL_MSG6) {
725         slog(st,LOG_SEC,"MSG6/PONG packet contained invalid data");
726         return False;
727     }
728     /* Older versions of secnet used to write some config data here
729      * which we ignore.  So we don't CHECK_EMPTY */
730     return True;
731 }
732
733 static bool_t decrypt_msg0(struct site *st, struct buffer_if *msg0)
734 {
735     cstring_t transform_err, auxkey_err, newkey_err="n/a";
736     struct msg0 m;
737     uint32_t problem;
738
739     if (!unpick_msg0(st,msg0,&m)) return False;
740
741     /* Keep a copy so we can try decrypting it with multiple keys */
742     buffer_copy(&st->scratch, msg0);
743
744     problem = st->current.transform->reverse(st->current.transform->st,
745                                              msg0,&transform_err);
746     if (!problem) {
747         if (!st->auxiliary_is_new)
748             delete_one_key(st,&st->auxiliary_key,
749                            "peer has used new key","auxiliary key",LOG_SEC);
750         return True;
751     }
752
753     if (problem==2) {
754         slog(st,LOG_DROP,"transform: %s (merely skew)",transform_err);
755         return False;
756     }
757
758     buffer_copy(msg0, &st->scratch);
759     problem = st->auxiliary_key.transform->reverse
760         (st->auxiliary_key.transform->st,msg0,&auxkey_err);
761     if (problem==0) {
762         slog(st,LOG_DROP,"processing packet which uses auxiliary key");
763         if (st->auxiliary_is_new) {
764             /* We previously timed out in state SENTMSG5 but it turns
765              * out that our peer did in fact get our MSG5 and is
766              * using the new key.  So we should switch to it too. */
767             /* This is a bit like activate_new_key. */
768             struct data_key t;
769             t=st->current;
770             st->current=st->auxiliary_key;
771             st->auxiliary_key=t;
772
773             delete_one_key(st,&st->auxiliary_key,"peer has used new key",
774                            "previous key",LOG_SEC);
775             st->auxiliary_is_new=0;
776             st->renegotiate_key_time=st->auxiliary_renegotiate_key_time;
777         }
778         return True;
779     }
780
781     if (st->state==SITE_SENTMSG5) {
782         buffer_copy(msg0, &st->scratch);
783         if (!st->new_transform->reverse(st->new_transform->st,
784                                         msg0,&newkey_err)) {
785             /* It looks like we didn't get the peer's MSG6 */
786             /* This is like a cut-down enter_new_state(SITE_RUN) */
787             slog(st,LOG_STATE,"will enter state RUN (MSG0 with new key)");
788             BUF_FREE(&st->buffer);
789             st->timeout=0;
790             activate_new_key(st);
791             return True; /* do process the data in this packet */
792         }
793     }
794
795     slog(st,LOG_SEC,"transform: %s (aux: %s, new: %s)",
796          transform_err,auxkey_err,newkey_err);
797     initiate_key_setup(st,"incoming message would not decrypt");
798     return False;
799 }
800
801 static bool_t process_msg0(struct site *st, struct buffer_if *msg0,
802                            const struct comm_addr *src)
803 {
804     uint32_t type;
805
806     if (!decrypt_msg0(st,msg0))
807         return False;
808
809     CHECK_AVAIL(msg0,4);
810     type=buf_unprepend_uint32(msg0);
811     switch(type) {
812     case LABEL_MSG7:
813         /* We must forget about the current session. */
814         delete_keys(st,"request from peer",LOG_SEC);
815         return True;
816     case LABEL_MSG9:
817         /* Deliver to netlink layer */
818         st->netlink->deliver(st->netlink->st,msg0);
819         transport_data_msgok(st,src);
820         /* See whether we should start negotiating a new key */
821         if (st->now > st->renegotiate_key_time)
822             initiate_key_setup(st,"incoming packet in renegotiation window");
823         return True;
824     default:
825         slog(st,LOG_SEC,"incoming encrypted message of type %08x "
826              "(unknown)",type);
827         break;
828     }
829     return False;
830 }
831
832 static void dump_packet(struct site *st, struct buffer_if *buf,
833                         const struct comm_addr *addr, bool_t incoming)
834 {
835     uint32_t dest=ntohl(*(uint32_t *)buf->start);
836     uint32_t source=ntohl(*(uint32_t *)(buf->start+4));
837     uint32_t msgtype=ntohl(*(uint32_t *)(buf->start+8));
838
839     if (st->log_events & LOG_DUMP)
840         slilog(st->log,M_DEBUG,"%s: %s: %08x<-%08x: %08x:",
841                st->tunname,incoming?"incoming":"outgoing",
842                dest,source,msgtype);
843 }
844
845 static uint32_t site_status(void *st)
846 {
847     return 0;
848 }
849
850 static bool_t send_msg(struct site *st)
851 {
852     if (st->retries>0) {
853         transport_xmit(st, &st->setup_peers, &st->buffer, True);
854         st->timeout=st->now+st->setup_retry_interval;
855         st->retries--;
856         return True;
857     } else if (st->state==SITE_SENTMSG5) {
858         slog(st,LOG_SETUP_TIMEOUT,"timed out sending MSG5, stashing new key");
859         /* We stash the key we have produced, in case it turns out that
860          * our peer did see our MSG5 after all and starts using it. */
861         /* This is a bit like some of activate_new_key */
862         struct transform_inst_if *t;
863         t=st->auxiliary_key.transform;
864         st->auxiliary_key.transform=st->new_transform;
865         st->new_transform=t;
866
867         t->delkey(t->st);
868         st->auxiliary_is_new=1;
869         st->auxiliary_key.key_timeout=st->now+st->key_lifetime;
870         st->auxiliary_renegotiate_key_time=st->now+st->key_renegotiate_time;
871         st->auxiliary_key.remote_session_id=st->setup_session_id;
872
873         enter_state_wait(st);
874         return False;
875     } else {
876         slog(st,LOG_SETUP_TIMEOUT,"timed out sending key setup packet "
877             "(in state %s)",state_name(st->state));
878         enter_state_wait(st);
879         return False;
880     }
881 }
882
883 static void site_resolve_callback(void *sst, struct in_addr *address)
884 {
885     struct site *st=sst;
886     struct comm_addr ca_buf, *ca_use;
887
888     if (st->state!=SITE_RESOLVE) {
889         slog(st,LOG_UNEXPECTED,"site_resolve_callback called unexpectedly");
890         return;
891     }
892     if (address) {
893         FILLZERO(ca_buf);
894         ca_buf.comm=st->comms[0];
895         ca_buf.sin.sin_family=AF_INET;
896         ca_buf.sin.sin_port=htons(st->remoteport);
897         ca_buf.sin.sin_addr=*address;
898         ca_use=&ca_buf;
899     } else {
900         slog(st,LOG_ERROR,"resolution of %s failed",st->address);
901         ca_use=0;
902     }
903     if (transport_compute_setupinit_peers(st,ca_use)) {
904         enter_new_state(st,SITE_SENTMSG1);
905     } else {
906         /* Can't figure out who to try to to talk to */
907         slog(st,LOG_SETUP_INIT,"key exchange failed: cannot find peer address");
908         enter_state_run(st);
909     }
910 }
911
912 static bool_t initiate_key_setup(struct site *st, cstring_t reason)
913 {
914     if (st->state!=SITE_RUN) return False;
915     slog(st,LOG_SETUP_INIT,"initiating key exchange (%s)",reason);
916     if (st->address) {
917         slog(st,LOG_SETUP_INIT,"resolving peer address");
918         return enter_state_resolve(st);
919     } else if (transport_compute_setupinit_peers(st,0)) {
920         return enter_new_state(st,SITE_SENTMSG1);
921     }
922     slog(st,LOG_SETUP_INIT,"key exchange failed: no address for peer");
923     return False;
924 }
925
926 static void activate_new_key(struct site *st)
927 {
928     struct transform_inst_if *t;
929
930     /* We have three transform instances, which we swap between old,
931        active and setup */
932     t=st->auxiliary_key.transform;
933     st->auxiliary_key.transform=st->current.transform;
934     st->current.transform=st->new_transform;
935     st->new_transform=t;
936
937     t->delkey(t->st);
938     st->timeout=0;
939     st->auxiliary_is_new=0;
940     st->auxiliary_key.key_timeout=st->current.key_timeout;
941     st->current.key_timeout=st->now+st->key_lifetime;
942     st->renegotiate_key_time=st->now+st->key_renegotiate_time;
943     transport_peers_copy(st,&st->peers,&st->setup_peers);
944     st->current.remote_session_id=st->setup_session_id;
945
946     slog(st,LOG_ACTIVATE_KEY,"new key activated");
947     enter_state_run(st);
948 }
949
950 static void delete_one_key(struct site *st, struct data_key *key,
951                            cstring_t reason, cstring_t which, uint32_t loglevel)
952 {
953     if (!key->transform->valid(key->transform->st)) return;
954     if (reason) slog(st,loglevel,"%s deleted (%s)",which,reason);
955     key->transform->delkey(key->transform->st);
956     key->key_timeout=0;
957 }
958
959 static void delete_keys(struct site *st, cstring_t reason, uint32_t loglevel)
960 {
961     if (current_valid(st)) {
962         slog(st,loglevel,"session closed (%s)",reason);
963
964         delete_one_key(st,&st->current,0,0,0);
965         set_link_quality(st);
966     }
967     delete_one_key(st,&st->auxiliary_key,0,0,0);
968 }
969
970 static void state_assert(struct site *st, bool_t ok)
971 {
972     if (!ok) fatal("site:state_assert");
973 }
974
975 static void enter_state_stop(struct site *st)
976 {
977     st->state=SITE_STOP;
978     st->timeout=0;
979     delete_keys(st,"entering state STOP",LOG_TIMEOUT_KEY);
980     st->new_transform->delkey(st->new_transform->st);
981 }
982
983 static void set_link_quality(struct site *st)
984 {
985     uint32_t quality;
986     if (current_valid(st))
987         quality=LINK_QUALITY_UP;
988     else if (st->state==SITE_WAIT || st->state==SITE_STOP)
989         quality=LINK_QUALITY_DOWN;
990     else if (st->address)
991         quality=LINK_QUALITY_DOWN_CURRENT_ADDRESS;
992     else if (transport_peers_valid(&st->peers))
993         quality=LINK_QUALITY_DOWN_STALE_ADDRESS;
994     else
995         quality=LINK_QUALITY_DOWN;
996
997     st->netlink->set_quality(st->netlink->st,quality);
998 }
999
1000 static void enter_state_run(struct site *st)
1001 {
1002     slog(st,LOG_STATE,"entering state RUN");
1003     st->state=SITE_RUN;
1004     st->timeout=0;
1005
1006     st->setup_session_id=0;
1007     transport_peers_clear(st,&st->setup_peers);
1008     memset(st->localN,0,NONCELEN);
1009     memset(st->remoteN,0,NONCELEN);
1010     st->new_transform->delkey(st->new_transform->st);
1011     memset(st->dhsecret,0,st->dh->len);
1012     memset(st->sharedsecret,0,st->transform->keylen);
1013     set_link_quality(st);
1014 }
1015
1016 static bool_t enter_state_resolve(struct site *st)
1017 {
1018     state_assert(st,st->state==SITE_RUN);
1019     slog(st,LOG_STATE,"entering state RESOLVE");
1020     st->state=SITE_RESOLVE;
1021     st->resolver->request(st->resolver->st,st->address,
1022                           site_resolve_callback,st);
1023     return True;
1024 }
1025
1026 static bool_t enter_new_state(struct site *st, uint32_t next)
1027 {
1028     bool_t (*gen)(struct site *st);
1029     int r;
1030
1031     slog(st,LOG_STATE,"entering state %s",state_name(next));
1032     switch(next) {
1033     case SITE_SENTMSG1:
1034         state_assert(st,st->state==SITE_RUN || st->state==SITE_RESOLVE);
1035         gen=generate_msg1;
1036         break;
1037     case SITE_SENTMSG2:
1038         state_assert(st,st->state==SITE_RUN || st->state==SITE_RESOLVE ||
1039                      st->state==SITE_SENTMSG1 || st->state==SITE_WAIT);
1040         gen=generate_msg2;
1041         break;
1042     case SITE_SENTMSG3:
1043         state_assert(st,st->state==SITE_SENTMSG1);
1044         BUF_FREE(&st->buffer);
1045         gen=generate_msg3;
1046         break;
1047     case SITE_SENTMSG4:
1048         state_assert(st,st->state==SITE_SENTMSG2);
1049         BUF_FREE(&st->buffer);
1050         gen=generate_msg4;
1051         break;
1052     case SITE_SENTMSG5:
1053         state_assert(st,st->state==SITE_SENTMSG3);
1054         BUF_FREE(&st->buffer);
1055         gen=generate_msg5;
1056         break;
1057     case SITE_RUN:
1058         state_assert(st,st->state==SITE_SENTMSG4);
1059         BUF_FREE(&st->buffer);
1060         gen=generate_msg6;
1061         break;
1062     default:
1063         gen=NULL;
1064         fatal("enter_new_state(%s): invalid new state",state_name(next));
1065         break;
1066     }
1067
1068     if (hacky_par_start_failnow()) return False;
1069
1070     r= gen(st) && send_msg(st);
1071
1072     hacky_par_end(&r,
1073                   st->setup_retries, st->setup_retry_interval,
1074                   send_msg, st);
1075     
1076     if (r) {
1077         st->state=next;
1078         if (next==SITE_RUN) {
1079             BUF_FREE(&st->buffer); /* Never reused */
1080             st->timeout=0; /* Never retransmit */
1081             activate_new_key(st);
1082         }
1083         return True;
1084     }
1085     slog(st,LOG_ERROR,"error entering state %s",state_name(next));
1086     st->buffer.free=False; /* Unconditionally use the buffer; it may be
1087                               in either state, and enter_state_wait() will
1088                               do a BUF_FREE() */
1089     enter_state_wait(st);
1090     return False;
1091 }
1092
1093 /* msg7 tells our peer that we're about to forget our key */
1094 static bool_t send_msg7(struct site *st, cstring_t reason)
1095 {
1096     cstring_t transform_err;
1097
1098     if (current_valid(st) && st->buffer.free
1099         && transport_peers_valid(&st->peers)) {
1100         BUF_ALLOC(&st->buffer,"site:MSG7");
1101         buffer_init(&st->buffer,st->transform->max_start_pad+(4*3));
1102         buf_append_uint32(&st->buffer,LABEL_MSG7);
1103         buf_append_string(&st->buffer,reason);
1104         st->current.transform->forwards(st->current.transform->st,
1105                                         &st->buffer, &transform_err);
1106         buf_prepend_uint32(&st->buffer,LABEL_MSG0);
1107         buf_prepend_uint32(&st->buffer,st->index);
1108         buf_prepend_uint32(&st->buffer,st->current.remote_session_id);
1109         transport_xmit(st,&st->peers,&st->buffer,True);
1110         BUF_FREE(&st->buffer);
1111         return True;
1112     }
1113     return False;
1114 }
1115
1116 /* We go into this state if our peer becomes uncommunicative. Similar to
1117    the "stop" state, we forget all session keys for a while, before
1118    re-entering the "run" state. */
1119 static void enter_state_wait(struct site *st)
1120 {
1121     slog(st,LOG_STATE,"entering state WAIT");
1122     st->timeout=st->now+st->wait_timeout;
1123     st->state=SITE_WAIT;
1124     set_link_quality(st);
1125     BUF_FREE(&st->buffer); /* will have had an outgoing packet in it */
1126     /* XXX Erase keys etc. */
1127 }
1128
1129 static inline void site_settimeout(uint64_t timeout, int *timeout_io)
1130 {
1131     if (timeout) {
1132         int64_t offset=timeout-*now;
1133         if (offset<0) offset=0;
1134         if (offset>INT_MAX) offset=INT_MAX;
1135         if (*timeout_io<0 || offset<*timeout_io)
1136             *timeout_io=offset;
1137     }
1138 }
1139
1140 static int site_beforepoll(void *sst, struct pollfd *fds, int *nfds_io,
1141                            int *timeout_io)
1142 {
1143     struct site *st=sst;
1144
1145     *nfds_io=0; /* We don't use any file descriptors */
1146     st->now=*now;
1147
1148     /* Work out when our next timeout is. The earlier of 'timeout' or
1149        'current.key_timeout'. A stored value of '0' indicates no timeout
1150        active. */
1151     site_settimeout(st->timeout, timeout_io);
1152     site_settimeout(st->current.key_timeout, timeout_io);
1153     site_settimeout(st->auxiliary_key.key_timeout, timeout_io);
1154
1155     return 0; /* success */
1156 }
1157
1158 static void check_expiry(struct site *st, struct data_key *key,
1159                          const char *which)
1160 {
1161     if (key->key_timeout && *now>key->key_timeout) {
1162         delete_one_key(st,key,"maximum life exceeded",which,LOG_TIMEOUT_KEY);
1163     }
1164 }
1165
1166 /* NB site_afterpoll will be called before site_beforepoll is ever called */
1167 static void site_afterpoll(void *sst, struct pollfd *fds, int nfds)
1168 {
1169     struct site *st=sst;
1170
1171     st->now=*now;
1172     if (st->timeout && *now>st->timeout) {
1173         st->timeout=0;
1174         if (st->state>=SITE_SENTMSG1 && st->state<=SITE_SENTMSG5) {
1175             if (!hacky_par_start_failnow())
1176                 send_msg(st);
1177         } else if (st->state==SITE_WAIT) {
1178             enter_state_run(st);
1179         } else {
1180             slog(st,LOG_ERROR,"site_afterpoll: unexpected timeout, state=%d",
1181                  st->state);
1182         }
1183     }
1184     check_expiry(st,&st->current,"current key");
1185     check_expiry(st,&st->auxiliary_key,"auxiliary key");
1186 }
1187
1188 /* This function is called by the netlink device to deliver packets
1189    intended for the remote network. The packet is in "raw" wire
1190    format, but is guaranteed to be word-aligned. */
1191 static void site_outgoing(void *sst, struct buffer_if *buf)
1192 {
1193     struct site *st=sst;
1194     cstring_t transform_err;
1195     
1196     if (st->state==SITE_STOP) {
1197         BUF_FREE(buf);
1198         return;
1199     }
1200
1201     /* In all other states we consider delivering the packet if we have
1202        a valid key and a valid address to send it to. */
1203     if (current_valid(st) && transport_peers_valid(&st->peers)) {
1204         /* Transform it and send it */
1205         if (buf->size>0) {
1206             buf_prepend_uint32(buf,LABEL_MSG9);
1207             st->current.transform->forwards(st->current.transform->st,
1208                                             buf, &transform_err);
1209             buf_prepend_uint32(buf,LABEL_MSG0);
1210             buf_prepend_uint32(buf,st->index);
1211             buf_prepend_uint32(buf,st->current.remote_session_id);
1212             transport_xmit(st,&st->peers,buf,False);
1213         }
1214         BUF_FREE(buf);
1215         return;
1216     }
1217
1218     slog(st,LOG_DROP,"discarding outgoing packet of size %d",buf->size);
1219     BUF_FREE(buf);
1220     initiate_key_setup(st,"outgoing packet");
1221 }
1222
1223 /* This function is called by the communication device to deliver
1224    packets from our peers. */
1225 static bool_t site_incoming(void *sst, struct buffer_if *buf,
1226                             const struct comm_addr *source)
1227 {
1228     struct site *st=sst;
1229
1230     if (buf->size < 12) return False;
1231
1232     uint32_t dest=ntohl(*(uint32_t *)buf->start);
1233
1234     if (dest==0) {
1235         /* It could be for any site - it should have LABEL_MSG1 and
1236            might have our name and our peer's name in it */
1237         if (buf->size<(st->setupsiglen+8+NONCELEN)) return False;
1238         if (memcmp(buf->start+8,st->setupsig,st->setupsiglen)==0) {
1239             /* It's addressed to us. Decide what to do about it. */
1240             dump_packet(st,buf,source,True);
1241             if (st->state==SITE_RUN || st->state==SITE_RESOLVE ||
1242                 st->state==SITE_WAIT) {
1243                 /* We should definitely process it */
1244                 if (process_msg1(st,buf,source)) {
1245                     slog(st,LOG_SETUP_INIT,"key setup initiated by peer");
1246                     enter_new_state(st,SITE_SENTMSG2);
1247                 } else {
1248                     slog(st,LOG_ERROR,"failed to process incoming msg1");
1249                 }
1250                 BUF_FREE(buf);
1251                 return True;
1252             } else if (st->state==SITE_SENTMSG1) {
1253                 /* We've just sent a message 1! They may have crossed on
1254                    the wire. If we have priority then we ignore the
1255                    incoming one, otherwise we process it as usual. */
1256                 if (st->setup_priority) {
1257                     BUF_FREE(buf);
1258                     slog(st,LOG_DUMP,"crossed msg1s; we are higher "
1259                          "priority => ignore incoming msg1");
1260                     return True;
1261                 } else {
1262                     slog(st,LOG_DUMP,"crossed msg1s; we are lower "
1263                          "priority => use incoming msg1");
1264                     if (process_msg1(st,buf,source)) {
1265                         BUF_FREE(&st->buffer); /* Free our old message 1 */
1266                         enter_new_state(st,SITE_SENTMSG2);
1267                     } else {
1268                         slog(st,LOG_ERROR,"failed to process an incoming "
1269                              "crossed msg1 (we have low priority)");
1270                     }
1271                     BUF_FREE(buf);
1272                     return True;
1273                 }
1274             }
1275             /* The message 1 was received at an unexpected stage of the
1276                key setup. XXX POLICY - what do we do? */
1277             slog(st,LOG_UNEXPECTED,"unexpected incoming message 1");
1278             BUF_FREE(buf);
1279             return True;
1280         }
1281         return False; /* Not for us. */
1282     }
1283     if (dest==st->index) {
1284         /* Explicitly addressed to us */
1285         uint32_t msgtype=ntohl(get_uint32(buf->start+8));
1286         if (msgtype!=LABEL_MSG0) dump_packet(st,buf,source,True);
1287         switch (msgtype) {
1288         case 0: /* NAK */
1289             /* If the source is our current peer then initiate a key setup,
1290                because our peer's forgotten the key */
1291             if (get_uint32(buf->start+4)==st->current.remote_session_id) {
1292                 initiate_key_setup(st,"received a NAK");
1293             } else {
1294                 slog(st,LOG_SEC,"bad incoming NAK");
1295             }
1296             break;
1297         case LABEL_MSG0:
1298             process_msg0(st,buf,source);
1299             break;
1300         case LABEL_MSG1:
1301             /* Setup packet: should not have been explicitly addressed
1302                to us */
1303             slog(st,LOG_SEC,"incoming explicitly addressed msg1");
1304             break;
1305         case LABEL_MSG2:
1306             /* Setup packet: expected only in state SENTMSG1 */
1307             if (st->state!=SITE_SENTMSG1) {
1308                 slog(st,LOG_UNEXPECTED,"unexpected MSG2");
1309             } else if (process_msg2(st,buf,source)) {
1310                 transport_setup_msgok(st,source);
1311                 enter_new_state(st,SITE_SENTMSG3);
1312             } else {
1313                 slog(st,LOG_SEC,"invalid MSG2");
1314             }
1315             break;
1316         case LABEL_MSG3:
1317             /* Setup packet: expected only in state SENTMSG2 */
1318             if (st->state!=SITE_SENTMSG2) {
1319                 slog(st,LOG_UNEXPECTED,"unexpected MSG3");
1320             } else if (process_msg3(st,buf,source)) {
1321                 transport_setup_msgok(st,source);
1322                 enter_new_state(st,SITE_SENTMSG4);
1323             } else {
1324                 slog(st,LOG_SEC,"invalid MSG3");
1325             }
1326             break;
1327         case LABEL_MSG4:
1328             /* Setup packet: expected only in state SENTMSG3 */
1329             if (st->state!=SITE_SENTMSG3) {
1330                 slog(st,LOG_UNEXPECTED,"unexpected MSG4");
1331             } else if (process_msg4(st,buf,source)) {
1332                 transport_setup_msgok(st,source);
1333                 enter_new_state(st,SITE_SENTMSG5);
1334             } else {
1335                 slog(st,LOG_SEC,"invalid MSG4");
1336             }
1337             break;
1338         case LABEL_MSG5:
1339             /* Setup packet: expected only in state SENTMSG4 */
1340             /* (may turn up in state RUN if our return MSG6 was lost
1341                and the new key has already been activated. In that
1342                case we discard it. The peer will realise that we
1343                are using the new key when they see our data packets.
1344                Until then the peer's data packets to us get discarded. */
1345             if (st->state==SITE_SENTMSG4) {
1346                 if (process_msg5(st,buf,source,st->new_transform)) {
1347                     transport_setup_msgok(st,source);
1348                     enter_new_state(st,SITE_RUN);
1349                 } else {
1350                     slog(st,LOG_SEC,"invalid MSG5");
1351                 }
1352             } else if (st->state==SITE_RUN) {
1353                 if (process_msg5(st,buf,source,st->current.transform)) {
1354                     slog(st,LOG_DROP,"got MSG5, retransmitting MSG6");
1355                     transport_setup_msgok(st,source);
1356                     create_msg6(st,st->current.transform,
1357                                 st->current.remote_session_id);
1358                     transport_xmit(st,&st->peers,&st->buffer,True);
1359                     BUF_FREE(&st->buffer);
1360                 } else {
1361                     slog(st,LOG_SEC,"invalid MSG5 (in state RUN)");
1362                 }
1363             } else {
1364                 slog(st,LOG_UNEXPECTED,"unexpected MSG5");
1365             }
1366             break;
1367         case LABEL_MSG6:
1368             /* Setup packet: expected only in state SENTMSG5 */
1369             if (st->state!=SITE_SENTMSG5) {
1370                 slog(st,LOG_UNEXPECTED,"unexpected MSG6");
1371             } else if (process_msg6(st,buf,source)) {
1372                 BUF_FREE(&st->buffer); /* Free message 5 */
1373                 transport_setup_msgok(st,source);
1374                 activate_new_key(st);
1375             } else {
1376                 slog(st,LOG_SEC,"invalid MSG6");
1377             }
1378             break;
1379         default:
1380             slog(st,LOG_SEC,"received message of unknown type 0x%08x",
1381                  msgtype);
1382             break;
1383         }
1384         BUF_FREE(buf);
1385         return True;
1386     }
1387
1388     return False;
1389 }
1390
1391 static void site_control(void *vst, bool_t run)
1392 {
1393     struct site *st=vst;
1394     if (run) enter_state_run(st);
1395     else enter_state_stop(st);
1396 }
1397
1398 static void site_phase_hook(void *sst, uint32_t newphase)
1399 {
1400     struct site *st=sst;
1401
1402     /* The program is shutting down; tell our peer */
1403     send_msg7(st,"shutting down");
1404 }
1405
1406 static list_t *site_apply(closure_t *self, struct cloc loc, dict_t *context,
1407                           list_t *args)
1408 {
1409     static uint32_t index_sequence;
1410     struct site *st;
1411     item_t *item;
1412     dict_t *dict;
1413     int i;
1414
1415     st=safe_malloc(sizeof(*st),"site_apply");
1416
1417     st->cl.description="site";
1418     st->cl.type=CL_SITE;
1419     st->cl.apply=NULL;
1420     st->cl.interface=&st->ops;
1421     st->ops.st=st;
1422     st->ops.control=site_control;
1423     st->ops.status=site_status;
1424
1425     /* First parameter must be a dict */
1426     item=list_elem(args,0);
1427     if (!item || item->type!=t_dict)
1428         cfgfatal(loc,"site","parameter must be a dictionary\n");
1429     
1430     dict=item->data.dict;
1431     st->localname=dict_read_string(dict, "local-name", True, "site", loc);
1432     st->remotename=dict_read_string(dict, "name", True, "site", loc);
1433
1434     st->peer_mobile=dict_read_bool(dict,"mobile",False,"site",loc,False);
1435     bool_t local_mobile=
1436         dict_read_bool(dict,"local-mobile",False,"site",loc,False);
1437
1438     /* Sanity check (which also allows the 'sites' file to include
1439        site() closures for all sites including our own): refuse to
1440        talk to ourselves */
1441     if (strcmp(st->localname,st->remotename)==0) {
1442         Message(M_DEBUG,"site %s: local-name==name -> ignoring this site\n",
1443                 st->localname);
1444         if (st->peer_mobile != local_mobile)
1445             cfgfatal(loc,"site","site %s's peer-mobile=%d"
1446                     " but our local-mobile=%d\n",
1447                     st->localname, st->peer_mobile, local_mobile);
1448         free(st);
1449         return NULL;
1450     }
1451     if (st->peer_mobile && local_mobile) {
1452         Message(M_WARNING,"site %s: site is mobile but so are we"
1453                 " -> ignoring this site\n", st->remotename);
1454         free(st);
1455         return NULL;
1456     }
1457
1458     assert(index_sequence < 0xffffffffUL);
1459     st->index = ++index_sequence;
1460     st->netlink=find_cl_if(dict,"link",CL_NETLINK,True,"site",loc);
1461
1462     list_t *comms_cfg=dict_lookup(dict,"comm");
1463     if (!comms_cfg) cfgfatal(loc,"site","closure list \"comm\" not found\n");
1464     st->ncomms=list_length(comms_cfg);
1465     st->comms=safe_malloc_ary(sizeof(*st->comms),st->ncomms,"comms");
1466     assert(st->ncomms);
1467     for (i=0; i<st->ncomms; i++) {
1468         item_t *item=list_elem(comms_cfg,i);
1469         if (item->type!=t_closure)
1470             cfgfatal(loc,"site","comm is not a closure\n");
1471         closure_t *cl=item->data.closure;
1472         if (cl->type!=CL_COMM) cfgfatal(loc,"site","comm closure wrong type\n");
1473         st->comms[i]=cl->interface;
1474     }
1475
1476     st->resolver=find_cl_if(dict,"resolver",CL_RESOLVER,True,"site",loc);
1477     st->log=find_cl_if(dict,"log",CL_LOG,True,"site",loc);
1478     st->random=find_cl_if(dict,"random",CL_RANDOMSRC,True,"site",loc);
1479
1480     st->privkey=find_cl_if(dict,"local-key",CL_RSAPRIVKEY,True,"site",loc);
1481     st->address=dict_read_string(dict, "address", False, "site", loc);
1482     if (st->address)
1483         st->remoteport=dict_read_number(dict,"port",True,"site",loc,0);
1484     else st->remoteport=0;
1485     st->pubkey=find_cl_if(dict,"key",CL_RSAPUBKEY,True,"site",loc);
1486
1487     st->transform=
1488         find_cl_if(dict,"transform",CL_TRANSFORM,True,"site",loc);
1489
1490     st->dh=find_cl_if(dict,"dh",CL_DH,True,"site",loc);
1491     st->hash=find_cl_if(dict,"hash",CL_HASH,True,"site",loc);
1492
1493 #define DEFAULT(D) (st->peer_mobile || local_mobile     \
1494                     ? DEFAULT_MOBILE_##D : DEFAULT_##D)
1495 #define CFG_NUMBER(k,D) dict_read_number(dict,(k),False,"site",loc,DEFAULT(D));
1496
1497     st->key_lifetime=         CFG_NUMBER("key-lifetime",  KEY_LIFETIME);
1498     st->setup_retries=        CFG_NUMBER("setup-retries", SETUP_RETRIES);
1499     st->setup_retry_interval= CFG_NUMBER("setup-timeout", SETUP_RETRY_INTERVAL);
1500     st->wait_timeout=         CFG_NUMBER("wait-time",     WAIT_TIME);
1501
1502     st->mobile_peer_expiry= dict_read_number(
1503        dict,"mobile-peer-expiry",False,"site",loc,DEFAULT_MOBILE_PEER_EXPIRY);
1504
1505     st->transport_peers_max= !st->peer_mobile ? 1 : dict_read_number(
1506         dict,"mobile-peers-max",False,"site",loc,DEFAULT_MOBILE_PEERS_MAX);
1507     if (st->transport_peers_max<1 ||
1508         st->transport_peers_max>=MAX_MOBILE_PEERS_MAX) {
1509         cfgfatal(loc,"site","mobile-peers-max must be in range 1.."
1510                  STRING(MAX_MOBILE_PEERS_MAX) "\n");
1511     }
1512
1513     if (st->key_lifetime < DEFAULT(KEY_RENEGOTIATE_GAP)*2)
1514         st->key_renegotiate_time=st->key_lifetime/2;
1515     else
1516         st->key_renegotiate_time=st->key_lifetime-DEFAULT(KEY_RENEGOTIATE_GAP);
1517     st->key_renegotiate_time=dict_read_number(
1518         dict,"renegotiate-time",False,"site",loc,st->key_renegotiate_time);
1519     if (st->key_renegotiate_time > st->key_lifetime) {
1520         cfgfatal(loc,"site",
1521                  "renegotiate-time must be less than key-lifetime\n");
1522     }
1523
1524     st->log_events=string_list_to_word(dict_lookup(dict,"log-events"),
1525                                        log_event_table,"site");
1526
1527     st->tunname=safe_malloc(strlen(st->localname)+strlen(st->remotename)+5,
1528                             "site_apply");
1529     sprintf(st->tunname,"%s<->%s",st->localname,st->remotename);
1530
1531     /* The information we expect to see in incoming messages of type 1 */
1532     /* fixme: lots of unchecked overflows here, but the results are only
1533        corrupted packets rather than undefined behaviour */
1534     st->setupsiglen=strlen(st->remotename)+strlen(st->localname)+8;
1535     st->setupsig=safe_malloc(st->setupsiglen,"site_apply");
1536     put_uint32(st->setupsig+0,LABEL_MSG1);
1537     put_uint16(st->setupsig+4,strlen(st->remotename));
1538     memcpy(&st->setupsig[6],st->remotename,strlen(st->remotename));
1539     put_uint16(st->setupsig+(6+strlen(st->remotename)),strlen(st->localname));
1540     memcpy(&st->setupsig[8+strlen(st->remotename)],st->localname,
1541            strlen(st->localname));
1542     st->setup_priority=(strcmp(st->localname,st->remotename)>0);
1543
1544     buffer_new(&st->buffer,SETUP_BUFFER_LEN);
1545
1546     buffer_new(&st->scratch,0);
1547     BUF_ALLOC(&st->scratch,"site:scratch");
1548
1549     /* We are interested in poll(), but only for timeouts. We don't have
1550        any fds of our own. */
1551     register_for_poll(st, site_beforepoll, site_afterpoll, 0, "site");
1552     st->timeout=0;
1553
1554     st->current.key_timeout=0;
1555     st->auxiliary_key.key_timeout=0;
1556     transport_peers_clear(st,&st->peers);
1557     transport_peers_clear(st,&st->setup_peers);
1558     /* XXX mlock these */
1559     st->dhsecret=safe_malloc(st->dh->len,"site:dhsecret");
1560     st->sharedsecret=safe_malloc(st->transform->keylen,"site:sharedsecret");
1561
1562     /* We need to compute some properties of our comms */
1563 #define COMPUTE_WORST(pad)                      \
1564     int worst_##pad=0;                          \
1565     for (i=0; i<st->ncomms; i++) {              \
1566         int thispad=st->comms[i]->pad;          \
1567         if (thispad > worst_##pad)              \
1568             worst_##pad=thispad;                \
1569     }
1570     COMPUTE_WORST(min_start_pad)
1571     COMPUTE_WORST(min_end_pad)
1572
1573     /* We need to register the remote networks with the netlink device */
1574     st->netlink->reg(st->netlink->st, site_outgoing, st,
1575                      st->transform->max_start_pad+(4*4)+
1576                      worst_min_start_pad,
1577                      st->transform->max_end_pad+worst_min_end_pad);
1578     
1579     for (i=0; i<st->ncomms; i++)
1580         st->comms[i]->request_notify(st->comms[i]->st, st, site_incoming);
1581
1582     st->current.transform=st->transform->create(st->transform->st);
1583     st->auxiliary_key.transform=st->transform->create(st->transform->st);
1584     st->new_transform=st->transform->create(st->transform->st);
1585     st->auxiliary_is_new=0;
1586
1587     enter_state_stop(st);
1588
1589     add_hook(PHASE_SHUTDOWN,site_phase_hook,st);
1590
1591     return new_closure(&st->cl);
1592 }
1593
1594 void site_module(dict_t *dict)
1595 {
1596     add_closure(dict,"site",site_apply);
1597 }
1598
1599
1600 /***** TRANSPORT PEERS definitions *****/
1601
1602 static void transport_peers_debug(struct site *st, transport_peers *dst,
1603                                   const char *didwhat,
1604                                   int nargs, const struct comm_addr *args,
1605                                   size_t stride) {
1606     int i;
1607     char *argp;
1608
1609     if (!(st->log_events & LOG_PEER_ADDRS))
1610         return; /* an optimisation */
1611
1612     slog(st, LOG_PEER_ADDRS, "peers (%s) %s nargs=%d => npeers=%d",
1613          (dst==&st->peers ? "data" :
1614           dst==&st->setup_peers ? "setup" : "UNKNOWN"),
1615          didwhat, nargs, dst->npeers);
1616
1617     for (i=0, argp=(void*)args;
1618          i<nargs;
1619          i++, (argp+=stride?stride:sizeof(*args))) {
1620         const struct comm_addr *ca=(void*)argp;
1621         slog(st, LOG_PEER_ADDRS, " args: addrs[%d]=%s",
1622              i, ca->comm->addr_to_string(ca->comm->st,ca));
1623     }
1624     for (i=0; i<dst->npeers; i++) {
1625         struct timeval diff;
1626         timersub(tv_now,&dst->peers[i].last,&diff);
1627         const struct comm_addr *ca=&dst->peers[i].addr;
1628         slog(st, LOG_PEER_ADDRS, " peers: addrs[%d]=%s T-%ld.%06ld",
1629              i, ca->comm->addr_to_string(ca->comm->st,ca),
1630              (unsigned long)diff.tv_sec, (unsigned long)diff.tv_usec);
1631     }
1632 }
1633
1634 static int transport_peer_compar(const void *av, const void *bv) {
1635     const transport_peer *a=av;
1636     const transport_peer *b=bv;
1637     /* put most recent first in the array */
1638     if (timercmp(&a->last, &b->last, <)) return +1;
1639     if (timercmp(&a->last, &b->last, >)) return -11;
1640     return 0;
1641 }
1642
1643 static void transport_peers_expire(struct site *st, transport_peers *peers) {
1644     /* peers must be sorted first */
1645     int previous_peers=peers->npeers;
1646     struct timeval oldest;
1647     oldest.tv_sec  = tv_now->tv_sec - st->mobile_peer_expiry;
1648     oldest.tv_usec = tv_now->tv_usec;
1649     while (peers->npeers>1 &&
1650            timercmp(&peers->peers[peers->npeers-1].last, &oldest, <))
1651         peers->npeers--;
1652     if (peers->npeers != previous_peers)
1653         transport_peers_debug(st,peers,"expire", 0,0,0);
1654 }
1655
1656 static void transport_record_peer(struct site *st, transport_peers *peers,
1657                                   const struct comm_addr *addr, const char *m) {
1658     int slot, changed=0;
1659
1660     for (slot=0; slot<peers->npeers; slot++)
1661         if (!memcmp(&peers->peers[slot].addr, addr, sizeof(*addr)))
1662             goto found;
1663
1664     changed=1;
1665     if (peers->npeers==st->transport_peers_max)
1666         slot=st->transport_peers_max;
1667     else
1668         slot=peers->npeers++;
1669
1670  found:
1671     peers->peers[slot].addr=*addr;
1672     peers->peers[slot].last=*tv_now;
1673
1674     if (peers->npeers>1)
1675         qsort(peers->peers, peers->npeers,
1676               sizeof(*peers->peers), transport_peer_compar);
1677
1678     if (changed || peers->npeers!=1)
1679         transport_peers_debug(st,peers,m, 1,addr,0);
1680     transport_peers_expire(st, peers);
1681 }
1682
1683 static bool_t transport_compute_setupinit_peers(struct site *st,
1684         const struct comm_addr *configured_addr /* 0 if none or not found */) {
1685
1686     if (!configured_addr && !transport_peers_valid(&st->peers))
1687         return False;
1688
1689     slog(st,LOG_SETUP_INIT,
1690          (!configured_addr ? "using only %d old peer address(es)"
1691           : "using configured address, and/or perhaps %d old peer address(es)"),
1692          st->peers);
1693
1694     /* Non-mobile peers havve st->peers.npeers==0 or ==1, since they
1695      * have transport_peers_max==1.  The effect is that this code
1696      * always uses the configured address if supplied, or otherwise
1697      * the existing data peer if one exists; this is as desired. */
1698
1699     transport_peers_copy(st,&st->setup_peers,&st->peers);
1700
1701     if (configured_addr)
1702         transport_record_peer(st,&st->setup_peers,configured_addr,"setupinit");
1703
1704     assert(transport_peers_valid(&st->setup_peers));
1705     return True;
1706 }
1707
1708 static void transport_setup_msgok(struct site *st, const struct comm_addr *a) {
1709     if (st->peer_mobile)
1710         transport_record_peer(st,&st->setup_peers,a,"setupmsg");
1711 }
1712 static void transport_data_msgok(struct site *st, const struct comm_addr *a) {
1713     if (st->peer_mobile)
1714         transport_record_peer(st,&st->peers,a,"datamsg");
1715 }
1716
1717 static int transport_peers_valid(transport_peers *peers) {
1718     return peers->npeers;
1719 }
1720 static void transport_peers_clear(struct site *st, transport_peers *peers) {
1721     peers->npeers= 0;
1722     transport_peers_debug(st,peers,"clear",0,0,0);
1723 }
1724 static void transport_peers_copy(struct site *st, transport_peers *dst,
1725                                  const transport_peers *src) {
1726     dst->npeers=src->npeers;
1727     memcpy(dst->peers, src->peers, sizeof(*dst->peers) * dst->npeers);
1728     transport_peers_debug(st,dst,"copy",
1729                           src->npeers, &src->peers->addr, sizeof(*src->peers));
1730 }
1731
1732 void transport_xmit(struct site *st, transport_peers *peers,
1733                     struct buffer_if *buf, bool_t candebug) {
1734     int slot;
1735     transport_peers_expire(st, peers);
1736     for (slot=0; slot<peers->npeers; slot++) {
1737         transport_peer *peer=&peers->peers[slot];
1738         if (candebug)
1739             dump_packet(st, buf, &peer->addr, False);
1740         peer->addr.comm->sendmsg(peer->addr.comm->st, buf, &peer->addr);
1741     }
1742 }
1743
1744 /***** END of transport peers declarations *****/