Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
No build reason found for SLE-Module-Web-Scripting:s390x
SUSE:SLE-12:Update
compat-openssl098.16428
openssl-CVE-2016-2181.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File openssl-CVE-2016-2181.patch of Package compat-openssl098.16428
commit b77ab018b79a00f789b0fb85596b446b08be4c9d Author: Matt Caswell <matt@openssl.org> Date: Tue Jul 5 12:04:37 2016 +0100 Fix DTLS replay protection The DTLS implementation provides some protection against replay attacks in accordance with RFC6347 section 4.1.2.6. A sliding "window" of valid record sequence numbers is maintained with the "right" hand edge of the window set to the highest sequence number we have received so far. Records that arrive that are off the "left" hand edge of the window are rejected. Records within the window are checked against a list of records received so far. If we already received it then we also reject the new record. If we have not already received the record, or the sequence number is off the right hand edge of the window then we verify the MAC of the record. If MAC verification fails then we discard the record. Otherwise we mark the record as received. If the sequence number was off the right hand edge of the window, then we slide the window along so that the right hand edge is in line with the newly received sequence number. Records may arrive for future epochs, i.e. a record from after a CCS being sent, can arrive before the CCS does if the packets get re-ordered. As we have not yet received the CCS we are not yet in a position to decrypt or validate the MAC of those records. OpenSSL places those records on an unprocessed records queue. It additionally updates the window immediately, even though we have not yet verified the MAC. This will only occur if currently in a handshake/renegotiation. This could be exploited by an attacker by sending a record for the next epoch (which does not have to decrypt or have a valid MAC), with a very large sequence number. This means the right hand edge of the window is moved very far to the right, and all subsequent legitimate packets are dropped causing a denial of service. A similar effect can be achieved during the initial handshake. In this case there is no MAC key negotiated yet. Therefore an attacker can send a message for the current epoch with a very large sequence number. The code will process the record as normal. If the hanshake message sequence number (as opposed to the record sequence number that we have been talking about so far) is in the future then the injected message is bufferred to be handled later, but the window is still updated. Therefore all subsequent legitimate handshake records are dropped. This aspect is not considered a security issue because there are many ways for an attacker to disrupt the initial handshake and prevent it from completing successfully (e.g. injection of a handshake message will cause the Finished MAC to fail and the handshake to be aborted). This issue comes about as a result of trying to do replay protection, but having no integrity mechanism in place yet. Does it even make sense to have replay protection in epoch 0? That issue isn't addressed here though. This addressed an OCAP Audit issue. CVE-2016-2181 Reviewed-by: Richard Levitte <levitte@openssl.org> commit 5802758eb480c5f14a768f6a061df1dd20aec8c4 Author: Matt Caswell <matt@openssl.org> Date: Wed Aug 17 17:55:36 2016 +0100 Update function error code A function error code needed updating due to merge issues. Reviewed-by: Richard Levitte <levitte@openssl.org> commit fa75569758298e2930c78989b516cac937118acc Author: Matt Caswell <matt@openssl.org> Date: Tue Jul 5 11:46:26 2016 +0100 Fix DTLS unprocessed records bug During a DTLS handshake we may get records destined for the next epoch arrive before we have processed the CCS. In that case we can't decrypt or verify the record yet, so we buffer it for later use. When we do receive the CCS we work through the queue of unprocessed records and process them. Unfortunately the act of processing wipes out any existing packet data that we were still working through. This includes any records from the new epoch that were in the same packet as the CCS. We should only process the buffered records if we've not got any data left. Reviewed-by: Richard Levitte <levitte@openssl.org> Index: openssl-0.9.8j/ssl/d1_pkt.c =================================================================== --- openssl-0.9.8j.orig/ssl/d1_pkt.c 2016-09-06 13:12:34.053077329 +0200 +++ openssl-0.9.8j/ssl/d1_pkt.c 2016-09-06 13:53:14.338540522 +0200 @@ -135,7 +135,7 @@ static int dtls1_record_needs_buffering( #endif static int dtls1_buffer_record(SSL *s, record_pqueue *q, PQ_64BIT priority); -static int dtls1_process_record(SSL *s); +static int dtls1_process_record(SSL *s, DTLS1_BITMAP *bitmap); #if PQ_64BIT_IS_INTEGER static PQ_64BIT bytes_to_long_long(unsigned char *bytes, PQ_64BIT *num); #endif @@ -249,6 +249,11 @@ static int dtls1_process_buffered_records(SSL *s) { pitem *item; + SSL3_BUFFER *rb; + SSL3_RECORD *rr; + DTLS1_BITMAP *bitmap; + unsigned int is_next_epoch; + int replayok = 1; item = pqueue_peek(s->d1->unprocessed_rcds.q); if (item) @@ -259,13 +264,52 @@ dtls1_process_buffered_records(SSL *s) /* Check if epoch is current. */ if (s->d1->unprocessed_rcds.epoch != s->d1->r_epoch) return(1); /* Nothing to do. */ + + rr = &s->s3->rrec; + rb = &s->s3->rbuf; + + if (rb->left > 0) { + /* + * We've still got data from the current packet to read. There could + * be a record from the new epoch in it - so don't overwrite it + * with the unprocessed records yet (we'll do it when we've + * finished reading the current packet). + */ + return 1; + } /* Process all the records. */ while (pqueue_peek(s->d1->unprocessed_rcds.q)) { dtls1_get_unprocessed_record(s); - if ( ! dtls1_process_record(s)) - return(0); + bitmap = dtls1_get_bitmap(s, rr, &is_next_epoch); + if (bitmap == NULL) { + /* + * Should not happen. This will only ever be NULL when the + * current record is from a different epoch. But that cannot + * be the case because we already checked the epoch above + */ + SSLerr(SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS, + ERR_R_INTERNAL_ERROR); + return 0; + } + { + /* + * Check whether this is a repeat, or aged record. We did this + * check once already when we first received the record - but + * we might have updated the window since then due to + * records we subsequently processed. + */ + replayok = dtls1_record_replay_check(s, bitmap, &(rr->seq_num)); + } + + if (!replayok || !dtls1_process_record(s, bitmap)) { + /* dump this record */ + rr->length = 0; + s->packet_length = 0; + continue; + } + dtls1_buffer_record(s, &(s->d1->processed_rcds), s->s3->rrec.seq_num); } @@ -326,7 +370,7 @@ dtls1_get_buffered_record(SSL *s) #endif static int -dtls1_process_record(SSL *s) +dtls1_process_record(SSL *s, DTLS1_BITMAP *bitmap) { int i,al; int enc_err; @@ -484,7 +528,7 @@ printf("\n"); /* we have pulled in a full packet so zero things */ s->packet_length=0; - dtls1_record_bitmap_update(s, &(s->d1->bitmap));/* Mark receipt of record. */ + dtls1_record_bitmap_update(s, bitmap);/* Mark receipt of record. */ return(1); decryption_failed_or_bad_record_mac: @@ -525,6 +569,7 @@ int dtls1_get_record(SSL *s) rr= &(s->s3->rrec); sess=s->session; +again: /* The epoch may have changed. If so, process all the * pending records. This is a non-blocking operation. */ if ( ! dtls1_process_buffered_records(s)) @@ -535,7 +580,6 @@ int dtls1_get_record(SSL *s) return 1; /* get something from the wire */ -again: /* check if we have the header */ if ( (s->rstate != SSL_ST_READ_BODY) || (s->packet_length < DTLS1_RT_HEADER_LENGTH)) @@ -640,13 +684,12 @@ again: * not processed, so as to prevent any potential resource DoS attack */ if (is_next_epoch) { - dtls1_record_bitmap_update(s, bitmap); dtls1_buffer_record(s, &(s->d1->unprocessed_rcds), rr->seq_num); s->packet_length = 0; goto again; } - if ( ! dtls1_process_record(s)) + if ( ! dtls1_process_record(s, bitmap)) return(0); dtls1_clear_timeouts(s); /* done waiting */ @@ -1685,8 +1728,13 @@ dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr if (rr->epoch == s->d1->r_epoch) return &s->d1->bitmap; - /* Only HM and ALERT messages can be from the next epoch */ + /* + * Only HM and ALERT messages can be from the next epoch and only if we + * have already processed all of the unprocessed records from the last + * epoch + */ else if (rr->epoch == (unsigned long)(s->d1->r_epoch + 1) && + s->d1->unprocessed_rcds.epoch != s->d1->r_epoch && (rr->type == SSL3_RT_HANDSHAKE || rr->type == SSL3_RT_ALERT)) { Index: openssl-0.9.8j/ssl/ssl_err.c =================================================================== --- openssl-0.9.8j.orig/ssl/ssl_err.c 2016-09-06 13:12:34.169079108 +0200 +++ openssl-0.9.8j/ssl/ssl_err.c 2016-09-06 13:12:34.285080887 +0200 @@ -1,6 +1,6 @@ /* ssl/ssl_err.c */ /* ==================================================================== - * Copyright (c) 1999-2011 The OpenSSL Project. All rights reserved. + * Copyright (c) 1999-2016 The OpenSSL Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -88,6 +88,8 @@ static ERR_STRING_DATA SSL_str_functs[]= {ERR_FUNC(SSL_F_DTLS1_GET_RECORD), "DTLS1_GET_RECORD"}, {ERR_FUNC(SSL_F_DTLS1_OUTPUT_CERT_CHAIN), "DTLS1_OUTPUT_CERT_CHAIN"}, {ERR_FUNC(SSL_F_DTLS1_PREPROCESS_FRAGMENT), "DTLS1_PREPROCESS_FRAGMENT"}, +{ERR_FUNC(SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS), + "DTLS1_PROCESS_BUFFERED_RECORDS"}, {ERR_FUNC(SSL_F_DTLS1_PROCESS_OUT_OF_SEQ_MESSAGE), "DTLS1_PROCESS_OUT_OF_SEQ_MESSAGE"}, {ERR_FUNC(SSL_F_DTLS1_PROCESS_RECORD), "DTLS1_PROCESS_RECORD"}, {ERR_FUNC(SSL_F_DTLS1_READ_BYTES), "DTLS1_READ_BYTES"}, Index: openssl-0.9.8j/ssl/ssl.h =================================================================== --- openssl-0.9.8j.orig/ssl/ssl.h 2016-09-06 13:12:34.173079170 +0200 +++ openssl-0.9.8j/ssl/ssl.h 2016-09-06 13:12:34.285080887 +0200 @@ -1686,6 +1686,7 @@ void ERR_load_SSL_strings(void); #define SSL_F_DTLS1_GET_RECORD 254 #define SSL_F_DTLS1_OUTPUT_CERT_CHAIN 255 #define SSL_F_DTLS1_PREPROCESS_FRAGMENT 277 +#define SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS 424 #define SSL_F_DTLS1_PROCESS_OUT_OF_SEQ_MESSAGE 256 #define SSL_F_DTLS1_PROCESS_RECORD 257 #define SSL_F_DTLS1_READ_BYTES 258
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
