1 /* 2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "netstack_log.h" 17 #include "gtest/gtest.h" 18 #include <cstring> 19 #include <iostream> 20 21 #include "local_socket_context.h" 22 #include "local_socket_exec.h" 23 #include "local_socket_server_context.h" 24 #include "multicast_get_loopback_context.h" 25 #include "multicast_get_ttl_context.h" 26 #include "multicast_membership_context.h" 27 #include "multicast_set_loopback_context.h" 28 #include "multicast_set_ttl_context.h" 29 #include "socket_exec.h" 30 #include "socket_exec_common.h" 31 32 #include "socks5.h" 33 #include "socks5_instance.h" 34 #include "socks5_none_method.h" 35 #include "socks5_passwd_method.h" 36 #include "socks5_package.h" 37 #include "socks5_utils.h" 38 39 class SocketTest : public testing::Test { 40 public: SetUpTestCase()41 static void SetUpTestCase() {} 42 TearDownTestCase()43 static void TearDownTestCase() {} 44 SetUp()45 virtual void SetUp() {} 46 TearDown()47 virtual void TearDown() {} 48 }; 49 50 namespace { 51 using namespace std; 52 using namespace testing::ext; 53 using namespace OHOS::NetStack; 54 using namespace OHOS::NetStack::Socket; 55 using namespace OHOS::NetStack::Socks5; 56 57 HWTEST_F(SocketTest, MulticastTest001, TestSize.Level1) 58 { 59 napi_env env = nullptr; 60 auto eventManager = std::make_shared<EventManager>(); 61 MulticastMembershipContext context(env, eventManager); 62 bool ret = SocketExec::ExecUdpAddMembership(&context); 63 EXPECT_EQ(ret, false); 64 } 65 66 HWTEST_F(SocketTest, MulticastTest002, TestSize.Level1) 67 { 68 napi_env env = nullptr; 69 auto eventManager = std::make_shared<EventManager>(); 70 MulticastMembershipContext context(env, eventManager); 71 bool ret = SocketExec::ExecUdpDropMembership(&context); 72 EXPECT_EQ(ret, false); 73 } 74 75 HWTEST_F(SocketTest, MulticastTest003, TestSize.Level1) 76 { 77 napi_env env = nullptr; 78 auto eventManager = std::make_shared<EventManager>(); 79 MulticastSetTTLContext context(env, eventManager); 80 bool ret = SocketExec::ExecSetMulticastTTL(&context); 81 EXPECT_EQ(ret, false); 82 } 83 84 HWTEST_F(SocketTest, MulticastTest004, TestSize.Level1) 85 { 86 napi_env env = nullptr; 87 auto eventManager = std::make_shared<EventManager>(); 88 MulticastGetTTLContext context(env, eventManager); 89 bool ret = SocketExec::ExecGetMulticastTTL(&context); 90 EXPECT_EQ(ret, false); 91 } 92 93 HWTEST_F(SocketTest, MulticastTest005, TestSize.Level1) 94 { 95 napi_env env = nullptr; 96 auto eventManager = std::make_shared<EventManager>(); 97 MulticastSetLoopbackContext context(env, eventManager); 98 bool ret = SocketExec::ExecSetLoopbackMode(&context); 99 EXPECT_EQ(ret, false); 100 } 101 102 HWTEST_F(SocketTest, MulticastTest006, TestSize.Level1) 103 { 104 napi_env env = nullptr; 105 auto eventManager = std::make_shared<EventManager>(); 106 MulticastGetLoopbackContext context(env, eventManager); 107 bool ret = SocketExec::ExecGetLoopbackMode(&context); 108 EXPECT_EQ(ret, false); 109 } 110 111 HWTEST_F(SocketTest, LocalSocketTest001, TestSize.Level1) 112 { 113 napi_env env = nullptr; 114 auto eventManager = std::make_shared<EventManager>(); 115 LocalSocketBindContext context(env, eventManager); 116 bool ret = LocalSocketExec::ExecLocalSocketBind(&context); 117 EXPECT_EQ(ret, false); 118 } 119 120 HWTEST_F(SocketTest, LocalSocketTest002, TestSize.Level1) 121 { 122 napi_env env = nullptr; 123 auto eventManager = std::make_shared<EventManager>(); 124 LocalSocketConnectContext context(env, eventManager); 125 bool ret = LocalSocketExec::ExecLocalSocketConnect(&context); 126 EXPECT_EQ(ret, false); 127 } 128 129 HWTEST_F(SocketTest, LocalSocketTest003, TestSize.Level1) 130 { 131 napi_env env = nullptr; 132 auto eventManager = std::make_shared<EventManager>(); 133 LocalSocketSendContext context(env, eventManager); 134 bool ret = LocalSocketExec::ExecLocalSocketSend(&context); 135 EXPECT_EQ(ret, false); 136 } 137 138 HWTEST_F(SocketTest, LocalSocketTest004, TestSize.Level1) 139 { 140 napi_env env = nullptr; 141 auto eventManager = std::make_shared<EventManager>(); 142 LocalSocketCloseContext context(env, eventManager); 143 bool ret = LocalSocketExec::ExecLocalSocketClose(&context); 144 EXPECT_EQ(ret, false); 145 } 146 147 HWTEST_F(SocketTest, LocalSocketTest005, TestSize.Level1) 148 { 149 napi_env env = nullptr; 150 auto eventManager = std::make_shared<EventManager>(); 151 LocalSocketGetStateContext context(env, eventManager); 152 bool ret = LocalSocketExec::ExecLocalSocketGetState(&context); 153 EXPECT_EQ(ret, true); 154 } 155 156 HWTEST_F(SocketTest, LocalSocketTest006, TestSize.Level1) 157 { 158 napi_env env = nullptr; 159 auto eventManager = std::make_shared<EventManager>(); 160 LocalSocketGetSocketFdContext context(env, eventManager); 161 bool ret = LocalSocketExec::ExecLocalSocketGetSocketFd(&context); 162 EXPECT_EQ(ret, true); 163 } 164 165 HWTEST_F(SocketTest, LocalSocketTest007, TestSize.Level1) 166 { 167 napi_env env = nullptr; 168 auto eventManager = std::make_shared<EventManager>(); 169 LocalSocketSetExtraOptionsContext context(env, eventManager); 170 bool ret = LocalSocketExec::ExecLocalSocketSetExtraOptions(&context); 171 EXPECT_EQ(ret, true); 172 } 173 174 HWTEST_F(SocketTest, LocalSocketTest008, TestSize.Level1) 175 { 176 napi_env env = nullptr; 177 auto eventManager = std::make_shared<EventManager>(); 178 LocalSocketGetExtraOptionsContext context(env, eventManager); 179 bool ret = LocalSocketExec::ExecLocalSocketGetExtraOptions(&context); 180 EXPECT_EQ(ret, false); 181 } 182 183 HWTEST_F(SocketTest, LocalSocketServerTest001, TestSize.Level1) 184 { 185 napi_env env = nullptr; 186 auto eventManager = std::make_shared<EventManager>(); 187 LocalSocketServerListenContext context(env, eventManager); 188 bool ret = LocalSocketExec::ExecLocalSocketServerListen(&context); 189 EXPECT_EQ(ret, false); 190 } 191 192 HWTEST_F(SocketTest, LocalSocketServerTest002, TestSize.Level1) 193 { 194 napi_env env = nullptr; 195 auto eventManager = std::make_shared<EventManager>(); 196 LocalSocketServerGetStateContext context(env, eventManager); 197 bool ret = LocalSocketExec::ExecLocalSocketServerGetState(&context); 198 EXPECT_EQ(ret, true); 199 } 200 201 HWTEST_F(SocketTest, LocalSocketServerTest003, TestSize.Level1) 202 { 203 napi_env env = nullptr; 204 auto eventManager = std::make_shared<EventManager>(); 205 LocalSocketServerSetExtraOptionsContext context(env, eventManager); 206 bool ret = LocalSocketExec::ExecLocalSocketServerSetExtraOptions(&context); 207 EXPECT_EQ(ret, false); 208 } 209 210 HWTEST_F(SocketTest, LocalSocketServerTest004, TestSize.Level1) 211 { 212 napi_env env = nullptr; 213 auto eventManager = std::make_shared<EventManager>(); 214 LocalSocketServerGetExtraOptionsContext context(env, eventManager); 215 bool ret = LocalSocketExec::ExecLocalSocketServerGetExtraOptions(&context); 216 EXPECT_EQ(ret, false); 217 } 218 219 HWTEST_F(SocketTest, LocalSocketServerTest005, TestSize.Level1) 220 { 221 napi_env env = nullptr; 222 auto eventManager = std::make_shared<EventManager>(); 223 LocalSocketServerSendContext context(env, eventManager); 224 bool ret = LocalSocketExec::ExecLocalSocketConnectionSend(&context); 225 EXPECT_EQ(ret, false); 226 } 227 228 HWTEST_F(SocketTest, LocalSocketServerTest006, TestSize.Level1) 229 { 230 napi_env env = nullptr; 231 auto eventManager = std::make_shared<EventManager>(); 232 LocalSocketServerCloseContext context(env, eventManager); 233 bool ret = LocalSocketExec::ExecLocalSocketConnectionClose(&context); 234 EXPECT_EQ(ret, false); 235 } 236 237 // socks5 proxy test start 238 HWTEST_F(SocketTest, Socks5SocketTest001, TestSize.Level1) 239 { 240 napi_env env = nullptr; 241 auto eventManager = std::make_shared<EventManager>(); 242 ConnectContext context(env, eventManager); 243 bool ret = SocketExec::ExecConnect(&context); 244 EXPECT_EQ(ret, false); 245 246 context.proxyOptions = make_shared<ProxyOptions>(); 247 context.proxyOptions->type_ = ProxyType::SOCKS5; 248 ret = SocketExec::ExecConnect(&context); 249 EXPECT_EQ(ret, false); 250 } 251 252 HWTEST_F(SocketTest, Socks5SocketTest002, TestSize.Level1) 253 { 254 napi_env env = nullptr; 255 auto eventManager = std::make_shared<EventManager>(); 256 UdpSendContext context(env, eventManager); 257 context.parseOK_ = false; 258 EXPECT_FALSE(SocketExec::ExecUdpSend(&context)); 259 260 context.parseOK_ = true; 261 EXPECT_FALSE(SocketExec::ExecUdpSend(&context)); 262 263 int data = 1; 264 eventManager->data_ = &data; 265 shared_ptr<Socks5Instance> socks5Udp = make_shared<Socks5UdpInstance>(); 266 socks5Udp->options_ = make_shared<Socks5Option>(); 267 socks5Udp->SetSocks5Instance(socks5Udp); 268 eventManager->proxyData_ = socks5Udp; 269 context.proxyOptions = make_shared<ProxyOptions>(); 270 context.proxyOptions->type_ = ProxyType::NONE; 271 EXPECT_FALSE(SocketExec::ExecUdpSend(&context)); 272 273 context.proxyOptions->type_ = ProxyType::SOCKS5; 274 EXPECT_FALSE(SocketExec::ExecUdpSend(&context)); 275 sleep(2); 276 } 277 278 HWTEST_F(SocketTest, SetSocks5OptionTest001, TestSize.Level1) 279 { 280 int32_t socketId = 1; 281 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 282 socks5Inst->SetSocks5Instance(socks5Inst); 283 shared_ptr<Socks5Option> opt = make_shared<Socks5Option>(); 284 socks5Inst->SetSocks5Option(opt); 285 EXPECT_FALSE(socks5Inst->options_ == nullptr); 286 } 287 288 HWTEST_F(SocketTest, DoConnectTest001, TestSize.Level1) 289 { 290 int32_t socketId = 1; 291 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 292 socks5Inst->options_ = make_shared<Socks5Option>(); 293 socks5Inst->SetSocks5Instance(socks5Inst); 294 auto ret = socks5Inst->DoConnect(Socks5Command::TCP_CONNECTION); 295 EXPECT_FALSE(ret); 296 EXPECT_FALSE(socks5Inst->IsConnected()); 297 } 298 299 HWTEST_F(SocketTest, RequestMethodTest001, TestSize.Level1) 300 { 301 int32_t socketId = 1; 302 vector<Socks5MethodType> methods = {Socks5MethodType::NO_AUTH, Socks5MethodType::PASSWORD}; 303 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 304 socks5Inst->options_ = make_shared<Socks5Option>(); 305 socks5Inst->SetSocks5Instance(socks5Inst); 306 auto ret = socks5Inst->RequestMethod(methods); 307 EXPECT_FALSE(ret); 308 } 309 310 HWTEST_F(SocketTest, CreateSocks5MethodByTypeTest001, TestSize.Level1) 311 { 312 int32_t socketId = 1; 313 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 314 socks5Inst->SetSocks5Instance(socks5Inst); 315 auto ret = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::NO_AUTH); 316 EXPECT_FALSE(ret == nullptr); 317 318 ret = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::PASSWORD); 319 EXPECT_FALSE(ret == nullptr); 320 321 ret = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::GSSAPI); 322 EXPECT_TRUE(ret == nullptr); 323 324 ret = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::NO_METHODS); 325 EXPECT_TRUE(ret == nullptr); 326 } 327 328 HWTEST_F(SocketTest, ConnectTest001, TestSize.Level1) 329 { 330 int32_t socketId = 1; 331 auto socks5TcpInst = make_shared<Socks5TcpInstance>(socketId); 332 socks5TcpInst->SetSocks5Instance(socks5TcpInst); 333 socks5TcpInst->options_ = make_shared<Socks5Option>(); 334 socks5TcpInst->state_ = Socks5AuthState::SUCCESS; 335 EXPECT_TRUE(socks5TcpInst->Connect()); 336 socks5TcpInst->state_ = Socks5AuthState::INIT; 337 EXPECT_FALSE(socks5TcpInst->Connect()); 338 } 339 340 HWTEST_F(SocketTest, ConnectTest002, TestSize.Level1) 341 { 342 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 343 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 344 socks5UdpInst->options_ = make_shared<Socks5Option>(); 345 socks5UdpInst->state_ = Socks5AuthState::SUCCESS; 346 EXPECT_TRUE(socks5UdpInst->Connect()); 347 socks5UdpInst->state_ = Socks5AuthState::INIT; 348 EXPECT_FALSE(socks5UdpInst->Connect()); 349 } 350 351 HWTEST_F(SocketTest, ConnectProxyTest001, TestSize.Level1) 352 { 353 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 354 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 355 socks5UdpInst->options_ = make_shared<Socks5Option>(); 356 EXPECT_FALSE(socks5UdpInst->ConnectProxy()); 357 } 358 359 HWTEST_F(SocketTest, RemoveHeaderTest001, TestSize.Level1) 360 { 361 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 362 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 363 void *data = nullptr; 364 size_t len = 2; 365 int af = AF_INET; 366 EXPECT_FALSE(socks5UdpInst->RemoveHeader(data, len, af)); 367 } 368 369 HWTEST_F(SocketTest, AddHeaderTest001, TestSize.Level1) 370 { 371 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 372 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 373 NetAddress dest; 374 dest.SetFamilyByJsValue(static_cast<uint32_t>(NetAddress::Family::IPv4)); 375 socks5UdpInst->dest_ = dest; 376 socks5UdpInst->AddHeader(); 377 EXPECT_EQ(socks5UdpInst->dest_.GetFamily(), NetAddress::Family::IPv4); 378 } 379 380 HWTEST_F(SocketTest, AddHeaderTest002, TestSize.Level1) 381 { 382 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 383 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 384 NetAddress dest; 385 dest.SetFamilyByJsValue(static_cast<uint32_t>(NetAddress::Family::IPv6)); 386 socks5UdpInst->dest_ = dest; 387 socks5UdpInst->AddHeader(); 388 EXPECT_EQ(socks5UdpInst->dest_.GetFamily(), NetAddress::Family::IPv6); 389 } 390 391 HWTEST_F(SocketTest, AddHeaderTest003, TestSize.Level1) 392 { 393 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 394 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 395 NetAddress dest; 396 dest.SetFamilyByJsValue(static_cast<uint32_t>(NetAddress::Family::DOMAIN_NAME)); 397 socks5UdpInst->dest_ = dest; 398 socks5UdpInst->AddHeader(); 399 EXPECT_EQ(socks5UdpInst->dest_.GetFamily(), NetAddress::Family::DOMAIN_NAME); 400 } 401 402 HWTEST_F(SocketTest, NoAuthMethodTest001, TestSize.Level1) 403 { 404 int32_t socketId = 1; 405 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 406 socks5Inst->SetSocks5Instance(socks5Inst); 407 auto noAuthMethod = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::NO_AUTH); 408 noAuthMethod->socks5Inst_ = socks5Inst; 409 Socks5ProxyAddress proxyAddr; 410 EXPECT_TRUE(noAuthMethod->RequestAuth(socketId, "", "", proxyAddr)); 411 412 NetAddress dest; 413 EXPECT_FALSE(noAuthMethod->RequestProxy(socketId, Socks5Command::TCP_CONNECTION, dest, proxyAddr).first); 414 415 dest.family_ = NetAddress::Family::IPv4; 416 EXPECT_FALSE(noAuthMethod->RequestProxy(socketId, Socks5Command::TCP_CONNECTION, dest, proxyAddr).first); 417 418 dest.family_ = NetAddress::Family::IPv6; 419 EXPECT_FALSE(noAuthMethod->RequestProxy(socketId, Socks5Command::TCP_CONNECTION, dest, proxyAddr).first); 420 421 dest.family_ = NetAddress::Family::DOMAIN_NAME; 422 EXPECT_FALSE(noAuthMethod->RequestProxy(socketId, Socks5Command::TCP_CONNECTION, dest, proxyAddr).first); 423 } 424 425 HWTEST_F(SocketTest, passWdMethodTest001, TestSize.Level1) 426 { 427 int32_t socketId = 1; 428 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 429 socks5Inst->SetSocks5Instance(socks5Inst); 430 auto passWdMethod = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::PASSWORD); 431 passWdMethod->socks5Inst_ = socks5Inst; 432 Socks5ProxyAddress proxyAddr; 433 EXPECT_FALSE(passWdMethod->RequestAuth(socketId, "", "pass", proxyAddr)); 434 EXPECT_FALSE(passWdMethod->RequestAuth(socketId, "user", "", proxyAddr)); 435 EXPECT_FALSE(passWdMethod->RequestAuth(socketId, "user", "pass", proxyAddr)); 436 } 437 438 HWTEST_F(SocketTest, Socks5PkgTest001, TestSize.Level1) 439 { 440 Socks5MethodRequest request; 441 Socks5MethodResponse response; 442 443 request.version_ = 1; 444 string serialized = request.Serialize(); 445 EXPECT_NE(serialized, ""); 446 447 EXPECT_FALSE(response.Deserialize((uint8_t*) serialized.c_str(), 1)); 448 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized.c_str(), serialized.size())); 449 } 450 451 HWTEST_F(SocketTest, Socks5PkgTest002, TestSize.Level1) 452 { 453 Socks5AuthRequest request; 454 Socks5AuthResponse response; 455 EXPECT_EQ(request.Serialize(), ""); 456 457 request.version_ = 1; 458 request.username_ = "user"; 459 request.password_ = "pass"; 460 string serialized = request.Serialize(); 461 EXPECT_NE(serialized, ""); 462 463 EXPECT_FALSE(response.Deserialize((uint8_t*) serialized.c_str(), 1)); 464 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized.c_str(), serialized.size())); 465 } 466 467 HWTEST_F(SocketTest, Socks5PkgTest003, TestSize.Level1) 468 { 469 Socks5ProxyRequest request; 470 Socks5ProxyResponse response; 471 EXPECT_EQ(request.Serialize(), ""); 472 473 request.version_ = 1; 474 request.cmd_ = Socks5Command::TCP_CONNECTION; 475 request.reserved_ = 1; 476 request.destPort_ = 1; 477 request.destAddr_ = "192.168.1.10"; 478 request.addrType_ = Socks5AddrType::IPV4; 479 string serialized = request.Serialize(); 480 EXPECT_NE(serialized, ""); 481 EXPECT_FALSE(response.Deserialize((uint8_t*) serialized.c_str(), 1)); 482 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized.c_str(), serialized.size())); 483 484 request.destAddr_ = "www.xxx.com"; 485 request.addrType_ = Socks5AddrType::DOMAIN_NAME; 486 string serialized2 = request.Serialize(); 487 EXPECT_NE(serialized2, ""); 488 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized2.c_str(), serialized2.size())); 489 490 request.destAddr_ = "fe80::100"; 491 request.addrType_ = Socks5AddrType::IPV6; 492 string serialized3 = request.Serialize(); 493 EXPECT_NE(serialized3, ""); 494 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized3.c_str(), serialized3.size())); 495 } 496 497 HWTEST_F(SocketTest, Socks5PkgTest004, TestSize.Level1) 498 { 499 Socks5UdpHeader header; 500 EXPECT_EQ(header.Serialize(), ""); 501 502 header.reserved_ = 0; 503 header.frag_ = 0; 504 header.dstPort_ = 1; 505 506 header.destAddr_ = "192.168.1.10"; 507 header.addrType_ = Socks5AddrType::IPV4; 508 string serialized = header.Serialize(); 509 EXPECT_NE(serialized, ""); 510 EXPECT_FALSE(header.Deserialize((uint8_t*) serialized.c_str(), 1)); 511 EXPECT_TRUE(header.Deserialize((uint8_t*) serialized.c_str(), serialized.size())); 512 513 header.destAddr_ = "www.xxx.com"; 514 header.addrType_ = Socks5AddrType::DOMAIN_NAME; 515 string serialized2 = header.Serialize(); 516 EXPECT_NE(serialized2, ""); 517 EXPECT_TRUE(header.Deserialize((uint8_t*) serialized2.c_str(), serialized2.size())); 518 519 header.destAddr_ = "fe80::100"; 520 header.addrType_ = Socks5AddrType::IPV6; 521 string serialized3 = header.Serialize(); 522 EXPECT_NE(serialized3, ""); 523 EXPECT_TRUE(header.Deserialize((uint8_t*) serialized3.c_str(), serialized3.size())); 524 } 525 526 } // namespace