281 lines
7.9 KiB
C
281 lines
7.9 KiB
C
/* Copyright (C) 2001, 2002 Juha Yrjölä <juha.yrjola@iki.fi>
|
|
* All rights reserved.
|
|
*
|
|
* PKCS#15 PIN code test
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
|
|
#include "libopensc/opensc.h"
|
|
#include "libopensc/pkcs15.h"
|
|
#include "sc-test.h"
|
|
|
|
void sc_test_print_card(const sc_pkcs15_card_t *mycard)
|
|
{
|
|
const char *flags[] = {
|
|
"Read-only",
|
|
"Login required",
|
|
"PRN generation",
|
|
"EID compliant"
|
|
};
|
|
int i, count = 0;
|
|
|
|
assert(mycard != NULL);
|
|
printf("PKCS#15 Card [%s]:\n", mycard->tokeninfo->label);
|
|
printf("\tVersion : %d\n", mycard->tokeninfo->version);
|
|
printf("\tSerial number : %s\n", mycard->tokeninfo->serial_number);
|
|
printf("\tManufacturer ID: %s\n", mycard->tokeninfo->manufacturer_id);
|
|
if (mycard->tokeninfo->preferred_language)
|
|
printf("\tLanguage : %s\n", mycard->tokeninfo->preferred_language);
|
|
printf("\tFlags : ");
|
|
for (i = 0; i < 4; i++) {
|
|
if ((mycard->tokeninfo->flags >> i) & 1) {
|
|
if (count)
|
|
printf(", ");
|
|
printf("%s", flags[i]);
|
|
count++;
|
|
}
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
static void print_pin(const struct sc_pkcs15_object *obj)
|
|
{
|
|
const char *pin_flags[] =
|
|
{
|
|
"case-sensitive", "local", "change-disabled",
|
|
"unblock-disabled", "initialized", "needs-padding",
|
|
"unblockingPin", "soPin", "disable_allowed",
|
|
"integrity-protected", "confidentiality-protected",
|
|
"exchangeRefData"
|
|
};
|
|
struct sc_pkcs15_auth_info *pin;
|
|
const int pf_count = sizeof(pin_flags) / sizeof(pin_flags[0]);
|
|
int i;
|
|
|
|
pin = (struct sc_pkcs15_auth_info *) obj->data;
|
|
printf("\tAuth ID : %s\n", sc_pkcs15_print_id(&pin->auth_id));
|
|
if (pin->auth_type == SC_PKCS15_PIN_AUTH_TYPE_PIN) {
|
|
printf("\tFlags : [0x%02X]", pin->attrs.pin.flags);
|
|
for (i = 0; i < pf_count; i++)
|
|
if (pin->attrs.pin.flags & (1 << i)) {
|
|
printf(", %s", pin_flags[i]);
|
|
}
|
|
printf("\n");
|
|
printf("\tLength : min_len:%lu, max_len:%lu, stored_len:%lu\n",
|
|
(unsigned long) pin->attrs.pin.min_length,
|
|
(unsigned long) pin->attrs.pin.max_length,
|
|
(unsigned long) pin->attrs.pin.stored_length);
|
|
printf("\tPad char : 0x%02X\n", pin->attrs.pin.pad_char);
|
|
printf("\tReference : %d\n", pin->attrs.pin.reference);
|
|
printf("\tEncoding : ");
|
|
switch (pin->attrs.pin.type) {
|
|
case SC_PKCS15_PIN_TYPE_BCD:
|
|
printf("BCD\n"); break;
|
|
case SC_PKCS15_PIN_TYPE_ASCII_NUMERIC:
|
|
printf("ASCII-numeric\n"); break;
|
|
case SC_PKCS15_PIN_TYPE_UTF8:
|
|
printf("UTF8\n"); break;
|
|
case SC_PKCS15_PIN_TYPE_HALFNIBBLE_BCD:
|
|
printf("half-nibble BCD\n"); break;
|
|
case SC_PKCS15_PIN_TYPE_ISO9564_1:
|
|
printf("ISO 9564-1\n"); break;
|
|
default:
|
|
printf("[encoding %d]\n", pin->attrs.pin.type);
|
|
}
|
|
}
|
|
if (pin->path.len)
|
|
printf("\tPath : %s\n", sc_print_path(&pin->path));
|
|
if (pin->tries_left >= 0)
|
|
printf("\tTries left : %d\n", pin->tries_left);
|
|
}
|
|
|
|
static void print_prkey(const struct sc_pkcs15_object *obj)
|
|
{
|
|
int i;
|
|
size_t j;
|
|
const char *usages[] =
|
|
{
|
|
"encrypt", "decrypt", "sign", "signRecover",
|
|
"wrap", "unwrap", "verify", "verifyRecover",
|
|
"derive", "nonRepudiation"
|
|
};
|
|
const int usage_count = sizeof(usages) / sizeof(usages[0]);
|
|
const char *access_flags[] =
|
|
{
|
|
"sensitive", "extract", "alwaysSensitive",
|
|
"neverExtract", "local"
|
|
};
|
|
const int af_count = sizeof(access_flags) / sizeof(access_flags[0]);
|
|
struct sc_pkcs15_prkey_info *prkey;
|
|
|
|
prkey = (struct sc_pkcs15_prkey_info *) obj->data;
|
|
|
|
printf("\tUsage : [0x%X]", prkey->usage);
|
|
for (i = 0; i < usage_count; i++)
|
|
if (prkey->usage & (1 << i)) {
|
|
printf(", %s", usages[i]);
|
|
}
|
|
printf("\n");
|
|
printf("\tAccess Flags: [0x%X]", prkey->access_flags);
|
|
for (i = 0; i < af_count; i++)
|
|
if (prkey->access_flags & (1 << i)) {
|
|
printf(", %s", access_flags[i]);
|
|
}
|
|
printf("\n");
|
|
if (obj->type == SC_PKCS15_TYPE_PRKEY_RSA)
|
|
printf("\tModLength : %lu\n",
|
|
(unsigned long) prkey->modulus_length);
|
|
printf("\tKey ref : %d\n", prkey->key_reference);
|
|
printf("\tNative : %s\n", prkey->native ? "yes" : "no");
|
|
if (prkey->path.len) {
|
|
printf("\tPath : ");
|
|
for (j = 0; j < prkey->path.len; j++)
|
|
printf("%02X", prkey->path.value[j]);
|
|
if (prkey->path.type == SC_PATH_TYPE_PATH_PROT)
|
|
printf(" (protected)");
|
|
printf("\n");
|
|
}
|
|
printf("\tID : %s\n", sc_pkcs15_print_id(&prkey->id));
|
|
}
|
|
|
|
static void print_pubkey(const struct sc_pkcs15_object *obj)
|
|
{
|
|
int i;
|
|
size_t j;
|
|
const char *usages[] =
|
|
{
|
|
"encrypt", "decrypt", "sign", "signRecover",
|
|
"wrap", "unwrap", "verify", "verifyRecover",
|
|
"derive", "nonRepudiation"
|
|
};
|
|
const int usage_count = sizeof(usages) / sizeof(usages[0]);
|
|
const char *access_flags[] =
|
|
{
|
|
"sensitive", "extract", "alwaysSensitive",
|
|
"neverExtract", "local"
|
|
};
|
|
const int af_count = sizeof(access_flags) / sizeof(access_flags[0]);
|
|
struct sc_pkcs15_pubkey_info *pubkey;
|
|
|
|
pubkey = (struct sc_pkcs15_pubkey_info *) obj->data;
|
|
|
|
printf("\tUsage : [0x%X]", pubkey->usage);
|
|
for (i = 0; i < usage_count; i++)
|
|
if (pubkey->usage & (1 << i)) {
|
|
printf(", %s", usages[i]);
|
|
}
|
|
printf("\n");
|
|
printf("\tAccess Flags: [0x%X]", pubkey->access_flags);
|
|
for (i = 0; i < af_count; i++)
|
|
if (pubkey->access_flags & (1 << i)) {
|
|
printf(", %s", access_flags[i]);
|
|
}
|
|
printf("\n");
|
|
if (obj->type == SC_PKCS15_TYPE_PUBKEY_RSA)
|
|
printf("\tModLength : %lu\n",
|
|
(unsigned long) pubkey->modulus_length);
|
|
printf("\tKey ref : %d\n", pubkey->key_reference);
|
|
printf("\tNative : %s\n", pubkey->native ? "yes" : "no");
|
|
printf("\tPath : ");
|
|
for (j = 0; j < pubkey->path.len; j++)
|
|
printf("%02X", pubkey->path.value[j]);
|
|
printf("\n");
|
|
printf("\tID : %s\n", sc_pkcs15_print_id(&pubkey->id));
|
|
}
|
|
|
|
static void print_cert_x509(const struct sc_pkcs15_object *obj)
|
|
{
|
|
struct sc_pkcs15_cert_info *cert;
|
|
|
|
cert = (struct sc_pkcs15_cert_info *) obj->data;
|
|
printf("\tAuthority : %s\n", cert->authority ? "yes" : "no");
|
|
printf("\tPath : %s\n",
|
|
cert->path.len? sc_print_path(&cert->path) : "<direct encoding>");
|
|
printf("\tID : %s\n", sc_pkcs15_print_id(&cert->id));
|
|
|
|
/* XXX original p15dump code would read the certificate
|
|
* and dump the label */
|
|
}
|
|
|
|
static void print_data_object_summary(const struct sc_pkcs15_object *obj)
|
|
{
|
|
struct sc_pkcs15_data_info *data_object;
|
|
unsigned i;
|
|
|
|
data_object = (struct sc_pkcs15_data_info *) obj->data;
|
|
printf("\tPath : ");
|
|
for (i = 0; i < data_object->path.len; i++)
|
|
printf("%02X", data_object->path.value[i]);
|
|
printf("\n");
|
|
printf("\tID : %s\n", sc_pkcs15_print_id(&data_object->id));
|
|
|
|
/* XXX original p15dump code would read the data object
|
|
* and dump the label */
|
|
}
|
|
|
|
void sc_test_print_object(const struct sc_pkcs15_object *obj)
|
|
{
|
|
const char *kind;
|
|
void (*printer) (const struct sc_pkcs15_object *);
|
|
|
|
switch (obj->type) {
|
|
case SC_PKCS15_TYPE_AUTH_PIN:
|
|
printer = print_pin;
|
|
kind = "PIN";
|
|
break;
|
|
case SC_PKCS15_TYPE_PRKEY_RSA:
|
|
printer = print_prkey;
|
|
kind = "Private RSA key";
|
|
break;
|
|
case SC_PKCS15_TYPE_PUBKEY_RSA:
|
|
printer = print_pubkey;
|
|
kind = "Public RSA key";
|
|
break;
|
|
case SC_PKCS15_TYPE_PRKEY_DSA:
|
|
printer = print_prkey;
|
|
kind = "Private DSA key";
|
|
break;
|
|
case SC_PKCS15_TYPE_PUBKEY_DSA:
|
|
printer = print_pubkey;
|
|
kind = "Public DSA key";
|
|
break;
|
|
case SC_PKCS15_TYPE_CERT_X509:
|
|
printer = print_cert_x509;
|
|
kind = "X.509 Certificate";
|
|
break;
|
|
case SC_PKCS15_TYPE_DATA_OBJECT:
|
|
printer = print_data_object_summary;
|
|
kind = "Data Object";
|
|
break;
|
|
default:
|
|
printer = NULL;
|
|
kind = "Something";
|
|
break;
|
|
}
|
|
|
|
printf("%s", kind);
|
|
if (obj->label[0])
|
|
printf(" [%.*s]\n", (int) sizeof obj->label, obj->label);
|
|
else
|
|
printf(" (no label)\n");
|
|
printf("\tCom. Flags : ");
|
|
switch (obj->flags) {
|
|
case 0x01: printf("private\n"); break;
|
|
case 0x02: printf("modifiable\n"); break;
|
|
case 0x03: printf("private, modifiable\n"); break;
|
|
default: printf("0x%X\n", obj->flags);
|
|
}
|
|
if (obj->auth_id.len)
|
|
printf("\tCom. Auth ID: %s\n", sc_pkcs15_print_id(&obj->auth_id));
|
|
if (obj->user_consent)
|
|
printf("\tUser consent: %u\n", obj->user_consent);
|
|
|
|
if (printer)
|
|
printer(obj);
|
|
}
|