Consolidate MLD_CONFIG_CUSTOM_ZEROIZE with mlkem-native

The MLD_CONFIG_CUSTOM_ZEROIZE macro in mldsa/src/ct.h behaves slightly
differently from MLK_CONFIG_CUSTOM_ZEROIZE in mlkem/src/verify.h.

This commit aligns their behavior.

Signed-off-by: willieyz <willie.zhao@chelpis.com>

Author: willieyz

examples/basic_deterministic/mldsa_native/mldsa_native_config.h

@@ -364,13 +364,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -383,15 +383,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }

examples/basic_lowram/mldsa_native/mldsa_native_config.h

@@ -363,13 +363,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -382,15 +382,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }

examples/bring_your_own_fips202/mldsa_native/mldsa_native_config.h

@@ -364,13 +364,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -383,15 +383,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }

examples/bring_your_own_fips202_static/mldsa_native/mldsa_native_config.h

@@ -365,13 +365,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -384,15 +384,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }

examples/custom_backend/mldsa_native/mldsa_native_config.h

@@ -360,13 +360,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -379,15 +379,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }

examples/monolithic_build/mldsa_native/mldsa_native_config.h

@@ -363,13 +363,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -382,15 +382,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }

examples/monolithic_build_multilevel/mldsa_native/mldsa_native_config.h

@@ -364,13 +364,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -383,15 +383,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }

examples/monolithic_build_multilevel_native/mldsa_native/mldsa_native_config.h

@@ -364,13 +364,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -383,15 +383,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }

examples/monolithic_build_native/mldsa_native/mldsa_native_config.h

@@ -363,13 +363,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -382,15 +382,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }

examples/multilevel_build/mldsa_native/mldsa_native_config.h

@@ -363,13 +363,13 @@
  *              zeroizes intermediate stack buffers before returning from
  *              function calls.
  *
- *              Set this option and define `mld_zeroize_native` if you want to
+ *              Set this option and define `mld_zeroize` if you want to
  *              use a custom method to zeroize intermediate stack buffers.
  *              The default implementation uses SecureZeroMemory on Windows
  *              and a memset + compiler barrier otherwise. If neither of those
  *              is available on the target platform, compilation will fail,
  *              and you will need to use MLD_CONFIG_CUSTOM_ZEROIZE to provide
- *              a custom implementation of `mld_zeroize_native()`.
+ *              a custom implementation of `mld_zeroize()`.
  *
  *              WARNING:
  *              The explicit stack zeroization conducted by mldsa-native
@@ -382,15 +382,15 @@
  *
  *              If you need bullet-proof zeroization of the stack, you need to
  *              consider additional measures instead of what this feature
- *              provides. In this case, you can set mld_zeroize_native to a
+ *              provides. In this case, you can set mld_zeroize to a
  *              no-op.
  *
  *****************************************************************************/
 /* #define MLD_CONFIG_CUSTOM_ZEROIZE
    #if !defined(__ASSEMBLER__)
    #include <stdint.h>
    #include "src/src.h"
-   static MLD_INLINE void mld_zeroize_native(void *ptr, size_t len)
+   static MLD_INLINE void mld_zeroize(void *ptr, size_t len)
    {
        ... your implementation ...
    }