"Fossies" - the Fresh Open Source Software Archive

Member "cryptsetup-2.4.3/lib/utils_safe_memory.c" (13 Jan 2022, 2448 Bytes) of package /linux/misc/cryptsetup-2.4.3.tar.xz:

    1 /*
    2  * utils_safe_memory - safe memory helpers
    3  *
    4  * Copyright (C) 2009-2021 Red Hat, Inc. All rights reserved.
    5  * Copyright (C) 2009-2021 Milan Broz
    6  *
    7  * This program is free software; you can redistribute it and/or
    8  * modify it under the terms of the GNU General Public License
    9  * as published by the Free Software Foundation; either version 2
   10  * of the License, or (at your option) any later version.
   11  *
   12  * This program is distributed in the hope that it will be useful,
   13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   15  * GNU General Public License for more details.
   16  *
   17  * You should have received a copy of the GNU General Public License
   18  * along with this program; if not, write to the Free Software
   19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
   20  */
   21 
   22 #include <stdlib.h>
   23 #include <string.h>
   24 #include "libcryptsetup.h"
   25 
   26 struct safe_allocation {
   27     size_t  size;
   28     char    data[0];
   29 };
   30 
   31 /*
   32  * Replacement for memset(s, 0, n) on stack that can be optimized out
   33  * Also used in safe allocations for explicit memory wipe.
   34  */
   35 void crypt_safe_memzero(void *data, size_t size)
   36 {
   37 #ifdef HAVE_EXPLICIT_BZERO
   38     explicit_bzero(data, size);
   39 #else
   40     volatile uint8_t *p = (volatile uint8_t *)data;
   41 
   42     while(size--)
   43         *p++ = 0;
   44 #endif
   45 }
   46 
   47 /* safe allocations */
   48 void *crypt_safe_alloc(size_t size)
   49 {
   50     struct safe_allocation *alloc;
   51 
   52     if (!size || size > (SIZE_MAX - offsetof(struct safe_allocation, data)))
   53         return NULL;
   54 
   55     alloc = malloc(size + offsetof(struct safe_allocation, data));
   56     if (!alloc)
   57         return NULL;
   58 
   59     alloc->size = size;
   60     crypt_safe_memzero(&alloc->data, size);
   61 
   62     /* coverity[leaked_storage] */
   63     return &alloc->data;
   64 }
   65 
   66 void crypt_safe_free(void *data)
   67 {
   68     struct safe_allocation *alloc;
   69     volatile size_t *s;
   70 
   71     if (!data)
   72         return;
   73 
   74     alloc = (struct safe_allocation *)
   75         ((char *)data - offsetof(struct safe_allocation, data));
   76 
   77     crypt_safe_memzero(data, alloc->size);
   78 
   79     s = (volatile size_t *)&alloc->size;
   80     *s = 0x55aa55aa;
   81     free(alloc);
   82 }
   83 
   84 void *crypt_safe_realloc(void *data, size_t size)
   85 {
   86     struct safe_allocation *alloc;
   87     void *new_data;
   88 
   89     new_data = crypt_safe_alloc(size);
   90 
   91     if (new_data && data) {
   92 
   93         alloc = (struct safe_allocation *)
   94             ((char *)data - offsetof(struct safe_allocation, data));
   95 
   96         if (size > alloc->size)
   97             size = alloc->size;
   98 
   99         memcpy(new_data, data, size);
  100     }
  101 
  102     crypt_safe_free(data);
  103     return new_data;
  104 }