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