diff --git a/services/service/include/relationshipsyncmgr/relationship_sync_mgr.h b/services/service/include/relationshipsyncmgr/relationship_sync_mgr.h
index d0787d446100bd24d710f928f2ad4c4cd86a33fb..57900827e82936a898ee5c381422982fd36714f8 100644
--- a/services/service/include/relationshipsyncmgr/relationship_sync_mgr.h
+++ b/services/service/include/relationshipsyncmgr/relationship_sync_mgr.h
@@ -84,6 +84,8 @@ struct RelationShipChangeMsg {
     bool FromJson(const std::string &msgJson);
 
     const std::string ToString() const;
+    bool BuildCoreFields(cJSON *msg) const;
+    cJSON *BuildUdidArray() const;
 };
 
 class ReleationShipSyncMgr {
diff --git a/services/service/src/relationshipsyncmgr/relationship_sync_mgr.cpp b/services/service/src/relationshipsyncmgr/relationship_sync_mgr.cpp
index a676b056dac2e0b3fda7b1203dbfc0e7bd14d5bf..be0db4f1268d5544c66f55c6df2e403eb0a0a9fc 100644
--- a/services/service/src/relationshipsyncmgr/relationship_sync_mgr.cpp
+++ b/services/service/src/relationshipsyncmgr/relationship_sync_mgr.cpp
@@ -542,54 +542,86 @@ cJSON *RelationShipChangeMsg::ToPayLoadJson() const
     return arrayObj;
 }
 
-std::string RelationShipChangeMsg::ToJson() const
+cJSON *RelationShipChangeMsg::BuildUdidArray() const
 {
-    cJSON *msg = cJSON_CreateObject();
-    if (msg == NULL) {
-        LOGE("failed to create cjson object");
-        return "";
+    cJSON *udidArrayObj = cJSON_CreateArray();
+    if (udidArrayObj == nullptr) {
+        LOGE("cJSON_CreatArray failed");
+        return nullptr;
     }
-    cJSON_AddNumberToObject(msg, MSG_TYPE, (uint32_t)type);
+    
+    for (uint32_t index = 0; index < peerUdids.size(); index++) {
+        cJSON *udidStringObj = cJSON_CreateString(peerUdids[index].c_str());
+        if (udidStringObj == nullptr) {
+            LOGE("Create UDID string failed");
+            return nullptr;
+        }
+
+        if (!cJSON_AddItemToArray(udidArrayObj, udidStringObj)) {
+            LOGE("Add UDID to array failed");
+            cJSON_Delete(udidArrayObj);
+            cJSON_Delete(udidStringObj);
+            return nullptr;
+        }
+    }
+    return udidArrayObj;
+}
+
+bool RelationShipChangeMsg::BuildCoreFields(cJSON *msg) const
+{
+    if (!cJSON_AddNumberToObject(msg, MSG_TYPE, (uint32_t)type)) {
+        LOGE("Add type failed");
+        return false;
+    }
+
     cJSON *arrayObj = ToPayLoadJson();
     if (arrayObj == nullptr) {
-        LOGE("ArrayObj is nullptr.");
-        cJSON_Delete(msg);
-        return "";
+        LOGE("Payload is nullptr");
+        return false;
     }
-    cJSON_AddItemToObject(msg, MSG_VALUE, arrayObj);
-
-    cJSON *udidArrayObj = cJSON_CreateArray();
+    if (!cJSON_AddItemToObject(msg, MSG_VALUE, arrayObj)) {
+        LOGE("Add Payload failed");
+        cJSON_Delete(arrayObj);
+        return false;
+    }
+    cJSON *udidArrayObj = BuildUdidArray();
     if (udidArrayObj == nullptr) {
-        LOGE("cJSON_CreateArray failed");
-        cJSON_Delete(msg);
+        return false;
+    }
+    if (!cJSON_AddItemToObject(msg, MSG_PEER_UDID, udidArrayObj)) {
+        LOGE("Add UDID array failed");
         cJSON_Delete(udidArrayObj);
+        return false;
+    }
+    if (!cJSON_AddStringToObject(msg, MSG_ACCOUNTID, accountName.c_str())) {
+        LOGE("Add account ID failed");
+        return false;
+    }
+    return true;
+}
+
+std::string RelationShipChangeMsg::ToJson() const
+{
+    cJSON *msg = cJSON_CreateObject();
+    if (msg == NULL) {
+        LOGE("Creat root object failed");
         return "";
     }
-    cJSON *udidStringObj = nullptr;
-    for (uint32_t index = 0; index < peerUdids.size(); index++) {
-        udidStringObj = cJSON_CreateString(peerUdids[index].c_str());
-        if (udidStringObj == nullptr || !cJSON_AddItemToArray(udidArrayObj, udidStringObj)) {
-            cJSON_Delete(udidStringObj);
-            cJSON_Delete(udidArrayObj);
-            cJSON_Delete(msg);
-            return "";
-        }
+
+    if (!BuildCoreFields(msg)) {
+        cJSON_Delete(msg);
+        return "";
     }
-    cJSON_AddItemToObject(msg, MSG_PEER_UDID, udidArrayObj);
-    cJSON_AddStringToObject(msg, MSG_ACCOUNTID, accountName.c_str());
+    
     char *retStr = cJSON_PrintUnformatted(msg);
     if (retStr == nullptr) {
-        LOGE("to json is nullptr.");
-        cJSON_Delete(msg);
-        cJSON_Delete(udidArrayObj);
-        cJSON_Delete(udidStringObj);
+        LOGE("Generate JSON string failed");
         return "";
     }
-    std::string ret = std::string(retStr);
+
+    std::string ret(retStr);
     cJSON_Delete(msg);
     cJSON_free(retStr);
-    cJSON_Delete(udidArrayObj);
-    cJSON_Delete(udidStringObj);
     return ret;
 }
 
diff --git a/test/unittest/UTTest_crypto_mgr.cpp b/test/unittest/UTTest_crypto_mgr.cpp
index 27510007c488ce651d17688e887e1e401fab8dbe..8d2f5bffbf8a44b5aa2ef9f4d40ba468e7b13d69 100644
--- a/test/unittest/UTTest_crypto_mgr.cpp
+++ b/test/unittest/UTTest_crypto_mgr.cpp
@@ -123,5 +123,229 @@ HWTEST_F(CryptoMgrTest, EncryptAndDecryptMessage_005, testing::ext::TestSize.Lev
     cryptoMgr->DecryptMessage(encryptData, decryptData);
     EXPECT_NE(ret, DM_OK);
 }
+HWTEST_F(CryptoMgrTest, EncryptAndDecryptMessage_006, testing::ext::TestSize.Level2)
+{
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    std::string inputMsg(MAX_ENCRY_MSG_LEN + 1, 'a');
+    std::string outputMsg;
+    auto ret = cryptoMgr->EncryptMessage(inputMsg, outputMsg);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, EncryptAndDecryptMessage_007, testing::ext::TestSize.Level2)
+{
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    std::string inputMsg = "test message"
+    std::string outputMsg;
+    auto ret = cryptoMgr->EncryptMessage(inputMsg, outputMsg);
+    EXPECT_EQ(ret, DM_OK);
+}
+HWTEST_F(CryptoMgrTest, DoEncryptData_001, testing::ext::TestSize.Level1) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char input[] = "test";
+    unsigned char encryptData[1024];
+    uint32_t encryptLen;
+    int32_t ret = cryptoMgr->DoEncryptData(nullptr, input, sizeof(input) - 1, encryptData, &encryptLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, DoEncryptData_002, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char encryptData[1024];
+    uint32_t encryptLen;
+    int32_t ret = cryptoMgr->DoEncryptData(&validKey_, nullptr, 10, encryptData, &encryptLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, DoEncryptData_003, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char input[] = "test";
+    unsigned char encryptData[1024];
+    uint32_t encryptLen;
+    int32_t ret = cryptoMgr->DoEncryptData(&validKey_, input, 0, encryptData, &encryptLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, DoEncryptData_004, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char input[] = "test";
+    uint32_t encryptLen;
+    int32_t ret = cryptoMgr->DoEncryptData(&validKey_, input, sizeof(input) - 1, nullptr, &encryptLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, DoEncryptData_005, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char input[] = "test";
+    unsigned char encryptData[1024];
+    int32_t ret = cryptoMgr->DoEncryptData(&validKey_, input, sizeof(input) - 1, encryptData, nullptr);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, DoEncryptData_006, testing::ext::TestSize.Level1) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char input[2048] = {0};
+    uint32_t inLen = sizeof(input);
+    uint32_t requiredLen = inLen + OVERHEAD_LEN;
+    unsigned char encryptData[1];
+    uint32_t encryptLen = 0;
+
+    int32_t ret = cryptoMgr->DoEncryptData(&validKey_, input, inLen, encryptData, &encryptLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_OPT_FAILED);
+}
+HWTEST_F(CryptoMgrTest, DoEncryptData_007, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char input[] = "valid test message";
+    uint32_t inLen = sizeof(input) - 1;
+    uint32_t requiredLen = inLen + OVERHEAD_LEN;
+    unsigned char encryptData[requiredLen];
+    uint32_t encryptLen = 0;
+
+    int32_t ret = cryptoMgr->DoEncryptData(&validKey_, input, inLen, encryptData, &encryptLen);
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(encryptLen, requiredLen);
+}
+HWTEST_F(CryptoMgrTest, GenerateRandomArray_001, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char randStr;
+    int32_t ret = cryptoMgr->GenerateRandomArray(NULL, 10);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, GenerateRandomArray_002, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char randStr;
+    int32_t ret = cryptoMgr->GenerateRandomArray(&randStr, 0);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, GenerateRandomArray_003, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char randStr[10];
+    int32_t ret = cryptoMgr->GenerateRandomArray(randStr, 10);
+    EXPECT_EQ(ret, DM_OK);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_001, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char plain[16] = {0};
+    unsigned char cipher[64];
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(nullptr, plain, 16, cipher, 64);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_002, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char cipher[64];
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(&validKey_, nullptr, 16, cipher, 64);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_003, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char plain[16] = {0};
+    unsigned char cipher[64];
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(&validKey_, plain, 0, cipher, 64);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_004, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char plain[16] = {0};
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(&validKey_, plain, 16, nullptr, 64);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_005, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char plain[16] = {0};
+    unsigned char cipher[16];
+    int32_t ret = cryptoMgr_->MbedAesGcmEncrypt(&validKey_, plain, 16, cipher, 16);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_006, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    AesGcmCipherKey invalidKey = validKey_;
+    invalidKey.keyLen = 999; // 构造无效的密钥长度
+
+    unsigned char plain[16] = {0};
+    unsigned char cipher[64];
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(&invalidKey, plain, 16, cipher, 64);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_OPT_FAILED);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_007, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    AesGcmCipherKey invalidKey = validKey_;
+    memset(invalidKey.iv, 0, sizeof(invalidKey.iv));
+
+    unsigned char plain[16] = {0};
+    unsigned char cipher[64];
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(&invalidKey, plain, 16, cipher, 64);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_OPT_FAILED);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_008, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char plain[16] = {0};
+    unsigned char cipher[16];
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(&validKey_, plain, 0, cipher, GCM_IV_LEN - 1);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_OPT_FAILED);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_009, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char plain[16] = {0};
+    const uint32_t cipherLen = GCM_IV_LEN + 16 + TAG_LEN - 1;
+    unsigned char cipher[cipherLen];
+    
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(&validKey_, plain, 16, cipher, cipherLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_OPT_FAILED);
+}
+HWTEST_F(CryptoMgrTest, MbedAesGcmEncrypt_010, testing::ext::TestSize.Level1) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    const std::string testStr = "Hello AES-GCM!";
+    const uint32_t plainLen = testStr.length();
+    const uint32_t cipherLen = plainLen + OVERHEAD_LEN;
+
+    unsigned char cipher[cipherLen];
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(
+        &validKey_,
+        reinterpret_cast<const unsigned char*>(testStr.c_str()),
+        plainLen,
+        cipher,
+        cipherLen
+    );
+
+    EXPECT_GE(ret, plainLen);
+    EXPECT_EQ(ret, static_cast<int32_t>(cipherLen));
+    
+    EXPECT_NE(memcmp(cipher, validKey_.iv, GCM_IV_LEN), 0);
+    EXPECT_NE(memcmp(cipher + GCM_IV_LEN + plainLen, cipher + cipherLen - TAG_LEN, TAG_LEN), 0);
+}
+HWTEST_F(CryptoMgrTest, DoDecryptData_001, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char plain[16] = {0};
+    const uint32_t cipherLen = GCM_IV_LEN + 16 + TAG_LEN - 1;
+    unsigned char cipher[cipherLen];
+    
+    int32_t ret = cryptoMgr->MbedAesGcmEncrypt(&validKey_, plain, 16, cipher, cipherLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_OPT_FAILED);
+}
+HWTEST_F(CryptoMgrTest, DoDecryptData_001, testing::ext::TestSize.Level1) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char encrypted[GCM_IV_LEN + 16] = {0};
+    unsigned char output[64];
+    uint32_t outputLen;
+    int32_t ret = cryptoMgr->DoDecryptData(nullptr, encrypted, sizeof(encrypted), output, &outputLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, DoDecryptData_002, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    AesGcmCipherKey key;
+    unsigned char output[64];
+    uint32_t outputLen;
+    int32_t ret = cryptoMgr->DoDecryptData(&key, nullptr, GCM_IV_LEN, output, &outputLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, DoDecryptData_003, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char encrypted[GCM_IV_LEN - 1] = {0};
+    unsigned char output[64];
+    uint32_t outputLen;
+    int32_t ret = cryptoMgr->DoDecryptData(&validKey_, encrypted, sizeof(encrypted), output, &outputLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
+HWTEST_F(CryptoMgrTest, DoDecryptData_004, testing::ext::TestSize.Level2) {
+    auto cryptoMgr = std::make_shared<CryptoMgr>();
+    unsigned char encrypted[128] = {0};
+    uint32_t outputLen;
+    int32_t ret = cryptoMgr->DoDecryptData(&validKey_, encrypted, sizeof(encrypted), nullptr, &outputLen);
+    EXPECT_EQ(ret, ERR_DM_CRYPTO_PARA_INVALID);
+}
 } // namespace DistributedHardware
 } // namespace OHOS