Web application security commands a large and growing proportion of computer security practitioners' collective attention — perhaps too much. I've been known to argue that a myopic focus on particular Web-based vulnerabilities tends to discount the importance of non-Web software security risks. Regardless of the Web question, in my view too much attention paid to particular bugs comes at a steep price, especially when architectural flaws are overlooked (see Getting Past the Bug Parade).
Fortunately, by understanding the subtle relationships between Web application security and software security, we can learn more about both critical Web-based vulnerabilities and what to do about them from a secure SDLC perspective. In the end, Web application security can advance software security on several fronts (and vice versa).
Ancient History: Computer Security Meets the Internet
I started my foray into computer security in 1995. Coincidentally, this was the same time that the Web was emerging as a commercially viable business technology platform. Java was released in 1996 with much fanfare. As a Web-based platform, a significant part of the promise of Java surrounded its security claims.
In the mid-'90s, computer security was primarily the domain of the DoD and intelligence community. Computer security research at the time reflected this fact, and top-notch scientific research conferences including the IEEE Security and Privacy Symposium (known to this day as “the Oakland conference”) tended to focus on multi-level security, applied cryptography, database security, and formal methods. When Princeton professor Ed Felten and his graduate students sought to publish their research findings relating to Java security holes at Oakland, the program committee had a heated debate about the value of papers relating to security holes in commercial software systems. Fortunately, the PC made the right decision. Ed and I decided to write Java Security: Hostile Applets Holes and Antidotes (Wiley 1996) after we met at the Oakland conference in 1996.
Essentially, my first major work in computer security was a book full of information about how the Java Virtual Machine could be exploited and what kinds of risks Web-based “mobile code” (a term we coined) brought to bear.
Java Security had good and bad consequences for the field. On the plus side, the work emphasized the importance of carefully considering the attacker's perspective when crafting an Internet-based technology platform. On the negative side, the book may have adversely (and unintentionally) impacted adoption of Java over its obviously-worse-for-security language rivals C and C++. Ultimately, though Ed and I started out laser focused on how to break Java, we ultimately came to understand the wider problem of software security precisely because of our work.
The publication of Building Secure Software in 1999 with John Viega owed much to our pondering the question of how technology masters including Guy Steele and Bill Joy erred when creating Java, and where future builders of Internet-based software would go to learn about security from a software perspective. Score one for Web security.
What Web Application Vulnerabilities Teach Us
These days, everyone in computer security agrees that understanding the attacker's perspective and diving deeply into the particulars of attacks and exploits is essential to the discipline. Web application security has done much to advance this understanding.
Leading practitioners, including WhiteHat's Jeremiah Grossman (this month's Silver Bullet podcast guest) and Robert RSnake Hanson carry on the tradition of identifying and discussing Web-based software vulnerabilities. Their work is important for two reasons. The first is obvious: by understanding how particular Web attacks work, we can both uncover particular versions of such problems in real software, and we can also learn to avoid certain particular problems.
Take the latest big Web vulnerability, Cross Site Request Forgery (CSRF). Closely-related to Cross-Site Scripting (XSS), a venerable Web bug, CSRF exploits the fact that Web browsers act as an authentication proxy for users of many Web applications. CSRF occurs when a malicious website causes the user's browser to perform an unwanted action on a trusted site. Interestingly, CSRF is possible whenever XSS is present, but the absence of XSS does not guarantee that CSRF is not possible.
Briefly, CSRF is possible because it is the Web browser that is in many cases authenticated to a Web application on behalf the user of the Web browser. So if a Web application user (on through a browser) types in a username and password thus opening a valid session (perhaps setting a cookie), the fact that the browser has an open session can be abused by an unrelated malicious Web content that leverages the session. (For a more technical discussion of CSRF, see Zeller and Felten's excellent paper CSRF: Exploitation and Prevention.)
The second reason that understanding and writing about particular Web vulnerabilities is important is that they serve as particular instances of more abstract software security problems that we do well to understand. For example, CSRF for all of its Web-relevance is a particular instance of an interposition attack. In this case, the attacker interposes in the authentication chain between the user and the browser. Interposition attacks are an especially relevant kind of problem in distributed systems, and one deserving more attention.
Web application security thus provides a tangible example of an interposition attack updated for modern software systems. And yet this same kind of attack applies in many non-Web situations, for example between the sound card driving a PC's speakers and the user's ears (a great place to intercept unencrypted music data), between a smart card reader and the serial bus (a great place to control a smart card from a PC), or between a SOA component and the rest of a system relying on the service to provide essential data.
I believe that every Web application security vulnerability has a software security counterpart outside of the Web domain. This suggests that understanding new Web vulnerabilities can expand our knowledge of software security, even suggesting novel attacks not yet pondered in the analog. It also suggests that the reverse is true (and that many software security attacks presage Web application counterparts).
Web application security has one major advantage over software security writ large — the HTTP protocol is stateless and exceedingly simple. This is a great advantage when it comes to automated security testing. In fact, the commercial success of Web application security scanners such as Watchfire/IBM and SPI-Dynamics/HP has much to do with the fact that automated testing is technically possible because of the simplicity of HTTP.
This advantage is a double-edged sword. Because many Web bugs can be easily discovered dynamically, some practitioners have come to believe that all software security issues can be so easily uncovered (and security testing completely automated). Would that it were so. Not only is security testing much more of a challenge for non-Web software, but even Web software itself presents serious issues. Jeremiah Grossman warns that 50% of Web problems he is aware of can't be reliably uncovered automatically (and he should know since his business is built around automating the Web security testing problem to the greatest extent possible).
In the end, while there is much we can learn from Web application security, it is critical that we don't over-generalize.