Merge branch 'remove-guint64' into 'master'tmp-draft-ietf-quic-tls-23

lib: drop gnutls_uint64 usage as sequence number

See merge request gnutls/gnutls!1102

16 files changed, 223 insertions, 358 deletions

diff --git a/lib/Makefile.am b/lib/Makefile.am
index 9fe78afbdc..f1e3bb90b6 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -66,7 +66,7 @@ SRP_COBJECTS = srp.c
 PSK_COBJECTS = psk.c
 
 COBJECTS = range.c record.c compress.c debug.c cipher.c gthreads.h handshake-tls13.c \
-	mbuffers.c buffers.c handshake.c num.c errors.c dh.c kx.c cipher-cbc.c \
+	mbuffers.c buffers.c handshake.c errors.c dh.c kx.c cipher-cbc.c \
 	priority.c hash_int.c cipher_int.c session.c db.c x509_b64.c	\
 	hello_ext.c auth.c sslv2_compat.c datum.c session_pack.c mpi.c \
 	pk.c cert-cred.c global.c constate.c anon_cred.c pkix_asn1_tab.c gnutls_asn1_tab.c	\
diff --git a/lib/buffers.c b/lib/buffers.c
index 1ca8b3705a..2d0e3d8afc 100644
--- a/lib/buffers.c
+++ b/lib/buffers.c
@@ -67,12 +67,12 @@
  */
 void
 _gnutls_record_buffer_put(gnutls_session_t session,
-			  content_type_t type, const gnutls_uint64 * seq,
+			  content_type_t type, uint64_t seq,
 			  mbuffer_st * bufel)
 {
 
 	bufel->type = type;
-	memcpy(&bufel->record_sequence, seq, sizeof(*seq));
+	bufel->record_sequence = seq;
 
 	_mbuffer_enqueue(&session->internals.record_buffer, bufel);
 	_gnutls_buffers_log("BUF[REC]: Inserted %d bytes of Data(%d)\n",
@@ -155,7 +155,7 @@ _gnutls_record_buffer_get(content_type_t type,
 		length = msg.size;
 
 	if (seq)
-		memcpy(seq, bufel->record_sequence.i, 8);
+		_gnutls_write_uint64(bufel->record_sequence, seq);
 
 	memcpy(data, msg.data, length);
 	_mbuffer_head_remove_bytes(&session->internals.record_buffer,
diff --git a/lib/buffers.h b/lib/buffers.h
index ef5171a0ce..5576020680 100644
--- a/lib/buffers.h
+++ b/lib/buffers.h
@@ -29,7 +29,7 @@
 
 void
 _gnutls_record_buffer_put(gnutls_session_t session,
-			  content_type_t type, const gnutls_uint64 * seq,
+			  content_type_t type, uint64_t seq,
 			  mbuffer_st * bufel);
 
 inline static int _gnutls_record_buffer_get_size(gnutls_session_t session)
diff --git a/lib/cipher-cbc.c b/lib/cipher-cbc.c
index 26f72d7ea4..178fc2e5e8 100644
--- a/lib/cipher-cbc.c
+++ b/lib/cipher-cbc.c
@@ -72,7 +72,7 @@ static void dummy_wait(record_parameters_st *params,
 int cbc_mac_verify(gnutls_session_t session, record_parameters_st *params,
 		   uint8_t preamble[MAX_PREAMBLE_SIZE],
 		   content_type_t type,
-		   const gnutls_uint64 *sequence,
+		   uint64_t sequence,
 		   const uint8_t *data, size_t data_size,
 		   size_t tag_size)
 {
@@ -126,7 +126,7 @@ int cbc_mac_verify(gnutls_session_t session, record_parameters_st *params,
 	 * MAC.
 	 */
 	preamble_size =
-	    _gnutls_make_preamble(UINT64DATA(*sequence), type,
+	    _gnutls_make_preamble(sequence, type,
 				  length, ver, preamble);
 
 	ret =
diff --git a/lib/cipher.c b/lib/cipher.c
index b69a228db5..275c57a4e8 100644
--- a/lib/cipher.c
+++ b/lib/cipher.c
@@ -54,14 +54,14 @@ static int decrypt_packet(gnutls_session_t session,
 			    gnutls_datum_t * plain,
 			    content_type_t type,
 			    record_parameters_st * params,
-			    const gnutls_uint64 * sequence);
+			    uint64_t sequence);
 
 static int
 decrypt_packet_tls13(gnutls_session_t session,
 		     gnutls_datum_t * ciphertext,
 		     gnutls_datum_t * plain,
 		     content_type_t *type, record_parameters_st * params,
-		     const gnutls_uint64 * sequence);
+		     uint64_t sequence);
 
 static int
 encrypt_packet_tls13(gnutls_session_t session,
@@ -138,7 +138,7 @@ _gnutls_decrypt(gnutls_session_t session,
 		gnutls_datum_t *output,
 		content_type_t *type,
 		record_parameters_st *params,
-		const gnutls_uint64 *sequence)
+		uint64_t sequence)
 {
 	int ret;
 	const version_entry_st *vers = get_version(session);
@@ -213,7 +213,7 @@ calc_enc_length_stream(gnutls_session_t session, int data_size,
  * and are not to be sent). Returns their size.
  */
 int
-_gnutls_make_preamble(const uint8_t * uint64_data, uint8_t type, unsigned int length,
+_gnutls_make_preamble(uint64_t uint64_data, uint8_t type, unsigned int length,
 		      const version_entry_st * ver, uint8_t preamble[MAX_PREAMBLE_SIZE])
 {
 	uint8_t *p = preamble;
@@ -221,7 +221,7 @@ _gnutls_make_preamble(const uint8_t * uint64_data, uint8_t type, unsigned int le
 
 	c_length = _gnutls_conv_uint16(length);
 
-	memcpy(p, uint64_data, 8);
+	_gnutls_write_uint64(uint64_data, p);
 	p += 8;
 	*p = type;
 	p++;
@@ -345,9 +345,7 @@ encrypt_packet(gnutls_session_t session,
 			 */
 			memcpy(nonce, params->write.iv,
 			       params->write.iv_size);
-			memcpy(&nonce[imp_iv_size],
-			       UINT64DATA(params->write.sequence_number),
-			       8);
+			_gnutls_write_uint64(params->write.sequence_number, &nonce[imp_iv_size]);
 
 			memcpy(data_ptr, &nonce[imp_iv_size],
 			       exp_iv_size);
@@ -359,8 +357,7 @@ encrypt_packet(gnutls_session_t session,
 				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
 
 			memset(nonce, 0, 4);
-			memcpy(&nonce[4],
-			       UINT64DATA(params->write.sequence_number), 8);
+			_gnutls_write_uint64(params->write.sequence_number, &nonce[4]);
 
 			memxor(nonce, params->write.iv, 12);
 		}
@@ -372,7 +369,7 @@ encrypt_packet(gnutls_session_t session,
 		ret = plain->size;
 
 	preamble_size =
-	    _gnutls_make_preamble(UINT64DATA(params->write.sequence_number),
+	    _gnutls_make_preamble(params->write.sequence_number,
 				  type, ret, ver, preamble);
 
 	if (algo_type == CIPHER_BLOCK || algo_type == CIPHER_STREAM) {
@@ -453,8 +450,9 @@ encrypt_packet_tls13(gnutls_session_t session,
 	if (unlikely(iv_size < 8))
 		return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
 
-	memcpy(nonce, params->write.iv, iv_size);
-	memxor(&nonce[iv_size-8], UINT64DATA(params->write.sequence_number), 8);
+	memset(nonce, 0, iv_size - 8);
+	_gnutls_write_uint64(params->write.sequence_number, &nonce[iv_size-8]);
+	memxor(nonce, params->write.iv, iv_size);
 
 	max = MAX_RECORD_SEND_SIZE(session);
 
@@ -526,7 +524,7 @@ decrypt_packet(gnutls_session_t session,
 		gnutls_datum_t * ciphertext,
 		gnutls_datum_t * plain,
 		content_type_t type, record_parameters_st * params,
-		const gnutls_uint64 * sequence)
+		uint64_t sequence)
 {
 	uint8_t tag[MAX_HASH_SIZE];
 	uint8_t nonce[MAX_CIPHER_IV_SIZE];
@@ -560,7 +558,7 @@ decrypt_packet(gnutls_session_t session,
 		if (unlikely(ciphertext->size < tag_size))
 			return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
 
-		preamble_size = _gnutls_make_preamble(UINT64DATA(*sequence),
+		preamble_size = _gnutls_make_preamble(sequence,
 						      type, ciphertext->size-tag_size,
 						      ver, preamble);
 
@@ -622,7 +620,7 @@ decrypt_packet(gnutls_session_t session,
 				return gnutls_assert_val(GNUTLS_E_DECRYPTION_FAILED);
 
 			memset(nonce, 0, 4);
-			memcpy(&nonce[4], UINT64DATA(*sequence), 8);
+			_gnutls_write_uint64(sequence, &nonce[4]);
 
 			memxor(nonce, params->read.iv, 12);
 		}
@@ -636,7 +634,7 @@ decrypt_packet(gnutls_session_t session,
 		 * MAC.
 		 */
 		preamble_size =
-		    _gnutls_make_preamble(UINT64DATA(*sequence), type,
+		    _gnutls_make_preamble(sequence, type,
 					  length, ver, preamble);
 
 
@@ -676,7 +674,7 @@ decrypt_packet(gnutls_session_t session,
 		 * MAC.
 		 */
 		preamble_size =
-		    _gnutls_make_preamble(UINT64DATA(*sequence), type,
+		    _gnutls_make_preamble(sequence, type,
 					  length, ver, preamble);
 
 		ret =
@@ -808,7 +806,7 @@ decrypt_packet_tls13(gnutls_session_t session,
 		     gnutls_datum_t *ciphertext,
 		     gnutls_datum_t *plain,
 		     content_type_t *type, record_parameters_st *params,
-		     const gnutls_uint64 *sequence)
+		     uint64_t sequence)
 {
 	uint8_t nonce[MAX_CIPHER_IV_SIZE];
 	size_t length, length_to_decrypt;
@@ -844,8 +842,9 @@ decrypt_packet_tls13(gnutls_session_t session,
 	if (unlikely(params->read.iv_size != iv_size || iv_size < 8))
 		return gnutls_assert_val(GNUTLS_E_DECRYPTION_FAILED);
 
-	memcpy(nonce, params->read.iv, params->read.iv_size);
-	memxor(&nonce[iv_size-8], UINT64DATA(*sequence), 8);
+	memset(nonce, 0, iv_size - 8);
+	_gnutls_write_uint64(sequence, &nonce[iv_size-8]);
+	memxor(nonce, params->read.iv, params->read.iv_size);
 
 	length =
 	    ciphertext->size - tag_size;
diff --git a/lib/cipher.h b/lib/cipher.h
index ada9929369..43cdde22f4 100644
--- a/lib/cipher.h
+++ b/lib/cipher.h
@@ -32,18 +32,18 @@ int _gnutls_encrypt(gnutls_session_t session,
 int _gnutls_decrypt(gnutls_session_t session,
 		    gnutls_datum_t * ciphertext, gnutls_datum_t * output,
 		    content_type_t *type, record_parameters_st * params,
-		    const gnutls_uint64 * sequence);
+		    uint64_t sequence);
 
 #define MAX_PREAMBLE_SIZE 16
 
 int
-_gnutls_make_preamble(const uint8_t * uint64_data, uint8_t type, unsigned int length,
+_gnutls_make_preamble(uint64_t uint64_data, uint8_t type, unsigned int length,
 		      const version_entry_st * ver, uint8_t preamble[MAX_PREAMBLE_SIZE]);
 
 int cbc_mac_verify(gnutls_session_t session, record_parameters_st *params,
 		   uint8_t preamble[MAX_PREAMBLE_SIZE],
 		   content_type_t type,
-		   const gnutls_uint64 *sequence,
+		   uint64_t sequence,
 		   const uint8_t *data, size_t data_size,
 		   size_t tag_size);
 
diff --git a/lib/constate.c b/lib/constate.c
index fc307debc3..51943ede69 100644
--- a/lib/constate.c
+++ b/lib/constate.c
@@ -981,10 +981,12 @@ _gnutls_epoch_setup_next(gnutls_session_t session, unsigned null_epoch, record_p
 		(*slot)->mac = NULL;
 	}
 
-	if (IS_DTLS(session))
-		_gnutls_write_uint16(session->security_parameters.epoch_next,
-				     UINT64DATA((*slot)->write.
-						sequence_number));
+	if (IS_DTLS(session)) {
+		uint64_t seq = (*slot)->write.sequence_number;
+		seq &= UINT64_C(0xffffffffffff);
+		seq |= ((uint64_t)session->security_parameters.epoch_next) << 48;
+		(*slot)->write.sequence_number = seq;
+	}
 
  finish:
 	if (newp != NULL)
diff --git a/lib/dtls-sw.c b/lib/dtls-sw.c
index f0fc5a6ef5..2511fb34a2 100644
--- a/lib/dtls-sw.c
+++ b/lib/dtls-sw.c
@@ -40,20 +40,6 @@
 
 #define DTLS_EMPTY_BITMAP		(0xFFFFFFFFFFFFFFFFULL)
 
-/* We expect the compiler to be able to spot that this is a byteswapping
- * load, and emit instructions like 'movbe' on x86_64 where appropriate.
-*/
-#define LOAD_UINT64(out, ubytes)  \
-	out = (((uint64_t)ubytes[0] << 56) |	\
-	       ((uint64_t)ubytes[1] << 48) |	\
-	       ((uint64_t)ubytes[2] << 40) |	\
-	       ((uint64_t)ubytes[3] << 32) |	\
-	       ((uint64_t)ubytes[4] << 24) |	\
-	       ((uint64_t)ubytes[5] << 16) |	\
-	       ((uint64_t)ubytes[6] << 8) |	\
-	       ((uint64_t)ubytes[7] << 0) )
-
-
 void _dtls_reset_window(struct record_parameters_st *rp)
 {
 	rp->dtls_sw_have_recv = 0;
@@ -63,12 +49,8 @@ void _dtls_reset_window(struct record_parameters_st *rp)
  * packet is detected it returns a negative value (but no sensible error code).
  * Otherwise zero.
  */
-int _dtls_record_check(struct record_parameters_st *rp, const gnutls_uint64 * _seq)
+int _dtls_record_check(struct record_parameters_st *rp, uint64_t seq_num)
 {
-	uint64_t seq_num = 0;
-
-	LOAD_UINT64(seq_num, _seq->i);
-
 	if ((seq_num >> DTLS_EPOCH_SHIFT) != rp->epoch) {
 		return gnutls_assert_val(-1);
 	}
diff --git a/lib/dtls.c b/lib/dtls.c
index b5f6cf2cb5..f0ded635c0 100644
--- a/lib/dtls.c
+++ b/lib/dtls.c
@@ -1040,7 +1040,7 @@ void gnutls_dtls_prestate_set(gnutls_session_t session,
 	if (ret < 0)
 		return;
 
-	params->write.sequence_number.i[7] = prestate->record_seq;
+	params->write.sequence_number = prestate->record_seq;
 
 	session->internals.dtls.hsk_read_seq = prestate->hsk_read_seq;
 	session->internals.dtls.hsk_write_seq =
diff --git a/lib/dtls.h b/lib/dtls.h
index 53de44621a..88fba4f3d1 100644
--- a/lib/dtls.h
+++ b/lib/dtls.h
@@ -30,7 +30,7 @@
 #include <constate.h>
 
 int _dtls_transmit(gnutls_session_t session);
-int _dtls_record_check(struct record_parameters_st *rp, const gnutls_uint64 * _seq);
+int _dtls_record_check(struct record_parameters_st *rp, uint64_t seq_num);
 void _dtls_reset_hsk_state(gnutls_session_t session);
 void _dtls_reset_window(struct record_parameters_st *rp);
 
diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index 5f1a915a14..3b683a1de1 100644
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -96,14 +96,6 @@ typedef int ssize_t;
 # define FALLTHROUGH
 #endif
 
-
-/* some systems had problems with long long int, thus,
- * it is not used.
- */
-typedef struct {
-	unsigned char i[8];
-} gnutls_uint64;
-
 #include <gnutls/gnutls.h>
 #include <gnutls/dtls.h>
 #include <gnutls/abstract.h>
@@ -462,7 +454,7 @@ typedef struct mbuffer_st {
 	content_type_t type;
 
 	/* record layer sequence */
-	gnutls_uint64 record_sequence;
+	uint64_t record_sequence;
 
 	/* Filled in by handshake layer on send:
 	 * type, epoch, htype, handshake_sequence
@@ -877,7 +869,7 @@ struct record_state_st {
 	} ctx;
 	unsigned aead_tag_size;
 	unsigned is_aead;
-	gnutls_uint64 sequence_number;
+	uint64_t sequence_number;
 };
 
 
diff --git a/lib/num.c b/lib/num.c
deleted file mode 100644
index cc62789e20..0000000000
--- a/lib/num.c
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (C) 2000-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 <https://www.gnu.org/licenses/>
- *
- */
-
-/* This file contains the functions needed for 64 bit integer support in
- * TLS, and functions which ease the access to TLS vectors (data of given size).
- */
-
-#include "gnutls_int.h"
-#include <num.h>
-#include "errors.h"
-
-/* This function will add one to uint64 x.
- * Returns 0 on success, or -1 if the uint64 max limit
- * has been reached.
- */
-int _gnutls_uint64pp(gnutls_uint64 * x)
-{
-	register int i, y = 0;
-
-	for (i = 7; i >= 0; i--) {
-		y = 0;
-		if (x->i[i] == 0xff) {
-			x->i[i] = 0;
-			y = 1;
-		} else
-			x->i[i]++;
-
-		if (y == 0)
-			break;
-	}
-	if (y != 0)
-		return -1;	/* over 64 bits! WOW */
-
-	return 0;
-}
-
-/* This function will add one to uint48 x.
- * Returns 0 on success, or -1 if the uint48 max limit
- * has been reached.
- */
-int _gnutls_uint48pp(gnutls_uint64 * x)
-{
-	register int i, y = 0;
-
-	for (i = 7; i >= 3; i--) {
-		y = 0;
-		if (x->i[i] == 0xff) {
-			x->i[i] = 0;
-			y = 1;
-		} else
-			x->i[i]++;
-
-		if (y == 0)
-			break;
-	}
-	if (y != 0)
-		return -1;	/* over 48 bits */
-
-	return 0;
-}
diff --git a/lib/num.h b/lib/num.h
index 6a7ec39d8c..c7e73a7527 100644
--- a/lib/num.h
+++ b/lib/num.h
@@ -28,11 +28,6 @@
 #include <minmax.h>
 #include <byteswap.h>
 
-int _gnutls_uint64pp(gnutls_uint64 *);
-int _gnutls_uint48pp(gnutls_uint64 *);
-
-#define UINT64DATA(x) ((x).i)
-
 inline static uint32_t _gnutls_uint24touint32(uint24 num)
 {
 	uint32_t ret = 0;
@@ -71,6 +66,17 @@ inline static uint32_t _gnutls_read_uint24(const uint8_t * data)
 	return res;
 }
 
+inline static uint64_t _gnutls_read_uint64(const uint8_t * data)
+{
+	uint64_t res;
+
+	memcpy(&res, data, sizeof(uint64_t));
+#ifndef WORDS_BIGENDIAN
+	res = bswap_64(res);
+#endif
+	return res;
+}
+
 inline static void _gnutls_write_uint64(uint64_t num, uint8_t * data)
 {
 #ifndef WORDS_BIGENDIAN
@@ -150,16 +156,4 @@ inline static uint16_t _gnutls_conv_uint16(uint16_t data)
 #endif
 }
 
-inline static uint32_t _gnutls_uint64touint32(const gnutls_uint64 * num)
-{
-	uint32_t ret;
-
-	memcpy(&ret, &num->i[4], 4);
-#ifndef WORDS_BIGENDIAN
-	ret = bswap_32(ret);
-#endif
-
-	return ret;
-}
-
 #endif /* GNUTLS_LIB_NUM_H */
diff --git a/lib/record.c b/lib/record.c
index ced217c245..af993fe6e5 100644
--- a/lib/record.c
+++ b/lib/record.c
@@ -58,7 +58,7 @@
 struct tls_record_st {
 	uint16_t header_size;
 	uint8_t version[2];
-	gnutls_uint64 sequence;	/* DTLS */
+	uint64_t sequence;	/* DTLS */
 	uint16_t length;
 	uint16_t packet_size;	/* header_size + length */
 	content_type_t type;
@@ -390,13 +390,28 @@ copy_record_version(gnutls_session_t session,
 /* Increments the sequence value
  */
 inline static int
-sequence_increment(gnutls_session_t session, gnutls_uint64 * value)
+sequence_increment(gnutls_session_t session, uint64_t * value)
 {
+	uint64_t snmax = UINT64_C(0xffffffffffffffff);
+
 	if (IS_DTLS(session)) {
-		return _gnutls_uint48pp(value);
+		uint64_t mask;
+
+		snmax = UINT64_C(0xffffffffffff);
+		mask = snmax;
+
+		if ((*value & mask) == snmax)
+			return -1;
+
+		*value = ((*value & mask) + 1) | (*value & ~mask);
 	} else {
-		return _gnutls_uint64pp(value);
+		if (*value == snmax)
+			return -1;
+
+		(*value)++;
 	}
+
+	return 0;
 }
 
 /* This function behaves exactly like write(). The only difference is
@@ -516,8 +531,7 @@ _gnutls_send_tlen_int(gnutls_session_t session, content_type_t type,
 
 		/* Adjust header length and add sequence for DTLS */
 		if (IS_DTLS(session))
-			memcpy(&headers[3],
-			       record_state->sequence_number.i, 8);
+			_gnutls_write_uint64(record_state->sequence_number, &headers[3]);
 
 		_gnutls_record_log
 		    ("REC[%p]: Preparing Packet %s(%d) with length: %d and min pad: %d\n",
@@ -577,17 +591,14 @@ _gnutls_send_tlen_int(gnutls_session_t session, content_type_t type,
 	session->internals.record_send_buffer_user_size = 0;
 
 	_gnutls_record_log
-	    ("REC[%p]: Sent Packet[%d] %s(%d) in epoch %d and length: %d\n",
-	     session, (unsigned int)
-	     _gnutls_uint64touint32(&record_state->sequence_number),
+	    ("REC[%p]: Sent Packet[%ld] %s(%d) in epoch %d and length: %d\n",
+	     session, (unsigned long)(record_state->sequence_number),
 	     _gnutls_packet2str(type), type, (int) record_params->epoch,
 	     (int) cipher_size);
 
 	if (vers->tls13_sem && !(session->internals.flags & GNUTLS_NO_AUTO_REKEY) &&
 	    !(record_params->cipher->flags & GNUTLS_CIPHER_FLAG_NO_REKEY)) {
-		if (unlikely(record_state->sequence_number.i[7] == 0xfd &&
-		    record_state->sequence_number.i[6] == 0xff &&
-		    record_state->sequence_number.i[5] == 0xff)) {
+		if (unlikely((record_state->sequence_number & UINT64_C(0xffffff)) == UINT64_C(0xfffffd))) {
 			/* After we have sent 2^24 messages, mark the session
 			 * as needing a key update. */
 			session->internals.rsend_state = RECORD_SEND_KEY_UPDATE_1;
@@ -798,7 +809,7 @@ static int
 record_add_to_buffers(gnutls_session_t session,
 		      struct tls_record_st *recv, content_type_t type,
 		      gnutls_handshake_description_t htype,
-		      const gnutls_uint64 * seq, mbuffer_st * bufel)
+		      uint64_t seq, mbuffer_st * bufel)
 {
 
 	int ret;
@@ -1122,10 +1133,9 @@ record_read_headers(gnutls_session_t session,
 		record->version[1] = headers[2];
 
 		if (IS_DTLS(session)) {
-			memcpy(record->sequence.i, &headers[3], 8);
+			record->sequence = _gnutls_read_uint64(&headers[3]);
 			record->length = _gnutls_read_uint16(&headers[11]);
-			record->epoch =
-			    _gnutls_read_uint16(record->sequence.i);
+			record->epoch = record->sequence >> 48;
 		} else {
 			memset(&record->sequence, 0,
 			       sizeof(record->sequence));
@@ -1190,14 +1200,9 @@ static int recv_headers(gnutls_session_t session,
 	if (IS_DTLS(session)) {
 		if (_gnutls_epoch_is_valid(session, record->epoch) == 0) {
 			_gnutls_audit_log(session,
-					  "Discarded message[%u] with invalid epoch %u.\n",
-					  (unsigned int)
-					  _gnutls_uint64touint32(&record->
-								 sequence),
-					  (unsigned int) record->sequence.
-					  i[0] * 256 +
-					  (unsigned int) record->sequence.
-					  i[1]);
+					  "Discarded message[%lu] with invalid epoch %u.\n",
+					  (unsigned long)record->sequence,
+					  (unsigned int) (record->sequence >> 48));
 			gnutls_assert();
 			/* doesn't matter, just a fatal error */
 			return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
@@ -1260,7 +1265,7 @@ _gnutls_recv_in_buffers(gnutls_session_t session, content_type_t type,
 			gnutls_handshake_description_t htype,
 			unsigned int ms)
 {
-	const gnutls_uint64 *packet_sequence;
+	uint64_t packet_sequence;
 	gnutls_datum_t ciphertext;
 	mbuffer_st *bufel = NULL, *decrypted = NULL;
 	gnutls_datum_t t;
@@ -1306,9 +1311,9 @@ _gnutls_recv_in_buffers(gnutls_session_t session, content_type_t type,
 	}
 
 	if (IS_DTLS(session))
-		packet_sequence = &record.sequence;
+		packet_sequence = record.sequence;
 	else
-		packet_sequence = &record_state->sequence_number;
+		packet_sequence = record_state->sequence_number;
 
 	/* Read the packet data and insert it to record_recv_buffer.
 	 */
@@ -1451,10 +1456,9 @@ _gnutls_recv_in_buffers(gnutls_session_t session, content_type_t type,
 					goto sanity_check_error;
 				}
 
-				_gnutls_record_log("REC[%p]: Discarded early data[%u] due to invalid decryption, length: %u\n",
+				_gnutls_record_log("REC[%p]: Discarded early data[%lu] due to invalid decryption, length: %u\n",
 						   session,
-						   (unsigned int)
-						   _gnutls_uint64touint32(packet_sequence),
+						   (unsigned long)packet_sequence,
 						   (unsigned int)
 						   record.length);
 				session->internals.early_data_received += record.length;
@@ -1470,9 +1474,8 @@ _gnutls_recv_in_buffers(gnutls_session_t session, content_type_t type,
 	if (ret < 0) {
 		gnutls_assert();
 		_gnutls_audit_log(session,
-				  "Discarded message[%u] due to invalid decryption\n",
-				  (unsigned int)
-				  _gnutls_uint64touint32(packet_sequence));
+				  "Discarded message[%lu] due to invalid decryption\n",
+				  (unsigned long)packet_sequence);
 		goto sanity_check_error;
 	}
 
@@ -1484,24 +1487,20 @@ _gnutls_recv_in_buffers(gnutls_session_t session, content_type_t type,
 			ret = _dtls_record_check(record_params, packet_sequence);
 			if (ret < 0) {
 				_gnutls_record_log
-				    ("REC[%p]: Discarded duplicate message[%u.%u]: %s\n",
+				    ("REC[%p]: Discarded duplicate message[%u.%lu]: %s\n",
 				     session,
-				     (unsigned int) record.sequence.i[0] * 256 +
-				     (unsigned int) record.sequence.i[1],
-				     (unsigned int)
-				     _gnutls_uint64touint32(packet_sequence),
+				     (unsigned int) (record.sequence >> 48),
+				     (unsigned long) (packet_sequence),
 				     _gnutls_packet2str(record.type));
 				goto sanity_check_error;
 			}
 		}
 
 		_gnutls_record_log
-		    ("REC[%p]: Decrypted Packet[%u.%u] %s(%d) with length: %d\n",
+		    ("REC[%p]: Decrypted Packet[%u.%lu] %s(%d) with length: %d\n",
 		     session,
-		     (unsigned int) record.sequence.i[0] * 256 +
-		     (unsigned int) record.sequence.i[1],
-		     (unsigned int)
-		     _gnutls_uint64touint32(packet_sequence),
+		     (unsigned int) (record.sequence >> 48),
+		     (unsigned long) packet_sequence,
 		     _gnutls_packet2str(record.type), record.type,
 		     (int) _mbuffer_get_udata_size(decrypted));
 
@@ -1510,10 +1509,9 @@ _gnutls_recv_in_buffers(gnutls_session_t session, content_type_t type,
 		record_state->sequence_number = record.sequence;
 	} else {
 		_gnutls_record_log
-		    ("REC[%p]: Decrypted Packet[%u] %s(%d) with length: %d\n",
+		    ("REC[%p]: Decrypted Packet[%lu] %s(%d) with length: %d\n",
 		     session,
-		     (unsigned int)
-		     _gnutls_uint64touint32(packet_sequence),
+		     (unsigned long) packet_sequence,
 		     _gnutls_packet2str(record.type), record.type,
 		     (int) _mbuffer_get_udata_size(decrypted));
 
@@ -1805,7 +1803,7 @@ void gnutls_packet_get(gnutls_packet_t packet, gnutls_datum_t *data, unsigned ch
 	assert(packet != NULL);
 
 	if (sequence) {
-		memcpy(sequence, packet->record_sequence.i, 8);
+		_gnutls_write_uint64(packet->record_sequence, sequence);
 	}
 
 	if (data) {
diff --git a/lib/state.c b/lib/state.c
index 0aec397241..ae77b9afef 100644
--- a/lib/state.c
+++ b/lib/state.c
@@ -1479,7 +1479,7 @@ gnutls_record_get_state(gnutls_session_t session,
 	}
 
 	if (seq_number)
-		memcpy(seq_number, UINT64DATA(record_state->sequence_number), 8);
+		_gnutls_write_uint64(record_state->sequence_number, seq_number);
 	return 0;
 }
 
@@ -1523,7 +1523,7 @@ gnutls_record_set_state(gnutls_session_t session,
 	else
 		record_state = &record_params->write;
 
-	memcpy(UINT64DATA(record_state->sequence_number), seq_number, 8);
+	record_state->sequence_number = _gnutls_read_uint64(seq_number);
 
 	if (IS_DTLS(session)) {
 		_dtls_reset_window(record_params);
diff --git a/tests/dtls-sliding-window.c b/tests/dtls-sliding-window.c
index f26112401a..d8e3c783c5 100644
--- a/tests/dtls-sliding-window.c
+++ b/tests/dtls-sliding-window.c
@@ -41,37 +41,14 @@ struct record_parameters_st {
 	unsigned epoch;
 };
 
-typedef struct {
-	unsigned char i[8];
-} gnutls_uint64;
 #define gnutls_assert_val(x) x
 
 void _dtls_reset_window(struct record_parameters_st *rp);
-int _dtls_record_check(struct record_parameters_st *rp, const gnutls_uint64 * _seq);
-
-/* taken from nettle */
-#ifdef WORDS_BIGENDIAN
-# define BSWAP64(x) x
-#else
-# define BSWAP64(x) \
-	((((uint64_t)(x) & 0xff) << 56) \
-	| (((uint64_t)(x) & 0xff00) << 40) \
-	| (((uint64_t)(x) & 0xff0000) << 24) \
-	| (((uint64_t)(x) & 0xff000000) << 8) \
-	| (((uint64_t)(x) >> 8) & 0xff000000) \
-	| (((uint64_t)(x) >> 24) & 0xff0000) \
-	| (((uint64_t)(x) >> 40) & 0xff00) \
-	| ((uint64_t)(x) >> 56) )
-#endif 
+int _dtls_record_check(struct record_parameters_st *rp, uint64_t _seq);
 
 #define DTLS_SW_NO_INCLUDES
 #include "../lib/dtls-sw.c"
 
-static void uint64_set(gnutls_uint64* t, uint64_t v)
-{
-	memcpy(t->i, &v, 8);
-}
-
 #define RESET_WINDOW \
 	memset(&state, 0, sizeof(state))
 
@@ -79,78 +56,78 @@ static void uint64_set(gnutls_uint64* t, uint64_t v)
 	state.dtls_sw_next = (((x)&DTLS_SEQ_NUM_MASK))
 
 #define SET_WINDOW_LAST_RECV(x) \
-	uint64_set(&t, BSWAP64(x)); \
+	t = x; \
 	state.dtls_sw_have_recv = 1
 
 static void check_dtls_window_uninit_0(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(0);
 
-	uint64_set(&t, 0);
+	t = 0;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_uninit_large(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 
-	uint64_set(&t, BSWAP64(LARGE_INT+1+64));
+	t = LARGE_INT+1+64;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_uninit_very_large(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 
-	uint64_set(&t, BSWAP64(INT_OVER_32_BITS));
+	t = INT_OVER_32_BITS;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_12(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(0);
 	SET_WINDOW_LAST_RECV(1);
 
-	uint64_set(&t, BSWAP64(2));
+	t = 2;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_19(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(0);
 	SET_WINDOW_LAST_RECV(1);
 
-	uint64_set(&t, BSWAP64(9));
+	t = 9;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_skip1(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 	unsigned i;
 
 	RESET_WINDOW;
@@ -158,15 +135,15 @@ static void check_dtls_window_skip1(void **glob_state)
 	SET_WINDOW_LAST_RECV(1);
 
 	for (i=2;i<256;i+=2) {
-		uint64_set(&t, BSWAP64(i));
-		assert_int_equal(_dtls_record_check(&state, &t), 0);
+		t = i;
+		assert_int_equal(_dtls_record_check(&state, t), 0);
 	}
 }
 
 static void check_dtls_window_skip3(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 	unsigned i;
 
 	RESET_WINDOW;
@@ -174,327 +151,327 @@ static void check_dtls_window_skip3(void **glob_state)
 	SET_WINDOW_LAST_RECV(1);
 
 	for (i=5;i<256;i+=2) {
-		uint64_set(&t, BSWAP64(i));
-		assert_int_equal(_dtls_record_check(&state, &t), 0);
+		t = i;
+		assert_int_equal(_dtls_record_check(&state, t), 0);
 	}
 }
 
 static void check_dtls_window_21(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(0);
 	SET_WINDOW_LAST_RECV(2);
 
-	uint64_set(&t, BSWAP64(1));
+	t = 1;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_91(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(0);
 	SET_WINDOW_LAST_RECV(9);
 
-	uint64_set(&t, BSWAP64(1));
+	t = 1;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_large_21(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT);
 	SET_WINDOW_LAST_RECV(LARGE_INT+2);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+1));
+	t = LARGE_INT+1;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_large_12(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT);
 	SET_WINDOW_LAST_RECV(LARGE_INT+1);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+2));
+	t = LARGE_INT+2;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_large_91(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT);
 	SET_WINDOW_LAST_RECV(LARGE_INT+9);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+1));
+	t = LARGE_INT+1;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_large_19(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT);
 	SET_WINDOW_LAST_RECV(LARGE_INT+1);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+9));
+	t = LARGE_INT+9;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_very_large_12(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(INT_OVER_32_BITS);
 	SET_WINDOW_LAST_RECV(INT_OVER_32_BITS+1);
 
-	uint64_set(&t, BSWAP64(INT_OVER_32_BITS+2));
+	t = INT_OVER_32_BITS+2;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_very_large_91(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(INT_OVER_32_BITS);
 	SET_WINDOW_LAST_RECV(INT_OVER_32_BITS+9);
 
-	uint64_set(&t, BSWAP64(INT_OVER_32_BITS+1));
+	t = INT_OVER_32_BITS+1;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_very_large_19(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(INT_OVER_32_BITS);
 	SET_WINDOW_LAST_RECV(INT_OVER_32_BITS+1);
 
-	uint64_set(&t, BSWAP64(INT_OVER_32_BITS+9));
+	t = INT_OVER_32_BITS+9;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_outside(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(0);
 	SET_WINDOW_LAST_RECV(1);
 
-	uint64_set(&t, BSWAP64(1+64));
+	t = 1+64;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_large_outside(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT);
 	SET_WINDOW_LAST_RECV(LARGE_INT+1);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+1+64));
+	t = LARGE_INT+1+64;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_very_large_outside(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(INT_OVER_32_BITS);
 	SET_WINDOW_LAST_RECV(INT_OVER_32_BITS+1);
 
-	uint64_set(&t, BSWAP64(INT_OVER_32_BITS+1+64));
+	t = INT_OVER_32_BITS+1+64;
 
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_dup1(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT-1);
 	SET_WINDOW_LAST_RECV(LARGE_INT);
 
-	uint64_set(&t, BSWAP64(LARGE_INT));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+1));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+1;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+16));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+16;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+1));
-	assert_int_equal(_dtls_record_check(&state, &t), -3);
+	t = LARGE_INT+1;
+	assert_int_equal(_dtls_record_check(&state, t), -3);
 }
 
 static void check_dtls_window_dup2(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT-1);
 	SET_WINDOW_LAST_RECV(LARGE_INT);
 
-	uint64_set(&t, BSWAP64(LARGE_INT));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+16));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+16;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+1));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+1;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+16));
-	assert_int_equal(_dtls_record_check(&state, &t), -3);
+	t = LARGE_INT+16;
+	assert_int_equal(_dtls_record_check(&state, t), -3);
 }
 
 static void check_dtls_window_dup3(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT-1);
 	SET_WINDOW_LAST_RECV(LARGE_INT);
 
-	uint64_set(&t, BSWAP64(LARGE_INT));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+16));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+16;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+15));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+15;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+14));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+14;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+5));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+5;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+5));
-	assert_int_equal(_dtls_record_check(&state, &t), -3);
+	t = LARGE_INT+5;
+	assert_int_equal(_dtls_record_check(&state, t), -3);
 }
 
 static void check_dtls_window_out_of_order(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT-1);
 	SET_WINDOW_LAST_RECV(LARGE_INT);
 
-	uint64_set(&t, BSWAP64(LARGE_INT));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+8));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+8;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+7));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+7;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+6));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+6;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+5));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+5;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+4));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+4;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+3));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+3;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+2));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+2;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+1));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+1;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(LARGE_INT+9));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT+9;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 }
 
 static void check_dtls_window_epoch_higher(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
 	SET_WINDOW_NEXT(LARGE_INT-1);
 	SET_WINDOW_LAST_RECV(LARGE_INT);
 
-	uint64_set(&t, BSWAP64(LARGE_INT));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = LARGE_INT;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64((LARGE_INT+8)|0x1000000000000LL));
-	assert_int_equal(_dtls_record_check(&state, &t), -1);
+	t = (LARGE_INT+8)|0x1000000000000LL;
+	assert_int_equal(_dtls_record_check(&state, t), -1);
 }
 
 static void check_dtls_window_epoch_lower(void **glob_state)
 {
 	struct record_parameters_st state;
-	gnutls_uint64 t;
+	uint64_t t;
 
 	RESET_WINDOW;
-	uint64_set(&t, BSWAP64(0x1000000000000LL));
+	t = 0x1000000000000LL;
 
 	state.epoch = 1;
 	SET_WINDOW_NEXT(0x1000000000000LL);
 	SET_WINDOW_LAST_RECV((0x1000000000000LL) + 1);
 
-	uint64_set(&t, BSWAP64(2 | 0x1000000000000LL));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = 2 | 0x1000000000000LL;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(3 | 0x1000000000000LL));
-	assert_int_equal(_dtls_record_check(&state, &t), 0);
+	t = 3 | 0x1000000000000LL;
+	assert_int_equal(_dtls_record_check(&state, t), 0);
 
-	uint64_set(&t, BSWAP64(5));
-	assert_int_equal(_dtls_record_check(&state, &t), -1);
+	t = 5;
+	assert_int_equal(_dtls_record_check(&state, t), -1);
 }