Git-Mirrors/keepassxc
1
0
Fork 0
mirror of https://github.com/keepassxreboot/keepassxc.git synced 2025-12-17 01:14:19 -05:00
Code Issues Projects Releases Packages Wiki Activity

Replace all crypto libraries with Botan

Browse source 
Selected the [Botan crypto library](https://github.com/randombit/botan) due to its feature list, maintainer support, availability across all deployment platforms, and ease of use. Also evaluated Crypto++ as a viable candidate, but the additional features of Botan (PKCS#11, TPM, etc) won out.

The random number generator received a backend upgrade. Botan prefers hardware-based RNG's and will provide one if available. This is transparent to KeePassXC and a significant improvement over gcrypt.

Replaced Argon2 library with built-in Botan implementation that supports i, d, and id. This requires Botan 2.11.0 or higher. Also simplified the parameter test across KDF's.

Aligned SymmetricCipher parameters with available modes. All encrypt and decrypt operations are done in-place instead of returning new objects. This allows use of secure vectors in the future with no additional overhead.

Took this opportunity to decouple KeeShare from SSH Agent. Removed leftover code from OpenSSHKey and consolidated the SSH Agent code into the same directory. Removed bcrypt and blowfish inserts since they are provided by Botan.

Additionally simplified KeeShare settings interface by removing raw certificate byte data from the user interface. KeeShare will be further refactored in a future PR.

NOTE: This PR breaks backwards compatibility with KeeShare certificates due to different RSA key storage with Botan. As a result, new "own" certificates will need to be generated and trust re-established.

Removed YKChallengeResponseKeyCLI in favor of just using the original implementation with signal/slots.

Removed TestRandom stub since it was just faking random numbers and not actually using the backend. TestRandomGenerator now uses the actual RNG.

Greatly simplified Secret Service plugin's use of crypto functions with Botan.
This commit is contained in:
Jonathan White 2021-04-04 08:56:00 -04:00
parent 86ddd702fb
commit 80809ace67
121 changed files with 1602 additions and 4532 deletions
Download patch file Download diff file Expand all files Collapse all files

85
src/crypto/Random.cpp
View file

@ -17,46 +17,64 @@
#include "Random.h"
#include <gcrypt.h>
#include "core/Global.h"
#include "crypto/Crypto.h"
class RandomBackendGcrypt : public RandomBackend
{
public:
void randomize(void* data, int len) override;
};
#include <QPointer>
#include <QSharedPointer>
#include <botan/auto_rng.h>
#include <botan/system_rng.h>
QSharedPointer<Random> Random::m_instance;
QSharedPointer<Random> Random::instance()
{
if (!m_instance) {
m_instance.reset(new Random());
}
return m_instance;
}
Random::Random()
{
#ifdef BOTAN_HAS_SYSTEM_RNG
m_rng.reset(new Botan::System_RNG);
#else
m_rng.reset(new Botan::Autoseeded_RNG);
#endif
}
QSharedPointer<Botan::RandomNumberGenerator> Random::getRng()
{
return m_rng;
}
void Random::randomize(QByteArray& ba)
{
m_backend->randomize(ba.data(), ba.size());
m_rng->randomize(reinterpret_cast<uint8_t*>(ba.data()), ba.size());
}
QByteArray Random::randomArray(int len)
{
QByteArray ba;
ba.resize(len);
QByteArray ba(len, '\0');
randomize(ba);
return ba;
}
quint32 Random::randomUInt(quint32 limit)
{
Q_ASSERT(limit != 0);
Q_ASSERT(limit <= QUINT32_MAX);
if (limit == 0) {
return 0;
}
quint32 rand;
const quint32 ceil = QUINT32_MAX - (QUINT32_MAX % limit) - 1;
// To avoid modulo bias:
// Make sure rand is below the largest number where rand%limit==0
// To avoid modulo bias make sure rand is below the largest number where rand%limit==0
do {
m_backend->randomize(&rand, 4);
m_rng->randomize(reinterpret_cast<uint8_t*>(&rand), 4);
} while (rand > ceil);
return (rand % limit);
@ -66,38 +84,3 @@ quint32 Random::randomUIntRange(quint32 min, quint32 max)
{
return min + randomUInt(max - min);
}
Random* Random::instance()
{
if (!m_instance) {
m_instance.reset(new Random(new RandomBackendGcrypt()));
}
return m_instance.data();
}
void Random::resetInstance()
{
m_instance.reset();
}
void Random::setInstance(RandomBackend* backend)
{
m_instance.reset(new Random(backend));
}
Random::Random(RandomBackend* backend)
: m_backend(backend)
{
}
void RandomBackendGcrypt::randomize(void* data, int len)
{
Q_ASSERT(Crypto::initialized());
gcry_randomize(data, len, GCRY_STRONG_RANDOM);
}
RandomBackend::~RandomBackend()
{
}