| Dir : /proc/self/root/opt/saltstack/salt/lib/python3.10/site-packages/salt/modules/ |
| Server: Linux ngx353.inmotionhosting.com 4.18.0-553.22.1.lve.1.el8.x86_64 #1 SMP Tue Oct 8 15:52:54 UTC 2024 x86_64 IP: 209.182.202.254 |
| Dir : //proc/self/root/opt/saltstack/salt/lib/python3.10/site-packages/salt/modules/iptables.py |
"""
Support for iptables
Configuration Options
---------------------
The following options can be set in the minion config, grains, pillar, or
master config. The configuration is read using :py:func:`config.get
<salt.modules.config.get>`.
- ``iptables.save_filters``: List of REGEX strings to FILTER OUT matching lines
This is useful for filtering out chains, rules, etc that you do not wish to
persist, such as ephemeral Docker rules.
The default is to not filter out anything.
.. code-block:: yaml
iptables.save_filters:
- "-j CATTLE_PREROUTING"
- "-j DOCKER"
- "-A POSTROUTING"
- "-A CATTLE_POSTROUTING"
- "-A FORWARD"
"""
import argparse
import logging
import os
import re
import string
import uuid
import salt.utils.args
import salt.utils.files
import salt.utils.path
from salt.exceptions import SaltException
from salt.state import STATE_INTERNAL_KEYWORDS as _STATE_INTERNAL_KEYWORDS
log = logging.getLogger(__name__)
def __virtual__():
"""
Only load the module if iptables is installed
"""
if not salt.utils.path.which("iptables"):
return (
False,
"The iptables execution module cannot be loaded: iptables not installed.",
)
return True
def _iptables_cmd(family="ipv4"):
"""
Return correct command based on the family, e.g. ipv4 or ipv6
"""
if family == "ipv6":
return salt.utils.path.which("ip6tables")
else:
return salt.utils.path.which("iptables")
def _has_option(option, family="ipv4"):
"""
Return truth of whether iptables has `option`. For example:
.. code-block:: python
_has_option('--wait')
_has_option('--check', family='ipv6')
"""
cmd = f"{_iptables_cmd(family)} --help"
if option in __salt__["cmd.run_stdout"](cmd, output_loglevel="quiet"):
return True
return False
def _conf(family="ipv4"):
"""
Some distros have a specific location for config files
"""
if __grains__["os_family"] == "RedHat":
if family == "ipv6":
return "/etc/sysconfig/ip6tables"
else:
return "/etc/sysconfig/iptables"
elif __grains__["os_family"] == "Arch":
if family == "ipv6":
return "/etc/iptables/ip6tables.rules"
else:
return "/etc/iptables/iptables.rules"
elif __grains__["os_family"] == "Debian":
# This assumes the iptables-persistent package is installed
if family == "ipv6":
return "/etc/iptables/rules.v6"
else:
return "/etc/iptables/rules.v4"
elif __grains__["os"] == "Gentoo":
if family == "ipv6":
return "/var/lib/ip6tables/rules-save"
else:
return "/var/lib/iptables/rules-save"
elif __grains__["os_family"] == "Suse":
# SuSE does not seem to use separate files for IPv4 and IPv6
return "/etc/sysconfig/scripts/SuSEfirewall2-custom"
elif __grains__["os_family"] == "Void":
if family == "ipv4":
return "/etc/iptables/iptables.rules"
else:
return "/etc/iptables/ip6tables.rules"
elif __grains__["os"] == "Alpine":
if family == "ipv6":
return "/etc/iptables/rules6-save"
else:
return "/etc/iptables/rules-save"
elif __grains__["os_family"] == "NILinuxRT":
if family == "ipv6":
return "/etc/natinst/share/ip6tables.conf"
else:
return "/etc/natinst/share/iptables.conf"
else:
raise SaltException(
"Saving iptables to file is not"
+ " supported on {}.".format(__grains__["os"])
+ " Please file an issue with SaltStack"
)
def _conf_save_filters():
"""
Return array of strings from `save_filters` in config.
This array will be pulled from minion config, minion grains,
minion pillar, or master config. The default value returned is [].
.. code-block:: python
_conf_save_filters()
"""
config = __salt__["config.option"]("iptables.save_filters", [])
return config
def _regex_iptables_save(cmd_output, filters=None):
"""
Return string with `save_filter` regex entries removed. For example:
If `filters` is not provided, it will be pulled from minion config,
minion grains, minion pillar, or master config. Default return value
if no filters found is the original cmd_output string.
.. code-block:: python
_regex_iptables_save(cmd_output, ['-A DOCKER*'])
"""
# grab RE compiled filters from context for performance
if "iptables.save_filters" not in __context__:
__context__["iptables.save_filters"] = []
for pattern in filters or _conf_save_filters():
try:
__context__["iptables.save_filters"].append(re.compile(pattern))
except re.error as e:
log.warning("Skipping regex rule: '%s': %s", pattern, e)
continue
if __context__["iptables.save_filters"]:
# line by line get rid of any regex matches
_filtered_cmd_output = [
line
for line in cmd_output.splitlines(True)
if not any(reg.search(line) for reg in __context__["iptables.save_filters"])
]
return "".join(_filtered_cmd_output)
return cmd_output
def version(family="ipv4"):
"""
Return version from iptables --version
CLI Example:
.. code-block:: bash
salt '*' iptables.version
IPv6:
salt '*' iptables.version family=ipv6
"""
cmd = f"{_iptables_cmd(family)} --version"
out = __salt__["cmd.run_stdout"](cmd).split()
return out[1]
def build_rule(
table="filter",
chain=None,
command=None,
position="",
full=None,
family="ipv4",
**kwargs,
):
"""
Build a well-formatted iptables rule based on kwargs. A `table` and `chain`
are not required, unless `full` is True.
If `full` is `True`, then `table`, `chain` and `command` are required.
`command` may be specified as either a short option ('I') or a long option
(`--insert`). This will return the iptables command, exactly as it would
be used from the command line.
If a position is required (as with `-I` or `-D`), it may be specified as
`position`. This will only be useful if `full` is True.
If `state` is passed, it will be ignored, use `connstate`.
If `connstate` is passed in, it will automatically be changed to `state`.
To pass in jump options that doesn't take arguments, pass in an empty
string.
.. note::
Whereas iptables will accept ``-p``, ``--proto[c[o[l]]]`` as synonyms
of ``--protocol``, if ``--proto`` appears in an iptables command after
the appearance of ``-m policy``, it is interpreted as the ``--proto``
option of the policy extension (see the iptables-extensions(8) man
page).
CLI Examples:
.. code-block:: bash
salt '*' iptables.build_rule match=state \\
connstate=RELATED,ESTABLISHED jump=ACCEPT
salt '*' iptables.build_rule filter INPUT command=I position=3 \\
full=True match=state connstate=RELATED,ESTABLISHED jump=ACCEPT
salt '*' iptables.build_rule filter INPUT command=A \\
full=True match=state connstate=RELATED,ESTABLISHED \\
source='127.0.0.1' jump=ACCEPT
.. Invert Rules
salt '*' iptables.build_rule filter INPUT command=A \\
full=True match=state connstate=RELATED,ESTABLISHED \\
source='!127.0.0.1' jump=ACCEPT
salt '*' iptables.build_rule filter INPUT command=A \\
full=True match=state connstate=RELATED,ESTABLISHED \\
destination='not 127.0.0.1' jump=ACCEPT
IPv6:
salt '*' iptables.build_rule match=state \\
connstate=RELATED,ESTABLISHED jump=ACCEPT \\
family=ipv6
salt '*' iptables.build_rule filter INPUT command=I position=3 \\
full=True match=state connstate=RELATED,ESTABLISHED jump=ACCEPT \\
family=ipv6
"""
if "target" in kwargs:
kwargs["jump"] = kwargs.pop("target")
# Ignore name and state for this function
kwargs.pop("name", None)
kwargs.pop("state", None)
for ignore in list(_STATE_INTERNAL_KEYWORDS) + ["chain", "save", "table"]:
if ignore in kwargs:
del kwargs[ignore]
rule = []
protocol = False
bang_not_pat = re.compile(r"(!|not)\s?")
def maybe_add_negation(arg):
"""
Will check if the defined argument is intended to be negated,
(i.e. prefixed with '!' or 'not'), and add a '! ' to the rule.
The prefix will be removed from the value in the kwargs dict.
"""
value = str(kwargs[arg])
if value.startswith("!") or value.startswith("not"):
kwargs[arg] = re.sub(bang_not_pat, "", value)
return "! "
return ""
if "if" in kwargs:
rule.append("{}-i {}".format(maybe_add_negation("if"), kwargs["if"]))
del kwargs["if"]
if "of" in kwargs:
rule.append("{}-o {}".format(maybe_add_negation("of"), kwargs["of"]))
del kwargs["of"]
if "proto" in kwargs and kwargs.get("match") != "policy":
kwargs["protocol"] = kwargs["proto"]
del kwargs["proto"]
# Handle the case 'proto' in kwargs and kwargs.get('match') == 'policy' below
if "protocol" in kwargs:
if not protocol:
rule.append(
"{}-p {}".format(maybe_add_negation("protocol"), kwargs["protocol"])
)
protocol = True
del kwargs["protocol"]
if "match" in kwargs:
match_value = kwargs["match"]
if not isinstance(match_value, list):
match_value = match_value.split(",")
for match in match_value:
rule.append(f"-m {match}")
if "name_" in kwargs and match.strip() in ("pknock", "quota2", "recent"):
rule.append("--name {}".format(kwargs["name_"]))
del kwargs["name_"]
if "proto" in kwargs and kwargs.get("match") == "policy":
rule.append(
"{}--proto {}".format(maybe_add_negation("proto"), kwargs["proto"])
)
del kwargs["proto"]
del kwargs["match"]
if "match-set" in kwargs:
if isinstance(kwargs["match-set"], str):
kwargs["match-set"] = [kwargs["match-set"]]
for match_set in kwargs["match-set"]:
negative_match_set = ""
if match_set.startswith("!") or match_set.startswith("not"):
negative_match_set = "! "
match_set = re.sub(bang_not_pat, "", match_set)
rule.append(f"-m set {negative_match_set}--match-set {match_set}")
del kwargs["match-set"]
if "connstate" in kwargs:
if "-m state" not in rule:
rule.append("-m state")
rule.append(
"{}--state {}".format(maybe_add_negation("connstate"), kwargs["connstate"])
)
del kwargs["connstate"]
if "dport" in kwargs:
rule.append("{}--dport {}".format(maybe_add_negation("dport"), kwargs["dport"]))
del kwargs["dport"]
if "sport" in kwargs:
rule.append("{}--sport {}".format(maybe_add_negation("sport"), kwargs["sport"]))
del kwargs["sport"]
for multiport_arg in ("dports", "sports"):
if multiport_arg in kwargs:
if "-m multiport" not in rule:
rule.append("-m multiport")
if not protocol:
return "Error: protocol must be specified"
mp_value = kwargs[multiport_arg]
if isinstance(mp_value, list):
if any(
i
for i in mp_value
if str(i).startswith("!") or str(i).startswith("not")
):
mp_value = [
re.sub(bang_not_pat, "", str(item)) for item in mp_value
]
rule.append("!")
dports = ",".join(str(i) for i in mp_value)
else:
if str(mp_value).startswith("!") or str(mp_value).startswith("not"):
dports = re.sub(bang_not_pat, "", mp_value)
rule.append("!")
else:
dports = mp_value
rule.append(f"--{multiport_arg} {dports}")
del kwargs[multiport_arg]
if "comment" in kwargs:
if "-m comment" not in rule:
rule.append("-m comment")
rule.append('--comment "{}"'.format(kwargs["comment"]))
del kwargs["comment"]
# --set in ipset is deprecated, works but returns error.
# rewrite to --match-set if not empty, otherwise treat as recent option
if "set" in kwargs and kwargs["set"]:
rule.append("{}--match-set {}".format(maybe_add_negation("set"), kwargs["set"]))
del kwargs["set"]
# Jumps should appear last, except for any arguments that are passed to
# jumps, which of course need to follow.
after_jump = []
# All jump arguments as extracted from man iptables-extensions, man iptables,
# man xtables-addons and http://www.iptables.info/en/iptables-targets-and-jumps.html
after_jump_arguments = (
"j", # j and jump needs to be first
"jump",
# IPTABLES
"add-set",
"and-mark",
"and-tos",
"checksum-fill",
"clamp-mss-to-pmtu",
"clustermac",
"ctevents",
"ctmask",
"del-set",
"ecn-tcp-remove",
"exist",
"expevents",
"gateway",
"hash-init",
"hashmode",
"helper",
"label",
"local-node",
"log-ip-options",
"log-level",
"log-prefix",
"log-tcp-options",
"log-tcp-sequence",
"log-uid",
"mask",
"new",
"nfmask",
"nflog-group",
"nflog-prefix",
"nflog-range",
"nflog-threshold",
"nodst",
"notrack",
"on-ip",
"on-port",
"or-mark",
"or-tos",
"persistent",
"queue-balance",
"queue-bypass",
"queue-num",
"random",
"rateest-ewmalog",
"rateest-interval",
"rateest-name",
"reject-with",
"restore",
"restore-mark",
#'save', # no arg, problematic name: How do we avoid collision with this?
"save-mark",
"selctx",
"set-class",
"set-dscp",
"set-dscp-class",
"set-mark",
"set-mss",
"set-tos",
"set-xmark",
"strip-options",
"timeout",
"to",
"to-destination",
"to-ports",
"to-source",
"total-nodes",
"tproxy-mark",
"ttl-dec",
"ttl-inc",
"ttl-set",
"type",
"ulog-cprange",
"ulog-nlgroup",
"ulog-prefix",
"ulog-qthreshold",
"xor-mark",
"xor-tos",
"zone",
# IPTABLES-EXTENSIONS
"dst-pfx",
"hl-dec",
"hl-inc",
"hl-set",
"hmark-dport-mask",
"hmark-dst-prefix",
"hmark-mod",
"hmark-offset",
"hmark-proto-mask",
"hmark-rnd",
"hmark-spi-mask",
"hmark-sport-mask",
"hmark-src-prefix",
"hmark-tuple",
"led-always-blink",
"led-delay",
"led-trigger-id",
"queue-cpu-fanout",
"src-pfx",
# WEB
"to-port",
# XTABLES
"addr",
"and-mask",
"delude",
"honeypot",
"or-mask",
"prefix",
"reset",
"reuse",
"set-mac",
"shift",
"static",
"tarpit",
"tname",
"ttl",
)
for after_jump_argument in after_jump_arguments:
if after_jump_argument in kwargs:
value = kwargs[after_jump_argument]
if value in (None, ""): # options without arguments
after_jump.append(f"--{after_jump_argument}")
elif any(ws_char in str(value) for ws_char in string.whitespace):
after_jump.append(f'--{after_jump_argument} "{value}"')
else:
after_jump.append(f"--{after_jump_argument} {value}")
del kwargs[after_jump_argument]
for key in kwargs:
negation = maybe_add_negation(key)
# don't use .items() since maybe_add_negation removes the prefix from
# the value in the kwargs, thus we need to fetch it after that has run
value = kwargs[key]
flag = "-" if len(key) == 1 else "--"
value = "" if value in (None, "") else f" {value}"
rule.append(f"{negation}{flag}{key}{value}")
rule += after_jump
if full:
if not table:
return "Error: Table needs to be specified"
if not chain:
return "Error: Chain needs to be specified"
if not command:
return "Error: Command needs to be specified"
if command in "ACDIRLSFZNXPE":
flag = "-"
else:
flag = "--"
wait = "--wait" if _has_option("--wait", family) else ""
return "{} {} -t {} {}{} {} {} {}".format(
_iptables_cmd(family),
wait,
table,
flag,
command,
chain,
position,
" ".join(rule),
)
return " ".join(rule)
def get_saved_rules(conf_file=None, family="ipv4"):
"""
Return a data structure of the rules in the conf file
CLI Example:
.. code-block:: bash
salt '*' iptables.get_saved_rules
IPv6:
salt '*' iptables.get_saved_rules family=ipv6
"""
return _parse_conf(conf_file=conf_file, family=family)
def get_rules(family="ipv4"):
"""
Return a data structure of the current, in-memory rules
CLI Example:
.. code-block:: bash
salt '*' iptables.get_rules
IPv6:
salt '*' iptables.get_rules family=ipv6
"""
return _parse_conf(in_mem=True, family=family)
def get_saved_policy(table="filter", chain=None, conf_file=None, family="ipv4"):
"""
Return the current policy for the specified table/chain
CLI Examples:
.. code-block:: bash
salt '*' iptables.get_saved_policy filter INPUT
salt '*' iptables.get_saved_policy filter INPUT \\
conf_file=/etc/iptables.saved
IPv6:
salt '*' iptables.get_saved_policy filter INPUT family=ipv6
salt '*' iptables.get_saved_policy filter INPUT \\
conf_file=/etc/iptables.saved family=ipv6
"""
if not chain:
return "Error: Chain needs to be specified"
rules = _parse_conf(conf_file, family=family)
try:
return rules[table][chain]["policy"]
except KeyError:
return None
def get_policy(table="filter", chain=None, family="ipv4"):
"""
Return the current policy for the specified table/chain
CLI Example:
.. code-block:: bash
salt '*' iptables.get_policy filter INPUT
IPv6:
salt '*' iptables.get_policy filter INPUT family=ipv6
"""
if not chain:
return "Error: Chain needs to be specified"
rules = _parse_conf(in_mem=True, family=family)
try:
return rules[table][chain]["policy"]
except KeyError:
return None
def set_policy(table="filter", chain=None, policy=None, family="ipv4"):
"""
Set the current policy for the specified table/chain
CLI Example:
.. code-block:: bash
salt '*' iptables.set_policy filter INPUT ACCEPT
IPv6:
salt '*' iptables.set_policy filter INPUT ACCEPT family=ipv6
"""
if not chain:
return "Error: Chain needs to be specified"
if not policy:
return "Error: Policy needs to be specified"
wait = "--wait" if _has_option("--wait", family) else ""
cmd = "{} {} -t {} -P {} {}".format(
_iptables_cmd(family), wait, table, chain, policy
)
out = __salt__["cmd.run_stderr"](cmd)
return out
def save(filename=None, family="ipv4"):
"""
Save the current in-memory rules to disk
CLI Example:
.. code-block:: bash
salt '*' iptables.save /etc/sysconfig/iptables
IPv6:
salt '*' iptables.save /etc/sysconfig/iptables family=ipv6
"""
if _conf() and not filename:
filename = _conf(family)
log.debug("Saving rules to %s", filename)
parent_dir = os.path.dirname(filename)
if not os.path.isdir(parent_dir):
os.makedirs(parent_dir)
cmd = f"{_iptables_cmd(family)}-save"
ipt = __salt__["cmd.run_stdout"](cmd)
# regex out the output if configured with filters
if _conf_save_filters():
ipt = _regex_iptables_save(ipt)
out = __salt__["file.write"](filename, ipt)
return out
def check(table="filter", chain=None, rule=None, family="ipv4"):
"""
Check for the existence of a rule in the table and chain
This function accepts a rule in a standard iptables command format,
starting with the chain. Trying to force users to adapt to a new
method of creating rules would be irritating at best, and we
already have a parser that can handle it.
CLI Example:
.. code-block:: bash
salt '*' iptables.check filter INPUT \\
rule='-m state --state RELATED,ESTABLISHED -j ACCEPT'
IPv6:
salt '*' iptables.check filter INPUT \\
rule='-m state --state RELATED,ESTABLISHED -j ACCEPT' \\
family=ipv6
"""
if not chain:
return "Error: Chain needs to be specified"
if not rule:
return "Error: Rule needs to be specified"
ipt_cmd = _iptables_cmd(family)
if _has_option("--check", family):
cmd = f"{ipt_cmd} -t {table} -C {chain} {rule}"
__salt__["cmd.run_stderr"](cmd, output_loglevel="quiet")
return not __context__["retcode"]
else:
_chain_name = hex(uuid.getnode())
# Create temporary table
__salt__["cmd.run"](f"{ipt_cmd} -t {table} -N {_chain_name}")
__salt__["cmd.run"](f"{ipt_cmd} -t {table} -A {_chain_name} {rule}")
out = __salt__["cmd.run_stdout"](f"{ipt_cmd}-save")
# Clean up temporary table
__salt__["cmd.run"](f"{ipt_cmd} -t {table} -F {_chain_name}")
__salt__["cmd.run"](f"{ipt_cmd} -t {table} -X {_chain_name}")
for i in out.splitlines():
if i.startswith(f"-A {_chain_name}"):
if i.replace(_chain_name, chain) in out.splitlines():
return True
return False
if not out:
return True
return out
def check_chain(table="filter", chain=None, family="ipv4"):
"""
.. versionadded:: 2014.1.0
Check for the existence of a chain in the table
CLI Example:
.. code-block:: bash
salt '*' iptables.check_chain filter INPUT
IPv6:
salt '*' iptables.check_chain filter INPUT family=ipv6
"""
if not chain:
return "Error: Chain needs to be specified"
cmd = f"{_iptables_cmd(family)}-save -t {table}"
out = __salt__["cmd.run_stdout"](cmd).find(f":{chain} ")
if out != -1:
out = True
else:
out = False
return out
def new_chain(table="filter", chain=None, family="ipv4"):
"""
.. versionadded:: 2014.1.0
Create new custom chain to the specified table.
CLI Example:
.. code-block:: bash
salt '*' iptables.new_chain filter CUSTOM_CHAIN
IPv6:
salt '*' iptables.new_chain filter CUSTOM_CHAIN family=ipv6
"""
if not chain:
return "Error: Chain needs to be specified"
wait = "--wait" if _has_option("--wait", family) else ""
cmd = f"{_iptables_cmd(family)} {wait} -t {table} -N {chain}"
out = __salt__["cmd.run_stderr"](cmd)
if not out:
out = True
return out
def delete_chain(table="filter", chain=None, family="ipv4"):
"""
.. versionadded:: 2014.1.0
Delete custom chain to the specified table.
CLI Example:
.. code-block:: bash
salt '*' iptables.delete_chain filter CUSTOM_CHAIN
IPv6:
salt '*' iptables.delete_chain filter CUSTOM_CHAIN family=ipv6
"""
if not chain:
return "Error: Chain needs to be specified"
wait = "--wait" if _has_option("--wait", family) else ""
cmd = f"{_iptables_cmd(family)} {wait} -t {table} -X {chain}"
out = __salt__["cmd.run_stderr"](cmd)
if not out:
out = True
return out
def append(table="filter", chain=None, rule=None, family="ipv4"):
"""
Append a rule to the specified table/chain.
This function accepts a rule in a standard iptables command format,
starting with the chain. Trying to force users to adapt to a new
method of creating rules would be irritating at best, and we
already have a parser that can handle it.
CLI Example:
.. code-block:: bash
salt '*' iptables.append filter INPUT \\
rule='-m state --state RELATED,ESTABLISHED -j ACCEPT'
IPv6:
salt '*' iptables.append filter INPUT \\
rule='-m state --state RELATED,ESTABLISHED -j ACCEPT' \\
family=ipv6
"""
if not chain:
return "Error: Chain needs to be specified"
if not rule:
return "Error: Rule needs to be specified"
wait = "--wait" if _has_option("--wait", family) else ""
returnCheck = check(table, chain, rule, family)
if isinstance(returnCheck, bool) and returnCheck:
return False
cmd = f"{_iptables_cmd(family)} {wait} -t {table} -A {chain} {rule}"
out = __salt__["cmd.run_stderr"](cmd)
return not out
def insert(table="filter", chain=None, position=None, rule=None, family="ipv4"):
"""
Insert a rule into the specified table/chain, at the specified position.
This function accepts a rule in a standard iptables command format,
starting with the chain. Trying to force users to adapt to a new
method of creating rules would be irritating at best, and we
already have a parser that can handle it.
If the position specified is a negative number, then the insert will be
performed counting from the end of the list. For instance, a position
of -1 will insert the rule as the second to last rule. To insert a rule
in the last position, use the append function instead.
CLI Examples:
.. code-block:: bash
salt '*' iptables.insert filter INPUT position=3 \\
rule='-m state --state RELATED,ESTABLISHED -j ACCEPT'
IPv6:
salt '*' iptables.insert filter INPUT position=3 \\
rule='-m state --state RELATED,ESTABLISHED -j ACCEPT' \\
family=ipv6
"""
if not chain:
return "Error: Chain needs to be specified"
if not position:
return "Error: Position needs to be specified or use append (-A)"
if not rule:
return "Error: Rule needs to be specified"
if position < 0:
rules = get_rules(family=family)
size = len(rules[table][chain]["rules"])
position = (size + position) + 1
if position == 0:
position = 1
wait = "--wait" if _has_option("--wait", family) else ""
returnCheck = check(table, chain, rule, family)
if isinstance(returnCheck, bool) and returnCheck:
return False
cmd = "{} {} -t {} -I {} {} {}".format(
_iptables_cmd(family), wait, table, chain, position, rule
)
out = __salt__["cmd.run_stderr"](cmd)
return out
def delete(table, chain=None, position=None, rule=None, family="ipv4"):
"""
Delete a rule from the specified table/chain, specifying either the rule
in its entirety, or the rule's position in the chain.
This function accepts a rule in a standard iptables command format,
starting with the chain. Trying to force users to adapt to a new
method of creating rules would be irritating at best, and we
already have a parser that can handle it.
CLI Examples:
.. code-block:: bash
salt '*' iptables.delete filter INPUT position=3
salt '*' iptables.delete filter INPUT \\
rule='-m state --state RELATED,ESTABLISHED -j ACCEPT'
IPv6:
salt '*' iptables.delete filter INPUT position=3 family=ipv6
salt '*' iptables.delete filter INPUT \\
rule='-m state --state RELATED,ESTABLISHED -j ACCEPT' \\
family=ipv6
"""
if position and rule:
return "Error: Only specify a position or a rule, not both"
if position:
rule = position
wait = "--wait" if _has_option("--wait", family) else ""
cmd = f"{_iptables_cmd(family)} {wait} -t {table} -D {chain} {rule}"
out = __salt__["cmd.run_stderr"](cmd)
return out
def flush(table="filter", chain="", family="ipv4"):
"""
Flush the chain in the specified table, flush all chains in the specified
table if not specified chain.
CLI Example:
.. code-block:: bash
salt '*' iptables.flush filter INPUT
IPv6:
salt '*' iptables.flush filter INPUT family=ipv6
"""
wait = "--wait" if _has_option("--wait", family) else ""
cmd = f"{_iptables_cmd(family)} {wait} -t {table} -F {chain}"
out = __salt__["cmd.run_stderr"](cmd)
return out
def _parse_conf(conf_file=None, in_mem=False, family="ipv4"):
"""
If a file is not passed in, and the correct one for this OS is not
detected, return False
"""
if _conf() and not conf_file and not in_mem:
conf_file = _conf(family)
rules = ""
if conf_file:
with salt.utils.files.fopen(conf_file, "r") as ifile:
rules = ifile.read()
elif in_mem:
cmd = f"{_iptables_cmd(family)}-save"
rules = __salt__["cmd.run_stdout"](cmd)
else:
raise SaltException("A file was not found to parse")
ret = {}
table = ""
parser = _parser()
for line in rules.splitlines():
line = salt.utils.stringutils.to_unicode(line)
if line.startswith("*"):
table = line.replace("*", "")
ret[table] = {}
elif line.startswith(":"):
comps = line.split()
chain = comps[0].replace(":", "")
ret[table][chain] = {}
ret[table][chain]["policy"] = comps[1]
counters = comps[2].replace("[", "").replace("]", "")
(pcount, bcount) = counters.split(":")
ret[table][chain]["packet count"] = pcount
ret[table][chain]["byte count"] = bcount
ret[table][chain]["rules"] = []
ret[table][chain]["rules_comment"] = {}
elif line.startswith("-A"):
args = salt.utils.args.shlex_split(line)
index = 0
while index + 1 < len(args):
swap = args[index] == "!" and args[index + 1].startswith("-")
if swap:
args[index], args[index + 1] = args[index + 1], args[index]
if args[index].startswith("-"):
index += 1
if args[index].startswith("-") or (args[index] == "!" and not swap):
args.insert(index, "")
else:
while (
index + 1 < len(args)
and args[index + 1] != "!"
and not args[index + 1].startswith("-")
):
args[index] += f" {args.pop(index + 1)}"
index += 1
if args[-1].startswith("-"):
args.append("")
parsed_args = []
opts, _ = parser.parse_known_args(args)
parsed_args = vars(opts)
ret_args = {}
chain = parsed_args["append"]
for arg in parsed_args:
if parsed_args[arg] and arg != "append":
ret_args[arg] = parsed_args[arg]
if parsed_args["comment"] is not None:
comment = parsed_args["comment"][0].strip('"')
ret[table][chain[0]]["rules_comment"][comment] = ret_args
ret[table][chain[0]]["rules"].append(ret_args)
return ret
def _parser():
"""
This function attempts to list all the options documented in the
iptables(8) and iptables-extensions(8) man pages. They will not all be
used by all parts of the module; use them intelligently and appropriately.
"""
parser = argparse.ArgumentParser()
add_arg = parser.add_argument
# COMMANDS
add_arg("-A", "--append", dest="append", action="append")
add_arg("-D", "--delete", dest="delete", action="append")
add_arg("-I", "--insert", dest="insert", action="append")
add_arg("-R", "--replace", dest="replace", action="append")
add_arg("-L", "--list", dest="list", action="append")
add_arg("-F", "--flush", dest="flush", action="append")
add_arg("-Z", "--zero", dest="zero", action="append")
add_arg("-N", "--new-chain", dest="new-chain", action="append")
add_arg("-X", "--delete-chain", dest="delete-chain", action="append")
add_arg("-P", "--policy", dest="policy", action="append")
add_arg("-E", "--rename-chain", dest="rename-chain", action="append")
# PARAMETERS
add_arg("-p", "--protocol", dest="protocol", action="append")
add_arg("-s", "--source", dest="source", action="append")
add_arg("-d", "--destination", dest="destination", action="append")
add_arg("-j", "--jump", dest="jump", action="append")
add_arg("-g", "--goto", dest="goto", action="append")
add_arg("-i", "--in-interface", dest="in-interface", action="append")
add_arg("-o", "--out-interface", dest="out-interface", action="append")
add_arg("-f", "--fragment", dest="fragment", action="append")
add_arg("-c", "--set-counters", dest="set-counters", action="append")
# MATCH EXTENSIONS
add_arg("-m", "--match", dest="match", action="append")
## addrtype
add_arg("--src-type", dest="src-type", action="append")
add_arg("--dst-type", dest="dst-type", action="append")
add_arg("--limit-iface-in", dest="limit-iface-in", action="append")
add_arg("--limit-iface-out", dest="limit-iface-out", action="append")
## ah
add_arg("--ahspi", dest="ahspi", action="append")
add_arg("--ahlen", dest="ahlen", action="append")
add_arg("--ahres", dest="ahres", action="append")
## bpf
add_arg("--bytecode", dest="bytecode", action="append")
## cgroup
add_arg("--cgroup", dest="cgroup", action="append")
## cluster
add_arg("--cluster-total-nodes", dest="cluster-total-nodes", action="append")
add_arg("--cluster-local-node", dest="cluster-local-node", action="append")
add_arg("--cluster-local-nodemask", dest="cluster-local-nodemask", action="append")
add_arg("--cluster-hash-seed", dest="cluster-hash-seed", action="append")
add_arg("--h-length", dest="h-length", action="append")
add_arg("--mangle-mac-s", dest="mangle-mac-s", action="append")
add_arg("--mangle-mac-d", dest="mangle-mac-d", action="append")
## comment
add_arg("--comment", dest="comment", action="append")
## connbytes
add_arg("--connbytes", dest="connbytes", action="append")
add_arg("--connbytes-dir", dest="connbytes-dir", action="append")
add_arg("--connbytes-mode", dest="connbytes-mode", action="append")
## connlabel
add_arg("--label", dest="label", action="append")
## connlimit
add_arg("--connlimit-upto", dest="connlimit-upto", action="append")
add_arg("--connlimit-above", dest="connlimit-above", action="append")
add_arg("--connlimit-mask", dest="connlimit-mask", action="append")
add_arg("--connlimit-saddr", dest="connlimit-saddr", action="append")
add_arg("--connlimit-daddr", dest="connlimit-daddr", action="append")
## connmark
add_arg("--mark", dest="mark", action="append")
## conntrack
add_arg("--ctstate", dest="ctstate", action="append")
add_arg("--ctproto", dest="ctproto", action="append")
add_arg("--ctorigsrc", dest="ctorigsrc", action="append")
add_arg("--ctorigdst", dest="ctorigdst", action="append")
add_arg("--ctreplsrc", dest="ctreplsrc", action="append")
add_arg("--ctrepldst", dest="ctrepldst", action="append")
add_arg("--ctorigsrcport", dest="ctorigsrcport", action="append")
add_arg("--ctorigdstport", dest="ctorigdstport", action="append")
add_arg("--ctreplsrcport", dest="ctreplsrcport", action="append")
add_arg("--ctrepldstport", dest="ctrepldstport", action="append")
add_arg("--ctstatus", dest="ctstatus", action="append")
add_arg("--ctexpire", dest="ctexpire", action="append")
add_arg("--ctdir", dest="ctdir", action="append")
## cpu
add_arg("--cpu", dest="cpu", action="append")
## dccp
add_arg("--sport", "--source-port", dest="source_port", action="append")
add_arg("--dport", "--destination-port", dest="destination_port", action="append")
add_arg("--dccp-types", dest="dccp-types", action="append")
add_arg("--dccp-option", dest="dccp-option", action="append")
## devgroup
add_arg("--src-group", dest="src-group", action="append")
add_arg("--dst-group", dest="dst-group", action="append")
## dscp
add_arg("--dscp", dest="dscp", action="append")
add_arg("--dscp-class", dest="dscp-class", action="append")
## dst
add_arg("--dst-len", dest="dst-len", action="append")
add_arg("--dst-opts", dest="dst-opts", action="append")
## ecn
add_arg("--ecn-tcp-cwr", dest="ecn-tcp-cwr", action="append")
add_arg("--ecn-tcp-ece", dest="ecn-tcp-ece", action="append")
add_arg("--ecn-ip-ect", dest="ecn-ip-ect", action="append")
## esp
add_arg("--espspi", dest="espspi", action="append")
## frag
add_arg("--fragid", dest="fragid", action="append")
add_arg("--fraglen", dest="fraglen", action="append")
add_arg("--fragres", dest="fragres", action="append")
add_arg("--fragfirst", dest="fragfirst", action="append")
add_arg("--fragmore", dest="fragmore", action="append")
add_arg("--fraglast", dest="fraglast", action="append")
## hashlimit
add_arg("--hashlimit-upto", dest="hashlimit-upto", action="append")
add_arg("--hashlimit-above", dest="hashlimit-above", action="append")
add_arg("--hashlimit-burst", dest="hashlimit-burst", action="append")
add_arg("--hashlimit-mode", dest="hashlimit-mode", action="append")
add_arg("--hashlimit-srcmask", dest="hashlimit-srcmask", action="append")
add_arg("--hashlimit-dstmask", dest="hashlimit-dstmask", action="append")
add_arg("--hashlimit-name", dest="hashlimit-name", action="append")
add_arg("--hashlimit-htable-size", dest="hashlimit-htable-size", action="append")
add_arg("--hashlimit-htable-max", dest="hashlimit-htable-max", action="append")
add_arg(
"--hashlimit-htable-expire", dest="hashlimit-htable-expire", action="append"
)
add_arg(
"--hashlimit-htable-gcinterval",
dest="hashlimit-htable-gcinterval",
action="append",
)
## hbh
add_arg("--hbh-len", dest="hbh-len", action="append")
add_arg("--hbh-opts", dest="hbh-opts", action="append")
## helper
add_arg("--helper", dest="helper", action="append")
## hl
add_arg("--hl-eq", dest="hl-eq", action="append")
add_arg("--hl-lt", dest="hl-lt", action="append")
add_arg("--hl-gt", dest="hl-gt", action="append")
## icmp
add_arg("--icmp-type", dest="icmp-type", action="append")
## icmp6
add_arg("--icmpv6-type", dest="icmpv6-type", action="append")
## iprange
add_arg("--src-range", dest="src-range", action="append")
add_arg("--dst-range", dest="dst-range", action="append")
## ipv6header
add_arg("--soft", dest="soft", action="append")
add_arg("--header", dest="header", action="append")
## ipvs
add_arg("--ipvs", dest="ipvs", action="append")
add_arg("--vproto", dest="vproto", action="append")
add_arg("--vaddr", dest="vaddr", action="append")
add_arg("--vport", dest="vport", action="append")
add_arg("--vdir", dest="vdir", action="append")
add_arg("--vmethod", dest="vmethod", action="append")
add_arg("--vportctl", dest="vportctl", action="append")
## length
add_arg("--length", dest="length", action="append")
## limit
add_arg("--limit", dest="limit", action="append")
add_arg("--limit-burst", dest="limit-burst", action="append")
## mac
add_arg("--mac-source", dest="mac-source", action="append")
## mh
add_arg("--mh-type", dest="mh-type", action="append")
## multiport
add_arg("--sports", "--source-ports", dest="source-ports", action="append")
add_arg(
"--dports", "--destination-ports", dest="destination-ports", action="append"
)
add_arg("--ports", dest="ports", action="append")
## nfacct
add_arg("--nfacct-name", dest="nfacct-name", action="append")
## osf
add_arg("--genre", dest="genre", action="append")
add_arg("--ttl", dest="ttl", action="append")
add_arg("--log", dest="log", action="append")
## owner
add_arg("--uid-owner", dest="uid-owner", action="append")
add_arg("--gid-owner", dest="gid-owner", action="append")
add_arg("--socket-exists", dest="socket-exists", action="append")
## physdev
add_arg("--physdev-in", dest="physdev-in", action="append")
add_arg("--physdev-out", dest="physdev-out", action="append")
add_arg("--physdev-is-in", dest="physdev-is-in", action="append")
add_arg("--physdev-is-out", dest="physdev-is-out", action="append")
add_arg("--physdev-is-bridged", dest="physdev-is-bridged", action="append")
## pkttype
add_arg("--pkt-type", dest="pkt-type", action="append")
## policy
add_arg("--dir", dest="dir", action="append")
add_arg("--pol", dest="pol", action="append")
add_arg("--strict", dest="strict", action="append")
add_arg("--reqid", dest="reqid", action="append")
add_arg("--spi", dest="spi", action="append")
add_arg("--proto", dest="proto", action="append")
add_arg("--mode", dest="mode", action="append")
add_arg("--tunnel-src", dest="tunnel-src", action="append")
add_arg("--tunnel-dst", dest="tunnel-dst", action="append")
add_arg("--next", dest="next", action="append")
## quota
add_arg("--quota", dest="quota", action="append")
## rateest
add_arg("--rateest", dest="rateest", action="append")
add_arg("--rateest1", dest="rateest1", action="append")
add_arg("--rateest2", dest="rateest2", action="append")
add_arg("--rateest-delta", dest="rateest-delta", action="append")
add_arg("--rateest-bps", dest="rateest-bps", action="append")
add_arg("--rateest-bps1", dest="rateest-bps1", action="append")
add_arg("--rateest-bps2", dest="rateest-bps2", action="append")
add_arg("--rateest-pps", dest="rateest-pps", action="append")
add_arg("--rateest-pps1", dest="rateest-pps1", action="append")
add_arg("--rateest-pps2", dest="rateest-pps2", action="append")
add_arg("--rateest-lt", dest="rateest-lt", action="append")
add_arg("--rateest-gt", dest="rateest-gt", action="append")
add_arg("--rateest-eq", dest="rateest-eq", action="append")
add_arg("--rateest-name", dest="rateest-name", action="append")
add_arg("--rateest-interval", dest="rateest-interval", action="append")
add_arg("--rateest-ewma", dest="rateest-ewma", action="append")
## realm
add_arg("--realm", dest="realm", action="append")
## recent
add_arg("--name", dest="name", action="append")
add_arg("--set", dest="set", action="append")
add_arg("--rsource", dest="rsource", action="append")
add_arg("--rdest", dest="rdest", action="append")
add_arg("--mask", dest="mask", action="append")
add_arg("--rcheck", dest="rcheck", action="append")
add_arg("--update", dest="update", action="append")
add_arg("--remove", dest="remove", action="append")
add_arg("--seconds", dest="seconds", action="append")
add_arg("--reap", dest="reap", action="append")
add_arg("--hitcount", dest="hitcount", action="append")
add_arg("--rttl", dest="rttl", action="append")
## rpfilter
add_arg("--loose", dest="loose", action="append")
add_arg("--validmark", dest="validmark", action="append")
add_arg("--accept-local", dest="accept-local", action="append")
add_arg("--invert", dest="invert", action="append")
## rt
add_arg("--rt-type", dest="rt-type", action="append")
add_arg("--rt-segsleft", dest="rt-segsleft", action="append")
add_arg("--rt-len", dest="rt-len", action="append")
add_arg("--rt-0-res", dest="rt-0-res", action="append")
add_arg("--rt-0-addrs", dest="rt-0-addrs", action="append")
add_arg("--rt-0-not-strict", dest="rt-0-not-strict", action="append")
## sctp
add_arg("--chunk-types", dest="chunk-types", action="append")
## set
add_arg("--match-set", dest="match-set", action="append")
add_arg("--return-nomatch", dest="return-nomatch", action="append")
add_arg("--update-counters", dest="update-counters", action="append")
add_arg("--update-subcounters", dest="update-subcounters", action="append")
add_arg("--packets-eq", dest="packets-eq", action="append")
add_arg("--packets-lt", dest="packets-lt", action="append")
add_arg("--packets-gt", dest="packets-gt", action="append")
add_arg("--bytes-eq", dest="bytes-eq", action="append")
add_arg("--bytes-lt", dest="bytes-lt", action="append")
add_arg("--bytes-gt", dest="bytes-gt", action="append")
## socket
add_arg("--transparent", dest="transparent", action="append")
add_arg("--nowildcard", dest="nowildcard", action="append")
## state
add_arg("--state", dest="state", action="append")
## statistic
add_arg("--probability", dest="probability", action="append")
add_arg("--every", dest="every", action="append")
add_arg("--packet", dest="packet", action="append")
## string
add_arg("--algo", dest="algo", action="append")
add_arg("--from", dest="from", action="append")
add_arg("--to", dest="to", action="append")
add_arg("--string", dest="string", action="append")
add_arg("--hex-string", dest="hex-string", action="append")
## tcp
add_arg("--tcp-flags", dest="tcp-flags", action="append")
add_arg("--syn", dest="syn", action="append")
add_arg("--tcp-option", dest="tcp-option", action="append")
## tcpmss
add_arg("--mss", dest="mss", action="append")
## time
add_arg("--datestart", dest="datestart", action="append")
add_arg("--datestop", dest="datestop", action="append")
add_arg("--timestart", dest="timestart", action="append")
add_arg("--timestop", dest="timestop", action="append")
add_arg("--monthdays", dest="monthdays", action="append")
add_arg("--weekdays", dest="weekdays", action="append")
add_arg("--contiguous", dest="contiguous", action="append")
add_arg("--kerneltz", dest="kerneltz", action="append")
add_arg("--utc", dest="utc", action="append")
add_arg("--localtz", dest="localtz", action="append")
## tos
add_arg("--tos", dest="tos", action="append")
## ttl
add_arg("--ttl-eq", dest="ttl-eq", action="append")
add_arg("--ttl-gt", dest="ttl-gt", action="append")
add_arg("--ttl-lt", dest="ttl-lt", action="append")
## u32
add_arg("--u32", dest="u32", action="append")
# Xtables-addons matches
## condition
add_arg("--condition", dest="condition", action="append")
## dhcpmac
add_arg("--mac", dest="mac", action="append")
## fuzzy
add_arg("--lower-limit", dest="lower-limit", action="append")
add_arg("--upper-limit", dest="upper-limit", action="append")
## geoip
add_arg("--src-cc", "--source-country", dest="source-country", action="append")
add_arg(
"--dst-cc", "--destination-country", dest="destination-country", action="append"
)
## gradm
add_arg("--enabled", dest="enabled", action="append")
add_arg("--disabled", dest="disabled", action="append")
## iface
add_arg("--iface", dest="iface", action="append")
add_arg("--dev-in", dest="dev-in", action="append")
add_arg("--dev-out", dest="dev-out", action="append")
add_arg("--up", dest="up", action="append")
add_arg("--down", dest="down", action="append")
add_arg("--broadcast", dest="broadcast", action="append")
add_arg("--loopback", dest="loopback", action="append")
add_arg("--pointtopoint", dest="pointtopoint", action="append")
add_arg("--running", dest="running", action="append")
add_arg("--noarp", dest="noarp", action="append")
add_arg("--arp", dest="arp", action="append")
add_arg("--promisc", dest="promisc", action="append")
add_arg("--multicast", dest="multicast", action="append")
add_arg("--dynamic", dest="dynamic", action="append")
add_arg("--lower-up", dest="lower-up", action="append")
add_arg("--dormant", dest="dormant", action="append")
## ipp2p
add_arg("--edk", dest="edk", action="append")
add_arg("--kazaa", dest="kazaa", action="append")
add_arg("--gnu", dest="gnu", action="append")
add_arg("--dc", dest="dc", action="append")
add_arg("--bit", dest="bit", action="append")
add_arg("--apple", dest="apple", action="append")
add_arg("--soul", dest="soul", action="append")
add_arg("--winmx", dest="winmx", action="append")
add_arg("--ares", dest="ares", action="append")
add_arg("--debug", dest="debug", action="append")
## ipv4options
add_arg("--flags", dest="flags", action="append")
add_arg("--any", dest="any", action="append")
## length2
add_arg("--layer3", dest="layer3", action="append")
add_arg("--layer4", dest="layer4", action="append")
add_arg("--layer5", dest="layer5", action="append")
## lscan
add_arg("--stealth", dest="stealth", action="append")
add_arg("--synscan", dest="synscan", action="append")
add_arg("--cnscan", dest="cnscan", action="append")
add_arg("--grscan", dest="grscan", action="append")
## psd
add_arg("--psd-weight-threshold", dest="psd-weight-threshold", action="append")
add_arg("--psd-delay-threshold", dest="psd-delay-threshold", action="append")
add_arg("--psd-lo-ports-weight", dest="psd-lo-ports-weight", action="append")
add_arg("--psd-hi-ports-weight", dest="psd-hi-ports-weight", action="append")
## quota2
add_arg("--grow", dest="grow", action="append")
add_arg("--no-change", dest="no-change", action="append")
add_arg("--packets", dest="packets", action="append")
## pknock
add_arg("--knockports", dest="knockports", action="append")
add_arg("--time", dest="time", action="append")
add_arg("--autoclose", dest="autoclose", action="append")
add_arg("--checkip", dest="checkip", action="append")
# TARGET EXTENSIONS
## AUDIT
add_arg("--type", dest="type", action="append")
## CHECKSUM
add_arg("--checksum-fill", dest="checksum-fill", action="append")
## CLASSIFY
add_arg("--set-class", dest="set-class", action="append")
## CLUSTERIP
add_arg("--new", dest="new", action="append")
add_arg("--hashmode", dest="hashmode", action="append")
add_arg("--clustermac", dest="clustermac", action="append")
add_arg("--total-nodes", dest="total-nodes", action="append")
add_arg("--local-node", dest="local-node", action="append")
add_arg("--hash-init", dest="hash-init", action="append")
## CONNMARK
add_arg("--set-xmark", dest="set-xmark", action="append")
add_arg("--save-mark", dest="save-mark", action="append")
add_arg("--restore-mark", dest="restore-mark", action="append")
add_arg("--and-mark", dest="and-mark", action="append")
add_arg("--or-mark", dest="or-mark", action="append")
add_arg("--xor-mark", dest="xor-mark", action="append")
add_arg("--set-mark", dest="set-mark", action="append")
add_arg("--nfmask", dest="nfmask", action="append")
add_arg("--ctmask", dest="ctmask", action="append")
## CONNSECMARK
add_arg("--save", dest="save", action="append")
add_arg("--restore", dest="restore", action="append")
## CT
add_arg("--notrack", dest="notrack", action="append")
add_arg("--ctevents", dest="ctevents", action="append")
add_arg("--expevents", dest="expevents", action="append")
add_arg("--zone", dest="zone", action="append")
add_arg("--timeout", dest="timeout", action="append")
## DNAT
add_arg("--to-destination", dest="to-destination", action="append")
add_arg("--random", dest="random", action="append")
add_arg("--persistent", dest="persistent", action="append")
## DNPT
add_arg("--src-pfx", dest="src-pfx", action="append")
add_arg("--dst-pfx", dest="dst-pfx", action="append")
## DSCP
add_arg("--set-dscp", dest="set-dscp", action="append")
add_arg("--set-dscp-class", dest="set-dscp-class", action="append")
## ECN
add_arg("--ecn-tcp-remove", dest="ecn-tcp-remove", action="append")
## HL
add_arg("--hl-set", dest="hl-set", action="append")
add_arg("--hl-dec", dest="hl-dec", action="append")
add_arg("--hl-inc", dest="hl-inc", action="append")
## HMARK
add_arg("--hmark-tuple", dest="hmark-tuple", action="append")
add_arg("--hmark-mod", dest="hmark-mod", action="append")
add_arg("--hmark-offset", dest="hmark-offset", action="append")
add_arg("--hmark-src-prefix", dest="hmark-src-prefix", action="append")
add_arg("--hmark-dst-prefix", dest="hmark-dst-prefix", action="append")
add_arg("--hmark-sport-mask", dest="hmark-sport-mask", action="append")
add_arg("--hmark-dport-mask", dest="hmark-dport-mask", action="append")
add_arg("--hmark-spi-mask", dest="hmark-spi-mask", action="append")
add_arg("--hmark-proto-mask", dest="hmark-proto-mask", action="append")
add_arg("--hmark-rnd", dest="hmark-rnd", action="append")
## LED
add_arg("--led-trigger-id", dest="led-trigger-id", action="append")
add_arg("--led-delay", dest="led-delay", action="append")
add_arg("--led-always-blink", dest="led-always-blink", action="append")
## LOG
add_arg("--log-level", dest="log-level", action="append")
add_arg("--log-prefix", dest="log-prefix", action="append")
add_arg("--log-tcp-sequence", dest="log-tcp-sequence", action="append")
add_arg("--log-tcp-options", dest="log-tcp-options", action="append")
add_arg("--log-ip-options", dest="log-ip-options", action="append")
add_arg("--log-uid", dest="log-uid", action="append")
## MASQUERADE
add_arg("--to-ports", dest="to-ports", action="append")
## NFLOG
add_arg("--nflog-group", dest="nflog-group", action="append")
add_arg("--nflog-prefix", dest="nflog-prefix", action="append")
add_arg("--nflog-range", dest="nflog-range", action="append")
add_arg("--nflog-threshold", dest="nflog-threshold", action="append")
## NFQUEUE
add_arg("--queue-num", dest="queue-num", action="append")
add_arg("--queue-balance", dest="queue-balance", action="append")
add_arg("--queue-bypass", dest="queue-bypass", action="append")
add_arg("--queue-cpu-fanout", dest="queue-cpu-fanout", action="append")
## RATEEST
add_arg("--rateest-ewmalog", dest="rateest-ewmalog", action="append")
## REJECT
add_arg("--reject-with", dest="reject-with", action="append")
## SAME
add_arg("--nodst", dest="nodst", action="append")
## SECMARK
add_arg("--selctx", dest="selctx", action="append")
## SET
add_arg("--add-set", dest="add-set", action="append")
add_arg("--del-set", dest="del-set", action="append")
add_arg("--exist", dest="exist", action="append")
## SNAT
add_arg("--to-source", dest="to-source", action="append")
## TCPMSS
add_arg("--set-mss", dest="set-mss", action="append")
add_arg("--clamp-mss-to-pmtu", dest="clamp-mss-to-pmtu", action="append")
## TCPOPTSTRIP
add_arg("--strip-options", dest="strip-options", action="append")
## TEE
add_arg("--gateway", dest="gateway", action="append")
## TOS
add_arg("--set-tos", dest="set-tos", action="append")
add_arg("--and-tos", dest="and-tos", action="append")
add_arg("--or-tos", dest="or-tos", action="append")
add_arg("--xor-tos", dest="xor-tos", action="append")
## TPROXY
add_arg("--on-port", dest="on-port", action="append")
add_arg("--on-ip", dest="on-ip", action="append")
add_arg("--tproxy-mark", dest="tproxy-mark", action="append")
## TTL
add_arg("--ttl-set", dest="ttl-set", action="append")
add_arg("--ttl-dec", dest="ttl-dec", action="append")
add_arg("--ttl-inc", dest="ttl-inc", action="append")
## ULOG
add_arg("--ulog-nlgroup", dest="ulog-nlgroup", action="append")
add_arg("--ulog-prefix", dest="ulog-prefix", action="append")
add_arg("--ulog-cprange", dest="ulog-cprange", action="append")
add_arg("--ulog-qthreshold", dest="ulog-qthreshold", action="append")
# Xtables-addons targets
## ACCOUNT
add_arg("--addr", dest="addr", action="append")
add_arg("--tname", dest="tname", action="append")
## CHAOS
add_arg("--delude", dest="delude", action="append")
add_arg("--tarpit", dest="tarpit", action="append")
## DHCPMAC
add_arg("--set-mac", dest="set-mac", action="append")
## DNETMAP
add_arg("--prefix", dest="prefix", action="append")
add_arg("--reuse", dest="reuse", action="append")
add_arg("--static", dest="static", action="append")
## IPMARK
add_arg("--and-mask", dest="and-mask", action="append")
add_arg("--or-mask", dest="or-mask", action="append")
add_arg("--shift", dest="shift", action="append")
## TARPIT
add_arg("--honeypot", dest="honeypot", action="append")
add_arg("--reset", dest="reset", action="append")
return parser