pintos-os.org Git - openvswitch/blob - debian/ovs-monitor-ipsec

   1 #!/usr/bin/python
   2 # Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
   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 argparse
  29 import glob
  30 import os
  31 import subprocess
  32 import sys
  33
  34 import ovs.dirs
  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 import ovs.unixctl
  41 import ovs.vlog
  42
  43 vlog = ovs.vlog.Vlog("ovs-monitor-ipsec")
  44 root_prefix = ''                # Prefix for absolute file names, for testing.
  45 SETKEY = "/usr/sbin/setkey"
  46 exiting = False
  47
  48
  49 def unixctl_exit(conn, unused_argv, unused_aux):
  50     global exiting
  51     exiting = True
  52     conn.reply(None)
  53
  54
  55 # Class to configure the racoon daemon, which handles IKE negotiation
  56 class Racoon:
  57     # Default locations for files
  58     conf_file = "/etc/racoon/racoon.conf"
  59     cert_dir = "/etc/racoon/certs"
  60     psk_file = "/etc/racoon/psk.txt"
  61
  62     # Racoon configuration header we use for IKE
  63     conf_header = """# Configuration file generated by Open vSwitch
  64 #
  65 # Do not modify by hand!
  66
  67 path pre_shared_key "%s";
  68 path certificate "%s";
  69
  70 """
  71
  72     # Racoon configuration footer we use for IKE
  73     conf_footer = """sainfo anonymous {
  74         pfs_group 2;
  75         lifetime time 1 hour;
  76         encryption_algorithm aes;
  77         authentication_algorithm hmac_sha1, hmac_md5;
  78         compression_algorithm deflate;
  79 }
  80
  81 """
  82
  83     # Certificate entry template.
  84     cert_entry = """remote %s {
  85         exchange_mode main;
  86         nat_traversal on;
  87         ike_frag on;
  88         certificate_type x509 "%s" "%s";
  89         my_identifier asn1dn;
  90         peers_identifier asn1dn;
  91         peers_certfile x509 "%s";
  92         verify_identifier on;
  93         proposal {
  94                 encryption_algorithm aes;
  95                 hash_algorithm sha1;
  96                 authentication_method rsasig;
  97                 dh_group 2;
  98         }
  99 }
 100
 101 """
 102
 103     # Pre-shared key template.
 104     psk_entry = """remote %s {
 105         exchange_mode main;
 106         nat_traversal on;
 107         proposal {
 108                 encryption_algorithm aes;
 109                 hash_algorithm sha1;
 110                 authentication_method pre_shared_key;
 111                 dh_group 2;
 112         }
 113 }
 114
 115 """
 116
 117     def __init__(self):
 118         self.psk_hosts = {}
 119         self.cert_hosts = {}
 120
 121         if not os.path.isdir(root_prefix + self.cert_dir):
 122             os.mkdir(self.cert_dir)
 123
 124         # Clean out stale peer certs from previous runs
 125         for ovs_cert in glob.glob("%s%s/ovs-*.pem"
 126                                   % (root_prefix, self.cert_dir)):
 127             try:
 128                 os.remove(ovs_cert)
 129             except OSError:
 130                 vlog.warn("couldn't remove %s" % ovs_cert)
 131
 132         # Replace racoon's conf file with our template
 133         self.commit()
 134
 135     def reload(self):
 136         exitcode = subprocess.call([root_prefix + "/etc/init.d/racoon",
 137                                     "reload"])
 138         if exitcode != 0:
 139             # Racoon is finicky about its 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             vlog.warn("attempting to restart racoon")
 144             exitcode = subprocess.call([root_prefix + "/etc/init.d/racoon",
 145                                         "restart"])
 146             if exitcode != 0:
 147                 vlog.warn("couldn't reload racoon")
 148
 149     def commit(self):
 150         # Rewrite the Racoon configuration file
 151         conf_file = open(root_prefix + self.conf_file, 'w')
 152         conf_file.write(Racoon.conf_header % (self.psk_file, self.cert_dir))
 153
 154         for host, vals in self.cert_hosts.iteritems():
 155             conf_file.write(Racoon.cert_entry % (host, vals["certificate"],
 156                     vals["private_key"], vals["peer_cert_file"]))
 157
 158         for host in self.psk_hosts:
 159             conf_file.write(Racoon.psk_entry % host)
 160
 161         conf_file.write(Racoon.conf_footer)
 162         conf_file.close()
 163
 164         # Rewrite the pre-shared keys file; it must only be readable by root.
 165         orig_umask = os.umask(0077)
 166         psk_file = open(root_prefix + Racoon.psk_file, 'w')
 167         os.umask(orig_umask)
 168
 169         psk_file.write("# Generated by Open vSwitch...do not modify by hand!")
 170         psk_file.write("\n\n")
 171         for host, vals in self.psk_hosts.iteritems():
 172             psk_file.write("%s   %s\n" % (host, vals["psk"]))
 173         psk_file.close()
 174
 175         self.reload()
 176
 177     def _add_psk(self, host, psk):
 178         if host in self.cert_hosts:
 179             raise error.Error("host %s already defined for cert" % host)
 180
 181         self.psk_hosts[host] = psk
 182         self.commit()
 183
 184     def _verify_certs(self, vals):
 185         # Racoon will refuse to start if the certificate files don't
 186         # exist, so verify that they're there.
 187         if not os.path.isfile(root_prefix + vals["certificate"]):
 188             raise error.Error("'certificate' file does not exist: %s"
 189                     % vals["certificate"])
 190         elif not os.path.isfile(root_prefix + vals["private_key"]):
 191             raise error.Error("'private_key' file does not exist: %s"
 192                     % vals["private_key"])
 193
 194         # Racoon won't start if a given certificate or private key isn't
 195         # valid.  This is a weak test, but will detect the most flagrant
 196         # errors.
 197         if vals["peer_cert"].find("-----BEGIN CERTIFICATE-----") == -1:
 198             raise error.Error("'peer_cert' is not in valid PEM format")
 199
 200         cert = open(root_prefix + vals["certificate"]).read()
 201         if cert.find("-----BEGIN CERTIFICATE-----") == -1:
 202             raise error.Error("'certificate' is not in valid PEM format")
 203
 204         cert = open(root_prefix + vals["private_key"]).read()
 205         if cert.find("-----BEGIN RSA PRIVATE KEY-----") == -1:
 206             raise error.Error("'private_key' is not in valid PEM format")
 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         f = open(root_prefix + vals["peer_cert_file"], "w")
 228         f.write(vals["peer_cert"])
 229         f.close()
 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(root_prefix + 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([root_prefix + SETKEY, "-c"],
 270                                  stdin=subprocess.PIPE,
 271                                  stdout=subprocess.PIPE)
 272         except:
 273             vlog.err("could not call %s%s" % (root_prefix, SETKEY))
 274             sys.exit(1)
 275
 276         # xxx It is safer to pass the string into the communicate()
 277         # xxx method, but it didn't work for slightly longer commands.
 278         # xxx An alternative may need to be found.
 279         p.stdin.write(cmds)
 280         return p.communicate()[0]
 281
 282     def get_spi(self, local_ip, remote_ip, proto="esp"):
 283         # Run the setkey dump command to retrieve the SAD.  Then, parse
 284         # the output looking for SPI buried in the output.  Note that
 285         # multiple SAD entries can exist for the same "flow", since an
 286         # older entry could be in a "dying" state.
 287         spi_list = []
 288         host_line = "%s %s" % (local_ip, remote_ip)
 289         results = self.call_setkey("dump ;\n").split("\n")
 290         for i in range(len(results)):
 291             if results[i].strip() == host_line:
 292                 # The SPI is in the line following the host pair
 293                 spi_line = results[i + 1]
 294                 if (spi_line[1:4] == proto):
 295                     spi = spi_line.split()[2]
 296                     spi_list.append(spi.split('(')[1].rstrip(')'))
 297         return spi_list
 298
 299     def sad_flush(self):
 300         self.call_setkey("flush;\n")
 301
 302     def sad_del(self, local_ip, remote_ip):
 303         # To delete all SAD entries, we should be able to use setkey's
 304         # "deleteall" command.  Unfortunately, it's fundamentally broken
 305         # on Linux and not documented as such.
 306         cmds = ""
 307
 308         # Delete local_ip->remote_ip SAD entries
 309         spi_list = self.get_spi(local_ip, remote_ip)
 310         for spi in spi_list:
 311             cmds += "delete %s %s esp %s;\n" % (local_ip, remote_ip, spi)
 312
 313         # Delete remote_ip->local_ip SAD entries
 314         spi_list = self.get_spi(remote_ip, local_ip)
 315         for spi in spi_list:
 316             cmds += "delete %s %s esp %s;\n" % (remote_ip, local_ip, spi)
 317
 318         if cmds:
 319             self.call_setkey(cmds)
 320
 321     def spd_flush(self):
 322         self.call_setkey("spdflush;\n")
 323
 324     def spd_add(self, local_ip, remote_ip):
 325         cmds = ("spdadd %s %s gre -P out ipsec esp/transport//require;\n" %
 326                     (local_ip, remote_ip))
 327         cmds += ("spdadd %s %s gre -P in ipsec esp/transport//require;\n" %
 328                     (remote_ip, local_ip))
 329         self.call_setkey(cmds)
 330
 331     def spd_del(self, local_ip, remote_ip):
 332         cmds = "spddelete %s %s gre -P out;\n" % (local_ip, remote_ip)
 333         cmds += "spddelete %s %s gre -P in;\n" % (remote_ip, local_ip)
 334         self.call_setkey(cmds)
 335
 336     def add_entry(self, local_ip, remote_ip, vals):
 337         if remote_ip in self.entries:
 338             raise error.Error("host %s already configured for ipsec"
 339                               % remote_ip)
 340
 341         self.racoon.add_entry(remote_ip, vals)
 342         self.spd_add(local_ip, remote_ip)
 343
 344         self.entries.append(remote_ip)
 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 update_ipsec(ipsec, interfaces, new_interfaces):
 356     for name, vals in interfaces.iteritems():
 357         if name not in new_interfaces:
 358             ipsec.del_entry(vals["local_ip"], vals["remote_ip"])
 359
 360     for name, vals in new_interfaces.iteritems():
 361         orig_vals = interfaces.get(name)
 362         if orig_vals:
 363             # Configuration for this host already exists.  Check if it's
 364             # changed.  We use set difference, since we want to ignore
 365             # any local additions to "orig_vals" that we've made
 366             # (e.g. the "peer_cert_file" key).
 367             if set(vals.items()) - set(orig_vals.items()):
 368                 ipsec.del_entry(vals["local_ip"], vals["remote_ip"])
 369             else:
 370                 continue
 371
 372         try:
 373             ipsec.add_entry(vals["local_ip"], vals["remote_ip"], vals)
 374         except error.Error, msg:
 375             vlog.warn("skipping ipsec config for %s: %s" % (name, msg))
 376
 377
 378 def get_ssl_cert(data):
 379     for ovs_rec in data["Open_vSwitch"].rows.itervalues():
 380         if ovs_rec.ssl:
 381             ssl = ovs_rec.ssl[0]
 382             if ssl.certificate and ssl.private_key:
 383                 return (ssl.certificate, ssl.private_key)
 384
 385     return None
 386
 387
 388 def main():
 389
 390     parser = argparse.ArgumentParser()
 391     parser.add_argument("database", metavar="DATABASE",
 392                         help="A socket on which ovsdb-server is listening.")
 393     parser.add_argument("--root-prefix", metavar="DIR",
 394                         help="Use DIR as alternate root directory"
 395                         " (for testing).")
 396
 397     ovs.vlog.add_args(parser)
 398     ovs.daemon.add_args(parser)
 399     args = parser.parse_args()
 400     ovs.vlog.handle_args(args)
 401     ovs.daemon.handle_args(args)
 402
 403     global root_prefix
 404     if args.root_prefix:
 405         root_prefix = args.root_prefix
 406
 407     remote = args.database
 408     schema_helper = ovs.db.idl.SchemaHelper()
 409     schema_helper.register_columns("Interface", ["name", "type", "options"])
 410     schema_helper.register_columns("Open_vSwitch", ["ssl"])
 411     schema_helper.register_columns("SSL", ["certificate", "private_key"])
 412     idl = ovs.db.idl.Idl(remote, schema_helper)
 413
 414     ovs.daemon.daemonize()
 415
 416     ovs.unixctl.command_register("exit", "", 0, 0, unixctl_exit, None)
 417     error, unixctl_server = ovs.unixctl.UnixctlServer.create(None)
 418     if error:
 419         ovs.util.ovs_fatal(error, "could not create unixctl server", vlog)
 420
 421     ipsec = IPsec()
 422
 423     interfaces = {}
 424     seqno = idl.change_seqno    # Sequence number when we last processed the db
 425     while True:
 426         unixctl_server.run()
 427         if exiting:
 428             break
 429
 430         idl.run()
 431         if seqno == idl.change_seqno:
 432             poller = ovs.poller.Poller()
 433             unixctl_server.wait(poller)
 434             idl.wait(poller)
 435             poller.block()
 436             continue
 437         seqno = idl.change_seqno
 438
 439         ssl_cert = get_ssl_cert(idl.tables)
 440
 441         new_interfaces = {}
 442         for rec in idl.tables["Interface"].rows.itervalues():
 443             if rec.type == "ipsec_gre":
 444                 name = rec.name
 445                 options = rec.options
 446                 peer_cert_name = "ovs-%s.pem" % (options.get("remote_ip"))
 447                 entry = {
 448                     "remote_ip": options.get("remote_ip"),
 449                     "local_ip": options.get("local_ip", "0.0.0.0/0"),
 450                     "certificate": options.get("certificate"),
 451                     "private_key": options.get("private_key"),
 452                     "use_ssl_cert": options.get("use_ssl_cert"),
 453                     "peer_cert": options.get("peer_cert"),
 454                     "peer_cert_file": Racoon.cert_dir + "/" + peer_cert_name,
 455                     "psk": options.get("psk")}
 456
 457                 if entry["peer_cert"] and entry["psk"]:
 458                     vlog.warn("both 'peer_cert' and 'psk' defined for %s"
 459                               % name)
 460                     continue
 461                 elif not entry["peer_cert"] and not entry["psk"]:
 462                     vlog.warn("no 'peer_cert' or 'psk' defined for %s" % name)
 463                     continue
 464
 465                 # The "use_ssl_cert" option is deprecated and will
 466                 # likely go away in the near future.
 467                 if entry["use_ssl_cert"] == "true":
 468                     if not ssl_cert:
 469                         vlog.warn("no valid SSL entry for %s" % name)
 470                         continue
 471
 472                     entry["certificate"] = ssl_cert[0]
 473                     entry["private_key"] = ssl_cert[1]
 474
 475                 new_interfaces[name] = entry
 476
 477         if interfaces != new_interfaces:
 478             update_ipsec(ipsec, interfaces, new_interfaces)
 479             interfaces = new_interfaces
 480
 481     unixctl_server.close()
 482     idl.close()
 483
 484
 485 if __name__ == '__main__':
 486     try:
 487         main()
 488     except SystemExit:
 489         # Let system.exit() calls complete normally
 490         raise
 491     except:
 492         vlog.exception("traceback")
 493         sys.exit(ovs.daemon.RESTART_EXIT_CODE)