dist/wpa/src/eap_peer/eap_gpsk.c

   1 /*
   2  * EAP peer method: EAP-GPSK (draft-ietf-emu-eap-gpsk-08.txt)
   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 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 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 const u8 * eap_gpsk_process_csuite_list(struct eap_sm *sm,
 223                                         struct eap_gpsk_data *data,
 224                                         const u8 **list, size_t *list_len,
 225                                         const u8 *pos, const u8 *end)
 226 {
 227         if (pos == NULL)
 228                 return NULL;
 229
 230         if (end - pos < 2) {
 231                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short GPSK-1 packet");
 232                 return NULL;
 233         }
 234         *list_len = WPA_GET_BE16(pos);
 235         pos += 2;
 236         if (end - pos < (int) *list_len) {
 237                 wpa_printf(MSG_DEBUG, "EAP-GPSK: CSuite_List overflow");
 238                 return NULL;
 239         }
 240         if (*list_len == 0 || (*list_len % sizeof(struct eap_gpsk_csuite))) {
 241                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Invalid CSuite_List len %d",
 242                            *list_len);
 243                 return NULL;
 244         }
 245         *list = pos;
 246         pos += *list_len;
 247
 248         if (eap_gpsk_select_csuite(sm, data, *list, *list_len) < 0)
 249                 return NULL;
 250
 251         return pos;
 252 }
 253
 254
 255 static struct wpabuf * eap_gpsk_process_gpsk_1(struct eap_sm *sm,
 256                                                struct eap_gpsk_data *data,
 257                                                struct eap_method_ret *ret,
 258                                                const struct wpabuf *reqData,
 259                                                const u8 *payload,
 260                                                size_t payload_len)
 261 {
 262         size_t csuite_list_len;
 263         const u8 *csuite_list, *pos, *end;
 264         struct wpabuf *resp;
 265
 266         if (data->state != GPSK_1) {
 267                 ret->ignore = TRUE;
 268                 return NULL;
 269         }
 270
 271         wpa_printf(MSG_DEBUG, "EAP-GPSK: Received Request/GPSK-1");
 272
 273         end = payload + payload_len;
 274
 275         pos = eap_gpsk_process_id_server(data, payload, end);
 276         pos = eap_gpsk_process_rand_server(data, pos, end);
 277         pos = eap_gpsk_process_csuite_list(sm, data, &csuite_list,
 278                                            &csuite_list_len, pos, end);
 279         if (pos == NULL) {
 280                 eap_gpsk_state(data, FAILURE);
 281                 return NULL;
 282         }
 283
 284         resp = eap_gpsk_send_gpsk_2(data, eap_get_id(reqData),
 285                                     csuite_list, csuite_list_len);
 286         if (resp == NULL)
 287                 return NULL;
 288
 289         eap_gpsk_state(data, GPSK_3);
 290
 291         return resp;
 292 }
 293
 294
 295 static struct wpabuf * eap_gpsk_send_gpsk_2(struct eap_gpsk_data *data,
 296                                             u8 identifier,
 297                                             const u8 *csuite_list,
 298                                             size_t csuite_list_len)
 299 {
 300         struct wpabuf *resp;
 301         size_t len, miclen;
 302         u8 *rpos, *start;
 303         struct eap_gpsk_csuite *csuite;
 304
 305         wpa_printf(MSG_DEBUG, "EAP-GPSK: Sending Response/GPSK-2");
 306
 307         miclen = eap_gpsk_mic_len(data->vendor, data->specifier);
 308         len = 1 + 2 + data->id_peer_len + 2 + data->id_server_len +
 309                 2 * EAP_GPSK_RAND_LEN + 2 + csuite_list_len +
 310                 sizeof(struct eap_gpsk_csuite) + 2 + miclen;
 311
 312         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_GPSK, len,
 313                              EAP_CODE_RESPONSE, identifier);
 314         if (resp == NULL)
 315                 return NULL;
 316
 317         wpabuf_put_u8(resp, EAP_GPSK_OPCODE_GPSK_2);
 318         start = wpabuf_put(resp, 0);
 319
 320         wpa_hexdump_ascii(MSG_DEBUG, "EAP-GPSK: ID_Peer",
 321                           data->id_peer, data->id_peer_len);
 322         wpabuf_put_be16(resp, data->id_peer_len);
 323         wpabuf_put_data(resp, data->id_peer, data->id_peer_len);
 324
 325         wpabuf_put_be16(resp, data->id_server_len);
 326         wpabuf_put_data(resp, data->id_server, data->id_server_len);
 327
 328         if (os_get_random(data->rand_peer, EAP_GPSK_RAND_LEN)) {
 329                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to get random data "
 330                            "for RAND_Peer");
 331                 eap_gpsk_state(data, FAILURE);
 332                 wpabuf_free(resp);
 333                 return NULL;
 334         }
 335         wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Peer",
 336                     data->rand_peer, EAP_GPSK_RAND_LEN);
 337         wpabuf_put_data(resp, data->rand_peer, EAP_GPSK_RAND_LEN);
 338         wpabuf_put_data(resp, data->rand_server, EAP_GPSK_RAND_LEN);
 339
 340         wpabuf_put_be16(resp, csuite_list_len);
 341         wpabuf_put_data(resp, csuite_list, csuite_list_len);
 342
 343         csuite = wpabuf_put(resp, sizeof(*csuite));
 344         WPA_PUT_BE32(csuite->vendor, data->vendor);
 345         WPA_PUT_BE16(csuite->specifier, data->specifier);
 346
 347         if (eap_gpsk_derive_keys(data->psk, data->psk_len,
 348                                  data->vendor, data->specifier,
 349                                  data->rand_peer, data->rand_server,
 350                                  data->id_peer, data->id_peer_len,
 351                                  data->id_server, data->id_server_len,
 352                                  data->msk, data->emsk,
 353                                  data->sk, &data->sk_len,
 354                                  data->pk, &data->pk_len) < 0) {
 355                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to derive keys");
 356                 eap_gpsk_state(data, FAILURE);
 357                 wpabuf_free(resp);
 358                 return NULL;
 359         }
 360
 361         /* No PD_Payload_1 */
 362         wpabuf_put_be16(resp, 0);
 363
 364         rpos = wpabuf_put(resp, miclen);
 365         if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
 366                                  data->specifier, start, rpos - start, rpos) <
 367             0) {
 368                 eap_gpsk_state(data, FAILURE);
 369                 wpabuf_free(resp);
 370                 return NULL;
 371         }
 372
 373         return resp;
 374 }
 375
 376
 377 const u8 * eap_gpsk_validate_rand(struct eap_gpsk_data *data, const u8 *pos,
 378                                   const u8 *end)
 379 {
 380         if (end - pos < EAP_GPSK_RAND_LEN) {
 381                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 382                            "RAND_Peer");
 383                 return NULL;
 384         }
 385         if (os_memcmp(pos, data->rand_peer, EAP_GPSK_RAND_LEN) != 0) {
 386                 wpa_printf(MSG_DEBUG, "EAP-GPSK: RAND_Peer in GPSK-2 and "
 387                            "GPSK-3 did not match");
 388                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Peer in GPSK-2",
 389                             data->rand_peer, EAP_GPSK_RAND_LEN);
 390                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Peer in GPSK-3",
 391                             pos, EAP_GPSK_RAND_LEN);
 392                 return NULL;
 393         }
 394         pos += EAP_GPSK_RAND_LEN;
 395
 396         if (end - pos < EAP_GPSK_RAND_LEN) {
 397                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 398                            "RAND_Server");
 399                 return NULL;
 400         }
 401         if (os_memcmp(pos, data->rand_server, EAP_GPSK_RAND_LEN) != 0) {
 402                 wpa_printf(MSG_DEBUG, "EAP-GPSK: RAND_Server in GPSK-1 and "
 403                            "GPSK-3 did not match");
 404                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Server in GPSK-1",
 405                             data->rand_server, EAP_GPSK_RAND_LEN);
 406                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Server in GPSK-3",
 407                             pos, EAP_GPSK_RAND_LEN);
 408                 return NULL;
 409         }
 410         pos += EAP_GPSK_RAND_LEN;
 411
 412         return pos;
 413 }
 414
 415
 416 const u8 * eap_gpsk_validate_id_server(struct eap_gpsk_data *data,
 417                                        const u8 *pos, const u8 *end)
 418 {
 419         size_t len;
 420
 421         if (pos == NULL)
 422                 return NULL;
 423
 424         if (end - pos < (int) 2) {
 425                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 426                            "length(ID_Server)");
 427                 return NULL;
 428         }
 429
 430         len = WPA_GET_BE16(pos);
 431         pos += 2;
 432
 433         if (end - pos < (int) len) {
 434                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 435                            "ID_Server");
 436                 return NULL;
 437         }
 438
 439         if (len != data->id_server_len ||
 440             os_memcmp(pos, data->id_server, len) != 0) {
 441                 wpa_printf(MSG_INFO, "EAP-GPSK: ID_Server did not match with "
 442                            "the one used in GPSK-1");
 443                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-GPSK: ID_Server in GPSK-1",
 444                                   data->id_server, data->id_server_len);
 445                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-GPSK: ID_Server in GPSK-3",
 446                                   pos, len);
 447         }
 448
 449         pos += len;
 450
 451         return pos;
 452 }
 453
 454
 455 const u8 * eap_gpsk_validate_csuite(struct eap_gpsk_data *data, const u8 *pos,
 456                                     const u8 *end)
 457 {
 458         int vendor, specifier;
 459         const struct eap_gpsk_csuite *csuite;
 460
 461         if (pos == NULL)
 462                 return NULL;
 463
 464         if (end - pos < (int) sizeof(*csuite)) {
 465                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 466                            "CSuite_Sel");
 467                 return NULL;
 468         }
 469         csuite = (const struct eap_gpsk_csuite *) pos;
 470         vendor = WPA_GET_BE32(csuite->vendor);
 471         specifier = WPA_GET_BE16(csuite->specifier);
 472         pos += sizeof(*csuite);
 473         if (vendor != data->vendor || specifier != data->specifier) {
 474                 wpa_printf(MSG_DEBUG, "EAP-GPSK: CSuite_Sel (%d:%d) does not "
 475                            "match with the one sent in GPSK-2 (%d:%d)",
 476                            vendor, specifier, data->vendor, data->specifier);
 477                 return NULL;
 478         }
 479
 480         return pos;
 481 }
 482
 483
 484 const u8 * eap_gpsk_validate_pd_payload_2(struct eap_gpsk_data *data,
 485                                           const u8 *pos, const u8 *end)
 486 {
 487         u16 alen;
 488
 489         if (pos == NULL)
 490                 return NULL;
 491
 492         if (end - pos < 2) {
 493                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 494                            "PD_Payload_2 length");
 495                 return NULL;
 496         }
 497         alen = WPA_GET_BE16(pos);
 498         pos += 2;
 499         if (end - pos < alen) {
 500                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 501                            "%d-octet PD_Payload_2", alen);
 502                 return NULL;
 503         }
 504         wpa_hexdump(MSG_DEBUG, "EAP-GPSK: PD_Payload_2", pos, alen);
 505         pos += alen;
 506
 507         return pos;
 508 }
 509
 510
 511 const u8 * eap_gpsk_validate_gpsk_3_mic(struct eap_gpsk_data *data,
 512                                         const u8 *payload,
 513                                         const u8 *pos, const u8 *end)
 514 {
 515         size_t miclen;
 516         u8 mic[EAP_GPSK_MAX_MIC_LEN];
 517
 518         if (pos == NULL)
 519                 return NULL;
 520
 521         miclen = eap_gpsk_mic_len(data->vendor, data->specifier);
 522         if (end - pos < (int) miclen) {
 523                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for MIC "
 524                            "(left=%d miclen=%d)", end - pos, miclen);
 525                 return NULL;
 526         }
 527         if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
 528                                  data->specifier, payload, pos - payload, mic)
 529             < 0) {
 530                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to compute MIC");
 531                 return NULL;
 532         }
 533         if (os_memcmp(mic, pos, miclen) != 0) {
 534                 wpa_printf(MSG_INFO, "EAP-GPSK: Incorrect MIC in GPSK-3");
 535                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Received MIC", pos, miclen);
 536                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Computed MIC", mic, miclen);
 537                 return NULL;
 538         }
 539         pos += miclen;
 540
 541         return pos;
 542 }
 543
 544
 545 static struct wpabuf * eap_gpsk_process_gpsk_3(struct eap_sm *sm,
 546                                                struct eap_gpsk_data *data,
 547                                                struct eap_method_ret *ret,
 548                                                const struct wpabuf *reqData,
 549                                                const u8 *payload,
 550                                                size_t payload_len)
 551 {
 552         struct wpabuf *resp;
 553         const u8 *pos, *end;
 554
 555         if (data->state != GPSK_3) {
 556                 ret->ignore = TRUE;
 557                 return NULL;
 558         }
 559
 560         wpa_printf(MSG_DEBUG, "EAP-GPSK: Received Request/GPSK-3");
 561
 562         end = payload + payload_len;
 563
 564         pos = eap_gpsk_validate_rand(data, payload, end);
 565         pos = eap_gpsk_validate_id_server(data, pos, end);
 566         pos = eap_gpsk_validate_csuite(data, pos, end);
 567         pos = eap_gpsk_validate_pd_payload_2(data, pos, end);
 568         pos = eap_gpsk_validate_gpsk_3_mic(data, payload, pos, end);
 569
 570         if (pos == NULL) {
 571                 eap_gpsk_state(data, FAILURE);
 572                 return NULL;
 573         }
 574         if (pos != end) {
 575                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Ignored %d bytes of extra "
 576                            "data in the end of GPSK-2", end - pos);
 577         }
 578
 579         resp = eap_gpsk_send_gpsk_4(data, eap_get_id(reqData));
 580         if (resp == NULL)
 581                 return NULL;
 582
 583         eap_gpsk_state(data, SUCCESS);
 584         ret->methodState = METHOD_DONE;
 585         ret->decision = DECISION_UNCOND_SUCC;
 586
 587         return resp;
 588 }
 589
 590
 591 static struct wpabuf * eap_gpsk_send_gpsk_4(struct eap_gpsk_data *data,
 592                                             u8 identifier)
 593 {
 594         struct wpabuf *resp;
 595         u8 *rpos, *start;
 596         size_t mlen;
 597
 598         wpa_printf(MSG_DEBUG, "EAP-GPSK: Sending Response/GPSK-4");
 599
 600         mlen = eap_gpsk_mic_len(data->vendor, data->specifier);
 601
 602         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_GPSK, 1 + 2 + mlen,
 603                              EAP_CODE_RESPONSE, identifier);
 604         if (resp == NULL)
 605                 return NULL;
 606
 607         wpabuf_put_u8(resp, EAP_GPSK_OPCODE_GPSK_4);
 608         start = wpabuf_put(resp, 0);
 609
 610         /* No PD_Payload_3 */
 611         wpabuf_put_be16(resp, 0);
 612
 613         rpos = wpabuf_put(resp, mlen);
 614         if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
 615                                  data->specifier, start, rpos - start, rpos) <
 616             0) {
 617                 eap_gpsk_state(data, FAILURE);
 618                 wpabuf_free(resp);
 619                 return NULL;
 620         }
 621
 622         return resp;
 623 }
 624
 625
 626 static struct wpabuf * eap_gpsk_process(struct eap_sm *sm, void *priv,
 627                                         struct eap_method_ret *ret,
 628                                         const struct wpabuf *reqData)
 629 {
 630         struct eap_gpsk_data *data = priv;
 631         struct wpabuf *resp;
 632         const u8 *pos;
 633         size_t len;
 634
 635         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_GPSK, reqData, &len);
 636         if (pos == NULL || len < 1) {
 637                 ret->ignore = TRUE;
 638                 return NULL;
 639         }
 640
 641         wpa_printf(MSG_DEBUG, "EAP-GPSK: Received frame: opcode %d", *pos);
 642
 643         ret->ignore = FALSE;
 644         ret->methodState = METHOD_MAY_CONT;
 645         ret->decision = DECISION_FAIL;
 646         ret->allowNotifications = FALSE;
 647
 648         switch (*pos) {
 649         case EAP_GPSK_OPCODE_GPSK_1:
 650                 resp = eap_gpsk_process_gpsk_1(sm, data, ret, reqData,
 651                                                pos + 1, len - 1);
 652                 break;
 653         case EAP_GPSK_OPCODE_GPSK_3:
 654                 resp = eap_gpsk_process_gpsk_3(sm, data, ret, reqData,
 655                                                pos + 1, len - 1);
 656                 break;
 657         default:
 658                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Ignoring message with "
 659                            "unknown opcode %d", *pos);
 660                 ret->ignore = TRUE;
 661                 return NULL;
 662         }
 663
 664         return resp;
 665 }
 666
 667
 668 static Boolean eap_gpsk_isKeyAvailable(struct eap_sm *sm, void *priv)
 669 {
 670         struct eap_gpsk_data *data = priv;
 671         return data->state == SUCCESS;
 672 }
 673
 674
 675 static u8 * eap_gpsk_getKey(struct eap_sm *sm, void *priv, size_t *len)
 676 {
 677         struct eap_gpsk_data *data = priv;
 678         u8 *key;
 679
 680         if (data->state != SUCCESS)
 681                 return NULL;
 682
 683         key = os_malloc(EAP_MSK_LEN);
 684         if (key == NULL)
 685                 return NULL;
 686         os_memcpy(key, data->msk, EAP_MSK_LEN);
 687         *len = EAP_MSK_LEN;
 688
 689         return key;
 690 }
 691
 692
 693 static u8 * eap_gpsk_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
 694 {
 695         struct eap_gpsk_data *data = priv;
 696         u8 *key;
 697
 698         if (data->state != SUCCESS)
 699                 return NULL;
 700
 701         key = os_malloc(EAP_EMSK_LEN);
 702         if (key == NULL)
 703                 return NULL;
 704         os_memcpy(key, data->emsk, EAP_EMSK_LEN);
 705         *len = EAP_EMSK_LEN;
 706
 707         return key;
 708 }
 709
 710
 711 int eap_peer_gpsk_register(void)
 712 {
 713         struct eap_method *eap;
 714         int ret;
 715
 716         eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
 717                                     EAP_VENDOR_IETF, EAP_TYPE_GPSK, "GPSK");
 718         if (eap == NULL)
 719                 return -1;
 720
 721         eap->init = eap_gpsk_init;
 722         eap->deinit = eap_gpsk_deinit;
 723         eap->process = eap_gpsk_process;
 724         eap->isKeyAvailable = eap_gpsk_isKeyAvailable;
 725         eap->getKey = eap_gpsk_getKey;
 726         eap->get_emsk = eap_gpsk_get_emsk;
 727
 728         ret = eap_peer_method_register(eap);
 729         if (ret)
 730                 eap_peer_method_free(eap);
 731         return ret;
 732 }