在不使用环回网络的情况下将数据包转发到同一主机中的服务

我有这个 libnetfilter_queue 应用程序，它根据某些 iptables 规则从内核接收数据包。在直接讨论我的问题之前，我提供了一个示例可行代码和其他工具来设置测试环境，以便我们的问题定义和可能的解决方案可以更加准确和稳健。

以下代码描述了该应用程序的核心功能：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <netinet/in.h>
#include <linux/types.h>
#include <linux/netfilter.h>    /* for NF_ACCEPT */
#include <errno.h>

#include <libnetfilter_queue/libnetfilter_queue.h>
#define PREROUTING 0
#define POSTROUTING 4
#define OUTPUT 3


/* returns packet id */
static u_int32_t
print_pkt (struct nfq_data *tb)
{
  int id = 0;
  struct nfqnl_msg_packet_hdr *ph;
  struct nfqnl_msg_packet_hw *hwph;
  u_int32_t mark, ifi;
  int ret;
  unsigned char *data;

  ph = nfq_get_msg_packet_hdr (tb);
  if (ph)
    {
      id = ntohl (ph->packet_id);
      printf ("hw_protocol=0x%04x hook=%u id=%u ",
          ntohs (ph->hw_protocol), ph->hook, id);
    }

  hwph = nfq_get_packet_hw (tb);
  if (hwph)
    {
      int i, hlen = ntohs (hwph->hw_addrlen);

      printf ("hw_src_addr=");
      for (i = 0; i < hlen - 1; i++)
    printf ("%02x:", hwph->hw_addr[i]);
      printf ("%02x ", hwph->hw_addr[hlen - 1]);
    }

  mark = nfq_get_nfmark (tb);
  if (mark)
    printf ("mark=%u ", mark);

  ifi = nfq_get_indev (tb);
  if (ifi)
    printf ("indev=%u ", ifi);

  ifi = nfq_get_outdev (tb);
  if (ifi)
    printf ("outdev=%u ", ifi);
  ifi = nfq_get_physindev (tb);
  if (ifi)
    printf ("physindev=%u ", ifi);

  ifi = nfq_get_physoutdev (tb);
  if (ifi)
    printf ("physoutdev=%u ", ifi);

  ret = nfq_get_payload (tb, &data);
  if (ret >= 0)
    printf ("payload_len=%d ", ret);

  fputc ('\n', stdout);

  return id;
}


static int
cb (struct nfq_q_handle *qh, struct nfgenmsg *nfmsg,
    struct nfq_data *nfa, void *data)
{
  uint32_t ip_src, ip_dst;
  struct in_addr s_ip;
  struct in_addr d_ip;
  uint16_t src_port;
  uint16_t dst_port;
  int verdict;
  int id;
  int ret;
  unsigned char *buffer;
  struct nfqnl_msg_packet_hdr *ph = nfq_get_msg_packet_hdr (nfa);
  if (ph)
    {
      id = ntohl (ph->packet_id);
      printf ("received packet with id %d", id);
    }
  ret = nfq_get_payload (nfa, &buffer);
  ip_src = *((uint32_t *) (buffer + 12));
  ip_dst = *((uint32_t *) (buffer + 16));
  src_port = *((uint16_t *) (buffer + 20));
  dst_port = *((uint16_t *) (buffer + 22));
  s_ip.s_addr = (uint32_t) ip_src;
  d_ip.s_addr = (uint32_t) ip_dst;
  *(buffer + 26) = 0x00;
  *(buffer + 27) = 0x00;
  printf ( "source IP %s", inet_ntoa (s_ip));
  printf ( "destination IP %s", inet_ntoa (d_ip));
  printf ( "source port %d", src_port);
  printf ( "destination port %d", dst_port);
  if (ret)
    {
      switch (ph->hook)
    {
    case PREROUTING:
      printf ( "inbound packet");
      //my_mangling_fun();
      break;
    case OUTPUT:
      printf ( "outbound packet");
      //my_mangling_fun();
      break;
    }
    }
  verdict = nfq_set_verdict (qh, id, NF_ACCEPT, ret, buffer);
  if (verdict)
    printf ( "verdict ok");
  return verdict;
}

int
main (int argc, char **argv)
{
  struct nfq_handle *h;
  struct nfq_q_handle *qh;
  struct nfnl_handle *nh;
  int fd;
  int rv;
  char buf[4096] __attribute__ ((aligned));

  printf ("opening library handle\n");
  h = nfq_open ();
  if (!h)
    {
      fprintf (stderr, "error during nfq_open()\n");
      exit (1);
    }

  printf ("unbinding existing nf_queue handler for AF_INET (if any)\n");
  if (nfq_unbind_pf (h, AF_INET) < 0)
    {
      fprintf (stderr, "error during nfq_unbind_pf()\n");
      exit (1);
    }

  printf ("binding nfnetlink_queue as nf_queue handler for AF_INET\n");
  if (nfq_bind_pf (h, AF_INET) < 0)
    {
      fprintf (stderr, "error during nfq_bind_pf()\n");
      exit (1);
    }

  printf ("binding this socket to queue '0'\n");
  qh = nfq_create_queue (h, 0, &cb, NULL);
  if (!qh)
    {
      fprintf (stderr, "error during nfq_create_queue()\n");
      exit (1);
    }

  printf ("setting copy_packet mode\n");
  if (nfq_set_mode (qh, NFQNL_COPY_PACKET, 0xffff) < 0)
    {
      fprintf (stderr, "can't set packet_copy mode\n");
      exit (1);
    }

  fd = nfq_fd (h);

  for (;;)
    {
      if ((rv = recv (fd, buf, sizeof (buf), 0)) >= 0)
    {
      printf ("pkt received\n");
      nfq_handle_packet (h, buf, rv);
      continue;
    }
      /* if your application is too slow to digest the packets that
       * are sent from kernel-space, the socket buffer that we use
       * to enqueue packets may fill up returning ENOBUFS. Depending
       * on your application, this error may be ignored. Please, see
       * the doxygen documentation of this library on how to improve
       * this situation.
       */
      if (rv < 0 && errno == ENOBUFS)
    {
      printf ("losing packets!\n");
      continue;
    }
      perror ("recv failed");
      break;
    }

  printf ("unbinding from queue 0\n");
  nfq_destroy_queue (qh);

#ifdef INSANE
  /* normally, applications SHOULD NOT issue this command, since
   * it detaches other programs/sockets from AF_INET, too ! */
  printf ("unbinding from AF_INET\n");
  nfq_unbind_pf (h, AF_INET);
#endif

  printf ("closing library handle\n");
  nfq_close (h);

  exit (0);
}

请注意，在回调函数中，对 my_mangling_fun() 的两次调用被注释掉了。这是我破坏传入和传出数据包的地方。我认为这段代码足以描述我的情况。如果需要进一步澄清，请询问，我将发布更多详细信息。

假设随附的 iptables 规则如下：

$iptables -t mangle -A PREROUTING -p udp --dport 5000 -j NFQUEUE
$iptables -t mangle -A OUTPUT -p udp --sport 5000 -j NFQUEUE

让我们编译并启动 udp 吧。

$gcc -g3 nfq_test.c -lnfnetlink -lnetfilter_queue
$./a.out (should be as root)

现在我们可以通过 netcat 客户端和服务器模式将垃圾 udp 有效负载提供给这个东西

$nc -ul 5000
$nc -uvv <IP> 5000

这将在标准输出中打印来自我的 netfilter_queue 应用程序的数据包。现在开发环境已经搭建完毕，我们可以进行下一步了。

我们想要实现的目标如下：

我们的服务器正在监听 5000 端口。现在，所有发往 udp 端口​​ 5000 的传入数据包将由内核排队。该队列的句柄将提供给我们前面列出的用户应用程序。这种队列机制的工作原理如下：当数据包可用时，调用回调函数（在我们的代码中为 cb()）。处理完成后，回调函数调用nfq_set_verdict()。之后verdict返回后，下一个数据包将从队列中弹出。请注意，如果前一个数据包尚未得到判决，则该数据包不会从队列中弹出。该判决值为 NF_ACCEPT（接受数据包）、NF_DROP（丢弃数据包）。

现在，如果我想连接传入和传出数据包的 udp 有效负载而不接触客户端和服务器端代码怎么办？

如果我想从我们的应用程序（这个应用程序）连接 udp 有效负载，那么我们手头需要有多个数据包。但我们已经看到，在对前一个数据包做出判决之前，数据包不会从队列中弹出。

那么如何才能做到这一点呢？

一种可能的解决方案是向每个数据包发出 NF_DROP 并将这些数据包保存在中间数据结构中。假设我们已经做到了。但是这个数据包如何传递到监听 5000 端口的服务呢？

我们不能使用网络堆栈来传递数据包，因为如果这样做，数据包将再次进入 NFQUEUE。

另一个问题是，服务器完全不知道这个应用程序。这意味着它不应该看到数据包有任何差异。它应该看到数据包，就像它来自原始客户端一样。

我听说应用程序可以通过编写一些文件来将数据发送到同一主机中的服务器，而无需使用网络层（ip，端口）。我不知道这个说法的有效性。但如果有人知道任何关于它的事情，那就太好了。

我可能会因为过于冗长而被投票。但我认为这会是一次有趣的会议。我们可以一起找到解决方案:)

我提出以下解决方案：

• 将数据包存储在应用程序中并返回判决 NF_DROP
• 使用原始套接字将数据包重新注入网络堆栈
• 使用 DSCP 标记串联的 UDP 数据包（请参阅 IP 数据包格式）
• 在 iptables 中，添加一条规则来匹配此 DSCP (--dscp) 并直接接受数据包，而不通过您的 netfilter 应用程序

如果您的提供商已经使用 DSCP 标记了某些数据包，您可以添加一些 iptables 规则来清除它们，例如：

iptables -t mangle -A INPUT -j DSCP --set-dscp 0

我希望这能解决您的用例。