How to zero a buffer(daemonology.net)

  memset(key, 0, sizeof(key)); 
  if (key[0])  // we are using key, so you can't skip memset()
    dropDead();

    Consider again the line that initializes pInstance:

    pInstance = new Singleton;

    This statement causes three things to happen:
    Step 1: Allocate memory to hold a Singleton object.
    Step 2: Construct a Singleton object in the allocated memory.
    Step 3: Make pInstance point to the allocated memory.

    [...]

    DCLP will work only if steps 1 and 2 are completed before
    step 3 is performed, but *there is no way to express this
    constraint in C or C++*.

  static void secure_memset(void *, int, size_t) __attribute__((weakref("memset")));

    foo->bar->baz[i].oof = foo->bar->baz[i].durb + meep;

   what *tmp = foo->bar->baz[i];
   tmp->oof = tmp->durb + meep;

      static void * (* const volatile memset_ptr)(void *, int, size_t) = memset;     

    #include <string.h>

    void doSecure(void)  
    {  
        /*char key[32];*/  
        char *key = (char*) malloc(sizeof(char)*32);

        memset(key,sizeof(char),32);  
    }

    int main(void)  
    {  
        doSecure();

        return 0;  
    }

    -- key on stack

    main:  
    .LFB13:  
        .cfi_startproc  
        xorl	%eax, %eax  
        ret  
        .cfi_endproc

    -- key on heap

    main:  
    .LFB13:  
        .cfi_startproc  
        subq	$8, %rsp  
        .cfi_def_cfa_offset 16  
        movl	$32, %edi  
        call	malloc  
        movabsq	$72340172838076673, %rdx  
        movq	%rdx, (%rax)  
        movq	%rdx, 8(%rax)  
        movq	%rdx, 16(%rax)  
        movq	%rdx, 24(%rax)  
        xorl	%eax, %eax  
        addq	$8, %rsp  
        .cfi_def_cfa_offset 8  
        ret  
        .cfi_endproc

    asm ("" : : "m" (&key));

    /* implemented in another translation unit */
    void zero_for_sure(void *data, size_t size);

    void func(void)
    {
      char securedata[42];
      /* ... */
      zero_for_sure(securedata, sizeof securedata);
    }

   void zero_for_sure(void *ptr, size_t size)
   {
      memset(ptr, 0, size);
   }

   void zero_for_sure(void *ptr, size_t size)
   {
      char securedata[42];
      /* ... */
      memset(securedata, 0, sizeof securedata);
      commit(securedata);
   }