imapfilter/imapfilter/memory.c

#include <stdlib.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>          /* IEEE Std 1003.1-2001 transitional. */
#include <sys/time.h>           /* IEEE Std 1003.1-2001 transitional. */
#include <sys/resource.h>

#include "config.h"
#include "imapfilter.h"


/* Secure memory information. */
typedef struct secmem {
        void *buf;              /* Allocated memory buffer. */
        size_t size;            /* Size of the buffer. */
        struct secmem *prev, *next;     /* Previous/next node of doubly linked
                                         * list. */
} secmem_t;


extern unsigned int options;

static secmem_t *secmem = NULL; /* First node of secure memory linked list. */


void secmem_append(secmem_t * sm);
secmem_t *secmem_find(void *ptr);
void secmem_remove(secmem_t * sm);


/*
 * A malloc() that checks the results and dies in case of error.
 */
void *
xmalloc(size_t size)
{
        void *ptr;

        ptr = (void *)malloc(size);

        if (ptr == NULL)
                fatal(ERROR_MEMALLOC,
                    "allocating memory; %s\n", strerror(errno));

        return ptr;
}


/*
 * A realloc() that checks the results and dies in case of error.
 */
void *
xrealloc(void *ptr, size_t size)
{
        ptr = (void *)realloc(ptr, size);

        if (ptr == NULL)
                fatal(ERROR_MEMALLOC,
                    "allocating memory; %s\n", strerror(errno));

        return ptr;
}


/*
 * A free() that dies if fed with NULL pointer.
 */
void
xfree(void *ptr)
{
        if (ptr == NULL)
                fatal(ERROR_MEMALLOC,
                    "NULL pointer given as argument");
        free(ptr);
}


/*
 * A strdup() that checks the results and dies in case of error.
 */
char *
xstrdup(const char *s)
{
        char *cp;

        cp = strdup(s);

        if (cp == NULL)
                fatal(ERROR_MEMALLOC, "allocating memory; %s\n", strerror(errno));

        return cp;
}


/*
 * Secure memory malloc().  Locks memory and keeps information about the
 * chunk that was allocated.
 */
void *
smalloc(size_t size)
{
        void *ptr;
        secmem_t *sm;

        ptr = xmalloc(size);

        sm = (secmem_t *) xmalloc(sizeof(secmem_t));

        sm->buf = ptr;
        sm->size = size;
        sm->prev = sm->next = NULL;

        secmem_append(sm);

        return ptr;
}


/*
 * Secure memory realloc().  Resize memory by allocating a new memory chunk
 * and NULL fill old memory, in order to protect sensitive data.
 */
void *
srealloc(void *ptr, size_t size)
{
        void *p;
        secmem_t *sm;

        if (!(sm = (secmem_t *) secmem_find(ptr))) {
                ptr = xrealloc(ptr, size);
                return ptr;
        }
        p = smalloc(size);
        memcpy(p, sm->buf, min(sm->size, size));

        memset(sm->buf, 0, sm->size);
        secmem_remove(sm);
        xfree(sm->buf);
        xfree(sm);

        return p;
}


/*
 * Secure memory free().  NULL fill memory before freeing it.
 */
void
sfree(void *ptr)
{
        secmem_t *sm;

        if (!(sm = (secmem_t *) secmem_find(ptr))) {
                xfree(ptr);
                return;
        }
        memset(sm->buf, 0, sm->size);
        secmem_remove(sm);
        xfree(sm->buf);
        xfree(sm);
}


/*
 * Secure memory strdup().  Uses secure memory allocation.
 */
char *
sstrdup(const char *s)
{
        char *p;

        p = (char *)smalloc(strlen(s) + 1);
        xstrncpy(p, s, strlen(s));

        return p;
}


/*
 * Append information about the newly allocated memory buffer.
 */
void
secmem_append(secmem_t * sm)
{
        secmem_t *pos;
        secmem_t **app;

        app = &secmem;
        pos = secmem;

        while (pos) {
                sm->prev = pos;
                app = &(pos->next);
                pos = pos->next;
        }

        *app = sm;
}


/*
 * Find the record of a memory buffer in the secure memory linked list.
 */
secmem_t *
secmem_find(void *ptr)
{
        secmem_t *pos;

        pos = secmem;

        while (pos != NULL && pos->buf != ptr)
                pos = pos->next;

        return pos;
}


/*
 * Remove a record of a secure memory buffer.
 */
void
secmem_remove(secmem_t * sm)
{
        if (sm->prev != NULL)
                sm->prev->next = sm->next;
        if (sm->next != NULL)
                sm->next->prev = sm->prev;
        if (secmem == sm)
                secmem = sm->next;

}


/*
 * Overwrite/clear all secure memory.
 */
void
secmem_clear(void)
{
        secmem_t *p, *t;

        for (p = secmem; p != NULL; p = t) {
                t = p->next;
                sfree(p->buf);
        }
}


/*
 * Disable core file dumping.
 */
void
corefile_disable(void)
{
        struct rlimit rl;

        getrlimit(RLIMIT_CORE, &rl);

        rl.rlim_cur = rl.rlim_max = 0;
        setrlimit(RLIMIT_CORE, &rl);
}
1	#include <stdlib.h>
2	#include <stdlib.h>
3	#include <unistd.h>
4	#include <string.h>
5	#include <errno.h>
6	#include <sys/types.h> /* IEEE Std 1003.1-2001 transitional. */
7	#include <sys/time.h> /* IEEE Std 1003.1-2001 transitional. */
8	#include <sys/resource.h>
9
10	#include "config.h"
11	#include "imapfilter.h"
12
13
14	/* Secure memory information. */
15	typedef struct secmem {
16	void buf; / Allocated memory buffer. */
17	size_t size; /* Size of the buffer. */
18	struct secmem prev, next; /* Previous/next node of doubly linked
19	* list. */
20	} secmem_t;
21
22
23	extern unsigned int options;
24
25	static secmem_t secmem = NULL; / First node of secure memory linked list. */
26
27
28	void secmem_append(secmem_t * sm);
29	secmem_t secmem_find(void ptr);
30	void secmem_remove(secmem_t * sm);
31
32
33	/*
34	* A malloc() that checks the results and dies in case of error.
35	*/
36	void *
37	xmalloc(size_t size)
38	{
39	void *ptr;
40
41	ptr = (void *)malloc(size);
42
43	if (ptr == NULL)
44	fatal(ERROR_MEMALLOC,
45	"allocating memory; %s\n", strerror(errno));
46
47	return ptr;
48	}
49
50
51	/*
52	* A realloc() that checks the results and dies in case of error.
53	*/
54	void *
55	xrealloc(void *ptr, size_t size)
56	{
57	ptr = (void *)realloc(ptr, size);
58
59	if (ptr == NULL)
60	fatal(ERROR_MEMALLOC,
61	"allocating memory; %s\n", strerror(errno));
62
63	return ptr;
64	}
65
66
67	/*
68	* A free() that dies if fed with NULL pointer.
69	*/
70	void
71	xfree(void *ptr)
72	{
73	if (ptr == NULL)
74	fatal(ERROR_MEMALLOC,
75	"NULL pointer given as argument");
76	free(ptr);
77	}
78
79
80	/*
81	* A strdup() that checks the results and dies in case of error.
82	*/
83	char *
84	xstrdup(const char *s)
85	{
86	char *cp;
87
88	cp = strdup(s);
89
90	if (cp == NULL)
91	fatal(ERROR_MEMALLOC, "allocating memory; %s\n", strerror(errno));
92
93	return cp;
94	}
95
96
97	/*
98	* Secure memory malloc(). Locks memory and keeps information about the
99	* chunk that was allocated.
100	*/
101	void *
102	smalloc(size_t size)
103	{
104	void *ptr;
105	secmem_t *sm;
106
107	ptr = xmalloc(size);
108
109	sm = (secmem_t *) xmalloc(sizeof(secmem_t));
110
111	sm->buf = ptr;
112	sm->size = size;
113	sm->prev = sm->next = NULL;
114
115	secmem_append(sm);
116
117	return ptr;
118	}
119
120
121	/*
122	* Secure memory realloc(). Resize memory by allocating a new memory chunk
123	* and NULL fill old memory, in order to protect sensitive data.
124	*/
125	void *
126	srealloc(void *ptr, size_t size)
127	{
128	void *p;
129	secmem_t *sm;
130
131	if (!(sm = (secmem_t *) secmem_find(ptr))) {
132	ptr = xrealloc(ptr, size);
133	return ptr;
134	}
135	p = smalloc(size);
136	memcpy(p, sm->buf, min(sm->size, size));
137
138	memset(sm->buf, 0, sm->size);
139	secmem_remove(sm);
140	xfree(sm->buf);
141	xfree(sm);
142
143	return p;
144	}
145
146
147	/*
148	* Secure memory free(). NULL fill memory before freeing it.
149	*/
150	void
151	sfree(void *ptr)
152	{
153	secmem_t *sm;
154
155	if (!(sm = (secmem_t *) secmem_find(ptr))) {
156	xfree(ptr);
157	return;
158	}
159	memset(sm->buf, 0, sm->size);
160	secmem_remove(sm);
161	xfree(sm->buf);
162	xfree(sm);
163	}
164
165
166	/*
167	* Secure memory strdup(). Uses secure memory allocation.
168	*/
169	char *
170	sstrdup(const char *s)
171	{
172	char *p;
173
174	p = (char *)smalloc(strlen(s) + 1);
175	xstrncpy(p, s, strlen(s));
176
177	return p;
178	}
179
180
181	/*
182	* Append information about the newly allocated memory buffer.
183	*/
184	void
185	secmem_append(secmem_t * sm)
186	{
187	secmem_t *pos;
188	secmem_t **app;
189
190	app = &secmem;
191	pos = secmem;
192
193	while (pos) {
194	sm->prev = pos;
195	app = &(pos->next);
196	pos = pos->next;
197	}
198
199	*app = sm;
200	}
201
202
203	/*
204	* Find the record of a memory buffer in the secure memory linked list.
205	*/
206	secmem_t *
207	secmem_find(void *ptr)
208	{
209	secmem_t *pos;
210
211	pos = secmem;
212
213	while (pos != NULL && pos->buf != ptr)
214	pos = pos->next;
215
216	return pos;
217	}
218
219
220	/*
221	* Remove a record of a secure memory buffer.
222	*/
223	void
224	secmem_remove(secmem_t * sm)
225	{
226	if (sm->prev != NULL)
227	sm->prev->next = sm->next;
228	if (sm->next != NULL)
229	sm->next->prev = sm->prev;
230	if (secmem == sm)
231	secmem = sm->next;
232
233	}
234
235
236	/*
237	* Overwrite/clear all secure memory.
238	*/
239	void
240	secmem_clear(void)
241	{
242	secmem_t p, t;
243
244	for (p = secmem; p != NULL; p = t) {
245	t = p->next;
246	sfree(p->buf);
247	}
248	}
249
250
251	/*
252	* Disable core file dumping.
253	*/
254	void
255	corefile_disable(void)
256	{
257	struct rlimit rl;
258
259	getrlimit(RLIMIT_CORE, &rl);
260
261	rl.rlim_cur = rl.rlim_max = 0;
262	setrlimit(RLIMIT_CORE, &rl);
263	}