diff --git a/frameworks/crypto_operation/sm2_crypto_util.c b/frameworks/crypto_operation/sm2_crypto_util.c
index a28cece0b31016348193ac5e23cd3dab407a63f1..88ef81ce479b1d11b58027bd52a353bb5c512093 100644
--- a/frameworks/crypto_operation/sm2_crypto_util.c
+++ b/frameworks/crypto_operation/sm2_crypto_util.c
@@ -105,6 +105,10 @@ HcfResult HcfGenCipherTextBySpec(Sm2CipherTextSpec *spec, const char *mode, HcfB
         return HCF_INVALID_PARAMS;
     }
     HcfSm2SpecToASN1CreateFunc createFunc = FindAbility(mode);
+    if (createFunc == NULL) {
+        LOGE("Failed to find create function");
+        return HCF_INVALID_PARAMS;
+    }
     HcfResult res = createFunc(spec, output);
     if (res != HCF_SUCCESS) {
         LOGE("Failed to convert construct to asn1!");
diff --git a/frameworks/native/include/native_common.h b/frameworks/native/include/native_common.h
index 03c924c1ff14168d2f82d6913fe8bd1871e86352..a324e2e620a91ab5d33094bb9c35b2518d4baef8 100644
--- a/frameworks/native/include/native_common.h
+++ b/frameworks/native/include/native_common.h
@@ -27,10 +27,8 @@ OH_Crypto_ErrCode GetOhCryptoErrCode(HcfResult errCode);
 OH_Crypto_ErrCode GetOhCryptoErrCodeNew(HcfResult errCode);
 
 void ReverseUint8Arr(uint8_t *data, size_t len);
-int32_t bigEndianArrToInt32(const uint8_t *data, size_t len);
-void Int32TobigEndianArr(int32_t value, uint8_t *data, size_t len);
-int32_t bigEndianArrToInt(const uint8_t *data, size_t len);
-void IntTobigEndianArr(int value, uint8_t *data, size_t len);
+uint32_t BigEndianArrToUint32(const uint8_t *data, size_t len);
+void Uint32TobigEndianArr(uint32_t value, uint8_t *data, size_t len);
 #ifdef __cplusplus
 }
 #endif
diff --git a/frameworks/native/src/asym_key.c b/frameworks/native/src/asym_key.c
index 55494d5255a5caabed1d7d59653172798a3cdcd8..fd4037932992a69b430ce016459bfcd44ccbefdf 100644
--- a/frameworks/native/src/asym_key.c
+++ b/frameworks/native/src/asym_key.c
@@ -861,7 +861,11 @@ static OH_Crypto_ErrCode SetEccCommSpec(HcfEccCommParamsSpec *spec, CryptoAsymKe
             if (value->len != sizeof(spec->h)) {
                 return CRYPTO_PARAMETER_CHECK_FAILED;
             }
-            spec->h = bigEndianArrToInt32(value->data, value->len);
+            uint32_t tmp = BigEndianArrToUint32(value->data, value->len);
+            if (tmp > INT32_MAX) {
+                return CRYPTO_PARAMETER_CHECK_FAILED;
+            }
+            spec->h = (int32_t)tmp;
             break;
         default:
             return CRYPTO_PARAMETER_CHECK_FAILED;
@@ -936,7 +940,11 @@ static OH_Crypto_ErrCode SetDhCommSpec(HcfDhCommParamsSpec *spec, CryptoAsymKey_
             if (value->len != sizeof(spec->length)) {
                 return CRYPTO_PARAMETER_CHECK_FAILED;
             }
-            spec->length = bigEndianArrToInt(value->data, value->len);
+            uint32_t tmp = BigEndianArrToUint32(value->data, value->len);
+            if (tmp > INT32_MAX) {
+                return CRYPTO_PARAMETER_CHECK_FAILED;
+            }
+            spec->length = (int)tmp;
             break;
         default:
             return CRYPTO_PARAMETER_CHECK_FAILED;
@@ -1309,7 +1317,13 @@ static OH_Crypto_ErrCode GetEccCommSpec(HcfEccCommParamsSpec *spec, CryptoAsymKe
                 return CRYPTO_MEMORY_ERROR;
             }
             value->len = sizeof(spec->h);
-            Int32TobigEndianArr(spec->h, value->data, value->len);
+            if (spec->h < 0) {
+                HcfFree(value->data);
+                value->data = NULL;
+                return CRYPTO_PARAMETER_CHECK_FAILED;
+            }
+            uint32_t tmp = (uint32_t)spec->h;
+            Uint32TobigEndianArr(tmp, value->data, value->len);
             break;
         default:
             return CRYPTO_PARAMETER_CHECK_FAILED;
@@ -1386,7 +1400,13 @@ static OH_Crypto_ErrCode GetDhCommSpec(HcfDhCommParamsSpec *spec, CryptoAsymKey_
                 return CRYPTO_MEMORY_ERROR;
             }
             value->len = sizeof(spec->length);
-            IntTobigEndianArr(spec->length, value->data, value->len);
+            if (spec->length < 0) {
+                HcfFree(value->data);
+                value->data = NULL;
+                return CRYPTO_PARAMETER_CHECK_FAILED;
+            }
+            uint32_t tmp = (uint32_t)spec->length;
+            Uint32TobigEndianArr(tmp, value->data, value->len);
             break;
         default:
             return CRYPTO_PARAMETER_CHECK_FAILED;
diff --git a/frameworks/native/src/native_common.c b/frameworks/native/src/native_common.c
index 62b7fd3da093a1ed09dc4bcffe06188e5658be7c..a92b10acdd4c398e623d99c47711b8f3992c3f0d 100644
--- a/frameworks/native/src/native_common.c
+++ b/frameworks/native/src/native_common.c
@@ -58,36 +58,19 @@ void ReverseUint8Arr(uint8_t *data, size_t len)
 
 #define NATIVE_BITS_SIZE 8
 
-int32_t bigEndianArrToInt32(const uint8_t *data, size_t len)
+uint32_t BigEndianArrToUint32(const uint8_t *data, size_t len)
 {
-    int32_t value = 0;
+    uint32_t value = 0;
 
     for (size_t i = 0; i < len; ++i) {
-        value |= (int32_t)(data[i] << ((sizeof(int32_t) - 1 - i) * NATIVE_BITS_SIZE));
+        value |= (uint32_t)(data[i] << ((sizeof(int32_t) - 1 - i) * NATIVE_BITS_SIZE));
     }
     return value;
 }
 
-void Int32TobigEndianArr(int32_t value, uint8_t *data, size_t len)
+void Uint32TobigEndianArr(uint32_t value, uint8_t *data, size_t len)
 {
     for (size_t i = 0; i < len; ++i) {
-        data[i] = (value >> ((sizeof(int32_t) - i - 1) * NATIVE_BITS_SIZE)) & 0xFF;
-    }
-}
-
-int32_t bigEndianArrToInt(const uint8_t *data, size_t len)
-{
-    int value = 0;
-
-    for (size_t i = 0; i < len; ++i) {
-        value |= (int)(data[i] << ((sizeof(int) - 1 - i) * NATIVE_BITS_SIZE));
-    }
-    return value;
-}
-
-void IntTobigEndianArr(int value, uint8_t *data, size_t len)
-{
-    for (size_t i = 0; i < len; ++i) {
-        data[i] = (value >> ((sizeof(int) - i - 1) * NATIVE_BITS_SIZE)) & 0xFF;
+        data[i] = (value >> ((sizeof(uint32_t) - i - 1) * NATIVE_BITS_SIZE)) & 0xFF;
     }
 }
diff --git a/plugin/openssl_plugin/crypto_operation/kdf/src/scrypt_openssl.c b/plugin/openssl_plugin/crypto_operation/kdf/src/scrypt_openssl.c
index 38fda9d20919d6d673ba0889f242dcc46402b2c5..413419d44f87f53f1ad7309b463d8d308253ac5f 100644
--- a/plugin/openssl_plugin/crypto_operation/kdf/src/scrypt_openssl.c
+++ b/plugin/openssl_plugin/crypto_operation/kdf/src/scrypt_openssl.c
@@ -128,7 +128,7 @@ static bool GetScryptSaltFromSpec(HcfScryptData *data, HcfScryptParamsSpec *para
         return false;
     }
     (void)memcpy_s(data->salt, params->salt.len, params->salt.data, params->salt.len);
-    data->saltLen = params->salt.len;
+    data->saltLen = (int)params->salt.len;
     return true;
 }
 
@@ -140,7 +140,7 @@ static bool GetScryptPasswordFromSpec(HcfScryptData *data, HcfScryptParamsSpec *
             return false;
         }
         (void)memcpy_s(data->password, params->passPhrase.len, params->passPhrase.data, params->passPhrase.len);
-        data->passwordLen = params->passPhrase.len;
+        data->passwordLen = (int)params->passPhrase.len;
     } else {
         data->passwordLen = 0;
         data->password = NULL;
@@ -173,7 +173,7 @@ static HcfResult InitScryptData(OpensslScryptSpiImpl *self, HcfScryptParamsSpec
         data->p = params->p;
         data->r = params->r;
         data->maxBytes = params->maxMem;
-        data->outLen = params->output.len;
+        data->outLen = (int)params->output.len;
         self->kdfData = data;
         return HCF_SUCCESS;
     } while (0);
diff --git a/plugin/openssl_plugin/key/sym_key_generator/src/sym_key_openssl.c b/plugin/openssl_plugin/key/sym_key_generator/src/sym_key_openssl.c
index af635f9d0c62e1b6d7a70354854bdb5e1de22420..ab72bfad9ec75fb187f9cec6a56db395931f67a4 100644
--- a/plugin/openssl_plugin/key/sym_key_generator/src/sym_key_openssl.c
+++ b/plugin/openssl_plugin/key/sym_key_generator/src/sym_key_openssl.c
@@ -186,7 +186,7 @@ static HcfResult HcfDesSymmKeySpiCreate(int32_t keyLen, SymKeyImpl *symKey)
 
     EVP_CIPHER_CTX_free(ctx);
     symKey->keyMaterial.data = keyMaterial;
-    symKey->keyMaterial.len = keyLen;
+    symKey->keyMaterial.len = (size_t)keyLen;
     return HCF_SUCCESS;
 }