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.
139 Commits
1 Branch
488 KiB
 
 
Tree: c5e4f43d04
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c5e4f43d04'
${ noResults }
xmss-KAT-generator/test/acvpkat.c

290 lines
10 KiB
Raw Blame History 

  1. /* 

  2.  * Generate intermediate test vectors useful to test implementations.

  3.  */

  4. 

  5. // Number of sample vectors to be generated

  6. #include <stdint.h>

  7. #include <stdio.h>

  8. #include <string.h>

  9. 

  10. #include "../fips202.h"

  11. #include "../params.h"

  12. #include "../randombytes.h"

  13. #include "../utils.h"

  14. #include "../wots.h"

  15. #include "../xmss_commons.h"

  16. #include "../xmss_core.h"

  17. 

  18. #include <sys/random.h>

  19. #include <sys/stat.h>

  20. 

  21. #include <json.h>

  22. 

  23. struct param_t {

  24.     uint8_t oid;

  25.     const char *hash;

  26.     unsigned height;

  27.     unsigned n_samples;

  28. };

  29. 

  30. void sprint_hex(char *sbuf, unsigned char *buf, int len) {

  31.     for (int i = 0; i < len; i++) { 

  32.         sprintf(&sbuf[2*i], "%02X", buf[i]); 

  33.     }

  34.     sbuf[2*len] = '\0';

  35. }

  36. 

  37. void vectors_keygen(uint32_t oid, json_object *jreq, json_object *jres, uint32_t n_samples) {

  38.     xmss_params params;

  39.     struct json_object *tc_req, *tcs_req, *tc_res, *tcs_res;

  40.     

  41.     xmss_parse_oid(&params, oid);

  42. 

  43.     unsigned char seed[params.n * 3];

  44.     unsigned char pk[params.pk_bytes + XMSS_OID_LEN];

  45.     unsigned char sk[params.sk_bytes + XMSS_OID_LEN];

  46.     char *sbuf;

  47.     unsigned i;

  48. 

  49.     tcs_req = json_object_new_array();

  50.     tcs_res = json_object_new_array();

  51. 

  52.     for (i = 0; i < XMSS_OID_LEN; i++) {

  53.         pk[XMSS_OID_LEN - i - 1] = (oid >> (8 * i)) & 0xFF;

  54.         sk[XMSS_OID_LEN - i - 1] = (oid >> (8 * i)) & 0xFF;

  55.     }

  56. 

  57.     for (size_t i=0; i<n_samples; i++) {

  58.         tc_req = json_object_new_object();

  59.         tc_res = json_object_new_object();

  60. 

  61.         getentropy(seed, 3*params.n);

  62.         xmssmt_core_seed_keypair(&params, &pk[XMSS_OID_LEN], &sk[XMSS_OID_LEN], seed);

  63. 

  64.         json_object_object_add(tc_req, "tcId", json_object_new_int(i+1));

  65.         sbuf = malloc(2*params.n + 1);

  66.         sprint_hex(sbuf, seed, params.n);

  67.         json_object_object_add(tc_req, "S_XMSS", json_object_new_string(sbuf));

  68.         sprint_hex(sbuf, &seed[params.n], params.n);

  69.         json_object_object_add(tc_req, "SK_PRF", json_object_new_string(sbuf));

  70.         sprint_hex(sbuf, &seed[2*params.n], params.n);

  71.         json_object_object_add(tc_req, "I", json_object_new_string(sbuf));

  72.         free(sbuf);

  73. 

  74.         json_object_object_add(tc_res, "tcId", json_object_new_int(i+1));

  75.         sbuf = malloc(2*params.pk_bytes + 1);

  76.         sprint_hex(sbuf, pk, params.pk_bytes + XMSS_OID_LEN);

  77.         json_object_object_add(tc_res, "publicKey", json_object_new_string(sbuf));

  78.         free(sbuf);

  79. 

  80.         sbuf = malloc(2*params.sk_bytes + 1);

  81.         sprint_hex(sbuf, sk, params.sk_bytes + XMSS_OID_LEN);

  82.         json_object_object_add(tc_res, "secretKey", json_object_new_string(sbuf));

  83.         free(sbuf);

  84. 

  85.         json_object_array_add(tcs_req,tc_req);

  86.         json_object_array_add(tcs_res,tc_res);

  87.     }

  88.     json_object_object_add(jreq, "tests", tcs_req);

  89.     json_object_object_add(jres, "tests", tcs_res);

  90. }

  91. 

  92. void json_header_keygen(json_object *jobj) {

  93.     json_object_object_add(jobj, "vsId", json_object_new_int(0));

  94.     json_object_object_add(jobj, "algorithm", json_object_new_string("XMSS"));

  95.     json_object_object_add(jobj, "mode", json_object_new_string("keyGen"));

  96.     json_object_object_add(jobj, "revision", json_object_new_string("1.0"));

  97.     json_object_object_add(jobj, "isSample", json_object_new_boolean(1));

  98. }

  99. 

  100. void keygen_KAT(const struct param_t *h) {

  101.     struct json_object *jres, *jreq, *tgs_req, *tgs_res, *tg_req, *tg_res;

  102.     char buf[256];

  103. 

  104.     jreq = json_object_new_object();

  105.     jres = json_object_new_object();

  106. 

  107.     json_header_keygen(jreq);

  108.     json_header_keygen(jres);

  109. 

  110.     tgs_req = json_object_new_array();

  111.     tgs_res = json_object_new_array();

  112. 

  113.     tg_req = json_object_new_object();

  114.     tg_res = json_object_new_object();

  115. 

  116.     // Request file

  117.     json_object_object_add(tg_req, "tgId", json_object_new_int(1));

  118.     json_object_object_add(tg_req, "testType", json_object_new_string("AFT"));

  119.     json_object_object_add(tg_req, "OID", json_object_new_int(h->oid));

  120. 

  121.     // Response file

  122.     json_object_object_add(tg_res, "tgId", json_object_new_int(1));

  123.     json_object_object_add(tg_req, "OID", json_object_new_int(h->oid));

  124. 

  125.     vectors_keygen(h->oid, tg_req, tg_res, h->n_samples); 

  126. 

  127.     json_object_array_add(tgs_req, tg_req);

  128.     json_object_array_add(tgs_res, tg_res);

  129. 

  130.     json_object_object_add(jreq, "testGroups", tgs_req);

  131.     json_object_object_add(jres, "testGroups", tgs_res);

  132.     

  133.     sprintf(buf, "XMSS-%s-%s-H%u", "keyGen", h->hash, h->height);

  134.     mkdir(buf, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);

  135.     sprintf(buf, "XMSS-%s-%s-H%u/%s", "keyGen", h->hash, h->height, "prompt.json");

  136.     json_object_to_file_ext(buf, jreq, JSON_C_TO_STRING_SPACED | JSON_C_TO_STRING_PRETTY);

  137.     sprintf(buf, "XMSS-%s-%s-H%u/%s", "keyGen", h->hash, h->height, "expectedResults.json");

  138.     json_object_to_file_ext(buf, jres, JSON_C_TO_STRING_SPACED | JSON_C_TO_STRING_PRETTY);

  139. 

  140.     json_object_put(jres);

  141.     json_object_put(jreq);

  142. }

  143. 

  144. void json_header_siggen(json_object *jobj) {

  145.     json_object_object_add(jobj, "vsId", json_object_new_int(0));

  146.     json_object_object_add(jobj, "algorithm", json_object_new_string("XMSS"));

  147.     json_object_object_add(jobj, "mode", json_object_new_string("sigGen"));

  148.     json_object_object_add(jobj, "revision", json_object_new_string("1.0"));

  149.     json_object_object_add(jobj, "isSample", json_object_new_boolean(1));

  150. }

  151. 

  152. void vectors_siggen(uint32_t oid, unsigned char *sk, json_object *jreq, json_object *jres, uint32_t n_samples) {

  153.     xmss_params params;

  154.     struct json_object *tc_req, *tcs_req, *tc_res, *tcs_res;

  155.     

  156.     xmss_parse_oid(&params, oid);

  157.     unsigned char sm[params.sig_bytes + 128];

  158.     unsigned long long smlen = 0;

  159.     unsigned char msg[128];

  160.     unsigned q;

  161.     unsigned height = 1u << (params.full_height);

  162.     char *sbuf;

  163. 

  164.     tcs_req = json_object_new_array();

  165.     tcs_res = json_object_new_array();

  166. 

  167.     for (size_t i=0; i<n_samples; i++) {

  168.         tc_req = json_object_new_object();

  169.         tc_res = json_object_new_object();

  170. 

  171.         getentropy(msg, 128);

  172.         getentropy(&q, sizeof(q));

  173.         q = q % height;

  174.         smlen = 0;

  175. 

  176.         ull_to_bytes(sk, params.index_bytes, q);

  177.         xmss_core_sign(&params, sk, sm, &smlen, msg, 128);

  178. 

  179.         json_object_object_add(tc_res, "tcId", json_object_new_int(i+1));

  180.         json_object_object_add(tc_req, "tcId", json_object_new_int(i+1));

  181. 

  182.         sbuf = malloc(2*128 + 1);

  183.         sprint_hex(sbuf, msg, 128);

  184.         json_object_object_add(tc_req, "message", json_object_new_string(sbuf));

  185.         free(sbuf);

  186. 

  187.         sbuf = malloc(2*smlen + 1);

  188.         sprint_hex(sbuf, sm, smlen);

  189.         json_object_object_add(tc_res, "signature", json_object_new_string(sbuf));

  190.         free(sbuf);

  191. 

  192.         json_object_object_add(tc_req, "q", json_object_new_int(q));

  193.         json_object_array_add(tcs_req, tc_req);

  194.         json_object_array_add(tcs_res, tc_res);

  195.     }

  196.     json_object_object_add(jreq, "tests", tcs_req);

  197.     json_object_object_add(jres, "tests", tcs_res);

  198. }

  199. 

  200. void siggen_KAT(const struct param_t *h) {

  201.     xmss_params params;

  202.     struct json_object *jres, *jreq, *tgs_req, *tgs_res, *tg_req, *tg_res;

  203.     xmss_parse_oid(&params, h->oid);

  204. 

  205.     char buf[256], *sbuf;

  206.     unsigned char seed[params.n * 3];

  207.     unsigned char pk[params.pk_bytes + XMSS_OID_LEN];

  208.     unsigned char sk[params.sk_bytes + XMSS_OID_LEN];

  209. 

  210.     jreq = json_object_new_object();

  211.     jres = json_object_new_object();

  212. 

  213.     json_header_siggen(jreq);

  214.     json_header_siggen(jres);

  215. 

  216.     tgs_req = json_object_new_array();

  217.     tgs_res = json_object_new_array();

  218. 

  219.     tg_req = json_object_new_object();

  220.     tg_res = json_object_new_object();

  221. 

  222.     // Request file

  223.     json_object_object_add(tg_req, "tgId", json_object_new_int(1));

  224.     json_object_object_add(tg_req, "testType", json_object_new_string("AFT"));

  225.     json_object_object_add(tg_req, "OID", json_object_new_int(h->oid));

  226. 

  227.     // Response file

  228.     json_object_object_add(tg_res, "tgId", json_object_new_int(1));

  229.     json_object_object_add(tg_req, "OID", json_object_new_int(h->oid));

  230.     

  231.     getentropy(seed, 3*params.n);

  232.     xmssmt_core_seed_keypair(&params, pk + XMSS_OID_LEN, sk + XMSS_OID_LEN, seed);

  233. 

  234.     sbuf = malloc(2*params.n + 1);

  235.     sprint_hex(sbuf, seed, params.n);

  236.     json_object_object_add(tg_req, "S_XMSS", json_object_new_string(sbuf));

  237.     sprint_hex(sbuf, &seed[params.n], params.n);

  238.     json_object_object_add(tg_req, "SK_PRF", json_object_new_string(sbuf));

  239.     sprint_hex(sbuf, &seed[2*params.n], params.n);

  240.     json_object_object_add(tg_req, "I", json_object_new_string(sbuf));

  241.     free(sbuf);

  242. 

  243.     sbuf = malloc(2*params.pk_bytes + 1);

  244.     sprint_hex(sbuf, pk, params.pk_bytes  + XMSS_OID_LEN);

  245.     json_object_object_add(tg_res, "publicKey", json_object_new_string(sbuf));

  246.     free(sbuf);

  247. 

  248.     vectors_siggen(h->oid, sk + XMSS_OID_LEN, tg_req, tg_res, h->n_samples); 

  249. 

  250.     json_object_array_add(tgs_req, tg_req);

  251.     json_object_array_add(tgs_res, tg_res);

  252. 

  253.     json_object_object_add(jreq, "testGroups", tgs_req);

  254.     json_object_object_add(jres, "testGroups", tgs_res);

  255.     

  256.     sprintf(buf, "XMSS-%s-%s-H%u", "sigGen", h->hash, h->height);

  257.     mkdir(buf, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);

  258.     sprintf(buf, "XMSS-%s-%s-H%u/%s", "sigGen", h->hash, h->height, "prompt.json");

  259.     json_object_to_file_ext(buf, jreq, JSON_C_TO_STRING_SPACED | JSON_C_TO_STRING_PRETTY);

  260.     sprintf(buf, "XMSS-%s-%s-H%u/%s", "sigGen", h->hash, h->height, "expectedResults.json");

  261.     json_object_to_file_ext(buf, jres, JSON_C_TO_STRING_SPACED | JSON_C_TO_STRING_PRETTY);

  262. 

  263.     json_object_put(jres);

  264.     json_object_put(jreq);

  265. }

  266. 

  267. int main() {

  268.     const struct param_t OIDs[] = {

  269.         {0x01, "SHA256-N32", 10, 10},   // H10

  270.         {0x0D, "SHA256-N24", 10, 10},   // H10

  271.         {0x10, "SHAKE256-N32", 10, 10}, // H10

  272.         {0x13, "SHAKE256-N24", 10, 10}, // H10

  273. 

  274.         {0x02, "SHA256-N32", 16, 5},    // H16

  275.         {0x0E, "SHA256-N24", 16, 5},    // H16

  276.         {0x11, "SHAKE256-N32", 16, 5},  // H16

  277.         {0x14, "SHAKE256-N24", 16, 5},  // H16

  278. 

  279.         {0x03, "SHA256-N32", 20, 3},    // H20

  280.         {0x0F, "SHA256-N24", 20, 3},    // H20

  281.         {0x12, "SHAKE256-N32", 20, 3},  // H20

  282.         {0x15, "SHAKE256-N24", 20, 3}   // H20

  283.     };

  284.     

  285.     for (size_t i=0; i<12; i++) {

  286.         keygen_KAT(&OIDs[i]);

  287.         siggen_KAT(&OIDs[i]);

  288.     }

  289. }