2746 lines
68 KiB
C
2746 lines
68 KiB
C
/*
|
|
*
|
|
* Wireless daemon for Linux
|
|
*
|
|
* Copyright (C) 2021 Intel Corporation. All rights reserved.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
|
|
#include <ell/ell.h>
|
|
|
|
#include "linux/nl80211.h"
|
|
|
|
#include "src/missing.h"
|
|
#include "src/dbus.h"
|
|
#include "src/netdev.h"
|
|
#include "src/module.h"
|
|
#include "src/dpp-util.h"
|
|
#include "src/band.h"
|
|
#include "src/frame-xchg.h"
|
|
#include "src/offchannel.h"
|
|
#include "src/wiphy.h"
|
|
#include "src/ie.h"
|
|
#include "src/iwd.h"
|
|
#include "src/util.h"
|
|
#include "src/crypto.h"
|
|
#include "src/mpdu.h"
|
|
#include "ell/useful.h"
|
|
#include "src/common.h"
|
|
#include "src/json.h"
|
|
#include "src/storage.h"
|
|
#include "src/station.h"
|
|
#include "src/scan.h"
|
|
#include "src/network.h"
|
|
#include "src/handshake.h"
|
|
#include "src/nl80211util.h"
|
|
|
|
#define DPP_FRAME_MAX_RETRIES 5
|
|
#define DPP_FRAME_RETRY_TIMEOUT 1
|
|
|
|
static uint32_t netdev_watch;
|
|
static struct l_genl_family *nl80211;
|
|
static uint8_t broadcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
|
static struct l_queue *dpp_list;
|
|
static uint32_t mlme_watch;
|
|
static uint32_t unicast_watch;
|
|
|
|
static uint8_t dpp_prefix[] = { 0x04, 0x09, 0x50, 0x6f, 0x9a, 0x1a, 0x01 };
|
|
|
|
enum dpp_state {
|
|
DPP_STATE_NOTHING,
|
|
DPP_STATE_PRESENCE,
|
|
DPP_STATE_AUTHENTICATING,
|
|
DPP_STATE_CONFIGURING,
|
|
};
|
|
|
|
enum dpp_capability {
|
|
DPP_CAPABILITY_ENROLLEE = 0x01,
|
|
DPP_CAPABILITY_CONFIGURATOR = 0x02,
|
|
};
|
|
|
|
struct dpp_sm {
|
|
struct netdev *netdev;
|
|
char *uri;
|
|
uint8_t role;
|
|
|
|
uint64_t wdev_id;
|
|
|
|
uint8_t *own_asn1;
|
|
size_t own_asn1_len;
|
|
uint8_t *peer_asn1;
|
|
size_t peer_asn1_len;
|
|
uint8_t own_boot_hash[32];
|
|
uint8_t peer_boot_hash[32];
|
|
const struct l_ecc_curve *curve;
|
|
size_t key_len;
|
|
size_t nonce_len;
|
|
struct l_ecc_scalar *boot_private;
|
|
struct l_ecc_point *boot_public;
|
|
struct l_ecc_point *peer_boot_public;
|
|
|
|
enum dpp_state state;
|
|
|
|
/*
|
|
* List of frequencies to jump between. The presence of this list is
|
|
* also used to signify that a configurator is an initiator vs responder
|
|
*/
|
|
uint32_t *freqs;
|
|
size_t freqs_len;
|
|
size_t freqs_idx;
|
|
uint32_t dwell;
|
|
uint32_t current_freq;
|
|
uint32_t new_freq;
|
|
struct scan_freq_set *presence_list;
|
|
|
|
uint32_t offchannel_id;
|
|
|
|
uint8_t auth_addr[6];
|
|
uint8_t r_nonce[32];
|
|
uint8_t i_nonce[32];
|
|
uint8_t e_nonce[32];
|
|
|
|
struct l_ecc_scalar *m;
|
|
uint64_t ke[L_ECC_MAX_DIGITS];
|
|
uint64_t k1[L_ECC_MAX_DIGITS];
|
|
uint64_t k2[L_ECC_MAX_DIGITS];
|
|
uint64_t auth_tag[L_ECC_MAX_DIGITS];
|
|
|
|
struct l_ecc_scalar *proto_private;
|
|
struct l_ecc_point *own_proto_public;
|
|
|
|
struct l_ecc_point *peer_proto_public;
|
|
|
|
uint8_t diag_token;
|
|
|
|
/* Timeout of either auth/config protocol */
|
|
struct l_timeout *timeout;
|
|
|
|
struct dpp_configuration *config;
|
|
uint32_t connect_scan_id;
|
|
uint64_t frame_cookie;
|
|
uint8_t frame_retry;
|
|
void *frame_pending;
|
|
size_t frame_size;
|
|
struct l_timeout *retry_timeout;
|
|
|
|
struct l_dbus_message *pending;
|
|
|
|
bool mcast_support : 1;
|
|
bool roc_started : 1;
|
|
};
|
|
|
|
static bool dpp_get_started(struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
struct l_dbus_message_builder *builder,
|
|
void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
bool started = (dpp->state != DPP_STATE_NOTHING);
|
|
|
|
l_dbus_message_builder_append_basic(builder, 'b', &started);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool dpp_get_role(struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
struct l_dbus_message_builder *builder,
|
|
void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
const char *role;
|
|
|
|
if (dpp->state == DPP_STATE_NOTHING)
|
|
return false;
|
|
|
|
switch (dpp->role) {
|
|
case DPP_CAPABILITY_ENROLLEE:
|
|
role = "enrollee";
|
|
break;
|
|
case DPP_CAPABILITY_CONFIGURATOR:
|
|
role = "configurator";
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
l_dbus_message_builder_append_basic(builder, 's', role);
|
|
return true;
|
|
}
|
|
|
|
static bool dpp_get_uri(struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
struct l_dbus_message_builder *builder,
|
|
void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
|
|
if (dpp->state == DPP_STATE_NOTHING)
|
|
return false;
|
|
|
|
l_dbus_message_builder_append_basic(builder, 's', dpp->uri);
|
|
return true;
|
|
}
|
|
|
|
static void dpp_property_changed_notify(struct dpp_sm *dpp)
|
|
{
|
|
const char *path = netdev_get_path(dpp->netdev);
|
|
|
|
l_dbus_property_changed(dbus_get_bus(), path, IWD_DPP_INTERFACE,
|
|
"Started");
|
|
l_dbus_property_changed(dbus_get_bus(), path, IWD_DPP_INTERFACE,
|
|
"Role");
|
|
l_dbus_property_changed(dbus_get_bus(), path, IWD_DPP_INTERFACE,
|
|
"URI");
|
|
}
|
|
|
|
static void *dpp_serialize_iovec(struct iovec *iov, size_t iov_len,
|
|
size_t *out_len)
|
|
{
|
|
unsigned int i;
|
|
size_t size = 0;
|
|
uint8_t *ret;
|
|
|
|
for (i = 0; i < iov_len; i++)
|
|
size += iov[i].iov_len;
|
|
|
|
ret = l_malloc(size);
|
|
size = 0;
|
|
|
|
for (i = 0; i < iov_len; i++) {
|
|
memcpy(ret + size, iov[i].iov_base, iov[i].iov_len);
|
|
size += iov[i].iov_len;
|
|
}
|
|
|
|
if (out_len)
|
|
*out_len = size;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void dpp_free_auth_data(struct dpp_sm *dpp)
|
|
{
|
|
if (dpp->own_proto_public) {
|
|
l_ecc_point_free(dpp->own_proto_public);
|
|
dpp->own_proto_public = NULL;
|
|
}
|
|
|
|
if (dpp->proto_private) {
|
|
l_ecc_scalar_free(dpp->proto_private);
|
|
dpp->proto_private = NULL;
|
|
}
|
|
|
|
if (dpp->peer_proto_public) {
|
|
l_ecc_point_free(dpp->peer_proto_public);
|
|
dpp->peer_proto_public = NULL;
|
|
}
|
|
|
|
if (dpp->peer_boot_public) {
|
|
l_ecc_point_free(dpp->peer_boot_public);
|
|
dpp->peer_boot_public = NULL;
|
|
}
|
|
|
|
if (dpp->m) {
|
|
l_ecc_scalar_free(dpp->m);
|
|
dpp->m = NULL;
|
|
}
|
|
}
|
|
|
|
static void dpp_reset(struct dpp_sm *dpp)
|
|
{
|
|
if (dpp->uri) {
|
|
l_free(dpp->uri);
|
|
dpp->uri = NULL;
|
|
}
|
|
|
|
if (dpp->freqs) {
|
|
l_free(dpp->freqs);
|
|
dpp->freqs = NULL;
|
|
}
|
|
|
|
if (dpp->offchannel_id) {
|
|
offchannel_cancel(dpp->wdev_id, dpp->offchannel_id);
|
|
dpp->offchannel_id = 0;
|
|
}
|
|
|
|
if (dpp->timeout) {
|
|
l_timeout_remove(dpp->timeout);
|
|
dpp->timeout = NULL;
|
|
}
|
|
|
|
if (dpp->config) {
|
|
dpp_configuration_free(dpp->config);
|
|
dpp->config = NULL;
|
|
}
|
|
|
|
if (dpp->connect_scan_id) {
|
|
scan_cancel(dpp->wdev_id, dpp->connect_scan_id);
|
|
dpp->connect_scan_id = 0;
|
|
}
|
|
|
|
if (dpp->peer_asn1) {
|
|
l_free(dpp->peer_asn1);
|
|
dpp->peer_asn1 = NULL;
|
|
}
|
|
|
|
if (dpp->frame_pending) {
|
|
l_free(dpp->frame_pending);
|
|
dpp->frame_pending = NULL;
|
|
}
|
|
|
|
if (dpp->retry_timeout) {
|
|
l_timeout_remove(dpp->retry_timeout);
|
|
dpp->retry_timeout = NULL;
|
|
}
|
|
|
|
dpp->state = DPP_STATE_NOTHING;
|
|
dpp->new_freq = 0;
|
|
dpp->frame_retry = 0;
|
|
dpp->frame_cookie = 0;
|
|
|
|
explicit_bzero(dpp->r_nonce, dpp->nonce_len);
|
|
explicit_bzero(dpp->i_nonce, dpp->nonce_len);
|
|
explicit_bzero(dpp->e_nonce, dpp->nonce_len);
|
|
explicit_bzero(dpp->ke, dpp->key_len);
|
|
explicit_bzero(dpp->k1, dpp->key_len);
|
|
explicit_bzero(dpp->k2, dpp->key_len);
|
|
explicit_bzero(dpp->auth_tag, dpp->key_len);
|
|
|
|
dpp_free_auth_data(dpp);
|
|
|
|
dpp_property_changed_notify(dpp);
|
|
}
|
|
|
|
static void dpp_free(struct dpp_sm *dpp)
|
|
{
|
|
dpp_reset(dpp);
|
|
|
|
if (dpp->own_asn1) {
|
|
l_free(dpp->own_asn1);
|
|
dpp->own_asn1 = NULL;
|
|
}
|
|
|
|
if (dpp->boot_public) {
|
|
l_ecc_point_free(dpp->boot_public);
|
|
dpp->boot_public = NULL;
|
|
}
|
|
|
|
if (dpp->boot_private) {
|
|
l_ecc_scalar_free(dpp->boot_private);
|
|
dpp->boot_private = NULL;
|
|
}
|
|
|
|
l_free(dpp);
|
|
}
|
|
|
|
static void dpp_send_frame_cb(struct l_genl_msg *msg, void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
int err = l_genl_msg_get_error(msg);
|
|
|
|
if (err < 0) {
|
|
l_error("Error sending frame (%d)", err);
|
|
return;
|
|
}
|
|
|
|
if (nl80211_parse_attrs(msg, NL80211_ATTR_COOKIE, &dpp->frame_cookie,
|
|
NL80211_ATTR_UNSPEC) < 0)
|
|
l_error("Error parsing frame cookie");
|
|
}
|
|
|
|
static void dpp_send_frame(struct dpp_sm *dpp,
|
|
struct iovec *iov, size_t iov_len,
|
|
uint32_t freq)
|
|
{
|
|
struct l_genl_msg *msg;
|
|
|
|
/*
|
|
* A received frame could potentially come in after the ROC session has
|
|
* ended. In this case the frame needs to be stored until ROC is started
|
|
* and sent at that time. The offchannel_id is also checked since
|
|
* this is not applicable when DPP is in a responder role waiting
|
|
* on the currently connected channel i.e. offchannel is never used.
|
|
*/
|
|
if (!dpp->roc_started && dpp->offchannel_id) {
|
|
dpp->frame_pending = dpp_serialize_iovec(iov, iov_len,
|
|
&dpp->frame_size);
|
|
return;
|
|
}
|
|
|
|
msg = l_genl_msg_new_sized(NL80211_CMD_FRAME, 512);
|
|
l_genl_msg_append_attr(msg, NL80211_ATTR_WDEV, 8, &dpp->wdev_id);
|
|
l_genl_msg_append_attr(msg, NL80211_ATTR_WIPHY_FREQ, 4, &freq);
|
|
l_genl_msg_append_attr(msg, NL80211_ATTR_OFFCHANNEL_TX_OK, 0, NULL);
|
|
l_genl_msg_append_attrv(msg, NL80211_ATTR_FRAME, iov, iov_len);
|
|
|
|
l_debug("Sending frame on frequency %u", freq);
|
|
|
|
if (!l_genl_family_send(nl80211, msg, dpp_send_frame_cb, dpp, NULL)) {
|
|
l_error("Could not send CMD_FRAME");
|
|
l_genl_msg_unref(msg);
|
|
}
|
|
}
|
|
|
|
static void dpp_frame_retry(struct dpp_sm *dpp)
|
|
{
|
|
struct iovec iov;
|
|
|
|
iov.iov_base = dpp->frame_pending;
|
|
iov.iov_len = dpp->frame_size;
|
|
|
|
dpp_send_frame(dpp, &iov, 1, dpp->current_freq);
|
|
|
|
l_free(dpp->frame_pending);
|
|
dpp->frame_pending = NULL;
|
|
}
|
|
|
|
|
|
static size_t dpp_build_header(const uint8_t *src, const uint8_t *dest,
|
|
enum dpp_frame_type type,
|
|
uint8_t buf[static 32])
|
|
{
|
|
uint8_t *ptr = buf + 24;
|
|
|
|
memset(buf, 0, 32);
|
|
|
|
l_put_le16(0x00d0, buf);
|
|
memcpy(buf + 4, dest, 6);
|
|
memcpy(buf + 10, src, 6);
|
|
memcpy(buf + 16, broadcast, 6);
|
|
|
|
*ptr++ = 0x04; /* Category: Public */
|
|
*ptr++ = 0x09; /* Action: Vendor specific usage */
|
|
memcpy(ptr, wifi_alliance_oui, 3);
|
|
ptr += 3;
|
|
*ptr++ = 0x1a; /* WiFi Alliance DPP OI type */
|
|
*ptr++ = 1; /* Cryptosuite */
|
|
*ptr++ = type;
|
|
|
|
return ptr - buf;
|
|
}
|
|
|
|
static size_t dpp_build_config_header(const uint8_t *src, const uint8_t *dest,
|
|
uint8_t diag_token,
|
|
uint8_t buf[static 37])
|
|
{
|
|
uint8_t *ptr = buf + 24;
|
|
|
|
memset(buf, 0, 37);
|
|
|
|
l_put_le16(0x00d0, buf);
|
|
memcpy(buf + 4, dest, 6);
|
|
memcpy(buf + 10, src, 6);
|
|
memcpy(buf + 16, broadcast, 6);
|
|
|
|
*ptr++ = 0x04; /* Public */
|
|
*ptr++ = 0x0a; /* Action */
|
|
*ptr++ = diag_token;
|
|
|
|
*ptr++ = IE_TYPE_ADVERTISEMENT_PROTOCOL;
|
|
*ptr++ = 8; /* len */
|
|
*ptr++ = 0x00;
|
|
*ptr++ = IE_TYPE_VENDOR_SPECIFIC;
|
|
*ptr++ = 5;
|
|
memcpy(ptr, wifi_alliance_oui, 3);
|
|
ptr += 3;
|
|
*ptr++ = 0x1a;
|
|
*ptr++ = 1;
|
|
|
|
return ptr - buf;
|
|
}
|
|
|
|
static void dpp_protocol_timeout(struct l_timeout *timeout, void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
|
|
l_debug("DPP timed out");
|
|
|
|
dpp_reset(dpp);
|
|
}
|
|
|
|
static void dpp_reset_protocol_timer(struct dpp_sm *dpp)
|
|
{
|
|
if (dpp->timeout)
|
|
l_timeout_modify(dpp->timeout, 10);
|
|
else
|
|
dpp->timeout = l_timeout_create(10, dpp_protocol_timeout,
|
|
dpp, NULL);
|
|
}
|
|
|
|
/*
|
|
* The configuration protocols use of AD components is somewhat confusing
|
|
* since the request/response frames are of a different format than the rest.
|
|
* In addition there are situations where the components length is zero yet it
|
|
* is still passed as such to AES-SIV.
|
|
*
|
|
* For the configuration request/response frames:
|
|
*
|
|
* "AAD for use with AES-SIV for protected messages in the DPP Configuration
|
|
* protocol shall consist of all octets in the Query Request and Query Response
|
|
* fields up to the first octet of the Wrapped Data attribute, which is the last
|
|
* attribute in a DPP Configuration frame. When the number of octets of AAD is
|
|
* zero, the number of components of AAD passed to AES-SIV is zero."
|
|
*
|
|
* - For configuration requests the optional query request field is not
|
|
* included, therefore no AAD data is passed. (dpp_configuration_start)
|
|
*
|
|
* - The configuration response does contain a query response field which is
|
|
* 5 bytes. (dpp_handle_config_response_frame)
|
|
*
|
|
* For the configuration result/status, the same rules are used as the
|
|
* authentication protocol. This is reiterated in section 6.4.1.
|
|
*
|
|
* - For the configuration result there is some confusion as to exactly how the
|
|
* second AAD component should be passed (since the spec specifically
|
|
* mentions using two components). There are no attributes prior to the
|
|
* wrapped data component meaning the length would be zero.
|
|
* Hostapd/wpa_supplicant pass a zero length AAD component to AES-SIV which
|
|
* does effect the resulting encryption/decryption so this is also what IWD
|
|
* will do to remain compliant with it.
|
|
*/
|
|
static void dpp_configuration_start(struct dpp_sm *dpp, const uint8_t *addr)
|
|
{
|
|
const char *json = "{\"name\":\"IWD\",\"wi-fi_tech\":\"infra\","
|
|
"\"netRole\":\"sta\"}";
|
|
struct iovec iov[3];
|
|
uint8_t hdr[37];
|
|
uint8_t attrs[512];
|
|
size_t json_len = strlen(json);
|
|
uint8_t *ptr = attrs;
|
|
|
|
l_getrandom(&dpp->diag_token, 1);
|
|
|
|
iov[0].iov_len = dpp_build_config_header(
|
|
netdev_get_address(dpp->netdev),
|
|
addr, dpp->diag_token, hdr);
|
|
iov[0].iov_base = hdr;
|
|
|
|
l_getrandom(dpp->e_nonce, dpp->nonce_len);
|
|
|
|
/* length */
|
|
ptr += 2;
|
|
|
|
/*
|
|
* "AAD for use with AES-SIV for protected messages in the DPP
|
|
* Configuration protocol shall consist of all octets in the Query
|
|
* Request and Query Response fields up to the first octet of the
|
|
* Wrapped Data attribute"
|
|
*
|
|
* In this case there is no query request/response fields, nor any
|
|
* attributes besides wrapped data meaning zero AD components.
|
|
*/
|
|
ptr += dpp_append_wrapped_data(NULL, 0, NULL, 0, ptr, sizeof(attrs),
|
|
dpp->ke, dpp->key_len, 2,
|
|
DPP_ATTR_ENROLLEE_NONCE, dpp->nonce_len, dpp->e_nonce,
|
|
DPP_ATTR_CONFIGURATION_REQUEST, json_len, json);
|
|
|
|
l_put_le16(ptr - attrs - 2, attrs);
|
|
|
|
iov[1].iov_base = attrs;
|
|
iov[1].iov_len = ptr - attrs;
|
|
|
|
dpp->state = DPP_STATE_CONFIGURING;
|
|
|
|
dpp_send_frame(dpp, iov, 2, dpp->current_freq);
|
|
}
|
|
|
|
static void send_config_result(struct dpp_sm *dpp, const uint8_t *to)
|
|
{
|
|
uint8_t hdr[32];
|
|
struct iovec iov[2];
|
|
uint8_t attrs[256];
|
|
uint8_t *ptr = attrs;
|
|
uint8_t zero = 0;
|
|
|
|
iov[0].iov_len = dpp_build_header(netdev_get_address(dpp->netdev), to,
|
|
DPP_FRAME_CONFIGURATION_RESULT, hdr);
|
|
iov[0].iov_base = hdr;
|
|
|
|
ptr += dpp_append_wrapped_data(hdr + 26, 6, attrs, 0, ptr,
|
|
sizeof(attrs), dpp->ke, dpp->key_len, 2,
|
|
DPP_ATTR_STATUS, (size_t) 1, &zero,
|
|
DPP_ATTR_ENROLLEE_NONCE, dpp->nonce_len, dpp->e_nonce);
|
|
|
|
iov[1].iov_base = attrs;
|
|
iov[1].iov_len = ptr - attrs;
|
|
|
|
dpp_send_frame(dpp, iov, 2, dpp->current_freq);
|
|
}
|
|
|
|
static void dpp_write_config(struct dpp_configuration *config,
|
|
struct network *network)
|
|
{
|
|
char ssid[33];
|
|
_auto_(l_settings_free) struct l_settings *settings = l_settings_new();
|
|
_auto_(l_free) char *path;
|
|
_auto_(l_free) uint8_t *psk = NULL;
|
|
size_t psk_len;
|
|
|
|
memcpy(ssid, config->ssid, config->ssid_len);
|
|
ssid[config->ssid_len] = '\0';
|
|
|
|
path = storage_get_network_file_path(SECURITY_PSK, ssid);
|
|
|
|
if (l_settings_load_from_file(settings, path)) {
|
|
/* Remove any existing Security keys */
|
|
l_settings_remove_group(settings, "Security");
|
|
}
|
|
|
|
if (config->passphrase) {
|
|
l_settings_set_string(settings, "Security", "Passphrase",
|
|
config->passphrase);
|
|
if (network)
|
|
network_set_passphrase(network, config->passphrase);
|
|
|
|
} else if (config->psk) {
|
|
l_settings_set_string(settings, "Security", "PreSharedKey",
|
|
config->psk);
|
|
|
|
psk = l_util_from_hexstring(config->psk, &psk_len);
|
|
|
|
if (network)
|
|
network_set_psk(network, psk);
|
|
}
|
|
|
|
l_debug("Storing credential for '%s(%s)'", ssid,
|
|
security_to_str(SECURITY_PSK));
|
|
storage_network_sync(SECURITY_PSK, ssid, settings);
|
|
}
|
|
|
|
static void dpp_scan_triggered(int err, void *user_data)
|
|
{
|
|
/* Not much can be done in this case */
|
|
if (err < 0)
|
|
l_error("Failed to trigger DPP scan");
|
|
}
|
|
|
|
static bool dpp_scan_results(int err, struct l_queue *bss_list,
|
|
const struct scan_freq_set *freqs,
|
|
void *userdata)
|
|
{
|
|
struct dpp_sm *dpp = userdata;
|
|
struct station *station = station_find(netdev_get_ifindex(dpp->netdev));
|
|
|
|
if (err < 0)
|
|
return false;
|
|
|
|
station_set_scan_results(station, bss_list, freqs, true);
|
|
|
|
return true;
|
|
}
|
|
|
|
static void dpp_scan_destroy(void *userdata)
|
|
{
|
|
struct dpp_sm *dpp = userdata;
|
|
|
|
dpp->connect_scan_id = 0;
|
|
dpp_reset(dpp);
|
|
}
|
|
|
|
static void dpp_handle_config_response_frame(const struct mmpdu_header *frame,
|
|
const void *body, size_t body_len,
|
|
int rssi, void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
const uint8_t *ptr = body;
|
|
uint16_t status;
|
|
uint16_t fragmented; /* Fragmented/Comeback delay field */
|
|
uint8_t adv_protocol_element[] = { 0x6C, 0x08, 0x7F };
|
|
uint8_t adv_protocol_id[] = { 0xDD, 0x05, 0x50, 0x6F,
|
|
0x9A, 0x1A, 0x01 };
|
|
uint16_t query_len;
|
|
struct dpp_attr_iter iter;
|
|
enum dpp_attribute_type type;
|
|
size_t len;
|
|
const uint8_t *data;
|
|
const char *json = NULL;
|
|
size_t json_len = 0;
|
|
int dstatus = -1;
|
|
const uint8_t *wrapped = NULL;
|
|
const uint8_t *e_nonce = NULL;
|
|
size_t wrapped_len = 0;
|
|
_auto_(l_free) uint8_t *unwrapped = NULL;
|
|
struct dpp_configuration *config;
|
|
struct station *station = station_find(netdev_get_ifindex(dpp->netdev));
|
|
struct network *network = NULL;
|
|
struct scan_bss *bss = NULL;
|
|
char ssid[33];
|
|
|
|
if (dpp->state != DPP_STATE_CONFIGURING)
|
|
return;
|
|
|
|
/*
|
|
* Can a configuration request come from someone other than who you
|
|
* authenticated to?
|
|
*/
|
|
if (memcmp(dpp->auth_addr, frame->address_2, 6))
|
|
return;
|
|
|
|
if (body_len < 19)
|
|
return;
|
|
|
|
ptr += 2;
|
|
|
|
if (*ptr++ != dpp->diag_token)
|
|
return;
|
|
|
|
status = l_get_le16(ptr);
|
|
ptr += 2;
|
|
|
|
if (status != 0) {
|
|
l_debug("Bad configuration status %u", status);
|
|
return;
|
|
}
|
|
|
|
fragmented = l_get_le16(ptr);
|
|
ptr += 2;
|
|
|
|
/*
|
|
* TODO: handle 0x0001 (fragmented), as well as comeback delay.
|
|
*/
|
|
if (fragmented != 0) {
|
|
l_debug("Fragmented messages not currently supported");
|
|
return;
|
|
}
|
|
|
|
if (memcmp(ptr, adv_protocol_element, sizeof(adv_protocol_element))) {
|
|
l_debug("Invalid Advertisement protocol element");
|
|
return;
|
|
}
|
|
|
|
ptr += sizeof(adv_protocol_element);
|
|
|
|
if (memcmp(ptr, adv_protocol_id, sizeof(adv_protocol_id))) {
|
|
l_debug("Invalid Advertisement protocol ID");
|
|
return;
|
|
}
|
|
|
|
ptr += sizeof(adv_protocol_id);
|
|
|
|
query_len = l_get_le16(ptr);
|
|
ptr += 2;
|
|
|
|
if (query_len > body_len - 19)
|
|
return;
|
|
|
|
dpp_attr_iter_init(&iter, ptr, query_len);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_STATUS:
|
|
dstatus = l_get_u8(data);
|
|
break;
|
|
case DPP_ATTR_WRAPPED_DATA:
|
|
wrapped = data;
|
|
wrapped_len = len;
|
|
break;
|
|
default:
|
|
/*
|
|
* TODO: CSR Attribute
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dstatus != DPP_STATUS_OK || !wrapped) {
|
|
l_debug("Bad status or missing attributes");
|
|
return;
|
|
}
|
|
|
|
unwrapped = dpp_unwrap_attr(ptr, wrapped - ptr - 4, NULL, 0, dpp->ke,
|
|
dpp->key_len, wrapped, wrapped_len,
|
|
&wrapped_len);
|
|
if (!unwrapped) {
|
|
l_debug("Failed to unwrap");
|
|
return;
|
|
}
|
|
|
|
dpp_attr_iter_init(&iter, unwrapped, wrapped_len);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_ENROLLEE_NONCE:
|
|
if (len != dpp->nonce_len)
|
|
break;
|
|
|
|
if (memcmp(data, dpp->e_nonce, dpp->nonce_len))
|
|
break;
|
|
|
|
e_nonce = data;
|
|
break;
|
|
case DPP_ATTR_CONFIGURATION_OBJECT:
|
|
json = (const char *)data;
|
|
json_len = len;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!json || !e_nonce) {
|
|
l_debug("No configuration object in response");
|
|
return;
|
|
}
|
|
|
|
config = dpp_parse_configuration_object(json, json_len);
|
|
if (!config) {
|
|
l_error("Configuration object did not parse");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* We should have a station device, but if not DPP can write the
|
|
* credentials out and be done
|
|
*/
|
|
if (station) {
|
|
memcpy(ssid, config->ssid, config->ssid_len);
|
|
ssid[config->ssid_len] = '\0';
|
|
|
|
network = station_network_find(station, ssid, SECURITY_PSK);
|
|
if (network)
|
|
bss = network_bss_select(network, true);
|
|
}
|
|
|
|
dpp_write_config(config, network);
|
|
dpp_configuration_free(config);
|
|
|
|
send_config_result(dpp, dpp->auth_addr);
|
|
|
|
offchannel_cancel(dpp->wdev_id, dpp->offchannel_id);
|
|
|
|
if (network && bss)
|
|
__station_connect_network(station, network, bss);
|
|
else if (station) {
|
|
dpp->connect_scan_id = scan_active(dpp->wdev_id, NULL, 0,
|
|
dpp_scan_triggered,
|
|
dpp_scan_results, dpp,
|
|
dpp_scan_destroy);
|
|
if (dpp->connect_scan_id)
|
|
return;
|
|
}
|
|
|
|
dpp_reset(dpp);
|
|
}
|
|
|
|
static void dpp_send_config_response(struct dpp_sm *dpp, uint8_t status)
|
|
{
|
|
_auto_(l_free) char *json = NULL;
|
|
struct iovec iov[3];
|
|
uint8_t hdr[41];
|
|
uint8_t attrs[512];
|
|
size_t json_len;
|
|
uint8_t *ptr = hdr + 24;
|
|
|
|
memset(hdr, 0, sizeof(hdr));
|
|
|
|
l_put_le16(0x00d0, hdr);
|
|
memcpy(hdr + 4, dpp->auth_addr, 6);
|
|
memcpy(hdr + 10, netdev_get_address(dpp->netdev), 6);
|
|
memcpy(hdr + 16, broadcast, 6);
|
|
|
|
*ptr++ = 0x04;
|
|
*ptr++ = 0x0b;
|
|
*ptr++ = dpp->diag_token;
|
|
l_put_le16(0, ptr); /* status */
|
|
ptr += 2;
|
|
l_put_le16(0, ptr); /* fragmented (no) */
|
|
ptr += 2;
|
|
*ptr++ = IE_TYPE_ADVERTISEMENT_PROTOCOL;
|
|
*ptr++ = 0x08;
|
|
*ptr++ = 0x7f;
|
|
*ptr++ = IE_TYPE_VENDOR_SPECIFIC;
|
|
*ptr++ = 5;
|
|
memcpy(ptr, wifi_alliance_oui, sizeof(wifi_alliance_oui));
|
|
ptr += sizeof(wifi_alliance_oui);
|
|
*ptr++ = 0x1a;
|
|
*ptr++ = 1;
|
|
|
|
iov[0].iov_base = hdr;
|
|
iov[0].iov_len = ptr - hdr;
|
|
|
|
ptr = attrs;
|
|
|
|
ptr += 2; /* length */
|
|
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_STATUS, &status, 1);
|
|
|
|
/*
|
|
* There are several failure status codes that can be used (defined in
|
|
* 6.4.3.1), each with their own set of attributes that should be
|
|
* included. For now IWD's basic DPP implementation will assume
|
|
* STATUS_CONFIGURE_FAILURE which only includes the E-Nonce.
|
|
*/
|
|
if (status == DPP_STATUS_OK) {
|
|
json = dpp_configuration_to_json(dpp->config);
|
|
json_len = strlen(json);
|
|
|
|
ptr += dpp_append_wrapped_data(attrs + 2, ptr - attrs - 2,
|
|
NULL, 0, ptr, sizeof(attrs),
|
|
dpp->ke, dpp->key_len, 2,
|
|
DPP_ATTR_ENROLLEE_NONCE,
|
|
dpp->nonce_len, dpp->e_nonce,
|
|
DPP_ATTR_CONFIGURATION_OBJECT,
|
|
json_len, json);
|
|
} else
|
|
ptr += dpp_append_wrapped_data(attrs + 2, ptr - attrs - 2,
|
|
NULL, 0, ptr, sizeof(attrs),
|
|
dpp->ke, dpp->key_len, 2,
|
|
DPP_ATTR_ENROLLEE_NONCE,
|
|
dpp->nonce_len, dpp->e_nonce);
|
|
|
|
l_put_le16(ptr - attrs - 2, attrs);
|
|
|
|
iov[1].iov_base = attrs;
|
|
iov[1].iov_len = ptr - attrs;
|
|
|
|
dpp_send_frame(dpp, iov, 2, dpp->current_freq);
|
|
}
|
|
|
|
static void dpp_handle_config_request_frame(const struct mmpdu_header *frame,
|
|
const void *body, size_t body_len,
|
|
int rssi, void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
const uint8_t *ptr = body;
|
|
struct dpp_attr_iter iter;
|
|
enum dpp_attribute_type type;
|
|
size_t len;
|
|
const uint8_t *data;
|
|
const char *json = NULL;
|
|
size_t json_len = 0;
|
|
struct json_contents *c;
|
|
const uint8_t *wrapped = NULL;
|
|
const uint8_t *e_nonce = NULL;
|
|
size_t wrapped_len = 0;
|
|
_auto_(l_free) uint8_t *unwrapped = NULL;
|
|
uint8_t hdr_check[] = { IE_TYPE_ADVERTISEMENT_PROTOCOL, 0x08, 0x7f,
|
|
IE_TYPE_VENDOR_SPECIFIC, 5 };
|
|
struct json_iter jsiter;
|
|
_auto_(l_free) char *tech = NULL;
|
|
_auto_(l_free) char *role = NULL;
|
|
|
|
if (dpp->state != DPP_STATE_AUTHENTICATING) {
|
|
l_debug("Configuration request in wrong state");
|
|
return;
|
|
}
|
|
|
|
if (memcmp(dpp->auth_addr, frame->address_2, 6)) {
|
|
l_debug("Configuration request not from authenticated peer");
|
|
return;
|
|
}
|
|
|
|
if (body_len < 15) {
|
|
l_debug("Configuration request data not long enough");
|
|
return;
|
|
}
|
|
|
|
ptr += 2;
|
|
|
|
dpp->diag_token = *ptr++;
|
|
|
|
if (memcmp(ptr, hdr_check, sizeof(hdr_check)))
|
|
return;
|
|
|
|
ptr += sizeof(hdr_check);
|
|
|
|
if (memcmp(ptr, wifi_alliance_oui, sizeof(wifi_alliance_oui)))
|
|
return;
|
|
|
|
ptr += sizeof(wifi_alliance_oui);
|
|
|
|
if (*ptr != 0x1a && *(ptr + 1) != 1)
|
|
return;
|
|
|
|
ptr += 2;
|
|
|
|
len = l_get_le16(ptr);
|
|
ptr += 2;
|
|
|
|
if (len > body_len - 15)
|
|
return;
|
|
|
|
dpp_attr_iter_init(&iter, ptr, len);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_WRAPPED_DATA:
|
|
wrapped = data;
|
|
wrapped_len = len;
|
|
break;
|
|
default:
|
|
/* Wrapped data should be only attribute */
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!wrapped) {
|
|
l_debug("Wrapped data missing");
|
|
return;
|
|
}
|
|
|
|
unwrapped = dpp_unwrap_attr(NULL, 0, NULL, 0, dpp->ke,
|
|
dpp->key_len, wrapped, wrapped_len,
|
|
&wrapped_len);
|
|
if (!unwrapped) {
|
|
l_debug("Failed to unwrap");
|
|
return;
|
|
}
|
|
|
|
dpp_attr_iter_init(&iter, unwrapped, wrapped_len);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_ENROLLEE_NONCE:
|
|
if (len != dpp->nonce_len)
|
|
break;
|
|
|
|
e_nonce = data;
|
|
break;
|
|
case DPP_ATTR_CONFIGURATION_REQUEST:
|
|
json = (const char *)data;
|
|
json_len = len;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!json || !e_nonce) {
|
|
l_debug("No configuration object in response");
|
|
return;
|
|
}
|
|
|
|
c = json_contents_new(json, json_len);
|
|
if (!c) {
|
|
json_contents_free(c);
|
|
return;
|
|
}
|
|
|
|
json_iter_init(&jsiter, c);
|
|
|
|
/*
|
|
* Check mandatory values (Table 7). There isn't much that can be done
|
|
* with these, but the spec requires they be included.
|
|
*/
|
|
if (!json_iter_parse(&jsiter,
|
|
JSON_MANDATORY("name", JSON_STRING, NULL),
|
|
JSON_MANDATORY("wi-fi_tech", JSON_STRING, &tech),
|
|
JSON_MANDATORY("netRole", JSON_STRING, &role),
|
|
JSON_UNDEFINED))
|
|
goto configure_failure;
|
|
|
|
if (strcmp(tech, "infra"))
|
|
goto configure_failure;
|
|
|
|
if (strcmp(role, "sta"))
|
|
goto configure_failure;
|
|
|
|
json_contents_free(c);
|
|
|
|
memcpy(dpp->e_nonce, e_nonce, dpp->nonce_len);
|
|
|
|
dpp->state = DPP_STATE_CONFIGURING;
|
|
|
|
dpp_send_config_response(dpp, DPP_STATUS_OK);
|
|
|
|
return;
|
|
|
|
configure_failure:
|
|
dpp_send_config_response(dpp, DPP_STATUS_CONFIGURE_FAILURE);
|
|
/*
|
|
* The other peer is still authenticated, and can potentially send
|
|
* additional requests so keep this session alive.
|
|
*/
|
|
}
|
|
|
|
static void dpp_handle_config_result_frame(struct dpp_sm *dpp,
|
|
const uint8_t *from, const void *body,
|
|
size_t body_len)
|
|
{
|
|
struct dpp_attr_iter iter;
|
|
enum dpp_attribute_type type;
|
|
size_t len;
|
|
const uint8_t *data;
|
|
int status = -1;
|
|
const void *e_nonce = NULL;
|
|
const void *wrapped = NULL;
|
|
size_t wrapped_len;
|
|
_auto_(l_free) void *unwrapped = NULL;
|
|
|
|
if (dpp->state != DPP_STATE_CONFIGURING)
|
|
return;
|
|
|
|
dpp_attr_iter_init(&iter, body + 8, body_len - 8);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_WRAPPED_DATA:
|
|
wrapped = data;
|
|
wrapped_len = len;
|
|
break;
|
|
default:
|
|
/* Wrapped data should be only attribute */
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!wrapped)
|
|
return;
|
|
|
|
unwrapped = dpp_unwrap_attr(body + 2, wrapped - body - 6, wrapped, 0,
|
|
dpp->ke, dpp->key_len, wrapped,
|
|
wrapped_len, &wrapped_len);
|
|
if (!unwrapped) {
|
|
l_debug("Failed to unwrap DPP configuration result");
|
|
return;
|
|
}
|
|
|
|
dpp_attr_iter_init(&iter, unwrapped, wrapped_len);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_STATUS:
|
|
status = l_get_u8(data);
|
|
break;
|
|
case DPP_ATTR_ENROLLEE_NONCE:
|
|
e_nonce = data;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (status != DPP_STATUS_OK || !e_nonce)
|
|
l_debug("Enrollee signaled a failed configuration");
|
|
else
|
|
l_debug("Configuration success");
|
|
|
|
dpp_reset(dpp);
|
|
}
|
|
|
|
/*
|
|
* The Authentication protocol has a consistent use of AD components, and this
|
|
* use is defined in 6.3.1.4:
|
|
*
|
|
* "Invocations of AES-SIV in the DPP Authentication protocol that produce
|
|
* ciphertext that is part of an additional AES-SIV invocation do not use AAD;
|
|
* in other words, the number of AAD components is set to zero. All other
|
|
* invocations of AES-SIV in the DPP Authentication protocol shall pass a vector
|
|
* of AAD having two components of AAD in the following order: (1) the DPP
|
|
* header, as defined in Table 30, from the OUI field (inclusive) to the DPP
|
|
* Frame Type field (inclusive); and (2) all octets in a DPP Public Action frame
|
|
* after the DPP Frame Type field up to and including the last octet of the last
|
|
* attribute before the Wrapped Data attribute"
|
|
*
|
|
* In practice you see this as AD0 being some offset in the frame (offset to the
|
|
* OUI). For outgoing packets this is 26 bytes offset since the header is built
|
|
* manually. For incoming packets the offset is 2 bytes. The length is always
|
|
* 6 bytes for AD0.
|
|
*
|
|
* The AD1 data is always the start of the attributes, and length is the number
|
|
* of bytes from these attributes to wrapped data. e.g.
|
|
*
|
|
* ad1 = attrs
|
|
* ad1_len = ptr - attrs
|
|
*/
|
|
static void send_authenticate_response(struct dpp_sm *dpp)
|
|
{
|
|
uint8_t hdr[32];
|
|
uint8_t attrs[256];
|
|
uint8_t *ptr = attrs;
|
|
uint8_t status = DPP_STATUS_OK;
|
|
uint64_t r_proto_key[L_ECC_MAX_DIGITS * 2];
|
|
uint8_t version = 2;
|
|
struct iovec iov[3];
|
|
uint8_t wrapped2_plaintext[dpp->key_len + 4];
|
|
uint8_t wrapped2[dpp->key_len + 16 + 8];
|
|
size_t wrapped2_len;
|
|
|
|
l_ecc_point_get_data(dpp->own_proto_public, r_proto_key,
|
|
sizeof(r_proto_key));
|
|
|
|
iov[0].iov_len = dpp_build_header(netdev_get_address(dpp->netdev),
|
|
dpp->auth_addr,
|
|
DPP_FRAME_AUTHENTICATION_RESPONSE, hdr);
|
|
iov[0].iov_base = hdr;
|
|
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_STATUS, &status, 1);
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_RESPONDER_BOOT_KEY_HASH,
|
|
dpp->own_boot_hash, 32);
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_RESPONDER_PROTOCOL_KEY,
|
|
r_proto_key, dpp->key_len * 2);
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_PROTOCOL_VERSION, &version, 1);
|
|
|
|
/* Wrap up secondary data (R-Auth) */
|
|
wrapped2_len = dpp_append_attr(wrapped2_plaintext,
|
|
DPP_ATTR_RESPONDER_AUTH_TAG,
|
|
dpp->auth_tag, dpp->key_len);
|
|
/*
|
|
* "Invocations of AES-SIV in the DPP Authentication protocol that
|
|
* produce ciphertext that is part of an additional AES-SIV invocation
|
|
* do not use AAD; in other words, the number of AAD components is set
|
|
* to zero.""
|
|
*/
|
|
if (!aes_siv_encrypt(dpp->ke, dpp->key_len, wrapped2_plaintext,
|
|
dpp->key_len + 4, NULL, 0, wrapped2)) {
|
|
l_error("Failed to encrypt wrapped data");
|
|
return;
|
|
}
|
|
|
|
wrapped2_len += 16;
|
|
|
|
ptr += dpp_append_wrapped_data(hdr + 26, 6, attrs, ptr - attrs,
|
|
ptr, sizeof(attrs), dpp->k2, dpp->key_len, 4,
|
|
DPP_ATTR_RESPONDER_NONCE, dpp->nonce_len, dpp->r_nonce,
|
|
DPP_ATTR_INITIATOR_NONCE, dpp->nonce_len, dpp->i_nonce,
|
|
DPP_ATTR_RESPONDER_CAPABILITIES, (size_t) 1, &dpp->role,
|
|
DPP_ATTR_WRAPPED_DATA, wrapped2_len, wrapped2);
|
|
|
|
iov[1].iov_base = attrs;
|
|
iov[1].iov_len = ptr - attrs;
|
|
|
|
dpp_send_frame(dpp, iov, 2, dpp->current_freq);
|
|
}
|
|
|
|
static void authenticate_confirm(struct dpp_sm *dpp, const uint8_t *from,
|
|
const uint8_t *body, size_t body_len)
|
|
{
|
|
struct dpp_attr_iter iter;
|
|
enum dpp_attribute_type type;
|
|
size_t len;
|
|
const uint8_t *data;
|
|
int status = -1;
|
|
const uint8_t *r_boot_hash = NULL;
|
|
const void *wrapped = NULL;
|
|
const uint8_t *i_auth = NULL;
|
|
size_t i_auth_len;
|
|
_auto_(l_free) uint8_t *unwrapped = NULL;
|
|
size_t wrapped_len = 0;
|
|
uint64_t i_auth_check[L_ECC_MAX_DIGITS];
|
|
const void *unwrap_key;
|
|
const void *ad0 = body + 2;
|
|
const void *ad1 = body + 8;
|
|
|
|
if (dpp->state != DPP_STATE_AUTHENTICATING)
|
|
return;
|
|
|
|
if (memcmp(from, dpp->auth_addr, 6))
|
|
return;
|
|
|
|
l_debug("authenticate confirm");
|
|
|
|
dpp_attr_iter_init(&iter, body + 8, body_len - 8);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_STATUS:
|
|
status = l_get_u8(data);
|
|
break;
|
|
case DPP_ATTR_RESPONDER_BOOT_KEY_HASH:
|
|
r_boot_hash = data;
|
|
/*
|
|
* Spec requires this, but does not mention if anything
|
|
* is to be done with it.
|
|
*/
|
|
break;
|
|
case DPP_ATTR_INITIATOR_BOOT_KEY_HASH:
|
|
/* No mutual authentication */
|
|
break;
|
|
case DPP_ATTR_WRAPPED_DATA:
|
|
wrapped = data;
|
|
wrapped_len = len;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!r_boot_hash || !wrapped) {
|
|
l_debug("Attributes missing from authenticate confirm");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* "The Responder obtains the DPP Authentication Confirm frame and
|
|
* checks the value of the DPP Status field. If the value of the DPP
|
|
* Status field is STATUS_NOT_COMPATIBLE or STATUS_AUTH_FAILURE, the
|
|
* Responder unwraps the wrapped data portion of the frame using k2"
|
|
*/
|
|
if (status == DPP_STATUS_OK)
|
|
unwrap_key = dpp->ke;
|
|
else if (status == DPP_STATUS_NOT_COMPATIBLE ||
|
|
status == DPP_STATUS_AUTH_FAILURE)
|
|
unwrap_key = dpp->k2;
|
|
else
|
|
goto auth_confirm_failed;
|
|
|
|
unwrapped = dpp_unwrap_attr(ad0, 6, ad1, wrapped - 4 - ad1,
|
|
unwrap_key, dpp->key_len, wrapped, wrapped_len,
|
|
&wrapped_len);
|
|
if (!unwrapped)
|
|
goto auth_confirm_failed;
|
|
|
|
if (status != DPP_STATUS_OK) {
|
|
/*
|
|
* "If unwrapping is successful, the Responder should generate
|
|
* an alert indicating the reason for the protocol failure."
|
|
*/
|
|
l_debug("Authentication failed due to status %s",
|
|
status == DPP_STATUS_NOT_COMPATIBLE ?
|
|
"NOT_COMPATIBLE" : "AUTH_FAILURE");
|
|
goto auth_confirm_failed;
|
|
}
|
|
|
|
dpp_attr_iter_init(&iter, unwrapped, wrapped_len);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_INITIATOR_AUTH_TAG:
|
|
i_auth = data;
|
|
i_auth_len = len;
|
|
break;
|
|
case DPP_ATTR_RESPONDER_NONCE:
|
|
/* Only if error */
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!i_auth || i_auth_len != dpp->key_len) {
|
|
l_debug("I-Auth missing from wrapped data");
|
|
goto auth_confirm_failed;
|
|
}
|
|
|
|
dpp_derive_i_auth(dpp->r_nonce, dpp->i_nonce, dpp->nonce_len,
|
|
dpp->own_proto_public, dpp->peer_proto_public,
|
|
dpp->boot_public, i_auth_check);
|
|
|
|
if (memcmp(i_auth, i_auth_check, i_auth_len)) {
|
|
l_error("I-Auth did not verify");
|
|
goto auth_confirm_failed;
|
|
}
|
|
|
|
l_debug("Authentication successful");
|
|
|
|
dpp_reset_protocol_timer(dpp);
|
|
|
|
if (dpp->role == DPP_CAPABILITY_ENROLLEE)
|
|
dpp_configuration_start(dpp, from);
|
|
|
|
return;
|
|
|
|
auth_confirm_failed:
|
|
dpp->state = DPP_STATE_PRESENCE;
|
|
dpp_free_auth_data(dpp);
|
|
}
|
|
|
|
static void dpp_auth_request_failed(struct dpp_sm *dpp,
|
|
enum dpp_status status,
|
|
void *k1)
|
|
{
|
|
uint8_t hdr[32];
|
|
uint8_t attrs[128];
|
|
uint8_t *ptr = attrs;
|
|
uint8_t version = 2;
|
|
uint8_t s = status;
|
|
struct iovec iov[2];
|
|
|
|
iov[0].iov_len = dpp_build_header(netdev_get_address(dpp->netdev),
|
|
dpp->auth_addr,
|
|
DPP_FRAME_AUTHENTICATION_RESPONSE, hdr);
|
|
iov[0].iov_base = hdr;
|
|
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_STATUS, &s, 1);
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_RESPONDER_BOOT_KEY_HASH,
|
|
dpp->own_boot_hash, 32);
|
|
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_PROTOCOL_VERSION, &version, 1);
|
|
|
|
ptr += dpp_append_wrapped_data(hdr + 26, 6, attrs, ptr - attrs,
|
|
ptr, sizeof(attrs) - (ptr - attrs), k1, dpp->key_len, 2,
|
|
DPP_ATTR_INITIATOR_NONCE, dpp->nonce_len, dpp->i_nonce,
|
|
DPP_ATTR_RESPONDER_CAPABILITIES,
|
|
(size_t) 1, &dpp->role);
|
|
|
|
iov[1].iov_base = attrs;
|
|
iov[1].iov_len = ptr - attrs;
|
|
|
|
dpp_send_frame(dpp, iov, 2, dpp->current_freq);
|
|
}
|
|
|
|
static bool dpp_check_roles(struct dpp_sm *dpp, uint8_t peer_capa)
|
|
{
|
|
if (dpp->role == DPP_CAPABILITY_ENROLLEE &&
|
|
!(peer_capa & DPP_CAPABILITY_CONFIGURATOR))
|
|
return false;
|
|
else if (dpp->role == DPP_CAPABILITY_CONFIGURATOR &&
|
|
!(peer_capa & DPP_CAPABILITY_ENROLLEE))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static void dpp_presence_announce(struct dpp_sm *dpp)
|
|
{
|
|
struct netdev *netdev = dpp->netdev;
|
|
uint8_t hdr[32];
|
|
uint8_t attrs[32 + 4];
|
|
uint8_t hash[32];
|
|
uint8_t *ptr = attrs;
|
|
const uint8_t *addr = netdev_get_address(netdev);
|
|
struct iovec iov[2];
|
|
|
|
iov[0].iov_len = dpp_build_header(addr, broadcast,
|
|
DPP_FRAME_PRESENCE_ANNOUNCEMENT, hdr);
|
|
iov[0].iov_base = hdr;
|
|
|
|
dpp_hash(L_CHECKSUM_SHA256, hash, 2, "chirp", strlen("chirp"),
|
|
dpp->own_asn1, dpp->own_asn1_len);
|
|
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_RESPONDER_BOOT_KEY_HASH, hash, 32);
|
|
|
|
iov[1].iov_base = attrs;
|
|
iov[1].iov_len = ptr - attrs;
|
|
|
|
l_debug("Sending presence announcement on frequency %u and waiting %u",
|
|
dpp->current_freq, dpp->dwell);
|
|
|
|
dpp_send_frame(dpp, iov, 2, dpp->current_freq);
|
|
}
|
|
|
|
static bool dpp_send_authenticate_request(struct dpp_sm *dpp)
|
|
{
|
|
uint8_t hdr[32];
|
|
uint8_t attrs[256];
|
|
uint8_t *ptr = attrs;
|
|
uint64_t i_proto_key[L_ECC_MAX_DIGITS * 2];
|
|
uint8_t version = 2;
|
|
struct iovec iov[2];
|
|
struct station *station = station_find(netdev_get_ifindex(dpp->netdev));
|
|
struct scan_bss *bss = station_get_connected_bss(station);
|
|
|
|
/* Got disconnected by the time the peer was discovered */
|
|
if (!bss) {
|
|
dpp_reset(dpp);
|
|
return false;
|
|
}
|
|
|
|
l_ecc_point_get_data(dpp->own_proto_public, i_proto_key,
|
|
sizeof(i_proto_key));
|
|
|
|
iov[0].iov_len = dpp_build_header(netdev_get_address(dpp->netdev),
|
|
dpp->auth_addr,
|
|
DPP_FRAME_AUTHENTICATION_REQUEST, hdr);
|
|
iov[0].iov_base = hdr;
|
|
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_RESPONDER_BOOT_KEY_HASH,
|
|
dpp->peer_boot_hash, 32);
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_INITIATOR_BOOT_KEY_HASH,
|
|
dpp->own_boot_hash, 32);
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_INITIATOR_PROTOCOL_KEY,
|
|
i_proto_key, dpp->key_len * 2);
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_PROTOCOL_VERSION, &version, 1);
|
|
|
|
if (dpp->current_freq != bss->frequency) {
|
|
uint8_t pair[2] = { 81,
|
|
band_freq_to_channel(bss->frequency, NULL) };
|
|
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_CHANNEL, pair, 2);
|
|
}
|
|
|
|
ptr += dpp_append_wrapped_data(hdr + 26, 6, attrs, ptr - attrs,
|
|
ptr, sizeof(attrs), dpp->k1, dpp->key_len, 2,
|
|
DPP_ATTR_INITIATOR_NONCE, dpp->nonce_len, dpp->i_nonce,
|
|
DPP_ATTR_INITIATOR_CAPABILITIES,
|
|
(size_t) 1, &dpp->role);
|
|
|
|
iov[1].iov_base = attrs;
|
|
iov[1].iov_len = ptr - attrs;
|
|
|
|
dpp_send_frame(dpp, iov, 2, dpp->current_freq);
|
|
|
|
return true;
|
|
}
|
|
|
|
static void dpp_roc_started(void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
|
|
/*
|
|
* - If a configurator, nothing to do but wait for a request
|
|
* (unless multicast frame registration is unsupported in which case
|
|
* send an authenticate request now)
|
|
* - If in the presence state continue sending announcements.
|
|
* - If authenticating, and this is a result of a channel switch send
|
|
* the authenticate response now.
|
|
*/
|
|
|
|
dpp->roc_started = true;
|
|
|
|
/*
|
|
* The retry timer indicates a frame was not acked in which case we
|
|
* should not change any state or send any frames until that expires.
|
|
*/
|
|
if (dpp->retry_timeout)
|
|
return;
|
|
|
|
if (dpp->frame_pending) {
|
|
dpp_frame_retry(dpp);
|
|
return;
|
|
}
|
|
|
|
switch (dpp->state) {
|
|
case DPP_STATE_PRESENCE:
|
|
if (dpp->role == DPP_CAPABILITY_CONFIGURATOR)
|
|
return;
|
|
|
|
if (dpp->pending) {
|
|
struct l_dbus_message *reply =
|
|
l_dbus_message_new_method_return(dpp->pending);
|
|
|
|
l_dbus_message_set_arguments(reply, "s", dpp->uri);
|
|
|
|
dbus_pending_reply(&dpp->pending, reply);
|
|
}
|
|
|
|
dpp_presence_announce(dpp);
|
|
break;
|
|
case DPP_STATE_AUTHENTICATING:
|
|
/*
|
|
* No multicast frame registration support, jump right into
|
|
* sending auth frames. This diverges from the 2.0 spec, but in
|
|
* reality the the main path nearly all drivers will hit.
|
|
*/
|
|
if (dpp->role == DPP_CAPABILITY_CONFIGURATOR) {
|
|
if (dpp->mcast_support)
|
|
return;
|
|
|
|
dpp_send_authenticate_request(dpp);
|
|
return;
|
|
}
|
|
|
|
if (dpp->new_freq) {
|
|
dpp->current_freq = dpp->new_freq;
|
|
dpp->new_freq = 0;
|
|
send_authenticate_response(dpp);
|
|
}
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void dpp_start_offchannel(struct dpp_sm *dpp, uint32_t freq);
|
|
|
|
static void dpp_presence_timeout(int error, void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
|
|
dpp->offchannel_id = 0;
|
|
dpp->roc_started = false;
|
|
|
|
/*
|
|
* If cancelled this is likely due to netdev going down or from Stop().
|
|
* Otherwise there was some other problem which is probably not
|
|
* recoverable.
|
|
*/
|
|
if (error == -ECANCELED)
|
|
return;
|
|
else if (error == -EIO)
|
|
goto next_roc;
|
|
else if (error < 0)
|
|
goto protocol_failed;
|
|
|
|
switch (dpp->state) {
|
|
case DPP_STATE_PRESENCE:
|
|
break;
|
|
case DPP_STATE_NOTHING:
|
|
/* Protocol already terminated */
|
|
return;
|
|
case DPP_STATE_AUTHENTICATING:
|
|
case DPP_STATE_CONFIGURING:
|
|
goto next_roc;
|
|
}
|
|
|
|
dpp->freqs_idx++;
|
|
|
|
if (dpp->freqs_idx >= dpp->freqs_len) {
|
|
l_debug("Max retries on presence announcements");
|
|
dpp->freqs_idx = 0;
|
|
}
|
|
|
|
dpp->current_freq = dpp->freqs[dpp->freqs_idx];
|
|
|
|
l_debug("Presence timeout, moving to next frequency %u, duration %u",
|
|
dpp->current_freq, dpp->dwell);
|
|
|
|
next_roc:
|
|
dpp_start_offchannel(dpp, dpp->current_freq);
|
|
|
|
return;
|
|
|
|
protocol_failed:
|
|
dpp_reset(dpp);
|
|
}
|
|
|
|
static void dpp_start_offchannel(struct dpp_sm *dpp, uint32_t freq)
|
|
{
|
|
/*
|
|
* This needs to be handled carefully for a few reasons:
|
|
*
|
|
* First, the next offchannel operation needs to be started prior to
|
|
* canceling an existing one. This is so the offchannel work can
|
|
* continue uninterrupted without any other work items starting in
|
|
* between canceling and starting the next (e.g. if a scan request is
|
|
* sitting in the queue).
|
|
*
|
|
* Second, dpp_presence_timeout resets dpp->offchannel_id to zero which
|
|
* is why the new ID is saved and only set to dpp->offchannel_id once
|
|
* the previous offchannel work is cancelled (i.e. destroy() has been
|
|
* called).
|
|
*/
|
|
uint32_t id = offchannel_start(netdev_get_wdev_id(dpp->netdev),
|
|
WIPHY_WORK_PRIORITY_OFFCHANNEL,
|
|
freq, dpp->dwell, dpp_roc_started,
|
|
dpp, dpp_presence_timeout);
|
|
|
|
if (dpp->offchannel_id)
|
|
offchannel_cancel(dpp->wdev_id, dpp->offchannel_id);
|
|
|
|
dpp->offchannel_id = id;
|
|
}
|
|
|
|
static void authenticate_request(struct dpp_sm *dpp, const uint8_t *from,
|
|
const uint8_t *body, size_t body_len)
|
|
{
|
|
struct dpp_attr_iter iter;
|
|
enum dpp_attribute_type type;
|
|
size_t len;
|
|
const uint8_t *data;
|
|
const uint8_t *r_boot = NULL;
|
|
const uint8_t *i_boot = NULL;
|
|
const uint8_t *i_proto = NULL;
|
|
const void *wrapped = NULL;
|
|
const uint8_t *i_nonce = NULL;
|
|
uint8_t i_capa = 0;
|
|
size_t r_boot_len = 0, i_proto_len = 0, wrapped_len = 0;
|
|
size_t i_nonce_len = 0;
|
|
_auto_(l_free) uint8_t *unwrapped = NULL;
|
|
_auto_(l_ecc_scalar_free) struct l_ecc_scalar *m = NULL;
|
|
_auto_(l_ecc_scalar_free) struct l_ecc_scalar *n = NULL;
|
|
uint64_t k1[L_ECC_MAX_DIGITS];
|
|
const void *ad0 = body + 2;
|
|
const void *ad1 = body + 8;
|
|
uint32_t freq;
|
|
|
|
if (util_is_broadcast_address(from))
|
|
return;
|
|
|
|
if (dpp->state != DPP_STATE_PRESENCE)
|
|
return;
|
|
|
|
l_debug("authenticate request");
|
|
|
|
dpp_attr_iter_init(&iter, body + 8, body_len - 8);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_INITIATOR_BOOT_KEY_HASH:
|
|
i_boot = data;
|
|
/*
|
|
* This attribute is required by the spec, but only
|
|
* used for mutual authentication.
|
|
*/
|
|
break;
|
|
case DPP_ATTR_RESPONDER_BOOT_KEY_HASH:
|
|
r_boot = data;
|
|
r_boot_len = len;
|
|
break;
|
|
case DPP_ATTR_INITIATOR_PROTOCOL_KEY:
|
|
i_proto = data;
|
|
i_proto_len = len;
|
|
break;
|
|
case DPP_ATTR_WRAPPED_DATA:
|
|
/* I-Nonce/I-Capabilities part of wrapped data */
|
|
wrapped = data;
|
|
wrapped_len = len;
|
|
break;
|
|
|
|
/* Optional attributes */
|
|
case DPP_ATTR_PROTOCOL_VERSION:
|
|
if (l_get_u8(data) != 2) {
|
|
l_debug("Protocol version did not match");
|
|
return;
|
|
}
|
|
|
|
break;
|
|
|
|
case DPP_ATTR_CHANNEL:
|
|
if (len != 2)
|
|
return;
|
|
|
|
freq = oci_to_frequency(l_get_u8(data),
|
|
l_get_u8(data + 1));
|
|
|
|
if (freq == dpp->current_freq)
|
|
break;
|
|
|
|
/*
|
|
* Configurators are already connected to a network, so
|
|
* to preserve wireless performance the enrollee will
|
|
* be required to be on this channel, not a channel it
|
|
* requests.
|
|
*/
|
|
if (dpp->role == DPP_CAPABILITY_CONFIGURATOR)
|
|
return;
|
|
|
|
/*
|
|
* Otherwise, as an enrollee, we can jump to whatever
|
|
* channel the configurator requests
|
|
*/
|
|
dpp->new_freq = freq;
|
|
|
|
l_debug("Configurator requested a new frequency %u",
|
|
dpp->new_freq);
|
|
|
|
dpp_start_offchannel(dpp, dpp->new_freq);
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!r_boot || !i_boot || !i_proto || !wrapped)
|
|
goto auth_request_failed;
|
|
|
|
if (r_boot_len != 32 || memcmp(dpp->own_boot_hash,
|
|
r_boot, r_boot_len)) {
|
|
l_debug("Responder boot key hash failed to verify");
|
|
goto auth_request_failed;
|
|
}
|
|
|
|
dpp->peer_proto_public = l_ecc_point_from_data(dpp->curve,
|
|
L_ECC_POINT_TYPE_FULL,
|
|
i_proto, i_proto_len);
|
|
if (!dpp->peer_proto_public) {
|
|
l_debug("Initiators protocol key invalid");
|
|
goto auth_request_failed;
|
|
}
|
|
|
|
m = dpp_derive_k1(dpp->peer_proto_public, dpp->boot_private, k1);
|
|
if (!m)
|
|
goto auth_request_failed;
|
|
|
|
unwrapped = dpp_unwrap_attr(ad0, 6, ad1, wrapped - 4 - ad1,
|
|
k1, dpp->key_len, wrapped, wrapped_len, &wrapped_len);
|
|
if (!unwrapped)
|
|
goto auth_request_failed;
|
|
|
|
dpp_attr_iter_init(&iter, unwrapped, wrapped_len);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_INITIATOR_NONCE:
|
|
i_nonce = data;
|
|
i_nonce_len = len;
|
|
break;
|
|
case DPP_ATTR_INITIATOR_CAPABILITIES:
|
|
/*
|
|
* "If the Responder is not capable of supporting the
|
|
* role indicated by the Initiator, it shall respond
|
|
* with a DPP Authentication Response frame indicating
|
|
* failure by adding the DPP Status field set to
|
|
* STATUS_NOT_COMPATIBLE"
|
|
*/
|
|
i_capa = l_get_u8(data);
|
|
|
|
if (!dpp_check_roles(dpp, i_capa)) {
|
|
l_debug("Peer does not support required role");
|
|
dpp_auth_request_failed(dpp,
|
|
DPP_STATUS_NOT_COMPATIBLE, k1);
|
|
goto auth_request_failed;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i_nonce_len != dpp->nonce_len) {
|
|
l_debug("I-Nonce has unexpected length %zu", i_nonce_len);
|
|
goto auth_request_failed;
|
|
}
|
|
|
|
memcpy(dpp->i_nonce, i_nonce, i_nonce_len);
|
|
|
|
/* Derive keys k2, ke, and R-Auth for authentication response */
|
|
|
|
n = dpp_derive_k2(dpp->peer_proto_public, dpp->proto_private, dpp->k2);
|
|
if (!n)
|
|
goto auth_request_failed;
|
|
|
|
l_getrandom(dpp->r_nonce, dpp->nonce_len);
|
|
|
|
if (!dpp_derive_ke(dpp->i_nonce, dpp->r_nonce, m, n, dpp->ke))
|
|
goto auth_request_failed;
|
|
|
|
if (!dpp_derive_r_auth(dpp->i_nonce, dpp->r_nonce, dpp->nonce_len,
|
|
dpp->peer_proto_public, dpp->own_proto_public,
|
|
dpp->boot_public, dpp->auth_tag))
|
|
goto auth_request_failed;
|
|
|
|
memcpy(dpp->auth_addr, from, 6);
|
|
|
|
dpp->state = DPP_STATE_AUTHENTICATING;
|
|
dpp_reset_protocol_timer(dpp);
|
|
|
|
/* Don't send if the frequency is changing */
|
|
if (!dpp->new_freq)
|
|
send_authenticate_response(dpp);
|
|
|
|
return;
|
|
|
|
auth_request_failed:
|
|
dpp->state = DPP_STATE_PRESENCE;
|
|
dpp_free_auth_data(dpp);
|
|
}
|
|
|
|
static void dpp_send_authenticate_confirm(struct dpp_sm *dpp)
|
|
{
|
|
uint8_t hdr[32];
|
|
struct iovec iov[2];
|
|
uint8_t attrs[256];
|
|
uint8_t *ptr = attrs;
|
|
uint8_t zero = 0;
|
|
|
|
iov[0].iov_len = dpp_build_header(netdev_get_address(dpp->netdev),
|
|
dpp->auth_addr,
|
|
DPP_FRAME_AUTHENTICATION_CONFIRM, hdr);
|
|
iov[0].iov_base = hdr;
|
|
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_STATUS, &zero, 1);
|
|
ptr += dpp_append_attr(ptr, DPP_ATTR_RESPONDER_BOOT_KEY_HASH,
|
|
dpp->peer_boot_hash, 32);
|
|
|
|
ptr += dpp_append_wrapped_data(hdr + 26, 6, attrs, ptr - attrs, ptr,
|
|
sizeof(attrs), dpp->ke, dpp->key_len, 1,
|
|
DPP_ATTR_INITIATOR_AUTH_TAG, dpp->key_len,
|
|
dpp->auth_tag);
|
|
|
|
iov[1].iov_base = attrs;
|
|
iov[1].iov_len = ptr - attrs;
|
|
|
|
dpp_send_frame(dpp, iov, 2, dpp->current_freq);
|
|
}
|
|
|
|
static void authenticate_response(struct dpp_sm *dpp, const uint8_t *from,
|
|
const uint8_t *body, size_t body_len)
|
|
{
|
|
struct dpp_attr_iter iter;
|
|
enum dpp_attribute_type type;
|
|
size_t len;
|
|
const uint8_t *data;
|
|
int status = -1;
|
|
const void *r_boot_hash = NULL;
|
|
const void *r_proto = NULL;
|
|
size_t r_proto_len = 0;
|
|
const void *wrapped = NULL;
|
|
size_t wrapped_len;
|
|
_auto_(l_free) uint8_t *unwrapped1 = NULL;
|
|
_auto_(l_free) uint8_t *unwrapped2 = NULL;
|
|
const void *r_nonce = NULL;
|
|
const void *i_nonce = NULL;
|
|
const void *r_auth = NULL;
|
|
_auto_(l_ecc_point_free) struct l_ecc_point *r_proto_key = NULL;
|
|
_auto_(l_ecc_scalar_free) struct l_ecc_scalar *n = NULL;
|
|
const void *ad0 = body + 2;
|
|
const void *ad1 = body + 8;
|
|
uint64_t r_auth_derived[L_ECC_MAX_DIGITS];
|
|
|
|
l_debug("Authenticate response");
|
|
|
|
if (dpp->state != DPP_STATE_AUTHENTICATING)
|
|
return;
|
|
|
|
if (dpp->role != DPP_CAPABILITY_CONFIGURATOR)
|
|
return;
|
|
|
|
if (!dpp->freqs)
|
|
return;
|
|
|
|
if (memcmp(from, dpp->auth_addr, 6))
|
|
return;
|
|
|
|
dpp_attr_iter_init(&iter, body + 8, body_len - 8);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_STATUS:
|
|
if (len != 1)
|
|
return;
|
|
|
|
status = l_get_u8(data);
|
|
break;
|
|
case DPP_ATTR_RESPONDER_BOOT_KEY_HASH:
|
|
r_boot_hash = data;
|
|
break;
|
|
case DPP_ATTR_RESPONDER_PROTOCOL_KEY:
|
|
r_proto = data;
|
|
r_proto_len = len;
|
|
break;
|
|
case DPP_ATTR_PROTOCOL_VERSION:
|
|
if (len != 1 || l_get_u8(data) != 2)
|
|
return;
|
|
break;
|
|
case DPP_ATTR_WRAPPED_DATA:
|
|
wrapped = data;
|
|
wrapped_len = len;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (status != DPP_STATUS_OK || !r_boot_hash || !r_proto ) {
|
|
l_debug("Auth response bad status or missing attributes");
|
|
return;
|
|
}
|
|
|
|
r_proto_key = l_ecc_point_from_data(dpp->curve, L_ECC_POINT_TYPE_FULL,
|
|
r_proto, r_proto_len);
|
|
if (!r_proto_key) {
|
|
l_debug("Peers protocol key was invalid");
|
|
return;
|
|
}
|
|
|
|
n = dpp_derive_k2(r_proto_key, dpp->proto_private, dpp->k2);
|
|
|
|
unwrapped1 = dpp_unwrap_attr(ad0, 6, ad1, wrapped - 4 - ad1, dpp->k2,
|
|
dpp->key_len, wrapped, wrapped_len,
|
|
&wrapped_len);
|
|
if (!unwrapped1) {
|
|
l_debug("Failed to unwrap primary data");
|
|
return;
|
|
}
|
|
|
|
wrapped = NULL;
|
|
|
|
dpp_attr_iter_init(&iter, unwrapped1, wrapped_len);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_RESPONDER_NONCE:
|
|
if (len != dpp->nonce_len)
|
|
return;
|
|
|
|
r_nonce = data;
|
|
break;
|
|
case DPP_ATTR_INITIATOR_NONCE:
|
|
if (len != dpp->nonce_len)
|
|
return;
|
|
|
|
i_nonce = data;
|
|
break;
|
|
case DPP_ATTR_RESPONDER_CAPABILITIES:
|
|
break;
|
|
case DPP_ATTR_WRAPPED_DATA:
|
|
wrapped = data;
|
|
wrapped_len = len;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!r_nonce || !i_nonce || !wrapped) {
|
|
l_debug("Wrapped data missing attributes");
|
|
return;
|
|
}
|
|
|
|
if (!dpp_derive_ke(i_nonce, r_nonce, dpp->m, n, dpp->ke)) {
|
|
l_debug("Failed to derive ke");
|
|
return;
|
|
}
|
|
|
|
unwrapped2 = dpp_unwrap_attr(NULL, 0, NULL, 0, dpp->ke, dpp->key_len,
|
|
wrapped, wrapped_len, &wrapped_len);
|
|
if (!unwrapped2) {
|
|
l_debug("Failed to unwrap secondary data");
|
|
return;
|
|
}
|
|
|
|
dpp_attr_iter_init(&iter, unwrapped2, wrapped_len);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_RESPONDER_AUTH_TAG:
|
|
if (len != dpp->key_len)
|
|
return;
|
|
|
|
r_auth = data;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!r_auth) {
|
|
l_debug("R-Auth was not in secondary wrapped data");
|
|
return;
|
|
}
|
|
|
|
if (!dpp_derive_r_auth(i_nonce, r_nonce, dpp->nonce_len,
|
|
dpp->own_proto_public, r_proto_key,
|
|
dpp->peer_boot_public, r_auth_derived)) {
|
|
l_debug("Failed to derive r_auth");
|
|
return;
|
|
}
|
|
|
|
if (memcmp(r_auth, r_auth_derived, dpp->key_len)) {
|
|
l_debug("R-Auth did not verify");
|
|
return;
|
|
}
|
|
|
|
if (!dpp_derive_i_auth(r_nonce, i_nonce, dpp->nonce_len,
|
|
r_proto_key, dpp->own_proto_public,
|
|
dpp->peer_boot_public, dpp->auth_tag)) {
|
|
l_debug("Could not derive I-Auth");
|
|
return;
|
|
}
|
|
|
|
dpp->current_freq = dpp->new_freq;
|
|
|
|
dpp_send_authenticate_confirm(dpp);
|
|
}
|
|
|
|
static void dpp_handle_presence_announcement(struct dpp_sm *dpp,
|
|
const uint8_t *from,
|
|
const uint8_t *body,
|
|
size_t body_len)
|
|
{
|
|
struct dpp_attr_iter iter;
|
|
enum dpp_attribute_type type;
|
|
size_t len;
|
|
const uint8_t *data;
|
|
const void *r_boot = NULL;
|
|
size_t r_boot_len = 0;
|
|
uint8_t hash[32];
|
|
|
|
l_debug("Presence announcement "MAC, MAC_STR(from));
|
|
|
|
/* Must be a configurator, in an initiator role, in PRESENCE state */
|
|
if (dpp->state != DPP_STATE_PRESENCE)
|
|
return;
|
|
|
|
if (dpp->role != DPP_CAPABILITY_CONFIGURATOR)
|
|
return;
|
|
|
|
if (!dpp->freqs)
|
|
return;
|
|
|
|
/*
|
|
* The URI may not have contained a MAC address, if this announcement
|
|
* verifies set auth_addr then.
|
|
*/
|
|
if (!l_memeqzero(dpp->auth_addr, 6) &&
|
|
memcmp(from, dpp->auth_addr, 6)) {
|
|
l_debug("Unexpected source "MAC" expected "MAC, MAC_STR(from),
|
|
MAC_STR(dpp->auth_addr));
|
|
return;
|
|
}
|
|
|
|
dpp_attr_iter_init(&iter, body + 8, body_len - 8);
|
|
|
|
while (dpp_attr_iter_next(&iter, &type, &len, &data)) {
|
|
switch (type) {
|
|
case DPP_ATTR_RESPONDER_BOOT_KEY_HASH:
|
|
r_boot = data;
|
|
r_boot_len = len;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!r_boot || r_boot_len != 32) {
|
|
l_debug("No responder boot hash");
|
|
return;
|
|
}
|
|
|
|
/* Hash what we have for the peer and check its our enrollee */
|
|
dpp_hash(L_CHECKSUM_SHA256, hash, 2, "chirp", strlen("chirp"),
|
|
dpp->peer_asn1, dpp->peer_asn1_len);
|
|
|
|
if (memcmp(hash, r_boot, sizeof(hash))) {
|
|
l_debug("Peers boot hash did not match");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* This is the peer we expected, save away the address and derive the
|
|
* initial keys.
|
|
*/
|
|
memcpy(dpp->auth_addr, from, 6);
|
|
|
|
dpp->state = DPP_STATE_AUTHENTICATING;
|
|
|
|
if (!dpp_send_authenticate_request(dpp))
|
|
return;
|
|
|
|
/*
|
|
* Should we wait for an ACK then go offchannel?
|
|
*/
|
|
if (dpp->current_freq != dpp->new_freq)
|
|
dpp_start_offchannel(dpp, dpp->new_freq);
|
|
}
|
|
|
|
static void dpp_handle_frame(struct dpp_sm *dpp,
|
|
const struct mmpdu_header *frame,
|
|
const void *body, size_t body_len)
|
|
{
|
|
const uint8_t *ptr;
|
|
|
|
/*
|
|
* Both handlers offset by 8 bytes to reach the beginning of the DPP
|
|
* attributes. Easier checking this in one place, which also covers the
|
|
* frame type byte.
|
|
*/
|
|
if (body_len < 8)
|
|
return;
|
|
|
|
ptr = body + 7;
|
|
|
|
switch (*ptr) {
|
|
case DPP_FRAME_AUTHENTICATION_REQUEST:
|
|
authenticate_request(dpp, frame->address_2, body, body_len);
|
|
break;
|
|
case DPP_FRAME_AUTHENTICATION_RESPONSE:
|
|
authenticate_response(dpp, frame->address_2, body, body_len);
|
|
break;
|
|
case DPP_FRAME_AUTHENTICATION_CONFIRM:
|
|
authenticate_confirm(dpp, frame->address_2, body, body_len);
|
|
break;
|
|
case DPP_FRAME_CONFIGURATION_RESULT:
|
|
dpp_handle_config_result_frame(dpp, frame->address_2,
|
|
body, body_len);
|
|
break;
|
|
case DPP_FRAME_PRESENCE_ANNOUNCEMENT:
|
|
dpp_handle_presence_announcement(dpp, frame->address_2,
|
|
body, body_len);
|
|
break;
|
|
default:
|
|
l_debug("Unhandled DPP frame %u", *ptr);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static bool match_wdev(const void *a, const void *b)
|
|
{
|
|
const struct dpp_sm *dpp = a;
|
|
const uint64_t *wdev_id = b;
|
|
|
|
return *wdev_id == dpp->wdev_id;
|
|
}
|
|
|
|
static void dpp_frame_timeout(struct l_timeout *timeout, void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
|
|
l_timeout_remove(timeout);
|
|
dpp->retry_timeout = NULL;
|
|
|
|
/*
|
|
* ROC has not yet started (in between an ROC timeout and starting a
|
|
* new session), this will most likely result in the frame failing to
|
|
* send. Just bail out now and the roc_started callback will take care
|
|
* of sending this out.
|
|
*/
|
|
if (!dpp->roc_started)
|
|
return;
|
|
|
|
dpp_frame_retry(dpp);
|
|
}
|
|
|
|
static void dpp_mlme_notify(struct l_genl_msg *msg, void *user_data)
|
|
{
|
|
struct dpp_sm *dpp;
|
|
uint64_t wdev_id = 0;
|
|
uint64_t cookie = 0;
|
|
bool ack = false;
|
|
struct iovec iov;
|
|
uint8_t cmd = l_genl_msg_get_command(msg);
|
|
|
|
if (cmd != NL80211_CMD_FRAME_TX_STATUS)
|
|
return;
|
|
|
|
if (nl80211_parse_attrs(msg, NL80211_ATTR_WDEV, &wdev_id,
|
|
NL80211_ATTR_COOKIE, &cookie,
|
|
NL80211_ATTR_ACK, &ack,
|
|
NL80211_ATTR_FRAME, &iov,
|
|
NL80211_ATTR_UNSPEC) < 0)
|
|
return;
|
|
|
|
dpp = l_queue_find(dpp_list, match_wdev, &wdev_id);
|
|
if (!dpp)
|
|
return;
|
|
|
|
if (dpp->state <= DPP_STATE_PRESENCE)
|
|
return;
|
|
|
|
/*
|
|
* Only want to handle the no-ACK case. Re-transmitting an ACKed
|
|
* frame likely wont do any good, at least in the case of DPP.
|
|
*/
|
|
if (dpp->frame_cookie != cookie || ack)
|
|
return;
|
|
|
|
if (dpp->frame_retry > DPP_FRAME_MAX_RETRIES) {
|
|
dpp_reset(dpp);
|
|
return;
|
|
}
|
|
|
|
/* This should never happen */
|
|
if (L_WARN_ON(dpp->frame_pending))
|
|
return;
|
|
|
|
l_debug("No ACK from peer, re-transmitting in %us",
|
|
DPP_FRAME_RETRY_TIMEOUT);
|
|
|
|
dpp->frame_retry++;
|
|
|
|
dpp->frame_pending = l_memdup(iov.iov_base, iov.iov_len);
|
|
dpp->frame_size = iov.iov_len;
|
|
dpp->retry_timeout = l_timeout_create(DPP_FRAME_RETRY_TIMEOUT,
|
|
dpp_frame_timeout, dpp, NULL);
|
|
}
|
|
|
|
static void dpp_unicast_notify(struct l_genl_msg *msg, void *user_data)
|
|
{
|
|
struct dpp_sm *dpp;
|
|
const uint64_t *wdev_id = NULL;
|
|
struct l_genl_attr attr;
|
|
uint16_t type, len, frame_len;
|
|
const void *data;
|
|
const struct mmpdu_header *mpdu = NULL;
|
|
const uint8_t *body;
|
|
size_t body_len;
|
|
|
|
if (l_genl_msg_get_command(msg) != NL80211_CMD_FRAME)
|
|
return;
|
|
|
|
if (!l_genl_attr_init(&attr, msg))
|
|
return;
|
|
|
|
while (l_genl_attr_next(&attr, &type, &len, &data)) {
|
|
switch (type) {
|
|
case NL80211_ATTR_WDEV:
|
|
if (len != 8)
|
|
break;
|
|
|
|
wdev_id = data;
|
|
break;
|
|
|
|
case NL80211_ATTR_FRAME:
|
|
mpdu = mpdu_validate(data, len);
|
|
if (!mpdu) {
|
|
l_warn("Frame didn't validate as MMPDU");
|
|
return;
|
|
}
|
|
|
|
frame_len = len;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!wdev_id) {
|
|
l_warn("Bad wdev attribute");
|
|
return;
|
|
}
|
|
|
|
dpp = l_queue_find(dpp_list, match_wdev, wdev_id);
|
|
if (!dpp)
|
|
return;
|
|
|
|
if (!mpdu) {
|
|
l_warn("Missing frame data");
|
|
return;
|
|
}
|
|
|
|
body = mmpdu_body(mpdu);
|
|
body_len = (const uint8_t *) mpdu + frame_len - body;
|
|
|
|
if (body_len < sizeof(dpp_prefix) ||
|
|
memcmp(body, dpp_prefix, sizeof(dpp_prefix)) != 0)
|
|
return;
|
|
|
|
dpp_handle_frame(dpp, mpdu, body, body_len);
|
|
}
|
|
|
|
static void dpp_frame_watch_cb(struct l_genl_msg *msg, void *user_data)
|
|
{
|
|
if (l_genl_msg_get_error(msg) < 0)
|
|
l_error("Could not register frame watch type %04x: %i",
|
|
L_PTR_TO_UINT(user_data), l_genl_msg_get_error(msg));
|
|
}
|
|
|
|
/*
|
|
* Special case the frame watch which includes the presence frames since they
|
|
* require multicast support. This is only supported by ath9k, so adding
|
|
* general support to frame-xchg isn't desireable.
|
|
*/
|
|
static void dpp_frame_watch(struct dpp_sm *dpp, uint16_t frame_type,
|
|
const uint8_t *prefix, size_t prefix_len)
|
|
{
|
|
struct l_genl_msg *msg;
|
|
|
|
msg = l_genl_msg_new_sized(NL80211_CMD_REGISTER_FRAME, 32 + prefix_len);
|
|
|
|
l_genl_msg_append_attr(msg, NL80211_ATTR_WDEV, 8, &dpp->wdev_id);
|
|
l_genl_msg_append_attr(msg, NL80211_ATTR_FRAME_TYPE, 2, &frame_type);
|
|
l_genl_msg_append_attr(msg, NL80211_ATTR_FRAME_MATCH,
|
|
prefix_len, prefix);
|
|
if (dpp->mcast_support)
|
|
l_genl_msg_append_attr(msg, NL80211_ATTR_RECEIVE_MULTICAST,
|
|
0, NULL);
|
|
|
|
l_genl_family_send(nl80211, msg, dpp_frame_watch_cb,
|
|
L_UINT_TO_PTR(frame_type), NULL);
|
|
}
|
|
|
|
static void dpp_create(struct netdev *netdev)
|
|
{
|
|
struct l_dbus *dbus = dbus_get_bus();
|
|
struct dpp_sm *dpp = l_new(struct dpp_sm, 1);
|
|
uint8_t dpp_conf_response_prefix[] = { 0x04, 0x0b };
|
|
uint8_t dpp_conf_request_prefix[] = { 0x04, 0x0a };
|
|
|
|
dpp->netdev = netdev;
|
|
dpp->state = DPP_STATE_NOTHING;
|
|
dpp->wdev_id = netdev_get_wdev_id(netdev);
|
|
dpp->curve = l_ecc_curve_from_ike_group(19);
|
|
dpp->key_len = l_ecc_curve_get_scalar_bytes(dpp->curve);
|
|
dpp->nonce_len = dpp_nonce_len_from_key_len(dpp->key_len);
|
|
dpp->mcast_support = wiphy_has_ext_feature(
|
|
wiphy_find_by_wdev(dpp->wdev_id),
|
|
NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS);
|
|
|
|
l_ecdh_generate_key_pair(dpp->curve, &dpp->boot_private,
|
|
&dpp->boot_public);
|
|
|
|
dpp->own_asn1 = dpp_point_to_asn1(dpp->boot_public, &dpp->own_asn1_len);
|
|
|
|
dpp_hash(L_CHECKSUM_SHA256, dpp->own_boot_hash, 1,
|
|
dpp->own_asn1, dpp->own_asn1_len);
|
|
|
|
l_dbus_object_add_interface(dbus, netdev_get_path(netdev),
|
|
IWD_DPP_INTERFACE, dpp);
|
|
|
|
dpp_frame_watch(dpp, 0x00d0, dpp_prefix, sizeof(dpp_prefix));
|
|
|
|
frame_watch_add(netdev_get_wdev_id(netdev), 0, 0x00d0,
|
|
dpp_conf_response_prefix,
|
|
sizeof(dpp_conf_response_prefix),
|
|
dpp_handle_config_response_frame, dpp, NULL);
|
|
frame_watch_add(netdev_get_wdev_id(netdev), 0, 0x00d0,
|
|
dpp_conf_request_prefix,
|
|
sizeof(dpp_conf_request_prefix),
|
|
dpp_handle_config_request_frame, dpp, NULL);
|
|
|
|
l_queue_push_tail(dpp_list, dpp);
|
|
}
|
|
|
|
static void dpp_netdev_watch(struct netdev *netdev,
|
|
enum netdev_watch_event event, void *userdata)
|
|
{
|
|
switch (event) {
|
|
case NETDEV_WATCH_EVENT_NEW:
|
|
case NETDEV_WATCH_EVENT_UP:
|
|
if (netdev_get_iftype(netdev) == NETDEV_IFTYPE_STATION &&
|
|
netdev_get_is_up(netdev))
|
|
dpp_create(netdev);
|
|
break;
|
|
case NETDEV_WATCH_EVENT_DEL:
|
|
case NETDEV_WATCH_EVENT_DOWN:
|
|
l_dbus_object_remove_interface(dbus_get_bus(),
|
|
netdev_get_path(netdev),
|
|
IWD_DPP_INTERFACE);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* EasyConnect 2.0 - 6.2.2
|
|
*/
|
|
static uint32_t *dpp_add_default_channels(struct dpp_sm *dpp, size_t *len_out)
|
|
{
|
|
struct wiphy *wiphy = wiphy_find_by_wdev(
|
|
netdev_get_wdev_id(dpp->netdev));
|
|
const struct scan_freq_set *list = wiphy_get_supported_freqs(wiphy);
|
|
uint32_t freq;
|
|
|
|
if (!dpp->presence_list)
|
|
dpp->presence_list = scan_freq_set_new();
|
|
|
|
scan_freq_set_add(dpp->presence_list, band_channel_to_freq(6,
|
|
BAND_FREQ_2_4_GHZ));
|
|
/*
|
|
* "5 GHz: Channel 44 (5.220 GHz) if local regulations permit operation
|
|
* only in the 5.150 - 5.250 GHz band and Channel 149 (5.745 GHz)
|
|
* otherwise"
|
|
*/
|
|
freq = band_channel_to_freq(149, BAND_FREQ_5_GHZ);
|
|
|
|
if (scan_freq_set_contains(list, freq))
|
|
scan_freq_set_add(dpp->presence_list, freq);
|
|
else
|
|
scan_freq_set_add(dpp->presence_list,
|
|
band_channel_to_freq(44, BAND_FREQ_5_GHZ));
|
|
|
|
/* TODO: 60GHz: Channel 2 */
|
|
|
|
return scan_freq_set_to_fixed_array(dpp->presence_list, len_out);
|
|
}
|
|
|
|
/*
|
|
* TODO: There is an entire procedure defined in the spec where you increase
|
|
* the ROC timeout with each unsuccessful iteration of channels, wait on channel
|
|
* for long periods of time etc. Due to offchannel issues in the kernel this
|
|
* procedure is not being fully implemented. In reality doing this would result
|
|
* in quite terrible DPP performance anyways.
|
|
*/
|
|
static void dpp_start_presence(struct dpp_sm *dpp, uint32_t *limit_freqs,
|
|
size_t limit_len)
|
|
{
|
|
uint32_t max_roc = wiphy_get_max_roc_duration(
|
|
wiphy_find_by_wdev(dpp->wdev_id));
|
|
|
|
if (2000 < max_roc)
|
|
max_roc = 2000;
|
|
|
|
if (limit_freqs) {
|
|
dpp->freqs = l_memdup(limit_freqs, sizeof(uint32_t) * limit_len);
|
|
dpp->freqs_len = limit_len;
|
|
} else
|
|
dpp->freqs = dpp_add_default_channels(dpp, &dpp->freqs_len);
|
|
|
|
dpp->dwell = max_roc;
|
|
dpp->freqs_idx = 0;
|
|
dpp->current_freq = dpp->freqs[0];
|
|
|
|
dpp_start_offchannel(dpp, dpp->current_freq);
|
|
}
|
|
|
|
static struct l_dbus_message *dpp_dbus_start_enrollee(struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
uint32_t freq = band_channel_to_freq(6, BAND_FREQ_2_4_GHZ);
|
|
struct station *station = station_find(netdev_get_ifindex(dpp->netdev));
|
|
|
|
if (dpp->state != DPP_STATE_NOTHING)
|
|
return dbus_error_busy(message);
|
|
|
|
/*
|
|
* Station isn't actually required for DPP itself, although this will
|
|
* prevent connecting to the network once configured.
|
|
*/
|
|
if (station && station_get_connected_network(station)) {
|
|
l_warn("cannot be enrollee while connected, please disconnect");
|
|
return dbus_error_busy(message);
|
|
} else if (!station)
|
|
l_debug("No station device, continuing anyways...");
|
|
|
|
dpp->uri = dpp_generate_uri(dpp->own_asn1, dpp->own_asn1_len, 2,
|
|
netdev_get_address(dpp->netdev), &freq,
|
|
1, NULL, NULL);
|
|
|
|
dpp->state = DPP_STATE_PRESENCE;
|
|
dpp->role = DPP_CAPABILITY_ENROLLEE;
|
|
|
|
l_ecdh_generate_key_pair(dpp->curve, &dpp->proto_private,
|
|
&dpp->own_proto_public);
|
|
|
|
l_debug("DPP Start Enrollee: %s", dpp->uri);
|
|
|
|
dpp->pending = l_dbus_message_ref(message);
|
|
|
|
/*
|
|
* Going off spec here. Select a single channel to send presence
|
|
* announcements on. This will be advertised in the URI. The full
|
|
* presence procedure can be implemented if it is ever needed.
|
|
*/
|
|
dpp_start_presence(dpp, &freq, 1);
|
|
|
|
scan_periodic_stop(dpp->wdev_id);
|
|
|
|
dpp_property_changed_notify(dpp);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Set up the configurator for an initiator role. The configurator
|
|
* will go offchannel to frequencies advertised by the enrollees URI or,
|
|
* if no channels are provided, use a default channel list.
|
|
*/
|
|
static bool dpp_configurator_start_presence(struct dpp_sm *dpp, const char *uri)
|
|
{
|
|
_auto_(l_free) uint32_t *freqs = NULL;
|
|
size_t freqs_len = 0;
|
|
struct dpp_uri_info *info;
|
|
|
|
info = dpp_parse_uri(uri);
|
|
if (!info)
|
|
return false;
|
|
|
|
/*
|
|
* Very few drivers actually support registration of multicast frames.
|
|
* This renders the presence procedure impossible on most drivers.
|
|
* But not all is lost. If the URI contains the MAC and channel
|
|
* info we an start going through channels sending auth requests which
|
|
* is basically DPP 1.0. Otherwise DPP cannot start.
|
|
*/
|
|
if (!dpp->mcast_support &&
|
|
(l_memeqzero(info->mac, 6) || !info->freqs)) {
|
|
l_error("No multicast registration support, URI must contain "
|
|
"MAC and channel information");
|
|
dpp_free_uri_info(info);
|
|
return false;
|
|
}
|
|
|
|
if (!l_memeqzero(info->mac, 6))
|
|
memcpy(dpp->auth_addr, info->mac, 6);
|
|
|
|
if (info->freqs)
|
|
freqs = scan_freq_set_to_fixed_array(info->freqs, &freqs_len);
|
|
|
|
dpp->peer_boot_public = l_ecc_point_clone(info->boot_public);
|
|
dpp->peer_asn1 = dpp_point_to_asn1(info->boot_public,
|
|
&dpp->peer_asn1_len);
|
|
|
|
dpp_free_uri_info(info);
|
|
|
|
if (!dpp->peer_asn1) {
|
|
l_debug("Peer boot key did not convert to asn1");
|
|
return false;
|
|
}
|
|
|
|
dpp_hash(L_CHECKSUM_SHA256, dpp->peer_boot_hash, 1, dpp->peer_asn1,
|
|
dpp->peer_asn1_len);
|
|
|
|
dpp_start_presence(dpp, freqs, freqs_len);
|
|
|
|
return true;
|
|
}
|
|
|
|
static struct l_dbus_message *dpp_start_configurator_common(
|
|
struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data,
|
|
bool responder)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
struct l_dbus_message *reply;
|
|
struct station *station = station_find(netdev_get_ifindex(dpp->netdev));
|
|
struct scan_bss *bss;
|
|
struct network *network;
|
|
struct l_settings *settings;
|
|
struct handshake_state *hs = netdev_get_handshake(dpp->netdev);
|
|
const char *uri;
|
|
|
|
/*
|
|
* For now limit the configurator to only configuring enrollees to the
|
|
* currently connected network.
|
|
*/
|
|
if (!station)
|
|
return dbus_error_not_available(message);
|
|
|
|
bss = station_get_connected_bss(station);
|
|
network = station_get_connected_network(station);
|
|
if (!bss || !network)
|
|
return dbus_error_not_connected(message);
|
|
|
|
settings = network_get_settings(network);
|
|
if (!settings)
|
|
return dbus_error_not_configured(message);
|
|
|
|
if (network_get_security(network) != SECURITY_PSK)
|
|
return dbus_error_not_supported(message);
|
|
|
|
if (dpp->state != DPP_STATE_NOTHING)
|
|
return dbus_error_busy(message);
|
|
|
|
l_ecdh_generate_key_pair(dpp->curve, &dpp->proto_private,
|
|
&dpp->own_proto_public);
|
|
|
|
dpp->state = DPP_STATE_PRESENCE;
|
|
|
|
if (!responder) {
|
|
if (!l_dbus_message_get_arguments(message, "s", &uri))
|
|
return dbus_error_invalid_args(message);
|
|
|
|
if (!dpp_configurator_start_presence(dpp, uri))
|
|
return dbus_error_invalid_args(message);
|
|
|
|
/* Since we have the peer's URI generate the keys now */
|
|
l_getrandom(dpp->i_nonce, dpp->nonce_len);
|
|
|
|
dpp->m = dpp_derive_k1(dpp->peer_boot_public,
|
|
dpp->proto_private, dpp->k1);
|
|
|
|
if (!dpp->mcast_support)
|
|
dpp->state = DPP_STATE_AUTHENTICATING;
|
|
|
|
dpp->new_freq = bss->frequency;
|
|
} else
|
|
dpp->current_freq = bss->frequency;
|
|
|
|
dpp->uri = dpp_generate_uri(dpp->own_asn1, dpp->own_asn1_len, 2,
|
|
netdev_get_address(dpp->netdev),
|
|
&bss->frequency, 1, NULL, NULL);
|
|
dpp->role = DPP_CAPABILITY_CONFIGURATOR;
|
|
dpp->config = dpp_configuration_new(settings,
|
|
network_get_ssid(network),
|
|
hs->akm_suite);
|
|
|
|
scan_periodic_stop(dpp->wdev_id);
|
|
|
|
dpp_property_changed_notify(dpp);
|
|
|
|
l_debug("DPP Start Configurator: %s", dpp->uri);
|
|
|
|
reply = l_dbus_message_new_method_return(message);
|
|
|
|
l_dbus_message_set_arguments(reply, "s", dpp->uri);
|
|
|
|
return reply;
|
|
}
|
|
|
|
static struct l_dbus_message *dpp_dbus_start_configurator(struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
return dpp_start_configurator_common(dbus, message, user_data, true);
|
|
}
|
|
|
|
static struct l_dbus_message *dpp_dbus_configure_enrollee(struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
return dpp_start_configurator_common(dbus, message, user_data, false);
|
|
}
|
|
|
|
static struct l_dbus_message *dpp_dbus_stop(struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
|
|
dpp_reset(dpp);
|
|
|
|
return l_dbus_message_new_method_return(message);
|
|
}
|
|
|
|
static void dpp_setup_interface(struct l_dbus_interface *interface)
|
|
{
|
|
l_dbus_interface_method(interface, "StartEnrollee", 0,
|
|
dpp_dbus_start_enrollee, "s", "", "uri");
|
|
l_dbus_interface_method(interface, "StartConfigurator", 0,
|
|
dpp_dbus_start_configurator, "s", "", "uri");
|
|
l_dbus_interface_method(interface, "ConfigureEnrollee", 0,
|
|
dpp_dbus_configure_enrollee, "", "s", "uri");
|
|
l_dbus_interface_method(interface, "Stop", 0,
|
|
dpp_dbus_stop, "", "");
|
|
|
|
l_dbus_interface_property(interface, "Started", 0, "b", dpp_get_started,
|
|
NULL);
|
|
l_dbus_interface_property(interface, "Role", 0, "s", dpp_get_role,
|
|
NULL);
|
|
l_dbus_interface_property(interface, "URI", 0, "s", dpp_get_uri, NULL);
|
|
}
|
|
|
|
static void dpp_destroy_interface(void *user_data)
|
|
{
|
|
struct dpp_sm *dpp = user_data;
|
|
|
|
l_queue_remove(dpp_list, dpp);
|
|
|
|
dpp_free(dpp);
|
|
}
|
|
|
|
static int dpp_init(void)
|
|
{
|
|
nl80211 = l_genl_family_new(iwd_get_genl(), NL80211_GENL_NAME);
|
|
if (!nl80211) {
|
|
l_error("Failed to obtain nl80211");
|
|
return -EIO;
|
|
}
|
|
|
|
netdev_watch = netdev_watch_add(dpp_netdev_watch, NULL, NULL);
|
|
|
|
l_dbus_register_interface(dbus_get_bus(), IWD_DPP_INTERFACE,
|
|
dpp_setup_interface,
|
|
dpp_destroy_interface, false);
|
|
|
|
mlme_watch = l_genl_family_register(nl80211, "mlme", dpp_mlme_notify,
|
|
NULL, NULL);
|
|
|
|
unicast_watch = l_genl_add_unicast_watch(iwd_get_genl(),
|
|
NL80211_GENL_NAME,
|
|
dpp_unicast_notify,
|
|
NULL, NULL);
|
|
|
|
dpp_list = l_queue_new();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void dpp_exit(void)
|
|
{
|
|
l_debug("");
|
|
|
|
l_dbus_unregister_interface(dbus_get_bus(), IWD_DPP_INTERFACE);
|
|
|
|
netdev_watch_remove(netdev_watch);
|
|
|
|
l_genl_remove_unicast_watch(iwd_get_genl(), unicast_watch);
|
|
|
|
l_genl_family_unregister(nl80211, mlme_watch);
|
|
mlme_watch = 0;
|
|
|
|
l_genl_family_free(nl80211);
|
|
nl80211 = NULL;
|
|
|
|
l_queue_destroy(dpp_list, (l_queue_destroy_func_t) dpp_free);
|
|
}
|
|
|
|
IWD_MODULE(dpp, dpp_init, dpp_exit);
|
|
IWD_MODULE_DEPENDS(dpp, netdev);
|