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.12proto esp spi 0x0bd7c7c3 reqid 245 mode tunnelreplay-window 0 flag af-unspecauth-trunc hmac(sha1) 0xf45ccce0353a76dbfd260902acb2d9b6a58140f2 96enc cbc(aes) 0xa8d0767a7a9c14046a83bc8d10b47d10b7b1d7f473e894c265b246f0b9e8096c
src 12.12.12.12 dst 11.11.11.11proto esp spi 0xcdbc8e20 reqid 245 mode tunnelreplay-window 0 flag af-unspecauth-trunc hmac(sha1) 0x582534112007077449011c1a6f955f1df9b14b04 96enc cbc(aes) 0xb6e944ba2f29ccea436aece32558173592fadf5fe61ae8c66f78d17046869ae1
# ip xfrm policy
src 0.0.0.0/0 dst 0.0.0.0/0dir out priority 399999 ptype maintmpl src 11.11.11.11 dst 12.12.12.12proto esp spi 0x0bc742d3 reqid 245 mode tunnel
src 0.0.0.0/0 dst 0.0.0.0/0dir fwd priority 399999 ptype maintmpl src 12.12.12.12 dst 11.11.11.11proto esp reqid 245 mode tunnel
src 0.0.0.0/0 dst 0.0.0.0/0dir in priority 399999 ptype maintmpl src 12.12.12.12 dst 11.11.11.11proto 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;}// 查SAx = 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的dstres = 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_rlocal  '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_1024established 865s ago, reauth in 7887snet-net: #1, reqid 1, INSTALLED, TUNNEL, ESP:AES_CBC-192/HMAC_SHA1_96installed 865s ago, rekeying in 4305s, expires in 5075sin  c1d3090f,   1260 bytes,    15 packets,   780s agoout cb124865,   1260 bytes,    15 packets,   780s agolocal  6.6.6.6/32remote 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 头协议类型该为 ESPerr = 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 走POSTROUTINGif (!skb_dst(skb)->xfrm)return dst_output(skb);// 否者过POSTROUTING，再次进入xfrm_output2err = 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、状态相关协议处理结构