Firefox sync uses end-to-end encryption: https://support.mozilla.org/en-US/kb/how-firefox-sync-keeps-..., https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc....
There's nothing mandatory about the initial shortcuts - just remove them. It's trivial to change your search engine to Duck Duck Go too.
In Chrome pushes forward with plans to limit ad blockers in the futuremozilla
fxa-auth-server
JavaScript2014–2023
mozilla / fxa-auth-server · Archived
fxa-auth-server
DEPRECATED - Migrated to https://github.com/mozilla/fxa
19Distinct people
19Mentions
0Explicit recommenders
397GitHub stars
What to know before exploring
What it is
DEPRECATED - Migrated to https://github.com/mozilla/fxa
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 12:54:37 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year19 dated mentions
Observed mentions: 2014-02-03 10:59:41 UTC to 2023-11-24 08:48:06 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 10 | 3 | 7 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 1 | 0 | 1 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
This repository has been migrated to https://github.com/mozilla/fxa/tree/master/packages/fxa-auth-server
Please file issues and open pull requests against https://github.com/mozilla/fxa
Read the full README on GitHubWhat Hacker News says
19 sourcesHey.. neat project!
From the docs at https://docs.doppler.com/docs/share-security :
> 2. Client-side JavaScript generates a cryptographically random 64 character passphrase
> 3. Client-side JavaScript generates a symmetric key using the passphrase, random salt, and 100,000 rounds of PBKDF2.
> ..
> 5. Client-side JavaScript create SHA256 hash of the passphrase
> 6. Client-side JavaScript sends the encrypted secret, hashed passphrase, and expiration details (days/views) to the server.
Using PBKDF (or any other "key-stretching" algorithm) is appropriate to prevent someone from cheaply building a table that maps from potential passphrase (+salt) to the potential symmetric key, ahead of time, and then quickly testing lots of potential keys against the encrypted data. If the passphrase is not full-strength to begin with, this is an important st
Read the rest
ep.
But.. if you then send a non-stretched, simple hash of the passphrase to the server, you're giving up all that benefit. The server, anyone who breaks into it, or someone who can snoop on the conversation, gets to perform the fast pre-computed dictionary attack against the passphrase. You've prevented the ciphertext from being used as a cheap oracle, but allowed the server's hashed-passphrase to serve that role instead.
The document didn't say what character set was used for each of the 64 characters of the passphrase, but even if it's just hex, that still gives you a 256-bit key, which is effectively infinite. So in this case, I don't think you need the PBKDF.
If the passphrase were not that strong, then I'd recommend protecting both values against being used as an oracle:
1: run the passphrase through PBKDF (or Argon2, or bcrypt, whatever) to produce the "stretched passphrase"
2: hash the stretched passphrase one way to produce the encryption key, e.g. key = sha256("key:" + stretchedPassphrase)
3: hash the stretched passphrase a different way to produce the hash that you reveal to the server, hash = sha256("hash:" + stretchedPassphrase)
4: never reveal stretchedPassphase to anyone else, or use it directly for any other purpose
That way a dictionary attack against any of the revealed values are equally difficult. This is effectively the scheme we used on Firefox Accounts to protect the Sync password: https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc... .
Also note: don't use different PBKDF round counts as a distinguisher, i.e. hash = PBKDF(rounds=10000, passphrase) and key = PBKDF(rounds=10001, passphrase). That amounts to the same thing, someone who learns the hash will get a cheap attack against the passphrase.
thanks for building this!
The new Firefox sync (v1.5) is surely great and has good usability, I preferred the old Firefox sync (v1.1), because it didn't require a Mozilla account (for password retrieval). The new service requires two servers for one's fully own setup (for managing accounts and a sync server), although it is possible to use Mozillas account server.
Also, from the description of the protocol ( https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc... ) it was not clear to me, what exactly is encrypted? Only the passwords? I had the impression that the bookmarks were stored in a way readable by Mozilla.
Update. It is not clear what kind of data is in "Class-A" as described here: https://wiki.mozilla.org/Identity/AttachedServices/Architect... ... It also says:
> we can share e.g. bookmarks with a third party (by telling them the decryption key)
In Private by Design: How We Built Firefox SyncYes, sort of (more about the process: https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc...). Key difference: you don't need to sync all the data up again, since there's a separate key for that, which doesn't change.
That said, if you forget your password you do lose remote synced data. The hope is that you have at least one device connected that still has the data, which will upload it in that case. This doesn't work in all cases (there's a pretty common and unfortunate pattern where someone reinstalls their OS, doesn't remember their password, and loses data as a result)
You can also generate and store a separate recovery key to help avoid data loss, https://support.mozilla.org/en-US/kb/reset-your-firefox-acco....
In Private by Design: How We Built Firefox SyncYour logins are encrypted end-to-end, with a key that Mozilla's server don't have.
You can find more about how sign-in and key management works in https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc...
In Firefox LockboxYes, they are encrypted on the client.
https://blog.mozilla.org/services/2014/04/30/firefox-syncs-n...
https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc...
In Firefox LockboxWe do :) The full details are at https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc..., but basically we derive two separate keys: one for authentication, that gets sent over the wire, and a completely different one for decrypting the sync key, which is not set over the wire. This means that even if you can observe the entire transaction, you still aren't able to derive the decryption key.
It's more or less:
let quickStretchPW = PBKDF2(email, password)
let authPW = HKDF('authPW', quickStretchPW)
let unwrapBkey = HKDF('unwrapBkey', quickStretchPW)
Where unwrapBkey !== authPW.
In Firefox 57.0 Released> the old protocol was very suitable
It wasn't, because I've managed to lose my history with it. I very much prefer my history to be synchronized to a server I cannot lose.
If your objection is not about cloud storage, then your objection isn't about the protocol, but its implementation (e.g. usage of HTML/Javascript): https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc...
> you download the browser once
That's not true. Modern browsers are set to upgrade automatically in the background, without notifying the user.
If you're paranoid, you can self-host your own Sync server, but then if you don't trust the vendor of your browser, then you've got bigger problems and I hope you're compiling your own binaries.
In Google will use Chrome browsing data for ad tailoringSource?
Are you perhaps thinking of the currently unused "class-A data"?
https://blog.mozilla.org/services/2014/04/30/firefox-syncs-n...
https://blog.mozilla.org/services/2014/02/07/a-better-firefo...
https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc...
Edit:
From what I can see, client side encryption in Google Chrome appears to be opt-in?
In Firefox: We Don't Need Google's Money Any MoreNew Firefox Sync protocol for Firefox Accounts
4 points · Open discussionFirefox Accounts using remote server as source of randomness
1 points · Open discussion> The old one let you run your own server.
This is still possible with the new system, although I'll admit the ease and usability of such a setup needs work (and IIRC there are some changes required before android devices can properly use a third-party server; it may take a few releases before this become as easy as it was with the old system).
> As it is, it's possible the new sync has a backdoor,
> even one many people at Mozilla don't know.
Both the client and server are open-source, and you can verify that the client follows the protocol [1] and doesn't leak anything more than a PBKDF2-stretched password derivative to the server. It's about as backdoor-proof as any client/server system is likely to get.
But yes, it is more dependent on the strength of your password than the previous sync system.
[1] https://github.com/mozilla/fxa-aut
Read the rest
You can run your own Firefox sync server, but it's a pain to implement.
http://docs.services.mozilla.com/howtos/run-sync.html
Once it's up and running, though, it's seamless.
Edit: Hmm. Looks like they're happy to break this:
" Some unknown proportion of the user base uses their own Sync servers ... [Asa] I don't think we should worry too much about this group. If we can identify them and message them that'd be sufficient for my concerns."
https://services.etherpad.mozilla.org/sync-migration
Well, thanks.
Here's a code-dump of the new Firefox Account server. Not sure yet if I can implement this:
https://github.com/mozilla/fxa-auth-server
In Firefox 29 beta arrives with easy Sync tool....True, if you accidentally lost data, this suggests the documentation should be better. But this is not entirely changing:
class-A: data assigned to this class can be recovered, even if the user forgets their password, by proving control over an email address and resetting the account. It can also be read by Mozilla (since it runs the keyserver and knows kA), or by the user's IdP (by resetting the account without the user's permission).
class-B: data in this class cannot be recovered if the password is forgotten. It cannot be read by the IdP. Mozilla (via the keyserver) cannot read this data, but can attempt a brute-force dictionary attack against the password.
- https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc...
We do not yet know which data will be assigned to which category by default, but it is likely that saved-passwords
Read the rest
will go into class-B, and many other datatypes will default to class-A. There will be an option to put all data into Class-B.
- https://wiki.mozilla.org/Identity/AttachedServices/Architect... (not sure if out of date)
...and for good reason, because since Mozilla presumably wants to avoid being required to hand over account data by governments to the greatest extent possible. Being able to reset your password via email necessarily makes it possible for Mozilla to decrypt that data.
The Sync protocol document is (linked in the article) has a lot of interesting details about the new system: https://github.com/mozilla/fxa-auth-server/wiki/onepw-protoc...
In A Better Firefox SyncShowing the 15 most recent of 19 sources. Enable JavaScript to search and browse every indexed mention.