contrib/wpa/src/ap/wpa_auth_kay.c

   1 /*
   2  * IEEE 802.1X-2010 KaY Interface
   3  * Copyright (c) 2019, The Linux Foundation
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10
  11 #include "utils/common.h"
  12 #include "pae/ieee802_1x_key.h"
  13 #include "pae/ieee802_1x_kay.h"
  14 #include "hostapd.h"
  15 #include "sta_info.h"
  16 #include "wpa_auth_kay.h"
  17 #include "ieee802_1x.h"
  18
  19
  20 #define DEFAULT_KEY_LEN         16
  21 /* secure Connectivity Association Key Name (CKN) */
  22 #define DEFAULT_CKN_LEN         16
  23
  24
  25 static int hapd_macsec_init(void *priv, struct macsec_init_params *params)
  26 {
  27         struct hostapd_data *hapd = priv;
  28
  29         if (!hapd->driver->macsec_init)
  30                 return -1;
  31         return hapd->driver->macsec_init(hapd->drv_priv, params);
  32 }
  33
  34
  35 static int hapd_macsec_deinit(void *priv)
  36 {
  37         struct hostapd_data *hapd = priv;
  38
  39         if (!hapd->driver->macsec_deinit)
  40                 return -1;
  41         return hapd->driver->macsec_deinit(hapd->drv_priv);
  42 }
  43
  44
  45 static int hapd_macsec_get_capability(void *priv, enum macsec_cap *cap)
  46 {
  47         struct hostapd_data *hapd = priv;
  48
  49         if (!hapd->driver->macsec_get_capability)
  50                 return -1;
  51         return hapd->driver->macsec_get_capability(hapd->drv_priv, cap);
  52 }
  53
  54
  55 static int hapd_enable_protect_frames(void *priv, Boolean enabled)
  56 {
  57         struct hostapd_data *hapd = priv;
  58
  59         if (!hapd->driver->enable_protect_frames)
  60                 return -1;
  61         return hapd->driver->enable_protect_frames(hapd->drv_priv, enabled);
  62 }
  63
  64
  65 static int hapd_enable_encrypt(void *priv, Boolean enabled)
  66 {
  67         struct hostapd_data *hapd = priv;
  68
  69         if (!hapd->driver->enable_encrypt)
  70                 return -1;
  71         return hapd->driver->enable_encrypt(hapd->drv_priv, enabled);
  72 }
  73
  74
  75 static int hapd_set_replay_protect(void *priv, Boolean enabled, u32 window)
  76 {
  77         struct hostapd_data *hapd = priv;
  78
  79         if (!hapd->driver->set_replay_protect)
  80                 return -1;
  81         return hapd->driver->set_replay_protect(hapd->drv_priv, enabled,
  82                                                  window);
  83 }
  84
  85
  86 static int hapd_set_current_cipher_suite(void *priv, u64 cs)
  87 {
  88         struct hostapd_data *hapd = priv;
  89
  90         if (!hapd->driver->set_current_cipher_suite)
  91                 return -1;
  92         return hapd->driver->set_current_cipher_suite(hapd->drv_priv, cs);
  93 }
  94
  95
  96 static int hapd_enable_controlled_port(void *priv, Boolean enabled)
  97 {
  98         struct hostapd_data *hapd = priv;
  99
 100         if (!hapd->driver->enable_controlled_port)
 101                 return -1;
 102         return hapd->driver->enable_controlled_port(hapd->drv_priv, enabled);
 103 }
 104
 105
 106 static int hapd_get_receive_lowest_pn(void *priv, struct receive_sa *sa)
 107 {
 108         struct hostapd_data *hapd = priv;
 109
 110         if (!hapd->driver->get_receive_lowest_pn)
 111                 return -1;
 112         return hapd->driver->get_receive_lowest_pn(hapd->drv_priv, sa);
 113 }
 114
 115
 116 static int hapd_get_transmit_next_pn(void *priv, struct transmit_sa *sa)
 117 {
 118         struct hostapd_data *hapd = priv;
 119
 120         if (!hapd->driver->get_transmit_next_pn)
 121                 return -1;
 122         return hapd->driver->get_transmit_next_pn(hapd->drv_priv, sa);
 123 }
 124
 125
 126 static int hapd_set_transmit_next_pn(void *priv, struct transmit_sa *sa)
 127 {
 128         struct hostapd_data *hapd = priv;
 129
 130         if (!hapd->driver->set_transmit_next_pn)
 131                 return -1;
 132         return hapd->driver->set_transmit_next_pn(hapd->drv_priv, sa);
 133 }
 134
 135
 136 static unsigned int conf_offset_val(enum confidentiality_offset co)
 137 {
 138         switch (co) {
 139         case CONFIDENTIALITY_OFFSET_30:
 140                 return 30;
 141                 break;
 142         case CONFIDENTIALITY_OFFSET_50:
 143                 return 50;
 144         default:
 145                 return 0;
 146         }
 147 }
 148
 149
 150 static int hapd_create_receive_sc(void *priv, struct receive_sc *sc,
 151                                   enum validate_frames vf,
 152                                   enum confidentiality_offset co)
 153 {
 154         struct hostapd_data *hapd = priv;
 155
 156         if (!hapd->driver->create_receive_sc)
 157                 return -1;
 158         return hapd->driver->create_receive_sc(hapd->drv_priv, sc,
 159                                                conf_offset_val(co), vf);
 160 }
 161
 162
 163 static int hapd_delete_receive_sc(void *priv, struct receive_sc *sc)
 164 {
 165         struct hostapd_data *hapd = priv;
 166
 167         if (!hapd->driver->delete_receive_sc)
 168                 return -1;
 169         return hapd->driver->delete_receive_sc(hapd->drv_priv, sc);
 170 }
 171
 172
 173 static int hapd_create_receive_sa(void *priv, struct receive_sa *sa)
 174 {
 175         struct hostapd_data *hapd = priv;
 176
 177         if (!hapd->driver->create_receive_sa)
 178                 return -1;
 179         return hapd->driver->create_receive_sa(hapd->drv_priv, sa);
 180 }
 181
 182
 183 static int hapd_delete_receive_sa(void *priv, struct receive_sa *sa)
 184 {
 185         struct hostapd_data *hapd = priv;
 186
 187         if (!hapd->driver->delete_receive_sa)
 188                 return -1;
 189         return hapd->driver->delete_receive_sa(hapd->drv_priv, sa);
 190 }
 191
 192
 193 static int hapd_enable_receive_sa(void *priv, struct receive_sa *sa)
 194 {
 195         struct hostapd_data *hapd = priv;
 196
 197         if (!hapd->driver->enable_receive_sa)
 198                 return -1;
 199         return hapd->driver->enable_receive_sa(hapd->drv_priv, sa);
 200 }
 201
 202
 203 static int hapd_disable_receive_sa(void *priv, struct receive_sa *sa)
 204 {
 205         struct hostapd_data *hapd = priv;
 206
 207         if (!hapd->driver->disable_receive_sa)
 208                 return -1;
 209         return hapd->driver->disable_receive_sa(hapd->drv_priv, sa);
 210 }
 211
 212
 213 static int
 214 hapd_create_transmit_sc(void *priv, struct transmit_sc *sc,
 215                         enum confidentiality_offset co)
 216 {
 217         struct hostapd_data *hapd = priv;
 218
 219         if (!hapd->driver->create_transmit_sc)
 220                 return -1;
 221         return hapd->driver->create_transmit_sc(hapd->drv_priv, sc,
 222                                                 conf_offset_val(co));
 223 }
 224
 225
 226 static int hapd_delete_transmit_sc(void *priv, struct transmit_sc *sc)
 227 {
 228         struct hostapd_data *hapd = priv;
 229
 230         if (!hapd->driver->delete_transmit_sc)
 231                 return -1;
 232         return hapd->driver->delete_transmit_sc(hapd->drv_priv, sc);
 233 }
 234
 235
 236 static int hapd_create_transmit_sa(void *priv, struct transmit_sa *sa)
 237 {
 238         struct hostapd_data *hapd = priv;
 239
 240         if (!hapd->driver->create_transmit_sa)
 241                 return -1;
 242         return hapd->driver->create_transmit_sa(hapd->drv_priv, sa);
 243 }
 244
 245
 246 static int hapd_delete_transmit_sa(void *priv, struct transmit_sa *sa)
 247 {
 248         struct hostapd_data *hapd = priv;
 249
 250         if (!hapd->driver->delete_transmit_sa)
 251                 return -1;
 252         return hapd->driver->delete_transmit_sa(hapd->drv_priv, sa);
 253 }
 254
 255
 256 static int hapd_enable_transmit_sa(void *priv, struct transmit_sa *sa)
 257 {
 258         struct hostapd_data *hapd = priv;
 259
 260         if (!hapd->driver->enable_transmit_sa)
 261                 return -1;
 262         return hapd->driver->enable_transmit_sa(hapd->drv_priv, sa);
 263 }
 264
 265
 266 static int hapd_disable_transmit_sa(void *priv, struct transmit_sa *sa)
 267 {
 268         struct hostapd_data *hapd = priv;
 269
 270         if (!hapd->driver->disable_transmit_sa)
 271                 return -1;
 272         return hapd->driver->disable_transmit_sa(hapd->drv_priv, sa);
 273 }
 274
 275
 276 int ieee802_1x_alloc_kay_sm_hapd(struct hostapd_data *hapd,
 277                                  struct sta_info *sta)
 278 {
 279         struct ieee802_1x_kay_ctx *kay_ctx;
 280         struct ieee802_1x_kay *res = NULL;
 281         enum macsec_policy policy;
 282
 283         ieee802_1x_dealloc_kay_sm_hapd(hapd);
 284
 285         if (!hapd->conf || hapd->conf->macsec_policy == 0)
 286                 return 0;
 287
 288         if (hapd->conf->macsec_policy == 1) {
 289                 if (hapd->conf->macsec_integ_only == 1)
 290                         policy = SHOULD_SECURE;
 291                 else
 292                         policy = SHOULD_ENCRYPT;
 293         } else {
 294                 policy = DO_NOT_SECURE;
 295         }
 296
 297         wpa_printf(MSG_DEBUG, "%s: if_name=%s", __func__, hapd->conf->iface);
 298         kay_ctx = os_zalloc(sizeof(*kay_ctx));
 299         if (!kay_ctx)
 300                 return -1;
 301
 302         kay_ctx->ctx = hapd;
 303
 304         kay_ctx->macsec_init = hapd_macsec_init;
 305         kay_ctx->macsec_deinit = hapd_macsec_deinit;
 306         kay_ctx->macsec_get_capability = hapd_macsec_get_capability;
 307         kay_ctx->enable_protect_frames = hapd_enable_protect_frames;
 308         kay_ctx->enable_encrypt = hapd_enable_encrypt;
 309         kay_ctx->set_replay_protect = hapd_set_replay_protect;
 310         kay_ctx->set_current_cipher_suite = hapd_set_current_cipher_suite;
 311         kay_ctx->enable_controlled_port = hapd_enable_controlled_port;
 312         kay_ctx->get_receive_lowest_pn = hapd_get_receive_lowest_pn;
 313         kay_ctx->get_transmit_next_pn = hapd_get_transmit_next_pn;
 314         kay_ctx->set_transmit_next_pn = hapd_set_transmit_next_pn;
 315         kay_ctx->create_receive_sc = hapd_create_receive_sc;
 316         kay_ctx->delete_receive_sc = hapd_delete_receive_sc;
 317         kay_ctx->create_receive_sa = hapd_create_receive_sa;
 318         kay_ctx->delete_receive_sa = hapd_delete_receive_sa;
 319         kay_ctx->enable_receive_sa = hapd_enable_receive_sa;
 320         kay_ctx->disable_receive_sa = hapd_disable_receive_sa;
 321         kay_ctx->create_transmit_sc = hapd_create_transmit_sc;
 322         kay_ctx->delete_transmit_sc = hapd_delete_transmit_sc;
 323         kay_ctx->create_transmit_sa = hapd_create_transmit_sa;
 324         kay_ctx->delete_transmit_sa = hapd_delete_transmit_sa;
 325         kay_ctx->enable_transmit_sa = hapd_enable_transmit_sa;
 326         kay_ctx->disable_transmit_sa = hapd_disable_transmit_sa;
 327
 328         res = ieee802_1x_kay_init(kay_ctx, policy,
 329                                   hapd->conf->macsec_replay_protect,
 330                                   hapd->conf->macsec_replay_window,
 331                                   hapd->conf->macsec_port,
 332                                   hapd->conf->mka_priority, hapd->conf->iface,
 333                                   hapd->own_addr);
 334         /* ieee802_1x_kay_init() frees kay_ctx on failure */
 335         if (!res)
 336                 return -1;
 337
 338         hapd->kay = res;
 339
 340         return 0;
 341 }
 342
 343
 344 void ieee802_1x_dealloc_kay_sm_hapd(struct hostapd_data *hapd)
 345 {
 346         if (!hapd->kay)
 347                 return;
 348
 349         ieee802_1x_kay_deinit(hapd->kay);
 350         hapd->kay = NULL;
 351 }
 352
 353
 354 static int ieee802_1x_auth_get_session_id(struct hostapd_data *hapd,
 355                                           struct sta_info *sta, u8 *sid,
 356                                           size_t *len)
 357 {
 358         const u8 *session_id;
 359         size_t id_len, need_len;
 360
 361         session_id = ieee802_1x_get_session_id(sta->eapol_sm, &id_len);
 362         if (!session_id) {
 363                 wpa_printf(MSG_DEBUG,
 364                            "MACsec: Failed to get SessionID from EAPOL state machines");
 365                 return -1;
 366         }
 367
 368         need_len = 1 + 2 * 32 /* random size */;
 369         if (need_len > id_len) {
 370                 wpa_printf(MSG_DEBUG, "EAP Session-Id not long enough");
 371                 return -1;
 372         }
 373
 374         os_memcpy(sid, session_id, need_len);
 375         *len = need_len;
 376
 377         return 0;
 378 }
 379
 380
 381 static int ieee802_1x_auth_get_msk(struct hostapd_data *hapd,
 382                                    struct sta_info *sta, u8 *msk, size_t *len)
 383 {
 384         const u8 *key;
 385         size_t keylen;
 386
 387         if (!sta->eapol_sm)
 388                 return -1;
 389
 390         key = ieee802_1x_get_key(sta->eapol_sm, &keylen);
 391         if (key == NULL) {
 392                 wpa_printf(MSG_DEBUG,
 393                            "MACsec: Failed to get MSK from EAPOL state machines");
 394                 return -1;
 395         }
 396         wpa_printf(MSG_DEBUG, "MACsec: Successfully fetched key (len=%lu)",
 397                    (unsigned long) keylen);
 398         wpa_hexdump_key(MSG_DEBUG, "MSK: ", key, keylen);
 399
 400         if (keylen > *len)
 401                 keylen = *len;
 402         os_memcpy(msk, key, keylen);
 403         *len = keylen;
 404
 405         return 0;
 406 }
 407
 408
 409 void * ieee802_1x_notify_create_actor_hapd(struct hostapd_data *hapd,
 410                                            struct sta_info *sta)
 411 {
 412         u8 *sid;
 413         size_t sid_len = 128;
 414         struct mka_key_name *ckn;
 415         struct mka_key *cak;
 416         struct mka_key *msk;
 417         void *res = NULL;
 418
 419         if (!hapd->kay || hapd->kay->policy == DO_NOT_SECURE)
 420                 return NULL;
 421
 422         wpa_printf(MSG_DEBUG,
 423                    "IEEE 802.1X: External notification - Create MKA for "
 424                    MACSTR, MAC2STR(sta->addr));
 425
 426         msk = os_zalloc(sizeof(*msk));
 427         sid = os_zalloc(sid_len);
 428         ckn = os_zalloc(sizeof(*ckn));
 429         cak = os_zalloc(sizeof(*cak));
 430         if (!msk || !sid || !ckn || !cak)
 431                 goto fail;
 432
 433         msk->len = DEFAULT_KEY_LEN;
 434         if (ieee802_1x_auth_get_msk(hapd, sta, msk->key, &msk->len)) {
 435                 wpa_printf(MSG_ERROR, "IEEE 802.1X: Could not get MSK");
 436                 goto fail;
 437         }
 438
 439         if (ieee802_1x_auth_get_session_id(hapd, sta, sid, &sid_len))
 440         {
 441                 wpa_printf(MSG_ERROR,
 442                            "IEEE 802.1X: Could not get EAP Session Id");
 443                 goto fail;
 444         }
 445
 446         wpa_hexdump(MSG_DEBUG, "own_addr", hapd->own_addr, ETH_ALEN);
 447         wpa_hexdump(MSG_DEBUG, "sta_addr", sta->addr, ETH_ALEN);
 448
 449         /* Derive CAK from MSK */
 450         cak->len = DEFAULT_KEY_LEN;
 451         if (ieee802_1x_cak_aes_cmac(msk->key, msk->len, hapd->own_addr,
 452                                     sta->addr, cak->key, cak->len)) {
 453                 wpa_printf(MSG_ERROR, "IEEE 802.1X: Deriving CAK failed");
 454                 goto fail;
 455         }
 456         wpa_hexdump_key(MSG_DEBUG, "Derived CAK", cak->key, cak->len);
 457
 458         /* Derive CKN from MSK */
 459         ckn->len = DEFAULT_CKN_LEN;
 460         if (ieee802_1x_ckn_aes_cmac(msk->key, msk->len, hapd->own_addr,
 461                                     sta->addr, sid, sid_len, ckn->name)) {
 462                 wpa_printf(MSG_ERROR, "IEEE 802.1X: Deriving CKN failed");
 463                 goto fail;
 464         }
 465         wpa_hexdump(MSG_DEBUG, "Derived CKN", ckn->name, ckn->len);
 466
 467         res = ieee802_1x_kay_create_mka(hapd->kay, ckn, cak, 0, EAP_EXCHANGE,
 468                                         TRUE);
 469
 470 fail:
 471         bin_clear_free(msk, sizeof(*msk));
 472         os_free(sid);
 473         os_free(ckn);
 474         bin_clear_free(cak, sizeof(*cak));
 475
 476         return res;
 477 }
 478
 479
 480 void * ieee802_1x_create_preshared_mka_hapd(struct hostapd_data *hapd,
 481                                             struct sta_info *sta)
 482 {
 483         struct mka_key *cak;
 484         struct mka_key_name *ckn;
 485         void *res = NULL;
 486
 487         if ((hapd->conf->mka_psk_set & MKA_PSK_SET) != MKA_PSK_SET)
 488                 goto end;
 489
 490         ckn = os_zalloc(sizeof(*ckn));
 491         if (!ckn)
 492                 goto end;
 493
 494         cak = os_zalloc(sizeof(*cak));
 495         if (!cak)
 496                 goto free_ckn;
 497
 498         if (ieee802_1x_alloc_kay_sm_hapd(hapd, sta) < 0 || !hapd->kay)
 499                 goto free_cak;
 500
 501         if (hapd->kay->policy == DO_NOT_SECURE)
 502                 goto dealloc;
 503
 504         cak->len = hapd->conf->mka_cak_len;
 505         os_memcpy(cak->key, hapd->conf->mka_cak, cak->len);
 506
 507         ckn->len = hapd->conf->mka_ckn_len;;
 508         os_memcpy(ckn->name, hapd->conf->mka_ckn, ckn->len);
 509
 510         res = ieee802_1x_kay_create_mka(hapd->kay, ckn, cak, 0, PSK, TRUE);
 511         if (res)
 512                 goto free_cak;
 513
 514 dealloc:
 515         /* Failed to create MKA */
 516         ieee802_1x_dealloc_kay_sm_hapd(hapd);
 517 free_cak:
 518         os_free(cak);
 519 free_ckn:
 520         os_free(ckn);
 521 end:
 522         return res;
 523 }