iptables: Module unload causing NULL pointer reference.
Subsystems (3)
cover iptables: Module unload causing NULL pointer reference.
A crash happened on ppc64le when running ltp network tests triggered by "rmmod iptable_mangle".
See previous discussion in this thread: https://lists.openwall.net/netdev/2020/06/03/161 .
In the crash I found in iptable_mangle_hook() that state->net->ipv4.iptable_mangle=NULL causing a NULL pointer dereference. net->ipv4.iptable_mangle is set to NULL in iptable_mangle_net_exit() and called when ip_mangle modules is unloaded. A rmmod task was found running in the crash dump. A 2nd crash showed the same problem when running "rmmod iptable_filter" (net->ipv4.iptable_filter=NULL).
To fix this I added .pre_exit hook in all iptable_foo.c. The pre_exit will un-register the underlying hook and exit would do the table freeing. The netns core does an unconditional synchronize_rcu after the pre_exit hooks insuring no packets are in flight that have picked up the pointer before completing the un-register.
These patches include changes for both iptables and ip6tables.
We tested this fix with ltp running iptables01.sh and iptables01.sh -6 a loop for 72 hours.
David Wilder (4):
netfilter: Split ipt_unregister_table() into pre_exit and exit
helpers.
netfilter: Add a .pre_exit hook in all iptable_foo.c.
netfilter: Split ip6t_unregister_table() into pre_exit and exit
helpers.
netfilter: Add a .pre_exit hook in all ip6table_foo.c.
include/linux/netfilter_ipv4/ip_tables.h | 6 ++++++ include/linux/netfilter_ipv6/ip6_tables.h | 3 +++ net/ipv4/netfilter/ip_tables.c | 15 ++++++++++++++- net/ipv4/netfilter/iptable_filter.c | 10 +++++++++- net/ipv4/netfilter/iptable_mangle.c | 10 +++++++++- net/ipv4/netfilter/iptable_nat.c | 10 ++++++++-- net/ipv4/netfilter/iptable_raw.c | 10 +++++++++- net/ipv4/netfilter/iptable_security.c | 11 +++++++++-- net/ipv6/netfilter/ip6_tables.c | 15 ++++++++++++++- net/ipv6/netfilter/ip6table_filter.c | 10 +++++++++- net/ipv6/netfilter/ip6table_mangle.c | 10 +++++++++- net/ipv6/netfilter/ip6table_nat.c | 10 ++++++++-- net/ipv6/netfilter/ip6table_raw.c | 10 +++++++++- net/ipv6/netfilter/ip6table_security.c | 10 +++++++++- 14 files changed, 125 insertions(+), 15 deletions(-)
Signature · 1 line
1.8.3.1
PATCH 1/4 netfilter: Split ipt_unregister_table() into pre_exit and exit helpers.
The pre_exit will un-register the underlying hook and .exit will do the table freeing. The netns core does an unconditional synchronize_rcu after the pre_exit hooks insuring no packets are in flight that have picked up the pointer before completing the un-register.
--- include/linux/netfilter_ipv4/ip_tables.h | 6 ++++++ net/ipv4/netfilter/ip_tables.c | 15 ++++++++++++++- 2 files changed, 20 insertions(+), 1 deletion(-)
include/linux/netfilter_ipv4/ip_tables.h +6 -0
@@ -25,6 +25,12 @@int ipt_register_table (struct net *net,const struct xt_table *table,const struct ipt_replace *repl,const struct nf_hook_ops *ops,struct xt_table **res); + +void ipt_unregister_table_pre_exit (struct net *net,struct xt_table *table, +const struct nf_hook_ops *ops); + +void ipt_unregister_table_exit (struct net *net,struct xt_table *table); +void ipt_unregister_table (struct net *net,struct xt_table *table,const struct nf_hook_ops *ops);
net/ipv4/netfilter/ip_tables.c +14 -1
@@ -1797,11 +1797,22 @@ int ipt_register_table(struct net *net, const struct xt_table *table,return ret; } +void ipt_unregister_table_pre_exit (struct net *net,struct xt_table *table, +const struct nf_hook_ops *ops) +{ +nf_unregister_net_hooks (net, ops,hweight32 (table->valid_hooks)); +} + +void ipt_unregister_table_exit (struct net *net,struct xt_table *table) +{ +__ipt_unregister_table (net, table); +} +void ipt_unregister_table (struct net *net,struct xt_table *table,const struct nf_hook_ops *ops) {if (ops) -nf_unregister_net_hooks (net, ops,hweight32 (table->valid_hooks)); +ipt_unregister_table_pre_exit (net, table, ops);__ipt_unregister_table (net, table); }
@@ -1958,6 +1969,8 @@ static void __exit ip_tables_fini(void)EXPORT_SYMBOL (ipt_register_table);EXPORT_SYMBOL (ipt_unregister_table); +EXPORT_SYMBOL (ipt_unregister_table_pre_exit); +EXPORT_SYMBOL (ipt_unregister_table_exit);EXPORT_SYMBOL (ipt_do_table);module_init (ip_tables_init);module_exit (ip_tables_fini);
Signature · 1 line
1.8.3.1
PATCH 2/4 netfilter: Add a .pre_exit hook in all iptable_foo.c.
In reply to David WilderUsing new helpers ipt_unregister_table_pre_exit() and ipt_unregister_table_exit().
--- net/ipv4/netfilter/iptable_filter.c | 10 +++++++++- net/ipv4/netfilter/iptable_mangle.c | 10 +++++++++- net/ipv4/netfilter/iptable_nat.c | 10 ++++++++-- net/ipv4/netfilter/iptable_raw.c | 10 +++++++++- net/ipv4/netfilter/iptable_security.c | 11 +++++++++-- 5 files changed, 44 insertions(+), 7 deletions(-)
net/ipv4/netfilter/iptable_filter.c +9 -1
@@ -72,16 +72,24 @@ static int __net_init iptable_filter_net_init(struct net *net)return 0 ; } +static void __net_exit iptable_filter_net_pre_exit(struct net *net) +{ +if (net->ipv4.iptable_filter) +ipt_unregister_table_pre_exit (net, net->ipv4.iptable_filter, + filter_ops); +} + static void __net_exit iptable_filter_net_exit(struct net *net) {if (!net->ipv4.iptable_filter)return ; -ipt_unregister_table (net, net->ipv4.iptable_filter, filter_ops); +ipt_unregister_table_exit (net, net->ipv4.iptable_filter); net->ipv4.iptable_filter =NULL ; }static struct pernet_operations iptable_filter_net_ops = { .init = iptable_filter_net_init, + .pre_exit = iptable_filter_net_pre_exit, .exit = iptable_filter_net_exit, };
net/ipv4/netfilter/iptable_mangle.c +9 -1
@@ -100,15 +100,23 @@ static int __net_init iptable_mangle_table_init(struct net *net)return ret; } +static void __net_exit iptable_mangle_net_pre_exit(struct net *net) +{ +if (net->ipv4.iptable_mangle) +ipt_unregister_table_pre_exit (net, net->ipv4.iptable_mangle, + mangle_ops); +} + static void __net_exit iptable_mangle_net_exit(struct net *net) {if (!net->ipv4.iptable_mangle)return ; -ipt_unregister_table (net, net->ipv4.iptable_mangle, mangle_ops); +ipt_unregister_table_exit (net, net->ipv4.iptable_mangle); net->ipv4.iptable_mangle =NULL ; }static struct pernet_operations iptable_mangle_net_ops = { + .pre_exit = iptable_mangle_net_pre_exit, .exit = iptable_mangle_net_exit, };
net/ipv4/netfilter/iptable_nat.c +8 -2
@@ -113,16 +113,22 @@ static int __net_init iptable_nat_table_init(struct net *net)return ret; } +static void __net_exit iptable_nat_net_pre_exit(struct net *net) +{ +if (net->ipv4.nat_table) +ipt_nat_unregister_lookups (net); +} + static void __net_exit iptable_nat_net_exit(struct net *net) {if (!net->ipv4.nat_table)return ; -ipt_nat_unregister_lookups (net); -ipt_unregister_table (net, net->ipv4.nat_table,NULL ); +ipt_unregister_table_exit (net, net->ipv4.nat_table); net->ipv4.nat_table =NULL ; }static struct pernet_operations iptable_nat_net_ops = { + .pre_exit = iptable_nat_net_pre_exit, .exit = iptable_nat_net_exit, };
net/ipv4/netfilter/iptable_raw.c +9 -1
@@ -67,15 +67,23 @@ static int __net_init iptable_raw_table_init(struct net *net)return ret; } +static void __net_exit iptable_raw_net_pre_exit(struct net *net) +{ +if (net->ipv4.iptable_raw) +ipt_unregister_table_pre_exit (net, net->ipv4.iptable_raw, + rawtable_ops); +} + static void __net_exit iptable_raw_net_exit(struct net *net) {if (!net->ipv4.iptable_raw)return ; -ipt_unregister_table (net, net->ipv4.iptable_raw, rawtable_ops); +ipt_unregister_table_exit (net, net->ipv4.iptable_raw); net->ipv4.iptable_raw =NULL ; }static struct pernet_operations iptable_raw_net_ops = { + .pre_exit = iptable_raw_net_pre_exit, .exit = iptable_raw_net_exit, };
net/ipv4/netfilter/iptable_security.c +9 -2
@@ -62,16 +62,23 @@ static int __net_init iptable_security_table_init(struct net *net)return ret; } +static void __net_exit iptable_security_net_pre_exit(struct net *net) +{ +if (net->ipv4.iptable_security) +ipt_unregister_table_pre_exit (net, net->ipv4.iptable_security, + sectbl_ops); +} + static void __net_exit iptable_security_net_exit(struct net *net) {if (!net->ipv4.iptable_security)return ; - -ipt_unregister_table (net, net->ipv4.iptable_security, sectbl_ops); +ipt_unregister_table_exit (net, net->ipv4.iptable_security); net->ipv4.iptable_security =NULL ; }static struct pernet_operations iptable_security_net_ops = { + .pre_exit = iptable_security_net_pre_exit, .exit = iptable_security_net_exit, };
Signature · 1 line
1.8.3.1
PATCH 3/4 netfilter: Split ip6t_unregister_table() into pre_exit and exit helpers.
In reply to David WilderThe pre_exit will un-register the underlying hook and .exit will do the table freeing. The netns core does an unconditional synchronize_rcu after the pre_exit hooks insuring no packets are in flight that have picked up the pointer before completing the un-register.
--- include/linux/netfilter_ipv6/ip6_tables.h | 3 +++ net/ipv6/netfilter/ip6_tables.c | 15 ++++++++++++++- 2 files changed, 17 insertions(+), 1 deletion(-)
include/linux/netfilter_ipv6/ip6_tables.h +3 -0
@@ -29,6 +29,9 @@ int ip6t_register_table(struct net *net, const struct xt_table *table, const struct nf_hook_ops *ops, struct xt_table **res);void ip6t_unregister_table (struct net *net,struct xt_table *table,const struct nf_hook_ops *ops); +void ip6t_unregister_table_pre_exit (struct net *net,struct xt_table *table, +const struct nf_hook_ops *ops); +void ip6t_unregister_table_exit (struct net *net,struct xt_table *table);extern unsigned int ip6t_do_table (struct sk_buff *skb,const struct nf_hook_state *state,struct xt_table *table);
net/ipv6/netfilter/ip6_tables.c +14 -1
@@ -1807,11 +1807,22 @@ int ip6t_register_table(struct net *net, const struct xt_table *table,return ret; } +void ip6t_unregister_table_pre_exit (struct net *net,struct xt_table *table, +const struct nf_hook_ops *ops) +{ +nf_unregister_net_hooks (net, ops,hweight32 (table->valid_hooks)); +} + +void ip6t_unregister_table_exit (struct net *net,struct xt_table *table) +{ +__ip6t_unregister_table (net, table); +} +void ip6t_unregister_table (struct net *net,struct xt_table *table,const struct nf_hook_ops *ops) {if (ops) -nf_unregister_net_hooks (net, ops,hweight32 (table->valid_hooks)); +ip6t_unregister_table_pre_exit (net, table, ops);__ip6t_unregister_table (net, table); }
@@ -1969,6 +1980,8 @@ static void __exit ip6_tables_fini(void)EXPORT_SYMBOL (ip6t_register_table);EXPORT_SYMBOL (ip6t_unregister_table); +EXPORT_SYMBOL (ip6t_unregister_table_pre_exit); +EXPORT_SYMBOL (ip6t_unregister_table_exit);EXPORT_SYMBOL (ip6t_do_table);module_init (ip6_tables_init);
Signature · 1 line
1.8.3.1
PATCH 4/4 netfilter: Add a .pre_exit hook in all ip6table_foo.c.
In reply to David WilderUsing new helpers ip6t_unregister_table_pre_exit() and ip6t_unregister_table_exit().
--- net/ipv6/netfilter/ip6table_filter.c | 10 +++++++++- net/ipv6/netfilter/ip6table_mangle.c | 10 +++++++++- net/ipv6/netfilter/ip6table_nat.c | 10 ++++++++-- net/ipv6/netfilter/ip6table_raw.c | 10 +++++++++- net/ipv6/netfilter/ip6table_security.c | 10 +++++++++- 5 files changed, 44 insertions(+), 6 deletions(-)
net/ipv6/netfilter/ip6table_filter.c +9 -1
@@ -73,16 +73,24 @@ static int __net_init ip6table_filter_net_init(struct net *net)return 0 ; } +static void __net_exit ip6table_filter_net_pre_exit(struct net *net) +{ +if (net->ipv6.ip6table_filter) +ip6t_unregister_table_pre_exit (net, net->ipv6.ip6table_filter, + filter_ops); +} + static void __net_exit ip6table_filter_net_exit(struct net *net) {if (!net->ipv6.ip6table_filter)return ; -ip6t_unregister_table (net, net->ipv6.ip6table_filter, filter_ops); +ip6t_unregister_table_exit (net, net->ipv6.ip6table_filter); net->ipv6.ip6table_filter =NULL ; }static struct pernet_operations ip6table_filter_net_ops = { .init = ip6table_filter_net_init, + .pre_exit = ip6table_filter_net_pre_exit, .exit = ip6table_filter_net_exit, };
net/ipv6/netfilter/ip6table_mangle.c +9 -1
@@ -93,16 +93,24 @@ static int __net_init ip6table_mangle_table_init(struct net *net)return ret; } +static void __net_exit ip6table_mangle_net_pre_exit(struct net *net) +{ +if (net->ipv6.ip6table_mangle) +ip6t_unregister_table_pre_exit (net, net->ipv6.ip6table_mangle, + mangle_ops); +} + static void __net_exit ip6table_mangle_net_exit(struct net *net) {if (!net->ipv6.ip6table_mangle)return ; -ip6t_unregister_table (net, net->ipv6.ip6table_mangle, mangle_ops); +ip6t_unregister_table_exit (net, net->ipv6.ip6table_mangle); net->ipv6.ip6table_mangle =NULL ; }static struct pernet_operations ip6table_mangle_net_ops = { + .pre_exit = ip6table_mangle_net_pre_exit, .exit = ip6table_mangle_net_exit, };
net/ipv6/netfilter/ip6table_nat.c +8 -2
@@ -114,16 +114,22 @@ static int __net_init ip6table_nat_table_init(struct net *net)return ret; } +static void __net_exit ip6table_nat_net_pre_exit(struct net *net) +{ +if (net->ipv6.ip6table_nat) +ip6t_nat_unregister_lookups (net); +} + static void __net_exit ip6table_nat_net_exit(struct net *net) {if (!net->ipv6.ip6table_nat)return ; -ip6t_nat_unregister_lookups (net); -ip6t_unregister_table (net, net->ipv6.ip6table_nat,NULL ); +ip6t_unregister_table_exit (net, net->ipv6.ip6table_nat); net->ipv6.ip6table_nat =NULL ; }static struct pernet_operations ip6table_nat_net_ops = { + .pre_exit = ip6table_nat_net_pre_exit, .exit = ip6table_nat_net_exit, };
net/ipv6/netfilter/ip6table_raw.c +9 -1
@@ -66,15 +66,23 @@ static int __net_init ip6table_raw_table_init(struct net *net)return ret; } +static void __net_exit ip6table_raw_net_pre_exit(struct net *net) +{ +if (net->ipv6.ip6table_raw) +ip6t_unregister_table_pre_exit (net, net->ipv6.ip6table_raw, + rawtable_ops); +} + static void __net_exit ip6table_raw_net_exit(struct net *net) {if (!net->ipv6.ip6table_raw)return ; -ip6t_unregister_table (net, net->ipv6.ip6table_raw, rawtable_ops); +ip6t_unregister_table_exit (net, net->ipv6.ip6table_raw); net->ipv6.ip6table_raw =NULL ; }static struct pernet_operations ip6table_raw_net_ops = { + .pre_exit = ip6table_raw_net_pre_exit, .exit = ip6table_raw_net_exit, };
net/ipv6/netfilter/ip6table_security.c +9 -1
@@ -61,15 +61,23 @@ static int __net_init ip6table_security_table_init(struct net *net)return ret; } +static void __net_exit ip6table_security_net_pre_exit(struct net *net) +{ +if (net->ipv6.ip6table_security) +ip6t_unregister_table_pre_exit (net, net->ipv6.ip6table_security, + sectbl_ops); +} + static void __net_exit ip6table_security_net_exit(struct net *net) {if (!net->ipv6.ip6table_security)return ; -ip6t_unregister_table (net, net->ipv6.ip6table_security, sectbl_ops); +ip6t_unregister_table_exit (net, net->ipv6.ip6table_security); net->ipv6.ip6table_security =NULL ; }static struct pernet_operations ip6table_security_net_ops = { + .pre_exit = ip6table_security_net_pre_exit, .exit = ip6table_security_net_exit, };
Signature · 1 line
1.8.3.1
Pablo Neira Ayuso
maintainerQuoted 11 lines · David Wilder
A crash happened on ppc64le when running ltp network tests triggered by "rmmod
iptable_mangle".See previous discussion in this thread: https://lists.openwall.net/netdev/2020/06/03/161 .
In the crash I found in
iptable_mangle_hook()that state->net->ipv4.iptable_mangle=NULL causing a NULL pointer dereference.net->ipv4.iptable_mangleis set to NULL iniptable_mangle_net_exit()and called whenip_manglemodules is unloaded. A rmmod task was found running in the crash dump. A 2nd crash showed the same problem when running "rmmodiptable_filter" (net->ipv4.iptable_filter=NULL).To fix this I added .pre_exit hook in all
iptable_foo.c. Thepre_exitwill un-register the underlying hook and exit would do the table freeing. The netns core does an unconditionalsynchronize_rcuafter thepre_exithooks insuring no packets are in flight that have picked up the pointer before completing the un-register.These patches include changes for both iptables and ip6tables.
We tested this fix with ltp running
iptables01.shandiptables01.sh-6 a loop for 72 hours.
Series applied, thanks.