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_sc_accepter.h"
17 
18 #include <string.h>
19 
20 #include "log.h"
21 #include "smp.h"
22 #include "smp_cmd.h"
23 #include "smp_common.h"
24 #include "smp_send.h"
25 #include "smp_tool.h"
26 
27 static const uint8_t SALT[SMP_ENCRYPT_KEY_LEN] = {
28     0x6C, 0x88, 0x83, 0x91, 0xAA, 0xF5, 0xA5, 0x38, 0x60, 0x37, 0x0B, 0xDB, 0x5A, 0x60, 0x83, 0xBE
29 };  // The key of an encryption algorithm.
30 
SMP_ScPairJustworkOrNumericSlaveStep1(const SMP_StepParam * param)31 void SMP_ScPairJustworkOrNumericSlaveStep1(const SMP_StepParam *param)
32 {
33     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
34         return;
35     }
36     LOG_DEBUG("%{public}s", __FUNCTION__);
37     AlarmCancel(SMP_GetPairMng()->alarm);
38     (void)memcpy_s(SMP_GetPairMng()->peer.publicKey, SMP_PUBLICKEY_LEN, (uint8_t *)param->data, SMP_PUBLICKEY_LEN);
39     LOG_DEBUG("SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_2 started.");
40     SMP_GetPairMng()->step = SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_2;
41     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
42     int ret = HCI_LeReadLocalP256PublicKey();
43     if (ret != SMP_SUCCESS) {
44         LOG_ERROR("HCI_LeReadLocalP256PublicKey failed.");
45         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
46             SMP_PAIR_STATUS_FAILED,
47             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
48             SMP_GetPairMng()->alarm);
49     }
50 }
51 
SMP_ScPairJustworkOrNumericSlaveStep2(const SMP_StepParam * param)52 void SMP_ScPairJustworkOrNumericSlaveStep2(const SMP_StepParam *param)
53 {
54     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
55         return;
56     }
57     HciLeGenerateDHKeyParam DHKeyParam;
58     const HciLeReadLocalP256PublicKeyCompleteEventParam *eventParam =
59         (HciLeReadLocalP256PublicKeyCompleteEventParam *)param->data;
60 
61     LOG_DEBUG("%{public}s", __FUNCTION__);
62     (void)memcpy_s(
63         SMP_GetPairMng()->local.publicKey, SMP_PUBLICKEY_LEN, eventParam->localP256PublicKey, SMP_PUBLICKEY_LEN);
64     LOG_DEBUG("SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_3 started.");
65     SMP_GetPairMng()->step = SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_3;
66     (void)memcpy_s(
67         DHKeyParam.remoteP256PublicKey, SMP_PUBLICKEY_LEN, SMP_GetPairMng()->peer.publicKey, SMP_PUBLICKEY_LEN);
68     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
69     int ret = HCI_LeGenerateDHKey(&DHKeyParam);
70     if (ret != SMP_SUCCESS) {
71         LOG_ERROR("HCI_LeGenerateDHKey failed.");
72         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
73             SMP_PAIR_STATUS_FAILED,
74             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
75             SMP_GetPairMng()->alarm);
76     }
77 }
78 
SMP_ScPairJustworkOrNumericSlaveStep3(const SMP_StepParam * param)79 void SMP_ScPairJustworkOrNumericSlaveStep3(const SMP_StepParam *param)
80 {
81     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
82         return;
83     }
84     const HciLeGenerateDHKeyCompleteEventParam *eventParam = (HciLeGenerateDHKeyCompleteEventParam *)param->data;
85 
86     LOG_DEBUG("%{public}s", __FUNCTION__);
87     SMP_MemoryReverseCopy(SMP_GetPairMng()->DHKey, eventParam->DHKey, SMP_DHKEY_LEN);
88     int ret =
89         SMP_SendPairingPublicKey(SMP_GetPairMng()->handle, SMP_GetPairMng()->local.publicKey, SMP_SendDataCallback);
90     if (ret != SMP_SUCCESS) {
91         LOG_ERROR("Send pairing public key failed.");
92         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
93             SMP_PAIR_STATUS_FAILED,
94             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
95             SMP_GetPairMng()->alarm);
96     } else {
97         LOG_DEBUG("SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_4 started.");
98         ret = SMP_SendHciLeRandCmd(SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_4);
99         if (ret != SMP_SUCCESS) {
100             SMP_GeneratePairResult(
101                 SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
102         }
103     }
104 }
105 
SMP_ScPairJustworkOrNumericSlaveStep4(const SMP_StepParam * param)106 void SMP_ScPairJustworkOrNumericSlaveStep4(const SMP_StepParam *param)
107 {
108     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
109         return;
110     }
111     const HciLeRandReturnParam *returnParam = (HciLeRandReturnParam *)param->data;
112 
113     LOG_DEBUG("%{public}s", __FUNCTION__);
114     (void)memcpy_s(SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN, returnParam->randomNumber, SMP_RAND_NUM_LEN);
115     LOG_DEBUG("SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_5 started.");
116     int ret = SMP_SendHciLeRandCmd(SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_5);
117     if (ret != SMP_SUCCESS) {
118         SMP_GeneratePairResult(
119             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
120     }
121 }
122 
SMP_ScPairJustworkOrNumericSlaveStep5(const SMP_StepParam * param)123 void SMP_ScPairJustworkOrNumericSlaveStep5(const SMP_StepParam *param)
124 {
125     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
126         return;
127     }
128     HciLeEncryptParam encryptParam;
129     uint8_t cryptAesCmacZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
130     const HciLeRandReturnParam *returnParam = (HciLeRandReturnParam *)param->data;
131 
132     LOG_DEBUG("%{public}s", __FUNCTION__);
133     (void)memcpy_s(SMP_GetPairMng()->local.random + SMP_RAND_NUM_LEN,
134         SMP_RAND_NUM_LEN,
135         returnParam->randomNumber,
136         SMP_RAND_NUM_LEN);
137     LOG_DEBUG("SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_6 started");
138     SMP_MemoryReverseCopy(encryptParam.key, SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN);
139     (void)memcpy_s(encryptParam.plaintextData, sizeof(encryptParam.plaintextData), cryptAesCmacZ, CRYPT_AESCMAC_Z_LEN);
140     int ret =
141         SMP_SendLeEncryptCmd(&encryptParam, SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_6, NULL, SMP_USING_HW_AES128_PAIR);
142     if (ret != SMP_SUCCESS) {
143         SMP_GeneratePairResult(
144             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
145     }
146     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
147 }
148 
SMP_ScPairJustworkOrNumericSlaveStep6(const SMP_StepParam * param)149 void SMP_ScPairJustworkOrNumericSlaveStep6(const SMP_StepParam *param)
150 {
151     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
152         return;
153     }
154     SMP_EncData *encData = (SMP_EncData *)param->data;
155     SMP_CryptF4Param cryptF4Param;
156     bool isPasskey = false;
157     LOG_DEBUG("%{public}s", __FUNCTION__);
158     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
159     if (ret != SMP_SUCCESS) {
160         return;
161     }
162     SMP_GetPublicKeyX(SMP_GetPairMng()->local.publicKey, cryptF4Param.U, sizeof(cryptF4Param.U));
163     SMP_GetPublicKeyX(SMP_GetPairMng()->peer.publicKey, cryptF4Param.V, sizeof(cryptF4Param.V));
164     SMP_ConstituteF4Param(isPasskey, &cryptF4Param);
165     SMP_CryptographicF4(&cryptF4Param);
166     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
167     SMP_ConstituteAesCmacStep3Param(encData, cryptF4Param.output, CRYPT_F4_OUT_LEN, &cryptAesCmacStep3Param);
168     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_7;
169     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_8;
170     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
171     if (ret != SMP_SUCCESS) {
172         SMP_GeneratePairResult(
173             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
174     }
175     (void)memset_s(cryptAesCmacStep3Param.key, CRYPT_AESCMAC_KEY_LEN, 0x00, CRYPT_AESCMAC_KEY_LEN);
176 }
177 
SMP_ScPairJustworkOrNumericSlaveStep7(const SMP_StepParam * param)178 void SMP_ScPairJustworkOrNumericSlaveStep7(const SMP_StepParam *param)
179 {
180     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
181         return;
182     }
183     SMP_EncData *encData = (SMP_EncData *)param->data;
184     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
185     LOG_DEBUG("%{public}s", __FUNCTION__);
186     int ret = SMP_ConstituteAesCmacStep4Param(encData,
187         SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_7,
188         SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_8,
189         SMP_ROLE_SLAVE,
190         &cryptAesCmacStep4Param);
191     if (!ret) {
192         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
193     }
194     if (ret != SMP_SUCCESS) {
195         SMP_GeneratePairResult(
196             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
197     }
198 }
199 
SMP_ScPairJustworkOrNumericSlaveStep8(const SMP_StepParam * param)200 void SMP_ScPairJustworkOrNumericSlaveStep8(const SMP_StepParam *param)
201 {
202     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
203         return;
204     }
205     SMP_EncData *encData = (SMP_EncData *)param->data;
206     uint8_t tmpConfirm[SMP_CONFIRM_DATA_LEN] = {0x00};
207     LOG_DEBUG("%{public}s", __FUNCTION__);
208     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
209     if (ret != SMP_SUCCESS) {
210         return;
211     }
212     SMP_MemoryReverseCopy(SMP_GetPairMng()->local.confirm, encData->encRetParam->encryptedData, SMP_CONFIRM_DATA_LEN);
213     SMP_MemoryReverseCopy(tmpConfirm, SMP_GetPairMng()->local.confirm, SMP_CONFIRM_DATA_LEN);
214     LOG_DEBUG("SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_9 started.");
215     SMP_GetPairMng()->step = SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_9;
216     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
217     ret = SMP_SendPairingConfirm(SMP_GetPairMng()->handle, tmpConfirm, SMP_SendDataCallback);
218     if (ret != SMP_SUCCESS) {
219         LOG_ERROR("Send Pairing Confirm failed.");
220         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
221             SMP_PAIR_STATUS_FAILED,
222             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
223             SMP_GetPairMng()->alarm);
224     }
225 }
226 
SMP_ScPairJustworkOrNumericSlaveStep9(const SMP_StepParam * param)227 void SMP_ScPairJustworkOrNumericSlaveStep9(const SMP_StepParam *param)
228 {
229     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
230         return;
231     }
232     int ret;
233     HciLeEncryptParam encryptParam;
234 
235     LOG_DEBUG("%{public}s", __FUNCTION__);
236     SMP_MemoryReverseCopy(SMP_GetPairMng()->peer.random, (uint8_t *)param->data, SMP_RANDOM_DATA_LEN);
237     if (SMP_GetPairMng()->local.pairMethod == SMP_PAIR_METHOD_JUST_WORK) {
238         uint8_t randomTemp[SMP_RANDOM_DATA_LEN] = {0x00};
239         SMP_MemoryReverseCopy(randomTemp, SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN);
240         SMP_GetPairMng()->step = SMP_SC_PAIR_COMMON_SLAVE_STEP_1;
241         LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_1 started.");
242         AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
243         ret = SMP_SendPairingRandom(SMP_GetPairMng()->handle, randomTemp, SMP_SendDataCallback);
244         if (ret != SMP_SUCCESS) {
245             SMP_GeneratePairResult(SMP_GetPairMng()->handle,
246                 SMP_PAIR_STATUS_FAILED,
247                 SMP_PAIR_FAILED_UNSPECIFIED_REASION,
248                 SMP_GetPairMng()->alarm);
249             LOG_ERROR("Send pairing random error.");
250         }
251     } else {
252         SMP_GetPairMng()->slaveDHKeyCheckRecvFlag = SMP_SLAVE_DHKEYCHECK_RECV_FLAG_NO;
253         SMP_MemoryReverseCopy(encryptParam.key, SMP_GetPairMng()->peer.random, sizeof(encryptParam.key));
254         uint8_t cryptAesCmacZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
255         (void)memcpy_s(
256             encryptParam.plaintextData, sizeof(encryptParam.plaintextData), cryptAesCmacZ, CRYPT_AESCMAC_Z_LEN);
257         LOG_DEBUG("SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_10 started.");
258         ret = SMP_SendLeEncryptCmd(
259             &encryptParam, SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_10, NULL, SMP_USING_HW_AES128_PAIR);
260         if (ret != SMP_SUCCESS) {
261             SMP_GeneratePairResult(
262                 SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
263         }
264     }
265     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
266 }
267 
SMP_ScPairJustworkOrNumericSlaveStep10(const SMP_StepParam * param)268 void SMP_ScPairJustworkOrNumericSlaveStep10(const SMP_StepParam *param)
269 {
270     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
271         return;
272     }
273     SMP_EncData *encData = (SMP_EncData *)param->data;
274     SMP_CryptG2Param cryptG2Param;
275     LOG_DEBUG("%{public}s", __FUNCTION__);
276     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
277     if (ret != SMP_SUCCESS) {
278         return;
279     }
280     SMP_GetPublicKeyX(SMP_GetPairMng()->peer.publicKey, cryptG2Param.U, sizeof(cryptG2Param.U));
281     SMP_GetPublicKeyX(SMP_GetPairMng()->local.publicKey, cryptG2Param.V, sizeof(cryptG2Param.V));
282     (void)memcpy_s(cryptG2Param.Y, sizeof(cryptG2Param.Y), SMP_GetPairMng()->local.random, sizeof(cryptG2Param.Y));
283     SMP_CryptographicG2(&cryptG2Param);
284     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
285     SMP_ConstituteAesCmacStep3Param(encData, cryptG2Param.output, CRYPT_G2_OUT_LEN, &cryptAesCmacStep3Param);
286     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_11;
287     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_12;
288     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
289     if (ret != SMP_SUCCESS) {
290         SMP_GeneratePairResult(
291             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
292     }
293     (void)memset_s(cryptAesCmacStep3Param.key, CRYPT_AESCMAC_KEY_LEN, 0x00, CRYPT_AESCMAC_KEY_LEN);
294 }
295 
SMP_ScPairJustworkOrNumericSlaveStep11(const SMP_StepParam * param)296 void SMP_ScPairJustworkOrNumericSlaveStep11(const SMP_StepParam *param)
297 {
298     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
299         return;
300     }
301     SMP_EncData *encData = (SMP_EncData *)param->data;
302     LOG_DEBUG("%{public}s", __FUNCTION__);
303     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
304     int ret = SMP_ConstituteAesCmacStep4Param(encData,
305         SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_11,
306         SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_12,
307         SMP_ROLE_SLAVE,
308         &cryptAesCmacStep4Param);
309     if (!ret) {
310         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
311     }
312     if (ret != SMP_SUCCESS) {
313         SMP_GeneratePairResult(
314             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
315     }
316 }
317 
SMP_ScPairJustworkOrNumericSlaveStep12(const SMP_StepParam * param)318 void SMP_ScPairJustworkOrNumericSlaveStep12(const SMP_StepParam *param)
319 {
320     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
321         return;
322     }
323     SMP_EncData *encData = (SMP_EncData *)param->data;
324     uint16_t handle = SMP_GetPairMng()->handle;
325     uint8_t pairMethod = SMP_GetPairMng()->local.pairMethod;
326     uint8_t randomTemp[SMP_RANDOM_DATA_LEN] = {0x00};
327 
328     LOG_DEBUG("%{public}s", __FUNCTION__);
329     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
330     if (ret != SMP_SUCCESS) {
331         return;
332     }
333     SMP_MemoryReverseCopy(randomTemp, SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN);
334     LOG_DEBUG("SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_13 started.");
335     SMP_GetPairMng()->step = SMP_SC_PAIR_JUSTWORKORNUMERIC_SLAVE_STEP_13;
336     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
337     ret = SMP_SendPairingRandom(SMP_GetPairMng()->handle, randomTemp, SMP_SendDataCallback);
338     if (ret != SMP_SUCCESS) {
339         LOG_ERROR("Send pairing random error.");
340         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
341             SMP_PAIR_STATUS_FAILED,
342             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
343             SMP_GetPairMng()->alarm);
344     } else {
345         uint32_t numeric = *((uint32_t *)encData->encRetParam->encryptedData);
346         numeric = numeric % (SMP_MAX_NUMERIC_VALUE + 0x01);
347         SMP_NotifyCbAuthReq(handle, pairMethod, (uint8_t *)&numeric);
348     }
349 }
350 
SMP_ScPairJustworkOrNumericSlaveStep13(const SMP_StepParam * param)351 void SMP_ScPairJustworkOrNumericSlaveStep13(const SMP_StepParam *param)
352 {
353     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
354         return;
355     }
356 
357     LOG_DEBUG("%{public}s", __FUNCTION__);
358     (void)memcpy_s(SMP_GetPairMng()->peer.DHKeyCheck, SMP_DHKEY_CHECK_LEN, (uint8_t *)param->data, SMP_DHKEY_CHECK_LEN);
359     SMP_GetPairMng()->slaveDHKeyCheckRecvFlag = SMP_SLAVE_DHKEYCHECK_RECV_FLAG_YES;
360 }
361 
SMP_ScPairPasskeyEntrySlaveStep1(const SMP_StepParam * param)362 void SMP_ScPairPasskeyEntrySlaveStep1(const SMP_StepParam *param)
363 {
364     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
365         return;
366     }
367     LOG_DEBUG("%{public}s", __FUNCTION__);
368     AlarmCancel(SMP_GetPairMng()->alarm);
369     (void)memcpy_s(SMP_GetPairMng()->peer.publicKey, SMP_PUBLICKEY_LEN, (uint8_t *)param->data, SMP_PUBLICKEY_LEN);
370     LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_2 started.");
371     SMP_GetPairMng()->step = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_2;
372     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
373     int ret = HCI_LeReadLocalP256PublicKey();
374     if (ret != SMP_SUCCESS) {
375         LOG_ERROR("HCI_LeReadLocalP256PublicKey failed.");
376         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
377             SMP_PAIR_STATUS_FAILED,
378             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
379             SMP_GetPairMng()->alarm);
380     }
381 }
382 
SMP_ScPairPasskeyEntrySlaveStep2(const SMP_StepParam * param)383 void SMP_ScPairPasskeyEntrySlaveStep2(const SMP_StepParam *param)
384 {
385     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
386         return;
387     }
388     HciLeGenerateDHKeyParam DHKeyParam;
389     const HciLeReadLocalP256PublicKeyCompleteEventParam *eventParam =
390         (HciLeReadLocalP256PublicKeyCompleteEventParam *)param->data;
391 
392     LOG_DEBUG("%{public}s", __FUNCTION__);
393     (void)memcpy_s(
394         SMP_GetPairMng()->local.publicKey, SMP_PUBLICKEY_LEN, eventParam->localP256PublicKey, SMP_PUBLICKEY_LEN);
395     LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_3 started.");
396     SMP_GetPairMng()->step = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_3;
397     (void)memcpy_s(
398         DHKeyParam.remoteP256PublicKey, SMP_PUBLICKEY_LEN, SMP_GetPairMng()->peer.publicKey, SMP_PUBLICKEY_LEN);
399     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
400     int ret = HCI_LeGenerateDHKey(&DHKeyParam);
401     if (ret != SMP_SUCCESS) {
402         LOG_ERROR("HCI_LeGenerateDHKey failed.");
403         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
404             SMP_PAIR_STATUS_FAILED,
405             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
406             SMP_GetPairMng()->alarm);
407     }
408 }
409 
SMP_ScPairPasskeyEntrySlaveStep3(const SMP_StepParam * param)410 void SMP_ScPairPasskeyEntrySlaveStep3(const SMP_StepParam *param)
411 {
412     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
413         return;
414     }
415     uint16_t handle = SMP_GetPairMng()->handle;
416     uint8_t pairMethod = SMP_GetPairMng()->local.pairMethod;
417     const HciLeGenerateDHKeyCompleteEventParam *eventParam = (HciLeGenerateDHKeyCompleteEventParam *)param->data;
418 
419     LOG_DEBUG("%{public}s", __FUNCTION__);
420     SMP_MemoryReverseCopy(SMP_GetPairMng()->DHKey, eventParam->DHKey, SMP_DHKEY_LEN);
421     int ret =
422         SMP_SendPairingPublicKey(SMP_GetPairMng()->handle, SMP_GetPairMng()->local.publicKey, SMP_SendDataCallback);
423     if (ret != SMP_SUCCESS) {
424         LOG_ERROR("Send pairing public key failed.");
425         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
426             SMP_PAIR_STATUS_FAILED,
427             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
428             SMP_GetPairMng()->alarm);
429     } else {
430         if (SMP_GetPairMng()->local.pairMethod == SMP_PAIR_METHOD_PASSKEY_DISPLAY) {
431             LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_4 started.");
432             SMP_GetPairMng()->scConfirmCheckCounter = 0x00;
433             ret = SMP_SendHciLeRandCmd(SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_4);
434             if (ret != SMP_SUCCESS) {
435                 SMP_GeneratePairResult(
436                     SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
437             }
438         } else {
439             LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_5 started.");
440             SMP_GetPairMng()->scConfirmCheckCounter = 0x00;
441             SMP_GetPairMng()->step = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_5;
442             AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
443             SMP_NotifyCbAuthReq(handle, pairMethod, NULL);
444         }
445     }
446 }
447 
SMP_ScPairPasskeyEntrySlaveStep4(const SMP_StepParam * param)448 void SMP_ScPairPasskeyEntrySlaveStep4(const SMP_StepParam *param)
449 {
450     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
451         return;
452     }
453     uint32_t passkey;
454     uint16_t handle = SMP_GetPairMng()->handle;
455     uint8_t pairMethod = SMP_GetPairMng()->local.pairMethod;
456     const HciLeRandReturnParam *returnParam = (HciLeRandReturnParam *)param->data;
457 
458     LOG_DEBUG("%{public}s", __FUNCTION__);
459     passkey = *((uint32_t *)returnParam->randomNumber);
460     passkey = passkey % (SMP_MAX_PASSKEY_VALUE + 0x01);
461     LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_5 started.");
462     SMP_GetPairMng()->step = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_5;
463     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
464     SMP_NotifyCbAuthReq(handle, pairMethod, (uint8_t *)&passkey);
465 }
466 
SMP_ScPairPasskeyEntrySlaveStep5(const SMP_StepParam * param)467 void SMP_ScPairPasskeyEntrySlaveStep5(const SMP_StepParam *param)
468 {
469     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
470         return;
471     }
472 
473     LOG_DEBUG("%{public}s", __FUNCTION__);
474     SMP_GetPairMng()->slaveConfirmRecvFlag = SMP_SLAVE_CONFIRM_RECV_FLAG_YES;
475     SMP_MemoryReverseCopy(SMP_GetPairMng()->peer.confirm, (uint8_t *)param->data, SMP_CONFIRM_DATA_LEN);
476 }
477 
SMP_ScPairPasskeyEntrySlaveStep6(const SMP_StepParam * param)478 void SMP_ScPairPasskeyEntrySlaveStep6(const SMP_StepParam *param)
479 {
480     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
481         return;
482     }
483     LOG_DEBUG("%{public}s", __FUNCTION__);
484     AlarmCancel(SMP_GetPairMng()->alarm);
485     SMP_MemoryReverseCopy(SMP_GetPairMng()->peer.confirm, (uint8_t *)param->data, SMP_CONFIRM_DATA_LEN);
486     LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_7 started.");
487     int ret = SMP_SendHciLeRandCmd(SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_7);
488     if (ret != SMP_SUCCESS) {
489         SMP_GeneratePairResult(
490             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
491     }
492 }
493 
SMP_ScPairPasskeyEntrySlaveStep7(const SMP_StepParam * param)494 void SMP_ScPairPasskeyEntrySlaveStep7(const SMP_StepParam *param)
495 {
496     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
497         return;
498     }
499     const HciLeRandReturnParam *returnParam = (HciLeRandReturnParam *)param->data;
500 
501     LOG_DEBUG("%{public}s", __FUNCTION__);
502     (void)memcpy_s(SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN, returnParam->randomNumber, SMP_RAND_NUM_LEN);
503     LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_8 started.");
504     int ret = SMP_SendHciLeRandCmd(SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_8);
505     if (ret != SMP_SUCCESS) {
506         SMP_GeneratePairResult(
507             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
508     }
509 }
510 
SMP_ScPairPasskeyEntrySlaveStep8(const SMP_StepParam * param)511 void SMP_ScPairPasskeyEntrySlaveStep8(const SMP_StepParam *param)
512 {
513     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
514         return;
515     }
516     HciLeEncryptParam encryptParam;
517     uint8_t cryptAesCmacZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
518     const HciLeRandReturnParam *returnParam = (HciLeRandReturnParam *)param->data;
519 
520     LOG_DEBUG("%{public}s", __FUNCTION__);
521     (void)memcpy_s(SMP_GetPairMng()->local.random + SMP_RAND_NUM_LEN,
522         SMP_RAND_NUM_LEN,
523         returnParam->randomNumber,
524         SMP_RAND_NUM_LEN);
525     SMP_MemoryReverseCopy(encryptParam.key, SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN);
526     LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_9 started");
527     (void)memcpy_s(encryptParam.plaintextData, sizeof(encryptParam.plaintextData), cryptAesCmacZ, CRYPT_AESCMAC_Z_LEN);
528     int ret =
529         SMP_SendLeEncryptCmd(&encryptParam, SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_9, NULL, SMP_USING_HW_AES128_PAIR);
530     if (ret != SMP_SUCCESS) {
531         SMP_GeneratePairResult(
532             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
533     }
534     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
535 }
536 
SMP_ScPairPasskeyEntrySlaveStep9(const SMP_StepParam * param)537 void SMP_ScPairPasskeyEntrySlaveStep9(const SMP_StepParam *param)
538 {
539     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
540         return;
541     }
542     SMP_EncData *encData = (SMP_EncData *)param->data;
543     SMP_CryptF4Param cryptF4Param;
544     bool isPasskey = true;
545     LOG_DEBUG("%{public}s", __FUNCTION__);
546     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
547     if (ret != SMP_SUCCESS) {
548         return;
549     }
550     SMP_GetPublicKeyX(SMP_GetPairMng()->local.publicKey, cryptF4Param.U, sizeof(cryptF4Param.U));
551     SMP_GetPublicKeyX(SMP_GetPairMng()->peer.publicKey, cryptF4Param.V, sizeof(cryptF4Param.V));
552     SMP_ConstituteF4Param(isPasskey, &cryptF4Param);
553     SMP_CryptographicF4(&cryptF4Param);
554     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
555     SMP_ConstituteAesCmacStep3Param(encData, cryptF4Param.output, CRYPT_F4_OUT_LEN, &cryptAesCmacStep3Param);
556     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_10;
557     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_11;
558     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
559     if (ret != SMP_SUCCESS) {
560         SMP_GeneratePairResult(
561             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
562     }
563     (void)memset_s(cryptAesCmacStep3Param.key, CRYPT_AESCMAC_KEY_LEN, 0x00, CRYPT_AESCMAC_KEY_LEN);
564 }
565 
SMP_ScPairPasskeyEntrySlaveStep10(const SMP_StepParam * param)566 void SMP_ScPairPasskeyEntrySlaveStep10(const SMP_StepParam *param)
567 {
568     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
569         return;
570     }
571     SMP_EncData *encData = (SMP_EncData *)param->data;
572     LOG_DEBUG("%{public}s", __FUNCTION__);
573     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
574     int ret = SMP_ConstituteAesCmacStep4Param(encData,
575         SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_10,
576         SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_11,
577         SMP_ROLE_SLAVE,
578         &cryptAesCmacStep4Param);
579     if (!ret) {
580         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
581     }
582     if (ret != SMP_SUCCESS) {
583         SMP_GeneratePairResult(
584             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
585     }
586 }
587 
SMP_ScPairPasskeyEntrySlaveStep11(const SMP_StepParam * param)588 void SMP_ScPairPasskeyEntrySlaveStep11(const SMP_StepParam *param)
589 {
590     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
591         return;
592     }
593     SMP_EncData *encData = (SMP_EncData *)param->data;
594     uint8_t confirmTmp[SMP_CONFIRM_DATA_LEN] = {0x00};
595     LOG_DEBUG("%{public}s", __FUNCTION__);
596     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
597     if (ret != SMP_SUCCESS) {
598         return;
599     }
600     SMP_MemoryReverseCopy(SMP_GetPairMng()->local.confirm, encData->encRetParam->encryptedData, SMP_CONFIRM_DATA_LEN);
601     SMP_MemoryReverseCopy(confirmTmp, SMP_GetPairMng()->local.confirm, SMP_CONFIRM_DATA_LEN);
602     LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_12 started.");
603     SMP_GetPairMng()->step = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_12;
604     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
605     ret = SMP_SendPairingConfirm(SMP_GetPairMng()->handle, confirmTmp, SMP_SendDataCallback);
606     if (ret != SMP_SUCCESS) {
607         LOG_ERROR("Send Pairing Confirm failed.");
608         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
609             SMP_PAIR_STATUS_FAILED,
610             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
611             SMP_GetPairMng()->alarm);
612     }
613 }
614 
SMP_ScPairPasskeyEntrySlaveStep12(const SMP_StepParam * param)615 void SMP_ScPairPasskeyEntrySlaveStep12(const SMP_StepParam *param)
616 {
617     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
618         return;
619     }
620     uint8_t cryptAesCmacZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
621     HciLeEncryptParam encryptParam;
622 
623     LOG_DEBUG("%{public}s", __FUNCTION__);
624     SMP_MemoryReverseCopy(SMP_GetPairMng()->peer.random, (uint8_t *)param->data, SMP_RANDOM_DATA_LEN);
625     SMP_MemoryReverseCopy(encryptParam.key, SMP_GetPairMng()->peer.random, SMP_RANDOM_DATA_LEN);
626     (void)memcpy_s(encryptParam.plaintextData, sizeof(encryptParam.plaintextData), cryptAesCmacZ, CRYPT_AESCMAC_Z_LEN);
627     LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_13 started.");
628     int ret =
629         SMP_SendLeEncryptCmd(&encryptParam, SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_13, NULL, SMP_USING_HW_AES128_PAIR);
630     if (ret != SMP_SUCCESS) {
631         SMP_GeneratePairResult(
632             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
633     }
634     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
635 }
636 
SMP_ScPairPasskeyEntrySlaveStep13(const SMP_StepParam * param)637 void SMP_ScPairPasskeyEntrySlaveStep13(const SMP_StepParam *param)
638 {
639     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
640         return;
641     }
642     SMP_EncData *encData = (SMP_EncData *)param->data;
643     SMP_CryptF4Param cryptF4Param;
644     bool isPasskey = true;
645     LOG_DEBUG("%{public}s", __FUNCTION__);
646     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
647     if (ret != SMP_SUCCESS) {
648         return;
649     }
650     SMP_GetPublicKeyX(SMP_GetPairMng()->peer.publicKey, cryptF4Param.U, sizeof(cryptF4Param.U));
651     SMP_GetPublicKeyX(SMP_GetPairMng()->local.publicKey, cryptF4Param.V, sizeof(cryptF4Param.V));
652     SMP_ConstituteF4Param(isPasskey, &cryptF4Param);
653     SMP_CryptographicF4(&cryptF4Param);
654     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
655     SMP_ConstituteAesCmacStep3Param(encData, cryptF4Param.output, CRYPT_F4_OUT_LEN, &cryptAesCmacStep3Param);
656     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_14;
657     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_15;
658     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
659     if (ret != SMP_SUCCESS) {
660         SMP_GeneratePairResult(
661             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
662     }
663     (void)memset_s(cryptAesCmacStep3Param.key, CRYPT_AESCMAC_KEY_LEN, 0x00, CRYPT_AESCMAC_KEY_LEN);
664 }
665 
SMP_ScPairPasskeyEntrySlaveStep14(const SMP_StepParam * param)666 void SMP_ScPairPasskeyEntrySlaveStep14(const SMP_StepParam *param)
667 {
668     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
669         return;
670     }
671     SMP_EncData *encData = (SMP_EncData *)param->data;
672     LOG_DEBUG("%{public}s", __FUNCTION__);
673     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
674     int ret = SMP_ConstituteAesCmacStep4Param(encData,
675         SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_14,
676         SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_15,
677         SMP_ROLE_SLAVE,
678         &cryptAesCmacStep4Param);
679     if (!ret) {
680         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
681     }
682     if (ret != SMP_SUCCESS) {
683         SMP_GeneratePairResult(
684             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
685     }
686 }
687 
SMP_ScPairPasskeyEntrySlaveStep15(const SMP_StepParam * param)688 void SMP_ScPairPasskeyEntrySlaveStep15(const SMP_StepParam *param)
689 {
690     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
691         return;
692     }
693     SMP_EncData *encData = (SMP_EncData *)param->data;
694     uint8_t confirmTmp[SMP_CONFIRM_DATA_LEN] = {0x00};
695     LOG_DEBUG("%{public}s", __FUNCTION__);
696     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
697     if (ret != SMP_SUCCESS) {
698         return;
699     }
700     SMP_MemoryReverseCopy(confirmTmp, encData->encRetParam->encryptedData, SMP_CONFIRM_DATA_LEN);
701     if (memcmp(confirmTmp, SMP_GetPairMng()->peer.confirm, SMP_CONFIRM_DATA_LEN) != 0x00) {
702         SMP_GeneratePairResult(SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_CONFIRM_VALUE, NULL);
703         LOG_ERROR("Confirm check failed");
704     } else {
705         LOG_INFO("Confirm check success");
706         uint8_t randomTemp[SMP_RANDOM_DATA_LEN] = {0x00};
707         SMP_GetPairMng()->scConfirmCheckCounter++;
708         if (SMP_GetPairMng()->scConfirmCheckCounter == 0x14) {
709             SMP_MemoryReverseCopy(randomTemp, SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN);
710             SMP_GetPairMng()->step = SMP_SC_PAIR_COMMON_SLAVE_STEP_1;
711             AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
712             LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_1 started.");
713             ret = SMP_SendPairingRandom(SMP_GetPairMng()->handle, randomTemp, SMP_SendDataCallback);
714         } else {
715             SMP_MemoryReverseCopy(randomTemp, SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN);
716             LOG_DEBUG("SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_6 started.");
717             SMP_GetPairMng()->step = SMP_SC_PAIR_PASSKEYENTRY_SLAVE_STEP_6;
718             AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
719             ret = SMP_SendPairingRandom(SMP_GetPairMng()->handle, randomTemp, SMP_SendDataCallback);
720         }
721         if (ret != SMP_SUCCESS) {
722             LOG_ERROR("Send pairing random error.");
723             SMP_GeneratePairResult(SMP_GetPairMng()->handle,
724                 SMP_PAIR_STATUS_FAILED,
725                 SMP_PAIR_FAILED_UNSPECIFIED_REASION,
726                 SMP_GetPairMng()->alarm);
727         }
728     }
729 }
730 
SMP_ScPairOobSlaveStep1(const SMP_StepParam * param)731 void SMP_ScPairOobSlaveStep1(const SMP_StepParam *param)
732 {
733     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
734         return;
735     }
736     uint16_t handle = SMP_GetPairMng()->handle;
737     uint8_t pairMethod = SMP_GetPairMng()->local.pairMethod;
738     const HciLeReadLocalP256PublicKeyCompleteEventParam *eventParam =
739         (HciLeReadLocalP256PublicKeyCompleteEventParam *)param->data;
740 
741     LOG_DEBUG("%{public}s", __FUNCTION__);
742     (void)memcpy_s(
743         SMP_GetPairMng()->local.publicKey, SMP_PUBLICKEY_LEN, eventParam->localP256PublicKey, SMP_PUBLICKEY_LEN);
744     LOG_DEBUG("SMP_SC_PAIR_OOB_SLAVE_STEP_7 started.");
745     SMP_GetPairMng()->step = SMP_SC_PAIR_OOB_SLAVE_STEP_7;
746     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
747     SMP_NotifyCbAuthReq(handle, pairMethod, NULL);
748 }
749 
SMP_ScPairOobSlaveStep7(const SMP_StepParam * param)750 void SMP_ScPairOobSlaveStep7(const SMP_StepParam *param)
751 {
752     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
753         return;
754     }
755 
756     LOG_DEBUG("%{public}s", __FUNCTION__);
757     (void)memcpy_s(SMP_GetPairMng()->peer.publicKey, SMP_PUBLICKEY_LEN, (uint8_t *)param->data, SMP_PUBLICKEY_LEN);
758     SMP_GetPairMng()->slavePubKeyRecvFlag = SMP_SLAVE_PUBLICKEY_RECV_FLAG_YES;
759 }
760 
SMP_ScPairOobSlaveStep8(const SMP_StepParam * param)761 void SMP_ScPairOobSlaveStep8(const SMP_StepParam *param)
762 {
763     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
764         return;
765     }
766     HciLeGenerateDHKeyParam DHKeyParam;
767 
768     LOG_DEBUG("%{public}s", __FUNCTION__);
769     AlarmCancel(SMP_GetPairMng()->alarm);
770     (void)memcpy_s(SMP_GetPairMng()->peer.publicKey, SMP_PUBLICKEY_LEN, (uint8_t *)param->data, SMP_PUBLICKEY_LEN);
771     SMP_GetPairMng()->step = SMP_SC_PAIR_OOB_SLAVE_STEP_9;
772     (void)memcpy_s(
773         DHKeyParam.remoteP256PublicKey, SMP_PUBLICKEY_LEN, SMP_GetPairMng()->peer.publicKey, SMP_PUBLICKEY_LEN);
774     LOG_DEBUG("SMP_SC_PAIR_OOB_SLAVE_STEP_9 started");
775     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
776     int ret = HCI_LeGenerateDHKey(&DHKeyParam);
777     if (ret != SMP_SUCCESS) {
778         LOG_ERROR("HCI_LeGenerateDHKey failed.");
779         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
780             SMP_PAIR_STATUS_FAILED,
781             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
782             SMP_GetPairMng()->alarm);
783     }
784 }
785 
SMP_ScPairOobSlaveStep9(const SMP_StepParam * param)786 void SMP_ScPairOobSlaveStep9(const SMP_StepParam *param)
787 {
788     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
789         return;
790     }
791     int ret;
792     const HciLeGenerateDHKeyCompleteEventParam *eventParam = (HciLeGenerateDHKeyCompleteEventParam *)param->data;
793     HciLeEncryptParam encryptParam;
794 
795     LOG_DEBUG("%{public}s", __FUNCTION__);
796     SMP_MemoryReverseCopy(SMP_GetPairMng()->DHKey, eventParam->DHKey, SMP_DHKEY_LEN);
797     if ((SMP_GetPairMng()->local.pairMethod == SMP_PAIR_METHOD_OOB_SC_BOTH_SIDE_SEND_RECV) ||
798         (SMP_GetPairMng()->local.pairMethod == SMP_PAIR_METHOD_OOB_SC_LOCAL_RECV_PEER_SEND)) {
799         LOG_DEBUG("SMP_SC_PAIR_OOB_SLAVE_STEP_10 started");
800         SMP_MemoryReverseCopy(encryptParam.key, SMP_GetPairMng()->peer.oobRand, SMP_RANDOM_DATA_LEN);
801         uint8_t tmpZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
802         (void)memcpy_s(encryptParam.plaintextData, sizeof(encryptParam.plaintextData), tmpZ, sizeof(tmpZ));
803         ret = SMP_SendLeEncryptCmd(&encryptParam, SMP_SC_PAIR_OOB_SLAVE_STEP_10, NULL, SMP_USING_HW_AES128_PAIR);
804         if (ret != SMP_SUCCESS) {
805             SMP_GeneratePairResult(
806                 SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
807         }
808     } else {
809         SMP_GetPairMng()->step = SMP_SC_PAIR_OOB_SLAVE_STEP_13;
810         AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
811         LOG_DEBUG("SMP_SC_PAIR_OOB_SLAVE_STEP_13 started.");
812         ret =
813             SMP_SendPairingPublicKey(SMP_GetPairMng()->handle, SMP_GetPairMng()->local.publicKey, SMP_SendDataCallback);
814         if (ret != SMP_SUCCESS) {
815             SMP_GeneratePairResult(SMP_GetPairMng()->handle,
816                 SMP_PAIR_STATUS_FAILED,
817                 SMP_PAIR_FAILED_UNSPECIFIED_REASION,
818                 SMP_GetPairMng()->alarm);
819             LOG_ERROR("Send pairing public key failed.");
820         }
821     }
822     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
823 }
824 
SMP_ScPairOobSlaveStep10(const SMP_StepParam * param)825 void SMP_ScPairOobSlaveStep10(const SMP_StepParam *param)
826 {
827     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
828         return;
829     }
830     SMP_EncData *encData = (SMP_EncData *)param->data;
831     SMP_CryptF4Param cryptF4Param;
832     bool isPasskey = false;
833     LOG_DEBUG("%{public}s", __FUNCTION__);
834     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
835     if (ret != SMP_SUCCESS) {
836         return;
837     }
838     SMP_GetPublicKeyX(SMP_GetPairMng()->peer.publicKey, cryptF4Param.U, sizeof(cryptF4Param.U));
839     SMP_GetPublicKeyX(SMP_GetPairMng()->peer.publicKey, cryptF4Param.V, sizeof(cryptF4Param.V));
840     SMP_ConstituteF4Param(isPasskey, &cryptF4Param);
841     SMP_CryptographicF4(&cryptF4Param);
842     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
843     SMP_ConstituteAesCmacStep3Param(encData, cryptF4Param.output, CRYPT_F4_OUT_LEN, &cryptAesCmacStep3Param);
844     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_OOB_SLAVE_STEP_11;
845     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_OOB_SLAVE_STEP_12;
846     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
847     if (ret != SMP_SUCCESS) {
848         SMP_GeneratePairResult(
849             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
850     }
851     (void)memset_s(cryptAesCmacStep3Param.key, CRYPT_AESCMAC_KEY_LEN, 0x00, CRYPT_AESCMAC_KEY_LEN);
852 }
853 
SMP_ScPairOobSlaveStep11(const SMP_StepParam * param)854 void SMP_ScPairOobSlaveStep11(const SMP_StepParam *param)
855 {
856     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
857         return;
858     }
859     SMP_EncData *encData = (SMP_EncData *)param->data;
860     LOG_DEBUG("%{public}s", __FUNCTION__);
861     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
862     int ret = SMP_ConstituteAesCmacStep4Param(
863         encData, SMP_SC_PAIR_OOB_SLAVE_STEP_11, SMP_SC_PAIR_OOB_SLAVE_STEP_12, SMP_ROLE_SLAVE, &cryptAesCmacStep4Param);
864     if (!ret) {
865         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
866     }
867     if (ret != SMP_SUCCESS) {
868         SMP_GeneratePairResult(
869             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
870     }
871 }
872 
SMP_ScPairOobSlaveStep12(const SMP_StepParam * param)873 void SMP_ScPairOobSlaveStep12(const SMP_StepParam *param)
874 {
875     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
876         return;
877     }
878     SMP_EncData *encData = (SMP_EncData *)param->data;
879     uint8_t tmpConfirm[SMP_CONFIRM_DATA_LEN] = {0x00};
880     LOG_DEBUG("%{public}s", __FUNCTION__);
881     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
882     if (ret != SMP_SUCCESS) {
883         return;
884     }
885     (void)memcpy_s(tmpConfirm, SMP_CONFIRM_DATA_LEN, encData->encRetParam->encryptedData, SMP_CONFIRM_DATA_LEN);
886     if (memcmp(tmpConfirm, SMP_GetPairMng()->peer.confirm, SMP_CONFIRM_DATA_LEN) != 0x00) {
887         LOG_ERROR("Confirm Check Failed.");
888         SMP_SendPairingPublicKey(SMP_GetPairMng()->handle, SMP_GetPairMng()->local.publicKey, SMP_SendDataCallback);
889         SMP_GeneratePairResult(SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_CONFIRM_VALUE, NULL);
890     } else {
891         LOG_INFO("Confirm Check Success.");
892         LOG_DEBUG("SMP_SC_PAIR_OOB_SLAVE_STEP_13 started.");
893         SMP_GetPairMng()->step = SMP_SC_PAIR_OOB_SLAVE_STEP_13;
894         AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
895         ret =
896             SMP_SendPairingPublicKey(SMP_GetPairMng()->handle, SMP_GetPairMng()->local.publicKey, SMP_SendDataCallback);
897         if (ret != SMP_SUCCESS) {
898             LOG_ERROR("Send pairing public key failed.");
899             SMP_GeneratePairResult(SMP_GetPairMng()->handle,
900                 SMP_PAIR_STATUS_FAILED,
901                 SMP_PAIR_FAILED_UNSPECIFIED_REASION,
902                 SMP_GetPairMng()->alarm);
903         }
904     }
905 }
906 
SMP_ScPairOobSlaveStep13(const SMP_StepParam * param)907 void SMP_ScPairOobSlaveStep13(const SMP_StepParam *param)
908 {
909     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
910         return;
911     }
912     LOG_DEBUG("%{public}s", __FUNCTION__);
913     SMP_MemoryReverseCopy(SMP_GetPairMng()->peer.random, (uint8_t *)param->data, SMP_RANDOM_DATA_LEN);
914     LOG_DEBUG("SMP_SC_PAIR_OOB_SLAVE_STEP_14 started.");
915     int ret = SMP_SendHciLeRandCmd(SMP_SC_PAIR_OOB_SLAVE_STEP_14);
916     if (ret != SMP_SUCCESS) {
917         SMP_GeneratePairResult(
918             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
919     }
920 }
921 
SMP_ScPairOobSlaveStep14(const SMP_StepParam * param)922 void SMP_ScPairOobSlaveStep14(const SMP_StepParam *param)
923 {
924     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
925         return;
926     }
927     const HciLeRandReturnParam *returnParam = (HciLeRandReturnParam *)param->data;
928 
929     LOG_DEBUG("%{public}s", __FUNCTION__);
930     (void)memcpy_s(SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN, returnParam->randomNumber, SMP_RAND_NUM_LEN);
931     LOG_DEBUG("SMP_SC_PAIR_OOB_SLAVE_STEP_15 started.");
932     int ret = SMP_SendHciLeRandCmd(SMP_SC_PAIR_OOB_SLAVE_STEP_15);
933     if (ret != SMP_SUCCESS) {
934         SMP_GeneratePairResult(
935             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
936     }
937 }
938 
SMP_ScPairOobSlaveStep15(const SMP_StepParam * param)939 void SMP_ScPairOobSlaveStep15(const SMP_StepParam *param)
940 {
941     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
942         return;
943     }
944     uint8_t randomTemp[SMP_RANDOM_DATA_LEN] = {0x00};
945     const HciLeRandReturnParam *returnParam = (HciLeRandReturnParam *)param->data;
946 
947     LOG_DEBUG("%{public}s", __FUNCTION__);
948     (void)memcpy_s(SMP_GetPairMng()->local.random + SMP_RAND_NUM_LEN,
949         SMP_RAND_NUM_LEN,
950         returnParam->randomNumber,
951         SMP_RAND_NUM_LEN);
952     SMP_MemoryReverseCopy(randomTemp, SMP_GetPairMng()->local.random, SMP_RANDOM_DATA_LEN);
953     LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_1 started.");
954     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
955     SMP_GetPairMng()->step = SMP_SC_PAIR_COMMON_SLAVE_STEP_1;
956     int ret = SMP_SendPairingRandom(SMP_GetPairMng()->handle, randomTemp, SMP_SendDataCallback);
957     if (ret != SMP_SUCCESS) {
958         LOG_ERROR("Send pairing random error.");
959         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
960             SMP_PAIR_STATUS_FAILED,
961             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
962             SMP_GetPairMng()->alarm);
963     }
964 }
965 
SMP_ScPairCommonSlaveStep1(const SMP_StepParam * param)966 void SMP_ScPairCommonSlaveStep1(const SMP_StepParam *param)
967 {
968     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
969         return;
970     }
971     uint8_t cryptAesCmacZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
972     HciLeEncryptParam encryptParam;
973     LOG_DEBUG("%{public}s", __FUNCTION__);
974     AlarmCancel(SMP_GetPairMng()->alarm);
975     (void)memcpy_s(SMP_GetPairMng()->peer.DHKeyCheck, SMP_DHKEY_CHECK_LEN, (uint8_t *)param->data, SMP_DHKEY_CHECK_LEN);
976     SMP_MemoryReverseCopy(encryptParam.key, SALT, sizeof(encryptParam.key));
977     (void)memcpy_s(encryptParam.plaintextData, sizeof(encryptParam.plaintextData), cryptAesCmacZ, CRYPT_AESCMAC_Z_LEN);
978     LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_2 started.");
979     int ret = SMP_SendLeEncryptCmd(&encryptParam, SMP_SC_PAIR_COMMON_SLAVE_STEP_2, NULL, SMP_USING_HW_AES128_PAIR);
980     if (ret != SMP_SUCCESS) {
981         SMP_GeneratePairResult(
982             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
983     }
984     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
985 }
986 
SMP_ScPairCommonSlaveStep2(const SMP_StepParam * param)987 void SMP_ScPairCommonSlaveStep2(const SMP_StepParam *param)
988 {
989     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
990         return;
991     }
992     SMP_EncData *encData = (SMP_EncData *)param->data;
993     LOG_DEBUG("%{public}s", __FUNCTION__);
994     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
995     if (ret != SMP_SUCCESS) {
996         return;
997     }
998     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
999     SMP_ConstituteAesCmacStep3Param(
1000         encData, SMP_GetPairMng()->DHKey, sizeof(SMP_GetPairMng()->DHKey), &cryptAesCmacStep3Param);
1001     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_COMMON_SLAVE_STEP_3;
1002     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_COMMON_SLAVE_STEP_4;
1003     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
1004     if (ret != SMP_SUCCESS) {
1005         SMP_GeneratePairResult(
1006             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1007     }
1008 }
1009 
SMP_ScPairCommonSlaveStep3(const SMP_StepParam * param)1010 void SMP_ScPairCommonSlaveStep3(const SMP_StepParam *param)
1011 {
1012     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1013         return;
1014     }
1015     SMP_EncData *encData = (SMP_EncData *)param->data;
1016     LOG_DEBUG("%{public}s", __FUNCTION__);
1017     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
1018     int ret = SMP_ConstituteAesCmacStep4Param(encData,
1019         SMP_SC_PAIR_COMMON_SLAVE_STEP_3,
1020         SMP_SC_PAIR_COMMON_SLAVE_STEP_4,
1021         SMP_ROLE_SLAVE,
1022         &cryptAesCmacStep4Param);
1023     if (!ret) {
1024         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
1025     }
1026     if (ret != SMP_SUCCESS) {
1027         SMP_GeneratePairResult(
1028             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1029     }
1030 }
1031 
SMP_ScPairCommonSlaveStep4(const SMP_StepParam * param)1032 void SMP_ScPairCommonSlaveStep4(const SMP_StepParam *param)
1033 {
1034     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1035         return;
1036     }
1037     SMP_EncData *encData = (SMP_EncData *)param->data;
1038     uint8_t cryptAesCmacZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
1039     const HciLeEncryptReturnParam *returnParam = encData->encRetParam;
1040     HciLeEncryptParam encryptParam;
1041     LOG_DEBUG("%{public}s", __FUNCTION__);
1042     int ret = SMP_EncryptCompleteJudgeException(returnParam->status, SMP_ROLE_SLAVE);
1043     if (ret != SMP_SUCCESS) {
1044         return;
1045     }
1046     (void)memcpy_s(encryptParam.key, sizeof(encryptParam.key), returnParam->encryptedData, sizeof(encryptParam.key));
1047     (void)memcpy_s(encryptParam.plaintextData, sizeof(encryptParam.plaintextData), cryptAesCmacZ, CRYPT_AESCMAC_Z_LEN);
1048     LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_5 started.");
1049     ret = SMP_SendLeEncryptCmd(&encryptParam, SMP_SC_PAIR_COMMON_SLAVE_STEP_5, NULL, SMP_USING_HW_AES128_PAIR);
1050     if (ret != SMP_SUCCESS) {
1051         SMP_GeneratePairResult(
1052             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1053     }
1054     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
1055 }
1056 
SMP_ScPairCommonSlaveStep5(const SMP_StepParam * param)1057 void SMP_ScPairCommonSlaveStep5(const SMP_StepParam *param)
1058 {
1059     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1060         return;
1061     }
1062     SMP_EncData *encData = (SMP_EncData *)param->data;
1063     SMP_CryptF5Param cryptF5Param;
1064     LOG_DEBUG("%{public}s", __FUNCTION__);
1065     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
1066     if (ret != SMP_SUCCESS) {
1067         return;
1068     }
1069     SMP_ConstituteF5Param(SMP_ROLE_SLAVE, &cryptF5Param);
1070     SMP_CryptographicF5(&cryptF5Param);
1071     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
1072     SMP_ConstituteAesCmacStep3Param(encData, cryptF5Param.output, CRYPT_F5_OUT_LEN, &cryptAesCmacStep3Param);
1073     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_COMMON_SLAVE_STEP_6;
1074     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_COMMON_SLAVE_STEP_7;
1075     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
1076     if (ret != SMP_SUCCESS) {
1077         SMP_GeneratePairResult(
1078             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1079     }
1080     (void)memset_s(cryptAesCmacStep3Param.key, CRYPT_AESCMAC_KEY_LEN, 0x00, CRYPT_AESCMAC_KEY_LEN);
1081 }
1082 
SMP_ScPairCommonSlaveStep6(const SMP_StepParam * param)1083 void SMP_ScPairCommonSlaveStep6(const SMP_StepParam *param)
1084 {
1085     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1086         return;
1087     }
1088     SMP_EncData *encData = (SMP_EncData *)param->data;
1089     LOG_DEBUG("%{public}s", __FUNCTION__);
1090     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
1091     int ret = SMP_ConstituteAesCmacStep4Param(encData,
1092         SMP_SC_PAIR_COMMON_SLAVE_STEP_6,
1093         SMP_SC_PAIR_COMMON_SLAVE_STEP_7,
1094         SMP_ROLE_SLAVE,
1095         &cryptAesCmacStep4Param);
1096     if (!ret) {
1097         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
1098     }
1099     if (ret != SMP_SUCCESS) {
1100         SMP_GeneratePairResult(
1101             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1102     }
1103 }
1104 
SMP_ScPairCommonSlaveStep7(const SMP_StepParam * param)1105 void SMP_ScPairCommonSlaveStep7(const SMP_StepParam *param)
1106 {
1107     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1108         return;
1109     }
1110     SMP_EncData *encData = (SMP_EncData *)param->data;
1111     HciLeEncryptParam encryptParam;
1112     uint8_t cryptAesCmacZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
1113     SMP_EncCmd *pEncCmdData = encData->encCmd;
1114 
1115     LOG_DEBUG("%{public}s", __FUNCTION__);
1116     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
1117     if (ret != SMP_SUCCESS) {
1118         return;
1119     }
1120     SMP_MemoryReverseCopy(SMP_GetPairMng()->macKey, encData->encRetParam->encryptedData, SMP_MACKEY_LEN);
1121     (void)memcpy_s(encryptParam.key, sizeof(encryptParam.key), pEncCmdData->key, sizeof(encryptParam.key));
1122     (void)memcpy_s(encryptParam.plaintextData, sizeof(encryptParam.plaintextData), cryptAesCmacZ, CRYPT_AESCMAC_Z_LEN);
1123     LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_8 started.");
1124     ret = SMP_SendLeEncryptCmd(&encryptParam, SMP_SC_PAIR_COMMON_SLAVE_STEP_8, NULL, SMP_USING_HW_AES128_PAIR);
1125     if (ret != SMP_SUCCESS) {
1126         SMP_GeneratePairResult(
1127             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1128     }
1129     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
1130 }
1131 
SMP_ScPairCommonSlaveStep8(const SMP_StepParam * param)1132 void SMP_ScPairCommonSlaveStep8(const SMP_StepParam *param)
1133 {
1134     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1135         return;
1136     }
1137     SMP_EncData *encData = (SMP_EncData *)param->data;
1138     SMP_CryptF5Param cryptF5Param;
1139     LOG_DEBUG("%{public}s", __FUNCTION__);
1140     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
1141     if (ret != SMP_SUCCESS) {
1142         return;
1143     }
1144     SMP_ConstituteF5Param(SMP_ROLE_SLAVE, &cryptF5Param);
1145     SMP_CryptographicF5(&cryptF5Param);
1146     cryptF5Param.output[0x00] = 0x01;
1147     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
1148     SMP_ConstituteAesCmacStep3Param(encData, cryptF5Param.output, CRYPT_F5_OUT_LEN, &cryptAesCmacStep3Param);
1149     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_COMMON_SLAVE_STEP_9;
1150     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_COMMON_SLAVE_STEP_10;
1151     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
1152     if (ret != SMP_SUCCESS) {
1153         SMP_GeneratePairResult(
1154             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1155     }
1156     (void)memset_s(cryptAesCmacStep3Param.key, CRYPT_AESCMAC_KEY_LEN, 0x00, CRYPT_AESCMAC_KEY_LEN);
1157 }
1158 
SMP_ScPairCommonSlaveStep9(const SMP_StepParam * param)1159 void SMP_ScPairCommonSlaveStep9(const SMP_StepParam *param)
1160 {
1161     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1162         return;
1163     }
1164     SMP_EncData *encData = (SMP_EncData *)param->data;
1165     LOG_DEBUG("%{public}s", __FUNCTION__);
1166     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
1167     int ret = SMP_ConstituteAesCmacStep4Param(encData,
1168         SMP_SC_PAIR_COMMON_SLAVE_STEP_9,
1169         SMP_SC_PAIR_COMMON_SLAVE_STEP_10,
1170         SMP_ROLE_SLAVE,
1171         &cryptAesCmacStep4Param);
1172     if (!ret) {
1173         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
1174     }
1175     if (ret != SMP_SUCCESS) {
1176         SMP_GeneratePairResult(
1177             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1178     }
1179 }
1180 
SMP_ScPairCommonSlaveStep10(const SMP_StepParam * param)1181 void SMP_ScPairCommonSlaveStep10(const SMP_StepParam *param)
1182 {
1183     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1184         return;
1185     }
1186     SMP_EncData *encData = (SMP_EncData *)param->data;
1187     const HciLeEncryptReturnParam *returnParam = encData->encRetParam;
1188     uint8_t tmpLTK[SMP_LTK_LEN] = {0x00};
1189     uint8_t cryptAesCmacZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
1190     HciLeEncryptParam encryptParam;
1191 
1192     LOG_DEBUG("%{public}s", __FUNCTION__);
1193     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
1194     if (ret != SMP_SUCCESS) {
1195         return;
1196     }
1197     (void)memcpy_s(tmpLTK, SMP_LTK_LEN, returnParam->encryptedData, SMP_LTK_LEN);
1198     SMP_LongTermKeyCopy(SMP_GetPairMng()->local.LTK, tmpLTK, SMP_GetPairMng()->encKeySize);
1199     SMP_LongTermKeyCopy(SMP_GetPairMng()->peer.LTK, tmpLTK, SMP_GetPairMng()->encKeySize);
1200     SMP_MemoryReverseCopy(encryptParam.key, SMP_GetPairMng()->macKey, SMP_MACKEY_LEN);
1201     (void)memcpy_s(encryptParam.plaintextData, sizeof(encryptParam.plaintextData), cryptAesCmacZ, CRYPT_AESCMAC_Z_LEN);
1202     LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_11 started.");
1203     ret = SMP_SendLeEncryptCmd(&encryptParam, SMP_SC_PAIR_COMMON_SLAVE_STEP_11, NULL, SMP_USING_HW_AES128_PAIR);
1204     if (ret != SMP_SUCCESS) {
1205         SMP_GeneratePairResult(
1206             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1207     }
1208     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
1209 }
1210 
SMP_ScPairCommonSlaveStep11(const SMP_StepParam * param)1211 void SMP_ScPairCommonSlaveStep11(const SMP_StepParam *param)
1212 {
1213     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1214         return;
1215     }
1216     SMP_EncData *encData = (SMP_EncData *)param->data;
1217     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
1218     LOG_DEBUG("%{public}s", __FUNCTION__);
1219     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
1220     if (ret != SMP_SUCCESS) {
1221         return;
1222     }
1223     SMP_CryptF6Param cryptF6Param;
1224     bool isCalculatePeer = true;
1225     SMP_ConstituteF6Param(isCalculatePeer, &cryptF6Param);
1226     SMP_CryptographicF6(&cryptF6Param);
1227     SMP_ConstituteAesCmacStep3Param(encData, cryptF6Param.output, CRYPT_F6_OUT_LEN, &cryptAesCmacStep3Param);
1228     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_COMMON_SLAVE_STEP_12;
1229     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_COMMON_SLAVE_STEP_13;
1230     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
1231     if (ret != SMP_SUCCESS) {
1232         SMP_GeneratePairResult(
1233             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1234     }
1235 }
1236 
SMP_ScPairCommonSlaveStep12(const SMP_StepParam * param)1237 void SMP_ScPairCommonSlaveStep12(const SMP_StepParam *param)
1238 {
1239     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1240         return;
1241     }
1242     SMP_EncData *encData = (SMP_EncData *)param->data;
1243     LOG_DEBUG("%{public}s", __FUNCTION__);
1244     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
1245     int ret = SMP_ConstituteAesCmacStep4Param(encData,
1246         SMP_SC_PAIR_COMMON_SLAVE_STEP_12,
1247         SMP_SC_PAIR_COMMON_SLAVE_STEP_13,
1248         SMP_ROLE_SLAVE,
1249         &cryptAesCmacStep4Param);
1250     if (!ret) {
1251         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
1252     }
1253     if (ret != SMP_SUCCESS) {
1254         SMP_GeneratePairResult(
1255             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1256     }
1257 }
1258 
SMP_ScPairCommonSlaveStep13(const SMP_StepParam * param)1259 void SMP_ScPairCommonSlaveStep13(const SMP_StepParam *param)
1260 {
1261     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1262         return;
1263     }
1264     SMP_EncData *encData = (SMP_EncData *)param->data;
1265     uint8_t dhkeyCheckTmp[SMP_DHKEY_CHECK_LEN] = {0x00};
1266     HciLeEncryptParam encryptParam;
1267 
1268     LOG_DEBUG("%{public}s", __FUNCTION__);
1269     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
1270     if (ret != SMP_SUCCESS) {
1271         return;
1272     }
1273     (void)memcpy_s(dhkeyCheckTmp, SMP_DHKEY_CHECK_LEN, encData->encRetParam->encryptedData, SMP_DHKEY_CHECK_LEN);
1274     if (memcmp(dhkeyCheckTmp, SMP_GetPairMng()->peer.DHKeyCheck, SMP_DHKEY_CHECK_LEN) != 0x00) {
1275         SMP_GeneratePairResult(SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_DHKEY_CHECK, NULL);
1276         LOG_ERROR("DHKey check failed");
1277     } else {
1278         LOG_INFO("DHKey check success");
1279         SMP_MemoryReverseCopy(encryptParam.key, SMP_GetPairMng()->macKey, SMP_MACKEY_LEN);
1280         uint8_t cryptAesCmacZ[CRYPT_AESCMAC_Z_LEN] = {0x00};
1281         (void)memcpy_s(
1282             encryptParam.plaintextData, sizeof(encryptParam.plaintextData), cryptAesCmacZ, CRYPT_AESCMAC_Z_LEN);
1283         LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_14 started.");
1284         ret = SMP_SendLeEncryptCmd(&encryptParam, SMP_SC_PAIR_COMMON_SLAVE_STEP_14, NULL, SMP_USING_HW_AES128_PAIR);
1285         if (ret != SMP_SUCCESS) {
1286             SMP_GeneratePairResult(
1287                 SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1288         }
1289     }
1290     (void)memset_s(encryptParam.key, SMP_ENCRYPT_KEY_LEN, 0x00, SMP_ENCRYPT_KEY_LEN);
1291 }
1292 
SMP_ScPairCommonSlaveStep14(const SMP_StepParam * param)1293 void SMP_ScPairCommonSlaveStep14(const SMP_StepParam *param)
1294 {
1295     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1296         return;
1297     }
1298     SMP_EncData *encData = (SMP_EncData *)param->data;
1299     SMP_CryptAesCmacStep3Param cryptAesCmacStep3Param;
1300     int ret = SMP_EncryptCompleteJudgeException(encData->encRetParam->status, SMP_ROLE_SLAVE);
1301     if (ret != SMP_SUCCESS) {
1302         return;
1303     }
1304     SMP_CryptF6Param cryptF6Param;
1305     bool isCalculatePeer = false;
1306     SMP_ConstituteF6Param(isCalculatePeer, &cryptF6Param);
1307     SMP_CryptographicF6(&cryptF6Param);
1308     SMP_ConstituteAesCmacStep3Param(encData, cryptF6Param.output, CRYPT_F6_OUT_LEN, &cryptAesCmacStep3Param);
1309     cryptAesCmacStep3Param.stepA = SMP_SC_PAIR_COMMON_SLAVE_STEP_15;
1310     cryptAesCmacStep3Param.stepB = SMP_SC_PAIR_COMMON_SLAVE_STEP_16;
1311     ret = SMP_CryptographicAesCmacStep3(&cryptAesCmacStep3Param);
1312     if (ret != SMP_SUCCESS) {
1313         SMP_GeneratePairResult(
1314             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1315     }
1316 }
1317 
SMP_ScPairCommonSlaveStep15(const SMP_StepParam * param)1318 void SMP_ScPairCommonSlaveStep15(const SMP_StepParam *param)
1319 {
1320     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1321         return;
1322     }
1323     SMP_EncData *encData = (SMP_EncData *)param->data;
1324     SMP_CryptAesCmacStep4Param cryptAesCmacStep4Param;
1325     int ret = SMP_ConstituteAesCmacStep4Param(encData,
1326         SMP_SC_PAIR_COMMON_SLAVE_STEP_15,
1327         SMP_SC_PAIR_COMMON_SLAVE_STEP_16,
1328         SMP_ROLE_SLAVE,
1329         &cryptAesCmacStep4Param);
1330     if (!ret) {
1331         ret = SMP_CryptographicAesCmacStep4(&cryptAesCmacStep4Param);
1332     }
1333     if (ret != SMP_SUCCESS) {
1334         SMP_GeneratePairResult(
1335             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1336     }
1337 }
1338 
SMP_ScPairCommonSlaveStep16(const SMP_StepParam * param)1339 void SMP_ScPairCommonSlaveStep16(const SMP_StepParam *param)
1340 {
1341     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1342         return;
1343     }
1344     SMP_EncData *encData = (SMP_EncData *)param->data;
1345     const HciLeEncryptReturnParam *returnParam = encData->encRetParam;
1346 
1347     LOG_DEBUG("%{public}s", __FUNCTION__);
1348     int ret = SMP_EncryptCompleteJudgeException(returnParam->status, SMP_ROLE_SLAVE);
1349     if (ret != SMP_SUCCESS) {
1350         return;
1351     }
1352     (void)memcpy_s(
1353         SMP_GetPairMng()->local.DHKeyCheck, SMP_DHKEY_CHECK_LEN, returnParam->encryptedData, SMP_DHKEY_CHECK_LEN);
1354     LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_17 started.");
1355     SMP_GetPairMng()->step = SMP_SC_PAIR_COMMON_SLAVE_STEP_17;
1356     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
1357     ret = SMP_SendPairingDHKeyCheck(SMP_GetPairMng()->handle, SMP_GetPairMng()->local.DHKeyCheck, SMP_SendDataCallback);
1358     if (ret != SMP_SUCCESS) {
1359         LOG_ERROR("Send Pairing DHKey Check failed.");
1360         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
1361             SMP_PAIR_STATUS_FAILED,
1362             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
1363             SMP_GetPairMng()->alarm);
1364     }
1365 }
1366 
SMP_ScPairCommonSlaveStep19(const SMP_StepParam * param)1367 void SMP_ScPairCommonSlaveStep19(const SMP_StepParam *param)
1368 {
1369     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1370         return;
1371     }
1372     const HciLeRandReturnParam *returnParam = (HciLeRandReturnParam *)param->data;
1373 
1374     LOG_DEBUG("%{public}s", __FUNCTION__);
1375     (void)memcpy_s(SMP_GetPairMng()->local.CSRK, SMP_CSRK_LEN, returnParam->randomNumber, SMP_RAND_NUM_LEN);
1376     LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_20 started.");
1377     int ret = SMP_SendHciLeRandCmd(SMP_SC_PAIR_COMMON_SLAVE_STEP_20);
1378     if (ret != SMP_SUCCESS) {
1379         SMP_GeneratePairResult(
1380             SMP_GetPairMng()->handle, SMP_PAIR_STATUS_FAILED, SMP_PAIR_FAILED_UNSPECIFIED_REASION, NULL);
1381     }
1382 }
1383 
SMP_ScPairCommonSlaveStep20(const SMP_StepParam * param)1384 void SMP_ScPairCommonSlaveStep20(const SMP_StepParam *param)
1385 {
1386     if (SMP_ParamIsNULL(param) != SMP_SUCCESS) {
1387         return;
1388     }
1389     const HciLeRandReturnParam *returnParam = (HciLeRandReturnParam *)param->data;
1390 
1391     LOG_DEBUG("%{public}s", __FUNCTION__);
1392     (void)memcpy_s(
1393         SMP_GetPairMng()->local.CSRK + SMP_RAND_NUM_LEN, SMP_RAND_NUM_LEN, returnParam->randomNumber, SMP_RAND_NUM_LEN);
1394     LOG_INFO("Send keys to remote.");
1395     LOG_DEBUG("SMP_SC_PAIR_COMMON_SLAVE_STEP_21 started.");
1396     SMP_GetPairMng()->step = SMP_SC_PAIR_COMMON_SLAVE_STEP_21;
1397     AlarmSet(SMP_GetPairMng()->alarm, SMP_PAIR_WAIT_TIME, SMP_PairTimeout, NULL);
1398     if (SMP_SendDistributionKeysToRemote()) {
1399         SMP_GeneratePairResult(SMP_GetPairMng()->handle,
1400             SMP_PAIR_STATUS_FAILED,
1401             SMP_PAIR_FAILED_UNSPECIFIED_REASION,
1402             SMP_GetPairMng()->alarm);
1403     }
1404 }