asynckeysauth.h

Go to the documentation of this file.

/*
 * Copyright (C) 2021-2025 QuasarApp.
 * Distributed under the GPLv3 software license, see the accompanying
 * Everyone is permitted to copy and distribute verbatim copies
 * of this license document, but changing it is not allowed.
*/
 
#ifndef ASYNCKEYSAUTH_H
#define ASYNCKEYSAUTH_H
 
#include <QCryptographicHash>
#include <time.h>
#include <QString>
#include <easyssl/icrypto.h>
 
 
namespace EasySSL {
 
template<class CryptoImplementation>
class AsyncKeysAuth: public CryptoImplementation
{
public:
    AsyncKeysAuth() {
        //The CryptoImplementation class must be support ICrypto::Features::Signing feature
        assert(this->supportedFeatures() & ICrypto::Features::Signing);
    }
 
    ~AsyncKeysAuth() {
 
    }
 
    bool auth(int allowedTimeRangeSec, QString* retLoginedUserId) const {
 
        int diff = time(0) - _unixTime;
 
        if (diff < 0) {
            return false;
        }
 
        if (diff >= allowedTimeRangeSec) {
            return false;
        }
 
        QByteArray data = _publicKey;
        data.insert(0, reinterpret_cast<const char*>(&_unixTime),
                    sizeof(_unixTime));
 
        bool result = checkSign(data, _signature, _publicKey);
 
        if (result && retLoginedUserId) {
            *retLoginedUserId = getUserId();
        }
 
        return result;
    }
 
    bool prepare() {
        _unixTime = time(0);
 
        QByteArray data = _publicKey;
        data.insert(0, reinterpret_cast<const char*>(&_unixTime),
                    sizeof(_unixTime));
 
        setSignature(signMessage(data, getPrivateKey()));
 
        return isValid();
    }
 
    unsigned int unixTime() const {
        return _unixTime;
    }
 
    void setUnixTime(unsigned int newUnixTime) {
        _unixTime = newUnixTime;
    }
 
    const QByteArray &signature() const {
        return _signature;
    }
 
    bool isValid() const {
        return _publicKey.size() && _signature.size() && _unixTime;
    }
 
    QString getUserId() const {
        return QCryptographicHash::hash(_publicKey,
                                        QCryptographicHash::Sha256).
                toBase64(QByteArray::Base64UrlEncoding);
    }
 
 
    const QByteArray &publicKey() const {
        return _publicKey;
    }
 
    void setPublicKey(const QByteArray &newPublicKey) {
        _publicKey = newPublicKey;
    }
 
protected:
 
    QByteArray decrypt(const QByteArray &message, const QByteArray &key) override {
        return CryptoImplementation::decrypt(message, key);
    };
 
    QByteArray encrypt(const QByteArray &message, const QByteArray &key) override {
        return CryptoImplementation::encrypt(message, key);
    };
 
    QByteArray signMessage(const QByteArray &message, const QByteArray &key) const override {
        return CryptoImplementation::signMessage(message, key);
    };
 
    bool checkSign(const QByteArray &message, const QByteArray &signature, const QByteArray &key) const override {
        return CryptoImplementation::checkSign(message, signature, key);
    };
 
    virtual QByteArray getPrivateKey() const = 0;
 
    void setSignature(const QByteArray &newSignature) {
        _signature = newSignature;
    }
 
    unsigned int _unixTime = 0;
    QByteArray _signature;
    QByteArray _publicKey;
};
 
}
 
#endif // ASYNCKEYSAUTH_H