New functions SSL[_CTX]_set_msg_callback().
[openssl.git] / ssl / s2_lib.c
1 /* ssl/s2_lib.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
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 "ssl_locl.h"
60 #ifndef OPENSSL_NO_SSL2
61 #include <stdio.h>
62 #include <openssl/rsa.h>
63 #include <openssl/objects.h>
64 #include <openssl/evp.h>
65 #include <openssl/md5.h>
66
67 static long ssl2_default_timeout(void );
68 const char *ssl2_version_str="SSLv2" OPENSSL_VERSION_PTEXT;
69
70 #define SSL2_NUM_CIPHERS (sizeof(ssl2_ciphers)/sizeof(SSL_CIPHER))
71
72 OPENSSL_GLOBAL SSL_CIPHER ssl2_ciphers[]={
73 /* NULL_WITH_MD5 v3 */
74 #if 0
75         {
76         1,
77         SSL2_TXT_NULL_WITH_MD5,
78         SSL2_CK_NULL_WITH_MD5,
79         SSL_kRSA|SSL_aRSA|SSL_eNULL|SSL_MD5|SSL_SSLV2,
80         SSL_EXPORT|SSL_EXP40,
81         0,
82         0,
83         SSL_ALL_CIPHERS,
84         SSL_ALL_STRENGTHS,
85         },
86 #endif
87 /* RC4_128_EXPORT40_WITH_MD5 */
88         {
89         1,
90         SSL2_TXT_RC4_128_EXPORT40_WITH_MD5,
91         SSL2_CK_RC4_128_EXPORT40_WITH_MD5,
92         SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_MD5|SSL_SSLV2,
93         SSL_EXPORT|SSL_EXP40,
94         SSL2_CF_5_BYTE_ENC,
95         40,
96         128,
97         SSL_ALL_CIPHERS,
98         SSL_ALL_STRENGTHS,
99         },
100 /* RC4_128_WITH_MD5 */
101         {
102         1,
103         SSL2_TXT_RC4_128_WITH_MD5,
104         SSL2_CK_RC4_128_WITH_MD5,
105         SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_MD5|SSL_SSLV2,
106         SSL_NOT_EXP|SSL_MEDIUM,
107         0,
108         128,
109         128,
110         SSL_ALL_CIPHERS,
111         SSL_ALL_STRENGTHS,
112         },
113 /* RC2_128_CBC_EXPORT40_WITH_MD5 */
114         {
115         1,
116         SSL2_TXT_RC2_128_CBC_EXPORT40_WITH_MD5,
117         SSL2_CK_RC2_128_CBC_EXPORT40_WITH_MD5,
118         SSL_kRSA|SSL_aRSA|SSL_RC2|SSL_MD5|SSL_SSLV2,
119         SSL_EXPORT|SSL_EXP40,
120         SSL2_CF_5_BYTE_ENC,
121         40,
122         128,
123         SSL_ALL_CIPHERS,
124         SSL_ALL_STRENGTHS,
125         },
126 /* RC2_128_CBC_WITH_MD5 */
127         {
128         1,
129         SSL2_TXT_RC2_128_CBC_WITH_MD5,
130         SSL2_CK_RC2_128_CBC_WITH_MD5,
131         SSL_kRSA|SSL_aRSA|SSL_RC2|SSL_MD5|SSL_SSLV2,
132         SSL_NOT_EXP|SSL_MEDIUM,
133         0,
134         128,
135         128,
136         SSL_ALL_CIPHERS,
137         SSL_ALL_STRENGTHS,
138         },
139 /* IDEA_128_CBC_WITH_MD5 */
140         {
141         1,
142         SSL2_TXT_IDEA_128_CBC_WITH_MD5,
143         SSL2_CK_IDEA_128_CBC_WITH_MD5,
144         SSL_kRSA|SSL_aRSA|SSL_IDEA|SSL_MD5|SSL_SSLV2,
145         SSL_NOT_EXP|SSL_MEDIUM,
146         0,
147         128,
148         128,
149         SSL_ALL_CIPHERS,
150         SSL_ALL_STRENGTHS,
151         },
152 /* DES_64_CBC_WITH_MD5 */
153         {
154         1,
155         SSL2_TXT_DES_64_CBC_WITH_MD5,
156         SSL2_CK_DES_64_CBC_WITH_MD5,
157         SSL_kRSA|SSL_aRSA|SSL_DES|SSL_MD5|SSL_SSLV2,
158         SSL_NOT_EXP|SSL_LOW,
159         0,
160         56,
161         56,
162         SSL_ALL_CIPHERS,
163         SSL_ALL_STRENGTHS,
164         },
165 /* DES_192_EDE3_CBC_WITH_MD5 */
166         {
167         1,
168         SSL2_TXT_DES_192_EDE3_CBC_WITH_MD5,
169         SSL2_CK_DES_192_EDE3_CBC_WITH_MD5,
170         SSL_kRSA|SSL_aRSA|SSL_3DES|SSL_MD5|SSL_SSLV2,
171         SSL_NOT_EXP|SSL_HIGH,
172         0,
173         168,
174         168,
175         SSL_ALL_CIPHERS,
176         SSL_ALL_STRENGTHS,
177         },
178 /* RC4_64_WITH_MD5 */
179 #if 1
180         {
181         1,
182         SSL2_TXT_RC4_64_WITH_MD5,
183         SSL2_CK_RC4_64_WITH_MD5,
184         SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_MD5|SSL_SSLV2,
185         SSL_NOT_EXP|SSL_LOW,
186         SSL2_CF_8_BYTE_ENC,
187         64,
188         64,
189         SSL_ALL_CIPHERS,
190         SSL_ALL_STRENGTHS,
191         },
192 #endif
193 /* NULL SSLeay (testing) */
194 #if 0
195         {       
196         0,
197         SSL2_TXT_NULL,
198         SSL2_CK_NULL,
199         0,
200         0,
201         0,
202         0,
203         SSL_ALL_CIPHERS,
204         SSL_ALL_STRENGTHS,
205         },
206 #endif
207
208 /* end of list :-) */
209         };
210
211 static SSL_METHOD SSLv2_data= {
212         SSL2_VERSION,
213         ssl2_new,       /* local */
214         ssl2_clear,     /* local */
215         ssl2_free,      /* local */
216         ssl_undefined_function,
217         ssl_undefined_function,
218         ssl2_read,
219         ssl2_peek,
220         ssl2_write,
221         ssl2_shutdown,
222         ssl_ok, /* NULL - renegotiate */
223         ssl_ok, /* NULL - check renegotiate */
224         ssl2_ctrl,      /* local */
225         ssl2_ctx_ctrl,  /* local */
226         ssl2_get_cipher_by_char,
227         ssl2_put_cipher_by_char,
228         ssl2_pending,
229         ssl2_num_ciphers,
230         ssl2_get_cipher,
231         ssl_bad_method,
232         ssl2_default_timeout,
233         &ssl3_undef_enc_method,
234         ssl_undefined_function,
235         ssl2_callback_ctrl,     /* local */
236         ssl2_ctx_callback_ctrl, /* local */
237         };
238
239 static long ssl2_default_timeout(void)
240         {
241         return(300);
242         }
243
244 SSL_METHOD *sslv2_base_method(void)
245         {
246         return(&SSLv2_data);
247         }
248
249 int ssl2_num_ciphers(void)
250         {
251         return(SSL2_NUM_CIPHERS);
252         }
253
254 SSL_CIPHER *ssl2_get_cipher(unsigned int u)
255         {
256         if (u < SSL2_NUM_CIPHERS)
257                 return(&(ssl2_ciphers[SSL2_NUM_CIPHERS-1-u]));
258         else
259                 return(NULL);
260         }
261
262 int ssl2_pending(SSL *s)
263         {
264         return SSL_in_init(s) ? 0 : s->s2->ract_data_length;
265         }
266
267 int ssl2_new(SSL *s)
268         {
269         SSL2_STATE *s2;
270
271         if ((s2=OPENSSL_malloc(sizeof *s2)) == NULL) goto err;
272         memset(s2,0,sizeof *s2);
273
274 #if SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER + 3 > SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER + 2
275 #  error "assertion failed"
276 #endif
277
278         if ((s2->rbuf=OPENSSL_malloc(
279                 SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2)) == NULL) goto err;
280         /* wbuf needs one byte more because when using two-byte headers,
281          * we leave the first byte unused in do_ssl_write (s2_pkt.c) */
282         if ((s2->wbuf=OPENSSL_malloc(
283                 SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+3)) == NULL) goto err;
284         s->s2=s2;
285
286         ssl2_clear(s);
287         return(1);
288 err:
289         if (s2 != NULL)
290                 {
291                 if (s2->wbuf != NULL) OPENSSL_free(s2->wbuf);
292                 if (s2->rbuf != NULL) OPENSSL_free(s2->rbuf);
293                 OPENSSL_free(s2);
294                 }
295         return(0);
296         }
297
298 void ssl2_free(SSL *s)
299         {
300         SSL2_STATE *s2;
301
302         if(s == NULL)
303             return;
304
305         s2=s->s2;
306         if (s2->rbuf != NULL) OPENSSL_free(s2->rbuf);
307         if (s2->wbuf != NULL) OPENSSL_free(s2->wbuf);
308         memset(s2,0,sizeof *s2);
309         OPENSSL_free(s2);
310         s->s2=NULL;
311         }
312
313 void ssl2_clear(SSL *s)
314         {
315         SSL2_STATE *s2;
316         unsigned char *rbuf,*wbuf;
317
318         s2=s->s2;
319
320         rbuf=s2->rbuf;
321         wbuf=s2->wbuf;
322
323         memset(s2,0,sizeof *s2);
324
325         s2->rbuf=rbuf;
326         s2->wbuf=wbuf;
327         s2->clear_text=1;
328         s->packet=s2->rbuf;
329         s->version=SSL2_VERSION;
330         s->packet_length=0;
331         }
332
333 long ssl2_ctrl(SSL *s, int cmd, long larg, void *parg)
334         {
335         int ret=0;
336
337         switch(cmd)
338                 {
339         case SSL_CTRL_GET_SESSION_REUSED:
340                 ret=s->hit;
341                 break;
342         default:
343                 break;
344                 }
345         return(ret);
346         }
347
348 long ssl2_callback_ctrl(SSL *s, int cmd, void (*fp)())
349         {
350         return(0);
351         }
352
353 long ssl2_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
354         {
355         return(0);
356         }
357
358 long ssl2_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)())
359         {
360         return(0);
361         }
362
363 /* This function needs to check if the ciphers required are actually
364  * available */
365 SSL_CIPHER *ssl2_get_cipher_by_char(const unsigned char *p)
366         {
367         static int init=1;
368         static SSL_CIPHER *sorted[SSL2_NUM_CIPHERS];
369         SSL_CIPHER c,*cp= &c,**cpp;
370         unsigned long id;
371         int i;
372
373         if (init)
374                 {
375                 CRYPTO_w_lock(CRYPTO_LOCK_SSL);
376
377                 for (i=0; i<SSL2_NUM_CIPHERS; i++)
378                         sorted[i]= &(ssl2_ciphers[i]);
379
380                 qsort(  (char *)sorted,
381                         SSL2_NUM_CIPHERS,sizeof(SSL_CIPHER *),
382                         FP_ICC ssl_cipher_ptr_id_cmp);
383
384                 CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
385                 init=0;
386                 }
387
388         id=0x02000000L|((unsigned long)p[0]<<16L)|
389                 ((unsigned long)p[1]<<8L)|(unsigned long)p[2];
390         c.id=id;
391         cpp=(SSL_CIPHER **)OBJ_bsearch((char *)&cp,
392                 (char *)sorted,
393                 SSL2_NUM_CIPHERS,sizeof(SSL_CIPHER *),
394                 FP_ICC ssl_cipher_ptr_id_cmp);
395         if ((cpp == NULL) || !(*cpp)->valid)
396                 return(NULL);
397         else
398                 return(*cpp);
399         }
400
401 int ssl2_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
402         {
403         long l;
404
405         if (p != NULL)
406                 {
407                 l=c->id;
408                 if ((l & 0xff000000) != 0x02000000) return(0);
409                 p[0]=((unsigned char)(l>>16L))&0xFF;
410                 p[1]=((unsigned char)(l>> 8L))&0xFF;
411                 p[2]=((unsigned char)(l     ))&0xFF;
412                 }
413         return(3);
414         }
415
416 void ssl2_generate_key_material(SSL *s)
417         {
418         unsigned int i;
419         EVP_MD_CTX ctx;
420         unsigned char *km;
421         unsigned char c='0';
422
423 #ifdef CHARSET_EBCDIC
424         c = os_toascii['0']; /* Must be an ASCII '0', not EBCDIC '0',
425                                 see SSLv2 docu */
426 #endif
427         EVP_MD_CTX_init(&ctx);
428         km=s->s2->key_material;
429         for (i=0; i<s->s2->key_material_length; i+=MD5_DIGEST_LENGTH)
430                 {
431                 EVP_DigestInit_ex(&ctx,EVP_md5(), NULL);
432
433                 EVP_DigestUpdate(&ctx,s->session->master_key,s->session->master_key_length);
434                 EVP_DigestUpdate(&ctx,&c,1);
435                 c++;
436                 EVP_DigestUpdate(&ctx,s->s2->challenge,s->s2->challenge_length);
437                 EVP_DigestUpdate(&ctx,s->s2->conn_id,s->s2->conn_id_length);
438                 EVP_DigestFinal_ex(&ctx,km,NULL);
439                 km+=MD5_DIGEST_LENGTH;
440                 }
441         EVP_MD_CTX_cleanup(&ctx);
442         }
443
444 void ssl2_return_error(SSL *s, int err)
445         {
446         if (!s->error)
447                 {
448                 s->error=3;
449                 s->error_code=err;
450
451                 ssl2_write_error(s);
452                 }
453         }
454
455
456 void ssl2_write_error(SSL *s)
457         {
458         unsigned char buf[3];
459         int i,error;
460
461         buf[0]=SSL2_MT_ERROR;
462         buf[1]=(s->error_code>>8)&0xff;
463         buf[2]=(s->error_code)&0xff;
464
465 /*      state=s->rwstate;*/
466         error=s->error;
467         s->error=0;
468         i=ssl2_write(s,&(buf[3-error]),error);
469 /*      if (i == error) s->rwstate=state; */
470
471         if (i < 0)
472                 s->error=error;
473         else if (i != s->error)
474                 s->error=error-i;
475         /* else
476                 s->error=0; */
477         }
478
479 int ssl2_shutdown(SSL *s)
480         {
481         s->shutdown=(SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
482         return(1);
483         }
484 #else /* !OPENSSL_NO_SSL2 */
485
486 # if PEDANTIC
487 static void *dummy=&dummy;
488 # endif
489
490 #endif