21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › SAML21走起15:加密解密CALLBACK模式
返回列表 发新帖我要提问

[Atmel] SAML21走起15:加密解密CALLBACK模式

[复制链接]
831|0
 楼主| ddllxxrr 发表于 2015-8-18 21:15 | 显示全部楼层 |阅读模式
ck, AC, sam, 加密解密, ST
本帖最后由 ddllxxrr 于 2015-8-18 21:17 编辑

CALLBACK模式只是在加密或解密结束后自动设一个标志而已，同上次的基本一样。
首先打开快速指导的加密解密CALLBACK模式。
按照指导步骤完成程序。然后编译，以下程序一次通过。可见该程序执行了以下操作：
  • ECB encryption and decryption
  • CBC encryption and decryption
  • CFB128 encryption and decryption
  • OFB encryption and decryption
  • CTR encryption and decryption


每次执行完加密解密都调一下中断，这就是CALLBACK模式

程序如下：
复制
  1. #include <asf.h>
    

  2. #define AES_EXAMPLE_REFBUF_SIZE 4
    

  3. /* @{ */
    

  4.         uint32_t ref_plain_text[AES_EXAMPLE_REFBUF_SIZE] = {
    

  5.                 0xe2bec16b,
    

  6.                 0x969f402e,
    

  7.                 0x117e3de9,
    

  8.                 0x2a179373
    

  9.         };
    

  10.         uint32_t ref_cipher_text_ecb[AES_EXAMPLE_REFBUF_SIZE] = {
    

  11.                 0xb47bd73a,
    

  12.                 0x60367a0d,
    

  13.                 0xf3ca9ea8,
    

  14.                 0x97ef6624
    

  15.         };
    

  16.         uint32_t ref_cipher_text_cbc[AES_EXAMPLE_REFBUF_SIZE] = {
    

  17.                 0xacab4976,
    

  18.                 0x46b21981,
    

  19.                 0x9b8ee9ce,
    

  20.                 0x7d19e912
    

  21.         };
    

  22.         uint32_t ref_cipher_text_cfb128[AES_EXAMPLE_REFBUF_SIZE] = {
    

  23.                 0x2ed93f3b,
    

  24.                 0x20ad2db7,
    

  25.                 0xf8493433,
    

  26.                 0x4afb3ce8
    

  27.         };
    

  28.         uint32_t ref_cipher_text_ofb[AES_EXAMPLE_REFBUF_SIZE] = {
    

  29.                 0x2ed93f3b,
    

  30.                 0x20ad2db7,
    

  31.                 0xf8493433,
    

  32.                 0x4afb3ce8
    

  33.         };
    

  34.         uint32_t ref_cipher_text_ctr[AES_EXAMPLE_REFBUF_SIZE] = {
    

  35.                 0x91614d87,
    

  36.                 0x26e320b6,
    

  37.                 0x6468ef1b,
    

  38.                 0xceb60d99
    

  39.         };
    

  40.         const uint32_t key128[4] = {
    

  41.                 0x16157e2b,
    

  42.                 0xa6d2ae28,
    

  43.                 0x8815f7ab,
    

  44.                 0x3c4fcf09
    

  45.         };
    

  46.         const uint32_t init_vector[4] = {
    

  47.                 0x03020100,
    

  48.                 0x07060504,
    

  49.                 0x0b0a0908,
    

  50.                 0x0f0e0d0c
    

  51.         };
    

  52.         const uint32_t init_vector_ctr[4] = {
    

  53.                 0xf3f2f1f0,
    

  54.                 0xf7f6f5f4,
    

  55.                 0xfbfaf9f8,
    

  56.                 0xfffefdfc
    

  57.         };
    


  58. 


  59. 

  60. /* Output data array */
    

  61. static uint32_t output_data[AES_EXAMPLE_REFBUF_SIZE];
    

  62. /* State indicate */
    

  63. volatile bool state = false;
    

  64. struct aes_config g_aes_cfg;
    

  65. struct aes_module aes_instance;
    

  66. struct usart_module usart_instance;
    


  67. 


  68. 

  69. static void configure_usart(void)
    

  70. {
    

  71.         struct usart_config config_usart;
    

  72.         usart_get_config_defaults(&config_usart);
    

  73.         config_usart.baudrate    = 38400;
    

  74.         config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
    

  75.         config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
    

  76.         config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
    

  77.         config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
    

  78.         config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
    

  79.         stdio_serial_init(&usart_instance, EDBG_CDC_MODULE, &config_usart);
    

  80.         usart_enable(&usart_instance);
    

  81. }
    

  82. static void aes_callback(void)
    

  83. {
    

  84.         /* Read the output. */
    

  85.         aes_read_output_data(&aes_instance, output_data);
    

  86.         state = true;
    

  87. }
    

  88. static void ecb_mode_test(void)
    

  89. {
    

  90.         printf("\r\n-----------------------------------\r\n");
    

  91.         printf("- 128bit cryptographic key\r\n");
    

  92.         printf("- ECB cipher mode\r\n");
    

  93.         printf("- Auto start mode\r\n");
    

  94.         printf("- 4 32bit words\r\n");
    

  95.         printf("-----------------------------------\r\n");
    

  96.         state = false;
    

  97.         /* Configure the AES. */
    

  98.         g_aes_cfg.encrypt_mode = AES_ENCRYPTION;
    

  99.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  100.         g_aes_cfg.start_mode = AES_AUTO_START;
    

  101.         g_aes_cfg.opmode = AES_ECB_MODE;
    

  102.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  103.         g_aes_cfg.lod = false;
    

  104.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  105.         /* Set the cryptographic key. */
    

  106.         aes_write_key(&aes_instance, key128);
    

  107.         /* The initialization vector is not used by the ECB cipher mode. */
    

  108.         aes_set_new_message(&aes_instance);
    

  109.         /* Write the data to be ciphered to the input data registers. */
    

  110.         aes_write_input_data(&aes_instance, ref_plain_text);
    

  111.         aes_clear_new_message(&aes_instance);
    

  112.         /* Wait for the end of the encryption process. */
    

  113.         while (false == state) {
    

  114.         }
    

  115.         if ((ref_cipher_text_ecb[0] != output_data[0]) ||
    

  116.         (ref_cipher_text_ecb[1] != output_data[1]) ||
    

  117.         (ref_cipher_text_ecb[2] != output_data[2]) ||
    

  118.         (ref_cipher_text_ecb[3] != output_data[3])) {
    

  119.                 printf("\r\nKO!!!\r\n");
    

  120.                 } else {
    

  121.                 printf("\r\nOK!!!\r\n");
    

  122.         }
    

  123.         printf("\r\n-----------------------------------\r\n");
    

  124.         printf("- 128bit cryptographic key\r\n");
    

  125.         printf("- ECB decipher mode\r\n");
    

  126.         printf("- Auto start mode\r\n");
    

  127.         printf("- 4 32bit words\r\n");
    

  128.         printf("-----------------------------------\r\n");
    

  129.         state = false;
    

  130.         /* Configure the AES. */
    

  131.         g_aes_cfg.encrypt_mode = AES_DECRYPTION;
    

  132.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  133.         g_aes_cfg.start_mode = AES_AUTO_START;
    

  134.         g_aes_cfg.opmode = AES_ECB_MODE;
    

  135.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  136.         g_aes_cfg.lod = false;
    

  137.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  138.         /* Set the cryptographic key. */
    

  139.         aes_write_key(&aes_instance, key128);
    

  140.         /* The initialization vector is not used by the ECB cipher mode. */
    

  141.         aes_set_new_message(&aes_instance);
    

  142.         /* Write the data to be deciphered to the input data registers. */
    

  143.         aes_write_input_data(&aes_instance, ref_cipher_text_ecb);
    

  144.         aes_clear_new_message(&aes_instance);
    

  145.         /* Wait for the end of the decryption process. */
    

  146.         while (false == state) {
    

  147.         }
    

  148.         /* check the result. */
    

  149.         if ((ref_plain_text[0] != output_data[0]) ||
    

  150.         (ref_plain_text[1] != output_data[1]) ||
    

  151.         (ref_plain_text[2] != output_data[2]) ||
    

  152.         (ref_plain_text[3] != output_data[3])) {
    

  153.                 printf("\r\nKO!!!\r\n");
    

  154.                 } else {
    

  155.                 printf("\r\nOK!!!\r\n");
    

  156.         }
    

  157. }
    

  158. static void cbc_mode_test(void)
    

  159. {
    

  160.         printf("\r\n-----------------------------------\r\n");
    

  161.         printf("- 128bit cryptographic key\r\n");
    

  162.         printf("- CBC cipher mode\r\n");
    

  163.         printf("- Auto start mode\r\n");
    

  164.         printf("- 4 32bit words\r\n");
    

  165.         printf("-----------------------------------\r\n");
    

  166.         state = false;
    

  167.         /* Configure the AES. */
    

  168.         g_aes_cfg.encrypt_mode = AES_ENCRYPTION;
    

  169.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  170.         g_aes_cfg.start_mode = AES_MANUAL_START;
    

  171.         g_aes_cfg.opmode = AES_CBC_MODE;
    

  172.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  173.         g_aes_cfg.lod = false;
    

  174.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  175.         /* Set the cryptographic key. */
    

  176.         aes_write_key(&aes_instance, key128);
    

  177.         /* Set the initialization vector. */
    

  178.         aes_write_init_vector(&aes_instance, init_vector);
    

  179.         /* Write the data to be ciphered to the input data registers. */
    

  180.         aes_write_input_data(&aes_instance, ref_plain_text);
    

  181.         aes_set_new_message(&aes_instance);
    

  182.         aes_start(&aes_instance);
    

  183.         aes_clear_new_message(&aes_instance);
    

  184.         /* Wait for the end of the encryption process. */
    

  185.         while (false == state) {
    

  186.         }
    

  187.         if ((ref_cipher_text_cbc[0] != output_data[0]) ||
    

  188.         (ref_cipher_text_cbc[1] != output_data[1]) ||
    

  189.         (ref_cipher_text_cbc[2] != output_data[2]) ||
    

  190.         (ref_cipher_text_cbc[3] != output_data[3])) {
    

  191.                 printf("\r\nKO!!!\r\n");
    

  192.                 } else {
    

  193.                 printf("\r\nOK!!!\r\n");
    

  194.         }
    

  195.         printf("\r\n-----------------------------------\r\n");
    

  196.         printf("- 128bit cryptographic key\r\n");
    

  197.         printf("- CBC decipher mode\r\n");
    

  198.         printf("- Auto start mode\r\n");
    

  199.         printf("- 4 32bit words\r\n");
    

  200.         printf("-----------------------------------\r\n");
    

  201.         state = false;
    

  202.         /* Configure the AES. */
    

  203.         g_aes_cfg.encrypt_mode = AES_DECRYPTION;
    

  204.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  205.         g_aes_cfg.start_mode = AES_AUTO_START;
    

  206.         g_aes_cfg.opmode = AES_CBC_MODE;
    

  207.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  208.         g_aes_cfg.lod = false;
    

  209.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  210.         /* Set the cryptographic key. */
    

  211.         aes_write_key(&aes_instance, key128);
    

  212.         /* Set the initialization vector. */
    

  213.         aes_write_init_vector(&aes_instance, init_vector);
    

  214.         aes_set_new_message(&aes_instance);
    

  215.         /* Write the data to be deciphered to the input data registers. */
    

  216.         aes_write_input_data(&aes_instance, ref_cipher_text_cbc);
    

  217.         aes_clear_new_message(&aes_instance);
    

  218.         /* Wait for the end of the decryption process. */
    

  219.         while (false == state) {
    

  220.         }
    

  221.         if ((ref_plain_text[0] != output_data[0]) ||
    

  222.         (ref_plain_text[1] != output_data[1]) ||
    

  223.         (ref_plain_text[2] != output_data[2]) ||
    

  224.         (ref_plain_text[3] != output_data[3])) {
    

  225.                 printf("\r\nKO!!!\r\n");
    

  226.                 } else {
    

  227.                 printf("\r\nOK!!!\r\n");
    

  228.         }
    

  229. }
    

  230. static void cfb128_mode_test(void)
    

  231. {
    

  232.         printf("\r\n-----------------------------------\r\n");
    

  233.         printf("- 128bit cryptographic key\r\n");
    

  234.         printf("- CFB128 cipher mode\r\n");
    

  235.         printf("- Auto start mode\r\n");
    

  236.         printf("- 4 32bit words\r\n");
    

  237.         printf("-----------------------------------\r\n");
    

  238.         state = false;
    

  239.         /* Configure the AES. */
    

  240.         g_aes_cfg.encrypt_mode = AES_ENCRYPTION;
    

  241.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  242.         g_aes_cfg.start_mode = AES_MANUAL_START;
    

  243.         g_aes_cfg.opmode = AES_CFB_MODE;
    

  244.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  245.         g_aes_cfg.lod = false;
    

  246.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  247.         /* Set the cryptographic key. */
    

  248.         aes_write_key(&aes_instance, key128);
    

  249.         /* Set the initialization vector. */
    

  250.         aes_write_init_vector(&aes_instance, init_vector);
    

  251.         /* Write the data to be ciphered to the input data registers. */
    

  252.         aes_write_input_data(&aes_instance, ref_plain_text);
    

  253.         aes_set_new_message(&aes_instance);
    

  254.         aes_start(&aes_instance);
    

  255.         aes_clear_new_message(&aes_instance);
    

  256.         /* Wait for the end of the encryption process. */
    

  257.         while (false == state) {
    

  258.         }
    

  259.         /* check the result. */
    

  260.         if ((ref_cipher_text_cfb128[0] != output_data[0]) ||
    

  261.         (ref_cipher_text_cfb128[1] != output_data[1]) ||
    

  262.         (ref_cipher_text_cfb128[2] != output_data[2]) ||
    

  263.         (ref_cipher_text_cfb128[3] != output_data[3])) {
    

  264.                 printf("\r\nKO!!!\r\n");
    

  265.                 } else {
    

  266.                 printf("\r\nOK!!!\r\n");
    

  267.         }
    

  268.         printf("\r\n-----------------------------------\r\n");
    

  269.         printf("- 128bit cryptographic key\r\n");
    

  270.         printf("- CFB128 decipher mode\r\n");
    

  271.         printf("- Auto start mode\r\n");
    

  272.         printf("- 4 32bit words\r\n");
    

  273.         printf("-----------------------------------\r\n");
    

  274.         state = false;
    

  275.         /* Configure the AES. */
    

  276.         g_aes_cfg.encrypt_mode = AES_DECRYPTION;
    

  277.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  278.         g_aes_cfg.start_mode = AES_MANUAL_START;
    

  279.         g_aes_cfg.opmode = AES_CFB_MODE;
    

  280.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  281.         g_aes_cfg.lod = false;
    

  282.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  283.         /* Set the cryptographic key. */
    

  284.         aes_write_key(&aes_instance, key128);
    

  285.         /* Set the initialization vector. */
    

  286.         aes_write_init_vector(&aes_instance, init_vector);
    

  287.         /* Write the data to be deciphered to the input data registers. */
    

  288.         aes_write_input_data(&aes_instance, ref_cipher_text_cfb128);
    

  289.         aes_set_new_message(&aes_instance);
    

  290.         aes_start(&aes_instance);
    

  291.         aes_clear_new_message(&aes_instance);
    

  292.         /* Wait for the end of the decryption process. */
    

  293.         while (false == state) {
    

  294.         }
    

  295.         /* check the result. */
    

  296.         if ((ref_plain_text[0] != output_data[0]) ||
    

  297.         (ref_plain_text[1] != output_data[1]) ||
    

  298.         (ref_plain_text[2] != output_data[2]) ||
    

  299.         (ref_plain_text[3] != output_data[3])) {
    

  300.                 printf("\r\nKO!!!\r\n");
    

  301.                 } else {
    

  302.                 printf("\r\nOK!!!\r\n");
    

  303.         }
    

  304. }
    

  305. static void ofb_mode_test(void)
    

  306. {
    

  307.         printf("\r\n-----------------------------------\r\n");
    

  308.         printf("- 128bit cryptographic key\r\n");
    

  309.         printf("- OFB cipher mode\r\n");
    

  310.         printf("- Auto start mode\r\n");
    

  311.         printf("- 4 32bit words\r\n");
    

  312.         printf("-----------------------------------\r\n");
    

  313.         state = false;
    

  314.         /* Configure the AES. */
    

  315.         g_aes_cfg.encrypt_mode = AES_ENCRYPTION;
    

  316.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  317.         g_aes_cfg.start_mode = AES_AUTO_START;
    

  318.         g_aes_cfg.opmode = AES_OFB_MODE;
    

  319.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  320.         g_aes_cfg.lod = false;
    

  321.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  322.         /* Set the cryptographic key. */
    

  323.         aes_write_key(&aes_instance, key128);
    

  324.         /* Set the initialization vector. */
    

  325.         aes_write_init_vector(&aes_instance, init_vector);
    

  326.         aes_set_new_message(&aes_instance);
    

  327.         /* Write the data to be ciphered to the input data registers. */
    

  328.         aes_write_input_data(&aes_instance, ref_plain_text);
    

  329.         aes_clear_new_message(&aes_instance);
    

  330.         /* Wait for the end of the encryption process. */
    

  331.         while (false == state) {
    

  332.         }
    

  333.         /* check the result. */
    

  334.         if ((ref_cipher_text_ofb[0] != output_data[0]) ||
    

  335.         (ref_cipher_text_ofb[1] != output_data[1]) ||
    

  336.         (ref_cipher_text_ofb[2] != output_data[2]) ||
    

  337.         (ref_cipher_text_ofb[3] != output_data[3])) {
    

  338.                 printf("\r\nKO!!!\r\n");
    

  339.                 } else {
    

  340.                 printf("\r\nOK!!!\r\n");
    

  341.         }
    

  342.         printf("\r\n-----------------------------------\r\n");
    

  343.         printf("- 128bit cryptographic key\r\n");
    

  344.         printf("- OFB decipher mode\r\n");
    

  345.         printf("- Auto start mode\r\n");
    

  346.         printf("- 4 32bit words\r\n");
    

  347.         printf("-----------------------------------\r\n");
    

  348.         state = false;
    

  349.         /* Configure the AES. */
    

  350.         g_aes_cfg.encrypt_mode = AES_DECRYPTION;
    

  351.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  352.         g_aes_cfg.start_mode = AES_MANUAL_START;
    

  353.         g_aes_cfg.opmode = AES_OFB_MODE;
    

  354.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  355.         g_aes_cfg.lod = false;
    

  356.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  357.         /* Set the cryptographic key. */
    

  358.         aes_write_key(&aes_instance, key128);
    

  359.         /* Set the initialization vector. */
    

  360.         aes_write_init_vector(&aes_instance, init_vector);
    

  361.         /* Write the data to be deciphered to the input data registers. */
    

  362.         aes_write_input_data(&aes_instance, ref_cipher_text_ofb);
    

  363.         aes_set_new_message(&aes_instance);
    

  364.         aes_start(&aes_instance);
    

  365.         aes_clear_new_message(&aes_instance);
    

  366.         /* Wait for the end of the decryption process. */
    

  367.         while (false == state) {
    

  368.         }
    

  369.         /* check the result. */
    

  370.         if ((ref_plain_text[0] != output_data[0]) ||
    

  371.         (ref_plain_text[1] != output_data[1]) ||
    

  372.         (ref_plain_text[2] != output_data[2]) ||
    

  373.         (ref_plain_text[3] != output_data[3])) {
    

  374.                 printf("\r\nKO!!!\r\n");
    

  375.                 } else {
    

  376.                 printf("\r\nOK!!!\r\n");
    

  377.         }
    

  378. }
    

  379. static void ctr_mode_test(void)
    

  380. {
    

  381.         printf("\r\n-----------------------------------\r\n");
    

  382.         printf("- 128bit cryptographic key\r\n");
    

  383.         printf("- CTR cipher mode\r\n");
    

  384.         printf("- Auto start mode\r\n");
    

  385.         printf("- 4 32bit words\r\n");
    

  386.         printf("-----------------------------------\r\n");
    

  387.         state = false;
    

  388.         /* Configure the AES. */
    

  389.         g_aes_cfg.encrypt_mode = AES_ENCRYPTION;
    

  390.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  391.         g_aes_cfg.start_mode = AES_AUTO_START;
    

  392.         g_aes_cfg.opmode = AES_CTR_MODE;
    

  393.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  394.         g_aes_cfg.lod = false;
    

  395.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  396.         /* Set the cryptographic key. */
    

  397.         aes_write_key(&aes_instance, key128);
    

  398.         /* Set the initialization vector. */
    

  399.         aes_write_init_vector(&aes_instance, init_vector_ctr);
    

  400.         aes_set_new_message(&aes_instance);
    

  401.         /* Write the data to be ciphered to the input data registers. */
    

  402.         aes_write_input_data(&aes_instance, ref_plain_text);
    

  403.         aes_clear_new_message(&aes_instance);
    

  404.         /* Wait for the end of the encryption process. */
    

  405.         while (false == state) {
    

  406.         }
    

  407.         /* check the result. */
    

  408.         if ((ref_cipher_text_ctr[0] != output_data[0]) ||
    

  409.         (ref_cipher_text_ctr[1] != output_data[1]) ||
    

  410.         (ref_cipher_text_ctr[2] != output_data[2]) ||
    

  411.         (ref_cipher_text_ctr[3] != output_data[3])) {
    

  412.                 printf("\r\nKO!!!\r\n");
    

  413.                 } else {
    

  414.                 printf("\r\nOK!!!\r\n");
    

  415.         }
    

  416.         printf("\r\n-----------------------------------\r\n");
    

  417.         printf("- 128bit cryptographic key\r\n");
    

  418.         printf("- CTR decipher mode\r\n");
    

  419.         printf("- Auto start mode\r\n");
    

  420.         printf("- 4 32bit words\r\n");
    

  421.         printf("-----------------------------------\r\n");
    

  422.         state = false;
    

  423.         /* Configure the AES. */
    

  424.         g_aes_cfg.encrypt_mode = AES_DECRYPTION;
    

  425.         g_aes_cfg.key_size = AES_KEY_SIZE_128;
    

  426.         g_aes_cfg.start_mode = AES_MANUAL_START;
    

  427.         g_aes_cfg.opmode = AES_CTR_MODE;
    

  428.         g_aes_cfg.cfb_size = AES_CFB_SIZE_128;
    

  429.         g_aes_cfg.lod = false;
    

  430.         aes_set_config(&aes_instance,AES, &g_aes_cfg);
    

  431.         /* Set the cryptographic key. */
    

  432.         aes_write_key(&aes_instance, key128);
    

  433.         /* Set the initialization vector. */
    

  434.         aes_write_init_vector(&aes_instance, init_vector_ctr);
    

  435.         /* Write the data to be deciphered to the input data registers. */
    

  436.         aes_write_input_data(&aes_instance, ref_cipher_text_ctr);
    

  437.         aes_set_new_message(&aes_instance);
    

  438.         aes_start(&aes_instance);
    

  439.         aes_clear_new_message(&aes_instance);
    

  440.         /* Wait for the end of the decryption process. */
    

  441.         while (false == state) {
    

  442.         }
    

  443.         /* check the result. */
    

  444.         if ((ref_plain_text[0] != output_data[0]) ||
    

  445.         (ref_plain_text[1] != output_data[1]) ||
    

  446.         (ref_plain_text[2] != output_data[2]) ||
    

  447.         (ref_plain_text[3] != output_data[3])) {
    

  448.                 printf("\r\nKO!!!\r\n");
    

  449.                 } else {
    

  450.                 printf("\r\nOK!!!\r\n");
    

  451.         }
    

  452. }
    


  453. 


  454. 

  455. int main (void)
    

  456. {
    

  457.         
    

  458.            /* Initialize the system and console*/
    

  459.            system_init();
    

  460.            configure_usart();
    

  461.            aes_get_config_defaults(&g_aes_cfg);
    

  462.            aes_init(&aes_instance,AES, &g_aes_cfg);
    

  463.            aes_enable(&aes_instance);
    

  464.            /* Enable AES interrupt. */
    

  465.            aes_register_callback(aes_callback,AES_CALLBACK_ENCRYPTION_COMPLETE);
    

  466.            aes_enable_callback(&aes_instance,AES_CALLBACK_ENCRYPTION_COMPLETE);
    

  467.            
    

  468.             ecb_mode_test();
    

  469.             cbc_mode_test();
    

  470.             cfb128_mode_test();
    

  471.             ofb_mode_test();
    

  472.             ctr_mode_test();
    

  473.         
    

  474. }
执行的结果如下：


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

相关帖子
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

ddllxxrr
个人签名：http://shop34182318.taobao.com/ http://shop562064536.taobao.com

2404

主题

7006

帖子

68

粉丝
快速回复 在线客服 返回列表 返回顶部