4 ms·
With E2E encryption you need to trust the developer of the software and the distribution channel (apt, App Store, web server). The GP comment is parroting the c
by josephg 6y ago
With E2E encryption you need to trust the developer of the software and the distribution channel (apt, App Store, web server). The GP comment is parroting the claim that browser based E2E encrypted systems are inherently less secure than native apps because web servers are untrustworthy systems for delivering software.
Does native software have fundamentally more trustworthy distribution channels than web servers? I see the argument in some cases - apt always delivers the same binary for the same request (I assume). And the App Store does binary signing, rather than just TLS. But plenty of native software is just installed via the developer’s website anyway. And if the developers host the website, they’re already a party you have to trust. Giving them more trust doesn’t change much - they could just slip something nasty in the binary if they wanted your data.
I still don’t totally buy it.
- detaro 6y agoA key aspect is that for native apps its harder (not necessarily impossible) to just at a selected point in time deliver malicious code to a selected user, with nothing persisting it. Compared to a native app that's installed in a way that it can't modify itself (and thus needs to deliver a vulnerable or malicious version during installation) that's very weak - arguably an app that can invisibly update itself is somewhere inbetween. With a web app you always load the code from the server - while at the same time using E2E to protect yourself against said server...
- feross 6y agoI agree with this analysis. We'd love to offer more assurances that the code hasn't changed out from under you when using Wormhole.app. We really need a better way to "pin" a site to a current version and only update it with user consent. Right now, we're limited by the capabilities of the web platform and will probably need to ship a native app to accomplish this.
- codezero 6y agoWhat about using sub resource integrity to allow users to request a specific JS version using its integrity attribute in the URL, that way shares also use the same pinned version, and can check/verify the integrity themselves or via some centrally informative place as well.
- tptacek 6y agoThe problem here is that there's no good way in the browser Javascript runtime to verify the current execution environment. All you can check are the script assets you load, not whether your current running code has been eval'd into something malicious. This is a very old debate that we're recapitulating here; if you sense that I'm being less than forthcoming about it, it's because there's something like 11 years of history of it in the search box below the page. I don't much care about the argument here. I'm have two things to say in this thread: 1. "Wormhole" is a bad name for a new secure file transfer system, since one of the better-known cryptographic file transfer systems is already named "Magic Wormhole" and has the command "Wormhole". It's confusing, and especially annoying since there's no dispute that Magic Wormhole is more secure than this application --- even if you think, incorrectly, that browser Javascript crypto is "end-to-end", there's no coherent way to suggest that it's as secure as the native Magic Wormhole program. 2. AES-GCM is not in fact a perfectly cromulent AEAD; it is an imperfectly cromulent AEAD, and one most designers would probably do well to avoid (use XSalsa-Poly1305, with random nonces).
- deleted 6y ago[deleted]
- codezero 6y agoX
- tptacek 6y agoI really don't understand this "if I disagree with an argument, it's fulmination" point you keep trying to make. Further: I haven't called you names at any point in this discussion --- that's a line you're starting to cross. I think perhaps we should just disengage. I'm not asking you to respond to me. If you feel we're not getting anywhere, we don't have to keep talking.
- dane-pgp 6y agoI think the argument against web-based software is that because you effectively re-download the application on every visit, there are more opportunities for a compromised provider to serve you a malicious version of the application. I suppose it's the difference between TOFU (Trust On First Use) and BEEF (Beware Each & Every Fetch). Okay, I made up that second acronym, but it seems like a reasonable name for that threat model. Anyway, as the sibling comment points out, the distinction is fairly moot if you have an auto-updating native application. To improve the situation for native applications, it would make sense to use a tamper-evident log like Trillian[0] so that a package manager or auto-updater can be sure that it is receiving the same binary as every other user (and possibly after a sufficient delay to allow reviewers to raise the alarm about the corresponding reproducibly-buildable source code). Applying this to web applications is more tricky, but can be done using the bookmarklet-dataURI trick[1] which effectively allows the user to freeze a copy of a web app "bootloader" that pulls in the remaining resources after checking their signatures against a hardcoded public key (as well as against a Trillian log). [0] https://transparency.dev/application/add-tamper-checking-to-a-package-manager/ https://transparency.dev/application/add-tamper-checking-to-... [1] https://news.ycombinator.com/item?id=17776456 https://news.ycombinator.com/item?id=17776456
- feross 6y agoThanks for the pointer to bookmarklet data uri trick - that's clever. I posted this elsewhere in the thread, but just wanted to mention it again in this context. Hyperboot [1] uses AppCache to give users the benefits of explicit, immutable versioning with control over upgrades using the html-version-spec while preserving the simplicity of passing around a URL. It offered the usability benefits of web apps – you can give someone a URL and they can immediately load the app – with the security of installed apps – doesn't change without warning. Unfortunately, AppCache is being removed from the web platform and there's no way to use ServiceWorker to accomplish the same thing. [1]: https://github.com/substack/hyperboot https://github.com/substack/hyperboot
- dane-pgp 6y agoYes, it's a pity that AppCache and ServiceWorkers won't be able to support this use case. Also, the data URI trick comes with its own limitations, such as the fact that the address bar won't present an actual domain name or padlock, so it has a slightly worse user experience than normal websites. One simple way that the web platform could be improved, then, would be to adopt something like the Hashlink proposal[0], which would allow the hash of the initial "bootloader" to be stored in the query string. If this were possible then a simple bookmark would suffice, or a URL sent in an email, as your comment suggests. [0] https://w3c-ccg.github.io/hashlink/ https://w3c-ccg.github.io/hashlink/