netpyexec.py

import socket
import subprocess
import argparse
import sys


def receive_messages(port):
    HOST = "0.0.0.0"
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((HOST, port))
    server.listen(3)
    server.settimeout(1)
    print(f"[+]listening on {port}")
    try:
        while True:
            try:
                conn, addr = server.accept()
                if conn:
                    print(f"[+]connection from {addr} accepted")
                    while True:
                        data = conn.recv(10000)
                        if not data:
                            conn.close()    
                            break
                        print(f"{data.decode()}") 
            except socket.timeout:
                continue
    except KeyboardInterrupt:
        print(f"[-]closing listener")
        server.close()

def send_messages(target, port, message):
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        client.connect((target, port))
        client.sendall(message.encode())
        print(f"Your message is successully sent to {target}:{port}")
    except OSError as e:
        print(f"Couldn't connect to socket-server. Terminating program : {e}")
    finally:
        client.close()

def delimiterCheck(Pobj):
    buffer = ""
    while True:
        character = Pobj.stdout.read(1) 
        if not character:
            break
        buffer = buffer + character
        if "<END>" in buffer:
            break
    buffer = buffer.replace("<END>","")
    return buffer

def cleanup(p):
    p.terminate()
    p.stdin.close()
    p.stdout.close()
    p.stderr.close()

def bindShell_listener(port):
    HOST = "0.0.0.0"
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((HOST, port))
    server.listen(1)
    print(f"[+]listening on {port}")
    p1 = subprocess.Popen(
        ["/bin/bash"], 
        stdin=subprocess.PIPE, 
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True)
    try:
        conn, addr = server.accept()
        if conn:
            while True:
                command = conn.recv(10000)
                if not command:
                    cleanup(p1)
                    server.close()
                    conn.close()
                    print(f"[-]closing listener")
                    sys.exit(0)
                command = command.decode()
                command = command + "\n"
                p1.stdin.write(command)
                p1.stdin.write("echo '<END>'\n")
                p1.stdin.flush()
                output = delimiterCheck(p1)
                output = output + "<END>"
                conn.sendall(output.encode())
    except BrokenPipeError:
        print("[-]shell died")
        sys.exit(0)
    except OSError as e:
        print(f"Couldn't connect to socket-server. Terminating program : {e}")
        cleanup(p1)
        server.close()

def receive_full_msg(client):
    buffer = b""
    while True:
        chunks = client.recv(1024)
        if not chunks:
            break
        buffer = buffer + chunks
        if b"<END>" in buffer:
            break
    buffer = buffer.replace(b"<END>", b"")
    return buffer
        

def send_commands(target, port):
    try:
        client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client.connect((target, port))
        while True:
            cmd = input("$> ")
            client.sendall(cmd.encode())
            output = receive_full_msg(client)
            print(output.decode())

    except KeyboardInterrupt:
        print(f"[-]closing bind shell")
    except OSError as e:
        print(f"Couldn't connect to socket-server. Terminating program : {e}")
    finally:
        client.close()


def parseArgs():
    parser = argparse.ArgumentParser(description ="take tcp server arguments")
    parser.add_argument("-l", "--listen", action="store_true", help="start listener")
    parser.add_argument("-p", "--port", metavar="PORT", help="port number")
    parser.add_argument("-t", "--target", metavar="IP", help="IP address")
    parser.add_argument("-m", "--message", help="send messages")
    parser.add_argument("-bL", "--bindListener", action="store_true", help="listen for rce")
    parser.add_argument("-bS", "--bindShell", action="store_true", help="initiate bind shell")
    return parser.parse_args()


def get_args():
    args = parseArgs()
    if (args.listen and args.port) and not (args.bindListener):
        port = int(args.port)
        receive_messages(port)
    elif args.target and args.port and args.message:
        target = args.target
        port = int(args.port)
        message = args.message
        send_messages(target, port, message)
    elif args.port and args.bindListener:
        port = int(args.port)
        bindShell_listener(port)
    elif args.target and args.port and args.bindShell:
        target = args.target
        port = int(args.port)
        send_commands(target, port)


def main():
    get_args()


if __name__ == "__main__":
    main()