c->c2.tls_multi->dco_peer_id = -1;
}
#endif
- int ret = dco_new_peer(&c->c1.tuntap->dco, multi->peer_id, sock->sd, NULL,
- proto_is_dgram(sock->info.proto) ? remoteaddr : NULL, NULL, NULL);
+ int ret = dco_new_peer(&c->c1.tuntap->dco, multi->rx_peer_id, sock->sd, NULL,
+ proto_is_dgram(sock->info.proto) ? remoteaddr : NULL,
+ NULL, NULL);
if (ret < 0)
{
return ret;
}
- c->c2.tls_multi->dco_peer_id = multi->peer_id;
+ c->c2.tls_multi->dco_peer_id = multi->rx_peer_id;
return 0;
}
{
struct context *c = &mi->context;
- int peer_id = c->c2.tls_multi->peer_id;
+ int peer_id = c->c2.tls_multi->rx_peer_id;
struct sockaddr *remoteaddr, *localaddr = NULL;
struct sockaddr_storage local = { 0 };
const socket_descriptor_t sd = c->c2.link_sockets[0]->sd;
{
#if defined(_WIN32)
dco_win_add_iroute_ipv6(&c->c1.tuntap->dco, addr->v6.addr, addr->netbits,
- c->c2.tls_multi->peer_id);
+ c->c2.tls_multi->rx_peer_id);
#else
const struct in6_addr *gateway = &mi->context.c2.push_ifconfig_ipv6_local;
if (addr->type & MR_ONLINK_DCO_ADDR)
{
#if defined(_WIN32)
dco_win_add_iroute_ipv4(&c->c1.tuntap->dco, addr->v4.addr, addr->netbits,
- c->c2.tls_multi->peer_id);
+ c->c2.tls_multi->rx_peer_id);
#else
in_addr_t dest = htonl(addr->v4.addr);
const in_addr_t *gateway = &mi->context.c2.push_ifconfig_local;
md_kt_name(o->authname));
}
- if (o->use_peer_id)
+ if (c->c2.tls_multi && c->c2.tls_multi->use_peer_id)
{
- buf_printf(&out, ", peer-id: %d", o->peer_id);
+ buf_printf(&out, ", rx-peer-id: %u, tx-peer-id: %u", c->c2.tls_multi->rx_peer_id,
+ c->c2.tls_multi->tx_peer_id);
}
#ifdef USE_COMP
}
#endif
+ /* The peer-id can also be negotiated without being pushed, so sync the
+ * option before the frame is recalculated: it decides whether the
+ * DATA_V2 header is accounted for */
+ c->options.use_peer_id = c->c2.tls_multi->use_peer_id;
+
struct tls_session *session = &c->c2.tls_multi->session[TM_ACTIVE];
if (!tls_session_update_crypto_params(c->c2.tls_multi, session, &c->options, &c->c2.frame,
frame_fragment, get_link_socket_info(c),
{
msg(D_PUSH_DEBUG, "OPTIONS IMPORT: peer-id set");
c->c2.tls_multi->use_peer_id = true;
- c->c2.tls_multi->peer_id = c->options.peer_id;
+ c->c2.tls_multi->tx_peer_id = c->options.peer_id;
+ c->c2.tls_multi->rx_peer_id = c->options.peer_id;
}
/* process (potentially) pushed options */
/* Ensure that for epoch data format is only enabled if also data v2
* is enabled */
bool epoch_data = c->options.imported_protocol_flags & CO_EPOCH_DATA_KEY_FORMAT;
- bool datav2_enabled = c->options.use_peer_id && c->options.peer_id < MAX_PEER_ID;
+ bool datav2_enabled = c->c2.tls_multi->use_peer_id && c->c2.tls_multi->tx_peer_id < MAX_PEER_ID;
if (epoch_data && !datav2_enabled)
{
{
chomp(line);
if (validate_peer_info_line(line)
- && (strncmp(line, "IV_", 3) == 0 || strncmp(line, "UV_", 3) == 0))
+ && (strncmp(line, "IV_", 3) == 0 || strncmp(line, "UV_", 3) == 0
+ || strncmp(line, "ID", 2) == 0))
{
msg(M_INFO, "peer info: %s", line);
env_set_add(es, line);
}
else
{
- msg(M_WARN, "validation failed on peer_info line received from client");
+ msg(M_WARN, "validation failed on peer_info line received");
}
}
}
if (mi->context.c2.tls_multi && check_debug_level(D_DCO_DEBUG)
&& dco_enabled(&mi->context.options))
{
- buf_printf(&out, " peer-id=%d", mi->context.c2.tls_multi->peer_id);
+ buf_printf(&out, " rx-peer-id=%d", mi->context.c2.tls_multi->rx_peer_id);
}
return BSTR(&out);
}
}
#endif
- if (mi->context.c2.tls_multi->peer_id != MAX_PEER_ID)
+ if (mi->context.c2.tls_multi->rx_peer_id != MAX_PEER_ID)
{
- m->instances[mi->context.c2.tls_multi->peer_id] = NULL;
+ m->instances[mi->context.c2.tls_multi->rx_peer_id] = NULL;
/* Adjust the max_peerid as this might have been the highest
* peer id instance */
#else
sep,
#endif
- sep,
- mi->context.c2.tls_multi ? mi->context.c2.tls_multi->peer_id : UINT32_MAX,
+ sep, mi->context.c2.tls_multi ? mi->context.c2.tls_multi->rx_peer_id : MAX_PEER_ID,
sep, translate_cipher_name_to_openvpn(mi->context.options.ciphername));
}
gc_free(&gc);
* has, so we disallow it. This can happen if a DCO netlink notification
* gets lost and we miss a floating step.
*/
- if (m1->peer_id == m2->peer_id)
+ if (m1->rx_peer_id == m2->rx_peer_id)
{
msg(M_WARN,
"disallowing peer %" PRIu32 " (%s) from floating to "
"its own address (%s)",
- m1->peer_id, tls_common_name(mi->context.c2.tls_multi, false),
+ m1->rx_peer_id, tls_common_name(mi->context.c2.tls_multi, false),
mroute_addr_print(&mi->real, &gc));
goto done;
}
}
msg(D_MULTI_MEDIUM, "peer %" PRIu32 " (%s) floated from %s to %s",
- mi->context.c2.tls_multi->peer_id, tls_common_name(mi->context.c2.tls_multi, false),
+ mi->context.c2.tls_multi->rx_peer_id,
+ tls_common_name(mi->context.c2.tls_multi, false),
mroute_addr_print_ex(&mi->real, MAPF_SHOW_FAMILY, &gc),
mroute_addr_print_ex(&real, MAPF_SHOW_FAMILY, &gc));
{
if (!m->instances[i])
{
- mi->context.c2.tls_multi->peer_id = i;
+ mi->context.c2.tls_multi->rx_peer_id = i;
m->instances[i] = mi;
break;
}
/* should not really end up here, since multi_create_instance returns null
* if amount of clients exceeds max_clients and this method would then
* also not have been called */
- ASSERT(mi->context.c2.tls_multi->peer_id < m->max_clients);
+ ASSERT(mi->context.c2.tls_multi->rx_peer_id < m->max_clients);
- if (mi->context.c2.tls_multi->peer_id > m->max_peerid)
+ if (mi->context.c2.tls_multi->rx_peer_id > m->max_peerid)
{
- m->max_peerid = mi->context.c2.tls_multi->peer_id;
+ m->max_peerid = mi->context.c2.tls_multi->rx_peer_id;
}
}
enum tun_driver_type windows_driver;
#endif
+ /** Whether the data channel uses the DATA_V2 header (peer-id).
+ * Mirror of tls_multi->use_peer_id, needed by the MTU/frame calculation
+ * which only has access to struct options. */
bool use_peer_id;
uint32_t peer_id;
print_in_addr_t(c->c2.push_ifconfig_remote_netmask, 0, gc));
}
- if (tls_multi->use_peer_id)
+ if (tls_multi->use_peer_id && !tls_multi->use_asymmetric_peer_id)
{
- push_option_fmt(gc, push_list, M_USAGE, "peer-id %d", tls_multi->peer_id);
+ push_option_fmt(gc, push_list, M_USAGE, "peer-id %d", tls_multi->rx_peer_id);
}
/*
* If server uses --auth-gen-token and we have an auth token
unsigned int permission_mask = pull_permission_mask(c);
if (process_push_update(c, &o, permission_mask, &option_types_found, &tmp_msg, true) == PUSH_MSG_ERROR)
{
- msg(M_WARN, "Failed to process push update message sent to client ID: %u", c->c2.tls_multi->peer_id);
+ msg(M_WARN, "Failed to process push update message sent to client ID: %u", c->c2.tls_multi->rx_peer_id);
}
e = e->next;
}
if (!support_push_update(mi))
{
- msg(M_CLIENT, "PUSH_UPDATE: not sending message to unsupported peer with ID: %u", mi->context.c2.tls_multi->peer_id);
+ msg(M_CLIENT, "PUSH_UPDATE: not sending message to unsupported peer with ID: %u", mi->context.c2.tls_multi->rx_peer_id);
buffer_list_free(msgs);
gc_free(&gc);
return 0;
/* Type is UPT_BROADCAST so we update every client */
if (!send_single_push_update(m, curr_mi, msgs))
{
- msg(M_CLIENT, "ERROR: Peer ID: %u has not been updated", curr_mi->context.c2.tls_multi->peer_id);
+ msg(M_CLIENT, "ERROR: Peer ID: %u has not been updated", curr_mi->context.c2.tls_multi->rx_peer_id);
continue;
}
count++;
/* get command line derived options */
ret->opt = *tls_options;
ret->dco_peer_id = -1;
- ret->peer_id = MAX_PEER_ID;
+ ret->use_asymmetric_peer_id = false;
+ /* The rx_peer_id is also used to identify DCO clients */
+ ret->rx_peer_id = MAX_PEER_ID;
+ ret->tx_peer_id = MAX_PEER_ID;
return ret;
}
tls_session_init(multi, &multi->session[TM_ACTIVE]);
tls_session_init(multi, &multi->session[TM_INITIAL]);
+
+ if (!multi->opt.dco_enabled)
+ {
+ /* Calculate the asymmetric peer-id */
+ if (multi->rx_peer_id == MAX_PEER_ID && multi->session[TM_INITIAL].opt->mode != MODE_SERVER)
+ {
+ multi->rx_peer_id = (uint32_t)(get_random() % (MAX_PEER_ID - 1));
+ }
+ }
}
/*
return str;
}
+static bool
+push_peer_info_peerid(struct buffer *out, struct tls_multi *multi, struct tls_session *session)
+{
+ if (multi->rx_peer_id == MAX_PEER_ID || session->opt->dco_enabled)
+ {
+ /* No valid peer id or DCO is enabled. Cannot use this feature */
+ return true;
+ }
+
+ /* In server mode we only add this when the client has announced its
+ * support for the feature */
+ if (session->opt->mode != MODE_SERVER || multi->use_asymmetric_peer_id)
+ {
+ return buf_printf(out, "ID=%x\n", multi->rx_peer_id);
+ }
+
+ return true;
+}
+
/**
* Prepares the IV_ and UV_ variables that are part of the
* exchange to signal the peer's capabilities. The amount
*
* @param buf the buffer to write these variables to
* @param session the TLS session object
+ * @param multi the TLS multi object
* @return true if no error was encountered
*/
static bool
-push_peer_info(struct buffer *buf, struct tls_session *session)
+push_peer_info(struct buffer *buf, struct tls_multi *multi, struct tls_session *session)
{
struct gc_arena gc = gc_new();
bool ret = false;
struct buffer out = alloc_buf_gc(512 * 3, &gc);
+ /* The asymmetric peer-id is always written when enabled */
+ if (!push_peer_info_peerid(&out, multi, session))
+ {
+ goto error;
+ }
+
if (session->opt->push_peer_info_detail > 1)
{
/* push version */
}
}
}
+ }
+ /* write peer info string if there is anything in it, empty string otherwise */
+ if (BLEN(&out) > 0)
+ {
if (!write_string(buf, BSTR(&out), -1))
{
goto error;
}
else
{
- if (!write_empty_string(buf)) /* no peer info */
+ if (!write_empty_string(buf))
{
goto error;
}
}
}
- if (!push_peer_info(buf, session))
+ if (!push_peer_info(buf, multi, session))
{
goto error;
}
if (multi->peer_info)
{
output_peer_info_env(session->opt->es, multi->peer_info);
+ uint32_t peer_id = extract_asymmetric_peer_id(multi->peer_info);
+ if (peer_id != MAX_PEER_ID && !session->opt->dco_enabled)
+ {
+ multi->tx_peer_id = peer_id;
+ multi->use_asymmetric_peer_id = true;
+ multi->use_peer_id = true;
+ }
+ else
+ {
+ /* Peer has no support for asymmetric peer-id, and DCO currently
+ * can only handle symmetric peer IDs */
+ multi->tx_peer_id = multi->rx_peer_id;
+ }
}
free(multi->remote_ciphername);
msg(D_TLS_DEBUG, __func__);
ASSERT(ks);
-
- peer = htonl(((P_DATA_V2 << P_OPCODE_SHIFT) | ks->key_id) << 24 | (multi->peer_id & 0xFFFFFF));
+ peer = htonl(((P_DATA_V2 << P_OPCODE_SHIFT) | ks->key_id) << 24
+ | (multi->tx_peer_id & 0xFFFFFF));
ASSERT(buf_write_prepend(buf, &peer, 4));
}
#define AUTH_TOKEN_VALID_EMPTYUSER (1 << 2)
/* For P_DATA_V2 */
- uint32_t peer_id;
+ uint32_t rx_peer_id;
+ uint32_t tx_peer_id;
bool use_peer_id;
+ bool use_asymmetric_peer_id;
char *remote_ciphername; /**< cipher specified in peer's config file */
bool remote_usescomp; /**< remote announced comp-lzo in OCC string */
{
/* will return 0 if peer_info is null */
const unsigned int iv_proto_peer = extract_iv_proto(multi->peer_info);
+ const unsigned int tx_peer_id = extract_asymmetric_peer_id(multi->peer_info);
/* The other peer does not support P2P NCP */
if (!(iv_proto_peer & IV_PROTO_NCP_P2P))
if (iv_proto_peer & IV_PROTO_DATA_V2)
{
multi->use_peer_id = true;
- multi->peer_id = 0x76706e; /* 'v' 'p' 'n' */
}
if (iv_proto_peer & IV_PROTO_CC_EXIT_NOTIFY)
if (iv_proto_peer & IV_PROTO_TLS_KEY_EXPORT)
{
session->opt->crypto_flags |= CO_USE_TLS_KEY_MATERIAL_EXPORT;
+ }
- if (multi->use_peer_id)
+ if (multi->use_peer_id)
+ {
+ /* The asymmetric peer-id trumps on the EKM generated ones */
+ if ((iv_proto_peer & IV_PROTO_TLS_KEY_EXPORT)
+ && (tx_peer_id != MAX_PEER_ID) && !multi->opt.dco_enabled)
+ {
+ multi->tx_peer_id = tx_peer_id;
+ multi->use_asymmetric_peer_id = true;
+ }
+ else
{
+ uint8_t peerid[3];
/* Using a non hardcoded peer-id makes a tiny bit harder to
* fingerprint packets and also gives each connection a unique
* peer-id that can be useful for NAT tracking etc. */
-
- uint8_t peerid[3];
- if (!key_state_export_keying_material(session, EXPORT_P2P_PEERID_LABEL,
- strlen(EXPORT_P2P_PEERID_LABEL), &peerid, 3))
+ if ((iv_proto_peer & IV_PROTO_TLS_KEY_EXPORT)
+ && key_state_export_keying_material(session, EXPORT_P2P_PEERID_LABEL,
+ strlen(EXPORT_P2P_PEERID_LABEL), &peerid, 3))
{
- /* Non DCO setup might still work but also this should never
- * happen or very likely the TLS encryption key exporter will
- * also fail */
- msg(M_NONFATAL, "TLS key export for P2P peer id failed. "
- "Continuing anyway, expect problems");
+ multi->rx_peer_id = (peerid[0] << 16) + (peerid[1] << 8) + peerid[2];
}
else
{
- multi->peer_id = (peerid[0] << 16) + (peerid[1] << 8) + peerid[2];
+ if (iv_proto_peer & IV_PROTO_TLS_KEY_EXPORT)
+ {
+ /* Non DCO setup might still work but also this should never
+ * happen or very likely the TLS encryption key exporter will
+ * also fail */
+ msg(M_NONFATAL, "TLS key export for P2P peer id failed. "
+ "Continuing anyway, expect problems");
+ }
+ multi->rx_peer_id = 0x76706e; /* 'v' 'p' 'n' */
}
+ multi->tx_peer_id = multi->rx_peer_id;
}
}
if (iv_proto_peer & IV_PROTO_DYN_TLS_CRYPT)
common_cipher = BSTR(&out);
}
- msg(D_TLS_DEBUG_LOW,
- "P2P mode NCP negotiation result: "
- "TLS_export=%d, DATA_v2=%d, peer-id %d, epoch=%d, cipher=%s",
- (bool)(session->opt->crypto_flags & CO_USE_TLS_KEY_MATERIAL_EXPORT), multi->use_peer_id,
- multi->peer_id, (bool)(session->opt->crypto_flags & CO_EPOCH_DATA_KEY_FORMAT),
+ msg(D_TLS_DEBUG_LOW, "P2P mode NCP negotiation result: "
+ "TLS_export=%d, DATA_v2=%d, rx-peer-id %d, tx-peer-id %d, epoch=%d, cipher=%s",
+ (bool)(session->opt->crypto_flags & CO_USE_TLS_KEY_MATERIAL_EXPORT),
+ multi->use_peer_id,
+ multi->rx_peer_id,
+ multi->tx_peer_id,
+ (bool)(session->opt->crypto_flags & CO_EPOCH_DATA_KEY_FORMAT),
common_cipher);
gc_free(&gc);
#endif
#include "syshead.h"
-
+#include "openvpn.h"
#include "ssl_util.h"
char *
return 0;
}
+uint32_t
+extract_asymmetric_peer_id(const char *peer_info)
+{
+ for (const char *p = peer_info; p && (p = strstr(p, "ID=")); p += 3)
+ {
+ /* only accept "ID=" at the start of a line, so it does not match
+ * substrings like "UV_ID=" or "GUID=" */
+ if (p == peer_info || p[-1] == '\n')
+ {
+ uint32_t peer_id = 0;
+ if (sscanf(p, "ID=%x", &peer_id) == 1 && peer_id < MAX_PEER_ID)
+ {
+ return peer_id;
+ }
+ }
+ }
+ return MAX_PEER_ID;
+}
+
const char *
options_string_compat_lzo(const char *options, struct gc_arena *gc)
{
*/
unsigned int extract_iv_proto(const char *peer_info);
+
+/**
+ * Extracts the ID variable and returns its value or
+ * MAX_PEER_ID if it cannot be extracted.
+ *
+ * @param peer_info peer info string to search for ID
+ */
+uint32_t extract_asymmetric_peer_id(const char *peer_info);
+
/**
* Takes a locally produced OCC string for TLS server mode and modifies as
* if the option comp-lzo was enabled. This is to send a client in
projects / thirdparty / openvpn.git / commitdiff
