fast-cryptography 0.1.0__py3-none-any.whl

fast_cryptography/__init__.py

@@ -0,0 +1,81 @@
+from .algorithms.asymmetric.rsa import gen_keys_pem as rsa_gen_keys_pem, encrypt as rsa_encrypt, decrypt as rsa_decrypt
+from .algorithms.asymmetric.ecc import gen_keys_pem as ecc_gen_keys_pem, sign as ecc_sign, verify as ecc_verify
+from .algorithms.asymmetric.ed25519 import gen_keys_pem as ed25519_gen_keys_pem, sign as ed25519_sign, verify as ed25519_verify
+
+from .algorithms.symmetric.fernet import generate_key as fernet_generate_key, encrypt as fernet_encrypt, decrypt as fernet_decrypt
+from .algorithms.symmetric.aes import generate_key as aes_generate_key, encrypt as aes_encrypt, decrypt as aes_decrypt
+from .algorithms.symmetric.chacha20 import generate_key as chacha20_generate_key, encrypt as chacha20_encrypt, decrypt as chacha20_decrypt
+
+
+
+from .algorithms.encoding.base64 import encode as base64_encode, decode as base64_decode, is_valid as is_valid_base64, url_encode as base64_url_encode, url_decode as base64_url_decode
+from .algorithms.encoding.base58 import encode as base58_encode, decode as base58_decode, is_valid as is_valid_base58
+from .algorithms.encoding.base16 import encode as base16_encode, decode as base16_decode, is_valid as is_valid_base16
+from .algorithms.encoding.base32 import encode as base32_encode, decode as base32_decode, is_valid as is_valid_base32
+from .algorithms.encoding.base85 import encode as base85_encode, decode as base85_decode, is_valid as is_valid_base85
+from .algorithms.encoding.baseA85 import encode as baseA85_encode, decode as baseA85_decode, is_valid as is_valid_baseA85
+from .algorithms.encoding.base45 import encode as base45_encode, decode as base45_decode, is_valid as is_valid_base45
+from .algorithms.scripts.password import auth, verify
+from .algorithms.scripts.what_encoding import what_encoding
+
+from algorithms.hashes.md4 import hash_md4
+from algorithms.hashes.md5 import hash_md5
+from algorithms.hashes.ripemd160 import hash_ripemd160
+from algorithms.hashes.sha1 import hash_sha1
+from algorithms.hashes.sha224 import hash_sha224
+from algorithms.hashes.sha256 import hash_sha256
+from algorithms.hashes.sha384 import hash_sha384
+from algorithms.hashes.sha512 import hash_sha512
+from algorithms.hashes.sha3_224 import hash_sha3_224
+from algorithms.hashes.sha3_256 import hash_sha3_256
+from algorithms.hashes.sha3_384 import hash_sha3_384
+from algorithms.hashes.sha3_512 import hash_sha3_512
+from algorithms.hashes.blake2b import hash_blake2b
+from algorithms.hashes.blake2s import hash_blake2s
+
+from .algorithms.cryptorandom.byte import bytes_token, bytes_urandom, bytes_uuid, bytes_random
+from .algorithms.cryptorandom.hex_bytes import hex_token, hex_token_bytes, encode_hex, decode_hex, hex2text, text2hex, is_valid_hex
+from algorithms.cryptorandom.choice import crypto_choice, random_choice, random_choices, scientific_choice
+from algorithms.cryptorandom.randint import crypto_randbelow, crypto_randint, random_randint
+from algorithms.cryptorandom.salt import salt_gen, salt_gen_hex
+from algorithms.cryptorandom.nonce import nonce_gen, nonce_gen_hex
+from algorithms.cryptorandom.iv import iv_gen, iv_gen_hex
+
+__all__ = [
+    # Asymmetric
+    'rsa_gen_keys_pem', 'rsa_encrypt', 'rsa_decrypt',
+    'ecc_gen_keys_pem', 'ecc_sign', 'ecc_verify',
+    'ed25519_gen_keys_pem', 'ed25519_sign', 'ed25519_verify',
+    
+    # Symmetric
+    'fernet_generate_key', 'fernet_encrypt', 'fernet_decrypt',
+    'aes_generate_key', 'aes_encrypt', 'aes_decrypt',
+    'chacha20_generate_key', 'chacha20_encrypt', 'chacha20_decrypt',
+    
+    # Encodings
+    'base64_encode', 'base64_decode', 'is_valid_base64', 'base64_url_encode', 'base64_url_decode',
+    'base58_encode', 'base58_decode', 'is_valid_base58',
+    'base16_encode', 'base16_decode', 'is_valid_base16',
+    'base32_encode', 'base32_decode', 'is_valid_base32',
+    'base85_encode', 'base85_decode', 'is_valid_base85',
+    'baseA85_encode', 'baseA85_decode', 'is_valid_baseA85',
+    
+    # Password
+    'auth', 'verify',
+    
+    # Hashes
+    'hash_md4', 'hash_md5', 'hash_ripemd160',
+    'hash_sha1', 'hash_sha224', 'hash_sha256', 'hash_sha384', 'hash_sha512',
+    'hash_sha3_224', 'hash_sha3_256', 'hash_sha3_384', 'hash_sha3_512',
+    'hash_blake2b', 'hash_blake2s',
+    
+    # Cryptorandom
+    'bytes_token', 'bytes_urandom', 'bytes_uuid', 'bytes_random',
+    'hex_token', 'hex_token_bytes', 'encode_hex', 'decode_hex',
+    'hex2text', 'text2hex', 'is_valid_hex',
+    'crypto_choice', 'random_choice', 'random_choices', 'scientific_choice',
+    'crypto_randbelow', 'crypto_randint', 'random_randint',
+    'salt_gen', 'salt_gen_hex',
+    'nonce_gen', 'nonce_gen_hex',
+    'iv_gen', 'iv_gen_hex'
+]

fast_cryptography/algorithms/__init__.py

@@ -0,0 +1 @@
+from . import asymmetric, symmetric, cryptorandom, scripts, encoding, hashes

fast_cryptography/algorithms/asymmetric/__init__.py

@@ -0,0 +1,19 @@
+from .rsa import gen_keys_pem as rsa_gen_keys_pem
+from .rsa import encrypt as rsa_encrypt
+from .rsa import decrypt as rsa_decrypt
+from .ecc import gen_keys_pem as ecc_gen_keys_pem
+from .ecc import sign as ecc_sign
+from .ecc import verify as ecc_verify
+from .ed25519 import gen_keys_pem as ed25519_gen_keys_pem
+from .ed25519 import sign as ed25519_sign
+from .ed25519 import verify as ed25519_verify
+
+from .rsa import gen_keys_pem as rsa_gen_keys_pem, encrypt as rsa_encrypt, decrypt as rsa_decrypt
+from .ecc import gen_keys_pem as ecc_gen_keys_pem, sign as ecc_sign, verify as ecc_verify
+from .ed25519 import gen_keys_pem as ed25519_gen_keys_pem, sign as ed25519_sign, verify as ed25519_verify
+
+__all__ = [
+    'rsa_gen_keys_pem', 'rsa_encrypt', 'rsa_decrypt',
+    'ecc_gen_keys_pem', 'ecc_sign', 'ecc_verify',
+    'ed25519_gen_keys_pem', 'ed25519_sign', 'ed25519_verify'
+]

fast_cryptography/algorithms/asymmetric/ecc.py

@@ -0,0 +1,55 @@
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives import serialization, hashes
+import base64
+
+
+def gen_keys_pem() -> dict:
+    """Generates an ECC key pair (secp256k1) in PEM format"""
+    private_key = ec.generate_private_key(ec.SECP256K1())
+    public_key = private_key.public_key()
+
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption()
+    ).decode('utf-8')
+
+    public_pem = public_key.public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo
+    ).decode('utf-8')
+
+    return {
+        'private': private_pem,
+        'public': public_pem
+    }
+
+
+def sign(message: str, private_key_pem: str) -> str:
+    """Signs a message using ECC private key"""
+    private_key = serialization.load_pem_private_key(
+        private_key_pem.encode(),
+        password=None
+    )
+    
+    signature = private_key.sign(
+        message.encode(),
+        ec.ECDSA(hashes.SHA256())
+    )
+    return base64.b64encode(signature).decode('utf-8')
+
+
+def verify(message: str, signature_b64: str, public_key_pem: str) -> bool:
+    """Verifies an ECC signature using public key"""
+    public_key = serialization.load_pem_public_key(public_key_pem.encode())
+    signature = base64.b64decode(signature_b64)
+    
+    try:
+        public_key.verify(
+            signature,
+            message.encode('utf-8'),
+            ec.ECDSA(hashes.SHA256())
+        )
+        return True
+    except:
+        return False

fast_cryptography/algorithms/asymmetric/ed25519.py

@@ -0,0 +1,58 @@
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives import serialization
+import base64
+
+
+def gen_keys_pem() -> dict:
+    """Generates an Ed25519 key pair in PEM format"""
+    private_key = ed25519.Ed25519PrivateKey()
+    public_key = private_key.public_key()
+
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption()
+    ).decode('utf-8')
+
+    public_pem = public_key.public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo
+    ).decode('utf-8')
+
+    return {
+        'private':private_pem,
+        'public':public_pem
+    }
+
+
+
+
+def sign(message: str, private_key_pem: str) -> str:
+    """Signs a message using Ed25519 private key"""
+    private_key = serialization.load_pem_private_key(
+        private_key_pem.encode(),
+        password=None
+    )
+
+    signature = private_key.sign(
+        message.encode('utf-8')
+    )
+    return base64.b64encode(signature).decode('utf-8')
+
+def verify(message: str, signature_b64: str, public_key_pem: str) -> bool:
+    """Verifies an Ed25519 signature using public key"""
+    public_key = serialization.load_pem_public_key(public_key_pem)
+    signature = base64.b64decode(signature_b64)
+
+    try:
+        public_key.verify(
+            signature,
+            message.encode('utf-8')
+        )
+
+        return True
+    
+    except:
+        return False
+    
+    

fast_cryptography/algorithms/asymmetric/rsa.py

@@ -0,0 +1,59 @@
+from cryptography.hazmat.primitives.asymmetric import rsa, padding
+from cryptography.hazmat.primitives import serialization, hashes
+import base64
+
+def gen_keys_pem(key_size=2048) -> dict:
+    """Generates an RSA key pair in PEM format"""
+    private_key = rsa.generate_private_key(
+        public_exponent=65537,
+        key_size=key_size
+    )
+    public_key = private_key.public_key()
+
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption()
+    ).decode('utf-8')
+
+    public_pem = public_key.public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo
+    ).decode('utf-8')
+
+    return {
+        'private': private_pem,
+        'public': public_pem
+    }
+
+def encrypt(message: str, public_pem: str) -> str:
+    """Encrypts a message using an RSA public key"""
+    public_key = serialization.load_pem_public_key(public_pem.encode())
+
+    encrypted = public_key.encrypt(
+        message.encode(),
+        padding.OAEP(
+            mgf=padding.MGF1(algorithm=hashes.SHA256()),
+            algorithm=hashes.SHA256(),
+            label=None
+        )
+    )
+    return base64.b64encode(encrypted).decode()
+
+def decrypt(encrypted_b64: str, private_key_pem: str) -> str:
+    """Decrypts a message using an RSA private key"""
+    private_key = serialization.load_pem_private_key(
+        private_key_pem.encode(),
+        password=None
+    )
+    
+    encrypted = base64.b64decode(encrypted_b64)
+    decrypted = private_key.decrypt(
+        encrypted,
+        padding.OAEP(
+            mgf=padding.MGF1(algorithm=hashes.SHA256()),
+            algorithm=hashes.SHA256(),
+            label=None
+        )
+    )
+    return decrypted.decode()

fast_cryptography/algorithms/cryptorandom/__init__.py

@@ -0,0 +1,17 @@
+from .byte import bytes_token, bytes_urandom, bytes_uuid, bytes_random
+from .hex_bytes import hex_token, hex_token_bytes, encode_hex, decode_hex, hex2text, text2hex, is_valid_hex
+from .salt import salt_gen, salt_gen_hex
+from .nonce import nonce_gen, nonce_gen_hex
+from .iv import iv_gen, iv_gen_hex
+from .choice import crypto_choice, random_choice, random_choices, scientific_choice
+from .randint import crypto_randbelow, crypto_randint, random_randint
+
+__all__ = [
+    'bytes_token', 'bytes_urandom', 'bytes_uuid', 'bytes_random',
+    'hex_token', 'hex_token_bytes', 'encode_hex', 'decode_hex', 'hex2text', 'text2hex', 'is_valid_hex',
+    'salt_gen', 'salt_gen_hex',
+    'nonce_gen', 'nonce_gen_hex',
+    'iv_gen', 'iv_gen_hex',
+    'crypto_choice', 'random_choice', 'random_choices', 'scientific_choice',
+    'crypto_randbelow', 'crypto_randint', 'random_randint'
+]

fast_cryptography/algorithms/cryptorandom/byte.py

@@ -0,0 +1,20 @@
+import secrets
+import os
+import random
+import uuid
+
+def bytes_token(byte: int) -> bytes:
+    """Generate bytes using secrets (safe)"""
+    return secrets.token_bytes(byte)
+
+def bytes_urandom(byte: int) -> bytes:
+    """Generate bytes using os.urandom (safe)"""
+    return os.urandom(byte)
+
+def bytes_uuid() -> bytes:
+    """Generate 16 bytes using uuid (medium security)"""
+    return uuid.uuid4().bytes
+
+def bytes_random(byte: int) -> bytes:
+    """Generate bytes using random (NOT SAFE for crypto!)"""
+    return random.randbytes(byte)

fast_cryptography/algorithms/cryptorandom/choice.py

@@ -0,0 +1,21 @@
+import secrets
+import random
+import numpy as np
+
+def crypto_choice(choicen) -> str:
+    """Cryptographically secure random choice"""
+    return secrets.choice(choicen)
+
+def random_choice(choicen) -> str:
+    """Not secure random choice"""
+    return random.choice(choicen)
+
+def random_choices(choicen) -> str:
+    """Not secure random choices"""
+    return random.choices(choicen)
+
+def scientific_choice(choicen) -> str:
+    """Scientific random choice"""
+    return np.random.choice(choicen)
+
+

fast_cryptography/algorithms/cryptorandom/hex_bytes.py

@@ -0,0 +1,34 @@
+import secrets
+import binascii
+
+def hex_token(byte: int) -> str:
+    """Generate hex string using secrets (safe)"""
+    return secrets.token_hex(byte)
+
+def hex_token_bytes(byte: int) -> str:
+    """Generate hex string via bytes using secrets (safe)"""
+    return secrets.token_bytes(byte).hex()
+
+def encode_hex(data: bytes) -> str:
+    """Encode bytes to hex string"""
+    return binascii.hexlify(data).decode('utf-8')
+
+def decode_hex(hex_str: str) -> bytes:  
+    """Decode hex string to bytes"""
+    return binascii.unhexlify(hex_str)
+
+def hex2text(hex_str: str) -> str:
+    """Convert hex string to text (UTF-8)"""
+    return decode_hex(hex_str).decode('utf-8', errors='replace')
+
+def text2hex(text: str) -> str:
+    """Convert text to hex string"""
+    return encode_hex(text.encode('utf-8'))
+
+def is_valid_hex(hex_str: str) -> bool:
+    """Check if string is valid hex"""
+    try:
+        bytes.fromhex(hex_str)
+        return True
+    except (binascii.Error, ValueError):
+        return False

fast_cryptography/algorithms/cryptorandom/iv.py

@@ -0,0 +1,12 @@
+import secrets
+
+def iv_gen(byte: 16) -> bytes:
+    """Generator iv using module secrets
+    Bytes 16"""
+    return secrets.token_bytes(byte)
+
+def iv_gen_hex() -> str:
+    """Generator iv bytes to hex using module secrets
+    Bytes 16"""
+    return iv_gen().hex()
+

fast_cryptography/algorithms/cryptorandom/nonce.py

@@ -0,0 +1,9 @@
+import secrets
+
+def nonce_gen(byte: int = 16) -> bytes:
+    """Generate nonce bytes (12-16 bytes recommended)"""
+    return secrets.token_bytes(byte)
+
+def nonce_gen_hex(byte: int = 16) -> str:
+    """Generate nonce as hex string"""
+    return secrets.token_hex(byte)

fast_cryptography/algorithms/cryptorandom/randint.py

@@ -0,0 +1,19 @@
+import random
+import secrets
+
+def crypto_randbelow(number: int) -> int:
+    """Return random integer in range (0, n)"""
+    return secrets.randbelow(number)
+
+def crypto_randint(a: int, b: int) -> int:
+    """Return random integer in range [a, b] inclusive"""
+    return secrets.randbelow(b - a + 1) + a
+
+def random_randint(a: int, b: int) -> int:
+    """Return random integer in range (0 , n)
+    It's not safe"""
+    return random.randint(a, b)
+    
+
+
+

fast_cryptography/algorithms/cryptorandom/salt.py

@@ -0,0 +1,11 @@
+import secrets
+
+def salt_gen(byte: int) -> bytes:
+    """Generator salt using module secrets
+    Bytes 16-64"""
+    return secrets.token_bytes(byte)
+
+def salt_gen_hex() -> str:
+    """Generator salt bytes to hex using module secrets
+    Bytes 16-64"""
+    return salt_gen().hex()

fast_cryptography/algorithms/encoding/__init__.py

@@ -0,0 +1,17 @@
+from .base64 import encode as base64_encode, decode as base64_decode, url_encode as base64_url_encode, url_decode as base64_url_decode, is_valid as is_valid_base64
+from .base58 import encode as base58_encode, decode as base58_decode, is_valid as is_valid_base58
+from .base32 import encode as base32_encode, decode as base32_decode, is_valid as is_valid_base32
+from .base16 import encode as base16_encode, decode as base16_decode, is_valid as is_valid_base16
+from .base85 import encode as base85_encode, decode as base85_decode, is_valid as is_valid_base85
+from .baseA85 import encode as baseA85_encode, decode as baseA85_decode, is_valid as is_valid_baseA85
+from .base45 import encode as base45_encode, decode as base45_decode, is_valid as is_valid_base45
+
+__all__ = [
+    'base64_encode', 'base64_decode', 'base64_url_encode', 'base64_url_decode', 'is_valid_base64',
+    'base58_encode', 'base58_decode', 'is_valid_base58',
+    'base32_encode', 'base32_decode', 'is_valid_base32',
+    'base16_encode', 'base16_decode', 'is_valid_base16',
+    'base85_encode', 'base85_decode', 'is_valid_base85',
+    'baseA85_encode', 'baseA85_decode', 'is_valid_baseA85',
+    'base45_encode', 'base45_decode', 'is_valid_base45'
+]

fast_cryptography/algorithms/encoding/base16.py

@@ -0,0 +1,17 @@
+import base64 as b64
+
+def encode(data: bytes) -> str:
+    """Encode using module base64 for base16"""
+    b64.b16encode(data).decode()
+
+def decode(data: str) -> bytes:
+    """Decode using module base54 for base16"""
+    b64.b16decode(data)
+
+def is_valid(data: str) -> bool:
+    """Check if string is base64 for base16"""
+    try:
+        bytes.fromhex(data)
+        return True
+    except:
+        return False 

fast_cryptography/algorithms/encoding/base32.py

@@ -0,0 +1,17 @@
+import base64 as b64
+
+def encode(data: bytes) -> str:
+    """Encode using module base64 for base32"""
+    return b64.b32encode(data).decode()
+
+def decode(data: str) -> bytes:
+    """Decode using module base64 for base32"""
+    return b64.b32decode(data)
+
+def is_valid(data: str) -> bool:
+    """Check if string is base64 fror base32"""
+    try:
+        bytes.fromhex(data)
+        return True
+    except:
+        return False

fast_cryptography/algorithms/encoding/base45.py

@@ -0,0 +1,20 @@
+import base45
+
+
+def encode(data: bytes) -> str:
+    """Encode bytes to Base45 string"""
+    return base45.b45encode(data).decode()
+
+
+def decode(s: str) -> bytes:
+    """Decode Base45 string to bytes"""
+    return base45.b45decode(s)
+
+
+def is_valid(s: str) -> bool:
+    """Check if string is valid Base45"""
+    try:
+        bytes.fromhex(s)
+        return True
+    except Exception:
+        return False

fast_cryptography/algorithms/encoding/base58.py

@@ -0,0 +1,17 @@
+import base58 as b58
+
+def encode(data: bytes) -> str:
+    """Encode using module base58"""
+    return b58.b58encode(data).decode()
+
+def decode(data: str) -> bytes:
+    """Decode using module base58"""
+    return b58.b58decode(data)
+
+def is_valid(data: str) -> bool:
+    """Check if string is base58"""
+    try:
+        bytes.fromhex(data)
+        return True
+    except:
+        return False    

fast_cryptography/algorithms/encoding/base64.py

@@ -0,0 +1,26 @@
+import base64 as b64
+
+def encode(data: bytes) -> str:
+    """Encode using module base64"""
+    return b64.b64encode(data).decode()
+
+def decode(data: str) -> bytes:
+    """Decode using module base64"""
+    return b64.b64decode(data)
+
+def url_encode(data: bytes) -> str:
+    """Encode url using module base64"""
+    return b64.urlsafe_b64encode(data).decode()
+
+def url_decode(data: str) -> bytes:
+    """Decode url using module base64"""
+    return b64.urlsafe_b64decode(data)
+
+def is_valid(data: str) -> bool:
+    """Check if string is base64"""
+    try:
+        bytes.fromhex(data)
+        return True
+    except:
+        return False
+    

fast_cryptography/algorithms/encoding/base85.py

@@ -0,0 +1,17 @@
+import base64 as b64
+
+def encode(data: bytes) -> str:
+    """Encode using module base64 for base85"""
+    return b64.b85encode(data).decode()
+
+def decode(data: str) -> bytes:
+    """Decode using module base64 for base85"""
+    return b64.b85decode(data)
+
+def is_valid(data: str) -> bool:
+    """Check if string is base64 for base85"""
+    try:
+        bytes.fromhex(data)
+        return True
+    except:
+        return False

fast_cryptography/algorithms/encoding/baseA85.py

@@ -0,0 +1,17 @@
+import base64 as b64
+
+def encode(data: bytes) -> str:
+    """Encode using module base64 for baseA85"""
+    return b64.a85encode(data).decode()
+
+def decode(data: str) -> bytes:
+    """Decode using module base64 from baseA85"""
+    return b64.a85decode(data)
+
+def is_valid(data: str) -> bool:
+    """Check if string is base64 for baseA85"""
+    try:
+        bytes.fromhex(data)
+        return True
+    except:
+        return False   

fast_cryptography/algorithms/hashes/__init__.py

@@ -0,0 +1,21 @@
+from .sha256 import hash_sha256
+from .sha512 import hash_sha512
+from .sha384 import hash_sha384
+from .sha224 import hash_sha224
+from .sha1 import hash_sha1
+from .sha3_256 import hash_sha3_256
+from .sha3_512 import hash_sha3_512
+from .sha3_384 import hash_sha3_384
+from .sha3_224 import hash_sha3_224
+from .blake2b import hash_blake2b
+from .blake2s import hash_blake2s
+from .md5 import hash_md5
+from .md4 import hash_md4
+from .ripemd160 import hash_ripemd160
+
+__all__ = [
+    'hash_sha256', 'hash_sha512', 'hash_sha384', 'hash_sha224', 'hash_sha1',
+    'hash_sha3_256', 'hash_sha3_512', 'hash_sha3_384', 'hash_sha3_224',
+    'hash_blake2b', 'hash_blake2s',
+    'hash_md5', 'hash_md4', 'hash_ripemd160'
+]

fast_cryptography/algorithms/hashes/blake2b.py

@@ -0,0 +1,8 @@
+import secrets
+import hashlib
+
+def hash_blake2b(message: str, byte: int) -> str:
+    """Blake2b Hash Function"""
+    salt = secrets.token_bytes(byte)
+    return hashlib.blake2b(message + salt.encode()).hexdigest()
+    

fast_cryptography/algorithms/hashes/blake2s.py

@@ -0,0 +1,9 @@
+import secrets
+import hashlib
+
+def hash_blake2s(message: str, byte: int) -> str:
+    """Blake2s Hash Function"""
+    salt = secrets.token_bytes(byte)
+    return hashlib.blake2s(message + salt.encode()).hexdigest()
+
+    

fast_cryptography/algorithms/hashes/md4.py

@@ -0,0 +1,10 @@
+from Crypto.Hash import MD4
+import secrets
+
+def hash_md4(message: str, byte: int) -> str:
+    """MD4 Hash Function"""
+    salt = secrets.token_bytes(byte)
+    hash_obj = MD4.new()
+    hash_obj.update(salt + message.encode())
+    hash_result = hash_obj.hexdigest()
+    return hash_result

fast_cryptography/algorithms/hashes/md5.py

@@ -0,0 +1,8 @@
+import hashlib
+import secrets
+
+def hash_md5(message: str, byte: int) -> str:
+    """MD5 Hash Function"""
+    salt = secrets.token_bytes(byte)
+    return hashlib.md5(message + salt.encode()).hexdigest()
+