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