mincrypt 1.1.7__py3-none-win_amd64.whl

mincrypt/__init__.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+from . import caesar, fastcalc, rail_fence, vigenere, xor
+from .exceptions import InvalidAlgorithmError, InvalidKeyError
+
+__all__ = [
+    "caesar",
+    "vigenere",
+    "xor",
+    "rail_fence",
+    "fastcalc",
+    "encrypt",
+    "decrypt",
+    "InvalidAlgorithmError",
+    "InvalidKeyError",
+]
+
+_ALGORITHMS = {
+    "caesar": caesar,
+    "vigenere": vigenere,
+    "xor": xor,
+    "rail_fence": rail_fence,
+    "rail-fence": rail_fence,
+    "railfence": rail_fence,
+}
+
+
+def _get_algorithm(name: str):
+    try:
+        return _ALGORITHMS[name.lower()]
+    except KeyError as exc:
+        available = ", ".join(sorted(_ALGORITHMS))
+        raise InvalidAlgorithmError(
+            f"Unknown algorithm {name!r}. Available: {available}."
+        ) from exc
+
+
+def encrypt(text: str, algorithm: str, **options) -> str:
+    module = _get_algorithm(algorithm)
+    return module.encrypt(text, **options)
+
+
+def decrypt(text: str, algorithm: str, **options) -> str:
+    module = _get_algorithm(algorithm)
+    return module.decrypt(text, **options)

mincrypt/caesar.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from . import fastcalc
+
+
+def encrypt(text: str, shift: int = 3) -> str:
+    """Encrypt text with a Caesar shift."""
+    return fastcalc.shift_text(text, shift)
+
+
+def decrypt(text: str, shift: int = 3) -> str:
+    """Decrypt text encrypted with the same Caesar shift."""
+    return fastcalc.shift_text(text, -shift)

mincrypt/exceptions.py

@@ -0,0 +1,10 @@
+class CryptoError(Exception):
+    """Base error for mincrypt."""
+
+
+class InvalidKeyError(CryptoError, ValueError):
+    """Raised when a key is empty or invalid."""
+
+
+class InvalidAlgorithmError(CryptoError, ValueError):
+    """Raised when an unknown algorithm name is requested."""

mincrypt/fastcalc.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+
+def mod(value: int, base: int) -> int:
+    """Return value modulo base."""
+    if base == 0:
+        raise ValueError("base must not be 0")
+    return value % base
+
+
+def shift_char(char: str, shift: int) -> str:
+    """
+    Shift one alphabet character.
+
+    Non alphabet characters are returned unchanged.
+    Keeps original uppercase/lowercase.
+    """
+    if len(char) != 1:
+        raise ValueError("char must be a single character")
+
+    code = ord(char)
+
+    if 65 <= code <= 90:
+        return chr(((code - 65 + shift) % 26) + 65)
+
+    if 97 <= code <= 122:
+        return chr(((code - 97 + shift) % 26) + 97)
+
+    return char
+
+
+def shift_text(text: str, shift: int) -> str:
+    """
+    Shift all alphabet characters in text.
+
+    Non alphabet characters are kept unchanged.
+    """
+    result = []
+
+    for char in text:
+        code = ord(char)
+
+        if 65 <= code <= 90:
+            result.append(chr(((code - 65 + shift) % 26) + 65))
+        elif 97 <= code <= 122:
+            result.append(chr(((code - 97 + shift) % 26) + 97))
+        else:
+            result.append(char)
+
+    return "".join(result)
+
+
+def alpha_shift_value(char: str) -> int:
+    """
+    Convert one alphabet character to a shift value.
+
+    A/a -> 0
+    B/b -> 1
+    ...
+    Z/z -> 25
+    """
+    if len(char) != 1:
+        raise ValueError("char must be a single character")
+
+    code = ord(char)
+
+    if 65 <= code <= 90:
+        return code - 65
+
+    if 97 <= code <= 122:
+        return code - 97
+
+    raise ValueError("char must be an alphabet character")
+
+
+def alpha_shift_values(text: str) -> list[int]:
+    """
+    Convert alphabet characters in text to shift values.
+
+    Non alphabet characters are ignored.
+    """
+    values = []
+
+    for char in text:
+        code = ord(char)
+
+        if 65 <= code <= 90:
+            values.append(code - 65)
+        elif 97 <= code <= 122:
+            values.append(code - 97)
+
+    return values
+
+
+def text_to_bytes(value: str, encoding: str = "utf-8") -> bytes:
+    """Convert text to bytes."""
+    return value.encode(encoding)
+
+
+def bytes_to_text(value: bytes, encoding: str = "utf-8") -> str:
+    """Convert bytes to text."""
+    return value.decode(encoding)
+
+
+def repeat_key_bytes(key: bytes, length: int) -> bytes:
+    """
+    Repeat key bytes until reaching target length.
+
+    Example:
+        key=b"ab", length=5 -> b"ababa"
+    """
+    if length < 0:
+        raise ValueError("length must be >= 0")
+
+    if not key:
+        raise ValueError("key must not be empty")
+
+    repeated = bytearray()
+
+    while len(repeated) < length:
+        repeated.extend(key)
+
+    return bytes(repeated[:length])
+
+
+def xor_bytes(data: bytes, key: bytes) -> bytes:
+    """
+    XOR data bytes with repeating key bytes.
+
+    Returns raw bytes.
+    """
+    if not key:
+        raise ValueError("key must not be empty")
+
+    result = bytearray()
+    key_length = len(key)
+
+    for index, byte in enumerate(data):
+        result.append(byte ^ key[index % key_length])
+
+    return bytes(result)
+
+
+def rail_index_pattern(length: int, rails: int) -> list[int]:
+    """
+    Return rail index pattern for Rail Fence calculation.
+
+    Example:
+        length=8, rails=3 -> [0, 1, 2, 1, 0, 1, 2, 1]
+    """
+    if length < 0:
+        raise ValueError("length must be >= 0")
+
+    if rails < 2:
+        raise ValueError("rails must be >= 2")
+
+    pattern = []
+    rail = 0
+    direction = 1
+
+    for _ in range(length):
+        pattern.append(rail)
+
+        rail += direction
+
+        if rail == 0 or rail == rails - 1:
+            direction *= -1
+
+    return pattern
+
+
+def split_by_indexes(text: str, indexes: list[int], target: int) -> str:
+    """
+    Return characters from text where indexes match target.
+
+    Used by algorithms that group characters by calculated indexes.
+    """
+    result = []
+
+    for position, char in enumerate(text):
+        if indexes[position] == target:
+            result.append(char)
+
+    return "".join(result)

mincrypt/rail_fence.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from . import fastcalc
+
+
+def _validate_rails(rails: int) -> None:
+    if not isinstance(rails, int):
+        raise TypeError("rails must be an int")
+    if rails < 2:
+        raise ValueError("rails must be at least 2")
+
+
+def encrypt(text: str, rails: int = 3) -> str:
+    """Encrypt text with a Rail Fence transposition."""
+    _validate_rails(rails)
+
+    pattern = fastcalc.rail_index_pattern(len(text), rails)
+    rows = []
+
+    for rail in range(rails):
+        rows.append(fastcalc.split_by_indexes(text, pattern, rail))
+
+    return "".join(rows)
+
+
+def decrypt(text: str, rails: int = 3) -> str:
+    """Decrypt text encrypted with the same rail count."""
+    _validate_rails(rails)
+
+    pattern = fastcalc.rail_index_pattern(len(text), rails)
+    counts = [0] * rails
+
+    for rail in pattern:
+        counts[rail] += 1
+
+    rows = []
+    start = 0
+
+    for count in counts:
+        rows.append(list(text[start : start + count]))
+        start += count
+
+    indexes = [0] * rails
+    output = []
+
+    for rail in pattern:
+        output.append(rows[rail][indexes[rail]])
+        indexes[rail] += 1
+
+    return "".join(output)

mincrypt/vigenere.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from . import fastcalc
+from .exceptions import InvalidKeyError
+
+
+def _crypt(text: str, key: str, direction: int) -> str:
+    shifts = fastcalc.alpha_shift_values(key)
+
+    if not shifts:
+        raise InvalidKeyError("Vigenere key must contain at least one letter.")
+
+    result = []
+    key_index = 0
+    key_length = len(shifts)
+
+    for char in text:
+        code = ord(char)
+
+        if 65 <= code <= 90 or 97 <= code <= 122:
+            shift = shifts[key_index % key_length] * direction
+            result.append(fastcalc.shift_char(char, shift))
+            key_index += 1
+        else:
+            result.append(char)
+
+    return "".join(result)
+
+
+def encrypt(text: str, key: str) -> str:
+    """Encrypt text with a repeating Vigenere key."""
+    return _crypt(text, key, direction=1)
+
+
+def decrypt(text: str, key: str) -> str:
+    """Decrypt text encrypted with the same Vigenere key."""
+    return _crypt(text, key, direction=-1)

mincrypt/xor.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import base64
+
+from . import fastcalc
+from .exceptions import InvalidKeyError
+
+BytesLike = bytes | bytearray | memoryview | str
+
+
+def _to_bytes(value: BytesLike) -> bytes:
+    if isinstance(value, str):
+        return fastcalc.text_to_bytes(value)
+    return bytes(value)
+
+
+def xor_bytes(data: BytesLike, key: BytesLike) -> bytes:
+    """XOR bytes with a repeating key and return raw bytes."""
+    data_bytes = _to_bytes(data)
+    key_bytes = _to_bytes(key)
+
+    if not key_bytes:
+        raise InvalidKeyError("XOR key must not be empty.")
+
+    return fastcalc.xor_bytes(data_bytes, key_bytes)
+
+
+def encrypt(text: str, key: BytesLike) -> str:
+    """Encrypt text and return a URL-safe Base64 token."""
+    encrypted = xor_bytes(text, key)
+    return fastcalc.bytes_to_text(base64.urlsafe_b64encode(encrypted), encoding="ascii")
+
+
+def decrypt(token: str, key: BytesLike) -> str:
+    """Decrypt a Base64 token produced by encrypt()."""
+    encrypted = base64.urlsafe_b64decode(fastcalc.text_to_bytes(token, encoding="ascii"))
+    decrypted = xor_bytes(encrypted, key)
+    return fastcalc.bytes_to_text(decrypted)

mincrypt-1.1.7.dist-info/METADATA

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: mincrypt
+Version: 1.1.7
+Summary: Simple classical cryptography utilities.
+Author: jishino
+Author-email: jishino@gmail.com
+License: MIT
+Keywords: crypto,cryptography
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+`mincrypt` includes Caesar, Vigenere, XOR, and Rail Fence helpers, plus generic `encrypt()` and `decrypt()` functions for selecting an algorithm by name.
+
+## Features
+
+- Caesar shift encryption and decryption
+- Vigenere encryption and decryption with repeating alphabetic keys
+- XOR encryption that returns URL-safe Base64 tokens
+- Rail Fence transposition encryption and decryption
+- Generic algorithm dispatch with `encrypt()` and `decrypt()`
+- Small helper functions for shifts, bytes, XOR, modulo, and rail patterns
+- Custom exceptions for invalid keys and unknown algorithms
+
+## Requirements
+
+- Python 3.8 or newer
+
+## Installation
+
+From the project root, install the package in editable mode:
+
+```bash
+python -m pip install -e .
+```
+
+Or, during local development, keep the package directory on your `PYTHONPATH` and import it directly:
+
+```python
+import mincrypt
+```
+
+## Quick start
+
+```python
+from mincrypt import caesar, decrypt, encrypt, rail_fence, vigenere, xor
+
+message = "Hello UIPackage!"
+
+caesar_cipher = caesar.encrypt(message, shift=4)
+print(caesar_cipher)
+print(caesar.decrypt(caesar_cipher, shift=4))
+
+vigenere_cipher = vigenere.encrypt(message, key="secret")
+print(vigenere_cipher)
+print(vigenere.decrypt(vigenere_cipher, key="secret"))
+
+xor_cipher = xor.encrypt(message, key="secret")
+print(xor_cipher)
+print(xor.decrypt(xor_cipher, key="secret"))
+
+rail_cipher = rail_fence.encrypt(message, rails=3)
+print(rail_cipher)
+print(rail_fence.decrypt(rail_cipher, rails=3))
+
+# Generic helper
+cipher = encrypt(message, algorithm="caesar", shift=2)
+print(cipher)
+print(decrypt(cipher, algorithm="caesar", shift=2))
+```
+
+Example output:
+
+```text
+Lipps YMTegoeki!
+Hello UIPackage!
+Zincs NATctotyi!
+Hello UIPackage!
+OwAPHgpUJiwzEwYfEgIGUw==
+Hello UIPackage!
+HoPael Iakg!lUce
+Hello UIPackage!
+Jgnnq WKRcemcig!
+Hello UIPackage!
+```
+
+## Algorithms
+
+### Caesar
+
+Shift alphabetic characters by a fixed number. Uppercase and lowercase letters are preserved, and non-alphabetic characters are left unchanged.
+
+```python
+from mincrypt import caesar
+
+cipher = caesar.encrypt("Attack at dawn!", shift=3)
+plain = caesar.decrypt(cipher, shift=3)
+```
+
+### Vigenere
+
+Encrypt text using a repeating alphabetic key. Non-alphabetic characters are preserved and do not consume key characters.
+
+```python
+from mincrypt import vigenere
+
+cipher = vigenere.encrypt("Attack at dawn!", key="lemon")
+plain = vigenere.decrypt(cipher, key="lemon")
+```
+
+A Vigenere key must contain at least one alphabetic character.
+
+### XOR
+
+XOR text with a repeating key. `encrypt()` returns a URL-safe Base64 token, and `decrypt()` converts that token back to text.
+
+```python
+from mincrypt import xor
+
+cipher = xor.encrypt("Attack at dawn!", key="secret")
+plain = xor.decrypt(cipher, key="secret")
+```
+
+For raw bytes, use `xor.xor_bytes()`:
+
+```python
+from mincrypt import xor
+
+raw = xor.xor_bytes(b"data", b"key")
+```
+
+### Rail Fence
+
+Encrypt text with a Rail Fence transposition using two or more rails.
+
+```python
+from mincrypt import rail_fence
+
+cipher = rail_fence.encrypt("Attack at dawn!", rails=3)
+plain = rail_fence.decrypt(cipher, rails=3)
+```
+
+## Generic API
+
+Use `encrypt()` and `decrypt()` when you want to choose an algorithm dynamically:
+
+```python
+from mincrypt import encrypt, decrypt
+
+cipher = encrypt("Hello", algorithm="caesar", shift=3)
+plain = decrypt(cipher, algorithm="caesar", shift=3)
+```
+
+Supported algorithm names:
+
+- `caesar`
+- `vigenere`
+- `xor`
+- `rail_fence`
+- `rail-fence`
+- `railfence`
+
+Algorithm-specific options are passed as keyword arguments:
+
+```python
+encrypt("Hello", algorithm="caesar", shift=3)
+encrypt("Hello", algorithm="vigenere", key="secret")
+encrypt("Hello", algorithm="xor", key="secret")
+encrypt("Hello", algorithm="rail_fence", rails=3)
+```
+
+## Exceptions
+
+```python
+from mincrypt import InvalidAlgorithmError, InvalidKeyError
+```
+
+- `InvalidKeyError` is raised when a required key is empty or invalid.
+- `InvalidAlgorithmError` is raised when the generic API receives an unknown algorithm name.
+
+Example:
+
+```python
+from mincrypt import InvalidAlgorithmError, encrypt
+
+try:
+    encrypt("Hello", algorithm="unknown")
+except InvalidAlgorithmError as exc:
+    print(exc)
+```
+
+## Helper functions
+
+The `fastcalc` module contains lower-level helpers used by the algorithms:
+
+- `mod(value, base)`
+- `shift_char(char, shift)`
+- `shift_text(text, shift)`
+- `alpha_shift_value(char)`
+- `alpha_shift_values(text)`
+- `text_to_bytes(value, encoding="utf-8")`
+- `bytes_to_text(value, encoding="utf-8")`
+- `repeat_key_bytes(key, length)`
+- `xor_bytes(data, key)`
+- `rail_index_pattern(length, rails)`
+- `split_by_indexes(text, indexes, target)`
+
+Most users should prefer the higher-level algorithm modules unless they need these building blocks directly.
+
+## Project layout
+
+```text
+mincrypt/
+├── __init__.py
+├── caesar.py
+├── exceptions.py
+├── fastcalc.py
+├── rail_fence.py
+├── vigenere.py
+└── xor.py
+README.md
+```
+
+## License
+
+MIT

mincrypt-1.1.7.dist-info/RECORD

@@ -0,0 +1,12 @@
+mincrypt/__init__.py,sha256=r5p8ZNA0eswX233DXBeydKQ_J_1e8oVE5B2ntK6L4Ew,1069
+mincrypt/caesar.py,sha256=EpCC9d3GJPOFjitVZAhifbdoRLdQp2Wl3oY6L7sRlxQ,351
+mincrypt/exceptions.py,sha256=Hug61Tg39gB98cjRn9I1VtxdiUw5fI6DVp0pBBOTE6s,282
+mincrypt/fastcalc.py,sha256=u-lO_JRgtlnp-llK7EVV4GFgcKIH3AUBliL0X6d1B-c,3998
+mincrypt/fastcalc.pyd,sha256=NatTylblbQ4YHsjh7gYM5ta4y5oKXMSzZdGeCJ_YiKQ,233984
+mincrypt/rail_fence.py,sha256=VUgqzHfnGqM5_wHcGfhAfpfOVmencdXeEzRkNdyZtbE,1167
+mincrypt/vigenere.py,sha256=QGBpistNJFMtqyY6YP8rOzRXRbrUGu1QEUOp7GRXSeo,976
+mincrypt/xor.py,sha256=q8Q2S73JGLY79DtTW6qDdF-C-0ExuTV2b2G3kHjSQd8,1148
+mincrypt-1.1.7.dist-info/METADATA,sha256=MYhbaj5t6PQioGdylVsNAFXFcVH7I94E3rn0IRJw35Q,5834
+mincrypt-1.1.7.dist-info/WHEEL,sha256=s_n0jCiMo-4SyzSB02xUGmNO5EUQXxQMERsYM7CCHiM,97
+mincrypt-1.1.7.dist-info/top_level.txt,sha256=vue3km76FXK2IFlYN48MgnrWZwOQWgUBFh7SqqGdmxY,9
+mincrypt-1.1.7.dist-info/RECORD,,

mincrypt-1.1.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-win_amd64
+

mincrypt-1.1.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+mincrypt