diff --git a/library/pk_wrap.c b/library/pk_wrap.c
index ff8eeb14cc..f8ce099952 100644
--- a/library/pk_wrap.c
+++ b/library/pk_wrap.c
@@ -87,7 +87,7 @@ static int rsa_verify_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
         return MBEDTLS_ERR_RSA_VERIFY_FAILED;
     }
 
-    key_len = mbedtls_rsa_pubkey_write(rsa, buf, &p);
+    key_len = mbedtls_rsa_write_pubkey(rsa, buf, &p);
     if (key_len <= 0) {
         return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
     }
@@ -185,7 +185,7 @@ int  mbedtls_pk_psa_rsa_sign_ext(psa_algorithm_t alg,
         return MBEDTLS_ERR_PK_BUFFER_TOO_SMALL;
     }
 
-    key_len = mbedtls_rsa_key_write(rsa_ctx, buf, &p);
+    key_len = mbedtls_rsa_write_key(rsa_ctx, buf, &p);
     if (key_len <= 0) {
         mbedtls_free(buf);
         return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
@@ -293,7 +293,7 @@ static int rsa_decrypt_wrap(mbedtls_pk_context *pk,
         return MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
     }
 
-    key_len = mbedtls_rsa_key_write(rsa, buf, &p);
+    key_len = mbedtls_rsa_write_key(rsa, buf, &p);
     if (key_len <= 0) {
         return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
     }
@@ -375,7 +375,7 @@ static int rsa_encrypt_wrap(mbedtls_pk_context *pk,
         return MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE;
     }
 
-    key_len = mbedtls_rsa_pubkey_write(rsa, buf, &p);
+    key_len = mbedtls_rsa_write_pubkey(rsa, buf, &p);
     if (key_len <= 0) {
         return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
     }
diff --git a/library/pkparse.c b/library/pkparse.c
index 17df101f01..b2127b2e5b 100644
--- a/library/pkparse.c
+++ b/library/pkparse.c
@@ -850,7 +850,7 @@ int mbedtls_pk_parse_subpubkey(unsigned char **p, const unsigned char *end,
 
 #if defined(MBEDTLS_RSA_C)
     if (pk_alg == MBEDTLS_PK_RSA) {
-        ret = mbedtls_rsa_pubkey_parse(mbedtls_pk_rsa(*pk), p, end);
+        ret = mbedtls_rsa_parse_pubkey(mbedtls_pk_rsa(*pk), p, end);
     } else
 #endif /* MBEDTLS_RSA_C */
 #if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
@@ -1098,7 +1098,7 @@ static int pk_parse_key_pkcs8_unencrypted_der(
 
 #if defined(MBEDTLS_RSA_C)
     if (pk_alg == MBEDTLS_PK_RSA) {
-        if ((ret = mbedtls_rsa_key_parse(mbedtls_pk_rsa(*pk), p, len)) != 0) {
+        if ((ret = mbedtls_rsa_parse_key(mbedtls_pk_rsa(*pk), p, len)) != 0) {
             mbedtls_pk_free(pk);
             return ret;
         }
@@ -1288,7 +1288,7 @@ int mbedtls_pk_parse_key(mbedtls_pk_context *pk,
     if (ret == 0) {
         pk_info = mbedtls_pk_info_from_type(MBEDTLS_PK_RSA);
         if ((ret = mbedtls_pk_setup(pk, pk_info)) != 0 ||
-            (ret = mbedtls_rsa_key_parse(mbedtls_pk_rsa(*pk),
+            (ret = mbedtls_rsa_parse_key(mbedtls_pk_rsa(*pk),
                                          pem.buf, pem.buflen)) != 0) {
             mbedtls_pk_free(pk);
         }
@@ -1429,7 +1429,7 @@ int mbedtls_pk_parse_key(mbedtls_pk_context *pk,
 
     pk_info = mbedtls_pk_info_from_type(MBEDTLS_PK_RSA);
     if (mbedtls_pk_setup(pk, pk_info) == 0 &&
-        mbedtls_rsa_key_parse(mbedtls_pk_rsa(*pk), key, keylen) == 0) {
+        mbedtls_rsa_parse_key(mbedtls_pk_rsa(*pk), key, keylen) == 0) {
         return 0;
     }
 
@@ -1504,7 +1504,7 @@ int mbedtls_pk_parse_public_key(mbedtls_pk_context *ctx,
             return ret;
         }
 
-        if ((ret = mbedtls_rsa_pubkey_parse(mbedtls_pk_rsa(*ctx), &p, p + pem.buflen)) != 0) {
+        if ((ret = mbedtls_rsa_parse_pubkey(mbedtls_pk_rsa(*ctx), &p, p + pem.buflen)) != 0) {
             mbedtls_pk_free(ctx);
         }
 
@@ -1551,7 +1551,7 @@ int mbedtls_pk_parse_public_key(mbedtls_pk_context *ctx,
     }
 
     p = (unsigned char *) key;
-    ret = mbedtls_rsa_pubkey_parse(mbedtls_pk_rsa(*ctx), &p, p + keylen);
+    ret = mbedtls_rsa_parse_pubkey(mbedtls_pk_rsa(*ctx), &p, p + keylen);
     if (ret == 0) {
         return ret;
     }
diff --git a/library/pkwrite.c b/library/pkwrite.c
index 91529eb752..b9ddcf1d8d 100644
--- a/library/pkwrite.c
+++ b/library/pkwrite.c
@@ -78,7 +78,7 @@ static int pk_write_rsa_der(unsigned char **p, unsigned char *buf,
         return (int) len;
     }
 #endif /* MBEDTLS_USE_PSA_CRYPTO */
-    return mbedtls_rsa_key_write(mbedtls_pk_rsa(*pk), buf, p);
+    return mbedtls_rsa_write_key(mbedtls_pk_rsa(*pk), buf, p);
 }
 #endif /* MBEDTLS_RSA_C */
 
@@ -416,7 +416,7 @@ int mbedtls_pk_write_pubkey(unsigned char **p, unsigned char *start,
 
 #if defined(MBEDTLS_RSA_C)
     if (mbedtls_pk_get_type(key) == MBEDTLS_PK_RSA) {
-        MBEDTLS_ASN1_CHK_ADD(len, mbedtls_rsa_pubkey_write(mbedtls_pk_rsa(*key), start, p));
+        MBEDTLS_ASN1_CHK_ADD(len, mbedtls_rsa_write_pubkey(mbedtls_pk_rsa(*key), start, p));
     } else
 #endif
 #if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
diff --git a/library/psa_crypto_rsa.c b/library/psa_crypto_rsa.c
index cfa2da6191..0047a26bfb 100644
--- a/library/psa_crypto_rsa.c
+++ b/library/psa_crypto_rsa.c
@@ -71,11 +71,11 @@ psa_status_t mbedtls_psa_rsa_load_representation(
 
     /* Parse the data. */
     if (PSA_KEY_TYPE_IS_KEY_PAIR(type)) {
-        status = mbedtls_to_psa_error(mbedtls_rsa_key_parse(*p_rsa, data, data_length));
+        status = mbedtls_to_psa_error(mbedtls_rsa_parse_key(*p_rsa, data, data_length));
     } else {
         unsigned char *p = data;
         unsigned char *end = (data + data_length);
-        status = mbedtls_to_psa_error(mbedtls_rsa_pubkey_parse(*p_rsa, &p, end));
+        status = mbedtls_to_psa_error(mbedtls_rsa_parse_pubkey(*p_rsa, &p, end));
     }
     if (status != PSA_SUCCESS) {
         goto exit;
@@ -163,9 +163,9 @@ psa_status_t mbedtls_psa_rsa_export_key(psa_key_type_t type,
      * representation of the non-encrypted PKCS#1 RSAPrivateKey for a
      * private key and of the RFC3279 RSAPublicKey for a public key. */
     if (PSA_KEY_TYPE_IS_KEY_PAIR(type)) {
-        ret = mbedtls_rsa_key_write(rsa, data, &end);
+        ret = mbedtls_rsa_write_key(rsa, data, &end);
     } else {
-        ret = mbedtls_rsa_pubkey_write(rsa, data, &end);
+        ret = mbedtls_rsa_write_pubkey(rsa, data, &end);
     }
 
     if (ret < 0) {
diff --git a/library/rsa.c b/library/rsa.c
index b81039ceb9..62b56cd25c 100644
--- a/library/rsa.c
+++ b/library/rsa.c
@@ -46,7 +46,7 @@
 
 #include "mbedtls/platform.h"
 
-int mbedtls_rsa_key_parse(mbedtls_rsa_context *rsa, const unsigned char *key, size_t keylen)
+int mbedtls_rsa_parse_key(mbedtls_rsa_context *rsa, const unsigned char *key, size_t keylen)
 {
     int ret, version;
     size_t len;
@@ -192,7 +192,7 @@ cleanup:
     return ret;
 }
 
-int mbedtls_rsa_pubkey_parse(mbedtls_rsa_context *rsa, unsigned char **p,
+int mbedtls_rsa_parse_pubkey(mbedtls_rsa_context *rsa, unsigned char **p,
                              const unsigned char *end)
 {
     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
@@ -250,7 +250,7 @@ int mbedtls_rsa_pubkey_parse(mbedtls_rsa_context *rsa, unsigned char **p,
     return 0;
 }
 
-int mbedtls_rsa_key_write(const mbedtls_rsa_context *rsa, unsigned char *start,
+int mbedtls_rsa_write_key(const mbedtls_rsa_context *rsa, unsigned char *start,
                           unsigned char **p)
 {
     size_t len = 0;
@@ -342,7 +342,7 @@ end_of_export:
  *      publicExponent    INTEGER   -- e
  *  }
  */
-int mbedtls_rsa_pubkey_write(const mbedtls_rsa_context *rsa, unsigned char *start,
+int mbedtls_rsa_write_pubkey(const mbedtls_rsa_context *rsa, unsigned char *start,
                              unsigned char **p)
 {
     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
diff --git a/library/rsa_internal.h b/library/rsa_internal.h
index 6046850fcc..7bbdc8c2b5 100644
--- a/library/rsa_internal.h
+++ b/library/rsa_internal.h
@@ -28,7 +28,7 @@
  * \return          MBEDTLS_ERR_ASN1_xxx in case of ASN.1 parsing errors.
  * \return          MBEDTLS_ERR_RSA_BAD_INPUT_DATA in case of invalid version.
  */
-int mbedtls_rsa_key_parse(mbedtls_rsa_context *rsa, const unsigned char *key, size_t keylen);
+int mbedtls_rsa_parse_key(mbedtls_rsa_context *rsa, const unsigned char *key, size_t keylen);
 
 /**
  * \brief           Parse a PKCS#1 (ASN.1) encoded public RSA key.
@@ -44,7 +44,7 @@ int mbedtls_rsa_key_parse(mbedtls_rsa_context *rsa, const unsigned char *key, si
  * \return          MBEDTLS_ERR_RSA_BAD_INPUT_DATA in case of importing or
  *                  priv/pub validation errors.
  */
-int mbedtls_rsa_pubkey_parse(mbedtls_rsa_context *rsa, unsigned char **p,
+int mbedtls_rsa_parse_pubkey(mbedtls_rsa_context *rsa, unsigned char **p,
                              const unsigned char *end);
 
 /**
@@ -67,7 +67,7 @@ int mbedtls_rsa_pubkey_parse(mbedtls_rsa_context *rsa, unsigned char **p,
  * \note            The output buffer is filled backward, i.e. starting from its
  *                  end and moving toward its start.
  */
-int mbedtls_rsa_key_write(const mbedtls_rsa_context *rsa, unsigned char *start,
+int mbedtls_rsa_write_key(const mbedtls_rsa_context *rsa, unsigned char *start,
                           unsigned char **p);
 
 /**
@@ -90,7 +90,7 @@ int mbedtls_rsa_key_write(const mbedtls_rsa_context *rsa, unsigned char *start,
  * \note            The output buffer is filled backward, i.e. starting from its
  *                  end and moving toward its start.
  */
-int mbedtls_rsa_pubkey_write(const mbedtls_rsa_context *rsa, unsigned char *start,
+int mbedtls_rsa_write_pubkey(const mbedtls_rsa_context *rsa, unsigned char *start,
                              unsigned char **p);
 
 #if defined(MBEDTLS_PKCS1_V21)
diff --git a/tests/suites/test_suite_rsa.function b/tests/suites/test_suite_rsa.function
index 44caacd6e8..2cc9fc17e5 100644
--- a/tests/suites/test_suite_rsa.function
+++ b/tests/suites/test_suite_rsa.function
@@ -1382,9 +1382,9 @@ void rsa_parse_pkcs1_key(int is_public, data_t *input, int exp_ret_val)
     mbedtls_rsa_init(&rsa_ctx);
 
     if (is_public) {
-        TEST_EQUAL(mbedtls_rsa_pubkey_parse(&rsa_ctx, &start, end), exp_ret_val);
+        TEST_EQUAL(mbedtls_rsa_parse_pubkey(&rsa_ctx, &start, end), exp_ret_val);
     } else {
-        TEST_EQUAL(mbedtls_rsa_key_parse(&rsa_ctx, input->x, input->len), exp_ret_val);
+        TEST_EQUAL(mbedtls_rsa_parse_key(&rsa_ctx, input->x, input->len), exp_ret_val);
     }
 
 exit:
@@ -1410,12 +1410,12 @@ void rsa_parse_write_pkcs1_key(int is_public, data_t *input)
 
     /* Parse the key and write it back to output_buf. */
     if (is_public) {
-        TEST_EQUAL(mbedtls_rsa_pubkey_parse(&rsa_ctx, &input_start, input_end), 0);
+        TEST_EQUAL(mbedtls_rsa_parse_pubkey(&rsa_ctx, &input_start, input_end), 0);
         TEST_ASSERT(input_start == input_end);
-        TEST_EQUAL(mbedtls_rsa_pubkey_write(&rsa_ctx, output_start, &output_end), input->len);
+        TEST_EQUAL(mbedtls_rsa_write_pubkey(&rsa_ctx, output_start, &output_end), input->len);
     } else {
-        TEST_EQUAL(mbedtls_rsa_key_parse(&rsa_ctx, input->x, input->len), 0);
-        TEST_EQUAL(mbedtls_rsa_key_write(&rsa_ctx, output_start, &output_end), input->len);
+        TEST_EQUAL(mbedtls_rsa_parse_key(&rsa_ctx, input->x, input->len), 0);
+        TEST_EQUAL(mbedtls_rsa_write_key(&rsa_ctx, output_start, &output_end), input->len);
     }
     /* This check holds because we alloacated an output buffer which is exactly
      * large enough to contain the written data. */
@@ -1444,9 +1444,9 @@ void rsa_key_write_incremental(int is_public, data_t *input)
     if (is_public) {
         start = input->x;
         end = input->x + input->len;
-        TEST_EQUAL(mbedtls_rsa_pubkey_parse(&rsa_ctx, &start, end), 0);
+        TEST_EQUAL(mbedtls_rsa_parse_pubkey(&rsa_ctx, &start, end), 0);
     } else {
-        TEST_EQUAL(mbedtls_rsa_key_parse(&rsa_ctx, input->x, input->len), 0);
+        TEST_EQUAL(mbedtls_rsa_parse_key(&rsa_ctx, input->x, input->len), 0);
     }
 
     for (i = 1; i < input->len; i++) {
@@ -1454,9 +1454,9 @@ void rsa_key_write_incremental(int is_public, data_t *input)
         end = buf + i;
         /* We don't care much about the return value as long as it fails. */
         if (is_public) {
-            TEST_ASSERT(mbedtls_rsa_pubkey_write(&rsa_ctx, buf, &end) != 0);
+            TEST_ASSERT(mbedtls_rsa_write_pubkey(&rsa_ctx, buf, &end) != 0);
         } else {
-            TEST_ASSERT(mbedtls_rsa_key_write(&rsa_ctx, buf, &end) != 0);
+            TEST_ASSERT(mbedtls_rsa_write_key(&rsa_ctx, buf, &end) != 0);
         }
         mbedtls_free(buf);
         buf = NULL;
@@ -1467,9 +1467,9 @@ void rsa_key_write_incremental(int is_public, data_t *input)
     end = buf + i;
 
     if (is_public) {
-        TEST_ASSERT(mbedtls_rsa_pubkey_write(&rsa_ctx, buf, &end) != 0);
+        TEST_ASSERT(mbedtls_rsa_write_pubkey(&rsa_ctx, buf, &end) != 0);
     } else {
-        TEST_ASSERT(mbedtls_rsa_key_write(&rsa_ctx, buf, &end) > 0);
+        TEST_ASSERT(mbedtls_rsa_write_key(&rsa_ctx, buf, &end) > 0);
     }
 
 exit: