C: แทนที่ตารางย่อย AES FIPS-197 โดยรหัสเวลาคงที่

ใน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];}

ฟังก์ชั่นนี้ไม่ได้ใช้เอง มันคือการทำแผนที่ย้อนกลับได้ประกอบด้วยการผกผันในสนาม Galois ตามด้วยการแปลงเลียนแบบ รายละเอียดทั้งหมดอยู่ในส่วนFIPS-197 5.1.1 หรือที่นี่ส่วน 4.2.1 (ภายใต้ชื่อที่แตกต่างกันเล็กน้อย)

ปัญหาหนึ่งที่มีการดำเนินการเป็นตารางก็คือว่ามันจะเปิดไปที่เรียกว่าการโจมตีแคชระยะเวลา

ดังนั้นภารกิจของคุณคือการสร้างสิ่งทดแทนที่แน่นอนสำหรับSubBytes()ฟังก์ชั่นด้านบนซึ่งแสดงพฤติกรรมที่คงที่ตลอดเวลา เราจะถือว่าเป็นกรณีที่เมื่อไม่มีอะไรขึ้นอยู่กับการป้อนข้อมูลxของSubBytesจะใช้อย่างใดอย่างหนึ่ง

• เป็นดัชนีอาร์เรย์
• การควบคุมตัวถูกดำเนินการของif, while, for, caseหรือผู้ประกอบการ?:;
• เป็นตัวถูกดำเนินการของผู้ประกอบการใด ๆ&&, ||, !, ==, !=, <, >, <=, >=, *, /, %;
• เป็นตัวถูกดำเนินการทางด้านขวาของผู้ประกอบการ>>, <<, *=, /=, %=, ,<<=>>=

รายการที่ชนะจะเป็นหนึ่งที่มีค่าใช้จ่ายต่ำสุดที่ได้รับจากจำนวนผู้ประกอบการดำเนินการในเส้นทางข้อมูลการป้อนข้อมูลขึ้นอยู่กับน้ำหนักของ 5 สำหรับผู้ประกอบการเอกภาค-และ~เช่นเดียวกับ<<1, >>1, +1, -1; น้ำหนัก 7 สำหรับตัวดำเนินการอื่นทั้งหมดการเปลี่ยนที่มีจำนวนอื่น ๆ หรือเพิ่ม / subs ของค่าคงที่อื่น ๆ (ประเภท casts และโปรโมชั่นฟรี) โดยหลักการค่าใช้จ่ายที่มีการเปลี่ยนแปลงโดยลูปคลี่ (ถ้ามี) xและเป็นอิสระจากการป้อนข้อมูล ในฐานะที่เป็น tie-breaker คำตอบด้วยรหัสที่สั้นที่สุดหลังจากลบช่องว่างและความคิดเห็นที่ชนะ

ฉันวางแผนที่จะกำหนดรายการเป็นคำตอบให้เร็วที่สุดเท่าที่จะทำได้ในปี 2556 UTC ฉันจะพิจารณาคำตอบในภาษาที่ฉันมีความรู้จัดอันดับพวกเขาเป็นคำแปลตรงไปยัง C ไม่เหมาะสำหรับขนาด

_{ขอโทษสำหรับการละเว้นเริ่มต้น+1และ-1ในผู้ประกอบการที่ชื่นชอบของฟรีปลดเปลื้องและโปรโมชั่นและการจัดอันดับของขนาด โปรดทราบว่า*เป็นสิ่งต้องห้ามเมื่อทั้งคู่ unary และเป็นการคูณ}

คะแนน: 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
    }
}

โครงสร้างนั้นเป็นแบบเดียวกับการนำ Boyar และ Peralta มาใช้ - ลดการผกผันใน GF (2 ^ 8) ไปสู่การผกผันใน GF (2 ^ 4) แบ่งมันออกเป็นเส้นตรงอารัมภบทไม่ใช่เส้นตรงและเส้นส่งท้ายเชิงเส้น แล้วย่อให้เล็กสุดแยกกัน ฉันจ่ายค่าปรับเล็กน้อยสำหรับการแตกบิต แต่ฉันชดเชยด้วยความสามารถในการดำเนินการแบบขนาน (ด้วยการแพ็ดบิตที่สมเหตุสมผลfwd) รายละเอียดเพิ่มเติม ...

พื้นหลัง

ดังที่ได้กล่าวไว้ในคำอธิบายปัญหา S-box ประกอบด้วยการผกผันในการใช้งานเฉพาะของ Galois field GF (2 ^ 8) ตามด้วยการแปลงเลียนแบบ หากคุณรู้ว่าหมายถึงอะไรทั้งสองให้ข้ามส่วนนี้

เลียนแบบ (หรือเชิงเส้น) การเปลี่ยนแปลงเป็นฟังก์ชั่นf(x)ที่เคารพและf(x + y) = f(x) + f(y)f(a*x) = a*f(x)

เขตข้อมูลคือชุดFขององค์ประกอบที่มีสององค์ประกอบพิเศษซึ่งเราจะเรียก0และ1และสองผู้ประกอบการซึ่งเราจะเรียก+และ*ที่เคารพคุณสมบัติต่างๆ ในส่วนนี้คิดว่าx, yและมีองค์ประกอบของzF

• องค์ประกอบของFรูปแบบกลุ่มศาสนาคริสต์ภายใต้การ+กับ0เป็นเอกลักษณ์: คือx + yเป็นองค์ประกอบของF; x + 0 = 0 + x = x; แต่ละคนxมีเหมือนกัน-xเช่นx + (-x) = (-x) + x = 0นั้น x + (y + z) = (x + y) + z; และ=x + yy + x
• องค์ประกอบของFอื่น ๆ นอกเหนือจาก0รูปแบบคริสต์กลุ่มภายใต้การ*กับ1เป็นตัวตน
• การคูณกระจายมากกว่าการเติม: x * (y + z) = (x * y) + (x * z).

ปรากฎว่ามีข้อ จำกัด ค่อนข้างรุนแรงในฟิลด์ จำกัด :

• พวกเขาจะต้องมีองค์ประกอบหลายอย่างซึ่งเป็นพลังของนายก
• พวกเขาเป็น isomorphic กับฟิลด์ จำกัด อื่น ๆ ทั้งหมดที่มีขนาดเดียวกัน (เช่นมีจริงๆเพียงหนึ่งฟิลด์ จำกัด ของขนาดที่กำหนดและอื่น ๆ ใด ๆ เป็นเพียง relabellings; โทรว่าสนาม GF (P ^ k) ที่pเป็นนายกรัฐมนตรีและkเป็นอำนาจ) .
• กลุ่มคูณF\{0}ภายใต้*เป็นวงจร คือมีอย่างน้อยหนึ่งองค์ประกอบดังกล่าวว่าทุกองค์ประกอบเป็นอำนาจของgg
• สำหรับพลังที่มากกว่า 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-box ให้เหมาะสม ประการที่สองเพราะเราสามารถได้รับผลประโยชน์บางด้าน วิธีสรุปโครงสร้าง:

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-box และรับฟรีเป็นหลัก

การคำนวณค่าสัมประสิทธิ์สำหรับการแปลงเชิงเส้นไม่น่าสนใจมากและไม่มีการปรับให้เหมาะสมขนาดเล็กเพื่อบันทึกมาสก์ที่นี่และการเปลี่ยนแปลงที่นั่น ส่วนที่น่าสนใจที่เหลือคือการเพิ่มประสิทธิภาพของinverse_GF16. มีฟังก์ชั่นที่แตกต่างกัน 2 ^ 64 จาก 4 บิตถึง 4 บิตดังนั้นการเพิ่มประสิทธิภาพโดยตรงต้องการหน่วยความจำและเวลาจำนวนมาก สิ่งที่ฉันทำคือการพิจารณา 4 ฟังก์ชั่นจาก 4 บิตถึง 1 บิตวางค่าใช้จ่ายทั้งหมดที่อนุญาตสำหรับฟังก์ชั่นใด ๆ (ด้วยราคาสูงสุด 63 ต่อฟังก์ชั่นหนึ่งฉันสามารถระบุการแสดงออกที่เหมาะสมทั้งหมดภายในไม่กี่นาที) และสำหรับแต่ละ tuple ของฟังก์ชั่นทำการกำจัดนิพจน์ย่อยทั่วไป หลังจากการกระทืบ 25 นาทีฉันพบว่าค่าผกผันที่ดีที่สุดที่มีได้คือต้นทุนรวม 133 (ค่าเฉลี่ย 33.25 ต่อบิตของการส่งออกซึ่งไม่เลวเลยเมื่อพิจารณาว่านิพจน์ที่ถูกที่สุดสำหรับบิตใด ๆ คือ 35) .

ฉันยังคงทดลองใช้วิธีการอื่นเพื่อลดการผกผันใน GF (2 ^ 4) และวิธีการที่สร้างจากล่างขึ้นบนมากกว่าบนลงล่างได้ผลดีขึ้นจาก 133 เป็น 126

คะแนน: 980 = 7 * 5 + 115 * 7 + 7 * 5 + 15 * 7, การย่อขนาดของ Boyar และ Peralta

ฉันพบเทคนิคการย่อขนาดตรรกะแบบใหม่พร้อมแอปพลิเคชันสำหรับวิทยาการเข้ารหัสโดย Joan Boyar และRené Peralta ซึ่ง (บันทึกสำหรับพิธีการ C) ทำสิ่งที่จำเป็น เทคนิคที่ใช้ในการรับสมการของพวกเขาได้รับการจดสิทธิบัตรโดยไม่น้อยกว่าในสหรัฐอเมริกา ผมก็ไม่ได้แปล 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;}

คะแนน: 10965

ใช้หลักการเดียวกันกับการยกเลิกการค้นหาอาเรย์ อาจต้องปลดเปลื้องพิเศษ

ขอขอบคุณที่ ugoren 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;
}

คะแนน: 9109, วิธีเชิงพีชคณิต

ฉันจะออกจากวิธีการค้นหาในกรณีที่ทุกคนสามารถปรับปรุงได้อย่างมาก แต่ปรากฎว่าวิธีการทางพีชคณิตที่ดีเป็นไปได้ การดำเนินการนี้พบผกผันโดยใช้อัลกอริทึมของยุคลิด ฉันเขียนมันใน Java แต่โดยหลักการแล้วมันสามารถส่งไปยัง C ได้ - ฉันได้คอมเม้นต์ส่วนต่างๆซึ่งจะเปลี่ยนแปลงหากคุณต้องการ rework มันโดยใช้ชนิด 8 บิตเท่านั้น

ขอบคุณ ugoren ที่ชี้ให้เห็นว่าจะ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;
    }
}

คะแนน: 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;}

คำอธิบาย:

โดยพื้นฐานแล้วการค้นหาอาร์เรย์นำมาใช้ใหม่โดยใช้ตัวดำเนินการระดับบิตและประมวลผลอาร์เรย์ทั้งหมดเสมอ เราวนรอบอาร์เรย์และ xor xกับแต่ละดัชนีจากนั้นใช้ตัวดำเนินการ bitwise ลบผลลัพธ์อย่างมีเหตุมีผลดังนั้นเราจะได้ 255 x=iและ 0 เป็นอย่างอื่น เรา bitwise- และนี่กับ array-value ดังนั้นค่าที่เลือกไว้จะไม่เปลี่ยนแปลงและอื่น ๆ กลายเป็น 0 จากนั้นเราก็ใช้ bitwise - หรือ array นี้ดังนั้นจึงดึงเฉพาะค่าที่เลือก

การ1 << jดำเนินการทั้งสองจะหายไปโดยเป็นส่วนหนึ่งของการคลี่วงแทนที่พวกมันด้วยพลังของ 2 จาก 1 ถึง 128

คะแนน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
}

การค้นหาตารางและมาสก์คะแนน = 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;
}