spiped 0.0.0

data/ext/spiped/spiped-source/spiped/Makefile

@@ -0,0 +1,98 @@
+# Program name.
+PROG	=	spiped
+MAN1	=	${PROG}.1
+
+# Libraries which are sometimes merged into libc
+LDADD	=	-lrt
+#LDADD	+=	-lxnet	# Missing on FreeBSD
+
+# Library code required
+LDADD_REQ	=	-lcrypto
+LDADD_REQ	+=	-lpthread
+
+# spiped code
+SRCS	=	main.c
+SRCS	+=	dispatch.c
+
+# spipe protocol
+.PATH.c	:	../proto
+SRCS	+=	proto_conn.c
+SRCS	+=	proto_crypt.c
+SRCS	+=	proto_handshake.c
+SRCS	+=	proto_pipe.c
+IDIRS	+=	-I ../proto
+
+# Fundamental algorithms
+.PATH.c	:	../libcperciva/alg
+SRCS	+=	sha256.c
+IDIRS	+=	-I ../libcperciva/alg
+
+# Data structures
+.PATH.c	:	../libcperciva/datastruct
+SRCS	+=	elasticarray.c
+SRCS	+=	ptrheap.c
+SRCS	+=	timerqueue.c
+IDIRS	+=	-I ../libcperciva/datastruct
+
+# DNS resolution
+.PATH.c	:	../lib/dnsthread
+SRCS	+=	dnsthread.c
+IDIRS	+=	-I ../lib/dnsthread
+
+# Utility functions
+.PATH.c	:	../libcperciva/util
+SRCS	+=	asprintf.c
+SRCS	+=	daemonize.c
+SRCS	+=	entropy.c
+SRCS	+=	insecure_memzero.c
+SRCS	+=	monoclock.c
+SRCS	+=	noeintr.c
+SRCS	+=	sock.c
+SRCS	+=	sock_util.c
+SRCS	+=	warnp.c
+IDIRS	+=	-I ../libcperciva/util
+
+# CPU features detection
+.PATH.c	:	../libcperciva/cpusupport
+SRCS	+=	cpusupport_x86_aesni.c
+IDIRS	+=	-I ../libcperciva/cpusupport
+
+# Event loop
+.PATH.c	:	../libcperciva/events
+SRCS	+=	events_immediate.c
+SRCS	+=	events_network.c
+SRCS	+=	events_network_selectstats.c
+SRCS	+=	events_timer.c
+SRCS	+=	events.c
+IDIRS	+=	-I ../libcperciva/events
+
+# Event-driven networking
+.PATH.c	:	../libcperciva/network
+SRCS	+=	network_accept.c
+SRCS	+=	network_connect.c
+SRCS	+=	network_read.c
+SRCS	+=	network_write.c
+IDIRS	+=	-I ../libcperciva/network
+
+# Crypto code
+.PATH.c	:	../libcperciva/crypto
+SRCS	+=	crypto_aes.c
+SRCS	+=	crypto_aes_aesni.c
+SRCS	+=	crypto_aesctr.c
+SRCS	+=	crypto_dh.c
+SRCS	+=	crypto_dh_group14.c
+SRCS	+=	crypto_entropy.c
+SRCS	+=	crypto_verify_bytes.c
+IDIRS	+=	-I ../libcperciva/crypto
+
+crypto_aes_aesni.o: crypto_aes_aesni.c cpusupport-config.h
+	. ./cpusupport-config.h; ${CC} ${CFLAGS} $${CFLAGS_X86_AESNI} -c $< -o $@
+cflags-crypto_aes_aesni.o=$${CFLAGS_X86_AESNI}
+
+# Debugging options
+CFLAGS	+=	-g
+#CFLAGS	+=	-DNDEBUG
+#CFLAGS	+=	-DDEBUG
+#CFLAGS	+=	-pg
+
+.include <bsd.prog.mk>

data/ext/spiped/spiped-source/spiped/README

@@ -0,0 +1,62 @@
+spiped usage
+============
+
+usage: spiped {-e | -d} -s <source socket> -t <target socket> -k <key file>
+    [-DFj] [-f | -g] [-n <max # connections>] [-o <connection timeout>]
+    [-p <pidfile>] [-r <rtime> | -R]
+
+Options:
+    -e
+	Take unencrypted connections from the source socket and send
+	encrypted connections to the target socket.
+    -d
+	Take encrypted connections from the source socket and send
+	unencrypted connections to the target socket.
+    -s <source socket>
+	Address on which spiped should listen for incoming connections.
+	Must be in one of the following formats:
+		/absolute/path/to/unix/socket
+		host.name:port
+		[ip.v4.ad.dr]:port
+		[ipv6::addr]:port
+	Note that hostnames are resolved when spiped is launched and are not
+	re-resolved later; thus if DNS entries change spiped will continue to
+	connect to the expired address.
+    -t <target socket>
+	Address to which spiped should connect.
+    -k <key file>
+	Use the provided key file to authenticate and encrypt.
+    -D
+	Wait for DNS.  Normally when spiped is launched it resolves addresses
+	and binds to its source socket before the parent process returns; with
+	this option it will daemonize first and retry failed DNS lookups until
+	they succeed.  This allows spiped to launch even if DNS isn't set up
+	yet, but at the expense of losing the guarantee that once spiped has
+	finished launching it will be ready to create pipes.
+    -f
+	Use fast/weak handshaking: This reduces the CPU time spent in the
+	initial connection setup, at the expense of losing perfect forward
+	secrecy.
+    -g
+	Require perfect forward secrecy by dropping connections if the other
+	host is using the -f option.
+    -F
+	Run in foreground.  This can be useful with systems like daemontools.
+    -j
+	Disable transport layer keep-alives. (By default they are enabled.)
+    -n <max # connections>
+	Limit on the number of simultaneous connections allowed.  Defaults
+	to 100 connections.
+    -o <connection timeout>
+	Timeout, in seconds, after which an attempt to connect to the target
+	or a protocol handshake will be aborted (and the connection dropped)
+	if not completed.  Defaults to 5s.
+    -p <pidfile>
+	File to which spiped's process ID should be written.  Defaults to
+	<source socket>.pid (in the current directory if <source socket> is
+	not an absolute path).
+    -r <rtime>
+	Re-resolve the address of <target socket> every <rtime> seconds.
+	Defaults to re-resolution every 60 seconds.
+    -R
+	Do not re-resolve the address of <target socket>.

data/ext/spiped/spiped-source/spiped/dispatch.c

@@ -0,0 +1,214 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "dnsthread.h"
+#include "events.h"
+#include "network.h"
+#include "sock.h"
+#include "sock_util.h"
+#include "warnp.h"
+
+#include "proto_conn.h"
+
+#include "dispatch.h"
+
+struct accept_state {
+	int s;
+	const char * tgt;
+	struct sock_addr ** sas;
+	double rtime;
+	int decr;
+	int nofps;
+	int requirefps;
+	int nokeepalive;
+	const struct proto_secret * K;
+	size_t nconn;
+	size_t nconn_max;
+	double timeo;
+	void * accept_cookie;
+	DNSTHREAD T;
+};
+
+static int callback_gotconn(void *, int);
+static int callback_resolveagain(void *);
+
+/* Callback from address resolution. */
+static int
+callback_resolve(void * cookie, struct sock_addr ** sas)
+{
+	struct accept_state * A = cookie;
+
+	/* If the address resolution succeeded... */
+	if (sas != NULL) {
+		/* Free the old addresses. */
+		sock_addr_freelist(A->sas);
+
+		/* Use the new addresses. */
+		A->sas = sas;
+	}
+
+	/* Wait a while before resolving again. */
+	if (events_timer_register_double(callback_resolveagain,
+	    A, A->rtime) == NULL)
+		goto err0;
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/* Timer callback to trigger another address resolution. */
+static int
+callback_resolveagain(void * cookie)
+{
+	struct accept_state * A = cookie;
+
+	/* Re-resolve the target address. */
+	return (dnsthread_resolveone(A->T, A->tgt, callback_resolve, A));
+}
+
+/* Non-blocking accept, if we can have more connections. */
+static int
+doaccept(struct accept_state * A)
+{
+	int rc = 0;
+
+	/* If we can, accept a new connection. */
+	if ((A->nconn < A->nconn_max) && (A->accept_cookie == NULL)) {
+		if ((A->accept_cookie =
+		    network_accept(A->s, callback_gotconn, A)) == NULL)
+			rc = -1;
+	}
+
+	/* Return success/fail status. */
+	return (rc);
+}
+
+/* A connection has closed.  Accept more if necessary. */
+static int
+callback_conndied(void * cookie)
+{
+	struct accept_state * A = cookie;
+
+	/* We've lost a connection. */
+	A->nconn -= 1;
+
+	/* Maybe accept more connections. */
+	return (doaccept(A));
+}
+
+/* Handle an incoming connection. */
+static int
+callback_gotconn(void * cookie, int s)
+{
+	struct accept_state * A = cookie;
+	struct sock_addr ** sas;
+
+	/* This accept is no longer in progress. */
+	A->accept_cookie = NULL;
+
+	/* If we got a -1 descriptor, something went seriously wrong. */
+	if (s == -1) {
+		warnp("network_accept failed");
+		goto err0;
+	}
+
+	/* We have gained a connection. */
+	A->nconn += 1;
+
+	/* Duplicate the target address list. */
+	if ((sas = sock_addr_duplist(A->sas)) == NULL)
+		goto err1;
+
+	/* Create a new connection. */
+	if (proto_conn_create(s, sas, A->decr, A->nofps, A->requirefps,
+	    A->nokeepalive, A->K, A->timeo, callback_conndied, A)) {
+		warnp("Failure setting up new connection");
+		goto err2;
+	}
+
+	/* Accept another connection if we can. */
+	if (doaccept(A))
+		goto err0;
+
+	/* Success! */
+	return (0);
+
+err2:
+	sock_addr_freelist(sas);
+err1:
+	A->nconn -= 1;
+	close(s);
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * dispatch_accept(s, tgt, rtime, sas, decr, nofps, requirefps, nokeepalive, K,
+ *     nconn_max, timeo):
+ * Start accepting connections on the socket ${s}.  Connect to the target
+ * ${tgt}, re-resolving it every ${rtime} seconds if ${rtime} > 0; on address
+ * resolution failure use the most recent successfully obtained addresses, or
+ * the addresses ${sas}.  If ${decr} is 0, encrypt the outgoing connections; if
+ * ${decr} is non-zero, decrypt the incoming connections.  Don't accept more
+ * than ${nconn_max} connections.  If ${nofps} is non-zero, don't use perfect
+ * forward secrecy.  If {$requirefps} is non-zero, require that both ends use
+ * perfect forward secrecy.  Enable transport layer keep-alives (if applicable)
+ * if and only if ${nokeepalive} is zero.  Drop connections if the handshake or
+ * connecting to the target takes more than ${timeo} seconds.
+ */
+int
+dispatch_accept(int s, const char * tgt, double rtime, struct sock_addr ** sas,
+    int decr, int nofps, int requirefps, int nokeepalive,
+    const struct proto_secret * K, size_t nconn_max, double timeo)
+{
+	struct accept_state * A;
+
+	/* Bake a cookie. */
+	if ((A = malloc(sizeof(struct accept_state))) == NULL)
+		goto err0;
+	A->s = s;
+	A->tgt = tgt;
+	A->sas = sas;
+	A->rtime = rtime;
+	A->decr = decr;
+	A->nofps = nofps;
+	A->requirefps = requirefps;
+	A->nokeepalive = nokeepalive;
+	A->K = K;
+	A->nconn = 0;
+	A->nconn_max = nconn_max;
+	A->timeo = timeo;
+	A->accept_cookie = NULL;
+
+	/* If address re-resolution is enabled... */
+	if (rtime > 0.0) {
+		/* Launch an address resolution thread. */
+		A->T = dnsthread_spawn();
+
+		/* Re-resolve the target address after a while. */
+		if (events_timer_register_double(callback_resolveagain,
+		    A, A->rtime) == NULL)
+			goto err1;
+	}
+
+	/* Accept a connection. */
+	if (doaccept(A))
+		goto err1;
+
+	/* Success! */
+	return (0);
+
+err1:
+	if (rtime > 0.0)
+		dnsthread_kill(A->T);
+	free(A);
+err0:
+	/* Failure! */
+	return (-1);
+}

data/ext/spiped/spiped-source/spiped/dispatch.h

@@ -0,0 +1,27 @@
+#ifndef _DISPATCH_H_
+#define _DISPATCH_H_
+
+#include <stdint.h>
+
+/* Opaque structures. */
+struct proto_secret;
+struct sock_addr;
+
+/**
+ * dispatch_accept(s, tgt, rtime, sas, decr, nofps, requirefps, nokeepalive, K,
+ *     nconn_max, timeo):
+ * Start accepting connections on the socket ${s}.  Connect to the target
+ * ${tgt}, re-resolving it every ${rtime} seconds if ${rtime} > 0; on address
+ * resolution failure use the most recent successfully obtained addresses, or
+ * the addresses ${sas}.  If ${decr} is 0, encrypt the outgoing connections; if
+ * ${decr} is non-zero, decrypt the incoming connections.  Don't accept more
+ * than ${nconn_max} connections.  If ${nofps} is non-zero, don't use perfect
+ * forward secrecy.  If {$requirefps} is non-zero, require that both ends use
+ * perfect forward secrecy.  Enable transport layer keep-alives (if applicable)
+ * if and only if ${nokeepalive} is zero.  Drop connections if the handshake or
+ * connecting to the target takes more than ${timeo} seconds.
+ */
+int dispatch_accept(int, const char *, double, struct sock_addr **, int, int,
+    int, int, const struct proto_secret *, size_t, double);
+
+#endif /* !_DISPATCH_H_ */

data/ext/spiped/spiped-source/spiped/main.c

@@ -0,0 +1,267 @@
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "asprintf.h"
+#include "daemonize.h"
+#include "events.h"
+#include "sock.h"
+#include "warnp.h"
+
+#include "dispatch.h"
+#include "proto_crypt.h"
+
+static void
+usage(void)
+{
+
+	fprintf(stderr, "usage: spiped {-e | -d} -s <source socket> "
+	    "-t <target socket> -k <key file>\n"
+	    "    [-DFj] [-f | -g] [-n <max # connections>] "
+	    "[-o <connection timeout>]\n"
+	    "    [-p <pidfile>] [-r <rtime> | -R]\n");
+	exit(1);
+}
+
+/* Simplify error-handling in command-line parse loop. */
+#define OPT_EPARSE(opt, arg) do {					\
+	warnp("Error parsing argument: -%c %s", opt, arg);		\
+	exit(1);							\
+} while (0)
+
+int
+main(int argc, char * argv[])
+{
+	/* Command-line parameters. */
+	int opt_d = 0;
+	int opt_D = 0;
+	int opt_e = 0;
+	int opt_f = 0;
+	int opt_g = 0;
+	int opt_F = 0;
+	int opt_j = 0;
+	const char * opt_k = NULL;
+	intmax_t opt_n = 0;
+	double opt_o = 0.0;
+	char * opt_p = NULL;
+	double opt_r = 0.0;
+	int opt_R = 0;
+	const char * opt_s = NULL;
+	const char * opt_t = NULL;
+
+	/* Working variables. */
+	struct sock_addr ** sas_s;
+	struct sock_addr ** sas_t;
+	struct proto_secret * K;
+	int ch;
+	int s;
+
+	WARNP_INIT;
+
+	/* Parse the command line. */
+	while ((ch = getopt(argc, argv, "dDefFgjk:n:o:r:Rp:s:t:")) != -1) {
+		switch (ch) {
+		case 'd':
+			if (opt_d || opt_e)
+				usage();
+			opt_d = 1;
+			break;
+		case 'D':
+			if (opt_D)
+				usage();
+			opt_D = 1;
+			break;
+		case 'e':
+			if (opt_d || opt_e)
+				usage();
+			opt_e = 1;
+			break;
+		case 'f':
+			if (opt_f)
+				usage();
+			opt_f = 1;
+			break;
+		case 'F':
+			if (opt_F)
+				usage();
+			opt_F = 1;
+			break;
+		case 'g':
+			if (opt_g)
+				usage();
+			opt_g = 1;
+			break;
+		case 'j':
+			if (opt_j)
+				usage();
+			opt_j = 1;
+			break;
+		case 'k':
+			if (opt_k)
+				usage();
+			opt_k = optarg;
+			break;
+		case 'n':
+			if (opt_n != 0)
+				usage();
+			if ((opt_n = strtoimax(optarg, NULL, 0)) == 0) {
+				warn0("Invalid option: -n %s", optarg);
+				exit(1);
+			}
+			if ((opt_n <= 0) || (opt_n > 500)) {
+				warn0("The parameter to -n must be between 1 and 500\n");
+				exit(1);
+			}
+			break;
+		case 'o':
+			if (opt_o != 0.0)
+				usage();
+			if ((opt_o = strtod(optarg, NULL)) == 0.0) {
+				warn0("Invalid option: -o %s", optarg);
+				exit(1);
+			}
+			break;
+		case 'p':
+			if (opt_p)
+				usage();
+			if ((opt_p = strdup(optarg)) == NULL)
+				OPT_EPARSE(ch, optarg);
+			break;
+		case 'r':
+			if (opt_r != 0.0)
+				usage();
+			if ((opt_r = strtod(optarg, NULL)) == 0.0) {
+				warn0("Invalid option: -r %s", optarg);
+				exit(1);
+			}
+			break;
+		case 'R':
+			if (opt_R)
+				usage();
+			opt_R = 1;
+			break;
+		case 's':
+			if (opt_s)
+				usage();
+			opt_s = optarg;
+			break;
+		case 't':
+			if (opt_t)
+				usage();
+			opt_t = optarg;
+			break;
+		default:
+			usage();
+		}
+	}
+
+	/* We should have processed all the arguments. */
+	if (argc != optind)
+		usage();
+
+	/* Set defaults. */
+	if (opt_n == 0)
+		opt_n = 100;
+	if (opt_o == 0.0)
+		opt_o = 5.0;
+	if (opt_r == 0.0)
+		opt_r = 60.0;
+
+	/* Sanity-check options. */
+	if (!opt_d && !opt_e)
+		usage();
+	if (opt_f && opt_g)
+		usage();
+	if (opt_k == NULL)
+		usage();
+	if (!(opt_o > 0.0))
+		usage();
+	if ((opt_r != 60.0) && opt_R)
+		usage();
+	if (opt_s == NULL)
+		usage();
+	if (opt_t == NULL)
+		usage();
+
+	/* Figure out where our pid should be written. */
+	if (opt_p == NULL) {
+		if (asprintf(&opt_p, "%s.pid", opt_s) == -1) {
+			warnp("asprintf");
+			exit(1);
+		}
+	}
+
+	/* Daemonize early if we're going to wait for DNS to be ready. */
+	if (opt_D && !opt_F && daemonize(opt_p)) {
+		warnp("Failed to daemonize");
+		exit(1);
+	}
+
+	/* Resolve source address. */
+	while ((sas_s = sock_resolve(opt_s)) == NULL) {
+		if (!opt_D) {
+			warnp("Error resolving socket address: %s", opt_s);
+			exit(1);
+		}
+		sleep(1);
+	}
+	if (sas_s[0] == NULL) {
+		warn0("No addresses found for %s", opt_s);
+		exit(1);
+	}
+
+	/* Resolve target address. */
+	while ((sas_t = sock_resolve(opt_t)) == NULL) {
+		if (!opt_D) {
+			warnp("Error resolving socket address: %s", opt_t);
+			exit(1);
+		}
+		sleep(1);
+	}
+	if (sas_t[0] == NULL) {
+		warn0("No addresses found for %s", opt_t);
+		exit(1);
+	}
+
+	/* Load the keying data. */
+	if ((K = proto_crypt_secret(opt_k)) == NULL) {
+		warnp("Error reading shared secret");
+		exit(1);
+	}
+
+	/* Create and bind a socket, and mark it as listening. */
+	if (sas_s[1] != NULL)
+		warn0("Listening on first of multiple addresses found for %s",
+		    opt_s);
+	if ((s = sock_listener(sas_s[0])) == -1)
+		exit(1);
+
+	/* Daemonize and write pid. */
+	if (!opt_F && daemonize(opt_p)) {
+		warnp("Failed to daemonize");
+		exit(1);
+	}
+
+	/* Start accepting connections. */
+	if (dispatch_accept(s, opt_t, opt_R ? 0.0 : opt_r, sas_t, opt_d,
+	    opt_f, opt_g, opt_j, K, opt_n, opt_o)) {
+		warnp("Failed to initialize connection acceptor");
+		exit(1);
+	}
+
+	/* Infinite loop handling events. */
+	do {
+		if (events_run()) {
+			warnp("Error running event loop");
+			exit(1);
+		}
+	} while (1);
+
+	/* NOTREACHED */
+	/*
+	 * If we could reach this point, we would free memory, close sockets,
+	 * and otherwise clean up here.
+	 */
+}