OSDN Git Service

Enlarge buffers for replies on transferring files.
[ffftp/ffftp.git] / putty / SSHRAND.C
1 /*\r
2  * cryptographic random number generator for PuTTY's ssh client\r
3  */\r
4 \r
5 #include "putty.h"\r
6 #include "ssh.h"\r
7 #include <assert.h>\r
8 \r
9 /* Collect environmental noise every 5 minutes */\r
10 #define NOISE_REGULAR_INTERVAL (5*60*TICKSPERSEC)\r
11 \r
12 void noise_get_heavy(void (*func) (void *, int));\r
13 void noise_get_light(void (*func) (void *, int));\r
14 \r
15 /*\r
16  * `pool' itself is a pool of random data which we actually use: we\r
17  * return bytes from `pool', at position `poolpos', until `poolpos'\r
18  * reaches the end of the pool. At this point we generate more\r
19  * random data, by adding noise, stirring well, and resetting\r
20  * `poolpos' to point to just past the beginning of the pool (not\r
21  * _the_ beginning, since otherwise we'd give away the whole\r
22  * contents of our pool, and attackers would just have to guess the\r
23  * next lot of noise).\r
24  *\r
25  * `incomingb' buffers acquired noise data, until it gets full, at\r
26  * which point the acquired noise is SHA'ed into `incoming' and\r
27  * `incomingb' is cleared. The noise in `incoming' is used as part\r
28  * of the noise for each stirring of the pool, in addition to local\r
29  * time, process listings, and other such stuff.\r
30  */\r
31 \r
32 #define HASHINPUT 64                   /* 64 bytes SHA input */\r
33 #define HASHSIZE 20                    /* 160 bits SHA output */\r
34 #define POOLSIZE 1200                  /* size of random pool */\r
35 \r
36 struct RandPool {\r
37     unsigned char pool[POOLSIZE];\r
38     int poolpos;\r
39 \r
40     unsigned char incoming[HASHSIZE];\r
41 \r
42     unsigned char incomingb[HASHINPUT];\r
43     int incomingpos;\r
44 \r
45     int stir_pending;\r
46 };\r
47 \r
48 static struct RandPool pool;\r
49 int random_active = 0;\r
50 long next_noise_collection;\r
51 \r
52 static void random_stir(void)\r
53 {\r
54     word32 block[HASHINPUT / sizeof(word32)];\r
55     word32 digest[HASHSIZE / sizeof(word32)];\r
56     int i, j, k;\r
57 \r
58     /*\r
59      * noise_get_light will call random_add_noise, which may call\r
60      * back to here. Prevent recursive stirs.\r
61      */\r
62     if (pool.stir_pending)\r
63         return;\r
64     pool.stir_pending = TRUE;\r
65 \r
66     noise_get_light(random_add_noise);\r
67 \r
68     SHATransform((word32 *) pool.incoming, (word32 *) pool.incomingb);\r
69     pool.incomingpos = 0;\r
70 \r
71     /*\r
72      * Chunks of this code are blatantly endianness-dependent, but\r
73      * as it's all random bits anyway, WHO CARES?\r
74      */\r
75     memcpy(digest, pool.incoming, sizeof(digest));\r
76 \r
77     /*\r
78      * Make two passes over the pool.\r
79      */\r
80     for (i = 0; i < 2; i++) {\r
81 \r
82         /*\r
83          * We operate SHA in CFB mode, repeatedly adding the same\r
84          * block of data to the digest. But we're also fiddling\r
85          * with the digest-so-far, so this shouldn't be Bad or\r
86          * anything.\r
87          */\r
88         memcpy(block, pool.pool, sizeof(block));\r
89 \r
90         /*\r
91          * Each pass processes the pool backwards in blocks of\r
92          * HASHSIZE, just so that in general we get the output of\r
93          * SHA before the corresponding input, in the hope that\r
94          * things will be that much less predictable that way\r
95          * round, when we subsequently return bytes ...\r
96          */\r
97         for (j = POOLSIZE; (j -= HASHSIZE) >= 0;) {\r
98             /*\r
99              * XOR the bit of the pool we're processing into the\r
100              * digest.\r
101              */\r
102 \r
103             for (k = 0; k < sizeof(digest) / sizeof(*digest); k++)\r
104                 digest[k] ^= ((word32 *) (pool.pool + j))[k];\r
105 \r
106             /*\r
107              * Munge our unrevealed first block of the pool into\r
108              * it.\r
109              */\r
110             SHATransform(digest, block);\r
111 \r
112             /*\r
113              * Stick the result back into the pool.\r
114              */\r
115 \r
116             for (k = 0; k < sizeof(digest) / sizeof(*digest); k++)\r
117                 ((word32 *) (pool.pool + j))[k] = digest[k];\r
118         }\r
119     }\r
120 \r
121     /*\r
122      * Might as well save this value back into `incoming', just so\r
123      * there'll be some extra bizarreness there.\r
124      */\r
125     SHATransform(digest, block);\r
126     memcpy(pool.incoming, digest, sizeof(digest));\r
127 \r
128     pool.poolpos = sizeof(pool.incoming);\r
129 \r
130     pool.stir_pending = FALSE;\r
131 }\r
132 \r
133 void random_add_noise(void *noise, int length)\r
134 {\r
135     unsigned char *p = noise;\r
136     int i;\r
137 \r
138     if (!random_active)\r
139         return;\r
140 \r
141     /*\r
142      * This function processes HASHINPUT bytes into only HASHSIZE\r
143      * bytes, so _if_ we were getting incredibly high entropy\r
144      * sources then we would be throwing away valuable stuff.\r
145      */\r
146     while (length >= (HASHINPUT - pool.incomingpos)) {\r
147         memcpy(pool.incomingb + pool.incomingpos, p,\r
148                HASHINPUT - pool.incomingpos);\r
149         p += HASHINPUT - pool.incomingpos;\r
150         length -= HASHINPUT - pool.incomingpos;\r
151         SHATransform((word32 *) pool.incoming, (word32 *) pool.incomingb);\r
152         for (i = 0; i < HASHSIZE; i++) {\r
153             pool.pool[pool.poolpos++] ^= pool.incomingb[i];\r
154             if (pool.poolpos >= POOLSIZE)\r
155                 pool.poolpos = 0;\r
156         }\r
157         if (pool.poolpos < HASHSIZE)\r
158             random_stir();\r
159 \r
160         pool.incomingpos = 0;\r
161     }\r
162 \r
163     memcpy(pool.incomingb + pool.incomingpos, p, length);\r
164     pool.incomingpos += length;\r
165 }\r
166 \r
167 void random_add_heavynoise(void *noise, int length)\r
168 {\r
169     unsigned char *p = noise;\r
170     int i;\r
171 \r
172     while (length >= POOLSIZE) {\r
173         for (i = 0; i < POOLSIZE; i++)\r
174             pool.pool[i] ^= *p++;\r
175         random_stir();\r
176         length -= POOLSIZE;\r
177     }\r
178 \r
179     for (i = 0; i < length; i++)\r
180         pool.pool[i] ^= *p++;\r
181     random_stir();\r
182 }\r
183 \r
184 static void random_add_heavynoise_bitbybit(void *noise, int length)\r
185 {\r
186     unsigned char *p = noise;\r
187     int i;\r
188 \r
189     while (length >= POOLSIZE - pool.poolpos) {\r
190         for (i = 0; i < POOLSIZE - pool.poolpos; i++)\r
191             pool.pool[pool.poolpos + i] ^= *p++;\r
192         random_stir();\r
193         length -= POOLSIZE - pool.poolpos;\r
194         pool.poolpos = 0;\r
195     }\r
196 \r
197     for (i = 0; i < length; i++)\r
198         pool.pool[i] ^= *p++;\r
199     pool.poolpos = i;\r
200 }\r
201 \r
202 static void random_timer(void *ctx, long now)\r
203 {\r
204     if (random_active > 0 && now - next_noise_collection >= 0) {\r
205         noise_regular();\r
206         next_noise_collection =\r
207             schedule_timer(NOISE_REGULAR_INTERVAL, random_timer, &pool);\r
208     }\r
209 }\r
210 \r
211 void random_ref(void)\r
212 {\r
213     if (!random_active) {\r
214         memset(&pool, 0, sizeof(pool));    /* just to start with */\r
215 \r
216         noise_get_heavy(random_add_heavynoise_bitbybit);\r
217         random_stir();\r
218 \r
219         next_noise_collection =\r
220             schedule_timer(NOISE_REGULAR_INTERVAL, random_timer, &pool);\r
221     }\r
222 \r
223     random_active++;\r
224 }\r
225 \r
226 void random_unref(void)\r
227 {\r
228     random_active--;\r
229     assert(random_active >= 0);\r
230     if (random_active) return;\r
231 \r
232     expire_timer_context(&pool);\r
233 }\r
234 \r
235 int random_byte(void)\r
236 {\r
237     if (pool.poolpos >= POOLSIZE)\r
238         random_stir();\r
239 \r
240     return pool.pool[pool.poolpos++];\r
241 }\r
242 \r
243 void random_get_savedata(void **data, int *len)\r
244 {\r
245     void *buf = snewn(POOLSIZE / 2, char);\r
246     random_stir();\r
247     memcpy(buf, pool.pool + pool.poolpos, POOLSIZE / 2);\r
248     *len = POOLSIZE / 2;\r
249     *data = buf;\r
250     random_stir();\r
251 }\r