diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_code_convert.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_code_convert.cpp
index 85d181b5fc25494574619b70292d189fbe22fde6..0e670ce4db9571adb6556d72b91e779598377b19 100755
--- a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_code_convert.cpp
+++ b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_code_convert.cpp
@@ -21,7 +21,9 @@
 #include <cstdlib>
 #include <securec.h>
 #include "wifi_code_convert.h"
+#include "wifi_logger.h"
 
+DEFINE_WIFILOG_LABEL("WifiCodeConvert");
 namespace OHOS {
 namespace Wifi {
 bool WifiCodeConvertUtil::IsUtf8(const std::string &stf)
@@ -114,7 +116,10 @@ std::string WifiCodeConvertUtil::Convert(const std::string &str, const std::stri
     int32_t resultlen  = ucnv_convert(toCharset.c_str(), fromCharset.c_str(), nullptr, 0, str.c_str(),
         str.length(), &status);
     std::unique_ptr<char[]> result = std::make_unique<char[]>(resultlen + 1);
-    memset_s(result.get(), resultlen + 1, 0, resultlen + 1);
+    if (memset_s(result.get(), resultlen + 1, 0, resultlen + 1) != EOK) {
+        WIFI_LOGE("%{public}s Failed to memset_s", __func__);
+        return str;
+    }
     status = U_ZERO_ERROR;
     ucnv_convert(toCharset.c_str(), fromCharset.c_str(), result.get(), resultlen + 1,
         str.c_str(), str.length(), &status);
diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_encryption_util.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_encryption_util.cpp
index 98985a8a668e3ec1311b256310fac2b59a2140e1..e38ccac44fce5df0237856571d0a60fb1a146a48 100755
--- a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_encryption_util.cpp
+++ b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_encryption_util.cpp
@@ -100,7 +100,9 @@ int32_t WifiEncryption(const WifiEncryptionInfo &wifiEncryptionInfo, const std::
     int32_t ret = HksGenerateRandom(NULL, &randomIV);
     if (ret != HKS_SUCCESS) {
         WIFI_LOGE("wifi encryption generate IV failed");
-        (void)memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText));
+        if (memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText)) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s01", __func__);
+        }
         return ret;
     }
     struct HksParam IVParam[] = {
@@ -116,7 +118,9 @@ int32_t WifiEncryption(const WifiEncryptionInfo &wifiEncryptionInfo, const std::
     ret = GetKeyByAlias(&authId, encryParamSet);
     if (ret != HKS_SUCCESS) {
         WIFI_LOGE("wifi encryption failed");
-        (void)memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText));
+        if (memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText)) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s02", __func__);
+        }
         HksFreeParamSet(&encryParamSet);
         return ret;
     }
@@ -130,14 +134,18 @@ int32_t WifiEncryption(const WifiEncryptionInfo &wifiEncryptionInfo, const std::
     ret = HksEncrypt(&authId, encryParamSet, &plainText, &cipherData);
     if (ret != HKS_SUCCESS) {
         WIFI_LOGE("Hks encryption failed");
-        (void)memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText));
+        if (memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText)) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s03", __func__);
+        }
         HksFreeParamSet(&encryParamSet);
         return ret;
     }
 
     encryptedData.encryptedPassword = ConvertArrayToHex(cipherBuf, cipherData.size);
     encryptedData.IV = ConvertArrayToHex(nonce, NONCE_SIZE);
-    (void)memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText));
+    if (memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText)) != EOK) {
+        WIFI_LOGE("%{public}s Failed to memset_s04", __func__);
+    }
     HksFreeParamSet(&encryParamSet);
     return ret;
 }
@@ -153,7 +161,9 @@ int32_t WifiDecryption(const WifiEncryptionInfo &wifiEncryptionInfo, const Encry
     uint32_t length = AES_COMMON_SIZE;
     int32_t retStrToArrat = HexStringToVec(encryptedData.encryptedPassword, cipherBuf, AES_COMMON_SIZE, length);
     if (retStrToArrat != 0) {
-        (void)memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE);
+        if (memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s01", __func__);
+        }
         return HKS_FAILURE;
     }
 
@@ -161,7 +171,9 @@ int32_t WifiDecryption(const WifiEncryptionInfo &wifiEncryptionInfo, const Encry
     uint32_t lengthIV = NONCE_SIZE;
     retStrToArrat = HexStringToVec(encryptedData.IV, nonce, NONCE_SIZE, lengthIV);
     if (retStrToArrat != 0) {
-        (void)memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE);
+        if (memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s02", __func__);
+        }
         return HKS_FAILURE;
     }
     struct HksParam IVParam[] = {
@@ -179,7 +191,9 @@ int32_t WifiDecryption(const WifiEncryptionInfo &wifiEncryptionInfo, const Encry
     int32_t ret = HksKeyExist(&authId, decryParamSet);
     if (ret != HKS_SUCCESS) {
         WIFI_LOGE("wifi decryption key not exist");
-        (void)memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE);
+        if (memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s03", __func__);
+        }
         HksFreeParamSet(&decryParamSet);
         return ret;
     }
@@ -192,7 +206,9 @@ int32_t WifiDecryption(const WifiEncryptionInfo &wifiEncryptionInfo, const Encry
     ret = HksDecrypt(&authId, decryParamSet, &cipherData, &plainText);
     if (ret != HKS_SUCCESS) {
         WIFI_LOGE("Hks decryption failed");
-        (void)memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE);
+        if (memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s04", __func__);
+        }
         HksFreeParamSet(&decryParamSet);
         return ret;
     }
@@ -200,8 +216,10 @@ int32_t WifiDecryption(const WifiEncryptionInfo &wifiEncryptionInfo, const Encry
     std::string temp(plainText.data, plainText.data + plainText.size);
     decryptedData = temp;
     std::fill(temp.begin(), temp.end(), 0);
-    (void)memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE);
-    (void)memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText));
+    if (memset_s(cipherBuf, AES_COMMON_SIZE, 0, AES_COMMON_SIZE) != EOK ||
+        memset_s(&plainText, sizeof(plainText), 0, sizeof(plainText)) != EOK) {
+        WIFI_LOGE("%{public}s Failed to memset_s05", __func__);
+    }
     HksFreeParamSet(&decryParamSet);
     return ret;
 }
@@ -222,7 +240,9 @@ int32_t HksUpdateAndFinish(const struct HksBlob *handle, const struct HksParamSe
         outDataSeg.data = (uint8_t *)malloc(outDataSeg.size);
         if (outDataSeg.data == nullptr) {
             WIFI_LOGE("HksUpdateAndFinish malloc failed.");
-            (void)memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg));
+            if (memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg)) != EOK) {
+                WIFI_LOGE("%{public}s Failed to memset_s01", __func__);
+            }
             return HKS_FAILURE;
         }
         int32_t hksResult = 0;
@@ -233,21 +253,27 @@ int32_t HksUpdateAndFinish(const struct HksBlob *handle, const struct HksParamSe
         }
         if (hksResult != HKS_SUCCESS) {
             WIFI_LOGE("HksUpdateAndFinish do HksUpdate or HksFinish failed: %{public}d.", hksResult);
-            (void)memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg));
+            if (memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg)) != EOK) {
+                WIFI_LOGE("%{public}s Failed to memset_s02", __func__);
+            }
             free(outDataSeg.data);
             outDataSeg.data = nullptr;
             return HKS_FAILURE;
         }
         if (handledOutDataSize + outDataSeg.size > outData->size) {
             WIFI_LOGE("HksUpdateAndFinish outData->size is too small.");
-            (void)memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg));
+            if (memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg)) != EOK) {
+                WIFI_LOGE("%{public}s Failed to memset_s03", __func__);
+            }
             free(outDataSeg.data);
             outDataSeg.data = nullptr;
             return HKS_FAILURE;
         }
         if (memcpy_s(handledOutData, outDataSeg.size, outDataSeg.data, outDataSeg.size) != EOK) {
             WIFI_LOGE("HksUpdateAndFinish memcpy_s failed.");
-            (void)memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg));
+            if (memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg)) != EOK) {
+                WIFI_LOGE("%{public}s Failed to memset_s04", __func__);
+            }
             free(outDataSeg.data);
             outDataSeg.data = nullptr;
             return HKS_FAILURE;
@@ -261,7 +287,9 @@ int32_t HksUpdateAndFinish(const struct HksBlob *handle, const struct HksParamSe
     }
     outData->size = handledOutDataSize;
     WIFI_LOGI("HksUpdateAndFinish outData.size: %{public}d.", static_cast<int>(outData->size));
-    (void)memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg));
+    if (memset_s(&inDataSeg, sizeof(inDataSeg), 0, sizeof(inDataSeg)) != EOK) {
+        WIFI_LOGE("%{public}s Failed to memset_s05", __func__);
+    }
     return HKS_SUCCESS;
 }
 
@@ -289,7 +317,9 @@ int32_t ImportKey(const WifiEncryptionInfo &wifiEncryptionInfo, const std::strin
     int32_t keyExist = HksKeyExist(&authId, encryParamSet);
     if (keyExist == HKS_ERROR_NOT_EXIST) {
         int32_t ret = HksImportKey(&authId, encryParamSet, &hksKey);
-        (void)memset_s(aesKey, sizeof(aesKey), 0, sizeof(aesKey));
+        if (memset_s(aesKey, sizeof(aesKey), 0, sizeof(aesKey)) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s01", __func__);
+        }
         if (ret != HKS_SUCCESS) {
             WIFI_LOGE("ImportKey failed: %{public}d.", ret);
         }
@@ -297,12 +327,16 @@ int32_t ImportKey(const WifiEncryptionInfo &wifiEncryptionInfo, const std::strin
         return ret;
     } else if (keyExist == HKS_SUCCESS) {
         WIFI_LOGI("ImportKey key is exist, donot need import key.");
-        (void)memset_s(aesKey, sizeof(aesKey), 0, sizeof(aesKey));
+        if (memset_s(aesKey, sizeof(aesKey), 0, sizeof(aesKey)) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s02", __func__);
+        }
         HksFreeParamSet(&encryParamSet);
         return HKS_SUCCESS;
     }
     WIFI_LOGE("ImportKey HksKeyExist check failed: %{public}d.", keyExist);
-    (void)memset_s(aesKey, sizeof(aesKey), 0, sizeof(aesKey));
+    if (memset_s(aesKey, sizeof(aesKey), 0, sizeof(aesKey)) != EOK) {
+        WIFI_LOGE("%{public}s Failed to memset_s03", __func__);
+    }
     HksFreeParamSet(&encryParamSet);
     return keyExist;
 }
@@ -435,7 +469,9 @@ int32_t WifiLoopEncrypt(const WifiEncryptionInfo &wifiEncryptionInfo, const std:
     uint8_t *cipherBuf = (uint8_t *)malloc(inputString.length() + AEAD_SIZE);
     if (cipherBuf == nullptr) {
         WIFI_LOGE("WifiLoopEncrypt malloc failed.");
-        (void)memset_s(&inData, sizeof(inData), 0, sizeof(inData));
+        if (memset_s(&inData, sizeof(inData), 0, sizeof(inData)) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s01", __func__);
+        }
         HksFreeParamSet(&encryParamSet);
         return HKS_FAILURE;
     }
@@ -443,8 +479,10 @@ int32_t WifiLoopEncrypt(const WifiEncryptionInfo &wifiEncryptionInfo, const std:
     ret = HksUpdateAndFinish(&handleEncrypt, encryParamSet, &inData, &outData);
     if (ret != HKS_SUCCESS) {
         WIFI_LOGE("WifiLoopEncrypt HksUpdateAndFinish failed: %{public}d.", ret);
-        (void)memset_s(&inData, sizeof(inData), 0, sizeof(inData));
-        (void)memset_s(&outData, sizeof(outData), 0, sizeof(outData));
+        if (memset_s(&inData, sizeof(inData), 0, sizeof(inData)) != EOK ||
+            memset_s(&outData, sizeof(outData), 0, sizeof(outData)) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s02", __func__);
+        }
         HksFreeParamSet(&encryParamSet);
         free(cipherBuf);
         cipherBuf = nullptr;
@@ -454,8 +492,10 @@ int32_t WifiLoopEncrypt(const WifiEncryptionInfo &wifiEncryptionInfo, const std:
     std::string temp(outData.data, outData.data + outData.size);
     encryptedData.encryptedPassword = temp;
     std::fill(temp.begin(), temp.end(), 0);
-    (void)memset_s(&inData, sizeof(inData), 0, sizeof(inData));
-    (void)memset_s(&outData, sizeof(outData), 0, sizeof(outData));
+    if (memset_s(&inData, sizeof(inData), 0, sizeof(inData)) != EOK ||
+        memset_s(&outData, sizeof(outData), 0, sizeof(outData)) != EOK) {
+        WIFI_LOGE("%{public}s Failed to memset_s03", __func__);
+    }
     HksFreeParamSet(&encryParamSet);
     free(cipherBuf);
     cipherBuf = nullptr;
@@ -493,7 +533,9 @@ int32_t WifiLoopDecrypt(const WifiEncryptionInfo &wifiEncryptionInfo, const Encr
     uint8_t *plainBuf = (uint8_t *)malloc(cipherLength);
     if (plainBuf == nullptr) {
         WIFI_LOGE("WifiLoopDecrypt malloc failed.");
-        (void)memset_s(&inData, sizeof(inData), 0, sizeof(inData));
+        if (memset_s(&inData, sizeof(inData), 0, sizeof(inData)) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s01", __func__);
+        }
         HksFreeParamSet(&decryParamSet);
         return HKS_FAILURE;
     }
@@ -501,8 +543,10 @@ int32_t WifiLoopDecrypt(const WifiEncryptionInfo &wifiEncryptionInfo, const Encr
     ret = HksUpdateAndFinish(&handleDecrypt, decryParamSet, &inData, &outData);
     if (ret != HKS_SUCCESS) {
         WIFI_LOGE("WifiLoopDecrypt HksUpdateAndFinish failed: %{public}d.", ret);
-        (void)memset_s(&inData, sizeof(inData), 0, sizeof(inData));
-        (void)memset_s(&outData, sizeof(outData), 0, sizeof(outData));
+        if (memset_s(&inData, sizeof(inData), 0, sizeof(inData)) != EOK ||
+            memset_s(&outData, sizeof(outData), 0, sizeof(outData)) != EOK) {
+            WIFI_LOGE("%{public}s Failed to memset_s02", __func__);
+        }
         HksFreeParamSet(&decryParamSet);
         free(plainBuf);
         plainBuf = nullptr;