Posts

The Newbie Guide to Ethical Hacking

I hack websites. I’ve been doing it for a long time, across various industries, tech stacks, and programming languages. When I tell people what I do, especially those in the tech community, they often ask how I started and how can they learn more. So today, I’m going to give you a quick intro into the tools and tricks to get started with web hacking. The best way to start is to dive into the details, using some hacking tools.

Here’s how I recommend starting:

  1. Understand the tools of the trade
  2. Understand common attacks and defenses
  3. Practice on test sites

Since we will be focusing on web hacking, a basic understanding and/or refresher may be useful. If so, check out my post on, “Understanding HTTP Basics,” then come back. Don’t worry, its pretty simple but lays the groundwork for later.

Tools of the Trade

The first thing I think anyone trying to get involved with web app security needs to know is how to use the most common web hacking tool, the proxy. Proxies let you intercept HTTP requests and responses, allowing you to fully understand how a website works and lets you uncover security issues. I wrote a post, “Web hacking Tools: Proxies,” which walks through installing and using the most common web proxy used by security people, Burp.

After you spend some time using a web proxy, it’s pretty eye opening to see how some of your favorite sites work, under the covers at the HTTP layer. This is also super-useful during normal development to debug and troubleshoot web application problems.

Common Attacks

Next, you need to gain an understanding of the common attacks hackers use to break-in, so you can test your sites and code for these vulnerabilities. You should check out my article on the iCloud attack here. OWASP provides a list of the top 10 attacks. This is a great place to start, although I should warn you that some of them get into the weed fairly quickly. Once you understand those, you can review sites you build to make sure they are protected.

Practice makes perfect

Armed with your first hacking tool, the web proxy, and an understanding of common attacks, it’s time to put your newfound knowledge to the test with a few hacking challenges. There are a few great sites out there where you can learn and try out hacking techniques without being worried about breaking the law. These are a few of my favorites:

After you brush up on your skills, you can take it to the next level with a few public bug bounty programs. These programs are great because they pay for you finding vulnerabilities in public websites, such as Google, Facebook, and Paypal. Make sure you read all the rules before starting:

If you don’t want to deal with these companies directly, you can also join a bug bounty program through a dedicated bug bounty company. These work with various businesses to test security using a pool of freelance hackers, including you! These two are the best:

Web Hacking Tools: Proxies

Let’s take a look at HTTP proxies, the core tool for web app hackers. When you’re getting started as a hacker, an HTTP proxy is an application that runs between the browser and the server, allowing you to intercept, view, and modify HTTP requests and responses.

My favorite proxy to use is a tool called Burp, which is free and can be downloaded here (http://portswigger.net/). The free version is all we need.

Here is how you setup Burp:

First, download and run Burp locally (it’s a java app, so you may need to install the Java JRE if you don’t already have it). Next, we have to configure a few settings to ensure our browser uses Burp. I prefer to use Firefox with Burp, you can set it up without having to change system-wide settings which affect a number of programs.

After starting Burp, click on the “Proxy Tab”, then on “Options”:

Make sure the “Proxy Listeners” is running and make note of the interface, by default it is 127.0.0.1:8080. Next, scroll down to the “Intercept Client Requests” and “Intercept Server Responses” sections. Make sure the top level “Intercept requests based on the following rules” and “Intercept responses based on the following rules” are both checked. Additionally, you will want to check the third checkbox under “Intercept Server Responses” which states “Or Request Was Intercepted”. Your settings should match the screenshot below:

This will let Burp capture both the browser requests and the server responses. Next, we need to setup Firefox to use Burp as a proxy. Click on “Firefox”, then “Preferences”.

Now click on the Advanced Icon, then the Network button. It should look like the screen below:

Finally, the last step is to change the network settings. Under Connection, Configure how Firefox connects to the Internet, click on the settings button.

Change the settings so it matches the screenshot below. Select Manual Proxy Configuration and set the IP address and Port to match Burps settings, which defaults to 127.0.0.1 port 8080. Check the box to “use this proxy server for all protocols”. Finally, remove the settings in the box which says “No Proxy for” to make sure we capture local traffic (such as requests and responses to our local rails app). Click OK and then you’re all set!

Now, let’s test our setup and make sure it works. Back in Firefox, enter google.com and click Enter. If everything is setup correctly, then the browser should just hang there, waiting for the website. Your request has been captured by Burp! Go back to Burp, and you should see the HTTP request to Google in the proxy, then Intercept tab. Make sure you’re looking at the right screen on Burp. There are a ton of options, but it should look like the screen below:

Now, click the Forward button to send the request to the server. You should almost immediately get the server’s response. You then need to click the Forward button again to send the server response to the browser:

The server response to our original request to google.com is a 301 redirection (“Moved Permanently”), which tells our browser in the location header to go to www.google.com. The browser now automatically makes this request for us and you can safely forward on this request and the response. Google once again makes another redirection, this time to the SSL version of google. However, this presents a problem.

In order for Burp to connect to SSL sites, it intercepts the connection and presents its own SSL certificate to the browser. That way, Burp can still decrypt the HTTP request and response even through SSL is being used. However, the browser is smart enough to tell whether or not the SSL certificate is valid and will provide a warning to the user that the SSL certificate is not valid for the site:

Since we know we are using Burp to intercept the request, we can click on “I Understand the Risks” and then the “Add Exception” button, adding Burps SSL certificate. Next click on “Confirm Security Exception” so that the browser will let us use Burp for this SSL connection. A word of warning: Be careful when accepting this and make sure you are using Burp, otherwise do not add the exception.

Ok, now the browser makes the SSL request, which is once again captured in Burp. Keep forwarding the requests and responses until the browser shows the Google homepage.

Congratulations, you have now just taken your first step to being a web hacker!

Before we move on to hacking our first site, lets go over a few quick items that can sometimes cause problems.

Common Problems and Solutions

1. Website doesn’t show in browser

Burp will capture every request and response and wait for you to forward it to either the server or the browser. Often times, these requests and responses will queue up in Burp, and it looks like the browser has stopped responding or you cannot access the site. If you run into problems and it seems like its not working, check the proxy tab in Burp and make sure there are no requests queued up. If you are not going to manually inspect the requests and responses for a little while, its useful to toggle off the intercept mode which will just allow the requests and responses to flow freely.

2. Weird Traffic

Occasionally when using Burp, you will notice a few web requests you didn’t make. This is traffic that is either sent from a browser plugin, or from the browser itself. If you setup the proxy to be the system proxy, then you may also get other interesting traffic from other applications. Most of this traffic is harmless, but it’s useful to know what chatting plugins or applications you have on your system that are making requests. Sometimes these requests leak sensitive information so they may require a deeper inspection.

3. Proxy is refusing connections

Burp is setup and running, and the browser is configured to use Burp, but when making a request to a website in the browser you get an error message that the proxy is refusing connections. Generally this occurs because you have the wrong IP address or port for the proxy, or it’s not running. Double check both the proxy settings and the browser settings and make sure they line up.

4. No server responses

Often times you will see the browser request but not the server response. When this happens, more than likely you missed the setting in Burp to intercept the server responses. Go back to Burp, go to the Proxy tab, then the Options tab, scroll down and make sure that the “Intercept Server Responses” settings match the settings shown above.

OK, now that we have a proxy running, we can intercept traffic. Let’s start hacking away.

Defensive Hacking: How to prevent a brute force attack

Your password’s never as safe as you think it is, and understanding how to protect your website will help you from becoming the next iCloud. Today I want to look at the security weaknesses that led to brute force attacks.

Most brute force attacks work by targeting a website, typically the login page, with millions of username and password combinations until a valid combination is found. The same concept can be applied to password resets, secret questions, promotional and discount codes, and/or other “secret” information used to identify a user.

To perform a brute force attack, we need to do a few things:

  • Confirm account lockout/request throttling is disabled or easy to bypass
  • Determine the format of the username
  • Create a list of potential usernames
  • Confirm which usernames are valid
  • Test passwords for each valid username

The first step is to determine if an account lockout exists. This can be done by failing the login for a user. Next we need to figure out the format of the username. These can be significantly from one site to another, but the current trend is to use an email address since it’s easy to remember and can be used for password resets.

Here is the login page on our example site that we are targeting:

The first thing to notice is that the username is an email address. If the login screen didn’t tell us that, we may have been able to figure it out by trying to register or signup for an account. It’s pretty obvious from the signup page that an email address is used for the username:

If it’s a large public site, generally people sign up with gmail, yahoo, or other well-known email domains. Unfortunately, with the rampant hacking on the internet these days, it’s fairly easy to find massive lists of email addresses from compromised databases (https://haveibeenpwned.com/), (users.tar.gz, Adobes hacked list of 135M users). For the iCloud hack, the attackers probably started with the email addresses of the celebrities they wanted to target.

Let’s say we were (HYPOTHETICALLY) targeting James Franco’s use of our site here. First, I enter jamesfranco@gmail.com and a password then click login.

No dice. However, there is an interesting error message — “jamesfranco@gmail.com doesn’t exist!”

Determining Usernames

Now that we have our first clue, the website telling us if the username is registered or not, we need to build a list of usernames. If this was a company site, determining the email format and then creating a custom list is pretty simple. Corporate email addresses generally consist of one of the following formats:

  • firstname.lastname@company.com
  • james.franco@company.com
  • firstinitiallastname@company.com
  • jfranco@company.com
  • lastnamefirstinitial@company.com
  • francoj@company.com
  • firstname@company.com
  • james@company.com

A quick google search (http://www.wordstream.com/blog/ws/2009/09/23/find-anyones-personal-email) for the email domain will generally give you one email address from which you can deduce the format from.

For our example application, we know that the domain is onemonthsimple.com (which we found in the domain and footer), so we can start there.

Guessing Accounts

Let’s guess a few accounts and see if we can find a valid username. Manually testing a few common usernames with the @onemonthsimple.com domain is our first step. Let’s try these users:

  • Joe
  • Kate
  • Brian
  • Eric
  • Kristen
  • Emily
  • Jon
  • Chris

Wow — a few of those worked. When we guess the correct username we get an error message about the password being incorrect. We have a valid username and are on our way to breaking in!

Lets review what we already know:

Usernames are email addresses. The application will tell us if the email address is valid or not. If we find a valid email address with the wrong password, an “Incorrect Password” error message is shown. Since it is a (demo) corporate HR application, we guess correctly that most users have the @onemonthsimple.com as the email. Using this, we can create or use a list of common names and try to find out more users!

Manually guessing these usernames takes awhile. In order to find as many usernames as possible, an attacker would automate the process of trying usernames and matching the error messages to determine which ones are valid.

Automating Attacks

First, we need a larger list of names. In hacker terms, these are called dictionaries or wordlists. Based on what we know about this app, we need a wordlist of first names. Let’s grab the most popular 10,000 baby names from the US census (http://www.ssa.gov/OACT/babynames/limits.html) as a starting place.

Next, we need a way to automate the login process. For this, you can either write a small custom program or use a variety of different brute force hacking tools such as brutus or hydra. For this example, let’s just write our own. All it needs to do is:

  1. Read a file of usernames line by line
  2. Send the username to the website login
  3. Review the error message to see if the user is valid or not

Here’s the code:

require "net/http"
require "uri"
uri = URI.parse("http://localhost/sessions")
http = Net::HTTP.new(uri.host, "3000")
File.open("onemonth2013-users.txt", "r").each_line do |username| # remove the newline
  username = username.chomp
  request = Net::HTTP::Post.new(uri.request_uri)  
  request.set_form_data({"email"=>username,"password"=> "n0taL1k3lyp@ssw0rd","commit"=>
"Login"})

  response = http.request(request) 
  # If response contains incorrect password then the username is valid  
  if response.body.include? "Incorrect"
    puts "Found: #{username}"
  end
end

After this tool is run, we have a list of users for the site. Next, we rerun the script, but slightly modified. For each valid user, we try thousands of different passwords until we stop seeing the “Incorrect Password” error message — then we know we have the right username and password! Game over.

Defending against brute force attacks

Brute force attacks work because developers tip their hand to attackers by revealing critical information in error messages, fail to properly enforce account lockout and password complexity, and do not implement any form of request throttling. Let’s take a look at each one of these areas and see how you can protect your site.

Leaking Information

In our example, the login page revealed if the username was invalid or not. This is how we were able to determine valid usernames. The same thing happens with the password. This problem exists all over the Internet, just try a few favorite sites (https://secure.meetup.com/login/) and use the wrong password, does the site give you any hints you can use to break in?

The best way to prevent these types of attacks is to return a consistent error message for failed logins. Don’t give hints to hackers with verbose error messages!

Also, don’t forget the password reset functionality!

Account Lockout

Now that we have fixed the error message, we still want to strengthen the login further to prevent brute force password guessing attacks. To do this, we will add an account lockout to users when they fail the login after a certain number of times. This will prevent our script from testing millions of passwords for each account. Here is how we add the account lockout in Rails when using devise (http://rubydoc.info/github/plataformatec/devise/master/Devise/Models/Lockable):

First, make sure the devise initializer is properly setup for account lockout:

config/initializers/devise.rb
# Lock account based on failed login attempts
config.lock_strategy = :failed_attempts
# Lock and unlock based on email
config.unlock_keys = [ :email ]
# Email the user the unlock link
config.unlock_strategy = :email
# Lockout the account after 5 failed logins
config.maximum_attempts = 5
# Make sure devise has:lockable set in your model:
devise :database_authenticatable, :registerable, :recoverable, :rememberable, :trackable, :validatable, :lockable

Give it a quick test and make sure accounts are getting locked out and can be reset. If you are adding this to an existing site, you may need to run a migration to add the required devise database fields.

If you are not using devise, then you can manually add a counter in the user model and increment it for each failed login during the authentication process. However, you should use devise!

Password Complexity

Next, we want to make sure the passwords are a little more complex (http://www.sans.org/security-resources/policies/general/pdf/password-protection-policy) so that user’s cannot enter in a weak password, such as “password” or “wizard1”. There are a couple ways to do this, although I personally like the “Devise Security Extension”. This gem provides the ability to configure a number of security controls around passwords, including complexity. Check out the github project for all the details:

https://github.com/phatworx/devise_security_extension

Again, without devise, a decent option is to create a regular expression and make sure that all new passwords meet the requirements. In general, I think it’s best to require at least one number and one special character, with a minimum character length of 10. Passphrases, or passwords that are more than one word are the way to go!

Throttle Requests

Finally, we want to slow down the attackers. One common way developers do this is to implement a security control called a captcha. A captcha is a special image that is intended to be easy for humans to understand, but difficult for automated tools (like our Ruby script). In general, captchas can be annoying and lead to a poor user experience. Also, there are a few tricks hackers use to get past captchas including things like optical character recognition tools, (http://www.zdnet.com/blog/security/inside-indias-captcha-solving-economy/1835), or tricking users into solving captchas.

A better solution is to add in some form of rate limiting based on IP address after a certain amount of failed login attempts. However, be careful as this could be abused by attackers to deny access to legitimate users coming from the same IP range (think your office, coffee shop, or school). Ideally, combining the rate limiting with displaying a captcha is a fairly secure way to go to stop these types of attacks.

The best Ruby gem I’ve seen for throttling requests is rack-attack (https://github.com/kickstarter/rack-attack). Rack-attack was built by Kickstarter to stop brute force attacks. Not only can rack-attack be used to protect login pages, it can be used to protect any page on your site from brute-force attacks.

With our security fixes in place, retest your site and make sure you’ve crushed these types of bugs! If only Apple had enabled these basic login controls, maybe iCloud would be a safe place to store pictures!

How Olivia Munn’s Apple iCloud Account Got Hacked

Recently hundreds of celebrity’s private photos (including XXX photos) were leaked on the internet by unknown attackers from Apple’s iCloud. We’re interested in understanding how this happened and how we can help prevent it in the future. What weakness in Apple’s security allowed for this attack to take place?

Here is what we know:

How can we make sure our sites are not susceptible to the same types of attack?

Strong defensive programming techniques and basic web application security knowledge would have prevented this type of attack. Let’s take a deeper look at how these “brute-force” attacks work.

So what is a brute force attack?

Most brute force attacks work by targeting a website, typically the login page, with millions of username and password combinations until a valid combination is found. The same concept can be applied to password reset secret question, promo or discount codes, or other “secret” information used to identify a user.

Let’s look at a real example to understand how this works. Getting past the login screen is often the first step to breaking into most websites. But without a username and password, how can you possibly get in?

Since a python proof of concept attack script was released on github, we can take a look through the code and get a better understanding of how this attack works. The code can be found here: https://github.com/hackappcom/ibrute

First, the code reads passwords and emails from two different files. For the type of targeted attacks that were performed against celebrities such as Olivia Munn, the attacker already knew their valid email address. Emails are loaded into a variable called “apple_ids”. Loading these values can be seen on line 79 and 83:

Next, for each apple_id (email address), the script tries each password and calls the “TryPass” method, shown below on line 98.

Take a minute to read over the following code snippet that actually sends the request:

On line 39, the target URL is constructed by placing the apple_id in the URL. Next, a user-agent header is added and a json object is constructed. Presumably this information was reverse-engineering the researchers sniffing the FindMyiPhone http traffic.

Finally, the email and password value are joined together and base64 encoded into an authorization header on line 64:

It’s interesting to note that the API is using “Basic” authentication, which has a number of known security weaknesses, including the inability to perform account lockouts.

Finally, the request is sent and based on the server response, one can tell if the email and password combination is valid. This is sent for each email address, going through each password, then moving to the next email address and repeating the process. Given a long enough password list, eventually the attacker will discover the right password.

After collecting valid passwords, the attacker was able to download the iCloud backup for the user.

Apple has since closed the security bug.

In my next post, I’ll show you how to find and fix these types of security holes in your own applications.

Have any of your accounts or websites ever been hacked? Let me know what happened in the comments below!