linux-image-manager 2.1.0__py3-none-any.whl

lim/image/choosers.py

@@ -0,0 +1,111 @@
+"""Interactive selection of the distribution image to install."""
+
+from lim import catalog, runner, ui
+from lim.errors import LimError
+from lim.image.plan import ImagePlan
+
+
+def choose_arch(plan: ImagePlan) -> None:
+    version = ui.ask("Which Raspberry Pi will be used (e.g.: 1, 2, 3b, 3b+, 4...):")
+    entry = catalog.arch_rpi_images().get(version)
+    if entry is None:
+        raise LimError(f"Version {version} isn't supported.")
+    plan.raspberry_pi_version = version
+    plan.boot_size = "+500M"
+    plan.base_download_url = "http://os.archlinuxarm.org/os/"
+    plan.image_name = entry["image"]
+    plan.luks_memory_cost = entry["luks_memory_cost"]
+
+
+def choose_manjaro(plan: ImagePlan) -> None:
+    plan.boot_size = "+500M"
+    flavour = ui.ask("Which version(e.g.:architect,gnome) should be used:")
+    if flavour == "architect":
+        plan.image_checksum = "6b1c2fce12f244c1e32212767a9d3af2cf8263b2"
+        plan.base_download_url = (
+            "https://osdn.net/frs/redir.php?m=dotsrc&f=%2Fstorage%2Fg%2Fm%2Fma"
+            "%2Fmanjaro%2Farchitect%2F20.0%2F"
+        )
+        plan.image_name = "manjaro-architect-20.0-200426-linux56.iso"
+    elif flavour == "gnome":
+        release = ui.ask("Which release(e.g.:20,21,raspberrypi) should be used:")
+        entry = catalog.manjaro_gnome_releases().get(release)
+        if entry is None:
+            raise LimError(f"Gnome release {release} isn't supported.")
+        plan.image_checksum = entry.get("checksum")
+        plan.base_download_url = entry["url"]
+        plan.image_name = entry["image"]
+        plan.luks_memory_cost = entry.get("luks_memory_cost")
+        plan.raspberry_pi_version = entry.get("raspberry_pi_version")
+    else:
+        raise LimError(f"Manjaro version {flavour} isn't supported.")
+
+
+def choose_moode(plan: ImagePlan) -> None:
+    plan.boot_size = "+200M"
+    plan.image_checksum = "185cbc9a4994534bb7a4bc2744c78197"
+    plan.base_download_url = (
+        "https://github.com/moode-player/moode/releases/download/r651prod/"
+    )
+    plan.image_name = "moode-r651-iso.zip"
+
+
+def choose_retropie(plan: ImagePlan) -> None:
+    plan.boot_size = "+500M"
+    version = ui.ask("Which version(e.g.:1,2,3,4) should be used:")
+    entry = catalog.retropie_images().get(version)
+    if entry is None:
+        raise LimError(f"Version {version} isn't supported.")
+    plan.raspberry_pi_version = version
+    plan.base_download_url = (
+        "https://github.com/RetroPie/RetroPie-Setup/releases/download/4.8/"
+    )
+    plan.image_checksum = entry["checksum"]
+    plan.image_name = entry["image"]
+
+
+def choose_torbox(plan: ImagePlan) -> None:
+    plan.base_download_url = "https://www.torbox.ch/data/"
+    plan.image_name = "torbox-20220102-v050.gz"
+    plan.image_checksum = (
+        "0E1BA7FFD14AAAE5F0462C8293D95B62C3BF1D9E726E26977BD04772C55680D3"
+    )
+    plan.boot_size = "+200M"
+
+
+def choose_android_x86(plan: ImagePlan) -> None:
+    plan.base_download_url = (
+        "https://www.fosshub.com/Android-x86.html?dwl=android-x86_64-9.0-r2.iso"
+    )
+    plan.image_name = "android-x86_64-9.0-r2.iso"
+    plan.image_checksum = (
+        "f7eb8fc56f29ad5432335dc054183acf086c539f3990f0b6e9ff58bd6df4604e"
+    )
+    plan.boot_size = "+500M"
+
+
+DISTRIBUTION_CHOOSERS = {
+    "android-x86": choose_android_x86,
+    "torbox": choose_torbox,
+    "arch": choose_arch,
+    "manjaro": choose_manjaro,
+    "moode": choose_moode,
+    "retropie": choose_retropie,
+}
+
+
+def choose_linux_image(plan: ImagePlan) -> None:
+    distribution = ui.ask(
+        "Which distribution should be used [arch,moode,retropie,manjaro,torbox...]?"
+    )
+    chooser = DISTRIBUTION_CHOOSERS.get(distribution)
+    if chooser is None:
+        raise LimError(f"Distribution {distribution} isn't supported.")
+    plan.distribution = distribution
+    chooser(plan)
+
+
+def choose_local_image(plan: ImagePlan) -> None:
+    ui.info("Available images:")
+    runner.run(["ls", "-l", str(plan.image_folder)], check=False)
+    plan.image_name = ui.ask("Which image would you like to use?")

lim/image/chroot.py

@@ -0,0 +1,23 @@
+"""Mount an image and open an interactive shell inside it."""
+
+from lim import device as device_module
+from lim import runner, ui
+from lim.image.session import ImageSession
+
+
+def run_chroot() -> None:
+    ui.info("Starting chroot...")
+    device = device_module.select_device()
+    session = ImageSession(device)
+    try:
+        session.make_working_folder()
+        session.make_mount_folders()
+        session.decrypt_root()
+        session.mount_partitions()
+        session.mount_chroot_binds()
+        session.copy_qemu()
+        session.copy_resolv_conf()
+        ui.info("Bash shell starts...")
+        runner.run(["chroot", str(session.root_mount_path), "/bin/bash"], sudo=True)
+    finally:
+        session.destructor()

lim/image/encryption.py

@@ -0,0 +1,117 @@
+"""Remote-unlockable LUKS boot configuration (dropbear + mkinitcpio).
+
+See https://gist.github.com/gea0/4fc2be0cb7a74d0e7cc4322aed710d38 and
+https://gist.github.com/EnigmaCurry/2f9bed46073da8e38057fe78a61e7994
+"""
+
+from pathlib import Path
+
+from lim import catalog, fsutil, packages, runner, ui
+from lim.image.plan import ImagePlan
+from lim.image.session import ImageSession, chroot_bash, install_packages
+
+MKINITCPIO_HOOKS_PREFIX = (
+    "base udev autodetect microcode modconf kms keyboard keymap consolefont block"
+)
+MKINITCPIO_HOOKS_SUFFIX = "filesystems fsck"
+
+
+def _configure_mkinitcpio(plan: ImagePlan, root: Path) -> None:
+    # Concerning mkinitcpio warnings, see
+    # https://gist.github.com/imrvelj/c65cd5ca7f5505a65e59204f5a3f7a6d
+    mkinitcpio_path = root / "etc/mkinitcpio.conf"
+    ui.info(f"Configuring {mkinitcpio_path}...")
+    additional_modules = catalog.mkinitcpio_modules_by_rpi().get(
+        plan.raspberry_pi_version
+    )
+    if additional_modules is None:
+        ui.warning(f"Version {plan.raspberry_pi_version} isn't supported.")
+        additional_modules = ""
+    modules = f"g_cdc usb_f_acm usb_f_ecm {additional_modules} g_ether".replace("  ", " ")
+    fsutil.replace_in_file("MODULES=()", f"MODULES=({modules})", mkinitcpio_path)
+    fsutil.replace_in_file(
+        "BINARIES=()", "BINARIES=(/usr/lib/libgcc_s.so.1)", mkinitcpio_path
+    )
+    fsutil.replace_in_file(
+        f"HOOKS=({MKINITCPIO_HOOKS_PREFIX} {MKINITCPIO_HOOKS_SUFFIX})",
+        f"HOOKS=({MKINITCPIO_HOOKS_PREFIX} sleep netconf dropbear encryptssh "
+        f"{MKINITCPIO_HOOKS_SUFFIX})",
+        mkinitcpio_path,
+    )
+    ui.info(f"Content of {mkinitcpio_path}:{mkinitcpio_path.read_text()}")
+    ui.info("Generating mkinitcpio...")
+    chroot_bash(root, "mkinitcpio -vP")
+
+
+def _register_encrypted_root(plan: ImagePlan, session: ImageSession, root: Path) -> None:
+    fstab_path = root / "etc/fstab"
+    fstab_line = (
+        f"UUID={session.root_partition_uuid}  / {plan.root_filesystem}"
+        "    defaults,noatime  0  1"
+    )
+    ui.info(f"Configuring {fstab_path}...")
+    fsutil.ensure_line_in_file(fstab_line, fstab_path)
+    ui.info(f"Content of {fstab_path}:{fstab_path.read_text()}")
+
+    crypttab_path = root / "etc/crypttab"
+    crypttab_line = (
+        f"{session.root_mapper_name} UUID={session.root_partition_uuid} none luks"
+    )
+    ui.info(f"Configuring {crypttab_path}...")
+    fsutil.ensure_line_in_file(crypttab_line, crypttab_path)
+    ui.info(f"Content of {crypttab_path}:{crypttab_path.read_text()}")
+
+
+def _configure_bootloader(plan: ImagePlan, session: ImageSession, root: Path) -> None:
+    cryptdevice = (
+        f"cryptdevice=UUID={session.root_partition_uuid}:{session.root_mapper_name} "
+        f"root={session.root_mapper_path}"
+    )
+    boot_txt_path = session.boot_mount_path / "boot.txt"
+    if boot_txt_path.is_file():
+        ui.info(f"Configuring {boot_txt_path}...")
+        hostname = (root / "etc/hostname").read_text().strip()
+        fsutil.replace_in_file(
+            "part uuid ${devtype} ${devnum}:2 uuid", "", boot_txt_path
+        )
+        fsutil.replace_in_file(
+            "setenv bootargs console=ttyS1,115200 console=tty0 root=PARTUUID=${uuid} "
+            'rw rootwait smsc95xx.macaddr="${usbethaddr}"',
+            f"setenv bootargs console=ttyS1,115200 console=tty0 "
+            f"ip=::::{hostname}:eth0:dhcp {cryptdevice} rw rootwait "
+            # Concerning issues with network adapter names, see
+            # https://forum.iobroker.net/topic/40542/raspberry-pi4-kein-eth0-mehr/16
+            'smsc95xx.macaddr="${usbethaddr}" net.ifnames=0 biosdevname=0',
+            boot_txt_path,
+        )
+        ui.info(f"Content of {boot_txt_path}:{boot_txt_path.read_text()}")
+        ui.info("Generating...")
+        chroot_bash(root, "cd /boot/ && ./mkscr || exit 1")
+    else:
+        cmdline_txt_path = session.boot_mount_path / "cmdline.txt"
+        ui.info(f"Configuring {cmdline_txt_path}...")
+        fsutil.replace_in_file(
+            "root=/dev/mmcblk0p2",
+            f"{cryptdevice} rootfstype={plan.root_filesystem}",
+            cmdline_txt_path,
+        )
+        ui.info(f"Content of {cmdline_txt_path}:{cmdline_txt_path.read_text()}")
+
+
+def configure_encryption(
+    plan: ImagePlan, session: ImageSession, authorized_keys: Path
+) -> None:
+    root = session.root_mount_path
+    ui.info("Setup encryption...")
+    ui.info("Installing neccessary software...")
+    install_packages(
+        plan.distribution, root, " ".join(packages.get_packages("server/luks"))
+    )
+
+    dropbear_root_key_path = root / "etc/dropbear/root_key"
+    ui.info(f"Adding {authorized_keys} to dropbear...")
+    runner.run(["cp", "-v", str(authorized_keys), str(dropbear_root_key_path)], sudo=True)
+
+    _configure_mkinitcpio(plan, root)
+    _register_encrypted_root(plan, session, root)
+    _configure_bootloader(plan, session, root)

lim/image/plan.py

@@ -0,0 +1,31 @@
+"""The image setup plan collected from the user's answers."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+DEFAULT_BOOT_SIZE = "+500M"
+
+
+@dataclass
+class ImagePlan:
+    operation_system: str = "linux"
+    distribution: str | None = None
+    base_download_url: str | None = None
+    image_name: str | None = None
+    image_checksum: str | None = None
+    boot_size: str = ""
+    luks_memory_cost: str | None = None
+    raspberry_pi_version: str | None = None
+    encrypt_system: bool = False
+    root_filesystem: str = ""
+    image_folder: Path = field(default_factory=Path)
+
+    @property
+    def download_url(self) -> str | None:
+        if self.base_download_url is None or self.image_name is None:
+            return None
+        return f"{self.base_download_url}{self.image_name}"
+
+    @property
+    def image_path(self) -> Path:
+        return self.image_folder / self.image_name

lim/image/raspberry.py

@@ -0,0 +1,236 @@
+"""Raspberry-Pi-specific configuration of a freshly transferred image."""
+
+from pathlib import Path
+
+from lim import device as device_module
+from lim import fsutil, runner, ui
+from lim.errors import LimError
+from lim.image.encryption import configure_encryption
+from lim.image.plan import ImagePlan
+from lim.image.session import ImageSession, chroot_bash, install_packages
+
+ADMINISTRATOR_USERNAME = "administrator"
+
+
+def configure_sudoers(root_mount_path: Path, username: str) -> None:
+    sudo_config_dir = root_mount_path / "etc/sudoers.d"
+    sudo_config_file = sudo_config_dir / username
+    sudo_config_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        sudo_config_file.write_text(f"{username} ALL=(ALL:ALL) ALL\n")
+        sudo_config_file.chmod(0o440)
+    except OSError as exc:
+        raise LimError(f"Failed to create sudoers file for {username}: {exc}") from exc
+
+
+def configure_ssh_key(
+    public_key_path: str, target_ssh_folder: Path, authorized_keys: Path
+) -> None:
+    source = Path(public_key_path)
+    if not source.is_file():
+        raise LimError(
+            f'The ssh key "{public_key_path}" can\'t be copied to '
+            f'"{authorized_keys}" because it doesn\'t exist.'
+        )
+    ui.info("Copy ssh key to target...")
+    target_ssh_folder.mkdir(parents=True, exist_ok=True)
+    authorized_keys.write_text(source.read_text())
+    ui.info(f"{authorized_keys} contains the following: {authorized_keys.read_text()}")
+    ui.info("Set permissions with chmod...")
+    target_ssh_folder.chmod(0o700)
+    authorized_keys.chmod(0o600)
+
+
+def _ensure_image_mounted(session: ImageSession) -> None:
+    ui.info("Start regular mounting procedure...")
+    if device_module.is_mounted(session.boot_partition_path):
+        ui.info(f"{session.boot_partition_path} is allready mounted...")
+    elif device_module.is_mounted(session.root_mapper_path):
+        ui.info(f"{session.root_mapper_path} is allready mounted...")
+    else:
+        session.decrypt_root()
+        session.mount_partitions()
+    if session.boot_partition_uuid is None:
+        # Partitions were mounted by an earlier run; fetch what mount_partitions
+        # would have provided so fstab/crypttab never see a None UUID.
+        session.read_partition_uuids()
+
+
+def _seed_boot_uuid(session: ImageSession) -> None:
+    fstab_path = session.root_mount_path / "etc/fstab"
+    if "/dev/mmcblk0p1" not in fstab_path.read_text():
+        # PARTUUID=/LABEL= based images (e.g. RetroPie, Manjaro ARM) have
+        # nothing to seed — that is a valid state, not an error.
+        ui.info(f"{fstab_path} does not reference /dev/mmcblk0p1. Skipping UUID seeding.")
+        return
+    ui.info(f"Seeding UUID to {fstab_path} to avoid path conflicts...")
+    fsutil.replace_in_file(
+        "/dev/mmcblk0p1", f"UUID={session.boot_partition_uuid}", fstab_path
+    )
+    ui.info(f"Content of {fstab_path}:{fstab_path.read_text()}")
+
+
+def _select_target_user(root: Path) -> tuple[str, str]:
+    """Return (default username, target username), renaming the home on request."""
+    target_home_path = root / "home"
+    home_entries = sorted(path.name for path in target_home_path.iterdir())
+    if not home_entries:
+        raise LimError(f"No home directory found under {target_home_path}.")
+    default_username = home_entries[0]
+    rename = default_username != ADMINISTRATOR_USERNAME and ui.confirm(
+        f"Should the {default_username} be renamed to {ADMINISTRATOR_USERNAME}? "
+    )
+    if not rename:
+        return default_username, default_username
+    ui.info(
+        f"Rename home directory from {target_home_path / default_username} "
+        f"to {target_home_path / ADMINISTRATOR_USERNAME}..."
+    )
+    runner.run(
+        [
+            "mv",
+            "-v",
+            str(target_home_path / default_username),
+            str(target_home_path / ADMINISTRATOR_USERNAME),
+        ],
+        sudo=True,
+        error_msg="Failed to rename home directory",
+    )
+    return default_username, ADMINISTRATOR_USERNAME
+
+
+def _change_passwords(root: Path, target_username: str) -> None:
+    password = ui.ask(
+        f"Type in new password for user root and {target_username} (leave empty to skip): "
+    )
+    if not password:
+        ui.info("No password change requested, skipped password change...")
+        return
+    repeated = ui.ask(f'Repeat new password for "{target_username}": ')
+    if password != repeated:
+        raise LimError("Passwords didn't match.")
+    ui.info("Changing passwords on target system...")
+    chroot_bash(
+        root,
+        f"( echo '{password}'; echo '{password}' ) | passwd {target_username}\n"
+        f"( echo '{password}'; echo '{password}' ) | passwd\n",
+        error_msg="Failed to change password.",
+    )
+
+
+def _configure_hostname(root: Path) -> None:
+    hostname_path = root / "etc/hostname"
+    hostname = ui.ask("Type in the hostname (leave empty to skip): ")
+    if hostname:
+        hostname_path.write_text(hostname + "\n")
+    else:
+        hostname = hostname_path.read_text().strip()
+        ui.info("No hostname change requested, skipped hostname change...")
+    ui.info(f"Used hostname is: {hostname}")
+
+
+def _update_system(plan: ImagePlan, root: Path) -> None:
+    if not ui.confirm("Should the system be updated?"):
+        return
+    ui.info("Updating system...")
+    if plan.distribution in ("arch", "manjaro"):
+        chroot_bash(root, "pacman --noconfirm -Syyu")
+    elif plan.distribution in ("moode", "retropie"):
+        chroot_bash(root, "yes | apt update\nyes | apt upgrade\n")
+    else:
+        ui.warning(
+            f'System update for operation system "{plan.distribution}" '
+            "is not supported yet. Skipped."
+        )
+
+
+def _run_retropie_procedures(session: ImageSession, public_key_path: str) -> None:
+    if public_key_path:
+        (session.boot_mount_path / "ssh").write_text("\n")
+    if not ui.confirm("Should the RetroFlag specific procedures be executed?"):
+        return
+    ui.info("Executing RetroFlag specific procedures...")
+    chroot_bash(
+        session.root_mount_path,
+        'wget -O - "https://raw.githubusercontent.com/RetroFlag/'
+        'retroflag-picase/master/install_gpi.sh" | bash\n',
+    )
+
+
+def _configure_users_and_keys(session: ImageSession) -> tuple[str, Path]:
+    """Handle user rename, sudo rights and SSH key; return (public key path, authorized_keys)."""
+    root = session.root_mount_path
+    ui.info("Define target paths...")
+    default_username, target_username = _select_target_user(root)
+    renamed = default_username != target_username
+    target_user_ssh_folder = root / "home" / target_username / ".ssh"
+    target_authorized_keys = target_user_ssh_folder / "authorized_keys"
+
+    if ui.confirm(f"Should the {target_username} have sudo rights? "):
+        configure_sudoers(root, target_username)
+
+    public_key_path = ui.ask(
+        "Enter the path to the SSH key to be added to the image (default: none):"
+    )
+    if public_key_path:
+        configure_ssh_key(public_key_path, target_user_ssh_folder, target_authorized_keys)
+    else:
+        ui.info("Skipped SSH-key copying..")
+
+    ui.info("Start chroot procedures...")
+    session.mount_chroot_binds()
+    session.copy_qemu()
+    session.copy_resolv_conf()
+
+    chroot_user_home = f"/home/{target_username}/"
+    if renamed:
+        ui.info("Delete old user and create new user")
+        chroot_bash(
+            root,
+            f"userdel -r {default_username}\n"
+            f"useradd -m -d {chroot_user_home} -s /bin/bash {target_username}\n"
+            f"chown -R {target_username}:{target_username} {chroot_user_home}\n",
+            error_msg="Failed to delete old user and create new user",
+        )
+
+    if public_key_path:
+        ui.info("Chroot to set ownership...")
+        chroot_bash(
+            root,
+            f"chown -vR {target_username}:{target_username} {chroot_user_home}.ssh\n",
+        )
+
+    _change_passwords(root, target_username)
+    return public_key_path, target_authorized_keys
+
+
+def configure_raspberry_image(plan: ImagePlan, session: ImageSession) -> None:
+    _ensure_image_mounted(session)
+    root = session.root_mount_path
+    _seed_boot_uuid(session)
+
+    public_key_path, target_authorized_keys = _configure_users_and_keys(session)
+
+    _configure_hostname(root)
+
+    if plan.distribution in ("arch", "manjaro"):
+        ui.info("Populating keys...")
+        chroot_bash(
+            root,
+            "yes | pacman-key --init\nyes | pacman-key --populate archlinuxarm\n",
+        )
+
+    _update_system(plan, root)
+
+    ui.info(f"Installing software for filesystem {plan.root_filesystem}...")
+    if plan.root_filesystem == "btrfs":
+        install_packages(plan.distribution, root, "btrfs-progs")
+    else:
+        ui.info("Skipped.")
+
+    if plan.encrypt_system:
+        configure_encryption(plan, session, target_authorized_keys)
+
+    ui.info("Running system specific procedures...")
+    if plan.distribution == "retropie":
+        _run_retropie_procedures(session, public_key_path)