4.5.3 ENABLE_NETWORK命令处理

ENABLE_NETWORK命令由wpa_supplicant_ctrl_iface_enable_network进行处理，其代码如 下所示。 **ctrl_iface.c：：wpa_supplicant_ctrl_iface_enable_network** ~~~ static int wpa_supplicant_ctrl_iface_enable_network(struct wpa_supplicant *wpa_s,char *cmd) { int id; struct wpa_ssid *ssid; if (os_strcmp(cmd, "all") == 0) { // 使能所有无线网络 ssid = NULL; } else { id = atoi(cmd); // 本例中的id为0 ssid = wpa_config_get_network(wpa_s->conf, id); // 找到id为0的无线网络配置对象 ...... // 在前面ADD_NETWORK中，disabled为1，表示还没有使能它。disable为2的情况和P2P有关 if (ssid->disabled == 2) {......} } wpa_supplicant_enable_network(wpa_s, ssid); return 0; } ~~~ 来看wpa_supplicant_enable_network，其代码如下所示。 **wpa_supplicant.c：：wpa_supplicant_enable_network** ~~~ void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid) { struct wpa_ssid *other_ssid; int was_disabled; if (ssid == NULL) { ......// 处理ENABLE_NETWORK all的情况 } else if (ssid->disabled && ssid->disabled != 2) { if (wpa_s->current_ssid == NULL) {// WPAS当前没有活跃的无线网络，所以current_ssid为空 wpa_s->reassociate = 1; // 注意这个变量的值 // ADD_NETWORK只是添加了一个无线网络配置项 // 接下来要发起扫描工作以和对应的无线网络进行交互 // 下面这个函数将发起scan操作。后面两个0代表时间。详情见下节分析 wpa_supplicant_req_scan(wpa_s, 0, 0); } was_disabled = ssid->disabled; ssid->disabled = 0; // 设置disabled为0 if (was_disabled != ssid->disabled) wpas_notify_network_enabled_changed(wpa_s, ssid); } } ~~~ 正如代码中注释所说，ADD_NETWORK不过是为WPAS添加了一个无线网络配置项罢了。该无线网络是否存在？通过SET_NETWORK配置的信息是否正确？这些问题的解答首先从无线网络扫描开始。 #### **一、无线网络扫描流程分析** ENABLE_NETWORK将发起无线网络扫描请求，这是由wpa_supplicant_req_scan完成的，其代码如下所示。 **scan.c：：wpa_supplicant_req_scan** ~~~ void wpa_supplicant_req_scan(struct wpa_supplicant *wpa_s, int sec, int usec) { #ifndef ANDROID // Android平台上，该宏被定义 ......// 不讨论非Android平台上的代码 #endif eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL); // 在本例中，sec和usec都是0，所以wpa_supplicant_scan将很快得到执行。该函数是扫描的核心代码 eloop_register_timeout(sec, usec, wpa_supplicant_scan, wpa_s, NULL); } ~~~ wpa_supplicant_scan是无线网络扫描的核心函数，其代码比较复杂，我们分段来看。 **1、wpa_supplicant_scan分析之一** 这一段代码主要和scan请求的参数准备有关。 **scan.c：：wpa_supplicant_scan代码段一** ~~~ static void wpa_supplicant_scan(void *eloop_ctx, void *timeout_ctx) { struct wpa_supplicant *wpa_s = eloop_ctx; struct wpa_ssid *ssid; int scan_req = 0, ret; struct wpabuf *extra_ie; // 用于存储Information Element信息 struct wpa_driver_scan_params params; // 发给驱动的scan请求命令 // 用于记录一个scan请求能包含多少个ssid。请参考4.3.4节关于capability的介绍 size_t max_ssids; enum wpa_states prev_state; // wpa_state取值为WPA_INACTIVE，由4.3.4节wpa_supplicant_driver_init函数中的代码设置 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) { return;} // disconnected为0，scan_req为1，都是wpa_supplicant构造时的默认值 if (wpa_s->disconnected && !wpa_s->scan_req) { ......} /* 搜索wpa_config中所有的无线网络配置项，看其中是否有使能的无线网络。本例中，在扫描之前， 已经将目标wpa_ssid的disabled变量置为0，这样，下面这个函数调用将返回非0值，使得整个if判断为假。 */ if (!wpa_supplicant_enabled_networks(wpa_s->conf) && !wpa_s->scan_req) {......} /* ap_scan是一个很有意思的参数，它和AP扫描和选择有关，默认值为1。值为1：表示WPAS来完成 AP扫描和选择的绝大部分工作（包括关联、EAPOL认证等工作）。值为0：表示驱动完成AP扫描和选 择的工作。这种驱动比较少见，笔者未能找到关于WPA_DRIVER_FLAGS_WIRED标志的合理解释，有 知晓的读者不妨和大家分享一下相关知识。值为2：和0类似，不过在NDIS（Windows上的网络设备 驱动）中用得较多。 */ if (wpa_s->conf->ap_scan != 0 && (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)){......} if (wpa_s->conf->ap_scan == 0) {// 如果驱动能完成大部分工作的话，WPAS的工作量将大大减少 wpa_supplicant_gen_assoc_event(wpa_s); return; // 无须后面的流程 } ......// CONFIG_P2P：P2P相关，本章不讨论 if (wpa_s->conf->ap_scan == 2) max_ssids = 1; else { max_ssids = wpa_s->max_scan_ssids; // 一个scan请求能包含多少个ssid if (max_ssids > WPAS_MAX_SCAN_SSIDS) max_ssids = WPAS_MAX_SCAN_SSIDS; } scan_req = wpa_s->scan_req; // scan_req为1 wpa_s->scan_req = 0; // scan_req被置为0 os_memset(¶ms, 0, sizeof(params)); // 初始化scan请求的参数，其类型为wpa_driver_scan_params } ~~~ 根据第3章关于无线网络扫描的介绍，一个Probe Request要么指定wildcard ssid以扫描周围所有的无线网络，要么指定某个ssid以扫描特定无线网络。为了方便WPAS的使用，wlandriver新增了一个功能，使得上层可通过一次scan请求来扫描多个不同ssid的无线网络。一个scan请求在代码中对应的数据结构就是wpa_driver_scan_params。而wpa_supplicant_scan最重要的工作就是准备好这个请求。 **2、wpa_supplicant_scan分析之二** 接着来看代码段二。 **scan.c：：wpa_supplicant_scan代码段二** ~~~ ......// 接上段代码 prev_state = wpa_s->wpa_state; // 此时的wpa_state是WPA_INACTIVE if (wpa_s->wpa_state == WPA_DISCONNECTED || wpa_s->wpa_state == WPA_INACTIVE) wpa_supplicant_set_state(wpa_s, WPA_SCANNING);// 设置WPAS状态为WPA_SCANNING /* connect_without_scan指向一个wpa_ssid对象。它对应的应用场景是：WPAS事先通过某种方 式（例如后续章节将要介绍的WPS）已经知道要连接的无线网络了，所以此处就无须扫描，仅关联它即可。 */ if (scan_req != 2 && wpa_s->connect_without_scan) { for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) { if (ssid == wpa_s->connect_without_scan) break; } wpa_s->connect_without_scan = NULL; if (ssid) { wpa_supplicant_associate(wpa_s, NULL, ssid); // 关联到目标网络 return; } } // 搜索wpa_config中的所有无线网络配置项，看看哪些需要包含到这次scan请求中 ssid = wpa_s->conf->ssid; /* prev_scan_ssid用于记录上一次scan请求的最后一个ssid。它对应了如下的应用场景。 假设scan请求一次只能携带2个ssid，如果要扫描wpa_config中配置的全部网络项（假设是4个）， 则需要发起两次scan请求。所以，当prev_scan_ssid上一次扫描的并非全部无线网络的话（由 wildcardssid来判断），则此处要接着扫描之前没有扫描的那些无线网络。 以本例而言，prev_scan_ssid初始值是WILDCARD_SSID_SCAN（其值为1）。 */ if (wpa_s->prev_scan_ssid != WILDCARD_SSID_SCAN) { while (ssid) { if (ssid == wpa_s->prev_scan_ssid) { ssid = ssid->next; break; } ssid = ssid->next; } } if (scan_req != 2 && wpa_s->conf->ap_scan == 2) { ......// 不考虑这种情况 #ifndef ANDROID ...... #endif } else { struct wpa_ssid *start = ssid, *tssid; int freqs_set = 0; if (ssid == NULL && max_ssids > 1) ssid = wpa_s->conf->ssid; while (ssid) { /* 有一些AP被设置为hidden ssid。即它不响应wildcard ssid扫描的Probe Request， 同时，自己发送的Beacon帧也不携带ssid信息。这样，只有知道ssid的STA才能和这 些AP连接上，其安全性略有提高。scan_ssid就是用来判断此无线网络是否需要指明ssid。 本例中的"Test"无线网络没有隐藏 ssid，所以scan_ssid值为0。否则需要通过SET_ NETWORK 0 scan_ssid 1来设置它。 */ if (!ssid->disabled && ssid->scan_ssid) { // 把ssid信息加到params的ssids数组中 params.ssids[params.num_ssids].ssid = ssid->ssid; params.ssids[params.num_ssids].ssid_len = ssid->ssid_len; params.num_ssids++; // 如果本次scan请求的ssid个数已经达到driver能支持的最大数，则跳出循环 if (params.num_ssids + 1 >= max_ssids) break; } ssid = ssid->next; if (ssid == start) break; if (ssid == NULL && max_ssids > 1 && start != wpa_s->conf->ssid) ssid = wpa_s->conf->ssid; } /* 处理扫描时的频率选择。如果已经知道目标无线网络的工作信道，可以直接设定频率参数以 优化扫描过程。否则，无线网卡将尝试在各个信道上搜索目标无线网络。本例没有使用频率参数。 */ for (tssid = wpa_s->conf->ssid; tssid; tssid = tssid->next) { if (tssid->disabled) continue; if ((params.freqs || !freqs_set) && tssid->scan_freq) { int_array_concat(¶ms.freqs,tssid->scan_freq); } else { os_free(params.freqs); params.freqs = NULL; } freqs_set = 1; } int_array_sort_unique(params.freqs); // 对所有频率参数进行升序排序 } if (ssid && max_ssids == 1) { // 如果scan请求最多只能包含一个ssid if (!wpa_s->prev_scan_wildcard) { params.ssids[0].ssid = NULL; // 扫描wildcast ssid params.ssids[0].ssid_len = 0; wpa_s->prev_scan_wildcard = 1; } else { wpa_s->prev_scan_ssid = ssid; wpa_s->prev_scan_wildcard = 0; } } else if (ssid) { wpa_s->prev_scan_ssid = ssid; params.num_ssids++; } else { wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN; params.num_ssids++; } // 对频率参数进行修改，和P2P以及WPS有关，本章略过它们 wpa_supplicant_optimize_freqs(wpa_s, ¶ms); // 是否需要携带附件的IE信息。主要用在WPS等情况，本章略过它们 extra_ie = wpa_supplicant_extra_ies(wpa_s, ¶ms); if (params.freqs == NULL && wpa_s->next_scan_freqs) { params.freqs = wpa_s->next_scan_freqs; } else os_free(wpa_s->next_scan_freqs); wpa_s->next_scan_freqs = NULL; /* scan请求可以设置一个过滤条件，扫描完毕后，driver wrapper会过滤掉那些不符合条件的无线 网络。注意，filter_ssids用来保存那些不能被过滤的无线网络ssid。即，扫描到的无线网络不在 filter_ssids中时，它将被过滤掉。过滤的代码在driver_nl80211.c nl80211_scan_filtered 函数中，其调用之处在同一文件里的bss_info_handler函数中。 */ params.filter_ssids = wpa_supplicant_build_filter_ssids(wpa_s->conf, ¶ms.num_filter_ssids); if (extra_ie) { params.extra_ies = wpabuf_head(extra_ie); params.extra_ies_len = wpabuf_len(extra_ie); } #ifdef CONFIG_P2P ...... #endif /* CONFIG_P2P */ ~~~ 上述wpa_supplicant_scan代码段主要展示了如何填写扫描请求参数，复杂之处在于其对细节的处理。下面来看最后一个代码段。 **3、wpa_supplicant_scan分析之三** 当scan请求的参数准备好后，wpa_supplicant_scan将直接向driver wrapper发起scan请求。 **scan.c：：wpa_supplicant_scan代码段三** ~~~ static int wpa_driver_nl80211_scan(void *priv, struct wpa_driver_scan_params *params) { struct i802_bss *bss = priv; // i802_bss是driver wrapper的上下文信息 struct wpa_driver_nl80211_data *drv = bss->drv; // 获取wpa_driver_nl80211_data对象 int ret = 0, timeout; struct nl_msg *msg, *ssids, *freqs, *rates; size_t i; drv->scan_for_auth = 0; msg = nlmsg_alloc();ssids = nlmsg_alloc();freqs = nlmsg_alloc(); rates = nlmsg_alloc(); // 这个函数的主要功能是将wpa_driver_scan_params参数转换成对应的netlink command os_free(drv->filter_ssids); drv->filter_ssids = params->filter_ssids; params->filter_ssids = NULL; drv->num_filter_ssids = params->num_filter_ssids; nl80211_cmd(drv, msg, 0, NL80211_CMD_TRIGGER_SCAN); NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex); // 指定网卡设备编号 for (i = 0; i < params->num_ssids; i++) // 填充ssid信息 NLA_PUT(ssids, i + 1, params->ssids[i].ssid_len,params->ssids[i].ssid); if (params->num_ssids) nla_put_nested(msg, NL80211_ATTR_SCAN_SSIDS, ssids); if (params->extra_ies) // 填充附加IE信息 NLA_PUT(msg, NL80211_ATTR_IE, params->extra_ies_len,params->extra_ies); if (params->freqs) { // 填充频率信息 for (i = 0; params->freqs[i]; i++) NLA_PUT_U32(freqs, i + 1, params->freqs[i]); nla_put_nested(msg, NL80211_ATTR_SCAN_FREQUENCIES, freqs); } if (params->p2p_probe) {......// P2P相关} /* 发送请求给wlan驱动。返回值只是表示该命令是否正确发送给了驱动。扫描结束事件将通过 driver event返回给WPAS。下文将分析如何处理扫描结束事件。 */ ret = send_and_recv_msgs(drv, msg, NULL, NULL); msg = NULL; if (ret) { ......// 错误处理} timeout = 10; /* 一般情况下，driver完成扫描后需要通知WPAS一个scan complete事件。如果驱动不通知的话， WPAS就会自己去查询driver以获取扫描到的无线网络信息。如何知晓driver是否会通知该事件呢？ WPAS中是通过scan_complete_events变量来判断的。值得指出的是，该变量的取值是测试出来的。 即scan_complete_events初始值为0。如果扫描后收到了scan complete事件，该值将被 修改为1。由于本例中，该变量是第一次碰到，所以其值为0。 */ if (drv->scan_complete_events) timeout = 30; eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx); // 本例中，timeout为10秒 eloop_register_timeout(timeout, 0, wpa_driver_nl80211_scan_timeout, drv, drv->ctx); ...... return ret; } ~~~ 就本例而言，ENABLE_WORK命令处理的第一步就是要扫描周围的无线网络。至于目标无线网络是否存在，则属于扫描结果处理流程的工作了。 **4、无线网络扫描流程总结** 图4-31所示为触发扫描功能的流程图。 :-:  图4-31　触发扫描的流程图 图4-31所示函数中，wpa_supplicant_scan的内容较为丰富，其中有很多细节内容。读者初次学习时，可以先不考虑这些细节，只要把握图4-31中的函数调用流程即可。 马上来看扫描结果的处理流程。 #### **二、扫描结果处理流程分析** 在上一节的扫描请求中，driver_nl80211发送了NL80211_CMD_TRIGGER_SCAN命令给wlan driver以通知它开始扫描周围的无线网络。当wlan driver完成此任务后，它将向4.3.4节中wpa_driver_nl80211_init_nl_global函数中注册的三个netlink组播之一的"scan"组播地址发送结果。而driver_nl80211对应处理来自wlan driver netlink消息处理回调函数为 process_global_event，而它最终又会调用do_process_drv_event进行处理。所有，直接来看do_process_drv_event中和扫描结果相关的代码即可。 **driver_nl80211.c：：do_process_drv_event** ~~~ static void do_process_drv_event(struct wpa_driver_nl80211_data *drv, int cmd, struct nlattr **tb) { /* ap_scan_as_station和hostapd有关，该值默认等于NL80211_IFTYPE_UNSPECIFIED。读 者可参考4.3.4节"wpa_supplicant_init_iface分析之三"中对wpa_driver_nl80211_init 的分析。 */ if (drv->ap_scan_as_station != NL80211_IFTYPE_UNSPECIFIED && (cmd == NL80211_CMD_NEW_SCAN_RESULTS ||cmd == NL80211_CMD_SCAN_ABORTED)) {......} switch (cmd) { // driver wrapper发送NL80211_CMD_TRIGGER_SCAN命令后，wlan driver也会回复同名的一个消息 case NL80211_CMD_TRIGGER_SCAN: wpa_printf(MSG_DEBUG, "nl80211: Scan trigger"); break; ......// 其他消息处理 case NL80211_CMD_NEW_SCAN_RESULTS: // 收到来自driver的scan回复，所以设置scan_complete_events变量为1 drv->scan_complete_events = 1; // 取消超时任务 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx); /* 图4-1所示的WPAS软件结构中曾提到driver wrapper将通过发送driver event的方式 触发WPAS其他模块进行对应处理。下面这个函数即是用来处理和发送与scan相关的driver event的。其详情见下文。 */ send_scan_event(drv, 0, tb); break; ...... } return } ~~~ 上述代码中的send_scan_event将解析来自wlan driver的扫描完毕事件，然后再向WPAS发送driver event，其代码如下所示。 **driver_nl80211.c：：send_scan_event** ~~~ static void send_scan_event(struct wpa_driver_nl80211_data *drv, int aborted, struct nlattr *tb[]) { // 代表driver event的数据结构 // 它是一个联合体，包含了assoc_info、auth_info、scan_info等较多内容 union wpa_event_data event; struct nlattr *nl; int rem; // 扫描信息，包含频率数组（int类型的数组）以及wpa_driver_scan_ssid数组 // 请读者特别注意scan_info不是扫描结果 struct scan_info *info; #define MAX_REPORT_FREQS 50 int freqs[MAX_REPORT_FREQS]; int num_freqs = 0; /* scan_for_auth变量和wlan driver有关，它描述了如下的应用场景。 当WPAS发起认证（authentication）操作时，它将向driver发送NL80211_CMD_ AUTHENTICATE命令。driver可能因为某种原因（超时等），其内部存储的目标BSS（代表目标无 线网络）信息失效。这时，它将返回ENOENT给WPAS。正常情况下，WPAS应该重新扫描。但为了加 快这个流程，WPAS可以单独扫描目标无线网络（因为WPAS还是保存了目标无线网络的信息，例如 频道等），然后再发起认证操作。从笔者角度来看，该场景对应的问题是wlan driver没有目标 BSS信息，而WPAS有目标BSS信息。WPAS和wlan driver是两个不同模块，二者的信息并不能 总是保持一致。既然WPAS有目标BSS信息，那么可以通过更加快捷的方法让wlan driver也得 到这个信息（通过在指定频道到扫描目标BSS），从而加快整个流程（从WPAS角度来看，用户加入无 线网络的流程已经进行到Authentication阶段，此时再退回到重新扫描的阶段实在有些麻烦）。 关于scan_for_auth的官方解释，请通过前面介绍的git blame命令获取commit message， 方法是先通过"git blame ./src/drivers/driver_nl80211.c | grep scan_for_auth" 获得和scan_for_auth相关的commit号，然后再用git log commit号查看。 git blame的用法请参考4.2.4节。 */ if (drv->scan_for_auth) {......} os_memset(&event, 0, sizeof(event)); info = &event.scan_info; info->aborted = aborted; if (tb[NL80211_ATTR_SCAN_SSIDS]) {// 遍历NL80211_ATTR_SCAN_SSIDS属性 nla_for_each_nested(nl, tb[NL80211_ATTR_SCAN_SSIDS], rem) { struct wpa_driver_scan_ssid *s = &info->ssids[info->num_ssids]; s->ssid = nla_data(nl); s->ssid_len = nla_len(nl); info->num_ssids++; if (info->num_ssids == WPAS_MAX_SCAN_SSIDS) break; } } if (tb[NL80211_ATTR_SCAN_FREQUENCIES]) {// 获取netlink消息中的频率信息 nla_for_each_nested(nl, tb[NL80211_ATTR_SCAN_FREQUENCIES], rem) { freqs[num_freqs] = nla_get_u32(nl); num_freqs++; if (num_freqs == MAX_REPORT_FREQS - 1) break; } info->freqs = freqs; info->num_freqs = num_freqs; } // wpa_supplicant_event被driver event模块用来发送driver事件给WPAS wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, &event); } ~~~ 上述代码中请注意struct scan_info的作用，它定义于联合体wpa_event_data中，包含了本次扫描请求扫描了哪些SSID、对应的频率等。 >[info] 提示　scan_info不是scan后得到的结果信息，而是代表驱动处理scan请求时的一些处理信息。对于那些不支持通知scan complete事件的driver而言，scan_info就没法获得。例如，超时扫描处理wpa_driver_nl80211_scan_timeout中调用wpa_supplicant_event时就没有scan_info。 scan_info到底有什么作用呢？后文将详细介绍它。 wpa_supplicant_event是driver wrapper向WPAS通知driver event的接口函数，其代码如下所示。 **events.c：：wpa_supplicant_event** ~~~ void wpa_supplicant_event(void *ctx, enum wpa_event_type event, union wpa_event_data *data) { struct wpa_supplicant *wpa_s = ctx; u16 reason_code = 0; int locally_generated = 0; ...... switch (event) { ......// driver event总类非常多，现在只分析EVENT_SCAN_RESULT即可 case EVENT_SCAN_RESULTS: wpa_supplicant_event_scan_results(wpa_s, data); break; ...... } } ~~~ 代码很简单，下面直接来分析此处的目标函数wpa_supplicant_event_scan_results。 **1、wpa_supplicant_event_scan_results函数分析** 函数代码如下。 **events.c：：wpa_supplicant_event_scan_results** ~~~ static void wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s, union wpa_event_data *data) { const char *rn, *rn2; struct wpa_supplicant *ifs; // 笔者编译的WPAS实际上打开了ANDROID_P2P宏，但本章不讨论P2P相关内容 #ifdef ANDROID_P2P if (_wpa_supplicant_event_scan_results(wpa_s, data, 0) < 0) #else if (_wpa_supplicant_event_scan_results(wpa_s, data) < 0) #endif return; /* get_radio_name函数和4.3.4节"wpa_supplicant_init_iface分析之三"中提到的 /sys/class/net/wlan0/phy80211/name文件内容有关。driver_nl80211实现了这个函数， 它将返回上面这个文件的内容。 */ if (!wpa_s->driver->get_radio_name) return; /* 下面这段代码的作用主要是看虚拟接口设备（参考4.3.4节中对Virtual Interface的介绍） 是不是使用了同一个物理设备。如果使用了同一个物理设备，则这个虚拟设备获得的扫描结果可以 和其他虚拟设备共享（避免重复扫描）。本章不对其中细节进行介绍。 */ rn = wpa_s->driver->get_radio_name(wpa_s->drv_priv); /* global指向wpa_global对象，ifaces是wpa_global的成员变量，指向一个wpa_supplicant 对象的队列，可参考图4-7和图4-11。在WPAS中，每一个wpa_supplicant对象会和一个虚拟接口 设备关联。 */ for (if s = wpa_s->global->ifaces; ifs; ifs = ifs->next) { if (ifs == wpa_s || !ifs->driver->get_radio_name) continue; rn2 = ifs->driver->get_radio_name(ifs->drv_priv); if (rn2 && os_strcmp(rn, rn2) == 0) {// 比较两个虚拟设备对应的物理设备是否为同一个 #ifdef ANDROID_P2P ...... #else // 和其他虚拟设备分享扫描结果 _wpa_supplicant_event_scan_results(ifs, data); #endif } } } ~~~ 上述代码中，_wpa_supplicant_event_scan_results是核心处理函数并且内容较多，所以下面将分段研究它。 **2、_wpa_supplicant_event_scan_results分析之一** 先来看第一个代码段，代码如下所示。 **events.c：：_wpa_supplicant_event_scan_results代码段一** ~~~ #ifdef ANDROID_P2P static int _wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s, union wpa_event_data *data, int suppress_event) #else static int _wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s, union wpa_event_data *data) #endif { struct wpa_bss *selected; struct wpa_ssid *ssid = NULL; struct wpa_scan_results *scan_res;// 这才是真正的扫描结果 int ap = 0; ...... wpa_supplicant_notify_scanning(wpa_s, 0); ......// 和P2P相关，本章不讨论 // 获得无线网络扫描结果。就本例而言，前面得到的scan_info信息将传递到下面这个函数 scan_res = wpa_supplicant_get_scan_results(wpa_s,data ? &data->scan_info : NULL, 1); if (scan_res == NULL) {......// 扫描结果为空，重新发起扫描} #ifndef CONFIG_NO_RANDOM_POOL /* 把扫描结果中得到的无线网络频率、信号强度等信息取出来，然后写到图4-1中的crpto模块。 这样，能增加随机数生成的随机性。WPAS中nonce的生成都会利用随机数生成器。感兴趣的读者 不妨自行研究相关内容。 */ ...... #endif /* CONFIG_NO_RANDOM_POOL */ ~~~ wpa_supplicant_get_scan_results比较重要，我们通过代码来介绍它。 **scan.c：：wpa_supplicant_get_scan_results** ~~~ struct wpa_scan_results * wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s, struct scan_info *info, int new_scan) { struct wpa_scan_results *scan_res; size_t i; int (*compar)(const void *, const void *) = wpa_scan_result_compar; /* 调用driver interface的get_scan_results2函数，对nl80211来说，其真实函数是wpa_driver_ nl80211_get_scan_results，它将向wlan driver发送NL80211_CMD_GET_SCAN命令以获取 扫描结果。另外，wpa_driver_nl80211_get_scan_results中还涉及一个比较有意思的函数 wpa_driver_nl80211_check_bss_status。其作用请读者利用前面介绍的git blame方法来查询。 */ scan_res = wpa_drv_get_scan_results2(wpa_s); if (scan_res == NULL) {return NULL;} // #ifdef CONFIG_WPS ......// WPS相关 #endif /* CONFIG_WPS */ /* 对扫描结果进行排序，排序函数是wpa_scan_result_compar,它将根据无线网络的信噪比（SNR） 进行排序信噪比越高，无线网络信号越强。注意，除了SNR外，wpa_scan_result_compar还有别 的比较条件，感兴趣的读者可行阅读该函数。 */ qsort(scan_res->res, scan_res->num, sizeof(struct wpa_scan_res *),compar); ...... /* 更新WPAS中保存的那些bss信息（即无线网络信息，每一个无线网络由wpa_bss表示）。我们在4.3.4节中 曾经介绍过和wpa_bss相关的知识。WPAS维护了一个wpa_bss链表，每次扫描时都可能更新这个链表 （添加新扫描得到的wpa_bss、删除某些老旧的wpa_bss）。 */ wpa_bss_update_start(wpa_s); for (i = 0; i < scan_res->num; i++) wpa_bss_update_scan_res(wpa_s, scan_res->res[i]); /* 这里用上了scan_info。那些没有包含在本次scan_info中的wpa_bss不用更新。结合4.5.3节 “wpa_supplicant_scan分析之二”中提到的prev_scan_ssid的作用，能想到为什么不更新那些 没有包含在scan_info中的wpa_bss吗？ */ wpa_bss_update_end(wpa_s, info, new_scan); return scan_res; } ~~~ :-:  图4-32　wpa_scan_res相关数据结构 **3、_wpa_supplicant_event_scan_results分析之二** 接着来看_wpa_supplicant_event_scan_results下一个代码片段。 **events.c：：_wpa_supplicant_event_scan_results代码段二** ~~~ ......// 接_wpa_supplicant_event_scan_results代码片段一 /* 如果wpa_supplicant对扫描结果有特殊处理，则调用scan_res_handler对应的函数处理。 目前只有P2P情况下scan_res_handler才起作用。 */ if (wpa_s->scan_res_handler) { ......return 0;} ......// hostapd的情况，本书不讨论 #ifdef ANDROID_P2P if(!suppress_event) #endif { ......// 通知客户端，扫描结束 } wpas_notify_scan_done(wpa_s, 1); if ((wpa_s->conf->ap_scan == 2 && !wpas_wps_searching(wpa_s))) {} if (wpa_s->disconnected) {......} /* 还记得4.5.3节“wpa_supplicant_scan分析之一”中的ap_scan变量吗？下面这个 wpas_driver_bss_selection函数判断是否由driver来控制无线网络的选择。显然， 本例中它将返回0值。不过，由于本例不支持bgscan（由CONFIG_BGSCAN宏控制）， bgscan_notify_scan返回0。 这样，下面这个if判断失败。 */ if (!wpas_driver_bss_selection(wpa_s)&&bgscan_notify_scan(wpa_s, scan_res) == 1) { wpa_scan_results_free(scan_res); return 0; } // 从扫描结果中选择一个合适的无线网络 // 注意，在本例中，下面这个函数将返回目标无线网络对应的wpa_bss对象 selected = wpa_supplicant_pick_network(wpa_s, scan_res, &ssid); } ~~~ 上面这段代码相对简单。注意最后一句代码中调用的wpa_supplicant_pick_network函数。它将根据scan_res（扫描结果）、wpa_bss（代表一个真实BSS的信息）和wpa_ssid（代表用户设置的某个无线网络配置项）的匹配情况来选择合适的无线网络。匹配检查包含很多内容，例如ssid是否匹配、安全设置是否匹配、速率是否匹配等。最终，该函数返回一个被选中的目标无 线网络的wpa_bss对象。 >[info] 提示　wpa_supplicant_pick_network函数实际上检查的项非常多。由于篇幅问题，本章不能一 一道来，感兴趣的读者请仔细研究。 **4、_wpa_supplicant_event_scan_results分析之三** 接着来看_wpa_supplicant_event_scan_results的第三段代码。 **events.c：：_wpa_supplicant_event_scan_results代码段三** ~~~ ......// 接代码段二 if (selected) { // 本例中返回的selected无线网络wpa_bss对象代表目标"Test"无线网络 int skip; /* 判断是否需要漫游。简单来说，漫游表示需要切换无线网络。对本例而言，由于之前没有和AP关联， 所以此处是需要漫游的（即需要切换无线网络）。 wpa_supplicant_need_to_roam中还包括对同一个ESS中如何选择更合适的BSS有一些 简单的判断，主要是根据信号强度来选择。 */ skip = !wpa_supplicant_need_to_roam(wpa_s, selected, ssid,scan_res); wpa_scan_results_free(scan_res); if (skip) {// 无须切换网络，所以没有太多要做的工作 wpa_supplicant_rsn_preauth_scan_results(wpa_s); return 0; } // 关联至目标无线网络。我们下一节再分析它 if (wpa_supplicant_connect(wpa_s, selected, ssid) < 0) {......} // 预认证（Pre-Authentication）处理，和802.11中的Fast Transition有关，本书不讨论 wpa_supplicant_rsn_preauth_scan_results(wpa_s); } else { ......// 没有匹配的无线网络情况的处理 } return 0; } ~~~ 到此为止，扫描结果的处理基本完毕，剩下的工作就是通过wpa_supplicant_connect向目标AP发起关联等请求以加入"Test"无线网络。 在介绍wpa_supplicant_connect之前，先总结一下扫描结果处理流程。 **5、扫描结果处理流程总结** 扫描结果的处理流程相对比较复杂，如图4-33所示。其中有几个函数包含一些非常重要的细节，读者在研究过程中要特别注意。 * wpa_supplicant_pick_nework：在扫描结果中找到一个最佳的无线网络。 * wpa_supplicant_need_to_roam：判断是否需要切换网络。 * wpa_supplicant_rsn_preauth_scan_results：更新PMKSA缓存信息。其工作和Pre-Authentication有关。不过Pre-Authenticaton真正的实现也需要AP的支持。 :-:  图4-33　扫描处理流程 图4-34所示为笔者通过AirPcap截获的目标AP发送的Probe Response帧。 :-:  图4-34　Probe Response帧内容 请读者注意图4-34中所示的RSN信息，它描述了AP所支持的RSN功能。下节介绍WPAS如何关联到目标无线网络时将用到它。 #### **三、关联无线网络处理流程分析** 关联无线网络处理的流程从wpa_supplicant_connect开始，其代码如下所示。 **events.c：：wpa_supplicant_connect** ~~~ int wpa_supplicant_connect(struct wpa_supplicant *wpa_s,struct wpa_bss *selected, struct wpa_ssid *ssid) { // WPS相关，本章不讨论 if (wpas_wps_scan_pbc_overlap(wpa_s, selected, ssid)) {......} /* 4.5.3节介绍的wpa_supplicant_enable_network函数中，reassociate值被设置为1。 当WPAS处于ASSOCIATING状态时，wpa_s->pending_bssid用于存储目标网络的BSSID。 */ if (wpa_s->reassociate || (os_memcmp(selected->bssid, wpa_s->bssid, ETH_ALEN) != 0 && ((wpa_s->wpa_state != WPA_ASSOCIATING && wpa_s->wpa_state != WPA_AUTHENTICATING) || os_memcmp(selected->bssid, wpa_s->pending_bssid, ETH_ALEN) != 0))) { // 和EAP-SIM/AKA认证方法有关。在此处初始化相关资源。本章不讨论 if (wpa_supplicant_scard_init(wpa_s, ssid)) { wpa_supplicant_req_new_scan(wpa_s, 10, 0); return 0; } wpa_supplicant_associate(wpa_s, selected, ssid);// 发起关联操作 } else {......} return 0; } ~~~ 就本例而言，wpa_supplicant_connect最重要的工作就是触发STA发起关联操作。关联操作通过wpa_supplicant_associate函数来完成。这部分代码比较复杂，我们分段来看。 **1、wpa_supplicant_associate分析之一** 和发起无线扫描请求一样，wpa_supplicant_associate函数主要目的就是填充一个用于向wlan driver发起关联请求的struct wpa_driver_associate_params类型的对象，然后调用driverinterface对应的接口函数。由于关联时考虑的因素非常多，所以对应的处理也比较烦琐。本节先介绍第一段内容。 **wpa_supplicant.c：：wpa_supplicant_associate代码段一** ~~~ void wpa_supplicant_associate(struct wpa_supplicant *wpa_s, struct wpa_bss *bss, struct wpa_ssid *ssid) { u8 wpa_ie[200]; size_t wpa_ie_len; int use_crypt, ret, i, bssid_changed; int algs = WPA_AUTH_ALG_OPEN; // 认证方法 enum wpa_cipher cipher_pairwise, cipher_group;// 单播数据和组播数据加密方法 struct wpa_driver_associate_params params; // 此函数主要目的是正确填充params的内容 int wep_keys_set = 0; struct wpa_driver_capa capa; int assoc_failed = 0; struct wpa_ssid *old_ssid; #ifdef CONFIG_HT_OVERRIDES ......// 802.11n相关的内容 #endif /* CONFIG_HT_OVERRIDES */ #ifdef CONFIG_IBSS_RSN ......// IBSS相关内容 #endif /* CONFIG_IBSS_RSN */ #ifdef ANDROID_P2P int freq = 0; #endif if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO || ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) { ...... return; } #ifdef CONFIG_TDLS ......// TDLS是WFA定义的另外一项规范。本书不讨论 #endif /* CONFIG_TDLS */ /* 我们曾在4.3.3节功能相关成员变量及背景知识中曾介绍过CONFIG_SME相关的信息。 Galaxy Note 2不支持WPA_DRIVER_FLAGS_SME参数。 */ if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && ssid->mode == IEEE80211_MODE_INFRA) { sme_authenticate(wpa_s, bss, ssid); return; } os_memset(¶ms, 0, sizeof(params)); wpa_s->reassociate = 0; // wpas_driver_bss_selection于判断是否由wlan driver来完成无线网络选择，本例它返回FALSE if (bss && !wpas_driver_bss_selection(wpa_s)) { #ifdef CONFIG_IEEE80211R ......// 802.11R相关 #endif /* CONFIG_IEEE80211R */ bssid_changed = !is_zero_ether_addr(wpa_s->bssid); os_memset(wpa_s->bssid, 0, ETH_ALEN);// 设置wpa_supplicant bssid数组成员值为全0 // 将BSSID复制到wpas->pending_bssid中 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN); if (bssid_changed) wpas_notify_bssid_changed(wpa_s); #ifdef CONFIG_IEEE80211R ......// 和802.11R有关 #endif /* CONFIG_IEEE80211R */ #ifdef CONFIG_WPS } else if (......WPS相关) { ...... #endif /* CONFIG_WPS */ } else os_memset(wpa_s->pending_bssid, 0, ETH_ALEN); // 取消计划扫描和普通扫描任务 wpa_supplicant_cancel_sched_scan(wpa_s); wpa_supplicant_cancel_scan(wpa_s); /* 清空上一次association时使用的WPA/RSN IE信息，这些信息保存在wpa_supplicant 对象的assoc_wpa_ie（类型为u8*）对应的buffer中。 */ wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0); } ~~~ 如果不考虑各种编译宏选项（对WPS、802.11R支持），上述代码段还算比较简单。 **2、wpa_supplicant_associate分析之二** 接着来看代码段二。 **wpa_supplicant.c：：wpa_supplicant_associate代码段二** ~~~ ......// 接代码段一 #ifdef IEEE8021X_EAPOL // 本例中，为目标无线网络配置的key_mgmt为SET_NETWORK 0 key_mgmt WPA-PSK // 通过"SET_NETWORK 0 key_mgmt WPA-PSK"命令来完成 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) { ......// 处理key_mgmt为非WPA的情况} #endif /* IEEE8021X_EAPOL */ /* auth_alg为认证方法，可取值有WPA_AUTH_ALG_OPEN、WPA_AUTH_ALG_SHARED等。根据第3章 对WPA的介绍，如果要使用WPA的话，在和AP关联时必须使用Open System（即WPA_AUTH_ALG_OPEN）。 如果没有设置该值，其值默认为0。 */ if (ssid->auth_alg) {......} /* 下面这个if判断很重要，请读者注意。 wpa_bss_get_vendor_ie函数用于获取wpa_bss中的和vendor相关的IE，此处IE对应的标志是 WPA_IE_VENDOR_TYPE（该值被定义为：#define WPA_IE_VENDOR_TYPE 0x0050f201）。 读者可参考图4-34中Probe Response帧中最后一个IE项（Microsoft：WPA IE, 因为MS的OUI是00-50-f2）。注意：该OUI也供WFA定义的几种规范使用。 wpa_bss_get_ie(bss, WLAN_EID_RSN)) 用于获取RSN IE。图4-34中也包含RSN IE。 wpa_key_mgmt_wpa(ssid->key_mgmt)用于判断无线网络配置时设置的key_mgmt是否 和WPA相关（本例中，key_mgmt被设为WPA-PSK，它属于WPA的一种）。 简而言之，下面这个if条件就是判断目标无线网络是否支持WPA/RSN功能，并且无线网络配置项 是否也设置key_mgmt与WPA相关。很显然，本例满足下面这个if条件。 */ if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) || wpa_bss_get_ie(bss, WLAN_EID_RSN)) && wpa_key_mgmt_wpa(ssid->key_mgmt)) { int try_opportunistic; /* ssid->proto默认值为DEFAULT_PROTO，它由4.5.1节中ADD_NETWORK命令处理的 wpa_config_set_network_defaults函数完成。proactive_key_caching默认值为0。 */ try_opportunistic = ssid->proactive_key_caching && (ssid->proto & WPA_PROTO_RSN); /* 下面这个函数用于从pmksa缓存中取出current_ssid对应的pmkid cache项（类型为rsn_ pmksa_cache）,然后将其赋值给wpa_sm中的cur_pmksa变量中。此时我们还没有pmksa 缓存信息，故if条件失败。 */ if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,wpa_s->current_ssid, try_opportunistic) == 0){ // 设置eapol_sm的cached_pmk为1（由该函数第二个参数决定），表示要使用pmksa eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1); } wpa_ie_len = sizeof(wpa_ie); /* wpa_supplicant_set_suites函数比较繁琐，其目的是生成一个用于关联请求的IE信息。 这些信息包括：group_cipher、pairwise_cipher、key_mgmt。信息的选择需要考虑AP的情况， 即图4-34中AP包含的RSN和WPA IE。最终的选择如下： proto=WPA_PROTO_RSN、group_cipher=pairwise_cipher=WPA_CIPHER_CCMP key_mgmt=WPA_KEY_MGMT_PSK 感兴趣的读者不妨自行阅读wpa_supplicant_set_suites。 */ if (wpa_supplicant_set_suites(wpa_s, bss, ssid,wpa_ie, &wpa_ie_len)) {......} } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) { ...... #ifdef CONFIG_WPS .......// WPS处理 #endif /* CONFIG_WPS */ } else {......} ......// P2P和interworking相关的处理 // 清除wlan driver中的key设置 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL); use_crypt = 1; /* 将WPAS中定义的数据类型转换成driver wrapper使用的数据类型。例如，WPAS使用WPA_CIPHER_CCMP， 而driver wrapper对应的值为CIPHER_CCMP。 */ cipher_pairwise = cipher_suite2driver(wpa_s->pairwise_cipher); cipher_group = cipher_suite2driver(wpa_s->group_cipher); if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {......} if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) use_crypt = 0; #ifdef IEEE8021X_EAPOL if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { ......// 选择单播和组播数据加密方法} #endif /* IEEE8021X_EAPOL */ if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {......} // 设置wpa_sm的状态为WPA_ASSOCIATING wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING); } } ~~~ 这段代码主要是根据AP的情况选择合适的加密方法及认证方法。虽然目的很简单，但判断条件以及相关函数却比较烦琐，而且还有相当一部分代码是针对P2P、WPS等不同情况的处理。建议读者先了解其目的，以后根据工作需要再来研读其中的细节。 **3、wpa_supplicant_associate分析之三** 下面来看wpa_supplicant_associate最后一段代码。 **wpa_supplicant.c：：wpa_supplicant_associate代码段三** ~~~ ......// 接代码段二 if (bss) { // 填充struct wpa_driver_associate_params中的信息 params.ssid = bss->ssid; params.ssid_len = bss->ssid_len; if (!wpas_driver_bss_selection(wpa_s)) { params.bssid = bss->bssid; params.freq = bss->freq; } }......// 其他处理 // 填充参数 params.wpa_ie = wpa_ie; params.wpa_ie_len = wpa_ie_len; params.pairwise_suite = cipher_pairwise; params.group_suite = cipher_group; params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt); params.wpa_proto = wpa_s->wpa_proto;params.auth_alg = algs; params.mode = ssid->mode; for (i = 0; i < NUM_WEP_KEYS; i++) {......// 设置wep key相关信息} params.wep_tx_keyidx = ssid->wep_tx_keyidx; ...... /* 设置wlan driver是否丢弃未加密数据包。注意，在通过RSN身份验证前，EAPOL 4-Way Handshake等 EAPOL数据是没有加密的，所以这个变量只针对非EAPOL/EAP数据包。本例中use_crpyt为1。 */ params.drop_unencrypted = use_crypt; #ifdef CONFIG_IEEE80211W ......// 802.11w相关 #endif /* CONFIG_IEEE80211W */ params.p2p = ssid->p2p_group; /* uapsd为Unscheduled Automatic Power Save Delivery的缩写，也称为WMM power save, 属于WFA定义的一种标准，和节电有关。 */ if (wpa_s->parent->set_sta_uapsd) params.uapsd = wpa_s->parent->sta_uapsd; else params.uapsd = -1; #ifdef ANDROID_P2P ......// P2P相关 #endif // 调用driver interface的associate函数以发起关联请求。该函数非常重要，下一节介绍 ret = wpa_drv_associate(wpa_s, ¶ms); if (ret < 0) {......// 错误处理} if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {......// 其他处理 #ifdef CONFIG_IBSS_RSN } else if (......) {......// IBSS相关 #endif /* CONFIG_IBSS_RSN */ } else { int timeout = 60;// 设置一个超时时间，身份认证必须在60秒内完成 if (assoc_failed) timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5; else if (wpa_s->conf->ap_scan == 1) // 对本例而言，timeout最终取值为10秒 timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10; // 设置一个超时任务：对应函数为wpa_supplicant_timeout，用于处理身份认证超时的情况 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0); } ...... if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) eapol_sm_invalidate_cached_session(wpa_s->eapol);// 设置上一次eapol session无效 old_ssid = wpa_s->current_ssid; wpa_s->current_ssid = ssid;// 设置wpa_supplicant对象的current_ssid和current_bss变量 wpa_s->current_bss = bss; // 下面这个函数实际上是将加密/身份验证信息设置到wpa_sm对应的变量中去 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid); // 配置eapol sm和eap sm。其中：portControl被置为AUTO // eapSuccess=altAccept=eapFail=altReject=FALSE。这个过程没有状态发生变化 wpa_supplicant_initiate_eapol(wpa_s); if (old_ssid != wpa_s->current_ssid) wpas_notify_network_changed(wpa_s); } ~~~ 至此，wpa_supplicant_associate函数就分析完毕。读者如果还记得第3章关于STA加入AP的步骤的话，可能会有一些疑惑。STA加入AP的顺序是先发送Authentication请求，然后再发送Association请求。但此处仅调用了wpa_drv_associate函数，似乎忽略了Authentication这一步。该问题的回答将放在下一节，直接来看driver nl80211对应的wpa_driver_nl80211_associate函数。 **4、wpa_driver_nl80211_associate函数分析** 代码如下所示。 **driver_nl80211.c：：wpa_driver_nl80211_associate** ~~~ static int wpa_driver_nl80211_associate(void *priv, struct wpa_driver_associate_params *params) { struct i802_bss *bss = priv; struct wpa_driver_nl80211_data *drv = bss->drv; int ret = -1; struct nl_msg *msg; // 处理AP和IBSS的情况 if (params->mode == IEEE80211_MODE_AP) return wpa_driver_nl80211_ap(drv, params); if (params->mode == IEEE80211_MODE_IBSS) return wpa_driver_nl80211_ibss(drv, params); // 目前大部分手机不支持WPA_DRIVER_FLAGS_SME if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) { enum nl80211_iftype nlmode = params->p2p ? // 本例对应的是非p2p情况 NL80211_IFTYPE_P2P_CLIENT : NL80211_IFTYPE_STATION; // 设置设备类型，可参考4.3.4节wpa_driver_nl80211_finish_drv_init函数分析 if (wpa_driver_nl80211_set_mode(priv, nlmode) < 0) return -1; return wpa_driver_nl80211_connect(drv, params); } /* 注意：根据第3章对STA加入AP操作的描述，STA需要首先发送authentication请求，然后再发送 association请求。在“wpa_supplicant_associate分析之一”中，有一个sme_authenticate 函数，它将发起authentication请求。对于不支持SME的wlan driver来说，WPAS只要向wlan driver 发送connect命令即可完成association和authentication这两步。这种实现方式和wlan driver 以及cfg80211有关。本书不拟对此展开详细讨论。读者可在wpa_supplicant官方源码中利用 "git log a8c5b43a"命令查看相关信息。 */ ......// 对于支持SME的wlan driver，则需要发送NL80211_CMD_ASSOCIATE命令 } ~~~ 来看wpa_driver_nl80211_connect函数，其代码如下所示。 **driver_nl80211.c：：wpa_driver_nl80211_connect** ~~~ static int wpa_driver_nl80211_connect(struct wpa_driver_nl80211_data *drv, struct wpa_driver_associate_params *params) { struct nl_msg *msg; enum nl80211_auth_type type; int ret = 0; int algs; msg = nlmsg_alloc(); nl80211_cmd(drv, msg, 0, NL80211_CMD_CONNECT);// 构造一个NL80211_CMD_CONNECT命令 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);// 设置本次命令对应的网络接口 // 设备索引号填充bssid信息 if (params->bssid) NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid); if (params->freq) {......// 填充频率信息} if (params->ssid) {// 填充ssid信息 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,params->ssid); os_memcpy(drv->ssid, params->ssid, params->ssid_len);// 将ssid信息保存起来 drv->ssid_len = params->ssid_len; } ...... if (params->pairwise_suite != CIPHER_NONE) { ......// 处理pairwise_cipher取值情况 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITES_PAIRWISE, cipher); } ......// 其他各项参数处理 // 向wlan driver发送NL80211_CMD_CONNECT命令 ret = send_and_recv_msgs(drv, msg, NULL, NULL); msg = NULL; if (ret) {......// 错误处理} ret = 0; ...... return ret; } } ~~~ 至此，WPAS就把CONNECT请求发给了驱动，驱动将完成Authentication帧和Association Request帧的处理。和scan请求类似，关联无线网络处理流程主要是为了填充一个wpa_driver_associate_params类型的对象。不过该对象中各个参数的设置颇有来头，需要对802.11规范有相当了解才可以做到正确无误。 **5、关联无线网络处理流程总结** 来看一下关联无线网络处理流程所涉及的几个重要函数调用，如图4-35所示。 :-:  图4-35　wpa_supplicant_connect流程 图4-35中最复杂的就是wpa_supplicant_associate函数，希望读者能结合代码进行阅读。 WPAS成功调用wpa_supplicant_associate后，将等待NL80211_CMD_CONNECT命令的处理结果。该结果由wlan driver通过NL80211_CMD_CONNECT类型的消息返回给driver wrapper。 下面一节将分析WPAS如何处理该消息。 #### **四、关联事件处理流程分析** 结合上节所述内容，WPAS中的driver wrapper将收到来自wlan driver的NL80211_CMD_CONNECT命令，其对应的处理代码如下所示。 **driver_nl80211.c：：do_process_drv_event** ~~~ static void do_process_drv_event(struct wpa_driver_nl80211_data *drv, int cmd, struct nlattr **tb) { // 曾在4.5.3节“扫描结果处理流程分析”中见过该函数处理NL80211_CMD_NEW_SCAN_RESULTS ...... switch (cmd) { ...... case NL80211_CMD_CONNECT:// wlan driver返回该命令的处理结果 case NL80211_CMD_ROAM: /* 调用mlme_event_connect进行处理，其中NL80211_ATTR_STATUS_CODE属性保存了AP的处理结果 （即Association请求的处理结果）、NL80211_ATTR_MAC属性保存了AP的MAC地址（就是bssid）、 NL80211_ATTR_REQ_IE属性保存了Association Request请求时包含的IE（STA发送的IE）、 NL80211_ATTR_RESP_IE属性保存了Association Response帧包含的IE信息（AP发送的IE）。 */ mlme_event_connect(drv, cmd, tb[NL80211_ATTR_STATUS_CODE], tb[NL80211_ATTR_MAC], tb[NL80211_ATTR_REQ_IE], tb[NL80211_ATTR_RESP_IE]); ...... } } ~~~ 当wlan driver返回NL80211_CMD_CONNECT命令时，其真正的处理函数实际上是mlme_event_connect，此函数代码如下所示。 **driver_nl80211.c：：mlme_event_connect** ~~~ static void mlme_event_connect(struct wpa_driver_nl80211_data *drv, enum nl80211_commands cmd, struct nlattr *status, struct nlattr *addr, struct nlattr *req_ie,struct nlattr *resp_ie) { /* driver wrapper通知WPAS其他模块时候使用的事件类型。我们曾在4.5.3节“扫描结果处理流程分析” 中对send_scan_event函数分析时见过。 */ union wpa_event_data event; if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {......// wlan driver支持SME时的处理} os_memset(&event, 0, sizeof(event)); if (cmd == NL80211_CMD_CONNECT && nla_get_u16(status) != WLAN_STATUS_SUCCESS) { ......// 关联AP失败的处理 wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event); return; } drv->associated = 1; if (addr)// 保存bssid os_memcpy(drv->bssid, nla_data(addr), ETH_ALEN);// 保存bssid信息 if (req_ie) {// 保存Association Request ie信息 event.assoc_info.req_ies = nla_data(req_ie); event.assoc_info.req_ies_len = nla_len(req_ie); } if (resp_ie) {// 保存Association Response ie信息 event.assoc_info.resp_ies = nla_data(resp_ie); event.assoc_info.resp_ies_len = nla_len(resp_ie); } // 通过发送NL80211_GET_SCAN命令获取STA的工作频率 event.assoc_info.freq = nl80211_get_assoc_freq(drv); // 重要函数，见下文分析 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event); } ~~~ wpa_supplicant_event中处理EVENT_ASSOC消息的是wpa_supplicant_event_assoc，下面将分段介绍它。 **1、wpa_supplicant_event_assoc分析之一** 代码如下所示。 **events.c：：wpa_supplicant_event_assoc代码段一** ~~~ static void wpa_supplicant_event_assoc(struct wpa_supplicant *wpa_s, union wpa_event_data *data) { u8 bssid[ETH_ALEN]; int ft_completed; int bssid_changed; struct wpa_driver_capa capa; ......// CONFIG_AP处理 // 判断Fast Transition是否完成，由于本例没有设置CONFIG_80211R宏，所以下面这个函数返回0 ft_completed = wpa_ft_is_completed(wpa_s->wpa); /* 在4.5.3节“wpa_supplicant_associate分析之一”中，wpa_supplicant对象的assoc_wpa_ie 被清空。此处需要保存这些IE信息。wpa_supplicant_event_associnfo比较烦琐，主要是更新RSN/WPA IE信息，请感兴趣的读者自行阅读。 */ if (data && wpa_supplicant_event_associnfo(wpa_s, data) < 0) return; wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);// 设置wpa_sm装为WPA_ASSOCIATED // 从driver wrapper中获得bssid信息 if (wpa_drv_get_bssid(wpa_s,bssid)>=0&&os_memcmp(bssid,wpa_s->bssid,ETH_ALEN)!=0){ random_add_randomness(bssid, ETH_ALEN); // 和随机数相关 bssid_changed = os_memcmp(wpa_s->bssid, bssid, ETH_ALEN); os_memcpy(wpa_s->bssid, bssid, ETH_ALEN); // 设置bssid os_memset(wpa_s->pending_bssid, 0, ETH_ALEN); // 清空pending_bssid if (bssid_changed) wpas_notify_bssid_changed(wpa_s); // 和动态WEP Key有关，本书不讨论 if (wpa_supplicant_dynamic_keys(wpa_s)&&!ft_completed)wpa_clear_keys(wpa_s, bssid); /* 就本例而言（ap_scan为1，并且current_ssid不为空），下面这个函数作用不大。对其他情况而言， 该函数负责的工作我们在前面都见识过了。 */ if (wpa_supplicant_select_config(wpa_s) < 0) {......// 错误处理} /* 这个if条件对应的代码段让笔者非常困惑，因为在4.5.3节“wpa_supplicant_associate 分析之三”的最后已经为wpa_s->current_bss赋值了。此处为何又再赋值？通过笔者实测，bss 和current_bss的值是相同的。添加这段代码的人也没有说明为什么（读者不妨参考“git show 8f770587”命令的结果）。有知晓其来龙去脉的读者不妨和大家分享相关知识。 */ if (wpa_s->current_ssid) { struct wpa_bss *bss = NULL; bss = wpa_supplicant_get_new_bss(wpa_s, bssid); if (!bss) { wpa_supplicant_update_scan_results(wpa_s); bss = wpa_supplicant_get_new_bss(wpa_s, bssid); } if (bss) wpa_s->current_bss = bss; } if (wpa_s->conf->ap_scan==1&&wpa_s->drv_flags&WPA_DRIVER_FLAGS_BSS_SELECTION){ ......// wlan driver支持BSS SELECTION功能时对应的处理 } } ~~~ wpa_supplicant_event_assoc函数的历史比较悠久（根据git commit信息，它从0.6.3版本开始就存在。而实际历史可能还要更久，因为WPAS从0.6.3版本后才开始使用git来管理代码）。在笔者研究的WPAS相关代码中，wpa_supplicant_event_assoc函数算是相当复杂的了。其中一个主要原因是该函数内部有很多细节需要考虑，有些细节甚至是为了解决某个bug。对于初学者而言，笔者建议可只关注该函数涉及的主要流程。 **2、wpa_supplicant_event_assoc分析之二** 接下来分析该函数最后一段代码。 **events.c：：wpa_supplicant_event_assoc代码段二** ~~~ ......// 接代码段一 #ifdef CONFIG_SME ......// 支持SME的情况 #endif /* CONFIG_SME */ if (wpa_s->current_ssid) { /* 初始化SIM/USIM卡。根据代码中的注释：在ap_scan为1的情况下，该函数在此之前就被调用过。 而其他情况下，需要在此处调用它。在4.5.3节关联无线网络处理流程分析中见过此函数。 */ wpa_supplicant_scard_init(wpa_s, wpa_s->current_ssid); } wpa_sm_notify_assoc(wpa_s->wpa, bssid); // 初始化wpa_sm中和后续EAPOL-Key交换相关联的变量 /* wpa_s->l2在4.3.4节wpa_supplicant_driver_init函数分析中通过l2_packet_init函数调用被赋值。 所以下面这个if条件为真。对Linux平台来说，l2_packet_notify_auth_start 实际上是一个空函数。 */ if (wpa_s->l2) l2_packet_notify_auth_start(wpa_s->l2); if (!ft_completed) {// 设置EAPOL相关外部变量 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE); eapol_sm_notify_portValid(wpa_s->eapol, FALSE); } // 本例采用的就是WPA-PSK认证算法 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || ft_completed) eapol_sm_notify_eap_success(wpa_s->eapol, FALSE); // 设置EAPOL模块中的portEnabled为TRUE，将状态机一系列动作。详情见下文 eapol_sm_notify_portEnabled(wpa_s->eapol, TRUE); wpa_s->eapol_received = 0; if (......){......} } else if (!ft_completed) { wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);// 重新注册一个认证超时任务 } wpa_supplicant_cancel_scan(wpa_s);// 取消scan任务 ......// 处理wlan driver支持WPA_DRIVER_FLAGS_4WAY_HANDSHAKE功能以及ft_complete为1时的情况 if (wpa_s->pending_eapol_rx) { /* pending_eapol_rx变量对应如下的应用场景。 有时候在WPAS收到来自wlan driver的EVENT_ASSOC事件之前（即wpa_supplicant_event_ assoc被调用之前），AP就发送EAPOL消息过来（后文会分析相关代码）以触发认证流程。而由于 WPAS还未处理EVENT_ASSOC事件。所以，EAPOL消息会先保存到pending_eapol_rx中，直到 wpa_supplicant_event_assoc函数中再来处理（即收到了EVENT_ASSOC事件）。笔者测试过 程中发现有些AP会出现这种情况。 */ } ......// WEP的情况 ......// IBSS的情况 } ~~~ wpa_supplicant_event_assoc函数终于分析完毕。正如上一节最后所提到的那样，该函数实际上非常复杂，细节内容很难在本章篇幅内一一覆盖。同时，对初学者来说，流程比细节更重要，所以可先略过这些细节。 上述代码中，eapol_sm_notify_portEnabled被调用以设置portEnable为TRUE。EAPOL模块包含众多SM，它们是否会因为这个变量的变化而随之发生状态改变呢？来看下节。 **3、eapol_sm_notify_portEnabled函数** eapol_sm_notify_portEnabled的代码如下所示。 **eapol_supp_sm.c：：eapol_sm_notify_portEnabled** ~~~ void eapol_sm_notify_portEnabled struct eapol_sm *sm, Boolean enabled) { ...... sm->portEnabled= enabled;// 设置portEnabled变量为TRUE eapol_sm_step(sm); // 状态机联动。这部分代码在4.4.2节介绍“状态机联动”时出现过 } ~~~ eapol_sm_step将依次更新SUPP_PAE、KEY_RX、SUPP_BE和EAP_SM状态信息。在该函数 执行之前，这四个状态机的状态依次如下。 * SUPP_PAE为DISCONNECTED状态； * KEY_RX为NO_KEY_RECEIVE状态； * SUPP_BE为IDLE状态； * EAP_SM为DISABLED状态。 根据代码（eapol_supp_sm.c中SM_STEP（SUPP_PAE））以及图4-28可知，SUPP_PAE下一个要进入的状态是CONNECTING，其EA（Entry Aciton）代码如下。 **eapol_supp_sm.c：：SM_STATE（SUPP_PAE，CONNECTING）** ~~~ SM_STATE(SUPP_PAE, CONNECTING) { // SUPP_PAE_state此时的值为SUPP_PAE_DISCONNECTED，故send_start为0 int send_start = sm->SUPP_PAE_state == SUPP_PAE_CONNECTING; SM_ENTRY(SUPP_PAE, CONNECTING); if (send_start) { sm->startWhen = sm->startPeriod; sm->startCount++; } else { #ifdef CONFIG_WPS sm->startWhen = 1; #else /* CONFIG_WPS */ sm->startWhen = 3; // 设置startWhen值为3 #endif /* CONFIG_WPS */ } eapol_enable_timer_tick(sm); // 使能Port Timers SM sm->eapolEap = FALSE; if (send_start) eapol_sm_txStart(sm); // 发送EAPOL Start包。此时该函数不会被调用 } ~~~ 读者可参考代码以及状态机示意图以了解其他状态机的切换。该函数执行完毕后，各个状态机的变化如下。 * SUPP_PAE进入CONNECTING状态； * KEY_RX不变（NO_KEY_RECEIVE）； * SUPP_BE进入IDLE状态； * EAP_SM不变（DISABLED状态）。 >[info] 注意　根据图4-21关于EAP SUPP_SM的描述，当portEnabled值为TRUE时，应该从DISABLED状态切换至INITIALIZE状态。不过，在4.5.3节“wpa_supplicant_associate分析之三”中曾调用过wpa_supplicant_initiate_eapol函数。在该函数中，由于本例使用的认证算法是WPA-PSK，所以force_disabled变量为TRUE，导致EAP SUPP SM不能转换至INITIALIZE状态。（参考eap.c：：SM_STEP（EAP）函数中第一个else if判断。） **4、关联事件处理流程总结** 关联事件处理流程中涉及的重要函数调用如图4-36所示。注意，wpa_supplicant_event_assoc中略去了部分细节代码。请读者清楚图中的几个重要函数后，再根据本节所述内容研究这些细节。 至此，WPAS已经和目标AP完成了Association操作，接来下将进入802.1X身份认证流程。根据图3-44所示，接下来的工作将是4-Way Handshake和Group Key Handshake的处理。 :-:  图4-36　NL80211_CMD_CONNECT处理流程 #### **五、EAPOL-Key交换流程分析** 对本例而言，本节所说的EAPOL-Key交换包括4-Way Handshake和Group Key Handshake过程（注意，由于采用的是PSK认证方式，故本节分析的交互流程将不涉及STA和AuthenticatorServer开展的身份认证的流程）。 首先发起的是4-Way Handshake Key交换。对于WPA-PSK认证方法来说，STA不会发送EAPOL-Start消息给AP。根据笔者的测试，完成关联操作后，Galaxy Note 2会发送一个Null function（没有实际数据）的数据包给AP（如图4-37所示），而AP接收到该消息后发现STA还未通过认证，所以它就会被触发以开始4-Way Handshake流程（参考图3-46的左图）。 :-:  图4-37　Null function数据包 由图4-37可知，Galaxy Note 2向AP发送一个Null function数据包后，AP就开始了4-Way Handshake流程。它首先发送一个EAPOL帧给STA（图4-37中"Message 1 of 4"这一项）。我们在4.3.4节的最后曾提到l2_packet模块（参考图4-1）用来接收PACKET类型socket数据的函数是wpa_supplicant_rx_eapol。实际上，该函数就是WPAS中用来接收EAP/EAPOL数据包的。所以，wpa_supplicant_rx_eapol将处理AP发送过来的EAPOL帧。马上来看此函数，代码如下所示。 **wpa_supplicant.c：：wpa_supplicant_rx_eapol** ~~~ void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr, const u8 *buf, size_t len) { struct wpa_supplicant *wpa_s = ctx; /* 读者还记得4.5.3节“wpa_supplicant_event_assoc分析之二”最后关于pending_eapol_rx 的解释吗？当wpa_state状态不为WPA_ASSOCIATED的时候，如果收到AP发来的数据包，则先保存 起来，然后留待wpa_supplicant_event_assoc中去处理。 */ if (wpa_s->wpa_state < WPA_ASSOCIATED) { wpabuf_free(wpa_s->pending_eapol_rx); wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);// 复制数据 if (wpa_s->pending_eapol_rx) { os_get_time(&wpa_s->pending_eapol_rx_time); os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,ETH_ALEN); } return; } ......// CONFIG_AP处理 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) { return; } /* eapol_received用于记录收到的EAPOL/EAP包个数。初次进来，需要设置认证超时任务（这个 任务已经设置过多次了，不过wpa_supplicant_req_auth_timeout会先取消上一次设置的认证超时 任务，然后再设置新的）。 */ if (wpa_s->eapol_received == 0 && (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) || !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || wpa_s->wpa_state != WPA_COMPLETED) && (wpa_s->current_ssid == NULL || wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS) ) { wpa_supplicant_req_auth_timeout(wpa_s, (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) || wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA || wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ? 70 : 10, 0); } wpa_s->eapol_received++; if (wpa_s->countermeasures) { return; } ......// CONFIG_IBSS_RSN处理 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN); /* 对于非PSK认证方法（如802.1X认证），EAPOL/EAP帧由eapol_sm_rx_eapol进行处理。 另外，与四次握手和组播密钥交换相关的EAPOL-Key帧也不在eapol_sm_rx_eapol中处理。 */ if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) && eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0) return; /* driver_nl80211没有实现poll函数。该函数的目的是为了从驱动中获取Association过程中涉及 的IE信息对于nl80211来说，关联完成后，我们就已经收到了这些信息，所以不需要再次获取它们了。 */ wpa_drv_poll(wpa_s); if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE)) wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);// 关键函数。见下文分析 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) { eapol_sm_notify_portValid(wpa_s->eapol, TRUE); } } ~~~ wpa_sm_rx_eapol是本节的重点。在介绍之前，先来介绍EAPOL-Key交换的背景知识。一方面对3.3.7节RSNA介绍的补充，另一方面该背景知识对我们理解wpa_sm_rx_eapol函数也有重要帮助。 **1、背景知识介绍[22][23]** 由3.3.7节可知，RSNA过程中有两组Key需要交换和派生。 * PTK（Pairwise Transient Key，成对临时密钥）用于加解密单播数据。它从PMK（Pairwise Master Key）派生（derive）而来。对于SOHO网络环境来说，PMK就是PSK。它由用户设置的passphrase扩展而来（请读者参考4.5.2节中wpa_config_update_psk）。AP和STA需要通过4-Way Handshake协议交换和派生PTK。 * GTK（Group Transient Key，组临时密钥）用于加解密组播数据。它由GMK（Group MasterKey，其来源由AP或Authenticator Server决定）派生而来。AP和STA通过Group Key Handshake协议交换和派生GTK。Group Key Handshake必须在完成4-Way Handshake之后才能开展。 提示　Group Key Handshake对应的场景比较特殊。对组播数据而言，AP和所有和它关联的STA使用同一个GTK。不过，如果中途有STA离开（取消和AP的关联）的话，从安全角度考虑，AP和剩下的STA之间最好更换一个新的GTK。AP将根据情况来触发Group Key Handshake流程。另外，AP可通过4-Way Handshake告知STA其当前使用的GTK。这种情况下，AP和STA之间 无须开展Group Key Handshake流程。 下面，通过实例来介绍4-Way Handshake涉及的四次帧交换以及其中包含的数据信息。 * 第一个EAPOL-Key帧（以后简称Message A）由AP发送给STA，其内容如图4-38所示。Key Descriptor Type及以下的内容属于Key Descriptor。Key Descriptor用来描述EAPOL-Key帧的Key信息，由多个字段组成。 * 第一个字段是Key Descriptor Type，目前取值有三个，分别是RC4、WPA和RSN（即WPA2），802.11中可使用后两个。 * Key Information字段（2字节）包含多个标志位。下文将一一介绍它们。 * Key Length字段（2字节）表示PTK密钥的长度。对CCMP来说，它是16字节（128位），而对TKIP来说，其长度是32字节（256位）。读者可参考图3-47中的CCMP-TK、TKIP-TK和TKIP-MIC Key。CCMP和TKIP长度不一致的原因是CCMP可用一个Key完成数据加解密和MIC校验，而TKIP使用不同的Key来完成加解密以及MIC校验。 * Replay Counter字段（8字节）和防止重放攻击有关。一个简单的应用场景为STA之前收到过Replay Counter为1的包。假如它又收到一个Replay Counter为0的包，则认为发生了重放攻击，STA将丢弃Replay Counter为0的包。对Message A来说，该值必须为0。 * Key Nonce字段（32字节）用于存储Nonce值。对Message A来说，此Nonce值由AP生成，所以也叫ANonce。 * Key IV字段（16字节）表示初始向量，用于Key生成。Message A中该字段为全0。 * Key RSC字段（8字节）是Key Receive Sequence Counter的缩写，也和重放攻击有关。该字段用于四次握手的第三帧以及组播Key握手的第一帧中。 * Key ID字段（8字节）对WPA/RSN来说，该字段未使用。 * Key MIC字段（可变字节长度）表示存储MIC数据，其长度和具体的算法有关。笔者查询了802.11文档[22]，规范中列出的几种算法对应的MIC长度都是16字节。 * Key Data Length字段（2字节）表示Key Data长度。图4-38没有携带Key Data，所以该项为0。如果该项不为0，Key Descriptor还将在Key Data Length后添加一个"Key Data"项。 :-:  图4-38　Message A的内容 图4-38中，Key Information字段的内容如图4-39所示。 :-:  图4-39　Key Information字段 如图4-39所示： * Key Descriptor Version：用于指示Key Descriptor的版本号。当值为2时，表示Key Descriptor的Key Data用AES加密，而Key MIC由HMAC-SHA1算法计算而来。 * Key Type：值为1，表示该帧用于PTK派生，值为0表示该帧用于GTK派生。 * Reserved：该字段必须为0（图4-38中，该字段也被称为Key Index）。 * Install：当Key Type为1时，Install值为1表示STA需要安装PTK（将PTK传给驱动，下文源码分析时将看到相关函数）。Key Type为0时，Install必须为0。 * Key ACK：AP发送EAPOL-Key帧给STA时，如果需要STA发送回复数据，则设置其为1。 * Key MIC：如果EAPOL-Key帧包含MIC信息，其值被设为1，否则为0。 * Secure：当STA或AP派生出了PTK或GTK后，STA或AP发出的EAPOL-Key帧将该值设为1。 * Error：使用TKIP时，如果STA检查到MIC错误，则设置该值为1。对于其他情况下的MIC错误，该值和Request都必须被设为1。 * Request：STA请求AP发起4-Way Handshake（Key Type同时被设为1）或者Group KeyHandshake（Key Type同时被设为0）流程时，其值被设为1。或者和Error都被设为1以报告MIC错误。 * Encrypted Key Data：表示Key Data是否加密。 * SMK：Station-to-station link Master Key的缩写，是另外一种Key交换协议。本书不讨论。同上述介绍，相信读者对Key Descriptor有了一定的了解。现在马上来介绍四次握手协议中每个EAPOL-Key帧所包含的内容以及接收方的处理逻辑。 Message A由AP发送给STA，其内容如下。 * Key Info：Error位为0，因为这是第一帧数据。Secure位为0表示该帧没有加密的数据。KeyMIC为0表示该帧不包含MIC数据。Key ACK位为1表示AP要求STA回复此帧。Key Install为0表示现在还无法安装PTK。Key Type设为1表示当前是Pairwise密钥派生。本例中，Key DescriptionVersion值为2。 * Replay Counter：本例中它被设为1。STA需要保存这个值以检测重放攻击。 * Key Nonce：AP生成的随机数，也叫ANonce。 * 由于本帧不包含Key信息，所以其他字段都设为0。 提醒　802.11规范中指出，Message A的Key Data可以携带PMKID信息（包含在RSN IE或其他厂商自定义的IE中）。不过本例中，Message A没有携带它。 STA收到Message A的处理逻辑如下。 1. 生成一个Nonce，也叫SNonce。 2. 派生PTK。 3. 构造第二个EAPOL-Key帧，称为Message B。 图4-40为Message B的截图。 :-:  图4-40　Message B的内容 如图4-40所示： * 由Key Info的设置可知该帧包括MIC数据（Key MIC位为1）。 * Replay Counter的值必须等于Message A中的Replay Counter。 * Key MIC是对整个EAPOL-Key帧进行计算而来，计算方法由Key Descriptor Version指定（图4-40中的HMAC-SHA1 MIC方法）。 * Key Data包含一个RSN Information Element。该RSN IE来自STA之前和AP在关联操作时获得的RSN IE。规范没有说明为何此处要包含RSN IE。不过[23]倒是有一句简单的说法。即为了防止STA中途更改安全参数。 * AP收到Message B的处理如下。 * 派生PTK。 * 检查Message B的MIC值是否正确。如果发现MIC错误，则丢弃（而且是silently）MessageB。 这种情况下，4-Way Handshake流程已经被中断。如果MIC正确，AP将构造第三个EAPOLKey 帧，此处称为Message C，其内容如图4-41所示。 :-:  图4-41　Message C的内容 由图4-41可知： * Install为1，表示STA收到该帧后就可以安装PTK了。Secure为1表示AP已经派生了PTK。Encrpted Key Data为1，表示Key Data被加密了。 * Replay Counter为2，比前面的值增加1。 * Key Nonce值和Message A的一样。 * MIC对EAPOL-Key整个进行计算得来。 * Key IV为0。注意，如果Key Descriptor Version为2时，该字段必须为0。否则可以是其他随机数。 * Key Data由PTK加密后而来。其解密后的内容包括AP在Probe Response或Beacon帧包含RSN IE信息，另外还有可能包括GTK信息。如果有GTK的话，4-Way Handshake完毕后就无须开展Group Key Handshake流程。 STA收到Message C的处理如下。 1. 检查Replay Counter，计算MIC以及利用自己的PTK解密Key Data以获取RSN IE。 2. 如果Message C包含GTK信息，则取出GTK。注意，GTK以及和Key相关的信息存储在KDE（Key Data Element）的IE中。关于KDE和GTK的格式，请读者继续阅读下文。 3. 构造并发送最后一个EAPOL-Key帧，称为Message D。 4. 为Driver安装PTK。 Message D的内容如图4-42所示。由图可知，Replay Counter和Message C一样。MIC通过对EAPOL-Key整个进行计算得来。 AP收到Message D的处理如下。 1. 再次计算MIC，如果正确则为driver安装PTK。 2. 更新Replay Counter，如果以后需要更新Key，则使用一个不同的Replay Counter。 至此，4-Way Handshake成功完成，而AP和STA以后的单播数据将全部通过PTK进行加密。这就使得我们无法通过AirPcap解析Group Key Handshake数据包。关于Group Key Handshake的流程请看参考资料[22][23]。 :-:  图4-42　Message D的内容 根据前文所述，AP在Message C中可以携带GTK信息。这样4-Way Handshake完毕后，STA无须开展Group Key Handshake。 > 注意　经过测试，有些AP每次在4-Way Handshake完毕后就发起Group Key Handshake，而有些AP在Message C中直接包含了GTK，这样就避免了Group Key Handshake。接下来的代码分析以后一种情况为目标。 另外，请注意图3-47，该图展示了PTK的组成。以CCMP为例，PTK包含三个部分，分别是KCK、KEK和TK。其中KCK用来处理MIC字段，KEK用来处理Key Data字段，而TK则用于握手协议完毕后的数据加密。 介绍完背景知识后，马上来研究wpa_sm_rx_eapol函数，它是不是遵守了规范所描述的流程呢？ **2、wpa_sm_rx_eapol函数** 在分析代码之前，先介绍两个重要的数据结构，如图4-43所示。 * struct ieee802_1x_hdr为EAPOL帧头信息。 * struct wpa_eapol_key为EAPOL-Key帧的数据信息。 :-:  图4-43　EAPOL-Key帧对应的数据结构 wpa_sm_rx_eapol代码如下所示。 **wpa.c：：wpa_sm_rx_eapol** ~~~ int wpa_sm_rx_eapol(struct wpa_sm *sm, const u8 *src_addr, const u8 *buf, size_t len) { size_t plen, data_len, extra_len; struct ieee802_1x_hdr *hdr; struct wpa_eapol_key *key; u16 key_info, ver; u8 *tmp; int ret = -1; struct wpa_peerkey *peerkey = NULL; ......// 参数检查 tmp = os_malloc(len); os_memcpy(tmp, buf, len); hdr = (struct ieee802_1x_hdr *) tmp; key = (struct wpa_eapol_key *) (hdr + 1); plen = be_to_host16(hdr->length); data_len = plen + sizeof(*hdr); // 检查EAPOL-Key帧的类型 if (hdr->version < EAPOL_VERSION) { } if (hdr->type != IEEE802_1X_TYPE_EAPOL_KEY)// 本函数只处理EAPOL-Key帧 { ret = 0; goto out;} if (key->type != EAPOL_KEY_TYPE_WPA && key->type != EAPOL_KEY_TYPE_RSN) { ret = 0; goto out; // 只处理key类型为WPA和RSN的情况 } /* 通知lowerLayerSuccess。该函数最后一个参数表示此次调用是否来自EAPOL模块内部， 由于wpa_sm_rx_eapol并非EAPOL模块内部，所以该参数为0。 */ eapol_sm_notify_lower_layer_success(sm->eapol, 0); // 取出Key Information字段，并保存到key_info变量中 key_info = WPA_GET_BE16(key->key_info); ver = key_info & WPA_KEY_INFO_TYPE_MASK; // 获取key descriptor version if (ver != WPA_KEY_INFO_TYPE_HMAC_MD5_RC4 && ver != WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) goto out; // 根据规范的要求做相应处理 ......// CONFIG_IEEE80211R和CONFIG_IEEE80211W的处理 // 加密算法兼容性检查 if (sm->pairwise_cipher==WPA_CIPHER_CCMP&&ver!= WPA_KEY_INFO_TYPE_HMAC_SHA1_AES){ // 下面这个if判断用于检查组播数据加密设置是否正确 if(sm->group_cipher!=WPA_CIPHER_CCMP&&!(key_info&WPA_KEY_INFO_KEY_TYPE)){ ......// 打印一句兼容性警告 } else goto out; } ......// CONFIG_PEERKEY处理。PeerKey对应peerkey handshake流程，它和IEEE802.11e DLS有关 // 检查Replay Counter，如果收到的Replay Counter比之前接收的值小，则丢弃该帧 if (!peerkey && sm->rx_replay_counter_set && os_memcmp(key->replay_counter, sm->rx_replay_counter, WPA_REPLAY_COUNTER_LEN) <= 0) goto out; // STA收到的EAPOL-Key帧必须设置ACK位或SMK位为1 if (!(key_info & (WPA_KEY_INFO_ACK | WPA_KEY_INFO_SMK_MESSAGE)) ) goto out; // 只有STA向AP发送的EAPOL-Key帧才能设置Request位 if (key_info & WPA_KEY_INFO_REQUEST) goto out; /* MIC位不为0，则需要解析MIC数据。对STA来说，只有Message C会携带MIC信息。 wpa_supplicant_verify_eapol_key_mic比较简单，请读者自行阅读它。其功能是：STA 根据KCK计算MIC，然后将其和接收到的MIC进行比较。如果MIC值检查正常，则PTK正确。 */ if ((key_info & WPA_KEY_INFO_MIC) && !peerkey && wpa_supplicant_verify_eapol_key_mic(sm, key, ver, tmp, data_len)) goto out; extra_len = data_len - sizeof(*hdr) - sizeof(*key); if (WPA_GET_BE16(key->key_data_length) > extra_len) goto out;// 参数检查 extra_len = WPA_GET_BE16(key->key_data_length); // Encrpted Key Data位为1，表示该帧包含加密数据，需要利用KEK进行解密 // 该函数也比较简单，请读者自行阅读 if (sm->proto == WPA_PROTO_RSN && (key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) { if (wpa_supplicant_decrypt_key_data(sm, key, ver)) goto out; extra_len = WPA_GET_BE16(key->key_data_length); } // Key Info Type值为1，表示为Pairwise Key。值为0表示Group Key if (key_info & WPA_KEY_INFO_KEY_TYPE) { if (key_info & WPA_KEY_INFO_KEY_INDEX_MASK) goto out; if (peerkey) { peerkey_rx_eapol_4way(sm, peerkey, key, key_info, ver); } else if (key_info & WPA_KEY_INFO_MIC) {// 对STA而言，只有Message C包含MIC信息 wpa_supplicant_process_3_of_4(sm, key, ver);// 处理Message C } else {// 处理Message A wpa_supplicant_process_1_of_4(sm, src_addr, key, ver); } } else if (key_info & WPA_KEY_INFO_SMK_MESSAGE) {// SMK的情况 peerkey_rx_eapol_smk(sm, src_addr, key, extra_len, key_info, ver); } else {// Group Key Handshake处理 if (key_info & WPA_KEY_INFO_MIC) {// 组播密钥交换。本章不讨论此函数 wpa_supplicant_process_1_of_2(sm, src_addr, key,extra_len, ver); } else ......// 打印一句警告 } ret = 1; out: os_free(tmp); return ret; } ~~~ wpa_sm_rx_eapol的流程比较简单，就是先处理EAPOL-Key的基本信息（如计算MIC、解密Key Data），然后根据情况处理MessageA、Message C或者Group Key Handshake的Message 1。 由于本例不涉及Group Key Handshake流程，所以下面将介绍Message A及Message C的处理过程。 **3、wpa_supplicant_process_1_of_4函数** wpa_supplicant_process_1_of_4用于处理Message A，其代码如下所示。 **wpa.c：：wpa_supplicant_process_1_of_4** ~~~ static void wpa_supplicant_process_1_of_4(struct wpa_sm *sm, const unsigned char *src_addr, const struct wpa_eapol_key *key, u16 ver) { struct wpa_eapol_ie_parse ie; struct wpa_ptk *ptk; u8 buf[8]; int res; if (wpa_sm_get_network_ctx(sm) == NULL) {......// 错误处理} wpa_sm_set_state(sm, WPA_4WAY_HANDSHAKE); // 设置状态为WPA_4WAY_HANDSHAKE os_memset(&ie, 0, sizeof(ie)); #ifndef CONFIG_NO_WPA2 if (sm->proto == WPA_PROTO_RSN) { const u8 *_buf = (const u8 *) (key + 1);// buf中是已经解密的Key Data数据 size_t len = WPA_GET_BE16(key->key_data_length); // 解析Message A中包含的RSN信息。对本例而言，Message A中没有RSN信息 if (wpa_supplicant_parse_ies(_buf, len, &ie) < 0) goto failed; } #endif /* CONFIG_NO_WPA2 */ // 如果根据RSN IE中的pmkid判断是否有PMKSA缓存项。本例没有RSN IE，所以不存在ie.pmkid res = wpa_supplicant_get_pmk(sm, src_addr, ie.pmkid); if (res == -2) return; if (res) goto failed; // 结合前面对背景知识的描述，STA需要创建自己的Nonce if (sm->renew_snonce) { if (random_get_bytes(sm->snonce, WPA_NONCE_LEN)) goto failed; sm->renew_snonce = 0; } /* tptk变量存储的是临时PTK，因为现在还不确定PTK是否正确。注意，当收到Message C时， wpa_sm_rx_eapol的wpa_supplicant_verify_eapol_key_mic函数将把sm->tptk的内容复制到 sm->ptk变量中作为正式的ptk存储。 */ ptk = &sm->tptk; wpa_derive_ptk(sm, src_addr, key, ptk);// 派生PTK并将结果保存到tptk变量中 os_memcpy(buf, ptk->u.auth.tx_mic_key, 8); os_memcpy(ptk->u.auth.tx_mic_key, ptk->u.auth.rx_mic_key, 8); os_memcpy(ptk->u.auth.rx_mic_key, buf, 8); sm->tptk_set = 1; // tptk_set为1表示临时PTK存在 // 构造并发送Message B。请读者结合参考资料[23]来研究此函数 if (wpa_supplicant_send_2_of_4(sm, sm->bssid, key, ver, sm->snonce, sm->assoc_wpa_ie, sm->assoc_wpa_ie_len, ptk)) goto failed; // 包括AP的Nonce信息 os_memcpy(sm->anonce, key->key_nonce, WPA_NONCE_LEN); return; failed: wpa_sm_deauthenticate(sm, WLAN_REASON_UNSPECIFIED); } ~~~ STA将Message B发送出去后，AP将接收到它并根据AP的处理逻辑进行处理。假设一切顺利，AP将构造并发送Message C给STA。 STA依然在wpa_sm_rx_eapol中处理Message C，其过程如下。 1. 由于Message C包含MIC以及Key Data数据，故它们将在wpa_sm_rx_eapol中的wpa_supplicant_verify_eapol_key_mic及wpa_supplicant_decrypt_key_data被处理。这两个函数的代码请感兴趣的读者自行阅读。 2. 接下来调用wpa_supplicant_process_3_of_4。这是我们分析的重点。 **4、wpa_supplicant_process_3_of_4函数** wpa_supplicant_process_3_of_4的代码如下所示。 **wpa.c：：wpa_supplicant_process_3_of_4** ~~~ static void wpa_supplicant_process_3_of_4(struct wpa_sm *sm, const struct wpa_eapol_key *key, u16 ver) { u16 key_info, keylen, len; const u8 *pos; struct wpa_eapol_ie_parse ie; wpa_sm_set_state(sm, WPA_4WAY_HANDSHAKE);// 还是处于WPA_4WAY_HANDSHAKE状态 key_info = WPA_GET_BE16(key->key_info); pos = (const u8 *) (key + 1); len = WPA_GET_BE16(key->key_data_length); /* 解析Message C中包含的IE信息。注意，key data中的数据已经由wpa_supplicant_decrypt_key_data 解密过了。 */ if (wpa_supplicant_parse_ies(pos, len, &ie) < 0) goto failed; if (ie.gtk && !(key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) goto failed; ......// CONFIG_IEEE80211W // 校验RSN信息。该校验似乎也是为了防止安全设置项中途发生改变 if (wpa_supplicant_validate_ie(sm, sm->bssid, &ie) < 0) goto failed; // 比较Message A和Message C中的Nonce值 if (os_memcmp(sm->anonce, key->key_nonce, WPA_NONCE_LEN) != 0) goto failed; keylen = WPA_GET_BE16(key->key_length); ......// 参数检查 // 构造并发送Message D，请读者自行阅读该函数 if (wpa_supplicant_send_4_of_4(sm, sm->bssid, key, ver, key_info, NULL, 0, &sm->ptk)) goto failed; sm->renew_snonce = 1; /* 调用driver_nl80211的wpa_driver_nl80211_set_key函数将key发给驱动。以后，所有 无线网络数据都将被加密。另外，如果wpa_supplicant.conf文件配置wpa_ptk_rekey （用来控制PTK的生命周期，时间为秒）时，该函数内部还将注册一个超时函数wpa_sm_rekey_ptk。一旦 wpa_ptk_rekey到期，STA将重新和AP开展4-Way Handshake以重新派生新的PTK。 请读者自行阅读wpa_supplicant_install_ptk函数。 */ if (key_info & WPA_KEY_INFO_INSTALL) // 安装Key if (wpa_supplicant_install_ptk(sm, key)) goto failed; // Message C必须设置Secure位 if (key_info & WPA_KEY_INFO_SECURE) { // 下面这个函数和管理帧加密有关系 wpa_sm_mlme_setprotection(sm, sm->bssid, MLME_SETPROTECTION_PROTECT_TYPE_RX, MLME_SETPROTECTION_KEY_TYPE_PAIRWISE); eapol_sm_notify_portValid(sm->eapol, TRUE);// 设置EAPOL SM portValid为TRUE } wpa_sm_set_state(sm, WPA_GROUP_HANDSHAKE); // 设置状态为WPA_GROUP_HANDSHAKE // 对本例而言，Message C中包含了GTK信息 if (ie.gtk && wpa_supplicant_pairwise_gtk(sm, key, ie.gtk, ie.gtk_len, key_info) < 0) goto failed; // 和IEEE80211W有关。本书不讨论它 if (ieee80211w_set_keys(sm, &ie) < 0) goto failed; /* 下面这个函数将调用driver wrapper的set_rekey_info函数。该函数和GTK的更新有关。 它对应以下应用场景。 当某STA因为省电或别的什么原因进入休眠状态时，如果AP在STA休眠过程中更新了GTK。当该STA 醒来时，其组播消息密钥肯定失效了。这种情况该如何处理呢？通过set_rekey_info函数，我们可 将该工作交给wlan芯片来完成。即由wlan芯片来负责处理EAPOL-Key帧交换以更新GTK。注意， 如果wlan driver不支持该功能，它将唤醒STA，并将该工作交给WPAS来完成。 这部分功能属于WoWLAN（无线局域网唤醒）机制的一部分，目前只有很少的系统支持它。读者可阅读 参考资料[24][25]以加深对WoWLAN的认识。 */ wpa_sm_set_rekey_offload(sm); return; failed: wpa_sm_deauthenticate(sm, WLAN_REASON_UNSPECIFIED); } ~~~ wpa_supplicant_process_3_of_4代码逻辑和背景知识介绍中关于Message C的处理逻辑大体一致。对于包含GTK信息的Message C来说，wpa_supplicant_pairwise_gtk将被调用以处理GTK对应的KDE信息。马上来看此函数。 **5、wpa_supplicant_pairwise_gtk函数** 介绍wpa_supplicant_pairwise_gtk之前，先来看看KDE和GTK的格式，如图4-44所示。 :-:  图4-44　KDE和GTK格式 图4-44中，上图为KDE的格式，其中Type取值为0xdd。Data包含具体的信息。当Data中的信息为GTK时，OUT取值为00-0F-AC，Data Type取值为1。下图为GTK的格式。KeyID字段可取值有0～3共4个，它和动态Key有关。Tx字段为1，表示发送和接收组播数据都需要使用该GTK。值为0表示仅接收组播数据需要使用该GTK。 **wpa.c：：wpa_supplicant_pairwise_gtk** ~~~ static int wpa_supplicant_pairwise_gtk(struct wpa_sm *sm, const struct wpa_eapol_key *key, const u8 *gtk, size_t gtk_len, int key_info) { #ifndef CONFIG_NO_WPA2 struct wpa_gtk_data gd; os_memset(&gd, 0, sizeof(gd)); if (gtk_len < 2 || gtk_len - 2 > sizeof(gd.gtk)) return -1; // 参数检查 gd.keyidx = gtk[0] & 0x3; // 下面这个函数对图4-44中的Tx位进行一些处理 // 它对某些AP错误设置Tx位的情况采取了“绕过去”的策略 gd.tx = wpa_supplicant_gtk_tx_bit_workaround(sm,!!(gtk[0] & BIT(2))); gtk += 2; gtk_len -= 2; os_memcpy(gd.gtk, gtk, gtk_len); gd.gtk_len = gtk_len; // 检查组播数据加密设置是否合适，然后调用wpa_supplicant_install_gtk函数安装GTK if (wpa_supplicant_check_group_cipher(sm, sm->group_cipher, gtk_len, gtk_len, &gd.key_rsc_len, &gd.alg) || wpa_supplicant_install_gtk(sm, &gd, key->key_rsc)) return -1; // 最后一个关键函数 wpa_supplicant_key_neg_complete(sm, sm->bssid,key_info & WPA_KEY_INFO_SECURE); return 0; #else return -1; #endif } ~~~ 上述代码中，请读者自行阅读除wpa_supplicant_key_neg_complete外的其他几个函数。下面来看最后一个关键函数。 **wpa.c：：wpa_supplicant_key_neg_complete** ~~~ static void wpa_supplicant_key_neg_complete(struct wpa_sm *sm,const u8 *addr, int secure) { wpa_sm_cancel_auth_timeout(sm);// 取消超时任务 // 该函数内部将调用wpa_supplicant.c中的wpa_supplicant_set_state。请读者自行阅读 // 不光是一个简单的设置状态，它还需要调用driver的set_supp_port函数 wpa_sm_set_state(sm, WPA_COMPLETED);// 设置WPAS的状态为WPA_COMPLETED if (secure) {// secure为1 wpa_sm_mlme_setprotection( sm, addr, MLME_SETPROTECTION_PROTECT_TYPE_RX_TX, MLME_SETPROTECTION_KEY_TYPE_PAIRWISE); eapol_sm_notify_portValid(sm->eapol, TRUE); if (wpa_key_mgmt_wpa_psk(sm->key_mgmt))// 本例采用了PSK认证，故可以通知eapSuccess eapol_sm_notify_eap_success(sm->eapol, TRUE); eloop_register_timeout(1, 0, wpa_sm_start_preauth, sm, NULL); } if (sm->cur_pmksa && sm->cur_pmksa->opportunistic) sm->cur_pmksa->opportunistic = 0; .....// CONFIG_IEEE80211R } ~~~ 至此，4-Way Handshake的处理就全部完成。而802.1X中Port的状态以及WPAS的状态则由此过程中相关的函数触发以发生转换。下一节将简单介绍这部分的内容。 **6、WPAS状态机变化** 上述4-Way Handshake处理流程节中，EAPOL模块、EAP模块以及WPAS的状态都会发生对应的转换。在上述wpa_supplicant_key_neg_complete中，wpa_sm_set_state将设置WPAS的状态为WPA_COMPLETED。马上来看wpa_sm_set_state的代码，如下所示。 **wpa_i.h：：wpa_sm_set_state** ~~~ static inline void wpa_sm_set_state(struct wpa_sm *sm, enum wpa_states state) { /* 调用回调函数。由4.3.4节的wpa_supplicant_init_wpa函数中设置，其真实函数为 _wpa_supplicant_set_state，而该函数又会调用wpa_supplicant_set_state。 */ sm->ctx->set_state(sm->ctx->ctx, state); } ~~~ wpa_sm_set_state将调用前面设置的回调函数进行处理。 最终的处理函数wpa_supplicant_set_state如下所示 **wpa_supplicant.c：：wpa_supplicant_set_state** ~~~ void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, enum wpa_states state) { enum wpa_states old_state = wpa_s->wpa_state; ...... if (state == WPA_COMPLETED && wpa_s->new_connection) { #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG) struct wpa_ssid *ssid = wpa_s->current_ssid; #endif wpa_s->new_connection = 0; wpa_s->reassociated_connection = 1; /* 设置driver的IfOperStatus为IF_OPER_UP，driver nl80211中对应的函数是 wpa_driver_nl80211_set_operstate。 */ wpa_drv_set_operstate(wpa_s, 1); #ifndef IEEE8021X_EAPOL /* 以driver nl80211来说，下面这个函数将调用wpa_driver_nl80211_set_supp_port 以设置驱动中STA的标志为NL80211_STA_FLAG_AUTHENTICATED。 */ wpa_drv_set_supp_port(wpa_s, 1); #endif /* IEEE8021X_EAPOL */ wpa_s->after_wps = 0; } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING || state == WPA_ASSOCIATED) { wpa_s->new_connection = 1;// ASSOCIATING或ASSOCIATED状态下，new_connection被置为1 wpa_drv_set_operstate(wpa_s, 0);// 设置driver的IfOperStatus为IF_OPER_DORMANT #ifndef IEEE8021X_EAPOL wpa_drv_set_supp_port(wpa_s, 0);// 取消STA的NL80211_STA_FLAG_AUTHENTICATED标志 #endif /* IEEE8021X_EAPOL */ } wpa_s->wpa_state = state; ....... } ~~~ 当WPAS的状态变成WPA_COMPLETED后，还需要设置driver的IfOperStatus以及NL80211_STA_FLAG_AUTHENTICATED标志位。如此这般，WPAS才算和Driver上下同心。 **7、EAPOL/EAP状态机变化** 在4-Way Handshake过程中，EAPOL/EAP状态机也会发生变化。在4.5.3节eapol_sm_notify_portEnabled函数分析的最后，已知EAPOL/EAP状态机的状态分别如下。 * SUPP_PAE进入CONNECTING状态； * KEY_RX不变（NO_KEY_RECEIVE）； * SUPP_BE进入IDLE状态； * EAP_SM不变（DISABLED状态）。 在4-Way Handshake过程中，一共有两个和EAPOL相关的函数被调用： eapol_sm_notify_portValid函数portValid被设为TRUE。 eapol_sm_notify_eap_success函数代码如下所示。 **eapol_supp_sm.c：：eapol_sm_notify_eap_success** ~~~ void eapol_sm_notify_eap_success(struct eapol_sm *sm, Boolean success) { if (sm == NULL) return; sm->eapSuccess = success; sm->altAccept = success; if (success) eap_notify_success(sm->eap); eapol_sm_step(sm);// 状态机联动 } // 直接来看eap_notify_success函数 void eap_notify_success(struct eap_sm *sm) { if (sm) { sm->decision = DECISION_COND_SUCC; sm->EAP_state = EAP_SUCCESS;// EAP_SM状态直接被设置为EAP_SUCCESS } } ~~~ 根据4.4.2节状态机联动中对eapol_sm_step的分析，四个状态机更新的顺序分别是SUPP_PAE、KER_RX、SUPP_BE和EAP_SM。分别结合四个状态机的切换图，我们可知第一轮循环中： * eapSuccess将先触发SUPP_PAE进入AUTHENTICATING状态，该状态对应的EA将设置suppStart为TRUE。 * eapSuccess和suppStart将触发SUPP_BE进入SUCCESS状态，该状态对应的EA将设置keyRun和suppSuccess为TRUE。 * EAP_SM状态在eap_notify_success中直接被置为EAP_SUCCESS。但在状态切换中，由于force_disabled变量为TRUE，导致EAP SUPP SM将直接转回DISABLED状态（和4.4.2节介绍的状态机联动的情况类似）。 * KER_RX状态不变。由于上述状态机均有状态变化，下面进入第二轮循环： * suppSuccess和portValid为TRUE将触发SUPP_PAE进入AUTHENTICATED状态（由于条件变量不会再改变，故SUPP_PAE将不再发生状态变化）。该状态的EA见下文代码。 * 由于UCT的存在，SUPP_BE将跳转到IDLE状态。 * KEY_RX和EAP_SM状态保持不变。 以下是SUPP_PAE的EA代码。 **eapol_supp_sm.c：：SM_STATE（SUPP_PAE，AUTHENTICATED** ~~~ SM_STATE(SUPP_PAE, AUTHENTICATED) { SM_ENTRY(SUPP_PAE, AUTHENTICATED); sm->suppPortStatus = Authorized; // 也会调用wpa_drv_set_supp_port函数 eapol_sm_set_port_authorized(sm); /* 设置cb_status为EAPOL_CB_SUCCESS，将触发eapol_sm_step在退出前调用 wpa_supplicant_eapol_cb，此函数对于WPA/RSN企业认证法有重要作用。请读者自行阅读。 */ sm->cb_status = EAPOL_CB_SUCCESS; } ~~~ 请读者结合SUPP_PAE和SUPP_BE的状态切换图来理解上述的状态变化过程。 至此，STA就通过了AP的身份验证。下一步的工作就是dhcpcd从AP那获取一个IP，然后手机就可以上网了。 **8、EAPOL-Key交换流程总结** 下面总结4-Way Handshake的流程，如图4-45和图4-46所示。 :-:  图4-45　Message A处理流程 :-:  图4-46　Message C处理流程 图中分别为4-Way Handshake中Message A与Message C的处理流程。其中，Message C还携带了GTK信息，这样就无须Group Key Handshake了。