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 <gtest/gtest.h>
17 #include <iostream>
18
19 #include <openssl/ssl.h>
20
21 #define private public
22 #include "accesstoken_kit.h"
23 #include "tls_socket.h"
24 #include "socket_remote_info.h"
25 #include "token_setproc.h"
26
27 namespace OHOS {
28 namespace NetStack {
29 namespace {
30 using namespace testing::ext;
31 using namespace Security::AccessToken;
32 using Security::AccessToken::AccessTokenID;
33 static constexpr const char *KEY_PASS = "";
34 static constexpr const char *PROTOCOL12 = "TLSv1.2";
35 static constexpr const char *PROTOCOL13 = "TLSv1.3";
36 static constexpr const char *IP_ADDRESS = "127.0.0.1";
37 static constexpr const char *ALPN_PROTOCOL = "http/1.1";
38 static constexpr const char *SIGNATURE_ALGORITHM = "rsa_pss_rsae_sha256:ECDSA+SHA256";
39 static constexpr const char *CIPHER_SUITE = "AES256-SHA256";
40 static constexpr const char *SEND_DATA = "How do you do";
41 static constexpr const char *SEND_DATA_EMPTY = "";
42 static constexpr const size_t MAX_BUFFER_SIZE = 8192;
43 const int PORT = 7838;
44 const int SOCKET_FD = 5;
45 const int SSL_ERROR_RETURN = -1;
46 static char g_clientFile[] =
47 "-----BEGIN CERTIFICATE-----\r\n"
48 "MIIDezCCAmMCFD6h5R4QvySV9q9mC6s31qQFLX14MA0GCSqGSIb3DQEBCwUAMHgx\r\n"
49 "CzAJBgNVBAYTAkNOMQswCQYDVQQIDAJHRDELMAkGA1UEBwwCU1oxDDAKBgNVBAoM\r\n"
50 "A0NPTTEMMAoGA1UECwwDTlNQMQswCQYDVQQDDAJDQTEmMCQGCSqGSIb3DQEJARYX\r\n"
51 "emhhbmd6aGV3ZWkwMTAzQDE2My5jb20wHhcNMjIwNDI0MDIwMjU3WhcNMjMwNDI0\r\n"
52 "MDIwMjU3WjB8MQswCQYDVQQGEwJDTjELMAkGA1UECAwCR0QxCzAJBgNVBAcMAlNa\r\n"
53 "MQwwCgYDVQQKDANDT00xDDAKBgNVBAsMA05TUDEPMA0GA1UEAwwGQ0xJRU5UMSYw\r\n"
54 "JAYJKoZIhvcNAQkBFhd6aGFuZ3poZXdlaTAxMDNAMTYzLmNvbTCCASIwDQYJKoZI\r\n"
55 "hvcNAQEBBQADggEPADCCAQoCggEBAKlc63+j5C7tLoaecpdhzzZtLy8iNSi6oLHc\r\n"
56 "+bPib1XWz1zcQ4On5ncGuuLSV2Tyse4tSsDbPycd8b9Teq6gdGrvirtGXau82zAq\r\n"
57 "no+t0mxVtV1r0OkSe+hnIrYKxTE5UDeAM319MSxWlCR0bg0uEAuVBPQpld5A9PQT\r\n"
58 "YCLbv4cTwB0sIKupsnNbrn2AsAlCFd288XeuTN+N87m05cDkprAkqkCJfAtRnejV\r\n"
59 "k+vbS+H6toR3P9PVQJXC77oM7cDOjR8AwpkRRA890XUWoQLwhHXvDpGPwKK+lLnG\r\n"
60 "FswiaHy3silUIOidwk7E/81BOqXSk77oUG6UQrVilkmu6g79VssCAwEAATANBgkq\r\n"
61 "hkiG9w0BAQsFAAOCAQEAOeqp+hFVRs4YB3UjU/3bvAUFQLS97gapCp2lk6jS88jt\r\n"
62 "uNeyvwulOAtZEbcoIIvzzNxvBDOVibTJ6gZU9P9g0WyRu2RTgy+UggNwH8u8KZzM\r\n"
63 "DT8sxuoYvRcEWbOhlNQgACa7AlQSLQifo8nvEMS2i9o8WHoHu42MRDYOHYVIwWXH\r\n"
64 "h6mZzfo+zrPyv3NFlwlWqaNiTGgnGCXzlVK3p5YYqLbNVYpy0U5FBxQ7fITsqcbK\r\n"
65 "PusAAEZzPxm8Epo647M28gNkdEEM/7bqhSTJO+jfkojgyQt2ghlw+NGCmG4dJGZb\r\n"
66 "yA7Z3PBj8aqEwmRUF8SAR1bxWBGk2IYRwgStuwvusg==\r\n"
67 "-----END CERTIFICATE-----\r\n";
68
69 static char g_caCrtFile[] =
70 "Certificate:\r\n"
71 " Data:\r\n"
72 " Version: 3 (0x2)\r\n"
73 " Serial Number: 1 (0x1)\r\n"
74 " Signature Algorithm: sha256WithRSAEncryption\r\n"
75 " Issuer: C=CN, ST=beijing, O=ahaha Inc, OU=Root CA, CN=ahaha CA\r\n"
76 " Validity\r\n"
77 " Not Before: Aug 23 07:33:55 2022 GMT\r\n"
78 " Not After : Aug 23 07:33:55 2023 GMT\r\n"
79 " Subject: C=CN, ST=beijing, O=ahaha Inc, OU=Root CA, CN=ahaha CA\r\n"
80 " Subject Public Key Info:\r\n"
81 " Public Key Algorithm: rsaEncryption\r\n"
82 " RSA Public-Key: (2048 bit)\r\n"
83 " Modulus:\r\n"
84 " 00:9d:df:68:f7:7b:78:0b:21:f3:6f:24:60:ef:ce:\r\n"
85 " 02:90:24:df:c4:d3:f3:e4:26:6c:c7:12:bf:28:cd:\r\n"
86 " 38:2d:3f:ab:76:11:64:ce:6b:f6:07:fd:35:1e:b9:\r\n"
87 " ec:22:72:03:4d:eb:d2:94:49:2d:82:44:6c:72:59:\r\n"
88 " 14:ab:e7:0c:72:32:3e:ad:fa:9d:52:da:24:8d:e9:\r\n"
89 " a4:10:d7:dd:34:66:df:7e:e0:0e:66:53:8b:ee:91:\r\n"
90 " 07:9a:ce:2a:85:25:09:77:3d:5f:75:1c:a1:b3:ab:\r\n"
91 " 86:3b:21:28:f8:43:aa:f0:0b:7d:4d:f9:df:85:33:\r\n"
92 " 4a:3b:ff:e4:03:59:25:62:a1:e9:da:92:63:02:93:\r\n"
93 " bd:f9:df:6e:c6:57:a7:d2:e6:7b:37:14:a9:ba:69:\r\n"
94 " 71:0c:c5:4f:66:fe:67:66:5c:8d:d7:04:4d:d8:f3:\r\n"
95 " 0b:c0:0b:7d:49:eb:68:94:28:f6:31:0f:0d:2a:03:\r\n"
96 " 70:a7:97:f9:38:90:36:d4:4b:39:4b:53:a5:2c:32:\r\n"
97 " 72:f2:41:86:32:13:3c:40:2d:3f:e8:63:d3:8c:8a:\r\n"
98 " 83:79:d3:20:f6:bc:cd:97:3e:94:91:4e:3c:74:8d:\r\n"
99 " 9a:fa:29:de:c4:a5:f7:e1:e2:06:55:e6:6c:41:0f:\r\n"
100 " 60:3b:90:de:3a:84:ef:3a:77:79:27:00:23:55:66:\r\n"
101 " ca:81\r\n"
102 " Exponent: 65537 (0x10001)\r\n"
103 " X509v3 extensions:\r\n"
104 " X509v3 Basic Constraints:\r\n"
105 " CA:TRUE\r\n"
106 " Signature Algorithm: sha256WithRSAEncryption\r\n"
107 " 61:3e:39:71:7f:b1:50:dd:71:97:cd:dc:a9:4b:72:96:0a:12:\r\n"
108 " c1:18:fd:35:b5:e0:97:1b:76:58:22:8d:cd:75:51:0f:ba:04:\r\n"
109 " 00:94:6a:46:d5:3a:c5:ac:ea:7d:9c:ec:6f:19:b6:f1:2b:06:\r\n"
110 " e9:bb:cb:49:24:34:0b:55:bd:02:19:24:19:85:bb:e4:a4:80:\r\n"
111 " f4:d6:90:82:7e:81:5c:9b:89:d4:15:ed:3a:b7:a2:37:59:40:\r\n"
112 " db:b4:18:25:90:2e:ae:82:f9:a8:0c:9d:bd:c7:8c:54:85:ed:\r\n"
113 " 07:d1:70:1d:ee:a1:92:bd:12:97:83:4d:9e:9e:b7:01:b5:56:\r\n"
114 " a5:1f:31:6e:a1:48:68:a4:4f:1c:fa:b0:38:27:47:12:eb:55:\r\n"
115 " a3:45:f7:e3:18:ba:d7:85:3c:1f:2c:1e:5e:38:75:5e:80:8a:\r\n"
116 " fd:1c:84:4f:9b:ef:85:b7:79:89:d7:43:eb:d4:fb:c5:51:5b:\r\n"
117 " 84:6f:0e:06:32:54:13:e4:a7:e2:20:2d:b8:fa:2d:09:f8:8f:\r\n"
118 " dd:01:19:39:cc:23:c0:d1:39:19:9a:f7:7c:53:63:bf:ea:be:\r\n"
119 " 04:9b:af:3e:6e:1e:77:c8:b9:0b:78:e9:0e:62:a7:51:db:1e:\r\n"
120 " c0:63:4d:4d:14:ff:ca:44:7f:15:e4:fa:98:1e:3d:58:c2:b6:\r\n"
121 " 5a:64:68:d0\r\n"
122 "-----BEGIN CERTIFICATE-----\r\n"
123 "MIIDazCCAlOgAwIBAgIBATANBgkqhkiG9w0BAQsFADBwMQswCQYDVQQGEwJDTjEQ\r\n"
124 "MA4GA1UECAwHYmVpamluZzEdMBsGA1UECgwUR2xvYmFsIEdvb2dsZSBDQSBJbmMx\r\n"
125 "EDAOBgNVBAsMB1Jvb3QgQ0ExHjAcBgNVBAMMFUdsb2JhbCBHb29nbGUgUm9vdCBD\r\n"
126 "QTAeFw0yMjA4MjMwNzMzNTVaFw0yMzA4MjMwNzMzNTVaMHAxCzAJBgNVBAYTAkNO\r\n"
127 "MRAwDgYDVQQIDAdiZWlqaW5nMR0wGwYDVQQKDBRHbG9iYWwgR29vZ2xlIENBIElu\r\n"
128 "YzEQMA4GA1UECwwHUm9vdCBDQTEeMBwGA1UEAwwVR2xvYmFsIEdvb2dsZSBSb290\r\n"
129 "IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnd9o93t4CyHzbyRg\r\n"
130 "784CkCTfxNPz5CZsxxK/KM04LT+rdhFkzmv2B/01HrnsInIDTevSlEktgkRsclkU\r\n"
131 "q+cMcjI+rfqdUtokjemkENfdNGbffuAOZlOL7pEHms4qhSUJdz1fdRyhs6uGOyEo\r\n"
132 "+EOq8At9TfnfhTNKO//kA1klYqHp2pJjApO9+d9uxlen0uZ7NxSpumlxDMVPZv5n\r\n"
133 "ZlyN1wRN2PMLwAt9SetolCj2MQ8NKgNwp5f5OJA21Es5S1OlLDJy8kGGMhM8QC0/\r\n"
134 "6GPTjIqDedMg9rzNlz6UkU48dI2a+inexKX34eIGVeZsQQ9gO5DeOoTvOnd5JwAj\r\n"
135 "VWbKgQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBh\r\n"
136 "Pjlxf7FQ3XGXzdypS3KWChLBGP01teCXG3ZYIo3NdVEPugQAlGpG1TrFrOp9nOxv\r\n"
137 "GbbxKwbpu8tJJDQLVb0CGSQZhbvkpID01pCCfoFcm4nUFe06t6I3WUDbtBglkC6u\r\n"
138 "gvmoDJ29x4xUhe0H0XAd7qGSvRKXg02enrcBtValHzFuoUhopE8c+rA4J0cS61Wj\r\n"
139 "RffjGLrXhTwfLB5eOHVegIr9HIRPm++Ft3mJ10Pr1PvFUVuEbw4GMlQT5KfiIC24\r\n"
140 "+i0J+I/dARk5zCPA0TkZmvd8U2O/6r4Em68+bh53yLkLeOkOYqdR2x7AY01NFP/K\r\n"
141 "RH8V5PqYHj1YwrZaZGjQ\r\n"
142 "-----END CERTIFICATE-----\r\n";
143
144 static char g_priKeyFile[] =
145 "-----BEGIN RSA PRIVATE KEY-----"
146 "MIIEowIBAAKCAQEAqVzrf6PkLu0uhp5yl2HPNm0vLyI1KLqgsdz5s+JvVdbPXNxD"
147 "g6fmdwa64tJXZPKx7i1KwNs/Jx3xv1N6rqB0au+Ku0Zdq7zbMCqej63SbFW1XWvQ"
148 "6RJ76GcitgrFMTlQN4AzfX0xLFaUJHRuDS4QC5UE9CmV3kD09BNgItu/hxPAHSwg"
149 "q6myc1uufYCwCUIV3bzxd65M343zubTlwOSmsCSqQIl8C1Gd6NWT69tL4fq2hHc/"
150 "09VAlcLvugztwM6NHwDCmRFEDz3RdRahAvCEde8OkY/Aor6UucYWzCJofLeyKVQg"
151 "6J3CTsT/zUE6pdKTvuhQbpRCtWKWSa7qDv1WywIDAQABAoIBAFGpbCPvcmbuFjDy"
152 "1W4Iy1EC9G1VoSwyUKlyUzRZSjWpjfLIggVJP+bEZ/hWU61pGEIvtIupK5pA5f/K"
153 "0KzC0V9+gPYrx563QTjIVAwTVBLIgNq60dCQCQ7WK/Z62voRGIyqVCl94+ftFyE8"
154 "wpO4UiRDhk/0fT7dMz882G32ZzNJmY9eHu+yOaRctJW2gRBROHpQfDGBCz7w8s2j"
155 "ulIcnvwGOrvVllsL+vgY95M0LOq0W8ObbUSlawTnNTSRxFL68Hz5EaVJ19EYvEcC"
156 "eWnpEqIfF8OhQ+mYbdrAutXCkqJLz3rdu5P2Lbk5Ht5ETfr7rtUzvb4+ExIcxVOs"
157 "eys8EgECgYEA29tTxJOy2Cb4DKB9KwTErD1sFt9Ed+Z/A3RGmnM+/h75DHccqS8n"
158 "g9DpvHVMcMWYFVYGlEHC1F+bupM9CgxqQcVhGk/ysJ5kXF6lSTnOQxORnku3HXnV"
159 "4QzgKtLfHbukW1Y2RZM3aCz+Hg+bJrpacWyWZ4tRWNYsO58JRaubZjsCgYEAxTSP"
160 "yUBleQejl5qO76PGUUs2W8+GPr492NJGb63mEiM1zTYLVN0uuDJ2JixzHb6o1NXZ"
161 "6i00pSksT3+s0eiBTRnF6BJ0y/8J07ZnfQQXRAP8ypiZtd3jdOnUxEHfBw2QaIdP"
162 "tVdUc2mpIhosAYT9sWpHYvlUqTCdeLwhkYfgeLECgYBoajjVcmQM3i0OKiZoCOKy"
163 "/pTYI/8rho+p/04MylEPdXxIXEWDYD6/DrgDZh4ArQc2kt2bCcRTAnk+WfEyVYUd"
164 "aXVdfry+/uqhJ94N8eMw3hlZeZIk8JkQQgIwtGd8goJjUoWB85Hr6vphIn5IHVcY"
165 "6T5hPLxMmaL2SeioawDpwwKBgQCFXjDH6Hc3zQTEKND2HIqou/b9THH7yOlG056z"
166 "NKZeKdXe/OfY8uT/yZDB7FnGCgVgO2huyTfLYvcGpNAZ/eZEYGPJuYGn3MmmlruS"
167 "fsvFQfUahu2dY3zKusEcIXhV6sR5DNnJSFBi5VhvKcgNFwYDkF7K/thUu/4jgwgo"
168 "xf33YQKBgDQffkP1jWqT/pzlVLFtF85/3eCC/uedBfxXknVMrWE+CM/Vsx9cvBZw"
169 "hi15LA5+hEdbgvj87hmMiCOc75e0oz2Rd12ZoRlBVfbncH9ngfqBNQElM7Bueqoc"
170 "JOpKV+gw0gQtiu4beIdFnYsdZoZwrTjC4rW7OI0WYoLJabMFFh3I"
171 "-----END RSA PRIVATE KEY-----";
172
BaseOption()173 TLSConnectOptions BaseOption()
174 {
175 TLSSecureOptions secureOption;
176 SecureData structureData(g_priKeyFile);
177 secureOption.SetKey(structureData);
178 std::vector<std::string> caChain;
179 caChain.push_back(g_caCrtFile);
180 secureOption.SetCaChain(caChain);
181 secureOption.SetCert(g_clientFile);
182 secureOption.SetCipherSuite(CIPHER_SUITE);
183 secureOption.SetSignatureAlgorithms(SIGNATURE_ALGORITHM);
184 std::vector<std::string> protocol;
185 protocol.push_back(PROTOCOL13);
186 secureOption.SetProtocolChain(protocol);
187
188 TLSConnectOptions connectOptions;
189 connectOptions.SetTlsSecureOptions(secureOption);
190 NetAddress netAddress;
191 netAddress.SetAddress(IP_ADDRESS);
192 netAddress.SetPort(0);
193 netAddress.SetFamilyBySaFamily(AF_INET);
194 connectOptions.SetNetAddress(netAddress);
195 std::vector<std::string> alpnProtocols;
196 alpnProtocols.push_back(ALPN_PROTOCOL);
197 connectOptions.SetAlpnProtocols(alpnProtocols);
198 return connectOptions;
199 }
200
201 HapInfoParams testInfoParms = {.bundleName = "TlsSocketBranchTest",
202 .userID = 1,
203 .instIndex = 0,
204 .appIDDesc = "test"};
205
206 PermissionDef testPermDef = {
207 .permissionName = "ohos.permission.INTERNET",
208 .bundleName = "TlsSocketBranchTest",
209 .grantMode = 1,
210 .label = "label",
211 .labelId = 1,
212 .description = "Test Tls Socket Branch",
213 .descriptionId = 1,
214 .availableLevel = APL_SYSTEM_BASIC,
215 };
216
217 PermissionStateFull testState = {
218 .grantFlags = {2},
219 .grantStatus = {PermissionState::PERMISSION_GRANTED},
220 .isGeneral = true,
221 .permissionName = "ohos.permission.INTERNET",
222 .resDeviceID = {"local"},
223 };
224
225 HapPolicyParams testPolicyPrams = {
226 .apl = APL_SYSTEM_BASIC,
227 .domain = "test.domain",
228 .permList = {testPermDef},
229 .permStateList = {testState},
230 };
231 } // namespace
232
233 class AccessToken {
234 public:
AccessToken()235 AccessToken() : currentID_(GetSelfTokenID())
236 {
237 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(testInfoParms, testPolicyPrams);
238 accessID_ = tokenIdEx.tokenIdExStruct.tokenID;
239 SetSelfTokenID(tokenIdEx.tokenIDEx);
240 }
~AccessToken()241 ~AccessToken()
242 {
243 AccessTokenKit::DeleteToken(accessID_);
244 SetSelfTokenID(currentID_);
245 }
246
247 private:
248 AccessTokenID currentID_;
249 AccessTokenID accessID_ = 0;
250 };
251
252 class TlsSocketBranchTest : public testing::Test {
253 public:
SetUpTestCase()254 static void SetUpTestCase() {}
255
TearDownTestCase()256 static void TearDownTestCase() {}
257
SetUp()258 virtual void SetUp() {}
259
TearDown()260 virtual void TearDown() {}
261 };
262
263 HWTEST_F(TlsSocketBranchTest, BranchTest1, TestSize.Level2)
264 {
265 TLSSecureOptions secureOption;
266 SecureData structureData(g_priKeyFile);
267 secureOption.SetKey(structureData);
268
269 SecureData keyPass(KEY_PASS);
270 secureOption.SetKeyPass(keyPass);
271 SecureData secureData = secureOption.GetKey();
272 EXPECT_EQ(structureData.Length(), strlen(g_priKeyFile));
273 std::vector<std::string> caChain;
274 caChain.push_back(g_caCrtFile);
275 secureOption.SetCaChain(caChain);
276 std::vector<std::string> getCaChain = secureOption.GetCaChain();
277 EXPECT_NE(getCaChain.data(), nullptr);
278
279 secureOption.SetCert(g_clientFile);
280 std::string getCert = secureOption.GetCert();
281 EXPECT_NE(getCert.data(), nullptr);
282
283 std::vector<std::string> protocolVec = {PROTOCOL12, PROTOCOL13};
284 secureOption.SetProtocolChain(protocolVec);
285 std::vector<std::string> getProtocol;
286 getProtocol = secureOption.GetProtocolChain();
287
288 TLSSecureOptions copyOption = TLSSecureOptions(secureOption);
289 TLSSecureOptions equalOption = secureOption;
290 }
291
292 HWTEST_F(TlsSocketBranchTest, BranchTest2, TestSize.Level2)
293 {
294 TLSSecureOptions secureOption;
295 secureOption.SetUseRemoteCipherPrefer(false);
296 bool isUseRemoteCipher = secureOption.UseRemoteCipherPrefer();
297 EXPECT_FALSE(isUseRemoteCipher);
298
299 secureOption.SetSignatureAlgorithms(SIGNATURE_ALGORITHM);
300 std::string getSignatureAlgorithm = secureOption.GetSignatureAlgorithms();
301 EXPECT_STREQ(getSignatureAlgorithm.data(), SIGNATURE_ALGORITHM);
302
303 secureOption.SetCipherSuite(CIPHER_SUITE);
304 std::string getCipherSuite = secureOption.GetCipherSuite();
305 EXPECT_STREQ(getCipherSuite.data(), CIPHER_SUITE);
306
307 TLSSecureOptions copyOption = TLSSecureOptions(secureOption);
308 TLSSecureOptions equalOption = secureOption;
309
310 TLSConnectOptions connectOptions;
311 connectOptions.SetTlsSecureOptions(secureOption);
312 }
313
314 HWTEST_F(TlsSocketBranchTest, BranchTest3, TestSize.Level2)
315 {
316 TLSSecureOptions secureOption;
317 TLSConnectOptions connectOptions;
318 connectOptions.SetTlsSecureOptions(secureOption);
319
320 NetAddress netAddress;
321 netAddress.SetAddress(IP_ADDRESS);
322 netAddress.SetPort(PORT);
323 connectOptions.SetNetAddress(netAddress);
324 NetAddress getNetAddress = connectOptions.GetNetAddress();
325 std::string address = getNetAddress.GetAddress();
326 EXPECT_STREQ(IP_ADDRESS, address.data());
327 int port = getNetAddress.GetPort();
328 EXPECT_EQ(port, PORT);
329 netAddress.SetFamilyBySaFamily(AF_INET6);
330 sa_family_t getFamily = netAddress.GetSaFamily();
331 EXPECT_EQ(getFamily, AF_INET6);
332
333 std::vector<std::string> alpnProtocols;
334 alpnProtocols.push_back(ALPN_PROTOCOL);
335 connectOptions.SetAlpnProtocols(alpnProtocols);
336 std::vector<std::string> getAlpnProtocols;
337 getAlpnProtocols = connectOptions.GetAlpnProtocols();
338 EXPECT_STREQ(getAlpnProtocols[0].data(), alpnProtocols[0].data());
339 }
340
341 HWTEST_F(TlsSocketBranchTest, BranchTest4, TestSize.Level2)
342 {
343 TLSSecureOptions secureOption;
344 SecureData structureData(g_priKeyFile);
345 secureOption.SetKey(structureData);
346 std::vector<std::string> caChain;
347 caChain.push_back(g_caCrtFile);
348 secureOption.SetCaChain(caChain);
349 secureOption.SetCert(g_clientFile);
350
351 TLSConnectOptions connectOptions;
352 connectOptions.SetTlsSecureOptions(secureOption);
353
354 NetAddress netAddress;
355 netAddress.SetAddress(IP_ADDRESS);
356 netAddress.SetPort(0);
357 netAddress.SetFamilyBySaFamily(AF_INET);
358
359 AccessToken token;
360 TLSSocket tlsSocket;
__anon196573b30202(int32_t errCode) 361 tlsSocket.Bind(netAddress, [](int32_t errCode) { EXPECT_EQ(errCode, TLSSOCKET_SUCCESS); });
362 SocketStateBase TlsSocketstate;
__anon196573b30302(int32_t errCode, const SocketStateBase &state) 363 tlsSocket.GetState([&TlsSocketstate](int32_t errCode, const SocketStateBase &state) {
364 EXPECT_EQ(errCode, TLSSOCKET_SUCCESS);
365 TlsSocketstate = state;
366 EXPECT_TRUE(TlsSocketstate.IsBound());
367 });
368 }
369
370 HWTEST_F(TlsSocketBranchTest, BranchTest5, TestSize.Level2)
371 {
372 TLSConnectOptions tlsConnectOptions = BaseOption();
373
374 AccessToken token;
375 TLSSocket tlsSocket;
__anon196573b30402(int32_t errCode) 376 tlsSocket.Bind(tlsConnectOptions.GetNetAddress(), [](int32_t errCode) { EXPECT_EQ(errCode, TLSSOCKET_SUCCESS); });
__anon196573b30502(int32_t errorNumber, const std::string &errorString) 377 tlsSocket.OnError([](int32_t errorNumber, const std::string &errorString) {
378 EXPECT_EQ(TLS_ERR_SSL_NULL, errorNumber);
379 });
__anon196573b30602(int32_t errCode) 380 tlsSocket.Connect(tlsConnectOptions, [](int32_t errCode) { EXPECT_EQ(TLS_ERR_SSL_NULL, errCode); });
381 std::string getData;
__anon196573b30702(const std::string &data, const SocketRemoteInfo &remoteInfo) 382 tlsSocket.OnMessage([&getData](const std::string &data, const SocketRemoteInfo &remoteInfo) {
383 EXPECT_STREQ(getData.data(), nullptr);
384 });
385 const std::string data = "how do you do?";
386 TCPSendOptions tcpSendOptions;
387 tcpSendOptions.SetData(data);
__anon196573b30802(int32_t errCode) 388 tlsSocket.Send(tcpSendOptions, [](int32_t errCode) { EXPECT_EQ(errCode, TLS_ERR_SSL_NULL); });
__anon196573b30902(int32_t errCode, const std::vector<std::string> &algorithms) 389 tlsSocket.GetSignatureAlgorithms([](int32_t errCode, const std::vector<std::string> &algorithms) {
390 EXPECT_EQ(errCode, TLS_ERR_SSL_NULL);
391 });
__anon196573b30a02(int32_t errCode, const X509CertRawData &cert) 392 tlsSocket.GetCertificate([](int32_t errCode, const X509CertRawData &cert) {
393 EXPECT_EQ(errCode, TLSSOCKET_SUCCESS);
394 });
__anon196573b30b02(int32_t errCode, const std::vector<std::string> &suite) 395 tlsSocket.GetCipherSuite([](int32_t errCode, const std::vector<std::string> &suite) {
396 EXPECT_EQ(errCode, TLS_ERR_SSL_NULL);
397 });
__anon196573b30c02(int32_t errCode, const std::string &protocol) 398 tlsSocket.GetProtocol([](int32_t errCode, const std::string &protocol) {
399 EXPECT_EQ(errCode, TLSSOCKET_SUCCESS);
400 });
__anon196573b30d02(int32_t errCode, const X509CertRawData &cert) 401 tlsSocket.GetRemoteCertificate([](int32_t errCode, const X509CertRawData &cert) {
402 EXPECT_EQ(errCode, TLS_ERR_SSL_NULL);
403 });
__anon196573b30e02(int32_t errCode) 404 (void)tlsSocket.Close([](int32_t errCode) { EXPECT_FALSE(errCode == TLSSOCKET_SUCCESS); });
405 }
406
407 HWTEST_F(TlsSocketBranchTest, BranchTest6, TestSize.Level2)
408 {
409 TLSConnectOptions connectOptions = BaseOption();
410
411 TLSSocket tlsSocket;
412 TLSSocket::TLSSocketInternal *tlsSocketInternal = new TLSSocket::TLSSocketInternal();
413 bool isConnectToHost = tlsSocketInternal->TlsConnectToHost(SOCKET_FD, connectOptions);
414 EXPECT_FALSE(isConnectToHost);
415 tlsSocketInternal->SetTlsConfiguration(connectOptions);
416
417 bool sendSslNull = tlsSocketInternal->Send(SEND_DATA);
418 EXPECT_FALSE(sendSslNull);
419 char buffer[MAX_BUFFER_SIZE];
420 bzero(buffer, MAX_BUFFER_SIZE);
421 int recvSslNull = tlsSocketInternal->Recv(buffer, MAX_BUFFER_SIZE);
422 EXPECT_EQ(recvSslNull, SSL_ERROR_RETURN);
423 bool closeSslNull = tlsSocketInternal->Close();
424 EXPECT_FALSE(closeSslNull);
425 tlsSocketInternal->ssl_ = SSL_new(SSL_CTX_new(TLS_client_method()));
426 bool send = tlsSocketInternal->Send(SEND_DATA);
427 EXPECT_FALSE(send);
428 bool sendEmpty = tlsSocketInternal->Send(SEND_DATA_EMPTY);
429 EXPECT_FALSE(sendEmpty);
430 int recv = tlsSocketInternal->Recv(buffer, MAX_BUFFER_SIZE);
431 EXPECT_EQ(recv, SSL_ERROR_RETURN);
432 bool close = tlsSocketInternal->Close();
433 EXPECT_FALSE(close);
434 delete tlsSocketInternal;
435 }
436
437 HWTEST_F(TlsSocketBranchTest, BranchTest7, TestSize.Level2)
438 {
439 TLSSocket tlsSocket;
440 TLSSocket::TLSSocketInternal *tlsSocketInternal = new TLSSocket::TLSSocketInternal();
441
442 std::vector<std::string> alpnProtocols;
443 alpnProtocols.push_back(ALPN_PROTOCOL);
444 bool alpnProSslNull = tlsSocketInternal->SetAlpnProtocols(alpnProtocols);
445 EXPECT_FALSE(alpnProSslNull);
446 std::vector<std::string> getCipherSuite = tlsSocketInternal->GetCipherSuite();
447 EXPECT_EQ(getCipherSuite.size(), 0);
448 bool setSharedSigals = tlsSocketInternal->SetSharedSigals();
449 EXPECT_FALSE(setSharedSigals);
450 tlsSocketInternal->ssl_ = SSL_new(SSL_CTX_new(TLS_client_method()));
451 getCipherSuite = tlsSocketInternal->GetCipherSuite();
452 EXPECT_NE(getCipherSuite.size(), 0);
453 setSharedSigals = tlsSocketInternal->SetSharedSigals();
454 EXPECT_FALSE(setSharedSigals);
455 TLSConnectOptions connectOptions = BaseOption();
456 bool alpnPro = tlsSocketInternal->SetAlpnProtocols(alpnProtocols);
457 EXPECT_TRUE(alpnPro);
458
459 SocketRemoteInfo remoteInfo;
460 tlsSocketInternal->hostName_ = IP_ADDRESS;
461 tlsSocketInternal->port_ = PORT;
462 tlsSocketInternal->family_ = AF_INET;
463 tlsSocketInternal->MakeRemoteInfo(remoteInfo);
464 getCipherSuite = tlsSocketInternal->GetCipherSuite();
465 EXPECT_NE(getCipherSuite.size(), 0);
466
467 std::string getRemoteCert = tlsSocketInternal->GetRemoteCertificate();
468 EXPECT_EQ(getRemoteCert, "");
469
470 std::vector<std::string> getSignatureAlgorithms = tlsSocketInternal->GetSignatureAlgorithms();
471 EXPECT_EQ(getSignatureAlgorithms.size(), 0);
472
473 std::string getProtocol = tlsSocketInternal->GetProtocol();
474 EXPECT_NE(getProtocol, "");
475
476 setSharedSigals = tlsSocketInternal->SetSharedSigals();
477 EXPECT_FALSE(setSharedSigals);
478
479 ssl_st *ssl = tlsSocketInternal->GetSSL();
480 EXPECT_NE(ssl, nullptr);
481 delete tlsSocketInternal;
482 }
483 } // namespace NetStack
484 } // namespace OHOS
485