frobulate(const struct foo *fooarray, size_t numfoos). For the sake of discussion, it really isn't important what
frobulatedoes, lets just say that it performs an action on an array of structures. Now, it turns out that it is pretty common to call
frobulate()with just a single structure, so we provide a helper function
frobulateOne(const struct foo *foop).
I realize this is silly, but bear with me.
Now, lets say a developer using your library finds that passing a malformed structure to
frobulateOnecauses it to crash. You identify that there is buffer overflow in your library code that is caused by not properly validating the contents of the structure passed as an argument. How do you fix it?
You might add some additional validation to
frobulateOne(), but certainly you would fix
frobulate()to validate each any every structure. After all,
frobulateOne()just turns around and calls
frobulate()to do the real work. Obviously, it is necessary to validate the input to
In fact, it is so obvious you are probably wondering why I'm wasting my time mentioning it.
Because somehow Microsoft, who made a high-profile effort to fix security bugs in their flagship product, screwed it up. When it was found in November 2004 that malformed animated cursors could lead to a buffer overflow, Microsoft issued a fix (MS05-002) 4 months later. The fix issued added input validation to the
LoadCursorIconFromFileMap()function. Being highly-security conscious, you would assume that in that four months developing a fix, someone would have noticed that
LoadCursorIconFromFileMap()is a wrapper that loads the icon data from the disk and calls
LoadAniIcon()to actually process the data. Or that, after discovering such a bug in one piece of code, they would have their crack team of security experts scour through related code looking for similar bugs.
But, sadly, they did not. Earlier this week, Microsoft had to scramble to issue new patches applying the exact same input validation they added to two years ago to
LoadAniIcon(). Independent security researchers had found Microsoft's obvious error before they did and hackers were exploiting the vulnerability to take control of Windows users' machines.
Of course, the IT press is encouraging everyone to apply Microsoft's patches ASAP due to the severity of the bug. Microsoft's detractors will hold it up as another example of how Microsoft's Windows operating system is inherently more insecure than their favorite OS.
But what strikes me is not the severity of the bug itself, but what it says about the internal processes at Microsoft. This latest security flaw is not the result of some previously-undiscovered bug -- it is the direct manifestation of Microsoft's failure to properly address the exact same flaw two years ago. And the correct solution, as I hope my little example at the start of this post demonstrated, should have been obvious from the start.
I'll avoid the debate of whether Microsoft's development processes are fundamentally flawed; I've never worked there so I wouldn't know. However, this bug should make it abundantly clear that Microsoft's processes for addressing known security issues are not just flawed, but practically non-existent. No organization employing professional software engineers could have missed the proper fix two years ago, much less an organization that professes to take security issues seriously. Microsoft claims to
"have dedicated staff whose job it is to perform root-cause analysis of defects". Somehow I don't believe it. Or, if they do, I should expect they'll be hiring a new group soon.
Update 2007/04/06: Apparently I'm not the only one who is baffled how Microsoft could fail to have proactively fixed this recent bug and still profess to be focused on making Windows more secure.