Fixing the Internet of Broken Things: An Open, Hardware-Led Approach
Our world is now woven with connected devices. They monitor our health, fly our planes, and drive our cars. Yet, beneath this convenience lies a critical flaw: the security of the Internet of Things is broken. This isn’t a theoretical risk. Vulnerabilities discovered by researchers aren’t just about stolen data; they have the potential for catastrophic, real-world harm.
The Failure of Security-by-Obscurity
For too long, many IoT manufacturers have operated on a dangerous assumption. They believe that hiding their code—security-by-obscurity—is enough. It’s a strategy that has repeatedly failed in the software world. Look at the legacy of proprietary systems like Windows, Java, or Flash. They became prime targets precisely because their closed nature didn’t guarantee safety; it often hid flaws from everyone but the attackers.
The tools available to reverse engineer device firmware are incredibly sophisticated. Malicious actors can extract code directly from hardware or find it in online updates. The idea that obscurity provides protection is a myth that needs to be retired. What’s the alternative? We must embrace openness.
Building on Open Source and Open Standards
Open source software offers a fundamentally different security model. Instead of a handful of developers scrutinizing code, you have thousands of expert eyes worldwide. Flaws are found and fixed with astonishing speed, often within hours. The community’s focus is on quality and utility, not corporate politics or commercial feature sets.
This transparency also addresses another shadowy concern: nation-state interference. History is littered with reports of governments pressuring companies to build secret backdoors into proprietary products. Such concerns rarely, if ever, touch the open-source community at large, where the code is open for all to inspect.
Open standards are equally crucial, especially for networking. Implementing complex protocols like TCP/IP is difficult. When a device engineer, unfamiliar with networking, is tasked with adding connectivity, mistakes are inevitable. Global, interoperable open standards encapsulate this complexity. They allow hardware developers to rely on robust, expert-maintained frameworks, outsourcing the trickiest security work to those who know it best.
Containing Risk with Hardware-Assisted Separation
Many embedded systems are designed as a single, monolithic environment. If a hacker breaches one component—say, the infotainment system in a car—they can often ‘move laterally’ to more critical systems like steering or brakes. This design flaw is a gift to attackers.
The solution is security by separation, enforced by hardware. Using hardware-assisted virtualization, a secure hypervisor can create isolated containers for each software function. The radio runs in one virtual box; the engine management system runs in another. From a risk perspective, assuming any software can be compromised is prudent. This architecture ensures that a breach in one container is contained, preventing it from becoming a stepping stone to the entire system.
Of course, systems need to communicate. The volume might need to increase as the car accelerates. This is managed through strictly controlled, secure channels between containers. This model isn’t just for safety; it’s essential for business. A smart TV without this separation could allow a rogue app to steal a protected video stream from Netflix, causing significant financial damage.
The Practical Path Forward
The ideal of a hardware-rooted, open security framework is the destination. Reaching it requires a journey. Not all chips today support advanced virtualization. However, progress can start now.
Manufacturers can begin with intermediate steps like Linux containers to isolate applications. Even without a dedicated ‘root of trust’ chip, firms can and must encrypt and cryptographically sign their firmware. They must commit to providing timely security patches. Waiting for perfect hardware is not an option when the vulnerabilities are present today.
The stakes couldn’t be higher. We built an internet of things without a foundation of security. To fix it, we must collectively move away from secrecy and toward openness, and away from monolithic designs and toward hardware-enforced separation. The journey is necessary, and it starts with a decision to change our approach.