1 /*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <VtsCoreUtil.h>
18 #include <aidl/Gtest.h>
19 #include <aidl/Vintf.h>
20 #include <aidl/android/hardware/wifi/supplicant/BnSupplicant.h>
21 #include <aidl/android/hardware/wifi/supplicant/BnSupplicantStaNetworkCallback.h>
22 #include <aidl/android/hardware/wifi/supplicant/TlsVersion.h>
23 #include <android/binder_manager.h>
24 #include <android/binder_status.h>
25 #include <binder/IServiceManager.h>
26 #include <binder/ProcessState.h>
27 #include <cutils/properties.h>
28
29 #include "supplicant_test_utils.h"
30 #include "wifi_aidl_test_utils.h"
31
32 using aidl::android::hardware::wifi::supplicant::AuthAlgMask;
33 using aidl::android::hardware::wifi::supplicant::BnSupplicantStaNetworkCallback;
34 using aidl::android::hardware::wifi::supplicant::DebugLevel;
35 using aidl::android::hardware::wifi::supplicant::DppConnectionKeys;
36 using aidl::android::hardware::wifi::supplicant::EapMethod;
37 using aidl::android::hardware::wifi::supplicant::EapPhase2Method;
38 using aidl::android::hardware::wifi::supplicant::GroupCipherMask;
39 using aidl::android::hardware::wifi::supplicant::GroupMgmtCipherMask;
40 using aidl::android::hardware::wifi::supplicant::IfaceType;
41 using aidl::android::hardware::wifi::supplicant::ISupplicant;
42 using aidl::android::hardware::wifi::supplicant::ISupplicantStaIface;
43 using aidl::android::hardware::wifi::supplicant::ISupplicantStaNetwork;
44 using aidl::android::hardware::wifi::supplicant::KeyMgmtMask;
45 using aidl::android::hardware::wifi::supplicant::
46 NetworkRequestEapSimGsmAuthParams;
47 using aidl::android::hardware::wifi::supplicant::
48 NetworkRequestEapSimUmtsAuthParams;
49 using aidl::android::hardware::wifi::supplicant::
50 NetworkResponseEapSimGsmAuthParams;
51 using aidl::android::hardware::wifi::supplicant::
52 NetworkResponseEapSimUmtsAuthParams;
53 using aidl::android::hardware::wifi::supplicant::OcspType;
54 using aidl::android::hardware::wifi::supplicant::PairwiseCipherMask;
55 using aidl::android::hardware::wifi::supplicant::ProtoMask;
56 using aidl::android::hardware::wifi::supplicant::SaeH2eMode;
57 using aidl::android::hardware::wifi::supplicant::TlsVersion;
58 using aidl::android::hardware::wifi::supplicant::TransitionDisableIndication;
59 using aidl::android::hardware::wifi::supplicant::WpaDriverCapabilitiesMask;
60 using android::ProcessState;
61
62 namespace {
63 const std::vector<uint8_t> kTestIdentity = {0x45, 0x67, 0x98, 0x67, 0x56};
64 const std::vector<uint8_t> kTestEncryptedIdentity = {0x35, 0x37, 0x58, 0x57,
65 0x26};
66 const std::string kTestSsidStr = "TestSsid1234";
67 const std::vector<uint8_t> kTestSsid =
68 std::vector<uint8_t>(kTestSsidStr.begin(), kTestSsidStr.end());
69 const std::vector<uint8_t> kTestBssid = {0x56, 0x67, 0x67, 0xf4, 0x56, 0x92};
70 const std::string kTestPskPassphrase =
71 "\"123456780abcdef0123456780abcdef0deadbeef\"";
72 const std::string kTestEapCert = "keystore://CERT";
73 const std::string kTestEapMatch = "match";
74 const KeyMgmtMask kTestKeyMgmt =
75 static_cast<KeyMgmtMask>(static_cast<uint32_t>(KeyMgmtMask::WPA_PSK) |
76 static_cast<uint32_t>(KeyMgmtMask::WPA_EAP));
77 const auto& kTestVendorData = generateOuiKeyedDataList(5);
78
79 } // namespace
80
81 class SupplicantStaNetworkCallback : public BnSupplicantStaNetworkCallback {
82 public:
83 SupplicantStaNetworkCallback() = default;
84
onNetworkEapIdentityRequest()85 ::ndk::ScopedAStatus onNetworkEapIdentityRequest() override {
86 return ndk::ScopedAStatus::ok();
87 }
onNetworkEapSimGsmAuthRequest(const NetworkRequestEapSimGsmAuthParams &)88 ::ndk::ScopedAStatus onNetworkEapSimGsmAuthRequest(
89 const NetworkRequestEapSimGsmAuthParams& /* params */) override {
90 return ndk::ScopedAStatus::ok();
91 }
onNetworkEapSimUmtsAuthRequest(const NetworkRequestEapSimUmtsAuthParams &)92 ::ndk::ScopedAStatus onNetworkEapSimUmtsAuthRequest(
93 const NetworkRequestEapSimUmtsAuthParams& /* params */) override {
94 return ndk::ScopedAStatus::ok();
95 }
onTransitionDisable(TransitionDisableIndication)96 ::ndk::ScopedAStatus onTransitionDisable(
97 TransitionDisableIndication /* ind */) override {
98 return ndk::ScopedAStatus::ok();
99 }
onServerCertificateAvailable(int32_t,const std::vector<uint8_t> &,const std::vector<uint8_t> &,const std::vector<uint8_t> &)100 ::ndk::ScopedAStatus onServerCertificateAvailable(
101 int32_t /* depth */, const std::vector<uint8_t>& /* subject */,
102 const std::vector<uint8_t>& /* certHash */,
103 const std::vector<uint8_t>& /* certBlob */) override {
104 return ndk::ScopedAStatus::ok();
105 }
onPermanentIdReqDenied()106 ::ndk::ScopedAStatus onPermanentIdReqDenied() override { return ndk::ScopedAStatus::ok(); }
107 };
108
109 class SupplicantStaNetworkAidlTest
110 : public testing::TestWithParam<std::string> {
111 public:
SetUp()112 void SetUp() override {
113 initializeService();
114 supplicant_ = getSupplicant(GetParam().c_str());
115 ASSERT_NE(supplicant_, nullptr);
116 ASSERT_TRUE(supplicant_->getInterfaceVersion(&interface_version_).isOk());
117 ASSERT_TRUE(supplicant_
118 ->setDebugParams(DebugLevel::EXCESSIVE,
119 true, // show timestamps
120 true)
121 .isOk());
122 EXPECT_TRUE(supplicant_->getStaInterface(getStaIfaceName(), &sta_iface_)
123 .isOk());
124 ASSERT_NE(sta_iface_, nullptr);
125 EXPECT_TRUE(sta_iface_->addNetwork(&sta_network_).isOk());
126 ASSERT_NE(sta_network_, nullptr);
127 }
128
TearDown()129 void TearDown() override {
130 stopSupplicantService();
131 startWifiFramework();
132 }
133
134 protected:
135 std::shared_ptr<ISupplicant> supplicant_;
136 std::shared_ptr<ISupplicantStaIface> sta_iface_;
137 std::shared_ptr<ISupplicantStaNetwork> sta_network_;
138 int interface_version_;
139
removeNetwork()140 void removeNetwork() {
141 ASSERT_NE(sta_iface_, nullptr);
142 int32_t net_id;
143 EXPECT_TRUE(sta_network_->getId(&net_id).isOk());
144 EXPECT_TRUE(sta_iface_->removeNetwork(net_id).isOk());
145 }
146 };
147
148 /*
149 * RegisterCallback
150 */
TEST_P(SupplicantStaNetworkAidlTest,RegisterCallback)151 TEST_P(SupplicantStaNetworkAidlTest, RegisterCallback) {
152 std::shared_ptr<SupplicantStaNetworkCallback> callback =
153 ndk::SharedRefBase::make<SupplicantStaNetworkCallback>();
154 ASSERT_NE(callback, nullptr);
155 EXPECT_TRUE(sta_network_->registerCallback(callback).isOk());
156 }
157
158 /*
159 * GetInterfaceName
160 */
TEST_P(SupplicantStaNetworkAidlTest,GetInterfaceName)161 TEST_P(SupplicantStaNetworkAidlTest, GetInterfaceName) {
162 std::string name;
163 EXPECT_TRUE(sta_network_->getInterfaceName(&name).isOk());
164 EXPECT_NE(name.size(), 0);
165 }
166
167 /*
168 * GetType
169 */
TEST_P(SupplicantStaNetworkAidlTest,GetType)170 TEST_P(SupplicantStaNetworkAidlTest, GetType) {
171 IfaceType type;
172 EXPECT_TRUE(sta_network_->getType(&type).isOk());
173 EXPECT_EQ(type, IfaceType::STA);
174 }
175
176 /*
177 * Set/Get ScanSsid
178 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetScanSsid)179 TEST_P(SupplicantStaNetworkAidlTest, SetGetScanSsid) {
180 bool scanSsid = false;
181 EXPECT_TRUE(sta_network_->setScanSsid(true).isOk());
182 EXPECT_TRUE(sta_network_->getScanSsid(&scanSsid).isOk());
183 EXPECT_TRUE(scanSsid);
184 }
185
186 /*
187 * Set/Get RequirePmf
188 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetRequirePmf)189 TEST_P(SupplicantStaNetworkAidlTest, SetGetRequirePmf) {
190 bool requirePmf = false;
191 EXPECT_TRUE(sta_network_->setRequirePmf(true).isOk());
192 EXPECT_TRUE(sta_network_->getRequirePmf(&requirePmf).isOk());
193 EXPECT_TRUE(requirePmf);
194 }
195
196 /*
197 * Set/Get IdStr
198 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetIdStr)199 TEST_P(SupplicantStaNetworkAidlTest, SetGetIdStr) {
200 const std::string savedIdStr = "TestIdstr";
201 EXPECT_TRUE(sta_network_->setIdStr(savedIdStr).isOk());
202
203 std::string retrievedIdStr;
204 EXPECT_TRUE(sta_network_->getIdStr(&retrievedIdStr).isOk());
205 EXPECT_EQ(retrievedIdStr, savedIdStr);
206 }
207
208 /*
209 * Set/Get EapMethod
210 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapMethod)211 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapMethod) {
212 const EapMethod savedMethod = EapMethod::PEAP;
213 EXPECT_TRUE(sta_network_->setEapMethod(savedMethod).isOk());
214
215 EapMethod retrievedMethod;
216 EXPECT_TRUE(sta_network_->getEapMethod(&retrievedMethod).isOk());
217 EXPECT_EQ(retrievedMethod, savedMethod);
218 }
219
220 /*
221 * Set/Get EapPhase2Method
222 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapPhase2Method)223 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapPhase2Method) {
224 const EapMethod savedEapMethod = EapMethod::PEAP;
225 EXPECT_TRUE(sta_network_->setEapMethod(savedEapMethod).isOk());
226
227 const EapPhase2Method savedPhase2Method = EapPhase2Method::NONE;
228 EXPECT_TRUE(sta_network_->setEapPhase2Method(savedPhase2Method).isOk());
229
230 EapPhase2Method retrievedMethod;
231 EXPECT_TRUE(sta_network_->getEapPhase2Method(&retrievedMethod).isOk());
232 EXPECT_EQ(retrievedMethod, savedPhase2Method);
233 }
234
235 /*
236 * Set/Get EapIdentity
237 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapIdentity)238 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapIdentity) {
239 EXPECT_TRUE(sta_network_->setEapIdentity(kTestIdentity).isOk());
240
241 std::vector<uint8_t> retrievedIdentity;
242 EXPECT_TRUE(sta_network_->getEapIdentity(&retrievedIdentity).isOk());
243 EXPECT_EQ(retrievedIdentity, kTestIdentity);
244 }
245
246 /*
247 * Set/Get EapAnonymousIdentity
248 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapAnonymousIdentity)249 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapAnonymousIdentity) {
250 EXPECT_TRUE(sta_network_->setEapAnonymousIdentity(kTestIdentity).isOk());
251
252 std::vector<uint8_t> retrievedIdentity;
253 EXPECT_TRUE(
254 sta_network_->getEapAnonymousIdentity(&retrievedIdentity).isOk());
255 EXPECT_EQ(retrievedIdentity, kTestIdentity);
256 }
257
258 /*
259 * Set/Get EapPassword
260 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapPassword)261 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapPassword) {
262 const std::string eapPasswdStr = "TestEapPasswd1234";
263 const std::vector<uint8_t> savedEapPasswd =
264 std::vector<uint8_t>(eapPasswdStr.begin(), eapPasswdStr.end());
265 ASSERT_TRUE(sta_network_->setEapPassword(savedEapPasswd).isOk());
266
267 std::vector<uint8_t> retrievedEapPasswd;
268 ASSERT_TRUE(sta_network_->getEapPassword(&retrievedEapPasswd).isOk());
269 ASSERT_EQ(retrievedEapPasswd, savedEapPasswd);
270 }
271
272 /*
273 * Set/Get EapCACert
274 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapCACert)275 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapCACert) {
276 EXPECT_TRUE(sta_network_->setEapCACert(kTestEapCert).isOk());
277
278 std::string retrievedCert;
279 EXPECT_TRUE(sta_network_->getEapCACert(&retrievedCert).isOk());
280 EXPECT_EQ(retrievedCert, kTestEapCert);
281 }
282
283 /*
284 * Set/Get EapCAPath
285 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapCAPath)286 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapCAPath) {
287 EXPECT_TRUE(sta_network_->setEapCAPath(kTestEapCert).isOk());
288
289 std::string retrievedCert;
290 EXPECT_TRUE(sta_network_->getEapCAPath(&retrievedCert).isOk());
291 EXPECT_EQ(retrievedCert, kTestEapCert);
292 }
293
294 /*
295 * Set/Get EapClientCert
296 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapClientCert)297 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapClientCert) {
298 EXPECT_TRUE(sta_network_->setEapClientCert(kTestEapCert).isOk());
299
300 std::string retrievedCert;
301 EXPECT_TRUE(sta_network_->getEapClientCert(&retrievedCert).isOk());
302 EXPECT_EQ(retrievedCert, kTestEapCert);
303 }
304
305 /*
306 * Set/Get EapPrivateKeyId
307 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapPrivateKeyId)308 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapPrivateKeyId) {
309 std::string savedKeyId = "key_id";
310 EXPECT_TRUE(sta_network_->setEapPrivateKeyId(savedKeyId).isOk());
311
312 std::string retrievedKeyId;
313 EXPECT_TRUE(sta_network_->getEapPrivateKeyId(&retrievedKeyId).isOk());
314 EXPECT_EQ(retrievedKeyId, savedKeyId);
315 }
316
317 /*
318 * Set/Get EapAltSubjectMatch
319 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapAltSubjectMatch)320 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapAltSubjectMatch) {
321 EXPECT_TRUE(sta_network_->setEapAltSubjectMatch(kTestEapMatch).isOk());
322
323 std::string retrievedMatch;
324 EXPECT_TRUE(sta_network_->getEapAltSubjectMatch(&retrievedMatch).isOk());
325 EXPECT_EQ(retrievedMatch, kTestEapMatch);
326 }
327
328 /*
329 * Set/Get EapSubjectMatch
330 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapSubjectMatch)331 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapSubjectMatch) {
332 EXPECT_TRUE(sta_network_->setEapSubjectMatch(kTestEapMatch).isOk());
333
334 std::string retrievedMatch;
335 EXPECT_TRUE(sta_network_->getEapSubjectMatch(&retrievedMatch).isOk());
336 EXPECT_EQ(retrievedMatch, kTestEapMatch);
337 }
338
339 /*
340 * Set/Get EapDomainSuffixMatch
341 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapDomainSuffixMatch)342 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapDomainSuffixMatch) {
343 EXPECT_TRUE(sta_network_->setEapDomainSuffixMatch(kTestEapMatch).isOk());
344
345 std::string retrievedMatch;
346 EXPECT_TRUE(sta_network_->getEapDomainSuffixMatch(&retrievedMatch).isOk());
347 EXPECT_EQ(retrievedMatch, kTestEapMatch);
348 }
349
350 /*
351 * Set/Get EapEngine
352 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapEngine)353 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapEngine) {
354 bool retrievedEapEngine = false;
355 EXPECT_TRUE(sta_network_->setEapEngine(true).isOk());
356 EXPECT_TRUE(sta_network_->getEapEngine(&retrievedEapEngine).isOk());
357 EXPECT_TRUE(retrievedEapEngine);
358 }
359
360 /*
361 * Set/Get EapEngineID
362 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEapEngineId)363 TEST_P(SupplicantStaNetworkAidlTest, SetGetEapEngineId) {
364 const std::string savedEngineId = "engine_id";
365 EXPECT_TRUE(sta_network_->setEapEngineID(savedEngineId).isOk());
366
367 std::string retrievedId;
368 EXPECT_TRUE(sta_network_->getEapEngineId(&retrievedId).isOk());
369 EXPECT_EQ(retrievedId, savedEngineId);
370 }
371
372 /*
373 * Set/Get Ocsp
374 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetOcsp)375 TEST_P(SupplicantStaNetworkAidlTest, SetGetOcsp) {
376 const OcspType savedOcspType = OcspType::REQUEST_CERT_STATUS;
377 EXPECT_TRUE(sta_network_->setOcsp(savedOcspType).isOk());
378
379 const OcspType invalidOcspType = static_cast<OcspType>(-1);
380 EXPECT_FALSE(sta_network_->setOcsp(invalidOcspType).isOk());
381
382 OcspType retrievedOcspType;
383 EXPECT_TRUE(sta_network_->getOcsp(&retrievedOcspType).isOk());
384 EXPECT_EQ(retrievedOcspType, savedOcspType);
385 }
386
387 /*
388 * Set/Get KeyMgmt
389 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetKeyMgmt)390 TEST_P(SupplicantStaNetworkAidlTest, SetGetKeyMgmt) {
391 KeyMgmtMask savedKeyMgmt = KeyMgmtMask::WAPI_PSK;
392 EXPECT_TRUE(sta_network_->setKeyMgmt(savedKeyMgmt).isOk());
393
394 KeyMgmtMask retrievedKeyMgmt;
395 EXPECT_TRUE(sta_network_->getKeyMgmt(&retrievedKeyMgmt).isOk());
396 EXPECT_EQ(retrievedKeyMgmt, savedKeyMgmt);
397
398 savedKeyMgmt = KeyMgmtMask::WAPI_CERT;
399 EXPECT_TRUE(sta_network_->setKeyMgmt(savedKeyMgmt).isOk());
400
401 EXPECT_TRUE(sta_network_->getKeyMgmt(&retrievedKeyMgmt).isOk());
402 EXPECT_EQ(retrievedKeyMgmt, savedKeyMgmt);
403 }
404
405 /*
406 * Set/Get Proto
407 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetProto)408 TEST_P(SupplicantStaNetworkAidlTest, SetGetProto) {
409 const ProtoMask savedProto = ProtoMask::WAPI;
410 EXPECT_TRUE(sta_network_->setProto(savedProto).isOk());
411
412 ProtoMask retrievedProto;
413 EXPECT_TRUE(sta_network_->getProto(&retrievedProto).isOk());
414 EXPECT_EQ(retrievedProto, savedProto);
415 }
416
417 /*
418 * Set/Get GroupCipher
419 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetGroupCipher)420 TEST_P(SupplicantStaNetworkAidlTest, SetGetGroupCipher) {
421 const GroupCipherMask savedCipher = GroupCipherMask::SMS4;
422 EXPECT_TRUE(sta_network_->setGroupCipher(savedCipher).isOk());
423
424 GroupCipherMask retrievedCipher;
425 EXPECT_TRUE(sta_network_->getGroupCipher(&retrievedCipher).isOk());
426 EXPECT_EQ(retrievedCipher, savedCipher);
427 }
428
429 /*
430 * Set/Get PairwiseCipher
431 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetPairwiseCipher)432 TEST_P(SupplicantStaNetworkAidlTest, SetGetPairwiseCipher) {
433 const PairwiseCipherMask savedCipher = PairwiseCipherMask::SMS4;
434 EXPECT_TRUE(sta_network_->setPairwiseCipher(savedCipher).isOk());
435
436 PairwiseCipherMask retrievedCipher;
437 EXPECT_TRUE(sta_network_->getPairwiseCipher(&retrievedCipher).isOk());
438 EXPECT_EQ(retrievedCipher, savedCipher);
439 }
440
441 /*
442 * Set/Get WapiCertSuite
443 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetWapiCertSuite)444 TEST_P(SupplicantStaNetworkAidlTest, SetGetWapiCertSuite) {
445 if (!keyMgmtSupported(sta_iface_, KeyMgmtMask::WAPI_PSK)) {
446 GTEST_SKIP() << "Skipping test since WAPI is not supported.";
447 }
448
449 const std::string savedCertSuite = "suite";
450 EXPECT_TRUE(sta_network_->setWapiCertSuite(savedCertSuite).isOk());
451
452 std::string retrievedCertSuite;
453 EXPECT_TRUE(sta_network_->getWapiCertSuite(&retrievedCertSuite).isOk());
454 EXPECT_EQ(retrievedCertSuite, savedCertSuite);
455 }
456
457 /*
458 * Set/Get WapiPsk
459 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetWapiPsk)460 TEST_P(SupplicantStaNetworkAidlTest, SetGetWapiPsk) {
461 if (!keyMgmtSupported(sta_iface_, KeyMgmtMask::WAPI_PSK)) {
462 GTEST_SKIP() << "Skipping test since WAPI is not supported.";
463 }
464
465 EXPECT_TRUE(sta_network_->setKeyMgmt(KeyMgmtMask::WAPI_PSK).isOk());
466 EXPECT_TRUE(sta_network_->setPskPassphrase(kTestPskPassphrase).isOk());
467
468 std::string retrievedPassphrase;
469 EXPECT_TRUE(sta_network_->getPskPassphrase(&retrievedPassphrase).isOk());
470 EXPECT_EQ(retrievedPassphrase, kTestPskPassphrase);
471
472 const std::string pskHex = "12345678";
473 EXPECT_TRUE(sta_network_->setPskPassphrase(pskHex).isOk());
474
475 EXPECT_TRUE(sta_network_->getPskPassphrase(&retrievedPassphrase).isOk());
476 EXPECT_EQ(retrievedPassphrase, pskHex);
477 }
478
479 /*
480 * Set/Get SaePassword
481 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetSaePassword)482 TEST_P(SupplicantStaNetworkAidlTest, SetGetSaePassword) {
483 const std::string savedPassword = "topsecret";
484 EXPECT_TRUE(sta_network_->setSaePassword(savedPassword).isOk());
485
486 std::string retrievedPassword;
487 EXPECT_TRUE(sta_network_->getSaePassword(&retrievedPassword).isOk());
488 EXPECT_EQ(retrievedPassword, savedPassword);
489 }
490
491 /*
492 * Set/Get SaePasswordId
493 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetSaePasswordId)494 TEST_P(SupplicantStaNetworkAidlTest, SetGetSaePasswordId) {
495 const std::string savedPasswdId = "id1";
496 EXPECT_TRUE(sta_network_->setSaePasswordId(savedPasswdId).isOk());
497
498 std::string retrievedPasswdId;
499 EXPECT_TRUE(sta_network_->getSaePasswordId(&retrievedPasswdId).isOk());
500 EXPECT_EQ(retrievedPasswdId, savedPasswdId);
501 }
502
503 /*
504 * Set/Get GroupMgmtCipher
505 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetGroupMgmtCipher)506 TEST_P(SupplicantStaNetworkAidlTest, SetGetGroupMgmtCipher) {
507 const GroupMgmtCipherMask savedCipher = GroupMgmtCipherMask::BIP_GMAC_256;
508 EXPECT_TRUE(sta_network_->setGroupMgmtCipher(savedCipher).isOk());
509
510 GroupMgmtCipherMask retrievedCipher;
511 EXPECT_TRUE(sta_network_->getGroupMgmtCipher(&retrievedCipher).isOk());
512 EXPECT_EQ(retrievedCipher, savedCipher);
513 }
514
515 /*
516 * Set/Get Ssid
517 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetSsid)518 TEST_P(SupplicantStaNetworkAidlTest, SetGetSsid) {
519 EXPECT_TRUE(sta_network_->setSsid(kTestSsid).isOk());
520
521 std::vector<uint8_t> retrievedSsid;
522 EXPECT_TRUE(sta_network_->getSsid(&retrievedSsid).isOk());
523 EXPECT_EQ(retrievedSsid, kTestSsid);
524 }
525
526 /*
527 * Set/Get Bssid
528 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetBssid)529 TEST_P(SupplicantStaNetworkAidlTest, SetGetBssid) {
530 EXPECT_TRUE(sta_network_->setBssid(kTestBssid).isOk());
531
532 std::vector<uint8_t> retrievedBssid;
533 EXPECT_TRUE(sta_network_->getBssid(&retrievedBssid).isOk());
534 EXPECT_EQ(retrievedBssid, kTestBssid);
535 }
536
537 /*
538 * Set/Get KeyAuthAlg
539 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetAuthAlg)540 TEST_P(SupplicantStaNetworkAidlTest, SetGetAuthAlg) {
541 const AuthAlgMask savedAlg =
542 static_cast<AuthAlgMask>(static_cast<uint32_t>(AuthAlgMask::OPEN) |
543 static_cast<uint32_t>(AuthAlgMask::SHARED));
544 EXPECT_TRUE(sta_network_->setAuthAlg(savedAlg).isOk());
545
546 AuthAlgMask retrievedAlg;
547 EXPECT_TRUE(sta_network_->getAuthAlg(&retrievedAlg).isOk());
548 EXPECT_EQ(retrievedAlg, savedAlg);
549 }
550
551 /*
552 * Set/Get WepTxKeyIdx
553 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetWepTxKeyIdx)554 TEST_P(SupplicantStaNetworkAidlTest, SetGetWepTxKeyIdx) {
555 const int32_t savedKeyIdx = 2;
556 EXPECT_TRUE(sta_network_->setWepTxKeyIdx(savedKeyIdx).isOk());
557
558 int32_t retrievedKeyIdx;
559 EXPECT_TRUE(sta_network_->getWepTxKeyIdx(&retrievedKeyIdx).isOk());
560 EXPECT_EQ(retrievedKeyIdx, savedKeyIdx);
561 }
562
563 /*
564 * Set SAE H2E (Hash-to-Element) mode
565 */
TEST_P(SupplicantStaNetworkAidlTest,SetSaeH2eMode)566 TEST_P(SupplicantStaNetworkAidlTest, SetSaeH2eMode) {
567 EXPECT_TRUE(sta_network_->setSaeH2eMode(SaeH2eMode::DISABLED).isOk());
568 EXPECT_TRUE(sta_network_->setSaeH2eMode(SaeH2eMode::H2E_MANDATORY).isOk());
569 EXPECT_TRUE(sta_network_->setSaeH2eMode(SaeH2eMode::H2E_OPTIONAL).isOk());
570 }
571
572 /*
573 * Set/Get Psk
574 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetPsk)575 TEST_P(SupplicantStaNetworkAidlTest, SetGetPsk) {
576 const std::vector<uint8_t> savedPsk = std::vector<uint8_t>(32, 0x12);
577 EXPECT_TRUE(sta_network_->setPsk(savedPsk).isOk());
578
579 std::vector<uint8_t> retrievedPsk;
580 EXPECT_TRUE(sta_network_->getPsk(&retrievedPsk).isOk());
581 EXPECT_EQ(retrievedPsk, savedPsk);
582 }
583
584 /*
585 * Set/Get WepKeys
586 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetWepKeys)587 TEST_P(SupplicantStaNetworkAidlTest, SetGetWepKeys) {
588 const uint32_t maxKeys = 4;
589 const std::vector<uint8_t> testWepKey = {0x56, 0x67, 0x67, 0xf4, 0x56};
590
591 for (uint32_t i = 0; i < maxKeys; i++) {
592 std::vector<uint8_t> retrievedKey;
593 EXPECT_TRUE(sta_network_->setWepKey(i, testWepKey).isOk());
594 EXPECT_TRUE(sta_network_->getWepKey(i, &retrievedKey).isOk());
595 EXPECT_EQ(retrievedKey, testWepKey);
596 }
597 }
598
599 /*
600 * SetPmkCacheEntry
601 */
TEST_P(SupplicantStaNetworkAidlTest,SetPmkCache)602 TEST_P(SupplicantStaNetworkAidlTest, SetPmkCache) {
603 const std::vector<uint8_t> serializedEntry(128, 0);
604 EXPECT_TRUE(sta_network_->setPmkCache(serializedEntry).isOk());
605 }
606
607 /*
608 * SetEapErp
609 */
TEST_P(SupplicantStaNetworkAidlTest,SetEapErp)610 TEST_P(SupplicantStaNetworkAidlTest, SetEapErp) {
611 if (!isFilsSupported(sta_iface_)) {
612 GTEST_SKIP()
613 << "Skipping test since driver/supplicant doesn't support FILS";
614 }
615 EXPECT_TRUE(sta_network_->setEapErp(true).isOk());
616 }
617
618 /*
619 * SetUpdateIdentifier
620 */
TEST_P(SupplicantStaNetworkAidlTest,SetUpdateIdentifier)621 TEST_P(SupplicantStaNetworkAidlTest, SetUpdateIdentifier) {
622 const uint32_t updateIdentifier = 21;
623 EXPECT_TRUE(sta_network_->setUpdateIdentifier(updateIdentifier).isOk());
624 }
625
626 /*
627 * SetProactiveKeyCaching
628 */
TEST_P(SupplicantStaNetworkAidlTest,SetProactiveKeyCaching)629 TEST_P(SupplicantStaNetworkAidlTest, SetProactiveKeyCaching) {
630 EXPECT_TRUE(sta_network_->setProactiveKeyCaching(true).isOk());
631 EXPECT_TRUE(sta_network_->setProactiveKeyCaching(false).isOk());
632 }
633
634 /*
635 * EnableSuiteBEapOpenSslCiphers
636 */
TEST_P(SupplicantStaNetworkAidlTest,EnableSuiteBEapOpenSslCiphers)637 TEST_P(SupplicantStaNetworkAidlTest, EnableSuiteBEapOpenSslCiphers) {
638 EXPECT_TRUE(sta_network_->enableSuiteBEapOpenSslCiphers().isOk());
639 }
640
641 /*
642 * EnableTlsSuiteBEapPhase1Param
643 */
TEST_P(SupplicantStaNetworkAidlTest,EnableTlsSuiteBEapPhase1Param)644 TEST_P(SupplicantStaNetworkAidlTest, EnableTlsSuiteBEapPhase1Param) {
645 EXPECT_TRUE(sta_network_->enableTlsSuiteBEapPhase1Param(true).isOk());
646 EXPECT_TRUE(sta_network_->enableTlsSuiteBEapPhase1Param(false).isOk());
647 }
648
649 /*
650 * SetEapEncryptedImsiIdentity
651 */
TEST_P(SupplicantStaNetworkAidlTest,SetEapEncryptedImsiIdentity)652 TEST_P(SupplicantStaNetworkAidlTest, SetEapEncryptedImsiIdentity) {
653 EXPECT_TRUE(
654 sta_network_->setEapEncryptedImsiIdentity(kTestEncryptedIdentity)
655 .isOk());
656 }
657
658 /*
659 * SetStrictConservativePeerMode
660 */
TEST_P(SupplicantStaNetworkAidlTest,SetStrictConversativePeerMode)661 TEST_P(SupplicantStaNetworkAidlTest, SetStrictConversativePeerMode) {
662 int32_t version = 0;
663 sta_network_->getInterfaceVersion(&version);
664 if (version < 2) {
665 GTEST_SKIP() << "Skipping test since it is not supported on this interface version";
666 }
667 EXPECT_TRUE(sta_network_->setStrictConservativePeerMode(true).isOk());
668 EXPECT_TRUE(sta_network_->setStrictConservativePeerMode(false).isOk());
669 }
670
671 /*
672 * SendNetworkEapIdentityResponse
673 */
TEST_P(SupplicantStaNetworkAidlTest,SendNetworkEapIdentityResponse)674 TEST_P(SupplicantStaNetworkAidlTest, SendNetworkEapIdentityResponse) {
675 EXPECT_TRUE(sta_network_
676 ->sendNetworkEapIdentityResponse(kTestIdentity,
677 kTestEncryptedIdentity)
678 .isOk());
679 }
680
681 /*
682 * Enable SAE PK only mode
683 */
TEST_P(SupplicantStaNetworkAidlTest,EnableSaePkOnlyMode)684 TEST_P(SupplicantStaNetworkAidlTest, EnableSaePkOnlyMode) {
685 // Check for SAE PK support
686 WpaDriverCapabilitiesMask caps;
687 EXPECT_TRUE(sta_iface_->getWpaDriverCapabilities(&caps).isOk());
688 const bool saePkSupported =
689 !!(static_cast<uint32_t>(caps) &
690 static_cast<uint32_t>(WpaDriverCapabilitiesMask::SAE_PK));
691 LOG(INFO) << "SAE-PK Supported: " << saePkSupported;
692
693 // Operation will succeed if SAE PK is supported, or fail otherwise.
694 EXPECT_EQ(sta_network_->enableSaePkOnlyMode(true).isOk(), saePkSupported);
695 EXPECT_EQ(sta_network_->enableSaePkOnlyMode(false).isOk(), saePkSupported);
696 }
697
698 /*
699 * Enable
700 */
TEST_P(SupplicantStaNetworkAidlTest,Enable)701 TEST_P(SupplicantStaNetworkAidlTest, Enable) {
702 // wpa_supplicant won't perform any connection initiation
703 // unless at least the SSID and key mgmt params are set.
704 EXPECT_TRUE(sta_network_->setSsid(kTestSsid).isOk());
705 EXPECT_TRUE(sta_network_->setKeyMgmt(kTestKeyMgmt).isOk());
706
707 EXPECT_TRUE(sta_network_->enable(false).isOk());
708 EXPECT_TRUE(sta_network_->enable(true).isOk());
709
710 // Now remove the network and ensure that the call fails.
711 removeNetwork();
712 ASSERT_FALSE(sta_network_->enable(true).isOk());
713 }
714
715 /*
716 * Disable
717 */
TEST_P(SupplicantStaNetworkAidlTest,Disable)718 TEST_P(SupplicantStaNetworkAidlTest, Disable) {
719 // wpa_supplicant won't perform any connection initiation
720 // unless at least the SSID and key mgmt params are set.
721 EXPECT_TRUE(sta_network_->setSsid(kTestSsid).isOk());
722 EXPECT_TRUE(sta_network_->setKeyMgmt(kTestKeyMgmt).isOk());
723
724 EXPECT_TRUE(sta_network_->disable().isOk());
725
726 // Now remove the network and ensure that the call fails.
727 removeNetwork();
728 EXPECT_FALSE(sta_network_->disable().isOk());
729 }
730
731 /*
732 * Select
733 */
TEST_P(SupplicantStaNetworkAidlTest,Select)734 TEST_P(SupplicantStaNetworkAidlTest, Select) {
735 // wpa_supplicant won't perform any connection initiation
736 // unless at least the SSID and key mgmt params are set.
737 EXPECT_TRUE(sta_network_->setSsid(kTestSsid).isOk());
738 EXPECT_TRUE(sta_network_->setKeyMgmt(kTestKeyMgmt).isOk());
739
740 EXPECT_TRUE(sta_network_->select().isOk());
741
742 // Now remove the network and ensure that the call fails.
743 removeNetwork();
744 EXPECT_FALSE(sta_network_->select().isOk());
745 }
746
747 /*
748 * SendNetworkEapSimGsmAuthResponse
749 */
TEST_P(SupplicantStaNetworkAidlTest,SendNetworkEapSimGsmAuthResponse)750 TEST_P(SupplicantStaNetworkAidlTest, SendNetworkEapSimGsmAuthResponse) {
751 NetworkResponseEapSimGsmAuthParams param;
752 param.kc =
753 std::vector<uint8_t>({0x56, 0x67, 0x67, 0xf4, 0x76, 0x87, 0x98, 0x12});
754 param.sres = std::vector<uint8_t>({0x56, 0x67, 0x67, 0xf4});
755 const std::vector<NetworkResponseEapSimGsmAuthParams> params = {param};
756 EXPECT_TRUE(sta_network_->sendNetworkEapSimGsmAuthResponse(params).isOk());
757 }
758
759 /*
760 * SendNetworkEapSimGsmAuthFailure
761 */
TEST_P(SupplicantStaNetworkAidlTest,SendNetworkEapSimGsmAuthFailure)762 TEST_P(SupplicantStaNetworkAidlTest, SendNetworkEapSimGsmAuthFailure) {
763 EXPECT_TRUE(sta_network_->sendNetworkEapSimGsmAuthFailure().isOk());
764 }
765
766 /*
767 * SendNetworkEapSimUmtsAuthResponse
768 */
TEST_P(SupplicantStaNetworkAidlTest,SendNetworkEapSimUmtsAuthResponse)769 TEST_P(SupplicantStaNetworkAidlTest, SendNetworkEapSimUmtsAuthResponse) {
770 NetworkResponseEapSimUmtsAuthParams params;
771 params.res = std::vector<uint8_t>({0x56, 0x67, 0x67, 0xf4, 0x67});
772 params.ik = std::vector<uint8_t>(16, 0x65);
773 params.ck = std::vector<uint8_t>(16, 0x45);
774 EXPECT_TRUE(sta_network_->sendNetworkEapSimUmtsAuthResponse(params).isOk());
775 }
776
777 /*
778 * SendNetworkEapSimUmtsAuthFailure
779 */
TEST_P(SupplicantStaNetworkAidlTest,SendNetworkEapSimUmtsAuthFailure)780 TEST_P(SupplicantStaNetworkAidlTest, SendNetworkEapSimUmtsAuthFailure) {
781 EXPECT_TRUE(sta_network_->sendNetworkEapSimUmtsAuthFailure().isOk());
782 }
783
784 /*
785 * SendNetworkEapSimUmtsAutsResponse
786 */
TEST_P(SupplicantStaNetworkAidlTest,SendNetworkEapSimUmtsAutsResponse)787 TEST_P(SupplicantStaNetworkAidlTest, SendNetworkEapSimUmtsAutsResponse) {
788 const std::vector<uint8_t> testAutParam = std::vector<uint8_t>(14, 0xe1);
789 EXPECT_TRUE(
790 sta_network_->sendNetworkEapSimUmtsAutsResponse(testAutParam).isOk());
791 }
792
793 /*
794 * GetWpsNfcConfigurationToken
795 */
TEST_P(SupplicantStaNetworkAidlTest,GetWpsNfcConfigurationToken)796 TEST_P(SupplicantStaNetworkAidlTest, GetWpsNfcConfigurationToken) {
797 EXPECT_TRUE(sta_network_->setSsid(kTestSsid).isOk());
798 EXPECT_TRUE(sta_network_->setKeyMgmt(kTestKeyMgmt).isOk());
799 EXPECT_TRUE(sta_network_->setPskPassphrase(kTestPskPassphrase).isOk());
800
801 std::vector<uint8_t> retrievedToken;
802 EXPECT_TRUE(
803 sta_network_->getWpsNfcConfigurationToken(&retrievedToken).isOk());
804 EXPECT_NE(retrievedToken.size(), 0);
805 }
806
807 /*
808 * SetRoamingConsortiumSelection
809 */
TEST_P(SupplicantStaNetworkAidlTest,SetRoamingConsortiumSelection)810 TEST_P(SupplicantStaNetworkAidlTest, SetRoamingConsortiumSelection) {
811 const std::vector<uint8_t> testSelection = std::vector<uint8_t>({0x11, 0x21, 0x33, 0x44});
812 EXPECT_TRUE(sta_network_->setRoamingConsortiumSelection(testSelection).isOk());
813 }
814
815 /*
816 * SetMinimumTlsVersionEapPhase1Param
817 */
TEST_P(SupplicantStaNetworkAidlTest,SetMinimumTlsVersionEapPhase1Param)818 TEST_P(SupplicantStaNetworkAidlTest, SetMinimumTlsVersionEapPhase1Param) {
819 WpaDriverCapabilitiesMask caps;
820 EXPECT_TRUE(sta_iface_->getWpaDriverCapabilities(&caps).isOk());
821 const bool tlsV13Supported = !!(static_cast<uint32_t>(caps) &
822 static_cast<uint32_t>(WpaDriverCapabilitiesMask::TLS_V1_3));
823 LOG(INFO) << "TLS_V1_3 Supported: " << tlsV13Supported;
824
825 // Operation will succeed if TLS_V1_3 is supported, or fail otherwise.
826 EXPECT_EQ(sta_network_->setMinimumTlsVersionEapPhase1Param(TlsVersion::TLS_V1_3).isOk(),
827 tlsV13Supported);
828 }
829
830 /*
831 * disableEht
832 */
TEST_P(SupplicantStaNetworkAidlTest,DisableEht)833 TEST_P(SupplicantStaNetworkAidlTest, DisableEht) {
834 if (interface_version_ < 3) {
835 GTEST_SKIP() << "disableEht is available as of Supplicant V3";
836 }
837 EXPECT_TRUE(sta_network_->disableEht().isOk());
838 }
839
840 /*
841 * SetDppKeys
842 */
TEST_P(SupplicantStaNetworkAidlTest,SetDppKeys)843 TEST_P(SupplicantStaNetworkAidlTest, SetDppKeys) {
844 if (!keyMgmtSupported(sta_iface_, KeyMgmtMask::DPP)) {
845 GTEST_SKIP() << "Missing DPP support";
846 }
847
848 DppConnectionKeys in_keys;
849 in_keys.connector = std::vector<uint8_t>({0x11, 0x22, 0x33, 0x44});
850 in_keys.cSign = std::vector<uint8_t>({0x55, 0x66, 0x77, 0x88});
851 in_keys.netAccessKey = std::vector<uint8_t>({0xaa, 0xbb, 0xcc, 0xdd});
852 EXPECT_TRUE(sta_network_->setDppKeys(in_keys).isOk());
853 }
854
855 /*
856 * SetVendorData
857 */
TEST_P(SupplicantStaNetworkAidlTest,SetVendorData)858 TEST_P(SupplicantStaNetworkAidlTest, SetVendorData) {
859 if (interface_version_ < 3) {
860 GTEST_SKIP() << "setVendorData is available as of Supplicant V3";
861 }
862 EXPECT_TRUE(sta_network_->setVendorData(kTestVendorData).isOk());
863 }
864
865 /*
866 * Set/Get EDMG
867 */
TEST_P(SupplicantStaNetworkAidlTest,SetGetEdmg)868 TEST_P(SupplicantStaNetworkAidlTest, SetGetEdmg) {
869 bool retrievedValue = false;
870 EXPECT_TRUE(sta_network_->setEdmg(true).isOk());
871 EXPECT_TRUE(sta_network_->getEdmg(&retrievedValue).isOk());
872 EXPECT_EQ(retrievedValue, true);
873
874 EXPECT_TRUE(sta_network_->setEdmg(false).isOk());
875 EXPECT_TRUE(sta_network_->getEdmg(&retrievedValue).isOk());
876 EXPECT_EQ(retrievedValue, false);
877 }
878
879 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SupplicantStaNetworkAidlTest);
880 INSTANTIATE_TEST_SUITE_P(Supplicant, SupplicantStaNetworkAidlTest,
881 testing::ValuesIn(android::getAidlHalInstanceNames(
882 ISupplicant::descriptor)),
883 android::PrintInstanceNameToString);
884
main(int argc,char ** argv)885 int main(int argc, char** argv) {
886 ::testing::InitGoogleTest(&argc, argv);
887 ProcessState::self()->setThreadPoolMaxThreadCount(1);
888 ProcessState::self()->startThreadPool();
889 return RUN_ALL_TESTS();
890 }
891