| OLD | NEW |
|---|
| (Empty) |
| 1 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 2 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 4 #include "prlog.h" | |
| 5 #include <stdio.h> | |
| 6 #include "cert.h" /* for CERT_DerNameToAscii & CERT_Hexify */ | |
| 7 | |
| 8 static PRLogModuleInfo *modlog = NULL; | |
| 9 | |
| 10 static CK_FUNCTION_LIST_PTR module_functions; | |
| 11 | |
| 12 static CK_FUNCTION_LIST debug_functions; | |
| 13 | |
| 14 static void print_final_statistics(void); | |
| 15 | |
| 16 #define STRING static const char | |
| 17 | |
| 18 STRING fmt_flags[] = " flags = 0x%x"; | |
| 19 STRING fmt_hKey[] = " hKey = 0x%x"; | |
| 20 STRING fmt_hObject[] = " hObject = 0x%x"; | |
| 21 STRING fmt_hSession[] = " hSession = 0x%x"; | |
| 22 STRING fmt_manufacturerID[] = " manufacturerID = \"%.32s\""; | |
| 23 STRING fmt_pData[] = " pData = 0x%p"; | |
| 24 STRING fmt_pDigest[] = " pDigest = 0x%p"; | |
| 25 STRING fmt_pEncryptedData[] = " pEncryptedData = 0x%p"; | |
| 26 STRING fmt_pEncryptedPart[] = " pEncryptedPart = 0x%p"; | |
| 27 STRING fmt_pInfo[] = " pInfo = 0x%p"; | |
| 28 STRING fmt_pMechanism[] = " pMechanism = 0x%p"; | |
| 29 STRING fmt_pOperationState[] = " pOperationState = 0x%p"; | |
| 30 STRING fmt_pPart[] = " pPart = 0x%p"; | |
| 31 STRING fmt_pPin[] = " pPin = 0x%p"; | |
| 32 STRING fmt_pSignature[] = " pSignature = 0x%p"; | |
| 33 STRING fmt_pTemplate[] = " pTemplate = 0x%p"; | |
| 34 STRING fmt_pWrappedKey[] = " pWrappedKey = 0x%p"; | |
| 35 STRING fmt_phKey[] = " phKey = 0x%p"; | |
| 36 STRING fmt_phObject[] = " phObject = 0x%p"; | |
| 37 STRING fmt_pulCount[] = " pulCount = 0x%p"; | |
| 38 STRING fmt_pulDataLen[] = " pulDataLen = 0x%p"; | |
| 39 STRING fmt_pulDigestLen[] = " pulDigestLen = 0x%p"; | |
| 40 STRING fmt_pulEncryptedPartLen[] = " pulEncryptedPartLen = 0x%p"; | |
| 41 STRING fmt_pulPartLen[] = " pulPartLen = 0x%p"; | |
| 42 STRING fmt_pulSignatureLen[] = " pulSignatureLen = 0x%p"; | |
| 43 STRING fmt_slotID[] = " slotID = 0x%x"; | |
| 44 STRING fmt_sphKey[] = " *phKey = 0x%x"; | |
| 45 STRING fmt_spulCount[] = " *pulCount = 0x%x"; | |
| 46 STRING fmt_spulDataLen[] = " *pulDataLen = 0x%x"; | |
| 47 STRING fmt_spulDigestLen[] = " *pulDigestLen = 0x%x"; | |
| 48 STRING fmt_spulEncryptedPartLen[] = " *pulEncryptedPartLen = 0x%x"; | |
| 49 STRING fmt_spulPartLen[] = " *pulPartLen = 0x%x"; | |
| 50 STRING fmt_spulSignatureLen[] = " *pulSignatureLen = 0x%x"; | |
| 51 STRING fmt_ulAttributeCount[] = " ulAttributeCount = %d"; | |
| 52 STRING fmt_ulCount[] = " ulCount = %d"; | |
| 53 STRING fmt_ulDataLen[] = " ulDataLen = %d"; | |
| 54 STRING fmt_ulEncryptedPartLen[] = " ulEncryptedPartLen = %d"; | |
| 55 STRING fmt_ulPartLen[] = " ulPartLen = %d"; | |
| 56 STRING fmt_ulPinLen[] = " ulPinLen = %d"; | |
| 57 STRING fmt_ulSignatureLen[] = " ulSignatureLen = %d"; | |
| 58 | |
| 59 STRING fmt_fwVersion[] = " firmware version: %d.%d"; | |
| 60 STRING fmt_hwVersion[] = " hardware version: %d.%d"; | |
| 61 STRING fmt_s_qsq_d[] = " %s = \"%s\" [%d]"; | |
| 62 STRING fmt_s_s_d[] = " %s = %s [%d]"; | |
| 63 STRING fmt_s_lu[] = " %s = %lu"; | |
| 64 STRING fmt_invalid_handle[] = " (CK_INVALID_HANDLE)"; | |
| 65 | |
| 66 | |
| 67 static void get_attr_type_str(CK_ATTRIBUTE_TYPE atype, char *str, int len) | |
| 68 { | |
| 69 #define CASE(attr) case attr: a = #attr ; break | |
| 70 | |
| 71 const char * a = NULL; | |
| 72 | |
| 73 switch (atype) { | |
| 74 CASE(CKA_CLASS); | |
| 75 CASE(CKA_TOKEN); | |
| 76 CASE(CKA_PRIVATE); | |
| 77 CASE(CKA_LABEL); | |
| 78 CASE(CKA_APPLICATION); | |
| 79 CASE(CKA_VALUE); | |
| 80 CASE(CKA_OBJECT_ID); | |
| 81 CASE(CKA_CERTIFICATE_TYPE); | |
| 82 CASE(CKA_CERTIFICATE_CATEGORY); | |
| 83 CASE(CKA_ISSUER); | |
| 84 CASE(CKA_SERIAL_NUMBER); | |
| 85 CASE(CKA_AC_ISSUER); | |
| 86 CASE(CKA_OWNER); | |
| 87 CASE(CKA_ATTR_TYPES); | |
| 88 CASE(CKA_TRUSTED); | |
| 89 CASE(CKA_KEY_TYPE); | |
| 90 CASE(CKA_SUBJECT); | |
| 91 CASE(CKA_ID); | |
| 92 CASE(CKA_SENSITIVE); | |
| 93 CASE(CKA_ENCRYPT); | |
| 94 CASE(CKA_DECRYPT); | |
| 95 CASE(CKA_WRAP); | |
| 96 CASE(CKA_UNWRAP); | |
| 97 CASE(CKA_SIGN); | |
| 98 CASE(CKA_SIGN_RECOVER); | |
| 99 CASE(CKA_VERIFY); | |
| 100 CASE(CKA_VERIFY_RECOVER); | |
| 101 CASE(CKA_DERIVE); | |
| 102 CASE(CKA_START_DATE); | |
| 103 CASE(CKA_END_DATE); | |
| 104 CASE(CKA_MODULUS); | |
| 105 CASE(CKA_MODULUS_BITS); | |
| 106 CASE(CKA_PUBLIC_EXPONENT); | |
| 107 CASE(CKA_PRIVATE_EXPONENT); | |
| 108 CASE(CKA_PRIME_1); | |
| 109 CASE(CKA_PRIME_2); | |
| 110 CASE(CKA_EXPONENT_1); | |
| 111 CASE(CKA_EXPONENT_2); | |
| 112 CASE(CKA_COEFFICIENT); | |
| 113 CASE(CKA_PRIME); | |
| 114 CASE(CKA_SUBPRIME); | |
| 115 CASE(CKA_BASE); | |
| 116 CASE(CKA_PRIME_BITS); | |
| 117 CASE(CKA_SUBPRIME_BITS); | |
| 118 CASE(CKA_VALUE_BITS); | |
| 119 CASE(CKA_VALUE_LEN); | |
| 120 CASE(CKA_EXTRACTABLE); | |
| 121 CASE(CKA_LOCAL); | |
| 122 CASE(CKA_NEVER_EXTRACTABLE); | |
| 123 CASE(CKA_ALWAYS_SENSITIVE); | |
| 124 CASE(CKA_KEY_GEN_MECHANISM); | |
| 125 CASE(CKA_MODIFIABLE); | |
| 126 CASE(CKA_ECDSA_PARAMS); | |
| 127 CASE(CKA_EC_POINT); | |
| 128 CASE(CKA_SECONDARY_AUTH); | |
| 129 CASE(CKA_AUTH_PIN_FLAGS); | |
| 130 CASE(CKA_HW_FEATURE_TYPE); | |
| 131 CASE(CKA_RESET_ON_INIT); | |
| 132 CASE(CKA_HAS_RESET); | |
| 133 CASE(CKA_VENDOR_DEFINED); | |
| 134 CASE(CKA_NSS_URL); | |
| 135 CASE(CKA_NSS_EMAIL); | |
| 136 CASE(CKA_NSS_SMIME_INFO); | |
| 137 CASE(CKA_NSS_SMIME_TIMESTAMP); | |
| 138 CASE(CKA_NSS_PKCS8_SALT); | |
| 139 CASE(CKA_NSS_PASSWORD_CHECK); | |
| 140 CASE(CKA_NSS_EXPIRES); | |
| 141 CASE(CKA_NSS_KRL); | |
| 142 CASE(CKA_NSS_PQG_COUNTER); | |
| 143 CASE(CKA_NSS_PQG_SEED); | |
| 144 CASE(CKA_NSS_PQG_H); | |
| 145 CASE(CKA_NSS_PQG_SEED_BITS); | |
| 146 CASE(CKA_TRUST); | |
| 147 CASE(CKA_TRUST_DIGITAL_SIGNATURE); | |
| 148 CASE(CKA_TRUST_NON_REPUDIATION); | |
| 149 CASE(CKA_TRUST_KEY_ENCIPHERMENT); | |
| 150 CASE(CKA_TRUST_DATA_ENCIPHERMENT); | |
| 151 CASE(CKA_TRUST_KEY_AGREEMENT); | |
| 152 CASE(CKA_TRUST_KEY_CERT_SIGN); | |
| 153 CASE(CKA_TRUST_CRL_SIGN); | |
| 154 CASE(CKA_TRUST_SERVER_AUTH); | |
| 155 CASE(CKA_TRUST_CLIENT_AUTH); | |
| 156 CASE(CKA_TRUST_CODE_SIGNING); | |
| 157 CASE(CKA_TRUST_EMAIL_PROTECTION); | |
| 158 CASE(CKA_TRUST_IPSEC_END_SYSTEM); | |
| 159 CASE(CKA_TRUST_IPSEC_TUNNEL); | |
| 160 CASE(CKA_TRUST_IPSEC_USER); | |
| 161 CASE(CKA_TRUST_TIME_STAMPING); | |
| 162 CASE(CKA_CERT_SHA1_HASH); | |
| 163 CASE(CKA_CERT_MD5_HASH); | |
| 164 CASE(CKA_NETSCAPE_DB); | |
| 165 CASE(CKA_NETSCAPE_TRUST); | |
| 166 default: break; | |
| 167 } | |
| 168 if (a) | |
| 169 PR_snprintf(str, len, "%s", a); | |
| 170 else | |
| 171 PR_snprintf(str, len, "0x%p", atype); | |
| 172 } | |
| 173 | |
| 174 static void get_obj_class(CK_OBJECT_CLASS objClass, char *str, int len) | |
| 175 { | |
| 176 | |
| 177 const char * a = NULL; | |
| 178 | |
| 179 switch (objClass) { | |
| 180 CASE(CKO_DATA); | |
| 181 CASE(CKO_CERTIFICATE); | |
| 182 CASE(CKO_PUBLIC_KEY); | |
| 183 CASE(CKO_PRIVATE_KEY); | |
| 184 CASE(CKO_SECRET_KEY); | |
| 185 CASE(CKO_HW_FEATURE); | |
| 186 CASE(CKO_DOMAIN_PARAMETERS); | |
| 187 CASE(CKO_NSS_CRL); | |
| 188 CASE(CKO_NSS_SMIME); | |
| 189 CASE(CKO_NSS_TRUST); | |
| 190 CASE(CKO_NSS_BUILTIN_ROOT_LIST); | |
| 191 default: break; | |
| 192 } | |
| 193 if (a) | |
| 194 PR_snprintf(str, len, "%s", a); | |
| 195 else | |
| 196 PR_snprintf(str, len, "0x%p", objClass); | |
| 197 } | |
| 198 | |
| 199 static void get_trust_val(CK_TRUST trust, char *str, int len) | |
| 200 { | |
| 201 const char * a = NULL; | |
| 202 | |
| 203 switch (trust) { | |
| 204 CASE(CKT_NSS_TRUSTED); | |
| 205 CASE(CKT_NSS_TRUSTED_DELEGATOR); | |
| 206 CASE(CKT_NSS_NOT_TRUSTED); | |
| 207 CASE(CKT_NSS_MUST_VERIFY_TRUST); | |
| 208 CASE(CKT_NSS_TRUST_UNKNOWN); | |
| 209 CASE(CKT_NSS_VALID_DELEGATOR); | |
| 210 default: break; | |
| 211 } | |
| 212 if (a) | |
| 213 PR_snprintf(str, len, "%s", a); | |
| 214 else | |
| 215 PR_snprintf(str, len, "0x%p", trust); | |
| 216 } | |
| 217 | |
| 218 static void log_rv(CK_RV rv) | |
| 219 { | |
| 220 const char * a = NULL; | |
| 221 | |
| 222 switch (rv) { | |
| 223 CASE(CKR_OK); | |
| 224 CASE(CKR_CANCEL); | |
| 225 CASE(CKR_HOST_MEMORY); | |
| 226 CASE(CKR_SLOT_ID_INVALID); | |
| 227 CASE(CKR_GENERAL_ERROR); | |
| 228 CASE(CKR_FUNCTION_FAILED); | |
| 229 CASE(CKR_ARGUMENTS_BAD); | |
| 230 CASE(CKR_NO_EVENT); | |
| 231 CASE(CKR_NEED_TO_CREATE_THREADS); | |
| 232 CASE(CKR_CANT_LOCK); | |
| 233 CASE(CKR_ATTRIBUTE_READ_ONLY); | |
| 234 CASE(CKR_ATTRIBUTE_SENSITIVE); | |
| 235 CASE(CKR_ATTRIBUTE_TYPE_INVALID); | |
| 236 CASE(CKR_ATTRIBUTE_VALUE_INVALID); | |
| 237 CASE(CKR_DATA_INVALID); | |
| 238 CASE(CKR_DATA_LEN_RANGE); | |
| 239 CASE(CKR_DEVICE_ERROR); | |
| 240 CASE(CKR_DEVICE_MEMORY); | |
| 241 CASE(CKR_DEVICE_REMOVED); | |
| 242 CASE(CKR_ENCRYPTED_DATA_INVALID); | |
| 243 CASE(CKR_ENCRYPTED_DATA_LEN_RANGE); | |
| 244 CASE(CKR_FUNCTION_CANCELED); | |
| 245 CASE(CKR_FUNCTION_NOT_PARALLEL); | |
| 246 CASE(CKR_FUNCTION_NOT_SUPPORTED); | |
| 247 CASE(CKR_KEY_HANDLE_INVALID); | |
| 248 CASE(CKR_KEY_SIZE_RANGE); | |
| 249 CASE(CKR_KEY_TYPE_INCONSISTENT); | |
| 250 CASE(CKR_KEY_NOT_NEEDED); | |
| 251 CASE(CKR_KEY_CHANGED); | |
| 252 CASE(CKR_KEY_NEEDED); | |
| 253 CASE(CKR_KEY_INDIGESTIBLE); | |
| 254 CASE(CKR_KEY_FUNCTION_NOT_PERMITTED); | |
| 255 CASE(CKR_KEY_NOT_WRAPPABLE); | |
| 256 CASE(CKR_KEY_UNEXTRACTABLE); | |
| 257 CASE(CKR_MECHANISM_INVALID); | |
| 258 CASE(CKR_MECHANISM_PARAM_INVALID); | |
| 259 CASE(CKR_OBJECT_HANDLE_INVALID); | |
| 260 CASE(CKR_OPERATION_ACTIVE); | |
| 261 CASE(CKR_OPERATION_NOT_INITIALIZED); | |
| 262 CASE(CKR_PIN_INCORRECT); | |
| 263 CASE(CKR_PIN_INVALID); | |
| 264 CASE(CKR_PIN_LEN_RANGE); | |
| 265 CASE(CKR_PIN_EXPIRED); | |
| 266 CASE(CKR_PIN_LOCKED); | |
| 267 CASE(CKR_SESSION_CLOSED); | |
| 268 CASE(CKR_SESSION_COUNT); | |
| 269 CASE(CKR_SESSION_HANDLE_INVALID); | |
| 270 CASE(CKR_SESSION_PARALLEL_NOT_SUPPORTED); | |
| 271 CASE(CKR_SESSION_READ_ONLY); | |
| 272 CASE(CKR_SESSION_EXISTS); | |
| 273 CASE(CKR_SESSION_READ_ONLY_EXISTS); | |
| 274 CASE(CKR_SESSION_READ_WRITE_SO_EXISTS); | |
| 275 CASE(CKR_SIGNATURE_INVALID); | |
| 276 CASE(CKR_SIGNATURE_LEN_RANGE); | |
| 277 CASE(CKR_TEMPLATE_INCOMPLETE); | |
| 278 CASE(CKR_TEMPLATE_INCONSISTENT); | |
| 279 CASE(CKR_TOKEN_NOT_PRESENT); | |
| 280 CASE(CKR_TOKEN_NOT_RECOGNIZED); | |
| 281 CASE(CKR_TOKEN_WRITE_PROTECTED); | |
| 282 CASE(CKR_UNWRAPPING_KEY_HANDLE_INVALID); | |
| 283 CASE(CKR_UNWRAPPING_KEY_SIZE_RANGE); | |
| 284 CASE(CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT); | |
| 285 CASE(CKR_USER_ALREADY_LOGGED_IN); | |
| 286 CASE(CKR_USER_NOT_LOGGED_IN); | |
| 287 CASE(CKR_USER_PIN_NOT_INITIALIZED); | |
| 288 CASE(CKR_USER_TYPE_INVALID); | |
| 289 CASE(CKR_USER_ANOTHER_ALREADY_LOGGED_IN); | |
| 290 CASE(CKR_USER_TOO_MANY_TYPES); | |
| 291 CASE(CKR_WRAPPED_KEY_INVALID); | |
| 292 CASE(CKR_WRAPPED_KEY_LEN_RANGE); | |
| 293 CASE(CKR_WRAPPING_KEY_HANDLE_INVALID); | |
| 294 CASE(CKR_WRAPPING_KEY_SIZE_RANGE); | |
| 295 CASE(CKR_WRAPPING_KEY_TYPE_INCONSISTENT); | |
| 296 CASE(CKR_RANDOM_SEED_NOT_SUPPORTED); | |
| 297 CASE(CKR_RANDOM_NO_RNG); | |
| 298 CASE(CKR_DOMAIN_PARAMS_INVALID); | |
| 299 CASE(CKR_BUFFER_TOO_SMALL); | |
| 300 CASE(CKR_SAVED_STATE_INVALID); | |
| 301 CASE(CKR_INFORMATION_SENSITIVE); | |
| 302 CASE(CKR_STATE_UNSAVEABLE); | |
| 303 CASE(CKR_CRYPTOKI_NOT_INITIALIZED); | |
| 304 CASE(CKR_CRYPTOKI_ALREADY_INITIALIZED); | |
| 305 CASE(CKR_MUTEX_BAD); | |
| 306 CASE(CKR_MUTEX_NOT_LOCKED); | |
| 307 CASE(CKR_FUNCTION_REJECTED); | |
| 308 CASE(CKR_KEY_PARAMS_INVALID); | |
| 309 default: break; | |
| 310 } | |
| 311 if (a) | |
| 312 PR_LOG(modlog, 1, (" rv = %s\n", a)); | |
| 313 else | |
| 314 PR_LOG(modlog, 1, (" rv = 0x%x\n", rv)); | |
| 315 } | |
| 316 | |
| 317 static void log_state(CK_STATE state) | |
| 318 { | |
| 319 const char * a = NULL; | |
| 320 | |
| 321 switch (state) { | |
| 322 CASE(CKS_RO_PUBLIC_SESSION); | |
| 323 CASE(CKS_RO_USER_FUNCTIONS); | |
| 324 CASE(CKS_RW_PUBLIC_SESSION); | |
| 325 CASE(CKS_RW_USER_FUNCTIONS); | |
| 326 CASE(CKS_RW_SO_FUNCTIONS); | |
| 327 default: break; | |
| 328 } | |
| 329 if (a) | |
| 330 PR_LOG(modlog, 1, (" state = %s\n", a)); | |
| 331 else | |
| 332 PR_LOG(modlog, 1, (" state = 0x%x\n", state)); | |
| 333 } | |
| 334 | |
| 335 static void log_handle(int level, const char * format, CK_ULONG handle) | |
| 336 { | |
| 337 char fmtBuf[80]; | |
| 338 if (handle) | |
| 339 PR_LOG(modlog, level, (format, handle)); | |
| 340 else { | |
| 341 PL_strncpyz(fmtBuf, format, sizeof fmtBuf); | |
| 342 PL_strcatn(fmtBuf, sizeof fmtBuf, fmt_invalid_handle); | |
| 343 PR_LOG(modlog, level, (fmtBuf, handle)); | |
| 344 } | |
| 345 } | |
| 346 | |
| 347 static void print_mechanism(CK_MECHANISM_PTR m) | |
| 348 { | |
| 349 | |
| 350 const char * a = NULL; | |
| 351 | |
| 352 switch (m->mechanism) { | |
| 353 CASE(CKM_AES_CBC); | |
| 354 CASE(CKM_AES_CBC_ENCRYPT_DATA); | |
| 355 CASE(CKM_AES_CBC_PAD); | |
| 356 CASE(CKM_AES_CCM); | |
| 357 CASE(CKM_AES_CTR); | |
| 358 CASE(CKM_AES_CTS); | |
| 359 CASE(CKM_AES_GCM); | |
| 360 CASE(CKM_AES_ECB); | |
| 361 CASE(CKM_AES_ECB_ENCRYPT_DATA); | |
| 362 CASE(CKM_AES_KEY_GEN); | |
| 363 CASE(CKM_AES_MAC); | |
| 364 CASE(CKM_AES_MAC_GENERAL); | |
| 365 CASE(CKM_CAMELLIA_CBC); | |
| 366 CASE(CKM_CAMELLIA_CBC_ENCRYPT_DATA); | |
| 367 CASE(CKM_CAMELLIA_CBC_PAD); | |
| 368 CASE(CKM_CAMELLIA_ECB); | |
| 369 CASE(CKM_CAMELLIA_ECB_ENCRYPT_DATA); | |
| 370 CASE(CKM_CAMELLIA_KEY_GEN); | |
| 371 CASE(CKM_CAMELLIA_MAC); | |
| 372 CASE(CKM_CAMELLIA_MAC_GENERAL); | |
| 373 CASE(CKM_CDMF_CBC); | |
| 374 CASE(CKM_CDMF_CBC_PAD); | |
| 375 CASE(CKM_CDMF_ECB); | |
| 376 CASE(CKM_CDMF_KEY_GEN); | |
| 377 CASE(CKM_CDMF_MAC); | |
| 378 CASE(CKM_CDMF_MAC_GENERAL); | |
| 379 CASE(CKM_CMS_SIG); | |
| 380 CASE(CKM_CONCATENATE_BASE_AND_DATA); | |
| 381 CASE(CKM_CONCATENATE_BASE_AND_KEY); | |
| 382 CASE(CKM_CONCATENATE_DATA_AND_BASE); | |
| 383 CASE(CKM_DES2_KEY_GEN); | |
| 384 CASE(CKM_DES3_CBC); | |
| 385 CASE(CKM_DES3_CBC_ENCRYPT_DATA); | |
| 386 CASE(CKM_DES3_CBC_PAD); | |
| 387 CASE(CKM_DES3_ECB); | |
| 388 CASE(CKM_DES3_ECB_ENCRYPT_DATA); | |
| 389 CASE(CKM_DES3_KEY_GEN); | |
| 390 CASE(CKM_DES3_MAC); | |
| 391 CASE(CKM_DES3_MAC_GENERAL); | |
| 392 CASE(CKM_DES_CBC); | |
| 393 CASE(CKM_DES_CBC_ENCRYPT_DATA); | |
| 394 CASE(CKM_DES_CBC_PAD); | |
| 395 CASE(CKM_DES_CFB64); | |
| 396 CASE(CKM_DES_CFB8); | |
| 397 CASE(CKM_DES_ECB); | |
| 398 CASE(CKM_DES_ECB_ENCRYPT_DATA); | |
| 399 CASE(CKM_DES_KEY_GEN); | |
| 400 CASE(CKM_DES_MAC); | |
| 401 CASE(CKM_DES_MAC_GENERAL); | |
| 402 CASE(CKM_DES_OFB64); | |
| 403 CASE(CKM_DES_OFB8); | |
| 404 CASE(CKM_DH_PKCS_DERIVE); | |
| 405 CASE(CKM_DH_PKCS_KEY_PAIR_GEN); | |
| 406 CASE(CKM_DH_PKCS_PARAMETER_GEN); | |
| 407 CASE(CKM_DSA); | |
| 408 CASE(CKM_DSA_KEY_PAIR_GEN); | |
| 409 CASE(CKM_DSA_PARAMETER_GEN); | |
| 410 CASE(CKM_DSA_SHA1); | |
| 411 CASE(CKM_ECDH1_COFACTOR_DERIVE); | |
| 412 CASE(CKM_ECDH1_DERIVE); | |
| 413 CASE(CKM_ECDSA); | |
| 414 CASE(CKM_ECDSA_SHA1); | |
| 415 CASE(CKM_ECMQV_DERIVE); | |
| 416 CASE(CKM_EC_KEY_PAIR_GEN); /* also CASE(CKM_ECDSA_KEY_PAIR_GEN); */ | |
| 417 CASE(CKM_EXTRACT_KEY_FROM_KEY); | |
| 418 CASE(CKM_FASTHASH); | |
| 419 CASE(CKM_FORTEZZA_TIMESTAMP); | |
| 420 CASE(CKM_GENERIC_SECRET_KEY_GEN); | |
| 421 CASE(CKM_IDEA_CBC); | |
| 422 CASE(CKM_IDEA_CBC_PAD); | |
| 423 CASE(CKM_IDEA_ECB); | |
| 424 CASE(CKM_IDEA_KEY_GEN); | |
| 425 CASE(CKM_IDEA_MAC); | |
| 426 CASE(CKM_IDEA_MAC_GENERAL); | |
| 427 CASE(CKM_KEA_KEY_DERIVE); | |
| 428 CASE(CKM_KEA_KEY_PAIR_GEN); | |
| 429 CASE(CKM_KEY_WRAP_LYNKS); | |
| 430 CASE(CKM_KEY_WRAP_SET_OAEP); | |
| 431 CASE(CKM_MD2); | |
| 432 CASE(CKM_MD2_HMAC); | |
| 433 CASE(CKM_MD2_HMAC_GENERAL); | |
| 434 CASE(CKM_MD2_KEY_DERIVATION); | |
| 435 CASE(CKM_MD2_RSA_PKCS); | |
| 436 CASE(CKM_MD5); | |
| 437 CASE(CKM_MD5_HMAC); | |
| 438 CASE(CKM_MD5_HMAC_GENERAL); | |
| 439 CASE(CKM_MD5_KEY_DERIVATION); | |
| 440 CASE(CKM_MD5_RSA_PKCS); | |
| 441 CASE(CKM_PBA_SHA1_WITH_SHA1_HMAC); | |
| 442 CASE(CKM_PBE_MD2_DES_CBC); | |
| 443 CASE(CKM_PBE_MD5_DES_CBC); | |
| 444 CASE(CKM_PBE_SHA1_DES2_EDE_CBC); | |
| 445 CASE(CKM_PBE_SHA1_DES3_EDE_CBC); | |
| 446 CASE(CKM_PBE_SHA1_RC2_128_CBC); | |
| 447 CASE(CKM_PBE_SHA1_RC2_40_CBC); | |
| 448 CASE(CKM_PBE_SHA1_RC4_128); | |
| 449 CASE(CKM_PBE_SHA1_RC4_40); | |
| 450 CASE(CKM_PKCS5_PBKD2); | |
| 451 CASE(CKM_RC2_CBC); | |
| 452 CASE(CKM_RC2_CBC_PAD); | |
| 453 CASE(CKM_RC2_ECB); | |
| 454 CASE(CKM_RC2_KEY_GEN); | |
| 455 CASE(CKM_RC2_MAC); | |
| 456 CASE(CKM_RC2_MAC_GENERAL); | |
| 457 CASE(CKM_RC4); | |
| 458 CASE(CKM_RC4_KEY_GEN); | |
| 459 CASE(CKM_RC5_CBC); | |
| 460 CASE(CKM_RC5_CBC_PAD); | |
| 461 CASE(CKM_RC5_ECB); | |
| 462 CASE(CKM_RC5_KEY_GEN); | |
| 463 CASE(CKM_RC5_MAC); | |
| 464 CASE(CKM_RC5_MAC_GENERAL); | |
| 465 CASE(CKM_RIPEMD128); | |
| 466 CASE(CKM_RIPEMD128_HMAC); | |
| 467 CASE(CKM_RIPEMD128_HMAC_GENERAL); | |
| 468 CASE(CKM_RIPEMD128_RSA_PKCS); | |
| 469 CASE(CKM_RIPEMD160); | |
| 470 CASE(CKM_RIPEMD160_HMAC); | |
| 471 CASE(CKM_RIPEMD160_HMAC_GENERAL); | |
| 472 CASE(CKM_RIPEMD160_RSA_PKCS); | |
| 473 CASE(CKM_RSA_9796); | |
| 474 CASE(CKM_RSA_PKCS); | |
| 475 CASE(CKM_RSA_PKCS_KEY_PAIR_GEN); | |
| 476 CASE(CKM_RSA_PKCS_OAEP); | |
| 477 CASE(CKM_RSA_PKCS_PSS); | |
| 478 CASE(CKM_RSA_X9_31); | |
| 479 CASE(CKM_RSA_X9_31_KEY_PAIR_GEN); | |
| 480 CASE(CKM_RSA_X_509); | |
| 481 CASE(CKM_SHA1_KEY_DERIVATION); | |
| 482 CASE(CKM_SHA1_RSA_PKCS); | |
| 483 CASE(CKM_SHA1_RSA_PKCS_PSS); | |
| 484 CASE(CKM_SHA1_RSA_X9_31); | |
| 485 CASE(CKM_SHA224); | |
| 486 CASE(CKM_SHA224_HMAC); | |
| 487 CASE(CKM_SHA224_HMAC_GENERAL); | |
| 488 CASE(CKM_SHA224_KEY_DERIVATION); | |
| 489 CASE(CKM_SHA224_RSA_PKCS); | |
| 490 CASE(CKM_SHA224_RSA_PKCS_PSS); | |
| 491 CASE(CKM_SHA256); | |
| 492 CASE(CKM_SHA256_HMAC); | |
| 493 CASE(CKM_SHA256_HMAC_GENERAL); | |
| 494 CASE(CKM_SHA256_KEY_DERIVATION); | |
| 495 CASE(CKM_SHA256_RSA_PKCS); | |
| 496 CASE(CKM_SHA256_RSA_PKCS_PSS); | |
| 497 CASE(CKM_SHA384); | |
| 498 CASE(CKM_SHA384_HMAC); | |
| 499 CASE(CKM_SHA384_HMAC_GENERAL); | |
| 500 CASE(CKM_SHA384_KEY_DERIVATION); | |
| 501 CASE(CKM_SHA384_RSA_PKCS); | |
| 502 CASE(CKM_SHA384_RSA_PKCS_PSS); | |
| 503 CASE(CKM_SHA512); | |
| 504 CASE(CKM_SHA512_HMAC); | |
| 505 CASE(CKM_SHA512_HMAC_GENERAL); | |
| 506 CASE(CKM_SHA512_KEY_DERIVATION); | |
| 507 CASE(CKM_SHA512_RSA_PKCS); | |
| 508 CASE(CKM_SHA512_RSA_PKCS_PSS); | |
| 509 CASE(CKM_SHA_1); | |
| 510 CASE(CKM_SHA_1_HMAC); | |
| 511 CASE(CKM_SHA_1_HMAC_GENERAL); | |
| 512 CASE(CKM_SKIPJACK_CBC64); | |
| 513 CASE(CKM_SKIPJACK_CFB16); | |
| 514 CASE(CKM_SKIPJACK_CFB32); | |
| 515 CASE(CKM_SKIPJACK_CFB64); | |
| 516 CASE(CKM_SKIPJACK_CFB8); | |
| 517 CASE(CKM_SKIPJACK_ECB64); | |
| 518 CASE(CKM_SKIPJACK_KEY_GEN); | |
| 519 CASE(CKM_SKIPJACK_OFB64); | |
| 520 CASE(CKM_SKIPJACK_PRIVATE_WRAP); | |
| 521 CASE(CKM_SKIPJACK_RELAYX); | |
| 522 CASE(CKM_SKIPJACK_WRAP); | |
| 523 CASE(CKM_SSL3_KEY_AND_MAC_DERIVE); | |
| 524 CASE(CKM_SSL3_MASTER_KEY_DERIVE); | |
| 525 CASE(CKM_SSL3_MASTER_KEY_DERIVE_DH); | |
| 526 CASE(CKM_SSL3_MD5_MAC); | |
| 527 CASE(CKM_SSL3_PRE_MASTER_KEY_GEN); | |
| 528 CASE(CKM_SSL3_SHA1_MAC); | |
| 529 CASE(CKM_TLS_KEY_AND_MAC_DERIVE); | |
| 530 CASE(CKM_TLS_MASTER_KEY_DERIVE); | |
| 531 CASE(CKM_TLS_MASTER_KEY_DERIVE_DH); | |
| 532 CASE(CKM_TLS_PRE_MASTER_KEY_GEN); | |
| 533 CASE(CKM_TLS_PRF); | |
| 534 CASE(CKM_TWOFISH_CBC); | |
| 535 CASE(CKM_TWOFISH_KEY_GEN); | |
| 536 CASE(CKM_X9_42_DH_DERIVE); | |
| 537 CASE(CKM_X9_42_DH_HYBRID_DERIVE); | |
| 538 CASE(CKM_X9_42_DH_KEY_PAIR_GEN); | |
| 539 CASE(CKM_X9_42_DH_PARAMETER_GEN); | |
| 540 CASE(CKM_X9_42_MQV_DERIVE); | |
| 541 CASE(CKM_XOR_BASE_AND_DATA); | |
| 542 default: break; | |
| 543 } | |
| 544 if (a) | |
| 545 PR_LOG(modlog, 4, (" mechanism = %s", a)); | |
| 546 else | |
| 547 PR_LOG(modlog, 4, (" mechanism = 0x%p", m->mechanism)); | |
| 548 } | |
| 549 | |
| 550 static void get_key_type(CK_KEY_TYPE keyType, char *str, int len) | |
| 551 { | |
| 552 | |
| 553 const char * a = NULL; | |
| 554 | |
| 555 switch (keyType) { | |
| 556 CASE(CKK_AES); | |
| 557 CASE(CKK_CAMELLIA); | |
| 558 CASE(CKK_CDMF); | |
| 559 CASE(CKK_DES); | |
| 560 CASE(CKK_DES2); | |
| 561 CASE(CKK_DES3); | |
| 562 CASE(CKK_DH); | |
| 563 CASE(CKK_DSA); | |
| 564 CASE(CKK_EC); /* also CASE(CKK_ECDSA); */ | |
| 565 CASE(CKK_GENERIC_SECRET); | |
| 566 CASE(CKK_IDEA); | |
| 567 CASE(CKK_INVALID_KEY_TYPE); | |
| 568 CASE(CKK_KEA); | |
| 569 CASE(CKK_RC2); | |
| 570 CASE(CKK_RC4); | |
| 571 CASE(CKK_RC5); | |
| 572 CASE(CKK_RSA); | |
| 573 CASE(CKK_SKIPJACK); | |
| 574 CASE(CKK_TWOFISH); | |
| 575 CASE(CKK_X9_42_DH); | |
| 576 default: break; | |
| 577 } | |
| 578 if (a) | |
| 579 PR_snprintf(str, len, "%s", a); | |
| 580 else | |
| 581 PR_snprintf(str, len, "0x%p", keyType); | |
| 582 } | |
| 583 | |
| 584 static void print_attr_value(CK_ATTRIBUTE_PTR attr) | |
| 585 { | |
| 586 char atype[48]; | |
| 587 char valstr[49]; | |
| 588 int len; | |
| 589 | |
| 590 get_attr_type_str(attr->type, atype, sizeof atype); | |
| 591 switch (attr->type) { | |
| 592 case CKA_ALWAYS_SENSITIVE: | |
| 593 case CKA_DECRYPT: | |
| 594 case CKA_DERIVE: | |
| 595 case CKA_ENCRYPT: | |
| 596 case CKA_EXTRACTABLE: | |
| 597 case CKA_LOCAL: | |
| 598 case CKA_MODIFIABLE: | |
| 599 case CKA_NEVER_EXTRACTABLE: | |
| 600 case CKA_PRIVATE: | |
| 601 case CKA_SENSITIVE: | |
| 602 case CKA_SIGN: | |
| 603 case CKA_SIGN_RECOVER: | |
| 604 case CKA_TOKEN: | |
| 605 case CKA_UNWRAP: | |
| 606 case CKA_VERIFY: | |
| 607 case CKA_VERIFY_RECOVER: | |
| 608 case CKA_WRAP: | |
| 609 if (attr->ulValueLen > 0 && attr->pValue) { | |
| 610 CK_BBOOL tf = *((CK_BBOOL *)attr->pValue); | |
| 611 PR_LOG(modlog, 4, (fmt_s_s_d, | |
| 612 atype, tf ? "CK_TRUE" : "CK_FALSE", attr->ulValueLen)); | |
| 613 break; | |
| 614 } | |
| 615 case CKA_CLASS: | |
| 616 if (attr->ulValueLen > 0 && attr->pValue) { | |
| 617 CK_OBJECT_CLASS objClass = *((CK_OBJECT_CLASS *)attr->pValue); | |
| 618 get_obj_class(objClass, valstr, sizeof valstr); | |
| 619 PR_LOG(modlog, 4, (fmt_s_s_d, | |
| 620 atype, valstr, attr->ulValueLen)); | |
| 621 break; | |
| 622 } | |
| 623 case CKA_TRUST_CLIENT_AUTH: | |
| 624 case CKA_TRUST_CODE_SIGNING: | |
| 625 case CKA_TRUST_EMAIL_PROTECTION: | |
| 626 case CKA_TRUST_SERVER_AUTH: | |
| 627 if (attr->ulValueLen > 0 && attr->pValue) { | |
| 628 CK_TRUST trust = *((CK_TRUST *)attr->pValue); | |
| 629 get_trust_val(trust, valstr, sizeof valstr); | |
| 630 PR_LOG(modlog, 4, (fmt_s_s_d, | |
| 631 atype, valstr, attr->ulValueLen)); | |
| 632 break; | |
| 633 } | |
| 634 case CKA_KEY_TYPE: | |
| 635 if (attr->ulValueLen > 0 && attr->pValue) { | |
| 636 CK_KEY_TYPE keyType = *((CK_KEY_TYPE *)attr->pValue); | |
| 637 get_key_type(keyType, valstr, sizeof valstr); | |
| 638 PR_LOG(modlog, 4, (fmt_s_s_d, | |
| 639 atype, valstr, attr->ulValueLen)); | |
| 640 break; | |
| 641 } | |
| 642 case CKA_PIXEL_X: | |
| 643 case CKA_PIXEL_Y: | |
| 644 case CKA_RESOLUTION: | |
| 645 case CKA_CHAR_ROWS: | |
| 646 case CKA_CHAR_COLUMNS: | |
| 647 case CKA_BITS_PER_PIXEL: | |
| 648 case CKA_CERTIFICATE_CATEGORY: /* should print as enum/string */ | |
| 649 case CKA_JAVA_MIDP_SECURITY_DOMAIN: /* should print as enum/string */ | |
| 650 case CKA_MODULUS_BITS: | |
| 651 case CKA_PRIME_BITS: | |
| 652 case CKA_SUBPRIME_BITS: | |
| 653 case CKA_VALUE_BITS: | |
| 654 case CKA_VALUE_LEN: | |
| 655 if (attr->ulValueLen > 0 && attr->pValue) { | |
| 656 CK_ULONG valueLen = *((CK_ULONG *)attr->pValue); | |
| 657 /* XXX check for the special value CK_UNAVAILABLE_INFORMATION */ | |
| 658 PR_LOG(modlog, 4, (fmt_s_lu, atype, (PRUint32)valueLen)); | |
| 659 break; | |
| 660 } | |
| 661 case CKA_LABEL: | |
| 662 case CKA_NSS_EMAIL: | |
| 663 case CKA_NSS_URL: | |
| 664 if (attr->ulValueLen > 0 && attr->pValue) { | |
| 665 len = PR_MIN(attr->ulValueLen + 1, sizeof valstr); | |
| 666 PR_snprintf(valstr, len, "%s", attr->pValue); | |
| 667 PR_LOG(modlog, 4, (fmt_s_qsq_d, | |
| 668 atype, valstr, attr->ulValueLen)); | |
| 669 break; | |
| 670 } | |
| 671 case CKA_ISSUER: | |
| 672 case CKA_SUBJECT: | |
| 673 if (attr->ulValueLen > 0 && attr->pValue) { | |
| 674 char * asciiName; | |
| 675 SECItem derName; | |
| 676 derName.type = siDERNameBuffer; | |
| 677 derName.data = attr->pValue; | |
| 678 derName.len = attr->ulValueLen; | |
| 679 asciiName = CERT_DerNameToAscii(&derName); | |
| 680 if (asciiName) { | |
| 681 PR_LOG(modlog, 4, (fmt_s_s_d, | |
| 682 atype, asciiName, attr->ulValueLen)); | |
| 683 PORT_Free(asciiName); | |
| 684 break; | |
| 685 } | |
| 686 /* else treat like a binary buffer */ | |
| 687 goto binary_buffer; | |
| 688 } | |
| 689 case CKA_ID: | |
| 690 if (attr->ulValueLen > 0 && attr->pValue) { | |
| 691 unsigned char * pV = attr->pValue; | |
| 692 for (len = (int)attr->ulValueLen; len > 0; --len) { | |
| 693 unsigned int ch = *pV++; | |
| 694 if (ch >= 0x20 && ch < 0x7f) | |
| 695 continue; | |
| 696 if (!ch && len == 1) /* will ignore NUL if last character */ | |
| 697 continue; | |
| 698 break; | |
| 699 } | |
| 700 if (!len) { /* entire string is printable */ | |
| 701 len = PR_MIN(attr->ulValueLen + 1, sizeof valstr); | |
| 702 PR_snprintf(valstr, len, "%s", attr->pValue); | |
| 703 PR_LOG(modlog, 4, (fmt_s_qsq_d, | |
| 704 atype, valstr, attr->ulValueLen)); | |
| 705 break; | |
| 706 } | |
| 707 /* else fall through and treat like a binary buffer */ | |
| 708 } | |
| 709 binary_buffer: | |
| 710 case CKA_SERIAL_NUMBER: | |
| 711 default: | |
| 712 if (attr->ulValueLen > 0 && attr->pValue) { | |
| 713 char * hexBuf; | |
| 714 SECItem attrBuf; | |
| 715 attrBuf.type = siDERNameBuffer; | |
| 716 attrBuf.data = attr->pValue; | |
| 717 attrBuf.len = PR_MIN(attr->ulValueLen, (sizeof valstr)/2); | |
| 718 | |
| 719 hexBuf = CERT_Hexify(&attrBuf, PR_FALSE); | |
| 720 if (hexBuf) { | |
| 721 PR_LOG(modlog, 4, (fmt_s_s_d, | |
| 722 atype, hexBuf, attr->ulValueLen)); | |
| 723 PORT_Free(hexBuf); | |
| 724 break; | |
| 725 } | |
| 726 /* else fall through and show only the address. :( */ | |
| 727 } | |
| 728 PR_LOG(modlog, 4, (" %s = [0x%p] [%d]", | |
| 729 atype, attr->pValue, attr->ulValueLen)); | |
| 730 break; | |
| 731 } | |
| 732 } | |
| 733 | |
| 734 static void print_template(CK_ATTRIBUTE_PTR templ, CK_ULONG tlen) | |
| 735 { | |
| 736 CK_ULONG i; | |
| 737 for (i=0; i<tlen; i++) { | |
| 738 print_attr_value(&templ[i]); | |
| 739 } | |
| 740 } | |
| 741 | |
| 742 struct nssdbg_prof_str { | |
| 743 PRUint32 time; | |
| 744 PRUint32 calls; | |
| 745 char *function; | |
| 746 }; | |
| 747 | |
| 748 #define NSSDBG_DEFINE(func) { 0, 0, #func } | |
| 749 | |
| 750 struct nssdbg_prof_str nssdbg_prof_data[] = { | |
| 751 #define FUNC_C_INITIALIZE 0 | |
| 752 NSSDBG_DEFINE(C_Initialize), | |
| 753 #define FUNC_C_FINALIZE 1 | |
| 754 NSSDBG_DEFINE(C_Finalize), | |
| 755 #define FUNC_C_GETINFO 2 | |
| 756 NSSDBG_DEFINE(C_GetInfo), | |
| 757 #define FUNC_C_GETFUNCITONLIST 3 | |
| 758 NSSDBG_DEFINE(C_GetFunctionList), | |
| 759 #define FUNC_C_GETSLOTLIST 4 | |
| 760 NSSDBG_DEFINE(C_GetSlotList), | |
| 761 #define FUNC_C_GETSLOTINFO 5 | |
| 762 NSSDBG_DEFINE(C_GetSlotInfo), | |
| 763 #define FUNC_C_GETTOKENINFO 6 | |
| 764 NSSDBG_DEFINE(C_GetTokenInfo), | |
| 765 #define FUNC_C_GETMECHANISMLIST 7 | |
| 766 NSSDBG_DEFINE(C_GetMechanismList), | |
| 767 #define FUNC_C_GETMECHANISMINFO 8 | |
| 768 NSSDBG_DEFINE(C_GetMechanismInfo), | |
| 769 #define FUNC_C_INITTOKEN 9 | |
| 770 NSSDBG_DEFINE(C_InitToken), | |
| 771 #define FUNC_C_INITPIN 10 | |
| 772 NSSDBG_DEFINE(C_InitPIN), | |
| 773 #define FUNC_C_SETPIN 11 | |
| 774 NSSDBG_DEFINE(C_SetPIN), | |
| 775 #define FUNC_C_OPENSESSION 12 | |
| 776 NSSDBG_DEFINE(C_OpenSession), | |
| 777 #define FUNC_C_CLOSESESSION 13 | |
| 778 NSSDBG_DEFINE(C_CloseSession), | |
| 779 #define FUNC_C_CLOSEALLSESSIONS 14 | |
| 780 NSSDBG_DEFINE(C_CloseAllSessions), | |
| 781 #define FUNC_C_GETSESSIONINFO 15 | |
| 782 NSSDBG_DEFINE(C_GetSessionInfo), | |
| 783 #define FUNC_C_GETOPERATIONSTATE 16 | |
| 784 NSSDBG_DEFINE(C_GetOperationState), | |
| 785 #define FUNC_C_SETOPERATIONSTATE 17 | |
| 786 NSSDBG_DEFINE(C_SetOperationState), | |
| 787 #define FUNC_C_LOGIN 18 | |
| 788 NSSDBG_DEFINE(C_Login), | |
| 789 #define FUNC_C_LOGOUT 19 | |
| 790 NSSDBG_DEFINE(C_Logout), | |
| 791 #define FUNC_C_CREATEOBJECT 20 | |
| 792 NSSDBG_DEFINE(C_CreateObject), | |
| 793 #define FUNC_C_COPYOBJECT 21 | |
| 794 NSSDBG_DEFINE(C_CopyObject), | |
| 795 #define FUNC_C_DESTROYOBJECT 22 | |
| 796 NSSDBG_DEFINE(C_DestroyObject), | |
| 797 #define FUNC_C_GETOBJECTSIZE 23 | |
| 798 NSSDBG_DEFINE(C_GetObjectSize), | |
| 799 #define FUNC_C_GETATTRIBUTEVALUE 24 | |
| 800 NSSDBG_DEFINE(C_GetAttributeValue), | |
| 801 #define FUNC_C_SETATTRIBUTEVALUE 25 | |
| 802 NSSDBG_DEFINE(C_SetAttributeValue), | |
| 803 #define FUNC_C_FINDOBJECTSINIT 26 | |
| 804 NSSDBG_DEFINE(C_FindObjectsInit), | |
| 805 #define FUNC_C_FINDOBJECTS 27 | |
| 806 NSSDBG_DEFINE(C_FindObjects), | |
| 807 #define FUNC_C_FINDOBJECTSFINAL 28 | |
| 808 NSSDBG_DEFINE(C_FindObjectsFinal), | |
| 809 #define FUNC_C_ENCRYPTINIT 29 | |
| 810 NSSDBG_DEFINE(C_EncryptInit), | |
| 811 #define FUNC_C_ENCRYPT 30 | |
| 812 NSSDBG_DEFINE(C_Encrypt), | |
| 813 #define FUNC_C_ENCRYPTUPDATE 31 | |
| 814 NSSDBG_DEFINE(C_EncryptUpdate), | |
| 815 #define FUNC_C_ENCRYPTFINAL 32 | |
| 816 NSSDBG_DEFINE(C_EncryptFinal), | |
| 817 #define FUNC_C_DECRYPTINIT 33 | |
| 818 NSSDBG_DEFINE(C_DecryptInit), | |
| 819 #define FUNC_C_DECRYPT 34 | |
| 820 NSSDBG_DEFINE(C_Decrypt), | |
| 821 #define FUNC_C_DECRYPTUPDATE 35 | |
| 822 NSSDBG_DEFINE(C_DecryptUpdate), | |
| 823 #define FUNC_C_DECRYPTFINAL 36 | |
| 824 NSSDBG_DEFINE(C_DecryptFinal), | |
| 825 #define FUNC_C_DIGESTINIT 37 | |
| 826 NSSDBG_DEFINE(C_DigestInit), | |
| 827 #define FUNC_C_DIGEST 38 | |
| 828 NSSDBG_DEFINE(C_Digest), | |
| 829 #define FUNC_C_DIGESTUPDATE 39 | |
| 830 NSSDBG_DEFINE(C_DigestUpdate), | |
| 831 #define FUNC_C_DIGESTKEY 40 | |
| 832 NSSDBG_DEFINE(C_DigestKey), | |
| 833 #define FUNC_C_DIGESTFINAL 41 | |
| 834 NSSDBG_DEFINE(C_DigestFinal), | |
| 835 #define FUNC_C_SIGNINIT 42 | |
| 836 NSSDBG_DEFINE(C_SignInit), | |
| 837 #define FUNC_C_SIGN 43 | |
| 838 NSSDBG_DEFINE(C_Sign), | |
| 839 #define FUNC_C_SIGNUPDATE 44 | |
| 840 NSSDBG_DEFINE(C_SignUpdate), | |
| 841 #define FUNC_C_SIGNFINAL 45 | |
| 842 NSSDBG_DEFINE(C_SignFinal), | |
| 843 #define FUNC_C_SIGNRECOVERINIT 46 | |
| 844 NSSDBG_DEFINE(C_SignRecoverInit), | |
| 845 #define FUNC_C_SIGNRECOVER 47 | |
| 846 NSSDBG_DEFINE(C_SignRecover), | |
| 847 #define FUNC_C_VERIFYINIT 48 | |
| 848 NSSDBG_DEFINE(C_VerifyInit), | |
| 849 #define FUNC_C_VERIFY 49 | |
| 850 NSSDBG_DEFINE(C_Verify), | |
| 851 #define FUNC_C_VERIFYUPDATE 50 | |
| 852 NSSDBG_DEFINE(C_VerifyUpdate), | |
| 853 #define FUNC_C_VERIFYFINAL 51 | |
| 854 NSSDBG_DEFINE(C_VerifyFinal), | |
| 855 #define FUNC_C_VERIFYRECOVERINIT 52 | |
| 856 NSSDBG_DEFINE(C_VerifyRecoverInit), | |
| 857 #define FUNC_C_VERIFYRECOVER 53 | |
| 858 NSSDBG_DEFINE(C_VerifyRecover), | |
| 859 #define FUNC_C_DIGESTENCRYPTUPDATE 54 | |
| 860 NSSDBG_DEFINE(C_DigestEncryptUpdate), | |
| 861 #define FUNC_C_DECRYPTDIGESTUPDATE 55 | |
| 862 NSSDBG_DEFINE(C_DecryptDigestUpdate), | |
| 863 #define FUNC_C_SIGNENCRYPTUPDATE 56 | |
| 864 NSSDBG_DEFINE(C_SignEncryptUpdate), | |
| 865 #define FUNC_C_DECRYPTVERIFYUPDATE 57 | |
| 866 NSSDBG_DEFINE(C_DecryptVerifyUpdate), | |
| 867 #define FUNC_C_GENERATEKEY 58 | |
| 868 NSSDBG_DEFINE(C_GenerateKey), | |
| 869 #define FUNC_C_GENERATEKEYPAIR 59 | |
| 870 NSSDBG_DEFINE(C_GenerateKeyPair), | |
| 871 #define FUNC_C_WRAPKEY 60 | |
| 872 NSSDBG_DEFINE(C_WrapKey), | |
| 873 #define FUNC_C_UNWRAPKEY 61 | |
| 874 NSSDBG_DEFINE(C_UnWrapKey), | |
| 875 #define FUNC_C_DERIVEKEY 62 | |
| 876 NSSDBG_DEFINE(C_DeriveKey), | |
| 877 #define FUNC_C_SEEDRANDOM 63 | |
| 878 NSSDBG_DEFINE(C_SeedRandom), | |
| 879 #define FUNC_C_GENERATERANDOM 64 | |
| 880 NSSDBG_DEFINE(C_GenerateRandom), | |
| 881 #define FUNC_C_GETFUNCTIONSTATUS 65 | |
| 882 NSSDBG_DEFINE(C_GetFunctionStatus), | |
| 883 #define FUNC_C_CANCELFUNCTION 66 | |
| 884 NSSDBG_DEFINE(C_CancelFunction), | |
| 885 #define FUNC_C_WAITFORSLOTEVENT 67 | |
| 886 NSSDBG_DEFINE(C_WaitForSlotEvent) | |
| 887 }; | |
| 888 | |
| 889 int nssdbg_prof_size = sizeof(nssdbg_prof_data)/sizeof(nssdbg_prof_data[0]); | |
| 890 | |
| 891 | |
| 892 static void nssdbg_finish_time(PRInt32 fun_number, PRIntervalTime start) | |
| 893 { | |
| 894 PRIntervalTime ival; | |
| 895 PRIntervalTime end = PR_IntervalNow(); | |
| 896 | |
| 897 ival = end-start; | |
| 898 /* sigh, lie to PRAtomic add and say we are using signed values */ | |
| 899 PR_ATOMIC_ADD((PRInt32 *)&nssdbg_prof_data[fun_number].time, (PRInt32)ival); | |
| 900 } | |
| 901 | |
| 902 static void nssdbg_start_time(PRInt32 fun_number, PRIntervalTime *start) | |
| 903 { | |
| 904 PR_ATOMIC_INCREMENT((PRInt32 *)&nssdbg_prof_data[fun_number].calls); | |
| 905 *start = PR_IntervalNow(); | |
| 906 } | |
| 907 | |
| 908 #define COMMON_DEFINITIONS \ | |
| 909 CK_RV rv; \ | |
| 910 PRIntervalTime start | |
| 911 | |
| 912 CK_RV NSSDBGC_Initialize( | |
| 913 CK_VOID_PTR pInitArgs | |
| 914 ) | |
| 915 { | |
| 916 COMMON_DEFINITIONS; | |
| 917 | |
| 918 PR_LOG(modlog, 1, ("C_Initialize")); | |
| 919 PR_LOG(modlog, 3, (" pInitArgs = 0x%p", pInitArgs)); | |
| 920 nssdbg_start_time(FUNC_C_INITIALIZE,&start); | |
| 921 rv = module_functions->C_Initialize(pInitArgs); | |
| 922 nssdbg_finish_time(FUNC_C_INITIALIZE,start); | |
| 923 log_rv(rv); | |
| 924 return rv; | |
| 925 } | |
| 926 | |
| 927 CK_RV NSSDBGC_Finalize( | |
| 928 CK_VOID_PTR pReserved | |
| 929 ) | |
| 930 { | |
| 931 COMMON_DEFINITIONS; | |
| 932 | |
| 933 PR_LOG(modlog, 1, ("C_Finalize")); | |
| 934 PR_LOG(modlog, 3, (" pReserved = 0x%p", pReserved)); | |
| 935 nssdbg_start_time(FUNC_C_FINALIZE,&start); | |
| 936 rv = module_functions->C_Finalize(pReserved); | |
| 937 nssdbg_finish_time(FUNC_C_FINALIZE,start); | |
| 938 log_rv(rv); | |
| 939 return rv; | |
| 940 } | |
| 941 | |
| 942 CK_RV NSSDBGC_GetInfo( | |
| 943 CK_INFO_PTR pInfo | |
| 944 ) | |
| 945 { | |
| 946 COMMON_DEFINITIONS; | |
| 947 | |
| 948 PR_LOG(modlog, 1, ("C_GetInfo")); | |
| 949 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); | |
| 950 nssdbg_start_time(FUNC_C_GETINFO,&start); | |
| 951 rv = module_functions->C_GetInfo(pInfo); | |
| 952 nssdbg_finish_time(FUNC_C_GETINFO,start); | |
| 953 if (rv == CKR_OK) { | |
| 954 PR_LOG(modlog, 4, (" cryptoki version: %d.%d", | |
| 955 pInfo->cryptokiVersion.major, | |
| 956 pInfo->cryptokiVersion.minor)); | |
| 957 PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID)); | |
| 958 PR_LOG(modlog, 4, (" library description = \"%.32s\"", | |
| 959 pInfo->libraryDescription)); | |
| 960 PR_LOG(modlog, 4, (" library version: %d.%d", | |
| 961 pInfo->libraryVersion.major, | |
| 962 pInfo->libraryVersion.minor)); | |
| 963 } | |
| 964 log_rv(rv); | |
| 965 return rv; | |
| 966 } | |
| 967 | |
| 968 CK_RV NSSDBGC_GetFunctionList( | |
| 969 CK_FUNCTION_LIST_PTR_PTR ppFunctionList | |
| 970 ) | |
| 971 { | |
| 972 COMMON_DEFINITIONS; | |
| 973 | |
| 974 PR_LOG(modlog, 1, ("C_GetFunctionList")); | |
| 975 PR_LOG(modlog, 3, (" ppFunctionList = 0x%p", ppFunctionList)); | |
| 976 nssdbg_start_time(FUNC_C_GETFUNCITONLIST,&start); | |
| 977 rv = module_functions->C_GetFunctionList(ppFunctionList); | |
| 978 nssdbg_finish_time(FUNC_C_GETFUNCITONLIST,start); | |
| 979 log_rv(rv); | |
| 980 return rv; | |
| 981 } | |
| 982 | |
| 983 CK_RV NSSDBGC_GetSlotList( | |
| 984 CK_BBOOL tokenPresent, | |
| 985 CK_SLOT_ID_PTR pSlotList, | |
| 986 CK_ULONG_PTR pulCount | |
| 987 ) | |
| 988 { | |
| 989 COMMON_DEFINITIONS; | |
| 990 | |
| 991 CK_ULONG i; | |
| 992 PR_LOG(modlog, 1, ("C_GetSlotList")); | |
| 993 PR_LOG(modlog, 3, (" tokenPresent = 0x%x", tokenPresent)); | |
| 994 PR_LOG(modlog, 3, (" pSlotList = 0x%p", pSlotList)); | |
| 995 PR_LOG(modlog, 3, (fmt_pulCount, pulCount)); | |
| 996 nssdbg_start_time(FUNC_C_GETSLOTLIST,&start); | |
| 997 rv = module_functions->C_GetSlotList(tokenPresent, pSlotList, pulCount); | |
| 998 nssdbg_finish_time(FUNC_C_GETSLOTLIST,start); | |
| 999 PR_LOG(modlog, 4, (fmt_spulCount, *pulCount)); | |
| 1000 if (pSlotList) { | |
| 1001 for (i=0; i<*pulCount; i++) { | |
| 1002 PR_LOG(modlog, 4, (" slotID[%d] = %x", i, pSlotList[i])); | |
| 1003 } | |
| 1004 } | |
| 1005 log_rv(rv); | |
| 1006 return rv; | |
| 1007 } | |
| 1008 | |
| 1009 CK_RV NSSDBGC_GetSlotInfo( | |
| 1010 CK_SLOT_ID slotID, | |
| 1011 CK_SLOT_INFO_PTR pInfo | |
| 1012 ) | |
| 1013 { | |
| 1014 COMMON_DEFINITIONS; | |
| 1015 | |
| 1016 PR_LOG(modlog, 1, ("C_GetSlotInfo")); | |
| 1017 PR_LOG(modlog, 3, (fmt_slotID, slotID)); | |
| 1018 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); | |
| 1019 nssdbg_start_time(FUNC_C_GETSLOTINFO,&start); | |
| 1020 rv = module_functions->C_GetSlotInfo(slotID, pInfo); | |
| 1021 nssdbg_finish_time(FUNC_C_GETSLOTINFO,start); | |
| 1022 if (rv == CKR_OK) { | |
| 1023 PR_LOG(modlog, 4, (" slotDescription = \"%.64s\"", | |
| 1024 pInfo->slotDescription)); | |
| 1025 PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID)); | |
| 1026 PR_LOG(modlog, 4, (" flags = %s %s %s", | |
| 1027 pInfo->flags & CKF_HW_SLOT ? "CKF_HW_SLOT" : "", | |
| 1028 pInfo->flags & CKF_REMOVABLE_DEVICE ? "CKF_REMOVABLE_DEVICE" : "", | |
| 1029 pInfo->flags & CKF_TOKEN_PRESENT ? "CKF_TOKEN_PRESENT" : "")); | |
| 1030 PR_LOG(modlog, 4, (fmt_hwVersion, | |
| 1031 pInfo->hardwareVersion.major, | |
| 1032 pInfo->hardwareVersion.minor)); | |
| 1033 PR_LOG(modlog, 4, (fmt_fwVersion, | |
| 1034 pInfo->firmwareVersion.major, | |
| 1035 pInfo->firmwareVersion.minor)); | |
| 1036 } | |
| 1037 log_rv(rv); | |
| 1038 return rv; | |
| 1039 } | |
| 1040 | |
| 1041 CK_RV NSSDBGC_GetTokenInfo( | |
| 1042 CK_SLOT_ID slotID, | |
| 1043 CK_TOKEN_INFO_PTR pInfo | |
| 1044 ) | |
| 1045 { | |
| 1046 COMMON_DEFINITIONS; | |
| 1047 | |
| 1048 PR_LOG(modlog, 1, ("C_GetTokenInfo")); | |
| 1049 PR_LOG(modlog, 3, (fmt_slotID, slotID)); | |
| 1050 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); | |
| 1051 nssdbg_start_time(FUNC_C_GETTOKENINFO,&start); | |
| 1052 rv = module_functions->C_GetTokenInfo(slotID, pInfo); | |
| 1053 nssdbg_finish_time(FUNC_C_GETTOKENINFO,start); | |
| 1054 if (rv == CKR_OK) { | |
| 1055 PR_LOG(modlog, 4, (" label = \"%.32s\"", pInfo->label)); | |
| 1056 PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID)); | |
| 1057 PR_LOG(modlog, 4, (" model = \"%.16s\"", pInfo->model)); | |
| 1058 PR_LOG(modlog, 4, (" serial = \"%.16s\"", pInfo->serialNumber)); | |
| 1059 PR_LOG(modlog, 4, (" flags = %s %s %s %s", | |
| 1060 pInfo->flags & CKF_RNG ? "CKF_RNG" : "", | |
| 1061 pInfo->flags & CKF_WRITE_PROTECTED ? "CKF_WRITE_PROTECTED" : "", | |
| 1062 pInfo->flags & CKF_LOGIN_REQUIRED ? "CKF_LOGIN_REQUIRED" : "", | |
| 1063 pInfo->flags & CKF_USER_PIN_INITIALIZED ? "CKF_USER_PIN_INIT" : ""))
; | |
| 1064 PR_LOG(modlog, 4, (" maxSessions = %u, Sessions = %u", | |
| 1065 pInfo->ulMaxSessionCount, pInfo->ulSessionCount)); | |
| 1066 PR_LOG(modlog, 4, (" maxRwSessions = %u, RwSessions = %u", | |
| 1067 pInfo->ulMaxRwSessionCount, | |
| 1068 pInfo->ulRwSessionCount)); | |
| 1069 /* ignore Max & Min Pin Len, Public and Private Memory */ | |
| 1070 PR_LOG(modlog, 4, (fmt_hwVersion, | |
| 1071 pInfo->hardwareVersion.major, | |
| 1072 pInfo->hardwareVersion.minor)); | |
| 1073 PR_LOG(modlog, 4, (fmt_fwVersion, | |
| 1074 pInfo->firmwareVersion.major, | |
| 1075 pInfo->firmwareVersion.minor)); | |
| 1076 } | |
| 1077 log_rv(rv); | |
| 1078 return rv; | |
| 1079 } | |
| 1080 | |
| 1081 CK_RV NSSDBGC_GetMechanismList( | |
| 1082 CK_SLOT_ID slotID, | |
| 1083 CK_MECHANISM_TYPE_PTR pMechanismList, | |
| 1084 CK_ULONG_PTR pulCount | |
| 1085 ) | |
| 1086 { | |
| 1087 COMMON_DEFINITIONS; | |
| 1088 | |
| 1089 PR_LOG(modlog, 1, ("C_GetMechanismList")); | |
| 1090 PR_LOG(modlog, 3, (fmt_slotID, slotID)); | |
| 1091 PR_LOG(modlog, 3, (" pMechanismList = 0x%p", pMechanismList)); | |
| 1092 PR_LOG(modlog, 3, (fmt_pulCount, pulCount)); | |
| 1093 nssdbg_start_time(FUNC_C_GETMECHANISMLIST,&start); | |
| 1094 rv = module_functions->C_GetMechanismList(slotID, | |
| 1095 pMechanismList, | |
| 1096 pulCount); | |
| 1097 nssdbg_finish_time(FUNC_C_GETMECHANISMLIST,start); | |
| 1098 PR_LOG(modlog, 4, (fmt_spulCount, *pulCount)); | |
| 1099 log_rv(rv); | |
| 1100 return rv; | |
| 1101 } | |
| 1102 | |
| 1103 CK_RV NSSDBGC_GetMechanismInfo( | |
| 1104 CK_SLOT_ID slotID, | |
| 1105 CK_MECHANISM_TYPE type, | |
| 1106 CK_MECHANISM_INFO_PTR pInfo | |
| 1107 ) | |
| 1108 { | |
| 1109 COMMON_DEFINITIONS; | |
| 1110 | |
| 1111 PR_LOG(modlog, 1, ("C_GetMechanismInfo")); | |
| 1112 PR_LOG(modlog, 3, (fmt_slotID, slotID)); | |
| 1113 PR_LOG(modlog, 3, (" type = 0x%x", type)); | |
| 1114 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); | |
| 1115 nssdbg_start_time(FUNC_C_GETMECHANISMINFO,&start); | |
| 1116 rv = module_functions->C_GetMechanismInfo(slotID, | |
| 1117 type, | |
| 1118 pInfo); | |
| 1119 nssdbg_finish_time(FUNC_C_GETMECHANISMINFO,start); | |
| 1120 log_rv(rv); | |
| 1121 return rv; | |
| 1122 } | |
| 1123 | |
| 1124 CK_RV NSSDBGC_InitToken( | |
| 1125 CK_SLOT_ID slotID, | |
| 1126 CK_CHAR_PTR pPin, | |
| 1127 CK_ULONG ulPinLen, | |
| 1128 CK_CHAR_PTR pLabel | |
| 1129 ) | |
| 1130 { | |
| 1131 COMMON_DEFINITIONS; | |
| 1132 | |
| 1133 PR_LOG(modlog, 1, ("C_InitToken")); | |
| 1134 PR_LOG(modlog, 3, (fmt_slotID, slotID)); | |
| 1135 PR_LOG(modlog, 3, (fmt_pPin, pPin)); | |
| 1136 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen)); | |
| 1137 PR_LOG(modlog, 3, (" pLabel = 0x%p", pLabel)); | |
| 1138 nssdbg_start_time(FUNC_C_INITTOKEN,&start); | |
| 1139 rv = module_functions->C_InitToken(slotID, | |
| 1140 pPin, | |
| 1141 ulPinLen, | |
| 1142 pLabel); | |
| 1143 nssdbg_finish_time(FUNC_C_INITTOKEN,start); | |
| 1144 log_rv(rv); | |
| 1145 return rv; | |
| 1146 } | |
| 1147 | |
| 1148 CK_RV NSSDBGC_InitPIN( | |
| 1149 CK_SESSION_HANDLE hSession, | |
| 1150 CK_CHAR_PTR pPin, | |
| 1151 CK_ULONG ulPinLen | |
| 1152 ) | |
| 1153 { | |
| 1154 COMMON_DEFINITIONS; | |
| 1155 | |
| 1156 PR_LOG(modlog, 1, ("C_InitPIN")); | |
| 1157 log_handle(3, fmt_hSession, hSession); | |
| 1158 PR_LOG(modlog, 3, (fmt_pPin, pPin)); | |
| 1159 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen)); | |
| 1160 nssdbg_start_time(FUNC_C_INITPIN,&start); | |
| 1161 rv = module_functions->C_InitPIN(hSession, | |
| 1162 pPin, | |
| 1163 ulPinLen); | |
| 1164 nssdbg_finish_time(FUNC_C_INITPIN,start); | |
| 1165 log_rv(rv); | |
| 1166 return rv; | |
| 1167 } | |
| 1168 | |
| 1169 CK_RV NSSDBGC_SetPIN( | |
| 1170 CK_SESSION_HANDLE hSession, | |
| 1171 CK_CHAR_PTR pOldPin, | |
| 1172 CK_ULONG ulOldLen, | |
| 1173 CK_CHAR_PTR pNewPin, | |
| 1174 CK_ULONG ulNewLen | |
| 1175 ) | |
| 1176 { | |
| 1177 COMMON_DEFINITIONS; | |
| 1178 | |
| 1179 PR_LOG(modlog, 1, ("C_SetPIN")); | |
| 1180 log_handle(3, fmt_hSession, hSession); | |
| 1181 PR_LOG(modlog, 3, (" pOldPin = 0x%p", pOldPin)); | |
| 1182 PR_LOG(modlog, 3, (" ulOldLen = %d", ulOldLen)); | |
| 1183 PR_LOG(modlog, 3, (" pNewPin = 0x%p", pNewPin)); | |
| 1184 PR_LOG(modlog, 3, (" ulNewLen = %d", ulNewLen)); | |
| 1185 nssdbg_start_time(FUNC_C_SETPIN,&start); | |
| 1186 rv = module_functions->C_SetPIN(hSession, | |
| 1187 pOldPin, | |
| 1188 ulOldLen, | |
| 1189 pNewPin, | |
| 1190 ulNewLen); | |
| 1191 nssdbg_finish_time(FUNC_C_SETPIN,start); | |
| 1192 log_rv(rv); | |
| 1193 return rv; | |
| 1194 } | |
| 1195 | |
| 1196 static PRUint32 numOpenSessions = 0; | |
| 1197 static PRUint32 maxOpenSessions = 0; | |
| 1198 | |
| 1199 CK_RV NSSDBGC_OpenSession( | |
| 1200 CK_SLOT_ID slotID, | |
| 1201 CK_FLAGS flags, | |
| 1202 CK_VOID_PTR pApplication, | |
| 1203 CK_NOTIFY Notify, | |
| 1204 CK_SESSION_HANDLE_PTR phSession | |
| 1205 ) | |
| 1206 { | |
| 1207 COMMON_DEFINITIONS; | |
| 1208 | |
| 1209 PR_ATOMIC_INCREMENT((PRInt32 *)&numOpenSessions); | |
| 1210 maxOpenSessions = PR_MAX(numOpenSessions, maxOpenSessions); | |
| 1211 PR_LOG(modlog, 1, ("C_OpenSession")); | |
| 1212 PR_LOG(modlog, 3, (fmt_slotID, slotID)); | |
| 1213 PR_LOG(modlog, 3, (fmt_flags, flags)); | |
| 1214 PR_LOG(modlog, 3, (" pApplication = 0x%p", pApplication)); | |
| 1215 PR_LOG(modlog, 3, (" Notify = 0x%x", Notify)); | |
| 1216 PR_LOG(modlog, 3, (" phSession = 0x%p", phSession)); | |
| 1217 nssdbg_start_time(FUNC_C_OPENSESSION,&start); | |
| 1218 rv = module_functions->C_OpenSession(slotID, | |
| 1219 flags, | |
| 1220 pApplication, | |
| 1221 Notify, | |
| 1222 phSession); | |
| 1223 nssdbg_finish_time(FUNC_C_OPENSESSION,start); | |
| 1224 log_handle(4, " *phSession = 0x%x", *phSession); | |
| 1225 log_rv(rv); | |
| 1226 return rv; | |
| 1227 } | |
| 1228 | |
| 1229 CK_RV NSSDBGC_CloseSession( | |
| 1230 CK_SESSION_HANDLE hSession | |
| 1231 ) | |
| 1232 { | |
| 1233 COMMON_DEFINITIONS; | |
| 1234 | |
| 1235 PR_ATOMIC_DECREMENT((PRInt32 *)&numOpenSessions); | |
| 1236 PR_LOG(modlog, 1, ("C_CloseSession")); | |
| 1237 log_handle(3, fmt_hSession, hSession); | |
| 1238 nssdbg_start_time(FUNC_C_CLOSESESSION,&start); | |
| 1239 rv = module_functions->C_CloseSession(hSession); | |
| 1240 nssdbg_finish_time(FUNC_C_CLOSESESSION,start); | |
| 1241 log_rv(rv); | |
| 1242 return rv; | |
| 1243 } | |
| 1244 | |
| 1245 CK_RV NSSDBGC_CloseAllSessions( | |
| 1246 CK_SLOT_ID slotID | |
| 1247 ) | |
| 1248 { | |
| 1249 COMMON_DEFINITIONS; | |
| 1250 | |
| 1251 PR_LOG(modlog, 1, ("C_CloseAllSessions")); | |
| 1252 PR_LOG(modlog, 3, (fmt_slotID, slotID)); | |
| 1253 nssdbg_start_time(FUNC_C_CLOSEALLSESSIONS,&start); | |
| 1254 rv = module_functions->C_CloseAllSessions(slotID); | |
| 1255 nssdbg_finish_time(FUNC_C_CLOSEALLSESSIONS,start); | |
| 1256 log_rv(rv); | |
| 1257 return rv; | |
| 1258 } | |
| 1259 | |
| 1260 CK_RV NSSDBGC_GetSessionInfo( | |
| 1261 CK_SESSION_HANDLE hSession, | |
| 1262 CK_SESSION_INFO_PTR pInfo | |
| 1263 ) | |
| 1264 { | |
| 1265 COMMON_DEFINITIONS; | |
| 1266 | |
| 1267 PR_LOG(modlog, 1, ("C_GetSessionInfo")); | |
| 1268 log_handle(3, fmt_hSession, hSession); | |
| 1269 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); | |
| 1270 nssdbg_start_time(FUNC_C_GETSESSIONINFO,&start); | |
| 1271 rv = module_functions->C_GetSessionInfo(hSession, | |
| 1272 pInfo); | |
| 1273 nssdbg_finish_time(FUNC_C_GETSESSIONINFO,start); | |
| 1274 if (rv == CKR_OK) { | |
| 1275 PR_LOG(modlog, 4, (fmt_slotID, pInfo->slotID)); | |
| 1276 log_state(pInfo->state); | |
| 1277 PR_LOG(modlog, 4, (" flags = %s %s", | |
| 1278 pInfo->flags & CKF_RW_SESSION ? "CKF_RW_SESSION" : "", | |
| 1279 pInfo->flags & CKF_SERIAL_SESSION ? "CKF_SERIAL_SESSION" : "")); | |
| 1280 PR_LOG(modlog, 4, (" deviceError = 0x%x", pInfo->ulDeviceError)); | |
| 1281 } | |
| 1282 log_rv(rv); | |
| 1283 return rv; | |
| 1284 } | |
| 1285 | |
| 1286 CK_RV NSSDBGC_GetOperationState( | |
| 1287 CK_SESSION_HANDLE hSession, | |
| 1288 CK_BYTE_PTR pOperationState, | |
| 1289 CK_ULONG_PTR pulOperationStateLen | |
| 1290 ) | |
| 1291 { | |
| 1292 COMMON_DEFINITIONS; | |
| 1293 | |
| 1294 PR_LOG(modlog, 1, ("C_GetOperationState")); | |
| 1295 log_handle(3, fmt_hSession, hSession); | |
| 1296 PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState)); | |
| 1297 PR_LOG(modlog, 3, (" pulOperationStateLen = 0x%p", pulOperationStateLen)); | |
| 1298 nssdbg_start_time(FUNC_C_GETOPERATIONSTATE,&start); | |
| 1299 rv = module_functions->C_GetOperationState(hSession, | |
| 1300 pOperationState, | |
| 1301 pulOperationStateLen); | |
| 1302 nssdbg_finish_time(FUNC_C_GETOPERATIONSTATE,start); | |
| 1303 PR_LOG(modlog, 4, (" *pulOperationStateLen = 0x%x", *pulOperationStateLen))
; | |
| 1304 log_rv(rv); | |
| 1305 return rv; | |
| 1306 } | |
| 1307 | |
| 1308 CK_RV NSSDBGC_SetOperationState( | |
| 1309 CK_SESSION_HANDLE hSession, | |
| 1310 CK_BYTE_PTR pOperationState, | |
| 1311 CK_ULONG ulOperationStateLen, | |
| 1312 CK_OBJECT_HANDLE hEncryptionKey, | |
| 1313 CK_OBJECT_HANDLE hAuthenticationKey | |
| 1314 ) | |
| 1315 { | |
| 1316 COMMON_DEFINITIONS; | |
| 1317 | |
| 1318 PR_LOG(modlog, 1, ("C_SetOperationState")); | |
| 1319 log_handle(3, fmt_hSession, hSession); | |
| 1320 PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState)); | |
| 1321 PR_LOG(modlog, 3, (" ulOperationStateLen = %d", ulOperationStateLen)); | |
| 1322 log_handle(3, " hEncryptionKey = 0x%x", hEncryptionKey); | |
| 1323 log_handle(3, " hAuthenticationKey = 0x%x", hAuthenticationKey); | |
| 1324 nssdbg_start_time(FUNC_C_SETOPERATIONSTATE,&start); | |
| 1325 rv = module_functions->C_SetOperationState(hSession, | |
| 1326 pOperationState, | |
| 1327 ulOperationStateLen, | |
| 1328 hEncryptionKey, | |
| 1329 hAuthenticationKey); | |
| 1330 nssdbg_finish_time(FUNC_C_SETOPERATIONSTATE,start); | |
| 1331 log_rv(rv); | |
| 1332 return rv; | |
| 1333 } | |
| 1334 | |
| 1335 CK_RV NSSDBGC_Login( | |
| 1336 CK_SESSION_HANDLE hSession, | |
| 1337 CK_USER_TYPE userType, | |
| 1338 CK_CHAR_PTR pPin, | |
| 1339 CK_ULONG ulPinLen | |
| 1340 ) | |
| 1341 { | |
| 1342 COMMON_DEFINITIONS; | |
| 1343 | |
| 1344 PR_LOG(modlog, 1, ("C_Login")); | |
| 1345 log_handle(3, fmt_hSession, hSession); | |
| 1346 PR_LOG(modlog, 3, (" userType = 0x%x", userType)); | |
| 1347 PR_LOG(modlog, 3, (fmt_pPin, pPin)); | |
| 1348 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen)); | |
| 1349 nssdbg_start_time(FUNC_C_LOGIN,&start); | |
| 1350 rv = module_functions->C_Login(hSession, | |
| 1351 userType, | |
| 1352 pPin, | |
| 1353 ulPinLen); | |
| 1354 nssdbg_finish_time(FUNC_C_LOGIN,start); | |
| 1355 log_rv(rv); | |
| 1356 return rv; | |
| 1357 } | |
| 1358 | |
| 1359 CK_RV NSSDBGC_Logout( | |
| 1360 CK_SESSION_HANDLE hSession | |
| 1361 ) | |
| 1362 { | |
| 1363 COMMON_DEFINITIONS; | |
| 1364 | |
| 1365 PR_LOG(modlog, 1, ("C_Logout")); | |
| 1366 log_handle(3, fmt_hSession, hSession); | |
| 1367 nssdbg_start_time(FUNC_C_LOGOUT,&start); | |
| 1368 rv = module_functions->C_Logout(hSession); | |
| 1369 nssdbg_finish_time(FUNC_C_LOGOUT,start); | |
| 1370 log_rv(rv); | |
| 1371 return rv; | |
| 1372 } | |
| 1373 | |
| 1374 CK_RV NSSDBGC_CreateObject( | |
| 1375 CK_SESSION_HANDLE hSession, | |
| 1376 CK_ATTRIBUTE_PTR pTemplate, | |
| 1377 CK_ULONG ulCount, | |
| 1378 CK_OBJECT_HANDLE_PTR phObject | |
| 1379 ) | |
| 1380 { | |
| 1381 COMMON_DEFINITIONS; | |
| 1382 | |
| 1383 PR_LOG(modlog, 1, ("C_CreateObject")); | |
| 1384 log_handle(3, fmt_hSession, hSession); | |
| 1385 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); | |
| 1386 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); | |
| 1387 PR_LOG(modlog, 3, (fmt_phObject, phObject)); | |
| 1388 print_template(pTemplate, ulCount); | |
| 1389 nssdbg_start_time(FUNC_C_CREATEOBJECT,&start); | |
| 1390 rv = module_functions->C_CreateObject(hSession, | |
| 1391 pTemplate, | |
| 1392 ulCount, | |
| 1393 phObject); | |
| 1394 nssdbg_finish_time(FUNC_C_CREATEOBJECT,start); | |
| 1395 log_handle(4, " *phObject = 0x%x", *phObject); | |
| 1396 log_rv(rv); | |
| 1397 return rv; | |
| 1398 } | |
| 1399 | |
| 1400 CK_RV NSSDBGC_CopyObject( | |
| 1401 CK_SESSION_HANDLE hSession, | |
| 1402 CK_OBJECT_HANDLE hObject, | |
| 1403 CK_ATTRIBUTE_PTR pTemplate, | |
| 1404 CK_ULONG ulCount, | |
| 1405 CK_OBJECT_HANDLE_PTR phNewObject | |
| 1406 ) | |
| 1407 { | |
| 1408 COMMON_DEFINITIONS; | |
| 1409 | |
| 1410 PR_LOG(modlog, 1, ("C_CopyObject")); | |
| 1411 log_handle(3, fmt_hSession, hSession); | |
| 1412 log_handle(3, fmt_hObject, hObject); | |
| 1413 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); | |
| 1414 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); | |
| 1415 PR_LOG(modlog, 3, (" phNewObject = 0x%p", phNewObject)); | |
| 1416 print_template(pTemplate, ulCount); | |
| 1417 nssdbg_start_time(FUNC_C_COPYOBJECT,&start); | |
| 1418 rv = module_functions->C_CopyObject(hSession, | |
| 1419 hObject, | |
| 1420 pTemplate, | |
| 1421 ulCount, | |
| 1422 phNewObject); | |
| 1423 nssdbg_finish_time(FUNC_C_COPYOBJECT,start); | |
| 1424 log_handle(4, " *phNewObject = 0x%x", *phNewObject); | |
| 1425 log_rv(rv); | |
| 1426 return rv; | |
| 1427 } | |
| 1428 | |
| 1429 CK_RV NSSDBGC_DestroyObject( | |
| 1430 CK_SESSION_HANDLE hSession, | |
| 1431 CK_OBJECT_HANDLE hObject | |
| 1432 ) | |
| 1433 { | |
| 1434 COMMON_DEFINITIONS; | |
| 1435 | |
| 1436 PR_LOG(modlog, 1, ("C_DestroyObject")); | |
| 1437 log_handle(3, fmt_hSession, hSession); | |
| 1438 log_handle(3, fmt_hObject, hObject); | |
| 1439 nssdbg_start_time(FUNC_C_DESTROYOBJECT,&start); | |
| 1440 rv = module_functions->C_DestroyObject(hSession, | |
| 1441 hObject); | |
| 1442 nssdbg_finish_time(FUNC_C_DESTROYOBJECT,start); | |
| 1443 log_rv(rv); | |
| 1444 return rv; | |
| 1445 } | |
| 1446 | |
| 1447 CK_RV NSSDBGC_GetObjectSize( | |
| 1448 CK_SESSION_HANDLE hSession, | |
| 1449 CK_OBJECT_HANDLE hObject, | |
| 1450 CK_ULONG_PTR pulSize | |
| 1451 ) | |
| 1452 { | |
| 1453 COMMON_DEFINITIONS; | |
| 1454 | |
| 1455 PR_LOG(modlog, 1, ("C_GetObjectSize")); | |
| 1456 log_handle(3, fmt_hSession, hSession); | |
| 1457 log_handle(3, fmt_hObject, hObject); | |
| 1458 PR_LOG(modlog, 3, (" pulSize = 0x%p", pulSize)); | |
| 1459 nssdbg_start_time(FUNC_C_GETOBJECTSIZE,&start); | |
| 1460 rv = module_functions->C_GetObjectSize(hSession, | |
| 1461 hObject, | |
| 1462 pulSize); | |
| 1463 nssdbg_finish_time(FUNC_C_GETOBJECTSIZE,start); | |
| 1464 PR_LOG(modlog, 4, (" *pulSize = 0x%x", *pulSize)); | |
| 1465 log_rv(rv); | |
| 1466 return rv; | |
| 1467 } | |
| 1468 | |
| 1469 CK_RV NSSDBGC_GetAttributeValue( | |
| 1470 CK_SESSION_HANDLE hSession, | |
| 1471 CK_OBJECT_HANDLE hObject, | |
| 1472 CK_ATTRIBUTE_PTR pTemplate, | |
| 1473 CK_ULONG ulCount | |
| 1474 ) | |
| 1475 { | |
| 1476 COMMON_DEFINITIONS; | |
| 1477 | |
| 1478 PR_LOG(modlog, 1, ("C_GetAttributeValue")); | |
| 1479 log_handle(3, fmt_hSession, hSession); | |
| 1480 log_handle(3, fmt_hObject, hObject); | |
| 1481 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); | |
| 1482 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); | |
| 1483 nssdbg_start_time(FUNC_C_GETATTRIBUTEVALUE,&start); | |
| 1484 rv = module_functions->C_GetAttributeValue(hSession, | |
| 1485 hObject, | |
| 1486 pTemplate, | |
| 1487 ulCount); | |
| 1488 nssdbg_finish_time(FUNC_C_GETATTRIBUTEVALUE,start); | |
| 1489 print_template(pTemplate, ulCount); | |
| 1490 log_rv(rv); | |
| 1491 return rv; | |
| 1492 } | |
| 1493 | |
| 1494 CK_RV NSSDBGC_SetAttributeValue( | |
| 1495 CK_SESSION_HANDLE hSession, | |
| 1496 CK_OBJECT_HANDLE hObject, | |
| 1497 CK_ATTRIBUTE_PTR pTemplate, | |
| 1498 CK_ULONG ulCount | |
| 1499 ) | |
| 1500 { | |
| 1501 COMMON_DEFINITIONS; | |
| 1502 | |
| 1503 PR_LOG(modlog, 1, ("C_SetAttributeValue")); | |
| 1504 log_handle(3, fmt_hSession, hSession); | |
| 1505 log_handle(3, fmt_hObject, hObject); | |
| 1506 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); | |
| 1507 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); | |
| 1508 print_template(pTemplate, ulCount); | |
| 1509 nssdbg_start_time(FUNC_C_SETATTRIBUTEVALUE,&start); | |
| 1510 rv = module_functions->C_SetAttributeValue(hSession, | |
| 1511 hObject, | |
| 1512 pTemplate, | |
| 1513 ulCount); | |
| 1514 nssdbg_finish_time(FUNC_C_SETATTRIBUTEVALUE,start); | |
| 1515 log_rv(rv); | |
| 1516 return rv; | |
| 1517 } | |
| 1518 | |
| 1519 CK_RV NSSDBGC_FindObjectsInit( | |
| 1520 CK_SESSION_HANDLE hSession, | |
| 1521 CK_ATTRIBUTE_PTR pTemplate, | |
| 1522 CK_ULONG ulCount | |
| 1523 ) | |
| 1524 { | |
| 1525 COMMON_DEFINITIONS; | |
| 1526 | |
| 1527 PR_LOG(modlog, 1, ("C_FindObjectsInit")); | |
| 1528 log_handle(3, fmt_hSession, hSession); | |
| 1529 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); | |
| 1530 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); | |
| 1531 print_template(pTemplate, ulCount); | |
| 1532 nssdbg_start_time(FUNC_C_FINDOBJECTSINIT,&start); | |
| 1533 rv = module_functions->C_FindObjectsInit(hSession, | |
| 1534 pTemplate, | |
| 1535 ulCount); | |
| 1536 nssdbg_finish_time(FUNC_C_FINDOBJECTSINIT,start); | |
| 1537 log_rv(rv); | |
| 1538 return rv; | |
| 1539 } | |
| 1540 | |
| 1541 CK_RV NSSDBGC_FindObjects( | |
| 1542 CK_SESSION_HANDLE hSession, | |
| 1543 CK_OBJECT_HANDLE_PTR phObject, | |
| 1544 CK_ULONG ulMaxObjectCount, | |
| 1545 CK_ULONG_PTR pulObjectCount | |
| 1546 ) | |
| 1547 { | |
| 1548 COMMON_DEFINITIONS; | |
| 1549 CK_ULONG i; | |
| 1550 | |
| 1551 PR_LOG(modlog, 1, ("C_FindObjects")); | |
| 1552 log_handle(3, fmt_hSession, hSession); | |
| 1553 PR_LOG(modlog, 3, (fmt_phObject, phObject)); | |
| 1554 PR_LOG(modlog, 3, (" ulMaxObjectCount = %d", ulMaxObjectCount)); | |
| 1555 PR_LOG(modlog, 3, (" pulObjectCount = 0x%p", pulObjectCount)); | |
| 1556 nssdbg_start_time(FUNC_C_FINDOBJECTS,&start); | |
| 1557 rv = module_functions->C_FindObjects(hSession, | |
| 1558 phObject, | |
| 1559 ulMaxObjectCount, | |
| 1560 pulObjectCount); | |
| 1561 nssdbg_finish_time(FUNC_C_FINDOBJECTS,start); | |
| 1562 PR_LOG(modlog, 4, (" *pulObjectCount = 0x%x", *pulObjectCount)); | |
| 1563 for (i=0; i<*pulObjectCount; i++) { | |
| 1564 PR_LOG(modlog, 4, (" phObject[%d] = 0x%x%s", i, phObject[i], | |
| 1565 phObject[i] ? "" : fmt_invalid_handle)); | |
| 1566 } | |
| 1567 log_rv(rv); | |
| 1568 return rv; | |
| 1569 } | |
| 1570 | |
| 1571 CK_RV NSSDBGC_FindObjectsFinal( | |
| 1572 CK_SESSION_HANDLE hSession | |
| 1573 ) | |
| 1574 { | |
| 1575 COMMON_DEFINITIONS; | |
| 1576 | |
| 1577 PR_LOG(modlog, 1, ("C_FindObjectsFinal")); | |
| 1578 log_handle(3, fmt_hSession, hSession); | |
| 1579 nssdbg_start_time(FUNC_C_FINDOBJECTSFINAL,&start); | |
| 1580 rv = module_functions->C_FindObjectsFinal(hSession); | |
| 1581 nssdbg_finish_time(FUNC_C_FINDOBJECTSFINAL,start); | |
| 1582 log_rv(rv); | |
| 1583 return rv; | |
| 1584 } | |
| 1585 | |
| 1586 CK_RV NSSDBGC_EncryptInit( | |
| 1587 CK_SESSION_HANDLE hSession, | |
| 1588 CK_MECHANISM_PTR pMechanism, | |
| 1589 CK_OBJECT_HANDLE hKey | |
| 1590 ) | |
| 1591 { | |
| 1592 COMMON_DEFINITIONS; | |
| 1593 | |
| 1594 PR_LOG(modlog, 1, ("C_EncryptInit")); | |
| 1595 log_handle(3, fmt_hSession, hSession); | |
| 1596 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 1597 log_handle(3, fmt_hKey, hKey); | |
| 1598 print_mechanism(pMechanism); | |
| 1599 nssdbg_start_time(FUNC_C_ENCRYPTINIT,&start); | |
| 1600 rv = module_functions->C_EncryptInit(hSession, | |
| 1601 pMechanism, | |
| 1602 hKey); | |
| 1603 nssdbg_finish_time(FUNC_C_ENCRYPTINIT,start); | |
| 1604 log_rv(rv); | |
| 1605 return rv; | |
| 1606 } | |
| 1607 | |
| 1608 CK_RV NSSDBGC_Encrypt( | |
| 1609 CK_SESSION_HANDLE hSession, | |
| 1610 CK_BYTE_PTR pData, | |
| 1611 CK_ULONG ulDataLen, | |
| 1612 CK_BYTE_PTR pEncryptedData, | |
| 1613 CK_ULONG_PTR pulEncryptedDataLen | |
| 1614 ) | |
| 1615 { | |
| 1616 COMMON_DEFINITIONS; | |
| 1617 | |
| 1618 PR_LOG(modlog, 1, ("C_Encrypt")); | |
| 1619 log_handle(3, fmt_hSession, hSession); | |
| 1620 PR_LOG(modlog, 3, (fmt_pData, pData)); | |
| 1621 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); | |
| 1622 PR_LOG(modlog, 3, (fmt_pEncryptedData, pEncryptedData)); | |
| 1623 PR_LOG(modlog, 3, (" pulEncryptedDataLen = 0x%p", pulEncryptedDataLen)); | |
| 1624 nssdbg_start_time(FUNC_C_ENCRYPT,&start); | |
| 1625 rv = module_functions->C_Encrypt(hSession, | |
| 1626 pData, | |
| 1627 ulDataLen, | |
| 1628 pEncryptedData, | |
| 1629 pulEncryptedDataLen); | |
| 1630 nssdbg_finish_time(FUNC_C_ENCRYPT,start); | |
| 1631 PR_LOG(modlog, 4, (" *pulEncryptedDataLen = 0x%x", *pulEncryptedDataLen)); | |
| 1632 log_rv(rv); | |
| 1633 return rv; | |
| 1634 } | |
| 1635 | |
| 1636 CK_RV NSSDBGC_EncryptUpdate( | |
| 1637 CK_SESSION_HANDLE hSession, | |
| 1638 CK_BYTE_PTR pPart, | |
| 1639 CK_ULONG ulPartLen, | |
| 1640 CK_BYTE_PTR pEncryptedPart, | |
| 1641 CK_ULONG_PTR pulEncryptedPartLen | |
| 1642 ) | |
| 1643 { | |
| 1644 COMMON_DEFINITIONS; | |
| 1645 | |
| 1646 PR_LOG(modlog, 1, ("C_EncryptUpdate")); | |
| 1647 log_handle(3, fmt_hSession, hSession); | |
| 1648 PR_LOG(modlog, 3, (fmt_pPart, pPart)); | |
| 1649 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); | |
| 1650 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); | |
| 1651 PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen)); | |
| 1652 nssdbg_start_time(FUNC_C_ENCRYPTUPDATE,&start); | |
| 1653 rv = module_functions->C_EncryptUpdate(hSession, | |
| 1654 pPart, | |
| 1655 ulPartLen, | |
| 1656 pEncryptedPart, | |
| 1657 pulEncryptedPartLen); | |
| 1658 nssdbg_finish_time(FUNC_C_ENCRYPTUPDATE,start); | |
| 1659 PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen)); | |
| 1660 log_rv(rv); | |
| 1661 return rv; | |
| 1662 } | |
| 1663 | |
| 1664 CK_RV NSSDBGC_EncryptFinal( | |
| 1665 CK_SESSION_HANDLE hSession, | |
| 1666 CK_BYTE_PTR pLastEncryptedPart, | |
| 1667 CK_ULONG_PTR pulLastEncryptedPartLen | |
| 1668 ) | |
| 1669 { | |
| 1670 COMMON_DEFINITIONS; | |
| 1671 | |
| 1672 PR_LOG(modlog, 1, ("C_EncryptFinal")); | |
| 1673 log_handle(3, fmt_hSession, hSession); | |
| 1674 PR_LOG(modlog, 3, (" pLastEncryptedPart = 0x%p", pLastEncryptedPart)); | |
| 1675 PR_LOG(modlog, 3, (" pulLastEncryptedPartLen = 0x%p", pulLastEncryptedPartL
en)); | |
| 1676 nssdbg_start_time(FUNC_C_ENCRYPTFINAL,&start); | |
| 1677 rv = module_functions->C_EncryptFinal(hSession, | |
| 1678 pLastEncryptedPart, | |
| 1679 pulLastEncryptedPartLen); | |
| 1680 nssdbg_finish_time(FUNC_C_ENCRYPTFINAL,start); | |
| 1681 PR_LOG(modlog, 4, (" *pulLastEncryptedPartLen = 0x%x", *pulLastEncryptedPar
tLen)); | |
| 1682 log_rv(rv); | |
| 1683 return rv; | |
| 1684 } | |
| 1685 | |
| 1686 CK_RV NSSDBGC_DecryptInit( | |
| 1687 CK_SESSION_HANDLE hSession, | |
| 1688 CK_MECHANISM_PTR pMechanism, | |
| 1689 CK_OBJECT_HANDLE hKey | |
| 1690 ) | |
| 1691 { | |
| 1692 COMMON_DEFINITIONS; | |
| 1693 | |
| 1694 PR_LOG(modlog, 1, ("C_DecryptInit")); | |
| 1695 log_handle(3, fmt_hSession, hSession); | |
| 1696 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 1697 log_handle(3, fmt_hKey, hKey); | |
| 1698 print_mechanism(pMechanism); | |
| 1699 nssdbg_start_time(FUNC_C_DECRYPTINIT,&start); | |
| 1700 rv = module_functions->C_DecryptInit(hSession, | |
| 1701 pMechanism, | |
| 1702 hKey); | |
| 1703 nssdbg_finish_time(FUNC_C_DECRYPTINIT,start); | |
| 1704 log_rv(rv); | |
| 1705 return rv; | |
| 1706 } | |
| 1707 | |
| 1708 CK_RV NSSDBGC_Decrypt( | |
| 1709 CK_SESSION_HANDLE hSession, | |
| 1710 CK_BYTE_PTR pEncryptedData, | |
| 1711 CK_ULONG ulEncryptedDataLen, | |
| 1712 CK_BYTE_PTR pData, | |
| 1713 CK_ULONG_PTR pulDataLen | |
| 1714 ) | |
| 1715 { | |
| 1716 COMMON_DEFINITIONS; | |
| 1717 | |
| 1718 PR_LOG(modlog, 1, ("C_Decrypt")); | |
| 1719 log_handle(3, fmt_hSession, hSession); | |
| 1720 PR_LOG(modlog, 3, (fmt_pEncryptedData, pEncryptedData)); | |
| 1721 PR_LOG(modlog, 3, (" ulEncryptedDataLen = %d", ulEncryptedDataLen)); | |
| 1722 PR_LOG(modlog, 3, (fmt_pData, pData)); | |
| 1723 PR_LOG(modlog, 3, (fmt_pulDataLen, pulDataLen)); | |
| 1724 nssdbg_start_time(FUNC_C_DECRYPT,&start); | |
| 1725 rv = module_functions->C_Decrypt(hSession, | |
| 1726 pEncryptedData, | |
| 1727 ulEncryptedDataLen, | |
| 1728 pData, | |
| 1729 pulDataLen); | |
| 1730 nssdbg_finish_time(FUNC_C_DECRYPT,start); | |
| 1731 PR_LOG(modlog, 4, (fmt_spulDataLen, *pulDataLen)); | |
| 1732 log_rv(rv); | |
| 1733 return rv; | |
| 1734 } | |
| 1735 | |
| 1736 CK_RV NSSDBGC_DecryptUpdate( | |
| 1737 CK_SESSION_HANDLE hSession, | |
| 1738 CK_BYTE_PTR pEncryptedPart, | |
| 1739 CK_ULONG ulEncryptedPartLen, | |
| 1740 CK_BYTE_PTR pPart, | |
| 1741 CK_ULONG_PTR pulPartLen | |
| 1742 ) | |
| 1743 { | |
| 1744 COMMON_DEFINITIONS; | |
| 1745 | |
| 1746 PR_LOG(modlog, 1, ("C_DecryptUpdate")); | |
| 1747 log_handle(3, fmt_hSession, hSession); | |
| 1748 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); | |
| 1749 PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen)); | |
| 1750 PR_LOG(modlog, 3, (fmt_pPart, pPart)); | |
| 1751 PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen)); | |
| 1752 nssdbg_start_time(FUNC_C_DECRYPTUPDATE,&start); | |
| 1753 rv = module_functions->C_DecryptUpdate(hSession, | |
| 1754 pEncryptedPart, | |
| 1755 ulEncryptedPartLen, | |
| 1756 pPart, | |
| 1757 pulPartLen); | |
| 1758 nssdbg_finish_time(FUNC_C_DECRYPTUPDATE,start); | |
| 1759 PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen)); | |
| 1760 log_rv(rv); | |
| 1761 return rv; | |
| 1762 } | |
| 1763 | |
| 1764 CK_RV NSSDBGC_DecryptFinal( | |
| 1765 CK_SESSION_HANDLE hSession, | |
| 1766 CK_BYTE_PTR pLastPart, | |
| 1767 CK_ULONG_PTR pulLastPartLen | |
| 1768 ) | |
| 1769 { | |
| 1770 COMMON_DEFINITIONS; | |
| 1771 | |
| 1772 PR_LOG(modlog, 1, ("C_DecryptFinal")); | |
| 1773 log_handle(3, fmt_hSession, hSession); | |
| 1774 PR_LOG(modlog, 3, (" pLastPart = 0x%p", pLastPart)); | |
| 1775 PR_LOG(modlog, 3, (" pulLastPartLen = 0x%p", pulLastPartLen)); | |
| 1776 nssdbg_start_time(FUNC_C_DECRYPTFINAL,&start); | |
| 1777 rv = module_functions->C_DecryptFinal(hSession, | |
| 1778 pLastPart, | |
| 1779 pulLastPartLen); | |
| 1780 nssdbg_finish_time(FUNC_C_DECRYPTFINAL,start); | |
| 1781 PR_LOG(modlog, 4, (" *pulLastPartLen = 0x%x", *pulLastPartLen)); | |
| 1782 log_rv(rv); | |
| 1783 return rv; | |
| 1784 } | |
| 1785 | |
| 1786 CK_RV NSSDBGC_DigestInit( | |
| 1787 CK_SESSION_HANDLE hSession, | |
| 1788 CK_MECHANISM_PTR pMechanism | |
| 1789 ) | |
| 1790 { | |
| 1791 COMMON_DEFINITIONS; | |
| 1792 | |
| 1793 PR_LOG(modlog, 1, ("C_DigestInit")); | |
| 1794 log_handle(3, fmt_hSession, hSession); | |
| 1795 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 1796 print_mechanism(pMechanism); | |
| 1797 nssdbg_start_time(FUNC_C_DIGESTINIT,&start); | |
| 1798 rv = module_functions->C_DigestInit(hSession, | |
| 1799 pMechanism); | |
| 1800 nssdbg_finish_time(FUNC_C_DIGESTINIT,start); | |
| 1801 log_rv(rv); | |
| 1802 return rv; | |
| 1803 } | |
| 1804 | |
| 1805 CK_RV NSSDBGC_Digest( | |
| 1806 CK_SESSION_HANDLE hSession, | |
| 1807 CK_BYTE_PTR pData, | |
| 1808 CK_ULONG ulDataLen, | |
| 1809 CK_BYTE_PTR pDigest, | |
| 1810 CK_ULONG_PTR pulDigestLen | |
| 1811 ) | |
| 1812 { | |
| 1813 COMMON_DEFINITIONS; | |
| 1814 | |
| 1815 PR_LOG(modlog, 1, ("C_Digest")); | |
| 1816 log_handle(3, fmt_hSession, hSession); | |
| 1817 PR_LOG(modlog, 3, (fmt_pData, pData)); | |
| 1818 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); | |
| 1819 PR_LOG(modlog, 3, (fmt_pDigest, pDigest)); | |
| 1820 PR_LOG(modlog, 3, (fmt_pulDigestLen, pulDigestLen)); | |
| 1821 nssdbg_start_time(FUNC_C_DIGEST,&start); | |
| 1822 rv = module_functions->C_Digest(hSession, | |
| 1823 pData, | |
| 1824 ulDataLen, | |
| 1825 pDigest, | |
| 1826 pulDigestLen); | |
| 1827 nssdbg_finish_time(FUNC_C_DIGEST,start); | |
| 1828 PR_LOG(modlog, 4, (fmt_spulDigestLen, *pulDigestLen)); | |
| 1829 log_rv(rv); | |
| 1830 return rv; | |
| 1831 } | |
| 1832 | |
| 1833 CK_RV NSSDBGC_DigestUpdate( | |
| 1834 CK_SESSION_HANDLE hSession, | |
| 1835 CK_BYTE_PTR pPart, | |
| 1836 CK_ULONG ulPartLen | |
| 1837 ) | |
| 1838 { | |
| 1839 COMMON_DEFINITIONS; | |
| 1840 | |
| 1841 PR_LOG(modlog, 1, ("C_DigestUpdate")); | |
| 1842 log_handle(3, fmt_hSession, hSession); | |
| 1843 PR_LOG(modlog, 3, (fmt_pPart, pPart)); | |
| 1844 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); | |
| 1845 nssdbg_start_time(FUNC_C_DIGESTUPDATE,&start); | |
| 1846 rv = module_functions->C_DigestUpdate(hSession, | |
| 1847 pPart, | |
| 1848 ulPartLen); | |
| 1849 nssdbg_finish_time(FUNC_C_DIGESTUPDATE,start); | |
| 1850 log_rv(rv); | |
| 1851 return rv; | |
| 1852 } | |
| 1853 | |
| 1854 CK_RV NSSDBGC_DigestKey( | |
| 1855 CK_SESSION_HANDLE hSession, | |
| 1856 CK_OBJECT_HANDLE hKey | |
| 1857 ) | |
| 1858 { | |
| 1859 COMMON_DEFINITIONS; | |
| 1860 | |
| 1861 PR_LOG(modlog, 1, ("C_DigestKey")); | |
| 1862 log_handle(3, fmt_hSession, hSession); | |
| 1863 nssdbg_start_time(FUNC_C_DIGESTKEY,&start); | |
| 1864 rv = module_functions->C_DigestKey(hSession, | |
| 1865 hKey); | |
| 1866 nssdbg_finish_time(FUNC_C_DIGESTKEY,start); | |
| 1867 log_rv(rv); | |
| 1868 return rv; | |
| 1869 } | |
| 1870 | |
| 1871 CK_RV NSSDBGC_DigestFinal( | |
| 1872 CK_SESSION_HANDLE hSession, | |
| 1873 CK_BYTE_PTR pDigest, | |
| 1874 CK_ULONG_PTR pulDigestLen | |
| 1875 ) | |
| 1876 { | |
| 1877 COMMON_DEFINITIONS; | |
| 1878 | |
| 1879 PR_LOG(modlog, 1, ("C_DigestFinal")); | |
| 1880 log_handle(3, fmt_hSession, hSession); | |
| 1881 PR_LOG(modlog, 3, (fmt_pDigest, pDigest)); | |
| 1882 PR_LOG(modlog, 3, (fmt_pulDigestLen, pulDigestLen)); | |
| 1883 nssdbg_start_time(FUNC_C_DIGESTFINAL,&start); | |
| 1884 rv = module_functions->C_DigestFinal(hSession, | |
| 1885 pDigest, | |
| 1886 pulDigestLen); | |
| 1887 nssdbg_finish_time(FUNC_C_DIGESTFINAL,start); | |
| 1888 PR_LOG(modlog, 4, (fmt_spulDigestLen, *pulDigestLen)); | |
| 1889 log_rv(rv); | |
| 1890 return rv; | |
| 1891 } | |
| 1892 | |
| 1893 CK_RV NSSDBGC_SignInit( | |
| 1894 CK_SESSION_HANDLE hSession, | |
| 1895 CK_MECHANISM_PTR pMechanism, | |
| 1896 CK_OBJECT_HANDLE hKey | |
| 1897 ) | |
| 1898 { | |
| 1899 COMMON_DEFINITIONS; | |
| 1900 | |
| 1901 PR_LOG(modlog, 1, ("C_SignInit")); | |
| 1902 log_handle(3, fmt_hSession, hSession); | |
| 1903 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 1904 log_handle(3, fmt_hKey, hKey); | |
| 1905 print_mechanism(pMechanism); | |
| 1906 nssdbg_start_time(FUNC_C_SIGNINIT,&start); | |
| 1907 rv = module_functions->C_SignInit(hSession, | |
| 1908 pMechanism, | |
| 1909 hKey); | |
| 1910 nssdbg_finish_time(FUNC_C_SIGNINIT,start); | |
| 1911 log_rv(rv); | |
| 1912 return rv; | |
| 1913 } | |
| 1914 | |
| 1915 CK_RV NSSDBGC_Sign( | |
| 1916 CK_SESSION_HANDLE hSession, | |
| 1917 CK_BYTE_PTR pData, | |
| 1918 CK_ULONG ulDataLen, | |
| 1919 CK_BYTE_PTR pSignature, | |
| 1920 CK_ULONG_PTR pulSignatureLen | |
| 1921 ) | |
| 1922 { | |
| 1923 COMMON_DEFINITIONS; | |
| 1924 | |
| 1925 PR_LOG(modlog, 1, ("C_Sign")); | |
| 1926 log_handle(3, fmt_hSession, hSession); | |
| 1927 PR_LOG(modlog, 3, (fmt_pData, pData)); | |
| 1928 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); | |
| 1929 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); | |
| 1930 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen)); | |
| 1931 nssdbg_start_time(FUNC_C_SIGN,&start); | |
| 1932 rv = module_functions->C_Sign(hSession, | |
| 1933 pData, | |
| 1934 ulDataLen, | |
| 1935 pSignature, | |
| 1936 pulSignatureLen); | |
| 1937 nssdbg_finish_time(FUNC_C_SIGN,start); | |
| 1938 PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen)); | |
| 1939 log_rv(rv); | |
| 1940 return rv; | |
| 1941 } | |
| 1942 | |
| 1943 CK_RV NSSDBGC_SignUpdate( | |
| 1944 CK_SESSION_HANDLE hSession, | |
| 1945 CK_BYTE_PTR pPart, | |
| 1946 CK_ULONG ulPartLen | |
| 1947 ) | |
| 1948 { | |
| 1949 COMMON_DEFINITIONS; | |
| 1950 | |
| 1951 PR_LOG(modlog, 1, ("C_SignUpdate")); | |
| 1952 log_handle(3, fmt_hSession, hSession); | |
| 1953 PR_LOG(modlog, 3, (fmt_pPart, pPart)); | |
| 1954 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); | |
| 1955 nssdbg_start_time(FUNC_C_SIGNUPDATE,&start); | |
| 1956 rv = module_functions->C_SignUpdate(hSession, | |
| 1957 pPart, | |
| 1958 ulPartLen); | |
| 1959 nssdbg_finish_time(FUNC_C_SIGNUPDATE,start); | |
| 1960 log_rv(rv); | |
| 1961 return rv; | |
| 1962 } | |
| 1963 | |
| 1964 CK_RV NSSDBGC_SignFinal( | |
| 1965 CK_SESSION_HANDLE hSession, | |
| 1966 CK_BYTE_PTR pSignature, | |
| 1967 CK_ULONG_PTR pulSignatureLen | |
| 1968 ) | |
| 1969 { | |
| 1970 COMMON_DEFINITIONS; | |
| 1971 | |
| 1972 PR_LOG(modlog, 1, ("C_SignFinal")); | |
| 1973 log_handle(3, fmt_hSession, hSession); | |
| 1974 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); | |
| 1975 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen)); | |
| 1976 nssdbg_start_time(FUNC_C_SIGNFINAL,&start); | |
| 1977 rv = module_functions->C_SignFinal(hSession, | |
| 1978 pSignature, | |
| 1979 pulSignatureLen); | |
| 1980 nssdbg_finish_time(FUNC_C_SIGNFINAL,start); | |
| 1981 PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen)); | |
| 1982 log_rv(rv); | |
| 1983 return rv; | |
| 1984 } | |
| 1985 | |
| 1986 CK_RV NSSDBGC_SignRecoverInit( | |
| 1987 CK_SESSION_HANDLE hSession, | |
| 1988 CK_MECHANISM_PTR pMechanism, | |
| 1989 CK_OBJECT_HANDLE hKey | |
| 1990 ) | |
| 1991 { | |
| 1992 COMMON_DEFINITIONS; | |
| 1993 | |
| 1994 PR_LOG(modlog, 1, ("C_SignRecoverInit")); | |
| 1995 log_handle(3, fmt_hSession, hSession); | |
| 1996 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 1997 log_handle(3, fmt_hKey, hKey); | |
| 1998 print_mechanism(pMechanism); | |
| 1999 nssdbg_start_time(FUNC_C_SIGNRECOVERINIT,&start); | |
| 2000 rv = module_functions->C_SignRecoverInit(hSession, | |
| 2001 pMechanism, | |
| 2002 hKey); | |
| 2003 nssdbg_finish_time(FUNC_C_SIGNRECOVERINIT,start); | |
| 2004 log_rv(rv); | |
| 2005 return rv; | |
| 2006 } | |
| 2007 | |
| 2008 CK_RV NSSDBGC_SignRecover( | |
| 2009 CK_SESSION_HANDLE hSession, | |
| 2010 CK_BYTE_PTR pData, | |
| 2011 CK_ULONG ulDataLen, | |
| 2012 CK_BYTE_PTR pSignature, | |
| 2013 CK_ULONG_PTR pulSignatureLen | |
| 2014 ) | |
| 2015 { | |
| 2016 COMMON_DEFINITIONS; | |
| 2017 | |
| 2018 PR_LOG(modlog, 1, ("C_SignRecover")); | |
| 2019 log_handle(3, fmt_hSession, hSession); | |
| 2020 PR_LOG(modlog, 3, (fmt_pData, pData)); | |
| 2021 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); | |
| 2022 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); | |
| 2023 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen)); | |
| 2024 nssdbg_start_time(FUNC_C_SIGNRECOVER,&start); | |
| 2025 rv = module_functions->C_SignRecover(hSession, | |
| 2026 pData, | |
| 2027 ulDataLen, | |
| 2028 pSignature, | |
| 2029 pulSignatureLen); | |
| 2030 nssdbg_finish_time(FUNC_C_SIGNRECOVER,start); | |
| 2031 PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen)); | |
| 2032 log_rv(rv); | |
| 2033 return rv; | |
| 2034 } | |
| 2035 | |
| 2036 CK_RV NSSDBGC_VerifyInit( | |
| 2037 CK_SESSION_HANDLE hSession, | |
| 2038 CK_MECHANISM_PTR pMechanism, | |
| 2039 CK_OBJECT_HANDLE hKey | |
| 2040 ) | |
| 2041 { | |
| 2042 COMMON_DEFINITIONS; | |
| 2043 | |
| 2044 PR_LOG(modlog, 1, ("C_VerifyInit")); | |
| 2045 log_handle(3, fmt_hSession, hSession); | |
| 2046 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 2047 log_handle(3, fmt_hKey, hKey); | |
| 2048 print_mechanism(pMechanism); | |
| 2049 nssdbg_start_time(FUNC_C_VERIFYINIT,&start); | |
| 2050 rv = module_functions->C_VerifyInit(hSession, | |
| 2051 pMechanism, | |
| 2052 hKey); | |
| 2053 nssdbg_finish_time(FUNC_C_VERIFYINIT,start); | |
| 2054 log_rv(rv); | |
| 2055 return rv; | |
| 2056 } | |
| 2057 | |
| 2058 CK_RV NSSDBGC_Verify( | |
| 2059 CK_SESSION_HANDLE hSession, | |
| 2060 CK_BYTE_PTR pData, | |
| 2061 CK_ULONG ulDataLen, | |
| 2062 CK_BYTE_PTR pSignature, | |
| 2063 CK_ULONG ulSignatureLen | |
| 2064 ) | |
| 2065 { | |
| 2066 COMMON_DEFINITIONS; | |
| 2067 | |
| 2068 PR_LOG(modlog, 1, ("C_Verify")); | |
| 2069 log_handle(3, fmt_hSession, hSession); | |
| 2070 PR_LOG(modlog, 3, (fmt_pData, pData)); | |
| 2071 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); | |
| 2072 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); | |
| 2073 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen)); | |
| 2074 nssdbg_start_time(FUNC_C_VERIFY,&start); | |
| 2075 rv = module_functions->C_Verify(hSession, | |
| 2076 pData, | |
| 2077 ulDataLen, | |
| 2078 pSignature, | |
| 2079 ulSignatureLen); | |
| 2080 nssdbg_finish_time(FUNC_C_VERIFY,start); | |
| 2081 log_rv(rv); | |
| 2082 return rv; | |
| 2083 } | |
| 2084 | |
| 2085 CK_RV NSSDBGC_VerifyUpdate( | |
| 2086 CK_SESSION_HANDLE hSession, | |
| 2087 CK_BYTE_PTR pPart, | |
| 2088 CK_ULONG ulPartLen | |
| 2089 ) | |
| 2090 { | |
| 2091 COMMON_DEFINITIONS; | |
| 2092 | |
| 2093 PR_LOG(modlog, 1, ("C_VerifyUpdate")); | |
| 2094 log_handle(3, fmt_hSession, hSession); | |
| 2095 PR_LOG(modlog, 3, (fmt_pPart, pPart)); | |
| 2096 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); | |
| 2097 nssdbg_start_time(FUNC_C_VERIFYUPDATE,&start); | |
| 2098 rv = module_functions->C_VerifyUpdate(hSession, | |
| 2099 pPart, | |
| 2100 ulPartLen); | |
| 2101 nssdbg_finish_time(FUNC_C_VERIFYUPDATE,start); | |
| 2102 log_rv(rv); | |
| 2103 return rv; | |
| 2104 } | |
| 2105 | |
| 2106 CK_RV NSSDBGC_VerifyFinal( | |
| 2107 CK_SESSION_HANDLE hSession, | |
| 2108 CK_BYTE_PTR pSignature, | |
| 2109 CK_ULONG ulSignatureLen | |
| 2110 ) | |
| 2111 { | |
| 2112 COMMON_DEFINITIONS; | |
| 2113 | |
| 2114 PR_LOG(modlog, 1, ("C_VerifyFinal")); | |
| 2115 log_handle(3, fmt_hSession, hSession); | |
| 2116 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); | |
| 2117 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen)); | |
| 2118 nssdbg_start_time(FUNC_C_VERIFYFINAL,&start); | |
| 2119 rv = module_functions->C_VerifyFinal(hSession, | |
| 2120 pSignature, | |
| 2121 ulSignatureLen); | |
| 2122 nssdbg_finish_time(FUNC_C_VERIFYFINAL,start); | |
| 2123 log_rv(rv); | |
| 2124 return rv; | |
| 2125 } | |
| 2126 | |
| 2127 CK_RV NSSDBGC_VerifyRecoverInit( | |
| 2128 CK_SESSION_HANDLE hSession, | |
| 2129 CK_MECHANISM_PTR pMechanism, | |
| 2130 CK_OBJECT_HANDLE hKey | |
| 2131 ) | |
| 2132 { | |
| 2133 COMMON_DEFINITIONS; | |
| 2134 | |
| 2135 PR_LOG(modlog, 1, ("C_VerifyRecoverInit")); | |
| 2136 log_handle(3, fmt_hSession, hSession); | |
| 2137 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 2138 log_handle(3, fmt_hKey, hKey); | |
| 2139 print_mechanism(pMechanism); | |
| 2140 nssdbg_start_time(FUNC_C_VERIFYRECOVERINIT,&start); | |
| 2141 rv = module_functions->C_VerifyRecoverInit(hSession, | |
| 2142 pMechanism, | |
| 2143 hKey); | |
| 2144 nssdbg_finish_time(FUNC_C_VERIFYRECOVERINIT,start); | |
| 2145 log_rv(rv); | |
| 2146 return rv; | |
| 2147 } | |
| 2148 | |
| 2149 CK_RV NSSDBGC_VerifyRecover( | |
| 2150 CK_SESSION_HANDLE hSession, | |
| 2151 CK_BYTE_PTR pSignature, | |
| 2152 CK_ULONG ulSignatureLen, | |
| 2153 CK_BYTE_PTR pData, | |
| 2154 CK_ULONG_PTR pulDataLen | |
| 2155 ) | |
| 2156 { | |
| 2157 COMMON_DEFINITIONS; | |
| 2158 | |
| 2159 PR_LOG(modlog, 1, ("C_VerifyRecover")); | |
| 2160 log_handle(3, fmt_hSession, hSession); | |
| 2161 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); | |
| 2162 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen)); | |
| 2163 PR_LOG(modlog, 3, (fmt_pData, pData)); | |
| 2164 PR_LOG(modlog, 3, (fmt_pulDataLen, pulDataLen)); | |
| 2165 nssdbg_start_time(FUNC_C_VERIFYRECOVER,&start); | |
| 2166 rv = module_functions->C_VerifyRecover(hSession, | |
| 2167 pSignature, | |
| 2168 ulSignatureLen, | |
| 2169 pData, | |
| 2170 pulDataLen); | |
| 2171 nssdbg_finish_time(FUNC_C_VERIFYRECOVER,start); | |
| 2172 PR_LOG(modlog, 4, (fmt_spulDataLen, *pulDataLen)); | |
| 2173 log_rv(rv); | |
| 2174 return rv; | |
| 2175 } | |
| 2176 | |
| 2177 CK_RV NSSDBGC_DigestEncryptUpdate( | |
| 2178 CK_SESSION_HANDLE hSession, | |
| 2179 CK_BYTE_PTR pPart, | |
| 2180 CK_ULONG ulPartLen, | |
| 2181 CK_BYTE_PTR pEncryptedPart, | |
| 2182 CK_ULONG_PTR pulEncryptedPartLen | |
| 2183 ) | |
| 2184 { | |
| 2185 COMMON_DEFINITIONS; | |
| 2186 | |
| 2187 PR_LOG(modlog, 1, ("C_DigestEncryptUpdate")); | |
| 2188 log_handle(3, fmt_hSession, hSession); | |
| 2189 PR_LOG(modlog, 3, (fmt_pPart, pPart)); | |
| 2190 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); | |
| 2191 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); | |
| 2192 PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen)); | |
| 2193 nssdbg_start_time(FUNC_C_DIGESTENCRYPTUPDATE,&start); | |
| 2194 rv = module_functions->C_DigestEncryptUpdate(hSession, | |
| 2195 pPart, | |
| 2196 ulPartLen, | |
| 2197 pEncryptedPart, | |
| 2198 pulEncryptedPartLen); | |
| 2199 nssdbg_finish_time(FUNC_C_DIGESTENCRYPTUPDATE,start); | |
| 2200 PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen)); | |
| 2201 log_rv(rv); | |
| 2202 return rv; | |
| 2203 } | |
| 2204 | |
| 2205 CK_RV NSSDBGC_DecryptDigestUpdate( | |
| 2206 CK_SESSION_HANDLE hSession, | |
| 2207 CK_BYTE_PTR pEncryptedPart, | |
| 2208 CK_ULONG ulEncryptedPartLen, | |
| 2209 CK_BYTE_PTR pPart, | |
| 2210 CK_ULONG_PTR pulPartLen | |
| 2211 ) | |
| 2212 { | |
| 2213 COMMON_DEFINITIONS; | |
| 2214 | |
| 2215 PR_LOG(modlog, 1, ("C_DecryptDigestUpdate")); | |
| 2216 log_handle(3, fmt_hSession, hSession); | |
| 2217 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); | |
| 2218 PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen)); | |
| 2219 PR_LOG(modlog, 3, (fmt_pPart, pPart)); | |
| 2220 PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen)); | |
| 2221 nssdbg_start_time(FUNC_C_DECRYPTDIGESTUPDATE,&start); | |
| 2222 rv = module_functions->C_DecryptDigestUpdate(hSession, | |
| 2223 pEncryptedPart, | |
| 2224 ulEncryptedPartLen, | |
| 2225 pPart, | |
| 2226 pulPartLen); | |
| 2227 nssdbg_finish_time(FUNC_C_DECRYPTDIGESTUPDATE,start); | |
| 2228 PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen)); | |
| 2229 log_rv(rv); | |
| 2230 return rv; | |
| 2231 } | |
| 2232 | |
| 2233 CK_RV NSSDBGC_SignEncryptUpdate( | |
| 2234 CK_SESSION_HANDLE hSession, | |
| 2235 CK_BYTE_PTR pPart, | |
| 2236 CK_ULONG ulPartLen, | |
| 2237 CK_BYTE_PTR pEncryptedPart, | |
| 2238 CK_ULONG_PTR pulEncryptedPartLen | |
| 2239 ) | |
| 2240 { | |
| 2241 COMMON_DEFINITIONS; | |
| 2242 | |
| 2243 PR_LOG(modlog, 1, ("C_SignEncryptUpdate")); | |
| 2244 log_handle(3, fmt_hSession, hSession); | |
| 2245 PR_LOG(modlog, 3, (fmt_pPart, pPart)); | |
| 2246 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); | |
| 2247 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); | |
| 2248 PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen)); | |
| 2249 nssdbg_start_time(FUNC_C_SIGNENCRYPTUPDATE,&start); | |
| 2250 rv = module_functions->C_SignEncryptUpdate(hSession, | |
| 2251 pPart, | |
| 2252 ulPartLen, | |
| 2253 pEncryptedPart, | |
| 2254 pulEncryptedPartLen); | |
| 2255 nssdbg_finish_time(FUNC_C_SIGNENCRYPTUPDATE,start); | |
| 2256 PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen)); | |
| 2257 log_rv(rv); | |
| 2258 return rv; | |
| 2259 } | |
| 2260 | |
| 2261 CK_RV NSSDBGC_DecryptVerifyUpdate( | |
| 2262 CK_SESSION_HANDLE hSession, | |
| 2263 CK_BYTE_PTR pEncryptedPart, | |
| 2264 CK_ULONG ulEncryptedPartLen, | |
| 2265 CK_BYTE_PTR pPart, | |
| 2266 CK_ULONG_PTR pulPartLen | |
| 2267 ) | |
| 2268 { | |
| 2269 COMMON_DEFINITIONS; | |
| 2270 | |
| 2271 PR_LOG(modlog, 1, ("C_DecryptVerifyUpdate")); | |
| 2272 log_handle(3, fmt_hSession, hSession); | |
| 2273 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); | |
| 2274 PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen)); | |
| 2275 PR_LOG(modlog, 3, (fmt_pPart, pPart)); | |
| 2276 PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen)); | |
| 2277 nssdbg_start_time(FUNC_C_DECRYPTVERIFYUPDATE,&start); | |
| 2278 rv = module_functions->C_DecryptVerifyUpdate(hSession, | |
| 2279 pEncryptedPart, | |
| 2280 ulEncryptedPartLen, | |
| 2281 pPart, | |
| 2282 pulPartLen); | |
| 2283 nssdbg_finish_time(FUNC_C_DECRYPTVERIFYUPDATE,start); | |
| 2284 PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen)); | |
| 2285 log_rv(rv); | |
| 2286 return rv; | |
| 2287 } | |
| 2288 | |
| 2289 CK_RV NSSDBGC_GenerateKey( | |
| 2290 CK_SESSION_HANDLE hSession, | |
| 2291 CK_MECHANISM_PTR pMechanism, | |
| 2292 CK_ATTRIBUTE_PTR pTemplate, | |
| 2293 CK_ULONG ulCount, | |
| 2294 CK_OBJECT_HANDLE_PTR phKey | |
| 2295 ) | |
| 2296 { | |
| 2297 COMMON_DEFINITIONS; | |
| 2298 | |
| 2299 PR_LOG(modlog, 1, ("C_GenerateKey")); | |
| 2300 log_handle(3, fmt_hSession, hSession); | |
| 2301 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 2302 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); | |
| 2303 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); | |
| 2304 PR_LOG(modlog, 3, (fmt_phKey, phKey)); | |
| 2305 print_template(pTemplate, ulCount); | |
| 2306 print_mechanism(pMechanism); | |
| 2307 nssdbg_start_time(FUNC_C_GENERATEKEY,&start); | |
| 2308 rv = module_functions->C_GenerateKey(hSession, | |
| 2309 pMechanism, | |
| 2310 pTemplate, | |
| 2311 ulCount, | |
| 2312 phKey); | |
| 2313 nssdbg_finish_time(FUNC_C_GENERATEKEY,start); | |
| 2314 log_handle(4, fmt_sphKey, *phKey); | |
| 2315 log_rv(rv); | |
| 2316 return rv; | |
| 2317 } | |
| 2318 | |
| 2319 CK_RV NSSDBGC_GenerateKeyPair( | |
| 2320 CK_SESSION_HANDLE hSession, | |
| 2321 CK_MECHANISM_PTR pMechanism, | |
| 2322 CK_ATTRIBUTE_PTR pPublicKeyTemplate, | |
| 2323 CK_ULONG ulPublicKeyAttributeCount, | |
| 2324 CK_ATTRIBUTE_PTR pPrivateKeyTemplate, | |
| 2325 CK_ULONG ulPrivateKeyAttributeCount, | |
| 2326 CK_OBJECT_HANDLE_PTR phPublicKey, | |
| 2327 CK_OBJECT_HANDLE_PTR phPrivateKey | |
| 2328 ) | |
| 2329 { | |
| 2330 COMMON_DEFINITIONS; | |
| 2331 | |
| 2332 PR_LOG(modlog, 1, ("C_GenerateKeyPair")); | |
| 2333 log_handle(3, fmt_hSession, hSession); | |
| 2334 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 2335 PR_LOG(modlog, 3, (" pPublicKeyTemplate = 0x%p", pPublicKeyTemplate)); | |
| 2336 PR_LOG(modlog, 3, (" ulPublicKeyAttributeCount = %d", ulPublicKeyAttributeC
ount)); | |
| 2337 PR_LOG(modlog, 3, (" pPrivateKeyTemplate = 0x%p", pPrivateKeyTemplate)); | |
| 2338 PR_LOG(modlog, 3, (" ulPrivateKeyAttributeCount = %d", ulPrivateKeyAttribut
eCount)); | |
| 2339 PR_LOG(modlog, 3, (" phPublicKey = 0x%p", phPublicKey)); | |
| 2340 print_template(pPublicKeyTemplate, ulPublicKeyAttributeCount); | |
| 2341 PR_LOG(modlog, 3, (" phPrivateKey = 0x%p", phPrivateKey)); | |
| 2342 print_template(pPrivateKeyTemplate, ulPrivateKeyAttributeCount); | |
| 2343 print_mechanism(pMechanism); | |
| 2344 nssdbg_start_time(FUNC_C_GENERATEKEYPAIR,&start); | |
| 2345 rv = module_functions->C_GenerateKeyPair(hSession, | |
| 2346 pMechanism, | |
| 2347 pPublicKeyTemplate, | |
| 2348 ulPublicKeyAttributeCount, | |
| 2349 pPrivateKeyTemplate, | |
| 2350 ulPrivateKeyAttributeCount, | |
| 2351 phPublicKey, | |
| 2352 phPrivateKey); | |
| 2353 nssdbg_finish_time(FUNC_C_GENERATEKEYPAIR,start); | |
| 2354 log_handle(4, " *phPublicKey = 0x%x", *phPublicKey); | |
| 2355 log_handle(4, " *phPrivateKey = 0x%x", *phPrivateKey); | |
| 2356 log_rv(rv); | |
| 2357 return rv; | |
| 2358 } | |
| 2359 | |
| 2360 CK_RV NSSDBGC_WrapKey( | |
| 2361 CK_SESSION_HANDLE hSession, | |
| 2362 CK_MECHANISM_PTR pMechanism, | |
| 2363 CK_OBJECT_HANDLE hWrappingKey, | |
| 2364 CK_OBJECT_HANDLE hKey, | |
| 2365 CK_BYTE_PTR pWrappedKey, | |
| 2366 CK_ULONG_PTR pulWrappedKeyLen | |
| 2367 ) | |
| 2368 { | |
| 2369 COMMON_DEFINITIONS; | |
| 2370 | |
| 2371 PR_LOG(modlog, 1, ("C_WrapKey")); | |
| 2372 log_handle(3, fmt_hSession, hSession); | |
| 2373 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 2374 log_handle(3, " hWrappingKey = 0x%x", hWrappingKey); | |
| 2375 log_handle(3, fmt_hKey, hKey); | |
| 2376 PR_LOG(modlog, 3, (fmt_pWrappedKey, pWrappedKey)); | |
| 2377 PR_LOG(modlog, 3, (" pulWrappedKeyLen = 0x%p", pulWrappedKeyLen)); | |
| 2378 print_mechanism(pMechanism); | |
| 2379 nssdbg_start_time(FUNC_C_WRAPKEY,&start); | |
| 2380 rv = module_functions->C_WrapKey(hSession, | |
| 2381 pMechanism, | |
| 2382 hWrappingKey, | |
| 2383 hKey, | |
| 2384 pWrappedKey, | |
| 2385 pulWrappedKeyLen); | |
| 2386 nssdbg_finish_time(FUNC_C_WRAPKEY,start); | |
| 2387 PR_LOG(modlog, 4, (" *pulWrappedKeyLen = 0x%x", *pulWrappedKeyLen)); | |
| 2388 log_rv(rv); | |
| 2389 return rv; | |
| 2390 } | |
| 2391 | |
| 2392 CK_RV NSSDBGC_UnwrapKey( | |
| 2393 CK_SESSION_HANDLE hSession, | |
| 2394 CK_MECHANISM_PTR pMechanism, | |
| 2395 CK_OBJECT_HANDLE hUnwrappingKey, | |
| 2396 CK_BYTE_PTR pWrappedKey, | |
| 2397 CK_ULONG ulWrappedKeyLen, | |
| 2398 CK_ATTRIBUTE_PTR pTemplate, | |
| 2399 CK_ULONG ulAttributeCount, | |
| 2400 CK_OBJECT_HANDLE_PTR phKey | |
| 2401 ) | |
| 2402 { | |
| 2403 COMMON_DEFINITIONS; | |
| 2404 | |
| 2405 PR_LOG(modlog, 1, ("C_UnwrapKey")); | |
| 2406 log_handle(3, fmt_hSession, hSession); | |
| 2407 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 2408 log_handle(3, " hUnwrappingKey = 0x%x", hUnwrappingKey); | |
| 2409 PR_LOG(modlog, 3, (fmt_pWrappedKey, pWrappedKey)); | |
| 2410 PR_LOG(modlog, 3, (" ulWrappedKeyLen = %d", ulWrappedKeyLen)); | |
| 2411 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); | |
| 2412 PR_LOG(modlog, 3, (fmt_ulAttributeCount, ulAttributeCount)); | |
| 2413 PR_LOG(modlog, 3, (fmt_phKey, phKey)); | |
| 2414 print_template(pTemplate, ulAttributeCount); | |
| 2415 print_mechanism(pMechanism); | |
| 2416 nssdbg_start_time(FUNC_C_UNWRAPKEY,&start); | |
| 2417 rv = module_functions->C_UnwrapKey(hSession, | |
| 2418 pMechanism, | |
| 2419 hUnwrappingKey, | |
| 2420 pWrappedKey, | |
| 2421 ulWrappedKeyLen, | |
| 2422 pTemplate, | |
| 2423 ulAttributeCount, | |
| 2424 phKey); | |
| 2425 nssdbg_finish_time(FUNC_C_UNWRAPKEY,start); | |
| 2426 log_handle(4, fmt_sphKey, *phKey); | |
| 2427 log_rv(rv); | |
| 2428 return rv; | |
| 2429 } | |
| 2430 | |
| 2431 CK_RV NSSDBGC_DeriveKey( | |
| 2432 CK_SESSION_HANDLE hSession, | |
| 2433 CK_MECHANISM_PTR pMechanism, | |
| 2434 CK_OBJECT_HANDLE hBaseKey, | |
| 2435 CK_ATTRIBUTE_PTR pTemplate, | |
| 2436 CK_ULONG ulAttributeCount, | |
| 2437 CK_OBJECT_HANDLE_PTR phKey | |
| 2438 ) | |
| 2439 { | |
| 2440 COMMON_DEFINITIONS; | |
| 2441 | |
| 2442 PR_LOG(modlog, 1, ("C_DeriveKey")); | |
| 2443 log_handle(3, fmt_hSession, hSession); | |
| 2444 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); | |
| 2445 log_handle(3, " hBaseKey = 0x%x", hBaseKey); | |
| 2446 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); | |
| 2447 PR_LOG(modlog, 3, (fmt_ulAttributeCount, ulAttributeCount)); | |
| 2448 PR_LOG(modlog, 3, (fmt_phKey, phKey)); | |
| 2449 print_template(pTemplate, ulAttributeCount); | |
| 2450 print_mechanism(pMechanism); | |
| 2451 nssdbg_start_time(FUNC_C_DERIVEKEY,&start); | |
| 2452 rv = module_functions->C_DeriveKey(hSession, | |
| 2453 pMechanism, | |
| 2454 hBaseKey, | |
| 2455 pTemplate, | |
| 2456 ulAttributeCount, | |
| 2457 phKey); | |
| 2458 nssdbg_finish_time(FUNC_C_DERIVEKEY,start); | |
| 2459 log_handle(4, fmt_sphKey, *phKey); | |
| 2460 log_rv(rv); | |
| 2461 return rv; | |
| 2462 } | |
| 2463 | |
| 2464 CK_RV NSSDBGC_SeedRandom( | |
| 2465 CK_SESSION_HANDLE hSession, | |
| 2466 CK_BYTE_PTR pSeed, | |
| 2467 CK_ULONG ulSeedLen | |
| 2468 ) | |
| 2469 { | |
| 2470 COMMON_DEFINITIONS; | |
| 2471 | |
| 2472 PR_LOG(modlog, 1, ("C_SeedRandom")); | |
| 2473 log_handle(3, fmt_hSession, hSession); | |
| 2474 PR_LOG(modlog, 3, (" pSeed = 0x%p", pSeed)); | |
| 2475 PR_LOG(modlog, 3, (" ulSeedLen = %d", ulSeedLen)); | |
| 2476 nssdbg_start_time(FUNC_C_SEEDRANDOM,&start); | |
| 2477 rv = module_functions->C_SeedRandom(hSession, | |
| 2478 pSeed, | |
| 2479 ulSeedLen); | |
| 2480 nssdbg_finish_time(FUNC_C_SEEDRANDOM,start); | |
| 2481 log_rv(rv); | |
| 2482 return rv; | |
| 2483 } | |
| 2484 | |
| 2485 CK_RV NSSDBGC_GenerateRandom( | |
| 2486 CK_SESSION_HANDLE hSession, | |
| 2487 CK_BYTE_PTR RandomData, | |
| 2488 CK_ULONG ulRandomLen | |
| 2489 ) | |
| 2490 { | |
| 2491 COMMON_DEFINITIONS; | |
| 2492 | |
| 2493 PR_LOG(modlog, 1, ("C_GenerateRandom")); | |
| 2494 log_handle(3, fmt_hSession, hSession); | |
| 2495 PR_LOG(modlog, 3, (" RandomData = 0x%p", RandomData)); | |
| 2496 PR_LOG(modlog, 3, (" ulRandomLen = %d", ulRandomLen)); | |
| 2497 nssdbg_start_time(FUNC_C_GENERATERANDOM,&start); | |
| 2498 rv = module_functions->C_GenerateRandom(hSession, | |
| 2499 RandomData, | |
| 2500 ulRandomLen); | |
| 2501 nssdbg_finish_time(FUNC_C_GENERATERANDOM,start); | |
| 2502 log_rv(rv); | |
| 2503 return rv; | |
| 2504 } | |
| 2505 | |
| 2506 CK_RV NSSDBGC_GetFunctionStatus( | |
| 2507 CK_SESSION_HANDLE hSession | |
| 2508 ) | |
| 2509 { | |
| 2510 COMMON_DEFINITIONS; | |
| 2511 | |
| 2512 PR_LOG(modlog, 1, ("C_GetFunctionStatus")); | |
| 2513 log_handle(3, fmt_hSession, hSession); | |
| 2514 nssdbg_start_time(FUNC_C_GETFUNCTIONSTATUS,&start); | |
| 2515 rv = module_functions->C_GetFunctionStatus(hSession); | |
| 2516 nssdbg_finish_time(FUNC_C_GETFUNCTIONSTATUS,start); | |
| 2517 log_rv(rv); | |
| 2518 return rv; | |
| 2519 } | |
| 2520 | |
| 2521 CK_RV NSSDBGC_CancelFunction( | |
| 2522 CK_SESSION_HANDLE hSession | |
| 2523 ) | |
| 2524 { | |
| 2525 COMMON_DEFINITIONS; | |
| 2526 | |
| 2527 PR_LOG(modlog, 1, ("C_CancelFunction")); | |
| 2528 log_handle(3, fmt_hSession, hSession); | |
| 2529 nssdbg_start_time(FUNC_C_CANCELFUNCTION,&start); | |
| 2530 rv = module_functions->C_CancelFunction(hSession); | |
| 2531 nssdbg_finish_time(FUNC_C_CANCELFUNCTION,start); | |
| 2532 log_rv(rv); | |
| 2533 return rv; | |
| 2534 } | |
| 2535 | |
| 2536 CK_RV NSSDBGC_WaitForSlotEvent( | |
| 2537 CK_FLAGS flags, | |
| 2538 CK_SLOT_ID_PTR pSlot, | |
| 2539 CK_VOID_PTR pRserved | |
| 2540 ) | |
| 2541 { | |
| 2542 COMMON_DEFINITIONS; | |
| 2543 | |
| 2544 PR_LOG(modlog, 1, ("C_WaitForSlotEvent")); | |
| 2545 PR_LOG(modlog, 3, (fmt_flags, flags)); | |
| 2546 PR_LOG(modlog, 3, (" pSlot = 0x%p", pSlot)); | |
| 2547 PR_LOG(modlog, 3, (" pRserved = 0x%p", pRserved)); | |
| 2548 nssdbg_start_time(FUNC_C_WAITFORSLOTEVENT,&start); | |
| 2549 rv = module_functions->C_WaitForSlotEvent(flags, | |
| 2550 pSlot, | |
| 2551 pRserved); | |
| 2552 nssdbg_finish_time(FUNC_C_WAITFORSLOTEVENT,start); | |
| 2553 log_rv(rv); | |
| 2554 return rv; | |
| 2555 } | |
| 2556 | |
| 2557 CK_FUNCTION_LIST_PTR nss_InsertDeviceLog( | |
| 2558 CK_FUNCTION_LIST_PTR devEPV | |
| 2559 ) | |
| 2560 { | |
| 2561 module_functions = devEPV; | |
| 2562 modlog = PR_NewLogModule("nss_mod_log"); | |
| 2563 debug_functions.C_Initialize = NSSDBGC_Initialize; | |
| 2564 debug_functions.C_Finalize = NSSDBGC_Finalize; | |
| 2565 debug_functions.C_GetInfo = NSSDBGC_GetInfo; | |
| 2566 debug_functions.C_GetFunctionList = NSSDBGC_GetFunctionList; | |
| 2567 debug_functions.C_GetSlotList = NSSDBGC_GetSlotList; | |
| 2568 debug_functions.C_GetSlotInfo = NSSDBGC_GetSlotInfo; | |
| 2569 debug_functions.C_GetTokenInfo = NSSDBGC_GetTokenInfo; | |
| 2570 debug_functions.C_GetMechanismList = NSSDBGC_GetMechanismList; | |
| 2571 debug_functions.C_GetMechanismInfo = NSSDBGC_GetMechanismInfo; | |
| 2572 debug_functions.C_InitToken = NSSDBGC_InitToken; | |
| 2573 debug_functions.C_InitPIN = NSSDBGC_InitPIN; | |
| 2574 debug_functions.C_SetPIN = NSSDBGC_SetPIN; | |
| 2575 debug_functions.C_OpenSession = NSSDBGC_OpenSession; | |
| 2576 debug_functions.C_CloseSession = NSSDBGC_CloseSession; | |
| 2577 debug_functions.C_CloseAllSessions = NSSDBGC_CloseAllSessions; | |
| 2578 debug_functions.C_GetSessionInfo = NSSDBGC_GetSessionInfo; | |
| 2579 debug_functions.C_GetOperationState = NSSDBGC_GetOperationState; | |
| 2580 debug_functions.C_SetOperationState = NSSDBGC_SetOperationState; | |
| 2581 debug_functions.C_Login = NSSDBGC_Login; | |
| 2582 debug_functions.C_Logout = NSSDBGC_Logout; | |
| 2583 debug_functions.C_CreateObject = NSSDBGC_CreateObject; | |
| 2584 debug_functions.C_CopyObject = NSSDBGC_CopyObject; | |
| 2585 debug_functions.C_DestroyObject = NSSDBGC_DestroyObject; | |
| 2586 debug_functions.C_GetObjectSize = NSSDBGC_GetObjectSize; | |
| 2587 debug_functions.C_GetAttributeValue = NSSDBGC_GetAttributeValue; | |
| 2588 debug_functions.C_SetAttributeValue = NSSDBGC_SetAttributeValue; | |
| 2589 debug_functions.C_FindObjectsInit = NSSDBGC_FindObjectsInit; | |
| 2590 debug_functions.C_FindObjects = NSSDBGC_FindObjects; | |
| 2591 debug_functions.C_FindObjectsFinal = NSSDBGC_FindObjectsFinal; | |
| 2592 debug_functions.C_EncryptInit = NSSDBGC_EncryptInit; | |
| 2593 debug_functions.C_Encrypt = NSSDBGC_Encrypt; | |
| 2594 debug_functions.C_EncryptUpdate = NSSDBGC_EncryptUpdate; | |
| 2595 debug_functions.C_EncryptFinal = NSSDBGC_EncryptFinal; | |
| 2596 debug_functions.C_DecryptInit = NSSDBGC_DecryptInit; | |
| 2597 debug_functions.C_Decrypt = NSSDBGC_Decrypt; | |
| 2598 debug_functions.C_DecryptUpdate = NSSDBGC_DecryptUpdate; | |
| 2599 debug_functions.C_DecryptFinal = NSSDBGC_DecryptFinal; | |
| 2600 debug_functions.C_DigestInit = NSSDBGC_DigestInit; | |
| 2601 debug_functions.C_Digest = NSSDBGC_Digest; | |
| 2602 debug_functions.C_DigestUpdate = NSSDBGC_DigestUpdate; | |
| 2603 debug_functions.C_DigestKey = NSSDBGC_DigestKey; | |
| 2604 debug_functions.C_DigestFinal = NSSDBGC_DigestFinal; | |
| 2605 debug_functions.C_SignInit = NSSDBGC_SignInit; | |
| 2606 debug_functions.C_Sign = NSSDBGC_Sign; | |
| 2607 debug_functions.C_SignUpdate = NSSDBGC_SignUpdate; | |
| 2608 debug_functions.C_SignFinal = NSSDBGC_SignFinal; | |
| 2609 debug_functions.C_SignRecoverInit = NSSDBGC_SignRecoverInit; | |
| 2610 debug_functions.C_SignRecover = NSSDBGC_SignRecover; | |
| 2611 debug_functions.C_VerifyInit = NSSDBGC_VerifyInit; | |
| 2612 debug_functions.C_Verify = NSSDBGC_Verify; | |
| 2613 debug_functions.C_VerifyUpdate = NSSDBGC_VerifyUpdate; | |
| 2614 debug_functions.C_VerifyFinal = NSSDBGC_VerifyFinal; | |
| 2615 debug_functions.C_VerifyRecoverInit = NSSDBGC_VerifyRecoverInit; | |
| 2616 debug_functions.C_VerifyRecover = NSSDBGC_VerifyRecover; | |
| 2617 debug_functions.C_DigestEncryptUpdate = NSSDBGC_DigestEncryptUpdate; | |
| 2618 debug_functions.C_DecryptDigestUpdate = NSSDBGC_DecryptDigestUpdate; | |
| 2619 debug_functions.C_SignEncryptUpdate = NSSDBGC_SignEncryptUpdate; | |
| 2620 debug_functions.C_DecryptVerifyUpdate = NSSDBGC_DecryptVerifyUpdate; | |
| 2621 debug_functions.C_GenerateKey = NSSDBGC_GenerateKey; | |
| 2622 debug_functions.C_GenerateKeyPair = NSSDBGC_GenerateKeyPair; | |
| 2623 debug_functions.C_WrapKey = NSSDBGC_WrapKey; | |
| 2624 debug_functions.C_UnwrapKey = NSSDBGC_UnwrapKey; | |
| 2625 debug_functions.C_DeriveKey = NSSDBGC_DeriveKey; | |
| 2626 debug_functions.C_SeedRandom = NSSDBGC_SeedRandom; | |
| 2627 debug_functions.C_GenerateRandom = NSSDBGC_GenerateRandom; | |
| 2628 debug_functions.C_GetFunctionStatus = NSSDBGC_GetFunctionStatus; | |
| 2629 debug_functions.C_CancelFunction = NSSDBGC_CancelFunction; | |
| 2630 debug_functions.C_WaitForSlotEvent = NSSDBGC_WaitForSlotEvent; | |
| 2631 return &debug_functions; | |
| 2632 } | |
| 2633 | |
| 2634 /* | |
| 2635 * scale the time factor up accordingly. | |
| 2636 * This routine tries to keep at least 2 significant figures on output. | |
| 2637 * If the time is 0, then indicate that with a 'z' for units. | |
| 2638 * If the time is greater than 10 minutes, output the time in minutes. | |
| 2639 * If the time is less than 10 minutes but greater than 10 seconds output | |
| 2640 * the time in second. | |
| 2641 * If the time is less than 10 seconds but greater than 10 milliseconds | |
| 2642 * output * the time in millisecond. | |
| 2643 * If the time is less than 10 milliseconds but greater than 0 ticks output | |
| 2644 * the time in microsecond. | |
| 2645 * | |
| 2646 */ | |
| 2647 static PRUint32 getPrintTime(PRIntervalTime time ,char **type) | |
| 2648 { | |
| 2649 PRUint32 prTime; | |
| 2650 | |
| 2651 /* detect a programming error by outputting 'bu' to the output stream | |
| 2652 * rather than crashing */ | |
| 2653 *type = "bug"; | |
| 2654 if (time == 0) { | |
| 2655 *type = "z"; | |
| 2656 return 0; | |
| 2657 } | |
| 2658 | |
| 2659 prTime = PR_IntervalToSeconds(time); | |
| 2660 | |
| 2661 if (prTime >= 600) { | |
| 2662 *type="m"; | |
| 2663 return prTime/60; | |
| 2664 } | |
| 2665 if (prTime >= 10) { | |
| 2666 *type="s"; | |
| 2667 return prTime; | |
| 2668 } | |
| 2669 prTime = PR_IntervalToMilliseconds(time); | |
| 2670 if (prTime >= 10) { | |
| 2671 *type="ms"; | |
| 2672 return prTime; | |
| 2673 } | |
| 2674 *type = "us"; | |
| 2675 return PR_IntervalToMicroseconds(time); | |
| 2676 } | |
| 2677 | |
| 2678 static void print_final_statistics(void) | |
| 2679 { | |
| 2680 int total_calls = 0; | |
| 2681 PRIntervalTime total_time = 0; | |
| 2682 PRUint32 pr_total_time; | |
| 2683 char *type; | |
| 2684 char *fname; | |
| 2685 FILE *outfile = NULL; | |
| 2686 int i; | |
| 2687 | |
| 2688 fname = PR_GetEnvSecure("NSS_OUTPUT_FILE"); | |
| 2689 if (fname) { | |
| 2690 /* need to add an optional process id to the filename */ | |
| 2691 outfile = fopen(fname,"w+"); | |
| 2692 } | |
| 2693 if (!outfile) { | |
| 2694 outfile = stdout; | |
| 2695 } | |
| 2696 | |
| 2697 | |
| 2698 fprintf(outfile,"%-25s %10s %12s %12s %10s\n", "Function", "# Calls", | |
| 2699 "Time", "Avg.", "% Time"); | |
| 2700 fprintf(outfile,"\n"); | |
| 2701 for (i=0; i < nssdbg_prof_size; i++) { | |
| 2702 total_calls += nssdbg_prof_data[i].calls; | |
| 2703 total_time += nssdbg_prof_data[i].time; | |
| 2704 } | |
| 2705 for (i=0; i < nssdbg_prof_size; i++) { | |
| 2706 PRIntervalTime time = nssdbg_prof_data[i].time; | |
| 2707 PRUint32 usTime = PR_IntervalToMicroseconds(time); | |
| 2708 PRUint32 prTime = 0; | |
| 2709 PRUint32 calls = nssdbg_prof_data[i].calls; | |
| 2710 /* don't print out functions that weren't even called */ | |
| 2711 if (calls == 0) { | |
| 2712 continue; | |
| 2713 } | |
| 2714 | |
| 2715 prTime = getPrintTime(time,&type); | |
| 2716 | |
| 2717 fprintf(outfile,"%-25s %10d %10d%2s ", nssdbg_prof_data[i].function, | |
| 2718 calls, prTime, type); | |
| 2719 /* for now always output the average in microseconds */ | |
| 2720 fprintf(outfile,"%10.2f%2s", (float)usTime / (float)calls, "us" ); | |
| 2721 fprintf(outfile,"%10.2f%%", ((float)time / (float)total_time) * 100); | |
| 2722 fprintf(outfile,"\n"); | |
| 2723 } | |
| 2724 fprintf(outfile,"\n"); | |
| 2725 | |
| 2726 pr_total_time = getPrintTime(total_time,&type); | |
| 2727 | |
| 2728 fprintf(outfile,"%25s %10d %10d%2s\n", "Totals", total_calls, | |
| 2729 pr_total_time, type); | |
| 2730 fprintf(outfile,"\n\nMaximum number of concurrent open sessions: %d\n\n", | |
| 2731 maxOpenSessions); | |
| 2732 fflush (outfile); | |
| 2733 if (outfile != stdout) { | |
| 2734 fclose(outfile); | |
| 2735 } | |
| 2736 } | |
| 2737 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2078763002:
Delete bundled copy of NSS and replace with README. (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/nss@master