Disable compression for DTLS.
[openssl.git] / ssl / d1_both.c
index 89338e9..ee945cb 100644 (file)
@@ -227,14 +227,14 @@ int dtls1_do_write(SSL *s, int type)
        unsigned int len, frag_off, mac_size, blocksize;
 
        /* AHA!  Figure out the MTU, and stick to the right size */
-       if ( ! (SSL_get_options(s) & SSL_OP_NO_QUERY_MTU))
+       if (s->d1->mtu < dtls1_min_mtu() && !(SSL_get_options(s) & SSL_OP_NO_QUERY_MTU))
                {
                s->d1->mtu = 
                        BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
 
                /* I've seen the kernel return bogus numbers when it doesn't know
                 * (initial write), so just make sure we have a reasonable number */
-               if ( s->d1->mtu < dtls1_min_mtu())
+               if (s->d1->mtu < dtls1_min_mtu())
                        {
                        s->d1->mtu = 0;
                        s->d1->mtu = dtls1_guess_mtu(s->d1->mtu);
@@ -313,9 +313,10 @@ int dtls1_do_write(SSL *s, int type)
                                s->init_off -= DTLS1_HM_HEADER_LENGTH;
                                s->init_num += DTLS1_HM_HEADER_LENGTH;
 
-                               /* write atleast DTLS1_HM_HEADER_LENGTH bytes */
-                               if ( len <= DTLS1_HM_HEADER_LENGTH)  
-                                       len += DTLS1_HM_HEADER_LENGTH;
+                               if ( s->init_num > curr_mtu)
+                                       len = curr_mtu;
+                               else
+                                       len = s->init_num;
                                }
 
                        dtls1_fix_message_header(s, frag_off, 
@@ -895,63 +896,6 @@ f_err:
        return(-1);
        }
 
-int dtls1_send_finished(SSL *s, int a, int b, const char *sender, int slen)
-       {
-       unsigned char *p,*d;
-       int i;
-       unsigned long l;
-
-       if (s->state == a)
-               {
-               d=(unsigned char *)s->init_buf->data;
-               p= &(d[DTLS1_HM_HEADER_LENGTH]);
-
-               i=s->method->ssl3_enc->final_finish_mac(s,
-                       sender,slen,s->s3->tmp.finish_md);
-               s->s3->tmp.finish_md_len = i;
-               memcpy(p, s->s3->tmp.finish_md, i);
-               p+=i;
-               l=i;
-
-       /* Copy the finished so we can use it for
-        * renegotiation checks
-        */
-       if(s->type == SSL_ST_CONNECT)
-               {
-               OPENSSL_assert(i <= EVP_MAX_MD_SIZE);
-               memcpy(s->s3->previous_client_finished, 
-                      s->s3->tmp.finish_md, i);
-               s->s3->previous_client_finished_len=i;
-               }
-       else
-               {
-               OPENSSL_assert(i <= EVP_MAX_MD_SIZE);
-               memcpy(s->s3->previous_server_finished, 
-                      s->s3->tmp.finish_md, i);
-               s->s3->previous_server_finished_len=i;
-               }
-
-#ifdef OPENSSL_SYS_WIN16
-               /* MSVC 1.5 does not clear the top bytes of the word unless
-                * I do this.
-                */
-               l&=0xffff;
-#endif
-
-               d = dtls1_set_message_header(s, d, SSL3_MT_FINISHED, l, 0, l);
-               s->init_num=(int)l+DTLS1_HM_HEADER_LENGTH;
-               s->init_off=0;
-
-               /* buffer the message to handle re-xmits */
-               dtls1_buffer_message(s, 0);
-
-               s->state=b;
-               }
-
-       /* SSL3_ST_SEND_xxxxxx_HELLO_B */
-       return(dtls1_do_write(s,SSL3_RT_HANDSHAKE));
-       }
-
 /* for these 2 messages, we need to
  * ssl->enc_read_ctx                   re-init
  * ssl->s3->read_sequence              zero
@@ -992,83 +936,6 @@ int dtls1_send_change_cipher_spec(SSL *s, int a, int b)
        return(dtls1_do_write(s,SSL3_RT_CHANGE_CIPHER_SPEC));
        }
 
-static int dtls1_add_cert_to_buf(BUF_MEM *buf, unsigned long *l, X509 *x)
-       {
-       int n;
-       unsigned char *p;
-
-       n=i2d_X509(x,NULL);
-       if (!BUF_MEM_grow_clean(buf,(int)(n+(*l)+3)))
-               {
-               SSLerr(SSL_F_DTLS1_ADD_CERT_TO_BUF,ERR_R_BUF_LIB);
-               return 0;
-               }
-       p=(unsigned char *)&(buf->data[*l]);
-       l2n3(n,p);
-       i2d_X509(x,&p);
-       *l+=n+3;
-
-       return 1;
-       }
-unsigned long dtls1_output_cert_chain(SSL *s, X509 *x)
-       {
-       unsigned char *p;
-       int i;
-       unsigned long l= 3 + DTLS1_HM_HEADER_LENGTH;
-       BUF_MEM *buf;
-
-       /* TLSv1 sends a chain with nothing in it, instead of an alert */
-       buf=s->init_buf;
-       if (!BUF_MEM_grow_clean(buf,10))
-               {
-               SSLerr(SSL_F_DTLS1_OUTPUT_CERT_CHAIN,ERR_R_BUF_LIB);
-               return(0);
-               }
-       if (x != NULL)
-               {
-               X509_STORE_CTX xs_ctx;
-
-               if (!X509_STORE_CTX_init(&xs_ctx,s->ctx->cert_store,x,NULL))
-                       {
-                       SSLerr(SSL_F_DTLS1_OUTPUT_CERT_CHAIN,ERR_R_X509_LIB);
-                       return(0);
-                       }
-  
-               X509_verify_cert(&xs_ctx);
-               /* Don't leave errors in the queue */
-               ERR_clear_error();
-               for (i=0; i < sk_X509_num(xs_ctx.chain); i++)
-                       {
-                       x = sk_X509_value(xs_ctx.chain, i);
-
-                       if (!dtls1_add_cert_to_buf(buf, &l, x))
-                               {
-                               X509_STORE_CTX_cleanup(&xs_ctx);
-                               return 0;
-                               }
-                       }
-               X509_STORE_CTX_cleanup(&xs_ctx);
-               }
-       /* Thawte special :-) */
-       for (i=0; i<sk_X509_num(s->ctx->extra_certs); i++)
-               {
-               x=sk_X509_value(s->ctx->extra_certs,i);
-               if (!dtls1_add_cert_to_buf(buf, &l, x))
-                       return 0;
-               }
-
-       l-= (3 + DTLS1_HM_HEADER_LENGTH);
-
-       p=(unsigned char *)&(buf->data[DTLS1_HM_HEADER_LENGTH]);
-       l2n3(l,p);
-       l+=3;
-       p=(unsigned char *)&(buf->data[0]);
-       p = dtls1_set_message_header(s, p, SSL3_MT_CERTIFICATE, l, 0, l);
-
-       l+=DTLS1_HM_HEADER_LENGTH;
-       return(l);
-       }
-
 int dtls1_read_failed(SSL *s, int code)
        {
        if ( code > 0)
@@ -1084,7 +951,11 @@ int dtls1_read_failed(SSL *s, int code)
                return code;
                }
 
-       if ( ! SSL_in_init(s))  /* done, no need to send a retransmit */
+#ifndef OPENSSL_NO_HEARTBEATS
+       if (!SSL_in_init(s) && !s->tlsext_hb_pending)  /* done, no need to send a retransmit */
+#else
+       if (!SSL_in_init(s))  /* done, no need to send a retransmit */
+#endif
                {
                BIO_set_flags(SSL_get_rbio(s), BIO_FLAGS_READ);
                return code;
@@ -1438,3 +1309,150 @@ int dtls1_shutdown(SSL *s)
 #endif
        return ret;
        }
+
+#ifndef OPENSSL_NO_HEARTBEATS
+int
+dtls1_process_heartbeat(SSL *s)
+       {
+       unsigned char *p = &s->s3->rrec.data[0], *pl;
+       unsigned short hbtype;
+       unsigned int payload;
+       unsigned int padding = 16; /* Use minimum padding */
+
+       /* Read type and payload length first */
+       hbtype = *p++;
+       n2s(p, payload);
+       pl = p;
+
+       if (s->msg_callback)
+               s->msg_callback(0, s->version, TLS1_RT_HEARTBEAT,
+                       &s->s3->rrec.data[0], s->s3->rrec.length,
+                       s, s->msg_callback_arg);
+
+       if (hbtype == TLS1_HB_REQUEST)
+               {
+               unsigned char *buffer, *bp;
+               int r;
+
+               /* Allocate memory for the response, size is 1 byte
+                * message type, plus 2 bytes payload length, plus
+                * payload, plus padding
+                */
+               buffer = OPENSSL_malloc(1 + 2 + payload + padding);
+               bp = buffer;
+
+               /* Enter response type, length and copy payload */
+               *bp++ = TLS1_HB_RESPONSE;
+               s2n(payload, bp);
+               memcpy(bp, pl, payload);
+               bp += payload;
+               /* Random padding */
+               RAND_pseudo_bytes(bp, padding);
+
+               r = dtls1_write_bytes(s, TLS1_RT_HEARTBEAT, buffer, 3 + payload + padding);
+
+               if (r >= 0 && s->msg_callback)
+                       s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
+                               buffer, 3 + payload + padding,
+                               s, s->msg_callback_arg);
+
+               OPENSSL_free(buffer);
+
+               if (r < 0)
+                       return r;
+               }
+       else if (hbtype == TLS1_HB_RESPONSE)
+               {
+               unsigned int seq;
+
+               /* We only send sequence numbers (2 bytes unsigned int),
+                * and 16 random bytes, so we just try to read the
+                * sequence number */
+               n2s(pl, seq);
+
+               if (payload == 18 && seq == s->tlsext_hb_seq)
+                       {
+                       dtls1_stop_timer(s);
+                       s->tlsext_hb_seq++;
+                       s->tlsext_hb_pending = 0;
+                       }
+               }
+
+       return 0;
+       }
+
+int
+dtls1_heartbeat(SSL *s)
+       {
+       unsigned char *buf, *p;
+       int ret;
+       unsigned int payload = 18; /* Sequence number + random bytes */
+       unsigned int padding = 16; /* Use minimum padding */
+
+       /* Only send if peer supports and accepts HB requests... */
+       if (!(s->tlsext_heartbeat & SSL_TLSEXT_HB_ENABLED) ||
+           s->tlsext_heartbeat & SSL_TLSEXT_HB_DONT_SEND_REQUESTS)
+               {
+               SSLerr(SSL_F_DTLS1_HEARTBEAT,SSL_R_TLS_HEARTBEAT_PEER_DOESNT_ACCEPT);
+               return -1;
+               }
+
+       /* ...and there is none in flight yet... */
+       if (s->tlsext_hb_pending)
+               {
+               SSLerr(SSL_F_DTLS1_HEARTBEAT,SSL_R_TLS_HEARTBEAT_PENDING);
+               return -1;
+               }
+
+       /* ...and no handshake in progress. */
+       if (SSL_in_init(s) || s->in_handshake)
+               {
+               SSLerr(SSL_F_DTLS1_HEARTBEAT,SSL_R_UNEXPECTED_MESSAGE);
+               return -1;
+               }
+
+       /* Check if padding is too long, payload and padding
+        * must not exceed 2^14 - 3 = 16381 bytes in total.
+        */
+       OPENSSL_assert(payload + padding <= 16381);
+
+       /* Create HeartBeat message, we just use a sequence number
+        * as payload to distuingish different messages and add
+        * some random stuff.
+        *  - Message Type, 1 byte
+        *  - Payload Length, 2 bytes (unsigned int)
+        *  - Payload, the sequence number (2 bytes uint)
+        *  - Payload, random bytes (16 bytes uint)
+        *  - Padding
+        */
+       buf = OPENSSL_malloc(1 + 2 + payload + padding);
+       p = buf;
+       /* Message Type */
+       *p++ = TLS1_HB_REQUEST;
+       /* Payload length (18 bytes here) */
+       s2n(payload, p);
+       /* Sequence number */
+       s2n(s->tlsext_hb_seq, p);
+       /* 16 random bytes */
+       RAND_pseudo_bytes(p, 16);
+       p += 16;
+       /* Random padding */
+       RAND_pseudo_bytes(p, padding);
+
+       ret = dtls1_write_bytes(s, TLS1_RT_HEARTBEAT, buf, 3 + payload + padding);
+       if (ret >= 0)
+               {
+               if (s->msg_callback)
+                       s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
+                               buf, 3 + payload + padding,
+                               s, s->msg_callback_arg);
+
+               dtls1_start_timer(s);
+               s->tlsext_hb_pending = 1;
+               }
+
+       OPENSSL_free(buf);
+
+       return ret;
+       }
+#endif