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