src/eap_server/eap_server_pax.c

   1 /*
   2  * hostapd / EAP-PAX (RFC 4746) server
   3  * Copyright (c) 2005-2007, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "includes.h"
  10
  11 #include "common.h"
  12 #include "crypto/random.h"
  13 #include "eap_server/eap_i.h"
  14 #include "eap_common/eap_pax_common.h"
  15
  16 /*
  17  * Note: only PAX_STD subprotocol is currently supported
  18  *
  19  * TODO: Add support with PAX_SEC with the mandatory to implement ciphersuite
  20  * (HMAC_SHA1_128, IANA DH Group 14 (2048 bits), RSA-PKCS1-V1_5) and
  21  * recommended ciphersuite (HMAC_SHA256_128, IANA DH Group 15 (3072 bits),
  22  * RSAES-OAEP).
  23  */
  24
  25 struct eap_pax_data {
  26         enum { PAX_STD_1, PAX_STD_3, SUCCESS, FAILURE } state;
  27         u8 mac_id;
  28         union {
  29                 u8 e[2 * EAP_PAX_RAND_LEN];
  30                 struct {
  31                         u8 x[EAP_PAX_RAND_LEN]; /* server rand */
  32                         u8 y[EAP_PAX_RAND_LEN]; /* client rand */
  33                 } r;
  34         } rand;
  35         u8 ak[EAP_PAX_AK_LEN];
  36         u8 mk[EAP_PAX_MK_LEN];
  37         u8 ck[EAP_PAX_CK_LEN];
  38         u8 ick[EAP_PAX_ICK_LEN];
  39         int keys_set;
  40         char *cid;
  41         size_t cid_len;
  42 };
  43
  44
  45 static void * eap_pax_init(struct eap_sm *sm)
  46 {
  47         struct eap_pax_data *data;
  48
  49         data = os_zalloc(sizeof(*data));
  50         if (data == NULL)
  51                 return NULL;
  52         data->state = PAX_STD_1;
  53         /*
  54          * TODO: make this configurable once EAP_PAX_HMAC_SHA256_128 is
  55          * supported
  56          */
  57         data->mac_id = EAP_PAX_MAC_HMAC_SHA1_128;
  58
  59         return data;
  60 }
  61
  62
  63 static void eap_pax_reset(struct eap_sm *sm, void *priv)
  64 {
  65         struct eap_pax_data *data = priv;
  66         os_free(data->cid);
  67         bin_clear_free(data, sizeof(*data));
  68 }
  69
  70
  71 static struct wpabuf * eap_pax_build_std_1(struct eap_sm *sm,
  72                                            struct eap_pax_data *data, u8 id)
  73 {
  74         struct wpabuf *req;
  75         struct eap_pax_hdr *pax;
  76         u8 *pos;
  77
  78         wpa_printf(MSG_DEBUG, "EAP-PAX: PAX_STD-1 (sending)");
  79
  80         if (random_get_bytes(data->rand.r.x, EAP_PAX_RAND_LEN)) {
  81                 wpa_printf(MSG_ERROR, "EAP-PAX: Failed to get random data");
  82                 data->state = FAILURE;
  83                 return NULL;
  84         }
  85
  86         req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PAX,
  87                             sizeof(*pax) + 2 + EAP_PAX_RAND_LEN +
  88                             EAP_PAX_ICV_LEN, EAP_CODE_REQUEST, id);
  89         if (req == NULL) {
  90                 wpa_printf(MSG_ERROR, "EAP-PAX: Failed to allocate memory "
  91                            "request");
  92                 data->state = FAILURE;
  93                 return NULL;
  94         }
  95
  96         pax = wpabuf_put(req, sizeof(*pax));
  97         pax->op_code = EAP_PAX_OP_STD_1;
  98         pax->flags = 0;
  99         pax->mac_id = data->mac_id;
 100         pax->dh_group_id = EAP_PAX_DH_GROUP_NONE;
 101         pax->public_key_id = EAP_PAX_PUBLIC_KEY_NONE;
 102
 103         wpabuf_put_be16(req, EAP_PAX_RAND_LEN);
 104         wpabuf_put_data(req, data->rand.r.x, EAP_PAX_RAND_LEN);
 105         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: A = X (server rand)",
 106                     data->rand.r.x, EAP_PAX_RAND_LEN);
 107
 108         pos = wpabuf_put(req, EAP_PAX_MAC_LEN);
 109         eap_pax_mac(data->mac_id, (u8 *) "", 0,
 110                     wpabuf_mhead(req), wpabuf_len(req) - EAP_PAX_ICV_LEN,
 111                     NULL, 0, NULL, 0, pos);
 112         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", pos, EAP_PAX_ICV_LEN);
 113
 114         return req;
 115 }
 116
 117
 118 static struct wpabuf * eap_pax_build_std_3(struct eap_sm *sm,
 119                                            struct eap_pax_data *data, u8 id)
 120 {
 121         struct wpabuf *req;
 122         struct eap_pax_hdr *pax;
 123         u8 *pos;
 124
 125         wpa_printf(MSG_DEBUG, "EAP-PAX: PAX_STD-3 (sending)");
 126
 127         req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PAX,
 128                             sizeof(*pax) + 2 + EAP_PAX_MAC_LEN +
 129                             EAP_PAX_ICV_LEN, EAP_CODE_REQUEST, id);
 130         if (req == NULL) {
 131                 wpa_printf(MSG_ERROR, "EAP-PAX: Failed to allocate memory "
 132                            "request");
 133                 data->state = FAILURE;
 134                 return NULL;
 135         }
 136
 137         pax = wpabuf_put(req, sizeof(*pax));
 138         pax->op_code = EAP_PAX_OP_STD_3;
 139         pax->flags = 0;
 140         pax->mac_id = data->mac_id;
 141         pax->dh_group_id = EAP_PAX_DH_GROUP_NONE;
 142         pax->public_key_id = EAP_PAX_PUBLIC_KEY_NONE;
 143
 144         wpabuf_put_be16(req, EAP_PAX_MAC_LEN);
 145         pos = wpabuf_put(req, EAP_PAX_MAC_LEN);
 146         eap_pax_mac(data->mac_id, data->ck, EAP_PAX_CK_LEN,
 147                     data->rand.r.y, EAP_PAX_RAND_LEN,
 148                     (u8 *) data->cid, data->cid_len, NULL, 0, pos);
 149         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: MAC_CK(B, CID)",
 150                     pos, EAP_PAX_MAC_LEN);
 151
 152         /* Optional ADE could be added here, if needed */
 153
 154         pos = wpabuf_put(req, EAP_PAX_MAC_LEN);
 155         eap_pax_mac(data->mac_id, data->ick, EAP_PAX_ICK_LEN,
 156                     wpabuf_mhead(req), wpabuf_len(req) - EAP_PAX_ICV_LEN,
 157                     NULL, 0, NULL, 0, pos);
 158         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", pos, EAP_PAX_ICV_LEN);
 159
 160         return req;
 161 }
 162
 163
 164 static struct wpabuf * eap_pax_buildReq(struct eap_sm *sm, void *priv, u8 id)
 165 {
 166         struct eap_pax_data *data = priv;
 167
 168         switch (data->state) {
 169         case PAX_STD_1:
 170                 return eap_pax_build_std_1(sm, data, id);
 171         case PAX_STD_3:
 172                 return eap_pax_build_std_3(sm, data, id);
 173         default:
 174                 wpa_printf(MSG_DEBUG, "EAP-PAX: Unknown state %d in buildReq",
 175                            data->state);
 176                 break;
 177         }
 178         return NULL;
 179 }
 180
 181
 182 static Boolean eap_pax_check(struct eap_sm *sm, void *priv,
 183                              struct wpabuf *respData)
 184 {
 185         struct eap_pax_data *data = priv;
 186         struct eap_pax_hdr *resp;
 187         const u8 *pos;
 188         size_t len, mlen;
 189         u8 icvbuf[EAP_PAX_ICV_LEN], *icv;
 190
 191         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PAX, respData, &len);
 192         if (pos == NULL || len < sizeof(*resp)) {
 193                 wpa_printf(MSG_INFO, "EAP-PAX: Invalid frame");
 194                 return TRUE;
 195         }
 196
 197         mlen = sizeof(struct eap_hdr) + 1 + len;
 198         resp = (struct eap_pax_hdr *) pos;
 199
 200         wpa_printf(MSG_DEBUG, "EAP-PAX: received frame: op_code 0x%x "
 201                    "flags 0x%x mac_id 0x%x dh_group_id 0x%x "
 202                    "public_key_id 0x%x",
 203                    resp->op_code, resp->flags, resp->mac_id, resp->dh_group_id,
 204                    resp->public_key_id);
 205         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: received payload",
 206                     (u8 *) (resp + 1), len - sizeof(*resp) - EAP_PAX_ICV_LEN);
 207
 208         if (data->state == PAX_STD_1 &&
 209             resp->op_code != EAP_PAX_OP_STD_2) {
 210                 wpa_printf(MSG_DEBUG, "EAP-PAX: Expected PAX_STD-2 - "
 211                            "ignore op %d", resp->op_code);
 212                 return TRUE;
 213         }
 214
 215         if (data->state == PAX_STD_3 &&
 216             resp->op_code != EAP_PAX_OP_ACK) {
 217                 wpa_printf(MSG_DEBUG, "EAP-PAX: Expected PAX-ACK - "
 218                            "ignore op %d", resp->op_code);
 219                 return TRUE;
 220         }
 221
 222         if (resp->op_code != EAP_PAX_OP_STD_2 &&
 223             resp->op_code != EAP_PAX_OP_ACK) {
 224                 wpa_printf(MSG_DEBUG, "EAP-PAX: Unknown op_code 0x%x",
 225                            resp->op_code);
 226         }
 227
 228         if (data->mac_id != resp->mac_id) {
 229                 wpa_printf(MSG_DEBUG, "EAP-PAX: Expected MAC ID 0x%x, "
 230                            "received 0x%x", data->mac_id, resp->mac_id);
 231                 return TRUE;
 232         }
 233
 234         if (resp->dh_group_id != EAP_PAX_DH_GROUP_NONE) {
 235                 wpa_printf(MSG_INFO, "EAP-PAX: Expected DH Group ID 0x%x, "
 236                            "received 0x%x", EAP_PAX_DH_GROUP_NONE,
 237                            resp->dh_group_id);
 238                 return TRUE;
 239         }
 240
 241         if (resp->public_key_id != EAP_PAX_PUBLIC_KEY_NONE) {
 242                 wpa_printf(MSG_INFO, "EAP-PAX: Expected Public Key ID 0x%x, "
 243                            "received 0x%x", EAP_PAX_PUBLIC_KEY_NONE,
 244                            resp->public_key_id);
 245                 return TRUE;
 246         }
 247
 248         if (resp->flags & EAP_PAX_FLAGS_MF) {
 249                 /* TODO: add support for reassembling fragments */
 250                 wpa_printf(MSG_INFO, "EAP-PAX: fragmentation not supported");
 251                 return TRUE;
 252         }
 253
 254         if (resp->flags & EAP_PAX_FLAGS_CE) {
 255                 wpa_printf(MSG_INFO, "EAP-PAX: Unexpected CE flag");
 256                 return TRUE;
 257         }
 258
 259         if (data->keys_set) {
 260                 if (len - sizeof(*resp) < EAP_PAX_ICV_LEN) {
 261                         wpa_printf(MSG_INFO, "EAP-PAX: No ICV in the packet");
 262                         return TRUE;
 263                 }
 264                 icv = wpabuf_mhead_u8(respData) + mlen - EAP_PAX_ICV_LEN;
 265                 wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", icv, EAP_PAX_ICV_LEN);
 266                 eap_pax_mac(data->mac_id, data->ick, EAP_PAX_ICK_LEN,
 267                             wpabuf_mhead(respData),
 268                             wpabuf_len(respData) - EAP_PAX_ICV_LEN,
 269                             NULL, 0, NULL, 0, icvbuf);
 270                 if (os_memcmp_const(icvbuf, icv, EAP_PAX_ICV_LEN) != 0) {
 271                         wpa_printf(MSG_INFO, "EAP-PAX: Invalid ICV");
 272                         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: Expected ICV",
 273                                     icvbuf, EAP_PAX_ICV_LEN);
 274                         return TRUE;
 275                 }
 276         }
 277
 278         return FALSE;
 279 }
 280
 281
 282 static void eap_pax_process_std_2(struct eap_sm *sm,
 283                                   struct eap_pax_data *data,
 284                                   struct wpabuf *respData)
 285 {
 286         struct eap_pax_hdr *resp;
 287         u8 mac[EAP_PAX_MAC_LEN], icvbuf[EAP_PAX_ICV_LEN];
 288         const u8 *pos;
 289         size_t len, left, cid_len;
 290         int i;
 291
 292         if (data->state != PAX_STD_1)
 293                 return;
 294
 295         wpa_printf(MSG_DEBUG, "EAP-PAX: Received PAX_STD-2");
 296
 297         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PAX, respData, &len);
 298         if (pos == NULL || len < sizeof(*resp) + EAP_PAX_ICV_LEN)
 299                 return;
 300
 301         resp = (struct eap_pax_hdr *) pos;
 302         pos = (u8 *) (resp + 1);
 303         left = len - sizeof(*resp);
 304
 305         if (left < 2 + EAP_PAX_RAND_LEN ||
 306             WPA_GET_BE16(pos) != EAP_PAX_RAND_LEN) {
 307                 wpa_printf(MSG_INFO, "EAP-PAX: Too short PAX_STD-2 (B)");
 308                 return;
 309         }
 310         pos += 2;
 311         left -= 2;
 312         os_memcpy(data->rand.r.y, pos, EAP_PAX_RAND_LEN);
 313         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: Y (client rand)",
 314                     data->rand.r.y, EAP_PAX_RAND_LEN);
 315         pos += EAP_PAX_RAND_LEN;
 316         left -= EAP_PAX_RAND_LEN;
 317
 318         if (left < 2 || (size_t) 2 + WPA_GET_BE16(pos) > left) {
 319                 wpa_printf(MSG_INFO, "EAP-PAX: Too short PAX_STD-2 (CID)");
 320                 return;
 321         }
 322         cid_len = WPA_GET_BE16(pos);
 323         if (cid_len > 1500) {
 324                 wpa_printf(MSG_INFO, "EAP-PAX: Too long CID");
 325                 return;
 326         }
 327         data->cid_len = cid_len;
 328         os_free(data->cid);
 329         data->cid = os_malloc(data->cid_len);
 330         if (data->cid == NULL) {
 331                 wpa_printf(MSG_INFO, "EAP-PAX: Failed to allocate memory for "
 332                            "CID");
 333                 return;
 334         }
 335         os_memcpy(data->cid, pos + 2, data->cid_len);
 336         pos += 2 + data->cid_len;
 337         left -= 2 + data->cid_len;
 338         wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-PAX: CID",
 339                           (u8 *) data->cid, data->cid_len);
 340
 341         if (left < 2 + EAP_PAX_MAC_LEN ||
 342             WPA_GET_BE16(pos) != EAP_PAX_MAC_LEN) {
 343                 wpa_printf(MSG_INFO, "EAP-PAX: Too short PAX_STD-2 (MAC_CK)");
 344                 return;
 345         }
 346         pos += 2;
 347         left -= 2;
 348         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: MAC_CK(A, B, CID)",
 349                     pos, EAP_PAX_MAC_LEN);
 350
 351         if (eap_user_get(sm, (u8 *) data->cid, data->cid_len, 0) < 0) {
 352                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-PAX: unknown CID",
 353                                   (u8 *) data->cid, data->cid_len);
 354                 data->state = FAILURE;
 355                 return;
 356         }
 357
 358         for (i = 0;
 359              i < EAP_MAX_METHODS &&
 360                      (sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
 361                       sm->user->methods[i].method != EAP_TYPE_NONE);
 362              i++) {
 363                 if (sm->user->methods[i].vendor == EAP_VENDOR_IETF &&
 364                     sm->user->methods[i].method == EAP_TYPE_PAX)
 365                         break;
 366         }
 367
 368         if (i >= EAP_MAX_METHODS ||
 369             sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
 370             sm->user->methods[i].method != EAP_TYPE_PAX) {
 371                 wpa_hexdump_ascii(MSG_DEBUG,
 372                                   "EAP-PAX: EAP-PAX not enabled for CID",
 373                                   (u8 *) data->cid, data->cid_len);
 374                 data->state = FAILURE;
 375                 return;
 376         }
 377
 378         if (sm->user->password == NULL ||
 379             sm->user->password_len != EAP_PAX_AK_LEN) {
 380                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-PAX: invalid password in "
 381                                   "user database for CID",
 382                                   (u8 *) data->cid, data->cid_len);
 383                 data->state = FAILURE;
 384                 return;
 385         }
 386         os_memcpy(data->ak, sm->user->password, EAP_PAX_AK_LEN);
 387
 388         if (eap_pax_initial_key_derivation(data->mac_id, data->ak,
 389                                            data->rand.e, data->mk, data->ck,
 390                                            data->ick) < 0) {
 391                 wpa_printf(MSG_INFO, "EAP-PAX: Failed to complete initial "
 392                            "key derivation");
 393                 data->state = FAILURE;
 394                 return;
 395         }
 396         data->keys_set = 1;
 397
 398         eap_pax_mac(data->mac_id, data->ck, EAP_PAX_CK_LEN,
 399                     data->rand.r.x, EAP_PAX_RAND_LEN,
 400                     data->rand.r.y, EAP_PAX_RAND_LEN,
 401                     (u8 *) data->cid, data->cid_len, mac);
 402         if (os_memcmp_const(mac, pos, EAP_PAX_MAC_LEN) != 0) {
 403                 wpa_printf(MSG_INFO, "EAP-PAX: Invalid MAC_CK(A, B, CID) in "
 404                            "PAX_STD-2");
 405                 wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: Expected MAC_CK(A, B, CID)",
 406                             mac, EAP_PAX_MAC_LEN);
 407                 data->state = FAILURE;
 408                 return;
 409         }
 410
 411         pos += EAP_PAX_MAC_LEN;
 412         left -= EAP_PAX_MAC_LEN;
 413
 414         if (left < EAP_PAX_ICV_LEN) {
 415                 wpa_printf(MSG_INFO, "EAP-PAX: Too short ICV (%lu) in "
 416                            "PAX_STD-2", (unsigned long) left);
 417                 return;
 418         }
 419         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", pos, EAP_PAX_ICV_LEN);
 420         eap_pax_mac(data->mac_id, data->ick, EAP_PAX_ICK_LEN,
 421                     wpabuf_head(respData),
 422                     wpabuf_len(respData) - EAP_PAX_ICV_LEN, NULL, 0, NULL, 0,
 423                     icvbuf);
 424         if (os_memcmp_const(icvbuf, pos, EAP_PAX_ICV_LEN) != 0) {
 425                 wpa_printf(MSG_INFO, "EAP-PAX: Invalid ICV in PAX_STD-2");
 426                 wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: Expected ICV",
 427                             icvbuf, EAP_PAX_ICV_LEN);
 428                 return;
 429         }
 430         pos += EAP_PAX_ICV_LEN;
 431         left -= EAP_PAX_ICV_LEN;
 432
 433         if (left > 0) {
 434                 wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ignored extra payload",
 435                             pos, left);
 436         }
 437
 438         data->state = PAX_STD_3;
 439 }
 440
 441
 442 static void eap_pax_process_ack(struct eap_sm *sm,
 443                                 struct eap_pax_data *data,
 444                                 struct wpabuf *respData)
 445 {
 446         if (data->state != PAX_STD_3)
 447                 return;
 448
 449         wpa_printf(MSG_DEBUG, "EAP-PAX: Received PAX-ACK - authentication "
 450                    "completed successfully");
 451         data->state = SUCCESS;
 452 }
 453
 454
 455 static void eap_pax_process(struct eap_sm *sm, void *priv,
 456                             struct wpabuf *respData)
 457 {
 458         struct eap_pax_data *data = priv;
 459         struct eap_pax_hdr *resp;
 460         const u8 *pos;
 461         size_t len;
 462
 463         if (sm->user == NULL || sm->user->password == NULL) {
 464                 wpa_printf(MSG_INFO, "EAP-PAX: Plaintext password not "
 465                            "configured");
 466                 data->state = FAILURE;
 467                 return;
 468         }
 469
 470         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PAX, respData, &len);
 471         if (pos == NULL || len < sizeof(*resp))
 472                 return;
 473
 474         resp = (struct eap_pax_hdr *) pos;
 475
 476         switch (resp->op_code) {
 477         case EAP_PAX_OP_STD_2:
 478                 eap_pax_process_std_2(sm, data, respData);
 479                 break;
 480         case EAP_PAX_OP_ACK:
 481                 eap_pax_process_ack(sm, data, respData);
 482                 break;
 483         }
 484 }
 485
 486
 487 static Boolean eap_pax_isDone(struct eap_sm *sm, void *priv)
 488 {
 489         struct eap_pax_data *data = priv;
 490         return data->state == SUCCESS || data->state == FAILURE;
 491 }
 492
 493
 494 static u8 * eap_pax_getKey(struct eap_sm *sm, void *priv, size_t *len)
 495 {
 496         struct eap_pax_data *data = priv;
 497         u8 *key;
 498
 499         if (data->state != SUCCESS)
 500                 return NULL;
 501
 502         key = os_malloc(EAP_MSK_LEN);
 503         if (key == NULL)
 504                 return NULL;
 505
 506         *len = EAP_MSK_LEN;
 507         eap_pax_kdf(data->mac_id, data->mk, EAP_PAX_MK_LEN,
 508                     "Master Session Key", data->rand.e, 2 * EAP_PAX_RAND_LEN,
 509                     EAP_MSK_LEN, key);
 510
 511         return key;
 512 }
 513
 514
 515 static u8 * eap_pax_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
 516 {
 517         struct eap_pax_data *data = priv;
 518         u8 *key;
 519
 520         if (data->state != SUCCESS)
 521                 return NULL;
 522
 523         key = os_malloc(EAP_EMSK_LEN);
 524         if (key == NULL)
 525                 return NULL;
 526
 527         *len = EAP_EMSK_LEN;
 528         eap_pax_kdf(data->mac_id, data->mk, EAP_PAX_MK_LEN,
 529                     "Extended Master Session Key",
 530                     data->rand.e, 2 * EAP_PAX_RAND_LEN,
 531                     EAP_EMSK_LEN, key);
 532
 533         return key;
 534 }
 535
 536
 537 static Boolean eap_pax_isSuccess(struct eap_sm *sm, void *priv)
 538 {
 539         struct eap_pax_data *data = priv;
 540         return data->state == SUCCESS;
 541 }
 542
 543
 544 int eap_server_pax_register(void)
 545 {
 546         struct eap_method *eap;
 547         int ret;
 548
 549         eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
 550                                       EAP_VENDOR_IETF, EAP_TYPE_PAX, "PAX");
 551         if (eap == NULL)
 552                 return -1;
 553
 554         eap->init = eap_pax_init;
 555         eap->reset = eap_pax_reset;
 556         eap->buildReq = eap_pax_buildReq;
 557         eap->check = eap_pax_check;
 558         eap->process = eap_pax_process;
 559         eap->isDone = eap_pax_isDone;
 560         eap->getKey = eap_pax_getKey;
 561         eap->isSuccess = eap_pax_isSuccess;
 562         eap->get_emsk = eap_pax_get_emsk;
 563
 564         ret = eap_server_method_register(eap);
 565         if (ret)
 566                 eap_server_method_free(eap);
 567         return ret;
 568 }