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 "dslm_test.h"
17
18 #include <chrono>
19 #include <condition_variable>
20 #include <gtest/gtest.h>
21 #include <iostream>
22 #include <mutex>
23 #include <thread>
24
25 #include "file_ex.h"
26 #include "nativetoken_kit.h"
27 #include "securec.h"
28 #include "token_setproc.h"
29
30 #include "device_security_defines.h"
31 #include "device_security_info.h"
32 #include "device_security_level_defines.h"
33 #include "dslm_core_defines.h"
34 #include "dslm_core_process.h"
35 #include "dslm_credential.h"
36 #include "dslm_crypto.h"
37 #include "dslm_device_list.h"
38 #include "dslm_fsm_process.h"
39 #include "dslm_hidumper.h"
40 #include "dslm_hievent.h"
41 #include "dslm_inner_process.h"
42 #include "dslm_memory_mock.h"
43 #include "dslm_messenger_wrapper.h"
44 #include "dslm_msg_interface_mock.h"
45 #include "dslm_msg_serialize.h"
46 #include "dslm_msg_utils.h"
47 #include "dslm_ohos_request.h"
48 #include "dslm_ohos_verify.h"
49 #include "dslm_request_callback_mock.h"
50 #include "external_interface_adapter.h"
51 #include "messenger_device_socket_manager.h"
52 #include "messenger_device_status_manager.h"
53 #include "utils_datetime.h"
54 #include "utils_mem.h"
55 #include "utils_tlv.h"
56 #include "utils_work_queue.h"
57
58 using namespace std;
59 using namespace std::chrono;
60 using namespace testing;
61 using namespace testing::ext;
62
63 typedef struct QueueMsgData {
64 DeviceIdentify srcIdentity;
65 uint32_t msgLen;
66 uint8_t msgData[1];
67 } QueueMsgData;
68
69 #define MESSENGER_PROCESS_QUEUE_SIZE 256
70 #define MESSENGER_PROCESS_QUEUE_NAME "messenger_queue"
71 #define MAX_CRED_LEN 81920
72 #define PTR_LEN 4
73 #define BUFF_LEN 8
74 #define MSG_BUFF_MAX_LENGTH (81920 * 4)
75
76 // for testing
77 extern "C" {
78 extern bool CheckMessage(const uint8_t *msg, uint32_t length);
79 extern void DoTimerProcess(TimerProc callback, const void *context);
80 QueueMsgData *CreateQueueMsgData(const DeviceIdentify *devId, const uint8_t *msg, uint32_t msgLen,
81 uint32_t *queueDataLen);
82 int32_t OnPeerMsgReceived(const DeviceIdentify *devId, const uint8_t *msg, uint32_t len);
83 int32_t OnPeerStatusReceiver(const DeviceIdentify *deviceId, uint32_t status, int32_t level);
84 int32_t OnSendResultNotifier(const DeviceIdentify *devId, uint64_t transNo, uint32_t result);
85 }
86
87 namespace OHOS {
88 namespace Security {
89 namespace DslmUnitTest {
90
91 static uint8_t CRED[] = {0x01, 0x01, 0xa5, 0x0b, 0x30, 0x82, 0x0b, 0xa1, 0x30, 0x82, 0x0a, 0x8b, 0xa0, 0x03, 0x02, 0x01,
92 0x02, 0x02, 0x01, 0x01, 0x30, 0x0b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x30, 0x7f,
93 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43, 0x4e, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03,
94 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11,
95 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13,
96 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64,
97 0x31, 0x16, 0x30, 0x14, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0d, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72,
98 0x6c, 0x64, 0x31, 0x31, 0x31, 0x31, 0x19, 0x30, 0x17, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09,
99 0x01, 0x16, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x34,
100 0x30, 0x34, 0x32, 0x38, 0x30, 0x39, 0x35, 0x36, 0x31, 0x32, 0x5a, 0x17, 0x0d, 0x33, 0x34, 0x30, 0x34, 0x32, 0x38,
101 0x30, 0x39, 0x35, 0x36, 0x31, 0x32, 0x5a, 0x30, 0x1a, 0x31, 0x18, 0x30, 0x16, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
102 0x0f, 0x41, 0x20, 0x4b, 0x65, 0x79, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79, 0x30, 0x82, 0x01,
103 0x20, 0x30, 0x0b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x03, 0x82, 0x01, 0x0f, 0x00,
104 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xc2, 0x61, 0x0a, 0xad, 0xa5, 0x33, 0xf8, 0x8f, 0x1e, 0xf3,
105 0x2d, 0xf8, 0x0e, 0x4a, 0x93, 0xa2, 0xcc, 0x71, 0x85, 0xdd, 0x62, 0x0e, 0xec, 0x5e, 0xd5, 0xa7, 0xfa, 0x0b, 0x2b,
106 0xdc, 0x3e, 0x9b, 0xb4, 0x06, 0xec, 0xe6, 0xea, 0x1c, 0x8f, 0x9a, 0x06, 0xfd, 0x90, 0x8f, 0xbb, 0xea, 0xe1, 0xe3,
107 0x77, 0xa1, 0xd5, 0x58, 0x73, 0xae, 0xba, 0xb1, 0x68, 0xce, 0x3a, 0xa7, 0x50, 0xf0, 0x95, 0x0d, 0x24, 0x80, 0x48,
108 0x06, 0xb1, 0x1b, 0x47, 0x7b, 0x09, 0x3e, 0x6a, 0xe8, 0x27, 0x33, 0x09, 0x82, 0xbb, 0x05, 0x8b, 0x88, 0x56, 0x6f,
109 0xb8, 0xbe, 0x61, 0x20, 0xe4, 0x9d, 0x13, 0xbc, 0x5b, 0x96, 0x70, 0xd1, 0x56, 0xfd, 0xf7, 0x2e, 0x34, 0x41, 0x6a,
110 0x02, 0xd3, 0xd9, 0xca, 0xb4, 0x2f, 0x1f, 0xf9, 0x59, 0x49, 0xf4, 0xb4, 0x04, 0x74, 0x3f, 0xe8, 0x5c, 0xc9, 0x9d,
111 0x9f, 0x2d, 0x54, 0x8c, 0xe2, 0x31, 0x39, 0x5d, 0xc3, 0x39, 0xf5, 0xa1, 0xee, 0x3a, 0x2a, 0x28, 0xe1, 0xa8, 0x89,
112 0x7d, 0xd6, 0x62, 0x1f, 0xc6, 0x4d, 0xd9, 0x0a, 0xc6, 0xb7, 0xae, 0x7f, 0x8d, 0xa8, 0x4a, 0x24, 0xf1, 0x4d, 0x56,
113 0xba, 0xc1, 0x1d, 0xd9, 0xa8, 0x5f, 0xbb, 0xc3, 0x60, 0xd1, 0x8b, 0x01, 0xa2, 0xb4, 0x39, 0x1f, 0xa7, 0xe8, 0x67,
114 0xcd, 0xd0, 0x00, 0x82, 0x37, 0xa3, 0x8b, 0xe6, 0xbb, 0x84, 0xd8, 0x71, 0xff, 0x0b, 0x3f, 0x93, 0x5a, 0x95, 0x27,
115 0x56, 0x54, 0x24, 0xa2, 0x33, 0xfe, 0x24, 0x10, 0x16, 0x29, 0x3a, 0x97, 0xc2, 0x5c, 0x25, 0x0b, 0x18, 0xbd, 0x82,
116 0xc2, 0x02, 0x3c, 0xf7, 0x45, 0x8c, 0x48, 0xef, 0xd4, 0x3b, 0xf8, 0xf6, 0x69, 0x3d, 0x3b, 0x96, 0xbd, 0x50, 0xff,
117 0x44, 0x52, 0xba, 0x61, 0xe7, 0xaa, 0x2e, 0x5f, 0xa8, 0x4a, 0xef, 0xdc, 0xca, 0x70, 0x8e, 0xf4, 0xed, 0x9d, 0x02,
118 0x03, 0x01, 0x00, 0x01, 0xa3, 0x82, 0x08, 0x91, 0x30, 0x82, 0x08, 0x8d, 0x30, 0x0b, 0x06, 0x03, 0x55, 0x1d, 0x0f,
119 0x04, 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x08, 0x06, 0x03, 0x55, 0x1d, 0x1f, 0x04, 0x01, 0x00, 0x30, 0x82, 0x08,
120 0x72, 0x06, 0x0c, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x8f, 0x5b, 0x02, 0x82, 0x78, 0x01, 0x03, 0x04, 0x82, 0x08, 0x60,
121 0x30, 0x82, 0x08, 0x5c, 0x02, 0x01, 0x00, 0x30, 0x72, 0x02, 0x01, 0x00, 0x06, 0x0d, 0x2b, 0x06, 0x01, 0x04, 0x01,
122 0x8f, 0x5b, 0x02, 0x82, 0x78, 0x02, 0x01, 0x04, 0x04, 0x5e, 0x7b, 0x22, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e,
123 0x67, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x35, 0x36, 0x33, 0x34, 0x31, 0x32, 0x37, 0x38, 0x35, 0x36, 0x33, 0x34,
124 0x31, 0x32, 0x22, 0x2c, 0x22, 0x70, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x22, 0x5b,
125 0x7b, 0x5c, 0x22, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x5c, 0x22, 0x20, 0x3a, 0x20, 0x5c, 0x22, 0x30, 0x5c,
126 0x22, 0x2c, 0x5c, 0x22, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x5c, 0x22, 0x20, 0x3a, 0x20, 0x5c,
127 0x22, 0x30, 0x5c, 0x22, 0x7d, 0x5d, 0x22, 0x7d, 0x00, 0x30, 0x1d, 0x02, 0x01, 0x02, 0x06, 0x0d, 0x2b, 0x06, 0x01,
128 0x04, 0x01, 0x8f, 0x5b, 0x02, 0x82, 0x78, 0x02, 0x01, 0x02, 0x04, 0x09, 0x64, 0x73, 0x6c, 0x6d, 0x5f, 0x6b, 0x65,
129 0x79, 0x00, 0x30, 0x59, 0x02, 0x01, 0x02, 0x06, 0x0d, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x8f, 0x5b, 0x02, 0x82, 0x78,
130 0x02, 0x01, 0x03, 0x30, 0x45, 0x06, 0x0e, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x8f, 0x5b, 0x02, 0x82, 0x78, 0x02, 0x01,
131 0x03, 0x01, 0x04, 0x33, 0x7b, 0x22, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x3a,
132 0x22, 0x64, 0x73, 0x6c, 0x6d, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x41, 0x50, 0x4c,
133 0x22, 0x3a, 0x22, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x62, 0x61, 0x73, 0x69, 0x63, 0x22, 0x7d, 0x30, 0x16,
134 0x02, 0x01, 0x03, 0x06, 0x0e, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x8f, 0x5b, 0x02, 0x82, 0x78, 0x02, 0x02, 0x04, 0x0a,
135 0x0c, 0x01, 0x00, 0x30, 0x82, 0x07, 0x03, 0x02, 0x01, 0x03, 0x06, 0x0e, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x8f, 0x5b,
136 0x02, 0x82, 0x78, 0x02, 0x02, 0x02, 0x05, 0x04, 0x82, 0x06, 0xec, 0x65, 0x79, 0x4a, 0x30, 0x65, 0x58, 0x41, 0x69,
137 0x4f, 0x69, 0x41, 0x69, 0x52, 0x46, 0x4e, 0x4d, 0x49, 0x6e, 0x30, 0x3d, 0x2e, 0x65, 0x79, 0x4a, 0x30, 0x65, 0x58,
138 0x42, 0x6c, 0x49, 0x6a, 0x6f, 0x67, 0x49, 0x6d, 0x52, 0x6c, 0x59, 0x6e, 0x56, 0x6e, 0x49, 0x69, 0x77, 0x67, 0x49,
139 0x6d, 0x31, 0x68, 0x62, 0x6e, 0x56, 0x6d, 0x59, 0x57, 0x4e, 0x30, 0x64, 0x58, 0x4a, 0x6c, 0x49, 0x6a, 0x6f, 0x67,
140 0x49, 0x6b, 0x39, 0x49, 0x54, 0x31, 0x4d, 0x69, 0x4c, 0x43, 0x41, 0x69, 0x59, 0x6e, 0x4a, 0x68, 0x62, 0x6d, 0x51,
141 0x69, 0x4f, 0x69, 0x41, 0x69, 0x54, 0x30, 0x68, 0x50, 0x55, 0x79, 0x49, 0x73, 0x49, 0x43, 0x4a, 0x74, 0x62, 0x32,
142 0x52, 0x6c, 0x62, 0x43, 0x49, 0x36, 0x49, 0x43, 0x4a, 0x50, 0x53, 0x45, 0x39, 0x54, 0x49, 0x69, 0x77, 0x67, 0x49,
143 0x6e, 0x4e, 0x76, 0x5a, 0x6e, 0x52, 0x33, 0x59, 0x58, 0x4a, 0x6c, 0x56, 0x6d, 0x56, 0x79, 0x63, 0x32, 0x6c, 0x76,
144 0x62, 0x69, 0x49, 0x36, 0x49, 0x43, 0x49, 0x7a, 0x4c, 0x6a, 0x41, 0x75, 0x4d, 0x43, 0x49, 0x73, 0x49, 0x43, 0x4a,
145 0x7a, 0x5a, 0x57, 0x4e, 0x31, 0x63, 0x6d, 0x6c, 0x30, 0x65, 0x55, 0x78, 0x6c, 0x64, 0x6d, 0x56, 0x73, 0x49, 0x6a,
146 0x6f, 0x67, 0x49, 0x6c, 0x4e, 0x4d, 0x4d, 0x53, 0x49, 0x73, 0x49, 0x43, 0x4a, 0x7a, 0x61, 0x57, 0x64, 0x75, 0x56,
147 0x47, 0x6c, 0x74, 0x5a, 0x53, 0x49, 0x36, 0x49, 0x43, 0x49, 0x79, 0x4d, 0x44, 0x49, 0x79, 0x4d, 0x44, 0x67, 0x79,
148 0x4d, 0x6a, 0x45, 0x78, 0x4e, 0x54, 0x63, 0x79, 0x4d, 0x43, 0x49, 0x73, 0x49, 0x43, 0x4a, 0x32, 0x5a, 0x58, 0x4a,
149 0x7a, 0x61, 0x57, 0x39, 0x75, 0x49, 0x6a, 0x6f, 0x67, 0x49, 0x6a, 0x45, 0x75, 0x4d, 0x43, 0x34, 0x78, 0x49, 0x6e,
150 0x30, 0x3d, 0x2e, 0x4d, 0x47, 0x51, 0x43, 0x4d, 0x46, 0x78, 0x6d, 0x6f, 0x75, 0x4f, 0x5a, 0x42, 0x6d, 0x43, 0x62,
151 0x73, 0x34, 0x64, 0x30, 0x52, 0x76, 0x54, 0x64, 0x57, 0x4f, 0x59, 0x77, 0x53, 0x73, 0x58, 0x79, 0x44, 0x77, 0x77,
152 0x62, 0x61, 0x4e, 0x58, 0x4e, 0x4d, 0x61, 0x64, 0x72, 0x6f, 0x71, 0x6d, 0x41, 0x43, 0x47, 0x64, 0x58, 0x4d, 0x59,
153 0x79, 0x43, 0x30, 0x4a, 0x30, 0x2f, 0x75, 0x7a, 0x61, 0x39, 0x42, 0x42, 0x6b, 0x52, 0x2f, 0x67, 0x49, 0x77, 0x42,
154 0x35, 0x5a, 0x75, 0x6d, 0x6b, 0x6d, 0x34, 0x45, 0x68, 0x66, 0x76, 0x48, 0x6f, 0x63, 0x45, 0x57, 0x6a, 0x34, 0x67,
155 0x57, 0x2b, 0x61, 0x44, 0x63, 0x61, 0x6e, 0x42, 0x4d, 0x49, 0x41, 0x37, 0x33, 0x6f, 0x6e, 0x4c, 0x5a, 0x42, 0x59,
156 0x71, 0x56, 0x4f, 0x73, 0x65, 0x58, 0x61, 0x4d, 0x6a, 0x7a, 0x39, 0x4f, 0x2f, 0x2f, 0x48, 0x4f, 0x58, 0x4e, 0x37,
157 0x59, 0x36, 0x72, 0x30, 0x54, 0x30, 0x2e, 0x57, 0x33, 0x73, 0x69, 0x64, 0x58, 0x4e, 0x6c, 0x63, 0x6c, 0x42, 0x31,
158 0x59, 0x6d, 0x78, 0x70, 0x59, 0x30, 0x74, 0x6c, 0x65, 0x53, 0x49, 0x36, 0x49, 0x43, 0x4a, 0x4e, 0x53, 0x47, 0x39,
159 0x33, 0x52, 0x6b, 0x46, 0x5a, 0x53, 0x45, 0x74, 0x76, 0x57, 0x6b, 0x6c, 0x36, 0x61, 0x6a, 0x42, 0x44, 0x51, 0x56,
160 0x46, 0x5a, 0x53, 0x6b, 0x74, 0x35, 0x55, 0x55, 0x52, 0x42, 0x64, 0x30, 0x6c, 0x4a, 0x51, 0x56, 0x46, 0x46, 0x54,
161 0x45, 0x45, 0x79, 0x53, 0x55, 0x46, 0x43, 0x52, 0x33, 0x56, 0x4e, 0x61, 0x46, 0x56, 0x47, 0x52, 0x6d, 0x35, 0x73,
162 0x55, 0x47, 0x74, 0x56, 0x64, 0x30, 0x31, 0x33, 0x64, 0x44, 0x68, 0x70, 0x51, 0x33, 0x4a, 0x50, 0x52, 0x55, 0x64,
163 0x45, 0x4c, 0x30, 0x78, 0x52, 0x61, 0x55, 0x31, 0x46, 0x4d, 0x6d, 0x5a, 0x36, 0x54, 0x45, 0x30, 0x72, 0x63, 0x32,
164 0x52, 0x61, 0x52, 0x58, 0x68, 0x4a, 0x4f, 0x57, 0x51, 0x78, 0x4e, 0x30, 0x52, 0x73, 0x57, 0x47, 0x68, 0x4a, 0x55,
165 0x32, 0x59, 0x72, 0x57, 0x6e, 0x52, 0x7a, 0x65, 0x46, 0x52, 0x4f, 0x56, 0x44, 0x52, 0x30, 0x4e, 0x44, 0x4e, 0x44,
166 0x53, 0x57, 0x31, 0x59, 0x62, 0x54, 0x6c, 0x74, 0x65, 0x6e, 0x4a, 0x4d, 0x4f, 0x54, 0x56, 0x74, 0x4f, 0x43, 0x74,
167 0x4b, 0x57, 0x45, 0x4a, 0x5a, 0x53, 0x47, 0x67, 0x7a, 0x61, 0x30, 0x6c, 0x54, 0x5a, 0x45, 0x6c, 0x6e, 0x5a, 0x48,
168 0x41, 0x78, 0x64, 0x56, 0x52, 0x6d, 0x62, 0x45, 0x5a, 0x49, 0x56, 0x6a, 0x42, 0x59, 0x5a, 0x6d, 0x31, 0x70, 0x59,
169 0x6e, 0x67, 0x72, 0x4d, 0x6c, 0x52, 0x4d, 0x54, 0x47, 0x35, 0x51, 0x59, 0x33, 0x56, 0x58, 0x4d, 0x46, 0x42, 0x57,
170 0x54, 0x58, 0x68, 0x4b, 0x4f, 0x44, 0x5a, 0x6e, 0x50, 0x54, 0x30, 0x69, 0x4c, 0x43, 0x41, 0x69, 0x63, 0x32, 0x6c,
171 0x6e, 0x62, 0x6d, 0x46, 0x30, 0x64, 0x58, 0x4a, 0x6c, 0x49, 0x6a, 0x6f, 0x67, 0x49, 0x6b, 0x31, 0x48, 0x55, 0x55,
172 0x4e, 0x4e, 0x51, 0x30, 0x5a, 0x34, 0x56, 0x47, 0x78, 0x6c, 0x64, 0x6a, 0x68, 0x58, 0x56, 0x6a, 0x5a, 0x6b, 0x4e,
173 0x6b, 0x74, 0x75, 0x65, 0x46, 0x70, 0x79, 0x61, 0x33, 0x70, 0x52, 0x62, 0x47, 0x59, 0x33, 0x53, 0x45, 0x38, 0x35,
174 0x54, 0x6d, 0x31, 0x55, 0x61, 0x33, 0x4e, 0x58, 0x65, 0x54, 0x56, 0x34, 0x61, 0x46, 0x56, 0x4f, 0x63, 0x6a, 0x6c,
175 0x4d, 0x61, 0x6d, 0x6c, 0x4d, 0x63, 0x6e, 0x55, 0x33, 0x64, 0x45, 0x59, 0x31, 0x65, 0x6d, 0x59, 0x72, 0x4d, 0x45,
176 0x4a, 0x5a, 0x65, 0x47, 0x35, 0x32, 0x57, 0x58, 0x67, 0x79, 0x62, 0x56, 0x46, 0x4a, 0x64, 0x32, 0x4e, 0x68, 0x65,
177 0x6e, 0x56, 0x74, 0x64, 0x30, 0x64, 0x73, 0x61, 0x47, 0x78, 0x4f, 0x52, 0x48, 0x67, 0x72, 0x5a, 0x48, 0x4a, 0x30,
178 0x5a, 0x30, 0x4a, 0x7a, 0x53, 0x48, 0x46, 0x4c, 0x63, 0x6b, 0x64, 0x71, 0x63, 0x57, 0x52, 0x45, 0x4e, 0x44, 0x4e,
179 0x54, 0x62, 0x44, 0x6b, 0x7a, 0x52, 0x33, 0x42, 0x33, 0x4e, 0x45, 0x38, 0x33, 0x55, 0x6b, 0x35, 0x52, 0x55, 0x7a,
180 0x4a, 0x51, 0x64, 0x6e, 0x67, 0x34, 0x53, 0x6d, 0x74, 0x4b, 0x59, 0x6e, 0x52, 0x46, 0x56, 0x57, 0x56, 0x79, 0x5a,
181 0x48, 0x59, 0x76, 0x4e, 0x56, 0x4d, 0x69, 0x66, 0x53, 0x77, 0x67, 0x65, 0x79, 0x4a, 0x31, 0x63, 0x32, 0x56, 0x79,
182 0x55, 0x48, 0x56, 0x69, 0x62, 0x47, 0x6c, 0x6a, 0x53, 0x32, 0x56, 0x35, 0x49, 0x6a, 0x6f, 0x67, 0x49, 0x6b, 0x31,
183 0x49, 0x62, 0x33, 0x64, 0x47, 0x51, 0x56, 0x6c, 0x49, 0x53, 0x32, 0x39, 0x61, 0x53, 0x58, 0x70, 0x71, 0x4d, 0x45,
184 0x4e, 0x42, 0x55, 0x56, 0x6c, 0x4b, 0x53, 0x33, 0x6c, 0x52, 0x52, 0x45, 0x46, 0x33, 0x53, 0x55, 0x6c, 0x42, 0x55,
185 0x55, 0x56, 0x4d, 0x51, 0x54, 0x4a, 0x4a, 0x51, 0x55, 0x4a, 0x46, 0x51, 0x6b, 0x46, 0x47, 0x57, 0x54, 0x6b, 0x72,
186 0x4d, 0x30, 0x52, 0x61, 0x54, 0x48, 0x4d, 0x34, 0x54, 0x6e, 0x52, 0x61, 0x52, 0x48, 0x56, 0x73, 0x5a, 0x48, 0x52,
187 0x77, 0x51, 0x6d, 0x70, 0x31, 0x61, 0x6c, 0x42, 0x32, 0x64, 0x32, 0x6c, 0x6c, 0x55, 0x44, 0x6c, 0x55, 0x64, 0x6b,
188 0x31, 0x50, 0x57, 0x46, 0x5a, 0x72, 0x4e, 0x57, 0x5a, 0x32, 0x53, 0x6b, 0x68, 0x46, 0x55, 0x58, 0x59, 0x32, 0x57,
189 0x45, 0x52, 0x6c, 0x62, 0x45, 0x64, 0x50, 0x4e, 0x47, 0x52, 0x6e, 0x55, 0x56, 0x6f, 0x7a, 0x4e, 0x6c, 0x56, 0x4b,
190 0x51, 0x32, 0x6c, 0x56, 0x64, 0x31, 0x55, 0x79, 0x4c, 0x33, 0x4a, 0x4c, 0x63, 0x6b, 0x4e, 0x72, 0x65, 0x6e, 0x46,
191 0x76, 0x53, 0x30, 0x74, 0x74, 0x61, 0x58, 0x4e, 0x4e, 0x61, 0x30, 0x59, 0x32, 0x61, 0x46, 0x46, 0x6e, 0x62, 0x6c,
192 0x5a, 0x46, 0x5a, 0x33, 0x6c, 0x33, 0x61, 0x33, 0x68, 0x61, 0x56, 0x32, 0x34, 0x7a, 0x61, 0x48, 0x46, 0x6a, 0x65,
193 0x6e, 0x67, 0x7a, 0x63, 0x44, 0x64, 0x7a, 0x61, 0x6d, 0x46, 0x32, 0x53, 0x33, 0x6c, 0x53, 0x59, 0x6e, 0x52, 0x58,
194 0x56, 0x57, 0x35, 0x58, 0x64, 0x6d, 0x74, 0x54, 0x56, 0x32, 0x63, 0x39, 0x50, 0x53, 0x49, 0x73, 0x49, 0x43, 0x4a,
195 0x7a, 0x61, 0x57, 0x64, 0x75, 0x59, 0x58, 0x52, 0x31, 0x63, 0x6d, 0x55, 0x69, 0x4f, 0x69, 0x41, 0x69, 0x54, 0x55,
196 0x64, 0x52, 0x51, 0x30, 0x31, 0x47, 0x55, 0x32, 0x4a, 0x48, 0x4d, 0x7a, 0x64, 0x4d, 0x63, 0x30, 0x64, 0x7a, 0x52,
197 0x6b, 0x70, 0x4c, 0x5a, 0x31, 0x6c, 0x44, 0x56, 0x55, 0x52, 0x30, 0x53, 0x33, 0x42, 0x74, 0x51, 0x33, 0x46, 0x56,
198 0x52, 0x48, 0x63, 0x31, 0x63, 0x6b, 0x31, 0x4d, 0x56, 0x6b, 0x68, 0x6a, 0x51, 0x33, 0x5a, 0x74, 0x61, 0x44, 0x56,
199 0x68, 0x63, 0x56, 0x68, 0x72, 0x51, 0x6d, 0x51, 0x32, 0x52, 0x7a, 0x6c, 0x7a, 0x55, 0x44, 0x5a, 0x47, 0x64, 0x30,
200 0x52, 0x71, 0x62, 0x6d, 0x64, 0x59, 0x65, 0x45, 0x74, 0x73, 0x51, 0x31, 0x52, 0x4d, 0x5a, 0x30, 0x6c, 0x33, 0x5a,
201 0x48, 0x56, 0x34, 0x64, 0x45, 0x67, 0x30, 0x59, 0x55, 0x51, 0x35, 0x52, 0x6a, 0x4e, 0x33, 0x54, 0x30, 0x74, 0x51,
202 0x4e, 0x6e, 0x5a, 0x4a, 0x4d, 0x31, 0x46, 0x76, 0x63, 0x56, 0x4e, 0x6e, 0x65, 0x57, 0x4a, 0x49, 0x4d, 0x6b, 0x5a,
203 0x6a, 0x64, 0x79, 0x74, 0x46, 0x59, 0x33, 0x6f, 0x32, 0x4d, 0x6b, 0x30, 0x33, 0x54, 0x30, 0x52, 0x74, 0x4e, 0x30,
204 0x70, 0x33, 0x52, 0x57, 0x52, 0x6d, 0x5a, 0x58, 0x6f, 0x77, 0x53, 0x6b, 0x4a, 0x31, 0x59, 0x30, 0x64, 0x4b, 0x4d,
205 0x30, 0x68, 0x4b, 0x5a, 0x58, 0x56, 0x56, 0x56, 0x79, 0x4a, 0x39, 0x4c, 0x43, 0x42, 0x37, 0x49, 0x6e, 0x56, 0x7a,
206 0x5a, 0x58, 0x4a, 0x51, 0x64, 0x57, 0x4a, 0x73, 0x61, 0x57, 0x4e, 0x4c, 0x5a, 0x58, 0x6b, 0x69, 0x4f, 0x69, 0x41,
207 0x69, 0x54, 0x55, 0x68, 0x76, 0x64, 0x30, 0x5a, 0x42, 0x57, 0x55, 0x68, 0x4c, 0x62, 0x31, 0x70, 0x4a, 0x65, 0x6d,
208 0x6f, 0x77, 0x51, 0x30, 0x46, 0x52, 0x57, 0x55, 0x70, 0x4c, 0x65, 0x56, 0x46, 0x45, 0x51, 0x58, 0x64, 0x4a, 0x53,
209 0x55, 0x46, 0x52, 0x52, 0x55, 0x78, 0x42, 0x4d, 0x6b, 0x6c, 0x42, 0x51, 0x6b, 0x52, 0x46, 0x4d, 0x48, 0x4e, 0x50,
210 0x4d, 0x55, 0x56, 0x57, 0x63, 0x58, 0x56, 0x69, 0x55, 0x48, 0x4d, 0x78, 0x62, 0x44, 0x4e, 0x61, 0x64, 0x6d, 0x70,
211 0x42, 0x54, 0x45, 0x35, 0x78, 0x52, 0x6b, 0x63, 0x72, 0x55, 0x6c, 0x42, 0x49, 0x65, 0x69, 0x39, 0x4e, 0x4b, 0x33,
212 0x52, 0x50, 0x65, 0x55, 0x4e, 0x36, 0x63, 0x54, 0x4a, 0x75, 0x4e, 0x55, 0x46, 0x4e, 0x52, 0x6e, 0x55, 0x72, 0x4d,
213 0x57, 0x78, 0x73, 0x55, 0x45, 0x46, 0x68, 0x56, 0x45, 0x64, 0x59, 0x59, 0x7a, 0x51, 0x77, 0x54, 0x79, 0x39, 0x75,
214 0x54, 0x47, 0x6c, 0x75, 0x65, 0x69, 0x38, 0x34, 0x65, 0x6d, 0x5a, 0x61, 0x4e, 0x48, 0x52, 0x45, 0x51, 0x57, 0x6c,
215 0x55, 0x62, 0x33, 0x4e, 0x42, 0x55, 0x6d, 0x6c, 0x4b, 0x4b, 0x32, 0x30, 0x7a, 0x63, 0x6b, 0x56, 0x57, 0x54, 0x55,
216 0x5a, 0x72, 0x51, 0x69, 0x74, 0x6d, 0x62, 0x6e, 0x68, 0x35, 0x53, 0x45, 0x46, 0x44, 0x63, 0x32, 0x55, 0x72, 0x59,
217 0x57, 0x70, 0x48, 0x64, 0x6d, 0x5a, 0x78, 0x5a, 0x32, 0x46, 0x32, 0x61, 0x6a, 0x6c, 0x47, 0x54, 0x58, 0x4e, 0x49,
218 0x59, 0x6a, 0x4a, 0x4d, 0x52, 0x56, 0x70, 0x51, 0x5a, 0x6d, 0x6b, 0x72, 0x64, 0x7a, 0x30, 0x39, 0x49, 0x69, 0x77,
219 0x67, 0x49, 0x6e, 0x4e, 0x70, 0x5a, 0x32, 0x35, 0x68, 0x64, 0x48, 0x56, 0x79, 0x5a, 0x53, 0x49, 0x36, 0x49, 0x43,
220 0x4a, 0x4e, 0x52, 0x30, 0x31, 0x44, 0x54, 0x55, 0x56, 0x30, 0x64, 0x44, 0x63, 0x31, 0x56, 0x47, 0x30, 0x77, 0x55,
221 0x6d, 0x64, 0x74, 0x59, 0x6c, 0x6b, 0x76, 0x62, 0x32, 0x56, 0x70, 0x62, 0x30, 0x59, 0x33, 0x63, 0x48, 0x63, 0x32,
222 0x4b, 0x32, 0x38, 0x76, 0x5a, 0x45, 0x4a, 0x6d, 0x57, 0x54, 0x46, 0x43, 0x56, 0x56, 0x52, 0x30, 0x52, 0x48, 0x6c,
223 0x56, 0x62, 0x6a, 0x46, 0x79, 0x57, 0x6a, 0x6c, 0x74, 0x54, 0x57, 0x31, 0x4e, 0x57, 0x47, 0x78, 0x79, 0x51, 0x30,
224 0x6f, 0x76, 0x61, 0x47, 0x46, 0x54, 0x63, 0x32, 0x35, 0x6f, 0x53, 0x47, 0x31, 0x32, 0x64, 0x32, 0x68, 0x33, 0x53,
225 0x58, 0x5a, 0x6d, 0x59, 0x54, 0x42, 0x54, 0x5a, 0x30, 0x67, 0x7a, 0x57, 0x45, 0x4e, 0x42, 0x62, 0x55, 0x52, 0x55,
226 0x57, 0x6d, 0x30, 0x78, 0x4d, 0x6e, 0x70, 0x54, 0x55, 0x48, 0x63, 0x34, 0x62, 0x31, 0x6c, 0x49, 0x4c, 0x33, 0x51,
227 0x76, 0x4e, 0x58, 0x46, 0x30, 0x53, 0x30, 0x74, 0x48, 0x64, 0x6c, 0x70, 0x46, 0x5a, 0x57, 0x4a, 0x6d, 0x53, 0x6c,
228 0x64, 0x49, 0x51, 0x56, 0x45, 0x35, 0x4d, 0x46, 0x70, 0x6e, 0x62, 0x6c, 0x68, 0x55, 0x64, 0x57, 0x4e, 0x4f, 0x52,
229 0x30, 0x46, 0x51, 0x59, 0x30, 0x35, 0x42, 0x4f, 0x45, 0x6b, 0x39, 0x49, 0x6e, 0x31, 0x64, 0x00, 0x30, 0x18, 0x02,
230 0x01, 0x02, 0x06, 0x0d, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x8f, 0x5b, 0x02, 0x82, 0x78, 0x02, 0x01, 0x0b, 0x04, 0x04,
231 0x00, 0x00, 0x00, 0x00, 0x30, 0x18, 0x02, 0x01, 0x02, 0x06, 0x0d, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x8f, 0x5b, 0x02,
232 0x82, 0x78, 0x02, 0x01, 0x05, 0x04, 0x04, 0x02, 0x00, 0x00, 0x00, 0x30, 0x16, 0x02, 0x01, 0x02, 0x06, 0x0e, 0x2b,
233 0x06, 0x01, 0x04, 0x01, 0x8f, 0x5b, 0x02, 0x82, 0x78, 0x02, 0x04, 0x01, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0b, 0x06,
234 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x03, 0x82, 0x01, 0x01, 0x00, 0x8d, 0xb8, 0xee, 0xa7,
235 0x12, 0x30, 0x8c, 0x48, 0xc0, 0x57, 0x26, 0x99, 0xed, 0x1b, 0x48, 0x93, 0xdd, 0x7c, 0x7f, 0x04, 0xbd, 0x8b, 0x2a,
236 0x70, 0x2d, 0x27, 0x02, 0x8d, 0x98, 0xf0, 0x27, 0x78, 0xc2, 0x10, 0x1e, 0xa9, 0x5a, 0x3d, 0xce, 0x7b, 0x0d, 0x16,
237 0x57, 0x33, 0xd4, 0x5b, 0x87, 0x79, 0x65, 0xf0, 0x6f, 0xc4, 0xb0, 0x61, 0xef, 0x04, 0xa5, 0x6e, 0xd6, 0xc5, 0xbe,
238 0xf1, 0xbe, 0x6d, 0xaf, 0x76, 0x6f, 0x88, 0xc1, 0x37, 0xe8, 0xcd, 0x9d, 0x11, 0xdf, 0x57, 0x79, 0xc9, 0x74, 0x9e,
239 0x91, 0x8c, 0xb6, 0x82, 0x8a, 0xc7, 0x82, 0x5c, 0x25, 0x68, 0x90, 0x70, 0x9a, 0x31, 0x4e, 0x06, 0x7d, 0x57, 0x57,
240 0x26, 0x60, 0x09, 0x52, 0xf5, 0x4e, 0x6c, 0xee, 0xd8, 0x6b, 0x36, 0x80, 0x35, 0x21, 0xa9, 0xb2, 0x7a, 0x6b, 0x26,
241 0x4c, 0x44, 0xbd, 0xb6, 0x37, 0x27, 0x66, 0xe8, 0x26, 0x12, 0x51, 0xd2, 0x5b, 0x85, 0x3e, 0x92, 0x5a, 0xd3, 0x9d,
242 0xca, 0xc5, 0x92, 0xcb, 0x13, 0xa0, 0x8a, 0x52, 0xb7, 0xa7, 0xf3, 0x2b, 0xdc, 0x6d, 0x65, 0xf0, 0xb6, 0x52, 0xbc,
243 0xf7, 0x40, 0xdc, 0x8e, 0xa8, 0x6b, 0xda, 0xbc, 0x6a, 0xb4, 0x50, 0x63, 0x20, 0xe4, 0x34, 0xf4, 0x59, 0xaa, 0x88,
244 0xdc, 0xe3, 0x7a, 0x88, 0xde, 0xcd, 0xd6, 0xb6, 0x0c, 0x19, 0xfc, 0x1f, 0xe2, 0x47, 0xae, 0x35, 0xcf, 0x91, 0x7e,
245 0x7b, 0x05, 0x9f, 0x7b, 0x27, 0x80, 0x25, 0x21, 0x06, 0x43, 0xa0, 0x28, 0xb0, 0xa2, 0x71, 0xda, 0xc8, 0x63, 0xed,
246 0x7d, 0x58, 0x2e, 0x20, 0xfc, 0xde, 0x00, 0x1a, 0x04, 0xba, 0xcc, 0x5f, 0x78, 0x99, 0x64, 0xa5, 0x65, 0x2f, 0x10,
247 0x7b, 0x98, 0xc0, 0x36, 0x4a, 0x5f, 0x82, 0xe6, 0x77, 0x81, 0x13, 0xda, 0xa0, 0x21, 0xec, 0x80, 0x0f, 0x46, 0x12,
248 0x13, 0x50, 0xdd, 0xe6, 0xee, 0x01, 0x01, 0xcf, 0x03, 0x30, 0x82, 0x03, 0xcb, 0x30, 0x82, 0x02, 0xb3, 0xa0, 0x03,
249 0x02, 0x01, 0x02, 0x02, 0x01, 0x03, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
250 0x05, 0x00, 0x30, 0x7e, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43, 0x4e, 0x31, 0x13,
251 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64,
252 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72,
253 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77,
254 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c, 0x68, 0x65, 0x6c, 0x6c,
255 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x31, 0x31, 0x19, 0x30, 0x17, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
256 0x0d, 0x01, 0x09, 0x01, 0x16, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x30, 0x1e, 0x17,
257 0x0d, 0x32, 0x32, 0x30, 0x31, 0x32, 0x32, 0x30, 0x39, 0x32, 0x35, 0x33, 0x33, 0x5a, 0x17, 0x0d, 0x33, 0x32, 0x30,
258 0x31, 0x32, 0x30, 0x30, 0x39, 0x32, 0x35, 0x33, 0x33, 0x5a, 0x30, 0x7f, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
259 0x04, 0x06, 0x13, 0x02, 0x43, 0x4e, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x68, 0x65,
260 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0a,
261 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0b,
262 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x16, 0x30, 0x14, 0x06, 0x03, 0x55,
263 0x04, 0x03, 0x0c, 0x0d, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x31, 0x31, 0x31, 0x19,
264 0x30, 0x17, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x0a, 0x68, 0x65, 0x6c, 0x6c,
265 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
266 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01,
267 0x00, 0xbc, 0x1c, 0x78, 0x55, 0x11, 0xb6, 0x37, 0xba, 0xea, 0xe2, 0x5b, 0x7c, 0x00, 0x70, 0x03, 0x05, 0xc0, 0x85,
268 0x1d, 0xf9, 0x52, 0x26, 0x01, 0x42, 0xa7, 0x58, 0x06, 0x25, 0xb2, 0x21, 0xcb, 0x3e, 0xcd, 0xc1, 0x86, 0x91, 0xc7,
269 0x6f, 0xae, 0xe4, 0x8f, 0x33, 0xf7, 0xad, 0xc4, 0x1b, 0x67, 0x69, 0x75, 0x2d, 0x23, 0x16, 0x8e, 0x85, 0x7c, 0x8d,
270 0x77, 0x24, 0x54, 0xc3, 0x85, 0xa8, 0xe9, 0x53, 0x96, 0xb6, 0x25, 0x18, 0xcd, 0xc6, 0xf3, 0x46, 0xd5, 0x69, 0x67,
271 0x04, 0x83, 0x0e, 0x1c, 0xfa, 0x79, 0x12, 0x93, 0xe0, 0x29, 0x1a, 0x63, 0x54, 0x6b, 0xaf, 0x47, 0x2b, 0x78, 0x7e,
272 0xe6, 0xf7, 0xf3, 0xf3, 0x57, 0xd5, 0x98, 0x92, 0xf5, 0xcd, 0x7d, 0x15, 0x69, 0x88, 0x80, 0xfb, 0x00, 0xb3, 0xac,
273 0x57, 0x35, 0xc3, 0x96, 0x86, 0x2a, 0x1b, 0x05, 0x21, 0xc2, 0x18, 0xf0, 0x55, 0x28, 0x8b, 0x5e, 0x71, 0xaf, 0x00,
274 0x14, 0x45, 0x0f, 0xbf, 0x13, 0x29, 0x73, 0x78, 0x5d, 0xf4, 0xda, 0xa1, 0xb0, 0x90, 0x21, 0xd8, 0xcb, 0x8c, 0xd0,
275 0xaa, 0x7d, 0xe8, 0x86, 0x4b, 0xb6, 0xe6, 0xb3, 0xcb, 0x50, 0xec, 0x8e, 0xa7, 0xa8, 0x09, 0x36, 0xcf, 0xf7, 0x05,
276 0x58, 0x7b, 0xe9, 0xbf, 0x7f, 0xd6, 0x24, 0xf2, 0x3f, 0xb9, 0x5d, 0x0c, 0x3e, 0xd5, 0x57, 0x85, 0x10, 0x09, 0x30,
277 0xe9, 0xa4, 0x5b, 0x6b, 0x0d, 0x06, 0x3f, 0x52, 0xb0, 0x61, 0x7b, 0xdb, 0x0f, 0x9f, 0x4f, 0xba, 0x19, 0x60, 0x5f,
278 0x92, 0x48, 0xf3, 0xe6, 0x7d, 0x5a, 0x18, 0x4e, 0xc9, 0x3f, 0x6b, 0xe6, 0x07, 0x7a, 0x8c, 0x83, 0x12, 0x29, 0x12,
279 0x49, 0x95, 0x2d, 0x52, 0x31, 0x87, 0xa7, 0x70, 0x04, 0xe9, 0xad, 0xaf, 0xeb, 0x13, 0xef, 0x12, 0x7e, 0x53, 0x39,
280 0x93, 0x59, 0xb6, 0xe1, 0x34, 0x60, 0xa4, 0xcd, 0x23, 0xf1, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x53, 0x30, 0x51,
281 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x83, 0x4e, 0xaa, 0x7a, 0x40, 0xe7, 0x71, 0x93,
282 0xdc, 0xc5, 0xd8, 0x7f, 0xbb, 0x20, 0x63, 0x9c, 0x92, 0xaf, 0xc0, 0xd4, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23,
283 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x4d, 0x60, 0x01, 0x09, 0x97, 0x0c, 0x4f, 0x3a, 0x3e, 0x45, 0x07, 0xb3, 0x38,
284 0x99, 0x3b, 0x0c, 0xa6, 0x89, 0x11, 0x2f, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05,
285 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05,
286 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x78, 0x0a, 0x42, 0x9b, 0x25, 0x05, 0xae, 0x0b, 0x6a, 0x63, 0xd1, 0xc4, 0xbe,
287 0xcd, 0xbe, 0x2f, 0xf1, 0xf4, 0x6a, 0xf0, 0xe3, 0xe3, 0x45, 0x53, 0xf2, 0x96, 0xa8, 0xc7, 0x5f, 0x82, 0x0c, 0xa6,
288 0x69, 0xe5, 0xd9, 0x53, 0x34, 0x0e, 0x43, 0x57, 0x0f, 0x44, 0x98, 0x3c, 0x2e, 0x48, 0xc6, 0x42, 0xb8, 0x6e, 0x0b,
289 0x60, 0x94, 0x6d, 0x11, 0x92, 0xbe, 0x1b, 0x95, 0x87, 0xfe, 0x3d, 0xd3, 0x5e, 0x9d, 0xb7, 0x9b, 0x59, 0x9b, 0xf0,
290 0xe1, 0x8d, 0xc9, 0x52, 0x84, 0x20, 0x49, 0xab, 0x1f, 0x74, 0x80, 0x3f, 0xac, 0x95, 0xd9, 0xb5, 0xfd, 0xe6, 0x55,
291 0x43, 0x4b, 0x98, 0xf9, 0x5c, 0x45, 0x66, 0x42, 0x3a, 0xd1, 0x89, 0x9a, 0xf9, 0x67, 0xb6, 0x9e, 0xff, 0xa9, 0x69,
292 0x7b, 0x24, 0x22, 0x1a, 0x88, 0x3e, 0xf7, 0xd9, 0xb6, 0x89, 0x53, 0x50, 0xd9, 0x72, 0x1c, 0xb7, 0x6a, 0x6d, 0x96,
293 0x58, 0x6a, 0x5c, 0x84, 0x11, 0x12, 0x04, 0xeb, 0x68, 0x4a, 0xf7, 0x72, 0xc0, 0x6f, 0x93, 0xd3, 0x14, 0x10, 0x71,
294 0x7c, 0xd8, 0x43, 0xe9, 0x87, 0x3e, 0xcc, 0xa6, 0xdf, 0x42, 0x42, 0xcc, 0x28, 0x6f, 0x64, 0x22, 0xb3, 0xf9, 0x02,
295 0x65, 0x21, 0x95, 0x09, 0xdd, 0x78, 0x28, 0x28, 0x7e, 0xcc, 0x56, 0xf8, 0x80, 0x49, 0x71, 0x9c, 0x58, 0xb2, 0x8e,
296 0x05, 0x86, 0x14, 0x0e, 0xdd, 0xc9, 0xf3, 0xf3, 0xcc, 0xb2, 0x16, 0xec, 0xa9, 0xbf, 0xab, 0x9b, 0xe5, 0x6a, 0x53,
297 0x9a, 0x21, 0x57, 0xc4, 0x6b, 0xfe, 0x74, 0x3e, 0x40, 0xbb, 0xc4, 0x15, 0xaf, 0x2b, 0xaf, 0x3e, 0xea, 0x63, 0xaf,
298 0xf6, 0x41, 0x26, 0xd4, 0xcb, 0xb4, 0x2f, 0x14, 0x2b, 0xfb, 0x31, 0x71, 0x43, 0xd6, 0x40, 0x87, 0xf7, 0x61, 0x4b,
299 0x1b, 0x09, 0x26, 0x58, 0x36, 0xaf, 0x33, 0x59, 0x1d, 0x54, 0xc5, 0xd9, 0x99, 0x5e, 0x78, 0x01, 0x01, 0xe3, 0x03,
300 0x30, 0x82, 0x03, 0xdf, 0x30, 0x82, 0x02, 0xc7, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x01, 0x02, 0x30, 0x0d, 0x06,
301 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x81, 0x92, 0x31, 0x0b, 0x30, 0x09,
302 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43, 0x4e, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c,
303 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04,
304 0x07, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03,
305 0x55, 0x04, 0x0a, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11,
306 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x14,
307 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0b, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64,
308 0x31, 0x31, 0x19, 0x30, 0x17, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x0a, 0x68,
309 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x32, 0x30, 0x31, 0x32, 0x32,
310 0x30, 0x39, 0x32, 0x33, 0x34, 0x38, 0x5a, 0x17, 0x0d, 0x33, 0x32, 0x30, 0x31, 0x32, 0x30, 0x30, 0x39, 0x32, 0x33,
311 0x34, 0x38, 0x5a, 0x30, 0x7e, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43, 0x4e, 0x31,
312 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c,
313 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f,
314 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f,
315 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c, 0x68, 0x65, 0x6c,
316 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x31, 0x31, 0x19, 0x30, 0x17, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
317 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x30, 0x82,
318 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82,
319 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xb4, 0xc9, 0x17, 0xe4, 0x80, 0x87, 0xf7,
320 0x1c, 0x99, 0xcc, 0x45, 0xfa, 0x57, 0xb4, 0x9b, 0xc5, 0xb1, 0xec, 0xdf, 0x64, 0x72, 0x53, 0x18, 0xa1, 0x45, 0x46,
321 0xc8, 0x93, 0x8f, 0x0e, 0xfd, 0x0b, 0xf6, 0x41, 0x3f, 0xd6, 0x18, 0x3d, 0x1c, 0x46, 0xaf, 0x08, 0x15, 0x9a, 0x97,
322 0xd6, 0x4a, 0xeb, 0xda, 0xfe, 0x8b, 0x56, 0x22, 0x1f, 0x5f, 0x18, 0xd0, 0x5e, 0x68, 0x02, 0xea, 0x8f, 0xd2, 0xd7,
323 0x9e, 0x74, 0x30, 0x72, 0x3e, 0x28, 0xbc, 0x21, 0xa0, 0xea, 0xb8, 0x92, 0x99, 0xd6, 0x19, 0x4c, 0x8b, 0x5d, 0xef,
324 0x3d, 0x8d, 0x5c, 0x81, 0x47, 0x06, 0xef, 0xb7, 0x0a, 0xcc, 0x2e, 0x53, 0x32, 0x59, 0x8d, 0x4c, 0xb7, 0xac, 0xd1,
325 0xd7, 0x67, 0xf7, 0xf9, 0x58, 0xe1, 0xa8, 0xe5, 0xe2, 0x48, 0x14, 0xaf, 0x76, 0xc2, 0x11, 0x79, 0x69, 0xe2, 0xe8,
326 0x41, 0x40, 0xf6, 0x25, 0x9e, 0xdb, 0xa3, 0x72, 0xd7, 0x23, 0x98, 0x47, 0x4c, 0xb5, 0xc2, 0x50, 0x9a, 0x11, 0xe9,
327 0xaf, 0x62, 0x6c, 0xf5, 0xca, 0xb6, 0x91, 0x99, 0xde, 0xcb, 0x9f, 0x5a, 0x7b, 0x99, 0x24, 0x2c, 0x2c, 0xe9, 0x16,
328 0xaa, 0x63, 0xed, 0xcb, 0xa7, 0xcf, 0x94, 0x6c, 0xdd, 0x16, 0x6c, 0xd7, 0xe3, 0x63, 0xc3, 0x9a, 0x00, 0x05, 0x2d,
329 0x7c, 0xa8, 0x0c, 0xb5, 0x08, 0x40, 0x67, 0x79, 0xc2, 0xce, 0x8b, 0xa9, 0x48, 0x3e, 0xf2, 0x1c, 0x92, 0x78, 0x01,
330 0x1d, 0xdb, 0xb0, 0x73, 0x33, 0x8c, 0xe5, 0x80, 0x41, 0x5d, 0xea, 0x8e, 0x78, 0xd9, 0x3b, 0x15, 0x64, 0xe2, 0x21,
331 0xfe, 0x4c, 0xb9, 0x79, 0x6a, 0x39, 0x29, 0x59, 0xe7, 0xb5, 0xa9, 0xf1, 0x2a, 0x9f, 0x0f, 0x3c, 0x12, 0xe3, 0xd6,
332 0xb0, 0xc0, 0x8f, 0x5d, 0xbc, 0x6a, 0x63, 0x83, 0x21, 0xa1, 0xdd, 0x94, 0x00, 0xe5, 0x35, 0xd7, 0x18, 0x62, 0x2c,
333 0x9f, 0x97, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x53, 0x30, 0x51, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04,
334 0x16, 0x04, 0x14, 0x4d, 0x60, 0x01, 0x09, 0x97, 0x0c, 0x4f, 0x3a, 0x3e, 0x45, 0x07, 0xb3, 0x38, 0x99, 0x3b, 0x0c,
335 0xa6, 0x89, 0x11, 0x2f, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x9a, 0x77,
336 0x73, 0xe5, 0x45, 0xa4, 0x69, 0x42, 0xfe, 0xbf, 0xd4, 0x88, 0xf0, 0xa8, 0xce, 0x81, 0xf5, 0x51, 0xc8, 0x0c, 0x30,
337 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0d, 0x06,
338 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x0a, 0xcb,
339 0x6d, 0x66, 0x56, 0x1b, 0x77, 0x07, 0xb8, 0x29, 0xcc, 0x04, 0x6a, 0x36, 0xf0, 0x5d, 0x0a, 0x54, 0xa7, 0x2d, 0xc6,
340 0x32, 0xd5, 0x38, 0x2c, 0xc3, 0x84, 0xa9, 0xc7, 0x22, 0xeb, 0x0b, 0x56, 0xa4, 0xe7, 0x67, 0xb0, 0x07, 0x79, 0x45,
341 0x39, 0xe8, 0xdc, 0xa8, 0x45, 0xf4, 0x91, 0x48, 0x81, 0x09, 0xd9, 0x33, 0x57, 0x90, 0x73, 0xbc, 0x33, 0x2c, 0x4d,
342 0x37, 0x79, 0x4f, 0xe1, 0x16, 0xa9, 0x41, 0xab, 0xce, 0xbc, 0x43, 0x4b, 0x13, 0xdf, 0x6c, 0xdb, 0xaf, 0x48, 0xb2,
343 0xe2, 0xcf, 0x0a, 0x9d, 0xe4, 0xeb, 0x39, 0xc9, 0x5f, 0x56, 0x56, 0xec, 0xc2, 0x2b, 0x4a, 0x9e, 0xc1, 0xcf, 0xee,
344 0xab, 0x05, 0x3b, 0xa1, 0xd8, 0x7f, 0x3b, 0xe0, 0x7f, 0xc1, 0x72, 0xf3, 0xd7, 0x68, 0x26, 0x41, 0xe1, 0x7d, 0xcd,
345 0xa6, 0x37, 0xee, 0xe2, 0xd4, 0x5c, 0x28, 0x4b, 0x52, 0x24, 0xa7, 0x55, 0x98, 0x89, 0x68, 0xb6, 0x35, 0xf5, 0xa8,
346 0xce, 0x5e, 0x60, 0x76, 0x39, 0x04, 0x34, 0x91, 0xd0, 0xcb, 0xd1, 0x62, 0xf4, 0xa5, 0x1f, 0xbf, 0xf0, 0x03, 0xd1,
347 0x44, 0x18, 0x9f, 0x06, 0x1c, 0x8e, 0xef, 0x68, 0x7c, 0x48, 0x33, 0x17, 0xf8, 0xf8, 0xe3, 0xb3, 0xf8, 0x4e, 0x30,
348 0xa8, 0xa2, 0x19, 0x65, 0xf6, 0x1e, 0x54, 0x17, 0x44, 0xa5, 0x9b, 0xdf, 0x54, 0x61, 0xd1, 0x6d, 0x2e, 0x5d, 0x12,
349 0x87, 0xea, 0x73, 0x83, 0x6d, 0x86, 0x53, 0x9b, 0x4d, 0x69, 0x70, 0x00, 0x88, 0x45, 0x81, 0x3c, 0xcb, 0xab, 0x2f,
350 0x32, 0xd9, 0x8d, 0xa3, 0x0d, 0x67, 0x09, 0x93, 0xdd, 0x7f, 0xcb, 0xdb, 0xbc, 0x17, 0x58, 0xd0, 0x02, 0xea, 0x1e,
351 0x98, 0x30, 0x98, 0xe4, 0x16, 0xa5, 0x67, 0xe0, 0x67, 0xd1, 0xe6, 0x50, 0x40, 0x79, 0x57, 0xba, 0x3c, 0x32, 0x65,
352 0xfa, 0x08, 0x2b, 0xea, 0x02, 0xb9, 0x4a, 0x01, 0x01, 0x0b, 0x04, 0x30, 0x82, 0x04, 0x07, 0x30, 0x82, 0x02, 0xef,
353 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x4a, 0xfc, 0x65, 0x4f, 0x67, 0x13, 0x23, 0x9a, 0xe3, 0xeb, 0xb3, 0x60,
354 0xe6, 0x5a, 0x90, 0xef, 0xaa, 0x5e, 0x45, 0x8b, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01,
355 0x01, 0x0b, 0x05, 0x00, 0x30, 0x81, 0x92, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43,
356 0x4e, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f,
357 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f,
358 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0a, 0x68, 0x65, 0x6c,
359 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x0a, 0x68,
360 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c,
361 0x0b, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x31, 0x19, 0x30, 0x17, 0x06, 0x09, 0x2a,
362 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c,
363 0x64, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x32, 0x30, 0x31, 0x32, 0x32, 0x30, 0x39, 0x32, 0x31, 0x34, 0x34, 0x5a, 0x17,
364 0x0d, 0x33, 0x32, 0x30, 0x31, 0x32, 0x30, 0x30, 0x39, 0x32, 0x31, 0x34, 0x34, 0x5a, 0x30, 0x81, 0x92, 0x31, 0x0b,
365 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43, 0x4e, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04,
366 0x08, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03,
367 0x55, 0x04, 0x07, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13, 0x30, 0x11,
368 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x31, 0x13,
369 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64,
370 0x31, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0b, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72,
371 0x6c, 0x64, 0x31, 0x31, 0x19, 0x30, 0x17, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16,
372 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09,
373 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01,
374 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xe7, 0x7f, 0xdc, 0x2f, 0xfb, 0x9c, 0xa3, 0x15, 0x38, 0xd1, 0xe2, 0x21, 0x05,
375 0xc7, 0xbf, 0x76, 0x44, 0xec, 0x40, 0x27, 0x74, 0xc2, 0x6c, 0x02, 0xef, 0xeb, 0xc9, 0x7e, 0xc4, 0x01, 0x1b, 0x60,
376 0xb6, 0x3c, 0x51, 0xe9, 0xf7, 0x67, 0x1f, 0x62, 0xe7, 0x98, 0xb0, 0x9b, 0xab, 0x89, 0xac, 0x42, 0xb7, 0xaa, 0x15,
377 0x72, 0x7f, 0x78, 0xc3, 0x3c, 0x16, 0x40, 0xd9, 0x70, 0xbc, 0xb5, 0xad, 0x53, 0x0c, 0x6d, 0x35, 0x8b, 0xc0, 0x6c,
378 0x57, 0x09, 0x79, 0x97, 0xb1, 0x19, 0x5e, 0xfb, 0x6d, 0xd2, 0xdd, 0x0c, 0x70, 0xfe, 0xc0, 0xc0, 0x76, 0x10, 0x46,
379 0xbd, 0xab, 0xfa, 0x84, 0x87, 0xcf, 0x2a, 0x31, 0xf4, 0x89, 0xfe, 0xdf, 0xdb, 0xa8, 0xd1, 0x96, 0xd4, 0x59, 0x53,
380 0xbc, 0x32, 0x87, 0xb0, 0xb9, 0xb2, 0xc3, 0xd1, 0x3c, 0x98, 0xbe, 0x66, 0xa4, 0xa2, 0x5d, 0x3f, 0x9a, 0x43, 0x96,
381 0x6a, 0x7d, 0xcb, 0x53, 0xd0, 0x58, 0xae, 0x36, 0xb2, 0x40, 0x79, 0xb0, 0x7c, 0x8a, 0xfd, 0x27, 0x86, 0x86, 0x75,
382 0xf4, 0xeb, 0x82, 0xe5, 0x4a, 0xad, 0x37, 0x2c, 0xff, 0xe7, 0x95, 0x27, 0x27, 0x0e, 0x98, 0x2d, 0xef, 0xe6, 0x44,
383 0x20, 0xe2, 0xd6, 0x84, 0xd1, 0x4c, 0x49, 0xc3, 0xeb, 0x08, 0x4b, 0x23, 0x1c, 0x55, 0xc5, 0xe0, 0x15, 0x6f, 0x2a,
384 0x95, 0xc0, 0xad, 0x60, 0x8a, 0xb0, 0x32, 0xfc, 0xa2, 0xfd, 0x91, 0x1f, 0x13, 0xf0, 0xef, 0x1c, 0x7b, 0x6c, 0x46,
385 0x41, 0x8a, 0x11, 0x89, 0x24, 0xe0, 0xb0, 0x21, 0x86, 0xab, 0x4a, 0xa9, 0x86, 0x49, 0x2b, 0xe8, 0x41, 0xd6, 0x00,
386 0x04, 0x67, 0xfe, 0x8e, 0xc7, 0xca, 0xf2, 0xa1, 0x5f, 0x50, 0xec, 0x7d, 0x8b, 0x76, 0x4c, 0x01, 0x0a, 0xbc, 0xe1,
387 0x2c, 0x56, 0x3c, 0x65, 0x49, 0x4a, 0xc9, 0xd7, 0x57, 0xaa, 0x93, 0x72, 0x02, 0x79, 0xc7, 0x02, 0x03, 0x01, 0x00,
388 0x01, 0xa3, 0x53, 0x30, 0x51, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x9a, 0x77, 0x73,
389 0xe5, 0x45, 0xa4, 0x69, 0x42, 0xfe, 0xbf, 0xd4, 0x88, 0xf0, 0xa8, 0xce, 0x81, 0xf5, 0x51, 0xc8, 0x0c, 0x30, 0x1f,
390 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x9a, 0x77, 0x73, 0xe5, 0x45, 0xa4, 0x69, 0x42,
391 0xfe, 0xbf, 0xd4, 0x88, 0xf0, 0xa8, 0xce, 0x81, 0xf5, 0x51, 0xc8, 0x0c, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13,
392 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
393 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x34, 0x1b, 0xea, 0x9d, 0xe7, 0x6f, 0xe5, 0x89,
394 0xce, 0x97, 0xae, 0x5a, 0x5a, 0x66, 0xf0, 0x1f, 0xd6, 0x32, 0x3b, 0xe5, 0xf6, 0x40, 0x45, 0xd0, 0x04, 0xd1, 0x13,
395 0x3d, 0x49, 0x7d, 0x68, 0xb9, 0x81, 0x7f, 0x02, 0x33, 0x6e, 0xf1, 0xab, 0x6b, 0x49, 0x03, 0xb2, 0x5f, 0x8c, 0x73,
396 0xd0, 0x3c, 0xfc, 0xd8, 0x27, 0xc2, 0x8a, 0x5f, 0xe9, 0x6b, 0x31, 0x22, 0xc9, 0xa8, 0x02, 0x85, 0x27, 0xb6, 0xe3,
397 0xd4, 0x91, 0x5f, 0x15, 0x17, 0x50, 0x3e, 0xaf, 0xdb, 0x25, 0x6e, 0x5e, 0x38, 0xc6, 0x25, 0xd6, 0x63, 0x3f, 0x74,
398 0xb8, 0x4f, 0xa8, 0x8c, 0xab, 0x7e, 0x19, 0x83, 0x89, 0x4d, 0xc5, 0xa3, 0xc3, 0xfd, 0xd5, 0xb9, 0x84, 0x76, 0xc8,
399 0x29, 0x7f, 0xcd, 0x17, 0x0c, 0xcc, 0xce, 0x9e, 0x60, 0xb9, 0xcf, 0xad, 0x81, 0x32, 0xd5, 0x65, 0x12, 0x0b, 0x2e,
400 0xf4, 0x36, 0x56, 0x03, 0xbd, 0x13, 0xd6, 0x42, 0xdd, 0xfb, 0xc9, 0xe5, 0xd0, 0x4a, 0x9c, 0xe1, 0xf2, 0x45, 0x1f,
401 0x23, 0x13, 0x56, 0xfb, 0xc1, 0x9e, 0x41, 0x9b, 0xad, 0xf9, 0x16, 0xaa, 0x0c, 0x23, 0x81, 0x9d, 0x27, 0xd7, 0x68,
402 0xa9, 0x49, 0x1e, 0xb5, 0xb5, 0xa6, 0xbb, 0x11, 0x5a, 0x37, 0x13, 0x4e, 0x97, 0xbd, 0x28, 0x17, 0x83, 0x6a, 0x6a,
403 0x2f, 0x2e, 0xa2, 0x00, 0x42, 0xc7, 0xfe, 0x0f, 0xfc, 0xaf, 0x88, 0x84, 0x65, 0xa2, 0x4f, 0x02, 0x13, 0xfd, 0xa9,
404 0x4b, 0xb6, 0x31, 0xc5, 0xfa, 0x41, 0xd3, 0x4b, 0xa6, 0xb0, 0xe3, 0x0c, 0x4a, 0xaf, 0xaa, 0x0b, 0x8f, 0xc5, 0x34,
405 0x9c, 0x77, 0xc1, 0x35, 0x65, 0x03, 0x2d, 0x2b, 0x0c, 0x4b, 0xdd, 0x69, 0xc6, 0xe4, 0x97, 0xf8, 0x2d, 0x49, 0x3a,
406 0xdd, 0x26, 0xb7, 0x09, 0xd3, 0x3d, 0xee, 0xc5, 0x09, 0x21, 0xcd, 0x73, 0x41, 0x05, 0xc1, 0xf1, 0xdb, 0x8e, 0x3a,
407 0x7f};
408
SetUpTestCase()409 void DslmTest::SetUpTestCase()
410 {
411 // modify the device's systime to ensure that the certificate verification passes
412 constexpr time_t yearTimeLeast = 1699977600;
413 constexpr time_t yearTimeValid = 1704038400;
414 struct timeval timeVal = {0};
415 string isEnforcing;
416
417 gettimeofday(&timeVal, nullptr);
418 if (timeVal.tv_sec <= yearTimeLeast) {
419 timeVal.tv_sec = yearTimeValid;
420 settimeofday(&timeVal, nullptr);
421 }
422
423 static const char *acls[] = {"ACCESS_IDS"};
424 static const char *perms[] = {
425 "ohos.permission.PLACE_CALL",
426 "ohos.permission.ACCESS_IDS",
427 };
428 uint64_t tokenId;
429 NativeTokenInfoParams infoInstance = {
430 .dcapsNum = 0,
431 .permsNum = 2,
432 .aclsNum = 1,
433 .dcaps = nullptr,
434 .perms = perms,
435 .acls = acls,
436 .processName = "dslm_service",
437 .aplStr = "system_core",
438 };
439 tokenId = GetAccessTokenId(&infoInstance);
440 SetSelfTokenID(tokenId);
441 LoadStringFromFile("/sys/fs/selinux/enforce", isEnforcing);
442 if (isEnforcing.compare("1") == 0) {
443 DslmTest::isEnforcing_ = true;
444 SaveStringToFile("/sys/fs/selinux/enforce", "0");
445 }
446 }
TearDownTestCase()447 void DslmTest::TearDownTestCase()
448 {
449 if (DslmTest::isEnforcing_) {
450 SaveStringToFile("/sys/fs/selinux/enforce", "1");
451 }
452 }
SetUp()453 void DslmTest::SetUp()
454 {
455 }
TearDown()456 void DslmTest::TearDown()
457 {
458 }
459 bool DslmTest::isEnforcing_ = false;
460
BlockCheckDeviceStatus(const DeviceIdentify * device,uint32_t status,uint64_t millisec)461 static void BlockCheckDeviceStatus(const DeviceIdentify *device, uint32_t status, uint64_t millisec)
462 {
463 static int sleepTick = 10;
464 uint64_t cnt = millisec / static_cast<uint64_t>(sleepTick) + 1;
465 do {
466 const DslmDeviceInfo *info = GetDslmDeviceInfo(device);
467 if (info == nullptr) {
468 continue;
469 }
470 if (info->machine.currState == status) {
471 break;
472 }
473 if (cnt == 0) {
474 break;
475 }
476 this_thread::sleep_for(milliseconds(sleepTick));
477 cnt--;
478 } while (true);
479 }
480
481 HWTEST_F(DslmTest, BuildDeviceSecInfoRequest_case1, TestSize.Level0)
482 {
483 uint64_t random = 0x0807060504030201;
484 MessageBuff *msg = nullptr;
485 // 0d196608 = 0x030000
486 const char *except = "{\"message\":1,\"payload\":{\"version\":196608,\"challenge\":\"0102030405060708\","
487 "\"support\":[3000,2000,1000]}}";
488 int32_t ret = BuildDeviceSecInfoRequest(random, &msg);
489 ASSERT_EQ(0, ret);
490 EXPECT_STREQ(except, (const char *)msg->buff);
491 FreeMessageBuff(msg);
492 }
493
494 HWTEST_F(DslmTest, BuildDeviceSecInfoRequest_case2, TestSize.Level0)
495 {
496 uint64_t random = 0x0807060504030201;
497 MessageBuff **msg = nullptr;
498 int32_t ret = BuildDeviceSecInfoRequest(random, msg);
499 ASSERT_EQ(ERR_INVALID_PARA, ret);
500 }
501
502 HWTEST_F(DslmTest, BuildDeviceSecInfoRequest_case3, TestSize.Level0)
503 {
504 uint64_t random = 0x0807060504030201;
505 const char *message = "{\"mege\":1,\"payload\":{\"version\":131072,\"challenge\":\"0102030405060708\"}}";
506 uint32_t messageLen = strlen(message) + 1;
507 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
508 MessageBuff *msg_ptr = &msg;
509
510 int32_t ret = BuildDeviceSecInfoRequest(random, &msg_ptr);
511 ASSERT_EQ(ERR_INVALID_PARA, ret);
512 }
513
514 HWTEST_F(DslmTest, BuildDeviceSecInfoResponse_case1, TestSize.Level0)
515 {
516 uint64_t random = 0x0807060504030201;
517 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
518 DslmCredBuff cred = {(CredType)3, 9, info};
519
520 // 0d196608 = 0x030000
521 const char *except = "{\"message\":2,\"payload\":{\"version\":196608,\"type\":3,\"challenge\":\"0102030405060708\","
522 "\"info\":\"YWJjZAEDBQcJ\"}}";
523
524 MessageBuff *msg = nullptr;
525 int32_t ret = BuildDeviceSecInfoResponse(random, (DslmCredBuff *)&cred, &msg);
526 ASSERT_EQ(0, ret);
527
528 EXPECT_STREQ(except, (const char *)msg->buff);
529 FreeMessageBuff(msg);
530 }
531
532 HWTEST_F(DslmTest, BuildDeviceSecInfoResponse_case2, TestSize.Level0)
533 {
534 uint64_t random = 0x0807060504030201;
535 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
536 DslmCredBuff cred = {(CredType)3, 9, info};
537
538 {
539 MessageBuff **msg = nullptr;
540
541 int32_t ret = BuildDeviceSecInfoResponse(random, (DslmCredBuff *)&cred, msg);
542 ASSERT_EQ(ERR_INVALID_PARA, ret);
543
544 ret = BuildDeviceSecInfoResponse(random, nullptr, msg);
545 }
546
547 {
548 MessageBuff msg;
549 memset_s(&msg, sizeof(MessageBuff), 0, sizeof(MessageBuff));
550 MessageBuff *msgPtr = &msg;
551
552 int32_t ret = BuildDeviceSecInfoResponse(random, (DslmCredBuff *)&cred, &msgPtr);
553 ASSERT_EQ(ERR_INVALID_PARA, ret);
554 }
555 }
556
557 HWTEST_F(DslmTest, ParseMessage_case1, TestSize.Level0)
558 {
559 const char *message = "{\"message\":1,\"payload\":{\"version\":131072,\"challenge\":\"0102030405060708\"}}";
560 const char *except = "{\"version\":131072,\"challenge\":\"0102030405060708\"}";
561
562 uint32_t messageLen = strlen(message) + 1;
563 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
564
565 MessagePacket *packet = ParseMessage(&msg);
566 ASSERT_NE(nullptr, packet);
567
568 EXPECT_EQ(1U, packet->type);
569 EXPECT_STREQ(except, (const char *)packet->payload);
570
571 FreeMessagePacket(packet);
572 }
573
574 HWTEST_F(DslmTest, ParseMessage_case2, TestSize.Level0)
575 {
576 const char *message = "{\"mege\":1,\"payload\":{\"version\":131072,\"challenge\":\"0102030405060708\"}}";
577
578 uint32_t messageLen = strlen(message) + 1;
579 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
580
581 MessagePacket *packet = ParseMessage(&msg);
582 EXPECT_EQ(nullptr, packet);
583 FreeMessagePacket(packet);
584 }
585
586 HWTEST_F(DslmTest, ParseMessage_case3, TestSize.Level0)
587 {
588 const char *message = "{\"message\":1,\"pay\":{\"version\":131072,\"challenge\":\"0102030405060708\"}}";
589
590 uint32_t messageLen = strlen(message) + 1;
591 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
592
593 MessagePacket *packet = ParseMessage(&msg);
594 EXPECT_EQ(nullptr, packet);
595 FreeMessagePacket(packet);
596 }
597
598 HWTEST_F(DslmTest, ParseMessage_case4, TestSize.Level0)
599 {
600 const MessageBuff *buff = nullptr;
601 EXPECT_EQ(nullptr, ParseMessage(buff));
602 }
603
604 HWTEST_F(DslmTest, ParseMessage_case5, TestSize.Level0)
605 {
606 uint8_t *message = nullptr;
607 uint32_t messageLen = 0;
608 MessageBuff msg = {.length = messageLen, .buff = message};
609
610 EXPECT_EQ(nullptr, ParseMessage(&msg));
611 }
612
613 HWTEST_F(DslmTest, ParseMessage_case6, TestSize.Level0)
614 {
615 uint8_t message[] = {'1', '2'};
616 uint32_t messageLen = 2;
617 MessageBuff msg = {.length = messageLen, .buff = message};
618 EXPECT_EQ(nullptr, ParseMessage(&msg));
619 }
620
621 HWTEST_F(DslmTest, ParseMessage_case7, TestSize.Level0)
622 {
623 uint8_t message[] = {1, 2, 0};
624 uint32_t messageLen = 3;
625 MessageBuff msg = {.length = messageLen, .buff = message};
626 EXPECT_EQ(nullptr, ParseMessage(&msg));
627 }
628
629 HWTEST_F(DslmTest, ParseMessage_case8, TestSize.Level0)
630 {
631 MockMalloc mock;
632
633 // mock the malloc return nullptr
634 EXPECT_CALL(mock, UtilsMalloc).WillRepeatedly(Return(nullptr));
635
636 const char *message = "{\"message\":1,\"payload\":{\"version\":131072,\"challenge\":\"0102030405060708\"}}";
637
638 uint32_t messageLen = strlen(message) + 1;
639 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
640
641 MessagePacket *packet = ParseMessage(&msg);
642 ASSERT_EQ(nullptr, packet);
643 }
644
645 HWTEST_F(DslmTest, GetPkInfoListStr_case1, TestSize.Level0)
646 {
647 const char *udidStr = "device";
648 char *pkInfoListStr = nullptr;
649
650 int32_t result = GetPkInfoListStr(true, udidStr, &pkInfoListStr);
651 EXPECT_EQ(result, 0);
652 }
653
654 HWTEST_F(DslmTest, GetPkInfoListStr_case2, TestSize.Level0)
655 {
656 const char *udidStr = "device";
657 char *pkInfoListStr = nullptr;
658
659 MockMalloc mock;
660
661 // mock the malloc always return nullptr
662 EXPECT_CALL(mock, UtilsMalloc).WillOnce(Return(nullptr));
663
664 int32_t result = GetPkInfoListStr(true, udidStr, &pkInfoListStr);
665 EXPECT_EQ(result, ERR_MEMORY_ERR);
666 }
667
668 HWTEST_F(DslmTest, GetPkInfoListStr_case3, TestSize.Level0)
669 {
670 const char *udidStr = "device";
671 char *pkInfoListStr = nullptr;
672
673 MockStrcpy mock;
674 // mock the strcpy_s return a EINVAL
675 EXPECT_CALL(mock, strcpy_s).WillOnce(Return(EINVAL));
676
677 int32_t result = GetPkInfoListStr(true, udidStr, &pkInfoListStr);
678 EXPECT_EQ(result, ERR_MEMORY_ERR);
679 }
680
681 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case1, TestSize.Level0)
682 {
683 const char *message = "{\"version\":3351057,\"challenge\":\"010203040a0b0c0d\"}";
684
685 uint32_t messageLen = strlen(message) + 1;
686 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
687
688 RequestObject obj;
689 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
690
691 // 3351057 = 0x332211
692 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
693 EXPECT_EQ(0, ret);
694
695 EXPECT_EQ(0x332211U, obj.version);
696 EXPECT_EQ(0x0d0c0b0a04030201UL, obj.challenge);
697 EXPECT_EQ(0U, obj.arraySize);
698 }
699
700 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case2, TestSize.Level0)
701 {
702 const char *message = "{\"version\":3351057,\"challenge\":\"z\"}";
703
704 uint32_t messageLen = strlen(message) + 1;
705 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
706
707 RequestObject obj;
708 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
709
710 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
711 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
712 }
713
714 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case3, TestSize.Level0)
715 {
716 const char *message = "{\"version\":3351057,\"challenge\":1}";
717
718 uint32_t messageLen = strlen(message) + 1;
719 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
720
721 RequestObject obj;
722 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
723 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
724 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
725 }
726
727 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case4, TestSize.Level0)
728 {
729 const char *message = "{\"version\":3351057,\"challssenge\":\"z\"}";
730
731 uint32_t messageLen = strlen(message) + 1;
732 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
733
734 RequestObject obj;
735 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
736 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
737 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
738 }
739
740 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case5, TestSize.Level0)
741 {
742 const char *message = "{\"version\":3351057,\"challenge\":\"010203040a0b0c0d\",\"support\":[33,44,55]}";
743
744 uint32_t messageLen = strlen(message) + 1;
745 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
746
747 RequestObject obj;
748 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
749
750 // 3351057 = 0x332211
751 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
752 EXPECT_EQ(static_cast<int32_t>(0), ret);
753 EXPECT_EQ(0x332211U, obj.version);
754 EXPECT_EQ(0x0d0c0b0a04030201U, obj.challenge);
755 // add support
756 EXPECT_EQ(3U, obj.arraySize);
757 EXPECT_EQ(33U, obj.credArray[0]);
758 EXPECT_EQ(44U, obj.credArray[1]);
759 EXPECT_EQ(55U, obj.credArray[2]);
760 }
761
762 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case6, TestSize.Level0)
763 {
764 const char *message = "{\"version\":3351057,\"challenge\":\"010203040a0b0c0d\",\"support\":[]}";
765
766 uint32_t messageLen = strlen(message) + 1;
767 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
768
769 RequestObject obj;
770 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
771
772 // 3351057 = 0x332211
773 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
774 EXPECT_EQ(0, ret);
775 EXPECT_EQ(0x332211U, obj.version);
776 EXPECT_EQ(0x0d0c0b0a04030201U, obj.challenge);
777 // add support
778 EXPECT_EQ(0U, obj.arraySize);
779 }
780
781 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case7, TestSize.Level0)
782 {
783 const char *message = "{\"version\":3351057,\"challenge\":\"010203040a0b0c0d\",\"support\":[]}";
784 uint32_t messageLen = strlen(message) + 1;
785 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
786
787 RequestObject obj;
788 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
789
790 {
791 int32_t ret = ParseDeviceSecInfoRequest(nullptr, &obj);
792 EXPECT_EQ(ERR_INVALID_PARA, ret);
793 }
794
795 {
796 int32_t ret = ParseDeviceSecInfoRequest(&msg, nullptr);
797 EXPECT_EQ(ERR_INVALID_PARA, ret);
798 }
799
800 {
801 int32_t ret = ParseDeviceSecInfoRequest(nullptr, &obj);
802 EXPECT_EQ(ERR_INVALID_PARA, ret);
803 }
804
805 {
806 msg.buff = nullptr;
807 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
808 EXPECT_EQ(ERR_INVALID_PARA, ret);
809 }
810 }
811
812 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case8, TestSize.Level0)
813 {
814 const char *message = "{\"version\":3351057,\"challenge}";
815
816 uint32_t messageLen = strlen(message) + 1;
817 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
818
819 RequestObject obj;
820 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
821
822 // 3351057 = 0x332211
823 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
824 EXPECT_EQ(ERR_INVALID_PARA, ret);
825 }
826
827 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case1, TestSize.Level0)
828 {
829 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
830 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
831
832 uint32_t messageLen = strlen(message) + 1;
833 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
834
835 uint64_t challenge;
836 uint32_t version;
837 DslmCredBuff *cred = nullptr;
838
839 // 131072 = 0x020000
840 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
841 EXPECT_EQ(0, ret);
842 EXPECT_EQ(0x020000U, version);
843
844 EXPECT_EQ(0xE2C4D353EE211F3CUL, challenge);
845
846 const char *except = "JADE-AL00:87AD28D3B1B...";
847 EXPECT_NE(nullptr, cred);
848 EXPECT_EQ(2U, cred->type);
849 EXPECT_EQ(strlen(except), cred->credLen);
850 EXPECT_EQ(0, strncmp(except, (const char *)cred->credVal, cred->credLen));
851 DestroyDslmCred(cred);
852 }
853
854 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case2, TestSize.Level0)
855 {
856 const char *message = "{\"version\":3351057,\"challssenge\":\"z\"}";
857
858 uint32_t messageLen = strlen(message) + 1;
859 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
860
861 uint64_t challenge;
862 uint32_t ver;
863 DslmCredBuff *cred = nullptr;
864
865 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, &cred);
866 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
867 }
868
869 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case3, TestSize.Level0)
870 {
871 const char *message =
872 "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"infod\":\"JADE-AL00:87AD28D3B1B...\"}";
873
874 uint32_t messageLen = strlen(message) + 1;
875 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
876
877 uint64_t challenge;
878 uint32_t ver;
879 DslmCredBuff *cred = nullptr;
880
881 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, &cred);
882 EXPECT_EQ(ERR_NO_CRED, ret);
883 }
884
885 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case4, TestSize.Level0)
886 {
887 const char *message =
888 "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"infod\":\"JADE-AL00:87AD28D3B1B...\"}";
889
890 uint32_t messageLen = strlen(message) + 1;
891 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
892
893 uint64_t challenge;
894 uint32_t ver;
895 DslmCredBuff **cred = nullptr;
896
897 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, cred);
898 EXPECT_EQ(ERR_INVALID_PARA, ret);
899 }
900
901 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case5, TestSize.Level0)
902 {
903 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
904 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
905
906 uint32_t messageLen = strlen(message) + 1;
907 // msg has null buff
908 MessageBuff msg = {.length = messageLen, .buff = nullptr};
909
910 uint64_t challenge;
911 uint32_t version;
912 DslmCredBuff *cred = nullptr;
913
914 // 131072 = 0x020000
915 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
916 EXPECT_EQ(ERR_INVALID_PARA, ret);
917 }
918
919 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case6, TestSize.Level0)
920 {
921 int32_t ret;
922 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
923 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
924 uint32_t messageLen = strlen(message) + 1;
925 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
926
927 uint64_t challenge;
928 uint32_t ver;
929 DslmCredBuff cred;
930 memset_s(&cred, sizeof(DslmCredBuff), 0, sizeof(DslmCredBuff));
931 DslmCredBuff *credPtr = &cred;
932
933 {
934 // malformed inputs
935 ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, nullptr);
936 EXPECT_EQ(ERR_INVALID_PARA, ret);
937 }
938
939 {
940 // malformed inputs, credPtr != nullptr
941 ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, &credPtr);
942 EXPECT_EQ(ERR_INVALID_PARA, ret);
943 }
944
945 {
946 ret = ParseDeviceSecInfoResponse(nullptr, &challenge, &ver, &credPtr);
947 EXPECT_EQ(ERR_INVALID_PARA, ret);
948 }
949
950 {
951 ret = ParseDeviceSecInfoResponse(&msg, nullptr, &ver, &credPtr);
952 EXPECT_EQ(ERR_INVALID_PARA, ret);
953 }
954
955 {
956 ret = ParseDeviceSecInfoResponse(&msg, &challenge, nullptr, &credPtr);
957 EXPECT_EQ(ERR_INVALID_PARA, ret);
958 }
959 }
960
961 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case7, TestSize.Level0)
962 {
963 int32_t ret;
964 uint64_t challenge;
965 uint32_t version;
966 DslmCredBuff *cred = nullptr;
967
968 {
969 // malformed challenge
970 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2A\",\"type\":2,\"info\":"
971 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
972 uint32_t messageLen = strlen(message) + 1;
973 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
974
975 // 131072 = 0x020000
976 ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
977 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
978 }
979
980 {
981 // malformed json
982 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"infod}";
983 uint32_t messageLen = strlen(message) + 1;
984 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
985
986 ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
987 EXPECT_EQ(ERR_INVALID_PARA, ret);
988 }
989 }
990
991 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case8, TestSize.Level0)
992 {
993 // malformed info field
994 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
995 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4ux\"}";
996
997 uint32_t messageLen = strlen(message) + 1;
998 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
999
1000 uint64_t challenge;
1001 uint32_t version;
1002 DslmCredBuff *cred = nullptr;
1003
1004 // 131072 = 0x020000
1005 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
1006 EXPECT_EQ(ERR_NO_CRED, ret);
1007 }
1008
1009 HWTEST_F(DslmTest, RandomValue_case1, TestSize.Level0)
1010 {
1011 RandomValue rand1 = {0, {0}};
1012 (void)memset_s(&rand1, sizeof(RandomValue), 0, sizeof(RandomValue));
1013 GenerateRandom(&rand1, sizeof(uint64_t));
1014
1015 RandomValue rand2 = {0, {0}};
1016 (void)memset_s(&rand2, sizeof(RandomValue), 0, sizeof(RandomValue));
1017 GenerateRandom(&rand2, sizeof(uint64_t));
1018
1019 EXPECT_EQ(sizeof(uint64_t), rand1.length);
1020 EXPECT_EQ(sizeof(uint64_t), rand2.length);
1021
1022 EXPECT_GT(rand1.value[0] + rand1.value[1] + rand1.value[2] + rand1.value[3], 0);
1023 EXPECT_EQ(rand1.value[31] + rand1.value[30] + rand1.value[29] + rand1.value[28], 0);
1024 EXPECT_NE(0, memcmp(rand1.value, rand2.value, sizeof(uint64_t)));
1025 }
1026
1027 HWTEST_F(DslmTest, RandomValue_case2, TestSize.Level0)
1028 {
1029 RandomValue rand = {0, {0}};
1030 (void)memset_s(&rand, sizeof(RandomValue), 0, sizeof(RandomValue));
1031
1032 GenerateRandom(&rand, 1024);
1033 EXPECT_EQ(static_cast<uint32_t>(RANDOM_MAX_LEN), rand.length);
1034
1035 GenerateRandom(nullptr, 1024);
1036 }
1037
1038 HWTEST_F(DslmTest, GetMillisecondSinceBoot_case1, TestSize.Level0)
1039 {
1040 uint64_t tick = 100;
1041 uint64_t start = GetMillisecondSinceBoot();
1042 EXPECT_GT(start, 0U);
1043 this_thread::sleep_for(milliseconds(tick));
1044 uint64_t end = GetMillisecondSinceBoot();
1045 EXPECT_GT(end, 0U);
1046
1047 EXPECT_GT(end - start, tick - 25);
1048 EXPECT_LT(end - start, tick + 25);
1049 }
1050
1051 HWTEST_F(DslmTest, GetMillisecondSince1970_case1, TestSize.Level0)
1052 {
1053 uint64_t tick = 100;
1054 uint64_t start = GetMillisecondSince1970();
1055 EXPECT_GT(start, 0U);
1056 this_thread::sleep_for(milliseconds(tick));
1057 uint64_t end = GetMillisecondSince1970();
1058 EXPECT_GT(end, 0U);
1059
1060 EXPECT_GT(end - start, tick - 25);
1061 EXPECT_LT(end - start, tick + 25);
1062 }
1063
1064 HWTEST_F(DslmTest, GetDateTime_case1, TestSize.Level0)
1065 {
1066 {
1067 DateTime date;
1068 EXPECT_TRUE(GetDateTimeByMillisecondSince1970(GetMillisecondSince1970(), &date));
1069 }
1070 {
1071 DateTime date;
1072 EXPECT_TRUE(GetDateTimeByMillisecondSinceBoot(GetMillisecondSinceBoot(), &date));
1073 }
1074 }
1075
1076 HWTEST_F(DslmTest, InitDslmCredentialFunctions_case1, TestSize.Level0)
1077 {
1078 bool ret = InitDslmCredentialFunctions(NULL);
1079 EXPECT_EQ(false, ret);
1080 }
1081
1082 HWTEST_F(DslmTest, OhosDslmCred_case1, TestSize.Level0)
1083 {
1084 const DeviceIdentify identify = {DEVICE_ID_MAX_LEN, {0}};
1085 RequestObject object;
1086
1087 object.arraySize = 1;
1088 object.credArray[0] = CRED_TYPE_STANDARD;
1089 object.challenge = 0x1234567812345678;
1090 object.version = 0x112234;
1091
1092 DslmCredBuff *cred = nullptr;
1093
1094 int32_t ret = DefaultRequestDslmCred(&identify, &object, &cred);
1095
1096 DslmCredInfo info;
1097 (void)memset_s(&info, sizeof(DslmCredInfo), 0, sizeof(DslmCredInfo));
1098
1099 ret = DefaultVerifyDslmCred(&identify, object.challenge, cred, &info);
1100
1101 DestroyDslmCred(cred);
1102 }
1103
1104 HWTEST_F(DslmTest, OhosDslmCred_case2, TestSize.Level0)
1105 {
1106 const DeviceIdentify identify = {DEVICE_ID_MAX_LEN, {0}};
1107 RequestObject object;
1108
1109 object.arraySize = 1;
1110 object.credArray[0] = CRED_TYPE_STANDARD;
1111 object.challenge = 0x1234567812345678;
1112 object.version = 0x112234;
1113
1114 DslmCredBuff cred = {
1115 .type = (CredType)3000,
1116 .credLen = sizeof(CRED),
1117 .credVal = &CRED[0],
1118 };
1119
1120 DslmCredInfo info;
1121 (void)memset_s(&info, sizeof(DslmCredInfo), 0, sizeof(DslmCredInfo));
1122
1123 int32_t ret = DefaultVerifyDslmCred(&identify, object.challenge, &cred, &info);
1124 EXPECT_EQ(SUCCESS, ret);
1125 EXPECT_GE(info.credLevel, 1U);
1126 }
1127
1128 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case1, TestSize.Level0)
1129 {
1130 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g'}};
1131
1132 const RequestOption option = {
1133 .challenge = 0xffffffffffffffff,
1134 .timeout = 2,
1135 };
1136
1137 {
1138 uint32_t cookie = 1234;
1139 DslmRequestCallbackMock mockCallback;
1140 EXPECT_CALL(mockCallback, RequestCallback(_, _, _)).Times(Exactly(0));
1141 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
1142 EXPECT_EQ(static_cast<int32_t>(ret), ERR_MSG_NOT_INIT);
1143 }
1144
1145 {
1146 uint32_t cookie = 1234;
1147 DslmRequestCallbackMock mockCallback;
1148 EXPECT_CALL(mockCallback, RequestCallback(_, _, _)).Times(Exactly(0));
1149 int32_t ret = OnRequestDeviceSecLevelInfo(nullptr, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
1150 EXPECT_EQ(static_cast<int32_t>(ret), ERR_INVALID_PARA);
1151 }
1152
1153 {
1154 uint32_t cookie = 1234;
1155 DslmRequestCallbackMock mockCallback;
1156 EXPECT_CALL(mockCallback, RequestCallback(_, _, _)).Times(Exactly(0));
1157 int32_t ret = OnRequestDeviceSecLevelInfo(&device, nullptr, 0, cookie, DslmRequestCallbackMock::MockedCallback);
1158 EXPECT_EQ(static_cast<int32_t>(ret), ERR_INVALID_PARA);
1159 }
1160
1161 {
1162 uint32_t cookie = 5678;
1163 DslmMsgInterfaceMock mockMsg;
1164 DslmRequestCallbackMock mockCallback;
1165 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
1166 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
1167 EXPECT_CALL(mockMsg, GetDeviceOnlineStatus(_, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(false));
1168 EXPECT_CALL(mockCallback, RequestCallback(_, _, _)).Times(Exactly(0));
1169 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
1170 EXPECT_EQ(static_cast<int32_t>(ret), ERR_NOEXIST_DEVICE);
1171
1172 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(AtLeast(2));
1173 mockMsg.MakeMsgLoopback();
1174 mockMsg.MakeDeviceOnline(&device);
1175 BlockCheckDeviceStatus(&device, STATE_SUCCESS, 10000);
1176 mockMsg.MakeDeviceOffline(&device);
1177 }
1178 }
1179
1180 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case2, TestSize.Level0)
1181 {
1182 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g'}};
1183
1184 const RequestOption option = {
1185 .challenge = 0xffffffffffffffff,
1186 .timeout = 2,
1187 };
1188
1189 {
1190 uint32_t cookie = 0xabcd;
1191 DslmMsgInterfaceMock mockMsg;
1192 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
1193 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
1194 EXPECT_CALL(mockMsg, GetDeviceOnlineStatus(_, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(true));
1195
1196 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
1197 EXPECT_EQ(ret, 0);
1198 mockMsg.MakeDeviceOffline(&device);
1199 }
1200
1201 {
1202 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0, 'b', 'c', 'd', 'e', 'f', 'g'}};
1203 uint32_t cookie = 0xabcd;
1204 DslmMsgInterfaceMock mockMsg;
1205 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
1206 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
1207 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(Exactly(0));
1208 DslmRequestCallbackMock mockCallback;
__anon2fef06d30102(const DslmCallbackInfo *info) 1209 auto isRightLevel = [](const DslmCallbackInfo *info) { return info->level >= 1; };
1210 EXPECT_CALL(mockCallback, RequestCallback(cookie, 0, Truly(isRightLevel))).Times(Exactly(1));
1211
1212 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
1213 EXPECT_EQ(ret, 0);
1214 mockMsg.MakeDeviceOffline(&device);
1215 }
1216 }
1217
1218 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case3, TestSize.Level0)
1219 {
1220 constexpr uint32_t maxNotifySize = 64;
1221
1222 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a'}};
1223 const RequestOption option = {
1224 .challenge = 0xffabcdffffffffee,
1225 .timeout = 2,
1226 .extra = 0,
1227 };
1228
1229 DslmMsgInterfaceMock mockMsg;
1230 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
1231 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
1232 EXPECT_CALL(mockMsg, GetDeviceOnlineStatus(_, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(true));
__anon2fef06d30202(const uint8_t *message) 1233 auto isSendRequestOut = [](const uint8_t *message) {
1234 const char *prefix = "{\"message\":1,\"payload\":{\"version\":196608,\"challenge\":\"";
1235 const string msg = string(static_cast<const char *>(static_cast<const void *>(message)));
1236 EXPECT_EQ(msg.rfind(prefix, 0), 0U);
1237 return true;
1238 };
1239
1240 uint32_t cookie = 0x4567;
1241 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, Truly(isSendRequestOut), _)).Times(Exactly(1)).WillRepeatedly(Return(true));
1242
1243 DslmDeviceInfo *info = CreatOrGetDslmDeviceInfo(&device);
1244 ASSERT_NE(info, nullptr);
1245
1246 EXPECT_EQ(info->notifyListSize, 0U);
1247
1248 DslmRequestCallbackMock callback;
1249 EXPECT_CALL(callback, RequestCallback(cookie, Ne(0U), Ne(nullptr))).Times(Exactly(maxNotifySize));
1250 for (uint32_t i = 1; i <= maxNotifySize; i++) {
1251 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
1252 EXPECT_EQ(static_cast<uint32_t>(ret), 0U);
1253 EXPECT_EQ(info->notifyListSize, i);
1254 EXPECT_EQ(info->historyListSize, 0U);
1255 }
1256 for (uint32_t i = 1; i <= maxNotifySize; i++) {
1257 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
1258 EXPECT_EQ(static_cast<uint32_t>(ret), ERR_SA_BUSY);
1259 EXPECT_EQ(info->notifyListSize, maxNotifySize);
1260 EXPECT_EQ(info->historyListSize, 0U);
1261 }
1262 mockMsg.MakeDeviceOffline(&device);
1263
1264 EXPECT_EQ(info->notifyListSize, 0U);
1265 EXPECT_EQ(info->historyListSize, 30U); // 30 is the max history list size
1266 }
1267
1268 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case4, TestSize.Level0)
1269 {
1270 DslmMsgInterfaceMock mockMsg;
1271 DslmRequestCallbackMock mockCallback;
1272
1273 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
1274 EXPECT_CALL(mockMsg, GetDeviceOnlineStatus(_, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(true));
1275 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(true));
1276 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
1277
1278 mutex mtx;
1279 condition_variable cv;
1280 int32_t cnt = 0;
1281 const time_point<system_clock> start = system_clock::now();
1282 const int32_t reqTimes = 3;
1283
1284 uint32_t cookies[] = {0, 0x1234, 0x5678, 0xabcd};
1285 uint32_t timeouts[] = {0, 1, 3, 5};
1286
__anon2fef06d30302(uint32_t cookie) 1287 auto checkCookie = [&mtx, &cv, &cnt, &start, &cookies, &timeouts](uint32_t cookie) {
1288 unique_lock<mutex> lck(mtx);
1289 cnt++;
1290 cv.notify_one();
1291 time_point<system_clock> curr = system_clock::now();
1292 auto cost = duration_cast<seconds>(curr - start).count();
1293 EXPECT_EQ(cookie, cookies[cnt]);
1294 EXPECT_EQ(cost, timeouts[cnt]);
1295 return true;
1296 };
1297
1298 EXPECT_CALL(mockCallback, RequestCallback(Truly(checkCookie), ERR_TIMEOUT, _)).Times(Exactly(3));
1299
1300 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1301 RequestOption option;
1302 for (int i = 1; i <= reqTimes; i++) {
1303 option.timeout = timeouts[i];
1304 int32_t ret =
1305 OnRequestDeviceSecLevelInfo(&device, &option, i, cookies[i], DslmRequestCallbackMock::MockedCallback);
1306 EXPECT_EQ(static_cast<uint32_t>(ret), 0U);
1307 }
1308
1309 unique_lock<mutex> lck(mtx);
__anon2fef06d30402() 1310 cv.wait(lck, [&cnt]() { return (cnt == reqTimes); });
1311 mockMsg.MakeDeviceOffline(&device);
1312 }
1313
1314 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case5, TestSize.Level0)
1315 {
1316 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1317 const RequestOption option = {
1318 .challenge = 0xffabcdffffffffee,
1319 .timeout = 2,
1320 .extra = 0,
1321 };
1322 uint32_t cookie = 1234;
1323
1324 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, nullptr);
1325 EXPECT_EQ(ERR_INVALID_PARA, ret);
1326 }
1327
1328 HWTEST_F(DslmTest, OnPeerMsgRequestInfoReceived_case1, TestSize.Level0)
1329 {
1330 const char *input = "{\"version\":65536,\"challenge\":\"0102030405060708\"}";
1331 uint32_t len = strlen(input) + 1;
1332
1333 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'}};
1334
1335 (void)OnPeerMsgRequestInfoReceived(&device, (const uint8_t *)input, len);
1336
1337 int32_t ret = OnPeerMsgRequestInfoReceived(&device, nullptr, len);
1338 EXPECT_EQ(ERR_INVALID_PARA, ret);
1339
1340 len = 0;
1341 ret = OnPeerMsgRequestInfoReceived(&device, (const uint8_t *)input, len);
1342 EXPECT_EQ(ERR_INVALID_PARA, ret);
1343 }
1344
1345 HWTEST_F(DslmTest, OnPeerMsgRequestInfoReceived_case2, TestSize.Level0)
1346 {
1347 const DeviceIdentify *device = nullptr;
1348 const char *input = "{\"version\":65536,\"challenge\":\"0102030405060708\"}";
1349 uint32_t len = strlen(input) + 1;
1350
1351 int32_t ret = OnPeerMsgRequestInfoReceived(device, (const uint8_t *)input, len);
1352 EXPECT_EQ(ERR_INVALID_PARA, ret);
1353 }
1354
1355 HWTEST_F(DslmTest, OnPeerMsgResponseInfoReceived_case1, TestSize.Level0)
1356 {
1357 const char *input = "{\"version\":65536,\"type\":0,\"challenge\":\"EEFFFFFFFFCDABFF\",\"info\":"
1358 "\"MDAwMTAyMDMwNDA1MDYwNzA4MDkwQTBCMEMwRDBFMEYxMDExMTIxMzE0MTUxNkFBQkJDQ0RE\"}";
1359 uint32_t len = strlen(input) + 1;
1360
1361 DeviceIdentify device = {8, {'a', 'b', 'c', 'd', 'e', 'f', 'g'}};
1362
1363 int32_t ret = OnPeerMsgResponseInfoReceived(&device, (const uint8_t *)input, len);
1364 EXPECT_EQ(ERR_NOEXIST_DEVICE, static_cast<int32_t>(ret));
1365
1366 ret = OnPeerMsgResponseInfoReceived(&device, nullptr, len);
1367 EXPECT_EQ(ERR_INVALID_PARA, ret);
1368
1369 len = 0;
1370 ret = OnPeerMsgResponseInfoReceived(&device, (const uint8_t *)input, len);
1371 EXPECT_EQ(ERR_INVALID_PARA, ret);
1372 }
1373
1374 HWTEST_F(DslmTest, OnPeerMsgResponseInfoReceived_case2, TestSize.Level0)
1375 {
1376 const DeviceIdentify *device = nullptr;
1377 const char *input = "{\"version\":65536,\"challenge\":\"0102030405060708\"}";
1378 uint32_t len = strlen(input) + 1;
1379
1380 int32_t ret = OnPeerMsgResponseInfoReceived(device, (const uint8_t *)input, len);
1381 EXPECT_EQ(ERR_INVALID_PARA, ret);
1382 }
1383
1384 HWTEST_F(DslmTest, InitSelfDeviceSecureLevel_case1, TestSize.Level0)
1385 {
1386 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'}};
1387 DslmDeviceInfo *info = GetDslmDeviceInfo(&device);
1388 EXPECT_EQ(nullptr, info);
1389
1390 DslmMsgInterfaceMock mockMsg;
1391 mockMsg.MakeSelfDeviceId(&device);
1392 mockMsg.MakeMsgLoopback();
1393 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
1394 InitSelfDeviceSecureLevel();
1395
1396 info = GetDslmDeviceInfo(&device);
1397 ASSERT_NE(nullptr, info);
1398 EXPECT_GE(info->credInfo.credLevel, 1U);
1399 mockMsg.MakeDeviceOffline(&device);
1400 }
1401
1402 HWTEST_F(DslmTest, InitSelfDeviceSecureLevel_case2, TestSize.Level0)
1403 {
1404 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x'}};
1405
1406 DslmDeviceInfo *info = GetDslmDeviceInfo(&device);
1407 EXPECT_EQ(nullptr, info);
1408
1409 DslmMsgInterfaceMock mockMsg;
1410 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(Exactly(6));
1411 mockMsg.MakeDeviceOnline(&device);
1412
1413 info = GetDslmDeviceInfo(&device);
1414 ASSERT_NE(nullptr, info);
1415 EXPECT_EQ(1U, info->queryTimes);
1416 EXPECT_EQ(STATE_WAITING_CRED_RSP, info->machine.currState);
1417
1418 BlockCheckDeviceStatus(&device, STATE_SUCCESS, 5000);
1419 EXPECT_EQ(STATE_FAILED, info->machine.currState);
1420 EXPECT_LT(5U, info->queryTimes);
1421 mockMsg.MakeDeviceOffline(&device);
1422 }
1423
1424 HWTEST_F(DslmTest, InnerKitsTest_case1, TestSize.Level0)
1425 {
1426 DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
1427
1428 DeviceSecurityInfo *info = nullptr;
1429 int32_t ret = RequestDeviceSecurityInfo(&device, nullptr, &info);
1430 EXPECT_EQ(ret, 0);
1431 int32_t level = 0;
1432 ret = GetDeviceSecurityLevelValue(info, &level);
1433 FreeDeviceSecurityInfo(info);
1434 EXPECT_EQ(ret, 0);
1435 EXPECT_GE(level, 1);
1436 }
1437
1438 static int32_t g_cnt = 0;
1439 static mutex g_mtx;
1440 static condition_variable g_cv;
1441
TestDeviceSecurityInfoCallback(const DeviceIdentify * identify,struct DeviceSecurityInfo * info)1442 void TestDeviceSecurityInfoCallback(const DeviceIdentify *identify, struct DeviceSecurityInfo *info)
1443 {
1444 unique_lock<mutex> lck(g_mtx);
1445 int32_t level = 0;
1446 int32_t ret = GetDeviceSecurityLevelValue(info, &level);
1447 FreeDeviceSecurityInfo(info);
1448 EXPECT_EQ(ret, 0);
1449 EXPECT_GE(level, 1);
1450 g_cnt++;
1451 g_cv.notify_one();
1452 }
1453
1454 HWTEST_F(DslmTest, InnerKitsTest_case2, TestSize.Level0)
1455 {
1456 DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
1457
1458 g_cnt = 0;
1459 int ret = RequestDeviceSecurityInfoAsync(&device, nullptr, TestDeviceSecurityInfoCallback);
1460 EXPECT_EQ(ret, 0);
1461
1462 ret = RequestDeviceSecurityInfoAsync(&device, nullptr, TestDeviceSecurityInfoCallback);
1463 EXPECT_EQ(ret, 0);
1464
1465 ret = RequestDeviceSecurityInfoAsync(&device, nullptr, TestDeviceSecurityInfoCallback);
1466 EXPECT_EQ(ret, 0);
1467
1468 unique_lock<mutex> lck(g_mtx);
__anon2fef06d30502() 1469 g_cv.wait_for(lck, std::chrono::milliseconds(2000), []() { return (g_cnt == 3); });
1470 EXPECT_EQ(g_cnt, 3);
1471 }
1472
1473 HWTEST_F(DslmTest, InnerKitsTest_case3, TestSize.Level0)
1474 {
1475 DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
1476 (void)memset_s(device.identity, DEVICE_ID_MAX_LEN, 'F', DEVICE_ID_MAX_LEN);
1477 DeviceSecurityInfo *info = nullptr;
1478 int32_t ret = RequestDeviceSecurityInfo(&device, nullptr, &info);
1479 EXPECT_EQ(ret, ERR_NOEXIST_DEVICE);
1480 }
1481
1482 HWTEST_F(DslmTest, GetSupportedCredTypes_case1, TestSize.Level0)
1483 {
1484 int32_t ret = GetSupportedCredTypes(nullptr, 0);
1485 EXPECT_EQ(0, ret);
1486 }
1487
1488 /**
1489 * @tc.name: GetSupportedCredTypes_case2
1490 * @tc.desc: function GetSupportedCredTypes with malformed inputs
1491 * @tc.type: FUNC
1492 * @tc.require: issueNumber
1493 */
1494 HWTEST_F(DslmTest, GetSupportedCredTypes_case2, TestSize.Level0)
1495 {
1496 int32_t ret;
1497 CredType list[] = {CRED_TYPE_MINI, CRED_TYPE_SMALL, CRED_TYPE_STANDARD, CRED_TYPE_LARGE};
1498 ret = GetSupportedCredTypes(list, 2);
1499 EXPECT_EQ(2, ret);
1500
1501 ret = GetSupportedCredTypes(list, 0);
1502 EXPECT_EQ(0, ret);
1503 }
1504
1505 HWTEST_F(DslmTest, CreateDslmCred_case1, TestSize.Level0)
1506 {
1507 CredType type = CRED_TYPE_STANDARD;
1508
1509 EXPECT_EQ(nullptr, CreateDslmCred(type, 0, nullptr));
1510 }
1511
1512 HWTEST_F(DslmTest, CreateDslmCred_case2, TestSize.Level0)
1513 {
1514 uint8_t buff[BUFF_LEN];
1515 memset_s(buff, sizeof(buff), 'c', sizeof(buff));
1516 TlvCommon *ptr = (TlvCommon *)buff;
1517 ptr->tag = 0x110;
1518 ptr->len = PTR_LEN;
1519 CredType type = CRED_TYPE_STANDARD;
1520
1521 EXPECT_EQ(nullptr, CreateDslmCred(type, 0, buff));
1522
1523 EXPECT_EQ(nullptr, CreateDslmCred(type, MAX_CRED_LEN + 1, buff));
1524 }
1525
1526 HWTEST_F(DslmTest, CheckAndGenerateChallenge_case1, TestSize.Level0)
1527 {
1528 DslmDeviceInfo device;
1529 (void)memset_s(&device, sizeof(DslmDeviceInfo), 0, sizeof(DslmDeviceInfo));
1530
1531 {
1532 int32_t ret = CheckAndGenerateChallenge(nullptr);
1533 EXPECT_EQ(ERR_INVALID_PARA, ret);
1534 }
1535
1536 {
1537 int32_t ret = CheckAndGenerateChallenge(&device);
1538 EXPECT_EQ(SUCCESS, ret);
1539 }
1540 }
1541
1542 HWTEST_F(DslmTest, CheckAndGenerateChallenge_case2, TestSize.Level0)
1543 {
1544 DslmDeviceInfo device;
1545 (void)memset_s(&device, sizeof(DslmDeviceInfo), 0, sizeof(DslmDeviceInfo));
1546
1547 {
1548 device.nonceTimeStamp = 0xFFFFFFFFFFFFFFFF;
1549 int32_t ret = CheckAndGenerateChallenge(&device);
1550 EXPECT_EQ(SUCCESS, ret);
1551 }
1552
1553 {
1554 device.nonceTimeStamp = GetMillisecondSinceBoot();
1555 int32_t ret = CheckAndGenerateChallenge(&device);
1556 EXPECT_EQ(SUCCESS, ret);
1557 }
1558
1559 {
1560 device.nonceTimeStamp = GetMillisecondSinceBoot();
1561 device.nonce = 1;
1562 int32_t ret = CheckAndGenerateChallenge(&device);
1563 EXPECT_EQ(SUCCESS, ret);
1564 }
1565 }
1566
1567 HWTEST_F(DslmTest, SendDeviceInfoRequest_case1, TestSize.Level0)
1568 {
1569 DslmDeviceInfo *device = nullptr;
1570
1571 int32_t ret = SendDeviceInfoRequest(device);
1572 EXPECT_EQ(ERR_INVALID_PARA, ret);
1573 }
1574
1575 HWTEST_F(DslmTest, VerifyDeviceInfoResponse_case1, TestSize.Level0)
1576 {
1577 DslmDeviceInfo *device = nullptr;
1578
1579 int32_t ret = VerifyDeviceInfoResponse(device, NULL);
1580 EXPECT_EQ(ERR_INVALID_PARA, ret);
1581 }
1582
1583 HWTEST_F(DslmTest, VerifyDeviceInfoResponse_case2, TestSize.Level0)
1584 {
1585 MessageBuff msg = {.length = 0, .buff = nullptr};
1586 DslmDeviceInfo device;
1587 (void)memset_s(&device, sizeof(device), 0, sizeof(device));
1588
1589 int32_t ret = VerifyDeviceInfoResponse(&device, &msg);
1590 EXPECT_EQ(ERR_INVALID_PARA, ret);
1591
1592 ret = VerifyDeviceInfoResponse(&device, nullptr);
1593 EXPECT_EQ(ERR_INVALID_PARA, ret);
1594 }
1595
1596 HWTEST_F(DslmTest, VerifyDeviceInfoResponse_case3, TestSize.Level0)
1597 {
1598 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
1599 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
1600 uint32_t messageLen = strlen(message) + 1;
1601 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
1602
1603 DslmDeviceInfo device;
1604 (void)memset_s(&device, sizeof(device), 0, sizeof(device));
1605
1606 int32_t ret = VerifyDeviceInfoResponse(&device, &msg);
1607 EXPECT_EQ(ERR_CHALLENGE_ERR, ret);
1608 }
1609
1610 HWTEST_F(DslmTest, VerifyDeviceInfoResponse_case4, TestSize.Level0)
1611 {
1612 DslmDeviceInfo device;
1613 memset_s(&device, sizeof(DslmDeviceInfo), 0, sizeof(DslmDeviceInfo));
1614 device.nonce = 0xE2C4D353EE211F3C;
1615 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
1616 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
1617 uint32_t messageLen = strlen(message) + 1;
1618 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
1619
1620 {
1621 int32_t ret = VerifyDeviceInfoResponse(&device, &msg);
1622 EXPECT_EQ(ERR_CHALLENGE_ERR, ret);
1623 }
1624
1625 {
1626 device.nonceTimeStamp = 0xFFFFFFFFFFFFFFFF;
1627 int32_t ret = VerifyDeviceInfoResponse(&device, &msg);
1628 EXPECT_EQ(ERR_CHALLENGE_ERR, ret);
1629 }
1630 }
1631
1632 HWTEST_F(DslmTest, GetDslmDeviceInfo_case1, TestSize.Level0)
1633 {
1634 DeviceIdentify *device = nullptr;
1635
1636 EXPECT_EQ(nullptr, GetDslmDeviceInfo(device));
1637 }
1638
1639 HWTEST_F(DslmTest, CreatOrGetDslmDeviceInfo_case1, TestSize.Level0)
1640 {
1641 DeviceIdentify *device = nullptr;
1642
1643 EXPECT_EQ(nullptr, CreatOrGetDslmDeviceInfo(device));
1644 }
1645
1646 HWTEST_F(DslmTest, CreatOrGetDslmDeviceInfo_case2, TestSize.Level0)
1647 {
1648 DeviceIdentify device = {.length = DEVICE_ID_MAX_LEN - 1};
1649
1650 EXPECT_EQ(nullptr, CreatOrGetDslmDeviceInfo(&device));
1651 }
1652
1653 HWTEST_F(DslmTest, IsSameDevice_case1, TestSize.Level0)
1654 {
1655 DeviceIdentify *device_first = nullptr;
1656 DeviceIdentify device_second;
1657 (void)memset_s(&device_second, sizeof(device_second), 0, sizeof(device_second));
1658
1659 EXPECT_EQ(false, IsSameDevice(device_first, &device_second));
1660
1661 EXPECT_EQ(false, IsSameDevice(&device_second, nullptr));
1662 }
1663
1664 HWTEST_F(DslmTest, GetCurrentMachineState_case1, TestSize.Level0)
1665 {
1666 DslmDeviceInfo *info = nullptr;
1667 uint32_t ret = GetCurrentMachineState(info);
1668 EXPECT_EQ(STATE_FAILED, ret);
1669 }
1670
1671 HWTEST_F(DslmTest, OnMsgSendResultNotifier_case1, TestSize.Level0)
1672 {
1673 DeviceIdentify identify = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1674 uint64_t transNo = 0;
1675 uint32_t result = ERR_DEFAULT;
1676
1677 {
1678 uint32_t ret = OnMsgSendResultNotifier(&identify, transNo, result);
1679 EXPECT_EQ(SUCCESS, ret);
1680 }
1681
1682 {
1683 uint32_t ret = OnMsgSendResultNotifier(nullptr, transNo, result);
1684 EXPECT_EQ(SUCCESS, ret);
1685 }
1686 }
1687
1688 HWTEST_F(DslmTest, OnPeerStatusReceiver_case1, TestSize.Level0)
1689 {
1690 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1691 uint32_t status = 1234;
1692 uint32_t level = -1;
1693
1694 int32_t ret = OnPeerStatusReceiver(&device, status, level);
1695 EXPECT_EQ(SUCCESS, ret);
1696 }
1697
1698 HWTEST_F(DslmTest, InitDslmProcess_case1, TestSize.Level0)
1699 {
1700 EXPECT_EQ(false, InitDslmProcess());
1701 }
1702
1703 HWTEST_F(DslmTest, DeinitDslmProcess_case1, TestSize.Level0)
1704 {
1705 EXPECT_EQ(true, DeinitDslmProcess());
1706 }
1707
1708 // dslm_ohos_verify.c
1709 HWTEST_F(DslmTest, VerifyOhosDslmCred_case1, TestSize.Level0)
1710 {
1711 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1712 uint64_t challenge = 0x1234;
1713 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
1714 DslmCredBuff cred = {CRED_TYPE_STANDARD, 9, info};
1715 DslmCredInfo *credInfo = nullptr;
1716
1717 int32_t ret = VerifyOhosDslmCred(&device, challenge, &cred, credInfo);
1718 EXPECT_EQ(ERR_INVALID_PARA, ret);
1719 }
1720
1721 HWTEST_F(DslmTest, VerifyOhosDslmCred_case2, TestSize.Level0)
1722 {
1723 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1724 uint64_t challenge = 0x1234;
1725 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
1726 DslmCredBuff cred = {CRED_TYPE_LARGE, 9, info};
1727 DslmCredInfo credInfo;
1728 (void)memset_s(&credInfo, sizeof(DslmCredInfo), 0, sizeof(DslmCredInfo));
1729
1730 int32_t ret = VerifyOhosDslmCred(&device, challenge, &cred, &credInfo);
1731 EXPECT_EQ(ERR_INVALID_PARA, ret);
1732
1733 ret = VerifyOhosDslmCred(nullptr, challenge, &cred, &credInfo);
1734 EXPECT_EQ(ERR_INVALID_PARA, ret);
1735
1736 ret = VerifyOhosDslmCred(&device, challenge, nullptr, &credInfo);
1737 EXPECT_EQ(ERR_INVALID_PARA, ret);
1738 }
1739
1740 HWTEST_F(DslmTest, VerifyOhosDslmCred_case3, TestSize.Level0)
1741 {
1742 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1743 uint64_t challenge = 0x1234;
1744 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
1745 DslmCredBuff cred = {CRED_TYPE_SMALL, 9, info};
1746 DslmCredInfo credInfo;
1747 (void)memset_s(&credInfo, sizeof(DslmCredInfo), 0, sizeof(DslmCredInfo));
1748
1749 int32_t ret = VerifyOhosDslmCred(&device, challenge, &cred, &credInfo);
1750 EXPECT_EQ(ERR_PARSE_CLOUD_CRED_DATA, ret);
1751 }
1752
1753 // dslm_ohos_request.c
1754
1755 // 2nd param of GetCredFromCurrentDevice() is 0
1756 HWTEST_F(DslmTest, GetCredFromCurrentDevice_case1, TestSize.Level0)
1757 {
1758 char cred[] = "test";
1759 uint32_t len = 0;
1760
1761 int32_t ret = GetCredFromCurrentDevice(cred, len);
1762 EXPECT_EQ(ERR_INVALID_PARA, ret);
1763
1764 ret = GetCredFromCurrentDevice(nullptr, len);
1765 EXPECT_EQ(ERR_INVALID_PARA, ret);
1766 }
1767
1768 /**
1769 * @tc.name: GetPeerDeviceOnlineStatus_case1
1770 * @tc.desc: function GetPeerDeviceOnlineStatus when g_messenger is NULL
1771 * @tc.type: FUNC
1772 * @tc.require: issueNumber
1773 */
1774 HWTEST_F(DslmTest, GetPeerDeviceOnlineStatus_case1, TestSize.Level0)
1775 {
1776 EXPECT_EQ(false, GetPeerDeviceOnlineStatus(nullptr, nullptr));
1777 }
1778
1779 /**
1780 * @tc.name: GetPeerDeviceOnlineStatus_case2
1781 * @tc.desc: function GetPeerDeviceOnlineStatus with null input
1782 * @tc.type: FUNC
1783 * @tc.require: issueNumber
1784 */
1785 HWTEST_F(DslmTest, GetPeerDeviceOnlineStatus_case2, TestSize.Level0)
1786 {
1787 DslmMsgInterfaceMock mockMsg;
1788 EXPECT_EQ(false, GetPeerDeviceOnlineStatus(nullptr, nullptr));
1789 }
1790
1791 /**
1792 * @tc.name: GetSelfDevice_case1
1793 * @tc.desc: function GetSelfDevice with null input
1794 * @tc.type: FUNC
1795 * @tc.require: issueNumber
1796 */
1797 HWTEST_F(DslmTest, GetSelfDevice_case1, TestSize.Level0)
1798 {
1799 int32_t level = 0;
1800 const DeviceIdentify *identify = GetSelfDevice(&level);
1801 EXPECT_NE(nullptr, identify);
1802 }
1803
1804 /**
1805 * @tc.name: DeinitMessenger_case1
1806 * @tc.desc: function DeinitMessenger when g_messenger is NULL
1807 * @tc.type: FUNC
1808 * @tc.require: issueNumber
1809 */
1810 HWTEST_F(DslmTest, DeinitMessenger_case1, TestSize.Level0)
1811 {
1812 DslmMsgInterfaceMock mockMsg;
1813
1814 uint32_t ret = DeinitMessenger();
1815 EXPECT_EQ(SUCCESS, ret);
1816 }
1817
1818 /**
1819 * @tc.name: DeinitMessenger_case2
1820 * @tc.desc: function DeinitMessenger when g_messenger is not NULL
1821 * @tc.type: FUNC
1822 * @tc.require: issueNumber
1823 */
1824 HWTEST_F(DslmTest, DeinitMessenger_case2, TestSize.Level0)
1825 {
1826 uint32_t ret = DeinitMessenger();
1827 EXPECT_EQ(SUCCESS, ret);
1828 }
1829
1830 /**
1831 * @tc.name: SendMsgToDevice_case1
1832 * @tc.desc: function SendMsgToDevice when g_messenger is NULL
1833 * @tc.type: FUNC
1834 * @tc.require: issueNumber
1835 */
1836 HWTEST_F(DslmTest, SendMsgToDevice_case1, TestSize.Level0)
1837 {
1838 DslmMsgInterfaceMock mockMsg;
1839 uint64_t transNo = 0xfe;
1840 const DeviceIdentify devId = {DEVICE_ID_MAX_LEN, {0}};
1841 const uint8_t msg[] = {'1', '2'};
1842 uint32_t msgLen = 2;
1843
1844 mockMsg.~DslmMsgInterfaceMock();
1845 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(Exactly(0));
1846
1847 SendMsgToDevice(transNo, &devId, msg, msgLen);
1848 }
1849
1850 /**
1851 * @tc.name: CheckMessage_case1
1852 * @tc.desc: function CheckMessage when malformed input,
1853 * msg contains non ASCII item.
1854 * @tc.type: FUNC
1855 * @tc.require: issueNumber
1856 */
1857 HWTEST_F(DslmTest, CheckMessage_case1, TestSize.Level0)
1858 {
1859 const uint8_t msg[] = {'1', 0x8f, '\0'};
1860 uint32_t msgLen = 3;
1861
1862 EXPECT_EQ(false, CheckMessage(msg, msgLen));
1863 }
1864
1865 // just for coverage
1866 /**
1867 * @tc.name: FreeMessagePacket_case1
1868 * @tc.desc: function FreeMessagePacket when packet->payload is NULL
1869 * @tc.type: FUNC
1870 * @tc.require: issueNumber
1871 */
1872 HWTEST_F(DslmTest, FreeMessagePacket_case1, TestSize.Level0)
1873 {
1874 MessagePacket *packet = (MessagePacket *)MALLOC(sizeof(MessagePacket));
1875 ASSERT_NE(nullptr, packet);
1876 (void)memset_s(packet, sizeof(MessagePacket), 0, sizeof(MessagePacket));
1877
1878 FreeMessagePacket(packet);
1879 }
1880
1881 // just for coverage
1882 /**
1883 * @tc.name: FreeMessageBuff_case1
1884 * @tc.desc: function FreeMessageBuff when buff->buff is NULL
1885 * @tc.type: FUNC
1886 * @tc.require: issueNumber
1887 */
1888 HWTEST_F(DslmTest, FreeMessageBuff_case1, TestSize.Level0)
1889 {
1890 MessageBuff *buff = (MessageBuff *)MALLOC(sizeof(MessageBuff));
1891 ASSERT_NE(nullptr, buff);
1892 memset_s(buff, sizeof(MessageBuff), 0, sizeof(MessageBuff));
1893
1894 FreeMessageBuff(buff);
1895 FreeMessageBuff(nullptr);
1896 }
1897
dummyDump(const DslmDeviceInfo * info,int32_t fd)1898 static void dummyDump(const DslmDeviceInfo *info, int32_t fd)
1899 {
1900 (void)info;
1901 (void)fd;
1902 }
1903
1904 HWTEST_F(DslmTest, ForEachDeviceDump_case1, TestSize.Level0)
1905 {
1906 ForEachDeviceDump(nullptr, 0);
1907 ForEachDeviceDump(dummyDump, 0);
1908 InitDslmStateMachine(nullptr);
1909 ScheduleDslmStateMachine(nullptr, 0, nullptr);
1910 }
1911
1912 /**
1913 * @tc.name: DestroyDslmCred_case1
1914 * @tc.desc: function DestroyDslmCred with malformed inputs
1915 * @tc.type: FUNC
1916 * @tc.require: issueNumber
1917 */
1918 HWTEST_F(DslmTest, DestroyDslmCred_case1, TestSize.Level0)
1919 {
1920 DslmCredBuff *cred = (DslmCredBuff *)MALLOC(sizeof(DslmCredBuff));
1921 cred->type = (CredType)3;
1922 cred->credLen = 9;
1923 cred->credVal = nullptr;
1924 DestroyDslmCred(cred);
1925
1926 cred = nullptr;
1927 DestroyDslmCred(cred);
1928 EXPECT_EQ(nullptr, cred);
1929 }
1930
1931 /**
1932 * @tc.name: ReportHiEventAppInvoke_case1
1933 * @tc.desc: function ReportHiEventAppInvoke with malformed inputs
1934 * @tc.type: FUNC
1935 * @tc.require: issueNumber
1936 */
1937 HWTEST_F(DslmTest, ReportHiEventAppInvoke_case1, TestSize.Level0)
1938 {
1939 DslmDeviceInfo *info = (DslmDeviceInfo *)MALLOC(sizeof(DslmDeviceInfo));
1940 ASSERT_NE(nullptr, info);
1941 (void)memset_s(info, sizeof(DslmDeviceInfo), 0, sizeof(DslmDeviceInfo));
1942 info->lastRequestTime = 10U;
1943 ReportHiEventInfoSync(nullptr);
1944 ReportHiEventInfoSync(info);
1945 ReportHiEventAppInvoke(nullptr);
1946 EXPECT_NE(nullptr, info);
1947 FREE(info);
1948 info = nullptr;
1949 }
1950
1951 /**
1952 * @tc.name: GetDeviceSecurityLevelValue_case1
1953 * @tc.desc: function GetDeviceSecurityLevelValue with malformed inputs
1954 * @tc.type: FUNC
1955 * @tc.require: issueNumber
1956 */
1957 HWTEST_F(DslmTest, GetDeviceSecurityLevelValue_case1, TestSize.Level0)
1958 {
1959 int32_t ret;
1960 int32_t level = 0;
1961 DeviceSecurityInfo info = {.magicNum = 0xcd, .result = 0, .level = 0};
1962
1963 ret = GetDeviceSecurityLevelValue(nullptr, &level);
1964 EXPECT_EQ(ERR_INVALID_PARA, ret);
1965
1966 ret = GetDeviceSecurityLevelValue(&info, nullptr);
1967 EXPECT_EQ(ERR_INVALID_PARA, ret);
1968 }
1969
1970 /**
1971 * @tc.name: RequestDeviceSecurityInfoAsync_case1
1972 * @tc.desc: function RequestDeviceSecurityInfoAsync with malformed inputs
1973 * @tc.type: FUNC
1974 * @tc.require: issueNumber
1975 */
1976 HWTEST_F(DslmTest, RequestDeviceSecurityInfoAsync_case1, TestSize.Level0)
1977 {
1978 int32_t ret;
1979 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g'}};
1980 RequestOption opt = {.challenge = 0xcd, .timeout = 400, .extra = 0};
__anon2fef06d30602(const DeviceIdentify *identify, struct DeviceSecurityInfo *info) 1981 auto callback = [](const DeviceIdentify *identify, struct DeviceSecurityInfo *info) { return; };
1982
1983 ret = RequestDeviceSecurityInfoAsync(nullptr, &opt, callback);
1984 EXPECT_EQ(ERR_INVALID_PARA, ret);
1985
1986 ret = RequestDeviceSecurityInfoAsync(&device, &opt, nullptr);
1987 EXPECT_EQ(ERR_INVALID_PARA, ret);
1988
1989 // malformed option->timeout > MAX_KEEP_LEN
1990 ret = RequestDeviceSecurityInfoAsync(&device, &opt, callback);
1991 EXPECT_EQ(ERR_INVALID_PARA, ret);
1992 }
1993
1994 HWTEST_F(DslmTest, DslmDumper_case1, TestSize.Level0)
1995 {
1996 DslmDumper(-1);
1997 }
1998
1999 HWTEST_F(DslmTest, CreateQueueMsgData_case1, TestSize.Level0)
2000 {
2001 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g'}};
2002 const uint8_t msg[] = {'1', '2'};
2003 uint32_t msgLen = 0;
2004 uint32_t queueDataLen = 0;
2005
2006 EXPECT_EQ(nullptr, CreateQueueMsgData(&device, msg, msgLen, &queueDataLen));
2007
2008 EXPECT_EQ(nullptr, CreateQueueMsgData(nullptr, msg, msgLen, &queueDataLen));
2009
2010 EXPECT_EQ(nullptr, CreateQueueMsgData(&device, nullptr, msgLen, &queueDataLen));
2011
2012 msgLen = 2;
2013 EXPECT_EQ(nullptr, CreateQueueMsgData(&device, msg, msgLen, nullptr));
2014
2015 (void)CreateQueueMsgData(&device, msg, msgLen, &queueDataLen);
2016 }
2017
2018 HWTEST_F(DslmTest, CreateMessenger_case1, TestSize.Level0)
2019 {
2020 MessengerConfig config = {
2021 .pkgName = GetMessengerPackageName(),
2022 .primarySockName = GetMessengerPrimarySessionName(),
2023 .secondarySockName = GetMessengerSecondarySessionName(),
2024 .messageReceiver = OnPeerMsgReceived,
2025 .statusReceiver = OnPeerStatusReceiver,
2026 .sendResultNotifier = OnSendResultNotifier,
2027 };
2028
2029 WorkQueue *processQueue = CreateWorkQueue(MESSENGER_PROCESS_QUEUE_SIZE, MESSENGER_PROCESS_QUEUE_NAME);
2030
2031 bool result = InitDeviceSocketManager(processQueue, &config);
2032
2033 EXPECT_EQ(false, InitDeviceSocketManager(nullptr, &config));
2034
2035 EXPECT_EQ(false, InitDeviceSocketManager(processQueue, nullptr));
2036
2037 result = InitDeviceStatusManager(processQueue, config.pkgName, config.statusReceiver);
2038
2039 EXPECT_EQ(false, InitDeviceStatusManager(nullptr, config.pkgName, config.statusReceiver));
2040
2041 EXPECT_EQ(false, InitDeviceStatusManager(processQueue, nullptr, config.statusReceiver));
2042
2043 EXPECT_EQ(false, InitDeviceStatusManager(processQueue, config.pkgName, nullptr));
2044 }
2045
2046 HWTEST_F(DslmTest, MessengerSendMsgTo_case1, TestSize.Level0)
2047 {
2048 uint64_t transNo = 0xfe;
2049 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
2050 const uint8_t msg[] = {'1', '2'};
2051 uint32_t msgLen = 2;
2052
2053 MessengerSendMsgTo(transNo, &device, msg, msgLen);
2054
2055 MessengerSendMsgTo(transNo, nullptr, msg, msgLen);
2056
2057 MessengerSendMsgTo(transNo, &device, nullptr, msgLen);
2058 MessengerSendMsgTo(transNo, &device, msg, 0);
2059
2060 MessengerSendMsgTo(transNo, &device, msg, MSG_BUFF_MAX_LENGTH + 1);
2061 }
2062
2063 HWTEST_F(DslmTest, MessengerGetDeviceIdentifyByNetworkId_case1, TestSize.Level0)
2064 {
2065 const char networkId[] = {'1', '2'};
2066 DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
2067
2068 EXPECT_EQ(false, MessengerGetDeviceIdentifyByNetworkId(networkId, &device));
2069
2070 EXPECT_EQ(false, MessengerGetDeviceIdentifyByNetworkId(nullptr, &device));
2071
2072 EXPECT_EQ(false, MessengerGetDeviceIdentifyByNetworkId(networkId, nullptr));
2073 }
2074
2075 HWTEST_F(DslmTest, MessengerGetNetworkIdByDeviceIdentify_case1, TestSize.Level0)
2076 {
2077 char networkId[DEVICE_ID_MAX_LEN + 1] = {0};
2078 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
2079 uint32_t len = 0;
2080
2081 EXPECT_EQ(false, MessengerGetNetworkIdByDeviceIdentify(&device, networkId, len));
2082
2083 EXPECT_EQ(false, MessengerGetNetworkIdByDeviceIdentify(nullptr, networkId, len));
2084
2085 EXPECT_EQ(false, MessengerGetNetworkIdByDeviceIdentify(&device, nullptr, len));
2086 }
2087
2088 HWTEST_F(DslmTest, MessengerGetSelfDeviceIdentify_case1, TestSize.Level0)
2089 {
2090 DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
2091 EXPECT_EQ(false, MessengerGetSelfDeviceIdentify(nullptr, nullptr));
2092 EXPECT_EQ(false, MessengerGetSelfDeviceIdentify(&device, nullptr));
2093 }
2094 } // namespace DslmUnitTest
2095 } // namespace Security
2096 } // namespace OHOS