hedockerssh 1.0.0__tar.gz

hedockerssh-1.0.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: hedockerssh
+Version: 1.0.0
+Summary: Make your Docker container available as an SSH connection.
+Author: undefined
+Author-email: undefined <hestudio@hestudio.net>
+License-Expression: MIT
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: System :: Operating System Kernels :: Linux
+Requires-Dist: passlib>=1.7.4
+Requires-Dist: rich>=15.0.0
+Requires-Python: >=3.14
+Project-URL: Homepage, https://github.com/hestudio-community/dockerssh
+Project-URL: Bug Tracker, https://github.com/hestudio-community/dockerssh/issues
+Project-URL: Blog, https://www.hestudio.net/
+Description-Content-Type: text/markdown
+
+# DockerSSH
+
+Make your Docker container available as an SSH connection.
+
+## Require
+
+1. Linux Only.
+2. bash.
+3. git.
+4. Latest docker.
+5. Root Permission.
+6. Latest Python LTS.
+7. uv
+
+## Install
+
+1. First install [uv](https://docs.astral.sh/uv).
+2. Run this command：
+
+```bash
+uv tool install hedockerssh
+```
+
+### How to use?
+
+You can view the manual using this command：
+
+```bash
+dockerssh -h
+```

hedockerssh-1.0.0/README.md

@@ -0,0 +1,30 @@
+# DockerSSH
+
+Make your Docker container available as an SSH connection.
+
+## Require
+
+1. Linux Only.
+2. bash.
+3. git.
+4. Latest docker.
+5. Root Permission.
+6. Latest Python LTS.
+7. uv
+
+## Install
+
+1. First install [uv](https://docs.astral.sh/uv).
+2. Run this command：
+
+```bash
+uv tool install hedockerssh
+```
+
+### How to use?
+
+You can view the manual using this command：
+
+```bash
+dockerssh -h
+```

hedockerssh-1.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "hedockerssh"
+version = "1.0.0"
+description = "Make your Docker container available as an SSH connection."
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "passlib>=1.7.4",
+    "rich>=15.0.0",
+]
+classifiers = [
+    "Operating System :: POSIX :: Linux",
+    "Topic :: System :: Operating System Kernels :: Linux",
+]
+license = "MIT"
+
+[[project.authors]]
+name = "undefined"
+email = "hestudio@hestudio.net"
+
+[project.urls]
+Homepage = "https://github.com/hestudio-community/dockerssh"
+"Bug Tracker" = "https://github.com/hestudio-community/dockerssh/issues"
+Blog = "https://www.hestudio.net/"
+
+[project.scripts]
+dockerssh = "hedockerssh:main"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"

hedockerssh-1.0.0/pyproject.toml.orig

@@ -0,0 +1,31 @@
+[project]
+name = "hedockerssh"
+version = "1.0.0"
+description = "Make your Docker container available as an SSH connection."
+readme = "README.md"
+authors = [
+    { name = "undefined", email = "hestudio@hestudio.net" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "passlib>=1.7.4",
+    "rich>=15.0.0",
+]
+classifiers = [
+    "Operating System :: POSIX :: Linux",
+    "Topic :: System :: Operating System Kernels :: Linux",
+]
+license = "MIT"
+
+[project.urls]
+"Homepage" = "https://github.com/hestudio-community/dockerssh"
+"Bug Tracker" = "https://github.com/hestudio-community/dockerssh/issues"
+"Blog" = "https://www.hestudio.net/"
+
+
+[project.scripts]
+dockerssh = "hedockerssh:main"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"

hedockerssh-1.0.0/src/hedockerssh/__init__.py

@@ -0,0 +1,161 @@
+import argparse
+import platform
+import sys
+
+from hedockerssh.controller import container_manager
+from hedockerssh.controller import env_manager
+
+
+import shutil
+import subprocess
+
+
+def dockerchecker() -> bool:
+    dockercmd = shutil.which("docker")
+    if not dockercmd:
+        return False
+
+    r = subprocess.run(
+        [dockercmd, "info", "--format", "{{.ServerVersion}}"],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    return r.returncode == 0
+
+
+def main() -> None:
+    if not platform.system() == "Linux":
+        print("This program runs exclusively on Linux systems.")
+        sys.exit(1)
+    if not dockerchecker():
+        print("You do not have permission to use Docker.")
+        sys.exit(1)
+
+    # parser router
+    parser = argparse.ArgumentParser()
+
+    # /
+    parser_sub = parser.add_subparsers(dest="cmd", required=True, metavar="<command>")
+    container_parser = parser_sub.add_parser("container", help="Manager Container.")
+    env_parser = parser_sub.add_parser("env", help="Manager Environment.")
+
+    # /env
+    env_parser_sub = env_parser.add_subparsers(
+        dest="subcmd", required=True, metavar="<command>"
+    )
+    env_parser_sub.add_parser("list", help="List Installed Environment.")
+    install_env_parser = env_parser_sub.add_parser(
+        "install", help="Install Environment."
+    )
+    remove_env_parser = env_parser_sub.add_parser(
+        "remove", help="Remove Installed Environment."
+    )
+
+    # /env/install
+    install_env_parser.add_argument(
+        "-p", "--platform", required=True, type=str, help="e.g. linux/amd64"
+    )
+    install_env_parser.add_argument(
+        "-l", "--libc", required=True, type=str, help="e.g. gnu or musl"
+    )
+
+    # /env/remove
+    remove_env_parser.add_argument(
+        "-e",
+        "-env",
+        "--enviromnemt",
+        required=True,
+        type=str,
+        help="e.g. linux/amd64/gnu",
+    )
+
+    # /container
+    container_parser_sub = container_parser.add_subparsers(
+        dest="subcmd", required=True, metavar="<command>"
+    )
+    new_container_parser = container_parser_sub.add_parser("new", help="New Container.")
+    container_parser_sub.add_parser("list", help="List Container.")
+    resetpasswd_container_parser = container_parser_sub.add_parser(
+        "resetpasswd", help="Reset Container Password."
+    )
+    start_container_parser = container_parser_sub.add_parser(
+        "start", help="Start Container."
+    )
+    stop_container_parser = container_parser_sub.add_parser(
+        "stop", help="Stop Container."
+    )
+    restart_container_parser = container_parser_sub.add_parser(
+        "restart", help="Restart Container."
+    )
+    remove_container_parser = container_parser_sub.add_parser(
+        "remove", help="Remove Container."
+    )
+
+    # /container/new
+    new_container_parser.add_argument("-i", "--image", type=str, required=True)
+    new_container_parser.add_argument(
+        "-e",
+        "-env",
+        "--enviromnemt",
+        type=str,
+        required=True,
+        help="e.g. linux/amd64/gnu",
+    )
+    new_container_parser.add_argument("-p", "--port", type=int)
+    new_container_parser.add_argument("--passwd", type=str)
+
+    # /container/resetpasswd
+    resetpasswd_container_parser.add_argument(
+        "container", type=str, metavar="<container>"
+    )
+    resetpasswd_container_parser.add_argument("--passwd", type=str)
+
+    # /container/start
+    start_container_parser.add_argument("container", type=str, metavar="<container>")
+    # /container/stop
+    stop_container_parser.add_argument("container", type=str, metavar="<container>")
+    # /container/restart
+    restart_container_parser.add_argument("container", type=str, metavar="<container>")
+    # /container/remove
+    remove_container_parser.add_argument("container", type=str, metavar="<container>")
+
+    # args router
+    args = parser.parse_args()
+
+    match args.cmd:
+        case "container":
+            match args.subcmd:
+                case "new":
+                    container_manager.new_container(
+                        port=args.port,
+                        image=args.image,
+                        passwd=args.passwd,
+                        env=args.enviromnemt,
+                    )
+                case "list":
+                    container_manager.list_container()
+                case "resetpasswd":
+                    container_manager.resetpasswd_container(args.passwd, args.container)
+                case "start":
+                    container_manager.start_container(args.container)
+                case "stop":
+                    container_manager.stop_container(args.container)
+                case "restart":
+                    container_manager.restart_container(args.container)
+                case "remove":
+                    container_manager.remove_container(args.container)
+                case _:
+                    container_parser.print_usage()
+        case "env":
+            match args.subcmd:
+                case "list":
+                    env_manager.listinstalledenv()
+                case "install":
+                    env_manager.installenv(platform=args.platform, libc=args.libc)
+                case "remove":
+                    env_manager.removeinstalledenv(env=args.enviromnemt)
+                case _:
+                    parser.print_usage()
+        case _:
+            parser.print_usage()

hedockerssh-1.0.0/src/hedockerssh/buildprofile/build.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+export BASEPATH="/var/lib/dockerssh/server"
+export SCRIPTPATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+export PLATFORM=$1
+export LIBC=$2
+
+echo "BASEPATH=$BASEPATH"
+echo "SCRIPTPATH=$SCRIPTPATH"
+echo "PLATFORM=$PLATFORM"
+echo "LIBC=$LIBC"
+
+if [[ ! -n $PLATFORM || ! -n $LIBC ]]; then
+    echo "require platform and libc."
+    exit
+fi
+
+mkdir -p $BASEPATH
+cd $BASEPATH
+
+if [[ $EUID -eq 0 ]]; then
+    echo "script run with root permission."
+else
+    echo "script run without root permission."
+    exit
+fi
+
+if command -v docker &>/dev/null; then
+    echo "docker already install."
+else
+    echo "docker not install."
+    exit 
+fi
+
+if command -v git &>/dev/null; then
+    echo "git already install."
+else
+    echo "git not install."
+    exit 
+fi
+
+if [[ -f $SCRIPTPATH/docker/$LIBC ]]; then
+    export DROPBEAR_BUILDPATH="$BASEPATH/$PLATFORM/$LIBC"
+    echo "DROPBEAR_BUILDPATH=$BASEPATH/$PLATFORM/$LIBC"
+    if [ -e "$DROPBEAR_BUILDPATH" ]; then
+        rm -rf "$DROPBEAR_BUILDPATH"
+        echo remove "$DROPBEAR_BUILDPATH"
+    fi
+    mkdir -p $DROPBEAR_BUILDPATH
+    cd $DROPBEAR_BUILDPATH
+    cp $SCRIPTPATH/scripts/* $DROPBEAR_BUILDPATH
+    cp $SCRIPTPATH/docker/$LIBC $DROPBEAR_BUILDPATH/Dockerfile
+    git clone https://github.com/mkj/dropbear.git --depth 1
+    docker build --platform $PLATFORM -t dockerssh-build-$LIBC .
+    docker run --platform $PLATFORM -it --rm -v $DROPBEAR_BUILDPATH:/build dockerssh-build-$LIBC bash build.sh
+    cp $SCRIPTPATH/public/* $DROPBEAR_BUILDPATH/out
+else
+    echo "dockerfile $LIBC not found."
+    exit
+fi

hedockerssh-1.0.0/src/hedockerssh/buildprofile/docker/gnu

@@ -0,0 +1,6 @@
+FROM ubuntu:latest
+
+WORKDIR /build
+RUN apt update -y
+RUN apt install bash -y
+RUN apt install build-essential -y

hedockerssh-1.0.0/src/hedockerssh/buildprofile/docker/musl

@@ -0,0 +1,6 @@
+FROM alpine:latest
+
+WORKDIR /build
+RUN apk update
+RUN apk add --no-cache bash
+RUN apk add --no-cache build-base

hedockerssh-1.0.0/src/hedockerssh/buildprofile/public/resetpasswd

@@ -0,0 +1,10 @@
+#!/bin/sh
+if [ -n "$DOCKERSSH_PASSWD" ]; then
+    HASH=$(echo "$DOCKERSSH_PASSWD" | base64 -d)
+    if grep -q '^root:' /etc/shadow 2>/dev/null; then
+        sed -i "s|^root:.*|root:${HASH}:0:0:99999:7:::|" /etc/shadow
+    else
+        echo "root:${HASH}:0:0:99999:7:::" >> /etc/shadow
+    fi
+    unset DOCKERSSH_PASSWD
+fi

hedockerssh-1.0.0/src/hedockerssh/buildprofile/public/run

@@ -0,0 +1,10 @@
+#!/bin/sh
+sh /var/lib/dockerssh/bin/resetpasswd $@
+mkdir -p /var/lib/dockerssh/etc
+/var/lib/dockerssh/bin/dropbearkey -t rsa -f /var/lib/dockerssh/etc/dropbear_rsa_host_key > /dev/null
+/var/lib/dockerssh/bin/dropbearkey -t ecdsa -f /var/lib/dockerssh/etc/dropbear_ecdsa_host_key > /dev/null
+/var/lib/dockerssh/bin/dropbearkey -t ed25519 -f /var/lib/dockerssh/etc/dropbear_ed25519_host_key > /dev/null
+/var/lib/dockerssh/bin/dropbear -F -p 22 \
+    -r /var/lib/dockerssh/etc/dropbear_rsa_host_key \
+    -r /var/lib/dockerssh/etc/dropbear_ecdsa_host_key \
+    -r /var/lib/dockerssh/etc/dropbear_ed25519_host_key

hedockerssh-1.0.0/src/hedockerssh/buildprofile/scripts/build.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+export DROPBEAR_BUILDPATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+cd $DROPBEAR_BUILDPATH
+echo "DROPBEAR_BUILDPATH=$DROPBEAR_BUILDPATH"
+
+cd $DROPBEAR_BUILDPATH/dropbear
+./configure --disable-zlib
+make
+
+cd $DROPBEAR_BUILDPATH
+export DROPBEAR_OUT=$DROPBEAR_BUILDPATH/out
+echo "DROPBEAR_OUT=$DROPBEAR_OUT"
+mkdir -p $DROPBEAR_OUT
+cp $DROPBEAR_BUILDPATH/dropbear/dropbear $DROPBEAR_OUT
+cp $DROPBEAR_BUILDPATH/dropbear/dropbearconvert $DROPBEAR_OUT
+cp $DROPBEAR_BUILDPATH/dropbear/dropbearkey $DROPBEAR_OUT

hedockerssh-1.0.0/src/hedockerssh/controller/container_manager.py

@@ -0,0 +1,44 @@
+from hedockerssh.services import newcontainer
+from hedockerssh.services import containermanager
+from rich.table import Table
+from rich.console import Console
+
+
+def new_container(port: int | None, image: str, passwd: str | None, env: str):
+    newcontainer.single(port, image, passwd, env)
+
+
+def list_container():
+    containerlist = containermanager.list_container()["containerlist"]
+    table = Table()
+    table.add_column("NAME")
+    table.add_column("PORT")
+    table.add_column("IMAGE")
+    table.add_column("LIBC")
+    table.add_column("PLATFORM")
+
+    for i in containerlist:
+        table.add_row(i["name"], str(i["port"]), i["image"], i["libc"], i["platform"])
+
+    console = Console()
+    console.print(table)
+
+
+def resetpasswd_container(passwd: str | None, container: str):
+    containermanager.resetpasswd(passwd, container)
+
+
+def start_container(container: str):
+    containermanager.start_container(container)
+
+
+def stop_container(container: str):
+    containermanager.stop_container(container)
+
+
+def restart_container(container: str):
+    containermanager.restart_container(container)
+
+
+def remove_container(container: str):
+    containermanager.remove_container(container)

hedockerssh-1.0.0/src/hedockerssh/controller/env_manager.py

@@ -0,0 +1,25 @@
+from rich.table import Table
+from rich.console import Console
+
+from hedockerssh.services import envmanager
+
+
+def listinstalledenv():
+    envlist = envmanager.listinstalledenv()
+    table = Table()
+    table.add_column("PLATFORM")
+    table.add_column("LIBC")
+
+    for i in envlist:
+        base, libc = i.rsplit("/", 1)
+        table.add_row(base, libc)
+
+    console = Console()
+    console.print(table)
+
+
+def installenv(platform: str, libc: str):
+    envmanager.installenv(platform, libc)
+
+def removeinstalledenv(env: str):
+    envmanager.removeinstalledenv(env)

hedockerssh-1.0.0/src/hedockerssh/services/containermanager.py

@@ -0,0 +1,149 @@
+import subprocess
+import json
+
+from hedockerssh.services.core.tools import generatepasswd
+
+
+def list_container():
+    try:
+        originoutput = subprocess.run(
+            [
+                "docker",
+                "ps",
+                "-a",
+                "--filter",
+                "label=dockerssh",
+                "--format",
+                '{"name":"{{.Names}}", "port":{{.Label "dockerssh"}}, "image":"{{.Image}}","libc":"{{.Label "dockerssh-libc"}}", "platform":"{{.Label "dockerssh-platform"}}"}',
+            ],
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(e.stderr.decode())
+        return {"code": "ERROR_PROCESS_ERROR"}
+
+    containerliststr = str(originoutput.stdout.decode("utf-8")).split("\n")[:-1]
+    containerlist = []
+    for i in containerliststr:
+        containerlist.append(json.loads(i))
+    return {"code": "SUCCESS", "containerlist": containerlist}
+
+
+def resetpasswd(passwd: str | None, container: str):
+    if not container[0:10] == "dockerssh-":
+        print("This container is not a dockerssh container.")
+        return {"code": "ERROR_NO_DOCKERSSH_CONTAINER"}
+
+    if passwd == None:
+        passwd = generatepasswd.generatepasswd()
+        print(f"PASSWORD: {passwd}")
+        print("The password will only appear ONCE!!!")
+    passwd_base64 = generatepasswd.generatepasswdhash(passwd)
+
+    try:
+        subprocess.run(
+            [
+                "docker",
+                "exec",
+                "-e",
+                f"DOCKERSSH_PASSWD={passwd_base64}",
+                container,
+                "/var/lib/dockerssh/bin/resetpasswd",
+            ],
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(e.stderr.decode())
+        return {"code": "ERROR_PROCESS_ERROR"}
+    return {"code": "SUCCESS", "passwd": passwd}
+
+
+def start_container(container: str):
+    if not container[0:10] == "dockerssh-":
+        print("This container is not a dockerssh container.")
+        return {"code": "ERROR_NO_DOCKERSSH_CONTAINER"}
+    try:
+        subprocess.run(
+            [
+                "docker",
+                "start",
+                container,
+            ],
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(e.stderr.decode())
+        return {"code": "ERROR_PROCESS_ERROR"}
+    return {"code": "SUCCESS"}
+
+
+def stop_container(container: str):
+    if not container[0:10] == "dockerssh-":
+        print("This container is not a dockerssh container.")
+        return {"code": "ERROR_NO_DOCKERSSH_CONTAINER"}
+    try:
+        subprocess.run(
+            [
+                "docker",
+                "stop",
+                container,
+            ],
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(e.stderr.decode())
+        return {"code": "ERROR_PROCESS_ERROR"}
+    return {"code": "SUCCESS"}
+
+
+def restart_container(container: str):
+    if not container[0:10] == "dockerssh-":
+        print("This container is not a dockerssh container.")
+        return {"code": "ERROR_NO_DOCKERSSH_CONTAINER"}
+    try:
+        subprocess.run(
+            [
+                "docker",
+                "restart",
+                container,
+            ],
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(e.stderr.decode())
+        return {"code": "ERROR_PROCESS_ERROR"}
+    return {"code": "SUCCESS"}
+
+
+def remove_container(container: str):
+    if not container[0:10] == "dockerssh-":
+        print("This container is not a dockerssh container.")
+        return {"code": "ERROR_NO_DOCKERSSH_CONTAINER"}
+    try:
+        subprocess.run(
+            [
+                "docker",
+                "stop",
+                container,
+            ],
+            capture_output=True,
+            check=True,
+        )
+        subprocess.run(
+            [
+                "docker",
+                "rm",
+                container,
+            ],
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(e.stderr.decode())
+        return {"code": "ERROR_PROCESS_ERROR"}
+    return {"code": "SUCCESS"}

hedockerssh-1.0.0/src/hedockerssh/services/core/env.py

@@ -0,0 +1,3 @@
+import pathlib
+
+BASEPATH = pathlib.Path(__file__).resolve().parent.parent.parent

hedockerssh-1.0.0/src/hedockerssh/services/core/tools/generatepasswd.py

@@ -0,0 +1,15 @@
+import base64
+import secrets
+import passlib.hash
+
+
+def generatepasswdhash(passwd: str) -> str:
+    passwd_base64 = base64.b64encode(
+        str(passlib.hash.sha512_crypt.hash(passwd)).encode("utf-8")
+    )
+    return passwd_base64.decode("utf-8")
+
+
+def generatepasswd() -> str:
+    passwd = secrets.token_hex(8)
+    return passwd

hedockerssh-1.0.0/src/hedockerssh/services/core/tools/port_services.py

@@ -0,0 +1,18 @@
+import random
+import socket
+
+
+def is_port_in_use(port: int, host: str = "0.0.0.0") -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.bind((host, port))
+            return False
+        except OSError:
+            return True
+
+
+def generate_port():
+    while True:
+        port = random.randint(49152, 65535)
+        if not is_port_in_use(port):
+            return port

hedockerssh-1.0.0/src/hedockerssh/services/envmanager.py

@@ -0,0 +1,65 @@
+import subprocess
+import pathlib
+import shutil
+
+from hedockerssh.services.core.env import BASEPATH
+
+
+def listplatformsupport() -> dict:
+    try:
+        origin = subprocess.run(
+            ["docker", "buildx", "ls", "--format", "{{.Platforms}}"],
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(e.stderr.decode())
+        return {"code": "ERROR_PROCESS_ERROR"}
+    return {
+        "code": "SUCCESS",
+        "platformsupport": origin.stdout.decode("utf-8")
+        .replace("\n", "")
+        .replace(" ", "")
+        .split(","),
+    }
+
+
+def checkplatformsupport(platform: str) -> bool:
+    if platform in listplatformsupport()["platformsupport"]:
+        return True
+    else:
+        return False
+
+
+def listinstalledenv() -> list:
+    base = pathlib.Path("/var/lib/dockerssh/server")
+    return sorted("/".join(p.parts[-3:]) for p in base.glob("*/*/*"))
+
+
+def checkinstalledenv(env: str) -> bool:
+    if env in listinstalledenv():
+        return True
+    else:
+        return False
+
+
+def installenv(platform: str, libc: str):
+    if not checkplatformsupport(platform):
+        print("Your Docker doesn't support this platform.")
+        return {"code": "ERROR_PLATFORM_NOT_SUPPORT"}
+    subprocess.run(["bash", f"{BASEPATH}/buildprofile/build.sh", platform, libc])
+    return {"code": "SUCCESS"}
+
+
+def removeinstalledenv(env: str):
+    if not checkinstalledenv(env):
+        print("The platform is not installed.")
+        return {"code": "ERROR_NOT_INSTALLED"}
+
+    try:
+        shutil.rmtree(f"/var/lib/dockerssh/server/{env}")
+    except PermissionError:
+        print("Permission denied.")
+        return {"code": "ERROR_NO_PERMISSION"}
+    
+    return {"code": "SUCCESS"}

hedockerssh-1.0.0/src/hedockerssh/services/newcontainer.py

@@ -0,0 +1,69 @@
+import secrets
+import subprocess
+
+
+from hedockerssh.services.core.env import BASEPATH
+from hedockerssh.services.core.tools import port_services
+from hedockerssh.services.core.tools import generatepasswd
+from hedockerssh.services.envmanager import checkinstalledenv
+
+
+def single(port: int | None, image: str, passwd: str | None, env: str) -> dict:
+    if not checkinstalledenv(env):
+        print("The platform is not installed.")
+        return {"code": "ERROR_NOT_INSTALLED"}
+
+    base, libc = env.rsplit("/", 1)
+
+    if port == None:
+        port = port_services.generate_port()
+        print(f"PORT: {port}")
+    else:
+        if not (1 <= port <= 65535):
+            print("the port must be between 1 and 65535. exiting...")
+            return {"code": "ERROR_PORT_SCOPE"}
+        elif port_services.is_port_in_use(port):
+            print("this port is already in use. exiting...")
+            return {"code": "ERROR_PORT_USED"}
+
+    if passwd == None:
+        passwd = generatepasswd.generatepasswd()
+        print(f"PASSWORD: {passwd}")
+        print("The password will only appear ONCE!!!")
+    passwd_base64 = generatepasswd.generatepasswdhash(passwd)
+
+    try:
+        subprocess.run(
+            [
+                "docker",
+                "run",
+                "--name",
+                f"dockerssh-{secrets.token_hex(4)}",
+                "--platform",
+                base,
+                "-d",
+                "-it",
+                "-l",
+                f"dockerssh={port}",
+                "-l",
+                f"dockerssh-libc={libc}",
+                "-l",
+                f"dockerssh-platform={base}",
+                "-v",
+                f"/var/lib/dockerssh/server/{env}/out:/var/lib/dockerssh/bin:ro",
+                "-p",
+                f"{str(port)}:22",
+                "-e",
+                f"DOCKERSSH_PASSWD={passwd_base64}",
+                image,
+                "sh"
+                "/var/lib/dockerssh/bin/run",
+            ],
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(e.stderr.decode())
+        return {"code": "ERROR_PROCESS_ERROR"}
+
+    return {"code": "SUCCESS", "port": port, "passwd": passwd, "image": image}