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