## 4 Security Issues
### WEB 1.0 Attacks  
Since there were no actual capabilities for interaction between clients, the main actor of this era was the web server, which was consequently the target of most attacks. For sure the most widespread attack of this era was the _denial of service_ (DoS), where the attacker using botnets [36] or protocol vulnerabilities [37; 38] was able to divert traffic or to saturate the server resources. Saturating the server resources is commonly achieved by either consuming all of the available network resources or by forcing the allocation of all of the available memory. The first technique is, in turn, implemented in at least two variants. In the first one, the attacker can leverage traffic amplification effects: small requests, which do not saturate the attacker's bandwidth, are crafted to cause larger replies that saturate the victim's bandwidth. Proxy systems placed for performance optimization can turn against their users and exacerbate the effect [39]. In the second variant, the attacker can flood the server with connection opening (TCP SYN) requests that are never followed by the packets needed to complete the protocol, leading it to use all of the possible concurrent connections (there is an upper bound which is OS-specific and cannot be overcome) until a timeout expires. During this period, the victim cannot accept any useful connection, and as soon as timeouts expire and some slots are freed, the attacker can quickly fill them up again. The memory saturation technique can leverage both application-level vulnerabilities and network-stack-level ones. In both cases, the attacker opens a connection, and obviously the server creates a process (or a connection handler) to serve the incoming request. The attacker crafts the input stream so that the created process or handler keeps growing instead of performing some computation, sending a reply, and terminating as it usually happens. Soon all the available memory is taken up by these rogue processes and none is left for the allocation of useful ones. Also the _Defacement_ attack was popular during the past decade. The attacker exploited web server vulnerabilities to obtain enough rights to change the web site home page. The goal of this attack was to discredit the image of a company or to deliver rogue contents by leveraging a popular site. The \begin{table}
\begin{tabular}{p{71.1 pt} p{113.8 pt} p{113.8 pt} p{113.8 pt}}
**Security property** & **Violation** & **Web 1.0 attacks** & **Additional Web 2.0 attacks** \\ \hline Availability & Denying service & DoS against the server composing the application & DoS against one server of the many composing the application \\ \hline Confidentiality & Stealing data & Exploit server vulnerability (code injection, SQL injection, Cross-site scripting) & Exploit client vulnerability (hijack browsing by injecting malware on client-based execution environments) \\ \hline Integrity & Altering data & Defacement by server vulnerability exploitation & Request forgeries and session hijacking \\ \hline \end{tabular}
\end{table} 
Table 1: A summary of Web 1.0 and Web 2.0 vulnerabilities. _Defacement_ attack became a _Massive Defacement_ attack in the case where the web server rights were not properly setup. For example if the same web server was holding up multiple websites and it uses a single user/group to manage them, an attacker able to compromise one website was potentially able to compromise all of them. This vulnerability, often due to misconfiguration but sometimes due to outright lack of sufficiently expressive and granular access control mechanisms, implied that each website owner had to trust every single website owner on the same web server. Many past attacks have been performed by attackers who simply acquired a legal space into the desired web server. Once the attacker owned a spot into the attacked web server he was obviously able to attack his own web application and perform a Massive Defacement attack on the entire web server exploiting the misconfiguration of access rights.