X-Git-Url: http://git.meshlink.io/?p=meshlink;a=blobdiff_plain;f=src%2Fprotocol_key.c;h=b614494b74b55cc2b41fdc0daaffa7f1ef00ff9a;hp=43a227bbd65b459aaf7254a5069609ff2a1ea6f7;hb=963c5055505f2fc117cd5efa06eaa02c9b2bf85d;hpb=0d133a5ff230ad78da3208d32521d7549836187e diff --git a/src/protocol_key.c b/src/protocol_key.c index 43a227bb..b614494b 100644 --- a/src/protocol_key.c +++ b/src/protocol_key.c @@ -31,18 +31,12 @@ #include "utils.h" #include "xalloc.h" -void send_key_changed(meshlink_handle_t *mesh) { - send_request(mesh, mesh->everyone, NULL, "%d %x %s", KEY_CHANGED, rand(), mesh->self->name); - - /* Force key exchange for connections using SPTPS */ - - for splay_each(node_t, n, mesh->nodes) - if(n->status.reachable && n->status.validkey) { - sptps_force_kex(&n->sptps); - } -} +static const int req_key_timeout = 2; bool key_changed_h(meshlink_handle_t *mesh, connection_t *c, const char *request) { + assert(request); + assert(*request); + char name[MAX_STRING_SIZE]; node_t *n; @@ -71,6 +65,10 @@ bool key_changed_h(meshlink_handle_t *mesh, connection_t *c, const char *request static bool send_initial_sptps_data(void *handle, uint8_t type, const void *data, size_t len) { (void)type; + + assert(data); + assert(len); + node_t *to = handle; meshlink_handle_t *mesh = to->mesh; to->sptps.send_data = send_sptps_data; @@ -80,7 +78,7 @@ static bool send_initial_sptps_data(void *handle, uint8_t type, const void *data } bool send_req_key(meshlink_handle_t *mesh, node_t *to) { - if(!node_read_ecdsa_public_key(mesh, to)) { + if(!node_read_public_key(mesh, to)) { logger(mesh, MESHLINK_DEBUG, "No ECDSA key known for %s", to->name); send_request(mesh, to->nexthop->connection, NULL, "%d %s %s %d", REQ_KEY, mesh->self->name, to->name, REQ_PUBKEY); return true; @@ -96,8 +94,7 @@ bool send_req_key(meshlink_handle_t *mesh, node_t *to) { to->status.validkey = false; to->status.waitingforkey = true; to->last_req_key = mesh->loop.now.tv_sec; - to->incompression = mesh->self->incompression; - return sptps_start(&to->sptps, to, true, true, mesh->self->connection->ecdsa, to->ecdsa, label, sizeof(label) - 1, send_initial_sptps_data, receive_sptps_record); + return sptps_start(&to->sptps, to, true, true, mesh->private_key, to->ecdsa, label, sizeof(label) - 1, send_initial_sptps_data, receive_sptps_record); } /* REQ_KEY is overloaded to allow arbitrary requests to be routed between two nodes. */ @@ -107,7 +104,7 @@ static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char * switch(reqno) { case REQ_PUBKEY: { - char *pubkey = ecdsa_get_base64_public_key(mesh->self->connection->ecdsa); + char *pubkey = ecdsa_get_base64_public_key(mesh->private_key); if(!from->nexthop || !from->nexthop->connection) { return false; @@ -119,7 +116,7 @@ static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char * } case ANS_PUBKEY: { - if(node_read_ecdsa_public_key(mesh, from)) { + if(node_read_public_key(mesh, from)) { logger(mesh, MESHLINK_WARNING, "Got ANS_PUBKEY from %s even though we already have his pubkey", from->name); return true; } @@ -132,12 +129,26 @@ static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char * } logger(mesh, MESHLINK_INFO, "Learned ECDSA public key from %s", from->name); - append_config_file(mesh, from->name, "ECDSAPublicKey", pubkey); + from->status.dirty = true; + + /* If we are trying to form an outgoing connection to this node, retry immediately */ + for list_each(outgoing_t, outgoing, mesh->outgoings) { + if(outgoing->node == from && outgoing->ev.cb) { + outgoing->timeout = 0; + timeout_set(&mesh->loop, &outgoing->ev, &(struct timespec) { + 0, 0 + }); + } + } + + /* Also reset any UTCP timers */ + utcp_reset_timers(from->utcp); + return true; } case REQ_KEY: { - if(!node_read_ecdsa_public_key(mesh, from)) { + if(!node_read_public_key(mesh, from)) { logger(mesh, MESHLINK_DEBUG, "No ECDSA key known for %s", from->name); send_request(mesh, from->nexthop->connection, NULL, "%d %s %s %d", REQ_KEY, mesh->self->name, from->name, REQ_PUBKEY); return true; @@ -146,7 +157,7 @@ static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char * if(from->sptps.label) { logger(mesh, MESHLINK_DEBUG, "Got REQ_KEY from %s while we already started a SPTPS session!", from->name); - if(strcmp(mesh->self->name, from->name) < 0) { + if(mesh->loop.now.tv_sec < from->last_req_key + req_key_timeout && strcmp(mesh->self->name, from->name) < 0) { logger(mesh, MESHLINK_DEBUG, "Ignoring REQ_KEY from %s.", from->name); return true; } @@ -166,8 +177,17 @@ static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char * from->status.validkey = false; from->status.waitingforkey = true; from->last_req_key = mesh->loop.now.tv_sec; - sptps_start(&from->sptps, from, false, true, mesh->self->connection->ecdsa, from->ecdsa, label, sizeof(label) - 1, send_sptps_data, receive_sptps_record); - sptps_receive_data(&from->sptps, buf, len); + + if(!sptps_start(&from->sptps, from, false, true, mesh->private_key, from->ecdsa, label, sizeof(label) - 1, send_sptps_data, receive_sptps_record)) { + logger(mesh, MESHLINK_ERROR, "Could not start SPTPS session with %s: %s", from->name, strerror(errno)); + return true; + } + + if(!sptps_receive_data(&from->sptps, buf, len)) { + logger(mesh, MESHLINK_ERROR, "Could not process SPTPS data from %s: %s", from->name, strerror(errno)); + return true; + } + return true; } @@ -185,7 +205,11 @@ static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char * return true; } - sptps_receive_data(&from->sptps, buf, len); + if(!sptps_receive_data(&from->sptps, buf, len)) { + logger(mesh, MESHLINK_ERROR, "Could not process SPTPS data from %s: %s", from->name, strerror(errno)); + return true; + } + return true; } @@ -196,6 +220,9 @@ static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char * } bool req_key_h(meshlink_handle_t *mesh, connection_t *c, const char *request) { + assert(request); + assert(*request); + char from_name[MAX_STRING_SIZE]; char to_name[MAX_STRING_SIZE]; node_t *from, *to; @@ -250,13 +277,10 @@ bool req_key_h(meshlink_handle_t *mesh, connection_t *c, const char *request) { return true; } -bool send_ans_key(meshlink_handle_t *mesh, node_t *to) { - (void)mesh; - (void)to; - abort(); -} - bool ans_key_h(meshlink_handle_t *mesh, connection_t *c, const char *request) { + assert(request); + assert(*request); + char from_name[MAX_STRING_SIZE]; char to_name[MAX_STRING_SIZE]; char key[MAX_STRING_SIZE]; @@ -302,7 +326,14 @@ bool ans_key_h(meshlink_handle_t *mesh, connection_t *c, const char *request) { return true; } - if(!*address && from->address.sa.sa_family != AF_UNSPEC) { + if(from == to) { + logger(mesh, MESHLINK_WARNING, "Got %s from %s from %s to %s", + "ANS_KEY", c->name, from_name, to_name); + return true; + } + + /* Append the known UDP address of the from node, if we have a confirmed one */ + if(!*address && from->status.udp_confirmed && from->address.sa.sa_family != AF_UNSPEC) { char *address, *port; logger(mesh, MESHLINK_DEBUG, "Appending reflexive UDP address to ANS_KEY from %s to %s", from->name, to->name); sockaddr2str(&from->address, &address, &port); @@ -315,24 +346,55 @@ bool ans_key_h(meshlink_handle_t *mesh, connection_t *c, const char *request) { return send_request(mesh, to->nexthop->connection, NULL, "%s", request); } - /* Don't use key material until every check has passed. */ - from->status.validkey = false; + /* Is this an ANS_KEY informing us of our own reflexive UDP address? */ + + if(from == mesh->self) { + if(*key == '.' && *address && *port) { + logger(mesh, MESHLINK_DEBUG, "Learned our own reflexive UDP address from %s: %s port %s", c->name, address, port); + + /* Inform all other nodes we want to communicate with and which are reachable via this connection */ + for splay_each(node_t, n, mesh->nodes) { + if(n->nexthop != c->node) { + continue; + } + + if(n->status.udp_confirmed) { + continue; + } + + if(!n->status.waitingforkey && !n->status.validkey) { + continue; + } + + logger(mesh, MESHLINK_DEBUG, "Forwarding our own reflexive UDP address to %s", n->name); + send_request(mesh, c, NULL, "%d %s %s . -1 -1 -1 0 %s %s", ANS_KEY, mesh->self->name, n->name, address, port); + } + } else { + logger(mesh, MESHLINK_WARNING, "Got %s from %s from %s to %s", + "ANS_KEY", c->name, from_name, to_name); + } - /* Compression is not supported. */ - if(compression != 0) { - logger(mesh, MESHLINK_ERROR, "Node %s uses bogus compression level!", from->name); return true; } - from->outcompression = compression; + /* Process SPTPS data if present */ + + if(*key != '.') { + /* Don't use key material until every check has passed. */ + from->status.validkey = false; - /* SPTPS or old-style key exchange? */ + /* Compression is not supported. */ + if(compression != 0) { + logger(mesh, MESHLINK_ERROR, "Node %s uses bogus compression level!", from->name); + return true; + } - char buf[strlen(key)]; - int len = b64decode(key, buf, strlen(key)); + char buf[strlen(key)]; + int len = b64decode(key, buf, strlen(key)); - if(!len || !sptps_receive_data(&from->sptps, buf, len)) { - logger(mesh, MESHLINK_ERROR, "Error processing SPTPS data from %s", from->name); + if(!len || !sptps_receive_data(&from->sptps, buf, len)) { + logger(mesh, MESHLINK_ERROR, "Error processing SPTPS data from %s", from->name); + } } if(from->status.validkey) { @@ -342,9 +404,7 @@ bool ans_key_h(meshlink_handle_t *mesh, connection_t *c, const char *request) { update_node_udp(mesh, from, &sa); } - if(from->options & OPTION_PMTU_DISCOVERY && !(from->options & OPTION_TCPONLY)) { - send_mtu_probe(mesh, from); - } + send_mtu_probe(mesh, from); } return true;