ZeroStorageCaptcha
/
cpp-lib
mirror of https://github.com/ZeroStorageCaptcha/cpp-lib
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
cpp-lib/zerostoragecaptcha.cpp

448 lines
13 KiB
C++
Raw Blame History

// GPLv3 (c) acetone, 2022
// Zero Storage Captcha
// PNG generation based on:
/*
* Copyright (c) 2014 Omkar Kanase
* QtCaptcha: https://github.com/omkar-developer/QtCaptcha
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#include "zerostoragecaptcha.h"
#include <QTime>
#include <QBuffer>
#include <QDebug>
#include <QPainter>
#include <QPainterPath>
#include <QRandomGenerator>
#include <QRegularExpression>
#include <QCryptographicHash>
bool ZeroStorageCaptcha::m_onlyNumbers = false;
void ZeroStorageCaptcha::init()
{
ZeroStorageCaptchaService::TimeToken::init();
m_hmod1 = 0.0;
m_hmod2 = 0.0;
m_vmod1 = 0.0;
m_vmod2 = 0.0;
m_font.setStyleStrategy(QFont::ForceOutline);
m_font.setPointSize(50);
m_font.setBold(true);
m_font.setLetterSpacing(QFont::PercentageSpacing, QFont::SemiCondensed);
m_captchaImage = QImage(200, 100, QImage::Format_RGB32);
if (QTime::currentTime().msec() % 2 == 0)
{
m_backColor = Qt::GlobalColor::white;
m_fontColor = Qt::GlobalColor::black;
}
else
{
m_backColor = Qt::GlobalColor::black;
m_fontColor = Qt::GlobalColor::white;
}
m_padding = 5;
}
ZeroStorageCaptcha::ZeroStorageCaptcha()
{
init();
setDifficulty(1);
}
ZeroStorageCaptcha::ZeroStorageCaptcha(const QString &answer, int difficulty)
{
init();
setAnswer(answer);
setDifficulty(difficulty);
render();
}
bool ZeroStorageCaptcha::validate(const QString &answer, const QString &token)
{
return ZeroStorageCaptchaService::TokenManager::validateAnswer(answer, token);
}
void ZeroStorageCaptcha::setCaseSensitive(bool enabled)
{
ZeroStorageCaptchaService::TokenManager::setCaseSensitive(enabled);
}
bool ZeroStorageCaptcha::caseSensitive()
{
return ZeroStorageCaptchaService::TokenManager::caseSensitive();
}
QString ZeroStorageCaptcha::token() const
{
if (m_token.isEmpty())
{
m_token = ZeroStorageCaptchaService::TokenManager::get(m_captchaText);
}
return m_token;
}
QByteArray ZeroStorageCaptcha::picturePng() const
{
QByteArray data;
QBuffer buff(&data);
m_captchaImage.save(&buff, "PNG");
return data;
}
void ZeroStorageCaptcha::render()
{
QPainterPath path;
QFontMetrics fm(m_font);
path.addText(m_vmod2 + m_padding, m_hmod2 - m_padding + fm.height(), font(), answer());
qreal sinrandomness = QRandomGenerator::system()->generateDouble() * 5.0;
for (int i = 0; i < path.elementCount(); ++i)
{
const QPainterPath::Element& el = path.elementAt(i);
qreal y = el.y + sin(el.x / m_hmod1 + sinrandomness) * m_hmod2;
qreal x = el.x + sin(el.y / m_vmod1 + sinrandomness) * m_vmod2;
path.setElementPositionAt(i, x, y);
}
m_captchaImage = QImage(static_cast<int>(fm.horizontalAdvance(m_captchaText) + m_vmod2 * 2 + m_padding * 2),
static_cast<int>(fm.height() + m_hmod2 * 2 + m_padding * 2), QImage::Format_RGB32);
m_captchaImage.fill(backColor());
QPainter painter;
painter.begin(&m_captchaImage);
painter.setPen(Qt::NoPen);
painter.setBrush(fontColor());
painter.setRenderHint(QPainter::Antialiasing);
painter.drawPath(path);
if (m_drawLines)
{
painter.setPen(QPen(Qt::black, m_lineWidth));
for (int i = 0; i < m_lineCount; i++)
{
int x1 = static_cast<int>(QRandomGenerator::system()->generateDouble() * m_captchaImage.width());
int y1 = static_cast<int>(QRandomGenerator::system()->generateDouble() * m_captchaImage.height());
int x2 = static_cast<int>(QRandomGenerator::system()->generateDouble() * m_captchaImage.width());
int y2 = static_cast<int>(QRandomGenerator::system()->generateDouble() * m_captchaImage.height());
painter.drawLine(x1, y1, x2, y2);
}
painter.setPen(Qt::NoPen);
}
if (m_drawEllipses)
{
for (int i = 0; i < m_ellipseCount; i++)
{
int x1 = static_cast<int>(m_ellipseMaxRadius / 2.0 + QRandomGenerator::system()->generateDouble() * (m_captchaImage.width() - m_ellipseMaxRadius));
int y1 = static_cast<int>(m_ellipseMaxRadius / 2.0 + QRandomGenerator::system()->generateDouble() * (m_captchaImage.height() - m_ellipseMaxRadius));
int rad1 = static_cast<int>(m_ellipseMinRadius + QRandomGenerator::system()->generateDouble() * (m_ellipseMaxRadius - m_ellipseMinRadius));
int rad2 = static_cast<int>(m_ellipseMinRadius + QRandomGenerator::system()->generateDouble() * (m_ellipseMaxRadius - m_ellipseMinRadius));
if (backColor() == Qt::GlobalColor::black)
{
painter.setBrush(fontColor());
painter.setCompositionMode(QPainter::CompositionMode_Difference);
} else {
painter.setBrush(backColor());
painter.setCompositionMode(QPainter::CompositionMode_Exclusion);
}
painter.drawEllipse(QPoint(x1, y1), rad1, rad2);
}
}
if (m_drawNoise)
{
for (int i = 0; i < m_noiseCount; i++)
{
int x1 = static_cast<int>(QRandomGenerator::system()->generateDouble() * m_captchaImage.width());
int y1 = static_cast<int>(QRandomGenerator::system()->generateDouble() * m_captchaImage.height());
QColor col = backColor() == Qt::GlobalColor::black ? Qt::GlobalColor::white : Qt::GlobalColor::black;
painter.setPen(QPen(col, m_noisePointSize));
painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
painter.drawPoint(x1, y1);
}
}
painter.end();
}
void ZeroStorageCaptcha::setSinDeform(qreal hAmplitude, qreal hFrequency, qreal vAmplitude, qreal vFrequency)
{
m_hmod1 = hFrequency;
m_hmod2 = hAmplitude;
m_vmod1 = vFrequency;
m_vmod2 = vAmplitude;
}
void ZeroStorageCaptcha::setDifficulty(int val)
{
short variant = QRandomGenerator::system()->bounded(1, 3);
if (val < 0 or val > 2)
{
qInfo().noquote() << QString(__PRETTY_FUNCTION__) << "Min difficulty is 0, maximal is 2";
}
if (val < 1)
{
m_drawLines = false;
m_drawNoise = false;
m_drawEllipses = true;
m_ellipseCount = 1;
m_ellipseMinRadius = 10;
m_ellipseMaxRadius = 40;
switch (variant) {
case 0:
setSinDeform(2, 5, 5, 15);
break;
case 1:
setSinDeform(5, 7, 7, 15);
break;
default:
setSinDeform(2, 1, 1, 10);
break;
}
}
else if (val == 1)
{
m_drawLines = true;
m_lineWidth = 2;
m_lineCount = 10;
m_drawEllipses = true;
m_ellipseCount = 2;
m_ellipseMinRadius = 20;
m_ellipseMaxRadius = 30;
m_drawNoise = true;
m_noiseCount = 30;
m_noisePointSize = 5;
switch (variant) {
case 0:
setSinDeform(2, 5, 5, 25);
break;
case 1:
setSinDeform(6, 8, 8, 25);
break;
default:
setSinDeform(3, 6, 6, 15);
break;
}
}
else
{
m_drawLines = true;
m_lineWidth = 4;
m_lineCount = 9;
m_drawEllipses = true;
m_ellipseCount = 1;
m_ellipseMinRadius = 50;
m_ellipseMaxRadius = 70;
m_drawNoise = true;
m_noiseCount = 150;
m_noisePointSize = 4;
setSinDeform(2, 5, 5, 15);
}
}
void ZeroStorageCaptcha::setAnswer(const QString &answer)
{
m_captchaText = answer;
}
void ZeroStorageCaptcha::generateAnswer(int length)
{
if (length <= 0)
{
qInfo() << QString(__PRETTY_FUNCTION__) << "Invalid number of characters. Set to 5.";
length = 5;
}
m_captchaText = ZeroStorageCaptchaService::random(length, m_onlyNumbers);
}
//////////////////////////
constexpr const int TIME_TOKEN_SIZE = 5;
constexpr const int TIMER_TO_CHANGE_TOKEN_MSECS = 90000; // 1,5 min
constexpr const int KEY_STRING_SIZE = 32;
namespace ZeroStorageCaptchaService {
QTimer* TimeToken::m_updater = nullptr;
QString TimeToken::m_current;
QString TimeToken::m_prev;
QMutex TokenManager::m_usedTokensMtx;
QMap<QString, QSet<quint64>> TokenManager::m_usedTokens;
bool TokenManager::m_caseSensitive = false;
QString TokenManager::m_key = nullptr;
void TimeToken::init()
{
if (m_updater) return;
m_updater = new QTimer;
m_current = ZeroStorageCaptchaService::random(TIME_TOKEN_SIZE) + QString::number(QDateTime::currentSecsSinceEpoch());
m_updater->setInterval(TIMER_TO_CHANGE_TOKEN_MSECS);
QObject::connect (
m_updater, &QTimer::timeout,
[&]() {
m_prev = m_current;
m_current = ZeroStorageCaptchaService::random(TIME_TOKEN_SIZE);
TokenManager::removeAllTokensExceptPassed( currentToken(), prevToken() );
}
);
m_updater->start();
}
std::atomic<size_t> IdCounter::m_counter = 0;
size_t IdCounter::get()
{
size_t value = ++m_counter;
if (value == 0)
{
value++;
}
return value;
}
QString TokenManager::get(const QString &captchaAnswer, size_t id, bool prevTimeToken)
{
if (m_key.isEmpty())
{
m_key = random(KEY_STRING_SIZE); // init at first call
}
if (id == 0)
{
id = IdCounter::get();
}
// ANSWER + TIME_TOKEN + ID + SESSION_KEY
// TIME_TOKEN - temporary marker for limiting captcha life circle
// ID - size_t validation key for concrete captcha
// SESSION_KEY - random run-time session key for unique hash value
const QString base = (m_caseSensitive ? captchaAnswer : captchaAnswer.toUpper()) +
(prevTimeToken ? TimeToken::prevToken() : TimeToken::currentToken()) +
QString::number(id) + m_key;
const QByteArray hash = QCryptographicHash::hash(base.toUtf8(), QCryptographicHash::Md5);
QString b64Hash = hash.toBase64(QByteArray::Base64Option::Base64UrlEncoding);
static QRegularExpression rgx_OnlyLetters("[^a-zA-Z]");
b64Hash.remove(rgx_OnlyLetters);
QString token = b64Hash + "_" + QString::number(id);
return token;
}
bool TokenManager::validateAnswer(const QString &answer, const QString &token)
{
QString idString {token};
static QRegularExpression rgx_id("^.*_");
idString.remove (rgx_id);
bool idConvertingStatus = false;
size_t id = idString.toULongLong(&idConvertingStatus);
if (not idConvertingStatus or id == 0)
{
return false;
}
QString timeKey;
if (TokenManager::get(answer, id) == token)
{
timeKey = TimeToken::currentToken();
}
else if (TokenManager::get(answer, id, true) == token)
{
timeKey = TimeToken::prevToken();
}
if (timeKey.isEmpty())
{
return false;
}
QMutexLocker lock (&m_usedTokensMtx);
if (m_usedTokens.contains(timeKey))
{
if (m_usedTokens[timeKey].contains(id)) // already used
{
return false;
}
}
m_usedTokens[timeKey].insert( id );
return true;
}
void TokenManager::removeAllTokensExceptPassed(const QString& current, const QString& prev)
{
QMutexLocker lock (&m_usedTokensMtx);
std::list<QMap<QString, QSet<size_t>>::iterator> toRemove;
for (auto iter = m_usedTokens.begin(); iter != m_usedTokens.end(); iter++)
{
if (iter.key() != current and iter.key() != prev)
{
toRemove.push_back(iter);
}
}
for (const auto& iter: toRemove)
{
m_usedTokens.erase(iter);
}
}
QByteArray random(int length, bool onlyNumbers)
{
constexpr char randomtable[60] =
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'k', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D',
'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'h', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X'};
QByteArray random_value;
while(random_value.size() < length)
{
random_value += randomtable[ QRandomGenerator::system()->bounded (
onlyNumbers ? 0 : 1,
onlyNumbers ? 9 : 59
) ];
}
return random_value;
}
} // namespace ZeroStorageCaptchaService
Reference in New Issue View Git Blame Copy Permalink