NEW_PADDING has been removed.

This extension did not get accepted by IETF so it is
now being removed. The gnutls_range API is kept in case
length hiding is implemented in a different way at some
point.

18 files changed, 26 insertions, 654 deletions

diff --git a/doc/cha-gtls-app.texi b/doc/cha-gtls-app.texi
index 0c5578025b..8c4142dce8 100644
--- a/doc/cha-gtls-app.texi
+++ b/doc/cha-gtls-app.texi
@@ -1081,12 +1081,6 @@ This is the default.
 @item %LATEST_RECORD_VERSION @tab
 will use the latest TLS version record version in client hello.
 
-@item %NEW_PADDING @tab
-will enable the new padding extension negotiation. If the new padding extension
-is negotiated, GnuTLS will use a more efficient length-hiding mechanism.
-Use @funcref{gnutls_record_can_use_length_hiding} to check whether length-hiding
-can be used in the current session. This is a GnuTLS extension to the protocol.
-
 @end multitable
 @caption{Special priority string keywords.}
 @end float
diff --git a/lib/ext/Makefile.am b/lib/ext/Makefile.am
index 0fcda01439..b532f7d6bc 100644
--- a/lib/ext/Makefile.am
+++ b/lib/ext/Makefile.am
@@ -39,8 +39,8 @@ libgnutls_ext_la_SOURCES = max_record.c cert_type.c \
 	max_record.h cert_type.h server_name.h srp.h \
 	session_ticket.h signature.h safe_renegotiation.h \
 	session_ticket.c srp.c ecc.c ecc.h heartbeat.c heartbeat.h \
-	status_request.h status_request.c new_record_padding.c \
-	new_record_padding.h dumbfw.c dumbfw.h
+	status_request.h status_request.c \
+	dumbfw.c dumbfw.h
 
 if ENABLE_ALPN
 libgnutls_ext_la_SOURCES += alpn.c alpn.h
diff --git a/lib/ext/new_record_padding.c b/lib/ext/new_record_padding.c
deleted file mode 100644
index aceec7c4b9..0000000000
--- a/lib/ext/new_record_padding.c
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright (C) 2012 Nikos Mavrogiannopoulos
- *
- * Author: Nikos Mavrogiannopoulos
- *
- * This file is part of GnuTLS.
- *
- * The GnuTLS is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *
- */
-
-/* This file contains the code for the Max Record Size TLS extension.
- */
-
-#include "gnutls_int.h"
-#include "gnutls_errors.h"
-#include "gnutls_num.h"
-#include <gnutls_extensions.h>
-#include <ext/new_record_padding.h>
-
-static int new_record_padding_recv_params(gnutls_session_t session,
-					  const uint8_t * data,
-					  size_t data_size);
-static int new_record_padding_send_params(gnutls_session_t session,
-					  gnutls_buffer_st * extdata);
-static int new_record_padding_before_epoch_change(gnutls_session_t
-						  session);
-
-extension_entry_st ext_mod_new_record_padding = {
-	.name = "NEW_RECORD_PADDING",
-	.type = GNUTLS_EXTENSION_NEW_RECORD_PADDING,
-	.parse_type = GNUTLS_EXT_TLS,
-
-	.recv_func = new_record_padding_recv_params,
-	.send_func = new_record_padding_send_params,
-	.pack_func = NULL,
-	.unpack_func = NULL,
-	.deinit_func = NULL,
-	.epoch_func = new_record_padding_before_epoch_change
-};
-
-static int
-new_record_padding_recv_params(gnutls_session_t session,
-			       const uint8_t * data, size_t _data_size)
-{
-	ssize_t data_size = _data_size;
-	extension_priv_data_t epriv;
-
-	if (data_size > 0)
-		return
-		    gnutls_assert_val(GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER);
-
-	if (session->security_parameters.entity == GNUTLS_SERVER) {
-		if (session->internals.priorities.new_record_padding != 0) {
-			epriv.num = 1;
-			_gnutls_ext_set_session_data(session,
-						     GNUTLS_EXTENSION_NEW_RECORD_PADDING,
-						     epriv);
-		}
-	} else {		/* client */
-
-		if (session->internals.priorities.new_record_padding != 0) {
-			epriv.num = 1;
-			_gnutls_ext_set_session_data(session,
-						     GNUTLS_EXTENSION_NEW_RECORD_PADDING,
-						     epriv);
-		}
-	}
-
-	return 0;
-}
-
-static int new_record_padding_before_epoch_change(gnutls_session_t session)
-{
-	extension_priv_data_t epriv;
-	int ret;
-
-	ret = _gnutls_ext_get_session_data(session,
-					   GNUTLS_EXTENSION_NEW_RECORD_PADDING,
-					   &epriv);
-	if (ret < 0)
-		return 0;	/* fine */
-
-	if (epriv.num != 0)
-		session->security_parameters.new_record_padding = 1;
-
-	return 0;
-}
-
-/* returns data_size or a negative number on failure
- */
-static int
-new_record_padding_send_params(gnutls_session_t session,
-			       gnutls_buffer_st * extdata)
-{
-	extension_priv_data_t epriv;
-	int ret;
-
-	/* this function sends the client extension data (dnsname) */
-	if (session->security_parameters.entity == GNUTLS_CLIENT) {
-		if (session->internals.priorities.new_record_padding != 0)
-			return GNUTLS_E_INT_RET_0;	/* advertize it */
-	} else {		/* server side */
-		ret = _gnutls_ext_get_session_data(session,
-						   GNUTLS_EXTENSION_NEW_RECORD_PADDING,
-						   &epriv);
-		if (ret < 0)
-			return 0;
-
-		if (epriv.num != 0)
-			return GNUTLS_E_INT_RET_0;
-	}
-
-	return 0;
-}
diff --git a/lib/ext/new_record_padding.h b/lib/ext/new_record_padding.h
deleted file mode 100644
index 97fc76f2fa..0000000000
--- a/lib/ext/new_record_padding.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2001-2012 Free Software Foundation, Inc.
- *
- * Author: Nikos Mavrogiannopoulos
- *
- * This file is part of GnuTLS.
- *
- * The GnuTLS is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *
- */
-
-#ifndef EXT_NEW_RECORD_PADDING_H
-#define EXT_NEW_RECORD_PADDING_H
-
-#include <gnutls_extensions.h>
-
-extern extension_entry_st ext_mod_new_record_padding;
-#endif
diff --git a/lib/gnutls_cipher.c b/lib/gnutls_cipher.c
index 571cd51a29..58ce797757 100644
--- a/lib/gnutls_cipher.c
+++ b/lib/gnutls_cipher.c
@@ -55,21 +55,6 @@ static int ciphertext_to_compressed(gnutls_session_t session,
 				    record_parameters_st * params,
 				    uint64 * sequence);
 
-static int ciphertext_to_compressed_new(gnutls_session_t session,
-					gnutls_datum_t * ciphertext,
-					gnutls_datum_t * compressed,
-					uint8_t type,
-					record_parameters_st * params,
-					uint64 * sequence);
-
-static int
-compressed_to_ciphertext_new(gnutls_session_t session,
-			     uint8_t * cipher_data, int cipher_size,
-			     gnutls_datum_t * compressed,
-			     size_t min_pad,
-			     content_type_t type,
-			     record_parameters_st * params);
-
 inline static int is_write_comp_null(record_parameters_st * record_params)
 {
 	if (record_params->compression_algorithm == GNUTLS_COMP_NULL)
@@ -129,22 +114,12 @@ _gnutls_encrypt(gnutls_session_t session,
 		comp.size = ret;
 	}
 
-	if (params->write.new_record_padding != 0)
-		ret =
-		    compressed_to_ciphertext_new(session,
-						 _mbuffer_get_udata_ptr
-						 (bufel),
-						 _mbuffer_get_udata_size
-						 (bufel), &comp, min_pad,
-						 type, params);
-	else
-		ret =
-		    compressed_to_ciphertext(session,
-					     _mbuffer_get_udata_ptr(bufel),
-					     _mbuffer_get_udata_size
-					     (bufel), &comp, min_pad, type,
-					     params);
-
+	ret =
+	    compressed_to_ciphertext(session,
+				     _mbuffer_get_udata_ptr(bufel),
+				     _mbuffer_get_udata_size
+				     (bufel), &comp, min_pad, type,
+				     params);
 	if (free_comp)
 		gnutls_free(comp.data);
 
@@ -184,17 +159,10 @@ _gnutls_decrypt(gnutls_session_t session,
 		return 0;
 
 	if (is_read_comp_null(params) == 0) {
-		if (params->read.new_record_padding != 0)
-			ret =
-			    ciphertext_to_compressed_new(session,
-							 ciphertext,
-							 output, type,
-							 params, sequence);
-		else
-			ret =
-			    ciphertext_to_compressed(session, ciphertext,
-						     output, type, params,
-						     sequence);
+		ret =
+		    ciphertext_to_compressed(session, ciphertext,
+					     output, type, params,
+					     sequence);
 		if (ret < 0)
 			return gnutls_assert_val(ret);
 
@@ -207,17 +175,10 @@ _gnutls_decrypt(gnutls_session_t session,
 		if (tmp.data == NULL)
 			return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
 
-		if (params->read.new_record_padding != 0)
-			ret =
-			    ciphertext_to_compressed_new(session,
-							 ciphertext, &tmp,
-							 type, params,
-							 sequence);
-		else
-			ret =
-			    ciphertext_to_compressed(session, ciphertext,
-						     &tmp, type, params,
-						     sequence);
+		ret =
+		    ciphertext_to_compressed(session, ciphertext,
+					     &tmp, type, params,
+					     sequence);
 		if (ret < 0)
 			goto leave;
 
@@ -473,198 +434,6 @@ compressed_to_ciphertext(gnutls_session_t session,
 	return length;
 }
 
-static int
-compressed_to_ciphertext_new(gnutls_session_t session,
-			     uint8_t * cipher_data, int cipher_size,
-			     gnutls_datum_t * compressed,
-			     size_t min_pad,
-			     content_type_t type,
-			     record_parameters_st * params)
-{
-	uint16_t pad = min_pad;
-	int length, length_to_encrypt, ret;
-	uint8_t preamble[MAX_PREAMBLE_SIZE];
-	int preamble_size;
-	int tag_size =
-	    _gnutls_auth_cipher_tag_len(&params->write.cipher_state);
-	int blocksize = _gnutls_cipher_get_block_size(params->cipher);
-	unsigned block_algo = _gnutls_cipher_is_block(params->cipher);
-	uint8_t *data_ptr;
-	const version_entry_st *ver = get_version(session);
-	int explicit_iv = _gnutls_version_has_explicit_iv(ver);
-	int auth_cipher =
-	    _gnutls_auth_cipher_is_aead(&params->write.cipher_state);
-	uint8_t nonce[MAX_CIPHER_BLOCK_SIZE];
-	unsigned imp_iv_size, final_cipher_size, iv_size, exp_iv_size;
-
-	if (unlikely(ver == NULL))
-		return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
-
-	imp_iv_size = _gnutls_cipher_get_implicit_iv_size(params->cipher);
-	exp_iv_size = _gnutls_cipher_get_explicit_iv_size(params->cipher);
-	iv_size = _gnutls_cipher_get_iv_size(params->cipher);
-
-	_gnutls_hard_log("ENC[%p]: cipher: %s, MAC: %s, Epoch: %u\n",
-			 session, _gnutls_cipher_get_name(params->cipher),
-			 _gnutls_mac_get_name(params->mac),
-			 (unsigned int) params->epoch);
-
-	/* Call _gnutls_rnd() once. Get data used for the IV
-	 */
-	ret = _gnutls_rnd(GNUTLS_RND_NONCE, nonce, blocksize);
-	if (ret < 0)
-		return gnutls_assert_val(ret);
-
-	/* cipher_data points to the start of data to be encrypted */
-	data_ptr = cipher_data;
-
-	length_to_encrypt = length = 0;
-
-	if (explicit_iv) {
-		if (block_algo == CIPHER_BLOCK) {
-			/* copy the random IV.
-			 */
-			DECR_LEN(cipher_size, blocksize);
-
-			memcpy(data_ptr, nonce, blocksize);
-			_gnutls_auth_cipher_setiv(&params->write.
-						  cipher_state, data_ptr,
-						  blocksize);
-
-			data_ptr += blocksize;
-			cipher_data += blocksize;
-			length += blocksize;
-		} else if (auth_cipher) {
-			/* Values in AEAD are pretty fixed in TLS 1.2 for 128-bit block
-			 */
-			if (params->write.IV.data == NULL
-			    || params->write.IV.size !=
-			    imp_iv_size)
-				return
-				    gnutls_assert_val
-				    (GNUTLS_E_INTERNAL_ERROR);
-
-			/* Instead of generating a new nonce on every packet, we use the
-			 * write.sequence_number (It is a MAY on RFC 5288).
-			 */
-			memcpy(nonce, params->write.IV.data,
-			       params->write.IV.size);
-			memcpy(&nonce[imp_iv_size],
-			       UINT64DATA(params->write.sequence_number),
-			       8);
-
-			_gnutls_auth_cipher_setiv(&params->write.
-						  cipher_state, nonce,
-						  imp_iv_size +
-						  exp_iv_size);
-
-			/* copy the explicit part */
-			DECR_LEN(cipher_size, exp_iv_size);
-			memcpy(data_ptr, &nonce[imp_iv_size],
-			       exp_iv_size);
-
-			data_ptr += exp_iv_size;
-			cipher_data += exp_iv_size;
-			length += exp_iv_size;
-		} else if (iv_size > 0)
-			_gnutls_auth_cipher_setiv(&params->write.
-						  cipher_state,
-						  UINT64DATA(params->write.
-							     sequence_number),
-						  8);
-	} else {
-		/* AEAD ciphers have an explicit IV. Shouldn't be used otherwise.
-		 */
-		if (auth_cipher)
-			return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
-	}
-
-	DECR_LEN(cipher_size, 2);
-
-	if (block_algo == CIPHER_BLOCK) {	/* make pad a multiple of blocksize */
-		unsigned t =
-		    (2 + pad + compressed->size + tag_size) % blocksize;
-		if (t > 0) {
-			pad += blocksize - t;
-		}
-	}
-
-	_gnutls_write_uint16(pad, data_ptr);
-	data_ptr += 2;
-	length_to_encrypt += 2;
-	length += 2;
-	final_cipher_size = cipher_size;
-
-	if (pad > 0) {
-		unsigned t;
-
-		t = cipher_size - compressed->size;
-		if (pad > t) {
-			if (block_algo == CIPHER_BLOCK) {
-				if (pad <= blocksize)
-					return
-					    gnutls_assert_val
-					    (GNUTLS_E_INVALID_REQUEST);
-
-				pad -= blocksize * ((pad - t) / blocksize);
-			} else
-				pad = t;
-		}
-
-		DECR_LEN(cipher_size, pad);
-
-		memset(data_ptr, 0, pad);
-		data_ptr += pad;
-		length_to_encrypt += pad;
-		length += pad;
-	}
-
-	DECR_LEN(cipher_size, compressed->size);
-
-	memcpy(data_ptr, compressed->data, compressed->size);
-	data_ptr += compressed->size;
-	length_to_encrypt += compressed->size;
-	length += compressed->size;
-
-	if (tag_size > 0) {
-		DECR_LEN(cipher_size, tag_size);
-
-		data_ptr += tag_size;
-
-		/* In AEAD ciphers we don't encrypt the tag 
-		 */
-		length += tag_size;
-	}
-
-	preamble_size =
-	    make_preamble(UINT64DATA
-			  (params->write.sequence_number),
-			  type, compressed->size + 2 + pad, ver, preamble);
-
-	_gnutls_auth_cipher_set_mac_nonce(&params->write.cipher_state,
-					  UINT64DATA(params->write.
-						     sequence_number), 8);
-	/* add the authenticated data */
-	ret =
-	    _gnutls_auth_cipher_add_auth(&params->write.cipher_state,
-					 preamble, preamble_size);
-	if (ret < 0)
-		return gnutls_assert_val(ret);
-
-	/* Actual encryption (inplace).
-	 */
-	ret =
-	    _gnutls_auth_cipher_encrypt2_tag(&params->write.cipher_state,
-					     cipher_data,
-					     length_to_encrypt,
-					     cipher_data,
-					     final_cipher_size, 0);
-	if (ret < 0)
-		return gnutls_assert_val(ret);
-
-	return length;
-}
-
 static void dummy_wait(record_parameters_st * params,
 		       gnutls_datum_t * plaintext, unsigned pad_failed,
 		       unsigned int pad, unsigned total)
@@ -961,169 +730,3 @@ ciphertext_to_compressed(gnutls_session_t session,
 
 	return length;
 }
-
-static int
-ciphertext_to_compressed_new(gnutls_session_t restrict session,
-			     gnutls_datum_t * restrict ciphertext,
-			     gnutls_datum_t * restrict compressed,
-			     uint8_t type,
-			     record_parameters_st * restrict params,
-			     uint64 * restrict sequence)
-{
-	uint8_t tag[MAX_HASH_SIZE];
-	const uint8_t *tag_ptr;
-	unsigned int pad;
-	int length, length_to_decrypt;
-	uint16_t blocksize;
-	int ret;
-	uint8_t preamble[MAX_PREAMBLE_SIZE];
-	unsigned int preamble_size;
-	const version_entry_st *ver = get_version(session);
-	unsigned int tag_size =
-	    _gnutls_auth_cipher_tag_len(&params->read.cipher_state);
-	unsigned int explicit_iv = _gnutls_version_has_explicit_iv(ver);
-	unsigned imp_iv_size, iv_size, exp_iv_size;
-
-	if (unlikely(ver == NULL))
-		return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
-
-	imp_iv_size = _gnutls_cipher_get_implicit_iv_size(params->cipher);
-	exp_iv_size = _gnutls_cipher_get_explicit_iv_size(params->cipher);
-	iv_size = _gnutls_cipher_get_iv_size(params->cipher);
-	blocksize = _gnutls_cipher_get_block_size(params->cipher);
-
-	/* actual decryption (inplace)
-	 */
-	switch (_gnutls_cipher_is_block(params->cipher)) {
-	case CIPHER_STREAM:
-		/* The way AEAD ciphers are defined in RFC5246, it allows
-		 * only stream ciphers.
-		 */
-		if (explicit_iv
-		    && _gnutls_auth_cipher_is_aead(&params->read.
-						   cipher_state)) {
-			uint8_t nonce[blocksize];
-			/* Values in AEAD are pretty fixed in TLS 1.2 for 128-bit block
-			 */
-			if (params->read.IV.data == NULL
-			    || params->read.IV.size != 4)
-				return
-				    gnutls_assert_val
-				    (GNUTLS_E_INTERNAL_ERROR);
-
-			if (ciphertext->size <
-			    tag_size + exp_iv_size + 2)
-				return
-				    gnutls_assert_val
-				    (GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
-
-			memcpy(nonce, params->read.IV.data,
-			       imp_iv_size);
-			memcpy(&nonce[imp_iv_size],
-			       ciphertext->data, exp_iv_size);
-
-			_gnutls_auth_cipher_setiv(&params->read.
-						  cipher_state, nonce,
-						  exp_iv_size +
-						  imp_iv_size);
-
-			ciphertext->data += exp_iv_size;
-			ciphertext->size -= exp_iv_size;
-
-			length_to_decrypt = ciphertext->size - tag_size;
-		} else if (iv_size > 0) {	/* a stream cipher with implicit IV */
-			_gnutls_auth_cipher_setiv(&params->read.
-						  cipher_state,
-						  UINT64DATA(*sequence),
-						  8);
-			length_to_decrypt = ciphertext->size;
-		} else {
-			if (ciphertext->size < tag_size)
-				return
-				    gnutls_assert_val
-				    (GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
-
-			length_to_decrypt = ciphertext->size;
-		}
-		break;
-	case CIPHER_BLOCK:
-		if (ciphertext->size < blocksize
-		    || (ciphertext->size % blocksize != 0))
-			return
-			    gnutls_assert_val
-			    (GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
-
-		if (explicit_iv) {
-			_gnutls_auth_cipher_setiv(&params->read.
-						  cipher_state,
-						  ciphertext->data,
-						  blocksize);
-
-			ciphertext->size -= blocksize;
-			ciphertext->data += blocksize;
-		}
-
-		if (ciphertext->size < tag_size + 2)
-			return
-			    gnutls_assert_val(GNUTLS_E_DECRYPTION_FAILED);
-
-		length_to_decrypt = ciphertext->size;
-		if (length_to_decrypt < blocksize)
-			return
-			    gnutls_assert_val
-			    (GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
-
-		break;
-
-	default:
-		return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
-	}
-
-	length = ciphertext->size - tag_size;
-
-	preamble_size =
-	    make_preamble(UINT64DATA(*sequence), type,
-			  length, ver, preamble);
-
-	_gnutls_auth_cipher_set_mac_nonce(&params->write.cipher_state,
-					  UINT64DATA(*sequence), 8);
-	ret =
-	    _gnutls_auth_cipher_add_auth(&params->read.cipher_state,
-					 preamble, preamble_size);
-	if (ret < 0)
-		return gnutls_assert_val(ret);
-
-	ret =
-	    _gnutls_auth_cipher_decrypt2(&params->read.cipher_state,
-					 ciphertext->data,
-					 length_to_decrypt,
-					 ciphertext->data,
-					 ciphertext->size);
-	if (ret < 0)
-		return gnutls_assert_val(ret);
-
-	pad = _gnutls_read_uint16(ciphertext->data);
-
-	tag_ptr = &ciphertext->data[length];
-	ret =
-	    _gnutls_auth_cipher_tag(&params->read.cipher_state, tag,
-				    tag_size);
-	if (ret < 0)
-		return gnutls_assert_val(ret);
-
-	/* Check MAC.
-	 */
-	if (memcmp(tag, tag_ptr, tag_size) != 0)
-		return gnutls_assert_val(GNUTLS_E_DECRYPTION_FAILED);
-
-	DECR_LEN(length, 2 + pad);
-
-	/* copy the decrypted stuff to compress_data.
-	 */
-	if (compressed->size < (unsigned) length)
-		return gnutls_assert_val(GNUTLS_E_DECOMPRESSION_FAILED);
-
-	memcpy(compressed->data, &ciphertext->data[2 + pad], length);
-
-	return length;
-}
diff --git a/lib/gnutls_constate.c b/lib/gnutls_constate.c
index 1336652556..97c538d34d 100644
--- a/lib/gnutls_constate.c
+++ b/lib/gnutls_constate.c
@@ -362,14 +362,10 @@ int _gnutls_epoch_set_keys(gnutls_session_t session, uint16_t epoch)
 	ret = _gnutls_init_record_state(params, ver, 1, &params->read);
 	if (ret < 0)
 		return gnutls_assert_val(ret);
-	params->read.new_record_padding =
-	    session->security_parameters.new_record_padding;
 
 	ret = _gnutls_init_record_state(params, ver, 0, &params->write);
 	if (ret < 0)
 		return gnutls_assert_val(ret);
-	params->write.new_record_padding =
-	    session->security_parameters.new_record_padding;
 
 	params->record_sw_size = 0;
 
diff --git a/lib/gnutls_dtls.c b/lib/gnutls_dtls.c
index c1d8727f1a..3b14322081 100644
--- a/lib/gnutls_dtls.c
+++ b/lib/gnutls_dtls.c
@@ -577,8 +577,7 @@ void gnutls_dtls_set_mtu(gnutls_session_t session, unsigned int mtu)
 
 static int record_overhead(const cipher_entry_st * cipher,
 			   const mac_entry_st * mac,
-			   gnutls_compression_method_t comp,
-			   unsigned new_padding)
+			   gnutls_compression_method_t comp)
 {
 	int total = 0;
 	int t, ret;
@@ -589,8 +588,7 @@ static int record_overhead(const cipher_entry_st * cipher,
 
 		/* padding */
 		t = _gnutls_cipher_get_block_size(cipher);
-		if (new_padding == 0)
-			total += t;
+		total += t;
 	}
 
 	if (mac->id == GNUTLS_MAC_AEAD) {
@@ -604,9 +602,6 @@ static int record_overhead(const cipher_entry_st * cipher,
 		total += ret;
 	}
 
-	if (new_padding != 0)
-		total += 2;
-
 	if (comp != GNUTLS_COMP_NULL)
 		total += EXTRA_COMP_SIZE;
 
@@ -659,7 +654,7 @@ size_t gnutls_est_record_overhead_size(gnutls_protocol_t version,
 	else
 		total = DTLS_RECORD_HEADER_SIZE;
 
-	total += record_overhead(c, m, comp, 0);
+	total += record_overhead(c, m, comp);
 
 	return total;
 }
@@ -687,9 +682,7 @@ static int record_overhead_rt(gnutls_session_t session)
 
 	/* requires padding */
 	return record_overhead(params->cipher, params->mac,
-			       params->compression_algorithm,
-			       session->security_parameters.
-			       new_record_padding);
+			       params->compression_algorithm);
 }
 
 /**
diff --git a/lib/gnutls_extensions.c b/lib/gnutls_extensions.c
index ef96a3e9ee..508e4883be 100644
--- a/lib/gnutls_extensions.c
+++ b/lib/gnutls_extensions.c
@@ -42,7 +42,6 @@
 #include <ext/srtp.h>
 #include <ext/alpn.h>
 #include <ext/dumbfw.h>
-#include <ext/new_record_padding.h>
 #include <gnutls_num.h>
 
 
@@ -337,10 +336,6 @@ int _gnutls_ext_init(void)
 		return ret;
 #endif
 
-	ret = _gnutls_ext_register(&ext_mod_new_record_padding);
-	if (ret != GNUTLS_E_SUCCESS)
-		return ret;
-
 	ret = _gnutls_ext_register(&ext_mod_session_ticket);
 	if (ret != GNUTLS_E_SUCCESS)
 		return ret;
diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index 4af861b134..6599f41faa 100644
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -548,9 +548,6 @@ typedef struct {
 	uint8_t session_id_size;
 	time_t timestamp;
 
-	/* if non-zero the new record padding is used */
-	uint8_t new_record_padding;
-
 	/* The send size is the one requested by the programmer.
 	 * The recv size is the one negotiated with the peer.
 	 */
@@ -582,7 +579,6 @@ struct record_state_st {
 	auth_cipher_hd_st cipher_state;
 	comp_hd_st compression_state;
 	uint64 sequence_number;
-	uint8_t new_record_padding;
 };
 
 
@@ -644,7 +640,6 @@ struct gnutls_priority_st {
 	/* to disable record padding */
 	bool no_extensions;
 	bool allow_large_records;
-	bool new_record_padding;
 	unsigned int max_empty_records;
 	unsigned int dumbfw;
 	safe_renegotiation_t sr;
@@ -1053,9 +1048,6 @@ inline static size_t max_user_send_size(gnutls_session_t session,
 		max = session->security_parameters.max_record_send_size;
 		/* DTLS data MTU accounts for those */
 
-		if (record_params->write.new_record_padding != 0)
-			max -= 2;
-
 		if (_gnutls_cipher_is_block(record_params->cipher))
 			max -=
 			    _gnutls_cipher_get_block_size(record_params->
diff --git a/lib/gnutls_priority.c b/lib/gnutls_priority.c
index a6e1882766..e01783f97b 100644
--- a/lib/gnutls_priority.c
+++ b/lib/gnutls_priority.c
@@ -857,10 +857,6 @@ static void enable_server_precedence(gnutls_priority_t c)
 {
 	c->server_precedence = 1;
 }
-static void enable_new_padding(gnutls_priority_t c)
-{
-	c->new_record_padding = 1;
-}
 static void dummy_func(gnutls_priority_t c)
 {
 }
diff --git a/lib/gnutls_range.c b/lib/gnutls_range.c
index 853e54a7e0..3209055b22 100644
--- a/lib/gnutls_range.c
+++ b/lib/gnutls_range.c
@@ -58,13 +58,8 @@ _gnutls_range_max_lh_pad(gnutls_session_t session, ssize_t data_length,
 		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 	}
 
-	if (session->security_parameters.new_record_padding != 0) {
-		max_pad = max_user_send_size(session, record_params);
-		fixed_pad = 2;
-	} else {
-		max_pad = MAX_PAD_SIZE;
-		fixed_pad = 1;
-	}
+	max_pad = MAX_PAD_SIZE;
+	fixed_pad = 1;
 
 	this_pad = MIN(max_pad, max_frag - data_length);
 
@@ -110,9 +105,6 @@ int gnutls_record_can_use_length_hiding(gnutls_session_t session)
 	int ret;
 	record_parameters_st *record_params;
 
-	if (session->security_parameters.new_record_padding != 0)
-		return 1;
-
 	if (get_num_version(session) == GNUTLS_SSL3)
 		return 0;
 
diff --git a/lib/gnutls_record.h b/lib/gnutls_record.h
index 71689b75f0..4af18c291d 100644
--- a/lib/gnutls_record.h
+++ b/lib/gnutls_record.h
@@ -83,9 +83,6 @@ unsigned int get_total_headers(gnutls_session_t session)
 	record_parameters_st *params;
 	unsigned total = RECORD_HEADER_SIZE(session);
 
-	if (session->security_parameters.new_record_padding)
-		total += 2;
-
 	ret = _gnutls_epoch_get(session, EPOCH_WRITE_CURRENT, &params);
 	if (ret < 0) {
 		return total;
@@ -99,9 +96,6 @@ unsigned int get_total_headers2(gnutls_session_t session, record_parameters_st *
 {
 	unsigned total = RECORD_HEADER_SIZE(session);
 
-	if (session->security_parameters.new_record_padding)
-		total += 2;
-
 	return total + _gnutls_cipher_get_explicit_iv_size(params->cipher);
 }
 
diff --git a/lib/gnutls_session_pack.c b/lib/gnutls_session_pack.c
index 0fb11eeb2e..6195856017 100644
--- a/lib/gnutls_session_pack.c
+++ b/lib/gnutls_session_pack.c
@@ -769,8 +769,6 @@ pack_security_parameters(gnutls_session_t session, gnutls_buffer_st * ps)
 	BUFFER_APPEND_NUM(ps,
 			  session->security_parameters.
 			  max_record_recv_size);
-	BUFFER_APPEND(ps, &session->security_parameters.new_record_padding,
-		      1);
 	BUFFER_APPEND_NUM(ps, session->security_parameters.ecc_curve);
 
 	BUFFER_APPEND_NUM(ps,
@@ -855,10 +853,6 @@ unpack_security_parameters(gnutls_session_t session, gnutls_buffer_st * ps)
 		       session->internals.resumed_security_parameters.
 		       max_record_recv_size);
 
-	BUFFER_POP(ps,
-		   &session->internals.resumed_security_parameters.
-		   new_record_padding, 1);
-
 	BUFFER_POP_NUM(ps,
 		       session->internals.resumed_security_parameters.
 		       ecc_curve);
diff --git a/lib/priority_options.gperf b/lib/priority_options.gperf
index fea1f2911f..683d37e4f6 100644
--- a/lib/priority_options.gperf
+++ b/lib/priority_options.gperf
@@ -27,4 +27,4 @@ PROFILE_HIGH, enable_profile_high
 PROFILE_ULTRA, enable_profile_ultra
 PROFILE_SUITEB128, enable_profile_suiteb128
 PROFILE_SUITEB192, enable_profile_suiteb192
-NEW_PADDING, enable_new_padding
+NEW_PADDING, dummy_func
diff --git a/src/cli-args.def b/src/cli-args.def
index 9bc90490d1..63164b000a 100644
--- a/src/cli-args.def
+++ b/src/cli-args.def
@@ -249,7 +249,7 @@ flag = {
 flag = {
     name      = ranges;
     descrip   = "Use length-hiding padding to prevent traffic analysis";
-    doc      = "When possible (e.g., when %NEW_PADDING is specified), use length-hiding padding to prevent traffic analysis.";
+    doc      = "When possible (e.g., when using CBC ciphersuites), use length-hiding padding to prevent traffic analysis.";
 };
 
 flag = {
diff --git a/tests/mini-record-2.c b/tests/mini-record-2.c
index 3c7cebbc6e..1b2f65c555 100644
--- a/tests/mini-record-2.c
+++ b/tests/mini-record-2.c
@@ -419,16 +419,9 @@ static void start(const char *prio, int ign)
 
 #define NULL_SHA1 "NONE:+VERS-TLS1.0:-CIPHER-ALL:+NULL:+SHA1:+SIGN-ALL:+COMP-NULL:+ANON-ECDH:+RSA:+CURVE-ALL"
 
-#define NEW_AES_CBC "NONE:+VERS-TLS1.0:-CIPHER-ALL:+AES-128-CBC:+SHA1:+SIGN-ALL:+COMP-NULL:+ANON-ECDH:+CURVE-ALL:%NEW_PADDING"
-#define NEW_ARCFOUR_SHA1 "NONE:+VERS-TLS1.0:-CIPHER-ALL:+ARCFOUR-128:+SHA1:+SIGN-ALL:+COMP-NULL:+ANON-ECDH:+CURVE-ALL:%NEW_PADDING"
-#define NEW_AES_CBC_SHA256 "NONE:+VERS-TLS1.2:-CIPHER-ALL:+RSA:+AES-128-CBC:+AES-256-CBC:+SHA256:+SIGN-ALL:+COMP-NULL:+ANON-ECDH:+CURVE-ALL:%NEW_PADDING"
-#define NEW_AES_GCM "NONE:+VERS-TLS1.2:-CIPHER-ALL:+RSA:+AES-128-GCM:+MAC-ALL:+SIGN-ALL:+COMP-NULL:+ANON-ECDH:+CURVE-ALL:%NEW_PADDING"
-
 #define ARCFOUR_SHA1_ZLIB "NONE:+VERS-TLS1.0:-CIPHER-ALL:+ARCFOUR-128:+SHA1:+SIGN-ALL:+COMP-DEFLATE:+ANON-ECDH:+CURVE-ALL"
-#define NEW_ARCFOUR_SHA1_ZLIB "NONE:+VERS-TLS1.0:-CIPHER-ALL:+ARCFOUR-128:+SHA1:+SIGN-ALL:+COMP-DEFLATE:+ANON-ECDH:+CURVE-ALL:%NEW_PADDING"
 
 #define AES_GCM_ZLIB "NONE:+VERS-TLS1.2:-CIPHER-ALL:+AES-128-GCM:+AEAD:+SIGN-ALL:+COMP-DEFLATE:+RSA:+CURVE-ALL"
-#define NEW_AES_GCM_ZLIB "NONE:+VERS-TLS1.2:-CIPHER-ALL:+AES-128-GCM:+AEAD:+SIGN-ALL:+COMP-DEFLATE:+RSA:+CURVE-ALL:%NEW_PADDING"
 
 static void ch_handler(int sig)
 {
@@ -450,30 +443,23 @@ void doit(void)
 {
 	signal(SIGCHLD, ch_handler);
 
-	start(NEW_AES_CBC, 1);
-	start(NEW_AES_CBC_SHA256, 1);
-	start(NEW_AES_GCM, 1);
-
 	start(AES_CBC, 1);
 	start(AES_CBC_SHA256, 1);
 	start(AES_GCM, 0);
 
 #ifndef ENABLE_FIPS140
 	start(NULL_SHA1, 0);
-	start(NEW_ARCFOUR_SHA1, 1);
 
 	start(ARCFOUR_SHA1, 0);
 	start(ARCFOUR_MD5, 0);
 
 # ifdef HAVE_LIBZ
 	start(ARCFOUR_SHA1_ZLIB, 0);
-	start(NEW_ARCFOUR_SHA1_ZLIB, 1);
 # endif
 #endif
 
 #ifdef HAVE_LIBZ
 	start(AES_GCM_ZLIB, 0);
-	start(NEW_AES_GCM_ZLIB, 1);
 #endif
 }
 
diff --git a/tests/mini-record-range.c b/tests/mini-record-range.c
index 10b793737a..7d35b9303c 100644
--- a/tests/mini-record-range.c
+++ b/tests/mini-record-range.c
@@ -27,7 +27,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#if defined(_WIN32)
+#if 1
 
 int main()
 {
@@ -358,7 +358,7 @@ static void start(const char *prio)
 	}
 }
 
-#define AES_CBC "NORMAL:+ANON-ECDH:+CURVE-ALL:%NEW_PADDING"
+#define AES_CBC "NORMAL:+ANON-ECDH:+CURVE-ALL"
 
 static void ch_handler(int sig)
 {
diff --git a/tests/mini-record.c b/tests/mini-record.c
index 001c1eabf5..71b2236b3d 100644
--- a/tests/mini-record.c
+++ b/tests/mini-record.c
@@ -382,10 +382,6 @@ static void start(const char *prio)
 #define AES_CBC_SHA256 "NONE:+VERS-DTLS1.0:-CIPHER-ALL:+RSA:+AES-128-CBC:+AES-256-CBC:+SHA256:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL"
 #define AES_GCM "NONE:+VERS-DTLS1.0:-CIPHER-ALL:+RSA:+AES-128-GCM:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL"
 
-#define NEW_AES_CBC "NONE:+VERS-DTLS1.0:-CIPHER-ALL:+AES-128-CBC:+SHA1:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL:%NEW_PADDING"
-#define NEW_AES_CBC_SHA256 "NONE:+VERS-DTLS1.0:-CIPHER-ALL:+RSA:+AES-128-CBC:+AES-256-CBC:+SHA256:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL:%NEW_PADDING"
-#define NEW_AES_GCM "NONE:+VERS-DTLS1.0:-CIPHER-ALL:+RSA:+AES-128-GCM:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL:%NEW_PADDING"
-
 static void ch_handler(int sig)
 {
 	int status;
@@ -406,10 +402,6 @@ void doit(void)
 {
 	signal(SIGCHLD, ch_handler);
 
-	start(NEW_AES_CBC);
-	start(NEW_AES_CBC_SHA256);
-	start(NEW_AES_GCM);
-
 	start(AES_CBC);
 	start(AES_CBC_SHA256);
 	start(AES_GCM);