Debian Codegraph @

external/boringssl/ssl/s3_pkt.c

raw
1 /* Copyright (C) 1995-1998 Eric Young ([email protected])
2 * All rights reserved.
3 *
4 * This package is an SSL implementation written
5 * by Eric Young ([email protected]).
6 * The implementation was written so as to conform with Netscapes SSL.
7 *
8 * This library is free for commercial and non-commercial use as long as
9 * the following conditions are aheared to. The following conditions
10 * apply to all code found in this distribution, be it the RC4, RSA,
11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
12 * included with this distribution is covered by the same copyright terms
13 * except that the holder is Tim Hudson ([email protected]).
14 *
15 * Copyright remains Eric Young's, and as such any Copyright notices in
16 * the code are not to be removed.
17 * If this package is used in a product, Eric Young should be given attribution
18 * as the author of the parts of the library used.
19 * This can be in the form of a textual message at program startup or
20 * in documentation (online or textual) provided with the package.
21 *
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
24 * are met:
25 * 1. Redistributions of source code must retain the copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 * must display the following acknowledgement:
32 * "This product includes cryptographic software written by
33 * Eric Young ([email protected])"
34 * The word 'cryptographic' can be left out if the rouines from the library
35 * being used are not cryptographic related :-).
36 * 4. If you include any Windows specific code (or a derivative thereof) from
37 * the apps directory (application code) you must include an acknowledgement:
38 * "This product includes software written by Tim Hudson ([email protected])"
39 *
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50 * SUCH DAMAGE.
51 *
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed. i.e. this code cannot simply be
54 * copied and put under another distribution licence
55 * [including the GNU Public Licence.]
56 */
57 /* ====================================================================
58 * Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved.
59 *
60 * Redistribution and use in source and binary forms, with or without
61 * modification, are permitted provided that the following conditions
62 * are met:
63 *
64 * 1. Redistributions of source code must retain the above copyright
65 * notice, this list of conditions and the following disclaimer.
66 *
67 * 2. Redistributions in binary form must reproduce the above copyright
68 * notice, this list of conditions and the following disclaimer in
69 * the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3. All advertising materials mentioning features or use of this
73 * software must display the following acknowledgment:
74 * "This product includes software developed by the OpenSSL Project
75 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
76 *
77 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
78 * endorse or promote products derived from this software without
79 * prior written permission. For written permission, please contact
80 * [email protected].
81 *
82 * 5. Products derived from this software may not be called "OpenSSL"
83 * nor may "OpenSSL" appear in their names without prior written
84 * permission of the OpenSSL Project.
85 *
86 * 6. Redistributions of any form whatsoever must retain the following
87 * acknowledgment:
88 * "This product includes software developed by the OpenSSL Project
89 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
90 *
91 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
92 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
93 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
94 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
95 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
96 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
97 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
98 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
99 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
100 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
101 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
102 * OF THE POSSIBILITY OF SUCH DAMAGE.
103 * ====================================================================
104 *
105 * This product includes cryptographic software written by Eric Young
106 * ([email protected]). This product includes software written by Tim
107 * Hudson ([email protected]). */
108
109 #include <openssl/ssl.h>
110
111 #include <assert.h>
112 #include <limits.h>
113 #include <string.h>
114
115 #include <openssl/buf.h>
116 #include <openssl/err.h>
117 #include <openssl/evp.h>
118 #include <openssl/mem.h>
119 #include <openssl/rand.h>
120
121 #include "internal.h"
122
123
124 static int do_ssl3_write(SSL *ssl, int type, const uint8_t *buf, unsigned len);
125
126 /* ssl3_get_record reads a new input record. On success, it places it in
127 * |ssl->s3->rrec| and returns one. Otherwise it returns <= 0 on error or if
128 * more data is needed. */
129 static int ssl3_get_record(SSL *ssl) {
130 again:
131 switch (ssl->s3->recv_shutdown) {
132 case ssl_shutdown_none:
133 break;
134 case ssl_shutdown_fatal_alert:
135 OPENSSL_PUT_ERROR(SSL, SSL_R_PROTOCOL_IS_SHUTDOWN);
136 return -1;
137 case ssl_shutdown_close_notify:
138 return 0;
139 }
140
141 CBS body;
142 uint8_t type, alert;
143 size_t consumed;
144 enum ssl_open_record_t open_ret =
145 tls_open_record(ssl, &type, &body, &consumed, &alert,
146 ssl_read_buffer(ssl), ssl_read_buffer_len(ssl));
147 if (open_ret != ssl_open_record_partial) {
148 ssl_read_buffer_consume(ssl, consumed);
149 }
150 switch (open_ret) {
151 case ssl_open_record_partial: {
152 int read_ret = ssl_read_buffer_extend_to(ssl, consumed);
153 if (read_ret <= 0) {
154 return read_ret;
155 }
156 goto again;
157 }
158
159 case ssl_open_record_success:
160 if (CBS_len(&body) > 0xffff) {
161 OPENSSL_PUT_ERROR(SSL, ERR_R_OVERFLOW);
162 return -1;
163 }
164
165 SSL3_RECORD *rr = &ssl->s3->rrec;
166 rr->type = type;
167 rr->length = (uint16_t)CBS_len(&body);
168 rr->data = (uint8_t *)CBS_data(&body);
169 return 1;
170
171 case ssl_open_record_discard:
172 goto again;
173
174 case ssl_open_record_close_notify:
175 return 0;
176
177 case ssl_open_record_fatal_alert:
178 return -1;
179
180 case ssl_open_record_error:
181 ssl3_send_alert(ssl, SSL3_AL_FATAL, alert);
182 return -1;
183 }
184
185 assert(0);
186 OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
187 return -1;
188 }
189
190 int ssl3_write_app_data(SSL *ssl, const void *buf, int len) {
191 assert(!SSL_in_init(ssl) || SSL_in_false_start(ssl));
192
193 return ssl3_write_bytes(ssl, SSL3_RT_APPLICATION_DATA, buf, len);
194 }
195
196 /* Call this to write data in records of type |type|. It will return <= 0 if
197 * not all data has been sent or non-blocking IO. */
198 int ssl3_write_bytes(SSL *ssl, int type, const void *buf_, int len) {
199 const uint8_t *buf = buf_;
200 unsigned tot, n, nw;
201
202 assert(ssl->s3->wnum <= INT_MAX);
203 tot = ssl->s3->wnum;
204 ssl->s3->wnum = 0;
205
206 /* Ensure that if we end up with a smaller value of data to write out than
207 * the the original len from a write which didn't complete for non-blocking
208 * I/O and also somehow ended up avoiding the check for this in
209 * ssl3_write_pending/SSL_R_BAD_WRITE_RETRY as it must never be possible to
210 * end up with (len-tot) as a large number that will then promptly send
211 * beyond the end of the users buffer ... so we trap and report the error in
212 * a way the user will notice. */
213 if (len < 0 || (size_t)len < tot) {
214 OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_LENGTH);
215 return -1;
216 }
217
218 n = (len - tot);
219 for (;;) {
220 /* max contains the maximum number of bytes that we can put into a
221 * record. */
222 unsigned max = ssl->max_send_fragment;
223 if (n > max) {
224 nw = max;
225 } else {
226 nw = n;
227 }
228
229 int ret = do_ssl3_write(ssl, type, &buf[tot], nw);
230 if (ret <= 0) {
231 ssl->s3->wnum = tot;
232 return ret;
233 }
234
235 if (ret == (int)n || (type == SSL3_RT_APPLICATION_DATA &&
236 (ssl->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))) {
237 return tot + ret;
238 }
239
240 n -= ret;
241 tot += ret;
242 }
243 }
244
245 static int ssl3_write_pending(SSL *ssl, int type, const uint8_t *buf,
246 unsigned int len) {
247 if (ssl->s3->wpend_tot > (int)len ||
248 (ssl->s3->wpend_buf != buf &&
249 !(ssl->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)) ||
250 ssl->s3->wpend_type != type) {
251 OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_WRITE_RETRY);
252 return -1;
253 }
254
255 int ret = ssl_write_buffer_flush(ssl);
256 if (ret <= 0) {
257 return ret;
258 }
259 return ssl->s3->wpend_ret;
260 }
261
262 /* do_ssl3_write writes an SSL record of the given type. */
263 static int do_ssl3_write(SSL *ssl, int type, const uint8_t *buf, unsigned len) {
264 /* If there is still data from the previous record, flush it. */
265 if (ssl_write_buffer_is_pending(ssl)) {
266 return ssl3_write_pending(ssl, type, buf, len);
267 }
268
269 /* If we have an alert to send, lets send it */
270 if (ssl->s3->alert_dispatch) {
271 int ret = ssl->method->ssl_dispatch_alert(ssl);
272 if (ret <= 0) {
273 return ret;
274 }
275 /* if it went, fall through and send more stuff */
276 }
277
278 if (len > SSL3_RT_MAX_PLAIN_LENGTH) {
279 OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
280 return -1;
281 }
282
283 if (len == 0) {
284 return 0;
285 }
286
287 size_t max_out = len + ssl_max_seal_overhead(ssl);
288 if (max_out < len) {
289 OPENSSL_PUT_ERROR(SSL, ERR_R_OVERFLOW);
290 return -1;
291 }
292 uint8_t *out;
293 size_t ciphertext_len;
294 if (!ssl_write_buffer_init(ssl, &out, max_out) ||
295 !tls_seal_record(ssl, out, &ciphertext_len, max_out, type, buf, len)) {
296 return -1;
297 }
298 ssl_write_buffer_set_len(ssl, ciphertext_len);
299
300 /* memorize arguments so that ssl3_write_pending can detect bad write retries
301 * later */
302 ssl->s3->wpend_tot = len;
303 ssl->s3->wpend_buf = buf;
304 ssl->s3->wpend_type = type;
305 ssl->s3->wpend_ret = len;
306
307 /* we now just need to write the buffer */
308 return ssl3_write_pending(ssl, type, buf, len);
309 }
310
311 int ssl3_read_app_data(SSL *ssl, uint8_t *buf, int len, int peek) {
312 assert(!SSL_in_init(ssl));
313 assert(ssl->s3->initial_handshake_complete);
314
315 return ssl3_read_bytes(ssl, SSL3_RT_APPLICATION_DATA, buf, len, peek);
316 }
317
318 int ssl3_read_change_cipher_spec(SSL *ssl) {
319 SSL3_RECORD *rr = &ssl->s3->rrec;
320
321 if (rr->length == 0) {
322 int ret = ssl3_get_record(ssl);
323 if (ret <= 0) {
324 return ret;
325 }
326 }
327
328 if (rr->type != SSL3_RT_CHANGE_CIPHER_SPEC) {
329 ssl3_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
330 OPENSSL_PUT_ERROR(SSL, SSL_R_UNEXPECTED_RECORD);
331 return -1;
332 }
333
334 if (rr->length != 1 || rr->data[0] != SSL3_MT_CCS) {
335 OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_CHANGE_CIPHER_SPEC);
336 ssl3_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_ILLEGAL_PARAMETER);
337 return -1;
338 }
339
340 ssl_do_msg_callback(ssl, 0 /* read */, ssl->version,
341 SSL3_RT_CHANGE_CIPHER_SPEC, rr->data, rr->length);
342
343 rr->length = 0;
344 ssl_read_buffer_discard(ssl);
345 return 1;
346 }
347
348 void ssl3_read_close_notify(SSL *ssl) {
349 /* Read records until an error or close_notify. */
350 while (ssl3_get_record(ssl) > 0) {
351 ;
352 }
353 }
354
355 static int ssl3_can_renegotiate(SSL *ssl) {
356 switch (ssl->renegotiate_mode) {
357 case ssl_renegotiate_never:
358 return 0;
359 case ssl_renegotiate_once:
360 return ssl->s3->total_renegotiations == 0;
361 case ssl_renegotiate_freely:
362 return 1;
363 case ssl_renegotiate_ignore:
364 return 1;
365 }
366
367 assert(0);
368 return 0;
369 }
370
371 /* Return up to 'len' payload bytes received in 'type' records.
372 * 'type' is one of the following:
373 *
374 * - SSL3_RT_HANDSHAKE (when ssl3_get_message calls us)
375 * - SSL3_RT_APPLICATION_DATA (when ssl3_read_app_data calls us)
376 *
377 * If we don't have stored data to work from, read a SSL/TLS record first
378 * (possibly multiple records if we still don't have anything to return).
379 *
380 * This function must handle any surprises the peer may have for us, such as
381 * Alert records (e.g. close_notify) or renegotiation requests. */
382 int ssl3_read_bytes(SSL *ssl, int type, uint8_t *buf, int len, int peek) {
383 int al, i, ret;
384 unsigned int n;
385 SSL3_RECORD *rr;
386
387 if ((type != SSL3_RT_APPLICATION_DATA && type != SSL3_RT_HANDSHAKE) ||
388 (peek && type != SSL3_RT_APPLICATION_DATA)) {
389 OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
390 return -1;
391 }
392
393 start:
394 /* ssl->s3->rrec.type - is the type of record
395 * ssl->s3->rrec.data - data
396 * ssl->s3->rrec.off - offset into 'data' for next read
397 * ssl->s3->rrec.length - number of bytes. */
398 rr = &ssl->s3->rrec;
399
400 /* get new packet if necessary */
401 if (rr->length == 0) {
402 ret = ssl3_get_record(ssl);
403 if (ret <= 0) {
404 return ret;
405 }
406 }
407
408 /* we now have a packet which can be read and processed */
409
410 if (type == rr->type) {
411 /* Discard empty records. */
412 if (rr->length == 0) {
413 goto start;
414 }
415
416 if (len <= 0) {
417 return len;
418 }
419
420 if ((unsigned int)len > rr->length) {
421 n = rr->length;
422 } else {
423 n = (unsigned int)len;
424 }
425
426 memcpy(buf, rr->data, n);
427 if (!peek) {
428 rr->length -= n;
429 rr->data += n;
430 if (rr->length == 0) {
431 /* The record has been consumed, so we may now clear the buffer. */
432 ssl_read_buffer_discard(ssl);
433 }
434 }
435
436 return n;
437 }
438
439 /* Process unexpected records. */
440
441 if (type == SSL3_RT_APPLICATION_DATA && rr->type == SSL3_RT_HANDSHAKE) {
442 /* If peer renegotiations are disabled, all out-of-order handshake records
443 * are fatal. Renegotiations as a server are never supported. */
444 if (ssl->server || !ssl3_can_renegotiate(ssl)) {
445 al = SSL_AD_NO_RENEGOTIATION;
446 OPENSSL_PUT_ERROR(SSL, SSL_R_NO_RENEGOTIATION);
447 goto f_err;
448 }
449
450 /* This must be a HelloRequest, possibly fragmented over multiple records.
451 * Consume data from the handshake protocol until it is complete. */
452 static const uint8_t kHelloRequest[] = {SSL3_MT_HELLO_REQUEST, 0, 0, 0};
453 while (ssl->s3->hello_request_len < sizeof(kHelloRequest)) {
454 if (rr->length == 0) {
455 /* Get a new record. */
456 goto start;
457 }
458 if (rr->data[0] != kHelloRequest[ssl->s3->hello_request_len]) {
459 al = SSL_AD_DECODE_ERROR;
460 OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_HELLO_REQUEST);
461 goto f_err;
462 }
463 rr->data++;
464 rr->length--;
465 ssl->s3->hello_request_len++;
466 }
467 ssl->s3->hello_request_len = 0;
468
469 ssl_do_msg_callback(ssl, 0 /* read */, ssl->version, SSL3_RT_HANDSHAKE,
470 kHelloRequest, sizeof(kHelloRequest));
471
472 if (ssl->renegotiate_mode == ssl_renegotiate_ignore) {
473 goto start;
474 }
475
476 /* Renegotiation is only supported at quiescent points in the application
477 * protocol, namely in HTTPS, just before reading the HTTP response. Require
478 * the record-layer be idle and avoid complexities of sending a handshake
479 * record while an application_data record is being written. */
480 if (ssl_write_buffer_is_pending(ssl)) {
481 al = SSL_AD_NO_RENEGOTIATION;
482 OPENSSL_PUT_ERROR(SSL, SSL_R_NO_RENEGOTIATION);
483 goto f_err;
484 }
485
486 /* Begin a new handshake. */
487 ssl->s3->total_renegotiations++;
488 ssl->state = SSL_ST_CONNECT;
489 i = ssl->handshake_func(ssl);
490 if (i < 0) {
491 return i;
492 }
493 if (i == 0) {
494 OPENSSL_PUT_ERROR(SSL, SSL_R_SSL_HANDSHAKE_FAILURE);
495 return -1;
496 }
497
498 /* The handshake completed synchronously. Continue reading records. */
499 goto start;
500 }
501
502 al = SSL_AD_UNEXPECTED_MESSAGE;
503 OPENSSL_PUT_ERROR(SSL, SSL_R_UNEXPECTED_RECORD);
504
505 f_err:
506 ssl3_send_alert(ssl, SSL3_AL_FATAL, al);
507 return -1;
508 }
509
510 int ssl3_send_alert(SSL *ssl, int level, int desc) {
511 /* It is illegal to send an alert when we've already sent a closing one. */
512 if (ssl->s3->send_shutdown != ssl_shutdown_none) {
513 OPENSSL_PUT_ERROR(SSL, SSL_R_PROTOCOL_IS_SHUTDOWN);
514 return -1;
515 }
516
517 if (level == SSL3_AL_FATAL) {
518 if (ssl->session != NULL) {
519 SSL_CTX_remove_session(ssl->ctx, ssl->session);
520 }
521 ssl->s3->send_shutdown = ssl_shutdown_fatal_alert;
522 } else if (level == SSL3_AL_WARNING && desc == SSL_AD_CLOSE_NOTIFY) {
523 ssl->s3->send_shutdown = ssl_shutdown_close_notify;
524 }
525
526 ssl->s3->alert_dispatch = 1;
527 ssl->s3->send_alert[0] = level;
528 ssl->s3->send_alert[1] = desc;
529 if (!ssl_write_buffer_is_pending(ssl)) {
530 /* Nothing is being written out, so the alert may be dispatched
531 * immediately. */
532 return ssl->method->ssl_dispatch_alert(ssl);
533 }
534
535 /* The alert will be dispatched later. */
536 return -1;
537 }
538
539 int ssl3_dispatch_alert(SSL *ssl) {
540 ssl->s3->alert_dispatch = 0;
541 int ret = do_ssl3_write(ssl, SSL3_RT_ALERT, &ssl->s3->send_alert[0], 2);
542 if (ret <= 0) {
543 ssl->s3->alert_dispatch = 1;
544 return ret;
545 }
546
547 /* If the alert is fatal, flush the BIO now. */
548 if (ssl->s3->send_alert[0] == SSL3_AL_FATAL) {
549 BIO_flush(ssl->wbio);
550 }
551
552 ssl_do_msg_callback(ssl, 1 /* write */, ssl->version, SSL3_RT_ALERT,
553 ssl->s3->send_alert, 2);
554
555 int alert = (ssl->s3->send_alert[0] << 8) | ssl->s3->send_alert[1];
556 ssl_do_info_callback(ssl, SSL_CB_WRITE_ALERT, alert);
557
558 return 1;
559 }