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