Application DoS Attacks
Resource abuse and starvation
The simplest way to attack an application is to exceed expected use beyond the capacity of the environment. This is conceptually very similar to a Network DoS attack in that it prevents legitimate users from accessing the application while it is forced to deal with many false requests.
More sophisticated attacks are based on an analysis of the application and its functionality, and identification of susceptible components. This may involve overflows on application buffers to crash the components on the servers themselves, or destruction of back-end data through SQL insertion for example.
User Based Attacks
In any application that makes use of user based authentication (e.g. a username and some form of password), the authentication system may be vulnerable to DoS attack.
Login Process DoS
It may be possible to overwhelm the login process by continually sending login-requests that require the presentation tier to access the authentication mechanism, rendering it unavailable or unreasonably slow to respond.
When a user enters an incorrect username and/or password, the application should respond with a generic error message stating that the information entered was incorrect. If the application explicitly states which component of the username/password pair was incorrect then an attacker can automate the process of trying common usernames from a dictionary file in an attempt to enumerate the users of the application.
Whilst applications may handle authentication failure messages correctly, many still allow attackers to enumerate users through the forgotten password feature. Typically, this feature requires the user to enter some form of identification before re-establishing access to an account. Many forgotten password features require only the username to be entered before responding with a message as to its validity. If the application behaves in this manner, as with login messages it is a trivial exercise to automatically deduce valid usernames.
With a list of valid usernames an attacker can attempt to mount automated attacks against the authentication mechanism.
In order to mitigate dictionary attacks, many applications implement an account lockout procedure to freeze a user's access should they make too many failed login attempts. The lockout facility is designed to deny access to users performing illegal operations, or who are suspected of malicious intent.
Since this mechanism is designed to deny access to the application, if it is not properly implemented it may be abused by attackers to deny access to legitimate users. A number of strategies may be employed by the lockout facility:
Lock the account and require manual intervention to re-enable it Any form of permanent lockout should be carefully evaluated to ensure that the process used to unlock the accounts doesn't require too much resource. Care should be taken when choosing lockout mechanisms that require manual intervention since they may be difficult to action should a large number of users be locked out simultaneously.
Lock out the IP address of the user temporarily or permanently Locking out users based on their IP address could create unforeseen problems as many use shared proxy servers2 or are in NAT environments. Locking out the proxy server's IP address could inadvertently deny service to many legitimate users.
Lock the account out for a certain period of time only This is often the best choice of lockout mechanism for as it prevents attackers from performing dictionary or brute force attacks, but still prevents them from locking out legitimate users. It also requires the least resource and interaction from the provider.
Attackers can abuse the first two lockout mechanisms using the same technique:
Enumerate usernames through another vulnerability in the application
Attempt to authenticate to the site using valid usernames and incorrect passwords
Systematically lock-out the accounts after the specified number of failed attempts
At this point legitimate users will not be able to use the site, and will have to follow the account unlocking procedure.
Depending on the business requirements of the application and the account un-locking procedures, automated account locking of a large portion of the application's user base can have an immediate damaging impact on the availability of online services.
Creating multiple false users
Some applications have the requirement of allowing users to sign-up, register or join the application by a fully automated method. This typically involves the user choosing a username and password and entering their required details. If there is no manual interaction required in this process, and if the application does not provide a mechanism to ensure that it is a person entering the data, then it may be susceptible to automated attack.
An attacker could use files containing lists of usernames, passwords, telephone numbers, addresses and even fictional credit card numbers. These lists could be created by manipulating the data from common dictionaries. Once in hand, the attacker could create a program that submits the registration forms repeatedly; adding a large number of spurious users to the application.
This could in itself be a form of attack, since any statistical analysis of the user data will be largely skewed to the side of fiction. Besides the threat to business process posed by the existence of a large amount of fictional data, there is also the risk that the attacker can use these user accounts to perform transactions through the application. With a pool of thousands of fictional users at their disposal, an attacker could develop starvation attacks that would have all the users purchase goods at exactly the same time, for example.
Checks should be built in to susceptible portions of the application to ensure that a person, and not an automated script, is submitting the data. One technique used particularly in high traffic sites is for the application to generate a random sequence of characters, displaying them as images that are slightly distorted and then requires the user to enter them3. This will foil most automation attempts as image recognition software has difficulty recognising these characters.
Another technique is to send an email to the user that requires them to click on a link to activate their account. While this may deter casual attackers, those with more determination can setup a system that receives and process those emails automatically.
Each transaction performed by the application requires resources such as processing time and storage space. By triggering an excessive number of transactions, the attack may be able to prevent normal operation of the application.
Some transactions may even incur a financial cost, such as when requesting third party services that are billed per transaction. Sending SMS messages or implementing automatic call back facilities also incur costs for each transaction. If an attacker has created thousands of fictional users, then it may be possible, through the use of an automated script to perform thousands of transactions that could incur a substantial cost.
Attacking the Database
Many web applications use databases extensively to store static data, which is accessed and modified infrequently, and dynamic data which is used to manage the user sessions. Each database operation incurs an overhead in storage space and processor cycles with static limits to both these resources. Simple application functions such as searches, performing user authentication or submitting registration forms often require the database to access data and to consume resources.
An attacker needs access to a large amount of bandwidth should he wish to attempt to flood the victims internet connection. Considerably less resource may be required if the attack is instead directed at a few carefully selected database queries. Complex database queries that can be performed without authentication are the most at risk, since they consume a larger amount of resource and can be accessed by anyone. Search functions that allow users to enter queries in natural language are a good example of a complex query. These require a comparatively large amount processing time for each query, especially if they allow the use of wildcard characters.
Should thousands complex queries repeatedly be submitted, the strain on the application may affect other more critical components, and could even prevent legitimate users from performing transactions.
Session ID Exhaustion
The HTTP protocol is stateless; meaning that each request to a web server is unique and unconnected to any preceding requests. A requirement of modern web applications is that a users multiple requests to be associated with each other across a "session", requiring unique HTTP requests be tracked and connected. A session typically begins when a user logs in to the application and ends when they logout. This session management is usually implemented through a unique, random identifier, called a Session ID, created at the start of the session. The client transmits this ID with all subsequent HTTP requests so that the server can identify the user.
The session IDs and corresponding session information is usually maintained in a database or at the application level. Each session ID that is generated therefore requires resource in terms of processing time and storage space. Attackers may use this to keep requesting session ID's in an attempt to exhaust the available resources and thereby deny access to legitimate users. The attacker's ability to request that the application generate a new session ID is largely controlled by the chosen session management strategy. As far as the generation of session IDs are concerned, applications can be broken down into three broad categories:
The application generates a session ID when the user visits a specific page, without authenticating. This is the most vulnerable class of application, as the attacker can request many session IDs easily, and quickly.
The application generates a session ID only after the user authenticates and allows multiple sessions for the same user. This requires the attacker has a valid user account on the application before session ID request's can be sent, but since the application allows multiple sessions for a single user it is still relatively easy to generate many session IDs in a short space of time.
The application generates a session ID after authentication and only allows one session per user. This is a more secure approach, since the attacker will have to use multiple user accounts to cause the application to track multiple session IDs. For some applications where user accounts are granted through a manual or manually-assisted process, it will be almost impossible for an attacker to create the required number of user accounts. But, where applications are vulnerable to automated registration scripts (section 2.2.1), it is only moderately more difficult for an attacker to sign-up thousands of fictitious users and have them all log in and request session IDs at the same time.
The generation of session IDs and the resources used to manage sessions can often be overwhelmed if an attacker has the ability to generate a large number of session IDs.