vicrypt 0.1.0__tar.gz

vicrypt-0.1.0/.gitignore

@@ -0,0 +1 @@
+.wakatime-project

vicrypt-0.1.0/LICENSE

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

vicrypt-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.5
+Name: vicrypt
+Version: 0.1.0
+Summary: A Python cryptography toolset for CTF work
+Project-URL: Homepage, https://github.com/vincentchen18/vicrypt
+Project-URL: Repository, https://github.com/vincentchen18/vicrypt
+Project-URL: Issues, https://github.com/vincentchen18/vicrypt/issues
+Author: Vincent Chen
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cipher,cryptography,ctf,encoding,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ViCrypt
+
+## Overview
+
+ViCrypt is a command line cryptography tool (currently a WIP) with basic encoding/decoding functionality! Featuring hex encode/decode, base64 encode/decode, base32 encode/decode, base85 encode/decode, URL encode/decode, binary encode/decode, atbash, ROT13, ROT47, ROT brute-force (all rotations), custom-offset rotation, affine encode/decode, affine brute-force (function exists but not wired to CLI), repeating-key XOR, single-byte XOR brute-force (in magic only), text and decimal codepoints, and the magic-wand auto-analyser (multi-layer beam search that auto-detects and decodes, scoring by printable ratio + common words + flag regex)
+
+This project was inspired by [gchq](https://github.com/gchq/)'s [Cyberchef](https://github.com/gchq/CyberChef), although no code was taken from it.
+
+## Installation
+
+### Requirements:
+Python >= 3.9
+
+In your terminal, run 
+
+`pip install vicrypt`
+
+and you're good to go!
+
+
+## Usage
+
+All commands take the form `vicrypt <command> <text> [options]`.
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `hex` | Hex encode / decode | `vicrypt hex <text>` |
+| `b64` | Base64 encode / decode | `vicrypt b64 <text>` |
+| `b32` | Base32 encode / decode | `vicrypt b32 <text>` |
+| `b85` | Base85 encode / decode | `vicrypt b85 <text>` |
+| `url` | URL encode / decode | `vicrypt url <text>` |
+| `binary` | Binary encode / decode | `vicrypt binary <text>` |
+| `atbash` | Atbash cipher (self-inverse) | `vicrypt atbash <text>` |
+| `rot` | ROT13 / ROT47, with brute-force | `vicrypt rot <text>` |
+| `affine` | Affine cipher | `vicrypt affine <text> -a 5 -b 8` |
+| `xor` | Repeating-key XOR | `vicrypt xor <text> --key <key>` |
+| `decimal` | Text to/from decimal codepoints | `vicrypt decimal <text>` |
+| `analyse` | Auto-detect and decode (magic wand) | `vicrypt analyse <text>` |
+
+### Flags
+
+| Flag | Applies to | Meaning |
+|------|-------------|---------|
+| `-d`, `--decode` | codecs, `affine`, `decimal` | decode instead of encode |
+| `--variant` | `rot` | rot13 (default) or rot47 |
+| `-n` | `rot` | rotation offset |
+| `--brute` | `rot` | print all rotations |
+| `-a`, `-b` | `affine` | cipher coefficients (required) |
+| `--key` | `xor` | XOR key (required) |
+| `-d`, `--depth` | `analyse` | max decode layers (default 3) |
+| `-b`, `--beam` | `analyse` | branches kept per layer (default 6) |
+
+## AI Use
+
+AI was used for help on the pyproject.toml as well as the argparse module, however all encodings and encryptions were researched and coded and implemented by me.

vicrypt-0.1.0/README.md

@@ -0,0 +1,55 @@
+# ViCrypt
+
+## Overview
+
+ViCrypt is a command line cryptography tool (currently a WIP) with basic encoding/decoding functionality! Featuring hex encode/decode, base64 encode/decode, base32 encode/decode, base85 encode/decode, URL encode/decode, binary encode/decode, atbash, ROT13, ROT47, ROT brute-force (all rotations), custom-offset rotation, affine encode/decode, affine brute-force (function exists but not wired to CLI), repeating-key XOR, single-byte XOR brute-force (in magic only), text and decimal codepoints, and the magic-wand auto-analyser (multi-layer beam search that auto-detects and decodes, scoring by printable ratio + common words + flag regex)
+
+This project was inspired by [gchq](https://github.com/gchq/)'s [Cyberchef](https://github.com/gchq/CyberChef), although no code was taken from it.
+
+## Installation
+
+### Requirements:
+Python >= 3.9
+
+In your terminal, run 
+
+`pip install vicrypt`
+
+and you're good to go!
+
+
+## Usage
+
+All commands take the form `vicrypt <command> <text> [options]`.
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `hex` | Hex encode / decode | `vicrypt hex <text>` |
+| `b64` | Base64 encode / decode | `vicrypt b64 <text>` |
+| `b32` | Base32 encode / decode | `vicrypt b32 <text>` |
+| `b85` | Base85 encode / decode | `vicrypt b85 <text>` |
+| `url` | URL encode / decode | `vicrypt url <text>` |
+| `binary` | Binary encode / decode | `vicrypt binary <text>` |
+| `atbash` | Atbash cipher (self-inverse) | `vicrypt atbash <text>` |
+| `rot` | ROT13 / ROT47, with brute-force | `vicrypt rot <text>` |
+| `affine` | Affine cipher | `vicrypt affine <text> -a 5 -b 8` |
+| `xor` | Repeating-key XOR | `vicrypt xor <text> --key <key>` |
+| `decimal` | Text to/from decimal codepoints | `vicrypt decimal <text>` |
+| `analyse` | Auto-detect and decode (magic wand) | `vicrypt analyse <text>` |
+
+### Flags
+
+| Flag | Applies to | Meaning |
+|------|-------------|---------|
+| `-d`, `--decode` | codecs, `affine`, `decimal` | decode instead of encode |
+| `--variant` | `rot` | rot13 (default) or rot47 |
+| `-n` | `rot` | rotation offset |
+| `--brute` | `rot` | print all rotations |
+| `-a`, `-b` | `affine` | cipher coefficients (required) |
+| `--key` | `xor` | XOR key (required) |
+| `-d`, `--depth` | `analyse` | max decode layers (default 3) |
+| `-b`, `--beam` | `analyse` | branches kept per layer (default 6) |
+
+## AI Use
+
+AI was used for help on the pyproject.toml as well as the argparse module, however all encodings and encryptions were researched and coded and implemented by me.

vicrypt-0.1.0/main.py

@@ -0,0 +1,388 @@
+import re
+def hex_to_text(text, delimiter=""):
+    try:
+        if delimiter:
+            text = text.replace(delimiter, "")
+        text = re.sub(r"(?i)0x|\\x|[^0-9a-f]", "", text)
+        if "0x" == text[:2]:
+            return bytes.fromhex(text[2:]).decode("utf-8")
+        else:
+            return bytes.fromhex(text).decode("utf-8")
+    except Exception:
+        return False
+
+def text_to_hex(text):
+    try:
+        return text.encode("utf-8").hex()
+    except Exception:
+        return False
+
+import base64
+def text_to_base64(text):
+    try:
+        return base64.b64encode(text.encode("utf-8")).decode("utf-8")
+    except Exception:
+        return False
+
+def base64_to_text(text):
+    try:
+        return base64.b64decode(text.encode("utf-8")).decode("utf-8")
+    except Exception:
+        return False
+
+def text_to_base32(text):
+    try:
+        return base64.b32encode(text.encode("utf-8")).decode("utf-8")
+    except Exception:
+        return False
+
+def base32_to_text(text):
+    try:
+        return base64.b32decode(text.encode("utf-8")).decode("utf-8")
+    except Exception:
+        return False
+
+def text_to_base85(text):
+    try:
+        return base64.b85encode(text.encode("utf-8")).decode("utf-8")
+    except Exception:
+        return False
+
+def base85_to_text(text):
+    try:
+        return base64.b85decode(text.encode("utf-8")).decode("utf-8")
+    except Exception:
+        return False
+
+from urllib.parse import quote, unquote
+def text_to_url(text):
+    try:
+        return quote(text.encode("utf-8"))
+    except Exception:
+        return False
+
+def url_to_text(url):
+    try:
+        return unquote(url)
+    except Exception:
+        return False
+
+letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
+def rot13(text, rot=13, bruteforce=False, rotate_numbers=False):
+    if bruteforce:
+        result = []
+        for i in range(26):
+            try:
+                result.append(rot13(text, rot=i+1, rotate_numbers=rotate_numbers))
+            except Exception:
+                return False
+        return result
+    else:
+        try:
+            global letters
+            ans = ""
+            for char in text:
+                if char in letters:
+                    ind = letters[(ord(char.upper())+13+rot)%26]
+                    if char.isupper():
+                        ans += ind.upper()
+                    else:
+                        ans += ind.lower()
+                elif rotate_numbers and char.isdigit():
+                    ans += str((int(char) + rot)%10)
+                else:
+                    ans += char
+            return ans
+        except Exception:
+            return False
+
+def xor(text, key):
+    ct = ""
+    for i in range(len(text)):
+        ct += chr(ord(text[i]) ^ ord(key[i % len(key)]))
+    return ct
+
+def rot47(text, rot=47, bruteforce=False):
+    if bruteforce:
+        result = []
+        for i in range(94):
+            try:
+                result.append(rot47(text, rot=i))
+            except Exception:
+                return False
+        return result
+    try:
+        ans = ""
+        for char in text:
+            if 33 <= ord(char) <= 126:
+                ans += chr((ord(char) - 33 + rot) % 94 + 33)
+            else:
+                ans += char
+        return ans
+    except Exception:
+        return False
+
+def affine_encode(text, a, b):
+    global letters
+    ret = ""
+    for char in text:
+        if char.lower() in letters:
+            if char.isupper():
+                ret += letters[((ord(char.upper()) - 65) * a + b)%26].upper()
+            else:
+                ret += letters[((ord(char.upper()) - 65) * a + b)%26].lower()
+        else:
+            ret += char
+    return ret
+
+def atbash(text):
+    return affine_encode(text, a=25, b=25)
+
+def affine_decode(text, a, b):
+    global letters
+    if a not in [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]:
+        return False
+    invmod = pow(a, -1, 26)
+    ret = ""
+    for char in text:
+        if char.lower() in letters:
+            if char.isupper():
+                ret += letters[((ord(char.upper())-65-b)%26 * invmod)%26].upper()
+            else:
+                ret += letters[((ord(char.upper())-65-b)%26 * invmod)%26].lower()
+        else:
+            ret += char
+    return ret
+
+def affine_bruteforce(text, ciphertext):
+    for a in [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]:
+        for b in range(26):
+            if affine_encode(text, a, b) == ciphertext:
+                return a, b
+    return False
+
+def decimal_to_text(decimallist):
+    ret = "".join([chr(decimallist[i]) for i in range(len(decimallist))])
+    return ret
+
+def text_to_decimal(text):
+    ret = [ord(char) for char in text]
+    return ret
+
+def binary_to_text(binarylist):
+    try:
+        ret = ""
+        for binary in list(binarylist.split()):
+            decimal = int(binary, 2)
+            ret += chr(decimal)
+        return ret
+    except Exception:
+        return False
+
+def text_to_binary(text):
+    try:
+        ret = []
+        for char in text:
+            decimal = ord(char)
+            if decimal > 255:
+                return False
+            binary = format(ord(char), "08b")
+            ret.append(binary)
+        return " ".join(ret)
+    except Exception:
+        return False
+
+import argparse
+import sys
+
+codecs = {
+    "hex":    (text_to_hex, hex_to_text),
+    "b64":    (text_to_base64, base64_to_text),
+    "b32":    (text_to_base32, base32_to_text),
+    "b85":    (text_to_base85, base85_to_text),
+    "url":    (text_to_url, url_to_text),
+    "binary": (text_to_binary, binary_to_text),
+    "atbash": (atbash, atbash),
+}
+
+common_words = {"the", "and", "flag", "for", "you", "that", "this",
+          "with", "ctf", "key", "are", "was", "have", "not"}
+
+flag_regex = re.compile(r"[a-zA-Z0-9_]{2,}\{[^}]{2,}\}")
+
+def score(s):
+    global flag_regex, common_words
+    if not s or not isinstance(s, str):
+        return 0.0
+    printable = sum(1 for c in s if 32 <= ord(c) < 127 or c in "\n\t\r")
+    scoar = printable / len(s)
+    low = s.lower()
+    scoar += 0.2 * sum(w in low for w in common_words)
+    if flag_regex.search(s):
+        scoar += 3.0
+    return scoar
+
+def one(fn, label):
+    def run(t):
+        out = fn(t)
+        return [(label, out)] if out and isinstance(out, str) else []
+    return run
+
+def rot13_all(t):
+    res = rot13(t, bruteforce=True)
+    return [(f"rot13#{i+1}", v) for i, v in enumerate(res)] if res else []
+
+def rot47_all(t):
+    res = rot47(t, bruteforce=True)
+    return [(f"rot47#{i}", v) for i, v in enumerate(res)] if res else []
+
+def affine_all(t):
+    out = []
+    for a in [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]:
+        for b in range(26):
+            v = affine_decode(t, a, b)
+            if v:
+                out.append((f"affine:a{a}b{b}", v))
+    return out
+
+def xor1(t):
+    out = []
+    for k in range(1, 256):
+        try:
+            out.append((f"xor:0x{k:02x}", xor(t, chr(k))))
+        except Exception:
+            pass
+    return out
+
+cheap_search = [
+    one(hex_to_text, "hex"),
+    one(base64_to_text, "b64"),
+    one(base32_to_text, "b32"),
+    one(base85_to_text, "b85"),
+    one(binary_to_text, "binary"),
+    one(atbash, "atbash"),
+    rot13_all,
+]
+expensive_search = [affine_all, rot47_all, xor1]
+
+def magic(data, max_depth=3, beam=6, top=10):
+    results = []
+    frontier = [(data, [])]
+    seen = {data}
+    for depth in range(max_depth):
+        decoders = cheap_search + (expensive_search if depth == 0 else [])
+        scored = []
+        for text, recipe in frontier:
+            for dec in decoders:
+                for label, out in dec(text):
+                    if not out or not isinstance(out, str) or out in seen:
+                        continue
+                    seen.add(out)
+                    sc = score(out)
+                    step = recipe + [label]
+                    results.append((sc, step, out))
+                    scored.append((sc, out, step))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        frontier = [(out, step) for _, out, step in scored[:beam]]
+        if not frontier:
+            break
+    results.sort(key=lambda x: x[0], reverse=True)
+    return results[:top]
+
+def do_codec(args):
+    enc, dec = codecs[args.op]
+    fn = dec if args.decode else enc
+    out = fn(args.text)
+    if out is False:
+        mode = "decode" if args.decode else "encode"
+        print(f"error: {args.op} {mode} failed", file=sys.stderr)
+        sys.exit(1)
+    print(out)
+
+def do_rot(args):
+    fn = rot47 if args.variant == "rot47" else rot13
+    if args.brute:
+        res = fn(args.text, bruteforce=True)
+        if not res:
+            sys.exit(1)
+        for i, v in enumerate(res):
+            print(f"{i}: {v}")
+    else:
+        kwargs = {"rot": args.n} if args.n is not None else {}
+        print(fn(args.text, **kwargs))
+
+def do_affine(args):
+    fn = affine_decode if args.decode else affine_encode
+    out = fn(args.text, args.a, args.b)
+    if out is False:
+        print("error: invalid a (must be coprime with 26)", file=sys.stderr)
+        sys.exit(1)
+    print(out)
+
+def do_xor(args):
+    print(xor(args.text, args.key))
+
+def do_decimal(args):
+    if args.decode:
+        nums = [int(x) for x in args.text.split()]
+        print(decimal_to_text(nums))
+    else:
+        print(" ".join(str(n) for n in text_to_decimal(args.text)))
+
+def do_analyse(args):
+    hits = magic(args.text, max_depth=args.depth, beam=args.beam)
+    if not hits:
+        print("no candidates found", file=sys.stderr)
+        sys.exit(1)
+    for sc, recipe, out in hits:
+        preview = out if len(out) <= 80 else out[:77] + "..."
+        print(f"[{sc:5.2f}] {' -> '.join(recipe):<28} {preview!r}")
+
+def build_parser():
+    p = argparse.ArgumentParser(prog="vicrypt", description="Crypto/encoding toolset for CTFs")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    for name in codecs:
+        c = sub.add_parser(name, help=f"{name} encode/decode")
+        c.add_argument("text")
+        c.add_argument("-d", "--decode", action="store_true")
+        c.set_defaults(func=do_codec, op=name)
+
+    ro = sub.add_parser("rot", help="rot13/rot47")
+    ro.add_argument("text")
+    ro.add_argument("--variant", choices=["rot13", "rot47"], default="rot13")
+    ro.add_argument("-n", type=int, default=None)
+    ro.add_argument("--brute", action="store_true")
+    ro.set_defaults(func=do_rot)
+
+    af = sub.add_parser("affine", help="affine cipher")
+    af.add_argument("text")
+    af.add_argument("-a", type=int, required=True)
+    af.add_argument("-b", type=int, required=True)
+    af.add_argument("-d", "--decode", action="store_true")
+    af.set_defaults(func=do_affine)
+
+    x = sub.add_parser("xor", help="repeating-key xor")
+    x.add_argument("text")
+    x.add_argument("--key", required=True)
+    x.set_defaults(func=do_xor)
+
+    de = sub.add_parser("decimal", help="text <-> decimal codepoints")
+    de.add_argument("text")
+    de.add_argument("-d", "--decode", action="store_true")
+    de.set_defaults(func=do_decimal)
+
+    an = sub.add_parser("analyse", aliases=["magic"], help="auto-detect & decode")
+    an.add_argument("text")
+    an.add_argument("-d", "--depth", type=int, default=3)
+    an.add_argument("-b", "--beam", type=int, default=6)
+    an.set_defaults(func=do_analyse)
+
+    return p
+
+def main():
+    args = build_parser().parse_args()
+    args.func(args)
+
+if __name__ == "__main__":
+    main()

vicrypt-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vicrypt"
+version = "0.1.0"
+description = "A Python cryptography toolset for CTF work"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "Vincent Chen" }]
+keywords = ["cryptography", "ctf", "cipher", "encoding", "security"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Security :: Cryptography",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "ruff>=0.4"]
+
+[project.urls]
+Homepage = "https://github.com/vincentchen18/vicrypt"
+Repository = "https://github.com/vincentchen18/vicrypt"
+Issues = "https://github.com/vincentchen18/vicrypt/issues"
+
+[project.scripts]
+vicrypt = "main:main"
+
+[tool.hatch.build.targets.wheel]
+only-include = ["main.py"]
+
+[tool.hatch.build.targets.wheel.sources]
+"main.py" = "vicrypt.py"
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]