Lines Matching refs:ssl
4 * This package is an SSL implementation written
6 * The implementation was written so as to conform with Netscapes SSL.
11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
109 #include <openssl/ssl.h>
125 static int do_ssl3_write(SSL *ssl, int type, const uint8_t *buf, unsigned len);
132 * |ssl->s3->rrec| and returns one. Otherwise it returns <= 0 on error or if
134 static int ssl3_get_record(SSL *ssl) {
138 ret = ssl_read_buffer_extend_to(ssl, ssl_record_prefix_len(ssl));
142 assert(ssl_read_buffer_len(ssl) >= ssl_record_prefix_len(ssl));
144 uint8_t *out = ssl_read_buffer(ssl) + ssl_record_prefix_len(ssl);
145 size_t max_out = ssl_read_buffer_len(ssl) - ssl_record_prefix_len(ssl);
148 switch (tls_open_record(ssl, &type, out, &len, &consumed, &alert, max_out,
149 ssl_read_buffer(ssl), ssl_read_buffer_len(ssl))) {
151 ssl_read_buffer_consume(ssl, consumed);
154 OPENSSL_PUT_ERROR(SSL, ERR_R_OVERFLOW);
158 SSL3_RECORD *rr = &ssl->s3->rrec;
165 ret = ssl_read_buffer_extend_to(ssl, consumed);
172 ssl_read_buffer_consume(ssl, consumed);
176 ssl3_send_alert(ssl, SSL3_AL_FATAL, alert);
181 OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
185 int ssl3_write_app_data(SSL *ssl, const void *buf, int len) {
186 return ssl3_write_bytes(ssl, SSL3_RT_APPLICATION_DATA, buf, len);
191 int ssl3_write_bytes(SSL *ssl, int type, const void *buf_, int len) {
196 ssl->rwstate = SSL_NOTHING;
197 assert(ssl->s3->wnum <= INT_MAX);
198 tot = ssl->s3->wnum;
199 ssl->s3->wnum = 0;
201 if (!ssl->in_handshake && SSL_in_init(ssl) && !SSL_in_false_start(ssl)) {
202 i = ssl->handshake_func(ssl);
207 OPENSSL_PUT_ERROR(SSL, SSL_R_SSL_HANDSHAKE_FAILURE);
220 OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_LENGTH);
228 unsigned max = ssl->max_send_fragment;
235 i = do_ssl3_write(ssl, type, &buf[tot], nw);
237 ssl->s3->wnum = tot;
242 (ssl->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))) {
251 static int ssl3_write_pending(SSL *ssl, int type, const uint8_t *buf,
253 if (ssl->s3->wpend_tot > (int)len ||
254 (ssl->s3->wpend_buf != buf &&
255 !(ssl->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)) ||
256 ssl->s3->wpend_type != type) {
257 OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_WRITE_RETRY);
261 int ret = ssl_write_buffer_flush(ssl);
265 return ssl->s3->wpend_ret;
268 /* do_ssl3_write writes an SSL record of the given type. */
269 static int do_ssl3_write(SSL *ssl, int type, const uint8_t *buf, unsigned len) {
271 if (ssl_write_buffer_is_pending(ssl)) {
272 return ssl3_write_pending(ssl, type, buf, len);
276 if (ssl->s3->alert_dispatch) {
277 int ret = ssl->method->ssl_dispatch_alert(ssl);
285 OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
293 size_t max_out = len + ssl_max_seal_overhead(ssl);
295 OPENSSL_PUT_ERROR(SSL, ERR_R_OVERFLOW);
300 if (!ssl_write_buffer_init(ssl, &out, max_out) ||
301 !tls_seal_record(ssl, out, &ciphertext_len, max_out, type, buf, len)) {
304 ssl_write_buffer_set_len(ssl, ciphertext_len);
308 ssl->s3->wpend_tot = len;
309 ssl->s3->wpend_buf = buf;
310 ssl->s3->wpend_type = type;
311 ssl->s3->wpend_ret = len;
314 return ssl3_write_pending(ssl, type, buf, len);
317 int ssl3_read_app_data(SSL *ssl, uint8_t *buf, int len, int peek) {
318 return ssl3_read_bytes(ssl, SSL3_RT_APPLICATION_DATA, buf, len, peek);
321 int ssl3_read_change_cipher_spec(SSL *ssl) {
323 int ret = ssl3_read_bytes(ssl, SSL3_RT_CHANGE_CIPHER_SPEC, &byte, 1 /* len */,
330 if (ssl->s3->rrec.length != 0 || byte != SSL3_MT_CCS) {
331 OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_CHANGE_CIPHER_SPEC);
332 ssl3_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_ILLEGAL_PARAMETER);
336 if (ssl->msg_callback != NULL) {
337 ssl->msg_callback(0, ssl->version, SSL3_RT_CHANGE_CIPHER_SPEC, &byte, 1,
338 ssl, ssl->msg_callback_arg);
344 void ssl3_read_close_notify(SSL *ssl) {
345 ssl3_read_bytes(ssl, 0, NULL, 0, 0);
348 static int ssl3_can_renegotiate(SSL *ssl) {
349 switch (ssl->renegotiate_mode) {
353 return ssl->s3->total_renegotiations == 0;
372 * If we don't have stored data to work from, read a SSL/TLS record first
377 int ssl3_read_bytes(SSL *ssl, int type, uint8_t *buf, int len, int peek) {
381 void (*cb)(const SSL *ssl, int type, int value) = NULL;
386 OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
391 * |ssl->handshake_func| to signal success one step early, but the handshake
395 while (!ssl->in_handshake && SSL_in_init(ssl)) {
397 i = ssl->handshake_func(ssl);
402 OPENSSL_PUT_ERROR(SSL, SSL_R_SSL_HANDSHAKE_FAILURE);
408 ssl->rwstate = SSL_NOTHING;
410 /* ssl->s3->rrec.type - is the type of record
411 * ssl->s3->rrec.data - data
412 * ssl->s3->rrec.off - offset into 'data' for next read
413 * ssl->s3->rrec.length - number of bytes. */
414 rr = &ssl->s3->rrec;
418 ret = ssl3_get_record(ssl);
428 if (ssl->shutdown & SSL_RECEIVED_SHUTDOWN) {
430 ssl->rwstate = SSL_NOTHING;
435 ssl->s3->warning_alert_count = 0;
439 if (SSL_in_init(ssl) && type == SSL3_RT_APPLICATION_DATA &&
440 ssl->aead_read_ctx == NULL) {
444 OPENSSL_PUT_ERROR(SSL, SSL_R_APP_DATA_IN_HANDSHAKE);
469 ssl_read_buffer_discard(ssl);
481 if (ssl->server || !ssl3_can_renegotiate(ssl)) {
483 OPENSSL_PUT_ERROR(SSL, SSL_R_NO_RENEGOTIATION);
490 while (ssl->s3->hello_request_len < sizeof(kHelloRequest)) {
495 if (rr->data[0] != kHelloRequest[ssl->s3->hello_request_len]) {
497 OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_HELLO_REQUEST);
502 ssl->s3->hello_request_len++;
504 ssl->s3->hello_request_len = 0;
506 if (ssl->msg_callback) {
507 ssl->msg_callback(0, ssl->version, SSL3_RT_HANDSHAKE, kHelloRequest,
508 sizeof(kHelloRequest), ssl, ssl->msg_callback_arg);
511 if (!SSL_is_init_finished(ssl) || !ssl->s3->initial_handshake_complete) {
515 OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
519 if (ssl->renegotiate_mode == ssl_renegotiate_ignore) {
527 if (ssl_write_buffer_is_pending(ssl)) {
529 OPENSSL_PUT_ERROR(SSL, SSL_R_NO_RENEGOTIATION);
534 ssl->s3->total_renegotiations++;
535 ssl->state = SSL_ST_CONNECT;
536 i = ssl->handshake_func(ssl);
541 OPENSSL_PUT_ERROR(SSL, SSL_R_SSL_HANDSHAKE_FAILURE);
555 OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_ALERT);
559 if (ssl->msg_callback) {
560 ssl->msg_callback(0, ssl->version, SSL3_RT_ALERT, rr->data, 2, ssl,
561 ssl->msg_callback_arg);
568 if (ssl->info_callback != NULL) {
569 cb = ssl->info_callback;
570 } else if (ssl->ctx->info_callback != NULL) {
571 cb = ssl->ctx->info_callback;
576 cb(ssl, SSL_CB_READ_ALERT, alert);
580 ssl->s3->warn_alert = alert_descr;
582 ssl->shutdown |= SSL_RECEIVED_SHUTDOWN;
595 OPENSSL_PUT_ERROR(SSL, SSL_R_NO_RENEGOTIATION);
599 ssl->s3->warning_alert_count++;
600 if (ssl->s3->warning_alert_count > kMaxWarningAlerts) {
602 OPENSSL_PUT_ERROR(SSL, SSL_R_TOO_MANY_WARNING_ALERTS);
608 ssl->rwstate = SSL_NOTHING;
609 ssl->s3->fatal_alert = alert_descr;
610 OPENSSL_PUT_ERROR(SSL, SSL_AD_REASON_OFFSET + alert_descr);
612 ERR_add_error_data(2, "SSL alert number ", tmp);
613 ssl->shutdown |= SSL_RECEIVED_SHUTDOWN;
614 SSL_CTX_remove_session(ssl->ctx, ssl->session);
618 OPENSSL_PUT_ERROR(SSL, SSL_R_UNKNOWN_ALERT_TYPE);
625 if (ssl->shutdown & SSL_SENT_SHUTDOWN) {
632 OPENSSL_PUT_ERROR(SSL, SSL_R_UNEXPECTED_RECORD);
635 ssl3_send_alert(ssl, SSL3_AL_FATAL, al);
640 int ssl3_do_change_cipher_spec(SSL *ssl) {
643 if (ssl->state & SSL_ST_ACCEPT) {
649 if (ssl->s3->tmp.key_block == NULL) {
650 if (ssl->session == NULL || ssl->session->master_key_length == 0) {
652 OPENSSL_PUT_ERROR(SSL, SSL_R_CCS_RECEIVED_EARLY);
656 ssl->session->cipher = ssl->s3->tmp.new_cipher;
657 if (!ssl->enc_method->setup_key_block(ssl)) {
662 if (!ssl->enc_method->change_cipher_state(ssl, i)) {
669 int ssl3_send_alert(SSL *ssl, int level, int desc) {
670 /* Map tls/ssl alert value to correct one */
671 desc = ssl->enc_method->alert_value(desc);
672 if (ssl->version == SSL3_VERSION && desc == SSL_AD_PROTOCOL_VERSION) {
673 /* SSL 3.0 does not have protocol_version alerts */
681 if (level == 2 && ssl->session != NULL) {
682 SSL_CTX_remove_session(ssl->ctx, ssl->session);
685 ssl->s3->alert_dispatch = 1;
686 ssl->s3->send_alert[0] = level;
687 ssl->s3->send_alert[1] = desc;
688 if (!ssl_write_buffer_is_pending(ssl)) {
691 return ssl->method->ssl_dispatch_alert(ssl);
699 int ssl3_dispatch_alert(SSL *ssl) {
701 void (*cb)(const SSL *ssl, int type, int value) = NULL;
703 ssl->s3->alert_dispatch = 0;
704 i = do_ssl3_write(ssl, SSL3_RT_ALERT, &ssl->s3->send_alert[0], 2);
706 ssl->s3->alert_dispatch = 1;
710 if (ssl->s3->send_alert[0] == SSL3_AL_FATAL) {
711 BIO_flush(ssl->wbio);
714 if (ssl->msg_callback) {
715 ssl->msg_callback(1, ssl->version, SSL3_RT_ALERT, ssl->s3->send_alert, 2,
716 ssl, ssl->msg_callback_arg);
719 if (ssl->info_callback != NULL) {
720 cb = ssl->info_callback;
721 } else if (ssl->ctx->info_callback != NULL) {
722 cb = ssl->ctx->info_callback;
726 j = (ssl->s3->send_alert[0] << 8) | ssl->s3->send_alert[1];
727 cb(ssl, SSL_CB_WRITE_ALERT, j);
