Linux内核中的IPSEC实现(5)

 

本文档的Copyleft归yfydz所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，严禁用于任何商业用途。
msn: [email protected]
来源： 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_lookup

xfrm4_policy_check
  -> xfrm_policy_check
    -> __xfrm_policy_check
      -> xfrm_decode_session
        -> afinfo->decode_session() == _decode_session4

7.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);
}

// 更新路由的MTU
static 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_flags

xfrm_state_find()
  -> xfrm_init_tempsel()
    -> afinfo->init_tempsel() == __xfrm4_init_tempsel

7.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->input

xfrm4_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_one

7.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协议数据包的输出处理中介绍.

...... 待续 ......