Linux网络协议栈9--ipsec收发包流程
IPSec协议帮助IP层建立安全可信的数据包传输通道。当前已经如strongswan、openswan等比较成熟稳定的开源项目做协议层的控制。但他们最终都是使用的内核的XFRM框架做报文的封装发送和接收解封，只不过内核的转发表项数据是由他们生成的。
XFRM，是transfrom的简写。
######IPSec收包解封流程
流程路径：ip_rcv() --> ip_rcv_finish() --> ip_local_deliver() --> ip_local_deliver_finish()
解封侧一定是ip报文的目的端，ip_rcv_finish中查到的路由肯定是本机路由（RTCF_LOCAL），调用 ip_local_deliver 处理。
下面是贴的网上的一张图片。
ip_local_deliver_finish中 根据上次协议类型，调用对应的处理函数。inet_protos 中挂载了各类协议的操作集，对于AH或者ESP来说，是xfrm4_rcv，对于ipsec nat-t情况下，是udp协议的处理函数udp_rcv，内部才是封装的ipsec报文（AH或者ESP）。
static int ip_local_deliver_finish(struct sk_buff *skb)
{
......
hash = protocol & (MAX_INET_PROTOS - 1);
ipprot = rcu_dereference(inet_protos[hash]);
......
if (ipprot != NULL) {
......
ret = ipprot->handler(skb);
......
}
......
}
xfrm4_rcv --> xfrm4_rcv_spi --> xfrm4_rcv_encap --> xfrm_input
最终调用 xfrm_input 做收包解封装流程。
1、创建SKB的安全路径；
2、解析报文，获取daddr、spi，加上协议类型（esp、ah等），就可以查询到SA了，这些是SA的key，下面列出了一组linux ipsec的state（sa）和policy，方便一眼就能看到关键信息；
3、调用SA对应协议类型的input函数，解包，并返回更上层的协议类型，type可为esp,ah,ipcomp等。对应的处理函数esp_input、ah_input等；
4、解码完成后，再根据ipsec的模式做解封处理，常用的有隧道模式和传输模式。对应xfrm4_mode_tunnel_input 和 xfrm4_transport_inout，处理都比较简单，隧道模式去掉外层头，传输模式只是设置一些skb的数据。
5、协议类型可以多层封装，如ESP+AH，所以需要再次解析内存协议，如果还是AH、ESP、COMP，则解析新的spi，返回2，查询新的SA处理报文。
6、经过上面流程处理，漏出了用户数据报文（IP报文），根据ipsec模式：
- tunnel模式，用新的ip头（用户报文），调用netif_rx 重入协议栈；
- 传输模式，调用进 xfrm4_transport_finish ，重入部分协议栈，首先进PREROUTING 点处理，虽然当前经过PREROUTING 和 INPUT点了，但解密出来的包的新的协议类型和端口号仍然可能要做nat，之后重新进行路由选择，调用路由的input函数（skb_dst(skb)->input(skb);），可能是ip_local_deliver()或ip_forward()，完成后面的协议栈。
#ip xfrm state
src 11.11.11.11 dst 12.12.12.12
proto esp spi 0x0bd7c7c3 reqid 245 mode tunnel
replay-window 0 flag af-unspec
auth-trunc hmac(sha1) 0xf45ccce0353a76dbfd260902acb2d9b6a58140f2 96
enc cbc(aes) 0xa8d0767a7a9c14046a83bc8d10b47d10b7b1d7f473e894c265b246f0b9e8096c
src 12.12.12.12 dst 11.11.11.11
proto esp spi 0xcdbc8e20 reqid 245 mode tunnel
replay-window 0 flag af-unspec
auth-trunc hmac(sha1) 0x582534112007077449011c1a6f955f1df9b14b04 96
enc cbc(aes) 0xb6e944ba2f29ccea436aece32558173592fadf5fe61ae8c66f78d17046869ae1
# ip xfrm policy
src 0.0.0.0/0 dst 0.0.0.0/0
dir out priority 399999 ptype main
tmpl src 11.11.11.11 dst 12.12.12.12
proto esp spi 0x0bc742d3 reqid 245 mode tunnel
src 0.0.0.0/0 dst 0.0.0.0/0
dir fwd priority 399999 ptype main
tmpl src 12.12.12.12 dst 11.11.11.11
proto esp reqid 245 mode tunnel
src 0.0.0.0/0 dst 0.0.0.0/0
dir in priority 399999 ptype main
tmpl src 12.12.12.12 dst 11.11.11.11
proto esp reqid 245 mode tunnel
int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
{
struct net *net = dev_net(skb->dev);
int err;
__be32 seq;
struct xfrm_state *x;
xfrm_address_t *daddr;
struct xfrm_mode *inner_mode;
unsigned int family;
int decaps = 0;
int async = 0;
/* A negative encap_type indicates async resumption. */
if (encap_type < 0) {
async = 1;
x = xfrm_input_state(skb);
seq = XFRM_SKB_CB(skb)->seq.input;
goto resume;
}
/* Allocate new secpath or COW existing one. */
// 安全路径在收包的时候创建
if (!skb->sp || atomic_read(&skb->sp->refcnt) != 1) {
struct sec_path *sp;
sp = secpath_dup(skb->sp);
if (!sp) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINERROR);
goto drop;
}
if (skb->sp)
secpath_put(skb->sp);
skb->sp = sp;
}
daddr = (xfrm_address_t *)(skb_network_header(skb) +
XFRM_SPI_SKB_CB(skb)->daddroff);
family = XFRM_SPI_SKB_CB(skb)->family;
seq = 0;
if (!spi && (err = xfrm_parse_spi(skb, nexthdr, &spi, &seq)) != 0) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINHDRERROR);
goto drop;
}
do {
if (skb->sp->len == XFRM_MAX_DEPTH) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINBUFFERERROR);
goto drop;
}
// 查SA
x = xfrm_state_lookup(net, skb->mark, daddr, spi, nexthdr, family);
if (x == NULL) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINNOSTATES);
xfrm_audit_state_notfound(skb, family, spi, seq);
goto drop;
}
skb->sp->xvec[skb->sp->len++] = x;
spin_lock(&x->lock);
if (unlikely(x->km.state != XFRM_STATE_VALID)) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEINVALID);
goto drop_unlock;
}
if ((x->encap ? x->encap->encap_type : 0) != encap_type) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMISMATCH);
goto drop_unlock;
}
if (x->props.replay_window && xfrm_replay_check(x, skb, seq)) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATESEQERROR);
goto drop_unlock;
}
if (xfrm_state_check_expire(x)) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEEXPIRED);
goto drop_unlock;
}
spin_unlock(&x->lock);
XFRM_SKB_CB(skb)->seq.input = seq;
// 根据 协议类型进行解码，并返回更上层的协议类型，type可为esp,ah,ipcomp等。对应的处理函数esp_input、ah_input等
nexthdr = x->type->input(x, skb);
if (nexthdr == -EINPROGRESS)
return 0;
resume:
spin_lock(&x->lock);
if (nexthdr <= 0) {
if (nexthdr == -EBADMSG) {
xfrm_audit_state_icvfail(x, skb,
x->type->proto);
x->stats.integrity_failed++;
}
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEPROTOERROR);
goto drop_unlock;
}
/* only the first xfrm gets the encap type */
encap_type = 0;
if (x->props.replay_window)
xfrm_replay_advance(x, seq);
x->curlft.bytes += skb->len;
x->curlft.packets++;
spin_unlock(&x->lock);
XFRM_MODE_SKB_CB(skb)->protocol = nexthdr;
inner_mode = x->inner_mode;
if (x->sel.family == AF_UNSPEC) {
inner_mode = xfrm_ip2inner_mode(x, XFRM_MODE_SKB_CB(skb)->protocol);
if (inner_mode == NULL)
goto drop;
}
// 解码完成，根据模式解封装
if (inner_mode->input(x, skb)) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMODEERROR);
goto drop;
}
if (x->outer_mode->flags & XFRM_MODE_FLAG_TUNNEL) {
decaps = 1;
break;
}
/*
* We need the inner address. However, we only get here for
* transport mode so the outer address is identical.
*/
daddr = &x->id.daddr;
family = x->outer_mode->afinfo->family;
/* 看内层协议是否还需要继续解封装， 1=no，0=yes，-1=err
协议类型可以多层封装，如ESP+AH
*/
err = xfrm_parse_spi(skb, nexthdr, &spi, &seq);
if (err < 0) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINHDRERROR);
goto drop;
}
} while (!err);
// 清 netfilter 数据，后面转发流程新建
nf_reset(skb);
if (decaps) {
// 隧道模式，解包后用新的ip头，重入协议栈
skb_dst_drop(skb);
netif_rx(skb);
return 0;
} else {
/* 传输模式，进 xfrm4_transport_finish ，也需要重入部分协议栈
如果支持netfilter，进PREROUTING 点处理，重新进行路由选择等处理
虽然本处已经处于 INPUT 点，但解码后的协议类型和端口号改变，可能要进行NAT 操作
不支持 netfilter 的情况，也需要重新进行IP协议的处理，因为协议类型改变了。
*/
return x->inner_mode->afinfo->transport_finish(skb, async);
}
drop_unlock:
spin_unlock(&x->lock);
drop:
kfree_skb(skb);
return 0;
}
######IPSec发包封装流程
流程路径如下图，这里以转发流程为例，本机发送的包主要流程类似。
转发流程：
ip_forward 函数中调用xfrm4_route_forward，这个函数：
1、解析用户报文，查找对应的Ipsec policy（__xfrm_policy_lookup）；
2、再根据policy的模版tmpl查找对应最优的SA（xfrm_tmpl_resolve），模版的内容以及和SA的对应关系见上面贴出的ip xfrm命令显示；
3、最后根据SA生成安全路由，挂载再skb的dst上； 一条用户流可以声明多个安全策略（policy），所以会对应多个SA，每个SA处理会生成一个安全路由项struct dst_entry结构（xfrm_resolve_and_create_bundle），这些安全路由项通过 child 指针链接为一个链表，其成员 output挂载了不同安全协议的处理函数，这样就可以对数据包进行连续的处理，比如先压缩，再ESP封装，再AH封装。
安全路由链的最后一个路由项一定是普通IP路由项，因为最终报文都得走普通路由转发出去，如果是隧道模式，在tunnel output封装完完成ip头后还会再查一次路由挂载到安全路由链的最后一个。
注： SA安全联盟是IPsec的基础，也是IPsec的本质。 SA是通信对等体间对某些要素的约定，例如使用哪种协议、协议的操作模式、加密算法、特定流中保护数据的共享密钥以及SA的生存周期等。
然后，经过FORWARD点后，调用ip_forward_finish()–>dst_output，最终调用skb_dst(skb)->output(skb)，此时挂载的xfrm4_output
int ip_forward(struct sk_buff *skb)
{
......
// ipsec路由和选路，替换了 skb_dst(skb)
if (!xfrm4_route_forward(skb))
goto drop;
......
return NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, skb, skb->dev,
rt->u.dst.dev, ip_forward_finish);
......
}
static int ip_forward_finish(struct sk_buff *skb)
{
struct ip_options * opt = &(IPCB(skb)->opt);
IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
if (unlikely(opt->optlen))
ip_forward_options(skb);
return dst_output(skb);
}
int __xfrm_route_forward(struct sk_buff *skb, unsigned short family)
{
struct net *net = dev_net(skb->dev);
struct flowi fl;
struct dst_entry *dst;
int res;
if (xfrm_decode_session(skb, &fl, family) < 0) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMFWDHDRERROR);
return 0;
}
skb_dst_force(skb);
dst = skb_dst(skb);
// 查找安全路由，替换skb的dst
res = xfrm_lookup(net, &dst, &fl, NULL, 0) == 0;
skb_dst_set(skb, dst);
return res;
}
本机发送流程简单记录一下，和转发流程殊途同归：
查询安全路由： ip_queue_xmit --> ip_route_output_flow --> __xfrm_lookup
封装发送： ip_queue_xmit --> ip_local_out --> dst_output --> xfrm4_output
注：
1). 无论转发还是本地发送，在查询安全路由之前都会查一次普通路由，如果查不到，报文丢弃，但这条路由不一定需要指向真实的下一跳的出接口，只要能匹配到报文DIP即可，如配置一跳其它接口的defualt。
2). strongswan是一款用的比较多的ipsec开源软件，协商完成后可以看到其创建了220 table，经常有人问里面的路由有啥用、为什么有时有有时无。这里做个测试记录： 1、220中貌似只有在tunnel模式且感兴趣流是本机发起（本机配置感兴趣流IP地址）的时候才会配置感兴趣流相关的路由，路由指定了source；2、不配置也没有关系，如1）中所说，只要存在感兴趣流的路由即可，只不过ping的时候需要指定source，否者可能匹配不到感兴趣流。所以感觉220这个表一是为了保证
# strongswan 协商的感兴趣流是6.6.6.6-7.7.7.7
[root@master conf.d]# swanctl -l
gw-gw: #1, ESTABLISHED, IKEv2, 05696f6ebb126b03_i* b8b3e87df66f496f_r
local 'moon.strongswan.org' @ 172.16.70.1[500]
remote 'sun.strongswan.org' @ 172.16.70.2[500]
AES_CBC-192/HMAC_SHA1_96/PRF_HMAC_SHA1/MODP_1024
established 865s ago, reauth in 7887s
net-net: #1, reqid 1, INSTALLED, TUNNEL, ESP:AES_CBC-192/HMAC_SHA1_96
installed 865s ago, rekeying in 4305s, expires in 5075s
in c1d3090f, 1260 bytes, 15 packets, 780s ago
out cb124865, 1260 bytes, 15 packets, 780s ago
local 6.6.6.6/32
remote 7.7.7.7/32
[root@master conf.d]# ip rule
0: from all lookup local
220: from all lookup 220
32766: from all lookup main
32767: from all lookup default
[root@master conf.d]# ip route ls table 220
7.7.7.7 via 172.16.70.2 dev br0 proto static src 6.6.6.6
# 指定DIP ping的通
[root@master conf.d]# ping 7.7.7.7
PING 7.7.7.7 (7.7.7.7) 56(84) bytes of data.
64 bytes from 7.7.7.7: icmp_seq=1 ttl=64 time=0.273 ms
64 bytes from 7.7.7.7: icmp_seq=2 ttl=64 time=0.204 ms
64 bytes from 7.7.7.7: icmp_seq=3 ttl=64 time=0.229 ms
# 删除路由
[root@master conf.d]# ip route del 7.7.7.7 via 172.16.70.2 table 220
[root@master conf.d]# ip route ls table 220
[root@master conf.d]#
#指定SIP ping 是一样的
[root@master conf.d]# ping 7.7.7.7
PING 7.7.7.7 (7.7.7.7) 56(84) bytes of data.
^C
--- 7.7.7.7 ping statistics ---
2 packets transmitted, 0 received, 100% packet loss, time 1048ms
[root@master conf.d]# ping 7.7.7.7 -I 6.6.6.6
PING 7.7.7.7 (7.7.7.7) from 6.6.6.6 : 56(84) bytes of data.
64 bytes from 7.7.7.7: icmp_seq=1 ttl=64 time=0.241 ms
64 bytes from 7.7.7.7: icmp_seq=2 ttl=64 time=0.189 ms
64 bytes from 7.7.7.7: icmp_seq=3 ttl=64 time=0.200 ms
ipsec封装发送流程：
xfrm4_output–>xfrm4_output_finish–>xfrm_output–>xfrm_output2–>xfrm_output_resume–>xfrm_output_one
xfrm4_output 函数先过POSTROUTING点，在封装之前可以先做SNAT。后面则调用xfrm_output_resume–>xfrm_output_one 做IPSEC封装最终走普通路由走IP发送。
int xfrm4_output(struct sk_buff *skb)
{
return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, skb,
NULL, skb_dst(skb)->dev, xfrm4_output_finish,
!(IPCB(skb)->flags & IPSKB_REROUTED));
}
// 循环发送，应用所有 policy
static int xfrm_output_one(struct sk_buff *skb, int err)
{
struct dst_entry *dst = skb_dst(skb);
struct xfrm_state *x = dst->xfrm;
struct net *net = xs_net(x);
if (err <= 0)
goto resume;
do {
// SA 合法性检查
err = xfrm_state_check_space(x, skb);
if (err) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTERROR);
goto error_nolock;
}
// 调用模式 的输出函数，如隧道模式的封装，封装外部ip头，协议类型暂时为IPIP，后面回换
err = x->outer_mode->output(x, skb);
if (err) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTSTATEMODEERROR);
goto error_nolock;
}
spin_lock_bh(&x->lock);
err = xfrm_state_check_expire(x);
if (err) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTSTATEEXPIRED);
goto error;
}
if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
XFRM_SKB_CB(skb)->seq.output = ++x->replay.oseq;
if (unlikely(x->replay.oseq == 0)) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTSTATESEQERROR);
x->replay.oseq--;
xfrm_audit_state_replay_overflow(x, skb);
err = -EOVERFLOW;
goto error;
}
if (xfrm_aevent_is_on(net))
xfrm_replay_notify(x, XFRM_REPLAY_UPDATE);
}
x->curlft.bytes += skb->len;
x->curlft.packets++;
spin_unlock_bh(&x->lock);
// 协议类型输出，如ESP AH，ESP = esp4_output，封装协议头，并将IP 头协议类型该为 ESP
err = x->type->output(x, skb);
if (err == -EINPROGRESS)
goto out_exit;
resume:
if (err) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTSTATEPROTOERROR);
goto error_nolock;
}
// 更新 dst 和 sa 为下一个子安全路由和SA，继续处理
dst = skb_dst_pop(skb);
if (!dst) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTERROR);
err = -EHOSTUNREACH;
goto error_nolock;
}
skb_dst_set_noref(skb, dst);
x = dst->xfrm;
} while (x && !(x->outer_mode->flags & XFRM_MODE_FLAG_TUNNEL));
err = 0;
out_exit:
return err;
error:
spin_unlock_bh(&x->lock);
error_nolock:
kfree_skb(skb);
goto out_exit;
}
int xfrm_output_resume(struct sk_buff *skb, int err)
{
while (likely((err = xfrm_output_one(skb, err)) == 0)) {
// 释放netfilter信息，重新创建
nf_reset(skb);
// 过一遍LOCAL_OUT上的钩子函数
err = skb_dst(skb)->ops->local_out(skb);
if (unlikely(err != 1))
goto out;
// 是否还关联SA，不关联，ip_output 走POSTROUTING
if (!skb_dst(skb)->xfrm)
return dst_output(skb);
// 否者过POSTROUTING，再次进入xfrm_output2
err = nf_hook(skb_dst(skb)->ops->family,
NF_INET_POST_ROUTING, skb,
NULL, skb_dst(skb)->dev, xfrm_output2);
if (unlikely(err != 1))
goto out;
}
if (err == -EINPROGRESS)
err = 0;
out:
return err;
}
贴一些网上的几张数据结构图
1、安全路由
2、策略相关协议处理结构
3、状态相关协议处理结构
