Upload CREBench benchmark corpus (48 algorithms, 432 instances) (part 13)

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+CREBench/MAGENTA-128/magenta.pdf filter=lfs diff=lfs merge=lfs -text

CREBench/LOKI97/public-weak_prng_seeded-O3/decompile/__fprintf_chk_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __fprintf_chk(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-O3/decompile/__gmon_start___decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __gmon_start__(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-O3/decompile/__libc_start_main_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __libc_start_main(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-O3/decompile/__printf_chk_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __printf_chk(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-O3/decompile/__stack_chk_fail_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __stack_chk_fail(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-O3/decompile/entry_decompiled

@@ -0,0 +1,13 @@
+
+void processEntry entry(undefined8 param_1,undefined8 param_2)
+
+{
+  undefined auStack_8 [8];
+  
+  (*(code *)PTR___libc_start_main_00103fd0)
+            (FUN_001010e0,param_2,&stack0x00000008,0,0,param_1,auStack_8);
+  do {
+                    /* WARNING: Do nothing block with infinite loop */
+  } while( true );
+}
+

CREBench/LOKI97/public-weak_prng_seeded-O3/decompile/memcmp_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+int memcmp(void *__s1,void *__s2,size_t __n)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-O3/decompile/strlen_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+size_t strlen(char *__s)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/address.json

@@ -0,0 +1,33 @@
+{
+  "00101020": "FUN_00101020",
+  "00108018": "__stack_chk_fail",
+  "00101000": "_DT_INIT",
+  "00101dd0": "FUN_00101dd0",
+  "00108038": "__fprintf_chk",
+  "001019c0": "FUN_001019c0",
+  "00108010": "strlen",
+  "00101080": "__cxa_finalize",
+  "00108030": "__printf_chk",
+  "00108050": "__cxa_finalize",
+  "001010a0": "__stack_chk_fail",
+  "001010e0": "FUN_001010e0",
+  "001010c0": "__printf_chk",
+  "00101a80": "FUN_00101a80",
+  "00108008": "_ITM_deregisterTMCloneTable",
+  "00101990": "entry",
+  "00101dc0": "FUN_00101dc0",
+  "00108028": "__gmon_start__",
+  "00108000": "__libc_start_main",
+  "00101090": "strlen",
+  "00108020": "memcmp",
+  "00108040": "_ITM_registerTMCloneTable",
+  "001019f0": "FUN_001019f0",
+  "00101e10": "FUN_00101e10",
+  "00101e54": "_DT_FINI",
+  "001010b0": "memcmp",
+  "00101b30": "FUN_00101b30",
+  "00101a30": "_FINI_0",
+  "00101b10": "FUN_00101b10",
+  "00101a70": "_INIT_0",
+  "001010d0": "__fprintf_chk"
+}

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_00101020_decompiled

@@ -0,0 +1,9 @@
+
+void FUN_00101020(void)
+
+{
+                    /* WARNING: Treating indirect jump as call */
+  (*(code *)PTR_00103fa0)();
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_001010e0_decompiled

@@ -0,0 +1,368 @@
+
+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
+
+bool FUN_001010e0(int param_1,undefined8 *param_2)
+
+{
+  char cVar1;
+  int iVar2;
+  int iVar3;
+  uint uVar4;
+  uint uVar5;
+  uint uVar6;
+  uint uVar7;
+  uint uVar8;
+  uint uVar9;
+  undefined uVar10;
+  int iVar11;
+  uint uVar12;
+  size_t sVar13;
+  uint *puVar14;
+  ulong uVar15;
+  ulong uVar16;
+  undefined8 uVar17;
+  uint uVar18;
+  uint uVar19;
+  uint uVar20;
+  uint uVar21;
+  int iVar22;
+  long lVar23;
+  char *pcVar24;
+  undefined1 *puVar25;
+  uint *puVar26;
+  uint uVar27;
+  ulong *puVar28;
+  long in_FS_OFFSET;
+  bool bVar29;
+  undefined8 extraout_XMM0_Qb;
+  int iVar30;
+  int iVar31;
+  int iVar32;
+  int iVar33;
+  ulong uVar34;
+  undefined auVar35 [16];
+  undefined auVar36 [16];
+  ulong uVar37;
+  undefined auVar38 [16];
+  byte local_288;
+  ulong *local_268;
+  ulong *local_260;
+  byte local_254;
+  ulong local_238 [48];
+  ulong local_b8 [4];
+  ulong local_98 [4];
+  undefined4 local_78;
+  undefined4 uStack_74;
+  undefined4 uStack_70;
+  undefined4 uStack_6c;
+  undefined4 local_68;
+  undefined4 uStack_64;
+  undefined4 uStack_60;
+  undefined4 uStack_5c;
+  undefined local_58 [8];
+  undefined local_50 [8];
+  undefined local_48 [8];
+  undefined local_40 [16];
+  long local_30;
+  
+  local_30 = *(long *)(in_FS_OFFSET + 0x28);
+  if (param_1 == 2) {
+    FUN_00101a80(local_58);
+    pcVar24 = (char *)param_2[1];
+    local_78 = _DAT_00102130;
+    uStack_74 = _UNK_00102134;
+    uStack_70 = _UNK_00102138;
+    uStack_6c = _UNK_0010213c;
+    local_68 = _DAT_00102140;
+    uStack_64 = _UNK_00102144;
+    uStack_60 = _UNK_00102148;
+    uStack_5c = _UNK_0010214c;
+    sVar13 = strlen(pcVar24);
+    if (sVar13 == 0x40) {
+      lVar23 = 0;
+      do {
+        cVar1 = pcVar24[lVar23 * 2];
+        iVar11 = (int)cVar1;
+        if ((byte)(cVar1 - 0x30U) < 10) {
+          uVar21 = iVar11 - 0x30;
+        }
+        else if ((byte)(cVar1 + 0x9fU) < 6) {
+          uVar21 = iVar11 - 0x57;
+        }
+        else {
+          uVar21 = iVar11 - 0x37;
+          if (5 < (byte)(cVar1 + 0xbfU)) {
+            uVar21 = 0xffffffff;
+          }
+        }
+        cVar1 = pcVar24[lVar23 * 2 + 1];
+        iVar11 = (int)cVar1;
+        if ((byte)(cVar1 - 0x30U) < 10) {
+          uVar18 = iVar11 - 0x30;
+        }
+        else if ((byte)(cVar1 + 0x9fU) < 6) {
+          uVar18 = iVar11 - 0x57;
+        }
+        else {
+          if (5 < (byte)(cVar1 + 0xbfU)) goto LAB_0010122a;
+          uVar18 = iVar11 - 0x37;
+        }
+        if ((int)(uVar21 | uVar18) < 0) goto LAB_0010122a;
+        local_268 = local_98;
+        *(byte *)((long)local_98 + lVar23) = (byte)(uVar21 << 4) | (byte)uVar18;
+        lVar23 = lVar23 + 1;
+      } while (lVar23 != 0x20);
+      if (DAT_00107060 == 0) {
+        lVar23 = 0;
+        puVar26 = &DAT_00104050;
+        puVar25 = &DAT_00105060;
+        do {
+          FUN_00101e10();
+          uVar10 = 0;
+          if (lVar23 != 0x1fff) {
+            uVar19 = 0;
+            uVar21 = (uint)lVar23 ^ 0x1fff;
+            uVar18 = uVar21;
+            uVar12 = uVar21;
+            do {
+              if ((uVar12 & 1) != 0) {
+                uVar19 = uVar19 ^ uVar18;
+              }
+              uVar18 = uVar18 * 2;
+              if (0x1fff < (int)uVar18) {
+                uVar18 = uVar18 ^ *puVar26;
+              }
+              uVar12 = (int)uVar12 >> 1;
+            } while (uVar12 != 0);
+            if (uVar19 == 0) {
+              uVar10 = 0;
+            }
+            else {
+              uVar18 = 0;
+              do {
+                if ((uVar19 & 1) != 0) {
+                  uVar18 = uVar18 ^ uVar21;
+                }
+                uVar10 = (undefined)uVar18;
+                uVar21 = uVar21 * 2;
+                if (0x1fff < (int)uVar21) {
+                  uVar21 = uVar21 ^ *puVar26;
+                }
+                uVar19 = (int)uVar19 >> 1;
+              } while (uVar19 != 0);
+            }
+          }
+          puVar25[lVar23] = uVar10;
+          lVar23 = lVar23 + 1;
+        } while (lVar23 != 0x2000);
+        lVar23 = 0;
+        puVar25 = &DAT_00104860;
+        do {
+          FUN_00101e10();
+          uVar10 = 0;
+          if (lVar23 != 0x7ff) {
+            uVar19 = 0;
+            uVar21 = (uint)lVar23 ^ 0x7ff;
+            uVar18 = uVar21;
+            uVar12 = uVar21;
+            do {
+              if ((uVar12 & 1) != 0) {
+                uVar19 = uVar19 ^ uVar18;
+              }
+              uVar18 = uVar18 * 2;
+              if (0x7ff < (int)uVar18) {
+                uVar18 = uVar18 ^ DAT_00104054;
+              }
+              uVar12 = (int)uVar12 >> 1;
+            } while (uVar12 != 0);
+            if (uVar19 == 0) {
+              uVar10 = 0;
+            }
+            else {
+              uVar18 = 0;
+              do {
+                if ((uVar19 & 1) != 0) {
+                  uVar18 = uVar18 ^ uVar21;
+                }
+                uVar10 = (undefined)uVar18;
+                uVar21 = uVar21 * 2;
+                if (0x7ff < (int)uVar21) {
+                  uVar21 = uVar21 ^ DAT_00104054;
+                }
+                uVar19 = (int)uVar19 >> 1;
+              } while (uVar19 != 0);
+            }
+          }
+          puVar25[lVar23] = uVar10;
+          uVar9 = _UNK_0010212c;
+          uVar8 = _UNK_00102128;
+          uVar7 = _UNK_00102124;
+          uVar6 = _DAT_00102120;
+          uVar5 = _UNK_0010211c;
+          uVar4 = _UNK_00102118;
+          uVar27 = _UNK_00102114;
+          uVar20 = _DAT_00102110;
+          uVar19 = _UNK_0010210c;
+          uVar12 = _UNK_00102108;
+          uVar18 = _UNK_00102104;
+          uVar21 = _DAT_00102100;
+          iVar3 = _UNK_001020fc;
+          iVar2 = _UNK_001020f8;
+          iVar22 = _UNK_001020f4;
+          iVar11 = _DAT_001020f0;
+          lVar23 = lVar23 + 1;
+        } while (lVar23 != 0x800);
+        puVar26 = (uint *)&DAT_00104060;
+        iVar30 = _DAT_001020e0;
+        iVar31 = _UNK_001020e4;
+        iVar32 = _UNK_001020e8;
+        iVar33 = _UNK_001020ec;
+        do {
+          puVar14 = puVar26 + 8;
+          puVar26[4] = (iVar32 >> 5) << 0xf & uVar4 | (iVar32 >> 4) << 7 & uVar8 |
+                       (iVar32 >> 7) << 0x1f | (iVar32 >> 6) << 0x17 & uVar12;
+          puVar26[5] = (iVar32 >> 2) << 0x17 & uVar12 | (iVar32 >> 1) << 0xf & uVar4 |
+                       (iVar32 >> 3) << 0x1f | iVar32 << 7 & uVar8;
+          puVar26[6] = (iVar33 >> 5) << 0xf & uVar5 | (iVar33 >> 4) << 7 & uVar9 |
+                       (iVar33 >> 7) << 0x1f | (iVar33 >> 6) << 0x17 & uVar19;
+          puVar26[7] = (iVar33 >> 2) << 0x17 & uVar19 | (iVar33 >> 1) << 0xf & uVar5 |
+                       (iVar33 >> 3) << 0x1f | iVar33 << 7 & uVar9;
+          *puVar26 = (iVar30 >> 5) << 0xf & uVar20 | (iVar30 >> 4) << 7 & uVar6 |
+                     (iVar30 >> 7) << 0x1f | (iVar30 >> 6) << 0x17 & uVar21;
+          puVar26[1] = (iVar30 >> 2) << 0x17 & uVar21 | (iVar30 >> 1) << 0xf & uVar20 |
+                       (iVar30 >> 3) << 0x1f | iVar30 << 7 & uVar6;
+          puVar26[2] = (iVar31 >> 5) << 0xf & uVar27 | (iVar31 >> 4) << 7 & uVar7 |
+                       (iVar31 >> 7) << 0x1f | (iVar31 >> 6) << 0x17 & uVar18;
+          puVar26[3] = (iVar31 >> 2) << 0x17 & uVar18 | (iVar31 >> 1) << 0xf & uVar27 |
+                       (iVar31 >> 3) << 0x1f | iVar31 << 7 & uVar7;
+          puVar26 = puVar14;
+          iVar30 = iVar30 + iVar11;
+          iVar31 = iVar31 + iVar22;
+          iVar32 = iVar32 + iVar2;
+          iVar33 = iVar33 + iVar3;
+        } while (puVar14 != (uint *)&DAT_00104860);
+        DAT_00107060 = 1;
+      }
+      uVar15 = FUN_00101b10(local_58);
+      auVar38._8_8_ = 0;
+      auVar38._0_8_ = uVar15;
+      uVar15 = FUN_00101b10(local_50);
+      auVar36._8_8_ = 0;
+      auVar36._0_8_ = uVar15;
+      uVar15 = FUN_00101b10(local_48);
+      uVar16 = FUN_00101b10(local_40);
+      auVar35._8_8_ = 0;
+      auVar35._0_8_ = uVar16;
+      FUN_00101e10();
+      iVar11 = DAT_00104058;
+      FUN_00101e10();
+      puVar28 = local_238;
+      uVar21 = DAT_0010405c;
+      while( true ) {
+        uVar34 = auVar35._0_8_;
+        uVar37 = auVar38._0_8_;
+        uVar18 = auVar36._4_4_ + auVar35._4_4_;
+        uVar16 = FUN_00101b30(CONCAT44(uVar18 + uVar21,
+                                       ((auVar35._0_4_ + auVar36._0_4_ + 1) -
+                                       (uint)(CARRY4(auVar36._4_4_,auVar35._4_4_) == false)) +
+                                       iVar11 + (uint)CARRY4(uVar18,uVar21)),uVar15);
+        *puVar28 = uVar16 ^ uVar37;
+        FUN_00101e10();
+        auVar38 = auVar36;
+        iVar22 = DAT_00104058;
+        auVar35._0_8_ = FUN_00101e10();
+        auVar35._8_8_ = extraout_XMM0_Qb;
+        bVar29 = CARRY4(uVar21,DAT_0010405c);
+        uVar21 = uVar21 + DAT_0010405c;
+        iVar11 = (iVar11 + iVar22 + 1) - (uint)(bVar29 == false);
+        puVar28 = puVar28 + 1;
+        if (local_b8 == puVar28) break;
+        auVar36._8_8_ = 0;
+        auVar36._0_8_ = uVar15;
+        uVar15 = uVar34;
+      }
+      uVar16 = 0xaae434d8c779ec9a;
+      uVar15 = 0xcf39801b6a4b1c33;
+      local_260 = local_b8;
+      do {
+        uVar19 = ((uint)*(byte *)(local_268 + 1) ^ (uint)uVar15) << 0x18 |
+                 (uint)(byte)((byte)(uVar15 >> 8) ^ *(byte *)((long)local_268 + 9)) << 0x10 |
+                 (uint)(byte)((byte)(uVar15 >> 0x18) ^ *(byte *)((long)local_268 + 0xb)) |
+                 (uint)(byte)((byte)(uVar15 >> 0x10) ^ *(byte *)((long)local_268 + 10)) << 8;
+        uVar12 = (uint)(byte)((byte)(uVar15 >> 0x20) ^ *(byte *)((long)local_268 + 0xc)) << 0x18 |
+                 (uint)(byte)((byte)(uVar15 >> 0x28) ^ *(byte *)((long)local_268 + 0xd)) << 0x10 |
+                 (uint)(byte)((byte)(uVar15 >> 0x38) ^ *(byte *)((long)local_268 + 0xf)) |
+                 (uint)(byte)((byte)(uVar15 >> 0x30) ^ *(byte *)((long)local_268 + 0xe)) << 8;
+        iVar11 = 1;
+        puVar28 = local_238;
+        uVar21 = ((uint)*(byte *)local_268 ^ (uint)uVar16) << 0x18 |
+                 (uint)(byte)((byte)(uVar16 >> 8) ^ *(byte *)((long)local_268 + 1)) << 0x10 |
+                 (uint)(byte)((byte)(uVar16 >> 0x18) ^ *(byte *)((long)local_268 + 3)) |
+                 (uint)(byte)((byte)(uVar16 >> 0x10) ^ *(byte *)((long)local_268 + 2)) << 8;
+        uVar18 = (uint)(byte)((byte)(uVar16 >> 0x20) ^ *(byte *)((long)local_268 + 4)) << 0x18 |
+                 (uint)(byte)((byte)(uVar16 >> 0x28) ^ *(byte *)((long)local_268 + 5)) << 0x10 |
+                 (uint)(byte)((byte)(uVar16 >> 0x38) ^ *(byte *)((long)local_268 + 7)) |
+                 (uint)(byte)((byte)(uVar16 >> 0x30) ^ *(byte *)((long)local_268 + 6)) << 8;
+        do {
+          uVar27 = uVar12 + *(uint *)((long)puVar28 + 4);
+          iVar22 = uVar19 + *(int *)puVar28 + (uint)CARRY4(uVar12,*(uint *)((long)puVar28 + 4));
+          uVar17 = FUN_00101b30(CONCAT44(uVar27,iVar22),local_238[iVar11]);
+          uVar20 = uVar27 + *(uint *)((long)puVar28 + 0x14);
+          uVar27 = iVar22 + *(int *)(puVar28 + 2) +
+                   (uint)CARRY4(uVar27,*(uint *)((long)puVar28 + 0x14));
+          puVar28 = puVar28 + 3;
+          iVar11 = iVar11 + 3;
+          uVar19 = uVar21 ^ (uint)uVar17;
+          uVar12 = uVar18 ^ (uint)((ulong)uVar17 >> 0x20);
+          uVar21 = uVar27;
+          uVar18 = uVar20;
+        } while (local_b8 != puVar28);
+        local_254 = (byte)(uVar20 >> 0x10);
+        local_288 = (byte)(uVar20 >> 0x18);
+        uVar16 = (((((((ulong)(uVar12 & 0xff) << 8 | (ulong)(uVar12 >> 8 & 0xff)) << 8 |
+                     (ulong)(uVar12 >> 0x10 & 0xff)) << 8 | (ulong)(uVar12 >> 0x18)) << 8 |
+                   (ulong)(uVar19 & 0xff)) << 8 | (ulong)(uVar19 >> 8 & 0xff)) << 8 |
+                 (ulong)(uVar19 >> 0x10 & 0xff)) << 8 | (ulong)(uVar19 >> 0x18);
+        local_268 = local_268 + 2;
+        *local_260 = uVar16;
+        local_260[1] = (((((((ulong)(byte)uVar20 << 8 | (ulong)(uVar20 >> 8 & 0xff)) << 8 |
+                           (ulong)local_254) << 8 | (ulong)local_288) << 8 | (ulong)(uVar27 & 0xff))
+                         << 8 | (ulong)(uVar27 >> 8 & 0xff)) << 8 | (ulong)(uVar27 >> 0x10 & 0xff))
+                       << 8 | (ulong)(uVar27 >> 0x18);
+        uVar15 = local_260[1];
+        local_260 = local_260 + 2;
+      } while (local_268 != (ulong *)&local_78);
+      __printf_chk(1,"Ciphertext(hex): ");
+      puVar28 = local_b8;
+      do {
+        uVar10 = *(undefined *)puVar28;
+        puVar28 = (ulong *)((long)puVar28 + 1);
+        __printf_chk(1,&DAT_0010203b,uVar10);
+      } while (puVar28 != local_98);
+      __printf_chk(1,"\n");
+      iVar11 = memcmp(local_b8,&local_78,0x20);
+      pcVar24 = "True";
+      if (iVar11 != 0) {
+        pcVar24 = "False";
+      }
+      __printf_chk(1,"Match: %s\n",pcVar24);
+      bVar29 = iVar11 != 0;
+    }
+    else {
+LAB_0010122a:
+      __fprintf_chk(*(undefined8 *)PTR_stderr_00103ff8,1,
+                    "Bad input hex. Expecting 64 hex chars (32 bytes).\n");
+      bVar29 = true;
+    }
+  }
+  else {
+    __fprintf_chk(*(undefined8 *)PTR_stderr_00103ff8,1,"Usage: %s <64-hex-chars>\n",*param_2);
+    bVar29 = true;
+  }
+  if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
+                    /* WARNING: Subroutine does not return */
+    __stack_chk_fail();
+  }
+  return bVar29;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_001019c0_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Removing unreachable block (ram,0x001019d3) */
+/* WARNING: Removing unreachable block (ram,0x001019df) */
+
+void FUN_001019c0(void)
+
+{
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_001019f0_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Removing unreachable block (ram,0x00101a14) */
+/* WARNING: Removing unreachable block (ram,0x00101a20) */
+
+void FUN_001019f0(void)
+
+{
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_00101a80_decompiled

@@ -0,0 +1,17 @@
+
+void FUN_00101a80(long param_1,ulong param_2)
+
+{
+  uint local_1c;
+  ulong local_18;
+  
+  local_1c = 0x4ed90b4c;
+  for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
+    local_1c = local_1c * 0x19660d + 0x3c6ef35f;
+    *(byte *)(local_18 + param_1) =
+         (byte)(local_1c >> (sbyte)(((uint)local_18 & 3) << 3)) ^
+         (&DAT_001020c0)[(uint)local_18 & 0x1f];
+  }
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_00101b10_decompiled

@@ -0,0 +1,13 @@
+
+undefined8 FUN_00101b10(uint *param_1)
+
+{
+  uint uVar1;
+  uint uVar2;
+  
+  uVar1 = *param_1;
+  uVar2 = param_1[1];
+  return CONCAT44(uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 | uVar2 << 0x18,
+                  uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18);
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_00101b30_decompiled

@@ -0,0 +1,47 @@
+
+ulong FUN_00101b30(undefined8 param_1,ulong param_2)
+
+{
+  uint uVar1;
+  uint uVar2;
+  uint uVar3;
+  uint uVar4;
+  
+  uVar1 = (uint)((ulong)param_1 >> 0x20);
+  uVar4 = (uVar1 ^ (uint)param_1) & (uint)(param_2 >> 0x20);
+  uVar3 = (uint)param_1 ^ uVar4;
+  uVar4 = uVar4 ^ uVar1;
+  uVar2 = *(uint *)(&DAT_00104060 + (ulong)(byte)(&DAT_00104860)[uVar3 & 0x7ff] * 8) >> 4 |
+          *(uint *)(&DAT_00104060 + (ulong)(byte)(&DAT_00105060)[uVar4 & 0x1fff] * 8) |
+          *(uint *)(&DAT_00104060 + (ulong)(byte)(&DAT_00104860)[uVar3 >> 0x10 & 0x7ff] * 8) >> 6 |
+          *(uint *)(&DAT_00104060 + (ulong)(byte)(&DAT_00105060)[uVar3 >> 8 & 0x1fff] * 8) >> 5 |
+          *(uint *)(&DAT_00104060 + (ulong)(byte)(&DAT_00105060)[uVar4 >> 0x10 & 0x1fff] * 8) >> 2 |
+          *(uint *)(&DAT_00104060 + (ulong)(byte)(&DAT_00104860)[uVar4 >> 8 & 0x7ff] * 8) >> 1 |
+          *(uint *)(&DAT_00104060 +
+                   (ulong)(byte)(&DAT_00105060)[uVar3 >> 0x18 | (uVar4 & 0x1f) << 8] * 8) >> 7 |
+          *(uint *)(&DAT_00104060 +
+                   (ulong)(byte)(&DAT_00104860)[(uVar3 & 7) << 8 | uVar4 >> 0x18] * 8) >> 3;
+  uVar1 = *(uint *)(&DAT_00104064 + (ulong)(byte)(&DAT_00104860)[uVar3 & 0x7ff] * 8) >> 4 |
+          *(uint *)(&DAT_00104064 + (ulong)(byte)(&DAT_00105060)[uVar4 & 0x1fff] * 8) |
+          *(uint *)(&DAT_00104064 + (ulong)(byte)(&DAT_00104860)[uVar3 >> 0x10 & 0x7ff] * 8) >> 6 |
+          *(uint *)(&DAT_00104064 + (ulong)(byte)(&DAT_00105060)[uVar3 >> 8 & 0x1fff] * 8) >> 5 |
+          *(uint *)(&DAT_00104064 + (ulong)(byte)(&DAT_00105060)[uVar4 >> 0x10 & 0x1fff] * 8) >> 2 |
+          *(uint *)(&DAT_00104064 + (ulong)(byte)(&DAT_00104860)[uVar4 >> 8 & 0x7ff] * 8) >> 1 |
+          *(uint *)(&DAT_00104064 +
+                   (ulong)(byte)(&DAT_00105060)[uVar3 >> 0x18 | (uVar4 & 0x1f) << 8] * 8) >> 7 |
+          *(uint *)(&DAT_00104064 +
+                   (ulong)(byte)(&DAT_00104860)[(uVar3 & 7) << 8 | uVar4 >> 0x18] * 8) >> 3;
+  return CONCAT44((uint)(byte)(&DAT_00105060)[uVar1 >> 8 & 0xff | (uint)param_2 * 8 & 0x1f00] << 8,
+                  (uint)(byte)(&DAT_00105060)[uVar2 >> 8 & 0xff | (uint)(param_2 >> 0xd) & 0x1f00]
+                  << 8) |
+         CONCAT44((uint)(byte)(&DAT_00104860)[uVar1 >> 0x10 & 0xff | (uint)(param_2 >> 2) & 0x700]
+                  << 0x10,(uint)(byte)(&DAT_00104860)
+                                      [uVar2 >> 0x10 & 0xff | (uint)(param_2 >> 0x12) & 0x700] <<
+                          0x10) |
+         (ulong)CONCAT41((uint)(byte)(&DAT_00104860)[(uint)(param_2 >> 5) & 0x700 | uVar1 >> 0x18]
+                         << 0x18,(&DAT_00104860)[(uint)(param_2 >> 0x15) & 0x700 | uVar2 >> 0x18])
+         << 0x18 | (ulong)CONCAT14((&DAT_00105060)[uVar1 & 0xff | ((uint)param_2 & 0x1f) << 8],
+                                   (uint)(byte)(&DAT_00105060)
+                                               [uVar2 & 0xff | (uint)(param_2 >> 8) & 0x1f00]);
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_00101dc0_decompiled

@@ -0,0 +1,7 @@
+
+void FUN_00101dc0(void)
+
+{
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_00101dd0_decompiled

@@ -0,0 +1,15 @@
+
+void FUN_00101dd0(uint *param_1,uint *param_2)
+
+{
+  uint *extraout_RDX;
+  
+  FUN_00101dc0();
+  *extraout_RDX = *param_1 ^ *param_2;
+  extraout_RDX[1] = param_1[1] ^ param_2[1];
+  extraout_RDX[2] = param_1[2] ^ param_2[2];
+  extraout_RDX[3] = param_1[3] ^ param_2[3];
+  FUN_00101dc0();
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/FUN_00101e10_decompiled

@@ -0,0 +1,14 @@
+
+void FUN_00101e10(undefined8 param_1)
+
+{
+  if (DAT_00104040 != 0) {
+    return;
+  }
+  FUN_00101dc0(param_1,&DAT_001020a0,&DAT_00104050,4);
+  FUN_00101dd0(&DAT_001020b0);
+  FUN_00101dc0();
+  DAT_00104040 = 1;
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/_DT_FINI_decompiled

@@ -0,0 +1,7 @@
+
+void _DT_FINI(void)
+
+{
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/_DT_INIT_decompiled

@@ -0,0 +1,10 @@
+
+void _DT_INIT(void)
+
+{
+  if (PTR___gmon_start___00103fe0 != (undefined *)0x0) {
+    (*(code *)PTR___gmon_start___00103fe0)();
+  }
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/_FINI_0_decompiled

@@ -0,0 +1,15 @@
+
+void _FINI_0(void)
+
+{
+  if (DAT_00104020 == '\0') {
+    if (PTR___cxa_finalize_00103ff0 != (undefined *)0x0) {
+      __cxa_finalize(PTR_LOOP_00104008);
+    }
+    FUN_001019c0();
+    DAT_00104020 = 1;
+    return;
+  }
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/_INIT_0_decompiled

@@ -0,0 +1,8 @@
+
+void _INIT_0(void)
+
+{
+  FUN_001019f0();
+  return;
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/_ITM_deregisterTMCloneTable_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void _ITM_deregisterTMCloneTable(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/_ITM_registerTMCloneTable_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void _ITM_registerTMCloneTable(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/__cxa_finalize_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __cxa_finalize(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/__fprintf_chk_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __fprintf_chk(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/__gmon_start___decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __gmon_start__(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/__libc_start_main_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __libc_start_main(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/__printf_chk_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __printf_chk(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/__stack_chk_fail_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __stack_chk_fail(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/entry_decompiled

@@ -0,0 +1,13 @@
+
+void processEntry entry(undefined8 param_1,undefined8 param_2)
+
+{
+  undefined auStack_8 [8];
+  
+  (*(code *)PTR___libc_start_main_00103fd0)
+            (FUN_001010e0,param_2,&stack0x00000008,0,0,param_1,auStack_8);
+  do {
+                    /* WARNING: Do nothing block with infinite loop */
+  } while( true );
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/memcmp_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+int memcmp(void *__s1,void *__s2,size_t __n)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/public-weak_prng_seeded-constxor/decompile/strlen_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+size_t strlen(char *__s)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/LOKI97/src/loki97.c

@@ -0,0 +1,315 @@
+/*
+ * Adapted for CREBench from the public LOKI97 reference implementations.
+ *
+ * Credits:
+ *   LOKI97 was written by Lawrie Brown, Josef Pieprzyk, and Jennifer Seberry.
+ *   Copyright (c) 1998 by Lawrie Brown and ITRACE (UNSW).
+ *   All rights reserved.
+ */
+
+#include "loki97.h"
+
+#include <string.h>
+
+#define LOKI97_ROUNDS 16
+#define LOKI97_NUM_SUBKEYS (3 * LOKI97_ROUNDS)
+
+#define S1_SIZE 0x2000
+#define S2_SIZE 0x0800
+
+static uint8_t s1[S1_SIZE];
+static uint8_t s2[S2_SIZE];
+static loki97_u64 perm_p[0x100];
+static int loki97_init_done = 0;
+
+#ifdef CONSTXOR_LOKI97_TABLES
+#include "constxor_tables.h"
+#define LOKI97_MAGIC_TABLE (constxor_loki97_magic())
+#else
+static const uint32_t loki97_magic[4] = {0x2911U, 0x0AA7U, 0x9E3779B9U, 0x7F4A7C15U};
+#define LOKI97_MAGIC_TABLE (loki97_magic)
+#endif
+
+#define LOKI97_S1_GEN_VALUE ((int)LOKI97_MAGIC_TABLE[0])
+#define LOKI97_S2_GEN_VALUE ((int)LOKI97_MAGIC_TABLE[1])
+#define LOKI97_DELTA_VALUE ((loki97_u64){LOKI97_MAGIC_TABLE[2], LOKI97_MAGIC_TABLE[3]})
+
+static int mult(int a, int b, int g, int n)
+{
+    int p = 0;
+    while (b != 0) {
+        if ((b & 0x01) != 0) {
+            p ^= a;
+        }
+        a <<= 1;
+        if (a >= n) {
+            a ^= g;
+        }
+        b >>= 1;
+    }
+    return p;
+}
+
+static int exp3(int b, int g, int n)
+{
+    int r = b;
+    if (b == 0) {
+        return 0;
+    }
+    b = mult(r, b, g, n);
+    r = mult(r, b, g, n);
+    return r;
+}
+
+static void loki97_init_tables(void)
+{
+    if (loki97_init_done) {
+        return;
+    }
+
+    const int s1_mask = S1_SIZE - 1;
+    const int s2_mask = S2_SIZE - 1;
+
+    for (int i = 0; i < S1_SIZE; i++) {
+        int b = i ^ s1_mask;
+        s1[i] = (uint8_t)exp3(b, LOKI97_S1_GEN_VALUE, S1_SIZE);
+    }
+
+    for (int i = 0; i < S2_SIZE; i++) {
+        int b = i ^ s2_mask;
+        s2[i] = (uint8_t)exp3(b, LOKI97_S2_GEN_VALUE, S2_SIZE);
+    }
+
+    for (int i = 0; i < 0x100; i++) {
+        uint32_t pval = 0;
+        for (int j = 0, k = 7; j < 4; j++, k += 8) {
+            pval |= ((uint32_t)((i >> j) & 0x1) << k);
+        }
+        perm_p[i].r = pval;
+        pval = 0;
+        for (int j = 4, k = 7; j < 8; j++, k += 8) {
+            pval |= ((uint32_t)((i >> j) & 0x1) << k);
+        }
+        perm_p[i].l = pval;
+    }
+
+    loki97_init_done = 1;
+}
+
+static loki97_u64 add64(loki97_u64 a, loki97_u64 b)
+{
+    loki97_u64 sum;
+    sum.r = a.r + b.r;
+    sum.l = a.l + b.l;
+    if (sum.r < b.r) {
+        sum.l++;
+    }
+    return sum;
+}
+
+static loki97_u64 sub64(loki97_u64 a, loki97_u64 b)
+{
+    loki97_u64 diff;
+    diff.r = a.r - b.r;
+    diff.l = a.l - b.l;
+    if (diff.r > a.r) {
+        diff.l--;
+    }
+    return diff;
+}
+
+static loki97_u64 xor64(loki97_u64 a, loki97_u64 b)
+{
+    loki97_u64 out;
+    out.l = a.l ^ b.l;
+    out.r = a.r ^ b.r;
+    return out;
+}
+
+static loki97_u64 load_u64(const uint8_t *in)
+{
+    loki97_u64 v;
+    v.l = ((uint32_t)in[0] << 24) | ((uint32_t)in[1] << 16) | ((uint32_t)in[2] << 8) | (uint32_t)in[3];
+    v.r = ((uint32_t)in[4] << 24) | ((uint32_t)in[5] << 16) | ((uint32_t)in[6] << 8) | (uint32_t)in[7];
+    return v;
+}
+
+static void store_u64(uint8_t *out, loki97_u64 v)
+{
+    out[0] = (uint8_t)(v.l >> 24);
+    out[1] = (uint8_t)(v.l >> 16);
+    out[2] = (uint8_t)(v.l >> 8);
+    out[3] = (uint8_t)v.l;
+    out[4] = (uint8_t)(v.r >> 24);
+    out[5] = (uint8_t)(v.r >> 16);
+    out[6] = (uint8_t)(v.r >> 8);
+    out[7] = (uint8_t)v.r;
+}
+
+static loki97_u64 f_func(loki97_u64 A, loki97_u64 B)
+{
+    loki97_u64 d, e, f;
+    uint32_t s;
+
+    d.l = (A.l & ~B.r) | (A.r & B.r);
+    d.r = (A.r & ~B.r) | (A.l & B.r);
+
+    s = s1[((d.l >> 24) | (d.r << 8)) & 0x1FFF];
+    e.l = perm_p[s].l >> 7;
+    e.r = perm_p[s].r >> 7;
+    s = s2[(d.l >> 16) & 0x7FF];
+    e.l |= perm_p[s].l >> 6;
+    e.r |= perm_p[s].r >> 6;
+    s = s1[(d.l >> 8) & 0x1FFF];
+    e.l |= perm_p[s].l >> 5;
+    e.r |= perm_p[s].r >> 5;
+    s = s2[d.l & 0x7FF];
+    e.l |= perm_p[s].l >> 4;
+    e.r |= perm_p[s].r >> 4;
+    s = s2[((d.r >> 24) | (d.l << 8)) & 0x7FF];
+    e.l |= perm_p[s].l >> 3;
+    e.r |= perm_p[s].r >> 3;
+    s = s1[(d.r >> 16) & 0x1FFF];
+    e.l |= perm_p[s].l >> 2;
+    e.r |= perm_p[s].r >> 2;
+    s = s2[(d.r >> 8) & 0x7FF];
+    e.l |= perm_p[s].l >> 1;
+    e.r |= perm_p[s].r >> 1;
+    s = s1[d.r & 0x1FFF];
+    e.l |= perm_p[s].l;
+    e.r |= perm_p[s].r;
+
+    f.l = ((uint32_t)s2[((e.l >> 24) & 0xFF) | ((B.l >> 21) & 0x700)] << 24)
+        | ((uint32_t)s2[((e.l >> 16) & 0xFF) | ((B.l >> 18) & 0x700)] << 16)
+        | ((uint32_t)s1[((e.l >> 8) & 0xFF) | ((B.l >> 13) & 0x1F00)] << 8)
+        | ((uint32_t)s1[(e.l & 0xFF) | ((B.l >> 8) & 0x1F00)]);
+
+    f.r = ((uint32_t)s2[((e.r >> 24) & 0xFF) | ((B.l >> 5) & 0x700)] << 24)
+        | ((uint32_t)s2[((e.r >> 16) & 0xFF) | ((B.l >> 2) & 0x700)] << 16)
+        | ((uint32_t)s1[((e.r >> 8) & 0xFF) | ((B.l << 3) & 0x1F00)] << 8)
+        | ((uint32_t)s1[(e.r & 0xFF) | ((B.l << 8) & 0x1F00)]);
+
+    return f;
+}
+
+int loki97_set_key(loki97_ctx *ctx, const uint8_t *key, size_t key_len)
+{
+    if (!ctx || !key) {
+        return -1;
+    }
+    if (key_len != 16 && key_len != 24 && key_len != 32) {
+        return -1;
+    }
+
+    loki97_init_tables();
+
+    loki97_u64 k4 = load_u64(key);
+    loki97_u64 k3 = load_u64(key + 8);
+    loki97_u64 k2;
+    loki97_u64 k1;
+
+    if (key_len == 16) {
+        k2 = f_func(k3, k4);
+        k1 = f_func(k4, k3);
+    } else {
+        k2 = load_u64(key + 16);
+        if (key_len == 24) {
+            k1 = f_func(k4, k3);
+        } else {
+            k1 = load_u64(key + 24);
+        }
+    }
+
+    loki97_u64 deltan = LOKI97_DELTA_VALUE;
+    for (int i = 0; i < LOKI97_NUM_SUBKEYS; i++) {
+        loki97_u64 t1 = add64(k1, k3);
+        loki97_u64 t2 = add64(t1, deltan);
+        loki97_u64 f_out = f_func(t2, k2);
+        ctx->sk[i] = xor64(k4, f_out);
+        k4 = k3;
+        k3 = k2;
+        k2 = k1;
+        k1 = ctx->sk[i];
+        deltan = add64(deltan, LOKI97_DELTA_VALUE);
+    }
+
+    return 0;
+}
+
+void loki97_encrypt_block(const loki97_ctx *ctx, const uint8_t *in, uint8_t *out)
+{
+    loki97_u64 L = load_u64(in);
+    loki97_u64 R = load_u64(in + 8);
+    loki97_u64 nR;
+    loki97_u64 f_out;
+    int k = 0;
+
+    for (int i = 0; i < LOKI97_ROUNDS; i++) {
+        nR = add64(R, ctx->sk[k++]);
+        f_out = f_func(nR, ctx->sk[k++]);
+        nR = add64(nR, ctx->sk[k++]);
+        R = xor64(L, f_out);
+        L = nR;
+    }
+
+    store_u64(out, R);
+    store_u64(out + 8, L);
+}
+
+void loki97_decrypt_block(const loki97_ctx *ctx, const uint8_t *in, uint8_t *out)
+{
+    loki97_u64 L = load_u64(in);
+    loki97_u64 R = load_u64(in + 8);
+    loki97_u64 nR;
+    loki97_u64 f_out;
+    int k = LOKI97_NUM_SUBKEYS - 1;
+
+    for (int i = 0; i < LOKI97_ROUNDS; i++) {
+        nR = sub64(R, ctx->sk[k--]);
+        f_out = f_func(nR, ctx->sk[k--]);
+        nR = sub64(nR, ctx->sk[k--]);
+        R = xor64(L, f_out);
+        L = nR;
+    }
+
+    store_u64(out, R);
+    store_u64(out + 8, L);
+}
+
+void loki97_cbc_encrypt(const loki97_ctx *ctx,
+                        const uint8_t *iv,
+                        const uint8_t *in,
+                        uint8_t *out,
+                        size_t len)
+{
+    uint8_t prev[LOKI97_BLOCK_SIZE];
+    memcpy(prev, iv, sizeof(prev));
+
+    for (size_t offset = 0; offset < len; offset += LOKI97_BLOCK_SIZE) {
+        uint8_t block[LOKI97_BLOCK_SIZE];
+        for (size_t i = 0; i < LOKI97_BLOCK_SIZE; i++) {
+            block[i] = (uint8_t)(in[offset + i] ^ prev[i]);
+        }
+        loki97_encrypt_block(ctx, block, out + offset);
+        memcpy(prev, out + offset, LOKI97_BLOCK_SIZE);
+    }
+}
+
+void loki97_cbc_decrypt(const loki97_ctx *ctx,
+                        const uint8_t *iv,
+                        const uint8_t *in,
+                        uint8_t *out,
+                        size_t len)
+{
+    uint8_t prev[LOKI97_BLOCK_SIZE];
+    memcpy(prev, iv, sizeof(prev));
+
+    for (size_t offset = 0; offset < len; offset += LOKI97_BLOCK_SIZE) {
+        uint8_t block[LOKI97_BLOCK_SIZE];
+        loki97_decrypt_block(ctx, in + offset, block);
+        for (size_t i = 0; i < LOKI97_BLOCK_SIZE; i++) {
+            out[offset + i] = (uint8_t)(block[i] ^ prev[i]);
+        }
+        memcpy(prev, in + offset, LOKI97_BLOCK_SIZE);
+    }
+}

CREBench/LOKI97/src/loki97.h

@@ -0,0 +1,57 @@
+/*
+ * Adapted for CREBench from the public LOKI97 reference implementations.
+ *
+ * Credits:
+ *   LOKI97 was written by Lawrie Brown, Josef Pieprzyk, and Jennifer Seberry.
+ *   Copyright (c) 1998 by Lawrie Brown and ITRACE (UNSW).
+ *   All rights reserved.
+ *
+ * LOKI97 Block Cipher - C implementation
+ *
+ * Block size: 128 bits (16 bytes)
+ * Key size: 128/192/256 bits (16/24/32 bytes)
+ */
+#ifndef LOKI97_H
+#define LOKI97_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define LOKI97_BLOCK_SIZE 16
+#define LOKI97_MAX_KEY_SIZE 32
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    uint32_t l;
+    uint32_t r;
+} loki97_u64;
+
+typedef struct {
+    loki97_u64 sk[48];
+} loki97_ctx;
+
+int loki97_set_key(loki97_ctx *ctx, const uint8_t *key, size_t key_len);
+
+void loki97_encrypt_block(const loki97_ctx *ctx, const uint8_t *in, uint8_t *out);
+void loki97_decrypt_block(const loki97_ctx *ctx, const uint8_t *in, uint8_t *out);
+
+void loki97_cbc_encrypt(const loki97_ctx *ctx,
+                        const uint8_t *iv,
+                        const uint8_t *in,
+                        uint8_t *out,
+                        size_t len);
+
+void loki97_cbc_decrypt(const loki97_ctx *ctx,
+                        const uint8_t *iv,
+                        const uint8_t *in,
+                        uint8_t *out,
+                        size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOKI97_H */

CREBench/LOKI97/test_vectors-fragmented_build.json

@@ -0,0 +1,37 @@
+[
+  {
+    "plaintext": "b71bd2fa62e987bd5ed5e227ffe7d8d992fca702ac1e627e1352745e1bfb857d",
+    "key": "7e93756fb6efde96745e10fe9e01d40fdc547f09b762ba8d0a502db6309d7bd2",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "fbdc6537f80c0fe3bff894f6cbb7a4821a8c3b0027fa9ae0e5fabe9a2dadf030",
+    "block_size": 16
+  },
+  {
+    "plaintext": "389f5c725ef0e9ef719ff5f0c5e054be80b1496193e75e04794ef16b9b934e7d",
+    "key": "7e93756fb6efde96745e10fe9e01d40fdc547f09b762ba8d0a502db6309d7bd2",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "bd220c8ea5052b8367e9b2f0dfd0df3ab52e093d2b1c2531efed5033b2033e93",
+    "block_size": 16
+  },
+  {
+    "plaintext": "6feb5fe16d74493abe5f6bd6211dbbf46f38f17592bb31198cb3faaf5d80f36b",
+    "key": "7e93756fb6efde96745e10fe9e01d40fdc547f09b762ba8d0a502db6309d7bd2",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "630023819f74bde6250004d766103c327b99488d0b9c500b4a6ce89da03b3578",
+    "block_size": 16
+  },
+  {
+    "plaintext": "099af1b541b236d7a8910813f98950b6c420fa2001282c0c25deba0d803e95b7",
+    "key": "7e93756fb6efde96745e10fe9e01d40fdc547f09b762ba8d0a502db6309d7bd2",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "08cd8e2974f008b81957160cd2d534a3f27b10b78638e4ffd64f96935d936cf6",
+    "block_size": 16
+  },
+  {
+    "plaintext": "0ac36cfe0a12e57adfecdb76bf791f9dcda7c4b653cddc2a3782149372d9261b",
+    "key": "7e93756fb6efde96745e10fe9e01d40fdc547f09b762ba8d0a502db6309d7bd2",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "6cb6e0904c2552ebc23d002262e4c29f1262ac72aeec671c52f1020ee9f8769c",
+    "block_size": 16
+  }
+]

CREBench/LOKI97/test_vectors-hardcode_plain.json

@@ -0,0 +1,37 @@
+[
+  {
+    "plaintext": "b71bd2fa62e987bd5ed5e227ffe7d8d992fca702ac1e627e1352745e1bfb857d",
+    "key": "37323cdc36471c5fa77253bb148eb5571a29cdcdf1527b968a151679f76eec7e",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "98d58c2ee69053048ad22767c55b4c7cf31bf81d7f731f1da1ca770b5cef5c8f",
+    "block_size": 16
+  },
+  {
+    "plaintext": "389f5c725ef0e9ef719ff5f0c5e054be80b1496193e75e04794ef16b9b934e7d",
+    "key": "37323cdc36471c5fa77253bb148eb5571a29cdcdf1527b968a151679f76eec7e",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "272248f095c76d76fe3e80814080bdabe10753a6e91a605a40a343dc7e215ef8",
+    "block_size": 16
+  },
+  {
+    "plaintext": "6feb5fe16d74493abe5f6bd6211dbbf46f38f17592bb31198cb3faaf5d80f36b",
+    "key": "37323cdc36471c5fa77253bb148eb5571a29cdcdf1527b968a151679f76eec7e",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "e9aee36e22ad62963baa7951bc4a4d2ccde43c3794dba98f31e5c2af56c54e30",
+    "block_size": 16
+  },
+  {
+    "plaintext": "099af1b541b236d7a8910813f98950b6c420fa2001282c0c25deba0d803e95b7",
+    "key": "37323cdc36471c5fa77253bb148eb5571a29cdcdf1527b968a151679f76eec7e",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "1d2380255e22750c7a57a17415b6e63c8f22fcfba567897bace1fc4c3124f41e",
+    "block_size": 16
+  },
+  {
+    "plaintext": "0ac36cfe0a12e57adfecdb76bf791f9dcda7c4b653cddc2a3782149372d9261b",
+    "key": "37323cdc36471c5fa77253bb148eb5571a29cdcdf1527b968a151679f76eec7e",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "50f518f16432541536efc564cd33472f47afd269e0716dfa9e59da8c0302f3ab",
+    "block_size": 16
+  }
+]

CREBench/LOKI97/test_vectors-weak_prng_seeded.json

@@ -0,0 +1,37 @@
+[
+  {
+    "plaintext": "b71bd2fa62e987bd5ed5e227ffe7d8d992fca702ac1e627e1352745e1bfb857d",
+    "key": "177940216765e177aeb26dc3fe6998d8cb0a3477bc80a5cfabff8c3dc99c04c5",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "f1cf0f5345310900ce4a43f68dcaeb5bd502cf0ed00852086b88b8fa12546120",
+    "block_size": 16
+  },
+  {
+    "plaintext": "389f5c725ef0e9ef719ff5f0c5e054be80b1496193e75e04794ef16b9b934e7d",
+    "key": "177940216765e177aeb26dc3fe6998d8cb0a3477bc80a5cfabff8c3dc99c04c5",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "7a74e1333cf71ca051115831b85849329137214938898c248e019cb1a1773cef",
+    "block_size": 16
+  },
+  {
+    "plaintext": "6feb5fe16d74493abe5f6bd6211dbbf46f38f17592bb31198cb3faaf5d80f36b",
+    "key": "177940216765e177aeb26dc3fe6998d8cb0a3477bc80a5cfabff8c3dc99c04c5",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "6052e319b50aa0c8066bd77a495865988089728de79197a7392ae74ad5123396",
+    "block_size": 16
+  },
+  {
+    "plaintext": "099af1b541b236d7a8910813f98950b6c420fa2001282c0c25deba0d803e95b7",
+    "key": "177940216765e177aeb26dc3fe6998d8cb0a3477bc80a5cfabff8c3dc99c04c5",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "ab1167a2e108d4498da691a68c71815388c560cc0a9fc7224a4b4f7d2278e0c3",
+    "block_size": 16
+  },
+  {
+    "plaintext": "0ac36cfe0a12e57adfecdb76bf791f9dcda7c4b653cddc2a3782149372d9261b",
+    "key": "177940216765e177aeb26dc3fe6998d8cb0a3477bc80a5cfabff8c3dc99c04c5",
+    "iv": "9aec79c7d834e4aa331c4b6a1b8039cf",
+    "ciphertext": "501ab3cb34799f39046794ce3ecb255ec3fd29c0074fe0c019d4272357ef8ccf",
+    "block_size": 16
+  }
+]

CREBench/Lucifer-128-ECB/Makefile

@@ -0,0 +1,9 @@
+.PHONY: all challenge clean
+
+all: challenge
+
+challenge:
+	$(MAKE) -C challenge_src
+
+clean:
+	$(MAKE) -C challenge_src clean

CREBench/Lucifer-128-ECB/challenge_src/Makefile

@@ -0,0 +1,22 @@
+CC := cc
+CFLAGS := -O3 -Wall -Wextra -std=c11
+CPPFLAGS := -I../src
+LTO ?= -flto
+STRIP_CMD ?= strip
+
+SRCS := challenge.c key_source.c ../src/lucifer.c
+OBJS := $(SRCS:.c=.o)
+
+TARGET := ../public/challenge
+
+all: $(TARGET)
+
+$(TARGET): $(OBJS)
+	@mkdir -p ../public
+	$(CC) $(CFLAGS) -o $@ $(OBJS) $(LTO)
+	$(STRIP_CMD) $@
+
+clean:
+	rm -f $(OBJS) $(TARGET)
+
+.PHONY: all clean

CREBench/Lucifer-128-ECB/challenge_src/challenge.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "../src/lucifer.h"
+
+extern void insecure_key_generate(uint8_t *key, size_t key_len);
+
+static int hex_char_to_nibble(char c) {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    return -1;
+}
+
+static int parse_hex(const char *hex, uint8_t *out, size_t out_len) {
+    size_t hex_len = strlen(hex);
+    if (hex_len != out_len * 2) return 0;
+    for (size_t i = 0; i < out_len; i++) {
+        int hi = hex_char_to_nibble(hex[2 * i]);
+        int lo = hex_char_to_nibble(hex[2 * i + 1]);
+        if (hi < 0 || lo < 0) return 0;
+        out[i] = (uint8_t)((hi << 4) | lo);
+    }
+    return 1;
+}
+
+static void print_hex(const unsigned char *buf, size_t len) {
+    for (size_t i = 0; i < len; i++) printf("%02x", buf[i]);
+}
+
+int main(int argc, char **argv) {
+    if (argc != 2) {
+        fprintf(stderr, "Usage: %s <64-hex-chars>\n", argv[0]);
+        return 1;
+    }
+
+    uint8_t key[LUCIFER_KEY_SIZE];
+    insecure_key_generate((uint8_t *)key, sizeof(key));
+
+    const uint8_t target_ciphertext[32] = {
+        0x01, 0xab, 0xc4, 0x7a, 0x7d, 0x6a, 0x1c, 0x98,
+        0xeb, 0xc9, 0xe1, 0x97, 0xdd, 0x58, 0x89, 0xfb,
+        0xb6, 0x87, 0x46, 0x1e, 0xcc, 0x80, 0xad, 0x32,
+        0xc3, 0xbf, 0xe0, 0xc6, 0x37, 0x24, 0x58, 0xbc
+    };
+
+    uint8_t plaintext[32];
+    if (!parse_hex(argv[1], plaintext, sizeof(plaintext))) {
+        fprintf(stderr, "Bad input hex. Expecting 64 hex chars (32 bytes).\n");
+        return 1;
+    }
+
+    lucifer_ctx ctx;
+    lucifer_set_encrypt_key(&ctx, key);
+
+    uint8_t ciphertext[32];
+    lucifer_ecb_encrypt(&ctx, plaintext, ciphertext, sizeof(ciphertext));
+
+    printf("Ciphertext(hex): ");
+    print_hex(ciphertext, sizeof(ciphertext));
+    printf("\n");
+
+    int same = memcmp(ciphertext, target_ciphertext, sizeof(ciphertext)) == 0;
+    printf("Match: %s\n", same ? "True" : "False");
+    return same ? 0 : 2;
+}

CREBench/Lucifer-128-ECB/challenge_src/constxor_tables.c

@@ -0,0 +1,199 @@
+#include "constxor_tables.h"
+
+#include <stddef.h>
+
+__attribute__((noinline, noclone))
+static void constxor_compiler_barrier(void) {
+    __asm__ __volatile__("" ::: "memory");
+}
+
+__attribute__((noinline, noclone))
+static void materialize_u8_table(const uint8_t *lhs_raw, const uint8_t *rhs_raw, uint8_t *out, size_t count) {
+    const volatile uint8_t *lhs = (const volatile uint8_t *)lhs_raw;
+    const volatile uint8_t *rhs = (const volatile uint8_t *)rhs_raw;
+    constxor_compiler_barrier();
+    for (size_t i = 0; i < count; ++i) {
+        out[i] = (uint8_t)(lhs[i] ^ rhs[i]);
+    }
+    constxor_compiler_barrier();
+}
+
+__attribute__((noinline, noclone))
+static void materialize_u16_table(const uint16_t *lhs_raw, const uint16_t *rhs_raw, uint16_t *out, size_t count) {
+    const volatile uint16_t *lhs = (const volatile uint16_t *)lhs_raw;
+    const volatile uint16_t *rhs = (const volatile uint16_t *)rhs_raw;
+    constxor_compiler_barrier();
+    for (size_t i = 0; i < count; ++i) {
+        out[i] = (uint16_t)(lhs[i] ^ rhs[i]);
+    }
+    constxor_compiler_barrier();
+}
+
+__attribute__((noinline, noclone))
+static void materialize_u64_table(const uint64_t *lhs_raw, const uint64_t *rhs_raw, uint64_t *out, size_t count) {
+    const volatile uint64_t *lhs = (const volatile uint64_t *)lhs_raw;
+    const volatile uint64_t *rhs = (const volatile uint64_t *)rhs_raw;
+    constxor_compiler_barrier();
+    for (size_t i = 0; i < count; ++i) {
+        out[i] = lhs[i] ^ rhs[i];
+    }
+    constxor_compiler_barrier();
+}
+
+__attribute__((noinline, noclone))
+static void materialize_u32_table(const uint32_t *lhs_raw, const uint32_t *rhs_raw, uint32_t *out, size_t count) {
+    const volatile uint32_t *lhs = (const volatile uint32_t *)lhs_raw;
+    const volatile uint32_t *rhs = (const volatile uint32_t *)rhs_raw;
+    constxor_compiler_barrier();
+    for (size_t i = 0; i < count; ++i) {
+        out[i] = lhs[i] ^ rhs[i];
+    }
+    constxor_compiler_barrier();
+}
+
+static const uint8_t Dps_xor_lhs[64] = {
+    0x30, 0x86, 0x85, 0x0C, 0xB9, 0xC7, 0xC4, 0xEC, 0x76, 0xCF, 0xB0, 0xA2, 0xFE, 0x43, 0x55, 0x96,
+    0xC3, 0x8B, 0x5B, 0x24, 0x0C, 0x33, 0x97, 0xB5, 0x19, 0x34, 0x0B, 0x28, 0x34, 0xE2, 0x21, 0x4D,
+    0x52, 0xFB, 0x0E, 0xD3, 0x6A, 0xEB, 0xF6, 0xC0, 0x9D, 0x33, 0xDE, 0xBB, 0x2B, 0x3D, 0x4B, 0x16,
+    0x06, 0xAF, 0x84, 0xC2, 0xA6, 0xB9, 0xDE, 0x09, 0xE7, 0x38, 0x8C, 0x11, 0x32, 0x04, 0xF8, 0x55
+};
+
+static const uint8_t Dps_xor_rhs[64] = {
+    0x34, 0x96, 0xA5, 0x0E, 0xB8, 0xCF, 0x84, 0x6C, 0xF6, 0xCB, 0xA0, 0x82, 0xFC, 0x42, 0x5D, 0xD6,
+    0x83, 0x0B, 0x5F, 0x34, 0x2C, 0x31, 0x96, 0xBD, 0x11, 0x74, 0x8B, 0x2C, 0x24, 0xC2, 0x23, 0x4C,
+    0x53, 0xF3, 0x4E, 0x53, 0x6E, 0xFB, 0xD6, 0xC2, 0x9F, 0x32, 0xD6, 0xFB, 0xAB, 0x39, 0x5B, 0x36,
+    0x26, 0xAD, 0x85, 0xCA, 0xE6, 0x39, 0xDA, 0x19, 0xF7, 0x18, 0x8E, 0x10, 0x3A, 0x44, 0x78, 0x51
+};
+
+static uint8_t Dps_decoded[64];
+static int Dps_ready;
+
+__attribute__((noinline, noclone))
+static void ensure_Dps_decoded(void) {
+    if (Dps_ready) {
+        return;
+    }
+    constxor_compiler_barrier();
+    materialize_u8_table(Dps_xor_lhs, Dps_xor_rhs, Dps_decoded, 64);
+    constxor_compiler_barrier();
+    Dps_ready = 1;
+}
+
+const uint8_t *constxor_lucifer_dps(void) {
+    ensure_Dps_decoded();
+    return Dps_decoded;
+}
+
+static const uint8_t TCB0_xor_lhs[256] = {
+    0xA6, 0x37, 0xC7, 0x39, 0x66, 0xCE, 0x11, 0x67, 0x37, 0x16, 0x68, 0x5F, 0x9C, 0x3F, 0xDA, 0xF8,
+    0xE7, 0xA7, 0xB5, 0xC4, 0x1D, 0xCF, 0x0F, 0x22, 0x22, 0x78, 0xE0, 0xE8, 0x9E, 0x5F, 0xD0, 0x30,
+    0xA6, 0xAD, 0x14, 0xB6, 0xD7, 0x51, 0x9C, 0xBA, 0x47, 0xA5, 0x7A, 0x48, 0x1A, 0x62, 0x52, 0xCD,
+    0x12, 0xB5, 0xEA, 0xFA, 0x8C, 0xA0, 0xE0, 0x8C, 0xE5, 0xF0, 0x59, 0x90, 0x4D, 0xDB, 0xF2, 0x5C,
+    0xE7, 0x96, 0x43, 0x21, 0x0A, 0x1F, 0x7F, 0x7B, 0x0C, 0xE0, 0x4E, 0x56, 0x8A, 0xB3, 0x99, 0x9E,
+    0x43, 0x6C, 0xB5, 0xAA, 0x7F, 0x36, 0x58, 0xA6, 0x22, 0x86, 0x28, 0x29, 0xC2, 0xFA, 0xEA, 0x0B,
+    0x84, 0x11, 0x18, 0x73, 0xE3, 0x6D, 0x47, 0xAF, 0x27, 0x03, 0x07, 0xCF, 0x4C, 0xAD, 0x8F, 0x81,
+    0x18, 0x92, 0xE4, 0xB1, 0x11, 0x8C, 0x4B, 0xAC, 0xD9, 0x90, 0x31, 0x91, 0x64, 0x7C, 0x5C, 0xB1,
+    0xEB, 0x0A, 0xA2, 0xC2, 0x71, 0xEB, 0x4C, 0x08, 0xCC, 0xF5, 0xD4, 0xE1, 0x2E, 0x58, 0xE2, 0xAC,
+    0x97, 0x7E, 0x8D, 0xE2, 0x34, 0x0F, 0x6F, 0xED, 0x46, 0x7F, 0xB6, 0x8D, 0xE1, 0x44, 0xC5, 0x07,
+    0x48, 0x82, 0x60, 0x33, 0x1E, 0x10, 0x03, 0x0B, 0x46, 0xF3, 0xFB, 0x9C, 0x35, 0x66, 0x02, 0x7D,
+    0x64, 0xA6, 0x47, 0xCE, 0x3E, 0x5A, 0x05, 0xD0, 0xD0, 0x8D, 0xE5, 0x95, 0x45, 0x3F, 0x7C, 0xB9,
+    0xE3, 0xD2, 0xFC, 0xE3, 0x08, 0x4D, 0x3E, 0x88, 0x58, 0x30, 0x77, 0xE2, 0xC2, 0xAF, 0x5B, 0x1A,
+    0xEC, 0x30, 0xB0, 0x9D, 0x85, 0xE6, 0x8C, 0x4D, 0x6A, 0xAF, 0xFB, 0x2F, 0xC1, 0xB8, 0x82, 0xD1,
+    0x95, 0x4E, 0x29, 0x3F, 0x23, 0x28, 0x32, 0x8F, 0x02, 0x68, 0x19, 0xB9, 0x71, 0x49, 0xCE, 0x87,
+    0x2E, 0x98, 0xEF, 0xD8, 0xC0, 0xD0, 0xBC, 0x44, 0x9A, 0x29, 0x28, 0x81, 0xC6, 0xCE, 0xA2, 0x80
+};
+
+static const uint8_t TCB0_xor_rhs[256] = {
+    0xF1, 0x22, 0xB2, 0x0F, 0x71, 0xF9, 0x05, 0x33, 0x43, 0x60, 0x7E, 0x6A, 0xC9, 0x48, 0xEE, 0xAE,
+    0x38, 0x3A, 0x48, 0x7A, 0x82, 0x70, 0x93, 0xFE, 0xDE, 0x86, 0x7E, 0x55, 0x43, 0xA0, 0x6C, 0xEE,
+    0x69, 0x20, 0xF9, 0x18, 0x58, 0xFE, 0x10, 0x76, 0xAB, 0x4B, 0xF4, 0xE5, 0xD7, 0x8D, 0xFE, 0x03,
+    0xC1, 0x24, 0x1B, 0x48, 0x1F, 0x13, 0x70, 0x5C, 0x15, 0x02, 0xCB, 0x21, 0x9C, 0x28, 0x42, 0x8E,
+    0x30, 0x03, 0xB6, 0x97, 0x9D, 0xA8, 0xEB, 0xAF, 0xF8, 0x16, 0xD8, 0xE3, 0x5F, 0x44, 0x2D, 0x48,
+    0x1C, 0x71, 0xC8, 0x94, 0x60, 0x09, 0x44, 0xFA, 0x5E, 0xF8, 0x36, 0x14, 0x9F, 0x85, 0xD6, 0x55,
+    0x5F, 0x88, 0xE1, 0xC9, 0x78, 0xD6, 0xDF, 0x77, 0xDF, 0xF9, 0x9D, 0x76, 0x95, 0x56, 0x37, 0x5B,
+    0x5B, 0x93, 0x85, 0x93, 0x12, 0xAF, 0x4B, 0xEC, 0xB9, 0xF2, 0x33, 0xB0, 0x25, 0x1F, 0x7C, 0xF3,
+    0x28, 0x8B, 0x43, 0x60, 0xF2, 0x48, 0xCC, 0xC8, 0x2C, 0x17, 0x56, 0x40, 0xEF, 0xBB, 0x42, 0x6E,
+    0x50, 0xFB, 0x68, 0x44, 0xB3, 0xA8, 0xEB, 0x29, 0xA2, 0x99, 0x30, 0x28, 0x24, 0xA3, 0x61, 0xC1,
+    0x83, 0x0B, 0x89, 0x99, 0x95, 0xBB, 0x8B, 0xC3, 0xAE, 0x19, 0x71, 0x35, 0xFC, 0x8D, 0xAA, 0xB7,
+    0x2F, 0xAF, 0x2E, 0xE4, 0x35, 0x71, 0x0D, 0x98, 0xB8, 0xE7, 0xEF, 0xBC, 0x0C, 0x54, 0x54, 0xF3,
+    0xB8, 0xCB, 0x85, 0xD9, 0x13, 0x76, 0x26, 0xD0, 0x20, 0x4A, 0x6D, 0xDB, 0x9B, 0xD4, 0x63, 0x40,
+    0xAB, 0x35, 0xD5, 0xBB, 0x82, 0xC1, 0x88, 0x09, 0x0E, 0xC9, 0xFD, 0x0A, 0x84, 0xDF, 0xA6, 0x97,
+    0xDA, 0x43, 0x44, 0x11, 0x2C, 0x07, 0x3E, 0xC3, 0x6E, 0x06, 0x17, 0x94, 0x3C, 0x26, 0xE2, 0xC9,
+    0x7D, 0x89, 0x9E, 0xEA, 0xD3, 0xE3, 0xAC, 0x14, 0xEA, 0x5B, 0x3A, 0xB0, 0x97, 0xBD, 0x92, 0xD2
+};
+
+static uint8_t TCB0_decoded[256];
+static int TCB0_ready;
+
+__attribute__((noinline, noclone))
+static void ensure_TCB0_decoded(void) {
+    if (TCB0_ready) {
+        return;
+    }
+    constxor_compiler_barrier();
+    materialize_u8_table(TCB0_xor_lhs, TCB0_xor_rhs, TCB0_decoded, 256);
+    constxor_compiler_barrier();
+    TCB0_ready = 1;
+}
+
+const uint8_t *constxor_lucifer_tcb0(void) {
+    ensure_TCB0_decoded();
+    return TCB0_decoded;
+}
+
+static const uint8_t TCB1_xor_lhs[256] = {
+    0x38, 0x21, 0x2E, 0x9B, 0xAD, 0x6F, 0xE8, 0x58, 0x05, 0x03, 0xD0, 0x4A, 0xD2, 0xAE, 0x72, 0xE1,
+    0xC1, 0x57, 0xAC, 0x01, 0xE8, 0x8C, 0xE4, 0xE9, 0x7F, 0x3E, 0x39, 0x8D, 0x3A, 0xA1, 0xD6, 0x61,
+    0x5A, 0xFE, 0xA4, 0xCC, 0x04, 0x92, 0xDF, 0x80, 0x2D, 0xA2, 0xAC, 0xC9, 0xBE, 0x21, 0x1D, 0xC7,
+    0xD1, 0xD8, 0x9A, 0xD0, 0x7D, 0x87, 0x7F, 0xDE, 0xD9, 0x10, 0x87, 0x3A, 0x19, 0x4E, 0xA2, 0xA8,
+    0x86, 0x41, 0xDF, 0x9E, 0x31, 0x4F, 0xF4, 0xDF, 0x5C, 0x27, 0xB8, 0x32, 0x0C, 0x6A, 0x00, 0x41,
+    0xE2, 0x8F, 0xBB, 0x15, 0x0E, 0xE8, 0x3A, 0xD9, 0xBE, 0x99, 0x46, 0xD0, 0x4B, 0x50, 0xE1, 0x37,
+    0xE8, 0xAF, 0xA0, 0xB0, 0x21, 0x8A, 0x0A, 0xC5, 0x82, 0x6B, 0x93, 0x26, 0xFC, 0xF3, 0x92, 0xF6,
+    0x1B, 0x28, 0x9F, 0x0C, 0xB3, 0x7A, 0x9C, 0x11, 0x73, 0xE1, 0xCD, 0x02, 0x1B, 0xAC, 0xA1, 0x9C,
+    0xFF, 0x2C, 0xCF, 0xFB, 0xA2, 0x9B, 0x08, 0x98, 0xD5, 0xBA, 0x20, 0x3A, 0x39, 0x11, 0x56, 0x84,
+    0xD3, 0x52, 0x15, 0x6F, 0x76, 0xAC, 0x14, 0x24, 0xEC, 0xDC, 0xD2, 0x02, 0x55, 0x55, 0x1E, 0xA6,
+    0x9C, 0xC0, 0xC8, 0x75, 0x31, 0x04, 0x72, 0xB8, 0xEF, 0x37, 0x04, 0x70, 0xB6, 0x32, 0x89, 0xF1,
+    0x06, 0xA2, 0x1C, 0x6E, 0x57, 0xC9, 0x93, 0x79, 0xD8, 0xCC, 0xE6, 0xB3, 0xB6, 0xA2, 0x8C, 0x46,
+    0x92, 0xD6, 0x29, 0x95, 0xD2, 0xF6, 0x95, 0x99, 0xAA, 0x66, 0xFF, 0x5D, 0xC8, 0x1D, 0xA3, 0xC2,
+    0x79, 0x0A, 0x0C, 0xCC, 0x31, 0xEA, 0xEB, 0x91, 0xE8, 0x5D, 0xC0, 0x37, 0xFC, 0xBC, 0x92, 0xC4,
+    0x4D, 0x43, 0x01, 0x28, 0xFD, 0x35, 0x3C, 0x7B, 0x35, 0x45, 0x46, 0x80, 0x06, 0x51, 0x8E, 0xE2,
+    0x93, 0x0B, 0x62, 0x05, 0xC0, 0x3C, 0x83, 0xBE, 0xE3, 0xCC, 0x05, 0x85, 0x3D, 0x2F, 0xE3, 0x40
+};
+
+static const uint8_t TCB1_xor_rhs[256] = {
+    0x6F, 0xFE, 0xE1, 0x48, 0x7A, 0x30, 0x33, 0x1B, 0xC6, 0xC4, 0x1B, 0x01, 0x89, 0xE9, 0x3D, 0xB2,
+    0xD4, 0xCA, 0x21, 0x90, 0x7D, 0x91, 0x7D, 0xE8, 0xFE, 0xBB, 0xB0, 0x84, 0x23, 0xA4, 0xDB, 0x70,
+    0x2F, 0x03, 0x49, 0x3D, 0xF1, 0xEF, 0x26, 0xE1, 0xCC, 0x47, 0x45, 0xA0, 0xC7, 0x44, 0x70, 0xB6,
+    0xE7, 0x66, 0x34, 0x62, 0xCB, 0xB9, 0xC5, 0xFC, 0x7B, 0xB6, 0x2D, 0x10, 0x23, 0x68, 0x8C, 0x9A,
+    0x91, 0xDE, 0x50, 0x0D, 0xA6, 0x50, 0x6F, 0xDC, 0xDF, 0xA0, 0x33, 0x39, 0x17, 0x6D, 0x0F, 0x52,
+    0xD5, 0x30, 0x14, 0xA6, 0xB9, 0xD7, 0x81, 0xFA, 0x1D, 0x3E, 0xED, 0xFB, 0x70, 0x77, 0xCE, 0x04,
+    0xFC, 0x33, 0x2C, 0x20, 0xB5, 0x96, 0x92, 0xC5, 0x02, 0xEF, 0x1B, 0x2E, 0xE4, 0xF7, 0x9E, 0xE6,
+    0x4F, 0xF4, 0x53, 0xDC, 0x67, 0x26, 0x44, 0x51, 0xB3, 0x25, 0x05, 0x4A, 0x43, 0xE8, 0xED, 0xCC,
+    0x8B, 0xD0, 0x23, 0x0B, 0x56, 0xE7, 0xF0, 0xF8, 0x35, 0x5E, 0xC8, 0x52, 0x41, 0x75, 0x3A, 0xF4,
+    0xA5, 0xAC, 0xFB, 0x9D, 0x80, 0xD2, 0xEE, 0x46, 0x0E, 0x3A, 0x38, 0x68, 0x2F, 0x33, 0x70, 0xD4,
+    0x8A, 0x5E, 0x46, 0xE7, 0xA7, 0x1A, 0xE8, 0xBA, 0x6D, 0xB1, 0x8E, 0x7A, 0xAC, 0x34, 0x87, 0xE3,
+    0x33, 0x1F, 0xB1, 0xDF, 0xE2, 0xF4, 0x2A, 0x58, 0x79, 0x69, 0x4F, 0x9A, 0x8F, 0x87, 0xA1, 0x77,
+    0xC7, 0x0B, 0xE4, 0x44, 0x07, 0xAB, 0x4C, 0xD8, 0x6B, 0xA3, 0x36, 0x14, 0x91, 0x58, 0xEE, 0x93,
+    0x0E, 0xF5, 0xE3, 0x3F, 0xC6, 0x95, 0x10, 0xF2, 0x0B, 0xBA, 0x2B, 0x5C, 0x87, 0xDB, 0xFD, 0xB7,
+    0x79, 0xFF, 0xAD, 0x98, 0x49, 0x09, 0x84, 0x5B, 0x95, 0xE1, 0xEE, 0xA8, 0x3E, 0x75, 0xA2, 0xD2,
+    0xC5, 0xD5, 0xAC, 0xD7, 0x16, 0x62, 0x59, 0xFC, 0x21, 0x0A, 0xCF, 0xCF, 0x67, 0x69, 0xAD, 0x12
+};
+
+static uint8_t TCB1_decoded[256];
+static int TCB1_ready;
+
+__attribute__((noinline, noclone))
+static void ensure_TCB1_decoded(void) {
+    if (TCB1_ready) {
+        return;
+    }
+    constxor_compiler_barrier();
+    materialize_u8_table(TCB1_xor_lhs, TCB1_xor_rhs, TCB1_decoded, 256);
+    constxor_compiler_barrier();
+    TCB1_ready = 1;
+}
+
+const uint8_t *constxor_lucifer_tcb1(void) {
+    ensure_TCB1_decoded();
+    return TCB1_decoded;
+}

CREBench/Lucifer-128-ECB/challenge_src/constxor_tables.h

@@ -0,0 +1,10 @@
+#ifndef CONSTXOR_TABLES_H
+#define CONSTXOR_TABLES_H
+
+#include <stdint.h>
+
+const uint8_t *constxor_lucifer_dps(void);
+const uint8_t *constxor_lucifer_tcb0(void);
+const uint8_t *constxor_lucifer_tcb1(void);
+
+#endif /* CONSTXOR_TABLES_H */

CREBench/Lucifer-128-ECB/challenge_src/generated/fragmented_build/challenge.c

@@ -0,0 +1,68 @@
+/* key_mode=fragmented_build variant=randomized challenge=Lucifer-128-ECB */
+/* canonical_flag=4cde8c3e531d8400971b8e064f31e7c627fb6bd1ece498fb510b10fb2756fb21 */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "../src/lucifer.h"
+
+extern void insecure_key_generate(uint8_t *key, size_t key_len);
+
+static int hex_char_to_nibble(char c) {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    return -1;
+}
+
+static int parse_hex(const char *hex, uint8_t *out, size_t out_len) {
+    size_t hex_len = strlen(hex);
+    if (hex_len != out_len * 2) return 0;
+    for (size_t i = 0; i < out_len; i++) {
+        int hi = hex_char_to_nibble(hex[2 * i]);
+        int lo = hex_char_to_nibble(hex[2 * i + 1]);
+        if (hi < 0 || lo < 0) return 0;
+        out[i] = (uint8_t)((hi << 4) | lo);
+    }
+    return 1;
+}
+
+static void print_hex(const unsigned char *buf, size_t len) {
+    for (size_t i = 0; i < len; i++) printf("%02x", buf[i]);
+}
+
+int main(int argc, char **argv) {
+    if (argc != 2) {
+        fprintf(stderr, "Usage: %s <64-hex-chars>\n", argv[0]);
+        return 1;
+    }
+
+    uint8_t key[LUCIFER_KEY_SIZE];
+    insecure_key_generate((uint8_t *)key, sizeof(key));
+
+    const uint8_t target_ciphertext[32] = {
+        0x16, 0xda, 0xa6, 0xec, 0xe6, 0x55, 0xc8, 0x97,
+        0xbb, 0x3e, 0x93, 0x92, 0x28, 0xf2, 0x7a, 0x98,
+        0x78, 0xd0, 0x9d, 0xf2, 0x29, 0x3e, 0xe4, 0xf3,
+        0xcf, 0x9e, 0x27, 0x12, 0xb0, 0x92, 0x43, 0xd5
+    };
+
+    uint8_t plaintext[32];
+    if (!parse_hex(argv[1], plaintext, sizeof(plaintext))) {
+        fprintf(stderr, "Bad input hex. Expecting 64 hex chars (32 bytes).\n");
+        return 1;
+    }
+
+    lucifer_ctx ctx;
+    lucifer_set_encrypt_key(&ctx, key);
+
+    uint8_t ciphertext[32];
+    lucifer_ecb_encrypt(&ctx, plaintext, ciphertext, sizeof(ciphertext));
+
+    printf("Ciphertext(hex): ");
+    print_hex(ciphertext, sizeof(ciphertext));
+    printf("\n");
+
+    int same = memcmp(ciphertext, target_ciphertext, sizeof(ciphertext)) == 0;
+    printf("Match: %s\n", same ? "True" : "False");
+    return same ? 0 : 1;
+}

CREBench/Lucifer-128-ECB/challenge_src/generated/fragmented_build/key_source.c

@@ -0,0 +1,34 @@
+/* instance_label=Lucifer-128-ECB-fragmented_build-random variant=even_odd_xor */
+#include <stddef.h>
+#include <stdint.h>
+
+#define INSECURE_KEY_NOOPT __attribute__((noinline, noclone, optimize("O0")))
+
+
+static const uint8_t FRAG_EVEN[] = {
+    0x87, 0xc7, 0xca, 0xe5, 0xc6, 0x01, 0x97, 0x33
+};
+
+static const uint8_t FRAG_ODD[] = {
+    0xe2, 0x5b, 0xb1, 0xc6, 0xe0, 0xc7, 0x06, 0xf2
+};
+
+INSECURE_KEY_NOOPT
+static uint8_t rebuild_byte(size_t index) {
+    volatile const uint8_t *even = FRAG_EVEN;
+    volatile const uint8_t *odd = FRAG_ODD;
+    volatile uint8_t value;
+    if ((index & 1U) == 0U) {
+        value = (uint8_t)(even[index / 2] ^ 0xd9);
+    } else {
+        value = (uint8_t)(odd[index / 2] ^ 0xd9);
+    }
+    return value;
+}
+
+INSECURE_KEY_NOOPT
+void insecure_key_generate(uint8_t *key, size_t key_len) {
+    for (size_t i = 0; i < key_len; i++) {
+        key[i] = rebuild_byte(i % 16);
+    }
+}

CREBench/Lucifer-128-ECB/challenge_src/generated/fragmented_build/metadata.json

@@ -0,0 +1,10 @@
+{
+  "challenge": "Lucifer-128-ECB",
+  "key_mode": "fragmented_build",
+  "variant": "randomized",
+  "flag": "4cde8c3e531d8400971b8e064f31e7c627fb6bd1ece498fb510b10fb2756fb21",
+  "key": "5e3b1e8213683c1f1f39d81e4edfea2b",
+  "iv": "",
+  "target_ciphertext": "16daa6ece655c897bb3e939228f27a9878d09df2293ee4f3cf9e2712b09243d5",
+  "test_vectors_path": "CREBench/Lucifer-128-ECB/test_vectors-fragmented_build.json"
+}

CREBench/Lucifer-128-ECB/challenge_src/generated/hardcode_plain/challenge.c

@@ -0,0 +1,68 @@
+/* key_mode=hardcode_plain variant=randomized challenge=Lucifer-128-ECB */
+/* canonical_flag=4cde8c3e531d8400971b8e064f31e7c627fb6bd1ece498fb510b10fb2756fb21 */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "../src/lucifer.h"
+
+extern void insecure_key_generate(uint8_t *key, size_t key_len);
+
+static int hex_char_to_nibble(char c) {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    return -1;
+}
+
+static int parse_hex(const char *hex, uint8_t *out, size_t out_len) {
+    size_t hex_len = strlen(hex);
+    if (hex_len != out_len * 2) return 0;
+    for (size_t i = 0; i < out_len; i++) {
+        int hi = hex_char_to_nibble(hex[2 * i]);
+        int lo = hex_char_to_nibble(hex[2 * i + 1]);
+        if (hi < 0 || lo < 0) return 0;
+        out[i] = (uint8_t)((hi << 4) | lo);
+    }
+    return 1;
+}
+
+static void print_hex(const unsigned char *buf, size_t len) {
+    for (size_t i = 0; i < len; i++) printf("%02x", buf[i]);
+}
+
+int main(int argc, char **argv) {
+    if (argc != 2) {
+        fprintf(stderr, "Usage: %s <64-hex-chars>\n", argv[0]);
+        return 1;
+    }
+
+    uint8_t key[LUCIFER_KEY_SIZE];
+    insecure_key_generate((uint8_t *)key, sizeof(key));
+
+    const uint8_t target_ciphertext[32] = {
+        0x33, 0xc2, 0x7c, 0x4f, 0xd0, 0xee, 0x40, 0x3a,
+        0x11, 0xe2, 0x6a, 0x9e, 0x03, 0xd7, 0x69, 0x42,
+        0xdd, 0x20, 0xab, 0xe1, 0xbc, 0x93, 0x37, 0xe8,
+        0xbd, 0xb3, 0x2c, 0xde, 0x0c, 0x7a, 0x84, 0xc5
+    };
+
+    uint8_t plaintext[32];
+    if (!parse_hex(argv[1], plaintext, sizeof(plaintext))) {
+        fprintf(stderr, "Bad input hex. Expecting 64 hex chars (32 bytes).\n");
+        return 1;
+    }
+
+    lucifer_ctx ctx;
+    lucifer_set_encrypt_key(&ctx, key);
+
+    uint8_t ciphertext[32];
+    lucifer_ecb_encrypt(&ctx, plaintext, ciphertext, sizeof(ciphertext));
+
+    printf("Ciphertext(hex): ");
+    print_hex(ciphertext, sizeof(ciphertext));
+    printf("\n");
+
+    int same = memcmp(ciphertext, target_ciphertext, sizeof(ciphertext)) == 0;
+    printf("Match: %s\n", same ? "True" : "False");
+    return same ? 0 : 1;
+}