workbench/network/WirelessManager/src/eap_peer/eap_gpsk.c

   1 /*
   2  * EAP peer method: EAP-GPSK (RFC 5433)
   3  * Copyright (c) 2006-2008, 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 "eap_peer/eap_i.h"
  19 #include "eap_common/eap_gpsk_common.h"
  20
  21 struct eap_gpsk_data {
  22         enum { GPSK_1, GPSK_3, SUCCESS, FAILURE } state;
  23         u8 rand_server[EAP_GPSK_RAND_LEN];
  24         u8 rand_peer[EAP_GPSK_RAND_LEN];
  25         u8 msk[EAP_MSK_LEN];
  26         u8 emsk[EAP_EMSK_LEN];
  27         u8 sk[EAP_GPSK_MAX_SK_LEN];
  28         size_t sk_len;
  29         u8 pk[EAP_GPSK_MAX_PK_LEN];
  30         size_t pk_len;
  31         u8 session_id;
  32         int session_id_set;
  33         u8 *id_peer;
  34         size_t id_peer_len;
  35         u8 *id_server;
  36         size_t id_server_len;
  37         int vendor; /* CSuite/Specifier */
  38         int specifier; /* CSuite/Specifier */
  39         u8 *psk;
  40         size_t psk_len;
  41 };
  42
  43
  44 static struct wpabuf * eap_gpsk_send_gpsk_2(struct eap_gpsk_data *data,
  45                                             u8 identifier,
  46                                             const u8 *csuite_list,
  47                                             size_t csuite_list_len);
  48 static struct wpabuf * eap_gpsk_send_gpsk_4(struct eap_gpsk_data *data,
  49                                             u8 identifier);
  50
  51
  52 #ifndef CONFIG_NO_STDOUT_DEBUG
  53 static const char * eap_gpsk_state_txt(int state)
  54 {
  55         switch (state) {
  56         case GPSK_1:
  57                 return "GPSK-1";
  58         case GPSK_3:
  59                 return "GPSK-3";
  60         case SUCCESS:
  61                 return "SUCCESS";
  62         case FAILURE:
  63                 return "FAILURE";
  64         default:
  65                 return "?";
  66         }
  67 }
  68 #endif /* CONFIG_NO_STDOUT_DEBUG */
  69
  70
  71 static void eap_gpsk_state(struct eap_gpsk_data *data, int state)
  72 {
  73         wpa_printf(MSG_DEBUG, "EAP-GPSK: %s -> %s",
  74                    eap_gpsk_state_txt(data->state),
  75                    eap_gpsk_state_txt(state));
  76         data->state = state;
  77 }
  78
  79
  80 static void eap_gpsk_deinit(struct eap_sm *sm, void *priv);
  81
  82
  83 static void * eap_gpsk_init(struct eap_sm *sm)
  84 {
  85         struct eap_gpsk_data *data;
  86         const u8 *identity, *password;
  87         size_t identity_len, password_len;
  88
  89         password = eap_get_config_password(sm, &password_len);
  90         if (password == NULL) {
  91                 wpa_printf(MSG_INFO, "EAP-GPSK: No key (password) configured");
  92                 return NULL;
  93         }
  94
  95         data = os_zalloc(sizeof(*data));
  96         if (data == NULL)
  97                 return NULL;
  98         data->state = GPSK_1;
  99
 100         identity = eap_get_config_identity(sm, &identity_len);
 101         if (identity) {
 102                 data->id_peer = os_malloc(identity_len);
 103                 if (data->id_peer == NULL) {
 104                         eap_gpsk_deinit(sm, data);
 105                         return NULL;
 106                 }
 107                 os_memcpy(data->id_peer, identity, identity_len);
 108                 data->id_peer_len = identity_len;
 109         }
 110
 111         data->psk = os_malloc(password_len);
 112         if (data->psk == NULL) {
 113                 eap_gpsk_deinit(sm, data);
 114                 return NULL;
 115         }
 116         os_memcpy(data->psk, password, password_len);
 117         data->psk_len = password_len;
 118
 119         return data;
 120 }
 121
 122
 123 static void eap_gpsk_deinit(struct eap_sm *sm, void *priv)
 124 {
 125         struct eap_gpsk_data *data = priv;
 126         os_free(data->id_server);
 127         os_free(data->id_peer);
 128         os_free(data->psk);
 129         os_free(data);
 130 }
 131
 132
 133 static const u8 * eap_gpsk_process_id_server(struct eap_gpsk_data *data,
 134                                              const u8 *pos, const u8 *end)
 135 {
 136         u16 alen;
 137
 138         if (end - pos < 2) {
 139                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short GPSK-1 packet");
 140                 return NULL;
 141         }
 142         alen = WPA_GET_BE16(pos);
 143         pos += 2;
 144         if (end - pos < alen) {
 145                 wpa_printf(MSG_DEBUG, "EAP-GPSK: ID_Server overflow");
 146                 return NULL;
 147         }
 148         os_free(data->id_server);
 149         data->id_server = os_malloc(alen);
 150         if (data->id_server == NULL) {
 151                 wpa_printf(MSG_DEBUG, "EAP-GPSK: No memory for ID_Server");
 152                 return NULL;
 153         }
 154         os_memcpy(data->id_server, pos, alen);
 155         data->id_server_len = alen;
 156         wpa_hexdump_ascii(MSG_DEBUG, "EAP-GPSK: ID_Server",
 157                           data->id_server, data->id_server_len);
 158         pos += alen;
 159
 160         return pos;
 161 }
 162
 163
 164 static const u8 * eap_gpsk_process_rand_server(struct eap_gpsk_data *data,
 165                                                const u8 *pos, const u8 *end)
 166 {
 167         if (pos == NULL)
 168                 return NULL;
 169
 170         if (end - pos < EAP_GPSK_RAND_LEN) {
 171                 wpa_printf(MSG_DEBUG, "EAP-GPSK: RAND_Server overflow");
 172                 return NULL;
 173         }
 174         os_memcpy(data->rand_server, pos, EAP_GPSK_RAND_LEN);
 175         wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Server",
 176                     data->rand_server, EAP_GPSK_RAND_LEN);
 177         pos += EAP_GPSK_RAND_LEN;
 178
 179         return pos;
 180 }
 181
 182
 183 static int eap_gpsk_select_csuite(struct eap_sm *sm,
 184                                   struct eap_gpsk_data *data,
 185                                   const u8 *csuite_list,
 186                                   size_t csuite_list_len)
 187 {
 188         struct eap_gpsk_csuite *csuite;
 189         int i, count;
 190
 191         count = csuite_list_len / sizeof(struct eap_gpsk_csuite);
 192         data->vendor = EAP_GPSK_VENDOR_IETF;
 193         data->specifier = EAP_GPSK_CIPHER_RESERVED;
 194         csuite = (struct eap_gpsk_csuite *) csuite_list;
 195         for (i = 0; i < count; i++) {
 196                 int vendor, specifier;
 197                 vendor = WPA_GET_BE32(csuite->vendor);
 198                 specifier = WPA_GET_BE16(csuite->specifier);
 199                 wpa_printf(MSG_DEBUG, "EAP-GPSK: CSuite[%d]: %d:%d",
 200                            i, vendor, specifier);
 201                 if (data->vendor == EAP_GPSK_VENDOR_IETF &&
 202                     data->specifier == EAP_GPSK_CIPHER_RESERVED &&
 203                     eap_gpsk_supported_ciphersuite(vendor, specifier)) {
 204                         data->vendor = vendor;
 205                         data->specifier = specifier;
 206                 }
 207                 csuite++;
 208         }
 209         if (data->vendor == EAP_GPSK_VENDOR_IETF &&
 210             data->specifier == EAP_GPSK_CIPHER_RESERVED) {
 211                 wpa_msg(sm->msg_ctx, MSG_INFO, "EAP-GPSK: No supported "
 212                         "ciphersuite found");
 213                 return -1;
 214         }
 215         wpa_printf(MSG_DEBUG, "EAP-GPSK: Selected ciphersuite %d:%d",
 216                    data->vendor, data->specifier);
 217
 218         return 0;
 219 }
 220
 221
 222 static const u8 * eap_gpsk_process_csuite_list(struct eap_sm *sm,
 223                                                struct eap_gpsk_data *data,
 224                                                const u8 **list,
 225                                                size_t *list_len,
 226                                                const u8 *pos, const u8 *end)
 227 {
 228         if (pos == NULL)
 229                 return NULL;
 230
 231         if (end - pos < 2) {
 232                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short GPSK-1 packet");
 233                 return NULL;
 234         }
 235         *list_len = WPA_GET_BE16(pos);
 236         pos += 2;
 237         if (end - pos < (int) *list_len) {
 238                 wpa_printf(MSG_DEBUG, "EAP-GPSK: CSuite_List overflow");
 239                 return NULL;
 240         }
 241         if (*list_len == 0 || (*list_len % sizeof(struct eap_gpsk_csuite))) {
 242                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Invalid CSuite_List len %lu",
 243                            (unsigned long) *list_len);
 244                 return NULL;
 245         }
 246         *list = pos;
 247         pos += *list_len;
 248
 249         if (eap_gpsk_select_csuite(sm, data, *list, *list_len) < 0)
 250                 return NULL;
 251
 252         return pos;
 253 }
 254
 255
 256 static struct wpabuf * eap_gpsk_process_gpsk_1(struct eap_sm *sm,
 257                                                struct eap_gpsk_data *data,
 258                                                struct eap_method_ret *ret,
 259                                                const struct wpabuf *reqData,
 260                                                const u8 *payload,
 261                                                size_t payload_len)
 262 {
 263         size_t csuite_list_len;
 264         const u8 *csuite_list, *pos, *end;
 265         struct wpabuf *resp;
 266
 267         if (data->state != GPSK_1) {
 268                 ret->ignore = TRUE;
 269                 return NULL;
 270         }
 271
 272         wpa_printf(MSG_DEBUG, "EAP-GPSK: Received Request/GPSK-1");
 273
 274         end = payload + payload_len;
 275
 276         pos = eap_gpsk_process_id_server(data, payload, end);
 277         pos = eap_gpsk_process_rand_server(data, pos, end);
 278         pos = eap_gpsk_process_csuite_list(sm, data, &csuite_list,
 279                                            &csuite_list_len, pos, end);
 280         if (pos == NULL) {
 281                 eap_gpsk_state(data, FAILURE);
 282                 return NULL;
 283         }
 284
 285         resp = eap_gpsk_send_gpsk_2(data, eap_get_id(reqData),
 286                                     csuite_list, csuite_list_len);
 287         if (resp == NULL)
 288                 return NULL;
 289
 290         eap_gpsk_state(data, GPSK_3);
 291
 292         return resp;
 293 }
 294
 295
 296 static struct wpabuf * eap_gpsk_send_gpsk_2(struct eap_gpsk_data *data,
 297                                             u8 identifier,
 298                                             const u8 *csuite_list,
 299                                             size_t csuite_list_len)
 300 {
 301         struct wpabuf *resp;
 302         size_t len, miclen;
 303         u8 *rpos, *start;
 304         struct eap_gpsk_csuite *csuite;
 305
 306         wpa_printf(MSG_DEBUG, "EAP-GPSK: Sending Response/GPSK-2");
 307
 308         miclen = eap_gpsk_mic_len(data->vendor, data->specifier);
 309         len = 1 + 2 + data->id_peer_len + 2 + data->id_server_len +
 310                 2 * EAP_GPSK_RAND_LEN + 2 + csuite_list_len +
 311                 sizeof(struct eap_gpsk_csuite) + 2 + miclen;
 312
 313         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_GPSK, len,
 314                              EAP_CODE_RESPONSE, identifier);
 315         if (resp == NULL)
 316                 return NULL;
 317
 318         wpabuf_put_u8(resp, EAP_GPSK_OPCODE_GPSK_2);
 319         start = wpabuf_put(resp, 0);
 320
 321         wpa_hexdump_ascii(MSG_DEBUG, "EAP-GPSK: ID_Peer",
 322                           data->id_peer, data->id_peer_len);
 323         wpabuf_put_be16(resp, data->id_peer_len);
 324         wpabuf_put_data(resp, data->id_peer, data->id_peer_len);
 325
 326         wpabuf_put_be16(resp, data->id_server_len);
 327         wpabuf_put_data(resp, data->id_server, data->id_server_len);
 328
 329         if (os_get_random(data->rand_peer, EAP_GPSK_RAND_LEN)) {
 330                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to get random data "
 331                            "for RAND_Peer");
 332                 eap_gpsk_state(data, FAILURE);
 333                 wpabuf_free(resp);
 334                 return NULL;
 335         }
 336         wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Peer",
 337                     data->rand_peer, EAP_GPSK_RAND_LEN);
 338         wpabuf_put_data(resp, data->rand_peer, EAP_GPSK_RAND_LEN);
 339         wpabuf_put_data(resp, data->rand_server, EAP_GPSK_RAND_LEN);
 340
 341         wpabuf_put_be16(resp, csuite_list_len);
 342         wpabuf_put_data(resp, csuite_list, csuite_list_len);
 343
 344         csuite = wpabuf_put(resp, sizeof(*csuite));
 345         WPA_PUT_BE32(csuite->vendor, data->vendor);
 346         WPA_PUT_BE16(csuite->specifier, data->specifier);
 347
 348         if (eap_gpsk_derive_keys(data->psk, data->psk_len,
 349                                  data->vendor, data->specifier,
 350                                  data->rand_peer, data->rand_server,
 351                                  data->id_peer, data->id_peer_len,
 352                                  data->id_server, data->id_server_len,
 353                                  data->msk, data->emsk,
 354                                  data->sk, &data->sk_len,
 355                                  data->pk, &data->pk_len) < 0) {
 356                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to derive keys");
 357                 eap_gpsk_state(data, FAILURE);
 358                 wpabuf_free(resp);
 359                 return NULL;
 360         }
 361
 362         /* No PD_Payload_1 */
 363         wpabuf_put_be16(resp, 0);
 364
 365         rpos = wpabuf_put(resp, miclen);
 366         if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
 367                                  data->specifier, start, rpos - start, rpos) <
 368             0) {
 369                 eap_gpsk_state(data, FAILURE);
 370                 wpabuf_free(resp);
 371                 return NULL;
 372         }
 373
 374         return resp;
 375 }
 376
 377
 378 static const u8 * eap_gpsk_validate_rand(struct eap_gpsk_data *data,
 379                                          const u8 *pos, const u8 *end)
 380 {
 381         if (end - pos < EAP_GPSK_RAND_LEN) {
 382                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 383                            "RAND_Peer");
 384                 return NULL;
 385         }
 386         if (os_memcmp(pos, data->rand_peer, EAP_GPSK_RAND_LEN) != 0) {
 387                 wpa_printf(MSG_DEBUG, "EAP-GPSK: RAND_Peer in GPSK-2 and "
 388                            "GPSK-3 did not match");
 389                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Peer in GPSK-2",
 390                             data->rand_peer, EAP_GPSK_RAND_LEN);
 391                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Peer in GPSK-3",
 392                             pos, EAP_GPSK_RAND_LEN);
 393                 return NULL;
 394         }
 395         pos += EAP_GPSK_RAND_LEN;
 396
 397         if (end - pos < EAP_GPSK_RAND_LEN) {
 398                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 399                            "RAND_Server");
 400                 return NULL;
 401         }
 402         if (os_memcmp(pos, data->rand_server, EAP_GPSK_RAND_LEN) != 0) {
 403                 wpa_printf(MSG_DEBUG, "EAP-GPSK: RAND_Server in GPSK-1 and "
 404                            "GPSK-3 did not match");
 405                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Server in GPSK-1",
 406                             data->rand_server, EAP_GPSK_RAND_LEN);
 407                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Server in GPSK-3",
 408                             pos, EAP_GPSK_RAND_LEN);
 409                 return NULL;
 410         }
 411         pos += EAP_GPSK_RAND_LEN;
 412
 413         return pos;
 414 }
 415
 416
 417 static const u8 * eap_gpsk_validate_id_server(struct eap_gpsk_data *data,
 418                                               const u8 *pos, const u8 *end)
 419 {
 420         size_t len;
 421
 422         if (pos == NULL)
 423                 return NULL;
 424
 425         if (end - pos < (int) 2) {
 426                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 427                            "length(ID_Server)");
 428                 return NULL;
 429         }
 430
 431         len = WPA_GET_BE16(pos);
 432         pos += 2;
 433
 434         if (end - pos < (int) len) {
 435                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 436                            "ID_Server");
 437                 return NULL;
 438         }
 439
 440         if (len != data->id_server_len ||
 441             os_memcmp(pos, data->id_server, len) != 0) {
 442                 wpa_printf(MSG_INFO, "EAP-GPSK: ID_Server did not match with "
 443                            "the one used in GPSK-1");
 444                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-GPSK: ID_Server in GPSK-1",
 445                                   data->id_server, data->id_server_len);
 446                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-GPSK: ID_Server in GPSK-3",
 447                                   pos, len);
 448                 return NULL;
 449         }
 450
 451         pos += len;
 452
 453         return pos;
 454 }
 455
 456
 457 static const u8 * eap_gpsk_validate_csuite(struct eap_gpsk_data *data,
 458                                            const u8 *pos, const u8 *end)
 459 {
 460         int vendor, specifier;
 461         const struct eap_gpsk_csuite *csuite;
 462
 463         if (pos == NULL)
 464                 return NULL;
 465
 466         if (end - pos < (int) sizeof(*csuite)) {
 467                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 468                            "CSuite_Sel");
 469                 return NULL;
 470         }
 471         csuite = (const struct eap_gpsk_csuite *) pos;
 472         vendor = WPA_GET_BE32(csuite->vendor);
 473         specifier = WPA_GET_BE16(csuite->specifier);
 474         pos += sizeof(*csuite);
 475         if (vendor != data->vendor || specifier != data->specifier) {
 476                 wpa_printf(MSG_DEBUG, "EAP-GPSK: CSuite_Sel (%d:%d) does not "
 477                            "match with the one sent in GPSK-2 (%d:%d)",
 478                            vendor, specifier, data->vendor, data->specifier);
 479                 return NULL;
 480         }
 481
 482         return pos;
 483 }
 484
 485
 486 static const u8 * eap_gpsk_validate_pd_payload_2(struct eap_gpsk_data *data,
 487                                                  const u8 *pos, const u8 *end)
 488 {
 489         u16 alen;
 490
 491         if (pos == NULL)
 492                 return NULL;
 493
 494         if (end - pos < 2) {
 495                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 496                            "PD_Payload_2 length");
 497                 return NULL;
 498         }
 499         alen = WPA_GET_BE16(pos);
 500         pos += 2;
 501         if (end - pos < alen) {
 502                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 503                            "%d-octet PD_Payload_2", alen);
 504                 return NULL;
 505         }
 506         wpa_hexdump(MSG_DEBUG, "EAP-GPSK: PD_Payload_2", pos, alen);
 507         pos += alen;
 508
 509         return pos;
 510 }
 511
 512
 513 static const u8 * eap_gpsk_validate_gpsk_3_mic(struct eap_gpsk_data *data,
 514                                                const u8 *payload,
 515                                                const u8 *pos, const u8 *end)
 516 {
 517         size_t miclen;
 518         u8 mic[EAP_GPSK_MAX_MIC_LEN];
 519
 520         if (pos == NULL)
 521                 return NULL;
 522
 523         miclen = eap_gpsk_mic_len(data->vendor, data->specifier);
 524         if (end - pos < (int) miclen) {
 525                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for MIC "
 526                            "(left=%lu miclen=%lu)",
 527                            (unsigned long) (end - pos),
 528                            (unsigned long) miclen);
 529                 return NULL;
 530         }
 531         if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
 532                                  data->specifier, payload, pos - payload, mic)
 533             < 0) {
 534                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to compute MIC");
 535                 return NULL;
 536         }
 537         if (os_memcmp(mic, pos, miclen) != 0) {
 538                 wpa_printf(MSG_INFO, "EAP-GPSK: Incorrect MIC in GPSK-3");
 539                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Received MIC", pos, miclen);
 540                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Computed MIC", mic, miclen);
 541                 return NULL;
 542         }
 543         pos += miclen;
 544
 545         return pos;
 546 }
 547
 548
 549 static struct wpabuf * eap_gpsk_process_gpsk_3(struct eap_sm *sm,
 550                                                struct eap_gpsk_data *data,
 551                                                struct eap_method_ret *ret,
 552                                                const struct wpabuf *reqData,
 553                                                const u8 *payload,
 554                                                size_t payload_len)
 555 {
 556         struct wpabuf *resp;
 557         const u8 *pos, *end;
 558
 559         if (data->state != GPSK_3) {
 560                 ret->ignore = TRUE;
 561                 return NULL;
 562         }
 563
 564         wpa_printf(MSG_DEBUG, "EAP-GPSK: Received Request/GPSK-3");
 565
 566         end = payload + payload_len;
 567
 568         pos = eap_gpsk_validate_rand(data, payload, end);
 569         pos = eap_gpsk_validate_id_server(data, pos, end);
 570         pos = eap_gpsk_validate_csuite(data, pos, end);
 571         pos = eap_gpsk_validate_pd_payload_2(data, pos, end);
 572         pos = eap_gpsk_validate_gpsk_3_mic(data, payload, pos, end);
 573
 574         if (pos == NULL) {
 575                 eap_gpsk_state(data, FAILURE);
 576                 return NULL;
 577         }
 578         if (pos != end) {
 579                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Ignored %lu bytes of extra "
 580                            "data in the end of GPSK-2",
 581                            (unsigned long) (end - pos));
 582         }
 583
 584         resp = eap_gpsk_send_gpsk_4(data, eap_get_id(reqData));
 585         if (resp == NULL)
 586                 return NULL;
 587
 588         eap_gpsk_state(data, SUCCESS);
 589         ret->methodState = METHOD_DONE;
 590         ret->decision = DECISION_UNCOND_SUCC;
 591
 592         return resp;
 593 }
 594
 595
 596 static struct wpabuf * eap_gpsk_send_gpsk_4(struct eap_gpsk_data *data,
 597                                             u8 identifier)
 598 {
 599         struct wpabuf *resp;
 600         u8 *rpos, *start;
 601         size_t mlen;
 602
 603         wpa_printf(MSG_DEBUG, "EAP-GPSK: Sending Response/GPSK-4");
 604
 605         mlen = eap_gpsk_mic_len(data->vendor, data->specifier);
 606
 607         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_GPSK, 1 + 2 + mlen,
 608                              EAP_CODE_RESPONSE, identifier);
 609         if (resp == NULL)
 610                 return NULL;
 611
 612         wpabuf_put_u8(resp, EAP_GPSK_OPCODE_GPSK_4);
 613         start = wpabuf_put(resp, 0);
 614
 615         /* No PD_Payload_3 */
 616         wpabuf_put_be16(resp, 0);
 617
 618         rpos = wpabuf_put(resp, mlen);
 619         if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
 620                                  data->specifier, start, rpos - start, rpos) <
 621             0) {
 622                 eap_gpsk_state(data, FAILURE);
 623                 wpabuf_free(resp);
 624                 return NULL;
 625         }
 626
 627         return resp;
 628 }
 629
 630
 631 static struct wpabuf * eap_gpsk_process(struct eap_sm *sm, void *priv,
 632                                         struct eap_method_ret *ret,
 633                                         const struct wpabuf *reqData)
 634 {
 635         struct eap_gpsk_data *data = priv;
 636         struct wpabuf *resp;
 637         const u8 *pos;
 638         size_t len;
 639
 640         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_GPSK, reqData, &len);
 641         if (pos == NULL || len < 1) {
 642                 ret->ignore = TRUE;
 643                 return NULL;
 644         }
 645
 646         wpa_printf(MSG_DEBUG, "EAP-GPSK: Received frame: opcode %d", *pos);
 647
 648         ret->ignore = FALSE;
 649         ret->methodState = METHOD_MAY_CONT;
 650         ret->decision = DECISION_FAIL;
 651         ret->allowNotifications = FALSE;
 652
 653         switch (*pos) {
 654         case EAP_GPSK_OPCODE_GPSK_1:
 655                 resp = eap_gpsk_process_gpsk_1(sm, data, ret, reqData,
 656                                                pos + 1, len - 1);
 657                 break;
 658         case EAP_GPSK_OPCODE_GPSK_3:
 659                 resp = eap_gpsk_process_gpsk_3(sm, data, ret, reqData,
 660                                                pos + 1, len - 1);
 661                 break;
 662         default:
 663                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Ignoring message with "
 664                            "unknown opcode %d", *pos);
 665                 ret->ignore = TRUE;
 666                 return NULL;
 667         }
 668
 669         return resp;
 670 }
 671
 672
 673 static Boolean eap_gpsk_isKeyAvailable(struct eap_sm *sm, void *priv)
 674 {
 675         struct eap_gpsk_data *data = priv;
 676         return data->state == SUCCESS;
 677 }
 678
 679
 680 static u8 * eap_gpsk_getKey(struct eap_sm *sm, void *priv, size_t *len)
 681 {
 682         struct eap_gpsk_data *data = priv;
 683         u8 *key;
 684
 685         if (data->state != SUCCESS)
 686                 return NULL;
 687
 688         key = os_malloc(EAP_MSK_LEN);
 689         if (key == NULL)
 690                 return NULL;
 691         os_memcpy(key, data->msk, EAP_MSK_LEN);
 692         *len = EAP_MSK_LEN;
 693
 694         return key;
 695 }
 696
 697
 698 static u8 * eap_gpsk_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
 699 {
 700         struct eap_gpsk_data *data = priv;
 701         u8 *key;
 702
 703         if (data->state != SUCCESS)
 704                 return NULL;
 705
 706         key = os_malloc(EAP_EMSK_LEN);
 707         if (key == NULL)
 708                 return NULL;
 709         os_memcpy(key, data->emsk, EAP_EMSK_LEN);
 710         *len = EAP_EMSK_LEN;
 711
 712         return key;
 713 }
 714
 715
 716 int eap_peer_gpsk_register(void)
 717 {
 718         struct eap_method *eap;
 719         int ret;
 720
 721         eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
 722                                     EAP_VENDOR_IETF, EAP_TYPE_GPSK, "GPSK");
 723         if (eap == NULL)
 724                 return -1;
 725
 726         eap->init = eap_gpsk_init;
 727         eap->deinit = eap_gpsk_deinit;
 728         eap->process = eap_gpsk_process;
 729         eap->isKeyAvailable = eap_gpsk_isKeyAvailable;
 730         eap->getKey = eap_gpsk_getKey;
 731         eap->get_emsk = eap_gpsk_get_emsk;
 732
 733         ret = eap_peer_method_register(eap);
 734         if (ret)
 735                 eap_peer_method_free(eap);
 736         return ret;
 737 }