Аппаратный синтез криптоалгоритма IDEA

Аппаратный синтез криптоалгоритма IDEA. IDEA — симметричный блочный алгоритм шифрования данных. На 2019 год IDEA является надёжным алгоритмом шифрования из-за отсутствия успешных линейных криптоаналитических атак . Его использование в критических приложениях, таких как военные или использование в пакете программ шифрования PGP, требует эффективной, высоконадёжной и правильной аппаратной реализации.

Надёжность IDEA

B. Schneier и A. Tanenbaum считают IDEA одним из самых безопасных доступных криптографических алгоритмов. Фактически, нет никаких успешных линейных криптоаналитических атак на IDEA, и нет никаких известных алгебраических слабостей в IDEA, кроме обнаруженной J Daemen. Йоан Даймен произвёл атаку, используя класс из 251 слабого ключа во время шифрования, что облегчает обнаружение и восстановление ключа. Однако, поскольку существует большое количество возможных ключей, этот результат не влияет на практическую безопасность шифра для предоставляемого шифрования.

Аппаратные реализации прошлых лет

Реализация аппаратного обеспечения этого криптографического алгоритма была областью активных разработок.

Ниже представлены наиболее часто встречающиеся реализации:

• Davor Runje и Mario Kovač

Представили реализацию ядра ПЛИС для IDEA. Они использовали систему с одноядерным модулем для реализации IDEA, что было осуществлено с использованием FPGA Xilinx.

• K. H. Tsoi, P. H. W. Leong

Исследовали высокопроизводительную реализацию IDEA с использованием как параллельных, так и последовательных архитектур. Они использовали FPGA Xilinx Virtex XCV300-6 и XCV1000-6 для оценки и анализа производительности.

• Allen Michalski, Kris Gaj, и Tarek El-Ghazawi

В представили сравнение реализации IDEA между компьютерами общего назначения SRC-6E и HC-36.

Реализация IDEA

Ниже изложенная реализация является трудом Ali E. Abdallah и Issam W. Damaj.

Уточнение: поток — это метод последовательной передачи значений. Он подразумевает последовательность сообщений в канале, причём каждое сообщение представляет разное значение. Предполагая, что поток конечен, после того, как будет передано последнее значение, будет сообщено об окончании передачи (EOT).

Рассмотрим алгоритм IDEA как три основных блока. Глобальное представление этих блоков показало бы шифрование (или дешифрование) в виде блока с 2 входами, закрытым ключом и открытым текстом (или зашифрованным текстом) и выводом зашифрованного текста (или открытого текста). Два оставшихся блока — это генерация подразделов шифрования и дешифрования. В случае генерации подразделов шифрования блок будет принимать частные ключи, входящие и выводящие нужные подразделы. Генератор decryptionsubkeys будет вводить созданные подразделы шифрования и выводить ключи decryptions. Определим некоторые типы, которые будут использоваться в следующей спецификации(Дальнейший код написан на HDL):

type Private = [Bool]
type SubKey = Int
type Plaintext = [Int]
type Ciphertext = [Int]
modVal = 65536

Основные блоки в рамках IDEA

• Побитовое исключающее ИЛИ

• Добавление 16-разрядных целых чисел по модулю 65536 ($2^{16}$)

• Умножение 16-битных целых чисел по модулю 65537 ($2^{16}-1$), где весь блок ввода нулей рассматривается как $2^{16}$.

Генерация ключей

52 16-битных подключа генерируются из 128-битного ключа шифрования. Алгоритм генерации следующий:

• Первые восемь подразделов выбираются непосредственно из ключа путём разделения ключа (128-битный список) на восемь сегментов равной длины (16-битных)

• Применяется круговой сдвиг 25-битных позиций. на ключ предыдущего шага, и затем извлекаются восемь подразделов.

• Эта процедура повторяется до тех пор, пока не будут сгенерированы все 52 подключа, то есть 8 раз и 4 выделенных ключа на конечном этапе.

В следующей спецификации генерация подключей — это функция generateEncSubKeys, эта функция принимает ключ шифрования в качестве входных данных и выводит список из 52 16-разрядных подключей. Она генерирует соответствующие подключи для каждого сдвига с помощью функции generateSubKeys. Сгенерированные ключи затем объединяются в один список. Затем 52 подключа извлекаются из списка и преобразуются в целые числа, эквивалентные 16-элементному списку bool, представляющему каждый подключ. Преобразование выполняется с использованием функции btoi:

generateEncSubKeys :: Private -> [SubKey]
generateEncSubKeys key = map (btoi) (take 52 (foldr1 (++) (map generateSubKeys (take 8 (keyRotation key)))))

Все сдвинутые ключи определяются функцией keyRotation, которая многократно их генерирует . Эта функция использует повторяющуюся полиморфную функцию, которая принимает функцию f и список xs и многократно применяет функцию f к xs. В данном случае она многократно возвращает ключ с шагом 25 бит. Следовательно, значения будут 0, 25, 50, 75, 100, 125:

keyRotation :: Private -> Bool
keyRotation key = take 8 (repeated (shift 25) key)
repeated :: (a -> a) -> a -> [a]
repeated fx=x:repeated f (f x)
shift :: Int -> [a] -> [a]
shift n key = (drop n key) ++ (take n key)

Чтобы сгенерировать 16-битные подключи из сдвинутых ключей, применяется функция generateEncSubKeys к функции generateSubKeys над списком сдвинутых ключей. Функция generateSubKeys использует segs, которая выбирает n подсписков из списка xs:

generateSubKeys :: Private -> [SubKey]
generateSubKeys key = segs 16 key
segs :: Int -> [a] -> a
segs n [] = []
segs n xs = (take n xs) : segs n (drop n xs)

Наконец, нужные подключи упаковываются в списки по 6 элементов в одном с использованием пакета функций:

pack :: [a] -> a
pack = segs 6

Дешифрование

После генерации шифрования, представим генерацию дешифрования, где каждый подраздел дешифрования является функцией одного из подразделов шифрования. Соотношение между ключами шифрования и дешифрования определяется в функции generateDecSubKeys. Эта функция выполняется путём отображения функции в подготовленный список индексов. Функция execute использует addInv и mulInv, которые соответствуют аддитивному и мультипликативному обратному соответственно. Эта функция также использует функции высокого порядка, которая берёт список функций и список значений и применяет (используя функцию apply) каждую функцию в первом списке к соответствующему значению во втором списке (используя функцию более высокого порядка zipWith):

generateDecSubKeys :: [SubKey] -> [SubKey]
generateDecSubKeys eKeys = take 52 (foldr1 (++) (map perform indices))
    where
        indices = mapWith fs (map reverse (pack (reverse [l | l<-[0..51]])))
        f1(xs) = shift 2 xs
        f2(xs) = zipWith (+) (copy (xs!!2) 6) [0, 2, 1, 3, -2, -1]
        f3=idfs = [f1, f2, f2, f2, f2, f2, f2, f2, f3]
        perform(as) = mapWith [mulInv , addInv, addInv, mulInv, id, id](zipWith (!!) (copy eKeys 6) as)
copy :: a -> Int -> [a]
copy x n = [x|i<-[1..n]]
mapWith :: [(a -> b)] -> [a] -> [b]
mapWith fs = zipWith (apply) fs
apply :: (a -> b) -> a -> b
apply f = f

Определяем аддитивную обратную арифметическую операцию (по модулю $2^{16}$) и мультипликативную обратную арифметическую операцию (по модулю $2^{16}+1$).Эти операции — функции addInv и mulInv. Функция addInv просто вводит число, вычитаемое из значения модуля:

addInv :: Int -> Int
addInv a = modVal - a

Для вычисления мультипликативной обратной арифметической операции используется расширенный евклидов алгоритм. Функциональная спецификация выглядит следующим образом:

mulInv :: Int ->
IntmulInv 0 = 0
mulInv b = if (y < 0) then ((modVal +1) + y) else (y)
    where
        y = (extendedEucA (modVal +1) b)!!2
        extendedEucA :: Int -> Int -> [Int]
        extendedEucA a b
        | b == 0 = [a, 1, 0] 
        | otherwise = iterateSteps [a, b, 0, 1, 1, 0] iterateSteps ls = if ((ls[1]) > 0)
            then (iterateSteps s2)
            else ([(ls[0]), (ls[3]), (ls[5])])
        where
            s1 = (step1 ls)
            s2 = (step2 [(ls[1]), (s1[1]), (ls[2]), (s1[2]), (ls[4]), (s1[3])])
        step1 :: [Int] -> [Int]
        step1 ls1 = [q , (ls1[0]) - (q * (ls1[1])), (ls1[3]) - (q * (ls1[2])), (ls1[5]) - (q * (ls1[4]))]
            where
                q = div (ls1[0]) (ls1[1]) 
        step2 :: [Int] -> [Int]
        step2 ls1 = [(ls1[0]), (ls1[1]), (ls1[3]), (ls1[2]), (ls1[5]), (ls1[4])]

Анализ и оценка производительности

Результаты для различных конструкций шифрования (дешифрования) отражают изменение производительности. Первый тест является самым быстрым с максимальной пропускной способностью 21,33 Гбит/с (средняя пропускная способность 21,5 Мбит/с), отмеченной при тестировании векторов случайного ввода с ключом = {1, 2, 3, 4, 5, 6, 7, 8} . Второй тест, который соответствует последовательному выполнению раундов, имеет ожидаемую самую медленную пропускную способность (максимальная пропускная способность 5,82 Гбит/с и средняя пропускная способность 19,53 Мбит/с). Стоит отметить, что различные реализации модульных арифметических операций существенно влияют на производительность IDEA.

Сравнение с другими реализациями

Реализация с использованием FPGA Xilinx(Davor Runje и Mario Kovač) сильно уступает производительностью, это связано и использованием раздельного питания в слотах PCI (линии питания ввода-вывода и основной логики карт расширения разделены во избежание повреждения контроллера).

K. H. Tsoi, P. H. W. Leong представили уже более высокопроизводительную реализацию на FPGA Xilinx Virtex XCV300-6. Но опять пропускная способность была не на самом высоком уровне и отставала на порядок от реализации Ali E. Abdallah и Issam W. Damaj.Битовая параллельная реализация на Virtex XCV300-6 и XCV1000-6 обеспечивает скорость шифрования 1166 Мб/с при системном тактовом сигнале 82 МГц, в то время как битовая последовательная реализация предлагает 600 Мб/с на 150 МГц. Расчётная производительность бит параллельный и битовый последовательные реализации на устройстве XCV1000-6 составляют 5.25 Гб/с и 2,40 Гб/с соответственно.

Allen Michalski, Kris Gaj, и Tarek El-Ghazawi получили результаты в 2, 5 МБ/с — пропускная способность обработки на Crypto++. Скорость аппаратной обработки платформой SRC в 18.5 раз выше для одиночных массивов данных и примерно в 24 раза выше для непрерывного потока массивов.