Update zeroize test to use mbedtls_platform_zeroize()

programs/test/zeroize.c

@@ -2,13 +2,14 @@
  * Zeroize application for debugger-driven testing
  *
  * This is a simple test application used for debugger-driven testing to check
- * whether calls to mbedtls_zeroize() are being eliminated by compiler
+ * whether calls to mbedtls_platform_zeroize() are being eliminated by compiler
  * optimizations. This application is used by the GDB script at
- * tests/scripts/test_zeroize.gdb under the assumption that line numbers do not
+ * tests/scripts/test_zeroize.gdb under the assumption that the code does not
  * change often (as opposed to the library code) because the script sets a
  * breakpoint at the last return statement in the main() function of this
  * program. The debugger facilities are then used to manually inspect the
- * memory and verify that the call to mbedtls_zeroize() was not eliminated.
+ * memory and verify that the call to mbedtls_platform_zeroize() was not
+ * eliminated.
  *
  *  Copyright (C) 2018, Arm Limited, All Rights Reserved
  *  SPDX-License-Identifier: Apache-2.0
@@ -45,14 +46,14 @@
 #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
 #endif
 
-#include "mbedtls/utils.h"
+#include "mbedtls/platform_util.h"
 
 #define BUFFER_LEN 1024
 
 void usage( void )
 {
     mbedtls_printf( "Zeroize is a simple program to assist with testing\n" );
-    mbedtls_printf( "the mbedtls_zeroize() function by using the\n" );
+    mbedtls_printf( "the mbedtls_platform_zeroize() function by using the\n" );
     mbedtls_printf( "debugger. This program takes a file as input and\n" );
     mbedtls_printf( "prints the first %d characters. Usage:\n\n", BUFFER_LEN );
     mbedtls_printf( "       zeroize <FILE>\n" );
@@ -94,7 +95,7 @@ int main( int argc, char** argv )
         mbedtls_printf( "The file is empty!\n" );
 
     fclose( fp );
-    mbedtls_zeroize( buf, sizeof( buf ) );
+    mbedtls_platform_zeroize( buf, sizeof( buf ) );
 
     return( exit_code );
 }

tests/scripts/test_zeroize.gdb

@@ -6,29 +6,29 @@
 #
 # Purpose
 #
-# Run a test using the debugger to check that the mbedtls_zeroize() function in
-# utils.h is not being optimized out by the compiler. To do so, the script
-# loads the test program at programs/test/zeroize.c and sets a breakpoint at
-# the last return statement in the main(). When the breakpoint is hit, the
-# debugger manually checks the contents to be zeroized and checks that it is
-# actually cleared.
+# Run a test using the debugger to check that the mbedtls_platform_zeroize()
+# function in platform_util.h is not being optimized out by the compiler. To do
+# so, the script loads the test program at programs/test/zeroize.c and sets a
+# breakpoint at the last return statement in main(). When the breakpoint is
+# hit, the debugger manually checks the contents to be zeroized and checks that
+# it is actually cleared.
 #
-# The mbedtls_zeroize() test is debugger driven because there does not seem to
-# be a mechanism to reliably check whether the zeroize calls are being
+# The mbedtls_platform_zeroize() test is debugger driven because there does not
+# seem to be a mechanism to reliably check whether the zeroize calls are being
 # eliminated by compiler optimizations from within the compiled program. The
 # problem is that a compiler would typically remove what it considers to be
 # "unecessary" assignments as part of redundant code elimination. To identify
 # such code, the compilar will create some form dependency graph between
 # reads and writes to variables (among other situations). It will then use this
 # data structure to remove redundant code that does not have an impact on the
-# program's observable behavior. In the case of mbedtls_zeroize(), an
+# program's observable behavior. In the case of mbedtls_platform_zeroize(), an
 # intelligent compiler could determine that this function clears a block of
 # memory that is not accessed later in the program, so removing the call to
-# mbedtls_zeroize() does not have an observable behavior. However, inserting a
-# test after a call to mbedtls_zeroize() to check whether the block of
-# memory was correctly zeroed would force the compiler to not eliminate the
-# mbedtls_zeroize() call. If this does not occur, then the compiler potentially
-# has a bug.
+# mbedtls_platform_zeroize() does not have an observable behavior. However,
+# inserting a test after a call to mbedtls_zeroize() to check whether the block
+# of memory was correctly zeroed would force the compiler to not eliminate the
+# mbedtls_platform_zeroize() call. If this does not occur, then the compiler
+# potentially has a bug.
 #
 # Note: This test requires that the test program is compiled with -g3.
 #
@@ -42,7 +42,7 @@
 
 set confirm off
 file ./programs/test/zeroize
-break zeroize.c:99
+break zeroize.c:100
 
 set args ./programs/test/zeroize.c
 run