diff --git a/library/psa_crypto.c b/library/psa_crypto.c
index 3327c30..bad55b1 100644
--- a/library/psa_crypto.c
+++ b/library/psa_crypto.c
@@ -8502,7 +8502,7 @@
     psa_status_t status;
 
     input_copy->buffer = NULL;
-    input_copy->len = 0;
+    input_copy->length = 0;
 
     if (input_len == 0) {
         return PSA_SUCCESS;
@@ -8516,10 +8516,10 @@
     }
     /* From now on, we must free input_copy->buffer on error. */
 
-    input_copy->len = input_len;
+    input_copy->length = input_len;
 
     status = psa_crypto_copy_input(input, input_len,
-                                   input_copy->buffer, input_copy->len);
+                                   input_copy->buffer, input_copy->length);
     if (status != PSA_SUCCESS) {
         goto error;
     }
@@ -8529,7 +8529,7 @@
 error:
     mbedtls_free(input_copy->buffer);
     input_copy->buffer = NULL;
-    input_copy->len = 0;
+    input_copy->length = 0;
     return status;
 }
 
@@ -8537,7 +8537,7 @@
 {
     mbedtls_free(input_copy->buffer);
     input_copy->buffer = NULL;
-    input_copy->len = 0;
+    input_copy->length = 0;
 }
 
 psa_status_t psa_crypto_output_copy_alloc(uint8_t *output, size_t output_len,
@@ -8545,7 +8545,7 @@
 {
     output_copy->original = NULL;
     output_copy->buffer = NULL;
-    output_copy->len = 0;
+    output_copy->length = 0;
 
     if (output_len == 0) {
         return PSA_SUCCESS;
@@ -8556,7 +8556,7 @@
          * a NULL return value means a failure of allocation. */
         return PSA_ERROR_INSUFFICIENT_MEMORY;
     }
-    output_copy->len = output_len;
+    output_copy->length = output_len;
     output_copy->original = output;
 
     return PSA_SUCCESS;
@@ -8567,7 +8567,7 @@
     psa_status_t status;
 
     if (output_copy->buffer == NULL) {
-        output_copy->len = 0;
+        output_copy->length = 0;
         return PSA_SUCCESS;
     }
     if (output_copy->original == NULL) {
@@ -8575,15 +8575,15 @@
         return PSA_ERROR_CORRUPTION_DETECTED;
     }
 
-    status = psa_crypto_copy_output(output_copy->buffer, output_copy->len,
-                                    output_copy->original, output_copy->len);
+    status = psa_crypto_copy_output(output_copy->buffer, output_copy->length,
+                                    output_copy->original, output_copy->length);
     if (status != PSA_SUCCESS) {
         return status;
     }
 
     mbedtls_free(output_copy->buffer);
     output_copy->buffer = NULL;
-    output_copy->len = 0;
+    output_copy->length = 0;
 
     return PSA_SUCCESS;
 }
diff --git a/library/psa_crypto_core.h b/library/psa_crypto_core.h
index 940748e..21d4bf3 100644
--- a/library/psa_crypto_core.h
+++ b/library/psa_crypto_core.h
@@ -856,7 +856,7 @@
 
 typedef struct psa_crypto_input_copy_s {
     uint8_t *buffer;
-    size_t len;
+    size_t length;
 } psa_crypto_input_copy_t;
 
 #define PSA_CRYPTO_INPUT_COPY_INIT { NULL, 0 }
@@ -886,7 +886,7 @@
 typedef struct psa_crypto_output_copy_s {
     uint8_t *original;
     uint8_t *buffer;
-    size_t len;
+    size_t length;
 } psa_crypto_output_copy_t;
 
 #define PSA_CRYPTO_OUTPUT_COPY_INIT { NULL, NULL, 0 }
diff --git a/tests/suites/test_suite_psa_crypto_memory.function b/tests/suites/test_suite_psa_crypto_memory.function
index e9e5299..8421604 100644
--- a/tests/suites/test_suite_psa_crypto_memory.function
+++ b/tests/suites/test_suite_psa_crypto_memory.function
@@ -98,7 +98,7 @@
             TEST_ASSERT(input_copy.buffer != input);
         }
         TEST_MEMORY_COMPARE(input, input_len,
-                            input_copy.buffer, input_copy.len);
+                            input_copy.buffer, input_copy.length);
     }
 
 exit:
@@ -113,18 +113,18 @@
     psa_crypto_input_copy_t input_copy;
 
     input_copy.buffer = NULL;
-    input_copy.len = input_len;
-    TEST_CALLOC(input_copy.buffer, input_copy.len);
+    input_copy.length = input_len;
+    TEST_CALLOC(input_copy.buffer, input_copy.length);
 
     psa_crypto_input_copy_free(&input_copy);
 
     TEST_ASSERT(input_copy.buffer == NULL);
-    TEST_EQUAL(input_copy.len, 0);
+    TEST_EQUAL(input_copy.length, 0);
 
 exit:
     mbedtls_free(input_copy.buffer);
     input_copy.buffer = NULL;
-    input_copy.len = 0;
+    input_copy.length = 0;
 }
 /* END_CASE */
 
@@ -139,13 +139,13 @@
 
     status = psa_crypto_input_copy_alloc(input, sizeof(input), &input_copy);
     TEST_EQUAL(status, PSA_SUCCESS);
-    TEST_MEMORY_COMPARE(input_copy.buffer, input_copy.len,
+    TEST_MEMORY_COMPARE(input_copy.buffer, input_copy.length,
                         input, sizeof(input));
     TEST_ASSERT(input_copy.buffer != input);
 
     psa_crypto_input_copy_free(&input_copy);
     TEST_ASSERT(input_copy.buffer == NULL);
-    TEST_EQUAL(input_copy.len, 0);
+    TEST_EQUAL(input_copy.length, 0);
 }
 /* END_CASE */
 
@@ -165,14 +165,14 @@
 
     if (exp_status == PSA_SUCCESS) {
         TEST_ASSERT(output_copy.original == output);
-        TEST_EQUAL(output_copy.len, output_len);
+        TEST_EQUAL(output_copy.length, output_len);
     }
 
 exit:
     mbedtls_free(output_copy.buffer);
     output_copy.original = NULL;
     output_copy.buffer = NULL;
-    output_copy.len = 0;
+    output_copy.length = 0;
     mbedtls_free(output);
     output = NULL;
 }
@@ -192,12 +192,12 @@
     }
     TEST_CALLOC(buffer_copy_for_comparison, output_len);
     TEST_CALLOC(output_copy.buffer, output_len);
-    output_copy.len = output_len;
+    output_copy.length = output_len;
     output_copy.original = output;
 
-    if (output_copy.len != 0) {
-        fill_buffer_pattern(output_copy.buffer, output_copy.len);
-        memcpy(buffer_copy_for_comparison, output_copy.buffer, output_copy.len);
+    if (output_copy.length != 0) {
+        fill_buffer_pattern(output_copy.buffer, output_copy.length);
+        memcpy(buffer_copy_for_comparison, output_copy.buffer, output_copy.length);
     }
 
     status = psa_crypto_output_copy_free(&output_copy);
@@ -205,7 +205,7 @@
 
     if (exp_status == PSA_SUCCESS) {
         TEST_ASSERT(output_copy.buffer == NULL);
-        TEST_EQUAL(output_copy.len, 0);
+        TEST_EQUAL(output_copy.length, 0);
         TEST_MEMORY_COMPARE(buffer_copy_for_comparison, output_len,
                             output, output_len);
     }
@@ -214,7 +214,7 @@
     mbedtls_free(output);
     mbedtls_free(buffer_copy_for_comparison);
     mbedtls_free(output_copy.buffer);
-    output_copy.len = 0;
+    output_copy.length = 0;
 }
 /* END_CASE */
 
@@ -231,14 +231,14 @@
     TEST_ASSERT(output_copy.buffer != output);
 
     /* Simulate the function generating output */
-    fill_buffer_pattern(output_copy.buffer, output_copy.len);
+    fill_buffer_pattern(output_copy.buffer, output_copy.length);
 
-    TEST_CALLOC(buffer_copy_for_comparison, output_copy.len);
-    memcpy(buffer_copy_for_comparison, output_copy.buffer, output_copy.len);
+    TEST_CALLOC(buffer_copy_for_comparison, output_copy.length);
+    memcpy(buffer_copy_for_comparison, output_copy.buffer, output_copy.length);
 
     psa_crypto_output_copy_free(&output_copy);
     TEST_ASSERT(output_copy.buffer == NULL);
-    TEST_EQUAL(output_copy.len, 0);
+    TEST_EQUAL(output_copy.length, 0);
 
     /* Check that the buffer was correctly copied back */
     TEST_MEMORY_COMPARE(output, sizeof(output),