5,737 karma · joined June 19, 2013
One thing I mentioned in a talk about at the TKey at FOSS-North this spring was that the internal name for the project at Mullvad that ultimately lead to the TKey was "TPM-ish". The idea was to develop a evice with just the parts of the TPM API needed to perform measured boot, but that we could control and trust.
This idea got simplified into a hardware Root of Trust device that could only do Ed25519 signing. Basically an iCE 40 UP FPGA mounted on a PCB talking SPI or LPC. And since it was based on RISC-V it didn't take long until Mullvad founder Fredrik Strömberg proposed that by combining with the DICE concept we could generalize it into what has become the Tkey.
The TKey Unlocked will be available very soon. These devices are not provisioned and not locked by Tillitis. This allows you to provision the UDS and UDI yourself, and do anything else you want with the TKey. This includes modifying the FW and the FPGA design. There will also be a TKey programmer to allow you to program TKey devices:
´´´ In today's payment ecosystem, customers' sensitive data is substituted by sequences of random numbers, and the uniqueness of each transaction is secured by a classical cryptographic method or code. However, adversaries and merchants with powerful computational resources can crack these codes and recover the customers' private data, and for example, make payments in their name. ´´´ Ignoring the strange statement that "sensitive data is substituted by sequences of random numbers", the second part is second statement about powerful computational resources is simply wrong.
And the suggested solution to the problem is also quite typical - it relies on equipment that basically require a lab to use. And it does not work with the infrastructure used today for payments. It doesn't scale, it would require replacing a lot of equipment and indeed the Internet itself.
So I'd like to add incentive (4): A way to seemingly have established researchers suggest punishment as accepted way of enforcement. Drive agenda, basically.
https://www.internationalscholarsjournals.com/articles/impac...
1. Steal, increase credibility for the article and the (assumed) real authors by attaching the name of a successful researcher with high credibility. People need to publish a number of papers to get their degree. Doing this may help them getting published easiser. A bit like also stealing the actual contents of the paper from an already published paper.
2. Destroy the credibility of a researcher by attaching their name to a paper that is falsified, plagiarized.
My very unfounded guess is that it is more (1) than (2) at play here. But research in political science is probably more at risk to cause anger and enemies than say cosmology. Unless the research is related to dwarf planets or some such.
http://cva.stanford.edu/classes/cs99s/papers/myer-sutherland...
I'm a wee bit skeptical on the valuations of companies from China and to some extent Saudi.
This is the artist: https://en.wikipedia.org/wiki/Caroline_af_Ugglas
The TKey does not have any persistent memory available for applications to store things. The idea is that we measure (calculate a keyed digest using BLAKE2s) the application during loading. The keyed digest (called CDI) is used as a base secret, random value by the application to derive the secrets the application needs. The Ed25519 signer for example derive its keypair based on the CDI.
A PGP application could use this to determinstically derive a keypair.
The FW application loader will also accept a User Supplied Secret (USS), which is also used during the calculation of the CDI. This means that the keypair derived will be based on the specific TKey device, the integrity to the device application and the USS. One way to use the USS is to control which keypair to derive. For example for SSH, different USS can derive keys used for different servers.
Also, a device application may use the CDI to derive wrapping keys, and then use authenticated encryption to protect a cookie that can be stored on the TKey client machine between usage.
We are working on providing libraries and examples for app developers to do this.
And to the yes part of the answer: Yes, a TKey could talk to a PGP agent and be called upon when needed. This is similar to how a SSH agent can talk to TKey today.
First: all registers and logic (LUTs) will always be cleared during the reset phase of the FPGA configuration. So any secrets stored there will be secure. We store the Unique Device Secret (UDS - the primary asset) in registers. Registers that can also only be read once between power cycling. The block RAMs (EBRs) however can be cleared or retain data based on the configuration <-- these are the ones to worry about.
Right now we have to touch the FW-RAM (implemented using EBRs) with the UDS for a few tens of cycles. After it being used, it is wiped from memory. So a successful exfiltration must trigger the warm boot-reconfiguration during that window of time. In order to make this harder (i.e. more time consuming) we do a few things:
1. We randomize when the UDS is moved to the FW-RAM and thus when the window to hit is. And we should not leak any indication when that is.
2. We use ASLR to randomize where and in which order the UDS is stored in the FW-RAM.
3. We use randomized data scrambling of the contents in the FW-RAM. And yes we do fill the memory with randomized, ASLRed data first.
The randomization control values are all stored in registers, and will be lost as part of the reset phase of the attack. So an exfiltration must:
1. Hit the window of time.
2. Extract the contents of the FW-RAM.
3. Be able to distinguish the random data words that make up the UDS from the other contents of the FW-RAM.
4. Descramble the UDS words and place them in the right order.
It is not an impossible attack, but it should take a long time. And it should not scale easily from one device to all other. One could automate it of course, but the work should be the same (multiple exfiltrations) for each device.
But we still think that the attack IS possible, and it is therefore out of scope of attacks that we mitigate for this version of the TKey. The next version will hopefully be able to keep the UDS in registers only. When we have that working, the threat model will be updated to reflect that.
https://github.com/tillitis/tillitis-key1/blob/main/doc/thre...
The current casing is fairly tamper evident (it will break), but we do not yet use real, tamper evident sealing. We are looking at tamper sealing for future versions. And ways to further protect against physical attacks.
(Full disclosure: I work for Tillitis.)
The issue here is liability and what the lawyers counseling a company will recommend. If your design contain IP that the company has valued (very common), risking leakage of that IP by using a library that in legalese seems to suggest that you may have to release your design, you can probably bet that the lawyers will recommend to find another technical solution. Protecting business value and avoid exposure, liability drives conservatism. And in my experience will always triumph over technology choice. Esp if there seems to be a possible choice to be made. Including developing your own solution.
As an open source HW creator I have to decide if I develop stuff for my own amusement, or if I do it to (in somehow small way) help the world - which means other using my creations. And then consider if the license I use support that goal. Since I don't just develop stuff for my own amusement I've decided to use a permissive license since I think that makes it easiest for others to use my stuff.
Judging by the number of downloads, messages and additional work I've gotten, it seems to work out pretty ok.
Releasing under AGPL is a great way to not see your design being used and contributed to. At least by entities that wants to abide by the license and do the right thing. Entities that steal work done by others, have no intention to contribute back may do differently.
We here at HN are quite probably not the norm. Being hobbyists that have been tinkering with computers since early childhood should not be a requirement to become a programmer. If it were, the industry would not be able to scale as it has. There are simply too few of us in the human population.