1 /*
2 * Copyright (c) 2022 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 #include <openssl/rsa.h>
20 #include <openssl/ssl.h>
21 #include <sstream>
22 #include <string>
23 #include <string_view>
24 #include <unistd.h>
25 #include <vector>
26
27 #include "net_address.h"
28 #include "secure_data.h"
29 #include "socket_error.h"
30 #include "socket_state_base.h"
31 #include "tls.h"
32 #include "tls_certificate.h"
33 #include "tls_configuration.h"
34 #include "tls_key.h"
35 #include "tls_socket.h"
36
37 namespace OHOS {
38 namespace NetStack {
39 namespace {
40 const std::string_view PRIVATE_KEY_PEM = "/data/ClientCert/client_rsa_private.pem.unsecure";
41 const std::string_view CA_DER = "/data/ClientCert/ca.crt";
42 const std::string_view CLIENT_CRT = "/data/ClientCert/client.crt";
43 const std::string_view IP_ADDRESS = "/data/Ip/address.txt";
44 const std::string_view PORT = "/data/Ip/port.txt";
45
CheckCaFileExistence(const char * function)46 inline bool CheckCaFileExistence(const char *function)
47 {
48 if (access(CA_DER.data(), 0)) {
49 std::cout << "CA file does not exist! (" << function << ")";
50 return false;
51 }
52 return true;
53 }
54
ChangeToFile(std::string_view fileName)55 std::string ChangeToFile(std::string_view fileName)
56 {
57 std::ifstream file;
58 file.open(fileName);
59 std::stringstream ss;
60 ss << file.rdbuf();
61 std::string infos = ss.str();
62 file.close();
63 return infos;
64 }
65
GetIp(std::string ip)66 std::string GetIp(std::string ip)
67 {
68 return ip.substr(0, ip.length() - 1);
69 }
70 } // namespace
71
72 class TlsSocketTest : public testing::Test {
73 public:
SetUpTestCase()74 static void SetUpTestCase() {}
75
TearDownTestCase()76 static void TearDownTestCase() {}
77
SetUp()78 virtual void SetUp() {}
79
TearDown()80 virtual void TearDown() {}
81 };
82
83 HWTEST_F(TlsSocketTest, bindInterface, testing::ext::TestSize.Level2)
84 {
85 if (!CheckCaFileExistence("bindInterface")) {
86 return;
87 }
88
89 TLSSocket server;
90 NetAddress address;
91
92 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
93 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
94 address.SetFamilyBySaFamily(AF_INET);
95
__anon87de19e50202(int32_t errCode) 96 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
97 }
98
99 HWTEST_F(TlsSocketTest, connectInterface, testing::ext::TestSize.Level2)
100 {
101 if (!CheckCaFileExistence("connectInterface")) {
102 return;
103 }
104
105 TLSConnectOptions options;
106 TLSSocket server;
107
108 TLSSecureOptions secureOption;
109 NetAddress address;
110
111 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
112 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
113 address.SetFamilyBySaFamily(AF_INET);
114
115 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
116 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
117 secureOption.SetCaChain(caVec);
118 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
119
120 options.SetNetAddress(address);
121 options.SetTlsSecureOptions(secureOption);
122
__anon87de19e50302(int32_t errCode) 123 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
124
__anon87de19e50402(int32_t errCode) 125 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
126
127 const std::string data = "how do you do? this is connectInterface";
128 TCPSendOptions tcpSendOptions;
129 tcpSendOptions.SetData(data);
__anon87de19e50502(int32_t errCode) 130 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
131 sleep(2);
132
__anon87de19e50602(int32_t errCode) 133 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
134 sleep(2);
135 }
136
137 HWTEST_F(TlsSocketTest, closeInterface, testing::ext::TestSize.Level2)
138 {
139 if (!CheckCaFileExistence("closeInterface")) {
140 return;
141 }
142
143 TLSConnectOptions options;
144 TLSSocket server;
145
146 TLSSecureOptions secureOption;
147 NetAddress address;
148
149 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
150 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
151 address.SetFamilyBySaFamily(AF_INET);
152
153 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
154 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
155 secureOption.SetCaChain(caVec);
156 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
157
158 options.SetNetAddress(address);
159 options.SetTlsSecureOptions(secureOption);
160
__anon87de19e50702(int32_t errCode) 161 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
162
__anon87de19e50802(int32_t errCode) 163 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
164
165 const std::string data = "how do you do? this is closeInterface";
166 TCPSendOptions tcpSendOptions;
167 tcpSendOptions.SetData(data);
168
__anon87de19e50902(int32_t errCode) 169 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
170 sleep(2);
171
__anon87de19e50a02(int32_t errCode) 172 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
173 }
174
175 HWTEST_F(TlsSocketTest, sendInterface, testing::ext::TestSize.Level2)
176 {
177 if (!CheckCaFileExistence("sendInterface")) {
178 return;
179 }
180 TLSConnectOptions options;
181 TLSSocket server;
182
183 TLSSecureOptions secureOption;
184 NetAddress address;
185
186 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
187 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
188 address.SetFamilyBySaFamily(AF_INET);
189
190 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
191 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
192 secureOption.SetCaChain(caVec);
193 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
194
195 options.SetNetAddress(address);
196 options.SetTlsSecureOptions(secureOption);
197
__anon87de19e50b02(int32_t errCode) 198 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
199
__anon87de19e50c02(int32_t errCode) 200 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
201
202 const std::string data = "how do you do? this is sendInterface";
203 TCPSendOptions tcpSendOptions;
204 tcpSendOptions.SetData(data);
205
__anon87de19e50d02(int32_t errCode) 206 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
207 sleep(2);
208
__anon87de19e50e02(int32_t errCode) 209 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
210 }
211
212 HWTEST_F(TlsSocketTest, getRemoteAddressInterface, testing::ext::TestSize.Level2)
213 {
214 if (!CheckCaFileExistence("getRemoteAddressInterface")) {
215 return;
216 }
217
218 TLSConnectOptions options;
219 TLSSocket server;
220 TLSSecureOptions secureOption;
221 NetAddress address;
222
223 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
224 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
225 address.SetFamilyBySaFamily(AF_INET);
226
227 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
228 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
229 secureOption.SetCaChain(caVec);
230 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
231
232 options.SetNetAddress(address);
233 options.SetTlsSecureOptions(secureOption);
234
__anon87de19e50f02(int32_t errCode) 235 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
236
__anon87de19e51002(int32_t errCode) 237 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
238
239 NetAddress netAddress;
__anon87de19e51102(int32_t errCode, const NetAddress &address) 240 server.GetRemoteAddress([&netAddress](int32_t errCode, const NetAddress &address) {
241 EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS);
242 netAddress.SetAddress(address.GetAddress());
243 netAddress.SetPort(address.GetPort());
244 netAddress.SetFamilyBySaFamily(address.GetSaFamily());
245 });
246 EXPECT_STREQ(netAddress.GetAddress().c_str(), GetIp(ChangeToFile(IP_ADDRESS)).c_str());
247 EXPECT_EQ(address.GetPort(), std::atoi(ChangeToFile(PORT).c_str()));
248 EXPECT_EQ(netAddress.GetSaFamily(), AF_INET);
249
250 const std::string data = "how do you do? this is getRemoteAddressInterface";
251 TCPSendOptions tcpSendOptions;
252 tcpSendOptions.SetData(data);
253
__anon87de19e51202(int32_t errCode) 254 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
255
__anon87de19e51302(int32_t errCode) 256 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
257 }
258
259 HWTEST_F(TlsSocketTest, getStateInterface, testing::ext::TestSize.Level2)
260 {
261 if (!CheckCaFileExistence("getRemoteAddressInterface")) {
262 return;
263 }
264
265 TLSConnectOptions options;
266 TLSSocket server;
267 TLSSecureOptions secureOption;
268 NetAddress address;
269
270 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
271 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
272 address.SetFamilyBySaFamily(AF_INET);
273
274 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
275 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
276 secureOption.SetCaChain(caVec);
277 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
278
279 options.SetNetAddress(address);
280 options.SetTlsSecureOptions(secureOption);
281
__anon87de19e51402(int32_t errCode) 282 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
__anon87de19e51502(int32_t errCode) 283 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
284
285 SocketStateBase TlsSocketstate;
__anon87de19e51602(int32_t errCode, const SocketStateBase &state) 286 server.GetState([&TlsSocketstate](int32_t errCode, const SocketStateBase &state) {
287 EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS);
288 TlsSocketstate = state;
289 });
290 std::cout << "TlsSocketstate.IsClose(): " << TlsSocketstate.IsClose() << std::endl;
291 EXPECT_TRUE(TlsSocketstate.IsBound());
292 EXPECT_TRUE(!TlsSocketstate.IsClose());
293 EXPECT_TRUE(TlsSocketstate.IsConnected());
294
295 const std::string data = "how do you do? this is getStateInterface";
296 TCPSendOptions tcpSendOptions;
297 tcpSendOptions.SetData(data);
__anon87de19e51702(int32_t errCode) 298 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
299
300 sleep(2);
301
__anon87de19e51802(int32_t errCode) 302 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
303 }
304
305 HWTEST_F(TlsSocketTest, getCertificateInterface, testing::ext::TestSize.Level2)
306 {
307 if (!CheckCaFileExistence("getCertificateInterface")) {
308 return;
309 }
310 TLSSocket server;
311 TLSConnectOptions options;
312 TCPSendOptions tcpSendOptions;
313 TLSSecureOptions secureOption;
314 NetAddress address;
315 const std::string data = "how do you do? This is UT test getCertificateInterface";
316
317 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
318 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
319 address.SetFamilyBySaFamily(AF_INET);
320
321 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
322 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
323 secureOption.SetCaChain(caVec);
324 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
325
326 options.SetNetAddress(address);
327 options.SetTlsSecureOptions(secureOption);
328
__anon87de19e51902(int32_t errCode) 329 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
330
__anon87de19e51a02(int32_t errCode) 331 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
332
333 tcpSendOptions.SetData(data);
__anon87de19e51b02(int32_t errCode) 334 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
335
336 server.GetCertificate(
__anon87de19e51c02(int32_t errCode, const X509CertRawData &cert) 337 [](int32_t errCode, const X509CertRawData &cert) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
338
339 sleep(2);
__anon87de19e51d02(int32_t errCode) 340 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
341 }
342
343 HWTEST_F(TlsSocketTest, getRemoteCertificateInterface, testing::ext::TestSize.Level2)
344 {
345 if (!CheckCaFileExistence("getRemoteCertificateInterface")) {
346 return;
347 }
348 TLSSocket server;
349 TLSConnectOptions options;
350 TCPSendOptions tcpSendOptions;
351 TLSSecureOptions secureOption;
352 NetAddress address;
353 const std::string data = "how do you do? This is UT test getRemoteCertificateInterface";
354
355 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
356 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
357 address.SetFamilyBySaFamily(AF_INET);
358
359 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
360 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
361 secureOption.SetCaChain(caVec);
362 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
363
364 options.SetNetAddress(address);
365 options.SetTlsSecureOptions(secureOption);
366
__anon87de19e51e02(int32_t errCode) 367 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
368
__anon87de19e51f02(int32_t errCode) 369 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
370
371 tcpSendOptions.SetData(data);
372
__anon87de19e52002(int32_t errCode) 373 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
374
375 server.GetRemoteCertificate(
__anon87de19e52102(int32_t errCode, const X509CertRawData &cert) 376 [](int32_t errCode, const X509CertRawData &cert) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
377
378 sleep(2);
__anon87de19e52202(int32_t errCode) 379 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
380 }
381
382 HWTEST_F(TlsSocketTest, protocolInterface, testing::ext::TestSize.Level2)
383 {
384 if (!CheckCaFileExistence("protocolInterface")) {
385 return;
386 }
387 TLSConnectOptions options;
388 TLSSocket server;
389 TLSSecureOptions secureOption;
390 NetAddress address;
391
392 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
393 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
394 address.SetFamilyBySaFamily(AF_INET);
395
396 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
397 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
398 secureOption.SetCaChain(caVec);
399 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
400 secureOption.SetCipherSuite("AES256-SHA256");
401 std::string protocolV1_3 = "TLSv1.3";
402 std::vector<std::string> protocolVec = {protocolV1_3};
403 secureOption.SetProtocolChain(protocolVec);
404
405 options.SetNetAddress(address);
406 options.SetTlsSecureOptions(secureOption);
407
__anon87de19e52302(int32_t errCode) 408 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
409
__anon87de19e52402(int32_t errCode) 410 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
411
412 const std::string data = "how do you do? this is protocolInterface";
413 TCPSendOptions tcpSendOptions;
414 tcpSendOptions.SetData(data);
415
__anon87de19e52502(int32_t errCode) 416 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
417 std::string getProtocolVal;
__anon87de19e52602(int32_t errCode, const std::string &protocol) 418 server.GetProtocol([&getProtocolVal](int32_t errCode, const std::string &protocol) {
419 EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS);
420 getProtocolVal = protocol;
421 });
422 EXPECT_STREQ(getProtocolVal.c_str(), "TLSv1.3");
423
424 SocketStateBase stateBase;
__anon87de19e52702(int32_t errCode, SocketStateBase state) 425 server.GetState([&stateBase](int32_t errCode, SocketStateBase state) {
426 if (errCode == TLSSOCKET_SUCCESS) {
427 EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS);
428 stateBase.SetIsBound(state.IsBound());
429 stateBase.SetIsClose(state.IsClose());
430 stateBase.SetIsConnected(state.IsConnected());
431 }
432 });
433 EXPECT_TRUE(stateBase.IsConnected());
434 sleep(2);
435
__anon87de19e52802(int32_t errCode) 436 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
437 }
438
439 HWTEST_F(TlsSocketTest, getCipherSuiteInterface, testing::ext::TestSize.Level2)
440 {
441 if (!CheckCaFileExistence("getCipherSuiteInterface")) {
442 return;
443 }
444
445 TLSConnectOptions options;
446 TLSSocket server;
447 TLSSecureOptions secureOption;
448 NetAddress address;
449
450 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
451 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
452 address.SetFamilyBySaFamily(AF_INET);
453
454 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
455 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
456 secureOption.SetCaChain(caVec);
457 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
458 secureOption.SetCipherSuite("AES256-SHA256");
459 std::string protocolV1_3 = "TLSv1.3";
460 std::vector<std::string> protocolVec = {protocolV1_3};
461 secureOption.SetProtocolChain(protocolVec);
462
463 options.SetNetAddress(address);
464 options.SetTlsSecureOptions(secureOption);
465
466 bool flag = false;
__anon87de19e52902(int32_t errCode) 467 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
__anon87de19e52a02(int32_t errCode) 468 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
469
470 const std::string data = "how do you do? This is getCipherSuiteInterface";
471 TCPSendOptions tcpSendOptions;
472 tcpSendOptions.SetData(data);
__anon87de19e52b02(int32_t errCode) 473 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
474
475 std::vector<std::string> cipherSuite;
__anon87de19e52c02(int32_t errCode, const std::vector<std::string> &suite) 476 server.GetCipherSuite([&cipherSuite](int32_t errCode, const std::vector<std::string> &suite) {
477 if (errCode == TLSSOCKET_SUCCESS) {
478 cipherSuite = suite;
479 }
480 });
481
482 for (auto const &iter : cipherSuite) {
483 if (iter == "AES256-SHA256") {
484 flag = true;
485 }
486 }
487
488 EXPECT_TRUE(flag);
489 sleep(2);
490
__anon87de19e52d02(int32_t errCode) 491 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
492 }
493
494 HWTEST_F(TlsSocketTest, getSignatureAlgorithmsInterface, testing::ext::TestSize.Level2)
495 {
496 if (!CheckCaFileExistence("getSignatureAlgorithmsInterface")) {
497 return;
498 }
499 TLSConnectOptions options;
500 TLSSocket server;
501 TLSSecureOptions secureOption;
502 NetAddress address;
503
504 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
505 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
506 address.SetFamilyBySaFamily(AF_INET);
507
508 std::string signatureAlgorithmVec = {"rsa_pss_rsae_sha256:ECDSA+SHA256"};
509 secureOption.SetSignatureAlgorithms(signatureAlgorithmVec);
510 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
511 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
512 secureOption.SetCaChain(caVec);
513 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
514 std::string protocolV1_3 = "TLSv1.3";
515 std::vector<std::string> protocolVec = {protocolV1_3};
516 secureOption.SetProtocolChain(protocolVec);
517
518 options.SetNetAddress(address);
519 options.SetTlsSecureOptions(secureOption);
520
521 bool flag = false;
__anon87de19e52e02(int32_t errCode) 522 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
523
__anon87de19e52f02(int32_t errCode) 524 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
525
526 const std::string data = "how do you do? this is getSignatureAlgorithmsInterface";
527 TCPSendOptions tcpSendOptions;
528 tcpSendOptions.SetData(data);
__anon87de19e53002(int32_t errCode) 529 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
530
531 std::vector<std::string> signatureAlgorithms;
__anon87de19e53102(int32_t errCode, const std::vector<std::string> &algorithms) 532 server.GetSignatureAlgorithms([&signatureAlgorithms](int32_t errCode, const std::vector<std::string> &algorithms) {
533 if (errCode == TLSSOCKET_SUCCESS) {
534 signatureAlgorithms = algorithms;
535 }
536 });
537 for (auto const &iter : signatureAlgorithms) {
538 if (iter == "ECDSA+SHA256") {
539 flag = true;
540 }
541 }
542 EXPECT_TRUE(flag);
543 sleep(2);
__anon87de19e53202(int32_t errCode) 544 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
545 }
546
547 HWTEST_F(TlsSocketTest, onMessageDataInterface, testing::ext::TestSize.Level2)
548 {
549 if (!CheckCaFileExistence("tlsSocketOnMessageData")) {
550 return;
551 }
552 std::string getData = "server->client";
553 TLSConnectOptions options;
554 TLSSocket server;
555 TLSSecureOptions secureOption;
556 NetAddress address;
557
558 address.SetAddress(GetIp(ChangeToFile(IP_ADDRESS)));
559 address.SetPort(std::atoi(ChangeToFile(PORT).c_str()));
560 address.SetFamilyBySaFamily(AF_INET);
561
562 secureOption.SetKey(SecureData(ChangeToFile(PRIVATE_KEY_PEM)));
563 std::vector<std::string> caVec = {ChangeToFile(CA_DER)};
564 secureOption.SetCaChain(caVec);
565 secureOption.SetCert(ChangeToFile(CLIENT_CRT));
566 secureOption.SetCipherSuite("AES256-SHA256");
567 std::string protocolV1_3 = "TLSv1.3";
568 std::vector<std::string> protocolVec = {protocolV1_3};
569 secureOption.SetProtocolChain(protocolVec);
570
571 options.SetNetAddress(address);
572 options.SetTlsSecureOptions(secureOption);
573
__anon87de19e53302(int32_t errCode) 574 server.Bind(address, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
575
__anon87de19e53402(int32_t errCode) 576 server.Connect(options, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
__anon87de19e53502(const std::string &data, const SocketRemoteInfo &remoteInfo) 577 server.OnMessage([&getData](const std::string &data, const SocketRemoteInfo &remoteInfo) {
578 if (data == getData) {
579 EXPECT_TRUE(true);
580 } else {
581 EXPECT_TRUE(false);
582 }
583 });
584
585 const std::string data = "how do you do? this is tlsSocketOnMessageData";
586 TCPSendOptions tcpSendOptions;
587 tcpSendOptions.SetData(data);
__anon87de19e53602(int32_t errCode) 588 server.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
589
590 sleep(2);
__anon87de19e53702(int32_t errCode) 591 (void)server.Close([](int32_t errCode) { EXPECT_TRUE(errCode == TLSSOCKET_SUCCESS); });
592 }
593 } // namespace NetStack
594 } // namespace OHOS
595