1 /*
2 * Copyright (c) 2005-2008 Alon Bar-Lev <alon.barlev@gmail.com>
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation.
8 *
9 * This program 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
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program (see the file COPYING.GPL included with this
16 * distribution); if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20 #include "config.h"
21
22 #if defined(_WIN32)
23 #include <windows.h>
24 #include <wincrypt.h>
25 #include <conio.h>
26 #else
27 #include <unistd.h>
28 #include <dlfcn.h>
29 #include <openssl/x509.h>
30 #endif
31
32 #include <string>
33 #include <cstdio>
34 #include <cstdlib>
35 #include <cstring>
36
37 #include "pkcs11.h"
38
39 #if defined(_WIN32)
40 #define PKCS11_MODULE_HANDLE HMODULE
41 #else
42 #define PKCS11_MODULE_HANDLE void *
43 #endif
44
45 #if !defined(IN)
46 #define IN
47 #endif
48
49 #if !defined(OUT)
50 #define OUT
51 #endif
52
53 #if !defined(_WIN32)
54 #if OPENSSL_VERSION_NUMBER < 0x00908000L
55 typedef unsigned char *pkcs11_openssl_d2i_t;
56 #else
57 typedef const unsigned char *pkcs11_openssl_d2i_t;
58 #endif
59 #endif
60
61 typedef enum {
62 attrtypeUnknown,
63 attrtypeString,
64 attrtypeByteArray,
65 attrtypeSubject,
66 attrtypeSubject1,
67 attrtypeBigInteger,
68 attrtypeCK_BBOOL,
69 attrtypeCK_DATE,
70 attrtypeCK_ULONG,
71 attrtypeCK_CERTIFICATE_TYPE,
72 attrtypeCK_KEY_TYPE,
73 attrtypeCK_MECHANISM_TYPE,
74 attrtypeCK_OBJECT_CLASS,
75 attrtypeCK_HW_FEATURE_TYPE,
76 attrtypeCK_CHAR,
77 attrtypeCK_ATTRIBUTE_PTR,
78 attrtypeCK_MECHANISM_TYPE_PTR
79 } AttributeType;
80
81 typedef struct {
82 int nId;
83 const char *szName;
84 AttributeType attrtypeType;
85 int nSize;
86 } AttributeDescription;
87
88 class CEGeneral {
89 public:
CEGeneral(IN const std::string & str)90 CEGeneral (
91 IN const std::string &str
92 ) : m_str(str) {};
93
94 public:
95 std::string m_str;
96 };
97
98 class CEPKCS11 {
99 public:
CEPKCS11(IN const std::string & str,IN const CK_RV rv)100 CEPKCS11 (
101 IN const std::string &str,
102 IN const CK_RV rv
103 ) : m_str(str), m_rv(rv) {};
104
105 public:
106 std::string m_str;
107 CK_RV m_rv;
108 };
109
110 const AttributeDescription attrdescAttributes[] = {
111 {CKA_CLASS, "CKA_CLASS", attrtypeCK_OBJECT_CLASS, 0},
112 {CKA_TOKEN, "CKA_TOKEN", attrtypeCK_BBOOL, 0},
113 {CKA_PRIVATE, "CKA_PRIVATE", attrtypeCK_BBOOL, 0},
114 {CKA_LABEL, "CKA_LABEL", attrtypeString, 0},
115 {CKA_APPLICATION, "CKA_APPLICATION", attrtypeString, 0},
116 {CKA_VALUE, "CKA_VALUE", attrtypeByteArray, 16},
117 {CKA_OBJECT_ID, "CKA_OBJECT_ID", attrtypeByteArray, 0},
118 {CKA_CERTIFICATE_TYPE, "CKA_CERTIFICATE_TYPE", attrtypeCK_CERTIFICATE_TYPE, 0},
119 {CKA_ISSUER, "CKA_ISSUER", attrtypeSubject, 0},
120 {CKA_SERIAL_NUMBER, "CKA_SERIAL_NUMBER", attrtypeByteArray, 0},
121 {CKA_AC_ISSUER, "CKA_AC_ISSUER", attrtypeSubject1, 0},
122 {CKA_OWNER, "CKA_OWNER", attrtypeSubject1, 0},
123 {CKA_ATTR_TYPES, "CKA_ATTR_TYPES", attrtypeByteArray, 0},
124 {CKA_TRUSTED, "CKA_TRUSTED", attrtypeCK_BBOOL, 0},
125 {CKA_CERTIFICATE_CATEGORY, "CKA_CERTIFICATE_CATEGORY", attrtypeCK_ULONG, 0},
126 {CKA_JAVA_MIDP_SECURITY_DOMAIN, "CKA_JAVA_MIDP_SECURITY_DOMAIN", attrtypeCK_ULONG, 0},
127 {CKA_URL, "CKA_URL", attrtypeString, 0},
128 {CKA_HASH_OF_SUBJECT_PUBLIC_KEY, "CKA_HASH_OF_SUBJECT_PUBLIC_KEY", attrtypeByteArray, 0},
129 {CKA_HASH_OF_ISSUER_PUBLIC_KEY, "CKA_HASH_OF_ISSUER_PUBLIC_KEY", attrtypeByteArray, 0},
130 {CKA_CHECK_VALUE, "CKA_CHECK_VALUE", attrtypeByteArray, 0},
131 {CKA_KEY_TYPE, "CKA_KEY_TYPE", attrtypeCK_KEY_TYPE, 0},
132 {CKA_SUBJECT, "CKA_SUBJECT", attrtypeSubject, 0},
133 {CKA_ID, "CKA_ID", attrtypeByteArray, 0},
134 {CKA_SENSITIVE, "CKA_SENSITIVE", attrtypeCK_BBOOL, 0},
135 {CKA_ENCRYPT, "CKA_ENCRYPT", attrtypeCK_BBOOL, 0},
136 {CKA_DECRYPT, "CKA_DECRYPT", attrtypeCK_BBOOL, 0},
137 {CKA_WRAP, "CKA_WRAP", attrtypeCK_BBOOL, 0},
138 {CKA_UNWRAP, "CKA_UNWRAP", attrtypeCK_BBOOL, 0},
139 {CKA_SIGN, "CKA_SIGN", attrtypeCK_BBOOL, 0},
140 {CKA_SIGN_RECOVER, "CKA_SIGN_RECOVER", attrtypeCK_BBOOL, 0},
141 {CKA_VERIFY, "CKA_VERIFY", attrtypeCK_BBOOL, 0},
142 {CKA_VERIFY_RECOVER, "CKA_VERIFY_RECOVER", attrtypeCK_BBOOL, 0},
143 {CKA_DERIVE, "CKA_DERIVE", attrtypeCK_BBOOL, 0},
144 {CKA_START_DATE, "CKA_START_DATE", attrtypeCK_DATE, 0},
145 {CKA_END_DATE, "CKA_END_DATE", attrtypeCK_DATE, 0},
146 {CKA_MODULUS, "CKA_MODULUS", attrtypeBigInteger, 0},
147 {CKA_MODULUS_BITS, "CKA_MODULUS_BITS", attrtypeCK_ULONG, 0},
148 {CKA_PUBLIC_EXPONENT, "CKA_PUBLIC_EXPONENT", attrtypeBigInteger, 0},
149 {CKA_PRIVATE_EXPONENT, "CKA_PRIVATE_EXPONENT", attrtypeBigInteger, 0},
150 {CKA_PRIME_1, "CKA_PRIME_1", attrtypeBigInteger, 0},
151 {CKA_PRIME_2, "CKA_PRIME_2", attrtypeBigInteger, 0},
152 {CKA_EXPONENT_1, "CKA_EXPONENT_1", attrtypeBigInteger, 0},
153 {CKA_EXPONENT_2, "CKA_EXPONENT_2", attrtypeBigInteger, 0},
154 {CKA_COEFFICIENT, "CKA_COEFFICIENT", attrtypeBigInteger, 0},
155 {CKA_PRIME, "CKA_PRIME", attrtypeBigInteger, 0},
156 {CKA_SUBPRIME, "CKA_SUBPRIME", attrtypeBigInteger, 0},
157 {CKA_BASE, "CKA_BASE", attrtypeBigInteger, 0},
158 {CKA_PRIME_BITS, "CKA_PRIME_BITS", attrtypeCK_ULONG, 0},
159 //OS {CKA_SUBPRIME_BITS, "CKA_SUBPRIME_BITS", attrtypeCK_ULONG, 0},
160 {CKA_SUB_PRIME_BITS, "CKA_SUB_PRIME_BITS", attrtypeCK_ULONG, 0},
161 {CKA_VALUE_BITS, "CKA_VALUE_BITS", attrtypeCK_ULONG, 0},
162 {CKA_VALUE_LEN, "CKA_VALUE_LEN", attrtypeCK_ULONG, 0},
163 {CKA_EXTRACTABLE, "CKA_EXTRACTABLE", attrtypeCK_BBOOL, 0},
164 {CKA_LOCAL, "CKA_LOCAL", attrtypeCK_BBOOL, 0},
165 {CKA_NEVER_EXTRACTABLE, "CKA_NEVER_EXTRACTABLE", attrtypeCK_BBOOL, 0},
166 {CKA_ALWAYS_SENSITIVE, "CKA_ALWAYS_SENSITIVE", attrtypeCK_BBOOL, 0},
167 {CKA_KEY_GEN_MECHANISM, "CKA_KEY_GEN_MECHANISM", attrtypeCK_MECHANISM_TYPE, 0},
168 {CKA_MODIFIABLE, "CKA_MODIFIABLE", attrtypeCK_BBOOL, 0},
169 {CKA_ECDSA_PARAMS, "CKA_ECDSA_PARAMS", attrtypeByteArray, 0},
170 {CKA_EC_PARAMS, "CKA_EC_PARAMS", attrtypeByteArray, 0},
171 {CKA_EC_POINT, "CKA_EC_POINT", attrtypeByteArray, 0},
172 {CKA_SECONDARY_AUTH, "CKA_SECONDARY_AUTH", attrtypeUnknown, 0},
173 {CKA_AUTH_PIN_FLAGS, "CKA_AUTH_PIN_FLAGS", attrtypeUnknown, 0},
174 {CKA_ALWAYS_AUTHENTICATE, "CKA_ALWAYS_AUTHENTICATE", attrtypeCK_BBOOL, 0},
175 {CKA_WRAP_WITH_TRUSTED, "CKA_WRAP_WITH_TRUSTED", attrtypeCK_BBOOL, 0},
176 {CKA_WRAP_TEMPLATE, "CKA_WRAP_TEMPLATE", attrtypeCK_ATTRIBUTE_PTR, 0},
177 {CKA_UNWRAP_TEMPLATE, "CKA_UNWRAP_TEMPLATE", attrtypeCK_ATTRIBUTE_PTR, 0},
178 {CKA_HW_FEATURE_TYPE, "CKA_HW_FEATURE_TYPE", attrtypeCK_HW_FEATURE_TYPE, 0},
179 {CKA_RESET_ON_INIT, "CKA_RESET_ON_INIT", attrtypeCK_BBOOL, 0},
180 {CKA_HAS_RESET, "CKA_HAS_RESET", attrtypeCK_BBOOL, 0},
181 {CKA_PIXEL_X, "CKA_PIXEL_X", attrtypeCK_ULONG, 0},
182 {CKA_PIXEL_Y, "CKA_PIXEL_Y", attrtypeCK_ULONG, 0},
183 {CKA_RESOLUTION, "CKA_RESOLUTION", attrtypeCK_ULONG, 0},
184 {CKA_CHAR_ROWS, "CKA_CHAR_ROWS", attrtypeCK_ULONG, 0},
185 {CKA_CHAR_COLUMNS, "CKA_CHAR_COLUMNS", attrtypeCK_ULONG, 0},
186 {CKA_COLOR, "CKA_COLOR", attrtypeCK_BBOOL, 0},
187 {CKA_BITS_PER_PIXEL, "CKA_BITS_PER_PIXEL", attrtypeCK_ULONG, 0},
188 {CKA_CHAR_SETS, "CKA_CHAR_SETS", attrtypeString, 0},
189 {CKA_ENCODING_METHODS, "CKA_ENCODING_METHODS", attrtypeString, 0},
190 {CKA_MIME_TYPES, "CKA_MIME_TYPES", attrtypeString, 0},
191 {CKA_MECHANISM_TYPE, "CKA_MECHANISM_TYPE", attrtypeCK_MECHANISM_TYPE, 0},
192 {CKA_REQUIRED_CMS_ATTRIBUTES, "CKA_REQUIRED_CMS_ATTRIBUTES", attrtypeByteArray, 0},
193 {CKA_DEFAULT_CMS_ATTRIBUTES, "CKA_DEFAULT_CMS_ATTRIBUTES", attrtypeByteArray, 0},
194 {CKA_SUPPORTED_CMS_ATTRIBUTES, "CKA_SUPPORTED_CMS_ATTRIBUTES", attrtypeByteArray, 0},
195 {CKA_ALLOWED_MECHANISMS, "CKA_ALLOWED_MECHANISMS", attrtypeCK_MECHANISM_TYPE_PTR, 0},
196 {-1, NULL, attrtypeUnknown, 0}
197 };
198
199 static
200 std::string
Resolve_CK_OBJECT_CLASS(IN const CK_OBJECT_CLASS c)201 Resolve_CK_OBJECT_CLASS (
202 IN const CK_OBJECT_CLASS c
203 ) {
204 switch (c) {
205 case CKO_DATA: return "CKO_DATA";
206 case CKO_CERTIFICATE: return "CKO_CERTIFICATE";
207 case CKO_PUBLIC_KEY: return "CKO_PUBLIC_KEY";
208 case CKO_PRIVATE_KEY: return "CKO_PRIVATE_KEY";
209 case CKO_SECRET_KEY: return "CKO_SECRET_KEY";
210 case CKO_HW_FEATURE: return "CKO_HW_FEATURE";
211 case CKO_DOMAIN_PARAMETERS: return "CKO_DOMAIN_PARAMETERS";
212 case CKO_MECHANISM: return "CKO_MECHANISM";
213 case CKO_VENDOR_DEFINED: return "CKO_VENDOR_DEFINED";
214 default:
215 {
216 char szError[1024];
217 sprintf (szError, "Unknown CK_OBJECT_CLASS %08lx", c);
218 return szError;
219 }
220 }
221 }
222
223 static
224 std::string
Resolve_CK_KEY_TYPE(IN const CK_KEY_TYPE t)225 Resolve_CK_KEY_TYPE (
226 IN const CK_KEY_TYPE t
227 ) {
228 switch (t) {
229 case CKK_RSA: return "CKK_RSA";
230 case CKK_DSA: return "CKK_DSA";
231 case CKK_DH: return "CKK_DH";
232 case CKK_ECDSA: return "CKK_ECDSA";
233 // case CKK_EC: return "CKK_EC";
234 case CKK_X9_42_DH: return "CKK_X9_42_DH";
235 case CKK_KEA: return "CKK_KEA";
236 case CKK_GENERIC_SECRET: return "CKK_GENERIC_SECRET";
237 case CKK_RC2: return "CKK_RC2";
238 case CKK_RC4: return "CKK_RC4";
239 case CKK_DES: return "CKK_DES";
240 case CKK_DES2: return "CKK_DES2";
241 case CKK_DES3: return "CKK_DES3";
242 case CKK_CAST: return "CKK_CAST";
243 case CKK_CAST3: return "CKK_CAST3";
244 //OS case CKK_CAST5: return "CKK_CAST5";
245 // case CKK_CAST128: return "CKK_CAST128";
246 case CKK_RC5: return "CKK_RC5";
247 case CKK_IDEA: return "CKK_IDEA";
248 case CKK_SKIPJACK: return "CKK_SKIPJACK";
249 case CKK_BATON: return "CKK_BATON";
250 case CKK_JUNIPER: return "CKK_JUNIPER";
251 case CKK_CDMF: return "CKK_CDMF";
252 case CKK_AES: return "CKK_AES";
253 case CKK_BLOWFISH: return "CKK_BLOWFISH";
254 case CKK_TWOFISH: return "CKK_TWOFISH";
255 case CKK_VENDOR_DEFINED: return "CKK_VENDOR_DEFINED";
256 default:
257 {
258 char szError[1024];
259 sprintf (szError, "Unknown CK_KEY_TYPE %08lx", t);
260 return szError;
261 }
262 }
263 }
264
265 static
266 std::string
Resolve_CK_MECHANISM_TYPE(IN CK_MECHANISM_TYPE t)267 Resolve_CK_MECHANISM_TYPE (
268 IN CK_MECHANISM_TYPE t
269 ) {
270 switch (t) {
271 case CKM_RSA_PKCS_KEY_PAIR_GEN: return "CKM_RSA_PKCS_KEY_PAIR_GEN";
272 case CKM_RSA_PKCS: return "CKM_RSA_PKCS";
273 case CKM_RSA_9796: return "CKM_RSA_9796";
274 case CKM_RSA_X_509: return "CKM_RSA_X_509";
275 case CKM_MD2_RSA_PKCS: return "CKM_MD2_RSA_PKCS";
276 case CKM_MD5_RSA_PKCS: return "CKM_MD5_RSA_PKCS";
277 case CKM_SHA1_RSA_PKCS: return "CKM_SHA1_RSA_PKCS";
278 case CKM_RIPEMD128_RSA_PKCS: return "CKM_RIPEMD128_RSA_PKCS";
279 case CKM_RIPEMD160_RSA_PKCS: return "CKM_RIPEMD160_RSA_PKCS";
280 case CKM_RSA_PKCS_OAEP: return "CKM_RSA_PKCS_OAEP";
281 case CKM_RSA_X9_31_KEY_PAIR_GEN: return "CKM_RSA_X9_31_KEY_PAIR_GEN";
282 case CKM_RSA_X9_31: return "CKM_RSA_X9_31";
283 case CKM_SHA1_RSA_X9_31: return "CKM_SHA1_RSA_X9_31";
284 case CKM_RSA_PKCS_PSS: return "CKM_RSA_PKCS_PSS";
285 case CKM_SHA1_RSA_PKCS_PSS: return "CKM_SHA1_RSA_PKCS_PSS";
286 case CKM_DSA_KEY_PAIR_GEN: return "CKM_DSA_KEY_PAIR_GEN";
287 case CKM_DSA: return "CKM_DSA";
288 case CKM_DSA_SHA1: return "CKM_DSA_SHA1";
289 case CKM_DH_PKCS_KEY_PAIR_GEN: return "CKM_DH_PKCS_KEY_PAIR_GEN";
290 case CKM_DH_PKCS_DERIVE: return "CKM_DH_PKCS_DERIVE";
291 case CKM_X9_42_DH_KEY_PAIR_GEN: return "CKM_X9_42_DH_KEY_PAIR_GEN";
292 case CKM_X9_42_DH_DERIVE: return "CKM_X9_42_DH_DERIVE";
293 case CKM_X9_42_DH_HYBRID_DERIVE: return "CKM_X9_42_DH_HYBRID_DERIVE";
294 case CKM_X9_42_MQV_DERIVE: return "CKM_X9_42_MQV_DERIVE";
295 /*OS
296 case CKM_SHA256_RSA_PKCS: return "CKM_SHA256_RSA_PKCS";
297 case CKM_SHA384_RSA_PKCS: return "CKM_SHA384_RSA_PKCS";
298 case CKM_SHA512_RSA_PKCS: return "CKM_SHA512_RSA_PKCS";
299 case CKM_SHA256_RSA_PKCS_PSS: return "CKM_SHA256_RSA_PKCS_PSS";
300 case CKM_SHA384_RSA_PKCS_PSS: return "CKM_SHA384_RSA_PKCS_PSS";
301 case CKM_SHA512_RSA_PKCS_PSS: return "CKM_SHA512_RSA_PKCS_PSS";
302 */
303 case CKM_RC2_KEY_GEN: return "CKM_RC2_KEY_GEN";
304 case CKM_RC2_ECB: return "CKM_RC2_ECB";
305 case CKM_RC2_CBC: return "CKM_RC2_CBC";
306 case CKM_RC2_MAC: return "CKM_RC2_MAC";
307 case CKM_RC2_MAC_GENERAL: return "CKM_RC2_MAC_GENERAL";
308 case CKM_RC2_CBC_PAD: return "CKM_RC2_CBC_PAD";
309 case CKM_RC4_KEY_GEN: return "CKM_RC4_KEY_GEN";
310 case CKM_RC4: return "CKM_RC4";
311 case CKM_DES_KEY_GEN: return "CKM_DES_KEY_GEN";
312 case CKM_DES_ECB: return "CKM_DES_ECB";
313 case CKM_DES_CBC: return "CKM_DES_CBC";
314 case CKM_DES_MAC: return "CKM_DES_MAC";
315 case CKM_DES_MAC_GENERAL: return "CKM_DES_MAC_GENERAL";
316 case CKM_DES_CBC_PAD: return "CKM_DES_CBC_PAD";
317 case CKM_DES2_KEY_GEN: return "CKM_DES2_KEY_GEN";
318 case CKM_DES3_KEY_GEN: return "CKM_DES3_KEY_GEN";
319 case CKM_DES3_ECB: return "CKM_DES3_ECB";
320 case CKM_DES3_CBC: return "CKM_DES3_CBC";
321 case CKM_DES3_MAC: return "CKM_DES3_MAC";
322 case CKM_DES3_MAC_GENERAL: return "CKM_DES3_MAC_GENERAL";
323 case CKM_DES3_CBC_PAD: return "CKM_DES3_CBC_PAD";
324 case CKM_CDMF_KEY_GEN: return "CKM_CDMF_KEY_GEN";
325 case CKM_CDMF_ECB: return "CKM_CDMF_ECB";
326 case CKM_CDMF_CBC: return "CKM_CDMF_CBC";
327 case CKM_CDMF_MAC: return "CKM_CDMF_MAC";
328 case CKM_CDMF_MAC_GENERAL: return "CKM_CDMF_MAC_GENERAL";
329 case CKM_CDMF_CBC_PAD: return "CKM_CDMF_CBC_PAD";
330 /*OS
331 case CKM_DES_OFB64: return "CKM_DES_OFB64";
332 case CKM_DES_OFB8: return "CKM_DES_OFB8";
333 case CKM_DES_CFB64: return "CKM_DES_CFB64";
334 case CKM_DES_CFB8: return "CKM_DES_CFB8";
335 */
336 case CKM_MD2: return "CKM_MD2";
337 case CKM_MD2_HMAC: return "CKM_MD2_HMAC";
338 case CKM_MD2_HMAC_GENERAL: return "CKM_MD2_HMAC_GENERAL";
339 case CKM_MD5: return "CKM_MD5";
340 case CKM_MD5_HMAC: return "CKM_MD5_HMAC";
341 case CKM_MD5_HMAC_GENERAL: return "CKM_MD5_HMAC_GENERAL";
342 case CKM_SHA_1: return "CKM_SHA_1";
343 case CKM_SHA_1_HMAC: return "CKM_SHA_1_HMAC";
344 case CKM_SHA_1_HMAC_GENERAL: return "CKM_SHA_1_HMAC_GENERAL";
345 case CKM_RIPEMD128: return "CKM_RIPEMD128";
346 case CKM_RIPEMD128_HMAC: return "CKM_RIPEMD128_HMAC";
347 case CKM_RIPEMD128_HMAC_GENERAL: return "CKM_RIPEMD128_HMAC_GENERAL";
348 case CKM_RIPEMD160: return "CKM_RIPEMD160";
349 case CKM_RIPEMD160_HMAC: return "CKM_RIPEMD160_HMAC";
350 case CKM_RIPEMD160_HMAC_GENERAL: return "CKM_RIPEMD160_HMAC_GENERAL";
351 /*OS
352 case CKM_SHA256: return "CKM_SHA256";
353 case CKM_SHA256_HMAC: return "CKM_SHA256_HMAC";
354 case CKM_SHA256_HMAC_GENERAL: return "CKM_SHA256_HMAC_GENERAL";
355 case CKM_SHA384: return "CKM_SHA384";
356 case CKM_SHA384_HMAC: return "CKM_SHA384_HMAC";
357 case CKM_SHA384_HMAC_GENERAL: return "CKM_SHA384_HMAC_GENERAL";
358 case CKM_SHA512: return "CKM_SHA512";
359 case CKM_SHA512_HMAC: return "CKM_SHA512_HMAC";
360 case CKM_SHA512_HMAC_GENERAL: return "CKM_SHA512_HMAC_GENERAL";
361 */
362 case CKM_CAST_KEY_GEN: return "CKM_CAST_KEY_GEN";
363 case CKM_CAST_ECB: return "CKM_CAST_ECB";
364 case CKM_CAST_CBC: return "CKM_CAST_CBC";
365 case CKM_CAST_MAC: return "CKM_CAST_MAC";
366 case CKM_CAST_MAC_GENERAL: return "CKM_CAST_MAC_GENERAL";
367 case CKM_CAST_CBC_PAD: return "CKM_CAST_CBC_PAD";
368 case CKM_CAST3_KEY_GEN: return "CKM_CAST3_KEY_GEN";
369 case CKM_CAST3_ECB: return "CKM_CAST3_ECB";
370 case CKM_CAST3_CBC: return "CKM_CAST3_CBC";
371 case CKM_CAST3_MAC: return "CKM_CAST3_MAC";
372 case CKM_CAST3_MAC_GENERAL: return "CKM_CAST3_MAC_GENERAL";
373 case CKM_CAST3_CBC_PAD: return "CKM_CAST3_CBC_PAD";
374 case CKM_CAST5_KEY_GEN: return "CKM_CAST5_KEY_GEN";
375 // case CKM_CAST128_KEY_GEN: return "CKM_CAST128_KEY_GEN";
376 case CKM_CAST5_ECB: return "CKM_CAST5_ECB";
377 // case CKM_CAST128_ECB: return "CKM_CAST128_ECB";
378 case CKM_CAST5_CBC: return "CKM_CAST5_CBC";
379 // case CKM_CAST128_CBC: return "CKM_CAST128_CBC";
380 case CKM_CAST5_MAC: return "CKM_CAST5_MAC";
381 // case CKM_CAST128_MAC: return "CKM_CAST128_MAC";
382 case CKM_CAST5_MAC_GENERAL: return "CKM_CAST5_MAC_GENERAL";
383 // case CKM_CAST128_MAC_GENERAL: return "CKM_CAST128_MAC_GENERAL";
384 case CKM_CAST5_CBC_PAD: return "CKM_CAST5_CBC_PAD";
385 // case CKM_CAST128_CBC_PAD: return "CKM_CAST128_CBC_PAD";
386 case CKM_RC5_KEY_GEN: return "CKM_RC5_KEY_GEN";
387 case CKM_RC5_ECB: return "CKM_RC5_ECB";
388 case CKM_RC5_CBC: return "CKM_RC5_CBC";
389 case CKM_RC5_MAC: return "CKM_RC5_MAC";
390 case CKM_RC5_MAC_GENERAL: return "CKM_RC5_MAC_GENERAL";
391 case CKM_RC5_CBC_PAD: return "CKM_RC5_CBC_PAD";
392 case CKM_IDEA_KEY_GEN: return "CKM_IDEA_KEY_GEN";
393 case CKM_IDEA_ECB: return "CKM_IDEA_ECB";
394 case CKM_IDEA_CBC: return "CKM_IDEA_CBC";
395 case CKM_IDEA_MAC: return "CKM_IDEA_MAC";
396 case CKM_IDEA_MAC_GENERAL: return "CKM_IDEA_MAC_GENERAL";
397 case CKM_IDEA_CBC_PAD: return "CKM_IDEA_CBC_PAD";
398 case CKM_GENERIC_SECRET_KEY_GEN: return "CKM_GENERIC_SECRET_KEY_GEN";
399 case CKM_CONCATENATE_BASE_AND_KEY: return "CKM_CONCATENATE_BASE_AND_KEY";
400 case CKM_CONCATENATE_BASE_AND_DATA: return "CKM_CONCATENATE_BASE_AND_DATA";
401 case CKM_CONCATENATE_DATA_AND_BASE: return "CKM_CONCATENATE_DATA_AND_BASE";
402 case CKM_XOR_BASE_AND_DATA: return "CKM_XOR_BASE_AND_DATA";
403 case CKM_EXTRACT_KEY_FROM_KEY: return "CKM_EXTRACT_KEY_FROM_KEY";
404 case CKM_SSL3_PRE_MASTER_KEY_GEN: return "CKM_SSL3_PRE_MASTER_KEY_GEN";
405 case CKM_SSL3_MASTER_KEY_DERIVE: return "CKM_SSL3_MASTER_KEY_DERIVE";
406 case CKM_SSL3_KEY_AND_MAC_DERIVE: return "CKM_SSL3_KEY_AND_MAC_DERIVE";
407 case CKM_SSL3_MASTER_KEY_DERIVE_DH: return "CKM_SSL3_MASTER_KEY_DERIVE_DH";
408 case CKM_TLS_PRE_MASTER_KEY_GEN: return "CKM_TLS_PRE_MASTER_KEY_GEN";
409 case CKM_TLS_MASTER_KEY_DERIVE: return "CKM_TLS_MASTER_KEY_DERIVE";
410 case CKM_TLS_KEY_AND_MAC_DERIVE: return "CKM_TLS_KEY_AND_MAC_DERIVE";
411 case CKM_TLS_MASTER_KEY_DERIVE_DH: return "CKM_TLS_MASTER_KEY_DERIVE_DH";
412 //OS case CKM_TLS_PRF: return "CKM_TLS_PRF";
413 case CKM_SSL3_MD5_MAC: return "CKM_SSL3_MD5_MAC";
414 case CKM_SSL3_SHA1_MAC: return "CKM_SSL3_SHA1_MAC";
415 case CKM_MD5_KEY_DERIVATION: return "CKM_MD5_KEY_DERIVATION";
416 case CKM_MD2_KEY_DERIVATION: return "CKM_MD2_KEY_DERIVATION";
417 case CKM_SHA1_KEY_DERIVATION: return "CKM_SHA1_KEY_DERIVATION";
418 /*OS
419 case CKM_SHA256_KEY_DERIVATION: return "CKM_SHA256_KEY_DERIVATION";
420 case CKM_SHA384_KEY_DERIVATION: return "CKM_SHA384_KEY_DERIVATION";
421 case CKM_SHA512_KEY_DERIVATION: return "CKM_SHA512_KEY_DERIVATION";
422 */
423 case CKM_PBE_MD2_DES_CBC: return "CKM_PBE_MD2_DES_CBC";
424 case CKM_PBE_MD5_DES_CBC: return "CKM_PBE_MD5_DES_CBC";
425 case CKM_PBE_MD5_CAST_CBC: return "CKM_PBE_MD5_CAST_CBC";
426 case CKM_PBE_MD5_CAST3_CBC: return "CKM_PBE_MD5_CAST3_CBC";
427 case CKM_PBE_MD5_CAST5_CBC: return "CKM_PBE_MD5_CAST5_CBC";
428 // case CKM_PBE_MD5_CAST128_CBC: return "CKM_PBE_MD5_CAST128_CBC";
429 case CKM_PBE_SHA1_CAST5_CBC: return "CKM_PBE_SHA1_CAST5_CBC";
430 // case CKM_PBE_SHA1_CAST128_CBC: return "CKM_PBE_SHA1_CAST128_CBC";
431 case CKM_PBE_SHA1_RC4_128: return "CKM_PBE_SHA1_RC4_128";
432 case CKM_PBE_SHA1_RC4_40: return "CKM_PBE_SHA1_RC4_40";
433 case CKM_PBE_SHA1_DES3_EDE_CBC: return "CKM_PBE_SHA1_DES3_EDE_CBC";
434 case CKM_PBE_SHA1_DES2_EDE_CBC: return "CKM_PBE_SHA1_DES2_EDE_CBC";
435 case CKM_PBE_SHA1_RC2_128_CBC: return "CKM_PBE_SHA1_RC2_128_CBC";
436 case CKM_PBE_SHA1_RC2_40_CBC: return "CKM_PBE_SHA1_RC2_40_CBC";
437 case CKM_PKCS5_PBKD2: return "CKM_PKCS5_PBKD2";
438 case CKM_PBA_SHA1_WITH_SHA1_HMAC: return "CKM_PBA_SHA1_WITH_SHA1_HMAC";
439 /*OS
440 case CKM_WTLS_PRE_MASTER_KEY_GEN: return "CKM_WTLS_PRE_MASTER_KEY_GEN";
441 case CKM_WTLS_MASTER_KEY_DERIVE: return "CKM_WTLS_MASTER_KEY_DERIVE";
442 // case CKM_WTLS_MASTER_KEY_DERVIE_DH_ECC: return "CKM_WTLS_MASTER_KEY_DERVIE_DH_ECC";
443 case CKM_WTLS_PRF: return "CKM_WTLS_PRF";
444 case CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE: return "CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE";
445 case CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE: return "CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE";
446 */
447 case CKM_KEY_WRAP_LYNKS: return "CKM_KEY_WRAP_LYNKS";
448 case CKM_KEY_WRAP_SET_OAEP: return "CKM_KEY_WRAP_SET_OAEP";
449 //OS case CKM_CMS_SIG: return "CKM_CMS_SIG";
450 case CKM_SKIPJACK_KEY_GEN: return "CKM_SKIPJACK_KEY_GEN";
451 case CKM_SKIPJACK_ECB64: return "CKM_SKIPJACK_ECB64";
452 case CKM_SKIPJACK_CBC64: return "CKM_SKIPJACK_CBC64";
453 case CKM_SKIPJACK_OFB64: return "CKM_SKIPJACK_OFB64";
454 case CKM_SKIPJACK_CFB64: return "CKM_SKIPJACK_CFB64";
455 case CKM_SKIPJACK_CFB32: return "CKM_SKIPJACK_CFB32";
456 case CKM_SKIPJACK_CFB16: return "CKM_SKIPJACK_CFB16";
457 case CKM_SKIPJACK_CFB8: return "CKM_SKIPJACK_CFB8";
458 case CKM_SKIPJACK_WRAP: return "CKM_SKIPJACK_WRAP";
459 case CKM_SKIPJACK_PRIVATE_WRAP: return "CKM_SKIPJACK_PRIVATE_WRAP";
460 case CKM_SKIPJACK_RELAYX: return "CKM_SKIPJACK_RELAYX";
461 case CKM_KEA_KEY_PAIR_GEN: return "CKM_KEA_KEY_PAIR_GEN";
462 case CKM_KEA_KEY_DERIVE: return "CKM_KEA_KEY_DERIVE";
463 case CKM_FORTEZZA_TIMESTAMP: return "CKM_FORTEZZA_TIMESTAMP";
464 case CKM_BATON_KEY_GEN: return "CKM_BATON_KEY_GEN";
465 case CKM_BATON_ECB128: return "CKM_BATON_ECB128";
466 case CKM_BATON_ECB96: return "CKM_BATON_ECB96";
467 case CKM_BATON_CBC128: return "CKM_BATON_CBC128";
468 case CKM_BATON_COUNTER: return "CKM_BATON_COUNTER";
469 case CKM_BATON_SHUFFLE: return "CKM_BATON_SHUFFLE";
470 case CKM_BATON_WRAP: return "CKM_BATON_WRAP";
471 case CKM_ECDSA_KEY_PAIR_GEN: return "CKM_ECDSA_KEY_PAIR_GEN";
472 // case CKM_EC_KEY_PAIR_GEN: return "CKM_EC_KEY_PAIR_GEN";
473 case CKM_ECDSA: return "CKM_ECDSA";
474 case CKM_ECDSA_SHA1: return "CKM_ECDSA_SHA1";
475 case CKM_ECDH1_DERIVE: return "CKM_ECDH1_DERIVE";
476 case CKM_ECDH1_COFACTOR_DERIVE: return "CKM_ECDH1_COFACTOR_DERIVE";
477 case CKM_ECMQV_DERIVE: return "CKM_ECMQV_DERIVE";
478 case CKM_JUNIPER_KEY_GEN: return "CKM_JUNIPER_KEY_GEN";
479 case CKM_JUNIPER_ECB128: return "CKM_JUNIPER_ECB128";
480 case CKM_JUNIPER_CBC128: return "CKM_JUNIPER_CBC128";
481 case CKM_JUNIPER_COUNTER: return "CKM_JUNIPER_COUNTER";
482 case CKM_JUNIPER_SHUFFLE: return "CKM_JUNIPER_SHUFFLE";
483 case CKM_JUNIPER_WRAP: return "CKM_JUNIPER_WRAP";
484 case CKM_FASTHASH: return "CKM_FASTHASH";
485 case CKM_AES_KEY_GEN: return "CKM_AES_KEY_GEN";
486 case CKM_AES_ECB: return "CKM_AES_ECB";
487 case CKM_AES_CBC: return "CKM_AES_CBC";
488 case CKM_AES_MAC: return "CKM_AES_MAC";
489 case CKM_AES_MAC_GENERAL: return "CKM_AES_MAC_GENERAL";
490 case CKM_AES_CBC_PAD: return "CKM_AES_CBC_PAD";
491 /*OS
492 case CKM_BLOWFISH_KEY_GEN: return "CKM_BLOWFISH_KEY_GEN";
493 case CKM_BLOWFISH_CBC: return "CKM_BLOWFISH_CBC";
494 case CKM_TWOFISH_KEY_GEN: return "CKM_TWOFISH_KEY_GEN";
495 case CKM_TWOFISH_CBC: return "CKM_TWOFISH_CBC";
496 case CKM_DES_ECB_ENCRYPT_DATA: return "CKM_DES_ECB_ENCRYPT_DATA";
497 case CKM_DES_CBC_ENCRYPT_DATA: return "CKM_DES_CBC_ENCRYPT_DATA";
498 case CKM_DES3_ECB_ENCRYPT_DATA: return "CKM_DES3_ECB_ENCRYPT_DATA";
499 case CKM_DES3_CBC_ENCRYPT_DATA: return "CKM_DES3_CBC_ENCRYPT_DATA";
500 case CKM_AES_ECB_ENCRYPT_DATA: return "CKM_AES_ECB_ENCRYPT_DATA";
501 case CKM_AES_CBC_ENCRYPT_DATA: return "CKM_AES_CBC_ENCRYPT_DATA";
502 case CKM_DSA_PARAMETER_GEN: return "CKM_DSA_PARAMETER_GEN";
503 */
504 case CKM_DH_PKCS_PARAMETER_GEN: return "CKM_DH_PKCS_PARAMETER_GEN";
505 case CKM_X9_42_DH_PARAMETER_GEN: return "CKM_X9_42_DH_PARAMETER_GEN";
506 case CKM_VENDOR_DEFINED: return "CKM_VENDOR_DEFINED";
507 default:
508 {
509 char szError[1024];
510 sprintf (szError, "Unknown CK_MECHANISM_TYPE %08lx", t);
511 return szError;
512 }
513 }
514 }
515
516 static
517 std::string
Resolve_CK_RV(IN const CK_RV rv)518 Resolve_CK_RV (
519 IN const CK_RV rv
520 ) {
521 switch (rv) {
522 case CKR_OK: return "CKR_OK";
523 case CKR_CANCEL: return "CKR_CANCEL";
524 case CKR_HOST_MEMORY: return "CKR_HOST_MEMORY";
525 case CKR_SLOT_ID_INVALID: return "CKR_SLOT_ID_INVALID";
526 case CKR_GENERAL_ERROR: return "CKR_GENERAL_ERROR";
527 case CKR_FUNCTION_FAILED: return "CKR_FUNCTION_FAILED";
528 case CKR_ARGUMENTS_BAD: return "CKR_ARGUMENTS_BAD";
529 case CKR_NO_EVENT: return "CKR_NO_EVENT";
530 case CKR_NEED_TO_CREATE_THREADS: return "CKR_NEED_TO_CREATE_THREADS";
531 case CKR_CANT_LOCK: return "CKR_CANT_LOCK";
532 case CKR_ATTRIBUTE_READ_ONLY: return "CKR_ATTRIBUTE_READ_ONLY";
533 case CKR_ATTRIBUTE_SENSITIVE: return "CKR_ATTRIBUTE_SENSITIVE";
534 case CKR_ATTRIBUTE_TYPE_INVALID: return "CKR_ATTRIBUTE_TYPE_INVALID";
535 case CKR_ATTRIBUTE_VALUE_INVALID: return "CKR_ATTRIBUTE_VALUE_INVALID";
536 case CKR_DATA_INVALID: return "CKR_DATA_INVALID";
537 case CKR_DATA_LEN_RANGE: return "CKR_DATA_LEN_RANGE";
538 case CKR_DEVICE_ERROR: return "CKR_DEVICE_ERROR";
539 case CKR_DEVICE_MEMORY: return "CKR_DEVICE_MEMORY";
540 case CKR_DEVICE_REMOVED: return "CKR_DEVICE_REMOVED";
541 case CKR_ENCRYPTED_DATA_INVALID: return "CKR_ENCRYPTED_DATA_INVALID";
542 case CKR_ENCRYPTED_DATA_LEN_RANGE: return "CKR_ENCRYPTED_DATA_LEN_RANGE";
543 case CKR_FUNCTION_CANCELED: return "CKR_FUNCTION_CANCELED";
544 case CKR_FUNCTION_NOT_PARALLEL: return "CKR_FUNCTION_NOT_PARALLEL";
545 case CKR_FUNCTION_NOT_SUPPORTED: return "CKR_FUNCTION_NOT_SUPPORTED";
546 case CKR_KEY_HANDLE_INVALID: return "CKR_KEY_HANDLE_INVALID";
547 case CKR_KEY_SIZE_RANGE: return "CKR_KEY_SIZE_RANGE";
548 case CKR_KEY_TYPE_INCONSISTENT: return "CKR_KEY_TYPE_INCONSISTENT";
549 case CKR_KEY_NOT_NEEDED: return "CKR_KEY_NOT_NEEDED";
550 case CKR_KEY_CHANGED: return "CKR_KEY_CHANGED";
551 case CKR_KEY_NEEDED: return "CKR_KEY_NEEDED";
552 case CKR_KEY_INDIGESTIBLE: return "CKR_KEY_INDIGESTIBLE";
553 case CKR_KEY_FUNCTION_NOT_PERMITTED: return "CKR_KEY_FUNCTION_NOT_PERMITTED";
554 case CKR_KEY_NOT_WRAPPABLE: return "CKR_KEY_NOT_WRAPPABLE";
555 case CKR_KEY_UNEXTRACTABLE: return "CKR_KEY_UNEXTRACTABLE";
556 case CKR_MECHANISM_INVALID: return "CKR_MECHANISM_INVALID";
557 case CKR_MECHANISM_PARAM_INVALID: return "CKR_MECHANISM_PARAM_INVALID";
558 case CKR_OBJECT_HANDLE_INVALID: return "CKR_OBJECT_HANDLE_INVALID";
559 case CKR_OPERATION_ACTIVE: return "CKR_OPERATION_ACTIVE";
560 case CKR_OPERATION_NOT_INITIALIZED: return "CKR_OPERATION_NOT_INITIALIZED";
561 case CKR_PIN_INCORRECT: return "CKR_PIN_INCORRECT";
562 case CKR_PIN_INVALID: return "CKR_PIN_INVALID";
563 case CKR_PIN_LEN_RANGE: return "CKR_PIN_LEN_RANGE";
564 case CKR_PIN_EXPIRED: return "CKR_PIN_EXPIRED";
565 case CKR_PIN_LOCKED: return "CKR_PIN_LOCKED";
566 case CKR_SESSION_CLOSED: return "CKR_SESSION_CLOSED";
567 case CKR_SESSION_COUNT: return "CKR_SESSION_COUNT";
568 case CKR_SESSION_HANDLE_INVALID: return "CKR_SESSION_HANDLE_INVALID";
569 case CKR_SESSION_PARALLEL_NOT_SUPPORTED: return "CKR_SESSION_PARALLEL_NOT_SUPPORTED";
570 case CKR_SESSION_READ_ONLY: return "CKR_SESSION_READ_ONLY";
571 case CKR_SESSION_EXISTS: return "CKR_SESSION_EXISTS";
572 case CKR_SESSION_READ_ONLY_EXISTS: return "CKR_SESSION_READ_ONLY_EXISTS";
573 case CKR_SESSION_READ_WRITE_SO_EXISTS: return "CKR_SESSION_READ_WRITE_SO_EXISTS";
574 case CKR_SIGNATURE_INVALID: return "CKR_SIGNATURE_INVALID";
575 case CKR_SIGNATURE_LEN_RANGE: return "CKR_SIGNATURE_LEN_RANGE";
576 case CKR_TEMPLATE_INCOMPLETE: return "CKR_TEMPLATE_INCOMPLETE";
577 case CKR_TEMPLATE_INCONSISTENT: return "CKR_TEMPLATE_INCONSISTENT";
578 case CKR_TOKEN_NOT_PRESENT: return "CKR_TOKEN_NOT_PRESENT";
579 case CKR_TOKEN_NOT_RECOGNIZED: return "CKR_TOKEN_NOT_RECOGNIZED";
580 case CKR_TOKEN_WRITE_PROTECTED: return "CKR_TOKEN_WRITE_PROTECTED";
581 case CKR_UNWRAPPING_KEY_HANDLE_INVALID: return "CKR_UNWRAPPING_KEY_HANDLE_INVALID";
582 case CKR_UNWRAPPING_KEY_SIZE_RANGE: return "CKR_UNWRAPPING_KEY_SIZE_RANGE";
583 case CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT: return "CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT";
584 case CKR_USER_ALREADY_LOGGED_IN: return "CKR_USER_ALREADY_LOGGED_IN";
585 case CKR_USER_NOT_LOGGED_IN: return "CKR_USER_NOT_LOGGED_IN";
586 case CKR_USER_PIN_NOT_INITIALIZED: return "CKR_USER_PIN_NOT_INITIALIZED";
587 case CKR_USER_TYPE_INVALID: return "CKR_USER_TYPE_INVALID";
588 case CKR_USER_ANOTHER_ALREADY_LOGGED_IN: return "CKR_USER_ANOTHER_ALREADY_LOGGED_IN";
589 case CKR_USER_TOO_MANY_TYPES: return "CKR_USER_TOO_MANY_TYPES";
590 case CKR_WRAPPED_KEY_INVALID: return "CKR_WRAPPED_KEY_INVALID";
591 case CKR_WRAPPED_KEY_LEN_RANGE: return "CKR_WRAPPED_KEY_LEN_RANGE";
592 case CKR_WRAPPING_KEY_HANDLE_INVALID: return "CKR_WRAPPING_KEY_HANDLE_INVALID";
593 case CKR_WRAPPING_KEY_SIZE_RANGE: return "CKR_WRAPPING_KEY_SIZE_RANGE";
594 case CKR_WRAPPING_KEY_TYPE_INCONSISTENT: return "CKR_WRAPPING_KEY_TYPE_INCONSISTENT";
595 case CKR_RANDOM_SEED_NOT_SUPPORTED: return "CKR_RANDOM_SEED_NOT_SUPPORTED";
596 case CKR_RANDOM_NO_RNG: return "CKR_RANDOM_NO_RNG";
597 case CKR_DOMAIN_PARAMS_INVALID: return "CKR_DOMAIN_PARAMS_INVALID";
598 case CKR_BUFFER_TOO_SMALL: return "CKR_BUFFER_TOO_SMALL";
599 case CKR_SAVED_STATE_INVALID: return "CKR_SAVED_STATE_INVALID";
600 case CKR_INFORMATION_SENSITIVE: return "CKR_INFORMATION_SENSITIVE";
601 case CKR_STATE_UNSAVEABLE: return "CKR_STATE_UNSAVEABLE";
602 case CKR_CRYPTOKI_NOT_INITIALIZED: return "CKR_CRYPTOKI_NOT_INITIALIZED";
603 case CKR_CRYPTOKI_ALREADY_INITIALIZED: return "CKR_CRYPTOKI_ALREADY_INITIALIZED";
604 case CKR_MUTEX_BAD: return "CKR_MUTEX_BAD";
605 case CKR_MUTEX_NOT_LOCKED: return "CKR_MUTEX_NOT_LOCKED";
606 case CKR_FUNCTION_REJECTED: return "CKR_FUNCTION_REJECTED";
607 case CKR_VENDOR_DEFINED: return "CKR_VENDOR_DEFINED";
608 default:
609 {
610 char szError[1024];
611 sprintf (szError, "PKCS#11 Error %08lx", rv);
612 return szError;
613 }
614 }
615 }
616
617 static
618 std::string
Resolve_CK_FLAGS(IN const CK_FLAGS f)619 Resolve_CK_FLAGS (
620 IN const CK_FLAGS f
621 ) {
622 std::string r;
623
624 if ((f&CKF_RNG)!=0) {
625 r += "CKF_RNG,";
626 }
627 if ((f&CKF_WRITE_PROTECTED)!=0) {
628 r += "CKF_WRITE_PROTECTED,";
629 }
630 if ((f&CKF_LOGIN_REQUIRED)!=0) {
631 r += "CKF_LOGIN_REQUIRED,";
632 }
633 if ((f&CKF_USER_PIN_INITIALIZED)!=0) {
634 r += "CKF_USER_PIN_INITIALIZED,";
635 }
636 if ((f&CKF_RESTORE_KEY_NOT_NEEDED)!=0) {
637 r += "CKF_RESTORE_KEY_NOT_NEEDED,";
638 }
639 if ((f&CKF_CLOCK_ON_TOKEN)!=0) {
640 r += "CKF_CLOCK_ON_TOKEN,";
641 }
642 if ((f&CKF_PROTECTED_AUTHENTICATION_PATH)!=0) {
643 r += "CKF_PROTECTED_AUTHENTICATION_PATH,";
644 }
645 if ((f&CKF_DUAL_CRYPTO_OPERATIONS)!=0) {
646 r += "CKF_DUAL_CRYPTO_OPERATIONS,";
647 }
648 if ((f&CKF_TOKEN_INITIALIZED)!=0) {
649 r += "CKF_TOKEN_INITIALIZED,";
650 }
651 if ((f&CKF_SECONDARY_AUTHENTICATION)!=0) {
652 r += "CKF_SECONDARY_AUTHENTICATION,";
653 }
654 if ((f&CKF_USER_PIN_COUNT_LOW)!=0) {
655 r += "CKF_USER_PIN_COUNT_LOW,";
656 }
657 if ((f&CKF_USER_PIN_FINAL_TRY)!=0) {
658 r += "CKF_USER_PIN_FINAL_TRY,";
659 }
660 if ((f&CKF_USER_PIN_LOCKED)!=0) {
661 r += "CKF_USER_PIN_LOCKED,";
662 }
663 if ((f&CKF_USER_PIN_TO_BE_CHANGED)!=0) {
664 r += "CKF_USER_PIN_TO_BE_CHANGED,";
665 }
666 if ((f&CKF_SO_PIN_COUNT_LOW)!=0) {
667 r += "CKF_SO_PIN_COUNT_LOW,";
668 }
669 if ((f&CKF_SO_PIN_FINAL_TRY)!=0) {
670 r += "CKF_SO_PIN_FINAL_TRY,";
671 }
672 if ((f&CKF_SO_PIN_LOCKED)!=0) {
673 r += "CKF_SO_PIN_LOCKED,";
674 }
675 if ((f&CKF_SO_PIN_TO_BE_CHANGED)!=0) {
676 r += "CKF_SO_PIN_TO_BE_CHANGED,";
677 }
678
679 if (r!="") {
680 r.erase (r.length ()-1);
681 }
682 return r;
683 }
684
685 static
686 std::string
Resolve_CK_CERTIFICATE_TYPE(IN const CK_CERTIFICATE_TYPE t)687 Resolve_CK_CERTIFICATE_TYPE (
688 IN const CK_CERTIFICATE_TYPE t
689 ) {
690 switch (t) {
691 case CKC_X_509: return "CKC_X_509";
692 case CKC_X_509_ATTR_CERT: return "CKC_X_509_ATTR_CERT";
693 case CKC_WTLS: return "CKC_WTLS";
694 case CKC_VENDOR_DEFINED: return "CKC_VENDOR_DEFINED";
695 default:
696 {
697 char szError[1024];
698 sprintf (szError, "Unknown CK_CERTIFICATE_TYPE %08lx", t);
699 return szError;
700 }
701 }
702 }
703
704 static
705 std::string
Resolve_CK_HW_FEATURE_TYPE(IN const CK_HW_FEATURE_TYPE t)706 Resolve_CK_HW_FEATURE_TYPE (
707 IN const CK_HW_FEATURE_TYPE t
708 ) {
709 switch (t) {
710 case CKH_MONOTONIC_COUNTER: return "CKH_MONOTONIC_COUNTER";
711 case CKH_CLOCK: return "CKH_CLOCK";
712 case CKH_USER_INTERFACE: return "CKH_USER_INTERFACE";
713 case CKH_VENDOR_DEFINED: return "CKH_VENDOR_DEFINED";
714 default:
715 {
716 char szError[1024];
717 sprintf (szError, "Unknown CK_HW_FEATURE_TYPE %08lx", t);
718 return szError;
719 }
720 }
721 }
722
723 static
724 std::string
ParseSubject(IN const void * const p,IN const unsigned s)725 ParseSubject (
726 IN const void * const p,
727 IN const unsigned s
728 ) {
729 char szSubject[1024];
730 bool fOK = false;
731
732 #if defined(_WIN32)
733 CRYPT_DER_BLOB blobSubject = {s, (PBYTE)p};
734
735 if (
736 CertNameToStr (
737 X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
738 &blobSubject,
739 CERT_X500_NAME_STR | CERT_NAME_STR_REVERSE_FLAG,
740 szSubject,
741 sizeof (szSubject)
742 ) != 0
743 ) {
744 fOK = true;
745 }
746 #else
747 X509_NAME *name;
748 name = X509_NAME_new ();
749 if (name != NULL) {
750 pkcs11_openssl_d2i_t pp = (pkcs11_openssl_d2i_t)p;
751 if (
752 d2i_X509_NAME (
753 &name,
754 &pp,
755 s
756 )
757 ) {
758 X509_NAME_oneline (
759 name,
760 szSubject,
761 sizeof (szSubject)
762 );
763 fOK = true;
764 }
765 X509_NAME_free (name);
766 }
767 #endif
768 if (fOK) {
769 return szSubject;
770 }
771 else {
772 return "ERROR";
773 }
774 }
775
776 static
777 std::string
FixedStringToString(IN const void * const p,IN const unsigned s)778 FixedStringToString (
779 IN const void * const p,
780 IN const unsigned s
781 ) {
782 std::string r;
783 for (unsigned long k=0;k<s;k++) {
784 unsigned char c = ((unsigned char *)p)[k];
785 if (isprint (c)) {
786 r+=c;
787 }
788 else {
789 char x[10];
790 sprintf (x, "\\x%02x", c & 0xff);
791 r+=x;
792 }
793 }
794
795 return r;
796 }
797
798 static
799 std::string
DumpToString(IN const void * const p,IN const unsigned s)800 DumpToString (
801 IN const void * const p,
802 IN const unsigned s
803 ) {
804 std::string r;
805 for (unsigned long k=0;k<s;k++) {
806 if ((k%16)==0) {
807 r+="\n";
808 }
809 unsigned char c = ((unsigned char *)p)[k];
810 char x[10];
811 sprintf (x, "%02x ", c & 0xff);
812 r+=x;
813 }
814 r+="\n";
815
816 return r;
817 }
818
819 static
820 void
Load(IN const std::string & strModule,OUT PKCS11_MODULE_HANDLE & hPKCS11,OUT CK_FUNCTION_LIST_PTR & pkcs11)821 Load (
822 IN const std::string &strModule,
823 OUT PKCS11_MODULE_HANDLE &hPKCS11,
824 OUT CK_FUNCTION_LIST_PTR &pkcs11
825 ) {
826 CK_RV rv;
827
828 #if defined(_WIN32)
829 hPKCS11 = LoadLibrary (strModule.c_str ());
830 #else
831 hPKCS11 = dlopen (strModule.c_str (), RTLD_NOW);
832 #endif
833
834 if (hPKCS11 == NULL) {
835 throw CEGeneral ("Cannot load module");
836 }
837
838 CK_C_GetFunctionList C_GetFunctionList = NULL;
839 #if defined(_WIN32)
840 C_GetFunctionList = (CK_C_GetFunctionList) (
841 GetProcAddress (hPKCS11, "C_GetFunctionList")
842 );
843 #else
844 void *p = dlsym (
845 hPKCS11,
846 "C_GetFunctionList"
847 );
848
849 memmove (
850 &C_GetFunctionList,
851 &p,
852 sizeof (void *)
853 );
854 #endif
855
856 if (C_GetFunctionList == NULL) {
857 throw CEGeneral ("Cannot get function list entry");
858 }
859
860 if ((rv = C_GetFunctionList (&pkcs11)) != CKR_OK) {
861 throw CEPKCS11 ("Cannot get function list", rv);
862 }
863
864 if ((rv = pkcs11->C_Initialize (NULL)) != CKR_OK) {
865 throw CEPKCS11 ("Cannot initialize", rv);
866 }
867 }
868
869 static
870 void
Unload(IN OUT PKCS11_MODULE_HANDLE & hPKCS11,IN OUT CK_FUNCTION_LIST_PTR & pkcs11)871 Unload (
872 IN OUT PKCS11_MODULE_HANDLE &hPKCS11,
873 IN OUT CK_FUNCTION_LIST_PTR &pkcs11
874 ) {
875 if (pkcs11 != NULL) {
876 pkcs11->C_Finalize (NULL);
877 pkcs11 = NULL;
878 }
879
880 if (hPKCS11 != NULL) {
881 #if defined(_WIN32)
882 FreeLibrary (hPKCS11);
883 #else
884 dlclose (hPKCS11);
885 #endif
886 hPKCS11 = NULL;
887 }
888 }
889
890 static
891 void
Info(IN const CK_FUNCTION_LIST_PTR & pkcs11)892 Info (
893 IN const CK_FUNCTION_LIST_PTR &pkcs11
894 ) {
895 CK_RV rv;
896 CK_INFO info;
897
898 if (
899 (rv = pkcs11->C_GetInfo (
900 &info
901 )) != CKR_OK
902 ) {
903 throw CEPKCS11 ("C_GetInfo", rv);
904 }
905
906 printf (
907 (
908 "Provider Information:\n"
909 "%30s: %u.%u\n"
910 "%30s: %s\n"
911 "%30s: %08lx\n"
912 ),
913 "cryptokiVersion", info.cryptokiVersion.major, info.cryptokiVersion.minor,
914 "manufacturerID", FixedStringToString (info.manufacturerID, sizeof (info.manufacturerID)).c_str (),
915 "flags", info.flags
916 );
917
918 if (info.cryptokiVersion.major >= 2) {
919 printf (
920 (
921 "%30s: %u.%u\n"
922 "%30s: %s\n"
923 ),
924 "libraryVersion", info.libraryVersion.major, info.libraryVersion.minor,
925 "libraryDescription", FixedStringToString (info.libraryDescription, sizeof (info.libraryDescription)).c_str ()
926 );
927 }
928 }
929
930 static
931 void
SlotList(IN const CK_FUNCTION_LIST_PTR & pkcs11)932 SlotList (
933 IN const CK_FUNCTION_LIST_PTR &pkcs11
934 ) {
935 CK_RV rv;
936 CK_SLOT_ID slots[1024];
937 CK_ULONG slotsnum;
938
939 if (
940 (rv = pkcs11->C_GetSlotList (
941 FALSE,
942 NULL,
943 &slotsnum
944 )) != CKR_OK
945 ) {
946 throw CEPKCS11 ("C_GetSlotList", rv);
947 }
948
949 if (slotsnum >= sizeof(slots)/sizeof(slots[0])) {
950 throw CEPKCS11 ("C_GetSlotList", CKR_BUFFER_TOO_SMALL);
951 }
952
953 if (
954 (rv = pkcs11->C_GetSlotList (
955 FALSE,
956 slots,
957 &slotsnum
958 )) != CKR_OK
959 ) {
960 throw CEPKCS11 ("C_GetSlotList", rv);
961 }
962
963 if (slotsnum == 0) {
964 printf ("No slot found\n");
965 }
966
967 for (CK_SLOT_ID slot=0;slot<slotsnum && slot < sizeof (slots)/sizeof (CK_SLOT_ID);slot++) {
968 CK_SLOT_INFO info;
969
970 if (
971 (rv = pkcs11->C_GetSlotInfo (
972 slots[slot],
973 &info
974 )) == CKR_OK
975 ) {
976 printf ("%lu\t%s\n", slots[slot], FixedStringToString (info.slotDescription, sizeof (info.slotDescription)).c_str ());
977 }
978 else {
979 printf ("C_GetSlotInfo failed %08lx\n", rv);
980 }
981 }
982 }
983
984 static
985 void
Dump(IN const CK_FUNCTION_LIST_PTR & pkcs11,IN const CK_SLOT_ID slotSlot,IN const std::string & strPIN)986 Dump (
987 IN const CK_FUNCTION_LIST_PTR &pkcs11,
988 IN const CK_SLOT_ID slotSlot,
989 IN const std::string &strPIN
990 ) {
991 CK_RV rv;
992 CK_SESSION_HANDLE hSession;
993 CK_OBJECT_HANDLE objects[1024];
994 CK_ULONG objectsmax = sizeof (objects) / sizeof (CK_OBJECT_HANDLE);
995 CK_ULONG objectssize;
996 CK_ULONG i;
997 CK_SLOT_ID slots[1024];
998 CK_ULONG slotsnum;
999
1000 if (
1001 (rv = pkcs11->C_GetSlotList (
1002 FALSE,
1003 NULL,
1004 &slotsnum
1005 )) != CKR_OK
1006 ) {
1007 throw CEPKCS11 ("C_GetSlotList", rv);
1008 }
1009
1010 if (slotsnum >= sizeof(slots)/sizeof(slots[0])) {
1011 throw CEPKCS11 ("C_GetSlotList", CKR_BUFFER_TOO_SMALL);
1012 }
1013
1014 if (
1015 (rv = pkcs11->C_GetSlotList (
1016 FALSE,
1017 slots,
1018 &slotsnum
1019 )) != CKR_OK
1020 ) {
1021 throw CEPKCS11 ("C_GetSlotList", rv);
1022 }
1023
1024 if (
1025 (rv=pkcs11->C_OpenSession (
1026 slotSlot,
1027 CKF_SERIAL_SESSION,
1028 NULL_PTR,
1029 NULL_PTR,
1030 &hSession
1031 )) != CKR_OK
1032 ) {
1033 throw CEPKCS11 ("C_OpenSession", rv);
1034 }
1035
1036 CK_TOKEN_INFO info;
1037
1038 if (
1039 (rv = pkcs11->C_GetTokenInfo (
1040 slotSlot,
1041 &info
1042 )) != CKR_OK
1043 ) {
1044 throw CEPKCS11 ("C_GetTokenInfo", rv);
1045 }
1046
1047 printf (
1048 (
1049 "Token Information:\n"
1050 "%30s: %s\n"
1051 "%30s: %s\n"
1052 "%30s: %s\n"
1053 "%30s: %s\n"
1054 "%30s: %s\n"
1055 "%30s: %ld\n"
1056 "%30s: %ld\n"
1057 "%30s: %ld\n"
1058 "%30s: %ld\n"
1059 "%30s: %ld\n"
1060 "%30s: %ld\n"
1061 "%30s: %ld\n"
1062 "%30s: %ld\n"
1063 "%30s: %03d.%03d\n"
1064 "%30s: %03d.%03d\n"
1065 "%30s: %s\n"
1066 ),
1067 "label", FixedStringToString (info.label, sizeof (info.label)).c_str (),
1068 "manufacturerID", FixedStringToString (info.manufacturerID, sizeof (info.manufacturerID)).c_str (),
1069 "model", FixedStringToString (info.model, sizeof (info.model)).c_str (),
1070 "serialNumber", FixedStringToString (info.serialNumber, sizeof (info.serialNumber)).c_str (),
1071 "flags", Resolve_CK_FLAGS (info.flags).c_str (),
1072 "ulMaxSessionCount", info.ulMaxSessionCount,
1073 "ulMaxSessionCount", info.ulMaxSessionCount,
1074 "ulMaxPinLen", info.ulMaxPinLen,
1075 "ulMinPinLen", info.ulMinPinLen,
1076 "ulTotalPublicMemory", info.ulTotalPublicMemory,
1077 "ulFreePublicMemory", info.ulFreePublicMemory,
1078 "ulTotalPrivateMemory", info.ulTotalPrivateMemory,
1079 "ulFreePrivateMemory", info.ulFreePrivateMemory,
1080 "hardwareVersion", info.hardwareVersion.major, info.hardwareVersion.minor,
1081 "firmwareVersion", info.firmwareVersion.major, info.firmwareVersion.minor,
1082 "utcTime", FixedStringToString (info.utcTime, sizeof (info.utcTime)).c_str ()
1083 );
1084
1085 if (
1086 (rv=pkcs11->C_Login (
1087 hSession,
1088 CKU_USER,
1089 (CK_CHAR_PTR)strPIN.c_str (),
1090 (CK_ULONG)strPIN.length ()
1091 )) != CKR_OK &&
1092 rv != CKR_USER_ALREADY_LOGGED_IN
1093 ) {
1094 throw CEPKCS11 ("C_Login", rv);
1095 }
1096
1097 if (
1098 (rv=pkcs11->C_FindObjectsInit (
1099 hSession,
1100 NULL_PTR,
1101 0
1102 )) != CKR_OK
1103 ) {
1104 throw CEPKCS11 ("C_FindObjectsInit", rv);
1105 }
1106
1107 if (
1108 (rv=pkcs11->C_FindObjects (
1109 hSession,
1110 objects,
1111 objectsmax,
1112 &objectssize
1113 )) != CKR_OK
1114 ) {
1115 throw CEPKCS11 ("C_FindObjects", rv);
1116 }
1117
1118 for (i=0;i<objectssize;i++) {
1119
1120 printf ("Object %lu\n", i);
1121
1122 CK_ULONG lObjectSize;
1123 if (
1124 (rv=pkcs11->C_GetObjectSize (
1125 hSession,
1126 objects[i],
1127 &lObjectSize
1128 )) != CKR_OK
1129 ) {
1130 printf ("%30s: Unknown\n", "Object size");
1131 }
1132 else {
1133 printf ("%30s: %ld\n", "Object size", lObjectSize);
1134 }
1135
1136 for (int j=0;attrdescAttributes[j].nId!=-1;j++) {
1137 char Buffer[10*1024];
1138 CK_ATTRIBUTE t[] = {
1139 {(CK_ATTRIBUTE_TYPE)attrdescAttributes[j].nId, Buffer, sizeof (Buffer)}
1140 };
1141
1142 if (
1143 (rv=pkcs11->C_GetAttributeValue (
1144 hSession,
1145 objects[i],
1146 t,
1147 sizeof (t) / sizeof (CK_ATTRIBUTE)
1148 )) == CKR_OK
1149 ) {
1150 printf ("%30s: ", attrdescAttributes[j].szName);
1151
1152 switch (attrdescAttributes[j].attrtypeType) {
1153 case attrtypeUnknown:
1154 printf ("Unknown value type");
1155 break;
1156 case attrtypeString:
1157 case attrtypeCK_CHAR:
1158 case attrtypeCK_DATE:
1159 printf ("%s", FixedStringToString (t[0].pValue, t[0].ulValueLen).c_str ());
1160 break;
1161 case attrtypeBigInteger:
1162 case attrtypeByteArray:
1163 printf ("%s", DumpToString (t[0].pValue, t[0].ulValueLen).c_str ());
1164 break;
1165 break;
1166 case attrtypeSubject:
1167 case attrtypeSubject1:
1168 printf ("%s\n", ParseSubject (t[0].pValue, t[0].ulValueLen).c_str ());
1169 break;
1170 case attrtypeCK_BBOOL:
1171 {
1172 CK_BBOOL b = *(CK_BBOOL *)t[0].pValue;
1173 if (b != CK_FALSE) {
1174 printf ("TRUE");
1175 }
1176 else {
1177 printf ("FALSE");
1178 }
1179 }
1180 break;
1181 case attrtypeCK_ULONG:
1182 {
1183 CK_ULONG l = *(CK_ULONG *)t[0].pValue;
1184 printf ("%ld", l);
1185 }
1186 break;
1187 case attrtypeCK_CERTIFICATE_TYPE:
1188 printf ("%s", Resolve_CK_CERTIFICATE_TYPE (*(CK_CERTIFICATE_TYPE *)t[0].pValue).c_str ());
1189 break;
1190 case attrtypeCK_KEY_TYPE:
1191 printf ("%s", Resolve_CK_KEY_TYPE (*(CK_KEY_TYPE *)t[0].pValue).c_str ());
1192 break;
1193 case attrtypeCK_MECHANISM_TYPE:
1194 printf ("%s", Resolve_CK_MECHANISM_TYPE (*(CK_MECHANISM_TYPE *)t[0].pValue).c_str ());
1195 break;
1196 case attrtypeCK_OBJECT_CLASS:
1197 printf ("%s", Resolve_CK_OBJECT_CLASS (*(CK_OBJECT_CLASS *)t[0].pValue).c_str ());
1198 break;
1199 case attrtypeCK_HW_FEATURE_TYPE:
1200 printf ("%s", Resolve_CK_HW_FEATURE_TYPE (*(CK_HW_FEATURE_TYPE *)t[0].pValue).c_str ());
1201 break;
1202 case attrtypeCK_ATTRIBUTE_PTR:
1203 printf ("Exists but value not parsed");
1204 break;
1205 case attrtypeCK_MECHANISM_TYPE_PTR:
1206 printf ("Exists but value not parsed");
1207 break;
1208 default:
1209 printf ("Unknown type");
1210 break;
1211 }
1212
1213 printf ("\n");
1214 }
1215 }
1216 }
1217
1218 pkcs11->C_FindObjectsFinal (hSession);
1219 pkcs11->C_Logout (hSession);
1220 pkcs11->C_CloseSession (hSession);
1221 }
1222
1223 std::string
GetPIN(IN const std::string & strPIN)1224 GetPIN (
1225 IN const std::string &strPIN
1226 ) {
1227 std::string strR;
1228
1229 if (strPIN != "-") {
1230 strR = strPIN;
1231 }
1232 else {
1233 #if defined(_WIN32)
1234 char c;
1235
1236 fprintf (stderr, "Please enter PIN: ");
1237
1238 while ((c = getch ()) != '\r') {
1239 fputc ('*', stderr);
1240 strR += c;
1241 }
1242
1243 fprintf (stderr, "\n");
1244 #else
1245 strR = getpass ("Please enter PIN: ");
1246 #endif
1247 }
1248
1249 return strR;
1250 }
1251
1252
1253 int
main(const int argc,const char * const argv[])1254 main (
1255 const int argc,
1256 const char * const argv[]
1257 ) {
1258
1259 fprintf (
1260 stderr,
1261 (
1262 "%s %s - PKI Cryptoki token dump\n"
1263 "Written by Alon Bar-Lev\n"
1264 "\n"
1265 "Copyright (C) 2005-2006 Alon Bar-Lev.\n"
1266 "This is free software; see the source for copying conditions.\n"
1267 "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
1268 "\n"
1269 ),
1270 PACKAGE,
1271 PACKAGE_VERSION
1272 );
1273
1274 bool fUsageOK = false;
1275 bool fOK = false;
1276
1277 if (argc > 1) {
1278 std::string strCommand = argv[1];
1279
1280 if (strCommand == "info") {
1281 if (argc == 3) {
1282 std::string strModule = argv[2];
1283 fUsageOK = true;
1284
1285 PKCS11_MODULE_HANDLE hPKCS11 = NULL;
1286 CK_FUNCTION_LIST_PTR pkcs11 = NULL;
1287 try {
1288 Load (strModule, hPKCS11, pkcs11);
1289 Info (pkcs11);
1290
1291 fOK = true;
1292 }
1293 catch (const CEPKCS11 &e) {
1294 fprintf (stderr, "Fatal: %s-%s\n", e.m_str.c_str (), Resolve_CK_RV (e.m_rv).c_str ());
1295 }
1296 catch (const CEGeneral &e) {
1297 fprintf (stderr, "Fatal: %s\n", e.m_str.c_str ());
1298 }
1299 catch (...) {
1300 fprintf (stderr, "Unknown error\n");
1301 }
1302 Unload (hPKCS11, pkcs11);
1303 }
1304 }
1305 else if (strCommand == "slotlist") {
1306 if (argc == 3) {
1307 std::string strModule = argv[2];
1308 fUsageOK = true;
1309
1310 PKCS11_MODULE_HANDLE hPKCS11 = NULL;
1311 CK_FUNCTION_LIST_PTR pkcs11 = NULL;
1312 try {
1313 Load (strModule, hPKCS11, pkcs11);
1314 //while (1) {
1315 SlotList (pkcs11);
1316 //sleep (1);
1317 //}
1318
1319 fOK = true;
1320 }
1321 catch (const CEPKCS11 &e) {
1322 fprintf (stderr, "Fatal: %s-%s\n", e.m_str.c_str (), Resolve_CK_RV (e.m_rv).c_str ());
1323 }
1324 catch (const CEGeneral &e) {
1325 fprintf (stderr, "Fatal: %s\n", e.m_str.c_str ());
1326 }
1327 catch (...) {
1328 fprintf (stderr, "Unknown error\n");
1329 }
1330 Unload (hPKCS11, pkcs11);
1331 }
1332 }
1333 else if (strCommand == "dump") {
1334 if (argc == 5) {
1335 std::string strModule = argv[2];
1336 CK_SLOT_ID slotSlot = strtoul(argv[3], NULL, 0);
1337 std::string strPIN = GetPIN (argv[4]);
1338 fUsageOK = true;
1339
1340 PKCS11_MODULE_HANDLE hPKCS11 = NULL;
1341 CK_FUNCTION_LIST_PTR pkcs11 = NULL;
1342 try {
1343 Load (strModule, hPKCS11, pkcs11);
1344 Dump (pkcs11, slotSlot, strPIN);
1345
1346 fOK = true;
1347 }
1348 catch (const CEPKCS11 &e) {
1349 fprintf (stderr, "Fatal: %s-%s\n", e.m_str.c_str (), Resolve_CK_RV (e.m_rv).c_str ());
1350 }
1351 catch (const CEGeneral &e) {
1352 fprintf (stderr, "Fatal: %s\n", e.m_str.c_str ());
1353 }
1354 catch (...) {
1355 fprintf (stderr, "Unknown error\n");
1356 }
1357 Unload (hPKCS11, pkcs11);
1358 }
1359 }
1360 }
1361
1362 if (!fUsageOK) {
1363 std::string strModule = argv[0];
1364 size_t n = strModule.find_last_of ('\\');
1365 if (n != std::string::npos) {
1366 strModule = strModule.substr (n+1);
1367 }
1368
1369 fprintf (
1370 stderr,
1371 (
1372 "Usage:\n"
1373 "%s info module\n"
1374 "%s slotlist module\n"
1375 "%s dump module slot user_pin|-\n"
1376 ),
1377 strModule.c_str (),
1378 strModule.c_str (),
1379 strModule.c_str ()
1380 );
1381 fOK = false;
1382 }
1383
1384 if (fOK) {
1385 exit (0);
1386 }
1387 else {
1388 exit (1);
1389 }
1390
1391 return 1;
1392 }
1393