Skip to contentSkip to conversation

dpp-util: add dpp_point_to_asn1

PATCH Superseded James Prestwood 1 participant 11 messages Dec 15, 2021 Kbuild

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore

James Prestwood

author
#0 lore raw

PATCH v3 1/11 dpp-util: add dpp_point_to_asn1

Converts an l_ecc_point to the DPP ASN.1 structure.

---
 src/dpp-util.c | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/dpp-util.h |  2 ++
 2 files changed, 91 insertions(+)
src/dpp-util.c +89 -0
index 0b355311..e5f76bfd 100644
@@ -361,3 +361,92 @@ bool dpp_derive_ke(const uint8_t *i_nonce, const uint8_t *r_nonce,
 	/* ke = HKDF-Expand(bk, "DPP Key", length) */
 	return hkdf_expand(sha, bk, key_len, "DPP Key", ke, key_len);
 }
+
+#define ASN1_ID(class, pc, tag)	(((class) << 6) | ((pc) << 5) | (tag))
+
+#define ASN1_ID_SEQUENCE	ASN1_ID(0, 1, 0x10)
+#define ASN1_ID_BIT_STRING	ASN1_ID(0, 0, 0x03)
+#define ASN1_ID_OID		ASN1_ID(0, 0, 0x06)
+
+static uint8_t ec_oid[] = { 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01 };
+static uint8_t ec_p256_oid[] = { 0x2a, 0x86, 0x48, 0xce,
+				0x3d, 0x03, 0x01, 0x07 };
+static uint8_t ec_p384_oid[] = { 0x2B, 0x81, 0x04, 0x00, 0x22 };
+static uint8_t ec_p512_oid[] = { 0x2B, 0x81, 0x04, 0x00, 0x23 };
+
+uint8_t *dpp_point_to_asn1(const struct l_ecc_point *p, size_t *len_out)
+{
+	uint8_t *asn1;
+	uint8_t *ptr;
+	uint8_t *type_oid;
+	size_t type_oid_len;
+	const struct l_ecc_curve *curve = l_ecc_point_get_curve(p);
+	ssize_t key_size = l_ecc_curve_get_scalar_bytes(curve);
+	uint64_t x[L_ECC_MAX_DIGITS];
+	ssize_t ret;
+	size_t len;
+
+	switch (key_size) {
+	case 32:
+		type_oid = ec_p256_oid;
+		type_oid_len = sizeof(ec_p256_oid);
+		break;
+	case 48:
+		type_oid = ec_p384_oid;
+		type_oid_len = sizeof(ec_p384_oid);
+		break;
+	case 64:
+		type_oid = ec_p512_oid;
+		type_oid_len = sizeof(ec_p512_oid);
+		break;
+	default:
+		return NULL;
+	}
+
+	ret = l_ecc_point_get_x(p, x, sizeof(x));
+	if (ret < 0 || ret != key_size)
+		return NULL;
+
+	len = 2 + sizeof(ec_oid) + 2 + type_oid_len + 2 + key_size + 4;
+
+	if (L_WARN_ON(len > 128))
+		return NULL;
+
+	asn1 = l_malloc(len + 2);
+	ptr = asn1;
+
+	*ptr++ = ASN1_ID_SEQUENCE;
+	/* Length of both OIDs and key, plus tag/len bytes */
+	*ptr++ = len;
+
+	*ptr++ = ASN1_ID_SEQUENCE;
+
+	len = sizeof(ec_oid) + type_oid_len + 4;
+
+	if (L_WARN_ON(len > 128))
+		return NULL;
+
+	*ptr++ = len;
+
+	*ptr++ = ASN1_ID_OID;
+	*ptr++ = sizeof(ec_oid);
+	memcpy(ptr, ec_oid, sizeof(ec_oid));
+	ptr += sizeof(ec_oid);
+
+	*ptr++ = ASN1_ID_OID;
+	*ptr++ = type_oid_len;
+	memcpy(ptr, type_oid, type_oid_len);
+	ptr += type_oid_len;
+
+	*ptr++ = ASN1_ID_BIT_STRING;
+	*ptr++ = key_size + 2;
+	*ptr++ = 0x00;
+	*ptr++ = 0x03;
+	memcpy(ptr, x, key_size);
+	ptr += key_size;
+
+	if (len_out)
+		*len_out = ptr - asn1;
+
+	return asn1;
+}
src/dpp-util.h +2 -0
index 6d0dcccb..0c22e9b7 100644
@@ -97,3 +97,5 @@ struct l_ecc_scalar *dpp_derive_k2(const struct l_ecc_point *i_proto_public,
 bool dpp_derive_ke(const uint8_t *i_nonce, const uint8_t *r_nonce,
 				struct l_ecc_scalar *m, struct l_ecc_scalar *n,
 				void *ke);
+
+uint8_t *dpp_point_to_asn1(const struct l_ecc_point *p, size_t *len_out);
Signature · 1 line
2.31.1
author
#1 lore raw

PATCH v3 2/11 dbus: add DPP interface

---
 src/dbus.h | 1 +
 1 file changed, 1 insertion(+)
src/dbus.h +1 -0
index 7703b37f..bbc76608 100644
@@ -43,6 +43,7 @@
 #define IWD_STATION_DIAGNOSTIC_INTERFACE "net.connman.iwd.StationDiagnostic"
 #define IWD_AP_DIAGNOSTIC_INTERFACE "net.connman.iwd.AccessPointDiagnostic"
 #define IWD_STATION_DEBUG_INTERFACE "net.connman.iwd.StationDebug"
+#define IWD_DPP_INTERFACE "net.connman.iwd.DeviceProvisioning"
 
 #define IWD_BASE_PATH "/net/connman/iwd"
 #define IWD_AGENT_MANAGER_PATH IWD_BASE_PATH
Signature · 1 line
2.31.1
author
#2 lore raw

PATCH v3 3/11 dpp: initial skeleton DPP module

In reply to James Prestwood
---
 Makefile.am |   1 +
 src/dpp.c   | 124 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 125 insertions(+)
 create mode 100644 src/dpp.c

v3:
* Create on UP/DOWN as well as NEW/DEL

Makefile.am +1 -0
index f408e462..332e5e4c 100644
@@ -250,6 +250,7 @@ src_iwd_SOURCES = src/main.c linux/nl80211.h src/iwd.h src/missing.h \
 					src/offchannel.h src/offchannel.c \
 					src/dpp-util.h src/dpp-util.c \
 					src/json.h src/json.c \
+					src/dpp.c \
 					$(eap_sources) \
 					$(builtin_sources)
 
src/dpp.c new file +124 -0

124 lines not on this page · raw message

Signature · 1 line
2.31.1
author
#3 lore raw

PATCH v3 4/11 dpp: generate URI on StartEnrollee

In reply to James Prestwood

Generates the required keys, hashes, and sets the Uri property

---
 src/dpp.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 70 insertions(+), 2 deletions(-)

v3:
* Move curve/key init into dpp_create
* Removed StartEnrollee argument entirely
* Removed Uri property change

src/dpp.c +70 -2
index e70a2357..dbab71c1 100644
@@ -29,11 +29,25 @@
 #include "src/dbus.h"
 #include "src/netdev.h"
 #include "src/module.h"
+#include "src/dpp-util.h"
+#include "src/band.h"
 
 static uint32_t netdev_watch;
 
 struct dpp_sm {
 	struct netdev *netdev;
+	char *uri;
+
+	uint64_t wdev_id;
+
+	uint8_t *pub_asn1;
+	size_t pub_asn1_len;
+	uint8_t pub_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;
 };
 
 static void dpp_create(struct netdev *netdev)
@@ -42,13 +56,49 @@ static void dpp_create(struct netdev *netdev)
 	struct dpp_sm *dpp = l_new(struct dpp_sm, 1);
 
 	dpp->netdev = 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);
+
+	l_ecdh_generate_key_pair(dpp->curve, &dpp->boot_private,
+					&dpp->boot_public);
+
+	dpp->pub_asn1 = dpp_point_to_asn1(dpp->boot_public, &dpp->pub_asn1_len);
+
+	dpp_hash(L_CHECKSUM_SHA256, dpp->pub_boot_hash, 1,
+			dpp->pub_asn1, dpp->pub_asn1_len);
 
 	l_dbus_object_add_interface(dbus, netdev_get_path(netdev),
 					IWD_DPP_INTERFACE, dpp);
 }
 
+static void dpp_reset(struct dpp_sm *dpp)
+{
+	if (dpp->uri) {
+		l_free(dpp->uri);
+		dpp->uri = NULL;
+	}
+
+	if (dpp->pub_asn1) {
+		l_free(dpp->pub_asn1);
+		dpp->pub_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;
+	}
+}
+
 static void dpp_free(struct dpp_sm *dpp)
 {
+	dpp_reset(dpp);
+
 	l_free(dpp);
 }
 
@@ -78,14 +128,32 @@ static struct l_dbus_message *dpp_dbus_start_enrollee(struct l_dbus *dbus,
 						struct l_dbus_message *message,
 						void *user_data)
 {
-	return dbus_error_not_supported(message);
+	struct dpp_sm *dpp = user_data;
+	uint32_t freq = band_channel_to_freq(6, BAND_FREQ_2_4_GHZ);
+	struct l_dbus_message *reply;
+
+	dpp->uri = dpp_generate_uri(dpp->pub_asn1, dpp->pub_asn1_len, 2,
+					netdev_get_address(dpp->netdev), &freq,
+					1, NULL, NULL);
+
+	l_debug("DPP Start Enrollee: %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_stop(struct l_dbus *dbus,
 						struct l_dbus_message *message,
 						void *user_data)
 {
-	return dbus_error_not_supported(message);
+	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)
Signature · 1 line
2.31.1
author
#4 lore raw

PATCH v3 5/11 dpp-util: add dpp status and attribute types

In reply to James Prestwood
---
 src/dpp-util.h | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
src/dpp-util.h +40 -0
index 0c22e9b7..e7e73071 100644
@@ -22,6 +22,46 @@
 struct l_ecc_point;
 struct l_ecc_scalar;
 
+enum dpp_frame_type {
+	DPP_FRAME_AUTHENTICATION_REQUEST	= 0,
+	DPP_FRAME_AUTHENTICATION_RESPONSE	= 1,
+	DPP_FRAME_AUTHENTICATION_CONFIRM	= 2,
+	/* 3 - 4 reserved */
+	DPP_FRAME_PEER_DISCOVERY_REQUEST	= 5,
+	DPP_FRAME_PEER_DISCOVERY_RESPONSE	= 6,
+	DPP_FRAME_PKEX_VERSION1_XCHG_REQUST	= 7,
+	DPP_FRAME_PKEX_XCHG_RESPONSE		= 8,
+	DPP_FRAME_PKEX_COMMIT_REVEAL_REQUEST	= 9,
+	DPP_FRAME_PKEX_COMMIT_REVEAP_RESPONSE	= 10,
+	DPP_FRAME_CONFIGURATION_RESULT		= 11,
+	DPP_FRAME_CONNECTION_STATUS_RESULT	= 12,
+	DPP_FRAME_PRESENCE_ANNOUNCEMENT		= 13,
+	DPP_FRAME_RECONF_ANNOUNCEMENT		= 14,
+	DPP_FRAME_RECONF_AUTHENTICATION_REQUEST	= 15,
+	DPP_FRAME_RECONF_AUTHENTICATION_RESPONSE = 16,
+	DPP_FRAME_RECONF_AUTHENTICATION_CONFIRM = 17,
+	DPP_FRAME_PKEX_XCHG_REQUEST		= 18,
+	/* 19 - 255 reserved */
+};
+
+enum dpp_status {
+	DPP_STATUS_OK,
+	DPP_STATUS_NOT_COMPATIBLE,
+	DPP_STATUS_AUTH_FAILURE,
+	DPP_STATUS_BAD_CODE,
+	DPP_STATUS_BAD_GROUP,
+	DPP_STATUS_CONFIGURE_FAILURE,
+	DPP_STATUS_RESPONSE_PENDING,
+	DPP_STATUS_INVALID_CONNECTOR,
+	DPP_STATUS_NO_MATCH,
+	DPP_STATUS_CONFIG_REJECTED,
+	DPP_STATUS_NO_AP,
+	DPP_STATUS_CONFIGURE_PENDING,
+	DPP_STATUS_CSR_NEEDED,
+	DPP_STATUS_CSR_BAD,
+	DPP_STATUS_NEW_KEY_NEEDED,
+};
+
 enum dpp_attribute_type {
 	/* 0000 - 0FFF reserved */
 	DPP_ATTR_STATUS				= 0x1000,
Signature · 1 line
2.31.1
author
#5 lore raw

PATCH v3 6/11 dpp: send presence announcements on StartEnrollee

In reply to James Prestwood

The presence procedure implemented is a far cry from what the spec actually wants. There are two reason for this: a) the kernels offchannel support is not at a level where it will work without rather annoying work arounds, and b) doing the procedure outlined in the spec will result in terrible discovery performance.

Because of this a simpler single channel announcement is done by default and the full presence procedure is left out until/if it is needed.

---
 src/dpp.c | 242 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 242 insertions(+)

v3:
* Removed old headers left from previous patch set
* memdup freqs since its on the stack
* Few other minor fixes

src/dpp.c +242 -0
index dbab71c1..13a1ed75 100644
@@ -24,15 +24,32 @@
 #include <config.h>
 #endif
 
+#include <errno.h>
+
 #include <ell/ell.h>
 
+#include "linux/nl80211.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"
 
 static uint32_t netdev_watch;
+static struct l_genl_family *nl80211;
+static uint8_t broadcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+
+enum dpp_state {
+	DPP_STATE_NOTHING,
+	DPP_STATE_PRESENCE,
+};
 
 struct dpp_sm {
 	struct netdev *netdev;
@@ -48,14 +65,119 @@ struct dpp_sm {
 	size_t nonce_len;
 	struct l_ecc_scalar *boot_private;
 	struct l_ecc_point *boot_public;
+
+	enum dpp_state state;
+
+	uint32_t *freqs;
+	size_t freqs_len;
+	size_t freqs_idx;
+	uint32_t dwell;
+	uint32_t current_freq;
+	struct scan_freq_set *presence_list;
+
+	uint32_t offchannel_id;
 };
 
+static void dpp_send_frame_cb(struct l_genl_msg *msg, void *user_data)
+{
+	if (l_genl_msg_get_error(msg) < 0)
+		l_error("Error sending frame");
+}
+
+static void dpp_send_frame(uint64_t wdev_id, struct iovec *iov, size_t iov_len,
+			uint32_t freq)
+{
+	struct l_genl_msg *msg;
+
+	msg = l_genl_msg_new_sized(NL80211_CMD_FRAME, 512);
+	l_genl_msg_append_attr(msg, NL80211_ATTR_WDEV, 8, &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, NULL, NULL))
+		l_error("Could not send CMD_FRAME");
+}
+
+static size_t dpp_append_attr(uint8_t *to, enum dpp_attribute_type type,
+				void *attr, size_t attr_len)
+{
+	l_put_le16(type, to);
+	l_put_le16(attr_len, to + 2);
+	memcpy(to + 4, attr, attr_len);
+
+	return attr_len + 4;
+}
+
+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 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->pub_asn1, dpp->pub_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 presense annoucement on frequency %u and waiting %u",
+		dpp->current_freq, dpp->dwell);
+
+	dpp_send_frame(netdev_get_wdev_id(netdev), iov, 2, dpp->current_freq);
+}
+
+static void dpp_roc_started(void *user_data)
+{
+	struct dpp_sm *dpp = user_data;
+
+	dpp_presence_announce(dpp);
+}
+
 static void dpp_create(struct netdev *netdev)
 {
 	struct l_dbus *dbus = dbus_get_bus();
 	struct dpp_sm *dpp = l_new(struct dpp_sm, 1);
 
 	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);
@@ -93,12 +215,22 @@ static void dpp_reset(struct dpp_sm *dpp)
 		l_ecc_scalar_free(dpp->boot_private);
 		dpp->boot_private = NULL;
 	}
+
+	dpp->state = DPP_STATE_NOTHING;
 }
 
 static void dpp_free(struct dpp_sm *dpp)
 {
 	dpp_reset(dpp);
 
+	if (dpp->freqs)
+		l_free(dpp->freqs);
+
+	if (dpp->offchannel_id) {
+		offchannel_cancel(dpp->wdev_id, dpp->offchannel_id);
+		dpp->offchannel_id = 0;
+	}
+
 	l_free(dpp);
 }
 
@@ -124,6 +256,98 @@ static void dpp_netdev_watch(struct netdev *netdev,
 	}
 }
 
+static void dpp_presence_timeout(int error, void *user_data)
+{
+	struct dpp_sm *dpp = user_data;
+
+	if (dpp->state != DPP_STATE_PRESENCE) {
+		l_debug("DPP state changed, stopping presence announcements");
+		dpp->freqs_idx = 0;
+		return;
+	}
+
+	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);
+
+	dpp->offchannel_id = offchannel_start(netdev_get_wdev_id(dpp->netdev),
+			dpp->current_freq, dpp->dwell, dpp_roc_started,
+			dpp, dpp_presence_timeout);
+}
+
+/*
+ * 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_announcements(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->offchannel_id = offchannel_start(netdev_get_wdev_id(dpp->netdev),
+			dpp->current_freq, dpp->dwell, dpp_roc_started,
+			dpp, dpp_presence_timeout);
+}
+
 static struct l_dbus_message *dpp_dbus_start_enrollee(struct l_dbus *dbus,
 						struct l_dbus_message *message,
 						void *user_data)
@@ -132,12 +356,24 @@ static struct l_dbus_message *dpp_dbus_start_enrollee(struct l_dbus *dbus,
 	uint32_t freq = band_channel_to_freq(6, BAND_FREQ_2_4_GHZ);
 	struct l_dbus_message *reply;
 
+	if (dpp->state != DPP_STATE_NOTHING)
+		return dbus_error_busy(message);
+
 	dpp->uri = dpp_generate_uri(dpp->pub_asn1, dpp->pub_asn1_len, 2,
 					netdev_get_address(dpp->netdev), &freq,
 					1, NULL, NULL);
 
+	dpp->state = DPP_STATE_PRESENCE;
+
 	l_debug("DPP Start Enrollee: %s", dpp->uri);
 
+	/*
+	 * 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_announcements(dpp, &freq, 1);
+
 	reply = l_dbus_message_new_method_return(message);
 
 	l_dbus_message_set_arguments(reply, "s", dpp->uri);
@@ -173,6 +409,12 @@ static void dpp_destroy_interface(void *user_data)
 
 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,
Signature · 1 line
2.31.1
author
#6 lore raw

PATCH v3 7/11 dpp: add DPP authentication protocol

In reply to James Prestwood

This implements the DPP protocol used to authenticate to a DPP configurator.

Note this is not a full implementation of the protocol and there are a few missing features which will be added as needed:

- Mutual authentication (needed for BLE bootstrapping)
- Configurator support
- Initiator role

---
 src/dpp.c | 571 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 571 insertions(+)
src/dpp.c +571 -0
index 13a1ed75..ec6ddc0c 100644
@@ -41,6 +41,9 @@
 #include "src/ie.h"
 #include "src/iwd.h"
 #include "src/util.h"
+#include "src/crypto.h"
+#include "src/mpdu.h"
+#include "ell/useful.h"
 
 static uint32_t netdev_watch;
 static struct l_genl_family *nl80211;
@@ -49,6 +52,7 @@ static uint8_t broadcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 enum dpp_state {
 	DPP_STATE_NOTHING,
 	DPP_STATE_PRESENCE,
+	DPP_STATE_AUTHENTICATING,
 };
 
 struct dpp_sm {
@@ -76,6 +80,18 @@ struct dpp_sm {
 	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];
+
+	uint64_t ke[L_ECC_MAX_DIGITS];
+	uint64_t k2[L_ECC_MAX_DIGITS];
+
+	struct l_ecc_scalar *proto_private;
+	struct l_ecc_point *proto_public;
+
+	struct l_ecc_point *i_proto_public;
 };
 
 static void dpp_send_frame_cb(struct l_genl_msg *msg, void *user_data)
@@ -101,6 +117,34 @@ static void dpp_send_frame(uint64_t wdev_id, struct iovec *iov, size_t iov_len,
 		l_error("Could not send CMD_FRAME");
 }
 
+static uint8_t *dpp_unwrap_attr(enum dpp_frame_type type, const void *start,
+				const void *key, size_t key_len,
+				const uint8_t *wrapped, size_t wrapped_len,
+				size_t *unwrapped_len)
+{
+	uint8_t ad0[] = { 0x50, 0x6f, 0x9a, 0x1a, 0x01, type };
+	struct iovec ad[2];
+	uint8_t *unwrapped;
+
+	ad[0].iov_base = ad0;
+	ad[0].iov_len = sizeof(ad0);
+
+	ad[1].iov_base = (void *)start;
+	ad[1].iov_len = ((wrapped - 4) - ((const uint8_t *)start));
+
+	unwrapped = l_malloc(wrapped_len - 16);
+
+	if (!aes_siv_decrypt(key, key_len, wrapped, wrapped_len, ad, 2,
+				unwrapped)) {
+		l_free(unwrapped);
+		return NULL;
+	}
+
+	*unwrapped_len = wrapped_len - 16;
+
+	return unwrapped;
+}
+
 static size_t dpp_append_attr(uint8_t *to, enum dpp_attribute_type type,
 				void *attr, size_t attr_len)
 {
@@ -111,6 +155,93 @@ static size_t dpp_append_attr(uint8_t *to, enum dpp_attribute_type type,
 	return attr_len + 4;
 }
 
+/*
+ * Encrypt DPP attributes encapsulated in DPP wrapped data.
+ *
+ * hdr - pointer to start of OUI, or NULL
+ * wrap_start - pointer to the start of wrapped data attribute
+ * to - buffer to encrypt data.
+ * to_len - size of 'to'
+ * key - key used to encrypt
+ * key_len - size of 'key'
+ * num_attrs - number of attributes listed (type, length, data triplets)
+ * ... - List of attributes, Type, Length, and data
+ */
+static size_t dpp_append_wrapped_data(uint8_t *hdr, uint8_t *wrap_start,
+					uint8_t *to, size_t to_len,
+					const void *key, size_t key_len,
+					size_t num_attrs, ...)
+{
+	size_t i;
+	size_t attrs_len = 0;
+	_auto_(l_free) uint8_t *plaintext = NULL;
+	uint8_t *ptr;
+	struct iovec ad[2];
+	size_t ad_size = 0;
+	va_list va;
+
+	if (hdr) {
+		ad[0].iov_base = hdr;
+		ad[0].iov_len = 6;
+		ad_size++;
+	}
+
+	va_start(va, num_attrs);
+
+	/* Count up total attributes length */
+	for (i = 0; i < num_attrs; i++) {
+		va_arg(va, enum dpp_attribute_type);
+		attrs_len += va_arg(va, size_t) + 4;
+		va_arg(va, void*);
+	}
+
+	if (to_len < attrs_len + 4 + 16)
+		return false;
+
+	plaintext = l_malloc(attrs_len);
+
+	ptr = plaintext;
+
+	va_end(va);
+
+	va_start(va, num_attrs);
+
+	/* Build up plaintext attributes */
+	for (i = 0; i < num_attrs; i++) {
+		enum dpp_attribute_type type = va_arg(va,
+						enum dpp_attribute_type);
+		size_t l = va_arg(va, size_t);
+		void *p = va_arg(va, void *);
+
+		l_put_le16(type, ptr);
+		ptr += 2;
+		l_put_le16(l, ptr);
+		ptr += 2;
+		memcpy(ptr, p, l);
+		ptr += l;
+	}
+
+	va_end(va);
+
+	ptr = to;
+
+	l_put_le16(DPP_ATTR_WRAPPED_DATA, ptr);
+	ptr += 2;
+	l_put_le16(attrs_len + 16, ptr);
+	ptr += 2;
+
+	if (wrap_start) {
+		ad[1].iov_base = wrap_start;
+		ad[1].iov_len = ptr - wrap_start - 4;
+		ad_size++;
+	}
+
+	aes_siv_encrypt(key, key_len, plaintext, attrs_len,
+				ad, ad_size, ptr);
+
+	return attrs_len + 4 + 16;
+}
+
 static size_t dpp_build_header(const uint8_t *src, const uint8_t *dest,
 				enum dpp_frame_type type,
 				uint8_t buf[static 32])
@@ -135,6 +266,439 @@ static size_t dpp_build_header(const uint8_t *src, const uint8_t *dest,
 	return ptr - buf;
 }
 
+static void dpp_free_auth_data(struct dpp_sm *dpp)
+{
+	if (dpp->proto_public) {
+		l_ecc_point_free(dpp->proto_public);
+		dpp->proto_public = NULL;
+	}
+
+	if (dpp->proto_private) {
+		l_ecc_scalar_free(dpp->proto_private);
+		dpp->proto_private = NULL;
+	}
+
+	if (dpp->i_proto_public) {
+		l_ecc_point_free(dpp->i_proto_public);
+		dpp->i_proto_public = NULL;
+	}
+}
+
+static void send_authenticate_response(struct dpp_sm *dpp, void *r_auth)
+{
+	uint8_t hdr[32];
+	uint8_t attrs[512];
+	uint8_t *ptr = attrs;
+	uint8_t status = DPP_STATUS_OK;
+	uint64_t r_proto_key[L_ECC_MAX_DIGITS * 2];
+	uint8_t version = 2;
+	uint8_t r_capabilities = 0x01;
+	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->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->pub_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,
+					r_auth, dpp->key_len);
+	aes_siv_encrypt(dpp->ke, dpp->key_len, wrapped2_plaintext,
+					dpp->key_len + 4, NULL, 0, wrapped2);
+
+	wrapped2_len += 16;
+
+	/* Wrap up primary data */
+	ptr += dpp_append_wrapped_data(hdr + 26, attrs,
+			ptr, 512, 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, 1, &r_capabilities,
+			DPP_ATTR_WRAPPED_DATA, wrapped2_len, wrapped2);
+
+	iov[1].iov_base = attrs;
+	iov[1].iov_len = ptr - attrs;
+	iov[2].iov_base = NULL;
+
+	dpp_send_frame(netdev_get_wdev_id(dpp->netdev), iov, 2,
+				dpp->current_freq);
+}
+
+static void authenticate_confirm(struct dpp_sm *dpp, const uint8_t *from,
+					const uint8_t *attrs, size_t attrs_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, *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;
+
+	if (dpp->state != DPP_STATE_AUTHENTICATING)
+		return;
+
+	if (memcmp(from, dpp->auth_addr, 6))
+		return;
+
+	l_debug("authenticate confirm");
+
+	dpp_attr_iter_init(&iter, attrs, attrs_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_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(DPP_FRAME_AUTHENTICATION_CONFIRM, attrs,
+			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->proto_public, dpp->i_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");
+
+	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 r_capabilities = 0x01;
+	uint8_t s = status;
+	struct iovec iov[3];
+
+	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->pub_boot_hash, 32);
+
+	ptr += dpp_append_attr(ptr, DPP_ATTR_PROTOCOL_VERSION, &version, 1);
+
+	ptr += dpp_append_wrapped_data(hdr + 26, 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, 1, &r_capabilities);
+
+	iov[1].iov_base = attrs;
+	iov[1].iov_len = ptr - attrs;
+	iov[2].iov_base = NULL;
+
+	dpp_send_frame(netdev_get_wdev_id(dpp->netdev), iov, 2,
+				dpp->current_freq);
+}
+
+static void authenticate_request(struct dpp_sm *dpp, const uint8_t *from,
+					const uint8_t *attrs, size_t attrs_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 uint8_t *wrapped = NULL;
+	const uint8_t *i_nonce = NULL;
+	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];
+	uint64_t r_auth[L_ECC_MAX_DIGITS];
+
+	if (dpp->state != DPP_STATE_PRESENCE)
+		return;
+
+	l_debug("authenticate request");
+
+	dpp_attr_iter_init(&iter, attrs, attrs_len);
+
+	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;
+		/*
+		 * TODO: Go on this channel for remainder of auth protocol.
+		 *
+		 * "the Responder determines whether it can use the requested
+		 * channel for the following exchanges. If so, it sends the DPP
+		 * Authentication Response frame on that channel. If not, it
+		 * discards the DPP Authentication Request frame without
+		 * replying to it."
+		 *
+		 * For the time being this feature is not being implemented and
+		 * the frame will be dropped.
+		 */
+		case DPP_ATTR_CHANNEL:
+			return;
+		default:
+			break;
+		}
+	}
+
+	if (!r_boot || !i_boot || !i_proto || !wrapped)
+		goto auth_request_failed;
+
+	if (r_boot_len != 32 || memcmp(dpp->pub_boot_hash,
+					r_boot, r_boot_len)) {
+		l_debug("Responder boot key hash failed to verify");
+		goto auth_request_failed;
+	}
+
+	dpp->i_proto_public = l_ecc_point_from_data(dpp->curve,
+						L_ECC_POINT_TYPE_FULL,
+						i_proto, i_proto_len);
+	if (!dpp->i_proto_public) {
+		l_debug("Initiators protocol key invalid");
+		goto auth_request_failed;
+	}
+
+	m = dpp_derive_k1(dpp->i_proto_public, dpp->boot_private, k1);
+	if (!m)
+		goto auth_request_failed;
+
+	unwrapped = dpp_unwrap_attr(DPP_FRAME_AUTHENTICATION_REQUEST, attrs, 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"
+			 */
+			if (!(l_get_u8(data) & 0x2)) {
+				l_debug("Initiator is not configurator");
+
+				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 %lu", 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 */
+
+	l_ecdh_generate_key_pair(dpp->curve, &dpp->proto_private,
+					&dpp->proto_public);
+
+	n = dpp_derive_k2(dpp->i_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->i_proto_public, dpp->proto_public,
+				dpp->boot_public, r_auth))
+		goto auth_request_failed;
+
+	memcpy(dpp->auth_addr, from, 6);
+
+	dpp->state = DPP_STATE_AUTHENTICATING;
+
+	send_authenticate_response(dpp, r_auth);
+
+	return;
+
+auth_request_failed:
+	dpp->state = DPP_STATE_PRESENCE;
+	dpp_free_auth_data(dpp);
+}
+
+static void dpp_handle_auth_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;
+
+	if (body_len < 8)
+		return;
+
+	ptr = body + 7;
+	body_len -= 7;
+
+	switch (*ptr) {
+	case DPP_FRAME_AUTHENTICATION_REQUEST:
+		authenticate_request(dpp, frame->address_2, ptr + 1,
+					body_len - 1);
+		break;
+	case DPP_FRAME_AUTHENTICATION_CONFIRM:
+		authenticate_confirm(dpp, frame->address_2, ptr + 1,
+					body_len - 1);
+		break;
+	default:
+		l_debug("Unhandled DPP frame %u", *ptr);
+		break;
+	}
+}
+
 static void dpp_presence_announce(struct dpp_sm *dpp)
 {
 	struct netdev *netdev = dpp->netdev;
@@ -174,6 +738,7 @@ 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_prefix[] = { 0x04, 0x09, 0x50, 0x6f, 0x9a, 0x1a, 0x01 };
 
 	dpp->netdev = netdev;
 	dpp->state = DPP_STATE_NOTHING;
@@ -192,6 +757,10 @@ static void dpp_create(struct netdev *netdev)
 
 	l_dbus_object_add_interface(dbus, netdev_get_path(netdev),
 					IWD_DPP_INTERFACE, dpp);
+
+	frame_watch_add(netdev_get_wdev_id(netdev), 0, 0x00d0, dpp_prefix,
+				sizeof(dpp_prefix), dpp_handle_auth_frame,
+				dpp, NULL);
 }
 
 static void dpp_reset(struct dpp_sm *dpp)
@@ -231,6 +800,8 @@ static void dpp_free(struct dpp_sm *dpp)
 		dpp->offchannel_id = 0;
 	}
 
+	dpp_free_auth_data(dpp);
+
 	l_free(dpp);
 }
 
Signature · 1 line
2.31.1
author
#7 lore raw

PATCH v3 8/11 dpp-util: add dpp_parse_configuration_object

In reply to James Prestwood

This parses the configuration JSON object from the configuration response. Only a minimal configuration object is supported for now.

---
 Makefile.am    |   3 +-
 src/dpp-util.c | 110 +++++++++++++++++++++++++++++++++++++++++++++++++
 src/dpp-util.h |  12 ++++++
 3 files changed, 124 insertions(+), 1 deletion(-)
Makefile.am +2 -1
index 332e5e4c..d079ba89 100644
@@ -552,7 +552,8 @@ unit_test_p2p_LDADD = $(ell_ldadd)
 
 unit_test_dpp_SOURCES = unit/test-dpp.c src/dpp-util.h src/dpp-util.c \
 				src/band.h src/band.c \
-				src/util.h src/util.c src/crypto.h src/crypto.c
+				src/util.h src/util.c src/crypto.h \
+				src/crypto.c src/json.h src/json.c
 unit_test_dpp_LDADD = $(ell_ldadd)
 
 unit_test_json_SOURCES = unit/test-json.c src/json.h src/json.c shared/jsmn.h
src/dpp-util.c +110 -0

122 lines not on this page · raw message

src/dpp-util.h +12 -0
index e7e73071..84404128 100644
@@ -100,6 +100,18 @@ enum dpp_attribute_type {
 	DPP_ATTR_CONFIGURATOR_NONCE		= 0x1022,
 };
 
+struct dpp_configuration {
+	uint8_t ssid[32];
+	size_t ssid_len;
+	uint32_t akm_suites;
+	char *passphrase;
+	char *psk;		/* hex string */
+};
+
+struct dpp_configuration *dpp_parse_configuration_object(const char *json,
+							size_t json_len);
+void dpp_configuration_free(struct dpp_configuration *conf);
+
 struct dpp_attr_iter {
 	const uint8_t *pos;
 	const uint8_t *end;
Signature · 1 line
2.31.1
author
#8 lore raw

PATCH v3 9/11 dpp: add support for configuration protocol

In reply to James Prestwood

This is a minimal implementation only supporting legacy network configuration, i.e. only SSID and PSK/passphrase are supported.

Missing features include:
- Fragmentation/comeback delay support
- DPP AKM support
- 8021x/PKEX support

---
 src/dpp.c | 297 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 297 insertions(+)
src/dpp.c +297 -0
index ec6ddc0c..af6a5fd0 100644
@@ -44,6 +44,8 @@
 #include "src/crypto.h"
 #include "src/mpdu.h"
 #include "ell/useful.h"
+#include "src/common.h"
+#include "src/storage.h"
 
 static uint32_t netdev_watch;
 static struct l_genl_family *nl80211;
@@ -53,6 +55,7 @@ enum dpp_state {
 	DPP_STATE_NOTHING,
 	DPP_STATE_PRESENCE,
 	DPP_STATE_AUTHENTICATING,
+	DPP_STATE_CONFIGURING,
 };
 
 struct dpp_sm {
@@ -84,6 +87,7 @@ struct dpp_sm {
 	uint8_t auth_addr[6];
 	uint8_t r_nonce[32];
 	uint8_t i_nonce[32];
+	uint8_t e_nonce[32];
 
 	uint64_t ke[L_ECC_MAX_DIGITS];
 	uint64_t k2[L_ECC_MAX_DIGITS];
@@ -92,6 +96,8 @@ struct dpp_sm {
 	struct l_ecc_point *proto_public;
 
 	struct l_ecc_point *i_proto_public;
+
+	uint8_t diag_token;
 };
 
 static void dpp_send_frame_cb(struct l_genl_msg *msg, void *user_data)
@@ -186,6 +192,13 @@ static size_t dpp_append_wrapped_data(uint8_t *hdr, uint8_t *wrap_start,
 		ad_size++;
 	}
 
+	/* The configuration result requires this zero-length data component */
+	if (hdr && hdr[5] == DPP_FRAME_CONFIGURATION_RESULT) {
+		ad[1].iov_base = NULL;
+		ad[1].iov_len = 0;
+		ad_size++;
+	}
+
 	va_start(va, num_attrs);
 
 	/* Count up total attributes length */
@@ -266,6 +279,284 @@ static size_t dpp_build_header(const uint8_t *src, const uint8_t *dest,
 	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_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;
+
+	ptr += dpp_append_wrapped_data(NULL, NULL, 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->wdev_id, 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, NULL, ptr, sizeof(attrs),
+			dpp->ke, dpp->key_len, 2,
+			DPP_ATTR_STATUS, 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->wdev_id, iov, 2, dpp->current_freq);
+}
+
+static void dpp_write_config(struct dpp_configuration *config)
+{
+	_auto_(l_free) char *ssid = l_malloc(config->ssid_len + 1);
+	_auto_(l_settings_free) struct l_settings *settings = l_settings_new();
+	_auto_(l_free) char *path;
+
+	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);
+	else if (config->psk)
+		l_settings_set_string(settings, "Security", "PreSharedKey",
+				config->psk);
+
+	l_debug("Storing credential for '%s(%s)'", ssid,
+						security_to_str(SECURITY_PSK));
+	storage_network_sync(SECURITY_PSK, ssid, settings);
+}
+
+static void dpp_handle_config_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;
+	uint8_t ad0[] = { 0x00, 0x10, 0x01, 0x00, 0x05 };
+	struct iovec ad = {
+		.iov_base = ad0,
+		.iov_len = 5
+	};
+
+	if (dpp->state != DPP_STATE_CONFIGURING)
+		return;
+
+	ptr += 2;
+
+	/*
+	 * Can a configuration request come from someone other than who you
+	 * authenticated to?
+	 */
+	if (memcmp(dpp->auth_addr, frame->address_2, 6))
+		return;
+
+	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;
+
+	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 = l_malloc(wrapped_len - 16);
+
+	aes_siv_decrypt(dpp->ke, dpp->key_len, wrapped, wrapped_len, &ad,
+				1, unwrapped);
+
+	wrapped_len -= 16;
+
+	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;
+	}
+
+	dpp_write_config(config);
+	/*
+	 * TODO: Depending on the info included in the configuration object a
+	 * limited scan could be issued to get autoconnect to trigger faster.
+	 * In addition this network may already be in past scan results and
+	 * could be joined immediately.
+	 *
+	 * For now just wait for autoconnect.
+	 */
+
+	dpp_configuration_free(config);
+
+	send_config_result(dpp, dpp->auth_addr);
+}
+
 static void dpp_free_auth_data(struct dpp_sm *dpp)
 {
 	if (dpp->proto_public) {
@@ -456,6 +747,8 @@ static void authenticate_confirm(struct dpp_sm *dpp, const uint8_t *from,
 
 	l_debug("Authentication successful");
 
+	dpp_configuration_start(dpp, from);
+
 	return;
 
 auth_confirm_failed:
@@ -739,6 +1032,7 @@ 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_prefix[] = { 0x04, 0x09, 0x50, 0x6f, 0x9a, 0x1a, 0x01 };
+	uint8_t dpp_conf_prefix[] = { 0x04, 0x0b };
 
 	dpp->netdev = netdev;
 	dpp->state = DPP_STATE_NOTHING;
@@ -761,6 +1055,9 @@ static void dpp_create(struct netdev *netdev)
 	frame_watch_add(netdev_get_wdev_id(netdev), 0, 0x00d0, dpp_prefix,
 				sizeof(dpp_prefix), dpp_handle_auth_frame,
 				dpp, NULL);
+	frame_watch_add(netdev_get_wdev_id(netdev), 0, 0x00d0, dpp_conf_prefix,
+				sizeof(dpp_conf_prefix),
+				dpp_handle_config_frame, dpp, NULL);
 }
 
 static void dpp_reset(struct dpp_sm *dpp)
Signature · 1 line
2.31.1
author
#9 lore raw

PATCH v3 10/11 dpp: handle protocol errors in ROC timeout

In reply to James Prestwood

This is a standing TODO of properly handling these timeouts but for now just treat any ROC timeout as an error if authenticating or configuring.

---
 src/dpp.c | 36 +++++++++++++++++++++++++++++++++---
 1 file changed, 33 insertions(+), 3 deletions(-)
src/dpp.c +33 -3
index af6a5fd0..2abbc3e6 100644
@@ -1128,10 +1128,34 @@ static void dpp_presence_timeout(int error, void *user_data)
 {
 	struct dpp_sm *dpp = user_data;
 
-	if (dpp->state != DPP_STATE_PRESENCE) {
-		l_debug("DPP state changed, stopping presence announcements");
-		dpp->freqs_idx = 0;
+	/*
+	 * 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 < 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:
+		/*
+		 * TODO: If either the auth or config protocol is running we
+		 * need to stay on channel until the specified timeouts.
+		 * Unfortunately the kernel makes this very inconvenient since
+		 * there is no way to stay on channel indefinitely or any way
+		 * of knowing what duration the kernel/card actually chooses.
+		 *
+		 * For now just treat this as a failure.
+		 */
+		goto protocol_failed;
 	}
 
 	dpp->freqs_idx++;
@@ -1149,6 +1173,12 @@ static void dpp_presence_timeout(int error, void *user_data)
 	dpp->offchannel_id = offchannel_start(netdev_get_wdev_id(dpp->netdev),
 			dpp->current_freq, dpp->dwell, dpp_roc_started,
 			dpp, dpp_presence_timeout);
+	return;
+
+protocol_failed:
+	dpp_reset(dpp);
+	dpp_free_auth_data(dpp);
+	return;
 }
 
 /*
Signature · 1 line
2.31.1
author
#10 lore raw

PATCH v3 11/11 doc: document DPP interface

In reply to James Prestwood
---
 doc/device-provisioning.txt | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 doc/device-provisioning.txt
doc/device-provisioning.txt new file +25 -0
new file mode 100644
index 00000000..3ac2d934
@@ -0,0 +1,25 @@
+Device Provisioning hierarchy
+=============================
+
+Service		net.connman.iwd
+Interface	net.connman.iwd.DeviceProvisioning [Experimental]
+Object path	/net/connman/iwd/{phy0,phy1,...}/{1,2,...}
+
+Methods		string StartEnrollee()
+
+			Start a DPP enrollee. Currently only station devices are
+			supported.
+
+			Returns the enrollees URI
+
+			Possible errors:	net.connman.iwd.InvalidArguments
+						net.connman.iwd.AlreadyExists
+						net.connman.iwd.NotAvailable
+
+		void Stop()
+
+			Stop an enrollee.
+
+			Possible errors:	net.connman.iwd.Busy
+						net.connman.iwd.Failed
+						net.connman.iwd.InvalidArguments
Signature · 1 line
2.31.1