#include <QtCore/QCoreApplication>

#include <windows.h>
#include <WinCryptEx.h>
#include <cades.h>
#include <iostream>
#include <vector>
#include <QByteArray>
#include <QFile>
#include <QDebug>

#define CERT_STORE_NAME  L"MY"
#define SIGNER_NAME  L"Andrey" //"test_flash"


#pragma comment(lib, "crypt32")
#pragma comment(lib, "cades")


static QByteArray signmessage(const QByteArray &message_data) {
    PCCERT_CONTEXT pContext;
    HCERTSTORE hStoreHandle;

    if ( !( hStoreHandle = CertOpenStore(
       CERT_STORE_PROV_SYSTEM,
       0,
       NULL,
       CERT_SYSTEM_STORE_CURRENT_USER,
       CERT_STORE_NAME))) {
         qDebug()<< "The MY store could not be opened.\n";
    }

    if(pContext = CertFindCertificateInStore(
       hStoreHandle,
       X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
       0,
       CERT_FIND_SUBJECT_STR,
           SIGNER_NAME,
       NULL)) {
        qDebug()<< "The signer's certificate was found.\n";
    } else {
        qDebug()<< "Signer certificate not found.\n";
    }

    CRYPT_SIGN_MESSAGE_PARA signPara = { sizeof(signPara) };
    signPara.dwMsgEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
    signPara.pSigningCert = pContext; // 0 for window
    //signPara.HashAlgorithm.pszObjId = szOID_OIWSEC_sha1;
    signPara.HashAlgorithm.pszObjId = szOID_CP_GOST_R3411;

    CADES_SIGN_PARA cadesSignPara = { sizeof(cadesSignPara) };
    cadesSignPara.dwCadesType = CADES_BES;

    CADES_SIGN_MESSAGE_PARA para = { sizeof(para) };
    para.pSignMessagePara = &signPara;
    para.pCadesSignPara = &cadesSignPara;


    std::vector<BYTE> data(10,25);

    BYTE *pbToBeSigned = (BYTE*)message_data.data();//{ &data[0] };
    DWORD cbToBeSigned = message_data.size();//{ (DWORD)data.size() };

    PCRYPT_DATA_BLOB pSignedMessage = 0;
    if(!CadesSignMessage(&para,true,1,(const BYTE**)&pbToBeSigned,&cbToBeSigned,
        &pSignedMessage))
    {
        qDebug()<< "CadesSignMessage() failed";
        qDebug()<< GetLastError();
        return NULL;
    }


    std::vector<BYTE> message(pSignedMessage->cbData);
    std::copy(pSignedMessage->pbData,
        pSignedMessage->pbData + pSignedMessage->cbData,message.begin());
    QByteArray message_signed((char*)(pSignedMessage->pbData), pSignedMessage->cbData);

    if(!CadesFreeBlob(pSignedMessage))
    {
        qDebug()<< "CadesFreeBlob() failed";
        return NULL;
    }

    qDebug()<< "OK! Signed successful!";

    return message_signed;
}


static bool signmessageverify(const QByteArray &message_signed, const QByteArray &message_data) {

    CRYPT_VERIFY_MESSAGE_PARA cryptVerifyPara = { sizeof(cryptVerifyPara) };
        cryptVerifyPara.dwMsgAndCertEncodingType =
            X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;

        CADES_VERIFICATION_PARA cadesVerifyPara = { sizeof(cadesVerifyPara) };
        cadesVerifyPara.dwCadesType = CADES_BES;

        CADES_VERIFY_MESSAGE_PARA verifyPara = { sizeof(verifyPara) };
        verifyPara.pVerifyMessagePara = &cryptVerifyPara;
        verifyPara.pCadesVerifyPara = &cadesVerifyPara;

        PCADES_VERIFICATION_INFO pVerifyInfo = 0;

        BYTE *pbToBeSigned = (BYTE*)message_data.data();
        DWORD cbToBeSigned = message_data.size();

        if(!CadesVerifyDetachedMessage(&verifyPara,0,
            (const BYTE*)(message_signed.constData()),message_signed.size(),1,(const BYTE**)&pbToBeSigned,&cbToBeSigned,&pVerifyInfo))
        {
            CadesFreeVerificationInfo(pVerifyInfo);
            qDebug() << "CadesVerifyMessage() failed";
            qDebug()<< GetLastError();
            return false;
        }


        if(pVerifyInfo->dwStatus != CADES_VERIFY_SUCCESS )
            qDebug() << "CAdES-BES message is not verified successfully.";
        else
            qDebug() << "CAdES-BES message verified successfully.";


    return true;
}



int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    QFile fl_signed_new("page1_signed_new.jpg");
    QFile fl_signed("page1_signed.jpg");
    QFile fl("page1.jpg");
    QByteArray message_data ;
    QByteArray signed_msg;
    QByteArray signed_msg_readed;
    if ( fl.open(QIODevice::ReadOnly)) {
      message_data = fl.readAll();
      fl.close();
    }

    if ( fl_signed.open(QIODevice::ReadOnly)) {
      signed_msg_readed = fl_signed.readAll();
      fl_signed.close();
    }

    qDebug()<< "veryfy signed:" << (signmessageverify(signed_msg,message_data)?"Y":"N");
    qDebug()<< "veryfy readed:" << (signmessageverify(signed_msg_readed,message_data)?"Y":"N");

    signed_msg = signmessage(message_data);
    if ( fl_signed_new.open(QIODevice::WriteOnly) )
    {
      fl_signed_new.write(signed_msg);
      fl_signed_new.close();
    }

    return a.exec();
}