1 /*
2 * Copyright (c) 2023-2025 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 <cstdlib>
17 #include "hichain_auth_connector.h"
18
19 #include "dm_log.h"
20 #include "dm_anonymous.h"
21 #include "dm_constants.h"
22 #include "dm_crypto.h"
23 #include "hichain_connector_callback.h"
24 #include "parameter.h"
25 #include "cJSON.h"
26
27 namespace OHOS {
28 namespace DistributedHardware {
29
30 std::shared_ptr<IDmDeviceAuthCallback> HiChainAuthConnector::dmDeviceAuthCallback_ = nullptr;
31 std::map<int64_t, std::shared_ptr<IDmDeviceAuthCallback>> HiChainAuthConnector::dmDeviceAuthCallbackMap_;
32 std::mutex HiChainAuthConnector::dmDeviceAuthCallbackMutex_;
33
FreeJsonString(char * jsonStr)34 void HiChainAuthConnector::FreeJsonString(char *jsonStr)
35 {
36 if (jsonStr != nullptr) {
37 cJSON_free(jsonStr);
38 jsonStr = nullptr;
39 }
40 }
41
FreeCharArray(char * charArray)42 void HiChainAuthConnector::FreeCharArray(char *charArray)
43 {
44 if (charArray != nullptr) {
45 free(charArray);
46 charArray = nullptr;
47 }
48 }
49
HiChainAuthConnector()50 HiChainAuthConnector::HiChainAuthConnector()
51 {
52 deviceAuthCallback_ = {.onTransmit = HiChainAuthConnector::onTransmit,
53 .onSessionKeyReturned = HiChainAuthConnector::onSessionKeyReturned,
54 .onFinish = HiChainAuthConnector::onFinish,
55 .onError = HiChainAuthConnector::onError,
56 .onRequest = HiChainAuthConnector::onRequest};
57 LOGI("hichain GetGaInstance success.");
58 }
59
~HiChainAuthConnector()60 HiChainAuthConnector::~HiChainAuthConnector()
61 {
62 for (auto& pair : dmDeviceAuthCallbackMap_) {
63 pair.second = nullptr;
64 }
65 dmDeviceAuthCallbackMap_.clear();
66 dmDeviceAuthCallback_ = nullptr;
67 LOGI("HiChainAuthConnector::destructor.");
68 }
69
RegisterHiChainAuthCallback(std::shared_ptr<IDmDeviceAuthCallback> callback)70 int32_t HiChainAuthConnector::RegisterHiChainAuthCallback(std::shared_ptr<IDmDeviceAuthCallback> callback)
71 {
72 std::lock_guard<std::mutex> lock(dmDeviceAuthCallbackMutex_);
73 dmDeviceAuthCallback_ = callback;
74 return DM_OK;
75 }
76
UnRegisterHiChainAuthCallback()77 int32_t HiChainAuthConnector::UnRegisterHiChainAuthCallback()
78 {
79 std::lock_guard<std::mutex> lock(dmDeviceAuthCallbackMutex_);
80 dmDeviceAuthCallback_ = nullptr;
81 return DM_OK;
82 }
83
84 // 当前id为tokenId对应生成的requestId
RegisterHiChainAuthCallbackById(int64_t id,std::shared_ptr<IDmDeviceAuthCallback> callback)85 int32_t HiChainAuthConnector::RegisterHiChainAuthCallbackById(int64_t id,
86 std::shared_ptr<IDmDeviceAuthCallback> callback)
87 {
88 std::lock_guard<std::mutex> lock(dmDeviceAuthCallbackMutex_);
89 dmDeviceAuthCallbackMap_[id] = callback;
90 return DM_OK;
91 }
92
UnRegisterHiChainAuthCallbackById(int64_t id)93 int32_t HiChainAuthConnector::UnRegisterHiChainAuthCallbackById(int64_t id)
94 {
95 std::lock_guard<std::mutex> lock(dmDeviceAuthCallbackMutex_);
96 if (dmDeviceAuthCallbackMap_.find(id) != dmDeviceAuthCallbackMap_.end()) {
97 dmDeviceAuthCallbackMap_[id] = nullptr;
98 }
99 return DM_OK;
100 }
101
GetDeviceAuthCallback(int64_t id)102 std::shared_ptr<IDmDeviceAuthCallback> HiChainAuthConnector::GetDeviceAuthCallback(int64_t id)
103 {
104 if (dmDeviceAuthCallbackMap_.find(id) != dmDeviceAuthCallbackMap_.end()) {
105 LOGD("dmDeviceAuthCallbackMap_ id: %{public}" PRId64 ".", id);
106 return dmDeviceAuthCallbackMap_[id];
107 }
108 LOGD("dmDeviceAuthCallbackMap_ not found, id: %{public}"
109 PRId64 ".", id);
110 // If the callback registered by the new protocol ID cannot be found, the callback registered
111 // by the old protocol is used. However, the old protocol callback may be empty.
112 return dmDeviceAuthCallback_;
113 }
114
AuthDevice(const std::string & pinCode,int32_t osAccountId,std::string udid,int64_t requestId)115 int32_t HiChainAuthConnector::AuthDevice(const std::string &pinCode, int32_t osAccountId, std::string udid,
116 int64_t requestId)
117 {
118 std::string pinCodeHash = GetAnonyString(Crypto::Sha256(pinCode));
119 LOGI("AuthDevice pinCodeHash: %{public}s", pinCodeHash.c_str());
120 JsonObject authParamJson;
121 authParamJson["osAccountId"] = osAccountId;
122 authParamJson["pinCode"] = pinCode;
123 authParamJson["acquireType"] = AcquireType::P2P_BIND;
124 std::string authParam = authParamJson.Dump();
125 LOGI("StartAuthDevice authParam %{public}s ,requestId %{public}" PRId64, GetAnonyString(authParam).c_str(),
126 requestId);
127 int32_t ret = StartAuthDevice(requestId, authParam.c_str(), &deviceAuthCallback_);
128 if (ret != HC_SUCCESS) {
129 LOGE("Hichain authDevice failed, ret is %{public}d.", ret);
130 return ERR_DM_FAILED;
131 }
132 return DM_OK;
133 }
134
ProcessAuthData(int64_t requestId,std::string authData,int32_t osAccountId)135 int32_t HiChainAuthConnector::ProcessAuthData(int64_t requestId, std::string authData, int32_t osAccountId)
136 {
137 LOGI("start.");
138 JsonObject jsonAuthParam;
139 jsonAuthParam["osAccountId"] = osAccountId;
140 jsonAuthParam["data"] = authData;
141 int32_t ret = ProcessAuthDevice(requestId, jsonAuthParam.Dump().c_str(), &deviceAuthCallback_);
142 if (ret != HC_SUCCESS) {
143 LOGE("Hichain processData failed ret %{public}d.", ret);
144 return ERR_DM_FAILED;
145 }
146 return DM_OK;
147 }
148
ProcessCredData(int64_t authReqId,const std::string & data)149 int32_t HiChainAuthConnector::ProcessCredData(int64_t authReqId, const std::string &data)
150 {
151 LOGI("start.");
152 const CredAuthManager *credAuthManager = GetCredAuthInstance();
153 int32_t ret = credAuthManager->processCredData(authReqId, reinterpret_cast<const uint8_t *>(data.c_str()),
154 data.length(), &deviceAuthCallback_);
155 if (ret != HC_SUCCESS) {
156 LOGE("Hichain processData failed ret %{public}d.", ret);
157 return ERR_DM_FAILED;
158 }
159 return DM_OK;
160 }
161
AddCredential(int32_t osAccountId,const std::string & authParams,std::string & credId)162 int32_t HiChainAuthConnector::AddCredential(int32_t osAccountId, const std::string &authParams, std::string &credId)
163 {
164 char *returnData = NULL;
165 const CredManager *credManager = GetCredMgrInstance();
166 int32_t ret = credManager->addCredential(osAccountId, authParams.c_str(), &returnData);
167 if (ret != HC_SUCCESS || returnData == NULL) {
168 LOGE("Hichain addCredential failed ret %{public}d.", ret);
169 return ERR_DM_FAILED;
170 }
171 LOGI("success ret=%{public}d, returnData=%{public}s.", ret, GetAnonyString(returnData).c_str());
172 credId = std::string(returnData);
173 credManager->destroyInfo(&returnData);
174 return DM_OK;
175 }
176
ExportCredential(int32_t osAccountId,const std::string & credId,std::string & publicKey)177 int32_t HiChainAuthConnector::ExportCredential(int32_t osAccountId, const std::string &credId, std::string &publicKey)
178 {
179 LOGI("start. osAccountId=%{public}d, credId=%{public}s", osAccountId, GetAnonyString(credId).c_str());
180 char *returnData = NULL;
181 const CredManager *credManager = GetCredMgrInstance();
182 int32_t ret = credManager->exportCredential(osAccountId, credId.c_str(), &returnData);
183 if (ret != HC_SUCCESS || returnData == NULL) {
184 LOGE("Hichain exportCredential failed ret %{public}d.", ret);
185 return ERR_DM_FAILED;
186 }
187
188 JsonObject jsonAuthParam(returnData);
189 credManager->destroyInfo(&returnData);
190 if (jsonAuthParam.IsDiscarded() || !jsonAuthParam["keyValue"].IsString()) {
191 LOGE("Hichain exportCredential failed, returnData is invalid.");
192 return ERR_DM_FAILED;
193 }
194
195 publicKey = jsonAuthParam["keyValue"].Get<std::string>();
196 return DM_OK;
197 }
198
AgreeCredential(int32_t osAccountId,const std::string selfCredId,const std::string & authParams,std::string & credId)199 int32_t HiChainAuthConnector::AgreeCredential(int32_t osAccountId, const std::string selfCredId,
200 const std::string &authParams, std::string &credId)
201 {
202 LOGI("start.");
203 char *returnData = NULL;
204 const CredManager *credManager = GetCredMgrInstance();
205 int32_t ret = credManager->agreeCredential(osAccountId, selfCredId.c_str(), authParams.c_str(), &returnData);
206 if (ret != HC_SUCCESS || returnData == NULL) {
207 LOGE("Hichain agreeCredential failed ret %{public}d.", ret);
208 return ERR_DM_FAILED;
209 }
210 credId = returnData;
211 credManager->destroyInfo(&returnData);
212 LOGI("leave agreeCredId=%{public}s.", GetAnonyString(credId).c_str());
213 return DM_OK;
214 }
215
DeleteCredential(int32_t osAccountId,const std::string & credId)216 int32_t HiChainAuthConnector::DeleteCredential(int32_t osAccountId, const std::string &credId)
217 {
218 LOGI("start. osAccountId=%{public}s, credId=%{public}s", GetAnonyInt32(osAccountId).c_str(),
219 GetAnonyString(credId).c_str());
220 const CredManager *credManager = GetCredMgrInstance();
221 int32_t ret = credManager->deleteCredential(osAccountId, credId.c_str());
222 if (ret != HC_SUCCESS) {
223 LOGE("Hichain deleteCredential failed ret %{public}d.", ret);
224 return ERR_DM_FAILED;
225 }
226 return DM_OK;
227 }
228
AuthCredential(int32_t osAccountId,int64_t authReqId,const std::string & credId,const std::string & pinCode)229 int32_t HiChainAuthConnector::AuthCredential(int32_t osAccountId, int64_t authReqId, const std::string &credId,
230 const std::string &pinCode)
231 {
232 LOGI("start. osAccountId=%{public}s, credId=%{public}s", GetAnonyInt32(osAccountId).c_str(),
233 GetAnonyString(credId).c_str());
234 if (credId.empty() && pinCode.empty()) {
235 LOGE("HiChainAuthConnector::AuthCredential failed, credId and pinCode is empty.");
236 return ERR_DM_FAILED;
237 }
238
239 JsonObject jsonAuthParam;
240 if (!credId.empty()) {
241 jsonAuthParam["credId"] = credId;
242 }
243 if (!pinCode.empty()) {
244 jsonAuthParam["pinCode"] = pinCode;
245 }
246 std::string authParams = jsonAuthParam.Dump();
247
248 const CredAuthManager *credAuthManager = GetCredAuthInstance();
249 int32_t ret = credAuthManager->authCredential(osAccountId, authReqId, authParams.c_str(), &deviceAuthCallback_);
250 if (ret != HC_SUCCESS) {
251 LOGE("HiChainAuthConnector::AuthCredential failed ret %{public}d.", ret);
252 return ERR_DM_FAILED;
253 }
254 return DM_OK;
255 }
256
AuthCredentialPinCode(int32_t osAccountId,int64_t authReqId,const std::string & pinCode)257 int32_t HiChainAuthConnector::AuthCredentialPinCode(int32_t osAccountId, int64_t authReqId, const std::string &pinCode)
258 {
259 std::string pinCodeHash = GetAnonyString(Crypto::Sha256(pinCode));
260 LOGI("AuthCredentialPinCode pinCodeHash: %{public}s", pinCodeHash.c_str());
261 if (static_cast<int32_t>(pinCode.size()) < MIN_PINCODE_SIZE) {
262 LOGE("HiChainAuthConnector::AuthCredentialPinCode failed, pinCode size is %{public}zu.", pinCode.size());
263 return ERR_DM_FAILED;
264 }
265
266 JsonObject jsonAuthParam;
267
268 jsonAuthParam[FIELD_PIN_CODE] = pinCode;
269 jsonAuthParam[FIELD_SERVICE_PKG_NAME] = std::string(DM_PKG_NAME);
270
271 std::string authParams = jsonAuthParam.Dump();
272
273 const CredAuthManager *credAuthManager = GetCredAuthInstance();
274 int32_t ret = credAuthManager->authCredential(osAccountId, authReqId, authParams.c_str(), &deviceAuthCallback_);
275 if (ret != HC_SUCCESS) {
276 LOGE("HiChainAuthConnector::AuthCredential failed ret %{public}d.", ret);
277 return ERR_DM_FAILED;
278 }
279
280 return DM_OK;
281 }
282
onTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)283 bool HiChainAuthConnector::onTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
284 {
285 LOGI("AuthDevice onTransmit, requestId %{public}" PRId64, requestId);
286 auto dmDeviceAuthCallback = GetDeviceAuthCallback(requestId);
287 if (dmDeviceAuthCallback == nullptr) {
288 LOGE("HiChainAuthConnector::onTransmit dmDeviceAuthCallback_ is nullptr.");
289 return false;
290 }
291 return dmDeviceAuthCallback->AuthDeviceTransmit(requestId, data, dataLen);
292 }
293
onRequest(int64_t requestId,int operationCode,const char * reqParams)294 char *HiChainAuthConnector::onRequest(int64_t requestId, int operationCode, const char *reqParams)
295 {
296 LOGI("start.");
297 auto dmDeviceAuthCallback = GetDeviceAuthCallback(requestId);
298 if (dmDeviceAuthCallback == nullptr) {
299 LOGE("HiChainAuthConnector::onRequest dmDeviceAuthCallback_ is nullptr.");
300 return nullptr;
301 }
302 return dmDeviceAuthCallback->AuthDeviceRequest(requestId, operationCode, reqParams);
303 }
304
onFinish(int64_t requestId,int operationCode,const char * returnData)305 void HiChainAuthConnector::onFinish(int64_t requestId, int operationCode, const char *returnData)
306 {
307 LOGI("reqId:%{public}" PRId64 ", operation:%{public}d.",
308 requestId, operationCode);
309 (void)returnData;
310 auto dmDeviceAuthCallback = GetDeviceAuthCallback(requestId);
311 if (dmDeviceAuthCallback == nullptr) {
312 LOGE("HiChainAuthConnector::onFinish dmDeviceAuthCallback_ is nullptr.");
313 return;
314 }
315 dmDeviceAuthCallback->AuthDeviceFinish(requestId);
316 }
317
onError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)318 void HiChainAuthConnector::onError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
319 {
320 LOGI("reqId:%{public}" PRId64 ", operation:%{public}d, errorCode:%{public}d.",
321 requestId, operationCode, errorCode);
322 (void)operationCode;
323 (void)errorReturn;
324 auto dmDeviceAuthCallback = GetDeviceAuthCallback(requestId);
325 if (dmDeviceAuthCallback == nullptr) {
326 LOGE("HiChainAuthConnector::onError dmDeviceAuthCallback_ is nullptr.");
327 return;
328 }
329 int32_t dmErrorCode = ERR_DM_FAILED;
330 if (errorCode == PROOF_MISMATCH) {
331 dmErrorCode = ERR_DM_HICHAIN_PROOFMISMATCH;
332 }
333 dmDeviceAuthCallback->AuthDeviceError(requestId, dmErrorCode);
334 }
335
onSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)336 void HiChainAuthConnector::onSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
337 {
338 LOGI("start.");
339 auto dmDeviceAuthCallback = GetDeviceAuthCallback(requestId);
340 if (dmDeviceAuthCallback == nullptr) {
341 LOGE("HiChainAuthConnector::onSessionKeyReturned dmDeviceAuthCallback_ is nullptr.");
342 return;
343 }
344 dmDeviceAuthCallback->AuthDeviceSessionKey(requestId, sessionKey, sessionKeyLen);
345 }
346
GenerateCredential(std::string & localUdid,int32_t osAccountId,std::string & publicKey)347 int32_t HiChainAuthConnector::GenerateCredential(std::string &localUdid, int32_t osAccountId, std::string &publicKey)
348 {
349 LOGI("start.");
350 JsonObject jsonObj;
351 jsonObj["osAccountId"] = osAccountId;
352 jsonObj["deviceId"] = localUdid;
353 jsonObj["acquireType"] = AcquireType::P2P_BIND;
354 jsonObj["flag"] = 1;
355 std::string requestParam = jsonObj.Dump();
356 char *returnData = nullptr;
357 if (ProcessCredential(CRED_OP_CREATE, requestParam.c_str(), &returnData) != HC_SUCCESS) {
358 LOGE("Hichain generate credential failed.");
359 FreeJsonString(returnData);
360 return ERR_DM_FAILED;
361 }
362 std::string returnDataStr = static_cast<std::string>(returnData);
363 FreeJsonString(returnData);
364 JsonObject jsonObject(returnDataStr);
365 if (jsonObject.IsDiscarded()) {
366 LOGE("Decode generate return data jsonStr error.");
367 return ERR_DM_FAILED;
368 }
369 if (!IsString(jsonObject, "publicKey")) {
370 LOGE("Hichain generate public key jsonObject invalied.");
371 return ERR_DM_FAILED;
372 }
373 publicKey = jsonObject["publicKey"].Get<std::string>();
374 return DM_OK;
375 }
376
QueryCredentialInfo(int32_t userId,const JsonObject & queryParams,JsonObject & resultJson)377 int32_t HiChainAuthConnector::QueryCredentialInfo(int32_t userId, const JsonObject &queryParams,
378 JsonObject &resultJson)
379 {
380 int32_t ret;
381
382 const CredManager *cm = GetCredMgrInstance();
383 char *credIdList = nullptr;
384 ret = cm->queryCredentialByParams(userId, queryParams.Dump().c_str(), &credIdList);
385 if (ret != DM_OK) {
386 LOGE("HiChainAuthConnector::QueryCredentialInfo fail to query credential id list with ret %{public}d.", ret);
387 FreeJsonString(credIdList);
388 return ERR_DM_FAILED;
389 }
390 JsonObject credIdListJson(credIdList);
391 FreeJsonString(credIdList);
392 if (credIdListJson.IsDiscarded()) {
393 LOGE("HiChainAuthConnector::QueryCredentialInfo credential id list to jsonStr error");
394 return ERR_DM_FAILED;
395 }
396
397 for (const auto& element : credIdListJson.Items()) {
398 if (!element.IsString()) {
399 continue;
400 }
401 std::string credId = element.Get<std::string>();
402
403 char *returnCredInfo = nullptr;
404 ret = cm->queryCredInfoByCredId(userId, credId.c_str(), &returnCredInfo);
405 if (ret != DM_OK) {
406 LOGE("HiChainAuthConnector::QueryCredentialInfo fail to query credential info.");
407 FreeJsonString(returnCredInfo);
408 return ERR_DM_FAILED;
409 }
410 JsonObject credInfoJson(returnCredInfo);
411 FreeJsonString(returnCredInfo);
412 if (credInfoJson.IsDiscarded()) {
413 LOGE("HiChainAuthConnector::QueryCredentialInfo credential info jsonStr error");
414 return ERR_DM_FAILED;
415 }
416
417 resultJson.Insert(credId, credInfoJson);
418 }
419
420 return DM_OK;
421 }
422
QueryCredInfoByCredId(int32_t userId,std::string credId,JsonObject & resultJson)423 int32_t HiChainAuthConnector::QueryCredInfoByCredId(int32_t userId, std::string credId, JsonObject &resultJson)
424 {
425 const CredManager *cm = GetCredMgrInstance();
426 char *returnCredInfo = nullptr;
427 int32_t ret = cm->queryCredInfoByCredId(userId, credId.c_str(), &returnCredInfo);
428 if (ret != DM_OK) {
429 LOGE("[HICHAIN]::QueryCredInfoByCredId failed, ret: %{public}d.", ret);
430 FreeJsonString(returnCredInfo);
431 return ret;
432 }
433 JsonObject credInfoJson(returnCredInfo);
434 FreeJsonString(returnCredInfo);
435 if (credInfoJson.IsDiscarded()) {
436 LOGE("QueryCredInfoByCredId credential info jsonStr error");
437 return ERR_DM_FAILED;
438 }
439 resultJson.Insert(credId, credInfoJson);
440 return DM_OK;
441 }
442
QueryCredential(std::string & localUdid,int32_t osAccountId,int32_t peerOsAccountId)443 bool HiChainAuthConnector::QueryCredential(std::string &localUdid, int32_t osAccountId, int32_t peerOsAccountId)
444 {
445 LOGI("start, deviceId: %{public}s, peerOsAccountId: %{public}s",
446 GetAnonyString(localUdid).c_str(), GetAnonyInt32(peerOsAccountId).c_str());
447 JsonObject jsonObj;
448 jsonObj["osAccountId"] = osAccountId;
449 jsonObj["peerOsAccountId"] = peerOsAccountId;
450 jsonObj["deviceId"] = localUdid;
451 jsonObj["acquireType"] = AcquireType::P2P_BIND;
452 jsonObj["flag"] = 1;
453 std::string requestParam = jsonObj.Dump();
454 char *returnData = nullptr;
455 if (ProcessCredential(CRED_OP_QUERY, requestParam.c_str(), &returnData) != HC_SUCCESS) {
456 LOGE("Hichain query credential failed.");
457 FreeJsonString(returnData);
458 return false;
459 }
460 std::string returnDataStr = static_cast<std::string>(returnData);
461 FreeJsonString(returnData);
462 JsonObject jsonObject(returnDataStr);
463 if (jsonObject.IsDiscarded()) {
464 LOGE("Decode query return data jsonStr error.");
465 return false;
466 }
467 if (!IsString(jsonObject, "publicKey")) {
468 LOGI("Credential not exist.");
469 return false;
470 }
471 return true;
472 }
473
GetCredential(std::string & localUdid,int32_t osAccountId,std::string & publicKey)474 int32_t HiChainAuthConnector::GetCredential(std::string &localUdid, int32_t osAccountId, std::string &publicKey)
475 {
476 LOGI("start");
477 JsonObject jsonObj;
478 jsonObj["osAccountId"] = osAccountId;
479 jsonObj["deviceId"] = localUdid;
480 jsonObj["acquireType"] = AcquireType::P2P_BIND;
481 jsonObj["flag"] = 1;
482 std::string requestParam = jsonObj.Dump();
483 char *returnData = nullptr;
484 if (ProcessCredential(CRED_OP_QUERY, requestParam.c_str(), &returnData) != HC_SUCCESS) {
485 LOGE("Hichain query credential failed.");
486 FreeJsonString(returnData);
487 return ERR_DM_FAILED;
488 }
489 std::string returnDataStr = static_cast<std::string>(returnData);
490 FreeJsonString(returnData);
491 JsonObject jsonObject(returnDataStr);
492 if (jsonObject.IsDiscarded()) {
493 LOGE("Decode query return data jsonStr error.");
494 return ERR_DM_FAILED;
495 }
496 if (!IsString(jsonObject, "publicKey")) {
497 LOGI("Credential not exist.");
498 return ERR_DM_FAILED;
499 }
500 publicKey = jsonObject["publicKey"].Get<std::string>();
501 return DM_OK;
502 }
503
ImportCredential(int32_t osAccountId,int32_t peerOsAccountId,std::string deviceId,std::string publicKey)504 int32_t HiChainAuthConnector::ImportCredential(int32_t osAccountId, int32_t peerOsAccountId, std::string deviceId,
505 std::string publicKey)
506 {
507 LOGI("start, deviceId: %{public}s, peerOsAccountId: %{public}s",
508 GetAnonyString(deviceId).c_str(), GetAnonyInt32(peerOsAccountId).c_str());
509 JsonObject jsonObj;
510 jsonObj["osAccountId"] = osAccountId;
511 jsonObj["peerOsAccountId"] = peerOsAccountId;
512 jsonObj["deviceId"] = deviceId;
513 jsonObj["acquireType"] = AcquireType::P2P_BIND;
514 jsonObj["publicKey"] = publicKey;
515 std::string requestParam = jsonObj.Dump();
516 char *returnData = nullptr;
517 if (ProcessCredential(CRED_OP_IMPORT, requestParam.c_str(), &returnData) != HC_SUCCESS) {
518 LOGE("Hichain query credential failed.");
519 FreeJsonString(returnData);
520 return ERR_DM_FAILED;
521 }
522 FreeJsonString(returnData);
523 return DM_OK;
524 }
525
DeleteCredential(const std::string & deviceId,int32_t userId,int32_t peerUserId)526 int32_t HiChainAuthConnector::DeleteCredential(const std::string &deviceId, int32_t userId, int32_t peerUserId)
527 {
528 LOGI("start, deviceId: %{public}s, peerUserId: %{public}d",
529 GetAnonyString(deviceId).c_str(), peerUserId);
530 JsonObject jsonObj;
531 jsonObj["deviceId"] = deviceId;
532 jsonObj["acquireType"] = AcquireType::P2P_BIND;
533 jsonObj["osAccountId"] = userId;
534 jsonObj["peerOsAccountId"] = peerUserId;
535 std::string requestParam = jsonObj.Dump();
536 char *returnData = nullptr;
537 if (ProcessCredential(CRED_OP_DELETE, requestParam.c_str(), &returnData) != HC_SUCCESS) {
538 LOGE("Hichain query credential failed.");
539 FreeJsonString(returnData);
540 return ERR_DM_FAILED;
541 }
542 FreeJsonString(returnData);
543 return DM_OK;
544 }
545
AddTokensToCredential(const std::string & credId,int32_t userId,std::vector<std::string> & tokenIds)546 int32_t HiChainAuthConnector::AddTokensToCredential(const std::string &credId, int32_t userId,
547 std::vector<std::string> &tokenIds)
548 {
549 const CredManager *cm = GetCredMgrInstance();
550 if (cm == nullptr) {
551 LOGE("cm is null.");
552 return ERR_DM_FAILED;
553 }
554 char *returnCredInfo = nullptr;
555 int32_t ret = cm->queryCredInfoByCredId(userId, credId.c_str(), &returnCredInfo);
556 if (ret != DM_OK) {
557 FreeCharArray(returnCredInfo);
558 LOGE("[HICHAIN]::QueryCredInfoByCredId failed, ret: %{public}d.", ret);
559 return ret;
560 }
561 JsonObject credInfoJson(returnCredInfo);
562 FreeCharArray(returnCredInfo);
563 if (credInfoJson.IsDiscarded()) {
564 LOGE("QueryCredInfoByCredId credential info jsonStr error");
565 return ERR_DM_FAILED;
566 }
567 std::vector<std::string> appList;
568 if (credInfoJson.Contains(FIELD_AUTHORIZED_APP_LIST)) {
569 credInfoJson[FIELD_AUTHORIZED_APP_LIST].Get(appList);
570 }
571 appList.insert(appList.end(), tokenIds.begin(), tokenIds.end());
572 JsonObject jsonObj;
573 jsonObj[FIELD_AUTHORIZED_APP_LIST] = appList;
574 ret = cm->updateCredInfo(userId, credId.c_str(), jsonObj.Dump().c_str());
575 if (ret != DM_OK) {
576 LOGE("[HICHAIN]::updateCredInfo failed, ret: %{public}d.", ret);
577 return ret;
578 }
579 return DM_OK;
580 }
581
UpdateCredential(const std::string & credId,int32_t userId,std::vector<std::string> & tokenIds)582 int32_t HiChainAuthConnector::UpdateCredential(const std::string &credId, int32_t userId,
583 std::vector<std::string> &tokenIds)
584 {
585 const CredManager *cm = GetCredMgrInstance();
586 if (cm == nullptr) {
587 LOGE("cm is null.");
588 return ERR_DM_FAILED;
589 }
590 char *returnCredInfo = nullptr;
591 int32_t ret = cm->queryCredInfoByCredId(userId, credId.c_str(), &returnCredInfo);
592 if (ret != DM_OK) {
593 FreeCharArray(returnCredInfo);
594 LOGE("[HICHAIN]::QueryCredInfoByCredId failed, ret: %{public}d.", ret);
595 return ret;
596 }
597 JsonObject credInfoJson(returnCredInfo);
598 FreeCharArray(returnCredInfo);
599 if (credInfoJson.IsDiscarded()) {
600 LOGE("QueryCredInfoByCredId credential info jsonStr error");
601 return ERR_DM_FAILED;
602 }
603 JsonObject jsonObj;
604 jsonObj[FIELD_AUTHORIZED_APP_LIST] = tokenIds;
605 ret = cm->updateCredInfo(userId, credId.c_str(), jsonObj.Dump().c_str());
606 if (ret != DM_OK) {
607 LOGE("[HICHAIN]::updateCredInfo failed, ret: %{public}d.", ret);
608 return ret;
609 }
610 return DM_OK;
611 }
612 } // namespace DistributedHardware
613 } // namespace OHOS
614