Here's what's going on at a high-level. 1. Somebody discovered a security vulnerability in the implementation of a network protocol (i.e., a bug). The bug can

Here's what's going on at a high-level. 1. Somebody discovered a security vulnerability in the implementation of a network protocol (i.e., a bug). The bug can be exploited remotely apparently. Which means that somebody from far away can break into your machine if your software has this bug. 2. This was used by someone else to push forward their agenda. In particular, their point is that newer dynamic root of trust trusted technologies are better than older static root of trust technologies. The goal of these technologies is to make a piece of code execute securely (i.e., without being compromised or modified by an attacker). Static root of trust can make a piece of code execute securely only by trusting the entire software stack from boot time until the execution of the piece of code. Dynamic root of trust bypasses this entire software stack -- it allows you to just verify that the piece of code hasn't been modified before it's being executed. 3. Now, the bug from step #1 can (in theory) be used for someone to "break" into the persistent storage of the NIC and compromise the NIC "forever" by changing its firmware to a "bad" firmware. This won't be caught by the static root of trust technology because such technologies do not typically check the firmware of a NIC card at boottime. And thus, in theory, the dynamic root of trust is "better" because it doesn't rely on making sure that the entire software stack remains uncompromised. Now .. my opinions. a. Remote vulnerabilities are very problematic because they lead to remote exploits. The lesson here -- get very experienced/senior/skeptical designers to implement networking protocols. Here's where it's worth hiring the smart guy. Implementing a new protocol in C from scratch is crazy. I'd fire this guy if he worked for me. b. Dynamic root of trust is better than static root of trust on paper. In practice, dynamic root of trust is very hard to implement in a way that stays secure while doing something useful. When executing in "secure" mode with dynamic root of trust, you cannot use interrupts which basically means that's almost impossible to do anything useful (like sending or receiving a network packet).