services/firewall/__init__.py

   1 # vim: set encoding=utf-8 et sw=4 sts=4 :
   2
   3 # TODO See if it's better (more secure) to execute commands via python instead
   4 # of using script templates.
   5
   6 from os import path
   7
   8 from seqtools import Sequence
   9 from dispatcher import Handler, handler, HandlerError
  10 from services.util import ServiceHandler, TransactionalHandler
  11 from services.util import Restorable, ConfigWriter
  12
  13 __ALL__ = ('FirewallHandler', 'Error', 'RuleError', 'RuleAlreadyExistsError',
  14            'RuleNotFoundError')
  15
  16 class Error(HandlerError):
  17     r"""
  18     Error(command) -> Error instance :: Base FirewallHandler exception class.
  19
  20     All exceptions raised by the FirewallHandler inherits from this one, so you can
  21     easily catch any FirewallHandler exception.
  22
  23     message - A descriptive error message.
  24     """
  25
  26     def __init__(self, message):
  27         r"Initialize the Error object. See class documentation for more info."
  28         self.message = message
  29
  30     def __str__(self):
  31         return self.message
  32
  33 class RuleError(Error, KeyError):
  34     r"""
  35     RuleError(rule) -> RuleError instance.
  36
  37     This is the base exception for all rule related errors.
  38     """
  39
  40     def __init__(self, rule):
  41         r"Initialize the object. See class documentation for more info."
  42         self.message = 'Rule error: "%s"' % rule
  43
  44 class RuleAlreadyExistsError(RuleError):
  45     r"""
  46     RuleAlreadyExistsError(rule) -> RuleAlreadyExistsError instance.
  47
  48     This exception is raised when trying to add a rule that already exists.
  49     """
  50
  51     def __init__(self, rule):
  52         r"Initialize the object. See class documentation for more info."
  53         self.message = 'Rule already exists: "%s"' % rule
  54
  55 class RuleNotFoundError(RuleError):
  56     r"""
  57     RuleNotFoundError(rule) -> RuleNotFoundError instance.
  58
  59     This exception is raised when trying to operate on a rule that doesn't
  60     exists.
  61     """
  62
  63     def __init__(self, rule):
  64         r"Initialize the object. See class documentation for more info."
  65         self.message = 'Rule not found: "%s"' % rule
  66
  67 class Rule(Sequence):
  68     r"""Rule(chain, target[, src[, dst[, ...]]]) -> Rule instance.
  69
  70     chain - INPUT, OUTPUT or FORWARD.
  71     target - ACCEPT, REJECT or DROP.
  72     src - Source subnet as IP/mask.
  73     dst - Destination subnet as IP/mask.
  74     protocol - ICMP, UDP, TCP or ALL.
  75     src_port - Source port (only for UDP or TCP protocols).
  76     dst_port - Destination port (only for UDP or TCP protocols).
  77     """
  78
  79     def __init__(self, chain, target, src=None, dst=None, protocol=None,
  80                        src_port=None, dst_port=None):
  81         r"Initialize object, see class documentation for details."
  82         self.chain = chain
  83         self.target = target
  84         self.src = src
  85         self.dst = dst
  86         self.protocol = protocol
  87         # TODO Validate that src_port and dst_port could be not None only
  88         # if the protocol is UDP or TCP
  89         self.src_port = src_port
  90         self.dst_port = dst_port
  91
  92     def update(self, chain=None, target=None, src=None, dst=None, protocol=None,
  93                        src_port=None, dst_port=None):
  94         r"update([chain[, ...]]) -> Update the values of a rule (see Rule doc)."
  95         if chain is not None: self.chain = chain
  96         if target is not None: self.target = target
  97         if src is not None: self.src = src
  98         if dst is not None: self.dst = dst
  99         if protocol is not None: self.protocol = protocol
 100         # TODO Validate that src_port and dst_port could be not None only
 101         # if the protocol is UDP or TCP
 102         if src_port is not None: self.src_port = src_port
 103         if dst_port is not None: self.dst_port = dst_port
 104
 105     def __cmp__(self, other):
 106         r"Compares two Rule objects."
 107         if self.chain == other.chain \
 108                 and self.target == other.target \
 109                 and self.src == other.src \
 110                 and self.dst == other.dst \
 111                 and self.protocol == other.protocol \
 112                 and self.src_port == other.src_port \
 113                 and self.dst_port == other.dst_port:
 114             return 0
 115         return cmp(id(self), id(other))
 116
 117     def as_tuple(self):
 118         r"Return a tuple representing the rule."
 119         return (self.chain, self.target, self.src, self.dst, self.protocol,
 120                     self.src_port)
 121
 122 class RuleHandler(Handler):
 123     r"""RuleHandler(rules) -> RuleHandler instance :: Handle a list of rules.
 124
 125     This class is a helper for FirewallHandler to do all the work related to rules
 126     administration.
 127
 128     rules - A list of Rule objects.
 129     """
 130
 131     def __init__(self, rules):
 132         r"Initialize the object, see class documentation for details."
 133         self.rules = rules
 134
 135     @handler(u'Add a new rule.')
 136     def add(self, *args, **kwargs):
 137         r"add(rule) -> None :: Add a rule to the rules list (see Rule doc)."
 138         rule = Rule(*args, **kwargs)
 139         if rule in self.rules:
 140             raise RuleAlreadyExistsError(rule)
 141         self.rules.append(rule)
 142
 143     @handler(u'Update a rule.')
 144     def update(self, index, *args, **kwargs):
 145         r"update(index, rule) -> None :: Update a rule (see Rule doc)."
 146         # TODO check if the modified rule is the same of an existing one
 147         index = int(index) # TODO validation
 148         try:
 149             self.rules[index].update(*args, **kwargs)
 150         except IndexError:
 151             raise RuleNotFoundError(index)
 152
 153     @handler(u'Delete a rule.')
 154     def delete(self, index):
 155         r"delete(index) -> Rule :: Delete a rule from the list returning it."
 156         index = int(index) # TODO validation
 157         try:
 158             return self.rules.pop(index)
 159         except IndexError:
 160             raise RuleNotFoundError(index)
 161
 162     @handler(u'Get information about a rule.')
 163     def get(self, index):
 164         r"get(rule) -> Rule :: Get all the information about a rule."
 165         index = int(index) # TODO validation
 166         try:
 167             return self.rules[index]
 168         except IndexError:
 169             raise RuleNotFoundError(index)
 170
 171     @handler(u'Get information about all rules.')
 172     def show(self):
 173         r"show() -> list of Rules :: List all the complete rules information."
 174         return self.rules
 175
 176 class FirewallHandler(Restorable, ConfigWriter, ServiceHandler,
 177                                                         TransactionalHandler):
 178     r"""FirewallHandler([pickle_dir[, config_dir]]) -> FirewallHandler instance.
 179
 180     Handles firewall commands using iptables.
 181
 182     pickle_dir - Directory where to write the persistent configuration data.
 183
 184     config_dir - Directory where to store de generated configuration files.
 185
 186     Both defaults to the current working directory.
 187     """
 188
 189     _persistent_vars = 'rules'
 190
 191     _restorable_defaults = dict(rules=list())
 192
 193     _config_writer_files = 'iptables.sh'
 194     _config_writer_tpl_dir = path.join(path.dirname(__file__), 'templates')
 195
 196     def __init__(self, pickle_dir='.', config_dir='.'):
 197         r"Initialize the object, see class documentation for details."
 198         self._persistent_dir = pickle_dir
 199         self._config_writer_cfg_dir = config_dir
 200         self._service_start = path.join(self._config_writer_cfg_dir,
 201                                                     self._config_writer_files)
 202         self._service_stop = ('iptables', '-t', 'filter', '-F')
 203         self._service_restart = self._service_start
 204         self._service_reload = self._service_start
 205         self._config_build_templates()
 206         self._restore()
 207         self.rule = RuleHandler(self.rules)
 208
 209     def _get_config_vars(self, config_file):
 210         return dict(rules=self.rules)
 211
 212 if __name__ == '__main__':
 213
 214     import os
 215
 216     fw_handler = FirewallHandler()
 217
 218     def dump():
 219         print '-' * 80
 220         print 'Rules:'
 221         print fw_handler.rule.show()
 222         print '-' * 80
 223
 224     dump()
 225
 226     fw_handler.rule.add('input','drop','icmp')
 227
 228     fw_handler.rule.update(0, dst='192.168.0.188/32')
 229
 230     fw_handler.rule.add('output','accept', '192.168.1.0/24')
 231
 232     fw_handler.commit()
 233
 234     fw_handler.stop()
 235
 236     dump()
 237
 238     os.system('rm -f *.pkl iptables.sh')
 239