]>
Commit | Line | Data |
---|---|---|
d02b48c6 | 1 | /* ssl/s3_lib.c */ |
58964a49 | 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
d02b48c6 RE |
3 | * All rights reserved. |
4 | * | |
5 | * This package is an SSL implementation written | |
6 | * by Eric Young (eay@cryptsoft.com). | |
7 | * The implementation was written so as to conform with Netscapes SSL. | |
8 | * | |
9 | * This library is free for commercial and non-commercial use as long as | |
10 | * the following conditions are aheared to. The following conditions | |
11 | * apply to all code found in this distribution, be it the RC4, RSA, | |
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | |
13 | * included with this distribution is covered by the same copyright terms | |
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | |
15 | * | |
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | |
17 | * the code are not to be removed. | |
18 | * If this package is used in a product, Eric Young should be given attribution | |
19 | * as the author of the parts of the library used. | |
20 | * This can be in the form of a textual message at program startup or | |
21 | * in documentation (online or textual) provided with the package. | |
22 | * | |
23 | * Redistribution and use in source and binary forms, with or without | |
24 | * modification, are permitted provided that the following conditions | |
25 | * are met: | |
26 | * 1. Redistributions of source code must retain the copyright | |
27 | * notice, this list of conditions and the following disclaimer. | |
28 | * 2. Redistributions in binary form must reproduce the above copyright | |
29 | * notice, this list of conditions and the following disclaimer in the | |
30 | * documentation and/or other materials provided with the distribution. | |
31 | * 3. All advertising materials mentioning features or use of this software | |
32 | * must display the following acknowledgement: | |
33 | * "This product includes cryptographic software written by | |
34 | * Eric Young (eay@cryptsoft.com)" | |
35 | * The word 'cryptographic' can be left out if the rouines from the library | |
36 | * being used are not cryptographic related :-). | |
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | |
38 | * the apps directory (application code) you must include an acknowledgement: | |
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | |
40 | * | |
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | |
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | |
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
51 | * SUCH DAMAGE. | |
52 | * | |
53 | * The licence and distribution terms for any publically available version or | |
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | |
55 | * copied and put under another distribution licence | |
56 | * [including the GNU Public Licence.] | |
57 | */ | |
58 | ||
59 | #include <stdio.h> | |
60 | #include "objects.h" | |
61 | #include "ssl_locl.h" | |
62 | ||
9cb0969f | 63 | char *ssl3_version_str="SSLv3 part of OpenSSL 0.9.2 31-Dec-1998"; |
d02b48c6 RE |
64 | |
65 | #define SSL3_NUM_CIPHERS (sizeof(ssl3_ciphers)/sizeof(SSL_CIPHER)) | |
66 | ||
67 | #ifndef NOPROTO | |
68 | static long ssl3_default_timeout(void ); | |
69 | #else | |
70 | static long ssl3_default_timeout(); | |
71 | #endif | |
72 | ||
73 | SSL_CIPHER ssl3_ciphers[]={ | |
74 | /* The RSA ciphers */ | |
75 | /* Cipher 01 */ | |
76 | { | |
77 | 1, | |
78 | SSL3_TXT_RSA_NULL_MD5, | |
79 | SSL3_CK_RSA_NULL_MD5, | |
80 | SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_MD5|SSL_NOT_EXP|SSL_SSLV3, | |
81 | 0, | |
82 | SSL_ALL_CIPHERS, | |
83 | }, | |
84 | /* Cipher 02 */ | |
85 | { | |
86 | 1, | |
87 | SSL3_TXT_RSA_NULL_SHA, | |
88 | SSL3_CK_RSA_NULL_SHA, | |
89 | SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3, | |
90 | 0, | |
91 | SSL_ALL_CIPHERS, | |
92 | }, | |
93 | ||
94 | /* anon DH */ | |
95 | /* Cipher 17 */ | |
96 | { | |
97 | 1, | |
98 | SSL3_TXT_ADH_RC4_40_MD5, | |
99 | SSL3_CK_ADH_RC4_40_MD5, | |
100 | SSL_kEDH |SSL_aNULL|SSL_RC4 |SSL_MD5 |SSL_EXP|SSL_SSLV3, | |
101 | 0, | |
102 | SSL_ALL_CIPHERS, | |
103 | }, | |
104 | /* Cipher 18 */ | |
105 | { | |
106 | 1, | |
107 | SSL3_TXT_ADH_RC4_128_MD5, | |
108 | SSL3_CK_ADH_RC4_128_MD5, | |
109 | SSL_kEDH |SSL_aNULL|SSL_RC4 |SSL_MD5|SSL_NOT_EXP|SSL_SSLV3, | |
110 | 0, | |
111 | SSL_ALL_CIPHERS, | |
112 | }, | |
113 | /* Cipher 19 */ | |
114 | { | |
115 | 1, | |
116 | SSL3_TXT_ADH_DES_40_CBC_SHA, | |
117 | SSL3_CK_ADH_DES_40_CBC_SHA, | |
118 | SSL_kEDH |SSL_aNULL|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3, | |
119 | 0, | |
120 | SSL_ALL_CIPHERS, | |
121 | }, | |
122 | /* Cipher 1A */ | |
123 | { | |
124 | 1, | |
125 | SSL3_TXT_ADH_DES_64_CBC_SHA, | |
126 | SSL3_CK_ADH_DES_64_CBC_SHA, | |
127 | SSL_kEDH |SSL_aNULL|SSL_DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3, | |
128 | 0, | |
129 | SSL_ALL_CIPHERS, | |
130 | }, | |
131 | /* Cipher 1B */ | |
132 | { | |
133 | 1, | |
58964a49 RE |
134 | SSL3_TXT_ADH_DES_192_CBC_SHA, |
135 | SSL3_CK_ADH_DES_192_CBC_SHA, | |
d02b48c6 RE |
136 | SSL_kEDH |SSL_aNULL|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3, |
137 | 0, | |
138 | SSL_ALL_CIPHERS, | |
139 | }, | |
140 | ||
141 | /* RSA again */ | |
142 | /* Cipher 03 */ | |
143 | { | |
144 | 1, | |
145 | SSL3_TXT_RSA_RC4_40_MD5, | |
146 | SSL3_CK_RSA_RC4_40_MD5, | |
147 | SSL_kRSA|SSL_aRSA|SSL_RC4 |SSL_MD5 |SSL_EXP|SSL_SSLV3, | |
148 | 0, | |
149 | SSL_ALL_CIPHERS, | |
150 | }, | |
151 | /* Cipher 04 */ | |
152 | { | |
153 | 1, | |
154 | SSL3_TXT_RSA_RC4_128_MD5, | |
155 | SSL3_CK_RSA_RC4_128_MD5, | |
156 | SSL_kRSA|SSL_aRSA|SSL_RC4 |SSL_MD5|SSL_NOT_EXP|SSL_SSLV3|SSL_MEDIUM, | |
157 | 0, | |
158 | SSL_ALL_CIPHERS, | |
159 | }, | |
160 | /* Cipher 05 */ | |
161 | { | |
162 | 1, | |
163 | SSL3_TXT_RSA_RC4_128_SHA, | |
164 | SSL3_CK_RSA_RC4_128_SHA, | |
165 | SSL_kRSA|SSL_aRSA|SSL_RC4 |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_MEDIUM, | |
166 | 0, | |
167 | SSL_ALL_CIPHERS, | |
168 | }, | |
169 | /* Cipher 06 */ | |
170 | { | |
171 | 1, | |
172 | SSL3_TXT_RSA_RC2_40_MD5, | |
173 | SSL3_CK_RSA_RC2_40_MD5, | |
174 | SSL_kRSA|SSL_aRSA|SSL_RC2 |SSL_MD5 |SSL_EXP|SSL_SSLV3, | |
175 | 0, | |
176 | SSL_ALL_CIPHERS, | |
177 | }, | |
178 | /* Cipher 07 */ | |
179 | { | |
180 | 1, | |
181 | SSL3_TXT_RSA_IDEA_128_SHA, | |
182 | SSL3_CK_RSA_IDEA_128_SHA, | |
183 | SSL_kRSA|SSL_aRSA|SSL_IDEA |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_MEDIUM, | |
184 | 0, | |
185 | SSL_ALL_CIPHERS, | |
186 | }, | |
187 | /* Cipher 08 */ | |
188 | { | |
189 | 1, | |
190 | SSL3_TXT_RSA_DES_40_CBC_SHA, | |
191 | SSL3_CK_RSA_DES_40_CBC_SHA, | |
192 | SSL_kRSA|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3, | |
193 | 0, | |
194 | SSL_ALL_CIPHERS, | |
195 | }, | |
196 | /* Cipher 09 */ | |
197 | { | |
198 | 1, | |
199 | SSL3_TXT_RSA_DES_64_CBC_SHA, | |
200 | SSL3_CK_RSA_DES_64_CBC_SHA, | |
201 | SSL_kRSA|SSL_aRSA|SSL_DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW, | |
202 | 0, | |
203 | SSL_ALL_CIPHERS, | |
204 | }, | |
205 | /* Cipher 0A */ | |
206 | { | |
207 | 1, | |
208 | SSL3_TXT_RSA_DES_192_CBC3_SHA, | |
209 | SSL3_CK_RSA_DES_192_CBC3_SHA, | |
210 | SSL_kRSA|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH, | |
211 | 0, | |
212 | SSL_ALL_CIPHERS, | |
213 | }, | |
214 | ||
215 | /* The DH ciphers */ | |
216 | /* Cipher 0B */ | |
217 | { | |
218 | 0, | |
219 | SSL3_TXT_DH_DSS_DES_40_CBC_SHA, | |
220 | SSL3_CK_DH_DSS_DES_40_CBC_SHA, | |
221 | SSL_kDHd |SSL_aDH|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3, | |
222 | 0, | |
223 | SSL_ALL_CIPHERS, | |
224 | }, | |
225 | /* Cipher 0C */ | |
226 | { | |
227 | 0, | |
228 | SSL3_TXT_DH_DSS_DES_64_CBC_SHA, | |
229 | SSL3_CK_DH_DSS_DES_64_CBC_SHA, | |
230 | SSL_kDHd |SSL_aDH|SSL_DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW, | |
231 | 0, | |
232 | SSL_ALL_CIPHERS, | |
233 | }, | |
234 | /* Cipher 0D */ | |
235 | { | |
236 | 0, | |
237 | SSL3_TXT_DH_DSS_DES_192_CBC3_SHA, | |
238 | SSL3_CK_DH_DSS_DES_192_CBC3_SHA, | |
239 | SSL_kDHd |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH, | |
240 | 0, | |
241 | SSL_ALL_CIPHERS, | |
242 | }, | |
243 | /* Cipher 0E */ | |
244 | { | |
245 | 0, | |
246 | SSL3_TXT_DH_RSA_DES_40_CBC_SHA, | |
247 | SSL3_CK_DH_RSA_DES_40_CBC_SHA, | |
248 | SSL_kDHr |SSL_aDH|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3, | |
249 | 0, | |
250 | SSL_ALL_CIPHERS, | |
251 | }, | |
252 | /* Cipher 0F */ | |
253 | { | |
254 | 0, | |
255 | SSL3_TXT_DH_RSA_DES_64_CBC_SHA, | |
256 | SSL3_CK_DH_RSA_DES_64_CBC_SHA, | |
257 | SSL_kDHr |SSL_aDH|SSL_DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW, | |
258 | 0, | |
259 | SSL_ALL_CIPHERS, | |
260 | }, | |
261 | /* Cipher 10 */ | |
262 | { | |
263 | 0, | |
264 | SSL3_TXT_DH_RSA_DES_192_CBC3_SHA, | |
265 | SSL3_CK_DH_RSA_DES_192_CBC3_SHA, | |
266 | SSL_kDHr |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH, | |
267 | 0, | |
268 | SSL_ALL_CIPHERS, | |
269 | }, | |
270 | ||
271 | /* The Ephemeral DH ciphers */ | |
272 | /* Cipher 11 */ | |
273 | { | |
274 | 1, | |
275 | SSL3_TXT_EDH_DSS_DES_40_CBC_SHA, | |
276 | SSL3_CK_EDH_DSS_DES_40_CBC_SHA, | |
277 | SSL_kEDH|SSL_aDSS|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3, | |
278 | 0, | |
279 | SSL_ALL_CIPHERS, | |
280 | }, | |
281 | /* Cipher 12 */ | |
282 | { | |
283 | 1, | |
284 | SSL3_TXT_EDH_DSS_DES_64_CBC_SHA, | |
285 | SSL3_CK_EDH_DSS_DES_64_CBC_SHA, | |
286 | SSL_kEDH|SSL_aDSS|SSL_DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW, | |
287 | 0, | |
288 | SSL_ALL_CIPHERS, | |
289 | }, | |
290 | /* Cipher 13 */ | |
291 | { | |
292 | 1, | |
293 | SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA, | |
294 | SSL3_CK_EDH_DSS_DES_192_CBC3_SHA, | |
295 | SSL_kEDH|SSL_aDSS|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH, | |
296 | 0, | |
297 | SSL_ALL_CIPHERS, | |
298 | }, | |
299 | /* Cipher 14 */ | |
300 | { | |
301 | 1, | |
302 | SSL3_TXT_EDH_RSA_DES_40_CBC_SHA, | |
303 | SSL3_CK_EDH_RSA_DES_40_CBC_SHA, | |
304 | SSL_kEDH|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3, | |
305 | 0, | |
306 | SSL_ALL_CIPHERS, | |
307 | }, | |
308 | /* Cipher 15 */ | |
309 | { | |
310 | 1, | |
311 | SSL3_TXT_EDH_RSA_DES_64_CBC_SHA, | |
312 | SSL3_CK_EDH_RSA_DES_64_CBC_SHA, | |
313 | SSL_kEDH|SSL_aRSA|SSL_DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW, | |
314 | 0, | |
315 | SSL_ALL_CIPHERS, | |
316 | }, | |
317 | /* Cipher 16 */ | |
318 | { | |
319 | 1, | |
320 | SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA, | |
321 | SSL3_CK_EDH_RSA_DES_192_CBC3_SHA, | |
322 | SSL_kEDH|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH, | |
323 | 0, | |
324 | SSL_ALL_CIPHERS, | |
325 | }, | |
326 | ||
327 | /* Fortezza */ | |
328 | /* Cipher 1C */ | |
329 | { | |
330 | 0, | |
331 | SSL3_TXT_FZA_DMS_NULL_SHA, | |
332 | SSL3_CK_FZA_DMS_NULL_SHA, | |
333 | SSL_kFZA|SSL_aFZA |SSL_eNULL |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3, | |
334 | 0, | |
335 | SSL_ALL_CIPHERS, | |
336 | }, | |
337 | ||
338 | /* Cipher 1D */ | |
339 | { | |
340 | 0, | |
341 | SSL3_TXT_FZA_DMS_FZA_SHA, | |
342 | SSL3_CK_FZA_DMS_FZA_SHA, | |
343 | SSL_kFZA|SSL_aFZA |SSL_eFZA |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3, | |
344 | 0, | |
345 | SSL_ALL_CIPHERS, | |
346 | }, | |
347 | ||
348 | /* Cipher 1E */ | |
349 | { | |
350 | 0, | |
351 | SSL3_TXT_FZA_DMS_RC4_SHA, | |
352 | SSL3_CK_FZA_DMS_RC4_SHA, | |
353 | SSL_kFZA|SSL_aFZA |SSL_RC4 |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3, | |
354 | 0, | |
355 | SSL_ALL_CIPHERS, | |
356 | }, | |
357 | ||
358 | /* end of list */ | |
359 | }; | |
360 | ||
58964a49 RE |
361 | static SSL3_ENC_METHOD SSLv3_enc_data={ |
362 | ssl3_enc, | |
363 | ssl3_mac, | |
364 | ssl3_setup_key_block, | |
365 | ssl3_generate_master_secret, | |
366 | ssl3_change_cipher_state, | |
367 | ssl3_final_finish_mac, | |
368 | MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH, | |
369 | ssl3_cert_verify_mac, | |
370 | SSL3_MD_CLIENT_FINISHED_CONST,4, | |
371 | SSL3_MD_SERVER_FINISHED_CONST,4, | |
372 | ssl3_alert_code, | |
373 | }; | |
374 | ||
d02b48c6 | 375 | static SSL_METHOD SSLv3_data= { |
58964a49 | 376 | SSL3_VERSION, |
d02b48c6 RE |
377 | ssl3_new, |
378 | ssl3_clear, | |
379 | ssl3_free, | |
380 | ssl_undefined_function, | |
381 | ssl_undefined_function, | |
382 | ssl3_read, | |
383 | ssl3_peek, | |
384 | ssl3_write, | |
385 | ssl3_shutdown, | |
386 | ssl3_renegotiate, | |
dfeab068 | 387 | ssl3_renegotiate_check, |
d02b48c6 RE |
388 | ssl3_ctrl, |
389 | ssl3_ctx_ctrl, | |
390 | ssl3_get_cipher_by_char, | |
391 | ssl3_put_cipher_by_char, | |
392 | ssl3_pending, | |
393 | ssl3_num_ciphers, | |
394 | ssl3_get_cipher, | |
395 | ssl_bad_method, | |
396 | ssl3_default_timeout, | |
58964a49 | 397 | &SSLv3_enc_data, |
d02b48c6 RE |
398 | }; |
399 | ||
400 | static long ssl3_default_timeout() | |
401 | { | |
402 | /* 2 hours, the 24 hours mentioned in the SSLv3 spec | |
403 | * is way too long for http, the cache would over fill */ | |
404 | return(60*60*2); | |
405 | } | |
406 | ||
407 | SSL_METHOD *sslv3_base_method() | |
408 | { | |
409 | return(&SSLv3_data); | |
410 | } | |
411 | ||
412 | int ssl3_num_ciphers() | |
413 | { | |
414 | return(SSL3_NUM_CIPHERS); | |
415 | } | |
416 | ||
417 | SSL_CIPHER *ssl3_get_cipher(u) | |
418 | unsigned int u; | |
419 | { | |
420 | if (u < SSL3_NUM_CIPHERS) | |
421 | return(&(ssl3_ciphers[SSL3_NUM_CIPHERS-1-u])); | |
422 | else | |
423 | return(NULL); | |
424 | } | |
425 | ||
426 | /* The problem is that it may not be the correct record type */ | |
427 | int ssl3_pending(s) | |
428 | SSL *s; | |
429 | { | |
430 | return(s->s3->rrec.length); | |
431 | } | |
432 | ||
433 | int ssl3_new(s) | |
434 | SSL *s; | |
435 | { | |
436 | SSL3_CTX *s3; | |
437 | ||
438 | if ((s3=(SSL3_CTX *)Malloc(sizeof(SSL3_CTX))) == NULL) goto err; | |
58964a49 | 439 | memset(s3,0,sizeof(SSL3_CTX)); |
d02b48c6 RE |
440 | |
441 | s->s3=s3; | |
58964a49 | 442 | /* |
d02b48c6 RE |
443 | s->s3->tmp.ca_names=NULL; |
444 | s->s3->tmp.key_block=NULL; | |
58964a49 | 445 | s->s3->tmp.key_block_length=0; |
d02b48c6 RE |
446 | s->s3->rbuf.buf=NULL; |
447 | s->s3->wbuf.buf=NULL; | |
58964a49 | 448 | */ |
d02b48c6 | 449 | |
58964a49 | 450 | s->method->ssl_clear(s); |
d02b48c6 RE |
451 | return(1); |
452 | err: | |
453 | return(0); | |
454 | } | |
455 | ||
456 | void ssl3_free(s) | |
457 | SSL *s; | |
458 | { | |
e03ddfae BL |
459 | if(s == NULL) |
460 | return; | |
461 | ||
d02b48c6 RE |
462 | ssl3_cleanup_key_block(s); |
463 | if (s->s3->rbuf.buf != NULL) | |
464 | Free(s->s3->rbuf.buf); | |
465 | if (s->s3->wbuf.buf != NULL) | |
466 | Free(s->s3->wbuf.buf); | |
dfeab068 RE |
467 | if (s->s3->rrec.comp != NULL) |
468 | Free(s->s3->rrec.comp); | |
d02b48c6 RE |
469 | #ifndef NO_DH |
470 | if (s->s3->tmp.dh != NULL) | |
471 | DH_free(s->s3->tmp.dh); | |
472 | #endif | |
473 | if (s->s3->tmp.ca_names != NULL) | |
474 | sk_pop_free(s->s3->tmp.ca_names,X509_NAME_free); | |
475 | memset(s->s3,0,sizeof(SSL3_CTX)); | |
476 | Free(s->s3); | |
477 | s->s3=NULL; | |
478 | } | |
479 | ||
480 | void ssl3_clear(s) | |
481 | SSL *s; | |
482 | { | |
483 | unsigned char *rp,*wp; | |
484 | ||
485 | ssl3_cleanup_key_block(s); | |
486 | if (s->s3->tmp.ca_names != NULL) | |
487 | sk_pop_free(s->s3->tmp.ca_names,X509_NAME_free); | |
488 | ||
489 | rp=s->s3->rbuf.buf; | |
490 | wp=s->s3->wbuf.buf; | |
491 | ||
492 | memset(s->s3,0,sizeof(SSL3_CTX)); | |
58964a49 RE |
493 | if (rp != NULL) s->s3->rbuf.buf=rp; |
494 | if (wp != NULL) s->s3->wbuf.buf=wp; | |
dfeab068 RE |
495 | |
496 | if (s->s3->rrec.comp != NULL) | |
497 | { | |
498 | Free(s->s3->rrec.comp); | |
499 | s->s3->rrec.comp=NULL; | |
500 | } | |
501 | ||
d02b48c6 | 502 | s->packet_length=0; |
58964a49 RE |
503 | s->s3->renegotiate=0; |
504 | s->s3->total_renegotiations=0; | |
505 | s->s3->num_renegotiations=0; | |
506 | s->s3->in_read_app_data=0; | |
507 | s->version=SSL3_VERSION; | |
d02b48c6 RE |
508 | } |
509 | ||
510 | long ssl3_ctrl(s,cmd,larg,parg) | |
511 | SSL *s; | |
512 | int cmd; | |
513 | long larg; | |
514 | char *parg; | |
515 | { | |
58964a49 RE |
516 | int ret=0; |
517 | ||
518 | switch (cmd) | |
519 | { | |
520 | case SSL_CTRL_GET_SESSION_REUSED: | |
521 | ret=s->hit; | |
522 | break; | |
523 | case SSL_CTRL_GET_CLIENT_CERT_REQUEST: | |
524 | break; | |
525 | case SSL_CTRL_GET_NUM_RENEGOTIATIONS: | |
526 | ret=s->s3->num_renegotiations; | |
527 | break; | |
528 | case SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS: | |
529 | ret=s->s3->num_renegotiations; | |
530 | s->s3->num_renegotiations=0; | |
531 | break; | |
532 | case SSL_CTRL_GET_TOTAL_RENEGOTIATIONS: | |
533 | ret=s->s3->total_renegotiations; | |
534 | break; | |
dfeab068 | 535 | case SSL_CTRL_GET_FLAGS: |
651d0aff | 536 | ret=(int)(s->s3->flags); |
dfeab068 | 537 | break; |
58964a49 RE |
538 | default: |
539 | break; | |
540 | } | |
541 | return(ret); | |
d02b48c6 RE |
542 | } |
543 | ||
544 | long ssl3_ctx_ctrl(ctx,cmd,larg,parg) | |
545 | SSL_CTX *ctx; | |
546 | int cmd; | |
547 | long larg; | |
548 | char *parg; | |
549 | { | |
550 | CERT *cert; | |
551 | ||
552 | cert=ctx->default_cert; | |
553 | ||
554 | switch (cmd) | |
555 | { | |
556 | #ifndef NO_RSA | |
557 | case SSL_CTRL_NEED_TMP_RSA: | |
558 | if ( (cert->rsa_tmp == NULL) && | |
559 | ((cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL) || | |
560 | (EVP_PKEY_size(cert->pkeys[SSL_PKEY_RSA_ENC].privatekey) > (512/8))) | |
561 | ) | |
562 | return(1); | |
563 | else | |
564 | return(0); | |
dfeab068 | 565 | /* break; */ |
d02b48c6 RE |
566 | case SSL_CTRL_SET_TMP_RSA: |
567 | { | |
568 | RSA *rsa; | |
569 | int i; | |
570 | ||
571 | rsa=(RSA *)parg; | |
572 | i=1; | |
573 | if (rsa == NULL) | |
574 | i=0; | |
575 | else | |
576 | { | |
577 | if ((rsa=RSAPrivateKey_dup(rsa)) == NULL) | |
578 | i=0; | |
579 | } | |
580 | if (!i) | |
581 | { | |
582 | SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_RSA_LIB); | |
583 | return(0); | |
584 | } | |
585 | else | |
586 | { | |
587 | if (cert->rsa_tmp != NULL) | |
588 | RSA_free(cert->rsa_tmp); | |
589 | cert->rsa_tmp=rsa; | |
590 | return(1); | |
591 | } | |
592 | } | |
dfeab068 | 593 | /* break; */ |
d02b48c6 RE |
594 | case SSL_CTRL_SET_TMP_RSA_CB: |
595 | cert->rsa_tmp_cb=(RSA *(*)())parg; | |
596 | break; | |
597 | #endif | |
598 | #ifndef NO_DH | |
599 | case SSL_CTRL_SET_TMP_DH: | |
600 | { | |
601 | DH *new=NULL,*dh; | |
dfeab068 | 602 | int rret=0; |
d02b48c6 RE |
603 | |
604 | dh=(DH *)parg; | |
605 | if ( ((new=DHparams_dup(dh)) == NULL) || | |
606 | (!DH_generate_key(new))) | |
607 | { | |
608 | SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_DH_LIB); | |
609 | if (new != NULL) DH_free(new); | |
d02b48c6 RE |
610 | } |
611 | else | |
612 | { | |
613 | if (cert->dh_tmp != NULL) | |
614 | DH_free(cert->dh_tmp); | |
615 | cert->dh_tmp=new; | |
dfeab068 | 616 | rret=1; |
d02b48c6 | 617 | } |
dfeab068 | 618 | return(rret); |
d02b48c6 | 619 | } |
dfeab068 | 620 | /*break; */ |
d02b48c6 RE |
621 | case SSL_CTRL_SET_TMP_DH_CB: |
622 | cert->dh_tmp_cb=(DH *(*)())parg; | |
623 | break; | |
624 | #endif | |
651d0aff | 625 | /* A Thawte special :-) */ |
dfeab068 RE |
626 | case SSL_CTRL_EXTRA_CHAIN_CERT: |
627 | if (ctx->extra_certs == NULL) | |
628 | { | |
629 | if ((ctx->extra_certs=sk_new_null()) == NULL) | |
630 | return(0); | |
631 | } | |
632 | sk_push(ctx->extra_certs,(char *)parg); | |
633 | break; | |
634 | ||
d02b48c6 RE |
635 | default: |
636 | return(0); | |
637 | } | |
638 | return(1); | |
639 | } | |
640 | ||
641 | /* This function needs to check if the ciphers required are actually | |
642 | * available */ | |
643 | SSL_CIPHER *ssl3_get_cipher_by_char(p) | |
644 | unsigned char *p; | |
645 | { | |
646 | static int init=1; | |
647 | static SSL_CIPHER *sorted[SSL3_NUM_CIPHERS]; | |
648 | SSL_CIPHER c,*cp= &c,**cpp; | |
649 | unsigned long id; | |
650 | int i; | |
651 | ||
652 | if (init) | |
653 | { | |
654 | init=0; | |
655 | ||
656 | for (i=0; i<SSL3_NUM_CIPHERS; i++) | |
657 | sorted[i]= &(ssl3_ciphers[i]); | |
658 | ||
659 | qsort( (char *)sorted, | |
660 | SSL3_NUM_CIPHERS,sizeof(SSL_CIPHER *), | |
661 | FP_ICC ssl_cipher_ptr_id_cmp); | |
662 | } | |
663 | ||
664 | id=0x03000000L|((unsigned long)p[0]<<8L)|(unsigned long)p[1]; | |
665 | c.id=id; | |
666 | cpp=(SSL_CIPHER **)OBJ_bsearch((char *)&cp, | |
667 | (char *)sorted, | |
668 | SSL3_NUM_CIPHERS,sizeof(SSL_CIPHER *), | |
669 | (int (*)())ssl_cipher_ptr_id_cmp); | |
670 | if ((cpp == NULL) || !(*cpp)->valid) | |
671 | return(NULL); | |
672 | else | |
673 | return(*cpp); | |
674 | } | |
675 | ||
676 | int ssl3_put_cipher_by_char(c,p) | |
677 | SSL_CIPHER *c; | |
678 | unsigned char *p; | |
679 | { | |
680 | long l; | |
681 | ||
682 | if (p != NULL) | |
683 | { | |
684 | l=c->id; | |
685 | if ((l & 0xff000000) != 0x03000000) return(0); | |
686 | p[0]=((unsigned char)(l>> 8L))&0xFF; | |
687 | p[1]=((unsigned char)(l ))&0xFF; | |
688 | } | |
689 | return(2); | |
690 | } | |
691 | ||
d02b48c6 RE |
692 | int ssl3_part_read(s,i) |
693 | SSL *s; | |
694 | int i; | |
695 | { | |
696 | s->rwstate=SSL_READING; | |
697 | ||
698 | if (i < 0) | |
699 | { | |
700 | return(i); | |
701 | } | |
702 | else | |
703 | { | |
704 | s->init_num+=i; | |
705 | return(0); | |
706 | } | |
707 | } | |
708 | ||
709 | SSL_CIPHER *ssl3_choose_cipher(s,have,pref) | |
710 | SSL *s; | |
711 | STACK *have,*pref; | |
712 | { | |
713 | SSL_CIPHER *c,*ret=NULL; | |
714 | int i,j,ok; | |
715 | CERT *cert; | |
716 | unsigned long alg,mask,emask; | |
717 | ||
718 | /* Lets see which ciphers we can supported */ | |
719 | if (s->cert != NULL) | |
720 | cert=s->cert; | |
721 | else | |
722 | cert=s->ctx->default_cert; | |
723 | ||
724 | ssl_set_cert_masks(cert); | |
725 | mask=cert->mask; | |
726 | emask=cert->export_mask; | |
727 | ||
728 | sk_set_cmp_func(pref,ssl_cipher_ptr_id_cmp); | |
729 | ||
730 | for (i=0; i<sk_num(have); i++) | |
731 | { | |
732 | c=(SSL_CIPHER *)sk_value(have,i); | |
733 | alg=c->algorithms&(SSL_MKEY_MASK|SSL_AUTH_MASK); | |
734 | if (alg & SSL_EXPORT) | |
735 | { | |
736 | ok=((alg & emask) == alg)?1:0; | |
737 | #ifdef CIPHER_DEBUG | |
738 | printf("%d:[%08lX:%08lX]%s\n",ok,alg,mask,c->name); | |
739 | #endif | |
740 | } | |
741 | else | |
742 | { | |
743 | ok=((alg & mask) == alg)?1:0; | |
744 | #ifdef CIPHER_DEBUG | |
745 | printf("%d:[%08lX:%08lX]%s\n",ok,alg,mask,c->name); | |
746 | #endif | |
747 | } | |
748 | ||
749 | if (!ok) continue; | |
750 | ||
751 | j=sk_find(pref,(char *)c); | |
752 | if (j >= 0) | |
753 | { | |
754 | ret=(SSL_CIPHER *)sk_value(pref,j); | |
755 | break; | |
756 | } | |
757 | } | |
758 | return(ret); | |
759 | } | |
760 | ||
761 | int ssl3_get_req_cert_type(s,p) | |
762 | SSL *s; | |
763 | unsigned char *p; | |
764 | { | |
765 | int ret=0; | |
766 | unsigned long alg; | |
767 | ||
768 | alg=s->s3->tmp.new_cipher->algorithms; | |
769 | ||
770 | #ifndef NO_DH | |
771 | if (alg & (SSL_kDHr|SSL_kEDH)) | |
772 | { | |
dfeab068 | 773 | # ifndef NO_RSA |
d02b48c6 | 774 | p[ret++]=SSL3_CT_RSA_FIXED_DH; |
dfeab068 RE |
775 | # endif |
776 | # ifndef NO_DSA | |
d02b48c6 | 777 | p[ret++]=SSL3_CT_DSS_FIXED_DH; |
dfeab068 | 778 | # endif |
d02b48c6 | 779 | } |
58964a49 RE |
780 | if ((s->version == SSL3_VERSION) && |
781 | (alg & (SSL_kEDH|SSL_kDHd|SSL_kDHr))) | |
d02b48c6 | 782 | { |
dfeab068 | 783 | # ifndef NO_RSA |
d02b48c6 | 784 | p[ret++]=SSL3_CT_RSA_EPHEMERAL_DH; |
dfeab068 RE |
785 | # endif |
786 | # ifndef NO_DSA | |
d02b48c6 | 787 | p[ret++]=SSL3_CT_DSS_EPHEMERAL_DH; |
dfeab068 | 788 | # endif |
d02b48c6 RE |
789 | } |
790 | #endif /* !NO_DH */ | |
791 | #ifndef NO_RSA | |
792 | p[ret++]=SSL3_CT_RSA_SIGN; | |
793 | #endif | |
dfeab068 | 794 | #ifndef NO_DSA |
58964a49 | 795 | p[ret++]=SSL3_CT_DSS_SIGN; |
dfeab068 | 796 | #endif |
d02b48c6 RE |
797 | return(ret); |
798 | } | |
799 | ||
800 | int ssl3_shutdown(s) | |
801 | SSL *s; | |
802 | { | |
803 | ||
804 | /* Don't do anything much if we have not done the handshake or | |
805 | * we don't want to send messages :-) */ | |
806 | if ((s->quiet_shutdown) || (s->state == SSL_ST_BEFORE)) | |
807 | { | |
808 | s->shutdown=(SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN); | |
809 | return(1); | |
810 | } | |
811 | ||
812 | if (!(s->shutdown & SSL_SENT_SHUTDOWN)) | |
813 | { | |
814 | s->shutdown|=SSL_SENT_SHUTDOWN; | |
815 | #if 1 | |
58964a49 | 816 | ssl3_send_alert(s,SSL3_AL_WARNING,SSL_AD_CLOSE_NOTIFY); |
d02b48c6 RE |
817 | #endif |
818 | /* our shutdown alert has been sent now, and if it still needs | |
819 | * to be written, s->s3->alert_dispatch will be true */ | |
820 | } | |
821 | else if (s->s3->alert_dispatch) | |
822 | { | |
823 | /* resend it if not sent */ | |
824 | #if 1 | |
825 | ssl3_dispatch_alert(s); | |
826 | #endif | |
827 | } | |
828 | else if (!(s->shutdown & SSL_RECEIVED_SHUTDOWN)) | |
829 | { | |
830 | /* If we are waiting for a close from our peer, we are closed */ | |
831 | ssl3_read_bytes(s,0,NULL,0); | |
832 | } | |
833 | ||
834 | if ((s->shutdown == (SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN)) && | |
835 | !s->s3->alert_dispatch) | |
836 | return(1); | |
837 | else | |
838 | return(0); | |
839 | } | |
840 | ||
841 | int ssl3_write(s,buf,len) | |
842 | SSL *s; | |
58964a49 | 843 | char *buf; |
d02b48c6 RE |
844 | int len; |
845 | { | |
846 | int ret,n; | |
847 | BIO *under; | |
848 | ||
849 | #if 0 | |
850 | if (s->shutdown & SSL_SEND_SHUTDOWN) | |
851 | { | |
852 | s->rwstate=SSL_NOTHING; | |
853 | return(0); | |
854 | } | |
855 | #endif | |
58964a49 RE |
856 | clear_sys_error(); |
857 | if (s->s3->renegotiate) ssl3_renegotiate_check(s); | |
d02b48c6 RE |
858 | |
859 | /* This is an experimental flag that sends the | |
860 | * last handshake message in the same packet as the first | |
861 | * use data - used to see if it helps the TCP protocol during | |
862 | * session-id reuse */ | |
863 | /* The second test is because the buffer may have been removed */ | |
864 | if ((s->s3->flags & SSL3_FLAGS_POP_BUFFER) && (s->wbio == s->bbio)) | |
865 | { | |
866 | /* First time through, we write into the buffer */ | |
867 | if (s->s3->delay_buf_pop_ret == 0) | |
868 | { | |
869 | ret=ssl3_write_bytes(s,SSL3_RT_APPLICATION_DATA, | |
870 | (char *)buf,len); | |
871 | if (ret <= 0) return(ret); | |
872 | ||
873 | s->s3->delay_buf_pop_ret=ret; | |
874 | } | |
875 | ||
876 | s->rwstate=SSL_WRITING; | |
877 | n=BIO_flush(s->wbio); | |
878 | if (n <= 0) return(n); | |
879 | s->rwstate=SSL_NOTHING; | |
880 | ||
881 | /* We have flushed the buffer */ | |
882 | under=BIO_pop(s->wbio); | |
883 | s->wbio=under; | |
884 | BIO_free(s->bbio); | |
885 | s->bbio=NULL; | |
886 | ret=s->s3->delay_buf_pop_ret; | |
887 | s->s3->delay_buf_pop_ret=0; | |
888 | ||
889 | s->s3->flags&= ~SSL3_FLAGS_POP_BUFFER; | |
890 | } | |
891 | else | |
892 | { | |
893 | ret=ssl3_write_bytes(s,SSL3_RT_APPLICATION_DATA, | |
894 | (char *)buf,len); | |
895 | if (ret <= 0) return(ret); | |
896 | } | |
58964a49 | 897 | |
d02b48c6 RE |
898 | return(ret); |
899 | } | |
900 | ||
901 | int ssl3_read(s,buf,len) | |
902 | SSL *s; | |
903 | char *buf; | |
904 | int len; | |
905 | { | |
58964a49 RE |
906 | int ret; |
907 | ||
908 | clear_sys_error(); | |
909 | if (s->s3->renegotiate) ssl3_renegotiate_check(s); | |
910 | s->s3->in_read_app_data=1; | |
911 | ret=ssl3_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len); | |
912 | if ((ret == -1) && (s->s3->in_read_app_data == 0)) | |
913 | { | |
914 | ERR_get_error(); /* clear the error */ | |
915 | s->s3->in_read_app_data=0; | |
916 | s->in_handshake++; | |
917 | ret=ssl3_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len); | |
918 | s->in_handshake--; | |
919 | } | |
920 | else | |
921 | s->s3->in_read_app_data=0; | |
922 | ||
923 | return(ret); | |
d02b48c6 RE |
924 | } |
925 | ||
926 | int ssl3_peek(s,buf,len) | |
927 | SSL *s; | |
928 | char *buf; | |
929 | int len; | |
930 | { | |
931 | SSL3_RECORD *rr; | |
932 | int n; | |
933 | ||
934 | rr= &(s->s3->rrec); | |
935 | if ((rr->length == 0) || (rr->type != SSL3_RT_APPLICATION_DATA)) | |
58964a49 RE |
936 | { |
937 | n=ssl3_read(s,buf,1); | |
938 | if (n <= 0) return(n); | |
939 | rr->length++; | |
940 | rr->off--; | |
941 | } | |
d02b48c6 RE |
942 | |
943 | if ((unsigned int)len > rr->length) | |
944 | n=rr->length; | |
945 | else | |
946 | n=len; | |
947 | memcpy(buf,&(rr->data[rr->off]),(unsigned int)n); | |
948 | return(n); | |
949 | } | |
950 | ||
951 | int ssl3_renegotiate(s) | |
952 | SSL *s; | |
953 | { | |
954 | if (s->handshake_func == NULL) | |
955 | return(1); | |
956 | ||
957 | if (s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) | |
958 | return(0); | |
959 | ||
58964a49 | 960 | s->s3->renegotiate=1; |
d02b48c6 RE |
961 | return(1); |
962 | } | |
963 | ||
58964a49 RE |
964 | int ssl3_renegotiate_check(s) |
965 | SSL *s; | |
966 | { | |
967 | int ret=0; | |
968 | ||
969 | if (s->s3->renegotiate) | |
970 | { | |
971 | if ( (s->s3->rbuf.left == 0) && | |
972 | (s->s3->wbuf.left == 0) && | |
973 | !SSL_in_init(s)) | |
974 | { | |
975 | /* | |
976 | if we are the server, and we have sent a 'RENEGOTIATE' message, we | |
977 | need to go to SSL_ST_ACCEPT.\1e | |
978 | */ | |
979 | /* SSL_ST_ACCEPT */ | |
980 | s->state=SSL_ST_RENEGOTIATE; | |
981 | s->s3->renegotiate=0; | |
982 | s->s3->num_renegotiations++; | |
983 | s->s3->total_renegotiations++; | |
984 | ret=1; | |
985 | } | |
986 | } | |
987 | return(ret); | |
988 | } | |
989 | ||
990 |