1 /*
2  * Copyright (c) 2024 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 <fstream>
17 #include <gtest/gtest.h>
18 #include <iostream>
19 
20 #ifdef GTEST_API_
21 #define private public
22 #endif
23 
24 #include "net_address.h"
25 #include "secure_data.h"
26 #include "socket_error.h"
27 #include "socket_state_base.h"
28 #include "tls.h"
29 #include "tls_certificate.h"
30 #include "tls_configuration.h"
31 #include "tls_key.h"
32 #include "tls_socket.h"
33 #include "tls_socket_server.h"
34 
35 namespace OHOS {
36 namespace NetStack {
37 namespace TlsSocketServer {
38 
39 class TlsSocketServerBranchTest : 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 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest001, testing::ext::TestSize.Level2)50 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest001, testing::ext::TestSize.Level2)
51 {
52     auto tlsSocketServer = new TLSSocketServer();
53     EXPECT_TRUE(tlsSocketServer != nullptr);
54     if (tlsSocketServer == nullptr) {
55         return;
56     }
57 
58     TLSServerSendOptions data;
59     TlsSocket::SendCallback sendCallback;
60     bool ret = tlsSocketServer->Send(data, sendCallback);
61     EXPECT_FALSE(ret);
62 
63     Socket::TCPExtraOptions tcpExtraOptions;
64     TlsSocket::SetExtraOptionsCallback callback;
65     ret = tlsSocketServer->SetExtraOptions(tcpExtraOptions, callback);
66     EXPECT_FALSE(ret);
67 
68     tcpExtraOptions.SetKeepAlive(true);
69     ret = tlsSocketServer->SetExtraOptions(tcpExtraOptions, callback);
70     EXPECT_FALSE(ret);
71 
72     tcpExtraOptions.SetOOBInline(true);
73     ret = tlsSocketServer->SetExtraOptions(tcpExtraOptions, callback);
74     EXPECT_FALSE(ret);
75 
76     tcpExtraOptions.SetTCPNoDelay(true);
77     ret = tlsSocketServer->SetExtraOptions(tcpExtraOptions, callback);
78     EXPECT_FALSE(ret);
79 }
80 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest002, testing::ext::TestSize.Level2)81 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest002, testing::ext::TestSize.Level2)
82 {
83     auto tlsSocketServer = new TLSSocketServer();
84     EXPECT_TRUE(tlsSocketServer != nullptr);
85     if (tlsSocketServer == nullptr) {
86         return;
87     }
88 
89     TlsSocket::TLSConnectOptions config;
90     tlsSocketServer->SetLocalTlsConfiguration(config);
91 
92     int socketFd = 0;
93     tlsSocketServer->ProcessTcpAccept(config, socketFd);
94     std::shared_ptr<TLSSocketServer::Connection> connection = std::make_shared<TLSSocketServer::Connection>();
95     EXPECT_TRUE(connection != nullptr);
96     tlsSocketServer->AddConnect(socketFd, connection);
97 
98     std::string data = "test";
99     auto ret = connection->Send(data);
100     EXPECT_FALSE(ret);
101 
102     char *buffer = nullptr;
103     int maxBufferSize = 0;
104     auto value = connection->Recv(buffer, maxBufferSize);
105     EXPECT_EQ(value, -1);
106 
107     ret = connection->Close();
108     EXPECT_FALSE(ret);
109 
110     std::vector<std::string> alpnProtocols;
111     ret = connection->SetAlpnProtocols(alpnProtocols);
112     EXPECT_FALSE(ret);
113 
114     auto stringVector = connection->GetCipherSuite();
115     EXPECT_TRUE(stringVector.empty());
116 
117     auto protocol = connection->GetProtocol();
118     EXPECT_EQ(protocol, "UNKNOW_PROTOCOL");
119 
120     ret = connection->SetSharedSigals();
121     EXPECT_FALSE(ret);
122 
123     ret = connection->StartShakingHands(config);
124     EXPECT_FALSE(ret);
125 }
126 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest003, testing::ext::TestSize.Level2)127 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest003, testing::ext::TestSize.Level2)
128 {
129     auto tlsSocketServer = new TLSSocketServer();
130     EXPECT_TRUE(tlsSocketServer != nullptr);
131 
132     std::shared_ptr<TLSSocketServer::Connection> connection = std::make_shared<TLSSocketServer::Connection>();
133     EXPECT_TRUE(connection != nullptr);
134     OnMessageCallback onMessageCallback;
135     connection->OnMessage(onMessageCallback);
136     OnCloseCallback onCloseCallback;
137     connection->OnClose(onCloseCallback);
138     connection->OffMessage();
139 
140     TlsSocket::OnErrorCallback onErrorCallback;
141     connection->OnError(onErrorCallback);
142     connection->OffClose();
143     connection->OffError();
144 
145     int32_t err = 0;
146     std::string testString = "test";
147     connection->CallOnErrorCallback(err, testString);
148 
149     OnConnectCallback onConnectCallback;
150     tlsSocketServer->OnConnect(onConnectCallback);
151     tlsSocketServer->OnError(onErrorCallback);
152     tlsSocketServer->OffConnect();
153     tlsSocketServer->OffError();
154 
155     sa_family_t family = 0;
156     tlsSocketServer->MakeIpSocket(family);
157     family = 2;
158     tlsSocketServer->MakeIpSocket(family);
159     tlsSocketServer->CallOnErrorCallback(err, testString);
160     EXPECT_TRUE(tlsSocketServer->onErrorCallback_ == nullptr);
161 }
162 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest004, testing::ext::TestSize.Level2)163 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest004, testing::ext::TestSize.Level2)
164 {
165     auto tlsSocketServer = new TLSSocketServer();
166     EXPECT_TRUE(tlsSocketServer != nullptr);
167     if (tlsSocketServer == nullptr) {
168         return;
169     }
170 
171     int socketFd = 0;
172     TlsSocket::CloseCallback closeCallback;
173     auto userCounter = tlsSocketServer->GetConnectionClientCount();
174     EXPECT_EQ(userCounter, 0);
175 
176     Socket::SocketStateBase state;
177     TlsSocket::GetStateCallback stateCallback;
178     tlsSocketServer->CallGetStateCallback(socketFd, state, stateCallback);
179     Socket::NetAddress address;
180     sockaddr_in addr4 = { 0 };
181     sockaddr_in6 addr6 = { 0 };
182     sockaddr *addr = nullptr;
183     socklen_t len;
184     tlsSocketServer->GetAddr(address, &addr4, &addr6, &addr, &len);
185 
186     auto result = tlsSocketServer->GetConnectionByClientID(socketFd);
187     EXPECT_TRUE(result == nullptr);
188 
189     int32_t err = 0;
190     ListenCallback callback;
191     tlsSocketServer->CallListenCallback(err, callback);
192 
193     std::shared_ptr<TLSSocketServer::Connection> connection = std::make_shared<TLSSocketServer::Connection>();
194     EXPECT_TRUE(connection != nullptr);
195     address.SetPort(0);
196     connection->SetAddress(address);
197     address = connection->GetAddress();
198     EXPECT_EQ(address.GetPort(), 0);
199 
200     TlsSocket::TLSConnectOptions options;
201     connection->SetTlsConfiguration(options);
202 
203     auto ret = connection->TlsAcceptToHost(socketFd, options);
204     EXPECT_FALSE(ret);
205 
206     std::string data = "";
207     ret = connection->Send(data);
208     EXPECT_FALSE(ret);
209 
210     char *buffer = nullptr;
211     int maxBufferSize = 0;
212     auto value = connection->Recv(buffer, maxBufferSize);
213     EXPECT_EQ(value, -1);
214 }
215 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest005, testing::ext::TestSize.Level2)216 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest005, testing::ext::TestSize.Level2)
217 {
218     std::shared_ptr<TLSSocketServer::Connection> connection = std::make_shared<TLSSocketServer::Connection>();
219     EXPECT_TRUE(connection != nullptr);
220     auto ret = connection->Close();
221     EXPECT_FALSE(ret);
222 
223     std::vector<std::string> alpnProtocols;
224     ret = connection->SetAlpnProtocols(alpnProtocols);
225     EXPECT_FALSE(ret);
226 
227     Socket::SocketRemoteInfo remoteInfo;
228     connection->MakeRemoteInfo(remoteInfo);
229 
230     TlsSocket::TLSConfiguration tLSConfiguration;
231     tLSConfiguration = connection->GetTlsConfiguration();
232     std::vector<std::string> certificate;
233     tLSConfiguration.SetCaCertificate(certificate);
234     EXPECT_TRUE(tLSConfiguration.GetCaCertificate().empty());
235 
236     auto cipherSuiteVec = connection->GetCipherSuite();
237     EXPECT_TRUE(cipherSuiteVec.empty());
238 
239     auto remoteCert = connection->GetRemoteCertificate();
240     EXPECT_TRUE(remoteCert.empty());
241 
242     auto signatureAlgorithms = connection->GetSignatureAlgorithms();
243     EXPECT_TRUE(signatureAlgorithms.empty());
244 
245     ret = connection->SetSharedSigals();
246     EXPECT_FALSE(ret);
247 
248     auto point = connection->GetSSL();
249     EXPECT_FALSE(point != nullptr);
250 }
251 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest006, testing::ext::TestSize.Level2)252 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest006, testing::ext::TestSize.Level2)
253 {
254     auto tlsSocketServer = new TLSSocketServer();
255     EXPECT_TRUE(tlsSocketServer != nullptr);
256     if (tlsSocketServer == nullptr) {
257         return;
258     }
259     std::shared_ptr<TLSSocketServer::Connection> connection = std::make_shared<TLSSocketServer::Connection>();
260     EXPECT_TRUE(connection != nullptr);
261 
262     TLSServerSendOptions tlsServerSendOptions;
263     tlsServerSendOptions.SetSocket(0);
264     auto socketFd = connection->GetSocketFd();
265     EXPECT_EQ(socketFd, 0);
266     socketFd = tlsServerSendOptions.GetSocket();
267     EXPECT_EQ(socketFd, 0);
268 
269     std::string testString = "test";
270     tlsServerSendOptions.SetSendData(testString);
271     auto data = tlsServerSendOptions.GetSendData();
272     EXPECT_EQ(data, testString);
273 
274     std::shared_ptr<EventManager> eventManager = nullptr;
275     connection->SetEventManager(eventManager);
276     EXPECT_TRUE(connection->GetEventManager() == nullptr);
277 
278     int32_t clientID = 0;
279     connection->SetClientID(clientID);
280     clientID = connection->GetClientID();
281     EXPECT_EQ(clientID, 0);
282 
283     TlsSocket::TLSConnectOptions options;
284     bool ret = connection->StartTlsAccept(options);
285     EXPECT_FALSE(ret);
286 
287     ret = connection->CreatTlsContext();
288     EXPECT_FALSE(ret);
289 
290     ret = connection->StartShakingHands(options);
291     EXPECT_FALSE(ret);
292 
293     ret = connection->SetRemoteCertRawData();
294     EXPECT_FALSE(ret);
295 
296     int index = 0;
297     tlsSocketServer->InitPollList(index);
298     tlsSocketServer->DropFdFromPollList(index);
299 
300     connection->CallOnCloseCallback(socketFd);
301     tlsSocketServer->CallOnConnectCallback(socketFd, eventManager);
302     tlsSocketServer->RemoveConnect(socketFd);
303     tlsSocketServer->RecvRemoteInfo(socketFd, index);
304 
305     Socket::SocketRemoteInfo remoteInfo;
306     connection->CallOnMessageCallback(socketFd, testString, remoteInfo);
307 
308     EventManager manager;
309     tlsSocketServer->CloseConnectionByEventManager(&manager);
310     tlsSocketServer->DeleteConnectionByEventManager(&manager);
311     auto connections = tlsSocketServer->GetConnectionByClientEventManager(&manager);
312     EXPECT_TRUE(connections == nullptr);
313 }
314 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest007, testing::ext::TestSize.Level2)315 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest007, testing::ext::TestSize.Level2)
316 {
317     auto connection = std::make_shared<TLSSocketServer::Connection>();
318     std::string hostName = "testHost";
319     X509 *x509Certificates = X509_new();
320 
321     std::string result = connection->CheckServerIdentityLegal(hostName, x509Certificates);
322     EXPECT_GE(result.length(), 0);
323     X509_EXTENSION *ext = X509_EXTENSION_new();
324     X509_add_ext(x509Certificates, ext, -1);
325     result = connection->CheckServerIdentityLegal(hostName, x509Certificates);
326     EXPECT_GE(result.length(), 0);
327 
328     X509_EXTENSION_free(ext);
329     X509_free(x509Certificates);
330 }
331 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest008, testing::ext::TestSize.Level2)332 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest008, testing::ext::TestSize.Level2)
333 {
334     auto connection = std::make_shared<TLSSocketServer::Connection>();
335     std::string hostName = "172.0.0.1";
336     X509 *x509Certificates = X509_new();
337 
338     std::string result = connection->CheckServerIdentityLegal(hostName, x509Certificates);
339     EXPECT_GE(result.length(), 0);
340     X509_EXTENSION *ext = X509_EXTENSION_new();
341     X509_add_ext(x509Certificates, ext, -1);
342     result = connection->CheckServerIdentityLegal(hostName, x509Certificates);
343     EXPECT_GE(result.length(), 0);
344 
345     X509_EXTENSION_free(ext);
346     X509_free(x509Certificates);
347 }
348 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest009, testing::ext::TestSize.Level2)349 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest009, testing::ext::TestSize.Level2)
350 {
351     auto connection = std::make_shared<TLSSocketServer::Connection>();
352     std::string hostName = "testHost";
353     X509 *x509Certificates = X509_new();
354     X509_NAME *subjectName = X509_get_subject_name(x509Certificates);
355     X509_NAME_add_entry_by_txt(subjectName, "CN", MBSTRING_ASC, (unsigned char *)"testHost", -1, -1, 0);
356     int index = X509_get_ext_by_NID(x509Certificates, NID_subject_alt_name, -1);
357     X509_EXTENSION *ext = X509_EXTENSION_new();
358     X509_add_ext(x509Certificates, ext, index);
359     std::string result = connection->CheckServerIdentityLegal(hostName, x509Certificates);
360     EXPECT_GE(result.length(), 0);
361     X509_EXTENSION_free(ext);
362     X509_free(x509Certificates);
363 }
364 
365 extern bool IsIP(const std::string &ip);
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest010, testing::ext::TestSize.Level2)366 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest010, testing::ext::TestSize.Level2)
367 {
368     std::string ip = "192.168.1.1";
369 
370     EXPECT_EQ(IsIP(ip), true);
371     std::string ip2 = "192.168.1";
372     EXPECT_EQ(IsIP(ip2), false);
373     std::string ip3;
374     EXPECT_EQ(IsIP(ip3), false);
375 }
376 
377 extern std::vector<std::string> SplitHostName(std::string &hostName);
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest011, testing::ext::TestSize.Level2)378 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest011, testing::ext::TestSize.Level2)
379 {
380     std::string hostName = "www.example.com";
381     std::vector<std::string> result = TlsSocketServer::SplitHostName(hostName);
382     std::vector<std::string> expect = {"www", "example", "com"};
383     EXPECT_EQ(result, expect);
384 }
385 
386 extern bool SeekIntersection(std::vector<std::string> &vecA, std::vector<std::string> &vecB);
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest012, testing::ext::TestSize.Level2)387 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest012, testing::ext::TestSize.Level2)
388 {
389     std::vector<std::string> vecA = {"apple", "banana", "cherry"};
390     std::vector<std::string> vecB = {"banana", "cherry", "date"};
391     EXPECT_TRUE(SeekIntersection(vecA, vecB));
392 }
393 
394 extern std::vector<std::string> SplitEscapedAltNames(std::string &altNames);
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest014, testing::ext::TestSize.Level2)395 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest014, testing::ext::TestSize.Level2)
396 {
397     std::string altNames = R"("test1", "test2", "test3", "test4")";
398     std::vector<std::string> expected = {""};
399     std::vector<std::string> result = SplitEscapedAltNames(altNames);
400     EXPECT_EQ(result, expected);
401 }
402 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest015, testing::ext::TestSize.Level2)403 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest015, testing::ext::TestSize.Level2)
404 {
405     std::string altNames = "test1";
406     std::vector<std::string> expected = {"test1"};
407     std::vector<std::string> result = SplitEscapedAltNames(altNames);
408     EXPECT_EQ(result, expected);
409 }
410 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest016, testing::ext::TestSize.Level2)411 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest016, testing::ext::TestSize.Level2)
412 {
413     auto tlsSocketServer = new TLSSocketServer();
414     bool callbackCalled = false;
415     tlsSocketServer->GetCertificate([&callbackCalled](int32_t errorNumber, const TlsSocket::X509CertRawData &cert) {
416         EXPECT_EQ(errorNumber, -1);
417         callbackCalled = true;
418     });
419     EXPECT_TRUE(callbackCalled);
420     delete tlsSocketServer;
421 }
422 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest017, testing::ext::TestSize.Level2)423 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest017, testing::ext::TestSize.Level2)
424 {
425     auto tlsSocketServer = new TLSSocketServer();
426     int sockFd = 0;
427     bool callbackCalled = false;
428     tlsSocketServer->GetRemoteCertificate(
429         sockFd, [&callbackCalled](int32_t errorNumber, const TlsSocket::X509CertRawData &cert) {
430         EXPECT_EQ(errorNumber, TlsSocket::TLS_ERR_SYS_EINVAL);
431         callbackCalled = true;
432     });
433     EXPECT_TRUE(callbackCalled);
434     delete tlsSocketServer;
435 }
436 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest018, testing::ext::TestSize.Level2)437 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest018, testing::ext::TestSize.Level2)
438 {
439     constexpr int sockFd = 1;
440     constexpr int testLen = 5;
441     auto tlsSocketServer = new TLSSocketServer();
442     auto connection = std::make_shared<TLSSocketServer::Connection>();
443     connection->remoteRawData_.data.length_ = testLen;
444     tlsSocketServer->clientIdConnections_.emplace(sockFd, connection);
445     bool callbackCalled = false;
446     tlsSocketServer->GetRemoteCertificate(
447         sockFd, [&callbackCalled, testLen](int32_t errorNumber, const TlsSocket::X509CertRawData &cert) {
448         EXPECT_EQ(errorNumber, TlsSocket::TLSSOCKET_SUCCESS);
449         EXPECT_EQ(cert.data.Length(), testLen);
450         callbackCalled = true;
451     });
452     EXPECT_TRUE(callbackCalled);
453     delete tlsSocketServer;
454 }
455 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest019, testing::ext::TestSize.Level2)456 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest019, testing::ext::TestSize.Level2)
457 {
458     constexpr int sockFd = 1;
459     constexpr int testLen = 0;
460     auto tlsSocketServer = new TLSSocketServer();
461     auto connection = std::make_shared<TLSSocketServer::Connection>();
462     connection->remoteRawData_.data.length_ = testLen;
463     tlsSocketServer->clientIdConnections_.emplace(sockFd, connection);
464     bool callbackCalled = false;
465     tlsSocketServer->GetRemoteCertificate(
466         sockFd, [&callbackCalled, testLen](int32_t errorNumber, const TlsSocket::X509CertRawData &cert) {
467         EXPECT_NE(errorNumber, TlsSocket::TLSSOCKET_SUCCESS);
468         EXPECT_EQ(cert.data.Length(), testLen);
469         callbackCalled = true;
470     });
471     EXPECT_TRUE(callbackCalled);
472     delete tlsSocketServer;
473 }
474 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest020, testing::ext::TestSize.Level2)475 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest020, testing::ext::TestSize.Level2)
476 {
477     auto tlsSocketServer = new TLSSocketServer();
478     tlsSocketServer->TLSServerConfiguration_.protocol_ = TlsSocket::TLS_V1_3;
479     bool callbackCalled = false;
480     tlsSocketServer->GetProtocol([&callbackCalled](int32_t errorNumber, const std::string &protocol) {
481         EXPECT_EQ(errorNumber, TlsSocket::TLSSOCKET_SUCCESS);
482         EXPECT_EQ(protocol, TlsSocket::PROTOCOL_TLS_V13);
483         callbackCalled = true;
484     });
485     EXPECT_TRUE(callbackCalled);
486     delete tlsSocketServer;
487 }
488 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest021, testing::ext::TestSize.Level2)489 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest021, testing::ext::TestSize.Level2)
490 {
491     auto tlsSocketServer = new TLSSocketServer();
492     tlsSocketServer->TLSServerConfiguration_.protocol_ = TlsSocket::TLS_V1_2;
493     bool callbackCalled = false;
494     tlsSocketServer->GetProtocol([&callbackCalled](int32_t errorNumber, const std::string &protocol) {
495         EXPECT_EQ(errorNumber, TlsSocket::TLSSOCKET_SUCCESS);
496         EXPECT_EQ(protocol, TlsSocket::PROTOCOL_TLS_V12);
497         callbackCalled = true;
498     });
499     EXPECT_TRUE(callbackCalled);
500     delete tlsSocketServer;
501 }
502 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest022, testing::ext::TestSize.Level2)503 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest022, testing::ext::TestSize.Level2)
504 {
505     auto tlsSocketServer = new TLSSocketServer();
506     constexpr int sockFd = 1;
507     bool callbackCalled = false;
508     tlsSocketServer->GetCipherSuite(sockFd,
509                                     [&callbackCalled](int32_t errorNumber, const std::vector<std::string> &suite) {
510         EXPECT_EQ(errorNumber, TlsSocket::TLS_ERR_SYS_EINVAL);
511         callbackCalled = true;
512     });
513     EXPECT_TRUE(callbackCalled);
514     delete tlsSocketServer;
515 }
516 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest023, testing::ext::TestSize.Level2)517 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest023, testing::ext::TestSize.Level2)
518 {
519     constexpr int sockFd = 1;
520     auto tlsSocketServer = new TLSSocketServer();
521     auto connection = std::make_shared<TLSSocketServer::Connection>();
522     tlsSocketServer->clientIdConnections_.emplace(sockFd, connection);
523 
524     bool callbackCalled = false;
525     tlsSocketServer->GetCipherSuite(sockFd,
526                                     [&callbackCalled](int32_t errorNumber, const std::vector<std::string> &suite) {
527         EXPECT_NE(errorNumber, TlsSocket::TLSSOCKET_SUCCESS);
528         callbackCalled = true;
529     });
530     EXPECT_TRUE(callbackCalled);
531     delete tlsSocketServer;
532 }
533 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest024, testing::ext::TestSize.Level2)534 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest024, testing::ext::TestSize.Level2)
535 {
536     constexpr int sockFd = 1;
537     auto tlsSocketServer = new TLSSocketServer();
538 
539     bool callbackCalled = false;
540     tlsSocketServer->GetSignatureAlgorithms(
541         sockFd, [&callbackCalled](int32_t errorNumber, const std::vector<std::string> &algorithms) {
542         EXPECT_EQ(errorNumber, TlsSocket::TLS_ERR_SYS_EINVAL);
543         callbackCalled = true;
544     });
545     EXPECT_TRUE(callbackCalled);
546     delete tlsSocketServer;
547 }
548 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest025, testing::ext::TestSize.Level2)549 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest025, testing::ext::TestSize.Level2)
550 {
551     constexpr int sockFd = 1;
552     auto tlsSocketServer = new TLSSocketServer();
553     auto connection = std::make_shared<TLSSocketServer::Connection>();
554     tlsSocketServer->clientIdConnections_.emplace(sockFd, connection);
555 
556     bool callbackCalled = false;
557     tlsSocketServer->GetSignatureAlgorithms(
558         sockFd, [&callbackCalled](int32_t errorNumber, const std::vector<std::string> &suite) {
559         EXPECT_NE(errorNumber, TlsSocket::TLSSOCKET_SUCCESS);
560         callbackCalled = true;
561     });
562     EXPECT_TRUE(callbackCalled);
563     delete tlsSocketServer;
564 }
565 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest026, testing::ext::TestSize.Level2)566 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest026, testing::ext::TestSize.Level2)
567 {
568     constexpr int sockFd = 1;
569     auto tlsSocketServer = new TLSSocketServer();
570     auto connection = std::make_shared<TLSSocketServer::Connection>();
571     connection->signatureAlgorithms_ = {"TEST"};
572     tlsSocketServer->clientIdConnections_.emplace(sockFd, connection);
573 
574     bool callbackCalled = false;
575     tlsSocketServer->GetSignatureAlgorithms(
576         sockFd, [&callbackCalled](int32_t errorNumber, const std::vector<std::string> &suite) {
577         EXPECT_EQ(errorNumber, TlsSocket::TLSSOCKET_SUCCESS);
578         callbackCalled = true;
579     });
580     EXPECT_TRUE(callbackCalled);
581     delete tlsSocketServer;
582 }
583 
584 extern void CheckIpAndDnsName(const std::string &hostName, std::vector<std::string> &dnsNames,
585                               std::vector<std::string> &ips, const X509 *x509Certificates,
586                               std::tuple<bool, std::string> &result);
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest027, testing::ext::TestSize.Level2)587 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest027, testing::ext::TestSize.Level2)
588 {
589     auto tlsSocketServer = new TLSSocketServer();
590     std::string hostName = "192.168.1.1";
591     std::vector<std::string> dnsNames = {"www.test.com", "www.example.com"};
592     std::vector<std::string>  ips = {"192.168.1.1", "192.168.1.2"};
593     const X509 *x509Certificates = X509_new();
594     std::tuple<bool, std::string> result;
595     CheckIpAndDnsName(hostName, dnsNames, ips, x509Certificates, result);
596     EXPECT_FALSE(std::get<0>(result));
597     delete tlsSocketServer;
598 }
599 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest028, testing::ext::TestSize.Level2)600 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest028, testing::ext::TestSize.Level2)
601 {
602     auto tlsSocketServer = new TLSSocketServer();
603     std::string hostName = "192.168.1.3";
604     std::vector<std::string> dnsNames = {"www.test.com", "www.example.com"};
605     std::vector<std::string>  ips = {"192.168.1.1", "192.168.1.2"};
606     const X509 *x509Certificates = X509_new();
607     std::tuple<bool, std::string> result;
608     CheckIpAndDnsName(hostName, dnsNames, ips, x509Certificates, result);
609     EXPECT_FALSE(std::get<0>(result));
610     EXPECT_EQ(std::get<1>(result), "IP: 192.168.1.3 is not in the cert's list");
611     delete tlsSocketServer;
612 }
613 
614 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest029, testing::ext::TestSize.Level2)615 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest029, testing::ext::TestSize.Level2)
616 {
617     auto tlsSocketServer = new TLSSocketServer();
618     std::string hostName = "www.test.com";
619     std::vector<std::string> dnsNames = {"www", "test", "com"};
620     std::vector<std::string>  ips = {"192.168.1.1", "192.168.1.2"};
621     const X509 *x509Certificates = X509_new();
622     std::tuple<bool, std::string> result;
623     CheckIpAndDnsName(hostName, dnsNames, ips, x509Certificates, result);
624     EXPECT_TRUE(std::get<0>(result));
625     delete tlsSocketServer;
626 }
627 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest031, testing::ext::TestSize.Level2)628 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest031, testing::ext::TestSize.Level2)
629 {
630     auto connection = std::make_shared<TLSSocketServer::Connection>();
631     std::string hostName = "testHost";
632     X509 *x509Certificates = X509_new();
633     std::string result = connection->CheckServerIdentityLegal(hostName, x509Certificates);
634     ASSERT_EQ(result, "X509 get ext nid error");
635     X509_free(x509Certificates);
636 }
637 
HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest032, testing::ext::TestSize.Level2)638 HWTEST_F(TlsSocketServerBranchTest, TlsSocketServerBranchTest032, testing::ext::TestSize.Level2)
639 {
640     auto connection = std::make_shared<TLSSocketServer::Connection>();
641     std::string hostName = "testHost";
642     X509 *x509Certificates = X509_new();
643     X509_EXTENSION *ext = X509_EXTENSION_new();
644     X509_add_ext(x509Certificates, ext, -1);
645     std::string result = connection->CheckServerIdentityLegal(hostName, x509Certificates);
646     ASSERT_EQ(result, "X509 get ext nid error");
647     X509_EXTENSION_free(ext);
648     X509_free(x509Certificates);
649 }
650 } // namespace TlsSocketServer
651 } // namespace NetStack
652 } // namespace OHOS
653