yet another KTLS

Linux 4.13/4.14内核带来了一个新玩意儿，它叫ULP(Upper Layer Protocol)，这是一个框架，引入的初衷旨在支持KTLS(Kernel TLS Support)，这就跟为了支持TCP BBR而对整个TCP实现进行重构一样。ULP完全就是为KTLS量身定制的，只是额外的，它恰到好处的可以做一些其它方面很漂亮的事情。本文后面将给出一个Dmeo。

什么？KTLS？这难道不是早就有了么？

是的，在Linux内核中支持TLS这个思路早就被Facebook提出来了，我之前也写过这方面的一篇文章：
《来自Facebook的KTLS(Kernel SSL/TLS)原理和实例》：http://blog.csdn.net/dog250/article/details/53868519
那么，Linux 4.14内核中的KTLS和Dave Watson的原始的KTLS实现又有何不同呢？答案是，4.14的KTLS利用ULP作为其底层支撑，妙处在于，ULP不但可以支撑KTLS，而且可以作为一个通用的框架来支撑其它的功能。

而对于原始的KTLS，它基于一种新型的套接字类型来支持TLS记录协议，这种实现并不优雅，如果你要实现另外一个协议，就需要再来一个套接字类型，最终会形成像UNIX sockopt那样的噩梦。ULP不一般，它简直就是一个平铺在“传输层”之上的“任意上层”，从而完美映射了OSI模型的7层模型！

Linux协议栈

从协议分层模型上来讲，Linux仅仅实现了TCP/IP模型，因此在Linux内核协议栈里是看不到传输层以上的各层的，如果你想实现一个表示层或者会话层，你就必须使用某种用户态的库，比如作为会话层协议的SSL/TLS握手协议，以及作为表示层协议的SSL/TLS记录协议，你可以使用OpenSSL来实现(libssl，libcrypto)，但是在内核协议栈中并不支持它们。

另一方面，从BSD socket接口上来说，socket仅仅提供一个接口规范，并没有规定接口如何实现。我们知道，在Windows系统中，socket程序必须初始化SPI，即必须以WSAStartup作为起始，安装了特定供应商的socket实现的WinSock，socket的行为便可以和特定的WinSock服务供应商的实现绑定，我在很早以前写过这么一个Demo：
《Windows上的OpenVPN如何封装真实IP作为源地址》：http://blog.csdn.net/dog250/article/details/7988939
很早前玩TAP网卡时写的一篇，现在Linux也可以实现类似的功能了。

动机

如果你要问把一些编码，封装之类的功能放到内核里实现到底有什么好处，答案可不仅仅是这可以提高性能这么简单，很多人对待用户态实现和内核态实现之间的比较时，总喜欢从性能入手，这其实远不正确。内核支持比库支持更底层，可以让你远离库依赖导致的兼容性，并且可以让你做到不改一行用户态代码就可以用新的协议封装数据，
诱惑够大了吧！事实上，很多时候性能并非关注点，用户态的库实现性能如今都堪比甚至超越内核实现了，至于说用户态和内核态之间的数据拷贝开销，也有很多不同的解决之道。

Linux 4.14的KTLS

Linux 4.14内核内置了KTLS的支持，然而如果你使用它的话，请务必注意，目前的KTLS并不是一个完整的TLS实现，它仅仅实现记录协议的一部分(即对称加密，目前依然没有实现对称解密操作)并完全没有实现握手协议，相关的资料链接列如下：
KTLS支撑-ULP：
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=734942cc4ea6478eed125af258da1bdbb4afe578
ULP说明：
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=99c195fb4eea405160ade58f74f62aed19b1822c
KTLS实现：
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3c4d7559159bfe1e3b94df3a657b2cda3a34e218
仔细看下这个实现，就会发现，它虽然没有完整实现整个TLS，但是搭建了一个好用的架子，要比Dave Watson的原始版本规整很多，在ULP基础上，所有的功能都可以很容易实现，让实现者更多的关注于业务逻辑而不是平台相关的细节，这是多么的OO啊！

UTP Demo-Caesar cipher

好了，以下才是本文我想着重表达的东西，即正文。

本文中，我想给出一个Demo，实现一个无缝的凯撒加密传输，所谓的无缝，就是说交互双方并不了解自己的数据被凯撒加密算法加密了，应用程序依然使用send/recv这类socket接口，然而仅仅通过一个显式的setsockopt或者一个被劫持的setsockopt调用，数据就被加密了，待数据到达接收端的时候，它被自然解密而还原。秘密何在，我来揭开！

首先看一下传输双方的代码，我以一个典型的基于TCP协议的C/S程序为例，首先我给出C和S的代码：

服务端代码(编译成server)

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<errno.h>
#include<sys/types.h>
#include <netinet/tcp.h>
#include <unistd.h>

int port = 1234;
// 两边的key必须一致
int key = 12354;

#define TCP_ULP         31
#define TCP_NONE        100

int main()
{
        int sockfd;
        int ret;
        char buf[256];
        struct sockaddr_in serveraddr;
        struct sockaddr_in clientaddr;
        int addr_len = sizeof(clientaddr); 
        int clientfd; 

        bzero(&serveraddr, sizeof(serveraddr));
        serveraddr.sin_family = AF_INET;
        serveraddr.sin_port = htons(port);
        serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);

        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if(sockfd == -1){
                perror("socket error_1");
                return 1;
        }

        ret = bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
        if(ret == -1){
                perror("bind error_1");
                close(sockfd);
                return 1;
        }

        ret = listen(sockfd, 5);
        if (ret < 0) {  
                perror("listen");  
                close(sockfd);
                return 1;  
        }  

        while(1){
                clientfd = accept(sockfd, (struct sockaddr*)&clientaddr, (socklen_t*)&addr_len);  
                if(clientfd < 0) {
                        perror("accept");
                        continue;
                }
                // 设置使用支持凯撒加密的ULP
                setsockopt(clientfd, SOL_TCP, TCP_ULP, "Caesar cipher", sizeof("Caesar cipher"));
                perror("ulp init");
                // 设置加密算法的key
                setsockopt(clientfd, SOL_TCP, TCP_NONE, &key, sizeof(int));
                perror("cipher init");

                ret = recv(clientfd, buf, sizeof(buf), 0);
                if (ret < 0) {
                        perror("recv error");
                        close(clientfd);
                        close(sockfd);
                        return 1;
                }
                buf[ret] = 0;
                printf("%s\n", buf);
                close(clientfd);
        }
        close(sockfd);
        return 0;
}

客户端代码(编译成client)

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<errno.h>
#include<sys/types.h>
#include <netinet/tcp.h>
#include <unistd.h>

int port = 1234;
// 两边的key必须一致
int key = 12354;

#define TCP_ULP         31
#define TCP_NONE        100

int main()
{
        int sockfd;
        int i = 0;
        int ret;
        struct sockaddr_in serveraddr;
        char *buf = "abcdefg";

        bzero(&serveraddr, sizeof(serveraddr));
        serveraddr.sin_family = AF_INET;
        serveraddr.sin_port = htons(port);
        serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");  

        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd == -1) {
                perror("socket error!");
                return 1;
        }
        // 设置使用凯撒加密的ULP
        setsockopt(sockfd, SOL_TCP, TCP_ULP, "Caesar cipher", sizeof("Caesar cipher"));
        perror("ulp init");
        // 设置加密算法的key
        setsockopt(sockfd, SOL_TCP, TCP_NONE, &key, sizeof(int));
        perror("cipher init");

        ret = connect(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
        if (ret < 0) {  
                perror("connect");  
                close(sockfd);
                return 1;  
        }  

        ret = send(sockfd, buf, sizeof(buf), 0);
        if (ret < 0) {
                perror("recvfrom error");
                perror("connect");  
                return 1;
        }

        close(sockfd);
        return 0;
}

先不要看代码里的那些setsockopt，只管看send/recv这些，可以看到和往常并没有什么不一样，客户端发送给服务端一串字符串“abcdefg”，服务端如实打印出来的就是“abcdefg”，毫不失真，然而，如果你抓包，就会看到下面的包：

这里写图片描述

显然，数据被加密了！

没有隧道，没有任何额外的外部配置，仅仅一个setsockopt就能让数据被加密？匪夷所思吧…这就是ULP实现的表示层，我们马上就来看看这是怎么实现的。

非常简单，内核中的ULP框架实际上做了两件事：

ULP支持框架做的事
替换setsockopt为自己的setsockopt回调，默认调用原始的setsockopt。
具体ULP实现做的事
实现setsockopt回调，在setsockopt回调中替换proto结构体，择情况重新实现proto结构体中的sendmsg，sendpage，recvmsg等回调函数。

实现有点简陋，但先不评鉴，先实现了一个Demo再说，我接下来马上就给出实现，即凯撒加密的实现，代码如下(编译成Caesar_cipher.ko)：

#include <linux/module.h>
#include <net/tcp.h>

static struct proto Caesar_cipher_base_prot;
static struct proto ulp_Caesar_cipher_prot;

#define TCP_NONE        100

struct Caesar_cipher_context {
        // 简陋的密钥
        int key;
        // 保留的原始的proto结构的setsockopt函数
        int  (*setsockopt)(struct sock *sk, int level, int optname, char __user *optval, unsigned int optlen);
        // 保留的原始的proto结构的getsockopt函数
        int  (*getsockopt)(struct sock *sk, int level, int optname, char __user *optval, int __user *optlen);
        // 保留的原始的proto结构的sendmsg函数
        int  (*sendmsg)(struct sock *sk, struct msghdr *msg, size_t len);
        // 保留的原始的proto结构的recvmsg函数
        int  (*recvmsg)(struct sock *sk, struct msghdr *msg, size_t len, int noblock, int flags, int *addr_len);
        // 保留的原始的proto结构的close函数
        void (*close)(struct sock *sk, long timeout);
};

static inline struct Caesar_cipher_context *Caesar_cipher_get_ctx(const struct sock *sk)
{
        struct inet_connection_sock *icsk = inet_csk(sk);
        return icsk->icsk_ulp_data;
}

// 感觉实现这个没有什么意义，暂不实现
static int Caesar_cipher_getsockopt(struct sock *sk, int level, int optname,
                          char __user *optval, int __user *optlen)
{
        struct Caesar_cipher_context *ctx = Caesar_cipher_get_ctx(sk);
        return ctx->getsockopt(sk, level, optname, optval, optlen);
}

static int Caesar_cipher_setsockopt(struct sock *sk, int level, int optname,
                          char __user *optval, unsigned int optlen)
{
        struct Caesar_cipher_context *ctx = Caesar_cipher_get_ctx(sk);
        struct proto *prot = NULL;
        int val;

        if (level != TCP_NONE) {
            return ctx->setsockopt(sk, level, optname, optval, optlen);
        }

        if (get_user(val, (int __user *)optval)) {
                ctx->key = 0;
        } else {
                ctx->key = val;
        }

        // 替换socket的proto并保留原始的close回调
        prot = &ulp_Caesar_cipher_prot;
        ctx->close = sk->sk_prot->close;
        sk->sk_prot = prot;

        return 0;
}

int Caesar_cipher_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
{
        struct Caesar_cipher_context *ctx = Caesar_cipher_get_ctx(sk);
        char *userbuf;
        struct msghdr newmsg;
        struct iovec iov[1];
        int err;

        mm_segment_t oldfs = get_fs();

        // 分配一个新的buffer，这是为了用户空间和内核空间冲突
        userbuf = vmalloc(size);
        if (!userbuf)  {
                return -ENOMEM;
        }

        iov[0].iov_base = userbuf;
        iov[0].iov_len = size;
        err = memcpy_from_msg(userbuf, msg, size);
        if (err) {
                vfree(userbuf);
                return -EINVAL;
        }

        // inline encrypt  凯撒加密操作
        { 
                int i = 0;
                for (i = 0; i < size; i++) {
                        userbuf[i] = userbuf[i] + ctx->key;
                }
        }

        iov_iter_init(&newmsg.msg_iter, WRITE, iov, 1, size);
        newmsg.msg_name = NULL;
        newmsg.msg_namelen = 0;
        newmsg.msg_control = NULL;
        newmsg.msg_controllen = 0;
        newmsg.msg_flags = msg->msg_flags;

        // 申明现在是在内核态发送数据
        set_fs(KERNEL_DS);
        // 调用原始的sendmsg发送新分配的buffer
        err = ctx->sendmsg(sk, &newmsg, size);
        set_fs(oldfs);

        vfree(userbuf);

        return err;
}

// 本回调函数的实现和sendmsg思路无异
int Caesar_cipher_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
                                int flags, int *addr_len)
{
        struct Caesar_cipher_context *ctx = Caesar_cipher_get_ctx(sk);
        int ret, err;

        char *userbuf;
        struct msghdr newmsg;
        struct iovec iov[1];

        mm_segment_t oldfs = get_fs();

        userbuf = vmalloc(len);
        if (!userbuf)  {
                return -ENOMEM;
        }

        iov[0].iov_base = userbuf;
        iov[0].iov_len = len;

        iov_iter_init(&newmsg.msg_iter, READ, iov, 1, len);
        newmsg.msg_name = NULL;
        newmsg.msg_namelen = 0;
        newmsg.msg_control = NULL;
        newmsg.msg_controllen = 0;
        newmsg.msg_flags = msg->msg_flags;

        set_fs(KERNEL_DS);
        ret = ctx->recvmsg(sk, &newmsg, len, nonblock, flags, addr_len);
        set_fs(oldfs);

        // inline decrypt 凯撒解密操作
        {
                int i = 0;
                for (i = 0; i < ret; i++) {
                        userbuf[i] = userbuf[i] - ctx->key;
                }
        }

        err = memcpy_to_msg(msg, userbuf, ret);
        if (err) {
                ret = -EINVAL;
        }

        vfree(userbuf);
        return ret;
}

static int Caesar_cipher_init(struct sock *sk)
{
        struct inet_connection_sock *icsk = inet_csk(sk);
        struct Caesar_cipher_context *ctx;
        int rc = 0;

        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
        if (!ctx) {
                rc = -ENOMEM;
                goto out;
        }

        icsk->icsk_ulp_data = ctx;

        // 保留set/getsockopt的核心操作
        ctx->setsockopt = sk->sk_prot->setsockopt;
        ctx->getsockopt = sk->sk_prot->getsockopt;
        // 保留send/recvmsg的核心操作
        ctx->sendmsg = sk->sk_prot->sendmsg;
        ctx->recvmsg = sk->sk_prot->recvmsg;

        // 整体替换socket的proto操作回调，但事实上就是复制了原始的proto操作回调，真正替换操作在setsockopt中进行
        sk->sk_prot = &Caesar_cipher_base_prot;
out:
        return rc;
}

static void Caesar_cipher_close(struct sock *sk, long timeout)
{
        struct Caesar_cipher_context *ctx = Caesar_cipher_get_ctx(sk);
        kfree (ctx);
        ctx->close(sk, timeout);
}

static struct tcp_ulp_ops tcp_Caesar_cipher_ulp_ops __read_mostly = {
        .name   = "Caesar cipher",
        .owner  = THIS_MODULE,
        .init   = Caesar_cipher_init,
};

static int __init Caesar_cipher_register(void)
{
        Caesar_cipher_base_prot                 = tcp_prot;
        Caesar_cipher_base_prot.setsockopt      = Caesar_cipher_setsockopt;
        Caesar_cipher_base_prot.getsockopt      = Caesar_cipher_getsockopt;

        // 替换个别的回调函数
        ulp_Caesar_cipher_prot                  = Caesar_cipher_base_prot;
        ulp_Caesar_cipher_prot.sendmsg          = Caesar_cipher_sendmsg;
        ulp_Caesar_cipher_prot.recvmsg          = Caesar_cipher_recvmsg;
        ulp_Caesar_cipher_prot.close            = Caesar_cipher_close;

        // 这个注册不再解释，无非就是把一个结构体链入一个链表，等到setsockopt执行ULP绑定时再查找而已
        tcp_register_ulp(&tcp_Caesar_cipher_ulp_ops);

        return 0;
}

static void __exit Caesar_cipher_unregister(void)
{
        tcp_unregister_ulp(&tcp_Caesar_cipher_ulp_ops);
}

module_init(Caesar_cipher_register);
module_exit(Caesar_cipher_unregister);

MODULE_AUTHOR("Zhao Ya <[email protected]>");
MODULE_DESCRIPTION("Linux 4.14 ULP Demo");
MODULE_LICENSE("GPL");

根据以上的描述和源码，这就很容易理解为什么需要两个setsockopt来完成注册和绑定了。第一个setsockopt只是替换了setsockopt函数，第二个setsockopt替换了部分的proto操作回调并且设置了加密密钥，然后新的proto操作就可以自由挥洒了，仅此而已。

如果你仔细看KTLS的实现，它也仅此而已。妙处就在ULP而别无他。然而，然而我不是说可以无缝进行应用程序的数据加密吗？如果应用程序不能改，也就说说不能分别加入那两个setsockopt，那可怎么办？简单！用Linux的LD_PRELOAD来劫持系统调用即可，仅以服务端为例。请把上述的服务端的C代码中的setsockopt分别注释掉，然后编译以下的代码：

#define _GNU_SOURCE
#include <stdio.h>  
#include <dlfcn.h> 
#include<errno.h>
#include <netinet/tcp.h>

#define TCP_ULP         31
#define TCP_NONE        100

int key = 12354;

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
{
        int clisd;
        typeof(accept) *_accept;  

        _accept = dlsym(RTLD_NEXT, "accept");
        clisd = (*_accept)(sockfd, addr, addrlen);
        setsockopt(clisd, SOL_TCP, TCP_ULP, "Caesar cipher", sizeof("Caesar cipher"));
        perror("client ulp init");
        setsockopt(clisd, SOL_TCP, TCP_NONE, &key, sizeof(int));
        perror("client cipher init");

        return clisd;
}

编译方法如下：

gcc -shared -fPIC preload_ulp.c -o preload_ulp.so

然后再运行服务端前引用一个环境变量：

LD_PRELOAD=./preload_ulp.so ./server

即可！

好啦，现在可以统一运行它们了。首先加载ULP内核模块：

insmod ./Caesar_cipher.ko

然后执行server：

LD_PRELOAD=./preload_ulp.so ./server

最后执行client：

./client

OK，服务端完美打印出了“abcdefg”。结束了吗？结束了！

现在要评鉴它了，ULP确实有点Low，基于它的Low，我也只能实现一个凯撒加密，更高大上的实现我止步于那些复杂的数据结构解析，当然这可能是因为我术业不精所致，但这难道不也印证了ULP的接口不友好吗？一个友好的接口可以让人们编程像是烧锅炉一样，就像吃饭一样，当一个接口调用像是做引体向上一样的时候，那就悲哀了！
…

我的感触是，并且我的愿望是，实现一个iptables的target，可以为任意一个既有的连接在端到端实现无缝的凯撒加密，比如这样：

iptables -A INPUT -s 1.1.1.1 -p tcp --sport 123 -d 2.2.2.2 --dport 234 -j GaiusDecrypt --key 12354 
iptables -A OUTPUT -s 1.1.1.1 -p tcp --sport 123 -d 2.2.2.2 --dport 234 -j GaiusDecrypt --key 12354

然后对应五元组TCP-1.1.1.1:123/2.2.2.2:234流量就被密钥为12354给加密了，这比较帅了，所需要做的只是在target处理函数中查找一下socket然后调用一下setsockopt而已，或者更加简单的，找到conntrack，然后将key设置到conntrack表项。然而这只是一个非常简单的思路，更加复杂的玩法尽在想象中，完全不受限制。

过程

编写这个Caesar cipher内核模块是艰辛的，这倒不是说ULP原理上有多难，代码多么难写，事实上代码是很简单的，问题出在环境的搭建上。

我的手头有Debian 9的开发机，它内置了4.9的内核，已经够新的了吧，但是很抱歉，ULP以及KTLS只在4.13+上被支持，这个从下面的链接可以看到：
Linux 4.13#Networking：https://kernelnewbies.org/Linux_4.13
所以我选择了4.14版本进行Demo的开发。我为源码编译分配了4G的磁盘空间，使用Debian 9自带的config文件进行编译，然而没过多久就提示空间不足，我只能全部重来，这个时候我把空间加大了一倍，到达8G的样子，于是我就睡觉了，次日醒来，几个提示空间不足的大字扎瞎了我的眼睛…由于我看到已经到最后一步了，所以我把空间加大到了9G，开启脚本后就去上班去了，晚上下班到家，终于搞定了….这才开始写这个Demo，空间不足问题足足耗了我一天一夜的时间！

我在想什么时候编译一个内核都需要这么大的磁盘空间了，难道诸发行版真的是越来越臃肿了吗？这还怎么玩啊！都胖成这样了，为何还不减肥…

Linux 4.13/4.14内核中带来的ULP(Upper Layer Protocol)

yet another KTLS

Linux协议栈

动机

Linux 4.14的KTLS

UTP Demo-Caesar cipher

过程

猜你喜欢