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