/security/nss/lib/pk11wrap/debug_module.c

http://github.com/zpao/v8monkey · C · 2765 lines · 2515 code · 191 blank · 59 comment · 69 complexity · 63f8023c3ca2eeba4114bd52dbfae15b MD5 · raw file

Large files are truncated click here to view the full file

  1. /* ***** BEGIN LICENSE BLOCK *****
  2. * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3. *
  4. * The contents of this file are subject to the Mozilla Public License Version
  5. * 1.1 (the "License"); you may not use this file except in compliance with
  6. * the License. You may obtain a copy of the License at
  7. * http://www.mozilla.org/MPL/
  8. *
  9. * Software distributed under the License is distributed on an "AS IS" basis,
  10. * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11. * for the specific language governing rights and limitations under the
  12. * License.
  13. *
  14. * The Original Code is the Netscape security libraries.
  15. *
  16. * The Initial Developer of the Original Code is
  17. * Netscape Communications Corporation.
  18. * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19. * the Initial Developer. All Rights Reserved.
  20. *
  21. * Contributor(s):
  22. *
  23. * Alternatively, the contents of this file may be used under the terms of
  24. * either the GNU General Public License Version 2 or later (the "GPL"), or
  25. * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26. * in which case the provisions of the GPL or the LGPL are applicable instead
  27. * of those above. If you wish to allow use of your version of this file only
  28. * under the terms of either the GPL or the LGPL, and not to allow others to
  29. * use your version of this file under the terms of the MPL, indicate your
  30. * decision by deleting the provisions above and replace them with the notice
  31. * and other provisions required by the GPL or the LGPL. If you do not delete
  32. * the provisions above, a recipient may use your version of this file under
  33. * the terms of any one of the MPL, the GPL or the LGPL.
  34. *
  35. * ***** END LICENSE BLOCK ***** */
  36. #include "prlog.h"
  37. #include <stdio.h>
  38. #include "cert.h" /* for CERT_DerNameToAscii & CERT_Hexify */
  39. static PRLogModuleInfo *modlog = NULL;
  40. static CK_FUNCTION_LIST_PTR module_functions;
  41. static CK_FUNCTION_LIST debug_functions;
  42. static void print_final_statistics(void);
  43. #define STRING static const char
  44. STRING fmt_flags[] = " flags = 0x%x";
  45. STRING fmt_hKey[] = " hKey = 0x%x";
  46. STRING fmt_hObject[] = " hObject = 0x%x";
  47. STRING fmt_hSession[] = " hSession = 0x%x";
  48. STRING fmt_manufacturerID[] = " manufacturerID = \"%.32s\"";
  49. STRING fmt_pData[] = " pData = 0x%p";
  50. STRING fmt_pDigest[] = " pDigest = 0x%p";
  51. STRING fmt_pEncryptedData[] = " pEncryptedData = 0x%p";
  52. STRING fmt_pEncryptedPart[] = " pEncryptedPart = 0x%p";
  53. STRING fmt_pInfo[] = " pInfo = 0x%p";
  54. STRING fmt_pMechanism[] = " pMechanism = 0x%p";
  55. STRING fmt_pOperationState[] = " pOperationState = 0x%p";
  56. STRING fmt_pPart[] = " pPart = 0x%p";
  57. STRING fmt_pPin[] = " pPin = 0x%p";
  58. STRING fmt_pSignature[] = " pSignature = 0x%p";
  59. STRING fmt_pTemplate[] = " pTemplate = 0x%p";
  60. STRING fmt_pWrappedKey[] = " pWrappedKey = 0x%p";
  61. STRING fmt_phKey[] = " phKey = 0x%p";
  62. STRING fmt_phObject[] = " phObject = 0x%p";
  63. STRING fmt_pulCount[] = " pulCount = 0x%p";
  64. STRING fmt_pulDataLen[] = " pulDataLen = 0x%p";
  65. STRING fmt_pulDigestLen[] = " pulDigestLen = 0x%p";
  66. STRING fmt_pulEncryptedPartLen[] = " pulEncryptedPartLen = 0x%p";
  67. STRING fmt_pulPartLen[] = " pulPartLen = 0x%p";
  68. STRING fmt_pulSignatureLen[] = " pulSignatureLen = 0x%p";
  69. STRING fmt_slotID[] = " slotID = 0x%x";
  70. STRING fmt_sphKey[] = " *phKey = 0x%x";
  71. STRING fmt_spulCount[] = " *pulCount = 0x%x";
  72. STRING fmt_spulDataLen[] = " *pulDataLen = 0x%x";
  73. STRING fmt_spulDigestLen[] = " *pulDigestLen = 0x%x";
  74. STRING fmt_spulEncryptedPartLen[] = " *pulEncryptedPartLen = 0x%x";
  75. STRING fmt_spulPartLen[] = " *pulPartLen = 0x%x";
  76. STRING fmt_spulSignatureLen[] = " *pulSignatureLen = 0x%x";
  77. STRING fmt_ulAttributeCount[] = " ulAttributeCount = %d";
  78. STRING fmt_ulCount[] = " ulCount = %d";
  79. STRING fmt_ulDataLen[] = " ulDataLen = %d";
  80. STRING fmt_ulEncryptedPartLen[] = " ulEncryptedPartLen = %d";
  81. STRING fmt_ulPartLen[] = " ulPartLen = %d";
  82. STRING fmt_ulPinLen[] = " ulPinLen = %d";
  83. STRING fmt_ulSignatureLen[] = " ulSignatureLen = %d";
  84. STRING fmt_fwVersion[] = " firmware version: %d.%d";
  85. STRING fmt_hwVersion[] = " hardware version: %d.%d";
  86. STRING fmt_s_qsq_d[] = " %s = \"%s\" [%d]";
  87. STRING fmt_s_s_d[] = " %s = %s [%d]";
  88. STRING fmt_s_lu[] = " %s = %lu";
  89. STRING fmt_invalid_handle[] = " (CK_INVALID_HANDLE)";
  90. static void get_attr_type_str(CK_ATTRIBUTE_TYPE atype, char *str, int len)
  91. {
  92. #define CASE(attr) case attr: a = #attr ; break
  93. const char * a = NULL;
  94. switch (atype) {
  95. CASE(CKA_CLASS);
  96. CASE(CKA_TOKEN);
  97. CASE(CKA_PRIVATE);
  98. CASE(CKA_LABEL);
  99. CASE(CKA_APPLICATION);
  100. CASE(CKA_VALUE);
  101. CASE(CKA_OBJECT_ID);
  102. CASE(CKA_CERTIFICATE_TYPE);
  103. CASE(CKA_CERTIFICATE_CATEGORY);
  104. CASE(CKA_ISSUER);
  105. CASE(CKA_SERIAL_NUMBER);
  106. CASE(CKA_AC_ISSUER);
  107. CASE(CKA_OWNER);
  108. CASE(CKA_ATTR_TYPES);
  109. CASE(CKA_TRUSTED);
  110. CASE(CKA_KEY_TYPE);
  111. CASE(CKA_SUBJECT);
  112. CASE(CKA_ID);
  113. CASE(CKA_SENSITIVE);
  114. CASE(CKA_ENCRYPT);
  115. CASE(CKA_DECRYPT);
  116. CASE(CKA_WRAP);
  117. CASE(CKA_UNWRAP);
  118. CASE(CKA_SIGN);
  119. CASE(CKA_SIGN_RECOVER);
  120. CASE(CKA_VERIFY);
  121. CASE(CKA_VERIFY_RECOVER);
  122. CASE(CKA_DERIVE);
  123. CASE(CKA_START_DATE);
  124. CASE(CKA_END_DATE);
  125. CASE(CKA_MODULUS);
  126. CASE(CKA_MODULUS_BITS);
  127. CASE(CKA_PUBLIC_EXPONENT);
  128. CASE(CKA_PRIVATE_EXPONENT);
  129. CASE(CKA_PRIME_1);
  130. CASE(CKA_PRIME_2);
  131. CASE(CKA_EXPONENT_1);
  132. CASE(CKA_EXPONENT_2);
  133. CASE(CKA_COEFFICIENT);
  134. CASE(CKA_PRIME);
  135. CASE(CKA_SUBPRIME);
  136. CASE(CKA_BASE);
  137. CASE(CKA_PRIME_BITS);
  138. CASE(CKA_SUBPRIME_BITS);
  139. CASE(CKA_VALUE_BITS);
  140. CASE(CKA_VALUE_LEN);
  141. CASE(CKA_EXTRACTABLE);
  142. CASE(CKA_LOCAL);
  143. CASE(CKA_NEVER_EXTRACTABLE);
  144. CASE(CKA_ALWAYS_SENSITIVE);
  145. CASE(CKA_KEY_GEN_MECHANISM);
  146. CASE(CKA_MODIFIABLE);
  147. CASE(CKA_ECDSA_PARAMS);
  148. CASE(CKA_EC_POINT);
  149. CASE(CKA_SECONDARY_AUTH);
  150. CASE(CKA_AUTH_PIN_FLAGS);
  151. CASE(CKA_HW_FEATURE_TYPE);
  152. CASE(CKA_RESET_ON_INIT);
  153. CASE(CKA_HAS_RESET);
  154. CASE(CKA_VENDOR_DEFINED);
  155. CASE(CKA_NSS_URL);
  156. CASE(CKA_NSS_EMAIL);
  157. CASE(CKA_NSS_SMIME_INFO);
  158. CASE(CKA_NSS_SMIME_TIMESTAMP);
  159. CASE(CKA_NSS_PKCS8_SALT);
  160. CASE(CKA_NSS_PASSWORD_CHECK);
  161. CASE(CKA_NSS_EXPIRES);
  162. CASE(CKA_NSS_KRL);
  163. CASE(CKA_NSS_PQG_COUNTER);
  164. CASE(CKA_NSS_PQG_SEED);
  165. CASE(CKA_NSS_PQG_H);
  166. CASE(CKA_NSS_PQG_SEED_BITS);
  167. CASE(CKA_TRUST);
  168. CASE(CKA_TRUST_DIGITAL_SIGNATURE);
  169. CASE(CKA_TRUST_NON_REPUDIATION);
  170. CASE(CKA_TRUST_KEY_ENCIPHERMENT);
  171. CASE(CKA_TRUST_DATA_ENCIPHERMENT);
  172. CASE(CKA_TRUST_KEY_AGREEMENT);
  173. CASE(CKA_TRUST_KEY_CERT_SIGN);
  174. CASE(CKA_TRUST_CRL_SIGN);
  175. CASE(CKA_TRUST_SERVER_AUTH);
  176. CASE(CKA_TRUST_CLIENT_AUTH);
  177. CASE(CKA_TRUST_CODE_SIGNING);
  178. CASE(CKA_TRUST_EMAIL_PROTECTION);
  179. CASE(CKA_TRUST_IPSEC_END_SYSTEM);
  180. CASE(CKA_TRUST_IPSEC_TUNNEL);
  181. CASE(CKA_TRUST_IPSEC_USER);
  182. CASE(CKA_TRUST_TIME_STAMPING);
  183. CASE(CKA_CERT_SHA1_HASH);
  184. CASE(CKA_CERT_MD5_HASH);
  185. CASE(CKA_NETSCAPE_DB);
  186. CASE(CKA_NETSCAPE_TRUST);
  187. default: break;
  188. }
  189. if (a)
  190. PR_snprintf(str, len, "%s", a);
  191. else
  192. PR_snprintf(str, len, "0x%p", atype);
  193. }
  194. static void get_obj_class(CK_OBJECT_CLASS objClass, char *str, int len)
  195. {
  196. const char * a = NULL;
  197. switch (objClass) {
  198. CASE(CKO_DATA);
  199. CASE(CKO_CERTIFICATE);
  200. CASE(CKO_PUBLIC_KEY);
  201. CASE(CKO_PRIVATE_KEY);
  202. CASE(CKO_SECRET_KEY);
  203. CASE(CKO_HW_FEATURE);
  204. CASE(CKO_DOMAIN_PARAMETERS);
  205. CASE(CKO_NSS_CRL);
  206. CASE(CKO_NSS_SMIME);
  207. CASE(CKO_NSS_TRUST);
  208. CASE(CKO_NSS_BUILTIN_ROOT_LIST);
  209. default: break;
  210. }
  211. if (a)
  212. PR_snprintf(str, len, "%s", a);
  213. else
  214. PR_snprintf(str, len, "0x%p", objClass);
  215. }
  216. static void get_trust_val(CK_TRUST trust, char *str, int len)
  217. {
  218. const char * a = NULL;
  219. switch (trust) {
  220. CASE(CKT_NSS_TRUSTED);
  221. CASE(CKT_NSS_TRUSTED_DELEGATOR);
  222. CASE(CKT_NSS_NOT_TRUSTED);
  223. CASE(CKT_NSS_MUST_VERIFY_TRUST);
  224. CASE(CKT_NSS_TRUST_UNKNOWN);
  225. CASE(CKT_NSS_VALID_DELEGATOR);
  226. default: break;
  227. }
  228. if (a)
  229. PR_snprintf(str, len, "%s", a);
  230. else
  231. PR_snprintf(str, len, "0x%p", trust);
  232. }
  233. static void log_rv(CK_RV rv)
  234. {
  235. const char * a = NULL;
  236. switch (rv) {
  237. CASE(CKR_OK);
  238. CASE(CKR_CANCEL);
  239. CASE(CKR_HOST_MEMORY);
  240. CASE(CKR_SLOT_ID_INVALID);
  241. CASE(CKR_GENERAL_ERROR);
  242. CASE(CKR_FUNCTION_FAILED);
  243. CASE(CKR_ARGUMENTS_BAD);
  244. CASE(CKR_NO_EVENT);
  245. CASE(CKR_NEED_TO_CREATE_THREADS);
  246. CASE(CKR_CANT_LOCK);
  247. CASE(CKR_ATTRIBUTE_READ_ONLY);
  248. CASE(CKR_ATTRIBUTE_SENSITIVE);
  249. CASE(CKR_ATTRIBUTE_TYPE_INVALID);
  250. CASE(CKR_ATTRIBUTE_VALUE_INVALID);
  251. CASE(CKR_DATA_INVALID);
  252. CASE(CKR_DATA_LEN_RANGE);
  253. CASE(CKR_DEVICE_ERROR);
  254. CASE(CKR_DEVICE_MEMORY);
  255. CASE(CKR_DEVICE_REMOVED);
  256. CASE(CKR_ENCRYPTED_DATA_INVALID);
  257. CASE(CKR_ENCRYPTED_DATA_LEN_RANGE);
  258. CASE(CKR_FUNCTION_CANCELED);
  259. CASE(CKR_FUNCTION_NOT_PARALLEL);
  260. CASE(CKR_FUNCTION_NOT_SUPPORTED);
  261. CASE(CKR_KEY_HANDLE_INVALID);
  262. CASE(CKR_KEY_SIZE_RANGE);
  263. CASE(CKR_KEY_TYPE_INCONSISTENT);
  264. CASE(CKR_KEY_NOT_NEEDED);
  265. CASE(CKR_KEY_CHANGED);
  266. CASE(CKR_KEY_NEEDED);
  267. CASE(CKR_KEY_INDIGESTIBLE);
  268. CASE(CKR_KEY_FUNCTION_NOT_PERMITTED);
  269. CASE(CKR_KEY_NOT_WRAPPABLE);
  270. CASE(CKR_KEY_UNEXTRACTABLE);
  271. CASE(CKR_MECHANISM_INVALID);
  272. CASE(CKR_MECHANISM_PARAM_INVALID);
  273. CASE(CKR_OBJECT_HANDLE_INVALID);
  274. CASE(CKR_OPERATION_ACTIVE);
  275. CASE(CKR_OPERATION_NOT_INITIALIZED);
  276. CASE(CKR_PIN_INCORRECT);
  277. CASE(CKR_PIN_INVALID);
  278. CASE(CKR_PIN_LEN_RANGE);
  279. CASE(CKR_PIN_EXPIRED);
  280. CASE(CKR_PIN_LOCKED);
  281. CASE(CKR_SESSION_CLOSED);
  282. CASE(CKR_SESSION_COUNT);
  283. CASE(CKR_SESSION_HANDLE_INVALID);
  284. CASE(CKR_SESSION_PARALLEL_NOT_SUPPORTED);
  285. CASE(CKR_SESSION_READ_ONLY);
  286. CASE(CKR_SESSION_EXISTS);
  287. CASE(CKR_SESSION_READ_ONLY_EXISTS);
  288. CASE(CKR_SESSION_READ_WRITE_SO_EXISTS);
  289. CASE(CKR_SIGNATURE_INVALID);
  290. CASE(CKR_SIGNATURE_LEN_RANGE);
  291. CASE(CKR_TEMPLATE_INCOMPLETE);
  292. CASE(CKR_TEMPLATE_INCONSISTENT);
  293. CASE(CKR_TOKEN_NOT_PRESENT);
  294. CASE(CKR_TOKEN_NOT_RECOGNIZED);
  295. CASE(CKR_TOKEN_WRITE_PROTECTED);
  296. CASE(CKR_UNWRAPPING_KEY_HANDLE_INVALID);
  297. CASE(CKR_UNWRAPPING_KEY_SIZE_RANGE);
  298. CASE(CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT);
  299. CASE(CKR_USER_ALREADY_LOGGED_IN);
  300. CASE(CKR_USER_NOT_LOGGED_IN);
  301. CASE(CKR_USER_PIN_NOT_INITIALIZED);
  302. CASE(CKR_USER_TYPE_INVALID);
  303. CASE(CKR_USER_ANOTHER_ALREADY_LOGGED_IN);
  304. CASE(CKR_USER_TOO_MANY_TYPES);
  305. CASE(CKR_WRAPPED_KEY_INVALID);
  306. CASE(CKR_WRAPPED_KEY_LEN_RANGE);
  307. CASE(CKR_WRAPPING_KEY_HANDLE_INVALID);
  308. CASE(CKR_WRAPPING_KEY_SIZE_RANGE);
  309. CASE(CKR_WRAPPING_KEY_TYPE_INCONSISTENT);
  310. CASE(CKR_RANDOM_SEED_NOT_SUPPORTED);
  311. CASE(CKR_RANDOM_NO_RNG);
  312. CASE(CKR_DOMAIN_PARAMS_INVALID);
  313. CASE(CKR_BUFFER_TOO_SMALL);
  314. CASE(CKR_SAVED_STATE_INVALID);
  315. CASE(CKR_INFORMATION_SENSITIVE);
  316. CASE(CKR_STATE_UNSAVEABLE);
  317. CASE(CKR_CRYPTOKI_NOT_INITIALIZED);
  318. CASE(CKR_CRYPTOKI_ALREADY_INITIALIZED);
  319. CASE(CKR_MUTEX_BAD);
  320. CASE(CKR_MUTEX_NOT_LOCKED);
  321. CASE(CKR_FUNCTION_REJECTED);
  322. CASE(CKR_KEY_PARAMS_INVALID);
  323. default: break;
  324. }
  325. if (a)
  326. PR_LOG(modlog, 1, (" rv = %s\n", a));
  327. else
  328. PR_LOG(modlog, 1, (" rv = 0x%x\n", rv));
  329. }
  330. static void log_state(CK_STATE state)
  331. {
  332. const char * a = NULL;
  333. switch (state) {
  334. CASE(CKS_RO_PUBLIC_SESSION);
  335. CASE(CKS_RO_USER_FUNCTIONS);
  336. CASE(CKS_RW_PUBLIC_SESSION);
  337. CASE(CKS_RW_USER_FUNCTIONS);
  338. CASE(CKS_RW_SO_FUNCTIONS);
  339. default: break;
  340. }
  341. if (a)
  342. PR_LOG(modlog, 1, (" state = %s\n", a));
  343. else
  344. PR_LOG(modlog, 1, (" state = 0x%x\n", state));
  345. }
  346. static void log_handle(int level, const char * format, CK_ULONG handle)
  347. {
  348. char fmtBuf[80];
  349. if (handle)
  350. PR_LOG(modlog, level, (format, handle));
  351. else {
  352. PL_strncpyz(fmtBuf, format, sizeof fmtBuf);
  353. PL_strcatn(fmtBuf, sizeof fmtBuf, fmt_invalid_handle);
  354. PR_LOG(modlog, level, (fmtBuf, handle));
  355. }
  356. }
  357. static void print_mechanism(CK_MECHANISM_PTR m)
  358. {
  359. const char * a = NULL;
  360. switch (m->mechanism) {
  361. CASE(CKM_AES_CBC);
  362. CASE(CKM_AES_CBC_ENCRYPT_DATA);
  363. CASE(CKM_AES_CBC_PAD);
  364. CASE(CKM_AES_ECB);
  365. CASE(CKM_AES_ECB_ENCRYPT_DATA);
  366. CASE(CKM_AES_KEY_GEN);
  367. CASE(CKM_AES_MAC);
  368. CASE(CKM_AES_MAC_GENERAL);
  369. CASE(CKM_CAMELLIA_CBC);
  370. CASE(CKM_CAMELLIA_CBC_ENCRYPT_DATA);
  371. CASE(CKM_CAMELLIA_CBC_PAD);
  372. CASE(CKM_CAMELLIA_ECB);
  373. CASE(CKM_CAMELLIA_ECB_ENCRYPT_DATA);
  374. CASE(CKM_CAMELLIA_KEY_GEN);
  375. CASE(CKM_CAMELLIA_MAC);
  376. CASE(CKM_CAMELLIA_MAC_GENERAL);
  377. CASE(CKM_CDMF_CBC);
  378. CASE(CKM_CDMF_CBC_PAD);
  379. CASE(CKM_CDMF_ECB);
  380. CASE(CKM_CDMF_KEY_GEN);
  381. CASE(CKM_CDMF_MAC);
  382. CASE(CKM_CDMF_MAC_GENERAL);
  383. CASE(CKM_CMS_SIG);
  384. CASE(CKM_CONCATENATE_BASE_AND_DATA);
  385. CASE(CKM_CONCATENATE_BASE_AND_KEY);
  386. CASE(CKM_CONCATENATE_DATA_AND_BASE);
  387. CASE(CKM_DES2_KEY_GEN);
  388. CASE(CKM_DES3_CBC);
  389. CASE(CKM_DES3_CBC_ENCRYPT_DATA);
  390. CASE(CKM_DES3_CBC_PAD);
  391. CASE(CKM_DES3_ECB);
  392. CASE(CKM_DES3_ECB_ENCRYPT_DATA);
  393. CASE(CKM_DES3_KEY_GEN);
  394. CASE(CKM_DES3_MAC);
  395. CASE(CKM_DES3_MAC_GENERAL);
  396. CASE(CKM_DES_CBC);
  397. CASE(CKM_DES_CBC_ENCRYPT_DATA);
  398. CASE(CKM_DES_CBC_PAD);
  399. CASE(CKM_DES_CFB64);
  400. CASE(CKM_DES_CFB8);
  401. CASE(CKM_DES_ECB);
  402. CASE(CKM_DES_ECB_ENCRYPT_DATA);
  403. CASE(CKM_DES_KEY_GEN);
  404. CASE(CKM_DES_MAC);
  405. CASE(CKM_DES_MAC_GENERAL);
  406. CASE(CKM_DES_OFB64);
  407. CASE(CKM_DES_OFB8);
  408. CASE(CKM_DH_PKCS_DERIVE);
  409. CASE(CKM_DH_PKCS_KEY_PAIR_GEN);
  410. CASE(CKM_DH_PKCS_PARAMETER_GEN);
  411. CASE(CKM_DSA);
  412. CASE(CKM_DSA_KEY_PAIR_GEN);
  413. CASE(CKM_DSA_PARAMETER_GEN);
  414. CASE(CKM_DSA_SHA1);
  415. CASE(CKM_ECDH1_COFACTOR_DERIVE);
  416. CASE(CKM_ECDH1_DERIVE);
  417. CASE(CKM_ECDSA);
  418. CASE(CKM_ECDSA_SHA1);
  419. CASE(CKM_ECMQV_DERIVE);
  420. CASE(CKM_EC_KEY_PAIR_GEN); /* also CASE(CKM_ECDSA_KEY_PAIR_GEN); */
  421. CASE(CKM_EXTRACT_KEY_FROM_KEY);
  422. CASE(CKM_FASTHASH);
  423. CASE(CKM_FORTEZZA_TIMESTAMP);
  424. CASE(CKM_GENERIC_SECRET_KEY_GEN);
  425. CASE(CKM_IDEA_CBC);
  426. CASE(CKM_IDEA_CBC_PAD);
  427. CASE(CKM_IDEA_ECB);
  428. CASE(CKM_IDEA_KEY_GEN);
  429. CASE(CKM_IDEA_MAC);
  430. CASE(CKM_IDEA_MAC_GENERAL);
  431. CASE(CKM_KEA_KEY_DERIVE);
  432. CASE(CKM_KEA_KEY_PAIR_GEN);
  433. CASE(CKM_KEY_WRAP_LYNKS);
  434. CASE(CKM_KEY_WRAP_SET_OAEP);
  435. CASE(CKM_MD2);
  436. CASE(CKM_MD2_HMAC);
  437. CASE(CKM_MD2_HMAC_GENERAL);
  438. CASE(CKM_MD2_KEY_DERIVATION);
  439. CASE(CKM_MD2_RSA_PKCS);
  440. CASE(CKM_MD5);
  441. CASE(CKM_MD5_HMAC);
  442. CASE(CKM_MD5_HMAC_GENERAL);
  443. CASE(CKM_MD5_KEY_DERIVATION);
  444. CASE(CKM_MD5_RSA_PKCS);
  445. CASE(CKM_PBA_SHA1_WITH_SHA1_HMAC);
  446. CASE(CKM_PBE_MD2_DES_CBC);
  447. CASE(CKM_PBE_MD5_DES_CBC);
  448. CASE(CKM_PBE_SHA1_DES2_EDE_CBC);
  449. CASE(CKM_PBE_SHA1_DES3_EDE_CBC);
  450. CASE(CKM_PBE_SHA1_RC2_128_CBC);
  451. CASE(CKM_PBE_SHA1_RC2_40_CBC);
  452. CASE(CKM_PBE_SHA1_RC4_128);
  453. CASE(CKM_PBE_SHA1_RC4_40);
  454. CASE(CKM_PKCS5_PBKD2);
  455. CASE(CKM_RC2_CBC);
  456. CASE(CKM_RC2_CBC_PAD);
  457. CASE(CKM_RC2_ECB);
  458. CASE(CKM_RC2_KEY_GEN);
  459. CASE(CKM_RC2_MAC);
  460. CASE(CKM_RC2_MAC_GENERAL);
  461. CASE(CKM_RC4);
  462. CASE(CKM_RC4_KEY_GEN);
  463. CASE(CKM_RC5_CBC);
  464. CASE(CKM_RC5_CBC_PAD);
  465. CASE(CKM_RC5_ECB);
  466. CASE(CKM_RC5_KEY_GEN);
  467. CASE(CKM_RC5_MAC);
  468. CASE(CKM_RC5_MAC_GENERAL);
  469. CASE(CKM_RIPEMD128);
  470. CASE(CKM_RIPEMD128_HMAC);
  471. CASE(CKM_RIPEMD128_HMAC_GENERAL);
  472. CASE(CKM_RIPEMD128_RSA_PKCS);
  473. CASE(CKM_RIPEMD160);
  474. CASE(CKM_RIPEMD160_HMAC);
  475. CASE(CKM_RIPEMD160_HMAC_GENERAL);
  476. CASE(CKM_RIPEMD160_RSA_PKCS);
  477. CASE(CKM_RSA_9796);
  478. CASE(CKM_RSA_PKCS);
  479. CASE(CKM_RSA_PKCS_KEY_PAIR_GEN);
  480. CASE(CKM_RSA_PKCS_OAEP);
  481. CASE(CKM_RSA_PKCS_PSS);
  482. CASE(CKM_RSA_X9_31);
  483. CASE(CKM_RSA_X9_31_KEY_PAIR_GEN);
  484. CASE(CKM_RSA_X_509);
  485. CASE(CKM_SHA1_KEY_DERIVATION);
  486. CASE(CKM_SHA1_RSA_PKCS);
  487. CASE(CKM_SHA1_RSA_PKCS_PSS);
  488. CASE(CKM_SHA1_RSA_X9_31);
  489. CASE(CKM_SHA224);
  490. CASE(CKM_SHA224_HMAC);
  491. CASE(CKM_SHA224_HMAC_GENERAL);
  492. CASE(CKM_SHA224_KEY_DERIVATION);
  493. CASE(CKM_SHA224_RSA_PKCS);
  494. CASE(CKM_SHA224_RSA_PKCS_PSS);
  495. CASE(CKM_SHA256);
  496. CASE(CKM_SHA256_HMAC);
  497. CASE(CKM_SHA256_HMAC_GENERAL);
  498. CASE(CKM_SHA256_KEY_DERIVATION);
  499. CASE(CKM_SHA256_RSA_PKCS);
  500. CASE(CKM_SHA256_RSA_PKCS_PSS);
  501. CASE(CKM_SHA384);
  502. CASE(CKM_SHA384_HMAC);
  503. CASE(CKM_SHA384_HMAC_GENERAL);
  504. CASE(CKM_SHA384_KEY_DERIVATION);
  505. CASE(CKM_SHA384_RSA_PKCS);
  506. CASE(CKM_SHA384_RSA_PKCS_PSS);
  507. CASE(CKM_SHA512);
  508. CASE(CKM_SHA512_HMAC);
  509. CASE(CKM_SHA512_HMAC_GENERAL);
  510. CASE(CKM_SHA512_KEY_DERIVATION);
  511. CASE(CKM_SHA512_RSA_PKCS);
  512. CASE(CKM_SHA512_RSA_PKCS_PSS);
  513. CASE(CKM_SHA_1);
  514. CASE(CKM_SHA_1_HMAC);
  515. CASE(CKM_SHA_1_HMAC_GENERAL);
  516. CASE(CKM_SKIPJACK_CBC64);
  517. CASE(CKM_SKIPJACK_CFB16);
  518. CASE(CKM_SKIPJACK_CFB32);
  519. CASE(CKM_SKIPJACK_CFB64);
  520. CASE(CKM_SKIPJACK_CFB8);
  521. CASE(CKM_SKIPJACK_ECB64);
  522. CASE(CKM_SKIPJACK_KEY_GEN);
  523. CASE(CKM_SKIPJACK_OFB64);
  524. CASE(CKM_SKIPJACK_PRIVATE_WRAP);
  525. CASE(CKM_SKIPJACK_RELAYX);
  526. CASE(CKM_SKIPJACK_WRAP);
  527. CASE(CKM_SSL3_KEY_AND_MAC_DERIVE);
  528. CASE(CKM_SSL3_MASTER_KEY_DERIVE);
  529. CASE(CKM_SSL3_MASTER_KEY_DERIVE_DH);
  530. CASE(CKM_SSL3_MD5_MAC);
  531. CASE(CKM_SSL3_PRE_MASTER_KEY_GEN);
  532. CASE(CKM_SSL3_SHA1_MAC);
  533. CASE(CKM_TLS_KEY_AND_MAC_DERIVE);
  534. CASE(CKM_TLS_MASTER_KEY_DERIVE);
  535. CASE(CKM_TLS_MASTER_KEY_DERIVE_DH);
  536. CASE(CKM_TLS_PRE_MASTER_KEY_GEN);
  537. CASE(CKM_TLS_PRF);
  538. CASE(CKM_TWOFISH_CBC);
  539. CASE(CKM_TWOFISH_KEY_GEN);
  540. CASE(CKM_X9_42_DH_DERIVE);
  541. CASE(CKM_X9_42_DH_HYBRID_DERIVE);
  542. CASE(CKM_X9_42_DH_KEY_PAIR_GEN);
  543. CASE(CKM_X9_42_DH_PARAMETER_GEN);
  544. CASE(CKM_X9_42_MQV_DERIVE);
  545. CASE(CKM_XOR_BASE_AND_DATA);
  546. default: break;
  547. }
  548. if (a)
  549. PR_LOG(modlog, 4, (" mechanism = %s", a));
  550. else
  551. PR_LOG(modlog, 4, (" mechanism = 0x%p", m->mechanism));
  552. }
  553. static void get_key_type(CK_KEY_TYPE keyType, char *str, int len)
  554. {
  555. const char * a = NULL;
  556. switch (keyType) {
  557. CASE(CKK_AES);
  558. CASE(CKK_CAMELLIA);
  559. CASE(CKK_CDMF);
  560. CASE(CKK_DES);
  561. CASE(CKK_DES2);
  562. CASE(CKK_DES3);
  563. CASE(CKK_DH);
  564. CASE(CKK_DSA);
  565. CASE(CKK_EC); /* also CASE(CKK_ECDSA); */
  566. CASE(CKK_GENERIC_SECRET);
  567. CASE(CKK_IDEA);
  568. CASE(CKK_INVALID_KEY_TYPE);
  569. CASE(CKK_KEA);
  570. CASE(CKK_RC2);
  571. CASE(CKK_RC4);
  572. CASE(CKK_RC5);
  573. CASE(CKK_RSA);
  574. CASE(CKK_SKIPJACK);
  575. CASE(CKK_TWOFISH);
  576. CASE(CKK_X9_42_DH);
  577. default: break;
  578. }
  579. if (a)
  580. PR_snprintf(str, len, "%s", a);
  581. else
  582. PR_snprintf(str, len, "0x%p", keyType);
  583. }
  584. static void print_attr_value(CK_ATTRIBUTE_PTR attr)
  585. {
  586. char atype[48];
  587. char valstr[49];
  588. int len;
  589. get_attr_type_str(attr->type, atype, sizeof atype);
  590. switch (attr->type) {
  591. case CKA_ALWAYS_SENSITIVE:
  592. case CKA_DECRYPT:
  593. case CKA_DERIVE:
  594. case CKA_ENCRYPT:
  595. case CKA_EXTRACTABLE:
  596. case CKA_LOCAL:
  597. case CKA_MODIFIABLE:
  598. case CKA_NEVER_EXTRACTABLE:
  599. case CKA_PRIVATE:
  600. case CKA_SENSITIVE:
  601. case CKA_SIGN:
  602. case CKA_SIGN_RECOVER:
  603. case CKA_TOKEN:
  604. case CKA_UNWRAP:
  605. case CKA_VERIFY:
  606. case CKA_VERIFY_RECOVER:
  607. case CKA_WRAP:
  608. if (attr->ulValueLen > 0 && attr->pValue) {
  609. CK_BBOOL tf = *((CK_BBOOL *)attr->pValue);
  610. PR_LOG(modlog, 4, (fmt_s_s_d,
  611. atype, tf ? "CK_TRUE" : "CK_FALSE", attr->ulValueLen));
  612. break;
  613. }
  614. case CKA_CLASS:
  615. if (attr->ulValueLen > 0 && attr->pValue) {
  616. CK_OBJECT_CLASS objClass = *((CK_OBJECT_CLASS *)attr->pValue);
  617. get_obj_class(objClass, valstr, sizeof valstr);
  618. PR_LOG(modlog, 4, (fmt_s_s_d,
  619. atype, valstr, attr->ulValueLen));
  620. break;
  621. }
  622. case CKA_TRUST_CLIENT_AUTH:
  623. case CKA_TRUST_CODE_SIGNING:
  624. case CKA_TRUST_EMAIL_PROTECTION:
  625. case CKA_TRUST_SERVER_AUTH:
  626. if (attr->ulValueLen > 0 && attr->pValue) {
  627. CK_TRUST trust = *((CK_TRUST *)attr->pValue);
  628. get_trust_val(trust, valstr, sizeof valstr);
  629. PR_LOG(modlog, 4, (fmt_s_s_d,
  630. atype, valstr, attr->ulValueLen));
  631. break;
  632. }
  633. case CKA_KEY_TYPE:
  634. if (attr->ulValueLen > 0 && attr->pValue) {
  635. CK_KEY_TYPE keyType = *((CK_KEY_TYPE *)attr->pValue);
  636. get_key_type(keyType, valstr, sizeof valstr);
  637. PR_LOG(modlog, 4, (fmt_s_s_d,
  638. atype, valstr, attr->ulValueLen));
  639. break;
  640. }
  641. case CKA_PIXEL_X:
  642. case CKA_PIXEL_Y:
  643. case CKA_RESOLUTION:
  644. case CKA_CHAR_ROWS:
  645. case CKA_CHAR_COLUMNS:
  646. case CKA_BITS_PER_PIXEL:
  647. case CKA_CERTIFICATE_CATEGORY: /* should print as enum/string */
  648. case CKA_JAVA_MIDP_SECURITY_DOMAIN: /* should print as enum/string */
  649. case CKA_MODULUS_BITS:
  650. case CKA_PRIME_BITS:
  651. case CKA_SUBPRIME_BITS:
  652. case CKA_VALUE_BITS:
  653. case CKA_VALUE_LEN:
  654. if (attr->ulValueLen > 0 && attr->pValue) {
  655. CK_ULONG valueLen = *((CK_ULONG *)attr->pValue);
  656. /* XXX check for the special value CK_UNAVAILABLE_INFORMATION */
  657. PR_LOG(modlog, 4, (fmt_s_lu, atype, (PRUint32)valueLen));
  658. break;
  659. }
  660. case CKA_LABEL:
  661. case CKA_NSS_EMAIL:
  662. case CKA_NSS_URL:
  663. if (attr->ulValueLen > 0 && attr->pValue) {
  664. len = PR_MIN(attr->ulValueLen + 1, sizeof valstr);
  665. PR_snprintf(valstr, len, "%s", attr->pValue);
  666. PR_LOG(modlog, 4, (fmt_s_qsq_d,
  667. atype, valstr, attr->ulValueLen));
  668. break;
  669. }
  670. case CKA_ISSUER:
  671. case CKA_SUBJECT:
  672. if (attr->ulValueLen > 0 && attr->pValue) {
  673. char * asciiName;
  674. SECItem derName;
  675. derName.type = siDERNameBuffer;
  676. derName.data = attr->pValue;
  677. derName.len = attr->ulValueLen;
  678. asciiName = CERT_DerNameToAscii(&derName);
  679. if (asciiName) {
  680. PR_LOG(modlog, 4, (fmt_s_s_d,
  681. atype, asciiName, attr->ulValueLen));
  682. PORT_Free(asciiName);
  683. break;
  684. }
  685. /* else treat like a binary buffer */
  686. goto binary_buffer;
  687. }
  688. case CKA_ID:
  689. if (attr->ulValueLen > 0 && attr->pValue) {
  690. unsigned char * pV = attr->pValue;
  691. for (len = (int)attr->ulValueLen; len > 0; --len) {
  692. unsigned int ch = *pV++;
  693. if (ch >= 0x20 && ch < 0x7f)
  694. continue;
  695. if (!ch && len == 1) /* will ignore NUL if last character */
  696. continue;
  697. break;
  698. }
  699. if (!len) { /* entire string is printable */
  700. len = PR_MIN(attr->ulValueLen + 1, sizeof valstr);
  701. PR_snprintf(valstr, len, "%s", attr->pValue);
  702. PR_LOG(modlog, 4, (fmt_s_qsq_d,
  703. atype, valstr, attr->ulValueLen));
  704. break;
  705. }
  706. /* else fall through and treat like a binary buffer */
  707. }
  708. binary_buffer:
  709. case CKA_SERIAL_NUMBER:
  710. default:
  711. if (attr->ulValueLen > 0 && attr->pValue) {
  712. char * hexBuf;
  713. SECItem attrBuf;
  714. attrBuf.type = siDERNameBuffer;
  715. attrBuf.data = attr->pValue;
  716. attrBuf.len = PR_MIN(attr->ulValueLen, (sizeof valstr)/2);
  717. hexBuf = CERT_Hexify(&attrBuf, PR_FALSE);
  718. if (hexBuf) {
  719. PR_LOG(modlog, 4, (fmt_s_s_d,
  720. atype, hexBuf, attr->ulValueLen));
  721. PORT_Free(hexBuf);
  722. break;
  723. }
  724. /* else fall through and show only the address. :( */
  725. }
  726. PR_LOG(modlog, 4, (" %s = [0x%p] [%d]",
  727. atype, attr->pValue, attr->ulValueLen));
  728. break;
  729. }
  730. }
  731. static void print_template(CK_ATTRIBUTE_PTR templ, CK_ULONG tlen)
  732. {
  733. CK_ULONG i;
  734. for (i=0; i<tlen; i++) {
  735. print_attr_value(&templ[i]);
  736. }
  737. }
  738. struct nssdbg_prof_str {
  739. PRUint32 time;
  740. PRUint32 calls;
  741. char *function;
  742. };
  743. #define NSSDBG_DEFINE(func) { 0, 0, #func }
  744. struct nssdbg_prof_str nssdbg_prof_data[] = {
  745. #define FUNC_C_INITIALIZE 0
  746. NSSDBG_DEFINE(C_Initialize),
  747. #define FUNC_C_FINALIZE 1
  748. NSSDBG_DEFINE(C_Finalize),
  749. #define FUNC_C_GETINFO 2
  750. NSSDBG_DEFINE(C_GetInfo),
  751. #define FUNC_C_GETFUNCITONLIST 3
  752. NSSDBG_DEFINE(C_GetFunctionList),
  753. #define FUNC_C_GETSLOTLIST 4
  754. NSSDBG_DEFINE(C_GetSlotList),
  755. #define FUNC_C_GETSLOTINFO 5
  756. NSSDBG_DEFINE(C_GetSlotInfo),
  757. #define FUNC_C_GETTOKENINFO 6
  758. NSSDBG_DEFINE(C_GetTokenInfo),
  759. #define FUNC_C_GETMECHANISMLIST 7
  760. NSSDBG_DEFINE(C_GetMechanismList),
  761. #define FUNC_C_GETMECHANISMINFO 8
  762. NSSDBG_DEFINE(C_GetMechanismInfo),
  763. #define FUNC_C_INITTOKEN 9
  764. NSSDBG_DEFINE(C_InitToken),
  765. #define FUNC_C_INITPIN 10
  766. NSSDBG_DEFINE(C_InitPIN),
  767. #define FUNC_C_SETPIN 11
  768. NSSDBG_DEFINE(C_SetPIN),
  769. #define FUNC_C_OPENSESSION 12
  770. NSSDBG_DEFINE(C_OpenSession),
  771. #define FUNC_C_CLOSESESSION 13
  772. NSSDBG_DEFINE(C_CloseSession),
  773. #define FUNC_C_CLOSEALLSESSIONS 14
  774. NSSDBG_DEFINE(C_CloseAllSessions),
  775. #define FUNC_C_GETSESSIONINFO 15
  776. NSSDBG_DEFINE(C_GetSessionInfo),
  777. #define FUNC_C_GETOPERATIONSTATE 16
  778. NSSDBG_DEFINE(C_GetOperationState),
  779. #define FUNC_C_SETOPERATIONSTATE 17
  780. NSSDBG_DEFINE(C_SetOperationState),
  781. #define FUNC_C_LOGIN 18
  782. NSSDBG_DEFINE(C_Login),
  783. #define FUNC_C_LOGOUT 19
  784. NSSDBG_DEFINE(C_Logout),
  785. #define FUNC_C_CREATEOBJECT 20
  786. NSSDBG_DEFINE(C_CreateObject),
  787. #define FUNC_C_COPYOBJECT 21
  788. NSSDBG_DEFINE(C_CopyObject),
  789. #define FUNC_C_DESTROYOBJECT 22
  790. NSSDBG_DEFINE(C_DestroyObject),
  791. #define FUNC_C_GETOBJECTSIZE 23
  792. NSSDBG_DEFINE(C_GetObjectSize),
  793. #define FUNC_C_GETATTRIBUTEVALUE 24
  794. NSSDBG_DEFINE(C_GetAttributeValue),
  795. #define FUNC_C_SETATTRIBUTEVALUE 25
  796. NSSDBG_DEFINE(C_SetAttributeValue),
  797. #define FUNC_C_FINDOBJECTSINIT 26
  798. NSSDBG_DEFINE(C_FindObjectsInit),
  799. #define FUNC_C_FINDOBJECTS 27
  800. NSSDBG_DEFINE(C_FindObjects),
  801. #define FUNC_C_FINDOBJECTSFINAL 28
  802. NSSDBG_DEFINE(C_FindObjectsFinal),
  803. #define FUNC_C_ENCRYPTINIT 29
  804. NSSDBG_DEFINE(C_EncryptInit),
  805. #define FUNC_C_ENCRYPT 30
  806. NSSDBG_DEFINE(C_Encrypt),
  807. #define FUNC_C_ENCRYPTUPDATE 31
  808. NSSDBG_DEFINE(C_EncryptUpdate),
  809. #define FUNC_C_ENCRYPTFINAL 32
  810. NSSDBG_DEFINE(C_EncryptFinal),
  811. #define FUNC_C_DECRYPTINIT 33
  812. NSSDBG_DEFINE(C_DecryptInit),
  813. #define FUNC_C_DECRYPT 34
  814. NSSDBG_DEFINE(C_Decrypt),
  815. #define FUNC_C_DECRYPTUPDATE 35
  816. NSSDBG_DEFINE(C_DecryptUpdate),
  817. #define FUNC_C_DECRYPTFINAL 36
  818. NSSDBG_DEFINE(C_DecryptFinal),
  819. #define FUNC_C_DIGESTINIT 37
  820. NSSDBG_DEFINE(C_DigestInit),
  821. #define FUNC_C_DIGEST 38
  822. NSSDBG_DEFINE(C_Digest),
  823. #define FUNC_C_DIGESTUPDATE 39
  824. NSSDBG_DEFINE(C_DigestUpdate),
  825. #define FUNC_C_DIGESTKEY 40
  826. NSSDBG_DEFINE(C_DigestKey),
  827. #define FUNC_C_DIGESTFINAL 41
  828. NSSDBG_DEFINE(C_DigestFinal),
  829. #define FUNC_C_SIGNINIT 42
  830. NSSDBG_DEFINE(C_SignInit),
  831. #define FUNC_C_SIGN 43
  832. NSSDBG_DEFINE(C_Sign),
  833. #define FUNC_C_SIGNUPDATE 44
  834. NSSDBG_DEFINE(C_SignUpdate),
  835. #define FUNC_C_SIGNFINAL 45
  836. NSSDBG_DEFINE(C_SignFinal),
  837. #define FUNC_C_SIGNRECOVERINIT 46
  838. NSSDBG_DEFINE(C_SignRecoverInit),
  839. #define FUNC_C_SIGNRECOVER 47
  840. NSSDBG_DEFINE(C_SignRecover),
  841. #define FUNC_C_VERIFYINIT 48
  842. NSSDBG_DEFINE(C_VerifyInit),
  843. #define FUNC_C_VERIFY 49
  844. NSSDBG_DEFINE(C_Verify),
  845. #define FUNC_C_VERIFYUPDATE 50
  846. NSSDBG_DEFINE(C_VerifyUpdate),
  847. #define FUNC_C_VERIFYFINAL 51
  848. NSSDBG_DEFINE(C_VerifyFinal),
  849. #define FUNC_C_VERIFYRECOVERINIT 52
  850. NSSDBG_DEFINE(C_VerifyRecoverInit),
  851. #define FUNC_C_VERIFYRECOVER 53
  852. NSSDBG_DEFINE(C_VerifyRecover),
  853. #define FUNC_C_DIGESTENCRYPTUPDATE 54
  854. NSSDBG_DEFINE(C_DigestEncryptUpdate),
  855. #define FUNC_C_DECRYPTDIGESTUPDATE 55
  856. NSSDBG_DEFINE(C_DecryptDigestUpdate),
  857. #define FUNC_C_SIGNENCRYPTUPDATE 56
  858. NSSDBG_DEFINE(C_SignEncryptUpdate),
  859. #define FUNC_C_DECRYPTVERIFYUPDATE 57
  860. NSSDBG_DEFINE(C_DecryptVerifyUpdate),
  861. #define FUNC_C_GENERATEKEY 58
  862. NSSDBG_DEFINE(C_GenerateKey),
  863. #define FUNC_C_GENERATEKEYPAIR 59
  864. NSSDBG_DEFINE(C_GenerateKeyPair),
  865. #define FUNC_C_WRAPKEY 60
  866. NSSDBG_DEFINE(C_WrapKey),
  867. #define FUNC_C_UNWRAPKEY 61
  868. NSSDBG_DEFINE(C_UnWrapKey),
  869. #define FUNC_C_DERIVEKEY 62
  870. NSSDBG_DEFINE(C_DeriveKey),
  871. #define FUNC_C_SEEDRANDOM 63
  872. NSSDBG_DEFINE(C_SeedRandom),
  873. #define FUNC_C_GENERATERANDOM 64
  874. NSSDBG_DEFINE(C_GenerateRandom),
  875. #define FUNC_C_GETFUNCTIONSTATUS 65
  876. NSSDBG_DEFINE(C_GetFunctionStatus),
  877. #define FUNC_C_CANCELFUNCTION 66
  878. NSSDBG_DEFINE(C_CancelFunction),
  879. #define FUNC_C_WAITFORSLOTEVENT 67
  880. NSSDBG_DEFINE(C_WaitForSlotEvent)
  881. };
  882. int nssdbg_prof_size = sizeof(nssdbg_prof_data)/sizeof(nssdbg_prof_data[0]);
  883. static void nssdbg_finish_time(PRInt32 fun_number, PRIntervalTime start)
  884. {
  885. PRIntervalTime ival;
  886. PRIntervalTime end = PR_IntervalNow();
  887. ival = end-start;
  888. /* sigh, lie to PRAtomic add and say we are using signed values */
  889. PR_ATOMIC_ADD((PRInt32 *)&nssdbg_prof_data[fun_number].time, (PRInt32)ival);
  890. }
  891. static void nssdbg_start_time(PRInt32 fun_number, PRIntervalTime *start)
  892. {
  893. PR_ATOMIC_INCREMENT((PRInt32 *)&nssdbg_prof_data[fun_number].calls);
  894. *start = PR_IntervalNow();
  895. }
  896. #define COMMON_DEFINITIONS \
  897. CK_RV rv; \
  898. PRIntervalTime start
  899. CK_RV NSSDBGC_Initialize(
  900. CK_VOID_PTR pInitArgs
  901. )
  902. {
  903. COMMON_DEFINITIONS;
  904. PR_LOG(modlog, 1, ("C_Initialize"));
  905. PR_LOG(modlog, 3, (" pInitArgs = 0x%p", pInitArgs));
  906. nssdbg_start_time(FUNC_C_INITIALIZE,&start);
  907. rv = module_functions->C_Initialize(pInitArgs);
  908. nssdbg_finish_time(FUNC_C_INITIALIZE,start);
  909. log_rv(rv);
  910. return rv;
  911. }
  912. CK_RV NSSDBGC_Finalize(
  913. CK_VOID_PTR pReserved
  914. )
  915. {
  916. COMMON_DEFINITIONS;
  917. PR_LOG(modlog, 1, ("C_Finalize"));
  918. PR_LOG(modlog, 3, (" pReserved = 0x%p", pReserved));
  919. nssdbg_start_time(FUNC_C_FINALIZE,&start);
  920. rv = module_functions->C_Finalize(pReserved);
  921. nssdbg_finish_time(FUNC_C_FINALIZE,start);
  922. log_rv(rv);
  923. return rv;
  924. }
  925. CK_RV NSSDBGC_GetInfo(
  926. CK_INFO_PTR pInfo
  927. )
  928. {
  929. COMMON_DEFINITIONS;
  930. PR_LOG(modlog, 1, ("C_GetInfo"));
  931. PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
  932. nssdbg_start_time(FUNC_C_GETINFO,&start);
  933. rv = module_functions->C_GetInfo(pInfo);
  934. nssdbg_finish_time(FUNC_C_GETINFO,start);
  935. if (rv == CKR_OK) {
  936. PR_LOG(modlog, 4, (" cryptoki version: %d.%d",
  937. pInfo->cryptokiVersion.major,
  938. pInfo->cryptokiVersion.minor));
  939. PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID));
  940. PR_LOG(modlog, 4, (" library description = \"%.32s\"",
  941. pInfo->libraryDescription));
  942. PR_LOG(modlog, 4, (" library version: %d.%d",
  943. pInfo->libraryVersion.major,
  944. pInfo->libraryVersion.minor));
  945. }
  946. log_rv(rv);
  947. return rv;
  948. }
  949. CK_RV NSSDBGC_GetFunctionList(
  950. CK_FUNCTION_LIST_PTR_PTR ppFunctionList
  951. )
  952. {
  953. COMMON_DEFINITIONS;
  954. PR_LOG(modlog, 1, ("C_GetFunctionList"));
  955. PR_LOG(modlog, 3, (" ppFunctionList = 0x%p", ppFunctionList));
  956. nssdbg_start_time(FUNC_C_GETFUNCITONLIST,&start);
  957. rv = module_functions->C_GetFunctionList(ppFunctionList);
  958. nssdbg_finish_time(FUNC_C_GETFUNCITONLIST,start);
  959. log_rv(rv);
  960. return rv;
  961. }
  962. CK_RV NSSDBGC_GetSlotList(
  963. CK_BBOOL tokenPresent,
  964. CK_SLOT_ID_PTR pSlotList,
  965. CK_ULONG_PTR pulCount
  966. )
  967. {
  968. COMMON_DEFINITIONS;
  969. CK_ULONG i;
  970. PR_LOG(modlog, 1, ("C_GetSlotList"));
  971. PR_LOG(modlog, 3, (" tokenPresent = 0x%x", tokenPresent));
  972. PR_LOG(modlog, 3, (" pSlotList = 0x%p", pSlotList));
  973. PR_LOG(modlog, 3, (fmt_pulCount, pulCount));
  974. nssdbg_start_time(FUNC_C_GETSLOTLIST,&start);
  975. rv = module_functions->C_GetSlotList(tokenPresent, pSlotList, pulCount);
  976. nssdbg_finish_time(FUNC_C_GETSLOTLIST,start);
  977. PR_LOG(modlog, 4, (fmt_spulCount, *pulCount));
  978. if (pSlotList) {
  979. for (i=0; i<*pulCount; i++) {
  980. PR_LOG(modlog, 4, (" slotID[%d] = %x", i, pSlotList[i]));
  981. }
  982. }
  983. log_rv(rv);
  984. return rv;
  985. }
  986. CK_RV NSSDBGC_GetSlotInfo(
  987. CK_SLOT_ID slotID,
  988. CK_SLOT_INFO_PTR pInfo
  989. )
  990. {
  991. COMMON_DEFINITIONS;
  992. PR_LOG(modlog, 1, ("C_GetSlotInfo"));
  993. PR_LOG(modlog, 3, (fmt_slotID, slotID));
  994. PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
  995. nssdbg_start_time(FUNC_C_GETSLOTINFO,&start);
  996. rv = module_functions->C_GetSlotInfo(slotID, pInfo);
  997. nssdbg_finish_time(FUNC_C_GETSLOTINFO,start);
  998. if (rv == CKR_OK) {
  999. PR_LOG(modlog, 4, (" slotDescription = \"%.64s\"",
  1000. pInfo->slotDescription));
  1001. PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID));
  1002. PR_LOG(modlog, 4, (" flags = %s %s %s",
  1003. pInfo->flags & CKF_HW_SLOT ? "CKF_HW_SLOT" : "",
  1004. pInfo->flags & CKF_REMOVABLE_DEVICE ? "CKF_REMOVABLE_DEVICE" : "",
  1005. pInfo->flags & CKF_TOKEN_PRESENT ? "CKF_TOKEN_PRESENT" : ""));
  1006. PR_LOG(modlog, 4, (fmt_hwVersion,
  1007. pInfo->hardwareVersion.major,
  1008. pInfo->hardwareVersion.minor));
  1009. PR_LOG(modlog, 4, (fmt_fwVersion,
  1010. pInfo->firmwareVersion.major,
  1011. pInfo->firmwareVersion.minor));
  1012. }
  1013. log_rv(rv);
  1014. return rv;
  1015. }
  1016. CK_RV NSSDBGC_GetTokenInfo(
  1017. CK_SLOT_ID slotID,
  1018. CK_TOKEN_INFO_PTR pInfo
  1019. )
  1020. {
  1021. COMMON_DEFINITIONS;
  1022. PR_LOG(modlog, 1, ("C_GetTokenInfo"));
  1023. PR_LOG(modlog, 3, (fmt_slotID, slotID));
  1024. PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
  1025. nssdbg_start_time(FUNC_C_GETTOKENINFO,&start);
  1026. rv = module_functions->C_GetTokenInfo(slotID, pInfo);
  1027. nssdbg_finish_time(FUNC_C_GETTOKENINFO,start);
  1028. if (rv == CKR_OK) {
  1029. PR_LOG(modlog, 4, (" label = \"%.32s\"", pInfo->label));
  1030. PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID));
  1031. PR_LOG(modlog, 4, (" model = \"%.16s\"", pInfo->model));
  1032. PR_LOG(modlog, 4, (" serial = \"%.16s\"", pInfo->serialNumber));
  1033. PR_LOG(modlog, 4, (" flags = %s %s %s %s",
  1034. pInfo->flags & CKF_RNG ? "CKF_RNG" : "",
  1035. pInfo->flags & CKF_WRITE_PROTECTED ? "CKF_WRITE_PROTECTED" : "",
  1036. pInfo->flags & CKF_LOGIN_REQUIRED ? "CKF_LOGIN_REQUIRED" : "",
  1037. pInfo->flags & CKF_USER_PIN_INITIALIZED ? "CKF_USER_PIN_INIT" : ""));
  1038. PR_LOG(modlog, 4, (" maxSessions = %u, Sessions = %u",
  1039. pInfo->ulMaxSessionCount, pInfo->ulSessionCount));
  1040. PR_LOG(modlog, 4, (" maxRwSessions = %u, RwSessions = %u",
  1041. pInfo->ulMaxRwSessionCount,
  1042. pInfo->ulRwSessionCount));
  1043. /* ignore Max & Min Pin Len, Public and Private Memory */
  1044. PR_LOG(modlog, 4, (fmt_hwVersion,
  1045. pInfo->hardwareVersion.major,
  1046. pInfo->hardwareVersion.minor));
  1047. PR_LOG(modlog, 4, (fmt_fwVersion,
  1048. pInfo->firmwareVersion.major,
  1049. pInfo->firmwareVersion.minor));
  1050. }
  1051. log_rv(rv);
  1052. return rv;
  1053. }
  1054. CK_RV NSSDBGC_GetMechanismList(
  1055. CK_SLOT_ID slotID,
  1056. CK_MECHANISM_TYPE_PTR pMechanismList,
  1057. CK_ULONG_PTR pulCount
  1058. )
  1059. {
  1060. COMMON_DEFINITIONS;
  1061. PR_LOG(modlog, 1, ("C_GetMechanismList"));
  1062. PR_LOG(modlog, 3, (fmt_slotID, slotID));
  1063. PR_LOG(modlog, 3, (" pMechanismList = 0x%p", pMechanismList));
  1064. PR_LOG(modlog, 3, (fmt_pulCount, pulCount));
  1065. nssdbg_start_time(FUNC_C_GETMECHANISMLIST,&start);
  1066. rv = module_functions->C_GetMechanismList(slotID,
  1067. pMechanismList,
  1068. pulCount);
  1069. nssdbg_finish_time(FUNC_C_GETMECHANISMLIST,start);
  1070. PR_LOG(modlog, 4, (fmt_spulCount, *pulCount));
  1071. log_rv(rv);
  1072. return rv;
  1073. }
  1074. CK_RV NSSDBGC_GetMechanismInfo(
  1075. CK_SLOT_ID slotID,
  1076. CK_MECHANISM_TYPE type,
  1077. CK_MECHANISM_INFO_PTR pInfo
  1078. )
  1079. {
  1080. COMMON_DEFINITIONS;
  1081. PR_LOG(modlog, 1, ("C_GetMechanismInfo"));
  1082. PR_LOG(modlog, 3, (fmt_slotID, slotID));
  1083. PR_LOG(modlog, 3, (" type = 0x%x", type));
  1084. PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
  1085. nssdbg_start_time(FUNC_C_GETMECHANISMINFO,&start);
  1086. rv = module_functions->C_GetMechanismInfo(slotID,
  1087. type,
  1088. pInfo);
  1089. nssdbg_finish_time(FUNC_C_GETMECHANISMINFO,start);
  1090. log_rv(rv);
  1091. return rv;
  1092. }
  1093. CK_RV NSSDBGC_InitToken(
  1094. CK_SLOT_ID slotID,
  1095. CK_CHAR_PTR pPin,
  1096. CK_ULONG ulPinLen,
  1097. CK_CHAR_PTR pLabel
  1098. )
  1099. {
  1100. COMMON_DEFINITIONS;
  1101. PR_LOG(modlog, 1, ("C_InitToken"));
  1102. PR_LOG(modlog, 3, (fmt_slotID, slotID));
  1103. PR_LOG(modlog, 3, (fmt_pPin, pPin));
  1104. PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
  1105. PR_LOG(modlog, 3, (" pLabel = 0x%p", pLabel));
  1106. nssdbg_start_time(FUNC_C_INITTOKEN,&start);
  1107. rv = module_functions->C_InitToken(slotID,
  1108. pPin,
  1109. ulPinLen,
  1110. pLabel);
  1111. nssdbg_finish_time(FUNC_C_INITTOKEN,start);
  1112. log_rv(rv);
  1113. return rv;
  1114. }
  1115. CK_RV NSSDBGC_InitPIN(
  1116. CK_SESSION_HANDLE hSession,
  1117. CK_CHAR_PTR pPin,
  1118. CK_ULONG ulPinLen
  1119. )
  1120. {
  1121. COMMON_DEFINITIONS;
  1122. PR_LOG(modlog, 1, ("C_InitPIN"));
  1123. log_handle(3, fmt_hSession, hSession);
  1124. PR_LOG(modlog, 3, (fmt_pPin, pPin));
  1125. PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
  1126. nssdbg_start_time(FUNC_C_INITPIN,&start);
  1127. rv = module_functions->C_InitPIN(hSession,
  1128. pPin,
  1129. ulPinLen);
  1130. nssdbg_finish_time(FUNC_C_INITPIN,start);
  1131. log_rv(rv);
  1132. return rv;
  1133. }
  1134. CK_RV NSSDBGC_SetPIN(
  1135. CK_SESSION_HANDLE hSession,
  1136. CK_CHAR_PTR pOldPin,
  1137. CK_ULONG ulOldLen,
  1138. CK_CHAR_PTR pNewPin,
  1139. CK_ULONG ulNewLen
  1140. )
  1141. {
  1142. COMMON_DEFINITIONS;
  1143. PR_LOG(modlog, 1, ("C_SetPIN"));
  1144. log_handle(3, fmt_hSession, hSession);
  1145. PR_LOG(modlog, 3, (" pOldPin = 0x%p", pOldPin));
  1146. PR_LOG(modlog, 3, (" ulOldLen = %d", ulOldLen));
  1147. PR_LOG(modlog, 3, (" pNewPin = 0x%p", pNewPin));
  1148. PR_LOG(modlog, 3, (" ulNewLen = %d", ulNewLen));
  1149. nssdbg_start_time(FUNC_C_SETPIN,&start);
  1150. rv = module_functions->C_SetPIN(hSession,
  1151. pOldPin,
  1152. ulOldLen,
  1153. pNewPin,
  1154. ulNewLen);
  1155. nssdbg_finish_time(FUNC_C_SETPIN,start);
  1156. log_rv(rv);
  1157. return rv;
  1158. }
  1159. static PRUint32 numOpenSessions = 0;
  1160. static PRUint32 maxOpenSessions = 0;
  1161. CK_RV NSSDBGC_OpenSession(
  1162. CK_SLOT_ID slotID,
  1163. CK_FLAGS flags,
  1164. CK_VOID_PTR pApplication,
  1165. CK_NOTIFY Notify,
  1166. CK_SESSION_HANDLE_PTR phSession
  1167. )
  1168. {
  1169. COMMON_DEFINITIONS;
  1170. PR_ATOMIC_INCREMENT((PRInt32 *)&numOpenSessions);
  1171. maxOpenSessions = PR_MAX(numOpenSessions, maxOpenSessions);
  1172. PR_LOG(modlog, 1, ("C_OpenSession"));
  1173. PR_LOG(modlog, 3, (fmt_slotID, slotID));
  1174. PR_LOG(modlog, 3, (fmt_flags, flags));
  1175. PR_LOG(modlog, 3, (" pApplication = 0x%p", pApplication));
  1176. PR_LOG(modlog, 3, (" Notify = 0x%x", Notify));
  1177. PR_LOG(modlog, 3, (" phSession = 0x%p", phSession));
  1178. nssdbg_start_time(FUNC_C_OPENSESSION,&start);
  1179. rv = module_functions->C_OpenSession(slotID,
  1180. flags,
  1181. pApplication,
  1182. Notify,
  1183. phSession);
  1184. nssdbg_finish_time(FUNC_C_OPENSESSION,start);
  1185. log_handle(4, " *phSession = 0x%x", *phSession);
  1186. log_rv(rv);
  1187. return rv;
  1188. }
  1189. CK_RV NSSDBGC_CloseSession(
  1190. CK_SESSION_HANDLE hSession
  1191. )
  1192. {
  1193. COMMON_DEFINITIONS;
  1194. PR_ATOMIC_DECREMENT((PRInt32 *)&numOpenSessions);
  1195. PR_LOG(modlog, 1, ("C_CloseSession"));
  1196. log_handle(3, fmt_hSession, hSession);
  1197. nssdbg_start_time(FUNC_C_CLOSESESSION,&start);
  1198. rv = module_functions->C_CloseSession(hSession);
  1199. nssdbg_finish_time(FUNC_C_CLOSESESSION,start);
  1200. log_rv(rv);
  1201. return rv;
  1202. }
  1203. CK_RV NSSDBGC_CloseAllSessions(
  1204. CK_SLOT_ID slotID
  1205. )
  1206. {
  1207. COMMON_DEFINITIONS;
  1208. PR_LOG(modlog, 1, ("C_CloseAllSessions"));
  1209. PR_LOG(modlog, 3, (fmt_slotID, slotID));
  1210. nssdbg_start_time(FUNC_C_CLOSEALLSESSIONS,&start);
  1211. rv = module_functions->C_CloseAllSessions(slotID);
  1212. nssdbg_finish_time(FUNC_C_CLOSEALLSESSIONS,start);
  1213. log_rv(rv);
  1214. return rv;
  1215. }
  1216. CK_RV NSSDBGC_GetSessionInfo(
  1217. CK_SESSION_HANDLE hSession,
  1218. CK_SESSION_INFO_PTR pInfo
  1219. )
  1220. {
  1221. COMMON_DEFINITIONS;
  1222. PR_LOG(modlog, 1, ("C_GetSessionInfo"));
  1223. log_handle(3, fmt_hSession, hSession);
  1224. PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
  1225. nssdbg_start_time(FUNC_C_GETSESSIONINFO,&start);
  1226. rv = module_functions->C_GetSessionInfo(hSession,
  1227. pInfo);
  1228. nssdbg_finish_time(FUNC_C_GETSESSIONINFO,start);
  1229. if (rv == CKR_OK) {
  1230. PR_LOG(modlog, 4, (fmt_slotID, pInfo->slotID));
  1231. log_state(pInfo->state);
  1232. PR_LOG(modlog, 4, (" flags = %s %s",
  1233. pInfo->flags & CKF_RW_SESSION ? "CKF_RW_SESSION" : "",
  1234. pInfo->flags & CKF_SERIAL_SESSION ? "CKF_SERIAL_SESSION" : ""));
  1235. PR_LOG(modlog, 4, (" deviceError = 0x%x", pInfo->ulDeviceError));
  1236. }
  1237. log_rv(rv);
  1238. return rv;
  1239. }
  1240. CK_RV NSSDBGC_GetOperationState(
  1241. CK_SESSION_HANDLE hSession,
  1242. CK_BYTE_PTR pOperationState,
  1243. CK_ULONG_PTR pulOperationStateLen
  1244. )
  1245. {
  1246. COMMON_DEFINITIONS;
  1247. PR_LOG(modlog, 1, ("C_GetOperationState"));
  1248. log_handle(3, fmt_hSession, hSession);
  1249. PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState));
  1250. PR_LOG(modlog, 3, (" pulOperationStateLen = 0x%p", pulOperationStateLen));
  1251. nssdbg_start_time(FUNC_C_GETOPERATIONSTATE,&start);
  1252. rv = module_functions->C_GetOperationState(hSession,
  1253. pOperationState,
  1254. pulOperationStateLen);
  1255. nssdbg_finish_time(FUNC_C_GETOPERATIONSTATE,start);
  1256. PR_LOG(modlog, 4, (" *pulOperationStateLen = 0x%x", *pulOperationStateLen));
  1257. log_rv(rv);
  1258. return rv;
  1259. }
  1260. CK_RV NSSDBGC_SetOperationState(
  1261. CK_SESSION_HANDLE hSession,
  1262. CK_BYTE_PTR pOperationState,
  1263. CK_ULONG ulOperationStateLen,
  1264. CK_OBJECT_HANDLE hEncryptionKey,
  1265. CK_OBJECT_HANDLE hAuthenticationKey
  1266. )
  1267. {
  1268. COMMON_DEFINITIONS;
  1269. PR_LOG(modlog, 1, ("C_SetOperationState"));
  1270. log_handle(3, fmt_hSession, hSession);
  1271. PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState));
  1272. PR_LOG(modlog, 3, (" ulOperationStateLen = %d", ulOperationStateLen));
  1273. log_handle(3, " hEncryptionKey = 0x%x", hEncryptionKey);
  1274. log_handle(3, " hAuthenticationKey = 0x%x", hAuthenticationKey);
  1275. nssdbg_start_time(FUNC_C_SETOPERATIONSTATE,&start);
  1276. rv = module_functions->C_SetOperationState(hSession,
  1277. pOperationState,
  1278. ulOperationStateLen,
  1279. hEncryptionKey,
  1280. hAuthenticationKey);
  1281. nssdbg_finish_time(FUNC_C_SETOPERATIONSTATE,start);
  1282. log_rv(rv);
  1283. return rv;
  1284. }
  1285. CK_RV NSSDBGC_Login(
  1286. CK_SESSION_HANDLE hSession,
  1287. CK_USER_TYPE userType,
  1288. CK_CHAR_PTR pPin,
  1289. CK_ULONG ulPinLen
  1290. )
  1291. {
  1292. COMMON_DEFINITIONS;
  1293. PR_LOG(modlog, 1, ("C_Login"));
  1294. log_handle(3, fmt_hSession, hSession);
  1295. PR_LOG(modlog, 3, (" userType = 0x%x", userType));
  1296. PR_LOG(modlog, 3, (fmt_pPin, pPin));
  1297. PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
  1298. nssdbg_start_time(FUNC_C_LOGIN,&start);
  1299. rv = module_functions->C_Login(hSession,
  1300. userType,
  1301. pPin,
  1302. ulPinLen);
  1303. nssdbg_finish_time(FUNC_C_LOGIN,start);
  1304. log_rv(rv);
  1305. return rv;
  1306. }
  1307. CK_RV NSSDBGC_Logout(
  1308. CK_SESSION_HANDLE hSession
  1309. )
  1310. {
  1311. COMMON_DEFINITIONS;
  1312. PR_LOG(modlog, 1, ("C_Logout"));
  1313. log_handle(3, fmt_hSession, hSession);
  1314. nssdbg_start_time(FUNC_C_LOGOUT,&start);
  1315. rv = module_functions->C_Logout(hSession);
  1316. nssdbg_finish_time(FUNC_C_LOGOUT,start);
  1317. log_rv(rv);
  1318. return rv;
  1319. }
  1320. CK_RV NSSDBGC_CreateObject(
  1321. CK_SESSION_HANDLE hSession,
  1322. CK_ATTRIBUTE_PTR pTemplate,
  1323. CK_ULONG ulCount,
  1324. CK_OBJECT_HANDLE_PTR phObject
  1325. )
  1326. {
  1327. COMMON_DEFINITIONS;
  1328. PR_LOG(modlog, 1, ("C_CreateObject"));
  1329. log_handle(3, fmt_hSession, hSession);
  1330. PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
  1331. PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
  1332. PR_LOG(modlog, 3, (fmt_phObject, phObject));
  1333. print_template(pTemplate, ulCount);
  1334. nssdbg_start_time(FUNC_C_CREATEOBJECT,&start);
  1335. rv = module_functions->C_CreateObject(hSession,
  1336. pTemplate,
  1337. ulCount,
  1338. phObject);
  1339. nssdbg_finish_time(FUNC_C_CREATEOBJECT,start);
  1340. log_handle(4, " *phObject = 0x%x", *phObject);
  1341. log_rv(rv);
  1342. return rv;
  1343. }
  1344. CK_RV NSSDBGC_CopyObject(
  1345. CK_SESSION_HANDLE hSession,
  1346. CK_OBJECT_HANDLE hObject,
  1347. CK_ATTRIBUTE_PTR pTemplate,
  1348. CK_ULONG ulCount,
  1349. CK_OBJECT_HANDLE_PTR phNewObject
  1350. )
  1351. {
  1352. COMMON_DEFINITIONS;
  1353. PR_LOG(modlog, 1, ("C_CopyObject"));
  1354. log_handle(3, fmt_hSession, hSession);
  1355. log_handle(3, fmt_hObject, hObject);
  1356. PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
  1357. PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
  1358. PR_LOG(modlog, 3, (" phNewObject = 0x%p", phNewObject));
  1359. print_template(pTemplate, ulCount);
  1360. nssdbg_start_time(FUNC_C_COPYOBJECT,&start);
  1361. rv = module_functions->C_CopyObject(hSession,
  1362. hObject,
  1363. pTemplate,
  1364. ulCount,
  1365. phNewObject);
  1366. nssdbg_finish_time(FUNC_C_COPYOBJECT,start);
  1367. log_handle(4, " *phNewObject = 0x%x", *phNewObject);
  1368. log_rv(rv);
  1369. return rv;
  1370. }
  1371. CK_RV NSSDBGC_DestroyObject(
  1372. CK_SESSION_HANDLE hSession,
  1373. CK_OBJECT_HANDLE hObject
  1374. )
  1375. {
  1376. COMMON_DEFINITIONS;
  1377. PR_LOG(modlog, 1, ("C_DestroyObject"));
  1378. log_handle(3, fmt_hSession, hSession);
  1379. log_handle(3, fmt_hObject, hObject);
  1380. nssdbg_start_time(FUNC_C_DESTROYOBJECT,&start);
  1381. rv = module_functions->C_DestroyObject(hSession,
  1382. hObject);
  1383. nssdbg_finish_time(FUNC_C_DESTROYOBJECT,start);
  1384. log_rv(rv);
  1385. return rv;
  1386. }
  1387. CK_RV NSSDBGC_GetObjectSize(
  1388. CK_SESSION_HANDLE hSession,
  1389. CK_OBJECT_HANDLE hObject,
  1390. CK_ULONG_PTR pulSize
  1391. )
  1392. {
  1393. COMMON_DEFINITIONS;
  1394. PR_LOG(modlog, 1, ("C_GetObjectSize"));
  1395. log_handle(3, fmt_hSession, hSession);
  1396. log_handle(3, fmt_hObject, hObject);
  1397. PR_LOG(modlog, 3, (" pulSize = 0x%p", pulSize));
  1398. nssdbg_start_time(FUNC_C_GETOBJECTSIZE,&start);
  1399. rv = module_functions->C_GetObjectSize(hSession,
  1400. hObject,
  1401. pulSize);
  1402. nssdbg_finish_time(FUNC_C_GETOBJECTSIZE,start);
  1403. PR_LOG(modlog, 4, (" *pulSize = 0x%x", *pulSize));
  1404. log_rv(rv);
  1405. return rv;
  1406. }
  1407. CK_RV NSSDBGC_GetAttributeValue(
  1408. CK_SESSION_HANDLE hSession,
  1409. CK_OBJECT_HANDLE hObject,
  1410. CK_ATTRIBUTE_PTR pTemplate,
  1411. CK_ULONG ulCount
  1412. )
  1413. {
  1414. COMMON_DEFINITIONS;
  1415. PR_LOG(modlog, 1, ("C_GetAttributeValue"));
  1416. log_handle(3, fmt_hSession, hSession);
  1417. log_handle(3, fmt_hObject, hObject);
  1418. PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
  1419. PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
  1420. nssdbg_start_time(FUNC_C_GETATTRIBUTEVALUE,&start);
  1421. rv = module_functions->C_GetAttributeValue(hSession,
  1422. hObject,
  1423. pTemplate,
  1424. ulCount);
  1425. nssdbg_finish_time(FUNC_C_GETATTRIBUTEVALUE,start);
  1426. print_template(pTemplate, ulCount);
  1427. log_rv(rv);
  1428. return rv;
  1429. }
  1430. CK_RV NSSDBGC_SetAttributeValue(
  1431. CK_SESSION_HANDLE hSession,
  1432. CK_OBJECT_HANDLE hObject,
  1433. CK_ATTRIBUTE_PTR pTemplate,
  1434. CK_ULONG ulCount
  1435. )
  1436. {
  1437. COMMON_DEFINITIONS;
  1438. PR_LOG(modlog, 1, ("C_SetAttributeValue"));
  1439. log_handle(3, fmt_hSession, hSession);
  1440. log_handle(3, fmt_hObject, hObject);
  1441. PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
  1442. PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
  1443. print_template(pTemplate, ulCount);
  1444. nssdbg_start_time(FUNC_C_SETATTRIBUTEVALUE,&start);
  1445. rv = module_functions->C_SetAttributeValue(hSession,
  1446. hObject,
  1447. pTemplate,
  1448. ulCount);
  1449. nssdbg_finish_time(FUNC_C_SETATTRIBUTEVALUE,start);
  1450. log_rv(rv);
  1451. return rv;
  1452. }
  1453. CK_RV NSSDBGC_FindObjectsInit(
  1454. CK_SESSION_HANDLE hSession,
  1455. CK_ATTRIBUTE_PTR pTemplate,
  1456. CK_ULONG ulCount
  1457. )
  1458. {
  1459. COMMON_DEFINITIONS;
  1460. PR_LOG(modlog, 1, ("C_FindObjectsInit"));
  1461. log_handle(3, fmt_hSession, hSession);
  1462. PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
  1463. PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
  1464. print_template(pTemplate, ulCount);
  1465. nssdbg_start_time(FUNC_C_FINDOBJECTSINIT,&start);
  1466. rv = module_functions->C_FindObjectsInit(hSession,
  1467. pTemplate,
  1468. ulCount);
  1469. nssdbg_finish_time(FUNC_C_FINDOBJECTSINIT,start);
  1470. log_rv(rv);
  1471. return rv;
  1472. }
  1473. CK_RV NSSDBGC_FindObjects(
  1474. CK_SESSION_HANDLE hSession,
  1475. CK_OBJECT_HANDLE_PTR phObject,
  1476. CK_ULONG ulMaxObjectCount,
  1477. CK_ULONG_PTR pulObjectCount
  1478. )
  1479. {
  1480. COMMON_DEFINITIONS;
  1481. CK_ULONG i;
  1482. PR_LOG(modlog, 1, ("C_FindObjects"));
  1483. log_handle(3, fmt_hSession, hSession);
  1484. PR_LOG(modlog, 3, (fmt_phObject, phObject));
  1485. PR_LOG(modlog, 3, (" ulMaxObjectCount = %d", ulMaxObjectCount));
  1486. PR_LOG(modlog, 3, (" pulObjectCount = 0x%p", pulObjectCount));
  1487. nssdbg_start_time(FUNC_C_FINDOBJECTS,&start);
  1488. rv = module_functions->C_FindObjects(hSession,
  1489. phObject,
  1490. ulMaxObjectCount,
  1491. pulObjectCount);
  1492. nssdbg_finish_time(FUNC_C_FINDOBJECTS,start);
  1493. PR_LOG(modlog, 4, (" *pulObjectCount = 0x%x", *pulObjectCount));
  1494. for (i=0; i<*pulObjectCount; i++) {
  1495. PR_LOG(modlog, 4, (" phObject[%d] = 0x%x%s", i, phObject[i],
  1496. phObject[i] ? "" : fmt_invalid_handle));
  1497. }
  1498. log_rv(rv);
  1499. return rv;
  1500. }
  1501. CK_RV NSSDBGC_FindObjectsFinal(
  1502. CK_SESSION_HANDLE hSession
  1503. )
  1504. {
  1505. COMMON_DEFINITIONS;
  1506. PR_LOG(modlog, 1, ("C_FindObjectsFinal"));
  1507. log_handle(3, fmt_hSession, hSession);
  1508. nssdbg_start_time(FUNC_C_FINDOBJECTSFINAL,&start);
  1509. rv = module_functions->C_FindObjectsFinal(hSession);
  1510. nssdbg_finish_time(FUNC_C_FINDOBJECTSFINAL,start);
  1511. log_rv(rv);
  1512. return rv;
  1513. }
  1514. CK_RV NSSDBGC_EncryptInit(
  1515. CK_SESSION_HANDLE hSession,
  1516. CK_MECHANISM_PTR pMechanism,
  1517. CK_OBJECT_HANDLE h