Tải bản đầy đủ - 0trang
11 Abusing Race Conditions
1. User accounts A, B, and C are all controlled by a single attacker.
2. User account A contains $1,000. Accounts B and C are empty.
3. The attacker initiates two balance transfers at the exact same moment (accomplished via automation—see the recipes on Perl). One balance transfer sends all
$1,000 to account B, and the other sends all $1,000 to account C.
4. The application receives request 1 and checks to ensure that the user has $1,000
in his account, and that the balance upon completion will be $0. This is true.
5. The application receives request 2 and checks to ensure that the user has $1,000
in his account, and that the balance upon completion will be $0. This is true—as
request 1 hasn’t been fully processed yet.
6. The application processes request 1, adds $1,000 to account B, and sets account
A to $0.
7. The application processes request 2, adds $1,000 to account C, and sets account
A to $0.
The attacker has just succeeded doubling his money, at the expense of the gambling
This example is referred to as a TOCTOU (Time of Check, Time of Use) race condition.
Database management systems include strong mechanisms to protect against these race
conditions, but they are not enabled by default. Actions that must be completed in a
specific order need to be wrapped up into atomic transaction requests to the database.
Protections on files must include locks or other concurrency methods. These things are
not easy to program, so please take the time to check your application.
The area where these issues have cropped up with the most severe effects have been in
multiplayer online games. The ability to duplicate in-game money or items has lead to
the collapse of in-game economies. This might not be such a big deal, except for two
aspects. First, if the game is less fun due to rampant cheating, paying players may cancel
their accounts. Second, some games allow one to buy and sell in-game items for realworld money. This represents a substantial profit motive for a hacker.
196 | Chapter 9: Seeking Design Flaws
A distributed system is one in which the failure of a
computer you didn’t even know existed can render your
own computer unusable.
cornerstone technologies in what is called “Web 2.0.” The distinction between Web
2.0 and Web 1.0 is pretty clear when you look at the interaction between the application
and the user. Web 1.0 applications were pretty simple. You had some really basic
building blocks: links and forms. You clicked on links and you filled in forms. By either
clicking the link or clicking the Submit button, you sent a bunch of inputs to the application and it returned a response. Web 2.0 applications are more interactive, and
you don’t see the whole screen change because you click a button. Instead, they can
make small requests autonomously and asynchronously to the server and then update
page can decide—for any number of reasons—that it needs data and can request it
without your clicking anything.
A trivial example application of AJAX is a running stock ticker. Every 30 seconds,
whether you click anything or not, it updates the current stock price on a part of your
web page. Another example is an events calendar that reacts to the mouse hovering
over a date, rather than clicking the date. As the mouse moves over a date (the onFo
the events that are scheduled for that date, and pops them up in a small window. When
the mouse moves away (the onBlur event), the dialog pops down. This behavior is not
strictly asynchronous, but it is not responding to a user’s explicit click, either.
As a tester, there are a few vital things you must realize about AJAX and how it works
in order to structure your tests for maximum benefit. Once your tests are structured
correctly, then we can give you some ideas on what to worry about from a security
point of view.
First, with an AJAX application, you have to view the application as being broken into
two parts. In the old Web 1.0 days, we didn’t worry much about “client-side” code in
our web apps. That is, there wasn’t much code of significance executing in the web
browser. When we did our tests (security or otherwise), we focused pretty exclusively
on the server and its functionality. In AJAX applications, there is significant code running in the web browser. It makes decisions, keeps track of state, and controls a lot of
the user’s experience. We now must test this code to make sure that our application
executes correctly. If we don’t, we’re omitting a significant chunk of the application
from our tests.
The next important fact to realize is that AJAX applications require many application
programming interfaces (APIs) on the server. Rather than being web pages or servlets
that serve up complete HTML, these APIs respond with XML or JSON data that the
a web application and look for all the JSPs, ASPs, or other public pages, and we were
pretty confident that we knew all the access points and input points. With AJAX, you
now need to know all the individual APIs that different AJAX objects may invoke, and
they’re not obvious from spidering a website. That’s why our first recipe, Recipe 10.1, teaches you simply how to observe these hidden APIs.
Lastly, you have to realize that failures can happen in both directions. That is, the client
can send malicious data to the server, or the server can send malicious data to the client.
Either kind of attack can create a security issue. Proxying tools like TamperData,
WebScarab, and Burp are essential because they allow you to manipulate both directions of the communications channel.
So what are some common security failures that we test for in AJAX applications? One
of the most common failures is in the security design of the APIs. Most big parts of an
authentication or authorization. That is, the AJAX APIs may not pay any attention to
cookie values, who the user is, or any part of the session’s identity. Imagine a bank
application, for example, that uses a servlet to show you a summary page with all your
the page to show those recent transactions. A common mistake in a design like this is
for that server API to fail to check the authorization of the requesting browser. That is,
the server API accepts an account number and returns the most recent five transactions
without checking to see if the current session is authorized to view transactions on that
account. Such mistakes, though obvious, are unfortunately quite common.
Another key security mistake in AJAX applications is to trust the client’s data without
verifying that it is logical and obeys business rules. Imagine that the server sends a list
will show some files as deletable and others as permanent. Some server applications
198 | Chapter 10: Attacking AJAX
assumption. So when the browser requests to delete a file, the server assumes that the
file must be one of the files that was listed as deletable, without actually checking.
One final note about AJAX and Web 2.0: although we have been speaking exclusively
much the same way. The Flash applets make HTTP requests behind the scenes, much
opaque to us. We cannot see their source code and know how they work internally,
techniques will work well for you. And the security failings that happen in AJAX applications happen just as often in Flash applications.
10.1 Observing Live AJAX Requests
Before you can test AJAX at all, you must be able to view the AJAX requests themselves.
You want to see when the request happens, the URL that is requested, and any parameters in that request.
The techniques we used in Recipes 3.3 and 3.4 are both applicable here, too. Beyond
basic HTTP interception, there are more interesting ways to observe AJAX requests.
Load your application where AJAX calls are used, and open Firebug.
In Firebug’s “Net” tab, you should see a list of all the requests issued after you browsed
to the current page. If your application regularly triggers AJAX requests (e.g., on a
timer), you should start to see them as additional requests in this tab. You may need
to move the mouse over certain elements on the page to trigger requests. Figure 10-1
shows an example of using Firebug’s Net tab to observe XMLHTTPRequests going to
you may filter by those options on the second menu bar. By clicking on any of the
individual requests, you can observe the request parameters, the HTTP headers, and
the response from the server. By viewing these requests, you can enumerate all the
various parameters and URLs your app uses for AJAX functionality.
When security experts discuss AJAX-related functionality, the one line you’ll hear over
and over again is: “AJAX increases the application’s surface area.” This means there is
an increased number of requests, parameters, or inputs where an attacker might sneak
10.1 Observing Live AJAX Requests | 199
Figure 10-1. Viewing underlying AJAX for Google maps
One aspect that is rarely discussed is that increased surface area can be of benefit to
means that there is no excuse to limit oneself to black-box AJAX testing. When each
to a wealth of information. You can see how the request is formulated—where it pulls
data from, how it serializes it, transforms it, and sends it. You can see the logic driving
the selection of data and how that logic might be used.
It’s not enough to just enumerate the requests and parameters and try difficult combinations. Now much more application functionality is exposed. In order to do web
way to peek inside.
not. You need to find them and sometimes fetch them.
In a sense, the solution is what we showed you back in Recipe 3.1: you look at the
source code of the application. In this case, look for a few specific tags, shown here:
200 | Chapter 10: Attacking AJAX