1 /*
2 * hidl interface for wpa_supplicant daemon
3 * Copyright (c) 2004-2016, Jouni Malinen <j@w1.fi>
4 * Copyright (c) 2004-2016, Roshan Pius <rpius@google.com>
5 *
6 * This software may be distributed under the terms of the BSD license.
7 * See README for more details.
8 */
9
10 #include "hidl_manager.h"
11 #include "hidl_return_util.h"
12 #include "misc_utils.h"
13 #include "sta_network.h"
14
15 extern "C" {
16 #include "wps_supplicant.h"
17 }
18
19 namespace {
20 using android::hardware::wifi::supplicant::V1_0::ISupplicantStaNetwork;
21 using android::hardware::wifi::supplicant::V1_0::SupplicantStatus;
22
23 constexpr uint8_t kZeroBssid[6] = {0, 0, 0, 0, 0, 0};
24
25 constexpr uint32_t kAllowedKeyMgmtMask =
26 (static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::NONE) |
27 static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::WPA_PSK) |
28 static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::WPA_EAP) |
29 static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::IEEE8021X) |
30 static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::FT_EAP) |
31 static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::FT_PSK) |
32 static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::OSEN));
33 constexpr uint32_t kAllowedProtoMask =
34 (static_cast<uint32_t>(ISupplicantStaNetwork::ProtoMask::WPA) |
35 static_cast<uint32_t>(ISupplicantStaNetwork::ProtoMask::RSN) |
36 static_cast<uint32_t>(ISupplicantStaNetwork::ProtoMask::OSEN));
37 constexpr uint32_t kAllowedAuthAlgMask =
38 (static_cast<uint32_t>(ISupplicantStaNetwork::AuthAlgMask::OPEN) |
39 static_cast<uint32_t>(ISupplicantStaNetwork::AuthAlgMask::SHARED) |
40 static_cast<uint32_t>(ISupplicantStaNetwork::AuthAlgMask::LEAP));
41 constexpr uint32_t kAllowedGroupCipherMask =
42 (static_cast<uint32_t>(ISupplicantStaNetwork::GroupCipherMask::WEP40) |
43 static_cast<uint32_t>(ISupplicantStaNetwork::GroupCipherMask::WEP104) |
44 static_cast<uint32_t>(ISupplicantStaNetwork::GroupCipherMask::TKIP) |
45 static_cast<uint32_t>(ISupplicantStaNetwork::GroupCipherMask::CCMP) |
46 static_cast<uint32_t>(
47 ISupplicantStaNetwork::GroupCipherMask::GTK_NOT_USED));
48 constexpr uint32_t kAllowedPairwisewCipherMask =
49 (static_cast<uint32_t>(ISupplicantStaNetwork::PairwiseCipherMask::NONE) |
50 static_cast<uint32_t>(ISupplicantStaNetwork::PairwiseCipherMask::TKIP) |
51 static_cast<uint32_t>(ISupplicantStaNetwork::PairwiseCipherMask::CCMP));
52
53 constexpr uint32_t kEapMethodMax =
54 static_cast<uint32_t>(ISupplicantStaNetwork::EapMethod::WFA_UNAUTH_TLS) + 1;
55 constexpr char const *kEapMethodStrings[kEapMethodMax] = {
56 "PEAP", "TLS", "TTLS", "PWD", "SIM", "AKA", "AKA'", "WFA-UNAUTH-TLS"};
57 constexpr uint32_t kEapPhase2MethodMax =
58 static_cast<uint32_t>(ISupplicantStaNetwork::EapPhase2Method::AKA_PRIME) +
59 1;
60 constexpr char const *kEapPhase2MethodStrings[kEapPhase2MethodMax] = {
61 "", "PAP", "MSCHAP", "MSCHAPV2", "GTC", "SIM", "AKA", "AKA'"};
62 constexpr char kEapPhase2AuthPrefix[] = "auth=";
63 constexpr char kEapPhase2AuthEapPrefix[] = "autheap=";
64 constexpr char kNetworkEapSimGsmAuthResponse[] = "GSM-AUTH";
65 constexpr char kNetworkEapSimUmtsAuthResponse[] = "UMTS-AUTH";
66 constexpr char kNetworkEapSimUmtsAutsResponse[] = "UMTS-AUTS";
67 constexpr char kNetworkEapSimGsmAuthFailure[] = "GSM-FAIL";
68 constexpr char kNetworkEapSimUmtsAuthFailure[] = "UMTS-FAIL";
69 } // namespace
70
71 namespace android {
72 namespace hardware {
73 namespace wifi {
74 namespace supplicant {
75 namespace V1_0 {
76 namespace implementation {
77 using hidl_return_util::validateAndCall;
78
StaNetwork(struct wpa_global * wpa_global,const char ifname[],int network_id)79 StaNetwork::StaNetwork(
80 struct wpa_global *wpa_global, const char ifname[], int network_id)
81 : wpa_global_(wpa_global),
82 ifname_(ifname),
83 network_id_(network_id),
84 is_valid_(true)
85 {
86 }
87
invalidate()88 void StaNetwork::invalidate() { is_valid_ = false; }
isValid()89 bool StaNetwork::isValid()
90 {
91 return (is_valid_ && (retrieveNetworkPtr() != nullptr));
92 }
93
getId(getId_cb _hidl_cb)94 Return<void> StaNetwork::getId(getId_cb _hidl_cb)
95 {
96 return validateAndCall(
97 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
98 &StaNetwork::getIdInternal, _hidl_cb);
99 }
100
getInterfaceName(getInterfaceName_cb _hidl_cb)101 Return<void> StaNetwork::getInterfaceName(getInterfaceName_cb _hidl_cb)
102 {
103 return validateAndCall(
104 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
105 &StaNetwork::getInterfaceNameInternal, _hidl_cb);
106 }
107
getType(getType_cb _hidl_cb)108 Return<void> StaNetwork::getType(getType_cb _hidl_cb)
109 {
110 return validateAndCall(
111 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
112 &StaNetwork::getTypeInternal, _hidl_cb);
113 }
114
registerCallback(const sp<ISupplicantStaNetworkCallback> & callback,registerCallback_cb _hidl_cb)115 Return<void> StaNetwork::registerCallback(
116 const sp<ISupplicantStaNetworkCallback> &callback,
117 registerCallback_cb _hidl_cb)
118 {
119 return validateAndCall(
120 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
121 &StaNetwork::registerCallbackInternal, _hidl_cb, callback);
122 }
123
setSsid(const hidl_vec<uint8_t> & ssid,setSsid_cb _hidl_cb)124 Return<void> StaNetwork::setSsid(
125 const hidl_vec<uint8_t> &ssid, setSsid_cb _hidl_cb)
126 {
127 return validateAndCall(
128 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
129 &StaNetwork::setSsidInternal, _hidl_cb, ssid);
130 }
131
setBssid(const hidl_array<uint8_t,6> & bssid,setBssid_cb _hidl_cb)132 Return<void> StaNetwork::setBssid(
133 const hidl_array<uint8_t, 6> &bssid, setBssid_cb _hidl_cb)
134 {
135 return validateAndCall(
136 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
137 &StaNetwork::setBssidInternal, _hidl_cb, bssid);
138 }
139
setScanSsid(bool enable,setScanSsid_cb _hidl_cb)140 Return<void> StaNetwork::setScanSsid(bool enable, setScanSsid_cb _hidl_cb)
141 {
142 return validateAndCall(
143 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
144 &StaNetwork::setScanSsidInternal, _hidl_cb, enable);
145 }
146
setKeyMgmt(uint32_t key_mgmt_mask,setKeyMgmt_cb _hidl_cb)147 Return<void> StaNetwork::setKeyMgmt(
148 uint32_t key_mgmt_mask, setKeyMgmt_cb _hidl_cb)
149 {
150 return validateAndCall(
151 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
152 &StaNetwork::setKeyMgmtInternal, _hidl_cb, key_mgmt_mask);
153 }
154
setProto(uint32_t proto_mask,setProto_cb _hidl_cb)155 Return<void> StaNetwork::setProto(uint32_t proto_mask, setProto_cb _hidl_cb)
156 {
157 return validateAndCall(
158 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
159 &StaNetwork::setProtoInternal, _hidl_cb, proto_mask);
160 }
161
setAuthAlg(uint32_t auth_alg_mask,std::function<void (const SupplicantStatus & status)> _hidl_cb)162 Return<void> StaNetwork::setAuthAlg(
163 uint32_t auth_alg_mask,
164 std::function<void(const SupplicantStatus &status)> _hidl_cb)
165 {
166 return validateAndCall(
167 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
168 &StaNetwork::setAuthAlgInternal, _hidl_cb, auth_alg_mask);
169 }
170
setGroupCipher(uint32_t group_cipher_mask,setGroupCipher_cb _hidl_cb)171 Return<void> StaNetwork::setGroupCipher(
172 uint32_t group_cipher_mask, setGroupCipher_cb _hidl_cb)
173 {
174 return validateAndCall(
175 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
176 &StaNetwork::setGroupCipherInternal, _hidl_cb, group_cipher_mask);
177 }
178
setPairwiseCipher(uint32_t pairwise_cipher_mask,setPairwiseCipher_cb _hidl_cb)179 Return<void> StaNetwork::setPairwiseCipher(
180 uint32_t pairwise_cipher_mask, setPairwiseCipher_cb _hidl_cb)
181 {
182 return validateAndCall(
183 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
184 &StaNetwork::setPairwiseCipherInternal, _hidl_cb,
185 pairwise_cipher_mask);
186 }
187
setPskPassphrase(const hidl_string & psk,setPskPassphrase_cb _hidl_cb)188 Return<void> StaNetwork::setPskPassphrase(
189 const hidl_string &psk, setPskPassphrase_cb _hidl_cb)
190 {
191 return validateAndCall(
192 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
193 &StaNetwork::setPskPassphraseInternal, _hidl_cb, psk);
194 }
195
setPsk(const hidl_array<uint8_t,32> & psk,setPsk_cb _hidl_cb)196 Return<void> StaNetwork::setPsk(
197 const hidl_array<uint8_t, 32> &psk, setPsk_cb _hidl_cb)
198 {
199 return validateAndCall(
200 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
201 &StaNetwork::setPskInternal, _hidl_cb, psk);
202 }
203
setWepKey(uint32_t key_idx,const hidl_vec<uint8_t> & wep_key,setWepKey_cb _hidl_cb)204 Return<void> StaNetwork::setWepKey(
205 uint32_t key_idx, const hidl_vec<uint8_t> &wep_key, setWepKey_cb _hidl_cb)
206 {
207 return validateAndCall(
208 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
209 &StaNetwork::setWepKeyInternal, _hidl_cb, key_idx, wep_key);
210 }
211
setWepTxKeyIdx(uint32_t key_idx,setWepTxKeyIdx_cb _hidl_cb)212 Return<void> StaNetwork::setWepTxKeyIdx(
213 uint32_t key_idx, setWepTxKeyIdx_cb _hidl_cb)
214 {
215 return validateAndCall(
216 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
217 &StaNetwork::setWepTxKeyIdxInternal, _hidl_cb, key_idx);
218 }
219
setRequirePmf(bool enable,setRequirePmf_cb _hidl_cb)220 Return<void> StaNetwork::setRequirePmf(bool enable, setRequirePmf_cb _hidl_cb)
221 {
222 return validateAndCall(
223 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
224 &StaNetwork::setRequirePmfInternal, _hidl_cb, enable);
225 }
226
setEapMethod(ISupplicantStaNetwork::EapMethod method,setEapMethod_cb _hidl_cb)227 Return<void> StaNetwork::setEapMethod(
228 ISupplicantStaNetwork::EapMethod method, setEapMethod_cb _hidl_cb)
229 {
230 return validateAndCall(
231 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
232 &StaNetwork::setEapMethodInternal, _hidl_cb, method);
233 }
234
setEapPhase2Method(ISupplicantStaNetwork::EapPhase2Method method,setEapPhase2Method_cb _hidl_cb)235 Return<void> StaNetwork::setEapPhase2Method(
236 ISupplicantStaNetwork::EapPhase2Method method,
237 setEapPhase2Method_cb _hidl_cb)
238 {
239 return validateAndCall(
240 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
241 &StaNetwork::setEapPhase2MethodInternal, _hidl_cb, method);
242 }
243
setEapIdentity(const hidl_vec<uint8_t> & identity,setEapIdentity_cb _hidl_cb)244 Return<void> StaNetwork::setEapIdentity(
245 const hidl_vec<uint8_t> &identity, setEapIdentity_cb _hidl_cb)
246 {
247 return validateAndCall(
248 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
249 &StaNetwork::setEapIdentityInternal, _hidl_cb, identity);
250 }
251
setEapAnonymousIdentity(const hidl_vec<uint8_t> & identity,setEapAnonymousIdentity_cb _hidl_cb)252 Return<void> StaNetwork::setEapAnonymousIdentity(
253 const hidl_vec<uint8_t> &identity, setEapAnonymousIdentity_cb _hidl_cb)
254 {
255 return validateAndCall(
256 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
257 &StaNetwork::setEapAnonymousIdentityInternal, _hidl_cb, identity);
258 }
259
setEapPassword(const hidl_vec<uint8_t> & password,setEapPassword_cb _hidl_cb)260 Return<void> StaNetwork::setEapPassword(
261 const hidl_vec<uint8_t> &password, setEapPassword_cb _hidl_cb)
262 {
263 return validateAndCall(
264 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
265 &StaNetwork::setEapPasswordInternal, _hidl_cb, password);
266 }
267
setEapCACert(const hidl_string & path,setEapCACert_cb _hidl_cb)268 Return<void> StaNetwork::setEapCACert(
269 const hidl_string &path, setEapCACert_cb _hidl_cb)
270 {
271 return validateAndCall(
272 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
273 &StaNetwork::setEapCACertInternal, _hidl_cb, path);
274 }
275
setEapCAPath(const hidl_string & path,setEapCAPath_cb _hidl_cb)276 Return<void> StaNetwork::setEapCAPath(
277 const hidl_string &path, setEapCAPath_cb _hidl_cb)
278 {
279 return validateAndCall(
280 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
281 &StaNetwork::setEapCAPathInternal, _hidl_cb, path);
282 }
283
setEapClientCert(const hidl_string & path,setEapClientCert_cb _hidl_cb)284 Return<void> StaNetwork::setEapClientCert(
285 const hidl_string &path, setEapClientCert_cb _hidl_cb)
286 {
287 return validateAndCall(
288 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
289 &StaNetwork::setEapClientCertInternal, _hidl_cb, path);
290 }
291
setEapPrivateKeyId(const hidl_string & id,setEapPrivateKeyId_cb _hidl_cb)292 Return<void> StaNetwork::setEapPrivateKeyId(
293 const hidl_string &id, setEapPrivateKeyId_cb _hidl_cb)
294 {
295 return validateAndCall(
296 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
297 &StaNetwork::setEapPrivateKeyIdInternal, _hidl_cb, id);
298 }
299
setEapSubjectMatch(const hidl_string & match,setEapSubjectMatch_cb _hidl_cb)300 Return<void> StaNetwork::setEapSubjectMatch(
301 const hidl_string &match, setEapSubjectMatch_cb _hidl_cb)
302 {
303 return validateAndCall(
304 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
305 &StaNetwork::setEapSubjectMatchInternal, _hidl_cb, match);
306 }
307
setEapAltSubjectMatch(const hidl_string & match,setEapAltSubjectMatch_cb _hidl_cb)308 Return<void> StaNetwork::setEapAltSubjectMatch(
309 const hidl_string &match, setEapAltSubjectMatch_cb _hidl_cb)
310 {
311 return validateAndCall(
312 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
313 &StaNetwork::setEapAltSubjectMatchInternal, _hidl_cb, match);
314 }
315
setEapEngine(bool enable,setEapEngine_cb _hidl_cb)316 Return<void> StaNetwork::setEapEngine(bool enable, setEapEngine_cb _hidl_cb)
317 {
318 return validateAndCall(
319 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
320 &StaNetwork::setEapEngineInternal, _hidl_cb, enable);
321 }
322
setEapEngineID(const hidl_string & id,setEapEngineID_cb _hidl_cb)323 Return<void> StaNetwork::setEapEngineID(
324 const hidl_string &id, setEapEngineID_cb _hidl_cb)
325 {
326 return validateAndCall(
327 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
328 &StaNetwork::setEapEngineIDInternal, _hidl_cb, id);
329 }
330
setEapDomainSuffixMatch(const hidl_string & match,setEapDomainSuffixMatch_cb _hidl_cb)331 Return<void> StaNetwork::setEapDomainSuffixMatch(
332 const hidl_string &match, setEapDomainSuffixMatch_cb _hidl_cb)
333 {
334 return validateAndCall(
335 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
336 &StaNetwork::setEapDomainSuffixMatchInternal, _hidl_cb, match);
337 }
338
setProactiveKeyCaching(bool enable,setProactiveKeyCaching_cb _hidl_cb)339 Return<void> StaNetwork::setProactiveKeyCaching(
340 bool enable, setProactiveKeyCaching_cb _hidl_cb)
341 {
342 return validateAndCall(
343 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
344 &StaNetwork::setProactiveKeyCachingInternal, _hidl_cb, enable);
345 }
346
setIdStr(const hidl_string & id_str,setIdStr_cb _hidl_cb)347 Return<void> StaNetwork::setIdStr(
348 const hidl_string &id_str, setIdStr_cb _hidl_cb)
349 {
350 return validateAndCall(
351 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
352 &StaNetwork::setIdStrInternal, _hidl_cb, id_str);
353 }
354
setUpdateIdentifier(uint32_t id,setUpdateIdentifier_cb _hidl_cb)355 Return<void> StaNetwork::setUpdateIdentifier(
356 uint32_t id, setUpdateIdentifier_cb _hidl_cb)
357 {
358 return validateAndCall(
359 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
360 &StaNetwork::setUpdateIdentifierInternal, _hidl_cb, id);
361 }
362
getSsid(getSsid_cb _hidl_cb)363 Return<void> StaNetwork::getSsid(getSsid_cb _hidl_cb)
364 {
365 return validateAndCall(
366 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
367 &StaNetwork::getSsidInternal, _hidl_cb);
368 }
369
getBssid(getBssid_cb _hidl_cb)370 Return<void> StaNetwork::getBssid(getBssid_cb _hidl_cb)
371 {
372 return validateAndCall(
373 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
374 &StaNetwork::getBssidInternal, _hidl_cb);
375 }
376
getScanSsid(getScanSsid_cb _hidl_cb)377 Return<void> StaNetwork::getScanSsid(getScanSsid_cb _hidl_cb)
378 {
379 return validateAndCall(
380 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
381 &StaNetwork::getScanSsidInternal, _hidl_cb);
382 }
383
getKeyMgmt(getKeyMgmt_cb _hidl_cb)384 Return<void> StaNetwork::getKeyMgmt(getKeyMgmt_cb _hidl_cb)
385 {
386 return validateAndCall(
387 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
388 &StaNetwork::getKeyMgmtInternal, _hidl_cb);
389 }
390
getProto(getProto_cb _hidl_cb)391 Return<void> StaNetwork::getProto(getProto_cb _hidl_cb)
392 {
393 return validateAndCall(
394 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
395 &StaNetwork::getProtoInternal, _hidl_cb);
396 }
397
getAuthAlg(getAuthAlg_cb _hidl_cb)398 Return<void> StaNetwork::getAuthAlg(getAuthAlg_cb _hidl_cb)
399 {
400 return validateAndCall(
401 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
402 &StaNetwork::getAuthAlgInternal, _hidl_cb);
403 }
404
getGroupCipher(getGroupCipher_cb _hidl_cb)405 Return<void> StaNetwork::getGroupCipher(getGroupCipher_cb _hidl_cb)
406 {
407 return validateAndCall(
408 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
409 &StaNetwork::getGroupCipherInternal, _hidl_cb);
410 }
411
getPairwiseCipher(getPairwiseCipher_cb _hidl_cb)412 Return<void> StaNetwork::getPairwiseCipher(getPairwiseCipher_cb _hidl_cb)
413 {
414 return validateAndCall(
415 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
416 &StaNetwork::getPairwiseCipherInternal, _hidl_cb);
417 }
418
getPskPassphrase(getPskPassphrase_cb _hidl_cb)419 Return<void> StaNetwork::getPskPassphrase(getPskPassphrase_cb _hidl_cb)
420 {
421 return validateAndCall(
422 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
423 &StaNetwork::getPskPassphraseInternal, _hidl_cb);
424 }
425
getPsk(getPsk_cb _hidl_cb)426 Return<void> StaNetwork::getPsk(getPsk_cb _hidl_cb)
427 {
428 return validateAndCall(
429 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
430 &StaNetwork::getPskInternal, _hidl_cb);
431 }
432
getWepKey(uint32_t key_idx,getWepKey_cb _hidl_cb)433 Return<void> StaNetwork::getWepKey(uint32_t key_idx, getWepKey_cb _hidl_cb)
434 {
435 return validateAndCall(
436 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
437 &StaNetwork::getWepKeyInternal, _hidl_cb, key_idx);
438 }
439
getWepTxKeyIdx(getWepTxKeyIdx_cb _hidl_cb)440 Return<void> StaNetwork::getWepTxKeyIdx(getWepTxKeyIdx_cb _hidl_cb)
441 {
442 return validateAndCall(
443 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
444 &StaNetwork::getWepTxKeyIdxInternal, _hidl_cb);
445 }
446
getRequirePmf(getRequirePmf_cb _hidl_cb)447 Return<void> StaNetwork::getRequirePmf(getRequirePmf_cb _hidl_cb)
448 {
449 return validateAndCall(
450 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
451 &StaNetwork::getRequirePmfInternal, _hidl_cb);
452 }
453
getEapMethod(getEapMethod_cb _hidl_cb)454 Return<void> StaNetwork::getEapMethod(getEapMethod_cb _hidl_cb)
455 {
456 return validateAndCall(
457 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
458 &StaNetwork::getEapMethodInternal, _hidl_cb);
459 }
460
getEapPhase2Method(getEapPhase2Method_cb _hidl_cb)461 Return<void> StaNetwork::getEapPhase2Method(getEapPhase2Method_cb _hidl_cb)
462 {
463 return validateAndCall(
464 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
465 &StaNetwork::getEapPhase2MethodInternal, _hidl_cb);
466 }
467
getEapIdentity(getEapIdentity_cb _hidl_cb)468 Return<void> StaNetwork::getEapIdentity(getEapIdentity_cb _hidl_cb)
469 {
470 return validateAndCall(
471 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
472 &StaNetwork::getEapIdentityInternal, _hidl_cb);
473 }
474
getEapAnonymousIdentity(getEapAnonymousIdentity_cb _hidl_cb)475 Return<void> StaNetwork::getEapAnonymousIdentity(
476 getEapAnonymousIdentity_cb _hidl_cb)
477 {
478 return validateAndCall(
479 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
480 &StaNetwork::getEapAnonymousIdentityInternal, _hidl_cb);
481 }
482
getEapPassword(getEapPassword_cb _hidl_cb)483 Return<void> StaNetwork::getEapPassword(getEapPassword_cb _hidl_cb)
484 {
485 return validateAndCall(
486 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
487 &StaNetwork::getEapPasswordInternal, _hidl_cb);
488 }
489
getEapCACert(getEapCACert_cb _hidl_cb)490 Return<void> StaNetwork::getEapCACert(getEapCACert_cb _hidl_cb)
491 {
492 return validateAndCall(
493 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
494 &StaNetwork::getEapCACertInternal, _hidl_cb);
495 }
496
getEapCAPath(getEapCAPath_cb _hidl_cb)497 Return<void> StaNetwork::getEapCAPath(getEapCAPath_cb _hidl_cb)
498 {
499 return validateAndCall(
500 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
501 &StaNetwork::getEapCAPathInternal, _hidl_cb);
502 }
503
getEapClientCert(getEapClientCert_cb _hidl_cb)504 Return<void> StaNetwork::getEapClientCert(getEapClientCert_cb _hidl_cb)
505 {
506 return validateAndCall(
507 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
508 &StaNetwork::getEapClientCertInternal, _hidl_cb);
509 }
510
getEapPrivateKeyId(getEapPrivateKeyId_cb _hidl_cb)511 Return<void> StaNetwork::getEapPrivateKeyId(getEapPrivateKeyId_cb _hidl_cb)
512 {
513 return validateAndCall(
514 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
515 &StaNetwork::getEapPrivateKeyIdInternal, _hidl_cb);
516 }
517
getEapSubjectMatch(getEapSubjectMatch_cb _hidl_cb)518 Return<void> StaNetwork::getEapSubjectMatch(getEapSubjectMatch_cb _hidl_cb)
519 {
520 return validateAndCall(
521 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
522 &StaNetwork::getEapSubjectMatchInternal, _hidl_cb);
523 }
524
getEapAltSubjectMatch(getEapAltSubjectMatch_cb _hidl_cb)525 Return<void> StaNetwork::getEapAltSubjectMatch(
526 getEapAltSubjectMatch_cb _hidl_cb)
527 {
528 return validateAndCall(
529 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
530 &StaNetwork::getEapAltSubjectMatchInternal, _hidl_cb);
531 }
532
getEapEngine(getEapEngine_cb _hidl_cb)533 Return<void> StaNetwork::getEapEngine(getEapEngine_cb _hidl_cb)
534 {
535 return validateAndCall(
536 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
537 &StaNetwork::getEapEngineInternal, _hidl_cb);
538 }
539
getEapEngineID(getEapEngineID_cb _hidl_cb)540 Return<void> StaNetwork::getEapEngineID(getEapEngineID_cb _hidl_cb)
541 {
542 return validateAndCall(
543 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
544 &StaNetwork::getEapEngineIDInternal, _hidl_cb);
545 }
546
getEapDomainSuffixMatch(getEapDomainSuffixMatch_cb _hidl_cb)547 Return<void> StaNetwork::getEapDomainSuffixMatch(
548 getEapDomainSuffixMatch_cb _hidl_cb)
549 {
550 return validateAndCall(
551 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
552 &StaNetwork::getEapDomainSuffixMatchInternal, _hidl_cb);
553 }
554
getIdStr(getIdStr_cb _hidl_cb)555 Return<void> StaNetwork::getIdStr(getIdStr_cb _hidl_cb)
556 {
557 return validateAndCall(
558 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
559 &StaNetwork::getIdStrInternal, _hidl_cb);
560 }
561
getWpsNfcConfigurationToken(getWpsNfcConfigurationToken_cb _hidl_cb)562 Return<void> StaNetwork::getWpsNfcConfigurationToken(
563 getWpsNfcConfigurationToken_cb _hidl_cb)
564 {
565 return validateAndCall(
566 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
567 &StaNetwork::getWpsNfcConfigurationTokenInternal, _hidl_cb);
568 }
569
enable(bool no_connect,enable_cb _hidl_cb)570 Return<void> StaNetwork::enable(bool no_connect, enable_cb _hidl_cb)
571 {
572 return validateAndCall(
573 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
574 &StaNetwork::enableInternal, _hidl_cb, no_connect);
575 }
576
disable(disable_cb _hidl_cb)577 Return<void> StaNetwork::disable(disable_cb _hidl_cb)
578 {
579 return validateAndCall(
580 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
581 &StaNetwork::disableInternal, _hidl_cb);
582 }
583
select(select_cb _hidl_cb)584 Return<void> StaNetwork::select(select_cb _hidl_cb)
585 {
586 return validateAndCall(
587 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
588 &StaNetwork::selectInternal, _hidl_cb);
589 }
590
sendNetworkEapSimGsmAuthResponse(const hidl_vec<ISupplicantStaNetwork::NetworkResponseEapSimGsmAuthParams> & vec_params,sendNetworkEapSimGsmAuthResponse_cb _hidl_cb)591 Return<void> StaNetwork::sendNetworkEapSimGsmAuthResponse(
592 const hidl_vec<ISupplicantStaNetwork::NetworkResponseEapSimGsmAuthParams>
593 &vec_params,
594 sendNetworkEapSimGsmAuthResponse_cb _hidl_cb)
595 {
596 return validateAndCall(
597 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
598 &StaNetwork::sendNetworkEapSimGsmAuthResponseInternal, _hidl_cb,
599 vec_params);
600 }
601
sendNetworkEapSimGsmAuthFailure(sendNetworkEapSimGsmAuthFailure_cb _hidl_cb)602 Return<void> StaNetwork::sendNetworkEapSimGsmAuthFailure(
603 sendNetworkEapSimGsmAuthFailure_cb _hidl_cb)
604 {
605 return validateAndCall(
606 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
607 &StaNetwork::sendNetworkEapSimGsmAuthFailureInternal, _hidl_cb);
608 }
609
sendNetworkEapSimUmtsAuthResponse(const ISupplicantStaNetwork::NetworkResponseEapSimUmtsAuthParams & params,sendNetworkEapSimUmtsAuthResponse_cb _hidl_cb)610 Return<void> StaNetwork::sendNetworkEapSimUmtsAuthResponse(
611 const ISupplicantStaNetwork::NetworkResponseEapSimUmtsAuthParams ¶ms,
612 sendNetworkEapSimUmtsAuthResponse_cb _hidl_cb)
613 {
614 return validateAndCall(
615 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
616 &StaNetwork::sendNetworkEapSimUmtsAuthResponseInternal, _hidl_cb,
617 params);
618 }
619
sendNetworkEapSimUmtsAutsResponse(const hidl_array<uint8_t,14> & auts,sendNetworkEapSimUmtsAutsResponse_cb _hidl_cb)620 Return<void> StaNetwork::sendNetworkEapSimUmtsAutsResponse(
621 const hidl_array<uint8_t, 14> &auts,
622 sendNetworkEapSimUmtsAutsResponse_cb _hidl_cb)
623 {
624 return validateAndCall(
625 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
626 &StaNetwork::sendNetworkEapSimUmtsAutsResponseInternal, _hidl_cb,
627 auts);
628 }
629
sendNetworkEapSimUmtsAuthFailure(sendNetworkEapSimUmtsAuthFailure_cb _hidl_cb)630 Return<void> StaNetwork::sendNetworkEapSimUmtsAuthFailure(
631 sendNetworkEapSimUmtsAuthFailure_cb _hidl_cb)
632 {
633 return validateAndCall(
634 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
635 &StaNetwork::sendNetworkEapSimUmtsAuthFailureInternal, _hidl_cb);
636 }
637
sendNetworkEapIdentityResponse(const hidl_vec<uint8_t> & identity,sendNetworkEapIdentityResponse_cb _hidl_cb)638 Return<void> StaNetwork::sendNetworkEapIdentityResponse(
639 const hidl_vec<uint8_t> &identity,
640 sendNetworkEapIdentityResponse_cb _hidl_cb)
641 {
642 return validateAndCall(
643 this, SupplicantStatusCode::FAILURE_NETWORK_INVALID,
644 &StaNetwork::sendNetworkEapIdentityResponseInternal, _hidl_cb,
645 identity);
646 }
647
getIdInternal()648 std::pair<SupplicantStatus, uint32_t> StaNetwork::getIdInternal()
649 {
650 return {{SupplicantStatusCode::SUCCESS, ""}, network_id_};
651 }
652
getInterfaceNameInternal()653 std::pair<SupplicantStatus, std::string> StaNetwork::getInterfaceNameInternal()
654 {
655 return {{SupplicantStatusCode::SUCCESS, ""}, ifname_};
656 }
657
getTypeInternal()658 std::pair<SupplicantStatus, IfaceType> StaNetwork::getTypeInternal()
659 {
660 return {{SupplicantStatusCode::SUCCESS, ""}, IfaceType::STA};
661 }
662
registerCallbackInternal(const sp<ISupplicantStaNetworkCallback> & callback)663 SupplicantStatus StaNetwork::registerCallbackInternal(
664 const sp<ISupplicantStaNetworkCallback> &callback)
665 {
666 HidlManager *hidl_manager = HidlManager::getInstance();
667 if (!hidl_manager ||
668 hidl_manager->addStaNetworkCallbackHidlObject(
669 ifname_, network_id_, callback)) {
670 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
671 }
672 return {SupplicantStatusCode::SUCCESS, ""};
673 }
674
setSsidInternal(const std::vector<uint8_t> & ssid)675 SupplicantStatus StaNetwork::setSsidInternal(const std::vector<uint8_t> &ssid)
676 {
677 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
678 if (ssid.size() == 0 ||
679 ssid.size() >
680 static_cast<uint32_t>(ISupplicantStaNetwork::ParamSizeLimits::
681 SSID_MAX_LEN_IN_BYTES)) {
682 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
683 }
684 if (setByteArrayFieldAndResetState(
685 ssid.data(), ssid.size(), &(wpa_ssid->ssid),
686 &(wpa_ssid->ssid_len), "ssid")) {
687 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
688 }
689 if (wpa_ssid->passphrase) {
690 wpa_config_update_psk(wpa_ssid);
691 }
692 return {SupplicantStatusCode::SUCCESS, ""};
693 }
694
setBssidInternal(const std::array<uint8_t,6> & bssid)695 SupplicantStatus StaNetwork::setBssidInternal(
696 const std::array<uint8_t, 6> &bssid)
697 {
698 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
699 int prev_bssid_set = wpa_ssid->bssid_set;
700 u8 prev_bssid[ETH_ALEN];
701 os_memcpy(prev_bssid, wpa_ssid->bssid, ETH_ALEN);
702 // Zero'ed array is used to clear out the BSSID value.
703 if (os_memcmp(bssid.data(), kZeroBssid, ETH_ALEN) == 0) {
704 wpa_ssid->bssid_set = 0;
705 wpa_printf(MSG_MSGDUMP, "BSSID any");
706 } else {
707 os_memcpy(wpa_ssid->bssid, bssid.data(), ETH_ALEN);
708 wpa_ssid->bssid_set = 1;
709 wpa_hexdump(MSG_MSGDUMP, "BSSID", wpa_ssid->bssid, ETH_ALEN);
710 }
711 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
712 if ((wpa_ssid->bssid_set != prev_bssid_set ||
713 os_memcmp(wpa_ssid->bssid, prev_bssid, ETH_ALEN) != 0)) {
714 wpas_notify_network_bssid_set_changed(wpa_s, wpa_ssid);
715 }
716 return {SupplicantStatusCode::SUCCESS, ""};
717 }
718
setScanSsidInternal(bool enable)719 SupplicantStatus StaNetwork::setScanSsidInternal(bool enable)
720 {
721 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
722 wpa_ssid->scan_ssid = enable ? 1 : 0;
723 resetInternalStateAfterParamsUpdate();
724 return {SupplicantStatusCode::SUCCESS, ""};
725 }
726
setKeyMgmtInternal(uint32_t key_mgmt_mask)727 SupplicantStatus StaNetwork::setKeyMgmtInternal(uint32_t key_mgmt_mask)
728 {
729 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
730 if (key_mgmt_mask & ~kAllowedKeyMgmtMask) {
731 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
732 }
733 wpa_ssid->key_mgmt = key_mgmt_mask;
734 wpa_printf(MSG_MSGDUMP, "key_mgmt: 0x%x", wpa_ssid->key_mgmt);
735 resetInternalStateAfterParamsUpdate();
736 return {SupplicantStatusCode::SUCCESS, ""};
737 }
738
setProtoInternal(uint32_t proto_mask)739 SupplicantStatus StaNetwork::setProtoInternal(uint32_t proto_mask)
740 {
741 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
742 if (proto_mask & ~kAllowedProtoMask) {
743 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
744 }
745 wpa_ssid->proto = proto_mask;
746 wpa_printf(MSG_MSGDUMP, "proto: 0x%x", wpa_ssid->proto);
747 resetInternalStateAfterParamsUpdate();
748 return {SupplicantStatusCode::SUCCESS, ""};
749 }
750
setAuthAlgInternal(uint32_t auth_alg_mask)751 SupplicantStatus StaNetwork::setAuthAlgInternal(uint32_t auth_alg_mask)
752 {
753 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
754 if (auth_alg_mask & ~kAllowedAuthAlgMask) {
755 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
756 }
757 wpa_ssid->auth_alg = auth_alg_mask;
758 wpa_printf(MSG_MSGDUMP, "auth_alg: 0x%x", wpa_ssid->auth_alg);
759 resetInternalStateAfterParamsUpdate();
760 return {SupplicantStatusCode::SUCCESS, ""};
761 }
762
setGroupCipherInternal(uint32_t group_cipher_mask)763 SupplicantStatus StaNetwork::setGroupCipherInternal(uint32_t group_cipher_mask)
764 {
765 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
766 if (group_cipher_mask & ~kAllowedGroupCipherMask) {
767 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
768 }
769 wpa_ssid->group_cipher = group_cipher_mask;
770 wpa_printf(MSG_MSGDUMP, "group_cipher: 0x%x", wpa_ssid->group_cipher);
771 resetInternalStateAfterParamsUpdate();
772 return {SupplicantStatusCode::SUCCESS, ""};
773 }
774
setPairwiseCipherInternal(uint32_t pairwise_cipher_mask)775 SupplicantStatus StaNetwork::setPairwiseCipherInternal(
776 uint32_t pairwise_cipher_mask)
777 {
778 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
779 if (pairwise_cipher_mask & ~kAllowedPairwisewCipherMask) {
780 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
781 }
782 wpa_ssid->pairwise_cipher = pairwise_cipher_mask;
783 wpa_printf(
784 MSG_MSGDUMP, "pairwise_cipher: 0x%x", wpa_ssid->pairwise_cipher);
785 resetInternalStateAfterParamsUpdate();
786 return {SupplicantStatusCode::SUCCESS, ""};
787 }
788
setPskPassphraseInternal(const std::string & psk)789 SupplicantStatus StaNetwork::setPskPassphraseInternal(const std::string &psk)
790 {
791 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
792 if (isPskPassphraseValid(psk)) {
793 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
794 }
795 if (wpa_ssid->passphrase &&
796 os_strlen(wpa_ssid->passphrase) == psk.size() &&
797 os_memcmp(wpa_ssid->passphrase, psk.c_str(), psk.size()) == 0) {
798 return {SupplicantStatusCode::SUCCESS, ""};
799 }
800 // Flag to indicate if raw psk is calculated or not using
801 // |wpa_config_update_psk|. Deferred if ssid not already set.
802 wpa_ssid->psk_set = 0;
803 if (setStringKeyFieldAndResetState(
804 psk.c_str(), &(wpa_ssid->passphrase), "psk passphrase")) {
805 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
806 }
807 if (wpa_ssid->ssid_len) {
808 wpa_config_update_psk(wpa_ssid);
809 }
810 return {SupplicantStatusCode::SUCCESS, ""};
811 }
812
setPskInternal(const std::array<uint8_t,32> & psk)813 SupplicantStatus StaNetwork::setPskInternal(const std::array<uint8_t, 32> &psk)
814 {
815 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
816 WPA_ASSERT(psk.size() == sizeof(wpa_ssid->psk));
817 str_clear_free(wpa_ssid->passphrase);
818 wpa_ssid->passphrase = nullptr;
819 os_memcpy(wpa_ssid->psk, psk.data(), sizeof(wpa_ssid->psk));
820 wpa_ssid->psk_set = 1;
821 resetInternalStateAfterParamsUpdate();
822 return {SupplicantStatusCode::SUCCESS, ""};
823 }
824
setWepKeyInternal(uint32_t key_idx,const std::vector<uint8_t> & wep_key)825 SupplicantStatus StaNetwork::setWepKeyInternal(
826 uint32_t key_idx, const std::vector<uint8_t> &wep_key)
827 {
828 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
829 if (key_idx >=
830 static_cast<uint32_t>(
831 ISupplicantStaNetwork::ParamSizeLimits::WEP_KEYS_MAX_NUM)) {
832 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
833 }
834 if (wep_key.size() !=
835 static_cast<uint32_t>(ISupplicantStaNetwork::ParamSizeLimits::
836 WEP40_KEY_LEN_IN_BYTES) &&
837 wep_key.size() !=
838 static_cast<uint32_t>(ISupplicantStaNetwork::ParamSizeLimits::
839 WEP104_KEY_LEN_IN_BYTES)) {
840 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
841 }
842 os_memcpy(wpa_ssid->wep_key[key_idx], wep_key.data(), wep_key.size());
843 wpa_ssid->wep_key_len[key_idx] = wep_key.size();
844 std::string msg_dump_title("wep_key" + std::to_string(key_idx));
845 wpa_hexdump_key(
846 MSG_MSGDUMP, msg_dump_title.c_str(), wpa_ssid->wep_key[key_idx],
847 wpa_ssid->wep_key_len[key_idx]);
848 resetInternalStateAfterParamsUpdate();
849 return {SupplicantStatusCode::SUCCESS, ""};
850 }
851
setWepTxKeyIdxInternal(uint32_t key_idx)852 SupplicantStatus StaNetwork::setWepTxKeyIdxInternal(uint32_t key_idx)
853 {
854 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
855 if (key_idx >=
856 static_cast<uint32_t>(
857 ISupplicantStaNetwork::ParamSizeLimits::WEP_KEYS_MAX_NUM)) {
858 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
859 }
860 wpa_ssid->wep_tx_keyidx = key_idx;
861 resetInternalStateAfterParamsUpdate();
862 return {SupplicantStatusCode::SUCCESS, ""};
863 }
864
setRequirePmfInternal(bool enable)865 SupplicantStatus StaNetwork::setRequirePmfInternal(bool enable)
866 {
867 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
868 wpa_ssid->ieee80211w =
869 enable ? MGMT_FRAME_PROTECTION_REQUIRED : NO_MGMT_FRAME_PROTECTION;
870 resetInternalStateAfterParamsUpdate();
871 return {SupplicantStatusCode::SUCCESS, ""};
872 }
873
setEapMethodInternal(ISupplicantStaNetwork::EapMethod method)874 SupplicantStatus StaNetwork::setEapMethodInternal(
875 ISupplicantStaNetwork::EapMethod method)
876 {
877 uint32_t eap_method_idx = static_cast<
878 std::underlying_type<ISupplicantStaNetwork::EapMethod>::type>(
879 method);
880 if (eap_method_idx >= kEapMethodMax) {
881 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
882 }
883
884 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
885 int retrieved_vendor, retrieved_method;
886 const char *method_str = kEapMethodStrings[eap_method_idx];
887 // This string lookup is needed to check if the device supports the
888 // corresponding EAP type.
889 retrieved_method = eap_peer_get_type(method_str, &retrieved_vendor);
890 if (retrieved_vendor == EAP_VENDOR_IETF &&
891 retrieved_method == EAP_TYPE_NONE) {
892 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
893 }
894 if (wpa_ssid->eap.eap_methods) {
895 os_free(wpa_ssid->eap.eap_methods);
896 }
897 // wpa_supplicant can support setting multiple eap methods for each
898 // network. But, this is not really used by Android. So, just adding
899 // support for setting one EAP method for each network. The additional
900 // |eap_method_type| member in the array is used to indicate the end
901 // of list.
902 wpa_ssid->eap.eap_methods =
903 (eap_method_type *)os_malloc(sizeof(eap_method_type) * 2);
904 if (!wpa_ssid->eap.eap_methods) {
905 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
906 }
907 wpa_ssid->eap.eap_methods[0].vendor = retrieved_vendor;
908 wpa_ssid->eap.eap_methods[0].method = retrieved_method;
909 wpa_ssid->eap.eap_methods[1].vendor = EAP_VENDOR_IETF;
910 wpa_ssid->eap.eap_methods[1].method = EAP_TYPE_NONE;
911
912 wpa_ssid->leap = 0;
913 wpa_ssid->non_leap = 0;
914 if (retrieved_vendor == EAP_VENDOR_IETF &&
915 retrieved_method == EAP_TYPE_LEAP) {
916 wpa_ssid->leap++;
917 } else {
918 wpa_ssid->non_leap++;
919 }
920 wpa_hexdump(
921 MSG_MSGDUMP, "eap methods", (u8 *)wpa_ssid->eap.eap_methods,
922 sizeof(eap_method_type) * 2);
923 resetInternalStateAfterParamsUpdate();
924 return {SupplicantStatusCode::SUCCESS, ""};
925 }
926
setEapPhase2MethodInternal(ISupplicantStaNetwork::EapPhase2Method method)927 SupplicantStatus StaNetwork::setEapPhase2MethodInternal(
928 ISupplicantStaNetwork::EapPhase2Method method)
929 {
930 uint32_t eap_phase2_method_idx = static_cast<
931 std::underlying_type<ISupplicantStaNetwork::EapPhase2Method>::type>(
932 method);
933 if (eap_phase2_method_idx >= kEapPhase2MethodMax) {
934 return {SupplicantStatusCode::FAILURE_ARGS_INVALID, ""};
935 }
936
937 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
938 // EAP method needs to be set for us to construct the eap
939 // phase 2 method string.
940 SupplicantStatus status;
941 ISupplicantStaNetwork::EapMethod eap_method;
942 std::tie(status, eap_method) = getEapMethodInternal();
943 if (status.code != SupplicantStatusCode::SUCCESS) {
944 return {SupplicantStatusCode::FAILURE_UNKNOWN,
945 "EAP method not set"};
946 }
947 std::string eap_phase2_str;
948 if (method == ISupplicantStaNetwork::EapPhase2Method::NONE) {
949 eap_phase2_str = "";
950 } else if (
951 eap_method == ISupplicantStaNetwork::EapMethod::TTLS &&
952 method == ISupplicantStaNetwork::EapPhase2Method::GTC) {
953 eap_phase2_str = kEapPhase2AuthEapPrefix;
954 } else {
955 eap_phase2_str = kEapPhase2AuthPrefix;
956 }
957 eap_phase2_str += kEapPhase2MethodStrings[eap_phase2_method_idx];
958 if (setStringFieldAndResetState(
959 eap_phase2_str.c_str(), &(wpa_ssid->eap.phase2),
960 "eap phase2")) {
961 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
962 }
963 return {SupplicantStatusCode::SUCCESS, ""};
964 }
965
setEapIdentityInternal(const std::vector<uint8_t> & identity)966 SupplicantStatus StaNetwork::setEapIdentityInternal(
967 const std::vector<uint8_t> &identity)
968 {
969 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
970 if (setByteArrayFieldAndResetState(
971 identity.data(), identity.size(), &(wpa_ssid->eap.identity),
972 &(wpa_ssid->eap.identity_len), "eap identity")) {
973 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
974 }
975 return {SupplicantStatusCode::SUCCESS, ""};
976 }
977
setEapAnonymousIdentityInternal(const std::vector<uint8_t> & identity)978 SupplicantStatus StaNetwork::setEapAnonymousIdentityInternal(
979 const std::vector<uint8_t> &identity)
980 {
981 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
982 if (setByteArrayFieldAndResetState(
983 identity.data(), identity.size(),
984 &(wpa_ssid->eap.anonymous_identity),
985 &(wpa_ssid->eap.anonymous_identity_len),
986 "eap anonymous_identity")) {
987 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
988 }
989 return {SupplicantStatusCode::SUCCESS, ""};
990 }
991
setEapPasswordInternal(const std::vector<uint8_t> & password)992 SupplicantStatus StaNetwork::setEapPasswordInternal(
993 const std::vector<uint8_t> &password)
994 {
995 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
996 if (setByteArrayKeyFieldAndResetState(
997 password.data(), password.size(), &(wpa_ssid->eap.password),
998 &(wpa_ssid->eap.password_len), "eap password")) {
999 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1000 }
1001 wpa_ssid->eap.flags &= ~EAP_CONFIG_FLAGS_PASSWORD_NTHASH;
1002 wpa_ssid->eap.flags &= ~EAP_CONFIG_FLAGS_EXT_PASSWORD;
1003 return {SupplicantStatusCode::SUCCESS, ""};
1004 }
1005
setEapCACertInternal(const std::string & path)1006 SupplicantStatus StaNetwork::setEapCACertInternal(const std::string &path)
1007 {
1008 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1009 if (setStringFieldAndResetState(
1010 path.c_str(), &(wpa_ssid->eap.ca_cert), "eap ca_cert")) {
1011 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1012 }
1013 return {SupplicantStatusCode::SUCCESS, ""};
1014 }
1015
setEapCAPathInternal(const std::string & path)1016 SupplicantStatus StaNetwork::setEapCAPathInternal(const std::string &path)
1017 {
1018 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1019 if (setStringFieldAndResetState(
1020 path.c_str(), &(wpa_ssid->eap.ca_path), "eap ca_path")) {
1021 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1022 }
1023 return {SupplicantStatusCode::SUCCESS, ""};
1024 }
1025
setEapClientCertInternal(const std::string & path)1026 SupplicantStatus StaNetwork::setEapClientCertInternal(const std::string &path)
1027 {
1028 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1029 if (setStringFieldAndResetState(
1030 path.c_str(), &(wpa_ssid->eap.client_cert),
1031 "eap client_cert")) {
1032 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1033 }
1034 return {SupplicantStatusCode::SUCCESS, ""};
1035 }
1036
setEapPrivateKeyIdInternal(const std::string & id)1037 SupplicantStatus StaNetwork::setEapPrivateKeyIdInternal(const std::string &id)
1038 {
1039 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1040 if (setStringFieldAndResetState(
1041 id.c_str(), &(wpa_ssid->eap.key_id), "eap key_id")) {
1042 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1043 }
1044 return {SupplicantStatusCode::SUCCESS, ""};
1045 }
1046
setEapSubjectMatchInternal(const std::string & match)1047 SupplicantStatus StaNetwork::setEapSubjectMatchInternal(
1048 const std::string &match)
1049 {
1050 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1051 if (setStringFieldAndResetState(
1052 match.c_str(), &(wpa_ssid->eap.subject_match),
1053 "eap subject_match")) {
1054 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1055 }
1056 return {SupplicantStatusCode::SUCCESS, ""};
1057 }
1058
setEapAltSubjectMatchInternal(const std::string & match)1059 SupplicantStatus StaNetwork::setEapAltSubjectMatchInternal(
1060 const std::string &match)
1061 {
1062 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1063 if (setStringFieldAndResetState(
1064 match.c_str(), &(wpa_ssid->eap.altsubject_match),
1065 "eap altsubject_match")) {
1066 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1067 }
1068 return {SupplicantStatusCode::SUCCESS, ""};
1069 }
1070
setEapEngineInternal(bool enable)1071 SupplicantStatus StaNetwork::setEapEngineInternal(bool enable)
1072 {
1073 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1074 wpa_ssid->eap.engine = enable ? 1 : 0;
1075 return {SupplicantStatusCode::SUCCESS, ""};
1076 }
1077
setEapEngineIDInternal(const std::string & id)1078 SupplicantStatus StaNetwork::setEapEngineIDInternal(const std::string &id)
1079 {
1080 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1081 if (setStringFieldAndResetState(
1082 id.c_str(), &(wpa_ssid->eap.engine_id), "eap engine_id")) {
1083 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1084 }
1085 return {SupplicantStatusCode::SUCCESS, ""};
1086 }
1087
setEapDomainSuffixMatchInternal(const std::string & match)1088 SupplicantStatus StaNetwork::setEapDomainSuffixMatchInternal(
1089 const std::string &match)
1090 {
1091 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1092 if (setStringFieldAndResetState(
1093 match.c_str(), &(wpa_ssid->eap.domain_suffix_match),
1094 "eap domain_suffix_match")) {
1095 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1096 }
1097 return {SupplicantStatusCode::SUCCESS, ""};
1098 }
1099
setProactiveKeyCachingInternal(bool enable)1100 SupplicantStatus StaNetwork::setProactiveKeyCachingInternal(bool enable)
1101 {
1102 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1103 wpa_ssid->proactive_key_caching = enable ? 1 : 0;
1104 resetInternalStateAfterParamsUpdate();
1105 return {SupplicantStatusCode::SUCCESS, ""};
1106 }
1107
setIdStrInternal(const std::string & id_str)1108 SupplicantStatus StaNetwork::setIdStrInternal(const std::string &id_str)
1109 {
1110 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1111 if (setStringFieldAndResetState(
1112 id_str.c_str(), &(wpa_ssid->id_str), "id_str")) {
1113 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1114 }
1115 return {SupplicantStatusCode::SUCCESS, ""};
1116 }
1117
setUpdateIdentifierInternal(uint32_t id)1118 SupplicantStatus StaNetwork::setUpdateIdentifierInternal(uint32_t id)
1119 {
1120 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1121 wpa_ssid->update_identifier = id;
1122 wpa_printf(
1123 MSG_MSGDUMP, "update_identifier: %d", wpa_ssid->update_identifier);
1124 resetInternalStateAfterParamsUpdate();
1125 return {SupplicantStatusCode::SUCCESS, ""};
1126 }
1127
getSsidInternal()1128 std::pair<SupplicantStatus, std::vector<uint8_t>> StaNetwork::getSsidInternal()
1129 {
1130 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1131 std::vector<uint8_t> ssid;
1132 ssid.assign(wpa_ssid->ssid, wpa_ssid->ssid + wpa_ssid->ssid_len);
1133 return {{SupplicantStatusCode::SUCCESS, ""}, std::move(ssid)};
1134 }
1135
1136 std::pair<SupplicantStatus, std::array<uint8_t, 6>>
getBssidInternal()1137 StaNetwork::getBssidInternal()
1138 {
1139 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1140 std::array<uint8_t, 6> bssid{};
1141 os_memcpy(bssid.data(), kZeroBssid, ETH_ALEN);
1142 if (wpa_ssid->bssid_set) {
1143 os_memcpy(bssid.data(), wpa_ssid->bssid, ETH_ALEN);
1144 }
1145 return {{SupplicantStatusCode::SUCCESS, ""}, std::move(bssid)};
1146 }
1147
getScanSsidInternal()1148 std::pair<SupplicantStatus, bool> StaNetwork::getScanSsidInternal()
1149 {
1150 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1151 return {{SupplicantStatusCode::SUCCESS, ""},
1152 (wpa_ssid->scan_ssid == 1)};
1153 }
1154
getKeyMgmtInternal()1155 std::pair<SupplicantStatus, uint32_t> StaNetwork::getKeyMgmtInternal()
1156 {
1157 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1158 return {{SupplicantStatusCode::SUCCESS, ""},
1159 wpa_ssid->key_mgmt & kAllowedKeyMgmtMask};
1160 }
1161
getProtoInternal()1162 std::pair<SupplicantStatus, uint32_t> StaNetwork::getProtoInternal()
1163 {
1164 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1165 return {{SupplicantStatusCode::SUCCESS, ""},
1166 wpa_ssid->proto & kAllowedProtoMask};
1167 }
1168
getAuthAlgInternal()1169 std::pair<SupplicantStatus, uint32_t> StaNetwork::getAuthAlgInternal()
1170 {
1171 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1172 return {{SupplicantStatusCode::SUCCESS, ""},
1173 wpa_ssid->auth_alg & kAllowedAuthAlgMask};
1174 }
1175
getGroupCipherInternal()1176 std::pair<SupplicantStatus, uint32_t> StaNetwork::getGroupCipherInternal()
1177 {
1178 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1179 return {{SupplicantStatusCode::SUCCESS, ""},
1180 wpa_ssid->group_cipher & kAllowedGroupCipherMask};
1181 }
1182
getPairwiseCipherInternal()1183 std::pair<SupplicantStatus, uint32_t> StaNetwork::getPairwiseCipherInternal()
1184 {
1185 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1186 return {{SupplicantStatusCode::SUCCESS, ""},
1187 wpa_ssid->pairwise_cipher & kAllowedPairwisewCipherMask};
1188 }
1189
getPskPassphraseInternal()1190 std::pair<SupplicantStatus, std::string> StaNetwork::getPskPassphraseInternal()
1191 {
1192 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1193 if (!wpa_ssid->passphrase) {
1194 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1195 }
1196 return {{SupplicantStatusCode::SUCCESS, ""}, wpa_ssid->passphrase};
1197 }
1198
1199 std::pair<SupplicantStatus, std::array<uint8_t, 32>>
getPskInternal()1200 StaNetwork::getPskInternal()
1201 {
1202 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1203 WPA_ASSERT(psk.size() == sizeof(wpa_ssid->psk));
1204 if (!wpa_ssid->psk_set) {
1205 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1206 }
1207 std::array<uint8_t, 32> psk;
1208 os_memcpy(psk.data(), wpa_ssid->psk, psk.size());
1209 return {{SupplicantStatusCode::SUCCESS, ""}, psk};
1210 }
1211
getWepKeyInternal(uint32_t key_idx)1212 std::pair<SupplicantStatus, std::vector<uint8_t>> StaNetwork::getWepKeyInternal(
1213 uint32_t key_idx)
1214 {
1215 std::vector<uint8_t> wep_key;
1216 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1217 if (key_idx >=
1218 static_cast<uint32_t>(
1219 ISupplicantStaNetwork::ParamSizeLimits::WEP_KEYS_MAX_NUM)) {
1220 return {{SupplicantStatusCode::FAILURE_ARGS_INVALID, ""},
1221 wep_key};
1222 }
1223 wep_key.assign(
1224 wpa_ssid->wep_key[key_idx],
1225 wpa_ssid->wep_key[key_idx] + wpa_ssid->wep_key_len[key_idx]);
1226 return {{SupplicantStatusCode::SUCCESS, ""}, std::move(wep_key)};
1227 }
1228
getWepTxKeyIdxInternal()1229 std::pair<SupplicantStatus, uint32_t> StaNetwork::getWepTxKeyIdxInternal()
1230 {
1231 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1232 return {{SupplicantStatusCode::SUCCESS, ""}, wpa_ssid->wep_tx_keyidx};
1233 }
1234
getRequirePmfInternal()1235 std::pair<SupplicantStatus, bool> StaNetwork::getRequirePmfInternal()
1236 {
1237 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1238 return {{SupplicantStatusCode::SUCCESS, ""},
1239 (wpa_ssid->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED)};
1240 }
1241
1242 std::pair<SupplicantStatus, ISupplicantStaNetwork::EapMethod>
getEapMethodInternal()1243 StaNetwork::getEapMethodInternal()
1244 {
1245 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1246 if (!wpa_ssid->eap.eap_methods) {
1247 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1248 }
1249 // wpa_supplicant can support setting multiple eap methods for each
1250 // network. But, this is not really used by Android. So, just reading
1251 // the first EAP method for each network.
1252 const std::string eap_method_str = eap_get_name(
1253 wpa_ssid->eap.eap_methods[0].vendor,
1254 static_cast<EapType>(wpa_ssid->eap.eap_methods[0].method));
1255 size_t eap_method_idx =
1256 std::find(
1257 std::begin(kEapMethodStrings), std::end(kEapMethodStrings),
1258 eap_method_str) -
1259 std::begin(kEapMethodStrings);
1260 if (eap_method_idx >= kEapMethodMax) {
1261 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1262 }
1263 return {{SupplicantStatusCode::SUCCESS, ""},
1264 static_cast<ISupplicantStaNetwork::EapMethod>(eap_method_idx)};
1265 }
1266
1267 std::pair<SupplicantStatus, ISupplicantStaNetwork::EapPhase2Method>
getEapPhase2MethodInternal()1268 StaNetwork::getEapPhase2MethodInternal()
1269 {
1270 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1271 if (!wpa_ssid->eap.phase2) {
1272 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1273 }
1274 const std::string eap_phase2_method_str_with_prefix =
1275 wpa_ssid->eap.phase2;
1276 std::string eap_phase2_method_str;
1277 // Strip out the phase 2 method prefix before doing a reverse lookup
1278 // of phase 2 string to the Eap Phase 2 type.
1279 if (eap_phase2_method_str_with_prefix.find(kEapPhase2AuthPrefix) == 0) {
1280 eap_phase2_method_str =
1281 eap_phase2_method_str_with_prefix.substr(
1282 strlen(kEapPhase2AuthPrefix),
1283 eap_phase2_method_str_with_prefix.size());
1284 } else if (
1285 eap_phase2_method_str_with_prefix.find(kEapPhase2AuthEapPrefix) ==
1286 0) {
1287 eap_phase2_method_str =
1288 eap_phase2_method_str_with_prefix.substr(
1289 strlen(kEapPhase2AuthEapPrefix),
1290 eap_phase2_method_str_with_prefix.size());
1291 }
1292 size_t eap_phase2_method_idx =
1293 std::find(
1294 std::begin(kEapPhase2MethodStrings),
1295 std::end(kEapPhase2MethodStrings), eap_phase2_method_str) -
1296 std::begin(kEapPhase2MethodStrings);
1297 if (eap_phase2_method_idx >= kEapPhase2MethodMax) {
1298 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1299 }
1300 return {{SupplicantStatusCode::SUCCESS, ""},
1301 static_cast<ISupplicantStaNetwork::EapPhase2Method>(
1302 eap_phase2_method_idx)};
1303 }
1304
1305 std::pair<SupplicantStatus, std::vector<uint8_t>>
getEapIdentityInternal()1306 StaNetwork::getEapIdentityInternal()
1307 {
1308 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1309 if (!wpa_ssid->eap.identity) {
1310 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1311 }
1312 return {{SupplicantStatusCode::SUCCESS, ""},
1313 std::vector<uint8_t>(
1314 wpa_ssid->eap.identity,
1315 wpa_ssid->eap.identity + wpa_ssid->eap.identity_len)};
1316 }
1317
1318 std::pair<SupplicantStatus, std::vector<uint8_t>>
getEapAnonymousIdentityInternal()1319 StaNetwork::getEapAnonymousIdentityInternal()
1320 {
1321 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1322 if (!wpa_ssid->eap.anonymous_identity) {
1323 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1324 }
1325 return {{SupplicantStatusCode::SUCCESS, ""},
1326 std::vector<uint8_t>(
1327 wpa_ssid->eap.anonymous_identity,
1328 wpa_ssid->eap.anonymous_identity +
1329 wpa_ssid->eap.anonymous_identity_len)};
1330 }
1331
1332 std::pair<SupplicantStatus, std::vector<uint8_t>>
getEapPasswordInternal()1333 StaNetwork::getEapPasswordInternal()
1334 {
1335 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1336 if (!wpa_ssid->eap.password) {
1337 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1338 }
1339 return {{SupplicantStatusCode::SUCCESS, ""},
1340 std::vector<uint8_t>(
1341 wpa_ssid->eap.password,
1342 wpa_ssid->eap.password + wpa_ssid->eap.password_len)};
1343 }
1344
getEapCACertInternal()1345 std::pair<SupplicantStatus, std::string> StaNetwork::getEapCACertInternal()
1346 {
1347 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1348 if (!wpa_ssid->eap.ca_cert) {
1349 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1350 }
1351 return {{SupplicantStatusCode::SUCCESS, ""},
1352 reinterpret_cast<char *>(wpa_ssid->eap.ca_cert)};
1353 }
1354
getEapCAPathInternal()1355 std::pair<SupplicantStatus, std::string> StaNetwork::getEapCAPathInternal()
1356 {
1357 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1358 if (!wpa_ssid->eap.ca_path) {
1359 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1360 }
1361 return {{SupplicantStatusCode::SUCCESS, ""},
1362 reinterpret_cast<char *>(wpa_ssid->eap.ca_path)};
1363 }
1364
getEapClientCertInternal()1365 std::pair<SupplicantStatus, std::string> StaNetwork::getEapClientCertInternal()
1366 {
1367 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1368 if (!wpa_ssid->eap.client_cert) {
1369 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1370 }
1371 return {{SupplicantStatusCode::SUCCESS, ""},
1372 reinterpret_cast<char *>(wpa_ssid->eap.client_cert)};
1373 }
1374
1375 std::pair<SupplicantStatus, std::string>
getEapPrivateKeyIdInternal()1376 StaNetwork::getEapPrivateKeyIdInternal()
1377 {
1378 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1379 if (!wpa_ssid->eap.key_id) {
1380 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1381 }
1382 return {{SupplicantStatusCode::SUCCESS, ""}, wpa_ssid->eap.key_id};
1383 }
1384
1385 std::pair<SupplicantStatus, std::string>
getEapSubjectMatchInternal()1386 StaNetwork::getEapSubjectMatchInternal()
1387 {
1388 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1389 if (!wpa_ssid->eap.subject_match) {
1390 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1391 }
1392 return {{SupplicantStatusCode::SUCCESS, ""},
1393 reinterpret_cast<char *>(wpa_ssid->eap.subject_match)};
1394 }
1395
1396 std::pair<SupplicantStatus, std::string>
getEapAltSubjectMatchInternal()1397 StaNetwork::getEapAltSubjectMatchInternal()
1398 {
1399 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1400 if (!wpa_ssid->eap.altsubject_match) {
1401 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1402 }
1403 return {{SupplicantStatusCode::SUCCESS, ""},
1404 reinterpret_cast<char *>(wpa_ssid->eap.altsubject_match)};
1405 }
1406
getEapEngineInternal()1407 std::pair<SupplicantStatus, bool> StaNetwork::getEapEngineInternal()
1408 {
1409 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1410 return {{SupplicantStatusCode::SUCCESS, ""}, wpa_ssid->eap.engine == 1};
1411 }
1412
getEapEngineIDInternal()1413 std::pair<SupplicantStatus, std::string> StaNetwork::getEapEngineIDInternal()
1414 {
1415 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1416 if (!wpa_ssid->eap.engine_id) {
1417 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1418 }
1419 return {{SupplicantStatusCode::SUCCESS, ""}, {wpa_ssid->eap.engine_id}};
1420 }
1421
1422 std::pair<SupplicantStatus, std::string>
getEapDomainSuffixMatchInternal()1423 StaNetwork::getEapDomainSuffixMatchInternal()
1424 {
1425 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1426 if (!wpa_ssid->eap.domain_suffix_match) {
1427 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1428 }
1429 return {{SupplicantStatusCode::SUCCESS, ""},
1430 {wpa_ssid->eap.domain_suffix_match}};
1431 }
1432
getIdStrInternal()1433 std::pair<SupplicantStatus, std::string> StaNetwork::getIdStrInternal()
1434 {
1435 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1436 if (!wpa_ssid->id_str) {
1437 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1438 }
1439 return {{SupplicantStatusCode::SUCCESS, ""}, {wpa_ssid->id_str}};
1440 }
1441
1442 std::pair<SupplicantStatus, std::vector<uint8_t>>
getWpsNfcConfigurationTokenInternal()1443 StaNetwork::getWpsNfcConfigurationTokenInternal()
1444 {
1445 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1446 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1447 auto token_buf = misc_utils::createWpaBufUniquePtr(
1448 wpas_wps_network_config_token(wpa_s, 0, wpa_ssid));
1449 if (!token_buf) {
1450 return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}};
1451 }
1452 return {{SupplicantStatusCode::SUCCESS, ""},
1453 misc_utils::convertWpaBufToVector(token_buf.get())};
1454 }
1455
enableInternal(bool no_connect)1456 SupplicantStatus StaNetwork::enableInternal(bool no_connect)
1457 {
1458 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1459 if (wpa_ssid->disabled == 2) {
1460 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1461 }
1462 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1463 if (no_connect) {
1464 wpa_ssid->disabled = 0;
1465 } else {
1466 wpa_s->scan_min_time.sec = 0;
1467 wpa_s->scan_min_time.usec = 0;
1468 wpa_supplicant_enable_network(wpa_s, wpa_ssid);
1469 }
1470 return {SupplicantStatusCode::SUCCESS, ""};
1471 }
1472
disableInternal()1473 SupplicantStatus StaNetwork::disableInternal()
1474 {
1475 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1476 if (wpa_ssid->disabled == 2) {
1477 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1478 }
1479 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1480 wpa_supplicant_disable_network(wpa_s, wpa_ssid);
1481 return {SupplicantStatusCode::SUCCESS, ""};
1482 }
1483
selectInternal()1484 SupplicantStatus StaNetwork::selectInternal()
1485 {
1486 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1487 if (wpa_ssid->disabled == 2) {
1488 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1489 }
1490 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1491 wpa_s->scan_min_time.sec = 0;
1492 wpa_s->scan_min_time.usec = 0;
1493 wpa_supplicant_select_network(wpa_s, wpa_ssid);
1494 return {SupplicantStatusCode::SUCCESS, ""};
1495 }
1496
sendNetworkEapSimGsmAuthResponseInternal(const std::vector<ISupplicantStaNetwork::NetworkResponseEapSimGsmAuthParams> & vec_params)1497 SupplicantStatus StaNetwork::sendNetworkEapSimGsmAuthResponseInternal(
1498 const std::vector<ISupplicantStaNetwork::NetworkResponseEapSimGsmAuthParams>
1499 &vec_params)
1500 {
1501 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1502 // Convert the incoming parameters to a string to pass to
1503 // wpa_supplicant.
1504 std::string ctrl_rsp_param = std::string(kNetworkEapSimGsmAuthResponse);
1505 for (const auto ¶ms : vec_params) {
1506 uint32_t kc_hex_len = params.kc.size() * 2 + 1;
1507 std::vector<char> kc_hex(kc_hex_len);
1508 uint32_t sres_hex_len = params.sres.size() * 2 + 1;
1509 std::vector<char> sres_hex(sres_hex_len);
1510 wpa_snprintf_hex(
1511 kc_hex.data(), kc_hex.size(), params.kc.data(),
1512 params.kc.size());
1513 wpa_snprintf_hex(
1514 sres_hex.data(), sres_hex.size(), params.sres.data(),
1515 params.sres.size());
1516 ctrl_rsp_param += ":" + std::string(kc_hex.data()) + ":" +
1517 std::string(sres_hex.data());
1518 }
1519 enum wpa_ctrl_req_type rtype = WPA_CTRL_REQ_SIM;
1520 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1521 if (wpa_supplicant_ctrl_rsp_handle(
1522 wpa_s, wpa_ssid, rtype, ctrl_rsp_param.c_str())) {
1523 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1524 }
1525 eapol_sm_notify_ctrl_response(wpa_s->eapol);
1526 wpa_hexdump_ascii_key(
1527 MSG_DEBUG, "network sim gsm auth response param",
1528 (const u8 *)ctrl_rsp_param.c_str(), ctrl_rsp_param.size());
1529 return {SupplicantStatusCode::SUCCESS, ""};
1530 }
1531
sendNetworkEapSimGsmAuthFailureInternal()1532 SupplicantStatus StaNetwork::sendNetworkEapSimGsmAuthFailureInternal()
1533 {
1534 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1535 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1536 enum wpa_ctrl_req_type rtype = WPA_CTRL_REQ_SIM;
1537 if (wpa_supplicant_ctrl_rsp_handle(
1538 wpa_s, wpa_ssid, rtype, kNetworkEapSimGsmAuthFailure)) {
1539 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1540 }
1541 eapol_sm_notify_ctrl_response(wpa_s->eapol);
1542 return {SupplicantStatusCode::SUCCESS, ""};
1543 }
1544
sendNetworkEapSimUmtsAuthResponseInternal(const ISupplicantStaNetwork::NetworkResponseEapSimUmtsAuthParams & params)1545 SupplicantStatus StaNetwork::sendNetworkEapSimUmtsAuthResponseInternal(
1546 const ISupplicantStaNetwork::NetworkResponseEapSimUmtsAuthParams ¶ms)
1547 {
1548 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1549 // Convert the incoming parameters to a string to pass to
1550 // wpa_supplicant.
1551 uint32_t ik_hex_len = params.ik.size() * 2 + 1;
1552 std::vector<char> ik_hex(ik_hex_len);
1553 uint32_t ck_hex_len = params.ck.size() * 2 + 1;
1554 std::vector<char> ck_hex(ck_hex_len);
1555 uint32_t res_hex_len = params.res.size() * 2 + 1;
1556 std::vector<char> res_hex(res_hex_len);
1557 wpa_snprintf_hex(
1558 ik_hex.data(), ik_hex.size(), params.ik.data(), params.ik.size());
1559 wpa_snprintf_hex(
1560 ck_hex.data(), ck_hex.size(), params.ck.data(), params.ck.size());
1561 wpa_snprintf_hex(
1562 res_hex.data(), res_hex.size(), params.res.data(),
1563 params.res.size());
1564 std::string ctrl_rsp_param =
1565 std::string(kNetworkEapSimUmtsAuthResponse) + ":" +
1566 std::string(ik_hex.data()) + ":" + std::string(ck_hex.data()) +
1567 ":" + std::string(res_hex.data());
1568 enum wpa_ctrl_req_type rtype = WPA_CTRL_REQ_SIM;
1569 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1570 if (wpa_supplicant_ctrl_rsp_handle(
1571 wpa_s, wpa_ssid, rtype, ctrl_rsp_param.c_str())) {
1572 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1573 }
1574 eapol_sm_notify_ctrl_response(wpa_s->eapol);
1575 wpa_hexdump_ascii_key(
1576 MSG_DEBUG, "network sim umts auth response param",
1577 (const u8 *)ctrl_rsp_param.c_str(), ctrl_rsp_param.size());
1578 return {SupplicantStatusCode::SUCCESS, ""};
1579 }
1580
sendNetworkEapSimUmtsAutsResponseInternal(const std::array<uint8_t,14> & auts)1581 SupplicantStatus StaNetwork::sendNetworkEapSimUmtsAutsResponseInternal(
1582 const std::array<uint8_t, 14> &auts)
1583 {
1584 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1585 uint32_t auts_hex_len = auts.size() * 2 + 1;
1586 std::vector<char> auts_hex(auts_hex_len);
1587 wpa_snprintf_hex(
1588 auts_hex.data(), auts_hex.size(), auts.data(), auts.size());
1589 std::string ctrl_rsp_param =
1590 std::string(kNetworkEapSimUmtsAutsResponse) + ":" +
1591 std::string(auts_hex.data());
1592 enum wpa_ctrl_req_type rtype = WPA_CTRL_REQ_SIM;
1593 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1594 if (wpa_supplicant_ctrl_rsp_handle(
1595 wpa_s, wpa_ssid, rtype, ctrl_rsp_param.c_str())) {
1596 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1597 }
1598 eapol_sm_notify_ctrl_response(wpa_s->eapol);
1599 wpa_hexdump_ascii_key(
1600 MSG_DEBUG, "network sim umts auts response param",
1601 (const u8 *)ctrl_rsp_param.c_str(), ctrl_rsp_param.size());
1602 return {SupplicantStatusCode::SUCCESS, ""};
1603 }
1604
sendNetworkEapSimUmtsAuthFailureInternal()1605 SupplicantStatus StaNetwork::sendNetworkEapSimUmtsAuthFailureInternal()
1606 {
1607 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1608 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1609 enum wpa_ctrl_req_type rtype = WPA_CTRL_REQ_SIM;
1610 if (wpa_supplicant_ctrl_rsp_handle(
1611 wpa_s, wpa_ssid, rtype, kNetworkEapSimUmtsAuthFailure)) {
1612 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1613 }
1614 eapol_sm_notify_ctrl_response(wpa_s->eapol);
1615 return {SupplicantStatusCode::SUCCESS, ""};
1616 }
1617
sendNetworkEapIdentityResponseInternal(const std::vector<uint8_t> & identity)1618 SupplicantStatus StaNetwork::sendNetworkEapIdentityResponseInternal(
1619 const std::vector<uint8_t> &identity)
1620 {
1621 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1622 std::string ctrl_rsp_param(identity.begin(), identity.end());
1623 enum wpa_ctrl_req_type rtype = WPA_CTRL_REQ_EAP_IDENTITY;
1624 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1625 if (wpa_supplicant_ctrl_rsp_handle(
1626 wpa_s, wpa_ssid, rtype, ctrl_rsp_param.c_str())) {
1627 return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
1628 }
1629 eapol_sm_notify_ctrl_response(wpa_s->eapol);
1630 wpa_hexdump_ascii_key(
1631 MSG_DEBUG, "network identity response param",
1632 (const u8 *)ctrl_rsp_param.c_str(), ctrl_rsp_param.size());
1633 return {SupplicantStatusCode::SUCCESS, ""};
1634 }
1635
1636 /**
1637 * Retrieve the underlying |wpa_ssid| struct pointer for
1638 * this network.
1639 * If the underlying network is removed or the interface
1640 * this network belong to
1641 * is removed, all RPC method calls on this object will
1642 * return failure.
1643 */
retrieveNetworkPtr()1644 struct wpa_ssid *StaNetwork::retrieveNetworkPtr()
1645 {
1646 wpa_supplicant *wpa_s = retrieveIfacePtr();
1647 if (!wpa_s)
1648 return nullptr;
1649 return wpa_config_get_network(wpa_s->conf, network_id_);
1650 }
1651
1652 /**
1653 * Retrieve the underlying |wpa_supplicant| struct
1654 * pointer for
1655 * this network.
1656 */
retrieveIfacePtr()1657 struct wpa_supplicant *StaNetwork::retrieveIfacePtr()
1658 {
1659 return wpa_supplicant_get_iface(wpa_global_, ifname_.c_str());
1660 }
1661
1662 /**
1663 * Check if the provided psk passhrase is valid or not.
1664 *
1665 * Returns 0 if valid, 1 otherwise.
1666 */
isPskPassphraseValid(const std::string & psk)1667 int StaNetwork::isPskPassphraseValid(const std::string &psk)
1668 {
1669 if (psk.size() <
1670 static_cast<uint32_t>(ISupplicantStaNetwork::ParamSizeLimits::
1671 PSK_PASSPHRASE_MIN_LEN_IN_BYTES) ||
1672 psk.size() >
1673 static_cast<uint32_t>(ISupplicantStaNetwork::ParamSizeLimits::
1674 PSK_PASSPHRASE_MAX_LEN_IN_BYTES)) {
1675 return 1;
1676 }
1677 if (has_ctrl_char((u8 *)psk.c_str(), psk.size())) {
1678 return 1;
1679 }
1680 return 0;
1681 }
1682
1683 /**
1684 * Reset internal wpa_supplicant state machine state
1685 * after params update (except
1686 * bssid).
1687 */
resetInternalStateAfterParamsUpdate()1688 void StaNetwork::resetInternalStateAfterParamsUpdate()
1689 {
1690 struct wpa_supplicant *wpa_s = retrieveIfacePtr();
1691 struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
1692
1693 wpa_sm_pmksa_cache_flush(wpa_s->wpa, wpa_ssid);
1694
1695 if (wpa_s->current_ssid == wpa_ssid || wpa_s->current_ssid == NULL) {
1696 /*
1697 * Invalidate the EAP session cache if
1698 * anything in the
1699 * current or previously used
1700 * configuration changes.
1701 */
1702 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1703 }
1704 }
1705
1706 /**
1707 * Helper function to set value in a string field in |wpa_ssid| structue
1708 * instance for this network.
1709 * This function frees any existing data in these fields.
1710 */
setStringFieldAndResetState(const char * value,uint8_t ** to_update_field,const char * hexdump_prefix)1711 int StaNetwork::setStringFieldAndResetState(
1712 const char *value, uint8_t **to_update_field, const char *hexdump_prefix)
1713 {
1714 return setStringFieldAndResetState(
1715 value, (char **)to_update_field, hexdump_prefix);
1716 }
1717
1718 /**
1719 * Helper function to set value in a string field in |wpa_ssid| structue
1720 * instance for this network.
1721 * This function frees any existing data in these fields.
1722 */
setStringFieldAndResetState(const char * value,char ** to_update_field,const char * hexdump_prefix)1723 int StaNetwork::setStringFieldAndResetState(
1724 const char *value, char **to_update_field, const char *hexdump_prefix)
1725 {
1726 int value_len = strlen(value);
1727 if (*to_update_field) {
1728 os_free(*to_update_field);
1729 }
1730 *to_update_field = dup_binstr(value, value_len);
1731 if (!(*to_update_field)) {
1732 return 1;
1733 }
1734 wpa_hexdump_ascii(
1735 MSG_MSGDUMP, hexdump_prefix, *to_update_field, value_len);
1736 resetInternalStateAfterParamsUpdate();
1737 return 0;
1738 }
1739
1740 /**
1741 * Helper function to set value in a string key field in |wpa_ssid| structue
1742 * instance for this network.
1743 * This function frees any existing data in these fields.
1744 */
setStringKeyFieldAndResetState(const char * value,char ** to_update_field,const char * hexdump_prefix)1745 int StaNetwork::setStringKeyFieldAndResetState(
1746 const char *value, char **to_update_field, const char *hexdump_prefix)
1747 {
1748 int value_len = strlen(value);
1749 if (*to_update_field) {
1750 str_clear_free(*to_update_field);
1751 }
1752 *to_update_field = dup_binstr(value, value_len);
1753 if (!(*to_update_field)) {
1754 return 1;
1755 }
1756 wpa_hexdump_ascii_key(
1757 MSG_MSGDUMP, hexdump_prefix, *to_update_field, value_len);
1758 resetInternalStateAfterParamsUpdate();
1759 return 0;
1760 }
1761
1762 /**
1763 * Helper function to set value in a string field with a corresponding length
1764 * field in |wpa_ssid| structue instance for this network.
1765 * This function frees any existing data in these fields.
1766 */
setByteArrayFieldAndResetState(const uint8_t * value,const size_t value_len,uint8_t ** to_update_field,size_t * to_update_field_len,const char * hexdump_prefix)1767 int StaNetwork::setByteArrayFieldAndResetState(
1768 const uint8_t *value, const size_t value_len, uint8_t **to_update_field,
1769 size_t *to_update_field_len, const char *hexdump_prefix)
1770 {
1771 if (*to_update_field) {
1772 os_free(*to_update_field);
1773 }
1774 *to_update_field = (uint8_t *)os_malloc(value_len);
1775 if (!(*to_update_field)) {
1776 return 1;
1777 }
1778 os_memcpy(*to_update_field, value, value_len);
1779 *to_update_field_len = value_len;
1780
1781 wpa_hexdump_ascii(
1782 MSG_MSGDUMP, hexdump_prefix, *to_update_field,
1783 *to_update_field_len);
1784 resetInternalStateAfterParamsUpdate();
1785 return 0;
1786 }
1787
1788 /**
1789 * Helper function to set value in a string key field with a corresponding
1790 * length field in |wpa_ssid| structue instance for this network.
1791 * This function frees any existing data in these fields.
1792 */
setByteArrayKeyFieldAndResetState(const uint8_t * value,const size_t value_len,uint8_t ** to_update_field,size_t * to_update_field_len,const char * hexdump_prefix)1793 int StaNetwork::setByteArrayKeyFieldAndResetState(
1794 const uint8_t *value, const size_t value_len, uint8_t **to_update_field,
1795 size_t *to_update_field_len, const char *hexdump_prefix)
1796 {
1797 if (*to_update_field) {
1798 bin_clear_free(*to_update_field, *to_update_field_len);
1799 }
1800 *to_update_field = (uint8_t *)os_malloc(value_len);
1801 if (!(*to_update_field)) {
1802 return 1;
1803 }
1804 os_memcpy(*to_update_field, value, value_len);
1805 *to_update_field_len = value_len;
1806
1807 wpa_hexdump_ascii_key(
1808 MSG_MSGDUMP, hexdump_prefix, *to_update_field,
1809 *to_update_field_len);
1810 resetInternalStateAfterParamsUpdate();
1811 return 0;
1812 }
1813
1814 } // namespace implementation
1815 } // namespace V1_0
1816 } // namespace wifi
1817 } // namespace supplicant
1818 } // namespace hardware
1819 } // namespace android
1820