userid.cpp

#include "userid.h"

#include <QCryptographicHash>
#include <QRandomGenerator>
#include <QSettings>
#include <QSysInfo>

namespace UserId {

const char* const kSaltKey            = "usage/userIdSalt";
const char* const kMachineFallbackKey = "usage/machineIdFallback";

namespace {

constexpr int kSaltBytes = 32;   // 256 bits — the whole point is that it is not guessable

QByteArray randomBytes(int count)
{
    QByteArray bytes(count, Qt::Uninitialized);
    // The system generator, not the default one: this value's only job is to be
    // unguessable, so a seedable PRNG would defeat it.
    QRandomGenerator::system()->generate(bytes.begin(), bytes.end());
    return bytes;
}

// Reads a base64 blob from `store`, minting and storing `count` random bytes
// the first time (or if the stored value is missing/corrupt).
QByteArray persistentRandom(QSettings& store, const char* key, int count)
{
    const QByteArray stored =
        QByteArray::fromBase64(store.value(QLatin1String(key)).toString().toLatin1());
    if (stored.size() == count)
        return stored;

    const QByteArray fresh = randomBytes(count);
    store.setValue(QLatin1String(key), QString::fromLatin1(fresh.toBase64()));
    return fresh;
}

} // namespace

QByteArray installSalt(QSettings& store)
{
    return persistentRandom(store, kSaltKey, kSaltBytes);
}

QByteArray machineId(QSettings& store)
{
    // Windows: registry MachineGuid.  Linux: /etc/machine-id (or
    // /var/lib/dbus/machine-id).  macOS: IOPlatformUUID.
    const QByteArray id = QSysInfo::machineUniqueId();
    if (!id.isEmpty())
        return id;

    // Nothing to read — a container, a hardened Linux install with no
    // machine-id file, or a platform Qt has no implementation for.  A stable
    // per-install random value keeps the reported id from churning every launch;
    // it means "same install" rather than "same machine", which is what the
    // statistics actually use it for.
    return persistentRandom(store, kMachineFallbackKey, kSaltBytes);
}

QString hashedUserId(const QByteArray& salt, const QByteArray& machineId)
{
    QCryptographicHash hash(QCryptographicHash::Sha256);
    hash.addData(salt);
    // A separator so that (salt, machineId) pairs cannot collide by shifting the
    // boundary between the two — belt and braces given the salt is fixed-length.
    hash.addData(QByteArrayLiteral(":"));
    hash.addData(machineId);
    return QString::fromLatin1(hash.result().toHex());
}

QString hashedUserId(QSettings& store)
{
    return hashedUserId(installSalt(store), machineId(store));
}

} // namespace UserId