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