tls: improve i/o loop

With tls_has_buffered_record(), entire kernel.org response
is printed at once, without 6 second pause to see its delayed EOF.

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

1 files changed, 92 insertions, 38 deletions

diff --git a/networking/tls.c b/networking/tls.c
index cdce1004e..000d2aedc 100644
--- a/networking/tls.c
+++ b/networking/tls.c
@@ -48,7 +48,7 @@
 # define dump_raw_out(...) ((void)0)
 #endif
 
-#if 1
+#if 0
 # define dump_raw_in(...) dump_hex(__VA_ARGS__)
 #else
 # define dump_raw_in(...) ((void)0)
@@ -72,9 +72,6 @@
 #define HANDSHAKE_CLIENT_KEY_EXCHANGE   16
 #define HANDSHAKE_FINISHED              20
 
-#define SSL_HS_RANDOM_SIZE              32
-#define SSL_HS_RSA_PREMASTER_SIZE       48
-
 #define SSL_NULL_WITH_NULL_NULL                 0x0000
 #define SSL_RSA_WITH_NULL_MD5                   0x0001
 #define SSL_RSA_WITH_NULL_SHA                   0x0002
@@ -175,12 +172,15 @@ enum {
 	AES128_KEYSIZE = 16,
 	AES256_KEYSIZE = 32,
 
+	RSA_PREMASTER_SIZE = 48,
+
 	RECHDR_LEN = 5,
 
 	MAX_TLS_RECORD = (1 << 14),
+	/* 8 = 3+5. 3 extra bytes result in record data being 32-bit aligned */
 	OUTBUF_PFX = 8 + AES_BLOCKSIZE, /* header + IV */
 	OUTBUF_SFX = SHA256_OUTSIZE + AES_BLOCKSIZE, /* MAC + padding */
-	MAX_OTBUF = MAX_TLS_RECORD - OUTBUF_PFX - OUTBUF_SFX,
+	MAX_OUTBUF = MAX_TLS_RECORD - OUTBUF_PFX - OUTBUF_SFX,
 };
 
 struct record_hdr {
@@ -205,20 +205,21 @@ typedef struct tls_state {
 	uint8_t server_write_MAC_key[SHA256_OUTSIZE];
 	uint8_t client_write_key[AES256_KEYSIZE];
 	uint8_t server_write_key[AES256_KEYSIZE];
-// RFC 5246
-// sequence number
-// Each connection state contains a sequence number, which is
-// maintained separately for read and write states.  The sequence
-// number MUST be set to zero whenever a connection state is made the
-// active state.  Sequence numbers are of type uint64 and may not
-// exceed 2^64-1.
+
+	// RFC 5246
+	// sequence number
+	//   Each connection state contains a sequence number, which is
+	//   maintained separately for read and write states.  The sequence
+	//   number MUST be set to zero whenever a connection state is made the
+	//   active state.  Sequence numbers are of type uint64 and may not
+	//   exceed 2^64-1.
 	uint64_t write_seq64_be;
 
 	int outbuf_size;
 	uint8_t *outbuf;
 
 	// RFC 5246
-	// |6.2.1. Fragmentation
+	// | 6.2.1. Fragmentation
 	// |  The record layer fragments information blocks into TLSPlaintext
 	// |  records carrying data in chunks of 2^14 bytes or less.  Client
 	// |  message boundaries are not preserved in the record layer (i.e.,
@@ -290,6 +291,9 @@ static void dump_tls_record(const void *vp, int len)
 		len -= xhdr_len;
 	}
 }
+#else
+# define dump_hex(...) ((void)0)
+# define dump_tls_record(...) ((void)0)
 #endif
 
 void tls_get_random(void *buf, unsigned len)
@@ -480,12 +484,19 @@ static tls_state_t *new_tls_state(void)
 static void tls_error_die(tls_state_t *tls)
 {
 	dump_tls_record(tls->inbuf, tls->insize + tls->tail);
-	xfunc_die();
+	bb_error_msg_and_die("TODO: useful diagnostic about %p", tls);
+}
+
+static void tls_free_outbuf(tls_state_t *tls)
+{
+	free(tls->outbuf);
+	tls->outbuf_size = 0;
+	tls->outbuf = NULL;
 }
 
 static void *tls_get_outbuf(tls_state_t *tls, int len)
 {
-	if (len > MAX_OTBUF)
+	if (len > MAX_OUTBUF)
 		xfunc_die();
 	if (tls->outbuf_size < len + OUTBUF_PFX + OUTBUF_SFX) {
 		tls->outbuf_size = len + OUTBUF_PFX + OUTBUF_SFX;
@@ -670,7 +681,22 @@ static void xwrite_and_update_handshake_hash(tls_state_t *tls, unsigned size)
 	xwrite_encrypted(tls, size, RECORD_TYPE_HANDSHAKE);
 }
 
-static int xread_tls_block(tls_state_t *tls)
+static int tls_has_buffered_record(tls_state_t *tls)
+{
+	int buffered = tls->tail;
+	struct record_hdr *xhdr;
+	int rec_size;
+
+	if (buffered < RECHDR_LEN)
+		return 0;
+	xhdr = (void*)(tls->inbuf + tls->insize);
+	rec_size = RECHDR_LEN + (0x100 * xhdr->len16_hi + xhdr->len16_lo);
+	if (buffered < rec_size)
+		return 0;
+	return rec_size;
+}
+
+static int tls_xread_record(tls_state_t *tls)
 {
 	struct record_hdr *xhdr;
 	int sz;
@@ -1012,7 +1038,7 @@ static void find_key_in_der_cert(tls_state_t *tls, uint8_t *der, int len)
 static int xread_tls_handshake_block(tls_state_t *tls, int min_len)
 {
 	struct record_hdr *xhdr;
-	int len = xread_tls_block(tls);
+	int len = tls_xread_record(tls);
 
 	xhdr = (void*)tls->inbuf;
 	if (len < min_len
@@ -1177,7 +1203,7 @@ static void send_client_key_exchange(tls_state_t *tls)
 	};
 //FIXME: better size estimate
 	struct client_key_exchange *record = tls_get_outbuf(tls, sizeof(*record));
-	uint8_t rsa_premaster[SSL_HS_RSA_PREMASTER_SIZE];
+	uint8_t rsa_premaster[RSA_PREMASTER_SIZE];
 	int len;
 
 	tls_get_random(rsa_premaster, sizeof(rsa_premaster));
@@ -1383,7 +1409,7 @@ static void tls_handshake(tls_state_t *tls)
 	send_client_hello(tls);
 	get_server_hello(tls);
 
-	//RFC 5246
+	// RFC 5246
 	// The server MUST send a Certificate message whenever the agreed-
 	// upon key exchange method uses certificates for authentication
 	// (this includes all key exchange methods defined in this document
@@ -1408,7 +1434,7 @@ static void tls_handshake(tls_state_t *tls)
 
 //	if (tls->inbuf[RECHDR_LEN] == HANDSHAKE_CERTIFICATE_REQUEST) {
 //		dbg("<< CERTIFICATE_REQUEST\n");
-//RFC 5246: (in response to this,) "If no suitable certificate is available,
+// RFC 5246: (in response to this,) "If no suitable certificate is available,
 // the client MUST send a certificate message containing no
 // certificates.  That is, the certificate_list structure has a
 // length of zero. ...
@@ -1433,7 +1459,7 @@ static void tls_handshake(tls_state_t *tls)
 	send_client_finished(tls);
 
 	/* Get CHANGE_CIPHER_SPEC */
-	len = xread_tls_block(tls);
+	len = tls_xread_record(tls);
 	if (len != 1 || memcmp(tls->inbuf, rec_CHANGE_CIPHER_SPEC, 6) != 0)
 		tls_error_die(tls);
 	dbg("<< CHANGE_CIPHER_SPEC\n");
@@ -1444,7 +1470,7 @@ static void tls_handshake(tls_state_t *tls)
 		tls->min_encrypted_len_on_read = AES_BLOCKSIZE + SHA256_OUTSIZE + AES_BLOCKSIZE;
 
 	/* Get (encrypted) FINISHED from the server */
-	len = xread_tls_block(tls);
+	len = tls_xread_record(tls);
 	if (len < 4 || tls->inbuf[RECHDR_LEN] != HANDSHAKE_FINISHED)
 		tls_error_die(tls);
 	dbg("<< FINISHED\n");
@@ -1473,9 +1499,12 @@ int tls_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int tls_main(int argc UNUSED_PARAM, char **argv)
 {
 	tls_state_t *tls;
-	fd_set readfds, testfds;
+	fd_set readfds;
+	int inbuf_size;
+	const int INBUF_STEP = 4 * 1024;
 	int cfd;
 
+
 	// INIT_G();
 	// getopt32(argv, "myopts")
 
@@ -1493,13 +1522,12 @@ int tls_main(int argc UNUSED_PARAM, char **argv)
 	FD_SET(cfd, &readfds);
 	FD_SET(STDIN_FILENO, &readfds);
 
-//#define iobuf bb_common_bufsiz1
-//	setup_common_bufsiz();
+	inbuf_size = INBUF_STEP;
 	for (;;) {
+		fd_set testfds;
 		int nread;
 
 		testfds = readfds;
-
 		if (select(cfd + 1, &testfds, NULL, NULL, NULL) < 0)
 			bb_perror_msg_and_die("select");
 
@@ -1507,26 +1535,52 @@ int tls_main(int argc UNUSED_PARAM, char **argv)
 			void *buf;
 
 			dbg("STDIN HAS DATA\n");
-//TODO: growable buffer
-			buf = tls_get_outbuf(tls, 4 * 1024);
-			nread = safe_read(STDIN_FILENO, buf, 4 * 1024);
+			buf = tls_get_outbuf(tls, inbuf_size);
+			nread = safe_read(STDIN_FILENO, buf, inbuf_size);
 			if (nread < 1) {
-//&& errno != EAGAIN
+				/* We'd want to do this: */
 				/* Close outgoing half-connection so they get EOF,
-				 * but leave incoming alone so we can see response */
-//TLS has no way to encode this, doubt it's ok to do it "raw"
-//				shutdown(cfd, SHUT_WR);
+				 * but leave incoming alone so we can see response
+				 */
+				//shutdown(cfd, SHUT_WR);
+				/* But TLS has no way to encode this,
+				 * doubt it's ok to do it "raw"
+				 */
 				FD_CLR(STDIN_FILENO, &readfds);
+				tls_free_outbuf(tls);
+			} else {
+				if (nread == inbuf_size) {
+					/* TLS has per record overhead, if input comes fast,
+					 * read, encrypt and send bigger chunks
+					 */
+					inbuf_size += INBUF_STEP;
+					if (inbuf_size > MAX_OUTBUF)
+						inbuf_size = MAX_OUTBUF;
+				}
+				tls_xwrite(tls, nread);
 			}
-			tls_xwrite(tls, nread);
 		}
 		if (FD_ISSET(cfd, &testfds)) {
 			dbg("NETWORK HAS DATA\n");
-			nread = xread_tls_block(tls);
-			if (nread < 1)
-//TODO: if eof, just close stdout, but not exit!
-				return EXIT_SUCCESS;
+ read_record:
+			nread = tls_xread_record(tls);
+			if (nread < 1) {
+				/* TLS protocol has no real concept of one-sided shutdowns:
+				 * if we get "TLS EOF" from the peer, writes will fail too
+				 */
+				//FD_CLR(cfd, &readfds);
+				//close(STDOUT_FILENO);
+				//continue;
+				break;
+			}
+			if (tls->inbuf[0] != RECORD_TYPE_APPLICATION_DATA)
+				bb_error_msg_and_die("unexpected record type %d", tls->inbuf[0]);
 			xwrite(STDOUT_FILENO, tls->inbuf + RECHDR_LEN, nread);
+			/* We may already have a complete next record buffered,
+			 * can process it without network reads (and possible blocking)
+			 */
+			if (tls_has_buffered_record(tls))
+				goto read_record;
 		}
 	}