fix validation of jumps
Florian Westphal
maintainerThe various stable kernels suffer from one of the following problems:
- They don't have 36472341017529e ("netfilter: x_tables: validate targets of jumps"). In that case there is no validation which is problematic with unpriv netns support or when using unprivileged containers.
- They have a faulty backport of this commit and xtables is completely broken (kernel freeze since we iterate over random memory contents). This affects current 3.18.y and 4.1.y kernels for example.
- They have a correct backport of this commit, which causes problems with large rulesets (depending on machine, 1k or more; but even on fast machines rulesets with more than 10k rules cause softlockup during iptables-restore and friends).
These patches all contain the same backport but amended so it applies to the indicated stable branch.
For 3.12:
- adjust for extra debug printks and lack of 36472341017529e. (The 36472341017529e commit is superseded by this).
For 3.14:
- adjust for extra debug printks and lack of kvfree. This backport is only needed to speed up rule validation.
For 3.18:
- adjust for extra debug printks and broken 36472341017529e backport. This backport is needed to make xtables work, we currently walk over random memory content so any iptables -A ... command will either fail or lock up.
For 4.1.y: same as 3.18.
For 4.4: Same as 3.14 -- backport is only needed to speed up ruleset validtion.
The 4.4 backport will also apply to the 4.6.y tree.
I briefly tested all the kernels with these patches applied and the large dummy ruleset from the commit message.
Florian Westphal
maintainerPATCH 1/1 netfilter: x_tables: speed up jump target validation
[ Upstream commit f4dc77713f8016d2e8a3295e1c9c53a21f296def ]
The dummy ruleset I used to test the original validation change was broken, most rules were unreachable and were not tested by mark_source_chains().
In some cases rulesets that used to load in a few seconds now require several minutes.
sample ruleset that shows the behaviour:
echo "*filter"
for i in $(seq 0 100000);do
printf ":chain_%06x - [0:0]\n" $i
done
for i in $(seq 0 100000);do
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
done
echo COMMIT
[ pipe result into iptables-restore ]
This ruleset will be about 74mbyte in size, with ~500k searches though all 500k[1] rule entries. iptables-restore will take forever (gave up after 10 minutes)
Instead of always searching the entire blob for a match, fill an array with the start offsets of every single ipt_entry struct, then do a binary search to check if the jump target is present or not.
After this change ruleset restore times get again close to what one gets when reverting 36472341017529e (~3 seconds on my workstation).
[1] every user-defined rule gets an implicit RETURN, so we get 300k jumps + 100k userchains + 100k returns -> 500k rule entries
--- include/linux/netfilter/x_tables.h | 4 +++ net/ipv4/netfilter/arp_tables.c | 47 +++++++++++++++++------------------ net/ipv4/netfilter/ip_tables.c | 45 ++++++++++++++++++---------------- net/ipv6/netfilter/ip6_tables.c | 45 ++++++++++++++++++---------------- net/netfilter/x_tables.c | 50 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 126 insertions(+), 65 deletions(-)
include/linux/netfilter/x_tables.h +4 -0
@@ -243,6 +243,10 @@ int xt_check_entry_offsets(const void *base, const char *elems,unsigned int target_offset, unsigned int next_offset); +unsigned int *xt_alloc_entry_offsets (unsigned int size); +bool xt_find_jump_offset (const unsigned int *offsets, +unsigned int target,unsigned int size); +int xt_check_match (struct xt_mtchk_param *,unsigned int size,u_int8_t proto,bool inv_proto); int xt_check_target(struct xt_tgchk_param *, unsigned int size, u_int8_t proto,
net/ipv4/netfilter/arp_tables.c +24 -23
112 lines not on this page · raw message
net/ipv4/netfilter/ip_tables.c +24 -21
109 lines not on this page · raw message
net/ipv6/netfilter/ip6_tables.c +24 -21
109 lines not on this page · raw message
net/netfilter/x_tables.c +50 -0
56 lines not on this page · raw message
Signature · 1 line
2.7.3
Re: [PATCH -stable 4.1.y] netfilter: x_tables: speed up jump target validation
Quoted 34 lines · Florian Westphal
[ Upstream commit
f4dc77713f8016d2e8a3295e1c9c53a21f296def]The dummy ruleset I used to test the original validation change was broken, most rules were unreachable and were not tested by
mark_source_chains().In some cases rulesets that used to load in a few seconds now require several minutes.
sample ruleset that shows the behaviour:
echo "*filter"
for i in $(seq 0 100000);doprintf ":chain_%06x - [0:0]\n" $idone
for i in $(seq 0 100000);do
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
done
echo COMMIT[ pipe result into iptables-restore ]
This ruleset will be about 74mbyte in size, with ~500k searches though all 500k[1] rule entries. iptables-restore will take forever (gave up after 10 minutes)
Instead of always searching the entire blob for a match, fill an array with the start offsets of every single
ipt_entrystruct, then do a binary search to check if the jump target is present or not.After this change ruleset restore times get again close to what one gets when reverting
36472341017529e(~3 seconds on my workstation).
Quoted 8 lines
[1] every user-defined rule gets an implicit RETURN, so we get 300k jumps + 100k userchains + 100k returns -> 500k rule entries
Fixes 36472341017529e ("netfilter: x_tables: validate targets of jumps")Reported-by Jeff Wu <[email protected]>Tested-by Jeff Wu <[email protected]>Signed-off-by Florian Westphal <[email protected]>Signed-off-by Pablo Neira Ayuso <[email protected]>
Hi Florian,
This patch doesn't seem to apply on 4.1, does it have any dependencies that don't currently exist in the tree?
Thanks,
Sasha
Florian Westphal
maintainerRe: [PATCH -stable 4.1.y] netfilter: x_tables: speed up jump target validation
Quoted 44 lines · Alexander
Quoted 34 lines · Florian Westphal
[ Upstream commit
f4dc77713f8016d2e8a3295e1c9c53a21f296def]The dummy ruleset I used to test the original validation change was broken, most rules were unreachable and were not tested by
mark_source_chains().In some cases rulesets that used to load in a few seconds now require several minutes.
sample ruleset that shows the behaviour:
echo "*filter"
for i in $(seq 0 100000);doprintf ":chain_%06x - [0:0]\n" $idone
for i in $(seq 0 100000);do
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
done
echo COMMIT[ pipe result into iptables-restore ]
This ruleset will be about 74mbyte in size, with ~500k searches though all 500k[1] rule entries. iptables-restore will take forever (gave up after 10 minutes)
Instead of always searching the entire blob for a match, fill an array with the start offsets of every single
ipt_entrystruct, then do a binary search to check if the jump target is present or not.After this change ruleset restore times get again close to what one gets when reverting
36472341017529e(~3 seconds on my workstation).Quoted 8 lines
[1] every user-defined rule gets an implicit RETURN, so we get 300k jumps + 100k userchains + 100k returns -> 500k rule entries
Fixes 36472341017529e ("netfilter: x_tables: validate targets of jumps")Reported-by Jeff Wu <[email protected]>Tested-by Jeff Wu <[email protected]>Signed-off-by Florian Westphal <[email protected]>Signed-off-by Pablo Neira Ayuso <[email protected]>
Quoted 4 lines
Hi Florian,
This patch doesn't seem to apply on 4.1, does it have any dependencies that don't currently exist in the tree?
I tried to apply it on top of c3ed55b836cff71 (4.1.29) and git-am worked without issues.
What is the problem?
Re: [PATCH -stable 4.1.y] netfilter: x_tables: speed up jump target validation
Quoted 47 lines · Florian Westphal
Quoted 46 lines · Alexander
Quoted 34 lines · Florian Westphal
[ Upstream commit
f4dc77713f8016d2e8a3295e1c9c53a21f296def]The dummy ruleset I used to test the original validation change was broken, most rules were unreachable and were not tested by
mark_source_chains().In some cases rulesets that used to load in a few seconds now require several minutes.
sample ruleset that shows the behaviour:
echo "*filter"
for i in $(seq 0 100000);doprintf ":chain_%06x - [0:0]\n" $idone
for i in $(seq 0 100000);do
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
done
echo COMMIT[ pipe result into iptables-restore ]
This ruleset will be about 74mbyte in size, with ~500k searches though all 500k[1] rule entries. iptables-restore will take forever (gave up after 10 minutes)
Instead of always searching the entire blob for a match, fill an array with the start offsets of every single
ipt_entrystruct, then do a binary search to check if the jump target is present or not.After this change ruleset restore times get again close to what one gets when reverting
36472341017529e(~3 seconds on my workstation).Quoted 8 lines
[1] every user-defined rule gets an implicit RETURN, so we get 300k jumps + 100k userchains + 100k returns -> 500k rule entries
Fixes 36472341017529e ("netfilter: x_tables: validate targets of jumps")Reported-by Jeff Wu <[email protected]>Tested-by Jeff Wu <[email protected]>Signed-off-by Florian Westphal <[email protected]>Signed-off-by Pablo Neira Ayuso <[email protected]>Hi Florian,
Quoted 7 lines
Quoted 2 lines
This patch doesn't seem to apply on 4.1, does it have any dependencies that don't currently exist in the tree?
I tried to apply it on top of
c3ed55b836cff71(4.1.29) and git-am worked without issues.What is the problem?
Hm, looks like the mail has spaces instead of tabs.
Thanks,
Sasha
Florian Westphal
maintainerPATCH 1/1 netfilter: x_tables: speed up jump target validation
In reply to Florian Westphal[ Upstream commit f4dc77713f8016d2e8a3295e1c9c53a21f296def ]
The dummy ruleset I used to test the original validation change was broken, most rules were unreachable and were not tested by mark_source_chains().
In some cases rulesets that used to load in a few seconds now require several minutes.
sample ruleset that shows the behaviour:
echo "*filter"
for i in $(seq 0 100000);do
printf ":chain_%06x - [0:0]\n" $i
done
for i in $(seq 0 100000);do
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
done
echo COMMIT
[ pipe result into iptables-restore ]
This ruleset will be about 74mbyte in size, with ~500k searches though all 500k[1] rule entries. iptables-restore will take forever (gave up after 10 minutes)
Instead of always searching the entire blob for a match, fill an array with the start offsets of every single ipt_entry struct, then do a binary search to check if the jump target is present or not.
After this change ruleset restore times get again close to what one gets when reverting 36472341017529e (~3 seconds on my workstation).
[1] every user-defined rule gets an implicit RETURN, so we get 300k jumps + 100k userchains + 100k returns -> 500k rule entries
--- include/linux/netfilter/x_tables.h | 4 +++ net/ipv4/netfilter/arp_tables.c | 48 ++++++++++++++++++------------------ net/ipv4/netfilter/ip_tables.c | 45 ++++++++++++++++++---------------- net/ipv6/netfilter/ip6_tables.c | 45 ++++++++++++++++++---------------- net/netfilter/x_tables.c | 50 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 127 insertions(+), 65 deletions(-)
include/linux/netfilter/x_tables.h +4 -0
@@ -243,6 +243,10 @@ int xt_check_entry_offsets(const void *base, const char *elems,unsigned int target_offset, unsigned int next_offset); +unsigned int *xt_alloc_entry_offsets (unsigned int size); +bool xt_find_jump_offset (const unsigned int *offsets, +unsigned int target,unsigned int size); +int xt_check_match (struct xt_mtchk_param *,unsigned int size,u_int8_t proto,bool inv_proto); int xt_check_target(struct xt_tgchk_param *, unsigned int size, u_int8_t proto,
net/ipv4/netfilter/arp_tables.c +25 -23
114 lines not on this page · raw message
net/ipv4/netfilter/ip_tables.c +24 -21
109 lines not on this page · raw message
net/ipv6/netfilter/ip6_tables.c +24 -21
109 lines not on this page · raw message
net/netfilter/x_tables.c +50 -0
56 lines not on this page · raw message
Signature · 1 line
2.7.3
Florian Westphal
maintainerPATCH 1/1 netfilter: x_tables: speed up jump target validation
In reply to Florian Westphal[ Upstream commit f4dc77713f8016d2e8a3295e1c9c53a21f296def ]
The dummy ruleset I used to test the original validation change was broken, most rules were unreachable and were not tested by mark_source_chains().
In some cases rulesets that used to load in a few seconds now require several minutes.
sample ruleset that shows the behaviour:
echo "*filter"
for i in $(seq 0 100000);do
printf ":chain_%06x - [0:0]\n" $i
done
for i in $(seq 0 100000);do
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
done
echo COMMIT
[ pipe result into iptables-restore ]
This ruleset will be about 74mbyte in size, with ~500k searches though all 500k[1] rule entries. iptables-restore will take forever (gave up after 10 minutes)
Instead of always searching the entire blob for a match, fill an array with the start offsets of every single ipt_entry struct, then do a binary search to check if the jump target is present or not.
After this change ruleset restore times get again close to what one gets when reverting 36472341017529e (~3 seconds on my workstation).
[1] every user-defined rule gets an implicit RETURN, so we get 300k jumps + 100k userchains + 100k returns -> 500k rule entries
--- include/linux/netfilter/x_tables.h | 4 +++ net/ipv4/netfilter/arp_tables.c | 59 ++++++++++++++++++++++---------------- net/ipv4/netfilter/ip_tables.c | 55 +++++++++++++++++++++-------------- net/ipv6/netfilter/ip6_tables.c | 54 ++++++++++++++++++++-------------- net/netfilter/x_tables.c | 50 ++++++++++++++++++++++++++++++++ 5 files changed, 154 insertions(+), 68 deletions(-)
include/linux/netfilter/x_tables.h +4 -0
@@ -248,6 +248,10 @@ int xt_check_match(struct xt_mtchk_param *, unsigned int size, u_int8_t proto,int xt_check_target (struct xt_tgchk_param *,unsigned int size,u_int8_t proto,bool inv_proto); +unsigned int *xt_alloc_entry_offsets (unsigned int size); +bool xt_find_jump_offset (const unsigned int *offsets, +unsigned int target,unsigned int size); +void *xt_copy_counters_from_user (const void __user *user,unsigned int len,struct xt_counters_info *info,bool compat);
net/ipv4/netfilter/arp_tables.c +35 -24
131 lines not on this page · raw message
net/ipv4/netfilter/ip_tables.c +33 -22
125 lines not on this page · raw message
net/ipv6/netfilter/ip6_tables.c +32 -22
124 lines not on this page · raw message
net/netfilter/x_tables.c +50 -0
56 lines not on this page · raw message
Signature · 1 line
2.7.3
Florian Westphal
maintainerPATCH 1/1 netfilter: x_tables: speed up jump target validation
In reply to Florian Westphal[ Upstream commit f4dc77713f8016d2e8a3295e1c9c53a21f296def ]
The dummy ruleset I used to test the original validation change was broken, most rules were unreachable and were not tested by mark_source_chains().
In some cases rulesets that used to load in a few seconds now require several minutes.
sample ruleset that shows the behaviour:
echo "*filter"
for i in $(seq 0 100000);do
printf ":chain_%06x - [0:0]\n" $i
done
for i in $(seq 0 100000);do
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
done
echo COMMIT
[ pipe result into iptables-restore ]
This ruleset will be about 74mbyte in size, with ~500k searches though all 500k[1] rule entries. iptables-restore will take forever (gave up after 10 minutes)
Instead of always searching the entire blob for a match, fill an array with the start offsets of every single ipt_entry struct, then do a binary search to check if the jump target is present or not.
After this change ruleset restore times get again close to what one gets when reverting 36472341017529e (~3 seconds on my workstation).
[1] every user-defined rule gets an implicit RETURN, so we get 300k jumps + 100k userchains + 100k returns -> 500k rule entries
--- include/linux/netfilter/x_tables.h | 4 +++ net/ipv4/netfilter/arp_tables.c | 48 ++++++++++++++++++------------------ net/ipv4/netfilter/ip_tables.c | 45 ++++++++++++++++++---------------- net/ipv6/netfilter/ip6_tables.c | 45 ++++++++++++++++++---------------- net/netfilter/x_tables.c | 50 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 127 insertions(+), 65 deletions(-)
include/linux/netfilter/x_tables.h +4 -0
@@ -243,6 +243,10 @@ int xt_check_entry_offsets(const void *base, const char *elems,unsigned int target_offset, unsigned int next_offset); +unsigned int *xt_alloc_entry_offsets (unsigned int size); +bool xt_find_jump_offset (const unsigned int *offsets, +unsigned int target,unsigned int size); +int xt_check_match (struct xt_mtchk_param *,unsigned int size,u_int8_t proto,bool inv_proto); int xt_check_target(struct xt_tgchk_param *, unsigned int size, u_int8_t proto,
net/ipv4/netfilter/arp_tables.c +25 -23
112 lines not on this page · raw message
net/ipv4/netfilter/ip_tables.c +24 -21
109 lines not on this page · raw message
net/ipv6/netfilter/ip6_tables.c +24 -21
109 lines not on this page · raw message
net/netfilter/x_tables.c +50 -0
56 lines not on this page · raw message
Signature · 1 line
2.7.3
Florian Westphal
maintainerPATCH 1/1 netfilter: x_tables: speed up jump target validation
In reply to Florian Westphal[ Upstream commit f4dc77713f8016d2e8a3295e1c9c53a21f296def ]
The dummy ruleset I used to test the original validation change was broken, most rules were unreachable and were not tested by mark_source_chains().
In some cases rulesets that used to load in a few seconds now require several minutes.
sample ruleset that shows the behaviour:
echo "*filter"
for i in $(seq 0 100000);do
printf ":chain_%06x - [0:0]\n" $i
done
for i in $(seq 0 100000);do
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
done
echo COMMIT
[ pipe result into iptables-restore ]
This ruleset will be about 74mbyte in size, with ~500k searches though all 500k[1] rule entries. iptables-restore will take forever (gave up after 10 minutes)
Instead of always searching the entire blob for a match, fill an array with the start offsets of every single ipt_entry struct, then do a binary search to check if the jump target is present or not.
After this change ruleset restore times get again close to what one gets when reverting 36472341017529e (~3 seconds on my workstation).
[1] every user-defined rule gets an implicit RETURN, so we get 300k jumps + 100k userchains + 100k returns -> 500k rule entries
--- include/linux/netfilter/x_tables.h | 4 +++ net/ipv4/netfilter/arp_tables.c | 39 ++++++++++++++++++++++------- net/ipv4/netfilter/ip_tables.c | 34 ++++++++++++++++++++------ net/ipv6/netfilter/ip6_tables.c | 33 +++++++++++++++++++------ net/netfilter/x_tables.c | 50 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 137 insertions(+), 23 deletions(-)
include/linux/netfilter/x_tables.h +4 -0
@@ -243,6 +243,10 @@ int xt_check_entry_offsets(const void *base, const char *elems,unsigned int target_offset, unsigned int next_offset); +unsigned int *xt_alloc_entry_offsets (unsigned int size); +bool xt_find_jump_offset (const unsigned int *offsets, +unsigned int target,unsigned int size); +extern int xt_check_match (struct xt_mtchk_param *,unsigned int size,u_int8_t proto,bool inv_proto); extern int xt_check_target(struct xt_tgchk_param *,
net/ipv4/netfilter/arp_tables.c +30 -9
@@ -362,7 +362,8 @@ static inline bool unconditional(const struct arpt_entry *e)* there are loops. Puts hook bitmask in comefrom. */ static int mark_source_chains (const struct xt_table_info *newinfo, -unsigned int valid_hooks,void *entry0) +unsigned int valid_hooks,void *entry0, +unsigned int *offsets) {unsigned int hook;
@@ -451,6 +452,11 @@ static int mark_source_chains(const struct xt_table_info *newinfo,/* This a jump; chase it. */ duprintf ("Jump rule %u -> %u\n" , pos, newpos); +if (!xt_find_jump_offset (offsets, newpos, + newinfo->number)) +return 0 ; + e = (struct arpt_entry *) + (entry0 + newpos); }else {/* ... this is a fallthru */ newpos = pos + e->next_offset;
@@ -610,6 +616,7 @@ static int translate_table(struct xt_table_info *newinfo, void *entry0, const struct arpt_replace *repl) {struct arpt_entry *iter; +unsigned int *offsets;unsigned int i;int ret =0 ;
@@ -623,8 +630,12 @@ static int translate_table(struct xt_table_info *newinfo, void *entry0, }duprintf ("translate_table: size %u\n" , newinfo->size); - i =0 ; + offsets =xt_alloc_entry_offsets (newinfo->number); +if (!offsets) +return -ENOMEM ; + + i =0 ;/* Walk through entries, checking offsets. */ xt_entry_foreach(iter, entry0, newinfo->size) { ret = check_entry_size_and_hooks(iter, newinfo, entry0,
@@ -633,7 +644,9 @@ static int translate_table(struct xt_table_info *newinfo, void *entry0, repl->underflow, repl->valid_hooks);if (ret !=0 ) -break ; + goto out_free; +if (i < repl->num_entries) + offsets[i] = (void *)iter - entry0; ++i;if (strcmp (arpt_get_target (iter)->u.user.name,XT_ERROR_TARGET ) ==0 )
@@ -641,12 +654,13 @@ static int translate_table(struct xt_table_info *newinfo, void *entry0, }duprintf ("translate_table: ARPT_ENTRY_ITERATE gives %d\n" , ret);if (ret !=0 ) -return ret; + goto out_free; + ret = -EINVAL ;if (i != repl->num_entries) {duprintf ("translate_table: %u not %u entries\n" , i, repl->num_entries); -return -EINVAL ; + goto out_free; }/* Check hooks all assigned */
@@ -654,20 +668,24 @@ static int translate_table(struct xt_table_info *newinfo, void *entry0,/* Only hooks which are valid */ if (!(repl->valid_hooks & (1 << i)))continue ; +if (newinfo->hook_entry[i] ==0xFFFFFFFF ) {duprintf ("Invalid hook entry %u %u\n" , i, repl->hook_entry[i]); -return -EINVAL ; + goto out_free; }if (newinfo->underflow[i] ==0xFFFFFFFF ) {duprintf ("Invalid underflow %u %u\n" , i, repl->underflow[i]); -return -EINVAL ; + goto out_free; } } -if (!mark_source_chains (newinfo, repl->valid_hooks, entry0)) -return -ELOOP ; +if (!mark_source_chains (newinfo, repl->valid_hooks, entry0, offsets)) { + ret = -ELOOP ; + goto out_free; + } +kvfree (offsets);/* Finally, each sanity check must pass */ i =0 ;
@@ -694,6 +712,9 @@ static int translate_table(struct xt_table_info *newinfo, void *entry0, }return ret; + out_free: +kvfree (offsets); +return ret; } static void get_counters(const struct xt_table_info *t,
net/ipv4/netfilter/ip_tables.c +27 -7
@@ -438,7 +438,8 @@ ipt_do_table(struct sk_buff *skb,there are loops. Puts hook bitmask in comefrom. */ static int mark_source_chains (const struct xt_table_info *newinfo, -unsigned int valid_hooks,void *entry0) +unsigned int valid_hooks,void *entry0, +unsigned int *offsets) {unsigned int hook;
@@ -531,6 +532,11 @@ mark_source_chains(const struct xt_table_info *newinfo,/* This a jump; chase it. */ duprintf ("Jump rule %u -> %u\n" , pos, newpos); +if (!xt_find_jump_offset (offsets, newpos, + newinfo->number)) +return 0 ; + e = (struct ipt_entry *) + (entry0 + newpos); }else {/* ... this is a fallthru */ newpos = pos + e->next_offset;
@@ -777,6 +783,7 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0, const struct ipt_replace *repl) {struct ipt_entry *iter; +unsigned int *offsets;unsigned int i;int ret =0 ;
@@ -790,6 +797,10 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0, }duprintf ("translate_table: size %u\n" , newinfo->size); + + offsets =xt_alloc_entry_offsets (newinfo->number); +if (!offsets) +return -ENOMEM ; i =0 ;/* Walk through entries, checking offsets. */ xt_entry_foreach(iter, entry0, newinfo->size) {
@@ -799,17 +810,20 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0, repl->underflow, repl->valid_hooks);if (ret !=0 ) -return ret; + goto out_free; +if (i < repl->num_entries) + offsets[i] = (void *)iter - entry0; ++i;if (strcmp (ipt_get_target (iter)->u.user.name,XT_ERROR_TARGET ) ==0 ) ++newinfo->stacksize; } + ret = -EINVAL ;if (i != repl->num_entries) {duprintf ("translate_table: %u not %u entries\n" , i, repl->num_entries); -return -EINVAL ; + goto out_free; }/* Check hooks all assigned */
@@ -820,17 +834,20 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0,if (newinfo->hook_entry[i] ==0xFFFFFFFF ) {duprintf ("Invalid hook entry %u %u\n" , i, repl->hook_entry[i]); -return -EINVAL ; + goto out_free; }if (newinfo->underflow[i] ==0xFFFFFFFF ) {duprintf ("Invalid underflow %u %u\n" , i, repl->underflow[i]); -return -EINVAL ; + goto out_free; } } -if (!mark_source_chains (newinfo, repl->valid_hooks, entry0)) -return -ELOOP ; +if (!mark_source_chains (newinfo, repl->valid_hooks, entry0, offsets)) { + ret = -ELOOP ; + goto out_free; + } +kvfree (offsets);/* Finally, each sanity check must pass */ i =0 ;
@@ -857,6 +874,9 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0, }return ret; + out_free: +kvfree (offsets); +return ret; } static void
net/ipv6/netfilter/ip6_tables.c +26 -7
@@ -448,7 +448,8 @@ ip6t_do_table(struct sk_buff *skb,there are loops. Puts hook bitmask in comefrom. */ static int mark_source_chains (const struct xt_table_info *newinfo, -unsigned int valid_hooks,void *entry0) +unsigned int valid_hooks,void *entry0, +unsigned int *offsets) {unsigned int hook;
@@ -541,6 +542,11 @@ mark_source_chains(const struct xt_table_info *newinfo,/* This a jump; chase it. */ duprintf ("Jump rule %u -> %u\n" , pos, newpos); +if (!xt_find_jump_offset (offsets, newpos, + newinfo->number)) +return 0 ; + e = (struct ip6t_entry *) + (entry0 + newpos); }else {/* ... this is a fallthru */ newpos = pos + e->next_offset;
@@ -787,6 +793,7 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0, const struct ip6t_replace *repl) {struct ip6t_entry *iter; +unsigned int *offsets;unsigned int i;int ret =0 ;
@@ -800,6 +807,9 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0, }duprintf ("translate_table: size %u\n" , newinfo->size); + offsets =xt_alloc_entry_offsets (newinfo->number); +if (!offsets) +return -ENOMEM ; i =0 ;/* Walk through entries, checking offsets. */ xt_entry_foreach(iter, entry0, newinfo->size) {
@@ -809,17 +819,20 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0, repl->underflow, repl->valid_hooks);if (ret !=0 ) -return ret; + goto out_free; +if (i < repl->num_entries) + offsets[i] = (void *)iter - entry0; ++i;if (strcmp (ip6t_get_target (iter)->u.user.name,XT_ERROR_TARGET ) ==0 ) ++newinfo->stacksize; } + ret = -EINVAL ;if (i != repl->num_entries) {duprintf ("translate_table: %u not %u entries\n" , i, repl->num_entries); -return -EINVAL ; + goto out_free; }/* Check hooks all assigned */
@@ -830,17 +843,20 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0,if (newinfo->hook_entry[i] ==0xFFFFFFFF ) {duprintf ("Invalid hook entry %u %u\n" , i, repl->hook_entry[i]); -return -EINVAL ; + goto out_free; }if (newinfo->underflow[i] ==0xFFFFFFFF ) {duprintf ("Invalid underflow %u %u\n" , i, repl->underflow[i]); -return -EINVAL ; + goto out_free; } } -if (!mark_source_chains (newinfo, repl->valid_hooks, entry0)) -return -ELOOP ; +if (!mark_source_chains (newinfo, repl->valid_hooks, entry0, offsets)) { + ret = -ELOOP ; + goto out_free; + } +kvfree (offsets);/* Finally, each sanity check must pass */ i =0 ;
@@ -867,6 +883,9 @@ translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0, }return ret; + out_free: +kvfree (offsets); +return ret; } static void
net/netfilter/x_tables.c +50 -0
56 lines not on this page · raw message
Signature · 1 line
2.7.3