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 "tlssocket_exec.h"
17
18 #include <string>
19 #include <vector>
20
21 #include <napi/native_api.h>
22 #include <securec.h>
23
24 #include "context_key.h"
25 #include "event_list.h"
26 #include "napi_utils.h"
27 #include "netstack_log.h"
28 #include "socket_error.h"
29 #include "tls_socket.h"
30
31 namespace OHOS {
32 namespace NetStack {
33 namespace TlsSocket {
34 namespace {
35 constexpr const char *CERTIFICATA_DATA = "data";
36 constexpr const char *CERTIFICATA_ENCODING_FORMAT = "encodingFormat";
37 } // namespace
ExecGetCertificate(GetCertificateContext * context)38 bool TLSSocketExec::ExecGetCertificate(GetCertificateContext *context)
39 {
40 auto manager = context->GetManager();
41 if (manager == nullptr) {
42 NETSTACK_LOGE("manager is nullptr");
43 return false;
44 }
45 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
46 if (tlsSocket == nullptr) {
47 NETSTACK_LOGE("ExecGetCertificate tlsSocket is null");
48 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
49 return false;
50 }
51 tlsSocket->GetCertificate([&context](int32_t errorNumber, const X509CertRawData &cert) {
52 context->localCert_ = cert;
53 context->errorNumber_ = errorNumber;
54 if (errorNumber != TLSSOCKET_SUCCESS) {
55 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
56 }
57 });
58 return context->errorNumber_ == TLSSOCKET_SUCCESS;
59 }
60
ExecConnect(TLSConnectContext * context)61 bool TLSSocketExec::ExecConnect(TLSConnectContext *context)
62 {
63 auto manager = context->GetManager();
64 if (manager == nullptr) {
65 NETSTACK_LOGE("manager is nullptr");
66 return false;
67 }
68 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
69 if (tlsSocket == nullptr) {
70 NETSTACK_LOGE("ExecConnect tlsSocket is null");
71 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
72 return false;
73 }
74 tlsSocket->Connect(context->connectOptions_, [&context](int32_t errorNumber) {
75 context->errorNumber_ = errorNumber;
76 if (errorNumber != TLSSOCKET_SUCCESS) {
77 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
78 }
79 });
80 return context->errorNumber_ == TLSSOCKET_SUCCESS;
81 }
82
ExecGetCipherSuites(GetCipherSuitesContext * context)83 bool TLSSocketExec::ExecGetCipherSuites(GetCipherSuitesContext *context)
84 {
85 auto manager = context->GetManager();
86 if (manager == nullptr) {
87 NETSTACK_LOGE("manager is nullptr");
88 return false;
89 }
90 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
91 if (tlsSocket == nullptr) {
92 NETSTACK_LOGE("ExecGetCipherSuites tlsSocket is null");
93 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
94 return false;
95 }
96 tlsSocket->GetCipherSuite([&context](int32_t errorNumber, const std::vector<std::string> &suite) {
97 context->cipherSuites_ = suite;
98 context->errorNumber_ = errorNumber;
99 if (errorNumber != TLSSOCKET_SUCCESS) {
100 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
101 }
102 });
103 return context->errorNumber_ == TLSSOCKET_SUCCESS;
104 }
105
ExecGetRemoteCertificate(GetRemoteCertificateContext * context)106 bool TLSSocketExec::ExecGetRemoteCertificate(GetRemoteCertificateContext *context)
107 {
108 auto manager = context->GetManager();
109 if (manager == nullptr) {
110 NETSTACK_LOGE("manager is nullptr");
111 return false;
112 }
113 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
114 if (tlsSocket == nullptr) {
115 NETSTACK_LOGE("ExecGetRemoteCertificate tlsSocket is null");
116 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
117 return false;
118 }
119 tlsSocket->GetRemoteCertificate([&context](int32_t errorNumber, const X509CertRawData &cert) {
120 context->remoteCert_ = cert;
121 context->errorNumber_ = errorNumber;
122 if (errorNumber != TLSSOCKET_SUCCESS) {
123 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
124 }
125 });
126 return context->errorNumber_ == TLSSOCKET_SUCCESS;
127 }
128
ExecGetProtocol(GetProtocolContext * context)129 bool TLSSocketExec::ExecGetProtocol(GetProtocolContext *context)
130 {
131 auto manager = context->GetManager();
132 if (manager == nullptr) {
133 NETSTACK_LOGE("manager is nullptr");
134 return false;
135 }
136 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
137 if (tlsSocket == nullptr) {
138 NETSTACK_LOGE("ExecGetProtocol tlsSocket is null");
139 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
140 return false;
141 }
142 tlsSocket->GetProtocol([&context](int32_t errorNumber, const std::string &protocol) {
143 context->protocol_ = protocol;
144 context->errorNumber_ = errorNumber;
145 if (errorNumber != TLSSOCKET_SUCCESS) {
146 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
147 }
148 });
149 return context->errorNumber_ == TLSSOCKET_SUCCESS;
150 }
151
ExecGetSignatureAlgorithms(GetSignatureAlgorithmsContext * context)152 bool TLSSocketExec::ExecGetSignatureAlgorithms(GetSignatureAlgorithmsContext *context)
153 {
154 auto manager = context->GetManager();
155 if (manager == nullptr) {
156 NETSTACK_LOGE("manager is nullptr");
157 return false;
158 }
159 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
160 if (tlsSocket == nullptr) {
161 NETSTACK_LOGE("ExecGetSignatureAlgorithms tlsSocket is null");
162 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
163 return false;
164 }
165 tlsSocket->GetSignatureAlgorithms([&context](int32_t errorNumber, const std::vector<std::string> &algorithms) {
166 context->signatureAlgorithms_ = algorithms;
167 context->errorNumber_ = errorNumber;
168 if (errorNumber != TLSSOCKET_SUCCESS) {
169 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
170 }
171 });
172 return context->errorNumber_ == TLSSOCKET_SUCCESS;
173 }
174
ExecSend(TLSSendContext * context)175 bool TLSSocketExec::ExecSend(TLSSendContext *context)
176 {
177 auto manager = context->GetManager();
178 if (manager == nullptr) {
179 NETSTACK_LOGE("manager is nullptr");
180 return false;
181 }
182 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
183 if (tlsSocket == nullptr) {
184 NETSTACK_LOGE("ExecSend tlsSocket is null");
185 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
186 return false;
187 }
188 Socket::TCPSendOptions tcpSendOptions;
189 tcpSendOptions.SetData(context->data_);
190 tlsSocket->Send(tcpSendOptions, [&context](int32_t errorNumber) {
191 context->errorNumber_ = errorNumber;
192 if (errorNumber != TLSSOCKET_SUCCESS) {
193 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
194 }
195 });
196 return context->errorNumber_ == TLSSOCKET_SUCCESS;
197 }
198
ExecClose(TLSNapiContext * context)199 bool TLSSocketExec::ExecClose(TLSNapiContext *context)
200 {
201 auto manager = context->GetManager();
202 if (manager == nullptr) {
203 NETSTACK_LOGE("manager is nullptr");
204 return false;
205 }
206 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
207 if (tlsSocket == nullptr) {
208 NETSTACK_LOGE("ExecClose tlsSocket is null");
209 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
210 return false;
211 }
212 tlsSocket->Close([&context](int32_t errorNumber) {
213 context->errorNumber_ = errorNumber;
214 if (errorNumber != TLSSOCKET_SUCCESS) {
215 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
216 }
217 });
218 delete tlsSocket;
219 manager->SetData(nullptr);
220 return context->errorNumber_ == TLSSOCKET_SUCCESS;
221 }
222
ExecBind(TLSBindContext * context)223 bool TLSSocketExec::ExecBind(TLSBindContext *context)
224 {
225 auto manager = context->GetManager();
226 if (manager == nullptr) {
227 NETSTACK_LOGE("manager is nullptr");
228 return false;
229 }
230 auto tlsSocket = new TLSSocket();
231 tlsSocket->Bind(context->address_, [&context](int32_t errorNumber) {
232 context->errorNumber_ = errorNumber;
233 if (errorNumber != TLSSOCKET_SUCCESS) {
234 std::string errorString = MakeErrorMessage(errorNumber);
235 context->SetError(errorNumber, errorString);
236 }
237 });
238 manager->SetData(tlsSocket);
239 return context->errorNumber_ == TLSSOCKET_SUCCESS;
240 }
241
ExecGetRemoteAddress(TLSGetRemoteAddressContext * context)242 bool TLSSocketExec::ExecGetRemoteAddress(TLSGetRemoteAddressContext *context)
243 {
244 auto manager = context->GetManager();
245 if (manager == nullptr) {
246 NETSTACK_LOGE("manager is nullptr");
247 return false;
248 }
249 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
250 if (tlsSocket == nullptr) {
251 NETSTACK_LOGE("ExecGetRemoteAddress tlsSocket is null");
252 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
253 return false;
254 }
255 tlsSocket->GetRemoteAddress([&context](int32_t errorNumber, const Socket::NetAddress address) {
256 context->address_ = address;
257 context->errorNumber_ = errorNumber;
258 if (errorNumber != TLSSOCKET_SUCCESS) {
259 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
260 }
261 });
262 return context->errorNumber_ == TLSSOCKET_SUCCESS;
263 }
264
ExecGetState(TLSGetStateContext * context)265 bool TLSSocketExec::ExecGetState(TLSGetStateContext *context)
266 {
267 auto manager = context->GetManager();
268 if (manager == nullptr) {
269 NETSTACK_LOGE("manager is nullptr");
270 context->state_.SetIsClose(true);
271 return true;
272 }
273 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
274 if (tlsSocket == nullptr) {
275 NETSTACK_LOGE("ExecGetState tlsSocket is null");
276 context->state_.SetIsClose(true);
277 return true;
278 }
279 tlsSocket->GetState([&context](int32_t errorNumber, const Socket::SocketStateBase state) {
280 context->state_ = state;
281 context->errorNumber_ = errorNumber;
282 if (errorNumber != TLSSOCKET_SUCCESS) {
283 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
284 }
285 });
286 return context->errorNumber_ == TLSSOCKET_SUCCESS;
287 }
288
ExecSetExtraOptions(TLSSetExtraOptionsContext * context)289 bool TLSSocketExec::ExecSetExtraOptions(TLSSetExtraOptionsContext *context)
290 {
291 auto manager = context->GetManager();
292 if (manager == nullptr) {
293 NETSTACK_LOGE("manager is nullptr");
294 return false;
295 }
296 auto tlsSocket = reinterpret_cast<TLSSocket *>(manager->GetData());
297 if (tlsSocket == nullptr) {
298 NETSTACK_LOGE("ExecSetExtraOptions tlsSocket is null");
299 context->SetError(TLS_ERR_NO_BIND, MakeErrorMessage(TLS_ERR_NO_BIND));
300 return false;
301 }
302 tlsSocket->SetExtraOptions(context->options_, [&context](int32_t errorNumber) {
303 context->errorNumber_ = errorNumber;
304 if (errorNumber != TLSSOCKET_SUCCESS) {
305 context->SetError(errorNumber, MakeErrorMessage(errorNumber));
306 }
307 });
308 return context->errorNumber_ == TLSSOCKET_SUCCESS;
309 }
310
GetCertificateCallback(GetCertificateContext * context)311 napi_value TLSSocketExec::GetCertificateCallback(GetCertificateContext *context)
312 {
313 void *data = nullptr;
314 napi_value arrayBuffer = NapiUtils::CreateArrayBuffer(context->GetEnv(), context->localCert_.data.Length(), &data);
315 if (data != nullptr && arrayBuffer != nullptr) {
316 if (memcpy_s(data, context->localCert_.data.Length(),
317 reinterpret_cast<const uint8_t *>(context->localCert_.data.Data()),
318 context->localCert_.data.Length()) != EOK) {
319 NETSTACK_LOGE("memcpy_s failed!");
320 return NapiUtils::GetUndefined(context->GetEnv());
321 }
322 }
323 napi_value outData = nullptr;
324 napi_create_typedarray(context->GetEnv(), napi_uint8_array, context->localCert_.data.Length(), arrayBuffer, 0,
325 &outData);
326 napi_value obj = NapiUtils::CreateObject(context->GetEnv());
327 if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
328 return NapiUtils::GetUndefined(context->GetEnv());
329 }
330 NapiUtils::SetNamedProperty(context->GetEnv(), obj, CERTIFICATA_DATA, outData);
331 NapiUtils::SetInt32Property(context->GetEnv(), obj, CERTIFICATA_ENCODING_FORMAT,
332 context->localCert_.encodingFormat);
333 return obj;
334 }
335
ConnectCallback(TLSConnectContext * context)336 napi_value TLSSocketExec::ConnectCallback(TLSConnectContext *context)
337 {
338 return NapiUtils::GetUndefined(context->GetEnv());
339 }
340
GetCipherSuitesCallback(GetCipherSuitesContext * context)341 napi_value TLSSocketExec::GetCipherSuitesCallback(GetCipherSuitesContext *context)
342 {
343 napi_value cipherSuites = NapiUtils::CreateArray(context->GetEnv(), 0);
344 int index = 0;
345 for (const auto &cipher : context->cipherSuites_) {
346 napi_value cipherSuite = NapiUtils::CreateStringUtf8(context->GetEnv(), cipher);
347 NapiUtils::SetArrayElement(context->GetEnv(), cipherSuites, index++, cipherSuite);
348 }
349 return cipherSuites;
350 }
351
GetRemoteCertificateCallback(GetRemoteCertificateContext * context)352 napi_value TLSSocketExec::GetRemoteCertificateCallback(GetRemoteCertificateContext *context)
353 {
354 void *data = nullptr;
355 napi_value arrayBuffer = NapiUtils::CreateArrayBuffer(context->GetEnv(), context->remoteCert_.data.Length(), &data);
356 if (data != nullptr && arrayBuffer != nullptr) {
357 if (memcpy_s(data, context->remoteCert_.data.Length(),
358 reinterpret_cast<const uint8_t *>(context->remoteCert_.data.Data()),
359 context->remoteCert_.data.Length()) != EOK) {
360 NETSTACK_LOGE("memcpy_s failed!");
361 return NapiUtils::GetUndefined(context->GetEnv());
362 }
363 }
364 napi_value outData = nullptr;
365 napi_create_typedarray(context->GetEnv(), napi_uint8_array, context->remoteCert_.data.Length(), arrayBuffer, 0,
366 &outData);
367 napi_value obj = NapiUtils::CreateObject(context->GetEnv());
368 if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
369 return NapiUtils::GetUndefined(context->GetEnv());
370 }
371 NapiUtils::SetNamedProperty(context->GetEnv(), obj, CERTIFICATA_DATA, outData);
372 NapiUtils::SetInt32Property(context->GetEnv(), obj, CERTIFICATA_ENCODING_FORMAT,
373 context->remoteCert_.encodingFormat);
374 return obj;
375 }
376
GetProtocolCallback(GetProtocolContext * context)377 napi_value TLSSocketExec::GetProtocolCallback(GetProtocolContext *context)
378 {
379 return NapiUtils::CreateStringUtf8(context->GetEnv(), context->protocol_);
380 }
381
GetSignatureAlgorithmsCallback(GetSignatureAlgorithmsContext * context)382 napi_value TLSSocketExec::GetSignatureAlgorithmsCallback(GetSignatureAlgorithmsContext *context)
383 {
384 napi_value signatureAlgorithms = NapiUtils::CreateArray(context->GetEnv(), 0);
385 int index = 0;
386 for (const auto &algorithm : context->signatureAlgorithms_) {
387 napi_value signatureAlgorithm = NapiUtils::CreateStringUtf8(context->GetEnv(), algorithm);
388 NapiUtils::SetArrayElement(context->GetEnv(), signatureAlgorithms, index++, signatureAlgorithm);
389 }
390 return signatureAlgorithms;
391 }
392
SendCallback(TLSSendContext * context)393 napi_value TLSSocketExec::SendCallback(TLSSendContext *context)
394 {
395 return NapiUtils::GetUndefined(context->GetEnv());
396 }
397
CloseCallback(TLSNapiContext * context)398 napi_value TLSSocketExec::CloseCallback(TLSNapiContext *context)
399 {
400 return NapiUtils::GetUndefined(context->GetEnv());
401 }
402
BindCallback(TLSBindContext * context)403 napi_value TLSSocketExec::BindCallback(TLSBindContext *context)
404 {
405 context->Emit(EVENT_LISTENING, std::make_pair(NapiUtils::GetUndefined(context->GetEnv()),
406 NapiUtils::GetUndefined(context->GetEnv())));
407 return NapiUtils::GetUndefined(context->GetEnv());
408 }
409
GetStateCallback(TLSGetStateContext * context)410 napi_value TLSSocketExec::GetStateCallback(TLSGetStateContext *context)
411 {
412 napi_value obj = NapiUtils::CreateObject(context->GetEnv());
413 if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
414 return NapiUtils::GetUndefined(context->GetEnv());
415 }
416 NapiUtils::SetBooleanProperty(context->GetEnv(), obj, KEY_IS_BOUND, context->state_.IsBound());
417 NapiUtils::SetBooleanProperty(context->GetEnv(), obj, KEY_IS_CLOSE, context->state_.IsClose());
418 NapiUtils::SetBooleanProperty(context->GetEnv(), obj, KEY_IS_CONNECTED, context->state_.IsConnected());
419 return obj;
420 }
421
GetRemoteAddressCallback(TLSGetRemoteAddressContext * context)422 napi_value TLSSocketExec::GetRemoteAddressCallback(TLSGetRemoteAddressContext *context)
423 {
424 napi_value obj = NapiUtils::CreateObject(context->GetEnv());
425 if (NapiUtils::GetValueType(context->GetEnv(), obj) != napi_object) {
426 return NapiUtils::GetUndefined(context->GetEnv());
427 }
428 NapiUtils::SetStringPropertyUtf8(context->GetEnv(), obj, KEY_ADDRESS, context->address_.GetAddress());
429 NapiUtils::SetUint32Property(context->GetEnv(), obj, KEY_FAMILY, context->address_.GetJsValueFamily());
430 NapiUtils::SetUint32Property(context->GetEnv(), obj, KEY_PORT, context->address_.GetPort());
431 return obj;
432 }
433
SetExtraOptionsCallback(TLSSetExtraOptionsContext * context)434 napi_value TLSSocketExec::SetExtraOptionsCallback(TLSSetExtraOptionsContext *context)
435 {
436 return NapiUtils::GetUndefined(context->GetEnv());
437 }
438
439 } // namespace TlsSocket
440 } // namespace NetStack
441 } // namespace OHOS
442