Replace WPA_ALG_PMK with KEY_FLAG_PMK

Drop the no longer needed internal alg WPA_ALG_PMK and use KEY_FLAG_PMK
as replacement.

Signed-off-by: Alexander Wetzel <alexander@wetzel-home.de>

diff --git a/src/common/defs.h b/src/common/defs.h
index bd16feb8acc4882f854b50b47ce1f3fafc473e57..077d6399a0ae5ba8b80c023b823a427f10baa4d2 100644 (file)
--- a/src/common/defs.h
+++ b/src/common/defs.h
@@ -200,7 +200,6 @@ enum wpa_alg {
        WPA_ALG_TKIP,
        WPA_ALG_CCMP,
        WPA_ALG_IGTK,
-       WPA_ALG_PMK,
        WPA_ALG_GCMP,
        WPA_ALG_SMS4,
        WPA_ALG_KRK,

diff --git a/src/drivers/driver.h b/src/drivers/driver.h
index 04a453ea8439276196915e50ddce796962f6dbe8..642230ec3801d9991ce319c7fdf51dbf533fb385 100644 (file)
--- a/src/drivers/driver.h
+++ b/src/drivers/driver.h
@@ -1546,9 +1546,8 @@ struct wpa_driver_set_key_params {
         * alg - Encryption algorithm
         *
         * (%WPA_ALG_NONE, %WPA_ALG_WEP, %WPA_ALG_TKIP, %WPA_ALG_CCMP,
-        * %WPA_ALG_IGTK, %WPA_ALG_PMK, %WPA_ALG_GCMP, %WPA_ALG_GCMP_256,
-        * %WPA_ALG_CCMP_256, %WPA_ALG_BIP_GMAC_128, %WPA_ALG_BIP_GMAC_256,
-        * %WPA_ALG_BIP_CMAC_256);
+        * %WPA_ALG_IGTK, %WPA_ALG_GCMP, %WPA_ALG_GCMP_256, %WPA_ALG_CCMP_256,
+        * %WPA_ALG_BIP_GMAC_128, %WPA_ALG_BIP_GMAC_256, %WPA_ALG_BIP_CMAC_256);
         * %WPA_ALG_NONE clears the key. */
        enum wpa_alg alg;
 
@@ -1698,7 +1697,7 @@ struct wpa_driver_capa {
 /** Driver takes care of all DFS operations */
 #define WPA_DRIVER_FLAGS_DFS_OFFLOAD                   0x00000004
 /** Driver takes care of RSN 4-way handshake internally; PMK is configured with
- * struct wpa_driver_ops::set_key using alg = WPA_ALG_PMK */
+ * struct wpa_driver_ops::set_key using key_flag = KEY_FLAG_PMK */
 #define WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X          0x00000008
 /** Driver is for a wired Ethernet interface */
 #define WPA_DRIVER_FLAGS_WIRED         0x00000010

diff --git a/src/drivers/driver_nl80211.c b/src/drivers/driver_nl80211.c
index f44209db03c220e47fee2ed642b506b91c2e7c48..93aa5d702cac51a84565ec5aba8b367f826c21ee 100644 (file)
--- a/src/drivers/driver_nl80211.c
+++ b/src/drivers/driver_nl80211.c
@@ -2883,7 +2883,6 @@ static u32 wpa_alg_to_cipher_suite(enum wpa_alg alg, size_t key_len)
        case WPA_ALG_KRK:
                return RSN_CIPHER_SUITE_KRK;
        case WPA_ALG_NONE:
-       case WPA_ALG_PMK:
                wpa_printf(MSG_ERROR, "nl80211: Unexpected encryption algorithm %d",
                           alg);
                return 0;
@@ -3084,7 +3083,7 @@ static int wpa_driver_nl80211_set_key(struct i802_bss *bss,
        }
 
 #ifdef CONFIG_DRIVER_NL80211_QCA
-       if (alg == WPA_ALG_PMK &&
+       if ((key_flag & KEY_FLAG_PMK) &&
            (drv->capa.flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD)) {
                wpa_printf(MSG_DEBUG, "%s: calling issue_key_mgmt_set_key",
                           __func__);
@@ -3093,10 +3092,9 @@ static int wpa_driver_nl80211_set_key(struct i802_bss *bss,
        }
 #endif /* CONFIG_DRIVER_NL80211_QCA */
 
-       if (alg == WPA_ALG_PMK &&
-           (drv->capa.flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X))
-               return nl80211_set_pmk(drv, key, key_len, addr);
        if (key_flag & KEY_FLAG_PMK) {
+               if (drv->capa.flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X)
+                       return nl80211_set_pmk(drv, key, key_len, addr);
                /* The driver does not have any offload mechanism for PMK, so
                 * there is no need to configure this key. */
                return 0;

diff --git a/src/drivers/driver_openbsd.c b/src/drivers/driver_openbsd.c
index e0eede96b57bedbd0894f3e5d0c580b1283081d5..bfc231178a2f2ef5a625beb95cc183e019d26141 100644 (file)
--- a/src/drivers/driver_openbsd.c
+++ b/src/drivers/driver_openbsd.c
@@ -73,11 +73,12 @@ wpa_driver_openbsd_set_key(void *priv, struct wpa_driver_set_key_params *params)
 {
        struct openbsd_driver_data *drv = priv;
        struct ieee80211_keyavail keyavail;
-       enum wpa_alg alg = params->alg;
+       enum key_flag key_flag = params->key_flag;
        const u8 *key = params->key;
        size_t key_len = params->key_len;
 
-       if (alg != WPA_ALG_PMK || key_len > IEEE80211_PMK_LEN)
+       if (key_len > IEEE80211_PMK_LEN ||
+           (key_flag & KEY_FLAG_PMK_MASK) != KEY_FLAG_PMK) {
                return -1;
 
        memset(&keyavail, 0, sizeof(keyavail));

diff --git a/src/drivers/driver_wext.c b/src/drivers/driver_wext.c
index 776eff72d22e837338ac8cb3afff46dda447669d..978e1cf438b727eccbe7b7b3287410ae99385576 100644 (file)
--- a/src/drivers/driver_wext.c
+++ b/src/drivers/driver_wext.c
@@ -1712,7 +1712,8 @@ static int wpa_driver_wext_set_key_ext(void *priv, enum wpa_alg alg,
                                       const u8 *addr, int key_idx,
                                       int set_tx, const u8 *seq,
                                       size_t seq_len,
-                                      const u8 *key, size_t key_len)
+                                      const u8 *key, size_t key_len,
+                                      enum key_flag key_flag)
 {
        struct wpa_driver_wext_data *drv = priv;
        struct iwreq iwr;
@@ -1751,30 +1752,31 @@ static int wpa_driver_wext_set_key_ext(void *priv, enum wpa_alg alg,
                os_memcpy(ext + 1, key, key_len);
                ext->key_len = key_len;
        }
-       switch (alg) {
-       case WPA_ALG_NONE:
-               ext->alg = IW_ENCODE_ALG_NONE;
-               break;
-       case WPA_ALG_WEP:
-               ext->alg = IW_ENCODE_ALG_WEP;
-               break;
-       case WPA_ALG_TKIP:
-               ext->alg = IW_ENCODE_ALG_TKIP;
-               break;
-       case WPA_ALG_CCMP:
-               ext->alg = IW_ENCODE_ALG_CCMP;
-               break;
-       case WPA_ALG_PMK:
+       if (key_flag & KEY_FLAG_PMK) {
                ext->alg = IW_ENCODE_ALG_PMK;
-               break;
-       case WPA_ALG_IGTK:
-               ext->alg = IW_ENCODE_ALG_AES_CMAC;
-               break;
-       default:
-               wpa_printf(MSG_DEBUG, "%s: Unknown algorithm %d",
-                          __FUNCTION__, alg);
-               os_free(ext);
-               return -1;
+       } else {
+               switch (alg) {
+               case WPA_ALG_NONE:
+                       ext->alg = IW_ENCODE_ALG_NONE;
+                       break;
+               case WPA_ALG_WEP:
+                       ext->alg = IW_ENCODE_ALG_WEP;
+                       break;
+               case WPA_ALG_TKIP:
+                       ext->alg = IW_ENCODE_ALG_TKIP;
+                       break;
+               case WPA_ALG_CCMP:
+                       ext->alg = IW_ENCODE_ALG_CCMP;
+                       break;
+               case WPA_ALG_IGTK:
+                       ext->alg = IW_ENCODE_ALG_AES_CMAC;
+                       break;
+               default:
+                       wpa_printf(MSG_DEBUG, "%s: Unknown algorithm %d",
+                                  __FUNCTION__, alg);
+                       os_free(ext);
+                       return -1;
+               }
        }
 
        if (seq && seq_len) {
@@ -1816,6 +1818,7 @@ static int wpa_driver_wext_set_key(void *priv,
        struct iwreq iwr;
        int ret = 0;
        enum wpa_alg alg = params->alg;
+       enum key_flag key_flag = params->key_flag;
        const u8 *addr = params->addr;
        int key_idx = params->key_idx;
        int set_tx = params->set_tx;
@@ -1830,7 +1833,7 @@ static int wpa_driver_wext_set_key(void *priv,
                   (unsigned long) seq_len, (unsigned long) key_len);
 
        ret = wpa_driver_wext_set_key_ext(drv, alg, addr, key_idx, set_tx,
-                                         seq, seq_len, key, key_len);
+                                         seq, seq_len, key, key_len, key_flag);
        if (ret == 0)
                return 0;
 

diff --git a/wpa_supplicant/wpas_glue.c b/wpa_supplicant/wpas_glue.c
index cef70a6f5771fd6869a06ef94f4cd3f74fd1f29c..7162f8f1fe7cd51ae1435e1439130a44330f2862 100644 (file)
--- a/wpa_supplicant/wpas_glue.c
+++ b/wpa_supplicant/wpas_glue.c
@@ -352,7 +352,7 @@ static void wpa_supplicant_eapol_cb(struct eapol_sm *eapol,
        wpa_hexdump_key(MSG_DEBUG, "RSN: Configure PMK for driver-based 4-way "
                        "handshake", pmk, pmk_len);
 
-       if (wpa_drv_set_key(wpa_s, WPA_ALG_PMK, NULL, 0, 0, NULL, 0, pmk,
+       if (wpa_drv_set_key(wpa_s, 0, NULL, 0, 0, NULL, 0, pmk,
                            pmk_len, KEY_FLAG_PMK)) {
                wpa_printf(MSG_DEBUG, "Failed to set PMK to the driver");
        }
@@ -1196,7 +1196,7 @@ static int wpa_supplicant_key_mgmt_set_pmk(void *ctx, const u8 *pmk,
 
        if (wpa_s->conf->key_mgmt_offload &&
            (wpa_s->drv_flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD))
-               return wpa_drv_set_key(wpa_s, WPA_ALG_PMK, NULL, 0, 0,
+               return wpa_drv_set_key(wpa_s, 0, NULL, 0, 0,
                                       NULL, 0, pmk, pmk_len, KEY_FLAG_PMK);
        else
                return 0;