Fix Serpent-AVX2 and Camellia-AVX2 counter modes
[libgcrypt.git] / src / secmem.c
1 /* secmem.c  -  memory allocation from a secure heap
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003, 2007 Free Software Foundation, Inc.
4  * Copyright (C) 2013 g10 Code GmbH
5  *
6  * This file is part of Libgcrypt.
7  *
8  * Libgcrypt is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser general Public License as
10  * published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * Libgcrypt is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <stdarg.h>
28 #include <unistd.h>
29 #include <stddef.h>
30
31 #if defined(HAVE_MLOCK) || defined(HAVE_MMAP)
32 #include <sys/mman.h>
33 #include <sys/types.h>
34 #include <fcntl.h>
35 #ifdef USE_CAPABILITIES
36 #include <sys/capability.h>
37 #endif
38 #endif
39
40 #include "ath.h"
41 #include "g10lib.h"
42 #include "secmem.h"
43
44 #if defined (MAP_ANON) && ! defined (MAP_ANONYMOUS)
45 #define MAP_ANONYMOUS MAP_ANON
46 #endif
47
48 #define MINIMUM_POOL_SIZE 16384
49 #define STANDARD_POOL_SIZE 32768
50 #define DEFAULT_PAGE_SIZE 4096
51
52 typedef struct memblock
53 {
54   unsigned size;                /* Size of the memory available to the
55                                    user.  */
56   int flags;                    /* See below.  */
57   PROPERLY_ALIGNED_TYPE aligned;
58 } memblock_t;
59
60 /* This flag specifies that the memory block is in use.  */
61 #define MB_FLAG_ACTIVE (1 << 0)
62
63 /* The pool of secure memory.  */
64 static void *pool;
65
66 /* Size of POOL in bytes.  */
67 static size_t pool_size;
68
69 /* True, if the memory pool is ready for use.  May be checked in an
70    atexit function.  */
71 static volatile int pool_okay;
72
73 /* True, if the memory pool is mmapped.  */
74 static volatile int pool_is_mmapped;
75
76 /* FIXME?  */
77 static int disable_secmem;
78 static int show_warning;
79 static int not_locked;
80 static int no_warning;
81 static int suspend_warning;
82 static int no_mlock;
83 static int no_priv_drop;
84
85 /* Stats.  */
86 static unsigned int cur_alloced, cur_blocks;
87
88 /* Lock protecting accesses to the memory pool.  */
89 static ath_mutex_t secmem_lock;
90
91 /* Convenient macros.  */
92 #define SECMEM_LOCK   ath_mutex_lock   (&secmem_lock)
93 #define SECMEM_UNLOCK ath_mutex_unlock (&secmem_lock)
94
95 /* The size of the memblock structure; this does not include the
96    memory that is available to the user.  */
97 #define BLOCK_HEAD_SIZE \
98   offsetof (memblock_t, aligned)
99
100 /* Convert an address into the according memory block structure.  */
101 #define ADDR_TO_BLOCK(addr) \
102   (memblock_t *) ((char *) addr - BLOCK_HEAD_SIZE)
103
104 /* Check whether P points into the pool.  */
105 static int
106 ptr_into_pool_p (const void *p)
107 {
108   /* We need to convert pointers to addresses.  This is required by
109      C-99 6.5.8 to avoid undefined behaviour.  Using size_t is at
110      least only implementation defined.  See also
111      http://lists.gnupg.org/pipermail/gcrypt-devel/2007-February/001102.html
112   */
113   size_t p_addr = (size_t)p;
114   size_t pool_addr = (size_t)pool;
115
116   return p_addr >= pool_addr && p_addr <  pool_addr+pool_size;
117 }
118
119 /* Update the stats.  */
120 static void
121 stats_update (size_t add, size_t sub)
122 {
123   if (add)
124     {
125       cur_alloced += add;
126       cur_blocks++;
127     }
128   if (sub)
129     {
130       cur_alloced -= sub;
131       cur_blocks--;
132     }
133 }
134
135 /* Return the block following MB or NULL, if MB is the last block.  */
136 static memblock_t *
137 mb_get_next (memblock_t *mb)
138 {
139   memblock_t *mb_next;
140
141   mb_next = (memblock_t *) ((char *) mb + BLOCK_HEAD_SIZE + mb->size);
142
143   if (! ptr_into_pool_p (mb_next))
144     mb_next = NULL;
145
146   return mb_next;
147 }
148
149 /* Return the block preceding MB or NULL, if MB is the first
150    block.  */
151 static memblock_t *
152 mb_get_prev (memblock_t *mb)
153 {
154   memblock_t *mb_prev, *mb_next;
155
156   if (mb == pool)
157     mb_prev = NULL;
158   else
159     {
160       mb_prev = (memblock_t *) pool;
161       while (1)
162         {
163           mb_next = mb_get_next (mb_prev);
164           if (mb_next == mb)
165             break;
166           else
167             mb_prev = mb_next;
168         }
169     }
170
171   return mb_prev;
172 }
173
174 /* If the preceding block of MB and/or the following block of MB
175    exist and are not active, merge them to form a bigger block.  */
176 static void
177 mb_merge (memblock_t *mb)
178 {
179   memblock_t *mb_prev, *mb_next;
180
181   mb_prev = mb_get_prev (mb);
182   mb_next = mb_get_next (mb);
183
184   if (mb_prev && (! (mb_prev->flags & MB_FLAG_ACTIVE)))
185     {
186       mb_prev->size += BLOCK_HEAD_SIZE + mb->size;
187       mb = mb_prev;
188     }
189   if (mb_next && (! (mb_next->flags & MB_FLAG_ACTIVE)))
190     mb->size += BLOCK_HEAD_SIZE + mb_next->size;
191 }
192
193 /* Return a new block, which can hold SIZE bytes.  */
194 static memblock_t *
195 mb_get_new (memblock_t *block, size_t size)
196 {
197   memblock_t *mb, *mb_split;
198
199   for (mb = block; ptr_into_pool_p (mb); mb = mb_get_next (mb))
200     if (! (mb->flags & MB_FLAG_ACTIVE) && mb->size >= size)
201       {
202         /* Found a free block.  */
203         mb->flags |= MB_FLAG_ACTIVE;
204
205         if (mb->size - size > BLOCK_HEAD_SIZE)
206           {
207             /* Split block.  */
208
209             mb_split = (memblock_t *) (((char *) mb) + BLOCK_HEAD_SIZE + size);
210             mb_split->size = mb->size - size - BLOCK_HEAD_SIZE;
211             mb_split->flags = 0;
212
213             mb->size = size;
214
215             mb_merge (mb_split);
216
217           }
218
219         break;
220       }
221
222   if (! ptr_into_pool_p (mb))
223     {
224       gpg_err_set_errno (ENOMEM);
225       mb = NULL;
226     }
227
228   return mb;
229 }
230
231 /* Print a warning message.  */
232 static void
233 print_warn (void)
234 {
235   if (!no_warning)
236     log_info (_("Warning: using insecure memory!\n"));
237 }
238
239 /* Lock the memory pages into core and drop privileges.  */
240 static void
241 lock_pool (void *p, size_t n)
242 {
243 #if defined(USE_CAPABILITIES) && defined(HAVE_MLOCK)
244   int err;
245
246   cap_set_proc (cap_from_text ("cap_ipc_lock+ep"));
247   err = no_mlock? 0 : mlock (p, n);
248   if (err && errno)
249     err = errno;
250   cap_set_proc (cap_from_text ("cap_ipc_lock+p"));
251
252   if (err)
253     {
254       if (errno != EPERM
255 #ifdef EAGAIN   /* OpenBSD returns this */
256           && errno != EAGAIN
257 #endif
258 #ifdef ENOSYS   /* Some SCOs return this (function not implemented) */
259           && errno != ENOSYS
260 #endif
261 #ifdef ENOMEM  /* Linux might return this. */
262             && errno != ENOMEM
263 #endif
264           )
265         log_error ("can't lock memory: %s\n", strerror (err));
266       show_warning = 1;
267       not_locked = 1;
268     }
269
270 #elif defined(HAVE_MLOCK)
271   uid_t uid;
272   int err;
273
274   uid = getuid ();
275
276 #ifdef HAVE_BROKEN_MLOCK
277   /* Under HP/UX mlock segfaults if called by non-root.  Note, we have
278      noch checked whether mlock does really work under AIX where we
279      also detected a broken nlock.  Note further, that using plock ()
280      is not a good idea under AIX. */
281   if (uid)
282     {
283       errno = EPERM;
284       err = errno;
285     }
286   else
287     {
288       err = no_mlock? 0 : mlock (p, n);
289       if (err && errno)
290         err = errno;
291     }
292 #else /* !HAVE_BROKEN_MLOCK */
293   err = no_mlock? 0 : mlock (p, n);
294   if (err && errno)
295     err = errno;
296 #endif /* !HAVE_BROKEN_MLOCK */
297
298   /* Test whether we are running setuid(0).  */
299   if (uid && ! geteuid ())
300     {
301       /* Yes, we are.  */
302       if (!no_priv_drop)
303         {
304           /* Check that we really dropped the privs.
305            * Note: setuid(0) should always fail */
306           if (setuid (uid) || getuid () != geteuid () || !setuid (0))
307             log_fatal ("failed to reset uid: %s\n", strerror (errno));
308         }
309     }
310
311   if (err)
312     {
313       if (errno != EPERM
314 #ifdef EAGAIN   /* OpenBSD returns this. */
315           && errno != EAGAIN
316 #endif
317 #ifdef ENOSYS   /* Some SCOs return this (function not implemented). */
318           && errno != ENOSYS
319 #endif
320 #ifdef ENOMEM  /* Linux might return this. */
321             && errno != ENOMEM
322 #endif
323           )
324         log_error ("can't lock memory: %s\n", strerror (err));
325       show_warning = 1;
326       not_locked = 1;
327     }
328
329 #elif defined ( __QNX__ )
330   /* QNX does not page at all, so the whole secure memory stuff does
331    * not make much sense.  However it is still of use because it
332    * wipes out the memory on a free().
333    * Therefore it is sufficient to suppress the warning.  */
334   (void)p;
335   (void)n;
336 #elif defined (HAVE_DOSISH_SYSTEM) || defined (__CYGWIN__)
337     /* It does not make sense to print such a warning, given the fact that
338      * this whole Windows !@#$% and their user base are inherently insecure. */
339   (void)p;
340   (void)n;
341 #elif defined (__riscos__)
342     /* No virtual memory on RISC OS, so no pages are swapped to disc,
343      * besides we don't have mmap, so we don't use it! ;-)
344      * But don't complain, as explained above.  */
345   (void)p;
346   (void)n;
347 #else
348   (void)p;
349   (void)n;
350   if (!no_mlock)
351     log_info ("Please note that you don't have secure memory on this system\n");
352 #endif
353 }
354
355 /* Initialize POOL.  */
356 static void
357 init_pool (size_t n)
358 {
359   size_t pgsize;
360   long int pgsize_val;
361   memblock_t *mb;
362
363   pool_size = n;
364
365   if (disable_secmem)
366     log_bug ("secure memory is disabled");
367
368 #if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
369   pgsize_val = sysconf (_SC_PAGESIZE);
370 #elif defined(HAVE_GETPAGESIZE)
371   pgsize_val = getpagesize ();
372 #else
373   pgsize_val = -1;
374 #endif
375   pgsize = (pgsize_val != -1 && pgsize_val > 0)? pgsize_val:DEFAULT_PAGE_SIZE;
376
377
378 #if HAVE_MMAP
379   pool_size = (pool_size + pgsize - 1) & ~(pgsize - 1);
380 #ifdef MAP_ANONYMOUS
381   pool = mmap (0, pool_size, PROT_READ | PROT_WRITE,
382                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
383 #else /* map /dev/zero instead */
384   {
385     int fd;
386
387     fd = open ("/dev/zero", O_RDWR);
388     if (fd == -1)
389       {
390         log_error ("can't open /dev/zero: %s\n", strerror (errno));
391         pool = (void *) -1;
392       }
393     else
394       {
395         pool = mmap (0, pool_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
396         close (fd);
397       }
398   }
399 #endif
400   if (pool == (void *) -1)
401     log_info ("can't mmap pool of %u bytes: %s - using malloc\n",
402               (unsigned) pool_size, strerror (errno));
403   else
404     {
405       pool_is_mmapped = 1;
406       pool_okay = 1;
407     }
408
409 #endif
410   if (!pool_okay)
411     {
412       pool = malloc (pool_size);
413       if (!pool)
414         log_fatal ("can't allocate memory pool of %u bytes\n",
415                    (unsigned) pool_size);
416       else
417         pool_okay = 1;
418     }
419
420   /* Initialize first memory block.  */
421   mb = (memblock_t *) pool;
422   mb->size = pool_size;
423   mb->flags = 0;
424 }
425
426 void
427 _gcry_secmem_set_flags (unsigned flags)
428 {
429   int was_susp;
430
431   SECMEM_LOCK;
432
433   was_susp = suspend_warning;
434   no_warning = flags & GCRY_SECMEM_FLAG_NO_WARNING;
435   suspend_warning = flags & GCRY_SECMEM_FLAG_SUSPEND_WARNING;
436   no_mlock      = flags & GCRY_SECMEM_FLAG_NO_MLOCK;
437   no_priv_drop = flags & GCRY_SECMEM_FLAG_NO_PRIV_DROP;
438
439   /* and now issue the warning if it is not longer suspended */
440   if (was_susp && !suspend_warning && show_warning)
441     {
442       show_warning = 0;
443       print_warn ();
444     }
445
446   SECMEM_UNLOCK;
447 }
448
449 unsigned int
450 _gcry_secmem_get_flags (void)
451 {
452   unsigned flags;
453
454   SECMEM_LOCK;
455
456   flags = no_warning ? GCRY_SECMEM_FLAG_NO_WARNING : 0;
457   flags |= suspend_warning ? GCRY_SECMEM_FLAG_SUSPEND_WARNING : 0;
458   flags |= not_locked ? GCRY_SECMEM_FLAG_NOT_LOCKED : 0;
459   flags |= no_mlock ? GCRY_SECMEM_FLAG_NO_MLOCK : 0;
460   flags |= no_priv_drop ? GCRY_SECMEM_FLAG_NO_PRIV_DROP : 0;
461
462   SECMEM_UNLOCK;
463
464   return flags;
465 }
466
467
468 /* See _gcry_secmem_init.  This function is expected to be called with
469    the secmem lock held. */
470 static void
471 secmem_init (size_t n)
472 {
473   if (!n)
474     {
475 #ifdef USE_CAPABILITIES
476       /* drop all capabilities */
477       cap_set_proc (cap_from_text ("all-eip"));
478
479 #elif !defined(HAVE_DOSISH_SYSTEM)
480       uid_t uid;
481
482       disable_secmem = 1;
483       uid = getuid ();
484       if (uid != geteuid ())
485         {
486           if (setuid (uid) || getuid () != geteuid () || !setuid (0))
487             log_fatal ("failed to drop setuid\n");
488         }
489 #endif
490     }
491   else
492     {
493       if (n < MINIMUM_POOL_SIZE)
494         n = MINIMUM_POOL_SIZE;
495       if (! pool_okay)
496         {
497           init_pool (n);
498           lock_pool (pool, n);
499         }
500       else
501         log_error ("Oops, secure memory pool already initialized\n");
502     }
503 }
504
505
506
507 /* Initialize the secure memory system.  If running with the necessary
508    privileges, the secure memory pool will be locked into the core in
509    order to prevent page-outs of the data.  Furthermore allocated
510    secure memory will be wiped out when released.  */
511 void
512 _gcry_secmem_init (size_t n)
513 {
514   SECMEM_LOCK;
515
516   secmem_init (n);
517
518   SECMEM_UNLOCK;
519 }
520
521
522 gcry_err_code_t
523 _gcry_secmem_module_init ()
524 {
525   int err;
526
527   err = ath_mutex_init (&secmem_lock);
528   if (err)
529     log_fatal ("could not allocate secmem lock\n");
530
531   return 0;
532 }
533
534
535 static void *
536 _gcry_secmem_malloc_internal (size_t size)
537 {
538   memblock_t *mb;
539
540   if (!pool_okay)
541     {
542       /* Try to initialize the pool if the user forgot about it.  */
543       secmem_init (STANDARD_POOL_SIZE);
544       if (!pool_okay)
545         {
546           log_info (_("operation is not possible without "
547                       "initialized secure memory\n"));
548           gpg_err_set_errno (ENOMEM);
549           return NULL;
550         }
551     }
552   if (not_locked && fips_mode ())
553     {
554       log_info (_("secure memory pool is not locked while in FIPS mode\n"));
555       gpg_err_set_errno (ENOMEM);
556       return NULL;
557     }
558   if (show_warning && !suspend_warning)
559     {
560       show_warning = 0;
561       print_warn ();
562     }
563
564   /* Blocks are always a multiple of 32. */
565   size = ((size + 31) / 32) * 32;
566
567   mb = mb_get_new ((memblock_t *) pool, size);
568   if (mb)
569     stats_update (size, 0);
570
571   return mb ? &mb->aligned.c : NULL;
572 }
573
574 void *
575 _gcry_secmem_malloc (size_t size)
576 {
577   void *p;
578
579   SECMEM_LOCK;
580   p = _gcry_secmem_malloc_internal (size);
581   SECMEM_UNLOCK;
582
583   return p;
584 }
585
586 static void
587 _gcry_secmem_free_internal (void *a)
588 {
589   memblock_t *mb;
590   int size;
591
592   if (!a)
593     return;
594
595   mb = ADDR_TO_BLOCK (a);
596   size = mb->size;
597
598   /* This does not make much sense: probably this memory is held in the
599    * cache. We do it anyway: */
600 #define MB_WIPE_OUT(byte) \
601   wipememory2 ((memblock_t *) ((char *) mb + BLOCK_HEAD_SIZE), (byte), size);
602
603   MB_WIPE_OUT (0xff);
604   MB_WIPE_OUT (0xaa);
605   MB_WIPE_OUT (0x55);
606   MB_WIPE_OUT (0x00);
607
608   stats_update (0, size);
609
610   mb->flags &= ~MB_FLAG_ACTIVE;
611
612   /* Update stats.  */
613
614   mb_merge (mb);
615 }
616
617 /* Wipe out and release memory.  */
618 void
619 _gcry_secmem_free (void *a)
620 {
621   SECMEM_LOCK;
622   _gcry_secmem_free_internal (a);
623   SECMEM_UNLOCK;
624 }
625
626 /* Realloc memory.  */
627 void *
628 _gcry_secmem_realloc (void *p, size_t newsize)
629 {
630   memblock_t *mb;
631   size_t size;
632   void *a;
633
634   SECMEM_LOCK;
635
636   mb = (memblock_t *) ((char *) p - ((size_t) &((memblock_t *) 0)->aligned.c));
637   size = mb->size;
638   if (newsize < size)
639     {
640       /* It is easier to not shrink the memory.  */
641       a = p;
642     }
643   else
644     {
645       a = _gcry_secmem_malloc_internal (newsize);
646       if (a)
647         {
648           memcpy (a, p, size);
649           memset ((char *) a + size, 0, newsize - size);
650           _gcry_secmem_free_internal (p);
651         }
652     }
653
654   SECMEM_UNLOCK;
655
656   return a;
657 }
658
659
660 /* Return true if P points into the secure memory area.  */
661 int
662 _gcry_private_is_secure (const void *p)
663 {
664   return pool_okay && ptr_into_pool_p (p);
665 }
666
667
668 /****************
669  * Warning:  This code might be called by an interrupt handler
670  *           and frankly, there should really be such a handler,
671  *           to make sure that the memory is wiped out.
672  *           We hope that the OS wipes out mlocked memory after
673  *           receiving a SIGKILL - it really should do so, otherwise
674  *           there is no chance to get the secure memory cleaned.
675  */
676 void
677 _gcry_secmem_term ()
678 {
679   if (!pool_okay)
680     return;
681
682   wipememory2 (pool, 0xff, pool_size);
683   wipememory2 (pool, 0xaa, pool_size);
684   wipememory2 (pool, 0x55, pool_size);
685   wipememory2 (pool, 0x00, pool_size);
686 #if HAVE_MMAP
687   if (pool_is_mmapped)
688     munmap (pool, pool_size);
689 #endif
690   pool = NULL;
691   pool_okay = 0;
692   pool_size = 0;
693   not_locked = 0;
694 }
695
696
697 void
698 _gcry_secmem_dump_stats ()
699 {
700 #if 1
701   SECMEM_LOCK;
702
703  if (pool_okay)
704     log_info ("secmem usage: %u/%lu bytes in %u blocks\n",
705               cur_alloced, (unsigned long)pool_size, cur_blocks);
706   SECMEM_UNLOCK;
707 #else
708   memblock_t *mb;
709   int i;
710
711   SECMEM_LOCK;
712
713   for (i = 0, mb = (memblock_t *) pool;
714        ptr_into_pool_p (mb);
715        mb = mb_get_next (mb), i++)
716     log_info ("SECMEM: [%s] block: %i; size: %i\n",
717               (mb->flags & MB_FLAG_ACTIVE) ? "used" : "free",
718               i,
719               mb->size);
720   SECMEM_UNLOCK;
721 #endif
722 }