# vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright 2013 Red Hat, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """Main entry point into the Key distribution Server service.""" import base64 import errno import os import time from keystone.openstack.common.crypto import utils as cryptoutils from keystone.openstack.common import jsonutils from oslo.config import cfg from keystone.common import dependency from keystone.common import logging from keystone.common import manager from keystone import config from keystone import exception CONF = config.CONF kds_opts = [ cfg.StrOpt('driver', default='keystone.contrib.kds.backends.sql.KDS'), cfg.StrOpt('master_key_file', default='/etc/keystone/kds.mkey'), cfg.StrOpt('enctype', default='AES'), cfg.StrOpt('hashtype', default='SHA256'), cfg.IntOpt('ticket_lifetime', default='3600') ] CONF.register_group(cfg.OptGroup(name='kds', title='Key Distribution Server opts')) CONF.register_opts(kds_opts, group='kds') LOG = logging.getLogger(__name__) KEY_SIZE = 16 GROUP_KEY_TTL = 900 # 15 minutes @dependency.provider('kds_api') class Manager(manager.Manager): """Default pivot point for the KDS backend. See :mod:`keystone.common.manager.Manager` for more details on how this dynamically calls the backend. """ def __init__(self): self.crypto = cryptoutils.SymmetricCrypto(enctype=CONF.kds.enctype, hashtype=CONF.kds.hashtype) self.hkdf = cryptoutils.HKDF(hashtype=CONF.kds.hashtype) self.ttl = CONF.kds.ticket_lifetime super(Manager, self).__init__(CONF.kds.driver) try: with open(CONF.kds.master_key_file, 'r') as f: self.mkey = base64.b64decode(f.read()) except IOError as e: if e.errno == errno.ENOENT: flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL try: f = os.open(CONF.kds.master_key_file, flags, 0600) self.mkey = self.crypto.new_key(KEY_SIZE) os.write(f, base64.b64encode(self.mkey)) except Exception: os.remove(CONF.kds.master_key_file) finally: if f > 0: os.close(f) else: # the file could be unreadbale due to bad permissions # so just pop up whatever error comes raise if len(self.mkey) != KEY_SIZE: raise Exception('Invalid Master Key Size') def _split_key(self, key, size): sig_key = key[:size] enc_key = key[size:] return sig_key, enc_key def _get_master_keys(self, key_id): if not self.mkey: raise exception.UnexpectedError('Failed to find mkey') km = self.hkdf.expand(self.mkey, key_id, 2 * KEY_SIZE) return self._split_key(km, KEY_SIZE) def _encrypt_keyblock(self, key_id, keyblock): skey, ekey = self._get_master_keys(key_id) try: enc = self.crypto.encrypt(ekey, keyblock, b64encode=False) except Exception: raise exception.UnexpectedError('Failed to encrypt key') try: sig = self.crypto.sign(skey, enc, b64encode=False) except Exception: raise exception.UnexpectedError('Failed to sign key') return sig, enc def _decrypt_keyblock(self, key_id, keyblock): sig, enc = self._split_key(keyblock, self.crypto.hashfn.digest_size) skey, ekey = self._get_master_keys(key_id) # signature check try: sigc = self.crypto.sign(skey, enc, b64encode=False) if not sigc == sig: raise exception.UnexpectedError('Signature check failed') except Exception: raise exception.UnexpectedError('Failed to verify key') try: plain = self.crypto.decrypt(ekey, enc, b64decode=False) except Exception: raise exception.UnexpectedError('Failed to decrypt key') return plain def _gen_group_key(self, key_id): """Generates a new group key.""" exp = time.time() + GROUP_KEY_TTL keyblock = self.crypto.new_key(KEY_SIZE) sig, enc = self._encrypt_keyblock(keyblock) gen = self.driver.set_group_key(key_id, exp, sig + enc) return keyblock, gen def _get_key(self, key_id, gen=0): """Decrypts the provided encoded key and returns the clear text key. :param key_id: Key Identifier """ # Get Requestor's encypted key k = self.driver.get_shared_key(key_id) if not k: raise exception.Forbidden('Invalid Key ID') if 'key_v1' in k: if gen != 0: raise exception.Forbidden('Invalid Key Type') key = base64.b64decode(k['key_v1']) elif 'group_keys' in k: g = k['group_keys'] # find a specific generation or throw back an error if gen != 0: key = base64.b64decode(g[gen]['key_v1']) # find one not expired and with at least 10 more # minutes lifetime, otherwise build a new generation else: t = time.time() last_gen = k['generation'] if last_gen in g and g[last_gen]['expiration'] > t: key = base64.b64decode(g[last_gen]['key_v1']) else: return self._gen_group_key(key_id) else: raise exception.UnexpectedError('Unknown key format') plain = self._decrypt_keyblock(key_id, key) return plain, gen def _set_key(self, key_id, keyblock): """Encrypts the provided key and stores it. :param keyblock: The key to encrypt """ sig, enc = self._encrypt_keyblock(key_id, keyblock) self.driver.set_shared_key(key_id, sig + enc) def _common_request(self, sig, req): if 'metadata' not in req: raise exception.Forbidden('Invalid Request format') try: meta = jsonutils.loads(base64.b64decode(req['metadata'])) except Exception: raise exception.Forbidden('Invalid Request format') if 'requestor' not in meta: raise exception.Forbidden('Invalid Request format') # Requests can be made only by non-group identities try: rkey, gen = self._get_key(meta['requestor'], 0) except exception.UnexpectedError: raise exception.Unauthorized('Invalid Request') if gen != 0: raise exception.Unauthorized('Invalid Request') try: signature = self.crypto.sign(rkey, req['metadata']) except Exception: raise exception.Unauthorized('Invalid Request') if signature != sig: raise exception.Unauthorized('Invalid Request') #TODO(simo): check and store signature for replay attack detection timestamp = time.time() if meta['timestamp'] < (timestamp - self.ttl): raise exception.Unauthorized('Invalid Request (expired)') return meta, rkey, timestamp def get_ticket(self, sig, req): meta, rkey, timestamp = self._common_request(sig, req) source = meta['requestor'] target = meta['target'] tkey, gen = self._get_key(target) if not tkey: raise exception.Unauthorized('Invalid Destination') if gen != 0: target += ':' + str(gen) # use new_key to get a random salt rndkey = self.hkdf.extract(rkey, self.crypto.new_key(KEY_SIZE)) info = '%s,%s,%s' % (source, target, str(timestamp)) sek = self.hkdf.expand(rndkey, info, KEY_SIZE * 2) skey, ekey = self._split_key(sek, KEY_SIZE) keydata = {'key': base64.b64encode(rndkey), 'timestamp': timestamp, 'ttl': self.ttl} esek = self.crypto.encrypt(tkey, jsonutils.dumps(keydata)) ticket = jsonutils.dumps({'skey': base64.b64encode(skey), 'ekey': base64.b64encode(ekey), 'esek': esek}) rep = dict() metadata = jsonutils.dumps({'source': source, 'destination': target, 'expiration': (timestamp + self.ttl)}) rep['metadata'] = base64.b64encode(metadata) rep['ticket'] = self.crypto.encrypt(rkey, ticket) payload = rep['metadata'] + rep['ticket'] rep['signature'] = self.crypto.sign(rkey, payload) return {'reply': rep} def get_group_key(self, sig, req): meta, rkey, timestamp = self._common_request(sig, req) source = meta['requestor'] target = meta['target'] group = source.split('.')[0] if ':' not in target: raise exception.Unauthorized('Invalid Target') grp, generation = target.split(':', 1) if group != grp: raise exception.Unauthorized('Invalid Target') tkey, gen = self._get_key(group, generation) if not tkey: raise exception.Unauthorized('Invalid Target') rep = dict() metadata = jsonutils.dumps({'source': source, 'destination': target, 'expiration': (timestamp + self.ttl)}) rep['metadata'] = base64.b64encode(metadata) rep['group_key'] = self.crypto.encrypt(rkey, tkey) payload = rep['metadata'] + rep['group_key'] rep['signature'] = self.crypto.sign(rkey, payload) return {'reply': rep} def set_key(self, name, req): self._set_key(name, base64.b64decode(req['key'])) def create_group(self, name): self.driver.set_group_key(name) def delete_key(self, name): if '.' not in name: raise exception.Unauthorized('Invalid Request') self.driver.del_key(name) def delete_group(self, name): if '.' in name: raise exception.Unauthorized('Invalid Request') self.driver.del_key(name) class Driver(object): """Interface description for a KDS driver.""" def set_shared_key(self, kds_id, key): """Set key related to kds_id.""" raise exception.NotImplemented() def set_group_key(self, kds_id, expiration=None, key=None): """Set or Create group key object.""" raise exception.NotImplemented() def del_group_key(self, kds_id): """Delete group key object.""" raise exception.NotImplemented() def get_shared_key(self, kds_id): """Get key related to kds_id. :returns: key :raises: keystone.exception.ServiceNotFound """ raise exception.NotImplemented()