kris
/
xmss-KAT-generator
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
91 Commits
1 Branch
488 KiB
 
 
Tree: 59d304027c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '59d304027c'
${ noResults }
xmss-KAT-generator/params.c

466 lines
11 KiB
Raw Blame History 

  1. #include <stdint.h>

  2. #include <string.h>

  3. 

  4. #include "params.h"

  5. #include "xmss_core.h"

  6. 

  7. int xmss_str_to_oid(uint32_t *oid, const char *s)

  8. {

  9.     if (!strcmp(s, "XMSS-SHA2_10_256")) {

  10.         *oid = 0x01000001;

  11.     }

  12.     else if (!strcmp(s, "XMSS-SHA2_16_256")) {

  13.         *oid = 0x02000002;

  14.     }

  15.     else if (!strcmp(s, "XMSS-SHA2_20_256")) {

  16.         *oid = 0x03000003;

  17.     }

  18.     else if (!strcmp(s, "XMSS-SHA2_10_512")) {

  19.         *oid = 0x04000004;

  20.     }

  21.     else if (!strcmp(s, "XMSS-SHA2_16_512")) {

  22.         *oid = 0x05000005;

  23.     }

  24.     else if (!strcmp(s, "XMSS-SHA2_20_512")) {

  25.         *oid = 0x06000006;

  26.     }

  27.     else if (!strcmp(s, "XMSS-SHAKE_10_256")) {

  28.         *oid = 0x07000007;

  29.     }

  30.     else if (!strcmp(s, "XMSS-SHAKE_16_256")) {

  31.         *oid = 0x08000008;

  32.     }

  33.     else if (!strcmp(s, "XMSS-SHAKE_20_256")) {

  34.         *oid = 0x09000009;

  35.     }

  36.     else if (!strcmp(s, "XMSS-SHAKE_10_512")) {

  37.         *oid = 0x0a00000a;

  38.     }

  39.     else if (!strcmp(s, "XMSS-SHAKE_16_512")) {

  40.         *oid = 0x0b00000b;

  41.     }

  42.     else if (!strcmp(s, "XMSS-SHAKE_20_512")) {

  43.         *oid = 0x0c00000c;

  44.     }

  45.     else {

  46.         return -1;

  47.     }

  48.     return 0;

  49. }

  50. 

  51. int xmssmt_str_to_oid(uint32_t *oid, const char *s)

  52. {

  53.     if (!strcmp(s, "XMSSMT-SHA2_20/2_256")) {

  54.        *oid = 0x01000001;

  55.     }

  56.     else if (!strcmp(s, "XMSSMT-SHA2_20/4_256")) {

  57.        *oid = 0x02000002;

  58.     }

  59.     else if (!strcmp(s, "XMSSMT-SHA2_40/2_256")) {

  60.        *oid = 0x03000003;

  61.     }

  62.     else if (!strcmp(s, "XMSSMT-SHA2_40/4_256")) {

  63.        *oid = 0x04000004;

  64.     }

  65.     else if (!strcmp(s, "XMSSMT-SHA2_40/8_256")) {

  66.        *oid = 0x05000005;

  67.     }

  68.     else if (!strcmp(s, "XMSSMT-SHA2_60/3_256")) {

  69.        *oid = 0x06000006;

  70.     }

  71.     else if (!strcmp(s, "XMSSMT-SHA2_60/6_256")) {

  72.        *oid = 0x07000007;

  73.     }

  74.     else if (!strcmp(s, "XMSSMT-SHA2_60/12_256")) {

  75.       *oid = 0x08000008;

  76.     }

  77.     else if (!strcmp(s, "XMSSMT-SHA2_20/2_512")) {

  78.        *oid = 0x09000009;

  79.     }

  80.     else if (!strcmp(s, "XMSSMT-SHA2_20/4_512")) {

  81.        *oid = 0x0a00000a;

  82.     }

  83.     else if (!strcmp(s, "XMSSMT-SHA2_40/2_512")) {

  84.        *oid = 0x0b00000b;

  85.     }

  86.     else if (!strcmp(s, "XMSSMT-SHA2_40/4_512")) {

  87.        *oid = 0x0c00000c;

  88.     }

  89.     else if (!strcmp(s, "XMSSMT-SHA2_40/8_512")) {

  90.        *oid = 0x0d00000d;

  91.     }

  92.     else if (!strcmp(s, "XMSSMT-SHA2_60/3_512")) {

  93.        *oid = 0x0e00000e;

  94.     }

  95.     else if (!strcmp(s, "XMSSMT-SHA2_60/6_512")) {

  96.        *oid = 0x0f00000f;

  97.     }

  98.     else if (!strcmp(s, "XMSSMT-SHA2_60/12_512")) {

  99.       *oid = 0x01010101;

  100.     }

  101.     else if (!strcmp(s, "XMSSMT-SHAKE_20/2_256")) {

  102.       *oid = 0x02010102;

  103.     }

  104.     else if (!strcmp(s, "XMSSMT-SHAKE_20/4_256")) {

  105.       *oid = 0x03010103;

  106.     }

  107.     else if (!strcmp(s, "XMSSMT-SHAKE_40/2_256")) {

  108.       *oid = 0x04010104;

  109.     }

  110.     else if (!strcmp(s, "XMSSMT-SHAKE_40/4_256")) {

  111.       *oid = 0x05010105;

  112.     }

  113.     else if (!strcmp(s, "XMSSMT-SHAKE_40/8_256")) {

  114.       *oid = 0x06010106;

  115.     }

  116.     else if (!strcmp(s, "XMSSMT-SHAKE_60/3_256")) {

  117.       *oid = 0x07010107;

  118.     }

  119.     else if (!strcmp(s, "XMSSMT-SHAKE_60/6_256")) {

  120.       *oid = 0x08010108;

  121.     }

  122.     else if (!strcmp(s, "XMSSMT-SHAKE_60/12_256")) {

  123.      *oid = 0x09010109;

  124.     }

  125.     else if (!strcmp(s, "XMSSMT-SHAKE_20/2_512")) {

  126.       *oid = 0x0a01010a;

  127.     }

  128.     else if (!strcmp(s, "XMSSMT-SHAKE_20/4_512")) {

  129.       *oid = 0x0b01010b;

  130.     }

  131.     else if (!strcmp(s, "XMSSMT-SHAKE_40/2_512")) {

  132.       *oid = 0x0c01010c;

  133.     }

  134.     else if (!strcmp(s, "XMSSMT-SHAKE_40/4_512")) {

  135.       *oid = 0x0d01010d;

  136.     }

  137.     else if (!strcmp(s, "XMSSMT-SHAKE_40/8_512")) {

  138.       *oid = 0x0e01010e;

  139.     }

  140.     else if (!strcmp(s, "XMSSMT-SHAKE_60/3_512")) {

  141.       *oid = 0x0f01010f;

  142.     }

  143.     else if (!strcmp(s, "XMSSMT-SHAKE_60/6_512")) {

  144.       *oid = 0x01020201;

  145.     }

  146.     else if (!strcmp(s, "XMSSMT-SHAKE_60/12_512")) {

  147.      *oid = 0x02020202;

  148.     }

  149.     else {

  150.         return -1;

  151.     }

  152.     return 0;

  153. }

  154. 

  155. int xmss_parse_oid(xmss_params *params, const uint32_t oid)

  156. {

  157.     switch (oid) {

  158.         case 0x01000001:

  159.         case 0x02000002:

  160.         case 0x03000003:

  161.         case 0x04000004:

  162.         case 0x05000005:

  163.         case 0x06000006:

  164.             params->func = XMSS_SHA2;

  165.             break;

  166. 

  167.         case 0x07000007:

  168.         case 0x08000008:

  169.         case 0x09000009:

  170.         case 0x0a00000a:

  171.         case 0x0b00000b:

  172.         case 0x0c00000c:

  173.             params->func = XMSS_SHAKE;

  174.             break;

  175. 

  176.         default:

  177.             return 1;

  178.     }

  179.     switch (oid) {

  180.         case 0x01000001:

  181.         case 0x02000002:

  182.         case 0x03000003:

  183. 

  184.         case 0x07000007:

  185.         case 0x08000008:

  186.         case 0x09000009:

  187.             params->n = 32;

  188.             break;

  189. 

  190.         case 0x04000004:

  191.         case 0x05000005:

  192.         case 0x06000006:

  193. 

  194.         case 0x0a00000a:

  195.         case 0x0b00000b:

  196.         case 0x0c00000c:

  197.             params->n = 64;

  198.             break;

  199. 

  200.         default:

  201.             return 1;

  202.     }

  203.     switch (oid) {

  204.         case 0x01000001:

  205.         case 0x04000004:

  206.         case 0x07000007:

  207.         case 0x0a00000a:

  208.             params->full_height = 10;

  209.             break;

  210. 

  211.         case 0x02000002:

  212.         case 0x05000005:

  213.         case 0x08000008:

  214.         case 0x0b00000b:

  215.             params->full_height = 16;

  216.             break;

  217. 

  218.         case 0x03000003:

  219.         case 0x06000006:

  220.         case 0x09000009:

  221.         case 0x0c00000c:

  222.             params->full_height = 20;

  223. 

  224.             break;

  225.         default:

  226.             return 1;

  227.     }

  228.     params->d = 1;

  229.     params->tree_height = params->full_height  / params->d;

  230.     params->wots_w = 16;

  231.     params->wots_log_w = 4;

  232.     params->wots_len1 = 8 * params->n / params->wots_log_w;

  233.     /* len_2 = floor(log(len_1 * (w - 1)) / log(w)) + 1 */

  234.     params->wots_len2 = 3;

  235.     params->wots_len = params->wots_len1 + params->wots_len2;

  236.     params->wots_sig_bytes = params->wots_len * params->n;

  237.     params->index_bytes = 4;

  238.     params->sig_bytes = (params->index_bytes + params->n

  239.                          + params->d * params->wots_sig_bytes

  240.                          + params->full_height * params->n);

  241.     params->pk_bytes = 2 * params->n;

  242.     params->sk_bytes = xmss_core_sk_bytes(params);

  243. 

  244.     // TODO figure out sensible and legal values for this based on the above

  245.     params->bds_k = 0;

  246.     return 0;

  247. }

  248. 

  249. int xmssmt_parse_oid(xmss_params *params, const uint32_t oid)

  250. {

  251.     switch (oid) {

  252.         case 0x01000001:

  253.         case 0x02000002:

  254.         case 0x03000003:

  255.         case 0x04000004:

  256.         case 0x05000005:

  257.         case 0x06000006:

  258.         case 0x07000007:

  259.         case 0x08000008:

  260.         case 0x09000009:

  261.         case 0x0a00000a:

  262.         case 0x0b00000b:

  263.         case 0x0c00000c:

  264.         case 0x0d00000d:

  265.         case 0x0e00000e:

  266.         case 0x0f00000f:

  267.         case 0x01010101:

  268.             params->func = XMSS_SHA2;

  269.             break;

  270. 

  271.         case 0x02010102:

  272.         case 0x03010103:

  273.         case 0x04010104:

  274.         case 0x05010105:

  275.         case 0x06010106:

  276.         case 0x07010107:

  277.         case 0x08010108:

  278.         case 0x09010109:

  279.         case 0x0a01010a:

  280.         case 0x0b01010b:

  281.         case 0x0c01010c:

  282.         case 0x0d01010d:

  283.         case 0x0e01010e:

  284.         case 0x0f01010f:

  285.         case 0x01020201:

  286.         case 0x02020202:

  287.             params->func = XMSS_SHAKE;

  288.             break;

  289. 

  290.         default:

  291.             return 1;

  292.     }

  293.     switch (oid) {

  294.         case 0x01000001:

  295.         case 0x02000002:

  296.         case 0x03000003:

  297.         case 0x04000004:

  298.         case 0x05000005:

  299.         case 0x06000006:

  300.         case 0x07000007:

  301.         case 0x08000008:

  302. 

  303.         case 0x02010102:

  304.         case 0x03010103:

  305.         case 0x04010104:

  306.         case 0x05010105:

  307.         case 0x06010106:

  308.         case 0x07010107:

  309.         case 0x08010108:

  310.         case 0x09010109:

  311.             params->n = 32;

  312.             break;

  313. 

  314.         case 0x09000009:

  315.         case 0x0a00000a:

  316.         case 0x0b00000b:

  317.         case 0x0c00000c:

  318.         case 0x0d00000d:

  319.         case 0x0e00000e:

  320.         case 0x0f00000f:

  321.         case 0x01010101:

  322. 

  323.         case 0x0a01010a:

  324.         case 0x0b01010b:

  325.         case 0x0c01010c:

  326.         case 0x0d01010d:

  327.         case 0x0e01010e:

  328.         case 0x0f01010f:

  329.         case 0x01020201:

  330.         case 0x02020202:

  331.             params->n = 64;

  332.             break;

  333. 

  334.         default:

  335.             return 1;

  336.     }

  337.     switch (oid) {

  338.         case 0x01000001:

  339.         case 0x02000002:

  340. 

  341.         case 0x09000009:

  342.         case 0x0a00000a:

  343. 

  344.         case 0x02010102:

  345.         case 0x03010103:

  346. 

  347.         case 0x0a01010a:

  348.         case 0x0b01010b:

  349.             params->full_height = 20;

  350.             break;

  351. 

  352.         case 0x03000003:

  353.         case 0x04000004:

  354.         case 0x05000005:

  355. 

  356.         case 0x0b00000b:

  357.         case 0x0c00000c:

  358.         case 0x0d00000d:

  359. 

  360.         case 0x04010104:

  361.         case 0x05010105:

  362.         case 0x06010106:

  363. 

  364.         case 0x0c01010c:

  365.         case 0x0d01010d:

  366.         case 0x0e01010e:

  367.             params->full_height = 40;

  368.             break;

  369. 

  370.         case 0x06000006:

  371.         case 0x07000007:

  372.         case 0x08000008:

  373. 

  374.         case 0x0e00000e:

  375.         case 0x0f00000f:

  376.         case 0x01010101:

  377. 

  378.         case 0x07010107:

  379.         case 0x08010108:

  380.         case 0x09010109:

  381. 

  382.         case 0x0f01010f:

  383.         case 0x01020201:

  384.         case 0x02020202:

  385.             params->full_height = 60;

  386.             break;

  387. 

  388.         default:

  389.             return 1;

  390.     }

  391.     switch (oid) {

  392.         case 0x01000001:

  393.         case 0x03000003:

  394.         case 0x09000009:

  395.         case 0x0b00000b:

  396.         case 0x02010102:

  397.         case 0x04010104:

  398.         case 0x0a01010a:

  399.         case 0x0c01010c:

  400.             params->d = 2;

  401.             break;

  402. 

  403.         case 0x02000002:

  404.         case 0x04000004:

  405.         case 0x0a00000a:

  406.         case 0x0c00000c:

  407.         case 0x03010103:

  408.         case 0x05010105:

  409.         case 0x0b01010b:

  410.         case 0x0d01010d:

  411.             params->d = 4;

  412.             break;

  413. 

  414.         case 0x05000005:

  415.         case 0x0d00000d:

  416.         case 0x06010106:

  417.         case 0x0e01010e:

  418.             params->d = 8;

  419.             break;

  420. 

  421.         case 0x06000006:

  422.         case 0x0e00000e:

  423.         case 0x07010107:

  424.         case 0x0f01010f:

  425.             params->d = 3;

  426.             break;

  427. 

  428.         case 0x07000007:

  429.         case 0x0f00000f:

  430.         case 0x08010108:

  431.         case 0x01020201:

  432.             params->d = 6;

  433.             break;

  434. 

  435.         case 0x08000008:

  436.         case 0x01010101:

  437.         case 0x09010109:

  438.         case 0x02020202:

  439.             params->d = 12;

  440.             break;

  441. 

  442.         default:

  443.             return 1;

  444.     }

  445. 

  446.     params->tree_height = params->full_height  / params->d;

  447.     params->wots_w = 16;

  448.     params->wots_log_w = 4;

  449.     params->wots_len1 = 8 * params->n / params->wots_log_w;

  450.     /* len_2 = floor(log(len_1 * (w - 1)) / log(w)) + 1 */

  451.     params->wots_len2 = 3;

  452.     params->wots_len = params->wots_len1 + params->wots_len2;

  453.     params->wots_sig_bytes = params->wots_len * params->n;

  454.     /* Round index_bytes up to nearest byte. */

  455.     params->index_bytes = (params->full_height + 7) / 8;

  456.     params->sig_bytes = (params->index_bytes + params->n

  457.                          + params->d * params->wots_sig_bytes

  458.                          + params->full_height * params->n);

  459.     params->pk_bytes = 2 * params->n;

  460.     params->sk_bytes = xmssmt_core_sk_bytes(params);

  461. 

  462.     // TODO figure out sensible and legal values for this based on the above

  463.     params->bds_k = 0;

  464.     return 0;

  465. }