Client-side encryption for Gmail in Google Workspace is now generally available
workspaceupdates.googleblog.com
workspaceupdates.googleblog.com
Also to be available it must first be enabled by a workspace admin, then by the end user.
> Your organization operates in a highly regulated industry, like aerospace and defense, financial services, or government.
What I'm saying is that the point of implementing this feature may not be that it's expected to be tremendously useful for a lot of actual users.
Rather I think the point is to not leave the "has client-side encryption" box unchecked in any comparison charts or scoring systems that may influence purchasing decisions.
Just out of curiosity, why would you expect anything different?
Admins of many orgs don't like letting the user have options for things like security.
Some organizations would want to prioritize encryption over search/printing. (Also, there's no reason search and printing couldn't work with encryption.)
Or just require the client to do the indexing and the searching, and not upload the index anywhere.
Availability
* Available to Google Workspace Enterprise Plus, Education Plus, and Education Standard customers
* Not available to Google Workspace Essentials, Business Starter, Business Standard, Business Plus, Enterprise Essentials, Education Fundamentals, Frontline, and Nonprofits, as well as legacy G Suite Basic and Business customers
* Not available to users with personal Google AccountsThey know the majority of their users are going to think 'generally available' is exactly what it sounds like, not their made up meaning.
The Google announcement is pretty direct about the plans the feature is included with, and how to enable it.
Bit of both, maybe.
Internally GA means released to at least some end users without caveats like "in beta".
Marketing are just repeating that. Maybe they are being deliberately disingenuous, or maybe they are just parroting a phrase they don't understand.
;-)
Whether it is available to everyone for free, requires a specific plan etc. is not part of the determination.
it looks like it could be like s/mime, or possibly a scheme for encrypting the contents of messages stored in gmail accounts. where are the keys stored? what is the threat model?
can anyone enlighten?
although i suppose that's probably what customers are most worried about. corporate scandals tend to frequently be rooted in leaked internal communications.
These days, people really should get their own domain and host there email there. If you do not know how to do this, there are plenty of cheap hosting companies you can use.
And if you want to encrypt, use gnupg or that thing Thunderbird now uses. I am a mutt user and gnupg with mutt is rather easy.
Deliverability is only an issue when self hosting (particularly for home IPs)
You don't know this for certain, no one can unless you monitor both ends.
It seems to be a giant pain in the ass, and might be impossible in some circumstances
https://cfenollosa.com/blog/after-self-hosting-my-email-for-...
So nothing for power users?
The only way to do client side encryption is PGP on a native client distributed by a third party.
Yes, they could target specific people, deliver different javascript and break their encryption, but in general it's still a huge security gain. It makes it impossible for Google to handover E-Mails retrospectively to police or spy agencies.
can be self hosted.
There's no way to tell if they are intercepting your messages clientside, and you'd have to monitor all the network traffic (which would be encrypted with their keys) to detect exfiltration.
Or the ability to execute arbitrary external code?
You can also run your own self-built client (alternative implementations are available) and forward the messages securely any way you wish.
Such subterfuge would not remain undetected.
Signal is e2ee in ways that iMessage and WhatsApp are not.
It isn't supposed to protect you from government agencies. Really what this feature is, is 1) e2e of email, and 2) integration with an external enterprise key management service.
#2 means that at very least, your org will have access to your keys and therefore all encrypted mail, and if they have access to that, then they are open to things like subpoenas from law enforcement.
Of course this is sort of an odd game where you need to cut their access off before they backdoor it, so you have to somehow predict that Google is going to become malicious and beat them to the punch. If you a reacting to something that they are doing it likely isn't helping much.
Another possible advantage is that you could potentially have logging on key access which could give some idea of data usage. So if Google starts requesting keys for all of your stored data then you can be suspicious that they are siphoning up your data. (Or doing some background maintenance? Who knows?)
In practice this is probably mostly checkbox theater where it is a feature that Google and their users can list.
Edit: Found out that it doesn't: https://support.google.com/a/answer/10741897#zippy=%2Cwhich-...
This is supposed to give them some guarantees that the data is locked&safe outside of their premises.
(Testing Cunningham's Law here)
> Not available to users with personal Google Accounts
RTFM.
> RTFM
What manual?
Why not?
For emails between members of one workspace/domain, you can conceptually perform key exchange to implement client-side encryption. You also don’t have spam concerns within members of a workspace.
There’s no general way to do key exchange between different email domains, and you do have spam concerns (which to address requires scanning the content).
There’s no protocol for doing such things over different email domains in a way that’s compatible and interoperable across software stacks. This technology is proprietary, and would make spam challenging to deal with (which again is not a problem within one workspace).
It’s also not clear to me whether this is really client-side encryption, so much as encryption at a layer higher than the email stack. (It’s pretty hard to do client-side encryption in the browser, in a way that matches user expectations. How do you store/retrieve the encryption key?)
A number of Chrome (and I think also Firefox) extensions include their own local copy of OpenPGP.js for use with various webmail services, including GMail.
WKD (and HKP) depends upon HTTPS without cert pinning, FWIU: https://wiki.gnupg.org/WKD
How does an email client use WKD?
1. A user selects a recipient for an email.
2. The email client uses the domain part of the email address to construct which server to ask.
3. HTTPS is used to get the current public key.
The email client is ready to encrypt and send now.
An example:
https://intevation.de/.well-known/openpgpkey/hu/it5sewh54rxz33fwmr8u6dy4bbz8itz4 is the direct method URL for "bernhard.reiter@intevation.deThe initial reaction that I have to client-side encryption with a web browser is: how does the client fetch/obtain the encryption key? (For signing outbound messages, or decrypting/verifying inbound.) Local storage wouldn't be appropriate as the sole storage for something like an asymmetric keypair, and it wouldn't provide the behavior that users expect: being able to log in and use a service from any web browser.
No one interacts with a web browser in such a way that it would be appropriate for the browser's local state to be the sole storage of something important like a private key. So this necessitates a service that the client interacts with during login to fetch its private key.
If you can log in with a browser, then that implies that you're fetching the key from somewhere. In the context of hosted Gmail, then that means that Gmail will be storing and providing your key. In which case it's nominally client-side encryption -- and the system that stores and provides your key might be totally separate from the email systems (and tightly controlled) -- but it's still not what I'd think of as client-side encryption generally. It's not really client-side encryption if the service that you're using to store data is the same service (from your perspective) as the one that stores/provides your key (those responsibilities might be separated from an implementation perspective, but they aren't from a user's perspective).
The service can employ various techniques like encrypting its copy of my private key using a symmetric key derived from my passphrase (and then discarded) -- and this decryption could perhaps be done client-side in the browser -- but ultimately the service still has the ability to obtain my key (at time of next login, if not any time).
If the service that provides a client-side encryption key could be divorced from a particular use-case -- e.g., if I could use my own pluggable key-providing service with Gmail, which my browser uses to fetch my key on login -- then the model would make a bit more sense. (You'd still have to trust a service like Gmail not to steal your key, but at least you don't have to trust it to store the key as well.)
Would it be possible to implement a standardized pluggable key server model? It seems plausible. Imagine that there was a standard HTTP protocol for this purpose, kind of like how WebAuthN is standardized. I log into Gmail, link it to my key server <https://keys.jcrites.example.com>, verify the connection, and then when logging into Gmail, then the web page is allowed to make HTTPS calls to <https://keys.jcrites.example.com> to either fetch my asymmetric key, or alternatively make calls to decrypt or encrypt specific content.
In the former case, it implements client-side encryption using a key server I control, while trusting Gmail not to misuse the key; in the latter case, it implements encryption using a keyserver that I control, and makes remote calls for each encryption operation. In that case Gmail would never have my key, although while browsing Gmail.com it could probably make arbitrary requests to the key server to perform operations using the key -- but you could log what operations are performed.
/? secure enclave browser
But WebCrypto: "PROPOSAL: Add support for general (hardware backed) cryptographic signatures and key exchange #263" https://github.com/w3c/webcrypto/issues/263
How the key is generated, where it is stored, and which encryption is used.