vcs.maemo.org Git - wpasupplicant/blob - 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 %lu",
 242                            (unsigned long) *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                 return NULL;
 448         }
 449
 450         pos += len;
 451
 452         return pos;
 453 }
 454
 455
 456 const u8 * eap_gpsk_validate_csuite(struct eap_gpsk_data *data, const u8 *pos,
 457                                     const u8 *end)
 458 {
 459         int vendor, specifier;
 460         const struct eap_gpsk_csuite *csuite;
 461
 462         if (pos == NULL)
 463                 return NULL;
 464
 465         if (end - pos < (int) sizeof(*csuite)) {
 466                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 467                            "CSuite_Sel");
 468                 return NULL;
 469         }
 470         csuite = (const struct eap_gpsk_csuite *) pos;
 471         vendor = WPA_GET_BE32(csuite->vendor);
 472         specifier = WPA_GET_BE16(csuite->specifier);
 473         pos += sizeof(*csuite);
 474         if (vendor != data->vendor || specifier != data->specifier) {
 475                 wpa_printf(MSG_DEBUG, "EAP-GPSK: CSuite_Sel (%d:%d) does not "
 476                            "match with the one sent in GPSK-2 (%d:%d)",
 477                            vendor, specifier, data->vendor, data->specifier);
 478                 return NULL;
 479         }
 480
 481         return pos;
 482 }
 483
 484
 485 const u8 * eap_gpsk_validate_pd_payload_2(struct eap_gpsk_data *data,
 486                                           const u8 *pos, const u8 *end)
 487 {
 488         u16 alen;
 489
 490         if (pos == NULL)
 491                 return NULL;
 492
 493         if (end - pos < 2) {
 494                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 495                            "PD_Payload_2 length");
 496                 return NULL;
 497         }
 498         alen = WPA_GET_BE16(pos);
 499         pos += 2;
 500         if (end - pos < alen) {
 501                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for "
 502                            "%d-octet PD_Payload_2", alen);
 503                 return NULL;
 504         }
 505         wpa_hexdump(MSG_DEBUG, "EAP-GPSK: PD_Payload_2", pos, alen);
 506         pos += alen;
 507
 508         return pos;
 509 }
 510
 511
 512 const u8 * eap_gpsk_validate_gpsk_3_mic(struct eap_gpsk_data *data,
 513                                         const u8 *payload,
 514                                         const u8 *pos, const u8 *end)
 515 {
 516         size_t miclen;
 517         u8 mic[EAP_GPSK_MAX_MIC_LEN];
 518
 519         if (pos == NULL)
 520                 return NULL;
 521
 522         miclen = eap_gpsk_mic_len(data->vendor, data->specifier);
 523         if (end - pos < (int) miclen) {
 524                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for MIC "
 525                            "(left=%lu miclen=%lu)",
 526                            (unsigned long) (end - pos),
 527                            (unsigned long) miclen);
 528                 return NULL;
 529         }
 530         if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
 531                                  data->specifier, payload, pos - payload, mic)
 532             < 0) {
 533                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to compute MIC");
 534                 return NULL;
 535         }
 536         if (os_memcmp(mic, pos, miclen) != 0) {
 537                 wpa_printf(MSG_INFO, "EAP-GPSK: Incorrect MIC in GPSK-3");
 538                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Received MIC", pos, miclen);
 539                 wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Computed MIC", mic, miclen);
 540                 return NULL;
 541         }
 542         pos += miclen;
 543
 544         return pos;
 545 }
 546
 547
 548 static struct wpabuf * eap_gpsk_process_gpsk_3(struct eap_sm *sm,
 549                                                struct eap_gpsk_data *data,
 550                                                struct eap_method_ret *ret,
 551                                                const struct wpabuf *reqData,
 552                                                const u8 *payload,
 553                                                size_t payload_len)
 554 {
 555         struct wpabuf *resp;
 556         const u8 *pos, *end;
 557
 558         if (data->state != GPSK_3) {
 559                 ret->ignore = TRUE;
 560                 return NULL;
 561         }
 562
 563         wpa_printf(MSG_DEBUG, "EAP-GPSK: Received Request/GPSK-3");
 564
 565         end = payload + payload_len;
 566
 567         pos = eap_gpsk_validate_rand(data, payload, end);
 568         pos = eap_gpsk_validate_id_server(data, pos, end);
 569         pos = eap_gpsk_validate_csuite(data, pos, end);
 570         pos = eap_gpsk_validate_pd_payload_2(data, pos, end);
 571         pos = eap_gpsk_validate_gpsk_3_mic(data, payload, pos, end);
 572
 573         if (pos == NULL) {
 574                 eap_gpsk_state(data, FAILURE);
 575                 return NULL;
 576         }
 577         if (pos != end) {
 578                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Ignored %lu bytes of extra "
 579                            "data in the end of GPSK-2",
 580                            (unsigned long) (end - pos));
 581         }
 582
 583         resp = eap_gpsk_send_gpsk_4(data, eap_get_id(reqData));
 584         if (resp == NULL)
 585                 return NULL;
 586
 587         eap_gpsk_state(data, SUCCESS);
 588         ret->methodState = METHOD_DONE;
 589         ret->decision = DECISION_UNCOND_SUCC;
 590
 591         return resp;
 592 }
 593
 594
 595 static struct wpabuf * eap_gpsk_send_gpsk_4(struct eap_gpsk_data *data,
 596                                             u8 identifier)
 597 {
 598         struct wpabuf *resp;
 599         u8 *rpos, *start;
 600         size_t mlen;
 601
 602         wpa_printf(MSG_DEBUG, "EAP-GPSK: Sending Response/GPSK-4");
 603
 604         mlen = eap_gpsk_mic_len(data->vendor, data->specifier);
 605
 606         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_GPSK, 1 + 2 + mlen,
 607                              EAP_CODE_RESPONSE, identifier);
 608         if (resp == NULL)
 609                 return NULL;
 610
 611         wpabuf_put_u8(resp, EAP_GPSK_OPCODE_GPSK_4);
 612         start = wpabuf_put(resp, 0);
 613
 614         /* No PD_Payload_3 */
 615         wpabuf_put_be16(resp, 0);
 616
 617         rpos = wpabuf_put(resp, mlen);
 618         if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
 619                                  data->specifier, start, rpos - start, rpos) <
 620             0) {
 621                 eap_gpsk_state(data, FAILURE);
 622                 wpabuf_free(resp);
 623                 return NULL;
 624         }
 625
 626         return resp;
 627 }
 628
 629
 630 static struct wpabuf * eap_gpsk_process(struct eap_sm *sm, void *priv,
 631                                         struct eap_method_ret *ret,
 632                                         const struct wpabuf *reqData)
 633 {
 634         struct eap_gpsk_data *data = priv;
 635         struct wpabuf *resp;
 636         const u8 *pos;
 637         size_t len;
 638
 639         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_GPSK, reqData, &len);
 640         if (pos == NULL || len < 1) {
 641                 ret->ignore = TRUE;
 642                 return NULL;
 643         }
 644
 645         wpa_printf(MSG_DEBUG, "EAP-GPSK: Received frame: opcode %d", *pos);
 646
 647         ret->ignore = FALSE;
 648         ret->methodState = METHOD_MAY_CONT;
 649         ret->decision = DECISION_FAIL;
 650         ret->allowNotifications = FALSE;
 651
 652         switch (*pos) {
 653         case EAP_GPSK_OPCODE_GPSK_1:
 654                 resp = eap_gpsk_process_gpsk_1(sm, data, ret, reqData,
 655                                                pos + 1, len - 1);
 656                 break;
 657         case EAP_GPSK_OPCODE_GPSK_3:
 658                 resp = eap_gpsk_process_gpsk_3(sm, data, ret, reqData,
 659                                                pos + 1, len - 1);
 660                 break;
 661         default:
 662                 wpa_printf(MSG_DEBUG, "EAP-GPSK: Ignoring message with "
 663                            "unknown opcode %d", *pos);
 664                 ret->ignore = TRUE;
 665                 return NULL;
 666         }
 667
 668         return resp;
 669 }
 670
 671
 672 static Boolean eap_gpsk_isKeyAvailable(struct eap_sm *sm, void *priv)
 673 {
 674         struct eap_gpsk_data *data = priv;
 675         return data->state == SUCCESS;
 676 }
 677
 678
 679 static u8 * eap_gpsk_getKey(struct eap_sm *sm, void *priv, size_t *len)
 680 {
 681         struct eap_gpsk_data *data = priv;
 682         u8 *key;
 683
 684         if (data->state != SUCCESS)
 685                 return NULL;
 686
 687         key = os_malloc(EAP_MSK_LEN);
 688         if (key == NULL)
 689                 return NULL;
 690         os_memcpy(key, data->msk, EAP_MSK_LEN);
 691         *len = EAP_MSK_LEN;
 692
 693         return key;
 694 }
 695
 696
 697 static u8 * eap_gpsk_get_emsk(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_EMSK_LEN);
 706         if (key == NULL)
 707                 return NULL;
 708         os_memcpy(key, data->emsk, EAP_EMSK_LEN);
 709         *len = EAP_EMSK_LEN;
 710
 711         return key;
 712 }
 713
 714
 715 int eap_peer_gpsk_register(void)
 716 {
 717         struct eap_method *eap;
 718         int ret;
 719
 720         eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
 721                                     EAP_VENDOR_IETF, EAP_TYPE_GPSK, "GPSK");
 722         if (eap == NULL)
 723                 return -1;
 724
 725         eap->init = eap_gpsk_init;
 726         eap->deinit = eap_gpsk_deinit;
 727         eap->process = eap_gpsk_process;
 728         eap->isKeyAvailable = eap_gpsk_isKeyAvailable;
 729         eap->getKey = eap_gpsk_getKey;
 730         eap->get_emsk = eap_gpsk_get_emsk;
 731
 732         ret = eap_peer_method_register(eap);
 733         if (ret)
 734                 eap_peer_method_free(eap);
 735         return ret;
 736 }