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  }