substitutionciphers 1.0.0__py3-none-any.whl

substitutionciphers/__init__.py

@@ -0,0 +1,3 @@
+from .griffinere import Griffinere
+
+__all__ = ['Griffinere']

substitutionciphers/griffinere.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import base64
+import math
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+
+@dataclass(slots=True)
+class Griffinere:
+    key: str
+    alphabet: str | None = None
+
+    _alphabet: List[str] = field(init=False, repr=False)
+    _alphabet_length: int = field(init=False, repr=False)
+    _alphabet_position_map: Dict[str, int] = field(init=False, repr=False)
+    _key_chars: List[str] = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        default_alphabet = (
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            "abcdefghijklmnopqrstuvwxyz"
+            "0123456789"
+        )
+        alphabet_str = self.alphabet or default_alphabet
+        self._alphabet = self._validate_alphabet(alphabet_str, self.key)
+        self._alphabet_length = len(self._alphabet)
+        self._alphabet_position_map = {ch: idx for idx, ch in enumerate(self._alphabet)}
+        self._key_chars = list(self.key)
+
+    def encrypt_string(self, plain_text: str, minimum_response_length: int | None = None) -> str:
+        if not plain_text or plain_text.isspace():
+            return ""
+        if minimum_response_length is None:
+            return self._encrypt_segments(plain_text)
+        if minimum_response_length < 1:
+            raise ValueError("minimum_response_length must be greater than zero")
+        need_to_add = minimum_response_length - len(plain_text)
+        if need_to_add <= 0:
+            return self._encrypt_segments(plain_text)
+        pull_from_front = math.ceil(need_to_add / 1.25)
+        pull_from_back = need_to_add - pull_from_front
+        contiguous = plain_text.replace(" ", "") or plain_text
+        string_to_front = self._cycle_take(contiguous, pull_from_front, True)
+        string_to_back = self._cycle_take(contiguous, pull_from_back, False)
+        fragments_front = f"{self._encrypt_segments(string_to_front[::-1])}." if string_to_front else ""
+        fragments_back = f".{self._encrypt_segments(string_to_back)}" if string_to_back else ""
+        core = self._encrypt_segments(plain_text)
+        return f"{fragments_front}{core}{fragments_back}"
+
+    def decrypt_string(self, cipher_text: str) -> str:
+        if not cipher_text or cipher_text.isspace():
+            return ""
+        if "." in cipher_text:
+            parts = cipher_text.split(".")
+            if len(parts) > 2:
+                cipher_text = parts[1]
+        return self._decrypt_segments(cipher_text)
+
+    @staticmethod
+    def _validate_alphabet(alphabet: str, key: str) -> List[str]:
+        if "." in alphabet:
+            raise ValueError("Alphabet must not contain '.'")
+        unique: List[str] = []
+        seen = set()
+        for ch in alphabet:
+            if ch in seen:
+                raise ValueError(f"Duplicate character '{ch}' in provided alphabet.")
+            seen.add(ch)
+            unique.append(ch)
+        for ch in key:
+            if ch not in seen:
+                raise ValueError(f"Alphabet does not contain the character '{ch}' supplied in the key.")
+        return unique
+
+    @staticmethod
+    def _cycle_take(source: str, count: int, front: bool) -> str:
+        if count <= 0 or not source:
+            return ""
+        result: List[str] = []
+        length = len(source)
+        idx = 0
+        while len(result) < count:
+            result.append(source[idx % length] if front else source[-1 - (idx % length)])
+            idx += 1
+        return "".join(result)
+
+    def _encrypt_segments(self, text: str) -> str:
+        return " ".join(self._encrypt_word(word) if word else "" for word in text.split(" "))
+
+    def _decrypt_segments(self, text: str) -> str:
+        return " ".join(self._decrypt_word(word) if word else "" for word in text.split(" "))
+
+    def _encrypt_word(self, word: str) -> str:
+        segment_chars = self._to_base64_char_list(word)
+        key_chars = self._get_key(segment_chars)
+        encrypted = [self._shift_positive(kc, sc) for kc, sc in zip(key_chars, segment_chars)]
+        return "".join(encrypted)
+
+    def _decrypt_word(self, word: str) -> str:
+        segment_chars = list(word)
+        key_chars = self._get_key(segment_chars)
+        decrypted = [self._shift_negative(kc, sc) for kc, sc in zip(key_chars, segment_chars)]
+        return self._from_base64_char_list(decrypted)
+
+    def _shift_positive(self, key_char: str, text_char: str) -> str:
+        key_pos = self._alphabet_position_map.get(key_char)
+        text_pos = self._alphabet_position_map.get(text_char)
+        if key_pos is None or text_pos is None:
+            return text_char
+        return self._alphabet[(key_pos + text_pos) % self._alphabet_length]
+
+    def _shift_negative(self, key_char: str, text_char: str) -> str:
+        key_pos = self._alphabet_position_map.get(key_char)
+        text_pos = self._alphabet_position_map.get(text_char)
+        if key_pos is None or text_pos is None:
+            return text_char
+        return self._alphabet[(text_pos - key_pos + self._alphabet_length) % self._alphabet_length]
+
+    def _get_key(self, segment: List[str]) -> List[str]:
+        if not segment:
+            return []
+        key = list(self._key_chars)
+        while len(key) < len(segment):
+            key.extend(self._key_chars)
+        return key[: len(segment)]
+
+    @staticmethod
+    def _to_base64_char_list(text: str) -> List[str]:
+        if text is None:
+            raise ValueError("text cannot be None")
+        if text == "":
+            return []
+        encoded = base64.b64encode(text.encode()).decode().rstrip("=")
+        return list(encoded)
+
+    @staticmethod
+    def _from_base64_char_list(chars: List[str]) -> str:
+        if not chars:
+            return ""
+        encoded = "".join(chars)
+        padding_needed = (-len(encoded)) % 4
+        encoded += "=" * padding_needed
+        decoded_bytes = base64.b64decode(encoded)
+        return decoded_bytes.decode()

substitutionciphers-1.0.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: substitutionciphers
+Version: 1.0.0
+Summary: The Griffinere cipher is a custom encryption algorithm in C# designed for reversible, base64-normalized encryption using a repeating key. Inspired by the Vigenère cipher, it adds configurable alphabet support, input validation, and padding-based encryption length enforcement.
+Project-URL: Homepage, https://github.com/RileyG00/Ciphers
+Project-URL: Source, https://github.com/RileyG00/Ciphers/tree/add-python
+Author-email: Riley Griffin <riley.griffin00@outlook.com>
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Griffinere Cipher 🔐 — Python Edition
+
+The **Griffinere** cipher is a reversible, Base‑64‑normalised encryption algorithm implemented in pure **Python**.
+Inspired by the classic Vigenère cipher, it adds:
+
+* **Configurable alphabets** (use any character set you like)
+* **Input validation** for safer usage
+* **Padding‑based length enforcement** so encrypted strings meet a minimum length
+
+---
+
+## 📦 Installation
+
+```bash
+pip install substitutionciphers
+```
+
+In your code:
+
+```python
+from griffinere import Griffinere
+```
+
+---
+
+## ✨ Features
+
+* 🔐 Encrypts & decrypts alphanumeric or **custom‑alphabet** strings
+* 🧩 Define your **own alphabet** (emoji? Cyrillic? go ahead!)
+* 📏 Optional **minimum‑length** padding for fixed‑width ciphertext
+* ✅ Strong validation of both alphabet and key integrity
+* 🧪 Unit‑tested with **pytest**
+
+---
+
+## 🧰 Usage
+
+### 1 Create a cipher
+
+#### 1.1 Default alphabet
+
+```python
+key = "YourSecureKey"
+cipher = Griffinere(key)
+```
+
+The built‑in alphabet is:
+
+```
+A‑Z  a‑z  0‑9
+```
+
+#### 1.2 Custom alphabet
+
+```python
+custom_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ12345"
+key = "YOURKEY"
+cipher = Griffinere(key, custom_alphabet)
+```
+
+##### Alphabet rules
+
+1. **Must not contain `.`** (dot)
+2. **All characters must be unique**
+3. **Every character in the key must appear in the alphabet**
+
+---
+
+### 2 Encrypt & decrypt
+
+#### 2.1 Encrypt a string
+
+```python
+plain_text = "Hello World 123"
+encrypted = cipher.encrypt_string(plain_text)
+# e.g. 'LUKsbK8 OK9ybKJ FC3z'
+```
+
+#### 2.2 Encrypt with a minimum length
+
+```python
+encrypted = cipher.encrypt_string(plain_text, minimum_response_length=24)
+# e.g. 'cm9JbAxsIJg.LUKsbK8 OK9ybKJ FC3z.Fw'
+```
+
+#### 3.1 Decrypt
+
+```python
+decrypted = cipher.decrypt_string(encrypted)
+assert decrypted == plain_text
+```
+
+---
+
+## ⚠️ Exceptions & validation
+
+| Condition                                       | Exception    |
+| ----------------------------------------------- | ------------ |
+| Alphabet contains `.`                           | `ValueError` |
+| Duplicate characters in alphabet                | `ValueError` |
+| Key contains characters not present in alphabet | `ValueError` |
+| `minimum_response_length` < 1                   | `ValueError` |
+
+---
+
+## 📄 License
+
+MIT License © 2025 Riley Griffin

substitutionciphers-1.0.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+substitutionciphers/__init__.py,sha256=btBU77-Vz-YOHIhV7nmCucMJpddkt69IgDI6vpecvRE,62
+substitutionciphers/griffinere.py,sha256=VnmhYS1zt6a41ip1_lvXAJAV1us4HdtqfiIFkb8hQmM,6059
+substitutionciphers-1.0.0.dist-info/METADATA,sha256=8nJbaL7zF5FloBNhKJLEfe9eL3mbzMyTxjUE5ZMSSag,3091
+substitutionciphers-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+substitutionciphers-1.0.0.dist-info/RECORD,,

substitutionciphers-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any