STM32 - H723ZG - mbedtls - Blowfish

W tym poście chciałbym opisać sposób obsługi szyfru blokowego Blowfish z wykorzystaniem biblioteki mbedtls.

[Źródło: https://www.st.com/en/evaluation-tools/nucleo-h723zg.html]

Projekt był testowany na płytce Nucleo z układem STM32H723ZG. Natomiast działanie biblioteki będzie takie samo dla innych układów.

Poniższe funkcje wykorzystują tryb działania ECB (Electronic Code Block). Czyli każdy blok danych szyfrowany jest za pomocą jednego klucza. Dane wejściowe są zapisane w postaci bloku.

Funkcja kodująca dane z wykorzystaniem ECB:

1. static void blowfish_encrypt_ecb(const unsigned char *key_buffer, unsigned char *src_buffer, unsigned char * des_buffer) {
2.     unsigned char output[8];
3.     int setkey_result = 0;
4.  
5.     mbedtls_blowfish_context ctx;
6.  
7.     for(uint8_t i=0; i<8; i++) { output[i] = 0x00; }
8.  
9.     mbedtls_blowfish_init(&ctx);
10.  
11.     setkey_result = mbedtls_blowfish_setkey(&ctx, key_buffer, 8*8);
12.  
13.     if(setkey_result == 0) {
14.         mbedtls_blowfish_crypt_ecb(&ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_buffer, output);
15.     }
16.  
17.     for(uint8_t i=0; i<8; i++) { *(des_buffer + i) = output[i]; }
18.  
19.     mbedtls_blowfish_free(&ctx);
20. }

Funkcja dekodująca dane z wykorzystaniem ECB:

1. static void blowfish_decrypt_ecb(const unsigned char * key_buffer, unsigned char * src_buffer, unsigned char * des_buffer)
2. {
3.     unsigned char output[8];
4.     int setkey_result = 0;
5.  
6.     mbedtls_blowfish_context ctx;
7.  
8.     for(uint8_t i=0; i<8; i++) { output[i] = 0x00; }
9.  
10.     mbedtls_blowfish_init(&ctx);
11.  
12.     setkey_result = mbedtls_blowfish_setkey(&ctx, key_buffer, 8*8);
13.  
14.     if(setkey_result == 0) {
15.         mbedtls_blowfish_crypt_ecb(&ctx, MBEDTLS_BLOWFISH_DECRYPT, src_buffer, output);
16.     }
17.  
18.     for(uint8_t i=0; i<8; i++) { *(des_buffer + i) = output[i]; }
19.  
20.     mbedtls_blowfish_free(&ctx);
21. }

Funkcja mbedtls_blowfish_crypt_ecb przyjmuje następujące parametry:

• Wskaźnik na strukturę z danymi dla Blowfish. Klucz musi być do niej wprowadzony przed wywołaniem funkcji szyfrującej.
• Rodzaj operacji czyli szyfrowanie lub odszyfrowanie wiadomości.
• Wskaźnik na dane wejściowe o rozmiarze 8 bajtów.
• Wskaźnik na dane wyjściowe.

Funkcja wywołująca operacje kodowania/dekowania funkcji:

1. uint8_t Test_Decrypt_Buffer[16] = {
2.         0x9D, 0x67, 0xE8, 0x3B, 0x98, 0x25, 0x03, 0x7F, 0x2A, 0x7B, 0x68, 0x73, 0x23, 0x91, 0x65, 0xEF
3. };
4.  
5. uint8_t Test_Encrypt_Buffer[16] = {
6.         0x7f, 0x4c, 0x63, 0x02, 0x64, 0x97, 0xdc, 0x55, 0xf0, 0x1b, 0x51, 0x32, 0xe3, 0xb5, 0x31, 0x9a
7. };
8.  
9. uint8_t Test_Password[8] = {
10.         0x8F, 0x7E, 0x60, 0x82, 0x74, 0x95, 0x27, 0x96
11. };
12.  
13. static void blowfish_encrypt_ecb(const unsigned char *key_buffer, unsigned char *src_buffer, unsigned char * des_buffer);
14. static void blowfish_decrypt_ecb(const unsigned char * key_buffer, unsigned char * src_buffer, unsigned char * des_buffer);
15.  
16. void test_encrypt_data(void)
17. {
18.     uint8_t output_encrypt_buffer[16] = {0x00};
19.     uint8_t output_decrypt_buffer[16] = {0x00};
20.  
21.     blowfish_encrypt_ecb(&Test_Password[0], &Test_Decrypt_Buffer[0], &output_encrypt_buffer[0]);
22.     blowfish_encrypt_ecb(&Test_Password[0], &Test_Decrypt_Buffer[8], &output_encrypt_buffer[8]);
23.  
24.     blowfish_decrypt_ecb(&Test_Password[0], &output_encrypt_buffer[0], &output_decrypt_buffer[0]);
25.     blowfish_decrypt_ecb(&Test_Password[0], &output_encrypt_buffer[8], &output_decrypt_buffer[8]);
26. }

Drugi sposób to CBC gdzie bloki danych zależą od poprzednich bloków. Na końcu szyfrowanie następuje za pomocą zwykłego klucza.

1. static uint8_t blowfish_encrypt_cbc(const unsigned char * key_buffer, unsigned char * iv_str,
2.                                 unsigned char * src_buffer, unsigned char * des_buffer, uint16_t src_buffer_size)
3. {
4.     unsigned char output[32];
5.     int operation_status = 0;
6.  
7.     for(uint8_t i=0; i<32; i++) { output[i] = 0x00; }
8.  
9.     mbedtls_blowfish_context ctx;
10.  
11.     mbedtls_blowfish_init( &ctx );
12.  
13.     operation_status = mbedtls_blowfish_setkey(&ctx, key_buffer, 8*8);
14.  
15.     if(operation_status == 0) {
16.         operation_status = mbedtls_blowfish_crypt_cbc(&ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_buffer_size , iv_str, src_buffer, output);
17.     }
18.  
19.     for(uint8_t i=0; i<32; i++) { *(des_buffer + i) = output[i]; }
20.  
21.     mbedtls_blowfish_free(&ctx);
22. }
23.  
24. static uint8_t blowfish_decrypt_cbc(const unsigned char * key_buffer, unsigned char * iv_buffer,
25.         unsigned char * src_buffer, unsigned char * des_buffer, uint16_t src_buffer_size)
26. {
27.     unsigned char output[32];
28.     int operation_status = 0;
29.  
30.     for(uint8_t i=0; i<32; i++) { output[i] = 0x00; }
31.  
32.     mbedtls_blowfish_context ctx;
33.     mbedtls_blowfish_init( &ctx );
34.  
35.     operation_status = mbedtls_blowfish_setkey(&ctx, key_buffer, 8*8);
36.  
37.     if(operation_status == 0) {
38.         operation_status = mbedtls_blowfish_crypt_cbc(&ctx, MBEDTLS_BLOWFISH_DECRYPT, src_buffer_size , iv_buffer, src_buffer, output);
39.     }
40.    
41.     for(uint8_t i=0; i<32; i++) { *(des_buffer + i) = output[i]; }
42.  
43.     mbedtls_blowfish_free(&ctx);
44. }

Funkcja mbedtls_blowfish_crypt_ecb przyjmuje następujące parametry:

• Wskaźnik na strukturę z danymi dla Blowfish. Klucz musi być do niej wprowadzony przed wywołaniem funkcji szyfrującej.
• Rodzaj operacji czyli szyfrowanie lub odszyfrowanie wiadomości.
• Ilość danych wejściowych. Rozmiar tablicy musi być wielokrotnością liczby 8.
• Tzw. Initialization Vector. (8 bajtów). Jest on aktualizowany w tej funkcji w celu użytku wykonywania wielu operacji na kilku blokach danych. W celu odszyfrowania danych potrzebny jest blok oryginalny. W związku z tym musi on zostać zapisany przed szyfrowaniem danych. 
• Wskaźnik na dane wejściowe. Rozmiar tablicy musi być wielokrotnością liczby 8.
• Wskaźnik na dane wyjściowe.

Wywołanie funkcji wygląda następująco:

1. uint8_t cbc_src_buffer[32] = {
2.         0x9D, 0x67, 0xE8, 0x3B, 0x98, 0x25, 0x03, 0x7F, 0x2A, 0x7B, 0x68, 0x73, 0x23, 0x91, 0x65, 0xEF,
3.         0x9D, 0x67, 0xE8, 0x3B, 0x56, 0x25, 0x03, 0x7F, 0x2A, 0xFE, 0x68, 0xCB, 0x23, 0x91, 0x65, 0xEF
4. };
5.  
6. uint8_t cbc_password[8] = {
7.         0x8F, 0x7E, 0x60, 0x82, 0x74, 0x95, 0x27, 0x96
8. };
9.  
10. uint8_t iv_buffer[8] = {
11.         0x55, 0x34, 0x87, 0x34, 0x98, 0x47, 0xAE, 0x8B
12. };
13.  
14. uint8_t iv_buffer_read[8] = {
15.         0x55, 0x34, 0x87, 0x34, 0x98, 0x47, 0xAE, 0x8B
16. };
17.  
18. uint8_t cbc_encrypt_buffer[32] = { 0x00 };
19. uint8_t cbc_decrypt_buffer[32] = { 0x00 };
20.  
21. static uint8_t blowfish_encrypt_cbc(const unsigned char * key_buffer, unsigned char * iv_str,
22.                                 unsigned char * src_buffer, unsigned char * des_buffer, uint16_t src_buffer_size);
23. static uint8_t blowfish_decrypt_cbc(const unsigned char * key_buffer, unsigned char * iv_buffer,
24.         unsigned char * src_buffer, unsigned char * des_buffer, uint16_t src_buffer_size);
25.  
26. void test_encrypt_data(void)
27. {
28.     blowfish_encrypt_cbc(&cbc_password[0], &iv_buffer[0], &cbc_src_buffer[0], &cbc_encrypt_buffer[0], 32);
29.     blowfish_decrypt_cbc(&cbc_password[0], &iv_buffer_read[0], &cbc_encrypt_buffer[0], &cbc_decrypt_buffer[0], 32);
30. }

Porównanie danych wejściowych i wyjściowych można zrobić korzystając np. z takiego narzędzia online. Pozwoli to na zweryfikowanie czy operacje wykonywane w programie działają poprawnie. 

Na wspomnianej stronie należy wybrać rodzaj wprowadzanych danych, szyfr, sposób kodowania oraz klucz jakim dane zostaną zakodowane.

Biblioteka mbedtls pozwala także na wywołanie innych trybów działania szyfrowania Blowfish np. cfb64.