Implement Client TLS state machine
[openssl.git] / ssl / s3_both.c
1 /* ssl/s3_both.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  * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
60  *
61  * Redistribution and use in source and binary forms, with or without
62  * modification, are permitted provided that the following conditions
63  * are met:
64  *
65  * 1. Redistributions of source code must retain the above copyright
66  *    notice, this list of conditions and the following disclaimer.
67  *
68  * 2. Redistributions in binary form must reproduce the above copyright
69  *    notice, this list of conditions and the following disclaimer in
70  *    the documentation and/or other materials provided with the
71  *    distribution.
72  *
73  * 3. All advertising materials mentioning features or use of this
74  *    software must display the following acknowledgment:
75  *    "This product includes software developed by the OpenSSL Project
76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77  *
78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79  *    endorse or promote products derived from this software without
80  *    prior written permission. For written permission, please contact
81  *    openssl-core@openssl.org.
82  *
83  * 5. Products derived from this software may not be called "OpenSSL"
84  *    nor may "OpenSSL" appear in their names without prior written
85  *    permission of the OpenSSL Project.
86  *
87  * 6. Redistributions of any form whatsoever must retain the following
88  *    acknowledgment:
89  *    "This product includes software developed by the OpenSSL Project
90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91  *
92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103  * OF THE POSSIBILITY OF SUCH DAMAGE.
104  * ====================================================================
105  *
106  * This product includes cryptographic software written by Eric Young
107  * (eay@cryptsoft.com).  This product includes software written by Tim
108  * Hudson (tjh@cryptsoft.com).
109  *
110  */
111 /* ====================================================================
112  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113  * ECC cipher suite support in OpenSSL originally developed by
114  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
115  */
116
117 #include <limits.h>
118 #include <string.h>
119 #include <stdio.h>
120 #include "ssl_locl.h"
121 #include <openssl/buffer.h>
122 #include <openssl/rand.h>
123 #include <openssl/objects.h>
124 #include <openssl/evp.h>
125 #include <openssl/x509.h>
126
127 /*
128  * send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or
129  * SSL3_RT_CHANGE_CIPHER_SPEC)
130  */
131 int ssl3_do_write(SSL *s, int type)
132 {
133     int ret;
134
135     ret = ssl3_write_bytes(s, type, &s->init_buf->data[s->init_off],
136                            s->init_num);
137     if (ret < 0)
138         return (-1);
139     if (type == SSL3_RT_HANDSHAKE)
140         /*
141          * should not be done for 'Hello Request's, but in that case we'll
142          * ignore the result anyway
143          */
144         ssl3_finish_mac(s, (unsigned char *)&s->init_buf->data[s->init_off],
145                         ret);
146
147     if (ret == s->init_num) {
148         if (s->msg_callback)
149             s->msg_callback(1, s->version, type, s->init_buf->data,
150                             (size_t)(s->init_off + s->init_num), s,
151                             s->msg_callback_arg);
152         return (1);
153     }
154     s->init_off += ret;
155     s->init_num -= ret;
156     return (0);
157 }
158
159 int ssl3_send_finished(SSL *s, int a, int b, const char *sender, int slen)
160 {
161     if (s->state == a) {
162         if (tls_construct_finished(s, sender, slen) == 0) {
163             statem_set_error(s);
164             return -1;
165         }
166         s->state = b;
167     }
168
169     /* SSL3_ST_SEND_xxxxxx_HELLO_B */
170     return ssl_do_write(s);
171 }
172
173 int tls_construct_finished(SSL *s, const char *sender, int slen)
174 {
175     unsigned char *p;
176     int i;
177     unsigned long l;
178
179     p = ssl_handshake_start(s);
180
181     i = s->method->ssl3_enc->final_finish_mac(s,
182                                               sender, slen,
183                                               s->s3->tmp.finish_md);
184     if (i <= 0)
185         return 0;
186     s->s3->tmp.finish_md_len = i;
187     memcpy(p, s->s3->tmp.finish_md, i);
188     l = i;
189
190     /*
191      * Copy the finished so we can use it for renegotiation checks
192      */
193     if (s->type == SSL_ST_CONNECT) {
194         OPENSSL_assert(i <= EVP_MAX_MD_SIZE);
195         memcpy(s->s3->previous_client_finished, s->s3->tmp.finish_md, i);
196         s->s3->previous_client_finished_len = i;
197     } else {
198         OPENSSL_assert(i <= EVP_MAX_MD_SIZE);
199         memcpy(s->s3->previous_server_finished, s->s3->tmp.finish_md, i);
200         s->s3->previous_server_finished_len = i;
201     }
202
203     if (!ssl_set_handshake_header(s, SSL3_MT_FINISHED, l)) {
204         SSLerr(SSL_F_TLS_CONSTRUCT_FINISHED, ERR_R_INTERNAL_ERROR);
205         return 0;
206     }
207
208     return 1;
209 }
210
211 #ifndef OPENSSL_NO_NEXTPROTONEG
212 /*
213  * ssl3_take_mac calculates the Finished MAC for the handshakes messages seen
214  * to far.
215  */
216 static void ssl3_take_mac(SSL *s)
217 {
218     const char *sender;
219     int slen;
220     /*
221      * If no new cipher setup return immediately: other functions will set
222      * the appropriate error.
223      */
224     if (s->s3->tmp.new_cipher == NULL)
225         return;
226     if (s->state & SSL_ST_CONNECT) {
227         sender = s->method->ssl3_enc->server_finished_label;
228         slen = s->method->ssl3_enc->server_finished_label_len;
229     } else {
230         sender = s->method->ssl3_enc->client_finished_label;
231         slen = s->method->ssl3_enc->client_finished_label_len;
232     }
233
234     s->s3->tmp.peer_finish_md_len = s->method->ssl3_enc->final_finish_mac(s,
235                                                                           sender,
236                                                                           slen,
237                                                                           s->s3->tmp.peer_finish_md);
238 }
239 #endif
240
241 int ssl3_get_change_cipher_spec(SSL *s, int a, int b)
242 {
243     int ok;
244     long n;
245
246     n = s->method->ssl_get_message(s, a, b, SSL3_MT_CHANGE_CIPHER_SPEC, 1, &ok);
247
248     if (!ok)
249         return ((int)n);
250
251     if (tls_process_change_cipher_spec(s, n) == 0) {
252         statem_set_error(s);
253         return -1;
254     }
255
256     return 1;
257 }
258
259 enum MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, long n)
260 {
261     int al;
262
263     /*
264      * 'Change Cipher Spec' is just a single byte, which should already have
265      * been consumed by ssl_get_message() so there should be no bytes left,
266      * unless we're using DTLS1_BAD_VER, which has an extra 2 bytes
267      */
268     if (SSL_IS_DTLS(s)) {
269         if ((s->version == DTLS1_BAD_VER && n != DTLS1_CCS_HEADER_LENGTH + 1)
270                     || (s->version != DTLS1_BAD_VER
271                         && n != DTLS1_CCS_HEADER_LENGTH - 1)) {
272                 al = SSL_AD_ILLEGAL_PARAMETER;
273                 SSLerr(SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC,
274                        SSL_R_BAD_CHANGE_CIPHER_SPEC);
275                 goto f_err;
276         }
277     } else {
278         if (n != 0) {
279             al = SSL_AD_ILLEGAL_PARAMETER;
280             SSLerr(SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC,
281                    SSL_R_BAD_CHANGE_CIPHER_SPEC);
282             goto f_err;
283         }
284     }
285
286     /* Check we have a cipher to change to */
287     if (s->s3->tmp.new_cipher == NULL) {
288         al = SSL_AD_UNEXPECTED_MESSAGE;
289         SSLerr(SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC, SSL_R_CCS_RECEIVED_EARLY);
290         goto f_err;
291     }
292
293     s->s3->change_cipher_spec = 1;
294     if (!ssl3_do_change_cipher_spec(s)) {
295         al = SSL_AD_INTERNAL_ERROR;
296         SSLerr(SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC, ERR_R_INTERNAL_ERROR);
297         goto f_err;
298     }
299
300     if (SSL_IS_DTLS(s)) {
301         dtls1_reset_seq_numbers(s, SSL3_CC_READ);
302
303         if (s->version == DTLS1_BAD_VER)
304             s->d1->handshake_read_seq++;
305
306 #ifndef OPENSSL_NO_SCTP
307         /*
308          * Remember that a CCS has been received, so that an old key of
309          * SCTP-Auth can be deleted when a CCS is sent. Will be ignored if no
310          * SCTP is used
311          */
312         BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL);
313 #endif
314     }
315
316     return MSG_PROCESS_CONTINUE_READING;
317  f_err:
318     ssl3_send_alert(s, SSL3_AL_FATAL, al);
319     statem_set_error(s);
320     return MSG_PROCESS_ERROR;
321 }
322
323
324 int ssl3_get_finished(SSL *s, int a, int b)
325 {
326     int ok;
327     long n;
328
329 #ifdef OPENSSL_NO_NEXTPROTONEG
330     /*
331      * the mac has already been generated when we received the change cipher
332      * spec message and is in s->s3->tmp.peer_finish_md
333      */
334 #endif
335
336     /* 64 argument should actually be 36+4 :-) */
337     n = s->method->ssl_get_message(s, a, b, SSL3_MT_FINISHED, 64, &ok);
338
339     if (!ok)
340         return ((int)n);
341
342     return tls_process_finished(s, (unsigned long)n);
343 }
344
345 enum MSG_PROCESS_RETURN tls_process_finished(SSL *s, unsigned long n)
346 {
347     int al, i;
348     unsigned char *p;
349
350     /* If this occurs, we have missed a message */
351     if (!s->s3->change_cipher_spec) {
352         al = SSL_AD_UNEXPECTED_MESSAGE;
353         SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_GOT_A_FIN_BEFORE_A_CCS);
354         goto f_err;
355     }
356     s->s3->change_cipher_spec = 0;
357
358     p = (unsigned char *)s->init_msg;
359     i = s->s3->tmp.peer_finish_md_len;
360
361     if (i < 0 || (unsigned long)i != n) {
362         al = SSL_AD_DECODE_ERROR;
363         SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_BAD_DIGEST_LENGTH);
364         goto f_err;
365     }
366
367     if (CRYPTO_memcmp(p, s->s3->tmp.peer_finish_md, i) != 0) {
368         al = SSL_AD_DECRYPT_ERROR;
369         SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_DIGEST_CHECK_FAILED);
370         goto f_err;
371     }
372
373     /*
374      * Copy the finished so we can use it for renegotiation checks
375      */
376     if (s->type == SSL_ST_ACCEPT) {
377         OPENSSL_assert(i <= EVP_MAX_MD_SIZE);
378         memcpy(s->s3->previous_client_finished, s->s3->tmp.peer_finish_md, i);
379         s->s3->previous_client_finished_len = i;
380     } else {
381         OPENSSL_assert(i <= EVP_MAX_MD_SIZE);
382         memcpy(s->s3->previous_server_finished, s->s3->tmp.peer_finish_md, i);
383         s->s3->previous_server_finished_len = i;
384     }
385
386     return MSG_PROCESS_CONTINUE_PROCESSING;
387  f_err:
388     ssl3_send_alert(s, SSL3_AL_FATAL, al);
389     statem_set_error(s);
390     return MSG_PROCESS_ERROR;
391 }
392
393 /*-
394  * for these 2 messages, we need to
395  * ssl->enc_read_ctx                    re-init
396  * ssl->rlayer.read_sequence            zero
397  * ssl->s3->read_mac_secret             re-init
398  * ssl->session->read_sym_enc           assign
399  * ssl->session->read_compression       assign
400  * ssl->session->read_hash              assign
401  */
402 int ssl3_send_change_cipher_spec(SSL *s, int a, int b)
403 {
404     if (s->state == a) {
405         if(tls_construct_change_cipher_spec(s) == 0) {
406             statem_set_error(s);
407             return 0;
408         }
409
410         s->state = b;
411     }
412
413     /* SSL3_ST_CW_CHANGE_B */
414     return (ssl3_do_write(s, SSL3_RT_CHANGE_CIPHER_SPEC));
415 }
416
417 int tls_construct_change_cipher_spec(SSL *s)
418 {
419     unsigned char *p;
420
421     p = (unsigned char *)s->init_buf->data;
422     *p = SSL3_MT_CCS;
423     s->init_num = 1;
424     s->init_off = 0;
425
426     return 1;
427 }
428
429 unsigned long ssl3_output_cert_chain(SSL *s, CERT_PKEY *cpk)
430 {
431     unsigned char *p;
432     unsigned long l = 3 + SSL_HM_HEADER_LENGTH(s);
433
434     if (!ssl_add_cert_chain(s, cpk, &l))
435         return 0;
436
437     l -= 3 + SSL_HM_HEADER_LENGTH(s);
438     p = ssl_handshake_start(s);
439     l2n3(l, p);
440     l += 3;
441
442     if (!ssl_set_handshake_header(s, SSL3_MT_CERTIFICATE, l)) {
443         SSLerr(SSL_F_SSL3_OUTPUT_CERT_CHAIN, ERR_R_INTERNAL_ERROR);
444         return 0;
445     }
446     return l + SSL_HM_HEADER_LENGTH(s);
447 }
448
449 enum WORK_STATE tls_finish_handshake(SSL *s, enum WORK_STATE wst)
450 {
451     void (*cb) (const SSL *ssl, int type, int val) = NULL;
452
453 #ifndef OPENSSL_NO_SCTP
454     if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s))) {
455         enum WORK_STATE ret;
456         ret = dtls_wait_for_dry(s);
457         if (ret != WORK_FINISHED_CONTINUE)
458             return ret;
459     }
460 #endif
461
462     /* clean a few things up */
463     ssl3_cleanup_key_block(s);
464     BUF_MEM_free(s->init_buf);
465     s->init_buf = NULL;
466
467     ssl_free_wbio_buffer(s);
468
469     s->init_num = 0;
470
471     if (!s->server || s->renegotiate == 2) {
472         /* skipped if we just sent a HelloRequest */
473         s->renegotiate = 0;
474         s->new_session = 0;
475
476         if (s->server) {
477             s->renegotiate = 0;
478             s->new_session = 0;
479
480             ssl_update_cache(s, SSL_SESS_CACHE_SERVER);
481
482             s->ctx->stats.sess_accept_good++;
483             s->handshake_func = ssl3_accept;
484         } else {
485             ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
486             if (s->hit)
487                 s->ctx->stats.sess_hit++;
488
489             s->handshake_func = ssl3_connect;
490             s->ctx->stats.sess_connect_good++;
491         }
492
493         if (s->info_callback != NULL)
494             cb = s->info_callback;
495         else if (s->ctx->info_callback != NULL)
496             cb = s->ctx->info_callback;
497
498         if (cb != NULL)
499             cb(s, SSL_CB_HANDSHAKE_DONE, 1);
500
501         if (SSL_IS_DTLS(s)) {
502             /* done with handshaking */
503             s->d1->handshake_read_seq = 0;
504             s->d1->handshake_write_seq = 0;
505             s->d1->next_handshake_write_seq = 0;
506         }
507     }
508
509     return WORK_FINISHED_STOP;
510 }
511
512
513 /*
514  * Obtain handshake message of message type 'mt' (any if mt == -1), maximum
515  * acceptable body length 'max'. The first four bytes (msg_type and length)
516  * are read in state 'st1', the body is read in state 'stn'.
517  */
518 long ssl3_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok)
519 {
520     unsigned char *p;
521     long n;
522     int al, mtin;
523
524     if (s->s3->tmp.reuse_message) {
525         s->s3->tmp.reuse_message = 0;
526         if ((mt >= 0) && (s->s3->tmp.message_type != mt)) {
527             al = SSL_AD_UNEXPECTED_MESSAGE;
528             SSLerr(SSL_F_SSL3_GET_MESSAGE, SSL_R_UNEXPECTED_MESSAGE);
529             goto f_err;
530         }
531         *ok = 1;
532         s->state = stn;
533         s->init_msg = s->init_buf->data + SSL3_HM_HEADER_LENGTH;
534         s->init_num = (int)s->s3->tmp.message_size;
535         return s->init_num;
536     }
537
538     p = (unsigned char *)s->init_buf->data;
539
540     if (s->state == st1) {
541         if (tls_get_message_header(s, &mtin) == 0) {
542             /* Could be NBIO */
543             *ok = 0;
544             return -1;
545         }
546         s->state = stn;
547         if (s->init_num == 0
548                 && mtin == SSL3_MT_CHANGE_CIPHER_SPEC
549                 && (mt < 0 || mt == SSL3_MT_CHANGE_CIPHER_SPEC)) {
550             if (*p != SSL3_MT_CCS) {
551                 al = SSL_AD_UNEXPECTED_MESSAGE;
552                 SSLerr(SSL_F_SSL3_GET_MESSAGE,
553                        SSL_R_UNEXPECTED_MESSAGE);
554                 goto f_err;
555             }
556             s->init_msg = p + 1;
557             s->s3->tmp.message_type = SSL3_MT_CHANGE_CIPHER_SPEC;
558             s->s3->tmp.message_size = s->init_num;
559             *ok = 1;
560             if (s->msg_callback)
561                 s->msg_callback(0, s->version,
562                                 SSL3_RT_CHANGE_CIPHER_SPEC, p, 1, s,
563                                 s->msg_callback_arg);
564             return s->init_num;
565         }
566         if (s->s3->tmp.message_size > (unsigned long)max) {
567             al = SSL_AD_ILLEGAL_PARAMETER;
568             SSLerr(SSL_F_SSL3_GET_MESSAGE, SSL_R_EXCESSIVE_MESSAGE_SIZE);
569             goto f_err;
570         }
571         if ((mt >= 0) && (mtin != mt)) {
572             al = SSL_AD_UNEXPECTED_MESSAGE;
573             SSLerr(SSL_F_SSL3_GET_MESSAGE, SSL_R_UNEXPECTED_MESSAGE);
574             goto f_err;
575         }
576     }
577
578     /* next state (stn) */
579     if (tls_get_message_body(s, (unsigned long *)&n) == 0) {
580         *ok = 0;
581         return n;
582     }
583
584     *ok = 1;
585     return n;
586  f_err:
587     ssl3_send_alert(s, SSL3_AL_FATAL, al);
588     statem_set_error(s);
589     *ok = 0;
590     return 0;
591 }
592
593 int tls_get_message_header(SSL *s, int *mt)
594 {
595     /* s->init_num < SSL3_HM_HEADER_LENGTH */
596     int skip_message, i, recvd_type, al;
597     unsigned char *p;
598     unsigned long l;
599
600     p = (unsigned char *)s->init_buf->data;
601
602     do {
603         while (s->init_num < SSL3_HM_HEADER_LENGTH) {
604             i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, &recvd_type,
605                 &p[s->init_num], SSL3_HM_HEADER_LENGTH - s->init_num, 0);
606             if (i <= 0) {
607                 s->rwstate = SSL_READING;
608                 return 0;
609             }
610             if (recvd_type == SSL3_RT_CHANGE_CIPHER_SPEC) {
611                 s->s3->tmp.message_type = *mt = SSL3_MT_CHANGE_CIPHER_SPEC;
612                 s->init_num = i - 1;
613                 s->s3->tmp.message_size = i;
614                 return 1;
615             } else if (recvd_type != SSL3_RT_HANDSHAKE) {
616                 al = SSL_AD_UNEXPECTED_MESSAGE;
617                 SSLerr(SSL_F_TLS_GET_MESSAGE_HEADER, SSL_R_CCS_RECEIVED_EARLY);
618                 goto f_err;
619             }
620             s->init_num += i;
621         }
622
623         skip_message = 0;
624         if (!s->server)
625             if (p[0] == SSL3_MT_HELLO_REQUEST)
626                 /*
627                  * The server may always send 'Hello Request' messages --
628                  * we are doing a handshake anyway now, so ignore them if
629                  * their format is correct. Does not count for 'Finished'
630                  * MAC.
631                  */
632                 if (p[1] == 0 && p[2] == 0 && p[3] == 0) {
633                     s->init_num = 0;
634                     skip_message = 1;
635
636                     if (s->msg_callback)
637                         s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
638                                         p, SSL3_HM_HEADER_LENGTH, s,
639                                         s->msg_callback_arg);
640                 }
641     } while (skip_message);
642     /* s->init_num == SSL3_HM_HEADER_LENGTH */
643
644     *mt = *p;
645     s->s3->tmp.message_type = *(p++);
646
647     if(RECORD_LAYER_is_sslv2_record(&s->rlayer)) {
648         /*
649          * Only happens with SSLv3+ in an SSLv2 backward compatible
650          * ClientHello
651          */
652          /*
653           * Total message size is the remaining record bytes to read
654           * plus the SSL3_HM_HEADER_LENGTH bytes that we already read
655           */
656         l = RECORD_LAYER_get_rrec_length(&s->rlayer)
657             + SSL3_HM_HEADER_LENGTH;
658         if (l && !BUF_MEM_grow_clean(s->init_buf, (int)l)) {
659             SSLerr(SSL_F_TLS_GET_MESSAGE_HEADER, ERR_R_BUF_LIB);
660             goto err;
661         }
662         s->s3->tmp.message_size = l;
663
664         s->init_msg = s->init_buf->data;
665         s->init_num = SSL3_HM_HEADER_LENGTH;
666     } else {
667         n2l3(p, l);
668         /* BUF_MEM_grow takes an 'int' parameter */
669         if (l > (INT_MAX - SSL3_HM_HEADER_LENGTH)) {
670             al = SSL_AD_ILLEGAL_PARAMETER;
671             SSLerr(SSL_F_TLS_GET_MESSAGE_HEADER, SSL_R_EXCESSIVE_MESSAGE_SIZE);
672             goto f_err;
673         }
674         if (l && !BUF_MEM_grow_clean(s->init_buf,
675                                     (int)l + SSL3_HM_HEADER_LENGTH)) {
676             SSLerr(SSL_F_TLS_GET_MESSAGE_HEADER, ERR_R_BUF_LIB);
677             goto err;
678         }
679         s->s3->tmp.message_size = l;
680
681         s->init_msg = s->init_buf->data + SSL3_HM_HEADER_LENGTH;
682         s->init_num = 0;
683     }
684
685     return 1;
686  f_err:
687     ssl3_send_alert(s, SSL3_AL_FATAL, al);
688  err:
689     return 0;
690 }
691
692 int tls_get_message_body(SSL *s, unsigned long *len)
693 {
694     long n;
695     unsigned char *p;
696     int i;
697
698     if (s->s3->tmp.message_type == SSL3_MT_CHANGE_CIPHER_SPEC) {
699         /* We've already read everything in */
700         *len = (unsigned long)s->init_num;
701         return 1;
702     }
703
704     p = s->init_msg;
705     n = s->s3->tmp.message_size - s->init_num;
706     while (n > 0) {
707         i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, NULL,
708                                       &p[s->init_num], n, 0);
709         if (i <= 0) {
710             s->rwstate = SSL_READING;
711             *len = 0;
712             return 0;
713         }
714         s->init_num += i;
715         n -= i;
716     }
717
718 #ifndef OPENSSL_NO_NEXTPROTONEG
719     /*
720      * If receiving Finished, record MAC of prior handshake messages for
721      * Finished verification.
722      */
723     if (*s->init_buf->data == SSL3_MT_FINISHED)
724         ssl3_take_mac(s);
725 #endif
726
727     /* Feed this message into MAC computation. */
728     if(RECORD_LAYER_is_sslv2_record(&s->rlayer)) {
729         ssl3_finish_mac(s, (unsigned char *)s->init_buf->data, s->init_num);
730         if (s->msg_callback)
731             s->msg_callback(0, SSL2_VERSION, 0,  s->init_buf->data,
732                             (size_t)s->init_num, s, s->msg_callback_arg);
733     } else {
734         ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
735             s->init_num + SSL3_HM_HEADER_LENGTH);
736         if (s->msg_callback)
737             s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data,
738                             (size_t)s->init_num + SSL3_HM_HEADER_LENGTH, s,
739                             s->msg_callback_arg);
740     }
741
742     /*
743      * init_num should never be negative...should probably be declared
744      * unsigned
745      */
746     if (s->init_num < 0) {
747         SSLerr(SSL_F_TLS_GET_MESSAGE_BODY, ERR_R_INTERNAL_ERROR);
748         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
749         *len = 0;
750         return 0;
751     }
752     *len = (unsigned long)s->init_num;
753     return 1;
754 }
755
756 int ssl_cert_type(X509 *x, EVP_PKEY *pkey)
757 {
758     EVP_PKEY *pk;
759     int ret = -1, i;
760
761     if (pkey == NULL)
762         pk = X509_get_pubkey(x);
763     else
764         pk = pkey;
765     if (pk == NULL)
766         goto err;
767
768     i = pk->type;
769     if (i == EVP_PKEY_RSA) {
770         ret = SSL_PKEY_RSA_ENC;
771     } else if (i == EVP_PKEY_DSA) {
772         ret = SSL_PKEY_DSA_SIGN;
773     }
774 #ifndef OPENSSL_NO_EC
775     else if (i == EVP_PKEY_EC) {
776         ret = SSL_PKEY_ECC;
777     }
778 #endif
779     else if (i == NID_id_GostR3410_2001) {
780         ret = SSL_PKEY_GOST01;
781     } else if (x && (i == EVP_PKEY_DH || i == EVP_PKEY_DHX)) {
782         /*
783          * For DH two cases: DH certificate signed with RSA and DH
784          * certificate signed with DSA.
785          */
786         i = X509_certificate_type(x, pk);
787         if (i & EVP_PKS_RSA)
788             ret = SSL_PKEY_DH_RSA;
789         else if (i & EVP_PKS_DSA)
790             ret = SSL_PKEY_DH_DSA;
791     }
792
793  err:
794     if (!pkey)
795         EVP_PKEY_free(pk);
796     return (ret);
797 }
798
799 int ssl_verify_alarm_type(long type)
800 {
801     int al;
802
803     switch (type) {
804     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
805     case X509_V_ERR_UNABLE_TO_GET_CRL:
806     case X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER:
807         al = SSL_AD_UNKNOWN_CA;
808         break;
809     case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
810     case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
811     case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
812     case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
813     case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
814     case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
815     case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
816     case X509_V_ERR_CERT_NOT_YET_VALID:
817     case X509_V_ERR_CRL_NOT_YET_VALID:
818     case X509_V_ERR_CERT_UNTRUSTED:
819     case X509_V_ERR_CERT_REJECTED:
820         al = SSL_AD_BAD_CERTIFICATE;
821         break;
822     case X509_V_ERR_CERT_SIGNATURE_FAILURE:
823     case X509_V_ERR_CRL_SIGNATURE_FAILURE:
824         al = SSL_AD_DECRYPT_ERROR;
825         break;
826     case X509_V_ERR_CERT_HAS_EXPIRED:
827     case X509_V_ERR_CRL_HAS_EXPIRED:
828         al = SSL_AD_CERTIFICATE_EXPIRED;
829         break;
830     case X509_V_ERR_CERT_REVOKED:
831         al = SSL_AD_CERTIFICATE_REVOKED;
832         break;
833     case X509_V_ERR_OUT_OF_MEM:
834         al = SSL_AD_INTERNAL_ERROR;
835         break;
836     case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
837     case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
838     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
839     case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
840     case X509_V_ERR_CERT_CHAIN_TOO_LONG:
841     case X509_V_ERR_PATH_LENGTH_EXCEEDED:
842     case X509_V_ERR_INVALID_CA:
843         al = SSL_AD_UNKNOWN_CA;
844         break;
845     case X509_V_ERR_APPLICATION_VERIFICATION:
846         al = SSL_AD_HANDSHAKE_FAILURE;
847         break;
848     case X509_V_ERR_INVALID_PURPOSE:
849         al = SSL_AD_UNSUPPORTED_CERTIFICATE;
850         break;
851     default:
852         al = SSL_AD_CERTIFICATE_UNKNOWN;
853         break;
854     }
855     return (al);
856 }
857
858 int ssl_allow_compression(SSL *s)
859 {
860     if (s->options & SSL_OP_NO_COMPRESSION)
861         return 0;
862     return ssl_security(s, SSL_SECOP_COMPRESSION, 0, 0, NULL);
863 }