advanced-encoder-and-decoder 1.0.0__tar.gz

advanced_encoder_and_decoder-1.0.0/LICENSE.txt

@@ -0,0 +1,8 @@
+MIT License
+Copyright 2026 Andrew Abdelmalek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

advanced_encoder_and_decoder-1.0.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: advanced_encoder_and_decoder
+Version: 1.0.0
+Summary: A small, easy to use module that helps you store data easily.
+Author-email: Andrew Abdelmalek <aa2@olprahraneast.catholic.edu.au>
+License-Expression: MIT
+Project-URL: Homepage, https://simple-storage-module.netlify.app
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+# advanced_encoder_and_decoder
+
+A complex encryption/decryption module
+
+## Install
+```bash
+pip install advanced_encoder_and_decoder

advanced_encoder_and_decoder-1.0.0/README.md

@@ -0,0 +1,7 @@
+# advanced_encoder_and_decoder
+
+A complex encryption/decryption module
+
+## Install
+```bash
+pip install advanced_encoder_and_decoder

advanced_encoder_and_decoder-1.0.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "advanced_encoder_and_decoder"
+version = "1.0.0"
+authors = [
+  { name="Andrew Abdelmalek", email="aa2@olprahraneast.catholic.edu.au" },
+]
+description = "A small, easy to use module that helps you store data easily."
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICENSE.txt"]
+
+[project.urls]
+Homepage = "https://simple-storage-module.netlify.app"
+

advanced_encoder_and_decoder-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

advanced_encoder_and_decoder-1.0.0/src/__init__.py

@@ -0,0 +1,3 @@
+from .simple_storage import (password_gen, encrypt, decrypt)
+
+__all__ = ["password_gen", "encrypt", "decrypt"]

advanced_encoder_and_decoder-1.0.0/src/advanced_encoder_and_decoder.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: advanced_encoder_and_decoder
+Version: 1.0.0
+Summary: A small, easy to use module that helps you store data easily.
+Author-email: Andrew Abdelmalek <aa2@olprahraneast.catholic.edu.au>
+License-Expression: MIT
+Project-URL: Homepage, https://simple-storage-module.netlify.app
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+# advanced_encoder_and_decoder
+
+A complex encryption/decryption module
+
+## Install
+```bash
+pip install advanced_encoder_and_decoder

advanced_encoder_and_decoder-1.0.0/src/advanced_encoder_and_decoder.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/__init__.py
+src/advanced_encoder_and_decoder.py
+src/advanced_encoder_and_decoder.egg-info/PKG-INFO
+src/advanced_encoder_and_decoder.egg-info/SOURCES.txt
+src/advanced_encoder_and_decoder.egg-info/dependency_links.txt
+src/advanced_encoder_and_decoder.egg-info/top_level.txt

advanced_encoder_and_decoder-1.0.0/src/advanced_encoder_and_decoder.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

advanced_encoder_and_decoder-1.0.0/src/advanced_encoder_and_decoder.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+advanced_encoder_and_decoder

advanced_encoder_and_decoder-1.0.0/src/advanced_encoder_and_decoder.py

@@ -0,0 +1,130 @@
+import base64
+import os
+import zlib
+import random
+import string
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives import hashes
+from cryptography.fernet import Fernet
+from cryptography.hazmat.backends import default_backend
+
+# ===================== CONFIG =====================
+ITERATIONS = 200_000
+CUSTOM_PASSES = 3
+CHUNK_SIZE = 5000 
+
+# ===================== PASSWORD GENERATOR =====================
+def generate_password(length: int = 24) -> str:
+    """Generates a high-entropy secure password."""
+    chars = string.ascii_letters + string.digits + string.punctuation
+    return ''.join(random.SystemRandom().choice(chars) for _ in range(length))
+
+# ===================== CORE CRYPTO FUNCTIONS =====================
+def _derive_key(password: str, salt: bytes) -> bytes:
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=salt,
+        iterations=ITERATIONS,
+        backend=default_backend()
+    )
+    return base64.urlsafe_b64encode(kdf.derive(password.encode()))
+
+def _aes_encrypt(data: bytes, password: str) -> bytes:
+    salt = os.urandom(16)
+    key = _derive_key(password, salt)
+    return salt + Fernet(key).encrypt(data)
+
+def _aes_decrypt(data: bytes, password: str) -> bytes:
+    salt, encrypted = data[:16], data[16:]
+    key = _derive_key(password, salt)
+    return Fernet(key).decrypt(encrypted)
+
+def _custom_encode(data: bytes, password: str, r: int) -> bytes:
+    shift = (sum(password.encode()) + r) % 256
+    return bytes((b + shift) % 256 for b in data)
+
+def _custom_decode(data: bytes, password: str, r: int) -> bytes:
+    shift = (sum(password.encode()) + r) % 256
+    return bytes((b - shift) % 256 for b in data)
+
+def _rotate_bits(data: bytes, password: str, rev=False) -> bytes:
+    r = len(password) % 8
+    if r == 0: return data
+    out = bytearray()
+    for b in data:
+        out.append(((b >> r | b << (8 - r)) if rev else (b << r | b >> (8 - r))) & 0xFF)
+    return bytes(out)
+
+def _substitution_table(password: str) -> bytes:
+    seed = sum(password.encode())
+    table = list(range(256))
+    for i in range(256):
+        j = (i + seed) % 256
+        table[i], table[j] = table[j], table[i]
+    return bytes(table)
+
+def _substitute(data: bytes, table: bytes, rev=False) -> bytes:
+    if not rev: return bytes(table[b] for b in data)
+    inv = bytearray(256)
+    for i, v in enumerate(table): inv[v] = i
+    return bytes(inv[b] for b in data)
+
+# ===================== MAIN WRAPPERS =====================
+def _encrypt_text(raw_text: str, password: str) -> str:
+    chunks = [raw_text[i:i+CHUNK_SIZE] for i in range(0, len(raw_text), CHUNK_SIZE)]
+    encrypted_chunks = []
+    table = _substitution_table(password)
+    
+    for chunk in chunks:
+        data = chunk.encode()
+        for i in range(CUSTOM_PASSES): 
+            data = _custom_encode(data, password, i)
+        data = _rotate_bits(data, password)
+        data = zlib.compress(data)
+        data = _aes_encrypt(data, password)
+        data = _substitute(data, table)
+        encrypted_chunks.append(base64.b64encode(data).decode())
+    
+    return "\n".join(encrypted_chunks)
+
+def _decrypt_text(encrypted_text: str, password: str) -> str:
+    chunks = encrypted_text.strip().split("\n")
+    decrypted_chunks = []
+    table = _substitution_table(password)
+    
+    for chunk in chunks:
+        data = base64.b64decode(chunk)
+        data = _substitute(data, table, True)
+        data = _aes_decrypt(data, password)
+        data = zlib.decompress(data)
+        data = _rotate_bits(data, password, True)
+        for i in reversed(range(CUSTOM_PASSES)): 
+            data = _custom_decode(data, password, i)
+        decrypted_chunks.append(data.decode())
+    
+    return "".join(decrypted_chunks)
+
+# ===================== EXPORTED FUNCTIONS =====================
+
+def password_gen() -> str:
+    """Returns a safe random password."""
+    return generate_password()
+
+def encrypt(raw_text: str, password: str) -> str:
+    """
+    Encrypts text using AES-256 and custom bit rotation.
+    :param raw_text: The string message to be encrypted.
+    :param password: The secret key for encryption.
+    :return: A base64 encoded string of encrypted chunks.
+    """
+    return _encrypt_text(raw_text, password)
+
+def decrypt(encrypted_text: str, password: str) -> str:
+    """
+    Decrypts text using AES-256 and custom bit rotation.
+    :param encrypted_text: The string message to be decrypted.
+    :param password: The secret key used during encryption.
+    :return: A plain decoded string.
+    """
+    return _decrypt_text(encrypted_text, password)