"Invalid Username" hides maximum password length error

[RealOrangeOne]

We are happy to answer your questions about the code or discuss technical ideas.

Please complete the following checklist (by adding [x]):

• I have searched open and closed issues for duplicates
• This isn't a feature request
• This is not a report about my app not working as expected

---

When logging in, I got a "Invalid username" error. After some digging, it seems this happens if my password is more than 72 characters.

My guess is something on the backend has changed recently and this is now validated. However, the message is clearly not right.

I discovered this by changing the below to log as an error, and then checking the log file:

proton-vpn-gtk-app/proton/vpn/app/gtk/widgets/login/login_form.py

Line 121 in d9a6ab0

logger.debug(error, category="APP", subcategory="LOGIN", event="RESULT")

Ideally the error message would be changed to something less generic (and more correct). Not sure if this is a recent change or not? But it's definitely not just me.

---

As a workaround, you can change your password to one with fewer than 72 characters. However forcing users to change their password is not ideal.

[eNTi]

Why would it even be limited at all? I hate apps and sites that do that. There's is usually malicious intent behind a decison like that and I don't expect that from Proton. Explain yourselves.

[Anonymous941]

There's is usually malicious intent behind a decison like that and I don't expect that from Proton.

What would Proton have to gain from that? A randomly generated 72 character password has way more entropy then could possibly be brute forced. My guess is they had to put some kind of limit to prevent DoS attacks, and chose 72 characters, even though it's a little low

[RealOrangeOne]

Why would it even be limited at all

bcrypt has a maximum length of 72 bytes, so limiting passwords to 72 chars is not only a good idea, it's a security feature. I don't know that they're using bcrypt, but there are plenty of reasons to put an upper-bound limit.

My guess is they had to put some kind of limit to prevent DoS attacks

Exactly. Limiting passwords is a good idea for that, especially if the hashing is complex. We don't know that it's that, but putting some form of upper bound on passwords is pretty common practice.

Explain yourselves.

Really not helpful.

[DuncanTDP]

I am having this exact same issue and proton vpn is non functional on my system currently.

[Renfield1897]

The same issue occurred with me, checked my password, and it was 64 characters long, so below the 72 mentioned, however I had used all the security options (Upper and Lower case, Special Symbols, Numbers, ANSI characters,and special symbols) so I decided to change the password anyway, so something shorter and without the additional security symbols, and it worked!

So it could be the case that not only does it not like longer than 72, but it also has stopped liking the use of ANSI characters and special symbols.

[eNTi]

Changes like that are indefinitely frustrating. I hate it when websites do that without actually telling you how the passwords are limited. Finding that out by guessing is just the worst user experience.

I really would like to know who's behind this change and why it was ACTUALLY made.

[ZemarKhos]

Proton does not use the standard bcrypt library. If you look at the code for their Windows application, you can see that they use their own bcrypt library. We need to port this library, written in Go, to Python so that it can handle passwords longer than 72 characters I think.

[ZemarKhos]

proton_bcrypt.py
util.py

Fix: Support passwords longer than 72 bytes in SRP authentication

Problem

The Python bcrypt library (v5.0.0+) raises a ValueError when passwords exceed 72 bytes, causing login failures with the error "Invalid username" for users with long passwords. This issue doesn't occur in the Windows client because it uses Proton's custom Go bcrypt fork which doesn't enforce this limit.

Related issue: #127

Root Cause

The standard Python bcrypt library enforces bcrypt's 72-byte password limit strictly:

# In proton/session/srp/util.py
hashed = bcrypt.hashpw(password, b"$2y$10$" + salt)  # Fails if len(password) > 72

However, Proton's Windows/mobile clients use a custom Go bcrypt implementation (github.com/ProtonMail/bcrypt) that handles longer passwords by cycling through the password bytes (wrap-around behavior).

Solution

Port Proton's Go bcrypt implementation to Python and use it instead of the standard bcrypt library.

Files to add/modify

1. NEW FILE: proton/session/srp/proton_bcrypt.py

This is a pure Python port of https://github.com/ProtonMail/bcrypt that:

• Implements the full Blowfish cipher and bcrypt algorithm
• Does NOT enforce the 72-byte password limit
• Matches the behavior of Proton's Go implementation
• Is 100% compatible with standard bcrypt for passwords ≤ 72 bytes

2. MODIFIED FILE: proton/session/srp/util.py

Change the import and usage:

# Before:
import bcrypt
# ...
hashed = bcrypt.hashpw(password, b"$2y$10$" + salt)

# After:
from proton.session.srp.proton_bcrypt import hashpw as proton_bcrypt_hashpw
# ...
hashed = proton_bcrypt_hashpw(password, b"$2y$10$" + salt)

Installation

Copy the files to your proton-core installation:

# Find your proton-core installation path
pip show proton-core | grep Location

# Copy the files (adjust path as needed)
sudo cp proton_bcrypt.py /usr/lib/python3.13/site-packages/proton/session/srp/
sudo cp util.py /usr/lib/python3.13/site-packages/proton/session/srp/

# Set correct permissions
sudo chmod 644 /usr/lib/python3.13/site-packages/proton/session/srp/proton_bcrypt.py
sudo chmod 644 /usr/lib/python3.13/site-packages/proton/session/srp/util.py

Testing

Verified working with passwords of 50, 72, 73, 100, 150, and 200 characters.

from proton.session.srp._pysrp import User

# This now works with any password length
password = 'A' * 100  # 100 character password
modulus = bytes([0xAB] * 256)
user = User(password, modulus)
challenge = user.get_challenge()  # Success!

Technical Details

The key difference is in how the password is processed during Blowfish key scheduling:

Standard bcrypt (Python): Rejects passwords > 72 bytes with an error

Proton bcrypt (Go/Python port): Uses streamtoword() function that cycles through password bytes:

def _streamtoword(data: bytes, off: int) -> Tuple[int, int]:
    word = 0
    for _ in range(4):
        word = ((word << 8) | (data[off] & 0xff)) & 0xFFFFFFFF
        off = (off + 1) % len(data)  # Wrap around for long passwords
    return word, off

This means all bytes of the password contribute to the hash, even beyond 72 bytes.

[sallto]

As a workaround you can also install the proton-vpn-cli, sign in via that (which works for some reason), which then also signs you into the GUI version, skipping the buggy section.+

Worked for me with a ASCII-only password >72 chars. YMMV

[Bl4ckspell7]

As a workaround you can also install the proton-vpn-cli, sign in via that (which works for some reason), which then also signs you into the GUI version, skipping the buggy section.+

Worked for me with a ASCII-only password >72 chars. YMMV

Didn't work for me. Was not able to sign in in neither CLI nor GUI. Had to change password.