I don’t write about the SDL very much, because I figure that the SDL team does a good enough job of it on their blog, but I was reading the news a while ago and realized that one of the aspects of the SDL would have helped if our competitors were to adopt it.
A long time ago, I wrote a short post about “giblets“, and they’re showing up a lot in the news lately. “Giblets” are a term coined by Steve Lipner , and they’ve entered the lexicon of “micro-speak”. Essentially a giblet is a chunk of code that you’ve included from a 3rd party. Michael Howard wrote about them on the SDL blog a while ago (early January), and now news comes out that Google’s Android SDK contains giblets that contain known exploitable vulnerabilities.
I find this vaguely humorous, and a bit troubling. As I commented in my earlier post (almost 4 years ago), adding a giblet to your product carries with it the responsibility to monitor the security mailing lists to make sure that you’re running the most recent (and presumably secure) version of the giblet.
What I found truly surprising was that Android development team had shipped code (even in beta) with those vulnerabilities. Their development team should have known about the problem with giblets and never accepted the vulnerable versions in the first place. That in turn leads me to wonder about the process management associated with the development of Android.
I fully understand that you need to lock down the components that are contained in your product during the development process, that’s why fixes take time to propagate into distributions. As I’ve seen it from watching FOSS bugs, the typical lifecycle of a security bug in FOSS code is: A bug is typically found in the component, and fixed quickly. Then over the next several months, the fix is propagated into the various distributions that contain the fix. So a fix for the bug is made very quickly (but is completely untested), the teams that package up the distribution consumes the fix and proceeds to test the fix in the distribution. As a result, distributions naturally lag behind fixes (btw, the MSFT security vulnerabilities follow roughly the same sequence – the fix is usually known within days of the bug being reported, but it takes time to test the fix to ensure that the fix doesn’t break things (especially since Microsoft patches vulnerabilities in multiple platforms, the fix for all of them needs to be released simultaneously)).
But even so, it’s surprising that a team would release a beta that contained a version of one of it’s giblets that was almost 4 years old (according to the original report, it contained libPNG version 1.2.7, from September 12, 2004)! This is especially true given the fact that the iPhone had a similar vulnerability found last year (ironically, the finder of this vulnerability was Travis Ormandy of Google). I’m also not picking on Google because of spite – other vendors like Apple and Microsoft were each bitten by exactly this vulnerability – 3 years ago. In Apple’s case, they did EXACTLY the same thing that the Android team did: They released a phone that contained a 3 year old vulnerability that had previously been fixed in their mainstream operating system.
So how would the SDL have helped the Android team? The SDL requires that you track giblets in your code – it forces you to have a plan to deal with the inevitable vulnerabilities in the giblets. In this case, SDL would have forced the development teams to have a process in place to monitor the vulnerabilities (and of course to track the history of the component), so they hopefully would never have shipped vulnerable components. It also means that when a vulnerability is found after shipping, they would have a plan in place to roll out a fix ASAP. This latter is critically important because history has shown us that when one component is known to have a vulnerability, the vultures immediately swoop in to find similar vulnerabilities in related code bases (on the theory that if you make a mistake once, you’re likely to make it a second or third time). In fact, that’s another requirement of the SDL: When a vulnerability is found in a component, the SDL requires that you also look for similar vulnerabilities in related code bases.
Yet another example where adopting the SDL would have helped to mitigate a vulnerability.
 Btw, I’m not saying that the SDL is the only way to solve this problem. There absolutely are other methodologies that would allow these problems to be mitigated. But when you’re developing software that’s going to be deployed connected to a network (any network), you MUST have a solution in place to manage your risk (and giblets are just one form of risk). The SDL is Microsoft’s way, and so far it’s clearly shown its value.