# 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)
#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
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 {
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.,
len -= xhdr_len;
}
}
+#else
+# define dump_hex(...) ((void)0)
+# define dump_tls_record(...) ((void)0)
#endif
void tls_get_random(void *buf, unsigned len)
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;
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;
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
};
//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));
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
// 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. ...
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");
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");
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")
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");
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;
}
}
projects / oweals / busybox.git / commitdiff