Client tcp/udp e server tcp

di il
4 risposte

Client tcp/udp e server tcp

Salve, sto approcciando per la prima volta alla creazione di socket per un esame di reti di calcolatori 1 già fatto ma in cui abbiamo trattato davvero poco il discorso socket. Siccome mi piace come argomento ho deciso di approfondire. Bene ho creato questo codice :
server tcp
import socket
import threading
bind_ip="0.0.0.0"
bind_port=9999
server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind((bind_ip,bind_port))
server.listen(5)
print "[*] Listening on %s:%d" % (bind_ip,bind_port)
def handle_client(client_socket):
    request=client_socket.recv(1024)
    print "[*] Received: %s" % request
    client_socket.send("ACK!")
    client_socket.close()
    
while True:
    client,addr=server.accept()
    print "[*] Accepted connection from: %s:%d" %(addr[0],addr[1])

client_handler=threading.Thread(
     target=handle_client,args=(client,))
client_handler.start()
socket tcp
import socket 
target_host="www.google.com"
target_port=80
client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect((target_host,target_port))
client.send("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
response=client.recv(4096)
print response
socket udp
import socket
target_host="127.0.0.1"
target_port=80
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
client.sendto("AAABBBCCC",(target_host,target_port))
data,addr=client.recvfrom(4096)
print data
Quello che vorrei chiedervi, è quali comandi dare da terminale ( sia su windows che su osx ) per avviare una connessione e vedere se vada bene. Nel senso usavo nc 127.0.0.1 80 però poi il testo che mi dovrebbe apparire in entrata non mi appare, non so se mi sono spiegato :/

4 Risposte

  • Re: Client tcp/udp e server tcp

    Francamente sono un pochino confuso su quello che vorresti fare.
    prova a spiegarlo, perchè mi pare davvero oscuro il "mappazzone" che hai messo
  • Re: Client tcp/udp e server tcp

    In pratica vorrei avviare sia client.py che server.py ( entrambi tcp) solo che se vado su server.py mi avvia la console e mi dice listenig etc etc e fin qui ok, se avvio sockettcp ( cioè la parte client) mi apre la console e subito me la chiude
  • Re: Client tcp/udp e server tcp

    Qui invece mi da errori alla voce except getopt.GetoptError as err: riportando così l'errore [evaluate bhnet.py]
    Traceback (most recent call last):
    File "C:\Users\birkh\Desktop\programmi python\bhnet.py", line 53, in <module>
    except getopt.GetoptError as err:
    invalid syntax: <string>, line 53, pos 22
    import sys
    import socket 
    import getopt
    import threading
    import subprocess
    
    listen      =False
    command     =False
    upload      =False
    execute     =""
    target      =""
    upload_destination  =""
    port        =0
    def usage():
        print "Sostituto di Netcat"
        print
        print "Utilizzo: bhpnet.py -t target_host -p port"
        print "-l --listen  -" \
              "ascolta su [host]:[port] in attesa di connessioni"
        print"-e --execute=file_to_run -"\
              "esegui il file appena ricevi una connessione"
        print "-c --command   -"\
              "inizializza un comando di shell"
        print "-u --upload=destination  -"\
              "subito dopo aver ricevuto una connessione,"\
              "fai l'upload dei file e scrivi su [destination]"
        print
        print
        print "Alcuni Esempi:"
        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():
            global listen
            global port
            global execute
            global command
            global upload_destination
            global target
            if not len(sys.argv[1:]):
                usage()
                try:
                    opt,args=getopt.getopt(
                        sys.argv[1:],
                        "hle:t:p:cu:",
                        ["help","listen","execute","target","port","command","upload"])
                    except getopt.GetoptError as err:
                        print str(err)
                        usage()
                    for o,a in opts:
                        if o in("-h","--help"):
                            usage()
                            elif o in ("-l","--listen"):
                                listen=True
                            elif o in("-e","--execute"):
                                execute=a
                            elif o in ("-c","--commandshell"):
                                command=True
                            ulif o in("-u","--upload"):
                                upload_destination=a
                            elif o in("-t","--target"):
                                target=a
                            elif o in("-p","--port"):
                                port=int(a)
                                else:
                                    assert False,"Unhandled Option"
                    if not listen and len(target) and port >0:
                        #leggi il buffer della linea di comando
                        #questa operazione sarà bloccante, per cui digita
                        #CTRL-D se non vuoi leggere dallo standard input
                        buffer=sys.stdin.read()
                        client_sender(buffer)
                        if listen:
                            server_loop()
                            def client_sender(buffer):
                                client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                                try:
                                    client.connect((target,port))
                                if len(buffer):
                                    client.send(buffer)
                                    while True:
                                        recv_len=1
                                        response=""
                                        while recv_len:
                                            data =client.recv(4096)
                                            recv_len=len(data)
                                            response += data
                                            if recv_len < 4096:
                                                break
                                            print response,
                                            buffer=raw_input("")
                                            buffer += "\n"
                                            client.send(buffer)
                                            except:
                                                print "[*] Exception! Exiting."
                                                client.close()
                                                def server_loop():
                                                    global target
                                                    global port
                                                    if not len(target)
                                                    target="0.0.0.0"
                                                    server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                                                    server.bind((target,port))
                                                    server.listen(5)
                                                    while True:
                                                        client_socket, addr=server.accept()
                                                        client_thread=threading.Thread(
                                                            target=client_handler,
                                                            args=(client_socket,))
                                                        client_thread.start()
                                                    def run_command(command):
                                                        command=command.rstrip()
                                                        try:
                                                            output=subprocess.check_output(
                                                                command,
                                                                stderr=subprocess.STDOUT,
                                                                shell=True)
                                                        except:
                                                            output="Failed to execute command. \r\n"
                                                            return output
                                                        def client_handler(client_socket):
                                                            global upload
                                                            global execute
                                                            global command
                                                            if len(upload_destination):
                                                                file_buffer=""
                                                                while True:
                                                                    data=client_socket.recv(1024)
                                                                    if not data:
                                                                        break
                                                                    else:
                                                                        file_buffer += data
                                                                        try:
                                                                            file_descriptor=open(upload_destination,"wb")
                                                                            file_descriptor.write(file_buffer)
                                                                            file_descriptor.close()
                                                client_socket.send("Successfully saved to %s\r\n" \
                                                                   % upload_destination)
                                                except:
                                                    client_socket.send("Failed to save file to %s\r\n" \
                                                                       % upload destination)
                                                    if len(execute):
                                                        output=run_command(execute)
                                                        client_socket.send(output)
                                                        if command:
                                                            while True:
                                                                client_socket.send("<BHP:#>")
                                                                cmd_buffer=""
                                                                while "\n" not in cmd buffer:
                                                                    cmd_buffer += client_socket.recv(1024)
                                                                    response=run_command(cmd_buffer)
                                                                    client_socket.send(response)
                                                            
                                                            
                                                       
                                                            
                                            
            
                                
                        main()
                        
        
  • Re: Client tcp/udp e server tcp

    Ciao, non ho capito molto bene il tuo problema perché hai 3 programmi diversi:
    • Un server che ascolta sulla porta 9999
    • Un client TCP che si connette a google
    • Un client UDP che si connette in locale alla porta 80
    Per testare il server è facile, basta che ti connetti tramite telnet: "telnet 127.0.0.1 9999"
    Per avere qualche risposta da google dovresti inviargli una richiesta, ma a livello di tcp non è così immediato.
    Per testare il client UDP dovresti avere un socket UDP in ascolto sulla porta 80, che ti puoi creare sempre tramite python (per aprire le porte sotto alla 1024 devi avere i permessi di root, almeno in linux)
Devi accedere o registrarti per scrivere nel forum
4 risposte