1 /* 2 * hostapd / Configuration helper functions 3 * Copyright (c) 2003-2014, Jouni Malinen <j@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 "utils/includes.h" 10 11 #include "utils/common.h" 12 #include "crypto/sha1.h" 13 #include "crypto/tls.h" 14 #include "radius/radius_client.h" 15 #include "common/ieee802_11_defs.h" 16 #include "common/eapol_common.h" 17 #include "common/dhcp.h" 18 #include "eap_common/eap_wsc_common.h" 19 #include "eap_server/eap.h" 20 #include "wpa_auth.h" 21 #include "sta_info.h" 22 #include "ap_config.h" 23 24 25 static void hostapd_config_free_vlan(struct hostapd_bss_config *bss) 26 { 27 struct hostapd_vlan *vlan, *prev; 28 29 vlan = bss->vlan; 30 prev = NULL; 31 while (vlan) { 32 prev = vlan; 33 vlan = vlan->next; 34 os_free(prev); 35 } 36 37 bss->vlan = NULL; 38 } 39 40 41 #ifndef DEFAULT_WPA_DISABLE_EAPOL_KEY_RETRIES 42 #define DEFAULT_WPA_DISABLE_EAPOL_KEY_RETRIES 0 43 #endif /* DEFAULT_WPA_DISABLE_EAPOL_KEY_RETRIES */ 44 45 void hostapd_config_defaults_bss(struct hostapd_bss_config *bss) 46 { 47 dl_list_init(&bss->anqp_elem); 48 49 bss->logger_syslog_level = HOSTAPD_LEVEL_INFO; 50 bss->logger_stdout_level = HOSTAPD_LEVEL_INFO; 51 bss->logger_syslog = (unsigned int) -1; 52 bss->logger_stdout = (unsigned int) -1; 53 54 bss->auth_algs = WPA_AUTH_ALG_OPEN | WPA_AUTH_ALG_SHARED; 55 56 bss->wep_rekeying_period = 300; 57 /* use key0 in individual key and key1 in broadcast key */ 58 bss->broadcast_key_idx_min = 1; 59 bss->broadcast_key_idx_max = 2; 60 bss->eap_reauth_period = 3600; 61 62 bss->wpa_group_rekey = 600; 63 bss->wpa_gmk_rekey = 86400; 64 bss->wpa_group_update_count = 4; 65 bss->wpa_pairwise_update_count = 4; 66 bss->wpa_disable_eapol_key_retries = 67 DEFAULT_WPA_DISABLE_EAPOL_KEY_RETRIES; 68 bss->wpa_key_mgmt = WPA_KEY_MGMT_PSK; 69 bss->wpa_pairwise = WPA_CIPHER_TKIP; 70 bss->wpa_group = WPA_CIPHER_TKIP; 71 bss->rsn_pairwise = 0; 72 73 bss->max_num_sta = MAX_STA_COUNT; 74 75 bss->dtim_period = 2; 76 77 bss->radius_server_auth_port = 1812; 78 bss->eap_sim_db_timeout = 1; 79 bss->ap_max_inactivity = AP_MAX_INACTIVITY; 80 bss->eapol_version = EAPOL_VERSION; 81 82 bss->max_listen_interval = 65535; 83 84 bss->pwd_group = 19; /* ECC: GF(p=256) */ 85 86 #ifdef CONFIG_IEEE80211W 87 bss->assoc_sa_query_max_timeout = 1000; 88 bss->assoc_sa_query_retry_timeout = 201; 89 bss->group_mgmt_cipher = WPA_CIPHER_AES_128_CMAC; 90 #endif /* CONFIG_IEEE80211W */ 91 #ifdef EAP_SERVER_FAST 92 /* both anonymous and authenticated provisioning */ 93 bss->eap_fast_prov = 3; 94 bss->pac_key_lifetime = 7 * 24 * 60 * 60; 95 bss->pac_key_refresh_time = 1 * 24 * 60 * 60; 96 #endif /* EAP_SERVER_FAST */ 97 98 /* Set to -1 as defaults depends on HT in setup */ 99 bss->wmm_enabled = -1; 100 101 #ifdef CONFIG_IEEE80211R_AP 102 bss->ft_over_ds = 1; 103 bss->rkh_pos_timeout = 86400; 104 bss->rkh_neg_timeout = 60; 105 bss->rkh_pull_timeout = 1000; 106 bss->rkh_pull_retries = 4; 107 bss->r0_key_lifetime = 1209600; 108 #endif /* CONFIG_IEEE80211R_AP */ 109 110 bss->radius_das_time_window = 300; 111 112 bss->sae_anti_clogging_threshold = 5; 113 bss->sae_sync = 5; 114 115 bss->gas_frag_limit = 1400; 116 117 #ifdef CONFIG_FILS 118 dl_list_init(&bss->fils_realms); 119 bss->fils_hlp_wait_time = 30; 120 bss->dhcp_server_port = DHCP_SERVER_PORT; 121 bss->dhcp_relay_port = DHCP_SERVER_PORT; 122 #endif /* CONFIG_FILS */ 123 124 bss->broadcast_deauth = 1; 125 126 #ifdef CONFIG_MBO 127 bss->mbo_cell_data_conn_pref = -1; 128 #endif /* CONFIG_MBO */ 129 130 /* Disable TLS v1.3 by default for now to avoid interoperability issue. 131 * This can be enabled by default once the implementation has been fully 132 * completed and tested with other implementations. */ 133 bss->tls_flags = TLS_CONN_DISABLE_TLSv1_3; 134 } 135 136 137 struct hostapd_config * hostapd_config_defaults(void) 138 { 139 #define ecw2cw(ecw) ((1 << (ecw)) - 1) 140 141 struct hostapd_config *conf; 142 struct hostapd_bss_config *bss; 143 const int aCWmin = 4, aCWmax = 10; 144 const struct hostapd_wmm_ac_params ac_bk = 145 { aCWmin, aCWmax, 7, 0, 0 }; /* background traffic */ 146 const struct hostapd_wmm_ac_params ac_be = 147 { aCWmin, aCWmax, 3, 0, 0 }; /* best effort traffic */ 148 const struct hostapd_wmm_ac_params ac_vi = /* video traffic */ 149 { aCWmin - 1, aCWmin, 2, 3008 / 32, 0 }; 150 const struct hostapd_wmm_ac_params ac_vo = /* voice traffic */ 151 { aCWmin - 2, aCWmin - 1, 2, 1504 / 32, 0 }; 152 const struct hostapd_tx_queue_params txq_bk = 153 { 7, ecw2cw(aCWmin), ecw2cw(aCWmax), 0 }; 154 const struct hostapd_tx_queue_params txq_be = 155 { 3, ecw2cw(aCWmin), 4 * (ecw2cw(aCWmin) + 1) - 1, 0}; 156 const struct hostapd_tx_queue_params txq_vi = 157 { 1, (ecw2cw(aCWmin) + 1) / 2 - 1, ecw2cw(aCWmin), 30}; 158 const struct hostapd_tx_queue_params txq_vo = 159 { 1, (ecw2cw(aCWmin) + 1) / 4 - 1, 160 (ecw2cw(aCWmin) + 1) / 2 - 1, 15}; 161 162 #undef ecw2cw 163 164 conf = os_zalloc(sizeof(*conf)); 165 bss = os_zalloc(sizeof(*bss)); 166 if (conf == NULL || bss == NULL) { 167 wpa_printf(MSG_ERROR, "Failed to allocate memory for " 168 "configuration data."); 169 os_free(conf); 170 os_free(bss); 171 return NULL; 172 } 173 conf->bss = os_calloc(1, sizeof(struct hostapd_bss_config *)); 174 if (conf->bss == NULL) { 175 os_free(conf); 176 os_free(bss); 177 return NULL; 178 } 179 conf->bss[0] = bss; 180 181 bss->radius = os_zalloc(sizeof(*bss->radius)); 182 if (bss->radius == NULL) { 183 os_free(conf->bss); 184 os_free(conf); 185 os_free(bss); 186 return NULL; 187 } 188 189 hostapd_config_defaults_bss(bss); 190 191 conf->num_bss = 1; 192 193 conf->beacon_int = 100; 194 conf->rts_threshold = -1; /* use driver default: 2347 */ 195 conf->fragm_threshold = -1; /* user driver default: 2346 */ 196 conf->send_probe_response = 1; 197 /* Set to invalid value means do not add Power Constraint IE */ 198 conf->local_pwr_constraint = -1; 199 200 conf->wmm_ac_params[0] = ac_be; 201 conf->wmm_ac_params[1] = ac_bk; 202 conf->wmm_ac_params[2] = ac_vi; 203 conf->wmm_ac_params[3] = ac_vo; 204 205 conf->tx_queue[0] = txq_vo; 206 conf->tx_queue[1] = txq_vi; 207 conf->tx_queue[2] = txq_be; 208 conf->tx_queue[3] = txq_bk; 209 210 conf->ht_capab = HT_CAP_INFO_SMPS_DISABLED; 211 212 conf->ap_table_max_size = 255; 213 conf->ap_table_expiration_time = 60; 214 conf->track_sta_max_age = 180; 215 216 #ifdef CONFIG_TESTING_OPTIONS 217 conf->ignore_probe_probability = 0.0; 218 conf->ignore_auth_probability = 0.0; 219 conf->ignore_assoc_probability = 0.0; 220 conf->ignore_reassoc_probability = 0.0; 221 conf->corrupt_gtk_rekey_mic_probability = 0.0; 222 conf->ecsa_ie_only = 0; 223 #endif /* CONFIG_TESTING_OPTIONS */ 224 225 conf->acs = 0; 226 conf->acs_ch_list.num = 0; 227 #ifdef CONFIG_ACS 228 conf->acs_num_scans = 5; 229 #endif /* CONFIG_ACS */ 230 231 /* The third octet of the country string uses an ASCII space character 232 * by default to indicate that the regulations encompass all 233 * environments for the current frequency band in the country. */ 234 conf->country[2] = ' '; 235 236 return conf; 237 } 238 239 240 int hostapd_mac_comp(const void *a, const void *b) 241 { 242 return os_memcmp(a, b, sizeof(macaddr)); 243 } 244 245 246 static int hostapd_config_read_wpa_psk(const char *fname, 247 struct hostapd_ssid *ssid) 248 { 249 FILE *f; 250 char buf[128], *pos; 251 int line = 0, ret = 0, len, ok; 252 u8 addr[ETH_ALEN]; 253 struct hostapd_wpa_psk *psk; 254 255 if (!fname) 256 return 0; 257 258 f = fopen(fname, "r"); 259 if (!f) { 260 wpa_printf(MSG_ERROR, "WPA PSK file '%s' not found.", fname); 261 return -1; 262 } 263 264 while (fgets(buf, sizeof(buf), f)) { 265 line++; 266 267 if (buf[0] == '#') 268 continue; 269 pos = buf; 270 while (*pos != '\0') { 271 if (*pos == '\n') { 272 *pos = '\0'; 273 break; 274 } 275 pos++; 276 } 277 if (buf[0] == '\0') 278 continue; 279 280 if (hwaddr_aton(buf, addr)) { 281 wpa_printf(MSG_ERROR, "Invalid MAC address '%s' on " 282 "line %d in '%s'", buf, line, fname); 283 ret = -1; 284 break; 285 } 286 287 psk = os_zalloc(sizeof(*psk)); 288 if (psk == NULL) { 289 wpa_printf(MSG_ERROR, "WPA PSK allocation failed"); 290 ret = -1; 291 break; 292 } 293 if (is_zero_ether_addr(addr)) 294 psk->group = 1; 295 else 296 os_memcpy(psk->addr, addr, ETH_ALEN); 297 298 pos = buf + 17; 299 if (*pos == '\0') { 300 wpa_printf(MSG_ERROR, "No PSK on line %d in '%s'", 301 line, fname); 302 os_free(psk); 303 ret = -1; 304 break; 305 } 306 pos++; 307 308 ok = 0; 309 len = os_strlen(pos); 310 if (len == 64 && hexstr2bin(pos, psk->psk, PMK_LEN) == 0) 311 ok = 1; 312 else if (len >= 8 && len < 64) { 313 pbkdf2_sha1(pos, ssid->ssid, ssid->ssid_len, 314 4096, psk->psk, PMK_LEN); 315 ok = 1; 316 } 317 if (!ok) { 318 wpa_printf(MSG_ERROR, "Invalid PSK '%s' on line %d in " 319 "'%s'", pos, line, fname); 320 os_free(psk); 321 ret = -1; 322 break; 323 } 324 325 psk->next = ssid->wpa_psk; 326 ssid->wpa_psk = psk; 327 } 328 329 fclose(f); 330 331 return ret; 332 } 333 334 335 static int hostapd_derive_psk(struct hostapd_ssid *ssid) 336 { 337 ssid->wpa_psk = os_zalloc(sizeof(struct hostapd_wpa_psk)); 338 if (ssid->wpa_psk == NULL) { 339 wpa_printf(MSG_ERROR, "Unable to alloc space for PSK"); 340 return -1; 341 } 342 wpa_hexdump_ascii(MSG_DEBUG, "SSID", 343 (u8 *) ssid->ssid, ssid->ssid_len); 344 wpa_hexdump_ascii_key(MSG_DEBUG, "PSK (ASCII passphrase)", 345 (u8 *) ssid->wpa_passphrase, 346 os_strlen(ssid->wpa_passphrase)); 347 pbkdf2_sha1(ssid->wpa_passphrase, 348 ssid->ssid, ssid->ssid_len, 349 4096, ssid->wpa_psk->psk, PMK_LEN); 350 wpa_hexdump_key(MSG_DEBUG, "PSK (from passphrase)", 351 ssid->wpa_psk->psk, PMK_LEN); 352 return 0; 353 } 354 355 356 int hostapd_setup_wpa_psk(struct hostapd_bss_config *conf) 357 { 358 struct hostapd_ssid *ssid = &conf->ssid; 359 360 if (ssid->wpa_passphrase != NULL) { 361 if (ssid->wpa_psk != NULL) { 362 wpa_printf(MSG_DEBUG, "Using pre-configured WPA PSK " 363 "instead of passphrase"); 364 } else { 365 wpa_printf(MSG_DEBUG, "Deriving WPA PSK based on " 366 "passphrase"); 367 if (hostapd_derive_psk(ssid) < 0) 368 return -1; 369 } 370 ssid->wpa_psk->group = 1; 371 } 372 373 return hostapd_config_read_wpa_psk(ssid->wpa_psk_file, &conf->ssid); 374 } 375 376 377 static void hostapd_config_free_radius(struct hostapd_radius_server *servers, 378 int num_servers) 379 { 380 int i; 381 382 for (i = 0; i < num_servers; i++) { 383 os_free(servers[i].shared_secret); 384 } 385 os_free(servers); 386 } 387 388 389 struct hostapd_radius_attr * 390 hostapd_config_get_radius_attr(struct hostapd_radius_attr *attr, u8 type) 391 { 392 for (; attr; attr = attr->next) { 393 if (attr->type == type) 394 return attr; 395 } 396 return NULL; 397 } 398 399 400 static void hostapd_config_free_radius_attr(struct hostapd_radius_attr *attr) 401 { 402 struct hostapd_radius_attr *prev; 403 404 while (attr) { 405 prev = attr; 406 attr = attr->next; 407 wpabuf_free(prev->val); 408 os_free(prev); 409 } 410 } 411 412 413 void hostapd_config_free_eap_user(struct hostapd_eap_user *user) 414 { 415 hostapd_config_free_radius_attr(user->accept_attr); 416 os_free(user->identity); 417 bin_clear_free(user->password, user->password_len); 418 bin_clear_free(user->salt, user->salt_len); 419 os_free(user); 420 } 421 422 423 void hostapd_config_free_eap_users(struct hostapd_eap_user *user) 424 { 425 struct hostapd_eap_user *prev_user; 426 427 while (user) { 428 prev_user = user; 429 user = user->next; 430 hostapd_config_free_eap_user(prev_user); 431 } 432 } 433 434 435 static void hostapd_config_free_wep(struct hostapd_wep_keys *keys) 436 { 437 int i; 438 for (i = 0; i < NUM_WEP_KEYS; i++) { 439 bin_clear_free(keys->key[i], keys->len[i]); 440 keys->key[i] = NULL; 441 } 442 } 443 444 445 void hostapd_config_clear_wpa_psk(struct hostapd_wpa_psk **l) 446 { 447 struct hostapd_wpa_psk *psk, *tmp; 448 449 for (psk = *l; psk;) { 450 tmp = psk; 451 psk = psk->next; 452 bin_clear_free(tmp, sizeof(*tmp)); 453 } 454 *l = NULL; 455 } 456 457 458 static void hostapd_config_free_anqp_elem(struct hostapd_bss_config *conf) 459 { 460 struct anqp_element *elem; 461 462 while ((elem = dl_list_first(&conf->anqp_elem, struct anqp_element, 463 list))) { 464 dl_list_del(&elem->list); 465 wpabuf_free(elem->payload); 466 os_free(elem); 467 } 468 } 469 470 471 static void hostapd_config_free_fils_realms(struct hostapd_bss_config *conf) 472 { 473 #ifdef CONFIG_FILS 474 struct fils_realm *realm; 475 476 while ((realm = dl_list_first(&conf->fils_realms, struct fils_realm, 477 list))) { 478 dl_list_del(&realm->list); 479 os_free(realm); 480 } 481 #endif /* CONFIG_FILS */ 482 } 483 484 485 static void hostapd_config_free_sae_passwords(struct hostapd_bss_config *conf) 486 { 487 struct sae_password_entry *pw, *tmp; 488 489 pw = conf->sae_passwords; 490 conf->sae_passwords = NULL; 491 while (pw) { 492 tmp = pw; 493 pw = pw->next; 494 str_clear_free(tmp->password); 495 os_free(tmp->identifier); 496 os_free(tmp); 497 } 498 } 499 500 501 void hostapd_config_free_bss(struct hostapd_bss_config *conf) 502 { 503 if (conf == NULL) 504 return; 505 506 hostapd_config_clear_wpa_psk(&conf->ssid.wpa_psk); 507 508 str_clear_free(conf->ssid.wpa_passphrase); 509 os_free(conf->ssid.wpa_psk_file); 510 hostapd_config_free_wep(&conf->ssid.wep); 511 #ifdef CONFIG_FULL_DYNAMIC_VLAN 512 os_free(conf->ssid.vlan_tagged_interface); 513 #endif /* CONFIG_FULL_DYNAMIC_VLAN */ 514 515 hostapd_config_free_eap_users(conf->eap_user); 516 os_free(conf->eap_user_sqlite); 517 518 os_free(conf->eap_req_id_text); 519 os_free(conf->erp_domain); 520 os_free(conf->accept_mac); 521 os_free(conf->deny_mac); 522 os_free(conf->nas_identifier); 523 if (conf->radius) { 524 hostapd_config_free_radius(conf->radius->auth_servers, 525 conf->radius->num_auth_servers); 526 hostapd_config_free_radius(conf->radius->acct_servers, 527 conf->radius->num_acct_servers); 528 } 529 hostapd_config_free_radius_attr(conf->radius_auth_req_attr); 530 hostapd_config_free_radius_attr(conf->radius_acct_req_attr); 531 os_free(conf->rsn_preauth_interfaces); 532 os_free(conf->ctrl_interface); 533 os_free(conf->ca_cert); 534 os_free(conf->server_cert); 535 os_free(conf->private_key); 536 os_free(conf->private_key_passwd); 537 os_free(conf->ocsp_stapling_response); 538 os_free(conf->ocsp_stapling_response_multi); 539 os_free(conf->dh_file); 540 os_free(conf->openssl_ciphers); 541 os_free(conf->pac_opaque_encr_key); 542 os_free(conf->eap_fast_a_id); 543 os_free(conf->eap_fast_a_id_info); 544 os_free(conf->eap_sim_db); 545 os_free(conf->radius_server_clients); 546 os_free(conf->radius); 547 os_free(conf->radius_das_shared_secret); 548 hostapd_config_free_vlan(conf); 549 os_free(conf->time_zone); 550 551 #ifdef CONFIG_IEEE80211R_AP 552 { 553 struct ft_remote_r0kh *r0kh, *r0kh_prev; 554 struct ft_remote_r1kh *r1kh, *r1kh_prev; 555 556 r0kh = conf->r0kh_list; 557 conf->r0kh_list = NULL; 558 while (r0kh) { 559 r0kh_prev = r0kh; 560 r0kh = r0kh->next; 561 os_free(r0kh_prev); 562 } 563 564 r1kh = conf->r1kh_list; 565 conf->r1kh_list = NULL; 566 while (r1kh) { 567 r1kh_prev = r1kh; 568 r1kh = r1kh->next; 569 os_free(r1kh_prev); 570 } 571 } 572 #endif /* CONFIG_IEEE80211R_AP */ 573 574 #ifdef CONFIG_WPS 575 os_free(conf->wps_pin_requests); 576 os_free(conf->device_name); 577 os_free(conf->manufacturer); 578 os_free(conf->model_name); 579 os_free(conf->model_number); 580 os_free(conf->serial_number); 581 os_free(conf->config_methods); 582 os_free(conf->ap_pin); 583 os_free(conf->extra_cred); 584 os_free(conf->ap_settings); 585 os_free(conf->upnp_iface); 586 os_free(conf->friendly_name); 587 os_free(conf->manufacturer_url); 588 os_free(conf->model_description); 589 os_free(conf->model_url); 590 os_free(conf->upc); 591 { 592 unsigned int i; 593 594 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) 595 wpabuf_free(conf->wps_vendor_ext[i]); 596 } 597 wpabuf_free(conf->wps_nfc_dh_pubkey); 598 wpabuf_free(conf->wps_nfc_dh_privkey); 599 wpabuf_free(conf->wps_nfc_dev_pw); 600 #endif /* CONFIG_WPS */ 601 602 os_free(conf->roaming_consortium); 603 os_free(conf->venue_name); 604 os_free(conf->venue_url); 605 os_free(conf->nai_realm_data); 606 os_free(conf->network_auth_type); 607 os_free(conf->anqp_3gpp_cell_net); 608 os_free(conf->domain_name); 609 hostapd_config_free_anqp_elem(conf); 610 611 #ifdef CONFIG_RADIUS_TEST 612 os_free(conf->dump_msk_file); 613 #endif /* CONFIG_RADIUS_TEST */ 614 615 #ifdef CONFIG_HS20 616 os_free(conf->hs20_oper_friendly_name); 617 os_free(conf->hs20_wan_metrics); 618 os_free(conf->hs20_connection_capability); 619 os_free(conf->hs20_operating_class); 620 os_free(conf->hs20_icons); 621 if (conf->hs20_osu_providers) { 622 size_t i; 623 for (i = 0; i < conf->hs20_osu_providers_count; i++) { 624 struct hs20_osu_provider *p; 625 size_t j; 626 p = &conf->hs20_osu_providers[i]; 627 os_free(p->friendly_name); 628 os_free(p->server_uri); 629 os_free(p->method_list); 630 for (j = 0; j < p->icons_count; j++) 631 os_free(p->icons[j]); 632 os_free(p->icons); 633 os_free(p->osu_nai); 634 os_free(p->osu_nai2); 635 os_free(p->service_desc); 636 } 637 os_free(conf->hs20_osu_providers); 638 } 639 if (conf->hs20_operator_icon) { 640 size_t i; 641 642 for (i = 0; i < conf->hs20_operator_icon_count; i++) 643 os_free(conf->hs20_operator_icon[i]); 644 os_free(conf->hs20_operator_icon); 645 } 646 os_free(conf->subscr_remediation_url); 647 os_free(conf->t_c_filename); 648 os_free(conf->t_c_server_url); 649 #endif /* CONFIG_HS20 */ 650 651 wpabuf_free(conf->vendor_elements); 652 wpabuf_free(conf->assocresp_elements); 653 654 os_free(conf->sae_groups); 655 #ifdef CONFIG_OWE 656 os_free(conf->owe_groups); 657 #endif /* CONFIG_OWE */ 658 659 os_free(conf->wowlan_triggers); 660 661 os_free(conf->server_id); 662 663 #ifdef CONFIG_TESTING_OPTIONS 664 wpabuf_free(conf->own_ie_override); 665 wpabuf_free(conf->sae_commit_override); 666 #endif /* CONFIG_TESTING_OPTIONS */ 667 668 os_free(conf->no_probe_resp_if_seen_on); 669 os_free(conf->no_auth_if_seen_on); 670 671 hostapd_config_free_fils_realms(conf); 672 673 #ifdef CONFIG_DPP 674 os_free(conf->dpp_connector); 675 wpabuf_free(conf->dpp_netaccesskey); 676 wpabuf_free(conf->dpp_csign); 677 #endif /* CONFIG_DPP */ 678 679 hostapd_config_free_sae_passwords(conf); 680 681 os_free(conf); 682 } 683 684 685 /** 686 * hostapd_config_free - Free hostapd configuration 687 * @conf: Configuration data from hostapd_config_read(). 688 */ 689 void hostapd_config_free(struct hostapd_config *conf) 690 { 691 size_t i; 692 693 if (conf == NULL) 694 return; 695 696 for (i = 0; i < conf->num_bss; i++) 697 hostapd_config_free_bss(conf->bss[i]); 698 os_free(conf->bss); 699 os_free(conf->supported_rates); 700 os_free(conf->basic_rates); 701 os_free(conf->acs_ch_list.range); 702 os_free(conf->driver_params); 703 #ifdef CONFIG_ACS 704 os_free(conf->acs_chan_bias); 705 #endif /* CONFIG_ACS */ 706 wpabuf_free(conf->lci); 707 wpabuf_free(conf->civic); 708 709 os_free(conf); 710 } 711 712 713 /** 714 * hostapd_maclist_found - Find a MAC address from a list 715 * @list: MAC address list 716 * @num_entries: Number of addresses in the list 717 * @addr: Address to search for 718 * @vlan_id: Buffer for returning VLAN ID or %NULL if not needed 719 * Returns: 1 if address is in the list or 0 if not. 720 * 721 * Perform a binary search for given MAC address from a pre-sorted list. 722 */ 723 int hostapd_maclist_found(struct mac_acl_entry *list, int num_entries, 724 const u8 *addr, struct vlan_description *vlan_id) 725 { 726 int start, end, middle, res; 727 728 start = 0; 729 end = num_entries - 1; 730 731 while (start <= end) { 732 middle = (start + end) / 2; 733 res = os_memcmp(list[middle].addr, addr, ETH_ALEN); 734 if (res == 0) { 735 if (vlan_id) 736 *vlan_id = list[middle].vlan_id; 737 return 1; 738 } 739 if (res < 0) 740 start = middle + 1; 741 else 742 end = middle - 1; 743 } 744 745 return 0; 746 } 747 748 749 int hostapd_rate_found(int *list, int rate) 750 { 751 int i; 752 753 if (list == NULL) 754 return 0; 755 756 for (i = 0; list[i] >= 0; i++) 757 if (list[i] == rate) 758 return 1; 759 760 return 0; 761 } 762 763 764 int hostapd_vlan_valid(struct hostapd_vlan *vlan, 765 struct vlan_description *vlan_desc) 766 { 767 struct hostapd_vlan *v = vlan; 768 int i; 769 770 if (!vlan_desc->notempty || vlan_desc->untagged < 0 || 771 vlan_desc->untagged > MAX_VLAN_ID) 772 return 0; 773 for (i = 0; i < MAX_NUM_TAGGED_VLAN; i++) { 774 if (vlan_desc->tagged[i] < 0 || 775 vlan_desc->tagged[i] > MAX_VLAN_ID) 776 return 0; 777 } 778 if (!vlan_desc->untagged && !vlan_desc->tagged[0]) 779 return 0; 780 781 while (v) { 782 if (!vlan_compare(&v->vlan_desc, vlan_desc) || 783 v->vlan_id == VLAN_ID_WILDCARD) 784 return 1; 785 v = v->next; 786 } 787 return 0; 788 } 789 790 791 const char * hostapd_get_vlan_id_ifname(struct hostapd_vlan *vlan, int vlan_id) 792 { 793 struct hostapd_vlan *v = vlan; 794 while (v) { 795 if (v->vlan_id == vlan_id) 796 return v->ifname; 797 v = v->next; 798 } 799 return NULL; 800 } 801 802 803 const u8 * hostapd_get_psk(const struct hostapd_bss_config *conf, 804 const u8 *addr, const u8 *p2p_dev_addr, 805 const u8 *prev_psk) 806 { 807 struct hostapd_wpa_psk *psk; 808 int next_ok = prev_psk == NULL; 809 810 if (p2p_dev_addr && !is_zero_ether_addr(p2p_dev_addr)) { 811 wpa_printf(MSG_DEBUG, "Searching a PSK for " MACSTR 812 " p2p_dev_addr=" MACSTR " prev_psk=%p", 813 MAC2STR(addr), MAC2STR(p2p_dev_addr), prev_psk); 814 addr = NULL; /* Use P2P Device Address for matching */ 815 } else { 816 wpa_printf(MSG_DEBUG, "Searching a PSK for " MACSTR 817 " prev_psk=%p", 818 MAC2STR(addr), prev_psk); 819 } 820 821 for (psk = conf->ssid.wpa_psk; psk != NULL; psk = psk->next) { 822 if (next_ok && 823 (psk->group || 824 (addr && os_memcmp(psk->addr, addr, ETH_ALEN) == 0) || 825 (!addr && p2p_dev_addr && 826 os_memcmp(psk->p2p_dev_addr, p2p_dev_addr, ETH_ALEN) == 827 0))) 828 return psk->psk; 829 830 if (psk->psk == prev_psk) 831 next_ok = 1; 832 } 833 834 return NULL; 835 } 836 837 838 static int hostapd_config_check_bss(struct hostapd_bss_config *bss, 839 struct hostapd_config *conf, 840 int full_config) 841 { 842 if (full_config && bss->ieee802_1x && !bss->eap_server && 843 !bss->radius->auth_servers) { 844 wpa_printf(MSG_ERROR, "Invalid IEEE 802.1X configuration (no " 845 "EAP authenticator configured)."); 846 return -1; 847 } 848 849 if (bss->wpa) { 850 int wep, i; 851 852 wep = bss->default_wep_key_len > 0 || 853 bss->individual_wep_key_len > 0; 854 for (i = 0; i < NUM_WEP_KEYS; i++) { 855 if (bss->ssid.wep.keys_set) { 856 wep = 1; 857 break; 858 } 859 } 860 861 if (wep) { 862 wpa_printf(MSG_ERROR, "WEP configuration in a WPA network is not supported"); 863 return -1; 864 } 865 } 866 867 if (full_config && bss->wpa && 868 bss->wpa_psk_radius != PSK_RADIUS_IGNORED && 869 bss->macaddr_acl != USE_EXTERNAL_RADIUS_AUTH) { 870 wpa_printf(MSG_ERROR, "WPA-PSK using RADIUS enabled, but no " 871 "RADIUS checking (macaddr_acl=2) enabled."); 872 return -1; 873 } 874 875 if (full_config && bss->wpa && (bss->wpa_key_mgmt & WPA_KEY_MGMT_PSK) && 876 bss->ssid.wpa_psk == NULL && bss->ssid.wpa_passphrase == NULL && 877 bss->ssid.wpa_psk_file == NULL && 878 (bss->wpa_psk_radius != PSK_RADIUS_REQUIRED || 879 bss->macaddr_acl != USE_EXTERNAL_RADIUS_AUTH)) { 880 wpa_printf(MSG_ERROR, "WPA-PSK enabled, but PSK or passphrase " 881 "is not configured."); 882 return -1; 883 } 884 885 if (full_config && !is_zero_ether_addr(bss->bssid)) { 886 size_t i; 887 888 for (i = 0; i < conf->num_bss; i++) { 889 if (conf->bss[i] != bss && 890 (hostapd_mac_comp(conf->bss[i]->bssid, 891 bss->bssid) == 0)) { 892 wpa_printf(MSG_ERROR, "Duplicate BSSID " MACSTR 893 " on interface '%s' and '%s'.", 894 MAC2STR(bss->bssid), 895 conf->bss[i]->iface, bss->iface); 896 return -1; 897 } 898 } 899 } 900 901 #ifdef CONFIG_IEEE80211R_AP 902 if (full_config && wpa_key_mgmt_ft(bss->wpa_key_mgmt) && 903 (bss->nas_identifier == NULL || 904 os_strlen(bss->nas_identifier) < 1 || 905 os_strlen(bss->nas_identifier) > FT_R0KH_ID_MAX_LEN)) { 906 wpa_printf(MSG_ERROR, "FT (IEEE 802.11r) requires " 907 "nas_identifier to be configured as a 1..48 octet " 908 "string"); 909 return -1; 910 } 911 #endif /* CONFIG_IEEE80211R_AP */ 912 913 #ifdef CONFIG_IEEE80211N 914 if (full_config && conf->ieee80211n && 915 conf->hw_mode == HOSTAPD_MODE_IEEE80211B) { 916 bss->disable_11n = 1; 917 wpa_printf(MSG_ERROR, "HT (IEEE 802.11n) in 11b mode is not " 918 "allowed, disabling HT capabilities"); 919 } 920 921 if (full_config && conf->ieee80211n && 922 bss->ssid.security_policy == SECURITY_STATIC_WEP) { 923 bss->disable_11n = 1; 924 wpa_printf(MSG_ERROR, "HT (IEEE 802.11n) with WEP is not " 925 "allowed, disabling HT capabilities"); 926 } 927 928 if (full_config && conf->ieee80211n && bss->wpa && 929 !(bss->wpa_pairwise & WPA_CIPHER_CCMP) && 930 !(bss->rsn_pairwise & (WPA_CIPHER_CCMP | WPA_CIPHER_GCMP | 931 WPA_CIPHER_CCMP_256 | WPA_CIPHER_GCMP_256))) 932 { 933 bss->disable_11n = 1; 934 wpa_printf(MSG_ERROR, "HT (IEEE 802.11n) with WPA/WPA2 " 935 "requires CCMP/GCMP to be enabled, disabling HT " 936 "capabilities"); 937 } 938 #endif /* CONFIG_IEEE80211N */ 939 940 #ifdef CONFIG_IEEE80211AC 941 if (full_config && conf->ieee80211ac && 942 bss->ssid.security_policy == SECURITY_STATIC_WEP) { 943 bss->disable_11ac = 1; 944 wpa_printf(MSG_ERROR, 945 "VHT (IEEE 802.11ac) with WEP is not allowed, disabling VHT capabilities"); 946 } 947 948 if (full_config && conf->ieee80211ac && bss->wpa && 949 !(bss->wpa_pairwise & WPA_CIPHER_CCMP) && 950 !(bss->rsn_pairwise & (WPA_CIPHER_CCMP | WPA_CIPHER_GCMP | 951 WPA_CIPHER_CCMP_256 | WPA_CIPHER_GCMP_256))) 952 { 953 bss->disable_11ac = 1; 954 wpa_printf(MSG_ERROR, 955 "VHT (IEEE 802.11ac) with WPA/WPA2 requires CCMP/GCMP to be enabled, disabling VHT capabilities"); 956 } 957 #endif /* CONFIG_IEEE80211AC */ 958 959 #ifdef CONFIG_WPS 960 if (full_config && bss->wps_state && bss->ignore_broadcast_ssid) { 961 wpa_printf(MSG_INFO, "WPS: ignore_broadcast_ssid " 962 "configuration forced WPS to be disabled"); 963 bss->wps_state = 0; 964 } 965 966 if (full_config && bss->wps_state && 967 bss->ssid.wep.keys_set && bss->wpa == 0) { 968 wpa_printf(MSG_INFO, "WPS: WEP configuration forced WPS to be " 969 "disabled"); 970 bss->wps_state = 0; 971 } 972 973 if (full_config && bss->wps_state && bss->wpa && 974 (!(bss->wpa & 2) || 975 !(bss->rsn_pairwise & (WPA_CIPHER_CCMP | WPA_CIPHER_GCMP | 976 WPA_CIPHER_CCMP_256 | 977 WPA_CIPHER_GCMP_256)))) { 978 wpa_printf(MSG_INFO, "WPS: WPA/TKIP configuration without " 979 "WPA2/CCMP/GCMP forced WPS to be disabled"); 980 bss->wps_state = 0; 981 } 982 #endif /* CONFIG_WPS */ 983 984 #ifdef CONFIG_HS20 985 if (full_config && bss->hs20 && 986 (!(bss->wpa & 2) || 987 !(bss->rsn_pairwise & (WPA_CIPHER_CCMP | WPA_CIPHER_GCMP | 988 WPA_CIPHER_CCMP_256 | 989 WPA_CIPHER_GCMP_256)))) { 990 wpa_printf(MSG_ERROR, "HS 2.0: WPA2-Enterprise/CCMP " 991 "configuration is required for Hotspot 2.0 " 992 "functionality"); 993 return -1; 994 } 995 #endif /* CONFIG_HS20 */ 996 997 #ifdef CONFIG_MBO 998 if (full_config && bss->mbo_enabled && (bss->wpa & 2) && 999 bss->ieee80211w == NO_MGMT_FRAME_PROTECTION) { 1000 wpa_printf(MSG_ERROR, 1001 "MBO: PMF needs to be enabled whenever using WPA2 with MBO"); 1002 return -1; 1003 } 1004 #endif /* CONFIG_MBO */ 1005 1006 return 0; 1007 } 1008 1009 1010 static int hostapd_config_check_cw(struct hostapd_config *conf, int queue) 1011 { 1012 int tx_cwmin = conf->tx_queue[queue].cwmin; 1013 int tx_cwmax = conf->tx_queue[queue].cwmax; 1014 int ac_cwmin = conf->wmm_ac_params[queue].cwmin; 1015 int ac_cwmax = conf->wmm_ac_params[queue].cwmax; 1016 1017 if (tx_cwmin > tx_cwmax) { 1018 wpa_printf(MSG_ERROR, 1019 "Invalid TX queue cwMin/cwMax values. cwMin(%d) greater than cwMax(%d)", 1020 tx_cwmin, tx_cwmax); 1021 return -1; 1022 } 1023 if (ac_cwmin > ac_cwmax) { 1024 wpa_printf(MSG_ERROR, 1025 "Invalid WMM AC cwMin/cwMax values. cwMin(%d) greater than cwMax(%d)", 1026 ac_cwmin, ac_cwmax); 1027 return -1; 1028 } 1029 return 0; 1030 } 1031 1032 1033 int hostapd_config_check(struct hostapd_config *conf, int full_config) 1034 { 1035 size_t i; 1036 1037 if (full_config && conf->ieee80211d && 1038 (!conf->country[0] || !conf->country[1])) { 1039 wpa_printf(MSG_ERROR, "Cannot enable IEEE 802.11d without " 1040 "setting the country_code"); 1041 return -1; 1042 } 1043 1044 if (full_config && conf->ieee80211h && !conf->ieee80211d) { 1045 wpa_printf(MSG_ERROR, "Cannot enable IEEE 802.11h without " 1046 "IEEE 802.11d enabled"); 1047 return -1; 1048 } 1049 1050 if (full_config && conf->local_pwr_constraint != -1 && 1051 !conf->ieee80211d) { 1052 wpa_printf(MSG_ERROR, "Cannot add Power Constraint element without Country element"); 1053 return -1; 1054 } 1055 1056 if (full_config && conf->spectrum_mgmt_required && 1057 conf->local_pwr_constraint == -1) { 1058 wpa_printf(MSG_ERROR, "Cannot set Spectrum Management bit without Country and Power Constraint elements"); 1059 return -1; 1060 } 1061 1062 for (i = 0; i < NUM_TX_QUEUES; i++) { 1063 if (hostapd_config_check_cw(conf, i)) 1064 return -1; 1065 } 1066 1067 for (i = 0; i < conf->num_bss; i++) { 1068 if (hostapd_config_check_bss(conf->bss[i], conf, full_config)) 1069 return -1; 1070 } 1071 1072 return 0; 1073 } 1074 1075 1076 void hostapd_set_security_params(struct hostapd_bss_config *bss, 1077 int full_config) 1078 { 1079 if (bss->individual_wep_key_len == 0) { 1080 /* individual keys are not use; can use key idx0 for 1081 * broadcast keys */ 1082 bss->broadcast_key_idx_min = 0; 1083 } 1084 1085 if ((bss->wpa & 2) && bss->rsn_pairwise == 0) 1086 bss->rsn_pairwise = bss->wpa_pairwise; 1087 if (bss->group_cipher) 1088 bss->wpa_group = bss->group_cipher; 1089 else 1090 bss->wpa_group = wpa_select_ap_group_cipher(bss->wpa, 1091 bss->wpa_pairwise, 1092 bss->rsn_pairwise); 1093 if (!bss->wpa_group_rekey_set) 1094 bss->wpa_group_rekey = bss->wpa_group == WPA_CIPHER_TKIP ? 1095 600 : 86400; 1096 1097 if (full_config) { 1098 bss->radius->auth_server = bss->radius->auth_servers; 1099 bss->radius->acct_server = bss->radius->acct_servers; 1100 } 1101 1102 if (bss->wpa && bss->ieee802_1x) { 1103 bss->ssid.security_policy = SECURITY_WPA; 1104 } else if (bss->wpa) { 1105 bss->ssid.security_policy = SECURITY_WPA_PSK; 1106 } else if (bss->ieee802_1x) { 1107 int cipher = WPA_CIPHER_NONE; 1108 bss->ssid.security_policy = SECURITY_IEEE_802_1X; 1109 bss->ssid.wep.default_len = bss->default_wep_key_len; 1110 if (full_config && bss->default_wep_key_len) { 1111 cipher = bss->default_wep_key_len >= 13 ? 1112 WPA_CIPHER_WEP104 : WPA_CIPHER_WEP40; 1113 } else if (full_config && bss->ssid.wep.keys_set) { 1114 if (bss->ssid.wep.len[0] >= 13) 1115 cipher = WPA_CIPHER_WEP104; 1116 else 1117 cipher = WPA_CIPHER_WEP40; 1118 } 1119 bss->wpa_group = cipher; 1120 bss->wpa_pairwise = cipher; 1121 bss->rsn_pairwise = cipher; 1122 if (full_config) 1123 bss->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA; 1124 } else if (bss->ssid.wep.keys_set) { 1125 int cipher = WPA_CIPHER_WEP40; 1126 if (bss->ssid.wep.len[0] >= 13) 1127 cipher = WPA_CIPHER_WEP104; 1128 bss->ssid.security_policy = SECURITY_STATIC_WEP; 1129 bss->wpa_group = cipher; 1130 bss->wpa_pairwise = cipher; 1131 bss->rsn_pairwise = cipher; 1132 if (full_config) 1133 bss->wpa_key_mgmt = WPA_KEY_MGMT_NONE; 1134 } else if (bss->osen) { 1135 bss->ssid.security_policy = SECURITY_OSEN; 1136 bss->wpa_group = WPA_CIPHER_CCMP; 1137 bss->wpa_pairwise = 0; 1138 bss->rsn_pairwise = WPA_CIPHER_CCMP; 1139 } else { 1140 bss->ssid.security_policy = SECURITY_PLAINTEXT; 1141 if (full_config) { 1142 bss->wpa_group = WPA_CIPHER_NONE; 1143 bss->wpa_pairwise = WPA_CIPHER_NONE; 1144 bss->rsn_pairwise = WPA_CIPHER_NONE; 1145 bss->wpa_key_mgmt = WPA_KEY_MGMT_NONE; 1146 } 1147 } 1148 } 1149