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