aswi2021jmsd-gitlab4/src/services/key_service.py @ 7313994f

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


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
        """
        # generate a new private key
        private_key_pem = self.cryptography_service.create_private_key(passphrase)

        # 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 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`
        """
        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
        """
        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
        """
        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
        """
        return self.cryptography_service.extract_public_key_from_private_key(private_key.private_key,
                                                                             private_key.password)