Шифрование и расшифровка данных: различия между версиями

Версия от 16:00, 20 марта 2023

В примере будет зашифрованы и расшифрованы данные алгоритмом кузнечик. Данный процесс будет рассмотрен с различными режимами шифрования. Шифрования для алгоритмов «Магма» и AES128 полностью аналогичны, за исключением разрядности обрабатываемых данных.

Работа с конфигуратором (В разработке)

Для начала настроем в конфигураторе тактирование mik32, например, от внешнего кварца 32МГц. Затем настроем делители шины. Так как крипто-блок тактируется от шины AHB_CLK, то зададим делитель AHB_DIV. В данном примере оставим делитель по умолчанию. В итоге вкладка с тактированием должна выглядеть так:

(Картинка тактирования из конфигуратора. В работе)

Затем перейдем к настройке самого крипто-блока. Для этого откроем вкладку крипто-блок и нажмем включить. После этого появятся несколько настроек.

Настройки крипто-блока в конфигураторе

Зададим им следующие значения:

Алгоритм шифрования - Кузнечик;
Режим шифрования - ECB;
В перестановке слова - нет перестановки;
Порядок загрузки/выгрузки - От старшего слова к младшему.

В итоге настройки крипто-блока в конфигураторе должны выглядеть как на рисунке.

Нажимаем кнопку сохранения и генерации. В итоге у нас появится проект для PlatformIo. Далее работа идет в visual studio code.

Использование библиотеки HAL_Crypto

В сгенерированном проекте в файле main.c должна быть функция Crypto_Init, в которой будут заданы настройки для крипто-блока. Выглядит она так:

static void Crypto_Init(void)
{
    hcrypto.Instance = CRYPTO;

    hcrypto.Algorithm = CRYPTO_ALG_KUZNECHIK;
    hcrypto.CipherMode = CRYPTO_CIPHER_MODE_ECB;
    hcrypto.SwapMode = CRYPTO_SWAP_MODE_NONE; 
    hcrypto.OrderMode = CRYPTO_ORDER_MODE_MSW;

    HAL_Crypto_Init(&hcrypto);
}

Кроме этого в функции SystemClock_Config приведены настройки для тактирования. Убедитесь, что в PeriphClkInit.PMClockAHB присутствует PM_CLOCK_CRYPTO_M. Сама функция должна выглядеть примерно так:

void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInit = {0};
    RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

    RCC_OscInit.OscillatorEnable = RCC_OSCILLATORTYPE_OSC32K | RCC_OSCILLATORTYPE_OSC32M;   
    RCC_OscInit.OscillatorSystem = RCC_OSCILLATORTYPE_OSC32M;                          
    RCC_OscInit.AHBDivider = 0;                             
    RCC_OscInit.APBMDivider = 0;                             
    RCC_OscInit.APBPDivider = 0;                             
    RCC_OscInit.HSI32MCalibrationValue = 0;                  
    RCC_OscInit.LSI32KCalibrationValue = 0;
    HAL_RCC_OscConfig(&RCC_OscInit);

    PeriphClkInit.PMClockAHB = PMCLOCKAHB_DEFAULT | PM_CLOCK_CRYPTO_M;    
    PeriphClkInit.PMClockAPB_M = PMCLOCKAPB_M_DEFAULT | PM_CLOCK_WU_M | PM_CLOCK_PAD_CONFIG_M;     
    PeriphClkInit.PMClockAPB_P = PMCLOCKAPB_P_DEFAULT | PM_CLOCK_UART_0_M; 
    PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_NO_CLK;
    PeriphClkInit.RTCClockCPUSelection = RCC_RTCCLKCPUSOURCE_NO_CLK;
    HAL_RCC_ClockConfig(&PeriphClkInit);
}

Для демонстрации вывода текста в PeriphClkInit.PMClockAPB_P присутствует PM_CLOCK_UART_0_M. У вас его может не быть, так как UART нужно включить отдельно. Для этого нужно подключить библиотеки uart_lib и xprintf.

#include "mik32_hal_rcc.h"
#include "mik32_hal_spi.h"

#include "uart_lib.h"
#include "xprintf.h"

Для инициализации UART в функции main, после функции тактирования SystemClock_Config, следует написать:

UART_Init(UART_0, 3333, UART_CONTROL1_TE_M | UART_CONTROL1_M_8BIT_M, 0, 0);

Скорость UART задается делителем во втором аргументе функции. При такой записи скорость будет 9600 бод.

В начале main.c можно видеть объявление структуры с набором настроек для крипто-блока, которую использует функция инициализации Crypto_Init.

Crypto_HandleTypeDef hcrypto;

void SystemClock_Config(void);
static void Crypto_Init(void);

Создадим глобальный массив для ключа. Количество элементов массива можно задать с помощью макросов CRYPTO_KEY_KUZNECHIK (количество слов в ключе для алгоритма кузнечик).

uint32_t crypto_key[CRYPTO_KEY_KUZNECHIK] = {0x8899aabb, 0xccddeeff, 0x00112233, 0x44556677, 0xfedcba98, 0x76543210, 0x01234567, 0x89abcdef};

Для режимов шифрования ECB и CBC длина данных должна быть кратна длине блока. Иначе данные следует дополнить.

Для режима CTR длинна данных может быть любой. В этом режиме дополнения не требуются.

Синхропосылка (вектор инициализации), в соответствии с ГОСТ 34.13—2015, для разных режимов может иметь разную длину:

В режиме ECB синхропосылка не используется;
В режиме CBC синхропосылка должна быть длинной m*z, где m - длина блока (128 бит для алгоритма Кузнечик), z - целое число. Поддерживается только случай z=1, m=n, где n - длина блока (4 слова для Кузнечика и AES, 2 слова для Магмы);
В режиме CTR в регистр INIT следует записывать значение счетчика состоящего из синхропосылки, длинна которой равна половине длине блока, и такого же количества нулей. В итоге размер синхропосылки будет равен размеру блока.

Режим простой замены (Electronic Codebook, ЕСВ)

Теперь напишем функции для зашифровки и расшифровки данных в режиме шифрования ECB - kuznechik_ECB_code и kuznechik_ECB_decode соответственно.

В функции kuznechik_ECB_code будет три массива данных:

plain_text - незашифрованные данные;
cipher_text - полученные зашифрованные данные;
expect_cipher_text - зашифрованные данные, которые ожидается получить.

Количество слов в данных для зашифровки должно быть кратно размеру блока (для кузнечика 4 слова или 128 бит). Если данных меньше, то их нужно дополнить вручную. ГОСТ 34.13—2015 определяет три возможные процедуры дополнения. Можно, например, дополнить остаток нулями до размера блока.

Внутри kuznechik_ECB_code сначала задается режим шифрования функцией HAL_Crypto_SetCipherMode (если другие режимы использовать не планируется, то этого можно не делать, так как этот режим шифрования уже задан после инициализации функцией Crypto_Init), затем устанавливается мастер-ключ функцией HAL_Crypto_SetKey. Так как ключ должен быть инициализирован в режиме шифрования, то после функции HAL_Crypto_SetKey блок находится в режиме зашифровки данных. После этого используется функция HAL_Crypto_Encode для зашифровки данных.

В конце поочередно выведем каждый из массивов в UART. После этого проведем сравнение полученных данных и ожидаемых.

Функция kuznechik_ECB_code

void kuznechik_ECB_code()
{
    uint32_t plain_text[] =     {            
                                    0x11223344, 0x55667700, 0xffeeddcc, 0xbbaa9988,
                                    0x00112233, 0x44556677, 0x8899aabb, 0xcceeff0a,
                                    0x11223344, 0x55667788, 0x99aabbcc, 0xeeff0a00,
                                    0x22334455, 0x66778899, 0xaabbccee, 0xff0a0011
                                };
    
    uint32_t cipher_text[] = {  
                                0x0, 0x0, 0x0, 0x0, 
                                0x0, 0x0, 0x0, 0x0, 
                                0x0, 0x0, 0x0, 0x0, 
                                0x0, 0x0, 0x0, 0x0
                             }; 

    uint32_t expect_cipher_text[] = {
                                        0x7f679d90, 0xbebc2430, 0x5a468d42, 0xb9d4edcd, 
                                        0xb429912c, 0x6e0032f9, 0x285452d7, 0x6718d08b, 
                                        0xf0ca3354, 0x9d247cee, 0xf3f5a531, 0x3bd4b157, 
                                        0xd0b09ccd, 0xe830b9eb, 0x3a02c4c5, 0xaa8ada98
                                    };


    uint32_t key_length = sizeof(crypto_key)/sizeof(*crypto_key);
    uint32_t plain_text_length = sizeof(plain_text)/sizeof(*plain_text);


    /* Задать режим шифрования */
    HAL_Crypto_SetCipherMode(&hcrypto, CRYPTO_CIPHER_MODE_ECB);
    /* Установка ключа */
    HAL_Crypto_SetKey(&hcrypto, crypto_key);


    /* Зашифровать данные */
    HAL_Crypto_Encode(&hcrypto, plain_text, cipher_text, plain_text_length); 


    xprintf("KEY ");
    for (uint32_t i = 0; i < key_length; i++)
    {
        xprintf("0x%08x, ", crypto_key[i]);
    }
    xprintf("\n");  

    xprintf("plain: ");
    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        xprintf("0x%08x, ", plain_text[i]);
    }
    xprintf("\n");   

    xprintf("cipher: ");
    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        xprintf("0x%08x, ", cipher_text[i]);
    }
    xprintf("\n");

    xprintf("expect: ");
    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        xprintf("0x%08x, ", expect_cipher_text[i]);
    }
    xprintf("\n");

    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        if(expect_cipher_text[i] != cipher_text[i])
        {
            xprintf("error\n");
            break;
        }
        else if ((i+1) == plain_text_length)
        {
            xprintf("Successfull\n");
        }
    }
    xprintf("\n");
}

Функция kuznechik_ECB_decode аналогична, но в ней используются другие массивы:

plain_text - полученные расшифрованные данные;
cipher_text - зашифрованные данные;
expect_plain_text - расшифрованные данные, которые ожидается получить.

Для расшифровки данных используется функция HAL_Crypto_Decode.

Функция kuznechik_ECB_decode

void kuznechik_ECB_decode()
{
    uint32_t plain_text[] =     {            
                                    0x0, 0x0, 0x0, 0x0, 
                                    0x0, 0x0, 0x0, 0x0, 
                                    0x0, 0x0, 0x0, 0x0, 
                                    0x0, 0x0, 0x0, 0x0
                                };
    
    uint32_t cipher_text[] = {  
                                0x7f679d90, 0xbebc2430, 0x5a468d42, 0xb9d4edcd, 
                                0xb429912c, 0x6e0032f9, 0x285452d7, 0x6718d08b, 
                                0xf0ca3354, 0x9d247cee, 0xf3f5a531, 0x3bd4b157, 
                                0xd0b09ccd, 0xe830b9eb, 0x3a02c4c5, 0xaa8ada98
                             }; 
    
    uint32_t expect_plain_text[] =  {            
                                        0x11223344, 0x55667700, 0xffeeddcc, 0xbbaa9988,
                                        0x00112233, 0x44556677, 0x8899aabb, 0xcceeff0a,
                                        0x11223344, 0x55667788, 0x99aabbcc, 0xeeff0a00,
                                        0x22334455, 0x66778899, 0xaabbccee, 0xff0a0011
                                    };

    uint32_t key_length = sizeof(crypto_key)/sizeof(*crypto_key);
    uint32_t cipher_text_length = sizeof(cipher_text)/sizeof(*cipher_text);


    /* Задать режим шифрования */
    HAL_Crypto_SetCipherMode(&hcrypto, CRYPTO_CIPHER_MODE_ECB);
    /* Установка ключа */
    HAL_Crypto_SetKey(&hcrypto, crypto_key);


    /* Расшифровать данные */
    HAL_Crypto_Decode(&hcrypto, cipher_text, plain_text, cipher_text_length); 


    xprintf("KEY ");
    for (uint32_t i = 0; i < key_length; i++)
    {
        xprintf("0x%08x, ", crypto_key[i]);
    }
    xprintf("\n");  

    xprintf("cipher: ");
    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        xprintf("0x%08x, ", cipher_text[i]);
    }
    xprintf("\n");   

    xprintf("plain: ");
    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        xprintf("0x%08x, ", plain_text[i]);
    }
    xprintf("\n");

    xprintf("expect: ");
    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        xprintf("0x%08x, ", expect_plain_text[i]);
    }
    xprintf("\n");

    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        if(expect_plain_text[i] != plain_text[i])
        {
            xprintf("error\n");
            break;
        }
        else if ((i+1) == cipher_text_length)
        {
            xprintf("Successfull\n");
        }
    }
    xprintf("\n");
}

Функция main.

int main()
{    
    SystemClock_Config();

    Crypto_Init();

    xprintf("\nkuznechik_ECB_code\n");
    kuznechik_ECB_code();
    xprintf("\nkuznechik_ECB_decode\n");   
    kuznechik_ECB_decode();

    while (1)
    {    

    }
       
}

Вывод в UART

Если у вас включен UART или подключен common.h, или объявлен #define MIK32_CRYPTO_DEBUG, то можно посмотреть вывод xprintf. Вывод в UART изображен на рисунке.

Функции для режимов CBC и CTR аналогичны, но содержат другие данные в массивах.

Отличие этих режимов в том, что они перед каждой новой расшифровкой или зашифровкой требуют записи вектора инициализации с помощью функции HAL_Crypto_SetINIT.

Режим гаммирования (Counter, CTR)

Размер массива для вектора инициализации можно задать с помощью макросов:

IV_LENGTH_KUZNECHIK_CBC
IV_LENGTH_MAGMA_CBC
IV_LENGTH_AES_CBC
IV_LENGTH_KUZNECHIK_CTR
IV_LENGTH_MAGMA_CTR
IV_LENGTH_AES_CTR

Количество слов в данных для зашифровки должно быть кратно размеру блока (для кузнечика 4 слова или 128 бит). Если данных меньше, то их нужно дополнить вручную.

Функция kuznechik_CBC_code

void kuznechik_CBC_code()
{
    uint32_t init_vector[IV_LENGTH_KUZNECHIK_CBC] = {0x12341234, 0x11114444, 0xABCDABCD, 0xAAAABBBB};
    
    uint32_t plain_text[] = {            
                                0x11223344, 0x55667700, 0xffeeddcc, 0xbbaa9988,
                                0x00112233, 0x44556677, 0x8899aabb, 0xcceeff0a,
                                0x11223344, 0x55667788, 0x99aabbcc, 0xeeff0a00,
                                0x22334455, 0x66778899, 0xaabbccee, 0xff0a0011
                            };

    uint32_t cipher_text[] = {  
                                0x0, 0x0, 0x0, 0x0, 
                                0x0, 0x0, 0x0, 0x0, 
                                0x0, 0x0, 0x0, 0x0, 
                                0x0, 0x0, 0x0, 0x0
                             }; 

    uint32_t expect_cipher_text[] = {
                                        0x50796e7f, 0x4094ce10, 0xbab7374c, 0x981047e3, 
                                        0x1ee4f83b, 0x334948ed, 0x86a0873c, 0x86bff9a2, 
                                        0xa084f5fa, 0x965481e4, 0xb64be9bd, 0x32ef21e3, 
                                        0xa6e376cf, 0x95e8a097, 0x9a46ba33, 0x152b1843
                                    };

    uint32_t key_length = sizeof(crypto_key)/sizeof(*crypto_key);
    uint32_t plain_text_length = sizeof(plain_text)/sizeof(*plain_text);


    /* Задать режим шифрования */
    HAL_Crypto_SetCipherMode(&hcrypto, CRYPTO_CIPHER_MODE_CBC);
    /* Установка вектора инициализации */  
    HAL_Crypto_SetIV(&hcrypto, init_vector, sizeof(init_vector)/sizeof(*init_vector)); 
    /* Установка ключа */
    HAL_Crypto_SetKey(&hcrypto, crypto_key);


    /* Зашифровать данные */
    HAL_Crypto_Encode(&hcrypto, plain_text, cipher_text, plain_text_length);     

    xprintf("KEY ");
    for (uint32_t i = 0; i < key_length; i++)
    {
        xprintf("0x%08x, ", crypto_key[i]);
    }
    xprintf("\n");  

    xprintf("plain: ");
    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        xprintf("0x%08x, ", plain_text[i]);
    }
    xprintf("\n");   

    xprintf("cipher: ");
    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        xprintf("0x%08x, ", cipher_text[i]);
    }
    xprintf("\n");

    xprintf("expect: ");
    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        xprintf("0x%08x, ", expect_cipher_text[i]);
    }
    xprintf("\n");

    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        if(expect_cipher_text[i] != cipher_text[i])
        {
            xprintf("error\n");
            break;
        }
        else if ((i+1) == plain_text_length)
        {
            xprintf("Successfull\n");
        }
    }
    xprintf("\n");
}

Функция kuznechik_CBC_decode для расшифровки.

void kuznechik_CBC_decode()
{
    uint32_t init_vector[IV_LENGTH_KUZNECHIK_CBC] = {0x12341234, 0x11114444, 0xABCDABCD, 0xAAAABBBB};
    
    uint32_t plain_text[] =     {            
                                    0x0, 0x0, 0x0, 0x0, 
                                    0x0, 0x0, 0x0, 0x0, 
                                    0x0, 0x0, 0x0, 0x0, 
                                    0x0, 0x0, 0x0, 0x0
                                };
    
    uint32_t cipher_text[] = {  
                                0x50796e7f, 0x4094ce10, 0xbab7374c, 0x981047e3, 
                                0x1ee4f83b, 0x334948ed, 0x86a0873c, 0x86bff9a2, 
                                0xa084f5fa, 0x965481e4, 0xb64be9bd, 0x32ef21e3, 
                                0xa6e376cf, 0x95e8a097, 0x9a46ba33, 0x152b1843
                             }; 

    uint32_t expect_plain_text[] =  {            
                                        0x11223344, 0x55667700, 0xffeeddcc, 0xbbaa9988,
                                        0x00112233, 0x44556677, 0x8899aabb, 0xcceeff0a,
                                        0x11223344, 0x55667788, 0x99aabbcc, 0xeeff0a00,
                                        0x22334455, 0x66778899, 0xaabbccee, 0xff0a0011
                                    };
    

    uint32_t key_length = sizeof(crypto_key)/sizeof(*crypto_key);
    uint32_t cipher_text_length = sizeof(cipher_text)/sizeof(*cipher_text);

    

    /* Задать режим шифрования */
    HAL_Crypto_SetCipherMode(&hcrypto, CRYPTO_CIPHER_MODE_CBC);
    /* Установка вектора инициализации */  
    HAL_Crypto_SetIV(&hcrypto, init_vector, sizeof(init_vector)/sizeof(*init_vector)); 
    /* Установка ключа */
    HAL_Crypto_SetKey(&hcrypto, crypto_key);
  

    /* Расшифровать данные */
    HAL_Crypto_Decode(&hcrypto, cipher_text, plain_text, cipher_text_length); 

    xprintf("KEY ");
    for (uint32_t i = 0; i < key_length; i++)
    {
        xprintf("0x%08x, ", crypto_key[i]);
    }
    xprintf("\n");  

    xprintf("cipher: ");
    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        xprintf("0x%08x, ", cipher_text[i]);
    }
    xprintf("\n");   

    xprintf("plain: ");
    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        xprintf("0x%08x, ", plain_text[i]);
    }
    xprintf("\n");

    xprintf("expect: ");
    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        xprintf("0x%08x, ", expect_plain_text[i]);
    }
    xprintf("\n");

    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        if(expect_plain_text[i] != plain_text[i])
        {
            xprintf("error\n");
            break;
        }
        else if ((i+1) == cipher_text_length)
        {
            xprintf("Successfull\n");
        }
    }
    xprintf("\n");
}

функция main.

int main()
{    

    SystemClock_Config();

    Crypto_Init();

    xprintf("\nkuznechik_CBC_code\n");
    kuznechik_CBC_code();
    xprintf("\nkuznechik_CBC_decode\n");   
    kuznechik_CBC_decode();

    while (1)
    {    
        
    }
       
}

Вывод в UART. CBC

Если у вас включен UART или подключен common.h, или объявлен #define MIK32_CRYPTO_DEBUG, то можно посмотреть вывод xprintf. Вывод в UART изображен на рисунке.

Режим простой замены с зацеплением (Cipher Block Chaining, СВС)

Количество слов в данных может быть любым. Если данных меньше, то их нужно дополнить вручную.

Функция kuznechik_CTR_code.

void kuznechik_CTR_code()
{
    uint32_t init_vector[IV_LENGTH_KUZNECHIK_CTR] = {0x12341235, 0x5BCDABCD};
    
    uint32_t plain_text[] =     {            
                                    0x11223344, 0x55667700, 0xffeeddcc, 0xbbaa9988,
                                    0x00112233, 0x44556677, 0x8899aabb, 0xcceeff0a,
                                    0x11223344, 0x55667788, 0x99aabbcc, 0xeeff0a00,
                                    0x22334455, 0x66778899
                                };
    
    uint32_t cipher_text[] = {  
                                0x0, 0x0, 0x0, 0x0, 
                                0x0, 0x0, 0x0, 0x0, 
                                0x0, 0x0, 0x0, 0x0, 
                                0x0, 0x0
                             }; 

    uint32_t expect_cipher_text[] = {
                                        0xf12504ea, 0x08bf9cd4, 0x2c1daede, 0x98792153, 
                                        0x2b92cfc8, 0xca2e1091, 0x2bf5d2b7, 0xe2179b86,
                                        0xab37ec96, 0x918795fe, 0xe6c2e8fa, 0xc2773e7b,
                                        0x74d3290d, 0xcd9aaf15
                                    };

    uint32_t key_length = sizeof(crypto_key)/sizeof(*crypto_key);
    uint32_t plain_text_length = sizeof(plain_text)/sizeof(*plain_text);


    /* Задать режим шифрования */
    HAL_Crypto_SetCipherMode(&hcrypto, CRYPTO_CIPHER_MODE_CTR);
    /* Установка вектора инициализации */  
    HAL_Crypto_SetIV(&hcrypto, init_vector, sizeof(init_vector)/sizeof(*init_vector)); 
    /* Установка ключа */
    HAL_Crypto_SetKey(&hcrypto, crypto_key);
 

    /* Зашифровать данные */
    HAL_Crypto_Encode(&hcrypto, plain_text, cipher_text, plain_text_length); 


    xprintf("KEY ");
    for (uint32_t i = 0; i < key_length; i++)
    {
        xprintf("0x%08x, ", crypto_key[i]);
    }
    xprintf("\n");  

    xprintf("plain: ");
    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        xprintf("0x%08x, ", plain_text[i]);
    }
    xprintf("\n");   

    xprintf("cipher: ");
    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        xprintf("0x%08x, ", cipher_text[i]);
    }
    xprintf("\n");

    xprintf("expect: ");
    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        xprintf("0x%08x, ", expect_cipher_text[i]);
    }
    xprintf("\n");

    for (uint32_t i = 0; i < plain_text_length; i++)
    {
        if(expect_cipher_text[i] != cipher_text[i])
        {
            xprintf("error\n");
            break;
        }
        else if ((i+1) == plain_text_length)
        {
            xprintf("Successfull\n");
        }
    }
    xprintf("\n");
}

Функция kuznechik_CTR_decode.

void kuznechik_CTR_decode()
{
    uint32_t init_vector[IV_LENGTH_KUZNECHIK_CTR] = {0x12341235, 0x5BCDABCD};
    
    uint32_t plain_text[] =     {            
                                    0x0, 0x0, 0x0, 0x0, 
                                    0x0, 0x0, 0x0, 0x0, 
                                    0x0, 0x0, 0x0, 0x0, 
                                    0x0, 0x0
                                };
    
    uint32_t cipher_text[] = {  
                                0xf12504ea, 0x08bf9cd4, 0x2c1daede, 0x98792153, 
                                0x2b92cfc8, 0xca2e1091, 0x2bf5d2b7, 0xe2179b86,
                                0xab37ec96, 0x918795fe, 0xe6c2e8fa, 0xc2773e7b,
                                0x74d3290d, 0xcd9aaf15
                             }; 

    uint32_t expect_plain_text[] =  {            
                                        0x11223344, 0x55667700, 0xffeeddcc, 0xbbaa9988,
                                        0x00112233, 0x44556677, 0x8899aabb, 0xcceeff0a,
                                        0x11223344, 0x55667788, 0x99aabbcc, 0xeeff0a00,
                                        0x22334455, 0x66778899
                                    };


    uint32_t key_length = sizeof(crypto_key)/sizeof(*crypto_key);
    uint32_t cipher_text_length = sizeof(cipher_text)/sizeof(*cipher_text); 


    /* Задать режим шифрования */
    HAL_Crypto_SetCipherMode(&hcrypto, CRYPTO_CIPHER_MODE_CTR);
    /* Установка вектора инициализации */  
    HAL_Crypto_SetIV(&hcrypto, init_vector, sizeof(init_vector)/sizeof(*init_vector)); 
    /* Установка ключа */
    HAL_Crypto_SetKey(&hcrypto, crypto_key);


    /* Расшифровать данные */
    HAL_Crypto_Decode(&hcrypto, cipher_text, plain_text, cipher_text_length); 

    xprintf("KEY ");
    for (uint32_t i = 0; i < key_length; i++)
    {
        xprintf("0x%08x, ", crypto_key[i]);
    }
    xprintf("\n");  

    xprintf("cipher: ");
    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        xprintf("0x%08x, ", cipher_text[i]);
    }
    xprintf("\n");   

    xprintf("plain: ");
    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        xprintf("0x%08x, ", plain_text[i]);
    }
    xprintf("\n");

    xprintf("expect: ");
    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        xprintf("0x%08x, ", expect_plain_text[i]);
    }
    xprintf("\n");

    for (uint32_t i = 0; i < cipher_text_length; i++)
    {
        if(expect_plain_text[i] != plain_text[i])
        {
            xprintf("error\n");
            break;
        }
        else if ((i+1) == cipher_text_length)
        {
            xprintf("Successfull\n");
        }
    }
    xprintf("\n");
}

Функция main.

int main()
{    

    SystemClock_Config();

    Crypto_Init();

    xprintf("\nkuznechik_CTR_code\n");
    kuznechik_CTR_code();
    xprintf("\nkuznechik_CTR_decode\n");   
    kuznechik_CTR_decode();

    while (1)
    {    
        
    }
       
}

Вывод в UART. CTR

Если у вас включен UART или подключен common.h, или объявлен #define MIK32_CRYPTO_DEBUG, то можно посмотреть вывод xprintf. Вывод в UART изображен на рисунке.

@@ Строка 22: / Строка 22: @@
 В сгенерированном проекте в файле main.c должна быть функция Crypto_Init, в которой будут заданы настройки для крипто-блока. Выглядит она так:
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
 <syntaxhighlight lang="c" line="1">
 static void Crypto_Init(void)
@@ Строка 34: / Строка 35: @@
      HAL_Crypto_Init(&hcrypto);
 }
-</syntaxhighlight>Кроме этого в функции SystemClock_Config приведены настройки для тактирования. Убедитесь что в PeriphClkInit.PMClockAHB присутствует PM_CLOCK_CRYPTO_M. Сама функция должна выглядеть примерно так:
+</syntaxhighlight>
+}}
+Кроме этого в функции SystemClock_Config приведены настройки для тактирования. Убедитесь, что в PeriphClkInit.PMClockAHB присутствует PM_CLOCK_CRYPTO_M. Сама функция должна выглядеть примерно так:
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
 <syntaxhighlight lang="c" line="1">
 void SystemClock_Config(void)
@@ Строка 58: / Строка 63: @@
      HAL_RCC_ClockConfig(&PeriphClkInit);
 }
-</syntaxhighlight>Для демонстрации вывода текста в PeriphClkInit.PMClockAPB_P присутствует PM_CLOCK_UART_0_M. У вас его может не быть так как UART нужно включить отдельно. В начале main.c можно видеть объявление структуры с набором настроек для крипто-блока, которую использует функция инициализации Crypto_Init.
+</syntaxhighlight>
+}}
+Для демонстрации вывода текста в PeriphClkInit.PMClockAPB_P присутствует PM_CLOCK_UART_0_M. У вас его может не быть, так как UART нужно включить отдельно. Для этого нужно подключить библиотеки uart_lib и xprintf.
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
+<syntaxhighlight lang="c" line="1">
+#include "mik32_hal_rcc.h"
+#include "mik32_hal_spi.h"
+#include "uart_lib.h"
+#include "xprintf.h"
+</syntaxhighlight>
+}}
+Для инициализации UART в функции main, после функции тактирования SystemClock_Config, следует написать:
+<syntaxhighlight lang="c" line="1" start="1">
+UART_Init(UART_0, 3333, UART_CONTROL1_TE_M | UART_CONTROL1_M_8BIT_M, 0, 0);
+</syntaxhighlight>
+Скорость UART задается делителем во втором аргументе функции. При такой записи скорость будет 9600 бод.
+В начале main.c можно видеть объявление структуры с набором настроек для крипто-блока, которую использует функция инициализации Crypto_Init.
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
 <syntaxhighlight lang="c" line="1">
 Crypto_HandleTypeDef hcrypto;
@@ Строка 66: / Строка 91: @@
 static void Crypto_Init(void);
 </syntaxhighlight>
+}}
 Создадим глобальный массив для ключа. Количество элементов массива можно задать с помощью макросов CRYPTO_KEY_KUZNECHIK (количество слов в ключе для алгоритма кузнечик).
@@ Строка 71: / Строка 97: @@
 <syntaxhighlight lang="c" line="1">
 uint32_t crypto_key[CRYPTO_KEY_KUZNECHIK] = {0x8899aabb, 0xccddeeff, 0x00112233, 0x44556677, 0xfedcba98, 0x76543210, 0x01234567, 0x89abcdef};
-</syntaxhighlight>Для режимов шифрования ECB и CBC длина данных должна быть кратна длине блока. Иначе данные следует дополнить.
+</syntaxhighlight>
+Для режимов шифрования ECB и CBC длина данных должна быть кратна длине блока. Иначе данные следует дополнить.
 Для режима CTR длинна данных может быть любой. В этом режиме дополнения не требуются.
-Синхропосылка (вектор инициализации), в соответствии с ГОСТ 34.13—2015, для разных режимов может иметь разную длину :
+Синхропосылка (вектор инициализации), в соответствии с ГОСТ 34.13—2015, для разных режимов может иметь разную длину:
 *В режиме ECB синхропосылка не используется;
@@ Строка 89: / Строка 117: @@
 *cipher_text - полученные зашифрованные данные;
 *expect_cipher_text - зашифрованные данные, которые ожидается получить.
 Количество слов в данных для зашифровки должно быть кратно размеру блока (для кузнечика 4 слова или 128 бит).  Если данных меньше, то их нужно дополнить вручную. ГОСТ 34.13—2015 определяет три возможные процедуры дополнения. Можно, например, дополнить остаток нулями до размера блока.
-Внутри  kuznechik_ECB_code сначала задается режим шифрования функцией HAL_Crypto_SetCipherMode (Если другие режимы использовать не планируется, то этого можно не делать так как этот режим шифрования уже задан после инициализации функцией Crypto_Init), затем устанавливается мастер-ключ функцией HAL_Crypto_SetKey. Так как ключ должен быть инициализирован в режиме шифрования, то после функции HAL_Crypto_SetKey блок находится в режиме зашифровки данных. После этого используется функция HAL_Crypto_Encode для зашифровки данных.
+Внутри  kuznechik_ECB_code сначала задается режим шифрования функцией HAL_Crypto_SetCipherMode (если другие режимы использовать не планируется, то этого можно не делать, так как этот режим шифрования уже задан после инициализации функцией Crypto_Init), затем устанавливается мастер-ключ функцией HAL_Crypto_SetKey. Так как ключ должен быть инициализирован в режиме шифрования, то после функции HAL_Crypto_SetKey блок находится в режиме зашифровки данных. После этого используется функция HAL_Crypto_Encode для зашифровки данных.
 В конце поочередно выведем каждый из массивов в UART. После этого проведем сравнение полученных данных и ожидаемых.
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
 Функция kuznechik_ECB_code<syntaxhighlight lang="c" line="1">
 void kuznechik_ECB_code()
@@ Строка 178: / Строка 206: @@
      xprintf("\n");
 }
-</syntaxhighlight>Функция kuznechik_ECB_decode аналогична, но в ней используются другие массивы:
+</syntaxhighlight>
+}}
+Функция kuznechik_ECB_decode аналогична, но в ней используются другие массивы:
-* plain_text - полученные расшифрованные данные;
+*plain_text - полученные расшифрованные данные;
 *cipher_text - зашифрованные данные;
 *expect_plain_text - расшифрованные данные, которые ожидается получить.
@@ Строка 186: / Строка 216: @@
 Для расшифровки данных используется функция HAL_Crypto_Decode.
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
 Функция kuznechik_ECB_decode<syntaxhighlight lang="c" line="1">
 void kuznechik_ECB_decode()
@@ Строка 267: / Строка 298: @@
 }
 </syntaxhighlight>
-Функция main
+}}
+Функция main.
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
 <syntaxhighlight lang="c" line="1">
 int main()
@@ Строка 287: / Строка 322: @@
 }
 </syntaxhighlight>
+}}
 [[Файл:Вывод в UART. Режим ECB.png|мини|Вывод в UART]]
 Если у вас включен UART или подключен common.h, или объявлен #define MIK32_CRYPTO_DEBUG, то можно посмотреть вывод xprintf. Вывод в UART изображен на рисунке.
@@ Строка 306: / Строка 342: @@
 Количество слов в данных для зашифровки должно быть кратно размеру блока (для кузнечика 4 слова или 128 бит).  Если данных меньше, то их нужно дополнить вручную.
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
 Функция kuznechik_CBC_code<syntaxhighlight lang="c" line="1">
 void kuznechik_CBC_code()
@@ Строка 390: / Строка 427: @@
 }
 </syntaxhighlight>
+}}
+Функция kuznechik_CBC_decode для расшифровки.
-Функция kuznechik_CBC_decode для расшифровки<syntaxhighlight lang="c" line="1">
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
+<syntaxhighlight lang="c" line="1">
 void kuznechik_CBC_decode()
 {
@@ Строка 478: / Строка 518: @@
 }
 </syntaxhighlight>
+}}
+функция main.
-функция main<syntaxhighlight lang="c" line="1">
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
+<syntaxhighlight lang="c" line="1">
 int main()
 {
@@ Строка 500: / Строка 543: @@
 }
 </syntaxhighlight>
+}}
 [[Файл:Вывод в UART. CBC.png|мини|Вывод в UART. CBC]]
 Если у вас включен UART или подключен common.h, или объявлен #define MIK32_CRYPTO_DEBUG, то можно посмотреть вывод xprintf. Вывод в UART изображен на рисунке.
@@ Строка 506: / Строка 550: @@
 Количество слов в данных может быть любым.  Если данных меньше, то их нужно дополнить вручную.
-Функция kuznechik_CTR_code<syntaxhighlight lang="c" line="1">
+Функция kuznechik_CTR_code.
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
+<syntaxhighlight lang="c" line="1">
 void kuznechik_CTR_code()
 {
@@ Строка 591: / Строка 637: @@
 }
 </syntaxhighlight>
-Функция kuznechik_CTR_decode <syntaxhighlight lang="c" line="1">
+}}
+Функция kuznechik_CTR_decode.
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
+<syntaxhighlight lang="c" line="1">
 void kuznechik_CTR_decode()
 {
@@ Строка 676: / Строка 727: @@
 }
 </syntaxhighlight>
-Функция main
+}}
+Функция main.
+{{#spoiler:show=Развернуть код|hide=Свернуть код|
 <syntaxhighlight lang="c" line="1">
 int main()
@@ Строка 697: / Строка 752: @@
 }
 </syntaxhighlight>
+}}
 [[Файл:Вывод в UART. CTR.png|мини|Вывод в UART. CTR]]
 Если у вас включен UART или подключен common.h, или объявлен #define MIK32_CRYPTO_DEBUG, то можно посмотреть вывод xprintf. Вывод в UART изображен на рисунке.

Аноним

Поиск

Шифрование и расшифровка данных: различия между версиями

Пространства имён

Ещё

Действия на странице

Версия от 16:00, 20 марта 2023

Содержание

Работа с конфигуратором (В разработке)

Использование библиотеки HAL_Crypto

Режим простой замены (Electronic Codebook, ЕСВ)

Режим гаммирования (Counter, CTR)

Режим простой замены с зацеплением (Cipher Block Chaining, СВС)

Навигация

Разделы

Навигация

Полезные материалы

Изменить этот блок

Вики-инструменты

Вики-инструменты

Аноним

Поиск

Шифрование и расшифровка данных: различия между версиями

Версия от 16:00, 20 марта 2023

Работа с конфигуратором (В разработке)

Использование библиотеки HAL_Crypto

Режим простой замены (Electronic Codebook, ЕСВ)

Режим гаммирования (Counter, CTR)

Режим простой замены с зацеплением (Cipher Block Chaining, СВС)

Навигация

Вики-инструменты

Инструменты для страниц