1 /*
2  * Copyright (C) 2021 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 "smp_tool.h"
17 
18 #include <string.h>
19 
20 #include "log.h"
21 #include "platform/include/allocator.h"
22 #include "smp.h"
23 #include "smp_common.h"
24 #include "smp_def.h"
25 #include "smp_send.h"
26 
27 static const uint8_t CONST_RB[CRYPT_AESCMAC_CONST_RB_LEN] = {
28     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87
29 };
30 
31 static const uint8_t MASTER_LEGACY_IO_TABLE[IO_COUNTS][IO_COUNTS] = {
32     {SMP_PAIR_METHOD_JUST_WORK,
33         SMP_PAIR_METHOD_JUST_WORK,
34         SMP_PAIR_METHOD_PASSKEY_ENTRY,
35         SMP_PAIR_METHOD_JUST_WORK,
36         SMP_PAIR_METHOD_PASSKEY_ENTRY},
37     {SMP_PAIR_METHOD_JUST_WORK,
38         SMP_PAIR_METHOD_JUST_WORK,
39         SMP_PAIR_METHOD_PASSKEY_ENTRY,
40         SMP_PAIR_METHOD_JUST_WORK,
41         SMP_PAIR_METHOD_PASSKEY_ENTRY},
42     {SMP_PAIR_METHOD_PASSKEY_DISPLAY,
43         SMP_PAIR_METHOD_PASSKEY_DISPLAY,
44         SMP_PAIR_METHOD_PASSKEY_ENTRY,
45         SMP_PAIR_METHOD_JUST_WORK,
46         SMP_PAIR_METHOD_PASSKEY_DISPLAY},
47     {SMP_PAIR_METHOD_JUST_WORK,
48         SMP_PAIR_METHOD_JUST_WORK,
49         SMP_PAIR_METHOD_JUST_WORK,
50         SMP_PAIR_METHOD_JUST_WORK,
51         SMP_PAIR_METHOD_JUST_WORK},
52     {SMP_PAIR_METHOD_PASSKEY_DISPLAY,
53         SMP_PAIR_METHOD_PASSKEY_DISPLAY,
54         SMP_PAIR_METHOD_PASSKEY_ENTRY,
55         SMP_PAIR_METHOD_JUST_WORK,
56         SMP_PAIR_METHOD_PASSKEY_DISPLAY},
57 };
58 
59 static const uint8_t SLAVE_LEGACY_IO_TABLE[IO_COUNTS][IO_COUNTS] = {
60     {SMP_PAIR_METHOD_JUST_WORK,
61         SMP_PAIR_METHOD_JUST_WORK,
62         SMP_PAIR_METHOD_PASSKEY_DISPLAY,
63         SMP_PAIR_METHOD_JUST_WORK,
64         SMP_PAIR_METHOD_PASSKEY_DISPLAY},
65     {SMP_PAIR_METHOD_JUST_WORK,
66         SMP_PAIR_METHOD_JUST_WORK,
67         SMP_PAIR_METHOD_PASSKEY_DISPLAY,
68         SMP_PAIR_METHOD_JUST_WORK,
69         SMP_PAIR_METHOD_PASSKEY_DISPLAY},
70     {SMP_PAIR_METHOD_PASSKEY_ENTRY,
71         SMP_PAIR_METHOD_PASSKEY_ENTRY,
72         SMP_PAIR_METHOD_PASSKEY_ENTRY,
73         SMP_PAIR_METHOD_JUST_WORK,
74         SMP_PAIR_METHOD_PASSKEY_ENTRY},
75     {SMP_PAIR_METHOD_JUST_WORK,
76         SMP_PAIR_METHOD_JUST_WORK,
77         SMP_PAIR_METHOD_JUST_WORK,
78         SMP_PAIR_METHOD_JUST_WORK,
79         SMP_PAIR_METHOD_JUST_WORK},
80     {SMP_PAIR_METHOD_PASSKEY_ENTRY,
81         SMP_PAIR_METHOD_PASSKEY_ENTRY,
82         SMP_PAIR_METHOD_PASSKEY_DISPLAY,
83         SMP_PAIR_METHOD_JUST_WORK,
84         SMP_PAIR_METHOD_PASSKEY_ENTRY},
85 };
86 
87 static const uint8_t MASTER_SCIO_TABLE[IO_COUNTS][IO_COUNTS] = {
88     {SMP_PAIR_METHOD_JUST_WORK,
89         SMP_PAIR_METHOD_JUST_WORK,
90         SMP_PAIR_METHOD_PASSKEY_ENTRY,
91         SMP_PAIR_METHOD_JUST_WORK,
92         SMP_PAIR_METHOD_PASSKEY_ENTRY},
93     {SMP_PAIR_METHOD_JUST_WORK,
94         SMP_PAIR_METHOD_NUMERIC_COMPARISON,
95         SMP_PAIR_METHOD_PASSKEY_ENTRY,
96         SMP_PAIR_METHOD_JUST_WORK,
97         SMP_PAIR_METHOD_NUMERIC_COMPARISON},
98     {SMP_PAIR_METHOD_PASSKEY_DISPLAY,
99         SMP_PAIR_METHOD_PASSKEY_DISPLAY,
100         SMP_PAIR_METHOD_PASSKEY_ENTRY,
101         SMP_PAIR_METHOD_JUST_WORK,
102         SMP_PAIR_METHOD_PASSKEY_DISPLAY},
103     {SMP_PAIR_METHOD_JUST_WORK,
104         SMP_PAIR_METHOD_JUST_WORK,
105         SMP_PAIR_METHOD_JUST_WORK,
106         SMP_PAIR_METHOD_JUST_WORK,
107         SMP_PAIR_METHOD_JUST_WORK},
108     {SMP_PAIR_METHOD_PASSKEY_DISPLAY,
109         SMP_PAIR_METHOD_NUMERIC_COMPARISON,
110         SMP_PAIR_METHOD_PASSKEY_ENTRY,
111         SMP_PAIR_METHOD_JUST_WORK,
112         SMP_PAIR_METHOD_NUMERIC_COMPARISON},
113 };
114 
115 static const uint8_t SLAVE_SCIO_TABLE[IO_COUNTS][IO_COUNTS] = {
116     {SMP_PAIR_METHOD_JUST_WORK,
117         SMP_PAIR_METHOD_JUST_WORK,
118         SMP_PAIR_METHOD_PASSKEY_DISPLAY,
119         SMP_PAIR_METHOD_JUST_WORK,
120         SMP_PAIR_METHOD_PASSKEY_DISPLAY},
121     {SMP_PAIR_METHOD_JUST_WORK,
122         SMP_PAIR_METHOD_NUMERIC_COMPARISON,
123         SMP_PAIR_METHOD_PASSKEY_DISPLAY,
124         SMP_PAIR_METHOD_JUST_WORK,
125         SMP_PAIR_METHOD_NUMERIC_COMPARISON},
126     {SMP_PAIR_METHOD_PASSKEY_ENTRY,
127         SMP_PAIR_METHOD_PASSKEY_ENTRY,
128         SMP_PAIR_METHOD_PASSKEY_ENTRY,
129         SMP_PAIR_METHOD_JUST_WORK,
130         SMP_PAIR_METHOD_PASSKEY_ENTRY},
131     {SMP_PAIR_METHOD_JUST_WORK,
132         SMP_PAIR_METHOD_JUST_WORK,
133         SMP_PAIR_METHOD_JUST_WORK,
134         SMP_PAIR_METHOD_JUST_WORK,
135         SMP_PAIR_METHOD_JUST_WORK},
136     {SMP_PAIR_METHOD_PASSKEY_ENTRY,
137         SMP_PAIR_METHOD_NUMERIC_COMPARISON,
138         SMP_PAIR_METHOD_PASSKEY_DISPLAY,
139         SMP_PAIR_METHOD_JUST_WORK,
140         SMP_PAIR_METHOD_NUMERIC_COMPARISON},
141 };
142 
143 #define CRYPT_XOR128_OUT_LEN 16
144 typedef struct {
145     const uint8_t *a;
146     const uint8_t *b;
147     uint8_t *out;
148 } SMP_CryptXor128Param;
149 
150 #define CRYPT_LEFTSHIFTONEBIT_OUT_LEN 16
151 typedef struct {
152     uint8_t *input;
153     uint8_t *output;
154 } SMP_CryptLeftShiftOneBitParam;
155 
156 #define CRYPT_PADDING_COUNT 16
157 typedef struct {
158     const uint8_t *lastb;
159     uint8_t *pad;
160     int length;
161 } SMP_CryptPaddingParam;
162 
163 typedef enum {
164     PAIR_REQ_0,
165     PAIR_REQ_1,
166     PAIR_REQ_2,
167     PAIR_REQ_3,
168     PAIR_REQ_4,
169     PAIR_REQ_5,
170     PAIR_REQ_6,
171 } SMP_PairReqInput;
172 
173 typedef enum {
174     PAIR_RES_0,
175     PAIR_RES_1,
176     PAIR_RES_2,
177     PAIR_RES_3,
178     PAIR_RES_4,
179     PAIR_RES_5,
180     PAIR_RES_6,
181 } SMP_PairResInput;
182 
183 static void SMP_CryptographicLeftShiftOneBit(SMP_CryptLeftShiftOneBitParam *param);
184 static void SMP_CryptographicXor128(SMP_CryptXor128Param *param);
185 static void SMP_CryptographicPadding(SMP_CryptPaddingParam *param);
186 static void SMP_CalcPairMethodLegacyPair(SMP_PairMng *mng);
187 static void SMP_CalcPairMethodScPair(SMP_PairMng *mng);
188 static void SMP_SetkeyDistCmdFlag(SMP_PairMng *mng);
189 static void SMP_WriteToRow(uint8_t *des, uint8_t desMax, uint8_t offset, const uint8_t *src, uint8_t length);
190 
SMP_WriteToRow(uint8_t * des,uint8_t desMax,uint8_t offset,const uint8_t * src,uint8_t length)191 static void SMP_WriteToRow(uint8_t *des, uint8_t desMax, uint8_t offset, const uint8_t *src, uint8_t length)
192 {
193     (void)memcpy_s(des + offset, desMax - offset, src, length);
194 }
195 
SMP_CryptographicLeftShiftOneBit(SMP_CryptLeftShiftOneBitParam * param)196 static void SMP_CryptographicLeftShiftOneBit(SMP_CryptLeftShiftOneBitParam *param)
197 {
198     int i;
199     uint8_t overflow = 0x00;
200 
201     for (i = CRYPT_LEFTSHIFTONEBIT_OUT_LEN - 1; i >= 0x00; i--) {
202         param->output[i] = (uint8_t)(param->input[i] << 0x01);
203         param->output[i] |= overflow;
204         overflow = (param->input[i] & 0x80) ? 0x01 : 0x00;
205     }
206 }
207 
SMP_CryptographicXor128(SMP_CryptXor128Param * param)208 static void SMP_CryptographicXor128(SMP_CryptXor128Param *param)
209 {
210     int i;
211 
212     for (i = 0x00; i < CRYPT_XOR128_OUT_LEN; i++) {
213         param->out[i] = param->a[i] ^ param->b[i];
214     }
215 }
216 
SMP_CryptographicPadding(SMP_CryptPaddingParam * param)217 static void SMP_CryptographicPadding(SMP_CryptPaddingParam *param)
218 {
219     int j;
220 
221     for (j = 0x00; j < CRYPT_PADDING_COUNT; j++) {
222         if (j < param->length) {
223             param->pad[j] = param->lastb[j];
224         } else if (j == param->length) {
225             param->pad[j] = 0x80;
226         } else {
227             param->pad[j] = 0x00;
228         }
229     }
230 }
231 
SMP_ConstituteC1Step1Param(uint8_t role,const uint8_t * random,uint8_t randomLen,SMP_CryptC1Step1Param * param)232 void SMP_ConstituteC1Step1Param(uint8_t role, const uint8_t *random, uint8_t randomLen, SMP_CryptC1Step1Param *param)
233 {
234     if (role == SMP_ROLE_MASTER) {
235         param->preq[PAIR_REQ_6] = SMP_CODE_PAIRING_REQ;
236         param->preq[PAIR_REQ_5] = SMP_GetPairMng()->local.pairParam.ioCapability;
237         param->preq[PAIR_REQ_4] = SMP_GetPairMng()->local.pairParam.oobDataFlag;
238         param->preq[PAIR_REQ_3] = SMP_GetPairMng()->local.pairParam.authReq;
239         param->preq[PAIR_REQ_2] = SMP_GetPairMng()->local.pairParam.maxEncKeySize;
240         param->preq[PAIR_REQ_1] = SMP_GetPairMng()->local.pairParam.initKeyDist;
241         param->preq[PAIR_REQ_0] = SMP_GetPairMng()->local.pairParam.respKeyDist;
242         param->pres[PAIR_RES_6] = SMP_CODE_PAIRING_RSP;
243         param->pres[PAIR_RES_5] = SMP_GetPairMng()->peer.pairParam.ioCapability;
244         param->pres[PAIR_RES_4] = SMP_GetPairMng()->peer.pairParam.oobDataFlag;
245         param->pres[PAIR_RES_3] = SMP_GetPairMng()->peer.pairParam.authReq;
246         param->pres[PAIR_RES_2] = SMP_GetPairMng()->peer.pairParam.maxEncKeySize;
247         param->pres[PAIR_RES_1] = SMP_GetPairMng()->peer.pairParam.initKeyDist;
248         param->pres[PAIR_RES_0] = SMP_GetPairMng()->peer.pairParam.respKeyDist;
249         param->iat = SMP_GetPairMng()->local.addr.type;
250         param->rat = SMP_GetPairMng()->peer.addr.type;
251     } else {
252         param->preq[PAIR_REQ_6] = SMP_CODE_PAIRING_REQ;
253         param->preq[PAIR_REQ_5] = SMP_GetPairMng()->peer.pairParam.ioCapability;
254         param->preq[PAIR_REQ_4] = SMP_GetPairMng()->peer.pairParam.oobDataFlag;
255         param->preq[PAIR_REQ_3] = SMP_GetPairMng()->peer.pairParam.authReq;
256         param->preq[PAIR_REQ_2] = SMP_GetPairMng()->peer.pairParam.maxEncKeySize;
257         param->preq[PAIR_REQ_1] = SMP_GetPairMng()->peer.pairParam.initKeyDist;
258         param->preq[PAIR_REQ_0] = SMP_GetPairMng()->peer.pairParam.respKeyDist;
259         param->pres[PAIR_RES_6] = SMP_CODE_PAIRING_RSP;
260         param->pres[PAIR_RES_5] = SMP_GetPairMng()->local.pairParam.ioCapability;
261         param->pres[PAIR_RES_4] = SMP_GetPairMng()->local.pairParam.oobDataFlag;
262         param->pres[PAIR_RES_3] = SMP_GetPairMng()->local.pairParam.authReq;
263         param->pres[PAIR_RES_2] = SMP_GetPairMng()->local.pairParam.maxEncKeySize;
264         param->pres[PAIR_RES_1] = SMP_GetPairMng()->local.pairParam.initKeyDist;
265         param->pres[PAIR_RES_0] = SMP_GetPairMng()->local.pairParam.respKeyDist;
266         param->iat = SMP_GetPairMng()->peer.addr.type;
267         param->rat = SMP_GetPairMng()->local.addr.type;
268     }
269     (void)memcpy_s(param->r, SMP_RANDOM_DATA_LEN, random, randomLen);
270 }
271 
SMP_CryptographicC1Step1(uint16_t step,SMP_CryptC1Step1Param * param)272 int SMP_CryptographicC1Step1(uint16_t step, SMP_CryptC1Step1Param *param)
273 {
274     HciLeEncryptParam encryptParam;
275     uint8_t iat, rat, p1[CRYPT_C1_P1_LEN];
276     uint8_t i;
277     LOG_DEBUG("%{public}s", __FUNCTION__);
278 
279     (void)memset_s(p1, CRYPT_C1_P1_LEN, 0x00, CRYPT_C1_P1_LEN);
280     (void)memset_s(param->output, CRYPT_C1_OUT_LEN, 0x00, CRYPT_C1_OUT_LEN);
281     iat = param->iat & 0x01;
282     rat = param->rat & 0x01;
283     uint8_t offset = 0x00;
284     SMP_WriteToRow(p1, CRYPT_C1_P1_LEN, offset, param->pres, SMP_CMD_PAIR_RSP_DATA_LEN);
285     offset += SMP_CMD_PAIR_RSP_DATA_LEN;
286     SMP_WriteToRow(p1, CRYPT_C1_P1_LEN, offset, param->preq, SMP_CMD_PAIR_REQ_DATA_LEN);
287     offset += SMP_CMD_PAIR_REQ_DATA_LEN;
288     p1[offset] = rat;
289     offset += sizeof(rat);
290     p1[offset] = iat;
291     for (i = 0x00; i < CRYPT_C1_OUT_LEN; i++) {
292         param->output[i] = param->r[i] ^ p1[i];
293     }
294     SMP_MemoryReverseCopy(encryptParam.key, SMP_GetPairMng()->TK, SMP_TK_LEN);
295     SMP_MemoryReverseCopy(encryptParam.plaintextData, param->output, sizeof(param->output));
296     int ret = SMP_SendLeEncryptCmd(&encryptParam, step, NULL, SMP_USING_HW_AES128_PAIR);
297     return ret;
298 }
299 
SMP_ConstituteC1Step2Param(const SMP_EncData * encData,uint8_t role,SMP_CryptC1Step2Param * param)300 int SMP_ConstituteC1Step2Param(const SMP_EncData *encData, uint8_t role, SMP_CryptC1Step2Param *param)
301 {
302     const HciLeEncryptReturnParam *returnParam = encData->encRetParam;
303     int ret = SMP_EncryptCompleteJudgeException(returnParam->status, role);
304     if (ret != SMP_SUCCESS) {
305         return ret;
306     }
307     SMP_MemoryReverseCopy(param->input, returnParam->encryptedData, sizeof(param->input));
308     if (role == SMP_ROLE_MASTER) {
309         (void)memcpy_s(param->ia, CRYPT_C1_IA_LEN, SMP_GetPairMng()->local.addr.addr, CRYPT_C1_IA_LEN);
310         (void)memcpy_s(param->ra, CRYPT_C1_RA_LEN, SMP_GetPairMng()->peer.addr.addr, CRYPT_C1_RA_LEN);
311     } else {
312         (void)memcpy_s(param->ia, CRYPT_C1_IA_LEN, SMP_GetPairMng()->peer.addr.addr, CRYPT_C1_IA_LEN);
313         (void)memcpy_s(param->ra, CRYPT_C1_RA_LEN, SMP_GetPairMng()->local.addr.addr, CRYPT_C1_RA_LEN);
314     }
315     return ret;
316 }
317 
SMP_CryptographicC1Step2(uint16_t step,SMP_CryptC1Step2Param * param)318 int SMP_CryptographicC1Step2(uint16_t step, SMP_CryptC1Step2Param *param)
319 {
320     HciLeEncryptParam encryptParam;
321     uint8_t p2[CRYPT_C1_P2_LEN], padding[CRYPT_C1_PADDING_LEN];
322     uint8_t i;
323     LOG_DEBUG("%{public}s", __FUNCTION__);
324 
325     (void)memset_s(p2, CRYPT_C1_P2_LEN, 0x00, CRYPT_C1_P2_LEN);
326     (void)memset_s(padding, CRYPT_C1_PADDING_LEN, 0x00, CRYPT_C1_PADDING_LEN);
327     (void)memset_s(param->output, CRYPT_C1_OUT_LEN, 0x00, CRYPT_C1_OUT_LEN);
328 
329     uint8_t offset = 0x00;
330     SMP_WriteToRow(p2, CRYPT_C1_P2_LEN, offset, padding, CRYPT_C1_PADDING_LEN);
331     offset += CRYPT_C1_PADDING_LEN;
332     SMP_WriteToRow(p2, CRYPT_C1_P2_LEN, offset, param->ia, CRYPT_C1_IA_LEN);
333     offset += CRYPT_C1_IA_LEN;
334     SMP_WriteToRow(p2, CRYPT_C1_P2_LEN, offset, param->ra, CRYPT_C1_RA_LEN);
335     for (i = 0x00; i < CRYPT_C1_OUT_LEN; i++) {
336         param->output[i] = param->input[i] ^ p2[i];
337     }
338     SMP_MemoryReverseCopy(encryptParam.key, SMP_GetPairMng()->TK, SMP_TK_LEN);
339     SMP_MemoryReverseCopy(encryptParam.plaintextData, param->output, sizeof(param->output));
340     int ret = SMP_SendLeEncryptCmd(&encryptParam, step, NULL, SMP_USING_HW_AES128_PAIR);
341     return ret;
342 }
343 
SMP_CryptographicS1(SMP_CryptS1Param * param)344 void SMP_CryptographicS1(SMP_CryptS1Param *param)
345 {
346     LOG_DEBUG("%{public}s", __FUNCTION__);
347     (void)memset_s(param->output, CRYPT_S1_OUT_LEN, 0x00, CRYPT_S1_OUT_LEN);
348     uint8_t offset = 0x00;
349     SMP_WriteToRow(param->output, CRYPT_S1_OUT_LEN, offset, &param->r1[SMP_RAND_NUM_LEN], SMP_RAND_NUM_LEN);
350     offset += SMP_RAND_NUM_LEN;
351     SMP_WriteToRow(param->output, CRYPT_S1_OUT_LEN, offset, &param->r2[SMP_RAND_NUM_LEN], SMP_RAND_NUM_LEN);
352 }
353 
SMP_ConstituteF4Param(bool isPasskey,SMP_CryptF4Param * param)354 void SMP_ConstituteF4Param(bool isPasskey, SMP_CryptF4Param *param)
355 {
356     uint32_t passkey = 0x00;
357     if (isPasskey) {
358         SMP_MemoryReverseCopy((uint8_t *)(&passkey), (SMP_GetPairMng()->TK + 0x0C), sizeof(uint32_t));
359         if (((uint32_t)(1 << SMP_GetPairMng()->scConfirmCheckCounter)) & passkey) {
360             param->Z[0x00] = 0x81;
361         } else {
362             param->Z[0x00] = 0x80;
363         }
364     } else {
365         param->Z[0x00] = 0x00;
366     }
367 }
368 
SMP_CryptographicF4(SMP_CryptF4Param * param)369 void SMP_CryptographicF4(SMP_CryptF4Param *param)
370 {
371     uint8_t offset = 0x00;
372     SMP_WriteToRow(param->output, CRYPT_F4_OUT_LEN, offset, param->U, SMP_PUBLICKEY_X_LEN);
373     offset += SMP_PUBLICKEY_X_LEN;
374     SMP_WriteToRow(param->output, CRYPT_F4_OUT_LEN, offset, param->V, SMP_PUBLICKEY_X_LEN);
375     offset += SMP_PUBLICKEY_X_LEN;
376     SMP_WriteToRow(param->output, CRYPT_F4_OUT_LEN, offset, param->Z, 0x01);
377 }
378 
SMP_ConstituteF5Param(uint8_t role,SMP_CryptF5Param * cryptF5Param)379 void SMP_ConstituteF5Param(uint8_t role, SMP_CryptF5Param *cryptF5Param)
380 {
381     if (role == SMP_ROLE_MASTER) {
382         cryptF5Param->A1[0x00] = SMP_GetPairMng()->local.addr.type;
383         cryptF5Param->A2[0x00] = SMP_GetPairMng()->peer.addr.type;
384         (void)memcpy_s(&cryptF5Param->A1[0x01], BT_ADDRESS_SIZE, SMP_GetPairMng()->local.addr.addr, BT_ADDRESS_SIZE);
385         (void)memcpy_s(&cryptF5Param->A2[0x01], BT_ADDRESS_SIZE, SMP_GetPairMng()->peer.addr.addr, BT_ADDRESS_SIZE);
386         (void)memcpy_s(cryptF5Param->N1, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->local.random, sizeof(cryptF5Param->N1));
387         (void)memcpy_s(cryptF5Param->N2, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->peer.random, sizeof(cryptF5Param->N2));
388     } else {
389         cryptF5Param->A1[0x00] = SMP_GetPairMng()->peer.addr.type;
390         cryptF5Param->A2[0x00] = SMP_GetPairMng()->local.addr.type;
391         (void)memcpy_s(&cryptF5Param->A1[0x01], BT_ADDRESS_SIZE, SMP_GetPairMng()->peer.addr.addr, BT_ADDRESS_SIZE);
392         (void)memcpy_s(&cryptF5Param->A2[0x01], BT_ADDRESS_SIZE, SMP_GetPairMng()->local.addr.addr, BT_ADDRESS_SIZE);
393         (void)memcpy_s(cryptF5Param->N1, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->peer.random, sizeof(cryptF5Param->N1));
394         (void)memcpy_s(cryptF5Param->N2, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->local.random, sizeof(cryptF5Param->N2));
395     }
396 }
397 
SMP_CryptographicF5(SMP_CryptF5Param * param)398 void SMP_CryptographicF5(SMP_CryptF5Param *param)
399 {
400     uint8_t keyID[CRYPT_F5_KEYID_LEN] = {0x62, 0x74, 0x6C, 0x65};
401     uint8_t counter0[0x01] = {0x00};
402     uint8_t length[CRYPT_F5_LENGTH_LEN] = {0x01, 0x00};
403     uint8_t offset = 0x00;
404     SMP_WriteToRow(param->output, CRYPT_F5_OUT_LEN, offset, counter0, 0x01);
405     offset += 0x01;
406     SMP_WriteToRow(param->output, CRYPT_F5_OUT_LEN, offset, keyID, CRYPT_F5_KEYID_LEN);
407     offset += CRYPT_F5_KEYID_LEN;
408     SMP_WriteToRow(param->output, CRYPT_F5_OUT_LEN, offset, param->N1, SMP_RANDOM_DATA_LEN);
409     offset += SMP_RANDOM_DATA_LEN;
410     SMP_WriteToRow(param->output, CRYPT_F5_OUT_LEN, offset, param->N2, SMP_RANDOM_DATA_LEN);
411     offset += SMP_RANDOM_DATA_LEN;
412     SMP_WriteToRow(param->output, CRYPT_F5_OUT_LEN, offset, param->A1, CRYPT_F5_A1_LEN);
413     offset += CRYPT_F5_A1_LEN;
414     SMP_WriteToRow(param->output, CRYPT_F5_OUT_LEN, offset, param->A2, CRYPT_F5_A2_LEN);
415     offset += CRYPT_F5_A2_LEN;
416     SMP_WriteToRow(param->output, CRYPT_F5_OUT_LEN, offset, length, CRYPT_F5_LENGTH_LEN);
417 }
418 
SMP_ConstituteF6Param(bool isCalculatePeer,SMP_CryptF6Param * cryptF6Param)419 void SMP_ConstituteF6Param(bool isCalculatePeer, SMP_CryptF6Param *cryptF6Param)
420 {
421     if (isCalculatePeer) {
422         int offset = 0;
423         cryptF6Param->IOcap[offset] = SMP_GetPairMng()->peer.pairParam.authReq;
424         offset += sizeof(SMP_GetPairMng()->peer.pairParam.authReq);
425         cryptF6Param->IOcap[offset] = SMP_GetPairMng()->peer.pairParam.oobDataFlag;
426         offset += sizeof(SMP_GetPairMng()->peer.pairParam.oobDataFlag);
427         cryptF6Param->IOcap[offset] = SMP_GetPairMng()->peer.pairParam.ioCapability;
428         cryptF6Param->A1[0] = SMP_GetPairMng()->peer.addr.type;
429         cryptF6Param->A2[0] = SMP_GetPairMng()->local.addr.type;
430         (void)memcpy_s(&cryptF6Param->A1[1], BT_ADDRESS_SIZE, SMP_GetPairMng()->peer.addr.addr, BT_ADDRESS_SIZE);
431         (void)memcpy_s(&cryptF6Param->A2[1], BT_ADDRESS_SIZE, SMP_GetPairMng()->local.addr.addr, BT_ADDRESS_SIZE);
432         (void)memset_s(cryptF6Param->R, SMP_RANDOM_DATA_LEN, 0x00, sizeof(cryptF6Param->R));
433         if (SMP_IsScOobPair(SMP_GetPairMng()->local.pairMethod)) {
434             (void)memcpy_s(cryptF6Param->R, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->local.oobRand, SMP_RANDOM_DATA_LEN);
435         }
436         (void)memcpy_s(cryptF6Param->N1, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->peer.random, sizeof(cryptF6Param->N1));
437         (void)memcpy_s(cryptF6Param->N2, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->local.random, sizeof(cryptF6Param->N2));
438     } else {
439         int offset = 0;
440         cryptF6Param->IOcap[offset] = SMP_GetPairMng()->local.pairParam.authReq;
441         offset += sizeof(SMP_GetPairMng()->local.pairParam.authReq);
442         cryptF6Param->IOcap[offset] = SMP_GetPairMng()->local.pairParam.oobDataFlag;
443         offset += sizeof(SMP_GetPairMng()->local.pairParam.oobDataFlag);
444         cryptF6Param->IOcap[offset] = SMP_GetPairMng()->local.pairParam.ioCapability;
445         cryptF6Param->A1[0] = SMP_GetPairMng()->local.addr.type;
446         cryptF6Param->A2[0] = SMP_GetPairMng()->peer.addr.type;
447         (void)memcpy_s(&cryptF6Param->A1[1], BT_ADDRESS_SIZE, SMP_GetPairMng()->local.addr.addr, BT_ADDRESS_SIZE);
448         (void)memcpy_s(&cryptF6Param->A2[1], BT_ADDRESS_SIZE, SMP_GetPairMng()->peer.addr.addr, BT_ADDRESS_SIZE);
449         (void)memset_s(cryptF6Param->R, SMP_RANDOM_DATA_LEN, 0x00, sizeof(cryptF6Param->R));
450         if (SMP_IsScOobPair(SMP_GetPairMng()->local.pairMethod)) {
451             (void)memcpy_s(cryptF6Param->R, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->peer.oobRand, SMP_RANDOM_DATA_LEN);
452         }
453         (void)memcpy_s(cryptF6Param->N1, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->local.random, sizeof(cryptF6Param->N1));
454         (void)memcpy_s(cryptF6Param->N2, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->peer.random, sizeof(cryptF6Param->N2));
455     }
456     if (SMP_IsPasskeyEntryPair(SMP_GetPairMng()->local.pairMethod)) {
457         (void)memcpy_s(cryptF6Param->R, SMP_RANDOM_DATA_LEN, SMP_GetPairMng()->TK, SMP_TK_LEN);
458     }
459 }
460 
SMP_CryptographicF6(SMP_CryptF6Param * param)461 void SMP_CryptographicF6(SMP_CryptF6Param *param)
462 {
463     uint8_t offset = 0x00;
464     SMP_WriteToRow(param->output, CRYPT_F6_OUT_LEN, offset, param->N1, SMP_RANDOM_DATA_LEN);
465     offset += SMP_RANDOM_DATA_LEN;
466     SMP_WriteToRow(param->output, CRYPT_F6_OUT_LEN, offset, param->N2, SMP_RANDOM_DATA_LEN);
467     offset += SMP_RANDOM_DATA_LEN;
468     SMP_WriteToRow(param->output, CRYPT_F6_OUT_LEN, offset, param->R, SMP_RANDOM_DATA_LEN);
469     offset += SMP_RANDOM_DATA_LEN;
470     SMP_WriteToRow(param->output, CRYPT_F6_OUT_LEN, offset, param->IOcap, CRYPT_F6_IO_LEN);
471     offset += CRYPT_F6_IO_LEN;
472     SMP_WriteToRow(param->output, CRYPT_F6_OUT_LEN, offset, param->A1, CRYPT_F6_A1_LEN);
473     offset += CRYPT_F6_A1_LEN;
474     SMP_WriteToRow(param->output, CRYPT_F6_OUT_LEN, offset, param->A2, CRYPT_F6_A2_LEN);
475 }
476 
SMP_CryptographicG2(SMP_CryptG2Param * param)477 void SMP_CryptographicG2(SMP_CryptG2Param *param)
478 {
479     uint8_t offset = 0x00;
480     SMP_WriteToRow(param->output, CRYPT_G2_OUT_LEN, offset, param->U, SMP_PUBLICKEY_X_LEN);
481     offset += SMP_PUBLICKEY_X_LEN;
482     SMP_WriteToRow(param->output, CRYPT_G2_OUT_LEN, offset, param->V, SMP_PUBLICKEY_X_LEN);
483     offset += SMP_PUBLICKEY_X_LEN;
484     SMP_WriteToRow(param->output, CRYPT_G2_OUT_LEN, offset, param->Y, SMP_RANDOM_DATA_LEN);
485 }
486 
SMP_CryptographicAesCmacStep1(SMP_CryptAesCmacStep1Param * param)487 void SMP_CryptographicAesCmacStep1(SMP_CryptAesCmacStep1Param *param)
488 {
489     uint8_t tmp[CRYPT_AESCMAC_TMP_LEN] = {0x00};
490     SMP_CryptXor128Param cryptXor128param = {
491         .a = tmp,
492         .b = CONST_RB,
493     };
494     SMP_CryptLeftShiftOneBitParam cryptLeftShiftOneBitParam;
495 
496     if ((param->input[0x00] & 0x80) == 0x00) {
497         cryptLeftShiftOneBitParam.input = param->input;
498         cryptLeftShiftOneBitParam.output = param->output1;
499         SMP_CryptographicLeftShiftOneBit(&cryptLeftShiftOneBitParam);
500     } else {
501         cryptLeftShiftOneBitParam.input = param->input;
502         cryptLeftShiftOneBitParam.output = tmp;
503         SMP_CryptographicLeftShiftOneBit(&cryptLeftShiftOneBitParam);
504         cryptXor128param.out = param->output1;
505         SMP_CryptographicXor128(&cryptXor128param);
506     }
507 
508     if ((param->output1[0x00] & 0x80) == 0x00) {
509         cryptLeftShiftOneBitParam.input = param->output1;
510         cryptLeftShiftOneBitParam.output = param->output2;
511         SMP_CryptographicLeftShiftOneBit(&cryptLeftShiftOneBitParam);
512     } else {
513         cryptLeftShiftOneBitParam.input = param->output1;
514         cryptLeftShiftOneBitParam.output = tmp;
515         SMP_CryptographicLeftShiftOneBit(&cryptLeftShiftOneBitParam);
516         cryptXor128param.out = param->output2;
517         SMP_CryptographicXor128(&cryptXor128param);
518     }
519 }
520 
SMP_CryptographicAesCmacStep2(SMP_CryptAesCmacStep2Param * param)521 void SMP_CryptographicAesCmacStep2(SMP_CryptAesCmacStep2Param *param)
522 {
523     uint8_t padded[CRYPT_AESCMAC_PADDED_LEN];
524     int flag;
525     SMP_CryptXor128Param cryptXor128param;
526     SMP_CryptPaddingParam cryptPaddingParam;
527 
528     (void)memset_s(padded, CRYPT_AESCMAC_PADDED_LEN, 0x00, CRYPT_AESCMAC_PADDED_LEN);
529 
530     param->n = (param->length + CRYPT_AESCMAC_NUM) / CRYPT_AESCMAC_TMP_LEN;
531 
532     if (param->n == 0x00) {
533         param->n = 0x01;
534         flag = 0x00;
535     } else {
536         if ((param->length % CRYPT_AESCMAC_TMP_LEN) == 0x00) {
537             flag = 0x01;
538         } else {
539             flag = 0x00;
540         }
541     }
542 
543     if (flag) {
544         cryptXor128param.a = &param->input3[CRYPT_AESCMAC_TMP_LEN * (param->n - 0x01)];
545         cryptXor128param.b = param->input1;
546         cryptXor128param.out = param->output;
547         SMP_CryptographicXor128(&cryptXor128param);
548     } else {
549         cryptPaddingParam.lastb = &param->input3[CRYPT_AESCMAC_TMP_LEN * (param->n - 0x01)];
550         cryptPaddingParam.pad = padded;
551         cryptPaddingParam.length = param->length % CRYPT_AESCMAC_TMP_LEN;
552         SMP_CryptographicPadding(&cryptPaddingParam);
553         cryptXor128param.a = padded;
554         cryptXor128param.b = param->input2;
555         cryptXor128param.out = param->output;
556         SMP_CryptographicXor128(&cryptXor128param);
557     }
558 }
559 
SMP_ConstituteAesCmacStep3Param(const SMP_EncData * encData,const uint8_t * data,uint8_t dataLen,SMP_CryptAesCmacStep3Param * param)560 void SMP_ConstituteAesCmacStep3Param(
561     const SMP_EncData *encData, const uint8_t *data, uint8_t dataLen, SMP_CryptAesCmacStep3Param *param)
562 {
563     SMP_CryptAesCmacStep1Param cryptAesCmacStep1Param;
564     SMP_CryptAesCmacStep2Param cryptAesCmacStep2Param;
565     SMP_MemoryReverseCopy(cryptAesCmacStep1Param.input, encData->encRetParam->encryptedData, CRYPT_AESCMAC_IN_LEN);
566     SMP_CryptographicAesCmacStep1(&cryptAesCmacStep1Param);
567     (void)memcpy_s(
568         cryptAesCmacStep2Param.input1, CRYPT_AESCMAC_IN_LEN, cryptAesCmacStep1Param.output1, CRYPT_AESCMAC_IN_LEN);
569     (void)memcpy_s(
570         cryptAesCmacStep2Param.input2, CRYPT_AESCMAC_IN_LEN, cryptAesCmacStep1Param.output2, CRYPT_AESCMAC_IN_LEN);
571     cryptAesCmacStep2Param.input3 = data;
572     cryptAesCmacStep2Param.length = dataLen;
573     SMP_CryptographicAesCmacStep2(&cryptAesCmacStep2Param);
574     param->message = data;
575     param->messageSize = dataLen;
576     (void)memcpy_s(
577         param->aesCmacOutput, SMP_AES_CMAC_OUTPUT_LEN, cryptAesCmacStep2Param.output, SMP_AES_CMAC_OUTPUT_LEN);
578     (void)memcpy_s(param->key, CRYPT_AESCMAC_KEY_LEN, encData->encCmd->key, CRYPT_AESCMAC_KEY_LEN);
579     param->n = cryptAesCmacStep2Param.n;
580     param->signCounter = 0x00;
581     param->isUsingHwAes128 = SMP_USING_HW_AES128_PAIR;
582 }
583 
SMP_CryptographicAesCmacStep3(const SMP_CryptAesCmacStep3Param * param)584 int SMP_CryptographicAesCmacStep3(const SMP_CryptAesCmacStep3Param *param)
585 {
586     int ret;
587     SMP_EncCmd *encCmd = SMP_AllocEncCmd();
588     if (encCmd == NULL) {
589         LOG_ERROR("%{public}s: Alloc error.", __FUNCTION__);
590         return SMP_ERR_OUT_OF_RES;
591     }
592     HciLeEncryptParam encryptParam;
593     SMP_CryptXor128Param cryptXor128param = {
594         .a = encCmd->X,
595         .out = encCmd->Y,
596     };
597 
598     (void)memset_s(encCmd->X, sizeof(encCmd->X), 0x00, sizeof(encCmd->X));
599     (void)memset_s(encCmd->Y, sizeof(encCmd->Y), 0x00, sizeof(encCmd->Y));
600     if (param->messageSize != 0) {
601         encCmd->length = param->messageSize;
602         encCmd->M = MEM_MALLOC.alloc(encCmd->length);
603         (void)memcpy_s(encCmd->M, param->messageSize, param->message, param->messageSize);
604     }
605     (void)memcpy_s(encCmd->M_last, sizeof(encCmd->M_last), param->aesCmacOutput, sizeof(encCmd->M_last));
606     (void)memcpy_s(encCmd->key, sizeof(encCmd->key), param->key, sizeof(encCmd->key));
607     encCmd->n = param->n;
608     encCmd->i = 0x00;
609     encCmd->signCounter = param->signCounter;
610 
611     if (encCmd->i < (encCmd->n - 0x01)) {
612         cryptXor128param.b = &param->message[CRYPT_AESCMAC_TMP_LEN * encCmd->i];
613         SMP_CryptographicXor128(&cryptXor128param);
614         encCmd->i++;
615 
616         (void)memcpy_s(encryptParam.key, sizeof(encryptParam.key), param->key, CRYPT_AESCMAC_KEY_LEN);
617         SMP_MemoryReverseCopy(encryptParam.plaintextData, encCmd->Y, CRYPT_AESCMAC_Y_LEN);
618         LOG_DEBUG("step %04X started.", param->stepA);
619         ret = SMP_SendLeEncryptCmd(&encryptParam, param->stepA, encCmd, param->isUsingHwAes128);
620     } else {
621         cryptXor128param.b = encCmd->M_last;
622         SMP_CryptographicXor128(&cryptXor128param);
623 
624         (void)memcpy_s(encryptParam.key, sizeof(encryptParam.key), param->key, CRYPT_AESCMAC_KEY_LEN);
625         SMP_MemoryReverseCopy(encryptParam.plaintextData, encCmd->Y, CRYPT_AESCMAC_Y_LEN);
626         LOG_DEBUG("step %04X started.", param->stepB);
627         ret = SMP_SendLeEncryptCmd(&encryptParam, param->stepB, encCmd, param->isUsingHwAes128);
628     }
629 
630     SMP_FreeEncCmd(encCmd);
631 
632     return ret;
633 }
634 
SMP_ConstituteAesCmacStep4Param(const SMP_EncData * encData,uint16_t stepA,uint16_t stepB,uint8_t role,SMP_CryptAesCmacStep4Param * param)635 int SMP_ConstituteAesCmacStep4Param(
636     const SMP_EncData *encData, uint16_t stepA, uint16_t stepB, uint8_t role, SMP_CryptAesCmacStep4Param *param)
637 {
638     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, role);
639     if (ret != SMP_SUCCESS) {
640         return ret;
641     }
642     param->stepA = stepA;
643     param->stepB = stepB;
644     param->pEncCmdData = encData->encCmd;
645     (void)memcpy_s(param->X, CRYPT_AESCMAC_X_LEN, encData->encRetParam->encryptedData, CRYPT_AESCMAC_X_LEN);
646     param->isUsingHwAes128 = SMP_USING_HW_AES128_PAIR;
647     return ret;
648 }
649 
SMP_CryptographicAesCmacStep4(SMP_CryptAesCmacStep4Param * param)650 int SMP_CryptographicAesCmacStep4(SMP_CryptAesCmacStep4Param *param)
651 {
652     int ret;
653     HciLeEncryptParam encryptParam;
654     SMP_CryptXor128Param cryptXor128param = {
655         .a = param->pEncCmdData->X,
656         .out = param->pEncCmdData->Y,
657     };
658 
659     SMP_MemoryReverseCopy(param->pEncCmdData->X, param->X, CRYPT_AESCMAC_X_LEN);
660 
661     if (param->pEncCmdData->i < (param->pEncCmdData->n - 0x01)) {
662         cryptXor128param.b = &param->pEncCmdData->M[CRYPT_AESCMAC_TMP_LEN * param->pEncCmdData->i];
663         SMP_CryptographicXor128(&cryptXor128param);
664         param->pEncCmdData->i++;
665 
666         (void)memcpy_s(encryptParam.key, sizeof(encryptParam.key), param->pEncCmdData->key, CRYPT_AESCMAC_KEY_LEN);
667         SMP_MemoryReverseCopy(encryptParam.plaintextData, param->pEncCmdData->Y, CRYPT_AESCMAC_Y_LEN);
668         LOG_DEBUG("step %04X started.", param->stepA);
669         ret = SMP_SendLeEncryptCmd(&encryptParam, param->stepA, param->pEncCmdData, param->isUsingHwAes128);
670     } else {
671         cryptXor128param.b = param->pEncCmdData->M_last;
672         SMP_CryptographicXor128(&cryptXor128param);
673 
674         (void)memcpy_s(encryptParam.key, sizeof(encryptParam.key), param->pEncCmdData->key, CRYPT_AESCMAC_KEY_LEN);
675         SMP_MemoryReverseCopy(encryptParam.plaintextData, param->pEncCmdData->Y, CRYPT_AESCMAC_Y_LEN);
676         LOG_DEBUG("step %04X started.", param->stepB);
677         ret = SMP_SendLeEncryptCmd(&encryptParam, param->stepB, param->pEncCmdData, param->isUsingHwAes128);
678     }
679     return ret;
680 }
681 
SMP_MemoryReverseCopy(uint8_t * dest,const uint8_t * source,uint16_t length)682 void SMP_MemoryReverseCopy(uint8_t *dest, const uint8_t *source, uint16_t length)
683 {
684     for (uint16_t temp = 0x00; temp < length; temp++) {
685         *(dest + temp) = *(source + length - 0x01 - temp);
686     }
687 }
688 
SMP_ReverseMemoryOrder(uint8_t * buf,uint16_t length)689 void SMP_ReverseMemoryOrder(uint8_t *buf, uint16_t length)
690 {
691     uint16_t index;
692 
693     for (index = 0x00; index < (length / 0x02); index++) {
694         uint8_t temp = buf[index];
695         buf[index] = buf[length - 0x01 - index];
696         buf[length - 0x01 - index] = temp;
697     }
698 }
699 
SMP_ClearPairState(SMP_PairMng * mng)700 void SMP_ClearPairState(SMP_PairMng *mng)
701 {
702     if (mng->alarm != NULL) {
703         AlarmCancel(mng->alarm);
704         AlarmDelete(mng->alarm);
705     }
706     (void)memset_s(mng, sizeof(SMP_PairMng), 0x00, sizeof(SMP_PairMng));
707 }
708 
SMP_CalculatePairType(SMP_PairMng * mng)709 void SMP_CalculatePairType(SMP_PairMng *mng)
710 {
711     LOG_INFO("%{public}s", __FUNCTION__);
712 
713     if ((mng->local.pairParam.authReq & SMP_AUTH_REQ_BIT_SC) && (mng->peer.pairParam.authReq & SMP_AUTH_REQ_BIT_SC)) {
714         mng->pairType = SMP_PAIR_TYPE_SECURE_CONNECTION;
715     } else {
716         mng->pairType = SMP_PAIR_TYPE_LEGACY;
717     }
718 }
719 
SMP_CalculateEncKeySize(SMP_PairMng * mng)720 void SMP_CalculateEncKeySize(SMP_PairMng *mng)
721 {
722     LOG_INFO("%{public}s", __FUNCTION__);
723 
724     if (mng->local.pairParam.maxEncKeySize >= mng->peer.pairParam.maxEncKeySize) {
725         mng->encKeySize = mng->peer.pairParam.maxEncKeySize;
726     } else {
727         mng->encKeySize = mng->local.pairParam.maxEncKeySize;
728     }
729 }
730 
SMP_CalculatePairMethod(SMP_PairMng * mng)731 void SMP_CalculatePairMethod(SMP_PairMng *mng)
732 {
733     LOG_INFO("%{public}s", __FUNCTION__);
734 
735     if (SMP_PAIR_TYPE_LEGACY == mng->pairType) {
736         SMP_CalcPairMethodLegacyPair(mng);
737     } else {
738         SMP_CalcPairMethodScPair(mng);
739     }
740 }
741 
SMP_CalculateKeyDistribution(SMP_PairMng * mng)742 void SMP_CalculateKeyDistribution(SMP_PairMng *mng)
743 {
744     LOG_INFO("%{public}s", __FUNCTION__);
745 
746     if (SMP_ROLE_MASTER == mng->role) {
747         mng->local.keyDist = mng->local.pairParam.initKeyDist & mng->peer.pairParam.initKeyDist;
748         mng->peer.keyDist = mng->local.pairParam.respKeyDist & mng->peer.pairParam.respKeyDist;
749     } else {
750         mng->local.keyDist = mng->local.pairParam.respKeyDist & mng->peer.pairParam.respKeyDist;
751         mng->peer.keyDist = mng->local.pairParam.initKeyDist & mng->peer.pairParam.initKeyDist;
752         mng->local.pairParam.initKeyDist = mng->peer.keyDist;
753         mng->local.pairParam.respKeyDist = mng->local.keyDist;
754     }
755 
756     if (SMP_PAIR_TYPE_SECURE_CONNECTION == mng->pairType) {
757         mng->local.keyDist = mng->local.keyDist & (~SMP_KEY_DIST_BIT_ENC_KEY);
758         mng->peer.keyDist = mng->peer.keyDist & (~SMP_KEY_DIST_BIT_ENC_KEY);
759     }
760 
761     SMP_SetkeyDistCmdFlag(mng);
762 }
763 
SMP_SetkeyDistCmdFlag(SMP_PairMng * mng)764 static void SMP_SetkeyDistCmdFlag(SMP_PairMng *mng)
765 {
766     mng->local.keyDistCmdFlag = 0x00;
767     mng->peer.keyDistCmdFlag = 0x00;
768 
769     if (mng->local.keyDist & SMP_KEY_DIST_BIT_ENC_KEY) {
770         mng->local.keyDistCmdFlag = mng->local.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_ENC_INFO;
771         mng->local.keyDistCmdFlag = mng->local.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_MASTER_IDENT;
772     }
773 
774     if (mng->local.keyDist & SMP_KEY_DIST_BIT_ID_KEY) {
775         mng->local.keyDistCmdFlag = mng->local.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_IDENT_INFO;
776         mng->local.keyDistCmdFlag = mng->local.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_IDENT_ADDR;
777     }
778 
779     if (mng->local.keyDist & SMP_KEY_DIST_BIT_SIGN_KEY) {
780         mng->local.keyDistCmdFlag = mng->local.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_SIGN_INFO;
781     }
782 
783     if (mng->peer.keyDist & SMP_KEY_DIST_BIT_ENC_KEY) {
784         mng->peer.keyDistCmdFlag = mng->peer.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_ENC_INFO;
785         mng->peer.keyDistCmdFlag = mng->peer.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_MASTER_IDENT;
786     }
787 
788     if (mng->peer.keyDist & SMP_KEY_DIST_BIT_ID_KEY) {
789         mng->peer.keyDistCmdFlag = mng->peer.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_IDENT_INFO;
790         mng->peer.keyDistCmdFlag = mng->peer.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_IDENT_ADDR;
791     }
792 
793     if (mng->peer.keyDist & SMP_KEY_DIST_BIT_SIGN_KEY) {
794         mng->peer.keyDistCmdFlag = mng->peer.keyDistCmdFlag | SMP_KEY_DIST_CMD_FLAG_BIT_SIGN_INFO;
795     }
796 }
797 
SMP_CalcPairMethodLegacyPair(SMP_PairMng * mng)798 static void SMP_CalcPairMethodLegacyPair(SMP_PairMng *mng)
799 {
800     if (mng->local.pairParam.oobDataFlag && mng->peer.pairParam.oobDataFlag) {
801         mng->local.pairMethod = SMP_PAIR_METHOD_OOB_LEGACY;
802         mng->peer.pairMethod = SMP_PAIR_METHOD_OOB_LEGACY;
803     } else if ((!(SMP_AUTH_REQ_BIT_MITM & mng->local.pairParam.authReq)) &&
804                (!(SMP_AUTH_REQ_BIT_MITM & mng->peer.pairParam.authReq))) {
805         mng->peer.pairMethod = SMP_PAIR_METHOD_JUST_WORK;
806         mng->local.pairMethod = SMP_PAIR_METHOD_JUST_WORK;
807     } else {
808         if (mng->role == SMP_ROLE_MASTER) {
809             mng->local.pairMethod =
810                 MASTER_LEGACY_IO_TABLE[mng->peer.pairParam.ioCapability][mng->local.pairParam.ioCapability];
811             mng->peer.pairMethod =
812                 SLAVE_LEGACY_IO_TABLE[mng->peer.pairParam.ioCapability][mng->local.pairParam.ioCapability];
813         } else {
814             mng->local.pairMethod =
815                 SLAVE_LEGACY_IO_TABLE[mng->local.pairParam.ioCapability][mng->peer.pairParam.ioCapability];
816             mng->peer.pairMethod =
817                 MASTER_LEGACY_IO_TABLE[mng->local.pairParam.ioCapability][mng->peer.pairParam.ioCapability];
818         }
819     }
820 }
821 
SMP_CalcPairMethodScPair(SMP_PairMng * mng)822 static void SMP_CalcPairMethodScPair(SMP_PairMng *mng)
823 {
824     if (mng->local.pairParam.oobDataFlag && mng->peer.pairParam.oobDataFlag) {
825         mng->local.pairMethod = SMP_PAIR_METHOD_OOB_SC_BOTH_SIDE_SEND_RECV;
826         mng->peer.pairMethod = SMP_PAIR_METHOD_OOB_SC_BOTH_SIDE_SEND_RECV;
827     } else if (mng->local.pairParam.oobDataFlag && (!mng->peer.pairParam.oobDataFlag)) {
828         mng->local.pairMethod = SMP_PAIR_METHOD_OOB_SC_LOCAL_RECV_PEER_SEND;
829         mng->peer.pairMethod = SMP_PAIR_METHOD_OOB_SC_LOCAL_RECV_PEER_SEND;
830     } else if ((!mng->local.pairParam.oobDataFlag) && mng->peer.pairParam.oobDataFlag) {
831         mng->local.pairMethod = SMP_PAIR_METHOD_OOB_SC_LOCAL_SEND_PEER_RECV;
832         mng->peer.pairMethod = SMP_PAIR_METHOD_OOB_SC_LOCAL_SEND_PEER_RECV;
833     } else if ((!(mng->local.pairParam.authReq & SMP_AUTH_REQ_BIT_MITM)) &&
834                (!(mng->peer.pairParam.authReq & SMP_AUTH_REQ_BIT_MITM))) {
835         mng->local.pairMethod = SMP_PAIR_METHOD_JUST_WORK;
836         mng->peer.pairMethod = SMP_PAIR_METHOD_JUST_WORK;
837     } else {
838         if (mng->role == SMP_ROLE_MASTER) {
839             mng->local.pairMethod =
840                 MASTER_SCIO_TABLE[mng->peer.pairParam.ioCapability][mng->local.pairParam.ioCapability];
841             mng->peer.pairMethod =
842                 SLAVE_SCIO_TABLE[mng->peer.pairParam.ioCapability][mng->local.pairParam.ioCapability];
843         } else {
844             mng->local.pairMethod =
845                 SLAVE_SCIO_TABLE[mng->local.pairParam.ioCapability][mng->peer.pairParam.ioCapability];
846             mng->peer.pairMethod =
847                 MASTER_SCIO_TABLE[mng->local.pairParam.ioCapability][mng->peer.pairParam.ioCapability];
848         }
849     }
850 }
851 
SMP_CheckRemotePairParam(const SMP_PairParam * pairParam,uint8_t * reason)852 int SMP_CheckRemotePairParam(const SMP_PairParam *pairParam, uint8_t *reason)
853 {
854     int ret = SMP_SUCCESS;
855 
856     if ((pairParam->maxEncKeySize < SMP_ENC_KEY_SIZE_MIN) || (pairParam->maxEncKeySize > SMP_ENC_KEY_SIZE_MAX)) {
857         *reason = SMP_PAIR_FAILED_ENC_KEY_SIZE;
858         ret = SMP_ERR_INVAL_PARAM;
859         return ret;
860     }
861 
862     return ret;
863 }
864 
SMP_ListCreate(FreeDataCb cb)865 List *SMP_ListCreate(FreeDataCb cb)
866 {
867     List *list = NULL;
868 
869     list = ListCreate(cb);
870 
871     return list;
872 }
873 
SMP_ListDelete(List * list)874 void SMP_ListDelete(List *list)
875 {
876     if (list != NULL) {
877         ListDelete(list);
878     }
879 }
880 
SMP_ListAddLast(List * list,void * data)881 void SMP_ListAddLast(List *list, void *data)
882 {
883     if (list != NULL) {
884         ListAddLast(list, data);
885     }
886 }
887 
SMP_ListRemoveNode(List * list,void * data)888 bool SMP_ListRemoveNode(List *list, void *data)
889 {
890     bool result = false;
891 
892     if (list != NULL) {
893         result = ListRemoveNode(list, data);
894     }
895 
896     return result;
897 }
898 
SMP_ListGetFirstNode(const List * list)899 ListNode *SMP_ListGetFirstNode(const List *list)
900 {
901     ListNode *listNode = NULL;
902 
903     if (list != NULL) {
904         listNode = ListGetFirstNode(list);
905     }
906 
907     return listNode;
908 }
909 
SMP_ListGetNodeData(const ListNode * node)910 void *SMP_ListGetNodeData(const ListNode *node)
911 {
912     void *data = NULL;
913 
914     if (node != NULL) {
915         data = ListGetNodeData(node);
916     }
917 
918     return data;
919 }
920 
SMP_IsScOobPair(uint8_t pairMethod)921 bool SMP_IsScOobPair(uint8_t pairMethod)
922 {
923     bool ret = false;
924 
925     if ((pairMethod == SMP_PAIR_METHOD_OOB_SC_BOTH_SIDE_SEND_RECV) ||
926         (pairMethod == SMP_PAIR_METHOD_OOB_SC_LOCAL_SEND_PEER_RECV) ||
927         (pairMethod == SMP_PAIR_METHOD_OOB_SC_LOCAL_RECV_PEER_SEND)) {
928         ret = true;
929     }
930 
931     return ret;
932 }
933 
SMP_IsPasskeyEntryPair(uint8_t pairMethod)934 bool SMP_IsPasskeyEntryPair(uint8_t pairMethod)
935 {
936     bool ret = false;
937 
938     if ((pairMethod == SMP_PAIR_METHOD_PASSKEY_ENTRY) || (pairMethod == SMP_PAIR_METHOD_PASSKEY_DISPLAY)) {
939         ret = true;
940     }
941 
942     return ret;
943 }
944 
SMP_IsJustworkOrNumericPair(uint8_t pairMethod)945 bool SMP_IsJustworkOrNumericPair(uint8_t pairMethod)
946 {
947     bool ret = false;
948 
949     if ((pairMethod == SMP_PAIR_METHOD_JUST_WORK) || (pairMethod == SMP_PAIR_METHOD_NUMERIC_COMPARISON)) {
950         ret = true;
951     }
952 
953     return ret;
954 }
955 
SMP_GetPublicKeyX(const uint8_t * pubKey,uint8_t * x,uint8_t length)956 void SMP_GetPublicKeyX(const uint8_t *pubKey, uint8_t *x, uint8_t length)
957 {
958     for (uint8_t index = 0x00; index < length; index++) {
959         x[index] = pubKey[length - 0x01 - index];
960     }
961 }
962 
SMP_LongTermKeyCopy(uint8_t * destLtk,const uint8_t * sourceLtk,uint8_t encKeySize)963 void SMP_LongTermKeyCopy(uint8_t *destLtk, const uint8_t *sourceLtk, uint8_t encKeySize)
964 {
965     if (destLtk != sourceLtk) {
966         (void)memcpy_s(destLtk, SMP_LTK_LEN, sourceLtk, SMP_LTK_LEN);
967     }
968 
969     if (encKeySize < SMP_LTK_LEN) {
970         (void)memset_s(destLtk + encKeySize, (SMP_LTK_LEN - encKeySize), 0x00, (SMP_LTK_LEN - encKeySize));
971     }
972 }
973