/** * \brief Run encryption, then decryption. Announce end by interrupt. * * This test encrypts a data block, decrypts it, and checks if it's * correct with respect to the input data block. Utilizes interrupts * to let the software know when a encryption/decryption is done. * AUTO mode will be used in this test. * * \param test Current test case. */ static void run_aes_encrypt_and_decrypt_test(const struct test_case *test) { bool success = true; set_buffer(output_data, 0x00); set_buffer(lastsubkey, 0x00); aes_software_reset(); /* Configure AES for automatic mode, with XOR, and interrupt. */ aes_configure(AES_ENCRYPT, AES_AUTO, AES_XOR_ON); aes_isr_configure(AES_INTLVL_LO); aes_set_key(encryption_key); aes_write_inputdata(encryption_data); /* * Wait for it to end, since we actually don't have * anything better to do */ while (!aes_is_finished) { /* Intentionally left empty */ } /* output_data should now contain encrypted data */ /* Configure AES for automatic mode, XOR off. Last subkey * is already in the module, so we don't need to load it */ aes_is_finished = false; aes_configure(AES_DECRYPT, AES_AUTO, AES_XOR_OFF); aes_write_inputdata(output_data); while (!aes_is_finished) { /* Intentionally left empty */ } /* The AES module should be finished now, and output_data * should contain our initial data. */ success = compare_data_block(output_data, encryption_data); test_assert_true(test, success, "End values do not match start 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 of a single block with DMA support. */ //******************************************************** // CIPHER IN MANUAL MODE: // - 128bit cryptographic key and data // - ECB cipher mode // - XOR disable // - DMA support for AES input and output //******************************************************** /* 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); /* Set KEY and write STATE using DMA channel 0. */ aes_dma_input(); /* 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()){ /* Read STATE using DMA channel 0. */ aes_dma_output(); } 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; } } /* 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 ) { 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(); } }