文章目录
- 前言
- 这条命令要实现起来最主要的难点在于对multiport模块的处理（如果没有这个模块会容易很多，之后的代码部分会提及）
- 一、libiptc库的应用
- 1.iptc_init
- 2.iptc_append_entry
- struct ipt_ip ip
- unsigned char elems[0]
- 首先我们看一下match的结构体的定义：
- 到这里，match的部分就暂时结束，然后是target结构体的定义：
- iptc_append_entry的总结
- 3.iptc_commit
- 二、iptc库实现-m 扩展模块的注意事项
- 1.直接填充match结构体会碰到的问题
- 2.问题的解决
- 总结
前言
最近在项目中需要使用iptc库对iptables防火墙中的nat表进行操作，完成对应的网络地址转换，基本上要实现的命令是：
iptables -t nat -A PREROUTING -p udp -m multiport -d proxyip --dport port1,port2,port3 -j DNAT --to-destination serverIp
这条命令要实现起来最主要的难点在于对multiport模块的处理（如果没有这个模块会容易很多，之后的代码部分会提及）
一、libiptc库的应用
这里我只会提到自己使用的一些函数接口，如果有其他接口的需求，可以自行百度iptc库，网上的介绍还是很多的
1.iptc_init
struct iptc_handle *h = NULL;
h = iptc_init("nat");iptc_init唯一的参数就是表的名称，我们这里使用的是nat表，因此就填nat，返回值是一个操作nat表的句柄，之后的规则添加、删除、修改之类的操作都会用到
2.iptc_append_entry
int iptc_append_entry(const xt_chainlabel chain,
const struct ipt_entry *e,
struct xtc_handle *handle);这相当于插入的函数，意义为向 handle对应的表中的chain链（这是个char[32]类型的数组，本质上是个字符串，对应上面iptables命令中的PREROUTING ，其余的还有INPUT、OUTPUT、POSTROUTING等，这些链所代表的意义，可以自行百度，算是iptables基础）中插入一条 e结构体代表的规则
不难看出，这个函数最核心的点就是对struct ipt_entry *e的填充，我们先来看一下这个结构体
/* This structure defines each of the firewall rules. Consists of 3
parts which are 1) general IP header stuff 2) match specific
stuff 3) the target to perform if the rule matches */
struct ipt_entry {
struct ipt_ip ip;
/* Mark with fields that we care about. */
unsigned int nfcache;
/* Size of ipt_entry + matches */
u_int16_t target_offset;
/* Size of ipt_entry + matches + target */
u_int16_t next_offset;
/* Back pointer */
unsigned int comefrom;
/* Packet and byte counters. */
struct xt_counters counters;
/* The matches (if any), then the target. */
unsigned char elems[0];
};不难看出，这个结构体最核心的部分是ip、elems两个成员：
struct ipt_ip ip
这个成员主要是源地址，目的地址，掩码等，对它的填充也很简单：
int fill_entry(struct ipt_entry *e, __u32 size, __u32 match_size, __u32 src_ip, uint32_t src_msk, __u32 dst_ip, uint32_t dst_msk, __u32 protocol) {
if (e == NULL) {
printf("fill_entry_error! %x \n", *(char *) e);
return -1;
}
/*初始化entry的源地址，目的地址和掩码*/
e->ip.src.s_addr = src_ip;
e->ip.dst.s_addr = dst_ip;
if (src_msk == -1) {
e->ip.dmsk.s_addr = htonl(0xFFFFFFFF << (32 - dst_msk));
} else {
e->ip.smsk.s_addr = htonl(0xFFFFFFFF << (32 - src_msk));
}
if (protocol == P_TCP) {
e->ip.proto = IPPROTO_TCP;
} else if (protocol == P_UDP) {
e->ip.proto = IPPROTO_UDP;
}
e->target_offset = IPT_ALIGN(sizeof(struct ipt_entry)) +match_size ;
e->next_offset = size;
return 0;
}其中关于target_offset 、next_offset 我们接下来谈
unsigned char elems[0]
这是一个柔型数组，对C语言不是很熟悉的朋友可以直接搜索，这里就不具体讨论了
这个地址很重要，它是iptables模块添加的起始位置，match和target都从这个位置开始填充，我的理解其中match代表的是iptables规则的匹配条件，target代表的是符合条件之后要完成的动作（对符合这个规则的数据包怎么操作，是接受ACCEPT、丢弃DROP、还是修改）
首先我们看一下match的结构体的定义：
//这两个文件是内核netfilter的头文件
//ip_tables.h
#define ipt_entry_match xt_entry_match
//x_tables.h
struct xt_entry_match {
union {
struct {
__u16 match_size;
/* Used by userspace */
char name[XT_FUNCTION_MAXNAMELEN-1];
__u8 revision;
} user;
struct {
__u16 match_size;
/* Used inside the kernel */
struct xt_match *match;
} kernel;
/* Total length */
__u16 match_size;
} u;
unsigned char data[0];
};这个结构体中联合体的理解应该不难，name数组存储扩展模块的名称，对应iptables命令中的-m multiport，如果在iptables源码中加一行打印，name的打印值就是multiport
重点依然是unsigned char data[0]这个柔性数组，这个地址指向的是模块对应要填充的结构体，我这里要使用的是multiport模块，因此需要使用multiport对应的结构体：
//xt_multiport.h
enum xt_multiport_flags {
XT_MULTIPORT_SOURCE,
XT_MULTIPORT_DESTINATION,
XT_MULTIPORT_EITHER
};
#define XT_MULTI_PORTS 15
/* Must fit inside union xt_matchinfo: 16 bytes */
struct xt_multiport {
__u8 flags; /* Type of comparison */
__u8 count; /* Number of ports */
__u16 ports[XT_MULTI_PORTS]; /* Ports */
};
struct xt_multiport_v1 {
__u8 flags; /* Type of comparison */
__u8 count; /* Number of ports */
__u16 ports[XT_MULTI_PORTS]; /* Ports */
__u8 pflags[XT_MULTI_PORTS]; /* Port flags */
__u8 invert; /* Invert flag */
};其中，我的Linux中iptables的版本是1.4.21，源码中使用的是xt_multiport_v1结构体，我们重点关注ports成员，multiport模块主要是提供分段端口的设置功能，具体到iptables命令就是：
iptables -t nat -A PREROUTING -p udp -m multiport -d proxyip --dport port1,port2,port3 -j DNAT --to-destination serverIp
其中：–dport port1,port2,port3的三个端口就是对应的ports，如果没有multiport模块，那么–dport参数就只能有一个（随口一提，要想使用范围端口的设置，需要iprange模块）
到这里，match的部分就暂时结束，然后是target结构体的定义：
//ip_tables.h
#define ipt_entry_target xt_entry_target
//x_tables.h
struct xt_entry_target {
union {
struct {
__u16 target_size;
/* Used by userspace */
char name[XT_FUNCTION_MAXNAMELEN-1];
__u8 revision;
} user;
struct {
__u16 target_size;
/* Used inside the kernel */
struct xt_target *target;
} kernel;
/* Total length */
__u16 target_size;
} u;
unsigned char data[0];
};可以看出target和match结构体在定义上其实很相似，我们可以主要关注data地址：
我这里使用的iptables命令中用到的target是 -j DNAT，也就是目的地址转换，需要填充的结构体为
//nf_nat.h
/* Single range specification. */
struct nf_nat_range
{
/* Set to OR of flags above. */
unsigned int flags;
/* Inclusive: network order. */
__be32 min_ip, max_ip;
/* Inclusive: network order */
union nf_conntrack_man_proto min, max;
};
/* For backwards compat: don't use in modern code. */
struct nf_nat_multi_range_compat
{
unsigned int rangesize; /* Must be 1. */
/* hangs off end. */
struct nf_nat_range range[1];
};
#define nf_nat_multi_range nf_nat_multi_range_compat具体的代码：
int fill_target(struct ipt_entry *e, struct ipt_entry_target *pt, struct nf_nat_multi_range_compat * p_target, const char *target, __u32 match_size,
__u32 target_size, __u32 out_ip, __u16 out_port, __u32 protocol) {
if (e == NULL || pt == NULL || p_target == NULL) {
printf("fill_target_error! %x---%x---%x\n", *(char *) e, *(char *) pt, *(char *) p_target);
return -1;
}
pt = (struct ipt_entry_target *) (e->elems + match_size);
pt->u.target_size = target_size;
strncpy(pt->u.user.name, target, sizeof(pt->u.user.name) - 1);
p_target = (struct nf_nat_multi_range_compat *) pt->data;
//
p_target->rangesize = 1;
out_port = 0;
if (out_port == 0) {
p_target->range[0].flags = 1;
} else {
p_target->range[0].flags = 3;
}
p_target->range[0].min_ip = out_ip;
p_target->range[0].max_ip = out_ip;
if (protocol == P_TCP) {
p_target->range[0].min.tcp.port = out_port;
p_target->range[0].max.tcp.port = out_port;
} else if (protocol == P_UDP) {
p_target->range[0].min.udp.port = out_port;
p_target->range[0].max.udp.port = out_port;
}
return 0;
}iptc_append_entry的总结
至此，关于iptc_append_entry函数最重要的部分ipt_entry结构体的介绍就大体结束了，值得注意的是，match和target部分都可以是有多个的，因此ipt_entry结构体真正的结构应该是：
struct ipt_entry + （struct xt_entry_match + 对应模块的结构体如struct xt_multiport_v1）+
（struct xt_entry_match + 对应模块的结构体） + ... +
（struct xt_entry_target + 对应target的结构体如struct nf_nat_multi_range_compat）
（struct xt_entry_target + 对应target的结构体） + ...又因为使用了柔性数组，因此这一长串的空间地址都是连续的
3.iptc_commit
ret = iptc_commit(h);
if (ret <= 0) {
printf("iptc_commit error:\n%s\n", iptc_strerror(ret));
}
iptc_free(h);这个函数是将我们iptc_append_entry增加的规则真正的提交到linux内核的防火墙模块生效，参数h是iptc_init函数返回的，iptables真正的工作部分还是在内核防火墙模块，如果出错，可以调用iptc_strerror打印出错信息
二、iptc库实现-m 扩展模块的注意事项
在对struct ipt_entry的介绍中，在match部分我只是介绍了match结构体的成员，并没有贴出填充这个结构体的具体的代码。因为这一块我想放到这里，是-m扩展模块的重点
1.直接填充match结构体会碰到的问题
根据对match的熟悉，我首先在测试是尝试了直接填充对应的match结构：
int fill_match(struct ipt_entry *e, struct ipt_entry_match *pm, __u32 match_size, __u16 src_port, __u16 dst_port, __u32 protocol) {
if (e == NULL || pm == NULL ) {
printf("fill_match_error! %x --- %x\n", *(char *) e, *(char *) pm);
return -1;
}
pm = (struct ipt_entry_match*) e->elems;
// pm->u.match_size = match_size;
pm->u.user.match_size = match_size;
strcpy(pm->u.user.name, "multiport");
struct xt_multiport_v1 *pmultiport = (struct xt_multiport_v1 *)pm->data;
int i;
for(i = 0; i < 15; i++){
pmultiport->pflags[i] = 0;
}
pmultiport->flags = XT_MULTIPORT_DESTINATION;
pmultiport->count = 3;
pmultiport->ports[0] = dst_port;
pmultiport->ports[1] = dst_port + 1;
pmultiport->ports[2] = dst_port + 2;
pmultiport->pflags[0] = 1;
pmultiport->pflags[1] = 1;
pmultiport->pflags[2] = 1;
return 0;
}简单粗暴的直接填充，在iptc_append_entry中并没有任何问题，但是在iptc_commit时却返回了一个错误：
Incompatible with this kernel
与此内核不兼容，咋看一下好像是内核版本兼容性的问题，但是仔细一想，在使用iptables的系统命令时却没有任何问题，我ldd查看了一下两个程序的动态库依赖，是依赖的相同的动态库，这样一来就很奇怪，调用同样的接口，一个成功，一个失败，其中必定会有深层次的原因。
2.问题的解决
在不断的阅读iptables(1.4.21)的源码，并自己加打印信息编译运行之后，我注意到了xtables.c这个文件
iptables第一步解析-m参数时，核心就调用了xtables_find_match，见名基本知意，optarg的值就是multiport，而这个函数中，尤其值得注意的就是：
load_extension中，dlopen了一个动态库，因为是multiport，因此打开的动态库是libxt_multiport.so，而这个动态库中接口在iptables源码extensions文件夹，事实上，所有的扩展模块都在这个文件夹：
//......
static struct xtables_match multiport_mt_reg[] = {
{
.family = NFPROTO_IPV4,
.name = "multiport",
.revision = 0,
.version = XTABLES_VERSION,
.size = XT_ALIGN(sizeof(struct xt_multiport)),
.userspacesize = XT_ALIGN(sizeof(struct xt_multiport)),
.help = multiport_help,
.x6_parse = multiport_parse,
.x6_fcheck = multiport_check,
.print = multiport_print,
.save = multiport_save,
.x6_options = multiport_opts,
},
{
.family = NFPROTO_IPV6,
.name = "multiport",
.revision = 0,
.version = XTABLES_VERSION,
.size = XT_ALIGN(sizeof(struct xt_multiport)),
.userspacesize = XT_ALIGN(sizeof(struct xt_multiport)),
.help = multiport_help,
.x6_parse = multiport_parse6,
.x6_fcheck = multiport_check,
.print = multiport_print6,
.save = multiport_save6,
.x6_options = multiport_opts,
},
{
.family = NFPROTO_IPV4,
.name = "multiport",
.version = XTABLES_VERSION,
.revision = 1,
.size = XT_ALIGN(sizeof(struct xt_multiport_v1)),
.userspacesize = XT_ALIGN(sizeof(struct xt_multiport_v1)),
.help = multiport_help_v1,
.x6_parse = multiport_parse_v1,
.x6_fcheck = multiport_check,
.print = multiport_print_v1,
.save = multiport_save_v1,
.x6_options = multiport_opts,
},
{
.family = NFPROTO_IPV6,
.name = "multiport",
.version = XTABLES_VERSION,
.revision = 1,
.size = XT_ALIGN(sizeof(struct xt_multiport_v1)),
.userspacesize = XT_ALIGN(sizeof(struct xt_multiport_v1)),
.help = multiport_help_v1,
.x6_parse = multiport_parse6_v1,
.x6_fcheck = multiport_check,
.print = multiport_print6_v1,
.save = multiport_save6_v1,
.x6_options = multiport_opts,
},
};
void
_init(void)
{
xtables_register_matches(multiport_mt_reg, ARRAY_SIZE(multiport_mt_reg));
}其中最重要的是x6_parse所指向的回调函数，即multiport_parse_v1：
static void __multiport_parse_v1(struct xt_option_call *cb, uint16_t pnum,
uint8_t invflags)
{
const char *proto;
struct xt_multiport_v1 *multiinfo = cb->data;
xtables_option_parse(cb);
switch (cb->entry->id) {
case O_SOURCE_PORTS:
proto = check_proto(pnum, invflags);
parse_multi_ports_v1(cb->arg, multiinfo, proto);
multiinfo->flags = XT_MULTIPORT_SOURCE;
break;
case O_DEST_PORTS:
proto = check_proto(pnum, invflags);
parse_multi_ports_v1(cb->arg, multiinfo, proto);
multiinfo->flags = XT_MULTIPORT_DESTINATION;
break;
case O_SD_PORTS:
proto = check_proto(pnum, invflags);
parse_multi_ports_v1(cb->arg, multiinfo, proto);
multiinfo->flags = XT_MULTIPORT_EITHER;
break;
}
if (cb->invert)
multiinfo->invert = 1;
}
static void multiport_parse_v1(struct xt_option_call *cb)
{
const struct ipt_entry *entry = cb->xt_entry;
return __multiport_parse_v1(cb,
entry->ip.proto, entry->ip.invflags);
}这个回调函数主要是作参数的解析，填充struct xt_multiport_v1结构体，对应到iptables命令中就是–dport port1,port2,port3，其中cb->arg就是port1,port2,port3三个分段端口
起初，我是有些不理解的，我自己的程序和iptables唯一的区别就是它使用了一个动态库（dlopen）去处理命令行的参数，填充相应的结构体，而我是直接填充struct ipt_entry结构体，但是我的程序却产生了错误。这其实是令人恼火的，Linux内核这一块我熟悉一些的都是网络部分，对防火墙netfilter部分了解不多，只能在网上不断浏览其他人的博客寻找方法，然后对照iptables源码，运气比较好，终于是让我找到了原因：
iptables match模块扩展 数据传递（用户空间 -> 内核空间）
/**
* @arg: input from command line
* @ext_name: name of extension currently being processed
* @entry: current option being processed
* @data: per-extension kernel data block
* @xflags: options of the extension that have been used
* @invert: whether option was used with !
* @nvals: number of results in uXX_multi
* @val: parsed result
* @udata: per-extension private scratch area
* (cf. xtables_{match,target}->udata_size)
*/
struct xt_option_call {
const char *arg, *ext_name;
const struct xt_option_entry *entry;
void *data;
unsigned int xflags;
bool invert;
uint8_t nvals;
union {
uint8_t u8, u8_range[2], syslog_level, protocol;
uint16_t u16, u16_range[2], port, port_range[2];
uint32_t u32, u32_range[2];
uint64_t u64, u64_range[2];
double dbl;
struct {
union nf_inet_addr haddr, hmask;
uint8_t hlen;
};
struct {
uint8_t tos_value, tos_mask;
};
struct {
uint32_t mark, mask;
};
uint8_t ethermac[6];
} val;
/* Wished for a world where the ones below were gone: */
union {
struct xt_entry_match **match;
struct xt_entry_target **target;
};
void *xt_entry;
void *udata;
};简单来说x6_parse指向的回调函数的参数struct xt_option_call的data成员会将数据传递到内核，iptables每一个extensions文件夹中的libxt_.c文件都对应一个libxt_.so动态库，而每个libxt_.so动态库在内核都有一个xt_.ko模块和它对应，iptables能操作内核防火墙，这个对应关系是绝对不能少的：
到了这里之后，要做的事情就很清晰了：
参照iptables源码，抽取出其调用libxt_multiport.so的逻辑来完成我们自己的参数填充，具体的代码如下：
int iptc_entry_add(struct iptc_handle *handle, const char *chain, const char *target, __u32 protocol, __u32 src_ip, __u16 src_port, __u32 src_msk,
__u32 dst_ip, __u16 dst_port, __u32 dst_msk, __u32 out_ip, __u16 out_port) {
struct xt_option_call cb;
struct xtables_match *m;
struct xtables_rule_match *matches;
m = xtables_find_match("multiport", XTF_LOAD_MUST_SUCCEED, &matches);
if(m->init != NULL)
m->init(m->m);
if (handle == NULL || chain == NULL || target == NULL) {
printf("iptc_entry_add error! %x---%x---%x\n", *(char *) handle, *(char *) chain, *(char *) target);
return -1;
}
struct ipt_entry *e = NULL;
struct ipt_entry_match pm;
struct ipt_entry_target pt;
struct nf_nat_multi_range_compat p_target;
__u32 target_size, match_size, size;
__u32 ret = 0;
if(protocol == P_TCP){
match_size = IPT_ALIGN(sizeof(struct ipt_entry_match)) + IPT_ALIGN(sizeof(struct ipt_tcp));
}else if(protocol == P_MULTI){
match_size = IPT_ALIGN(sizeof(struct ipt_entry_match)) + IPT_ALIGN(sizeof(struct xt_multiport_v1));
}else{
match_size = IPT_ALIGN(sizeof(struct ipt_entry_match)) + IPT_ALIGN(sizeof(struct ipt_udp));
}
target_size = IPT_ALIGN(sizeof(struct ipt_entry_target))+ IPT_ALIGN(sizeof(struct nf_nat_multi_range_compat));
// target_size = sizeof(struct ipt_standard_target)+ sizeof(struct nf_nat_multi_range_compat);
size = IPT_ALIGN(sizeof(struct ipt_entry)) + target_size + match_size;
e = malloc(size);
memset((void *) e, 0, size);
m->m = e->elems;
m->m->u.match_size = match_size;
if (m->real_name == NULL) {
strcpy(m->m->u.user.name, m->name);
} else {
strcpy(m->m->u.user.name, m->real_name);
}
m->m->u.user.revision = m->revision;
fill_entry(e, size, match_size, src_ip, src_msk, dst_ip, dst_msk, protocol);
// fill_match(e, &pm, match_size, src_port, dst_port, protocol);
cb.entry = xtables_option_lookup(m->x6_options, 1); // 1-->dports, 0-->sports
cb.arg = "20000,20001,20002";
cb.invert = 0;
cb.ext_name = "multiport";
cb.data = m->m->data;
cb.xflags = m->mflags;
cb.match = &m->m;
cb.xt_entry = e;
cb.udata = m->udata;
m->x6_parse(&cb);
m->mflags = cb.xflags;
fill_target(e, &pt, &p_target, target, match_size, target_size, out_ip, out_port, protocol);
/* 在规则链中插入一项 */
ret = iptc_append_entry(chain, e, handle);
if(ret <= 0){
printf("iptc_append_entry:\n%s\n\n", iptc_strerror(ret));
}
if (e) {
free(e);
}
return ret;
}核心部分是对struct xt_option_call 结构体的填充：
编译运行，有一个地方需要修改，在iptables源码中，xtoptions.c文件中：
optarg参数是iptables用了getopt_long函数来解析linux命令行参数，但是如果我的程序没有使用这个函数，当程序运行到这里就会因为optarg==NULL而退出，因此我将这个判断注释掉了，重新编译了iptables源码，并替换libxtables.so动态库
之后再编译程序，运行正常，iptables -t nat -A PREROUTING -p udp -m multiport -d proxyip --dport port1,port2,port3 -j DNAT --to-destination serverIp这条命令即使不系统调用iptables，在我自己的程序中也能通过ipt_commit提交添加并生效，iptables -t nat -nvL查看也能正常显示。
总结
其实要根本的解决问题，还是应该弄明白iptables和内核交互的具体流程和代码，但是这需要更扎实的知识储备和时间，暂时作为一个长期规划处理吧
