C: заменить таблицу SubBytes AES FIPS-197 кодом постоянного времени

17

В FIPS-197 ( расширенный стандарт шифрования , известный как AES) он широко используется SubBytes, который может быть реализован как

unsigned char SubBytes(unsigned char x) {
static const unsigned char t[256] = {
  0x63,0x7C,0x77,0x7B,0xF2,0x6B,0x6F,0xC5,0x30,0x01,0x67,0x2B,0xFE,0xD7,0xAB,0x76,
  0xCA,0x82,0xC9,0x7D,0xFA,0x59,0x47,0xF0,0xAD,0xD4,0xA2,0xAF,0x9C,0xA4,0x72,0xC0,
  0xB7,0xFD,0x93,0x26,0x36,0x3F,0xF7,0xCC,0x34,0xA5,0xE5,0xF1,0x71,0xD8,0x31,0x15,
  0x04,0xC7,0x23,0xC3,0x18,0x96,0x05,0x9A,0x07,0x12,0x80,0xE2,0xEB,0x27,0xB2,0x75,
  0x09,0x83,0x2C,0x1A,0x1B,0x6E,0x5A,0xA0,0x52,0x3B,0xD6,0xB3,0x29,0xE3,0x2F,0x84,
  0x53,0xD1,0x00,0xED,0x20,0xFC,0xB1,0x5B,0x6A,0xCB,0xBE,0x39,0x4A,0x4C,0x58,0xCF,
  0xD0,0xEF,0xAA,0xFB,0x43,0x4D,0x33,0x85,0x45,0xF9,0x02,0x7F,0x50,0x3C,0x9F,0xA8,
  0x51,0xA3,0x40,0x8F,0x92,0x9D,0x38,0xF5,0xBC,0xB6,0xDA,0x21,0x10,0xFF,0xF3,0xD2,
  0xCD,0x0C,0x13,0xEC,0x5F,0x97,0x44,0x17,0xC4,0xA7,0x7E,0x3D,0x64,0x5D,0x19,0x73,
  0x60,0x81,0x4F,0xDC,0x22,0x2A,0x90,0x88,0x46,0xEE,0xB8,0x14,0xDE,0x5E,0x0B,0xDB,
  0xE0,0x32,0x3A,0x0A,0x49,0x06,0x24,0x5C,0xC2,0xD3,0xAC,0x62,0x91,0x95,0xE4,0x79,
  0xE7,0xC8,0x37,0x6D,0x8D,0xD5,0x4E,0xA9,0x6C,0x56,0xF4,0xEA,0x65,0x7A,0xAE,0x08,
  0xBA,0x78,0x25,0x2E,0x1C,0xA6,0xB4,0xC6,0xE8,0xDD,0x74,0x1F,0x4B,0xBD,0x8B,0x8A,
  0x70,0x3E,0xB5,0x66,0x48,0x03,0xF6,0x0E,0x61,0x35,0x57,0xB9,0x86,0xC1,0x1D,0x9E,
  0xE1,0xF8,0x98,0x11,0x69,0xD9,0x8E,0x94,0x9B,0x1E,0x87,0xE9,0xCE,0x55,0x28,0xDF,
  0x8C,0xA1,0x89,0x0D,0xBF,0xE6,0x42,0x68,0x41,0x99,0x2D,0x0F,0xB0,0x54,0xBB,0x16};
return t[x];}

Эта функция не является произвольной; это обратимое отображение, состоящее из инверсии в поле Галуа с последующим аффинным преобразованием. Все подробности приведены в разделе 5.1.1 FIPS-197 или разделе 4.2.1 здесь (под немного другим названием).

Одна из проблем, связанных с реализацией в виде таблицы, заключается в том, что она открыта для так называемых атак с кэшированием .

Таким образом, ваша миссия состоит в том, чтобы разработать точную замену вышеуказанной SubBytes()функции, которая демонстрирует поведение в постоянном времени; мы будем считать , что это тот случай , когда ничего не зависит от ввода xот SubBytesиспользуется либо:

  • в качестве индекса массива,
  • как контроль операнда if, while, for, case, или оператора ?:;
  • как любой операнд операторов &&, ||, !, ==, !=, <, >, <=, >=, *, /, %;
  • в качестве правого операнда операторов >>, <<, *=, /=, %=, <<=, >>=.

Вход победы будет один с наименьшими затратами, полученный из числа операторов , выполненных во входном-зависимого пути передачи данных, с весом 5 для одинарных операторов -и ~, а также <<1, >>1, +1, -1; вес 7 для всех других операторов, сдвигов с другими счетами или добавлений / переходов других констант (приведение типов и продвижение бесплатно). В принципе, эта стоимость не изменяется при развертывании циклов (если они есть) и не зависит от ввода x. Ответы с кратчайшим кодом после удаления пробелов и комментариев побеждают.

Я планирую обозначить запись как ответ, как только смогу, в 2013 году, UTC. Я рассмотрю ответы на языках, о которых я немного знаю, оценивая их как прямой перевод C, не оптимизированный по размеру.

Извинения за первоначальное упущение +1и -1в пользу привилегированных операторов, бесплатных забросов и рекламных акций, а также ранжирование по размеру. Учтите, что *это запрещено как при одинарном, так и при умножении.

fgrieu
источник
1
Стоит отметить, что поиски бесплатны, потому что вы можете встроить их как константы.
Питер Тейлор
«в начале 2013 года, UTC» - не будет ли дата более интересной, чем часовой пояс?
Paŭlo Ebermann
@ PaŭloEbermann: Мое намерение должно быть ясно сейчас.
fgrieu
См. Также codegolf.stackexchange.com/questions/3766/…
Кит Рэндалл,

Ответы:

13

Оценка: 940 933 926 910, подход к полевой башне

public class SBox2
{
    public static void main(String[] args)
    {
        for (int i = 0; i < 256; i++) {
            int s = SubBytes(i);
            System.out.format("%02x  ", s);
            if (i % 16 == 15) System.out.println();
        }
    }

    private static int SubBytes(int x) {
        int fwd;
        fwd  = 0x010001 & -(x & 1); x >>= 1; //   7+5+7+5+ | 24+
        fwd ^= 0x1d010f & -(x & 1); x >>= 1; // 7+7+5+7+5+ | 31+
        fwd ^= 0x4f020b & -(x & 1); x >>= 1; // 7+7+5+7+5+ | 31+
        fwd ^= 0x450201 & -(x & 1); x >>= 1; // 7+7+5+7+5+ | 31+
        fwd ^= 0xce080d & -(x & 1); x >>= 1; // 7+7+5+7+5+ | 31+
        fwd ^= 0xa20f0f & -(x & 1); x >>= 1; // 7+7+5+7+5+ | 31+
        fwd ^= 0xc60805 & -(x & 1); x >>= 1; // 7+7+5+7+5+ | 31+
        fwd ^= 0x60070e & -x;                // 7+7+5+     | 19+

        // Running total so far: 229

        int p1;
        {
            int ma = fwd;
            int mb = fwd >> 16;         // 7+         | 7+
            p1  = ma & -(mb&1); ma<<=1; //   7+5+7+5+ | 24+
            p1 ^= ma & -(mb&2); ma<<=1; // 7+7+5+7+5+ | 31+
            p1 ^= ma & -(mb&4); ma<<=1; // 7+7+5+7+5+ | 31+
            p1 ^= ma & -(mb&8);         // 7+7+5+7+   | 26+
            int t = p1 >> 3;            // 7+         | 7+
            p1 ^= (t >> 1) ^ (t & 0xe); // 7+5+7+7+   | 26+
        }

        // Running total so far: 229 + 152 = 381

        int y3, y2, y1, y0;
        {
            int Kinv = (fwd >> 20) ^ p1;     // 7+7+
            int w0 = Kinv & 1; Kinv >>= 1;   // 7+5+
            int w1 = Kinv & 1; Kinv >>= 1;   // 7+5+
            int w2 = Kinv & 1; Kinv >>= 1;   // 7+5+
            int w3 = Kinv & 1;               // 7+

            int t0 = w1 ^ w0 ^ (w2 & w3);      // 7+7+7+
            int t1 = w2 ^ (w0 | w3);           // 7+7+
            int t2 = t0 ^ t1;                  // 7+

            y3 = t2 ^ (t1 & (w1 & w3));        // 7+7+7+
            y2 = t0 ^ (w0 | t2);               // 7+7+
            y1 = w0 ^ w3 ^ (t1 & t0);          // 7+7+7+
            y0 = w3 ^ (t0 | (w1 ^ (w0 | w2))); // 7+7+7+7


        }

        // Running total so far: 381 + 24*7 + 3*5 = 564

        int p2;
        {
            int ma = fwd;
            p2  = ma & -y0; ma<<=1;       //   7+5+5+ | 17+
            p2 ^= ma & -y1; ma<<=1;       // 7+7+5+5+ | 24+
            p2 ^= ma & -y2; ma<<=1;       // 7+7+5+5+ | 24+
            p2 ^= ma & -y3;               // 7+7+5+   | 19+
            int t = p2 >> 3;              // 7+       | 7+
            p2 ^= (t >> 1) ^ (t & 0xe0e); // 7+5+7+7+ | 26
        }

        // Running total so far: 564 + 117 = 681

        int inv8;
        inv8  =  31 & -(p2 & 1);           //   7+5+7+   | 19+
        inv8 ^= 178 & -(p2 & 2); p2 >>= 2; // 7+7+5+7+7+ | 33+
        inv8 ^= 171 & -(p2 & 1);           // 7+7+5+7+   | 26+
        inv8 ^=  54 & -(p2 & 2); p2 >>= 6; // 7+7+5+7+7+ | 33+
        inv8 ^= 188 & -(p2 & 1);           // 7+7+5+7+   | 26+
        inv8 ^=  76 & -(p2 & 2); p2 >>= 2; // 7+7+5+7+7+ | 33+
        inv8 ^= 127 & -(p2 & 1);           // 7+7+5+7+   | 26+
        inv8 ^= 222 & -(p2 & 2);           // 7+7+5+7    | 26+

        return inv8 ^ 0x63;                // 7+         | 7+

        // Grand total: 681 + 229 = 910
    }
}

Структура по сути такая же, как у Бояра и Перальты: уменьшить инверсию в GF (2 ^ 8) до инверсии в GF (2 ^ 4), разбить ее на линейный пролог, нелинейное тело и линейный эпилог, а затем свести их к минимуму отдельно. Я плачу некоторые штрафы за извлечение битов, но я компенсирую это за счет возможности выполнять операции параллельно (с некоторым разумным дополнением битов fwd). Подробнее...

Фон

Как уже упоминалось в описании проблемы, S-блок состоит из инверсии в конкретной реализации поля Галуа GF (2 ^ 8) с последующим аффинным преобразованием. Если вы знаете, что они оба значат, пропустите этот раздел.

Аффинное (или линейное) преобразование - это функция, f(x)которая уважает f(x + y) = f(x) + f(y)и f(a*x) = a*f(x).

Поле - это набор Fэлементов с двумя специальными элементами, которые мы будем называть 0и 1, и двумя операторами, которые мы будем называть +и *которые учитывают различные свойства. В этом разделе предполагается , что x, yи zявляются элементами F.

  • Элементы Fформы абелевой группы в соответствии +с 0тождеством: т.е. x + yявляется элементом F; x + 0 = 0 + x = x; у каждого xесть соответствующий -xтакой, что x + (-x) = (-x) + x = 0; x + (y + z) = (x + y) + z; и x + y= y + x.
  • Элементы, Fотличные от 0образующих абелеву группу в соответствии *с 1идентичностью.
  • Умножение распределяет более того: x * (y + z) = (x * y) + (x * z).

Оказывается, существуют некоторые довольно жесткие ограничения на конечные поля:

  • Они должны иметь ряд элементов, которые являются степенью простого числа.
  • Они изоморфны всем остальным конечным полям того же размера (т. Е. На самом деле существует только одно конечное поле заданного размера, а любые другие являются просто перестановками; назовем это поле GF (p ^ k), где pпростое число и kстепень) ,
  • Мультипликативная группа F\{0}под *является циклической; то есть есть по крайней мере один элемент gтакой, что каждый элемент является степенью g.
  • Для степеней, больших 1, существует представление в виде одномерных многочленов порядка kполя простого порядка. Например, GF (2 ^ 8) имеет представление в виде полиномов xнад GF (2). На самом деле обычно существует более одного представления. Рассмотрим x^7 * xв GF (2 ^ 8); он должен быть эквивалентен некоторому полиному порядка 7, но какой? Есть много вариантов, которые дают правильную структуру; AES решает сделать x^8 = x^4 + x^3 + x + 1(лексикографически наименьший многочлен, который работает).

Итак, как мы вычисляем обратное в этом конкретном представлении GF (2 ^ 8)? Это слишком сложная задача, чтобы решать ее напрямую, поэтому нам нужно разобраться с ней.

Полевые башни: представляющие GF (2 ^ 8) в терминах GF (2 ^ 4)

Вместо того, чтобы представлять GF (2 ^ 8) полиномами из 8 членов над GF (2), мы можем представить его полиномами из 2 членов над GF (2 ^ 4). На этот раз нам нужно выбрать линейный полином для x^2. Предположим, мы выбрали x^2 = px + q. Тогда (ax + b) * (cx + d) = (ad + bc + acp)x + (bd + acq).

Легче ли найти обратное в этом представлении? Если (cx + d) = (ax + b)^-1мы получим одновременные уравнения

  • ad + (b + ap)c = 0
  • bd + (aq)c = 1

Позвольте D = [b(b+ap) + a^2 q]и установить c = a * D^-1; d = (b + ap) * D^-1, Таким образом, мы можем сделать обратное в GF (2 ^ 8) для стоимости преобразования в GF (2 ^ 4), обратное и несколько сложений и умножений в GF (2 ^ 4) и обратное преобразование. Даже если мы сделаем обратное с помощью таблицы, мы уменьшили размер таблицы с 256 до 16.

Детали реализации

Чтобы построить представление GF (4), мы можем выбрать один из трех полиномов для уменьшения x^4:

  • x^4 = x + 1
  • x^4 = x^3 + 1
  • x^4 = x^3 + x^2 + x + 1

Самое важное отличие заключается в реализации умножения. Для любого из трех (которые соответствуют poly3, 9, f) будет работать следующее:

// 14x &, 7x unary -, 3x <<1, 3x >>1, 3x >>3, 6x ^ gives score 226
int mul(int a, int b) {
    // Call current values a = a0, b = b0
    int p = a & -(b & 1);
    a = ((a << 1) ^ (poly & -(a >> 3))) & 15;
    b >>= 1;
    // Now p = a0 * (b0 mod x); a = a0 x; b = b0 div x

    p ^= a & -(b & 1);
    a = ((a << 1) ^ (poly & -(a >> 3))) & 15;
    b >>= 1;
    // Now p = a0 * (b0 mod x^2); a = a0 x^2; b = b0 div x^2

    p ^= a & -(b & 1);
    a = ((a << 1) ^ (poly & -(a >> 3))) & 15;
    b >>= 1;
    // Now p = a0 * (b0 mod x^3); a = a0 x^3; b = b0 div x^3

    p ^= a & -(b & 1);
    // p = a0 * b0

    return p;
}

Однако, если мы решим, poly = 3мы сможем справиться с переполнением намного эффективнее, потому что оно имеет хорошую структуру: двойного переполнения не существует, потому что оба входа являются x^6 = x^2 (x + 1)кубическими и кубическими. Кроме того, мы можем сохранить сдвиги b: поскольку мы оставляем переполнение до последнего, a0 x^2не имеет никаких установленных битов, соответствующих xили 1, и поэтому мы можем замаскировать его с -4 вместо -1. Результат

// 10x &, 4x unary -, 3x <<1, 1x >>1, 1x >>3, 5x ^ gives score 152
int mul(int a, int b) {
    int p;
    p  = a & -(b & 1); a <<= 1;
    p ^= a & -(b & 2); a <<= 1;
    p ^= a & -(b & 4); a <<= 1;
    p ^= a & -(b & 8);
    // Here p = a0 * b0 but with overflow, which we need to bring back down.

    int t = p >> 3;
    p ^= (t >> 1) ^ (t & 0xe);
    return p & 15;
}

Нам все еще нужно выбрать значения pи qдля представления GF (2 ^ 8) над GF (2 ^ 4), но у нас не так много на них ограничений. Единственное, что имеет значение, - это то, что мы можем получить линейную функцию от битов нашего исходного представления до битов рабочего представления. Это имеет значение по двум причинам: во-первых, линейные преобразования легко выполнять, тогда как нелинейное преобразование потребует оптимизации, эквивалентной по сложности простой оптимизации всего S-блока; во-вторых, потому что мы можем получить некоторые побочные выгоды. Чтобы подвести итог структуры:

GF256 SubBytes(GF256 x) {
    GF16 a, b, t, D, Dinv, c, d;

    (a, b) = f(x); // f is linear

    t = b + a * p;
    D = b * t + a * a * q;
    Dinv = inverse_GF16(D);
    c = a * Dinv;
    d = t * Dinv;

    return finv(c, d); // finv is also linear
}

Если биты xявляются x7 x6 ... x0то , поскольку преобразование является линейным , мы получаем a = f({x7}0000000 + 0{x6}000000 + ... + 0000000{x0}) = f({x7}0000000) + f(0{x6}000000) + ... + f(0000000{x0}). Возведем его в квадрат, и мы получим, a^2 = f({x7}0000000)^2 + f(0{x6}000000)^2 + ... + f(0000000{x0})^2где перекрестные члены отменяются (потому что в GF (2), 1 + 1 = 0). Так же a^2может быть вычислено как линейная функция x. Мы можем увеличить прямое линейное преобразование, чтобы получить:

GF256 SubBytes(GF256 x) {
    GF16 a, b, t, a2q, D, Dinv, c, d;

    (a, b, t, a2q) = faug(x);

    D = b * t + a2q;
    Dinv = inverse_GF16(D);
    c = a * Dinv;
    d = t * Dinv;

    return finv(c, d);
}

и мы до трех умножений и одного сложения. Мы также можем расширить код умножения для Dinvпараллельного выполнения двух умножений . Таким образом, наша общая стоимость - прямое линейное преобразование, сложение, два умножения, обратное в GF (2 ^ 4) и обратное линейное преобразование. Мы можем добавить пост-обратное линейное преобразование S-блока и получить его практически бесплатно.

Вычисление коэффициентов для линейных преобразований не очень интересно, и при этом микрооптимизация не позволяет сохранить маску здесь и сдвиг там. Остальная интересная часть - это оптимизацияinverse_GF16, Существует от 2 до 64 различных функций от 4 до 4 бит, поэтому прямая оптимизация требует много памяти и времени. Что я сделал, так это рассмотрел 4 функции от 4 бит до 1 бита, ограничил общую стоимость, разрешенную для какой-либо одной функции (с максимальной стоимостью 63 за функцию я могу перечислить все подходящие выражения менее чем за минуту), и для каждого набора функций делайте общее исключение подвыражения. После 25 минут хруста, я обнаружил, что наилучшее возможное обратное значение с этим ограничением имеет общую стоимость 133 (в среднем 33,25 на бит на выходе, что неплохо, учитывая, что самое дешевое выражение для любого отдельного бита - 35) ,

Я все еще экспериментирую с другими подходами, чтобы минимизировать инверсию в GF (2 ^ 4), и подход, который строит восходящий, а не нисходящий, принес улучшение с 133 до 126.

Питер Тейлор
источник
Фантастический! Я подтверждаю, что это работает! Деталь: восьмое & 1может быть обрезано (особенно если xесть unsigned char; CHAR_BITв Codegolf есть 8).
fgrieu
@fgrieu, хорошая мысль.
Питер Тейлор
8

Оценка: 980 = 7 * 5 + 115 * 7 + 7 * 5 + 15 * 7, минимизация Бояра и Перальты

Я нашел новую технику минимизации комбинационной логики с приложениями к криптологии Джоан Бояр и Рене Перальта, которая (за исключением формализма C) делает то, что требуется. Методика, используемая для получения их уравнений, запатентована не менее, чем в США. Я просто сделал прямой перевод их уравнений , любезно связанных здесь .

unsigned char SubBytes_Boyar_Peralta(unsigned char x7){
  unsigned char 
  x6=x7>>1,x5=x6>>1,x4=x5>>1,x3=x4>>1,x2=x3>>1,x1=x2>>1,x0=x1>>1,
  y14=x3^x5,y13=x0^x6,y9=x0^x3,y8=x0^x5,t0=x1^x2,y1=t0^x7,y4=y1^x3,y12=y13^y14,y2=y1^x0,
  y5=y1^x6,y3=y5^y8,t1=x4^y12,y15=t1^x5,y20=t1^x1,y6=y15^x7,y10=y15^t0,y11=y20^y9,y7=x7^y11,
  y17=y10^y11,y19=y10^y8,y16=t0^y11,y21=y13^y16,y18=x0^y16,t2=y12&y15,t3=y3&y6,t4=t3^t2,
  t5=y4&x7,t6=t5^t2,t7=y13&y16,t8=y5&y1,t9=t8^t7,t10=y2&y7,t11=t10^t7,t12=y9&y11,
  t13=y14&y17,t14=t13^t12,t15=y8&y10,t16=t15^t12,t17=t4^t14,t18=t6^t16,t19=t9^t14,
  t20=t11^t16,t21=t17^y20,t22=t18^y19,t23=t19^y21,t24=t20^y18,t25=t21^t22,t26=t21&t23,
  t27=t24^t26,t28=t25&t27,t29=t28^t22,t30=t23^t24,t31=t22^t26,t32=t31&t30,t33=t32^t24,
  t34=t23^t33,t35=t27^t33,t36=t24&t35,t37=t36^t34,t38=t27^t36,t39=t29&t38,t40=t25^t39,
  t41=t40^t37,t42=t29^t33,t43=t29^t40,t44=t33^t37,t45=t42^t41,z0=t44&y15,z1=t37&y6,
  z2=t33&x7,z3=t43&y16,z4=t40&y1,z5=t29&y7,z6=t42&y11,z7=t45&y17,z8=t41&y10,z9=t44&y12,
  z10=t37&y3,z11=t33&y4,z12=t43&y13,z13=t40&y5,z14=t29&y2,z15=t42&y9,z16=t45&y14,z17=t41&y8,
  t46=z15^z16,t47=z10^z11,t48=z5^z13,t49=z9^z10,t50=z2^z12,t51=z2^z5,t52=z7^z8,t53=z0^z3,
  t54=z6^z7,t55=z16^z17,t56=z12^t48,t57=t50^t53,t58=z4^t46,t59=z3^t54,t60=t46^t57,
  t61=z14^t57,t62=t52^t58,t63=t49^t58,t64=z4^t59,t65=t61^t62,t66=z1^t63,s0=t59^t63,
  s6=t56^t62,s7=t48^t60,t67=t64^t65,s3=t53^t66,s4=t51^t66,s5=t47^t65,s1=t64^s3,s2=t55^t67;
  return (((((((s0<<1|s1&1)<<1|s2&1)<<1|s3&1)<<1|s4&1)<<1|s5&1)<<1|s6&1)<<1|s7&1)^0x63;}
fgrieu
источник
Вау, действительно работает, и действительно дешево. При разборке это действительно 144 инструкции, исключая пролог, эпилогию и инструкции по перемещению.
Угорен
5

Счет: 10965

При этом используется тот же принцип развертывания поиска в массиве. Может потребоваться дополнительные броски.

Спасибо Угорену за указание, как улучшить is_zero.

// Cost: 255 * (5+7+24+7) = 10965
unsigned char SubBytes(unsigned char x) {
    unsigned char r = 0x63;
    char c = (char)x;
    c--; r ^= is_zero(c) & (0x63^0x7c); // 5+7+24+7 inlining the final xor
    c--; r ^= is_zero(c) & (0x63^0x77); // 5+7+24+7
    // ...
    c--; r ^= is_zero(c) & (0x63^0x16); // 5+7+24+7
    return r;
}

// Cost: 24
// Returns (unsigned char)-1 when input is 0 and 0 otherwise
unsigned char is_zero(char c) {
    // Shifting a signed number right is unspecified, so use unsigned
    unsigned char u;
    c |= -c;               // 7+5+
    u = (unsigned char)c;
    u >>= (CHAR_BITS - 1); // 7+
    c = (char)u;
    // c is 0 if we want -1 and 1 otherwise.
    c--;                   // 5
    return (unsigned char)c;
}
Питер Тейлор
источник
2
Для целого числа c, (c|-c)>>310 для 0 и -1 в противном случае.
Угорен
@ugoren, на разумных языках, да. В C смещение вправо беззнакового типа не определено.
Питер Тейлор
1
Я думаю, вы имеете в виду подписано. Но этот сайт на самом деле не славится строгим соответствием стандартам. Кроме того, c >> 4мне кажется, что вы подписали правильный сдвиг вправо. И если ты действительно настаиваешь - ((unsigned int)(c|-c))>>31есть c?1:0.
Угорен
@ugoren, ты прав, я имел в виду подпись. c >>4Работает с или без расширения знака. Но хорошая выгода от использования беззнаковой смены: будет редактировать, когда я вернусь домой, и могу использовать подходящий компьютер, а не телефон. Благодарю.
Питер Тейлор
3

Оценка: 9109, алгебраический подход

Я оставлю подход поиска в случае, если кто-то сможет значительно улучшить его, но оказывается, что возможен хороший алгебраический подход. Эта реализация находит мультипликативное обратное с использованием алгоритма Евклида . Я написал его на Java, но в принципе его можно перенести на C - я прокомментировал части, которые могли бы измениться, если вы захотите переработать его, используя только 8-битные типы.

Спасибо Угорену за то, что он указал, как сократить is_nonzeroпроверку в комментарии к моему другому ответу.

public class SBox
{
    public static void main(String[] args)
    {
        for (int i = 0; i < 256; i++) {
            int s = SubBytes(i);
            System.out.format("%02x  ", s);
            if (i % 16 == 15) System.out.println();
        }
    }

    // Total cost: 9109
    public static int SubBytes(int x)
    {
        x = inv_euclid(x); // 9041
        x = affine(x);     // 68
        return x;
    }

    // Total cost: 68
    private static int affine(int s0) {
        int s = s0;
        s ^= (s0 << 1) ^ (s0 >> 7); // 5 + 7
        s ^= (s0 << 2) ^ (s0 >> 6); // 7 + 7
        s ^= (s0 << 3) ^ (s0 >> 5); // 7 + 7
        s ^= (s0 << 4) ^ (s0 >> 4); // 7 + 7
        return (s ^ 0x63) & 0xff;   // 7 + 7
    }

    // Does the inverse in the Galois field for a total cost of 24 + 9010 + 7 = 9041
    private static int inv_euclid(int s) {
        // The first part of handling the special case: cost of 24
        int zeromask = is_nonzero(s);

        // NB the special value of r would complicate the unrolling slightly with unsigned bytes
        int r = 0x11b, a = 0, b = 1;

        // Total cost of loop: 7*(29+233+566+503+28) - 503 = 9010
        for (int depth = 0; depth < 7; depth++) { // 7*(
            // Calculate mask to fake out when we're looping further than necessary: cost 29
            int mask = is_nonzero(s >> 1);

            // Cost: 233
            int ord = polynomial_order(s);

            // This next block does div/rem at a total cost of 6*(24+49) + 69 + 59 = 566
            int quot = 0, rem = r;
            for (int i = 7; i > 1; i--) {                   // 6*(
                int divmask = is_nonzero(ord & (rem >> i)); // 24+7+7
                quot ^= (1 << i) & divmask;                 // 7+0+7+ since 1<<i is inlined on unrolling
                rem ^= (s << i) & divmask;                  // 7+7+7) +
            }
            int divmask1 = is_nonzero(ord & (rem >> 1));    // 24+7+5
            quot ^= 2 & divmask1;                           // 7+7+
            rem ^= (s << 1) & divmask1;                     // 7+5+7+
            int divmask0 = is_nonzero(ord & rem);           // 24+7
            quot ^= 1 & divmask0;                           // 7+7+
            rem ^= s & divmask0;                            // 7+7

            // This next block does the rest for the cost of a mul (503) plus 28
            // When depth = 0, b = 1 so we can skip the mul on unrolling
            r = s;
            s = rem;
            quot = mul(quot, b) ^ a;
            a = b;
            b ^= (quot ^ b) & mask;
        }

        // The rest of handling the special case: cost 7
        return b & zeromask;
    }

    // Gets the highest set bit in the input. Assumes that it's always at least 1<<1
    // Cost: 233
    private static int polynomial_order(int s) {
        int ord = 2;
        ord ^= 6 & -((s >> 2) & 1);           // 7+7+5+7+7 = 33 +
        ord ^= (ord ^ 8) & -((s >> 3) & 1);   // 7+7+7+5+7+7 = 40 +
        ord ^= (ord ^ 16) & -((s >> 4) & 1);  // 40 +
        ord ^= (ord ^ 32) & -((s >> 5) & 1);  // 40 +
        ord ^= (ord ^ 64) & -((s >> 6) & 1);  // 40 +
        ord ^= (ord ^ 128) & -((s >> 7) & 1); // 40
        return ord;
    }

    // Returns 0 if c is 0 and -1 otherwise
    // Cost: 24
    private static int is_nonzero(int c) {
        c |= -c;   // 7+5+
        c >>>= 31; // 7+ (simulating a cast to unsigned and right shift by CHAR_BIT)
        c = -c;    // 5+ (could be saved assuming a particular implementation of signed right shift)
        return c;
    }

    // Performs a multiplication in the Rijndael finite field
    // Cost: 503 (496 if working with unsigned bytes)
    private static int mul(int a, int b) {
        int p = 0;
        for (int counter = 0; counter < 8; counter++) { // 8*(_+_
            p ^= a & -(b & 1);                          // +7+7+5+7
            a = (a << 1) ^ (0x1b & -(a >> 7));          // +5+7+7+5+7
            b >>= 1;                                    // +5)
        }
        p &= 0xff;                                      // +7 avoidable with unsigned bytes
        return p;
    }
}
Питер Тейлор
источник
2

Оценка: 256 * (7+ (8 * (7 + 7 + 7) - (2 + 2)) + 5 + 7 + 7) = 48640 (при условии, что циклы развернуты)

unsigned char SubBytes(unsigned char x) {
static const unsigned char t[256] = {
  0x63,0x7C,0x77,0x7B,0xF2,0x6B,0x6F,0xC5,0x30,0x01,0x67,0x2B,0xFE,0xD7,0xAB,0x76,
  0xCA,0x82,0xC9,0x7D,0xFA,0x59,0x47,0xF0,0xAD,0xD4,0xA2,0xAF,0x9C,0xA4,0x72,0xC0,
  0xB7,0xFD,0x93,0x26,0x36,0x3F,0xF7,0xCC,0x34,0xA5,0xE5,0xF1,0x71,0xD8,0x31,0x15,
  0x04,0xC7,0x23,0xC3,0x18,0x96,0x05,0x9A,0x07,0x12,0x80,0xE2,0xEB,0x27,0xB2,0x75,
  0x09,0x83,0x2C,0x1A,0x1B,0x6E,0x5A,0xA0,0x52,0x3B,0xD6,0xB3,0x29,0xE3,0x2F,0x84,
  0x53,0xD1,0x00,0xED,0x20,0xFC,0xB1,0x5B,0x6A,0xCB,0xBE,0x39,0x4A,0x4C,0x58,0xCF,
  0xD0,0xEF,0xAA,0xFB,0x43,0x4D,0x33,0x85,0x45,0xF9,0x02,0x7F,0x50,0x3C,0x9F,0xA8,
  0x51,0xA3,0x40,0x8F,0x92,0x9D,0x38,0xF5,0xBC,0xB6,0xDA,0x21,0x10,0xFF,0xF3,0xD2,
  0xCD,0x0C,0x13,0xEC,0x5F,0x97,0x44,0x17,0xC4,0xA7,0x7E,0x3D,0x64,0x5D,0x19,0x73,
  0x60,0x81,0x4F,0xDC,0x22,0x2A,0x90,0x88,0x46,0xEE,0xB8,0x14,0xDE,0x5E,0x0B,0xDB,
  0xE0,0x32,0x3A,0x0A,0x49,0x06,0x24,0x5C,0xC2,0xD3,0xAC,0x62,0x91,0x95,0xE4,0x79,
  0xE7,0xC8,0x37,0x6D,0x8D,0xD5,0x4E,0xA9,0x6C,0x56,0xF4,0xEA,0x65,0x7A,0xAE,0x08,
  0xBA,0x78,0x25,0x2E,0x1C,0xA6,0xB4,0xC6,0xE8,0xDD,0x74,0x1F,0x4B,0xBD,0x8B,0x8A,
  0x70,0x3E,0xB5,0x66,0x48,0x03,0xF6,0x0E,0x61,0x35,0x57,0xB9,0x86,0xC1,0x1D,0x9E,
  0xE1,0xF8,0x98,0x11,0x69,0xD9,0x8E,0x94,0x9B,0x1E,0x87,0xE9,0xCE,0x55,0x28,0xDF,
  0x8C,0xA1,0x89,0x0D,0xBF,0xE6,0x42,0x68,0x41,0x99,0x2D,0x0F,0xB0,0x54,0xBB,0x16};

unsigned char ret_val = 0;
int i,j;
for(i=0;i<256;i++) {
  unsigned char is_index = (x ^ ((unsigned char) i));
  for(j=0;j<8;j++) {
   is_index |= (is_index << (1 << j)) | (is_index >> (1 << j));
  }
  is_index = ~is_index;
  ret_val |= is_index & t[i];
}

return ret_val;}

Объяснение:

По сути, поиск в массиве переопределен с использованием побитовых операторов и всегда обрабатывает весь массив. Перебираем массив, и xorx с каждым индексом, затем используем побитовые операторы для логического отрицания результата, поэтому мы получаем 255 когда x=iи 0 в противном случае. Мы поразрядно - и это со значением массива, так что выбранное значение остается неизменным, а остальные становятся равными 0. Затем мы берем побитовый - или этого массива, тем самым вытаскивая только выбранное значение.

Эти две 1 << jоперации исчезнут как часть развертывания цикла, заменив их степенями от 2 до 1.

histocrat
источник
Теперь, чтобы увидеть, возможно ли на самом деле сделать математику с помощью побитовых операторов.
гистократ
Просматривая алгоритм здесь , я сомневаюсь, что можно будет реализовать полиномиальную инверсию, не перебирая все байты хотя бы один раз в качестве замены некоторых шагов за полиномиальное время. Так что это вполне может превзойти любые «умные» решения. Я подозреваю, что настройка поиска в массиве с постоянным временем - более перспективный путь.
гистократ
Ницца. Функция rj_sbox в aes.c здесь может дать вдохновение (хотя, как есть, она не соответствует вопросу).
fgrieu
Откуда берется -(2+2)ваш подсчет очков? Редактировать: ах, встраивание создает <<1и >>1.
Питер Тейлор
0

Оценка 1968 1692, используя справочную таблицу

Примечание. Это решение не соответствует критериям из-за w >> b .

Использование таблицы поиска, но чтение 8 байтов за раз.
3 * 7 + 32 * (6 * 7 + 2 * 5) + 7 = 692

unsigned char SubBytes(unsigned char x){

static const unsigned char t[256] = {
  0x63,0x7C,0x77,0x7B,0xF2,0x6B,0x6F,0xC5,0x30,0x01,0x67,0x2B,0xFE,0xD7,0xAB,0x76,
  0xCA,0x82,0xC9,0x7D,0xFA,0x59,0x47,0xF0,0xAD,0xD4,0xA2,0xAF,0x9C,0xA4,0x72,0xC0,
  0xB7,0xFD,0x93,0x26,0x36,0x3F,0xF7,0xCC,0x34,0xA5,0xE5,0xF1,0x71,0xD8,0x31,0x15,
  0x04,0xC7,0x23,0xC3,0x18,0x96,0x05,0x9A,0x07,0x12,0x80,0xE2,0xEB,0x27,0xB2,0x75,
  0x09,0x83,0x2C,0x1A,0x1B,0x6E,0x5A,0xA0,0x52,0x3B,0xD6,0xB3,0x29,0xE3,0x2F,0x84,
  0x53,0xD1,0x00,0xED,0x20,0xFC,0xB1,0x5B,0x6A,0xCB,0xBE,0x39,0x4A,0x4C,0x58,0xCF,
  0xD0,0xEF,0xAA,0xFB,0x43,0x4D,0x33,0x85,0x45,0xF9,0x02,0x7F,0x50,0x3C,0x9F,0xA8,
  0x51,0xA3,0x40,0x8F,0x92,0x9D,0x38,0xF5,0xBC,0xB6,0xDA,0x21,0x10,0xFF,0xF3,0xD2,
  0xCD,0x0C,0x13,0xEC,0x5F,0x97,0x44,0x17,0xC4,0xA7,0x7E,0x3D,0x64,0x5D,0x19,0x73,
  0x60,0x81,0x4F,0xDC,0x22,0x2A,0x90,0x88,0x46,0xEE,0xB8,0x14,0xDE,0x5E,0x0B,0xDB,
  0xE0,0x32,0x3A,0x0A,0x49,0x06,0x24,0x5C,0xC2,0xD3,0xAC,0x62,0x91,0x95,0xE4,0x79,
  0xE7,0xC8,0x37,0x6D,0x8D,0xD5,0x4E,0xA9,0x6C,0x56,0xF4,0xEA,0x65,0x7A,0xAE,0x08,
  0xBA,0x78,0x25,0x2E,0x1C,0xA6,0xB4,0xC6,0xE8,0xDD,0x74,0x1F,0x4B,0xBD,0x8B,0x8A,
  0x70,0x3E,0xB5,0x66,0x48,0x03,0xF6,0x0E,0x61,0x35,0x57,0xB9,0x86,0xC1,0x1D,0x9E,
  0xE1,0xF8,0x98,0x11,0x69,0xD9,0x8E,0x94,0x9B,0x1E,0x87,0xE9,0xCE,0x55,0x28,0xDF,
  0x8C,0xA1,0x89,0x0D,0xBF,0xE6,0x42,0x68,0x41,0x99,0x2D,0x0F,0xB0,0x54,0xBB,0x16};

  unsigned long long *t2 = (unsigned long long *)t;
  int a = x>>3, b=(x&7)<<3;                       // 7+7+7
  int i;
  int ret = 0;
  for (i=0;i<256/8;i++) {                         // 32 *
      unsigned long long w = t2[i];
      int badi = ((unsigned int)(a|-a))>>31;      // 7+7+5
      w &= (badi-1);                              // +7+7
      a--;                                        // +5
      ret |= w >> b;                              // +7+7
  }
  return ret & 0xff;                              // +7
}
ugoren
источник
Я не думаю, что это соответствует определению постоянного времени в вопросе, потому w>>bчто RHS рассчитывается изx
Питер Тейлор
Есть несколько нарушений: w >> bгде bзависит от ввода; Кроме того x/8, x%8и *= (1-badi). Первый, скорее всего, выродится в временную зависимость от младших процессоров. Тем не менее, идея использования широких переменных, безусловно, имеет потенциал.
fgrieu
Я недостаточно внимательно прочитал инструкцию. Я могу решить большинство проблем, но w >> bэто очень важно (мне нужно посмотреть, можно ли это исправить, не переписывая все.
Угорен
0

Таблица поиска и маска, оценка = 256 * (5 * 7 + 1 * 5) = 10240

Использует поиск таблицы с маской, чтобы выбрать только тот результат, который мы хотим. Использует тот факт, что j|-jявляется либо отрицательным (когда i! = X), либо нулевым (когда i == x). Сдвиг создает маску «все в один» или «все в ноль», которая используется для выбора только той записи, которую мы хотим.

static const unsigned char t[256] = {
  0x63,0x7C,0x77,0x7B,0xF2,0x6B,0x6F,0xC5,0x30,0x01,0x67,0x2B,0xFE,0xD7,0xAB,0x76,
  0xCA,0x82,0xC9,0x7D,0xFA,0x59,0x47,0xF0,0xAD,0xD4,0xA2,0xAF,0x9C,0xA4,0x72,0xC0,
  0xB7,0xFD,0x93,0x26,0x36,0x3F,0xF7,0xCC,0x34,0xA5,0xE5,0xF1,0x71,0xD8,0x31,0x15,
  0x04,0xC7,0x23,0xC3,0x18,0x96,0x05,0x9A,0x07,0x12,0x80,0xE2,0xEB,0x27,0xB2,0x75,
  0x09,0x83,0x2C,0x1A,0x1B,0x6E,0x5A,0xA0,0x52,0x3B,0xD6,0xB3,0x29,0xE3,0x2F,0x84,
  0x53,0xD1,0x00,0xED,0x20,0xFC,0xB1,0x5B,0x6A,0xCB,0xBE,0x39,0x4A,0x4C,0x58,0xCF,
  0xD0,0xEF,0xAA,0xFB,0x43,0x4D,0x33,0x85,0x45,0xF9,0x02,0x7F,0x50,0x3C,0x9F,0xA8,
  0x51,0xA3,0x40,0x8F,0x92,0x9D,0x38,0xF5,0xBC,0xB6,0xDA,0x21,0x10,0xFF,0xF3,0xD2,
  0xCD,0x0C,0x13,0xEC,0x5F,0x97,0x44,0x17,0xC4,0xA7,0x7E,0x3D,0x64,0x5D,0x19,0x73,
  0x60,0x81,0x4F,0xDC,0x22,0x2A,0x90,0x88,0x46,0xEE,0xB8,0x14,0xDE,0x5E,0x0B,0xDB,
  0xE0,0x32,0x3A,0x0A,0x49,0x06,0x24,0x5C,0xC2,0xD3,0xAC,0x62,0x91,0x95,0xE4,0x79,
  0xE7,0xC8,0x37,0x6D,0x8D,0xD5,0x4E,0xA9,0x6C,0x56,0xF4,0xEA,0x65,0x7A,0xAE,0x08,
  0xBA,0x78,0x25,0x2E,0x1C,0xA6,0xB4,0xC6,0xE8,0xDD,0x74,0x1F,0x4B,0xBD,0x8B,0x8A,
  0x70,0x3E,0xB5,0x66,0x48,0x03,0xF6,0x0E,0x61,0x35,0x57,0xB9,0x86,0xC1,0x1D,0x9E,
  0xE1,0xF8,0x98,0x11,0x69,0xD9,0x8E,0x94,0x9B,0x1E,0x87,0xE9,0xCE,0x55,0x28,0xDF,
  0x8C,0xA1,0x89,0x0D,0xBF,0xE6,0x42,0x68,0x41,0x99,0x2D,0x0F,0xB0,0x54,0xBB,0x16};

unsigned char SubBytes(unsigned char x) {
  unsigned char r = 255;
  for (int i = 0; i < 256; i++) {
    int j = i - x;
    r &= t[i] | ((j | -j) >> 31);
  }
  return r;
}
Кит Рэндалл
источник
Разве это не то же самое, что мой второй ответ, за исключением менее оптимизированного?
Питер Тейлор
Я думаю, близко. Я использую сдвиг со знаком, поэтому мне не нужно делать -1 в конце.
Кит Рэндалл