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