Update libsrtp to upstream 1.5.0

srtp/crypto/cipher/aes.c

 /*
  * aes.c
  *
  * An implemnetation of the AES block cipher.
  *
  * David A. McGrew
  * Cisco Systems, Inc.
  */
 
 /*
@@ skipping 25 matching lines @@
  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
+#ifdef HAVE_CONFIG_H
+    #include <config.h>
+#endif
 
 #include "aes.h"
 #include "err.h"
 
 /* 
  * we use the tables T0, T1, T2, T3, and T4 to compute AES, and 
  * the tables U0, U1, U2, and U4 to compute its inverse
  *
  * different tables are used on little-endian (Intel, VMS) and
  * big-endian processors (everything else)
@@ skipping 1462 matching lines @@
    * for the first and the last)  
    *
    * mixColumn is implemented by using the tables U0, U1, U2, U3,
    * followed by the T4 table (which cancels out the use of the sbox
    * in the U-tables)
    */
   for (i=1; i < num_rounds; i++) {
 #ifdef CPU_RISC
     uint32_t tmp;
 
+#ifdef WORDS_BIGENDIAN
     tmp = expanded_key->round[i].v32[0];
     expanded_key->round[i].v32[0] = 
       U0[T4[(tmp >> 24)       ] & 0xff] ^ 
       U1[T4[(tmp >> 16) & 0xff] & 0xff] ^ 
       U2[T4[(tmp >> 8)  & 0xff] & 0xff] ^ 
       U3[T4[(tmp)       & 0xff] & 0xff];
 
     tmp = expanded_key->round[i].v32[1];
     expanded_key->round[i].v32[1] = 
       U0[T4[(tmp >> 24)       ] & 0xff] ^ 
       U1[T4[(tmp >> 16) & 0xff] & 0xff] ^ 
       U2[T4[(tmp >> 8)  & 0xff] & 0xff] ^ 
       U3[T4[(tmp)       & 0xff] & 0xff];
 
     tmp = expanded_key->round[i].v32[2];
     expanded_key->round[i].v32[2] = 
       U0[T4[(tmp >> 24)       ] & 0xff] ^ 
       U1[T4[(tmp >> 16) & 0xff] & 0xff] ^ 
       U2[T4[(tmp >> 8)  & 0xff] & 0xff] ^ 
       U3[T4[(tmp)       & 0xff] & 0xff];
 
     tmp = expanded_key->round[i].v32[3];
     expanded_key->round[i].v32[3] = 
       U0[T4[(tmp >> 24)       ] & 0xff] ^ 
       U1[T4[(tmp >> 16) & 0xff] & 0xff] ^ 
       U2[T4[(tmp >> 8)  & 0xff] & 0xff] ^ 
       U3[T4[(tmp)       & 0xff] & 0xff];
+#else
+    tmp = expanded_key->round[i].v32[0];
+    expanded_key->round[i].v32[0] = 
+      U3[T4[(tmp >> 24)       ] & 0xff] ^ 
+      U2[T4[(tmp >> 16) & 0xff] & 0xff] ^ 
+      U1[T4[(tmp >> 8)  & 0xff] & 0xff] ^ 
+      U0[T4[(tmp)       & 0xff] & 0xff];
+
+    tmp = expanded_key->round[i].v32[1];
+    expanded_key->round[i].v32[1] = 
+      U3[T4[(tmp >> 24)       ] & 0xff] ^ 
+      U2[T4[(tmp >> 16) & 0xff] & 0xff] ^ 
+      U1[T4[(tmp >> 8)  & 0xff] & 0xff] ^ 
+      U0[T4[(tmp)       & 0xff] & 0xff];
+
+    tmp = expanded_key->round[i].v32[2];
+    expanded_key->round[i].v32[2] = 
+      U3[T4[(tmp >> 24)       ] & 0xff] ^ 
+      U2[T4[(tmp >> 16) & 0xff] & 0xff] ^ 
+      U1[T4[(tmp >> 8)  & 0xff] & 0xff] ^ 
+      U0[T4[(tmp)       & 0xff] & 0xff];
+
+    tmp = expanded_key->round[i].v32[3];
+    expanded_key->round[i].v32[3] = 
+      U3[T4[(tmp >> 24)       ] & 0xff] ^ 
+      U2[T4[(tmp >> 16) & 0xff] & 0xff] ^ 
+      U1[T4[(tmp >> 8)  & 0xff] & 0xff] ^ 
+      U0[T4[(tmp)       & 0xff] & 0xff];
+#endif /* WORDS_BIGENDIAN */
+
 #else /* assume CPU_CISC */
 
     uint32_t c0, c1, c2, c3;
 
     c0 = U0[aes_sbox[expanded_key->round[i].v8[0]]] 
        ^ U1[aes_sbox[expanded_key->round[i].v8[1]]] 
        ^ U2[aes_sbox[expanded_key->round[i].v8[2]]] 
        ^ U3[aes_sbox[expanded_key->round[i].v8[3]]];
 
     c1 = U0[aes_sbox[expanded_key->round[i].v8[4]]] 
@@ skipping 18 matching lines @@
 
 #endif     
   }
 
   return err_status_ok;
 }
 
 #ifdef CPU_CISC
 
 
-static INLINE void
+static inline void
 aes_round(v128_t *state, const v128_t *round_key) {
   uint32_t column0, column1, column2, column3;
 
   /* compute the columns of the output square in terms of the octets
      of state, using the tables T0, T1, T2, T3 */
 
   column0 = T0[state->v8[0]] ^ T1[state->v8[5]]
     ^ T2[state->v8[10]] ^ T3[state->v8[15]];
 
   column1 = T0[state->v8[4]] ^ T1[state->v8[9]]
     ^ T2[state->v8[14]] ^ T3[state->v8[3]];
 
   column2 = T0[state->v8[8]] ^ T1[state->v8[13]]
     ^ T2[state->v8[2]] ^ T3[state->v8[7]];
 
   column3 = T0[state->v8[12]] ^ T1[state->v8[1]]
     ^ T2[state->v8[6]] ^ T3[state->v8[11]];
 
   state->v32[0] = column0 ^ round_key->v32[0];
   state->v32[1] = column1 ^ round_key->v32[1];
   state->v32[2] = column2 ^ round_key->v32[2];
   state->v32[3] = column3 ^ round_key->v32[3];
 
 }
 
 
-static INLINE void
+static inline void
 aes_inv_round(v128_t *state, const v128_t *round_key) {
   uint32_t column0, column1, column2, column3;
 
   /* compute the columns of the output square in terms of the octets
      of state, using the tables U0, U1, U2, U3 */
 
   column0 = U0[state->v8[0]] ^ U1[state->v8[13]]
     ^ U2[state->v8[10]] ^ U3[state->v8[7]];
 
   column1 = U0[state->v8[4]] ^ U1[state->v8[1]]
     ^ U2[state->v8[14]] ^ U3[state->v8[11]];
 
   column2 = U0[state->v8[8]] ^ U1[state->v8[5]]
     ^ U2[state->v8[2]] ^ U3[state->v8[15]];
 
   column3 = U0[state->v8[12]] ^ U1[state->v8[9]]
     ^ U2[state->v8[6]] ^ U3[state->v8[3]];
 
   state->v32[0] = column0 ^ round_key->v32[0];
   state->v32[1] = column1 ^ round_key->v32[1];
   state->v32[2] = column2 ^ round_key->v32[2];
   state->v32[3] = column3 ^ round_key->v32[3];
 
 }
 
-static INLINE void
+static inline void
 aes_final_round(v128_t *state, const v128_t *round_key) {
   uint8_t tmp;
 
   /* byte substitutions and row shifts */
   /* first row - no shift */
   state->v8[0] = aes_sbox[state->v8[0]];
   state->v8[4] = aes_sbox[state->v8[4]];
   state->v8[8] = aes_sbox[state->v8[8]];
   state->v8[12] = aes_sbox[state->v8[12]];
 
@@ skipping 15 matching lines @@
   /* fourth row - shift three left */
   tmp = aes_sbox[state->v8[15]];
   state->v8[15] = aes_sbox[state->v8[11]];
   state->v8[11] = aes_sbox[state->v8[7]];
   state->v8[7] = aes_sbox[state->v8[3]];
   state->v8[3] = tmp;
 
   v128_xor_eq(state, round_key);
 }
 
-static INLINE void
+static inline void
 aes_inv_final_round(v128_t *state, const v128_t *round_key) {
   uint8_t tmp;
 
   /* byte substitutions and row shifts */
   /* first row - no shift */
   state->v8[0] = aes_inv_sbox[state->v8[0]];
   state->v8[4] = aes_inv_sbox[state->v8[4]];
   state->v8[8] = aes_inv_sbox[state->v8[8]];
   state->v8[12] = aes_inv_sbox[state->v8[12]];
 
@@ skipping 18 matching lines @@
   state->v8[7] = aes_inv_sbox[state->v8[11]];
   state->v8[11] = aes_inv_sbox[state->v8[15]];
   state->v8[15] = tmp;
 
   v128_xor_eq(state, round_key);
 }
 
 
 #elif CPU_RISC
 
-static INLINE void
+static inline void
 aes_round(v128_t *state, const v128_t *round_key) {
   uint32_t column0, column1, column2, column3;
 
   /* compute the columns of the output square in terms of the octets
      of state, using the tables T0, T1, T2, T3 */
 #ifdef WORDS_BIGENDIAN
   column0 = T0[state->v32[0] >> 24] ^ T1[(state->v32[1] >> 16) & 0xff]
     ^ T2[(state->v32[2] >> 8) & 0xff] ^ T3[state->v32[3] & 0xff];
 
   column1 = T0[state->v32[1] >> 24] ^ T1[(state->v32[2] >> 16) & 0xff]
@@ skipping 18 matching lines @@
         ^ T2[(state->v32[1] >> 16) & 0xff] ^ T3[state->v32[2] >> 24];
 #endif /* WORDS_BIGENDIAN */
 
   state->v32[0] = column0 ^ round_key->v32[0];
   state->v32[1] = column1 ^ round_key->v32[1];
   state->v32[2] = column2 ^ round_key->v32[2];
   state->v32[3] = column3 ^ round_key->v32[3];
 
 }
 
-static INLINE void
+static inline void
 aes_inv_round(v128_t *state, const v128_t *round_key) {
   uint32_t column0, column1, column2, column3;
 
   /* compute the columns of the output square in terms of the octets
      of state, using the tables U0, U1, U2, U3 */
 
 #ifdef WORDS_BIGENDIAN
-  /* FIX!  WRong indexes */
   column0 = U0[state->v32[0] >> 24] ^ U1[(state->v32[3] >> 16) & 0xff]
     ^ U2[(state->v32[2] >> 8) & 0xff] ^ U3[state->v32[1] & 0xff];
 
   column1 = U0[state->v32[1] >> 24] ^ U1[(state->v32[0] >> 16) & 0xff]
     ^ U2[(state->v32[3] >> 8) & 0xff] ^ U3[state->v32[2] & 0xff];
 
   column2 = U0[state->v32[2] >> 24] ^ U1[(state->v32[1] >> 16) & 0xff]
     ^ U2[(state->v32[0] >> 8) & 0xff] ^ U3[state->v32[3] & 0xff];
 
   column3 = U0[state->v32[3] >> 24] ^ U1[(state->v32[2] >> 16) & 0xff]
     ^ U2[(state->v32[1] >> 8) & 0xff] ^ U3[state->v32[0] & 0xff];
 #else
-  column0 = U0[state->v32[0] & 0xff] ^ U1[(state->v32[1] >> 8) & 0xff]
-        ^ U2[(state->v32[2] >> 16) & 0xff] ^ U3[state->v32[3] >> 24];
+  column0 = U0[state->v32[0] & 0xff] ^ U1[(state->v32[3] >> 8) & 0xff]
+    ^ U2[(state->v32[2] >> 16) & 0xff] ^ U3[(state->v32[1] >> 24) & 0xff];
 
-  column1 = U0[state->v32[1] & 0xff] ^ U1[(state->v32[2] >> 8) & 0xff]
-        ^ U2[(state->v32[3] >> 16) & 0xff] ^ U3[state->v32[0] >> 24];
+  column1 = U0[state->v32[1] & 0xff] ^ U1[(state->v32[0] >> 8) & 0xff]
+    ^ U2[(state->v32[3] >> 16) & 0xff] ^ U3[(state->v32[2] >> 24) & 0xff];
 
-  column2 = U0[state->v32[2] & 0xff] ^ U1[(state->v32[3] >> 8) & 0xff]
-        ^ U2[(state->v32[0] >> 16) & 0xff] ^ U3[state->v32[1] >> 24];
+  column2 = U0[state->v32[2] & 0xff] ^ U1[(state->v32[1] >> 8) & 0xff]
+    ^ U2[(state->v32[0] >> 16) & 0xff] ^ U3[(state->v32[3] >> 24) & 0xff];
 
-  column3 = U0[state->v32[3] & 0xff] ^ U1[(state->v32[0] >> 8) & 0xff]
-        ^ U2[(state->v32[1] >> 16) & 0xff] ^ U3[state->v32[2] >> 24];
+  column3 = U0[state->v32[3] & 0xff] ^ U1[(state->v32[2] >> 8) & 0xff]
+    ^ U2[(state->v32[1] >> 16) & 0xff] ^ U3[(state->v32[0] >> 24) & 0xff];
 #endif /* WORDS_BIGENDIAN */
 
   state->v32[0] = column0 ^ round_key->v32[0];
   state->v32[1] = column1 ^ round_key->v32[1];
   state->v32[2] = column2 ^ round_key->v32[2];
   state->v32[3] = column3 ^ round_key->v32[3];
 
 }
 
-static INLINE void
+static inline void
 aes_final_round(v128_t *state, const v128_t *round_key) {
   uint32_t tmp0, tmp1, tmp2, tmp3;
 
+#ifdef WORDS_BIGENDIAN
   tmp0 = (T4[(state->v32[0] >> 24)]        & 0xff000000) 
        ^ (T4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000) 
        ^ (T4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00) 
        ^ (T4[(state->v32[3]      ) & 0xff] & 0x000000ff) 
        ^ round_key->v32[0];
 
   tmp1 = (T4[(state->v32[1] >> 24)]        & 0xff000000)
        ^ (T4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000)
        ^ (T4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00)
        ^ (T4[(state->v32[0]      ) & 0xff] & 0x000000ff)
        ^ round_key->v32[1];
 
   tmp2 = (T4[(state->v32[2] >> 24)]        & 0xff000000)
        ^ (T4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000)
        ^ (T4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00)
        ^ (T4[(state->v32[1]      ) & 0xff] & 0x000000ff)
        ^ round_key->v32[2];
 
   tmp3 = (T4[(state->v32[3] >> 24)]        & 0xff000000)
        ^ (T4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000)
        ^ (T4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00)
        ^ (T4[(state->v32[2]      ) & 0xff] & 0x000000ff)
        ^ round_key->v32[3];
+#else
+  tmp0 = (T4[(state->v32[3] >> 24)]        & 0xff000000) 
+       ^ (T4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000) 
+       ^ (T4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00) 
+       ^ (T4[(state->v32[0]      ) & 0xff] & 0x000000ff) 
+       ^ round_key->v32[0];
+
+  tmp1 = (T4[(state->v32[0] >> 24)]        & 0xff000000)
+       ^ (T4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000)
+       ^ (T4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00)
+       ^ (T4[(state->v32[1]      ) & 0xff] & 0x000000ff)
+       ^ round_key->v32[1];
+
+  tmp2 = (T4[(state->v32[1] >> 24)]        & 0xff000000)
+       ^ (T4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000)
+       ^ (T4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00)
+       ^ (T4[(state->v32[2]      ) & 0xff] & 0x000000ff)
+       ^ round_key->v32[2];
+
+  tmp3 = (T4[(state->v32[2] >> 24)]        & 0xff000000)
+       ^ (T4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000)
+       ^ (T4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00)
+       ^ (T4[(state->v32[3]      ) & 0xff] & 0x000000ff)
+       ^ round_key->v32[3];
+#endif /* WORDS_BIGENDIAN */
 
   state->v32[0] = tmp0;
   state->v32[1] = tmp1;
   state->v32[2] = tmp2;
   state->v32[3] = tmp3;
 
 }
 
-static INLINE void
+static inline void
 aes_inv_final_round(v128_t *state, const v128_t *round_key) {
   uint32_t tmp0, tmp1, tmp2, tmp3;
 
+#ifdef WORDS_BIGENDIAN
   tmp0 = (U4[(state->v32[0] >> 24)]        & 0xff000000) 
        ^ (U4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000) 
        ^ (U4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00) 
        ^ (U4[(state->v32[1]      ) & 0xff] & 0x000000ff) 
        ^ round_key->v32[0];
 
   tmp1 = (U4[(state->v32[1] >> 24)]        & 0xff000000)
        ^ (U4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000)
        ^ (U4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00)
        ^ (U4[(state->v32[2]      ) & 0xff] & 0x000000ff)
        ^ round_key->v32[1];
 
   tmp2 = (U4[(state->v32[2] >> 24)]        & 0xff000000)
        ^ (U4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000)
        ^ (U4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00)
        ^ (U4[(state->v32[3]      ) & 0xff] & 0x000000ff)
        ^ round_key->v32[2];
 
   tmp3 = (U4[(state->v32[3] >> 24)]        & 0xff000000)
        ^ (U4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000)
        ^ (U4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00)
        ^ (U4[(state->v32[0]      ) & 0xff] & 0x000000ff)
        ^ round_key->v32[3];
+#else
+  tmp0 = (U4[(state->v32[1] >> 24)]        & 0xff000000) 
+       ^ (U4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000) 
+       ^ (U4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00) 
+       ^ (U4[(state->v32[0]      ) & 0xff] & 0x000000ff) 
+       ^ round_key->v32[0];
+
+  tmp1 = (U4[(state->v32[2] >> 24)]        & 0xff000000)
+       ^ (U4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000)
+       ^ (U4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00)
+       ^ (U4[(state->v32[1]      ) & 0xff] & 0x000000ff)
+       ^ round_key->v32[1];
+
+  tmp2 = (U4[(state->v32[3] >> 24)]        & 0xff000000)
+       ^ (U4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000)
+       ^ (U4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00)
+       ^ (U4[(state->v32[2]      ) & 0xff] & 0x000000ff)
+       ^ round_key->v32[2];
+
+  tmp3 = (U4[(state->v32[0] >> 24)]        & 0xff000000)
+       ^ (U4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000)
+       ^ (U4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00)
+       ^ (U4[(state->v32[3]      ) & 0xff] & 0x000000ff)
+       ^ round_key->v32[3];
+#endif /* WORDS_BIGENDIAN */
 
   state->v32[0] = tmp0;
   state->v32[1] = tmp1;
   state->v32[2] = tmp2;
   state->v32[3] = tmp3;
 
 }
 
 #elif CPU_16  /* assume 16-bit word size on processor */
 
-static INLINE void
+static inline void
 aes_round(v128_t *state, const v128_t *round_key) {
   uint32_t column0, column1, column2, column3;
   uint16_t c
   /* compute the columns of the output square in terms of the octets
      of state, using the tables T0, T1, T2, T3 */
 
   column0 = T0[state->v8[0]] ^ T1[state->v8[5]]
     ^ T2[state->v8[10]] ^ T3[state->v8[15]];
 
   column1 = T0[state->v8[4]] ^ T1[state->v8[9]]
     ^ T2[state->v8[14]] ^ T3[state->v8[3]];
 
   column2 = T0[state->v8[8]] ^ T1[state->v8[13]]
     ^ T2[state->v8[2]] ^ T3[state->v8[7]];
 
   column3 = T0[state->v8[12]] ^ T1[state->v8[1]]
     ^ T2[state->v8[6]] ^ T3[state->v8[11]];
 
   state->v32[0] = column0 ^ round_key->v32[0];
   state->v32[1] = column1 ^ round_key->v32[1];
   state->v32[2] = column2 ^ round_key->v32[2];
   state->v32[3] = column3 ^ round_key->v32[3];
 
 }
 
 
-static INLINE void
+static inline void
 aes_inv_round(v128_t *state, const v128_t *round_key) {
   uint32_t column0, column1, column2, column3;
 
   /* compute the columns of the output square in terms of the octets
      of state, using the tables U0, U1, U2, U3 */
 
   column0 = U0[state->v8[0]] ^ U1[state->v8[5]]
     ^ U2[state->v8[10]] ^ U3[state->v8[15]];
 
   column1 = U0[state->v8[4]] ^ U1[state->v8[9]]
     ^ U2[state->v8[14]] ^ U3[state->v8[3]];
 
   column2 = U0[state->v8[8]] ^ U1[state->v8[13]]
     ^ U2[state->v8[2]] ^ U3[state->v8[7]];
 
   column3 = U0[state->v8[12]] ^ U1[state->v8[1]]
     ^ U2[state->v8[6]] ^ U3[state->v8[11]];
 
   state->v32[0] = column0 ^ round_key->v32[0];
   state->v32[1] = column1 ^ round_key->v32[1];
   state->v32[2] = column2 ^ round_key->v32[2];
   state->v32[3] = column3 ^ round_key->v32[3];
 
 }
 
-static INLINE void
+static inline void
 aes_final_round(v128_t *state, const v128_t *round_key) {
   uint8_t tmp;
 
   /* byte substitutions and row shifts */
   /* first row - no shift */
   state->v8[0] = aes_sbox[state->v8[0]];
   state->v8[4] = aes_sbox[state->v8[4]];
   state->v8[8] = aes_sbox[state->v8[8]];
   state->v8[12] = aes_sbox[state->v8[12]];
 
@@ skipping 15 matching lines @@
   /* fourth row - shift three left */
   tmp = aes_sbox[state->v8[15]];
   state->v8[15] = aes_sbox[state->v8[11]];
   state->v8[11] = aes_sbox[state->v8[7]];
   state->v8[7] = aes_sbox[state->v8[3]];
   state->v8[3] = tmp;
 
   v128_xor_eq(state, round_key);
 }
 
-static INLINE void
+static inline void
 aes_inv_final_round(v128_t *state, const v128_t *round_key) {
   uint8_t tmp;
 
   /* byte substitutions and row shifts */
   /* first row - no shift */
   state->v8[0] = aes_inv_sbox[state->v8[0]];
   state->v8[4] = aes_inv_sbox[state->v8[4]];
   state->v8[8] = aes_inv_sbox[state->v8[8]];
   state->v8[12] = aes_inv_sbox[state->v8[12]];
 
@@ skipping 83 matching lines @@
     aes_inv_final_round(plaintext, &exp_key->round[12]);  
   }
   else if (exp_key->num_rounds == 14) {
     aes_inv_round(plaintext, &exp_key->round[10]);  
     aes_inv_round(plaintext, &exp_key->round[11]);
     aes_inv_round(plaintext, &exp_key->round[12]);  
     aes_inv_round(plaintext, &exp_key->round[13]);
     aes_inv_final_round(plaintext, &exp_key->round[14]);  
   }
 }