jeirmeister/Cockatrice
1
0
Fork 0
mirror of https://github.com/Cockatrice/Cockatrice.git synced 2026-09-21 17:15:09 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

[Security] Add challenge-response auth with scrypt verifiers and stop storing plaintext passwords

Browse source 
Challenge-response authentication: the client derives a scrypt verifier
(RFC 7914, EVP_PBE_scrypt, N=32768, r=8, p=1) and authenticates with
HMAC-SHA256(key, nonce), so neither the password nor its hash is
transmitted. The stored format becomes
"$scrypt$<n>$<r>$<p>$<salt>$<verifier>" and Response_PasswordSalt
now carries the cost parameters. Strict servers only accept scrypt
verifiers; legacy accounts are migrated after a successful login.

Fix #344 for challenge-response servers: a saved profile stores the
derived verifier under the password key instead of the plaintext password.
The connect dialog loads it without revealing it, autoconnect passes it
through, the change-password dialog no longer prefills the old password
field with it, and the client only persists the verifier when
"Save password" is checked.

Took 3 minutes


Took 1 minute

Took 10 seconds
This commit is contained in:
Lukas Brübach 2026-08-04 11:36:10 +02:00
parent 5257a8bfa8
commit 088e932882
33 changed files with 675 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

68
tests/password_hash_test.cpp
View file

@ -36,6 +36,74 @@ TEST(PasswordHashTest, TokenHasExpectedLength)
const QString token = PasswordHasher::generateActivationToken();
ASSERT_EQ(token.size(), 16);
}
TEST(PasswordHashTest, DeriveKeyMatchesKnownVector)
{
// RFC 7914 scrypt test vector, P="password", S="NaCl", N=1024, r=8, p=16
const QByteArray expected = QByteArray::fromHex("fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b"
"3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cb"
"dfa2cc0640");
const QByteArray derived = PasswordHasher::deriveKey("password", QByteArray("NaCl"), 1024, 8, 16);
ASSERT_EQ(derived.toHex(), expected.toHex());
}
TEST(PasswordHashTest, PasswordVerifierRoundTrip)
{
const QString stored = PasswordHasher::generatePasswordVerifier("hunter2");
ASSERT_FALSE(stored.isEmpty());
ASSERT_TRUE(stored.startsWith("$scrypt$"));
const PasswordVerifier parsed = PasswordHasher::parsePasswordVerifier(stored);
ASSERT_TRUE(parsed.isValid);
ASSERT_EQ(parsed.format, PasswordFormat::Scrypt);
ASSERT_EQ(parsed.n, SCRYPT_N);
ASSERT_EQ(parsed.r, SCRYPT_R);
ASSERT_EQ(parsed.p, SCRYPT_P);
ASSERT_EQ(parsed.salt.size(), SCRYPT_SALT_LENGTH);
ASSERT_EQ(parsed.verifier.size(), SCRYPT_VERIFIER_LENGTH);
}
TEST(PasswordHashTest, PasswordVerifierInvalidInput)
{
ASSERT_FALSE(PasswordHasher::parsePasswordVerifier("garbage").isValid);
ASSERT_FALSE(PasswordHasher::parsePasswordVerifier("$scrypt$not-an-int$8$1$AAAA$BBBB").isValid);
ASSERT_FALSE(PasswordHasher::parsePasswordVerifier("$scrypt$1024$8$1$AAAA$too-short").isValid);
ASSERT_FALSE(PasswordHasher::parsePasswordVerifier("$pbkdf2-sha512$1000$AAAA$BBBB").isValid);
}
TEST(PasswordHashTest, LegacyFormatDetection)
{
ASSERT_TRUE(PasswordHasher::isLegacyFormat("salt+hash"));
ASSERT_FALSE(PasswordHasher::isLegacyFormat(PasswordHasher::generatePasswordVerifier("password")));
}
TEST(PasswordHashTest, DeriveKeyDependsOnCostParameters)
{
const QByteArray keyA = PasswordHasher::deriveKey("password", QByteArray("NaCl"), 1024, 8, 16);
const QByteArray keyB = PasswordHasher::deriveKey("password", QByteArray("NaCl"), 2048, 8, 16);
const QByteArray keyC = PasswordHasher::deriveKey("password", QByteArray("NaCl"), 1024, 8, 1);
ASSERT_NE(keyA, keyB);
ASSERT_NE(keyA, keyC);
}
TEST(PasswordHashTest, ComputeResponseIsDeterministic)
{
const QByteArray nonce = QByteArray("a nonce value");
const QByteArray key = QByteArray("the verifier bytes");
const QByteArray r1 = PasswordHasher::computeResponse(key, nonce);
const QByteArray r2 = PasswordHasher::computeResponse(key, nonce);
const QByteArray r3 = PasswordHasher::computeResponse(QByteArray("a different key"), nonce);
ASSERT_EQ(r1, r2);
ASSERT_NE(r1, r3);
}
TEST(PasswordHashTest, ConstantTimeEquals)
{
ASSERT_TRUE(PasswordHasher::constantTimeEquals(QByteArray("same"), QByteArray("same")));
ASSERT_FALSE(PasswordHasher::constantTimeEquals(QByteArray("same"), QByteArray("diff")));
ASSERT_FALSE(PasswordHasher::constantTimeEquals(QByteArray("short"), QByteArray("longer")));
}
} // namespace
int main(int argc, char **argv)