mirror of
https://salsa.debian.org/freeipa-team/freeipa.git
synced 2024-12-26 17:01:14 -06:00
1bc892c02d
The CA cert was not loaded, so if it was missing from the PKCS#12 file, installation would fail. Pass the cert filename to the server installers and include it in the NSS DB. Part of the work for: https://fedorahosted.org/freeipa/ticket/3363
407 lines
16 KiB
Python
407 lines
16 KiB
Python
# Authors: Rob Crittenden <rcritten@redhat.com>
|
|
#
|
|
# Copyright (C) 2007 Red Hat
|
|
# see file 'COPYING' for use and warranty information
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
|
|
import os
|
|
import os.path
|
|
import tempfile
|
|
import pwd
|
|
import shutil
|
|
|
|
import service
|
|
import certs
|
|
import installutils
|
|
from ipapython import sysrestore
|
|
from ipapython import ipautil
|
|
from ipapython import services as ipaservices
|
|
from ipapython import dogtag
|
|
from ipapython.ipa_log_manager import *
|
|
from ipalib import api
|
|
|
|
HTTPD_DIR = "/etc/httpd"
|
|
SSL_CONF = HTTPD_DIR + "/conf.d/ssl.conf"
|
|
NSS_CONF = HTTPD_DIR + "/conf.d/nss.conf"
|
|
|
|
selinux_warning = """
|
|
WARNING: could not set selinux boolean(s) %(var)s to true. The web
|
|
interface may not function correctly until this boolean is successfully
|
|
change with the command:
|
|
/usr/sbin/setsebool -P %(var)s true
|
|
Try updating the policycoreutils and selinux-policy packages.
|
|
"""
|
|
|
|
class WebGuiInstance(service.SimpleServiceInstance):
|
|
def __init__(self):
|
|
service.SimpleServiceInstance.__init__(self, "ipa_webgui")
|
|
|
|
class HTTPInstance(service.Service):
|
|
def __init__(self, fstore=None, cert_nickname='Server-Cert'):
|
|
service.Service.__init__(self, "httpd", service_desc="the web interface")
|
|
if fstore:
|
|
self.fstore = fstore
|
|
else:
|
|
self.fstore = sysrestore.FileStore('/var/lib/ipa/sysrestore')
|
|
|
|
self.cert_nickname = cert_nickname
|
|
|
|
subject_base = ipautil.dn_attribute_property('_subject_base')
|
|
|
|
def create_instance(self, realm, fqdn, domain_name, dm_password=None,
|
|
autoconfig=True, pkcs12_info=None,
|
|
self_signed_ca=False, subject_base=None,
|
|
auto_redirect=True, ca_file=None):
|
|
self.fqdn = fqdn
|
|
self.realm = realm
|
|
self.domain = domain_name
|
|
self.dm_password = dm_password
|
|
self.suffix = ipautil.realm_to_suffix(self.realm)
|
|
self.pkcs12_info = pkcs12_info
|
|
self.self_signed_ca = self_signed_ca
|
|
self.principal = "HTTP/%s@%s" % (self.fqdn, self.realm)
|
|
self.dercert = None
|
|
self.subject_base = subject_base
|
|
self.sub_dict = dict(
|
|
REALM=realm,
|
|
FQDN=fqdn,
|
|
DOMAIN=self.domain,
|
|
AUTOREDIR='' if auto_redirect else '#',
|
|
CRL_PUBLISH_PATH=dogtag.install_constants.CRL_PUBLISH_PATH,
|
|
)
|
|
self.ca_file = ca_file
|
|
|
|
# get a connection to the DS
|
|
self.ldap_connect()
|
|
|
|
|
|
self.step("disabling mod_ssl in httpd", self.__disable_mod_ssl)
|
|
self.step("setting mod_nss port to 443", self.__set_mod_nss_port)
|
|
self.step("setting mod_nss password file", self.__set_mod_nss_passwordfile)
|
|
self.step("enabling mod_nss renegotiate", self.enable_mod_nss_renegotiate)
|
|
self.step("adding URL rewriting rules", self.__add_include)
|
|
self.step("configuring httpd", self.__configure_http)
|
|
self.step("setting up ssl", self.__setup_ssl)
|
|
if autoconfig:
|
|
self.step("setting up browser autoconfig", self.__setup_autoconfig)
|
|
self.step("publish CA cert", self.__publish_ca_cert)
|
|
self.step("creating a keytab for httpd", self.__create_http_keytab)
|
|
self.step("clean up any existing httpd ccache", self.remove_httpd_ccache)
|
|
self.step("configuring SELinux for httpd", self.configure_selinux_for_httpd)
|
|
self.step("restarting httpd", self.__start)
|
|
self.step("configuring httpd to start on boot", self.__enable)
|
|
|
|
self.start_creation(runtime=60)
|
|
|
|
def __start(self):
|
|
self.backup_state("running", self.is_running())
|
|
self.restart()
|
|
|
|
def __enable(self):
|
|
self.backup_state("enabled", self.is_running())
|
|
# We do not let the system start IPA components on its own,
|
|
# Instead we reply on the IPA init script to start only enabled
|
|
# components as found in our LDAP configuration tree
|
|
self.ldap_enable('HTTP', self.fqdn, self.dm_password, self.suffix)
|
|
|
|
def configure_selinux_for_httpd(self):
|
|
def get_setsebool_args(changes):
|
|
if len(changes) == 1:
|
|
# workaround https://bugzilla.redhat.com/show_bug.cgi?id=825163
|
|
updates = changes.items()[0]
|
|
else:
|
|
updates = ["%s=%s" % update for update in changes.iteritems()]
|
|
|
|
args = ["/usr/sbin/setsebool", "-P"]
|
|
args.extend(updates)
|
|
|
|
return args
|
|
|
|
selinux = False
|
|
try:
|
|
if (os.path.exists('/usr/sbin/selinuxenabled')):
|
|
ipautil.run(["/usr/sbin/selinuxenabled"])
|
|
selinux = True
|
|
except ipautil.CalledProcessError:
|
|
# selinuxenabled returns 1 if not enabled
|
|
pass
|
|
|
|
if selinux:
|
|
# Don't assume all vars are available
|
|
updated_vars = {}
|
|
failed_vars = {}
|
|
required_settings = (("httpd_can_network_connect", "on"),
|
|
("httpd_manage_ipa", "on"))
|
|
for setting, state in required_settings:
|
|
try:
|
|
(stdout, stderr, returncode) = ipautil.run(["/usr/sbin/getsebool", setting])
|
|
original_state = stdout.split()[2]
|
|
self.backup_state(setting, original_state)
|
|
|
|
if original_state != state:
|
|
updated_vars[setting] = state
|
|
except ipautil.CalledProcessError, e:
|
|
root_logger.debug("Cannot get SELinux boolean '%s': %s", setting, e)
|
|
failed_vars[setting] = state
|
|
|
|
# Allow apache to connect to the dogtag UI and the session cache
|
|
# This can still fail even if selinux is enabled. Execute these
|
|
# together so it is speedier.
|
|
if updated_vars:
|
|
args = get_setsebool_args(updated_vars)
|
|
try:
|
|
ipautil.run(args)
|
|
except ipautil.CalledProcessError:
|
|
failed_vars.update(updated_vars)
|
|
|
|
if failed_vars:
|
|
args = get_setsebool_args(failed_vars)
|
|
names = [update[0] for update in updated_vars]
|
|
message = ['WARNING: could not set the following SELinux boolean(s):']
|
|
for update in failed_vars.iteritems():
|
|
message.append(' %s -> %s' % update)
|
|
message.append('The web interface may not function correctly until the booleans')
|
|
message.append('are successfully changed with the command:')
|
|
message.append(' '.join(args))
|
|
message.append('Try updating the policycoreutils and selinux-policy packages.')
|
|
|
|
self.print_msg("\n".join(message))
|
|
|
|
def __create_http_keytab(self):
|
|
installutils.kadmin_addprinc(self.principal)
|
|
installutils.create_keytab("/etc/httpd/conf/ipa.keytab", self.principal)
|
|
self.move_service(self.principal)
|
|
self.add_cert_to_service()
|
|
|
|
pent = pwd.getpwnam("apache")
|
|
os.chown("/etc/httpd/conf/ipa.keytab", pent.pw_uid, pent.pw_gid)
|
|
|
|
def remove_httpd_ccache(self):
|
|
# Clean up existing ccache
|
|
pent = pwd.getpwnam("apache")
|
|
installutils.remove_file('/tmp/krb5cc_%d' % pent.pw_uid)
|
|
|
|
def __configure_http(self):
|
|
target_fname = '/etc/httpd/conf.d/ipa.conf'
|
|
http_txt = ipautil.template_file(ipautil.SHARE_DIR + "ipa.conf", self.sub_dict)
|
|
self.fstore.backup_file("/etc/httpd/conf.d/ipa.conf")
|
|
http_fd = open(target_fname, "w")
|
|
http_fd.write(http_txt)
|
|
http_fd.close()
|
|
os.chmod(target_fname, 0644)
|
|
|
|
target_fname = '/etc/httpd/conf.d/ipa-rewrite.conf'
|
|
http_txt = ipautil.template_file(ipautil.SHARE_DIR + "ipa-rewrite.conf", self.sub_dict)
|
|
self.fstore.backup_file("/etc/httpd/conf.d/ipa-rewrite.conf")
|
|
http_fd = open(target_fname, "w")
|
|
http_fd.write(http_txt)
|
|
http_fd.close()
|
|
os.chmod(target_fname, 0644)
|
|
|
|
def __disable_mod_ssl(self):
|
|
if os.path.exists(SSL_CONF):
|
|
self.fstore.backup_file(SSL_CONF)
|
|
os.unlink(SSL_CONF)
|
|
|
|
def __set_mod_nss_port(self):
|
|
self.fstore.backup_file(NSS_CONF)
|
|
if installutils.update_file(NSS_CONF, '8443', '443') != 0:
|
|
print "Updating port in %s failed." % NSS_CONF
|
|
|
|
def __set_mod_nss_nickname(self, nickname):
|
|
installutils.set_directive(NSS_CONF, 'NSSNickname', nickname)
|
|
|
|
def enable_mod_nss_renegotiate(self):
|
|
installutils.set_directive(NSS_CONF, 'NSSRenegotiation', 'on', False)
|
|
installutils.set_directive(NSS_CONF, 'NSSRequireSafeNegotiation', 'on', False)
|
|
|
|
def __set_mod_nss_passwordfile(self):
|
|
installutils.set_directive(NSS_CONF, 'NSSPassPhraseDialog', 'file:/etc/httpd/conf/password.conf')
|
|
|
|
def __add_include(self):
|
|
"""This should run after __set_mod_nss_port so is already backed up"""
|
|
if installutils.update_file(NSS_CONF, '</VirtualHost>', 'Include conf.d/ipa-rewrite.conf\n</VirtualHost>') != 0:
|
|
print "Adding Include conf.d/ipa-rewrite to %s failed." % NSS_CONF
|
|
|
|
def __setup_ssl(self):
|
|
fqdn = None
|
|
if not self.self_signed_ca:
|
|
fqdn = self.fqdn
|
|
|
|
ca_db = certs.CertDB(self.realm, host_name=fqdn, subject_base=self.subject_base)
|
|
|
|
db = certs.CertDB(self.realm, subject_base=self.subject_base)
|
|
if self.pkcs12_info:
|
|
db.create_from_pkcs12(self.pkcs12_info[0], self.pkcs12_info[1],
|
|
passwd=None, ca_file=self.ca_file)
|
|
server_certs = db.find_server_certs()
|
|
if len(server_certs) == 0:
|
|
raise RuntimeError("Could not find a suitable server cert in import in %s" % self.pkcs12_info[0])
|
|
|
|
db.create_password_conf()
|
|
|
|
# We only handle one server cert
|
|
nickname = server_certs[0][0]
|
|
self.dercert = db.get_cert_from_db(nickname, pem=False)
|
|
|
|
if api.env.enable_ra:
|
|
db.track_server_cert(nickname, self.principal, db.passwd_fname, 'restart_httpd')
|
|
|
|
self.__set_mod_nss_nickname(nickname)
|
|
else:
|
|
if self.self_signed_ca:
|
|
db.create_from_cacert(ca_db.cacert_fname)
|
|
|
|
db.create_password_conf()
|
|
self.dercert = db.create_server_cert(self.cert_nickname, self.fqdn,
|
|
ca_db)
|
|
db.track_server_cert(self.cert_nickname, self.principal,
|
|
db.passwd_fname, 'restart_httpd')
|
|
db.create_signing_cert("Signing-Cert", "Object Signing Cert", ca_db)
|
|
|
|
# Fix the database permissions
|
|
os.chmod(certs.NSS_DIR + "/cert8.db", 0660)
|
|
os.chmod(certs.NSS_DIR + "/key3.db", 0660)
|
|
os.chmod(certs.NSS_DIR + "/secmod.db", 0660)
|
|
os.chmod(certs.NSS_DIR + "/pwdfile.txt", 0660)
|
|
|
|
pent = pwd.getpwnam("apache")
|
|
os.chown(certs.NSS_DIR + "/cert8.db", 0, pent.pw_gid )
|
|
os.chown(certs.NSS_DIR + "/key3.db", 0, pent.pw_gid )
|
|
os.chown(certs.NSS_DIR + "/secmod.db", 0, pent.pw_gid )
|
|
os.chown(certs.NSS_DIR + "/pwdfile.txt", 0, pent.pw_gid )
|
|
|
|
# Fix SELinux permissions on the database
|
|
ipaservices.restore_context(certs.NSS_DIR + "/cert8.db")
|
|
ipaservices.restore_context(certs.NSS_DIR + "/key3.db")
|
|
|
|
# In case this got generated as part of the install, reset the
|
|
# context
|
|
if ipautil.file_exists(certs.CA_SERIALNO):
|
|
ipaservices.restore_context(certs.CA_SERIALNO)
|
|
os.chown(certs.CA_SERIALNO, 0, pent.pw_gid)
|
|
os.chmod(certs.CA_SERIALNO, 0664)
|
|
|
|
def __setup_autoconfig(self):
|
|
target_fname = '/usr/share/ipa/html/preferences.html'
|
|
ipautil.copy_template_file(
|
|
ipautil.SHARE_DIR + "preferences.html.template",
|
|
target_fname, self.sub_dict)
|
|
os.chmod(target_fname, 0644)
|
|
|
|
# The signing cert is generated in __setup_ssl
|
|
db = certs.CertDB(self.realm, subject_base=self.subject_base)
|
|
with open(db.passwd_fname) as pwdfile:
|
|
pwd = pwdfile.read()
|
|
|
|
# Setup configure.jar
|
|
tmpdir = tempfile.mkdtemp(prefix="tmp-")
|
|
target_fname = '/usr/share/ipa/html/configure.jar'
|
|
shutil.copy("/usr/share/ipa/html/preferences.html", tmpdir)
|
|
db.run_signtool(["-k", "Signing-Cert",
|
|
"-Z", target_fname,
|
|
"-e", ".html", "-p", pwd,
|
|
tmpdir])
|
|
shutil.rmtree(tmpdir)
|
|
os.chmod(target_fname, 0644)
|
|
|
|
self.setup_firefox_extension(self.realm, self.domain, force=True)
|
|
|
|
def setup_firefox_extension(self, realm, domain, force=False):
|
|
"""Set up the signed browser configuration extension
|
|
|
|
If the extension is already set up, skip the installation unless
|
|
``force`` is true.
|
|
"""
|
|
|
|
target_fname = '/usr/share/ipa/html/krb.js'
|
|
if os.path.exists(target_fname) and not force:
|
|
root_logger.info(
|
|
'%s exists, skipping install of Firefox extension',
|
|
target_fname)
|
|
return
|
|
|
|
sub_dict = dict(REALM=realm, DOMAIN=domain)
|
|
db = certs.CertDB(realm)
|
|
with open(db.passwd_fname) as pwdfile:
|
|
pwd = pwdfile.read()
|
|
|
|
ipautil.copy_template_file(ipautil.SHARE_DIR + "krb.js.template",
|
|
target_fname, sub_dict)
|
|
os.chmod(target_fname, 0644)
|
|
|
|
# Setup extension
|
|
tmpdir = tempfile.mkdtemp(prefix="tmp-")
|
|
extdir = tmpdir + "/ext"
|
|
target_fname = "/usr/share/ipa/html/kerberosauth.xpi"
|
|
shutil.copytree("/usr/share/ipa/ffextension", extdir)
|
|
if db.has_nickname('Signing-Cert'):
|
|
db.run_signtool(["-k", "Signing-Cert",
|
|
"-p", pwd,
|
|
"-X", "-Z", target_fname,
|
|
extdir])
|
|
else:
|
|
root_logger.warning('Object-signing certificate was not found. '
|
|
'Creating unsigned Firefox configuration extension.')
|
|
filenames = os.listdir(extdir)
|
|
ipautil.run(['/usr/bin/zip', '-r', target_fname] + filenames,
|
|
cwd=extdir)
|
|
shutil.rmtree(tmpdir)
|
|
os.chmod(target_fname, 0644)
|
|
|
|
def __publish_ca_cert(self):
|
|
ca_db = certs.CertDB(self.realm)
|
|
ca_db.publish_ca_cert("/usr/share/ipa/html/ca.crt")
|
|
|
|
def uninstall(self):
|
|
if self.is_configured():
|
|
self.print_msg("Unconfiguring web server")
|
|
|
|
running = self.restore_state("running")
|
|
enabled = self.restore_state("enabled")
|
|
|
|
if not running is None:
|
|
self.stop()
|
|
|
|
db = certs.CertDB(api.env.realm)
|
|
db.untrack_server_cert(self.cert_nickname)
|
|
if not enabled is None and not enabled:
|
|
self.disable()
|
|
|
|
for f in ["/etc/httpd/conf.d/ipa.conf", SSL_CONF, NSS_CONF]:
|
|
try:
|
|
self.fstore.restore_file(f)
|
|
except ValueError, error:
|
|
root_logger.debug(error)
|
|
pass
|
|
|
|
# Remove the configuration files we create
|
|
installutils.remove_file("/etc/httpd/conf.d/ipa-rewrite.conf")
|
|
installutils.remove_file("/etc/httpd/conf.d/ipa.conf")
|
|
installutils.remove_file("/etc/httpd/conf.d/ipa-pki-proxy.conf")
|
|
|
|
for var in ["httpd_can_network_connect", "httpd_manage_ipa"]:
|
|
sebool_state = self.restore_state(var)
|
|
if not sebool_state is None:
|
|
try:
|
|
ipautil.run(["/usr/sbin/setsebool", "-P", var, sebool_state])
|
|
except ipautil.CalledProcessError, e:
|
|
self.print_msg("Cannot restore SELinux boolean '%s' back to '%s': %s" \
|
|
% (var, sebool_state, e))
|
|
|
|
if not running is None and running:
|
|
self.start()
|