contrib/wpa_supplicant/eap_gpsk.c

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