rtty-soda 0.3.2__py3-none-any.whl

rtty_soda/cli/main.pyi

@@ -0,0 +1,111 @@
+from pathlib import Path
+
+from click import Command
+
+cli: Command
+
+def genkey_cmd(
+    encoding: str,
+    output_file: Path | None,
+    group_len: int,
+    line_len: int,
+    padding: int,
+    verbose: bool,
+) -> None: ...
+def pubkey_cmd(
+    private_key_file: Path,
+    encoding: str,
+    output_file: Path | None,
+    group_len: int,
+    line_len: int,
+    padding: int,
+    verbose: bool,
+) -> None: ...
+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: ...
+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: ...
+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: ...
+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: ...
+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: ...
+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: ...
+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: ...
+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: ...

rtty_soda/cryptography/kdf.py

@@ -0,0 +1,49 @@
+from nacl.encoding import RawEncoder
+from nacl.hash import blake2b
+from nacl.public import PrivateKey
+from nacl.pwhash import argon2id
+from nacl.pwhash.argon2id import (
+    MEMLIMIT_INTERACTIVE,
+    MEMLIMIT_MODERATE,
+    MEMLIMIT_SENSITIVE,
+    OPSLIMIT_INTERACTIVE,
+    OPSLIMIT_MODERATE,
+    OPSLIMIT_SENSITIVE,
+    SALTBYTES,
+)
+
+__all__ = ["KDF_PROFILES", "KdfProfile", "hash_salt", "kdf"]
+
+type KdfProfile = tuple[int, int]
+
+KDF_PROFILES: dict[str, KdfProfile] = {
+    "interactive": (OPSLIMIT_INTERACTIVE, MEMLIMIT_INTERACTIVE),
+    "moderate": (OPSLIMIT_MODERATE, MEMLIMIT_MODERATE),
+    "sensitive": (OPSLIMIT_SENSITIVE, MEMLIMIT_SENSITIVE),
+}
+
+SALT_MOD = b"""And here I solemnly protest I have no intention to vilify or asperse any
+one; for though everything is copied from the book of nature, and scarce a character or
+action produced which I have not taken from my own observations or experience; yet I
+have used the utmost care to obscure the persons by such different circumstances,
+degrees, and colors, that it will be impossible to guess at them with any degree of
+certainty;
+(c) Henry Fielding
+"""
+
+
+def hash_salt(salt: bytes) -> bytes:
+    return blake2b(data=salt, digest_size=SALTBYTES, encoder=RawEncoder)
+
+
+def kdf(password: bytes, profile: KdfProfile) -> bytes:
+    salt = hash_salt(password + SALT_MOD)
+    ops, mem = profile
+    return argon2id.kdf(
+        size=PrivateKey.SIZE,
+        password=password,
+        salt=salt,
+        opslimit=ops,
+        memlimit=mem,
+        encoder=RawEncoder,
+    )

rtty_soda/cryptography/public.py

@@ -0,0 +1,20 @@
+from typing import TYPE_CHECKING
+
+from nacl.encoding import RawEncoder
+from nacl.public import Box, PrivateKey, PublicKey
+
+if TYPE_CHECKING:
+    from nacl.utils import EncryptedMessage
+
+
+__all__ = ["decrypt", "encrypt"]
+
+
+def encrypt(private: PrivateKey, public: PublicKey, data: bytes) -> EncryptedMessage:
+    box = Box(private_key=private, public_key=public)
+    return box.encrypt(plaintext=data, encoder=RawEncoder)
+
+
+def decrypt(private: PrivateKey, public: PublicKey, data: bytes) -> bytes:
+    box = Box(private_key=private, public_key=public)
+    return box.decrypt(ciphertext=data, encoder=RawEncoder)

rtty_soda/cryptography/secret.py

@@ -0,0 +1,20 @@
+from typing import TYPE_CHECKING
+
+from nacl.encoding import RawEncoder
+from nacl.secret import SecretBox
+
+if TYPE_CHECKING:
+    from nacl.utils import EncryptedMessage
+
+
+__all__ = ["decrypt", "encrypt"]
+
+
+def encrypt(key: bytes, data: bytes) -> EncryptedMessage:
+    box = SecretBox(key=key, encoder=RawEncoder)
+    return box.encrypt(plaintext=data, encoder=RawEncoder)
+
+
+def decrypt(key: bytes, data: bytes) -> bytes:
+    box = SecretBox(key=key, encoder=RawEncoder)
+    return box.decrypt(ciphertext=data, encoder=RawEncoder)

rtty_soda/encoders/__init__.py

@@ -0,0 +1,30 @@
+from .base26_encoder import Base26Encoder
+from .base31_encoder import Base31Encoder
+from .base36_encoder import Base36Encoder
+from .base64_encoder import Base64Encoder
+from .base94_encoder import Base94Encoder
+from .encoder import Encoder
+from .functions import decode_bytes, encode_str
+from .scsu import scsu_decode, scsu_encode
+
+__all__ = [
+    "ENCODERS",
+    "Base26Encoder",
+    "Base31Encoder",
+    "Base36Encoder",
+    "Base64Encoder",
+    "Base94Encoder",
+    "Encoder",
+    "decode_bytes",
+    "encode_str",
+    "scsu_decode",
+    "scsu_encode",
+]
+
+ENCODERS: dict[str, Encoder] = {
+    "base26": Base26Encoder(),
+    "base31": Base31Encoder(),
+    "base36": Base36Encoder(),
+    "base64": Base64Encoder(),
+    "base94": Base94Encoder(),
+}

rtty_soda/encoders/base26_encoder.py

@@ -0,0 +1,18 @@
+import string
+
+from .encoder import Encoder
+from .functions import base_to_bytes, bytes_to_base
+
+__all__ = ["ALPHABET", "Base26Encoder"]
+
+ALPHABET = string.ascii_uppercase
+
+
+class Base26Encoder(Encoder):
+    @staticmethod
+    def encode(data: bytes) -> str:
+        return bytes_to_base(data, ALPHABET)
+
+    @staticmethod
+    def decode(data: str) -> bytes:
+        return base_to_bytes(data, ALPHABET)

rtty_soda/encoders/base31_encoder.py

@@ -0,0 +1,16 @@
+from .encoder import Encoder
+from .functions import base_to_bytes, bytes_to_base
+
+__all__ = ["ALPHABET", "Base31Encoder"]
+
+ALPHABET = "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЫЭЮЯ"
+
+
+class Base31Encoder(Encoder):
+    @staticmethod
+    def encode(data: bytes) -> str:
+        return bytes_to_base(data, ALPHABET)
+
+    @staticmethod
+    def decode(data: str) -> bytes:
+        return base_to_bytes(data, ALPHABET)

rtty_soda/encoders/base36_encoder.py

@@ -0,0 +1,18 @@
+import string
+
+from .encoder import Encoder
+from .functions import base_to_bytes, bytes_to_base
+
+__all__ = ["ALPHABET", "Base36Encoder"]
+
+ALPHABET = string.digits + string.ascii_uppercase
+
+
+class Base36Encoder(Encoder):
+    @staticmethod
+    def encode(data: bytes) -> str:
+        return bytes_to_base(data, ALPHABET)
+
+    @staticmethod
+    def decode(data: str) -> bytes:
+        return base_to_bytes(data, ALPHABET)

rtty_soda/encoders/base64_encoder.py

@@ -0,0 +1,16 @@
+import base64
+
+from .encoder import Encoder
+from .functions import decode_bytes, encode_str
+
+__all__ = ["Base64Encoder"]
+
+
+class Base64Encoder(Encoder):
+    @staticmethod
+    def encode(data: bytes) -> str:
+        return decode_bytes(base64.b64encode(data))
+
+    @staticmethod
+    def decode(data: str) -> bytes:
+        return base64.b64decode(encode_str(data))

rtty_soda/encoders/base94_encoder.py

@@ -0,0 +1,16 @@
+from .encoder import Encoder
+from .functions import base_to_bytes, bytes_to_base
+
+__all__ = ["ALPHABET", "Base94Encoder"]
+
+ALPHABET = "".join([chr(i) for i in range(33, 127)])
+
+
+class Base94Encoder(Encoder):
+    @staticmethod
+    def encode(data: bytes) -> str:
+        return bytes_to_base(data, ALPHABET)
+
+    @staticmethod
+    def decode(data: str) -> bytes:
+        return base_to_bytes(data, ALPHABET)

rtty_soda/encoders/encoder.py

@@ -0,0 +1,11 @@
+from typing import Protocol
+
+__all__ = ["Encoder"]
+
+
+class Encoder(Protocol):
+    @staticmethod
+    def encode(data: bytes) -> str: ...
+
+    @staticmethod
+    def decode(data: str) -> bytes: ...

rtty_soda/encoders/functions.py

@@ -0,0 +1,56 @@
+from typing import cast
+
+__all__ = ["base_to_bytes", "bytes_to_base", "decode_bytes", "encode_str"]
+
+
+def encode_str(data: str) -> bytes:
+    return data.encode(encoding="utf-8", errors="strict")
+
+
+def decode_bytes(data: bytes) -> str:
+    return data.decode(encoding="utf-8", errors="strict")
+
+
+def int_to_base(number: int, alphabet: str) -> str:
+    if number == 0:
+        return alphabet[0]
+
+    result: list[str] = []
+    base = len(alphabet)
+    abs_number = abs(number)
+    while abs_number:
+        abs_number, remainder = divmod(abs_number, base)
+        result.append(alphabet[remainder])
+
+    return "".join(reversed(result))
+
+
+def base_to_int(source: str, alphabet: str) -> int:
+    number = 0
+    base = len(alphabet)
+    for index, digit in enumerate(reversed(source)):
+        number += alphabet.index(digit) * cast("int", base**index)
+
+    return number
+
+
+def bytes_to_base(source: bytes, alphabet: str) -> str:
+    number = int.from_bytes(source, byteorder="big", signed=False)
+    return int_to_base(number, alphabet)
+
+
+def int_to_bytes(number: int) -> bytes:
+    if number == 0:
+        return b"\x00"
+
+    buffer = bytearray()
+    while number:
+        buffer.append(number & 0xFF)
+        number //= 256
+
+    buffer.reverse()
+    return bytes(buffer)
+
+
+def base_to_bytes(source: str, alphabet: str) -> bytes:
+    return int_to_bytes(base_to_int(source, alphabet))

rtty_soda/encoders/scsu.py

@@ -0,0 +1,19 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .scsu_stubs import SCSUIncrementalDecoder, SCSUIncrementalEncoder
+else:
+    from scsu.codecs.decoder import SCSUIncrementalDecoder
+    from scsu.codecs.encoder import SCSUIncrementalEncoder
+
+__all__ = ["scsu_decode", "scsu_encode"]
+
+
+def scsu_encode(data: str) -> bytes:
+    encoder = SCSUIncrementalEncoder(errors="strict")
+    return encoder.encode(s=data, final=True)
+
+
+def scsu_decode(data: bytes) -> str:
+    decoder = SCSUIncrementalDecoder(errors="strict")
+    return decoder.decode(s=data, final=True)

rtty_soda/encoders/scsu_stubs.pyi

@@ -0,0 +1,7 @@
+class SCSUIncrementalEncoder:
+    def __init__(self, errors: str = "strict") -> None: ...
+    def encode(self, s: str, final: bool = False) -> bytes: ...
+
+class SCSUIncrementalDecoder:
+    def __init__(self, errors: str = "strict") -> None: ...
+    def decode(self, s: bytes, final: bool = False) -> str: ...

rtty_soda/formatters.py

@@ -0,0 +1,46 @@
+import re
+from typing import NamedTuple, Protocol
+
+__all__ = ["FixedFormatter", "FormattedText", "Formatter", "remove_whitespace"]
+
+
+class FormattedText(NamedTuple):
+    text: str
+    groups: int
+
+
+class Formatter(Protocol):
+    def format(self, text: str) -> FormattedText: ...
+
+
+class FixedFormatter(Formatter):
+    def __init__(self, group_len: int, line_len: int, pad_count: int) -> None:
+        self.group_len = group_len
+        self.line_len = line_len
+        self.pad_count = pad_count
+
+    def format(self, text: str) -> FormattedText:
+        groups = 0
+
+        if 0 < self.group_len < self.line_len:
+            text, groups = self.split_groups(text)
+
+        if self.pad_count > 0:
+            text = self.pad_newlines(text)
+
+        return FormattedText(text, groups)
+
+    def split_groups(self, data: str) -> FormattedText:
+        step = self.group_len
+        gpl = self.line_len // (step + 1)
+        groups = [data[i : i + step] for i in range(0, len(data), step)]
+        lines = [" ".join(groups[i : i + gpl]) for i in range(0, len(groups), gpl)]
+        return FormattedText("\n".join(lines), len(groups))
+
+    def pad_newlines(self, text: str) -> str:
+        padding = "\n" * self.pad_count
+        return padding + text.strip() + "\n" + padding
+
+
+def remove_whitespace(data: str) -> str:
+    return re.sub(r"\s", "", data)

rtty_soda/interfaces.py

@@ -0,0 +1,19 @@
+from typing import Protocol
+
+__all__ = ["Reader", "Writer"]
+
+
+class Reader(Protocol):
+    """Reads data source."""
+
+    def read_str(self) -> str: ...
+
+    def read_bytes(self) -> bytes: ...
+
+
+class Writer(Protocol):
+    """Outputs data and prints diagnostics."""
+
+    def write_bytes(self, data: bytes) -> None: ...
+
+    def write_diag(self, message: str) -> None: ...

rtty_soda/services/__init__.py

@@ -0,0 +1,14 @@
+from .encoding_service import EncodingService
+from .encryption_service import EncryptionService, Keypair, Pipe
+from .key_service import KeyService
+from .service import FormattedOutput, Service
+
+__all__ = [
+    "EncodingService",
+    "EncryptionService",
+    "FormattedOutput",
+    "KeyService",
+    "Keypair",
+    "Pipe",
+    "Service",
+]

rtty_soda/services/encoding_service.py

@@ -0,0 +1,29 @@
+from typing import TYPE_CHECKING
+
+from rtty_soda.encoders import ENCODERS
+
+from .service import Service
+
+if TYPE_CHECKING:
+    from rtty_soda.formatters import Formatter
+    from rtty_soda.interfaces import Reader, Writer
+
+__all__ = ["EncodingService"]
+
+
+class EncodingService(Service):
+    def __init__(
+        self,
+        in_encoding: str,
+        out_encoding: str,
+        formatter: Formatter,
+        writer: Writer,
+        verbose: bool,
+    ) -> None:
+        super().__init__(formatter, writer, verbose)
+        self.in_encoder = ENCODERS.get(in_encoding)
+        self.out_encoder = ENCODERS.get(out_encoding)
+
+    def encode(self, data: Reader) -> None:
+        buff = self.read_input(data, self.in_encoder)
+        self.write_output(buff, self.out_encoder)

rtty_soda/services/encryption_service.py

@@ -0,0 +1,137 @@
+from typing import TYPE_CHECKING
+
+from nacl.public import PrivateKey, PublicKey
+
+from rtty_soda.archivers import ARCHIVERS, UNARCHIVERS
+from rtty_soda.cryptography import public, secret
+from rtty_soda.encoders import ENCODERS, encode_str, scsu_decode, scsu_encode
+
+from .key_service import KeyService
+from .service import Service
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from rtty_soda.formatters import Formatter
+    from rtty_soda.interfaces import Reader, Writer
+
+__all__ = ["EncryptionService", "Keypair", "Pipe"]
+
+type Keypair = tuple[PrivateKey, PublicKey]
+type Pipe = Callable[[bytes], bytes]
+
+
+class EncryptionService(Service):
+    def __init__(
+        self,
+        text_mode: bool,
+        key_encoding: str,
+        data_encoding: str,
+        compression: str,
+        formatter: Formatter | None,
+        writer: Writer,
+        verbose: bool,
+    ) -> None:
+        super().__init__(formatter, writer, verbose)
+        self.text_mode = text_mode
+        self.key_encoder = ENCODERS.get(key_encoding)
+        self.data_encoder = ENCODERS.get(data_encoding)
+        self.archiver = ARCHIVERS.get(compression)
+        self.unarchiver = UNARCHIVERS.get(compression)
+
+    def read_keypair(self, private_key: Reader, public_key: Reader) -> Keypair:
+        priv_seed = self.read_input(private_key, self.key_encoder)
+        priv = PrivateKey(private_key=priv_seed)
+        pub_seed = self.read_input(public_key, self.key_encoder)
+        pub = PublicKey(public_key=pub_seed)
+        return priv, pub
+
+    def encryption_flow(self, message: Reader, encrypt: Pipe) -> None:
+        if self.text_mode:
+            text = message.read_str().strip()
+            plaintext_len = len(text)
+            data = scsu_encode(text)
+        else:
+            data = message.read_bytes()
+            plaintext_len = len(data)
+
+        if self.archiver is not None:
+            data = self.archiver(data)
+
+        data = encrypt(data)
+        buff = self.format_data(data, self.data_encoder)
+        writer = self.writer
+        writer.write_bytes(buff.data)
+        if self.verbose:
+            overhead = buff.chars / plaintext_len
+            writer.write_diag(f"Groups: {buff.groups}")
+            writer.write_diag(f"Plaintext: {plaintext_len}")
+            writer.write_diag(f"Ciphertext: {buff.chars}")
+            writer.write_diag(f"Overhead: {overhead:.3f}")
+
+    def encrypt_public(
+        self, private_key: Reader, public_key: Reader, message: Reader
+    ) -> None:
+        priv, pub = self.read_keypair(private_key, public_key)
+
+        def encrypt(data: bytes) -> bytes:
+            return public.encrypt(private=priv, public=pub, data=data)
+
+        self.encryption_flow(message, encrypt)
+
+    def encrypt_secret(self, key: Reader, message: Reader) -> None:
+        sk = self.read_input(key, self.key_encoder)
+
+        def encrypt(data: bytes) -> bytes:
+            return secret.encrypt(key=sk, data=data)
+
+        self.encryption_flow(message, encrypt)
+
+    def encrypt_password(
+        self, password: Reader, message: Reader, kdf_profile: str
+    ) -> None:
+        key = KeyService.derive_key(password, kdf_profile)
+
+        def encrypt(data: bytes) -> bytes:
+            return secret.encrypt(key, data)
+
+        self.encryption_flow(message, encrypt)
+
+    def decryption_flow(self, message: Reader, decrypt: Pipe) -> None:
+        data = self.read_input(message, self.data_encoder)
+        data = decrypt(data)
+        if self.unarchiver is not None:
+            data = self.unarchiver(data)
+
+        if self.text_mode:
+            data = encode_str(scsu_decode(data))
+
+        self.writer.write_bytes(data)
+
+    def decrypt_public(
+        self, private_key: Reader, public_key: Reader, message: Reader
+    ) -> None:
+        priv, pub = self.read_keypair(private_key, public_key)
+
+        def decrypt(data: bytes) -> bytes:
+            return public.decrypt(private=priv, public=pub, data=data)
+
+        self.decryption_flow(message, decrypt)
+
+    def decrypt_secret(self, key: Reader, message: Reader) -> None:
+        sk = self.read_input(key, self.key_encoder)
+
+        def decrypt(data: bytes) -> bytes:
+            return secret.decrypt(key=sk, data=data)
+
+        self.decryption_flow(message, decrypt)
+
+    def decrypt_password(
+        self, password: Reader, message: Reader, kdf_profile: str
+    ) -> None:
+        key = KeyService.derive_key(password, kdf_profile)
+
+        def decrypt(data: bytes) -> bytes:
+            return secret.decrypt(key, data)
+
+        self.decryption_flow(message, decrypt)