Home | History | Annotate | Download | only in wps
      1 /*
      2  * Wi-Fi Protected Setup - common functionality
      3  * Copyright (c) 2008-2012, Jouni Malinen <j (at) w1.fi>
      4  *
      5  * This software may be distributed under the terms of the BSD license.
      6  * See README for more details.
      7  */
      8 
      9 #include "includes.h"
     10 
     11 #include "common.h"
     12 #include "common/defs.h"
     13 #include "common/ieee802_11_common.h"
     14 #include "crypto/aes_wrap.h"
     15 #include "crypto/crypto.h"
     16 #include "crypto/dh_group5.h"
     17 #include "crypto/sha1.h"
     18 #include "crypto/sha256.h"
     19 #include "crypto/random.h"
     20 #include "wps_i.h"
     21 #include "wps_dev_attr.h"
     22 
     23 
     24 void wps_kdf(const u8 *key, const u8 *label_prefix, size_t label_prefix_len,
     25 	     const char *label, u8 *res, size_t res_len)
     26 {
     27 	u8 i_buf[4], key_bits[4];
     28 	const u8 *addr[4];
     29 	size_t len[4];
     30 	int i, iter;
     31 	u8 hash[SHA256_MAC_LEN], *opos;
     32 	size_t left;
     33 
     34 	WPA_PUT_BE32(key_bits, res_len * 8);
     35 
     36 	addr[0] = i_buf;
     37 	len[0] = sizeof(i_buf);
     38 	addr[1] = label_prefix;
     39 	len[1] = label_prefix_len;
     40 	addr[2] = (const u8 *) label;
     41 	len[2] = os_strlen(label);
     42 	addr[3] = key_bits;
     43 	len[3] = sizeof(key_bits);
     44 
     45 	iter = (res_len + SHA256_MAC_LEN - 1) / SHA256_MAC_LEN;
     46 	opos = res;
     47 	left = res_len;
     48 
     49 	for (i = 1; i <= iter; i++) {
     50 		WPA_PUT_BE32(i_buf, i);
     51 		hmac_sha256_vector(key, SHA256_MAC_LEN, 4, addr, len, hash);
     52 		if (i < iter) {
     53 			os_memcpy(opos, hash, SHA256_MAC_LEN);
     54 			opos += SHA256_MAC_LEN;
     55 			left -= SHA256_MAC_LEN;
     56 		} else
     57 			os_memcpy(opos, hash, left);
     58 	}
     59 }
     60 
     61 
     62 int wps_derive_keys(struct wps_data *wps)
     63 {
     64 	struct wpabuf *pubkey, *dh_shared;
     65 	u8 dhkey[SHA256_MAC_LEN], kdk[SHA256_MAC_LEN];
     66 	const u8 *addr[3];
     67 	size_t len[3];
     68 	u8 keys[WPS_AUTHKEY_LEN + WPS_KEYWRAPKEY_LEN + WPS_EMSK_LEN];
     69 
     70 	if (wps->dh_privkey == NULL) {
     71 		wpa_printf(MSG_DEBUG, "WPS: Own DH private key not available");
     72 		return -1;
     73 	}
     74 
     75 	pubkey = wps->registrar ? wps->dh_pubkey_e : wps->dh_pubkey_r;
     76 	if (pubkey == NULL) {
     77 		wpa_printf(MSG_DEBUG, "WPS: Peer DH public key not available");
     78 		return -1;
     79 	}
     80 
     81 	wpa_hexdump_buf_key(MSG_DEBUG, "WPS: DH Private Key", wps->dh_privkey);
     82 	wpa_hexdump_buf(MSG_DEBUG, "WPS: DH peer Public Key", pubkey);
     83 	dh_shared = dh5_derive_shared(wps->dh_ctx, pubkey, wps->dh_privkey);
     84 	dh5_free(wps->dh_ctx);
     85 	wps->dh_ctx = NULL;
     86 	dh_shared = wpabuf_zeropad(dh_shared, 192);
     87 	if (dh_shared == NULL) {
     88 		wpa_printf(MSG_DEBUG, "WPS: Failed to derive DH shared key");
     89 		return -1;
     90 	}
     91 
     92 	/* Own DH private key is not needed anymore */
     93 	wpabuf_clear_free(wps->dh_privkey);
     94 	wps->dh_privkey = NULL;
     95 
     96 	wpa_hexdump_buf_key(MSG_DEBUG, "WPS: DH shared key", dh_shared);
     97 
     98 	/* DHKey = SHA-256(g^AB mod p) */
     99 	addr[0] = wpabuf_head(dh_shared);
    100 	len[0] = wpabuf_len(dh_shared);
    101 	sha256_vector(1, addr, len, dhkey);
    102 	wpa_hexdump_key(MSG_DEBUG, "WPS: DHKey", dhkey, sizeof(dhkey));
    103 	wpabuf_clear_free(dh_shared);
    104 
    105 	/* KDK = HMAC-SHA-256_DHKey(N1 || EnrolleeMAC || N2) */
    106 	addr[0] = wps->nonce_e;
    107 	len[0] = WPS_NONCE_LEN;
    108 	addr[1] = wps->mac_addr_e;
    109 	len[1] = ETH_ALEN;
    110 	addr[2] = wps->nonce_r;
    111 	len[2] = WPS_NONCE_LEN;
    112 	hmac_sha256_vector(dhkey, sizeof(dhkey), 3, addr, len, kdk);
    113 	wpa_hexdump_key(MSG_DEBUG, "WPS: KDK", kdk, sizeof(kdk));
    114 
    115 	wps_kdf(kdk, NULL, 0, "Wi-Fi Easy and Secure Key Derivation",
    116 		keys, sizeof(keys));
    117 	os_memcpy(wps->authkey, keys, WPS_AUTHKEY_LEN);
    118 	os_memcpy(wps->keywrapkey, keys + WPS_AUTHKEY_LEN, WPS_KEYWRAPKEY_LEN);
    119 	os_memcpy(wps->emsk, keys + WPS_AUTHKEY_LEN + WPS_KEYWRAPKEY_LEN,
    120 		  WPS_EMSK_LEN);
    121 
    122 	wpa_hexdump_key(MSG_DEBUG, "WPS: AuthKey",
    123 			wps->authkey, WPS_AUTHKEY_LEN);
    124 	wpa_hexdump_key(MSG_DEBUG, "WPS: KeyWrapKey",
    125 			wps->keywrapkey, WPS_KEYWRAPKEY_LEN);
    126 	wpa_hexdump_key(MSG_DEBUG, "WPS: EMSK", wps->emsk, WPS_EMSK_LEN);
    127 
    128 	return 0;
    129 }
    130 
    131 
    132 int wps_derive_psk(struct wps_data *wps, const u8 *dev_passwd,
    133 		   size_t dev_passwd_len)
    134 {
    135 	u8 hash[SHA256_MAC_LEN];
    136 
    137 	if (hmac_sha256(wps->authkey, WPS_AUTHKEY_LEN, dev_passwd,
    138 			(dev_passwd_len + 1) / 2, hash) < 0)
    139 		return -1;
    140 	os_memcpy(wps->psk1, hash, WPS_PSK_LEN);
    141 	if (hmac_sha256(wps->authkey, WPS_AUTHKEY_LEN,
    142 			dev_passwd + (dev_passwd_len + 1) / 2,
    143 			dev_passwd_len / 2, hash) < 0)
    144 		return -1;
    145 	os_memcpy(wps->psk2, hash, WPS_PSK_LEN);
    146 
    147 	wpa_hexdump_ascii_key(MSG_DEBUG, "WPS: Device Password",
    148 			      dev_passwd, dev_passwd_len);
    149 	wpa_hexdump_key(MSG_DEBUG, "WPS: PSK1", wps->psk1, WPS_PSK_LEN);
    150 	wpa_hexdump_key(MSG_DEBUG, "WPS: PSK2", wps->psk2, WPS_PSK_LEN);
    151 	return 0;
    152 }
    153 
    154 
    155 struct wpabuf * wps_decrypt_encr_settings(struct wps_data *wps, const u8 *encr,
    156 					  size_t encr_len)
    157 {
    158 	struct wpabuf *decrypted;
    159 	const size_t block_size = 16;
    160 	size_t i;
    161 	u8 pad;
    162 	const u8 *pos;
    163 
    164 	/* AES-128-CBC */
    165 	if (encr == NULL || encr_len < 2 * block_size || encr_len % block_size)
    166 	{
    167 		wpa_printf(MSG_DEBUG, "WPS: No Encrypted Settings received");
    168 		return NULL;
    169 	}
    170 
    171 	decrypted = wpabuf_alloc(encr_len - block_size);
    172 	if (decrypted == NULL)
    173 		return NULL;
    174 
    175 	wpa_hexdump(MSG_MSGDUMP, "WPS: Encrypted Settings", encr, encr_len);
    176 	wpabuf_put_data(decrypted, encr + block_size, encr_len - block_size);
    177 	if (aes_128_cbc_decrypt(wps->keywrapkey, encr, wpabuf_mhead(decrypted),
    178 				wpabuf_len(decrypted))) {
    179 		wpabuf_clear_free(decrypted);
    180 		return NULL;
    181 	}
    182 
    183 	wpa_hexdump_buf_key(MSG_MSGDUMP, "WPS: Decrypted Encrypted Settings",
    184 			    decrypted);
    185 
    186 	pos = wpabuf_head_u8(decrypted) + wpabuf_len(decrypted) - 1;
    187 	pad = *pos;
    188 	if (pad > wpabuf_len(decrypted)) {
    189 		wpa_printf(MSG_DEBUG, "WPS: Invalid PKCS#5 v2.0 pad value");
    190 		wpabuf_clear_free(decrypted);
    191 		return NULL;
    192 	}
    193 	for (i = 0; i < pad; i++) {
    194 		if (*pos-- != pad) {
    195 			wpa_printf(MSG_DEBUG, "WPS: Invalid PKCS#5 v2.0 pad "
    196 				   "string");
    197 			wpabuf_clear_free(decrypted);
    198 			return NULL;
    199 		}
    200 	}
    201 	decrypted->used -= pad;
    202 
    203 	return decrypted;
    204 }
    205 
    206 
    207 /**
    208  * wps_pin_checksum - Compute PIN checksum
    209  * @pin: Seven digit PIN (i.e., eight digit PIN without the checksum digit)
    210  * Returns: Checksum digit
    211  */
    212 unsigned int wps_pin_checksum(unsigned int pin)
    213 {
    214 	unsigned int accum = 0;
    215 	while (pin) {
    216 		accum += 3 * (pin % 10);
    217 		pin /= 10;
    218 		accum += pin % 10;
    219 		pin /= 10;
    220 	}
    221 
    222 	return (10 - accum % 10) % 10;
    223 }
    224 
    225 
    226 /**
    227  * wps_pin_valid - Check whether a PIN has a valid checksum
    228  * @pin: Eight digit PIN (i.e., including the checksum digit)
    229  * Returns: 1 if checksum digit is valid, or 0 if not
    230  */
    231 unsigned int wps_pin_valid(unsigned int pin)
    232 {
    233 	return wps_pin_checksum(pin / 10) == (pin % 10);
    234 }
    235 
    236 
    237 /**
    238  * wps_generate_pin - Generate a random PIN
    239  * Returns: Eight digit PIN (i.e., including the checksum digit)
    240  */
    241 int wps_generate_pin(unsigned int *pin)
    242 {
    243 	unsigned int val;
    244 
    245 	/* Generate seven random digits for the PIN */
    246 	if (random_get_bytes((unsigned char *) &val, sizeof(val)) < 0)
    247 		return -1;
    248 	val %= 10000000;
    249 
    250 	/* Append checksum digit */
    251 	*pin = val * 10 + wps_pin_checksum(val);
    252 	return 0;
    253 }
    254 
    255 
    256 int wps_pin_str_valid(const char *pin)
    257 {
    258 	const char *p;
    259 	size_t len;
    260 
    261 	p = pin;
    262 	while (*p >= '0' && *p <= '9')
    263 		p++;
    264 	if (*p != '\0')
    265 		return 0;
    266 
    267 	len = p - pin;
    268 	return len == 4 || len == 8;
    269 }
    270 
    271 
    272 void wps_fail_event(struct wps_context *wps, enum wps_msg_type msg,
    273 		    u16 config_error, u16 error_indication, const u8 *mac_addr)
    274 {
    275 	union wps_event_data data;
    276 
    277 	if (wps->event_cb == NULL)
    278 		return;
    279 
    280 	os_memset(&data, 0, sizeof(data));
    281 	data.fail.msg = msg;
    282 	data.fail.config_error = config_error;
    283 	data.fail.error_indication = error_indication;
    284 	os_memcpy(data.fail.peer_macaddr, mac_addr, ETH_ALEN);
    285 	wps->event_cb(wps->cb_ctx, WPS_EV_FAIL, &data);
    286 }
    287 
    288 
    289 void wps_success_event(struct wps_context *wps, const u8 *mac_addr)
    290 {
    291 	union wps_event_data data;
    292 
    293 	if (wps->event_cb == NULL)
    294 		return;
    295 
    296 	os_memset(&data, 0, sizeof(data));
    297 	os_memcpy(data.success.peer_macaddr, mac_addr, ETH_ALEN);
    298 	wps->event_cb(wps->cb_ctx, WPS_EV_SUCCESS, &data);
    299 }
    300 
    301 
    302 void wps_pwd_auth_fail_event(struct wps_context *wps, int enrollee, int part,
    303 			     const u8 *mac_addr)
    304 {
    305 	union wps_event_data data;
    306 
    307 	if (wps->event_cb == NULL)
    308 		return;
    309 
    310 	os_memset(&data, 0, sizeof(data));
    311 	data.pwd_auth_fail.enrollee = enrollee;
    312 	data.pwd_auth_fail.part = part;
    313 	os_memcpy(data.pwd_auth_fail.peer_macaddr, mac_addr, ETH_ALEN);
    314 	wps->event_cb(wps->cb_ctx, WPS_EV_PWD_AUTH_FAIL, &data);
    315 }
    316 
    317 
    318 void wps_pbc_overlap_event(struct wps_context *wps)
    319 {
    320 	if (wps->event_cb == NULL)
    321 		return;
    322 
    323 	wps->event_cb(wps->cb_ctx, WPS_EV_PBC_OVERLAP, NULL);
    324 }
    325 
    326 
    327 void wps_pbc_timeout_event(struct wps_context *wps)
    328 {
    329 	if (wps->event_cb == NULL)
    330 		return;
    331 
    332 	wps->event_cb(wps->cb_ctx, WPS_EV_PBC_TIMEOUT, NULL);
    333 }
    334 
    335 
    336 void wps_pbc_active_event(struct wps_context *wps)
    337 {
    338 	if (wps->event_cb == NULL)
    339 		return;
    340 
    341 	wps->event_cb(wps->cb_ctx, WPS_EV_PBC_ACTIVE, NULL);
    342 }
    343 
    344 
    345 void wps_pbc_disable_event(struct wps_context *wps)
    346 {
    347 	if (wps->event_cb == NULL)
    348 		return;
    349 
    350 	wps->event_cb(wps->cb_ctx, WPS_EV_PBC_DISABLE, NULL);
    351 }
    352 
    353 
    354 #ifdef CONFIG_WPS_OOB
    355 
    356 struct wpabuf * wps_get_oob_cred(struct wps_context *wps, int rf_band,
    357 				 int channel)
    358 {
    359 	struct wps_data data;
    360 	struct wpabuf *plain;
    361 
    362 	plain = wpabuf_alloc(500);
    363 	if (plain == NULL) {
    364 		wpa_printf(MSG_ERROR, "WPS: Failed to allocate memory for OOB "
    365 			   "credential");
    366 		return NULL;
    367 	}
    368 
    369 	os_memset(&data, 0, sizeof(data));
    370 	data.wps = wps;
    371 	data.auth_type = wps->auth_types;
    372 	data.encr_type = wps->encr_types;
    373 	if (wps_build_cred(&data, plain) ||
    374 	    (rf_band && wps_build_rf_bands_attr(plain, rf_band)) ||
    375 	    (channel && wps_build_ap_channel(plain, channel)) ||
    376 	    wps_build_mac_addr(plain, wps->dev.mac_addr) ||
    377 	    wps_build_wfa_ext(plain, 0, NULL, 0, 0)) {
    378 		os_free(data.new_psk);
    379 		wpabuf_clear_free(plain);
    380 		return NULL;
    381 	}
    382 
    383 	if (wps->wps_state == WPS_STATE_NOT_CONFIGURED && data.new_psk &&
    384 	    wps->ap) {
    385 		struct wps_credential cred;
    386 
    387 		wpa_printf(MSG_DEBUG, "WPS: Moving to Configured state based "
    388 			   "on credential token generation");
    389 
    390 		os_memset(&cred, 0, sizeof(cred));
    391 		os_memcpy(cred.ssid, wps->ssid, wps->ssid_len);
    392 		cred.ssid_len = wps->ssid_len;
    393 		cred.auth_type = WPS_AUTH_WPAPSK | WPS_AUTH_WPA2PSK;
    394 		cred.encr_type = WPS_ENCR_TKIP | WPS_ENCR_AES;
    395 		os_memcpy(cred.key, data.new_psk, data.new_psk_len);
    396 		cred.key_len = data.new_psk_len;
    397 
    398 		wps->wps_state = WPS_STATE_CONFIGURED;
    399 		wpa_hexdump_ascii_key(MSG_DEBUG,
    400 				      "WPS: Generated random passphrase",
    401 				      data.new_psk, data.new_psk_len);
    402 		if (wps->cred_cb)
    403 			wps->cred_cb(wps->cb_ctx, &cred);
    404 	}
    405 
    406 	os_free(data.new_psk);
    407 
    408 	return plain;
    409 }
    410 
    411 
    412 struct wpabuf * wps_build_nfc_pw_token(u16 dev_pw_id,
    413 				       const struct wpabuf *pubkey,
    414 				       const struct wpabuf *dev_pw)
    415 {
    416 	struct wpabuf *data;
    417 
    418 	data = wpabuf_alloc(200);
    419 	if (data == NULL)
    420 		return NULL;
    421 
    422 	if (wps_build_oob_dev_pw(data, dev_pw_id, pubkey,
    423 				 wpabuf_head(dev_pw), wpabuf_len(dev_pw)) ||
    424 	    wps_build_wfa_ext(data, 0, NULL, 0, 0)) {
    425 		wpa_printf(MSG_ERROR, "WPS: Failed to build NFC password "
    426 			   "token");
    427 		wpabuf_clear_free(data);
    428 		return NULL;
    429 	}
    430 
    431 	return data;
    432 }
    433 
    434 
    435 int wps_oob_use_cred(struct wps_context *wps, struct wps_parse_attr *attr)
    436 {
    437 	struct wpabuf msg;
    438 	size_t i;
    439 
    440 	for (i = 0; i < attr->num_cred; i++) {
    441 		struct wps_credential local_cred;
    442 		struct wps_parse_attr cattr;
    443 
    444 		os_memset(&local_cred, 0, sizeof(local_cred));
    445 		wpabuf_set(&msg, attr->cred[i], attr->cred_len[i]);
    446 		if (wps_parse_msg(&msg, &cattr) < 0 ||
    447 		    wps_process_cred(&cattr, &local_cred)) {
    448 			wpa_printf(MSG_ERROR, "WPS: Failed to parse OOB "
    449 				   "credential");
    450 			return -1;
    451 		}
    452 		wps->cred_cb(wps->cb_ctx, &local_cred);
    453 	}
    454 
    455 	return 0;
    456 }
    457 
    458 
    459 #endif /* CONFIG_WPS_OOB */
    460 
    461 
    462 int wps_dev_type_str2bin(const char *str, u8 dev_type[WPS_DEV_TYPE_LEN])
    463 {
    464 	const char *pos;
    465 
    466 	/* <categ>-<OUI>-<subcateg> */
    467 	WPA_PUT_BE16(dev_type, atoi(str));
    468 	pos = os_strchr(str, '-');
    469 	if (pos == NULL)
    470 		return -1;
    471 	pos++;
    472 	if (hexstr2bin(pos, &dev_type[2], 4))
    473 		return -1;
    474 	pos = os_strchr(pos, '-');
    475 	if (pos == NULL)
    476 		return -1;
    477 	pos++;
    478 	WPA_PUT_BE16(&dev_type[6], atoi(pos));
    479 
    480 
    481 	return 0;
    482 }
    483 
    484 
    485 char * wps_dev_type_bin2str(const u8 dev_type[WPS_DEV_TYPE_LEN], char *buf,
    486 			    size_t buf_len)
    487 {
    488 	int ret;
    489 
    490 	ret = os_snprintf(buf, buf_len, "%u-%08X-%u",
    491 			  WPA_GET_BE16(dev_type), WPA_GET_BE32(&dev_type[2]),
    492 			  WPA_GET_BE16(&dev_type[6]));
    493 	if (os_snprintf_error(buf_len, ret))
    494 		return NULL;
    495 
    496 	return buf;
    497 }
    498 
    499 
    500 void uuid_gen_mac_addr(const u8 *mac_addr, u8 *uuid)
    501 {
    502 	const u8 *addr[2];
    503 	size_t len[2];
    504 	u8 hash[SHA1_MAC_LEN];
    505 	u8 nsid[16] = {
    506 		0x52, 0x64, 0x80, 0xf8,
    507 		0xc9, 0x9b,
    508 		0x4b, 0xe5,
    509 		0xa6, 0x55,
    510 		0x58, 0xed, 0x5f, 0x5d, 0x60, 0x84
    511 	};
    512 
    513 	addr[0] = nsid;
    514 	len[0] = sizeof(nsid);
    515 	addr[1] = mac_addr;
    516 	len[1] = 6;
    517 	sha1_vector(2, addr, len, hash);
    518 	os_memcpy(uuid, hash, 16);
    519 
    520 	/* Version: 5 = named-based version using SHA-1 */
    521 	uuid[6] = (5 << 4) | (uuid[6] & 0x0f);
    522 
    523 	/* Variant specified in RFC 4122 */
    524 	uuid[8] = 0x80 | (uuid[8] & 0x3f);
    525 }
    526 
    527 
    528 u16 wps_config_methods_str2bin(const char *str)
    529 {
    530 	u16 methods = 0;
    531 
    532 	if (str == NULL || str[0] == '\0') {
    533 		/* Default to enabling methods based on build configuration */
    534 		methods |= WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD;
    535 		methods |= WPS_CONFIG_VIRT_DISPLAY;
    536 #ifdef CONFIG_WPS_NFC
    537 		methods |= WPS_CONFIG_NFC_INTERFACE;
    538 #endif /* CONFIG_WPS_NFC */
    539 #ifdef CONFIG_P2P
    540 		methods |= WPS_CONFIG_P2PS;
    541 #endif /* CONFIG_P2P */
    542 	} else {
    543 		if (os_strstr(str, "ethernet"))
    544 			methods |= WPS_CONFIG_ETHERNET;
    545 		if (os_strstr(str, "label"))
    546 			methods |= WPS_CONFIG_LABEL;
    547 		if (os_strstr(str, "display"))
    548 			methods |= WPS_CONFIG_DISPLAY;
    549 		if (os_strstr(str, "ext_nfc_token"))
    550 			methods |= WPS_CONFIG_EXT_NFC_TOKEN;
    551 		if (os_strstr(str, "int_nfc_token"))
    552 			methods |= WPS_CONFIG_INT_NFC_TOKEN;
    553 		if (os_strstr(str, "nfc_interface"))
    554 			methods |= WPS_CONFIG_NFC_INTERFACE;
    555 		if (os_strstr(str, "push_button"))
    556 			methods |= WPS_CONFIG_PUSHBUTTON;
    557 		if (os_strstr(str, "keypad"))
    558 			methods |= WPS_CONFIG_KEYPAD;
    559 		if (os_strstr(str, "virtual_display"))
    560 			methods |= WPS_CONFIG_VIRT_DISPLAY;
    561 		if (os_strstr(str, "physical_display"))
    562 			methods |= WPS_CONFIG_PHY_DISPLAY;
    563 		if (os_strstr(str, "virtual_push_button"))
    564 			methods |= WPS_CONFIG_VIRT_PUSHBUTTON;
    565 		if (os_strstr(str, "physical_push_button"))
    566 			methods |= WPS_CONFIG_PHY_PUSHBUTTON;
    567 		if (os_strstr(str, "p2ps"))
    568 			methods |= WPS_CONFIG_P2PS;
    569 	}
    570 
    571 	return methods;
    572 }
    573 
    574 
    575 struct wpabuf * wps_build_wsc_ack(struct wps_data *wps)
    576 {
    577 	struct wpabuf *msg;
    578 
    579 	wpa_printf(MSG_DEBUG, "WPS: Building Message WSC_ACK");
    580 
    581 	msg = wpabuf_alloc(1000);
    582 	if (msg == NULL)
    583 		return NULL;
    584 
    585 	if (wps_build_version(msg) ||
    586 	    wps_build_msg_type(msg, WPS_WSC_ACK) ||
    587 	    wps_build_enrollee_nonce(wps, msg) ||
    588 	    wps_build_registrar_nonce(wps, msg) ||
    589 	    wps_build_wfa_ext(msg, 0, NULL, 0, 0)) {
    590 		wpabuf_free(msg);
    591 		return NULL;
    592 	}
    593 
    594 	return msg;
    595 }
    596 
    597 
    598 struct wpabuf * wps_build_wsc_nack(struct wps_data *wps)
    599 {
    600 	struct wpabuf *msg;
    601 
    602 	wpa_printf(MSG_DEBUG, "WPS: Building Message WSC_NACK");
    603 
    604 	msg = wpabuf_alloc(1000);
    605 	if (msg == NULL)
    606 		return NULL;
    607 
    608 	if (wps_build_version(msg) ||
    609 	    wps_build_msg_type(msg, WPS_WSC_NACK) ||
    610 	    wps_build_enrollee_nonce(wps, msg) ||
    611 	    wps_build_registrar_nonce(wps, msg) ||
    612 	    wps_build_config_error(msg, wps->config_error) ||
    613 	    wps_build_wfa_ext(msg, 0, NULL, 0, 0)) {
    614 		wpabuf_free(msg);
    615 		return NULL;
    616 	}
    617 
    618 	return msg;
    619 }
    620 
    621 
    622 #ifdef CONFIG_WPS_NFC
    623 
    624 struct wpabuf * wps_nfc_token_build(int ndef, int id, struct wpabuf *pubkey,
    625 				    struct wpabuf *dev_pw)
    626 {
    627 	struct wpabuf *ret;
    628 
    629 	if (pubkey == NULL || dev_pw == NULL)
    630 		return NULL;
    631 
    632 	ret = wps_build_nfc_pw_token(id, pubkey, dev_pw);
    633 	if (ndef && ret) {
    634 		struct wpabuf *tmp;
    635 		tmp = ndef_build_wifi(ret);
    636 		wpabuf_free(ret);
    637 		if (tmp == NULL)
    638 			return NULL;
    639 		ret = tmp;
    640 	}
    641 
    642 	return ret;
    643 }
    644 
    645 
    646 int wps_nfc_gen_dh(struct wpabuf **pubkey, struct wpabuf **privkey)
    647 {
    648 	struct wpabuf *priv = NULL, *pub = NULL;
    649 	void *dh_ctx;
    650 
    651 	dh_ctx = dh5_init(&priv, &pub);
    652 	if (dh_ctx == NULL)
    653 		return -1;
    654 	pub = wpabuf_zeropad(pub, 192);
    655 	if (pub == NULL) {
    656 		wpabuf_free(priv);
    657 		dh5_free(dh_ctx);
    658 		return -1;
    659 	}
    660 	wpa_hexdump_buf(MSG_DEBUG, "WPS: Generated new DH pubkey", pub);
    661 	dh5_free(dh_ctx);
    662 
    663 	wpabuf_free(*pubkey);
    664 	*pubkey = pub;
    665 	wpabuf_clear_free(*privkey);
    666 	*privkey = priv;
    667 
    668 	return 0;
    669 }
    670 
    671 
    672 struct wpabuf * wps_nfc_token_gen(int ndef, int *id, struct wpabuf **pubkey,
    673 				  struct wpabuf **privkey,
    674 				  struct wpabuf **dev_pw)
    675 {
    676 	struct wpabuf *pw;
    677 	u16 val;
    678 
    679 	pw = wpabuf_alloc(WPS_OOB_DEVICE_PASSWORD_LEN);
    680 	if (pw == NULL)
    681 		return NULL;
    682 
    683 	if (random_get_bytes(wpabuf_put(pw, WPS_OOB_DEVICE_PASSWORD_LEN),
    684 			     WPS_OOB_DEVICE_PASSWORD_LEN) ||
    685 	    random_get_bytes((u8 *) &val, sizeof(val))) {
    686 		wpabuf_free(pw);
    687 		return NULL;
    688 	}
    689 
    690 	if (wps_nfc_gen_dh(pubkey, privkey) < 0) {
    691 		wpabuf_free(pw);
    692 		return NULL;
    693 	}
    694 
    695 	*id = 0x10 + val % 0xfff0;
    696 	wpabuf_clear_free(*dev_pw);
    697 	*dev_pw = pw;
    698 
    699 	return wps_nfc_token_build(ndef, *id, *pubkey, *dev_pw);
    700 }
    701 
    702 
    703 struct wpabuf * wps_build_nfc_handover_req(struct wps_context *ctx,
    704 					   struct wpabuf *nfc_dh_pubkey)
    705 {
    706 	struct wpabuf *msg;
    707 	void *len;
    708 
    709 	if (ctx == NULL)
    710 		return NULL;
    711 
    712 	wpa_printf(MSG_DEBUG, "WPS: Building attributes for NFC connection "
    713 		   "handover request");
    714 
    715 	if (nfc_dh_pubkey == NULL) {
    716 		wpa_printf(MSG_DEBUG, "WPS: No NFC OOB Device Password "
    717 			   "configured");
    718 		return NULL;
    719 	}
    720 
    721 	msg = wpabuf_alloc(1000);
    722 	if (msg == NULL)
    723 		return msg;
    724 	len = wpabuf_put(msg, 2);
    725 
    726 	if (wps_build_oob_dev_pw(msg, DEV_PW_NFC_CONNECTION_HANDOVER,
    727 				 nfc_dh_pubkey, NULL, 0) ||
    728 	    wps_build_uuid_e(msg, ctx->uuid) ||
    729 	    wps_build_wfa_ext(msg, 0, NULL, 0, 0)) {
    730 		wpabuf_free(msg);
    731 		return NULL;
    732 	}
    733 
    734 	WPA_PUT_BE16(len, wpabuf_len(msg) - 2);
    735 
    736 	return msg;
    737 }
    738 
    739 
    740 static int wps_build_ssid(struct wpabuf *msg, struct wps_context *wps)
    741 {
    742 	wpa_printf(MSG_DEBUG, "WPS:  * SSID");
    743 	wpa_hexdump_ascii(MSG_DEBUG, "WPS: SSID in Connection Handover Select",
    744 			  wps->ssid, wps->ssid_len);
    745 	wpabuf_put_be16(msg, ATTR_SSID);
    746 	wpabuf_put_be16(msg, wps->ssid_len);
    747 	wpabuf_put_data(msg, wps->ssid, wps->ssid_len);
    748 	return 0;
    749 }
    750 
    751 
    752 static int wps_build_ap_freq(struct wpabuf *msg, int freq)
    753 {
    754 	enum hostapd_hw_mode mode;
    755 	u8 channel, rf_band;
    756 	u16 ap_channel;
    757 
    758 	if (freq <= 0)
    759 		return 0;
    760 
    761 	mode = ieee80211_freq_to_chan(freq, &channel);
    762 	if (mode == NUM_HOSTAPD_MODES)
    763 		return 0; /* Unknown channel */
    764 
    765 	if (mode == HOSTAPD_MODE_IEEE80211G || mode == HOSTAPD_MODE_IEEE80211B)
    766 		rf_band = WPS_RF_24GHZ;
    767 	else if (mode == HOSTAPD_MODE_IEEE80211A)
    768 		rf_band = WPS_RF_50GHZ;
    769 	else if (mode == HOSTAPD_MODE_IEEE80211AD)
    770 		rf_band = WPS_RF_60GHZ;
    771 	else
    772 		return 0; /* Unknown band */
    773 	ap_channel = channel;
    774 
    775 	if (wps_build_rf_bands_attr(msg, rf_band) ||
    776 	    wps_build_ap_channel(msg, ap_channel))
    777 		return -1;
    778 
    779 	return 0;
    780 }
    781 
    782 
    783 struct wpabuf * wps_build_nfc_handover_sel(struct wps_context *ctx,
    784 					   struct wpabuf *nfc_dh_pubkey,
    785 					   const u8 *bssid, int freq)
    786 {
    787 	struct wpabuf *msg;
    788 	void *len;
    789 
    790 	if (ctx == NULL)
    791 		return NULL;
    792 
    793 	wpa_printf(MSG_DEBUG, "WPS: Building attributes for NFC connection "
    794 		   "handover select");
    795 
    796 	if (nfc_dh_pubkey == NULL) {
    797 		wpa_printf(MSG_DEBUG, "WPS: No NFC OOB Device Password "
    798 			   "configured");
    799 		return NULL;
    800 	}
    801 
    802 	msg = wpabuf_alloc(1000);
    803 	if (msg == NULL)
    804 		return msg;
    805 	len = wpabuf_put(msg, 2);
    806 
    807 	if (wps_build_oob_dev_pw(msg, DEV_PW_NFC_CONNECTION_HANDOVER,
    808 				 nfc_dh_pubkey, NULL, 0) ||
    809 	    wps_build_ssid(msg, ctx) ||
    810 	    wps_build_ap_freq(msg, freq) ||
    811 	    (bssid && wps_build_mac_addr(msg, bssid)) ||
    812 	    wps_build_wfa_ext(msg, 0, NULL, 0, 0)) {
    813 		wpabuf_free(msg);
    814 		return NULL;
    815 	}
    816 
    817 	WPA_PUT_BE16(len, wpabuf_len(msg) - 2);
    818 
    819 	return msg;
    820 }
    821 
    822 
    823 struct wpabuf * wps_build_nfc_handover_req_p2p(struct wps_context *ctx,
    824 					       struct wpabuf *nfc_dh_pubkey)
    825 {
    826 	struct wpabuf *msg;
    827 
    828 	if (ctx == NULL)
    829 		return NULL;
    830 
    831 	wpa_printf(MSG_DEBUG, "WPS: Building attributes for NFC connection "
    832 		   "handover request (P2P)");
    833 
    834 	if (nfc_dh_pubkey == NULL) {
    835 		wpa_printf(MSG_DEBUG, "WPS: No NFC DH Public Key configured");
    836 		return NULL;
    837 	}
    838 
    839 	msg = wpabuf_alloc(1000);
    840 	if (msg == NULL)
    841 		return msg;
    842 
    843 	if (wps_build_manufacturer(&ctx->dev, msg) ||
    844 	    wps_build_model_name(&ctx->dev, msg) ||
    845 	    wps_build_model_number(&ctx->dev, msg) ||
    846 	    wps_build_oob_dev_pw(msg, DEV_PW_NFC_CONNECTION_HANDOVER,
    847 				 nfc_dh_pubkey, NULL, 0) ||
    848 	    wps_build_rf_bands(&ctx->dev, msg, 0) ||
    849 	    wps_build_serial_number(&ctx->dev, msg) ||
    850 	    wps_build_uuid_e(msg, ctx->uuid) ||
    851 	    wps_build_wfa_ext(msg, 0, NULL, 0, 0)) {
    852 		wpabuf_free(msg);
    853 		return NULL;
    854 	}
    855 
    856 	return msg;
    857 }
    858 
    859 
    860 struct wpabuf * wps_build_nfc_handover_sel_p2p(struct wps_context *ctx,
    861 					       int nfc_dev_pw_id,
    862 					       struct wpabuf *nfc_dh_pubkey,
    863 					       struct wpabuf *nfc_dev_pw)
    864 {
    865 	struct wpabuf *msg;
    866 	const u8 *dev_pw;
    867 	size_t dev_pw_len;
    868 
    869 	if (ctx == NULL)
    870 		return NULL;
    871 
    872 	wpa_printf(MSG_DEBUG, "WPS: Building attributes for NFC connection "
    873 		   "handover select (P2P)");
    874 
    875 	if (nfc_dh_pubkey == NULL ||
    876 	    (nfc_dev_pw_id != DEV_PW_NFC_CONNECTION_HANDOVER &&
    877 	     nfc_dev_pw == NULL)) {
    878 		wpa_printf(MSG_DEBUG, "WPS: No NFC OOB Device Password "
    879 			   "configured");
    880 		return NULL;
    881 	}
    882 
    883 	msg = wpabuf_alloc(1000);
    884 	if (msg == NULL)
    885 		return msg;
    886 
    887 	if (nfc_dev_pw) {
    888 		dev_pw = wpabuf_head(nfc_dev_pw);
    889 		dev_pw_len = wpabuf_len(nfc_dev_pw);
    890 	} else {
    891 		dev_pw = NULL;
    892 		dev_pw_len = 0;
    893 	}
    894 
    895 	if (wps_build_manufacturer(&ctx->dev, msg) ||
    896 	    wps_build_model_name(&ctx->dev, msg) ||
    897 	    wps_build_model_number(&ctx->dev, msg) ||
    898 	    wps_build_oob_dev_pw(msg, nfc_dev_pw_id, nfc_dh_pubkey,
    899 				 dev_pw, dev_pw_len) ||
    900 	    wps_build_rf_bands(&ctx->dev, msg, 0) ||
    901 	    wps_build_serial_number(&ctx->dev, msg) ||
    902 	    wps_build_uuid_e(msg, ctx->uuid) ||
    903 	    wps_build_wfa_ext(msg, 0, NULL, 0, 0)) {
    904 		wpabuf_free(msg);
    905 		return NULL;
    906 	}
    907 
    908 	return msg;
    909 }
    910 
    911 #endif /* CONFIG_WPS_NFC */
    912