www.project-moonshot.org Git - mech_eap.orig/blob - src/wps/wps_common.c

   1 /*
   2  * Wi-Fi Protected Setup - common functionality
   3  * Copyright (c) 2008-2009, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16
  17 #include "common.h"
  18 #include "crypto/aes_wrap.h"
  19 #include "crypto/crypto.h"
  20 #include "crypto/dh_group5.h"
  21 #include "crypto/sha1.h"
  22 #include "crypto/sha256.h"
  23 #include "wps_i.h"
  24 #include "wps_dev_attr.h"
  25
  26
  27 void wps_kdf(const u8 *key, const u8 *label_prefix, size_t label_prefix_len,
  28              const char *label, u8 *res, size_t res_len)
  29 {
  30         u8 i_buf[4], key_bits[4];
  31         const u8 *addr[4];
  32         size_t len[4];
  33         int i, iter;
  34         u8 hash[SHA256_MAC_LEN], *opos;
  35         size_t left;
  36
  37         WPA_PUT_BE32(key_bits, res_len * 8);
  38
  39         addr[0] = i_buf;
  40         len[0] = sizeof(i_buf);
  41         addr[1] = label_prefix;
  42         len[1] = label_prefix_len;
  43         addr[2] = (const u8 *) label;
  44         len[2] = os_strlen(label);
  45         addr[3] = key_bits;
  46         len[3] = sizeof(key_bits);
  47
  48         iter = (res_len + SHA256_MAC_LEN - 1) / SHA256_MAC_LEN;
  49         opos = res;
  50         left = res_len;
  51
  52         for (i = 1; i <= iter; i++) {
  53                 WPA_PUT_BE32(i_buf, i);
  54                 hmac_sha256_vector(key, SHA256_MAC_LEN, 4, addr, len, hash);
  55                 if (i < iter) {
  56                         os_memcpy(opos, hash, SHA256_MAC_LEN);
  57                         opos += SHA256_MAC_LEN;
  58                         left -= SHA256_MAC_LEN;
  59                 } else
  60                         os_memcpy(opos, hash, left);
  61         }
  62 }
  63
  64
  65 int wps_derive_keys(struct wps_data *wps)
  66 {
  67         struct wpabuf *pubkey, *dh_shared;
  68         u8 dhkey[SHA256_MAC_LEN], kdk[SHA256_MAC_LEN];
  69         const u8 *addr[3];
  70         size_t len[3];
  71         u8 keys[WPS_AUTHKEY_LEN + WPS_KEYWRAPKEY_LEN + WPS_EMSK_LEN];
  72
  73         if (wps->dh_privkey == NULL) {
  74                 wpa_printf(MSG_DEBUG, "WPS: Own DH private key not available");
  75                 return -1;
  76         }
  77
  78         pubkey = wps->registrar ? wps->dh_pubkey_e : wps->dh_pubkey_r;
  79         if (pubkey == NULL) {
  80                 wpa_printf(MSG_DEBUG, "WPS: Peer DH public key not available");
  81                 return -1;
  82         }
  83
  84         wpa_hexdump_buf_key(MSG_DEBUG, "WPS: DH Private Key", wps->dh_privkey);
  85         wpa_hexdump_buf(MSG_DEBUG, "WPS: DH peer Public Key", pubkey);
  86         dh_shared = dh5_derive_shared(wps->dh_ctx, pubkey, wps->dh_privkey);
  87         dh5_free(wps->dh_ctx);
  88         wps->dh_ctx = NULL;
  89         dh_shared = wpabuf_zeropad(dh_shared, 192);
  90         if (dh_shared == NULL) {
  91                 wpa_printf(MSG_DEBUG, "WPS: Failed to derive DH shared key");
  92                 return -1;
  93         }
  94
  95         /* Own DH private key is not needed anymore */
  96         wpabuf_free(wps->dh_privkey);
  97         wps->dh_privkey = NULL;
  98
  99         wpa_hexdump_buf_key(MSG_DEBUG, "WPS: DH shared key", dh_shared);
 100
 101         /* DHKey = SHA-256(g^AB mod p) */
 102         addr[0] = wpabuf_head(dh_shared);
 103         len[0] = wpabuf_len(dh_shared);
 104         sha256_vector(1, addr, len, dhkey);
 105         wpa_hexdump_key(MSG_DEBUG, "WPS: DHKey", dhkey, sizeof(dhkey));
 106         wpabuf_free(dh_shared);
 107
 108         /* KDK = HMAC-SHA-256_DHKey(N1 || EnrolleeMAC || N2) */
 109         addr[0] = wps->nonce_e;
 110         len[0] = WPS_NONCE_LEN;
 111         addr[1] = wps->mac_addr_e;
 112         len[1] = ETH_ALEN;
 113         addr[2] = wps->nonce_r;
 114         len[2] = WPS_NONCE_LEN;
 115         hmac_sha256_vector(dhkey, sizeof(dhkey), 3, addr, len, kdk);
 116         wpa_hexdump_key(MSG_DEBUG, "WPS: KDK", kdk, sizeof(kdk));
 117
 118         wps_kdf(kdk, NULL, 0, "Wi-Fi Easy and Secure Key Derivation",
 119                 keys, sizeof(keys));
 120         os_memcpy(wps->authkey, keys, WPS_AUTHKEY_LEN);
 121         os_memcpy(wps->keywrapkey, keys + WPS_AUTHKEY_LEN, WPS_KEYWRAPKEY_LEN);
 122         os_memcpy(wps->emsk, keys + WPS_AUTHKEY_LEN + WPS_KEYWRAPKEY_LEN,
 123                   WPS_EMSK_LEN);
 124
 125         wpa_hexdump_key(MSG_DEBUG, "WPS: AuthKey",
 126                         wps->authkey, WPS_AUTHKEY_LEN);
 127         wpa_hexdump_key(MSG_DEBUG, "WPS: KeyWrapKey",
 128                         wps->keywrapkey, WPS_KEYWRAPKEY_LEN);
 129         wpa_hexdump_key(MSG_DEBUG, "WPS: EMSK", wps->emsk, WPS_EMSK_LEN);
 130
 131         return 0;
 132 }
 133
 134
 135 void wps_derive_psk(struct wps_data *wps, const u8 *dev_passwd,
 136                     size_t dev_passwd_len)
 137 {
 138         u8 hash[SHA256_MAC_LEN];
 139
 140         hmac_sha256(wps->authkey, WPS_AUTHKEY_LEN, dev_passwd,
 141                     (dev_passwd_len + 1) / 2, hash);
 142         os_memcpy(wps->psk1, hash, WPS_PSK_LEN);
 143         hmac_sha256(wps->authkey, WPS_AUTHKEY_LEN,
 144                     dev_passwd + (dev_passwd_len + 1) / 2,
 145                     dev_passwd_len / 2, hash);
 146         os_memcpy(wps->psk2, hash, WPS_PSK_LEN);
 147
 148         wpa_hexdump_ascii_key(MSG_DEBUG, "WPS: Device Password",
 149                               dev_passwd, dev_passwd_len);
 150         wpa_hexdump_key(MSG_DEBUG, "WPS: PSK1", wps->psk1, WPS_PSK_LEN);
 151         wpa_hexdump_key(MSG_DEBUG, "WPS: PSK2", wps->psk2, WPS_PSK_LEN);
 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_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_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_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 unsigned int wps_generate_pin(void)
 242 {
 243         unsigned int val;
 244
 245         /* Generate seven random digits for the PIN */
 246         if (os_get_random((unsigned char *) &val, sizeof(val)) < 0) {
 247                 struct os_time now;
 248                 os_get_time(&now);
 249                 val = os_random() ^ now.sec ^ now.usec;
 250         }
 251         val %= 10000000;
 252
 253         /* Append checksum digit */
 254         return val * 10 + wps_pin_checksum(val);
 255 }
 256
 257
 258 void wps_fail_event(struct wps_context *wps, enum wps_msg_type msg,
 259                     u16 config_error)
 260 {
 261         union wps_event_data data;
 262
 263         if (wps->event_cb == NULL)
 264                 return;
 265
 266         os_memset(&data, 0, sizeof(data));
 267         data.fail.msg = msg;
 268         data.fail.config_error = config_error;
 269         wps->event_cb(wps->cb_ctx, WPS_EV_FAIL, &data);
 270 }
 271
 272
 273 void wps_success_event(struct wps_context *wps)
 274 {
 275         if (wps->event_cb == NULL)
 276                 return;
 277
 278         wps->event_cb(wps->cb_ctx, WPS_EV_SUCCESS, NULL);
 279 }
 280
 281
 282 void wps_pwd_auth_fail_event(struct wps_context *wps, int enrollee, int part)
 283 {
 284         union wps_event_data data;
 285
 286         if (wps->event_cb == NULL)
 287                 return;
 288
 289         os_memset(&data, 0, sizeof(data));
 290         data.pwd_auth_fail.enrollee = enrollee;
 291         data.pwd_auth_fail.part = part;
 292         wps->event_cb(wps->cb_ctx, WPS_EV_PWD_AUTH_FAIL, &data);
 293 }
 294
 295
 296 void wps_pbc_overlap_event(struct wps_context *wps)
 297 {
 298         if (wps->event_cb == NULL)
 299                 return;
 300
 301         wps->event_cb(wps->cb_ctx, WPS_EV_PBC_OVERLAP, NULL);
 302 }
 303
 304
 305 void wps_pbc_timeout_event(struct wps_context *wps)
 306 {
 307         if (wps->event_cb == NULL)
 308                 return;
 309
 310         wps->event_cb(wps->cb_ctx, WPS_EV_PBC_TIMEOUT, NULL);
 311 }
 312
 313
 314 #ifdef CONFIG_WPS_OOB
 315
 316 static struct wpabuf * wps_get_oob_cred(struct wps_context *wps)
 317 {
 318         struct wps_data data;
 319         struct wpabuf *plain;
 320
 321         plain = wpabuf_alloc(500);
 322         if (plain == NULL) {
 323                 wpa_printf(MSG_ERROR, "WPS: Failed to allocate memory for OOB "
 324                            "credential");
 325                 return NULL;
 326         }
 327
 328         os_memset(&data, 0, sizeof(data));
 329         data.wps = wps;
 330         data.auth_type = wps->auth_types;
 331         data.encr_type = wps->encr_types;
 332         if (wps_build_version(plain) ||
 333             wps_build_cred(&data, plain) ||
 334             wps_build_wfa_ext(plain, 0, NULL, 0)) {
 335                 wpabuf_free(plain);
 336                 return NULL;
 337         }
 338
 339         return plain;
 340 }
 341
 342
 343 static struct wpabuf * wps_get_oob_dev_pwd(struct wps_context *wps)
 344 {
 345         struct wpabuf *data;
 346
 347         data = wpabuf_alloc(9 + WPS_OOB_DEVICE_PASSWORD_ATTR_LEN);
 348         if (data == NULL) {
 349                 wpa_printf(MSG_ERROR, "WPS: Failed to allocate memory for OOB "
 350                            "device password attribute");
 351                 return NULL;
 352         }
 353
 354         wpabuf_free(wps->oob_conf.dev_password);
 355         wps->oob_conf.dev_password =
 356                 wpabuf_alloc(WPS_OOB_DEVICE_PASSWORD_LEN * 2 + 1);
 357         if (wps->oob_conf.dev_password == NULL) {
 358                 wpa_printf(MSG_ERROR, "WPS: Failed to allocate memory for OOB "
 359                            "device password");
 360                 wpabuf_free(data);
 361                 return NULL;
 362         }
 363
 364         if (wps_build_version(data) ||
 365             wps_build_oob_dev_password(data, wps) ||
 366             wps_build_wfa_ext(data, 0, NULL, 0)) {
 367                 wpa_printf(MSG_ERROR, "WPS: Build OOB device password "
 368                            "attribute error");
 369                 wpabuf_free(data);
 370                 return NULL;
 371         }
 372
 373         return data;
 374 }
 375
 376
 377 static int wps_parse_oob_dev_pwd(struct wps_context *wps,
 378                                  struct wpabuf *data)
 379 {
 380         struct oob_conf_data *oob_conf = &wps->oob_conf;
 381         struct wps_parse_attr attr;
 382         const u8 *pos;
 383
 384         if (wps_parse_msg(data, &attr) < 0 ||
 385             attr.oob_dev_password == NULL) {
 386                 wpa_printf(MSG_ERROR, "WPS: OOB device password not found");
 387                 return -1;
 388         }
 389
 390         pos = attr.oob_dev_password;
 391
 392         oob_conf->pubkey_hash =
 393                 wpabuf_alloc_copy(pos, WPS_OOB_PUBKEY_HASH_LEN);
 394         if (oob_conf->pubkey_hash == NULL) {
 395                 wpa_printf(MSG_ERROR, "WPS: Failed to allocate memory for OOB "
 396                            "public key hash");
 397                 return -1;
 398         }
 399         pos += WPS_OOB_PUBKEY_HASH_LEN;
 400
 401         wps->oob_dev_pw_id = WPA_GET_BE16(pos);
 402         pos += sizeof(wps->oob_dev_pw_id);
 403
 404         oob_conf->dev_password =
 405                 wpabuf_alloc(WPS_OOB_DEVICE_PASSWORD_LEN * 2 + 1);
 406         if (oob_conf->dev_password == NULL) {
 407                 wpa_printf(MSG_ERROR, "WPS: Failed to allocate memory for OOB "
 408                            "device password");
 409                 return -1;
 410         }
 411         wpa_snprintf_hex_uppercase(wpabuf_put(oob_conf->dev_password,
 412                                    wpabuf_size(oob_conf->dev_password)),
 413                                    wpabuf_size(oob_conf->dev_password), pos,
 414                                    WPS_OOB_DEVICE_PASSWORD_LEN);
 415
 416         return 0;
 417 }
 418
 419
 420 static int wps_parse_oob_cred(struct wps_context *wps, struct wpabuf *data)
 421 {
 422         struct wpabuf msg;
 423         struct wps_parse_attr attr;
 424         size_t i;
 425
 426         if (wps_parse_msg(data, &attr) < 0 || attr.num_cred <= 0) {
 427                 wpa_printf(MSG_ERROR, "WPS: OOB credential not found");
 428                 return -1;
 429         }
 430
 431         for (i = 0; i < attr.num_cred; i++) {
 432                 struct wps_credential local_cred;
 433                 struct wps_parse_attr cattr;
 434
 435                 os_memset(&local_cred, 0, sizeof(local_cred));
 436                 wpabuf_set(&msg, attr.cred[i], attr.cred_len[i]);
 437                 if (wps_parse_msg(&msg, &cattr) < 0 ||
 438                     wps_process_cred(&cattr, &local_cred)) {
 439                         wpa_printf(MSG_ERROR, "WPS: Failed to parse OOB "
 440                                    "credential");
 441                         return -1;
 442                 }
 443                 wps->cred_cb(wps->cb_ctx, &local_cred);
 444         }
 445
 446         return 0;
 447 }
 448
 449
 450 int wps_process_oob(struct wps_context *wps, struct oob_device_data *oob_dev,
 451                     int registrar)
 452 {
 453         struct wpabuf *data;
 454         int ret, write_f, oob_method = wps->oob_conf.oob_method;
 455         void *oob_priv;
 456
 457         write_f = oob_method == OOB_METHOD_DEV_PWD_E ? !registrar : registrar;
 458
 459         oob_priv = oob_dev->init_func(wps, oob_dev, registrar);
 460         if (oob_priv == NULL) {
 461                 wpa_printf(MSG_ERROR, "WPS: Failed to initialize OOB device");
 462                 return -1;
 463         }
 464
 465         if (write_f) {
 466                 if (oob_method == OOB_METHOD_CRED)
 467                         data = wps_get_oob_cred(wps);
 468                 else
 469                         data = wps_get_oob_dev_pwd(wps);
 470
 471                 ret = 0;
 472                 if (data == NULL || oob_dev->write_func(oob_priv, data) < 0)
 473                         ret = -1;
 474         } else {
 475                 data = oob_dev->read_func(oob_priv);
 476                 if (data == NULL)
 477                         ret = -1;
 478                 else {
 479                         if (oob_method == OOB_METHOD_CRED)
 480                                 ret = wps_parse_oob_cred(wps, data);
 481                         else
 482                                 ret = wps_parse_oob_dev_pwd(wps, data);
 483                 }
 484         }
 485         wpabuf_free(data);
 486         oob_dev->deinit_func(oob_priv);
 487
 488         if (ret < 0) {
 489                 wpa_printf(MSG_ERROR, "WPS: Failed to process OOB data");
 490                 return -1;
 491         }
 492
 493         return 0;
 494 }
 495
 496
 497 struct oob_device_data * wps_get_oob_device(char *device_type)
 498 {
 499 #ifdef CONFIG_WPS_UFD
 500         if (os_strstr(device_type, "ufd") != NULL)
 501                 return &oob_ufd_device_data;
 502 #endif /* CONFIG_WPS_UFD */
 503 #ifdef CONFIG_WPS_NFC
 504         if (os_strstr(device_type, "nfc") != NULL)
 505                 return &oob_nfc_device_data;
 506 #endif /* CONFIG_WPS_NFC */
 507
 508         return NULL;
 509 }
 510
 511
 512 #ifdef CONFIG_WPS_NFC
 513 struct oob_nfc_device_data * wps_get_oob_nfc_device(char *device_name)
 514 {
 515         if (device_name == NULL)
 516                 return NULL;
 517 #ifdef CONFIG_WPS_NFC_PN531
 518         if (os_strstr(device_name, "pn531") != NULL)
 519                 return &oob_nfc_pn531_device_data;
 520 #endif /* CONFIG_WPS_NFC_PN531 */
 521
 522         return NULL;
 523 }
 524 #endif /* CONFIG_WPS_NFC */
 525
 526
 527 int wps_get_oob_method(char *method)
 528 {
 529         if (os_strstr(method, "pin-e") != NULL)
 530                 return OOB_METHOD_DEV_PWD_E;
 531         if (os_strstr(method, "pin-r") != NULL)
 532                 return OOB_METHOD_DEV_PWD_R;
 533         if (os_strstr(method, "cred") != NULL)
 534                 return OOB_METHOD_CRED;
 535         return OOB_METHOD_UNKNOWN;
 536 }
 537
 538 #endif /* CONFIG_WPS_OOB */
 539
 540
 541 int wps_dev_type_str2bin(const char *str, u8 dev_type[WPS_DEV_TYPE_LEN])
 542 {
 543         const char *pos;
 544
 545         /* <categ>-<OUI>-<subcateg> */
 546         WPA_PUT_BE16(dev_type, atoi(str));
 547         pos = os_strchr(str, '-');
 548         if (pos == NULL)
 549                 return -1;
 550         pos++;
 551         if (hexstr2bin(pos, &dev_type[2], 4))
 552                 return -1;
 553         pos = os_strchr(pos, '-');
 554         if (pos == NULL)
 555                 return -1;
 556         pos++;
 557         WPA_PUT_BE16(&dev_type[6], atoi(pos));
 558
 559
 560         return 0;
 561 }
 562
 563
 564 char * wps_dev_type_bin2str(const u8 dev_type[WPS_DEV_TYPE_LEN], char *buf,
 565                             size_t buf_len)
 566 {
 567         int ret;
 568
 569         ret = os_snprintf(buf, buf_len, "%u-%08X-%u",
 570                           WPA_GET_BE16(dev_type), WPA_GET_BE32(&dev_type[2]),
 571                           WPA_GET_BE16(&dev_type[6]));
 572         if (ret < 0 || (unsigned int) ret >= buf_len)
 573                 return NULL;
 574
 575         return buf;
 576 }
 577
 578
 579 void uuid_gen_mac_addr(const u8 *mac_addr, u8 *uuid)
 580 {
 581         const u8 *addr[2];
 582         size_t len[2];
 583         u8 hash[SHA1_MAC_LEN];
 584         u8 nsid[16] = {
 585                 0x52, 0x64, 0x80, 0xf8,
 586                 0xc9, 0x9b,
 587                 0x4b, 0xe5,
 588                 0xa6, 0x55,
 589                 0x58, 0xed, 0x5f, 0x5d, 0x60, 0x84
 590         };
 591
 592         addr[0] = nsid;
 593         len[0] = sizeof(nsid);
 594         addr[1] = mac_addr;
 595         len[1] = 6;
 596         sha1_vector(2, addr, len, hash);
 597         os_memcpy(uuid, hash, 16);
 598
 599         /* Version: 5 = named-based version using SHA-1 */
 600         uuid[6] = (5 << 4) | (uuid[6] & 0x0f);
 601
 602         /* Variant specified in RFC 4122 */
 603         uuid[8] = 0x80 | (uuid[8] & 0x3f);
 604 }
 605
 606
 607 u16 wps_config_methods_str2bin(const char *str)
 608 {
 609         u16 methods = 0;
 610
 611         if (str == NULL) {
 612                 /* Default to enabling methods based on build configuration */
 613                 methods |= WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD;
 614 #ifdef CONFIG_WPS2
 615                 methods |= WPS_CONFIG_VIRT_DISPLAY;
 616 #endif /* CONFIG_WPS2 */
 617 #ifdef CONFIG_WPS_UFD
 618                 methods |= WPS_CONFIG_USBA;
 619 #endif /* CONFIG_WPS_UFD */
 620 #ifdef CONFIG_WPS_NFC
 621                 methods |= WPS_CONFIG_NFC_INTERFACE;
 622 #endif /* CONFIG_WPS_NFC */
 623         } else {
 624                 if (os_strstr(str, "usba"))
 625                         methods |= WPS_CONFIG_USBA;
 626                 if (os_strstr(str, "ethernet"))
 627                         methods |= WPS_CONFIG_ETHERNET;
 628                 if (os_strstr(str, "label"))
 629                         methods |= WPS_CONFIG_LABEL;
 630                 if (os_strstr(str, "display"))
 631                         methods |= WPS_CONFIG_DISPLAY;
 632                 if (os_strstr(str, "ext_nfc_token"))
 633                         methods |= WPS_CONFIG_EXT_NFC_TOKEN;
 634                 if (os_strstr(str, "int_nfc_token"))
 635                         methods |= WPS_CONFIG_INT_NFC_TOKEN;
 636                 if (os_strstr(str, "nfc_interface"))
 637                         methods |= WPS_CONFIG_NFC_INTERFACE;
 638                 if (os_strstr(str, "push_button"))
 639                         methods |= WPS_CONFIG_PUSHBUTTON;
 640                 if (os_strstr(str, "keypad"))
 641                         methods |= WPS_CONFIG_KEYPAD;
 642 #ifdef CONFIG_WPS2
 643                 if (os_strstr(str, "virtual_display"))
 644                         methods |= WPS_CONFIG_VIRT_DISPLAY;
 645                 if (os_strstr(str, "physical_display"))
 646                         methods |= WPS_CONFIG_PHY_DISPLAY;
 647                 if (os_strstr(str, "virtual_push_button"))
 648                         methods |= WPS_CONFIG_VIRT_PUSHBUTTON;
 649                 if (os_strstr(str, "physical_push_button"))
 650                         methods |= WPS_CONFIG_PHY_PUSHBUTTON;
 651 #endif /* CONFIG_WPS2 */
 652         }
 653
 654         return methods;
 655 }