开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
Ap4AesBlockCipher.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：62k
源码类别：

多媒体编程

开发平台：

Visual C++

Ap4AesBlockCipher.cpp：源码内容
  1. /*
  2. * AES Block cipher
  3. * (c) 2005 Gilles Boccon-Gibod
  4. * Portions (c) 2001, Dr Brian Gladman (see below)
  5. */
  7. /*
  8. -------------------------------------------------------------------------
  9. Copyright (c) 2001, Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK.
  10. All rights reserved.
  12. LICENSE TERMS
  14. The free distribution and use of this software in both source and binary 
  15. form is allowed (with or without changes) provided that:
  17. 1. distributions of this source code include the above copyright 
  18. notice, this list of conditions and the following disclaimer;
  20. 2. distributions in binary form include the above copyright
  21. notice, this list of conditions and the following disclaimer
  22. in the documentation and/or other associated materials;
  24. 3. the copyright holder's name is not used to endorse products 
  25. built using this software without specific written permission. 
  27. DISCLAIMER
  29. This software is provided 'as is' with no explicit or implied warranties
  30. in respect of its properties, including, but not limited to, correctness 
  31. and fitness for purpose.
  32. -------------------------------------------------------------------------
  33. Issue Date: 29/07/2002
  34. */
  36. /*----------------------------------------------------------------------
  37. |       includes
  38. +---------------------------------------------------------------------*/
  39. #include "Ap4AesBlockCipher.h"
  40. #include "Ap4Results.h"
  42. /*----------------------------------------------------------------------
  43. |       build options
  44. +---------------------------------------------------------------------*/
  45. #define ENCRYPTION_KEY_SCHEDULE
  46. #define ENCRYPTION
  47. #define BLOCK_SIZE AP4_AES_BLOCK_SIZE
  49. /*----------------------------------------------------------------------
  50. |       options
  51. +---------------------------------------------------------------------*/
  52. /*  START OF CONFIGURATION OPTIONS
  54.     USE OF DEFINES
  55.   
  56.     Later in this section there are a number of defines that control the 
  57.     operation of the code.  In each section, the purpose of each define is 
  58.     explained so that the relevant form can be included or excluded by 
  59.     setting either 1's or 0's respectively on the branches of the related 
  60.     #if clauses.
  61. */
  63. /*  1. BYTE ORDER IN 32-BIT WORDS
  65.     To obtain the highest speed on processors with 32-bit words, this code 
  66.     needs to determine the order in which bytes are packed into such words.
  67.     The following block of code is an attempt to capture the most obvious 
  68.     ways in which various environemnts define byte order. It may well fail, 
  69.     in which case the definitions will need to be set by editing at the 
  70.     points marked **** EDIT HERE IF NECESSARY **** below.
  71. */
  72. #define AES_LITTLE_ENDIAN   1234 /* byte 0 is least significant (i386) */
  73. #define AES_BIG_ENDIAN      4321 /* byte 0 is most significant (mc68k) */
  75. #if !defined(AP4_PLATFORM_BYTE_ORDER)
  76. #  error AP4_PLATFORM_BYTE_ORDER is not set
  77. #endif
  79. #if 0
  80. #if AP4_PLATFORM_BYTE_ORDER == AP4_PLATFORM_BIG_ENDIAN
  81. #define PLATFORM_BYTE_ORDER AES_BIG_ENDIAN
  82. #elif AP4_PLATFORM_BYTE_ORDER == AP4_PLATFORM_LITTLE_ENDIAN
  83. #define PLATFORM_BYTE_ORDER AES_LITTLE_ENDIAN
  84. #else
  85. #error unsupported value for AP4_PLATFORM_BYTE_ORDER
  86. #endif
  87. #endif
  89. #define PLATFORM_BYTE_ORDER AES_LITTLE_ENDIAN
  92. /*  2. BYTE ORDER WITHIN 32 BIT WORDS
  94.     The fundamental data processing units in Rijndael are 8-bit bytes. The 
  95.     input, output and key input are all enumerated arrays of bytes in which 
  96.     bytes are numbered starting at zero and increasing to one less than the 
  97.     number of bytes in the array in question. This enumeration is only used 
  98.     for naming bytes and does not imply any adjacency or order relationship 
  99.     from one byte to another. When these inputs and outputs are considered 
  100.     as bit sequences, bits 8*n to 8*n+7 of the bit sequence are mapped to 
  101.     byte[n] with bit 8n+i in the sequence mapped to bit 7-i within the byte. 
  102.     In this implementation bits are numbered from 0 to 7 starting at the 
  103.     numerically least significant end of each byte (bit n represents 2^n).
  105.     However, Rijndael can be implemented more efficiently using 32-bit 
  106.     words by packing bytes into words so that bytes 4*n to 4*n+3 are placed
  107.     into word[n]. While in principle these bytes can be assembled into words 
  108.     in any positions, this implementation only supports the two formats in 
  109.     which bytes in adjacent positions within words also have adjacent byte
  110.     numbers. This order is called big-endian if the lowest numbered bytes 
  111.     in words have the highest numeric significance and little-endian if the 
  112.     opposite applies. 
  113.     
  114.     This code can work in either order irrespective of the order used by the 
  115.     machine on which it runs. Normally the internal byte order will be set
  116.     to the order of the processor on which the code is to be run but this
  117.     define can be used to reverse this in special situations
  118. */
  119. #if 1
  120. #define INTERNAL_BYTE_ORDER PLATFORM_BYTE_ORDER
  121. #elif defined(AES_LITTLE_ENDIAN)
  122. #define INTERNAL_BYTE_ORDER AES_LITTLE_ENDIAN
  123. #elif defined(AES_BIG_ENDIAN)
  124. #define INTERNAL_BYTE_ORDER AES_BIG_ENDIAN
  125. #endif
  127. /*  3. FAST INPUT/OUTPUT OPERATIONS.  
  129.     On some machines it is possible to improve speed by transferring the 
  130.     bytes in the input and output arrays to and from the internal 32-bit 
  131.     variables by addressing these arrays as if they are arrays of 32-bit 
  132.     words.  On some machines this will always be possible but there may 
  133.     be a large performance penalty if the byte arrays are not aligned on 
  134.     the normal word boundaries. On other machines this technique will 
  135.     lead to memory access errors when such 32-bit word accesses are not
  136.     properly aligned. The option SAFE_IO avoids such problems but will 
  137.     often be slower on those machines that support misaligned access 
  138.     (especially so if care is taken to align the input  and output byte 
  139.     arrays on 32-bit word boundaries). If SAFE_IO is not defined it is 
  140.     assumed that access to byte arrays as if they are arrays of 32-bit 
  141.     words will not cause problems when such accesses are misaligned.
  142. */
  143. #if 1
  144. #define SAFE_IO
  145. #endif
  147. /*  4. LOOP UNROLLING
  149.     The code for encryption and decrytpion cycles through a number of rounds
  150.     that can be implemented either in a loop or by expanding the code into a 
  151.     long sequence of instructions, the latter producing a larger program but
  152.     one that will often be much faster. The latter is called loop unrolling.
  153.     There are also potential speed advantages in expanding two iterations in
  154.     a loop with half the number of iterations, which is called partial loop
  155.     unrolling.  The following options allow partial or full loop unrolling 
  156.     to be set independently for encryption and decryption
  157. */
  158. #if 1
  159. #define ENC_UNROLL  FULL
  160. #elif 0
  161. #define ENC_UNROLL  PARTIAL
  162. #else
  163. #define ENC_UNROLL  NONE
  164. #endif
  166. #if 1
  167. #define DEC_UNROLL  FULL
  168. #elif 0
  169. #define DEC_UNROLL  PARTIAL
  170. #else
  171. #define DEC_UNROLL  NONE
  172. #endif
  174. /*  5. FIXED OR DYNAMIC TABLES
  176.     When this section is included the tables used by the code are comipled 
  177.     statically into the binary file.  Otherwise they are computed once when 
  178.     the code is first used.
  179. */
  180. #if 1
  181. #define FIXED_TABLES
  182. #endif
  184. /*  6. FAST FINITE FIELD OPERATIONS
  186.     If this section is included, tables are used to provide faster finite 
  187.     field arithmetic (this has no effect if FIXED_TABLES is defined).
  188. */
  189. #if 1
  190. #define FF_TABLES
  191. #endif
  193. /*  7. INTERNAL STATE VARIABLE FORMAT
  195.     The internal state of Rijndael is stored in a number of local 32-bit 
  196.     word varaibles which can be defined either as an array or as individual 
  197.     names variables. Include this section if you want to store these local
  198.     variables in arrays. Otherwise individual local variables will be used.
  199. */
  200. #if 1
  201. #define ARRAYS
  202. #endif
  204. /* In this implementation the columns of the state array are each held in
  205.    32-bit words. The state array can be held in various ways: in an array
  206.    of words, in a number of individual word variables or in a number of 
  207.    processor registers. The following define maps a variable name x and
  208.    a column number c to the way the state array variable is to be held.
  209.    The first define below maps the state into an array x[c] whereas the 
  210.    second form maps the state into a number of individual variables x0,
  211.    x1, etc.  Another form could map individual state colums to machine
  212.    register names.
  213. */
  215. #if defined(ARRAYS)
  216. #define s(x,c) x[c]
  217. #else
  218. #define s(x,c) x##c
  219. #endif
  221. /*  8. VARIABLE BLOCK SIZE SPEED
  223.     This section is only relevant if you wish to use the variable block
  224.     length feature of the code.  Include this section if you place more
  225.     emphasis on speed rather than code size.
  226. */
  227. #if 1
  228. #define FAST_VARIABLE
  229. #endif
  231. /*  9. INTERNAL TABLE CONFIGURATION
  233.     This cipher proceeds by repeating in a number of cycles known as 'rounds'
  234.     which are implemented by a round function which can optionally be speeded
  235.     up using tables.  The basic tables are each 256 32-bit words, with either 
  236.     one or four tables being required for each round function depending on
  237.     how much speed is required. The encryption and decryption round functions
  238.     are different and the last encryption and decrytpion round functions are
  239.     different again making four different round functions in all.
  241.     This means that:
  242.       1. Normal encryption and decryption rounds can each use either 0, 1 
  243.          or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
  244.       2. The last encryption and decryption rounds can also use either 0, 1 
  245.          or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
  247.     Include or exclude the appropriate definitions below to set the number
  248.     of tables used by this implementation.
  249. */
  251. #if 1   /* set tables for the normal encryption round */
  252. #define ENC_ROUND   FOUR_TABLES
  253. #elif 0
  254. #define ENC_ROUND   ONE_TABLE
  255. #else
  256. #define ENC_ROUND   NO_TABLES
  257. #endif
  259. #if 1   /* set tables for the last encryption round */
  260. #define LAST_ENC_ROUND  FOUR_TABLES
  261. #elif 0
  262. #define LAST_ENC_ROUND  ONE_TABLE
  263. #else
  264. #define LAST_ENC_ROUND  NO_TABLES
  265. #endif
  267. #if 1   /* set tables for the normal decryption round */
  268. #define DEC_ROUND   FOUR_TABLES
  269. #elif 0
  270. #define DEC_ROUND   ONE_TABLE
  271. #else
  272. #define DEC_ROUND   NO_TABLES
  273. #endif
  275. #if 1   /* set tables for the last decryption round */
  276. #define LAST_DEC_ROUND  FOUR_TABLES
  277. #elif 0
  278. #define LAST_DEC_ROUND  ONE_TABLE
  279. #else
  280. #define LAST_DEC_ROUND  NO_TABLES
  281. #endif
  283. /*  The decryption key schedule can be speeded up with tables in the same
  284.     way that the round functions can.  Include or exclude the following 
  285.     defines to set this requirement.
  286. */
  287. #if 1
  288. #define KEY_SCHED   FOUR_TABLES
  289. #elif 0
  290. #define KEY_SCHED   ONE_TABLE
  291. #else
  292. #define KEY_SCHED   NO_TABLES
  293. #endif
  295. /* END OF CONFIGURATION OPTIONS */
  297. #define NO_TABLES   0   /* DO NOT CHANGE */
  298. #define ONE_TABLE   1   /* DO NOT CHANGE */
  299. #define FOUR_TABLES 4   /* DO NOT CHANGE */
  300. #define NONE        0   /* DO NOT CHANGE */
  301. #define PARTIAL     1   /* DO NOT CHANGE */
  302. #define FULL        2   /* DO NOT CHANGE */
  304. #if defined(BLOCK_SIZE) && ((BLOCK_SIZE & 3) || BLOCK_SIZE < 16 || BLOCK_SIZE > 32)
  305. #error An illegal block size has been specified.
  306. #endif  
  308. #if !defined(BLOCK_SIZE)
  309. #define RC_LENGTH    29
  310. #else
  311. #define RC_LENGTH   5 * BLOCK_SIZE / 4 - (BLOCK_SIZE == 16 ? 10 : 11)
  312. #endif
  314. /* Disable at least some poor combinations of options */
  316. #if ENC_ROUND == NO_TABLES && LAST_ENC_ROUND != NO_TABLES
  317. #undef  LAST_ENC_ROUND
  318. #define LAST_ENC_ROUND  NO_TABLES
  319. #elif ENC_ROUND == ONE_TABLE && LAST_ENC_ROUND == FOUR_TABLES
  320. #undef  LAST_ENC_ROUND
  321. #define LAST_ENC_ROUND  ONE_TABLE 
  322. #endif
  324. #if ENC_ROUND == NO_TABLES && ENC_UNROLL != NONE
  325. #undef  ENC_UNROLL
  326. #define ENC_UNROLL  NONE
  327. #endif
  329. #if DEC_ROUND == NO_TABLES && LAST_DEC_ROUND != NO_TABLES
  330. #undef  LAST_DEC_ROUND
  331. #define LAST_DEC_ROUND  NO_TABLES
  332. #elif DEC_ROUND == ONE_TABLE && LAST_DEC_ROUND == FOUR_TABLES
  333. #undef  LAST_DEC_ROUND
  334. #define LAST_DEC_ROUND  ONE_TABLE 
  335. #endif
  337. #if DEC_ROUND == NO_TABLES && DEC_UNROLL != NONE
  338. #undef  DEC_UNROLL
  339. #define DEC_UNROLL  NONE
  340. #endif
  342. /*  upr(x,n):  rotates bytes within words by n positions, moving bytes to
  343.                higher index positions with wrap around into low positions
  344.     ups(x,n):  moves bytes by n positions to higher index positions in 
  345.                words but without wrap around
  346.     bval(x,n): extracts a byte from a word
  348.     NOTE:      The definitions given here are intended only for use with 
  349.                unsigned variables and with shift counts that are compile
  350.                time constants
  351. */
  353. #if (INTERNAL_BYTE_ORDER == AES_LITTLE_ENDIAN)
  354. #if defined(_MSC_VER)
  355. #define upr(x,n)        _lrotl((aes_32t)(x), 8 * (n))
  356. #else
  357. #define upr(x,n)        ((aes_32t)(x) << 8 * (n) | (aes_32t)(x) >> (32 - 8 * (n)))
  358. #endif
  359. #define ups(x,n)        ((aes_32t)(x) << 8 * (n))
  360. #define bval(x,n)       ((aes_08t)((x) >> 8 * (n)))
  361. #define bytes2word(b0, b1, b2, b3)  
  362.         (((aes_32t)(b3) << 24) | ((aes_32t)(b2) << 16) | ((aes_32t)(b1) << 8) | (b0))
  363. #endif
  365. #if (INTERNAL_BYTE_ORDER == AES_BIG_ENDIAN)
  366. #define upr(x,n)        ((aes_32t)(x) >> 8 * (n) | (aes_32t)(x) << 32 - 8 * (n))
  367. #define ups(x,n)        ((aes_32t)(x) >> 8 * (n)))
  368. #define bval(x,n)       ((aes_08t)((x) >> (24 - 8 * (n))))
  369. #define bytes2word(b0, b1, b2, b3)  
  370.         (((aes_32t)(b0) << 24) | ((aes_32t)(b1) << 16) | ((aes_32t)(b2) << 8) | (b3))
  371. #endif
  373. #if defined(SAFE_IO)
  375. #define word_in(x)      bytes2word((x)[0], (x)[1], (x)[2], (x)[3])
  376. #define word_out(x,v)   { (x)[0] = bval(v,0); (x)[1] = bval(v,1);   
  377.                           (x)[2] = bval(v,2); (x)[3] = bval(v,3);   }
  379. #elif (INTERNAL_BYTE_ORDER == PLATFORM_BYTE_ORDER)
  381. #define word_in(x)      *(aes_32t*)(x)
  382. #define word_out(x,v)   *(aes_32t*)(x) = (v)
  384. #else
  386. #if !defined(bswap_32)
  387. #if !defined(_MSC_VER)
  388. #define _lrotl(x,n)     ((((aes_32t)(x)) <<  n) | (((aes_32t)(x)) >> (32 - n)))
  389. #endif
  390. #define bswap_32(x)     ((_lrotl((x),8) & 0x00ff00ff) | (_lrotl((x),24) & 0xff00ff00)) 
  391. #endif
  393. #define word_in(x)      bswap_32(*(aes_32t*)(x))
  394. #define word_out(x,v)   *(aes_32t*)(x) = bswap_32(v)
  396. #endif
  398. /* the finite field modular polynomial and elements */
  400. #define WPOLY   0x011b
  401. #define BPOLY     0x1b
  403. /* multiply four bytes in GF(2^8) by 'x' {02} in parallel */
  405. #define m1  0x80808080
  406. #define m2  0x7f7f7f7f
  407. #define FFmulX(x)  ((((x) & m2) << 1) ^ ((((x) & m1) >> 7) * BPOLY))
  409. /* The following defines provide alternative definitions of FFmulX that might
  410.    give improved performance if a fast 32-bit multiply is not available. Note
  411.    that a temporary variable u needs to be defined where FFmulX is used.
  413. #define FFmulX(x) (u = (x) & m1, u |= (u >> 1), ((x) & m2) << 1) ^ ((u >> 3) | (u >> 6)) 
  414. #define m4  (0x01010101 * BPOLY)
  415. #define FFmulX(x) (u = (x) & m1, ((x) & m2) << 1) ^ ((u - (u >> 7)) & m4) 
  416. */
  418. /* Work out which tables are needed for the different options   */
  420. #ifdef  AES_ASM
  421. #ifdef  ENC_ROUND
  422. #undef  ENC_ROUND
  423. #endif
  424. #define ENC_ROUND   FOUR_TABLES
  425. #ifdef  LAST_ENC_ROUND
  426. #undef  LAST_ENC_ROUND
  427. #endif
  428. #define LAST_ENC_ROUND  FOUR_TABLES
  429. #ifdef  DEC_ROUND
  430. #undef  DEC_ROUND
  431. #endif
  432. #define DEC_ROUND   FOUR_TABLES
  433. #ifdef  LAST_DEC_ROUND
  434. #undef  LAST_DEC_ROUND
  435. #endif
  436. #define LAST_DEC_ROUND  FOUR_TABLES
  437. #ifdef  KEY_SCHED
  438. #undef  KEY_SCHED
  439. #define KEY_SCHED   FOUR_TABLES
  440. #endif
  441. #endif
  443. #if defined(ENCRYPTION) || defined(AES_ASM)
  444. #if ENC_ROUND == ONE_TABLE
  445. #define FT1_SET
  446. #elif ENC_ROUND == FOUR_TABLES
  447. #define FT4_SET
  448. #else
  449. #define SBX_SET
  450. #endif
  451. #if LAST_ENC_ROUND == ONE_TABLE
  452. #define FL1_SET
  453. #elif LAST_ENC_ROUND == FOUR_TABLES
  454. #define FL4_SET
  455. #elif !defined(SBX_SET)
  456. #define SBX_SET
  457. #endif
  458. #endif
  460. #if defined(DECRYPTION) || defined(AES_ASM)
  461. #if DEC_ROUND == ONE_TABLE
  462. #define IT1_SET
  463. #elif DEC_ROUND == FOUR_TABLES
  464. #define IT4_SET
  465. #else
  466. #define ISB_SET
  467. #endif
  468. #if LAST_DEC_ROUND == ONE_TABLE
  469. #define IL1_SET
  470. #elif LAST_DEC_ROUND == FOUR_TABLES
  471. #define IL4_SET
  472. #elif !defined(ISB_SET)
  473. #define ISB_SET
  474. #endif
  475. #endif
  477. #if defined(ENCRYPTION_KEY_SCHEDULE) || defined(DECRYPTION_KEY_SCHEDULE)
  478. #if KEY_SCHED == ONE_TABLE
  479. #define LS1_SET
  480. #define IM1_SET
  481. #elif KEY_SCHED == FOUR_TABLES
  482. #define LS4_SET
  483. #define IM4_SET
  484. #elif !defined(SBX_SET)
  485. #define SBX_SET
  486. #endif
  487. #endif
  489. #ifdef  FIXED_TABLES
  490. #define prefx   static const
  491. #else
  492. #define prefx   extern
  493. extern aes_08t  tab_init;
  494. void gen_tabs(void);
  495. #endif
  497. //prefx aes_32t  rcon_tab[29];
  498. //
  499. //#ifdef  SBX_SET
  500. //prefx aes_08t s_box[256];
  501. //#endif
  502. //
  503. //#ifdef  ISB_SET
  504. //prefx aes_08t inv_s_box[256];
  505. //#endif
  506. //
  507. //#ifdef  FT1_SET
  508. //prefx aes_32t ft_tab[256];
  509. //#endif
  510. //
  511. //#ifdef  FT4_SET
  512. //prefx aes_32t ft_tab[4][256];
  513. //#endif
  514. //
  515. //#ifdef  FL1_SET
  516. //prefx aes_32t fl_tab[256];
  517. //#endif
  518. //
  519. //#ifdef  FL4_SET
  520. //prefx aes_32t fl_tab[4][256];
  521. //#endif
  522. //
  523. //#ifdef  IT1_SET
  524. //prefx aes_32t it_tab[256];
  525. //#endif
  526. //
  527. //#ifdef  IT4_SET
  528. //prefx aes_32t it_tab[4][256];
  529. //#endif
  530. //
  531. //#ifdef  IL1_SET
  532. //prefx aes_32t il_tab[256];
  533. //#endif
  534. //
  535. //#ifdef  IL4_SET
  536. //prefx aes_32t il_tab[4][256];
  537. //#endif
  538. //
  539. //#ifdef  LS1_SET
  540. //#ifdef  FL1_SET
  541. //#undef  LS1_SET
  542. //#else
  543. //prefx aes_32t ls_tab[256];
  544. //#endif
  545. //#endif
  546. //
  547. //#ifdef  LS4_SET
  548. //#ifdef  FL4_SET
  549. //#undef  LS4_SET
  550. //#else
  551. //prefx aes_32t ls_tab[4][256];
  552. //#endif
  553. //#endif
  554. //
  555. //#ifdef  IM1_SET
  556. //prefx aes_32t im_tab[256];
  557. //#endif
  558. //
  559. //#ifdef  IM4_SET
  560. //prefx aes_32t im_tab[4][256];
  561. //#endif
  563. /* Set the number of columns in nc.  Note that it is important
  564.    that nc is a constant which is known at compile time if the
  565.    highest speed version of the code is needed.
  566. */
  568. #if defined(BLOCK_SIZE)
  569. #define nc  (BLOCK_SIZE >> 2)
  570. #else
  571. #define nc  (cx->n_blk >> 2)
  572. #endif
  574. /* generic definitions of Rijndael macros that use tables    */
  576. #define no_table(x,box,vf,rf,c) bytes2word( 
  577.     box[bval(vf(x,0,c),rf(0,c))], 
  578.     box[bval(vf(x,1,c),rf(1,c))], 
  579.     box[bval(vf(x,2,c),rf(2,c))], 
  580.     box[bval(vf(x,3,c),rf(3,c))])
  582. #define one_table(x,op,tab,vf,rf,c) 
  583.  (     tab[bval(vf(x,0,c),rf(0,c))] 
  584.   ^ op(tab[bval(vf(x,1,c),rf(1,c))],1) 
  585.   ^ op(tab[bval(vf(x,2,c),rf(2,c))],2) 
  586.   ^ op(tab[bval(vf(x,3,c),rf(3,c))],3))
  588. #define four_tables(x,tab,vf,rf,c) 
  589.  (  tab[0][bval(vf(x,0,c),rf(0,c))] 
  590.   ^ tab[1][bval(vf(x,1,c),rf(1,c))] 
  591.   ^ tab[2][bval(vf(x,2,c),rf(2,c))] 
  592.   ^ tab[3][bval(vf(x,3,c),rf(3,c))])
  594. #define vf1(x,r,c)  (x)
  595. #define rf1(r,c)    (r)
  596. #define rf2(r,c)    ((r-c)&3)
  598. /* perform forward and inverse column mix operation on four bytes in long word x in */
  599. /* parallel. NOTE: x must be a simple variable, NOT an expression in these macros.  */
  601. #define dec_fmvars
  602. #if defined(FM4_SET)    /* not currently used */
  603. #define fwd_mcol(x)     four_tables(x,fm_tab,vf1,rf1,0)
  604. #elif defined(FM1_SET)  /* not currently used */
  605. #define fwd_mcol(x)     one_table(x,upr,fm_tab,vf1,rf1,0)
  606. #else
  607. #undef  dec_fmvars
  608. #define dec_fmvars      aes_32t f1, f2;
  609. #define fwd_mcol(x)     (f1 = (x), f2 = FFmulX(f1), f2 ^ upr(f1 ^ f2, 3) ^ upr(f1, 2) ^ upr(f1, 1))
  610. #endif
  612. #define dec_imvars
  613. #if defined(IM4_SET)
  614. #define inv_mcol(x)     four_tables(x,im_tab,vf1,rf1,0)
  615. #elif defined(IM1_SET)
  616. #define inv_mcol(x)     one_table(x,upr,im_tab,vf1,rf1,0)
  617. #else
  618. #undef  dec_imvars
  619. #define dec_imvars      aes_32t    f2, f4, f8, f9;
  620. #define inv_mcol(x) 
  621.     (f9 = (x), f2 = FFmulX(f9), f4 = FFmulX(f2), f8 = FFmulX(f4), f9 ^= f8, 
  622.     f2 ^= f4 ^ f8 ^ upr(f2 ^ f9,3) ^ upr(f4 ^ f9,2) ^ upr(f9,1))
  623. #endif
  625. #if defined(FL4_SET)
  626. #define ls_box(x,c)     four_tables(x,fl_tab,vf1,rf2,c)
  627. #elif   defined(LS4_SET)
  628. #define ls_box(x,c)     four_tables(x,ls_tab,vf1,rf2,c)
  629. #elif defined(FL1_SET)
  630. #define ls_box(x,c)     one_table(x,upr,fl_tab,vf1,rf2,c)
  631. #elif defined(LS1_SET)
  632. #define ls_box(x,c)     one_table(x,upr,ls_tab,vf1,rf2,c)
  633. #else
  634. #define ls_box(x,c)     no_table(x,s_box,vf1,rf2,c)
  635. #endif
  637. /*----------------------------------------------------------------------
  638. |       tables
  639. +---------------------------------------------------------------------*/
  640. #if defined(FIXED_TABLES) || !defined(FF_TABLES) 
  642. /*  finite field arithmetic operations */
  644. #define f2(x)   ((x<<1) ^ (((x>>7) & 1) * WPOLY))
  645. #define f4(x)   ((x<<2) ^ (((x>>6) & 1) * WPOLY) ^ (((x>>6) & 2) * WPOLY))
  646. #define f8(x)   ((x<<3) ^ (((x>>5) & 1) * WPOLY) ^ (((x>>5) & 2) * WPOLY) 
  647.                         ^ (((x>>5) & 4) * WPOLY))
  648. #define f3(x)   (f2(x) ^ x)
  649. #define f9(x)   (f8(x) ^ x)
  650. #define fb(x)   (f8(x) ^ f2(x) ^ x)
  651. #define fd(x)   (f8(x) ^ f4(x) ^ x)
  652. #define fe(x)   (f8(x) ^ f4(x) ^ f2(x))
  654. #endif
  656. #if defined(FIXED_TABLES)
  658. #define sb_data(w) 
  659.     w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), w(0xc5),
  660.     w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), w(0xab), w(0x76),
  661.     w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), w(0x59), w(0x47), w(0xf0),
  662.     w(0xad), w(0xd4), w(0xa2), w(0xaf), w(0x9c), w(0xa4), w(0x72), w(0xc0),
  663.     w(0xb7), w(0xfd), w(0x93), w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc),
  664.     w(0x34), w(0xa5), w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15),
  665.     w(0x04), w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a),
  666.     w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), w(0x75),
  667.     w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), w(0x5a), w(0xa0),
  668.     w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), w(0xe3), w(0x2f), w(0x84),
  669.     w(0x53), w(0xd1), w(0x00), w(0xed), w(0x20), w(0xfc), w(0xb1), w(0x5b),
  670.     w(0x6a), w(0xcb), w(0xbe), w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf),
  671.     w(0xd0), w(0xef), w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85),
  672.     w(0x45), w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8),
  673.     w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), w(0xf5),
  674.     w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), w(0xf3), w(0xd2),
  675.     w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), w(0x97), w(0x44), w(0x17),
  676.     w(0xc4), w(0xa7), w(0x7e), w(0x3d), w(0x64), w(0x5d), w(0x19), w(0x73),
  677.     w(0x60), w(0x81), w(0x4f), w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88),
  678.     w(0x46), w(0xee), w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb),
  679.     w(0xe0), w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c),
  680.     w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), w(0x79),
  681.     w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), w(0x4e), w(0xa9),
  682.     w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), w(0x7a), w(0xae), w(0x08),
  683.     w(0xba), w(0x78), w(0x25), w(0x2e), w(0x1c), w(0xa6), w(0xb4), w(0xc6),
  684.     w(0xe8), w(0xdd), w(0x74), w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a),
  685.     w(0x70), w(0x3e), w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e),
  686.     w(0x61), w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e),
  687.     w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), w(0x94),
  688.     w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), w(0x28), w(0xdf),
  689.     w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), w(0xe6), w(0x42), w(0x68),
  690.     w(0x41), w(0x99), w(0x2d), w(0x0f), w(0xb0), w(0x54), w(0xbb), w(0x16)
  692. #define isb_data(w) 
  693.     w(0x52), w(0x09), w(0x6a), w(0xd5), w(0x30), w(0x36), w(0xa5), w(0x38),
  694.     w(0xbf), w(0x40), w(0xa3), w(0x9e), w(0x81), w(0xf3), w(0xd7), w(0xfb),
  695.     w(0x7c), w(0xe3), w(0x39), w(0x82), w(0x9b), w(0x2f), w(0xff), w(0x87),
  696.     w(0x34), w(0x8e), w(0x43), w(0x44), w(0xc4), w(0xde), w(0xe9), w(0xcb),
  697.     w(0x54), w(0x7b), w(0x94), w(0x32), w(0xa6), w(0xc2), w(0x23), w(0x3d),
  698.     w(0xee), w(0x4c), w(0x95), w(0x0b), w(0x42), w(0xfa), w(0xc3), w(0x4e),
  699.     w(0x08), w(0x2e), w(0xa1), w(0x66), w(0x28), w(0xd9), w(0x24), w(0xb2),
  700.     w(0x76), w(0x5b), w(0xa2), w(0x49), w(0x6d), w(0x8b), w(0xd1), w(0x25),
  701.     w(0x72), w(0xf8), w(0xf6), w(0x64), w(0x86), w(0x68), w(0x98), w(0x16),
  702.     w(0xd4), w(0xa4), w(0x5c), w(0xcc), w(0x5d), w(0x65), w(0xb6), w(0x92),
  703.     w(0x6c), w(0x70), w(0x48), w(0x50), w(0xfd), w(0xed), w(0xb9), w(0xda),
  704.     w(0x5e), w(0x15), w(0x46), w(0x57), w(0xa7), w(0x8d), w(0x9d), w(0x84),
  705.     w(0x90), w(0xd8), w(0xab), w(0x00), w(0x8c), w(0xbc), w(0xd3), w(0x0a),
  706.     w(0xf7), w(0xe4), w(0x58), w(0x05), w(0xb8), w(0xb3), w(0x45), w(0x06),
  707.     w(0xd0), w(0x2c), w(0x1e), w(0x8f), w(0xca), w(0x3f), w(0x0f), w(0x02),
  708.     w(0xc1), w(0xaf), w(0xbd), w(0x03), w(0x01), w(0x13), w(0x8a), w(0x6b),
  709.     w(0x3a), w(0x91), w(0x11), w(0x41), w(0x4f), w(0x67), w(0xdc), w(0xea),
  710.     w(0x97), w(0xf2), w(0xcf), w(0xce), w(0xf0), w(0xb4), w(0xe6), w(0x73),
  711.     w(0x96), w(0xac), w(0x74), w(0x22), w(0xe7), w(0xad), w(0x35), w(0x85),
  712.     w(0xe2), w(0xf9), w(0x37), w(0xe8), w(0x1c), w(0x75), w(0xdf), w(0x6e),
  713.     w(0x47), w(0xf1), w(0x1a), w(0x71), w(0x1d), w(0x29), w(0xc5), w(0x89),
  714.     w(0x6f), w(0xb7), w(0x62), w(0x0e), w(0xaa), w(0x18), w(0xbe), w(0x1b),
  715.     w(0xfc), w(0x56), w(0x3e), w(0x4b), w(0xc6), w(0xd2), w(0x79), w(0x20),
  716.     w(0x9a), w(0xdb), w(0xc0), w(0xfe), w(0x78), w(0xcd), w(0x5a), w(0xf4),
  717.     w(0x1f), w(0xdd), w(0xa8), w(0x33), w(0x88), w(0x07), w(0xc7), w(0x31),
  718.     w(0xb1), w(0x12), w(0x10), w(0x59), w(0x27), w(0x80), w(0xec), w(0x5f),
  719.     w(0x60), w(0x51), w(0x7f), w(0xa9), w(0x19), w(0xb5), w(0x4a), w(0x0d),
  720.     w(0x2d), w(0xe5), w(0x7a), w(0x9f), w(0x93), w(0xc9), w(0x9c), w(0xef),
  721.     w(0xa0), w(0xe0), w(0x3b), w(0x4d), w(0xae), w(0x2a), w(0xf5), w(0xb0),
  722.     w(0xc8), w(0xeb), w(0xbb), w(0x3c), w(0x83), w(0x53), w(0x99), w(0x61),
  723.     w(0x17), w(0x2b), w(0x04), w(0x7e), w(0xba), w(0x77), w(0xd6), w(0x26),
  724.     w(0xe1), w(0x69), w(0x14), w(0x63), w(0x55), w(0x21), w(0x0c), w(0x7d),
  726. #define mm_data(w) 
  727.     w(0x00), w(0x01), w(0x02), w(0x03), w(0x04), w(0x05), w(0x06), w(0x07),
  728.     w(0x08), w(0x09), w(0x0a), w(0x0b), w(0x0c), w(0x0d), w(0x0e), w(0x0f),
  729.     w(0x10), w(0x11), w(0x12), w(0x13), w(0x14), w(0x15), w(0x16), w(0x17),
  730.     w(0x18), w(0x19), w(0x1a), w(0x1b), w(0x1c), w(0x1d), w(0x1e), w(0x1f),
  731.     w(0x20), w(0x21), w(0x22), w(0x23), w(0x24), w(0x25), w(0x26), w(0x27),
  732.     w(0x28), w(0x29), w(0x2a), w(0x2b), w(0x2c), w(0x2d), w(0x2e), w(0x2f),
  733.     w(0x30), w(0x31), w(0x32), w(0x33), w(0x34), w(0x35), w(0x36), w(0x37),
  734.     w(0x38), w(0x39), w(0x3a), w(0x3b), w(0x3c), w(0x3d), w(0x3e), w(0x3f),
  735.     w(0x40), w(0x41), w(0x42), w(0x43), w(0x44), w(0x45), w(0x46), w(0x47),
  736.     w(0x48), w(0x49), w(0x4a), w(0x4b), w(0x4c), w(0x4d), w(0x4e), w(0x4f),
  737.     w(0x50), w(0x51), w(0x52), w(0x53), w(0x54), w(0x55), w(0x56), w(0x57),
  738.     w(0x58), w(0x59), w(0x5a), w(0x5b), w(0x5c), w(0x5d), w(0x5e), w(0x5f),
  739.     w(0x60), w(0x61), w(0x62), w(0x63), w(0x64), w(0x65), w(0x66), w(0x67),
  740.     w(0x68), w(0x69), w(0x6a), w(0x6b), w(0x6c), w(0x6d), w(0x6e), w(0x6f),
  741.     w(0x70), w(0x71), w(0x72), w(0x73), w(0x74), w(0x75), w(0x76), w(0x77),
  742.     w(0x78), w(0x79), w(0x7a), w(0x7b), w(0x7c), w(0x7d), w(0x7e), w(0x7f),
  743.     w(0x80), w(0x81), w(0x82), w(0x83), w(0x84), w(0x85), w(0x86), w(0x87),
  744.     w(0x88), w(0x89), w(0x8a), w(0x8b), w(0x8c), w(0x8d), w(0x8e), w(0x8f),
  745.     w(0x90), w(0x91), w(0x92), w(0x93), w(0x94), w(0x95), w(0x96), w(0x97),
  746.     w(0x98), w(0x99), w(0x9a), w(0x9b), w(0x9c), w(0x9d), w(0x9e), w(0x9f),
  747.     w(0xa0), w(0xa1), w(0xa2), w(0xa3), w(0xa4), w(0xa5), w(0xa6), w(0xa7),
  748.     w(0xa8), w(0xa9), w(0xaa), w(0xab), w(0xac), w(0xad), w(0xae), w(0xaf),
  749.     w(0xb0), w(0xb1), w(0xb2), w(0xb3), w(0xb4), w(0xb5), w(0xb6), w(0xb7),
  750.     w(0xb8), w(0xb9), w(0xba), w(0xbb), w(0xbc), w(0xbd), w(0xbe), w(0xbf),
  751.     w(0xc0), w(0xc1), w(0xc2), w(0xc3), w(0xc4), w(0xc5), w(0xc6), w(0xc7),
  752.     w(0xc8), w(0xc9), w(0xca), w(0xcb), w(0xcc), w(0xcd), w(0xce), w(0xcf),
  753.     w(0xd0), w(0xd1), w(0xd2), w(0xd3), w(0xd4), w(0xd5), w(0xd6), w(0xd7),
  754.     w(0xd8), w(0xd9), w(0xda), w(0xdb), w(0xdc), w(0xdd), w(0xde), w(0xdf),
  755.     w(0xe0), w(0xe1), w(0xe2), w(0xe3), w(0xe4), w(0xe5), w(0xe6), w(0xe7),
  756.     w(0xe8), w(0xe9), w(0xea), w(0xeb), w(0xec), w(0xed), w(0xee), w(0xef),
  757.     w(0xf0), w(0xf1), w(0xf2), w(0xf3), w(0xf4), w(0xf5), w(0xf6), w(0xf7),
  758.     w(0xf8), w(0xf9), w(0xfa), w(0xfb), w(0xfc), w(0xfd), w(0xfe), w(0xff)
  760. #define h0(x)   (x)
  762. /*  These defines are used to ensure tables are generated in the 
  763.     right format depending on the internal byte order required
  764. */
  766. #define w0(p)   bytes2word(p, 0, 0, 0)
  767. #define w1(p)   bytes2word(0, p, 0, 0)
  768. #define w2(p)   bytes2word(0, 0, p, 0)
  769. #define w3(p)   bytes2word(0, 0, 0, p)
  771. /*  Number of elements required in this table for different
  772.     block and key lengths is:
  774.     Rcon Table      key length (bytes)
  775.     Length          16  20  24  28  32
  776.                 ---------------------
  777.     block     16 |  10   9   8   7   7
  778.     length    20 |  14  11  10   9   9
  779.     (bytes)   24 |  19  15  12  11  11
  780.               28 |  24  19  16  13  13
  781.               32 |  29  23  19  17  14
  783.     this table can be a table of bytes if the key schedule
  784.     code is adjusted accordingly
  785. */
  787. #define u0(p)   bytes2word(f2(p), p, p, f3(p))
  788. #define u1(p)   bytes2word(f3(p), f2(p), p, p)
  789. #define u2(p)   bytes2word(p, f3(p), f2(p), p)
  790. #define u3(p)   bytes2word(p, p, f3(p), f2(p))
  792. #define v0(p)   bytes2word(fe(p), f9(p), fd(p), fb(p))
  793. #define v1(p)   bytes2word(fb(p), fe(p), f9(p), fd(p))
  794. #define v2(p)   bytes2word(fd(p), fb(p), fe(p), f9(p))
  795. #define v3(p)   bytes2word(f9(p), fd(p), fb(p), fe(p))
  797. static const aes_32t rcon_tab[29] =
  798. {
  799.     w0(0x01), w0(0x02), w0(0x04), w0(0x08),
  800.     w0(0x10), w0(0x20), w0(0x40), w0(0x80),
  801.     w0(0x1b), w0(0x36), w0(0x6c), w0(0xd8),
  802.     w0(0xab), w0(0x4d), w0(0x9a), w0(0x2f),
  803.     w0(0x5e), w0(0xbc), w0(0x63), w0(0xc6),
  804.     w0(0x97), w0(0x35), w0(0x6a), w0(0xd4),
  805.     w0(0xb3), w0(0x7d), w0(0xfa), w0(0xef),
  806.     w0(0xc5)
  807. };
  809. #ifdef  SBX_SET
  810. static const aes_08t s_box[256] = { sb_data(h0) };
  811. #endif
  812. #ifdef  ISB_SET
  813. static const aes_08t inv_s_box[256] = { isb_data(h0) };
  814. #endif
  816. #ifdef  FT1_SET
  817. static const aes_32t ft_tab[256] = { sb_data(u0) };
  818. #endif
  819. #ifdef  FT4_SET
  820. static const aes_32t ft_tab[4][256] = 
  821.     { {  sb_data(u0) }, {  sb_data(u1) }, {  sb_data(u2) }, {  sb_data(u3) } };
  822. #endif
  824. #ifdef  FL1_SET
  825. static const aes_32t fl_tab[256] = { sb_data(w0) };
  826. #endif
  827. #ifdef  FL4_SET
  828. static const aes_32t fl_tab[4][256] = 
  829.     { {  sb_data(w0) }, {  sb_data(w1) }, {  sb_data(w2) }, {  sb_data(w3) } };
  830. #endif
  832. #ifdef  IT1_SET
  833. static const aes_32t it_tab[256] = { isb_data(v0) };
  834. #endif
  835. #ifdef  IT4_SET
  836. static const aes_32t it_tab[4][256] =
  837.     { { isb_data(v0) }, { isb_data(v1) }, { isb_data(v2) }, { isb_data(v3) } };
  838. #endif
  840. #ifdef  IL1_SET
  841. static const aes_32t il_tab[256] = { isb_data(w0) };
  842. #endif
  843. #ifdef  IL4_SET
  844. static const aes_32t il_tab[4][256] = 
  845.     { { isb_data(w0) }, { isb_data(w1) }, { isb_data(w2) }, { isb_data(w3) } };
  846. #endif
  848. #ifdef  LS1_SET
  849. static const aes_32t ls_tab[256] = { sb_data(w0) };
  850. #endif
  851. #ifdef  LS4_SET
  852. static const aes_32t ls_tab[4][256] =
  853.     { {  sb_data(w0) }, {  sb_data(w1) }, {  sb_data(w2) }, {  sb_data(w3) } };
  854. #endif
  856. #ifdef  IM1_SET
  857. static const aes_32t im_tab[256] = { mm_data(v0) };
  858. #endif
  859. #ifdef  IM4_SET
  860. static const aes_32t im_tab[4][256] = 
  861.     { {  mm_data(v0) }, {  mm_data(v1) }, {  mm_data(v2) }, {  mm_data(v3) } };
  862. #endif
  864. #else   /* dynamic table generation */
  866. aes_08t tab_init = 0;
  868. #define const
  870. static aes_32t  rcon_tab[RC_LENGTH];
  872. #ifdef  SBX_SET
  873. aes_08t s_box[256];
  874. #endif
  875. #ifdef  ISB_SET
  876. aes_08t inv_s_box[256];
  877. #endif
  879. #ifdef  FT1_SET
  880. aes_32t ft_tab[256];
  881. #endif
  882. #ifdef  FT4_SET
  883. aes_32t ft_tab[4][256];
  884. #endif
  886. #ifdef  FL1_SET
  887. aes_32t fl_tab[256];
  888. #endif
  889. #ifdef  FL4_SET
  890. aes_32t fl_tab[4][256];
  891. #endif
  893. #ifdef  IT1_SET
  894. aes_32t it_tab[256];
  895. #endif
  896. #ifdef  IT4_SET
  897. aes_32t it_tab[4][256];
  898. #endif
  900. #ifdef  IL1_SET
  901. aes_32t il_tab[256];
  902. #endif
  903. #ifdef  IL4_SET
  904. aes_32t il_tab[4][256];
  905. #endif
  907. #ifdef  LS1_SET
  908. aes_32t ls_tab[256];
  909. #endif
  910. #ifdef  LS4_SET
  911. aes_32t ls_tab[4][256];
  912. #endif
  914. #ifdef  IM1_SET
  915. aes_32t im_tab[256];
  916. #endif
  917. #ifdef  IM4_SET
  918. aes_32t im_tab[4][256];
  919. #endif
  921. #if !defined(FF_TABLES)
  923. /*  Generate the tables for the dynamic table option
  925.     It will generally be sensible to use tables to compute finite 
  926.     field multiplies and inverses but where memory is scarse this 
  927.     code might sometimes be better. But it only has effect during
  928.     initialisation so its pretty unimportant in overall terms.
  929. */
  931. /*  return 2 ^ (n - 1) where n is the bit number of the highest bit
  932.     set in x with x in the range 1 < x < 0x00000200.   This form is
  933.     used so that locals within fi can be bytes rather than words
  934. */
  936. static aes_08t hibit(const aes_32t x)
  937. {   aes_08t r = (aes_08t)((x >> 1) | (x >> 2));
  938.     
  939.     r |= (r >> 2);
  940.     r |= (r >> 4);
  941.     return (r + 1) >> 1;
  942. }
  944. /* return the inverse of the finite field element x */
  946. static aes_08t fi(const aes_08t x)
  947. {   aes_08t p1 = x, p2 = BPOLY, n1 = hibit(x), n2 = 0x80, v1 = 1, v2 = 0;
  949.     if(x < 2) return x;
  951.     for(;;)
  952.     {
  953.         if(!n1) return v1;
  955.         while(n2 >= n1)
  956.         {   
  957.             n2 /= n1; p2 ^= p1 * n2; v2 ^= v1 * n2; n2 = hibit(p2);
  958.         }
  959.         
  960.         if(!n2) return v2;
  962.         while(n1 >= n2)
  963.         {   
  964.             n1 /= n2; p1 ^= p2 * n1; v1 ^= v2 * n1; n1 = hibit(p1);
  965.         }
  966.     }
  967. }
  969. #else
  971. /* define the finite field multiplies required for Rijndael */
  973. #define f2(x) ((x) ? pow[log[x] + 0x19] : 0)
  974. #define f3(x) ((x) ? pow[log[x] + 0x01] : 0)
  975. #define f9(x) ((x) ? pow[log[x] + 0xc7] : 0)
  976. #define fb(x) ((x) ? pow[log[x] + 0x68] : 0)
  977. #define fd(x) ((x) ? pow[log[x] + 0xee] : 0)
  978. #define fe(x) ((x) ? pow[log[x] + 0xdf] : 0)
  979. #define fi(x) ((x) ?   pow[255 - log[x]]: 0)
  981. #endif
  983. /* The forward and inverse affine transformations used in the S-box */
  985. #define fwd_affine(x) 
  986.     (w = (aes_32t)x, w ^= (w<<1)^(w<<2)^(w<<3)^(w<<4), 0x63^(aes_08t)(w^(w>>8)))
  988. #define inv_affine(x) 
  989.     (w = (aes_32t)x, w = (w<<1)^(w<<3)^(w<<6), 0x05^(aes_08t)(w^(w>>8)))
  991. void gen_tabs(void)
  992. {   aes_32t  i, w;
  994. #if defined(FF_TABLES)
  996.     aes_08t  pow[512], log[256];
  998.     /*  log and power tables for GF(2^8) finite field with
  999.         WPOLY as modular polynomial - the simplest primitive
  1000.         root is 0x03, used here to generate the tables
  1001.     */
  1003.     i = 0; w = 1; 
  1004.     do
  1005.     {   
  1006.         pow[i] = (aes_08t)w;
  1007.         pow[i + 255] = (aes_08t)w;
  1008.         log[w] = (aes_08t)i++;
  1009.         w ^=  (w << 1) ^ (w & 0x80 ? WPOLY : 0);
  1010.     }
  1011.     while (w != 1);
  1013. #endif
  1015.     for(i = 0, w = 1; i < RC_LENGTH; ++i)
  1016.     {
  1017.         rcon_tab[i] = bytes2word(w, 0, 0, 0);
  1018.         w = f2(w);
  1019.     }
  1021.     for(i = 0; i < 256; ++i)
  1022.     {   aes_08t    b;
  1024.         b = fwd_affine(fi((aes_08t)i));
  1025.         w = bytes2word(f2(b), b, b, f3(b));
  1027. #ifdef  SBX_SET
  1028.         s_box[i] = b;
  1029. #endif
  1031. #ifdef  FT1_SET                 /* tables for a normal encryption round */
  1032.         ft_tab[i] = w;
  1033. #endif
  1034. #ifdef  FT4_SET
  1035.         ft_tab[0][i] = w;
  1036.         ft_tab[1][i] = upr(w,1);
  1037.         ft_tab[2][i] = upr(w,2);
  1038.         ft_tab[3][i] = upr(w,3);
  1039. #endif
  1040.         w = bytes2word(b, 0, 0, 0);
  1042. #ifdef  FL1_SET                 /* tables for last encryption round (may also   */
  1043.         fl_tab[i] = w;          /* be used in the key schedule)                 */
  1044. #endif
  1045. #ifdef  FL4_SET
  1046.         fl_tab[0][i] = w;
  1047.         fl_tab[1][i] = upr(w,1);
  1048.         fl_tab[2][i] = upr(w,2);
  1049.         fl_tab[3][i] = upr(w,3);
  1050. #endif
  1052. #ifdef  LS1_SET                 /* table for key schedule if fl_tab above is    */
  1053.         ls_tab[i] = w;          /* not of the required form                     */
  1054. #endif
  1055. #ifdef  LS4_SET
  1056.         ls_tab[0][i] = w;
  1057.         ls_tab[1][i] = upr(w,1);
  1058.         ls_tab[2][i] = upr(w,2);
  1059.         ls_tab[3][i] = upr(w,3);
  1060. #endif
  1062.         b = fi(inv_affine((aes_08t)i));
  1063.         w = bytes2word(fe(b), f9(b), fd(b), fb(b));
  1065. #ifdef  IM1_SET                 /* tables for the inverse mix column operation  */
  1066.         im_tab[b] = w;
  1067. #endif
  1068. #ifdef  IM4_SET
  1069.         im_tab[0][b] = w;
  1070.         im_tab[1][b] = upr(w,1);
  1071.         im_tab[2][b] = upr(w,2);
  1072.         im_tab[3][b] = upr(w,3);
  1073. #endif
  1075. #ifdef  ISB_SET
  1076.         inv_s_box[i] = b;
  1077. #endif
  1078. #ifdef  IT1_SET                 /* tables for a normal decryption round */
  1079.         it_tab[i] = w;
  1080. #endif
  1081. #ifdef  IT4_SET
  1082.         it_tab[0][i] = w;
  1083.         it_tab[1][i] = upr(w,1);
  1084.         it_tab[2][i] = upr(w,2);
  1085.         it_tab[3][i] = upr(w,3);
  1086. #endif
  1087.         w = bytes2word(b, 0, 0, 0);
  1088. #ifdef  IL1_SET                 /* tables for last decryption round */
  1089.         il_tab[i] = w;
  1090. #endif
  1091. #ifdef  IL4_SET
  1092.         il_tab[0][i] = w;
  1093.         il_tab[1][i] = upr(w,1);
  1094.         il_tab[2][i] = upr(w,2);
  1095.         il_tab[3][i] = upr(w,3);
  1096. #endif
  1097.     }
  1099.     tab_init = 1;
  1100. }
  1102. #endif
  1104. /*----------------------------------------------------------------------
  1105. |       key schedule
  1106. +---------------------------------------------------------------------*/
  1107. #if !defined(BLOCK_SIZE)
  1109. static aes_rval aes_blk_len(unsigned int blen, aes_ctx cx[1])
  1110. {
  1111. #if !defined(FIXED_TABLES)
  1112.     if(!tab_init) gen_tabs();
  1113. #endif
  1115.     if((blen & 7) || blen < 16 || blen > 32) 
  1116.     {     
  1117.         cx->n_blk = 0; return aes_bad;
  1118.     }
  1120.     cx->n_blk = blen;
  1121.     return aes_good;
  1122. }
  1124. #endif
  1126. /* Initialise the key schedule from the user supplied key. The key
  1127.    length is now specified in bytes - 16, 24 or 32 as appropriate.
  1128.    This corresponds to bit lengths of 128, 192 and 256 bits, and
  1129.    to Nk values of 4, 6 and 8 respectively.
  1131.    The following macros implement a single cycle in the key 
  1132.    schedule generation process. The number of cycles needed 
  1133.    for each cx->n_col and nk value is:
  1134.  
  1135.     nk =             4  5  6  7  8
  1136.     ------------------------------
  1137.     cx->n_col = 4   10  9  8  7  7
  1138.     cx->n_col = 5   14 11 10  9  9
  1139.     cx->n_col = 6   19 15 12 11 11
  1140.     cx->n_col = 7   21 19 16 13 14
  1141.     cx->n_col = 8   29 23 19 17 14
  1142. */
  1144. #define ke4(k,i) 
  1145. {   k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ rcon_tab[i]; k[4*(i)+5] = ss[1] ^= ss[0]; 
  1146.     k[4*(i)+6] = ss[2] ^= ss[1]; k[4*(i)+7] = ss[3] ^= ss[2]; 
  1147. }
  1148. #define kel4(k,i) 
  1149. {   k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ rcon_tab[i]; k[4*(i)+5] = ss[1] ^= ss[0]; 
  1150.     k[4*(i)+6] = ss[2] ^= ss[1]; k[4*(i)+7] = ss[3] ^= ss[2]; 
  1151. }
  1153. #define ke6(k,i) 
  1154. {   k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ rcon_tab[i]; k[6*(i)+ 7] = ss[1] ^= ss[0]; 
  1155.     k[6*(i)+ 8] = ss[2] ^= ss[1]; k[6*(i)+ 9] = ss[3] ^= ss[2]; 
  1156.     k[6*(i)+10] = ss[4] ^= ss[3]; k[6*(i)+11] = ss[5] ^= ss[4]; 
  1157. }
  1158. #define kel6(k,i) 
  1159. {   k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ rcon_tab[i]; k[6*(i)+ 7] = ss[1] ^= ss[0]; 
  1160.     k[6*(i)+ 8] = ss[2] ^= ss[1]; k[6*(i)+ 9] = ss[3] ^= ss[2]; 
  1161. }
  1163. #define ke8(k,i) 
  1164. {   k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ rcon_tab[i]; k[8*(i)+ 9] = ss[1] ^= ss[0]; 
  1165.     k[8*(i)+10] = ss[2] ^= ss[1]; k[8*(i)+11] = ss[3] ^= ss[2]; 
  1166.     k[8*(i)+12] = ss[4] ^= ls_box(ss[3],0); k[8*(i)+13] = ss[5] ^= ss[4]; 
  1167.     k[8*(i)+14] = ss[6] ^= ss[5]; k[8*(i)+15] = ss[7] ^= ss[6]; 
  1168. }
  1169. #define kel8(k,i) 
  1170. {   k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ rcon_tab[i]; k[8*(i)+ 9] = ss[1] ^= ss[0]; 
  1171.     k[8*(i)+10] = ss[2] ^= ss[1]; k[8*(i)+11] = ss[3] ^= ss[2]; 
  1172. }
  1174. #if defined(ENCRYPTION_KEY_SCHEDULE)
  1176. static aes_rval aes_enc_key(const unsigned char in_key[], unsigned int klen, aes_ctx cx[1])
  1177. {   aes_32t    ss[8]; 
  1179. #if !defined(FIXED_TABLES)
  1180.     if(!tab_init) gen_tabs();
  1181. #endif
  1183. #if !defined(BLOCK_SIZE)
  1184.     if(!cx->n_blk) cx->n_blk = 16;
  1185. #else
  1186.     cx->n_blk = BLOCK_SIZE;
  1187. #endif
  1188.     
  1189.     cx->n_blk = (cx->n_blk & ~3) | 1;
  1191.     cx->k_sch[0] = ss[0] = word_in(in_key     );
  1192.     cx->k_sch[1] = ss[1] = word_in(in_key +  4);
  1193.     cx->k_sch[2] = ss[2] = word_in(in_key +  8);
  1194.     cx->k_sch[3] = ss[3] = word_in(in_key + 12);
  1196. #if (BLOCK_SIZE == 16) && (ENC_UNROLL != NONE)
  1198.     switch(klen)
  1199.     {
  1200.     case 16:    ke4(cx->k_sch, 0); ke4(cx->k_sch, 1); 
  1201.                 ke4(cx->k_sch, 2); ke4(cx->k_sch, 3);
  1202.                 ke4(cx->k_sch, 4); ke4(cx->k_sch, 5); 
  1203.                 ke4(cx->k_sch, 6); ke4(cx->k_sch, 7);
  1204.                 ke4(cx->k_sch, 8); kel4(cx->k_sch, 9); 
  1205.                 cx->n_rnd = 10; break;
  1206.     case 24:    cx->k_sch[4] = ss[4] = word_in(in_key + 16);
  1207.                 cx->k_sch[5] = ss[5] = word_in(in_key + 20);
  1208.                 ke6(cx->k_sch, 0); ke6(cx->k_sch, 1); 
  1209.                 ke6(cx->k_sch, 2); ke6(cx->k_sch, 3);
  1210.                 ke6(cx->k_sch, 4); ke6(cx->k_sch, 5); 
  1211.                 ke6(cx->k_sch, 6); kel6(cx->k_sch, 7); 
  1212.                 cx->n_rnd = 12; break;
  1213.     case 32:    cx->k_sch[4] = ss[4] = word_in(in_key + 16);
  1214.                 cx->k_sch[5] = ss[5] = word_in(in_key + 20);
  1215.                 cx->k_sch[6] = ss[6] = word_in(in_key + 24);
  1216.                 cx->k_sch[7] = ss[7] = word_in(in_key + 28);
  1217.                 ke8(cx->k_sch, 0); ke8(cx->k_sch, 1); 
  1218.                 ke8(cx->k_sch, 2); ke8(cx->k_sch, 3);
  1219.                 ke8(cx->k_sch, 4); ke8(cx->k_sch, 5); 
  1220.                 kel8(cx->k_sch, 6); 
  1221.                 cx->n_rnd = 14; break;
  1222.     default:    cx->n_rnd = 0; return aes_bad; 
  1223.     }
  1224. #else
  1225.     {   aes_32t i, l;
  1226.         cx->n_rnd = ((klen >> 2) > nc ? (klen >> 2) : nc) + 6;
  1227.         l = (nc * cx->n_rnd + nc - 1) / (klen >> 2);
  1229.         switch(klen)
  1230.         {
  1231.         case 16:    for(i = 0; i < l; ++i)
  1232.                         ke4(cx->k_sch, i);
  1233.                     break;
  1234.         case 24:    cx->k_sch[4] = ss[4] = word_in(in_key + 16);
  1235.                     cx->k_sch[5] = ss[5] = word_in(in_key + 20);
  1236.                     for(i = 0; i < l; ++i)
  1237.                         ke6(cx->k_sch, i);
  1238.                     break;
  1239.         case 32:    cx->k_sch[4] = ss[4] = word_in(in_key + 16);
  1240.                     cx->k_sch[5] = ss[5] = word_in(in_key + 20);
  1241.                     cx->k_sch[6] = ss[6] = word_in(in_key + 24);
  1242.                     cx->k_sch[7] = ss[7] = word_in(in_key + 28);
  1243.                     for(i = 0; i < l; ++i)
  1244.                         ke8(cx->k_sch,  i);
  1245.                     break;
  1246.         default:    cx->n_rnd = 0; return aes_bad; 
  1247.         }
  1248.     }
  1249. #endif
  1251.     return aes_good;
  1252. }
  1254. #endif
  1256. #if defined(DECRYPTION_KEY_SCHEDULE)
  1258. #if (DEC_ROUND != NO_TABLES)
  1259. #define d_vars  dec_imvars
  1260. #define ff(x)   inv_mcol(x)
  1261. #else
  1262. #define ff(x)   (x)
  1263. #define d_vars
  1264. #endif
  1266. #if 1
  1267. #define kdf4(k,i) 
  1268. {   ss[0] = ss[0] ^ ss[2] ^ ss[1] ^ ss[3]; ss[1] = ss[1] ^ ss[3]; ss[2] = ss[2] ^ ss[3]; ss[3] = ss[3]; 
  1269.     ss[4] = ls_box(ss[(i+3) % 4], 3) ^ rcon_tab[i]; ss[i % 4] ^= ss[4]; 
  1270.     ss[4] ^= k[4*(i)];   k[4*(i)+4] = ff(ss[4]); ss[4] ^= k[4*(i)+1]; k[4*(i)+5] = ff(ss[4]); 
  1271.     ss[4] ^= k[4*(i)+2]; k[4*(i)+6] = ff(ss[4]); ss[4] ^= k[4*(i)+3]; k[4*(i)+7] = ff(ss[4]); 
  1272. }
  1273. #define kd4(k,i) 
  1274. {   ss[4] = ls_box(ss[(i+3) % 4], 3) ^ rcon_tab[i]; ss[i % 4] ^= ss[4]; ss[4] = ff(ss[4]); 
  1275.     k[4*(i)+4] = ss[4] ^= k[4*(i)]; k[4*(i)+5] = ss[4] ^= k[4*(i)+1]; 
  1276.     k[4*(i)+6] = ss[4] ^= k[4*(i)+2]; k[4*(i)+7] = ss[4] ^= k[4*(i)+3]; 
  1277. }
  1278. #define kdl4(k,i) 
  1279. {   ss[4] = ls_box(ss[(i+3) % 4], 3) ^ rcon_tab[i]; ss[i % 4] ^= ss[4]; 
  1280.     k[4*(i)+4] = (ss[0] ^= ss[1]) ^ ss[2] ^ ss[3]; k[4*(i)+5] = ss[1] ^ ss[3]; 
  1281.     k[4*(i)+6] = ss[0]; k[4*(i)+7] = ss[1]; 
  1282. }
  1283. #else
  1284. #define kdf4(k,i) 
  1285. {   ss[0] ^= ls_box(ss[3],3) ^ rcon_tab[i]; k[4*(i)+ 4] = ff(ss[0]); ss[1] ^= ss[0]; k[4*(i)+ 5] = ff(ss[1]); 
  1286.     ss[2] ^= ss[1]; k[4*(i)+ 6] = ff(ss[2]); ss[3] ^= ss[2]; k[4*(i)+ 7] = ff(ss[3]); 
  1287. }
  1288. #define kd4(k,i) 
  1289. {   ss[4] = ls_box(ss[3],3) ^ rcon_tab[i]; 
  1290.     ss[0] ^= ss[4]; ss[4] = ff(ss[4]); k[4*(i)+ 4] = ss[4] ^= k[4*(i)]; 
  1291.     ss[1] ^= ss[0]; k[4*(i)+ 5] = ss[4] ^= k[4*(i)+ 1]; 
  1292.     ss[2] ^= ss[1]; k[4*(i)+ 6] = ss[4] ^= k[4*(i)+ 2]; 
  1293.     ss[3] ^= ss[2]; k[4*(i)+ 7] = ss[4] ^= k[4*(i)+ 3]; 
  1294. }
  1295. #define kdl4(k,i) 
  1296. {   ss[0] ^= ls_box(ss[3],3) ^ rcon_tab[i]; k[4*(i)+ 4] = ss[0]; ss[1] ^= ss[0]; k[4*(i)+ 5] = ss[1]; 
  1297.     ss[2] ^= ss[1]; k[4*(i)+ 6] = ss[2]; ss[3] ^= ss[2]; k[4*(i)+ 7] = ss[3]; 
  1298. }
  1299. #endif
  1301. #define kdf6(k,i) 
  1302. {   ss[0] ^= ls_box(ss[5],3) ^ rcon_tab[i]; k[6*(i)+ 6] = ff(ss[0]); ss[1] ^= ss[0]; k[6*(i)+ 7] = ff(ss[1]); 
  1303.     ss[2] ^= ss[1]; k[6*(i)+ 8] = ff(ss[2]); ss[3] ^= ss[2]; k[6*(i)+ 9] = ff(ss[3]); 
  1304.     ss[4] ^= ss[3]; k[6*(i)+10] = ff(ss[4]); ss[5] ^= ss[4]; k[6*(i)+11] = ff(ss[5]); 
  1305. }
  1306. #define kd6(k,i) 
  1307. {   ss[6] = ls_box(ss[5],3) ^ rcon_tab[i]; 
  1308.     ss[0] ^= ss[6]; ss[6] = ff(ss[6]); k[6*(i)+ 6] = ss[6] ^= k[6*(i)]; 
  1309.     ss[1] ^= ss[0]; k[6*(i)+ 7] = ss[6] ^= k[6*(i)+ 1]; 
  1310.     ss[2] ^= ss[1]; k[6*(i)+ 8] = ss[6] ^= k[6*(i)+ 2]; 
  1311.     ss[3] ^= ss[2]; k[6*(i)+ 9] = ss[6] ^= k[6*(i)+ 3]; 
  1312.     ss[4] ^= ss[3]; k[6*(i)+10] = ss[6] ^= k[6*(i)+ 4]; 
  1313.     ss[5] ^= ss[4]; k[6*(i)+11] = ss[6] ^= k[6*(i)+ 5]; 
  1314. }
  1315. #define kdl6(k,i) 
  1316. {   ss[0] ^= ls_box(ss[5],3) ^ rcon_tab[i]; k[6*(i)+ 6] = ss[0]; ss[1] ^= ss[0]; k[6*(i)+ 7] = ss[1]; 
  1317.     ss[2] ^= ss[1]; k[6*(i)+ 8] = ss[2]; ss[3] ^= ss[2]; k[6*(i)+ 9] = ss[3]; 
  1318. }
  1320. #define kdf8(k,i) 
  1321. {   ss[0] ^= ls_box(ss[7],3) ^ rcon_tab[i]; k[8*(i)+ 8] = ff(ss[0]); ss[1] ^= ss[0]; k[8*(i)+ 9] = ff(ss[1]); 
  1322.     ss[2] ^= ss[1]; k[8*(i)+10] = ff(ss[2]); ss[3] ^= ss[2]; k[8*(i)+11] = ff(ss[3]); 
  1323.     ss[4] ^= ls_box(ss[3],0); k[8*(i)+12] = ff(ss[4]); ss[5] ^= ss[4]; k[8*(i)+13] = ff(ss[5]); 
  1324.     ss[6] ^= ss[5]; k[8*(i)+14] = ff(ss[6]); ss[7] ^= ss[6]; k[8*(i)+15] = ff(ss[7]); 
  1325. }
  1326. #define kd8(k,i) 
  1327. {   aes_32t g = ls_box(ss[7],3) ^ rcon_tab[i]; 
  1328.     ss[0] ^= g; g = ff(g); k[8*(i)+ 8] = g ^= k[8*(i)]; 
  1329.     ss[1] ^= ss[0]; k[8*(i)+ 9] = g ^= k[8*(i)+ 1]; 
  1330.     ss[2] ^= ss[1]; k[8*(i)+10] = g ^= k[8*(i)+ 2]; 
  1331.     ss[3] ^= ss[2]; k[8*(i)+11] = g ^= k[8*(i)+ 3]; 
  1332.     g = ls_box(ss[3],0); 
  1333.     ss[4] ^= g; g = ff(g); k[8*(i)+12] = g ^= k[8*(i)+ 4]; 
  1334.     ss[5] ^= ss[4]; k[8*(i)+13] = g ^= k[8*(i)+ 5]; 
  1335.     ss[6] ^= ss[5]; k[8*(i)+14] = g ^= k[8*(i)+ 6]; 
  1336.     ss[7] ^= ss[6]; k[8*(i)+15] = g ^= k[8*(i)+ 7]; 
  1337. }
  1338. #define kdl8(k,i) 
  1339. {   ss[0] ^= ls_box(ss[7],3) ^ rcon_tab[i]; k[8*(i)+ 8] = ss[0]; ss[1] ^= ss[0]; k[8*(i)+ 9] = ss[1]; 
  1340.     ss[2] ^= ss[1]; k[8*(i)+10] = ss[2]; ss[3] ^= ss[2]; k[8*(i)+11] = ss[3]; 
  1341. }
  1343. static aes_rval aes_dec_key(const unsigned char in_key[], unsigned int klen, aes_ctx cx[1])
  1344. {   aes_32t    ss[8]; 
  1345.     d_vars
  1347. #if !defined(FIXED_TABLES)
  1348.     if(!tab_init) gen_tabs();
  1349. #endif
  1351. #if !defined(BLOCK_SIZE)
  1352.     if(!cx->n_blk) cx->n_blk = 16;
  1353. #else
  1354.     cx->n_blk = BLOCK_SIZE;
  1355. #endif
  1357.     cx->n_blk = (cx->n_blk & ~3) | 2;
  1359.     cx->k_sch[0] = ss[0] = word_in(in_key     );
  1360.     cx->k_sch[1] = ss[1] = word_in(in_key +  4);
  1361.     cx->k_sch[2] = ss[2] = word_in(in_key +  8);
  1362.     cx->k_sch[3] = ss[3] = word_in(in_key + 12);
  1364. #if (BLOCK_SIZE == 16) && (DEC_UNROLL != NONE)
  1366.     switch(klen)
  1367.     {
  1368.     case 16:    kdf4(cx->k_sch, 0); kd4(cx->k_sch, 1); 
  1369.                 kd4(cx->k_sch, 2); kd4(cx->k_sch, 3);
  1370.                 kd4(cx->k_sch, 4); kd4(cx->k_sch, 5); 
  1371.                 kd4(cx->k_sch, 6); kd4(cx->k_sch, 7);
  1372.                 kd4(cx->k_sch, 8); kdl4(cx->k_sch, 9); 
  1373.                 cx->n_rnd = 10; break;
  1374.     case 24:    cx->k_sch[4] = ff(ss[4] = word_in(in_key + 16));
  1375.                 cx->k_sch[5] = ff(ss[5] = word_in(in_key + 20));
  1376.                 kdf6(cx->k_sch, 0); kd6(cx->k_sch, 1); 
  1377.                 kd6(cx->k_sch, 2); kd6(cx->k_sch, 3);
  1378.                 kd6(cx->k_sch, 4); kd6(cx->k_sch, 5); 
  1379.                 kd6(cx->k_sch, 6); kdl6(cx->k_sch, 7); 
  1380.                 cx->n_rnd = 12; break;
  1381.     case 32:    cx->k_sch[4] = ff(ss[4] = word_in(in_key + 16));
  1382.                 cx->k_sch[5] = ff(ss[5] = word_in(in_key + 20));
  1383.                 cx->k_sch[6] = ff(ss[6] = word_in(in_key + 24));
  1384.                 cx->k_sch[7] = ff(ss[7] = word_in(in_key + 28));
  1385.                 kdf8(cx->k_sch, 0); kd8(cx->k_sch, 1); 
  1386.                 kd8(cx->k_sch, 2); kd8(cx->k_sch, 3);
  1387.                 kd8(cx->k_sch, 4); kd8(cx->k_sch, 5); 
  1388.                 kdl8(cx->k_sch, 6); 
  1389.                 cx->n_rnd = 14; break;
  1390.     default:    cx->n_rnd = 0; return aes_bad; 
  1391.     }
  1392. #else
  1393.     {   aes_32t i, l;
  1394.         cx->n_rnd = ((klen >> 2) > nc ? (klen >> 2) : nc) + 6;
  1395.         l = (nc * cx->n_rnd + nc - 1) / (klen >> 2);
  1397.         switch(klen)
  1398.         {
  1399.         case 16: 
  1400.                     for(i = 0; i < l; ++i)
  1401.                         ke4(cx->k_sch, i);
  1402.                     break;
  1403.         case 24:    cx->k_sch[4] = ss[4] = word_in(in_key + 16);
  1404.                     cx->k_sch[5] = ss[5] = word_in(in_key + 20);
  1405.                     for(i = 0; i < l; ++i)
  1406.                         ke6(cx->k_sch, i);
  1407.                     break;
  1408.         case 32:    cx->k_sch[4] = ss[4] = word_in(in_key + 16);
  1409.                     cx->k_sch[5] = ss[5] = word_in(in_key + 20);
  1410.                     cx->k_sch[6] = ss[6] = word_in(in_key + 24);
  1411.                     cx->k_sch[7] = ss[7] = word_in(in_key + 28);
  1412.                     for(i = 0; i < l; ++i)
  1413.                         ke8(cx->k_sch,  i);
  1414.                     break;
  1415.         default:    cx->n_rnd = 0; return aes_bad; 
  1416.         }
  1417. #if (DEC_ROUND != NO_TABLES)
  1418.         for(i = nc; i < nc * cx->n_rnd; ++i)
  1419.             cx->k_sch[i] = inv_mcol(cx->k_sch[i]);
  1420. #endif
  1421.     }
  1422. #endif
  1424.     return aes_good;
  1425. }
  1427. #endif
  1429. /*----------------------------------------------------------------------
  1430. |       cipher
  1431. +---------------------------------------------------------------------*/
  1432. #define unused  77  /* Sunset Strip */
  1434. #define si(y,x,k,c) s(y,c) = word_in(x + 4 * c) ^ k[c]
  1435. #define so(y,x,c)   word_out(y + 4 * c, s(x,c))
  1437. #if BLOCK_SIZE == 16
  1439. #if defined(ARRAYS)
  1440. #define locals(y,x)     x[4],y[4]
  1441. #else
  1442. #define locals(y,x)     x##0,x##1,x##2,x##3,y##0,y##1,y##2,y##3
  1443.  /* 
  1444.    the following defines prevent the compiler requiring the declaration
  1445.    of generated but unused variables in the fwd_var and inv_var macros
  1446.  */
  1447. #define b04 unused
  1448. #define b05 unused
  1449. #define b06 unused
  1450. #define b07 unused
  1451. #define b14 unused
  1452. #define b15 unused
  1453. #define b16 unused
  1454. #define b17 unused
  1455. #endif
  1456. #define l_copy(y, x)    s(y,0) = s(x,0); s(y,1) = s(x,1); 
  1457.                         s(y,2) = s(x,2); s(y,3) = s(x,3);
  1458. #define state_in(y,x,k) si(y,x,k,0); si(y,x,k,1); si(y,x,k,2); si(y,x,k,3)
  1459. #define state_out(y,x)  so(y,x,0); so(y,x,1); so(y,x,2); so(y,x,3)
  1460. #define round(rm,y,x,k) rm(y,x,k,0); rm(y,x,k,1); rm(y,x,k,2); rm(y,x,k,3)
  1462. #elif BLOCK_SIZE == 24
  1464. #if defined(ARRAYS)
  1465. #define locals(y,x)     x[6],y[6]
  1466. #else
  1467. #define locals(y,x)     x##0,x##1,x##2,x##3,x##4,x##5, 
  1468.                         y##0,y##1,y##2,y##3,y##4,y##5
  1469. #define b06 unused
  1470. #define b07 unused
  1471. #define b16 unused
  1472. #define b17 unused
  1473. #endif
  1474. #define l_copy(y, x)    s(y,0) = s(x,0); s(y,1) = s(x,1); 
  1475.                         s(y,2) = s(x,2); s(y,3) = s(x,3); 
  1476.                         s(y,4) = s(x,4); s(y,5) = s(x,5);
  1477. #define state_in(y,x,k) si(y,x,k,0); si(y,x,k,1); si(y,x,k,2); 
  1478.                         si(y,x,k,3); si(y,x,k,4); si(y,x,k,5)
  1479. #define state_out(y,x)  so(y,x,0); so(y,x,1); so(y,x,2); 
  1480.                         so(y,x,3); so(y,x,4); so(y,x,5)
  1481. #define round(rm,y,x,k) rm(y,x,k,0); rm(y,x,k,1); rm(y,x,k,2); 
  1482.                         rm(y,x,k,3); rm(y,x,k,4); rm(y,x,k,5)
  1483. #else
  1485. #if defined(ARRAYS)
  1486. #define locals(y,x)     x[8],y[8]
  1487. #else
  1488. #define locals(y,x)     x##0,x##1,x##2,x##3,x##4,x##5,x##6,x##7, 
  1489.                         y##0,y##1,y##2,y##3,y##4,y##5,y##6,y##7
  1490. #endif
  1491. #define l_copy(y, x)    s(y,0) = s(x,0); s(y,1) = s(x,1); 
  1492.                         s(y,2) = s(x,2); s(y,3) = s(x,3); 
  1493.                         s(y,4) = s(x,4); s(y,5) = s(x,5); 
  1494.                         s(y,6) = s(x,6); s(y,7) = s(x,7);
  1496. #if BLOCK_SIZE == 32
  1498. #define state_in(y,x,k) si(y,x,k,0); si(y,x,k,1); si(y,x,k,2); si(y,x,k,3); 
  1499.                         si(y,x,k,4); si(y,x,k,5); si(y,x,k,6); si(y,x,k,7)
  1500. #define state_out(y,x)  so(y,x,0); so(y,x,1); so(y,x,2); so(y,x,3); 
  1501.                         so(y,x,4); so(y,x,5); so(y,x,6); so(y,x,7)
  1502. #define round(rm,y,x,k) rm(y,x,k,0); rm(y,x,k,1); rm(y,x,k,2); rm(y,x,k,3); 
  1503.                         rm(y,x,k,4); rm(y,x,k,5); rm(y,x,k,6); rm(y,x,k,7)
  1504. #else
  1506. #define state_in(y,x,k) 
  1507. switch(nc) 
  1508. {   case 8: si(y,x,k,7); si(y,x,k,6); 
  1509.     case 6: si(y,x,k,5); si(y,x,k,4); 
  1510.     case 4: si(y,x,k,3); si(y,x,k,2); 
  1511.             si(y,x,k,1); si(y,x,k,0); 
  1512. }
  1514. #define state_out(y,x) 
  1515. switch(nc) 
  1516. {   case 8: so(y,x,7); so(y,x,6); 
  1517.     case 6: so(y,x,5); so(y,x,4); 
  1518.     case 4: so(y,x,3); so(y,x,2); 
  1519.             so(y,x,1); so(y,x,0); 
  1520. }
  1522. #if defined(FAST_VARIABLE)
  1524. #define round(rm,y,x,k) 
  1525. switch(nc) 
  1526. {   case 8: rm(y,x,k,7); rm(y,x,k,6); 
  1527.             rm(y,x,k,5); rm(y,x,k,4); 
  1528.             rm(y,x,k,3); rm(y,x,k,2); 
  1529.             rm(y,x,k,1); rm(y,x,k,0); 
  1530.             break; 
  1531.     case 6: rm(y,x,k,5); rm(y,x,k,4); 
  1532.             rm(y,x,k,3); rm(y,x,k,2); 
  1533.             rm(y,x,k,1); rm(y,x,k,0); 
  1534.             break; 
  1535.     case 4: rm(y,x,k,3); rm(y,x,k,2); 
  1536.             rm(y,x,k,1); rm(y,x,k,0); 
  1537.             break; 
  1538. }
  1539. #else
  1541. #define round(rm,y,x,k) 
  1542. switch(nc) 
  1543. {   case 8: rm(y,x,k,7); rm(y,x,k,6); 
  1544.     case 6: rm(y,x,k,5); rm(y,x,k,4); 
  1545.     case 4: rm(y,x,k,3); rm(y,x,k,2); 
  1546.             rm(y,x,k,1); rm(y,x,k,0); 
  1547. }
  1549. #endif
  1551. #endif
  1552. #endif
  1554. #if defined(ENCRYPTION)
  1556. /* I am grateful to Frank Yellin for the following construction
  1557.    (and that for decryption) which, given the column (c) of the 
  1558.    output state variable, gives the input state variables which 
  1559.    are needed in its computation for each row (r) of the state.
  1561.    For the fixed block size options, compilers should be able to 
  1562.    reduce this complex expression (and the equivalent one for 
  1563.    decryption) to a static variable reference at compile time. 
  1564.    But for variable block size code, there will be some limbs on
  1565.    which conditional clauses will be returned.
  1566. */
  1568. /* y = output word, x = input word, r = row, c = column for r = 0, 
  1569.    1, 2 and 3 = column accessed for row r.
  1570. */
  1572. #define fwd_var(x,r,c)
  1573.  ( r == 0 ?           
  1574.     ( c == 0 ? s(x,0) 
  1575.     : c == 1 ? s(x,1) 
  1576.     : c == 2 ? s(x,2) 
  1577.     : c == 3 ? s(x,3) 
  1578.     : c == 4 ? s(x,4) 
  1579.     : c == 5 ? s(x,5) 
  1580.     : c == 6 ? s(x,6) 
  1581.     :          s(x,7))
  1582.  : r == 1 ?           
  1583.     ( c == 0 ? s(x,1) 
  1584.     : c == 1 ? s(x,2) 
  1585.     : c == 2 ? s(x,3) 
  1586.     : c == 3 ? nc == 4 ? s(x,0) : s(x,4) 
  1587.     : c == 4 ? s(x,5) 
  1588.     : c == 5 ? nc == 8 ? s(x,6) : s(x,0) 
  1589.     : c == 6 ? s(x,7) 
  1590.     :          s(x,0))
  1591.  : r == 2 ?           
  1592.     ( c == 0 ? nc == 8 ? s(x,3) : s(x,2) 
  1593.     : c == 1 ? nc == 8 ? s(x,4) : s(x,3) 
  1594.     : c == 2 ? nc == 4 ? s(x,0) : nc == 8 ? s(x,5) : s(x,4) 
  1595.     : c == 3 ? nc == 4 ? s(x,1) : nc == 8 ? s(x,6) : s(x,5) 
  1596.     : c == 4 ? nc == 8 ? s(x,7) : s(x,0) 
  1597.     : c == 5 ? nc == 8 ? s(x,0) : s(x,1) 
  1598.     : c == 6 ? s(x,1) 
  1599.     :          s(x,2))
  1600.  :                    
  1601.     ( c == 0 ? nc == 8 ? s(x,4) : s(x,3) 
  1602.     : c == 1 ? nc == 4 ? s(x,0) : nc == 8 ? s(x,5) : s(x,4) 
  1603.     : c == 2 ? nc == 4 ? s(x,1) : nc == 8 ? s(x,6) : s(x,5) 
  1604.     : c == 3 ? nc == 4 ? s(x,2) : nc == 8 ? s(x,7) : s(x,0) 
  1605.     : c == 4 ? nc == 8 ? s(x,0) : s(x,1) 
  1606.     : c == 5 ? nc == 8 ? s(x,1) : s(x,2) 
  1607.     : c == 6 ? s(x,2) 
  1608.     :          s(x,3)))
  1610. #if defined(FT4_SET)
  1611. #undef  dec_fmvars
  1612. #define dec_fmvars
  1613. #define fwd_rnd(y,x,k,c)    s(y,c)= (k)[c] ^ four_tables(x,ft_tab,fwd_var,rf1,c)
  1614. #elif defined(FT1_SET)
  1615. #undef  dec_fmvars
  1616. #define dec_fmvars
  1617. #define fwd_rnd(y,x,k,c)    s(y,c)= (k)[c] ^ one_table(x,upr,ft_tab,fwd_var,rf1,c)
  1618. #else
  1619. #define fwd_rnd(y,x,k,c)    s(y,c) = fwd_mcol(no_table(x,s_box,fwd_var,rf1,c)) ^ (k)[c]
  1620. #endif
  1622. #if defined(FL4_SET)
  1623. #define fwd_lrnd(y,x,k,c)   s(y,c)= (k)[c] ^ four_tables(x,fl_tab,fwd_var,rf1,c)
  1624. #elif defined(FL1_SET)
  1625. #define fwd_lrnd(y,x,k,c)   s(y,c)= (k)[c] ^ one_table(x,ups,fl_tab,fwd_var,rf1,c)
  1626. #else
  1627. #define fwd_lrnd(y,x,k,c)   s(y,c) = no_table(x,s_box,fwd_var,rf1,c) ^ (k)[c]
  1628. #endif
  1630. static aes_rval aes_enc_blk(const unsigned char in_blk[], unsigned char out_blk[], const aes_ctx cx[1])
  1631. {   aes_32t        locals(b0, b1);
  1632.     const aes_32t  *kp = cx->k_sch;
  1633.     dec_fmvars  /* declare variables for fwd_mcol() if needed */
  1635.     if(!(cx->n_blk & 1)) return aes_bad;
  1637.     state_in(b0, in_blk, kp); 
  1639. #if (ENC_UNROLL == FULL)
  1641.     kp += (cx->n_rnd - 9) * nc;
  1643.     switch(cx->n_rnd)
  1644.     {
  1645.     case 14:    round(fwd_rnd,  b1, b0, kp - 4 * nc); 
  1646.                 round(fwd_rnd,  b0, b1, kp - 3 * nc);
  1647.     case 12:    round(fwd_rnd,  b1, b0, kp - 2 * nc); 
  1648.                 round(fwd_rnd,  b0, b1, kp -     nc);
  1649.     case 10:    round(fwd_rnd,  b1, b0, kp         );             
  1650.                 round(fwd_rnd,  b0, b1, kp +     nc);
  1651.                 round(fwd_rnd,  b1, b0, kp + 2 * nc); 
  1652.                 round(fwd_rnd,  b0, b1, kp + 3 * nc);
  1653.                 round(fwd_rnd,  b1, b0, kp + 4 * nc); 
  1654.                 round(fwd_rnd,  b0, b1, kp + 5 * nc);
  1655.                 round(fwd_rnd,  b1, b0, kp + 6 * nc); 
  1656.                 round(fwd_rnd,  b0, b1, kp + 7 * nc);
  1657.                 round(fwd_rnd,  b1, b0, kp + 8 * nc);
  1658.                 round(fwd_lrnd, b0, b1, kp + 9 * nc);
  1659.     }
  1660. #else
  1661.     
  1662. #if (ENC_UNROLL == PARTIAL)
  1663.     {   aes_32t    rnd;
  1664.         for(rnd = 0; rnd < (cx->n_rnd >> 1) - 1; ++rnd)
  1665.         {
  1666.             kp += nc;
  1667.             round(fwd_rnd, b1, b0, kp); 
  1668.             kp += nc;
  1669.             round(fwd_rnd, b0, b1, kp); 
  1670.         }
  1671.         kp += nc;
  1672.         round(fwd_rnd,  b1, b0, kp);
  1673. #else
  1674.     {   aes_32t    rnd, *p0 = b0, *p1 = b1, *pt;
  1675.         for(rnd = 0; rnd < cx->n_rnd - 1; ++rnd)
  1676.         {
  1677.             kp += nc;
  1678.             round(fwd_rnd, p1, p0, kp); 
  1679.             pt = p0, p0 = p1, p1 = pt;
  1680.         }
  1681. #endif
  1682.         kp += nc;
  1683.         round(fwd_lrnd, b0, b1, kp);
  1684.     }
  1685. #endif
  1687.     state_out(out_blk, b0);
  1688.     return aes_good;
  1689. }
  1691. #endif
  1693. #if defined(DECRYPTION)
  1695. #define inv_var(x,r,c) 
  1696.  ( r == 0 ?           
  1697.     ( c == 0 ? s(x,0) 
  1698.     : c == 1 ? s(x,1) 
  1699.     : c == 2 ? s(x,2) 
  1700.     : c == 3 ? s(x,3) 
  1701.     : c == 4 ? s(x,4) 
  1702.     : c == 5 ? s(x,5) 
  1703.     : c == 6 ? s(x,6) 
  1704.     :          s(x,7))
  1705.  : r == 1 ?           
  1706.     ( c == 0 ? nc == 4 ? s(x,3) : nc == 8 ? s(x,7) : s(x,5) 
  1707.     : c == 1 ? s(x,0) 
  1708.     : c == 2 ? s(x,1) 
  1709.     : c == 3 ? s(x,2) 
  1710.     : c == 4 ? s(x,3) 
  1711.     : c == 5 ? s(x,4) 
  1712.     : c == 6 ? s(x,5) 
  1713.     :          s(x,6))
  1714.  : r == 2 ?           
  1715.     ( c == 0 ? nc == 4 ? s(x,2) : nc == 8 ? s(x,5) : s(x,4) 
  1716.     : c == 1 ? nc == 4 ? s(x,3) : nc == 8 ? s(x,6) : s(x,5) 
  1717.     : c == 2 ? nc == 8 ? s(x,7) : s(x,0) 
  1718.     : c == 3 ? nc == 8 ? s(x,0) : s(x,1) 
  1719.     : c == 4 ? nc == 8 ? s(x,1) : s(x,2) 
  1720.     : c == 5 ? nc == 8 ? s(x,2) : s(x,3) 
  1721.     : c == 6 ? s(x,3) 
  1722.     :          s(x,4))
  1723.  :                    
  1724.     ( c == 0 ? nc == 4 ? s(x,1) : nc == 8 ? s(x,4) : s(x,3) 
  1725.     : c == 1 ? nc == 4 ? s(x,2) : nc == 8 ? s(x,5) : s(x,4) 
  1726.     : c == 2 ? nc == 4 ? s(x,3) : nc == 8 ? s(x,6) : s(x,5) 
  1727.     : c == 3 ? nc == 8 ? s(x,7) : s(x,0) 
  1728.     : c == 4 ? nc == 8 ? s(x,0) : s(x,1) 
  1729.     : c == 5 ? nc == 8 ? s(x,1) : s(x,2) 
  1730.     : c == 6 ? s(x,2) 
  1731.     :          s(x,3)))
  1733. #if defined(IT4_SET)
  1734. #undef  dec_imvars
  1735. #define dec_imvars
  1736. #define inv_rnd(y,x,k,c)    s(y,c)= (k)[c] ^ four_tables(x,it_tab,inv_var,rf1,c)
  1737. #elif defined(IT1_SET)
  1738. #undef  dec_imvars
  1739. #define dec_imvars
  1740. #define inv_rnd(y,x,k,c)    s(y,c)= (k)[c] ^ one_table(x,upr,it_tab,inv_var,rf1,c)
  1741. #else
  1742. #define inv_rnd(y,x,k,c)    s(y,c) = inv_mcol(no_table(x,inv_s_box,inv_var,rf1,c) ^ (k)[c])
  1743. #endif
  1745. #if defined(IL4_SET)
  1746. #define inv_lrnd(y,x,k,c)   s(y,c)= (k)[c] ^ four_tables(x,il_tab,inv_var,rf1,c)
  1747. #elif defined(IL1_SET)
  1748. #define inv_lrnd(y,x,k,c)   s(y,c)= (k)[c] ^ one_table(x,ups,il_tab,inv_var,rf1,c)
  1749. #else
  1750. #define inv_lrnd(y,x,k,c)   s(y,c) = no_table(x,inv_s_box,inv_var,rf1,c) ^ (k)[c]
  1751. #endif
  1753. static aes_rval aes_dec_blk(const unsigned char in_blk[], unsigned char out_blk[], const aes_ctx cx[1])
  1754. {   aes_32t        locals(b0, b1);
  1755.     const aes_32t  *kp = cx->k_sch + nc * cx->n_rnd;
  1756.     dec_imvars  /* declare variables for inv_mcol() if needed */
  1758.     if(!(cx->n_blk & 2)) return aes_bad;
  1760.     state_in(b0, in_blk, kp);
  1762. #if (DEC_UNROLL == FULL)
  1764.     kp = cx->k_sch + 9 * nc;
  1765.     switch(cx->n_rnd)
  1766.     {
  1767.     case 14:    round(inv_rnd,  b1, b0, kp + 4 * nc);
  1768.                 round(inv_rnd,  b0, b1, kp + 3 * nc);
  1769.     case 12:    round(inv_rnd,  b1, b0, kp + 2 * nc);
  1770.                 round(inv_rnd,  b0, b1, kp + nc    );
  1771.     case 10:    round(inv_rnd,  b1, b0, kp         );             
  1772.                 round(inv_rnd,  b0, b1, kp -     nc);
  1773.                 round(inv_rnd,  b1, b0, kp - 2 * nc); 
  1774.                 round(inv_rnd,  b0, b1, kp - 3 * nc);
  1775.                 round(inv_rnd,  b1, b0, kp - 4 * nc); 
  1776.                 round(inv_rnd,  b0, b1, kp - 5 * nc);
  1777.                 round(inv_rnd,  b1, b0, kp - 6 * nc); 
  1778.                 round(inv_rnd,  b0, b1, kp - 7 * nc);
  1779.                 round(inv_rnd,  b1, b0, kp - 8 * nc);
  1780.                 round(inv_lrnd, b0, b1, kp - 9 * nc);
  1781.     }
  1782. #else
  1783.     
  1784. #if (DEC_UNROLL == PARTIAL)
  1785.     {   aes_32t    rnd;
  1786.         for(rnd = 0; rnd < (cx->n_rnd >> 1) - 1; ++rnd)
  1787.         {
  1788.             kp -= nc; 
  1789.             round(inv_rnd, b1, b0, kp); 
  1790.             kp -= nc; 
  1791.             round(inv_rnd, b0, b1, kp); 
  1792.         }
  1793.         kp -= nc;
  1794.         round(inv_rnd, b1, b0, kp);
  1795. #else
  1796.     {   aes_32t    rnd, *p0 = b0, *p1 = b1, *pt;
  1797.         for(rnd = 0; rnd < cx->n_rnd - 1; ++rnd)
  1798.         {
  1799.             kp -= nc;
  1800.             round(inv_rnd, p1, p0, kp); 
  1801.             pt = p0, p0 = p1, p1 = pt;
  1802.         }
  1803. #endif
  1804.         kp -= nc;
  1805.         round(inv_lrnd, b0, b1, kp);
  1806.     }
  1807. #endif
  1809.     state_out(out_blk, b0);
  1810.     return aes_good;
  1811. }
  1813. #endif
  1815. /*----------------------------------------------------------------------
  1816. |       AP4_AesBlockCipher::AP4_AesBlockCipher
  1817. +---------------------------------------------------------------------*/
  1818. AP4_AesBlockCipher::AP4_AesBlockCipher(const AP4_UI08* key)
  1819. {
  1820.     aes_enc_key(key, AP4_AES_KEY_LENGTH, &m_Context);
  1821. }
  1823. /*----------------------------------------------------------------------
  1824. |       AP4_AesBlockCipher::~AP4_AesBlockCipher
  1825. +---------------------------------------------------------------------*/
  1826. AP4_AesBlockCipher::~AP4_AesBlockCipher()
  1827. {
  1828. }
  1830. /*----------------------------------------------------------------------
  1831. |       AP4_AesCipher::EncryptBlock
  1832. +---------------------------------------------------------------------*/
  1833. AP4_Result 
  1834. AP4_AesBlockCipher::EncryptBlock(const AP4_UI08* block_in, AP4_UI08* block_out)
  1835. {
  1836.     aes_rval result;
  1837.     result = aes_enc_blk(block_in, block_out, &m_Context);
  1838.     return result == aes_good ? AP4_SUCCESS : AP4_FAILURE;
  1839. }