/** * \brief Test AES decryption function. * * This test decrypts the pre-encrypted data and checks * whether it is correct. * * \param test Current test case. */ static void run_aes_decryption_test(const struct test_case *test) { t_key decrypted_data; bool success; set_buffer(decrypted_data, 0x00); set_buffer(lastsubkey, 0x00); /* Call helper function to generate a last subkey for decryption */ if (!aes_lastsubkey_generate(encryption_key, lastsubkey)) { success = false; test_assert_true(test, !success, "Could not generate last subkey"); } else { /* Configure module for manual decryption */ aes_software_reset(); aes_set_key(lastsubkey); aes_configure(AES_DECRYPT, AES_MANUAL, AES_XOR_OFF); aes_write_inputdata(pre_encrypted_data); aes_start(); do { /* Wait until AES is finished or an error occurs. */ } while (aes_is_busy()); aes_read_outputdata(decrypted_data); /* Verify that the decrypted data is correct */ success = compare_data_block(decrypted_data, encryption_data); test_assert_true(test, success, "Decrypted values do not match excepted values"); } }
int main( void ) { uint8_t i; board_init(); sysclk_init(); sleepmgr_init(); /* Assume that everything is ok */ success = true; /* Enable the AES clock. */ sysclk_enable_module(SYSCLK_PORT_GEN, SYSCLK_AES); /* Do AES encryption and decryption of a single block. */ //******************************************************** // CIPHER IN MANUAL MODE: // - 128bit cryptographic key and data // - ECB cipher mode // - XOR disable // - Polling AES State Ready Interrupt flag //******************************************************** /* Before using the AES it is recommended to do an AES software reset to * put the module in known state, in case other parts of your code has * accessed the AES module. */ aes_software_reset(); /* Set AES encryption of a single block in manual mode. */ aes_configure(AES_ENCRYPT, AES_MANUAL, AES_XOR_OFF); /* Disable the AES interrupt. */ aes_isr_configure(AES_INTLVL_OFF); /* Load key into AES key memory. */ aes_set_key(key); /* Load data into AES state memory. */ aes_write_inputdata(plain_text); /* Start encryption. */ aes_start(); do { /* Wait until AES is finished or an error occurs. */ } while (aes_is_busy()); /* Store the result if not error. */ if (!aes_is_error()) { aes_read_outputdata(single_ans); } else { success = false; } /* Check if encrypted answer is equal to cipher result. */ for (i = 0; i < BLOCK_LENGTH ; i++ ) { if (cipher_text[i] != single_ans[i]) { success = false; } } //******************************************************** // DECIPHER IN AUTO MODE: // - 128bit cryptographic key and data // - ECB cipher mode // - XOR disable // - Polling AES State Ready Interrupt flag //******************************************************** /* Generate last subkey. */ if (!aes_lastsubkey_generate(key, lastsubkey)) { success = false; } /* Before using the AES it is recommended to do an AES software reset to * put the module in known state, in case other parts of your code has * accessed the AES module. */ aes_software_reset(); /* Set AES decryption of a single block in auto mode. */ aes_configure(AES_DECRYPT, AES_AUTO, AES_XOR_OFF); /* Disable the AES interrupt. */ aes_isr_configure(AES_INTLVL_OFF); /* Load key into AES key memory. */ aes_set_key(lastsubkey); /* Load data into AES state memory. */ aes_write_inputdata(cipher_text); // NOTE: since we're in auto mode, the ciphering process will start as soon // as the correct number of input data is written. In this case, the // process should start when we write the sixteenth byte. do { /* Wait until AES is finished or an error occurs. */ } while (aes_is_busy()); /* Store the result if not error. */ if (!aes_is_error()) { aes_read_outputdata(single_ans); } else { success = false; } /* Check if decrypted answer is equal to plaintext. */ for (i = 0; i < BLOCK_LENGTH ; i++ ) { if (plain_text[i] != single_ans[i]) { success = false; } } /* Disable the AES clock. */ sysclk_disable_module(SYSCLK_PORT_GEN, SYSCLK_AES); /* Indicate final result by lighting LED. */ if (success) { /* If the example ends up here every thing is ok. */ ioport_set_pin_low(LED0_GPIO); } else { /* If the example ends up here something is wrong. */ ioport_set_pin_low(LED1_GPIO); } while (true) { /* Go to sleep. */ sleepmgr_enter_sleep(); } }
int main( void ) { uint16_t i; /* Enable all three interrupt levels of the PMIC. */ pmic_init(); board_init(); sysclk_init(); sleepmgr_init(); /* Assume that everything is ok*/ success = true; /* Enable the AES clock. */ sysclk_enable_module(SYSCLK_PORT_GEN, SYSCLK_AES); /* Do AES decryption of a single block with AES interrupt handler. */ //******************************************************** // DECIPHER IN MANUAL MODE: // - 128bit cryptographic key and data // - ECB cipher mode // - XOR disable // - Interrupt call back handler //******************************************************** /* Generate last subkey. */ if (!aes_lastsubkey_generate(key, lastsubkey)) { success = false; } /* Enable global interrupts. */ cpu_irq_enable(); /* Assume no interrupt is finished. */ int_end = false; byte_count = 0; /* Set AES interrupt call back function. */ aes_set_callback(&aes_isr_handler); /* Before using the AES it is recommended to do an AES software reset to * put the module in known state, in case other parts of your code has * accessed the AES module. */ aes_software_reset(); /* Set AES encryption of a single block in manual mode. */ aes_configure(AES_DECRYPT, AES_MANUAL, AES_XOR_OFF); /* Enable the AES low level interrupt. */ aes_isr_configure(AES_INTLVL_LO); /* Load key into AES key memory. */ aes_set_key(lastsubkey); /* Load data into AES state memory. */ aes_write_inputdata(cipher_text); /* Start encryption. */ aes_start(); do{ /* Wait until the AES interrupt is finished. */ } while (!int_end); /* Do AES encryption and decryption of multi blocks. */ //******************************************************** // CIPHER IN AUTO MODE: // - 128bit cryptographic key and data // - CBC cipher mode // - XOR on // - Interrupt call back handler //******************************************************** /* Assume no interrupt is finished. */ int_end = false; byte_count = 0; /* Set AES interrupt call back function. */ aes_set_callback(&aes_isr_cbc_encrypt_handler); /* Before using the AES it is recommended to do an AES software reset to * put the module in known state, in case other parts of your code has * accessed the AES module. */ aes_software_reset(); /* Load initial vector into AES state memory. */ aes_write_inputdata(init); /* Set AES encryption of a single block in auto mode. */ aes_configure(AES_ENCRYPT, AES_AUTO, AES_XOR_ON); /* Enable the AES low level interrupt. */ aes_isr_configure(AES_INTLVL_LO); /* Load key into AES key memory. */ aes_set_key(key); /* Load data into AES state memory. */ aes_write_inputdata(data_block); // NOTE: since we're in auto mode, the ciphering process will start as soon // as the correct number of input data is written. In this case, the // process should start when we write the sixteenth byte. do{ /* Wait until the AES interrupt is finished. */ } while (!int_end); //******************************************************** // DECIPHER IN AUTO MODE: // - 128bit cryptographic key and data // - CBC cipher mode // - XOR off // - Interrupt call back handler //******************************************************** /* Generate last subkey. */ if (!aes_lastsubkey_generate(key, lastsubkey)) { success = false; } /* Assume no interrupt is finished. */ int_end = false; byte_count = 0; /* Set AES interrupt call back function. */ aes_set_callback(&aes_isr_cbc_decrypt_handler); /* Before using the AES it is recommended to do an AES software reset to * put the module in known state, in case other parts of your code has * accessed the AES module. */ aes_software_reset(); /* Set AES decryption of a single block in auto mode. */ aes_configure(AES_DECRYPT, AES_AUTO, AES_XOR_OFF); /* Enable the AES low level interrupt. */ aes_isr_configure(AES_INTLVL_LO); /* Load key into AES key memory. */ aes_set_key(lastsubkey); /* Load data into AES state memory. */ aes_write_inputdata(cipher_block_ans); // NOTE: since we're in auto mode, the ciphering process will start as soon // as the correct number of input data is written. In this case, the // process should start when we write the sixteenth byte. do{ /* Wait until the AES interrupt is finished. */ } while (!int_end); /* Check if decrypted answer is equal to plaintext. */ for (i = 0; i < BLOCK_LENGTH * BLOCK_COUNT ; i++) { if (data_block[i] != plain_block_ans[i]){ success = false; } } /* Disable the AES clock. */ sysclk_disable_module(SYSCLK_PORT_GEN, SYSCLK_AES); /* Indicate final result by lighting LED. */ if (success) { /* If the example ends up here every thing is ok. */ ioport_set_pin_low(LED0_GPIO); } else { /* If the example ends up here something is wrong. */ ioport_set_pin_low(LED1_GPIO); } while (true) { /* Go to sleep. */ sleepmgr_enter_sleep(); } }