Fix bug in randpool_add and randpool_strir.
[bertos.git] / algos / randpool.c
1 /**
2  * \file
3  * <!--
4  * Copyright 2007 Develer S.r.l. (http://www.develer.com/)
5  * This file is part of DevLib - See README.devlib for information.
6  * -->
7  *
8  * \brief API function for to manage entropy pool.
9  *
10  * \version $Id$
11  * \author Daniele Basile <asterix@develer.com>
12  */
13
14 /*#*
15  *#* $Log$
16  *#* Revision 1.17  2007/02/15 13:40:42  asterix
17  *#* Fix bug in randpool_add and randpool_strir.
18  *#*
19  *#* Revision 1.16  2007/02/13 15:11:37  asterix
20  *#* Typo.
21  *#*
22  *#* Revision 1.14  2007/02/13 09:57:12  asterix
23  *#* Add directive #if in struct EntropyPool, and remove #else in randpool_add.
24  *#*
25  *#* Revision 1.13  2007/02/12 18:25:34  asterix
26  *#* Fix bug in randpool_getN.
27  *#*
28  *#* Revision 1.12  2007/02/12 09:47:39  asterix
29  *#* Remove randpool_save. Add randpool_pool.
30  *#*
31  *#* Revision 1.10  2007/02/12 09:03:32  asterix
32  *#* Add CONFIG_RANDPOOL_TIMER macro to swich on or off timer support
33  *#*
34  *#* Revision 1.9  2007/02/09 17:58:09  asterix
35  *#* Add macro CONFIG_RANDPOOL_TIMER.
36  *#*
37  *#* Revision 1.6  2007/02/09 09:24:38  asterix
38  *#* Typos. Add data_len in randpool_add and n_byte in randpool_push pototypes.
39  *#*
40  *#* Revision 1.3  2007/02/08 14:25:29  asterix
41  *#* Write static funcion push_byte.
42  *#*
43  *#*/
44
45 #include "randpool.h"
46 #include "md2.h"
47
48 #include <stdio.h>           //sprintf();
49 #include <string.h>          //memset(), memcpy();
50
51 #include <cfg/compiler.h>
52 #include <cfg/debug.h>       //ASSERT()
53 #include <cfg/macros.h>      //MIN(), ROUND_UP();
54
55 #if CONFIG_RANDPOOL_TIMER
56         #include <drv/timer.h>       //timer_clock();
57 #endif
58
59
60
61 /*
62  * Insert bytes in entropy pool, making a XOR of bytes present
63  * in entropy pool.
64  */
65 static void randpool_push(EntropyPool *pool, void *_byte, size_t n_byte)
66 {
67         size_t i = pool->pos_add; // Current number of byte insert in entropy pool.
68         uint8_t *byte;
69
70         byte = (uint8_t *)_byte;
71
72         /*
73          * Insert a bytes in entropy pool.
74          */
75         for(int j = 0; j < n_byte; j++)
76         {
77                 pool->pool_entropy[i] = pool->pool_entropy[i] ^ byte[j];
78                 i = (++i) % CONFIG_SIZE_ENTROPY_POOL;
79         }
80
81         pool->pos_add  =  i; // Update a insert bytes.
82 }
83
84
85 /*
86  * This function stir entropy pool with MD2 function hash.
87  *
88  */
89 static void randpool_stir(EntropyPool *pool)
90 {
91         size_t entropy = pool->entropy; //Save current calue of entropy.
92         Md2Context context;
93         uint8_t tmp_buf[((sizeof(size_t) * 2) + sizeof(int)) * 2 + 1]; //Temporary buffer.
94
95         md2_init(&context); //Init MD2 algorithm.
96
97         randpool_add(pool, NULL, 0);
98
99         for (int i = 0; i < (CONFIG_SIZE_ENTROPY_POOL / MD2_DIGEST_LEN); i++)
100         {
101                 sprintf(tmp_buf, "%0x%0x%0x",pool->counter, i, pool->pos_add);
102
103                 /*
104                  * Hash with MD2 algorithm the entropy pool.
105                  */
106                 md2_update(&context, pool->pool_entropy, CONFIG_SIZE_ENTROPY_POOL);
107
108                 md2_update(&context, tmp_buf, sizeof(tmp_buf) - 1);
109
110                 /*Insert a message digest in entropy pool.*/
111                 randpool_push(pool, md2_end(&context), MD2_DIGEST_LEN);
112
113                 pool->counter = pool->counter + 1; 
114
115         }
116
117         /*Insert in pool the difference between a two call of this function (see above).*/
118         randpool_add(pool, NULL, 0);
119
120         pool->entropy = entropy; //Restore old value of entropy. We haven't add entropy.
121 }
122
123 /**
124  * Add \param entropy bits from \param data buffer to the entropy \param pool.
125  */
126 void randpool_add(EntropyPool *pool, void *data, size_t entropy)
127 {
128         uint8_t sep[] = "\xaa\xaa\xaa\xaa";  // ??
129         size_t data_len = ROUND_UP(entropy, 8) / 8; //Number of entropy byte in input.
130
131         randpool_push(pool, data, data_len); //Insert data to entropy pool.
132
133 #if CONFIG_RANDPOOL_TIMER
134
135         ticks_t event = timer_clock();
136         ticks_t delta;
137
138         /*Difference of time between a two accese to entropy pool.*/
139         delta = event - pool->last_counter;
140
141         randpool_push(pool, &event, sizeof(ticks_t));
142         randpool_push(pool, sep, sizeof(sep) - 1); // ??
143         randpool_push(pool, &delta, sizeof(delta));
144
145         /*
146          * Count of number entropy bit add with delta.
147          */
148         delta = delta & 0xff;
149         while(delta)
150         {
151                 delta >>= 1;
152                 entropy++;
153         }
154
155         pool->last_counter = event;
156
157 #endif
158
159         pool->entropy += entropy;      //Update a entropy of the pool.
160 }
161
162 /**
163  * Randpool function initialization.
164  * The entropy pool can be initialize also with 
165  * a previous entropy pool. 
166  */
167 void randpool_init(EntropyPool *pool, void *_data, size_t len)
168 {
169         uint8_t *data;
170
171         data = (uint8_t *)_data;
172
173         memset(pool, 0, sizeof(EntropyPool));
174         pool->pos_get = CONFIG_MD2_BLOCK_LEN;
175
176 #if CONFIG_RANDPOOL_TIMER
177         pool->last_counter = timer_clock();
178 #endif
179
180         ASSERT(len < CONFIG_SIZE_ENTROPY_POOL);
181
182         if(len > 0)
183         {
184                 /*
185                  * Initialize a entropy pool with a 
186                  * previous pool, and assume all pool as
187                  * entropy.
188                  */
189                 memcpy(pool->pool_entropy, data, len);
190                 pool->entropy = len;
191         }
192
193 }
194
195 /**
196  * Get the actual value of entropy.
197  */
198 size_t randpool_size(EntropyPool *pool)
199 {
200         return pool->entropy;
201 }
202
203 void randpool_get(EntropyPool *pool, void *data, size_t n_byte)
204 {
205
206 }
207
208 /**
209  * Get n_byte from entropy pool. If n_byte is larger than number
210  * byte of entropy in entropy pool, rand_pool_getN continue
211  * to generate pseudocasual value from previous state of
212  * pool.
213  */
214 void randpool_getN(EntropyPool *pool, void *_data, size_t n_byte)
215 {
216         Md2Context context;
217         size_t i = pool->pos_get;
218         size_t n = n_byte;
219         size_t pos_write = 0;  //Number of block has been written in data.
220         size_t len = MIN((size_t)CONFIG_MD2_BLOCK_LEN, n_byte);
221         uint8_t *data;
222
223         data = (uint8_t *)_data;
224
225         /* Test if i + CONFIG_MD2_BLOCK_LEN  is inside of entropy pool.*/
226         ASSERT((CONFIG_MD2_BLOCK_LEN + i) < CONFIG_SIZE_ENTROPY_POOL);
227
228         md2_init(&context); 
229
230         while(n > 0)
231         {
232
233                 /*Hash previous state of pool*/
234                 md2_update(&context, &pool->pool_entropy[i], CONFIG_MD2_BLOCK_LEN);
235
236                 memcpy(&data[pos_write], md2_end(&context), len);
237
238                 pos_write += len;   //Update number of block has been written in data.
239                 n -= len;           //Number of byte copied in data.
240
241                 len = MIN(n,(size_t)CONFIG_MD2_BLOCK_LEN);
242
243                 i = (i + CONFIG_MD2_BLOCK_LEN) % CONFIG_SIZE_ENTROPY_POOL;
244
245                 /* If we haven't more entropy pool to hash, we stir it.*/
246                 if(i < CONFIG_MD2_BLOCK_LEN)
247                 {
248                         randpool_stir(pool);
249                         i = pool->pos_get;
250                 }
251
252         }
253         
254
255         pool->pos_get = i; //Current number of byte we get from pool.
256         
257         pool->entropy -= n_byte; //Update a entropy.
258
259         /*If we get all entropy entropy is 0*/
260         if(pool->entropy < 0) 
261                 pool->entropy = 0;
262
263 }
264
265 /**
266  * Return a pointer to entropy pool.
267  */
268 uint8_t *randpool_pool(EntropyPool *pool)
269 {
270         return pool->pool_entropy;
271 }
272