nicira-ext: Convert all "uintNN_t"s to "ovs_beNN"s.
[openvswitch] / debian / ovs-monitor-ipsec
1 #!/usr/bin/python
2 # Copyright (c) 2009, 2010 Nicira Networks
3 #
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
7 #
8 #     http://www.apache.org/licenses/LICENSE-2.0
9 #
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15
16
17 # A daemon to monitor attempts to create GRE-over-IPsec tunnels.
18 # Uses racoon and setkey to support the configuration.  Assumes that
19 # OVS has complete control over IPsec configuration for the box.
20
21 # xxx To-do:
22 #  - Doesn't actually check that Interface is connected to bridge
23 #  - Doesn't support cert authentication
24
25
26 import getopt
27 import logging, logging.handlers
28 import os
29 import stat
30 import subprocess
31 import sys
32
33 from ovs.db import error
34 from ovs.db import types
35 import ovs.util
36 import ovs.daemon
37 import ovs.db.idl
38
39
40 # By default log messages as DAEMON into syslog
41 s_log = logging.getLogger("ovs-monitor-ipsec")
42 l_handler = logging.handlers.SysLogHandler(
43         "/dev/log",
44         facility=logging.handlers.SysLogHandler.LOG_DAEMON)
45 l_formatter = logging.Formatter('%(filename)s: %(levelname)s: %(message)s')
46 l_handler.setFormatter(l_formatter)
47 s_log.addHandler(l_handler)
48
49
50 setkey = "/usr/sbin/setkey"
51
52 # Class to configure the racoon daemon, which handles IKE negotiation
53 class Racoon:
54     # Default locations for files
55     conf_file = "/etc/racoon/racoon.conf"
56     cert_file = "/etc/racoon/certs"
57     psk_file = "/etc/racoon/psk.txt"
58
59     # Default racoon configuration file we use for IKE
60     conf_template = """# Configuration file generated by Open vSwitch
61 #
62 # Do not modify by hand!
63
64 path pre_shared_key "/etc/racoon/psk.txt";
65 path certificate "/etc/racoon/certs";
66
67 remote anonymous {
68         exchange_mode main;
69         nat_traversal on;
70         proposal {
71                 encryption_algorithm aes;
72                 hash_algorithm sha1;
73                 authentication_method pre_shared_key;
74                 dh_group 2;
75         }
76 }
77
78 sainfo anonymous {
79         pfs_group 2;
80         lifetime time 1 hour;
81         encryption_algorithm aes;
82         authentication_algorithm hmac_sha1, hmac_md5;
83         compression_algorithm deflate;
84 }
85 """
86
87     def __init__(self):
88         self.psk_hosts = {}
89         self.cert_hosts = {}
90
91         # Replace racoon's conf file with our template
92         f = open(Racoon.conf_file, "w")
93         f.write(Racoon.conf_template)
94         f.close()
95
96         # Clear out any pre-shared keys
97         self.commit_psk()
98
99         self.reload()
100
101     def reload(self):
102         exitcode = subprocess.call(["/etc/init.d/racoon", "reload"])
103         if exitcode != 0:
104             s_log.warning("couldn't reload racoon")
105
106     def commit_psk(self):
107         f = open(Racoon.psk_file, 'w')
108  
109         # The file must only be accessible by root
110         os.chmod(Racoon.psk_file, stat.S_IRUSR | stat.S_IWUSR)
111
112         f.write("# Generated by Open vSwitch...do not modify by hand!\n\n")
113         for host, psk in self.psk_hosts.iteritems():
114             f.write("%s   %s\n" % (host, psk))
115         f.close()
116
117     def add_psk(self, host, psk):
118         self.psk_hosts[host] = psk
119         self.commit_psk()
120
121     def del_psk(self, host):
122         if host in self.psk_hosts:
123             del self.psk_hosts[host]
124             self.commit_psk()
125
126
127 # Class to configure IPsec on a system using racoon for IKE and setkey
128 # for maintaining the Security Association Database (SAD) and Security
129 # Policy Database (SPD).  Only policies for GRE are supported.
130 class IPsec:
131     def __init__(self):
132         self.sad_flush()
133         self.spd_flush()
134         self.racoon = Racoon()
135
136     def call_setkey(self, cmds):
137         try:
138             p = subprocess.Popen([setkey, "-c"], stdin=subprocess.PIPE, 
139                     stdout=subprocess.PIPE)
140         except:
141             s_log.error("could not call setkey")
142             sys.exit(1)
143
144         # xxx It is safer to pass the string into the communicate()
145         # xxx method, but it didn't work for slightly longer commands.
146         # xxx An alternative may need to be found.
147         p.stdin.write(cmds)
148         return p.communicate()[0]
149
150     def get_spi(self, local_ip, remote_ip, proto="esp"):
151         # Run the setkey dump command to retrieve the SAD.  Then, parse
152         # the output looking for SPI buried in the output.  Note that
153         # multiple SAD entries can exist for the same "flow", since an
154         # older entry could be in a "dying" state.
155         spi_list = []
156         host_line = "%s %s" % (local_ip, remote_ip)
157         results = self.call_setkey("dump ;").split("\n")
158         for i in range(len(results)):
159             if results[i].strip() == host_line:
160                 # The SPI is in the line following the host pair
161                 spi_line = results[i+1]
162                 if (spi_line[1:4] == proto):
163                     spi = spi_line.split()[2]
164                     spi_list.append(spi.split('(')[1].rstrip(')'))
165         return spi_list
166
167     def sad_flush(self):
168         self.call_setkey("flush;")
169
170     def sad_del(self, local_ip, remote_ip):
171         # To delete all SAD entries, we should be able to use setkey's
172         # "deleteall" command.  Unfortunately, it's fundamentally broken
173         # on Linux and not documented as such.
174         cmds = ""
175
176         # Delete local_ip->remote_ip SAD entries
177         spi_list = self.get_spi(local_ip, remote_ip)
178         for spi in spi_list:
179             cmds += "delete %s %s esp %s;\n" % (local_ip, remote_ip, spi)
180
181         # Delete remote_ip->local_ip SAD entries
182         spi_list = self.get_spi(remote_ip, local_ip)
183         for spi in spi_list:
184             cmds += "delete %s %s esp %s;\n" % (remote_ip, local_ip, spi)
185
186         if cmds:
187             self.call_setkey(cmds)
188
189     def spd_flush(self):
190         self.call_setkey("spdflush;")
191
192     def spd_add(self, local_ip, remote_ip):
193         cmds = ("spdadd %s %s gre -P out ipsec esp/transport//default;" %
194                     (local_ip, remote_ip))
195         cmds += "\n"
196         cmds += ("spdadd %s %s gre -P in ipsec esp/transport//default;" %
197                     (remote_ip, local_ip))
198         self.call_setkey(cmds)
199
200     def spd_del(self, local_ip, remote_ip):
201         cmds = "spddelete %s %s gre -P out;" % (local_ip, remote_ip)
202         cmds += "\n"
203         cmds += "spddelete %s %s gre -P in;" % (remote_ip, local_ip)
204         self.call_setkey(cmds)
205
206     def ipsec_cert_del(self, local_ip, remote_ip):
207         # Need to support cert...right now only PSK supported
208         self.racoon.del_psk(remote_ip)
209         self.spd_del(local_ip, remote_ip)
210         self.sad_del(local_ip, remote_ip)
211
212     def ipsec_cert_update(self, local_ip, remote_ip, cert):
213         # Need to support cert...right now only PSK supported
214         self.racoon.add_psk(remote_ip, "abc12345")
215         self.spd_add(local_ip, remote_ip)
216
217     def ipsec_psk_del(self, local_ip, remote_ip):
218         self.racoon.del_psk(remote_ip)
219         self.spd_del(local_ip, remote_ip)
220         self.sad_del(local_ip, remote_ip)
221
222     def ipsec_psk_update(self, local_ip, remote_ip, psk):
223         self.racoon.add_psk(remote_ip, psk)
224         self.spd_add(local_ip, remote_ip)
225
226
227 def keep_table_columns(schema, table_name, column_types):
228     table = schema.tables.get(table_name)
229     if not table:
230         raise error.Error("schema has no %s table" % table_name)
231
232     new_columns = {}
233     for column_name, column_type in column_types.iteritems():
234         column = table.columns.get(column_name)
235         if not column:
236             raise error.Error("%s table schema lacks %s column"
237                               % (table_name, column_name))
238         if column.type != column_type:
239             raise error.Error("%s column in %s table has type \"%s\", "
240                               "expected type \"%s\""
241                               % (column_name, table_name,
242                                  column.type.toEnglish(),
243                                  column_type.toEnglish()))
244         new_columns[column_name] = column
245     table.columns = new_columns
246     return table
247  
248 def monitor_uuid_schema_cb(schema):
249     string_type = types.Type(types.BaseType(types.StringType))
250     string_map_type = types.Type(types.BaseType(types.StringType),
251                                  types.BaseType(types.StringType),
252                                  0, sys.maxint)
253  
254     new_tables = {}
255     new_tables["Interface"] = keep_table_columns(
256         schema, "Interface", {"name": string_type,
257                               "type": string_type,
258                               "options": string_map_type,
259                               "other_config": string_map_type})
260     schema.tables = new_tables
261
262 def usage():
263     print "usage: %s [OPTIONS] DATABASE" % sys.argv[0]
264     print "where DATABASE is a socket on which ovsdb-server is listening."
265     ovs.daemon.usage()
266     print "Other options:"
267     print "  -h, --help               display this help message"
268     sys.exit(0)
269  
270 def main(argv):
271     try:
272         options, args = getopt.gnu_getopt(
273             argv[1:], 'h', ['help'] + ovs.daemon.LONG_OPTIONS)
274     except getopt.GetoptError, geo:
275         sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
276         sys.exit(1)
277  
278     for key, value in options:
279         if key in ['-h', '--help']:
280             usage()
281         elif not ovs.daemon.parse_opt(key, value):
282             sys.stderr.write("%s: unhandled option %s\n"
283                              % (ovs.util.PROGRAM_NAME, key))
284             sys.exit(1)
285  
286     if len(args) != 1:
287         sys.stderr.write("%s: exactly one nonoption argument is required "
288                          "(use --help for help)\n" % ovs.util.PROGRAM_NAME)
289         sys.exit(1)
290
291     ovs.daemon.die_if_already_running()
292  
293     remote = args[0]
294     idl = ovs.db.idl.Idl(remote, "Open_vSwitch", monitor_uuid_schema_cb)
295
296     ovs.daemon.daemonize()
297
298     ipsec = IPsec()
299
300     interfaces = {}
301     while True:
302         if not idl.run():
303             poller = ovs.poller.Poller()
304             idl.wait(poller)
305             poller.block()
306             continue
307  
308         new_interfaces = {}
309         for rec in idl.data["Interface"].itervalues():
310             name = rec.name.as_scalar()
311             ipsec_cert = rec.other_config.get("ipsec_cert")
312             ipsec_psk = rec.other_config.get("ipsec_psk")
313             is_ipsec = ipsec_cert or ipsec_psk
314
315             if rec.type.as_scalar() == "gre" and is_ipsec:
316                 new_interfaces[name] = {
317                         "remote_ip": rec.options.get("remote_ip"),
318                         "local_ip": rec.options.get("local_ip", "0.0.0.0/0"),
319                         "ipsec_cert": ipsec_cert,
320                         "ipsec_psk": ipsec_psk }
321  
322         if interfaces != new_interfaces:
323             for name, vals in interfaces.items():
324                 if name not in new_interfaces.keys():
325                     ipsec.ipsec_cert_del(vals["local_ip"], vals["remote_ip"])
326             for name, vals in new_interfaces.items():
327                 if vals == interfaces.get(name):
328                     s_log.warning(
329                         "configuration changed for %s, need to delete "
330                         "interface first" % name)
331                     continue
332
333                 if vals["ipsec_cert"]:
334                     ipsec.ipsec_cert_update(vals["local_ip"],
335                             vals["remote_ip"], vals["ipsec_cert"])
336                 elif vals["ipsec_psk"]:
337                     ipsec.ipsec_psk_update(vals["local_ip"], 
338                             vals["remote_ip"], vals["ipsec_psk"])
339                 else:
340                     s_log.warning(
341                         "no ipsec_cert or ipsec_psk defined for %s" % name)
342                     continue
343
344             interfaces = new_interfaces
345  
346 if __name__ == '__main__':
347     try:
348         main(sys.argv)
349     except SystemExit:
350         # Let system.exit() calls complete normally
351         raise
352     except:
353         s_log.exception("traceback")
354         sys.exit(ovs.daemon.RESTART_EXIT_CODE)