detssh 0.1.0__py3-none-any.whl

detssh/__init__.py

@@ -0,0 +1,14 @@
+from detssh.backends.kdf import BACKENDS as KDF_BACKENDS
+from detssh.backends.salt import ALGOS as SALT_ALGOS
+from detssh.keygen import default_output_path, keypair_from_seed, public_key_path, write_keypair
+
+
+__version__ = "0.1.0"
+__all__ = [
+    "KDF_BACKENDS",
+    "SALT_ALGOS",
+    "default_output_path",
+    "keypair_from_seed",
+    "public_key_path",
+    "write_keypair",
+]

detssh/backends/base.py

@@ -0,0 +1,177 @@
+from pathlib import Path
+
+import click
+import questionary
+
+from detssh.keygen import keypair_from_seed, public_key_path, write_keypair
+
+
+def _display_path(path):
+    try:
+        return f"~/{Path(path).relative_to(Path.home())}"
+    except (TypeError, ValueError):
+        return str(path)
+
+
+DEFAULT_TEXT_MARKER = "\x00"
+
+
+class Field:
+    def __init__(self, message, kind="text", required=False, choices=(), min_value=None, max_value=None, soft_max=None):
+        self.message = message
+        self.kind = kind
+        self.required = required
+        self.choices = choices
+        self.min_value = min_value
+        self.max_value = max_value
+        self.soft_max = soft_max
+
+    def hint(self):
+        parts = []
+        if self.min_value is not None and self.max_value is not None:
+            parts.append(f"{self.min_value}-{self.max_value}")
+        elif self.min_value is not None:
+            parts.append(f">= {self.min_value}")
+        elif self.max_value is not None:
+            parts.append(f"<= {self.max_value}")
+        if self.soft_max is not None:
+            parts.append(f"soft max {self.soft_max}")
+        return f" ({', '.join(parts)})" if parts else ""
+
+    def hard_error_for(self, value):
+        if value is None:
+            return None
+        if self.min_value is not None and value < self.min_value:
+            return f"must be at least {self.min_value}"
+        if self.max_value is not None and value > self.max_value:
+            return f"must be at most {self.max_value}"
+        return None
+
+    def soft_error_for(self, value):
+        if value is None or self.soft_max is None or value <= self.soft_max:
+            return None
+        return f"is {value}, above the recommended safe limit of {self.soft_max} - this may take a long time"
+
+    def ask(self, default):
+        message = self.message + self.hint()
+        if self.kind == "secret":
+            return click.prompt(message, hide_input=True, confirmation_prompt=True)
+        if self.kind == "int":
+            return click.prompt(message, default=default, type=int)
+        if self.kind == "path":
+            if default is not None:
+                message = f"{message} [{_display_path(default)}]"
+            return click.prompt(
+                message, default=default, type=click.Path(dir_okay=False, path_type=Path), show_default=False
+            )
+        if self.kind == "select":
+            answer = questionary.select(message, choices=list(self.choices), default=default).ask()
+            if answer is None:
+                raise click.Abort()
+            return answer
+        return click.prompt(message, default=default, show_default=bool(default))
+
+
+def build_options(fields, defaults=None):
+    defaults = defaults or {}
+    options = []
+    for name, field in fields.items():
+        kwargs = {"default": None, "help": field.message + field.hint()}
+
+        default_value = defaults.get(name)
+        if callable(default_value):
+            default_value = default_value()
+        if default_value not in (None, ""):
+            display_value = _display_path(default_value) if field.kind == "path" else default_value
+            kwargs["help"] = f"{field.message}{field.hint()}{DEFAULT_TEXT_MARKER}[default: {display_value}]"
+
+        if field.kind == "int":
+            kwargs["type"] = int
+        elif field.kind == "select":
+            kwargs["type"] = click.Choice(field.choices)
+        elif field.kind == "path":
+            kwargs["type"] = click.Path(dir_okay=False, path_type=Path)
+        options.append(click.Option([f"--{name.replace('_', '-')}"], **kwargs))
+    return options
+
+
+def is_interactive(values):
+    return all(value is None for value in values.values())
+
+
+def resolve_fields(fields, values, defaults, interactive, allow_soft_constraints=False):
+    resolved = {}
+    soft_violations = []
+    for name, field in fields.items():
+        flag = f"--{name.replace('_', '-')}"
+        value = values.get(name)
+
+        if value is None and interactive:
+            default = defaults.get(name)
+            if callable(default):
+                default = default()
+            while True:
+                value = field.ask(default)
+                hard_error = field.hard_error_for(value)
+                if hard_error:
+                    click.echo(f"Error: {flag} {hard_error}")
+                    continue
+                break
+            soft_error = field.soft_error_for(value)
+            if soft_error:
+                soft_violations.append(f"{flag} {soft_error}")
+        elif value is None and field.required:
+            raise click.UsageError(f"{flag} is required")
+        elif value is None:
+            default = defaults.get(name)
+            value = default() if callable(default) else default
+        else:
+            hard_error = field.hard_error_for(value)
+            if hard_error:
+                raise click.UsageError(f"{flag} {hard_error}")
+            soft_error = field.soft_error_for(value)
+            if soft_error and not allow_soft_constraints:
+                raise click.UsageError(f"{flag} {soft_error} - pass --force-allow-soft-constraints to override")
+
+        if field.kind == "path" and value is not None:
+            value = Path(value).expanduser()
+        if field.required and not value:
+            raise click.UsageError(f"{flag} must not be empty")
+        resolved[name] = value
+
+    if soft_violations:
+        click.echo("These may take a long time:")
+        for violation in soft_violations:
+            click.echo(f"  {violation}")
+        if not click.confirm("Continue anyway?"):
+            raise click.Abort()
+
+    return resolved
+
+
+def confirm_overwrite(output, overwrite_files):
+    if overwrite_files:
+        return
+    output = Path(output)
+    if (output.exists() or public_key_path(output).exists()) and not click.confirm(
+        f"{output} already exists. Overwrite?"
+    ):
+        raise click.Abort()
+
+
+def write_keypair_and_recap(seed_bytes, output, comment, recap):
+    private_key, public_key = keypair_from_seed(seed_bytes)
+    try:
+        priv_path, pub_path = write_keypair(private_key, public_key, output, comment=comment)
+    except OSError as e:
+        raise click.ClickException(f"couldn't write {output}: {e.strerror or e}") from e
+    except ValueError as e:
+        raise click.UsageError(str(e)) from e
+
+    click.echo(f"Wrote private key: {priv_path}")
+    click.echo(f"Wrote public key:  {pub_path}")
+
+    click.echo()
+    click.echo("To recreate this exact key, remember your passphrase (keep it secret) plus:")
+    for name, value in (*recap, ("algorithm", "ed25519")):
+        click.echo(f"  {name:<18} {value}")

detssh/backends/kdf/__init__.py

@@ -0,0 +1,22 @@
+from detssh.backends.kdf.argon2d import Argon2D
+from detssh.backends.kdf.argon2i import Argon2I
+from detssh.backends.kdf.argon2id import Argon2Id
+from detssh.backends.kdf.bcrypt_pbkdf import BcryptPbkdf
+from detssh.backends.kdf.pbkdf2 import Pbkdf2
+from detssh.backends.kdf.scrypt import Scrypt
+
+
+BACKENDS = {
+    "argon2id": Argon2Id,
+    "argon2i": Argon2I,
+    "argon2d": Argon2D,
+    "scrypt": Scrypt,
+    "pbkdf2": Pbkdf2,
+    "bcrypt_pbkdf": BcryptPbkdf,
+}
+
+for _name, _backend in BACKENDS.items():
+    if _backend.name != _name:
+        raise TypeError(f"{_backend.__name__}.name must equal its registry key {_name!r}")
+    if _backend.salt_constraints is None:
+        raise TypeError(f"{_backend.__name__} must set salt_constraints (use NO_SALT_CONSTRAINTS if none apply)")

detssh/backends/kdf/_argon2.py

@@ -0,0 +1,44 @@
+from argon2.exceptions import Argon2Error
+from argon2.low_level import hash_secret_raw
+
+from detssh.backends.base import Field
+from detssh.backends.kdf.base import KDFBackend, KDFError, SaltConstraints
+
+
+class Argon2Base(KDFBackend):
+    salt_constraints = SaltConstraints(min_size=8)
+    type = None
+
+    fields = {
+        "iterations": Field("Argon2 iterations", kind="int", soft_max=100),
+        "memory": Field("Argon2 memory, in MiB", kind="int", soft_max=2048),
+        "parallelism": Field("Argon2 parallelism", kind="int", soft_max=16),
+    }
+    defaults = {
+        "iterations": 10,
+        "memory": 1024,
+        "parallelism": 4,
+    }
+
+    @classmethod
+    def run(cls, resolved, salt):
+        try:
+            return hash_secret_raw(
+                secret=resolved["seed"].encode("utf-8"),
+                salt=salt,
+                time_cost=resolved["iterations"],
+                memory_cost=resolved["memory"] * 1024,
+                parallelism=resolved["parallelism"],
+                hash_len=resolved["hash_len"],
+                type=cls.type,
+            )
+        except (Argon2Error, OverflowError, ValueError) as e:
+            raise KDFError(str(e)) from e
+
+    @classmethod
+    def recap(cls, resolved):
+        return (
+            ("iterations", resolved["iterations"]),
+            ("memory", f"{resolved['memory']} MiB"),
+            ("parallelism", resolved["parallelism"]),
+        )

detssh/backends/kdf/argon2d.py

@@ -0,0 +1,8 @@
+from argon2.low_level import Type
+
+from detssh.backends.kdf._argon2 import Argon2Base
+
+
+class Argon2D(Argon2Base):
+    name = "argon2d"
+    type = Type.D

detssh/backends/kdf/argon2i.py

@@ -0,0 +1,8 @@
+from argon2.low_level import Type
+
+from detssh.backends.kdf._argon2 import Argon2Base
+
+
+class Argon2I(Argon2Base):
+    name = "argon2i"
+    type = Type.I

detssh/backends/kdf/argon2id.py

@@ -0,0 +1,8 @@
+from argon2.low_level import Type
+
+from detssh.backends.kdf._argon2 import Argon2Base
+
+
+class Argon2Id(Argon2Base):
+    name = "argon2id"
+    type = Type.ID

detssh/backends/kdf/base.py

@@ -0,0 +1,36 @@
+class SaltConstraints:
+    def __init__(self, min_size=None, max_size=None, exact_size=None):
+        self.min_size = min_size
+        self.max_size = max_size
+        self.exact_size = exact_size
+
+    def error_for(self, size):
+        if self.exact_size is not None and size != self.exact_size:
+            return f"needs a salt of exactly {self.exact_size} bytes, got {size}"
+        if self.min_size is not None and size < self.min_size:
+            return f"needs a salt of at least {self.min_size} bytes, got {size}"
+        if self.max_size is not None and size > self.max_size:
+            return f"needs a salt of at most {self.max_size} bytes, got {size}"
+        return None
+
+
+NO_SALT_CONSTRAINTS = SaltConstraints()
+
+
+class KDFError(Exception):
+    pass
+
+
+class KDFBackend:
+    name = None
+    salt_constraints = None
+    fields = {}
+    defaults = {}
+
+    @classmethod
+    def run(cls, resolved, salt):
+        raise NotImplementedError
+
+    @classmethod
+    def recap(cls, resolved):
+        return ()

detssh/backends/kdf/bcrypt_pbkdf.py

@@ -0,0 +1,32 @@
+import bcrypt
+
+from detssh.backends.base import Field
+from detssh.backends.kdf.base import KDFBackend, KDFError, SaltConstraints
+
+
+class BcryptPbkdf(KDFBackend):
+    name = "bcrypt_pbkdf"
+    salt_constraints = SaltConstraints(min_size=1)
+
+    fields = {
+        "rounds": Field("bcrypt_pbkdf rounds", kind="int", soft_max=2000),
+    }
+    defaults = {
+        "rounds": 16,
+    }
+
+    @classmethod
+    def run(cls, resolved, salt):
+        try:
+            return bcrypt.kdf(
+                password=resolved["seed"].encode("utf-8"),
+                salt=salt,
+                desired_key_bytes=resolved["hash_len"],
+                rounds=resolved["rounds"],
+            )
+        except (ValueError, OverflowError) as e:
+            raise KDFError(str(e)) from e
+
+    @classmethod
+    def recap(cls, resolved):
+        return (("rounds", resolved["rounds"]),)

detssh/backends/kdf/pbkdf2.py

@@ -0,0 +1,36 @@
+import hashlib
+
+from detssh.backends.base import Field
+from detssh.backends.kdf.base import NO_SALT_CONSTRAINTS, KDFBackend, KDFError
+
+
+class Pbkdf2(KDFBackend):
+    name = "pbkdf2"
+    salt_constraints = NO_SALT_CONSTRAINTS
+
+    fields = {
+        "iterations": Field("PBKDF2 iterations", kind="int", soft_max=50_000_000),
+    }
+    defaults = {
+        "iterations": 600_000,
+    }
+
+    @classmethod
+    def run(cls, resolved, salt):
+        try:
+            return hashlib.pbkdf2_hmac(
+                "sha256",
+                resolved["seed"].encode("utf-8"),
+                salt,
+                resolved["iterations"],
+                dklen=resolved["hash_len"],
+            )
+        except (ValueError, OverflowError) as e:
+            raise KDFError(str(e)) from e
+
+    @classmethod
+    def recap(cls, resolved):
+        return (
+            ("iterations", resolved["iterations"]),
+            ("prf", "sha256"),
+        )

detssh/backends/kdf/scrypt.py

@@ -0,0 +1,45 @@
+import hashlib
+
+from detssh.backends.base import Field
+from detssh.backends.kdf.base import NO_SALT_CONSTRAINTS, KDFBackend, KDFError
+
+
+class Scrypt(KDFBackend):
+    name = "scrypt"
+    salt_constraints = NO_SALT_CONSTRAINTS
+
+    fields = {
+        "cost": Field("scrypt cost (N, power of two)", kind="int", soft_max=2**18),
+        "block_size": Field("scrypt block size (r)", kind="int", soft_max=16),
+        "parallelism": Field("scrypt parallelism (p)", kind="int", soft_max=8),
+    }
+    defaults = {
+        "cost": 2**14,
+        "block_size": 8,
+        "parallelism": 1,
+    }
+
+    @classmethod
+    def run(cls, resolved, salt):
+        cost, block_size, parallelism = resolved["cost"], resolved["block_size"], resolved["parallelism"]
+        maxmem = 128 * block_size * (cost + parallelism + 2) * 2
+        try:
+            return hashlib.scrypt(
+                resolved["seed"].encode("utf-8"),
+                salt=salt,
+                n=cost,
+                r=block_size,
+                p=parallelism,
+                maxmem=maxmem,
+                dklen=resolved["hash_len"],
+            )
+        except (ValueError, TypeError, OverflowError) as e:
+            raise KDFError(str(e)) from e
+
+    @classmethod
+    def recap(cls, resolved):
+        return (
+            ("cost (N)", resolved["cost"]),
+            ("block-size (r)", resolved["block_size"]),
+            ("parallelism (p)", resolved["parallelism"]),
+        )

detssh/backends/salt/__init__.py

@@ -0,0 +1,26 @@
+from detssh.backends.salt.blake2b import Blake2b
+from detssh.backends.salt.blake2s import Blake2s
+from detssh.backends.salt.sha3_256 import Sha3256
+from detssh.backends.salt.sha3_384 import Sha3384
+from detssh.backends.salt.sha3_512 import Sha3512
+from detssh.backends.salt.sha256 import Sha256
+from detssh.backends.salt.sha384 import Sha384
+from detssh.backends.salt.sha512 import Sha512
+
+
+ALGOS = {
+    "blake2b": Blake2b,
+    "blake2s": Blake2s,
+    "sha256": Sha256,
+    "sha384": Sha384,
+    "sha512": Sha512,
+    "sha3_256": Sha3256,
+    "sha3_384": Sha3384,
+    "sha3_512": Sha3512,
+}
+
+for _name, _algo in ALGOS.items():
+    if _algo.name != _name:
+        raise TypeError(f"{_algo.__name__}.name must equal its registry key {_name!r}")
+    if _algo.digest_size is None and (_algo.min_digest_size is None or _algo.max_digest_size is None):
+        raise TypeError(f"{_algo.__name__} must set digest_size, or min/max_digest_size if variable")

detssh/backends/salt/base.py

@@ -0,0 +1,25 @@
+class SaltError(Exception):
+    pass
+
+
+class SaltAlgo:
+    name = None
+    digest_size = None
+    min_digest_size = None
+    max_digest_size = None
+    fields = {}
+    defaults = {}
+
+    @classmethod
+    def is_variable(cls):
+        return cls.digest_size is None
+
+    @classmethod
+    def digest(cls, label, resolved):
+        raise NotImplementedError
+
+    @classmethod
+    def recap(cls, resolved):
+        if cls.is_variable():
+            return (("salt-digest-size", resolved["salt_digest_size"]),)
+        return ()

detssh/backends/salt/blake2b.py

@@ -0,0 +1,26 @@
+import hashlib
+
+from detssh.backends.base import Field
+from detssh.backends.salt.base import SaltAlgo, SaltError
+
+
+class Blake2b(SaltAlgo):
+    name = "blake2b"
+    min_digest_size = 1
+    max_digest_size = 64
+
+    fields = {
+        "salt_digest_size": Field(
+            "Salt digest size, in bytes", kind="int", min_value=min_digest_size, max_value=max_digest_size
+        ),
+    }
+    defaults = {
+        "salt_digest_size": 16,
+    }
+
+    @classmethod
+    def digest(cls, label, resolved):
+        try:
+            return hashlib.blake2b(label.encode("utf-8"), digest_size=resolved["salt_digest_size"]).digest()
+        except (ValueError, OverflowError) as e:
+            raise SaltError(str(e)) from e

detssh/backends/salt/blake2s.py

@@ -0,0 +1,26 @@
+import hashlib
+
+from detssh.backends.base import Field
+from detssh.backends.salt.base import SaltAlgo, SaltError
+
+
+class Blake2s(SaltAlgo):
+    name = "blake2s"
+    min_digest_size = 1
+    max_digest_size = 32
+
+    fields = {
+        "salt_digest_size": Field(
+            "Salt digest size, in bytes", kind="int", min_value=min_digest_size, max_value=max_digest_size
+        ),
+    }
+    defaults = {
+        "salt_digest_size": 16,
+    }
+
+    @classmethod
+    def digest(cls, label, resolved):
+        try:
+            return hashlib.blake2s(label.encode("utf-8"), digest_size=resolved["salt_digest_size"]).digest()
+        except (ValueError, OverflowError) as e:
+            raise SaltError(str(e)) from e

detssh/backends/salt/sha256.py

@@ -0,0 +1,15 @@
+import hashlib
+
+from detssh.backends.salt.base import SaltAlgo, SaltError
+
+
+class Sha256(SaltAlgo):
+    name = "sha256"
+    digest_size = 32
+
+    @classmethod
+    def digest(cls, label, resolved):
+        try:
+            return hashlib.sha256(label.encode("utf-8")).digest()
+        except ValueError as e:
+            raise SaltError(str(e)) from e

detssh/backends/salt/sha384.py

@@ -0,0 +1,15 @@
+import hashlib
+
+from detssh.backends.salt.base import SaltAlgo, SaltError
+
+
+class Sha384(SaltAlgo):
+    name = "sha384"
+    digest_size = 48
+
+    @classmethod
+    def digest(cls, label, resolved):
+        try:
+            return hashlib.sha384(label.encode("utf-8")).digest()
+        except ValueError as e:
+            raise SaltError(str(e)) from e

detssh/backends/salt/sha3_256.py

@@ -0,0 +1,15 @@
+import hashlib
+
+from detssh.backends.salt.base import SaltAlgo, SaltError
+
+
+class Sha3256(SaltAlgo):
+    name = "sha3_256"
+    digest_size = 32
+
+    @classmethod
+    def digest(cls, label, resolved):
+        try:
+            return hashlib.sha3_256(label.encode("utf-8")).digest()
+        except ValueError as e:
+            raise SaltError(str(e)) from e

detssh/backends/salt/sha3_384.py

@@ -0,0 +1,15 @@
+import hashlib
+
+from detssh.backends.salt.base import SaltAlgo, SaltError
+
+
+class Sha3384(SaltAlgo):
+    name = "sha3_384"
+    digest_size = 48
+
+    @classmethod
+    def digest(cls, label, resolved):
+        try:
+            return hashlib.sha3_384(label.encode("utf-8")).digest()
+        except ValueError as e:
+            raise SaltError(str(e)) from e

detssh/backends/salt/sha3_512.py

@@ -0,0 +1,15 @@
+import hashlib
+
+from detssh.backends.salt.base import SaltAlgo, SaltError
+
+
+class Sha3512(SaltAlgo):
+    name = "sha3_512"
+    digest_size = 64
+
+    @classmethod
+    def digest(cls, label, resolved):
+        try:
+            return hashlib.sha3_512(label.encode("utf-8")).digest()
+        except ValueError as e:
+            raise SaltError(str(e)) from e

detssh/backends/salt/sha512.py

@@ -0,0 +1,15 @@
+import hashlib
+
+from detssh.backends.salt.base import SaltAlgo, SaltError
+
+
+class Sha512(SaltAlgo):
+    name = "sha512"
+    digest_size = 64
+
+    @classmethod
+    def digest(cls, label, resolved):
+        try:
+            return hashlib.sha512(label.encode("utf-8")).digest()
+        except ValueError as e:
+            raise SaltError(str(e)) from e

detssh/cli.py

@@ -0,0 +1,183 @@
+import textwrap
+
+import click
+from click.formatting import measure_table
+
+from detssh.backends import kdf, salt
+from detssh.backends.base import (
+    DEFAULT_TEXT_MARKER,
+    Field,
+    build_options,
+    confirm_overwrite,
+    is_interactive,
+    resolve_fields,
+    write_keypair_and_recap,
+)
+from detssh.backends.kdf.base import KDFError
+from detssh.backends.salt.base import SaltError
+from detssh.keygen import COMMENT_FORBIDDEN_CHARS, ED25519_SEED_LENGTH, default_output_path
+
+
+DEFAULT_KDF = "argon2id"
+DEFAULT_SALT_ALGO = "blake2b"
+HASH_LEN = ED25519_SEED_LENGTH
+
+SELECTORS = {
+    "kdf": Field("KDF backend", kind="select", choices=tuple(kdf.BACKENDS)),
+    "salt_algo": Field("Salt hash algorithm", kind="select", choices=tuple(salt.ALGOS)),
+}
+COMMON = {
+    "seed": Field("Seed passphrase", kind="secret", required=True),
+    "label": Field("Label"),
+    "output": Field("Output path for the private key (ssh-keygen style, e.g. ~/.ssh/id_ed25519)", kind="path"),
+    "comment": Field("Comment for the public key"),
+}
+DEFAULTS = {
+    "kdf": DEFAULT_KDF,
+    "salt_algo": DEFAULT_SALT_ALGO,
+    "label": "",
+    "output": default_output_path,
+    "comment": "",
+}
+
+
+def _peek(args, flag, default):
+    value = default
+    for i, arg in enumerate(args):
+        if arg == flag and i + 1 < len(args):
+            value = args[i + 1]
+        elif arg.startswith(flag + "="):
+            value = arg.split("=", 1)[1]
+    return value
+
+
+def _fields_for(kdf_cls, salt_cls):
+    return {
+        "seed": COMMON["seed"],
+        "label": COMMON["label"],
+        **kdf_cls.fields,
+        **salt_cls.fields,
+        "output": COMMON["output"],
+        "comment": COMMON["comment"],
+    }
+
+
+def _help_note(kdf_cls, salt_cls):
+    return (
+        "\b\n"
+        f"Options below are for --kdf={kdf_cls.name} --salt-algo={salt_cls.name} "
+        "(defaults, unless you passed both already).\n"
+        f"--kdf choices:       {', '.join(kdf.BACKENDS)}\n"
+        f"--salt-algo choices: {', '.join(salt.ALGOS)}\n"
+        "\b\n"
+        "Each combination has its own options. To see another one's:\n"
+        "  detssh --kdf pbkdf2 --salt-algo sha256 --help"
+    )
+
+
+class KDFSaltCommand(click.Command):
+    def parse_args(self, ctx, args):
+        kdf_name = _peek(args, "--kdf", DEFAULT_KDF)
+        salt_name = _peek(args, "--salt-algo", DEFAULT_SALT_ALGO)
+
+        kdf_cls = kdf.BACKENDS.get(kdf_name, kdf.BACKENDS[DEFAULT_KDF])
+        salt_cls = salt.ALGOS.get(salt_name, salt.ALGOS[DEFAULT_SALT_ALGO])
+
+        fields = {**SELECTORS, **_fields_for(kdf_cls, salt_cls)}
+        defaults = {**DEFAULTS, **kdf_cls.defaults, **salt_cls.defaults}
+        self.params = build_options(fields, defaults) + [
+            click.Option(["--overwrite-files"], is_flag=True, help="Overwrite existing output files without asking."),
+            click.Option(
+                ["--force-allow-soft-constraints"],
+                is_flag=True,
+                default=None,
+                help="Flag mode only: skip the 'this may take a long time' confirmation for oversized cost "
+                "knobs. Interactive mode always asks.",
+            ),
+        ]
+        self.epilog = _help_note(kdf_cls, salt_cls)
+
+        return super().parse_args(ctx, args)
+
+    def format_options(self, ctx, formatter):
+        opts = [record for param in self.get_params(ctx) if (record := param.get_help_record(ctx)) is not None]
+        if not opts:
+            return
+
+        first_col = min(measure_table(opts)[0], 30)
+        text_width = max(formatter.width - first_col - 4, 10)
+
+        rewrapped = []
+        for name, help_text in opts:
+            if DEFAULT_TEXT_MARKER in help_text:
+                description, default_line = help_text.split(DEFAULT_TEXT_MARKER, 1)
+                lines = textwrap.wrap(description, text_width) or [""]
+                lines.append(default_line)
+                help_text = "\b\n" + "\n".join(lines)
+            rewrapped.append((name, help_text))
+
+        with formatter.section("Options"):
+            formatter.write_dl(rewrapped)
+
+
+@click.command(
+    cls=KDFSaltCommand, context_settings={"help_option_names": ["-h", "--help"], "max_content_width": 120}
+)
+def main(overwrite_files, **values):
+    interactive = is_interactive(values)
+    force_allow_soft_constraints = bool(values.get("force_allow_soft_constraints"))
+
+    kdf_name = values["kdf"]
+    if kdf_name is None:
+        kdf_name = SELECTORS["kdf"].ask(DEFAULTS["kdf"]) if interactive else DEFAULTS["kdf"]
+    kdf_cls = kdf.BACKENDS[kdf_name]
+
+    salt_name = values["salt_algo"]
+    if salt_name is None:
+        salt_name = SELECTORS["salt_algo"].ask(DEFAULTS["salt_algo"]) if interactive else DEFAULTS["salt_algo"]
+    salt_cls = salt.ALGOS[salt_name]
+
+    fields = _fields_for(kdf_cls, salt_cls)
+    defaults = {**DEFAULTS, **kdf_cls.defaults, **salt_cls.defaults}
+
+    resolved = {
+        "kdf": kdf_name,
+        "salt_algo": salt_name,
+        "hash_len": HASH_LEN,
+        **resolve_fields(fields, values, defaults, interactive, force_allow_soft_constraints),
+    }
+
+    if any(char in resolved["comment"] for char in COMMENT_FORBIDDEN_CHARS):
+        raise click.UsageError("--comment must not contain newlines")
+
+    try:
+        salt_bytes = salt_cls.digest(resolved["label"], resolved)
+    except SaltError as e:
+        raise click.UsageError(f"{salt_name}: {e}") from e
+    salt_error = kdf_cls.salt_constraints.error_for(len(salt_bytes))
+    if salt_error:
+        raise click.UsageError(f"{kdf_name} {salt_error}")
+
+    confirm_overwrite(resolved["output"], overwrite_files)
+
+    click.echo("Deriving key...")
+    try:
+        seed_bytes = kdf_cls.run(resolved, salt_bytes)
+    except KDFError as e:
+        raise click.UsageError(f"{kdf_name}: {e}") from e
+
+    recap = (
+        ("kdf", kdf_name),
+        ("salt-algo", salt_name),
+        ("label", repr(resolved["label"])),
+        ("encoding", "utf-8"),
+        *salt_cls.recap(resolved),
+        *kdf_cls.recap(resolved),
+        ("hash-len", resolved["hash_len"]),
+    )
+
+    write_keypair_and_recap(seed_bytes, resolved["output"], resolved["comment"], recap=recap)
+
+
+if __name__ == "__main__":
+    main()

detssh/keygen.py

@@ -0,0 +1,64 @@
+import os
+import stat
+from pathlib import Path
+
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+
+ED25519_SEED_LENGTH = 32
+COMMENT_FORBIDDEN_CHARS = ("\n", "\r")
+PRIVATE_KEY_MODE = stat.S_IRUSR | stat.S_IWUSR
+SSH_DIR_MODE = stat.S_IRWXU
+
+
+def _ssh_dir():
+    return Path.home() / ".ssh"
+
+
+def default_output_path():
+    return _ssh_dir() / "id_ed25519"
+
+
+# ed25519 is the only algorithm whose private key is literally its own seed, so it's the only one usable here.
+def keypair_from_seed(seed):
+    if len(seed) != ED25519_SEED_LENGTH:
+        raise ValueError(f"Ed25519 seed must be {ED25519_SEED_LENGTH} bytes, got {len(seed)}")
+    private_key = Ed25519PrivateKey.from_private_bytes(seed)
+    return private_key, private_key.public_key()
+
+
+def public_key_path(private_key_path):
+    private_key_path = Path(private_key_path)
+    return private_key_path.with_name(private_key_path.name + ".pub")
+
+
+def write_keypair(private_key, public_key, output_path, comment=""):
+    if any(char in comment for char in COMMENT_FORBIDDEN_CHARS):
+        raise ValueError("comment must not contain newlines")
+
+    output_path = Path(output_path)
+    pub_path = public_key_path(output_path)
+
+    if output_path.parent == _ssh_dir():
+        output_path.parent.mkdir(mode=SSH_DIR_MODE, exist_ok=True)
+
+    private_bytes = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.OpenSSH,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    public_bytes = public_key.public_bytes(
+        encoding=serialization.Encoding.OpenSSH,
+        format=serialization.PublicFormat.OpenSSH,
+    )
+
+    fd = os.open(output_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, PRIVATE_KEY_MODE)
+    os.fchmod(fd, PRIVATE_KEY_MODE)
+    with os.fdopen(fd, "wb") as f:
+        f.write(private_bytes)
+
+    comment_suffix = f" {comment}" if comment else ""
+    pub_path.write_bytes(public_bytes + comment_suffix.encode("utf-8") + b"\n")
+
+    return output_path, pub_path

detssh-0.1.0.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: detssh
+Version: 0.1.0
+Summary: Deterministic Ed25519 SSH key generation from a seed passphrase, via configurable KDF and salt-hash backends.
+Project-URL: Homepage, https://github.com/isik-kaplan/detssh
+Project-URL: Repository, https://github.com/isik-kaplan/detssh
+Author-email: Işık Kaplan <isik.kaplan@outlook.com>
+License: MIT
+License-File: LICENSE
+Keywords: argon2,bcrypt,cryptography,ed25519,kdf,pbkdf2,scrypt,ssh
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.11
+Requires-Dist: argon2-cffi>=21.3
+Requires-Dist: bcrypt>=5.0.0
+Requires-Dist: click>=8.1
+Requires-Dist: cryptography>=41.0
+Requires-Dist: questionary>=2.1.1
+Description-Content-Type: text/markdown
+
+# detssh
+
+Deterministic Ed25519 SSH key generation from a seed passphrase. Same
+passphrase + same parameters → same keypair, every time, on any machine -
+nothing to back up but what's in your head.
+
+```
+detssh
+```
+Prompts for everything (passphrase hidden + confirmed) and writes to the
+same place `ssh-keygen` would: `~/.ssh/id_ed25519` / `~/.ssh/id_ed25519.pub`
+(mode 600/700, `~/.ssh` created if missing). Pass `--output` to write
+somewhere else instead.
+
+Non-interactively:
+```
+detssh --kdf argon2id --salt-algo blake2b --seed "..." --label github --overwrite-files
+```
+Any flag switches to non-interactive mode: missing optional fields fall back
+to their defaults, `--seed` is the only required one. Passing `--seed` on the
+command line puts it in your shell history and process list (`ps aux`) - fine
+for local scripting, but prefer the interactive prompt when that matters.
+
+## Backends
+
+- `--kdf`: `argon2id` (default), `argon2i`, `argon2d`, `scrypt`, `pbkdf2`, `bcrypt_pbkdf`
+- `--salt-algo`: `blake2b` (default), `blake2s`, `sha256`, `sha384`, `sha512`, `sha3_256`, `sha3_384`, `sha3_512`
+
+Each combination has its own options (cost knobs, salt digest size, etc.),
+with their valid ranges shown in both `--help` and the interactive prompts.
+See them with:
+```
+detssh --kdf <kdf> --salt-algo <salt-algo> --help
+```
+
+We recommend sticking with the defaults (`argon2id`, memory-hard with a high
+cost) unless you have a specific reason not to - they make brute-forcing your
+passphrase significantly more expensive than faster KDFs like `pbkdf2`.
+
+Cost knobs (iterations, memory, cost, rounds, ...) also carry a soft safety
+limit meant to catch typos before they cost you minutes of derivation time.
+In interactive mode, going over one doesn't interrupt you - everything you
+exceeded is summarized in one confirmation at the very end. In flag mode, it
+fails immediately unless you pass `--force-allow-soft-constraints`.
+
+## Determinism guarantee
+
+Same explicit parameters → same key, across any release sharing the same
+major version - only a major version bump may change key derivation. That
+guarantee starts at 1.0; we're still on 0.x, so it doesn't apply yet (see
+`tests/golden/README.md`).
+
+## Development
+
+```
+uv sync
+uv run pytest
+uv run ruff check .
+```

detssh-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+detssh/__init__.py,sha256=jTiwAoFX3ZWkVL67_vHNbaAGQGanSWCLG-ocfs2Jy-I,379
+detssh/cli.py,sha256=tD4ugI4knYm6LIUvfUMceWIkNQ7tU6926J8B7tE4b2g,6169
+detssh/keygen.py,sha256=hSzcAWELziTBLq_f6m6zlQ3iYrro6dLOvw8tYMCW9ds,2094
+detssh/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+detssh/backends/base.py,sha256=AxcqHVxgpdKsmOYYUAdX6qIwZi8CXTG7FdsD29k_800,6655
+detssh/backends/kdf/__init__.py,sha256=viL9hQdQ16khsB3q2JueUJJh7DBSuSd6K_JzjLmQDD0,783
+detssh/backends/kdf/_argon2.py,sha256=VfWRuSSkSle2wgXdA0rGxUZtz9ERVdUn_dCbZcnuAT0,1425
+detssh/backends/kdf/argon2d.py,sha256=rPeYgeCI0PTDLrNhxZKrwpxin4p2pZVUsQBP4dv9SBg,154
+detssh/backends/kdf/argon2i.py,sha256=MOfmdxkDLG84Qlcp5JlD07dFV2MeLQiSZX0RAF9Snvo,154
+detssh/backends/kdf/argon2id.py,sha256=s3W9oiU6aTtuk0Dqs5Qfducr49K0glP5zvNtcFYcFG0,157
+detssh/backends/kdf/base.py,sha256=lb2zUu9ntjGMALciaRNuzCToQt9E-XIeYvUyZCa8atw,1016
+detssh/backends/kdf/bcrypt_pbkdf.py,sha256=mcK378mH81YfFCLhZ68gVZAuwp0MPzcaZcmwbp1ix_U,864
+detssh/backends/kdf/pbkdf2.py,sha256=TjrdkUMkzfOiiSDX03uaDRyy4H1_7VkylzVR_3xwCKc,934
+detssh/backends/kdf/scrypt.py,sha256=OhFOVwtyTdTEL-r9VNKoGV57cAYN7HtAcNU1PTwE19c,1444
+detssh/backends/salt/__init__.py,sha256=Sh29uTmSxgnHL2uC6RoGbZH1MM2MWGM0esl7gbKlCq4,949
+detssh/backends/salt/base.py,sha256=BB39jTzxxglXknHIGp9lpfJhVU815pkwKwrUE7FqbnA,524
+detssh/backends/salt/blake2b.py,sha256=4ov2CG3N2k_IrBc5_LiNdPgIQABGy8Kg_6cXI6KLzsg,710
+detssh/backends/salt/blake2s.py,sha256=UR5uPruY6iVgbPuINnjUuQF1CfLDgMtVb-CEbY1ndx4,710
+detssh/backends/salt/sha256.py,sha256=C0dhhLz5V-1PEHZkK-h77RBQUAsCnaOzQ4oPWHOWzGY,351
+detssh/backends/salt/sha384.py,sha256=m5POotRzVCX66lwPq-gP68PTe3K4ZKP5Nh-CR-PCXxc,351
+detssh/backends/salt/sha3_256.py,sha256=zCnfHxsQTsgxfXDlKxPjLcPI8JWFBpAJf2k0rMYkRIU,356
+detssh/backends/salt/sha3_384.py,sha256=cAnU6PQDPxJXF22ryieQTmqDEdGvJ92TMqNpWmkEPQs,356
+detssh/backends/salt/sha3_512.py,sha256=HPyZceWPXOWNXrC1Vz0j889PhPMRlpAZKlHXYooyJHs,356
+detssh/backends/salt/sha512.py,sha256=_xxN62l8CtSkzeEi2ogjKHe4Y1qSMy1EeeQ9ueutndw,351
+detssh-0.1.0.dist-info/METADATA,sha256=7Egt_kFXAU4KNv9OwdgXKU5bSb-0Vo6hqFyxgGD8cpQ,3086
+detssh-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+detssh-0.1.0.dist-info/entry_points.txt,sha256=3B9mgrDZWnKGJYzE3QAWCk5BqZNVUHWH4RrSbuIEZEE,43
+detssh-0.1.0.dist-info/licenses/LICENSE,sha256=FzSzVjj4SYgBjf1YNOfHhWqAJf14w_bcpbpvRMAetfQ,1070
+detssh-0.1.0.dist-info/RECORD,,

detssh-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

detssh-0.1.0.dist-info/entry_points.txt

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

detssh-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Işık Kaplan
+
+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.