AES.tex

\section{Стандарт шифрования США AES}\index{шифр!AES|(}
\selectlanguage{russian}

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

Для повышения криптостойкости и замены стандарта DES был объявлен конкурс на новый стандарт AES (аббревиатура от Advanced Encryption Standard). Победителем конкурса стал шифр Rijndael. Название составлено с использованием первых слогов фамилий его создателей (Rijmen и Daemen). В русскоязычном варианте читается как <<Рэндал>>~\cite{Kiwi:1999}. 26 ноября 2001 г. шифр был утверждён в качестве стандарта FIPS 197 и введён в действие 26 мая 2002 года~\cite{FIPS-PUB-197}.

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

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

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

\emph{Ключ шифрования раунда} ($\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-байтного вектора, используется обозначение $(a, b, c, d)$, где $a$, $b$, $c$, $d$ соответствуют байтам в одной из позиций ($0$, $1$, $2$, $3$) в столбце или векторе.

\emph{Входные} и \emph{выходные} блоки шифра 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{Операции в поле}

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

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

Хотя определение операций дано через их математическое представление, в реализациях шифра AES активно используются таблицы с заранее вычисленными результатами операций над отдельными байтами, включая взятие обратного элемента и перемножение элементов в поле $\GF{2^8}$ (на что требуется 256 байтов и 65 Кбайт памяти соответственно).

\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}[!ht]
%    \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 с помощью ключа шифра находят \emph{расширенный ключ};
    \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}[ht]
    \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{RotWord}(\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] = \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.

\index{шифр!AES|)}