/* * DPP over TCP * Copyright (c) 2019-2020, The Linux Foundation * * This software may be distributed under the terms of the BSD license. * See README for more details. */ #include "utils/includes.h" #include #include "utils/common.h" #include "utils/ip_addr.h" #include "utils/eloop.h" #include "common/ieee802_11_common.h" #include "common/wpa_ctrl.h" #include "dpp.h" #include "dpp_i.h" #ifdef CONFIG_DPP2 struct dpp_connection { struct dl_list list; struct dpp_controller *ctrl; struct dpp_relay_controller *relay; struct dpp_global *global; struct dpp_authentication *auth; int sock; u8 mac_addr[ETH_ALEN]; unsigned int freq; u8 msg_len[4]; size_t msg_len_octets; struct wpabuf *msg; struct wpabuf *msg_out; size_t msg_out_pos; unsigned int read_eloop:1; unsigned int write_eloop:1; unsigned int on_tcp_tx_complete_gas_done:1; unsigned int on_tcp_tx_complete_remove:1; unsigned int on_tcp_tx_complete_auth_ok:1; }; /* Remote Controller */ struct dpp_relay_controller { struct dl_list list; struct dpp_global *global; u8 pkhash[SHA256_MAC_LEN]; struct hostapd_ip_addr ipaddr; void *cb_ctx; void (*tx)(void *ctx, const u8 *addr, unsigned int freq, const u8 *msg, size_t len); void (*gas_resp_tx)(void *ctx, const u8 *addr, u8 dialog_token, int prot, struct wpabuf *buf); struct dl_list conn; /* struct dpp_connection */ }; /* Local Controller */ struct dpp_controller { struct dpp_global *global; u8 allowed_roles; int qr_mutual; int sock; struct dl_list conn; /* struct dpp_connection */ char *configurator_params; }; static void dpp_controller_rx(int sd, void *eloop_ctx, void *sock_ctx); static void dpp_conn_tx_ready(int sock, void *eloop_ctx, void *sock_ctx); static void dpp_controller_auth_success(struct dpp_connection *conn, int initiator); static void dpp_connection_free(struct dpp_connection *conn) { if (conn->sock >= 0) { wpa_printf(MSG_DEBUG, "DPP: Close Controller socket %d", conn->sock); eloop_unregister_sock(conn->sock, EVENT_TYPE_READ); eloop_unregister_sock(conn->sock, EVENT_TYPE_WRITE); close(conn->sock); } eloop_cancel_timeout(dpp_controller_conn_status_result_wait_timeout, conn, NULL); wpabuf_free(conn->msg); wpabuf_free(conn->msg_out); dpp_auth_deinit(conn->auth); os_free(conn); } static void dpp_connection_remove(struct dpp_connection *conn) { dl_list_del(&conn->list); dpp_connection_free(conn); } int dpp_relay_add_controller(struct dpp_global *dpp, struct dpp_relay_config *config) { struct dpp_relay_controller *ctrl; if (!dpp) return -1; ctrl = os_zalloc(sizeof(*ctrl)); if (!ctrl) return -1; dl_list_init(&ctrl->conn); ctrl->global = dpp; os_memcpy(&ctrl->ipaddr, config->ipaddr, sizeof(*config->ipaddr)); os_memcpy(ctrl->pkhash, config->pkhash, SHA256_MAC_LEN); ctrl->cb_ctx = config->cb_ctx; ctrl->tx = config->tx; ctrl->gas_resp_tx = config->gas_resp_tx; dl_list_add(&dpp->controllers, &ctrl->list); return 0; } static struct dpp_relay_controller * dpp_relay_controller_get(struct dpp_global *dpp, const u8 *pkhash) { struct dpp_relay_controller *ctrl; if (!dpp) return NULL; dl_list_for_each(ctrl, &dpp->controllers, struct dpp_relay_controller, list) { if (os_memcmp(pkhash, ctrl->pkhash, SHA256_MAC_LEN) == 0) return ctrl; } return NULL; } static void dpp_controller_gas_done(struct dpp_connection *conn) { struct dpp_authentication *auth = conn->auth; if (auth->peer_version >= 2 && auth->conf_resp_status == DPP_STATUS_OK) { wpa_printf(MSG_DEBUG, "DPP: Wait for Configuration Result"); auth->waiting_conf_result = 1; return; } wpa_msg(conn->ctrl->global->msg_ctx, MSG_INFO, DPP_EVENT_CONF_SENT); dpp_connection_remove(conn); } static int dpp_tcp_send(struct dpp_connection *conn) { int res; if (!conn->msg_out) { eloop_unregister_sock(conn->sock, EVENT_TYPE_WRITE); conn->write_eloop = 0; return -1; } res = send(conn->sock, wpabuf_head_u8(conn->msg_out) + conn->msg_out_pos, wpabuf_len(conn->msg_out) - conn->msg_out_pos, 0); if (res < 0) { wpa_printf(MSG_DEBUG, "DPP: Failed to send buffer: %s", strerror(errno)); dpp_connection_remove(conn); return -1; } conn->msg_out_pos += res; if (wpabuf_len(conn->msg_out) > conn->msg_out_pos) { wpa_printf(MSG_DEBUG, "DPP: %u/%u bytes of message sent to Controller", (unsigned int) conn->msg_out_pos, (unsigned int) wpabuf_len(conn->msg_out)); if (!conn->write_eloop && eloop_register_sock(conn->sock, EVENT_TYPE_WRITE, dpp_conn_tx_ready, conn, NULL) == 0) conn->write_eloop = 1; return 1; } wpa_printf(MSG_DEBUG, "DPP: Full message sent over TCP"); wpabuf_free(conn->msg_out); conn->msg_out = NULL; conn->msg_out_pos = 0; eloop_unregister_sock(conn->sock, EVENT_TYPE_WRITE); conn->write_eloop = 0; if (!conn->read_eloop && eloop_register_sock(conn->sock, EVENT_TYPE_READ, dpp_controller_rx, conn, NULL) == 0) conn->read_eloop = 1; if (conn->on_tcp_tx_complete_remove) { dpp_connection_remove(conn); } else if (conn->ctrl && conn->on_tcp_tx_complete_gas_done && conn->auth) { dpp_controller_gas_done(conn); } else if (conn->on_tcp_tx_complete_auth_ok) { conn->on_tcp_tx_complete_auth_ok = 0; dpp_controller_auth_success(conn, 1); } return 0; } static int dpp_tcp_send_msg(struct dpp_connection *conn, const struct wpabuf *msg) { wpabuf_free(conn->msg_out); conn->msg_out_pos = 0; conn->msg_out = wpabuf_alloc(4 + wpabuf_len(msg) - 1); if (!conn->msg_out) return -1; wpabuf_put_be32(conn->msg_out, wpabuf_len(msg) - 1); wpabuf_put_data(conn->msg_out, wpabuf_head_u8(msg) + 1, wpabuf_len(msg) - 1); if (dpp_tcp_send(conn) == 1) { if (!conn->write_eloop) { if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE, dpp_conn_tx_ready, conn, NULL) < 0) return -1; conn->write_eloop = 1; } } return 0; } static void dpp_controller_start_gas_client(struct dpp_connection *conn) { struct dpp_authentication *auth = conn->auth; struct wpabuf *buf; int netrole_ap = 0; /* TODO: make this configurable */ buf = dpp_build_conf_req_helper(auth, "Test", netrole_ap, NULL, NULL); if (!buf) { wpa_printf(MSG_DEBUG, "DPP: No configuration request data available"); return; } dpp_tcp_send_msg(conn, buf); wpabuf_free(buf); } static void dpp_controller_auth_success(struct dpp_connection *conn, int initiator) { struct dpp_authentication *auth = conn->auth; if (!auth) return; wpa_printf(MSG_DEBUG, "DPP: Authentication succeeded"); wpa_msg(conn->global->msg_ctx, MSG_INFO, DPP_EVENT_AUTH_SUCCESS "init=%d", initiator); #ifdef CONFIG_TESTING_OPTIONS if (dpp_test == DPP_TEST_STOP_AT_AUTH_CONF) { wpa_printf(MSG_INFO, "DPP: TESTING - stop at Authentication Confirm"); if (auth->configurator) { /* Prevent GAS response */ auth->auth_success = 0; } return; } #endif /* CONFIG_TESTING_OPTIONS */ if (!auth->configurator) dpp_controller_start_gas_client(conn); } static void dpp_conn_tx_ready(int sock, void *eloop_ctx, void *sock_ctx) { struct dpp_connection *conn = eloop_ctx; wpa_printf(MSG_DEBUG, "DPP: TCP socket %d ready for TX", sock); dpp_tcp_send(conn); } static int dpp_ipaddr_to_sockaddr(struct sockaddr *addr, socklen_t *addrlen, const struct hostapd_ip_addr *ipaddr, int port) { struct sockaddr_in *dst; #ifdef CONFIG_IPV6 struct sockaddr_in6 *dst6; #endif /* CONFIG_IPV6 */ switch (ipaddr->af) { case AF_INET: dst = (struct sockaddr_in *) addr; os_memset(dst, 0, sizeof(*dst)); dst->sin_family = AF_INET; dst->sin_addr.s_addr = ipaddr->u.v4.s_addr; dst->sin_port = htons(port); *addrlen = sizeof(*dst); break; #ifdef CONFIG_IPV6 case AF_INET6: dst6 = (struct sockaddr_in6 *) addr; os_memset(dst6, 0, sizeof(*dst6)); dst6->sin6_family = AF_INET6; os_memcpy(&dst6->sin6_addr, &ipaddr->u.v6, sizeof(struct in6_addr)); dst6->sin6_port = htons(port); *addrlen = sizeof(*dst6); break; #endif /* CONFIG_IPV6 */ default: return -1; } return 0; } static struct dpp_connection * dpp_relay_new_conn(struct dpp_relay_controller *ctrl, const u8 *src, unsigned int freq) { struct dpp_connection *conn; struct sockaddr_storage addr; socklen_t addrlen; char txt[100]; if (dl_list_len(&ctrl->conn) >= 15) { wpa_printf(MSG_DEBUG, "DPP: Too many ongoing Relay connections to the Controller - cannot start a new one"); return NULL; } if (dpp_ipaddr_to_sockaddr((struct sockaddr *) &addr, &addrlen, &ctrl->ipaddr, DPP_TCP_PORT) < 0) return NULL; conn = os_zalloc(sizeof(*conn)); if (!conn) return NULL; conn->global = ctrl->global; conn->relay = ctrl; os_memcpy(conn->mac_addr, src, ETH_ALEN); conn->freq = freq; conn->sock = socket(AF_INET, SOCK_STREAM, 0); if (conn->sock < 0) goto fail; wpa_printf(MSG_DEBUG, "DPP: TCP relay socket %d connection to %s", conn->sock, hostapd_ip_txt(&ctrl->ipaddr, txt, sizeof(txt))); if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) { wpa_printf(MSG_DEBUG, "DPP: fnctl(O_NONBLOCK) failed: %s", strerror(errno)); goto fail; } if (connect(conn->sock, (struct sockaddr *) &addr, addrlen) < 0) { if (errno != EINPROGRESS) { wpa_printf(MSG_DEBUG, "DPP: Failed to connect: %s", strerror(errno)); goto fail; } /* * Continue connecting in the background; eloop will call us * once the connection is ready (or failed). */ } if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE, dpp_conn_tx_ready, conn, NULL) < 0) goto fail; conn->write_eloop = 1; /* TODO: eloop timeout to clear a connection if it does not complete * properly */ dl_list_add(&ctrl->conn, &conn->list); return conn; fail: dpp_connection_free(conn); return NULL; } static struct wpabuf * dpp_tcp_encaps(const u8 *hdr, const u8 *buf, size_t len) { struct wpabuf *msg; msg = wpabuf_alloc(4 + 1 + DPP_HDR_LEN + len); if (!msg) return NULL; wpabuf_put_be32(msg, 1 + DPP_HDR_LEN + len); wpabuf_put_u8(msg, WLAN_PA_VENDOR_SPECIFIC); wpabuf_put_data(msg, hdr, DPP_HDR_LEN); wpabuf_put_data(msg, buf, len); wpa_hexdump_buf(MSG_MSGDUMP, "DPP: Outgoing TCP message", msg); return msg; } static int dpp_relay_tx(struct dpp_connection *conn, const u8 *hdr, const u8 *buf, size_t len) { u8 type = hdr[DPP_HDR_LEN - 1]; wpa_printf(MSG_DEBUG, "DPP: Continue already established Relay/Controller connection for this session"); wpabuf_free(conn->msg_out); conn->msg_out_pos = 0; conn->msg_out = dpp_tcp_encaps(hdr, buf, len); if (!conn->msg_out) { dpp_connection_remove(conn); return -1; } /* TODO: for proto ver 1, need to do remove connection based on GAS Resp * TX status */ if (type == DPP_PA_CONFIGURATION_RESULT) conn->on_tcp_tx_complete_remove = 1; dpp_tcp_send(conn); return 0; } int dpp_relay_rx_action(struct dpp_global *dpp, const u8 *src, const u8 *hdr, const u8 *buf, size_t len, unsigned int freq, const u8 *i_bootstrap, const u8 *r_bootstrap) { struct dpp_relay_controller *ctrl; struct dpp_connection *conn; u8 type = hdr[DPP_HDR_LEN - 1]; /* Check if there is an already started session for this peer and if so, * continue that session (send this over TCP) and return 0. */ if (type != DPP_PA_PEER_DISCOVERY_REQ && type != DPP_PA_PEER_DISCOVERY_RESP && type != DPP_PA_PRESENCE_ANNOUNCEMENT && type != DPP_PA_RECONFIG_ANNOUNCEMENT) { dl_list_for_each(ctrl, &dpp->controllers, struct dpp_relay_controller, list) { dl_list_for_each(conn, &ctrl->conn, struct dpp_connection, list) { if (os_memcmp(src, conn->mac_addr, ETH_ALEN) == 0) return dpp_relay_tx(conn, hdr, buf, len); } } } if (type == DPP_PA_PRESENCE_ANNOUNCEMENT || type == DPP_PA_RECONFIG_ANNOUNCEMENT) { /* TODO: Could send this to all configured Controllers. For now, * only the first Controller is supported. */ ctrl = dl_list_first(&dpp->controllers, struct dpp_relay_controller, list); } else { if (!r_bootstrap) return -1; ctrl = dpp_relay_controller_get(dpp, r_bootstrap); } if (!ctrl) return -1; wpa_printf(MSG_DEBUG, "DPP: Authentication Request for a configured Controller"); conn = dpp_relay_new_conn(ctrl, src, freq); if (!conn) return -1; conn->msg_out = dpp_tcp_encaps(hdr, buf, len); if (!conn->msg_out) { dpp_connection_remove(conn); return -1; } /* Message will be sent in dpp_conn_tx_ready() */ return 0; } int dpp_relay_rx_gas_req(struct dpp_global *dpp, const u8 *src, const u8 *data, size_t data_len) { struct dpp_relay_controller *ctrl; struct dpp_connection *conn, *found = NULL; struct wpabuf *msg; /* Check if there is a successfully completed authentication for this * and if so, continue that session (send this over TCP) and return 0. */ dl_list_for_each(ctrl, &dpp->controllers, struct dpp_relay_controller, list) { if (found) break; dl_list_for_each(conn, &ctrl->conn, struct dpp_connection, list) { if (os_memcmp(src, conn->mac_addr, ETH_ALEN) == 0) { found = conn; break; } } } if (!found) return -1; msg = wpabuf_alloc(4 + 1 + data_len); if (!msg) return -1; wpabuf_put_be32(msg, 1 + data_len); wpabuf_put_u8(msg, WLAN_PA_GAS_INITIAL_REQ); wpabuf_put_data(msg, data, data_len); wpa_hexdump_buf(MSG_MSGDUMP, "DPP: Outgoing TCP message", msg); wpabuf_free(conn->msg_out); conn->msg_out_pos = 0; conn->msg_out = msg; dpp_tcp_send(conn); return 0; } static void dpp_controller_free(struct dpp_controller *ctrl) { struct dpp_connection *conn, *tmp; if (!ctrl) return; dl_list_for_each_safe(conn, tmp, &ctrl->conn, struct dpp_connection, list) dpp_connection_remove(conn); if (ctrl->sock >= 0) { close(ctrl->sock); eloop_unregister_sock(ctrl->sock, EVENT_TYPE_READ); } os_free(ctrl->configurator_params); os_free(ctrl); } static int dpp_controller_rx_auth_req(struct dpp_connection *conn, const u8 *hdr, const u8 *buf, size_t len) { const u8 *r_bootstrap, *i_bootstrap; u16 r_bootstrap_len, i_bootstrap_len; struct dpp_bootstrap_info *own_bi = NULL, *peer_bi = NULL; if (!conn->ctrl) return 0; wpa_printf(MSG_DEBUG, "DPP: Authentication Request"); r_bootstrap = dpp_get_attr(buf, len, DPP_ATTR_R_BOOTSTRAP_KEY_HASH, &r_bootstrap_len); if (!r_bootstrap || r_bootstrap_len != SHA256_MAC_LEN) { wpa_printf(MSG_INFO, "Missing or invalid required Responder Bootstrapping Key Hash attribute"); return -1; } wpa_hexdump(MSG_MSGDUMP, "DPP: Responder Bootstrapping Key Hash", r_bootstrap, r_bootstrap_len); i_bootstrap = dpp_get_attr(buf, len, DPP_ATTR_I_BOOTSTRAP_KEY_HASH, &i_bootstrap_len); if (!i_bootstrap || i_bootstrap_len != SHA256_MAC_LEN) { wpa_printf(MSG_INFO, "Missing or invalid required Initiator Bootstrapping Key Hash attribute"); return -1; } wpa_hexdump(MSG_MSGDUMP, "DPP: Initiator Bootstrapping Key Hash", i_bootstrap, i_bootstrap_len); /* Try to find own and peer bootstrapping key matches based on the * received hash values */ dpp_bootstrap_find_pair(conn->ctrl->global, i_bootstrap, r_bootstrap, &own_bi, &peer_bi); if (!own_bi) { wpa_printf(MSG_INFO, "No matching own bootstrapping key found - ignore message"); return -1; } if (conn->auth) { wpa_printf(MSG_INFO, "Already in DPP authentication exchange - ignore new one"); return 0; } conn->auth = dpp_auth_req_rx(conn->ctrl->global, conn->ctrl->global->msg_ctx, conn->ctrl->allowed_roles, conn->ctrl->qr_mutual, peer_bi, own_bi, -1, hdr, buf, len); if (!conn->auth) { wpa_printf(MSG_DEBUG, "DPP: No response generated"); return -1; } if (dpp_set_configurator(conn->auth, conn->ctrl->configurator_params) < 0) { dpp_connection_remove(conn); return -1; } return dpp_tcp_send_msg(conn, conn->auth->resp_msg); } static int dpp_controller_rx_auth_resp(struct dpp_connection *conn, const u8 *hdr, const u8 *buf, size_t len) { struct dpp_authentication *auth = conn->auth; struct wpabuf *msg; int res; if (!auth) return -1; wpa_printf(MSG_DEBUG, "DPP: Authentication Response"); msg = dpp_auth_resp_rx(auth, hdr, buf, len); if (!msg) { if (auth->auth_resp_status == DPP_STATUS_RESPONSE_PENDING) { wpa_printf(MSG_DEBUG, "DPP: Start wait for full response"); return -1; } wpa_printf(MSG_DEBUG, "DPP: No confirm generated"); dpp_connection_remove(conn); return -1; } conn->on_tcp_tx_complete_auth_ok = 1; res = dpp_tcp_send_msg(conn, msg); wpabuf_free(msg); return res; } static int dpp_controller_rx_auth_conf(struct dpp_connection *conn, const u8 *hdr, const u8 *buf, size_t len) { struct dpp_authentication *auth = conn->auth; wpa_printf(MSG_DEBUG, "DPP: Authentication Confirmation"); if (!auth) { wpa_printf(MSG_DEBUG, "DPP: No DPP Authentication in progress - drop"); return -1; } if (dpp_auth_conf_rx(auth, hdr, buf, len) < 0) { wpa_printf(MSG_DEBUG, "DPP: Authentication failed"); return -1; } dpp_controller_auth_success(conn, 0); return 0; } void dpp_controller_conn_status_result_wait_timeout(void *eloop_ctx, void *timeout_ctx) { struct dpp_connection *conn = eloop_ctx; if (!conn->auth->waiting_conf_result) return; wpa_printf(MSG_DEBUG, "DPP: Timeout while waiting for Connection Status Result"); wpa_msg(conn->ctrl->global->msg_ctx, MSG_INFO, DPP_EVENT_CONN_STATUS_RESULT "timeout"); dpp_connection_remove(conn); } static int dpp_controller_rx_conf_result(struct dpp_connection *conn, const u8 *hdr, const u8 *buf, size_t len) { struct dpp_authentication *auth = conn->auth; enum dpp_status_error status; if (!conn->ctrl) return 0; wpa_printf(MSG_DEBUG, "DPP: Configuration Result"); if (!auth || !auth->waiting_conf_result) { wpa_printf(MSG_DEBUG, "DPP: No DPP Configuration waiting for result - drop"); return -1; } status = dpp_conf_result_rx(auth, hdr, buf, len); if (status == DPP_STATUS_OK && auth->send_conn_status) { wpa_msg(conn->ctrl->global->msg_ctx, MSG_INFO, DPP_EVENT_CONF_SENT "wait_conn_status=1"); wpa_printf(MSG_DEBUG, "DPP: Wait for Connection Status Result"); eloop_cancel_timeout( dpp_controller_conn_status_result_wait_timeout, conn, NULL); eloop_register_timeout( 16, 0, dpp_controller_conn_status_result_wait_timeout, conn, NULL); return 0; } if (status == DPP_STATUS_OK) wpa_msg(conn->ctrl->global->msg_ctx, MSG_INFO, DPP_EVENT_CONF_SENT); else wpa_msg(conn->ctrl->global->msg_ctx, MSG_INFO, DPP_EVENT_CONF_FAILED); return -1; /* to remove the completed connection */ } static int dpp_controller_rx_conn_status_result(struct dpp_connection *conn, const u8 *hdr, const u8 *buf, size_t len) { struct dpp_authentication *auth = conn->auth; enum dpp_status_error status; u8 ssid[SSID_MAX_LEN]; size_t ssid_len = 0; char *channel_list = NULL; if (!conn->ctrl) return 0; wpa_printf(MSG_DEBUG, "DPP: Connection Status Result"); if (!auth || !auth->waiting_conn_status_result) { wpa_printf(MSG_DEBUG, "DPP: No DPP Configuration waiting for connection status result - drop"); return -1; } status = dpp_conn_status_result_rx(auth, hdr, buf, len, ssid, &ssid_len, &channel_list); wpa_msg(conn->ctrl->global->msg_ctx, MSG_INFO, DPP_EVENT_CONN_STATUS_RESULT "result=%d ssid=%s channel_list=%s", status, wpa_ssid_txt(ssid, ssid_len), channel_list ? channel_list : "N/A"); os_free(channel_list); return -1; /* to remove the completed connection */ } static int dpp_controller_rx_presence_announcement(struct dpp_connection *conn, const u8 *hdr, const u8 *buf, size_t len) { const u8 *r_bootstrap; u16 r_bootstrap_len; struct dpp_bootstrap_info *peer_bi; struct dpp_authentication *auth; struct dpp_global *dpp = conn->ctrl->global; if (conn->auth) { wpa_printf(MSG_DEBUG, "DPP: Ignore Presence Announcement during ongoing Authentication"); return -1; } wpa_printf(MSG_DEBUG, "DPP: Presence Announcement"); r_bootstrap = dpp_get_attr(buf, len, DPP_ATTR_R_BOOTSTRAP_KEY_HASH, &r_bootstrap_len); if (!r_bootstrap || r_bootstrap_len != SHA256_MAC_LEN) { wpa_msg(dpp->msg_ctx, MSG_INFO, DPP_EVENT_FAIL "Missing or invalid required Responder Bootstrapping Key Hash attribute"); return -1; } wpa_hexdump(MSG_MSGDUMP, "DPP: Responder Bootstrapping Key Hash", r_bootstrap, r_bootstrap_len); peer_bi = dpp_bootstrap_find_chirp(dpp, r_bootstrap); if (!peer_bi) { wpa_printf(MSG_DEBUG, "DPP: No matching bootstrapping information found"); return -1; } auth = dpp_auth_init(dpp, dpp->msg_ctx, peer_bi, NULL, DPP_CAPAB_CONFIGURATOR, -1, NULL, 0); if (!auth) return -1; if (dpp_set_configurator(auth, conn->ctrl->configurator_params) < 0) { dpp_auth_deinit(auth); dpp_connection_remove(conn); return -1; } conn->auth = auth; return dpp_tcp_send_msg(conn, conn->auth->req_msg); } static int dpp_controller_rx_reconfig_announcement(struct dpp_connection *conn, const u8 *hdr, const u8 *buf, size_t len) { const u8 *csign_hash; u16 csign_hash_len; struct dpp_configurator *conf; struct dpp_global *dpp = conn->ctrl->global; if (conn->auth) { wpa_printf(MSG_DEBUG, "DPP: Ignore Reconfig Announcement during ongoing Authentication"); return -1; } wpa_printf(MSG_DEBUG, "DPP: Reconfig Announcement"); csign_hash = dpp_get_attr(buf, len, DPP_ATTR_C_SIGN_KEY_HASH, &csign_hash_len); if (!csign_hash || csign_hash_len != SHA256_MAC_LEN) { wpa_msg(dpp->msg_ctx, MSG_INFO, DPP_EVENT_FAIL "Missing or invalid required Configurator C-sign key Hash attribute"); return -1; } wpa_hexdump(MSG_MSGDUMP, "DPP: Configurator C-sign key Hash (kid)", csign_hash, csign_hash_len); conf = dpp_configurator_find_kid(dpp, csign_hash); if (!conf) { wpa_printf(MSG_DEBUG, "DPP: No matching Configurator information found"); return -1; } /* TODO: Initiate Reconfig Authentication */ return -1; } static int dpp_controller_rx_action(struct dpp_connection *conn, const u8 *msg, size_t len) { const u8 *pos, *end; u8 type; wpa_printf(MSG_DEBUG, "DPP: Received DPP Action frame over TCP"); pos = msg; end = msg + len; if (end - pos < DPP_HDR_LEN || WPA_GET_BE24(pos) != OUI_WFA || pos[3] != DPP_OUI_TYPE) { wpa_printf(MSG_DEBUG, "DPP: Unrecognized header"); return -1; } if (pos[4] != 1) { wpa_printf(MSG_DEBUG, "DPP: Unsupported Crypto Suite %u", pos[4]); return -1; } type = pos[5]; wpa_printf(MSG_DEBUG, "DPP: Received message type %u", type); pos += DPP_HDR_LEN; wpa_hexdump(MSG_MSGDUMP, "DPP: Received message attributes", pos, end - pos); if (dpp_check_attrs(pos, end - pos) < 0) return -1; if (conn->relay) { wpa_printf(MSG_DEBUG, "DPP: Relay - send over WLAN"); conn->relay->tx(conn->relay->cb_ctx, conn->mac_addr, conn->freq, msg, len); return 0; } switch (type) { case DPP_PA_AUTHENTICATION_REQ: return dpp_controller_rx_auth_req(conn, msg, pos, end - pos); case DPP_PA_AUTHENTICATION_RESP: return dpp_controller_rx_auth_resp(conn, msg, pos, end - pos); case DPP_PA_AUTHENTICATION_CONF: return dpp_controller_rx_auth_conf(conn, msg, pos, end - pos); case DPP_PA_CONFIGURATION_RESULT: return dpp_controller_rx_conf_result(conn, msg, pos, end - pos); case DPP_PA_CONNECTION_STATUS_RESULT: return dpp_controller_rx_conn_status_result(conn, msg, pos, end - pos); case DPP_PA_PRESENCE_ANNOUNCEMENT: return dpp_controller_rx_presence_announcement(conn, msg, pos, end - pos); case DPP_PA_RECONFIG_ANNOUNCEMENT: return dpp_controller_rx_reconfig_announcement(conn, msg, pos, end - pos); default: /* TODO: missing messages types */ wpa_printf(MSG_DEBUG, "DPP: Unsupported frame subtype %d", type); return -1; } } static int dpp_controller_rx_gas_req(struct dpp_connection *conn, const u8 *msg, size_t len) { const u8 *pos, *end, *next; u8 dialog_token; const u8 *adv_proto; u16 slen; struct wpabuf *resp, *buf; struct dpp_authentication *auth = conn->auth; if (len < 1 + 2) return -1; wpa_printf(MSG_DEBUG, "DPP: Received DPP Configuration Request over TCP"); if (!conn->ctrl || !auth || !auth->auth_success) { wpa_printf(MSG_DEBUG, "DPP: No matching exchange in progress"); return -1; } pos = msg; end = msg + len; dialog_token = *pos++; adv_proto = pos++; slen = *pos++; if (*adv_proto != WLAN_EID_ADV_PROTO || slen > end - pos || slen < 2) return -1; next = pos + slen; pos++; /* skip QueryRespLenLimit and PAME-BI */ if (slen != 8 || *pos != WLAN_EID_VENDOR_SPECIFIC || pos[1] != 5 || WPA_GET_BE24(&pos[2]) != OUI_WFA || pos[5] != DPP_OUI_TYPE || pos[6] != 0x01) return -1; pos = next; /* Query Request */ if (end - pos < 2) return -1; slen = WPA_GET_LE16(pos); pos += 2; if (slen > end - pos) return -1; resp = dpp_conf_req_rx(auth, pos, slen); if (!resp) return -1; buf = wpabuf_alloc(4 + 18 + wpabuf_len(resp)); if (!buf) { wpabuf_free(resp); return -1; } wpabuf_put_be32(buf, 18 + wpabuf_len(resp)); wpabuf_put_u8(buf, WLAN_PA_GAS_INITIAL_RESP); wpabuf_put_u8(buf, dialog_token); wpabuf_put_le16(buf, WLAN_STATUS_SUCCESS); wpabuf_put_le16(buf, 0); /* GAS Comeback Delay */ dpp_write_adv_proto(buf); dpp_write_gas_query(buf, resp); wpabuf_free(resp); /* Send Config Response over TCP; GAS fragmentation is taken care of by * the Relay */ wpa_hexdump_buf(MSG_MSGDUMP, "DPP: Outgoing TCP message", buf); wpabuf_free(conn->msg_out); conn->msg_out_pos = 0; conn->msg_out = buf; conn->on_tcp_tx_complete_gas_done = 1; dpp_tcp_send(conn); return 0; } static int dpp_tcp_rx_gas_resp(struct dpp_connection *conn, struct wpabuf *resp) { struct dpp_authentication *auth = conn->auth; int res; struct wpabuf *msg; enum dpp_status_error status; wpa_printf(MSG_DEBUG, "DPP: Configuration Response for local stack from TCP"); res = dpp_conf_resp_rx(auth, resp); wpabuf_free(resp); if (res < 0) { wpa_printf(MSG_DEBUG, "DPP: Configuration attempt failed"); return -1; } if (conn->global->process_conf_obj) res = conn->global->process_conf_obj(conn->global->cb_ctx, auth); else res = 0; if (auth->peer_version < 2 || auth->conf_resp_status != DPP_STATUS_OK) return -1; wpa_printf(MSG_DEBUG, "DPP: Send DPP Configuration Result"); status = res < 0 ? DPP_STATUS_CONFIG_REJECTED : DPP_STATUS_OK; msg = dpp_build_conf_result(auth, status); if (!msg) return -1; conn->on_tcp_tx_complete_remove = 1; res = dpp_tcp_send_msg(conn, msg); wpabuf_free(msg); /* This exchange will be terminated in the TX status handler */ return res; } static int dpp_rx_gas_resp(struct dpp_connection *conn, const u8 *msg, size_t len) { struct wpabuf *buf; u8 dialog_token; const u8 *pos, *end, *next, *adv_proto; u16 status, slen; if (len < 5 + 2) return -1; wpa_printf(MSG_DEBUG, "DPP: Received DPP Configuration Response over TCP"); pos = msg; end = msg + len; dialog_token = *pos++; status = WPA_GET_LE16(pos); if (status != WLAN_STATUS_SUCCESS) { wpa_printf(MSG_DEBUG, "DPP: Unexpected Status Code %u", status); return -1; } pos += 2; pos += 2; /* ignore GAS Comeback Delay */ adv_proto = pos++; slen = *pos++; if (*adv_proto != WLAN_EID_ADV_PROTO || slen > end - pos || slen < 2) return -1; next = pos + slen; pos++; /* skip QueryRespLenLimit and PAME-BI */ if (slen != 8 || *pos != WLAN_EID_VENDOR_SPECIFIC || pos[1] != 5 || WPA_GET_BE24(&pos[2]) != OUI_WFA || pos[5] != DPP_OUI_TYPE || pos[6] != 0x01) return -1; pos = next; /* Query Response */ if (end - pos < 2) return -1; slen = WPA_GET_LE16(pos); pos += 2; if (slen > end - pos) return -1; buf = wpabuf_alloc(slen); if (!buf) return -1; wpabuf_put_data(buf, pos, slen); if (!conn->relay && !conn->ctrl) return dpp_tcp_rx_gas_resp(conn, buf); if (!conn->relay) { wpa_printf(MSG_DEBUG, "DPP: No matching exchange in progress"); wpabuf_free(buf); return -1; } wpa_printf(MSG_DEBUG, "DPP: Relay - send over WLAN"); conn->relay->gas_resp_tx(conn->relay->cb_ctx, conn->mac_addr, dialog_token, 0, buf); return 0; } static void dpp_controller_rx(int sd, void *eloop_ctx, void *sock_ctx) { struct dpp_connection *conn = eloop_ctx; int res; const u8 *pos; wpa_printf(MSG_DEBUG, "DPP: TCP data available for reading (sock %d)", sd); if (conn->msg_len_octets < 4) { u32 msglen; res = recv(sd, &conn->msg_len[conn->msg_len_octets], 4 - conn->msg_len_octets, 0); if (res < 0) { wpa_printf(MSG_DEBUG, "DPP: recv failed: %s", strerror(errno)); dpp_connection_remove(conn); return; } if (res == 0) { wpa_printf(MSG_DEBUG, "DPP: No more data available over TCP"); dpp_connection_remove(conn); return; } wpa_printf(MSG_DEBUG, "DPP: Received %d/%d octet(s) of message length field", res, (int) (4 - conn->msg_len_octets)); conn->msg_len_octets += res; if (conn->msg_len_octets < 4) { wpa_printf(MSG_DEBUG, "DPP: Need %d more octets of message length field", (int) (4 - conn->msg_len_octets)); return; } msglen = WPA_GET_BE32(conn->msg_len); wpa_printf(MSG_DEBUG, "DPP: Message length: %u", msglen); if (msglen > 65535) { wpa_printf(MSG_INFO, "DPP: Unexpectedly long message"); dpp_connection_remove(conn); return; } wpabuf_free(conn->msg); conn->msg = wpabuf_alloc(msglen); } if (!conn->msg) { wpa_printf(MSG_DEBUG, "DPP: No buffer available for receiving the message"); dpp_connection_remove(conn); return; } wpa_printf(MSG_DEBUG, "DPP: Need %u more octets of message payload", (unsigned int) wpabuf_tailroom(conn->msg)); res = recv(sd, wpabuf_put(conn->msg, 0), wpabuf_tailroom(conn->msg), 0); if (res < 0) { wpa_printf(MSG_DEBUG, "DPP: recv failed: %s", strerror(errno)); dpp_connection_remove(conn); return; } if (res == 0) { wpa_printf(MSG_DEBUG, "DPP: No more data available over TCP"); dpp_connection_remove(conn); return; } wpa_printf(MSG_DEBUG, "DPP: Received %d octets", res); wpabuf_put(conn->msg, res); if (wpabuf_tailroom(conn->msg) > 0) { wpa_printf(MSG_DEBUG, "DPP: Need %u more octets of message payload", (unsigned int) wpabuf_tailroom(conn->msg)); return; } conn->msg_len_octets = 0; wpa_hexdump_buf(MSG_DEBUG, "DPP: Received TCP message", conn->msg); if (wpabuf_len(conn->msg) < 1) { dpp_connection_remove(conn); return; } pos = wpabuf_head(conn->msg); switch (*pos) { case WLAN_PA_VENDOR_SPECIFIC: if (dpp_controller_rx_action(conn, pos + 1, wpabuf_len(conn->msg) - 1) < 0) dpp_connection_remove(conn); break; case WLAN_PA_GAS_INITIAL_REQ: if (dpp_controller_rx_gas_req(conn, pos + 1, wpabuf_len(conn->msg) - 1) < 0) dpp_connection_remove(conn); break; case WLAN_PA_GAS_INITIAL_RESP: if (dpp_rx_gas_resp(conn, pos + 1, wpabuf_len(conn->msg) - 1) < 0) dpp_connection_remove(conn); break; default: wpa_printf(MSG_DEBUG, "DPP: Ignore unsupported message type %u", *pos); break; } } static void dpp_controller_tcp_cb(int sd, void *eloop_ctx, void *sock_ctx) { struct dpp_controller *ctrl = eloop_ctx; struct sockaddr_in addr; socklen_t addr_len = sizeof(addr); int fd; struct dpp_connection *conn; wpa_printf(MSG_DEBUG, "DPP: New TCP connection"); fd = accept(ctrl->sock, (struct sockaddr *) &addr, &addr_len); if (fd < 0) { wpa_printf(MSG_DEBUG, "DPP: Failed to accept new connection: %s", strerror(errno)); return; } wpa_printf(MSG_DEBUG, "DPP: Connection from %s:%d", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port)); conn = os_zalloc(sizeof(*conn)); if (!conn) goto fail; conn->global = ctrl->global; conn->ctrl = ctrl; conn->sock = fd; if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) { wpa_printf(MSG_DEBUG, "DPP: fnctl(O_NONBLOCK) failed: %s", strerror(errno)); goto fail; } if (eloop_register_sock(conn->sock, EVENT_TYPE_READ, dpp_controller_rx, conn, NULL) < 0) goto fail; conn->read_eloop = 1; /* TODO: eloop timeout to expire connections that do not complete in * reasonable time */ dl_list_add(&ctrl->conn, &conn->list); return; fail: close(fd); os_free(conn); } int dpp_tcp_init(struct dpp_global *dpp, struct dpp_authentication *auth, const struct hostapd_ip_addr *addr, int port) { struct dpp_connection *conn; struct sockaddr_storage saddr; socklen_t addrlen; const u8 *hdr, *pos, *end; char txt[100]; wpa_printf(MSG_DEBUG, "DPP: Initialize TCP connection to %s port %d", hostapd_ip_txt(addr, txt, sizeof(txt)), port); if (dpp_ipaddr_to_sockaddr((struct sockaddr *) &saddr, &addrlen, addr, port) < 0) { dpp_auth_deinit(auth); return -1; } conn = os_zalloc(sizeof(*conn)); if (!conn) { dpp_auth_deinit(auth); return -1; } conn->global = dpp; conn->auth = auth; conn->sock = socket(AF_INET, SOCK_STREAM, 0); if (conn->sock < 0) goto fail; if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) { wpa_printf(MSG_DEBUG, "DPP: fnctl(O_NONBLOCK) failed: %s", strerror(errno)); goto fail; } if (connect(conn->sock, (struct sockaddr *) &saddr, addrlen) < 0) { if (errno != EINPROGRESS) { wpa_printf(MSG_DEBUG, "DPP: Failed to connect: %s", strerror(errno)); goto fail; } /* * Continue connecting in the background; eloop will call us * once the connection is ready (or failed). */ } if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE, dpp_conn_tx_ready, conn, NULL) < 0) goto fail; conn->write_eloop = 1; hdr = wpabuf_head(auth->req_msg); end = hdr + wpabuf_len(auth->req_msg); hdr += 2; /* skip Category and Actiom */ pos = hdr + DPP_HDR_LEN; conn->msg_out = dpp_tcp_encaps(hdr, pos, end - pos); if (!conn->msg_out) goto fail; /* Message will be sent in dpp_conn_tx_ready() */ /* TODO: eloop timeout to clear a connection if it does not complete * properly */ dl_list_add(&dpp->tcp_init, &conn->list); return 0; fail: dpp_connection_free(conn); return -1; } int dpp_controller_start(struct dpp_global *dpp, struct dpp_controller_config *config) { struct dpp_controller *ctrl; int on = 1; struct sockaddr_in sin; int port; if (!dpp || dpp->controller) return -1; ctrl = os_zalloc(sizeof(*ctrl)); if (!ctrl) return -1; ctrl->global = dpp; if (config->configurator_params) ctrl->configurator_params = os_strdup(config->configurator_params); dl_list_init(&ctrl->conn); /* TODO: configure these somehow */ ctrl->allowed_roles = DPP_CAPAB_ENROLLEE | DPP_CAPAB_CONFIGURATOR; ctrl->qr_mutual = 0; ctrl->sock = socket(AF_INET, SOCK_STREAM, 0); if (ctrl->sock < 0) goto fail; if (setsockopt(ctrl->sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) { wpa_printf(MSG_DEBUG, "DPP: setsockopt(SO_REUSEADDR) failed: %s", strerror(errno)); /* try to continue anyway */ } if (fcntl(ctrl->sock, F_SETFL, O_NONBLOCK) < 0) { wpa_printf(MSG_INFO, "DPP: fnctl(O_NONBLOCK) failed: %s", strerror(errno)); goto fail; } /* TODO: IPv6 */ os_memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY; port = config->tcp_port ? config->tcp_port : DPP_TCP_PORT; sin.sin_port = htons(port); if (bind(ctrl->sock, (struct sockaddr *) &sin, sizeof(sin)) < 0) { wpa_printf(MSG_INFO, "DPP: Failed to bind Controller TCP port: %s", strerror(errno)); goto fail; } if (listen(ctrl->sock, 10 /* max backlog */) < 0 || fcntl(ctrl->sock, F_SETFL, O_NONBLOCK) < 0 || eloop_register_sock(ctrl->sock, EVENT_TYPE_READ, dpp_controller_tcp_cb, ctrl, NULL)) goto fail; dpp->controller = ctrl; wpa_printf(MSG_DEBUG, "DPP: Controller started on TCP port %d", port); return 0; fail: dpp_controller_free(ctrl); return -1; } void dpp_controller_stop(struct dpp_global *dpp) { if (dpp) { dpp_controller_free(dpp->controller); dpp->controller = NULL; } } void dpp_tcp_init_flush(struct dpp_global *dpp) { struct dpp_connection *conn, *tmp; dl_list_for_each_safe(conn, tmp, &dpp->tcp_init, struct dpp_connection, list) dpp_connection_remove(conn); } static void dpp_relay_controller_free(struct dpp_relay_controller *ctrl) { struct dpp_connection *conn, *tmp; dl_list_for_each_safe(conn, tmp, &ctrl->conn, struct dpp_connection, list) dpp_connection_remove(conn); os_free(ctrl); } void dpp_relay_flush_controllers(struct dpp_global *dpp) { struct dpp_relay_controller *ctrl, *tmp; if (!dpp) return; dl_list_for_each_safe(ctrl, tmp, &dpp->controllers, struct dpp_relay_controller, list) { dl_list_del(&ctrl->list); dpp_relay_controller_free(ctrl); } } #endif /* CONFIG_DPP2 */