ssh-mole

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

# ┏━┓┏━┓╻ ╻   ┏┳┓┏━┓╻  ┏━╸
# ┗━┓┗━┓┣━┫╺━╸┃┃┃┃ ┃┃  ┣╸
# ┗━┛┗━┛╹ ╹   ╹ ╹┗━┛┗━╸┗━╸

# MIT License
#
# Copyright (c) 2017 Shane R. Spencer
#
# 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.

from __future__ import print_function, unicode_literals

import os
import sys
import socket
import tempfile
import select
import struct
import argparse

__git_ident__ = '$Id$'
__git_export_subst__ = '$Format:%ci$ ($Format:%h$)'

__version__ = '0.01'

RECV_SIZE = 1024

# FROM: http://api.libssh.org/rfc/PROTOCOL.agent

SSH_AGENTC_REQUEST_RSA_IDENTITIES = 1
SSH_AGENTC_RSA_CHALLENGE = 3
SSH_AGENTC_ADD_RSA_IDENTITY = 7
SSH_AGENTC_REMOVE_RSA_IDENTITY = 8
SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES = 9
SSH_AGENTC_ADD_RSA_ID_CONSTRAINED = 24

SSH2_AGENTC_REQUEST_IDENTITIES = 11
SSH2_AGENTC_SIGN_REQUEST = 13
SSH2_AGENTC_ADD_IDENTITY = 17
SSH2_AGENTC_REMOVE_IDENTITY = 18
SSH2_AGENTC_REMOVE_ALL_IDENTITIES = 19
SSH2_AGENTC_ADD_ID_CONSTRAINED = 25

SSH_AGENTC_ADD_SMARTCARD_KEY = 20
SSH_AGENTC_REMOVE_SMARTCARD_KEY = 21
SSH_AGENTC_LOCK = 22
SSH_AGENTC_UNLOCK = 23
SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED = 26

SSH_AGENT_FAILURE = 5
SSH_AGENT_SUCCESS = 6

SSH_AGENT_RSA_IDENTITIES_ANSWER = 2
SSH_AGENT_RSA_RESPONSE = 4

SSH2_AGENT_IDENTITIES_ANSWER = 12
SSH2_AGENT_SIGN_RESPONSE = 14

SSH_AGENT_CONSTRAIN_LIFETIME = 1
SSH_AGENT_CONSTRAIN_CONFIRM = 2

SSH_AGENT_REQUEST_TYPES = [
    x for x in locals().keys() if x.startswith('SSH_AGENTC') or x.startswith('SSH2_AGENTC')
]

SSH_MOLEC_SEND_SOURCE_FILE = -1

SSH_MOLEC_RECEIVE = 200
SSH_MOLEC_RECEIVE_STREAM = 201
SSH_MOLEC_SEND = 220
SSH_MOLEC_SEND_STREAM = 221

SSH_MOLE_FAILURE = SSH_AGENT_FAILURE
SSH_MOLE_SUCCESS = SSH_AGENT_SUCCESS

SSH_MOLE_REQUEST_TYPES = [
    x for x in locals().keys() if x.startswith('SSH_MOLEC')
]

# ┏┳┓┏━┓╻┏┓╻
# ┃┃┃┣━┫┃┃┗┫
# ╹ ╹╹ ╹╹╹ ╹

def main_old():

    p = argparse.ArgumentParser()

    p.add_argument('command')
    p.add_argument('remaining', nargs=argparse.REMAINDER)

    args = p.parse_args()

    listen_file_fileno, listen_file_path = tempfile.mkstemp()
    os.close(listen_file_fileno)
    os.remove(listen_file_path)

    fork_pid = os.fork()

    if fork_pid == 0:

        os.environ['SSH_ORIG_AUTH_SOCK'] = os.environ['SSH_AUTH_SOCK']
        os.environ['SSH_AUTH_SOCK'] = listen_file_path
        os.execvp(args.remaining[0], args.remaining)

    else:

        socket_data_by_fileno = {}

        def close_socket_delete_data(socket_data):
            if not socket_data:
                return

            try:
                socket_data['socket'].close()
            except:
                pass

            try:
                del(socket_data_by_fileno[socket_data['fileno']])
            except:
                pass

        def create_socket_data(type, socket):
            """ Create a self referencing dict with common socket parameters """
            data = {
                'type': type,
                'socket': socket,
                'fileno': socket.fileno()
            }
            data[type + '_data'] = data

            return data

        listen_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        listen_socket.bind(listen_file_path)
        listen_socket.listen(5)

        listen_data = create_socket_data('listen', listen_socket)

        socket_data_by_fileno[listen_socket.fileno()] = listen_data

        while True:

            wait_child_pid, wait_child_status = os.waitpid(fork_pid, os.P_NOWAIT)

            if wait_child_pid == fork_pid:
                break

            ##fixme
            import time
            time.sleep(0.1)

            socket_fileno_read_list, socket_fileno_write_list, socket_fileno_error_list = select.select(
                socket_data_by_fileno.keys(),
                [],
                [],
                1
            )

            for socket_fileno in socket_fileno_read_list:

                socket_data = socket_data_by_fileno[socket_fileno]

                listen_data = socket_data.get('listen_data')
                downstream_data = socket_data.get('downstream_data')
                downstream_protocol_data = socket_data.get('downstream_protocol_data')
                upstream_data = socket_data.get('upstream_data')

                if socket_data['type'] == 'listen':

                    # ╻  ╻┏━┓╺┳╸┏━╸┏┓╻
                    # ┃  ┃┗━┓ ┃ ┣╸ ┃┗┫
                    # ┗━╸╹┗━┛ ╹ ┗━╸╹ ╹

                    downstream_socket, downstream_addr = listen_data['socket'].accept()
                    downstream_socket.setblocking(0)

                    downstream_data = create_socket_data('downstream', downstream_socket)

                    socket_data_by_fileno[downstream_socket.fileno()] = downstream_data

                elif socket_data['type'] == 'downstream':

                    # ╺┳┓┏━┓╻ ╻┏┓╻┏━┓╺┳╸┏━┓┏━╸┏━┓┏┳┓
                    #  ┃┃┃ ┃┃╻┃┃┗┫┗━┓ ┃ ┣┳┛┣╸ ┣━┫┃┃┃
                    # ╺┻┛┗━┛┗┻┛╹ ╹┗━┛ ╹ ╹┗╸┗━╸╹ ╹╹ ╹

                    chunk = downstream_data['socket'].recv(RECV_SIZE)

                    #FIXME: MOVE TO PROTOCOL HANDLER
                    if not upstream_data:
                        upstream_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

                        upstream_data = create_socket_data('upstream', upstream_socket)

                        upstream_data['downstream_data'] = downstream_data
                        downstream_data['upstream_data'] = upstream_data

                        socket_data_by_fileno[upstream_socket.fileno()] = upstream_data

                        upstream_data['socket'].connect(os.environ['SSH_AUTH_SOCK'])
                        upstream_socket.setblocking(0) #This has to come after connect on Cygwin.. so here it is

                    if not chunk:
                        close_socket_delete_data(downstream_data)
                        close_socket_delete_data(upstream_data)
                    else:
                        if not downstream_protocol_data:

                            downstream_protocol_data = {
                                'type': 'SSH_AGENT' #INNOCENT UNTIL PROVEN GUILTY
                            }

                            socket_data['downstream_protocol_data'] = downstream_protocol_data

                            if len(chunk) < 5:
                                print 'SENDING SOURCE'
                                downstream_protocol_data['type'] = 'SSH_MOLE'
                                downstream_protocol_data['request'] = SSH_MOLEC_SEND_SOURCE_FILE
                            else:
                                message_length, request_type = struct.unpack(">ib", chunk[:5])

                                if request_type in SSH_AGENT_REQUEST_TYPES: #REDUNDANT BUT FUN
                                    downstream_protocol_data['type'] = 'SSH_AGENT'

                                if request_type in SSH_MOLE_REQUEST_TYPES:
                                    downstream_protocol_data['type'] = 'SSH_MOLE'

                        if downstream_protocol_data['type'] == 'SSH_AGENT': #PASS THROUGH STREAM
                            upstream_data['socket'].sendall(chunk)

                        if downstream_protocol_data['type'] == 'SSH_MOLE':
                            if downstream_protocol_data['request'] == SSH_MOLEC_SEND_SOURCE_FILE:
                                downstream_data['socket'].sendall(open(os.path.basename(__file__)).read())
                                close_socket_delete_data(downstream_data)
                            print repr(('SSH_MOLE', chunk))

                elif socket_data['type'] == 'upstream':

                    # ╻ ╻┏━┓┏━┓╺┳╸┏━┓┏━╸┏━┓┏┳┓
                    # ┃ ┃┣━┛┗━┓ ┃ ┣┳┛┣╸ ┣━┫┃┃┃
                    # ┗━┛╹  ┗━┛ ╹ ╹┗╸┗━╸╹ ╹╹ ╹

                    chunk = upstream_data['socket'].recv(RECV_SIZE)

                    if not chunk:
                        close_socket_delete_data(downstream_data)
                        close_socket_delete_data(upstream_data)
                    else:
                        downstream_data['socket'].sendall(chunk)


def parse_args(argv):
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers()
    parser.add_argument('--version', action='version', version='%(prog)s 1.0')

    parser.add_argument("-k", "--key-file", default=None)
    parser.add_argument("-c", "--cert-file", default=None)
    parser.add_argument("--log-level", default="DEBUG",
                        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"])
    parser.add_argument("--log-config", default=None)

    server_parser = subparsers.add_parser('server', help='start a serving daemon')
    server_parser.add_argument("-l", "--listen-addr", required=True)
    server_parser.add_argument("-m", "--max-connections", default=16)

    server_parser.add_argument("-p", "--plugin", action='append', default=[])
    server_parser.add_argument("--timeout", type=int, default=300,
                               help="exit if have no successfull connection in this timeout")
    server_parser.add_argument("-d", "--daemon", action="store_true", help="became a daemon")
    server_parser.add_argument("--stdout-file", default=None)
    server_parser.add_argument("-s", "--show-settings", default=None, nargs='?', const='-',
                               help="dump settings dict after daemonization, not used in other cases")
    server_parser.add_argument("--working-dir", default="/tmp",
                               help="cd to this directory after daemonization, not used in other cases")
    server_parser.add_argument("--id", default="", help="Used only to find a process")
    server_parser.set_defaults(subparser_name="server")

    client_parser = subparsers.add_parser('call', help='send cmd to server')
    client_parser.add_argument("-s", "--server-addr", required=True)
    client_parser.add_argument("name")
    client_parser.add_argument("params", nargs="*")
    client_parser.set_defaults(subparser_name="call")

    keygen_parser = subparsers.add_parser('gen_keys', help='Generate keys')
    keygen_parser.add_argument("--subj",
                               default="/C=NN/ST=Some/L=Some/O=Ceph-monitor/OU=Ceph-monitor/CN=mirantis.com")
    keygen_parser.set_defaults(subparser_name="keygen")

    return parser.parse_args(argv[1:])

def main(argv):
    options = parse_args(argv)

if __name__ == '__main__':
    exit(main(sys.argv))