aswi2021jmsd-gitlab/src/services/key_service.py @ 932420d8

from injector import inject

from src.dao.private_key_repository import PrivateKeyRepository
from src.model.private_key import PrivateKey
from src.services.cryptography import CryptographyService
from src.utils.logger import Logger


class KeyService:

    @inject
    def __init__(self, cryptography_service: CryptographyService, private_key_repository: PrivateKeyRepository):
        self.cryptography_service = cryptography_service
        self.private_key_repository = private_key_repository

    def create_new_key(self, passphrase="") -> PrivateKey:
        """
        Creates a new private key using the given passphrase.
        :param passphrase: Passphrase to be used when encrypting the PK
        :return: An instance of the <PrivateKey> class representing the generated PK
        """

        Logger.debug("Function launched.")

        # generate a new private key
        private_key_pem = self.cryptography_service.create_private_key(passphrase)

        # store the private key
        private_key = self.wrap_and_store_key(passphrase, private_key_pem)

        return private_key

    def wrap_and_store_key(self, passphrase, private_key_pem):
        """
        Stores a previously unknown PK PEM/passphrase tuple in a PK repository while wrapping the tuple in a PrivateKey
        wrapper.
        :param passphrase: PK passphrase
        :param private_key_pem: PK PEM
        :return: a new PrivateKey wrapper
        """
        Logger.debug("Function launched.")

        # store generated PK and the passphrase in a wrapper
        private_key = PrivateKey(-1, private_key_pem, passphrase)
        # store the wrapper in the PK repository
        private_key_id = self.private_key_repository.create(private_key)
        # assign the generated ID to the wrapper
        private_key.private_key_id = private_key_id
        return private_key

    def wrap_custom_key(self, key_pem, passphrase):
        """
        Checks whether a supplied PEM/passphrase tuple is already known and tries to fetch it from a PK repository,
        if not, stores it in a PK repository. Returns a wrapped PEM/passphrase tuple in a PrivateKey instance together
        with its associated ID.
        :param key_pem: target PEM
        :param passphrase: corresponding passphrase
        :return: PrivateKey instance
        """
        Logger.debug("Function launched.")

        # check if the supplied key is already known
        private_key = self.private_key_repository.find_pk(key_pem)

        # if not
        if private_key is None:
            # store as new
            private_key = self.wrap_and_store_key(passphrase, key_pem)

        return private_key

    def get_key(self, unique_id):
        """
        Tries to fetch a PK using the given ID.
        :param unique_id: ID of the PK to be found
        :return:An instance of the required PK or `None`
        """

        Logger.debug("Function launched.")

        return self.private_key_repository.read(unique_id)

    def get_keys(self, unique_ids=None):
        """
        Tries to fetch all PKs in the repository. Exact PKs to be fetched can be specified using the `unique_ids`
        parameter. If `unique_ids` parameter is not passed then all PKs in the repository are returned.
        :param unique_ids: An array containing IDs of PKs to be fetched from the repository.
        :return: A list of instances of the PrivateKey class representing the PKs found
        """

        Logger.debug("Function launched.")

        if unique_ids is None:
            return self.private_key_repository.read_all()
        else:
            # TODO this is very inefficient
            return [self.private_key_repository.read(identifier) for identifier in unique_ids]

    def delete_key(self, unique_id):
        """
        Deletes a private key

        :param unique_id: ID of specific certificate to be deleted
        :return: `True` when the deletion was successful. `False` in other case
        """

        Logger.debug("Function launched.")

        return self.private_key_repository.delete(unique_id)

    def get_public_key(self, private_key: PrivateKey):
        """
        Extracts a public key from the given private key
        :param private_key: private key from which a public key should be extracted
        :return: a string containing the extracted public key in PEM format
        """

        Logger.debug("Function launched.")

        return self.cryptography_service.extract_public_key_from_private_key(private_key.private_key,
                                                                             private_key.password)

    def verify_key(self, key, passphrase):
        """
        Verifies whether the provided key is encrypted by the provided passphrase. If passphrase is none, verifies
        that the provided key is unencrypted.
        Simply calls the namesake CryptographyService method.
        :param key: target key
        :param passphrase: target passphrase or None
        :return: True if the condition is fulfilled, else False
        """
        return self.cryptography_service.verify_key(key, passphrase)