1/* 2 * WPA Supplicant / Configuration backend: Windows registry 3 * Copyright (c) 2003-2008, 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 * This file implements a configuration backend for Windows registry. All the 9 * configuration information is stored in the registry and the format for 10 * network configuration fields is same as described in the sample 11 * configuration file, wpa_supplicant.conf. 12 * 13 * Configuration data is in 14 * \a HKEY_LOCAL_MACHINE\\SOFTWARE\\%wpa_supplicant\\configs 15 * key. Each configuration profile has its own key under this. In terms of text 16 * files, each profile would map to a separate text file with possibly multiple 17 * networks. Under each profile, there is a networks key that lists all 18 * networks as a subkey. Each network has set of values in the same way as 19 * network block in the configuration file. In addition, blobs subkey has 20 * possible blobs as values. 21 * 22 * Example network configuration block: 23 * \verbatim 24HKEY_LOCAL_MACHINE\SOFTWARE\wpa_supplicant\configs\test\networks\0000 25 ssid="example" 26 key_mgmt=WPA-PSK 27\endverbatim 28 */ 29 30#include "includes.h" 31 32#include "common.h" 33#include "uuid.h" 34#include "config.h" 35 36#ifndef WPA_KEY_ROOT 37#define WPA_KEY_ROOT HKEY_LOCAL_MACHINE 38#endif 39#ifndef WPA_KEY_PREFIX 40#define WPA_KEY_PREFIX TEXT("SOFTWARE\\wpa_supplicant") 41#endif 42 43#ifdef UNICODE 44#define TSTR "%S" 45#else /* UNICODE */ 46#define TSTR "%s" 47#endif /* UNICODE */ 48 49 50static int wpa_config_read_blobs(struct wpa_config *config, HKEY hk) 51{ 52 struct wpa_config_blob *blob; 53 int errors = 0; 54 HKEY bhk; 55 LONG ret; 56 DWORD i; 57 58 ret = RegOpenKeyEx(hk, TEXT("blobs"), 0, KEY_QUERY_VALUE, &bhk); 59 if (ret != ERROR_SUCCESS) { 60 wpa_printf(MSG_DEBUG, "Could not open wpa_supplicant config " 61 "blobs key"); 62 return 0; /* assume no blobs */ 63 } 64 65 for (i = 0; ; i++) { 66#define TNAMELEN 255 67 TCHAR name[TNAMELEN]; 68 char data[4096]; 69 DWORD namelen, datalen, type; 70 71 namelen = TNAMELEN; 72 datalen = sizeof(data); 73 ret = RegEnumValue(bhk, i, name, &namelen, NULL, &type, 74 (LPBYTE) data, &datalen); 75 76 if (ret == ERROR_NO_MORE_ITEMS) 77 break; 78 79 if (ret != ERROR_SUCCESS) { 80 wpa_printf(MSG_DEBUG, "RegEnumValue failed: 0x%x", 81 (unsigned int) ret); 82 break; 83 } 84 85 if (namelen >= TNAMELEN) 86 namelen = TNAMELEN - 1; 87 name[namelen] = TEXT('\0'); 88 wpa_unicode2ascii_inplace(name); 89 90 if (datalen >= sizeof(data)) 91 datalen = sizeof(data) - 1; 92 93 wpa_printf(MSG_MSGDUMP, "blob %d: field='%s' len %d", 94 (int) i, name, (int) datalen); 95 96 blob = os_zalloc(sizeof(*blob)); 97 if (blob == NULL) { 98 errors++; 99 break; 100 } 101 blob->name = os_strdup((char *) name); 102 blob->data = os_malloc(datalen); 103 if (blob->name == NULL || blob->data == NULL) { 104 wpa_config_free_blob(blob); 105 errors++; 106 break; 107 } 108 os_memcpy(blob->data, data, datalen); 109 blob->len = datalen; 110 111 wpa_config_set_blob(config, blob); 112 } 113 114 RegCloseKey(bhk); 115 116 return errors ? -1 : 0; 117} 118 119 120static int wpa_config_read_reg_dword(HKEY hk, const TCHAR *name, int *_val) 121{ 122 DWORD val, buflen; 123 LONG ret; 124 125 buflen = sizeof(val); 126 ret = RegQueryValueEx(hk, name, NULL, NULL, (LPBYTE) &val, &buflen); 127 if (ret == ERROR_SUCCESS && buflen == sizeof(val)) { 128 wpa_printf(MSG_DEBUG, TSTR "=%d", name, (int) val); 129 *_val = val; 130 return 0; 131 } 132 133 return -1; 134} 135 136 137static char * wpa_config_read_reg_string(HKEY hk, const TCHAR *name) 138{ 139 DWORD buflen; 140 LONG ret; 141 TCHAR *val; 142 143 buflen = 0; 144 ret = RegQueryValueEx(hk, name, NULL, NULL, NULL, &buflen); 145 if (ret != ERROR_SUCCESS) 146 return NULL; 147 val = os_malloc(buflen); 148 if (val == NULL) 149 return NULL; 150 151 ret = RegQueryValueEx(hk, name, NULL, NULL, (LPBYTE) val, &buflen); 152 if (ret != ERROR_SUCCESS) { 153 os_free(val); 154 return NULL; 155 } 156 157 wpa_unicode2ascii_inplace(val); 158 wpa_printf(MSG_DEBUG, TSTR "=%s", name, (char *) val); 159 return (char *) val; 160} 161 162 163#ifdef CONFIG_WPS 164static int wpa_config_read_global_uuid(struct wpa_config *config, HKEY hk) 165{ 166 char *str; 167 int ret = 0; 168 169 str = wpa_config_read_reg_string(hk, TEXT("uuid")); 170 if (str == NULL) 171 return 0; 172 173 if (uuid_str2bin(str, config->uuid)) 174 ret = -1; 175 176 os_free(str); 177 178 return ret; 179} 180 181 182static int wpa_config_read_global_os_version(struct wpa_config *config, 183 HKEY hk) 184{ 185 char *str; 186 int ret = 0; 187 188 str = wpa_config_read_reg_string(hk, TEXT("os_version")); 189 if (str == NULL) 190 return 0; 191 192 if (hexstr2bin(str, config->os_version, 4)) 193 ret = -1; 194 195 os_free(str); 196 197 return ret; 198} 199#endif /* CONFIG_WPS */ 200 201 202static int wpa_config_read_global(struct wpa_config *config, HKEY hk) 203{ 204 int errors = 0; 205 int val; 206 207 wpa_config_read_reg_dword(hk, TEXT("ap_scan"), &config->ap_scan); 208 wpa_config_read_reg_dword(hk, TEXT("fast_reauth"), 209 &config->fast_reauth); 210 wpa_config_read_reg_dword(hk, TEXT("dot11RSNAConfigPMKLifetime"), 211 (int *) &config->dot11RSNAConfigPMKLifetime); 212 wpa_config_read_reg_dword(hk, 213 TEXT("dot11RSNAConfigPMKReauthThreshold"), 214 (int *) 215 &config->dot11RSNAConfigPMKReauthThreshold); 216 wpa_config_read_reg_dword(hk, TEXT("dot11RSNAConfigSATimeout"), 217 (int *) &config->dot11RSNAConfigSATimeout); 218 wpa_config_read_reg_dword(hk, TEXT("update_config"), 219 &config->update_config); 220 221 if (wpa_config_read_reg_dword(hk, TEXT("eapol_version"), 222 &config->eapol_version) == 0) { 223 if (config->eapol_version < 1 || 224 config->eapol_version > 2) { 225 wpa_printf(MSG_ERROR, "Invalid EAPOL version (%d)", 226 config->eapol_version); 227 errors++; 228 } 229 } 230 231 config->ctrl_interface = wpa_config_read_reg_string( 232 hk, TEXT("ctrl_interface")); 233 234#ifdef CONFIG_WPS 235 if (wpa_config_read_global_uuid(config, hk)) 236 errors++; 237 config->device_name = wpa_config_read_reg_string( 238 hk, TEXT("device_name")); 239 config->manufacturer = wpa_config_read_reg_string( 240 hk, TEXT("manufacturer")); 241 config->model_name = wpa_config_read_reg_string( 242 hk, TEXT("model_name")); 243 config->serial_number = wpa_config_read_reg_string( 244 hk, TEXT("serial_number")); 245 { 246 char *t = wpa_config_read_reg_string( 247 hk, TEXT("device_type")); 248 if (t && wps_dev_type_str2bin(t, config->device_type)) 249 errors++; 250 os_free(t); 251 } 252 config->config_methods = wpa_config_read_reg_string( 253 hk, TEXT("config_methods")); 254 if (wpa_config_read_global_os_version(config, hk)) 255 errors++; 256 wpa_config_read_reg_dword(hk, TEXT("wps_cred_processing"), 257 &config->wps_cred_processing); 258#endif /* CONFIG_WPS */ 259#ifdef CONFIG_P2P 260 config->p2p_ssid_postfix = wpa_config_read_reg_string( 261 hk, TEXT("p2p_ssid_postfix")); 262 wpa_config_read_reg_dword(hk, TEXT("p2p_group_idle"), 263 (int *) &config->p2p_group_idle); 264#endif /* CONFIG_P2P */ 265 266 wpa_config_read_reg_dword(hk, TEXT("bss_max_count"), 267 (int *) &config->bss_max_count); 268 wpa_config_read_reg_dword(hk, TEXT("filter_ssids"), 269 &config->filter_ssids); 270 wpa_config_read_reg_dword(hk, TEXT("max_num_sta"), 271 (int *) &config->max_num_sta); 272 wpa_config_read_reg_dword(hk, TEXT("disassoc_low_ack"), 273 (int *) &config->disassoc_low_ack); 274 275 wpa_config_read_reg_dword(hk, TEXT("okc"), &config->okc); 276 wpa_config_read_reg_dword(hk, TEXT("pmf"), &val); 277 config->pmf = val; 278 279 return errors ? -1 : 0; 280} 281 282 283static struct wpa_ssid * wpa_config_read_network(HKEY hk, const TCHAR *netw, 284 int id) 285{ 286 HKEY nhk; 287 LONG ret; 288 DWORD i; 289 struct wpa_ssid *ssid; 290 int errors = 0; 291 292 ret = RegOpenKeyEx(hk, netw, 0, KEY_QUERY_VALUE, &nhk); 293 if (ret != ERROR_SUCCESS) { 294 wpa_printf(MSG_DEBUG, "Could not open wpa_supplicant config " 295 "network '" TSTR "'", netw); 296 return NULL; 297 } 298 299 wpa_printf(MSG_MSGDUMP, "Start of a new network '" TSTR "'", netw); 300 ssid = os_zalloc(sizeof(*ssid)); 301 if (ssid == NULL) { 302 RegCloseKey(nhk); 303 return NULL; 304 } 305 dl_list_init(&ssid->psk_list); 306 ssid->id = id; 307 308 wpa_config_set_network_defaults(ssid); 309 310 for (i = 0; ; i++) { 311 TCHAR name[255], data[1024]; 312 DWORD namelen, datalen, type; 313 314 namelen = 255; 315 datalen = sizeof(data); 316 ret = RegEnumValue(nhk, i, name, &namelen, NULL, &type, 317 (LPBYTE) data, &datalen); 318 319 if (ret == ERROR_NO_MORE_ITEMS) 320 break; 321 322 if (ret != ERROR_SUCCESS) { 323 wpa_printf(MSG_ERROR, "RegEnumValue failed: 0x%x", 324 (unsigned int) ret); 325 break; 326 } 327 328 if (namelen >= 255) 329 namelen = 255 - 1; 330 name[namelen] = TEXT('\0'); 331 332 if (datalen >= 1024) 333 datalen = 1024 - 1; 334 data[datalen] = TEXT('\0'); 335 336 wpa_unicode2ascii_inplace(name); 337 wpa_unicode2ascii_inplace(data); 338 if (wpa_config_set(ssid, (char *) name, (char *) data, 0) < 0) 339 errors++; 340 } 341 342 RegCloseKey(nhk); 343 344 if (ssid->passphrase) { 345 if (ssid->psk_set) { 346 wpa_printf(MSG_ERROR, "Both PSK and passphrase " 347 "configured for network '" TSTR "'.", netw); 348 errors++; 349 } 350 wpa_config_update_psk(ssid); 351 } 352 353 if ((ssid->group_cipher & WPA_CIPHER_CCMP) && 354 !(ssid->pairwise_cipher & WPA_CIPHER_CCMP) && 355 !(ssid->pairwise_cipher & WPA_CIPHER_NONE)) { 356 /* Group cipher cannot be stronger than the pairwise cipher. */ 357 wpa_printf(MSG_DEBUG, "Removed CCMP from group cipher " 358 "list since it was not allowed for pairwise " 359 "cipher for network '" TSTR "'.", netw); 360 ssid->group_cipher &= ~WPA_CIPHER_CCMP; 361 } 362 363 if (errors) { 364 wpa_config_free_ssid(ssid); 365 ssid = NULL; 366 } 367 368 return ssid; 369} 370 371 372static int wpa_config_read_networks(struct wpa_config *config, HKEY hk) 373{ 374 HKEY nhk; 375 struct wpa_ssid *ssid, *tail = NULL, *head = NULL; 376 int errors = 0; 377 LONG ret; 378 DWORD i; 379 380 ret = RegOpenKeyEx(hk, TEXT("networks"), 0, KEY_ENUMERATE_SUB_KEYS, 381 &nhk); 382 if (ret != ERROR_SUCCESS) { 383 wpa_printf(MSG_ERROR, "Could not open wpa_supplicant networks " 384 "registry key"); 385 return -1; 386 } 387 388 for (i = 0; ; i++) { 389 TCHAR name[255]; 390 DWORD namelen; 391 392 namelen = 255; 393 ret = RegEnumKeyEx(nhk, i, name, &namelen, NULL, NULL, NULL, 394 NULL); 395 396 if (ret == ERROR_NO_MORE_ITEMS) 397 break; 398 399 if (ret != ERROR_SUCCESS) { 400 wpa_printf(MSG_DEBUG, "RegEnumKeyEx failed: 0x%x", 401 (unsigned int) ret); 402 break; 403 } 404 405 if (namelen >= 255) 406 namelen = 255 - 1; 407 name[namelen] = '\0'; 408 409 ssid = wpa_config_read_network(nhk, name, i); 410 if (ssid == NULL) { 411 wpa_printf(MSG_ERROR, "Failed to parse network " 412 "profile '%s'.", name); 413 errors++; 414 continue; 415 } 416 if (head == NULL) { 417 head = tail = ssid; 418 } else { 419 tail->next = ssid; 420 tail = ssid; 421 } 422 if (wpa_config_add_prio_network(config, ssid)) { 423 wpa_printf(MSG_ERROR, "Failed to add network profile " 424 "'%s' to priority list.", name); 425 errors++; 426 continue; 427 } 428 } 429 430 RegCloseKey(nhk); 431 432 config->ssid = head; 433 434 return errors ? -1 : 0; 435} 436 437 438struct wpa_config * wpa_config_read(const char *name, struct wpa_config *cfgp) 439{ 440 TCHAR buf[256]; 441 int errors = 0; 442 struct wpa_config *config; 443 HKEY hk; 444 LONG ret; 445 446 if (name == NULL) 447 return NULL; 448 if (cfgp) 449 config = cfgp; 450 else 451 config = wpa_config_alloc_empty(NULL, NULL); 452 if (config == NULL) 453 return NULL; 454 wpa_printf(MSG_DEBUG, "Reading configuration profile '%s'", name); 455 456#ifdef UNICODE 457 _snwprintf(buf, 256, WPA_KEY_PREFIX TEXT("\\configs\\%S"), name); 458#else /* UNICODE */ 459 os_snprintf(buf, 256, WPA_KEY_PREFIX TEXT("\\configs\\%s"), name); 460#endif /* UNICODE */ 461 462 ret = RegOpenKeyEx(WPA_KEY_ROOT, buf, 0, KEY_QUERY_VALUE, &hk); 463 if (ret != ERROR_SUCCESS) { 464 wpa_printf(MSG_ERROR, "Could not open wpa_supplicant " 465 "configuration registry HKLM\\" TSTR, buf); 466 os_free(config); 467 return NULL; 468 } 469 470 if (wpa_config_read_global(config, hk)) 471 errors++; 472 473 if (wpa_config_read_networks(config, hk)) 474 errors++; 475 476 if (wpa_config_read_blobs(config, hk)) 477 errors++; 478 479 wpa_config_debug_dump_networks(config); 480 481 RegCloseKey(hk); 482 483 if (errors) { 484 wpa_config_free(config); 485 config = NULL; 486 } 487 488 return config; 489} 490 491 492static int wpa_config_write_reg_dword(HKEY hk, const TCHAR *name, int val, 493 int def) 494{ 495 LONG ret; 496 DWORD _val = val; 497 498 if (val == def) { 499 RegDeleteValue(hk, name); 500 return 0; 501 } 502 503 ret = RegSetValueEx(hk, name, 0, REG_DWORD, (LPBYTE) &_val, 504 sizeof(_val)); 505 if (ret != ERROR_SUCCESS) { 506 wpa_printf(MSG_ERROR, "WINREG: Failed to set %s=%d: error %d", 507 name, val, (int) GetLastError()); 508 return -1; 509 } 510 511 return 0; 512} 513 514 515static int wpa_config_write_reg_string(HKEY hk, const char *name, 516 const char *val) 517{ 518 LONG ret; 519 TCHAR *_name, *_val; 520 521 _name = wpa_strdup_tchar(name); 522 if (_name == NULL) 523 return -1; 524 525 if (val == NULL) { 526 RegDeleteValue(hk, _name); 527 os_free(_name); 528 return 0; 529 } 530 531 _val = wpa_strdup_tchar(val); 532 if (_val == NULL) { 533 os_free(_name); 534 return -1; 535 } 536 ret = RegSetValueEx(hk, _name, 0, REG_SZ, (BYTE *) _val, 537 (os_strlen(val) + 1) * sizeof(TCHAR)); 538 if (ret != ERROR_SUCCESS) { 539 wpa_printf(MSG_ERROR, "WINREG: Failed to set %s='%s': " 540 "error %d", name, val, (int) GetLastError()); 541 os_free(_name); 542 os_free(_val); 543 return -1; 544 } 545 546 os_free(_name); 547 os_free(_val); 548 return 0; 549} 550 551 552static int wpa_config_write_global(struct wpa_config *config, HKEY hk) 553{ 554#ifdef CONFIG_CTRL_IFACE 555 wpa_config_write_reg_string(hk, "ctrl_interface", 556 config->ctrl_interface); 557#endif /* CONFIG_CTRL_IFACE */ 558 559 wpa_config_write_reg_dword(hk, TEXT("eapol_version"), 560 config->eapol_version, 561 DEFAULT_EAPOL_VERSION); 562 wpa_config_write_reg_dword(hk, TEXT("ap_scan"), config->ap_scan, 563 DEFAULT_AP_SCAN); 564 wpa_config_write_reg_dword(hk, TEXT("fast_reauth"), 565 config->fast_reauth, DEFAULT_FAST_REAUTH); 566 wpa_config_write_reg_dword(hk, TEXT("dot11RSNAConfigPMKLifetime"), 567 config->dot11RSNAConfigPMKLifetime, 0); 568 wpa_config_write_reg_dword(hk, 569 TEXT("dot11RSNAConfigPMKReauthThreshold"), 570 config->dot11RSNAConfigPMKReauthThreshold, 571 0); 572 wpa_config_write_reg_dword(hk, TEXT("dot11RSNAConfigSATimeout"), 573 config->dot11RSNAConfigSATimeout, 0); 574 wpa_config_write_reg_dword(hk, TEXT("update_config"), 575 config->update_config, 576 0); 577#ifdef CONFIG_WPS 578 if (!is_nil_uuid(config->uuid)) { 579 char buf[40]; 580 uuid_bin2str(config->uuid, buf, sizeof(buf)); 581 wpa_config_write_reg_string(hk, "uuid", buf); 582 } 583 wpa_config_write_reg_string(hk, "device_name", config->device_name); 584 wpa_config_write_reg_string(hk, "manufacturer", config->manufacturer); 585 wpa_config_write_reg_string(hk, "model_name", config->model_name); 586 wpa_config_write_reg_string(hk, "model_number", config->model_number); 587 wpa_config_write_reg_string(hk, "serial_number", 588 config->serial_number); 589 { 590 char _buf[WPS_DEV_TYPE_BUFSIZE], *buf; 591 buf = wps_dev_type_bin2str(config->device_type, 592 _buf, sizeof(_buf)); 593 wpa_config_write_reg_string(hk, "device_type", buf); 594 } 595 wpa_config_write_reg_string(hk, "config_methods", 596 config->config_methods); 597 if (WPA_GET_BE32(config->os_version)) { 598 char vbuf[10]; 599 os_snprintf(vbuf, sizeof(vbuf), "%08x", 600 WPA_GET_BE32(config->os_version)); 601 wpa_config_write_reg_string(hk, "os_version", vbuf); 602 } 603 wpa_config_write_reg_dword(hk, TEXT("wps_cred_processing"), 604 config->wps_cred_processing, 0); 605#endif /* CONFIG_WPS */ 606#ifdef CONFIG_P2P 607 wpa_config_write_reg_string(hk, "p2p_ssid_postfix", 608 config->p2p_ssid_postfix); 609 wpa_config_write_reg_dword(hk, TEXT("p2p_group_idle"), 610 config->p2p_group_idle, 0); 611#endif /* CONFIG_P2P */ 612 613 wpa_config_write_reg_dword(hk, TEXT("bss_max_count"), 614 config->bss_max_count, 615 DEFAULT_BSS_MAX_COUNT); 616 wpa_config_write_reg_dword(hk, TEXT("filter_ssids"), 617 config->filter_ssids, 0); 618 wpa_config_write_reg_dword(hk, TEXT("max_num_sta"), 619 config->max_num_sta, DEFAULT_MAX_NUM_STA); 620 wpa_config_write_reg_dword(hk, TEXT("disassoc_low_ack"), 621 config->disassoc_low_ack, 0); 622 623 wpa_config_write_reg_dword(hk, TEXT("okc"), config->okc, 0); 624 wpa_config_write_reg_dword(hk, TEXT("pmf"), config->pmf, 0); 625 626 wpa_config_write_reg_dword(hk, TEXT("external_sim"), 627 config->external_sim, 0); 628 629 return 0; 630} 631 632 633static int wpa_config_delete_subkeys(HKEY hk, const TCHAR *key) 634{ 635 HKEY nhk; 636 int i, errors = 0; 637 LONG ret; 638 639 ret = RegOpenKeyEx(hk, key, 0, KEY_ENUMERATE_SUB_KEYS | DELETE, &nhk); 640 if (ret != ERROR_SUCCESS) { 641 wpa_printf(MSG_DEBUG, "WINREG: Could not open key '" TSTR 642 "' for subkey deletion: error 0x%x (%d)", key, 643 (unsigned int) ret, (int) GetLastError()); 644 return 0; 645 } 646 647 for (i = 0; ; i++) { 648 TCHAR name[255]; 649 DWORD namelen; 650 651 namelen = 255; 652 ret = RegEnumKeyEx(nhk, i, name, &namelen, NULL, NULL, NULL, 653 NULL); 654 655 if (ret == ERROR_NO_MORE_ITEMS) 656 break; 657 658 if (ret != ERROR_SUCCESS) { 659 wpa_printf(MSG_DEBUG, "RegEnumKeyEx failed: 0x%x (%d)", 660 (unsigned int) ret, (int) GetLastError()); 661 break; 662 } 663 664 if (namelen >= 255) 665 namelen = 255 - 1; 666 name[namelen] = TEXT('\0'); 667 668 ret = RegDeleteKey(nhk, name); 669 if (ret != ERROR_SUCCESS) { 670 wpa_printf(MSG_DEBUG, "RegDeleteKey failed: 0x%x (%d)", 671 (unsigned int) ret, (int) GetLastError()); 672 errors++; 673 } 674 } 675 676 RegCloseKey(nhk); 677 678 return errors ? -1 : 0; 679} 680 681 682static void write_str(HKEY hk, const char *field, struct wpa_ssid *ssid) 683{ 684 char *value = wpa_config_get(ssid, field); 685 if (value == NULL) 686 return; 687 wpa_config_write_reg_string(hk, field, value); 688 os_free(value); 689} 690 691 692static void write_int(HKEY hk, const char *field, int value, int def) 693{ 694 char val[20]; 695 if (value == def) 696 return; 697 os_snprintf(val, sizeof(val), "%d", value); 698 wpa_config_write_reg_string(hk, field, val); 699} 700 701 702static void write_bssid(HKEY hk, struct wpa_ssid *ssid) 703{ 704 char *value = wpa_config_get(ssid, "bssid"); 705 if (value == NULL) 706 return; 707 wpa_config_write_reg_string(hk, "bssid", value); 708 os_free(value); 709} 710 711 712static void write_psk(HKEY hk, struct wpa_ssid *ssid) 713{ 714 char *value = wpa_config_get(ssid, "psk"); 715 if (value == NULL) 716 return; 717 wpa_config_write_reg_string(hk, "psk", value); 718 os_free(value); 719} 720 721 722static void write_proto(HKEY hk, struct wpa_ssid *ssid) 723{ 724 char *value; 725 726 if (ssid->proto == DEFAULT_PROTO) 727 return; 728 729 value = wpa_config_get(ssid, "proto"); 730 if (value == NULL) 731 return; 732 if (value[0]) 733 wpa_config_write_reg_string(hk, "proto", value); 734 os_free(value); 735} 736 737 738static void write_key_mgmt(HKEY hk, struct wpa_ssid *ssid) 739{ 740 char *value; 741 742 if (ssid->key_mgmt == DEFAULT_KEY_MGMT) 743 return; 744 745 value = wpa_config_get(ssid, "key_mgmt"); 746 if (value == NULL) 747 return; 748 if (value[0]) 749 wpa_config_write_reg_string(hk, "key_mgmt", value); 750 os_free(value); 751} 752 753 754static void write_pairwise(HKEY hk, struct wpa_ssid *ssid) 755{ 756 char *value; 757 758 if (ssid->pairwise_cipher == DEFAULT_PAIRWISE) 759 return; 760 761 value = wpa_config_get(ssid, "pairwise"); 762 if (value == NULL) 763 return; 764 if (value[0]) 765 wpa_config_write_reg_string(hk, "pairwise", value); 766 os_free(value); 767} 768 769 770static void write_group(HKEY hk, struct wpa_ssid *ssid) 771{ 772 char *value; 773 774 if (ssid->group_cipher == DEFAULT_GROUP) 775 return; 776 777 value = wpa_config_get(ssid, "group"); 778 if (value == NULL) 779 return; 780 if (value[0]) 781 wpa_config_write_reg_string(hk, "group", value); 782 os_free(value); 783} 784 785 786static void write_auth_alg(HKEY hk, struct wpa_ssid *ssid) 787{ 788 char *value; 789 790 if (ssid->auth_alg == 0) 791 return; 792 793 value = wpa_config_get(ssid, "auth_alg"); 794 if (value == NULL) 795 return; 796 if (value[0]) 797 wpa_config_write_reg_string(hk, "auth_alg", value); 798 os_free(value); 799} 800 801 802#ifdef IEEE8021X_EAPOL 803static void write_eap(HKEY hk, struct wpa_ssid *ssid) 804{ 805 char *value; 806 807 value = wpa_config_get(ssid, "eap"); 808 if (value == NULL) 809 return; 810 811 if (value[0]) 812 wpa_config_write_reg_string(hk, "eap", value); 813 os_free(value); 814} 815#endif /* IEEE8021X_EAPOL */ 816 817 818static void write_wep_key(HKEY hk, int idx, struct wpa_ssid *ssid) 819{ 820 char field[20], *value; 821 822 os_snprintf(field, sizeof(field), "wep_key%d", idx); 823 value = wpa_config_get(ssid, field); 824 if (value) { 825 wpa_config_write_reg_string(hk, field, value); 826 os_free(value); 827 } 828} 829 830 831static int wpa_config_write_network(HKEY hk, struct wpa_ssid *ssid, int id) 832{ 833 int i, errors = 0; 834 HKEY nhk, netw; 835 LONG ret; 836 TCHAR name[5]; 837 838 ret = RegOpenKeyEx(hk, TEXT("networks"), 0, KEY_CREATE_SUB_KEY, &nhk); 839 if (ret != ERROR_SUCCESS) { 840 wpa_printf(MSG_DEBUG, "WINREG: Could not open networks key " 841 "for subkey addition: error 0x%x (%d)", 842 (unsigned int) ret, (int) GetLastError()); 843 return 0; 844 } 845 846#ifdef UNICODE 847 wsprintf(name, L"%04d", id); 848#else /* UNICODE */ 849 os_snprintf(name, sizeof(name), "%04d", id); 850#endif /* UNICODE */ 851 ret = RegCreateKeyEx(nhk, name, 0, NULL, 0, KEY_WRITE, NULL, &netw, 852 NULL); 853 RegCloseKey(nhk); 854 if (ret != ERROR_SUCCESS) { 855 wpa_printf(MSG_DEBUG, "WINREG: Could not add network key '%s':" 856 " error 0x%x (%d)", 857 name, (unsigned int) ret, (int) GetLastError()); 858 return -1; 859 } 860 861#define STR(t) write_str(netw, #t, ssid) 862#define INT(t) write_int(netw, #t, ssid->t, 0) 863#define INTe(t) write_int(netw, #t, ssid->eap.t, 0) 864#define INT_DEF(t, def) write_int(netw, #t, ssid->t, def) 865#define INT_DEFe(t, def) write_int(netw, #t, ssid->eap.t, def) 866 867 STR(ssid); 868 INT(scan_ssid); 869 write_bssid(netw, ssid); 870 write_psk(netw, ssid); 871 write_proto(netw, ssid); 872 write_key_mgmt(netw, ssid); 873 write_pairwise(netw, ssid); 874 write_group(netw, ssid); 875 write_auth_alg(netw, ssid); 876#ifdef IEEE8021X_EAPOL 877 write_eap(netw, ssid); 878 STR(identity); 879 STR(anonymous_identity); 880 STR(password); 881 STR(ca_cert); 882 STR(ca_path); 883 STR(client_cert); 884 STR(private_key); 885 STR(private_key_passwd); 886 STR(dh_file); 887 STR(subject_match); 888 STR(altsubject_match); 889 STR(ca_cert2); 890 STR(ca_path2); 891 STR(client_cert2); 892 STR(private_key2); 893 STR(private_key2_passwd); 894 STR(dh_file2); 895 STR(subject_match2); 896 STR(altsubject_match2); 897 STR(phase1); 898 STR(phase2); 899 STR(pcsc); 900 STR(pin); 901 STR(engine_id); 902 STR(key_id); 903 STR(cert_id); 904 STR(ca_cert_id); 905 STR(key2_id); 906 STR(pin2); 907 STR(engine2_id); 908 STR(cert2_id); 909 STR(ca_cert2_id); 910 INTe(engine); 911 INTe(engine2); 912 INT_DEF(eapol_flags, DEFAULT_EAPOL_FLAGS); 913#endif /* IEEE8021X_EAPOL */ 914 for (i = 0; i < 4; i++) 915 write_wep_key(netw, i, ssid); 916 INT(wep_tx_keyidx); 917 INT(priority); 918#ifdef IEEE8021X_EAPOL 919 INT_DEF(eap_workaround, DEFAULT_EAP_WORKAROUND); 920 STR(pac_file); 921 INT_DEFe(fragment_size, DEFAULT_FRAGMENT_SIZE); 922#endif /* IEEE8021X_EAPOL */ 923 INT(mode); 924 write_int(netw, "proactive_key_caching", ssid->proactive_key_caching, 925 -1); 926 INT(disabled); 927 INT(peerkey); 928#ifdef CONFIG_IEEE80211W 929 write_int(netw, "ieee80211w", ssid->ieee80211w, 930 MGMT_FRAME_PROTECTION_DEFAULT); 931#endif /* CONFIG_IEEE80211W */ 932 STR(id_str); 933#ifdef CONFIG_HS20 934 INT(update_identifier); 935#endif /* CONFIG_HS20 */ 936 937#undef STR 938#undef INT 939#undef INT_DEF 940 941 RegCloseKey(netw); 942 943 return errors ? -1 : 0; 944} 945 946 947static int wpa_config_write_blob(HKEY hk, struct wpa_config_blob *blob) 948{ 949 HKEY bhk; 950 LONG ret; 951 TCHAR *name; 952 953 ret = RegCreateKeyEx(hk, TEXT("blobs"), 0, NULL, 0, KEY_WRITE, NULL, 954 &bhk, NULL); 955 if (ret != ERROR_SUCCESS) { 956 wpa_printf(MSG_DEBUG, "WINREG: Could not add blobs key: " 957 "error 0x%x (%d)", 958 (unsigned int) ret, (int) GetLastError()); 959 return -1; 960 } 961 962 name = wpa_strdup_tchar(blob->name); 963 ret = RegSetValueEx(bhk, name, 0, REG_BINARY, blob->data, 964 blob->len); 965 if (ret != ERROR_SUCCESS) { 966 wpa_printf(MSG_ERROR, "WINREG: Failed to set blob %s': " 967 "error 0x%x (%d)", blob->name, (unsigned int) ret, 968 (int) GetLastError()); 969 RegCloseKey(bhk); 970 os_free(name); 971 return -1; 972 } 973 os_free(name); 974 975 RegCloseKey(bhk); 976 977 return 0; 978} 979 980 981int wpa_config_write(const char *name, struct wpa_config *config) 982{ 983 TCHAR buf[256]; 984 HKEY hk; 985 LONG ret; 986 int errors = 0; 987 struct wpa_ssid *ssid; 988 struct wpa_config_blob *blob; 989 int id; 990 991 wpa_printf(MSG_DEBUG, "Writing configuration file '%s'", name); 992 993#ifdef UNICODE 994 _snwprintf(buf, 256, WPA_KEY_PREFIX TEXT("\\configs\\%S"), name); 995#else /* UNICODE */ 996 os_snprintf(buf, 256, WPA_KEY_PREFIX TEXT("\\configs\\%s"), name); 997#endif /* UNICODE */ 998 999 ret = RegOpenKeyEx(WPA_KEY_ROOT, buf, 0, KEY_SET_VALUE | DELETE, &hk); 1000 if (ret != ERROR_SUCCESS) { 1001 wpa_printf(MSG_ERROR, "Could not open wpa_supplicant " 1002 "configuration registry %s: error %d", buf, 1003 (int) GetLastError()); 1004 return -1; 1005 } 1006 1007 if (wpa_config_write_global(config, hk)) { 1008 wpa_printf(MSG_ERROR, "Failed to write global configuration " 1009 "data"); 1010 errors++; 1011 } 1012 1013 wpa_config_delete_subkeys(hk, TEXT("networks")); 1014 for (ssid = config->ssid, id = 0; ssid; ssid = ssid->next, id++) { 1015 if (ssid->key_mgmt == WPA_KEY_MGMT_WPS) 1016 continue; /* do not save temporary WPS networks */ 1017 if (wpa_config_write_network(hk, ssid, id)) 1018 errors++; 1019 } 1020 1021 RegDeleteKey(hk, TEXT("blobs")); 1022 for (blob = config->blobs; blob; blob = blob->next) { 1023 if (wpa_config_write_blob(hk, blob)) 1024 errors++; 1025 } 1026 1027 RegCloseKey(hk); 1028 1029 wpa_printf(MSG_DEBUG, "Configuration '%s' written %ssuccessfully", 1030 name, errors ? "un" : ""); 1031 return errors ? -1 : 0; 1032} 1033