Дневник Шестеро Михаила - April 21st, 2014

Apr. 21st, 2014

12:00 am - Шифровка потока информации PHP-HTTP-Qt. Часть 2

...Это продолжение, начало см. Часть 1!

Decrypter-объект m_decrypter логически "вставляется" между входным потоком QNetworkReply и приёмником QxmlInputSource :

    connect(m_pManager, SIGNAL(finished(QNetworkReply*)),
            this, SLOT(onFinish(QNetworkReply*)));

…
    m_reader = new QXmlSimpleReader;
    // connect QXmlSimpleReader to handlers
    m_reader->setContentHandler(this);
    m_reader->setErrorHandler(this);

    QNetworkRequest request(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");

    m_first = true;
    m_timestart.start(); // = QTime::currentTime();
    m_timestop  = QTime();
    m_reply = m_pManager->post( request, postData().encodedQuery() );
    qDebug() << "Got new m_reply=" << m_reply;
    //m_reply->setReadBufferSize(16*1024);

    m_decrypter = new Decrypter(m_reply, m_pSettings);
    m_xmlsource = new QxmlInputSource(m_decrypter); // [**]

    connect(m_reply, SIGNAL(readyRead()), this, SLOT(onReadyRead()) );
    connect(m_reply, SIGNAL(downloadProgress(qint64, qint64)),
            this,  SLOT(onDownloadProgress(qint64, qint64)));
К сожалению, мне не удалось добиться того, что бы Decryptor работал в точности также как объект QNetworkReply; возможно причина в том, что он выдаёт информацию только 16-байтовыми порциями и не может в конце правильно оценить размер, но в handler-е SAX-парсера не запускался endDocument();
Мне удалось тем не менее заставить это работать как надо дополнительно «стимулируя» Decryptor в обработчиках сигналов readyRead() и downloadProgress(qint64, qint64)
(если не использовать шифрование и класть m_reply вместо m_decrypter в QxmlInputSource() это не требуется:

void WorkplaceTab::onReadyRead()
{
    if ( m_reader==NULL || m_xmlsource==NULL )
    {
        qDebug() << "WorkplaceTab::onReadyRead() - warning";
        return;
    }

    if (m_first)
    {
        // выполняется один раз - при приёме превой порции данных
        qDebug() << "m_reader->parse(m_xmlsource, true);";
        if (!m_reader->parse(m_xmlsource, true))
            to_idle_state(); // прекращение режима приёма
        m_first = false;
    }

    long watchdog = 100;
    while ( m_decrypter!=NULL && m_decrypter->bytesAvailable()>0 )
    {
        m_xmlsource->fetchData();
        if (!m_reader->parseContinue())
            to_idle_state();    // прекращение режима приёма

        if (watchdog--<0)
            break;
    }
}

void WorkplaceTab::onDownloadProgress(qint64 bytesReceived, qint64 bytesTotal)
{
    logmessage( tr("%1 bytes and %2 rows loaded").arg(bytesReceived).arg(m_row) );

    if (bytesReceived==bytesTotal)
    {
        // выполняется один раз - после приёма последней порции данных
        qDebug() << "WorkplaceTab::onDownloadProgress LAST TIME";
        if (m_reader==NULL || m_xmlsource==NULL || m_reply==NULL)
        {
            qDebug() << "Warning: m_reader==NULL or m_xmlsource==NULL or m_reply==NULL!";
            return;
        }

        long watchdog=1000000;
        bool b=true;
        while (b && m_xmlsource->data().length()>0 &&--watchdog)
            b = m_reader->parseContinue();

        if (b)
        {
            m_xmlsource->next();        // и ещё раз - вхолостую -
            m_reader->parseContinue();  // что бы вызвалось QXmlInputSource::EndOfDocument
        }
        /*
        if (m_row<=0) // TODO: проверка что QXmlInputSource::EndOfDocument не отработал
            to_idle_state(); // грубая остановка
        */
    }
}

// ?? иногда вызывается до завершения разборки XML! :-O
void WorkplaceTab::onFinish(QNetworkReply *reply)
{
    qDebug() << "WorkplaceTab::onFinish";

    m_timestop.start(); // = QTime::currentTime();

    bool anew = false;

    // отсоединяем обработчики onReadyRead и onDownloadProgress
    //reply->disconnect();
    disconnect(reply, SIGNAL(readyRead()), this, SLOT(onReadyRead()) );
    disconnect(reply, SIGNAL(downloadProgress(qint64, qint64)),
            this,  SLOT(onDownloadProgress(qint64, qint64)));
....
Может кто-то поможет с этим окончательно разобраться?
На этом на сегодя всё... вот так … :-)
Надеюсь вам было интересно!(?)

Tags: , , , , , , ,
Current Mood: [mood icon] satisfied

12:06 am - Шифровка потока информации PHP-HTTP-Qt. Часть 1

В этом посте расскажу о том, как поточно шифровать данные, передаваемые из PHP-скрипта в программу-клиент по HTTP. «Поточно» обозначает, что шифровка-передача-расшифровка происходит параллельно их поступлению (в данном случае из небуферизированного запроса к MySQL).
Как известно, данные передаваемые по HTTP никак не защищены и могут быть легко перехвачены и даже изменены на промежуточных узлах сети. Поэтому, если не использовать HTTPS, весьма уместно ценные данные при передаче зашифравать.

Данные я предаю в формате XML. Программа клиент сделаная на C++ и Qt расшифровав, направляет их в SAX-парсер (QXmlSimpleReader, XML-handler) и далее в GUI-таблицу QTableWidget «на лету».

Шифровка на сервере выполняется исключительно средствами PHP (поточным фильтром). Для расшифровки информации в клиенте я использовал библиотеку CryptoC++.
Я использовал древнюю Qt 4.5.0. Программа клиент разрабатывалась и компилировалась под Linux, а также (кросс-компилятором) под Windows.
Шифр я выбрал Twofish, который сейчас считается весьма стойким. Шифромание и дешифровка Twofish происходит блоками по 16 байт, причём я использовал режим сцеплания блоков шифротекста (CBC).

Я использовал два пароля — один общий для всех пользователей — вбивается в HEX-формате в настройках программы. Там же вбивается общий начальный вектор инициализации блока шифрования. Также у пользователя есть индивидуальный (относительно короткий) пароль, который он вводит каждый раз при старте программы для авторизации.
Для авторизации я посылаю POST-параметром HEX-форму индивидуального пароля пользователя, зашифрованный общим паролем (переведённым в бинарный формат из HEX-представления). На сервере происходит расшифровка его и сопоставление с хранящимся там паролем (или MD5-суммой).
Конечно, ещё стоит добавить до шифровки изменяющуюся не повотояющуюся последовательность, для того что бы нельзя было тупо перехватить и использовать это шифрованное значение. Сделаю это в будущем.
Рабочий ключ для шифровки и расшифровки данных создаю из бинарного представления MD5-суммы индивидуального пароля и из общего пароля беря оттуда и оттуда байты по очереди.
Мой серверный скрипт умеет посылать нешифрованный ответ — это удобно в случае если произошла какая-то ошибка (например, пароль не верный) и для отладки. Для того что бы отличать шифрованный ответ от не шифрованного в первом случае я в начале отправляю «заголовок» - 32 байта (два 16-байтовых блока), первый из которых является нулём. В XML-е вообще не должно быть нулевых байт, так что это — надёжный признак. Не шифрованный XML идёт обычно, без всякого заголовка.
Все эти детали не относятся прямо к теме, но, надеюсь, они помогут разобраться в моём коде, который я привожу в статье. Он уже прошёл "обкадку" и с уверенностью можно сказать, что всё работает надёжно под Linux и Windows (по крайней мере при компиляции с библиотеками, которые у меня)!

Вот важные фрагменты PHP серверной части:
date_default_timezone_set("Europe/Moscow");

@
ini_set('output_buffering'0);

header('Content-Transfer-Encoding: binary');

$alg  MCRYPT_TWOFISH// MCRYPT_TripleDES; // MCRYPT_PANAMA;
$mode MCRYPT_MODE_CBC// MCRYPT_MODE_STREAM;
$ivsize mcrypt_get_iv_size($alg,$mode); 
$z="";for($i=0;$i<$ivsize;$i++) $z.="\0"// нулевой блок
$iv=$z;

// получаем вектор инициализации из таблицы с настроечными параметрами:
$ksql "SELECT *, MD5(value) as M FROM parameters WHERE name='iv'";
$rr0a $mysqli1->query($ksql); 
if ( 
$rr0a && ($row $rr0a->fetch_assoc()) )
{
  
$ivh $row["M"]; // MD5
  // assert length($ivh)=32
  
$b pack("H*"$ivh); // OR:
  // $b = hex2bin($ivh); // request PHP 5.4 !
  
if ($b===false)
  {
    
$message "110\tCannot decode initialization vecto$ivh!";
  }
  else
  {
    
$iv $b;
  }
}


// проверка авторизации происходит так:
$password = (string)pack("H*"$password );
$password trimmcrypt_decrypt($alg$key$password$mode$iv), "\x00..\x1F" );
user_check$user$password ); // set second argument to false here to disable passwords
$pwd md5($password);



ob_flush
();
$f fopen('php://output''w'); // пишем XML-информацию так: fwrite( $f, …);
// ...[*]...

$encr = ((!$message) || $message<=""); // $message у меня сигнализирует об ошибке
//$encr = false; ← что бы отключить шифровку для отладки

if ($encr) echo $z.md5($iv,true); // write 16 zero bytes + 16 bytes of iv (признак шифрованной информации - «заголовок»)


// формирование рабочего ключа mix $key and $pwd into $key1
$pwd pack("H*"$pwd); // convert to binary
$key1="";
for (
$i=0$i<strlen($key) && $i<strlen($pwd); $i++)
$key1.=$key[$i].$pwd[$i]; }
if (
strlen($key)>strlen($pwd)) $key1.=substr($key,strlen($pwd));
if (
strlen($key)<strlen($pwd)) $key1.=substr($pwd,strlen($key));
// note that maximum key lenght may exceeded
// Twofish::MAX_KEYLENGTH
//$key1=$pwd;

$opts = array('iv'=>$iv'key'=>$key1);
if (
$encrstream_filter_append($f"mcrypt.$alg"STREAM_FILTER_WRITE$opts); // <== активируем поточный фильтр-шифровальщик
//stream_filter_append($f, 'convert.base64-encode');

fwrite($f'<?xml version="1.0" encoding="UTF-8"?>'."\n" ); // и понеслось...

Для того что бы это работало, разумеется нужна поддержка соответствующего фильтра mcrypt.* в PHP. Проверить это можно с помощью функции phpinfo().

На стороне клиента шифрование индивидуального пароля для авторизации и формирование запроса происходит так:

QByteArray Dialog_Settings::encrypt(const QString& plain_str)
{
    byte iv[ CryptoPP::Twofish::BLOCKSIZE ];
    memset(iv,0,sizeof(iv));

    CryptoPP::SecByteBlock keyblock( CryptoPP::Twofish::DEFAULT_KEYLENGTH );

    const QByteArray iva = get_iv();
    // assert iva.size()==BLOCKSIZE()==16
    for (int i=0; i<CryptoPP::Twofish::BLOCKSIZE; i++) iv[i]=iva[i];

    const QString k = get_key();
    qDebug() << "key=" << k;
    keyblock.Assign(
        (const unsigned char*)
        QByteArray::fromHex(k.toLatin1()).data(), // k.toStdString().c_str(),
        k.toStdString().length()/2
    );

    try
    {
        const std::string plain = plain_str.toStdString();
        std::string cipher;

        CryptoPP::CBC_Mode< CryptoPP::Twofish >::Encryption e(
            keyblock, keyblock.size(), iv );

        // The StreamTransformationFilter adds padding
        //  as required. ECB and CBC Mode must be padded
        //  to the block size of the cipher.
        {
            CryptoPP::StringSource ss( plain, true,
                new CryptoPP::StreamTransformationFilter(
                    e,
                    new CryptoPP::StringSink( cipher )
                ) // StreamTransformationFilter
            ); // StringSource
        }

        qDebug() << plain_str << "encryped. size=" << cipher.length();

        return QByteArray( cipher.c_str(), cipher.length() );
    }
    catch( const CryptoPP::Exception& e )
    {
        qDebug() << "Error encryption: " << e.what() << endl;

        return QByteArray();
    }
}
..........

            bool ok = false;
            QString p = QInputDialog::getText(
                    this, // NULL, // this
                    tr("Password"),
                    get_username().isEmpty()?
                        tr("Enter user passord"):
                        tr("Enter password for %1").arg(
                                QString("<b>")+get_username()+"</b>"),
                    QLineEdit::Password,
                    v,
                    &ok,
                    Qt::Window | Qt::WindowStaysOnTopHint // Qt::WType_TopLevel // obsolete
            );
            if (ok)
            {
                m_encrypted = encrypt(p);
..........

    const QString surl = baseurl()+"/xml.php?user="+user;

    QUrl url( surl );

    QUrl postData;
    foreach (const RequestItem& wh, hr.reqrec.where())
    {
        postData.addQueryItem("where[]", wh.where());
    }
    foreach (const QString& col, m_pTableWidget->m_hidden[hr.table])
    {
        postData.addQueryItem("skip[]", col);
        qDebug() << "at table" << hr.table << " skipped " << col;
    }
    qDebug() << "sending password...";
    qDebug() << m_pSettings->get_enc().toHex();
    postData.addQueryItem("password", m_pSettings->get_enc().toHex());  // ← m_pSettings->m_encrypted

    QNetworkRequest request(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
так как шифрование происходит блоками, нужно что бы входная информация была дополнена до размера кратного длине блока («padding»). Для этого служит класс StreamTransformationFilter, дополнение происходит нулями. Кстати, поточный фильтр mcrypt.TwoFish в PHP тоже для этого использует нулевые байты (и это вроде нигде не написано). Т.к. мы передаём XML, т. е. plain-текст, в котором нет нулевых байт, мы легко можем удалить их с конца (см «де-padding» в конце кода метода Decrypter::readData ниже).

Для поточной расшифровки я сделал класс-обёртку QIODevice под названием Decrypter.
Для начала посмотрите код его заготовки - класса-пустышки Decrypter0, который ничего не делает (можно использовать для отладки, отключив шифрование в PHP):
class Decrypter0 : public QIODevice
{
    Q_OBJECT

public:
    // Decrypter0() {}

    // my methods:
    virtual void unset() { m_source=NULL; } // { setSource(NULL); }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
    virtual bool setSource(QIODevice* source, QWidget* topwidget)
    { m_source=source; return false; }
#pragma GCC diagnostic pop

    // QIODevice virtual;
    virtual qint64 bytesAvailable () const
    { return m_source==NULL? 0: m_source->bytesAvailable(); }

    virtual bool atEnd() const
    { return m_source==NULL? true: m_source->atEnd(); }

    virtual qint64 size() const
    { return m_source==NULL? 0: m_source->size(); }

    virtual bool open(OpenMode mode)
    {   qDebug() << "open called";
        QIODevice::open(mode);
        if (m_source==NULL) return false;
        return m_source->open(mode);
    }
    virtual void close()
    { QIODevice::close(); if (m_source!=NULL) m_source->close(); }

    // ### Qt 5: pos() and seek() should not be virtual, and
    // ### seek() should call a virtual seekData() function.
    virtual qint64 pos() const
    { return m_source==NULL? qint64(0): m_source->pos(); }
    virtual bool seek(qint64 pos) const
    { return m_source==NULL? false: m_source->seek(pos); }
    virtual bool reset() const
    { return m_source==NULL? false: m_source->reset(); }

    virtual bool canReadLine() const
    { return m_source==NULL? false: m_source->canReadLine(); }

    virtual bool isSequential() const { return true; }

    virtual bool waitForReadyRead ( int msecs )
    { return m_source==NULL? false: m_source->waitForReadyRead(msecs); }

protected:
    virtual void connectNotify ( const char * signal )
    {
        qDebug() << "Don't try to connect the signal to decriptor! "
                 << QLatin1String(signal);
        exit(109);
    }

    virtual qint64 readData(char *data, qint64 maxlen)
    { return m_source==NULL? 0: m_source->read(data,maxlen); }
    // read method is not virtual !

    virtual qint64 readLineData(char *, qint64)
    { exit(111); }

    virtual qint64 writeData(const char *, qint64) { return 0; } // read-only

    QIODevice* m_source;
};
А вот сам Decrypter:
Описание:
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wtype-limits"
#include "cryptopp/cryptlib.h"
#include "cryptopp/twofish.h"
#include "cryptopp/modes.h"
#pragma GCC diagnostic pop

#include <QIODevice>

class Decrypter : public QIODevice
{
    Q_OBJECT

public:
    Decrypter(QIODevice* source, const Dialog_Settings* settings);

    inline qint64 BLOCKSIZE() const;

    virtual qint64 bytesAvailable() const;

    virtual bool atEnd() const { return m_source==NULL? true: m_source->atEnd(); }

    bool unencrypted()  { return !m_protected; } // признак отсутствия шифрования
    size_t get_gc()     { return m_gc; } // только для отладки

protected:
    virtual qint64 readData(char *data, qint64 maxlen);
    virtual qint64 writeData(const char *, qint64) { return 0; } //Этот класс read-only

    QIODevice* m_source;
    bool           m_first;
    bool           m_protected;

    size_t         m_gc;// globar data bytes counter; temporary/ debug - только для отладки

    CryptoPP::CBC_Mode< CryptoPP::Twofish >::Decryption m_d; // дешифратор
};
Имплементация:
#include "decrypter.h"

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wtype-limits"
#include "cryptopp/filters.h"    // StringSink
#include "cryptopp/osrng.h"      // AutoSeededRandomPool
//#include "cryptopp/hex.h"      // HexEncoder
#include "cryptopp/base64.h"
#pragma GCC diagnostic pop

#include <string>
#include <iostream>

#include "dialog_settings.h"

#include <QDebug>


using namespace CryptoPP;

Decrypter::Decrypter(QIODevice* source, const Dialog_Settings* settings)
    : m_source(source)
    , m_first(true)
    , m_protected(false)    // Обозначает, что принимаются/приняты шифрованные данные
    , m_gc(0)
{
    m_first = true;
    m_protected = false;

    byte iv[ BLOCKSIZE() ];
    memset(iv,0,sizeof(iv));

    SecByteBlock keyblock( Twofish::DEFAULT_KEYLENGTH );

    if (settings!=NULL)
    {
        const QByteArray iva = settings->get_iv(); // initialization vector
        // assert iva.size()==BLOCKSIZE()==16
        for (int i=0; i<BLOCKSIZE(); i++) iv[i]=iva[i];

        // формирование рабочего ключа
        QByteArray kk = QByteArray::fromHex(settings->get_key().toLatin1());
        QByteArray kp = QByteArray::fromHex(settings->get_pwd().toLatin1());
        QByteArray k; // Keyblock is to compose from common secret key and user password
        for (int i=0; i<kk.size() || i<kp.size(); i++)
        {
            if (i<kk.size()) k.push_back( kk[i] );
            if (i<kp.size()) k.push_back( kp[i] );
            if (k.size()>=Twofish::MAX_KEYLENGTH)
                break;
        }
        keyblock.Assign(
            (const unsigned char*)
            k.data(), // k.toStdString().c_str(),
            k.size()
        );
    }

    m_d.SetKeyWithIV( keyblock, keyblock.size(), iv );
    // m_d=new CryptoPP::CBC_Mode< CryptoPP::Twofish >::Decryption(
    //  keyblock, keyblock.size(), iv );
}

qint64 Decrypter::BLOCKSIZE() const
{
    return Twofish::BLOCKSIZE;
}

qint64 Decrypter::bytesAvailable() const
{
    if (m_source==NULL) return 0;
    return m_protected?
                BLOCKSIZE()*(qint64)( m_source->bytesAvailable() / BLOCKSIZE() ) :
                m_source->bytesAvailable();
    //return m_source->bytesAvailable(); // <-- так не работает
}

qint64 Decrypter::readData(char *data, qint64 maxlen)
{
    //qDebug() << "Decrypter::m_source=" << m_source;
    if (m_source==NULL) return 0;

    //qDebug() << "Decrypter::m_first=" << m_first;
    if (m_first)
    {
        // выполняется только при приёме первого байта
        // - проверка признака шифровки
        const QByteArray test( (const QByteArray&) m_source->peek(1) );
        if (test.size()==0)
            return 0;
        m_protected = (test.size()==1 && test[0]==0); // передача зашифрована?
        qDebug() << "Data stream:" << (m_protected?"CRYPTED":"OPEN");
        if (m_protected) m_source->seek(32); // skip first 32 bytes ("header")
        m_first = false;
    }

    if (!m_protected)   // Если передача не шифруется просто перекладываем данные
    {
        qint64 r = m_source->read(data,maxlen);
        m_gc+=r;
        return r;
    }

    // qint64 len = BLOCKSIZE()*(qint64)( m_source->bytesAvailable() / BLOCKSIZE() );
    qint64 len = bytesAvailable();
    // qDebug() << "LEN=" << len;

    if (len>maxlen) len = maxlen;
    qint64 len1 = BLOCKSIZE()*((qint64)len/BLOCKSIZE());
    // assign(len1<=maxlen)
    qint64 s = m_source->read(data, len1);
    // assign(s==len1)
    // s - размер прочитанных данных до расшифровки
    size_t s2 = 0; // s2 - размер данных на выходе
    try {
        ArraySink *a = new ArraySink( (byte*)data, (size_t)s ); // объект-посредник для приёма данных в массив data
        StringSource ss( (const byte*)data, (size_t)s, true,
            new StreamTransformationFilter(
                m_d, // это объект CryptoPP::CBC_Mode< CryptoPP::Twofish >::Decryption
                a,
                StreamTransformationFilter::ZEROS_PADDING //StreamTransformationFilter::NO_PADDING
            ) // StreamTransformationFilter
        ); // Source
        s2 = a->TotalPutLength(); // получаем размер данных на выходе
    }
    catch( CryptoPP::Exception& e )
    {
        std::cerr << "Caught Crypto++ Exception: " << e.what() << std::endl;
    }
    for (int j=s-1; j>=s-BLOCKSIZE() && j>=0; j--) // де-padding
        if (data[j]==0) data[j]=' ';               // нулевые байты в конце заменяем пробелами
        else break;

    //qDebug() << "s2="<< s2 << "rest0="<< (len-s) << "rest="<< m_source->bytesAvailable();
    m_gc+=s2;
    //qDebug() << "global.counter=" << m_gc; // чисто для проверки
    return s2;
}

см. продолжение - Часть 2.

Tags: , , , , , , ,
Current Mood: [mood icon] satisfied
Previous day (Calendar) Next day