Annotation of embedaddon/ntp/lib/isc/win32/entropy.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (C) 2004, 2007, 2009 Internet Systems Consortium, Inc. ("ISC")
3: * Copyright (C) 2000-2002 Internet Software Consortium.
4: *
5: * Permission to use, copy, modify, and/or distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10: * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11: * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12: * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13: * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14: * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15: * PERFORMANCE OF THIS SOFTWARE.
16: */
17:
18: /* $Id: entropy.c,v 1.8.332.2 2009/01/18 23:47:41 tbox Exp $ */
19:
20: /*
21: * This is the system dependent part of the ISC entropy API.
22: */
23:
24: #include <config.h>
25:
26: #include <windows.h>
27: #include <wincrypt.h>
28:
29: #include <process.h>
30: #include <io.h>
31: #include <share.h>
32:
33: /*
34: * There is only one variable in the entropy data structures that is not
35: * system independent, but pulling the structure that uses it into this file
36: * ultimately means pulling several other independent structures here also to
37: * resolve their interdependencies. Thus only the problem variable's type
38: * is defined here.
39: */
40: #define FILESOURCE_HANDLE_TYPE HCRYPTPROV
41:
42: typedef struct {
43: int dummy;
44: } isc_entropyusocketsource_t;
45:
46: #include "../entropy.c"
47:
48: static unsigned int
49: get_from_filesource(isc_entropysource_t *source, isc_uint32_t desired) {
50: isc_entropy_t *ent = source->ent;
51: unsigned char buf[128];
52: HCRYPTPROV hcryptprov = source->sources.file.handle;
53: ssize_t ndesired;
54: unsigned int added;
55:
56: if (source->bad)
57: return (0);
58:
59: desired = desired / 8 + (((desired & 0x07) > 0) ? 1 : 0);
60:
61: added = 0;
62: while (desired > 0) {
63: ndesired = ISC_MIN(desired, sizeof(buf));
64: if (!CryptGenRandom(hcryptprov, ndesired, buf)) {
65: CryptReleaseContext(hcryptprov, 0);
66: source->bad = ISC_TRUE;
67: goto out;
68: }
69:
70: entropypool_adddata(ent, buf, ndesired, ndesired * 8);
71: added += ndesired * 8;
72: desired -= ndesired;
73: }
74:
75: out:
76: return (added);
77: }
78:
79: /*
80: * Poll each source, trying to get data from it to stuff into the entropy
81: * pool.
82: */
83: static void
84: fillpool(isc_entropy_t *ent, unsigned int desired, isc_boolean_t blocking) {
85: unsigned int added;
86: unsigned int remaining;
87: unsigned int needed;
88: unsigned int nsource;
89: isc_entropysource_t *source;
90: isc_entropysource_t *firstsource;
91:
92: REQUIRE(VALID_ENTROPY(ent));
93:
94: needed = desired;
95:
96: /*
97: * This logic is a little strange, so an explanation is in order.
98: *
99: * If needed is 0, it means we are being asked to "fill to whatever
100: * we think is best." This means that if we have at least a
101: * partially full pool (say, > 1/4th of the pool) we probably don't
102: * need to add anything.
103: *
104: * Also, we will check to see if the "pseudo" count is too high.
105: * If it is, try to mix in better data. Too high is currently
106: * defined as 1/4th of the pool.
107: *
108: * Next, if we are asked to add a specific bit of entropy, make
109: * certain that we will do so. Clamp how much we try to add to
110: * (DIGEST_SIZE * 8 < needed < POOLBITS - entropy).
111: *
112: * Note that if we are in a blocking mode, we will only try to
113: * get as much data as we need, not as much as we might want
114: * to build up.
115: */
116: if (needed == 0) {
117: REQUIRE(!blocking);
118:
119: if ((ent->pool.entropy >= RND_POOLBITS / 4)
120: && (ent->pool.pseudo <= RND_POOLBITS / 4))
121: return;
122:
123: needed = THRESHOLD_BITS * 4;
124: } else {
125: needed = ISC_MAX(needed, THRESHOLD_BITS);
126: needed = ISC_MIN(needed, RND_POOLBITS);
127: }
128:
129: /*
130: * In any case, clamp how much we need to how much we can add.
131: */
132: needed = ISC_MIN(needed, RND_POOLBITS - ent->pool.entropy);
133:
134: /*
135: * But wait! If we're not yet initialized, we need at least
136: * THRESHOLD_BITS
137: * of randomness.
138: */
139: if (ent->initialized < THRESHOLD_BITS)
140: needed = ISC_MAX(needed, THRESHOLD_BITS - ent->initialized);
141:
142: /*
143: * Poll each file source to see if we can read anything useful from
144: * it. XXXMLG When where are multiple sources, we should keep a
145: * record of which one we last used so we can start from it (or the
146: * next one) to avoid letting some sources build up entropy while
147: * others are always drained.
148: */
149:
150: added = 0;
151: remaining = needed;
152: if (ent->nextsource == NULL) {
153: ent->nextsource = ISC_LIST_HEAD(ent->sources);
154: if (ent->nextsource == NULL)
155: return;
156: }
157: source = ent->nextsource;
158: /*
159: * Remember the first source so we can break if we have looped back to
160: * the beginning and still have nothing
161: */
162: firstsource = source;
163: again_file:
164: for (nsource = 0; nsource < ent->nsources; nsource++) {
165: unsigned int got;
166:
167: if (remaining == 0)
168: break;
169:
170: got = 0;
171:
172: if (source->type == ENTROPY_SOURCETYPE_FILE)
173: got = get_from_filesource(source, remaining);
174:
175: added += got;
176:
177: remaining -= ISC_MIN(remaining, got);
178:
179: source = ISC_LIST_NEXT(source, link);
180: if (source == NULL)
181: source = ISC_LIST_HEAD(ent->sources);
182: }
183: ent->nextsource = source;
184:
185: /*
186: * Go again only if there's been progress and we've not
187: * gone back to the beginning
188: */
189: if (!(ent->nextsource == firstsource && added == 0)) {
190: if (blocking && remaining != 0) {
191: goto again_file;
192: }
193: }
194:
195: /*
196: * Here, if there are bits remaining to be had and we can block,
197: * check to see if we have a callback source. If so, call them.
198: */
199: source = ISC_LIST_HEAD(ent->sources);
200: while ((remaining != 0) && (source != NULL)) {
201: unsigned int got;
202:
203: got = 0;
204:
205: if (source->type == ENTROPY_SOURCETYPE_CALLBACK)
206: got = get_from_callback(source, remaining, blocking);
207:
208: added += got;
209: remaining -= ISC_MIN(remaining, got);
210:
211: if (added >= needed)
212: break;
213:
214: source = ISC_LIST_NEXT(source, link);
215: }
216:
217: /*
218: * Mark as initialized if we've added enough data.
219: */
220: if (ent->initialized < THRESHOLD_BITS)
221: ent->initialized += added;
222: }
223:
224:
225:
226: /*
227: * Requires "ent" be locked.
228: */
229: static void
230: destroyfilesource(isc_entropyfilesource_t *source) {
231: CryptReleaseContext(source->handle, 0);
232: }
233:
234: static void
235: destroyusocketsource(isc_entropyusocketsource_t *source) {
236: UNUSED(source);
237: }
238:
239:
240: isc_result_t
241: isc_entropy_createfilesource(isc_entropy_t *ent, const char *fname) {
242: isc_result_t ret;
243: isc_entropysource_t *source;
244: HCRYPTPROV hcryptprov;
245: DWORD errval;
246: BOOL err;
247:
248: REQUIRE(VALID_ENTROPY(ent));
249: REQUIRE(fname != NULL);
250:
251: LOCK(&ent->lock);
252:
253: source = NULL;
254:
255: /*
256: * The first time we just try to acquire the context
257: */
258: err = CryptAcquireContext(&hcryptprov, NULL, NULL, PROV_RSA_FULL,
259: CRYPT_VERIFYCONTEXT);
260: if (!err){
261: errval = GetLastError();
262: ret = ISC_R_IOERROR;
263: goto errout;
264: }
265:
266: source = isc_mem_get(ent->mctx, sizeof(isc_entropysource_t));
267: if (source == NULL) {
268: ret = ISC_R_NOMEMORY;
269: goto closecontext;
270: }
271:
272: /*
273: * From here down, no failures can occur.
274: */
275: source->magic = SOURCE_MAGIC;
276: source->type = ENTROPY_SOURCETYPE_FILE;
277: source->ent = ent;
278: source->total = 0;
279: source->bad = ISC_FALSE;
280: memset(source->name, 0, sizeof(source->name));
281: ISC_LINK_INIT(source, link);
282: source->sources.file.handle = hcryptprov;
283:
284: /*
285: * Hook it into the entropy system.
286: */
287: ISC_LIST_APPEND(ent->sources, source, link);
288: ent->nsources++;
289:
290: UNLOCK(&ent->lock);
291: return (ISC_R_SUCCESS);
292:
293: closecontext:
294: CryptReleaseContext(hcryptprov, 0);
295:
296: errout:
297: if (source != NULL)
298: isc_mem_put(ent->mctx, source, sizeof(isc_entropysource_t));
299:
300: UNLOCK(&ent->lock);
301:
302: return (ret);
303: }
304:
305:
306:
307:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to entropy.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc / win32