Skip to main content
  • Home
  • login
  • Browse the archive

    swh mirror partner logo
swh logo
SoftwareHeritage
Software
Heritage
Mirror
Features
  • Search

  • Downloads

  • Save code now

  • Add forge now

  • Help

Revision f5c7f5dfbaf0d2f7d946d0fe86f08e6bcb36ed0d authored by Matt Caswell on 30 June 2016, 12:17:08 UTC, committed by Matt Caswell on 22 August 2016, 09:53:55 UTC
Fix DTLS buffered message DoS attack
DTLS can handle out of order record delivery. Additionally since
handshake messages can be bigger than will fit into a single packet, the
messages can be fragmented across multiple records (as with normal TLS).
That means that the messages can arrive mixed up, and we have to
reassemble them. We keep a queue of buffered messages that are "from the
future", i.e. messages we're not ready to deal with yet but have arrived
early. The messages held there may not be full yet - they could be one
or more fragments that are still in the process of being reassembled.

The code assumes that we will eventually complete the reassembly and
when that occurs the complete message is removed from the queue at the
point that we need to use it.

However, DTLS is also tolerant of packet loss. To get around that DTLS
messages can be retransmitted. If we receive a full (non-fragmented)
message from the peer after previously having received a fragment of
that message, then we ignore the message in the queue and just use the
non-fragmented version. At that point the queued message will never get
removed.

Additionally the peer could send "future" messages that we never get to
in order to complete the handshake. Each message has a sequence number
(starting from 0). We will accept a message fragment for the current
message sequence number, or for any sequence up to 10 into the future.
However if the Finished message has a sequence number of 2, anything
greater than that in the queue is just left there.

So, in those two ways we can end up with "orphaned" data in the queue
that will never get removed - except when the connection is closed. At
that point all the queues are flushed.

An attacker could seek to exploit this by filling up the queues with
lots of large messages that are never going to be used in order to
attempt a DoS by memory exhaustion.

I will assume that we are only concerned with servers here. It does not
seem reasonable to be concerned about a memory exhaustion attack on a
client. They are unlikely to process enough connections for this to be
an issue.

A "long" handshake with many messages might be 5 messages long (in the
incoming direction), e.g. ClientHello, Certificate, ClientKeyExchange,
CertificateVerify, Finished. So this would be message sequence numbers 0
to 4. Additionally we can buffer up to 10 messages in the future.
Therefore the maximum number of messages that an attacker could send
that could get orphaned would typically be 15.

The maximum size that a DTLS message is allowed to be is defined by
max_cert_list, which by default is 100k. Therefore the maximum amount of
"orphaned" memory per connection is 1500k.

Message sequence numbers get reset after the Finished message, so
renegotiation will not extend the maximum number of messages that can be
orphaned per connection.

As noted above, the queues do get cleared when the connection is closed.
Therefore in order to mount an effective attack, an attacker would have
to open many simultaneous connections.

Issue reported by Quan Luo.

CVE-2016-2179

Reviewed-by: Richard Levitte <levitte@openssl.org>
1 parent 5dfd038
  • Files
  • Changes
  • c0c9b13
  • /
  • util
  • /
  • openssl-format-source
Raw File
Cook and download a directory from the Software Heritage Vault

You have requested the cooking of the directory with identifier None into a standard tar.gz archive.

Are you sure you want to continue ?

Download a directory from the Software Heritage Vault

You have requested the download of the directory with identifier None as a standard tar.gz archive.

Are you sure you want to continue ?

Cook and download a revision from the Software Heritage Vault

You have requested the cooking of the history heading to revision with identifier swh:1:rev:f5c7f5dfbaf0d2f7d946d0fe86f08e6bcb36ed0d into a bare git archive.

Are you sure you want to continue ?

Download a revision from the Software Heritage Vault

You have requested the download of the history heading to revision with identifier swh:1:rev:f5c7f5dfbaf0d2f7d946d0fe86f08e6bcb36ed0d as a bare git archive.

Are you sure you want to continue ?

Invalid Email !

The provided email is not well-formed.

Download link has expired

The requested archive is no longer available for download from the Software Heritage Vault.

Do you want to cook it again ?

Permalinks

To reference or cite the objects present in the Software Heritage archive, permalinks based on SoftWare Hash IDentifiers (SWHIDs) must be used.
Select below a type of object currently browsed in order to display its associated SWHID and permalink.

  • revision
  • content
revision badge
swh:1:rev:f5c7f5dfbaf0d2f7d946d0fe86f08e6bcb36ed0d
content badge Iframe embedding
swh:1:cnt:3dcc128a9f1ec747fac854dd4de0954543fa30df
openssl-format-source
#!/bin/sh
#
# Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
#
# Licensed under the OpenSSL license (the "License").  You may not use
# this file except in compliance with the License.  You can obtain a copy
# in the file LICENSE in the source distribution or at
# https://www.openssl.org/source/license.html

#
# openssl-format-source 
# - format source tree according to OpenSSL coding style using indent
#
# usage:
#   openssl-format-source [-v] [-n] [file|directory] ...
#
# note: the indent options assume GNU indent v2.2.10 which was released
#       Feb-2009 so if you have an older indent the options may not 
#	match what is expected
#
# any marked block comment blocks have to be moved to align manually after
# the reformatting has been completed as marking a block causes indent to 
# not move it at all ...
#

PATH=/usr/local/bin:/bin:/usr/bin:$PATH
export PATH
HERE="`dirname $0`"

set -e

INDENT=indent
uname -s | grep BSD > /dev/null && type gindent > /dev/null 2>&1 && INDENT=gindent

if [ $# -eq 0 ]; then
  echo "usage: $0 [-v] [-n] [-c] [sourcefile|sourcedir] ..." >&2
  exit 1
fi

VERBOSE=false
DONT=false
STOPARGS=false
COMMENTS=false
CHANGED=false
DEBUG=""

# for this exercise, we want to force the openssl style, so we roll
# our own indent profile, which is at a well known location
INDENT_PROFILE="$HERE/indent.pro"
export INDENT_PROFILE
if [ ! -f "$INDENT_PROFILE" ]; then
  echo "$0: unable to locate the openssl indent.pro file" >&2
  exit 1
fi

# Extra arguments; for adding the comment-formatting
INDENT_ARGS=""
for i 
do
  if [ "$STOPARGS" != "true" ]; then
    case $i in
      --) STOPARGS="true"; continue;;
      -n) DONT="true"; continue;;
      -v) VERBOSE="true"; 
	  echo "INDENT_PROFILE=$INDENT_PROFILE";
	  continue;;
      -c) COMMENTS="true"; 
      	  INDENT_ARGS="-fc1 -fca -cdb -sc"; 
	  continue;;
      -nc) COMMENTS="true";
	  continue;;
      -d) DEBUG='eval tee "$j.pre" |'
	  continue;;
    esac
  fi

  if [ -d "$i" ]; then
    LIST=`find "$i" -name '*.[ch]' -print`
  else 
    if [ ! -f "$i" ]; then
      echo "$0: source file not found: $i" >&2
      exit 1
    fi
    LIST="$i"
  fi
  
  for j in $LIST
  do
    # ignore symlinks - we only ever process the base file - so if we
    # expand a directory tree we need to ignore any located symlinks
    if [ -d "$i" ]; then
      if [ -h "$j" ]; then
	continue;
      fi
    fi

    if [ "$DONT" = "false" ]; then
      tmp=$(mktemp /tmp/indent.XXXXXX)
      trap 'rm -f "$tmp"' HUP INT TERM EXIT

      case `basename $j` in 
	# the list of files that indent is unable to handle correctly
	# that we simply leave alone for manual formatting now
	obj_dat.h|aes_core.c|aes_x86core.c|ecp_nistz256.c)
	  echo "skipping $j"
	  ;;
	*)
	  if [ "$COMMENTS" = "true" ]; then
	    # we have to mark single line comments as /*- ...*/ to stop indent
	    # messing with them, run expand then indent as usual but with the
	    # the process-comments options and then undo that marking, and then 
	    # finally re-run indent without process-comments so the marked-to-
	    # be-ignored comments we did automatically end up getting moved 
	    # into the right possition within the code as indent leaves marked 
	    # comments entirely untouched - we appear to have no way to avoid 
	    # the double processing and get the desired output
	    cat "$j" | \
	    expand | \
	    perl -0 -np \
	      -e 's/(\n#[ \t]*ifdef[ \t]+__cplusplus\n[^\n]*\n#[ \t]*endif\n)/\n\/**INDENT-OFF**\/$1\/**INDENT-ON**\/\n/g;' \
	      -e 's/(\n\/\*\!)/\n\/**/g;' \
	      -e 's/(STACK_OF|LHASH_OF)\(([^ \t,\)]+)\)( |\n)/$1_$2_$3/g;' \
	      | \
	    perl -np \
	      -e 's/^([ \t]*)\/\*([ \t]+.*)\*\/[ \t]*$/my ($x1,$x2) = ($1, $2); if (length("$x1$x2")<75 && $x2 !~ m#^\s*\*INDENT-(ON|OFF)\*\s*$#) {$c="-"}else{$c=""}; "$x1\/*$c$x2*\/"/e;' \
	      -e 's/^\/\* ((Copyright|=|----).*)$/\/*-$1/;' \
	      -e 's/^((DECLARE|IMPLEMENT)_.*)$/\/**INDENT-OFF**\/\n$1\n\/**INDENT-ON**\//;' \
	      -e 's/^([ \t]*(make_dh|make_dh_bn|make_rfc5114_td)\(.*\)[ \t,]*)$/\/**INDENT-OFF**\/\n$1\n\/**INDENT-ON**\//;' \
	      -e 's/^(ASN1_ADB_TEMPLATE\(.*)$/\/**INDENT-OFF**\/\n$1\n\/**INDENT-ON**\//;' \
	      -e 's/^((ASN1|ADB)_.*_(end|END)\(.*[\){=,;]+[ \t]*)$/$1\n\/**INDENT-ON**\//;' \
	      -e '/ASN1_(ITEM_ref|ITEM_ptr|ITEM_rptr|PCTX)/ || s/^((ASN1|ADB)_[^\*]*[){=,]+[ \t]*)$/\/**INDENT-OFF**\/\n$1/;' \
	      -e 's/^(} (ASN1|ADB)_[^\*]*[\){=,;]+)$/$1\n\/**INDENT-ON**\//;' \
	      | \
	      $DEBUG $INDENT $INDENT_ARGS | \
	      perl -np \
		-e 's/^([ \t]*)\/\*-(.*)\*\/[ \t]*$/$1\/*$2*\//;' \
		-e 's/^\/\*-((Copyright|=|----).*)$/\/* $1/;' \
	      | $INDENT | \
	      perl -0 -np \
		-e 's/\/\*\*INDENT-(ON|OFF)\*\*\/\n//g;' \
	      | perl -np \
	        -e 's/(STACK_OF|LHASH_OF)_([^ \t,]+)_( |\/)/$1($2)$3/g;' \
	        -e 's/(STACK_OF|LHASH_OF)_([^ \t,]+)_$/$1($2)/g;' \
	      | perl "$HERE"/su-filter.pl \
	      > "$tmp"
	  else
	    expand "$j" | $INDENT $INDENT_ARGS > "$tmp"
	  fi;
	  if cmp -s "$tmp" "$j"; then
	    if [ "$VERBOSE" = "true" ]; then
	      echo "$j unchanged"
	    fi
	    rm "$tmp"
	  else
	    if [ "$VERBOSE" = "true" ]; then
	      echo "$j changed"
	    fi
	    CHANGED=true
	    mv "$tmp" "$j"
	  fi
	  ;;
      esac
    fi
  done
done


if [ "$VERBOSE" = "true" ]; then
  echo
  if [ "$CHANGED" = "true" ]; then
    echo "SOURCE WAS MODIFIED"
  else
    echo "SOURCE WAS NOT MODIFIED"
  fi
fi
The diff you're trying to view is too large. Only the first 1000 changed files have been loaded.
Showing with 0 additions and 0 deletions (0 / 0 diffs computed)
swh spinner

Computing file changes ...

ENEA — Copyright (C), ENEA. License: GNU AGPLv3+.
Legal notes  ::  JavaScript license information ::  Web API

back to top