Code Viewer - BingoFish2.^

/***************************************************************************************
 *   _________  .___  ________   ________
 *  /   _____/  |   |/  _____/  /  _____/      ________.__.__  .________
 *  \_____  \   |   /   \  ___ /   \  ___     /  _____/|__|  | |   ____/
 *  /        \  |   \    \_\  \\    \_\  \   /   \  ___ |  |  | |____  \
 * /_______  /  |___|\______  / \______  /   \    \_\  \|  |  |/       \
 *         \/              \/         \/     \______  /|__|__/______  /
 *                                                 \/            (By BingoFish2)
 *   ASCII-арт: Условное изображение «BingoFish» (улучшенная версия Blowfish на базе AES)
 **************************************************************************************
 *
 *   BingoFish2 (русская версия) - демонстрационный пример, показывающий:
 *   1. Как использовать AES (ECB) при помощи библиотеки OpenSSL.
 *   2. Структуру класса CBingoFish2 со схожим интерфейсом, что и "BingoFish",
 *      но внутри используется AES вместо Blowfish.
 *
 *   ! ВАЖНО:
 *   - Для современной безопасной криптографии рекомендуется использовать режимы шифрования
 *     с аутентификацией (GCM/CCM), а не ECB.
 *   - Если нужен padding, его необходимо реализовать вручную или включить в OpenSSL.
 *
 **************************************************************************************/

#include <iostream>     // std::cout, std::endl
#include <vector>
#include <cstring>      // std::memcpy
#include <stdexcept>    // std::runtime_error
#include <openssl/evp.h>

/**
 * Класс CBingoFish2:
 * Реализует шифрование/дешифрование AES (ECB) через OpenSSL.
 *
 * - Конструктор принимает ключ размером 16, 24 или 32 байта (AES-128/192/256).
 * - Методы Encrypt/Decrypt доступны в вариантах "in-place" и "in->out".
 * - Включен "no-padding" (длина данных должна быть кратной 16 байтам).
 * g++ BingoFish2_ru.cpp -o BingoFish2_ru -lcrypto -lssl
 */
class CBingoFish2
{
public:
    /**
     * Конструктор:
     *  - key      - указатель на массив с ключом AES (16/24/32 байта).
     *  - keySize  - размер ключа в байтах.
     *
     * При инициализации создаются два контекста OpenSSL: для шифрования и для расшифрования.
     */
    CBingoFish2(const unsigned char* key, size_t keySize)
    {
        // Проверяем, что ключ корректного размера (16, 24 или 32 байта).
        if (keySize != 16 && keySize != 24 && keySize != 32)
        {
            throw std::runtime_error(
                "CBingoFish2: неподдерживаемый размер ключа. Допустимо 16, 24 или 32 байта (AES-128/192/256).");
        }

// Создаем структуры контекстов EVP.
        m_encryptCtx = EVP_CIPHER_CTX_new();
        m_decryptCtx = EVP_CIPHER_CTX_new();
        if (!m_encryptCtx || !m_decryptCtx)
        {
            throw std::runtime_error("CBingoFish2: ошибка при создании EVP_CIPHER_CTX");
        }

// Определяем EVP-алгоритм, исходя из размера ключа.
        const EVP_CIPHER* cipher = nullptr;
        switch (keySize)
        {
            case 16: cipher = EVP_aes_128_ecb(); break; // AES-128
            case 24: cipher = EVP_aes_192_ecb(); break; // AES-192
            case 32: cipher = EVP_aes_256_ecb(); break; // AES-256
        }

// Инициализируем контекст для шифрования (ECB, без IV).
        if (1 != EVP_EncryptInit_ex(m_encryptCtx, cipher, nullptr, key, nullptr))
        {
            throw std::runtime_error("CBingoFish2: не удалось инициализировать EncryptInit");
        }

// Инициализируем контекст для дешифрования (ECB, без IV).
        if (1 != EVP_DecryptInit_ex(m_decryptCtx, cipher, nullptr, key, nullptr))
        {
            throw std::runtime_error("CBingoFish2: не удалось инициализировать DecryptInit");
        }

// Отключаем автоматический padding в OpenSSL
        EVP_CIPHER_CTX_set_padding(m_encryptCtx, 0);
        EVP_CIPHER_CTX_set_padding(m_decryptCtx, 0);
    }

// Деструктор - освобождает контексты OpenSSL
    ~CBingoFish2()
    {
        if (m_encryptCtx) EVP_CIPHER_CTX_free(m_encryptCtx);
        if (m_decryptCtx) EVP_CIPHER_CTX_free(m_decryptCtx);
    }

/**
     * Шифрование in-place (ECB).
     *  - buf  - буфер исходных данных, результат шифрования сохраняется туда же.
     *  - n    - размер данных в байтах, должен быть кратен 16.
     */
    void Encrypt(unsigned char* buf, size_t n)
    {
        const size_t blockSize = 16; // Блок AES = 16 байт
        if (n % blockSize != 0)
        {
            throw std::runtime_error("Encrypt: длина данных должна быть кратна 16");
        }

unsigned char outBlock[16];
        int outLen = 0;

// Сбрасываем (reset) контекст шифрования
        EVP_EncryptInit_ex(m_encryptCtx, nullptr, nullptr, nullptr, nullptr);

// Обрабатываем каждый блок по 16 байт
        for (size_t offset = 0; offset < n; offset += blockSize)
        {
            if (1 != EVP_EncryptUpdate(m_encryptCtx, outBlock, &outLen, buf + offset, blockSize))
            {
                throw std::runtime_error("Encrypt: ошибка EVP_EncryptUpdate");
            }
            // Перекладываем результат обратно в buf
            std::memcpy(buf + offset, outBlock, blockSize);
        }
    }

/**
     * Дешифрование in-place (ECB).
     */
    void Decrypt(unsigned char* buf, size_t n)
    {
        const size_t blockSize = 16;
        if (n % blockSize != 0)
        {
            throw std::runtime_error("Decrypt: длина данных должна быть кратна 16");
        }

unsigned char outBlock[16];
        int outLen = 0;
        EVP_DecryptInit_ex(m_decryptCtx, nullptr, nullptr, nullptr, nullptr);

for (size_t offset = 0; offset < n; offset += blockSize)
        {
            if (1 != EVP_DecryptUpdate(m_decryptCtx, outBlock, &outLen, buf + offset, blockSize))
            {
                throw std::runtime_error("Decrypt: ошибка EVP_DecryptUpdate");
            }
            std::memcpy(buf + offset, outBlock, blockSize);
        }
    }

/**
     * Шифрование из буфера `in` в буфер `out` (ECB).
     */
    void Encrypt(const unsigned char* in, unsigned char* out, size_t n)
    {
        const size_t blockSize = 16;
        if (n % blockSize != 0)
        {
            throw std::runtime_error("Encrypt(in->out): длина данных должна быть кратна 16");
        }

int outLen = 0;
        EVP_EncryptInit_ex(m_encryptCtx, nullptr, nullptr, nullptr, nullptr);

for (size_t offset = 0; offset < n; offset += blockSize)
        {
            if (1 != EVP_EncryptUpdate(m_encryptCtx, out + offset, &outLen, in + offset, blockSize))
            {
                throw std::runtime_error("Encrypt(in->out): ошибка EVP_EncryptUpdate");
            }
        }
    }

/**
     * Дешифрование из буфера `in` в буфер `out` (ECB).
     */
    void Decrypt(const unsigned char* in, unsigned char* out, size_t n)
    {
        const size_t blockSize = 16;
        if (n % blockSize != 0)
        {
            throw std::runtime_error("Decrypt(in->out): длина данных должна быть кратна 16");
        }

int outLen = 0;
        EVP_DecryptInit_ex(m_decryptCtx, nullptr, nullptr, nullptr, nullptr);

for (size_t offset = 0; offset < n; offset += blockSize)
        {
            if (1 != EVP_DecryptUpdate(m_decryptCtx, out + offset, &outLen, in + offset, blockSize))
            {
                throw std::runtime_error("Decrypt(in->out): ошибка EVP_DecryptUpdate");
            }
        }
    }

private:
    EVP_CIPHER_CTX* m_encryptCtx;  // Контекст для шифрования AES
    EVP_CIPHER_CTX* m_decryptCtx;  // Контекст для дешифрования AES
};

// -------------------------
// Пример использования
// -------------------------
int main()
{
    try
    {
        // Создаем ключ 256-бит (32 байта) для AES-256
        // (Для AES-128 нужно 16 байт, для AES-192 — 24 байта)
        unsigned char key[32] = {
            0x00, 0x11, 0x22, 0x33,
            0x44, 0x55, 0x66, 0x77,
            0x88, 0x99, 0xAA, 0xBB,
            0xCC, 0xDD, 0xEE, 0xFF,
            // Вторая половина (ещё 16 байт)
            0xF1, 0xE2, 0xD3, 0xC4,
            0xB5, 0xA6, 0x97, 0x88,
            0x79, 0x6A, 0x5B, 0x4C,
            0x3D, 0x2E, 0x1F, 0x0F
        };

// Инициализируем CBingoFish2 для AES-256
        CBingoFish2 fish2(key, sizeof(key));

// Подготовим буфер для шифрования: длина должна быть кратной 16.
        // Возьмём 32 байта = 2 блока AES.
        unsigned char plain[32] = {
            'H','e','l','l','o',' ','B','i',
            'n','g','o','F','i','s','h','2',
            '!',' ','D','e','m','o',' ','#',
            0x01, 0x02, 0x03, 0x04,  'X','Y','Z','!'
        };

std::cout << "Исходные данные (hex): ";
        for (int i=0; i<32; i++)
            printf("%02X ", plain[i]);
        std::cout << std::endl;

// Шифруем буфер in-place
        fish2.Encrypt(plain, 32);

std::cout << "Зашифрованные (hex): ";
        for (int i=0; i<32; i++)
            printf("%02X ", plain[i]);
        std::cout << std::endl;

// Теперь дешифруем (in-place)
        fish2.Decrypt(plain, 32);

std::cout << "Расшифрованные (hex): ";
        for (int i=0; i<32; i++)
            printf("%02X ", plain[i]);
        std::cout << std::endl;

// Выведем часть как строку (всё что в пределах ASCII):
        std::cout << "Как текст: ";
        for (int i=0; i<32; i++)
        {
            unsigned char c = plain[i];
            if (c >= 32 && c < 127)
                std::cout << c;
            else
                std::cout << ".";
        }
        std::cout << std::endl;
    }
    catch (const std::exception& e)
    {
        std::cerr << "Ошибка: " << e.what() << std::endl;
    }

return 0;
}

Shelluthcode

Instrukcja użytkownika