New action NXAST_RESUBMIT_TABLE.
[openvswitch] / debian / ovs-monitor-ipsec
1 #!/usr/bin/python
2 # Copyright (c) 2009, 2010, 2011 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 #  - If a certificate is badly formed, Racoon will refuse to start.  We
24 #    should do a better job of verifying certificates are valid before
25 #    adding an interface to racoon.conf.
26
27
28 import getopt
29 import glob
30 import logging, logging.handlers
31 import os
32 import subprocess
33 import sys
34
35 from ovs.db import error
36 from ovs.db import types
37 import ovs.util
38 import ovs.daemon
39 import ovs.db.idl
40
41
42 # By default log messages as DAEMON into syslog
43 s_log = logging.getLogger("ovs-monitor-ipsec")
44 l_handler = logging.handlers.SysLogHandler(
45         "/dev/log",
46         facility=logging.handlers.SysLogHandler.LOG_DAEMON)
47 l_formatter = logging.Formatter('%(filename)s: %(levelname)s: %(message)s')
48 l_handler.setFormatter(l_formatter)
49 s_log.addHandler(l_handler)
50
51
52 setkey = "/usr/sbin/setkey"
53
54 # Class to configure the racoon daemon, which handles IKE negotiation
55 class Racoon:
56     # Default locations for files
57     conf_file = "/etc/racoon/racoon.conf"
58     cert_dir = "/etc/racoon/certs"
59     psk_file = "/etc/racoon/psk.txt"
60
61     # Racoon configuration header we use for IKE
62     conf_header = """# Configuration file generated by Open vSwitch
63 #
64 # Do not modify by hand!
65
66 path pre_shared_key "%s";
67 path certificate "%s";
68
69 """
70
71     # Racoon configuration footer we use for IKE
72     conf_footer = """sainfo anonymous {
73         pfs_group 2;
74         lifetime time 1 hour;
75         encryption_algorithm aes;
76         authentication_algorithm hmac_sha1, hmac_md5;
77         compression_algorithm deflate;
78 }
79
80 """
81
82     # Certificate entry template.
83     cert_entry = """remote %s {
84         exchange_mode main;
85         nat_traversal on;
86         ike_frag on;
87         certificate_type x509 "%s" "%s";
88         my_identifier asn1dn;
89         peers_identifier asn1dn;
90         peers_certfile x509 "%s";
91         verify_identifier on;
92         proposal {
93                 encryption_algorithm aes;
94                 hash_algorithm sha1;
95                 authentication_method rsasig;
96                 dh_group 2;
97         }
98 }
99
100 """
101
102     # Pre-shared key template.
103     psk_entry = """remote %s {
104         exchange_mode main;
105         nat_traversal on;
106         proposal {
107                 encryption_algorithm aes;
108                 hash_algorithm sha1;
109                 authentication_method pre_shared_key;
110                 dh_group 2;
111         }
112 }
113
114 """
115
116     def __init__(self):
117         self.psk_hosts = {}
118         self.cert_hosts = {}
119
120         if not os.path.isdir(self.cert_dir):
121             os.mkdir(self.cert_dir)
122
123         # Clean out stale peer certs from previous runs
124         for ovs_cert in glob.glob("%s/ovs-*.pem" % self.cert_dir):
125             try:
126                 os.remove(ovs_cert)
127             except OSError:
128                 s_log.warning("couldn't remove %s" % ovs_cert)
129
130         # Replace racoon's conf file with our template
131         self.commit()
132
133     def reload(self):
134         exitcode = subprocess.call(["/etc/init.d/racoon", "reload"])
135         if exitcode != 0:
136             # Racoon is finicky about it's configuration file and will
137             # refuse to start if it sees something it doesn't like
138             # (e.g., a certificate file doesn't exist).  Try restarting
139             # the process before giving up.
140             s_log.warning("attempting to restart racoon")
141             exitcode = subprocess.call(["/etc/init.d/racoon", "restart"])
142             if exitcode != 0:
143                 s_log.warning("couldn't reload racoon")
144
145     def commit(self):
146         # Rewrite the Racoon configuration file
147         conf_file = open(self.conf_file, 'w')
148         conf_file.write(Racoon.conf_header % (self.psk_file, self.cert_dir))
149
150         for host, vals in self.cert_hosts.iteritems():
151             conf_file.write(Racoon.cert_entry % (host, vals["certificate"],
152                     vals["private_key"], vals["peer_cert_file"]))
153
154         for host in self.psk_hosts:
155             conf_file.write(Racoon.psk_entry % host)
156
157         conf_file.write(Racoon.conf_footer)
158         conf_file.close()
159
160         # Rewrite the pre-shared keys file; it must only be readable by root.
161         orig_umask = os.umask(0077)
162         psk_file = open(Racoon.psk_file, 'w')
163         os.umask(orig_umask)
164
165         psk_file.write("# Generated by Open vSwitch...do not modify by hand!")
166         psk_file.write("\n\n")
167         for host, vals in self.psk_hosts.iteritems():
168             psk_file.write("%s   %s\n" % (host, vals["psk"]))
169         psk_file.close()
170
171         self.reload()
172
173     def _add_psk(self, host, psk):
174         if host in self.cert_hosts:
175             raise error.Error("host %s already defined for cert" % host)
176
177         self.psk_hosts[host] = psk
178         self.commit()
179
180     def _verify_certs(self, vals):
181         # Racoon will refuse to start if the certificate files don't
182         # exist, so verify that they're there.
183         if not os.path.isfile(vals["certificate"]):
184             raise error.Error("'certificate' file does not exist: %s"
185                     % vals["certificate"])
186         elif not os.path.isfile(vals["private_key"]):
187             raise error.Error("'private_key' file does not exist: %s"
188                     % vals["private_key"])
189
190         # Racoon won't start if a given certificate or private key isn't
191         # valid.  This is a weak test, but will detect the most flagrant
192         # errors.
193         if vals["peer_cert"].find("-----BEGIN CERTIFICATE-----") == -1:
194             raise error.Error("'peer_cert' is not in valid PEM format")
195
196         cert = open(vals["certificate"]).read()
197         if cert.find("-----BEGIN CERTIFICATE-----") == -1:
198             raise error.Error("'certificate' is not in valid PEM format")
199
200         cert = open(vals["private_key"]).read()
201         if cert.find("-----BEGIN RSA PRIVATE KEY-----") == -1:
202             raise error.Error("'private_key' is not in valid PEM format")
203             
204
205     def _add_cert(self, host, vals):
206         if host in self.psk_hosts:
207             raise error.Error("host %s already defined for psk" % host)
208
209         if vals["certificate"] == None:
210             raise error.Error("'certificate' not defined for %s" % host)
211         elif vals["private_key"] == None:
212             # Assume the private key is stored in the same PEM file as 
213             # the certificate.  We make a copy of "vals" so that we don't
214             # modify the original "vals", which would cause the script
215             # to constantly think that the configuration has changed
216             # in the database.
217             vals = vals.copy()
218             vals["private_key"] = vals["certificate"]
219
220         self._verify_certs(vals)
221
222         # The peer's certificate comes to us in PEM format as a string.
223         # Write that string to a file for Racoon to use.
224         peer_cert_file = "%s/ovs-%s.pem" % (self.cert_dir, host)
225         f = open(peer_cert_file, "w")
226         f.write(vals["peer_cert"])
227         f.close()
228
229         vals["peer_cert_file"] = peer_cert_file
230
231         self.cert_hosts[host] = vals
232         self.commit()
233
234     def _del_cert(self, host):
235         peer_cert_file = self.cert_hosts[host]["peer_cert_file"]
236         del self.cert_hosts[host]
237         self.commit()
238         try:
239             os.remove(peer_cert_file)
240         except OSError:
241             pass
242
243     def add_entry(self, host, vals):
244         if vals["peer_cert"]:
245             self._add_cert(host, vals)
246         elif vals["psk"]:
247             self._add_psk(host, vals)
248
249     def del_entry(self, host):
250         if host in self.cert_hosts:
251             self._del_cert(host)
252         elif host in self.psk_hosts:
253             del self.psk_hosts[host]
254             self.commit()
255
256
257 # Class to configure IPsec on a system using racoon for IKE and setkey
258 # for maintaining the Security Association Database (SAD) and Security
259 # Policy Database (SPD).  Only policies for GRE are supported.
260 class IPsec:
261     def __init__(self):
262         self.sad_flush()
263         self.spd_flush()
264         self.racoon = Racoon()
265         self.entries = []
266
267     def call_setkey(self, cmds):
268         try:
269             p = subprocess.Popen([setkey, "-c"], stdin=subprocess.PIPE, 
270                     stdout=subprocess.PIPE)
271         except:
272             s_log.error("could not call setkey")
273             sys.exit(1)
274
275         # xxx It is safer to pass the string into the communicate()
276         # xxx method, but it didn't work for slightly longer commands.
277         # xxx An alternative may need to be found.
278         p.stdin.write(cmds)
279         return p.communicate()[0]
280
281     def get_spi(self, local_ip, remote_ip, proto="esp"):
282         # Run the setkey dump command to retrieve the SAD.  Then, parse
283         # the output looking for SPI buried in the output.  Note that
284         # multiple SAD entries can exist for the same "flow", since an
285         # older entry could be in a "dying" state.
286         spi_list = []
287         host_line = "%s %s" % (local_ip, remote_ip)
288         results = self.call_setkey("dump ;").split("\n")
289         for i in range(len(results)):
290             if results[i].strip() == host_line:
291                 # The SPI is in the line following the host pair
292                 spi_line = results[i+1]
293                 if (spi_line[1:4] == proto):
294                     spi = spi_line.split()[2]
295                     spi_list.append(spi.split('(')[1].rstrip(')'))
296         return spi_list
297
298     def sad_flush(self):
299         self.call_setkey("flush;")
300
301     def sad_del(self, local_ip, remote_ip):
302         # To delete all SAD entries, we should be able to use setkey's
303         # "deleteall" command.  Unfortunately, it's fundamentally broken
304         # on Linux and not documented as such.
305         cmds = ""
306
307         # Delete local_ip->remote_ip SAD entries
308         spi_list = self.get_spi(local_ip, remote_ip)
309         for spi in spi_list:
310             cmds += "delete %s %s esp %s;\n" % (local_ip, remote_ip, spi)
311
312         # Delete remote_ip->local_ip SAD entries
313         spi_list = self.get_spi(remote_ip, local_ip)
314         for spi in spi_list:
315             cmds += "delete %s %s esp %s;\n" % (remote_ip, local_ip, spi)
316
317         if cmds:
318             self.call_setkey(cmds)
319
320     def spd_flush(self):
321         self.call_setkey("spdflush;")
322
323     def spd_add(self, local_ip, remote_ip):
324         cmds = ("spdadd %s %s gre -P out ipsec esp/transport//require;\n" %
325                     (local_ip, remote_ip))
326         cmds += ("spdadd %s %s gre -P in ipsec esp/transport//require;" %
327                     (remote_ip, local_ip))
328         self.call_setkey(cmds)
329
330     def spd_del(self, local_ip, remote_ip):
331         cmds = "spddelete %s %s gre -P out;\n" % (local_ip, remote_ip)
332         cmds += "spddelete %s %s gre -P in;" % (remote_ip, local_ip)
333         self.call_setkey(cmds)
334
335     def add_entry(self, local_ip, remote_ip, vals):
336         if remote_ip in self.entries:
337             raise error.Error("host %s already configured for ipsec"
338                               % remote_ip)
339
340         self.racoon.add_entry(remote_ip, vals)
341         self.spd_add(local_ip, remote_ip)
342
343         self.entries.append(remote_ip)
344
345
346     def del_entry(self, local_ip, remote_ip):
347         if remote_ip in self.entries:
348             self.racoon.del_entry(remote_ip)
349             self.spd_del(local_ip, remote_ip)
350             self.sad_del(local_ip, remote_ip)
351
352             self.entries.remove(remote_ip)
353
354
355 def keep_table_columns(schema, table_name, column_types):
356     table = schema.tables.get(table_name)
357     if not table:
358         raise error.Error("schema has no %s table" % table_name)
359
360     new_columns = {}
361     for column_name, column_type in column_types.iteritems():
362         column = table.columns.get(column_name)
363         if not column:
364             raise error.Error("%s table schema lacks %s column"
365                               % (table_name, column_name))
366         if column.type != column_type:
367             raise error.Error("%s column in %s table has type \"%s\", "
368                               "expected type \"%s\""
369                               % (column_name, table_name,
370                                  column.type.toEnglish(),
371                                  column_type.toEnglish()))
372         new_columns[column_name] = column
373     table.columns = new_columns
374     return table
375  
376 def monitor_uuid_schema_cb(schema):
377     string_type = types.Type(types.BaseType(types.StringType))
378     optional_ssl_type = types.Type(types.BaseType(types.UuidType,
379                                                   ref_table='SSL'), None, 0, 1)
380     string_map_type = types.Type(types.BaseType(types.StringType),
381                                  types.BaseType(types.StringType),
382                                  0, sys.maxint)
383  
384     new_tables = {}
385     new_tables["Interface"] = keep_table_columns(
386         schema, "Interface", {"name": string_type,
387                               "type": string_type,
388                               "options": string_map_type})
389     new_tables["Open_vSwitch"] = keep_table_columns(
390         schema, "Open_vSwitch", {"ssl": optional_ssl_type})
391     new_tables["SSL"] = keep_table_columns(
392         schema, "SSL", {"certificate": string_type,
393                         "private_key": string_type})
394     schema.tables = new_tables
395
396 def usage():
397     print "usage: %s [OPTIONS] DATABASE" % sys.argv[0]
398     print "where DATABASE is a socket on which ovsdb-server is listening."
399     ovs.daemon.usage()
400     print "Other options:"
401     print "  -h, --help               display this help message"
402     sys.exit(0)
403  
404 def update_ipsec(ipsec, interfaces, new_interfaces):
405     for name, vals in interfaces.iteritems():
406         if name not in new_interfaces:
407             ipsec.del_entry(vals["local_ip"], vals["remote_ip"])
408
409     for name, vals in new_interfaces.iteritems():
410         orig_vals = interfaces.get(name)
411         if orig_vals:
412             # Configuration for this host already exists.  Check if it's
413             # changed.
414             if vals == orig_vals:
415                 continue
416             else:
417                 ipsec.del_entry(vals["local_ip"], vals["remote_ip"])
418
419         try:
420             ipsec.add_entry(vals["local_ip"], vals["remote_ip"], vals)
421         except error.Error, msg:
422             s_log.warning("skipping ipsec config for %s: %s" % (name, msg))
423
424 def get_ssl_cert(data):
425     for ovs_rec in data["Open_vSwitch"].itervalues():
426         if ovs_rec.ssl.as_list():
427             ssl_rec = data["SSL"][ovs_rec.ssl.as_scalar()]
428             return (ssl_rec.certificate.as_scalar(),
429                     ssl_rec.private_key.as_scalar())
430
431     return None
432
433 def main(argv):
434     try:
435         options, args = getopt.gnu_getopt(
436             argv[1:], 'h', ['help'] + ovs.daemon.LONG_OPTIONS)
437     except getopt.GetoptError, geo:
438         sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
439         sys.exit(1)
440  
441     for key, value in options:
442         if key in ['-h', '--help']:
443             usage()
444         elif not ovs.daemon.parse_opt(key, value):
445             sys.stderr.write("%s: unhandled option %s\n"
446                              % (ovs.util.PROGRAM_NAME, key))
447             sys.exit(1)
448  
449     if len(args) != 1:
450         sys.stderr.write("%s: exactly one nonoption argument is required "
451                          "(use --help for help)\n" % ovs.util.PROGRAM_NAME)
452         sys.exit(1)
453
454     remote = args[0]
455     idl = ovs.db.idl.Idl(remote, "Open_vSwitch", monitor_uuid_schema_cb)
456
457     ovs.daemon.daemonize()
458
459     ipsec = IPsec()
460
461     interfaces = {}
462     while True:
463         if not idl.run():
464             poller = ovs.poller.Poller()
465             idl.wait(poller)
466             poller.block()
467             continue
468
469         ssl_cert = get_ssl_cert(idl.data)
470  
471         new_interfaces = {}
472         for rec in idl.data["Interface"].itervalues():
473             if rec.type.as_scalar() == "ipsec_gre":
474                 name = rec.name.as_scalar()
475                 entry = {
476                     "remote_ip": rec.options.get("remote_ip"),
477                     "local_ip": rec.options.get("local_ip", "0.0.0.0/0"),
478                     "certificate": rec.options.get("certificate"),
479                     "private_key": rec.options.get("private_key"),
480                     "use_ssl_cert": rec.options.get("use_ssl_cert"),
481                     "peer_cert": rec.options.get("peer_cert"),
482                     "psk": rec.options.get("psk") }
483
484                 if entry["peer_cert"] and entry["psk"]:
485                     s_log.warning("both 'peer_cert' and 'psk' defined for %s" 
486                             % name)
487                     continue
488                 elif not entry["peer_cert"] and not entry["psk"]:
489                     s_log.warning("no 'peer_cert' or 'psk' defined for %s" 
490                             % name)
491                     continue
492
493                 # The "use_ssl_cert" option is deprecated and will
494                 # likely go away in the near future.
495                 if entry["use_ssl_cert"] == "true":
496                     if not ssl_cert:
497                         s_log.warning("no valid SSL entry for %s" % name)
498                         continue
499
500                     entry["certificate"] = ssl_cert[0]
501                     entry["private_key"] = ssl_cert[1]
502
503                 new_interfaces[name] = entry
504  
505         if interfaces != new_interfaces:
506             update_ipsec(ipsec, interfaces, new_interfaces)
507             interfaces = new_interfaces
508  
509 if __name__ == '__main__':
510     try:
511         main(sys.argv)
512     except SystemExit:
513         # Let system.exit() calls complete normally
514         raise
515     except:
516         s_log.exception("traceback")
517         sys.exit(ovs.daemon.RESTART_EXIT_CODE)