diff --git a/frameworks/native/src/asym_key.c b/frameworks/native/src/asym_key.c
index 43b7d5df60c00187f32bcfd7d834321f9703b421..5f852706a16973ddeaaf2e50c3473a3f2235dbc1 100644
--- a/frameworks/native/src/asym_key.c
+++ b/frameworks/native/src/asym_key.c
@@ -152,30 +152,92 @@ OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_SetPassword(OH_CryptoAsymKeyGenerato
     return CRYPTO_SUCCESS;
 }
 
+static OH_Crypto_ErrCode ProcessPriKeyData(Crypto_DataBlob *priKeyData, char **priKeyStr)
+{
+    if (priKeyData == NULL) {
+        return CRYPTO_SUCCESS;
+    }
+    
+    *priKeyStr = (char *)HcfMalloc(priKeyData->len + 1, 0);
+    if (*priKeyStr == NULL) {
+        return CRYPTO_MEMORY_ERROR;
+    }
+    (void)memcpy_s(*priKeyStr, priKeyData->len, priKeyData->data, priKeyData->len);
+    return CRYPTO_SUCCESS;
+}
+
+static OH_Crypto_ErrCode ProcessPubKeyData(Crypto_DataBlob *pubKeyData, char **pubKeyStr)
+{
+    if (pubKeyData == NULL) {
+        return CRYPTO_SUCCESS;
+    }
+    
+    *pubKeyStr = (char *)HcfMalloc(pubKeyData->len + 1, 0);
+    if (*pubKeyStr == NULL) {
+        return CRYPTO_MEMORY_ERROR;
+    }
+    (void)memcpy_s(*pubKeyStr, pubKeyData->len, pubKeyData->data, pubKeyData->len);
+    return CRYPTO_SUCCESS;
+}
+
+static HcfResult ExecutePemConversion(OH_CryptoAsymKeyGenerator *ctx, char *pubKeyStr,
+    char *priKeyStr, OH_CryptoKeyPair **keyCtx)
+{
+    return ctx->base->convertPemKey == NULL ? HCF_INVALID_PARAMS :
+        ctx->base->convertPemKey((HcfAsyKeyGenerator *)(ctx->base), (HcfParamsSpec *)(ctx->decSpec),
+            pubKeyStr, priKeyStr, (HcfKeyPair **)keyCtx);
+}
+
+static void CleanupPemMemory(char *priKeyStr, char *pubKeyStr)
+{
+    if (priKeyStr != NULL) {
+        (void)memset_s(priKeyStr, strlen(priKeyStr), 0, strlen(priKeyStr));
+        HcfFree(priKeyStr);
+    }
+    if (pubKeyStr != NULL) {
+        (void)memset_s(pubKeyStr, strlen(pubKeyStr), 0, strlen(pubKeyStr));
+        HcfFree(pubKeyStr);
+    }
+}
+
+static OH_Crypto_ErrCode HandlePemConversion(OH_CryptoAsymKeyGenerator *ctx, Crypto_DataBlob *pubKeyData,
+    Crypto_DataBlob *priKeyData, OH_CryptoKeyPair **keyCtx)
+{
+    char *priKeyStr = NULL;
+    char *pubKeyStr = NULL;
+    OH_Crypto_ErrCode ret = ProcessPriKeyData(priKeyData, &priKeyStr);
+    if (ret != CRYPTO_SUCCESS) {
+        return ret;
+    }
+
+    ret = ProcessPubKeyData(pubKeyData, &pubKeyStr);
+    if (ret != CRYPTO_SUCCESS) {
+        CleanupPemMemory(priKeyStr, pubKeyStr);
+        return ret;
+    }
+
+    HcfResult hcfRet = ExecutePemConversion(ctx, pubKeyStr, priKeyStr, keyCtx);
+    CleanupPemMemory(priKeyStr, pubKeyStr);
+    return GetOhCryptoErrCode(hcfRet);
+}
+
 OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Convert(OH_CryptoAsymKeyGenerator *ctx, Crypto_EncodingType type,
     Crypto_DataBlob *pubKeyData, Crypto_DataBlob *priKeyData, OH_CryptoKeyPair **keyCtx)
 {
     if ((ctx == NULL) || (ctx->base == NULL) || (pubKeyData == NULL && priKeyData == NULL) || (keyCtx == NULL)) {
         return CRYPTO_INVALID_PARAMS;
     }
-    HcfResult ret = HCF_SUCCESS;
-    const char *priKeyStr = (priKeyData == NULL)? NULL : (const char *)priKeyData->data;
-    const char *pubKeyStr = (pubKeyData == NULL)? NULL : (const char *)pubKeyData->data;
+
     switch (type) {
         case CRYPTO_PEM:
-            ret = ctx->base->convertPemKey == NULL ? HCF_INVALID_PARAMS :
-                ctx->base->convertPemKey((HcfAsyKeyGenerator *)(ctx->base), (HcfParamsSpec *)(ctx->decSpec), pubKeyStr,
-                    priKeyStr, (HcfKeyPair **)keyCtx);
-            break;
+            return HandlePemConversion(ctx, pubKeyData, priKeyData, keyCtx);
         case CRYPTO_DER:
-            ret = ctx->base->convertKey == NULL ? HCF_INVALID_PARAMS :
+            return GetOhCryptoErrCode(ctx->base->convertKey == NULL ? HCF_INVALID_PARAMS :
                 ctx->base->convertKey((HcfAsyKeyGenerator *)(ctx->base), (HcfParamsSpec *)(ctx->decSpec),
-                    (HcfBlob *)pubKeyData, (HcfBlob *)priKeyData, (HcfKeyPair **)keyCtx);
-            break;
+                    (HcfBlob *)pubKeyData, (HcfBlob *)priKeyData, (HcfKeyPair **)keyCtx));
         default:
             return CRYPTO_INVALID_PARAMS;
     }
-    return GetOhCryptoErrCode(ret);
 }
 
 const char *OH_CryptoAsymKeyGenerator_GetAlgoName(OH_CryptoAsymKeyGenerator *ctx)
@@ -310,6 +372,7 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P
             }
             value->data = (uint8_t *)returnInt;
             value->len = sizeof(int32_t);
+            ReverseUint8Arr(value->data, value->len);
             break;
         case CRYPTO_ECC_FIELD_TYPE_STR:
         case CRYPTO_ECC_CURVE_NAME_STR:
@@ -329,6 +392,7 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P
             }
             value->data = (uint8_t *)bigIntValue.data;
             value->len = (size_t)bigIntValue.len;
+            ReverseUint8Arr(value->data, value->len);
             break;
     }
     return GetOhCryptoErrCode(ret);
@@ -398,12 +462,6 @@ OH_Crypto_ErrCode OH_CryptoPrivKey_Encode(OH_CryptoPrivKey *key, Crypto_Encoding
             if (key->getEncodedPem == NULL) {
                 return CRYPTO_PARAMETER_CHECK_FAILED;
             }
-            if (params == NULL) {
-                ret = key->getEncodedPem((HcfPriKey *)key, NULL, encodingStandard, &pemStr);
-            } else {
-                ret = key->getEncodedPem((HcfPriKey *)key, (HcfParamsSpec *)params, encodingStandard, &pemStr);
-            }
-            
             ret = key->getEncodedPem((HcfPriKey *)key, (HcfParamsSpec *)params, encodingStandard, &pemStr);
             if (ret != HCF_SUCCESS) {
                 break;
@@ -1581,7 +1639,7 @@ OH_Crypto_ErrCode OH_CryptoEcPoint_Create(const char *curveName, Crypto_DataBlob
     }
     HcfResult ret = HcfConvertPoint(curveName, (HcfBlob *)ecKeyData, &((*point)->pointBase));
     if (ret != HCF_SUCCESS) {
-        HcfFree(*point);
+        OH_CryptoEcPoint_Destroy(*point);
         *point = NULL;
     }
     return GetOhCryptoErrCodeNew(ret);
@@ -1601,6 +1659,8 @@ OH_Crypto_ErrCode OH_CryptoEcPoint_GetCoordinate(OH_CryptoEcPoint *point, Crypto
     y->data = dPoint.y.data;
     x->len = dPoint.x.len;
     y->len = dPoint.y.len;
+    ReverseUint8Arr(x->data, x->len);
+    ReverseUint8Arr(y->data, y->len);
     return CRYPTO_SUCCESS;
 }
 
@@ -1625,6 +1685,8 @@ OH_Crypto_ErrCode OH_CryptoEcPoint_SetCoordinate(OH_CryptoEcPoint *point, Crypto
     point->pointBase.x.len = dPoint.x.len;
     point->pointBase.y.data = dPoint.y.data;
     point->pointBase.y.len = dPoint.y.len;
+    ReverseUint8Arr(point->pointBase.x.data, point->pointBase.x.len);
+    ReverseUint8Arr(point->pointBase.y.data, point->pointBase.y.len);
     return CRYPTO_SUCCESS;
 }
 
diff --git a/frameworks/native/src/native_common.c b/frameworks/native/src/native_common.c
index a9579a0018152feb136cbbaccabf26d5698cab24..62b7fd3da093a1ed09dc4bcffe06188e5658be7c 100644
--- a/frameworks/native/src/native_common.c
+++ b/frameworks/native/src/native_common.c
@@ -49,11 +49,11 @@ OH_Crypto_ErrCode GetOhCryptoErrCodeNew(HcfResult errCode)
 
 void ReverseUint8Arr(uint8_t *data, size_t len)
 {
-    for (size_t i = 0; i < len / 2; ++i) {
+    for (size_t i = 0; i < (len >> 1); ++i) {
         uint8_t temp = data[i];
         data[i] = data[len - 1 - i];
         data[len - 1 - i] = temp;
-    } 
+    }
 }
 
 #define NATIVE_BITS_SIZE 8
diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c
index a374d6830f0369bc947938375d028d060f40537a..08d887e791c2a15d835a70acbbd66ec02c6426de 100644
--- a/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c
+++ b/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c
@@ -724,13 +724,13 @@ static HcfResult GetPriKeyEncodedPem(const HcfPriKey *self, HcfParamsSpec *param
             OpensslEvpPkeyFree(pkey);
             return HCF_NOT_SUPPORT;
         }
-        cipher = EVP_CIPHER_fetch(NULL, cipherStr, NULL);
         passWord = (const char *)spec->password;
         if (passWord == NULL) {
             LOGE("passWord is NULL.");
             OpensslEvpPkeyFree(pkey);
             return HCF_ERR_PARAMETER_CHECK_FAILED;
         }
+        cipher = EVP_CIPHER_fetch(NULL, cipherStr, NULL);
         result = GetPriKeyPem(format, pkey, cipher, passWord, returnString);
         EVP_CIPHER_free((EVP_CIPHER *)cipher);
     } else {
diff --git a/test/unittest/src/native/native_asym_key_test.cpp b/test/unittest/src/native/native_asym_key_test.cpp
index 9017faed93af1ae51285fd230eb83bad7aa2b8ed..584e8e61ac102d39669875509953a2ad06cdfc5a 100644
--- a/test/unittest/src/native/native_asym_key_test.cpp
+++ b/test/unittest/src/native/native_asym_key_test.cpp
@@ -1063,6 +1063,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest022, TestSize.Level0)
 
     OH_CryptoKeyPair *keyPair = nullptr;
     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
+    // 输入使用大端时会校验成功
     EXPECT_EQ(ret, CRYPTO_SUCCESS);
     ASSERT_NE(keyPair, nullptr);
     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
@@ -1109,6 +1110,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest023, TestSize.Level0)
 
     OH_CryptoKeyPair *keyPair = nullptr;
     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
+    // 输入使用大端时会校验成功
     EXPECT_EQ(ret, CRYPTO_SUCCESS);
     ASSERT_NE(keyPair, nullptr);
     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);