3

我有这个 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()。返回判决后，下一个数据包将从队列中弹出。请注意，如果之前的数据包没有被发出判决，则该数据包不会从队列中弹出。这个判断值是 NF_ACCEPT 用于接受数据包，NF_DROP 用于丢弃数据包。

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

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

那么如何做到这一点呢？

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

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

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

我听说应用程序可以通过编写一些文件，在不使用网络层（ip，端口）的情况下将数据发送到同一主机中的服务器。我不知道这个说法的有效性。但是，如果有人对此有所了解，那就太好了。

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

4

2 回答 2

1

我提出以下解决方案：

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

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

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

我希望这可以解决您的用例。

于 2012-04-25T11:15:10.063 回答
1

首先，非常感谢 Aftnix！您的示例启动了我的自动数据包检查唤醒局域网项目。我想让我的家庭服务器在空闲时休眠，但是一旦有请求进来就会醒来。这个想法是检查 ddwrt 路由器上的请求，确定它是合法请求并发送 wol 包。对于 SMTP，想法是将多个数据包排队，让另一端对一些虚假响应感到满意，并透明地启动真实服务器。

我稍微修改了您的示例以将 1 个数据包排队并与下一个数据包一起发送。这只是一个概念验证，但效果很好。

// struct and variable needed to store 1 packet
struct packetbuffer {
  struct nfq_q_handle *qh;
  u_int32_t id;
  u_int32_t verdict;
  u_int32_t data_len;
  unsigned char *buf;
};

struct packetbuffer pbuf;
int counter = 0;

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

  // My modification starts here
  if ((counter % 2) == 0)
  {
    pbuf.qh = qh;
    pbuf.id = id;
    pbuf.data_len = ret;
    pbuf.buf = malloc(ret);
    memcpy(pbuf.buf, buffer, ret);
    printf(" queue package %d \n", id);
  }
  else
  {
      printf(" output 1st package %d, len=%d\n", pbuf.id, pbuf.data_len);
      verdict = nfq_set_verdict (pbuf.qh, pbuf.id, NF_ACCEPT, pbuf.data_len, pbuf.buf);
      free(pbuf.buf);

      printf(" output 2nd package %d, len=%d\n", id, ret);
      verdict = nfq_set_verdict (qh, id, NF_ACCEPT, ret, buffer);
  }
  counter++;
  return 0;
}

这不是所有的代码，但应该很明显改变了什么。

我知道我参加聚会有点晚了，但我决定发布这个解决方案以供将来参考，并希望得到一些批评。

编辑：嗯，也许我最好写一个像rinetd这样的用户空间进程。

于 2013-04-19T13:34:19.357 回答