1 /*
2 * Copyright (C) 2015 Mathias Brossard <mathias@brossard.org>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
17 * USA
18 */
19
20 #include "config.h"
21 #if !defined(_MSC_VER) || _MSC_VER >= 1800
22 #include <inttypes.h>
23 #endif
24 #include <string.h>
25
26 #ifdef ENABLE_OPENSSL
27 #include <openssl/x509.h>
28 #endif
29
30 #include "pkcs11-display.h"
31
32 /* Some Netscape/Mozilla-specific stuff:
33 * http://www.opensource.apple.com/darwinsource/10.3/SecurityNssAsn1-11/nssDER/Source/pkcs11n.h */
34
35 /*
36 * Netscape-defined object classes
37 *
38 */
39 #define CKO_NETSCAPE 0xCE534350
40
41 #define CKO_NETSCAPE_CRL (CKO_NETSCAPE + 1)
42 #define CKO_NETSCAPE_SMIME (CKO_NETSCAPE + 2)
43 #define CKO_NETSCAPE_TRUST (CKO_NETSCAPE + 3)
44 #define CKO_NETSCAPE_BUILTIN_ROOT_LIST (CKO_NETSCAPE + 4)
45
46 /*
47 * Netscape-defined object attributes
48 *
49 */
50
51 #define CKA_NETSCAPE 0xCE534350
52
53 #define CKA_NETSCAPE_URL (CKA_NETSCAPE + 1)
54 #define CKA_NETSCAPE_EMAIL (CKA_NETSCAPE + 2)
55 #define CKA_NETSCAPE_SMIME_INFO (CKA_NETSCAPE + 3)
56 #define CKA_NETSCAPE_SMIME_TIMESTAMP (CKA_NETSCAPE + 4)
57 #define CKA_NETSCAPE_PKCS8_SALT (CKA_NETSCAPE + 5)
58 #define CKA_NETSCAPE_PASSWORD_CHECK (CKA_NETSCAPE + 6)
59 #define CKA_NETSCAPE_EXPIRES (CKA_NETSCAPE + 7)
60 #define CKA_NETSCAPE_KRL (CKA_NETSCAPE + 8)
61
62 #define CKA_NETSCAPE_PQG_COUNTER (CKA_NETSCAPE + 20)
63 #define CKA_NETSCAPE_PQG_SEED (CKA_NETSCAPE + 21)
64 #define CKA_NETSCAPE_PQG_H (CKA_NETSCAPE + 22)
65 #define CKA_NETSCAPE_PQG_SEED_BITS (CKA_NETSCAPE + 23)
66
67 #define CKA_TRUST (CKA_NETSCAPE + 0x2000)
68
69 /* "Usage" key information */
70 #define CKA_TRUST_DIGITAL_SIGNATURE (CKA_TRUST + 1)
71 #define CKA_TRUST_NON_REPUDIATION (CKA_TRUST + 2)
72 #define CKA_TRUST_KEY_ENCIPHERMENT (CKA_TRUST + 3)
73 #define CKA_TRUST_DATA_ENCIPHERMENT (CKA_TRUST + 4)
74 #define CKA_TRUST_KEY_AGREEMENT (CKA_TRUST + 5)
75 #define CKA_TRUST_KEY_CERT_SIGN (CKA_TRUST + 6)
76 #define CKA_TRUST_CRL_SIGN (CKA_TRUST + 7)
77
78 /* "Purpose" trust information */
79 #define CKA_TRUST_SERVER_AUTH (CKA_TRUST + 8)
80 #define CKA_TRUST_CLIENT_AUTH (CKA_TRUST + 9)
81 #define CKA_TRUST_CODE_SIGNING (CKA_TRUST + 10)
82 #define CKA_TRUST_EMAIL_PROTECTION (CKA_TRUST + 11)
83 #define CKA_TRUST_IPSEC_END_SYSTEM (CKA_TRUST + 12)
84 #define CKA_TRUST_IPSEC_TUNNEL (CKA_TRUST + 13)
85 #define CKA_TRUST_IPSEC_USER (CKA_TRUST + 14)
86 #define CKA_TRUST_TIME_STAMPING (CKA_TRUST + 15)
87 #define CKA_CERT_SHA1_HASH (CKA_TRUST + 100)
88 #define CKA_CERT_MD5_HASH (CKA_TRUST + 101)
89
90
91 static char *
buf_spec(CK_VOID_PTR buf_addr,CK_ULONG buf_len)92 buf_spec(CK_VOID_PTR buf_addr, CK_ULONG buf_len)
93 {
94 static char ret[64];
95
96 #if !defined(_MSC_VER) || _MSC_VER >= 1800
97 const size_t prwidth = sizeof(CK_VOID_PTR) * 2;
98
99 sprintf(ret, "%0*"PRIxPTR" / %ld", (int) prwidth, (uintptr_t) buf_addr,
100 buf_len);
101 #else
102 if (sizeof(CK_VOID_PTR) == 4)
103 sprintf(ret, "%08lx / %lu", (unsigned long) buf_addr, buf_len);
104 else
105 sprintf(ret, "%016llx / %lu", (unsigned long long) buf_addr,
106 buf_len);
107 #endif
108
109 return ret;
110 }
111
112
113 void
print_enum(FILE * f,CK_LONG type,CK_VOID_PTR value,CK_ULONG size,CK_VOID_PTR arg)114 print_enum(FILE *f, CK_LONG type, CK_VOID_PTR value, CK_ULONG size, CK_VOID_PTR arg)
115 {
116 enum_spec *spec = (enum_spec*)arg;
117 CK_ULONG i;
118 CK_ULONG ctype = *((CK_ULONG_PTR)value);
119
120 for(i = 0; i < spec->size; i++) {
121 if(spec->specs[i].type == ctype) {
122 fprintf(f, "%s\n", spec->specs[i].name);
123 return;
124 }
125 }
126 fprintf(f, "Value %lX not found for type %s\n", ctype, spec->name);
127 }
128
129
130 void
print_boolean(FILE * f,CK_LONG type,CK_VOID_PTR value,CK_ULONG size,CK_VOID_PTR arg)131 print_boolean(FILE *f, CK_LONG type, CK_VOID_PTR value, CK_ULONG size, CK_VOID_PTR arg)
132 {
133 CK_BYTE i = *((CK_BYTE *)value);
134 fprintf(f, i ? "True\n" : "False\n");
135 }
136
137
138 void
print_generic(FILE * f,CK_LONG type,CK_VOID_PTR value,CK_ULONG size,CK_VOID_PTR arg)139 print_generic(FILE *f, CK_LONG type, CK_VOID_PTR value, CK_ULONG size, CK_VOID_PTR arg)
140 {
141 CK_ULONG i;
142
143 if((CK_LONG)size != -1 && value != NULL) {
144 char hex[16*3+1] = {0};
145 char ascii[16+1];
146 char *hex_ptr = hex, *ascii_ptr = ascii;
147 int offset = 0;
148
149 memset(ascii, ' ', sizeof ascii);
150 ascii[sizeof ascii -1] = 0;
151 fprintf(f, "%s", buf_spec(value, size));
152 for(i = 0; i < size; i++) {
153 CK_BYTE val;
154
155 if (i && (i % 16) == 0) {
156 fprintf(f, "\n %08X %s %s", offset, hex, ascii);
157 offset += 16;
158 hex_ptr = hex;
159 ascii_ptr = ascii;
160 memset(ascii, ' ', sizeof ascii -1);
161 }
162
163 val = ((CK_BYTE *)value)[i];
164 /* hex */
165 sprintf(hex_ptr, "%02X ", val);
166 hex_ptr += 3;
167 /* ascii */
168 if (val > 31 && val < 128)
169 *ascii_ptr = val;
170 else
171 *ascii_ptr = '.';
172 ascii_ptr++;
173 }
174
175 /* padd */
176 while (strlen(hex) < 3*16)
177 strcat(hex, " ");
178 fprintf(f, "\n %08X %s %s", offset, hex, ascii);
179 }
180 else {
181 if (value != NULL)
182 fprintf(f, "EMPTY");
183 else
184 fprintf(f, "NULL [size : 0x%lX (%ld)]", size, size);
185 }
186 fprintf(f, "\n");
187 }
188
189
190 #ifdef ENABLE_OPENSSL
191 static void
print_dn(FILE * f,CK_LONG type,CK_VOID_PTR value,CK_ULONG size,CK_VOID_PTR arg)192 print_dn(FILE *f, CK_LONG type, CK_VOID_PTR value, CK_ULONG size, CK_VOID_PTR arg)
193 {
194 print_generic(f, type, value, size, arg);
195 if(size && value) {
196 X509_NAME *name;
197 const unsigned char *tmp = value;
198
199 name = d2i_X509_NAME(NULL, &tmp, size);
200 if(name) {
201 BIO *bio = BIO_new(BIO_s_file());
202 BIO_set_fp(bio, f, 0);
203 fprintf(f, " DN: ");
204 X509_NAME_print(bio, name, XN_FLAG_RFC2253);
205 fprintf(f, "\n");
206 BIO_free(bio);
207 }
208 }
209 }
210 #endif
211
212 void
print_print(FILE * f,CK_LONG type,CK_VOID_PTR value,CK_ULONG size,CK_VOID_PTR arg)213 print_print(FILE *f, CK_LONG type, CK_VOID_PTR value, CK_ULONG size, CK_VOID_PTR arg)
214 {
215 CK_ULONG i, j=0;
216 CK_BYTE c;
217
218 if((CK_LONG)size != -1) {
219 fprintf(f, "%s\n ", buf_spec(value, size));
220 for(i = 0; i < size; i += j) {
221 for(j = 0; ((i + j < size) && (j < 32)); j++) {
222 if (((j % 4) == 0) && (j != 0))
223 fprintf(f, " ");
224 c = ((CK_BYTE *)value)[i+j];
225 fprintf(f, "%02X", c);
226 }
227 fprintf(f, "\n ");
228
229 for(j = 0; ((i + j < size) && (j < 32)); j++) {
230 if (((j % 4) == 0) && (j != 0))
231 fprintf(f, " ");
232 c = ((CK_BYTE *)value)[i + j];
233 if((c > 32) && (c < 128))
234 fprintf(f, " %c", c);
235 else
236 fprintf(f, " .");
237 }
238 }
239 if(j == 32)
240 fprintf(f, "\n ");
241 }
242 else {
243 fprintf(f, "EMPTY");
244 }
245 fprintf(f, "\n");
246 }
247
248 static enum_specs ck_cls_s[] = {
249 { CKO_DATA , "CKO_DATA " },
250 { CKO_CERTIFICATE , "CKO_CERTIFICATE " },
251 { CKO_PUBLIC_KEY , "CKO_PUBLIC_KEY " },
252 { CKO_PRIVATE_KEY , "CKO_PRIVATE_KEY " },
253 { CKO_SECRET_KEY , "CKO_SECRET_KEY " },
254 { CKO_PROFILE , "CKO_PROFILE " },
255 { CKO_HW_FEATURE , "CKO_HW_FEATURE " },
256 { CKO_DOMAIN_PARAMETERS, "CKO_DOMAIN_PARAMETERS" },
257 { CKO_NETSCAPE_CRL, "CKO_NETSCAPE_CRL " },
258 { CKO_NETSCAPE_SMIME , "CKO_NETSCAPE_SMIME " },
259 { CKO_NETSCAPE_TRUST, "CKO_NETSCAPE_TRUST " },
260 { CKO_NETSCAPE_BUILTIN_ROOT_LIST, "CKO_NETSCAPE_BUILTIN_ROOT_LIST" },
261 { CKO_VENDOR_DEFINED , "CKO_VENDOR_DEFINED " }
262 };
263
264 enum_specs ck_profile_s[] = {
265 { CKP_INVALID_ID , "CKP_INVALID_ID " },
266 { CKP_BASELINE_PROVIDER , "CKP_BASELINE_PROVIDER " },
267 { CKP_EXTENDED_PROVIDER , "CKP_EXTENDED_PROVIDER " },
268 { CKP_AUTHENTICATION_TOKEN , "CKP_AUTHENTICATION_TOKEN " },
269 { CKP_PUBLIC_CERTIFICATES_TOKEN, "CKP_PUBLIC_CERTIFICATES_TOKEN" },
270 { CKP_VENDOR_DEFINED , "CKP_VENDOR_DEFINED " }
271 };
272
273 static enum_specs ck_crt_s[] = {
274 { CKC_X_509, "CKC_X_509" },
275 { CKC_X_509_ATTR_CERT, "CKC_X_509_ATTR_CERT" },
276 };
277
278 static enum_specs ck_key_s[] = {
279 { CKK_RSA , "CKK_RSA " },
280 { CKK_DSA , "CKK_DSA " },
281 { CKK_DH , "CKK_DH " },
282 { CKK_EC , "CKK_EC " },
283 { CKK_EC_EDWARDS , "CKK_EC_EDWARDS " },
284 { CKK_EC_MONTGOMERY , "CKK_EC_MONTOGMERY " },
285 { CKK_X9_42_DH , "CKK_X9_42_DH " },
286 { CKK_KEA , "CKK_KEA " },
287 { CKK_GENERIC_SECRET, "CKK_GENERIC_SECRET " },
288 { CKK_RC2 , "CKK_RC2 " },
289 { CKK_RC4 , "CKK_RC4 " },
290 { CKK_DES , "CKK_DES " },
291 { CKK_DES2 , "CKK_DES2 " },
292 { CKK_DES3 , "CKK_DES3 " },
293 { CKK_CAST , "CKK_CAST " },
294 { CKK_CAST3 , "CKK_CAST3 " },
295 { CKK_CAST128 , "CKK_CAST128 " },
296 { CKK_RC5 , "CKK_RC5 " },
297 { CKK_IDEA , "CKK_IDEA " },
298 { CKK_SKIPJACK , "CKK_SKIPJACK " },
299 { CKK_BATON , "CKK_BATON " },
300 { CKK_JUNIPER , "CKK_JUNIPER " },
301 { CKK_CDMF , "CKK_CDMF " },
302 { CKK_AES , "CKK_AES " },
303 { CKK_BLOWFISH , "CKK_BLOWFISH " },
304 { CKK_TWOFISH , "CKK_TWOFISH " },
305 { CKK_GOSTR3410 , "CKK_GOSTR3410 " },
306 { CKK_GOSTR3411 , "CKK_GOSTR3411 " },
307 { CKK_GOST28147 , "CKK_GOST28147 " }
308 };
309
310 static enum_specs ck_mec_s[] = {
311 { CKM_RSA_PKCS_KEY_PAIR_GEN , "CKM_RSA_PKCS_KEY_PAIR_GEN " },
312 { CKM_RSA_PKCS , "CKM_RSA_PKCS " },
313 { CKM_RSA_9796 , "CKM_RSA_9796 " },
314 { CKM_RSA_X_509 , "CKM_RSA_X_509 " },
315 { CKM_MD2_RSA_PKCS , "CKM_MD2_RSA_PKCS " },
316 { CKM_MD5_RSA_PKCS , "CKM_MD5_RSA_PKCS " },
317 { CKM_SHA1_RSA_PKCS , "CKM_SHA1_RSA_PKCS " },
318 { CKM_SHA256_RSA_PKCS , "CKM_SHA256_RSA_PKCS " },
319 { CKM_SHA384_RSA_PKCS , "CKM_SHA384_RSA_PKCS " },
320 { CKM_SHA512_RSA_PKCS , "CKM_SHA512_RSA_PKCS " },
321 { CKM_RIPEMD128_RSA_PKCS , "CKM_RIPEMD128_RSA_PKCS " },
322 { CKM_RIPEMD160_RSA_PKCS , "CKM_RIPEMD160_RSA_PKCS " },
323 { CKM_RSA_PKCS_OAEP , "CKM_RSA_PKCS_OAEP " },
324 { CKM_RSA_X9_31_KEY_PAIR_GEN , "CKM_RSA_X9_31_KEY_PAIR_GEN " },
325 { CKM_RSA_X9_31 , "CKM_RSA_X9_31 " },
326 { CKM_SHA1_RSA_X9_31 , "CKM_SHA1_RSA_X9_31 " },
327 { CKM_RSA_PKCS_PSS , "CKM_RSA_PKCS_PSS " },
328 { CKM_SHA1_RSA_PKCS_PSS , "CKM_SHA1_RSA_PKCS_PSS " },
329 { CKM_SHA256_RSA_PKCS_PSS , "CKM_SHA256_RSA_PKCS_PSS " },
330 { CKM_SHA384_RSA_PKCS_PSS , "CKM_SHA384_RSA_PKCS_PSS " },
331 { CKM_SHA512_RSA_PKCS_PSS , "CKM_SHA512_RSA_PKCS_PSS " },
332 { CKM_DSA_KEY_PAIR_GEN , "CKM_DSA_KEY_PAIR_GEN " },
333 { CKM_DSA , "CKM_DSA " },
334 { CKM_DSA_SHA1 , "CKM_DSA_SHA1 " },
335 { CKM_DSA_SHA224 , "CKM_DSA_SHA224 " },
336 { CKM_DSA_SHA256 , "CKM_DSA_SHA256 " },
337 { CKM_DSA_SHA384 , "CKM_DSA_SHA384 " },
338 { CKM_DSA_SHA512 , "CKM_DSA_SHA512 " },
339 { CKM_DH_PKCS_KEY_PAIR_GEN , "CKM_DH_PKCS_KEY_PAIR_GEN " },
340 { CKM_DH_PKCS_DERIVE , "CKM_DH_PKCS_DERIVE " },
341 { CKM_X9_42_DH_KEY_PAIR_GEN , "CKM_X9_42_DH_KEY_PAIR_GEN " },
342 { CKM_X9_42_DH_DERIVE , "CKM_X9_42_DH_DERIVE " },
343 { CKM_X9_42_DH_HYBRID_DERIVE , "CKM_X9_42_DH_HYBRID_DERIVE " },
344 { CKM_X9_42_MQV_DERIVE , "CKM_X9_42_MQV_DERIVE " },
345 { CKM_RC2_KEY_GEN , "CKM_RC2_KEY_GEN " },
346 { CKM_RC2_ECB , "CKM_RC2_ECB " },
347 { CKM_RC2_CBC , "CKM_RC2_CBC " },
348 { CKM_RC2_MAC , "CKM_RC2_MAC " },
349 { CKM_RC2_MAC_GENERAL , "CKM_RC2_MAC_GENERAL " },
350 { CKM_RC2_CBC_PAD , "CKM_RC2_CBC_PAD " },
351 { CKM_RC4_KEY_GEN , "CKM_RC4_KEY_GEN " },
352 { CKM_RC4 , "CKM_RC4 " },
353 { CKM_DES_KEY_GEN , "CKM_DES_KEY_GEN " },
354 { CKM_DES_ECB , "CKM_DES_ECB " },
355 { CKM_DES_CBC , "CKM_DES_CBC " },
356 { CKM_DES_MAC , "CKM_DES_MAC " },
357 { CKM_DES_MAC_GENERAL , "CKM_DES_MAC_GENERAL " },
358 { CKM_DES_CBC_PAD , "CKM_DES_CBC_PAD " },
359 { CKM_DES2_KEY_GEN , "CKM_DES2_KEY_GEN " },
360 { CKM_DES3_KEY_GEN , "CKM_DES3_KEY_GEN " },
361 { CKM_DES3_ECB , "CKM_DES3_ECB " },
362 { CKM_DES3_CBC , "CKM_DES3_CBC " },
363 { CKM_DES3_MAC , "CKM_DES3_MAC " },
364 { CKM_DES3_MAC_GENERAL , "CKM_DES3_MAC_GENERAL " },
365 { CKM_DES3_CBC_PAD , "CKM_DES3_CBC_PAD " },
366 { CKM_DES3_CMAC , "CKM_DES3_CMAC " },
367 { CKM_CDMF_KEY_GEN , "CKM_CDMF_KEY_GEN " },
368 { CKM_CDMF_ECB , "CKM_CDMF_ECB " },
369 { CKM_CDMF_CBC , "CKM_CDMF_CBC " },
370 { CKM_CDMF_MAC , "CKM_CDMF_MAC " },
371 { CKM_CDMF_MAC_GENERAL , "CKM_CDMF_MAC_GENERAL " },
372 { CKM_CDMF_CBC_PAD , "CKM_CDMF_CBC_PAD " },
373 { CKM_MD2 , "CKM_MD2 " },
374 { CKM_MD2_HMAC , "CKM_MD2_HMAC " },
375 { CKM_MD2_HMAC_GENERAL , "CKM_MD2_HMAC_GENERAL " },
376 { CKM_MD5 , "CKM_MD5 " },
377 { CKM_MD5_HMAC , "CKM_MD5_HMAC " },
378 { CKM_MD5_HMAC_GENERAL , "CKM_MD5_HMAC_GENERAL " },
379 { CKM_SHA_1 , "CKM_SHA_1 " },
380 { CKM_SHA_1_HMAC , "CKM_SHA_1_HMAC " },
381 { CKM_SHA_1_HMAC_GENERAL , "CKM_SHA_1_HMAC_GENERAL " },
382 { CKM_SHA256 , "CKM_SHA256 " },
383 { CKM_SHA256_HMAC , "CKM_SHA256_HMAC " },
384 { CKM_SHA256_HMAC_GENERAL , "CKM_SHA256_HMAC_GENERAL " },
385 { CKM_SHA384 , "CKM_SHA384 " },
386 { CKM_SHA384_HMAC , "CKM_SHA384_HMAC " },
387 { CKM_SHA384_HMAC_GENERAL , "CKM_SHA384_HMAC_GENERAL " },
388 { CKM_SHA512 , "CKM_SHA512 " },
389 { CKM_SHA512_HMAC , "CKM_SHA512_HMAC " },
390 { CKM_SHA512_HMAC_GENERAL , "CKM_SHA512_HMAC_GENERAL " },
391 { CKM_RIPEMD128 , "CKM_RIPEMD128 " },
392 { CKM_RIPEMD128_HMAC , "CKM_RIPEMD128_HMAC " },
393 { CKM_RIPEMD128_HMAC_GENERAL , "CKM_RIPEMD128_HMAC_GENERAL " },
394 { CKM_RIPEMD160 , "CKM_RIPEMD160 " },
395 { CKM_RIPEMD160_HMAC , "CKM_RIPEMD160_HMAC " },
396 { CKM_RIPEMD160_HMAC_GENERAL , "CKM_RIPEMD160_HMAC_GENERAL " },
397 { CKM_SHA256 , "CKM_SHA256 " },
398 { CKM_SHA256_HMAC , "CKM_SHA256_HMAC " },
399 { CKM_SHA256_HMAC_GENERAL , "CKM_SHA256_HMAC_GENERAL " },
400 { CKM_SHA384 , "CKM_SHA384 " },
401 { CKM_SHA384_HMAC , "CKM_SHA384_HMAC " },
402 { CKM_SHA384_HMAC_GENERAL , "CKM_SHA384_HMAC_GENERAL " },
403 { CKM_CAST_KEY_GEN , "CKM_CAST_KEY_GEN " },
404 { CKM_CAST_ECB , "CKM_CAST_ECB " },
405 { CKM_CAST_CBC , "CKM_CAST_CBC " },
406 { CKM_CAST_MAC , "CKM_CAST_MAC " },
407 { CKM_CAST_MAC_GENERAL , "CKM_CAST_MAC_GENERAL " },
408 { CKM_CAST_CBC_PAD , "CKM_CAST_CBC_PAD " },
409 { CKM_CAST3_KEY_GEN , "CKM_CAST3_KEY_GEN " },
410 { CKM_CAST3_ECB , "CKM_CAST3_ECB " },
411 { CKM_CAST3_CBC , "CKM_CAST3_CBC " },
412 { CKM_CAST3_MAC , "CKM_CAST3_MAC " },
413 { CKM_CAST3_MAC_GENERAL , "CKM_CAST3_MAC_GENERAL " },
414 { CKM_CAST3_CBC_PAD , "CKM_CAST3_CBC_PAD " },
415 { CKM_CAST5_KEY_GEN , "CKM_CAST5_KEY_GEN " },
416 { CKM_CAST128_KEY_GEN , "CKM_CAST128_KEY_GEN " },
417 { CKM_CAST5_ECB , "CKM_CAST5_ECB " },
418 { CKM_CAST128_ECB , "CKM_CAST128_ECB " },
419 { CKM_CAST5_CBC , "CKM_CAST5_CBC " },
420 { CKM_CAST128_CBC , "CKM_CAST128_CBC " },
421 { CKM_CAST5_MAC , "CKM_CAST5_MAC " },
422 { CKM_CAST128_MAC , "CKM_CAST128_MAC " },
423 { CKM_CAST5_MAC_GENERAL , "CKM_CAST5_MAC_GENERAL " },
424 { CKM_CAST128_MAC_GENERAL , "CKM_CAST128_MAC_GENERAL " },
425 { CKM_CAST5_CBC_PAD , "CKM_CAST5_CBC_PAD " },
426 { CKM_CAST128_CBC_PAD , "CKM_CAST128_CBC_PAD " },
427 { CKM_RC5_KEY_GEN , "CKM_RC5_KEY_GEN " },
428 { CKM_RC5_ECB , "CKM_RC5_ECB " },
429 { CKM_RC5_CBC , "CKM_RC5_CBC " },
430 { CKM_RC5_MAC , "CKM_RC5_MAC " },
431 { CKM_RC5_MAC_GENERAL , "CKM_RC5_MAC_GENERAL " },
432 { CKM_RC5_CBC_PAD , "CKM_RC5_CBC_PAD " },
433 { CKM_IDEA_KEY_GEN , "CKM_IDEA_KEY_GEN " },
434 { CKM_IDEA_ECB , "CKM_IDEA_ECB " },
435 { CKM_IDEA_CBC , "CKM_IDEA_CBC " },
436 { CKM_IDEA_MAC , "CKM_IDEA_MAC " },
437 { CKM_IDEA_MAC_GENERAL , "CKM_IDEA_MAC_GENERAL " },
438 { CKM_IDEA_CBC_PAD , "CKM_IDEA_CBC_PAD " },
439 { CKM_GENERIC_SECRET_KEY_GEN , "CKM_GENERIC_SECRET_KEY_GEN " },
440 { CKM_CONCATENATE_BASE_AND_KEY , "CKM_CONCATENATE_BASE_AND_KEY " },
441 { CKM_CONCATENATE_BASE_AND_DATA, "CKM_CONCATENATE_BASE_AND_DATA" },
442 { CKM_CONCATENATE_DATA_AND_BASE, "CKM_CONCATENATE_DATA_AND_BASE" },
443 { CKM_XOR_BASE_AND_DATA , "CKM_XOR_BASE_AND_DATA " },
444 { CKM_EXTRACT_KEY_FROM_KEY , "CKM_EXTRACT_KEY_FROM_KEY " },
445 { CKM_SSL3_PRE_MASTER_KEY_GEN , "CKM_SSL3_PRE_MASTER_KEY_GEN " },
446 { CKM_SSL3_MASTER_KEY_DERIVE , "CKM_SSL3_MASTER_KEY_DERIVE " },
447 { CKM_SSL3_KEY_AND_MAC_DERIVE , "CKM_SSL3_KEY_AND_MAC_DERIVE " },
448 { CKM_SSL3_MASTER_KEY_DERIVE_DH, "CKM_SSL3_MASTER_KEY_DERIVE_DH" },
449 { CKM_TLS_PRE_MASTER_KEY_GEN , "CKM_TLS_PRE_MASTER_KEY_GEN " },
450 { CKM_TLS_MASTER_KEY_DERIVE , "CKM_TLS_MASTER_KEY_DERIVE " },
451 { CKM_TLS_KEY_AND_MAC_DERIVE , "CKM_TLS_KEY_AND_MAC_DERIVE " },
452 { CKM_TLS_MASTER_KEY_DERIVE_DH , "CKM_TLS_MASTER_KEY_DERIVE_DH " },
453 { CKM_SSL3_MD5_MAC , "CKM_SSL3_MD5_MAC " },
454 { CKM_SSL3_SHA1_MAC , "CKM_SSL3_SHA1_MAC " },
455 { CKM_MD5_KEY_DERIVATION , "CKM_MD5_KEY_DERIVATION " },
456 { CKM_MD2_KEY_DERIVATION , "CKM_MD2_KEY_DERIVATION " },
457 { CKM_SHA1_KEY_DERIVATION , "CKM_SHA1_KEY_DERIVATION " },
458 { CKM_PBE_MD2_DES_CBC , "CKM_PBE_MD2_DES_CBC " },
459 { CKM_PBE_MD5_DES_CBC , "CKM_PBE_MD5_DES_CBC " },
460 { CKM_PBE_MD5_CAST_CBC , "CKM_PBE_MD5_CAST_CBC " },
461 { CKM_PBE_MD5_CAST3_CBC , "CKM_PBE_MD5_CAST3_CBC " },
462 { CKM_PBE_MD5_CAST5_CBC , "CKM_PBE_MD5_CAST5_CBC " },
463 { CKM_PBE_MD5_CAST128_CBC , "CKM_PBE_MD5_CAST128_CBC " },
464 { CKM_PBE_SHA1_CAST5_CBC , "CKM_PBE_SHA1_CAST5_CBC " },
465 { CKM_PBE_SHA1_CAST128_CBC , "CKM_PBE_SHA1_CAST128_CBC " },
466 { CKM_PBE_SHA1_RC4_128 , "CKM_PBE_SHA1_RC4_128 " },
467 { CKM_PBE_SHA1_RC4_40 , "CKM_PBE_SHA1_RC4_40 " },
468 { CKM_PBE_SHA1_DES3_EDE_CBC , "CKM_PBE_SHA1_DES3_EDE_CBC " },
469 { CKM_PBE_SHA1_DES2_EDE_CBC , "CKM_PBE_SHA1_DES2_EDE_CBC " },
470 { CKM_PBE_SHA1_RC2_128_CBC , "CKM_PBE_SHA1_RC2_128_CBC " },
471 { CKM_PBE_SHA1_RC2_40_CBC , "CKM_PBE_SHA1_RC2_40_CBC " },
472 { CKM_PKCS5_PBKD2 , "CKM_PKCS5_PBKD2 " },
473 { CKM_PBA_SHA1_WITH_SHA1_HMAC , "CKM_PBA_SHA1_WITH_SHA1_HMAC " },
474 { CKM_KEY_WRAP_LYNKS , "CKM_KEY_WRAP_LYNKS " },
475 { CKM_KEY_WRAP_SET_OAEP , "CKM_KEY_WRAP_SET_OAEP " },
476 { CKM_SKIPJACK_KEY_GEN , "CKM_SKIPJACK_KEY_GEN " },
477 { CKM_SKIPJACK_ECB64 , "CKM_SKIPJACK_ECB64 " },
478 { CKM_SKIPJACK_CBC64 , "CKM_SKIPJACK_CBC64 " },
479 { CKM_SKIPJACK_OFB64 , "CKM_SKIPJACK_OFB64 " },
480 { CKM_SKIPJACK_CFB64 , "CKM_SKIPJACK_CFB64 " },
481 { CKM_SKIPJACK_CFB32 , "CKM_SKIPJACK_CFB32 " },
482 { CKM_SKIPJACK_CFB16 , "CKM_SKIPJACK_CFB16 " },
483 { CKM_SKIPJACK_CFB8 , "CKM_SKIPJACK_CFB8 " },
484 { CKM_SKIPJACK_WRAP , "CKM_SKIPJACK_WRAP " },
485 { CKM_SKIPJACK_PRIVATE_WRAP , "CKM_SKIPJACK_PRIVATE_WRAP " },
486 { CKM_SKIPJACK_RELAYX , "CKM_SKIPJACK_RELAYX " },
487 { CKM_KEA_KEY_PAIR_GEN , "CKM_KEA_KEY_PAIR_GEN " },
488 { CKM_KEA_KEY_DERIVE , "CKM_KEA_KEY_DERIVE " },
489 { CKM_FORTEZZA_TIMESTAMP , "CKM_FORTEZZA_TIMESTAMP " },
490 { CKM_BATON_KEY_GEN , "CKM_BATON_KEY_GEN " },
491 { CKM_BATON_ECB128 , "CKM_BATON_ECB128 " },
492 { CKM_BATON_ECB96 , "CKM_BATON_ECB96 " },
493 { CKM_BATON_CBC128 , "CKM_BATON_CBC128 " },
494 { CKM_BATON_COUNTER , "CKM_BATON_COUNTER " },
495 { CKM_BATON_SHUFFLE , "CKM_BATON_SHUFFLE " },
496 { CKM_BATON_WRAP , "CKM_BATON_WRAP " },
497 { CKM_EC_KEY_PAIR_GEN , "CKM_EC_KEY_PAIR_GEN " },
498 { CKM_ECDSA , "CKM_ECDSA " },
499 { CKM_ECDSA_SHA1 , "CKM_ECDSA_SHA1 " },
500 { CKM_ECDH1_DERIVE , "CKM_ECDH1_DERIVE " },
501 { CKM_ECDH1_COFACTOR_DERIVE , "CKM_ECDH1_COFACTOR_DERIVE " },
502 { CKM_ECMQV_DERIVE , "CKM_ECMQV_DERIVE " },
503 { CKM_EDDSA , "CKM_EDDSA " },
504 { CKM_XEDDSA , "CKM_XEDDSA " },
505 { CKM_JUNIPER_KEY_GEN , "CKM_JUNIPER_KEY_GEN " },
506 { CKM_JUNIPER_ECB128 , "CKM_JUNIPER_ECB128 " },
507 { CKM_JUNIPER_CBC128 , "CKM_JUNIPER_CBC128 " },
508 { CKM_JUNIPER_COUNTER , "CKM_JUNIPER_COUNTER " },
509 { CKM_JUNIPER_SHUFFLE , "CKM_JUNIPER_SHUFFLE " },
510 { CKM_JUNIPER_WRAP , "CKM_JUNIPER_WRAP " },
511 { CKM_FASTHASH , "CKM_FASTHASH " },
512 { CKM_AES_KEY_GEN , "CKM_AES_KEY_GEN " },
513 { CKM_AES_ECB , "CKM_AES_ECB " },
514 { CKM_AES_CBC , "CKM_AES_CBC " },
515 { CKM_AES_MAC , "CKM_AES_MAC " },
516 { CKM_AES_MAC_GENERAL , "CKM_AES_MAC_GENERAL " },
517 { CKM_AES_CBC_PAD , "CKM_AES_CBC_PAD " },
518 { CKM_AES_CTR , "CKM_AES_CTR " },
519 { CKM_AES_GCM , "CKM_AES_GCM " },
520 { CKM_AES_CCM , "CKM_AES_CCM " },
521 { CKM_AES_CMAC , "CKM_AES_CMAC " },
522 { CKM_AES_CTS , "CKM_AES_CTS " },
523 { CKM_BLOWFISH_KEY_GEN , "CKM_BLOWFISH_KEY_GEN " },
524 { CKM_BLOWFISH_CBC , "CKM_BLOWFISH_CBC " },
525 { CKM_TWOFISH_KEY_GEN , "CKM_TWOFISH_KEY_GEN " },
526 { CKM_TWOFISH_CBC , "CKM_TWOFISH_CBC " },
527 { CKM_DES_ECB_ENCRYPT_DATA , "CKM_DES_ECB_ENCRYPT_DATA " },
528 { CKM_DES_CBC_ENCRYPT_DATA , "CKM_DES_CBC_ENCRYPT_DATA " },
529 { CKM_DES3_ECB_ENCRYPT_DATA , "CKM_DES3_ECB_ENCRYPT_DATA " },
530 { CKM_DES3_CBC_ENCRYPT_DATA , "CKM_DES3_CBC_ENCRYPT_DATA " },
531 { CKM_AES_ECB_ENCRYPT_DATA , "CKM_AES_ECB_ENCRYPT_DATA " },
532 { CKM_AES_CBC_ENCRYPT_DATA , "CKM_AES_CBC_ENCRYPT_DATA " },
533 { CKM_GOSTR3410_KEY_PAIR_GEN , "CKM_GOSTR3410_KEY_PAIR_GEN " },
534 { CKM_GOSTR3410 , "CKM_GOSTR3410 " },
535 { CKM_GOSTR3410_WITH_GOSTR3411 , "CKM_GOSTR3410_WITH_GOSTR3411 " },
536 { CKM_GOSTR3410_KEY_WRAP , "CKM_GOSTR3410_KEY_WRAP " },
537 { CKM_GOSTR3410_DERIVE , "CKM_GOSTR3410_DERIVE " },
538 { CKM_GOSTR3411 , "CKM_GOSTR3411 " },
539 { CKM_GOSTR3411_HMAC , "CKM_GOSTR3411_HMAC " },
540 { CKM_GOST28147_KEY_GEN , "CKM_GOST28147_KEY_GEN " },
541 { CKM_GOST28147_ECB , "CKM_GOST28147_ECB " },
542 { CKM_GOST28147 , "CKM_GOST28147 " },
543 { CKM_GOST28147_MAC , "CKM_GOST28147_MAC " },
544 { CKM_GOST28147_KEY_WRAP , "CKM_GOST28147_KEY_WRAP " },
545 { CKM_DSA_PARAMETER_GEN , "CKM_DSA_PARAMETER_GEN " },
546 { CKM_DH_PKCS_PARAMETER_GEN , "CKM_DH_PKCS_PARAMETER_GEN " },
547 { CKM_X9_42_DH_PARAMETER_GEN , "CKM_X9_42_DH_PARAMETER_GEN " },
548 { CKM_AES_KEY_WRAP , "CKM_AES_KEY_WRAP " },
549 { CKM_VENDOR_DEFINED , "CKM_VENDOR_DEFINED " }
550 };
551
552 static enum_specs ck_mgf_s[] = {
553 { CKG_MGF1_SHA1 , "CKG_MGF1_SHA1 " },
554 { CKG_MGF1_SHA224, "CKG_MGF1_SHA224" },
555 { CKG_MGF1_SHA256, "CKG_MGF1_SHA256" },
556 { CKG_MGF1_SHA384, "CKG_MGF1_SHA384" },
557 { CKG_MGF1_SHA512, "CKG_MGF1_SHA512" },
558 };
559
560 static enum_specs ck_err_s[] = {
561 { CKR_OK, "CKR_OK" },
562 { CKR_CANCEL, "CKR_CANCEL" },
563 { CKR_HOST_MEMORY, "CKR_HOST_MEMORY" },
564 { CKR_SLOT_ID_INVALID, "CKR_SLOT_ID_INVALID" },
565 { CKR_GENERAL_ERROR, "CKR_GENERAL_ERROR" },
566 { CKR_FUNCTION_FAILED, "CKR_FUNCTION_FAILED" },
567 { CKR_ARGUMENTS_BAD, "CKR_ARGUMENTS_BAD" },
568 { CKR_NO_EVENT, "CKR_NO_EVENT" },
569 { CKR_NEED_TO_CREATE_THREADS, "CKR_NEED_TO_CREATE_THREADS" },
570 { CKR_CANT_LOCK, "CKR_CANT_LOCK" },
571 { CKR_ATTRIBUTE_READ_ONLY, "CKR_ATTRIBUTE_READ_ONLY" },
572 { CKR_ATTRIBUTE_SENSITIVE, "CKR_ATTRIBUTE_SENSITIVE" },
573 { CKR_ATTRIBUTE_TYPE_INVALID, "CKR_ATTRIBUTE_TYPE_INVALID" },
574 { CKR_ATTRIBUTE_VALUE_INVALID, "CKR_ATTRIBUTE_VALUE_INVALID" },
575 { CKR_DATA_INVALID, "CKR_DATA_INVALID" },
576 { CKR_DATA_LEN_RANGE, "CKR_DATA_LEN_RANGE" },
577 { CKR_DEVICE_ERROR, "CKR_DEVICE_ERROR" },
578 { CKR_DEVICE_MEMORY, "CKR_DEVICE_MEMORY" },
579 { CKR_DEVICE_REMOVED, "CKR_DEVICE_REMOVED" },
580 { CKR_ENCRYPTED_DATA_INVALID, "CKR_ENCRYPTED_DATA_INVALID" },
581 { CKR_ENCRYPTED_DATA_LEN_RANGE, "CKR_ENCRYPTED_DATA_LEN_RANGE" },
582 { CKR_FUNCTION_CANCELED, "CKR_FUNCTION_CANCELED" },
583 { CKR_FUNCTION_NOT_PARALLEL, "CKR_FUNCTION_NOT_PARALLEL" },
584 { CKR_FUNCTION_NOT_SUPPORTED, "CKR_FUNCTION_NOT_SUPPORTED" },
585 { CKR_KEY_HANDLE_INVALID, "CKR_KEY_HANDLE_INVALID" },
586 { CKR_KEY_SIZE_RANGE, "CKR_KEY_SIZE_RANGE" },
587 { CKR_KEY_TYPE_INCONSISTENT, "CKR_KEY_TYPE_INCONSISTENT" },
588 { CKR_KEY_NOT_NEEDED, "CKR_KEY_NOT_NEEDED" },
589 { CKR_KEY_CHANGED, "CKR_KEY_CHANGED" },
590 { CKR_KEY_NEEDED, "CKR_KEY_NEEDED" },
591 { CKR_KEY_INDIGESTIBLE, "CKR_KEY_INDIGESTIBLE" },
592 { CKR_KEY_FUNCTION_NOT_PERMITTED, "CKR_KEY_FUNCTION_NOT_PERMITTED" },
593 { CKR_KEY_NOT_WRAPPABLE, "CKR_KEY_NOT_WRAPPABLE" },
594 { CKR_KEY_UNEXTRACTABLE, "CKR_KEY_UNEXTRACTABLE" },
595 { CKR_MECHANISM_INVALID, "CKR_MECHANISM_INVALID" },
596 { CKR_MECHANISM_PARAM_INVALID, "CKR_MECHANISM_PARAM_INVALID" },
597 { CKR_OBJECT_HANDLE_INVALID, "CKR_OBJECT_HANDLE_INVALID" },
598 { CKR_OPERATION_ACTIVE, "CKR_OPERATION_ACTIVE" },
599 { CKR_OPERATION_NOT_INITIALIZED, "CKR_OPERATION_NOT_INITIALIZED" },
600 { CKR_PIN_INCORRECT, "CKR_PIN_INCORRECT" },
601 { CKR_PIN_INVALID, "CKR_PIN_INVALID" },
602 { CKR_PIN_LEN_RANGE, "CKR_PIN_LEN_RANGE" },
603 { CKR_PIN_EXPIRED, "CKR_PIN_EXPIRED" },
604 { CKR_PIN_LOCKED, "CKR_PIN_LOCKED" },
605 { CKR_SESSION_CLOSED, "CKR_SESSION_CLOSED" },
606 { CKR_SESSION_COUNT, "CKR_SESSION_COUNT" },
607 { CKR_SESSION_HANDLE_INVALID, "CKR_SESSION_HANDLE_INVALID" },
608 { CKR_SESSION_PARALLEL_NOT_SUPPORTED, "CKR_SESSION_PARALLEL_NOT_SUPPORTED" },
609 { CKR_SESSION_READ_ONLY, "CKR_SESSION_READ_ONLY" },
610 { CKR_SESSION_EXISTS, "CKR_SESSION_EXISTS" },
611 { CKR_SESSION_READ_ONLY_EXISTS, "CKR_SESSION_READ_ONLY_EXISTS" },
612 { CKR_SESSION_READ_WRITE_SO_EXISTS, "CKR_SESSION_READ_WRITE_SO_EXISTS" },
613 { CKR_SIGNATURE_INVALID, "CKR_SIGNATURE_INVALID" },
614 { CKR_SIGNATURE_LEN_RANGE, "CKR_SIGNATURE_LEN_RANGE" },
615 { CKR_TEMPLATE_INCOMPLETE, "CKR_TEMPLATE_INCOMPLETE" },
616 { CKR_TEMPLATE_INCONSISTENT, "CKR_TEMPLATE_INCONSISTENT" },
617 { CKR_TOKEN_NOT_PRESENT, "CKR_TOKEN_NOT_PRESENT" },
618 { CKR_TOKEN_NOT_RECOGNIZED, "CKR_TOKEN_NOT_RECOGNIZED" },
619 { CKR_TOKEN_WRITE_PROTECTED, "CKR_TOKEN_WRITE_PROTECTED" },
620 { CKR_UNWRAPPING_KEY_HANDLE_INVALID, "CKR_UNWRAPPING_KEY_HANDLE_INVALID" },
621 { CKR_UNWRAPPING_KEY_SIZE_RANGE, "CKR_UNWRAPPING_KEY_SIZE_RANGE" },
622 { CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT, "CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT" },
623 { CKR_USER_ALREADY_LOGGED_IN, "CKR_USER_ALREADY_LOGGED_IN" },
624 { CKR_USER_NOT_LOGGED_IN, "CKR_USER_NOT_LOGGED_IN" },
625 { CKR_USER_PIN_NOT_INITIALIZED, "CKR_USER_PIN_NOT_INITIALIZED" },
626 { CKR_USER_TYPE_INVALID, "CKR_USER_TYPE_INVALID" },
627 { CKR_USER_ANOTHER_ALREADY_LOGGED_IN, "CKR_USER_ANOTHER_ALREADY_LOGGED_IN" },
628 { CKR_USER_TOO_MANY_TYPES, "CKR_USER_TOO_MANY_TYPES" },
629 { CKR_WRAPPED_KEY_INVALID, "CKR_WRAPPED_KEY_INVALID" },
630 { CKR_WRAPPED_KEY_LEN_RANGE, "CKR_WRAPPED_KEY_LEN_RANGE" },
631 { CKR_WRAPPING_KEY_HANDLE_INVALID, "CKR_WRAPPING_KEY_HANDLE_INVALID" },
632 { CKR_WRAPPING_KEY_SIZE_RANGE, "CKR_WRAPPING_KEY_SIZE_RANGE" },
633 { CKR_WRAPPING_KEY_TYPE_INCONSISTENT, "CKR_WRAPPING_KEY_TYPE_INCONSISTENT" },
634 { CKR_RANDOM_SEED_NOT_SUPPORTED, "CKR_RANDOM_SEED_NOT_SUPPORTED" },
635 { CKR_RANDOM_NO_RNG, "CKR_RANDOM_NO_RNG" },
636 { CKR_DOMAIN_PARAMS_INVALID, "CKR_DOMAIN_PARAMS_INVALID" },
637 { CKR_BUFFER_TOO_SMALL, "CKR_BUFFER_TOO_SMALL" },
638 { CKR_SAVED_STATE_INVALID, "CKR_SAVED_STATE_INVALID" },
639 { CKR_INFORMATION_SENSITIVE, "CKR_INFORMATION_SENSITIVE" },
640 { CKR_STATE_UNSAVEABLE, "CKR_STATE_UNSAVEABLE" },
641 { CKR_CRYPTOKI_NOT_INITIALIZED, "CKR_CRYPTOKI_NOT_INITIALIZED" },
642 { CKR_CRYPTOKI_ALREADY_INITIALIZED, "CKR_CRYPTOKI_ALREADY_INITIALIZED" },
643 { CKR_MUTEX_BAD, "CKR_MUTEX_BAD" },
644 { CKR_MUTEX_NOT_LOCKED, "CKR_MUTEX_NOT_LOCKED" },
645 { CKR_VENDOR_DEFINED, "CKR_VENDOR_DEFINED" }
646 };
647
648 static enum_specs ck_usr_s[] = {
649 { CKU_SO, "CKU_SO" },
650 { CKU_USER, "CKU_USER" },
651 { CKU_CONTEXT_SPECIFIC, "CKU_CONTEXT_SPECIFIC" }
652 };
653
654 static enum_specs ck_sta_s[] = {
655 { CKS_RO_PUBLIC_SESSION, "CKS_RO_PUBLIC_SESSION" },
656 { CKS_RO_USER_FUNCTIONS, "CKS_RO_USER_FUNCTIONS" },
657 { CKS_RW_PUBLIC_SESSION, "CKS_RW_PUBLIC_SESSION" },
658 { CKS_RW_USER_FUNCTIONS, "CKS_RW_USER_FUNCTIONS" },
659 { CKS_RW_SO_FUNCTIONS, "CKS_RW_SO_FUNCTIONS" }
660 };
661
662 static enum_specs ck_ckd_s[] = {
663 { CKD_NULL, "CKD_NULL" },
664 { CKD_SHA1_KDF, "CKD_SHA1_KDF" },
665 { CKD_SHA224_KDF, "CKD_SHA224_KDF" },
666 { CKD_SHA256_KDF, "CKD_SHA256_KDF" },
667 { CKD_SHA384_KDF, "CKD_SHA384_KDF" },
668 { CKD_SHA512_KDF, "CKD_SHA512_KDF" },
669 };
670
671 #define SZ_SPECS sizeof(enum_specs)
672
673 enum_spec ck_types[] = {
674 { OBJ_T, ck_cls_s, sizeof(ck_cls_s) / SZ_SPECS, "CK_OBJECT_CLASS" },
675 { PROFILE_T, ck_profile_s, sizeof(ck_profile_s)/SZ_SPECS, "CK_PROFILE"},
676 { KEY_T, ck_key_s, sizeof(ck_key_s) / SZ_SPECS, "CK_KEY_TYPE" },
677 { CRT_T, ck_crt_s, sizeof(ck_crt_s) / SZ_SPECS, "CK_CERTIFICATE_TYPE" },
678 { MEC_T, ck_mec_s, sizeof(ck_mec_s) / SZ_SPECS, "CK_MECHANISM_TYPE" },
679 { MGF_T, ck_mgf_s, sizeof(ck_mgf_s) / SZ_SPECS, "CK_RSA_PKCS_MGF_TYPE"},
680 { USR_T, ck_usr_s, sizeof(ck_usr_s) / SZ_SPECS, "CK_USER_TYPE" },
681 { STA_T, ck_sta_s, sizeof(ck_sta_s) / SZ_SPECS, "CK_STATE" },
682 { CKD_T, ck_ckd_s, sizeof(ck_ckd_s) / SZ_SPECS, "CK_EC_KDF_TYPE" },
683 { RV_T, ck_err_s, sizeof(ck_err_s) / SZ_SPECS, "CK_RV" },
684 };
685
686 static enum_spec ck_key_t[] = { { KEY_T, ck_key_s, sizeof(ck_key_s) / SZ_SPECS, "CK_KEY_TYPE" } };
687 static enum_spec ck_cls_t[] = { { OBJ_T, ck_cls_s, sizeof(ck_cls_s) / SZ_SPECS, "CK_OBJECT_CLASS" } };
688 static enum_spec ck_crt_t[] = { { CRT_T, ck_crt_s, sizeof(ck_crt_s) / SZ_SPECS, "CK_CERTIFICATE_TYPE" } };
689 static enum_spec ck_profile_t[] = { { PROFILE_T, ck_profile_s, sizeof(ck_profile_s) / SZ_SPECS, "CK_PROFILE" } };
690
691 type_spec ck_attribute_specs[] = {
692 { CKA_CLASS , "CKA_CLASS ", print_enum, ck_cls_t },
693 { CKA_TOKEN , "CKA_TOKEN ", print_boolean, NULL },
694 { CKA_PRIVATE , "CKA_PRIVATE ", print_boolean, NULL },
695 { CKA_LABEL , "CKA_LABEL ", print_print, NULL },
696 { CKA_APPLICATION , "CKA_APPLICATION ", print_print, NULL },
697 { CKA_VALUE , "CKA_VALUE ", print_generic, NULL },
698 { CKA_OBJECT_ID , "CKA_OBJECT_ID ", print_generic, NULL },
699 { CKA_CERTIFICATE_TYPE , "CKA_CERTIFICATE_TYPE ", print_enum, ck_crt_t },
700 #ifdef ENABLE_OPENSSL
701 { CKA_ISSUER , "CKA_ISSUER ", print_dn, NULL },
702 #else
703 { CKA_ISSUER , "CKA_ISSUER ", print_generic, NULL },
704 #endif
705 { CKA_SERIAL_NUMBER , "CKA_SERIAL_NUMBER ", print_generic, NULL },
706 #ifdef ENABLE_OPENSSL
707 { CKA_AC_ISSUER , "CKA_AC_ISSUER ", print_dn, NULL },
708 #else
709 { CKA_AC_ISSUER , "CKA_AC_ISSUER ", print_generic, NULL },
710 #endif
711 { CKA_OWNER , "CKA_OWNER ", print_generic, NULL },
712 { CKA_ATTR_TYPES , "CKA_ATTR_TYPES ", print_generic, NULL },
713 { CKA_TRUSTED , "CKA_TRUSTED ", print_generic, NULL },
714 { CKA_CERTIFICATE_CATEGORY, "CKA_CERTIFICATE_CATEGORY ", print_generic, NULL },
715 { CKA_JAVA_MIDP_SECURITY_DOMAIN, "CKA_JAVA_MIDP_SECURITY_DOMAIN ", print_generic, NULL },
716 { CKA_URL , "CKA_URL ", print_generic, NULL },
717 { CKA_HASH_OF_SUBJECT_PUBLIC_KEY, "CKA_HASH_OF_SUBJECT_PUBLIC_KEY ", print_generic, NULL },
718 { CKA_HASH_OF_ISSUER_PUBLIC_KEY, "CKA_HASH_OF_ISSUER_PUBLIC_KEY ", print_generic, NULL },
719 { CKA_CHECK_VALUE , "CKA_CHECK_VALUE ", print_generic, NULL },
720 { CKA_KEY_TYPE , "CKA_KEY_TYPE ", print_enum, ck_key_t },
721 #ifdef ENABLE_OPENSSL
722 { CKA_SUBJECT , "CKA_SUBJECT ", print_dn, NULL },
723 #else
724 { CKA_SUBJECT , "CKA_SUBJECT ", print_generic, NULL },
725 #endif
726 { CKA_ID , "CKA_ID ", print_generic, NULL },
727 { CKA_SENSITIVE , "CKA_SENSITIVE ", print_boolean, NULL },
728 { CKA_ENCRYPT , "CKA_ENCRYPT ", print_boolean, NULL },
729 { CKA_DECRYPT , "CKA_DECRYPT ", print_boolean, NULL },
730 { CKA_WRAP , "CKA_WRAP ", print_boolean, NULL },
731 { CKA_UNWRAP , "CKA_UNWRAP ", print_boolean, NULL },
732 { CKA_SIGN , "CKA_SIGN ", print_boolean, NULL },
733 { CKA_SIGN_RECOVER , "CKA_SIGN_RECOVER ", print_boolean, NULL },
734 { CKA_VERIFY , "CKA_VERIFY ", print_boolean, NULL },
735 { CKA_VERIFY_RECOVER , "CKA_VERIFY_RECOVER ", print_boolean, NULL },
736 { CKA_DERIVE , "CKA_DERIVE ", print_boolean, NULL },
737 { CKA_START_DATE , "CKA_START_DATE ", print_generic, NULL },
738 { CKA_END_DATE , "CKA_END_DATE ", print_generic, NULL },
739 { CKA_MODULUS , "CKA_MODULUS ", print_generic, NULL },
740 { CKA_MODULUS_BITS , "CKA_MODULUS_BITS ", print_generic, NULL },
741 { CKA_PUBLIC_EXPONENT , "CKA_PUBLIC_EXPONENT ", print_generic, NULL },
742 { CKA_PRIVATE_EXPONENT , "CKA_PRIVATE_EXPONENT ", print_generic, NULL },
743 { CKA_PRIME_1 , "CKA_PRIME_1 ", print_generic, NULL },
744 { CKA_PRIME_2 , "CKA_PRIME_2 ", print_generic, NULL },
745 { CKA_EXPONENT_1 , "CKA_EXPONENT_1 ", print_generic, NULL },
746 { CKA_EXPONENT_2 , "CKA_EXPONENT_2 ", print_generic, NULL },
747 { CKA_COEFFICIENT , "CKA_COEFFICIENT ", print_generic, NULL },
748 { CKA_PRIME , "CKA_PRIME ", print_generic, NULL },
749 { CKA_SUBPRIME , "CKA_SUBPRIME ", print_generic, NULL },
750 { CKA_BASE , "CKA_BASE ", print_generic, NULL },
751 { CKA_PRIME_BITS , "CKA_PRIME_BITS ", print_generic, NULL },
752 { CKA_SUB_PRIME_BITS , "CKA_SUB_PRIME_BITS ", print_generic, NULL },
753 { CKA_VALUE_BITS , "CKA_VALUE_BITS ", print_generic, NULL },
754 { CKA_VALUE_LEN , "CKA_VALUE_LEN ", print_generic, NULL },
755 { CKA_EXTRACTABLE , "CKA_EXTRACTABLE ", print_boolean, NULL },
756 { CKA_LOCAL , "CKA_LOCAL ", print_boolean, NULL },
757 { CKA_NEVER_EXTRACTABLE , "CKA_NEVER_EXTRACTABLE", print_boolean, NULL },
758 { CKA_ALWAYS_SENSITIVE , "CKA_ALWAYS_SENSITIVE ", print_boolean, NULL },
759 { CKA_KEY_GEN_MECHANISM , "CKA_KEY_GEN_MECHANISM", print_boolean, NULL },
760 { CKA_MODIFIABLE , "CKA_MODIFIABLE ", print_boolean, NULL },
761 { CKA_EC_PARAMS , "CKA_EC_PARAMS ", print_generic, NULL },
762 { CKA_ECDSA_PARAMS , "CKA_ECDSA_PARAMS ", print_generic, NULL },
763 { CKA_EC_POINT , "CKA_EC_POINT ", print_generic, NULL },
764 { CKA_SECONDARY_AUTH , "CKA_SECONDARY_AUTH ", print_generic, NULL },
765 { CKA_AUTH_PIN_FLAGS , "CKA_AUTH_PIN_FLAGS ", print_generic, NULL },
766 { CKA_ALWAYS_AUTHENTICATE, "CKA_ALWAYS_AUTHENTICATE ", print_boolean, NULL },
767 { CKA_WRAP_WITH_TRUSTED , "CKA_WRAP_WITH_TRUSTED ", print_generic, NULL },
768 { CKA_WRAP_TEMPLATE , "CKA_WRAP_TEMPLATE ", print_generic, NULL },
769 { CKA_UNWRAP_TEMPLATE , "CKA_UNWRAP_TEMPLATE ", print_generic, NULL },
770 { CKA_OTP_FORMAT , "CKA_OTP_FORMAT ", print_generic, NULL },
771 { CKA_OTP_LENGTH , "CKA_OTP_LENGTH ", print_generic, NULL },
772 { CKA_OTP_TIME_INTERVAL , "CKA_OTP_TIME_INTERVAL ", print_generic, NULL },
773 { CKA_OTP_USER_FRIENDLY_MODE, "CKA_OTP_USER_FRIENDLY_MODE ", print_boolean, NULL },
774 { CKA_OTP_CHALLENGE_REQUIREMENT, "CKA_OTP_CHALLENGE_REQUIREMENT ", print_generic, NULL },
775 { CKA_OTP_TIME_REQUIREMENT, "CKA_OTP_TIME_REQUIREMENT ", print_generic, NULL },
776 { CKA_OTP_COUNTER_REQUIREMENT, "CKA_OTP_COUNTER_REQUIREMENT ", print_generic, NULL },
777 { CKA_OTP_PIN_REQUIREMENT, "CKA_OTP_PIN_REQUIREMENT ", print_generic, NULL },
778 { CKA_OTP_COUNTER , "CKA_OTP_COUNTER ", print_generic, NULL },
779 { CKA_OTP_TIME , "CKA_OTP_TIME ", print_print, NULL },
780 { CKA_OTP_USER_IDENTIFIER, "CKA_OTP_USER_IDENTIFIER ", print_print, NULL },
781 { CKA_OTP_SERVICE_IDENTIFIER, "CKA_OTP_SERVICE_IDENTIFIER ", print_print, NULL },
782 { CKA_OTP_SERVICE_LOGO , "CKA_OTP_SERVICE_LOGO ", print_generic, NULL },
783 { CKA_OTP_SERVICE_LOGO_TYPE, "CKA_OTP_SERVICE_LOGO_TYPE ", print_print, NULL },
784 { CKA_GOSTR3410_PARAMS , "CKA_GOSTR3410_PARAMS ", print_generic, NULL },
785 { CKA_GOSTR3411_PARAMS , "CKA_GOSTR3411_PARAMS ", print_generic, NULL },
786 { CKA_GOST28147_PARAMS , "CKA_GOST28147_PARAMS ", print_generic, NULL },
787 { CKA_HW_FEATURE_TYPE , "CKA_HW_FEATURE_TYPE ", print_generic, NULL },
788 { CKA_RESET_ON_INIT , "CKA_RESET_ON_INIT ", print_generic, NULL },
789 { CKA_HAS_RESET , "CKA_HAS_RESET ", print_generic, NULL },
790 { CKA_PIXEL_X , "CKA_PIXEL_X ", print_generic, NULL },
791 { CKA_PIXEL_Y , "CKA_PIXEL_Y ", print_generic, NULL },
792 { CKA_RESOLUTION , "CKA_RESOLUTION ", print_generic, NULL },
793 { CKA_CHAR_ROWS , "CKA_CHAR_ROWS ", print_generic, NULL },
794 { CKA_CHAR_COLUMNS , "CKA_CHAR_COLUMNS ", print_generic, NULL },
795 { CKA_COLOR , "CKA_COLOR ", print_generic, NULL },
796 { CKA_BITS_PER_PIXEL , "CKA_BITS_PER_PIXEL ", print_generic, NULL },
797 { CKA_CHAR_SETS , "CKA_CHAR_SETS ", print_generic, NULL },
798 { CKA_ENCODING_METHODS , "CKA_ENCODING_METHODS ", print_generic, NULL },
799 { CKA_MIME_TYPES , "CKA_MIME_TYPES ", print_generic, NULL },
800 { CKA_MECHANISM_TYPE , "CKA_MECHANISM_TYPE ", print_generic, NULL },
801 { CKA_PROFILE_ID , "CKA_PROFILE_ID ", print_enum, ck_profile_t },
802 { CKA_REQUIRED_CMS_ATTRIBUTES, "CKA_REQUIRED_CMS_ATTRIBUTES ", print_generic, NULL },
803 { CKA_DEFAULT_CMS_ATTRIBUTES, "CKA_DEFAULT_CMS_ATTRIBUTES ", print_generic, NULL },
804 { CKA_SUPPORTED_CMS_ATTRIBUTES, "CKA_SUPPORTED_CMS_ATTRIBUTES ", print_generic, NULL },
805 { CKA_ALLOWED_MECHANISMS, "CKA_ALLOWED_MECHANISMS ", print_generic, NULL },
806 { CKA_NETSCAPE_URL, "CKA_NETSCAPE_URL(Netsc) ", print_generic, NULL },
807 { CKA_NETSCAPE_EMAIL, "CKA_NETSCAPE_EMAIL(Netsc) ", print_generic, NULL },
808 { CKA_NETSCAPE_SMIME_INFO, "CKA_NETSCAPE_SMIME_INFO(Netsc) ", print_boolean, NULL },
809 { CKA_NETSCAPE_SMIME_TIMESTAMP, "CKA_NETSCAPE_SMIME_TIMESTAMP(Netsc) ", print_generic, NULL },
810 { CKA_NETSCAPE_PKCS8_SALT, "CKA_NETSCAPE_PKCS8_SALT(Netsc) ", print_generic, NULL },
811 { CKA_NETSCAPE_PASSWORD_CHECK, "CKA_NETSCAPE_PASSWORD_CHECK(Netsc) ", print_generic, NULL },
812 { CKA_NETSCAPE_EXPIRES, "CKA_NETSCAPE_EXPIRES(Netsc) ", print_generic, NULL },
813 { CKA_NETSCAPE_KRL, "CKA_NETSCAPE_KRL(Netsc) ", print_generic, NULL },
814 { CKA_NETSCAPE_PQG_COUNTER, "CKA_NETSCAPE_PQG_COUNTER(Netsc) ", print_generic, NULL },
815 { CKA_NETSCAPE_PQG_SEED, "CKA_NETSCAPE_PQG_SEED(Netsc) ", print_generic, NULL },
816 { CKA_NETSCAPE_PQG_H, "CKA_NETSCAPE_PQG_H(Netsc) ", print_generic, NULL },
817 { CKA_NETSCAPE_PQG_SEED_BITS, "CKA_NETSCAPE_PQG_SEED_BITS(Netsc) ", print_generic, NULL },
818 { CKA_TRUST_DIGITAL_SIGNATURE, "CKA_TRUST_DIGITAL_SIGNATURE(Netsc) ", print_boolean, NULL },
819 { CKA_TRUST_NON_REPUDIATION, "CKA_TRUST_NON_REPUDIATION(Netsc) ", print_boolean, NULL },
820 { CKA_TRUST_KEY_ENCIPHERMENT, "CKA_TRUST_KEY_ENCIPHERMENT(Netsc) ", print_boolean, NULL },
821 { CKA_TRUST_DATA_ENCIPHERMENT, "CKA_TRUST_DATA_ENCIPHERMENT(Netsc) ", print_boolean, NULL },
822 { CKA_TRUST_KEY_AGREEMENT, "CKA_TRUST_KEY_AGREEMENT(Netsc) ", print_boolean, NULL },
823 { CKA_TRUST_KEY_CERT_SIGN, "CKA_TRUST_KEY_CERT_SIGN(Netsc) ", print_boolean, NULL },
824 { CKA_TRUST_CRL_SIGN, "CKA_TRUST_CRL_SIGN(Netsc) ", print_boolean, NULL },
825 { CKA_TRUST_SERVER_AUTH, "CKA_TRUST_SERVER_AUTH(Netsc) ", print_boolean, NULL },
826 { CKA_TRUST_CLIENT_AUTH, "CKA_TRUST_CLIENT_AUTH(Netsc) ", print_boolean, NULL },
827 { CKA_TRUST_CODE_SIGNING, "CKA_TRUST_CODE_SIGNING(Netsc) ", print_boolean, NULL },
828 { CKA_TRUST_EMAIL_PROTECTION, "CKA_TRUST_EMAIL_PROTECTION(Netsc) ", print_boolean, NULL },
829 { CKA_TRUST_IPSEC_END_SYSTEM, "CKA_TRUST_IPSEC_END_SYSTEM(Netsc) ", print_boolean, NULL },
830 { CKA_TRUST_IPSEC_TUNNEL, "CKA_TRUST_IPSEC_TUNNEL(Netsc) ", print_boolean, NULL },
831 { CKA_TRUST_IPSEC_USER, "CKA_TRUST_IPSEC_USER(Netsc) ", print_boolean, NULL },
832 { CKA_TRUST_TIME_STAMPING, "CKA_TRUST_TIME_STAMPING(Netsc) ", print_boolean, NULL },
833 { CKA_CERT_SHA1_HASH, "CKA_CERT_SHA1_HASH(Netsc) ", print_generic, NULL },
834 { CKA_CERT_MD5_HASH, "CKA_CERT_MD5_HASH(Netsc) ", print_generic, NULL },
835 };
836
837 CK_ULONG ck_attribute_num = sizeof(ck_attribute_specs)/sizeof(type_spec);
838
839
840 const char *
lookup_enum_spec(enum_spec * spec,CK_ULONG value)841 lookup_enum_spec(enum_spec *spec, CK_ULONG value)
842 {
843 CK_ULONG i;
844
845 for(i = 0; i < spec->size; i++)
846 if(spec->specs[i].type == value)
847 return spec->specs[i].name;
848 return NULL;
849 }
850
851
852 const char *
lookup_enum(CK_ULONG type,CK_ULONG value)853 lookup_enum(CK_ULONG type, CK_ULONG value)
854 {
855 CK_ULONG i;
856
857 for(i = 0; ck_types[i].type < ( sizeof(ck_types) / sizeof(enum_spec) ) ; i++)
858 if(ck_types[i].type == type)
859 return lookup_enum_spec(&(ck_types[i]), value);
860 return NULL;
861 }
862
863
864 void
show_error(FILE * f,char * str,CK_RV rc)865 show_error( FILE *f, char *str, CK_RV rc )
866 {
867 fprintf(f, "%s returned: %ld %s", str, (unsigned long) rc, lookup_enum ( RV_T, rc ));
868 fprintf(f, "\n");
869 }
870
871
872 void
print_ck_info(FILE * f,CK_INFO * info)873 print_ck_info(FILE *f, CK_INFO *info)
874 {
875 fprintf(f, " cryptokiVersion: %d.%d\n", info->cryptokiVersion.major, info->cryptokiVersion.minor );
876 fprintf(f, " manufacturerID: '%32.32s'\n", info->manufacturerID );
877 fprintf(f, " flags: %0lx\n", info->flags );
878 fprintf(f, " libraryDescription: '%32.32s'\n", info->libraryDescription );
879 fprintf(f, " libraryVersion: %d.%d\n", info->libraryVersion.major, info->libraryVersion.minor );
880 }
881
882
883 void
print_slot_list(FILE * f,CK_SLOT_ID_PTR pSlotList,CK_ULONG ulCount)884 print_slot_list(FILE *f, CK_SLOT_ID_PTR pSlotList, CK_ULONG ulCount)
885 {
886 CK_ULONG i;
887
888 if(pSlotList) {
889 for (i = 0; i < ulCount; i++)
890 fprintf(f, "Slot %ld\n", pSlotList[i]);
891 }
892 else {
893 fprintf(f, "Count is %ld\n", ulCount);
894 }
895 }
896
897
898 void
print_slot_info(FILE * f,CK_SLOT_INFO * info)899 print_slot_info(FILE *f, CK_SLOT_INFO *info)
900 {
901 size_t i;
902 enum_specs ck_flags[] = {
903 { CKF_TOKEN_PRESENT , "CKF_TOKEN_PRESENT " },
904 { CKF_REMOVABLE_DEVICE , "CKF_REMOVABLE_DEVICE " },
905 { CKF_HW_SLOT , "CKF_HW_SLOT " },
906 };
907
908 fprintf(f, " slotDescription: '%32.32s'\n", info->slotDescription );
909 fprintf(f, " '%32.32s'\n", info->slotDescription+32 );
910 fprintf(f, " manufacturerID: '%32.32s'\n", info->manufacturerID );
911 fprintf(f, " hardwareVersion: %d.%d\n", info->hardwareVersion.major, info->hardwareVersion.minor );
912 fprintf(f, " firmwareVersion: %d.%d\n", info->firmwareVersion.major, info->firmwareVersion.minor );
913 fprintf(f, " flags: %0lx\n", info->flags );
914
915 for(i = 0; i < sizeof (ck_flags) / sizeof (*ck_flags); i++)
916 if(info->flags & ck_flags[i].type)
917 fprintf(f, " %s\n", ck_flags[i].name);
918 }
919
920
921 void
print_token_info(FILE * f,CK_TOKEN_INFO * info)922 print_token_info(FILE *f, CK_TOKEN_INFO *info)
923 {
924 size_t i;
925 enum_specs ck_flags[] = {
926 { CKF_RNG , "CKF_RNG " },
927 { CKF_WRITE_PROTECTED , "CKF_WRITE_PROTECTED " },
928 { CKF_LOGIN_REQUIRED , "CKF_LOGIN_REQUIRED " },
929 { CKF_USER_PIN_INITIALIZED , "CKF_USER_PIN_INITIALIZED " },
930 { CKF_RESTORE_KEY_NOT_NEEDED , "CKF_RESTORE_KEY_NOT_NEEDED " },
931 { CKF_CLOCK_ON_TOKEN , "CKF_CLOCK_ON_TOKEN " },
932 { CKF_PROTECTED_AUTHENTICATION_PATH, "CKF_PROTECTED_AUTHENTICATION_PATH" },
933 { CKF_DUAL_CRYPTO_OPERATIONS , "CKF_DUAL_CRYPTO_OPERATIONS " },
934 { CKF_TOKEN_INITIALIZED , "CKF_TOKEN_INITIALIZED " },
935 { CKF_SECONDARY_AUTHENTICATION , "CKF_SECONDARY_AUTHENTICATION " },
936 { CKF_USER_PIN_COUNT_LOW , "CKF_USER_PIN_COUNT_LOW " },
937 { CKF_USER_PIN_FINAL_TRY , "CKF_USER_PIN_FINAL_TRY " },
938 { CKF_USER_PIN_LOCKED , "CKF_USER_PIN_LOCKED " },
939 { CKF_USER_PIN_TO_BE_CHANGED , "CKF_USER_PIN_TO_BE_CHANGED " },
940 { CKF_SO_PIN_COUNT_LOW , "CKF_SO_PIN_COUNT_LOW " },
941 { CKF_SO_PIN_FINAL_TRY , "CKF_SO_PIN_FINAL_TRY " },
942 { CKF_SO_PIN_LOCKED , "CKF_SO_PIN_LOCKED " },
943 { CKF_SO_PIN_TO_BE_CHANGED , "CKF_SO_PIN_TO_BE_CHANGED " }
944 };
945
946 fprintf(f, " label: '%32.32s'\n", info->label );
947 fprintf(f, " manufacturerID: '%32.32s'\n", info->manufacturerID );
948 fprintf(f, " model: '%16.16s'\n", info->model );
949 fprintf(f, " serialNumber: '%16.16s'\n", info->serialNumber );
950 fprintf(f, " ulMaxSessionCount: %ld\n", info->ulMaxSessionCount );
951 fprintf(f, " ulSessionCount: %ld\n", info->ulSessionCount );
952 fprintf(f, " ulMaxRwSessionCount: %ld\n", info->ulMaxRwSessionCount );
953 fprintf(f, " ulRwSessionCount: %ld\n", info->ulRwSessionCount );
954 fprintf(f, " ulMaxPinLen: %ld\n", info->ulMaxPinLen );
955 fprintf(f, " ulMinPinLen: %ld\n", info->ulMinPinLen );
956 fprintf(f, " ulTotalPublicMemory: %ld\n", info->ulTotalPublicMemory );
957 fprintf(f, " ulFreePublicMemory: %ld\n", info->ulFreePublicMemory );
958 fprintf(f, " ulTotalPrivateMemory: %ld\n", info->ulTotalPrivateMemory );
959 fprintf(f, " ulFreePrivateMemory: %ld\n", info->ulFreePrivateMemory );
960 fprintf(f, " hardwareVersion: %d.%d\n", info->hardwareVersion.major, info->hardwareVersion.minor );
961 fprintf(f, " firmwareVersion: %d.%d\n", info->firmwareVersion.major, info->firmwareVersion.minor );
962 fprintf(f, " time: '%16.16s'\n", info->utcTime );
963 fprintf(f, " flags: %0lx\n", info->flags );
964
965 for(i = 0; i < sizeof (ck_flags) / sizeof (*ck_flags); i++)
966 if(info->flags & ck_flags[i].type)
967 fprintf(f, " %s\n", ck_flags[i].name);
968 }
969
970
971 void
print_mech_list(FILE * f,CK_MECHANISM_TYPE_PTR pMechanismList,CK_ULONG ulMechCount)972 print_mech_list(FILE *f, CK_MECHANISM_TYPE_PTR pMechanismList, CK_ULONG ulMechCount)
973 {
974 CK_ULONG imech;
975
976 if(pMechanismList) {
977 for (imech = 0; imech < ulMechCount; imech++) {
978 const char *name = lookup_enum(MEC_T, pMechanismList[imech]);
979 if (name)
980 fprintf(f, "%30s \n", name);
981 else
982 fprintf(f, " Unknown Mechanism (%08lx) \n", pMechanismList[imech]);
983 }
984 }
985 else {
986 fprintf(f, "Count is %ld\n", ulMechCount);
987 }
988 }
989
990
991 void
print_mech_info(FILE * f,CK_MECHANISM_TYPE type,CK_MECHANISM_INFO_PTR minfo)992 print_mech_info(FILE *f, CK_MECHANISM_TYPE type, CK_MECHANISM_INFO_PTR minfo)
993 {
994 const char *name = lookup_enum(MEC_T, type);
995 CK_ULONG known_flags = CKF_HW | CKF_ENCRYPT | CKF_DECRYPT | CKF_DIGEST |
996 CKF_SIGN | CKF_SIGN_RECOVER | CKF_VERIFY | CKF_VERIFY_RECOVER |
997 CKF_GENERATE | CKF_GENERATE_KEY_PAIR | CKF_WRAP | CKF_UNWRAP |
998 CKF_DERIVE | CKF_EC_F_P | CKF_EC_F_2M |CKF_EC_ECPARAMETERS |
999 CKF_EC_NAMEDCURVE | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS;
1000
1001 if (name)
1002 fprintf(f, "%s : ", name);
1003 else
1004 fprintf(f, "Unknown Mechanism (%08lx) : ", type);
1005
1006 fprintf(f, "min:%lu max:%lu flags:0x%lX ",
1007 (unsigned long) minfo->ulMinKeySize,
1008 (unsigned long) minfo->ulMaxKeySize, minfo->flags);
1009 fprintf(f, "( %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
1010 (minfo->flags & CKF_HW) ? "Hardware " : "",
1011 (minfo->flags & CKF_ENCRYPT) ? "Encrypt " : "",
1012 (minfo->flags & CKF_DECRYPT) ? "Decrypt " : "",
1013 (minfo->flags & CKF_DIGEST) ? "Digest " : "",
1014 (minfo->flags & CKF_SIGN) ? "Sign " : "",
1015 (minfo->flags & CKF_SIGN_RECOVER) ? "SigRecov " : "",
1016 (minfo->flags & CKF_VERIFY) ? "Verify " : "",
1017 (minfo->flags & CKF_VERIFY_RECOVER) ? "VerRecov " : "",
1018 (minfo->flags & CKF_GENERATE) ? "Generate " : "",
1019 (minfo->flags & CKF_GENERATE_KEY_PAIR) ? "KeyPair " : "",
1020 (minfo->flags & CKF_WRAP) ? "Wrap " : "",
1021 (minfo->flags & CKF_UNWRAP) ? "Unwrap " : "",
1022 (minfo->flags & CKF_DERIVE) ? "Derive " : "",
1023 (minfo->flags & CKF_EC_F_P) ? "F(P) " : "",
1024 (minfo->flags & CKF_EC_F_2M) ? "F(2^M) " : "",
1025 (minfo->flags & CKF_EC_ECPARAMETERS) ? "EcParams " : "",
1026 (minfo->flags & CKF_EC_NAMEDCURVE) ? "NamedCurve " : "",
1027 (minfo->flags & CKF_EC_UNCOMPRESS) ? "Uncompress " : "",
1028 (minfo->flags & CKF_EC_COMPRESS) ? "Compress " : "",
1029 (minfo->flags & ~known_flags) ? "Unknown " : "");
1030 }
1031
1032
1033 void
print_attribute_list(FILE * f,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)1034 print_attribute_list(FILE *f, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
1035 {
1036 CK_ULONG j, k;
1037 int found;
1038
1039 if (!pTemplate)
1040 return;
1041
1042 for(j = 0; j < ulCount ; j++) {
1043 found = 0;
1044 for(k = 0; k < ck_attribute_num; k++) {
1045 if(ck_attribute_specs[k].type == pTemplate[j].type) {
1046 found = 1;
1047 fprintf(f, " %s ", ck_attribute_specs[k].name);
1048 if(pTemplate[j].pValue && ((CK_LONG) pTemplate[j].ulValueLen) > 0) {
1049 ck_attribute_specs[k].display
1050 (f, pTemplate[j].type, pTemplate[j].pValue,
1051 pTemplate[j].ulValueLen,
1052 ck_attribute_specs[k].arg);
1053 } else {
1054 fprintf(f, "%s\n", buf_spec(pTemplate[j].pValue, pTemplate[j].ulValueLen));
1055 }
1056 k = ck_attribute_num;
1057 }
1058 }
1059 if (!found) {
1060 fprintf(f, " CKA_? (0x%08lx) ", pTemplate[j].type);
1061 fprintf(f, "%s\n", buf_spec(pTemplate[j].pValue, pTemplate[j].ulValueLen));
1062 }
1063 }
1064 }
1065
1066
1067 void
print_attribute_list_req(FILE * f,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)1068 print_attribute_list_req(FILE *f, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
1069 {
1070 CK_ULONG j, k;
1071 int found;
1072
1073 if (!pTemplate)
1074 return;
1075
1076 for(j = 0; j < ulCount ; j++) {
1077 found = 0;
1078 for(k = 0; k < ck_attribute_num; k++) {
1079 if(ck_attribute_specs[k].type == pTemplate[j].type) {
1080 found = 1;
1081 fprintf(f, " %s ", ck_attribute_specs[k].name);
1082 fprintf(f, "%s\n", buf_spec(pTemplate[j].pValue, pTemplate[j].ulValueLen));
1083 k = ck_attribute_num;
1084 }
1085 }
1086
1087 if (!found) {
1088 fprintf(f, " CKA_? (0x%08lx) ", pTemplate[j].type);
1089 fprintf(f, "%s\n", buf_spec(pTemplate[j].pValue, pTemplate[j].ulValueLen));
1090 }
1091 }
1092 }
1093
1094
1095 void
print_session_info(FILE * f,CK_SESSION_INFO * info)1096 print_session_info(FILE *f, CK_SESSION_INFO *info)
1097 {
1098 size_t i;
1099 enum_specs ck_flags[] = {
1100 { CKF_RW_SESSION , "CKF_RW_SESSION " },
1101 { CKF_SERIAL_SESSION , "CKF_SERIAL_SESSION " }
1102 };
1103
1104 fprintf(f, " slotID: %ld\n", info->slotID );
1105 fprintf(f, " state: '%32.32s'\n", lookup_enum(STA_T, info->state));
1106 fprintf(f, " flags: %0lx\n", info->flags );
1107
1108 for(i = 0; i < sizeof (ck_flags) / sizeof (*ck_flags); i++) {
1109 if(info->flags & ck_flags[i].type)
1110 fprintf(f, " %s\n", ck_flags[i].name);
1111 }
1112 fprintf(f, " ulDeviceError: %0lx\n", info->ulDeviceError );
1113 }
1114
1115
1116 void
print_interfaces_list(FILE * f,CK_INTERFACE_PTR pInterfacesList,CK_ULONG ulCount)1117 print_interfaces_list(FILE *f, CK_INTERFACE_PTR pInterfacesList, CK_ULONG ulCount)
1118 {
1119 CK_ULONG i;
1120
1121 if (pInterfacesList) {
1122 for (i = 0; i < ulCount; i++) {
1123 fprintf(f, "Interface '%s' flags=%lx\n",
1124 pInterfacesList[i].pInterfaceName,
1125 pInterfacesList[i].flags);
1126 }
1127 }
1128 else {
1129 fprintf(f, "Count is %ld\n", ulCount);
1130 }
1131 }
1132