enc67 0.1.0__tar.gz

enc67-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Snorre
+
+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.

enc67-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: enc67
+Version: 0.1.0
+Summary: Encode bytes as a stream of 67s and 76s, with optional XOR obfuscation.
+Project-URL: Homepage, https://pypi.org/project/enc67/
+Author-email: Snorre <snorre@addmedia.no>
+License: MIT
+License-File: LICENSE
+Keywords: 67,encoding,fun,obfuscation
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# enc67
+
+Encode bytes as a stream of `67` and `76` tokens. Optional repeating-XOR key for light obfuscation.
+
+> ⚠️ **Not real encryption.** The optional key is repeating-XOR (Vigenère on bytes). Use it as a toy or for fun — not for secrets.
+
+## Install
+
+```bash
+pip install enc67
+```
+
+## Use it
+
+```python
+from enc67 import encrypt, decrypt
+
+ct = encrypt("Hi", key="secret")
+# '67 67 76 76 76 67 76 76 67 67 67 67 76 76 67 67'
+
+decrypt(ct, key="secret")
+# 'Hi'
+```
+
+Or from the CLI:
+
+```bash
+enc67 encrypt "Hi" secret
+enc67 decrypt "67 67 76 ..." secret
+```
+
+## How it works
+
+1. Encode UTF-8.
+2. (Optional) XOR with the repeating key.
+3. For each byte, emit 8 tokens: `67` for bit `0`, `76` for bit `1`, big-endian.
+
+No key → pure encoding. With a key → toy obfuscation.
+
+## License
+
+MIT.

enc67-0.1.0/README.md

@@ -0,0 +1,42 @@
+# enc67
+
+Encode bytes as a stream of `67` and `76` tokens. Optional repeating-XOR key for light obfuscation.
+
+> ⚠️ **Not real encryption.** The optional key is repeating-XOR (Vigenère on bytes). Use it as a toy or for fun — not for secrets.
+
+## Install
+
+```bash
+pip install enc67
+```
+
+## Use it
+
+```python
+from enc67 import encrypt, decrypt
+
+ct = encrypt("Hi", key="secret")
+# '67 67 76 76 76 67 76 76 67 67 67 67 76 76 67 67'
+
+decrypt(ct, key="secret")
+# 'Hi'
+```
+
+Or from the CLI:
+
+```bash
+enc67 encrypt "Hi" secret
+enc67 decrypt "67 67 76 ..." secret
+```
+
+## How it works
+
+1. Encode UTF-8.
+2. (Optional) XOR with the repeating key.
+3. For each byte, emit 8 tokens: `67` for bit `0`, `76` for bit `1`, big-endian.
+
+No key → pure encoding. With a key → toy obfuscation.
+
+## License
+
+MIT.

enc67-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "enc67"
+version = "0.1.0"
+description = "Encode bytes as a stream of 67s and 76s, with optional XOR obfuscation."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+authors = [{ name = "Snorre", email = "snorre@addmedia.no" }]
+keywords = ["encoding", "obfuscation", "fun", "67"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Security :: Cryptography",
+    "Topic :: Utilities",
+]
+
+[project.scripts]
+enc67 = "enc67.__main__:main"
+
+[project.urls]
+Homepage = "https://pypi.org/project/enc67/"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/enc67"]

enc67-0.1.0/src/enc67/__init__.py

@@ -0,0 +1,9 @@
+"""enc67 — encode bytes as a stream of 67s and 76s, with optional XOR obfuscation.
+
+WARNING: the optional key is repeating-XOR (Vigenère on bytes). It is OBFUSCATION,
+not cryptography. Do not use this to protect real secrets.
+"""
+from .core import encrypt, decrypt, encode, decode
+
+__all__ = ["encrypt", "decrypt", "encode", "decode"]
+__version__ = "0.1.0"

enc67-0.1.0/src/enc67/__main__.py

@@ -0,0 +1,22 @@
+"""CLI: python -m enc67 encrypt|decrypt <text> [key]"""
+import sys
+from .core import encrypt, decrypt
+
+
+def main() -> None:
+    if len(sys.argv) < 3:
+        print("usage: enc67 [encrypt|decrypt] <text> [key]", file=sys.stderr)
+        sys.exit(2)
+    mode, text = sys.argv[1], sys.argv[2]
+    key = sys.argv[3] if len(sys.argv) > 3 else ""
+    if mode == "encrypt":
+        print(encrypt(text, key))
+    elif mode == "decrypt":
+        print(decrypt(text, key))
+    else:
+        print(f"unknown mode: {mode}", file=sys.stderr)
+        sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()

enc67-0.1.0/src/enc67/core.py

@@ -0,0 +1,56 @@
+"""Core encode/decode + obfuscation primitives."""
+from __future__ import annotations
+
+
+def _key_stream(key: bytes, n: int) -> bytes:
+    if not key:
+        return b"\x00" * n
+    return bytes(key[i % len(key)] for i in range(n))
+
+
+def encode(data: bytes) -> str:
+    """Encode raw bytes as space-separated 67/76 tokens (8 per byte)."""
+    tokens = []
+    for byte in data:
+        for i in range(7, -1, -1):
+            tokens.append("76" if (byte >> i) & 1 else "67")
+    return " ".join(tokens)
+
+
+def decode(tokens_str: str) -> bytes:
+    """Decode a 67/76 token stream back into bytes."""
+    tokens = tokens_str.split()
+    if len(tokens) % 8 != 0:
+        raise ValueError(f"token count {len(tokens)} is not a multiple of 8")
+    out = bytearray()
+    for i in range(0, len(tokens), 8):
+        byte = 0
+        for t in tokens[i:i + 8]:
+            if t == "67":
+                bit = 0
+            elif t == "76":
+                bit = 1
+            else:
+                raise ValueError(f"bad token {t!r} — expected 67 or 76")
+            byte = (byte << 1) | bit
+        out.append(byte)
+    return bytes(out)
+
+
+def encrypt(plaintext: str, key: str = "") -> str:
+    """XOR plaintext (UTF-8) with repeating key, then 67/76-encode.
+
+    With no key this is just encoding. With a key it is repeating-XOR
+    obfuscation — not real encryption.
+    """
+    data = plaintext.encode("utf-8")
+    ks = _key_stream(key.encode("utf-8"), len(data))
+    xored = bytes(b ^ k for b, k in zip(data, ks))
+    return encode(xored)
+
+
+def decrypt(ciphertext: str, key: str = "") -> str:
+    """Inverse of encrypt — returns UTF-8 plaintext."""
+    data = decode(ciphertext)
+    ks = _key_stream(key.encode("utf-8"), len(data))
+    return bytes(b ^ k for b, k in zip(data, ks)).decode("utf-8")