static pskc_t *
get_container (const struct gengetopt_args_info *args_info)
{
const char *filename = args_info->inputs ? args_info->inputs[0] : NULL;
int strict = args_info->strict_flag;
pskc_t *container;
char *buffer;
size_t len;
int rc;
rc = pskc_init (&container);
if (rc != PSKC_OK)
error (EXIT_FAILURE, 0, "initializing PSKC structure: %s",
pskc_strerror (rc));
if (filename)
buffer = read_binary_file (filename, &len);
else
buffer = fread_file (stdin, &len);
if (buffer == NULL)
error (EXIT_FAILURE, errno, "read");
rc = pskc_parse_from_memory (container, len, buffer);
if (!strict && rc == PSKC_PARSE_ERROR)
fprintf (stderr, "warning: parse error (use -d to diagnose), output "
"may be incomplete\n");
else if (rc != PSKC_OK)
error (EXIT_FAILURE, 0, "parsing PSKC data: %s", pskc_strerror (rc));
free (buffer);
return container;
}
int
main (int argc, const char *argv[])
{
char buffer[4096];
FILE *fh = fopen (argv[1], "r");
size_t len = fread (buffer, 1, sizeof (buffer), fh);
pskc_t *container;
pskc_key_t *keypackage;
int rc;
fclose (fh);
rc = pskc_global_init ();
PSKC_CHECK_RC;
rc = pskc_init (&container);
PSKC_CHECK_RC;
rc = pskc_parse_from_memory (container, len, buffer);
PSKC_CHECK_RC;
keypackage = pskc_get_keypackage (container, 0);
if (keypackage)
printf ("SerialNo: %s\n", pskc_get_device_serialno (keypackage));
pskc_done (container);
pskc_global_done ();
}
int
main (int argc, const char *argv[])
{
char buffer[4096];
FILE *fh = fopen (argv[1], "r");
size_t len = fread (buffer, 1, sizeof (buffer), fh);
pskc_t *container;
int rc, valid_sig;
fclose (fh);
rc = pskc_global_init (); PSKC_CHECK_RC;
rc = pskc_init (&container); PSKC_CHECK_RC;
rc = pskc_parse_from_memory (container, len, buffer); PSKC_CHECK_RC;
rc = pskc_verify_x509crt (container, argv[2], &valid_sig); PSKC_CHECK_RC;
puts (valid_sig ? "OK" : "FAIL");
pskc_done (container);
pskc_global_done ();
}
int
main (void)
{
pskc_t *pskc;
pskc_key_t *keyp;
struct tm startdate = { 1, 2, 3, 4, 5, 6 };
struct tm expirydate = { 6, 5, 4, 3, 2, 1 };
char *out;
size_t len;
int rc;
rc = pskc_global_init ();
if (rc != PSKC_OK)
{
printf ("pskc_global_init: %d\n", rc);
return 1;
}
pskc_global_log (my_log);
rc = pskc_init (&pskc);
if (rc != PSKC_OK)
{
printf ("pskc_init: %d\n", rc);
return 1;
}
pskc_set_version (pskc, "42");
pskc_set_id (pskc, "MyID");
rc = pskc_add_keypackage (pskc, &keyp);
if (rc != PSKC_OK)
{
printf ("pskc_add_keypackage: %d\n", rc);
return 1;
}
rc = precheck (pskc);
if (rc != 0)
return rc;
pskc_set_device_manufacturer (keyp, "iana.foo");
pskc_set_device_serialno (keyp, "42");
pskc_set_device_model (keyp, "model");
pskc_set_device_issueno (keyp, "issueno");
pskc_set_device_devicebinding (keyp, "devbind");
pskc_set_device_startdate (keyp, &startdate);
pskc_set_device_expirydate (keyp, &expirydate);
pskc_set_device_userid (keyp, "userid");
pskc_set_cryptomodule_id (keyp, "cid");
pskc_set_key_id (keyp, "keyid");
pskc_set_key_algorithm (keyp, "keyalg");
pskc_set_key_issuer (keyp, "keyissuer");
pskc_set_key_algparm_suite (keyp, "keyalgparmsuite");
pskc_set_key_algparm_chall_encoding (keyp, PSKC_VALUEFORMAT_ALPHANUMERIC);
pskc_set_key_algparm_chall_min (keyp, 4711);
pskc_set_key_algparm_chall_max (keyp, 42);
pskc_set_key_algparm_chall_checkdigits (keyp, 1);
pskc_set_key_algparm_resp_encoding (keyp, PSKC_VALUEFORMAT_BASE64);
pskc_set_key_algparm_resp_length (keyp, 216);
pskc_set_key_algparm_resp_checkdigits (keyp, 1);
pskc_set_key_profileid (keyp, "profileid");
pskc_set_key_reference (keyp, "keyref");
pskc_set_key_friendlyname (keyp, "fname");
pskc_set_key_userid (keyp, "keyuserid");
pskc_set_key_data_counter (keyp, 4711);
pskc_set_key_data_time (keyp, 12345);
pskc_set_key_data_timeinterval (keyp, 123456);
pskc_set_key_data_timedrift (keyp, 321);
pskc_set_key_policy_startdate (keyp, &startdate);
pskc_set_key_policy_expirydate (keyp, &expirydate);
pskc_set_key_policy_pinkeyid (keyp, "pinkeyid");
pskc_set_key_policy_pinusagemode (keyp, PSKC_PINUSAGEMODE_APPEND);
pskc_set_key_policy_pinmaxfailedattempts (keyp, 123);
pskc_set_key_policy_pinminlength (keyp, 24);
pskc_set_key_policy_pinmaxlength (keyp, 42);
pskc_set_key_policy_pinencoding (keyp, PSKC_VALUEFORMAT_BASE64);
pskc_set_key_policy_keyusages (keyp, PSKC_KEYUSAGE_VERIFY);
pskc_set_key_policy_numberoftransactions (keyp, 17);
rc = pskc_set_key_data_secret (keyp, "foo", 3);
if (rc != PSKC_OK)
{
printf ("pskc_set_key_data_secret: %d\n", rc);
return 1;
}
rc = pskc_set_key_data_b64secret (keyp, "Zm9v");
if (rc != PSKC_OK)
{
printf ("pskc_set_key_data_b64secret: %d\n", rc);
return 1;
}
rc = pskc_set_key_data_b64secret (keyp, "nix");
if (rc != PSKC_BASE64_ERROR)
{
printf ("pskc_set_key_data_b64secret: %d\n", rc);
return 1;
}
rc = check (pskc);
if (rc != 0)
return rc;
rc = pskc_build_xml (pskc, &out, &len);
if (rc != PSKC_OK)
{
printf ("pskc_build_xml: %d\n", rc);
return 1;
}
pskc_done (pskc);
if (len != strlen (pskc_expect) || memcmp (pskc_expect, out, len) != 0)
{
printf ("generated data mismatch. expected:\n%s\ngot:\n%.*s\n",
pskc_expect, (int) len, out);
return 1;
}
rc = pskc_init (&pskc);
if (rc != PSKC_OK)
{
printf ("pskc_init: %d\n", rc);
return 1;
}
rc = pskc_parse_from_memory (pskc, len, out);
if (rc != PSKC_OK)
{
printf ("pskc_parse_from_memory: %d\n", rc);
return 1;
}
pskc_free (out);
rc = check (pskc);
if (rc != 0)
return rc;
pskc_done (pskc);
pskc_global_done ();
return 0;
}
int
main (int argc, const char *argv[])
{
struct stat st;
FILE *fh = NULL;
char *buffer = NULL, *out;
size_t i;
pskc_t *container = NULL;
pskc_key_t *keypackage;
int exit_code = EXIT_FAILURE, rc, isvalid;
rc = pskc_global_init ();
if (rc != PSKC_OK)
{
fprintf (stderr, "pskc_global_init: %s\n", pskc_strerror (rc));
goto done;
}
if (argc != 2)
{
fprintf (stderr, "Usage: %s PSKCFILE\n", argv[0]);
goto done;
}
/* Part 1: Read file. */
fh = fopen (argv[1], "r");
if (fh == NULL)
{
perror ("fopen");
goto done;
}
if (fstat (fileno (fh), &st) != 0)
{
perror ("fstat");
goto done;
}
buffer = malloc (st.st_size);
if (buffer == NULL)
{
perror ("malloc");
goto done;
}
i = fread (buffer, 1, st.st_size, fh);
if (i != st.st_size)
{
fprintf (stderr, "short read\n");
goto done;
}
/* Part 2: Parse PSKC data. */
rc = pskc_init (&container);
if (rc != PSKC_OK)
{
fprintf (stderr, "pskc_init: %s\n", pskc_strerror (rc));
goto done;
}
rc = pskc_parse_from_memory (container, i, buffer);
if (rc != PSKC_OK)
{
fprintf (stderr, "pskc_parse_from_memory: %s\n", pskc_strerror (rc));
goto done;
}
/* Part 3: Output human readable variant of PSKC data to stderr. */
rc = pskc_output (container, PSKC_OUTPUT_HUMAN_COMPLETE, &out, &i);
if (rc != PSKC_OK)
{
fprintf (stderr, "pskc_output: %s\n", pskc_strerror (rc));
goto done;
}
fprintf (stderr, "%.*s\n", (int) i, out);
pskc_free (out);
/* Part 4: Validate PSKC data. */
rc = pskc_validate (container, &isvalid);
if (rc != PSKC_OK)
{
fprintf (stderr, "pskc_validate: %s\n", pskc_strerror (rc));
goto done;
}
fprintf (stderr, "PSKC data is Schema valid: %s\n", isvalid ? "YES" : "NO");
/* Part 5: Iterate through keypackages and print key id, device
serial number and base64 encoded secret. */
for (i = 0; (keypackage = pskc_get_keypackage (container, i)); i++)
{
const char *key_id = pskc_get_key_id (keypackage);
const char *device_serialno = pskc_get_key_id (keypackage);
const char *b64secret = pskc_get_key_data_b64secret (keypackage);
printf ("%s,%s,%s\n", key_id ? key_id : "",
device_serialno ? device_serialno : "",
b64secret ? b64secret : "");
}
exit_code = EXIT_SUCCESS;
done:
pskc_done (container);
if (fh && fclose (fh) != 0)
perror ("fclose");
free (buffer);
pskc_global_done ();
exit (exit_code);
}
