Linux内核中的IPSEC实现(5)
本文档的Copyleft归yfydz所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，严禁用于任何商业用途。
msn: yfydz_no1@hotmail.com
来源：http://yfydz.cublog.cn
7. IPV4下的xfrm支持处理在xfrm中各种和地址相关的操作是和协议族相关的, 因此这部分的具体实现就放在相关的协议族实现中, 然后通过状态和策略信息结构来指引到实际的操作中，完成对普通数据包的IPSEC包装或对IPSEC包的解封装。7.1 IPV4下的xfrm策略IPV4下的xfrm策略在net/ipv4/xfrm4_policy.c文件中定义, 主要是定义IPV4的策略信息结构:static struct xfrm_policy_afinfo xfrm4_policy_afinfo = { .family = AF_INET, .dst_ops = &xfrm4_dst_ops, .dst_lookup = xfrm4_dst_lookup, .get_saddr = xfrm4_get_saddr, .find_bundle = __xfrm4_find_bundle, .bundle_create = __xfrm4_bundle_create, .decode_session = _decode_session4,};在xfrm_policy_register_afinfo()函数中, 还定义了struct xfrm_policy_afinfo结构的其他几个成员函数,因为这几个函数是和协议无关的, 所以在登记函数中定义了: afinfo->garbage_collect = __xfrm_garbage_collect;该函数已经在本系列的第3篇中介绍过了. 以下是结构中几个函数的定义:// IPV4的路由查找, 就是普通是路由查找方法// 返回0成功static int xfrm4_dst_lookup(struct xfrm_dst **dst, struct flowi *fl){ return __ip_route_output_key((struct rtable**)dst, fl);}// 查找地址, 这个函数是在通道模式下, 源地址没明确指定时调用的,查找获取// 外部头中的源地址static int xfrm4_get_saddr(xfrm_address_t *saddr, xfrm_address_t *daddr){ struct rtable *rt;// 通道的流结构定义,用于查找路由 struct flowi fl_tunnel = { .nl_u = { .ip4_u = { .daddr = daddr->a4, }, }, };// 根据目的地址找路由 if (!xfrm4_dst_lookup((struct xfrm_dst **)&rt, &fl_tunnel)) {// 将找到的路由项中的源地址作为通道模式下的外部源地址 saddr->a4 = rt->rt_src; dst_release(&rt->u.dst); return 0; } return -EHOSTUNREACH;}// 查找策略中的安全路由, 查找条件是流结构的定义的参数static struct dst_entry *__xfrm4_find_bundle(struct flowi *fl, struct xfrm_policy *policy){ struct dst_entry *dst; read_lock_bh(&policy->lock);// 遍历策略的安全路由链表 for (dst = policy->bundles; dst; dst = dst->next) { struct xfrm_dst *xdst = (struct xfrm_dst*)dst;// 比较网卡位置, 目的地址, 源地址, TOS值是否匹配// 同时检查该安全路由是否可用 if (xdst->u.rt.fl.oif == fl->oif && /*XXX*/ xdst->u.rt.fl.fl4_dst == fl->fl4_dst && xdst->u.rt.fl.fl4_src == fl->fl4_src && xdst->u.rt.fl.fl4_tos == fl->fl4_tos && xfrm_bundle_ok(policy, xdst, fl, AF_INET, 0)) { dst_clone(dst); break; } } read_unlock_bh(&policy->lock); return dst;}// 解码skb数据, 填充流结构static void_decode_session4(struct sk_buff *skb, struct flowi *fl){ struct iphdr *iph = skb->nh.iph;// xprth是IP头后的上层协议头起始 u8 *xprth = skb->nh.raw + iph->ihl*4;// 先将流结构清零 memset(fl, 0, sizeof(struct flowi));// 数据包必须不是分片包 if (!(iph->frag_off & htons(IP_MF | IP_OFFSET))) { switch (iph->protocol) {// 对UDP(17), TCP(6), SCTP(132)和DCCP(33)协议, 要提取源端口和目的端口// 头4字节是源端口和目的端口 case IPPROTO_UDP: case IPPROTO_TCP: case IPPROTO_SCTP: case IPPROTO_DCCP:// 要让skb预留出IP头长度加4字节的长度, 在IP层data应该指向最外面的IP头 if (pskb_may_pull(skb, xprth + 4 - skb->data)) { u16 *ports = (u16 *)xprth;// 提取端口参数 fl->fl_ip_sport = ports[0]; fl->fl_ip_dport = ports[1]; } break; case IPPROTO_ICMP:// 对ICMP(1)协议要提取ICMP包的类型和编码, 2字节 if (pskb_may_pull(skb, xprth + 2 - skb->data)) { u8 *icmp = xprth; fl->fl_icmp_type = icmp[0]; fl->fl_icmp_code = icmp[1]; } break; case IPPROTO_ESP:// 对于ESP(50)协议要提取其中的SPI值, 4字节 if (pskb_may_pull(skb, xprth + 4 - skb->data)) { __be32 *ehdr = (__be32 *)xprth; fl->fl_ipsec_spi = ehdr[0]; } break; case IPPROTO_AH:// 对于AH(51)协议要提取其中的SPI值, 4字节 if (pskb_may_pull(skb, xprth + 8 - skb->data)) { __be32 *ah_hdr = (__be32*)xprth; fl->fl_ipsec_spi = ah_hdr[1]; } break; case IPPROTO_COMP:// 对于COMP(108)协议要提取其中CPI值作为SPI值, 2字节 if (pskb_may_pull(skb, xprth + 4 - skb->data)) { __be16 *ipcomp_hdr = (__be16 *)xprth; fl->fl_ipsec_spi = htonl(ntohs(ipcomp_hdr[1])); } break; default: fl->fl_ipsec_spi = 0; break; }; }// 填充协议,源地址,目的地址, TOS参数 fl->proto = iph->protocol; fl->fl4_dst = iph->daddr; fl->fl4_src = iph->saddr; fl->fl4_tos = iph->tos;} /* Allocate chain of dst_entry's, attach known xfrm's, calculate * all the metrics... Shortly, bundle a bundle. */// 创建安全路由static int__xfrm4_bundle_create(struct xfrm_policy *policy, struct xfrm_state **xfrm, int nx, struct flowi *fl, struct dst_entry **dst_p){ struct dst_entry *dst, *dst_prev; struct rtable *rt0 = (struct rtable*)(*dst_p); struct rtable *rt = rt0; u32 remote = fl->fl4_dst; u32 local = fl->fl4_src; struct flowi fl_tunnel = { .nl_u = { .ip4_u = { .saddr = local, .daddr = remote, .tos = fl->fl4_tos } } }; int i; int err; int header_len = 0; int trailer_len = 0; dst = dst_prev = NULL; dst_hold(&rt->u.dst);// 循环次数为策略中SA的数量, 每个SA对应一个安全路由, 一个安全路由对应对数据包的一个// 操作: 如压缩, ESP封装, AH封装等 for (i = 0; i < nx; i++) {// 分配安全路由, 安全路由的操作结构是xfrm4_dst_ops// 因为定义了很多不同类型的路由, 每种路由都有各自的操作结构, 这样在上层可用// 统一的接口进行路由处理 struct dst_entry *dst1 = dst_alloc(&xfrm4_dst_ops); struct xfrm_dst *xdst; int tunnel = 0; if (unlikely(dst1 == NULL)) { err = -ENOBUFS; dst_release(&rt->u.dst); goto error; } if (!dst)// 第一次循环 dst = dst1; else {// 将新分配的安全路由作为前一个路由的child dst_prev->child = dst1; dst1->flags |= DST_NOHASH; dst_clone(dst1); } xdst = (struct xfrm_dst *)dst1;// 安全路由中保留相应的普通路由 xdst->route = &rt->u.dst; xdst->genid = xfrm[i]->genid;// 新节点的next是老节点 dst1->next = dst_prev;// 现在prev节点位新节点 dst_prev = dst1; if (xfrm[i]->props.mode != XFRM_MODE_TRANSPORT) { remote = xfrm[i]->id.daddr.a4; local = xfrm[i]->props.saddr.a4; tunnel = 1; } header_len += xfrm[i]->props.header_len; trailer_len += xfrm[i]->props.trailer_len;// 如果是通道模式, 需要重新包裹外部IP头, 需要重新寻找外部IP头的路由 if (tunnel) { fl_tunnel.fl4_src = local; fl_tunnel.fl4_dst = remote; err = xfrm_dst_lookup((struct xfrm_dst **)&rt, &fl_tunnel, AF_INET); if (err) goto error; } else dst_hold(&rt->u.dst); }// 将最新节点的child指向最后的普通路由 dst_prev->child = &rt->u.dst;// 最老一个安全路由的path指向最后的普通路由 dst->path = &rt->u.dst;// 将最老安全路由点作为要返回的路由节点链表头 *dst_p = dst;// dst现在是最新节点 dst = dst_prev;// prev现在指向最老安全节点 dst_prev = *dst_p; i = 0;/* 为更好理解上面的操作, 用图来表示. 以上循环形成了下图水平方向的一个链表, 链表中的最左边的路由项节点dst为最老的安全路由项, 新分配的安全路由项通过child链接成链表, child通过next指向老节点, 最后一项是数据包封装完后的最后普通路由项.垂直方向的链表是在xfrm_lookup()中形成的, 是多个策略同时起作用的情况, 一般情况下就只有一个策略, 本文中可不考虑多策略的情况. rt0.u.dst rt.u.dst rt.u.dst ^ ^ ^ route | route | route | | child | child | bundle +-----+ -----> +-----+ -----> +-----+ child policy -------> | dst | <----- | dst | <----- ... | dst | -----> rt.u.dst +-----+ next +-----+ next +-----+ | |next | V child child +-----+ -----> +-----+ -----> +-----+ child | dst | <----- | dst | <----- ... | dst | -----> rt.u.dst +-----+ next +-----+ next +-----+ | |next | V ....*/// 对新生成的每个安全路由项填充结构参数 for (; dst_prev != &rt->u.dst; dst_prev = dst_prev->child) { struct xfrm_dst *x = (struct xfrm_dst*)dst_prev; x->u.rt.fl = *fl; dst_prev->xfrm = xfrm[i++]; dst_prev->dev = rt->u.dst.dev; if (rt->u.dst.dev) dev_hold(rt->u.dst.dev); dst_prev->obsolete = -1; dst_prev->flags |= DST_HOST; dst_prev->lastuse = jiffies; dst_prev->header_len = header_len; dst_prev->nfheader_len = 0; dst_prev->trailer_len = trailer_len; memcpy(&dst_prev->metrics, &x->route->metrics, sizeof(dst_prev->metrics)); /* Copy neighbout for reachability confirmation */ dst_prev->neighbour = neigh_clone(rt->u.dst.neighbour); dst_prev->input = rt->u.dst.input;// 注意安全路由的输出函数是xfrm4_output, 在以后分析路由过程时要用到 dst_prev->output = xfrm4_output; if (rt->peer) atomic_inc(&rt->peer->refcnt); x->u.rt.peer = rt->peer; /* Sheit... I remember I did this right. Apparently, * it was magically lost, so this code needs audit */ x->u.rt.rt_flags = rt0->rt_flags&(RTCF_BROADCAST|RTCF_MULTICAST|RTCF_LOCAL); x->u.rt.rt_type = rt->rt_type; x->u.rt.rt_src = rt0->rt_src; x->u.rt.rt_dst = rt0->rt_dst; x->u.rt.rt_gateway = rt->rt_gateway; x->u.rt.rt_spec_dst = rt0->rt_spec_dst; x->u.rt.idev = rt0->idev; in_dev_hold(rt0->idev); header_len -= x->u.dst.xfrm->props.header_len; trailer_len -= x->u.dst.xfrm->props.trailer_len; }// 初始化路由项的MTU值 xfrm_init_pmtu(dst); return 0;error: if (dst) dst_free(dst); return err;} 7.1. 小结IPV4的策略信息结构中的相关成员函数的被调用关系可如下简单表示:xfrm_lookup: find xfrm_dst for the skb, create dst_list -> xfrm_find_bundle -> afinfo->find_bundle() == __xfrm4_find_bundle -> xfrm_tmpl_resolve -> xfrm_tmpl_resolve_one -> xfrm_get_saddr -> afinfo->get_saddr == xfrm4_get_saddr -> xfrm4_dst_lookup -> xfrm_bundle_create -> afinfo->bundle_create() == __xfrm4_bundle_create -> xfrm_dst_lookup() -> afinfo->dst_lookup() == xfrm4_dst_lookupxfrm4_policy_check -> xfrm_policy_check -> __xfrm_policy_check -> xfrm_decode_session -> afinfo->decode_session() == _decode_session47.2 IPV4安全路由操作路由操作是针对每种类型的路由定义的一个操作结构, 对上层隐藏了不同路由处理内部的处理方法, 对于IPSEC的IPV4安全路由(xfrm_dst)的操作结构定义如下:/* net/ipv4/xfrm4_policy.c */static struct dst_ops xfrm4_dst_ops = { .family = AF_INET, .protocol = __constant_htons(ETH_P_IP), .gc = xfrm4_garbage_collect, .update_pmtu = xfrm4_update_pmtu, .destroy = xfrm4_dst_destroy, .ifdown = xfrm4_dst_ifdown, .gc_thresh = 1024, .entry_size = sizeof(struct xfrm_dst),};在xfrm_policy_register_afinfo()函数中, 还定义了安全路由操作结构的其他几个成员函数,因为这几个函数是和协议无关的, 所以在登记函数中定义了: dst_ops->kmem_cachep = xfrm_dst_cache; dst_ops->check = xfrm_dst_check; dst_ops->negative_advice = xfrm_negative_advice; dst_ops->link_failure = xfrm_link_failure; // 安全路由垃圾搜集, 就是调用安全策略信息结构的垃圾搜集函数static inline int xfrm4_garbage_collect(void){ xfrm4_policy_afinfo.garbage_collect(); return (atomic_read(&xfrm4_dst_ops.entries) > xfrm4_dst_ops.gc_thresh*2);}// 更新路由的MTUstatic void xfrm4_update_pmtu(struct dst_entry *dst, u32 mtu){ struct xfrm_dst *xdst = (struct xfrm_dst *)dst; struct dst_entry *path = xdst->route;// 调用的是安全路由的原始普通路由的MTU更新操作 path->ops->update_pmtu(path, mtu);}// 释放安全路由static void xfrm4_dst_destroy(struct dst_entry *dst){ struct xfrm_dst *xdst = (struct xfrm_dst *)dst;// 释放inet网卡引用 if (likely(xdst->u.rt.idev)) in_dev_put(xdst->u.rt.idev);// 释放对方IP的引用 if (likely(xdst->u.rt.peer)) inet_putpeer(xdst->u.rt.peer);// 释放安全路由 xfrm_dst_destroy(xdst);} static inline void xfrm_dst_destroy(struct xfrm_dst *xdst) { // 释放和安全路由相关的普通路由 dst_release(xdst->route); // 释放SA if (likely(xdst->u.dst.xfrm)) xfrm_state_put(xdst->u.dst.xfrm); }// 网卡down时的回调操作static void xfrm4_dst_ifdown(struct dst_entry *dst, struct net_device *dev, int unregister){ struct xfrm_dst *xdst; if (!unregister) return; xdst = (struct xfrm_dst *)dst;// 该安全路由对应的网卡是当前停掉的网卡 if (xdst->u.rt.idev->dev == dev) { struct in_device *loopback_idev = in_dev_get(&loopback_dev); BUG_ON(!loopback_idev); do {// 释放安全路由网卡 in_dev_put(xdst->u.rt.idev);// 安全路由网卡采用自身的回环网卡 xdst->u.rt.idev = loopback_idev; in_dev_hold(loopback_idev);// 子路由 xdst = (struct xfrm_dst *)xdst->u.dst.child; } while (xdst->u.dst.xfrm); __in_dev_put(loopback_idev); } xfrm_dst_ifdown(dst, dev);} 7.3 IPV4下的xfrm状态IPV4下的xfrm状态在net/ipv4/xfrm4_state.c文件中定义, 主要是定义IPV4的状态信息结构:static struct xfrm_state_afinfo xfrm4_state_afinfo = { .family = AF_INET, .init_flags = xfrm4_init_flags, .init_tempsel = __xfrm4_init_tempsel,};该结构中在IPV4下只定义了两个处理函数:// 初始化状态标志static int xfrm4_init_flags(struct xfrm_state *x){ if (ipv4_config.no_pmtu_disc) x->props.flags |= XFRM_STATE_NOPMTUDISC; return 0;}// 初始化模板选择子static void__xfrm4_init_tempsel(struct xfrm_state *x, struct flowi *fl, struct xfrm_tmpl *tmpl, xfrm_address_t *daddr, xfrm_address_t *saddr){// 填写选择子信息// 源地址 x->sel.daddr.a4 = fl->fl4_dst;// 目的地址 x->sel.saddr.a4 = fl->fl4_src;// 目的端口, 掩码 x->sel.dport = xfrm_flowi_dport(fl); x->sel.dport_mask = htons(0xffff);// 源端口掩码 x->sel.sport = xfrm_flowi_sport(fl); x->sel.sport_mask = htons(0xffff);// 源目的地址长度 x->sel.prefixlen_d = 32; x->sel.prefixlen_s = 32;// 协议 x->sel.proto = fl->proto;// 网卡位置 x->sel.ifindex = fl->oif;// 状态ID值 x->id = tmpl->id; if (x->id.daddr.a4 == 0) x->id.daddr.a4 = daddr->a4;// 支持结构中的参数// 源地址 x->props.saddr = tmpl->saddr; if (x->props.saddr.a4 == 0) x->props.saddr.a4 = saddr->a4;// 模式 x->props.mode = tmpl->mode;// 请求ID x->props.reqid = tmpl->reqid;// 协议族 x->props.family = AF_INET;}7.3小结IPV4的状态信息结构中的相关成员函数的被调用关系可如下简单表示:xfrm_init_state() -> afinfo->init_flags() == xfrm4_init_flagsxfrm_state_find() -> xfrm_init_tempsel() -> afinfo->init_tempsel() == __xfrm4_init_tempsel7.4 模式xfrm4支持3种模式: 通道, 传输和BEET模式, 分别在xfrm4_mode_tunnel.c, xfrm4_mode_transport.c和xfrm4_mode_beet.c中定义.每个模式都通过结构struct xfrm_mode定义:struct xfrm_mode { int (*input)(struct xfrm_state *x, struct sk_buff *skb); int (*output)(struct xfrm_state *x,struct sk_buff *skb); struct module *owner; unsigned int encap;};其中input函数在数据接收时调用, output函数数据发出时调用, encap参数表示是否封装.7.4.1 通道通道模式通过以下结构定义:/* net/ipv4/xfrm4_mode_transport.c */static struct xfrm_mode xfrm4_tunnel_mode = { .input = xfrm4_tunnel_input, .output = xfrm4_tunnel_output, .owner = THIS_MODULE, .encap = XFRM_MODE_TUNNEL,};// 通道模式下的接收函数, 解封装static int xfrm4_tunnel_input(struct xfrm_state *x, struct sk_buff *skb){ struct iphdr *iph = skb->nh.iph; int err = -EINVAL;// IP协议为IPPROTO_IPIP(4) if (iph->protocol != IPPROTO_IPIP) goto out;// 需要在skb头留出IP头的长度(20字节) if (!pskb_may_pull(skb, sizeof(struct iphdr))) goto out;// 如果是clone包,重新拷贝一个 if (skb_cloned(skb) && (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC))) goto out;// 复制dscp字段 if (x->props.flags & XFRM_STATE_DECAP_DSCP) ipv4_copy_dscp(iph, skb->h.ipiph);// 非XFRM_STATE_NOECN时进行ECN解封装 if (!(x->props.flags & XFRM_STATE_NOECN)) ipip_ecn_decapsulate(skb);// 将硬件地址挪到数据包缓冲区前 skb->mac.raw = memmove(skb->data - skb->mac_len, skb->mac.raw, skb->mac_len);// 网络部分数据头 skb->nh.raw = skb->data; err = 0;out: return err;}// 通道模式下的数据发出函数, 进行封装static int xfrm4_tunnel_output(struct xfrm_state *x, struct sk_buff *skb){ struct dst_entry *dst = skb->dst; struct iphdr *iph, *top_iph; int flags; iph = skb->nh.iph; skb->h.ipiph = iph;// 数据头部增加外部IP头的长度 skb->nh.raw = skb_push(skb, x->props.header_len); top_iph = skb->nh.iph;// 填写外部IP头参数 top_iph->ihl = 5; top_iph->version = 4; /* DS disclosed */// 重新计算TOS top_iph->tos = INET_ECN_encapsulate(iph->tos, iph->tos); flags = x->props.flags; if (flags & XFRM_STATE_NOECN) IP_ECN_clear(top_iph);// 处理分片包情况 top_iph->frag_off = (flags & XFRM_STATE_NOPMTUDISC) ? 0 : (iph->frag_off & htons(IP_DF)); if (!top_iph->frag_off) __ip_select_ident(top_iph, dst->child, 0);// TTL top_iph->ttl = dst_metric(dst->child, RTAX_HOPLIMIT);// 外部源地址用proposal中的源地址 top_iph->saddr = x->props.saddr.a4;// 外部目的地址是SA中的目的地址 top_iph->daddr = x->id.daddr.a4;// 外部IP头内的协议号为IPIP(4) top_iph->protocol = IPPROTO_IPIP;// IP选项部分设置为0 memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options)); return 0;}7.4.2 传输传输模式下不添加新的IP头, 其实几乎什么都不用做, 老点的2.6内核中就没有专门为传输模式定义.传输模式结构定义为:/* net/ipv4/xfrm4_mode_transport.c */static struct xfrm_mode xfrm4_transport_mode = { .input = xfrm4_transport_input, .output = xfrm4_transport_output, .owner = THIS_MODULE, .encap = XFRM_MODE_TRANSPORT,};/* Remove encapsulation header. * * The IP header will be moved over the top of the encapsulation header. * * On entry, skb->h shall point to where the IP header should be and skb->nh * shall be set to where the IP header currently is. skb->data shall point * to the start of the payload. */// 传输模式下的数据输入函数static int xfrm4_transport_input(struct xfrm_state *x, struct sk_buff *skb){// data指向负载头, h指向IP头, 但很多情况下两者相同 int ihl = skb->data - skb->h.raw;// 如果h和nh不同, 将nh所指向IP头部分移动到h处 if (skb->h.raw != skb->nh.raw) skb->nh.raw = memmove(skb->h.raw, skb->nh.raw, ihl);// 增加数据包长度, 重新对数据包长度赋值 skb->nh.iph->tot_len = htons(skb->len + ihl); skb->h.raw = skb->data; return 0;} /* Add encapsulation header. * * The IP header will be moved forward to make space for the encapsulation * header. * * On exit, skb->h will be set to the start of the payload to be processed * by x->type->output and skb->nh will be set to the top IP header. */// 传输模式下的数据发出函数static int xfrm4_transport_output(struct xfrm_state *x, struct sk_buff *skb){ struct iphdr *iph; int ihl;// nh和赋值给h iph = skb->nh.iph; skb->h.ipiph = iph;// ip头长度 ihl = iph->ihl * 4;// 重新计算h位置 skb->h.raw += ihl;// 重新计算新的nh位置,增加proposal中的头长度, 拷贝原来的IP头数据 skb->nh.raw = memmove(skb_push(skb, x->props.header_len), iph, ihl); return 0;}7.4.3 BEET封装成BEETPH(94)包, 非标准IPSEC, 略.7.4.4 小结和xfrm_mode相关的xfrm函数有:登记: int xfrm_register_mode(struct xfrm_mode *mode, int family);撤销: int xfrm_unregister_mode(struct xfrm_mode *mode, int family)获取: struct xfrm_mode *xfrm_get_mode(unsigned int encap, int family)释放: void xfrm_put_mode(struct xfrm_mode *mode)xfrm_mode的输入输出函数调用:xfrm4_rcv_encap() -> x->mode->inputxfrm4_output_one() -> x->mode->output 7.5 数据接收IPV4的IPSEC数据接收处理在net/ipv4/xfrm4_input.c中定义, 作为AH和ESP协议数据接收处理函数./* net/ipv4/xfrm4_input.c */int xfrm4_rcv(struct sk_buff *skb){ return xfrm4_rcv_encap(skb, 0);}实际就是xfrm4_rcv_encap，封装类型参数设置为0,在NAT-T时IPSEC数据被封装在UDP包中时, 该参数才非0.int xfrm4_rcv_encap(struct sk_buff *skb, __u16 encap_type){ int err; __be32 spi, seq; struct xfrm_state *xfrm_vec[XFRM_MAX_DEPTH]; struct xfrm_state *x; int xfrm_nr = 0; int decaps = 0;// 获取skb中的spi和序列号信息 if ((err = xfrm4_parse_spi(skb, skb->nh.iph->protocol, &spi, &seq)) != 0) goto drop;// 进入循环进行解包操作 do { struct iphdr *iph = skb->nh.iph;// 循环解包次数太深的话放弃 if (xfrm_nr == XFRM_MAX_DEPTH) goto drop;// 根据地址, SPI和协议查找SA x = xfrm_state_lookup((xfrm_address_t *)&iph->daddr, spi, iph->protocol, AF_INET); if (x == NULL) goto drop;// 以下根据SA定义的操作对数据解码 spin_lock(&x->lock); if (unlikely(x->km.state != XFRM_STATE_VALID)) goto drop_unlock;// 检查由SA指定的封装类型是否和函数指定的封装类型相同 if ((x->encap ? x->encap->encap_type : 0) != encap_type) goto drop_unlock;// SA重放窗口检查 if (x->props.replay_window && xfrm_replay_check(x, seq)) goto drop_unlock;// SA生存期检查 if (xfrm_state_check_expire(x)) goto drop_unlock;// type可为esp,ah,ipcomp, ipip等, 对输入数据解密 if (x->type->input(x, skb)) 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);// 保存数据解封用的SA, 增加SA数量计数 xfrm_vec[xfrm_nr++] = x;// mode可为通道,传输等模式, 对输入数据解封装 if (x->mode->input(x, skb)) goto drop;// 如果是IPSEC通道模式，将decaps参数置1，否则表示是传输模式 if (x->props.mode == XFRM_MODE_TUNNEL) { decaps = 1; break; }// 看内层协议是否还要继续解包, 不需要解时返回1, 需要解时返回0, 错误返回负数// 协议类型可以多层封装的,比如用AH封装ESP, 就得先解完AH再解ESP if ((err = xfrm_parse_spi(skb, skb->nh.iph->protocol, &spi, &seq)) < 0) goto drop; } while (!err); /* Allocate new secpath or COW existing one. */// 为skb包建立新的安全路径(struct sec_path) if (!skb->sp || atomic_read(&skb->sp->refcnt) != 1) { struct sec_path *sp; sp = secpath_dup(skb->sp); if (!sp) goto drop; if (skb->sp) secpath_put(skb->sp); skb->sp = sp; } if (xfrm_nr + skb->sp->len > XFRM_MAX_DEPTH) goto drop;// 将刚才循环解包用到的SA拷贝到安全路径// 因此检查一个数据包是否是普通明文包还是解密后的明文包就看skb->sp参数是否为空 memcpy(skb->sp->xvec + skb->sp->len, xfrm_vec, xfrm_nr * sizeof(xfrm_vec[0])); skb->sp->len += xfrm_nr; nf_reset(skb); if (decaps) {// 通道模式 if (!(skb->dev->flags&IFF_LOOPBACK)) { dst_release(skb->dst); skb->dst = NULL; }// 重新进入网卡接收函数 netif_rx(skb); return 0; } else {// 传输模式#ifdef CONFIG_NETFILTER// 如果定义NETFILTER, 进入PRE_ROUTING链处理,然后进入路由选择处理// 其实现在已经处于INPUT点, 但解码后需要将该包作为一个新包看待// 可能需要进行目的NAT操作, 这时候可能目的地址就会改变不是到自身// 的了, 因此需要将其相当于是放回PRE_PROUTING点去操作, 重新找路由// 这也说明可以制定针对解码后明文包的NAT规则,在还是加密包的时候不匹配// 但解码后能匹配上 __skb_push(skb, skb->data - skb->nh.raw); skb->nh.iph->tot_len = htons(skb->len); ip_send_check(skb->nh.iph); NF_HOOK(PF_INET, NF_IP_PRE_ROUTING, skb, skb->dev, NULL, xfrm4_rcv_encap_finish); return 0;#else// 内核不支持NETFILTER, 该包肯定就是到自身的了// 返回IP协议的负值, 表示重新进行IP层协议的处理// 用解码后的内层协议来处理数据 return -skb->nh.iph->protocol;#endif }drop_unlock: spin_unlock(&x->lock); xfrm_state_put(x);drop: while (--xfrm_nr >= 0) xfrm_state_put(xfrm_vec[xfrm_nr]); kfree_skb(skb); return 0;}// 解析AH,ESP数据包中的SPI和序号static int xfrm4_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq){ switch (nexthdr) {// 如果只是普通的IPIP包, SPI为源地址, 序号位0 case IPPROTO_IPIP: *spi = skb->nh.iph->saddr; *seq = 0; return 0; }// 否则解析AH/ESP/COMP协议头中的SPI和序号 return xfrm_parse_spi(skb, nexthdr, spi, seq);}// 接收封装完成处理函数static inline int xfrm4_rcv_encap_finish(struct sk_buff *skb){ struct iphdr *iph = skb->nh.iph;// 如果没有路由, 重新查找路由 if (skb->dst == NULL) { if (ip_route_input(skb, iph->daddr, iph->saddr, iph->tos, skb->dev)) goto drop; }// 调用相关的路由输入函数 return dst_input(skb);drop: kfree_skb(skb); return NET_RX_DROP;} 调用关系:ip_rcv -> (AH/ESP) net_protocol->handler == xfrm4_rcv -> xfrm4_rcv_encap -> xfrm4_parse_spi -> xfrm_parse_spi -> xfrm4_rcv_encap_finish 7.6 数据发送IPV4的IPSEC数据发送处理在net/ipv4/xfrm4_output.c中定义,作为安全路由的输出函数:int xfrm4_output(struct sk_buff *skb){// 就是一个条件HOOK, 当skb包不带IPSKB_REROUTED标志时进入POSTROUTING点的NAT操作// 这是数据在xfrm策略中多个bundle时会多次调用, 也就是数据在封装完成前可以进行// 源NAT操作// HOOK出口函数为xfrm4_output_finish return NF_HOOK_COND(PF_INET, NF_IP_POST_ROUTING, skb, NULL, skb->dst->dev, xfrm4_output_finish, !(IPCB(skb)->flags & IPSKB_REROUTED));}// 发送结束处理static int xfrm4_output_finish(struct sk_buff *skb){ struct sk_buff *segs;#ifdef CONFIG_NETFILTER// 如果内核定义了NETFILTER, 当到达最后一个路由(普通路由)时, 设置IPSKB_REROUTED// 标志, 进行普通路由发出函数(ip_output), 设置该标志后不进行源NAT操作 if (!skb->dst->xfrm) { IPCB(skb)->flags |= IPSKB_REROUTED; return dst_output(skb); }#endif// 如果skb包不是是gso, 转xfrm4_output_finish2// gso是什么意思现在还不知道, 以后再仔细分析 if (!skb_is_gso(skb)) return xfrm4_output_finish2(skb);// 处理gso数据包, 最终也是使用xfrm4_output_finish2处理数据包 skb->protocol = htons(ETH_P_IP); segs = skb_gso_segment(skb, 0); kfree_skb(skb); if (unlikely(IS_ERR(segs))) return PTR_ERR(segs); do { struct sk_buff *nskb = segs->next; int err; segs->next = NULL; err = xfrm4_output_finish2(segs); if (unlikely(err)) { while ((segs = nskb)) { nskb = segs->next; segs->next = NULL; kfree_skb(segs); } return err; } segs = nskb; } while (segs); return 0;} // 第2级发送结束处理static int xfrm4_output_finish2(struct sk_buff *skb){ int err;// 根据安全路由包装要发送数据 while (likely((err = xfrm4_output_one(skb)) == 0)) {// 处理成功// 释放skb中的netfilter信息 nf_reset(skb);// 重新将该包作为初始发送包, 进入OUTPUT点处理, 注意这是个函数而不是宏// 如果内核没定义NETFILTER, 该函数只是个空函数// 返回1表示NF_ACCEPT err = nf_hook(PF_INET, NF_IP_LOCAL_OUT, &skb, NULL, skb->dst->dev, dst_output); if (unlikely(err != 1)) break;// 如果已经没有SA, 就只是个普通包了, 路由发送(ip_output)返回, 退出循环 if (!skb->dst->xfrm) return dst_output(skb);// 如果还有SA, 目前还只是中间状态, 还可以进行SNAT操作, 进入POSTROUTING点处理 err = nf_hook(PF_INET, NF_IP_POST_ROUTING, &skb, NULL, skb->dst->dev, xfrm4_output_finish2); if (unlikely(err != 1)) break; } return err;}// 按安全路由链表的安全路由处理数据, 该链表反映了多个SA对数据包进行处理// 链表是在__xfrm4_bundle_create函数中建立的static int xfrm4_output_one(struct sk_buff *skb){// 安全路由 struct dst_entry *dst = skb->dst;// 相关SA struct xfrm_state *x = dst->xfrm; int err;// skb包校验和 检查 if (skb->ip_summed == CHECKSUM_PARTIAL) { err = skb_checksum_help(skb); if (err) goto error_nolock; }// 如果是通道模式, 检查skb数据长度, 并进行相关处理, 通道模式下封装后的数据包长度可能// 会超过1500字节的 if (x->props.mode == XFRM_MODE_TUNNEL) { err = xfrm4_tunnel_check_size(skb); if (err) goto error_nolock; } do { spin_lock_bh(&x->lock);// SA合法性检查 err = xfrm_state_check(x, skb); if (err) goto error;// 调用模式输出函数, 如通道封装, 此时外部IP头协议为IPIP err = x->mode->output(x, skb); if (err) goto error;// 调用协议输出, 如对应ESP协议来说是esp4_output, 此时外部IP头协议会改为ESP err = x->type->output(x, skb); if (err) goto error;// 更新SA中的当前生命期结构中的包和字节计数 x->curlft.bytes += skb->len; x->curlft.packets++; spin_unlock_bh(&x->lock);// 转移到下一个子路由 if (!(skb->dst = dst_pop(dst))) { err = -EHOSTUNREACH; goto error_nolock; }// dst和x参数更新为子路由中的安全路由和SA dst = skb->dst; x = dst->xfrm;// 循环条件是SA非空, 而且SA提议模式不是通道模式 } while (x && (x->props.mode != XFRM_MODE_TUNNEL));// skb中设置IPSKB_XFRM_TRANSFORMED标志// 有该标志的数据包将NAT操作后将不进行一些特殊检查 IPCB(skb)->flags |= IPSKB_XFRM_TRANSFORMED; err = 0;out_exit: return err;error: spin_unlock_bh(&x->lock);error_nolock: kfree_skb(skb); goto out_exit;}IPSEC输出函数调用关系:dst_output -> xfrm_dst->output == xfrm4_output -> NF_HOOK(POSTROUTING) -> xfrm4_output_finish -> xfrm4_output_finish2 -> xfrm4_output_one7.7 NAT-T支持在支持NAT穿越的IPSEC处理中，是通过UDP数据包来封装IPSEC数据(ESP数据包)，因此在对UDP处理时需要进行特殊处理。由于IKE同样是用UDP处理的, 区分是IKE包还是封装的ESP包就看数据头部头4字节表示的SPI值, SPI为0表示是IKE包, 由IKE用户空间程序接收进行处理, SPI非0表示是UDP封装的ESP包, 需进行ESP解封。7.7.1 接收数据被UDP封装的IPSEC包在接收时会先按普通UDP包接收，在UDP处理中再解开该包后进行IPSEC处理/* net/ipv4/udp.c */// 正常接收的UDP包都将进入该函数static int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb){ struct udp_sock *up = udp_sk(sk); int rc; /* * Charge it to the socket, dropping if the queue is full. */// 检查针对该sock，skb包的输入方法上的是否有安全策略 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) { kfree_skb(skb); return -1; } nf_reset(skb);// 检查该SOCK是否是IPSEC封装的，该参数通过setsockopt系统调用的UDP_ENCAP选项设置// 一般是IKE程序在打开UDP4500端口时设置的 if (up->encap_type) { /* * This is an encapsulation socket, so let's see if this is * an encapsulated packet. * If it's a keepalive packet, then just eat it. * If it's an encapsulateed packet, then pass it to the * IPsec xfrm input and return the response * appropriately. Otherwise, just fall through and * pass this up the UDP socket. */ int ret;// 进入UDP封装接收, 判断是否是ESP包// 返回值小于0表示是IPSEC包, 大于0表示是普通UDP包, 等于0表示是错误包 ret = udp_encap_rcv(sk, skb); if (ret == 0) { /* Eat the packet .. */ kfree_skb(skb); return 0; } if (ret < 0) {// 进行IPSEC接收处理 /* process the ESP packet */ ret = xfrm4_rcv_encap(skb, up->encap_type); UDP_INC_STATS_BH(UDP_MIB_INDATAGRAMS); return -ret; } /* FALLTHROUGH -- it's a UDP Packet */ }// 以下按普通UDP包接收处理, 分析略 if (sk->sk_filter && skb->ip_summed != CHECKSUM_UNNECESSARY) { if (__udp_checksum_complete(skb)) { UDP_INC_STATS_BH(UDP_MIB_INERRORS); kfree_skb(skb); return -1; } skb->ip_summed = CHECKSUM_UNNECESSARY; } if ((rc = sock_queue_rcv_skb(sk,skb)) < 0) { /* Note that an ENOMEM error is charged twice */ if (rc == -ENOMEM) UDP_INC_STATS_BH(UDP_MIB_RCVBUFERRORS); UDP_INC_STATS_BH(UDP_MIB_INERRORS); kfree_skb(skb); return -1; } UDP_INC_STATS_BH(UDP_MIB_INDATAGRAMS); return 0;}/* return: * 1 if the the UDP system should process it * 0 if we should drop this packet * -1 if it should get processed by xfrm4_rcv_encap */static int udp_encap_rcv(struct sock * sk, struct sk_buff *skb){#ifndef CONFIG_XFRM// 在内核不支持IPSEC情况下直接返回1 return 1;#else struct udp_sock *up = udp_sk(sk); struct udphdr *uh; struct iphdr *iph; int iphlen, len; __u8 *udpdata; __be32 *udpdata32;// sock的封装标志值 __u16 encap_type = up->encap_type; /* if we're overly short, let UDP handle it */// UDP数据包中数据部分的长度 len = skb->len - sizeof(struct udphdr); if (len <= 0) return 1; /* if this is not encapsulated socket, then just return now */// 没定义封装处理, 返回1, 普通处理 if (!encap_type) return 1; /* If this is a paged skb, make sure we pull up * whatever data we need to look at. */ if (!pskb_may_pull(skb, sizeof(struct udphdr) + min(len, 8))) return 1; /* Now we can get the pointers */ uh = skb->h.uh; udpdata = (__u8 *)uh + sizeof(struct udphdr); udpdata32 = (__be32 *)udpdata; switch (encap_type) { default:// 在UDP中封装ESP case UDP_ENCAP_ESPINUDP: /* Check if this is a keepalive packet. If so, eat it. */ if (len == 1 && udpdata[0] == 0xff) {// 只是普通UDP的IPSEC通道保活包, 直接丢弃 return 0; } else if (len > sizeof(struct ip_esp_hdr) && udpdata32[0] != 0 ) {// 头4字节非零, ESP包，需要下一步解析 /* ESP Packet without Non-ESP header */ len = sizeof(struct udphdr); } else// 这是IKE包，按普通UDP接收处理 /* Must be an IKE packet.. pass it through */ return 1; break; case UDP_ENCAP_ESPINUDP_NON_IKE: /* Check if this is a keepalive packet. If so, eat it. */ if (len == 1 && udpdata[0] == 0xff) {// IPSEC通道保活包, 丢弃 return 0; } else if (len > 2 * sizeof(u32) + sizeof(struct ip_esp_hdr) && udpdata32[0] == 0 && udpdata32[1] == 0) {// 头4字节非零, ESP包，需要下一步解析 /* ESP Packet with Non-IKE marker */ len = sizeof(struct udphdr) + 2 * sizeof(u32); } else// 这是IKE数据包,由 /* Must be an IKE packet.. pass it through */ return 1; break; } /* At this point we are sure that this is an ESPinUDP packet, * so we need to remove 'len' bytes from the packet (the UDP * header and optional ESP marker bytes) and then modify the * protocol to ESP, and then call into the transform receiver. */// 如果是clone包需要复制成独立包 if (skb_cloned(skb) && pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) return 0;// 检查数据长度 /* Now we can update and verify the packet length... */ iph = skb->nh.iph; iphlen = iph->ihl << 2; iph->tot_len = htons(ntohs(iph->tot_len) - len); if (skb->len < iphlen + len) { /* packet is too small!?! */ return 0; } /* pull the data buffer up to the ESP header and set the * transport header to point to ESP. Keep UDP on the stack * for later. */// 修改IP上层头位置 skb->h.raw = skb_pull(skb, len);// 更改IP头协议类型为ESP包, 返回-1 /* modify the protocol (it's ESP!) */ iph->protocol = IPPROTO_ESP; /* and let the caller know to send this into the ESP processor... */ return -1;#endif}函数调用关系：udp_rcv ->udp_queue_rcv_skb -> udp_encap_rcv -> xfrm4_policy_check -> xfrm_policy_check -> __xfrm_policy_check 7.7.2 ESP包的UDP封装对于ESP包的UDP封装处理, 在下一节ESP协议数据包的输出处理中介绍....... 待续 ......