Rijndael MixColumns - Rijndael MixColumns

La operación MixColumns realizada por el cifrado de Rijndael , junto con el paso ShiftRows, es la fuente principal de difusión en Rijndael. Cada columna se trata como un polinomio de cuatro términos que son elementos dentro del campo . Los coeficientes de los polinomios son elementos dentro del subcampo principal . ${\ Displaystyle b (x) = b_ {3} x ^ {3} + b_ {2} x ^ {2} + b_ {1} x + b_ {0}}$${\ Displaystyle \ operatorname {GF} (2 ^ {8})}$ ${\ Displaystyle \ operatorname {GF} (2)}$

Cada columna se multiplica por un módulo polinomial fijo ; la inversa de este polinomio es . ${\ Displaystyle a (x) = 3x ^ {3} + x ^ {2} + x + 2}$${\ displaystyle x ^ {4} +1}$${\ Displaystyle a ^ {- 1} (x) = 11x ^ {3} + 13x ^ {2} + 9x + 14}$

MezclarColumnas

La operación consiste en la multiplicación modular de dos polinomios de cuatro términos cuyos coeficientes son elementos de . El módulo utilizado para esta operación es . ${\ Displaystyle \ operatorname {GF} \ left (2 ^ {8} \ right)}$${\ displaystyle x ^ {4} +1}$

Los primeros coeficientes polinomiales de cuatro términos están definidos por la columna de estado , que contiene cuatro bytes. Cada byte es un coeficiente de los cuatro términos de modo que ${\ displaystyle {\ begin {bmatrix} b_ {3} & b_ {2} & b_ {1} & b_ {0} \ end {bmatrix}}}$

${\ Displaystyle b (x) = b_ {3} x ^ {3} + b_ {2} x ^ {2} + b_ {1} x + b_ {0}.}$

El segundo polinomio de cuatro términos es un polinomio constante . Sus coeficientes también son elementos de . Su inverso es . ${\ Displaystyle a (x) = 3x ^ {3} + x ^ {2} + x + 2}$${\ Displaystyle \ operatorname {GF} \ left (2 ^ {8} \ right)}$${\ Displaystyle a ^ {- 1} (x) = 11x ^ {3} + 13x ^ {2} + 9x + 14}$

Necesitamos definir alguna notación:

${\ Displaystyle \ otimes}$denota módulo de multiplicación .${\ displaystyle x ^ {4} +1}$

${\ Displaystyle \ oplus}$denota adición por encima .${\ Displaystyle \ operatorname {GF} \ left (2 ^ {8} \ right)}$

${\ Displaystyle \ bullet}$denota multiplicación (multiplicación de polinomios habitual cuando se trata de polinomios y multiplicación por encima de los coeficientes).${\ Displaystyle \ operatorname {GF} \ left (2 ^ {8} \ right)}$

La suma de dos polinomios cuyos coeficientes son elementos de tiene la siguiente regla: ${\ Displaystyle \ operatorname {GF} \ left (2 ^ {8} \ right)}$

${\ Displaystyle {\ begin {alineado} & \ left (a_ {3} x ^ {3} + a_ {2} x ^ {2} + a_ {1} x + a_ {0} \ right) + \ left ( b_ {3} x ^ {3} + b_ {2} x ^ {2} + b_ {1} x + b_ {0} \ right) \\ = {} & \ left (a_ {3} \ oplus b_ { 3} \ right) x ^ {3} + \ left (a_ {2} \ oplus b_ {2} \ right) x ^ {2} + \ left (a_ {1} \ oplus b_ {1} \ right) x + \ left (a_ {0} \ oplus b_ {0} \ right) \ end {alineado}}}$

Demostración

El polinomio se expresará como . ${\ Displaystyle a (x) = 3x ^ {3} + x ^ {2} + x + 2}$${\ Displaystyle a (x) = a_ {3} x ^ {3} + a_ {2} x ^ {2} + a_ {1} x + a_ {0}}$

Multiplicación de polinomios

${\ Displaystyle {\ begin {alineado} a (x) \ bullet b (x) = c (x) & = \ left (a_ {3} x ^ {3} + a_ {2} x ^ {2} + a_ {1} x + a_ {0} \ right) \ bullet \ left (b_ {3} x ^ {3} + b_ {2} x ^ {2} + b_ {1} x + b_ {0} \ right) \\ & = c_ {6} x ^ {6} + c_ {5} x ^ {5} + c_ {4} x ^ {4} + c_ {3} x ^ {3} + c_ {2} x ^ {2} + c_ {1} x + c_ {0} \ end {alineado}}}$

dónde:

${\ Displaystyle {\ begin {alineado} c_ {0} & = a_ {0} \ bullet b_ {0} \\ c_ {1} & = a_ {1} \ bullet b_ {0} \ oplus a_ {0} \ bullet b_ {1} \\ c_ {2} & = a_ {2} \ bullet b_ {0} \ oplus a_ {1} \ bullet b_ {1} \ oplus a_ {0} \ bullet b_ {2} \\ c_ {3} & = a_ {3} \ bullet b_ {0} \ oplus a_ {2} \ bullet b_ {1} \ oplus a_ {1} \ bullet b_ {2} \ oplus a_ {0} \ bullet b_ {3 } \\ c_ {4} & = a_ {3} \ bullet b_ {1} \ oplus a_ {2} \ bullet b_ {2} \ oplus a_ {1} \ bullet b_ {3} \\ c_ {5} & = a_ {3} \ bullet b_ {2} \ oplus a_ {2} \ bullet b_ {3} \\ c_ {6} & = a_ {3} \ bullet b_ {3} \ end {alineado}}}$

Reducción modular

El resultado es un polinomio de siete términos, que debe reducirse a una palabra de cuatro bytes, lo que se realiza mediante el módulo de multiplicación . ${\ Displaystyle c (x)}$${\ displaystyle x ^ {4} +1}$

Si hacemos algunas operaciones modulares polinomiales básicas podemos ver que:

${\ displaystyle {\ begin {alineado} x ^ {6} {\ bmod {\ left (x ^ {4} +1 \ right)}} & = - x ^ {2} = x ^ {2} {\ text {over}} \ operatorname {GF} \ left (2 ^ {8} \ right) \\ x ^ {5} {\ bmod {\ left (x ^ {4} +1 \ right)}} & = - x = x {\ text {over}} \ operatorname {GF} \ left (2 ^ {8} \ right) \\ x ^ {4} {\ bmod {\ left (x ^ {4} +1 \ right)} } & = - 1 = 1 {\ text {over}} \ operatorname {GF} \ left (2 ^ {8} \ right) \ end {alineado}}}$

En general, podemos decir que ${\ displaystyle x ^ {i} {\ bmod {\ left (x ^ {4} +1 \ right)}} = x ^ {i {\ bmod {4}}}.}$

Entonces

${\ Displaystyle {\ begin {alineado} a (x) \ otimes b (x) & = c (x) {\ bmod {\ left (x ^ {4} +1 \ right)}} \\ & = \ left (c_ {6} x ^ {6} + c_ {5} x ^ {5} + c_ {4} x ^ {4} + c_ {3} x ^ {3} + c_ {2} x ^ {2} + c_ {1} x + c_ {0} \ right) {\ bmod {\ left (x ^ {4} +1 \ right)}} \\ & = c_ {6} x ^ {6 {\ bmod {4 }}} + c_ {5} x ^ {5 {\ bmod {4}}} + c_ {4} x ^ {4 {\ bmod {4}}} + c_ {3} x ^ {3 {\ bmod { 4}}} + c_ {2} x ^ {2 {\ bmod {4}}} + c_ {1} x ^ {1 {\ bmod {4}}} + c_ {0} x ^ {0 {\ bmod {4}}} \\ & = c_ {6} x ^ {2} + c_ {5} x + c_ {4} + c_ {3} x ^ {3} + c_ {2} x ^ {2} + c_ {1} x + c_ {0} \\ & = c_ {3} x ^ {3} + \ left (c_ {2} \ oplus c_ {6} \ right) x ^ {2} + \ left (c_ {1} \ oplus c_ {5} \ right) x + c_ {0} \ oplus c_ {4} \\ & = d_ {3} x ^ {3} + d_ {2} x ^ {2} + d_ { 1} x + d_ {0} \ end {alineado}}}$

dónde

${\ Displaystyle d_ {0} = c_ {0} \ oplus c_ {4}}$

${\ Displaystyle d_ {1} = c_ {1} \ oplus c_ {5}}$

${\ Displaystyle d_ {2} = c_ {2} \ oplus c_ {6}}$

${\ Displaystyle d_ {3} = c_ {3}}$

Representación matricial

El coeficiente de , , y también se puede expresar como sigue: ${\ Displaystyle d_ {3}}$${\ Displaystyle d_ {2}}$${\ Displaystyle d_ {1}}$${\ Displaystyle d_ {0}}$

${\ Displaystyle d_ {0} = a_ {0} \ bullet b_ {0} \ oplus a_ {3} \ bullet b_ {1} \ oplus a_ {2} \ bullet b_ {2} \ oplus a_ {1} \ bullet b_ {3}}$

${\ Displaystyle d_ {1} = a_ {1} \ bullet b_ {0} \ oplus a_ {0} \ bullet b_ {1} \ oplus a_ {3} \ bullet b_ {2} \ oplus a_ {2} \ bullet b_ {3}}$

${\ Displaystyle d_ {2} = a_ {2} \ bullet b_ {0} \ oplus a_ {1} \ bullet b_ {1} \ oplus a_ {0} \ bullet b_ {2} \ oplus a_ {3} \ bullet b_ {3}}$

${\ Displaystyle d_ {3} = a_ {3} \ bullet b_ {0} \ oplus a_ {2} \ bullet b_ {1} \ oplus a_ {1} \ bullet b_ {2} \ oplus a_ {0} \ bullet b_ {3}}$

Y cuando reemplazamos los coeficientes de por las constantes utilizadas en el cifrado obtenemos lo siguiente: ${\ Displaystyle a (x)}$${\ displaystyle {\ begin {bmatrix} 3 & 1 & 1 & 2 \ end {bmatrix}}}$

${\ Displaystyle d_ {0} = 2 \ bullet b_ {0} \ oplus 3 \ bullet b_ {1} \ oplus 1 \ bullet b_ {2} \ oplus 1 \ bullet b_ {3}}$

${\ Displaystyle d_ {1} = 1 \ bullet b_ {0} \ oplus 2 \ bullet b_ {1} \ oplus 3 \ bullet b_ {2} \ oplus 1 \ bullet b_ {3}}$

${\ Displaystyle d_ {2} = 1 \ bullet b_ {0} \ oplus 1 \ bullet b_ {1} \ oplus 2 \ bullet b_ {2} \ oplus 3 \ bullet b_ {3}}$

${\ Displaystyle d_ {3} = 3 \ bullet b_ {0} \ oplus 1 \ bullet b_ {1} \ oplus 1 \ bullet b_ {2} \ oplus 2 \ bullet b_ {3}}$

Esto demuestra que la operación en sí es similar a un cifrado Hill . Se puede realizar multiplicando un vector de coordenadas de cuatro números en el campo Galois de Rijndael por la siguiente matriz MDS circulante :

${\ displaystyle {\ begin {bmatrix} d_ {0} \\ d_ {1} \\ d_ {2} \\ d_ {3} \ end {bmatrix}} = {\ begin {bmatrix} 2 & 3 & 1 & 1 \\ 1 & 2 & 3 & 1 \\ 1 & 1 & 2 & 3 \\ 3 & 1 & 1 & 2 \ end {bmatrix}} {\ begin {bmatrix} b_ {0} \\ b_ {1} \\ b_ {2} \\ b_ {3} \ end {bmatrix}}}$

Ejemplo de implementación

Esto se puede simplificar un poco en la implementación real reemplazando la multiplicación por 2 con un solo turno y condicional exclusivo o, y reemplazando una multiplicación por 3 con una multiplicación por 2 combinada con una exclusiva o. A continuación, se muestra un ejemplo de C de tal implementación:

void gmix_column(unsigned char *r) {
    unsigned char a[4];
    unsigned char b[4];
    unsigned char c;
    unsigned char h;
    /* The array 'a' is simply a copy of the input array 'r'
     * The array 'b' is each element of the array 'a' multiplied by 2
     * in Rijndael's Galois field
     * a[n] ^ b[n] is element n multiplied by 3 in Rijndael's Galois field */ 
    for (c = 0; c < 4; c++) {
        a[c] = r[c];
        /* h is 0xff if the high bit of r[c] is set, 0 otherwise */
        h = (r[c] >> 7) & 1; /* arithmetic right shift, thus shifting in either zeros or ones */
        b[c] = r[c] << 1; /* implicitly removes high bit because b[c] is an 8-bit char, so we xor by 0x1b and not 0x11b in the next line */
        b[c] ^= h * 0x1B; /* Rijndael's Galois field */
    }
    r[0] = b[0] ^ a[3] ^ a[2] ^ b[1] ^ a[1]; /* 2 * a0 + a3 + a2 + 3 * a1 */
    r[1] = b[1] ^ a[0] ^ a[3] ^ b[2] ^ a[2]; /* 2 * a1 + a0 + a3 + 3 * a2 */
    r[2] = b[2] ^ a[1] ^ a[0] ^ b[3] ^ a[3]; /* 2 * a2 + a1 + a0 + 3 * a3 */
    r[3] = b[3] ^ a[2] ^ a[1] ^ b[0] ^ a[0]; /* 2 * a3 + a2 + a1 + 3 * a0 */
}

Ejemplo de AC #

private byte GMul(byte a, byte b) { // Galois Field (256) Multiplication of two Bytes
    byte p = 0;

    for (int counter = 0; counter < 8; counter++) {
        if ((b & 1) != 0) {
            p ^= a;
        }

        bool hi_bit_set = (a & 0x80) != 0;
        a <<= 1;
        if (hi_bit_set) {
            a ^= 0x1B; /* x^8 + x^4 + x^3 + x + 1 */
        }
        b >>= 1;
    }

    return p;
}

private void MixColumns() { // 's' is the main State matrix, 'ss' is a temp matrix of the same dimensions as 's'.
    Array.Clear(ss, 0, ss.Length);

    for (int c = 0; c < 4; c++) {
        ss[0, c] = (byte)(GMul(0x02, s[0, c]) ^ GMul(0x03, s[1, c]) ^ s[2, c] ^ s[3, c]);
        ss[1, c] = (byte)(s[0, c] ^ GMul(0x02, s[1, c]) ^ GMul(0x03, s[2, c]) ^ s[3,c]);
        ss[2, c] = (byte)(s[0, c] ^ s[1, c] ^ GMul(0x02, s[2, c]) ^ GMul(0x03, s[3, c]));
        ss[3, c] = (byte)(GMul(0x03, s[0,c]) ^ s[1, c] ^ s[2, c] ^ GMul(0x02, s[3, c]));
    }

    ss.CopyTo(s, 0);
}

Vectores de prueba para MixColumn ()

InverseMixColumns

La operación MixColumns tiene la siguiente inversa (los números son decimales):

${\ displaystyle {\ begin {bmatrix} b_ {0} \\ b_ {1} \\ b_ {2} \\ b_ {3} \ end {bmatrix}} = {\ begin {bmatrix} 14 & 11 & 13 & 9 \\ 9 & 14 & 11 & 13 \\ 13 y 9 y 14 y 11 \\ 11 y 13 y 9 y 14 \ end {bmatrix}} {\ begin {bmatrix} d_ {0} \\ d_ {1} \\ d_ {2} \\ d_ {3} \ end {bmatrix}}}$

O:

${\ Displaystyle {\ begin {alineado} b_ {0} & = 14 \ bullet d_ {0} \ oplus 11 \ bullet d_ {1} \ oplus 13 \ bullet d_ {2} \ oplus 9 \ bullet d_ {3} \ \ b_ {1} & = 9 \ bullet d_ {0} \ oplus 14 \ bullet d_ {1} \ oplus 11 \ bullet d_ {2} \ oplus 13 \ bullet d_ {3} \\ b_ {2} & = 13 \ bullet d_ {0} \ oplus 9 \ bullet d_ {1} \ oplus 14 \ bullet d_ {2} \ oplus 11 \ bullet d_ {3} \\ b_ {3} & = 11 \ bullet d_ {0} \ oplus 13 \ bullet d_ {1} \ oplus 9 \ bullet d_ {2} \ oplus 14 \ bullet d_ {3} \ end {alineado}}}$

Tablas de búsqueda de multiplicación de Galois

Por lo general, en lugar de implementar la multiplicación de Galois, las implementaciones de Rijndael simplemente usan tablas de búsqueda precalculadas para realizar la multiplicación de bytes por 2, 3, 9, 11, 13 y 14.

Por ejemplo, en C # estas tablas se pueden almacenar en matrices Byte [256]. Para calcular

p * 3

El resultado se obtiene de esta forma:

result = table_3[(int)p]

Algunas de las instancias más comunes de estas tablas de búsqueda son las siguientes:

Multiplica por 2:

0x00,0x02,0x04,0x06,0x08,0x0a,0x0c,0x0e,0x10,0x12,0x14,0x16,0x18,0x1a,0x1c,0x1e,
0x20,0x22,0x24,0x26,0x28,0x2a,0x2c,0x2e,0x30,0x32,0x34,0x36,0x38,0x3a,0x3c,0x3e,
0x40,0x42,0x44,0x46,0x48,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,0x5e,
0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6e,0x70,0x72,0x74,0x76,0x78,0x7a,0x7c,0x7e,	
0x80,0x82,0x84,0x86,0x88,0x8a,0x8c,0x8e,0x90,0x92,0x94,0x96,0x98,0x9a,0x9c,0x9e,
0xa0,0xa2,0xa4,0xa6,0xa8,0xaa,0xac,0xae,0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe,
0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce,0xd0,0xd2,0xd4,0xd6,0xd8,0xda,0xdc,0xde,
0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee,0xf0,0xf2,0xf4,0xf6,0xf8,0xfa,0xfc,0xfe,
0x1b,0x19,0x1f,0x1d,0x13,0x11,0x17,0x15,0x0b,0x09,0x0f,0x0d,0x03,0x01,0x07,0x05,
0x3b,0x39,0x3f,0x3d,0x33,0x31,0x37,0x35,0x2b,0x29,0x2f,0x2d,0x23,0x21,0x27,0x25,
0x5b,0x59,0x5f,0x5d,0x53,0x51,0x57,0x55,0x4b,0x49,0x4f,0x4d,0x43,0x41,0x47,0x45,
0x7b,0x79,0x7f,0x7d,0x73,0x71,0x77,0x75,0x6b,0x69,0x6f,0x6d,0x63,0x61,0x67,0x65,
0x9b,0x99,0x9f,0x9d,0x93,0x91,0x97,0x95,0x8b,0x89,0x8f,0x8d,0x83,0x81,0x87,0x85,
0xbb,0xb9,0xbf,0xbd,0xb3,0xb1,0xb7,0xb5,0xab,0xa9,0xaf,0xad,0xa3,0xa1,0xa7,0xa5,
0xdb,0xd9,0xdf,0xdd,0xd3,0xd1,0xd7,0xd5,0xcb,0xc9,0xcf,0xcd,0xc3,0xc1,0xc7,0xc5,
0xfb,0xf9,0xff,0xfd,0xf3,0xf1,0xf7,0xf5,0xeb,0xe9,0xef,0xed,0xe3,0xe1,0xe7,0xe5

Multiplica por 3:

0x00,0x03,0x06,0x05,0x0c,0x0f,0x0a,0x09,0x18,0x1b,0x1e,0x1d,0x14,0x17,0x12,0x11,
0x30,0x33,0x36,0x35,0x3c,0x3f,0x3a,0x39,0x28,0x2b,0x2e,0x2d,0x24,0x27,0x22,0x21,
0x60,0x63,0x66,0x65,0x6c,0x6f,0x6a,0x69,0x78,0x7b,0x7e,0x7d,0x74,0x77,0x72,0x71,
0x50,0x53,0x56,0x55,0x5c,0x5f,0x5a,0x59,0x48,0x4b,0x4e,0x4d,0x44,0x47,0x42,0x41,
0xc0,0xc3,0xc6,0xc5,0xcc,0xcf,0xca,0xc9,0xd8,0xdb,0xde,0xdd,0xd4,0xd7,0xd2,0xd1,
0xf0,0xf3,0xf6,0xf5,0xfc,0xff,0xfa,0xf9,0xe8,0xeb,0xee,0xed,0xe4,0xe7,0xe2,0xe1,
0xa0,0xa3,0xa6,0xa5,0xac,0xaf,0xaa,0xa9,0xb8,0xbb,0xbe,0xbd,0xb4,0xb7,0xb2,0xb1,
0x90,0x93,0x96,0x95,0x9c,0x9f,0x9a,0x99,0x88,0x8b,0x8e,0x8d,0x84,0x87,0x82,0x81,	
0x9b,0x98,0x9d,0x9e,0x97,0x94,0x91,0x92,0x83,0x80,0x85,0x86,0x8f,0x8c,0x89,0x8a,
0xab,0xa8,0xad,0xae,0xa7,0xa4,0xa1,0xa2,0xb3,0xb0,0xb5,0xb6,0xbf,0xbc,0xb9,0xba,
0xfb,0xf8,0xfd,0xfe,0xf7,0xf4,0xf1,0xf2,0xe3,0xe0,0xe5,0xe6,0xef,0xec,0xe9,0xea,	
0xcb,0xc8,0xcd,0xce,0xc7,0xc4,0xc1,0xc2,0xd3,0xd0,0xd5,0xd6,0xdf,0xdc,0xd9,0xda,	
0x5b,0x58,0x5d,0x5e,0x57,0x54,0x51,0x52,0x43,0x40,0x45,0x46,0x4f,0x4c,0x49,0x4a,
0x6b,0x68,0x6d,0x6e,0x67,0x64,0x61,0x62,0x73,0x70,0x75,0x76,0x7f,0x7c,0x79,0x7a,	
0x3b,0x38,0x3d,0x3e,0x37,0x34,0x31,0x32,0x23,0x20,0x25,0x26,0x2f,0x2c,0x29,0x2a,
0x0b,0x08,0x0d,0x0e,0x07,0x04,0x01,0x02,0x13,0x10,0x15,0x16,0x1f,0x1c,0x19,0x1a

Multiplica por 9:

0x00,0x09,0x12,0x1b,0x24,0x2d,0x36,0x3f,0x48,0x41,0x5a,0x53,0x6c,0x65,0x7e,0x77,
0x90,0x99,0x82,0x8b,0xb4,0xbd,0xa6,0xaf,0xd8,0xd1,0xca,0xc3,0xfc,0xf5,0xee,0xe7,
0x3b,0x32,0x29,0x20,0x1f,0x16,0x0d,0x04,0x73,0x7a,0x61,0x68,0x57,0x5e,0x45,0x4c,
0xab,0xa2,0xb9,0xb0,0x8f,0x86,0x9d,0x94,0xe3,0xea,0xf1,0xf8,0xc7,0xce,0xd5,0xdc,
0x76,0x7f,0x64,0x6d,0x52,0x5b,0x40,0x49,0x3e,0x37,0x2c,0x25,0x1a,0x13,0x08,0x01,
0xe6,0xef,0xf4,0xfd,0xc2,0xcb,0xd0,0xd9,0xae,0xa7,0xbc,0xb5,0x8a,0x83,0x98,0x91,
0x4d,0x44,0x5f,0x56,0x69,0x60,0x7b,0x72,0x05,0x0c,0x17,0x1e,0x21,0x28,0x33,0x3a,
0xdd,0xd4,0xcf,0xc6,0xf9,0xf0,0xeb,0xe2,0x95,0x9c,0x87,0x8e,0xb1,0xb8,0xa3,0xaa,	
0xec,0xe5,0xfe,0xf7,0xc8,0xc1,0xda,0xd3,0xa4,0xad,0xb6,0xbf,0x80,0x89,0x92,0x9b,	
0x7c,0x75,0x6e,0x67,0x58,0x51,0x4a,0x43,0x34,0x3d,0x26,0x2f,0x10,0x19,0x02,0x0b,
0xd7,0xde,0xc5,0xcc,0xf3,0xfa,0xe1,0xe8,0x9f,0x96,0x8d,0x84,0xbb,0xb2,0xa9,0xa0,
0x47,0x4e,0x55,0x5c,0x63,0x6a,0x71,0x78,0x0f,0x06,0x1d,0x14,0x2b,0x22,0x39,0x30,
0x9a,0x93,0x88,0x81,0xbe,0xb7,0xac,0xa5,0xd2,0xdb,0xc0,0xc9,0xf6,0xff,0xe4,0xed,
0x0a,0x03,0x18,0x11,0x2e,0x27,0x3c,0x35,0x42,0x4b,0x50,0x59,0x66,0x6f,0x74,0x7d,	
0xa1,0xa8,0xb3,0xba,0x85,0x8c,0x97,0x9e,0xe9,0xe0,0xfb,0xf2,0xcd,0xc4,0xdf,0xd6,
0x31,0x38,0x23,0x2a,0x15,0x1c,0x07,0x0e,0x79,0x70,0x6b,0x62,0x5d,0x54,0x4f,0x46

Multiplicar por 11 (0xB):

0x00,0x0b,0x16,0x1d,0x2c,0x27,0x3a,0x31,0x58,0x53,0x4e,0x45,0x74,0x7f,0x62,0x69,
0xb0,0xbb,0xa6,0xad,0x9c,0x97,0x8a,0x81,0xe8,0xe3,0xfe,0xf5,0xc4,0xcf,0xd2,0xd9,
0x7b,0x70,0x6d,0x66,0x57,0x5c,0x41,0x4a,0x23,0x28,0x35,0x3e,0x0f,0x04,0x19,0x12,
0xcb,0xc0,0xdd,0xd6,0xe7,0xec,0xf1,0xfa,0x93,0x98,0x85,0x8e,0xbf,0xb4,0xa9,0xa2,
0xf6,0xfd,0xe0,0xeb,0xda,0xd1,0xcc,0xc7,0xae,0xa5,0xb8,0xb3,0x82,0x89,0x94,0x9f,
0x46,0x4d,0x50,0x5b,0x6a,0x61,0x7c,0x77,0x1e,0x15,0x08,0x03,0x32,0x39,0x24,0x2f,
0x8d,0x86,0x9b,0x90,0xa1,0xaa,0xb7,0xbc,0xd5,0xde,0xc3,0xc8,0xf9,0xf2,0xef,0xe4,
0x3d,0x36,0x2b,0x20,0x11,0x1a,0x07,0x0c,0x65,0x6e,0x73,0x78,0x49,0x42,0x5f,0x54,
0xf7,0xfc,0xe1,0xea,0xdb,0xd0,0xcd,0xc6,0xaf,0xa4,0xb9,0xb2,0x83,0x88,0x95,0x9e,
0x47,0x4c,0x51,0x5a,0x6b,0x60,0x7d,0x76,0x1f,0x14,0x09,0x02,0x33,0x38,0x25,0x2e,
0x8c,0x87,0x9a,0x91,0xa0,0xab,0xb6,0xbd,0xd4,0xdf,0xc2,0xc9,0xf8,0xf3,0xee,0xe5,
0x3c,0x37,0x2a,0x21,0x10,0x1b,0x06,0x0d,0x64,0x6f,0x72,0x79,0x48,0x43,0x5e,0x55,
0x01,0x0a,0x17,0x1c,0x2d,0x26,0x3b,0x30,0x59,0x52,0x4f,0x44,0x75,0x7e,0x63,0x68,
0xb1,0xba,0xa7,0xac,0x9d,0x96,0x8b,0x80,0xe9,0xe2,0xff,0xf4,0xc5,0xce,0xd3,0xd8,
0x7a,0x71,0x6c,0x67,0x56,0x5d,0x40,0x4b,0x22,0x29,0x34,0x3f,0x0e,0x05,0x18,0x13,
0xca,0xc1,0xdc,0xd7,0xe6,0xed,0xf0,0xfb,0x92,0x99,0x84,0x8f,0xbe,0xb5,0xa8,0xa3

Multiplicar por 13 (0xD):

0x00,0x0d,0x1a,0x17,0x34,0x39,0x2e,0x23,0x68,0x65,0x72,0x7f,0x5c,0x51,0x46,0x4b,
0xd0,0xdd,0xca,0xc7,0xe4,0xe9,0xfe,0xf3,0xb8,0xb5,0xa2,0xaf,0x8c,0x81,0x96,0x9b,
0xbb,0xb6,0xa1,0xac,0x8f,0x82,0x95,0x98,0xd3,0xde,0xc9,0xc4,0xe7,0xea,0xfd,0xf0,
0x6b,0x66,0x71,0x7c,0x5f,0x52,0x45,0x48,0x03,0x0e,0x19,0x14,0x37,0x3a,0x2d,0x20,
0x6d,0x60,0x77,0x7a,0x59,0x54,0x43,0x4e,0x05,0x08,0x1f,0x12,0x31,0x3c,0x2b,0x26,
0xbd,0xb0,0xa7,0xaa,0x89,0x84,0x93,0x9e,0xd5,0xd8,0xcf,0xc2,0xe1,0xec,0xfb,0xf6,
0xd6,0xdb,0xcc,0xc1,0xe2,0xef,0xf8,0xf5,0xbe,0xb3,0xa4,0xa9,0x8a,0x87,0x90,0x9d,
0x06,0x0b,0x1c,0x11,0x32,0x3f,0x28,0x25,0x6e,0x63,0x74,0x79,0x5a,0x57,0x40,0x4d,
0xda,0xd7,0xc0,0xcd,0xee,0xe3,0xf4,0xf9,0xb2,0xbf,0xa8,0xa5,0x86,0x8b,0x9c,0x91,
0x0a,0x07,0x10,0x1d,0x3e,0x33,0x24,0x29,0x62,0x6f,0x78,0x75,0x56,0x5b,0x4c,0x41,
0x61,0x6c,0x7b,0x76,0x55,0x58,0x4f,0x42,0x09,0x04,0x13,0x1e,0x3d,0x30,0x27,0x2a,
0xb1,0xbc,0xab,0xa6,0x85,0x88,0x9f,0x92,0xd9,0xd4,0xc3,0xce,0xed,0xe0,0xf7,0xfa,
0xb7,0xba,0xad,0xa0,0x83,0x8e,0x99,0x94,0xdf,0xd2,0xc5,0xc8,0xeb,0xe6,0xf1,0xfc,
0x67,0x6a,0x7d,0x70,0x53,0x5e,0x49,0x44,0x0f,0x02,0x15,0x18,0x3b,0x36,0x21,0x2c,
0x0c,0x01,0x16,0x1b,0x38,0x35,0x22,0x2f,0x64,0x69,0x7e,0x73,0x50,0x5d,0x4a,0x47,
0xdc,0xd1,0xc6,0xcb,0xe8,0xe5,0xf2,0xff,0xb4,0xb9,0xae,0xa3,0x80,0x8d,0x9a,0x97

Multiplicar por 14 (0xE):

0x00,0x0e,0x1c,0x12,0x38,0x36,0x24,0x2a,0x70,0x7e,0x6c,0x62,0x48,0x46,0x54,0x5a,
0xe0,0xee,0xfc,0xf2,0xd8,0xd6,0xc4,0xca,0x90,0x9e,0x8c,0x82,0xa8,0xa6,0xb4,0xba,
0xdb,0xd5,0xc7,0xc9,0xe3,0xed,0xff,0xf1,0xab,0xa5,0xb7,0xb9,0x93,0x9d,0x8f,0x81,
0x3b,0x35,0x27,0x29,0x03,0x0d,0x1f,0x11,0x4b,0x45,0x57,0x59,0x73,0x7d,0x6f,0x61,
0xad,0xa3,0xb1,0xbf,0x95,0x9b,0x89,0x87,0xdd,0xd3,0xc1,0xcf,0xe5,0xeb,0xf9,0xf7,
0x4d,0x43,0x51,0x5f,0x75,0x7b,0x69,0x67,0x3d,0x33,0x21,0x2f,0x05,0x0b,0x19,0x17,
0x76,0x78,0x6a,0x64,0x4e,0x40,0x52,0x5c,0x06,0x08,0x1a,0x14,0x3e,0x30,0x22,0x2c,
0x96,0x98,0x8a,0x84,0xae,0xa0,0xb2,0xbc,0xe6,0xe8,0xfa,0xf4,0xde,0xd0,0xc2,0xcc,
0x41,0x4f,0x5d,0x53,0x79,0x77,0x65,0x6b,0x31,0x3f,0x2d,0x23,0x09,0x07,0x15,0x1b,
0xa1,0xaf,0xbd,0xb3,0x99,0x97,0x85,0x8b,0xd1,0xdf,0xcd,0xc3,0xe9,0xe7,0xf5,0xfb,
0x9a,0x94,0x86,0x88,0xa2,0xac,0xbe,0xb0,0xea,0xe4,0xf6,0xf8,0xd2,0xdc,0xce,0xc0,
0x7a,0x74,0x66,0x68,0x42,0x4c,0x5e,0x50,0x0a,0x04,0x16,0x18,0x32,0x3c,0x2e,0x20,
0xec,0xe2,0xf0,0xfe,0xd4,0xda,0xc8,0xc6,0x9c,0x92,0x80,0x8e,0xa4,0xaa,0xb8,0xb6,
0x0c,0x02,0x10,0x1e,0x34,0x3a,0x28,0x26,0x7c,0x72,0x60,0x6e,0x44,0x4a,0x58,0x56,
0x37,0x39,0x2b,0x25,0x0f,0x01,0x13,0x1d,0x47,0x49,0x5b,0x55,0x7f,0x71,0x63,0x6d,
0xd7,0xd9,0xcb,0xc5,0xef,0xe1,0xf3,0xfd,0xa7,0xa9,0xbb,0xb5,0x9f,0x91,0x83,0x8d

Referencias

• FIPS PUB 197: el estándar oficial AES ( archivo PDF )

Ver también

• Estándar de cifrado avanzado