Minimizing the time: included existing C interfaces

This includes the C interfaces that exist to overwrite sensitive data from
memory such as explicit_bzero. As this is a common mistake not to overwrite
the data, I think listing these interfaces has value even if a complete solution
that includes security from the memory swap is harder.

Signed-off-by: Nikos Mavrogiannopoulos <[email protected]>

Author: Nikos Mavrogiannopoulos

secure_software_development_fundamentals.md

@@ -4956,6 +4956,8 @@ The normal comparison operations (such as **is-equal**) try to minimize executio
 
 *Constant-time comparisons* are comparisons (usually equality) that take the same time no matter what data is provided to them. These are not the same as O(1) operations in computer science. Examples of these constant-time comparison functions are:
 
+* OpenSSL: **CRYPTO_memcmp**
+
 * Node.js: **crypto.timingSafeEqual**
 
 * Ruby on Rails: **ActiveSupport::SecurityUtils secure_compare** and **fixed_length_secure_compare**
@@ -4966,7 +4968,13 @@ Whenever you compare secret values or cryptographic values (such as session keys
 
 #### Minimizing the Time Keys/Decrypted Data Exists
 
-Remember that per least privilege, we want to minimize the time a privilege is active. In cryptography, you often want to minimize the time a private key or password is available, or at least minimize the time that the decrypted data is available. This can be harder that you might think. At the operating system level you can probably lock it into memory with **mlock()** or **VirtualLock()**; this will at least prevent the data from being copied into storage. Ideally, you would erase it from memory after use, though that is often surprisingly difficult. Compilers may turn overwrite code into a no-op, because they detect that nothing reads the overwritten values. Languages with built-in garbage collection often quietly make extra copies and/or do not provide a mechanism for erasure. That said, some languages or infrastructure do make this easy. For example, those using the .NET framework (e.g., C#) can use SecureString.
+Remember that per least privilege, we want to minimize the time a privilege is active. In cryptography, you often want to minimize the time a private key or password is available, or at least minimize the time that the decrypted data is available. This can be harder that you might think. At the operating system level you can probably lock it into memory with **mlock()** or **VirtualLock()**; this will at least prevent the data from being copied into storage. Ideally, you would erase it from memory after use using interfaces that are safe for that purpose. Compiler optimizers may quietly eliminate the code to overwrite data, because they detect that nothing else in the program reads the overwritten values. In addition, languages with built-in garbage collection often quietly make extra copies and/or do not provide a mechanism for erasure. The following interfaces in C and C++ are safer for overwriting sensitive data in memory.
+
+* Linux: **explicit_bzero**
+
+* Windows: **SecureZeroMemory**
+
+Languages with built-in garbage collection often quietly make extra copies and/or do not provide a mechanism for erasure. That said, some languages or infrastructure do make this easy. For example, those using the .NET framework (e.g., C#) can use SecureString.
 
 #### Quantum Computing