AES-GCM查表原理

内容来源论文The Galois/Counter Mode of Operation(GCM)，本文主要根据第4.1章软件实现进行原理推导。

问题：已知 f = 1 + α + α² + α⁷ + α¹²⁸ 求 H · X，其中X、H都是128位的比特串

 

一、查表1

The operation H ·X is linear in the bits of X, over the field GF(2). This property can be exploited tomakeefficient table-driven implementations,in which tables computedforaparticular valueof H can be used to multiply H byan arbitrary elementX. The simplest method computes Z = X·H as

Z = M₀[byte(X, 0)] ⊕ M₁[byte(X, 1)] ⊕ ... ⊕ M₁₅[byte(X, 15)]

解释：实际上就是将 X 拆分成16个独立的操作进行查表。

X · H = (x₀ + x₁α + x₂α² + x₃α³ + ···· + x₁₂₆α¹²⁶ + x₁₂₇α¹²⁷) · H

=  (x₀ + x₁α + x₂α² + x₃α³ + ···· + x₇α⁷ + 0α⁸ + ··· + 0α¹²⁷) · H +

    (0 + 0α + ···· + 0α⁷ + x₈α⁸ + x₉α⁹ + ··· + x₁₅α¹⁵ + 0α¹⁶ + ··· + 0α¹²⁷) · H +

    ··· + 

 

    (0 + 0α + ···· + 0α¹¹⁹ + x₁₂₀α¹²⁰ + x₁₂₁α¹²¹ + ··· + x₁₂₇α¹²⁷) · H    -- 公式1

这样就可以转化为16次乘法 + 16次加法操作，对于每个乘法操作，由于只有1个字节不为0，所以我们可以预先遍历256种取值，对于每一个取值 x，计算 x · H。当后续需要时直接查表即可，因此可以转化为16次查表 + 16次加法操作。具体可以再配制密钥完成后，先计算出H，再进行预计算。

所需要的空间：16（表的数量）· 256（每张表中元素的个数）· 16（每个元素的字节数，为128比特） = 2⁴·2⁸·2⁴ = 64KBytes。

 

另外一种方法可以按照 4比特 拆分，因此一共需要32次查表 + 32次加法。

所需要的空间：32（表的数量）· 16（每张表中元素的个数）· 16（每个元素的字节数，为128比特） = 2⁵·2⁴·2⁴ = 8KBytes。

 

二、查表2

1、With a small increase in the amount of computation, we can reduce the storage requirements considerably, as describedby Shoup[9].We can use only the table M0 defined above to multiply an arbitrary element X ∈ GF(2¹²⁸) by H as follows.Wefirstexpresstheproductas

X · H = (x₀ + x₁α + x₂α² + x₃α³ + ···· + x₁₂₆α¹²⁶ + x₁₂₇α¹²⁷) · H

=  (x₀ + x₁α + x₂α² + x₃α³ + ···· + x₇α⁷ + 0α⁸ + ··· + 0α¹²⁷) · H +

    (0 + 0α + ···· + 0α⁷ + x₈α⁸ + x₉α⁹ + ··· + x₁₅α¹⁵ + 0α¹⁶ + ··· + 0α¹²⁷) · H +

    ··· + 

 

    (0 + 0α + ···· + 0α¹¹⁹ + x₁₂₀α¹²⁰ + x₁₂₁α¹²¹ + ··· + x₁₂₇α¹²⁷) · H

=  (x₀ + x₁α + x₂α² + x₃α³ + ···· + x₇α⁷ + 0α⁸ + ··· + 0α¹²⁷) · H +

    (0 + 0α + ···· + 0α⁷ + x₈α⁰ + x₉α¹ + ··· + x₁₅α⁷ + 0α¹⁶ + ··· + 0α¹²⁷) · α⁸ · H +

    ··· + 

 

    (0 + 0α + ···· + 0α¹¹⁹ + x₁₂₀α⁰ + x₁₂₁α¹ + ··· + x₁₂₇α⁷) · α¹²⁰ · H   -- 公式2

论文中转换后的算法如下

---

 算法1

---

 Z = 0

for i = 15 to 1 do
    Z = Z ⊕ (X_i · H)
    Z = Z · α⁸

end for

Z = Z ⊕ (X₀ · H)

return Z

---

 

2、解释：这里算法中的X_i分别对应16个字节（等价于x_i*8+0x_i*8+1x_i*8+2x_i*8+3x_i*8+4x_i*8+5x_i*8+6x_i*8+7）。

论文中对算法1进行了解释，但期初看起来可能比较费解。这里我们详细计算验证算法的等价性。

i = 15结束后：Z = X₁₅ · H · α⁸

i = 14结束后：Z = (X₁₅ · H · α⁸ ⊕ X₁₄ · H) · α⁸  

                          = X₁₅ · H · α¹⁶ ⊕ X₁₄ · H · α⁸ 

i = 13结束后：Z = (X₁₅ · H · α¹⁶ ⊕ X₁₄ · H · α⁸  ⊕  X₁₃ · H) · α⁸

                          = X₁₅ · H · α²⁴ ⊕ X₁₄ · H · α¹⁶  ⊕  X₁₃ · H · α⁸

···

i = 1结束后：Z = X₁₅ · H · α¹²⁰ ⊕ X₁₄ · H · α¹¹²  ⊕  X₁₃ · H · α¹⁰⁴ ⊕ ··· ⊕ X₂ · H · α¹⁶ ⊕  X₁ · H · α⁸

算法结束后：Z = X₁₅ · H · α¹²⁰ ⊕ X₁₄ · H · α¹¹²  ⊕  X₁₃ · H · α¹⁰⁴ ⊕ ··· ⊕ X₂ · H · α¹⁶ ⊕  X₁ · H · α⁸ ⊕  X₀ · H  -- 公式3

以比特串的形式表示，我们可以发现公式3和公式2是等价的，因此可以证明算法1是正确的。

 

3、算法1的求解

1）X_i · H 可以通过查表得到，其中 X_i 只有第1个字节不为0，其余120比特全为0，因此我们只需要遍历256种情况即可。16次查表操作均可以只使用1个表格，再通过移位实现。

2）Z ⊕ (X_i · H)对应的二进制比特串将不再是只有第1个字节不为0，重点求解 Z = Z · α⁸

Z = Z · α⁸

= Z · α · α⁷

= ((Z >> 1) ⊕ x₁₂₇R) ·  α⁷ （其中，R = 0xe1000···0，高 8 比特为 e1，后 120 比特为全 0；x₁₂₇R 表示若 Z 的第 127 比特为 0，则 x₁₂₇R 为 0，否则为 R ）

= (Z' ⊕ x₁₂₇R) ·  α⁷ （记 Z' 表示 Z 右移 1 位）

= (Z' ⊕ x₁₂₇R) · α · α⁶

= ((Z' ⊕ x₁₂₇R)' ⊕ x₁₂₇R) · α⁶

= ((Z'' ⊕ x₁₂₇R' ⊕ x₁₂₆R) · α⁶

= ((Z''' ⊕ x₁₂₇R'' ⊕ x₁₂₆R' ⊕ x₁₂₅R) · α⁵

···

= Z'''''''' ⊕ x₁₂₇R''''''' ⊕ x₁₂₆R'''''' ⊕ x₁₂₅R'''''⊕ ···⊕ x₁₂₀R  -- 公式4

其中 Z'''''''' 可以直接通过循环右移 8 比特得到；对于x₁₂₇R''''''' ⊕ x₁₂₆R'''''' ⊕ x₁₂₅R'''''⊕ ···⊕ x₁₂₀R，由于 R 本身是常量，因此我们可以遍历 x₁₂₇、x₁₂₆、 x₁₂₅ 、···、 x₁₂₀ 共256种取值进行预计算，最终通过查表得到实际结果。

所需要的空间：1（X_i · H 表的数量，只对第1个字节预计算）· 256（每张表中 X_i 取值的情况）· 16（每个结果的字节数，为128比特）+ 1（R表的数量）· 256 (x₁₂₇、x₁₂₆、 x₁₂₅ 、···、 x₁₂₀ 256种取值）+ 2（由于R只有最高8比特非0，最多右移8次，因此只需要16比特即可表示） = 4KBytes + 512 Bytes。

 

同理，若按照 4比特 拆分，所需要的空间：1（X_i · H 表的数量，只对 x₀x₁x₂x₃ 预计算）· 16（每张表中  x₀x₁x₂x₃  取值的情况）· 16（每个结果的字节数，为128比特）+ 1（R表的数量）· 16 (x₁₂₇、x₁₂₆、x₁₂₅、x₁₂₄ 共16种取值）+ 2（由于R只有最高8比特非0，最多右移8次，因此只需要16比特即可表示） = 256Bytes + 32 Bytes。

 

3）这里给出按照 4比特 拆分时，R表的构造方法。8 比特拆分的计算方法同理

根据公式4，可以容易的推导出

Z = Z · α⁴

   = Z'''' ⊕ x₁₂₇R''' ⊕ x₁₂₆R'' ⊕ x₁₂₅R'⊕ ···⊕ x₁₂₄R  -- 公式5

x₁₂₄ x₁₂₅ x₁₂₆ x₁₂₇   结果

0     0      0      0        0

0     0      0      1        R''' = 0xe1 >> 3 = 0x1c20

0     0      1      0        R'' = 0xe1 >> 2 = 0x3840

0     0      1      1        R''' ⊕ R'' = 0x1c20 ⊕ 0x3840 = 0x2460

0     1      0      0        R' = 0xe1 >> 1 = 0x7080

0     1      0      1        R''' ⊕ R' = 0x1c20 ⊕ 0x7080 = 0x6ca0

0     1      1      0        R'' ⊕ R' = 0x3840 ⊕ 0x7080 = 0x48c0

0     1      1      1        R''' ⊕ R'' ⊕ R' = 0x2460 ⊕ 0x7080= 0x54e0

1     0      0      0        R = 0xe100

1     0      0      1        R''' ⊕ R = 0x1c20 ⊕ 0xe100 = 0xfd20

1     0      1      0        R'' ⊕ R = 0x3840 ⊕ 0xe100  = 0xd940

1     0      1      1        R''' ⊕ R'' ⊕ R= 0x2460 ⊕ 0xe100  = 0xc560

1     1      0      0        R' ⊕ R = 0x7080 ⊕ 0xe100 = 0x9180

1     1      0      1        R''' ⊕ R' ⊕ R = 0x6ca0 ⊕ 0xe100 = 0x8da0

1     1      1      0        R''⊕ R' ⊕ R = 0x48c0 ⊕ 0xe100 = 0xa9c0

1     1      1      1        R''' ⊕ R'' ⊕ R' ⊕ R = 0x54e0 ⊕ 0xe100  = 0xb5e0

4)  8 bit Table

#include <stdio.h>
#include <stdint.h>

static uint16_t right[8] = {
        0xe100, 0x7080, 0x3840, 0x1c20, 0x0e10, 0x0708, 0x0384, 0x01c2
};

int main (void)
{
        int i, j;
        uint8_t value, tmp;
        uint16_t last8[256];
        uint16_t res;

        for (i = 0, value = 0; i < 256; ++i, ++value)
        {
                res = 0;
                tmp = value;
                j = 0;

                while (tmp != 0)
                {
                        if (0x80 & tmp) {
                                res ^= right[j];
                        }
                        tmp = tmp << 1;
                        j++;
                }
                last8[i] = res;
        }

        for (i = 0; i < 256; ++i)
        {
                if (i % 8 == 0 && i != 0)
                {
                        printf("\n");
                }
                printf("0x%4x, ", last8[i]);
        }

        return 0;
}