Microsoft's Shared-Source defeats Trustworthy Computing

Security through obscurity only works to a point

Opinion The recent leak of Windows source code onto the Web has made a lot of people jumpy. According to MS news blog, the company has already discovered at least one downloader and sent him a nastygram. If this is true, it indicates an aggressive response back in Redmond, a scrambling to plug the leaks and intimidate in the curious RIAA-style.

It should surprise no one that the proverbial chickens have come home to roost. Microsoft's security is in part a function of keeping its source code out of the wrong hands. Thus the Shared Source gimmick is in direct conflict with that portion of the company's Trustworthy Computing gimmick that depends on secrecy.

No one wants malicious coders to get their hands on enough of the Windows source to accelerate development of the never-ending torrent of novel exploits already coming out on a weekly basis.

Keeping the code under lock and key is a brake on exploit development: it works simply by making the process more difficult. But by sharing it with numerous partners, the company also makes it more difficult to keep the lid on. Shared Source means that future leaks are inevitable.

And these leaks have consequences. It took only a few days for a computer enthusiast to find a simple exploit against IE 5 based on the leaked code.

It wasn't a terribly important one; but it was, the enthusiast claimed, based on a quick review of the code. More serious exploits may yet be found in the code now circulating, or not as the case may be. But the next time source code is stolen or accidentally released - and it will happen - there might be widespread and very serious security implications.

Deep in the Bowels of Redmond

Consider that the 'recent' ASN.1 vulnerability needed six months to be fixed. The problem was not so much Microsoft's bureaucratic inertia, but the fact that the flaw was located deep in the bowels of Windows.

It was difficult to fix because it affected many interdependent components. Microsoft's penchant for system integration and interdependence is itself an obstacle to developing patches that work properly and don't break other things.

It's no wonder the company is jumpy. Its nightmare consists of a dual threat: first, that more source code will leak and lead to the discovery of a serious exploit, and second, that the problem (like the ASN.1 bug) will be so deeply rooted in the system that patching it will require months of work. It is reasonable to foresee a situation in which millions of Windows boxes would be susceptible to an exploit that can't be patched adequately for many months.

It could happen as a result of the recent code leak, or we might have to wait for the next blunder. But it will happen: it's only a matter of time.

But if (perhaps in some alternate universe) Microsoft products were open source, the need to maintain secrecy would be eliminated, and with it, a significant source of anxiety. But that's not an option.

Security through obscurity can work in some situations, but only so long as obscurity is maintained. If I bury money in my yard, it will remain safe so long as I don't tell anyone about it, and so long as some accident doesn't reveal it. If you go down that path, you have got to stay on it, and that's difficult under the best of circumstances because accidents do happen.

Undeserved obscurity

Microsoft's mistake is trying to have it both ways. It wants to keep the code under wraps, yet share parts of it with big clients and partners whom it hopes it can trust. But some trustees will be unscrupulous while others will be incompetent, and occasional failures in obscurity are inevitable. As Poor Richard's Almanac noted many years ago, "three can keep a secret if two of them are dead."

The security of MS products, bad as it is, will only be degraded further so long as the company relies on keeping its source code secret, while at the same time sharing it with hundreds of 'select' outsiders. This is a contradictory approach. It simply can't be made to work over the long term.

Unfortunately, at this point, there is no solution. The code can't be put back in the box. This is simply a bad decision that the company has made, the consequences of which have yet to be felt firmly.

But they will. It's only a matter of time. ®

Sponsored: Designing and building an open ITOA architecture