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