绑定完请刷新页面
取消
刷新
登录 | 注册

分享好友

×
取消 复制
Netfilter 地址转换的实现（2）
2020-05-26 15:26:34

ip_nat_out

  1. static unsigned int
  2. ip_nat_out(unsigned int hooknum,
  3.            struct sk_buff **pskb,
  4.            const struct net_device *in,
  5.            const struct net_device *out,
  6.            int (*okfn)(struct sk_buff *))
  7. {
  8.         /* root is playing with raw sockets. */
  9.         if ((*pskb)->len < sizeof(struct iphdr)
  10.             || (*pskb)->nh.iph->ihl * 4 < sizeof(struct iphdr))
  11.                 return NF_ACCEPT;

  13.         if ((*pskb)->nh.iph->frag_off & htons(IP_MF|IP_OFFSET)) {
  14.                 *pskb = ip_ct_gather_frags(*pskb, IP_DEFRAG_NAT_OUT);

  16.                 if (!*pskb)
  17.                         return NF_STOLEN;
  18.         }

  20.         return ip_nat_fn(hooknum, pskb, in, out, okfn);
  21. }
复制代码



在进行了IP包的长度较验和分片检查之后，函数进入ip_nat_fn，它是整个地址转换的核心函数之一：

  1. static unsigned int
  2. ip_nat_fn(unsigned int hooknum,
  3.           struct sk_buff **pskb,
  4.           const struct net_device *in,
  5.           const struct net_device *out,
  6.           int (*okfn)(struct sk_buff *))
  7. {
  8.         struct ip_conntrack *ct;
  9.         enum ip_conntrack_info ctinfo;
  10.         struct ip_nat_info *info;
  11.         /* maniptype通过调用HOOK2MAINIP宏判断Hook点，指明转换类型是源地址转换还是目的地址转换，为0(IP_NAT_MANIP_SRC)表示源地址转换，为1(IP_NAT_MANIP_DST)表示目的地址转换 */
  12.         enum ip_nat_manip_type maniptype = HOOK2MANIP(hooknum);

  14.         /* 前面函数中已经处理过分片的情况，这里应该不会再出现分片包了. */
  15.         IP_NF_ASSERT(!((*pskb)->nh.iph->frag_off
  16.                        & htons(IP_MF|IP_OFFSET)));

  18. /*因为地址转换会修改数据包，所以这里先初始化将其设置为“未修改”标志，后面进行数据包修改时再来重置这个标志*/
  19.         (*pskb)->nfcache |= NFC_UNKNOWN;

  21.         /* If we had a hardware checksum before, it's now invalid */
  22.         if ((*pskb)->ip_summed == CHECKSUM_HW)
  23.                 if (skb_checksum_help(*pskb, (out == NULL)))
  24.                         return NF_DROP;
  25.         
  26. /*取得数据包的连接状态*/
  27.         ct = ip_conntrack_get(*pskb, &ctinfo);
  28.         /* 如果找不到对应连接，则应该直接放行它，而不再对其进行转换处理，特别地，ICMP重定向报文将会被丢弃*/
  29.         if (!ct) {
  30.                 /* Exception: ICMP redirect to new connection (not in
  31.                    hash table yet).  We must not let this through, in
  32.                    case we're doing NAT to the same network. */
  33.                 if ((*pskb)->nh.iph->protocol == IPPROTO_ICMP) {
  34.                         struct icmphdr _hdr, *hp;

  36.                         hp = skb_header_pointer(*pskb,
  37.                                                 (*pskb)->nh.iph->ihl*4,
  38.                                                 sizeof(_hdr), &_hdr);
  39.                         if (hp != NULL &&
  40.                             hp->type == ICMP_REDIRECT)
  41.                                 return NF_DROP;
  42.                 }
  43.                 return NF_ACCEPT;
  44.         }

  46. /*判断连接状态，调用相应的处理函数*/
  47.         switch (ctinfo) {
  48.         case IP_CT_RELATED:
  49.         case IP_CT_RELATED+IP_CT_IS_REPLY:
  50.                 if ((*pskb)->nh.iph->protocol == IPPROTO_ICMP) {
  51.                         if (!icmp_reply_translation(pskb, ct, maniptype,
  52.                                                     CTINFO2DIR(ctinfo)))
  53.                                 return NF_DROP;
  54.                         else
  55.                                 return NF_ACCEPT;
  56.                 }
  57.                 /* Fall thru... (Only ICMPs can be IP_CT_IS_REPLY) */
  58.         case IP_CT_NEW:
  59.                 info = &ct->nat.info;

  61.                 /* 观察这个新建封包是否已经被NAT模块修改过了，如果没有，进一步调用ip_nat_rule_find函数*/
  62.                 if (!ip_nat_initialized(ct, maniptype)) {
  63.                         unsigned int ret;

  65.                         /* LOCAL_IN hook doesn't have a chain!  */
  66.                         if (hooknum == NF_IP_LOCAL_IN)
  67.                                 ret = alloc_null_binding(ct, info, hooknum);
  68.                         else
  69.                                 ret = ip_nat_rule_find(pskb, hooknum,
  70.                                                        in, out, ct,
  71.                                                        info);

  73.                         if (ret != NF_ACCEPT) {
  74.                                 return ret;
  75.                         }
  76.                 } else
  77.                         DEBUGP("Already setup manip %%%%s for ct %%%%p\n",
  78.                                maniptype == IP_NAT_MANIP_SRC ? "SRC" : "DST",
  79.                                ct);
  80.                 break;

  82.         default:
  83.                 /* ESTABLISHED */
  84.                 IP_NF_ASSERT(ctinfo == IP_CT_ESTABLISHED
  85.                              || ctinfo == (IP_CT_ESTABLISHED+IP_CT_IS_REPLY));
  86.                 info = &ct->nat.info;
  87.         }

  89.         IP_NF_ASSERT(info);
  90.         return nat_packet(ct, ctinfo, hooknum, pskb);
  91. }
复制代码



我们假设这是一个刚刚进入Linux的数据包，它是一个新建状态的连接，首先调用ip_nat_initialized函数判断它是否已经被地址转换例程修改过，即是否已经设置了相应转换类型的标志位：
static inline int ip_nat_initialized(struct ip_conntrack *conntrack,
                                     enum ip_nat_manip_type manip)
{
        /*如果是源地址转换，即测试源地址转换位，否则，测试目的地址转换位*/
if (manip == IP_NAT_MANIP_SRC)
                return test_bit(IPS_SRC_NAT_DONE_BIT, &conntrack->status);
        return test_bit(IPS_DST_NAT_DONE_BIT, &conntrack->status);
}

对于一个中转没有被修改过的包，ip_nat_rule_find函数将会被调用，以作进一步处理。

ip_nat_rule_find

ip_nat_rule_find 函数，从名称上我们就可以看出，它的含义是“NAT 规则查找”，它是一个规则匹配函数，其重要的工作，就是调用ipt_do_table函数进行规则的检测，这个函数我们在包过滤一章已经对它进行了详细的分析，当ipt_do_table函数发现数据包匹配一条源地址转换的规则时，则会调用SNAT模块的target函数。

  1. int ip_nat_rule_find(struct sk_buff **pskb,
  2.                      unsigned int hooknum,
  3.                      const struct net_device *in,
  4.                      const struct net_device *out,
  5.                      struct ip_conntrack *ct,
  6.                      struct ip_nat_info *info)
  7. {
  8.         int ret;

  10.         /*NAT规则匹配*/
  11.         ret = ipt_do_table(pskb, hooknum, in, out, &nat_table, NULL);

  13.         if (ret == NF_ACCEPT) {
  14.                 if (!ip_nat_initialized(ct, HOOK2MANIP(hooknum)))
  15.                         /* NUL mapping */
  16.                         ret = alloc_null_binding(ct, info, hooknum);
  17.         }
  18.         return ret;
  19. }
复制代码



前面我们已经讨论过，SNAT注册的的target函数是ipt_snat_target，这个函数，首先取得规则中“转换后地址”的信息，然后将工作交给ip_nat_setup_info进一步处理：

  1. /* Source NAT */
  2. static unsigned int ipt_snat_target(struct sk_buff **pskb,
  3.                                     const struct net_device *in,
  4.                                     const struct net_device *out,
  5.                                     unsigned int hooknum,
  6.                                     const void *targinfo,
  7.                                     void *userinfo)
  8. {
  9.         struct ip_conntrack *ct;
  10.         enum ip_conntrack_info ctinfo;
  11.         /*取得规则中的target部份*/
  12.         const struct ip_nat_multi_range_compat *mr = targinfo;

  14.         IP_NF_ASSERT(hooknum == NF_IP_POST_ROUTING);
  15.         
  16. /*取得数据包的连接*/
  17.         ct = ip_conntrack_get(*pskb, &ctinfo);

  19.         /* Connection must be valid and new. */
  20.         IP_NF_ASSERT(ct && (ctinfo == IP_CT_NEW || ctinfo == IP_CT_RELATED
  21.                             || ctinfo == IP_CT_RELATED + IP_CT_IS_REPLY));
  22.         IP_NF_ASSERT(out);

  24.         return ip_nat_setup_info(ct, &mr->range[0], hooknum);
  25. }
复制代码



ip_nat_setup_info

ip_nat_setup_info 函数是地址转换中又一个非常重要的函数：

  1. unsigned int
  2. ip_nat_setup_info(struct ip_conntrack *conntrack,                /*数据包对应的连接*/
  3.                   const struct ip_nat_range range,                                /*转换后的地址池*/
  4.                   unsigned int hooknum)                                        /*Hook点*/
  5. {
  6.         struct ip_conntrack_tuple curr_tuple, new_tuple;
  7.         struct ip_nat_info *info = &conntrack->nat.info;
  8.         int have_to_hash = !(conntrack->status & IPS_NAT_DONE_MASK);
  9.         enum ip_nat_manip_type maniptype = HOOK2MANIP(hooknum);

  11.         IP_NF_ASSERT(hooknum == NF_IP_PRE_ROUTING
  12.                      || hooknum == NF_IP_POST_ROUTING
  13.                      || hooknum == NF_IP_LOCAL_IN
  14.                      || hooknum == NF_IP_LOCAL_OUT);
  15.         BUG_ON(ip_nat_initialized(conntrack, maniptype));

  17.         /* What we've got will look like inverse of reply. Normally
  18.            this is what is in the conntrack, except for prior
  19.            manipulations (future optimization: if num_manips == 0,
  20.            orig_tp =
  21.            conntrack->tuplehash[IP_CT_DIR_ORIGINAL].tuple) */
  22.         invert_tuplepr(&curr_tuple,
  23.                        &conntrack->tuplehash[IP_CT_DIR_REPLY].tuple);

  25.         get_unique_tuple(&new_tuple, &curr_tuple, range, conntrack, maniptype);

  27.         if (!ip_ct_tuple_equal(&new_tuple, &curr_tuple)) {
  28.                 struct ip_conntrack_tuple reply;

  30.                 /* Alter conntrack table so will recognize replies. */
  31.                 invert_tuplepr(&reply, &new_tuple);
  32.                 ip_conntrack_alter_reply(conntrack, &reply);

  34.                 /* Non-atomic: we own this at the moment. */
  35.                 if (maniptype == IP_NAT_MANIP_SRC)
  36.                         conntrack->status |= IPS_SRC_NAT;
  37.                 else
  38.                         conntrack->status |= IPS_DST_NAT;
  39.         }

  41.         /* Place in source hash if this is the first time. */
  42.         if (have_to_hash) {
  43.                 unsigned int srchash
  44.                         = hash_by_src(&conntrack->tuplehash[IP_CT_DIR_ORIGINAL]
  45.                                       .tuple);
  46.                 WRITE_LOCK(&ip_nat_lock);
  47.                 list_add(&info->bysource, &bysource[srchash]);
  48.                 WRITE_UNLOCK(&ip_nat_lock);
  49.         }

  51.         /* It's done. */
  52.         if (maniptype == IP_NAT_MANIP_DST)
  53.                 set_bit(IPS_DST_NAT_DONE_BIT, &conntrack->status);
  54.         else
  55.                 set_bit(IPS_SRC_NAT_DONE_BIT, &conntrack->status);

  57.         return NF_ACCEPT;
  58. }
复制代码



这个函数转换来转换去，让人头大，慢慢抽丝拨茧先。首先调用invert_tuplepr取得一个当前数据包对应的replay tuple，然后对其取反得到一个curr_tuple，接着调用get_unique_tuple函数：

  1. static void
  2. get_unique_tuple(struct ip_conntrack_tuple *tuple,
  3.                  const struct ip_conntrack_tuple *orig_tuple,
  4.                  const struct ip_nat_range *range,
  5.                  struct ip_conntrack *conntrack,
  6.                  enum ip_nat_manip_type maniptype)
  7. {
  8.         struct ip_nat_protocol *proto
  9.                 = ip_nat_find_proto(orig_tuple->dst.protonum);

  11.         /* 1) If this srcip/proto/src-proto-part is currently mapped,
  12.            and that same mapping gives a unique tuple within the given
  13.            range, use that.

  15.            This is only required for source (ie. NAT/masq) mappings.
  16.            So far, we don't do local source mappings, so multiple
  17.            manips not an issue.  */
  18.         if (maniptype == IP_NAT_MANIP_SRC) {
  19.                 if (find_appropriate_src(orig_tuple, tuple, range)) {
  20.                         DEBUGP("get_unique_tuple: Found current src map\n");
  21.                         if (!ip_nat_used_tuple(tuple, conntrack))
  22.                                 return;
  23.                 }
  24.         }

  26.         /* 2) Select the least-used IP/proto combination in the given
  27.            range. */
  28.         *tuple = *orig_tuple;
  29.         find_best_ips_proto(tuple, range, conntrack, maniptype);

  31.         /* 3) The per-protocol part of the manip is made to map into
  32.            the range to make a unique tuple. */

  34.         /* Only bother mapping if it's not already in range and unique */
  35.         if ((!(range->flags & IP_NAT_RANGE_PROTO_SPECIFIED)
  36.              || proto->in_range(tuple, maniptype, &range->min, &range->max))
  37.             && !ip_nat_used_tuple(tuple, conntrack))
  38.                 return;

  40.         /* Last change: get protocol to try to obtain unique tuple. */
  41.         proto->unique_tuple(tuple, range, maniptype, conntrack);
  42. }
复制代码


文章来源CU社区：Netfilter 地址转换的实现


上一篇：elasticsearch的查询基础知识
下一篇：Netfilter 地址转换的实现（1）
分享好友

分享这个小栈给你的朋友们，一起进步吧。

内核源码
创建时间：2020-05-18 13:36:55
内核源码精华帖内容汇总
展开
订阅须知

• 所有用户可根据关注领域订阅专区或所有专区

• 付费订阅：虚拟交易，一经交易不退款；若特殊情况，可3日内客服咨询

• 专区发布评论属默认订阅所评论专区（除付费小栈外）

技术专家

查看更多
  • 飘絮絮絮丶
    专家
戳我，来吐槽～

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8  北京市公安局海淀分局网监中心备案编号：11010802021510  未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员