rtty-soda 0.3.2__py3-none-any.whl

rtty_soda/archivers.py

@@ -0,0 +1,59 @@
+from collections.abc import Callable
+from compression import bz2, lzma, zlib, zstd
+
+__all__ = ["ARCHIVERS", "UNARCHIVERS", "Archiver"]
+
+
+type Archiver = Callable[[bytes], bytes]
+
+
+def compress_zstd(data: bytes) -> bytes:
+    return zstd.compress(data, level=20)
+
+
+def compress_zlib(data: bytes) -> bytes:
+    return zlib.compress(data, level=9)
+
+
+def compress_bz2(data: bytes) -> bytes:
+    return bz2.compress(data, compresslevel=9)
+
+
+def compress_lzma(data: bytes) -> bytes:
+    return lzma.compress(
+        data,
+        format=lzma.FORMAT_ALONE,
+        check=lzma.CHECK_NONE,
+        preset=lzma.PRESET_EXTREME,
+    )
+
+
+def decompress_zstd(data: bytes) -> bytes:
+    return zstd.decompress(data)
+
+
+def decompress_zlib(data: bytes) -> bytes:
+    return zlib.decompress(data)
+
+
+def decompress_bz2(data: bytes) -> bytes:
+    return bz2.decompress(data)
+
+
+def decompress_lzma(data: bytes) -> bytes:
+    return lzma.decompress(data, format=lzma.FORMAT_ALONE)
+
+
+ARCHIVERS: dict[str, Archiver] = {
+    "zstd": compress_zstd,
+    "zlib": compress_zlib,
+    "bz2": compress_bz2,
+    "lzma": compress_lzma,
+}
+
+UNARCHIVERS: dict[str, Archiver] = {
+    "zstd": decompress_zstd,
+    "zlib": decompress_zlib,
+    "bz2": decompress_bz2,
+    "lzma": decompress_lzma,
+}

rtty_soda/cli/__init__.py

@@ -0,0 +1,6 @@
+from .cli_options import CliOptions
+from .cli_reader import CliReader
+from .cli_writer import CliWriter
+from .main import cli
+
+__all__ = ["CliOptions", "CliReader", "CliWriter", "cli"]

rtty_soda/cli/cli_options.py

@@ -0,0 +1,115 @@
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import click
+
+if TYPE_CHECKING:
+    from click.decorators import FC
+
+__all__ = ["CliOptions", "out_path"]
+
+out_path = click.Path(
+    file_okay=True, dir_okay=False, writable=True, allow_dash=True, path_type=Path
+)
+
+
+class CliOptions:
+    @staticmethod
+    def compression(function: FC) -> FC:
+        return click.option(
+            "--compression",
+            "-c",
+            default="zstd",
+            show_default=True,
+            envvar="COMPRESSION",
+        )(function)
+
+    @staticmethod
+    def data_encoding(function: FC) -> FC:
+        return click.option(
+            "--data-encoding",
+            "-e",
+            default="base64",
+            show_default=True,
+            envvar="DATA_ENCODING",
+        )(function)
+
+    @staticmethod
+    def key_encoding(function: FC) -> FC:
+        return click.option(
+            "--key-encoding", default="base64", show_default=True, envvar="KEY_ENCODING"
+        )(function)
+
+    @staticmethod
+    def short_key_encoding(function: FC) -> FC:
+        return click.option(
+            "--encoding",
+            "-e",
+            default="base64",
+            show_default=True,
+            envvar="KEY_ENCODING",
+        )(function)
+
+    @staticmethod
+    def kdf_profile(function: FC) -> FC:
+        return click.option(
+            "--kdf-profile",
+            "-p",
+            default="sensitive",
+            show_default=True,
+            envvar="KDF_PROFILE",
+        )(function)
+
+    @staticmethod
+    def short_kdf_profile(function: FC) -> FC:
+        return click.option(
+            "--profile",
+            "-p",
+            default="sensitive",
+            show_default=True,
+            envvar="KDF_PROFILE",
+        )(function)
+
+    @staticmethod
+    def verbose(function: FC) -> FC:
+        return click.option(
+            "--verbose",
+            "-v",
+            is_flag=True,
+            envvar="VERBOSE",
+            help="Show verbose output.",
+        )(function)
+
+    @staticmethod
+    def text(function: FC) -> FC:
+        return click.option(
+            "--text",
+            "-t",
+            is_flag=True,
+            envvar="TEXT",
+            help="Treat message as text (binary if not specified).",
+        )(function)
+
+    @staticmethod
+    def group_len(function: FC) -> FC:
+        return click.option(
+            "--group-len", default=0, show_default=True, envvar="GROUP_LEN"
+        )(function)
+
+    @staticmethod
+    def line_len(function: FC) -> FC:
+        return click.option(
+            "--line-len", default=80, show_default=True, envvar="LINE_LEN"
+        )(function)
+
+    @staticmethod
+    def output_file(function: FC) -> FC:
+        return click.option(
+            "--output-file", "-o", type=out_path, help="Write output to file."
+        )(function)
+
+    @staticmethod
+    def padding(function: FC) -> FC:
+        return click.option(
+            "--padding", default=0, show_default=True, envvar="PADDING"
+        )(function)

rtty_soda/cli/cli_reader.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, BinaryIO, TextIO, cast
+
+from rtty_soda.interfaces import Reader
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+import click
+
+__all__ = ["CliReader"]
+
+
+class CliReader(Reader):
+    def __init__(self, source: Path) -> None:
+        self.source = source
+
+    def read_str(self) -> str:
+        with click.open_file(
+            self.source, mode="rt", encoding="utf-8", errors="strict"
+        ) as fd:
+            return cast("TextIO", fd).read()
+
+    def read_bytes(self) -> bytes:
+        with click.open_file(self.source, mode="rb") as fd:
+            return cast("BinaryIO", fd).read()

rtty_soda/cli/cli_writer.py

@@ -0,0 +1,41 @@
+import random
+import string
+from typing import TYPE_CHECKING
+
+from rtty_soda.interfaces import Writer
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+import click
+
+__all__ = ["CliWriter"]
+
+
+class CliWriter(Writer):
+    def __init__(self, target: Path | None) -> None:
+        self.target = target
+
+    @staticmethod
+    def write_bytes_atomic(target: Path, data: bytes) -> None:
+        temp_name = "".join(random.choices(string.ascii_lowercase, k=10))  # noqa: S311
+        temp_path = target.parent / temp_name
+        temp_path.write_bytes(data)
+        temp_path.replace(target)
+
+    def write_bytes(self, data: bytes) -> None:
+        if self.target is None or self.target.stem == "-":
+            add_nl = not data.endswith(b"\n")
+            click.echo(data, nl=add_nl)
+        else:
+            if self.target.exists():
+                click.confirm(
+                    f"Overwrite the output file? ({self.target})",
+                    default=False,
+                    abort=True,
+                )
+
+            self.write_bytes_atomic(self.target, data)
+
+    def write_diag(self, message: str) -> None:
+        click.echo(message, err=True)

rtty_soda/cli/main.py

@@ -0,0 +1,417 @@
+from pathlib import Path
+
+import click
+from click_aliases import ClickAliasedGroup
+
+from rtty_soda.cli import CliOptions, CliReader, CliWriter
+from rtty_soda.formatters import FixedFormatter
+from rtty_soda.services import EncodingService, EncryptionService, KeyService
+
+__all__ = ["cli", "in_path"]
+
+in_path = click.Path(
+    exists=True,
+    file_okay=True,
+    dir_okay=False,
+    readable=True,
+    allow_dash=True,
+    path_type=Path,
+)
+
+CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+
+@click.group(cls=ClickAliasedGroup, context_settings=CONTEXT_SETTINGS)
+@click.version_option(package_name="rtty-soda")
+def cli() -> None:
+    pass
+
+
+@cli.command()  # pyright: ignore[reportAny]
+@CliOptions.short_key_encoding
+@CliOptions.output_file
+@CliOptions.group_len
+@CliOptions.line_len
+@CliOptions.padding
+@CliOptions.verbose
+def genkey_cmd(
+    encoding: str,
+    output_file: Path | None,
+    group_len: int,
+    line_len: int,
+    padding: int,
+    verbose: bool,
+) -> None:
+    """Generate Private Key.
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+    """
+    formatter = FixedFormatter(group_len, line_len, padding)
+    writer = CliWriter(output_file)
+    service = KeyService(encoding, formatter, writer, verbose)
+    service.genkey()
+
+
+@cli.command()  # pyright: ignore[reportAny]
+@click.argument("private_key_file", type=in_path)
+@CliOptions.short_key_encoding
+@CliOptions.output_file
+@CliOptions.group_len
+@CliOptions.line_len
+@CliOptions.padding
+@CliOptions.verbose
+def pubkey_cmd(
+    private_key_file: Path,
+    encoding: str,
+    output_file: Path | None,
+    group_len: int,
+    line_len: int,
+    padding: int,
+    verbose: bool,
+) -> None:
+    """Get Public Key.
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+    """
+    formatter = FixedFormatter(group_len, line_len, padding)
+    writer = CliWriter(output_file)
+    service = KeyService(encoding, formatter, writer, verbose)
+    priv = CliReader(private_key_file)
+    service.pubkey(priv)
+
+
+@cli.command()  # pyright: ignore[reportAny]
+@click.argument("password_file", type=in_path)
+@CliOptions.short_key_encoding
+@CliOptions.short_kdf_profile
+@CliOptions.output_file
+@CliOptions.group_len
+@CliOptions.line_len
+@CliOptions.padding
+@CliOptions.verbose
+def kdf_cmd(
+    password_file: Path,
+    encoding: str,
+    profile: str,
+    output_file: Path | None,
+    group_len: int,
+    line_len: int,
+    padding: int,
+    verbose: bool,
+) -> None:
+    """Key Derivation Function.
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+
+    Profile: interactive | moderate | sensitive
+    """
+    formatter = FixedFormatter(group_len, line_len, padding)
+    writer = CliWriter(output_file)
+    service = KeyService(encoding, formatter, writer, verbose)
+    password = CliReader(password_file)
+    service.kdf(password=password, kdf_profile=profile)
+
+
+@cli.command(aliases=["e"])  # pyright: ignore[reportAny]
+@click.argument("private_key_file", type=in_path)
+@click.argument("public_key_file", type=in_path)
+@click.argument("message_file", type=in_path)
+@CliOptions.text
+@CliOptions.key_encoding
+@CliOptions.data_encoding
+@CliOptions.compression
+@CliOptions.output_file
+@CliOptions.group_len
+@CliOptions.line_len
+@CliOptions.padding
+@CliOptions.verbose
+def encrypt_public_cmd(
+    private_key_file: Path,
+    public_key_file: Path,
+    message_file: Path,
+    text: bool,
+    key_encoding: str,
+    data_encoding: str,
+    compression: str,
+    output_file: Path | None,
+    group_len: int,
+    line_len: int,
+    padding: int,
+    verbose: bool,
+) -> None:
+    """Encrypt Message (Public).
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+
+    Compression: zstd | zlib | bz2 | lzma | raw
+    """
+    formatter = FixedFormatter(group_len, line_len, padding)
+    writer = CliWriter(output_file)
+    service = EncryptionService(
+        text_mode=text,
+        key_encoding=key_encoding,
+        data_encoding=data_encoding,
+        compression=compression,
+        formatter=formatter,
+        writer=writer,
+        verbose=verbose,
+    )
+    priv = CliReader(private_key_file)
+    pub = CliReader(public_key_file)
+    message = CliReader(message_file)
+    service.encrypt_public(private_key=priv, public_key=pub, message=message)
+
+
+@cli.command(aliases=["es"])  # pyright: ignore[reportAny]
+@click.argument("key_file", type=in_path)
+@click.argument("message_file", type=in_path)
+@CliOptions.text
+@CliOptions.key_encoding
+@CliOptions.data_encoding
+@CliOptions.compression
+@CliOptions.output_file
+@CliOptions.group_len
+@CliOptions.line_len
+@CliOptions.padding
+@CliOptions.verbose
+def encrypt_secret_cmd(
+    key_file: Path,
+    message_file: Path,
+    text: bool,
+    key_encoding: str,
+    data_encoding: str,
+    compression: str,
+    output_file: Path | None,
+    group_len: int,
+    line_len: int,
+    padding: int,
+    verbose: bool,
+) -> None:
+    """Encrypt Message (Secret).
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+
+    Compression: zstd | zlib | bz2 | lzma | raw
+    """
+    formatter = FixedFormatter(group_len, line_len, padding)
+    writer = CliWriter(output_file)
+    service = EncryptionService(
+        text_mode=text,
+        key_encoding=key_encoding,
+        data_encoding=data_encoding,
+        compression=compression,
+        formatter=formatter,
+        writer=writer,
+        verbose=verbose,
+    )
+    key = CliReader(key_file)
+    message = CliReader(message_file)
+    service.encrypt_secret(key, message)
+
+
+@cli.command(aliases=["ep"])  # pyright: ignore[reportAny]
+@click.argument("password_file", type=in_path)
+@click.argument("message_file", type=in_path)
+@CliOptions.text
+@CliOptions.kdf_profile
+@CliOptions.data_encoding
+@CliOptions.compression
+@CliOptions.output_file
+@CliOptions.group_len
+@CliOptions.line_len
+@CliOptions.padding
+@CliOptions.verbose
+def encrypt_password_cmd(
+    password_file: Path,
+    message_file: Path,
+    text: bool,
+    kdf_profile: str,
+    data_encoding: str,
+    compression: str,
+    output_file: Path | None,
+    group_len: int,
+    line_len: int,
+    padding: int,
+    verbose: bool,
+) -> None:
+    """Encrypt Message (Password).
+
+    KDF profile: interactive | moderate | sensitive
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+
+    Compression: zstd | zlib | bz2 | lzma | raw
+    """
+    formatter = FixedFormatter(group_len, line_len, padding)
+    writer = CliWriter(output_file)
+    service = EncryptionService(
+        text_mode=text,
+        key_encoding="binary",
+        data_encoding=data_encoding,
+        compression=compression,
+        formatter=formatter,
+        writer=writer,
+        verbose=verbose,
+    )
+    pw = CliReader(password_file)
+    message = CliReader(message_file)
+    service.encrypt_password(password=pw, message=message, kdf_profile=kdf_profile)
+
+
+@cli.command(aliases=["d"])  # pyright: ignore[reportAny]
+@click.argument("private_key_file", type=in_path)
+@click.argument("public_key_file", type=in_path)
+@click.argument("message_file", type=in_path)
+@CliOptions.text
+@CliOptions.key_encoding
+@CliOptions.data_encoding
+@CliOptions.compression
+@CliOptions.output_file
+def decrypt_public_cmd(
+    private_key_file: Path,
+    public_key_file: Path,
+    message_file: Path,
+    text: bool,
+    key_encoding: str,
+    data_encoding: str,
+    compression: str,
+    output_file: Path | None,
+) -> None:
+    """Decrypt Message (Public).
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+
+    Compression: zstd | zlib | bz2 | lzma | raw
+    """
+    writer = CliWriter(output_file)
+    service = EncryptionService(
+        text_mode=text,
+        key_encoding=key_encoding,
+        data_encoding=data_encoding,
+        compression=compression,
+        formatter=None,
+        writer=writer,
+        verbose=False,
+    )
+    priv = CliReader(private_key_file)
+    pub = CliReader(public_key_file)
+    message = CliReader(message_file)
+    service.decrypt_public(private_key=priv, public_key=pub, message=message)
+
+
+@cli.command(aliases=["ds"])  # pyright: ignore[reportAny]
+@click.argument("key_file", type=in_path)
+@click.argument("message_file", type=in_path)
+@CliOptions.text
+@CliOptions.key_encoding
+@CliOptions.data_encoding
+@CliOptions.compression
+@CliOptions.output_file
+def decrypt_secret_cmd(
+    key_file: Path,
+    message_file: Path,
+    text: bool,
+    key_encoding: str,
+    data_encoding: str,
+    compression: str,
+    output_file: Path | None,
+) -> None:
+    """Decrypt Message (Secret).
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+
+    Compression: zstd | zlib | bz2 | lzma | raw
+    """
+    writer = CliWriter(output_file)
+    service = EncryptionService(
+        text_mode=text,
+        key_encoding=key_encoding,
+        data_encoding=data_encoding,
+        compression=compression,
+        formatter=None,
+        writer=writer,
+        verbose=False,
+    )
+    key = CliReader(key_file)
+    message = CliReader(message_file)
+    service.decrypt_secret(key, message)
+
+
+@cli.command(aliases=["dp"])  # pyright: ignore[reportAny]
+@click.argument("password_file", type=in_path)
+@click.argument("message_file", type=in_path)
+@CliOptions.text
+@CliOptions.kdf_profile
+@CliOptions.data_encoding
+@CliOptions.compression
+@CliOptions.output_file
+def decrypt_password_cmd(
+    password_file: Path,
+    message_file: Path,
+    text: bool,
+    kdf_profile: str,
+    data_encoding: str,
+    compression: str,
+    output_file: Path | None,
+) -> None:
+    """Decrypt Message (Password).
+
+    KDF profile: interactive | moderate | sensitive
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+
+    Compression: zstd | zlib | bz2 | lzma | raw
+    """
+    writer = CliWriter(output_file)
+    service = EncryptionService(
+        text_mode=text,
+        key_encoding="binary",
+        data_encoding=data_encoding,
+        compression=compression,
+        formatter=None,
+        writer=writer,
+        verbose=False,
+    )
+    pw = CliReader(password_file)
+    message = CliReader(message_file)
+    service.decrypt_password(password=pw, message=message, kdf_profile=kdf_profile)
+
+
+@cli.command()  # pyright: ignore[reportAny]
+@click.argument("in_encoding")
+@click.argument("out_encoding")
+@click.argument("file", type=in_path)
+@CliOptions.output_file
+@CliOptions.group_len
+@CliOptions.line_len
+@CliOptions.padding
+@CliOptions.verbose
+def encode_cmd(
+    in_encoding: str,
+    out_encoding: str,
+    file: Path,
+    output_file: Path | None,
+    group_len: int,
+    line_len: int,
+    padding: int,
+    verbose: bool,
+) -> None:
+    """Encode File.
+
+    Encoding: base26 | base31 | base36 | base64 | base94 | binary
+    """
+    writer = CliWriter(output_file)
+    formatter = FixedFormatter(group_len, line_len, padding)
+    service = EncodingService(
+        in_encoding=in_encoding,
+        out_encoding=out_encoding,
+        formatter=formatter,
+        writer=writer,
+        verbose=verbose,
+    )
+    data = CliReader(file)
+    service.encode(data)
+
+
+if __name__ == "__main__":
+    cli()