Annotation of embedaddon/axTLS/crypto/crypto_misc.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (c) 2007, Cameron Rich
3: *
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions are met:
8: *
9: * * Redistributions of source code must retain the above copyright notice,
10: * this list of conditions and the following disclaimer.
11: * * Redistributions in binary form must reproduce the above copyright notice,
12: * this list of conditions and the following disclaimer in the documentation
13: * and/or other materials provided with the distribution.
14: * * Neither the name of the axTLS project nor the names of its contributors
15: * may be used to endorse or promote products derived from this software
16: * without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
22: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25: * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29: */
30:
31: /**
32: * Some misc. routines to help things out
33: */
34:
35: #include <stdlib.h>
36: #include <string.h>
37: #include <stdarg.h>
38: #include <stdio.h>
39: #include "os_port.h"
40: #include "crypto_misc.h"
41: #ifdef CONFIG_WIN32_USE_CRYPTO_LIB
42: #include "wincrypt.h"
43: #endif
44:
45: #ifndef WIN32
46: static int rng_fd = -1;
47: #elif defined(CONFIG_WIN32_USE_CRYPTO_LIB)
48: static HCRYPTPROV gCryptProv;
49: #endif
50:
51: #if (!defined(CONFIG_USE_DEV_URANDOM) && !defined(CONFIG_WIN32_USE_CRYPTO_LIB))
52: /* change to processor registers as appropriate */
53: #define ENTROPY_POOL_SIZE 32
54: #define ENTROPY_COUNTER1 ((((uint64_t)tv.tv_sec)<<32) | tv.tv_usec)
55: #define ENTROPY_COUNTER2 rand()
56: static uint8_t entropy_pool[ENTROPY_POOL_SIZE];
57: #endif
58:
59: const char * const unsupported_str = "Error: Feature not supported\n";
60:
61: #ifndef CONFIG_SSL_SKELETON_MODE
62: /**
63: * Retrieve a file and put it into memory
64: * @return The size of the file, or -1 on failure.
65: */
66: int get_file(const char *filename, uint8_t **buf)
67: {
68: int total_bytes = 0;
69: int bytes_read = 0;
70: int filesize;
71: FILE *stream = fopen(filename, "rb");
72:
73: if (stream == NULL)
74: {
75: #ifdef CONFIG_SSL_FULL_MODE
76: printf("file '%s' does not exist\n", filename); TTY_FLUSH();
77: #endif
78: return -1;
79: }
80:
81: /* Win CE doesn't support stat() */
82: fseek(stream, 0, SEEK_END);
83: filesize = ftell(stream);
84: *buf = (uint8_t *)malloc(filesize);
85: fseek(stream, 0, SEEK_SET);
86:
87: do
88: {
89: bytes_read = fread(*buf+total_bytes, 1, filesize-total_bytes, stream);
90: total_bytes += bytes_read;
91: } while (total_bytes < filesize && bytes_read > 0);
92:
93: fclose(stream);
94: return filesize;
95: }
96: #endif
97:
98: /**
99: * Initialise the Random Number Generator engine.
100: * - On Win32 use the platform SDK's crypto engine.
101: * - On Linux use /dev/urandom
102: * - If none of these work then use a custom RNG.
103: */
104: EXP_FUNC void STDCALL RNG_initialize()
105: {
106: #if !defined(WIN32) && defined(CONFIG_USE_DEV_URANDOM)
107: rng_fd = ax_open("/dev/urandom", O_RDONLY);
108: #elif defined(WIN32) && defined(CONFIG_WIN32_USE_CRYPTO_LIB)
109: if (!CryptAcquireContext(&gCryptProv,
110: NULL, NULL, PROV_RSA_FULL, 0))
111: {
112: if (GetLastError() == NTE_BAD_KEYSET &&
113: !CryptAcquireContext(&gCryptProv,
114: NULL,
115: NULL,
116: PROV_RSA_FULL,
117: CRYPT_NEWKEYSET))
118: {
119: printf("CryptoLib: %x\n", unsupported_str, GetLastError());
120: exit(1);
121: }
122: }
123: #else
124: /* start of with a stack to copy across */
125: int i;
126: memcpy(entropy_pool, &i, ENTROPY_POOL_SIZE);
127: srand((unsigned int)&i);
128: #endif
129: }
130:
131: /**
132: * If no /dev/urandom, then initialise the RNG with something interesting.
133: */
134: EXP_FUNC void STDCALL RNG_custom_init(const uint8_t *seed_buf, int size)
135: {
136: #if defined(WIN32) || defined(CONFIG_WIN32_USE_CRYPTO_LIB)
137: int i;
138:
139: for (i = 0; i < ENTROPY_POOL_SIZE && i < size; i++)
140: entropy_pool[i] ^= seed_buf[i];
141: #endif
142: }
143:
144: /**
145: * Terminate the RNG engine.
146: */
147: EXP_FUNC void STDCALL RNG_terminate(void)
148: {
149: #ifndef WIN32
150: close(rng_fd);
151: #elif defined(CONFIG_WIN32_USE_CRYPTO_LIB)
152: CryptReleaseContext(gCryptProv, 0);
153: #endif
154: }
155:
156: /**
157: * Set a series of bytes with a random number. Individual bytes can be 0
158: */
159: EXP_FUNC void STDCALL get_random(int num_rand_bytes, uint8_t *rand_data)
160: {
161: #if !defined(WIN32) && defined(CONFIG_USE_DEV_URANDOM)
162: /* use the Linux default */
163: read(rng_fd, rand_data, num_rand_bytes); /* read from /dev/urandom */
164: #elif defined(WIN32) && defined(CONFIG_WIN32_USE_CRYPTO_LIB)
165: /* use Microsoft Crypto Libraries */
166: CryptGenRandom(gCryptProv, num_rand_bytes, rand_data);
167: #else /* nothing else to use, so use a custom RNG */
168: /* The method we use when we've got nothing better. Use RC4, time
169: and a couple of random seeds to generate a random sequence */
170: RC4_CTX rng_ctx;
171: struct timeval tv;
172: MD5_CTX rng_digest_ctx;
173: uint8_t digest[MD5_SIZE];
174: uint64_t *ep;
175: int i;
176:
177: /* A proper implementation would use counters etc for entropy */
178: gettimeofday(&tv, NULL);
179: ep = (uint64_t *)entropy_pool;
180: ep[0] ^= ENTROPY_COUNTER1;
181: ep[1] ^= ENTROPY_COUNTER2;
182:
183: /* use a digested version of the entropy pool as a key */
184: MD5_Init(&rng_digest_ctx);
185: MD5_Update(&rng_digest_ctx, entropy_pool, ENTROPY_POOL_SIZE);
186: MD5_Final(digest, &rng_digest_ctx);
187:
188: /* come up with the random sequence */
189: RC4_setup(&rng_ctx, digest, MD5_SIZE); /* use as a key */
190: memcpy(rand_data, entropy_pool, num_rand_bytes < ENTROPY_POOL_SIZE ?
191: num_rand_bytes : ENTROPY_POOL_SIZE);
192: RC4_crypt(&rng_ctx, rand_data, rand_data, num_rand_bytes);
193:
194: /* move things along */
195: for (i = ENTROPY_POOL_SIZE-1; i >= MD5_SIZE ; i--)
196: entropy_pool[i] = entropy_pool[i-MD5_SIZE];
197:
198: /* insert the digest at the start of the entropy pool */
199: memcpy(entropy_pool, digest, MD5_SIZE);
200: #endif
201: }
202:
203: /**
204: * Set a series of bytes with a random number. Individual bytes are not zero.
205: */
206: void get_random_NZ(int num_rand_bytes, uint8_t *rand_data)
207: {
208: int i;
209: get_random(num_rand_bytes, rand_data);
210:
211: for (i = 0; i < num_rand_bytes; i++)
212: {
213: while (rand_data[i] == 0) /* can't be 0 */
214: rand_data[i] = (uint8_t)(rand());
215: }
216: }
217:
218: /**
219: * Some useful diagnostic routines
220: */
221: #if defined(CONFIG_SSL_FULL_MODE) || defined(CONFIG_DEBUG)
222: int hex_finish;
223: int hex_index;
224:
225: static void print_hex_init(int finish)
226: {
227: hex_finish = finish;
228: hex_index = 0;
229: }
230:
231: static void print_hex(uint8_t hex)
232: {
233: static int column;
234:
235: if (hex_index == 0)
236: {
237: column = 0;
238: }
239:
240: printf("%02x ", hex);
241: if (++column == 8)
242: {
243: printf(": ");
244: }
245: else if (column >= 16)
246: {
247: printf("\n");
248: column = 0;
249: }
250:
251: if (++hex_index >= hex_finish && column > 0)
252: {
253: printf("\n");
254: }
255: }
256:
257: /**
258: * Spit out a blob of data for diagnostics. The data is is a nice column format
259: * for easy reading.
260: *
261: * @param format [in] The string (with possible embedded format characters)
262: * @param size [in] The number of numbers to print
263: * @param data [in] The start of data to use
264: * @param ... [in] Any additional arguments
265: */
266: EXP_FUNC void STDCALL print_blob(const char *format,
267: const uint8_t *data, int size, ...)
268: {
269: int i;
270: char tmp[80];
271: va_list(ap);
272:
273: va_start(ap, size);
274: sprintf(tmp, "%s\n", format);
275: vprintf(tmp, ap);
276: print_hex_init(size);
277: for (i = 0; i < size; i++)
278: {
279: print_hex(data[i]);
280: }
281:
282: va_end(ap);
283: TTY_FLUSH();
284: }
285: #elif defined(WIN32)
286: /* VC6.0 doesn't handle variadic macros */
287: EXP_FUNC void STDCALL print_blob(const char *format, const unsigned char *data,
288: int size, ...) {}
289: #endif
290:
291: #if defined(CONFIG_SSL_HAS_PEM) || defined(CONFIG_HTTP_HAS_AUTHORIZATION)
292: /* base64 to binary lookup table */
293: static const uint8_t map[128] =
294: {
295: 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
296: 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
297: 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
298: 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
299: 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255,
300: 255, 254, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6,
301: 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
302: 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
303: 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
304: 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
305: 49, 50, 51, 255, 255, 255, 255, 255
306: };
307:
308: EXP_FUNC int STDCALL base64_decode(const char *in, int len,
309: uint8_t *out, int *outlen)
310: {
311: int g, t, x, y, z;
312: uint8_t c;
313: int ret = -1;
314:
315: g = 3;
316: for (x = y = z = t = 0; x < len; x++)
317: {
318: if ((c = map[in[x]&0x7F]) == 0xff)
319: continue;
320:
321: if (c == 254) /* this is the end... */
322: {
323: c = 0;
324:
325: if (--g < 0)
326: goto error;
327: }
328: else if (g != 3) /* only allow = at end */
329: goto error;
330:
331: t = (t<<6) | c;
332:
333: if (++y == 4)
334: {
335: out[z++] = (uint8_t)((t>>16)&255);
336:
337: if (g > 1)
338: out[z++] = (uint8_t)((t>>8)&255);
339:
340: if (g > 2)
341: out[z++] = (uint8_t)(t&255);
342:
343: y = t = 0;
344: }
345:
346: /* check that we don't go past the output buffer */
347: if (z > *outlen)
348: goto error;
349: }
350:
351: if (y != 0)
352: goto error;
353:
354: *outlen = z;
355: ret = 0;
356:
357: error:
358: #ifdef CONFIG_SSL_FULL_MODE
359: if (ret < 0)
360: printf("Error: Invalid base64\n"); TTY_FLUSH();
361: #endif
362: TTY_FLUSH();
363: return ret;
364:
365: }
366: #endif
367:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to crypto_misc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / axTLS / crypto