AES.tex

\section{Американский стандарт шифрования AES}
\selectlanguage{russian}

До 2001 г. американским стандартом шифрования данных был DES (аббревиатура от Data Encryption Standard), который принят в 1980 году. Входной блок открытого текста и выходной блок шифрованного текста DES составляли по 64 бита каждый, длина ключа 56 бит (до процедуры расширения). Алгоритм основан на ячейке Фейстеля с $s$-блоками и таблицами расширения и перестановки бит. Количество раундов -- 16.

Для повышения криптостойкости и замены стандарта DES был объявлен конкурс на новый стандарт AES (аббревиатура от Advanced Encryption Standard). Победителем конкурса стал шифр Rijndael. Название составлено с использованием первых слогов фамилий его создателей (Rijmen and Daemen). В русскоязычном варианте читается как <<Рейндолл>>. Стандарт утвержден в ноябре 2001 г.

AES -- это итеративный блочный шифр с переменной длиной ключа (128, 192 или 256 бит) и фиксированной длиной входного и выходного блоков (128 бит).


\subsection[Состояние, ключ шифрования и число раундов]{Состояние, ключ шифрования и число \protect\\ раундов}

Различные преобразования воздействуют на результат промежуточного шифрования, называемый \textit{состоянием} ($\mathsf{State}$). Состояние представлено $(4 \times 4)$-матрицей из байтов.

\textit{Ключ шифрования раунда} ($\mathsf{Key}$) также представляется прямоугольной $(4 \times \mathsf{Nk})$-матрицей из байтов $k_{i,j}$, где $\mathsf{Nk}$ равно длине ключа, разделенной на 32, то есть 4, 6 или 8.

Эти представления приведены ниже.
\[
    \mathsf{State} = \left[ \begin{array}{cccc}
        a_{0,0} & a_{0,1} & a_{0,2} & a_{0,3} \\
        a_{1,0} & a_{1,1} & a_{1,2} & a_{1,3} \\
        a_{2,0} & a_{2,1} & a_{2,2} & a_{2,3} \\
        a_{3,0} & a_{3,1} &a_{3,2} & a_{3,3}  \\
    \end{array} \right],
\] \[
    \mathsf{Key} = \left[ \begin{array}{cccc}
        k_{0,0} & k_{0,1} & k_{0,2} & k_{0,3} \\
        k_{1,0} & k_{1,1} & k_{1,2} & k_{1,3} \\
        k_{2,0} & k_{2,1} & k_{2,2} & k_{2,3} \\
        k_{3,0} & k_{3,1} & k_{3,2} & k_{3,3} \\
    \end{array} \right].
\]

Иногда, блоки символов интерпретируются как одномерные последовательности из 4-байтовых векторов, где каждый вектор является соответствующим столбцом прямоугольной таблицы. В этих случаях таблицы можно рассматривать как наборы из 4, 6 или 8 векторов, нумеруемых в диапазоне $0 \dots 3, 0 \dots 5$ или $0 \dots 7$. Сами 4-байтовые векторы называют словами. В тех случаях, когда нужно пометить индивидуальный байт внутри 4-байтового вектора или слова, используется обозначение $(a, b, c, d)$, где $a, b, c, d$ соответствуют байтам в одной из позиций $0, 1, 2, 3$ в столбце, векторе или слове.

\textit{Входные} и \textit{выходные} блоки шифра AES рассматриваются как последовательности 16 байтов $(a_0, a_1, \dots, a_{15})$. Преобразование входного блока $(a_0, \dots, a_{15})$ в исходную $(4 \times 4)$ матрицу состояния $\mathsf{State}$ или конечной матрицы состояния в выходную последовательность проводится по правилу (запись по столбцам):
    \[ a_{i,j} = a_{i + 4j}, ~ i = 0 \dots 3, ~ j = 0 \dots 3. \]

Аналогично ключ шифрования  может рассматриваться как последовательность байтов $(k_0, k_1, \dots, k_{4 \cdot \mathsf{Nk} - 1})$, где $\mathsf{Nk} = 4, 6, 8$. Число байтов в этой последовательности равно 16, 24 или 32. Соответственно номера этих байтов находятся в интервалах $0 \dots 15, ~ 0 \dots 23$ или $0 \dots 31$. $(4 \times \mathsf{Nk})$-матрица ключа шифрования $\mathsf{Key}$ задается по правилу:
    \[ k_{i,j} = k_{i + 4j}, ~ i = 0 \dots 3, ~ j = 0 \dots \mathsf{Nk} - 1. \]

Число раундов $\mathsf{Nr}$ зависит от длины ключа. Его значения приведены в таблице ниже.

\begin{center}
    \begin{tabular}{|l|c|c|c|}
    \hline
    Длина ключа, биты           &128 & 192 & 256 \\
    $\mathsf{Nk}$               & 4  & 6   & 8 \\
    Число раундов $\mathsf{Nr}$ & 10 & 12 & 14 \\
    \hline
    \end{tabular}
\end{center}


\subsection{Операции в поле}

При переходе от одного раунда к другому матрицы \textit{состояния} и \textit{ключа шифрования раунда} подвергаются ряду преобразований. Преобразования могут осуществляться над:
\begin{itemize}
    \item отдельными байтами или парами байтов (необходимо определить операции сложения и умножения);
    \item столбцами матрицы, которые рассматриваются как 4-мерные векторы с соответствующими байтами в качестве элементов;
    \item строками матрицы.
\end{itemize}

В алгоритме шифрования AES байты рассматриваются как элементы поля $\GF{2^8}$, а вектор-столбцы из четырех байтов -- как многочлены третьей степени над полем $\GF{2^8}$. В Приложении \ref{chap:discrete-math} дано подробное описание этих операций.

\subsubsection{Сложение и умножение байтов}

Байты $a_1$ и $a_2$,  как элементы поля Галуа $\GF{2^8}$, представлены многочленами 7-ой степени $a_1(x)$ и $a_2(x)$ с двоичными коэффициентами. Сложение байтов выполняется как сложение многочленов $a_1(x) + a_2(x)$ в поле $\GF{2}$. Умножение байта $a_1(x)$ на байт $a_2(x)$ в поле $\GF{2^8}$ производится по модулю неприводимого многочлена
    \[ m(x) = x^{8} + x^{4} + x^{3} + x + 1. \]

\subsubsection{Сложение и умножение вектор-столбцов из байтов}

Следующий тип операций -- это операции над столбцами матриц. Вектор-столбец $\mathbf{a}$, состоящий из байтов $(a_0, a_1, a_2, a_3)$, интерпретируется как многочлен третьей степени $\mathbf{a}(y)$ над полем $\GF{2^8}$, то есть
    \[ \mathbf{a}(y) = a_3 y^{3} + a_2 y^{2} + a_1 y + a_0, ~ a_i \in \GF{2^8}. \]

Сложение двух векторов $\mathbf{a}_1$ и $\mathbf{a}_2$ из 4 байтов определяется как сложение многочленов $\mathbf{a}_1(y) + \mathbf{a}_2(y)$ на полем $\GF{2^8}$. Умножение вектора $\mathbf{a}_1$ на вектор $\mathbf{a}_2$ задано как умножение многочлена $\mathbf{a}_1(y)$ на  многочлен $\mathbf{a}_2(y)$ над полем $\GF{2^8}$ по модулю многочлена
    \[ \mathbf{M}(y)= \mathrm{'01'} y^4 + \mathrm{'01'} = y^4 + 1, ~ \mathrm{'01'}=1 \in \GF{2^8}, \]
    \[ \mathbf{M}(y)= (01, 00, 00, 01), \]
который не является неприводимым над $\GF{2^8}$.  Чтобы подчеркнуть, что коэффициенты многочлена являются элементами поля $\GF{2^8}$, используется нотация из описания алгоритма в виде значений байтов в 16-ричной системе в кавычках, например $\mathrm{'01'}$.

Операция умножения по этому модулю обозначается как $\otimes$:
    \[ \mathbf{a}_1(y) ~ \mathbf{a}_2(y) \mod \mathbf{M}(y) \equiv \mathbf{a}_1(y) \otimes \mathbf{a}_2(y). \]

Третий тип операции <<Перемешивание столбца>> состоит в умножении многочлена вектора-столбца из 4 байтов на многочлен
    \[ \mathbf{c}(y) = (03, 01, 01, 02) = \mathrm{'03'} y^3 + \mathrm{'01'} y^2 + \mathrm{'01'} y + \mathrm{'02'} \]
по модулю $\mathbf{M}(y)$. Для многочлена  $\mathbf{c}(y)$ существует обратный многочлен
    \[ \mathbf{d}(y) = \mathbf{c}^{-1}(y) \mod \mathbf{M}(y) = (0B, 0D, 09, 0E) = \]
        \[ = \mathrm{'0B'} y^3 + \mathrm{'0D'} y^2 + \mathrm{'09'} y + \mathrm{'0E'}, \]
    \[ \mathbf{c}(y) \otimes \mathbf{d}(y) = (00, 00, 00, 01) = 1. \]
Многочлен $\mathbf{d}(y)$ используется вместо $\mathbf{c}(y)$ при расшифровании.


\subsection{Операции одного раунда шифрования}

В каждом раунде шифра AES, кроме последнего раунда, производятся следующие 4 операции с использованием таблиц:

\begin{itemize}
  \item замена байтов, $\mathsf{SubBytes}$;
  \item сдвиг строк, $\mathsf{ShiftRows}$;
  \item перемешивание столбцов, $\mathsf{MixColumns}$;
  \item добавление текущего ключа, $\mathsf{AddRoundKey}$.
\end{itemize}
В последнем раунде исключается операция <<Перемешивание столбцов>>. В обозначениях, близких к языку С, можно записать программу в виде
\[
    \begin{array}{l}
        \mathsf{Round(State, RoundKey)} \{ \\
        ~~~~ \mathsf{SubBytes(State)}; \\
        ~~~~ \mathsf{ShiftRows(State)}; \\
        ~~~~ \mathsf{MixColumns(State)}; \\
        ~~~~ \mathsf{AddRoundKey(State, RoundKey)}; \\
        \} \\
    \end{array}
\]
Последний раунд слегка отличается и записан в виде
\[
    \begin{array}{l}
        \mathsf{Round(State, RoundKey)} \{ \\
        ~~~~ \mathsf{SubBytes(State)}; \\
        ~~~~ \mathsf{ShiftRows(State)}; \\
        ~~~~ \mathsf{AddRoundKey(State, RoundKey)}; \\
        \} \\
    \end{array}
\]
В этих обозначениях все <<функции>>, а именно, $\mathsf{Round}$, $\mathsf{SubBytes}$, $\mathsf{ShiftRows}$, $\mathsf{MixColumns}$, $\mathsf{AddRoundKey}$, воздействуют на матрицы, определяемые указателем $\mathsf{(State, RoundKey)}$. Сами преобразования описаны в следующих разделах.


\subsubsection{Замена байтов $\mathsf{SubBytes}$}

Нелинейная операция <<Замена байтов>> действует независимо на каждый байт $a_{i,j}$ текущего состояния. Таблица замены (или $s$-блок) является обратимой и формируется последовательным применением двух преобразований.

\begin{enumerate}
    \item Сначала байт $a$ представляется как элемент $a(x)$ поля Галуа $\GF{2^8}$ и заменяется на обратный элемент $a^{-1} \equiv a^{-1}(x)$ в поле. Байт $\mathrm{'00'}$, для которого обратного элемента не существует, переходит сам в себя.
    \item Затем к обратному байту $a^{-1} = (x_0, x_1, x_2, x_3, x_4, x_5, x_6, x_7)$ применяется аффинное преобразование над полем $\GF{2}$ следующего вида:
        \[
            \left[  \begin{array}{c}
                y_{0} \\ y_{1} \\ y_{2} \\ y_{3} \\ y_{4} \\ y_{5} \\ y_{6} \\ y_{7} \\
            \end{array} \right] = \left[ \begin{array}{cccccccc}
                1 & 0 & 0  & 0 & 1 & 1 & 1 & 1 \\
                1 & 1 & 0  & 0 & 0 & 1 & 1 & 1 \\
                1 & 1 & 1  & 0 & 0 & 0 & 1 & 1 \\
                1 & 1 & 1  & 1 & 0 & 0 & 0 & 1 \\
                1 & 1 & 1  & 1 & 1 & 0 & 0 & 0 \\
                0 & 1 & 1  & 1 & 1 & 1 & 0 & 0 \\
                0 & 0 & 1  & 1 & 1 & 1 & 1 & 0 \\
                0 & 0 & 0  & 1 & 1 & 1 & 1 & 1  \
            \end{array} \right] \cdot \left[ \begin{array}{c}
                x_{0} \\ x_{1} \\ x_{2} \\ x_{3} \\ x_{4} \\ x_{5} \\ x_{6} \\ x_{7} \\
            \end{array} \right] + \left[ \begin{array}{c}
                1 \\ 1 \\ 0 \\ 0 \\ 0 \\ 1 \\ 1 \\ 0 \\
            \end{array} \right].
        \]
\end{enumerate}

В полиномиальном представлении это аффинное преобразование имеет вид:
\[Y(z)=(z^4)X(z)(1+z+z^2+z^3+z^4)\mod(1+z^8) + F(z).\]
Применение описанных операций $s$-блока ко всем байтам текущего состояния обозначено
    \[ \mathsf{SubBytes(State)}. \]

Обращение операции $\mathsf{SubBytes(State)}$ также является заменой байтов. Сначала выполняется обратное аффинное преобразование, а затем от полученного байта берется обратный.


\subsubsection{Сдвиг строк $\mathsf{ShiftRows}$}

Для выполнения операции <<Сдвиг строк>> строки в таблице текущего состояния циклически сдвигаются влево. Величина сдвига различна для различных строк. Строка $0$ не сдвигается вообще. Строка $1$ сдвигается на $C_1=1$ позицию, строка $2$ –- на $C_2=2$ позиции, строка $3$ -– на $C_3=3$ позиции.
%Величины $C1,C2$ и $C3$ зависят от $Nb$. Их значения приведены в табл. \ref{tab:AES-shift-rows}.
%
%\begin{table}[h!]
%    \centering
%    \begin{tabular}{|c|c|c|c|}
%        \hline
%        Nb & C1 & C2 & C3 \\
%        \hline
%        4  & 1  & 2  & 3  \\
%        \hline
%        6  & 1  & 2  & 3  \\
%        \hline
%        8  & 1  & 3  & 4  \\
%        \hline
%    \end{tabular}
%    \caption{Сдвиг $C$ и длина блока $Nb$.}
%    \label{tab:AES-shift-rows}
%\end{table}


\subsubsection{Перемешивание столбцов $\mathsf{Mix Columns}$}

При выполнении операции <<Перемешивание столбцов>> столбцы матрицы текущего состояния рассматриваются как многочлены над полем $\GF{2^8}$ и умножаются по модулю многочлена $y^4 +1$ на фиксированный многочлен $\mathbf{c}(y)$, где
    \[ \mathbf{c}(y) = \mathrm{'03'} y^3 + \mathrm{'01'} y^2 + \mathrm{'01'} y + \mathrm{'02'}. \]
Этот многочлен взаимно прост с многочленом $y^4 + 1$ и, следовательно, обратим. Перемножение удобнее проводить в матричном виде. Если $\mathbf{b}(y) = \mathbf{c}(y) \otimes \mathbf{a}(y)$, то
\[
    \left[ \begin{array}{c}
        b_{0} \\ b_{1} \\ b_{2} \\ b_{3} \\
    \end{array}\right] =  \left[ \begin{array}{cccc}
        \mathrm{'02'} & \mathrm{'03'} & \mathrm{'01'} & \mathrm{'01'} \\
        \mathrm{'01'} & \mathrm{'02'} & \mathrm{'03'} & \mathrm{'01'} \\
        \mathrm{'01'} & \mathrm{'01'} & \mathrm{'02'} & \mathrm{'03'} \\
        \mathrm{'03'} & \mathrm{'01'} & \mathrm{'01'} & \mathrm{'02'} \\
    \end{array} \right] \cdot \left[ \begin{array}{c}
        a_{0} \\ a_{1} \\ a_{2} \\ a_{3} \\
     \end{array} \right].
\]

Обратная операция состоит в умножении на многочлен $\mathbf{d}(y)$, обратный многочлену $\mathbf{c}(y)$ по модулю $y^4 + 1$, то есть
\[
    (\mathrm{'03'} y^{3} + \mathrm{'01'} y^{2} + \mathrm{'01'} y + \mathrm{'02'}) \otimes \mathbf{d}(y) = \mathrm{'01'}.
\]
Этот многочлен равен
\[
    \mathbf{d}(y) = \mathrm{'0B'} y^3 + \mathrm{'0D'} y^2 + \mathrm{'09'} y + \mathrm{'0E'}.
\]


\subsubsection{Добавление ключа раунда $\mathsf{AddRoundKey}$}

Операция <<Добавление ключа раунда>> состоит в том, что к матрице текущего состояния добавляется по модулю $2$ матрица ключа текущего раунда. Обе матрицы должны иметь одинаковые размеры. Матрица ключа раунда вычисляется с помощью процедуры \emph{расширения ключа}, описанной ниже. Операция <<Добавление ключа раунда>> обозначается $\mathsf{AddRoundKey(State, RoundKey)}$.

\[
    \left[ \begin{array}{cccc}
        a_{0,0} & a_{0,1} & a_{0,2} & a_{0,3} \\
        a_{1,0} & a_{1,1} & a_{1,2} & a_{1,3} \\
        a_{2,0} & a_{2,1} & a_{2,2} & a_{2,3} \\
        a_{3,0} & a_{3,1} & a_{3,2} & a_{3,3}
    \end{array} \right]
    \oplus
    \left[ \begin{array}{cccc}
        k_{0,0} & k_{0,1} & k_{0,2} & k_{0,3} \\
        k_{1,0} & k_{1,1} & k_{1,2} & k_{1,3} \\
        k_{2,0} & k_{2,1} & k_{2,2} & k_{2,3} \\
        k_{3,0} & k_{3,1} & k_{3,2} & k_{3,3}
    \end{array} \right] =
\] \[
    = \left[ \begin{array}{cccc}
        b_{0,0} & b_{0,1} & b_{0,2} & b_{0,3} \\
        b_{1,0} & b_{1,1} & b_{1,2} & b_{1,3} \\
        b_{2,0} & b_{2,1} & b_{2,2} & b_{2,3} \\
        b_{3,0} & b_{3,1} & b_{3,2} & b_{3,3}
    \end{array} \right].
\]


\subsection{Процедура расширения ключа}

Матрица ключа текущего раунда получается из исходного ключа шифра с помощью специальной процедуры, состоящей из расширения ключа и выбора раундового ключа. Основные принципы этой процедуры состоят в следующем.
\begin{itemize}
    \item Суммарная длина ключей всех раундов равна длине блока, умноженной на увеличенное на 1 число раундов. Для блока длины 128 бит и 10 раундов общее длина всех ключей раундов равна 1408.
    \item С помощью ключа шифра находят \textit{расширенный ключ}.
    \item Ключи \emph{раунда} выбираются из \emph{расширенного} ключа по правилу: ключ первого раунда состоит из первых 4-х столбцов матрицы расширенного ключа, второй ключ –- из следующих 4-х столбцов и т.д.
\end{itemize}

Расширенный ключ –- это матрица $\mathsf{W}$, состоящая из $4 \cdot (\mathsf{Nr} + 1)$ 4-байтовых вектор-столбцов, каждый столбец $i$ обозначается $\mathsf{W}[i]$.

Далее рассматривается только случай, когда ключ шифра состоит из $16$ байтов. Первые $\mathsf{Nk} = 4$ столбцов содержат ключ шифра. Остальные столбцы вычисляются рекурсивно из столбцов с меньшими номерами.

Для $\mathsf{Nk} = 4$ имеем 16-байтовый ключ
\[
    \mathsf{Key} = (\mathsf{Key}[0], \mathsf{Key}[1], \dots, \mathsf{Key}[15]).
\]
Приведем алгоритм расширения ключа для $\mathsf{Nk} = 4$.
\begin{algorithm}[iht]
    \caption{$\mathsf{KeyExpansion}(\mathsf{Key}, \mathsf{W})$\label{alg:AES-key-exp}}
    \begin{algorithmic}
        \FOR{ $i=0$ \TO $\mathsf{Nk} - 1$}
            \STATE $\mathsf{W}[i] = (\mathsf{Key}[4i], ~ \mathsf{Key}[4i+1], ~ \mathsf{Key}[4i+2], ~ \mathsf{Key}[4i+3])^T$;
        \ENDFOR
        \FOR{ $i = \mathsf{Nk}$ \TO $4 \cdot (\mathsf{Nr} + 1) - 1$}
            \STATE $\mathsf{temp} = \mathsf{W}[i-1]$;
            \IF{ ($i = 0 \mod \mathsf{Nk}$)}
                \STATE $\mathsf{temp} = \mathsf{SubWord}(\mathsf{RotWord}(\mathsf{temp})) ~ \oplus ~ \mathsf{Rcon}[i / \mathsf{Nk}]$;
            \ENDIF
            \STATE $\mathsf{W}[i] = \mathsf{W}[i - \mathsf{Nk}] ~ \oplus ~ \mathsf{temp}$;
        \ENDFOR
    \end{algorithmic}
\end{algorithm}

%\[
%    \begin{array}{l}
%        \mathsf{KeyExpansion}(\mathsf{Key}, \mathsf{W}) \{ \\
%        ~~~~ \mathsf{for ~ (i = 0; ~ i < Nk = 4; ~ i++)} \\
%        ~~~~~~~~ \mathsf{W[i] = (Key[4 \cdot i], ~ Key[4*i+1], ~ Key[4*i+2], ~ Key[4*i+3]);} \\
%        ~~~~ \mathsf{for ~ (i = Nk; ~ i < 4 * (Nr + 1); ~ i++)} ~ \{ \\
%        ~~~~~~~~ \mathsf{temp = W[i-1];} \\
%        ~~~~~~~~ \mathsf{if ~ (i ~ \% ~ Nk ~ == ~ 0)} \\
%        ~~~~~~~~~~~~ \mathsf{temp = SubWord(RotWord(temp))} ~ \oplus ~ \mathsf{Rcon[i / Nk];} \\
%        ~~~~~~~~ \mathsf{W[i] = W[i - Nk]} ~ \oplus ~ \mathsf{temp;} \\
%        ~~~~ \} \\
%        \} \\
%    \end{array}
%\]

Здесь $\mathsf{SubWord}(\mathsf{W})[i]$ обозначает функцию, которая применяет операцию <<Замена байтов>> (или s-блок) $\mathsf{SubBytes}$ к каждому из 4-х байтов столбца $\mathsf{W}[i]$. Функция $\mathsf{RotWord}(\mathsf{W}[i])$  осуществляет циклический сдвиг вверх байтов столбца $\mathsf{W}[i]$: если $\mathsf{W}[i] = (a, b, c, d)^T$, то $\mathsf{RotByte}(\mathsf{W}[i]) = (b, c, d, a)^T$. Векторы-константы $\mathsf{Rcon}[i]$ определены ниже.

Как видно из этого описания, первые $\mathsf{Nk} = 4$ столбцов заполняются ключом шифра. Все следующие столбцы $\mathsf{W}[i]$ равны сумме по модулю 2  предыдущего столбца $\mathsf{W}[i-1]$ и столбца $\mathsf{W}[i-4]$. Для столбцов $\mathsf{W}[i]$ с номерами $i$, кратными $\mathsf{Nk} = 4$, к столбцу $\mathsf{W}[i-1]$ применяются операции $\mathsf{RotWord(W)}$ и $\mathsf{SubWord(W)}$, а затем производится суммирование по модулю 2 со столбцом $\mathsf{W}[i-4]$ и константой раунда $\mathsf{Rcon}[i ~/~ 4]$.

%Для $\mathsf{Nk}>6$ имеем
%\[
%\begin{array}{l}
% \mathsf{KeyExpansion\,(byte\,Key\,[4*Nk]\,\, word \,\, W[Nb*(Nr+1)])}\\
%  \{\\
% \quad\quad \mathsf{for\,\,(i=0;\,\, i<Nk;\,\,i++)} \\
%  \qquad \quad\quad\quad \mathsf{W[i]=(Key[4*i];Key[4*i+1];Key[4*i+2];Key[4*i+3]);}\\
%  \quad\quad \mathsf{for \,\,(i=Nk;\,\,i<Nb*(Nr+1);\,\,i++)}\\
%  \quad\quad \{ \\
%  \quad \quad\quad\quad \mathsf{temp=W[i-1]}; \\
%  \quad \quad\quad\quad \mathsf{if\,\,(i\quad\% \quad Nk==0)}\\
%  \qquad \qquad \qquad \quad \mathsf{temp=SubByte(RotByte(temp))\quad\widehat{\,}\quad Rcon[i/Nk]};\\
%\quad \quad\quad\quad \mathsf{else \,\,if\,\,(i\quad\% \quad Nk==4)}\\
% \qquad \qquad \qquad \quad \mathsf{temp=SubByte(temp)};\\
%  \quad \quad\quad\quad \mathsf{W[i]=W[i-Nk] \quad\widehat{\,}\quad temp};\\
%  \quad\quad \} \\
%  \}\, \\
%\end{array}
%\]
%Различие между этими двумя случаями состоит в том, что во втором случае к столбцу $\mathsf{W[i-1]}$ применяются операции
% $\mathsf{RotByte(W)}$ и $\mathsf{SubByte(W)}$, если $\mathsf{i-4}$ кратно $\mathsf{Nk}$.\\

Константы раундов определяются следующим образом:
    \[ \mathsf{Rcon}[i] = (\mathsf{RC}[i], \mathrm{'00'}, \mathrm{'00'}, \mathrm{'00'})^T, \]
где байт $\mathsf{RC}[1]$ равен $\mathsf{RC}[1] = \mathrm{'01'}$, а байты $\mathsf{RC}[i] = \alpha^{i-1}, ~ i = 2, 3, \dots$. Байт $\alpha = \mathrm{'02'}$ –- это примитивный элемент поля $\GF{2^8}$.

\example
Пусть $\mathsf{Nk} = 4$. В этом случае ключ шифра имеет длину 128 бит. Найдем столбцы расширенного ключа. Столбцы $\mathsf{W}[0], \mathsf{W}[1], \mathsf{W}[2], \mathsf{W}[3]$ непосредственно заполняются битами ключа шифра. Номер следующего столбца $\mathsf{W}[4]$ кратен $\mathsf{Nk}$, поэтому
\[
    \mathsf{W}[4] = \mathsf{SubWord}(\mathsf{RotWord}(\mathsf{W}[3])) \oplus \mathsf{W}[0] \oplus
        \left[ \begin{array}{c}
            \mathrm{'01'} \\ \mathrm{'00'} \\ \mathrm{'00'} \\ \mathrm{'00'} \\
        \end{array} \right].
\]
Далее имеем
\[
    \begin{array}{l}
        \mathsf{W}[5] = \mathsf{W}[4] \oplus \mathsf{W}[1], \\
        \mathsf{W}[6] = \mathsf{W}[5] \oplus \mathsf{W}[2], \\
        \mathsf{W}[7] = \mathsf{W}[6] \oplus \mathsf{W}[3].  \\
    \end{array}
\]
Затем
\[
    \mathsf{W}[8] = \mathsf{SubWord}(\mathsf{RotWord}(\mathsf{W}[7])) \oplus \mathsf{W}[4] \oplus
        \left[ \begin{array}{c}
            \alpha \\
            \mathrm{'00'}\\
            \mathrm{'00'}\\
            \mathrm{'00'}\\
        \end{array} \right] ,
\] \[
    \begin{array}{l}
        \mathsf{W}[9] = \mathsf{W}[8] \oplus \mathsf{W}[5], \\
        \mathsf{W}[10] = \mathsf{W}[9] \oplus \mathsf{W}[6], \\
        \mathsf{W}[11] = \mathsf{W}[10] \oplus \mathsf{W}[7] \\
    \end{array}
\]
и т.д.
\exampleend

%\example
%Пусть $\mathsf{Nk=6}.$ В этом случае ключ шифра имеет длину 192 бита. Найдем столбцы расширенного ключа. Столбцы $\mathsf{W[0],W[1],W[2],W[3],W[4],W[5]}$ непосредственно заполняются
%битами ключа шифра. Номер следующего столбца $\mathsf{W[6]}$ кратен $\mathsf{Nk}$, поэтому
%\[
%\begin{array}{ccccccc}
% \mathsf{W[6]} & = & \mathsf{SubByte(RotByte(W[5]))} &\oplus  &  \mathsf{W[0]} & \oplus  & \left[ \begin{array}{c}
% \mathsf{`01'} \\
%  \mathsf{`00'}\\
%  \mathsf{`00'}\\
%  \mathsf{`00'}\\
%\end{array}
%\right]    \\
%\end{array}
%\].
%
%Далее имеем
%\[
%\begin{array}{ccc}
% \mathsf{W[7]=W[6]}\oplus \mathsf{W[1]}; & \mathsf{W[8]=W[7]}\oplus \mathsf{W[2]}; & \mathsf{W[9]=W[8]}\oplus \mathsf{W[3]}; \\
% \mathsf{W[10]=W[9]}\oplus \mathsf{W[4]}; &\mathsf{ W[11]=W[10]}\oplus \mathsf{W[5]}.\\
%\end{array}
%\]
%Затем
%\[
%\begin{array}{ccccccc}
% \mathsf{W[12]} & = & \mathsf{SubByte(RotByte(W[11]))} &\oplus  &  \mathsf{W[6]} & \oplus  & \left[ \begin{array}{c}
% \mathsf{\alpha} \\
%  \mathsf{`00'}\\
%  \mathsf{`00'}\\
%  \mathsf{`00'}\\
%\end{array}
%\right] ,   \\
%\end{array}
%\]
%\[
%\begin{array}{ccc}
% \mathsf{W[13]=W[12]}\oplus \mathsf{W[7]}; & \mathsf{W[14]= W[13]}\oplus \mathsf{W[8]};  & \mathsf{W[15]=W[14]}\oplus \mathsf{W[9]},  \\
%\end{array}
%\]
%и т.д.
%\exampleend
%
%\example
%Пусть $\mathsf{Nk=8}.$ В этом случае ключ шифра имеет длину $256$ бита. Найдем столбцы расширенного ключа. Столбцы
%$\mathsf{W[0],W[1],W[2],W[3],W[4],W[5],W[6],W[7]}$  непосредственно заполняются битами ключа шифра. Номер следующего столбца
%$\mathsf{W[8]}$ кратен $\mathsf{Nk}$, поэтому
%\[
%\begin{array}{ccccccc}
% \mathsf{W[8]} & = & \mathsf{SubByte(RotByte(W[7]))} &\oplus  &  \mathsf{W[0]} & \oplus  & \left[ \begin{array}{c}
% \mathsf{`01'} \\
%  \mathsf{`00'}\\
%  \mathsf{`00'}\\
%  \mathsf{`00'}\\
%\end{array}
%\right]    \\
%\end{array}
%\].
%Далее имеем
%\[
%\begin{array}{ccc}
%\mathsf{ W[7]=W[6]}\oplus \mathsf{W[1]}; & \mathsf{W[8]=W[7]}\oplus \mathsf{W[2]}; & \mathsf{W[9]=W[8]}\oplus \mathsf{W[3]}; \\
%\mathsf{ W[10]=W[9]}\oplus \mathsf{W[4]}; & \mathsf{W[11]=W[10]}\oplus \mathsf{W[5]}.\\
%\end{array}
%\]
%Номер следующего столбца $\mathsf{W[12]}$ равен $12$. Так как $12-4$ кратно $\mathsf{Nk}$, то
%\[
%\begin{array}{ccc}
%\mathsf{ W[12]=SubByte(RotByte(W[11]))}\oplus \mathsf{W[4]}; & \mathsf{W[13]=W[12]}\oplus \mathsf{W[5]}; & \mathsf{W[14]=W[13]}\oplus \mathsf{W[6]}; \\
%\mathsf{ W[15]=W[14]}\oplus \mathsf{W[7]}. &  &\\
%\end{array}
%\]
%Затем
%\[
%\begin{array}{ccccccc}
% \mathsf{W[16]} & = & \mathsf{SubByte(RotByte(W[15]))} &\oplus  &  \mathsf{W[8]} & \oplus  & \left[ \begin{array}{c}
% \mathsf{\alpha} \\
%  \mathsf{`00'}\\
%  \mathsf{`00'}\\
%  \mathsf{`00'}\\
%\end{array}
%\right] ,   \\
%\end{array}
%\]
%\[
%\begin{array}{ccc}
% \mathsf{W[17]=W[16]}\oplus \mathsf{W[9]}; & \mathsf{W[18]=W[17]}\oplus \mathsf{W[10]};  &\mathsf{ W[19]=W[18]}\oplus \mathsf{W[10]}, \\
%\end{array}
%\]
%
%\[
%\begin{array}{ccc}
%\mathsf{ W[20]=SubByte(RotByte(W[19]))}\oplus \mathsf{W[12]}; & \mathsf{W[21]=W[20]}\oplus \mathsf{W[13]}; & \mathsf{W[22]=W[21]}\oplus \mathsf{W[14]}; \\
%\mathsf{ W[23]=W[22]}\oplus \mathsf{W[15]}, &  &\\
%\end{array}
%\]
%и т.д.

Ключ $i$-го раунда состоит из столбцов матрицы расширенного ключа
\[
    \mathsf{RoundKey} = (\mathsf{W}[4(i-1)], \mathsf{W}[4(i-1) + 1], \ldots, \mathsf{W}[4i-1]).
\]
%Если длина блока равна 192 битам $Nb=6$, то ключ 5-го раунда состоит из столбцов $W[24],W[25],W[26],W[27],W[28],W[29].$
%\exampleend

В настоящее время американский стандарт шифрования AES де-факто используется международно в негосударственных системах передачи данных, если позволяет законодательство страны. C 2010 г. процессоры Intel поддерживают специальный набор инструкций для шифра AES.