/src/openssl30/crypto/bn/bn_ctx.c

Source (jump to first uncovered line)
/*
 * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <openssl/trace.h>
#include "internal/cryptlib.h"
#include "bn_local.h"

/* How many bignums are in each "pool item"; */
#define BN_CTX_POOL_SIZE        16
/* The stack frame info is resizing, set a first-time expansion size; */
#define BN_CTX_START_FRAMES     32

/***********/
/* BN_POOL */
/***********/

/* A bundle of bignums that can be linked with other bundles */
typedef struct bignum_pool_item {
    /* The bignum values */
    BIGNUM vals[BN_CTX_POOL_SIZE];
    /* Linked-list admin */
    struct bignum_pool_item *prev, *next;
} BN_POOL_ITEM;
/* A linked-list of bignums grouped in bundles */
typedef struct bignum_pool {
    /* Linked-list admin */
    BN_POOL_ITEM *head, *current, *tail;
    /* Stack depth and allocation size */
    unsigned used, size;
} BN_POOL;
static void BN_POOL_init(BN_POOL *);
static void BN_POOL_finish(BN_POOL *);
static BIGNUM *BN_POOL_get(BN_POOL *, int);
static void BN_POOL_release(BN_POOL *, unsigned int);

/************/
/* BN_STACK */
/************/

/* A wrapper to manage the "stack frames" */
typedef struct bignum_ctx_stack {
    /* Array of indexes into the bignum stack */
    unsigned int *indexes;
    /* Number of stack frames, and the size of the allocated array */
    unsigned int depth, size;
} BN_STACK;
static void BN_STACK_init(BN_STACK *);
static void BN_STACK_finish(BN_STACK *);
static int BN_STACK_push(BN_STACK *, unsigned int);
static unsigned int BN_STACK_pop(BN_STACK *);

/**********/
/* BN_CTX */
/**********/

/* The opaque BN_CTX type */
struct bignum_ctx {
    /* The bignum bundles */
    BN_POOL pool;
    /* The "stack frames", if you will */
    BN_STACK stack;
    /* The number of bignums currently assigned */
    unsigned int used;
    /* Depth of stack overflow */
    int err_stack;
    /* Block "gets" until an "end" (compatibility behaviour) */
    int too_many;
    /* Flags. */
    int flags;
    /* The library context */
    OSSL_LIB_CTX *libctx;
};

#ifndef FIPS_MODULE
/* Debugging functionality */
static void ctxdbg(BIO *channel, const char *text, BN_CTX *ctx)
{
    unsigned int bnidx = 0, fpidx = 0;
    BN_POOL_ITEM *item = ctx->pool.head;
    BN_STACK *stack = &ctx->stack;

    BIO_printf(channel, "%s\n", text);
    BIO_printf(channel, "  (%16p): ", (void*)ctx);
    while (bnidx < ctx->used) {
        BIO_printf(channel, "%03x ",
                   item->vals[bnidx++ % BN_CTX_POOL_SIZE].dmax);
        if (!(bnidx % BN_CTX_POOL_SIZE))
            item = item->next;
    }
    BIO_printf(channel, "\n");
    bnidx = 0;
    BIO_printf(channel, "   %16s : ", "");
    while (fpidx < stack->depth) {
        while (bnidx++ < stack->indexes[fpidx])
            BIO_printf(channel, "    ");
        BIO_printf(channel, "^^^ ");
        bnidx++;
        fpidx++;
    }
    BIO_printf(channel, "\n");
}

# define CTXDBG(str, ctx)           \
    OSSL_TRACE_BEGIN(BN_CTX) {      \
        ctxdbg(trc_out, str, ctx);  \
    } OSSL_TRACE_END(BN_CTX)
#else
/* We do not want tracing in FIPS module */
# define CTXDBG(str, ctx) do {} while(0)
#endif /* FIPS_MODULE */

BN_CTX *BN_CTX_new_ex(OSSL_LIB_CTX *ctx)
{
    BN_CTX *ret;

    if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
        ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
        return NULL;
    }
    /* Initialise the structure */
    BN_POOL_init(&ret->pool);
    BN_STACK_init(&ret->stack);
    ret->libctx = ctx;
    return ret;
}

#ifndef FIPS_MODULE
BN_CTX *BN_CTX_new(void)
{
    return BN_CTX_new_ex(NULL);
}
#endif

BN_CTX *BN_CTX_secure_new_ex(OSSL_LIB_CTX *ctx)
{
    BN_CTX *ret = BN_CTX_new_ex(ctx);

    if (ret != NULL)
        ret->flags = BN_FLG_SECURE;
    return ret;
}

#ifndef FIPS_MODULE
BN_CTX *BN_CTX_secure_new(void)
{
    return BN_CTX_secure_new_ex(NULL);
}
#endif

void BN_CTX_free(BN_CTX *ctx)
{
    if (ctx == NULL)
        return;
#ifndef FIPS_MODULE
    OSSL_TRACE_BEGIN(BN_CTX) {
        BN_POOL_ITEM *pool = ctx->pool.head;
        BIO_printf(trc_out,
                   "BN_CTX_free(): stack-size=%d, pool-bignums=%d\n",
                   ctx->stack.size, ctx->pool.size);
        BIO_printf(trc_out, "  dmaxs: ");
        while (pool) {
            unsigned loop = 0;
            while (loop < BN_CTX_POOL_SIZE)
                BIO_printf(trc_out, "%02x ", pool->vals[loop++].dmax);
            pool = pool->next;
        }
        BIO_printf(trc_out, "\n");
    } OSSL_TRACE_END(BN_CTX);
#endif
    BN_STACK_finish(&ctx->stack);
    BN_POOL_finish(&ctx->pool);
    OPENSSL_free(ctx);
}

void BN_CTX_start(BN_CTX *ctx)
{
    CTXDBG("ENTER BN_CTX_start()", ctx);
    /* If we're already overflowing ... */
    if (ctx->err_stack || ctx->too_many)
        ctx->err_stack++;
    /* (Try to) get a new frame pointer */
    else if (!BN_STACK_push(&ctx->stack, ctx->used)) {
        ERR_raise(ERR_LIB_BN, BN_R_TOO_MANY_TEMPORARY_VARIABLES);
        ctx->err_stack++;
    }
    CTXDBG("LEAVE BN_CTX_start()", ctx);
}

void BN_CTX_end(BN_CTX *ctx)
{
    if (ctx == NULL)
        return;
    CTXDBG("ENTER BN_CTX_end()", ctx);
    if (ctx->err_stack)
        ctx->err_stack--;
    else {
        unsigned int fp = BN_STACK_pop(&ctx->stack);
        /* Does this stack frame have anything to release? */
        if (fp < ctx->used)
            BN_POOL_release(&ctx->pool, ctx->used - fp);
        ctx->used = fp;
        /* Unjam "too_many" in case "get" had failed */
        ctx->too_many = 0;
    }
    CTXDBG("LEAVE BN_CTX_end()", ctx);
}

BIGNUM *BN_CTX_get(BN_CTX *ctx)
{
    BIGNUM *ret;

    CTXDBG("ENTER BN_CTX_get()", ctx);
    if (ctx->err_stack || ctx->too_many)
        return NULL;
    if ((ret = BN_POOL_get(&ctx->pool, ctx->flags)) == NULL) {
        /*
         * Setting too_many prevents repeated "get" attempts from cluttering
         * the error stack.
         */
        ctx->too_many = 1;
        ERR_raise(ERR_LIB_BN, BN_R_TOO_MANY_TEMPORARY_VARIABLES);
        return NULL;
    }
    /* OK, make sure the returned bignum is "zero" */
    BN_zero(ret);
    /* clear BN_FLG_CONSTTIME if leaked from previous frames */
    ret->flags &= (~BN_FLG_CONSTTIME);
    ctx->used++;
    CTXDBG("LEAVE BN_CTX_get()", ctx);
    return ret;
}

OSSL_LIB_CTX *ossl_bn_get_libctx(BN_CTX *ctx)
{
    if (ctx == NULL)
        return NULL;
    return ctx->libctx;
}

/************/
/* BN_STACK */
/************/

static void BN_STACK_init(BN_STACK *st)
{
    st->indexes = NULL;
    st->depth = st->size = 0;
}

static void BN_STACK_finish(BN_STACK *st)
{
    OPENSSL_free(st->indexes);
    st->indexes = NULL;
}


static int BN_STACK_push(BN_STACK *st, unsigned int idx)
{
    if (st->depth == st->size) {
        /* Need to expand */
        unsigned int newsize =
            st->size ? (st->size * 3 / 2) : BN_CTX_START_FRAMES;
        unsigned int *newitems;

        if ((newitems = OPENSSL_malloc(sizeof(*newitems) * newsize)) == NULL) {
            ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
            return 0;
        }
        if (st->depth)
            memcpy(newitems, st->indexes, sizeof(*newitems) * st->depth);
        OPENSSL_free(st->indexes);
        st->indexes = newitems;
        st->size = newsize;
    }
    st->indexes[(st->depth)++] = idx;
    return 1;
}

static unsigned int BN_STACK_pop(BN_STACK *st)
{
    return st->indexes[--(st->depth)];
}

/***********/
/* BN_POOL */
/***********/

static void BN_POOL_init(BN_POOL *p)
{
    p->head = p->current = p->tail = NULL;
    p->used = p->size = 0;
}

static void BN_POOL_finish(BN_POOL *p)
{
    unsigned int loop;
    BIGNUM *bn;

    while (p->head) {
        for (loop = 0, bn = p->head->vals; loop++ < BN_CTX_POOL_SIZE; bn++)
            if (bn->d)
                BN_clear_free(bn);
        p->current = p->head->next;
        OPENSSL_free(p->head);
        p->head = p->current;
    }
}


static BIGNUM *BN_POOL_get(BN_POOL *p, int flag)
{
    BIGNUM *bn;
    unsigned int loop;

    /* Full; allocate a new pool item and link it in. */
    if (p->used == p->size) {
        BN_POOL_ITEM *item;

        if ((item = OPENSSL_malloc(sizeof(*item))) == NULL) {
            ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
            return NULL;
        }
        for (loop = 0, bn = item->vals; loop++ < BN_CTX_POOL_SIZE; bn++) {
            bn_init(bn);
            if ((flag & BN_FLG_SECURE) != 0)
                BN_set_flags(bn, BN_FLG_SECURE);
        }
        item->prev = p->tail;
        item->next = NULL;

        if (p->head == NULL)
            p->head = p->current = p->tail = item;
        else {
            p->tail->next = item;
            p->tail = item;
            p->current = item;
        }
        p->size += BN_CTX_POOL_SIZE;
        p->used++;
        /* Return the first bignum from the new pool */
        return item->vals;
    }

    if (!p->used)
        p->current = p->head;
    else if ((p->used % BN_CTX_POOL_SIZE) == 0)
        p->current = p->current->next;
    return p->current->vals + ((p->used++) % BN_CTX_POOL_SIZE);
}

static void BN_POOL_release(BN_POOL *p, unsigned int num)
{
    unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;

    p->used -= num;
    while (num--) {
        bn_check_top(p->current->vals + offset);
        if (offset == 0) {
            offset = BN_CTX_POOL_SIZE - 1;
            p->current = p->current->prev;
        } else
            offset--;
    }
}

Coverage Report

Created: 2023-06-08 06:40

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10		#include <openssl/trace.h>
11		#include "internal/cryptlib.h"
12		#include "bn_local.h"
13
14		/* How many bignums are in each "pool item"; */
15	4.84M	#define BN_CTX_POOL_SIZE 16
16		/* The stack frame info is resizing, set a first-time expansion size; */
17	2.94k	#define BN_CTX_START_FRAMES 32
18
19		/***********/
20		/* BN_POOL */
21		/***********/
22
23		/* A bundle of bignums that can be linked with other bundles */
24		typedef struct bignum_pool_item {
25		/* The bignum values */
26		BIGNUM vals[BN_CTX_POOL_SIZE];
27		/* Linked-list admin */
28		struct bignum_pool_item prev, next;
29		} BN_POOL_ITEM;
30		/* A linked-list of bignums grouped in bundles */
31		typedef struct bignum_pool {
32		/* Linked-list admin */
33		BN_POOL_ITEM head, current, *tail;
34		/* Stack depth and allocation size */
35		unsigned used, size;
36		} BN_POOL;
37		static void BN_POOL_init(BN_POOL *);
38		static void BN_POOL_finish(BN_POOL *);
39		static BIGNUM BN_POOL_get(BN_POOL , int);
40		static void BN_POOL_release(BN_POOL *, unsigned int);
41
42		/************/
43		/* BN_STACK */
44		/************/
45
46		/* A wrapper to manage the "stack frames" */
47		typedef struct bignum_ctx_stack {
48		/* Array of indexes into the bignum stack */
49		unsigned int *indexes;
50		/* Number of stack frames, and the size of the allocated array */
51		unsigned int depth, size;
52		} BN_STACK;
53		static void BN_STACK_init(BN_STACK *);
54		static void BN_STACK_finish(BN_STACK *);
55		static int BN_STACK_push(BN_STACK *, unsigned int);
56		static unsigned int BN_STACK_pop(BN_STACK *);
57
58		/**********/
59		/* BN_CTX */
60		/**********/
61
62		/* The opaque BN_CTX type */
63		struct bignum_ctx {
64		/* The bignum bundles */
65		BN_POOL pool;
66		/* The "stack frames", if you will */
67		BN_STACK stack;
68		/* The number of bignums currently assigned */
69		unsigned int used;
70		/* Depth of stack overflow */
71		int err_stack;
72		/* Block "gets" until an "end" (compatibility behaviour) */
73		int too_many;
74		/* Flags. */
75		int flags;
76		/* The library context */
77		OSSL_LIB_CTX *libctx;
78		};
79
80		#ifndef FIPS_MODULE
81		/* Debugging functionality */
82		static void ctxdbg(BIO channel, const char text, BN_CTX *ctx)
83	0	{
84	0	unsigned int bnidx = 0, fpidx = 0;
85	0	BN_POOL_ITEM *item = ctx->pool.head;
86	0	BN_STACK *stack = &ctx->stack;
87	0
88	0	BIO_printf(channel, "%s\n", text);
89	0	BIO_printf(channel, " (%16p): ", (void*)ctx);
90	0	while (bnidx < ctx->used) {
91	0	BIO_printf(channel, "%03x ",
92	0	item->vals[bnidx++ % BN_CTX_POOL_SIZE].dmax);
93	0	if (!(bnidx % BN_CTX_POOL_SIZE))
94	0	item = item->next;
95	0	}
96	0	BIO_printf(channel, "\n");
97	0	bnidx = 0;
98	0	BIO_printf(channel, " %16s : ", "");
99	0	while (fpidx < stack->depth) {
100	0	while (bnidx++ < stack->indexes[fpidx])
101	0	BIO_printf(channel, " ");
102	0	BIO_printf(channel, "^^^ ");
103	0	bnidx++;
104	0	fpidx++;
105	0	}
106	0	BIO_printf(channel, "\n");
107	0	}
108
109		# define CTXDBG(str, ctx) \
110	8.55M	OSSL_TRACE_BEGIN(BN_CTX) { \
111	0	ctxdbg(trc_out, str, ctx); \
112	8.55M	} OSSL_TRACE_END(BN_CTX)
113		#else
114		/* We do not want tracing in FIPS module */
115		# define CTXDBG(str, ctx) do {} while(0)
116		#endif /* FIPS_MODULE */
117
118		BN_CTX BN_CTX_new_ex(OSSL_LIB_CTX ctx)
119	3.17k	{
120	3.17k	BN_CTX *ret;
121
122	3.17k	if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
123	0	ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
124	0	return NULL;
125	0	}
126		/* Initialise the structure */
127	3.17k	BN_POOL_init(&ret->pool);
128	3.17k	BN_STACK_init(&ret->stack);
129	3.17k	ret->libctx = ctx;
130	3.17k	return ret;
131	3.17k	}
132
133		#ifndef FIPS_MODULE
134		BN_CTX *BN_CTX_new(void)
135	3.17k	{
136	3.17k	return BN_CTX_new_ex(NULL);
137	3.17k	}
138		#endif
139
140		BN_CTX BN_CTX_secure_new_ex(OSSL_LIB_CTX ctx)
141	0	{
142	0	BN_CTX *ret = BN_CTX_new_ex(ctx);
143
144	0	if (ret != NULL)
145	0	ret->flags = BN_FLG_SECURE;
146	0	return ret;
147	0	}
148
149		#ifndef FIPS_MODULE
150		BN_CTX *BN_CTX_secure_new(void)
151	0	{
152	0	return BN_CTX_secure_new_ex(NULL);
153	0	}
154		#endif
155
156		void BN_CTX_free(BN_CTX *ctx)
157	4.46k	{
158	4.46k	if (ctx == NULL)
159	1.29k	return;
160	3.17k	#ifndef FIPS_MODULE
161	3.17k	OSSL_TRACE_BEGIN(BN_CTX) {
162	0	BN_POOL_ITEM *pool = ctx->pool.head;
163	0	BIO_printf(trc_out,
164	0	"BN_CTX_free(): stack-size=%d, pool-bignums=%d\n",
165	0	ctx->stack.size, ctx->pool.size);
166	0	BIO_printf(trc_out, " dmaxs: ");
167	0	while (pool) {
168	0	unsigned loop = 0;
169	0	while (loop < BN_CTX_POOL_SIZE)
170	0	BIO_printf(trc_out, "%02x ", pool->vals[loop++].dmax);
171	0	pool = pool->next;
172	0	}
173	0	BIO_printf(trc_out, "\n");
174	3.17k	} OSSL_TRACE_END(BN_CTX);
175	3.17k	#endif
176	3.17k	BN_STACK_finish(&ctx->stack);
177	3.17k	BN_POOL_finish(&ctx->pool);
178	3.17k	OPENSSL_free(ctx);
179	3.17k	}
180
181		void BN_CTX_start(BN_CTX *ctx)
182	1.20M	{
183	1.20M	CTXDBG("ENTER BN_CTX_start()", ctx);
184		/* If we're already overflowing ... */
185	1.20M	if (ctx->err_stack \|\| ctx->too_many)
186	0	ctx->err_stack++;
187		/* (Try to) get a new frame pointer */
188	1.20M	else if (!BN_STACK_push(&ctx->stack, ctx->used)) {
189	0	ERR_raise(ERR_LIB_BN, BN_R_TOO_MANY_TEMPORARY_VARIABLES);
190	0	ctx->err_stack++;
191	0	}
192	1.20M	CTXDBG("LEAVE BN_CTX_start()", ctx);
193	1.20M	}
194
195		void BN_CTX_end(BN_CTX *ctx)
196	1.20M	{
197	1.20M	if (ctx == NULL)
198	0	return;
199	1.20M	CTXDBG("ENTER BN_CTX_end()", ctx);
200	1.20M	if (ctx->err_stack)
201	0	ctx->err_stack--;
202	1.20M	else {
203	1.20M	unsigned int fp = BN_STACK_pop(&ctx->stack);
204		/* Does this stack frame have anything to release? */
205	1.20M	if (fp < ctx->used)
206	1.03M	BN_POOL_release(&ctx->pool, ctx->used - fp);
207	1.20M	ctx->used = fp;
208		/* Unjam "too_many" in case "get" had failed */
209	1.20M	ctx->too_many = 0;
210	1.20M	}
211	1.20M	CTXDBG("LEAVE BN_CTX_end()", ctx);
212	1.20M	}
213
214		BIGNUM BN_CTX_get(BN_CTX ctx)
215	1.85M	{
216	1.85M	BIGNUM *ret;
217
218	1.85M	CTXDBG("ENTER BN_CTX_get()", ctx);
219	1.85M	if (ctx->err_stack \|\| ctx->too_many)
220	0	return NULL;
221	1.85M	if ((ret = BN_POOL_get(&ctx->pool, ctx->flags)) == NULL) {
222		/*
223		* Setting too_many prevents repeated "get" attempts from cluttering
224		* the error stack.
225		*/
226	0	ctx->too_many = 1;
227	0	ERR_raise(ERR_LIB_BN, BN_R_TOO_MANY_TEMPORARY_VARIABLES);
228	0	return NULL;
229	0	}
230		/* OK, make sure the returned bignum is "zero" */
231	1.85M	BN_zero(ret);
232		/* clear BN_FLG_CONSTTIME if leaked from previous frames */
233	1.85M	ret->flags &= (~BN_FLG_CONSTTIME);
234	1.85M	ctx->used++;
235	1.85M	CTXDBG("LEAVE BN_CTX_get()", ctx);
236	1.85M	return ret;
237	1.85M	}
238
239		OSSL_LIB_CTX ossl_bn_get_libctx(BN_CTX ctx)
240	0	{
241	0	if (ctx == NULL)
242	0	return NULL;
243	0	return ctx->libctx;
244	0	}
245
246		/************/
247		/* BN_STACK */
248		/************/
249
250		static void BN_STACK_init(BN_STACK *st)
251	3.17k	{
252	3.17k	st->indexes = NULL;
253	3.17k	st->depth = st->size = 0;
254	3.17k	}
255
256		static void BN_STACK_finish(BN_STACK *st)
257	3.17k	{
258	3.17k	OPENSSL_free(st->indexes);
259	3.17k	st->indexes = NULL;
260	3.17k	}
261
262
263		static int BN_STACK_push(BN_STACK *st, unsigned int idx)
264	1.20M	{
265	1.20M	if (st->depth == st->size) {
266		/* Need to expand */
267	2.94k	unsigned int newsize =
268	2.94k	st->size ? (st->size * 3 / 2) : BN_CTX_START_FRAMES;
269	2.94k	unsigned int *newitems;
270
271	2.94k	if ((newitems = OPENSSL_malloc(sizeof(newitems) newsize)) == NULL) {
272	0	ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
273	0	return 0;
274	0	}
275	2.94k	if (st->depth)
276	0	memcpy(newitems, st->indexes, sizeof(newitems) st->depth);
277	2.94k	OPENSSL_free(st->indexes);
278	2.94k	st->indexes = newitems;
279	2.94k	st->size = newsize;
280	2.94k	}
281	1.20M	st->indexes[(st->depth)++] = idx;
282	1.20M	return 1;
283	1.20M	}
284
285		static unsigned int BN_STACK_pop(BN_STACK *st)
286	1.20M	{
287	1.20M	return st->indexes[--(st->depth)];
288	1.20M	}
289
290		/***********/
291		/* BN_POOL */
292		/***********/
293
294		static void BN_POOL_init(BN_POOL *p)
295	3.17k	{
296	3.17k	p->head = p->current = p->tail = NULL;
297	3.17k	p->used = p->size = 0;
298	3.17k	}
299
300		static void BN_POOL_finish(BN_POOL *p)
301	3.17k	{
302	3.17k	unsigned int loop;
303	3.17k	BIGNUM *bn;
304
305	6.24k	while (p->head) {
306	52.2k	for (loop = 0, bn = p->head->vals; loop++ < BN_CTX_POOL_SIZE; bn++)
307	49.2k	if (bn->d)
308	33.1k	BN_clear_free(bn);
309	3.07k	p->current = p->head->next;
310	3.07k	OPENSSL_free(p->head);
311	3.07k	p->head = p->current;
312	3.07k	}
313	3.17k	}
314
315
316		static BIGNUM BN_POOL_get(BN_POOL p, int flag)
317	1.85M	{
318	1.85M	BIGNUM *bn;
319	1.85M	unsigned int loop;
320
321		/* Full; allocate a new pool item and link it in. */
322	1.85M	if (p->used == p->size) {
323	3.07k	BN_POOL_ITEM *item;
324
325	3.07k	if ((item = OPENSSL_malloc(sizeof(*item))) == NULL) {
326	0	ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
327	0	return NULL;
328	0	}
329	52.2k	for (loop = 0, bn = item->vals; loop++ < BN_CTX_POOL_SIZE; bn++) {
330	49.2k	bn_init(bn);
331	49.2k	if ((flag & BN_FLG_SECURE) != 0)
332	0	BN_set_flags(bn, BN_FLG_SECURE);
333	49.2k	}
334	3.07k	item->prev = p->tail;
335	3.07k	item->next = NULL;
336
337	3.07k	if (p->head == NULL)
338	2.94k	p->head = p->current = p->tail = item;
339	135	else {
340	135	p->tail->next = item;
341	135	p->tail = item;
342	135	p->current = item;
343	135	}
344	3.07k	p->size += BN_CTX_POOL_SIZE;
345	3.07k	p->used++;
346		/* Return the first bignum from the new pool */
347	3.07k	return item->vals;
348	3.07k	}
349
350	1.85M	if (!p->used)
351	2.93k	p->current = p->head;
352	1.84M	else if ((p->used % BN_CTX_POOL_SIZE) == 0)
353	878	p->current = p->current->next;
354	1.85M	return p->current->vals + ((p->used++) % BN_CTX_POOL_SIZE);
355	1.85M	}
356
357		static void BN_POOL_release(BN_POOL *p, unsigned int num)
358	1.03M	{
359	1.03M	unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;
360
361	1.03M	p->used -= num;
362	2.88M	while (num--) {
363	1.85M	bn_check_top(p->current->vals + offset);
364	1.85M	if (offset == 0) {
365	6.89k	offset = BN_CTX_POOL_SIZE - 1;
366	6.89k	p->current = p->current->prev;
367	6.89k	} else
368	1.84M	offset--;
369	1.85M	}
370	1.03M	}