8 ms·
Tillitis Key – Mullvad spin-off inspired by measured boot and DICE
- teddyh 4y agoRYF certification?
- greyface- 4y agohttps://github.com/tillitis/tillitis-key1/ https://github.com/tillitis/tillitis-key1/ https://github.com/tillitis/tillitis-key1-apps/ https://github.com/tillitis/tillitis-key1-apps/
- Havoc 4y agoAm I right in thinking that this is basically like a yubikey except with openness as key differentiator? Or is it’s function something else ?
- kreetx 4y agoNot exactly sure, but the OSFC conference page has some extra info on what it can do: https://www.osfc.io/2022/talks/tillitis-key-a-usb-security-key-inspired-by-measured-boot-and-dice/ https://www.osfc.io/2022/talks/tillitis-key-a-usb-security-k... Maybe it will be ~YubiKey plus extras?
- LibertyBeta 4y agoSo Solokey V2. Not that I'm complaining by the way. Any open competition to yubikey is a win in my book.
- byyll 4y agoI really dislike how "Yubikey" is being used in many places as a name for U2F and FIDO2.
- riedel 4y agoThis is because the fido2 libraries follows a lot of defacto standardisation: either to match yubikey or windows hello as the only real implementations in the wild. Fido2 ctap extensions would support all the use cases of the new device except you won't be able to use them e.g. in windows because vendors are ignorant about all the openess to push their own agenda.
- jffry 4y agoIt's the same as "Google Authenticator" being used instead of TOTP. I think it's reasonable for apps' documentation to meet users on their turf to aid understanding.
- _8j50 4y agoProbably for use with something like secure enclave.
- ldng 4y agoIt is an FPGA, fully open both at software and hardware level. So quite a bit more futurproof, inspectable and upgradable than a yubikey.
- JoachimS 4y ago(For full disclosure I am the primary FPGA designer of TillitisKey.) It also perform a measurement of the application being loaded. And the measurement together with the Unique Device Secret (UDS) will generate the primary secret applications can use to derive keys etc it needs. This means that you can verify the application integrity. This is very close to, inspired by DICE: https://www.microsoft.com/en-us/research/project/dice-device-identifier-composition-engine/ https://www.microsoft.com/en-us/research/project/dice-device...
- tinco 4y agoDid you design the board? It looks sick, such high density of components on the top layer.
- JoachimS 4y agoNo, the board design is done by the wizard Matt Mets at https://blinkinlabs.com/ https://blinkinlabs.com/
- layer8 4y agoWhat exactly is the “measurement”? A hash of the application code?
- michaelt 4y agoAccording to [1] > It offers both security and flexibility by being end-user programmable while also preventing applications loaded onto the device from knowing each other’s secrets. During use firmware on Tillitis Key derives a unique key for each application it runs by measuring it before execution. This is done by combining an application’s hash value with a unique per device secret. Applications are loaded onto the device from the host computer during use, and are not stored persistently on the device. So the idea here is: * General purpose, reprogrammable security coprocessor * If you save secrets with application A, then install evil application B, it can't access the secrets from A. * And if you revert back to A, those saved secrets will still be there. * Therefore, it's more practical to run two different applications - and safer to experiment with your own applications, because you won't lose all your website logins. [1] https://www.tillitis.se/ https://www.tillitis.se/
- xani_ 4y ago* If you save secrets with application A, then install evil application B, it can't access the secrets from A. * And if you revert back to A, those saved secrets will still be there. What stops app B from pretending it's an app A ?
- michaelt 4y agoSomething like 'Secure Boot' / 'Measured Boot' on modern PCs, I imagine. A bootloader will checksum the current application before running it, checking its digital signatures and version and whatnot, and deriving an encryption key based on that.
- kfreds 4y ago1. The hardware contains a UDS (unique per device secret) which can only be read once per boot cycle. 2. Firmware in ROM does unconditional measurement of the first mutable boot stage, which is loaded from the host, over USB. The KDF used for measurement is Blake2s(UDS, Blake2s(application), USS). Note that when I say hardware I mean FPGA hardware design.
- 4y ago
- kfreds 4y agoThe Tillitis Key is a new kind of USB security key inspired by measured boot and DICE. Tillitis Key’s design encourages developers to experiment with new security key applications and models in a way that makes adoption easier and less risky for end-users. It offers both security and flexibility by being end-user programmable while also preventing applications loaded onto the device from knowing each other’s secrets. During use firmware on Tillitis Key derives a unique key for each application it runs by measuring it before execution. This is done by combining an application’s hash value with a unique per device secret. Applications are loaded onto the device from the host computer during use, and are not stored persistently on the device. A user- or host-supplied secret can also be mixed into the key derivation function, providing further protection. A sophisticated physical attacker should be assumed to have knowledge of the target application’s hash, and will likely eventually succeed in extracting the UDS from the hardware. By adding a host-supplied secret, knowledge of the application used as well as the security key’s UDS is not sufficient to produce the application secret. This makes the security impact of a lost or stolen Tillitis Key less than for conventional security keys. Device applications can be chain-loaded where the first application stage hands off its secret to the second stage. This improves user experience as it makes it possible for the application secret (and its public key) to remain the same even if a device application is updated. It also enables developers to define their own software update trust policies. A simple first-stage application might do code signing verification of the second stage, whereas a more advanced one will require m-of-n code signatures, or a Sigsum inclusion proof. Sigsum was designed with embedded use cases in mind. Tillitis Key is and always will be open source hardware and software. Schematics, PCB design and FPGA design source as well as all software source code can be found on GitHub. https://www.tillitis.se https://www.tillitis.se https://github.com/tillitis/ https://github.com/tillitis/ (Full disclosure: I'm Fredrik Stromberg, cofounder of Mullvad VPN and co-designer of Tillitis Key)
- mwcampbell 4y agoIIUC, popular security key devices like the YubiKey securely store a private key, but only allow it to be used for specific authentication applications (e.g. OTP or U2F). Would the Tillitis Key be able to securely store a private key, then with appropriate authentication from the host, use that key for encryption and decryption?
- PhilippGille 4y ago> Something that makes the key unique is the fact that both its software and hardware are open source Aren't SoloKeys [1] also open hardware and software? Or is the Tillitis key more general purpose and thus not in the same category? [1] https://solokeys.com/ https://solokeys.com/
- FredFS456 4y agoMy understanding is that it's both a more general platform (targeting more than 2FA) and also uses an FPGA running open-source code, so that the "secure enclave" functionality can be inspected and found to be secure, rather than just trusting NXP/ARM's chip as SoloKeys have done.
- ptman 4y agoFTR SoloKeys targets FIDO2, not just U2F
- Matl 4y agoI think what they mean is that this can be reprogrammed for more use cases than FIDO2 and U2F, it can say be programmed to support my own homegrown thing that I've made up just now or even a more general concept than just getting into things perhaps.
- JoachimS 4y agoYes. And your application will get a per device unique primary secret when loaded, which the application then can use for whatever it needs. (Including not using it all all.) TOTP, FIDO2, PIV, simple touch triggered challenge/response... or something completely different. If it can fit in around 100 kByte RAM when compiled for RV32IMC and not be too computationally expensive, it could be a Tillitis app. Just to give you some indication, the Ed25519 signer operation in the SSH authentication we showed on stage today takes ~ one second to perform the signing. And we have several ways to improve that we know already.
- 4y ago
- deleted 4y ago[deleted]
- _8j50 4y agoGood VPN company (one of the best) and good idea (sounds like USB Armory). But the best it can do is assure that their VMs are not logging anything and keep other promises. Will they also be able to share details of their hosting setup in a way you can independently verify (because they can always have more middleware transparent traffic logging VMs)? doubt it, same goes to whomever they use for hosting. My point is, while I don't ascribe to the extremes of pro or anti VPN sentiments, having a good understanding of what services like this can and cannot do and performing rudimentary yet essential security and privacy risk asessment is essential before trusting them with all your traffic.
- Foxboron 4y ago> Good VPN company (one of the best) and good idea (sounds like USB Armory). But the best it can do is assure that their VMs are not logging anything and keep other promises. Will they also be able to share details of their hosting setup in a way you can independently verify (because they can always have more middleware transparent traffic logging VMs)? doubt it, same goes to whomever they use for hosting. We are working on this as part of the System Transparency project. https://system-transparency.org/ https://system-transparency.org/ Disclaimer: I work on this. Beyond this Penetration Testing reports on the Mullvad infrastructure is public.
- LASR 4y agoI’ve always wondered what is feasible through a state-issued mandate along with a gag order to circumvent the technology for something like this.
- _8j50 4y agoThat's what I mean about risk asessment. You should not expect mullvad or any other legally liable organization to resist lawful orders or unlawful coercion, these are not reasonable expectations and your security posture should account for that.
- vladvasiliu 4y ago
- switch007 4y agoThe name sounds like a disease.
- MisterTea 4y agoThe letters themselves form the side profile of a restaurant dining room in disarray.
- notemaker 4y agoProbably a play on words in Swedish, "tillit" means trust / confidence.
- alrlroipsp 4y agoMove over, IKEA.
- encode 4y agoIt’s a play on the Swedish word ”tillit”, which means trust. So tillitiskey = trust is key.
- layer8 4y agoIt’s tillitating.
- kreetx 4y agodupe, https://news.ycombinator.com/item?id=32896658 https://news.ycombinator.com/item?id=32896658
- SadTrombone 4y agoTo be fair, this thread was posted first.
- dang 4y agoOK, we'll merge that one hither.
- pxeger1 4y agoIt strikes me that open source hardware should be more common. It's surely much easier to monetise than open source software: you just sell the hardware, because noone wants to build one themselves. Why isn't it?
- _def 4y agoIt's risky. You still need the software, otherwise only some devs and tinkerers will buy it - and even for them there better be tool chains etc
- Semaphor 4y agoJust from reading comments and articles, I’d guess that’s because you very often rely on 3rd-party parts that are not open. So you either need to limit what you use, or design the whole thing.
- arsome 4y agoNo one wants to built it themselves until people actually want it, if your device is popular then your device is $2 on AliExpress/eBay and you have no part in that, look at Arduino for a good example.
- tyingq 4y agoThis...if it's successful, a knockoff of your device will end up on eBay, AliExpress, Amazon, etc, often with sketchy parts, at a price you'll never match. With some exceptions, where you're able to make the product depend on a hard-to-get-cheap part, etc.
- spicyjpeg 4y agoBecause hardware is, well, hard. There is a huge upfront investment that isn't even remotely comparable to the amount of money you can spend on software development, and equally huge incentives for third parties to undercut you by taking your designs, manufacturing them for cheap and offloading support onto you (as already pointed out Arduino is a great example of this happening in real life). Even if everything is open source you have to build an entire business and marketing department around selling the hardware, while with pure software you can just put it up on GitHub and call it a day. Not to mention that in this day and age every piece of hardware has software at its core, so open source hardware does not save you from also writing the code that runs on it. If anything developing open source firmware is actually harder, because most chip vendors expect your product to be closed source and want you to sign countless NDAs before you can access a datasheet or even just buy the chips. You are restricted to using older and/or more expensive parts whose documentation is freely available; it's the exact opposite of the software world, where the latest and greatest is one npm install away.
- jeroenhd 4y agoI'm not sure what problem this solves. I see per-application keys based on the hash of the application, but wouldn't this prevent updates of those applications without key loss? It's clear to me that this device can be used for _some_ kind of cryptographic operation/verification mechanism, but I'm at a loss for what problem this is actually designed to solve. What's the practical application of this key?
- xani_ 4y agoThe app key would need to stay the same, but I can't think of a mechanism that would deny one app trying to pretend it's another. Also the fact it doesn't emulate smartcard means every single software supporting it would have to make a special client so yeah, that's a problem. "Just" smartcard allows for at the very least GPG signing and SSH agent without much fuss, and also HTTPS client cert auth
- layer8 4y agoI believe the only thing needed is someone writing a PKCS #11 driver for it, then it should be interoperable.
- dmurray 4y agoWe used to use the same version of applications for years. It's OK to say this has a serious limitation in that it can't easily support updating applications, but that hardly rules out it being useful at all.
- kfreds 4y agoTillitis Key’s design encourages developers to experiment with new security key applications and models in a way that makes adoption easier and less risky for end-users. You can read more on tillitis.se or in the comment I made below. Tillitis Key will allow you to chain-load applications. This means that you could have a thin loader which does code signing verification of the next application stage, and hand off the secret to it. Basically it's a trust policy that defines under what circumstances the next application stage gets the secret. Another trust policy the loader could have is requiring m-of-n code signatures, or perhaps that as well as transparency log inclusion. Check out sigsum.org.
- croon 4y agoUnimportant trivia from a Swedish speaker: Mullvad means mole (for the tunnelling more than planted spy connotations, hopefully), and the "Tillit" part of the name means trust. They're working on some IKEA style naming, which I enjoy.
- kfreds 4y agoThanks! The other news of today is that we've started a second sister company - Glasklar Teknik AB - which will focus on maintenance and development of System Transparency and Sigsum. System Transparency: Mullvad's security architecture we'll use to eventually make our running VPN systems transparent. Sigsum: A transparency log design with distributed trust assumptions (witness cosigning).
- croon 4y agoGlad to hear it! Both valiant efforts, and good naming here too. For non-speakers; "Glasklar" means literally "glass clear", but makes more sense to explain as the phrase in Swedish equivalent to "clear as day".
- cinntaile 4y agoYou can say crystal clear in English, it's a bit closer to the original version.
- trelane 4y agoWonder how this compares to NitroKey, which also is open, but not FPGA-based. It's almost certainly a good time to update https://lwn.net/Articles/736231/ https://lwn.net/Articles/736231/
- dang 4y agoRelated: https://mullvad.net/en/blog/2022/9/19/mullvad-creates-a-hardware-company/ https://mullvad.net/en/blog/2022/9/19/mullvad-creates-a-hard... (via https://news.ycombinator.com/item?id=32896658 https://news.ycombinator.com/item?id=32896658, but we merged that thread hither)
- irusensei 4y agoQuick question about such devices: can I use stuff like Yubikey or similar to luksOpen a crypt device during boot or operation? Thanks in advance.
- vinay_ys 4y agoDo you mean something like this: https://github.com/agherzan/yubikey-full-disk-encryption https://github.com/agherzan/yubikey-full-disk-encryption
- VTimofeenko 4y agoYes, there's multiple ways. Systemd offers systemd-cryptenroll that works with FIDO2 and X509 certificates on the hardware key to unlock a drive. The key is embedded as a luks header into the partition. The information about the key and the device is passed to initrd through /etc/crypttab for unlocking during boot. I wrote a couple of posts describing how this can be sort-of-handrolled with nitrokey and gpg key for x509 cert: https://vtimofeenko.com/posts/unlocking-luks2-with-x509-nitrokey-during-boot/ https://vtimofeenko.com/posts/unlocking-luks2-with-x509-nitr...
- filleokus 4y agoCool! Always nice to see extra competition in this space. One thing I've wanted for a while is a way to properly backup a webauthn token. An approach I discussed a couple of weeks ago [1] was: 1: Generate on-hardware webauthn master key on device A. 2: Generate on-hardware key-pair on device B 3: Export B’s public key, import to A 4: On Device A: Encrypt master key with B’s public key 5: Export encrypted master key to B 6: Decrypt on B I guess this would probably be possible with this device? Perhaps there are some even more clever way to do it. [1]: https://news.ycombinator.com/item?id=32621426 https://news.ycombinator.com/item?id=32621426
- kfreds 4y agoHi! Interesting. Which company do you work for? Yes, that'd be possible. I don't know how webauthn works, but if it relies on ECC you could probably do ECDH between all security keys you wanted to carry your master key, and then use the combined ECDH values as the master key.
- filleokus 4y agoI work at a consulting firm in Stockholm, my remark about competition was solely from a user/hacker standpoint. My day job is more about security in the higher levels of the stack :-) Cool! It was a while since I looked in the standards, but I think there definitely is support for using ECC based algorithms. Looking forward to follow your journey!
- kfreds 4y agoAh, OK! :)
- dbrgn 4y agoAre you aware of Trussed, an initiative by SoloKeys and Nitrokey? https://solokeys.com/blogs/news/trussed-announcement https://solokeys.com/blogs/news/trussed-announcement / https://trussed.dev/ https://trussed.dev/ From what I understand, this is an API to write applications against a common interface, which can run on different hardware devices. An abstraction layer for security key apps. Similar to Java Card, but in a more modern way. Is this something that would or could be compatible with Tillitis?
- ecesena 4y agoI've been dreaming of a fpga-based key since I read about precursor. Not sure if it's yet possible to power it via NFC. But with this said, sharing at least the FIDO implementation would be outstanding.
- kfreds 4y agoYes, I'm aware of it. I'm not sure if it's small enough for the Tillitis Key to be able to use it.
- Perseids 4y agoA bit off-topic: Can anyone recommend a platform that is production ready today, if I want to (develop and) deploy a custom Smartcard / HSM application in small scale? JavaCard seems to fit the bill, but I've not yet found an approachable tutorial.
- zahllos 4y agoJavaCard is the answer for smartcards. You can find example card software all over github, and you're looking for the JavaCard SDK from Oracle and GlobalPlatformPro to program them: https://github.com/martinpaljak/GlobalPlatformPro https://github.com/martinpaljak/GlobalPlatformPro. There's even an ant task around somewhere that allows you to use ant tooling. Blank cards with "developer"/default keys can be picked up pretty much anywhere. Buy blank cards, write your applet, test in an emulator if you want, push to card, test for real with your software that talks to the card, profit. Be aware that if your goal is to write custom cryptography implementations in Java on the Javacard, these will be prohibitively slow. No need to take my word for it, Niels Duif did exactly this: https://research.tue.nl/en/studentTheses/smart-card-implementation-of-a-digital-signature-scheme-for-twist https://research.tue.nl/en/studentTheses/smart-card-implemen... > Java Card proves to be a worthless platform for high-speed cryptography. Despite the > speedups, generating a signature takes more than 28 minutes for a private key of 254 > bits. How is crypto done then? JavaCard provides APIs that do it, but these call implementations that either use coprocessors, or contain optimised implementations in the mask ROM. You can't program a mask ROM without doing a production run of smartcards in the hundreds of thousands. Small scale, this isn't possible. HSM vendors will often sell SDKs for custom code, which you can add to certain models. The barrier to entry simply being that you need to buy an HSM, which isn't cheap. It can be done, however, and on the plus side in my experience of Thales HSMs this means actual C code, meaning performant implementation is possible.
- Hacker_Yogi 4y ago
- fiat_fandango 4y agoSo basically a pluggable HSM? Curious if this should be considered more similar to the Yubi HSM 2 [0] (think dedicated HSM, not very useful for anything else but very secure) or the USB Armory [1], very adaptive small arm SBC with a USB port? [0] https://www.yubico.com/product/yubihsm-2/ https://www.yubico.com/product/yubihsm-2/ [1] https://inversepath.com/usbarmory https://inversepath.com/usbarmory
- kfreds 4y agoYes, except YubiHSM boots using verified boot. In the case of Tillitis Key each program gets its own secret key, which it can use to e.g. derive a key pair.
- JoachimS 4y agoOr CrypTech: https://cryptech.is/ https://cryptech.is/ There are things developed by the CrypTech project I would like to try and reuse for TillitisKey.
- fiat_fandango 4y agoVery cool, thanks for the link! This context helps a ton :)
- fleventynine 4y agoFrom the photo, that looks like a stock iCE40 FPGA, which does not support hardware attestation of the loaded bitstream. How does the user verify that the FPGA loaded the expected bitstream instead of something with a backdoor? A DICE chain that is not rooted in physical, immutable hardware isn't very useful.
- kfreds 4y ago> From the photo, that looks like a stock iCE40 FPGA, which does not support hardware attestation of the loaded bitstream. Which FPGA models support _attestation_ of the loaded bitstream? Do any? > How does the user verify that the FPGA loaded the expected bitstream instead of something with a backdoor? It's a Lattice ice40up5k, which contains a programmable and lockable NVCM memory in-package. The engineering samples we handed out today at OSFC store the FPGA configuration bitstream on a SPI flash memory though. > A DICE chain that is not rooted in physical, immutable hardware isn't very useful. When we start selling them we'll likely sell both security keys with pre-provisioned bitstreams in NVCM as well as unprovisioned security keys so you can provision your own.
- 70rd 4y agoAn interesting approach to vendor-independent attestation was outlined in [1]. Basically the bitstream is fed into a physical unclonable function (PUF) which is used to derive a key to decrypt the rest of the bitstream. For attestation, one could simply store the secret part of an asymmetric key in the encrypted bitstream (for challenge-response). [1]: An Autonomous, Self-Authenticating, and Self-Contained Secure Boot Process for Field-Programmable Gate Arrays, https://www.mdpi.com/2410-387X/2/3/15 https://www.mdpi.com/2410-387X/2/3/15
- fleventynine 4y ago> Which FPGA models support _attestation_ of the loaded bitstream? Do any? I haven't seen this feature yet, but I desperately want it on every FPGA I use. NVCM eliminates most of the benefits of using an FPGA...
- dtx1 4y agoBeing FPGA Based from what i can tell is a brilliant idea. This makes it possible to fix hardware level security issues. I've been shocked by the recent exploit found in google pixels security chip since i rely heavily on it (using graphene os). An unfixable hardware level bug in it would turn my phone to e-waste for me. This solves this quite elegantly.
- AtNightWeCode 4y agoFrom a security perspective people should glue their USB-ports shut. Do the people endorsing this crap even considering that anyone with a bit of knowhow can buy a malicious replica.
- octoberfranklin 4y agoThe most important part of this project is in the very last sentence: it's all implemented on an FPGA (one which doesn't have any backdoorable-for-surveillance hard cores). Without that, none of the other stuff would be trustable.
- kfreds 4y agoNote that we specifically chose the Lattice ice40 UltraPlus 5K because: - It is supported by an open-source FPGA toolchain - Has an in-package non-volatile configuration memory (NVCM) that is lockable. This is where we'll eventually keep the FPGA configuration bitstream, including the unique per device secret. After some reverse-engineering work we're also able to program and lock NVCM with open tooling, as opposed to having to use Lattice's proprietary one.
- Mandatum 4y agoThis doesn't solve cookie theft, but this does massively raise the bar for hackers getting into service provider environments. Couldn't think of a better time to launch.