/* site.c - manage communication with a remote network site */
+/* The 'site' code doesn't know anything about the structure of the
+ packets it's transmitting. In fact, under the new netlink
+ configuration scheme it doesn't need to know anything at all about
+ IP addresses, except how to contact its peer. This means it could
+ potentially be used to tunnel other protocols too (IPv6, IPX, plain
+ old Ethernet frames) if appropriate netlink code can be written
+ (and that ought not to be too hard, eg. using the TUN/TAP device to
+ pretend to be an Ethernet interface). */
+
#include "secnet.h"
#include <stdio.h>
+#include <string.h>
/* MBM asserts the next one is needed for compilation under BSD. */
#include <sys/socket.h>
#define DEFAULT_KEY_RENEGOTIATE_GAP 300000 /* Five minutes */
#define DEFAULT_SETUP_RETRIES 5
#define DEFAULT_SETUP_TIMEOUT 1000
-#define DEFAULT_WAIT_TIME 10000
+#define DEFAULT_WAIT_TIME 20000
/* Each site can be in one of several possible states. */
#define SITE_SENTMSG5 7
#define SITE_WAIT 8
-#if 0
static string_t state_name(uint32_t state)
{
switch (state) {
- case 0: return "SITE_STOP";
- case 1: return "SITE_RUN";
- case 2: return "SITE_RESOLVE";
- case 3: return "SITE_SENTMSG1";
- case 4: return "SITE_SENTMSG2";
- case 5: return "SITE_SENTMSG3";
- case 6: return "SITE_SENTMSG4";
- case 7: return "SITE_SENTMSG5";
- case 8: return "SITE_WAIT";
+ case 0: return "STOP";
+ case 1: return "RUN";
+ case 2: return "RESOLVE";
+ case 3: return "SENTMSG1";
+ case 4: return "SENTMSG2";
+ case 5: return "SENTMSG3";
+ case 6: return "SENTMSG4";
+ case 7: return "SENTMSG5";
+ case 8: return "WAIT";
default: return "*bad state*";
}
}
-#endif /* 0 */
#define LABEL_MSG0 0x00020200
#define LABEL_MSG1 0x01010101
struct log_if *log;
struct random_if *random;
struct rsaprivkey_if *privkey;
- struct subnet_list remotenets;
struct rsapubkey_if *pubkey;
struct transform_if *transform;
struct dh_if *dh;
uint32_t state;
uint64_t now; /* Most recently seen time */
- void *netlink_cid;
-
uint32_t remote_session_id;
struct transform_inst_if *current_transform;
bool_t current_valid;
{
va_list ap;
uint8_t buf[240];
+ uint32_t class;
va_start(ap,msg);
if (event&st->log_events) {
+ switch(event) {
+ case LOG_UNEXPECTED: class=M_INFO; break;
+ case LOG_SETUP_INIT: class=M_INFO; break;
+ case LOG_SETUP_TIMEOUT: class=M_NOTICE; break;
+ case LOG_ACTIVATE_KEY: class=M_INFO; break;
+ case LOG_TIMEOUT_KEY: class=M_INFO; break;
+ case LOG_SEC: class=M_SECURITY; break;
+ case LOG_STATE: class=M_DEBUG; break;
+ case LOG_DROP: class=M_DEBUG; break;
+ case LOG_DUMP: class=M_DEBUG; break;
+ case LOG_ERROR: class=M_ERR; break;
+ default: class=M_ERR; break;
+ }
+
vsnprintf(buf,240,msg,ap);
- st->log->log(st->log->st,0,"%s: %s",st->tunname,buf);
+ st->log->log(st->log->st,class,"%s: %s",st->tunname,buf);
}
va_end(ap);
}
static void set_link_quality(struct site *st);
-static bool_t initiate_key_setup(struct site *st);
+static void delete_key(struct site *st, string_t reason, uint32_t loglevel);
+static bool_t initiate_key_setup(struct site *st, string_t reason);
static void enter_state_run(struct site *st);
static bool_t enter_state_resolve(struct site *st);
static bool_t enter_state_sentmsg1(struct site *st);
/* We are going to add three words to the transformed message */
buffer_init(&st->buffer,st->transform->max_start_pad+(4*3));
buf_append_uint32(&st->buffer,LABEL_MSG5);
+ /* Give the netlink code an opportunity to put its own stuff in the
+ message (configuration information, etc.) */
+ st->netlink->output_config(st->netlink->st,&st->buffer);
st->new_transform->forwards(st->new_transform->st,&st->buffer,
&transform_err);
buf_prepend_uint32(&st->buffer,LABEL_MSG5);
slog(st,LOG_SEC,"MSG5/PING packet contained invalid data");
return False;
}
+ if (!st->netlink->check_config(st->netlink->st,msg5)) {
+ slog(st,LOG_SEC,"MSG5/PING packet contained bad netlink config");
+ return False;
+ }
CHECK_EMPTY(msg5);
return True;
}
/* We are going to add three words to the transformed message */
buffer_init(&st->buffer,st->transform->max_start_pad+(4*3));
buf_append_uint32(&st->buffer,LABEL_MSG6);
+ /* Give the netlink code an opportunity to put its own stuff in the
+ message (configuration information, etc.) */
+ st->netlink->output_config(st->netlink->st,&st->buffer);
st->new_transform->forwards(st->new_transform->st,&st->buffer,
&transform_err);
buf_prepend_uint32(&st->buffer,LABEL_MSG6);
slog(st,LOG_SEC,"MSG6/PONG packet contained invalid data");
return False;
}
+ if (!st->netlink->check_config(st->netlink->st,msg6)) {
+ slog(st,LOG_SEC,"MSG6/PONG packet contained bad netlink config");
+ return False;
+ }
CHECK_EMPTY(msg6);
return True;
}
if (!st->current_valid) {
slog(st,LOG_DROP,"incoming message but no current key -> dropping");
- return initiate_key_setup(st);
+ return initiate_key_setup(st,"incoming message but no current key");
}
if (!unpick_msg0(st,msg0,&m)) return False;
msg0,&transform_err)) {
/* There's a problem */
slog(st,LOG_SEC,"transform: %s",transform_err);
- return False;
+ return initiate_key_setup(st,"incoming message would not decrypt");
}
CHECK_AVAIL(msg0,4);
type=buf_unprepend_uint32(msg0);
switch(type) {
+ case LABEL_MSG7:
+ /* We must forget about the current session. */
+ delete_key(st,"request from peer",LOG_SEC);
+ return True;
+ break;
case LABEL_MSG9:
/* Deliver to netlink layer */
- st->netlink->deliver(st->netlink->st,st->netlink_cid,msg0);
+ st->netlink->deliver(st->netlink->st,msg0);
return True;
break;
default:
uint32_t msgtype=ntohl(*(uint32_t *)(buf->start+8));
if (st->log_events & LOG_DUMP)
- log(st->log,0,"%s: %s: %08x<-%08x: %08x:",
+ log(st->log,M_DEBUG,"%s: %s: %08x<-%08x: %08x:",
st->tunname,incoming?"incoming":"outgoing",
dest,source,msgtype);
}
st->retries--;
return True;
} else {
- slog(st,LOG_SETUP_TIMEOUT,"timed out sending key setup packet");
+ slog(st,LOG_SETUP_TIMEOUT,"timed out sending key setup packet "
+ "(in state %s)",state_name(st->state));
enter_state_wait(st);
return False;
}
}
}
-static bool_t initiate_key_setup(struct site *st)
+static bool_t initiate_key_setup(struct site *st,string_t reason)
{
if (st->state!=SITE_RUN) return False;
+ slog(st,LOG_SETUP_INIT,"initiating key exchange (%s)",reason);
if (st->address) {
- slog(st,LOG_SETUP_INIT,"initiating key exchange; resolving address");
+ slog(st,LOG_SETUP_INIT,"resolving peer address");
return enter_state_resolve(st);
} else if (st->peer_valid) {
- slog(st,LOG_SETUP_INIT,"initiating key exchange using old "
- "peer address");
+ slog(st,LOG_SETUP_INIT,"using old peer address");
st->setup_peer=st->peer;
return enter_state_sentmsg1(st);
}
enter_state_run(st);
}
+static void delete_key(struct site *st, string_t reason, uint32_t loglevel)
+{
+ if (st->current_valid) {
+ slog(st,loglevel,"session closed (%s)",reason);
+
+ st->current_valid=False;
+ st->current_transform->delkey(st->current_transform->st);
+ st->current_key_timeout=0;
+ set_link_quality(st);
+ }
+}
+
static void state_assert(struct site *st, bool_t ok)
{
if (!ok) fatal("state_assert\n");
{
st->state=SITE_STOP;
st->timeout=0;
- st->current_transform->delkey(st->current_transform->st);
- st->current_valid=False;
- st->current_key_timeout=0;
-
- st->peer_valid=False;
-
- set_link_quality(st);
-
+ delete_key(st,"entering state STOP",LOG_TIMEOUT_KEY);
st->new_transform->delkey(st->new_transform->st);
}
else
quality=LINK_QUALITY_DOWN;
- st->netlink->set_quality(st->netlink->st,st->netlink_cid,quality);
+ st->netlink->set_quality(st->netlink->st,quality);
}
static void enter_state_run(struct site *st)
return False;
}
+static bool_t send_msg7(struct site *st,string_t reason)
+{
+ string_t transform_err;
+
+ if (st->current_valid && st->peer_valid && st->buffer.free) {
+ BUF_ALLOC(&st->buffer,"site:MSG7");
+ buffer_init(&st->buffer,st->transform->max_start_pad+(4*3));
+ buf_append_uint32(&st->buffer,LABEL_MSG7);
+ buf_append_string(&st->buffer,reason);
+ st->current_transform->forwards(st->current_transform->st,
+ &st->buffer, &transform_err);
+ buf_prepend_uint32(&st->buffer,LABEL_MSG0);
+ buf_prepend_uint32(&st->buffer,(uint32_t)st);
+ buf_prepend_uint32(&st->buffer,st->remote_session_id);
+ st->comm->sendmsg(st->comm->st,&st->buffer,&st->peer);
+ BUF_FREE(&st->buffer);
+ return True;
+ }
+ return False;
+}
+
/* We go into this state if our peer becomes uncommunicative. Similar to
the "stop" state, we forget all session keys for a while, before
re-entering the "run" state. */
}
}
if (st->current_key_timeout && *now>st->current_key_timeout) {
- slog(st,LOG_TIMEOUT_KEY,"maximum key life exceeded; session closed");
- st->current_valid=False;
- st->current_transform->delkey(st->current_transform->st);
- st->current_key_timeout=0;
- set_link_quality(st);
+ delete_key(st,"maximum key life exceeded",LOG_TIMEOUT_KEY);
}
}
/* This function is called by the netlink device to deliver packets
intended for the remote network. The packet is in "raw" wire
format, but is guaranteed to be word-aligned. */
-static void site_outgoing(void *sst, void *cid, struct buffer_if *buf)
+static void site_outgoing(void *sst, struct buffer_if *buf)
{
struct site *st=sst;
string_t transform_err;
slog(st,LOG_DROP,"discarding outgoing packet of size %d",buf->size);
BUF_FREE(buf);
- initiate_key_setup(st);
+ initiate_key_setup(st,"outgoing packet");
}
/* This function is called by the communication device to deliver
return False; /* Not for us. */
}
if (dest==(uint32_t)st) {
- uint32_t msgtype=ntohl(*(uint32_t *)(buf->start+8));
+ uint32_t msgtype=ntohl(get_uint32(buf->start+8));
/* Explicitly addressed to us */
if (msgtype!=LABEL_MSG0) dump_packet(st,buf,source,True);
switch (msgtype) {
+ case 0: /* NAK */
+ /* If the source is our current peer then initiate a key setup,
+ because our peer's forgotten the key */
+ if (get_uint32(buf->start+4)==st->remote_session_id) {
+ initiate_key_setup(st,"received a NAK");
+ } else {
+ slog(st,LOG_SEC,"bad incoming NAK");
+ }
+ break;
case LABEL_MSG0:
process_msg0(st,buf,source);
break;
slog(st,LOG_SEC,"invalid MSG6");
}
break;
- case LABEL_MSG8:
- /* NAK packet: enter state where we ping and check for response */
- slog(st,LOG_ERROR,"received a NAK");
- break;
default:
slog(st,LOG_SEC,"received message of unknown type 0x%08x",
msgtype);
else enter_state_stop(st);
}
+static void site_phase_hook(void *sst, uint32_t newphase)
+{
+ struct site *st=sst;
+
+ /* The program is shutting down; tell our peer */
+ send_msg7(st,"shutting down");
+}
+
static list_t *site_apply(closure_t *self, struct cloc loc, dict_t *context,
list_t *args)
{
site() closures for all sites including our own): refuse to
talk to ourselves */
if (strcmp(st->localname,st->remotename)==0) {
- Message(M_INFO,"site %s: local-name==name -> ignoring this site\n",
+ Message(M_DEBUG,"site %s: local-name==name -> ignoring this site\n",
st->localname);
free(st);
return NULL;
}
- st->netlink=find_cl_if(dict,"netlink",CL_NETLINK,True,"site",loc);
+ st->netlink=find_cl_if(dict,"link",CL_NETLINK,True,"site",loc);
st->comm=find_cl_if(dict,"comm",CL_COMM,True,"site",loc);
st->resolver=find_cl_if(dict,"resolver",CL_RESOLVER,True,"site",loc);
st->log=find_cl_if(dict,"log",CL_LOG,True,"site",loc);
st->random=find_cl_if(dict,"random",CL_RANDOMSRC,True,"site",loc);
st->privkey=find_cl_if(dict,"local-key",CL_RSAPRIVKEY,True,"site",loc);
- st->remoteport=dict_read_number(dict,"port",True,"site",loc,0);
-
st->address=dict_read_string(dict, "address", False, "site", loc);
- dict_read_subnet_list(dict, "networks", True, "site", loc,
- &st->remotenets);
+ if (st->address)
+ st->remoteport=dict_read_number(dict,"port",True,"site",loc,0);
+ else st->remoteport=0;
st->pubkey=find_cl_if(dict,"key",CL_RSAPUBKEY,True,"site",loc);
st->transform=
sprintf(st->tunname,"%s<->%s",st->localname,st->remotename);
/* The information we expect to see in incoming messages of type 1 */
- /* XXX fix this bit for unaligned access */
st->setupsiglen=strlen(st->remotename)+strlen(st->localname)+8;
st->setupsig=safe_malloc(st->setupsiglen,"site_apply");
put_uint32(st->setupsig+0,LABEL_MSG1);
st->sharedsecret=safe_malloc(st->transform->keylen,"site:sharedsecret");
/* We need to register the remote networks with the netlink device */
- st->netlink_cid=st->netlink->regnets(st->netlink->st, &st->remotenets,
- site_outgoing, st,
- st->transform->max_start_pad+(4*4),
- st->transform->max_end_pad,
- (st->address!=NULL), st->tunname);
- if (!st->netlink_cid) {
- Message(M_WARNING,"%s: netlink device did not let us register "
- "our remote networks. This site will not start.\n",
- st->tunname);
- return NULL; /* XXX should free site first */
- }
+ st->netlink->reg(st->netlink->st, site_outgoing, st,
+ st->transform->max_start_pad+(4*4),
+ st->transform->max_end_pad);
st->comm->request_notify(st->comm->st, st, site_incoming);
enter_state_stop(st);
+ add_hook(PHASE_SHUTDOWN,site_phase_hook,st);
+
return new_closure(&st->cl);
}