softcloak 1.0.0__py3-none-any.whl

softcloak/__init__.py

@@ -0,0 +1,6 @@
+"""Replace APK strings and re-sign the package."""
+
+from softcloak.rewrite import RewriteResult, rewrite_apk
+
+__all__ = ["RewriteResult", "rewrite_apk"]
+__version__ = "1.0.0"

softcloak/__main__.py

@@ -0,0 +1,4 @@
+from softcloak.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

softcloak/cli.py

@@ -0,0 +1,122 @@
+"""Command line for SoftCloak."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from softcloak.rewrite import rewrite_apk
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="softcloak",
+        description=(
+            "Replace substrings in an APK with a same-length obfuscated token, "
+            "replace exact strings with text you choose, and re-sign the APK."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "examples:\n"
+            "  softcloak app.apk -o rebuilt.apk --contains com.example --contains CompanyName\n"
+            '  softcloak app.apk -o rebuilt.apk --exact "Old full sentence" "New full sentence"\n'
+        ),
+    )
+    parser.add_argument("apk", help="input APK")
+    parser.add_argument("-o", "--output", required=True, help="signed output APK")
+    parser.add_argument(
+        "--contains",
+        action="append",
+        default=[],
+        metavar="SUBSTRING",
+        help="replace every occurrence of SUBSTRING with one generated token of the same length",
+    )
+    parser.add_argument(
+        "--exact",
+        nargs=2,
+        action="append",
+        default=[],
+        metavar=("OLD", "NEW"),
+        help="replace the exact text OLD with NEW. NEW must be the same length unless --fit is set",
+    )
+    parser.add_argument("--seed", default="softcloak", help="seed for generated tokens")
+    parser.add_argument(
+        "--fit",
+        choices=("error", "pad", "clip"),
+        default="error",
+        help="what to do when an exact replacement has a different length (default: error)",
+    )
+    parser.add_argument(
+        "--pad-char", default=" ", help="character used by --fit pad or --fit clip"
+    )
+    parser.add_argument(
+        "--allow-missing",
+        action="store_true",
+        help="do not fail when a search string is absent",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="report replacements without writing an APK",
+    )
+    parser.add_argument(
+        "--keystore",
+        help="existing keystore. A temporary key is generated when omitted",
+    )
+    parser.add_argument("--storepass", help="keystore password")
+    parser.add_argument("--keypass", help="key password. Defaults to --storepass")
+    parser.add_argument("--alias", default="repack", help="key alias")
+    return parser
+
+
+def _print_result(result) -> None:
+    for rule in result.rules:
+        utf8_count, utf16_count = result.counts.get(rule.old, (0, 0))
+        extras = [form for form in rule.forms if form != rule.old]
+        suffix = f" also {extras!r}" if extras else ""
+        print(
+            f"{rule.kind} {rule.old!r} -> {rule.new!r}{suffix} "
+            f"(utf8={utf8_count}, utf16={utf16_count})"
+        )
+    for warning in result.warnings:
+        print(f"warning: {warning}", file=sys.stderr)
+    if result.dry_run:
+        print("dry run: no APK written")
+    else:
+        print(f"wrote {result.output}")
+        print("signature verified")
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    for text in args.contains:
+        if len(text) < 4:
+            print(
+                f"warning: {text!r} is very short and can match unrelated bytes",
+                file=sys.stderr,
+            )
+    try:
+        result = rewrite_apk(
+            args.apk,
+            args.output,
+            contains=args.contains,
+            exact=[tuple(pair) for pair in args.exact],
+            seed=args.seed,
+            fit=args.fit,
+            pad_char=args.pad_char,
+            allow_missing=args.allow_missing,
+            dry_run=args.dry_run,
+            keystore=args.keystore,
+            storepass=args.storepass,
+            keypass=args.keypass,
+            alias=args.alias,
+        )
+    except (ValueError, RuntimeError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    _print_result(result)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

softcloak/package.py

@@ -0,0 +1,209 @@
+"""Build an aligned APK and sign it with jarsigner."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import struct
+import subprocess
+import tempfile
+import zipfile
+import zlib
+from pathlib import Path
+
+SIGNATURE_SUFFIXES = (".SF", ".RSA", ".DSA", ".EC")
+
+
+def is_signature_entry(name: str) -> bool:
+    if not name.upper().startswith("META-INF/"):
+        return False
+    base = name.rsplit("/", 1)[-1].upper()
+    return (
+        base == "MANIFEST.MF"
+        or base.startswith("SIG-")
+        or base.endswith(SIGNATURE_SUFFIXES)
+    )
+
+
+def find_java_tool(name: str) -> str:
+    found = shutil.which(name)
+    if found:
+        return found
+    java_home = os.environ.get("JAVA_HOME")
+    if java_home:
+        suffix = ".exe" if os.name == "nt" else ""
+        candidate = Path(java_home) / "bin" / f"{name}{suffix}"
+        if candidate.is_file():
+            return str(candidate)
+    raise RuntimeError(f"Could not find {name}. Install a JDK and put it on PATH.")
+
+
+def _deflate(data: bytes) -> bytes:
+    compressor = zlib.compressobj(9, zlib.DEFLATED, -15)
+    return compressor.compress(data) + compressor.flush()
+
+
+def build_zip(entries: list[tuple[zipfile.ZipInfo, bytes]], dest: Path) -> None:
+    blob = bytearray()
+    central = bytearray()
+    for info, data in entries:
+        name_b = info.filename.encode("utf-8")
+        method = (
+            zipfile.ZIP_STORED
+            if info.compress_type == zipfile.ZIP_STORED
+            else zipfile.ZIP_DEFLATED
+        )
+        crc = zlib.crc32(data) & 0xFFFFFFFF
+        if method == zipfile.ZIP_STORED:
+            payload = data
+            pad = (4 - ((len(blob) + 30 + len(name_b)) % 4)) % 4
+            extra = b"\x00" * pad
+        else:
+            payload = _deflate(data)
+            extra = b""
+        date_time = info.date_time or (2026, 10, 12, 0, 0, 0)
+        dos_time = (date_time[3] << 11) | (date_time[4] << 5) | (date_time[5] // 2)
+        dos_date = ((date_time[0] - 1980) << 9) | (date_time[1] << 5) | date_time[2]
+        local_off = len(blob)
+        blob += struct.pack(
+            "<IHHHHHIIIHH",
+            0x04034B50,
+            20,
+            0,
+            method,
+            dos_time,
+            dos_date,
+            crc,
+            len(payload),
+            len(data),
+            len(name_b),
+            len(extra),
+        )
+        blob += name_b + extra + payload
+        if (
+            method == zipfile.ZIP_STORED
+            and (local_off + 30 + len(name_b) + len(extra)) % 4 != 0
+        ):
+            raise RuntimeError(f"failed to align {info.filename}")
+        central += struct.pack(
+            "<IHHHHHHIIIHHHHHII",
+            0x02014B50,
+            20,
+            20,
+            0,
+            method,
+            dos_time,
+            dos_date,
+            crc,
+            len(payload),
+            len(data),
+            len(name_b),
+            len(extra),
+            0,
+            0,
+            0,
+            0,
+            local_off,
+        )
+        central += name_b + extra
+    cd_off = len(blob)
+    blob += central
+    blob += struct.pack(
+        "<IHHHHIIH",
+        0x06054B50,
+        0,
+        0,
+        len(entries),
+        len(entries),
+        len(central),
+        cd_off,
+        0,
+    )
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_bytes(blob)
+
+
+def _run(command: list[str]) -> None:
+    result = subprocess.run(command, capture_output=True, text=True, check=False)
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout or "").strip()
+        raise RuntimeError(f"{command[0]} failed: {detail}")
+
+
+def sign_apk(
+    unsigned: Path,
+    dest: Path,
+    *,
+    keystore: Path | None = None,
+    storepass: str | None = None,
+    keypass: str | None = None,
+    alias: str = "repack",
+) -> None:
+    keytool = find_java_tool("keytool")
+    jarsigner = find_java_tool("jarsigner")
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp = Path(temp_dir)
+        owned_keystore = keystore is None
+        if owned_keystore:
+            keystore = temp / "repack.keystore"
+            storepass = "android"
+            keypass = "android"
+            _run(
+                [
+                    keytool,
+                    "-genkeypair",
+                    "-keystore",
+                    str(keystore),
+                    "-storepass",
+                    storepass,
+                    "-keypass",
+                    keypass,
+                    "-alias",
+                    alias,
+                    "-keyalg",
+                    "RSA",
+                    "-keysize",
+                    "2048",
+                    "-validity",
+                    "10000",
+                    "-dname",
+                    "CN=SoftCloak, OU=Local, O=Local, C=US",
+                ]
+            )
+        if storepass is None:
+            raise RuntimeError("storepass is required when keystore is provided")
+        keypass = keypass or storepass
+        signed = temp / "signed.apk"
+        _run(
+            [
+                jarsigner,
+                "-sigalg",
+                "SHA256withRSA",
+                "-digestalg",
+                "SHA-256",
+                "-keystore",
+                str(keystore),
+                "-storepass",
+                storepass,
+                "-keypass",
+                keypass,
+                "-signedjar",
+                str(signed),
+                str(unsigned),
+                alias,
+            ]
+        )
+        with zipfile.ZipFile(signed) as archive:
+            entries = [
+                (info, archive.read(info.filename)) for info in archive.infolist()
+            ]
+        build_zip(entries, dest)
+        result = subprocess.run(
+            [jarsigner, "-verify", str(dest)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            detail = (result.stderr or result.stdout or "").strip()
+            raise RuntimeError(f"signed APK failed verification: {detail}")

softcloak/rewrite.py

@@ -0,0 +1,300 @@
+"""In-place APK string replacement that keeps binary lengths stable."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import struct
+import tempfile
+import zipfile
+import zlib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from softcloak.package import build_zip, is_signature_entry, sign_apk
+
+SKIP_SUFFIXES = {
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".webp",
+    ".gif",
+    ".so",
+    ".mp3",
+    ".ogg",
+    ".wav",
+    ".ttf",
+    ".otf",
+}
+
+
+@dataclass
+class Rule:
+    kind: str
+    old: str
+    new: str
+    forms: tuple[str, ...] = ()
+
+
+@dataclass
+class RewriteResult:
+    output: Path | None
+    rules: list[Rule]
+    counts: dict[str, tuple[int, int]]
+    warnings: list[str] = field(default_factory=list)
+    dry_run: bool = False
+
+
+def _ascii(value: str, label: str) -> None:
+    try:
+        value.encode("ascii")
+    except UnicodeEncodeError as exc:
+        raise ValueError(
+            f"{label} must be ASCII so the APK layout stays intact: {value!r}"
+        ) from exc
+
+
+def _fit(old: str, new: str, mode: str, pad_char: str) -> str:
+    if len(pad_char) != 1 or not pad_char.isascii():
+        raise ValueError("pad character must be one ASCII character")
+    if len(new) == len(old):
+        return new
+    if mode == "error":
+        raise ValueError(
+            f"length mismatch for {old!r}: the existing text is {len(old)} characters "
+            f"and the replacement is {len(new)}. Use a string of length {len(old)}, "
+            "or pass --fit pad or --fit clip."
+        )
+    if mode == "pad":
+        if len(new) > len(old):
+            raise ValueError(
+                f"replacement for {old!r} is {len(new)} characters and the existing text "
+                f"is {len(old)}. --fit pad only fills a shorter string."
+            )
+        return new + pad_char * (len(old) - len(new))
+    if mode == "clip":
+        clipped = new[: len(old)]
+        return clipped + pad_char * (len(old) - len(clipped))
+    raise ValueError(f"unknown fit mode: {mode}")
+
+
+def obfuscated_token(text: str, blocked: list[str], seed: str) -> str:
+    alphabet = "abcdefghijklmnopqrstuvwxyz"
+    blocked_lower = [item.lower() for item in blocked if item]
+    counter = 0
+    while counter < 1000:
+        material = hashlib.sha256(f"{seed}:{counter}:{text}".encode()).digest()
+        chars: list[str] = []
+        while len(chars) < len(text):
+            material = hashlib.sha256(material).digest()
+            chars.extend(alphabet[byte % 26] for byte in material)
+        token = "".join(chars[: len(text)])
+        haystack = token.lower()
+        if token != text and all(item not in haystack for item in blocked_lower):
+            return token
+        counter += 1
+    raise RuntimeError(f"could not build an obfuscated replacement for {text!r}")
+
+
+def _replace_span(data: bytes, old: bytes, new: bytes) -> tuple[bytes, int]:
+    if len(old) != len(new):
+        raise ValueError("internal replacement lengths differ")
+    count = data.count(old)
+    if count:
+        data = data.replace(old, new)
+    return data, count
+
+
+def apply_rules(
+    data: bytes, rules: list[Rule]
+) -> tuple[bytes, dict[str, tuple[int, int]]]:
+    counts = {rule.old: [0, 0] for rule in rules}
+    for rule in rules:
+        for form in rule.forms:
+            data, utf8_count = _replace_span(
+                data, form.encode("utf-8"), rule.new.encode("utf-8")
+            )
+            data, utf16_count = _replace_span(
+                data,
+                form.encode("utf-16le"),
+                rule.new.encode("utf-16le"),
+            )
+            counts[rule.old][0] += utf8_count
+            counts[rule.old][1] += utf16_count
+    return data, {key: (value[0], value[1]) for key, value in counts.items()}
+
+
+def separator_forms(text: str) -> tuple[str, ...]:
+    """Android class names use '/' in DEX and '.' everywhere else."""
+    return tuple(dict.fromkeys((text, text.replace(".", "/"), text.replace("/", "."))))
+
+
+def present_in(data: bytes, text: str) -> bool:
+    return text.encode("utf-8") in data or text.encode("utf-16le") in data
+
+
+def rule_present(data: bytes, rule: Rule) -> bool:
+    return any(present_in(data, form) for form in rule.forms)
+
+
+def fix_dex(data: bytes) -> bytes:
+    if not data.startswith(b"dex\n"):
+        return data
+    raw = bytearray(data)
+    raw[12:32] = hashlib.sha1(raw[32:]).digest()
+    raw[8:12] = struct.pack("<I", zlib.adler32(bytes(raw[12:])) & 0xFFFFFFFF)
+    return bytes(raw)
+
+
+def _skipped(name: str) -> bool:
+    lower = name.lower()
+    return any(lower.endswith(suffix) for suffix in SKIP_SUFFIXES)
+
+
+def build_rules(
+    contains: list[str] | None,
+    exact: list[tuple[str, str]] | None,
+    *,
+    seed: str,
+    fit: str,
+    pad_char: str,
+) -> list[Rule]:
+    contains = list(contains or [])
+    exact = list(exact or [])
+    if not contains and not exact:
+        raise ValueError(
+            "provide at least one --contains substring or --exact replacement"
+        )
+    for text in contains:
+        if not text:
+            raise ValueError("--contains does not accept an empty string")
+        _ascii(text, "--contains")
+    seen = set()
+    for text in contains:
+        if text in seen:
+            raise ValueError(f"repeated --contains value: {text!r}")
+        seen.add(text)
+
+    exact_rules: list[Rule] = []
+    used_exact: set[str] = set()
+    for old, new in exact:
+        if not old:
+            raise ValueError("--exact does not accept an empty search string")
+        _ascii(old, "exact search text")
+        _ascii(new, "exact replacement")
+        if old in used_exact:
+            raise ValueError(f"repeated --exact search string: {old!r}")
+        used_exact.add(old)
+        fitted = _fit(old, new, fit, pad_char)
+        for text in contains:
+            if text in fitted:
+                raise ValueError(
+                    f"exact replacement {fitted!r} still contains --contains value {text!r}. "
+                    "A later substring pass would change it."
+                )
+        exact_rules.append(Rule("exact", old, fitted, (old,)))
+
+    blocked = (
+        contains
+        + [rule.old for rule in exact_rules]
+        + [rule.new for rule in exact_rules]
+    )
+    contain_rules = [
+        Rule(
+            "contains",
+            text,
+            obfuscated_token(text, blocked, seed),
+            separator_forms(text),
+        )
+        for text in sorted(contains, key=len, reverse=True)
+    ]
+    exact_rules.sort(key=lambda rule: len(rule.old), reverse=True)
+    return exact_rules + contain_rules
+
+
+def rewrite_apk(
+    source: str | Path,
+    dest: str | Path,
+    contains: list[str] | None = None,
+    exact: list[tuple[str, str]] | None = None,
+    *,
+    seed: str = "softcloak",
+    fit: str = "error",
+    pad_char: str = " ",
+    allow_missing: bool = False,
+    dry_run: bool = False,
+    keystore: str | Path | None = None,
+    storepass: str | None = None,
+    keypass: str | None = None,
+    alias: str = "repack",
+) -> RewriteResult:
+    source_path = Path(source)
+    dest_path = Path(dest)
+    if not source_path.is_file():
+        raise ValueError(f"APK not found: {source_path}")
+    rules = build_rules(contains, exact, seed=seed, fit=fit, pad_char=pad_char)
+
+    with zipfile.ZipFile(source_path) as archive:
+        stored = [(info, archive.read(info.filename)) for info in archive.infolist()]
+
+    warnings: list[str] = []
+    missing: list[str] = []
+    searchable = []
+    for info, data in stored:
+        if is_signature_entry(info.filename) or _skipped(info.filename):
+            hits = [rule.old for rule in rules if rule_present(data, rule)]
+            if hits:
+                reason = (
+                    "signature file"
+                    if is_signature_entry(info.filename)
+                    else "skipped binary file"
+                )
+                warnings.append(
+                    f"{info.filename} ({reason}) still contains: {', '.join(hits)}. "
+                    "Those bytes were left unchanged."
+                )
+            continue
+        searchable.append((info, data))
+
+    for rule in rules:
+        if not any(rule_present(data, rule) for _, data in searchable):
+            missing.append(rule.old)
+    if missing and not allow_missing:
+        joined = ", ".join(repr(item) for item in missing)
+        raise ValueError(f"no occurrences found for: {joined}")
+
+    totals = {rule.old: [0, 0] for rule in rules}
+    rewritten: list[tuple[zipfile.ZipInfo, bytes]] = []
+    for info, data in searchable:
+        updated, counts = apply_rules(data, rules)
+        for key, (utf8_count, utf16_count) in counts.items():
+            totals[key][0] += utf8_count
+            totals[key][1] += utf16_count
+        if updated != data and info.filename.endswith(".dex"):
+            updated = fix_dex(updated)
+        rewritten.append((info, updated))
+
+    result_counts = {key: (value[0], value[1]) for key, value in totals.items()}
+    if dry_run:
+        return RewriteResult(None, rules, result_counts, warnings, dry_run=True)
+
+    same_target = source_path.resolve() == dest_path.resolve()
+    output = dest_path
+    if same_target:
+        output = dest_path.with_name(dest_path.name + ".tmp")
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        unsigned = Path(temp_dir) / "unsigned.apk"
+        build_zip(rewritten, unsigned)
+        sign_apk(
+            unsigned,
+            output,
+            keystore=Path(keystore) if keystore else None,
+            storepass=storepass,
+            keypass=keypass,
+            alias=alias,
+        )
+    if same_target:
+        os.replace(output, dest_path)
+        output = dest_path
+    return RewriteResult(output, rules, result_counts, warnings, dry_run=False)

softcloak-1.0.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: softcloak
+Version: 1.0.0
+Summary: Replace strings in an APK and re-sign it.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: ruff>=0.16; extra == "dev"
+
+# SoftCloak
+
+The goal of this repository is to try and make reverse engineering more difficult. Currently only
+focused on APK files but will eventually move on to IPA files, binaries, firmware, and other software.
+
+SoftCloak replaces text inside an APK, then signs the rebuilt package. Substring matches are swapped for one generated token of the same length. Exact matches are swapped for text you choose. The APK is signed with a new jar signature.
+
+Same-length replacements keep the DEX, manifest, and resource table aligned, so the file can still be installed.
+
+## Install
+
+A JDK is required. `keytool` and `jarsigner` must be on `PATH`.
+
+From the project directory:
+
+```bash
+pip install -e ".[dev]"
+```
+
+The `dev` extra installs Ruff. The test suite runs `ruff check` and `ruff format --check`.
+
+## Use
+
+Generate a token for every occurrence of a substring:
+
+```bash
+softcloak app.apk -o rebuilt.apk --contains com.example --contains CompanyName
+```
+
+Replace one exact string with your own text. The new text has to be the same length:
+
+```bash
+softcloak app.apk -o rebuilt.apk --exact "Old full sentence" "New full sentence"
+```
+
+Both can be combined. Exact replacements run first, then substring tokens. The command prints each mapping and checks the signature before it finishes.
+
+```bash
+softcloak app.apk -o rebuilt.apk --dry-run --contains CompanyName
+softcloak app.apk -o rebuilt.apk --exact "abcdef" "xy" --fit pad
+softcloak app.apk -o rebuilt.apk --contains CompanyName --keystore my.keystore --storepass secret --alias mykey
+```
+
+`--fit pad` fills a shorter exact replacement. `--fit clip` cuts a longer one and pads a shorter one. The default is to stop when the lengths differ.
+
+`--contains` replaces that text wherever it sits inside a longer string, in every file, in both UTF-8 and UTF-16. A dotted name also rewrites the DEX form with slashes, so `com.example` changes `Lcom/example/...` as well. Matching is case-sensitive. Pass `AppName` and `appname` separately. Patterns shorter than 4 characters are allowed, but they can hit unrelated bytes.
+
+Image, audio, font, and native-library entries are left unchanged. Signature files are removed and replaced by the new signature. Other `META-INF` files are kept and edited.
+
+## What can break the app
+
+SoftCloak changes only the text you pass in. A same-length rename of your own package or class name can still install and run, because the manifest and `classes.dex` are updated together.
+
+The app can crash or fail a lookup when a replacement has to match something that was not changed:
+
+- Framework names such as `android` or `java` appear inside system class names. Replacing them makes those calls invalid. A short warning exists for patterns under 4 characters, and it does not stop the run. `android` is long enough to pass through with no warning.
+- Resource paths, such as `res/layout/...`, must match the file names in the APK. SoftCloak does not rename those files.
+- Native libraries are left unchanged. If code now looks up a new name and the library still has the old one, that call fails.
+- Intent actions, content-provider authorities, and server URLs fail when only one side of the match is replaced.

softcloak-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+softcloak/__init__.py,sha256=OPDrXBzNeYQT2d1DKZOfrzY1sJURdkzmID-CZ6YNB04,175
+softcloak/__main__.py,sha256=JjqiIjpJ-SMRgTRv-rgDn41HL-f5HqsxV8rhIBSpVhw,88
+softcloak/cli.py,sha256=MkhtVxK9ybQsmVH2ypdYYWzua4TldIjgvfhlupCHxxk,4069
+softcloak/package.py,sha256=I9Wa_zBqYz6aJ7ixDLKFh1VRp9-dS8-bFcX9wGqYAhs,6045
+softcloak/rewrite.py,sha256=LWMR4RxU-mv_1BUCCjo_vVfx7FfDYumCK3jcHCsyGOY,9746
+softcloak-1.0.0.dist-info/METADATA,sha256=Qk3jSX3bDz5eJ5PqoTOv7inh_-g4xG0ddEGDsvIJg_w,3420
+softcloak-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+softcloak-1.0.0.dist-info/entry_points.txt,sha256=upeHV2zJs-qsx5HGPtvmy2FULOJg576nT66YYAunupw,49
+softcloak-1.0.0.dist-info/top_level.txt,sha256=-LcF8tK3UTGu9M-R-zUm7qgOPHfYyN0xuIC_vvhadys,10
+softcloak-1.0.0.dist-info/RECORD,,

softcloak-1.0.0.dist-info/WHEEL

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

softcloak-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+softcloak = softcloak.cli:main

softcloak-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+softcloak