passphera-core 0.8.2__tar.gz → 0.9.0__tar.gz

{passphera-core-0.8.2 → passphera-core-0.9.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: passphera-core
-Version: 0.8.2
+Version: 0.9.0
 Summary: The core system of passphera project
 Home-page: https://github.com/passphera/core
 Author: Fathi Abdelmalek
 Author-email: abdelmalek.fathi.2001@gmail.com
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python

{passphera-core-0.8.2 → passphera-core-0.9.0}/passphera_core/__init__.py

@@ -1,2 +1,2 @@
-from passphera_core.generator import PasswordGenerator
+from passphera_core.entities.generator import Generator
 from passphera_core.exceptions import InvalidAlgorithmException

passphera-core-0.9.0/passphera_core/entities.py

@@ -0,0 +1,125 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from uuid import UUID, uuid4
+
+from cryptography.fernet import Fernet
+
+from cipherspy.cipher import *
+from cipherspy.cipher.base_cipher import BaseCipherAlgorithm
+from cipherspy.utilities import generate_salt, derive_key
+
+from passphera_core import exceptions
+
+
+@dataclass
+class Password:
+    id: UUID = field(default_factory=uuid4)
+    user_id: UUID = field(default_factory=uuid4)
+    created_at: datetime = field(default=datetime.now(timezone.utc))
+    updated_at: datetime = field(default=datetime.now(timezone.utc))
+    context: str = field(default_factory=str)
+    text: str = field(default_factory=str)
+    password: str = field(default_factory=str)
+    salt: bytes = field(default_factory=bytes)
+
+    def encrypt(self) -> None:
+        self.salt = generate_salt()
+        key = derive_key(self.password, self.salt)
+        self.password = Fernet(key).encrypt(self.password.encode()).decode()
+
+    def decrypt(self) -> str:
+        key = derive_key(self.password, self.salt)
+        return Fernet(key).decrypt(self.password.encode()).decode()
+
+
+@dataclass
+class GeneratorConfig:
+    id: UUID = field(default_factory=uuid4)
+    generator_id: UUID = field(default_factory=uuid4)
+    shift: int = field(default=3)
+    multiplier: int = field(default=3)
+    key: str = field(default="hill")
+    algorithm: str = field(default="hill")
+    prefix: str = field(default="secret")
+    postfix: str = field(default="secret")
+    characters_replacements: dict[str, str] = field(default_factory=dict[str, str])
+    _cipher_registry: dict[str, BaseCipherAlgorithm] = field(default_factory=lambda: {
+        'caesar': CaesarCipherAlgorithm,
+        'affine': AffineCipherAlgorithm,
+        'playfair': PlayfairCipherAlgorithm,
+        'hill': HillCipherAlgorithm,
+    }, init=False)
+
+    def get_algorithm(self) -> BaseCipherAlgorithm:
+        """
+        Get the primary algorithm used to cipher the password
+        :return: BaseCipherAlgorithm: The primary algorithm used for the cipher
+        """
+        if self.algorithm.lower() not in self._cipher_registry:
+            raise exceptions.InvalidAlgorithmException(self.algorithm)
+        return self._cipher_registry[self.algorithm.lower()]
+
+    def replace_character(self, char: str, replacement: str) -> None:
+        """
+        Replace a character with another character or set of characters
+        Eg: pg.replace_character('a', '@1')
+        :param char: The character to be replaced
+        :param replacement: The (character|set of characters) to replace the first one
+        :return:
+        """
+        self.characters_replacements[char[0]] = replacement
+
+    def reset_character(self, char: str) -> None:
+        """
+        Reset a character to its original value (remove its replacement from characters_replacements)
+        :param char: The character to be reset to its original value
+        :return:
+        """
+        self.characters_replacements.pop(char, None)
+
+
+@dataclass
+class Generator:
+    id: UUID = field(default_factory=uuid4)
+    user_id: UUID = field(default_factory=uuid4)
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+    config: GeneratorConfig = field(default_factory=GeneratorConfig)
+
+    def apply_replacements(self, password: str) -> str:
+        """
+        Replace character from the ciphered password with character replacements from the generator configurations
+        :return: str: The new ciphered password after character replacements
+        """
+        translation_table = str.maketrans(self.config.characters_replacements)
+        return password.translate(translation_table)
+
+    def generate_password(self, text: str) -> str:
+        """
+        Generate a strong password string using the raw password (add another layer of encryption to it)
+        :return: str: The generated ciphered password
+        """
+        affine = AffineCipherAlgorithm(self.config.shift, self.config.multiplier)
+        intermediate = affine.encrypt(f"{self.config.prefix}{text}{self.config.postfix}")
+        main_algorithm = self.config.get_algorithm()
+        password = main_algorithm.encrypt(intermediate)
+        password = self.apply_replacements(password)
+        return ''.join(c.upper() if c in text else c for c in password)
+
+
+@dataclass
+class User:
+    id: UUID = field(default_factory=uuid4)
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+    username: str = field(default_factory=str)
+    email: str = field(default_factory=str)
+    password: str = field(default_factory=str)
+    generator: UUID = field(default_factory=UUID)
+    passwords: list[UUID] = field(default_factory=list[UUID])
+
+    def add_password(self, password_id: UUID) -> None:
+        self.passwords.append(password_id)
+
+    def delete_password(self, password_id: UUID) -> None:
+        self.passwords.remove(password_id)

passphera-core-0.9.0/passphera_core/exceptions.py

@@ -0,0 +1,49 @@
+from typing import Union, Literal
+
+from passphera_core.entities import Password, Generator, User
+
+
+class InvalidAlgorithmException(Exception):
+    def __init__(self, algorithm: str) -> None:
+        self.algorithm = algorithm
+        super().__init__(f"Invalid algorithm: '{algorithm}'")
+
+
+class EntityNotFoundException(Exception):
+    def __init__(self, entity: Union[Password, Generator, User]) -> None:
+        self.entity = entity
+        entity_type = entity.__class__.__name__
+        super().__init__(f"{entity_type} not found")
+
+
+class DuplicateEntityException(Exception):
+    def __init__(
+            self,
+            entity: Union[Password, User],
+            duplicate_field: Literal['context', 'email', 'username'] = None
+    ) -> None:
+        self.entity = entity
+        self.duplicate_field = duplicate_field
+        message = self._build_message(entity, duplicate_field)
+        super().__init__(message)
+
+    def _build_message(self, entity: Union[Password, User], duplicate_field: str | None) -> str:
+        if isinstance(entity, Password):
+            return self._build_password_message(entity)
+        elif isinstance(entity, User):
+            return self._build_user_message(entity, duplicate_field)
+        return "Duplicate entity detected"
+
+    @staticmethod
+    def _build_password_message(password: Password) -> str:
+        if hasattr(password, 'context') and password.context:
+            return f"Password for context '{password.context}' already exists"
+        return "Duplicate password detected"
+
+    @staticmethod
+    def _build_user_message(user: User, duplicate_field: str) -> str:
+        if duplicate_field == 'email':
+            return f"User with email '{user.email}' already exists"
+        elif duplicate_field == 'username':
+            return f"User with username '{user.username}' already exists"
+        return "Duplicate user detected"

passphera-core-0.9.0/passphera_core/interfaces.py

@@ -0,0 +1,92 @@
+from abc import ABC, abstractmethod
+from uuid import UUID
+
+from passphera_core.entities import Password, Generator, GeneratorConfig, User
+
+
+class PasswordRepository(ABC):
+    @abstractmethod
+    def save(self, password: Password) -> None:
+        pass
+
+    @abstractmethod
+    def update(self, password: Password) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, password_id: UUID) -> None:
+        pass
+
+    @abstractmethod
+    def find_by_id(self, password_id: UUID) -> Password:
+        pass
+
+
+class GeneratorRepository(ABC):
+    @abstractmethod
+    def save(self, generator: Generator) -> None:
+        pass
+
+    @abstractmethod
+    def update(self, generator: Generator) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, generator_id: UUID) -> None:
+        pass
+
+    @abstractmethod
+    def find_by_id(self, generator_id: UUID) -> Generator:
+        pass
+
+    @abstractmethod
+    def find_by_user_id(self, user_id: UUID) -> Generator:
+        pass
+
+
+class GeneratorConfigRepository(ABC):
+    @abstractmethod
+    def save(self, generator_config: GeneratorConfig) -> None:
+        pass
+
+    @abstractmethod
+    def update(self, generator_config: GeneratorConfig) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, generator_config_id: UUID) -> None:
+        pass
+
+    @abstractmethod
+    def find_by_id(self, generator_config_id: UUID) -> GeneratorConfig:
+        pass
+
+    @abstractmethod
+    def find_by_generator_id(self, generator_id: UUID) -> GeneratorConfig:
+        pass
+
+
+class UserRepository(ABC):
+    @abstractmethod
+    def save(self, user: User) -> None:
+        pass
+
+    @abstractmethod
+    def update(self, user: User) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, user_id: UUID) -> None:
+        pass
+
+    @abstractmethod
+    def find_by_id(self, user_id: UUID) -> User:
+        pass
+
+    @abstractmethod
+    def find_by_username(self, username: str) -> User:
+        pass
+
+    @abstractmethod
+    def find_by_email(self, email: str) -> User:
+        pass

{passphera-core-0.8.2 → passphera-core-0.9.0}/passphera_core.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: passphera-core
-Version: 0.8.2
+Version: 0.9.0
 Summary: The core system of passphera project
 Home-page: https://github.com/passphera/core
 Author: Fathi Abdelmalek
 Author-email: abdelmalek.fathi.2001@gmail.com
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python

{passphera-core-0.8.2 → passphera-core-0.9.0}/passphera_core.egg-info/SOURCES.txt

@@ -1,8 +1,9 @@
 README.md
 setup.py
 passphera_core/__init__.py
+passphera_core/entities.py
 passphera_core/exceptions.py
-passphera_core/generator.py
+passphera_core/interfaces.py
 passphera_core.egg-info/PKG-INFO
 passphera_core.egg-info/SOURCES.txt
 passphera_core.egg-info/dependency_links.txt

{passphera-core-0.8.2 → passphera-core-0.9.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name='passphera-core',
-    version='0.8.2',
+    version='0.9.0',
     author='Fathi Abdelmalek',
     author_email='abdelmalek.fathi.2001@gmail.com',
     url='https://github.com/passphera/core',
@@ -16,7 +16,7 @@ setup(
     python_requires='>=3',
     install_requires=['cipherspy'],
     classifiers=[
-        "Development Status :: 2 - Pre-Alpha",
+        "Development Status :: 3 - Alpha",
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
         "Programming Language :: Python",

passphera-core-0.8.2/passphera_core/exceptions.py

@@ -1,3 +0,0 @@
-class InvalidAlgorithmException(Exception):
-    def __init__(self, algorithm: str) -> None:
-        super().__init__(f"Invalid algorithm name [{algorithm}]")

passphera-core-0.8.2/passphera_core/generator.py

@@ -1,228 +0,0 @@
-from cipherspy.cipher import *
-
-from .exceptions import InvalidAlgorithmException
-
-
-class PasswordGenerator:
-    """
-    A strong password generator use multiple cipher algorithms to cipher a given plain text
-    """
-    def __init__(
-            self,
-            shift: int = 3,
-            multiplier: int = 3,
-            key: str = "hill",
-            algorithm: str = 'hill',
-            prefix: str = 'secret',
-            postfix: str = 'secret',
-            characters_replacements: dict = None,
-    ):
-        """
-        :param shift: number of characters to shift each character (default 3)
-        :param multiplier: number of characters to shift each character (default 3)
-        :param key: cipher key string (default "secret")
-        :param algorithm: main cipher algorithm name (default 'playfair')
-        :param characters_replacements: replace characters with the given values (default {})
-        :param text: plain text to be ciphered
-        """
-        if characters_replacements is None:
-            characters_replacements = {}
-        self._shift: int = shift
-        self._multiplier: int = multiplier
-        self._key: str = key
-        self._algorithm_name: str = algorithm.lower()
-        self._algorithm = self._set_algorithm()
-        self._prefix: str = prefix
-        self._postfix: str = postfix
-        self._characters_replacements: dict = characters_replacements
-
-    @property
-    def shift(self) -> int:
-        """
-        Returns the shift value for the cipher algorithm
-        Eg: ```shift = pg.shift```
-        :return: int: The shift value for the cipher algorithm
-        """
-        return self._shift
-
-    @shift.setter
-    def shift(self, shift: int) -> None:
-        """
-        Sets the shift value for the cipher algorithm
-        Eg: ```pg.shift = 3```
-        :param shift: The shift value for the cipher algorithm
-        :return:
-        """
-        self._shift = shift
-
-    @property
-    def multiplier(self) -> int:
-        """
-        Returns the multiplier value for the cipher algorithm
-        Eg: ```multiplier = pg.multiplier```
-        :return: int: The multiplier value for the cipher algorithm
-        """
-        return self._multiplier
-
-    @multiplier.setter
-    def multiplier(self, multiplier: int) -> None:
-        """
-        Sets the multiplier value for the cipher algorithm
-        Eg: ```pg.multiplier = 3```
-        :param multiplier: The multiplier value for the cipher algorithm
-        :return:
-        """
-        self._multiplier = multiplier
-
-    @property
-    def key(self) -> str:
-        """
-        Returns the key string for the cipher algorithm
-        Eg: ```key = pg.key```
-        :return: str: The key string for the cipher algorithm
-        """
-        return self._key
-
-    @key.setter
-    def key(self, key: str) -> None:
-        """
-        Sets the key string for the cipher algorithm
-        Eg: ```pg.key = 'secret key'```
-        :param key: The key string for the cipher algorithm
-        :return:
-        """
-        self._key = key
-
-    @property
-    def prefix(self) -> str:
-        """
-        Returns the prefix string for the cipher algorithm
-        Eg: ```prefix = pg.prefix```
-        :return: str: The prefix string for the cipher algorithm
-        """
-        return self._prefix
-
-    @prefix.setter
-    def prefix(self, prefix: str):
-        """
-        Sets the prefix string for the cipher algorithm
-        Eg: ```pg.prefix = 'something'```
-        :param prefix: The string for the cipher algorithm
-        :return:
-        """
-        self._prefix = prefix
-
-    @property
-    def postfix(self) -> str:
-        """
-        Returns the postfix string for the cipher algorithm
-        Eg: ```postfix = pg.postfix```
-        :return: str: The postfix string for the cipher algorithm
-        """
-        return self._postfix
-
-    @postfix.setter
-    def postfix(self, postfix: str):
-        """
-        Sets the postfix string for the cipher algorithm
-        Eg: ```pg.postfix = 'something'```
-        :param postfix: The string for the cipher algorithm
-        :return:
-        """
-        self._postfix = postfix
-
-    @property
-    def algorithm(self) -> str:
-        """
-        Returns the main cipher algorithm name
-        Eg: ```algorithm = pg.algorithm```
-        :return: str: The main cipher algorithm name
-        """
-        return self._algorithm_name
-
-    @algorithm.setter
-    def algorithm(self, algorithm: str) -> None:
-        """
-        Sets the main cipher algorithm
-        Eg: ```pg.algorithm = 'playfair'```
-        :param algorithm: The name of the main cipher algorithm
-        :return:
-        """
-        self._algorithm_name = algorithm.lower()
-        self._algorithm = self._set_algorithm()
-
-    @property
-    def characters_replacements(self) -> dict:
-        """
-        Returns the dictionary of the characters replacements
-        Eg: ```print(pg.characters_replacements)  # {'a': '@1', 'b': '#2'}```
-        :return: dict: The dictionary of the characters replacements
-        """
-        return self._characters_replacements
-
-    def _set_algorithm(self):
-        """
-        Return new instance of the used algorithm to the given one by it's name
-        :return: new algorithm class
-        """
-        match self._algorithm_name:
-            case 'caesar':
-                return CaesarCipher(self._shift)
-            case 'affine':
-                return AffineCipher(self._shift, self._multiplier)
-            case 'playfair':
-                return PlayfairCipher(self._key)
-            case 'hill':
-                return HillCipher(self._key)
-            case _:
-                raise InvalidAlgorithmException(self._algorithm_name)
-
-    def _update_algorithm_properties(self) -> None:
-        """
-        Update the main cipher algorithm
-        """
-        self._algorithm = self._set_algorithm()
-
-    def replace_character(self, char: str, replacement: str) -> None:
-        """
-        Replace a character with another character or set of characters
-        Eg: pg.replace_character('a', '@1')
-        :param char: The character to be replaced
-        :param replacement: The (character|set of characters) to replace the first one
-        :return:
-        """
-        self._characters_replacements[char[0]] = replacement
-
-    def reset_character(self, char: str) -> None:
-        """
-        Reset a character to it's original value (remove it's replacement from characters_replacements)
-        :param char: The character to be reset to its original value
-        :return:
-        """
-        if char in self._characters_replacements:
-            del self._characters_replacements[char]
-
-    def generate_raw_password(self, text: str) -> str:
-        """
-        Generate a raw password string using the given parameters
-        :return: str: The generated raw password
-        """
-        self._update_algorithm_properties()
-        return self._algorithm.encrypt(f"{self._prefix}{text}{self._postfix}")
-
-    def generate_password(self, text: str) -> str:
-        """
-        Generate a strong password string using the raw password (add another layer of encryption to it)
-        :return: str: The generated strong password
-        """
-        old_algorithm = self._algorithm_name
-        self._algorithm_name = 'affine'
-        password = self.generate_raw_password(text)
-        self._algorithm_name = old_algorithm
-        password = self.generate_raw_password(password)
-        for char, replacement in self._characters_replacements.items():
-            password = password.replace(char, replacement)
-        for char in password:
-            if char in text:
-                password = password.replace(char, char.upper())
-        return password