giomba
/
opensc
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

- Whitespace cleanup from me and Martin Paljak 

git-svn-id: https://www.opensc-project.org/svnp/opensc/trunk@2181 c6295689-39f2-0310-b995-f0e70906c6a9
This commit is contained in:
aet 2005-02-11 20:09:34 +00:00
parent df12bfb5b1
commit df5e357694
17 changed files with 286 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
src/libopensc/card-mcrd.c
View File

@ -57,7 +57,7 @@ enum {
#define EF_KeyD 0x0013 /* File with extra key information. */ #define EF_KeyD 0x0013 /* File with extra key information. */
#define EF_Rule 0x0030 /* Default ACL file. */ #define EF_Rule 0x0030 /* Default ACL file. */
#define MAX_CURPATH 10 #define MAX_CURPATH 10
struct rule_record_s { struct rule_record_s {
struct rule_record_s *next; struct rule_record_s *next;
@ -76,7 +76,7 @@ struct keyd_record_s {
struct df_info_s { struct df_info_s {
struct df_info_s *next; struct df_info_s *next;
unsigned short path[MAX_CURPATH]; unsigned short path[MAX_CURPATH];
size_t pathlen; size_t pathlen;
struct rule_record_s *rule_file; /* keeps records of EF_Rule. */ struct rule_record_s *rule_file; /* keeps records of EF_Rule. */
struct keyd_record_s *keyd_file; /* keeps records of EF_KeyD. */ struct keyd_record_s *keyd_file; /* keeps records of EF_KeyD. */
}; };
@ -85,7 +85,7 @@ struct mcrd_priv_data {
unsigned short curpath[MAX_CURPATH]; /* The currently selected path. */ unsigned short curpath[MAX_CURPATH]; /* The currently selected path. */
size_t curpathlen; /* Length of this path or 0 if unknown. */ size_t curpathlen; /* Length of this path or 0 if unknown. */
int is_ef; /* True if the path points to an EF. */ int is_ef; /* True if the path points to an EF. */
struct df_info_s *df_infos; struct df_info_s *df_infos;
sc_security_env_t sec_env; /* current security environment */ sc_security_env_t sec_env; /* current security environment */
}; };
@ -145,11 +145,11 @@ static void clear_special_files (struct df_info_s *dfi)
} }
} }
/* Some functionality straight from the EstEID manual. /* Some functionality straight from the EstEID manual.
* Official notice: Refer to the Micardo 2.1 Public manual. * Official notice: Refer to the Micardo 2.1 Public manual.
* Sad side: not available without a NDA. * Sad side: not available without a NDA.
*/ */
static int static int
mcrd_delete_ref_to_authkey (struct sc_card *card) mcrd_delete_ref_to_authkey (struct sc_card *card)
{ {
@ -201,7 +201,7 @@ mcrd_set_decipher_key_ref (struct sc_card *card, int key_reference)
u8 keyref_data[SC_ESTEID_KEYREF_FILE_RECLEN]; u8 keyref_data[SC_ESTEID_KEYREF_FILE_RECLEN];
assert (card != NULL); assert (card != NULL);
sc_format_apdu (card, &apdu, SC_APDU_CASE_3_SHORT, 0x22, 0x41, 0xB8); sc_format_apdu (card, &apdu, SC_APDU_CASE_3_SHORT, 0x22, 0x41, 0xB8);
/* track the active keypair */ /* track the active keypair */
sc_format_path("0033", &path); sc_format_path("0033", &path);
r = sc_select_file(card, &path, NULL); r = sc_select_file(card, &path, NULL);
@ -214,12 +214,12 @@ mcrd_set_decipher_key_ref (struct sc_card *card, int key_reference)
"Can't read keyref info file!"); "Can't read keyref info file!");
sc_debug(card->ctx, sc_debug(card->ctx,
"authkey reference 0x%02x%02x\n", "authkey reference 0x%02x%02x\n",
keyref_data[9], keyref_data[10]); keyref_data[9], keyref_data[10]);
sc_debug(card->ctx, sc_debug(card->ctx,
"signkey reference 0x%02x%02x\n", "signkey reference 0x%02x%02x\n",
keyref_data[19], keyref_data[20]); keyref_data[19], keyref_data[20]);
sbuf[0] = 0x83; sbuf[0] = 0x83;
@ -312,7 +312,7 @@ static int load_special_files (struct sc_card *card)
/* First check whether we already cached it. */ /* First check whether we already cached it. */
dfi = get_df_info (card); dfi = get_df_info (card);
if (dfi && dfi->rule_file) if (dfi && dfi->rule_file)
return 0; /* yes. */ return 0; /* yes. */
clear_special_files (dfi); clear_special_files (dfi);
@ -413,7 +413,7 @@ static int get_se_num_from_keyd (struct sc_card *card, unsigned short fid,
if (!dfi || !dfi->keyd_file) { if (!dfi || !dfi->keyd_file) {
sc_debug (ctx, "EF_keyD not loaded\n"); sc_debug (ctx, "EF_keyD not loaded\n");
return -1; return -1;
} }
for (keyd=dfi->keyd_file; keyd; keyd = keyd->next) { for (keyd=dfi->keyd_file; keyd; keyd = keyd->next) {
p = keyd->data; p = keyd->data;
@ -654,20 +654,20 @@ static void process_fcp(struct sc_card *card, struct sc_file *file,
/* Proprietary information. */ /* Proprietary information. */
tag = bad_fde? NULL : sc_asn1_find_tag(ctx, p, len, 0x85, &taglen); tag = bad_fde? NULL : sc_asn1_find_tag(ctx, p, len, 0x85, &taglen);
if (tag != NULL && taglen) { if (tag != NULL && taglen) {
sc_file_set_prop_attr(file, tag, taglen); sc_file_set_prop_attr(file, tag, taglen);
} else } else
file->prop_attr_len = 0; file->prop_attr_len = 0;
/* Proprietary information, constructed. */ /* Proprietary information, constructed. */
tag = sc_asn1_find_tag(ctx, p, len, 0xA5, &taglen); tag = sc_asn1_find_tag(ctx, p, len, 0xA5, &taglen);
if (tag != NULL && taglen) { if (tag != NULL && taglen) {
sc_file_set_prop_attr(file, tag, taglen); sc_file_set_prop_attr(file, tag, taglen);
} }
/* Security attributes, proprietary format. */ /* Security attributes, proprietary format. */
tag = sc_asn1_find_tag(ctx, p, len, 0x86, &taglen); tag = sc_asn1_find_tag(ctx, p, len, 0x86, &taglen);
if (tag != NULL && taglen) { if (tag != NULL && taglen) {
sc_file_set_sec_attr(file, tag, taglen); sc_file_set_sec_attr(file, tag, taglen);
} }
/* Security attributes, reference to expanded format. */ /* Security attributes, reference to expanded format. */
@ -716,7 +716,7 @@ do_select(struct sc_card *card, u8 kind,
if (apdu.sw1 == 0x61) if (apdu.sw1 == 0x61)
SC_FUNC_RETURN(card->ctx, 2, 0); SC_FUNC_RETURN(card->ctx, 2, 0);
r = sc_check_sw(card, apdu.sw1, apdu.sw2); r = sc_check_sw(card, apdu.sw1, apdu.sw2);
if (!r && kind == MCRD_SEL_AID) if (!r && kind == MCRD_SEL_AID)
card->cache.current_path.len = 0; card->cache.current_path.len = 0;
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
@ -781,7 +781,7 @@ select_down (struct sc_card *card,
int found_ef = 0; int found_ef = 0;
if (!pathlen) if (!pathlen)
return SC_ERROR_INVALID_ARGUMENTS; return SC_ERROR_INVALID_ARGUMENTS;
for (; pathlen; pathlen--, pathptr++) { for (; pathlen; pathlen--, pathptr++) {
if (priv->curpathlen == MAX_CURPATH) if (priv->curpathlen == MAX_CURPATH)
@ -792,7 +792,7 @@ select_down (struct sc_card *card,
/* first try to select an EF and retry an DF /* first try to select an EF and retry an DF
on error. */ on error. */
r = select_part (card, MCRD_SEL_EF,*pathptr, file); r = select_part (card, MCRD_SEL_EF,*pathptr, file);
if (!r) if (!r)
found_ef = 1; found_ef = 1;
} }
if (r) if (r)
@ -803,7 +803,7 @@ select_down (struct sc_card *card,
priv->curpathlen++; priv->curpathlen++;
} }
priv->is_ef = found_ef; priv->is_ef = found_ef;
if (!found_ef) if (!found_ef)
load_special_files (card); load_special_files (card);
return 0; return 0;
@ -815,7 +815,7 @@ select_down (struct sc_card *card,
this is accomplished be keeping track of the currently selected this is accomplished be keeping track of the currently selected
file. Note that PATH is an array of PATHLEN file ids and not the file. Note that PATH is an array of PATHLEN file ids and not the
usual sc_path structure. */ usual sc_path structure. */
static int static int
select_file_by_path (struct sc_card *card, unsigned short *pathptr, select_file_by_path (struct sc_card *card, unsigned short *pathptr,
size_t pathlen, size_t pathlen,
@ -879,7 +879,7 @@ select_file_by_path (struct sc_card *card, unsigned short *pathptr,
priv->curpathlen = 0; priv->curpathlen = 0;
priv->is_ef = 0; priv->is_ef = 0;
r = select_down (card, pathptr, pathlen, 0, file); r = select_down (card, pathptr, pathlen, 0, file);
} }
} else { } else {
/* Relative addressing. */ /* Relative addressing. */
if (!priv->curpathlen) { if (!priv->curpathlen) {
@ -913,7 +913,7 @@ select_file_by_fid (struct sc_card *card, unsigned short *pathptr,
if (pathlen > 1) if (pathlen > 1)
return SC_ERROR_INVALID_ARGUMENTS; return SC_ERROR_INVALID_ARGUMENTS;
if (pathlen && *pathptr == 0x3FFF) if (pathlen && *pathptr == 0x3FFF)
return 0; return 0;
if (!pathlen) { if (!pathlen) {
@ -1014,7 +1014,7 @@ mcrd_select_file(struct sc_card *card, const struct sc_path *path,
for (n = 0; n < path->len; n += 2) for (n = 0; n < path->len; n += 2)
pathptr[n>>1] = (path->value[n] << 8)|path->value[n+1]; pathptr[n>>1] = (path->value[n] << 8)|path->value[n+1];
pathlen = path->len >> 1; pathlen = path->len >> 1;
if (path->type == SC_PATH_TYPE_PATH) if (path->type == SC_PATH_TYPE_PATH)
r = select_file_by_path (card, pathptr, pathlen, file); r = select_file_by_path (card, pathptr, pathlen, file);
else { /* SC_PATH_TYPE_FILEID */ else { /* SC_PATH_TYPE_FILEID */
r = select_file_by_fid (card, pathptr, pathlen, file); r = select_file_by_fid (card, pathptr, pathlen, file);
@ -1053,7 +1053,7 @@ static int mcrd_enable_se (struct sc_card *card, int se_num)
/* It seems that MICARDO does not fully comply with ISO, so I use /* It seems that MICARDO does not fully comply with ISO, so I use
values gathered from peeking actual signing opeations using a values gathered from peeking actual signing opeations using a
different system. different system.
It has been generalized [?] and modified by information coming from It has been generalized [?] and modified by information coming from
openpgp card implementation, EstEID 'manual' and some other sources. -mp openpgp card implementation, EstEID 'manual' and some other sources. -mp
*/ */
@ -1272,7 +1272,7 @@ static int mcrd_decipher(struct sc_card *card,
static int mcrd_pin_cmd(struct sc_card *card, struct sc_pin_cmd_data *data, static int mcrd_pin_cmd(struct sc_card *card, struct sc_pin_cmd_data *data,
int *tries_left) int *tries_left)
{ {
SC_FUNC_CALLED(card->ctx, 3); SC_FUNC_CALLED(card->ctx, 3);
data->pin1.offset = 5; data->pin1.offset = 5;
data->pin1.length_offset = 4; data->pin1.length_offset = 4;
data->pin2.offset = 5; data->pin2.offset = 5;

17
src/libopensc/card-setcos.c
View File

@ -116,13 +116,12 @@ static int setcos_init(struct sc_card *card)
/* Handle unknown or forced cards */ /* Handle unknown or forced cards */
if (card->type < 0) { if (card->type < 0) {
card->type = SC_CARD_TYPE_SETCOS_GENERIC;
#if 0 #if 0
/* Hmm. For now, assume it's a bank card with FinEID application */ /* Hmm. For now, assume it's a bank card with FinEID application */
if (match_hist_bytes(card, "AVANT", 0)) { if (match_hist_bytes(card, "AVANT", 0)) {
card->type = SC_CARD_TYPE_SETCOS_FINEID; card->type = SC_CARD_TYPE_SETCOS_FINEID;
} else
#endif #endif
card->type = SC_CARD_TYPE_SETCOS_GENERIC;
} }
if (card->type == SC_CARD_TYPE_SETCOS_FINEID) { if (card->type == SC_CARD_TYPE_SETCOS_FINEID) {
card->cla = 0x00; card->cla = 0x00;
@ -130,7 +129,7 @@ static int setcos_init(struct sc_card *card)
} }
if (card->type == SC_CARD_TYPE_SETCOS_PKI || card->type == SC_CARD_TYPE_SETCOS_FINEID) { if (card->type == SC_CARD_TYPE_SETCOS_PKI || card->type == SC_CARD_TYPE_SETCOS_FINEID) {
unsigned long flags; unsigned long flags;
flags = SC_ALGORITHM_RSA_RAW | SC_ALGORITHM_RSA_PAD_PKCS1; flags = SC_ALGORITHM_RSA_RAW | SC_ALGORITHM_RSA_PAD_PKCS1;
flags |= SC_ALGORITHM_RSA_HASH_NONE | SC_ALGORITHM_RSA_HASH_SHA1; flags |= SC_ALGORITHM_RSA_HASH_NONE | SC_ALGORITHM_RSA_HASH_SHA1;
@ -313,7 +312,7 @@ static int setcos_set_security_env(struct sc_card *card,
tmp.algorithm_ref |= 0x10; tmp.algorithm_ref |= 0x10;
return setcos_set_security_env2(card, &tmp, se_num); return setcos_set_security_env2(card, &tmp, se_num);
} }
return setcos_set_security_env2(card, env, se_num); return setcos_set_security_env2(card, env, se_num);
} }
static void add_acl_entry(struct sc_file *file, int op, u8 byte) static void add_acl_entry(struct sc_file *file, int op, u8 byte)
@ -378,7 +377,7 @@ static int setcos_select_file(struct sc_card *card,
struct sc_file **file) struct sc_file **file)
{ {
int r; int r;
r = iso_ops->select_file(card, in_path, file); r = iso_ops->select_file(card, in_path, file);
if (r) if (r)
return r; return r;
@ -410,15 +409,15 @@ static struct sc_card_driver * sc_get_driver(void)
setcos_ops = *iso_drv->ops; setcos_ops = *iso_drv->ops;
setcos_ops.match_card = setcos_match_card; setcos_ops.match_card = setcos_match_card;
setcos_ops.init = setcos_init; setcos_ops.init = setcos_init;
setcos_ops.finish = setcos_finish; setcos_ops.finish = setcos_finish;
if (iso_ops == NULL) if (iso_ops == NULL)
iso_ops = iso_drv->ops; iso_ops = iso_drv->ops;
setcos_ops.create_file = setcos_create_file; setcos_ops.create_file = setcos_create_file;
setcos_ops.set_security_env = setcos_set_security_env; setcos_ops.set_security_env = setcos_set_security_env;
setcos_ops.select_file = setcos_select_file; setcos_ops.select_file = setcos_select_file;
setcos_ops.list_files = setcos_list_files; setcos_ops.list_files = setcos_list_files;
return &setcos_drv; return &setcos_drv;
} }
#if 1 #if 1

58
src/libopensc/card.c
View File

@ -519,9 +519,9 @@ int sc_unlock(struct sc_card *card)
if (card->lock_count == 1) { if (card->lock_count == 1) {
if (card->reader->ops->unlock != NULL) if (card->reader->ops->unlock != NULL)
r = card->reader->ops->unlock(card->reader, card->slot); r = card->reader->ops->unlock(card->reader, card->slot);
} }
card->lock_count--; card->lock_count--;
sc_mutex_unlock(card->mutex); sc_mutex_unlock(card->mutex);
return r; return r;
} }
@ -531,10 +531,10 @@ int sc_list_files(struct sc_card *card, u8 *buf, size_t buflen)
assert(card != NULL); assert(card != NULL);
SC_FUNC_CALLED(card->ctx, 1); SC_FUNC_CALLED(card->ctx, 1);
if (card->ops->list_files == NULL) if (card->ops->list_files == NULL)
SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_NOT_SUPPORTED);
r = card->ops->list_files(card, buf, buflen); r = card->ops->list_files(card, buf, buflen);
SC_FUNC_RETURN(card->ctx, 1, r); SC_FUNC_RETURN(card->ctx, 1, r);
} }
int sc_create_file(struct sc_card *card, struct sc_file *file) int sc_create_file(struct sc_card *card, struct sc_file *file)
@ -549,10 +549,10 @@ int sc_create_file(struct sc_card *card, struct sc_file *file)
in_path->type, in_path->type,
sc_print_path(in_path), file->size); sc_print_path(in_path), file->size);
} }
if (card->ops->create_file == NULL) if (card->ops->create_file == NULL)
SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_NOT_SUPPORTED);
r = card->ops->create_file(card, file); r = card->ops->create_file(card, file);
SC_FUNC_RETURN(card->ctx, 1, r); SC_FUNC_RETURN(card->ctx, 1, r);
} }
int sc_delete_file(struct sc_card *card, const struct sc_path *path) int sc_delete_file(struct sc_card *card, const struct sc_path *path)
@ -565,10 +565,10 @@ int sc_delete_file(struct sc_card *card, const struct sc_path *path)
path->type, path->type,
sc_print_path(path)); sc_print_path(path));
} }
if (card->ops->delete_file == NULL) if (card->ops->delete_file == NULL)
SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_NOT_SUPPORTED);
r = card->ops->delete_file(card, path); r = card->ops->delete_file(card, path);
SC_FUNC_RETURN(card->ctx, 1, r); SC_FUNC_RETURN(card->ctx, 1, r);
} }
int sc_read_binary(struct sc_card *card, unsigned int idx, int sc_read_binary(struct sc_card *card, unsigned int idx,
@ -610,7 +610,7 @@ int sc_read_binary(struct sc_card *card, unsigned int idx,
SC_FUNC_RETURN(card->ctx, 2, bytes_read); SC_FUNC_RETURN(card->ctx, 2, bytes_read);
} }
r = card->ops->read_binary(card, idx, buf, count, flags); r = card->ops->read_binary(card, idx, buf, count, flags);
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
int sc_write_binary(struct sc_card *card, unsigned int idx, int sc_write_binary(struct sc_card *card, unsigned int idx,
@ -652,7 +652,7 @@ int sc_write_binary(struct sc_card *card, unsigned int idx,
SC_FUNC_RETURN(card->ctx, 2, bytes_written); SC_FUNC_RETURN(card->ctx, 2, bytes_written);
} }
r = card->ops->write_binary(card, idx, buf, count, flags); r = card->ops->write_binary(card, idx, buf, count, flags);
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
int sc_update_binary(struct sc_card *card, unsigned int idx, int sc_update_binary(struct sc_card *card, unsigned int idx,
@ -694,7 +694,7 @@ int sc_update_binary(struct sc_card *card, unsigned int idx,
SC_FUNC_RETURN(card->ctx, 2, bytes_written); SC_FUNC_RETURN(card->ctx, 2, bytes_written);
} }
r = card->ops->update_binary(card, idx, buf, count, flags); r = card->ops->update_binary(card, idx, buf, count, flags);
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
int sc_select_file(struct sc_card *card, int sc_select_file(struct sc_card *card,
@ -729,7 +729,7 @@ int sc_select_file(struct sc_card *card,
/* Remember file path */ /* Remember file path */
if (r == 0 && file && *file) if (r == 0 && file && *file)
(*file)->path = *in_path; (*file)->path = *in_path;
SC_FUNC_RETURN(card->ctx, 1, r); SC_FUNC_RETURN(card->ctx, 1, r);
} }
int sc_get_data(sc_card_t *card, unsigned int tag, u8 *buf, size_t len) int sc_get_data(sc_card_t *card, unsigned int tag, u8 *buf, size_t len)
@ -737,10 +737,10 @@ int sc_get_data(sc_card_t *card, unsigned int tag, u8 *buf, size_t len)
int r; int r;
sc_debug(card->ctx, "called, tag=%04x\n", tag); sc_debug(card->ctx, "called, tag=%04x\n", tag);
if (card->ops->get_data == NULL) if (card->ops->get_data == NULL)
SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED);
r = card->ops->get_data(card, tag, buf, len); r = card->ops->get_data(card, tag, buf, len);
SC_FUNC_RETURN(card->ctx, 1, r); SC_FUNC_RETURN(card->ctx, 1, r);
} }
int sc_put_data(sc_card_t *card, unsigned int tag, const u8 *buf, size_t len) int sc_put_data(sc_card_t *card, unsigned int tag, const u8 *buf, size_t len)
@ -748,10 +748,10 @@ int sc_put_data(sc_card_t *card, unsigned int tag, const u8 *buf, size_t len)
int r; int r;
sc_debug(card->ctx, "called, tag=%04x\n", tag); sc_debug(card->ctx, "called, tag=%04x\n", tag);
if (card->ops->put_data == NULL) if (card->ops->put_data == NULL)
SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED);
r = card->ops->put_data(card, tag, buf, len); r = card->ops->put_data(card, tag, buf, len);
SC_FUNC_RETURN(card->ctx, 1, r); SC_FUNC_RETURN(card->ctx, 1, r);
} }
int sc_get_challenge(struct sc_card *card, u8 *rnd, size_t len) int sc_get_challenge(struct sc_card *card, u8 *rnd, size_t len)
@ -760,10 +760,10 @@ int sc_get_challenge(struct sc_card *card, u8 *rnd, size_t len)
assert(card != NULL); assert(card != NULL);
SC_FUNC_CALLED(card->ctx, 2); SC_FUNC_CALLED(card->ctx, 2);
if (card->ops->get_challenge == NULL) if (card->ops->get_challenge == NULL)
SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED);
r = card->ops->get_challenge(card, rnd, len); r = card->ops->get_challenge(card, rnd, len);
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
int sc_read_record(struct sc_card *card, unsigned int rec_nr, u8 *buf, int sc_read_record(struct sc_card *card, unsigned int rec_nr, u8 *buf,
@ -773,10 +773,10 @@ int sc_read_record(struct sc_card *card, unsigned int rec_nr, u8 *buf,
assert(card != NULL); assert(card != NULL);
SC_FUNC_CALLED(card->ctx, 2); SC_FUNC_CALLED(card->ctx, 2);
if (card->ops->read_record == NULL) if (card->ops->read_record == NULL)
SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED);
r = card->ops->read_record(card, rec_nr, buf, count, flags); r = card->ops->read_record(card, rec_nr, buf, count, flags);
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
int sc_write_record(struct sc_card *card, unsigned int rec_nr, const u8 * buf, int sc_write_record(struct sc_card *card, unsigned int rec_nr, const u8 * buf,
@ -786,10 +786,10 @@ int sc_write_record(struct sc_card *card, unsigned int rec_nr, const u8 * buf,
assert(card != NULL); assert(card != NULL);
SC_FUNC_CALLED(card->ctx, 2); SC_FUNC_CALLED(card->ctx, 2);
if (card->ops->write_record == NULL) if (card->ops->write_record == NULL)
SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED);
r = card->ops->write_record(card, rec_nr, buf, count, flags); r = card->ops->write_record(card, rec_nr, buf, count, flags);
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
int sc_append_record(struct sc_card *card, const u8 * buf, size_t count, int sc_append_record(struct sc_card *card, const u8 * buf, size_t count,
@ -799,10 +799,10 @@ int sc_append_record(struct sc_card *card, const u8 * buf, size_t count,
assert(card != NULL); assert(card != NULL);
SC_FUNC_CALLED(card->ctx, 2); SC_FUNC_CALLED(card->ctx, 2);
if (card->ops->append_record == NULL) if (card->ops->append_record == NULL)
SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED);
r = card->ops->append_record(card, buf, count, flags); r = card->ops->append_record(card, buf, count, flags);
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
int sc_update_record(struct sc_card *card, unsigned int rec_nr, const u8 * buf, int sc_update_record(struct sc_card *card, unsigned int rec_nr, const u8 * buf,
@ -812,10 +812,10 @@ int sc_update_record(struct sc_card *card, unsigned int rec_nr, const u8 * buf,
assert(card != NULL); assert(card != NULL);
SC_FUNC_CALLED(card->ctx, 2); SC_FUNC_CALLED(card->ctx, 2);
if (card->ops->update_record == NULL) if (card->ops->update_record == NULL)
SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED); SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_NOT_SUPPORTED);
r = card->ops->update_record(card, rec_nr, buf, count, flags); r = card->ops->update_record(card, rec_nr, buf, count, flags);
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
int sc_delete_record(struct sc_card *card, unsigned int rec_nr) int sc_delete_record(struct sc_card *card, unsigned int rec_nr)
@ -844,7 +844,7 @@ sc_card_ctl(struct sc_card *card, unsigned long cmd, void *args)
assert(card != NULL); assert(card != NULL);
SC_FUNC_CALLED(card->ctx, 2); SC_FUNC_CALLED(card->ctx, 2);
if (card->ops->card_ctl != NULL) if (card->ops->card_ctl != NULL)
r = card->ops->card_ctl(card, cmd, args); r = card->ops->card_ctl(card, cmd, args);
/* suppress "not supported" error messages */ /* suppress "not supported" error messages */
@ -852,7 +852,7 @@ sc_card_ctl(struct sc_card *card, unsigned long cmd, void *args)
sc_debug(card->ctx, "card_ctl(%lu) not supported\n", cmd); sc_debug(card->ctx, "card_ctl(%lu) not supported\n", cmd);
return r; return r;
} }
SC_FUNC_RETURN(card->ctx, 2, r); SC_FUNC_RETURN(card->ctx, 2, r);
} }
int _sc_card_add_algorithm(struct sc_card *card, const struct sc_algorithm_info *info) int _sc_card_add_algorithm(struct sc_card *card, const struct sc_algorithm_info *info)

7
src/libopensc/pinpad-ccid.c
View File

@ -1,4 +1,4 @@
/* /*
* OpenSC pinpad support for CCID compatible readers. * OpenSC pinpad support for CCID compatible readers.
* *
* These functions build CCID PIN control blocks to be used with * These functions build CCID PIN control blocks to be used with
@ -64,7 +64,6 @@ static int ccid_build_verify_pin_block(u8 * buf, size_t * size, struct sc_pin_cm
if (!data->pin1.min_length || !data->pin1.max_length) if (!data->pin1.min_length || !data->pin1.max_length)
return SC_ERROR_INVALID_ARGUMENTS; return SC_ERROR_INVALID_ARGUMENTS;
buf[count++] = data->pin1.max_length; /* wPINMaxExtraDigit: max */ buf[count++] = data->pin1.max_length; /* wPINMaxExtraDigit: max */
buf[count++] = data->pin1.min_length; /* wPINMaxExtraDigit: min */ buf[count++] = data->pin1.min_length; /* wPINMaxExtraDigit: min */
@ -95,7 +94,7 @@ static int ccid_build_verify_pin_block(u8 * buf, size_t * size, struct sc_pin_cm
* *
* Otherwise we assume a proper APDU and CCID compatible operations * Otherwise we assume a proper APDU and CCID compatible operations
* and the APDU is copied verbatim. * and the APDU is copied verbatim.
*/ */
if (data->pin1.length_offset > 4) { if (data->pin1.length_offset > 4) {
memcpy(&buf[count], apdu->data, apdu->datalen); memcpy(&buf[count], apdu->data, apdu->datalen);
count += apdu->datalen; count += apdu->datalen;
@ -150,7 +149,7 @@ ccid_pin_cmd(struct sc_reader *reader, sc_slot_info_t * slot,
/* The slot must be manually locked, as the control does not pass through card.c /* The slot must be manually locked, as the control does not pass through card.c
* wrappers that lock the card (card_transmit is not OK in this case, as it assumes * wrappers that lock the card (card_transmit is not OK in this case, as it assumes
* a proper APDU as a parameter, not a arbitary binary blob to be sent to the reader) * a proper APDU as a parameter, not an arbitary binary blob to be sent to the reader)
*/ */
r = reader->ops->lock(reader, slot); r = reader->ops->lock(reader, slot);
SC_TEST_RET(reader->ctx, r, "CCID PIN: Could not lock!"); SC_TEST_RET(reader->ctx, r, "CCID PIN: Could not lock!");

4
src/libopensc/pkcs15-esteid.c
View File

@ -63,10 +63,8 @@ sc_pkcs15emu_esteid_init (sc_pkcs15_card_t * p15card)
set_string (&p15card->label, "EstEID isikutunnistus"); set_string (&p15card->label, "EstEID isikutunnistus");
set_string (&p15card->manufacturer_id, "AS Sertifitseerimiskeskus"); set_string (&p15card->manufacturer_id, "AS Sertifitseerimiskeskus");
select_esteid_df (card);
/* read the serial (document number) */ /* read the serial (document number) */
sc_format_path ("5044", &tmppath); sc_format_path ("3f00eeee5044", &tmppath);
tmppath.type = SC_PATH_TYPE_PATH; tmppath.type = SC_PATH_TYPE_PATH;
r = sc_select_file (card, &tmppath, NULL); r = sc_select_file (card, &tmppath, NULL);
SC_TEST_RET (card->ctx, r, "select esteid PD failed"); SC_TEST_RET (card->ctx, r, "select esteid PD failed");

4
src/libopensc/pkcs15.c
View File

@ -765,7 +765,7 @@ __sc_pkcs15_search_objects(sc_pkcs15_card_t *p15card,
int sc_pkcs15_get_objects(struct sc_pkcs15_card *p15card, int type, int sc_pkcs15_get_objects(struct sc_pkcs15_card *p15card, int type,
struct sc_pkcs15_object **ret, int ret_size) struct sc_pkcs15_object **ret, int ret_size)
{ {
return sc_pkcs15_get_objects_cond(p15card, type, NULL, NULL, ret, ret_size); return sc_pkcs15_get_objects_cond(p15card, type, NULL, NULL, ret, ret_size);
} }
static int compare_obj_id(struct sc_pkcs15_object *obj, const sc_pkcs15_id_t *id) static int compare_obj_id(struct sc_pkcs15_object *obj, const sc_pkcs15_id_t *id)
@ -1183,7 +1183,7 @@ int sc_pkcs15_parse_df(struct sc_pkcs15_card *p15card,
{ {
struct sc_context *ctx = p15card->card->ctx; struct sc_context *ctx = p15card->card->ctx;
u8 *buf; u8 *buf;
const u8 *p; const u8 *p;
size_t bufsize; size_t bufsize;
int r; int r;
struct sc_pkcs15_object *obj = NULL; struct sc_pkcs15_object *obj = NULL;

77
src/pkcs11/framework-pkcs15.c
View File

@ -49,7 +49,7 @@ struct pkcs15_slot_data {
attr->ulValueLen = size; \ attr->ulValueLen = size; \
return CKR_BUFFER_TOO_SMALL; \ return CKR_BUFFER_TOO_SMALL; \
} \ } \
attr->ulValueLen = size; attr->ulValueLen = size;
#define MAX_OBJECTS 64 #define MAX_OBJECTS 64
struct pkcs15_fw_data { struct pkcs15_fw_data {
@ -291,7 +291,7 @@ __pkcs15_create_cert_object(struct pkcs15_fw_data *fw_data,
memcpy(obj2->pub_data, &p15_cert->key, sizeof(sc_pkcs15_pubkey_t)); memcpy(obj2->pub_data, &p15_cert->key, sizeof(sc_pkcs15_pubkey_t));
/* invalidate public data of the cert object so that sc_pkcs15_cert_free /* invalidate public data of the cert object so that sc_pkcs15_cert_free
* does not free the public key data as well (something like * does not free the public key data as well (something like
* sc_pkcs15_pubkey_dup would have been nice here) -- Nils * sc_pkcs15_pubkey_dup would have been nice here) -- Nils
*/ */
memset(&p15_cert->key, 0, sizeof(sc_pkcs15_pubkey_t)); memset(&p15_cert->key, 0, sizeof(sc_pkcs15_pubkey_t));
obj2->pub_cert = object; obj2->pub_cert = object;
@ -692,7 +692,7 @@ static CK_RV pkcs15_create_tokens(struct sc_pkcs11_card *p11card)
struct pkcs15_any_object *obj = fw_data->objects[j]; struct pkcs15_any_object *obj = fw_data->objects[j];
if (!(obj->base.flags & SC_PKCS11_OBJECT_SEEN)) { if (!(obj->base.flags & SC_PKCS11_OBJECT_SEEN)) {
sc_debug(context, "Object %d was not seen previously\n", j); sc_debug(context, "Object %d was not seen previously\n", j);
if (!slot) { if (!slot) {
rv = pkcs15_create_slot(p11card, NULL, &slot); rv = pkcs15_create_slot(p11card, NULL, &slot);
if (rv != CKR_OK) if (rv != CKR_OK)
@ -719,7 +719,7 @@ static CK_RV pkcs15_create_tokens(struct sc_pkcs11_card *p11card)
static CK_RV pkcs15_release_token(struct sc_pkcs11_card *p11card, void *fw_token) static CK_RV pkcs15_release_token(struct sc_pkcs11_card *p11card, void *fw_token)
{ {
unlock_card((struct pkcs15_fw_data *) p11card->fw_data); unlock_card((struct pkcs15_fw_data *) p11card->fw_data);
return CKR_OK; return CKR_OK;
} }
static CK_RV pkcs15_login(struct sc_pkcs11_card *p11card, static CK_RV pkcs15_login(struct sc_pkcs11_card *p11card,
@ -926,7 +926,7 @@ static CK_RV pkcs15_create_private_key(struct sc_pkcs11_card *p11card,
case CKA_KEY_TYPE: case CKA_KEY_TYPE:
case CKA_MODULUS_BITS: case CKA_MODULUS_BITS:
case CKA_PRIVATE: case CKA_PRIVATE:
break; break;
case CKA_LABEL: case CKA_LABEL:
args.label = (char *) attr->pValue; args.label = (char *) attr->pValue;
break; break;
@ -991,9 +991,9 @@ static CK_RV pkcs15_create_public_key(struct sc_pkcs11_card *p11card,
struct pkcs15_any_object *key_any_obj; struct pkcs15_any_object *key_any_obj;
struct sc_pkcs15_object *key_obj; struct sc_pkcs15_object *key_obj;
struct sc_pkcs15_pin_info *pin; struct sc_pkcs15_pin_info *pin;
CK_KEY_TYPE key_type; CK_KEY_TYPE key_type;
struct sc_pkcs15_pubkey_rsa *rsa; struct sc_pkcs15_pubkey_rsa *rsa;
int rc, rv; int rc, rv;
memset(&args, 0, sizeof(args)); memset(&args, 0, sizeof(args));
@ -1022,7 +1022,7 @@ static CK_RV pkcs15_create_public_key(struct sc_pkcs11_card *p11card,
case CKA_KEY_TYPE: case CKA_KEY_TYPE:
case CKA_MODULUS_BITS: case CKA_MODULUS_BITS:
case CKA_PRIVATE: case CKA_PRIVATE:
break; break;
case CKA_LABEL: case CKA_LABEL:
args.label = (char *) attr->pValue; args.label = (char *) attr->pValue;
break; break;
@ -1100,7 +1100,7 @@ static CK_RV pkcs15_create_certificate(struct sc_pkcs11_card *p11card,
switch (attr->type) { switch (attr->type) {
/* Skip attrs we already know or don't care for */ /* Skip attrs we already know or don't care for */
case CKA_CLASS: case CKA_CLASS:
break; break;
case CKA_PRIVATE: case CKA_PRIVATE:
rv = attr_extract(attr, &bValue, NULL); rv = attr_extract(attr, &bValue, NULL);
if (bValue) { if (bValue) {
@ -1153,7 +1153,7 @@ static CK_RV pkcs15_create_object(struct sc_pkcs11_card *p11card,
{ {
struct sc_profile *profile = NULL; struct sc_profile *profile = NULL;
CK_OBJECT_CLASS _class; CK_OBJECT_CLASS _class;
int rv, rc; int rv, rc;
rv = attr_find(pTemplate, ulCount, CKA_CLASS, &_class, NULL); rv = attr_find(pTemplate, ulCount, CKA_CLASS, &_class, NULL);
if (rv != CKR_OK) if (rv != CKR_OK)
@ -1563,17 +1563,15 @@ static CK_RV pkcs15_cert_get_attribute(struct sc_pkcs11_session *session,
memcpy(attr->pValue, cert->cert_data->data, cert->cert_data->data_len); memcpy(attr->pValue, cert->cert_data->data, cert->cert_data->data_len);
break; break;
case CKA_SERIAL_NUMBER: case CKA_SERIAL_NUMBER:
check_attribute_buffer(attr, cert->cert_data->serial_len); check_attribute_buffer(attr, cert->cert_data->serial_len);
memcpy(attr->pValue, cert->cert_data->serial, cert->cert_data->serial_len); memcpy(attr->pValue, cert->cert_data->serial, cert->cert_data->serial_len);
break; break;
case CKA_SUBJECT: case CKA_SUBJECT:
return asn1_sequence_wrapper(cert->cert_data->subject, return asn1_sequence_wrapper(cert->cert_data->subject,
cert->cert_data->subject_len, cert->cert_data->subject_len, attr);
attr);
case CKA_ISSUER: case CKA_ISSUER:
return asn1_sequence_wrapper(cert->cert_data->issuer, return asn1_sequence_wrapper(cert->cert_data->issuer,
cert->cert_data->issuer_len, cert->cert_data->issuer_len, attr);
attr);
default: default:
return CKR_ATTRIBUTE_TYPE_INVALID; return CKR_ATTRIBUTE_TYPE_INVALID;
} }
@ -1762,7 +1760,7 @@ static CK_RV pkcs15_prkey_sign(struct sc_pkcs11_session *ses, void *obj,
if (prkey->prv_p15obj->user_consent) { if (prkey->prv_p15obj->user_consent) {
/* XXX we should really keep track how often the key /* XXX we should really keep track how often the key
* is used, and how often we need to ask the user for * is used, and how often we need to ask the user for
* her PIN. * her PIN.
* For now, we just assume user_consent is 1. * For now, we just assume user_consent is 1.
*/ */
/* XXX - do we require an sc_lock here? */ /* XXX - do we require an sc_lock here? */
@ -1775,7 +1773,7 @@ static CK_RV pkcs15_prkey_sign(struct sc_pkcs11_session *ses, void *obj,
while (prkey while (prkey
&& !(prkey->prv_info->usage && !(prkey->prv_info->usage
& (SC_PKCS15_PRKEY_USAGE_SIGN|SC_PKCS15_PRKEY_USAGE_SIGNRECOVER| & (SC_PKCS15_PRKEY_USAGE_SIGN|SC_PKCS15_PRKEY_USAGE_SIGNRECOVER|
SC_PKCS15_PRKEY_USAGE_NONREPUDIATION))) SC_PKCS15_PRKEY_USAGE_NONREPUDIATION)))
prkey = prkey->prv_next; prkey = prkey->prv_next;
if (prkey == NULL) if (prkey == NULL)
@ -1870,7 +1868,7 @@ pkcs15_prkey_decrypt(struct sc_pkcs11_session *ses, void *obj,
/* Select the proper padding mechanism */ /* Select the proper padding mechanism */
switch (pMechanism->mechanism) { switch (pMechanism->mechanism) {
case CKM_RSA_PKCS: case CKM_RSA_PKCS:
flags |= SC_ALGORITHM_RSA_PAD_PKCS1; flags |= SC_ALGORITHM_RSA_PAD_PKCS1;
break; break;
case CKM_RSA_X_509: case CKM_RSA_X_509:
flags |= SC_ALGORITHM_RSA_RAW; flags |= SC_ALGORITHM_RSA_RAW;
@ -1892,8 +1890,7 @@ pkcs15_prkey_decrypt(struct sc_pkcs11_session *ses, void *obj,
} }
rv = sc_pkcs15_decipher(fw_data->p15_card, prkey->prv_p15obj, rv = sc_pkcs15_decipher(fw_data->p15_card, prkey->prv_p15obj,
flags, flags, pEncryptedData, ulEncryptedDataLen,
pEncryptedData, ulEncryptedDataLen,
decrypted, sizeof(decrypted)); decrypted, sizeof(decrypted));
/* Do we have to try a re-login and then try to decrypt again? */ /* Do we have to try a re-login and then try to decrypt again? */
@ -1901,8 +1898,7 @@ pkcs15_prkey_decrypt(struct sc_pkcs11_session *ses, void *obj,
rv = revalidate_pin(data, ses); rv = revalidate_pin(data, ses);
if (rv == 0) if (rv == 0)
rv = sc_pkcs15_decipher(fw_data->p15_card, prkey->prv_p15obj, rv = sc_pkcs15_decipher(fw_data->p15_card, prkey->prv_p15obj,
flags, flags, pEncryptedData, ulEncryptedDataLen,
pEncryptedData, ulEncryptedDataLen,
decrypted, sizeof(decrypted)); decrypted, sizeof(decrypted));
} }
sc_unlock(ses->slot->card->card); sc_unlock(ses->slot->card->card);
@ -1989,7 +1985,7 @@ static CK_RV pkcs15_pubkey_get_attribute(struct sc_pkcs11_session *session,
case CKA_CLASS: case CKA_CLASS:
check_attribute_buffer(attr, sizeof(CK_OBJECT_CLASS)); check_attribute_buffer(attr, sizeof(CK_OBJECT_CLASS));
*(CK_OBJECT_CLASS*)attr->pValue = CKO_PUBLIC_KEY; *(CK_OBJECT_CLASS*)attr->pValue = CKO_PUBLIC_KEY;
break; break;
case CKA_TOKEN: case CKA_TOKEN:
case CKA_LOCAL: case CKA_LOCAL:
case CKA_SENSITIVE: case CKA_SENSITIVE:
@ -1997,13 +1993,13 @@ static CK_RV pkcs15_pubkey_get_attribute(struct sc_pkcs11_session *session,
case CKA_NEVER_EXTRACTABLE: case CKA_NEVER_EXTRACTABLE:
check_attribute_buffer(attr, sizeof(CK_BBOOL)); check_attribute_buffer(attr, sizeof(CK_BBOOL));
*(CK_BBOOL*)attr->pValue = TRUE; *(CK_BBOOL*)attr->pValue = TRUE;
break; break;
case CKA_PRIVATE: case CKA_PRIVATE:
case CKA_MODIFIABLE: case CKA_MODIFIABLE:
case CKA_EXTRACTABLE: case CKA_EXTRACTABLE:
check_attribute_buffer(attr, sizeof(CK_BBOOL)); check_attribute_buffer(attr, sizeof(CK_BBOOL));
*(CK_BBOOL*)attr->pValue = FALSE; *(CK_BBOOL*)attr->pValue = FALSE;
break; break;
case CKA_LABEL: case CKA_LABEL:
if (pubkey->pub_p15obj) { if (pubkey->pub_p15obj) {
len = strlen(pubkey->pub_p15obj->label); len = strlen(pubkey->pub_p15obj->label);
@ -2019,8 +2015,8 @@ static CK_RV pkcs15_pubkey_get_attribute(struct sc_pkcs11_session *session,
break; break;
case CKA_KEY_TYPE: case CKA_KEY_TYPE:
check_attribute_buffer(attr, sizeof(CK_KEY_TYPE)); check_attribute_buffer(attr, sizeof(CK_KEY_TYPE));
*(CK_KEY_TYPE*)attr->pValue = CKK_RSA; *(CK_KEY_TYPE*)attr->pValue = CKK_RSA;
break; break;
case CKA_ID: case CKA_ID:
if (pubkey->pub_info) { if (pubkey->pub_info) {
check_attribute_buffer(attr, pubkey->pub_info->id.len); check_attribute_buffer(attr, pubkey->pub_info->id.len);
@ -2031,10 +2027,10 @@ static CK_RV pkcs15_pubkey_get_attribute(struct sc_pkcs11_session *session,
} else { } else {
return CKR_ATTRIBUTE_TYPE_INVALID; return CKR_ATTRIBUTE_TYPE_INVALID;
} }
break; break;
case CKA_KEY_GEN_MECHANISM: case CKA_KEY_GEN_MECHANISM:
check_attribute_buffer(attr, sizeof(CK_MECHANISM_TYPE)); check_attribute_buffer(attr, sizeof(CK_MECHANISM_TYPE));
*(CK_MECHANISM_TYPE*)attr->pValue = CK_UNAVAILABLE_INFORMATION; *(CK_MECHANISM_TYPE*)attr->pValue = CK_UNAVAILABLE_INFORMATION;
break; break;
case CKA_ENCRYPT: case CKA_ENCRYPT:
case CKA_DECRYPT: case CKA_DECRYPT:
@ -2105,10 +2101,10 @@ static CK_RV pkcs15_dobj_set_attribute(struct sc_pkcs11_session *session,
static int pkcs15_dobj_get_value(struct sc_pkcs11_session *session, static int pkcs15_dobj_get_value(struct sc_pkcs11_session *session,
struct pkcs15_data_object *dobj, struct pkcs15_data_object *dobj,
struct sc_pkcs15_data **out_data) struct sc_pkcs15_data **out_data)
{ {
int rv; int rv;
struct pkcs15_fw_data *fw_data = struct pkcs15_fw_data *fw_data =
(struct pkcs15_fw_data *) session->slot->card->fw_data; (struct pkcs15_fw_data *) session->slot->card->fw_data;
struct pkcs15_slot_data *data = slot_data(session->slot->fw_data); struct pkcs15_slot_data *data = slot_data(session->slot->fw_data);
struct sc_card *card = session->slot->card->card; struct sc_card *card = session->slot->card->card;
@ -2158,12 +2154,12 @@ static CK_RV pkcs15_dobj_get_attribute(struct sc_pkcs11_session *session,
break; break;
case CKA_PRIVATE: case CKA_PRIVATE:
check_attribute_buffer(attr, sizeof(CK_BBOOL)); check_attribute_buffer(attr, sizeof(CK_BBOOL));
*(CK_BBOOL*)attr->pValue = *(CK_BBOOL*)attr->pValue =
(dobj->base.p15_object->flags & 0x01) != 0; (dobj->base.p15_object->flags & 0x01) != 0;
break; break;
case CKA_MODIFIABLE: case CKA_MODIFIABLE:
check_attribute_buffer(attr, sizeof(CK_BBOOL)); check_attribute_buffer(attr, sizeof(CK_BBOOL));
*(CK_BBOOL*)attr->pValue = *(CK_BBOOL*)attr->pValue =
(dobj->base.p15_object->flags & 0x02) != 0; (dobj->base.p15_object->flags & 0x02) != 0;
break; break;
case CKA_LABEL: case CKA_LABEL:
@ -2180,7 +2176,7 @@ static CK_RV pkcs15_dobj_get_attribute(struct sc_pkcs11_session *session,
case CKA_ID: case CKA_ID:
check_attribute_buffer(attr, dobj->info->id.len); check_attribute_buffer(attr, dobj->info->id.len);
memcpy(attr->pValue, dobj->info->id.value, dobj->info->id.len); memcpy(attr->pValue, dobj->info->id.value, dobj->info->id.len);
break; break;
#endif #endif
case CKA_OBJECT_ID: case CKA_OBJECT_ID:
{ {
@ -2189,7 +2185,7 @@ static CK_RV pkcs15_dobj_get_attribute(struct sc_pkcs11_session *session,
check_attribute_buffer(attr, len); check_attribute_buffer(attr, len);
memcpy(attr->pValue, dobj->info->app_oid.value, len); memcpy(attr->pValue, dobj->info->app_oid.value, len);
} }
break; break;
case CKA_VALUE: case CKA_VALUE:
{ {
CK_RV rv; CK_RV rv;
@ -2227,7 +2223,6 @@ struct sc_pkcs11_object_ops pkcs15_dobj_ops = {
}; };
/* /*
* get_attribute helpers * get_attribute helpers
*/ */
@ -2535,7 +2530,7 @@ unlock_card(struct pkcs15_fw_data *fw_data)
* need to present these PINs again because some card operations may * need to present these PINs again because some card operations may
* clobber the authentication state (the GPK for instance). */ * clobber the authentication state (the GPK for instance). */
static void static void
add_pins_to_keycache(struct sc_pkcs11_card *p11card, add_pins_to_keycache(struct sc_pkcs11_card *p11card,
struct sc_pkcs11_slot *slot) struct sc_pkcs11_slot *slot)
{ {
#ifdef USE_PKCS15_INIT #ifdef USE_PKCS15_INIT

2
src/pkcs11/misc.c
View File

@ -145,7 +145,7 @@ CK_RV pool_find_and_delete(struct sc_pkcs11_pool *pool, CK_ULONG handle, void **
if (item->prev) item->prev->next = item->next; if (item->prev) item->prev->next = item->next;
if (item->next) item->next->prev = item->prev; if (item->next) item->next->prev = item->prev;
if (pool->head == item) pool->head = item->next; if (pool->head == item) pool->head = item->next;
if (pool->tail == item) pool->tail = item->prev; if (pool->tail == item) pool->tail = item->prev;
*item_ptr = item->item; *item_ptr = item->item;
free(item); free(item);

10
src/pkcs11/pkcs11-global.c
View File

@ -48,11 +48,11 @@ CK_RV C_Initialize(CK_VOID_PTR pReserved)
load_pkcs11_parameters(&sc_pkcs11_conf, context); load_pkcs11_parameters(&sc_pkcs11_conf, context);
first_free_slot = 0; first_free_slot = 0;
pool_initialize(&session_pool, POOL_TYPE_SESSION); pool_initialize(&session_pool, POOL_TYPE_SESSION);
for (i=0; i<SC_PKCS11_MAX_VIRTUAL_SLOTS; i++) for (i=0; i<SC_PKCS11_MAX_VIRTUAL_SLOTS; i++)
slot_initialize(i, &virtual_slots[i]); slot_initialize(i, &virtual_slots[i]);
for (i=0; i<SC_PKCS11_MAX_READERS; i++) for (i=0; i<SC_PKCS11_MAX_READERS; i++)
card_initialize(i); card_initialize(i);
/* Detect any card, but do not flag "insert" events */ /* Detect any card, but do not flag "insert" events */
__card_detect_all(0); __card_detect_all(0);
@ -213,7 +213,7 @@ CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo)
if (now >= card_table[slot->reader].slot_state_expires || now == 0) { if (now >= card_table[slot->reader].slot_state_expires || now == 0) {
/* Update slot status */ /* Update slot status */
rv = card_detect(slot->reader); rv = card_detect(slot->reader);
/* Don't ask again within the next second */ /* Don't ask again within the next second */
card_table[slot->reader].slot_state_expires = now + 1000; card_table[slot->reader].slot_state_expires = now + 1000;
} }
} }
@ -504,7 +504,7 @@ sc_pkcs11_free_lock()
_lock = NULL; _lock = NULL;
/* Now unlock. On SMP machines the synchronization /* Now unlock. On SMP machines the synchronization
* primitives should take care of flushing out * primitives should take care of flushing out
* all changed data to RAM */ * all changed data to RAM */
__sc_pkcs11_unlock(tempLock); __sc_pkcs11_unlock(tempLock);

90
src/pkcs11/pkcs11-object.c
View File

@ -40,7 +40,7 @@ CK_RV C_CreateObject(CK_SESSION_HANDLE hSession, /* the session's handle */
rv = sc_pkcs11_lock(); rv = sc_pkcs11_lock();
if (rv != CKR_OK) if (rv != CKR_OK)
return rv; return rv;
dump_template("C_CreateObject()", pTemplate, ulCount); dump_template("C_CreateObject()", pTemplate, ulCount);
rv = pool_find(&session_pool, hSession, (void**) &session); rv = pool_find(&session_pool, hSession, (void**) &session);
if (rv != CKR_OK) if (rv != CKR_OK)
@ -316,7 +316,7 @@ CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, /* the session's han
&operation->handles[operation->current_handle], &operation->handles[operation->current_handle],
to_return * sizeof(CK_OBJECT_HANDLE)); to_return * sizeof(CK_OBJECT_HANDLE));
operation->current_handle += to_return; operation->current_handle += to_return;
out: sc_pkcs11_unlock(); out: sc_pkcs11_unlock();
return rv; return rv;
@ -361,10 +361,10 @@ CK_RV C_DigestInit(CK_SESSION_HANDLE hSession, /* the session's handle */
rv = pool_find(&session_pool, hSession, (void**) &session); rv = pool_find(&session_pool, hSession, (void**) &session);
if (rv == CKR_OK) if (rv == CKR_OK)
rv = sc_pkcs11_md_init(session, pMechanism); rv = sc_pkcs11_md_init(session, pMechanism);
sc_debug(context, "C_DigestInit returns %d\n", rv); sc_debug(context, "C_DigestInit returns %d\n", rv);
sc_pkcs11_unlock(); sc_pkcs11_unlock();
return rv; return rv;
} }
CK_RV C_Digest(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_Digest(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -391,7 +391,7 @@ CK_RV C_Digest(CK_SESSION_HANDLE hSession, /* the session's handle */
out: sc_debug(context, "C_Digest returns %d\n", rv); out: sc_debug(context, "C_Digest returns %d\n", rv);
sc_pkcs11_unlock(); sc_pkcs11_unlock();
return rv; return rv;
} }
CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -409,15 +409,15 @@ CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */
if (rv == CKR_OK) if (rv == CKR_OK)
rv = sc_pkcs11_md_update(session, pPart, ulPartLen); rv = sc_pkcs11_md_update(session, pPart, ulPartLen);
sc_debug(context, "C_DigestUpdate returns %d\n", rv); sc_debug(context, "C_DigestUpdate returns %d\n", rv);
sc_pkcs11_unlock(); sc_pkcs11_unlock();
return rv; return rv;
} }
CK_RV C_DigestKey(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_DigestKey(CK_SESSION_HANDLE hSession, /* the session's handle */
CK_OBJECT_HANDLE hKey) /* handle of secret key to digest */ CK_OBJECT_HANDLE hKey) /* handle of secret key to digest */
{ {
return CKR_FUNCTION_NOT_SUPPORTED; return CKR_FUNCTION_NOT_SUPPORTED;
} }
CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -435,9 +435,9 @@ CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, /* the session's handle */
if (rv == CKR_OK) if (rv == CKR_OK)
rv = sc_pkcs11_md_final(session, pDigest, pulDigestLen); rv = sc_pkcs11_md_final(session, pDigest, pulDigestLen);
sc_debug(context, "C_DigestFinal returns %d\n", rv); sc_debug(context, "C_DigestFinal returns %d\n", rv);
sc_pkcs11_unlock(); sc_pkcs11_unlock();
return rv; return rv;
} }
CK_RV C_SignInit(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_SignInit(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -465,18 +465,18 @@ CK_RV C_SignInit(CK_SESSION_HANDLE hSession, /* the session's handle */
goto out; goto out;
if (object->ops->sign == NULL_PTR) { if (object->ops->sign == NULL_PTR) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
rv = object->ops->get_attribute(session, object, &sign_attribute); rv = object->ops->get_attribute(session, object, &sign_attribute);
if (rv != CKR_OK || !can_sign) { if (rv != CKR_OK || !can_sign) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
rv = object->ops->get_attribute(session, object, &key_type_attr); rv = object->ops->get_attribute(session, object, &key_type_attr);
if (rv != CKR_OK) { if (rv != CKR_OK) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
@ -485,7 +485,7 @@ CK_RV C_SignInit(CK_SESSION_HANDLE hSession, /* the session's handle */
out: sc_debug(context, "Sign initialization returns %d\n", rv); out: sc_debug(context, "Sign initialization returns %d\n", rv);
sc_pkcs11_unlock(); sc_pkcs11_unlock();
return rv; return rv;
} }
CK_RV C_Sign(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_Sign(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -526,7 +526,7 @@ CK_RV C_Sign(CK_SESSION_HANDLE hSession, /* the session's handle */
out: sc_debug(context, "Signing result was %d\n", rv); out: sc_debug(context, "Signing result was %d\n", rv);
sc_pkcs11_unlock(); sc_pkcs11_unlock();
return rv; return rv;
} }
CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -583,14 +583,14 @@ CK_RV C_SignFinal(CK_SESSION_HANDLE hSession, /* the session's handle */
out: sc_debug(context, "C_SignFinal returns %d\n", rv); out: sc_debug(context, "C_SignFinal returns %d\n", rv);
sc_pkcs11_unlock(); sc_pkcs11_unlock();
return rv; return rv;
} }
CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession, /* the session's handle */
CK_MECHANISM_PTR pMechanism, /* the signature mechanism */ CK_MECHANISM_PTR pMechanism, /* the signature mechanism */
CK_OBJECT_HANDLE hKey) /* handle of the signature key */ CK_OBJECT_HANDLE hKey) /* handle of the signature key */
{ {
CK_BBOOL can_sign; CK_BBOOL can_sign;
CK_KEY_TYPE key_type; CK_KEY_TYPE key_type;
CK_ATTRIBUTE sign_attribute = { CKA_SIGN, &can_sign, sizeof(can_sign) }; CK_ATTRIBUTE sign_attribute = { CKA_SIGN, &can_sign, sizeof(can_sign) };
CK_ATTRIBUTE key_type_attr = { CKA_KEY_TYPE, &key_type, sizeof(key_type) }; CK_ATTRIBUTE key_type_attr = { CKA_KEY_TYPE, &key_type, sizeof(key_type) };
@ -611,30 +611,30 @@ CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession, /* the session's handle */
goto out; goto out;
if (object->ops->sign == NULL_PTR) { if (object->ops->sign == NULL_PTR) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
rv = object->ops->get_attribute(session, object, &sign_attribute); rv = object->ops->get_attribute(session, object, &sign_attribute);
if (rv != CKR_OK || !can_sign) { if (rv != CKR_OK || !can_sign) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
rv = object->ops->get_attribute(session, object, &key_type_attr); rv = object->ops->get_attribute(session, object, &key_type_attr);
if (rv != CKR_OK) { if (rv != CKR_OK) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
/* XXX: need to tell the signature algorithm that we want /* XXX: need to tell the signature algorithm that we want
* to recover the signature */ * to recover the signature */
sc_debug(context, "SignRecover operation initialized\n"); sc_debug(context, "SignRecover operation initialized\n");
rv = sc_pkcs11_sign_init(session, pMechanism, object, key_type); rv = sc_pkcs11_sign_init(session, pMechanism, object, key_type);
out: sc_debug(context, "Sign initialization returns %d\n", rv); out: sc_debug(context, "Sign initialization returns %d\n", rv);
sc_pkcs11_unlock(); sc_pkcs11_unlock();
return rv; return rv;
} }
CK_RV C_SignRecover(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_SignRecover(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -643,14 +643,14 @@ CK_RV C_SignRecover(CK_SESSION_HANDLE hSession, /* the session's handle *
CK_BYTE_PTR pSignature, /* receives the signature */ CK_BYTE_PTR pSignature, /* receives the signature */
CK_ULONG_PTR pulSignatureLen) /* receives byte count of signature */ CK_ULONG_PTR pulSignatureLen) /* receives byte count of signature */
{ {
return CKR_FUNCTION_NOT_SUPPORTED; return CKR_FUNCTION_NOT_SUPPORTED;
} }
CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession, /* the session's handle */
CK_MECHANISM_PTR pMechanism, /* the encryption mechanism */ CK_MECHANISM_PTR pMechanism, /* the encryption mechanism */
CK_OBJECT_HANDLE hKey) /* handle of encryption key */ CK_OBJECT_HANDLE hKey) /* handle of encryption key */
{ {
return CKR_FUNCTION_NOT_SUPPORTED; return CKR_FUNCTION_NOT_SUPPORTED;
} }
CK_RV C_Encrypt(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_Encrypt(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -659,7 +659,7 @@ CK_RV C_Encrypt(CK_SESSION_HANDLE hSession, /* the session's handle *
CK_BYTE_PTR pEncryptedData, /* receives encrypted data */ CK_BYTE_PTR pEncryptedData, /* receives encrypted data */
CK_ULONG_PTR pulEncryptedDataLen) /* receives encrypted byte count */ CK_ULONG_PTR pulEncryptedDataLen) /* receives encrypted byte count */
{ {
return CKR_FUNCTION_NOT_SUPPORTED; return CKR_FUNCTION_NOT_SUPPORTED;
} }
CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -668,14 +668,14 @@ CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, /* the session's han
CK_BYTE_PTR pEncryptedPart, /* receives encrypted data */ CK_BYTE_PTR pEncryptedPart, /* receives encrypted data */
CK_ULONG_PTR pulEncryptedPartLen)/* receives encrypted byte count */ CK_ULONG_PTR pulEncryptedPartLen)/* receives encrypted byte count */
{ {
return CKR_FUNCTION_NOT_SUPPORTED; return CKR_FUNCTION_NOT_SUPPORTED;
} }
CK_RV C_EncryptFinal(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_EncryptFinal(CK_SESSION_HANDLE hSession, /* the session's handle */
CK_BYTE_PTR pLastEncryptedPart, /* receives encrypted last part */ CK_BYTE_PTR pLastEncryptedPart, /* receives encrypted last part */
CK_ULONG_PTR pulLastEncryptedPartLen) /* receives byte count */ CK_ULONG_PTR pulLastEncryptedPartLen) /* receives byte count */
{ {
return CKR_FUNCTION_NOT_SUPPORTED; return CKR_FUNCTION_NOT_SUPPORTED;
} }
CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -703,18 +703,18 @@ CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession, /* the session's handle */
goto out; goto out;
if (object->ops->decrypt == NULL_PTR) { if (object->ops->decrypt == NULL_PTR) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
rv = object->ops->get_attribute(session, object, &decrypt_attribute); rv = object->ops->get_attribute(session, object, &decrypt_attribute);
if (rv != CKR_OK || !can_decrypt) { if (rv != CKR_OK || !can_decrypt) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
rv = object->ops->get_attribute(session, object, &key_type_attr); rv = object->ops->get_attribute(session, object, &key_type_attr);
if (rv != CKR_OK) { if (rv != CKR_OK) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
@ -828,10 +828,10 @@ CK_RV C_GenerateKeyPair(CK_SESSION_HANDLE hSession, /* the
rv = sc_pkcs11_lock(); rv = sc_pkcs11_lock();
if (rv != CKR_OK) if (rv != CKR_OK)
return rv; return rv;
dump_template("C_CreateObject(), PrivKey attrs", pPrivateKeyTemplate, ulPrivateKeyAttributeCount); dump_template("C_CreateObject(), PrivKey attrs", pPrivateKeyTemplate, ulPrivateKeyAttributeCount);
dump_template("C_CreateObject(), PubKey attrs", pPublicKeyTemplate, ulPublicKeyAttributeCount); dump_template("C_CreateObject(), PubKey attrs", pPublicKeyTemplate, ulPublicKeyAttributeCount);
rv = pool_find(&session_pool, hSession, (void**) &session); rv = pool_find(&session_pool, hSession, (void**) &session);
if (rv != CKR_OK) if (rv != CKR_OK)
goto out; goto out;
@ -886,7 +886,7 @@ CK_RV C_UnwrapKey(CK_SESSION_HANDLE hSession, /* the session's handl
goto out; goto out;
if (object->ops->sign == NULL_PTR) { if (object->ops->sign == NULL_PTR) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
@ -978,7 +978,7 @@ CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession, /* the session's handle */
return CKR_FUNCTION_NOT_SUPPORTED; return CKR_FUNCTION_NOT_SUPPORTED;
#else #else
#if 0 #if 0
CK_BBOOL can_verify; CK_BBOOL can_verify;
CK_ATTRIBUTE verify_attribute = { CKA_VERIFY, &can_verify, sizeof(can_verify) }; CK_ATTRIBUTE verify_attribute = { CKA_VERIFY, &can_verify, sizeof(can_verify) };
#endif #endif
CK_KEY_TYPE key_type; CK_KEY_TYPE key_type;
@ -1001,14 +1001,14 @@ CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession, /* the session's handle */
#if 0 #if 0
rv = object->ops->get_attribute(session, object, &verify_attribute); rv = object->ops->get_attribute(session, object, &verify_attribute);
if (rv != CKR_OK || !can_verify) { if (rv != CKR_OK || !can_verify) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }
#endif #endif
rv = object->ops->get_attribute(session, object, &key_type_attr); rv = object->ops->get_attribute(session, object, &key_type_attr);
if (rv != CKR_OK) { if (rv != CKR_OK) {
rv = CKR_KEY_TYPE_INCONSISTENT; rv = CKR_KEY_TYPE_INCONSISTENT;
goto out; goto out;
} }

16
src/pkcs11/pkcs11-session.c
View File

@ -30,7 +30,7 @@ CK_RV C_OpenSession(CK_SLOT_ID slotID, /* the slot's ID */
CK_SESSION_HANDLE_PTR phSession) /* receives new session handle */ CK_SESSION_HANDLE_PTR phSession) /* receives new session handle */
{ {
struct sc_pkcs11_slot *slot; struct sc_pkcs11_slot *slot;
struct sc_pkcs11_session *session; struct sc_pkcs11_session *session;
int rv; int rv;
rv = sc_pkcs11_lock(); rv = sc_pkcs11_lock();
@ -49,7 +49,7 @@ CK_RV C_OpenSession(CK_SLOT_ID slotID, /* the slot's ID */
goto out; goto out;
} }
rv = slot_get_token(slotID, &slot); rv = slot_get_token(slotID, &slot);
if (rv != CKR_OK) if (rv != CKR_OK)
goto out; goto out;
@ -85,7 +85,7 @@ out: sc_pkcs11_unlock();
static CK_RV sc_pkcs11_close_session(CK_SESSION_HANDLE hSession) static CK_RV sc_pkcs11_close_session(CK_SESSION_HANDLE hSession)
{ {
struct sc_pkcs11_slot *slot; struct sc_pkcs11_slot *slot;
struct sc_pkcs11_session *session; struct sc_pkcs11_session *session;
int rv; int rv;
rv = pool_find_and_delete(&session_pool, hSession, (void**) &session); rv = pool_find_and_delete(&session_pool, hSession, (void**) &session);
@ -178,8 +178,8 @@ CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession, /* the session's handle */
sc_debug(context, "C_GetSessionInfo(slot %d).\n", session->slot->id); sc_debug(context, "C_GetSessionInfo(slot %d).\n", session->slot->id);
pInfo->slotID = session->slot->id; pInfo->slotID = session->slot->id;
pInfo->flags = session->flags; pInfo->flags = session->flags;
pInfo->ulDeviceError = 0; pInfo->ulDeviceError = 0;
slot = session->slot; slot = session->slot;
if (slot->login_user == CKU_SO) { if (slot->login_user == CKU_SO) {
@ -211,7 +211,7 @@ CK_RV C_SetOperationState(CK_SESSION_HANDLE hSession, /* the session'
CK_OBJECT_HANDLE hEncryptionKey, /* handle of en/decryption key */ CK_OBJECT_HANDLE hEncryptionKey, /* handle of en/decryption key */
CK_OBJECT_HANDLE hAuthenticationKey) /* handle of sign/verify key */ CK_OBJECT_HANDLE hAuthenticationKey) /* handle of sign/verify key */
{ {
return CKR_FUNCTION_NOT_SUPPORTED; return CKR_FUNCTION_NOT_SUPPORTED;
} }
CK_RV C_Login(CK_SESSION_HANDLE hSession, /* the session's handle */ CK_RV C_Login(CK_SESSION_HANDLE hSession, /* the session's handle */
@ -228,7 +228,7 @@ CK_RV C_Login(CK_SESSION_HANDLE hSession, /* the session's handle */
return rv; return rv;
if (userType != CKU_USER && userType != CKU_SO) { if (userType != CKU_USER && userType != CKU_SO) {
rv = CKR_USER_TYPE_INVALID; rv = CKR_USER_TYPE_INVALID;
goto out; goto out;
} }
@ -246,7 +246,7 @@ CK_RV C_Login(CK_SESSION_HANDLE hSession, /* the session's handle */
} }
if (slot->login_user >= 0) { if (slot->login_user >= 0) {
rv = CKR_USER_ALREADY_LOGGED_IN; rv = CKR_USER_ALREADY_LOGGED_IN;
goto out; goto out;
} }

52
src/pkcs11/sc-pkcs11.h
View File

@ -61,9 +61,9 @@ struct sc_pkcs11_card;
/* Object Pool */ /* Object Pool */
struct sc_pkcs11_pool_item { struct sc_pkcs11_pool_item {
int handle; int handle;
void *item; void *item;
struct sc_pkcs11_pool_item *next; struct sc_pkcs11_pool_item *next;
struct sc_pkcs11_pool_item *prev; struct sc_pkcs11_pool_item *prev;
}; };
enum { enum {
@ -73,10 +73,10 @@ enum {
struct sc_pkcs11_pool { struct sc_pkcs11_pool {
int type; int type;
int next_free_handle; int next_free_handle;
int num_items; int num_items;
struct sc_pkcs11_pool_item *head; struct sc_pkcs11_pool_item *head;
struct sc_pkcs11_pool_item *tail; struct sc_pkcs11_pool_item *tail;
}; };
struct sc_pkcs11_config { struct sc_pkcs11_config {
@ -92,16 +92,16 @@ struct sc_pkcs11_config {
*/ */
struct sc_pkcs11_object_ops { struct sc_pkcs11_object_ops {
/* Generic operations */ /* Generic operations */
void (*release)(void *); void (*release)(void *);
/* Management methods */ /* Management methods */
CK_RV (*set_attribute)(struct sc_pkcs11_session *, void *, CK_ATTRIBUTE_PTR); CK_RV (*set_attribute)(struct sc_pkcs11_session *, void *, CK_ATTRIBUTE_PTR);
CK_RV (*get_attribute)(struct sc_pkcs11_session *, void *, CK_ATTRIBUTE_PTR); CK_RV (*get_attribute)(struct sc_pkcs11_session *, void *, CK_ATTRIBUTE_PTR);
int (*cmp_attribute)(struct sc_pkcs11_session *, void *, CK_ATTRIBUTE_PTR); int (*cmp_attribute)(struct sc_pkcs11_session *, void *, CK_ATTRIBUTE_PTR);
CK_RV (*destroy_object)(struct sc_pkcs11_session *, void *); CK_RV (*destroy_object)(struct sc_pkcs11_session *, void *);
CK_RV (*get_size)(struct sc_pkcs11_session *, void *); CK_RV (*get_size)(struct sc_pkcs11_session *, void *);
/* Cryptographic methods */ /* Cryptographic methods */
CK_RV (*sign)(struct sc_pkcs11_session *, void *, CK_RV (*sign)(struct sc_pkcs11_session *, void *,
@ -118,12 +118,12 @@ struct sc_pkcs11_object_ops {
CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen,
CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen); CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen);
/* Others to be added when implemented */ /* Others to be added when implemented */
}; };
struct sc_pkcs11_object { struct sc_pkcs11_object {
int flags; int flags;
struct sc_pkcs11_object_ops *ops; struct sc_pkcs11_object_ops *ops;
}; };
#define SC_PKCS11_OBJECT_SEEN 0x0001 #define SC_PKCS11_OBJECT_SEEN 0x0001
@ -136,20 +136,20 @@ struct sc_pkcs11_object {
*/ */
struct sc_pkcs11_framework_ops { struct sc_pkcs11_framework_ops {
/* Detect and bind card to framework */ /* Detect and bind card to framework */
CK_RV (*bind)(struct sc_pkcs11_card *); CK_RV (*bind)(struct sc_pkcs11_card *);
/* Unbind and release allocated resources */ /* Unbind and release allocated resources */
CK_RV (*unbind)(struct sc_pkcs11_card *); CK_RV (*unbind)(struct sc_pkcs11_card *);
/* Create tokens to virtual slots and /* Create tokens to virtual slots and
* objects in tokens; called after bind */ * objects in tokens; called after bind */
CK_RV (*create_tokens)(struct sc_pkcs11_card *); CK_RV (*create_tokens)(struct sc_pkcs11_card *);
CK_RV (*release_token)(struct sc_pkcs11_card *, void *); CK_RV (*release_token)(struct sc_pkcs11_card *, void *);
/* Login and logout */ /* Login and logout */
CK_RV (*login)(struct sc_pkcs11_card *, void *, CK_RV (*login)(struct sc_pkcs11_card *, void *,
CK_USER_TYPE, CK_CHAR_PTR, CK_ULONG); CK_USER_TYPE, CK_CHAR_PTR, CK_ULONG);
CK_RV (*logout)(struct sc_pkcs11_card *, void *); CK_RV (*logout)(struct sc_pkcs11_card *, void *);
CK_RV (*change_pin)(struct sc_pkcs11_card *, void *, CK_RV (*change_pin)(struct sc_pkcs11_card *, void *,
CK_CHAR_PTR, CK_ULONG, CK_CHAR_PTR, CK_ULONG,
CK_CHAR_PTR, CK_ULONG); CK_CHAR_PTR, CK_ULONG);
@ -157,7 +157,7 @@ struct sc_pkcs11_framework_ops {
/* /*
* In future: functions to create new objects * In future: functions to create new objects
* (ie. certificates, private keys) * (ie. certificates, private keys)
*/ */
CK_RV (*init_token)(struct sc_pkcs11_card *, void *, CK_RV (*init_token)(struct sc_pkcs11_card *, void *,
CK_UTF8CHAR_PTR, CK_ULONG, CK_UTF8CHAR_PTR, CK_ULONG,
CK_UTF8CHAR_PTR); CK_UTF8CHAR_PTR);
@ -182,9 +182,9 @@ struct sc_pkcs11_framework_ops {
*/ */
struct sc_pkcs11_card { struct sc_pkcs11_card {
int reader; int reader;
struct sc_card *card; struct sc_card *card;
struct sc_pkcs11_framework_ops *framework; struct sc_pkcs11_framework_ops *framework;
void *fw_data; void *fw_data;
sc_timestamp_t slot_state_expires; sc_timestamp_t slot_state_expires;
@ -200,17 +200,17 @@ struct sc_pkcs11_card {
struct sc_pkcs11_slot { struct sc_pkcs11_slot {
int id; int id;
int login_user; int login_user;
/* Slot specific information (information about reader) */ /* Slot specific information (information about reader) */
CK_SLOT_INFO slot_info; CK_SLOT_INFO slot_info;
/* Token specific information (information about card) */ /* Token specific information (information about card) */
CK_TOKEN_INFO token_info; CK_TOKEN_INFO token_info;
/* Reader to which card is allocated (same as card->reader /* Reader to which card is allocated (same as card->reader
* if there's a card present) */ * if there's a card present) */
int reader; int reader;
/* The card associated with this slot */ /* The card associated with this slot */
struct sc_pkcs11_card *card; struct sc_pkcs11_card *card;
/* Card events SC_EVENT_CARD_{INSERTED,REMOVED} */ /* Card events SC_EVENT_CARD_{INSERTED,REMOVED} */
int events; int events;
@ -293,8 +293,8 @@ struct sc_pkcs11_operation {
#define SC_PKCS11_FIND_MAX_HANDLES 32 #define SC_PKCS11_FIND_MAX_HANDLES 32
struct sc_pkcs11_find_operation { struct sc_pkcs11_find_operation {
struct sc_pkcs11_operation operation; struct sc_pkcs11_operation operation;
int num_handles, current_handle; int num_handles, current_handle;
CK_OBJECT_HANDLE handles[SC_PKCS11_FIND_MAX_HANDLES]; CK_OBJECT_HANDLE handles[SC_PKCS11_FIND_MAX_HANDLES];
}; };
/* /*
@ -304,10 +304,10 @@ struct sc_pkcs11_find_operation {
struct sc_pkcs11_session { struct sc_pkcs11_session {
/* Session to this slot */ /* Session to this slot */
struct sc_pkcs11_slot *slot; struct sc_pkcs11_slot *slot;
CK_FLAGS flags; CK_FLAGS flags;
/* Notifications */ /* Notifications */
CK_NOTIFY notify_callback; CK_NOTIFY notify_callback;
CK_VOID_PTR notify_data; CK_VOID_PTR notify_data;
/* Active operations - one per type */ /* Active operations - one per type */
struct sc_pkcs11_operation *operation[SC_PKCS11_OPERATION_MAX]; struct sc_pkcs11_operation *operation[SC_PKCS11_OPERATION_MAX];
}; };
@ -353,7 +353,7 @@ CK_RV pool_find(struct sc_pkcs11_pool *, CK_ULONG, void **);
CK_RV pool_find_and_delete(struct sc_pkcs11_pool *, CK_ULONG, void **); CK_RV pool_find_and_delete(struct sc_pkcs11_pool *, CK_ULONG, void **);
/* Session manipulation */ /* Session manipulation */
CK_RV session_start_operation(struct sc_pkcs11_session *, CK_RV session_start_operation(struct sc_pkcs11_session *,
int, sc_pkcs11_mechanism_type_t *, int, sc_pkcs11_mechanism_type_t *,
struct sc_pkcs11_operation **); struct sc_pkcs11_operation **);
CK_RV session_get_operation(struct sc_pkcs11_session *, int, CK_RV session_get_operation(struct sc_pkcs11_session *, int,

6
src/pkcs11/slot.c
View File

@ -22,11 +22,11 @@
#include "sc-pkcs11.h" #include "sc-pkcs11.h"
static struct sc_pkcs11_framework_ops *frameworks[] = { static struct sc_pkcs11_framework_ops *frameworks[] = {
&framework_pkcs15, &framework_pkcs15,
#ifdef USE_PKCS15_INIT #ifdef USE_PKCS15_INIT
/* This should be the last framework, because it /* This should be the last framework, because it
* will assume the card is blank and try to initialize it */ * will assume the card is blank and try to initialize it */
&framework_pkcs15init, &framework_pkcs15init,
#endif #endif
NULL NULL
}; };
@ -241,7 +241,7 @@ CK_RV slot_allocate(struct sc_pkcs11_slot **slot, struct sc_pkcs11_card *card)
CK_RV slot_get_slot(int id, struct sc_pkcs11_slot **slot) CK_RV slot_get_slot(int id, struct sc_pkcs11_slot **slot)
{ {
if (context == NULL) if (context == NULL)
return CKR_CRYPTOKI_NOT_INITIALIZED; return CKR_CRYPTOKI_NOT_INITIALIZED;
if (id < 0 || id >= SC_PKCS11_MAX_VIRTUAL_SLOTS) if (id < 0 || id >= SC_PKCS11_MAX_VIRTUAL_SLOTS)
return CKR_SLOT_ID_INVALID; return CKR_SLOT_ID_INVALID;

8
src/sslengines/engine_opensc.c
View File

@ -79,7 +79,7 @@ int opensc_init(void)
if (r) if (r)
goto err; goto err;
return 1; return 1;
err: err:
/* need to do engine stuff? */ /* need to do engine stuff? */
fprintf(stderr, "error: %d", r); fprintf(stderr, "error: %d", r);
opensc_finish(); opensc_finish();
@ -178,7 +178,7 @@ int sc_prkey_op_init(const RSA * rsa, struct sc_pkcs15_object **key_obj_out,
} }
*key_obj_out = key_obj; *key_obj_out = key_obj;
return 0; return 0;
err: err:
return -1; return -1;
} }
@ -352,7 +352,7 @@ sc_private_decrypt(int flen, const unsigned char * from, unsigned char * to,
goto err; goto err;
} }
return r; return r;
err: err:
return -1; return -1;
} }
@ -386,7 +386,7 @@ sc_sign(int type, const unsigned char * m, unsigned int m_len,
} }
*siglen = r; *siglen = r;
return 1; return 1;
err: err:
return 0; return 0;
} }

99
src/tools/opensc-explorer.c
View File

@ -98,7 +98,7 @@ ambiguous_match(struct command *table, const char *cmd)
int matches = 0; int matches = 0;
for (; table->name; table++) { for (; table->name; table++) {
if (strncasecmp(cmd, table->name, strlen(cmd)) == 0) { if (strncasecmp(cmd, table->name, strlen(cmd)) == 0) {
last_match = table; last_match = table;
matches++; matches++;
} }
@ -154,12 +154,12 @@ static void print_file(const struct sc_file *file)
if (file->type == SC_FILE_TYPE_DF) if (file->type == SC_FILE_TYPE_DF)
printf("["); printf("[");
else else
printf(" "); printf(" ");
printf("%02X%02X", file->id >> 8, file->id & 0xFF); printf("%02X%02X", file->id >> 8, file->id & 0xFF);
if (file->type == SC_FILE_TYPE_DF) if (file->type == SC_FILE_TYPE_DF)
printf("]"); printf("]");
else else
printf(" "); printf(" ");
switch (file->type) { switch (file->type) {
case SC_FILE_TYPE_WORKING_EF: case SC_FILE_TYPE_WORKING_EF:
st = "wEF"; st = "wEF";
@ -175,12 +175,12 @@ static void print_file(const struct sc_file *file)
break; break;
} }
printf("\t%4s", st); printf("\t%4s", st);
printf(" %5d", file->size); printf(" %5d", file->size);
if (file->namelen) { if (file->namelen) {
printf("\tName: "); printf("\tName: ");
print_binary(stdout, file->name, file->namelen); print_binary(stdout, file->name, file->namelen);
} }
printf("\n"); printf("\n");
return; return;
} }
@ -189,15 +189,15 @@ static int do_ls(int argc, char **argv)
u8 buf[256], *cur = buf; u8 buf[256], *cur = buf;
int r, count; int r, count;
if (argc) if (argc)
goto usage; goto usage;
r = sc_list_files(card, buf, sizeof(buf)); r = sc_list_files(card, buf, sizeof(buf));
if (r < 0) { if (r < 0) {
check_ret(r, SC_AC_OP_LIST_FILES, "unable to receive file listing", current_file); check_ret(r, SC_AC_OP_LIST_FILES, "unable to receive file listing", current_file);
return -1; return -1;
} }
count = r; count = r;
printf("FileID\tType Size\n"); printf("FileID\tType Size\n");
while (count >= 2) { while (count >= 2) {
struct sc_path path; struct sc_path path;
struct sc_file *file = NULL; struct sc_file *file = NULL;
@ -210,17 +210,17 @@ static int do_ls(int argc, char **argv)
return -1; return -1;
} }
file->id = (cur[0] << 8) | cur[1]; file->id = (cur[0] << 8) | cur[1];
cur += 2; cur += 2;
count -= 2; count -= 2;
print_file(file); print_file(file);
sc_file_free(file); sc_file_free(file);
r = sc_select_file(card, &current_path, NULL); r = sc_select_file(card, &current_path, NULL);
if (r) { if (r) {
printf("unable to select parent DF: %s\n", sc_strerror(r)); printf("unable to select parent DF: %s\n", sc_strerror(r));
die(1); die(1);
} }
} }
return 0; return 0;
usage: usage:
puts("Usage: ls"); puts("Usage: ls");
return -1; return -1;
@ -232,14 +232,14 @@ static int do_cd(int argc, char **argv)
struct sc_file *file; struct sc_file *file;
int r; int r;
if (argc != 1) if (argc != 1)
goto usage; goto usage;
if (strcmp(argv[0], "..") == 0) { if (strcmp(argv[0], "..") == 0) {
if (current_path.len < 4) { if (current_path.len < 4) {
printf("unable to go up, already in MF.\n"); printf("unable to go up, already in MF.\n");
return -1; return -1;
} }
path = current_path; path = current_path;
path.len -= 2; path.len -= 2;
r = sc_select_file(card, &path, &file); r = sc_select_file(card, &path, &file);
if (r) { if (r) {
@ -252,7 +252,7 @@ static int do_cd(int argc, char **argv)
return 0; return 0;
} }
if (arg_to_path(argv[0], &path, 0) != 0) if (arg_to_path(argv[0], &path, 0) != 0)
goto usage; goto usage;
r = sc_select_file(card, &path, &file); r = sc_select_file(card, &path, &file);
if (r) { if (r) {
@ -330,18 +330,18 @@ static int do_cat(int argc, char **argv)
{ {
int r, err = 0; int r, err = 0;
struct sc_path path; struct sc_path path;
struct sc_file *file; struct sc_file *file;
int not_current = 1; int not_current = 1;
if (argc > 1) if (argc > 1)
goto usage; goto usage;
if (!argc) { if (!argc) {
path = current_path; path = current_path;
file = current_file; file = current_file;
not_current = 0; not_current = 0;
} else { } else {
if (arg_to_path(argv[0], &path, 0) != 0) if (arg_to_path(argv[0], &path, 0) != 0)
goto usage; goto usage;
r = sc_select_file(card, &path, &file); r = sc_select_file(card, &path, &file);
if (r) { if (r) {
@ -366,10 +366,10 @@ static int do_cat(int argc, char **argv)
die(1); die(1);
} }
} }
return -err; return -err;
usage: usage:
puts("Usage: cat [file_id]"); puts("Usage: cat [file_id]");
return -1; return -1;
} }
static int do_info(int argc, char **argv) static int do_info(int argc, char **argv)
@ -386,15 +386,14 @@ static int do_info(int argc, char **argv)
not_current = 0; not_current = 0;
} else if (argc == 1) { } else if (argc == 1) {
if (arg_to_path(argv[0], &path, 0) != 0) if (arg_to_path(argv[0], &path, 0) != 0)
goto usage; goto usage;
r = sc_select_file(card, &path, &file); r = sc_select_file(card, &path, &file);
if (r) { if (r) {
printf("unable to select file: %s\n", sc_strerror(r)); printf("unable to select file: %s\n", sc_strerror(r));
return -1; return -1;
} }
} } else
else goto usage;
goto usage;
switch (file->type) { switch (file->type) {
case SC_FILE_TYPE_WORKING_EF: case SC_FILE_TYPE_WORKING_EF:
@ -412,7 +411,7 @@ static int do_info(int argc, char **argv)
printf("%-15s", "File path:"); printf("%-15s", "File path:");
for (i = 0; i < path.len; i++) { for (i = 0; i < path.len; i++) {
for (i = 0; i < path.len; i++) { for (i = 0; i < path.len; i++) {
if ((i & 1) == 0 && i) if ((i & 1) == 0 && i)
printf("/"); printf("/");
printf("%02X", path.value[i]); printf("%02X", path.value[i]);
} }
@ -436,11 +435,11 @@ static int do_info(int argc, char **argv)
printf("%-25s%s\n", buf, acl_to_str(sc_file_get_acl_entry(file, i))); printf("%-25s%s\n", buf, acl_to_str(sc_file_get_acl_entry(file, i)));
} }
} else { } else {
const char *structs[] = { const char *structs[] = {
"Unknown", "Transparent", "Linear fixed", "Unknown", "Transparent", "Linear fixed",
"Linear fixed, SIMPLE-TLV", "Linear variable", "Linear fixed, SIMPLE-TLV", "Linear variable",
"Linear variable TLV", "Cyclic, SIMPLE-TLV", "Linear variable TLV", "Cyclic, SIMPLE-TLV",
}; };
const char *ops[] = { const char *ops[] = {
"READ", "UPDATE", "WRITE", "ERASE", "REHABILITATE", "READ", "UPDATE", "WRITE", "ERASE", "REHABILITATE",
"INVALIDATE", "LIST_FILES", "CRYPTO", "INVALIDATE", "LIST_FILES", "CRYPTO",
@ -476,9 +475,9 @@ static int do_info(int argc, char **argv)
} }
return 0; return 0;
usage: usage:
puts("Usage: info [file_id]"); puts("Usage: info [file_id]");
return -1; return -1;
} }
static int create_file(struct sc_file *file) static int create_file(struct sc_file *file)
@ -507,8 +506,8 @@ static int do_create(int argc, char **argv)
unsigned int size; unsigned int size;
int r, op; int r, op;
if (argc != 2) if (argc != 2)
goto usage; goto usage;
if (arg_to_path(argv[0], &path, 1) != 0) if (arg_to_path(argv[0], &path, 1) != 0)
goto usage; goto usage;
/* %z isn't supported everywhere */ /* %z isn't supported everywhere */
@ -538,8 +537,8 @@ static int do_mkdir(int argc, char **argv)
unsigned int size; unsigned int size;
int r, op; int r, op;
if (argc != 2) if (argc != 2)
goto usage; goto usage;
if (arg_to_path(argv[0], &path, 1) != 0) if (arg_to_path(argv[0], &path, 1) != 0)
goto usage; goto usage;
if (sscanf(argv[1], "%d", &size) != 1) if (sscanf(argv[1], "%d", &size) != 1)
@ -565,8 +564,8 @@ static int do_delete(int argc, char **argv)
struct sc_path path; struct sc_path path;
int r; int r;
if (argc != 1) if (argc != 1)
goto usage; goto usage;
if (arg_to_path(argv[0], &path, 1) != 0) if (arg_to_path(argv[0], &path, 1) != 0)
goto usage; goto usage;
if (path.len != 2) if (path.len != 2)
@ -597,12 +596,12 @@ static int do_verify(int argc, char **argv)
}; };
int r, tries_left = -1; int r, tries_left = -1;
u8 buf[30]; u8 buf[30];
const char *s; const char *s;
size_t buflen = sizeof(buf), i; size_t buflen = sizeof(buf), i;
struct sc_pin_cmd_data data; struct sc_pin_cmd_data data;
if (argc < 1 || argc > 2) if (argc < 1 || argc > 2)
goto usage; goto usage;
memset(&data, 0, sizeof(data)); memset(&data, 0, sizeof(data));
data.cmd = SC_PIN_CMD_VERIFY; data.cmd = SC_PIN_CMD_VERIFY;
@ -613,7 +612,7 @@ static int do_verify(int argc, char **argv)
data.pin_type = typeNames[i].type; data.pin_type = typeNames[i].type;
break; break;
} }
} }
if (data.pin_type == SC_AC_NONE) { if (data.pin_type == SC_AC_NONE) {
printf("Invalid type.\n"); printf("Invalid type.\n");
goto usage; goto usage;
@ -623,21 +622,21 @@ static int do_verify(int argc, char **argv)
goto usage; goto usage;
} }
if (argc < 2) { if (argc < 2) {
if (!(card->reader->slot[0].capabilities & SC_SLOT_CAP_PIN_PAD)) { if (!(card->reader->slot[0].capabilities & SC_SLOT_CAP_PIN_PAD)) {
printf("Card reader or driver doesn't support PIN PAD\n"); printf("Card reader or driver doesn't support PIN PAD\n");
return -1; return -1;
} }
printf("Please enter PIN on the reader's pin pad.\n"); printf("Please enter PIN on the reader's pin pad.\n");
data.pin1.prompt = "Please enter PIN"; data.pin1.prompt = "Please enter PIN";
data.flags |= SC_PIN_CMD_USE_PINPAD; data.flags |= SC_PIN_CMD_USE_PINPAD;
} else if (argv[1][0] == '"') { } else if (argv[1][0] == '"') {
for (s=argv[1]+1, i=0; i < sizeof(buf) && *s && *s != '"';i++) for (s=argv[1]+1, i=0; i < sizeof(buf) && *s && *s != '"';i++)
buf[i] = *s++; buf[i] = *s++;
data.pin1.data = buf; data.pin1.data = buf;
data.pin1.len = i; data.pin1.len = i;
} else { } else {
r = sc_hex_to_bin(argv[1], buf, &buflen); r = sc_hex_to_bin(argv[1], buf, &buflen);
if (0 != r) { if (0 != r) {
printf("Invalid key value.\n"); printf("Invalid key value.\n");
goto usage; goto usage;
@ -711,7 +710,7 @@ static int do_change(int argc, char **argv)
if (argv[0][0] == '"') { if (argv[0][0] == '"') {
for (s = argv[0] + 1, i = 0; for (s = argv[0] + 1, i = 0;
i < sizeof(newpin) && *s && *s != '"'; i++) i < sizeof(newpin) && *s && *s != '"'; i++)
newpin[i] = *s++; newpin[i] = *s++;
newpinlen = i; newpinlen = i;
} else if (sc_hex_to_bin(argv[0], newpin, &newpinlen) != 0) { } else if (sc_hex_to_bin(argv[0], newpin, &newpinlen) != 0) {
@ -782,7 +781,7 @@ static int do_unblock(int argc, char **argv)
if (argv[0][0] == '"') { if (argv[0][0] == '"') {
for (s = argv[0] + 1, i = 0; for (s = argv[0] + 1, i = 0;
i < sizeof(newpin) && *s && *s != '"'; i++) i < sizeof(newpin) && *s && *s != '"'; i++)
newpin[i] = *s++; newpin[i] = *s++;
newpinlen = i; newpinlen = i;
} else if (sc_hex_to_bin(argv[0], newpin, &newpinlen) != 0) { } else if (sc_hex_to_bin(argv[0], newpin, &newpinlen) != 0) {

21
src/tools/pkcs11-tool.c
View File

@ -219,8 +219,8 @@ main(int argc, char * const argv[])
CK_RV rv; CK_RV rv;
while (1) { while (1) {
c = getopt_long(argc, argv, "ILMOa:d:e:hi:klm:o:p:scvty:w:z:r", c = getopt_long(argc, argv, "ILMOa:d:e:hi:klm:o:p:scvty:w:z:r",
options, &long_optind); options, &long_optind);
if (c == -1) if (c == -1)
break; break;
switch (c) { switch (c) {
@ -1043,10 +1043,10 @@ find_object(CK_SESSION_HANDLE sess, CK_OBJECT_CLASS cls,
attrs[0].ulValueLen = sizeof(cls); attrs[0].ulValueLen = sizeof(cls);
nattrs++; nattrs++;
if (id) { if (id) {
attrs[nattrs].type = CKA_ID; attrs[nattrs].type = CKA_ID;
attrs[nattrs].pValue = (void *) id; attrs[nattrs].pValue = (void *) id;
attrs[nattrs].ulValueLen = id_len; attrs[nattrs].ulValueLen = id_len;
nattrs++; nattrs++;
} }
rv = p11->C_FindObjectsInit(sess, attrs, nattrs); rv = p11->C_FindObjectsInit(sess, attrs, nattrs);
@ -1370,12 +1370,11 @@ show_dobj(CK_SESSION_HANDLE sess, CK_OBJECT_HANDLE obj)
} }
printf(" flags: "); printf(" flags: ");
if (getMODIFIABLE(sess, obj)) if (getMODIFIABLE(sess, obj))
printf(" modifiable"); printf(" modifiable");
if (getPRIVATE(sess, obj)) if (getPRIVATE(sess, obj))
printf(" private"); printf(" private");
printf ("\n"); printf ("\n");
} }
void void
@ -2065,7 +2064,7 @@ sign_verify(CK_SLOT_ID slot, CK_SESSION_HANDLE session, CK_OBJECT_HANDLE priv_ke
CK_ULONG signat_len; CK_ULONG signat_len;
int j, errors = 0; int j, errors = 0;
memcpy(buf, "\x00\x01\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00", 11); memcpy(buf, "\x00\x01\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00", 11);
for (j = 0, mech_type = mech_types; *mech_type != 0xffffff; mech_type++, j++) { for (j = 0, mech_type = mech_types; *mech_type != 0xffffff; mech_type++, j++) {
CK_MECHANISM mech = {*mech_type, NULL, 0}; CK_MECHANISM mech = {*mech_type, NULL, 0};
@ -2863,7 +2862,7 @@ int hex_to_bin(const char *in, unsigned char *out, size_t *outlen)
return 1; return 1;
} }
left = *outlen; left = *outlen;
while (*in != '\0') { while (*in != '\0') {
int byte = 0, nybbles = 2; int byte = 0, nybbles = 2;

64
src/tools/pkcs15-tool.c
View File

@ -113,7 +113,7 @@ struct sc_pkcs15_card *p15card = NULL;
static void print_cert_info(const struct sc_pkcs15_object *obj) static void print_cert_info(const struct sc_pkcs15_object *obj)
{ {
unsigned int i; unsigned int i;
struct sc_pkcs15_cert_info *cert = (struct sc_pkcs15_cert_info *) obj->data; struct sc_pkcs15_cert_info *cert = (struct sc_pkcs15_cert_info *) obj->data;
printf("X.509 Certificate [%s]\n", obj->label); printf("X.509 Certificate [%s]\n", obj->label);
printf("\tFlags : %d\n", obj->flags); printf("\tFlags : %d\n", obj->flags);
@ -129,7 +129,7 @@ static void print_cert_info(const struct sc_pkcs15_object *obj)
static int list_certificates(void) static int list_certificates(void)
{ {
int r, i; int r, i;
struct sc_pkcs15_object *objs[32]; struct sc_pkcs15_object *objs[32];
r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_CERT_X509, objs, 32); r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_CERT_X509, objs, 32);
if (r < 0) { if (r < 0) {
@ -362,7 +362,7 @@ static int list_data_objects(void)
static void print_prkey_info(const struct sc_pkcs15_object *obj) static void print_prkey_info(const struct sc_pkcs15_object *obj)
{ {
unsigned int i; unsigned int i;
struct sc_pkcs15_prkey_info *prkey = (struct sc_pkcs15_prkey_info *) obj->data; struct sc_pkcs15_prkey_info *prkey = (struct sc_pkcs15_prkey_info *) obj->data;
const char *usages[] = { const char *usages[] = {
"encrypt", "decrypt", "sign", "signRecover", "encrypt", "decrypt", "sign", "signRecover",
"wrap", "unwrap", "verify", "verifyRecover", "wrap", "unwrap", "verify", "verifyRecover",
@ -378,17 +378,17 @@ static void print_prkey_info(const struct sc_pkcs15_object *obj)
printf("Private RSA Key [%s]\n", obj->label); printf("Private RSA Key [%s]\n", obj->label);
printf("\tCom. Flags : %X\n", obj->flags); printf("\tCom. Flags : %X\n", obj->flags);
printf("\tUsage : [0x%X]", prkey->usage); printf("\tUsage : [0x%X]", prkey->usage);
for (i = 0; i < usage_count; i++) for (i = 0; i < usage_count; i++)
if (prkey->usage & (1 << i)) { if (prkey->usage & (1 << i)) {
printf(", %s", usages[i]); printf(", %s", usages[i]);
} }
printf("\n"); printf("\n");
printf("\tAccess Flags: [0x%X]", prkey->access_flags); printf("\tAccess Flags: [0x%X]", prkey->access_flags);
for (i = 0; i < af_count; i++) for (i = 0; i < af_count; i++)
if (prkey->access_flags & (1 << i)) { if (prkey->access_flags & (1 << i)) {
printf(", %s", access_flags[i]); printf(", %s", access_flags[i]);
} }
printf("\n"); printf("\n");
printf("\tModLength : %d\n", prkey->modulus_length); printf("\tModLength : %d\n", prkey->modulus_length);
printf("\tKey ref : %d\n", prkey->key_reference); printf("\tKey ref : %d\n", prkey->key_reference);
printf("\tNative : %s\n", prkey->native ? "yes" : "no"); printf("\tNative : %s\n", prkey->native ? "yes" : "no");
@ -423,7 +423,7 @@ static int list_private_keys(void)
static void print_pubkey_info(const struct sc_pkcs15_object *obj) static void print_pubkey_info(const struct sc_pkcs15_object *obj)
{ {
unsigned int i; unsigned int i;
const struct sc_pkcs15_pubkey_info *pubkey = (const struct sc_pkcs15_pubkey_info *) obj->data; const struct sc_pkcs15_pubkey_info *pubkey = (const struct sc_pkcs15_pubkey_info *) obj->data;
const char *usages[] = { const char *usages[] = {
"encrypt", "decrypt", "sign", "signRecover", "encrypt", "decrypt", "sign", "signRecover",
"wrap", "unwrap", "verify", "verifyRecover", "wrap", "unwrap", "verify", "verifyRecover",
@ -439,17 +439,17 @@ static void print_pubkey_info(const struct sc_pkcs15_object *obj)
printf("Public RSA Key [%s]\n", obj->label); printf("Public RSA Key [%s]\n", obj->label);
printf("\tCom. Flags : %X\n", obj->flags); printf("\tCom. Flags : %X\n", obj->flags);
printf("\tUsage : [0x%X]", pubkey->usage); printf("\tUsage : [0x%X]", pubkey->usage);
for (i = 0; i < usage_count; i++) for (i = 0; i < usage_count; i++)
if (pubkey->usage & (1 << i)) { if (pubkey->usage & (1 << i)) {
printf(", %s", usages[i]); printf(", %s", usages[i]);
} }
printf("\n"); printf("\n");
printf("\tAccess Flags: [0x%X]", pubkey->access_flags); printf("\tAccess Flags: [0x%X]", pubkey->access_flags);
for (i = 0; i < af_count; i++) for (i = 0; i < af_count; i++)
if (pubkey->access_flags & (1 << i)) { if (pubkey->access_flags & (1 << i)) {
printf(", %s", access_flags[i]); printf(", %s", access_flags[i]);
} }
printf("\n"); printf("\n");
printf("\tModLength : %d\n", pubkey->modulus_length); printf("\tModLength : %d\n", pubkey->modulus_length);
printf("\tKey ref : %d\n", pubkey->key_reference); printf("\tKey ref : %d\n", pubkey->key_reference);
printf("\tNative : %s\n", pubkey->native ? "yes" : "no"); printf("\tNative : %s\n", pubkey->native ? "yes" : "no");
@ -464,7 +464,7 @@ static void print_pubkey_info(const struct sc_pkcs15_object *obj)
static int list_public_keys(void) static int list_public_keys(void)
{ {
int r, i; int r, i;
struct sc_pkcs15_object *objs[32]; struct sc_pkcs15_object *objs[32];
r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_PUBKEY_RSA, objs, 32); r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_PUBKEY_RSA, objs, 32);
if (r < 0) { if (r < 0) {
@ -544,11 +544,11 @@ static int read_public_key(void)
static sc_pkcs15_object_t * static sc_pkcs15_object_t *
get_pin_info(void) get_pin_info(void)
{ {
sc_pkcs15_object_t *objs[32], *obj; sc_pkcs15_object_t *objs[32], *obj;
int r; int r;
if (opt_auth_id == NULL) { if (opt_auth_id == NULL) {
r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_AUTH_PIN, objs, 32); r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_AUTH_PIN, objs, 32);
if (r < 0) { if (r < 0) {
fprintf(stderr, "PIN code enumeration failed: %s\n", sc_strerror(r)); fprintf(stderr, "PIN code enumeration failed: %s\n", sc_strerror(r));
return NULL; return NULL;
@ -557,7 +557,7 @@ get_pin_info(void)
fprintf(stderr, "No PIN codes found.\n"); fprintf(stderr, "No PIN codes found.\n");
return NULL; return NULL;
} }
obj = objs[0]; obj = objs[0];
} else { } else {
struct sc_pkcs15_id auth_id; struct sc_pkcs15_id auth_id;
@ -627,7 +627,7 @@ static void print_pin_info(const struct sc_pkcs15_object *obj)
}; };
const char *pin_types[] = {"bcd", "ascii-numeric", "UTF-8", const char *pin_types[] = {"bcd", "ascii-numeric", "UTF-8",
"halfnibble bcd", "iso 9664-1"}; "halfnibble bcd", "iso 9664-1"};
const struct sc_pkcs15_pin_info *pin = (const struct sc_pkcs15_pin_info *) obj->data; const struct sc_pkcs15_pin_info *pin = (const struct sc_pkcs15_pin_info *) obj->data;
const size_t pf_count = sizeof(pin_flags)/sizeof(pin_flags[0]); const size_t pf_count = sizeof(pin_flags)/sizeof(pin_flags[0]);
char path[SC_MAX_PATH_SIZE * 2 + 1]; char path[SC_MAX_PATH_SIZE * 2 + 1];
size_t i; size_t i;
@ -822,7 +822,7 @@ static int learn_card(void)
{ {
char dir[PATH_MAX]; char dir[PATH_MAX];
int r, i, cert_count; int r, i, cert_count;
struct sc_pkcs15_object *certs[32]; struct sc_pkcs15_object *certs[32];
struct sc_pkcs15_df *df; struct sc_pkcs15_df *df;
r = sc_get_cache_dir(ctx, dir, sizeof(dir)); r = sc_get_cache_dir(ctx, dir, sizeof(dir));
@ -832,18 +832,18 @@ static int learn_card(void)
} }
printf("Using cache directory '%s'.\n", dir); printf("Using cache directory '%s'.\n", dir);
r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_CERT_X509, certs, 32); r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_CERT_X509, certs, 32);
if (r < 0) { if (r < 0) {
fprintf(stderr, "Certificate enumeration failed: %s\n", sc_strerror(r)); fprintf(stderr, "Certificate enumeration failed: %s\n", sc_strerror(r));
return 1; return 1;
} }
cert_count = r; cert_count = r;
r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_PRKEY_RSA, NULL, 0); r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_PRKEY_RSA, NULL, 0);
if (r < 0) { if (r < 0) {
fprintf(stderr, "Private key enumeration failed: %s\n", sc_strerror(r)); fprintf(stderr, "Private key enumeration failed: %s\n", sc_strerror(r));
return 1; return 1;
} }
r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_AUTH_PIN, NULL, 0); r = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_AUTH_PIN, NULL, 0);
if (r < 0) { if (r < 0) {
fprintf(stderr, "PIN code enumeration failed: %s\n", sc_strerror(r)); fprintf(stderr, "PIN code enumeration failed: %s\n", sc_strerror(r));
return 1; return 1;