kris
/
xmss-KAT-generator
1
0
Forka 0
Codice Problemi 0 Pull Requests 0 Rilasci 0 Wiki Attività
Non puoi selezionare più di 25 argomenti Gli argomenti devono iniziare con una lettera o un numero, possono includere trattini ('-') e possono essere lunghi fino a 35 caratteri.
89 Commit
1 Ramo (Branch)
488 KiB
 
 
Albero (Tree): 5ce8fc402b
Rami (Branch) Tag
${ item.name }
Crea branch ${ searchTerm }
da '5ce8fc402b'
${ noResults }
xmss-KAT-generator/params.c

464 righe
11 KiB
Originale Blame Cronologia 

  1. #include <stdint.h>

  2. #include <string.h>

  3. #include "params.h"

  4. 

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

  6. {

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

  8.         *oid = 0x01000001;

  9.     }

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

  11.         *oid = 0x02000002;

  12.     }

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

  14.         *oid = 0x03000003;

  15.     }

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

  17.         *oid = 0x04000004;

  18.     }

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

  20.         *oid = 0x05000005;

  21.     }

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

  23.         *oid = 0x06000006;

  24.     }

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

  26.         *oid = 0x07000007;

  27.     }

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

  29.         *oid = 0x08000008;

  30.     }

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

  32.         *oid = 0x09000009;

  33.     }

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

  35.         *oid = 0x0a00000a;

  36.     }

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

  38.         *oid = 0x0b00000b;

  39.     }

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

  41.         *oid = 0x0c00000c;

  42.     }

  43.     else {

  44.         return -1;

  45.     }

  46.     return 0;

  47. }

  48. 

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

  50. {

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

  52.        *oid = 0x01000001;

  53.     }

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

  55.        *oid = 0x02000002;

  56.     }

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

  58.        *oid = 0x03000003;

  59.     }

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

  61.        *oid = 0x04000004;

  62.     }

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

  64.        *oid = 0x05000005;

  65.     }

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

  67.        *oid = 0x06000006;

  68.     }

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

  70.        *oid = 0x07000007;

  71.     }

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

  73.       *oid = 0x08000008;

  74.     }

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

  76.        *oid = 0x09000009;

  77.     }

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

  79.        *oid = 0x0a00000a;

  80.     }

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

  82.        *oid = 0x0b00000b;

  83.     }

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

  85.        *oid = 0x0c00000c;

  86.     }

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

  88.        *oid = 0x0d00000d;

  89.     }

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

  91.        *oid = 0x0e00000e;

  92.     }

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

  94.        *oid = 0x0f00000f;

  95.     }

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

  97.       *oid = 0x01010101;

  98.     }

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

  100.       *oid = 0x02010102;

  101.     }

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

  103.       *oid = 0x03010103;

  104.     }

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

  106.       *oid = 0x04010104;

  107.     }

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

  109.       *oid = 0x05010105;

  110.     }

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

  112.       *oid = 0x06010106;

  113.     }

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

  115.       *oid = 0x07010107;

  116.     }

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

  118.       *oid = 0x08010108;

  119.     }

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

  121.      *oid = 0x09010109;

  122.     }

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

  124.       *oid = 0x0a01010a;

  125.     }

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

  127.       *oid = 0x0b01010b;

  128.     }

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

  130.       *oid = 0x0c01010c;

  131.     }

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

  133.       *oid = 0x0d01010d;

  134.     }

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

  136.       *oid = 0x0e01010e;

  137.     }

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

  139.       *oid = 0x0f01010f;

  140.     }

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

  142.       *oid = 0x01020201;

  143.     }

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

  145.      *oid = 0x02020202;

  146.     }

  147.     else {

  148.         return -1;

  149.     }

  150.     return 0;

  151. }

  152. 

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

  154. {

  155.     switch (oid) {

  156.         case 0x01000001:

  157.         case 0x02000002:

  158.         case 0x03000003:

  159.         case 0x04000004:

  160.         case 0x05000005:

  161.         case 0x06000006:

  162.             params->func = XMSS_SHA2;

  163.             break;

  164. 

  165.         case 0x07000007:

  166.         case 0x08000008:

  167.         case 0x09000009:

  168.         case 0x0a00000a:

  169.         case 0x0b00000b:

  170.         case 0x0c00000c:

  171.             params->func = XMSS_SHAKE;

  172.             break;

  173. 

  174.         default:

  175.             return 1;

  176.     }

  177.     switch (oid) {

  178.         case 0x01000001:

  179.         case 0x02000002:

  180.         case 0x03000003:

  181. 

  182.         case 0x07000007:

  183.         case 0x08000008:

  184.         case 0x09000009:

  185.             params->n = 32;

  186.             break;

  187. 

  188.         case 0x04000004:

  189.         case 0x05000005:

  190.         case 0x06000006:

  191. 

  192.         case 0x0a00000a:

  193.         case 0x0b00000b:

  194.         case 0x0c00000c:

  195.             params->n = 64;

  196.             break;

  197. 

  198.         default:

  199.             return 1;

  200.     }

  201.     switch (oid) {

  202.         case 0x01000001:

  203.         case 0x04000004:

  204.         case 0x07000007:

  205.         case 0x0a00000a:

  206.             params->full_height = 10;

  207.             break;

  208. 

  209.         case 0x02000002:

  210.         case 0x05000005:

  211.         case 0x08000008:

  212.         case 0x0b00000b:

  213.             params->full_height = 16;

  214.             break;

  215. 

  216.         case 0x03000003:

  217.         case 0x06000006:

  218.         case 0x09000009:

  219.         case 0x0c00000c:

  220.             params->full_height = 20;

  221. 

  222.             break;

  223.         default:

  224.             return 1;

  225.     }

  226.     params->d = 1;

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

  228.     params->wots_w = 16;

  229.     params->wots_log_w = 4;

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

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

  232.     params->wots_len2 = 3;

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

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

  235.     params->index_bytes = 4;

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

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

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

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

  240.     params->sk_bytes = 4 * params->n + params->index_bytes;

  241. 

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

  243.     params->bds_k = 0;

  244.     return 0;

  245. }

  246. 

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

  248. {

  249.     switch (oid) {

  250.         case 0x01000001:

  251.         case 0x02000002:

  252.         case 0x03000003:

  253.         case 0x04000004:

  254.         case 0x05000005:

  255.         case 0x06000006:

  256.         case 0x07000007:

  257.         case 0x08000008:

  258.         case 0x09000009:

  259.         case 0x0a00000a:

  260.         case 0x0b00000b:

  261.         case 0x0c00000c:

  262.         case 0x0d00000d:

  263.         case 0x0e00000e:

  264.         case 0x0f00000f:

  265.         case 0x01010101:

  266.             params->func = XMSS_SHA2;

  267.             break;

  268. 

  269.         case 0x02010102:

  270.         case 0x03010103:

  271.         case 0x04010104:

  272.         case 0x05010105:

  273.         case 0x06010106:

  274.         case 0x07010107:

  275.         case 0x08010108:

  276.         case 0x09010109:

  277.         case 0x0a01010a:

  278.         case 0x0b01010b:

  279.         case 0x0c01010c:

  280.         case 0x0d01010d:

  281.         case 0x0e01010e:

  282.         case 0x0f01010f:

  283.         case 0x01020201:

  284.         case 0x02020202:

  285.             params->func = XMSS_SHAKE;

  286.             break;

  287. 

  288.         default:

  289.             return 1;

  290.     }

  291.     switch (oid) {

  292.         case 0x01000001:

  293.         case 0x02000002:

  294.         case 0x03000003:

  295.         case 0x04000004:

  296.         case 0x05000005:

  297.         case 0x06000006:

  298.         case 0x07000007:

  299.         case 0x08000008:

  300. 

  301.         case 0x02010102:

  302.         case 0x03010103:

  303.         case 0x04010104:

  304.         case 0x05010105:

  305.         case 0x06010106:

  306.         case 0x07010107:

  307.         case 0x08010108:

  308.         case 0x09010109:

  309.             params->n = 32;

  310.             break;

  311. 

  312.         case 0x09000009:

  313.         case 0x0a00000a:

  314.         case 0x0b00000b:

  315.         case 0x0c00000c:

  316.         case 0x0d00000d:

  317.         case 0x0e00000e:

  318.         case 0x0f00000f:

  319.         case 0x01010101:

  320. 

  321.         case 0x0a01010a:

  322.         case 0x0b01010b:

  323.         case 0x0c01010c:

  324.         case 0x0d01010d:

  325.         case 0x0e01010e:

  326.         case 0x0f01010f:

  327.         case 0x01020201:

  328.         case 0x02020202:

  329.             params->n = 64;

  330.             break;

  331. 

  332.         default:

  333.             return 1;

  334.     }

  335.     switch (oid) {

  336.         case 0x01000001:

  337.         case 0x02000002:

  338. 

  339.         case 0x09000009:

  340.         case 0x0a00000a:

  341. 

  342.         case 0x02010102:

  343.         case 0x03010103:

  344. 

  345.         case 0x0a01010a:

  346.         case 0x0b01010b:

  347.             params->full_height = 20;

  348.             break;

  349. 

  350.         case 0x03000003:

  351.         case 0x04000004:

  352.         case 0x05000005:

  353. 

  354.         case 0x0b00000b:

  355.         case 0x0c00000c:

  356.         case 0x0d00000d:

  357. 

  358.         case 0x04010104:

  359.         case 0x05010105:

  360.         case 0x06010106:

  361. 

  362.         case 0x0c01010c:

  363.         case 0x0d01010d:

  364.         case 0x0e01010e:

  365.             params->full_height = 40;

  366.             break;

  367. 

  368.         case 0x06000006:

  369.         case 0x07000007:

  370.         case 0x08000008:

  371. 

  372.         case 0x0e00000e:

  373.         case 0x0f00000f:

  374.         case 0x01010101:

  375. 

  376.         case 0x07010107:

  377.         case 0x08010108:

  378.         case 0x09010109:

  379. 

  380.         case 0x0f01010f:

  381.         case 0x01020201:

  382.         case 0x02020202:

  383.             params->full_height = 60;

  384.             break;

  385. 

  386.         default:

  387.             return 1;

  388.     }

  389.     switch (oid) {

  390.         case 0x01000001:

  391.         case 0x03000003:

  392.         case 0x09000009:

  393.         case 0x0b00000b:

  394.         case 0x02010102:

  395.         case 0x04010104:

  396.         case 0x0a01010a:

  397.         case 0x0c01010c:

  398.             params->d = 2;

  399.             break;

  400. 

  401.         case 0x02000002:

  402.         case 0x04000004:

  403.         case 0x0a00000a:

  404.         case 0x0c00000c:

  405.         case 0x03010103:

  406.         case 0x05010105:

  407.         case 0x0b01010b:

  408.         case 0x0d01010d:

  409.             params->d = 4;

  410.             break;

  411. 

  412.         case 0x05000005:

  413.         case 0x0d00000d:

  414.         case 0x06010106:

  415.         case 0x0e01010e:

  416.             params->d = 8;

  417.             break;

  418. 

  419.         case 0x06000006:

  420.         case 0x0e00000e:

  421.         case 0x07010107:

  422.         case 0x0f01010f:

  423.             params->d = 3;

  424.             break;

  425. 

  426.         case 0x07000007:

  427.         case 0x0f00000f:

  428.         case 0x08010108:

  429.         case 0x01020201:

  430.             params->d = 6;

  431.             break;

  432. 

  433.         case 0x08000008:

  434.         case 0x01010101:

  435.         case 0x09010109:

  436.         case 0x02020202:

  437.             params->d = 12;

  438.             break;

  439. 

  440.         default:

  441.             return 1;

  442.     }

  443. 

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

  445.     params->wots_w = 16;

  446.     params->wots_log_w = 4;

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

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

  449.     params->wots_len2 = 3;

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

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

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

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

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

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

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

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

  458.     params->sk_bytes = 4 * params->n + params->index_bytes;

  459. 

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

  461.     params->bds_k = 0;

  462.     return 0;

  463. }