Cryptography on STM32 Implementing Secure Embedded Systems with STM32U0

4.1. Overview of AES-CBC Used in This Code

The program uses AES-128 in CBC mode.

AES basics

1. AES operates on 128-bit blocks (16 bytes).
2. AES-128 uses a 16-byte key.
3. The algorithm performs 10 rounds of transformations internally.

CBC (Cipher Block Chaining)

CBC ensures that each block depends on the previous block, increasing security.

Encryption formula:

Ci = AESenc(Pi ⊕ C(i-1))

Where:

P_i = plaintext block
C_i = ciphertext block
C_i−1 = previous ciphertext block
C₀ = IV (Initialization Vector)

Decryption:

P_i = AES_dec(C_i) ⊕ C_i−1

Example (first block)

Plaintext:

6bc1bee22e409f96e93d7e117393172a

IV:

000102030405060708090a0b0c0d0e0f

CBC first step:

InputBlock = Plaintext XOR IV

Then AES encrypts it.

This example uses official NIST vectors so the output can be validated.

4.2. Important Global Variables

AES Key

const uint8_t Key[] =
{
    0x2b, 0x7e, 0x15, 0x16, ...
};

16 bytes → AES-128 key

Initialization Vector (IV)

const uint8_t IV[] =
{
    0x00, 0x01, 0x02, ...
};

Also 16 bytes

Used only for the first block

Plaintext

const uint8_t Plaintext[];

64 bytes total.

AES block size = 16 bytes

64 / 16 = 4 blocks;

Expected Ciphertext

const uint8_t Expected_Ciphertext[];

This is the correct output defined by NIST.

The program checks that the library produces the same values.

Buffers

uint8_t Computed_Ciphertext[];
uint8_t Computed_Plaintext[];

These store the results generated by encryption/decryption.

4.3. Initialization in main()

HAL initialization

HAL_Init();
SystemClock_Config();

Initializes:

• STM32 hardware
• clock system
• SysTick timer

Initialize crypto library

cmox_initialize(&init_target);

This initializes the Cortex-M optimized crypto engine.

Without this call, encryption functions will fail.

LED initialization

BSP_LED_Init(LED4);

• success → LED ON
• error → LED blinking

4.4. Single-Call Encryption

The simplest usage.

retval = cmox_cipher_encrypt(
        CMOX_AES_CBC_ENC_ALGO,
        Plaintext,
        sizeof(Plaintext),
        Key,
        sizeof(Key),
        IV,
        sizeof(IV),
        Computed_Ciphertext,
        &computed_size
);

Parameters explained

Internally the library performs

block1 = AES(P1 ^ IV);
block2 = AES(P2 ^ block1);
block3 = AES(P3 ^ block2);
block4 = AES(P4 ^ block3);

Verification

memcmp(Expected_Ciphertext, Computed_Ciphertext);

Error_Handler();

4.5. Single-Call Decryption

retval = cmox_cipher_decrypt(
        CMOX_AES_CBC_DEC_ALGO,
        Expected_Ciphertext,
        sizeof(Expected_Ciphertext),
        Key,
        sizeof(Key),
        IV,
        sizeof(IV),
        Computed_Plaintext,
        &computed_size
);

Internally:

P1 = AES_DEC(C1) ^ IV;
P2 = AES_DEC(C2) ^ C1;
P3 = AES_DEC(C3) ^ C2;
P4 = AES_DEC(C4) ^ C3;

memcmp(Plaintext, Computed_Plaintext);

4.6. Multiple-Call (Chunked) Encryption

This demonstrates streaming encryption.

• Data arrives in packets
• Data is too large for RAM

Create CBC context

cipher_ctx = cmox_cbc_construct(&Cbc_Ctx, CMOX_AES_CBC_ENC);

Initialize it

cmox_cipher_init(cipher_ctx);

Load key

cmox_cipher_setKey(cipher_ctx, Key, sizeof(Key));

Set IV

cmox_cipher_setIV(cipher_ctx, IV, sizeof(IV));

4.7. Chunk Encryption Loop

The program processes 48-byte chunks:

#define CHUNK_SIZE 48

Loop:

for (index = 0; index < (sizeof(Plaintext) - CHUNK_SIZE); index += CHUNK_SIZE)

Then:

cmox_cipher_append(...);

This function:

• encrypts the chunk
• updates CBC internal state

Important: the context remembers the last ciphertext block.

Chunk 1:
block1
block2
block3

Chunk 2:
block4

4.8. Last Partial Block

if (index < sizeof(Plaintext))
{
    /* Encrypt remaining bytes */
}

4.9. Cleanup

cmox_cipher_cleanup(cipher_ctx);

Releases internal context resources.

4.10. Multi-Call Decryption

CMOX_AES_CBC_DEC

• construct context
• init
• set key
• set IV
• append ciphertext chunks
• verify plaintext

4.11. Finalization

cmox_finalize(NULL);

Shuts down cryptographic services.