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