--- /dev/null
+//
+// tlsnke.c
+// tlsnke
+//
+// Created by Fabrice Gautier on 11/11/11.
+// Copyright (c) 2011 Apple, Inc. All rights reserved.
+//
+
+#include <mach/mach_types.h>
+#include <sys/kernel_types.h>
+#include <sys/kpi_socket.h>
+#include <sys/kpi_socketfilter.h>
+#include <sys/kpi_mbuf.h>
+#include <sys/malloc.h>
+#include <sys/socketvar.h>
+#include <sys/queue.h>
+#include <sys/mbuf.h>
+#include <sys/param.h>
+
+#include <netinet/in.h>
+
+#include <libkern/libkern.h>
+#include <libkern/OSMalloc.h>
+
+#include <stdint.h>
+
+/* For IOLog */
+#include <IOKit/IOLib.h>
+#include <stdarg.h>
+
+#define DEBUG_ASSERT_COMPONENT_NAME_STRING "tlsnke"
+#define DEBUG_ASSERT_PRODUCTION_CODE 0
+
+#include <AssertMacros.h>
+
+
+#include "SSLRecordInternal.h"
+#include "tlsnke.h"
+
+#include <net/if_utun_crypto_dtls.h>
+
+/*
+ Used a registered creator type here - to register for one - go to the
+ Apple Developer Connection Datatype Registration page
+ <http://developer.apple.com/datatype/>
+ */
+#define MYBUNDLEID "com.apple.kext.tlsnke"
+
+
+#define TLS_DEBUG 0
+#define TLS_TEST 0 /* To enable the bsd devfs interface for testing the utun code path */
+/* ==================================== */
+
+
+typedef struct dtls_ctx *dtls_ctx_t; /* forward declaration, see below */
+
+
+/* =================================== */
+
+/* global dtls contexts table */
+
+/* TODO: LOCK/UNLOCK global context table */
+
+#define N_DTLS_MAX 1
+static dtls_ctx_t g_dtls_contexts[N_DTLS_MAX];
+
+static void clear_dtls_contexts(void)
+{
+ memset(g_dtls_contexts, 0, sizeof(g_dtls_contexts));
+}
+
+static dtls_ctx_t get_dtls_context(int dtls_handle)
+{
+ if(dtls_handle>=0 && dtls_handle<N_DTLS_MAX) {
+ return g_dtls_contexts[dtls_handle];
+ } else {
+ return NULL;
+ }
+}
+
+static int register_dtls_context(dtls_ctx_t dtls_ref)
+{
+ int i;
+ for(i=0; i<N_DTLS_MAX; i++) {
+ if(g_dtls_contexts[i]==NULL) {
+ g_dtls_contexts[i]=dtls_ref;
+ return i;
+ }
+ }
+ return -1;
+}
+
+static int unregister_dtls_context(dtls_ctx_t dtls_ref)
+{
+ int i;
+ for(i=0; i<N_DTLS_MAX; i++) {
+ if(g_dtls_contexts[i]==dtls_ref) {
+ g_dtls_contexts[i]=NULL;
+ return i;
+ }
+ }
+ return -1;
+}
+
+/* =================================== */
+// MARK: Utility Functions
+
+/*
+ * Messages to the system log
+ */
+
+static void
+tls_printf(const char *fmt, ...)
+{
+#if TLS_DEBUG
+ va_list listp;
+ char log_buffer[252];
+
+ log_buffer[250]='\n';
+ log_buffer[251]=0;
+
+ va_start(listp, fmt);
+
+ vsnprintf(log_buffer, sizeof(log_buffer)-2, fmt, listp);
+ //printf("%s", log_buffer);
+ IOLog("%s", log_buffer);
+ va_end(listp);
+#endif
+}
+
+static void
+tls_dump(const unsigned char *p, size_t len)
+{
+#if TLS_DEBUG
+ size_t i;
+ for(i=0; i<len; i++) {
+ tls_printf("%02x ", p[i]);
+ if(i%0x1F==0x1F)
+ tls_printf("\n");
+ }
+ tls_printf("\n");
+#endif
+}
+
+
+
+/* =================================== */
+
+static OSMallocTag gOSMallocTag; // tag for use with OSMalloc calls which is used to associate memory
+ // allocations made with this kext. Preferred to using MALLOC and FREE
+
+
+/* the PktQueueItem record is used to store packet information for queued packets. */
+struct PktQueueItem {
+ STAILQ_ENTRY(PktQueueItem) next; /* link to next queued entry or NULL */
+ mbuf_t data;
+ sflt_data_flag_t flags;
+};
+
+/* Internal DTLS context for socket filter */
+
+struct dtls_ctx {
+ socket_t socket; /* socket to which we are attached - may not be needed */
+ bool has_from;
+ struct sockaddr from; /* from address */
+ bool has_to;
+ struct sockaddr to; /* to address */
+ struct utun_pcb *utun_ref; /* utun handle, if bypass is enabled */
+ bool wait_for_key;
+ SSLRecordContextRef ssl_ctx; /* ctx for actual SSL implementation */
+ STAILQ_HEAD(, PktQueueItem) in_queue;
+ size_t in_off;
+#ifdef TLS_TEST
+ bool queue_to_tlsnkedev; /* for testing only, if true, queue decrypted incoming data
+ in the tlsnkedev queue instead of sending to utun or userland */
+#endif
+};
+
+
+/* =================================== */
+
+#if TLS_TEST
+/* Q for incoming data */
+static int tlsnkedev_queue(mbuf_t m);
+#endif
+
+/* Wrappers around utun functions */
+
+/* Send a data packet to utun interface */
+static int utun_data_packet_input(struct utun_pcb *utun_ref, mbuf_t data)
+{
+ tls_printf("tlsnke():%s\n",__FUNCTION__);
+ return utun_pkt_dtls_input(utun_ref, &data, 0);
+}
+
+/* Disable the DTLS bypass in utun - Called by DTLS when socket is clsoed or other error cases */
+static void utun_disable_dtls(struct utun_pcb *utun_ref)
+{
+ tls_printf("tlsnke():%s\n",__FUNCTION__);
+ /* TODO: This is not exported from xnu yet */
+ //utun_ctl_disable_crypto_dtls(utun_ref);
+}
+
+
+/*===== DTLS IO Callbacks =====*/
+// MARK: DTLS IO Callbacks
+
+static
+int DTLSIOReadFunc (SSLIOConnectionRef connection, void *data, size_t *dataLength)
+{
+ dtls_ctx_t dtls_ref = connection;
+ struct PktQueueItem *in_q = STAILQ_FIRST(&dtls_ref->in_queue);
+ size_t avail;
+ size_t len = *dataLength;
+ int rc = 0;
+
+ check(dtls_ref);
+ check(data);
+ check(dataLength);
+
+ if(in_q==NULL) {
+ *dataLength=0;
+ return errSSLRecordWouldBlock;
+ }
+
+ avail = mbuf_pkthdr_len(in_q->data)-dtls_ref->in_off;
+
+ tls_printf("tlsnke(%p):%s - avail=%d wants=%d\n", dtls_ref, __FUNCTION__, avail, *dataLength);
+
+ if(len>avail) {
+ /* Note: This should never happen for DTLS here */
+ check(0);
+ len = avail;
+ }
+
+ require_noerr_action(mbuf_copydata(in_q->data, dtls_ref->in_off, *dataLength, data), out, rc=errSSLRecordInternal);
+ *dataLength = len;
+
+ //const unsigned char *p=data;
+ //tls_printf("tlsnke(%p):%s - IORead rc=%d, err=%d, len=%d/%d, avail=%d, off=%d, in_q=%p, mbuf=%p\n", dtls_ref, __FUNCTION__,
+ // rc, err, len, *dataLength, avail, dtls_ref->in_off, in_q, in_q->data);
+ //tls_dump(p, len);
+
+ /* We consumed a full packet, remove it from the queue */
+ if(len==avail) {
+ STAILQ_REMOVE_HEAD(&dtls_ref->in_queue, next);
+ mbuf_freem(in_q->data);
+ OSFree(in_q, sizeof(struct PktQueueItem), gOSMallocTag);
+ dtls_ref->in_off=0;
+ } else {
+ dtls_ref->in_off += len;
+ }
+
+out:
+ return rc;
+}
+
+static
+int DTLSIOWriteFunc (SSLIOConnectionRef connection, const void *data, size_t *dataLength)
+{
+ /* Write data callback: */
+ dtls_ctx_t dtls_ref = connection;
+ mbuf_t out_mbuf=NULL;
+
+ check(dtls_ref);
+
+ //const unsigned char *p=data;
+ //tls_printf("tlsnke(%p):%s - IOWrite len=%d\n", dtls_ref, __FUNCTION__, *dataLength);
+ //tls_dump(p, *dataLength);
+
+ /* create a new data mbuf */
+ require_noerr(mbuf_allocpacket(M_NOWAIT, *dataLength, NULL, &out_mbuf), fail);
+ require(out_mbuf, fail);
+ require_noerr(mbuf_copyback(out_mbuf, 0, *dataLength, data, M_NOWAIT), fail);
+
+ //tls_printf("tlsnke(%p):%s - inject to=%p mbuf flags=0x%x\n", dtls_ref, __FUNCTION__, dtls_ref->has_to?&dtls_ref->to:NULL, mbuf_flags(out_mbuf));
+
+ /* out_mbuf is freed here in anycase */
+ return sock_inject_data_out(dtls_ref->socket, dtls_ref->has_to?&dtls_ref->to:NULL, out_mbuf, NULL, 0);
+
+fail:
+ /* If we allocated an mbuf, and something failed, we have to free it */
+ if(out_mbuf)
+ mbuf_freem(out_mbuf);
+
+ return errSSLRecordInternal;
+}
+
+static
+dtls_ctx_t dtls_create_context(socket_t so)
+{
+ dtls_ctx_t dtls_ref;
+
+ dtls_ref = (dtls_ctx_t)OSMalloc(sizeof(struct dtls_ctx), gOSMallocTag);
+ require(dtls_ref, fail);
+ memset(dtls_ref, 0, sizeof(struct dtls_ctx));
+
+ dtls_ref->socket=so;
+ STAILQ_INIT(&dtls_ref->in_queue);
+ dtls_ref->ssl_ctx = SSLCreateInternalRecordLayer(true);
+ require(dtls_ref->ssl_ctx, fail);
+
+ /* Those two functions never fail */
+ SSLSetInternalRecordLayerIOFuncs(dtls_ref->ssl_ctx, DTLSIOReadFunc, DTLSIOWriteFunc);
+ SSLSetInternalRecordLayerConnection(dtls_ref->ssl_ctx, dtls_ref);
+
+ return dtls_ref;
+
+fail:
+ if(dtls_ref)
+ OSFree(dtls_ref, sizeof(struct dtls_ctx), gOSMallocTag);
+ return NULL;
+}
+
+
+static
+void dtls_free_context(dtls_ctx_t dtls_ref)
+{
+ /* TODO: LOCK this dtls ref */
+
+ /* Disable bridge to utun if enabled */
+ if(dtls_ref->utun_ref) {
+ utun_disable_dtls(dtls_ref->utun_ref);
+ }
+
+ /* TODO: Clear incoming mbuf queue */
+
+ SSLDestroyInternalRecordLayer(dtls_ref->ssl_ctx);
+
+ unregister_dtls_context(dtls_ref);
+
+ OSFree(dtls_ref, sizeof(struct dtls_ctx), gOSMallocTag);
+ /* TODO: UNLOCK */
+}
+
+/* Get the tls_record_hdr from the control mbuf */
+static
+tls_record_hdr_t dtls_get_header(mbuf_t *control)
+{
+ struct cmsghdr *cm;
+ tls_record_hdr_t hdr;
+
+ if(control==NULL)
+ return NULL;
+
+ if((*control)==NULL)
+ return NULL;
+
+ /* Needs to be in one mbuf */
+ if (mbuf_next(*control))
+ return NULL;
+ /* Control mbuf needs to be big enough for the tls_record_hdr struct - <rdar://problem/11204421> */
+ if (mbuf_len(*control) < CMSG_LEN(sizeof(struct tls_record_hdr)))
+ return NULL;
+
+ cm = mbuf_data(*control);
+
+ if(cm==NULL)
+ return NULL;
+
+ hdr=(tls_record_hdr_t)CMSG_DATA(cm);
+
+ return hdr;
+}
+
+
+/* encrypt a dtls record */
+
+
+static
+int dtls_process_output_packet(dtls_ctx_t dtls_ref, mbuf_t data, tls_record_hdr_t hdr)
+{
+ /* This should be thread safe as this may be called from both
+ the userland socket or from utun -- maybe ? */
+
+ SSLRecord rec;
+ size_t len = mbuf_pkthdr_len(data);
+ errno_t err;
+ int rc = errSSLRecordInternal;
+
+ require(len<UINT32_MAX, out);
+ rec.contents.data = OSMalloc((uint32_t)len, gOSMallocTag);
+ rec.contents.length = len;
+ require(rec.contents.data, out);
+
+ rec.contentType = hdr->content_type;
+ rec.protocolVersion = hdr->protocol_version;
+
+ tls_printf("tlsnke(%p):%s ct=%d, pv=%04x, len=%d\n", dtls_ref, __FUNCTION__, rec.contentType, rec.protocolVersion, len);
+
+ /* ...then the data */
+ err = mbuf_copydata(data, 0, len, rec.contents.data);
+ require_noerr(err, out);
+
+ rc=SSLRecordLayerInternal.write(dtls_ref->ssl_ctx, rec);
+
+out:
+ /* Free the allocated record */
+ if(rec.contents.data)
+ OSFree(rec.contents.data, (uint32_t)len, gOSMallocTag);
+
+ return rc;
+}
+
+
+static void dtls_process_incoming_queue(dtls_ctx_t dtls_ref)
+{
+ /* TODO: LOCK this dtls_ref */
+ SSLRecord rec;
+ struct cmsghdr *cmsg;
+ tls_record_hdr_t hdr;
+ size_t cbuf_len = CMSG_SPACE(sizeof(*hdr));
+ uint8_t *cbuf; //cbuf_len;
+
+ int rc;
+ errno_t err;
+ mbuf_t data;
+ mbuf_t control;
+ struct sockaddr *from;
+
+ tls_printf("tlsnke(%p):%s \n", dtls_ref, __FUNCTION__);
+
+ rc=0;
+ while(rc==0) {
+ rc=SSLRecordLayerInternal.read(dtls_ref->ssl_ctx, &rec);
+
+ if(rc)
+ break;
+
+ /* Create a new control mbuf to store the DTLS header */
+ check_noerr(mbuf_get(M_NOWAIT, MBUF_TYPE_CONTROL, &control));
+ check(mbuf_maxlen(control)>=cbuf_len);
+ mbuf_setlen(control, cbuf_len);
+ cbuf = mbuf_data(control);
+
+ cmsg = (struct cmsghdr *)cbuf;
+ cmsg->cmsg_len = CMSG_LEN(sizeof(*hdr));
+ cmsg->cmsg_level = SOL_SOCKET;
+ cmsg->cmsg_type = SCM_TLS_HEADER;
+
+ hdr = (tls_record_hdr_t)CMSG_DATA(cmsg);
+ hdr->content_type = rec.contentType;
+ hdr->protocol_version = rec.protocolVersion;
+
+ /* create a new data mbuf */
+ check_noerr(mbuf_allocpacket(M_NOWAIT, rec.contents.length, NULL, &data));
+ check_noerr(mbuf_copyback(data, 0, rec.contents.length, rec.contents.data, M_NOWAIT));
+ SSLRecordLayerInternal.free(dtls_ref->ssl_ctx, rec);
+
+ /* We pause processing when getting a change cipher spec */
+ if(hdr->content_type==SSL_RecordTypeChangeCipher) {
+ tls_printf("tlsnke(%p):%s got a ChangeCipher message\n", dtls_ref, __FUNCTION__);
+ dtls_ref->wait_for_key=true;
+ }
+
+ if(dtls_ref->has_from)
+ from=&dtls_ref->from;
+ else
+ from=NULL;
+
+ tls_printf("tlsnke(%p):%s injecting packet d=%p c=%p h=%p, from=%p, flags=0x%x\n", dtls_ref, __FUNCTION__, data, control, hdr, from, mbuf_flags(data));
+
+ err = sock_inject_data_in(dtls_ref->socket, from, data, control, 0);
+
+ check_noerr(err);
+ }
+
+}
+
+
+
+/* =================================== */
+// MARK: Socket Filter Functions
+
+
+static void
+tls_unregistered_fn(sflt_handle handle)
+{
+ tls_printf("tlsnke:%s\n", __FUNCTION__);
+}
+
+static errno_t
+tls_attach_fn(void **cookie, socket_t so)
+{
+ tls_printf("tlsnke:%s (so=%p)\n", __FUNCTION__, so);
+
+ dtls_ctx_t dtls_ref;
+
+ dtls_ref = dtls_create_context(so);
+
+ *cookie=dtls_ref;
+
+ if(dtls_ref)
+ return 0;
+ else
+ return -1;
+}
+
+static void
+tls_detach_fn(void *cookie, socket_t so)
+{
+ dtls_ctx_t dtls_ref = (dtls_ctx_t)cookie;
+ tls_printf("tlsnke(%p):%s\n", cookie, __FUNCTION__);
+
+ /* disconnect from utun if necessary */
+ if(dtls_ref->utun_ref) {
+ utun_disable_dtls(dtls_ref->utun_ref);
+ }
+
+ dtls_free_context(dtls_ref);
+}
+
+static void
+tls_notify_fn(void *cookie, socket_t so, sflt_event_t event, void *param)
+{
+ tls_printf("tlsnke(%p):%s - so: %p - evt: %d\n", cookie, __FUNCTION__, so, event);
+}
+
+static errno_t
+tls_data_in_fn(void *cookie, socket_t so, const struct sockaddr *from,
+ mbuf_t *data, mbuf_t *control, sflt_data_flag_t flags)
+{
+ /* TODO: LOCK ? */
+ dtls_ctx_t dtls_ref = (dtls_ctx_t)cookie;
+ struct tls_record_hdr *hdr;
+ errno_t err;
+
+ tls_printf("tlsnke(%p):%s so=%p, data=%p/l=%d, control=%p/l=%d, from=%p, flags=0x%x\n",
+ cookie, __FUNCTION__, so,
+ data?*data:(void*)-1, (data && *data)?mbuf_pkthdr_len(*data):-1,
+ control?*control:(void*)-1, (control && *control)?mbuf_pkthdr_len(*control):-1,
+ from, flags);
+
+ // If this packet already has a DTLS header, just drop it through */
+ hdr = dtls_get_header(control);
+
+ if(hdr) {
+ tls_printf("tlsnke(%p):%s This was already processed. hdr=%p\n", cookie, __FUNCTION__, hdr);
+
+#if TLS_TEST
+ /* if switch enabled and this is a application data packet, send to tlsnkedev Q */
+ if((dtls_ref->queue_to_tlsnkedev) && (hdr->content_type==SSL_RecordTypeAppData)) {
+ /* Q data into tlsnkedev Q */
+ tls_printf("tlsnke(%p):%s Sending packet to tlsnkdev. data=%p\n", cookie, __FUNCTION__, *data);
+ err = tlsnkedev_queue(*data);
+ verify_noerr_action(err, return err);
+ /* no error, lets free the control mbuf... */
+ mbuf_freem(*control);
+ /* ... and swallow */
+ return EJUSTRETURN;
+ }
+#endif
+ /* There should never be a case where we have dtls header and no data, but we test that data is non null anyway */
+
+ /* if switch enabled and this is a application data packet, send to utun */
+ if(data && (dtls_ref->utun_ref) && (hdr->content_type==SSL_RecordTypeAppData)) {
+ /* reinject data into utun */
+ tls_printf("tlsnke(%p):%s Sending packet to utun. data=%p\n", cookie, __FUNCTION__, *data);
+ err = utun_data_packet_input(dtls_ref->utun_ref, *data);
+ verify_noerr_action(err, return err);
+ /* no error, lets free the control mbuf... */
+ mbuf_freem(*control);
+ /* ... and swallow */
+ return EJUSTRETURN;
+ }
+
+ /* keep the packet moving up in the stack to userland */
+ return 0;
+ }
+ tls_printf("tlsnke(%p):%s Queuing the data %p\n", cookie, __FUNCTION__, data);
+
+ /* Queue the packet */
+ if(data) {
+ struct PktQueueItem *tlq= (struct PktQueueItem *)OSMalloc(sizeof (struct PktQueueItem), gOSMallocTag);
+
+ /* If we can't allocate, we return an error, so the socket layer will free that mbuf */
+ verify_action(tlq, return ENOMEM);
+
+ tlq->data = *data;
+
+ STAILQ_INSERT_TAIL(&dtls_ref->in_queue, tlq, next);
+ }
+
+ if(from) {
+ dtls_ref->has_from=true;
+ memcpy(&dtls_ref->from, from, sizeof(struct sockaddr));
+ } else {
+ dtls_ref->has_from=false;
+ }
+
+ /* If we are waiting for userland, just return */
+ if(dtls_ref->wait_for_key) {
+ tls_printf("tlsnke(%p):%s holding the Q\n", cookie, __FUNCTION__);
+ } else {
+ /* Process incoming queue */
+ dtls_process_incoming_queue(dtls_ref);
+ }
+
+ return EJUSTRETURN;
+}
+
+static errno_t
+tls_data_out_fn(void *cookie, socket_t so, const struct sockaddr *to, mbuf_t *data,
+ mbuf_t *control, sflt_data_flag_t flags)
+{
+ /* TODO: LOCK ? */
+ errno_t err;
+ dtls_ctx_t dtls_ref = (dtls_ctx_t)cookie;
+ tls_record_hdr_t hdr;
+
+ tls_printf("tlsnke(%p):%s so=%p, data=%p/l=%d, control=%p/l=%d, to=%p, flags=0x%x\n", cookie, __FUNCTION__, so,
+ data?*data:(void *)-1, (data && *data)?mbuf_pkthdr_len(*data):-1,
+ control?*control:(void *)-1, (control && *control)?mbuf_pkthdr_len(*control):-1, to, flags);
+
+ hdr = dtls_get_header(control);
+
+ /* It may be possible for a data to be NULL. Never seen it, but this is not documented
+ otherwise, so lets not rely on current behaviour */
+
+ if(hdr && data) {
+ if(to) {
+ dtls_ref->has_to=true;
+ memcpy(&dtls_ref->to, to, sizeof(struct sockaddr));
+ } else {
+ dtls_ref->has_to=false;
+ }
+
+ err = dtls_process_output_packet(dtls_ref, *data, hdr);
+ verify_noerr_action(err, return err);
+
+ /* We have to free the mbufs only if we have no error */
+ mbuf_freem(*data);
+ mbuf_freem(*control);
+
+ return EJUSTRETURN;
+ } else {
+ /* No TLS header, just send. Dont process this */
+ return 0;
+ }
+}
+
+static errno_t
+tls_connect_in_fn(void *cookie, socket_t so, const struct sockaddr *from)
+{
+ tls_printf("tlsnke(%p):%s\n", cookie, __FUNCTION__);
+ return 0;
+}
+
+static errno_t
+tls_connect_out_fn(void *cookie, socket_t so, const struct sockaddr *to)
+{
+ tls_printf("tlsnke(%p):%s\n", cookie, __FUNCTION__);
+ return 0;
+}
+
+static errno_t
+tls_bind_fn(void *cookie, socket_t so, const struct sockaddr *to)
+{
+ tls_printf("tlsnke(%p):%s\n", cookie, __FUNCTION__);
+ return 0;
+}
+
+static errno_t
+tls_setoption_fn(void *cookie, socket_t so, sockopt_t opt)
+{
+ /* TODO : LOCK ? */
+ errno_t err;
+ int rc;
+ dtls_ctx_t dtls_ref = (dtls_ctx_t)cookie;
+
+ int level = sockopt_level(opt);
+ int name = sockopt_name(opt);
+ size_t valsize = sockopt_valsize(opt);
+
+ tls_printf("tlsnke(%p):%s - %x %x %d\n", cookie, __FUNCTION__, level, name, valsize);
+
+ /* We only handle SOL_SOCKET level options */
+ if(level!=SOL_SOCKET)
+ return 0;
+
+ switch (name) {
+ case SO_TLS_INIT_CIPHER:
+ {
+ uint16_t selectedCipher;
+ bool server;
+ SSLBuffer key;
+ unsigned char *buf;
+
+ verify_action(valsize>=4, return EINVAL);
+ verify_action(valsize<=4096, return EINVAL);
+
+ buf=OSMalloc((uint32_t)valsize, gOSMallocTag);
+
+ verify_action(buf, return ENOMEM);
+ err=sockopt_copyin(opt, buf, valsize);
+ verify_noerr_action(err, return err);
+
+ selectedCipher = (buf[0] << 8) | buf[1];
+ server = buf[2];
+ key.length = valsize - 3;
+ key.data = buf + 3;
+
+ tls_printf("tlsnke(%p):%s - Init Ciphers. cipherspec=%04x. server=%d.\n", dtls_ref, __FUNCTION__, selectedCipher, server);
+ rc = SSLRecordLayerInternal.initPendingCiphers(dtls_ref->ssl_ctx, selectedCipher, server, key);
+ tls_printf("tlsnke(%p):%s - Init Ciphers done rc=%d\n", dtls_ref, __FUNCTION__, rc);
+ }
+ break;
+ case SO_TLS_ADVANCE_READ_CIPHER:
+ check(dtls_ref->wait_for_key);
+ rc = SSLRecordLayerInternal.advanceReadCipher(dtls_ref->ssl_ctx);
+ tls_printf("tlsnke(%p):%s - Read Cipher Advanced, process incoming queue now.\n", dtls_ref, __FUNCTION__);
+ dtls_ref->wait_for_key=false;
+ dtls_process_incoming_queue(dtls_ref);
+ break;
+ case SO_TLS_ADVANCE_WRITE_CIPHER:
+ tls_printf("tlsnke(%p):%s - Advancing write cipher.\n", dtls_ref, __FUNCTION__);
+ rc = SSLRecordLayerInternal.advanceWriteCipher(dtls_ref->ssl_ctx);
+ break;
+ case SO_TLS_ROLLBACK_WRITE_CIPHER:
+ tls_printf("tlsnke(%p):%s - Rolling back write cipher.\n", dtls_ref, __FUNCTION__);
+ rc = SSLRecordLayerInternal.rollbackWriteCipher(dtls_ref->ssl_ctx);
+ break;
+ case SO_TLS_PROTOCOL_VERSION:
+ {
+ SSLProtocolVersion pv;
+ verify_action(valsize==sizeof(SSLProtocolVersion), return EINVAL);
+ err=sockopt_copyin(opt, &pv, sizeof(SSLProtocolVersion));
+ verify_noerr_action(err, return err);
+ tls_printf("tlsnke(%p):%s - Setting protocol version %04x\n", dtls_ref, __FUNCTION__, pv);
+ rc = SSLRecordLayerInternal.setProtocolVersion(dtls_ref->ssl_ctx, pv);
+ }
+ break;
+ case SO_TLS_SERVICE_WRITE_QUEUE:
+ tls_printf("tlsnke(%p):%s - Servicing the write Queue.\n", dtls_ref, __FUNCTION__);
+ rc = SSLRecordLayerInternal.serviceWriteQueue(dtls_ref->ssl_ctx);
+ break;
+ default:
+ /* We just ignore other option. We dont normally get any */
+ return 0;
+ }
+
+ /* Option was a valid filter specific option, return JUSTRETURN
+ or the result from the call */
+ if(rc==0)
+ return EJUSTRETURN;
+ else
+ return rc;
+}
+
+static errno_t
+tls_getoption_fn(void *cookie, socket_t so, sockopt_t opt)
+{
+ errno_t err;
+ dtls_ctx_t dtls_ref = (dtls_ctx_t)cookie;
+
+ int level = sockopt_level(opt);
+ int name = sockopt_name(opt);
+ size_t valsize = sockopt_valsize(opt);
+
+ int handle;
+
+ if(level!=SOL_SOCKET)
+ return 0;
+
+ switch (name) {
+ case SO_TLS_HANDLE:
+ handle=register_dtls_context(dtls_ref);
+ verify_action(handle>=0, return EBUSY); /* No space in the global table */
+ verify_action(valsize==sizeof(handle), return EINVAL);
+ err = sockopt_copyout(opt, &handle, valsize);
+ verify_noerr_action(err, return err);
+ tls_printf("tlsnke(%p):%s - get handle : %d\n", cookie, __FUNCTION__, handle);
+ break;
+ default:
+ /* We just ignore other options. Another option we often get is SO_NREAD. */
+ return 0;
+ }
+
+
+ return EJUSTRETURN;
+}
+
+static errno_t
+tls_listen_fn(void *cookie, socket_t so)
+{
+ tls_printf("tlsnke(%p):%s\n", cookie, __FUNCTION__);
+
+ return 0;
+}
+
+
+/* Dispatch vector for TCPLogger IPv4 socket functions */
+static struct sflt_filter tls_sflt_filter_ip4 = {
+ TLS_HANDLE_IP4, /* sflt_handle - use a registered creator type - <http://developer.apple.com/datatype/> */
+ SFLT_PROG, /* sf_flags */
+ MYBUNDLEID, /* sf_name - cannot be nil else param err results */
+ tls_unregistered_fn, /* sf_unregistered_func */
+ tls_attach_fn, /* sf_attach_func - cannot be nil else param err results */
+ tls_detach_fn, /* sf_detach_func - cannot be nil else param err results */
+ tls_notify_fn, /* sf_notify_func */
+ NULL, /* sf_getpeername_func */
+ NULL, /* sf_getsockname_func */
+ tls_data_in_fn, /* sf_data_in_func */
+ tls_data_out_fn, /* sf_data_out_func */
+ tls_connect_in_fn, /* sf_connect_in_func */
+ tls_connect_out_fn, /* sf_connect_out_func */
+ tls_bind_fn, /* sf_bind_func */
+ tls_setoption_fn, /* sf_setoption_func */
+ tls_getoption_fn, /* sf_getoption_func */
+ tls_listen_fn, /* sf_listen_func */
+ NULL /* sf_ioctl_func */
+};
+
+
+static caddr_t tls_utun_crypto_kpi_connect_fn(int dtls_handle, struct utun_pcb *utun_ref)
+{
+ dtls_ctx_t dtls_ref;
+
+ tls_printf("tlsnke:%s - handle=%d\n", __FUNCTION__, dtls_handle);
+
+ dtls_ref=get_dtls_context(dtls_handle);
+
+ if(dtls_ref) {
+ dtls_ref->utun_ref = utun_ref;
+ }
+
+ return (caddr_t)dtls_ref;
+}
+
+static errno_t tls_utun_crypto_kpi_send_fn(caddr_t ref, mbuf_t *pkt)
+{
+ dtls_ctx_t dtls_ref = (dtls_ctx_t)ref;
+ mbuf_t control = NULL;
+ struct cmsghdr *cmsg;
+ tls_record_hdr_t hdr;
+ size_t cbuf_len = CMSG_SPACE(sizeof(*hdr));
+ uint8_t cbuf[cbuf_len];
+ errno_t err;
+ int tmp=0;
+
+ check(ref);
+ check(pkt);
+
+ cmsg = (struct cmsghdr *)cbuf;
+ cmsg->cmsg_len = CMSG_LEN(sizeof(*hdr));
+ cmsg->cmsg_level = SOL_SOCKET;
+ cmsg->cmsg_type = SCM_TLS_HEADER;
+
+ hdr = (tls_record_hdr_t) CMSG_DATA(cmsg);
+ hdr->content_type = SSL_RecordTypeAppData;
+ hdr->protocol_version = DTLS_Version_1_0;
+
+ /*
+ Inject the packet that came from utun on top of the socket,
+ the socket filter will see the packet in tls_data_out_fn
+ where we do the decryption
+ TODO: do we need to specify dest address and/or flags ?
+ */
+
+ require_noerr(err=mbuf_allocpacket(M_NOWAIT, cbuf_len, NULL, &control), free_and_fail);
+ require_noerr(err=mbuf_copyback(control, 0, cbuf_len, cbuf, M_NOWAIT), free_and_fail);
+
+ /* TODO: Locking ?? only to get the socket out of the dtls_ref ? */
+ /* sock_inject_data_out will always free the mbufs, so we have a different fail path after that call */
+ require_noerr(err=sock_inject_data_out(dtls_ref->socket, NULL, *pkt, control, 0), just_fail);
+
+ require_noerr(err=sock_setsockopt(dtls_ref->socket, SOL_SOCKET, SO_TLS_SERVICE_WRITE_QUEUE, &tmp, 0), just_fail);
+
+/* Fail path before calling sock_inject_data_out */
+free_and_fail:
+ if(control)
+ mbuf_freem(control);
+ if(*pkt)
+ mbuf_freem(*pkt);
+
+/* Fail path after calling sock_inject_data_out */
+just_fail:
+ return err;
+}
+
+static struct utun_crypto_kpi_reg tls_utun_crypto_kpi = {
+ /* Dispatch functions */
+ .crypto_kpi_type = UTUN_CRYPTO_TYPE_DTLS,
+ .crypto_kpi_flags = 0,
+ .crypto_kpi_connect = tls_utun_crypto_kpi_connect_fn,
+ .crypto_kpi_send = tls_utun_crypto_kpi_send_fn
+};
+
+
+#if TLS_TEST
+/* BSD interface for testing only */
+#include <sys/conf.h>
+#include <miscfs/devfs/devfs.h>
+#include <sys/uio.h>
+
+/* Queue mbuf to tlsnkdev in Q */
+static STAILQ_HEAD(, PktQueueItem) tlsnkedev_inq;
+static lck_grp_attr_t *tlsnkedev_lock_grp_attr;
+static lck_grp_t *tlsnkedev_lock_grp;
+static lck_attr_t *tlsnkedev_lock_attr;
+static lck_mtx_t *tlsnkedev_lock;
+
+
+static int tlsnkedev_queue(mbuf_t m)
+{
+ struct PktQueueItem *tlq= (struct PktQueueItem *)OSMalloc(sizeof (struct PktQueueItem), gOSMallocTag);
+
+ tls_printf("tlsnkedev:%s\n", __FUNCTION__);
+
+ /* If we can't allocate, we just drop */
+ verify_action(tlq, return ENOMEM);
+ tlq->data = m;
+
+ lck_mtx_lock(tlsnkedev_lock);
+ STAILQ_INSERT_TAIL(&tlsnkedev_inq, tlq, next);
+ wakeup(&tlsnkedev_inq);
+ lck_mtx_unlock(tlsnkedev_lock);
+
+ return 0;
+}
+
+static int tlsnkedev_open(__unused dev_t dev, int flags, __unused int devtype, __unused struct proc *p)
+{
+ dtls_ctx_t dtls_ref;
+
+ tls_printf("tlsnkedev:%s\n", __FUNCTION__);
+
+ dtls_ref = get_dtls_context(0);
+ dtls_ref->queue_to_tlsnkedev=true;
+
+ /* Reinitialize the Q */
+ STAILQ_INIT(&tlsnkedev_inq);
+
+ tls_printf("tlsnkedev:%s. inq first=%p last=%p\n", __FUNCTION__, tlsnkedev_inq.stqh_first, tlsnkedev_inq.stqh_last);
+
+ return 0;
+}
+
+static int tlsnkedev_close(__unused dev_t dev, __unused int flags, __unused int mode, __unused struct proc *p)
+{
+ dtls_ctx_t dtls_ref;
+
+ tls_printf("tlsnkedev:%s\n", __FUNCTION__);
+
+ dtls_ref = get_dtls_context(0);
+ dtls_ref->queue_to_tlsnkedev=false;
+
+ return 0;
+}
+
+static int tlsnkedev_read(dev_t dev, struct uio *uio, int ioflag)
+{
+ int err=0;
+ int ulen, mlen, amnt;
+ char *buffer=NULL;
+ mbuf_t m;
+ struct PktQueueItem *in_q;
+
+ tls_printf("tlsnkedev:%s\n", __FUNCTION__);
+
+ ulen=uio_resid(uio);
+
+ lck_mtx_lock(tlsnkedev_lock);
+ if(STAILQ_EMPTY(&tlsnkedev_inq)) {
+ msleep(&tlsnkedev_inq, tlsnkedev_lock, 0, __FUNCTION__, NULL);
+ }
+ in_q = STAILQ_FIRST(&tlsnkedev_inq);
+ STAILQ_REMOVE_HEAD(&tlsnkedev_inq, next);
+ lck_mtx_unlock(tlsnkedev_lock);
+
+ tls_printf("tlsnkedev:%s. got %p from inq\n", __FUNCTION__, in_q);
+
+ verify_action(in_q, return EAGAIN); // This should not happen since we are blocking.
+
+ m = in_q->data;
+ verify_action(m, return EFAULT); // we should never queue NULL mbufs
+
+ mlen=mbuf_len(m);
+ check(mlen); // we should never queue empty mbufs, but we can just return a read of 0.
+ check(ulen); // user requested 0 bytes? sure, but this will drop the mbuf.
+
+ amnt = MIN(mlen, ulen);
+
+ buffer=OSMalloc(amnt, gOSMallocTag);
+ verify_action(buffer, return ENOMEM); // We drop the mbuf in that case too.
+
+ require_noerr(err=mbuf_copydata(m, 0, amnt, buffer), out);
+ require_noerr(err=uiomove(buffer, amnt, uio), out);
+
+out:
+ OSFree(in_q, sizeof (struct PktQueueItem), gOSMallocTag);
+ mbuf_freem(m);
+ OSFree(buffer, amnt, gOSMallocTag);
+ return 0;
+}
+
+static int tlsnkedev_write(dev_t dev, struct uio *uio, int ioflag)
+{
+ int err=0;
+ int len;
+ char *buffer=NULL;
+ mbuf_t m=NULL;
+
+ tls_printf("tlsnkedev:%s\n", __FUNCTION__);
+
+ len=uio_resid(uio);
+
+ buffer=OSMalloc(len, gOSMallocTag);
+ verify_action(buffer, return ENOMEM);
+
+ require_noerr(err=uiomove(buffer, len, uio), out);
+ require_noerr(err=mbuf_allocpacket(M_NOWAIT, len, NULL, &m), out);
+ require_noerr(err=mbuf_copyback(m, 0, len, buffer, M_NOWAIT), out);
+
+
+ err=tls_utun_crypto_kpi_send_fn((caddr_t)get_dtls_context(0), &m);
+
+out:
+ OSFree(buffer, len, gOSMallocTag);
+
+ return err;
+}
+
+static struct cdevsw tlsnkedev_cdevsw =
+{
+ tlsnkedev_open, /* open */
+ tlsnkedev_close, /* close */
+ tlsnkedev_read, /* read */
+ tlsnkedev_write, /* write */
+ eno_ioctl, /* ioctl */
+ eno_stop, /* stop */
+ eno_reset, /* reset */
+ NULL, /* tty's */
+ eno_select, /* select */
+ eno_mmap, /* mmap */
+ eno_strat, /* strategy */
+ eno_getc, /* getc */
+ eno_putc, /* putc */
+ 0 /* type */
+};
+
+static void tlsnkedev_devinit(void)
+{
+ int ret;
+
+ ret = cdevsw_add(-1, &tlsnkedev_cdevsw);
+
+ tls_printf("tlsnkedev:%s - major=%d\n", __FUNCTION__, ret);
+
+ devfs_make_node(makedev(ret, 0), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0666, "tlsnke");
+
+
+ /* allocate lock group attribute and group */
+ tlsnkedev_lock_grp_attr = lck_grp_attr_alloc_init();
+ tlsnkedev_lock_grp = lck_grp_alloc_init("tlsnkedev_lock", tlsnkedev_lock_grp_attr);
+ /* Allocate lock attribute */
+ tlsnkedev_lock_attr = lck_attr_alloc_init();
+ tlsnkedev_lock = lck_mtx_alloc_init(tlsnkedev_lock_grp, tlsnkedev_lock_attr);
+
+
+}
+#endif /* TLS_TEST */
+
+kern_return_t tlsnke_start(kmod_info_t * ki, void *d);
+kern_return_t tlsnke_stop(kmod_info_t *ki, void *d);
+
+kern_return_t tlsnke_start(kmod_info_t * ki, void *d)
+{
+ kern_return_t retval;
+
+ tls_printf("tlsnke:%s\n", __FUNCTION__);
+
+#if TLS_TEST
+ //Init the BSD device
+ tlsnkedev_devinit();
+#endif
+
+ // set up the tag value associated with this NKE in preparation for swallowing packets and re-injecting them
+ gOSMallocTag = OSMalloc_Tagalloc(MYBUNDLEID, OSMT_DEFAULT); // don't want the flag set to OSMT_PAGEABLE since
+ // it would indicate that the memory was pageable.
+ verify_action(gOSMallocTag, return KERN_MEMORY_ERROR);
+
+ clear_dtls_contexts();
+
+ retval = utun_ctl_register_dtls(&tls_utun_crypto_kpi);
+ require_noerr(retval, out);
+
+ retval = sflt_register(&tls_sflt_filter_ip4, PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+
+out:
+ return retval;
+}
+
+kern_return_t tlsnke_stop(kmod_info_t *ki, void *d)
+{
+ kern_return_t retval;
+ tls_printf("tlsnke:%s\n", __FUNCTION__);
+
+ retval = sflt_unregister(TLS_HANDLE_IP4);
+
+ return KERN_SUCCESS;
+}
projects / apple / security.git / blobdiff