29ab69e4b0
Add limit on number of failed attempts that could have used PKEX code. If the limit (5) is reached, drop the PKEX state (including the code) and report this on the control interface to indicate that a new code needs to be entered due to possible attack. Signed-off-by: Jouni Malinen <jouni@qca.qualcomm.com>
2163 lines
57 KiB
C
2163 lines
57 KiB
C
/*
|
|
* wpa_supplicant - DPP
|
|
* Copyright (c) 2017, Qualcomm Atheros, Inc.
|
|
*
|
|
* This software may be distributed under the terms of the BSD license.
|
|
* See README for more details.
|
|
*/
|
|
|
|
#include "utils/includes.h"
|
|
|
|
#include "utils/common.h"
|
|
#include "utils/eloop.h"
|
|
#include "common/dpp.h"
|
|
#include "common/gas.h"
|
|
#include "common/gas_server.h"
|
|
#include "rsn_supp/wpa.h"
|
|
#include "rsn_supp/pmksa_cache.h"
|
|
#include "wpa_supplicant_i.h"
|
|
#include "config.h"
|
|
#include "driver_i.h"
|
|
#include "offchannel.h"
|
|
#include "gas_query.h"
|
|
#include "bss.h"
|
|
#include "scan.h"
|
|
#include "notify.h"
|
|
#include "dpp_supplicant.h"
|
|
|
|
|
|
static int wpas_dpp_listen_start(struct wpa_supplicant *wpa_s,
|
|
unsigned int freq);
|
|
static void wpas_dpp_reply_wait_timeout(void *eloop_ctx, void *timeout_ctx);
|
|
static void wpas_dpp_auth_success(struct wpa_supplicant *wpa_s, int initiator);
|
|
static void wpas_dpp_tx_status(struct wpa_supplicant *wpa_s,
|
|
unsigned int freq, const u8 *dst,
|
|
const u8 *src, const u8 *bssid,
|
|
const u8 *data, size_t data_len,
|
|
enum offchannel_send_action_result result);
|
|
|
|
static const u8 broadcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
|
|
|
/* Use a hardcoded Transaction ID 1 in Peer Discovery frames since there is only
|
|
* a single transaction in progress at any point in time. */
|
|
static const u8 TRANSACTION_ID = 1;
|
|
|
|
|
|
static struct dpp_configurator *
|
|
dpp_configurator_get_id(struct wpa_supplicant *wpa_s, unsigned int id)
|
|
{
|
|
struct dpp_configurator *conf;
|
|
|
|
dl_list_for_each(conf, &wpa_s->dpp_configurator,
|
|
struct dpp_configurator, list) {
|
|
if (conf->id == id)
|
|
return conf;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static unsigned int wpas_dpp_next_id(struct wpa_supplicant *wpa_s)
|
|
{
|
|
struct dpp_bootstrap_info *bi;
|
|
unsigned int max_id = 0;
|
|
|
|
dl_list_for_each(bi, &wpa_s->dpp_bootstrap, struct dpp_bootstrap_info,
|
|
list) {
|
|
if (bi->id > max_id)
|
|
max_id = bi->id;
|
|
}
|
|
return max_id + 1;
|
|
}
|
|
|
|
|
|
/**
|
|
* wpas_dpp_qr_code - Parse and add DPP bootstrapping info from a QR Code
|
|
* @wpa_s: Pointer to wpa_supplicant data
|
|
* @cmd: DPP URI read from a QR Code
|
|
* Returns: Identifier of the stored info or -1 on failure
|
|
*/
|
|
int wpas_dpp_qr_code(struct wpa_supplicant *wpa_s, const char *cmd)
|
|
{
|
|
struct dpp_bootstrap_info *bi;
|
|
struct dpp_authentication *auth = wpa_s->dpp_auth;
|
|
|
|
bi = dpp_parse_qr_code(cmd);
|
|
if (!bi)
|
|
return -1;
|
|
|
|
bi->id = wpas_dpp_next_id(wpa_s);
|
|
dl_list_add(&wpa_s->dpp_bootstrap, &bi->list);
|
|
|
|
if (auth && auth->response_pending &&
|
|
dpp_notify_new_qr_code(auth, bi) == 1) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Sending out pending authentication response");
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR
|
|
" freq=%u type=%d",
|
|
MAC2STR(auth->peer_mac_addr), auth->curr_freq,
|
|
DPP_PA_AUTHENTICATION_RESP);
|
|
offchannel_send_action(wpa_s, auth->curr_freq,
|
|
auth->peer_mac_addr, wpa_s->own_addr,
|
|
broadcast,
|
|
wpabuf_head(auth->resp_msg),
|
|
wpabuf_len(auth->resp_msg),
|
|
500, wpas_dpp_tx_status, 0);
|
|
}
|
|
|
|
return bi->id;
|
|
}
|
|
|
|
|
|
static char * get_param(const char *cmd, const char *param)
|
|
{
|
|
const char *pos, *end;
|
|
char *val;
|
|
size_t len;
|
|
|
|
pos = os_strstr(cmd, param);
|
|
if (!pos)
|
|
return NULL;
|
|
|
|
pos += os_strlen(param);
|
|
end = os_strchr(pos, ' ');
|
|
if (end)
|
|
len = end - pos;
|
|
else
|
|
len = os_strlen(pos);
|
|
val = os_malloc(len + 1);
|
|
if (!val)
|
|
return NULL;
|
|
os_memcpy(val, pos, len);
|
|
val[len] = '\0';
|
|
return val;
|
|
}
|
|
|
|
|
|
int wpas_dpp_bootstrap_gen(struct wpa_supplicant *wpa_s, const char *cmd)
|
|
{
|
|
char *chan = NULL, *mac = NULL, *info = NULL, *pk = NULL, *curve = NULL;
|
|
char *key = NULL;
|
|
u8 *privkey = NULL;
|
|
size_t privkey_len = 0;
|
|
size_t len;
|
|
int ret = -1;
|
|
struct dpp_bootstrap_info *bi;
|
|
|
|
bi = os_zalloc(sizeof(*bi));
|
|
if (!bi)
|
|
goto fail;
|
|
|
|
if (os_strstr(cmd, "type=qrcode"))
|
|
bi->type = DPP_BOOTSTRAP_QR_CODE;
|
|
else if (os_strstr(cmd, "type=pkex"))
|
|
bi->type = DPP_BOOTSTRAP_PKEX;
|
|
else
|
|
goto fail;
|
|
|
|
chan = get_param(cmd, " chan=");
|
|
mac = get_param(cmd, " mac=");
|
|
info = get_param(cmd, " info=");
|
|
curve = get_param(cmd, " curve=");
|
|
key = get_param(cmd, " key=");
|
|
|
|
if (key) {
|
|
privkey_len = os_strlen(key) / 2;
|
|
privkey = os_malloc(privkey_len);
|
|
if (!privkey ||
|
|
hexstr2bin(key, privkey, privkey_len) < 0)
|
|
goto fail;
|
|
}
|
|
|
|
pk = dpp_keygen(bi, curve, privkey, privkey_len);
|
|
if (!pk)
|
|
goto fail;
|
|
|
|
len = 4; /* "DPP:" */
|
|
if (chan) {
|
|
if (dpp_parse_uri_chan_list(bi, chan) < 0)
|
|
goto fail;
|
|
len += 3 + os_strlen(chan); /* C:...; */
|
|
}
|
|
if (mac) {
|
|
if (dpp_parse_uri_mac(bi, mac) < 0)
|
|
goto fail;
|
|
len += 3 + os_strlen(mac); /* M:...; */
|
|
}
|
|
if (info) {
|
|
if (dpp_parse_uri_info(bi, info) < 0)
|
|
goto fail;
|
|
len += 3 + os_strlen(info); /* I:...; */
|
|
}
|
|
len += 4 + os_strlen(pk);
|
|
bi->uri = os_malloc(len + 1);
|
|
if (!bi->uri)
|
|
goto fail;
|
|
os_snprintf(bi->uri, len + 1, "DPP:%s%s%s%s%s%s%s%s%sK:%s;;",
|
|
chan ? "C:" : "", chan ? chan : "", chan ? ";" : "",
|
|
mac ? "M:" : "", mac ? mac : "", mac ? ";" : "",
|
|
info ? "I:" : "", info ? info : "", info ? ";" : "",
|
|
pk);
|
|
bi->id = wpas_dpp_next_id(wpa_s);
|
|
dl_list_add(&wpa_s->dpp_bootstrap, &bi->list);
|
|
ret = bi->id;
|
|
bi = NULL;
|
|
fail:
|
|
os_free(curve);
|
|
os_free(pk);
|
|
os_free(chan);
|
|
os_free(mac);
|
|
os_free(info);
|
|
str_clear_free(key);
|
|
bin_clear_free(privkey, privkey_len);
|
|
dpp_bootstrap_info_free(bi);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static struct dpp_bootstrap_info *
|
|
dpp_bootstrap_get_id(struct wpa_supplicant *wpa_s, unsigned int id)
|
|
{
|
|
struct dpp_bootstrap_info *bi;
|
|
|
|
dl_list_for_each(bi, &wpa_s->dpp_bootstrap, struct dpp_bootstrap_info,
|
|
list) {
|
|
if (bi->id == id)
|
|
return bi;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static int dpp_bootstrap_del(struct wpa_supplicant *wpa_s, unsigned int id)
|
|
{
|
|
struct dpp_bootstrap_info *bi, *tmp;
|
|
int found = 0;
|
|
|
|
dl_list_for_each_safe(bi, tmp, &wpa_s->dpp_bootstrap,
|
|
struct dpp_bootstrap_info, list) {
|
|
if (id && bi->id != id)
|
|
continue;
|
|
found = 1;
|
|
dl_list_del(&bi->list);
|
|
dpp_bootstrap_info_free(bi);
|
|
}
|
|
|
|
if (id == 0)
|
|
return 0; /* flush succeeds regardless of entries found */
|
|
return found ? 0 : -1;
|
|
}
|
|
|
|
|
|
int wpas_dpp_bootstrap_remove(struct wpa_supplicant *wpa_s, const char *id)
|
|
{
|
|
unsigned int id_val;
|
|
|
|
if (os_strcmp(id, "*") == 0) {
|
|
id_val = 0;
|
|
} else {
|
|
id_val = atoi(id);
|
|
if (id_val == 0)
|
|
return -1;
|
|
}
|
|
|
|
return dpp_bootstrap_del(wpa_s, id_val);
|
|
}
|
|
|
|
|
|
const char * wpas_dpp_bootstrap_get_uri(struct wpa_supplicant *wpa_s,
|
|
unsigned int id)
|
|
{
|
|
struct dpp_bootstrap_info *bi;
|
|
|
|
bi = dpp_bootstrap_get_id(wpa_s, id);
|
|
if (!bi)
|
|
return NULL;
|
|
return bi->uri;
|
|
}
|
|
|
|
|
|
int wpas_dpp_bootstrap_info(struct wpa_supplicant *wpa_s, int id,
|
|
char *reply, int reply_size)
|
|
{
|
|
struct dpp_bootstrap_info *bi;
|
|
|
|
bi = dpp_bootstrap_get_id(wpa_s, id);
|
|
if (!bi)
|
|
return -1;
|
|
return os_snprintf(reply, reply_size, "type=%s\n"
|
|
"mac_addr=" MACSTR "\n"
|
|
"info=%s\n"
|
|
"num_freq=%u\n"
|
|
"curve=%s\n",
|
|
dpp_bootstrap_type_txt(bi->type),
|
|
MAC2STR(bi->mac_addr),
|
|
bi->info ? bi->info : "",
|
|
bi->num_freq,
|
|
bi->curve->name);
|
|
}
|
|
|
|
|
|
static void wpas_dpp_tx_status(struct wpa_supplicant *wpa_s,
|
|
unsigned int freq, const u8 *dst,
|
|
const u8 *src, const u8 *bssid,
|
|
const u8 *data, size_t data_len,
|
|
enum offchannel_send_action_result result)
|
|
{
|
|
const char *res_txt;
|
|
|
|
res_txt = result == OFFCHANNEL_SEND_ACTION_SUCCESS ? "SUCCESS" :
|
|
(result == OFFCHANNEL_SEND_ACTION_NO_ACK ? "no-ACK" :
|
|
"FAILED");
|
|
wpa_printf(MSG_DEBUG, "DPP: TX status: freq=%u dst=" MACSTR
|
|
" result=%s", freq, MAC2STR(dst), res_txt);
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR
|
|
" freq=%u result=%s", MAC2STR(dst), freq, res_txt);
|
|
|
|
if (!wpa_s->dpp_auth) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Ignore TX status since there is no ongoing authentication exchange");
|
|
return;
|
|
}
|
|
|
|
if (wpa_s->dpp_auth->remove_on_tx_status) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Terminate authentication exchange due to an earlier error");
|
|
eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
|
|
offchannel_send_action_done(wpa_s);
|
|
dpp_auth_deinit(wpa_s->dpp_auth);
|
|
wpa_s->dpp_auth = NULL;
|
|
return;
|
|
}
|
|
|
|
if (wpa_s->dpp_auth_ok_on_ack)
|
|
wpas_dpp_auth_success(wpa_s, 1);
|
|
|
|
if (!is_broadcast_ether_addr(dst) &&
|
|
result != OFFCHANNEL_SEND_ACTION_SUCCESS) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Unicast DPP Action frame was not ACKed");
|
|
/* TODO: In case of DPP Authentication Request frame, move to
|
|
* the next channel immediately */
|
|
}
|
|
|
|
if (!wpa_s->dpp_auth_ok_on_ack && wpa_s->dpp_auth->neg_freq > 0 &&
|
|
wpa_s->dpp_auth->curr_freq != wpa_s->dpp_auth->neg_freq) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Move from curr_freq %u MHz to neg_freq %u MHz for response",
|
|
wpa_s->dpp_auth->curr_freq,
|
|
wpa_s->dpp_auth->neg_freq);
|
|
offchannel_send_action_done(wpa_s);
|
|
wpas_dpp_listen_start(wpa_s, wpa_s->dpp_auth->neg_freq);
|
|
}
|
|
}
|
|
|
|
|
|
static void wpas_dpp_reply_wait_timeout(void *eloop_ctx, void *timeout_ctx)
|
|
{
|
|
struct wpa_supplicant *wpa_s = eloop_ctx;
|
|
unsigned int freq;
|
|
|
|
if (!wpa_s->dpp_auth)
|
|
return;
|
|
freq = wpa_s->dpp_auth->curr_freq;
|
|
if (wpa_s->dpp_auth->neg_freq > 0)
|
|
freq = wpa_s->dpp_auth->neg_freq;
|
|
wpa_printf(MSG_DEBUG, "DPP: Continue reply wait on channel %u MHz",
|
|
freq);
|
|
wpas_dpp_listen_start(wpa_s, freq);
|
|
}
|
|
|
|
|
|
static void wpas_dpp_set_testing_options(struct wpa_supplicant *wpa_s,
|
|
struct dpp_authentication *auth)
|
|
{
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
if (wpa_s->dpp_config_obj_override)
|
|
auth->config_obj_override =
|
|
os_strdup(wpa_s->dpp_config_obj_override);
|
|
if (wpa_s->dpp_discovery_override)
|
|
auth->discovery_override =
|
|
os_strdup(wpa_s->dpp_discovery_override);
|
|
if (wpa_s->dpp_groups_override)
|
|
auth->groups_override =
|
|
os_strdup(wpa_s->dpp_groups_override);
|
|
auth->ignore_netaccesskey_mismatch =
|
|
wpa_s->dpp_ignore_netaccesskey_mismatch;
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
|
}
|
|
|
|
|
|
static void wpas_dpp_set_configurator(struct wpa_supplicant *wpa_s,
|
|
struct dpp_authentication *auth,
|
|
const char *cmd)
|
|
{
|
|
const char *pos, *end;
|
|
struct dpp_configuration *conf_sta = NULL, *conf_ap = NULL;
|
|
struct dpp_configurator *conf = NULL;
|
|
u8 ssid[32] = { "test" };
|
|
size_t ssid_len = 4;
|
|
char pass[64] = { };
|
|
size_t pass_len = 0;
|
|
u8 psk[PMK_LEN];
|
|
int psk_set = 0;
|
|
|
|
if (!cmd)
|
|
return;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Set configurator parameters: %s", cmd);
|
|
pos = os_strstr(cmd, " ssid=");
|
|
if (pos) {
|
|
pos += 6;
|
|
end = os_strchr(pos, ' ');
|
|
ssid_len = end ? (size_t) (end - pos) : os_strlen(pos);
|
|
ssid_len /= 2;
|
|
if (ssid_len > sizeof(ssid) ||
|
|
hexstr2bin(pos, ssid, ssid_len) < 0)
|
|
goto fail;
|
|
}
|
|
|
|
pos = os_strstr(cmd, " pass=");
|
|
if (pos) {
|
|
pos += 6;
|
|
end = os_strchr(pos, ' ');
|
|
pass_len = end ? (size_t) (end - pos) : os_strlen(pos);
|
|
pass_len /= 2;
|
|
if (pass_len > sizeof(pass) - 1 || pass_len < 8 ||
|
|
hexstr2bin(pos, (u8 *) pass, pass_len) < 0)
|
|
goto fail;
|
|
}
|
|
|
|
pos = os_strstr(cmd, " psk=");
|
|
if (pos) {
|
|
pos += 5;
|
|
if (hexstr2bin(pos, psk, PMK_LEN) < 0)
|
|
goto fail;
|
|
psk_set = 1;
|
|
}
|
|
|
|
if (os_strstr(cmd, " conf=sta-")) {
|
|
conf_sta = os_zalloc(sizeof(struct dpp_configuration));
|
|
if (!conf_sta)
|
|
goto fail;
|
|
os_memcpy(conf_sta->ssid, ssid, ssid_len);
|
|
conf_sta->ssid_len = ssid_len;
|
|
if (os_strstr(cmd, " conf=sta-psk")) {
|
|
conf_sta->dpp = 0;
|
|
if (psk_set) {
|
|
os_memcpy(conf_sta->psk, psk, PMK_LEN);
|
|
} else {
|
|
conf_sta->passphrase = os_strdup(pass);
|
|
if (!conf_sta->passphrase)
|
|
goto fail;
|
|
}
|
|
} else if (os_strstr(cmd, " conf=sta-dpp")) {
|
|
conf_sta->dpp = 1;
|
|
} else {
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
if (os_strstr(cmd, " conf=ap-")) {
|
|
conf_ap = os_zalloc(sizeof(struct dpp_configuration));
|
|
if (!conf_ap)
|
|
goto fail;
|
|
os_memcpy(conf_ap->ssid, ssid, ssid_len);
|
|
conf_ap->ssid_len = ssid_len;
|
|
if (os_strstr(cmd, " conf=ap-psk")) {
|
|
conf_ap->dpp = 0;
|
|
if (psk_set) {
|
|
os_memcpy(conf_ap->psk, psk, PMK_LEN);
|
|
} else {
|
|
conf_ap->passphrase = os_strdup(pass);
|
|
if (!conf_ap->passphrase)
|
|
goto fail;
|
|
}
|
|
} else if (os_strstr(cmd, " conf=ap-dpp")) {
|
|
conf_ap->dpp = 1;
|
|
} else {
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
pos = os_strstr(cmd, " expiry=");
|
|
if (pos) {
|
|
long int val;
|
|
|
|
pos += 8;
|
|
val = strtol(pos, NULL, 0);
|
|
if (val <= 0)
|
|
goto fail;
|
|
if (conf_sta)
|
|
conf_sta->netaccesskey_expiry = val;
|
|
if (conf_ap)
|
|
conf_ap->netaccesskey_expiry = val;
|
|
}
|
|
|
|
pos = os_strstr(cmd, " configurator=");
|
|
if (pos) {
|
|
pos += 14;
|
|
conf = dpp_configurator_get_id(wpa_s, atoi(pos));
|
|
if (!conf) {
|
|
wpa_printf(MSG_INFO,
|
|
"DPP: Could not find the specified configurator");
|
|
goto fail;
|
|
}
|
|
}
|
|
auth->conf_sta = conf_sta;
|
|
auth->conf_ap = conf_ap;
|
|
auth->conf = conf;
|
|
return;
|
|
|
|
fail:
|
|
wpa_printf(MSG_DEBUG, "DPP: Failed to set configurator parameters");
|
|
dpp_configuration_free(conf_sta);
|
|
dpp_configuration_free(conf_ap);
|
|
}
|
|
|
|
|
|
int wpas_dpp_auth_init(struct wpa_supplicant *wpa_s, const char *cmd)
|
|
{
|
|
const char *pos;
|
|
struct dpp_bootstrap_info *peer_bi, *own_bi = NULL;
|
|
const u8 *dst;
|
|
int res;
|
|
int configurator = 1;
|
|
unsigned int wait_time;
|
|
unsigned int neg_freq = 0;
|
|
|
|
wpa_s->dpp_gas_client = 0;
|
|
|
|
pos = os_strstr(cmd, " peer=");
|
|
if (!pos)
|
|
return -1;
|
|
pos += 6;
|
|
peer_bi = dpp_bootstrap_get_id(wpa_s, atoi(pos));
|
|
if (!peer_bi) {
|
|
wpa_printf(MSG_INFO,
|
|
"DPP: Could not find bootstrapping info for the identified peer");
|
|
return -1;
|
|
}
|
|
|
|
pos = os_strstr(cmd, " own=");
|
|
if (pos) {
|
|
pos += 5;
|
|
own_bi = dpp_bootstrap_get_id(wpa_s, atoi(pos));
|
|
if (!own_bi) {
|
|
wpa_printf(MSG_INFO,
|
|
"DPP: Could not find bootstrapping info for the identified local entry");
|
|
return -1;
|
|
}
|
|
|
|
if (peer_bi->curve != own_bi->curve) {
|
|
wpa_printf(MSG_INFO,
|
|
"DPP: Mismatching curves in bootstrapping info (peer=%s own=%s)",
|
|
peer_bi->curve->name, own_bi->curve->name);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
pos = os_strstr(cmd, " role=");
|
|
if (pos) {
|
|
pos += 6;
|
|
if (os_strncmp(pos, "configurator", 12) == 0)
|
|
configurator = 1;
|
|
else if (os_strncmp(pos, "enrollee", 8) == 0)
|
|
configurator = 0;
|
|
else
|
|
goto fail;
|
|
}
|
|
|
|
pos = os_strstr(cmd, " netrole=");
|
|
if (pos) {
|
|
pos += 9;
|
|
wpa_s->dpp_netrole_ap = os_strncmp(pos, "ap", 2) == 0;
|
|
}
|
|
|
|
pos = os_strstr(cmd, " neg_freq=");
|
|
if (pos)
|
|
neg_freq = atoi(pos + 10);
|
|
|
|
if (wpa_s->dpp_auth) {
|
|
eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
|
|
offchannel_send_action_done(wpa_s);
|
|
dpp_auth_deinit(wpa_s->dpp_auth);
|
|
}
|
|
wpa_s->dpp_auth = dpp_auth_init(wpa_s, peer_bi, own_bi, configurator,
|
|
neg_freq);
|
|
if (!wpa_s->dpp_auth)
|
|
goto fail;
|
|
wpas_dpp_set_testing_options(wpa_s, wpa_s->dpp_auth);
|
|
wpas_dpp_set_configurator(wpa_s, wpa_s->dpp_auth, cmd);
|
|
|
|
/* TODO: Support iteration over all frequencies and filtering of
|
|
* frequencies based on locally enabled channels that allow initiation
|
|
* of transmission. */
|
|
if (peer_bi->num_freq > 0)
|
|
wpa_s->dpp_auth->curr_freq = peer_bi->freq[0];
|
|
else
|
|
wpa_s->dpp_auth->curr_freq = 2412;
|
|
wpa_s->dpp_auth->neg_freq = neg_freq;
|
|
|
|
if (is_zero_ether_addr(peer_bi->mac_addr)) {
|
|
dst = broadcast;
|
|
} else {
|
|
dst = peer_bi->mac_addr;
|
|
os_memcpy(wpa_s->dpp_auth->peer_mac_addr, peer_bi->mac_addr,
|
|
ETH_ALEN);
|
|
}
|
|
wpa_s->dpp_auth_ok_on_ack = 0;
|
|
eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
|
|
wait_time = wpa_s->max_remain_on_chan;
|
|
if (wait_time > 2000)
|
|
wait_time = 2000;
|
|
eloop_register_timeout(wait_time / 1000, (wait_time % 1000) * 1000,
|
|
wpas_dpp_reply_wait_timeout,
|
|
wpa_s, NULL);
|
|
if (neg_freq > 0 && wpa_s->dpp_auth->curr_freq != neg_freq) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Initiate on curr_freq %u MHz and move to neg_freq %u MHz for response",
|
|
wpa_s->dpp_auth->curr_freq,
|
|
wpa_s->dpp_auth->neg_freq);
|
|
}
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
|
|
MAC2STR(dst), wpa_s->dpp_auth->curr_freq,
|
|
DPP_PA_AUTHENTICATION_REQ);
|
|
res = offchannel_send_action(wpa_s, wpa_s->dpp_auth->curr_freq,
|
|
dst, wpa_s->own_addr, broadcast,
|
|
wpabuf_head(wpa_s->dpp_auth->req_msg),
|
|
wpabuf_len(wpa_s->dpp_auth->req_msg),
|
|
wait_time, wpas_dpp_tx_status, 0);
|
|
|
|
return res;
|
|
fail:
|
|
return -1;
|
|
}
|
|
|
|
|
|
struct wpas_dpp_listen_work {
|
|
unsigned int freq;
|
|
unsigned int duration;
|
|
struct wpabuf *probe_resp_ie;
|
|
};
|
|
|
|
|
|
static void wpas_dpp_listen_work_free(struct wpas_dpp_listen_work *lwork)
|
|
{
|
|
if (!lwork)
|
|
return;
|
|
os_free(lwork);
|
|
}
|
|
|
|
|
|
static void wpas_dpp_listen_work_done(struct wpa_supplicant *wpa_s)
|
|
{
|
|
struct wpas_dpp_listen_work *lwork;
|
|
|
|
if (!wpa_s->dpp_listen_work)
|
|
return;
|
|
|
|
lwork = wpa_s->dpp_listen_work->ctx;
|
|
wpas_dpp_listen_work_free(lwork);
|
|
radio_work_done(wpa_s->dpp_listen_work);
|
|
wpa_s->dpp_listen_work = NULL;
|
|
}
|
|
|
|
|
|
static void dpp_start_listen_cb(struct wpa_radio_work *work, int deinit)
|
|
{
|
|
struct wpa_supplicant *wpa_s = work->wpa_s;
|
|
struct wpas_dpp_listen_work *lwork = work->ctx;
|
|
|
|
if (deinit) {
|
|
if (work->started) {
|
|
wpa_s->dpp_listen_work = NULL;
|
|
wpas_dpp_listen_stop(wpa_s);
|
|
}
|
|
wpas_dpp_listen_work_free(lwork);
|
|
return;
|
|
}
|
|
|
|
wpa_s->dpp_listen_work = work;
|
|
|
|
wpa_s->dpp_pending_listen_freq = lwork->freq;
|
|
|
|
if (wpa_drv_remain_on_channel(wpa_s, lwork->freq,
|
|
wpa_s->max_remain_on_chan) < 0) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Failed to request the driver to remain on channel (%u MHz) for listen",
|
|
lwork->freq);
|
|
wpas_dpp_listen_work_done(wpa_s);
|
|
wpa_s->dpp_pending_listen_freq = 0;
|
|
return;
|
|
}
|
|
wpa_s->off_channel_freq = 0;
|
|
wpa_s->roc_waiting_drv_freq = lwork->freq;
|
|
}
|
|
|
|
|
|
static int wpas_dpp_listen_start(struct wpa_supplicant *wpa_s,
|
|
unsigned int freq)
|
|
{
|
|
struct wpas_dpp_listen_work *lwork;
|
|
|
|
if (wpa_s->dpp_listen_work) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Reject start_listen since dpp_listen_work already exists");
|
|
return -1;
|
|
}
|
|
|
|
if (wpa_s->dpp_listen_freq)
|
|
wpas_dpp_listen_stop(wpa_s);
|
|
wpa_s->dpp_listen_freq = freq;
|
|
|
|
lwork = os_zalloc(sizeof(*lwork));
|
|
if (!lwork)
|
|
return -1;
|
|
lwork->freq = freq;
|
|
|
|
if (radio_add_work(wpa_s, freq, "dpp-listen", 0, dpp_start_listen_cb,
|
|
lwork) < 0) {
|
|
wpas_dpp_listen_work_free(lwork);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int wpas_dpp_listen(struct wpa_supplicant *wpa_s, const char *cmd)
|
|
{
|
|
int freq;
|
|
|
|
freq = atoi(cmd);
|
|
if (freq <= 0)
|
|
return -1;
|
|
|
|
if (os_strstr(cmd, " role=configurator"))
|
|
wpa_s->dpp_allowed_roles = DPP_CAPAB_CONFIGURATOR;
|
|
else if (os_strstr(cmd, " role=enrollee"))
|
|
wpa_s->dpp_allowed_roles = DPP_CAPAB_ENROLLEE;
|
|
else
|
|
wpa_s->dpp_allowed_roles = DPP_CAPAB_CONFIGURATOR |
|
|
DPP_CAPAB_ENROLLEE;
|
|
wpa_s->dpp_qr_mutual = os_strstr(cmd, " qr=mutual") != NULL;
|
|
wpa_s->dpp_netrole_ap = os_strstr(cmd, " netrole=ap") != NULL;
|
|
if (wpa_s->dpp_listen_freq == (unsigned int) freq) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Already listening on %u MHz",
|
|
freq);
|
|
return 0;
|
|
}
|
|
|
|
return wpas_dpp_listen_start(wpa_s, freq);
|
|
}
|
|
|
|
|
|
void wpas_dpp_listen_stop(struct wpa_supplicant *wpa_s)
|
|
{
|
|
if (!wpa_s->dpp_listen_freq)
|
|
return;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Stop listen on %u MHz",
|
|
wpa_s->dpp_listen_freq);
|
|
wpa_drv_cancel_remain_on_channel(wpa_s);
|
|
wpa_s->dpp_listen_freq = 0;
|
|
wpas_dpp_listen_work_done(wpa_s);
|
|
}
|
|
|
|
|
|
void wpas_dpp_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
|
|
unsigned int freq)
|
|
{
|
|
if (!wpa_s->dpp_listen_freq && !wpa_s->dpp_pending_listen_freq)
|
|
return;
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: remain-on-channel callback (off_channel_freq=%u dpp_pending_listen_freq=%d roc_waiting_drv_freq=%d freq=%u)",
|
|
wpa_s->off_channel_freq, wpa_s->dpp_pending_listen_freq,
|
|
wpa_s->roc_waiting_drv_freq, freq);
|
|
if (wpa_s->off_channel_freq &&
|
|
wpa_s->off_channel_freq == wpa_s->dpp_pending_listen_freq) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Listen on %u MHz started", freq);
|
|
wpa_s->dpp_pending_listen_freq = 0;
|
|
} else {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Ignore remain-on-channel callback (off_channel_freq=%u dpp_pending_listen_freq=%d freq=%u)",
|
|
wpa_s->off_channel_freq,
|
|
wpa_s->dpp_pending_listen_freq, freq);
|
|
}
|
|
}
|
|
|
|
|
|
void wpas_dpp_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
|
|
unsigned int freq)
|
|
{
|
|
wpas_dpp_listen_work_done(wpa_s);
|
|
|
|
if (wpa_s->dpp_auth && !wpa_s->dpp_gas_client) {
|
|
/* Continue listen with a new remain-on-channel */
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Continue wait on %u MHz for the ongoing DPP provisioning session",
|
|
wpa_s->dpp_auth->curr_freq);
|
|
wpas_dpp_listen_start(wpa_s, wpa_s->dpp_auth->curr_freq);
|
|
return;
|
|
}
|
|
|
|
if (wpa_s->dpp_listen_freq) {
|
|
/* Continue listen with a new remain-on-channel */
|
|
wpas_dpp_listen_start(wpa_s, wpa_s->dpp_listen_freq);
|
|
}
|
|
}
|
|
|
|
|
|
static void wpas_dpp_rx_auth_req(struct wpa_supplicant *wpa_s, const u8 *src,
|
|
const u8 *hdr, const u8 *buf, size_t len,
|
|
unsigned int freq)
|
|
{
|
|
const u8 *r_bootstrap, *i_bootstrap;
|
|
u16 r_bootstrap_len, i_bootstrap_len;
|
|
struct dpp_bootstrap_info *bi, *own_bi = NULL, *peer_bi = NULL;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Authentication Request from " MACSTR,
|
|
MAC2STR(src));
|
|
|
|
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(wpa_s, MSG_INFO, DPP_EVENT_FAIL
|
|
"Missing or invalid required Responder Bootstrapping Key Hash attribute");
|
|
return;
|
|
}
|
|
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_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
|
|
"Missing or invalid required Initiator Bootstrapping Key Hash attribute");
|
|
return;
|
|
}
|
|
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 */
|
|
dl_list_for_each(bi, &wpa_s->dpp_bootstrap, struct dpp_bootstrap_info,
|
|
list) {
|
|
if (!own_bi && bi->own &&
|
|
os_memcmp(bi->pubkey_hash, r_bootstrap,
|
|
SHA256_MAC_LEN) == 0) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Found matching own bootstrapping information");
|
|
own_bi = bi;
|
|
}
|
|
|
|
if (!peer_bi && !bi->own &&
|
|
os_memcmp(bi->pubkey_hash, i_bootstrap,
|
|
SHA256_MAC_LEN) == 0) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Found matching peer bootstrapping information");
|
|
peer_bi = bi;
|
|
}
|
|
|
|
if (own_bi && peer_bi)
|
|
break;
|
|
}
|
|
|
|
if (!own_bi) {
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
|
|
"No matching own bootstrapping key found - ignore message");
|
|
return;
|
|
}
|
|
|
|
if (wpa_s->dpp_auth) {
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
|
|
"Already in DPP authentication exchange - ignore new one");
|
|
return;
|
|
}
|
|
|
|
wpa_s->dpp_gas_client = 0;
|
|
wpa_s->dpp_auth_ok_on_ack = 0;
|
|
wpa_s->dpp_auth = dpp_auth_req_rx(wpa_s, wpa_s->dpp_allowed_roles,
|
|
wpa_s->dpp_qr_mutual,
|
|
peer_bi, own_bi, freq, hdr, buf, len);
|
|
if (!wpa_s->dpp_auth) {
|
|
wpa_printf(MSG_DEBUG, "DPP: No response generated");
|
|
return;
|
|
}
|
|
wpas_dpp_set_testing_options(wpa_s, wpa_s->dpp_auth);
|
|
wpas_dpp_set_configurator(wpa_s, wpa_s->dpp_auth,
|
|
wpa_s->dpp_configurator_params);
|
|
os_memcpy(wpa_s->dpp_auth->peer_mac_addr, src, ETH_ALEN);
|
|
|
|
if (wpa_s->dpp_listen_freq &&
|
|
wpa_s->dpp_listen_freq != wpa_s->dpp_auth->curr_freq) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Stop listen on %u MHz to allow response on the request %u MHz",
|
|
wpa_s->dpp_listen_freq, wpa_s->dpp_auth->curr_freq);
|
|
wpas_dpp_listen_stop(wpa_s);
|
|
}
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
|
|
MAC2STR(src), wpa_s->dpp_auth->curr_freq,
|
|
DPP_PA_AUTHENTICATION_RESP);
|
|
offchannel_send_action(wpa_s, wpa_s->dpp_auth->curr_freq,
|
|
src, wpa_s->own_addr, broadcast,
|
|
wpabuf_head(wpa_s->dpp_auth->resp_msg),
|
|
wpabuf_len(wpa_s->dpp_auth->resp_msg),
|
|
500, wpas_dpp_tx_status, 0);
|
|
}
|
|
|
|
|
|
static void wpas_dpp_start_gas_server(struct wpa_supplicant *wpa_s)
|
|
{
|
|
/* TODO: stop wait and start ROC */
|
|
}
|
|
|
|
|
|
static struct wpa_ssid * wpas_dpp_add_network(struct wpa_supplicant *wpa_s,
|
|
struct dpp_authentication *auth)
|
|
{
|
|
struct wpa_ssid *ssid;
|
|
|
|
ssid = wpa_config_add_network(wpa_s->conf);
|
|
if (!ssid)
|
|
return NULL;
|
|
wpas_notify_network_added(wpa_s, ssid);
|
|
wpa_config_set_network_defaults(ssid);
|
|
ssid->disabled = 1;
|
|
|
|
ssid->ssid = os_malloc(auth->ssid_len);
|
|
if (!ssid->ssid)
|
|
goto fail;
|
|
os_memcpy(ssid->ssid, auth->ssid, auth->ssid_len);
|
|
ssid->ssid_len = auth->ssid_len;
|
|
|
|
if (auth->connector) {
|
|
ssid->key_mgmt = WPA_KEY_MGMT_DPP;
|
|
ssid->ieee80211w = 1;
|
|
ssid->dpp_connector = os_strdup(auth->connector);
|
|
if (!ssid->dpp_connector)
|
|
goto fail;
|
|
}
|
|
|
|
if (auth->c_sign_key) {
|
|
ssid->dpp_csign = os_malloc(wpabuf_len(auth->c_sign_key));
|
|
if (!ssid->dpp_csign)
|
|
goto fail;
|
|
os_memcpy(ssid->dpp_csign, wpabuf_head(auth->c_sign_key),
|
|
wpabuf_len(auth->c_sign_key));
|
|
ssid->dpp_csign_len = wpabuf_len(auth->c_sign_key);
|
|
}
|
|
|
|
if (auth->net_access_key) {
|
|
ssid->dpp_netaccesskey =
|
|
os_malloc(wpabuf_len(auth->net_access_key));
|
|
if (!ssid->dpp_netaccesskey)
|
|
goto fail;
|
|
os_memcpy(ssid->dpp_netaccesskey,
|
|
wpabuf_head(auth->net_access_key),
|
|
wpabuf_len(auth->net_access_key));
|
|
ssid->dpp_netaccesskey_len = wpabuf_len(auth->net_access_key);
|
|
ssid->dpp_netaccesskey_expiry = auth->net_access_key_expiry;
|
|
}
|
|
|
|
if (!auth->connector) {
|
|
ssid->key_mgmt = WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_PSK_SHA256;
|
|
ssid->ieee80211w = 1;
|
|
if (auth->passphrase[0]) {
|
|
if (wpa_config_set_quoted(ssid, "psk",
|
|
auth->passphrase) < 0)
|
|
goto fail;
|
|
wpa_config_update_psk(ssid);
|
|
ssid->export_keys = 1;
|
|
} else {
|
|
ssid->psk_set = auth->psk_set;
|
|
os_memcpy(ssid->psk, auth->psk, PMK_LEN);
|
|
}
|
|
}
|
|
|
|
return ssid;
|
|
fail:
|
|
wpas_notify_network_removed(wpa_s, ssid);
|
|
wpa_config_remove_network(wpa_s->conf, ssid->id);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static void wpas_dpp_process_config(struct wpa_supplicant *wpa_s,
|
|
struct dpp_authentication *auth)
|
|
{
|
|
struct wpa_ssid *ssid;
|
|
|
|
if (wpa_s->conf->dpp_config_processing < 1)
|
|
return;
|
|
|
|
ssid = wpas_dpp_add_network(wpa_s, auth);
|
|
if (!ssid)
|
|
return;
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_NETWORK_ID "%d", ssid->id);
|
|
if (wpa_s->conf->dpp_config_processing < 2)
|
|
return;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Trying to connect to the new network");
|
|
ssid->disabled = 0;
|
|
wpa_s->disconnected = 0;
|
|
wpa_s->reassociate = 1;
|
|
wpa_s->scan_runs = 0;
|
|
wpa_s->normal_scans = 0;
|
|
wpa_supplicant_cancel_sched_scan(wpa_s);
|
|
wpa_supplicant_req_scan(wpa_s, 0, 0);
|
|
}
|
|
|
|
|
|
static void wpas_dpp_handle_config_obj(struct wpa_supplicant *wpa_s,
|
|
struct dpp_authentication *auth)
|
|
{
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_RECEIVED);
|
|
if (auth->ssid_len)
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONFOBJ_SSID "%s",
|
|
wpa_ssid_txt(auth->ssid, auth->ssid_len));
|
|
if (auth->connector) {
|
|
/* TODO: Save the Connector and consider using a command
|
|
* to fetch the value instead of sending an event with
|
|
* it. The Connector could end up being larger than what
|
|
* most clients are ready to receive as an event
|
|
* message. */
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONNECTOR "%s",
|
|
auth->connector);
|
|
}
|
|
if (auth->c_sign_key) {
|
|
char *hex;
|
|
size_t hexlen;
|
|
|
|
hexlen = 2 * wpabuf_len(auth->c_sign_key) + 1;
|
|
hex = os_malloc(hexlen);
|
|
if (hex) {
|
|
wpa_snprintf_hex(hex, hexlen,
|
|
wpabuf_head(auth->c_sign_key),
|
|
wpabuf_len(auth->c_sign_key));
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_C_SIGN_KEY "%s",
|
|
hex);
|
|
os_free(hex);
|
|
}
|
|
}
|
|
if (auth->net_access_key) {
|
|
char *hex;
|
|
size_t hexlen;
|
|
|
|
hexlen = 2 * wpabuf_len(auth->net_access_key) + 1;
|
|
hex = os_malloc(hexlen);
|
|
if (hex) {
|
|
wpa_snprintf_hex(hex, hexlen,
|
|
wpabuf_head(auth->net_access_key),
|
|
wpabuf_len(auth->net_access_key));
|
|
if (auth->net_access_key_expiry)
|
|
wpa_msg(wpa_s, MSG_INFO,
|
|
DPP_EVENT_NET_ACCESS_KEY "%s %lu", hex,
|
|
(long unsigned)
|
|
auth->net_access_key_expiry);
|
|
else
|
|
wpa_msg(wpa_s, MSG_INFO,
|
|
DPP_EVENT_NET_ACCESS_KEY "%s", hex);
|
|
os_free(hex);
|
|
}
|
|
}
|
|
|
|
wpas_dpp_process_config(wpa_s, auth);
|
|
}
|
|
|
|
|
|
static void wpas_dpp_gas_resp_cb(void *ctx, const u8 *addr, u8 dialog_token,
|
|
enum gas_query_result result,
|
|
const struct wpabuf *adv_proto,
|
|
const struct wpabuf *resp, u16 status_code)
|
|
{
|
|
struct wpa_supplicant *wpa_s = ctx;
|
|
const u8 *pos;
|
|
struct dpp_authentication *auth = wpa_s->dpp_auth;
|
|
|
|
if (!auth || !auth->auth_success) {
|
|
wpa_printf(MSG_DEBUG, "DPP: No matching exchange in progress");
|
|
return;
|
|
}
|
|
if (!resp || status_code != WLAN_STATUS_SUCCESS) {
|
|
wpa_printf(MSG_DEBUG, "DPP: GAS query did not succeed");
|
|
goto fail;
|
|
}
|
|
|
|
wpa_hexdump_buf(MSG_DEBUG, "DPP: Configuration Response adv_proto",
|
|
adv_proto);
|
|
wpa_hexdump_buf(MSG_DEBUG, "DPP: Configuration Response (GAS response)",
|
|
resp);
|
|
|
|
if (wpabuf_len(adv_proto) != 10 ||
|
|
!(pos = wpabuf_head(adv_proto)) ||
|
|
pos[0] != WLAN_EID_ADV_PROTO ||
|
|
pos[1] != 8 ||
|
|
pos[3] != WLAN_EID_VENDOR_SPECIFIC ||
|
|
pos[4] != 5 ||
|
|
WPA_GET_BE24(&pos[5]) != OUI_WFA ||
|
|
pos[8] != 0x1a ||
|
|
pos[9] != 1) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Not a DPP Advertisement Protocol ID");
|
|
goto fail;
|
|
}
|
|
|
|
if (dpp_conf_resp_rx(auth, resp) < 0) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Configuration attempt failed");
|
|
goto fail;
|
|
}
|
|
|
|
wpas_dpp_handle_config_obj(wpa_s, auth);
|
|
dpp_auth_deinit(wpa_s->dpp_auth);
|
|
wpa_s->dpp_auth = NULL;
|
|
return;
|
|
|
|
fail:
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
|
|
dpp_auth_deinit(wpa_s->dpp_auth);
|
|
wpa_s->dpp_auth = NULL;
|
|
}
|
|
|
|
|
|
static void wpas_dpp_start_gas_client(struct wpa_supplicant *wpa_s)
|
|
{
|
|
struct dpp_authentication *auth = wpa_s->dpp_auth;
|
|
struct wpabuf *buf, *conf_req;
|
|
char json[100];
|
|
int res;
|
|
|
|
wpa_s->dpp_gas_client = 1;
|
|
os_snprintf(json, sizeof(json),
|
|
"{\"name\":\"Test\","
|
|
"\"wi-fi_tech\":\"infra\","
|
|
"\"netRole\":\"%s\"}",
|
|
wpa_s->dpp_netrole_ap ? "ap" : "sta");
|
|
wpa_printf(MSG_DEBUG, "DPP: GAS Config Attributes: %s", json);
|
|
|
|
offchannel_send_action_done(wpa_s);
|
|
wpas_dpp_listen_stop(wpa_s);
|
|
|
|
conf_req = dpp_build_conf_req(auth, json);
|
|
if (!conf_req) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: No configuration request data available");
|
|
return;
|
|
}
|
|
|
|
buf = gas_build_initial_req(0, 10 + 2 + wpabuf_len(conf_req));
|
|
if (!buf) {
|
|
wpabuf_free(conf_req);
|
|
return;
|
|
}
|
|
|
|
/* Advertisement Protocol IE */
|
|
wpabuf_put_u8(buf, WLAN_EID_ADV_PROTO);
|
|
wpabuf_put_u8(buf, 8); /* Length */
|
|
wpabuf_put_u8(buf, 0x7f);
|
|
wpabuf_put_u8(buf, WLAN_EID_VENDOR_SPECIFIC);
|
|
wpabuf_put_u8(buf, 5);
|
|
wpabuf_put_be24(buf, OUI_WFA);
|
|
wpabuf_put_u8(buf, DPP_OUI_TYPE);
|
|
wpabuf_put_u8(buf, 0x01);
|
|
|
|
/* GAS Query */
|
|
wpabuf_put_le16(buf, wpabuf_len(conf_req));
|
|
wpabuf_put_buf(buf, conf_req);
|
|
wpabuf_free(conf_req);
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: GAS request to " MACSTR " (freq %u MHz)",
|
|
MAC2STR(auth->peer_mac_addr), auth->curr_freq);
|
|
|
|
res = gas_query_req(wpa_s->gas, auth->peer_mac_addr, auth->curr_freq,
|
|
buf, wpas_dpp_gas_resp_cb, wpa_s);
|
|
if (res < 0) {
|
|
wpa_msg(wpa_s, MSG_DEBUG, "GAS: Failed to send Query Request");
|
|
wpabuf_free(buf);
|
|
} else {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: GAS query started with dialog token %u", res);
|
|
}
|
|
}
|
|
|
|
|
|
static void wpas_dpp_auth_success(struct wpa_supplicant *wpa_s, int initiator)
|
|
{
|
|
wpa_printf(MSG_DEBUG, "DPP: Authentication succeeded");
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_SUCCESS "init=%d", initiator);
|
|
|
|
if (wpa_s->dpp_auth->configurator)
|
|
wpas_dpp_start_gas_server(wpa_s);
|
|
else
|
|
wpas_dpp_start_gas_client(wpa_s);
|
|
}
|
|
|
|
|
|
static void wpas_dpp_rx_auth_resp(struct wpa_supplicant *wpa_s, const u8 *src,
|
|
const u8 *hdr, const u8 *buf, size_t len,
|
|
unsigned int freq)
|
|
{
|
|
struct dpp_authentication *auth = wpa_s->dpp_auth;
|
|
struct wpabuf *msg;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Authentication Response from " MACSTR
|
|
" (freq %u MHz)", MAC2STR(src), freq);
|
|
|
|
if (!auth) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: No DPP Authentication in progress - drop");
|
|
return;
|
|
}
|
|
|
|
if (!is_zero_ether_addr(auth->peer_mac_addr) &&
|
|
os_memcmp(src, auth->peer_mac_addr, ETH_ALEN) != 0) {
|
|
wpa_printf(MSG_DEBUG, "DPP: MAC address mismatch (expected "
|
|
MACSTR ") - drop", MAC2STR(auth->peer_mac_addr));
|
|
return;
|
|
}
|
|
|
|
eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
|
|
|
|
if (auth->curr_freq != freq && auth->neg_freq == freq) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Responder accepted request for different negotiation channel");
|
|
auth->curr_freq = freq;
|
|
}
|
|
|
|
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");
|
|
offchannel_send_action_done(wpa_s);
|
|
wpas_dpp_listen_start(wpa_s, auth->curr_freq);
|
|
return;
|
|
}
|
|
wpa_printf(MSG_DEBUG, "DPP: No confirm generated");
|
|
return;
|
|
}
|
|
os_memcpy(auth->peer_mac_addr, src, ETH_ALEN);
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
|
|
MAC2STR(src), auth->curr_freq, DPP_PA_AUTHENTICATION_CONF);
|
|
offchannel_send_action(wpa_s, auth->curr_freq,
|
|
src, wpa_s->own_addr, broadcast,
|
|
wpabuf_head(msg), wpabuf_len(msg),
|
|
500, wpas_dpp_tx_status, 0);
|
|
wpabuf_free(msg);
|
|
wpa_s->dpp_auth_ok_on_ack = 1;
|
|
}
|
|
|
|
|
|
static void wpas_dpp_rx_auth_conf(struct wpa_supplicant *wpa_s, const u8 *src,
|
|
const u8 *hdr, const u8 *buf, size_t len)
|
|
{
|
|
struct dpp_authentication *auth = wpa_s->dpp_auth;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Authentication Confirmation from " MACSTR,
|
|
MAC2STR(src));
|
|
|
|
if (!auth) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: No DPP Authentication in progress - drop");
|
|
return;
|
|
}
|
|
|
|
if (os_memcmp(src, auth->peer_mac_addr, ETH_ALEN) != 0) {
|
|
wpa_printf(MSG_DEBUG, "DPP: MAC address mismatch (expected "
|
|
MACSTR ") - drop", MAC2STR(auth->peer_mac_addr));
|
|
return;
|
|
}
|
|
|
|
if (dpp_auth_conf_rx(auth, hdr, buf, len) < 0) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Authentication failed");
|
|
return;
|
|
}
|
|
|
|
wpas_dpp_auth_success(wpa_s, 0);
|
|
}
|
|
|
|
|
|
static void wpas_dpp_rx_peer_disc_resp(struct wpa_supplicant *wpa_s,
|
|
const u8 *src,
|
|
const u8 *buf, size_t len)
|
|
{
|
|
struct wpa_ssid *ssid;
|
|
const u8 *connector, *trans_id, *status;
|
|
u16 connector_len, trans_id_len, status_len;
|
|
struct dpp_introduction intro;
|
|
struct rsn_pmksa_cache_entry *entry;
|
|
struct os_time now;
|
|
struct os_reltime rnow;
|
|
os_time_t expiry;
|
|
unsigned int seconds;
|
|
enum dpp_status_error res;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Peer Discovery Response from " MACSTR,
|
|
MAC2STR(src));
|
|
if (is_zero_ether_addr(wpa_s->dpp_intro_bssid) ||
|
|
os_memcmp(src, wpa_s->dpp_intro_bssid, ETH_ALEN) != 0) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Not waiting for response from "
|
|
MACSTR " - drop", MAC2STR(src));
|
|
return;
|
|
}
|
|
offchannel_send_action_done(wpa_s);
|
|
|
|
for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
|
|
if (ssid == wpa_s->dpp_intro_network)
|
|
break;
|
|
}
|
|
if (!ssid || !ssid->dpp_connector || !ssid->dpp_netaccesskey ||
|
|
!ssid->dpp_csign) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Profile not found for network introduction");
|
|
return;
|
|
}
|
|
|
|
trans_id = dpp_get_attr(buf, len, DPP_ATTR_TRANSACTION_ID,
|
|
&trans_id_len);
|
|
if (!trans_id || trans_id_len != 1) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Peer did not include Transaction ID");
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
|
|
" fail=missing_transaction_id", MAC2STR(src));
|
|
goto fail;
|
|
}
|
|
if (trans_id[0] != TRANSACTION_ID) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Ignore frame with unexpected Transaction ID %u",
|
|
trans_id[0]);
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
|
|
" fail=transaction_id_mismatch", MAC2STR(src));
|
|
goto fail;
|
|
}
|
|
|
|
status = dpp_get_attr(buf, len, DPP_ATTR_STATUS, &status_len);
|
|
if (!status || status_len != 1) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Peer did not include Status");
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
|
|
" fail=missing_status", MAC2STR(src));
|
|
goto fail;
|
|
}
|
|
if (status[0] != DPP_STATUS_OK) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Peer rejected network introduction: Status %u",
|
|
status[0]);
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
|
|
" status=%u", MAC2STR(src), status[0]);
|
|
goto fail;
|
|
}
|
|
|
|
connector = dpp_get_attr(buf, len, DPP_ATTR_CONNECTOR, &connector_len);
|
|
if (!connector) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Peer did not include its Connector");
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
|
|
" fail=missing_connector", MAC2STR(src));
|
|
goto fail;
|
|
}
|
|
|
|
res = dpp_peer_intro(&intro, ssid->dpp_connector,
|
|
ssid->dpp_netaccesskey,
|
|
ssid->dpp_netaccesskey_len,
|
|
ssid->dpp_csign,
|
|
ssid->dpp_csign_len,
|
|
connector, connector_len, &expiry);
|
|
if (res != DPP_STATUS_OK) {
|
|
wpa_printf(MSG_INFO,
|
|
"DPP: Network Introduction protocol resulted in failure");
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
|
|
" fail=peer_connector_validation_failed", MAC2STR(src));
|
|
goto fail;
|
|
}
|
|
|
|
entry = os_zalloc(sizeof(*entry));
|
|
if (!entry)
|
|
goto fail;
|
|
os_memcpy(entry->aa, src, ETH_ALEN);
|
|
os_memcpy(entry->pmkid, intro.pmkid, PMKID_LEN);
|
|
os_memcpy(entry->pmk, intro.pmk, intro.pmk_len);
|
|
entry->pmk_len = intro.pmk_len;
|
|
entry->akmp = WPA_KEY_MGMT_DPP;
|
|
if (expiry) {
|
|
os_get_time(&now);
|
|
seconds = expiry - now.sec;
|
|
} else {
|
|
seconds = 86400 * 7;
|
|
}
|
|
os_get_reltime(&rnow);
|
|
entry->expiration = rnow.sec + seconds;
|
|
entry->reauth_time = rnow.sec + seconds;
|
|
entry->network_ctx = ssid;
|
|
wpa_sm_pmksa_cache_add_entry(wpa_s->wpa, entry);
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
|
|
" status=%u", MAC2STR(src), status[0]);
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Try connection again after successful network introduction");
|
|
if (wpa_supplicant_fast_associate(wpa_s) != 1) {
|
|
wpa_supplicant_cancel_sched_scan(wpa_s);
|
|
wpa_supplicant_req_scan(wpa_s, 0, 0);
|
|
}
|
|
fail:
|
|
os_memset(&intro, 0, sizeof(intro));
|
|
}
|
|
|
|
|
|
static void
|
|
wpas_dpp_tx_pkex_status(struct wpa_supplicant *wpa_s,
|
|
unsigned int freq, const u8 *dst,
|
|
const u8 *src, const u8 *bssid,
|
|
const u8 *data, size_t data_len,
|
|
enum offchannel_send_action_result result)
|
|
{
|
|
const char *res_txt;
|
|
|
|
res_txt = result == OFFCHANNEL_SEND_ACTION_SUCCESS ? "SUCCESS" :
|
|
(result == OFFCHANNEL_SEND_ACTION_NO_ACK ? "no-ACK" :
|
|
"FAILED");
|
|
wpa_printf(MSG_DEBUG, "DPP: TX status: freq=%u dst=" MACSTR
|
|
" result=%s (PKEX)",
|
|
freq, MAC2STR(dst), res_txt);
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR
|
|
" freq=%u result=%s", MAC2STR(dst), freq, res_txt);
|
|
/* TODO: Time out wait for response more quickly in error cases? */
|
|
|
|
if (!wpa_s->dpp_pkex) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Ignore TX status since there is no ongoing PKEX exchange");
|
|
return;
|
|
}
|
|
|
|
if (wpa_s->dpp_pkex->failed) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Terminate PKEX exchange due to an earlier error");
|
|
if (wpa_s->dpp_pkex->t > wpa_s->dpp_pkex->own_bi->pkex_t)
|
|
wpa_s->dpp_pkex->own_bi->pkex_t = wpa_s->dpp_pkex->t;
|
|
dpp_pkex_free(wpa_s->dpp_pkex);
|
|
wpa_s->dpp_pkex = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
wpas_dpp_rx_pkex_exchange_req(struct wpa_supplicant *wpa_s, const u8 *src,
|
|
const u8 *buf, size_t len, unsigned int freq)
|
|
{
|
|
struct wpabuf *msg;
|
|
unsigned int wait_time;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: PKEX Exchange Request from " MACSTR,
|
|
MAC2STR(src));
|
|
|
|
/* TODO: Support multiple PKEX codes by iterating over all the enabled
|
|
* values here */
|
|
|
|
if (!wpa_s->dpp_pkex_code || !wpa_s->dpp_pkex_bi) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: No PKEX code configured - ignore request");
|
|
return;
|
|
}
|
|
|
|
if (wpa_s->dpp_pkex) {
|
|
/* TODO: Support parallel operations */
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Already in PKEX session - ignore new request");
|
|
return;
|
|
}
|
|
|
|
wpa_s->dpp_pkex = dpp_pkex_rx_exchange_req(wpa_s, wpa_s->dpp_pkex_bi,
|
|
wpa_s->own_addr, src,
|
|
wpa_s->dpp_pkex_identifier,
|
|
wpa_s->dpp_pkex_code,
|
|
buf, len);
|
|
if (!wpa_s->dpp_pkex) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Failed to process the request - ignore it");
|
|
return;
|
|
}
|
|
|
|
msg = wpa_s->dpp_pkex->exchange_resp;
|
|
wait_time = wpa_s->max_remain_on_chan;
|
|
if (wait_time > 2000)
|
|
wait_time = 2000;
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
|
|
MAC2STR(src), freq, DPP_PA_PKEX_EXCHANGE_RESP);
|
|
offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr,
|
|
broadcast,
|
|
wpabuf_head(msg), wpabuf_len(msg),
|
|
wait_time, wpas_dpp_tx_pkex_status, 0);
|
|
}
|
|
|
|
|
|
static void
|
|
wpas_dpp_rx_pkex_exchange_resp(struct wpa_supplicant *wpa_s, const u8 *src,
|
|
const u8 *buf, size_t len, unsigned int freq)
|
|
{
|
|
struct wpabuf *msg;
|
|
unsigned int wait_time;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: PKEX Exchange Response from " MACSTR,
|
|
MAC2STR(src));
|
|
|
|
/* TODO: Support multiple PKEX codes by iterating over all the enabled
|
|
* values here */
|
|
|
|
if (!wpa_s->dpp_pkex || !wpa_s->dpp_pkex->initiator ||
|
|
wpa_s->dpp_pkex->exchange_done) {
|
|
wpa_printf(MSG_DEBUG, "DPP: No matching PKEX session");
|
|
return;
|
|
}
|
|
|
|
os_memcpy(wpa_s->dpp_pkex->peer_mac, src, ETH_ALEN);
|
|
msg = dpp_pkex_rx_exchange_resp(wpa_s->dpp_pkex, buf, len);
|
|
if (!msg) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Failed to process the response");
|
|
return;
|
|
}
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Send PKEX Commit-Reveal Request to " MACSTR,
|
|
MAC2STR(src));
|
|
|
|
wait_time = wpa_s->max_remain_on_chan;
|
|
if (wait_time > 2000)
|
|
wait_time = 2000;
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
|
|
MAC2STR(src), freq, DPP_PA_PKEX_COMMIT_REVEAL_REQ);
|
|
offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr,
|
|
broadcast,
|
|
wpabuf_head(msg), wpabuf_len(msg),
|
|
wait_time, wpas_dpp_tx_pkex_status, 0);
|
|
wpabuf_free(msg);
|
|
}
|
|
|
|
|
|
static void
|
|
wpas_dpp_rx_pkex_commit_reveal_req(struct wpa_supplicant *wpa_s, const u8 *src,
|
|
const u8 *hdr, const u8 *buf, size_t len,
|
|
unsigned int freq)
|
|
{
|
|
struct wpabuf *msg;
|
|
unsigned int wait_time;
|
|
struct dpp_pkex *pkex = wpa_s->dpp_pkex;
|
|
struct dpp_bootstrap_info *bi;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: PKEX Commit-Reveal Request from " MACSTR,
|
|
MAC2STR(src));
|
|
|
|
if (!pkex || pkex->initiator || !pkex->exchange_done) {
|
|
wpa_printf(MSG_DEBUG, "DPP: No matching PKEX session");
|
|
return;
|
|
}
|
|
|
|
msg = dpp_pkex_rx_commit_reveal_req(pkex, hdr, buf, len);
|
|
if (!msg) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Failed to process the request");
|
|
if (pkex->failed) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Terminate PKEX exchange");
|
|
if (pkex->t > pkex->own_bi->pkex_t)
|
|
pkex->own_bi->pkex_t = pkex->t;
|
|
dpp_pkex_free(wpa_s->dpp_pkex);
|
|
wpa_s->dpp_pkex = NULL;
|
|
}
|
|
return;
|
|
}
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Send PKEX Commit-Reveal Response to "
|
|
MACSTR, MAC2STR(src));
|
|
|
|
wait_time = wpa_s->max_remain_on_chan;
|
|
if (wait_time > 2000)
|
|
wait_time = 2000;
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
|
|
MAC2STR(src), freq, DPP_PA_PKEX_COMMIT_REVEAL_RESP);
|
|
offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr,
|
|
broadcast,
|
|
wpabuf_head(msg), wpabuf_len(msg),
|
|
wait_time, wpas_dpp_tx_pkex_status, 0);
|
|
wpabuf_free(msg);
|
|
|
|
bi = os_zalloc(sizeof(*bi));
|
|
if (!bi)
|
|
return;
|
|
bi->id = wpas_dpp_next_id(wpa_s);
|
|
bi->type = DPP_BOOTSTRAP_PKEX;
|
|
os_memcpy(bi->mac_addr, src, ETH_ALEN);
|
|
bi->num_freq = 1;
|
|
bi->freq[0] = freq;
|
|
bi->curve = pkex->own_bi->curve;
|
|
bi->pubkey = pkex->peer_bootstrap_key;
|
|
pkex->peer_bootstrap_key = NULL;
|
|
dpp_pkex_free(pkex);
|
|
wpa_s->dpp_pkex = NULL;
|
|
if (dpp_bootstrap_key_hash(bi) < 0) {
|
|
dpp_bootstrap_info_free(bi);
|
|
return;
|
|
}
|
|
dl_list_add(&wpa_s->dpp_bootstrap, &bi->list);
|
|
}
|
|
|
|
|
|
static void
|
|
wpas_dpp_rx_pkex_commit_reveal_resp(struct wpa_supplicant *wpa_s, const u8 *src,
|
|
const u8 *hdr, const u8 *buf, size_t len,
|
|
unsigned int freq)
|
|
{
|
|
int res;
|
|
struct dpp_bootstrap_info *bi, *own_bi;
|
|
struct dpp_pkex *pkex = wpa_s->dpp_pkex;
|
|
char cmd[500];
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: PKEX Commit-Reveal Response from " MACSTR,
|
|
MAC2STR(src));
|
|
|
|
if (!pkex || !pkex->initiator || !pkex->exchange_done) {
|
|
wpa_printf(MSG_DEBUG, "DPP: No matching PKEX session");
|
|
return;
|
|
}
|
|
|
|
res = dpp_pkex_rx_commit_reveal_resp(pkex, hdr, buf, len);
|
|
if (res < 0) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Failed to process the response");
|
|
return;
|
|
}
|
|
|
|
own_bi = pkex->own_bi;
|
|
|
|
bi = os_zalloc(sizeof(*bi));
|
|
if (!bi)
|
|
return;
|
|
bi->id = wpas_dpp_next_id(wpa_s);
|
|
bi->type = DPP_BOOTSTRAP_PKEX;
|
|
os_memcpy(bi->mac_addr, src, ETH_ALEN);
|
|
bi->num_freq = 1;
|
|
bi->freq[0] = freq;
|
|
bi->curve = own_bi->curve;
|
|
bi->pubkey = pkex->peer_bootstrap_key;
|
|
pkex->peer_bootstrap_key = NULL;
|
|
dpp_pkex_free(pkex);
|
|
wpa_s->dpp_pkex = NULL;
|
|
if (dpp_bootstrap_key_hash(bi) < 0) {
|
|
dpp_bootstrap_info_free(bi);
|
|
return;
|
|
}
|
|
dl_list_add(&wpa_s->dpp_bootstrap, &bi->list);
|
|
|
|
os_snprintf(cmd, sizeof(cmd), " peer=%u %s",
|
|
bi->id,
|
|
wpa_s->dpp_pkex_auth_cmd ? wpa_s->dpp_pkex_auth_cmd : "");
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Start authentication after PKEX with parameters: %s",
|
|
cmd);
|
|
if (wpas_dpp_auth_init(wpa_s, cmd) < 0) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Authentication initialization failed");
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
void wpas_dpp_rx_action(struct wpa_supplicant *wpa_s, const u8 *src,
|
|
const u8 *buf, size_t len, unsigned int freq)
|
|
{
|
|
u8 crypto_suite;
|
|
enum dpp_public_action_frame_type type;
|
|
const u8 *hdr;
|
|
unsigned int pkex_t;
|
|
|
|
if (len < DPP_HDR_LEN)
|
|
return;
|
|
if (WPA_GET_BE24(buf) != OUI_WFA || buf[3] != DPP_OUI_TYPE)
|
|
return;
|
|
hdr = buf;
|
|
buf += 4;
|
|
len -= 4;
|
|
crypto_suite = *buf++;
|
|
type = *buf++;
|
|
len -= 2;
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Received DPP Public Action frame crypto suite %u type %d from "
|
|
MACSTR " freq=%u",
|
|
crypto_suite, type, MAC2STR(src), freq);
|
|
if (crypto_suite != 1) {
|
|
wpa_printf(MSG_DEBUG, "DPP: Unsupported crypto suite %u",
|
|
crypto_suite);
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_RX "src=" MACSTR
|
|
" freq=%u type=%d ignore=unsupported-crypto-suite",
|
|
MAC2STR(src), freq, type);
|
|
return;
|
|
}
|
|
wpa_hexdump(MSG_MSGDUMP, "DPP: Received message attributes", buf, len);
|
|
if (dpp_check_attrs(buf, len) < 0) {
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_RX "src=" MACSTR
|
|
" freq=%u type=%d ignore=invalid-attributes",
|
|
MAC2STR(src), freq, type);
|
|
return;
|
|
}
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_RX "src=" MACSTR " freq=%u type=%d",
|
|
MAC2STR(src), freq, type);
|
|
|
|
switch (type) {
|
|
case DPP_PA_AUTHENTICATION_REQ:
|
|
wpas_dpp_rx_auth_req(wpa_s, src, hdr, buf, len, freq);
|
|
break;
|
|
case DPP_PA_AUTHENTICATION_RESP:
|
|
wpas_dpp_rx_auth_resp(wpa_s, src, hdr, buf, len, freq);
|
|
break;
|
|
case DPP_PA_AUTHENTICATION_CONF:
|
|
wpas_dpp_rx_auth_conf(wpa_s, src, hdr, buf, len);
|
|
break;
|
|
case DPP_PA_PEER_DISCOVERY_RESP:
|
|
wpas_dpp_rx_peer_disc_resp(wpa_s, src, buf, len);
|
|
break;
|
|
case DPP_PA_PKEX_EXCHANGE_REQ:
|
|
wpas_dpp_rx_pkex_exchange_req(wpa_s, src, buf, len, freq);
|
|
break;
|
|
case DPP_PA_PKEX_EXCHANGE_RESP:
|
|
wpas_dpp_rx_pkex_exchange_resp(wpa_s, src, buf, len, freq);
|
|
break;
|
|
case DPP_PA_PKEX_COMMIT_REVEAL_REQ:
|
|
wpas_dpp_rx_pkex_commit_reveal_req(wpa_s, src, hdr, buf, len,
|
|
freq);
|
|
break;
|
|
case DPP_PA_PKEX_COMMIT_REVEAL_RESP:
|
|
wpas_dpp_rx_pkex_commit_reveal_resp(wpa_s, src, hdr, buf, len,
|
|
freq);
|
|
break;
|
|
default:
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Ignored unsupported frame subtype %d", type);
|
|
break;
|
|
}
|
|
|
|
if (wpa_s->dpp_pkex)
|
|
pkex_t = wpa_s->dpp_pkex->t;
|
|
else if (wpa_s->dpp_pkex_bi)
|
|
pkex_t = wpa_s->dpp_pkex_bi->pkex_t;
|
|
else
|
|
pkex_t = 0;
|
|
if (pkex_t >= PKEX_COUNTER_T_LIMIT) {
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PKEX_T_LIMIT "id=0");
|
|
wpas_dpp_pkex_remove(wpa_s, "*");
|
|
}
|
|
}
|
|
|
|
|
|
static struct wpabuf *
|
|
wpas_dpp_gas_req_handler(void *ctx, const u8 *sa, const u8 *query,
|
|
size_t query_len)
|
|
{
|
|
struct wpa_supplicant *wpa_s = ctx;
|
|
struct dpp_authentication *auth = wpa_s->dpp_auth;
|
|
struct wpabuf *resp;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: GAS request from " MACSTR,
|
|
MAC2STR(sa));
|
|
if (!auth || !auth->auth_success ||
|
|
os_memcmp(sa, auth->peer_mac_addr, ETH_ALEN) != 0) {
|
|
wpa_printf(MSG_DEBUG, "DPP: No matching exchange in progress");
|
|
return NULL;
|
|
}
|
|
wpa_hexdump(MSG_DEBUG,
|
|
"DPP: Received Configuration Request (GAS Query Request)",
|
|
query, query_len);
|
|
resp = dpp_conf_req_rx(auth, query, query_len);
|
|
if (!resp)
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
|
|
return resp;
|
|
}
|
|
|
|
|
|
static void
|
|
wpas_dpp_gas_status_handler(void *ctx, struct wpabuf *resp, int ok)
|
|
{
|
|
struct wpa_supplicant *wpa_s = ctx;
|
|
struct dpp_authentication *auth = wpa_s->dpp_auth;
|
|
|
|
if (!auth) {
|
|
wpabuf_free(resp);
|
|
return;
|
|
}
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Configuration exchange completed (ok=%d)",
|
|
ok);
|
|
eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
|
|
offchannel_send_action_done(wpa_s);
|
|
wpas_dpp_listen_stop(wpa_s);
|
|
if (ok)
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_SENT);
|
|
else
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
|
|
dpp_auth_deinit(wpa_s->dpp_auth);
|
|
wpa_s->dpp_auth = NULL;
|
|
wpabuf_free(resp);
|
|
}
|
|
|
|
|
|
static unsigned int wpas_dpp_next_configurator_id(struct wpa_supplicant *wpa_s)
|
|
{
|
|
struct dpp_configurator *conf;
|
|
unsigned int max_id = 0;
|
|
|
|
dl_list_for_each(conf, &wpa_s->dpp_configurator,
|
|
struct dpp_configurator, list) {
|
|
if (conf->id > max_id)
|
|
max_id = conf->id;
|
|
}
|
|
return max_id + 1;
|
|
}
|
|
|
|
|
|
int wpas_dpp_configurator_add(struct wpa_supplicant *wpa_s, const char *cmd)
|
|
{
|
|
char *curve = NULL;
|
|
char *key = NULL;
|
|
u8 *privkey = NULL;
|
|
size_t privkey_len = 0;
|
|
int ret = -1;
|
|
struct dpp_configurator *conf = NULL;
|
|
|
|
curve = get_param(cmd, " curve=");
|
|
key = get_param(cmd, " key=");
|
|
|
|
if (key) {
|
|
privkey_len = os_strlen(key) / 2;
|
|
privkey = os_malloc(privkey_len);
|
|
if (!privkey ||
|
|
hexstr2bin(key, privkey, privkey_len) < 0)
|
|
goto fail;
|
|
}
|
|
|
|
conf = dpp_keygen_configurator(curve, privkey, privkey_len);
|
|
if (!conf)
|
|
goto fail;
|
|
|
|
conf->id = wpas_dpp_next_configurator_id(wpa_s);
|
|
dl_list_add(&wpa_s->dpp_configurator, &conf->list);
|
|
ret = conf->id;
|
|
conf = NULL;
|
|
fail:
|
|
os_free(curve);
|
|
str_clear_free(key);
|
|
bin_clear_free(privkey, privkey_len);
|
|
dpp_configurator_free(conf);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int dpp_configurator_del(struct wpa_supplicant *wpa_s, unsigned int id)
|
|
{
|
|
struct dpp_configurator *conf, *tmp;
|
|
int found = 0;
|
|
|
|
dl_list_for_each_safe(conf, tmp, &wpa_s->dpp_configurator,
|
|
struct dpp_configurator, list) {
|
|
if (id && conf->id != id)
|
|
continue;
|
|
found = 1;
|
|
dl_list_del(&conf->list);
|
|
dpp_configurator_free(conf);
|
|
}
|
|
|
|
if (id == 0)
|
|
return 0; /* flush succeeds regardless of entries found */
|
|
return found ? 0 : -1;
|
|
}
|
|
|
|
|
|
int wpas_dpp_configurator_remove(struct wpa_supplicant *wpa_s, const char *id)
|
|
{
|
|
unsigned int id_val;
|
|
|
|
if (os_strcmp(id, "*") == 0) {
|
|
id_val = 0;
|
|
} else {
|
|
id_val = atoi(id);
|
|
if (id_val == 0)
|
|
return -1;
|
|
}
|
|
|
|
return dpp_configurator_del(wpa_s, id_val);
|
|
}
|
|
|
|
|
|
int wpas_dpp_configurator_sign(struct wpa_supplicant *wpa_s, const char *cmd)
|
|
{
|
|
struct dpp_authentication *auth;
|
|
int ret = -1;
|
|
char *curve = NULL;
|
|
|
|
auth = os_zalloc(sizeof(*auth));
|
|
if (!auth)
|
|
return -1;
|
|
|
|
curve = get_param(cmd, " curve=");
|
|
wpas_dpp_set_configurator(wpa_s, auth, cmd);
|
|
|
|
if (dpp_configurator_own_config(auth, curve) == 0) {
|
|
wpas_dpp_handle_config_obj(wpa_s, auth);
|
|
ret = 0;
|
|
}
|
|
|
|
dpp_auth_deinit(auth);
|
|
os_free(curve);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void
|
|
wpas_dpp_tx_introduction_status(struct wpa_supplicant *wpa_s,
|
|
unsigned int freq, const u8 *dst,
|
|
const u8 *src, const u8 *bssid,
|
|
const u8 *data, size_t data_len,
|
|
enum offchannel_send_action_result result)
|
|
{
|
|
const char *res_txt;
|
|
|
|
res_txt = result == OFFCHANNEL_SEND_ACTION_SUCCESS ? "SUCCESS" :
|
|
(result == OFFCHANNEL_SEND_ACTION_NO_ACK ? "no-ACK" :
|
|
"FAILED");
|
|
wpa_printf(MSG_DEBUG, "DPP: TX status: freq=%u dst=" MACSTR
|
|
" result=%s (DPP Peer Discovery Request)",
|
|
freq, MAC2STR(dst), res_txt);
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR
|
|
" freq=%u result=%s", MAC2STR(dst), freq, res_txt);
|
|
/* TODO: Time out wait for response more quickly in error cases? */
|
|
}
|
|
|
|
|
|
int wpas_dpp_check_connect(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
|
|
struct wpa_bss *bss)
|
|
{
|
|
struct os_time now;
|
|
struct wpabuf *msg;
|
|
unsigned int wait_time;
|
|
|
|
if (!(ssid->key_mgmt & WPA_KEY_MGMT_DPP) || !bss)
|
|
return 0; /* Not using DPP AKM - continue */
|
|
if (wpa_sm_pmksa_exists(wpa_s->wpa, bss->bssid, ssid))
|
|
return 0; /* PMKSA exists for DPP AKM - continue */
|
|
|
|
if (!ssid->dpp_connector || !ssid->dpp_netaccesskey ||
|
|
!ssid->dpp_csign) {
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_MISSING_CONNECTOR
|
|
"missing %s",
|
|
!ssid->dpp_connector ? "Connector" :
|
|
(!ssid->dpp_netaccesskey ? "netAccessKey" :
|
|
"C-sign-key"));
|
|
return -1;
|
|
}
|
|
|
|
os_get_time(&now);
|
|
|
|
if (ssid->dpp_netaccesskey_expiry &&
|
|
ssid->dpp_netaccesskey_expiry < now.sec) {
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_MISSING_CONNECTOR
|
|
"netAccessKey expired");
|
|
return -1;
|
|
}
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Starting network introduction protocol to derive PMKSA for "
|
|
MACSTR, MAC2STR(bss->bssid));
|
|
|
|
msg = dpp_alloc_msg(DPP_PA_PEER_DISCOVERY_REQ,
|
|
5 + 4 + os_strlen(ssid->dpp_connector));
|
|
if (!msg)
|
|
return -1;
|
|
|
|
/* Transaction ID */
|
|
wpabuf_put_le16(msg, DPP_ATTR_TRANSACTION_ID);
|
|
wpabuf_put_le16(msg, 1);
|
|
wpabuf_put_u8(msg, TRANSACTION_ID);
|
|
|
|
/* DPP Connector */
|
|
wpabuf_put_le16(msg, DPP_ATTR_CONNECTOR);
|
|
wpabuf_put_le16(msg, os_strlen(ssid->dpp_connector));
|
|
wpabuf_put_str(msg, ssid->dpp_connector);
|
|
|
|
/* TODO: Timeout on AP response */
|
|
wait_time = wpa_s->max_remain_on_chan;
|
|
if (wait_time > 2000)
|
|
wait_time = 2000;
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
|
|
MAC2STR(bss->bssid), bss->freq, DPP_PA_PEER_DISCOVERY_REQ);
|
|
offchannel_send_action(wpa_s, bss->freq, bss->bssid, wpa_s->own_addr,
|
|
broadcast,
|
|
wpabuf_head(msg), wpabuf_len(msg),
|
|
wait_time, wpas_dpp_tx_introduction_status, 0);
|
|
wpabuf_free(msg);
|
|
|
|
/* Request this connection attempt to terminate - new one will be
|
|
* started when network introduction protocol completes */
|
|
os_memcpy(wpa_s->dpp_intro_bssid, bss->bssid, ETH_ALEN);
|
|
wpa_s->dpp_intro_network = ssid;
|
|
return 1;
|
|
}
|
|
|
|
|
|
int wpas_dpp_pkex_add(struct wpa_supplicant *wpa_s, const char *cmd)
|
|
{
|
|
struct dpp_bootstrap_info *own_bi;
|
|
const char *pos, *end;
|
|
unsigned int wait_time;
|
|
|
|
pos = os_strstr(cmd, " own=");
|
|
if (!pos)
|
|
return -1;
|
|
pos += 5;
|
|
own_bi = dpp_bootstrap_get_id(wpa_s, atoi(pos));
|
|
if (!own_bi) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Identified bootstrap info not found");
|
|
return -1;
|
|
}
|
|
if (own_bi->type != DPP_BOOTSTRAP_PKEX) {
|
|
wpa_printf(MSG_DEBUG,
|
|
"DPP: Identified bootstrap info not for PKEX");
|
|
return -1;
|
|
}
|
|
wpa_s->dpp_pkex_bi = own_bi;
|
|
own_bi->pkex_t = 0; /* clear pending errors on new code */
|
|
|
|
os_free(wpa_s->dpp_pkex_identifier);
|
|
wpa_s->dpp_pkex_identifier = NULL;
|
|
pos = os_strstr(cmd, " identifier=");
|
|
if (pos) {
|
|
pos += 12;
|
|
end = os_strchr(pos, ' ');
|
|
if (!end)
|
|
return -1;
|
|
wpa_s->dpp_pkex_identifier = os_malloc(end - pos + 1);
|
|
if (!wpa_s->dpp_pkex_identifier)
|
|
return -1;
|
|
os_memcpy(wpa_s->dpp_pkex_identifier, pos, end - pos);
|
|
wpa_s->dpp_pkex_identifier[end - pos] = '\0';
|
|
}
|
|
|
|
pos = os_strstr(cmd, " code=");
|
|
if (!pos)
|
|
return -1;
|
|
os_free(wpa_s->dpp_pkex_code);
|
|
wpa_s->dpp_pkex_code = os_strdup(pos + 6);
|
|
if (!wpa_s->dpp_pkex_code)
|
|
return -1;
|
|
|
|
if (os_strstr(cmd, " init=1")) {
|
|
struct wpabuf *msg;
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Initiating PKEX");
|
|
dpp_pkex_free(wpa_s->dpp_pkex);
|
|
wpa_s->dpp_pkex = dpp_pkex_init(wpa_s, own_bi, wpa_s->own_addr,
|
|
wpa_s->dpp_pkex_identifier,
|
|
wpa_s->dpp_pkex_code);
|
|
if (!wpa_s->dpp_pkex)
|
|
return -1;
|
|
|
|
msg = wpa_s->dpp_pkex->exchange_req;
|
|
wait_time = wpa_s->max_remain_on_chan;
|
|
if (wait_time > 2000)
|
|
wait_time = 2000;
|
|
/* TODO: Which channel to use? */
|
|
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR
|
|
" freq=%u type=%d",
|
|
MAC2STR(broadcast), 2437, DPP_PA_PKEX_EXCHANGE_REQ);
|
|
offchannel_send_action(wpa_s, 2437, broadcast, wpa_s->own_addr,
|
|
broadcast,
|
|
wpabuf_head(msg), wpabuf_len(msg),
|
|
wait_time, wpas_dpp_tx_pkex_status, 0);
|
|
}
|
|
|
|
/* TODO: Support multiple PKEX info entries */
|
|
|
|
os_free(wpa_s->dpp_pkex_auth_cmd);
|
|
wpa_s->dpp_pkex_auth_cmd = os_strdup(cmd);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
int wpas_dpp_pkex_remove(struct wpa_supplicant *wpa_s, const char *id)
|
|
{
|
|
unsigned int id_val;
|
|
|
|
if (os_strcmp(id, "*") == 0) {
|
|
id_val = 0;
|
|
} else {
|
|
id_val = atoi(id);
|
|
if (id_val == 0)
|
|
return -1;
|
|
}
|
|
|
|
if ((id_val != 0 && id_val != 1) || !wpa_s->dpp_pkex_code)
|
|
return -1;
|
|
|
|
/* TODO: Support multiple PKEX entries */
|
|
os_free(wpa_s->dpp_pkex_code);
|
|
wpa_s->dpp_pkex_code = NULL;
|
|
os_free(wpa_s->dpp_pkex_identifier);
|
|
wpa_s->dpp_pkex_identifier = NULL;
|
|
os_free(wpa_s->dpp_pkex_auth_cmd);
|
|
wpa_s->dpp_pkex_auth_cmd = NULL;
|
|
wpa_s->dpp_pkex_bi = NULL;
|
|
/* TODO: Remove dpp_pkex only if it is for the identified PKEX code */
|
|
dpp_pkex_free(wpa_s->dpp_pkex);
|
|
wpa_s->dpp_pkex = NULL;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int wpas_dpp_init(struct wpa_supplicant *wpa_s)
|
|
{
|
|
u8 adv_proto_id[7];
|
|
|
|
adv_proto_id[0] = WLAN_EID_VENDOR_SPECIFIC;
|
|
adv_proto_id[1] = 5;
|
|
WPA_PUT_BE24(&adv_proto_id[2], OUI_WFA);
|
|
adv_proto_id[5] = DPP_OUI_TYPE;
|
|
adv_proto_id[6] = 0x01;
|
|
|
|
if (gas_server_register(wpa_s->gas_server, adv_proto_id,
|
|
sizeof(adv_proto_id), wpas_dpp_gas_req_handler,
|
|
wpas_dpp_gas_status_handler, wpa_s) < 0)
|
|
return -1;
|
|
dl_list_init(&wpa_s->dpp_bootstrap);
|
|
dl_list_init(&wpa_s->dpp_configurator);
|
|
wpa_s->dpp_init_done = 1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
void wpas_dpp_deinit(struct wpa_supplicant *wpa_s)
|
|
{
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
os_free(wpa_s->dpp_config_obj_override);
|
|
wpa_s->dpp_config_obj_override = NULL;
|
|
os_free(wpa_s->dpp_discovery_override);
|
|
wpa_s->dpp_discovery_override = NULL;
|
|
os_free(wpa_s->dpp_groups_override);
|
|
wpa_s->dpp_groups_override = NULL;
|
|
wpa_s->dpp_ignore_netaccesskey_mismatch = 0;
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
|
if (!wpa_s->dpp_init_done)
|
|
return;
|
|
eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
|
|
offchannel_send_action_done(wpa_s);
|
|
wpas_dpp_listen_stop(wpa_s);
|
|
dpp_bootstrap_del(wpa_s, 0);
|
|
dpp_configurator_del(wpa_s, 0);
|
|
dpp_auth_deinit(wpa_s->dpp_auth);
|
|
wpa_s->dpp_auth = NULL;
|
|
wpas_dpp_pkex_remove(wpa_s, "*");
|
|
wpa_s->dpp_pkex = NULL;
|
|
os_memset(wpa_s->dpp_intro_bssid, 0, ETH_ALEN);
|
|
os_free(wpa_s->dpp_configurator_params);
|
|
wpa_s->dpp_configurator_params = NULL;
|
|
}
|