netfilter使用

最新推荐文章于 2024-04-28 12:35:10 发布
最新推荐文章于 2024-04-28 12:35:10 发布
阅读量360 收藏 9
点赞数 7
文章标签： 网络 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongcheng123456789/article/details/136500770
版权

netfilter的使用

linux内核中ip的打印

//ipv4在linux内核中存在的类型为uint32_t，可以转为string。
void IP2Str(char *s_ip_addr, int size, uint32_t ip)
{
	snprintf(s_ip_addr, size, "%d.%d.%d.%d", ( ip >> 24 ) & 0xff, 
	( ip >> 16 ) & 0xff, ( ip >> 8 ) & 0xff, ip & 0xff);
}
//ipv6转为string
void IP62Str(char *str, int size, struct in6_addr *ip6)
{
	 snprintf(str, size, "%pI6c", ip6);
}

netfilter函数注册

netfilter函数有5个挂载点，分别为NF_BR_LOCAL_IN，NF_BR_LOCAL_OUT，NF_BR_PRE_ROUTING，NF_BR_FORWARD和NF_BR_POST_ROUTING。本文主要使用了NF_BR_LOCAL_IN和NF_BR_LOCAL_OUT。

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 18, 0)
unsigned int my_local_in_hook(void *priv, struct sk_buff *skb,const struct nf_hook_state *state)
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
unsigned int my_local_in_hook(const struct nf_hook_ops *ops, struct sk_buff *skb, 
			const struct net_device *in, const struct net_device *out,
#ifndef __GENKSYMS__
            const struct nf_hook_state *state
#else
            int (*okfn)(struct sk_buff *)
#endif
		   )
#else
unsigned int my_local_in_hook(unsigned int hooknum,
                               struct sk_buff *skb,
                               const struct net_device *in,
                               const struct net_device *out,
                               int (*okfn)(struct sk_buff *))
#endif
{
	struct iphdr *iph;
	char s_ip_addr[20];
	//char d_ip_addr[20];
	if( unlikely(!skb) ) {
		return NF_ACCEPT;
	}

	iph = ip_hdr(skb);
	if( unlikely(!iph) ) {
		return NF_ACCEPT;
	}
 	memset(s_ip_addr, 0, sizeof(s_ip_addr));
	//memset(d_ip_addr, 0, sizeof(d_ip_addr));
	IP2Str(s_ip_addr, sizeof(s_ip_addr), ntohl(iph->saddr));
	//IP2Str(d_ip_addr, sizeof(d_ip_addr), ntohl(iph->daddr));
	if(likely(iph->protocol == IPPROTO_ICMP)) 
	{
		printk("pinging the host...");
    }
	else if(likely(iph->protocol == IPPROTO_TCP))
	{
		struct tcphdr *tcph = tcp_hdr(skb);
		if( unlikely(!tcph) )
		{
			return NF_ACCEPT;
        }
		if ((int)ntohs(tcph->dest)!=22)
		{
			printk("receive IPPROTO_TCP from %s,%d,%d\n", s_ip_addr,(int)ntohs(tcph->source),(int)ntohs(tcph->dest));
		}
		
	}
	else if(likely(iph->protocol == IPPROTO_UDP))
	{
		struct udphdr *udph = udp_hdr(skb);
		if( unlikely(!udph) )
		{
			return NF_ACCEPT;
        }
        printk("receive IPPROTO_UTP from %s,%d,%d\n", s_ip_addr,(int)ntohs(udph->source),(int)ntohs(udph->dest));
	}

	return NF_ACCEPT;
}

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 18, 0)
unsigned int my_local_out_hook(void *priv, struct sk_buff *skb,const struct nf_hook_state *state)
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
unsigned int my_local_out_hook(const struct nf_hook_ops *ops, struct sk_buff *skb, 
			const struct net_device *in, const struct net_device *out,
#ifndef __GENKSYMS__
            const struct nf_hook_state *state
#else
            int (*okfn)(struct sk_buff *)
#endif
		   )
#else
unsigned int my_local_out_hook(unsigned int hooknum,
                               struct sk_buff *skb,
                               const struct net_device *in,
                               const struct net_device *out,
                               int (*okfn)(struct sk_buff *))
#endif
{
	struct iphdr *iph;
	char d_ip_addr[20];

	if( unlikely(!skb) ) {
		return NF_ACCEPT;
	}

	iph = ip_hdr(skb);
	if( unlikely(!iph) ) {
		return NF_ACCEPT;
	}
 	memset(d_ip_addr, 0, sizeof(d_ip_addr));
	IP2Str(d_ip_addr, sizeof(d_ip_addr), ntohl(iph->daddr));
	if(likely(iph->protocol == IPPROTO_ICMP)) 
	{
		printk("pinging...\n");
    }
	else if(likely(iph->protocol == IPPROTO_TCP))
	{
		struct tcphdr *tcph = tcp_hdr(skb);
		if( unlikely(!tcph) )
		{
			return NF_ACCEPT;
        }
		printk("send IPPROTO_TCP from %d, to %s:%d\n", (int)ntohs(tcph->source),d_ip_addr,(int)ntohs(tcph->dest));
	}
	else if(likely(iph->protocol == IPPROTO_UDP))
	{
		struct udphdr *udph = udp_hdr(skb);
		if( unlikely(!udph) )
		{
			return NF_ACCEPT;
        }
        printk("send IPPROTO_UTP from %d,to %s:%d\n", (int)ntohs(udph->source), d_ip_addr,(int)ntohs(udph->dest));
	}

	return NF_ACCEPT;
}
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 18, 0)
unsigned int my_local_in_hook_v6(void *priv, struct sk_buff *skb,const struct nf_hook_state *state)
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
unsigned int my_local_in_hook_v6(const struct nf_hook_ops *ops,
       struct sk_buff *skb,
       const struct net_device *in,
       const struct net_device *out,
#ifndef __GENKSYMS__
       const struct nf_hook_state *state
#else
       int (*okfn)(struct sk_buff *)
#endif
	   )
#else 
unsigned int my_local_in_hook_v6(unsigned int hooknum,
                               struct sk_buff *skb,
                               const struct net_device *in,
                               const struct net_device *out,
                               int (*okfn)(struct sk_buff *))
#endif
{   
    struct ipv6hdr *iph6;
    char s_addr[40] = {0};
	iph6 = ipv6_hdr(skb);
    if (!iph6)
        return NF_ACCEPT;
 
    /* 过滤 ::/128 空类型地址 */
    if (ipv6_addr_any(&iph6->saddr) || ipv6_addr_any(&iph6->daddr))
        return NF_ACCEPT;
 
    /* 过滤源地址和目的地址相等的报文 */
    if (ipv6_addr_equal(&iph6->saddr, &iph6->daddr))
        return NF_ACCEPT;
 
    /* 过滤环回地址报文 ::1/128 */
    if (ipv6_addr_loopback(&iph6->saddr) || ipv6_addr_loopback(&iph6->daddr))
    {
        return NF_ACCEPT;
    }
    IP62Str(s_addr, 40, &iph6->saddr);
	if (iph6->nexthdr == NEXTHDR_ICMP)
	{
		ptintk("pinging...");
	}
	else if (iph6->nexthdr == NEXTHDR_TCP)
	{
		struct tcphdr *tcph = tcp_hdr(skb);
		if( unlikely(!tcph) )
		{
			return NF_ACCEPT;
        }
        printk("recv ipv6 tcp from %s:%d, to %d\n",s_addr, (int)ntohs(tcph->source), (int)ntohs(tcph->dest));
	}
	else if (iph6->nexthdr == NEXTHDR_UDP)
	{
		struct udphdr *udph = udp_hdr(skb);
		if( unlikely(!udph) )
		{
			return NF_ACCEPT;
        }
        printk("recv ipv6 udp from %s:%d, to %d\n",s_addr, (int)ntohs(udph->source), (int)ntohs(udph->dest));
	}
    return NF_ACCEPT;                          
}
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 18, 0)
unsigned int my_local_out_hook_v6(void *priv, struct sk_buff *skb,const struct nf_hook_state *state)
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
unsigned int my_local_out_hook_v6(const struct nf_hook_ops *ops,
       struct sk_buff *skb,
       const struct net_device *in,
       const struct net_device *out,
#ifndef __GENKSYMS__
       const struct nf_hook_state *state
#else
       int (*okfn)(struct sk_buff *)
#endif
	   )
#else
unsigned int my_local_out_hook_v6(unsigned int hooknum,
                               struct sk_buff *skb,
                               const struct net_device *in,
                               const struct net_device *out,
                               int (*okfn)(struct sk_buff *))
#endif
{   
    /* do something */
    struct ipv6hdr *iph6;
    char d_addr[40] = {0};
	iph6 = ipv6_hdr(skb);
    if (!iph6)
        return NF_ACCEPT;
 
    /* 过滤 ::/128 空类型地址 */
    if (ipv6_addr_any(&iph6->saddr) || ipv6_addr_any(&iph6->daddr))
        return NF_ACCEPT;
 
    /* 过滤源地址和目的地址相等的报文 */
    if (ipv6_addr_equal(&iph6->saddr, &iph6->daddr))
        return NF_ACCEPT;
 
    /* 过滤环回地址报文 ::1/128 */
    if (ipv6_addr_loopback(&iph6->saddr) || ipv6_addr_loopback(&iph6->daddr))
    {
        return NF_ACCEPT;
    }
    IP62Str(d_addr, 40, &iph6->daddr);
	if (iph6->nexthdr == NEXTHDR_TCP)
	{
		struct tcphdr *tcph = tcp_hdr(skb);
		if( unlikely(!tcph) )
		{
			return NF_ACCEPT;
        }
		printk("send ipv6 tcp from %d, to %s:%d\n",(int)ntohs(tcph->source), d_addr, (int)ntohs(tcph->dest));
	}
	else if (iph6->nexthdr == NEXTHDR_UDP)
	{
		struct udphdr *udph = udp_hdr(skb);
		if( unlikely(!udph) )
		{
			return NF_ACCEPT;
        }
        printk("send ipv6 udp from %d, to %s:%d\n",(int)ntohs(udph->source), d_addr, (int)ntohs(udph->dest));
	}
    return NF_ACCEPT;                          
}
 
static struct nf_hook_ops my_hook_ops[] __read_mostly = 
{
	{
		.hook = my_local_in_hook,          //hook处理函数
		.pf = PF_INET,              //协议类型
		//.hooknum = NF_BR_PRE_ROUTING,    //hook注册点
		.hooknum = NF_BR_LOCAL_IN,
		.priority = NF_IP_PRI_FIRST,      //优先级
	},
	{
		.hook = my_local_out_hook,          //hook处理函数
		.pf = PF_INET,              //协议类型
		//.hooknum = NF_BR_PRE_ROUTING,    //hook注册点
		.hooknum = NF_BR_LOCAL_OUT,
		.priority = NF_IP_PRI_FIRST,      //优先级
	},
	{
        .hook = my_local_in_hook_v6,       /* 钩子处理函数 */
        .pf = NFPROTO_IPV6,                 /* 协议类型IPv6 */
        .hooknum = NF_BR_LOCAL_IN,     /* Pre_Routing链 */
        .priority = NF_IP_PRI_FIRST + 20,   /* 优先级 */
    },
    {
        .hook = my_local_out_hook_v6,        /* 钩子处理函数 */
        .pf = NFPROTO_IPV6,                   /* 协议类型IPv6 */
        //.hooknum = NF_INET_LOCAL_IN,       /* Post_Routing链 */
		.hooknum = NF_BR_LOCAL_OUT, 
        .priority = NF_IP_PRI_FIRST + 20,     /* 优先级 */
    },
};

//注册hook函数
void my_netfilter_init(void)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 13, 0)
	if ( nf_register_net_hooks(&init_net, my_hook_ops, ARRAY_SIZE(my_hook_ops)) != 0 ) {
#else
	if ( nf_register_hooks(my_hook_ops, ARRAY_SIZE(my_hook_ops)) != 0) { 
#endif
		goto err;
	}
	return;
 
err:
	return;
}

//取消hook
 void netfilter_exit(void)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 13, 0)
	nf_unregister_net_hooks(&init_net, my_hook_ops, ARRAY_SIZE(my_hook_ops));
#else
	nf_unregister_hooks(my_hook_ops, ARRAY_SIZE(my_hook_ops));
#endif
}
dongcheng123456789
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Linux下使用Netfilter框架编写内核模块（统计协议层ping特定地址丢包数）
ljbcharles的专栏
02-24 4000
1.5个HOOK点的执行点说明：数据包从进入系统，进行IP校验以后，首先经过第一个HOOK函数NF_IP_PRE_ROUTING进行处理；然后就进入FORWARD路由匹配，其决定该数据报是需要转发还是发给本机的；若该数据包是发给本机的，则该数据经过HOOK函数NF_IP_LOCAL_IN处理以后然后传递给上层协议；若该数据报应该被转发则它被NF_IP_FORWARD处理；经过转发的数据报经过最后一个HOOK函数NF_IP_POST_ROUTING处理以后，再传输到网络上。
Netfilter和iptables命令详解，从入门到精通
meihualing的专栏
05-09 2382
iptables命令详解
深入理解Netfilter
weixin_36184908的博客
05-24 929
Netfilter是Linux内核中的一个框架，用于进行网络数据包的过滤和操作。它提供了强大的网络数据包处理功能，使系统管理员能够在Linux系统上实施高级的网络安全策略，包括防火墙、网络地址转换（NAT）、流量控制等。Netfilter的核心是一个包过滤器，它可以在数据包通过网络协议栈的不同阶段进行处理。当数据包经过网络协议栈时，Netfilter可以检查、修改或丢弃这些数据包，从而允许管理员根据自己的需求对网络流量进行控制和管理。
Netfilter的使用和实现
yqtao的博客
02-28 1005
本文转自：http://blog.csdn.net/zhangskd/article/details/22678659概述\quadNetfilter为多种网络协议（IPv4、IPv6、ARP等）各提供了一套钩子函数。在IPv4中定义了5个钩子函数，这些钩子函数在数据包流经协议栈的5个关键点被调用。这就像有5个钓鱼台，在每个钓鱼台放了一个鱼钩(钩子函数)，把经过的数据包钓上来，然后根据自定义的规则，
大白话netfilter
yanchendage的博客
03-16 9825
背景 最近在看k8s源码，读到了kube proxy，网络应该是k8s里重要的一章节，看着看着发现还是之前学的又给忘了，所以先来一波技术储备。 netfilter net+filter，filter是过滤的意思，那我们从字面分析就是过滤数据包从而达到防火墙的目的。上面说netfilter位于内核空间，那也就是说netfilter在内核空间设立了一个个检测点（HOOK）。 NF_IP_PRE_ROUTING 刚刚进入网络层的数据包通过此点 NF_IP_LOCAL_IN 经路由查找后，送往本机的通过此检查点
ja-netfilter
02-09
ja-netfilter
netfilter.pdf
12-31
主要对netfilter框架的原理和源码进行讲解，对于netfilter、iptables、conntrack、nat直接如何配合，进行了详细的图标绘制，源码分析，对于个人理解netfilter框架有很好的提高
NetFilter防火墙驱动
10-24
NetFilter防火墙驱动 驱动调用~ 网络驱动层封包截取一系列源码里面包含一个完整的网络防火墙程序
netfilter框架分析_netfilter_linuxnetfilter_
09-29
Linux协议栈，Netfilter框架分析文档，Linux内核中进行数据包过滤、连接跟踪、地址转换等的主要实现框架。
Linux Netfilter框架实现及函数调用处理过程
mrtyxr的博客
01-26 1236
本身从事网络安全工作，具体为防火墙产品的开发，对Linux 内核而言，Linux 防火墙功能由Netfilter框架实现，因此有了对Linux内核Netfilter实现逻辑的学习研究的兴趣，也想借此平台和大家一起交流学习。
linux netfilter/iptables 架构分析及nelink的使用
飞翔de刺猬
09-29 4134
本文主要介绍，分为三部分： 1.linux netfilter/iptables组织架构，及其如何扩展netfilter模块。 2.linux netlink机制及其使用方式。 3.介绍内核模块的编写方法：内嵌到源码树构建；独立于源码树构建。
linux 内核 printk %pI4的用法
我的博客
12-04 730
linux 内核 printk %pI4的用法
Linux: Netfilter 简介
最新发布
JiMoKuangXiangQu的专栏
04-28 1344
Linux，网络，Netfilter
linux内核邻居子系统入门之打印局域网内所有机器的ip和mac地址
我的博客
12-01 204
linux内核邻居子系统入门之打印局域网内所有机器的ip和mac地址
netfilter框架概述
rondyning的博客
05-25 2803
1 Netfilter 1.1 netfilter概述 Netfilter是linux 2.4.x引入的一个子系统，它是一个通用的、抽象的框架。其不依赖于具体的协议，而是为每种网络协议定义一套HOOK函数。这些HOOK函数在数据报经过协议栈的几个关键点被调用。 内核的任何模块可以对每种协议的一个或多个HOOK进行注册，实现挂接。这样当某个数据报被传递给Netfilter框架时，内核能检测到是否有任何模块对该协议和HOOK函数进行了注册。若注册了，则调用该模块的注册时使用的回调函数，这样这些模块就有机会检查、
linux 内核配置ip地址,linux内核IP地址转换函数
weixin_28746213的博客
04-29 892
http://www.cloudbbs.org/forum.php?mod=viewthread&tid=17856IP 地址转换(字符串 -> 数值)#includeiph->saddr = in_aton("1.1.1.1");打印 IP 地址#includeprintk("%d.%d.%d.%d\n", NIPQUAD(iph->saddr));#define NI...
程序中打印IP的方法
鬼手
03-04 1135
IP的打印，老是记不住 应用层 printf("ip = %d.%d.%d.%d", NIPQUAD(ip)); 内核 printk("ip = %pI4", NIPQUAD(ip));
使用netfilter实现vlan功能
03-28
使用`iptables`命令配置Netfilter规则，例如： ``` sudo iptables -A FORWARD -i eth0.10 -j ACCEPT sudo iptables -A FORWARD -o eth0.10 -j ACCEPT ``` 其中，`-i`和`-o`参数分别表示输入和输出接口，`-j ACCEPT...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值