Smart Passwords Library (smartpasslib) v2.0.0

Author: smartlegionlab

README.md

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "smartpasslib"
-version = "1.2.1"
+version = "2.0.0"
 description = "Cross-platform library for generating smart passwords."
 authors = [
-    {name = "A.A Suvorov", email = "smartlegiondev@gmail.com"}
+    {name = "Alexander Suvorov", email = "smartlegiondev@gmail.com"}
 ]
 license = "BSD-3-Clause"
 readme = "README.md"

data/images/cov.png

@@ -11,7 +11,7 @@
 from smartpasslib.managers.smart_password_manager import SmartPasswordManager
 from smartpasslib.masters.smart_password_master import SmartPasswordMaster
 from smartpasslib.smart_passwords.smart_password import SmartPassword
-__version__ = '1.2.1'
+__version__ = '2.0.0'
 __author__ = 'A.A. Suvorov'
 __all__ = [
     "SmartPasswordMaster",

data/requirements/develop_requirements.txt

@@ -3,19 +3,21 @@
 
 
 class SmartPasswordFactory:
-    """Factory class for creating SmartPassword instances."""
+    """
+    Factory class for creating SmartPassword objects.
+    """
 
     @classmethod
-    def create_smart_password(cls, login: str, key: str, length: int) -> SmartPassword:
+    def create_smart_password(cls, public_key: str, description: str, length: int = 12) -> SmartPassword:
         """
         Create a new SmartPassword instance.
 
         Args:
-            login (str): User login.
-            key (str): Generation key.
-            length (int): Password length.
+            public_key: Public key for verifying secret phrase knowledge
+            description: Service/account description
+            length: Password length (default: 12)
 
         Returns:
-            SmartPassword: New SmartPassword instance.
+            SmartPassword: Configured smart password object
         """
-        return SmartPassword(login=login, key=key, length=length)
+        return SmartPassword(public_key=public_key, description=description, length=length)

pyproject.toml

@@ -4,22 +4,24 @@
 
 
 class BasePasswordGenerator:
-    """Basic password generator with letters, digits, and symbols."""
+    """
+    Generator for basic random passwords.
+    """
 
     letters = string.ascii_letters
     digits = string.digits
     symbols = '!@#$%&^_'
 
     @classmethod
-    def generate(cls, length: int = 10) -> str:
+    def generate(cls, length: int = 12) -> str:
         """
-        Generates a password of the specified length.
+        Generate a random password of specified length.
 
         Args:
-            length (int): Password length (default: 10).
+            length: Length of password to generate (default: 12)
 
         Returns:
-            str: Generated password.
+            str: Randomly generated password
         """
         symbols_string = cls.letters + cls.digits + cls.symbols
         return ''.join((random.choice(symbols_string) for _ in range(length)))

smartpasslib/__init__.py

@@ -4,11 +4,26 @@
 
 
 class CodeGenerator:
+    """
+    Generator for secure codes with guaranteed character sets.
+    """
+
     special_chars = "!@#$%^&*"
 
     @classmethod
     def generate(cls, length: int = 6) -> str:
+        """
+        Generate a secure code with at least one character from each required set.
+
+        Args:
+            length: Code length, minimum 4 characters
+
+        Returns:
+            str: Generated code
 
+        Raises:
+            ValueError: If length is less than 4
+        """
         if length < 4:
             raise ValueError("The code length must be at least 4 characters..")
 

smartpasslib/factories/smart_password_factory.py

@@ -3,18 +3,20 @@
 
 
 class HashGenerator:
-    """SHA3-512 hash generator."""
+    """
+    Generator for cryptographic hash values.
+    """
 
     @classmethod
     def generate(cls, text: str) -> str:
         """
-        Generates a SHA3-512 hash for the given text.
+        Generate SHA3-512 hash for the given text.
 
         Args:
-            text (str): Input string to hash.
+            text: Input text to hash
 
         Returns:
-            str: Hexadecimal representation of the hash.
+            str: Hexadecimal SHA3-512 hash
         """
         text = str(text)
         sha = hashlib.sha3_512(text.encode('utf-8'))

smartpasslib/generators/base.py

@@ -3,82 +3,71 @@
 
 
 class SmartKeyGenerator:
-    """Key generator based on iterative hashing."""
+    """
+    Generator for cryptographic keys from secret phrases.
+    """
 
     @classmethod
-    def _create_key(cls, login: str = '', secret: str = '', public_step: int = 15) -> str:
+    def _create_key(cls, secret, steps: int = 30) -> str:
         """
-        Internal method for key generation.
-
-        Args:
-            login (str): User login.
-            secret (str): Secret string.
-            public_step (int): Number of hashing iterations.
-
-        Returns:
-            str: Generated key.
+        Internal method to create a key through iterative hashing.
         """
-        login_hash = cls.get_hash(text=login)
-        secret_hash = cls.get_hash(text=secret)
-        all_hash = cls.get_hash(text=login_hash + secret_hash)
-        for _ in range(public_step):
-            temp_hash = cls.get_hash(all_hash)
-            all_hash = cls.get_hash(all_hash + temp_hash + secret_hash)
+        all_hash = cls.get_hash(secret)
+        for i in range(steps):
+            temp_string = f"{all_hash}:{secret}:{i}"
+            all_hash = cls.get_hash(temp_string)
         return cls.get_hash(all_hash)
 
     @classmethod
-    def generate_public_key(cls, login: str = '', secret: str = '') -> str:
+    def generate_public_key(cls, secret) -> str:
         """
-        Generates a public key.
+        Generate a public verification key from secret phrase.
 
         Args:
-            login (str): User login.
-            secret (str): Secret string.
+            secret: Secret phrase
 
         Returns:
-            str: Public key.
+            str: Public key for verification
         """
-        return cls._create_key(login, secret, 60)
+        return cls._create_key(secret=secret, steps=60)
 
     @classmethod
-    def generate_private_key(cls, login: str = '', secret: str = '') -> str:
+    def generate_private_key(cls, secret) -> str:
         """
-        Generates a private key.
+        Generate a private key from secret phrase.
 
         Args:
-            login (str): User login.
-            secret (str): Secret string.
+            secret: Secret phrase
 
         Returns:
-            str: Private key.
+            str: Private key
         """
-        return cls._create_key(login, secret, 30)
+        return cls._create_key(secret=secret, steps=30)
 
     @classmethod
-    def check_key(cls, login: str = '', secret: str = '', key: str = '') -> bool:
+    def check_key(cls, secret: str, key: str) -> bool:
         """
-        Verifies if a key matches the given login and secret.
+        Verify if a key matches the secret phrase.
 
         Args:
-            login (str): User login.
-            secret (str): Secret string.
-            key (str): Key to verify.
+            secret: Secret phrase to check
+            key: Key to verify
 
         Returns:
-            bool: True if the key is valid, False otherwise.
+            bool: True if key was generated from this secret
         """
-        return cls.generate_public_key(login=login, secret=secret) == key
+        return cls.generate_public_key(secret=secret) == key
 
     @classmethod
     def get_hash(cls, text: str = '') -> str:
         """
-        Generates a hash for the given text.
+        Generate SHA3-512 hash of text.
 
         Args:
-            text (str): Input string.
+            text: Input text
 
         Returns:
-            str: Hash of the input string.
+            str: Hexadecimal hash
         """
         text = str(text)
         return HashGenerator.generate(str(text.encode('utf-8')))