crypto

#include <Windows.h>
#include <wincrypt.h>
#include <iostream>

using namespace std;


void ErrorHandling(){
    DWORD dw = GetLastError();
    cout << "Error: " << hex << dw << endl;
    exit(1);
}


int main()
{
    // TODO
    // реализация лабораторной работы 5
    // провести оптимизацию кода
    // добавить метод для освобождения из памяти объектов
    // возможно, потребуется вынести их как глобальные переменные

    HCRYPTPROV      hProv;
    HCRYPTHASH      hHash;
    HCRYPTKEY       hKey;
    string          hashData = "Example String";
    PBYTE           pbBuffer = PBYTE(hashData.c_str()); // массив типа BYTE*, в котором зашифрована строка
    DWORD           dwBufferLen = DWORD(strlen(reinterpret_cast<char*>(pbBuffer)) + 1); // длина массива

    // создание и проверка цифровой подписи
    // Взаимодействие двух сторон: подписывающей и проверяющей ЦП

    // Дескриптор CSP

    if (CryptAcquireContext(&hProv, nullptr,
            nullptr,
            PROV_RSA_FULL,
            0))
    {
        cout << "CryptAcquireContext Successful. \n";
    }
    else
        ErrorHandling();

    // --- Подписывающая сторона ---
    cout << "\t\tCreating signature\n";
    // Получение открытого ключа

    if (CryptGetUserKey(hProv,AT_KEYEXCHANGE,&hKey))
    {
        cout << "CryptGetUserKey successful. \n";
    }
    else
    {
        if (GetLastError() == 0x8009000D) // nte_no_key == 0x8009000D
        {
            if (!CryptGenKey(hProv,AT_KEYEXCHANGE, CRYPT_EXPORTABLE, &hKey))
            {
                ErrorHandling();
            }
        }
    }

        // Экспорт открытого ключа для использования проверяющей стороной

        BYTE*           pbBlob; // BLOB в котором мы будем хранить ключ
        DWORD           dwBlobLen = 0; // длина BLOB

        // Вычисление объема памяти для экспорта ключа

        if (CryptExportKey(hKey,NULL,PUBLICKEYBLOB,0,NULL,
                           &dwBlobLen))
        {
            cout << "Computing size of blob succeed.\n";
        }
        else
            ErrorHandling();

        // Непосредственный экспорт ключа
        // Выделяем память под blob

        pbBlob = new BYTE[dwBlobLen];

        if (CryptExportKey(hKey,NULL,PUBLICKEYBLOB,0,pbBlob,&dwBlobLen))
        {
            cout << "Export key to BLOB succeed.\n";
        }
        else
            ErrorHandling();

        // Вывод информации о BLOB

        cout << "BLOB has been created!\n"
            << "BLOB Length: " << dwBlobLen << "\n";
        cout << "Out BLOB\n";
        for (int i = 0; i < static_cast<int>(dwBlobLen); i++)
            cout << pbBlob[i];
        cout << "\n";

        // Теперь мы имеем БЛОБ, который можно экспортировать файл для передачи проверяющей стороне

        // Уничтожаем информацию о ключе

        if (hKey)
        {
            cout << "Key has been deleted.\n";
            CryptDestroyKey(hKey);
        }

        // Вычисление хеш-значения подписываемых данных массива типа BYTE (PBYTE)

        // Создаём хеширующий объект

        if (CryptCreateHash(hProv,CALG_MD5,0,0,&hHash))
        {
            cout << "Hash object has been created\n";
        }
        else
        {
            ErrorHandling();
        }

        // Вычисление хеша

        if (CryptHashData(hHash,pbBuffer,dwBufferLen,0))
        {
            cout << "The data has been hashed successful. \n";
        }
        else
        {
            ErrorHandling();
        }

        // Вычисление размера памяти под подписываемый объект

        BYTE*           pbSign; // буфер подписи
        DWORD           dwSignLen = 0; // длина буфера подписи

        if (CryptSignHash(hHash, AT_KEYEXCHANGE, NULL, 0, NULL, &dwSignLen))
        {
            cout << "Computing size of signature buffer succeed. \n";
        }
        else
        {
            ErrorHandling();
        }

        pbSign =  new BYTE[dwSignLen];

        // Подпись объекта

        if (CryptSignHash(hHash, AT_KEYEXCHANGE, NULL,0,pbSign,&dwSignLen))
        {
            cout << "Signature has been successful created.\n";
        }
        else
        {
            ErrorHandling();
        }

        // Отображение информации о подписи в консоль

        for (int i = 0; i < static_cast<int>(dwSignLen); i++)
            cout << pbSign[i];
        cout << endl;

        if (hHash)
        {
            cout << "Free memory of Hash. \n";
            CryptDestroyHash(hHash);
        }

        // --- Проверяющая сторона ---
        cout << "\t\tVerify signature\n";
        HCRYPTKEY hPublicKey; // Публичный ключ

        // Импорт открытого ключа из BLOB
        if (CryptImportKey(hProv,pbBlob,dwBlobLen,0,0,&hPublicKey))
        {
            cout << "The key has been imported successful. \n";
        }
        else
        {
            ErrorHandling();
        }

        // Хешируем объект

        // Создаём хеширующий объект

        if (CryptCreateHash(hProv,CALG_MD5,0,0,&hHash))
        {
            cout << "Hash object has been created\n";
        }
        else
        {
            ErrorHandling();
        }

        // Вычисление хеша

        if (CryptHashData(hHash,pbBuffer,dwBufferLen,0))
        {
            cout << "The data has been hashed successful. \n";
        }
        else
        {
            ErrorHandling();
        }

        // Проверка цифровой подписи

        bool verification = CryptVerifySignature(hHash,pbSign,dwSignLen,hPublicKey, nullptr,0);

        cout << endl;
        cout << ((verification)? "Signature verified!" : "NOT verified!") << endl;
        cout << endl;
        if (hProv)
        {
            cout << "Free memory of CSP. \n";
            CryptReleaseContext(hProv,0);
        }
        if (hPublicKey)
        {
            cout << "The Public key has been deleted.\n";
            CryptDestroyKey(hPublicKey);
        }
        delete [] pbBlob;
        delete [] pbSign;
        system("PAUSE");
        return 0;
        }