# 【记录】使用 Termux 作为 SSH 客户端

Last updated on March 19, 2024 pm

## 安装 Termux

- 下载 termux-app（点此镜像加速）

    1
    2
    3
    4
    5

    pkg install proot-distro
    proot-distro install alpine
    proot-distro login alpine
    sed -i 's/dl-cdn.alpinelinux.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apk/repositories
    apk update && apk add openssh

## 快捷登录

    1
    2
    3
    4
    5
    6

    host SER5
      user root
      hostname limour.top
      Port 22
      # PreferredAuthentications publickey
      # IdentityFile ~/.ssh/id_rsa

    1
    2
    3
    4
    5

    nano ~/.ssh/config # 写入上面的配置文件
    ssh-keygen -t rsa
    ssh-copy-id SER5
    nano ~/.ssh/config # 将注释取消掉
    ssh SER5 # 即可直接登录

## 附加 简易上传服务

    1

    python upload.py 8000

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298

    #!/usr/bin/env python
    # -*- coding: UTF-8 -*-

    """Simple HTTP Server With Upload.
    This module builds on BaseHTTPServer by implementing the standard GET
    and HEAD requests in a fairly straightforward manner.
    """

    __version__ = "0.3.1"
    __author__ = "freelamb@126.com"
    __all__ = ["SimpleHTTPRequestHandler"]

    import os
    import sys
    import argparse
    import posixpath
    try:
        from html import escape
    except ImportError:
        from cgi import escape
    import shutil
    import mimetypes
    import re
    import signal
    from io import StringIO, BytesIO

    if sys.version_info.major == 3:
        # Python3
        from urllib.parse import quote
        from urllib.parse import unquote
        from http.server import HTTPServer
        from http.server import BaseHTTPRequestHandler
    else:
        # Python2
        reload(sys)
        sys.setdefaultencoding('utf-8')
        from urllib import quote
        from urllib import unquote
        from BaseHTTPServer import HTTPServer
        from BaseHTTPServer import BaseHTTPRequestHandler

    class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
        """Simple HTTP request handler with GET/HEAD/POST commands.
        This serves files from the current directory and any of its
        subdirectories.  The MIME type for files is determined by
        calling the .guess_type() method. And can receive file uploaded
        by client.
        The GET/HEAD/POST requests are identical except that the HEAD
        request omits the actual contents of the file.
        """

        server_version = "simple_http_server/" + __version__

        def do_GET(self):
            """Serve a GET request."""
            fd = self.send_head()
            if fd:
                shutil.copyfileobj(fd, self.wfile)
                fd.close()

        def do_HEAD(self):
            """Serve a HEAD request."""
            fd = self.send_head()
            if fd:
                fd.close()

        def do_POST(self):
            """Serve a POST request."""
            r, info = self.deal_post_data()
            print(r, info, "by: ", self.client_address)
            f = BytesIO()
            f.write(b'<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">')
            f.write(b"<html>\n<title>Upload Result Page</title>\n")
            f.write(b"<body>\n<h2>Upload Result Page</h2>\n")
            f.write(b"<hr>\n")
            if r:
                f.write(b"<strong>Success:</strong>")
            else:
                f.write(b"<strong>Failed:</strong>")
            f.write(info.encode('utf-8'))
            f.write(b"<br><a href=\".\">back</a>")
            f.write(b"<hr><small>Powered By: freelamb, check new version at ")
            f.write(b"<a href=\"https://github.com/freelamb/simple_http_server\">")
            f.write(b"here</a>.</small></body>\n</html>\n")
            length = f.tell()
            f.seek(0)
            self.send_response(200)
            self.send_header("Content-type", "text/html;charset=utf-8")
            self.send_header("Content-Length", str(length))
            self.end_headers()
            if f:
                shutil.copyfileobj(f, self.wfile)
                f.close()

        def deal_post_data(self):
            boundary = self.headers["Content-Type"].split("=")[1].encode('utf-8')
            remain_bytes = int(self.headers['content-length'])
            line = self.rfile.readline()
            remain_bytes -= len(line)
            if boundary not in line:
                return False, "Content NOT begin with boundary"
            line = self.rfile.readline()
            remain_bytes -= len(line)
            fn = re.findall(r'Content-Disposition.*name="file"; filename="(.*)"', line.decode('utf-8'))
            if not fn:
                return False, "Can't find out file name..."
            path = translate_path(self.path)
            fn = os.path.join(path, fn[0])
            while os.path.exists(fn):
                fn += "_"
            line = self.rfile.readline()
            remain_bytes -= len(line)
            line = self.rfile.readline()
            remain_bytes -= len(line)
            try:
                out = open(fn, 'wb')
            except IOError:
                return False, "Can't create file to write, do you have permission to write?"

            pre_line = self.rfile.readline()
            remain_bytes -= len(pre_line)
            while remain_bytes > 0:
                line = self.rfile.readline()
                remain_bytes -= len(line)
                if boundary in line:
                    pre_line = pre_line[0:-1]
                    if pre_line.endswith(b'\r'):
                        pre_line = pre_line[0:-1]
                    out.write(pre_line)
                    out.close()
                    return True, "File '%s' upload success!" % fn
                else:
                    out.write(pre_line)
                    pre_line = line
            return False, "Unexpect Ends of data."

        def send_head(self):
            """Common code for GET and HEAD commands.
            This sends the response code and MIME headers.
            Return value is either a file object (which has to be copied
            to the output file by the caller unless the command was HEAD,
            and must be closed by the caller under all circumstances), or
            None, in which case the caller has nothing further to do.
            """
            path = translate_path(self.path)
            if os.path.isdir(path):
                if not self.path.endswith('/'):
                    # redirect browser - doing basically what apache does
                    self.send_response(301)
                    self.send_header("Location", self.path + "/")
                    self.end_headers()
                    return None
                for index in "index.html", "index.htm":
                    index = os.path.join(path, index)
                    if os.path.exists(index):
                        path = index
                        break
                else:
                    return self.list_directory(path)
            content_type = self.guess_type(path)
            try:
                # Always read in binary mode. Opening files in text mode may cause
                # newline translations, making the actual size of the content
                # transmitted *less* than the content-length!
                f = open(path, 'rb')
            except IOError:
                self.send_error(404, "File not found")
                return None
            self.send_response(200)
            self.send_header("Content-type", content_type)
            fs = os.fstat(f.fileno())
            self.send_header("Content-Length", str(fs[6]))
            self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))
            self.end_headers()
            return f

        def list_directory(self, path):
            """Helper to produce a directory listing (absent index.html).
            Return value is either a file object, or None (indicating an
            error).  In either case, the headers are sent, making the
            interface the same as for send_head().
            """
            try:
                list_dir = os.listdir(path)
            except os.error:
                self.send_error(404, "No permission to list directory")
                return None
            list_dir.sort(key=lambda a: a.lower())
            f = BytesIO()
            display_path = escape(unquote(self.path))
            f.write(b'<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">')
            f.write(b"<html>\n<title>Directory listing for %s</title>\n" % display_path.encode('utf-8'))
            f.write(b"<body>\n<h2>Directory listing for %s</h2>\n" % display_path.encode('utf-8'))
            f.write(b"<hr>\n")
            f.write(b"<form ENCTYPE=\"multipart/form-data\" method=\"post\">")
            f.write(b"<input name=\"file\" type=\"file\"/>")
            f.write(b"<input type=\"submit\" value=\"upload\"/></form>\n")
            f.write(b"<hr>\n<ul>\n")
            for name in list_dir:
                fullname = os.path.join(path, name)
                display_name = linkname = name
                # Append / for directories or @ for symbolic links
                if os.path.isdir(fullname):
                    display_name = name + "/"
                    linkname = name + "/"
                if os.path.islink(fullname):
                    display_name = name + "@"
                    # Note: a link to a directory displays with @ and links with /
                f.write(b'<li><a href="%s">%s</a>\n' % (quote(linkname).encode('utf-8'), escape(display_name).encode('utf-8')))
            f.write(b"</ul>\n<hr>\n</body>\n</html>\n")
            length = f.tell()
            f.seek(0)
            self.send_response(200)
            self.send_header("Content-type", "text/html;charset=utf-8")
            self.send_header("Content-Length", str(length))
            self.end_headers()
            return f

        def guess_type(self, path):
            """Guess the type of a file.
            Argument is a PATH (a filename).
            Return value is a string of the form type/subtype,
            usable for a MIME Content-type header.
            The default implementation looks the file's extension
            up in the table self.extensions_map, using application/octet-stream
            as a default; however it would be permissible (if
            slow) to look inside the data to make a better guess.
            """

            base, ext = posixpath.splitext(path)
            if ext in self.extensions_map:
                return self.extensions_map[ext]
            ext = ext.lower()
            if ext in self.extensions_map:
                return self.extensions_map[ext]
            else:
                return self.extensions_map['']

        if not mimetypes.inited:
            mimetypes.init()  # try to read system mime.types
        extensions_map = mimetypes.types_map.copy()
        extensions_map.update({
            '': 'application/octet-stream',  # Default
            '.py': 'text/plain',
            '.c': 'text/plain',
            '.h': 'text/plain',
        })

    def translate_path(path):
        """Translate a /-separated PATH to the local filename syntax.
        Components that mean special things to the local file system
        (e.g. drive or directory names) are ignored.  (XXX They should
        probably be diagnosed.)
        """
        # abandon query parameters
        path = path.split('?', 1)[0]
        path = path.split('#', 1)[0]
        path = posixpath.normpath(unquote(path))
        words = path.split('/')
        words = filter(None, words)
        path = os.getcwd()
        for word in words:
            drive, word = os.path.splitdrive(word)
            head, word = os.path.split(word)
            if word in (os.curdir, os.pardir):
                continue
            path = os.path.join(path, word)
        return path

    def signal_handler(signal, frame):
        print("You choose to stop me.")
        exit()

    def _argparse():
        parser = argparse.ArgumentParser()
        parser.add_argument('--bind', '-b', metavar='ADDRESS', default='0.0.0.0', help='Specify alternate bind address [default: all interfaces]')
        parser.add_argument('--version', '-v', action='version', version=__version__)
        parser.add_argument('port', action='store', default=8000, type=int, nargs='?', help='Specify alternate port [default: 8000]')
        return parser.parse_args()

    def main():
        args = _argparse()
        # print(args)
        server_address = (args.bind, args.port)
        signal.signal(signal.SIGINT, signal_handler)
        signal.signal(signal.SIGTERM, signal_handler)
        httpd = HTTPServer(server_address, SimpleHTTPRequestHandler)
        server = httpd.socket.getsockname()
        print("server_version: " + SimpleHTTPRequestHandler.server_version + ", python_version: " + SimpleHTTPRequestHandler.sys_version)
        print("sys encoding: " + sys.getdefaultencoding())
        print("Serving http on: " + str(server[0]) + ", port: " + str(server[1]) + " ... (http://" + server[0] + ":" + str(server[1]) + "/)")
        httpd.serve_forever()

    if __name__ == '__main__':
        main()

## 附加 集成Shizuku

- ADB
- Shizuku
- PackageViewer

    1
    2
    3
    4
    5
    6

    adb devices
    .\adb.exe install -t '.\termux.apk'
    .\adb.exe install -t '.\shizuku.apk'

    adb shell
    sh /storage/emulated/0/Android/data/moe.shizuku.privileged.api/start.sh

- 在`Shizuku-在终端应用中使用Shizuku`中导出`rish`文件到`termux`
- 修改`rish`文件中的`"PKG"`为`"com.termux"`
- 在`termux`中运行`sh rish`进入`adb shell`

    1

    pm disable-user --user 0 com.android.browser

#termux #ssh
【记录】使用 Termux 作为 SSH 客户端
https://hexo.limour.top/-ji-lu--shi-yong-Termux-zuo-wei-SSH-ke-hu-duan
Author
Limour
Posted on
July 22, 2023
Updated on
March 19, 2024
Licensed under
【记录】GOST 进行 SOCKS5 的负载均衡 Previous
【记录】使用 tdl 下载 Telegram 中的视频 Next

#### Search

Keyword