Files
ChaosCrypt/chaoscrypt/tui.py
T
dvs 2529edac1d v2.1.6: Restructure as a distributable library
Restructure ChaosCrypt from a single-file script into a complete,
installable Python package with three interfaces: a typed Python API, an
argument-driven CLI, and a bilingual interactive TUI.

The algorithm itself is unchanged. Ciphertexts and key files remain fully
interoperable with the original implementation in both directions, which is
enforced by dedicated tests rather than merely documented.

Added
- Library API: ChaosCrypt facade plus ChaosCryptCore for the raw algorithm
- Unified error hierarchy: 16 named types, all ChaosCryptError subclasses,
  rendering as ChaosCrypt_ERR_<Detail>_<Code>
- CLI: keygen, encrypt, decrypt, file, info, chpwd, tui, with --json output,
  stdin/stdout piping, and three password sources per secret
- Bilingual TUI: English default, runtime switch to Chinese, getpass password
  entry with a non-TTY fallback that keeps it scriptable
- Binary and file support: encrypt_bytes/decrypt_bytes and
  encrypt_file/decrypt_file
- Key management: change_key_password rewraps without altering key material;
  export_key_text/load_from_text move a key without touching disk
- Documentation: SECURITY.md with the full design and threat analysis, plus
  docs/ covering the API, CLI, architecture and build process
- Test suite: 92 tests across round-trips, binary safety, key management,
  error types, CLI, TUI, i18n and legacy interoperability
- Packaging: pyproject.toml, setup.py compatibility shim, MANIFEST.in,
  py.typed, examples, MIT licence

Fixed
- Conflicting --pwd option between the -p and -P groups prevented the CLI
  from starting at all
- Wrong key file password reported as file corruption (E002); structural
  validation now distinguishes it from a damaged file (E003)
- export_key_text produced key material without loading it into the instance
- Non-hexadecimal input was accepted as ciphertext and silently decrypted
  into garbage, making corruption indistinguishable from success; malformed
  input now raises E010 before any processing
- TUI failed under piped input because getpass requires a TTY
- TUI kept reading the default key file name after generating a new one

Changed
- Source tree reorganised: the package lives at chaoscrypt/, with tests,
  examples and legacy alongside it; documentation and build artefacts at the
  repository root
- Code comments unified in English; public docstrings document parameters,
  return values and raised exceptions
- English is now the default UI language
- ChaosCryptChat removed from the repository
- Attribution updated to Dvs (DvsXT); project URLs point to Gitea
2026-09-27 17:03:05 +08:00

474 lines
16 KiB
Python

"""
ChaosCrypt interactive terminal UI.
A dependency-free menu-driven interface, intended for people who would
rather not memorise command line flags. English is the default language;
the menu can switch to Chinese at runtime.
Running ``chaoscrypt`` with no arguments launches this UI. The module is
imported lazily so that library users never pay for it.
"""
from __future__ import annotations
import os
import sys
from typing import Optional
from . import DEFAULT_KEY_FILE, __version__, ChaosCrypt
from .errors import ChaosCryptError
from .i18n import DEFAULT_LANG, LANG_NAMES, t
__all__ = ["run_tui", "TUI"]
WIDTH = 66
# ANSI styling; degrades to plain text when the terminal cannot handle it.
_C = {
"reset": "\033[0m",
"bold": "\033[1m",
"dim": "\033[2m",
"cyan": "\033[36m",
"green": "\033[32m",
"yellow": "\033[33m",
"red": "\033[31m",
"magenta": "\033[35m",
}
def _supports_color() -> bool:
"""Whether the attached stdout can render ANSI colour."""
if os.environ.get("NO_COLOR"):
return False
if not sys.stdout.isatty():
return False
if os.name == "nt":
try:
import ctypes
kernel32 = ctypes.windll.kernel32
kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
return True
except Exception:
return False
return True
_COLOR = _supports_color()
def c(text: str, *styles: str) -> str:
"""Wrap ``text`` in ANSI styles, or return it unchanged."""
if not _COLOR or not styles:
return text
return "".join(_C.get(s, "") for s in styles) + text + _C["reset"]
# ---------------------------------------------------------------------------
# Input helpers
# ---------------------------------------------------------------------------
class _Abort(Exception):
"""Raised when the user asks to return to the main menu."""
def _ask(prompt: str, default: Optional[str] = None) -> str:
suffix = f" [{default}]" if default else ""
try:
val = input(f"{c('>', 'cyan')} {prompt}{suffix}: ").strip()
except (EOFError, KeyboardInterrupt):
print()
raise _Abort()
if not val and default is not None:
return default
return val
def _ask_secret(prompt: str) -> str:
"""Read a password without echoing it when possible.
Interactive terminals use ``getpass`` so the input is not shown. Piped or
redirected input cannot use ``getpass``, so it falls back to ``input``,
which keeps the UI scriptable.
"""
label = f"{c('>', 'cyan')} {prompt}: "
if sys.stdin is not None and sys.stdin.isatty():
try:
import getpass
return getpass.getpass(label)
except (EOFError, KeyboardInterrupt):
print()
raise _Abort()
except Exception:
pass # Fall through to the non-echoing fallback below.
try:
return input(label).strip()
except (EOFError, KeyboardInterrupt):
print()
raise _Abort()
def _ask_yes_no(prompt: str, lang: str) -> bool:
try:
val = input(f"{c('>', 'cyan')} {prompt} [y/n]: ").strip().lower()
except (EOFError, KeyboardInterrupt):
print()
raise _Abort()
return val in ("y", "yes")
def _pause(lang: str) -> None:
try:
input(c(f" {t('press_enter', lang)}", "dim"))
except (EOFError, KeyboardInterrupt):
print()
def _rule() -> str:
return "-" * WIDTH
# ---------------------------------------------------------------------------
# TUI
# ---------------------------------------------------------------------------
class TUI:
"""Menu-driven bilingual interface over :class:`~chaoscrypt.ChaosCrypt`."""
def __init__(self, lang: str = DEFAULT_LANG,
key_file: str = DEFAULT_KEY_FILE) -> None:
self.lang = lang if lang in LANG_NAMES else DEFAULT_LANG
self.key_file = key_file
self.cc = ChaosCrypt()
self.key_password: Optional[str] = None
# ------------------------------------------------------------------ view
def _tr(self, key: str) -> str:
return t(key, self.lang)
def banner(self) -> None:
print()
print(c("+" + "=" * (WIDTH - 2) + "+", "magenta"))
title = f" {self._tr('app_title')} v{__version__}"
print(c("|", "magenta")
+ c(title.ljust(WIDTH - 2), "bold", "cyan")
+ c("|", "magenta"))
print(c("+" + "=" * (WIDTH - 2) + "+", "magenta"))
for line in self._tr("warn_banner").split("\n"):
print(c(line, "yellow"))
shown = self.cc.key_file or self.key_file or DEFAULT_KEY_FILE
state = (
c("[*] " + self._tr("key_loaded"), "green")
if self.cc.loaded
else c("[ ] " + self._tr("no_key_loaded"), "red")
)
print(f"\n{state} {c(shown, 'dim')}")
def _print_error(self, exc: Exception) -> None:
"""Render a unified error, with a hint where one applies."""
print()
print(c("+" + "-" * (WIDTH - 2) + "+", "red"))
print(c("| ", "red")
+ c(f"{self._tr('err_prefix')}: {exc}", "red", "bold"))
print(c("+" + "-" * (WIDTH - 2) + "+", "red"))
msg = str(exc)
if "_E011" in msg or "_E003" in msg:
print(c(" " + self._tr("err_hint_password"), "dim"))
elif "_E004" in msg or "_E001" in msg:
print(c(" " + self._tr("err_hint_key_required"), "dim"))
# ------------------------------------------------------------------ menu
def menu(self) -> str:
items = [
("1", "menu_encrypt"),
("2", "menu_decrypt"),
("3", "menu_encrypt_file"),
("4", "menu_decrypt_file"),
("5", "menu_keygen"),
("6", "menu_loadkey"),
("7", "menu_keyinfo"),
("8", "menu_chpwd"),
("9", "menu_lang"),
("a", "menu_about"),
("q", "menu_quit"),
]
print()
print(c(_rule(), "dim"))
print(c(" " + self._tr("menu_choose"), "bold"))
print(c(_rule(), "dim"))
for key, label in items:
print(f" {c('[' + key + ']', 'cyan')} {self._tr(label)}")
print(c(_rule(), "dim"))
return _ask(self._tr("menu_prompt")).lower()
# ------------------------------------------------------------ key state
def _ensure_key(self) -> bool:
"""Make sure a key is loaded, offering to create one if none exists.
Searches the instance's loaded key, then the remembered file, then
the default name.
"""
if self.cc.loaded:
return True
path = (
self.cc.key_file
or self.key_file
or DEFAULT_KEY_FILE
)
self.key_file = path
if not os.path.exists(path):
if _ask_yes_no(self._tr("prompt_create_if_missing"), self.lang):
return self.action_keygen()
return False
try:
pwd = self.key_password or _ask_secret(self._tr("prompt_key_password"))
self.cc.load(path, pwd)
self.key_password = pwd
print(c(f"{self._tr('key_loaded')}: {path}", "green"))
return True
except ChaosCryptError as exc:
self._print_error(exc)
return False
# ---------------------------------------------------------------- actions
def action_encrypt(self) -> None:
if not self._ensure_key():
return
text = _ask(self._tr("prompt_plaintext"))
if not text:
print(c(" " + self._tr("cancelled"), "dim"))
return
pwd = _ask_secret(self._tr("prompt_user_password"))
try:
ct = self.cc.encrypt(text, pwd)
print()
print(c(f"{self._tr('result_ciphertext')}:", "green", "bold"))
print(c(ct, "cyan"))
except ChaosCryptError as exc:
self._print_error(exc)
def action_decrypt(self) -> None:
if not self._ensure_key():
return
text = _ask(self._tr("prompt_ciphertext"))
if not text:
print(c(" " + self._tr("cancelled"), "dim"))
return
pwd = _ask_secret(self._tr("prompt_user_password"))
try:
pt = self.cc.decrypt(text, pwd)
print()
print(c(f"{self._tr('result_plaintext')}:", "green", "bold"))
print(c(pt, "cyan"))
except ChaosCryptError as exc:
self._print_error(exc)
def action_encrypt_file(self) -> None:
if not self._ensure_key():
return
src = _ask(self._tr("prompt_src_file"))
if not src or not os.path.exists(src):
print(c(f" {self._tr('failed')}: {src}", "red"))
return
dst = _ask(self._tr("prompt_dst_file")) or None
pwd = _ask_secret(self._tr("prompt_user_password"))
try:
out = self.cc.encrypt_file(src, pwd, dst)
print(c(f"{self._tr('file_written')}: {out}", "green"))
except ChaosCryptError as exc:
self._print_error(exc)
def action_decrypt_file(self) -> None:
if not self._ensure_key():
return
src = _ask(self._tr("prompt_src_file"))
if not src or not os.path.exists(src):
print(c(f" {self._tr('failed')}: {src}", "red"))
return
dst = _ask(self._tr("prompt_dst_file")) or None
pwd = _ask_secret(self._tr("prompt_user_password"))
try:
out = self.cc.decrypt_file(src, pwd, dst)
print(c(f"{self._tr('file_written')}: {out}", "green"))
except ChaosCryptError as exc:
self._print_error(exc)
def action_keygen(self) -> bool:
default = self.cc.key_file or self.key_file or DEFAULT_KEY_FILE
path = _ask(self._tr("prompt_key_file"), default)
overwrite = False
if os.path.exists(path):
if not _ask_yes_no(self._tr("prompt_overwrite"), self.lang):
print(c(" " + self._tr("cancelled"), "dim"))
return False
overwrite = True
pwd = _ask_secret(self._tr("prompt_key_password_new"))
if not pwd:
print(c(" " + self._tr("failed"), "red"))
return False
confirm = _ask_secret(self._tr("prompt_key_password_confirm"))
if pwd != confirm:
print(c(" ChaosCrypt_ERR_PasswordMismatch_E007", "red"))
return False
try:
out = self.cc.create_key(pwd, path, overwrite=overwrite)
self.key_file = out
self.key_password = pwd
print(c(f"{self._tr('key_saved')}: {out}", "green"))
return True
except ChaosCryptError as exc:
self._print_error(exc)
return False
def action_loadkey(self) -> None:
default = self.cc.key_file or self.key_file or DEFAULT_KEY_FILE
path = _ask(self._tr("prompt_key_file"), default)
pwd = _ask_secret(self._tr("prompt_key_password"))
try:
self.cc.load(path, pwd)
self.key_file = path
self.key_password = pwd
print(c(f"{self._tr('key_loaded')}: {path}", "green"))
except ChaosCryptError as exc:
self._print_error(exc)
def action_keyinfo(self) -> None:
if not self._ensure_key():
return
try:
info = self.cc.info()
except ChaosCryptError as exc:
self._print_error(exc)
return
rows = [
("info_key_file", info["key_file"]),
("info_version", info["version"]),
("info_upper", info["upper_mapping"]),
("info_lower", info["lower_mapping"]),
("info_digit", "".join(info["digit_mapping"].values())),
("info_equal", "".join(info["equal_mapping"].values())),
("info_flip", info["flip_pattern"]),
("info_long_key",
f"{info['long_key_length']} {self._tr('characters')}"),
("info_short_key",
f"{info['short_key_length']} {self._tr('characters')}"),
("info_loaded", self._tr("yes")),
]
print()
print(c(_rule(), "dim"))
for key, val in rows:
print(f" {c(self._tr(key), 'bold'):<38} {val}")
print(c(_rule(), "dim"))
def action_chpwd(self) -> None:
default = self.cc.key_file or self.key_file or DEFAULT_KEY_FILE
path = _ask(self._tr("prompt_key_file"), default)
if not os.path.exists(path):
print(c(" ChaosCrypt_ERR_KeyFileNotFound_E001", "red"))
return
old = _ask_secret(self._tr("prompt_key_password_old"))
new = _ask_secret(self._tr("prompt_key_password_new"))
confirm = _ask_secret(self._tr("prompt_key_password_confirm"))
if new != confirm:
print(c(" ChaosCrypt_ERR_PasswordMismatch_E007", "red"))
return
try:
out = self.cc.change_key_password(old, new, path)
self.key_password = new
print(c(f"{self._tr('key_password_changed')}: {out}", "green"))
except ChaosCryptError as exc:
self._print_error(exc)
def action_lang(self) -> None:
codes = list(LANG_NAMES.keys())
print()
for i, (code, name) in enumerate(LANG_NAMES.items(), 1):
mark = "*" if code == self.lang else " "
print(f" {c('[' + str(i) + ']', 'cyan')} {mark} {name} ({code})")
default_index = str(codes.index(self.lang) + 1) if self.lang in codes else "1"
choice = _ask("Language", default_index)
try:
idx = int(choice) - 1
if 0 <= idx < len(codes):
self.lang = codes[idx]
except ValueError:
if choice in codes:
self.lang = choice
print(c(f" -> {LANG_NAMES[self.lang]}", "green"))
def action_about(self) -> None:
print()
print(c(self._tr("about_body"), "cyan"))
# ------------------------------------------------------------- main loop
def run(self) -> int:
while True:
self.banner()
try:
choice = self.menu()
except _Abort:
print()
print(c(self._tr("bye"), "green"))
return 0
try:
if choice == "1":
self.action_encrypt()
elif choice == "2":
self.action_decrypt()
elif choice == "3":
self.action_encrypt_file()
elif choice == "4":
self.action_decrypt_file()
elif choice == "5":
self.action_keygen()
elif choice == "6":
self.action_loadkey()
elif choice == "7":
self.action_keyinfo()
elif choice == "8":
self.action_chpwd()
elif choice == "9":
self.action_lang()
elif choice in ("a", "about"):
self.action_about()
elif choice in ("q", "quit", "exit"):
print()
print(c(self._tr("bye"), "green"))
return 0
else:
print(c(" " + self._tr("menu_invalid"), "yellow"))
continue
except _Abort:
print(c(" " + self._tr("cancelled"), "dim"))
continue
except KeyboardInterrupt:
print()
print(c(self._tr("bye"), "green"))
return 0
_pause(self.lang)
def run_tui(lang: str = DEFAULT_LANG,
key_file: str = DEFAULT_KEY_FILE) -> int:
"""Launch the interactive UI and return the process exit code."""
try:
return TUI(lang=lang, key_file=key_file).run()
except KeyboardInterrupt:
print()
return 0
if __name__ == "__main__": # pragma: no cover
sys.exit(run_tui())