← Back to branch summary

~webapps/unity-js-scopes/node.js

« back to all changes in this revision

Viewing changes to deps/openssl/openssl/ssl/d1_pkt.c

  • Committer: Marcus Tomlinson
  • Date: 2015-11-13 07:59:04 UTC
  • Revision ID: marcus.tomlinson@canonical.com-20151113075904-h0swczmoq1rvstfc
Node v4 (stable)

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/openssl/openssl/ssl/d1_pkt.c
 
1
/* ssl/d1_pkt.c */
 
2
/*
 
3
 * DTLS implementation written by Nagendra Modadugu
 
4
 * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
 
5
 */
 
6
/* ====================================================================
 
7
 * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
 
8
 *
 
9
 * Redistribution and use in source and binary forms, with or without
 
10
 * modification, are permitted provided that the following conditions
 
11
 * are met:
 
12
 *
 
13
 * 1. Redistributions of source code must retain the above copyright
 
14
 *    notice, this list of conditions and the following disclaimer.
 
15
 *
 
16
 * 2. Redistributions in binary form must reproduce the above copyright
 
17
 *    notice, this list of conditions and the following disclaimer in
 
18
 *    the documentation and/or other materials provided with the
 
19
 *    distribution.
 
20
 *
 
21
 * 3. All advertising materials mentioning features or use of this
 
22
 *    software must display the following acknowledgment:
 
23
 *    "This product includes software developed by the OpenSSL Project
 
24
 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
 
25
 *
 
26
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 
27
 *    endorse or promote products derived from this software without
 
28
 *    prior written permission. For written permission, please contact
 
29
 *    openssl-core@openssl.org.
 
30
 *
 
31
 * 5. Products derived from this software may not be called "OpenSSL"
 
32
 *    nor may "OpenSSL" appear in their names without prior written
 
33
 *    permission of the OpenSSL Project.
 
34
 *
 
35
 * 6. Redistributions of any form whatsoever must retain the following
 
36
 *    acknowledgment:
 
37
 *    "This product includes software developed by the OpenSSL Project
 
38
 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 
39
 *
 
40
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 
41
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
42
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
43
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 
44
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
45
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
46
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 
47
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
48
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 
49
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
50
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 
51
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 
52
 * ====================================================================
 
53
 *
 
54
 * This product includes cryptographic software written by Eric Young
 
55
 * (eay@cryptsoft.com).  This product includes software written by Tim
 
56
 * Hudson (tjh@cryptsoft.com).
 
57
 *
 
58
 */
 
59
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 
60
 * All rights reserved.
 
61
 *
 
62
 * This package is an SSL implementation written
 
63
 * by Eric Young (eay@cryptsoft.com).
 
64
 * The implementation was written so as to conform with Netscapes SSL.
 
65
 *
 
66
 * This library is free for commercial and non-commercial use as long as
 
67
 * the following conditions are aheared to.  The following conditions
 
68
 * apply to all code found in this distribution, be it the RC4, RSA,
 
69
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 
70
 * included with this distribution is covered by the same copyright terms
 
71
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 
72
 *
 
73
 * Copyright remains Eric Young's, and as such any Copyright notices in
 
74
 * the code are not to be removed.
 
75
 * If this package is used in a product, Eric Young should be given attribution
 
76
 * as the author of the parts of the library used.
 
77
 * This can be in the form of a textual message at program startup or
 
78
 * in documentation (online or textual) provided with the package.
 
79
 *
 
80
 * Redistribution and use in source and binary forms, with or without
 
81
 * modification, are permitted provided that the following conditions
 
82
 * are met:
 
83
 * 1. Redistributions of source code must retain the copyright
 
84
 *    notice, this list of conditions and the following disclaimer.
 
85
 * 2. Redistributions in binary form must reproduce the above copyright
 
86
 *    notice, this list of conditions and the following disclaimer in the
 
87
 *    documentation and/or other materials provided with the distribution.
 
88
 * 3. All advertising materials mentioning features or use of this software
 
89
 *    must display the following acknowledgement:
 
90
 *    "This product includes cryptographic software written by
 
91
 *     Eric Young (eay@cryptsoft.com)"
 
92
 *    The word 'cryptographic' can be left out if the rouines from the library
 
93
 *    being used are not cryptographic related :-).
 
94
 * 4. If you include any Windows specific code (or a derivative thereof) from
 
95
 *    the apps directory (application code) you must include an acknowledgement:
 
96
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 
97
 *
 
98
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 
99
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
100
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
101
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 
102
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
103
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 
104
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
105
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
106
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 
107
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 
108
 * SUCH DAMAGE.
 
109
 *
 
110
 * The licence and distribution terms for any publically available version or
 
111
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 
112
 * copied and put under another distribution licence
 
113
 * [including the GNU Public Licence.]
 
114
 */
 
115
 
 
116
#include <stdio.h>
 
117
#include <errno.h>
 
118
#define USE_SOCKETS
 
119
#include "ssl_locl.h"
 
120
#include <openssl/evp.h>
 
121
#include <openssl/buffer.h>
 
122
#include <openssl/pqueue.h>
 
123
#include <openssl/rand.h>
 
124
 
 
125
/* mod 128 saturating subtract of two 64-bit values in big-endian order */
 
126
static int satsub64be(const unsigned char *v1, const unsigned char *v2)
 
127
{
 
128
    int ret, sat, brw, i;
 
129
 
 
130
    if (sizeof(long) == 8)
 
131
        do {
 
132
            const union {
 
133
                long one;
 
134
                char little;
 
135
            } is_endian = {
 
136
                1
 
137
            };
 
138
            long l;
 
139
 
 
140
            if (is_endian.little)
 
141
                break;
 
142
            /* not reached on little-endians */
 
143
            /*
 
144
             * following test is redundant, because input is always aligned,
 
145
             * but I take no chances...
 
146
             */
 
147
            if (((size_t)v1 | (size_t)v2) & 0x7)
 
148
                break;
 
149
 
 
150
            l = *((long *)v1);
 
151
            l -= *((long *)v2);
 
152
            if (l > 128)
 
153
                return 128;
 
154
            else if (l < -128)
 
155
                return -128;
 
156
            else
 
157
                return (int)l;
 
158
        } while (0);
 
159
 
 
160
    ret = (int)v1[7] - (int)v2[7];
 
161
    sat = 0;
 
162
    brw = ret >> 8;             /* brw is either 0 or -1 */
 
163
    if (ret & 0x80) {
 
164
        for (i = 6; i >= 0; i--) {
 
165
            brw += (int)v1[i] - (int)v2[i];
 
166
            sat |= ~brw;
 
167
            brw >>= 8;
 
168
        }
 
169
    } else {
 
170
        for (i = 6; i >= 0; i--) {
 
171
            brw += (int)v1[i] - (int)v2[i];
 
172
            sat |= brw;
 
173
            brw >>= 8;
 
174
        }
 
175
    }
 
176
    brw <<= 8;                  /* brw is either 0 or -256 */
 
177
 
 
178
    if (sat & 0xff)
 
179
        return brw | 0x80;
 
180
    else
 
181
        return brw + (ret & 0xFF);
 
182
}
 
183
 
 
184
static int have_handshake_fragment(SSL *s, int type, unsigned char *buf,
 
185
                                   int len, int peek);
 
186
static int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap);
 
187
static void dtls1_record_bitmap_update(SSL *s, DTLS1_BITMAP *bitmap);
 
188
static DTLS1_BITMAP *dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr,
 
189
                                      unsigned int *is_next_epoch);
 
190
#if 0
 
191
static int dtls1_record_needs_buffering(SSL *s, SSL3_RECORD *rr,
 
192
                                        unsigned short *priority,
 
193
                                        unsigned long *offset);
 
194
#endif
 
195
static int dtls1_buffer_record(SSL *s, record_pqueue *q,
 
196
                               unsigned char *priority);
 
197
static int dtls1_process_record(SSL *s);
 
198
 
 
199
/* copy buffered record into SSL structure */
 
200
static int dtls1_copy_record(SSL *s, pitem *item)
 
201
{
 
202
    DTLS1_RECORD_DATA *rdata;
 
203
 
 
204
    rdata = (DTLS1_RECORD_DATA *)item->data;
 
205
 
 
206
    if (s->s3->rbuf.buf != NULL)
 
207
        OPENSSL_free(s->s3->rbuf.buf);
 
208
 
 
209
    s->packet = rdata->packet;
 
210
    s->packet_length = rdata->packet_length;
 
211
    memcpy(&(s->s3->rbuf), &(rdata->rbuf), sizeof(SSL3_BUFFER));
 
212
    memcpy(&(s->s3->rrec), &(rdata->rrec), sizeof(SSL3_RECORD));
 
213
 
 
214
    /* Set proper sequence number for mac calculation */
 
215
    memcpy(&(s->s3->read_sequence[2]), &(rdata->packet[5]), 6);
 
216
 
 
217
    return (1);
 
218
}
 
219
 
 
220
static int
 
221
dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority)
 
222
{
 
223
    DTLS1_RECORD_DATA *rdata;
 
224
    pitem *item;
 
225
 
 
226
    /* Limit the size of the queue to prevent DOS attacks */
 
227
    if (pqueue_size(queue->q) >= 100)
 
228
        return 0;
 
229
 
 
230
    rdata = OPENSSL_malloc(sizeof(DTLS1_RECORD_DATA));
 
231
    item = pitem_new(priority, rdata);
 
232
    if (rdata == NULL || item == NULL) {
 
233
        if (rdata != NULL)
 
234
            OPENSSL_free(rdata);
 
235
        if (item != NULL)
 
236
            pitem_free(item);
 
237
 
 
238
        SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR);
 
239
        return -1;
 
240
    }
 
241
 
 
242
    rdata->packet = s->packet;
 
243
    rdata->packet_length = s->packet_length;
 
244
    memcpy(&(rdata->rbuf), &(s->s3->rbuf), sizeof(SSL3_BUFFER));
 
245
    memcpy(&(rdata->rrec), &(s->s3->rrec), sizeof(SSL3_RECORD));
 
246
 
 
247
    item->data = rdata;
 
248
 
 
249
#ifndef OPENSSL_NO_SCTP
 
250
    /* Store bio_dgram_sctp_rcvinfo struct */
 
251
    if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
 
252
        (s->state == SSL3_ST_SR_FINISHED_A
 
253
         || s->state == SSL3_ST_CR_FINISHED_A)) {
 
254
        BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SCTP_GET_RCVINFO,
 
255
                 sizeof(rdata->recordinfo), &rdata->recordinfo);
 
256
    }
 
257
#endif
 
258
 
 
259
    s->packet = NULL;
 
260
    s->packet_length = 0;
 
261
    memset(&(s->s3->rbuf), 0, sizeof(SSL3_BUFFER));
 
262
    memset(&(s->s3->rrec), 0, sizeof(SSL3_RECORD));
 
263
 
 
264
    if (!ssl3_setup_buffers(s)) {
 
265
        SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR);
 
266
        if (rdata->rbuf.buf != NULL)
 
267
            OPENSSL_free(rdata->rbuf.buf);
 
268
        OPENSSL_free(rdata);
 
269
        pitem_free(item);
 
270
        return (-1);
 
271
    }
 
272
 
 
273
    /* insert should not fail, since duplicates are dropped */
 
274
    if (pqueue_insert(queue->q, item) == NULL) {
 
275
        SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR);
 
276
        if (rdata->rbuf.buf != NULL)
 
277
            OPENSSL_free(rdata->rbuf.buf);
 
278
        OPENSSL_free(rdata);
 
279
        pitem_free(item);
 
280
        return (-1);
 
281
    }
 
282
 
 
283
    return (1);
 
284
}
 
285
 
 
286
static int dtls1_retrieve_buffered_record(SSL *s, record_pqueue *queue)
 
287
{
 
288
    pitem *item;
 
289
 
 
290
    item = pqueue_pop(queue->q);
 
291
    if (item) {
 
292
        dtls1_copy_record(s, item);
 
293
 
 
294
        OPENSSL_free(item->data);
 
295
        pitem_free(item);
 
296
 
 
297
        return (1);
 
298
    }
 
299
 
 
300
    return (0);
 
301
}
 
302
 
 
303
/*
 
304
 * retrieve a buffered record that belongs to the new epoch, i.e., not
 
305
 * processed yet
 
306
 */
 
307
#define dtls1_get_unprocessed_record(s) \
 
308
                   dtls1_retrieve_buffered_record((s), \
 
309
                   &((s)->d1->unprocessed_rcds))
 
310
 
 
311
/*
 
312
 * retrieve a buffered record that belongs to the current epoch, ie,
 
313
 * processed
 
314
 */
 
315
#define dtls1_get_processed_record(s) \
 
316
                   dtls1_retrieve_buffered_record((s), \
 
317
                   &((s)->d1->processed_rcds))
 
318
 
 
319
static int dtls1_process_buffered_records(SSL *s)
 
320
{
 
321
    pitem *item;
 
322
 
 
323
    item = pqueue_peek(s->d1->unprocessed_rcds.q);
 
324
    if (item) {
 
325
        /* Check if epoch is current. */
 
326
        if (s->d1->unprocessed_rcds.epoch != s->d1->r_epoch)
 
327
            return (1);         /* Nothing to do. */
 
328
 
 
329
        /* Process all the records. */
 
330
        while (pqueue_peek(s->d1->unprocessed_rcds.q)) {
 
331
            dtls1_get_unprocessed_record(s);
 
332
            if (!dtls1_process_record(s))
 
333
                return (0);
 
334
            if (dtls1_buffer_record(s, &(s->d1->processed_rcds),
 
335
                                    s->s3->rrec.seq_num) < 0)
 
336
                return -1;
 
337
        }
 
338
    }
 
339
 
 
340
    /*
 
341
     * sync epoch numbers once all the unprocessed records have been
 
342
     * processed
 
343
     */
 
344
    s->d1->processed_rcds.epoch = s->d1->r_epoch;
 
345
    s->d1->unprocessed_rcds.epoch = s->d1->r_epoch + 1;
 
346
 
 
347
    return (1);
 
348
}
 
349
 
 
350
#if 0
 
351
 
 
352
static int dtls1_get_buffered_record(SSL *s)
 
353
{
 
354
    pitem *item;
 
355
    PQ_64BIT priority =
 
356
        (((PQ_64BIT) s->d1->handshake_read_seq) << 32) |
 
357
        ((PQ_64BIT) s->d1->r_msg_hdr.frag_off);
 
358
 
 
359
    /* if we're not (re)negotiating, nothing buffered */
 
360
    if (!SSL_in_init(s))
 
361
        return 0;
 
362
 
 
363
    item = pqueue_peek(s->d1->rcvd_records);
 
364
    if (item && item->priority == priority) {
 
365
        /*
 
366
         * Check if we've received the record of interest.  It must be a
 
367
         * handshake record, since data records as passed up without
 
368
         * buffering
 
369
         */
 
370
        DTLS1_RECORD_DATA *rdata;
 
371
        item = pqueue_pop(s->d1->rcvd_records);
 
372
        rdata = (DTLS1_RECORD_DATA *)item->data;
 
373
 
 
374
        if (s->s3->rbuf.buf != NULL)
 
375
            OPENSSL_free(s->s3->rbuf.buf);
 
376
 
 
377
        s->packet = rdata->packet;
 
378
        s->packet_length = rdata->packet_length;
 
379
        memcpy(&(s->s3->rbuf), &(rdata->rbuf), sizeof(SSL3_BUFFER));
 
380
        memcpy(&(s->s3->rrec), &(rdata->rrec), sizeof(SSL3_RECORD));
 
381
 
 
382
        OPENSSL_free(item->data);
 
383
        pitem_free(item);
 
384
 
 
385
        /* s->d1->next_expected_seq_num++; */
 
386
        return (1);
 
387
    }
 
388
 
 
389
    return 0;
 
390
}
 
391
 
 
392
#endif
 
393
 
 
394
static int dtls1_process_record(SSL *s)
 
395
{
 
396
    int i, al;
 
397
    int enc_err;
 
398
    SSL_SESSION *sess;
 
399
    SSL3_RECORD *rr;
 
400
    unsigned int mac_size, orig_len;
 
401
    unsigned char md[EVP_MAX_MD_SIZE];
 
402
 
 
403
    rr = &(s->s3->rrec);
 
404
    sess = s->session;
 
405
 
 
406
    /*
 
407
     * At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length,
 
408
     * and we have that many bytes in s->packet
 
409
     */
 
410
    rr->input = &(s->packet[DTLS1_RT_HEADER_LENGTH]);
 
411
 
 
412
    /*
 
413
     * ok, we can now read from 's->packet' data into 'rr' rr->input points
 
414
     * at rr->length bytes, which need to be copied into rr->data by either
 
415
     * the decryption or by the decompression When the data is 'copied' into
 
416
     * the rr->data buffer, rr->input will be pointed at the new buffer
 
417
     */
 
418
 
 
419
    /*
 
420
     * We now have - encrypted [ MAC [ compressed [ plain ] ] ] rr->length
 
421
     * bytes of encrypted compressed stuff.
 
422
     */
 
423
 
 
424
    /* check is not needed I believe */
 
425
    if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
 
426
        al = SSL_AD_RECORD_OVERFLOW;
 
427
        SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
 
428
        goto f_err;
 
429
    }
 
430
 
 
431
    /* decrypt in place in 'rr->input' */
 
432
    rr->data = rr->input;
 
433
 
 
434
    enc_err = s->method->ssl3_enc->enc(s, 0);
 
435
    /*-
 
436
     * enc_err is:
 
437
     *    0: (in non-constant time) if the record is publically invalid.
 
438
     *    1: if the padding is valid
 
439
     *   -1: if the padding is invalid
 
440
     */
 
441
    if (enc_err == 0) {
 
442
        /* For DTLS we simply ignore bad packets. */
 
443
        rr->length = 0;
 
444
        s->packet_length = 0;
 
445
        goto err;
 
446
    }
 
447
#ifdef TLS_DEBUG
 
448
    printf("dec %d\n", rr->length);
 
449
    {
 
450
        unsigned int z;
 
451
        for (z = 0; z < rr->length; z++)
 
452
            printf("%02X%c", rr->data[z], ((z + 1) % 16) ? ' ' : '\n');
 
453
    }
 
454
    printf("\n");
 
455
#endif
 
456
 
 
457
    /* r->length is now the compressed data plus mac */
 
458
    if ((sess != NULL) &&
 
459
        (s->enc_read_ctx != NULL) && (EVP_MD_CTX_md(s->read_hash) != NULL)) {
 
460
        /* s->read_hash != NULL => mac_size != -1 */
 
461
        unsigned char *mac = NULL;
 
462
        unsigned char mac_tmp[EVP_MAX_MD_SIZE];
 
463
        mac_size = EVP_MD_CTX_size(s->read_hash);
 
464
        OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
 
465
 
 
466
        /*
 
467
         * kludge: *_cbc_remove_padding passes padding length in rr->type
 
468
         */
 
469
        orig_len = rr->length + ((unsigned int)rr->type >> 8);
 
470
 
 
471
        /*
 
472
         * orig_len is the length of the record before any padding was
 
473
         * removed. This is public information, as is the MAC in use,
 
474
         * therefore we can safely process the record in a different amount
 
475
         * of time if it's too short to possibly contain a MAC.
 
476
         */
 
477
        if (orig_len < mac_size ||
 
478
            /* CBC records must have a padding length byte too. */
 
479
            (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
 
480
             orig_len < mac_size + 1)) {
 
481
            al = SSL_AD_DECODE_ERROR;
 
482
            SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_LENGTH_TOO_SHORT);
 
483
            goto f_err;
 
484
        }
 
485
 
 
486
        if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {
 
487
            /*
 
488
             * We update the length so that the TLS header bytes can be
 
489
             * constructed correctly but we need to extract the MAC in
 
490
             * constant time from within the record, without leaking the
 
491
             * contents of the padding bytes.
 
492
             */
 
493
            mac = mac_tmp;
 
494
            ssl3_cbc_copy_mac(mac_tmp, rr, mac_size, orig_len);
 
495
            rr->length -= mac_size;
 
496
        } else {
 
497
            /*
 
498
             * In this case there's no padding, so |orig_len| equals
 
499
             * |rec->length| and we checked that there's enough bytes for
 
500
             * |mac_size| above.
 
501
             */
 
502
            rr->length -= mac_size;
 
503
            mac = &rr->data[rr->length];
 
504
        }
 
505
 
 
506
        i = s->method->ssl3_enc->mac(s, md, 0 /* not send */ );
 
507
        if (i < 0 || mac == NULL
 
508
            || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
 
509
            enc_err = -1;
 
510
        if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
 
511
            enc_err = -1;
 
512
    }
 
513
 
 
514
    if (enc_err < 0) {
 
515
        /* decryption failed, silently discard message */
 
516
        rr->length = 0;
 
517
        s->packet_length = 0;
 
518
        goto err;
 
519
    }
 
520
 
 
521
    /* r->length is now just compressed */
 
522
    if (s->expand != NULL) {
 
523
        if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) {
 
524
            al = SSL_AD_RECORD_OVERFLOW;
 
525
            SSLerr(SSL_F_DTLS1_PROCESS_RECORD,
 
526
                   SSL_R_COMPRESSED_LENGTH_TOO_LONG);
 
527
            goto f_err;
 
528
        }
 
529
        if (!ssl3_do_uncompress(s)) {
 
530
            al = SSL_AD_DECOMPRESSION_FAILURE;
 
531
            SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_BAD_DECOMPRESSION);
 
532
            goto f_err;
 
533
        }
 
534
    }
 
535
 
 
536
    if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH) {
 
537
        al = SSL_AD_RECORD_OVERFLOW;
 
538
        SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);
 
539
        goto f_err;
 
540
    }
 
541
 
 
542
    rr->off = 0;
 
543
    /*-
 
544
     * So at this point the following is true
 
545
     * ssl->s3->rrec.type   is the type of record
 
546
     * ssl->s3->rrec.length == number of bytes in record
 
547
     * ssl->s3->rrec.off    == offset to first valid byte
 
548
     * ssl->s3->rrec.data   == where to take bytes from, increment
 
549
     *                         after use :-).
 
550
     */
 
551
 
 
552
    /* we have pulled in a full packet so zero things */
 
553
    s->packet_length = 0;
 
554
    return (1);
 
555
 
 
556
 f_err:
 
557
    ssl3_send_alert(s, SSL3_AL_FATAL, al);
 
558
 err:
 
559
    return (0);
 
560
}
 
561
 
 
562
/*-
 
563
 * Call this to get a new input record.
 
564
 * It will return <= 0 if more data is needed, normally due to an error
 
565
 * or non-blocking IO.
 
566
 * When it finishes, one packet has been decoded and can be found in
 
567
 * ssl->s3->rrec.type    - is the type of record
 
568
 * ssl->s3->rrec.data,   - data
 
569
 * ssl->s3->rrec.length, - number of bytes
 
570
 */
 
571
/* used only by dtls1_read_bytes */
 
572
int dtls1_get_record(SSL *s)
 
573
{
 
574
    int ssl_major, ssl_minor;
 
575
    int i, n;
 
576
    SSL3_RECORD *rr;
 
577
    unsigned char *p = NULL;
 
578
    unsigned short version;
 
579
    DTLS1_BITMAP *bitmap;
 
580
    unsigned int is_next_epoch;
 
581
 
 
582
    rr = &(s->s3->rrec);
 
583
 
 
584
    /*
 
585
     * The epoch may have changed.  If so, process all the pending records.
 
586
     * This is a non-blocking operation.
 
587
     */
 
588
    if (dtls1_process_buffered_records(s) < 0)
 
589
        return -1;
 
590
 
 
591
    /* if we're renegotiating, then there may be buffered records */
 
592
    if (dtls1_get_processed_record(s))
 
593
        return 1;
 
594
 
 
595
    /* get something from the wire */
 
596
 again:
 
597
    /* check if we have the header */
 
598
    if ((s->rstate != SSL_ST_READ_BODY) ||
 
599
        (s->packet_length < DTLS1_RT_HEADER_LENGTH)) {
 
600
        n = ssl3_read_n(s, DTLS1_RT_HEADER_LENGTH, s->s3->rbuf.len, 0);
 
601
        /* read timeout is handled by dtls1_read_bytes */
 
602
        if (n <= 0)
 
603
            return (n);         /* error or non-blocking */
 
604
 
 
605
        /* this packet contained a partial record, dump it */
 
606
        if (s->packet_length != DTLS1_RT_HEADER_LENGTH) {
 
607
            s->packet_length = 0;
 
608
            goto again;
 
609
        }
 
610
 
 
611
        s->rstate = SSL_ST_READ_BODY;
 
612
 
 
613
        p = s->packet;
 
614
 
 
615
        if (s->msg_callback)
 
616
            s->msg_callback(0, 0, SSL3_RT_HEADER, p, DTLS1_RT_HEADER_LENGTH,
 
617
                            s, s->msg_callback_arg);
 
618
 
 
619
        /* Pull apart the header into the DTLS1_RECORD */
 
620
        rr->type = *(p++);
 
621
        ssl_major = *(p++);
 
622
        ssl_minor = *(p++);
 
623
        version = (ssl_major << 8) | ssl_minor;
 
624
 
 
625
        /* sequence number is 64 bits, with top 2 bytes = epoch */
 
626
        n2s(p, rr->epoch);
 
627
 
 
628
        memcpy(&(s->s3->read_sequence[2]), p, 6);
 
629
        p += 6;
 
630
 
 
631
        n2s(p, rr->length);
 
632
 
 
633
        /* Lets check version */
 
634
        if (!s->first_packet) {
 
635
            if (version != s->version) {
 
636
                /* unexpected version, silently discard */
 
637
                rr->length = 0;
 
638
                s->packet_length = 0;
 
639
                goto again;
 
640
            }
 
641
        }
 
642
 
 
643
        if ((version & 0xff00) != (s->version & 0xff00)) {
 
644
            /* wrong version, silently discard record */
 
645
            rr->length = 0;
 
646
            s->packet_length = 0;
 
647
            goto again;
 
648
        }
 
649
 
 
650
        if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
 
651
            /* record too long, silently discard it */
 
652
            rr->length = 0;
 
653
            s->packet_length = 0;
 
654
            goto again;
 
655
        }
 
656
 
 
657
        /* now s->rstate == SSL_ST_READ_BODY */
 
658
    }
 
659
 
 
660
    /* s->rstate == SSL_ST_READ_BODY, get and decode the data */
 
661
 
 
662
    if (rr->length > s->packet_length - DTLS1_RT_HEADER_LENGTH) {
 
663
        /* now s->packet_length == DTLS1_RT_HEADER_LENGTH */
 
664
        i = rr->length;
 
665
        n = ssl3_read_n(s, i, i, 1);
 
666
        /* this packet contained a partial record, dump it */
 
667
        if (n != i) {
 
668
            rr->length = 0;
 
669
            s->packet_length = 0;
 
670
            goto again;
 
671
        }
 
672
 
 
673
        /*
 
674
         * now n == rr->length, and s->packet_length ==
 
675
         * DTLS1_RT_HEADER_LENGTH + rr->length
 
676
         */
 
677
    }
 
678
    s->rstate = SSL_ST_READ_HEADER; /* set state for later operations */
 
679
 
 
680
    /* match epochs.  NULL means the packet is dropped on the floor */
 
681
    bitmap = dtls1_get_bitmap(s, rr, &is_next_epoch);
 
682
    if (bitmap == NULL) {
 
683
        rr->length = 0;
 
684
        s->packet_length = 0;   /* dump this record */
 
685
        goto again;             /* get another record */
 
686
    }
 
687
#ifndef OPENSSL_NO_SCTP
 
688
    /* Only do replay check if no SCTP bio */
 
689
    if (!BIO_dgram_is_sctp(SSL_get_rbio(s))) {
 
690
#endif
 
691
        /*
 
692
         * Check whether this is a repeat, or aged record. Don't check if
 
693
         * we're listening and this message is a ClientHello. They can look
 
694
         * as if they're replayed, since they arrive from different
 
695
         * connections and would be dropped unnecessarily.
 
696
         */
 
697
        if (!(s->d1->listen && rr->type == SSL3_RT_HANDSHAKE &&
 
698
              s->packet_length > DTLS1_RT_HEADER_LENGTH &&
 
699
              s->packet[DTLS1_RT_HEADER_LENGTH] == SSL3_MT_CLIENT_HELLO) &&
 
700
            !dtls1_record_replay_check(s, bitmap)) {
 
701
            rr->length = 0;
 
702
            s->packet_length = 0; /* dump this record */
 
703
            goto again;         /* get another record */
 
704
        }
 
705
#ifndef OPENSSL_NO_SCTP
 
706
    }
 
707
#endif
 
708
 
 
709
    /* just read a 0 length packet */
 
710
    if (rr->length == 0)
 
711
        goto again;
 
712
 
 
713
    /*
 
714
     * If this record is from the next epoch (either HM or ALERT), and a
 
715
     * handshake is currently in progress, buffer it since it cannot be
 
716
     * processed at this time. However, do not buffer anything while
 
717
     * listening.
 
718
     */
 
719
    if (is_next_epoch) {
 
720
        if ((SSL_in_init(s) || s->in_handshake) && !s->d1->listen) {
 
721
            if (dtls1_buffer_record
 
722
                (s, &(s->d1->unprocessed_rcds), rr->seq_num) < 0)
 
723
                return -1;
 
724
            /* Mark receipt of record. */
 
725
            dtls1_record_bitmap_update(s, bitmap);
 
726
        }
 
727
        rr->length = 0;
 
728
        s->packet_length = 0;
 
729
        goto again;
 
730
    }
 
731
 
 
732
    if (!dtls1_process_record(s)) {
 
733
        rr->length = 0;
 
734
        s->packet_length = 0;   /* dump this record */
 
735
        goto again;             /* get another record */
 
736
    }
 
737
    dtls1_record_bitmap_update(s, bitmap); /* Mark receipt of record. */
 
738
 
 
739
    return (1);
 
740
 
 
741
}
 
742
 
 
743
/*-
 
744
 * Return up to 'len' payload bytes received in 'type' records.
 
745
 * 'type' is one of the following:
 
746
 *
 
747
 *   -  SSL3_RT_HANDSHAKE (when ssl3_get_message calls us)
 
748
 *   -  SSL3_RT_APPLICATION_DATA (when ssl3_read calls us)
 
749
 *   -  0 (during a shutdown, no data has to be returned)
 
750
 *
 
751
 * If we don't have stored data to work from, read a SSL/TLS record first
 
752
 * (possibly multiple records if we still don't have anything to return).
 
753
 *
 
754
 * This function must handle any surprises the peer may have for us, such as
 
755
 * Alert records (e.g. close_notify), ChangeCipherSpec records (not really
 
756
 * a surprise, but handled as if it were), or renegotiation requests.
 
757
 * Also if record payloads contain fragments too small to process, we store
 
758
 * them until there is enough for the respective protocol (the record protocol
 
759
 * may use arbitrary fragmentation and even interleaving):
 
760
 *     Change cipher spec protocol
 
761
 *             just 1 byte needed, no need for keeping anything stored
 
762
 *     Alert protocol
 
763
 *             2 bytes needed (AlertLevel, AlertDescription)
 
764
 *     Handshake protocol
 
765
 *             4 bytes needed (HandshakeType, uint24 length) -- we just have
 
766
 *             to detect unexpected Client Hello and Hello Request messages
 
767
 *             here, anything else is handled by higher layers
 
768
 *     Application data protocol
 
769
 *             none of our business
 
770
 */
 
771
int dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
 
772
{
 
773
    int al, i, j, ret;
 
774
    unsigned int n;
 
775
    SSL3_RECORD *rr;
 
776
    void (*cb) (const SSL *ssl, int type2, int val) = NULL;
 
777
 
 
778
    if (s->s3->rbuf.buf == NULL) /* Not initialized yet */
 
779
        if (!ssl3_setup_buffers(s))
 
780
            return (-1);
 
781
 
 
782
    /* XXX: check what the second '&& type' is about */
 
783
    if ((type && (type != SSL3_RT_APPLICATION_DATA) &&
 
784
         (type != SSL3_RT_HANDSHAKE) && type) ||
 
785
        (peek && (type != SSL3_RT_APPLICATION_DATA))) {
 
786
        SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR);
 
787
        return -1;
 
788
    }
 
789
 
 
790
    /*
 
791
     * check whether there's a handshake message (client hello?) waiting
 
792
     */
 
793
    if ((ret = have_handshake_fragment(s, type, buf, len, peek)))
 
794
        return ret;
 
795
 
 
796
    /*
 
797
     * Now s->d1->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE.
 
798
     */
 
799
 
 
800
#ifndef OPENSSL_NO_SCTP
 
801
    /*
 
802
     * Continue handshake if it had to be interrupted to read app data with
 
803
     * SCTP.
 
804
     */
 
805
    if ((!s->in_handshake && SSL_in_init(s)) ||
 
806
        (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
 
807
         (s->state == DTLS1_SCTP_ST_SR_READ_SOCK
 
808
          || s->state == DTLS1_SCTP_ST_CR_READ_SOCK)
 
809
         && s->s3->in_read_app_data != 2))
 
810
#else
 
811
    if (!s->in_handshake && SSL_in_init(s))
 
812
#endif
 
813
    {
 
814
        /* type == SSL3_RT_APPLICATION_DATA */
 
815
        i = s->handshake_func(s);
 
816
        if (i < 0)
 
817
            return (i);
 
818
        if (i == 0) {
 
819
            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
 
820
            return (-1);
 
821
        }
 
822
    }
 
823
 
 
824
 start:
 
825
    s->rwstate = SSL_NOTHING;
 
826
 
 
827
    /*-
 
828
     * s->s3->rrec.type         - is the type of record
 
829
     * s->s3->rrec.data,    - data
 
830
     * s->s3->rrec.off,     - offset into 'data' for next read
 
831
     * s->s3->rrec.length,  - number of bytes.
 
832
     */
 
833
    rr = &(s->s3->rrec);
 
834
 
 
835
    /*
 
836
     * We are not handshaking and have no data yet, so process data buffered
 
837
     * during the last handshake in advance, if any.
 
838
     */
 
839
    if (s->state == SSL_ST_OK && rr->length == 0) {
 
840
        pitem *item;
 
841
        item = pqueue_pop(s->d1->buffered_app_data.q);
 
842
        if (item) {
 
843
#ifndef OPENSSL_NO_SCTP
 
844
            /* Restore bio_dgram_sctp_rcvinfo struct */
 
845
            if (BIO_dgram_is_sctp(SSL_get_rbio(s))) {
 
846
                DTLS1_RECORD_DATA *rdata = (DTLS1_RECORD_DATA *)item->data;
 
847
                BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SCTP_SET_RCVINFO,
 
848
                         sizeof(rdata->recordinfo), &rdata->recordinfo);
 
849
            }
 
850
#endif
 
851
 
 
852
            dtls1_copy_record(s, item);
 
853
 
 
854
            OPENSSL_free(item->data);
 
855
            pitem_free(item);
 
856
        }
 
857
    }
 
858
 
 
859
    /* Check for timeout */
 
860
    if (dtls1_handle_timeout(s) > 0)
 
861
        goto start;
 
862
 
 
863
    /* get new packet if necessary */
 
864
    if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY)) {
 
865
        ret = dtls1_get_record(s);
 
866
        if (ret <= 0) {
 
867
            ret = dtls1_read_failed(s, ret);
 
868
            /* anything other than a timeout is an error */
 
869
            if (ret <= 0)
 
870
                return (ret);
 
871
            else
 
872
                goto start;
 
873
        }
 
874
    }
 
875
 
 
876
    if (s->d1->listen && rr->type != SSL3_RT_HANDSHAKE) {
 
877
        rr->length = 0;
 
878
        goto start;
 
879
    }
 
880
 
 
881
    /* we now have a packet which can be read and processed */
 
882
 
 
883
    if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec,
 
884
                                   * reset by ssl3_get_finished */
 
885
        && (rr->type != SSL3_RT_HANDSHAKE)) {
 
886
        /*
 
887
         * We now have application data between CCS and Finished. Most likely
 
888
         * the packets were reordered on their way, so buffer the application
 
889
         * data for later processing rather than dropping the connection.
 
890
         */
 
891
        if (dtls1_buffer_record(s, &(s->d1->buffered_app_data), rr->seq_num) <
 
892
            0) {
 
893
            SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR);
 
894
            return -1;
 
895
        }
 
896
        rr->length = 0;
 
897
        goto start;
 
898
    }
 
899
 
 
900
    /*
 
901
     * If the other end has shut down, throw anything we read away (even in
 
902
     * 'peek' mode)
 
903
     */
 
904
    if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
 
905
        rr->length = 0;
 
906
        s->rwstate = SSL_NOTHING;
 
907
        return (0);
 
908
    }
 
909
 
 
910
    if (type == rr->type) {     /* SSL3_RT_APPLICATION_DATA or
 
911
                                 * SSL3_RT_HANDSHAKE */
 
912
        /*
 
913
         * make sure that we are not getting application data when we are
 
914
         * doing a handshake for the first time
 
915
         */
 
916
        if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
 
917
            (s->enc_read_ctx == NULL)) {
 
918
            al = SSL_AD_UNEXPECTED_MESSAGE;
 
919
            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_APP_DATA_IN_HANDSHAKE);
 
920
            goto f_err;
 
921
        }
 
922
 
 
923
        if (len <= 0)
 
924
            return (len);
 
925
 
 
926
        if ((unsigned int)len > rr->length)
 
927
            n = rr->length;
 
928
        else
 
929
            n = (unsigned int)len;
 
930
 
 
931
        memcpy(buf, &(rr->data[rr->off]), n);
 
932
        if (!peek) {
 
933
            rr->length -= n;
 
934
            rr->off += n;
 
935
            if (rr->length == 0) {
 
936
                s->rstate = SSL_ST_READ_HEADER;
 
937
                rr->off = 0;
 
938
            }
 
939
        }
 
940
#ifndef OPENSSL_NO_SCTP
 
941
        /*
 
942
         * We were about to renegotiate but had to read belated application
 
943
         * data first, so retry.
 
944
         */
 
945
        if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
 
946
            rr->type == SSL3_RT_APPLICATION_DATA &&
 
947
            (s->state == DTLS1_SCTP_ST_SR_READ_SOCK
 
948
             || s->state == DTLS1_SCTP_ST_CR_READ_SOCK)) {
 
949
            s->rwstate = SSL_READING;
 
950
            BIO_clear_retry_flags(SSL_get_rbio(s));
 
951
            BIO_set_retry_read(SSL_get_rbio(s));
 
952
        }
 
953
 
 
954
        /*
 
955
         * We might had to delay a close_notify alert because of reordered
 
956
         * app data. If there was an alert and there is no message to read
 
957
         * anymore, finally set shutdown.
 
958
         */
 
959
        if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
 
960
            s->d1->shutdown_received
 
961
            && !BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) {
 
962
            s->shutdown |= SSL_RECEIVED_SHUTDOWN;
 
963
            return (0);
 
964
        }
 
965
#endif
 
966
        return (n);
 
967
    }
 
968
 
 
969
    /*
 
970
     * If we get here, then type != rr->type; if we have a handshake message,
 
971
     * then it was unexpected (Hello Request or Client Hello).
 
972
     */
 
973
 
 
974
    /*
 
975
     * In case of record types for which we have 'fragment' storage, fill
 
976
     * that so that we can process the data at a fixed place.
 
977
     */
 
978
    {
 
979
        unsigned int k, dest_maxlen = 0;
 
980
        unsigned char *dest = NULL;
 
981
        unsigned int *dest_len = NULL;
 
982
 
 
983
        if (rr->type == SSL3_RT_HANDSHAKE) {
 
984
            dest_maxlen = sizeof s->d1->handshake_fragment;
 
985
            dest = s->d1->handshake_fragment;
 
986
            dest_len = &s->d1->handshake_fragment_len;
 
987
        } else if (rr->type == SSL3_RT_ALERT) {
 
988
            dest_maxlen = sizeof(s->d1->alert_fragment);
 
989
            dest = s->d1->alert_fragment;
 
990
            dest_len = &s->d1->alert_fragment_len;
 
991
        }
 
992
#ifndef OPENSSL_NO_HEARTBEATS
 
993
        else if (rr->type == TLS1_RT_HEARTBEAT) {
 
994
            dtls1_process_heartbeat(s);
 
995
 
 
996
            /* Exit and notify application to read again */
 
997
            rr->length = 0;
 
998
            s->rwstate = SSL_READING;
 
999
            BIO_clear_retry_flags(SSL_get_rbio(s));
 
1000
            BIO_set_retry_read(SSL_get_rbio(s));
 
1001
            return (-1);
 
1002
        }
 
1003
#endif
 
1004
        /* else it's a CCS message, or application data or wrong */
 
1005
        else if (rr->type != SSL3_RT_CHANGE_CIPHER_SPEC) {
 
1006
            /*
 
1007
             * Application data while renegotiating is allowed. Try again
 
1008
             * reading.
 
1009
             */
 
1010
            if (rr->type == SSL3_RT_APPLICATION_DATA) {
 
1011
                BIO *bio;
 
1012
                s->s3->in_read_app_data = 2;
 
1013
                bio = SSL_get_rbio(s);
 
1014
                s->rwstate = SSL_READING;
 
1015
                BIO_clear_retry_flags(bio);
 
1016
                BIO_set_retry_read(bio);
 
1017
                return (-1);
 
1018
            }
 
1019
 
 
1020
            /* Not certain if this is the right error handling */
 
1021
            al = SSL_AD_UNEXPECTED_MESSAGE;
 
1022
            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNEXPECTED_RECORD);
 
1023
            goto f_err;
 
1024
        }
 
1025
 
 
1026
        if (dest_maxlen > 0) {
 
1027
            /*
 
1028
             * XDTLS: In a pathalogical case, the Client Hello may be
 
1029
             * fragmented--don't always expect dest_maxlen bytes
 
1030
             */
 
1031
            if (rr->length < dest_maxlen) {
 
1032
#ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE
 
1033
                /*
 
1034
                 * for normal alerts rr->length is 2, while
 
1035
                 * dest_maxlen is 7 if we were to handle this
 
1036
                 * non-existing alert...
 
1037
                 */
 
1038
                FIX ME
 
1039
#endif
 
1040
                 s->rstate = SSL_ST_READ_HEADER;
 
1041
                rr->length = 0;
 
1042
                goto start;
 
1043
            }
 
1044
 
 
1045
            /* now move 'n' bytes: */
 
1046
            for (k = 0; k < dest_maxlen; k++) {
 
1047
                dest[k] = rr->data[rr->off++];
 
1048
                rr->length--;
 
1049
            }
 
1050
            *dest_len = dest_maxlen;
 
1051
        }
 
1052
    }
 
1053
 
 
1054
    /*-
 
1055
     * s->d1->handshake_fragment_len == 12  iff  rr->type == SSL3_RT_HANDSHAKE;
 
1056
     * s->d1->alert_fragment_len == 7      iff  rr->type == SSL3_RT_ALERT.
 
1057
     * (Possibly rr is 'empty' now, i.e. rr->length may be 0.)
 
1058
     */
 
1059
 
 
1060
    /* If we are a client, check for an incoming 'Hello Request': */
 
1061
    if ((!s->server) &&
 
1062
        (s->d1->handshake_fragment_len >= DTLS1_HM_HEADER_LENGTH) &&
 
1063
        (s->d1->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) &&
 
1064
        (s->session != NULL) && (s->session->cipher != NULL)) {
 
1065
        s->d1->handshake_fragment_len = 0;
 
1066
 
 
1067
        if ((s->d1->handshake_fragment[1] != 0) ||
 
1068
            (s->d1->handshake_fragment[2] != 0) ||
 
1069
            (s->d1->handshake_fragment[3] != 0)) {
 
1070
            al = SSL_AD_DECODE_ERROR;
 
1071
            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_BAD_HELLO_REQUEST);
 
1072
            goto f_err;
 
1073
        }
 
1074
 
 
1075
        /*
 
1076
         * no need to check sequence number on HELLO REQUEST messages
 
1077
         */
 
1078
 
 
1079
        if (s->msg_callback)
 
1080
            s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
 
1081
                            s->d1->handshake_fragment, 4, s,
 
1082
                            s->msg_callback_arg);
 
1083
 
 
1084
        if (SSL_is_init_finished(s) &&
 
1085
            !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) &&
 
1086
            !s->s3->renegotiate) {
 
1087
            s->d1->handshake_read_seq++;
 
1088
            s->new_session = 1;
 
1089
            ssl3_renegotiate(s);
 
1090
            if (ssl3_renegotiate_check(s)) {
 
1091
                i = s->handshake_func(s);
 
1092
                if (i < 0)
 
1093
                    return (i);
 
1094
                if (i == 0) {
 
1095
                    SSLerr(SSL_F_DTLS1_READ_BYTES,
 
1096
                           SSL_R_SSL_HANDSHAKE_FAILURE);
 
1097
                    return (-1);
 
1098
                }
 
1099
 
 
1100
                if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
 
1101
                    if (s->s3->rbuf.left == 0) { /* no read-ahead left? */
 
1102
                        BIO *bio;
 
1103
                        /*
 
1104
                         * In the case where we try to read application data,
 
1105
                         * but we trigger an SSL handshake, we return -1 with
 
1106
                         * the retry option set.  Otherwise renegotiation may
 
1107
                         * cause nasty problems in the blocking world
 
1108
                         */
 
1109
                        s->rwstate = SSL_READING;
 
1110
                        bio = SSL_get_rbio(s);
 
1111
                        BIO_clear_retry_flags(bio);
 
1112
                        BIO_set_retry_read(bio);
 
1113
                        return (-1);
 
1114
                    }
 
1115
                }
 
1116
            }
 
1117
        }
 
1118
        /*
 
1119
         * we either finished a handshake or ignored the request, now try
 
1120
         * again to obtain the (application) data we were asked for
 
1121
         */
 
1122
        goto start;
 
1123
    }
 
1124
 
 
1125
    if (s->d1->alert_fragment_len >= DTLS1_AL_HEADER_LENGTH) {
 
1126
        int alert_level = s->d1->alert_fragment[0];
 
1127
        int alert_descr = s->d1->alert_fragment[1];
 
1128
 
 
1129
        s->d1->alert_fragment_len = 0;
 
1130
 
 
1131
        if (s->msg_callback)
 
1132
            s->msg_callback(0, s->version, SSL3_RT_ALERT,
 
1133
                            s->d1->alert_fragment, 2, s, s->msg_callback_arg);
 
1134
 
 
1135
        if (s->info_callback != NULL)
 
1136
            cb = s->info_callback;
 
1137
        else if (s->ctx->info_callback != NULL)
 
1138
            cb = s->ctx->info_callback;
 
1139
 
 
1140
        if (cb != NULL) {
 
1141
            j = (alert_level << 8) | alert_descr;
 
1142
            cb(s, SSL_CB_READ_ALERT, j);
 
1143
        }
 
1144
 
 
1145
        if (alert_level == SSL3_AL_WARNING) {
 
1146
            s->s3->warn_alert = alert_descr;
 
1147
            if (alert_descr == SSL_AD_CLOSE_NOTIFY) {
 
1148
#ifndef OPENSSL_NO_SCTP
 
1149
                /*
 
1150
                 * With SCTP and streams the socket may deliver app data
 
1151
                 * after a close_notify alert. We have to check this first so
 
1152
                 * that nothing gets discarded.
 
1153
                 */
 
1154
                if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
 
1155
                    BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) {
 
1156
                    s->d1->shutdown_received = 1;
 
1157
                    s->rwstate = SSL_READING;
 
1158
                    BIO_clear_retry_flags(SSL_get_rbio(s));
 
1159
                    BIO_set_retry_read(SSL_get_rbio(s));
 
1160
                    return -1;
 
1161
                }
 
1162
#endif
 
1163
                s->shutdown |= SSL_RECEIVED_SHUTDOWN;
 
1164
                return (0);
 
1165
            }
 
1166
#if 0
 
1167
            /* XXX: this is a possible improvement in the future */
 
1168
            /* now check if it's a missing record */
 
1169
            if (alert_descr == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE) {
 
1170
                unsigned short seq;
 
1171
                unsigned int frag_off;
 
1172
                unsigned char *p = &(s->d1->alert_fragment[2]);
 
1173
 
 
1174
                n2s(p, seq);
 
1175
                n2l3(p, frag_off);
 
1176
 
 
1177
                dtls1_retransmit_message(s,
 
1178
                                         dtls1_get_queue_priority
 
1179
                                         (frag->msg_header.seq, 0), frag_off,
 
1180
                                         &found);
 
1181
                if (!found && SSL_in_init(s)) {
 
1182
                    /*
 
1183
                     * fprintf( stderr,"in init = %d\n", SSL_in_init(s));
 
1184
                     */
 
1185
                    /*
 
1186
                     * requested a message not yet sent, send an alert
 
1187
                     * ourselves
 
1188
                     */
 
1189
                    ssl3_send_alert(s, SSL3_AL_WARNING,
 
1190
                                    DTLS1_AD_MISSING_HANDSHAKE_MESSAGE);
 
1191
                }
 
1192
            }
 
1193
#endif
 
1194
        } else if (alert_level == SSL3_AL_FATAL) {
 
1195
            char tmp[16];
 
1196
 
 
1197
            s->rwstate = SSL_NOTHING;
 
1198
            s->s3->fatal_alert = alert_descr;
 
1199
            SSLerr(SSL_F_DTLS1_READ_BYTES,
 
1200
                   SSL_AD_REASON_OFFSET + alert_descr);
 
1201
            BIO_snprintf(tmp, sizeof tmp, "%d", alert_descr);
 
1202
            ERR_add_error_data(2, "SSL alert number ", tmp);
 
1203
            s->shutdown |= SSL_RECEIVED_SHUTDOWN;
 
1204
            SSL_CTX_remove_session(s->ctx, s->session);
 
1205
            return (0);
 
1206
        } else {
 
1207
            al = SSL_AD_ILLEGAL_PARAMETER;
 
1208
            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNKNOWN_ALERT_TYPE);
 
1209
            goto f_err;
 
1210
        }
 
1211
 
 
1212
        goto start;
 
1213
    }
 
1214
 
 
1215
    if (s->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a
 
1216
                                            * shutdown */
 
1217
        s->rwstate = SSL_NOTHING;
 
1218
        rr->length = 0;
 
1219
        return (0);
 
1220
    }
 
1221
 
 
1222
    if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) {
 
1223
        struct ccs_header_st ccs_hdr;
 
1224
        unsigned int ccs_hdr_len = DTLS1_CCS_HEADER_LENGTH;
 
1225
 
 
1226
        dtls1_get_ccs_header(rr->data, &ccs_hdr);
 
1227
 
 
1228
        if (s->version == DTLS1_BAD_VER)
 
1229
            ccs_hdr_len = 3;
 
1230
 
 
1231
        /*
 
1232
         * 'Change Cipher Spec' is just a single byte, so we know exactly
 
1233
         * what the record payload has to look like
 
1234
         */
 
1235
        /* XDTLS: check that epoch is consistent */
 
1236
        if ((rr->length != ccs_hdr_len) ||
 
1237
            (rr->off != 0) || (rr->data[0] != SSL3_MT_CCS)) {
 
1238
            i = SSL_AD_ILLEGAL_PARAMETER;
 
1239
            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_BAD_CHANGE_CIPHER_SPEC);
 
1240
            goto err;
 
1241
        }
 
1242
 
 
1243
        rr->length = 0;
 
1244
 
 
1245
        if (s->msg_callback)
 
1246
            s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC,
 
1247
                            rr->data, 1, s, s->msg_callback_arg);
 
1248
 
 
1249
        /*
 
1250
         * We can't process a CCS now, because previous handshake messages
 
1251
         * are still missing, so just drop it.
 
1252
         */
 
1253
        if (!s->d1->change_cipher_spec_ok) {
 
1254
            goto start;
 
1255
        }
 
1256
 
 
1257
        s->d1->change_cipher_spec_ok = 0;
 
1258
 
 
1259
        s->s3->change_cipher_spec = 1;
 
1260
        if (!ssl3_do_change_cipher_spec(s))
 
1261
            goto err;
 
1262
 
 
1263
        /* do this whenever CCS is processed */
 
1264
        dtls1_reset_seq_numbers(s, SSL3_CC_READ);
 
1265
 
 
1266
        if (s->version == DTLS1_BAD_VER)
 
1267
            s->d1->handshake_read_seq++;
 
1268
 
 
1269
#ifndef OPENSSL_NO_SCTP
 
1270
        /*
 
1271
         * Remember that a CCS has been received, so that an old key of
 
1272
         * SCTP-Auth can be deleted when a CCS is sent. Will be ignored if no
 
1273
         * SCTP is used
 
1274
         */
 
1275
        BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL);
 
1276
#endif
 
1277
 
 
1278
        goto start;
 
1279
    }
 
1280
 
 
1281
    /*
 
1282
     * Unexpected handshake message (Client Hello, or protocol violation)
 
1283
     */
 
1284
    if ((s->d1->handshake_fragment_len >= DTLS1_HM_HEADER_LENGTH) &&
 
1285
        !s->in_handshake) {
 
1286
        struct hm_header_st msg_hdr;
 
1287
 
 
1288
        /* this may just be a stale retransmit */
 
1289
        dtls1_get_message_header(rr->data, &msg_hdr);
 
1290
        if (rr->epoch != s->d1->r_epoch) {
 
1291
            rr->length = 0;
 
1292
            goto start;
 
1293
        }
 
1294
 
 
1295
        /*
 
1296
         * If we are server, we may have a repeated FINISHED of the client
 
1297
         * here, then retransmit our CCS and FINISHED.
 
1298
         */
 
1299
        if (msg_hdr.type == SSL3_MT_FINISHED) {
 
1300
            if (dtls1_check_timeout_num(s) < 0)
 
1301
                return -1;
 
1302
 
 
1303
            dtls1_retransmit_buffered_messages(s);
 
1304
            rr->length = 0;
 
1305
            goto start;
 
1306
        }
 
1307
 
 
1308
        if (((s->state & SSL_ST_MASK) == SSL_ST_OK) &&
 
1309
            !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) {
 
1310
#if 0                           /* worked only because C operator preferences
 
1311
                                 * are not as expected (and because this is
 
1312
                                 * not really needed for clients except for
 
1313
                                 * detecting protocol violations): */
 
1314
            s->state = SSL_ST_BEFORE | (s->server)
 
1315
                ? SSL_ST_ACCEPT : SSL_ST_CONNECT;
 
1316
#else
 
1317
            s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT;
 
1318
#endif
 
1319
            s->renegotiate = 1;
 
1320
            s->new_session = 1;
 
1321
        }
 
1322
        i = s->handshake_func(s);
 
1323
        if (i < 0)
 
1324
            return (i);
 
1325
        if (i == 0) {
 
1326
            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
 
1327
            return (-1);
 
1328
        }
 
1329
 
 
1330
        if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
 
1331
            if (s->s3->rbuf.left == 0) { /* no read-ahead left? */
 
1332
                BIO *bio;
 
1333
                /*
 
1334
                 * In the case where we try to read application data, but we
 
1335
                 * trigger an SSL handshake, we return -1 with the retry
 
1336
                 * option set.  Otherwise renegotiation may cause nasty
 
1337
                 * problems in the blocking world
 
1338
                 */
 
1339
                s->rwstate = SSL_READING;
 
1340
                bio = SSL_get_rbio(s);
 
1341
                BIO_clear_retry_flags(bio);
 
1342
                BIO_set_retry_read(bio);
 
1343
                return (-1);
 
1344
            }
 
1345
        }
 
1346
        goto start;
 
1347
    }
 
1348
 
 
1349
    switch (rr->type) {
 
1350
    default:
 
1351
#ifndef OPENSSL_NO_TLS
 
1352
        /* TLS just ignores unknown message types */
 
1353
        if (s->version == TLS1_VERSION) {
 
1354
            rr->length = 0;
 
1355
            goto start;
 
1356
        }
 
1357
#endif
 
1358
        al = SSL_AD_UNEXPECTED_MESSAGE;
 
1359
        SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNEXPECTED_RECORD);
 
1360
        goto f_err;
 
1361
    case SSL3_RT_CHANGE_CIPHER_SPEC:
 
1362
    case SSL3_RT_ALERT:
 
1363
    case SSL3_RT_HANDSHAKE:
 
1364
        /*
 
1365
         * we already handled all of these, with the possible exception of
 
1366
         * SSL3_RT_HANDSHAKE when s->in_handshake is set, but that should not
 
1367
         * happen when type != rr->type
 
1368
         */
 
1369
        al = SSL_AD_UNEXPECTED_MESSAGE;
 
1370
        SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR);
 
1371
        goto f_err;
 
1372
    case SSL3_RT_APPLICATION_DATA:
 
1373
        /*
 
1374
         * At this point, we were expecting handshake data, but have
 
1375
         * application data.  If the library was running inside ssl3_read()
 
1376
         * (i.e. in_read_app_data is set) and it makes sense to read
 
1377
         * application data at this point (session renegotiation not yet
 
1378
         * started), we will indulge it.
 
1379
         */
 
1380
        if (s->s3->in_read_app_data &&
 
1381
            (s->s3->total_renegotiations != 0) &&
 
1382
            (((s->state & SSL_ST_CONNECT) &&
 
1383
              (s->state >= SSL3_ST_CW_CLNT_HELLO_A) &&
 
1384
              (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
 
1385
             ) || ((s->state & SSL_ST_ACCEPT) &&
 
1386
                   (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
 
1387
                   (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
 
1388
             )
 
1389
            )) {
 
1390
            s->s3->in_read_app_data = 2;
 
1391
            return (-1);
 
1392
        } else {
 
1393
            al = SSL_AD_UNEXPECTED_MESSAGE;
 
1394
            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNEXPECTED_RECORD);
 
1395
            goto f_err;
 
1396
        }
 
1397
    }
 
1398
    /* not reached */
 
1399
 
 
1400
 f_err:
 
1401
    ssl3_send_alert(s, SSL3_AL_FATAL, al);
 
1402
 err:
 
1403
    return (-1);
 
1404
}
 
1405
 
 
1406
int dtls1_write_app_data_bytes(SSL *s, int type, const void *buf_, int len)
 
1407
{
 
1408
    int i;
 
1409
 
 
1410
#ifndef OPENSSL_NO_SCTP
 
1411
    /*
 
1412
     * Check if we have to continue an interrupted handshake for reading
 
1413
     * belated app data with SCTP.
 
1414
     */
 
1415
    if ((SSL_in_init(s) && !s->in_handshake) ||
 
1416
        (BIO_dgram_is_sctp(SSL_get_wbio(s)) &&
 
1417
         (s->state == DTLS1_SCTP_ST_SR_READ_SOCK
 
1418
          || s->state == DTLS1_SCTP_ST_CR_READ_SOCK)))
 
1419
#else
 
1420
    if (SSL_in_init(s) && !s->in_handshake)
 
1421
#endif
 
1422
    {
 
1423
        i = s->handshake_func(s);
 
1424
        if (i < 0)
 
1425
            return (i);
 
1426
        if (i == 0) {
 
1427
            SSLerr(SSL_F_DTLS1_WRITE_APP_DATA_BYTES,
 
1428
                   SSL_R_SSL_HANDSHAKE_FAILURE);
 
1429
            return -1;
 
1430
        }
 
1431
    }
 
1432
 
 
1433
    if (len > SSL3_RT_MAX_PLAIN_LENGTH) {
 
1434
        SSLerr(SSL_F_DTLS1_WRITE_APP_DATA_BYTES, SSL_R_DTLS_MESSAGE_TOO_BIG);
 
1435
        return -1;
 
1436
    }
 
1437
 
 
1438
    i = dtls1_write_bytes(s, type, buf_, len);
 
1439
    return i;
 
1440
}
 
1441
 
 
1442
        /*
 
1443
         * this only happens when a client hello is received and a handshake
 
1444
         * is started.
 
1445
         */
 
1446
static int
 
1447
have_handshake_fragment(SSL *s, int type, unsigned char *buf,
 
1448
                        int len, int peek)
 
1449
{
 
1450
 
 
1451
    if ((type == SSL3_RT_HANDSHAKE) && (s->d1->handshake_fragment_len > 0))
 
1452
        /* (partially) satisfy request from storage */
 
1453
    {
 
1454
        unsigned char *src = s->d1->handshake_fragment;
 
1455
        unsigned char *dst = buf;
 
1456
        unsigned int k, n;
 
1457
 
 
1458
        /* peek == 0 */
 
1459
        n = 0;
 
1460
        while ((len > 0) && (s->d1->handshake_fragment_len > 0)) {
 
1461
            *dst++ = *src++;
 
1462
            len--;
 
1463
            s->d1->handshake_fragment_len--;
 
1464
            n++;
 
1465
        }
 
1466
        /* move any remaining fragment bytes: */
 
1467
        for (k = 0; k < s->d1->handshake_fragment_len; k++)
 
1468
            s->d1->handshake_fragment[k] = *src++;
 
1469
        return n;
 
1470
    }
 
1471
 
 
1472
    return 0;
 
1473
}
 
1474
 
 
1475
/*
 
1476
 * Call this to write data in records of type 'type' It will return <= 0 if
 
1477
 * not all data has been sent or non-blocking IO.
 
1478
 */
 
1479
int dtls1_write_bytes(SSL *s, int type, const void *buf, int len)
 
1480
{
 
1481
    int i;
 
1482
 
 
1483
    OPENSSL_assert(len <= SSL3_RT_MAX_PLAIN_LENGTH);
 
1484
    s->rwstate = SSL_NOTHING;
 
1485
    i = do_dtls1_write(s, type, buf, len, 0);
 
1486
    return i;
 
1487
}
 
1488
 
 
1489
int do_dtls1_write(SSL *s, int type, const unsigned char *buf,
 
1490
                   unsigned int len, int create_empty_fragment)
 
1491
{
 
1492
    unsigned char *p, *pseq;
 
1493
    int i, mac_size, clear = 0;
 
1494
    int prefix_len = 0;
 
1495
    int eivlen;
 
1496
    SSL3_RECORD *wr;
 
1497
    SSL3_BUFFER *wb;
 
1498
    SSL_SESSION *sess;
 
1499
 
 
1500
    /*
 
1501
     * first check if there is a SSL3_BUFFER still being written out.  This
 
1502
     * will happen with non blocking IO
 
1503
     */
 
1504
    if (s->s3->wbuf.left != 0) {
 
1505
        OPENSSL_assert(0);      /* XDTLS: want to see if we ever get here */
 
1506
        return (ssl3_write_pending(s, type, buf, len));
 
1507
    }
 
1508
 
 
1509
    /* If we have an alert to send, lets send it */
 
1510
    if (s->s3->alert_dispatch) {
 
1511
        i = s->method->ssl_dispatch_alert(s);
 
1512
        if (i <= 0)
 
1513
            return (i);
 
1514
        /* if it went, fall through and send more stuff */
 
1515
    }
 
1516
 
 
1517
    if (len == 0 && !create_empty_fragment)
 
1518
        return 0;
 
1519
 
 
1520
    wr = &(s->s3->wrec);
 
1521
    wb = &(s->s3->wbuf);
 
1522
    sess = s->session;
 
1523
 
 
1524
    if ((sess == NULL) ||
 
1525
        (s->enc_write_ctx == NULL) || (EVP_MD_CTX_md(s->write_hash) == NULL))
 
1526
        clear = 1;
 
1527
 
 
1528
    if (clear)
 
1529
        mac_size = 0;
 
1530
    else {
 
1531
        mac_size = EVP_MD_CTX_size(s->write_hash);
 
1532
        if (mac_size < 0)
 
1533
            goto err;
 
1534
    }
 
1535
 
 
1536
    /* DTLS implements explicit IV, so no need for empty fragments */
 
1537
#if 0
 
1538
    /*
 
1539
     * 'create_empty_fragment' is true only when this function calls itself
 
1540
     */
 
1541
    if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done
 
1542
        && SSL_version(s) != DTLS1_VERSION && SSL_version(s) != DTLS1_BAD_VER)
 
1543
    {
 
1544
        /*
 
1545
         * countermeasure against known-IV weakness in CBC ciphersuites (see
 
1546
         * http://www.openssl.org/~bodo/tls-cbc.txt)
 
1547
         */
 
1548
 
 
1549
        if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA) {
 
1550
            /*
 
1551
             * recursive function call with 'create_empty_fragment' set; this
 
1552
             * prepares and buffers the data for an empty fragment (these
 
1553
             * 'prefix_len' bytes are sent out later together with the actual
 
1554
             * payload)
 
1555
             */
 
1556
            prefix_len = s->method->do_ssl_write(s, type, buf, 0, 1);
 
1557
            if (prefix_len <= 0)
 
1558
                goto err;
 
1559
 
 
1560
            if (s->s3->wbuf.len <
 
1561
                (size_t)prefix_len + SSL3_RT_MAX_PACKET_SIZE) {
 
1562
                /* insufficient space */
 
1563
                SSLerr(SSL_F_DO_DTLS1_WRITE, ERR_R_INTERNAL_ERROR);
 
1564
                goto err;
 
1565
            }
 
1566
        }
 
1567
 
 
1568
        s->s3->empty_fragment_done = 1;
 
1569
    }
 
1570
#endif
 
1571
    p = wb->buf + prefix_len;
 
1572
 
 
1573
    /* write the header */
 
1574
 
 
1575
    *(p++) = type & 0xff;
 
1576
    wr->type = type;
 
1577
    /*
 
1578
     * Special case: for hello verify request, client version 1.0 and we
 
1579
     * haven't decided which version to use yet send back using version 1.0
 
1580
     * header: otherwise some clients will ignore it.
 
1581
     */
 
1582
    if (s->method->version == DTLS_ANY_VERSION) {
 
1583
        *(p++) = DTLS1_VERSION >> 8;
 
1584
        *(p++) = DTLS1_VERSION & 0xff;
 
1585
    } else {
 
1586
        *(p++) = s->version >> 8;
 
1587
        *(p++) = s->version & 0xff;
 
1588
    }
 
1589
 
 
1590
    /* field where we are to write out packet epoch, seq num and len */
 
1591
    pseq = p;
 
1592
    p += 10;
 
1593
 
 
1594
    /* Explicit IV length, block ciphers appropriate version flag */
 
1595
    if (s->enc_write_ctx) {
 
1596
        int mode = EVP_CIPHER_CTX_mode(s->enc_write_ctx);
 
1597
        if (mode == EVP_CIPH_CBC_MODE) {
 
1598
            eivlen = EVP_CIPHER_CTX_iv_length(s->enc_write_ctx);
 
1599
            if (eivlen <= 1)
 
1600
                eivlen = 0;
 
1601
        }
 
1602
        /* Need explicit part of IV for GCM mode */
 
1603
        else if (mode == EVP_CIPH_GCM_MODE)
 
1604
            eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN;
 
1605
        else
 
1606
            eivlen = 0;
 
1607
    } else
 
1608
        eivlen = 0;
 
1609
 
 
1610
    /* lets setup the record stuff. */
 
1611
    wr->data = p + eivlen;      /* make room for IV in case of CBC */
 
1612
    wr->length = (int)len;
 
1613
    wr->input = (unsigned char *)buf;
 
1614
 
 
1615
    /*
 
1616
     * we now 'read' from wr->input, wr->length bytes into wr->data
 
1617
     */
 
1618
 
 
1619
    /* first we compress */
 
1620
    if (s->compress != NULL) {
 
1621
        if (!ssl3_do_compress(s)) {
 
1622
            SSLerr(SSL_F_DO_DTLS1_WRITE, SSL_R_COMPRESSION_FAILURE);
 
1623
            goto err;
 
1624
        }
 
1625
    } else {
 
1626
        memcpy(wr->data, wr->input, wr->length);
 
1627
        wr->input = wr->data;
 
1628
    }
 
1629
 
 
1630
    /*
 
1631
     * we should still have the output to wr->data and the input from
 
1632
     * wr->input.  Length should be wr->length. wr->data still points in the
 
1633
     * wb->buf
 
1634
     */
 
1635
 
 
1636
    if (mac_size != 0) {
 
1637
        if (s->method->ssl3_enc->mac(s, &(p[wr->length + eivlen]), 1) < 0)
 
1638
            goto err;
 
1639
        wr->length += mac_size;
 
1640
    }
 
1641
 
 
1642
    /* this is true regardless of mac size */
 
1643
    wr->input = p;
 
1644
    wr->data = p;
 
1645
 
 
1646
    if (eivlen)
 
1647
        wr->length += eivlen;
 
1648
 
 
1649
    if (s->method->ssl3_enc->enc(s, 1) < 1)
 
1650
        goto err;
 
1651
 
 
1652
    /* record length after mac and block padding */
 
1653
    /*
 
1654
     * if (type == SSL3_RT_APPLICATION_DATA || (type == SSL3_RT_ALERT && !
 
1655
     * SSL_in_init(s)))
 
1656
     */
 
1657
 
 
1658
    /* there's only one epoch between handshake and app data */
 
1659
 
 
1660
    s2n(s->d1->w_epoch, pseq);
 
1661
 
 
1662
    /* XDTLS: ?? */
 
1663
    /*
 
1664
     * else s2n(s->d1->handshake_epoch, pseq);
 
1665
     */
 
1666
 
 
1667
    memcpy(pseq, &(s->s3->write_sequence[2]), 6);
 
1668
    pseq += 6;
 
1669
    s2n(wr->length, pseq);
 
1670
 
 
1671
    if (s->msg_callback)
 
1672
        s->msg_callback(1, 0, SSL3_RT_HEADER, pseq - DTLS1_RT_HEADER_LENGTH,
 
1673
                        DTLS1_RT_HEADER_LENGTH, s, s->msg_callback_arg);
 
1674
 
 
1675
    /*
 
1676
     * we should now have wr->data pointing to the encrypted data, which is
 
1677
     * wr->length long
 
1678
     */
 
1679
    wr->type = type;            /* not needed but helps for debugging */
 
1680
    wr->length += DTLS1_RT_HEADER_LENGTH;
 
1681
 
 
1682
#if 0                           /* this is now done at the message layer */
 
1683
    /* buffer the record, making it easy to handle retransmits */
 
1684
    if (type == SSL3_RT_HANDSHAKE || type == SSL3_RT_CHANGE_CIPHER_SPEC)
 
1685
        dtls1_buffer_record(s, wr->data, wr->length,
 
1686
                            *((PQ_64BIT *) & (s->s3->write_sequence[0])));
 
1687
#endif
 
1688
 
 
1689
    ssl3_record_sequence_update(&(s->s3->write_sequence[0]));
 
1690
 
 
1691
    if (create_empty_fragment) {
 
1692
        /*
 
1693
         * we are in a recursive call; just return the length, don't write
 
1694
         * out anything here
 
1695
         */
 
1696
        return wr->length;
 
1697
    }
 
1698
 
 
1699
    /* now let's set up wb */
 
1700
    wb->left = prefix_len + wr->length;
 
1701
    wb->offset = 0;
 
1702
 
 
1703
    /*
 
1704
     * memorize arguments so that ssl3_write_pending can detect bad write
 
1705
     * retries later
 
1706
     */
 
1707
    s->s3->wpend_tot = len;
 
1708
    s->s3->wpend_buf = buf;
 
1709
    s->s3->wpend_type = type;
 
1710
    s->s3->wpend_ret = len;
 
1711
 
 
1712
    /* we now just need to write the buffer */
 
1713
    return ssl3_write_pending(s, type, buf, len);
 
1714
 err:
 
1715
    return -1;
 
1716
}
 
1717
 
 
1718
static int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap)
 
1719
{
 
1720
    int cmp;
 
1721
    unsigned int shift;
 
1722
    const unsigned char *seq = s->s3->read_sequence;
 
1723
 
 
1724
    cmp = satsub64be(seq, bitmap->max_seq_num);
 
1725
    if (cmp > 0) {
 
1726
        memcpy(s->s3->rrec.seq_num, seq, 8);
 
1727
        return 1;               /* this record in new */
 
1728
    }
 
1729
    shift = -cmp;
 
1730
    if (shift >= sizeof(bitmap->map) * 8)
 
1731
        return 0;               /* stale, outside the window */
 
1732
    else if (bitmap->map & (1UL << shift))
 
1733
        return 0;               /* record previously received */
 
1734
 
 
1735
    memcpy(s->s3->rrec.seq_num, seq, 8);
 
1736
    return 1;
 
1737
}
 
1738
 
 
1739
static void dtls1_record_bitmap_update(SSL *s, DTLS1_BITMAP *bitmap)
 
1740
{
 
1741
    int cmp;
 
1742
    unsigned int shift;
 
1743
    const unsigned char *seq = s->s3->read_sequence;
 
1744
 
 
1745
    cmp = satsub64be(seq, bitmap->max_seq_num);
 
1746
    if (cmp > 0) {
 
1747
        shift = cmp;
 
1748
        if (shift < sizeof(bitmap->map) * 8)
 
1749
            bitmap->map <<= shift, bitmap->map |= 1UL;
 
1750
        else
 
1751
            bitmap->map = 1UL;
 
1752
        memcpy(bitmap->max_seq_num, seq, 8);
 
1753
    } else {
 
1754
        shift = -cmp;
 
1755
        if (shift < sizeof(bitmap->map) * 8)
 
1756
            bitmap->map |= 1UL << shift;
 
1757
    }
 
1758
}
 
1759
 
 
1760
int dtls1_dispatch_alert(SSL *s)
 
1761
{
 
1762
    int i, j;
 
1763
    void (*cb) (const SSL *ssl, int type, int val) = NULL;
 
1764
    unsigned char buf[DTLS1_AL_HEADER_LENGTH];
 
1765
    unsigned char *ptr = &buf[0];
 
1766
 
 
1767
    s->s3->alert_dispatch = 0;
 
1768
 
 
1769
    memset(buf, 0x00, sizeof(buf));
 
1770
    *ptr++ = s->s3->send_alert[0];
 
1771
    *ptr++ = s->s3->send_alert[1];
 
1772
 
 
1773
#ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE
 
1774
    if (s->s3->send_alert[1] == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE) {
 
1775
        s2n(s->d1->handshake_read_seq, ptr);
 
1776
# if 0
 
1777
        if (s->d1->r_msg_hdr.frag_off == 0)
 
1778
            /*
 
1779
             * waiting for a new msg
 
1780
             */
 
1781
            else
 
1782
            s2n(s->d1->r_msg_hdr.seq, ptr); /* partial msg read */
 
1783
# endif
 
1784
 
 
1785
# if 0
 
1786
        fprintf(stderr,
 
1787
                "s->d1->handshake_read_seq = %d, s->d1->r_msg_hdr.seq = %d\n",
 
1788
                s->d1->handshake_read_seq, s->d1->r_msg_hdr.seq);
 
1789
# endif
 
1790
        l2n3(s->d1->r_msg_hdr.frag_off, ptr);
 
1791
    }
 
1792
#endif
 
1793
 
 
1794
    i = do_dtls1_write(s, SSL3_RT_ALERT, &buf[0], sizeof(buf), 0);
 
1795
    if (i <= 0) {
 
1796
        s->s3->alert_dispatch = 1;
 
1797
        /* fprintf( stderr, "not done with alert\n" ); */
 
1798
    } else {
 
1799
        if (s->s3->send_alert[0] == SSL3_AL_FATAL
 
1800
#ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE
 
1801
            || s->s3->send_alert[1] == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE
 
1802
#endif
 
1803
            )
 
1804
            (void)BIO_flush(s->wbio);
 
1805
 
 
1806
        if (s->msg_callback)
 
1807
            s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3->send_alert,
 
1808
                            2, s, s->msg_callback_arg);
 
1809
 
 
1810
        if (s->info_callback != NULL)
 
1811
            cb = s->info_callback;
 
1812
        else if (s->ctx->info_callback != NULL)
 
1813
            cb = s->ctx->info_callback;
 
1814
 
 
1815
        if (cb != NULL) {
 
1816
            j = (s->s3->send_alert[0] << 8) | s->s3->send_alert[1];
 
1817
            cb(s, SSL_CB_WRITE_ALERT, j);
 
1818
        }
 
1819
    }
 
1820
    return (i);
 
1821
}
 
1822
 
 
1823
static DTLS1_BITMAP *dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr,
 
1824
                                      unsigned int *is_next_epoch)
 
1825
{
 
1826
 
 
1827
    *is_next_epoch = 0;
 
1828
 
 
1829
    /* In current epoch, accept HM, CCS, DATA, & ALERT */
 
1830
    if (rr->epoch == s->d1->r_epoch)
 
1831
        return &s->d1->bitmap;
 
1832
 
 
1833
    /* Only HM and ALERT messages can be from the next epoch */
 
1834
    else if (rr->epoch == (unsigned long)(s->d1->r_epoch + 1) &&
 
1835
             (rr->type == SSL3_RT_HANDSHAKE || rr->type == SSL3_RT_ALERT)) {
 
1836
        *is_next_epoch = 1;
 
1837
        return &s->d1->next_bitmap;
 
1838
    }
 
1839
 
 
1840
    return NULL;
 
1841
}
 
1842
 
 
1843
#if 0
 
1844
static int
 
1845
dtls1_record_needs_buffering(SSL *s, SSL3_RECORD *rr,
 
1846
                             unsigned short *priority, unsigned long *offset)
 
1847
{
 
1848
 
 
1849
    /* alerts are passed up immediately */
 
1850
    if (rr->type == SSL3_RT_APPLICATION_DATA || rr->type == SSL3_RT_ALERT)
 
1851
        return 0;
 
1852
 
 
1853
    /*
 
1854
     * Only need to buffer if a handshake is underway. (this implies that
 
1855
     * Hello Request and Client Hello are passed up immediately)
 
1856
     */
 
1857
    if (SSL_in_init(s)) {
 
1858
        unsigned char *data = rr->data;
 
1859
        /* need to extract the HM/CCS sequence number here */
 
1860
        if (rr->type == SSL3_RT_HANDSHAKE ||
 
1861
            rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) {
 
1862
            unsigned short seq_num;
 
1863
            struct hm_header_st msg_hdr;
 
1864
            struct ccs_header_st ccs_hdr;
 
1865
 
 
1866
            if (rr->type == SSL3_RT_HANDSHAKE) {
 
1867
                dtls1_get_message_header(data, &msg_hdr);
 
1868
                seq_num = msg_hdr.seq;
 
1869
                *offset = msg_hdr.frag_off;
 
1870
            } else {
 
1871
                dtls1_get_ccs_header(data, &ccs_hdr);
 
1872
                seq_num = ccs_hdr.seq;
 
1873
                *offset = 0;
 
1874
            }
 
1875
 
 
1876
            /*
 
1877
             * this is either a record we're waiting for, or a retransmit of
 
1878
             * something we happened to previously receive (higher layers
 
1879
             * will drop the repeat silently
 
1880
             */
 
1881
            if (seq_num < s->d1->handshake_read_seq)
 
1882
                return 0;
 
1883
            if (rr->type == SSL3_RT_HANDSHAKE &&
 
1884
                seq_num == s->d1->handshake_read_seq &&
 
1885
                msg_hdr.frag_off < s->d1->r_msg_hdr.frag_off)
 
1886
                return 0;
 
1887
            else if (seq_num == s->d1->handshake_read_seq &&
 
1888
                     (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC ||
 
1889
                      msg_hdr.frag_off == s->d1->r_msg_hdr.frag_off))
 
1890
                return 0;
 
1891
            else {
 
1892
                *priority = seq_num;
 
1893
                return 1;
 
1894
            }
 
1895
        } else                  /* unknown record type */
 
1896
            return 0;
 
1897
    }
 
1898
 
 
1899
    return 0;
 
1900
}
 
1901
#endif
 
1902
 
 
1903
void dtls1_reset_seq_numbers(SSL *s, int rw)
 
1904
{
 
1905
    unsigned char *seq;
 
1906
    unsigned int seq_bytes = sizeof(s->s3->read_sequence);
 
1907
 
 
1908
    if (rw & SSL3_CC_READ) {
 
1909
        seq = s->s3->read_sequence;
 
1910
        s->d1->r_epoch++;
 
1911
        memcpy(&(s->d1->bitmap), &(s->d1->next_bitmap), sizeof(DTLS1_BITMAP));
 
1912
        memset(&(s->d1->next_bitmap), 0x00, sizeof(DTLS1_BITMAP));
 
1913
    } else {
 
1914
        seq = s->s3->write_sequence;
 
1915
        memcpy(s->d1->last_write_sequence, seq,
 
1916
               sizeof(s->s3->write_sequence));
 
1917
        s->d1->w_epoch++;
 
1918
    }
 
1919
 
 
1920
    memset(seq, 0x00, seq_bytes);
 
1921
}