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

fix some warnings + cleanup 

git-svn-id: https://www.opensc-project.org/svnp/opensc/trunk@2847 c6295689-39f2-0310-b995-f0e70906c6a9
This commit is contained in:
nils 2006-02-15 17:05:05 +00:00
parent 5c6f8d0ea9
commit a092e863b8
4 changed files with 237 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/scconf/test-conf.c
View File

@ -42,7 +42,7 @@ static int ldap_cb(const scconf_context * config, const scconf_block * block, sc
{"base", SCCONF_STRING, SCCONF_VERBOSE, NULL, NULL},
{"attributes", SCCONF_LIST, SCCONF_VERBOSE, NULL, NULL},
{"filter", SCCONF_STRING, SCCONF_VERBOSE, NULL, NULL},
{NULL}
{NULL, 0, 0, NULL, NULL}
};
char *cardprefix = (char *) entry->arg;
char *str = scconf_list_strdup(block->name, " ");
@ -64,7 +64,7 @@ static int card_cb(const scconf_context * config, const scconf_block * block, sc
scconf_entry card_entry[] =
{
{"ldap", SCCONF_CALLBACK, SCCONF_VERBOSE | SCCONF_ALL_BLOCKS, (void *) ldap_cb, str},
{NULL}
{NULL, 0, 0, NULL, NULL}
};
if (!str)
@ -91,18 +91,18 @@ int write_entries(scconf_context *conf, scconf_list *list)
static int int42 = 42, int1 = 1;
scconf_entry subblock[] =
{
{"stringIT", SCCONF_STRING, SCCONF_VERBOSE, (void *) "sexy"},
{"callback_str", SCCONF_CALLBACK, SCCONF_VERBOSE, (void *) write_cb},
{NULL}
{"stringIT", SCCONF_STRING, SCCONF_VERBOSE, (void *) "sexy", NULL},
{"callback_str", SCCONF_CALLBACK, SCCONF_VERBOSE, (void *) write_cb, NULL},
{NULL, 0, 0, NULL, NULL}
};
scconf_entry wentry[] =
{
{"string", SCCONF_STRING, SCCONF_VERBOSE, (void *) "value1"},
{"integer", SCCONF_INTEGER, SCCONF_VERBOSE, (void *) &int42},
{"sucks", SCCONF_BOOLEAN, SCCONF_VERBOSE, (void *) &int1 },
{"listN", SCCONF_LIST, SCCONF_VERBOSE, (void *) list},
{"string", SCCONF_STRING, SCCONF_VERBOSE, (void *) "value1", NULL},
{"integer", SCCONF_INTEGER, SCCONF_VERBOSE, (void *) &int42, NULL},
{"sucks", SCCONF_BOOLEAN, SCCONF_VERBOSE, (void *) &int1, NULL },
{"listN", SCCONF_LIST, SCCONF_VERBOSE, (void *) list, NULL},
{"blockN", SCCONF_BLOCK, SCCONF_VERBOSE, (void *) subblock, (void *) list},
{NULL}
{NULL, 0, 0, NULL, NULL}
};
return scconf_write_entries(conf, NULL, wentry);
}
@ -117,9 +117,9 @@ int main(int argc, char **argv)
scconf_context *conf = NULL;
scconf_entry entry[] =
{
{"ldap", SCCONF_CALLBACK, SCCONF_VERBOSE | SCCONF_ALL_BLOCKS, (void *) ldap_cb},
{"card", SCCONF_CALLBACK, SCCONF_VERBOSE | SCCONF_ALL_BLOCKS, (void *) card_cb},
{NULL}
{"ldap", SCCONF_CALLBACK, SCCONF_VERBOSE | SCCONF_ALL_BLOCKS, (void *) ldap_cb, NULL},
{"card", SCCONF_CALLBACK, SCCONF_VERBOSE | SCCONF_ALL_BLOCKS, (void *) card_cb, NULL},
{NULL, 0, 0, NULL, NULL}
};
char *in = NULL, *out = NULL;
int r;

2
src/tools/eidenv.c
View File

@ -221,7 +221,7 @@ static int read_transp(sc_card_t *card, const char *pathstring, unsigned char *b
}
/* Hex-encode the buf, 2*len+1 bytes must be reserved. E.g. {'1','2'} -> {'3','1','3','2','\0'} */
const static char hextable[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'E'};
static const char hextable[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'E'};
static void bintohex(char *buf, int len)
{
int i;

66
src/tools/netkey-tool.c
View File

@ -67,10 +67,14 @@ static struct {
int len;
u8 value[32];
} pinlist[]={
{"3F005000", "pin", "global PIN", 1,-1, 0, 0},
{"3F005001", "puk", "global PUK", -1,-1, 0, 0},
{"3F00DF015080", "pin0", "local PIN0", 3, 0, 0, 0},
{"3F00DF015081", "pin1", "local PIN1", 0,-1, 0, 0},
{"3F005000", "pin", "global PIN", 1,-1, 0, 0,
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{"3F005001", "puk", "global PUK", -1,-1, 0, 0,
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{"3F00DF015080", "pin0", "local PIN0", 3, 0, 0, 0,
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{"3F00DF015081", "pin1", "local PIN1", 0,-1, 0, 0,
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
};
@ -124,7 +128,8 @@ void show_certs(
sc_file_t *f;
X509 *c;
u8 buf[2000], *q;
int i, j;
int j;
size_t i;
printf("\n");
for(i=0;i<sizeof(certlist)/sizeof(certlist[0]);++i){
@ -396,9 +401,12 @@ void handle_writecert(
return;
}
printf("OK\nStoring Cert into Card-Certificate %d: ", cert); fflush(stdout);
q=buf; len=i2d_X509(c,NULL); if(len>0 && len<=sizeof(buf)) i2d_X509(c,&q);
q=buf;
len=i2d_X509(c,NULL);
if(len>0 && len<=(int)sizeof(buf))
i2d_X509(c,&q);
X509_free(c);
if(len<=0 || len>sizeof(buf)){
if(len<=0 || len>(int)sizeof(buf)){
printf("certificate too long or invalid (Len=%d)\n", len);
return;
}
@ -419,7 +427,7 @@ void handle_writecert(
int pin_string2int(
char *s
){
int i;
size_t i;
for(i=0;i<sizeof(pinlist)/sizeof(pinlist[0]);++i) if(!strcasecmp(pinlist[i].name,s)) return i;
return -1;
@ -476,9 +484,10 @@ int main(
int do_help=0, do_unblock=0, do_change=0, do_nullpin=0, do_readcert=0, do_writecert=0;
u8 newpin[32];
char *certfile=NULL, *p;
int i, oerr=0, reader=0, debug=0, newlen=0, pin_nr=-1, cert_nr=-1;
int r, oerr=0, reader=0, debug=0, newlen=0, pin_nr=-1, cert_nr=-1;
size_t i;
while((i=getopt_long(argc,argv,"hvr:p:u:0:1:",options,NULL))!=EOF) switch(i){
while((r=getopt_long(argc,argv,"hvr:p:u:0:1:",options,NULL))!=EOF) switch(r){
case 'h': ++do_help; break;
case 'v': ++debug; break;
case 'r': reader=atoi(optarg); break;
@ -542,12 +551,12 @@ int main(
if(optind==argc-3 && !strcmp(argv[optind],"cert")){
++optind;
cert_nr=strtol(argv[optind],&p,10);
if(argv[optind][0] && !*p && cert_nr>=0 && cert_nr<sizeof(certlist)/sizeof(certlist[0])){
if(argv[optind][0] && !*p && cert_nr>=0 && cert_nr<(int)(sizeof(certlist)/sizeof(certlist[0]))){
do_readcert=1, certfile=argv[optind+1];
} else {
do_writecert=1, certfile=argv[optind];
cert_nr=strtol(argv[optind+1],&p,10);
if(!argv[optind][0] || *p || cert_nr<0 || cert_nr>=sizeof(certlist)/sizeof(certlist[0])) ++oerr;
if(!argv[optind][0] || *p || cert_nr<0 || cert_nr>=(int)(sizeof(certlist)/sizeof(certlist[0]))) ++oerr;
}
optind+=2;
}
@ -560,41 +569,42 @@ int main(
ctx_param.ver = 0;
ctx_param.app_name = argv[0];
i = sc_context_create(&ctx, &ctx_param);
if(i<0){
fprintf(stderr,"Establish-Context failed: %s\n", sc_strerror(i));
r = sc_context_create(&ctx, &ctx_param);
if(r < 0){
fprintf(stderr,"Establish-Context failed: %s\n", sc_strerror(r));
exit(1);
}
ctx->debug=debug;
if(ctx->debug>0) printf("Context for application \"%s\" created, Debug=%d\n", ctx->app_name, ctx->debug);
if(ctx->debug>0)
printf("Context for application \"%s\" created, Debug=%d\n", ctx->app_name, ctx->debug);
for(i=0;ctx->card_drivers[i];++i) if(!strcmp("tcos", ctx->card_drivers[i]->short_name)) break;
for(i=0;ctx->card_drivers[i];++i)
if(!strcmp("tcos", ctx->card_drivers[i]->short_name)) break;
if(!ctx->card_drivers[i]){
fprintf(stderr,"Context does not support TCOS-cards\n");
exit(1);
}
printf("%d Reader detected\n", ctx->reader_count);
for(i=0;i<ctx->reader_count;++i){
printf("%d: %s, Driver: %s, %d Slot(s)\n",
i, ctx->reader[i]->name, ctx->reader[i]->driver->name,
ctx->reader[i]->slot_count
);
printf("%d Reader detected\n", sc_ctx_get_reader_count(ctx));
for(i=0; i < sc_ctx_get_reader_count(ctx); ++i){
sc_reader_t *reader = sc_ctx_get_reader(ctx, i);
printf("%d: %s, Driver: %s, %d Slot(s)\n", i, reader->name,
reader->driver->name, reader->slot_count);
}
if(reader<0 || reader>=ctx->reader_count){
if(reader < 0 || reader >= (int)sc_ctx_get_reader_count(ctx)){
fprintf(stderr,"Cannot open reader %d\n", reader);
exit(1);
}
if((i=sc_connect_card(ctx->reader[0], 0, &card))<0){
fprintf(stderr,"Connect-Card failed: %s\n", sc_strerror(i));
if((r = sc_connect_card(sc_ctx_get_reader(ctx, 0), 0, &card))<0){
fprintf(stderr,"Connect-Card failed: %s\n", sc_strerror(r));
exit(1);
}
printf("\nCard detected (driver: %s)\nATR:", card->driver->name);
for(i=0;i<card->atr_len;++i) printf("%c%02X", i?':':' ', card->atr[i]); printf("\n");
if((i=sc_lock(card))<0){
fprintf(stderr,"Lock failed: %s\n", sc_strerror(i));
if((r = sc_lock(card))<0){
fprintf(stderr,"Lock failed: %s\n", sc_strerror(r));
exit(1);
}

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

@ -1525,23 +1525,31 @@ get##ATTR(CK_SESSION_HANDLE sess, CK_OBJECT_HANDLE obj, CK_ULONG_PTR pulCount) \
* Define attribute accessors
*/
ATTR_METHOD(CLASS, CK_OBJECT_CLASS);
#if 0
ATTR_METHOD(TOKEN, CK_BBOOL);
ATTR_METHOD(LOCAL, CK_BBOOL);
ATTR_METHOD(SENSITIVE, CK_BBOOL);
ATTR_METHOD(ALWAYS_SENSITIVE, CK_BBOOL);
ATTR_METHOD(NEVER_EXTRACTABLE, CK_BBOOL);
#endif
ATTR_METHOD(PRIVATE, CK_BBOOL);
ATTR_METHOD(MODIFIABLE, CK_BBOOL);
ATTR_METHOD(ENCRYPT, CK_BBOOL);
ATTR_METHOD(DECRYPT, CK_BBOOL);
ATTR_METHOD(SIGN, CK_BBOOL);
#if 0
ATTR_METHOD(SIGN_RECOVER, CK_BBOOL);
#endif
ATTR_METHOD(VERIFY, CK_BBOOL);
#if 0
ATTR_METHOD(VERIFY_RECOVER, CK_BBOOL);
#endif
ATTR_METHOD(WRAP, CK_BBOOL);
ATTR_METHOD(UNWRAP, CK_BBOOL);
#if 0
ATTR_METHOD(DERIVE, CK_BBOOL);
ATTR_METHOD(EXTRACTABLE, CK_BBOOL);
#endif
ATTR_METHOD(KEY_TYPE, CK_KEY_TYPE);
ATTR_METHOD(CERTIFICATE_TYPE, CK_CERTIFICATE_TYPE);
ATTR_METHOD(MODULUS_BITS, CK_ULONG);
@ -1763,7 +1771,7 @@ get_mechanisms(CK_SLOT_ID slot,
if (rv != CKR_OK)
p11_fatal("C_GetMechanismList", rv);
if (flags != -1) {
if (flags != (CK_FLAGS)-1) {
CK_MECHANISM_TYPE *mechs = *pList;
CK_MECHANISM_INFO info;
@ -2716,7 +2724,7 @@ encrypt_decrypt(CK_SLOT_ID slot, CK_SESSION_HANDLE session,
if (pkey == NULL)
return 0;
if (EVP_PKEY_size(pkey) > sizeof(encrypted)) {
if (EVP_PKEY_size(pkey) > (int)sizeof(encrypted)) {
printf("Ciphertext buffer too small\n");
EVP_PKEY_free(pkey);
return 0;
@ -3156,7 +3164,7 @@ p11_slot_info_flags(CK_FLAGS value)
{ CKF_TOKEN_PRESENT, "token present" },
{ CKF_REMOVABLE_DEVICE, "removable device" },
{ CKF_HW_SLOT, "hardware slot" },
{ 0 }
{ 0, NULL }
};
return p11_flag_names(slot_flags, value);
@ -3172,7 +3180,7 @@ p11_token_info_flags(CK_FLAGS value)
{ CKF_USER_PIN_INITIALIZED, "PIN initialized" },
{ CKF_PROTECTED_AUTHENTICATION_PATH, "PIN pad present" },
{ CKF_TOKEN_INITIALIZED, "token initialized" },
{ 0 }
{ 0, NULL }
};
return p11_flag_names(slot_flags, value);
@ -3268,181 +3276,181 @@ int hex_to_bin(const char *in, unsigned char *out, size_t *outlen)
}
static struct mech_info p11_mechanisms[] = {
{ CKM_RSA_PKCS_KEY_PAIR_GEN, "RSA-PKCS-KEY-PAIR-GEN" },
{ CKM_RSA_PKCS, "RSA-PKCS" },
{ CKM_RSA_9796, "RSA-9796" },
{ CKM_RSA_X_509, "RSA-X-509" },
{ CKM_MD2_RSA_PKCS, "MD2-RSA-PKCS" },
{ CKM_MD5_RSA_PKCS, "MD5-RSA-PKCS", "rsa-md5" },
{ CKM_RSA_PKCS_KEY_PAIR_GEN, "RSA-PKCS-KEY-PAIR-GEN", NULL },
{ CKM_RSA_PKCS, "RSA-PKCS", NULL },
{ CKM_RSA_9796, "RSA-9796", NULL },
{ CKM_RSA_X_509, "RSA-X-509", NULL },
{ CKM_MD2_RSA_PKCS, "MD2-RSA-PKCS", NULL },
{ CKM_MD5_RSA_PKCS, "MD5-RSA-PKCS", "rsa-md5" },
{ CKM_SHA1_RSA_PKCS, "SHA1-RSA-PKCS", "rsa-sha1" },
{ CKM_RIPEMD128_RSA_PKCS, "RIPEMD128-RSA-PKCS" },
{ CKM_RIPEMD128_RSA_PKCS, "RIPEMD128-RSA-PKCS", NULL },
{ CKM_RIPEMD160_RSA_PKCS, "RIPEMD160-RSA-PKCS", "rsa-ripemd160" },
{ CKM_RSA_PKCS_OAEP, "RSA-PKCS-OAEP" },
{ CKM_RSA_X9_31_KEY_PAIR_GEN,"RSA-X9-31-KEY-PAIR-GEN" },
{ CKM_RSA_X9_31, "RSA-X9-31" },
{ CKM_SHA1_RSA_X9_31, "SHA1-RSA-X9-31" },
{ CKM_RSA_PKCS_PSS, "RSA-PKCS-PSS" },
{ CKM_SHA1_RSA_PKCS_PSS, "SHA1-RSA-PKCS-PSS" },
{ CKM_DSA_KEY_PAIR_GEN, "DSA-KEY-PAIR-GEN" },
{ CKM_DSA, "DSA" },
{ CKM_DSA_SHA1, "DSA-SHA1" },
{ CKM_DH_PKCS_KEY_PAIR_GEN,"DH-PKCS-KEY-PAIR-GEN" },
{ CKM_DH_PKCS_DERIVE, "DH-PKCS-DERIVE" },
{ CKM_X9_42_DH_KEY_PAIR_GEN,"X9-42-DH-KEY-PAIR-GEN" },
{ CKM_X9_42_DH_DERIVE, "X9-42-DH-DERIVE" },
{ CKM_X9_42_DH_HYBRID_DERIVE,"X9-42-DH-HYBRID-DERIVE" },
{ CKM_X9_42_MQV_DERIVE, "X9-42-MQV-DERIVE" },
{ CKM_RC2_KEY_GEN, "RC2-KEY-GEN" },
{ CKM_RC2_ECB, "RC2-ECB" },
{ CKM_RC2_CBC, "RC2-CBC" },
{ CKM_RC2_MAC, "RC2-MAC" },
{ CKM_RC2_MAC_GENERAL, "RC2-MAC-GENERAL" },
{ CKM_RC2_CBC_PAD, "RC2-CBC-PAD" },
{ CKM_RC4_KEY_GEN, "RC4-KEY-GEN" },
{ CKM_RC4, "RC4" },
{ CKM_DES_KEY_GEN, "DES-KEY-GEN" },
{ CKM_DES_ECB, "DES-ECB" },
{ CKM_DES_CBC, "DES-CBC" },
{ CKM_DES_MAC, "DES-MAC" },
{ CKM_DES_MAC_GENERAL, "DES-MAC-GENERAL" },
{ CKM_DES_CBC_PAD, "DES-CBC-PAD" },
{ CKM_DES2_KEY_GEN, "DES2-KEY-GEN" },
{ CKM_DES3_KEY_GEN, "DES3-KEY-GEN" },
{ CKM_DES3_ECB, "DES3-ECB" },
{ CKM_DES3_CBC, "DES3-CBC" },
{ CKM_DES3_MAC, "DES3-MAC" },
{ CKM_DES3_MAC_GENERAL, "DES3-MAC-GENERAL" },
{ CKM_DES3_CBC_PAD, "DES3-CBC-PAD" },
{ CKM_CDMF_KEY_GEN, "CDMF-KEY-GEN" },
{ CKM_CDMF_ECB, "CDMF-ECB" },
{ CKM_CDMF_CBC, "CDMF-CBC" },
{ CKM_CDMF_MAC, "CDMF-MAC" },
{ CKM_CDMF_MAC_GENERAL, "CDMF-MAC-GENERAL" },
{ CKM_CDMF_CBC_PAD, "CDMF-CBC-PAD" },
{ CKM_MD2, "MD2" },
{ CKM_MD2_HMAC, "MD2-HMAC" },
{ CKM_MD2_HMAC_GENERAL, "MD2-HMAC-GENERAL" },
{ CKM_MD5, "MD5" },
{ CKM_MD5_HMAC, "MD5-HMAC" },
{ CKM_MD5_HMAC_GENERAL, "MD5-HMAC-GENERAL" },
{ CKM_SHA_1, "SHA-1" },
{ CKM_SHA_1_HMAC, "SHA-1-HMAC" },
{ CKM_SHA_1_HMAC_GENERAL, "SHA-1-HMAC-GENERAL" },
{ CKM_RIPEMD128, "RIPEMD128" },
{ CKM_RIPEMD128_HMAC, "RIPEMD128-HMAC" },
{ CKM_RIPEMD128_HMAC_GENERAL,"RIPEMD128-HMAC-GENERAL" },
{ CKM_RIPEMD160, "RIPEMD160" },
{ CKM_RIPEMD160_HMAC, "RIPEMD160-HMAC" },
{ CKM_RIPEMD160_HMAC_GENERAL,"RIPEMD160-HMAC-GENERAL" },
{ CKM_CAST_KEY_GEN, "CAST-KEY-GEN" },
{ CKM_CAST_ECB, "CAST-ECB" },
{ CKM_CAST_CBC, "CAST-CBC" },
{ CKM_CAST_MAC, "CAST-MAC" },
{ CKM_CAST_MAC_GENERAL, "CAST-MAC-GENERAL" },
{ CKM_CAST_CBC_PAD, "CAST-CBC-PAD" },
{ CKM_CAST3_KEY_GEN, "CAST3-KEY-GEN" },
{ CKM_CAST3_ECB, "CAST3-ECB" },
{ CKM_CAST3_CBC, "CAST3-CBC" },
{ CKM_CAST3_MAC, "CAST3-MAC" },
{ CKM_CAST3_MAC_GENERAL, "CAST3-MAC-GENERAL" },
{ CKM_CAST3_CBC_PAD, "CAST3-CBC-PAD" },
{ CKM_CAST5_KEY_GEN, "CAST5-KEY-GEN" },
{ CKM_CAST5_ECB, "CAST5-ECB" },
{ CKM_CAST5_CBC, "CAST5-CBC" },
{ CKM_CAST5_MAC, "CAST5-MAC" },
{ CKM_CAST5_MAC_GENERAL, "CAST5-MAC-GENERAL" },
{ CKM_CAST5_CBC_PAD, "CAST5-CBC-PAD" },
{ CKM_RC5_KEY_GEN, "RC5-KEY-GEN" },
{ CKM_RC5_ECB, "RC5-ECB" },
{ CKM_RC5_CBC, "RC5-CBC" },
{ CKM_RC5_MAC, "RC5-MAC" },
{ CKM_RC5_MAC_GENERAL, "RC5-MAC-GENERAL" },
{ CKM_RC5_CBC_PAD, "RC5-CBC-PAD" },
{ CKM_IDEA_KEY_GEN, "IDEA-KEY-GEN" },
{ CKM_IDEA_ECB, "IDEA-ECB" },
{ CKM_IDEA_CBC, "IDEA-CBC" },
{ CKM_IDEA_MAC, "IDEA-MAC" },
{ CKM_IDEA_MAC_GENERAL, "IDEA-MAC-GENERAL" },
{ CKM_IDEA_CBC_PAD, "IDEA-CBC-PAD" },
{ CKM_GENERIC_SECRET_KEY_GEN,"GENERIC-SECRET-KEY-GEN" },
{ CKM_CONCATENATE_BASE_AND_KEY,"CONCATENATE-BASE-AND-KEY" },
{ CKM_CONCATENATE_BASE_AND_DATA,"CONCATENATE-BASE-AND-DATA" },
{ CKM_CONCATENATE_DATA_AND_BASE,"CONCATENATE-DATA-AND-BASE" },
{ CKM_XOR_BASE_AND_DATA, "XOR-BASE-AND-DATA" },
{ CKM_EXTRACT_KEY_FROM_KEY,"EXTRACT-KEY-FROM-KEY" },
{ CKM_SSL3_PRE_MASTER_KEY_GEN,"SSL3-PRE-MASTER-KEY-GEN" },
{ CKM_SSL3_MASTER_KEY_DERIVE,"SSL3-MASTER-KEY-DERIVE" },
{ CKM_SSL3_KEY_AND_MAC_DERIVE,"SSL3-KEY-AND-MAC-DERIVE" },
{ CKM_SSL3_MASTER_KEY_DERIVE_DH,"SSL3-MASTER-KEY-DERIVE-DH" },
{ CKM_TLS_PRE_MASTER_KEY_GEN,"TLS-PRE-MASTER-KEY-GEN" },
{ CKM_TLS_MASTER_KEY_DERIVE,"TLS-MASTER-KEY-DERIVE" },
{ CKM_TLS_KEY_AND_MAC_DERIVE,"TLS-KEY-AND-MAC-DERIVE" },
{ CKM_TLS_MASTER_KEY_DERIVE_DH,"TLS-MASTER-KEY-DERIVE-DH" },
{ CKM_SSL3_MD5_MAC, "SSL3-MD5-MAC" },
{ CKM_SSL3_SHA1_MAC, "SSL3-SHA1-MAC" },
{ CKM_MD5_KEY_DERIVATION, "MD5-KEY-DERIVATION" },
{ CKM_MD2_KEY_DERIVATION, "MD2-KEY-DERIVATION" },
{ CKM_SHA1_KEY_DERIVATION,"SHA1-KEY-DERIVATION" },
{ CKM_PBE_MD2_DES_CBC, "PBE-MD2-DES-CBC" },
{ CKM_PBE_MD5_DES_CBC, "PBE-MD5-DES-CBC" },
{ CKM_PBE_MD5_CAST_CBC, "PBE-MD5-CAST-CBC" },
{ CKM_PBE_MD5_CAST3_CBC, "PBE-MD5-CAST3-CBC" },
{ CKM_PBE_MD5_CAST5_CBC, "PBE-MD5-CAST5-CBC" },
{ CKM_PBE_SHA1_CAST5_CBC, "PBE-SHA1-CAST5-CBC" },
{ CKM_PBE_SHA1_RC4_128, "PBE-SHA1-RC4-128" },
{ CKM_PBE_SHA1_RC4_40, "PBE-SHA1-RC4-40" },
{ CKM_PBE_SHA1_DES3_EDE_CBC,"PBE-SHA1-DES3-EDE-CBC" },
{ CKM_PBE_SHA1_DES2_EDE_CBC,"PBE-SHA1-DES2-EDE-CBC" },
{ CKM_PBE_SHA1_RC2_128_CBC,"PBE-SHA1-RC2-128-CBC" },
{ CKM_PBE_SHA1_RC2_40_CBC,"PBE-SHA1-RC2-40-CBC" },
{ CKM_PKCS5_PBKD2, "PKCS5-PBKD2" },
{ CKM_PBA_SHA1_WITH_SHA1_HMAC,"PBA-SHA1-WITH-SHA1-HMAC" },
{ CKM_KEY_WRAP_LYNKS, "KEY-WRAP-LYNKS" },
{ CKM_KEY_WRAP_SET_OAEP, "KEY-WRAP-SET-OAEP" },
{ CKM_SKIPJACK_KEY_GEN, "SKIPJACK-KEY-GEN" },
{ CKM_SKIPJACK_ECB64, "SKIPJACK-ECB64" },
{ CKM_SKIPJACK_CBC64, "SKIPJACK-CBC64" },
{ CKM_SKIPJACK_OFB64, "SKIPJACK-OFB64" },
{ CKM_SKIPJACK_CFB64, "SKIPJACK-CFB64" },
{ CKM_SKIPJACK_CFB32, "SKIPJACK-CFB32" },
{ CKM_SKIPJACK_CFB16, "SKIPJACK-CFB16" },
{ CKM_SKIPJACK_CFB8, "SKIPJACK-CFB8" },
{ CKM_SKIPJACK_WRAP, "SKIPJACK-WRAP" },
{ CKM_SKIPJACK_PRIVATE_WRAP,"SKIPJACK-PRIVATE-WRAP" },
{ CKM_SKIPJACK_RELAYX, "SKIPJACK-RELAYX" },
{ CKM_KEA_KEY_PAIR_GEN, "KEA-KEY-PAIR-GEN" },
{ CKM_KEA_KEY_DERIVE, "KEA-KEY-DERIVE" },
{ CKM_FORTEZZA_TIMESTAMP, "FORTEZZA-TIMESTAMP" },
{ CKM_BATON_KEY_GEN, "BATON-KEY-GEN" },
{ CKM_BATON_ECB128, "BATON-ECB128" },
{ CKM_BATON_ECB96, "BATON-ECB96" },
{ CKM_BATON_CBC128, "BATON-CBC128" },
{ CKM_BATON_COUNTER, "BATON-COUNTER" },
{ CKM_BATON_SHUFFLE, "BATON-SHUFFLE" },
{ CKM_BATON_WRAP, "BATON-WRAP" },
{ CKM_ECDSA_KEY_PAIR_GEN, "ECDSA-KEY-PAIR-GEN" },
{ CKM_ECDSA, "ECDSA" },
{ CKM_ECDSA_SHA1, "ECDSA-SHA1" },
{ CKM_ECDH1_DERIVE, "ECDH1-DERIVE" },
{ CKM_ECDH1_COFACTOR_DERIVE,"ECDH1-COFACTOR-DERIVE" },
{ CKM_ECMQV_DERIVE, "ECMQV-DERIVE" },
{ CKM_JUNIPER_KEY_GEN, "JUNIPER-KEY-GEN" },
{ CKM_JUNIPER_ECB128, "JUNIPER-ECB128" },
{ CKM_JUNIPER_CBC128, "JUNIPER-CBC128" },
{ CKM_JUNIPER_COUNTER, "JUNIPER-COUNTER" },
{ CKM_JUNIPER_SHUFFLE, "JUNIPER-SHUFFLE" },
{ CKM_JUNIPER_WRAP, "JUNIPER-WRAP" },
{ CKM_FASTHASH, "FASTHASH" },
{ CKM_AES_KEY_GEN, "AES-KEY-GEN" },
{ CKM_AES_ECB, "AES-ECB" },
{ CKM_AES_CBC, "AES-CBC" },
{ CKM_AES_MAC, "AES-MAC" },
{ CKM_AES_MAC_GENERAL, "AES-MAC-GENERAL" },
{ CKM_AES_CBC_PAD, "AES-CBC-PAD" },
{ CKM_DSA_PARAMETER_GEN, "DSA-PARAMETER-GEN" },
{ CKM_DH_PKCS_PARAMETER_GEN,"DH-PKCS-PARAMETER-GEN" },
{ CKM_X9_42_DH_PARAMETER_GEN,"X9-42-DH-PARAMETER-GEN" },
{ NO_MECHANISM, NULL }
{ CKM_RSA_PKCS_OAEP, "RSA-PKCS-OAEP", NULL },
{ CKM_RSA_X9_31_KEY_PAIR_GEN,"RSA-X9-31-KEY-PAIR-GEN", NULL },
{ CKM_RSA_X9_31, "RSA-X9-31", NULL },
{ CKM_SHA1_RSA_X9_31, "SHA1-RSA-X9-31", NULL },
{ CKM_RSA_PKCS_PSS, "RSA-PKCS-PSS", NULL },
{ CKM_SHA1_RSA_PKCS_PSS, "SHA1-RSA-PKCS-PSS", NULL },
{ CKM_DSA_KEY_PAIR_GEN, "DSA-KEY-PAIR-GEN", NULL },
{ CKM_DSA, "DSA", NULL },
{ CKM_DSA_SHA1, "DSA-SHA1", NULL },
{ CKM_DH_PKCS_KEY_PAIR_GEN,"DH-PKCS-KEY-PAIR-GEN", NULL },
{ CKM_DH_PKCS_DERIVE, "DH-PKCS-DERIVE", NULL },
{ CKM_X9_42_DH_KEY_PAIR_GEN,"X9-42-DH-KEY-PAIR-GEN", NULL },
{ CKM_X9_42_DH_DERIVE, "X9-42-DH-DERIVE", NULL },
{ CKM_X9_42_DH_HYBRID_DERIVE,"X9-42-DH-HYBRID-DERIVE", NULL },
{ CKM_X9_42_MQV_DERIVE, "X9-42-MQV-DERIVE", NULL },
{ CKM_RC2_KEY_GEN, "RC2-KEY-GEN", NULL },
{ CKM_RC2_ECB, "RC2-ECB", NULL },
{ CKM_RC2_CBC, "RC2-CBC", NULL },
{ CKM_RC2_MAC, "RC2-MAC", NULL },
{ CKM_RC2_MAC_GENERAL, "RC2-MAC-GENERAL", NULL },
{ CKM_RC2_CBC_PAD, "RC2-CBC-PAD", NULL },
{ CKM_RC4_KEY_GEN, "RC4-KEY-GEN", NULL },
{ CKM_RC4, "RC4", NULL },
{ CKM_DES_KEY_GEN, "DES-KEY-GEN", NULL },
{ CKM_DES_ECB, "DES-ECB", NULL },
{ CKM_DES_CBC, "DES-CBC", NULL },
{ CKM_DES_MAC, "DES-MAC", NULL },
{ CKM_DES_MAC_GENERAL, "DES-MAC-GENERAL", NULL },
{ CKM_DES_CBC_PAD, "DES-CBC-PAD", NULL },
{ CKM_DES2_KEY_GEN, "DES2-KEY-GEN", NULL },
{ CKM_DES3_KEY_GEN, "DES3-KEY-GEN", NULL },
{ CKM_DES3_ECB, "DES3-ECB", NULL },
{ CKM_DES3_CBC, "DES3-CBC", NULL },
{ CKM_DES3_MAC, "DES3-MAC", NULL },
{ CKM_DES3_MAC_GENERAL, "DES3-MAC-GENERAL", NULL },
{ CKM_DES3_CBC_PAD, "DES3-CBC-PAD", NULL },
{ CKM_CDMF_KEY_GEN, "CDMF-KEY-GEN", NULL },
{ CKM_CDMF_ECB, "CDMF-ECB", NULL },
{ CKM_CDMF_CBC, "CDMF-CBC", NULL },
{ CKM_CDMF_MAC, "CDMF-MAC", NULL },
{ CKM_CDMF_MAC_GENERAL, "CDMF-MAC-GENERAL", NULL },
{ CKM_CDMF_CBC_PAD, "CDMF-CBC-PAD", NULL },
{ CKM_MD2, "MD2", NULL },
{ CKM_MD2_HMAC, "MD2-HMAC", NULL },
{ CKM_MD2_HMAC_GENERAL, "MD2-HMAC-GENERAL", NULL },
{ CKM_MD5, "MD5", NULL },
{ CKM_MD5_HMAC, "MD5-HMAC", NULL },
{ CKM_MD5_HMAC_GENERAL, "MD5-HMAC-GENERAL", NULL },
{ CKM_SHA_1, "SHA-1", NULL },
{ CKM_SHA_1_HMAC, "SHA-1-HMAC", NULL },
{ CKM_SHA_1_HMAC_GENERAL, "SHA-1-HMAC-GENERAL", NULL },
{ CKM_RIPEMD128, "RIPEMD128", NULL },
{ CKM_RIPEMD128_HMAC, "RIPEMD128-HMAC", NULL },
{ CKM_RIPEMD128_HMAC_GENERAL,"RIPEMD128-HMAC-GENERAL", NULL },
{ CKM_RIPEMD160, "RIPEMD160", NULL },
{ CKM_RIPEMD160_HMAC, "RIPEMD160-HMAC", NULL },
{ CKM_RIPEMD160_HMAC_GENERAL,"RIPEMD160-HMAC-GENERAL", NULL },
{ CKM_CAST_KEY_GEN, "CAST-KEY-GEN", NULL },
{ CKM_CAST_ECB, "CAST-ECB", NULL },
{ CKM_CAST_CBC, "CAST-CBC", NULL },
{ CKM_CAST_MAC, "CAST-MAC", NULL },
{ CKM_CAST_MAC_GENERAL, "CAST-MAC-GENERAL", NULL },
{ CKM_CAST_CBC_PAD, "CAST-CBC-PAD", NULL },
{ CKM_CAST3_KEY_GEN, "CAST3-KEY-GEN", NULL },
{ CKM_CAST3_ECB, "CAST3-ECB", NULL },
{ CKM_CAST3_CBC, "CAST3-CBC", NULL },
{ CKM_CAST3_MAC, "CAST3-MAC", NULL },
{ CKM_CAST3_MAC_GENERAL, "CAST3-MAC-GENERAL", NULL },
{ CKM_CAST3_CBC_PAD, "CAST3-CBC-PAD", NULL },
{ CKM_CAST5_KEY_GEN, "CAST5-KEY-GEN", NULL },
{ CKM_CAST5_ECB, "CAST5-ECB", NULL },
{ CKM_CAST5_CBC, "CAST5-CBC", NULL },
{ CKM_CAST5_MAC, "CAST5-MAC", NULL },
{ CKM_CAST5_MAC_GENERAL, "CAST5-MAC-GENERAL", NULL },
{ CKM_CAST5_CBC_PAD, "CAST5-CBC-PAD", NULL },
{ CKM_RC5_KEY_GEN, "RC5-KEY-GEN", NULL },
{ CKM_RC5_ECB, "RC5-ECB", NULL },
{ CKM_RC5_CBC, "RC5-CBC", NULL },
{ CKM_RC5_MAC, "RC5-MAC", NULL },
{ CKM_RC5_MAC_GENERAL, "RC5-MAC-GENERAL", NULL },
{ CKM_RC5_CBC_PAD, "RC5-CBC-PAD", NULL },
{ CKM_IDEA_KEY_GEN, "IDEA-KEY-GEN", NULL },
{ CKM_IDEA_ECB, "IDEA-ECB", NULL },
{ CKM_IDEA_CBC, "IDEA-CBC", NULL },
{ CKM_IDEA_MAC, "IDEA-MAC", NULL },
{ CKM_IDEA_MAC_GENERAL, "IDEA-MAC-GENERAL", NULL },
{ CKM_IDEA_CBC_PAD, "IDEA-CBC-PAD", NULL },
{ CKM_GENERIC_SECRET_KEY_GEN,"GENERIC-SECRET-KEY-GEN", NULL },
{ CKM_CONCATENATE_BASE_AND_KEY,"CONCATENATE-BASE-AND-KEY", NULL },
{ CKM_CONCATENATE_BASE_AND_DATA,"CONCATENATE-BASE-AND-DATA", NULL },
{ CKM_CONCATENATE_DATA_AND_BASE,"CONCATENATE-DATA-AND-BASE", NULL },
{ CKM_XOR_BASE_AND_DATA, "XOR-BASE-AND-DATA", NULL },
{ CKM_EXTRACT_KEY_FROM_KEY,"EXTRACT-KEY-FROM-KEY", NULL },
{ CKM_SSL3_PRE_MASTER_KEY_GEN,"SSL3-PRE-MASTER-KEY-GEN", NULL },
{ CKM_SSL3_MASTER_KEY_DERIVE,"SSL3-MASTER-KEY-DERIVE", NULL },
{ CKM_SSL3_KEY_AND_MAC_DERIVE,"SSL3-KEY-AND-MAC-DERIVE", NULL },
{ CKM_SSL3_MASTER_KEY_DERIVE_DH,"SSL3-MASTER-KEY-DERIVE-DH", NULL },
{ CKM_TLS_PRE_MASTER_KEY_GEN,"TLS-PRE-MASTER-KEY-GEN", NULL },
{ CKM_TLS_MASTER_KEY_DERIVE,"TLS-MASTER-KEY-DERIVE", NULL },
{ CKM_TLS_KEY_AND_MAC_DERIVE,"TLS-KEY-AND-MAC-DERIVE", NULL },
{ CKM_TLS_MASTER_KEY_DERIVE_DH,"TLS-MASTER-KEY-DERIVE-DH", NULL },
{ CKM_SSL3_MD5_MAC, "SSL3-MD5-MAC", NULL },
{ CKM_SSL3_SHA1_MAC, "SSL3-SHA1-MAC", NULL },
{ CKM_MD5_KEY_DERIVATION, "MD5-KEY-DERIVATION", NULL },
{ CKM_MD2_KEY_DERIVATION, "MD2-KEY-DERIVATION", NULL },
{ CKM_SHA1_KEY_DERIVATION,"SHA1-KEY-DERIVATION", NULL },
{ CKM_PBE_MD2_DES_CBC, "PBE-MD2-DES-CBC", NULL },
{ CKM_PBE_MD5_DES_CBC, "PBE-MD5-DES-CBC", NULL },
{ CKM_PBE_MD5_CAST_CBC, "PBE-MD5-CAST-CBC", NULL },
{ CKM_PBE_MD5_CAST3_CBC, "PBE-MD5-CAST3-CBC", NULL },
{ CKM_PBE_MD5_CAST5_CBC, "PBE-MD5-CAST5-CBC", NULL },
{ CKM_PBE_SHA1_CAST5_CBC, "PBE-SHA1-CAST5-CBC", NULL },
{ CKM_PBE_SHA1_RC4_128, "PBE-SHA1-RC4-128", NULL },
{ CKM_PBE_SHA1_RC4_40, "PBE-SHA1-RC4-40", NULL },
{ CKM_PBE_SHA1_DES3_EDE_CBC,"PBE-SHA1-DES3-EDE-CBC", NULL },
{ CKM_PBE_SHA1_DES2_EDE_CBC,"PBE-SHA1-DES2-EDE-CBC", NULL },
{ CKM_PBE_SHA1_RC2_128_CBC,"PBE-SHA1-RC2-128-CBC", NULL },
{ CKM_PBE_SHA1_RC2_40_CBC,"PBE-SHA1-RC2-40-CBC", NULL },
{ CKM_PKCS5_PBKD2, "PKCS5-PBKD2", NULL },
{ CKM_PBA_SHA1_WITH_SHA1_HMAC,"PBA-SHA1-WITH-SHA1-HMAC", NULL },
{ CKM_KEY_WRAP_LYNKS, "KEY-WRAP-LYNKS", NULL },
{ CKM_KEY_WRAP_SET_OAEP, "KEY-WRAP-SET-OAEP", NULL },
{ CKM_SKIPJACK_KEY_GEN, "SKIPJACK-KEY-GEN", NULL },
{ CKM_SKIPJACK_ECB64, "SKIPJACK-ECB64", NULL },
{ CKM_SKIPJACK_CBC64, "SKIPJACK-CBC64", NULL },
{ CKM_SKIPJACK_OFB64, "SKIPJACK-OFB64", NULL },
{ CKM_SKIPJACK_CFB64, "SKIPJACK-CFB64", NULL },
{ CKM_SKIPJACK_CFB32, "SKIPJACK-CFB32", NULL },
{ CKM_SKIPJACK_CFB16, "SKIPJACK-CFB16", NULL },
{ CKM_SKIPJACK_CFB8, "SKIPJACK-CFB8", NULL },
{ CKM_SKIPJACK_WRAP, "SKIPJACK-WRAP", NULL },
{ CKM_SKIPJACK_PRIVATE_WRAP,"SKIPJACK-PRIVATE-WRAP", NULL },
{ CKM_SKIPJACK_RELAYX, "SKIPJACK-RELAYX", NULL },
{ CKM_KEA_KEY_PAIR_GEN, "KEA-KEY-PAIR-GEN", NULL },
{ CKM_KEA_KEY_DERIVE, "KEA-KEY-DERIVE", NULL },
{ CKM_FORTEZZA_TIMESTAMP, "FORTEZZA-TIMESTAMP", NULL },
{ CKM_BATON_KEY_GEN, "BATON-KEY-GEN", NULL },
{ CKM_BATON_ECB128, "BATON-ECB128", NULL },
{ CKM_BATON_ECB96, "BATON-ECB96", NULL },
{ CKM_BATON_CBC128, "BATON-CBC128", NULL },
{ CKM_BATON_COUNTER, "BATON-COUNTER", NULL },
{ CKM_BATON_SHUFFLE, "BATON-SHUFFLE", NULL },
{ CKM_BATON_WRAP, "BATON-WRAP", NULL },
{ CKM_ECDSA_KEY_PAIR_GEN, "ECDSA-KEY-PAIR-GEN", NULL },
{ CKM_ECDSA, "ECDSA", NULL },
{ CKM_ECDSA_SHA1, "ECDSA-SHA1", NULL },
{ CKM_ECDH1_DERIVE, "ECDH1-DERIVE", NULL },
{ CKM_ECDH1_COFACTOR_DERIVE,"ECDH1-COFACTOR-DERIVE", NULL },
{ CKM_ECMQV_DERIVE, "ECMQV-DERIVE", NULL },
{ CKM_JUNIPER_KEY_GEN, "JUNIPER-KEY-GEN", NULL },
{ CKM_JUNIPER_ECB128, "JUNIPER-ECB128", NULL },
{ CKM_JUNIPER_CBC128, "JUNIPER-CBC128", NULL },
{ CKM_JUNIPER_COUNTER, "JUNIPER-COUNTER", NULL },
{ CKM_JUNIPER_SHUFFLE, "JUNIPER-SHUFFLE", NULL },
{ CKM_JUNIPER_WRAP, "JUNIPER-WRAP", NULL },
{ CKM_FASTHASH, "FASTHASH", NULL },
{ CKM_AES_KEY_GEN, "AES-KEY-GEN", NULL },
{ CKM_AES_ECB, "AES-ECB", NULL },
{ CKM_AES_CBC, "AES-CBC", NULL },
{ CKM_AES_MAC, "AES-MAC", NULL },
{ CKM_AES_MAC_GENERAL, "AES-MAC-GENERAL", NULL },
{ CKM_AES_CBC_PAD, "AES-CBC-PAD", NULL },
{ CKM_DSA_PARAMETER_GEN, "DSA-PARAMETER-GEN", NULL },
{ CKM_DH_PKCS_PARAMETER_GEN,"DH-PKCS-PARAMETER-GEN", NULL },
{ CKM_X9_42_DH_PARAMETER_GEN,"X9-42-DH-PARAMETER-GEN", NULL },
{ NO_MECHANISM, NULL, NULL }
};
static const char *