Microsoft can, and should, provide more insight into how well its security development life cycle is working.Burton Group security analyst Pete Lindstrom set the security blogoshere ablaze with his post Microsoft's SDL has Saved the World!. David Maynor at Errata Security calls Lindstrom an old man. While Michael Howard, a senior security program manager at Microsoft responded here.

At issue isn't the value of improving software development processes to incorporate security throughout the development life cycle. What's at issue is whether or not Microsoft's SDL has improved the security of its software when it's shipped at GA. I certainly believe it has come a long way since this day (link), and that Microsoft is using public vulnerability discovery counts as its measurement of success.

Lindstrom makes a number of points, some are dubious, others are worth consideration as to why the number of publicly discovered vulnerabilities is on the wane. And not all of these have anything to do with an improvement in development:

1. Microsoft has hired/contracted with the most talented bugfinders, and they're no longer going public with the bugs they find. 2. Bugfinders are selling (or keeping) the vulnerabilities they find underground. (There's been more and more of this going on in the past few years). 3. Bugfinders are growing bored with Microsoft operating systems, and focusing more on the client applications. 4.Microsoft has improved its software development processes.

While I find the first point dubious at best, even Microsoft can't hire every skilled bugfinder. But, points two, three, and four are all contributing factors as to why the number of publically disclosed vulnerability counts is down.

In Howard's retort to Lindstrom's post, Howard quoted Lindstrom as saying the following:

"Microsoft has systematically hired and/or contracted with every one of their most vocal critics (and most seasoned bugfinders) to do the work behind the scenes and they don't count those vulns!"

This is part of Howard's response:

But in making this assertion, he's saying the vulnerabilities we remove (and do not add to the code in the first place) as part of the SDL process should be counted as though they were part of the product after we shipped it. We don't count vulnerabilities that don't affect customers, regardless of the vendor.

My question is: Why doesn't Microsoft count the vulnerabilities it finds and eliminates during development? How else can success be measured, as well as improve internal processes and the focus on developer training and education?

Instead, the market just fed the rhetoric that since there are fewer publically discovered vulnerabilities, the secure development life cycle is a success. This just isn't intrinsically so. Correlation isn't always causation. There may be many, many other external factors that could lead to a reduction in publicly discovered vulnerabilities.

From Michael Howard's blog:

Some of the many SDL principles that reduce or mitigate security bugs include:

• Mandatory education (Net effect: fewer security bugs up front)

• Design decisions based on threat models (Net effect: fewer security design bugs up front)

• Cannot use known insecure APIs (Net effect: fewer security bugs up front)

• Use of static analysis tools (Net effect: fewer security bugs enter the central source code repository)

• Cannot use known weak crypto primitives and key lengths (Net effect: fewer security bugs up front)

• Compiler and linker requirements (Net effect: extra defenses, in case you miss a bug)

• Fuzz testing (Net effect: implementation bugs found before shipping)

There are a lot of claims here, so why not share some numbers that substantiates them. Surely we can't expect Microsoft to share all of its internal numbers, but why can't the company reveal the percentage reduction of security bugs discovered earlier in development, say per thousand lines of code? Or what's the percentage of vulnerabilities reduced during static code analysis in products developed in the SDL?

How well is the mandatory developer education is working? How well is threat-modeling and mis-use cases working at reducing the attack surface -- it must be very difficult improvement the processes. There's much the industry could learn here.

I'm not aware of any other company on the planet that relies on the random process of public defect finding as their primary measurement of quality control. Surely, Microsoft can do better than just pointing to publicly discovered vulnerability counts as the only measure of success.