Coverage Report

Created: 2024-11-21 07:03

/src/nss-nspr/nss/lib/pk11wrap/debug_module.c
Line
Count
Source (jump to first uncovered line)
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_3_0_PTR module_functions;
11
12
static CK_FUNCTION_LIST_3_0 debug_functions;
13
14
static void print_final_statistics(void);
15
16
#define STRING static const char
17
STRING fmt_flags[] = "  flags = 0x%x";
18
STRING fmt_hKey[] = "  hKey = 0x%x";
19
STRING fmt_hObject[] = "  hObject = 0x%x";
20
STRING fmt_hSession[] = "  hSession = 0x%x";
21
STRING fmt_manufacturerID[] = "  manufacturerID = \"%.32s\"";
22
STRING fmt_pAssociatedData[] = "  pAssociatedData = 0x%p";
23
STRING fmt_pCiphertext[] = "  pCiphertext = 0x%p";
24
STRING fmt_pCiphertextPart[] = "  pCiphertextPart = 0x%p";
25
STRING fmt_pData[] = "  pData = 0x%p";
26
STRING fmt_pDigest[] = "  pDigest = 0x%p";
27
STRING fmt_pEncryptedData[] = "  pEncryptedData = 0x%p";
28
STRING fmt_pEncryptedPart[] = "  pEncryptedPart = 0x%p";
29
STRING fmt_pInfo[] = "  pInfo = 0x%p";
30
STRING fmt_pMechanism[] = "  pMechanism = 0x%p";
31
STRING fmt_pOperationState[] = "  pOperationState = 0x%p";
32
STRING fmt_pParameter[] = "  pParameter = 0x%p";
33
STRING fmt_pPart[] = "  pPart = 0x%p";
34
STRING fmt_pPlaintext[] = "  pPlaintext = 0x%p";
35
STRING fmt_pPlaintextPart[] = "  pPlaintextPart = 0x%p";
36
STRING fmt_pPin[] = "  pPin = 0x%p";
37
STRING fmt_pSignature[] = "  pSignature = 0x%p";
38
STRING fmt_pTemplate[] = "  pTemplate = 0x%p";
39
STRING fmt_pWrappedKey[] = "  pWrappedKey = 0x%p";
40
STRING fmt_phKey[] = "  phKey = 0x%p";
41
STRING fmt_phObject[] = "  phObject = 0x%p";
42
STRING fmt_pulCount[] = "  pulCount = 0x%p";
43
STRING fmt_pulCiphertextLen[] = "  pulCiphertextLen = 0x%p";
44
STRING fmt_pulCiphertextPartLen[] = "  pulCiphertextPartLen = 0x%p";
45
STRING fmt_pulDataLen[] = "  pulDataLen = 0x%p";
46
STRING fmt_pulDigestLen[] = "  pulDigestLen = 0x%p";
47
STRING fmt_pulEncryptedPartLen[] = "  pulEncryptedPartLen = 0x%p";
48
STRING fmt_pulPartLen[] = "  pulPartLen = 0x%p";
49
STRING fmt_pulPlaintextLen[] = "  pulPlaintextLen = 0x%p";
50
STRING fmt_pulPlaintextPartLen[] = "  pulPlaintextPartLen = 0x%p";
51
STRING fmt_pulSignatureLen[] = "  pulSignatureLen = 0x%p";
52
STRING fmt_slotID[] = "  slotID = 0x%x";
53
STRING fmt_sphKey[] = "  *phKey = 0x%x";
54
STRING fmt_spulCount[] = "  *pulCount = 0x%x";
55
STRING fmt_spulDataLen[] = "  *pulDataLen = 0x%x";
56
STRING fmt_spulDigestLen[] = "  *pulDigestLen = 0x%x";
57
STRING fmt_spulEncryptedPartLen[] = "  *pulEncryptedPartLen = 0x%x";
58
STRING fmt_spulPartLen[] = "  *pulPartLen = 0x%x";
59
STRING fmt_spulSignatureLen[] = "  *pulSignatureLen = 0x%x";
60
STRING fmt_ulAttributeCount[] = "  ulAttributeCount = %d";
61
STRING fmt_ulCiphertextLen[] = "  ulCiphertextLen = %d";
62
STRING fmt_ulCiphertextPartLen[] = "  ulCiphertextPartLen = %d";
63
STRING fmt_ulCount[] = "  ulCount = %d";
64
STRING fmt_ulDataLen[] = "  ulDataLen = %d";
65
STRING fmt_ulEncryptedPartLen[] = "  ulEncryptedPartLen = %d";
66
STRING fmt_ulAssociatedDataLen[] = "  ulAssociatedDataLen = 0x%p";
67
STRING fmt_ulParameterLen[] = "  ulParameterLen = 0x%p";
68
STRING fmt_ulPartLen[] = "  ulPartLen = %d";
69
STRING fmt_ulPlaintextLen[] = "  ulPlaintextLen = 0x%p";
70
STRING fmt_ulPlaintextPartLen[] = "  ulPlaintextPartLen = 0x%p";
71
STRING fmt_ulPinLen[] = "  ulPinLen = %d";
72
STRING fmt_ulSignatureLen[] = "  ulSignatureLen = %d";
73
74
STRING fmt_fwVersion[] = "  firmware version: %d.%d";
75
STRING fmt_hwVersion[] = "  hardware version: %d.%d";
76
STRING fmt_s_qsq_d[] = "    %s = \"%s\" [%d]";
77
STRING fmt_s_s_d[] = "    %s = %s [%d]";
78
STRING fmt_s_lu[] = "    %s = %lu";
79
STRING fmt_invalid_handle[] = " (CK_INVALID_HANDLE)";
80
81
static void
82
get_attr_type_str(CK_ATTRIBUTE_TYPE atype, char *str, int len)
83
0
{
84
0
#define CASE(attr) \
85
0
    case attr:     \
86
0
        a = #attr; \
87
0
        break
88
89
0
    const char *a = NULL;
90
91
0
    switch (atype) {
92
0
        CASE(CKA_CLASS);
93
0
        CASE(CKA_TOKEN);
94
0
        CASE(CKA_PRIVATE);
95
0
        CASE(CKA_LABEL);
96
0
        CASE(CKA_APPLICATION);
97
0
        CASE(CKA_VALUE);
98
0
        CASE(CKA_OBJECT_ID);
99
0
        CASE(CKA_CERTIFICATE_TYPE);
100
0
        CASE(CKA_CERTIFICATE_CATEGORY);
101
0
        CASE(CKA_ISSUER);
102
0
        CASE(CKA_SERIAL_NUMBER);
103
0
        CASE(CKA_AC_ISSUER);
104
0
        CASE(CKA_OWNER);
105
0
        CASE(CKA_ATTR_TYPES);
106
0
        CASE(CKA_TRUSTED);
107
0
        CASE(CKA_KEY_TYPE);
108
0
        CASE(CKA_SUBJECT);
109
0
        CASE(CKA_ID);
110
0
        CASE(CKA_SENSITIVE);
111
0
        CASE(CKA_ENCRYPT);
112
0
        CASE(CKA_DECRYPT);
113
0
        CASE(CKA_WRAP);
114
0
        CASE(CKA_UNWRAP);
115
0
        CASE(CKA_SIGN);
116
0
        CASE(CKA_SIGN_RECOVER);
117
0
        CASE(CKA_VERIFY);
118
0
        CASE(CKA_VERIFY_RECOVER);
119
0
        CASE(CKA_DERIVE);
120
0
        CASE(CKA_START_DATE);
121
0
        CASE(CKA_END_DATE);
122
0
        CASE(CKA_MODULUS);
123
0
        CASE(CKA_MODULUS_BITS);
124
0
        CASE(CKA_PUBLIC_EXPONENT);
125
0
        CASE(CKA_PRIVATE_EXPONENT);
126
0
        CASE(CKA_PRIME_1);
127
0
        CASE(CKA_PRIME_2);
128
0
        CASE(CKA_EXPONENT_1);
129
0
        CASE(CKA_EXPONENT_2);
130
0
        CASE(CKA_COEFFICIENT);
131
0
        CASE(CKA_PRIME);
132
0
        CASE(CKA_SUBPRIME);
133
0
        CASE(CKA_BASE);
134
0
        CASE(CKA_PRIME_BITS);
135
0
        CASE(CKA_SUBPRIME_BITS);
136
0
        CASE(CKA_VALUE_BITS);
137
0
        CASE(CKA_VALUE_LEN);
138
0
        CASE(CKA_EXTRACTABLE);
139
0
        CASE(CKA_LOCAL);
140
0
        CASE(CKA_NEVER_EXTRACTABLE);
141
0
        CASE(CKA_ALWAYS_SENSITIVE);
142
0
        CASE(CKA_KEY_GEN_MECHANISM);
143
0
        CASE(CKA_MODIFIABLE);
144
0
        CASE(CKA_ECDSA_PARAMS);
145
0
        CASE(CKA_EC_POINT);
146
0
        CASE(CKA_SECONDARY_AUTH);
147
0
        CASE(CKA_AUTH_PIN_FLAGS);
148
0
        CASE(CKA_HW_FEATURE_TYPE);
149
0
        CASE(CKA_RESET_ON_INIT);
150
0
        CASE(CKA_HAS_RESET);
151
0
        CASE(CKA_VENDOR_DEFINED);
152
0
        CASE(CKA_PROFILE_ID);
153
0
        CASE(CKA_NSS_URL);
154
0
        CASE(CKA_NSS_EMAIL);
155
0
        CASE(CKA_NSS_SMIME_INFO);
156
0
        CASE(CKA_NSS_SMIME_TIMESTAMP);
157
0
        CASE(CKA_NSS_PKCS8_SALT);
158
0
        CASE(CKA_NSS_PASSWORD_CHECK);
159
0
        CASE(CKA_NSS_EXPIRES);
160
0
        CASE(CKA_NSS_KRL);
161
0
        CASE(CKA_NSS_PQG_COUNTER);
162
0
        CASE(CKA_NSS_PQG_SEED);
163
0
        CASE(CKA_NSS_PQG_H);
164
0
        CASE(CKA_NSS_PQG_SEED_BITS);
165
0
        CASE(CKA_TRUST);
166
0
        CASE(CKA_TRUST_DIGITAL_SIGNATURE);
167
0
        CASE(CKA_TRUST_NON_REPUDIATION);
168
0
        CASE(CKA_TRUST_KEY_ENCIPHERMENT);
169
0
        CASE(CKA_TRUST_DATA_ENCIPHERMENT);
170
0
        CASE(CKA_TRUST_KEY_AGREEMENT);
171
0
        CASE(CKA_TRUST_KEY_CERT_SIGN);
172
0
        CASE(CKA_TRUST_CRL_SIGN);
173
0
        CASE(CKA_TRUST_SERVER_AUTH);
174
0
        CASE(CKA_TRUST_CLIENT_AUTH);
175
0
        CASE(CKA_TRUST_CODE_SIGNING);
176
0
        CASE(CKA_TRUST_EMAIL_PROTECTION);
177
0
        CASE(CKA_TRUST_IPSEC_END_SYSTEM);
178
0
        CASE(CKA_TRUST_IPSEC_TUNNEL);
179
0
        CASE(CKA_TRUST_IPSEC_USER);
180
0
        CASE(CKA_TRUST_TIME_STAMPING);
181
0
        CASE(CKA_CERT_SHA1_HASH);
182
0
        CASE(CKA_CERT_MD5_HASH);
183
0
        CASE(CKA_NSS_DB);
184
0
        CASE(CKA_NSS_TRUST);
185
0
        default:
186
0
            break;
187
0
    }
188
0
    if (a)
189
0
        PR_snprintf(str, len, "%s", a);
190
0
    else
191
0
        PR_snprintf(str, len, "0x%p", atype);
192
0
}
193
194
static void
195
get_obj_class(CK_OBJECT_CLASS objClass, char *str, int len)
196
0
{
197
198
0
    const char *a = NULL;
199
200
0
    switch (objClass) {
201
0
        CASE(CKO_DATA);
202
0
        CASE(CKO_CERTIFICATE);
203
0
        CASE(CKO_PUBLIC_KEY);
204
0
        CASE(CKO_PRIVATE_KEY);
205
0
        CASE(CKO_SECRET_KEY);
206
0
        CASE(CKO_HW_FEATURE);
207
0
        CASE(CKO_DOMAIN_PARAMETERS);
208
0
        CASE(CKO_PROFILE);
209
0
        CASE(CKO_NSS_CRL);
210
0
        CASE(CKO_NSS_SMIME);
211
0
        CASE(CKO_NSS_TRUST);
212
0
        CASE(CKO_NSS_BUILTIN_ROOT_LIST);
213
0
        default:
214
0
            break;
215
0
    }
216
0
    if (a)
217
0
        PR_snprintf(str, len, "%s", a);
218
0
    else
219
0
        PR_snprintf(str, len, "0x%p", objClass);
220
0
}
221
222
static void
223
get_profile_val(CK_PROFILE_ID profile, char *str, int len)
224
0
{
225
226
0
    const char *a = NULL;
227
228
0
    switch (profile) {
229
0
        CASE(CKP_INVALID_ID);
230
0
        CASE(CKP_BASELINE_PROVIDER);
231
0
        CASE(CKP_EXTENDED_PROVIDER);
232
0
        CASE(CKP_AUTHENTICATION_TOKEN);
233
0
        CASE(CKP_PUBLIC_CERTIFICATES_TOKEN);
234
0
        default:
235
0
            break;
236
0
    }
237
0
    if (a)
238
0
        PR_snprintf(str, len, "%s", a);
239
0
    else
240
0
        PR_snprintf(str, len, "0x%p", profile);
241
0
}
242
243
static void
244
get_trust_val(CK_TRUST trust, char *str, int len)
245
0
{
246
0
    const char *a = NULL;
247
248
0
    switch (trust) {
249
0
        CASE(CKT_NSS_TRUSTED);
250
0
        CASE(CKT_NSS_TRUSTED_DELEGATOR);
251
0
        CASE(CKT_NSS_NOT_TRUSTED);
252
0
        CASE(CKT_NSS_MUST_VERIFY_TRUST);
253
0
        CASE(CKT_NSS_TRUST_UNKNOWN);
254
0
        CASE(CKT_NSS_VALID_DELEGATOR);
255
0
        default:
256
0
            break;
257
0
    }
258
0
    if (a)
259
0
        PR_snprintf(str, len, "%s", a);
260
0
    else
261
0
        PR_snprintf(str, len, "0x%p", trust);
262
0
}
263
264
static void
265
log_rv(CK_RV rv)
266
0
{
267
0
    const char *a = NULL;
268
269
0
    switch (rv) {
270
0
        CASE(CKR_OK);
271
0
        CASE(CKR_CANCEL);
272
0
        CASE(CKR_HOST_MEMORY);
273
0
        CASE(CKR_SLOT_ID_INVALID);
274
0
        CASE(CKR_GENERAL_ERROR);
275
0
        CASE(CKR_FUNCTION_FAILED);
276
0
        CASE(CKR_ARGUMENTS_BAD);
277
0
        CASE(CKR_NO_EVENT);
278
0
        CASE(CKR_NEED_TO_CREATE_THREADS);
279
0
        CASE(CKR_CANT_LOCK);
280
0
        CASE(CKR_ATTRIBUTE_READ_ONLY);
281
0
        CASE(CKR_ATTRIBUTE_SENSITIVE);
282
0
        CASE(CKR_ATTRIBUTE_TYPE_INVALID);
283
0
        CASE(CKR_ATTRIBUTE_VALUE_INVALID);
284
0
        CASE(CKR_DATA_INVALID);
285
0
        CASE(CKR_DATA_LEN_RANGE);
286
0
        CASE(CKR_DEVICE_ERROR);
287
0
        CASE(CKR_DEVICE_MEMORY);
288
0
        CASE(CKR_DEVICE_REMOVED);
289
0
        CASE(CKR_ENCRYPTED_DATA_INVALID);
290
0
        CASE(CKR_ENCRYPTED_DATA_LEN_RANGE);
291
0
        CASE(CKR_FUNCTION_CANCELED);
292
0
        CASE(CKR_FUNCTION_NOT_PARALLEL);
293
0
        CASE(CKR_FUNCTION_NOT_SUPPORTED);
294
0
        CASE(CKR_KEY_HANDLE_INVALID);
295
0
        CASE(CKR_KEY_SIZE_RANGE);
296
0
        CASE(CKR_KEY_TYPE_INCONSISTENT);
297
0
        CASE(CKR_KEY_NOT_NEEDED);
298
0
        CASE(CKR_KEY_CHANGED);
299
0
        CASE(CKR_KEY_NEEDED);
300
0
        CASE(CKR_KEY_INDIGESTIBLE);
301
0
        CASE(CKR_KEY_FUNCTION_NOT_PERMITTED);
302
0
        CASE(CKR_KEY_NOT_WRAPPABLE);
303
0
        CASE(CKR_KEY_UNEXTRACTABLE);
304
0
        CASE(CKR_MECHANISM_INVALID);
305
0
        CASE(CKR_MECHANISM_PARAM_INVALID);
306
0
        CASE(CKR_OBJECT_HANDLE_INVALID);
307
0
        CASE(CKR_OPERATION_ACTIVE);
308
0
        CASE(CKR_OPERATION_NOT_INITIALIZED);
309
0
        CASE(CKR_PIN_INCORRECT);
310
0
        CASE(CKR_PIN_INVALID);
311
0
        CASE(CKR_PIN_LEN_RANGE);
312
0
        CASE(CKR_PIN_EXPIRED);
313
0
        CASE(CKR_PIN_LOCKED);
314
0
        CASE(CKR_SESSION_CLOSED);
315
0
        CASE(CKR_SESSION_COUNT);
316
0
        CASE(CKR_SESSION_HANDLE_INVALID);
317
0
        CASE(CKR_SESSION_PARALLEL_NOT_SUPPORTED);
318
0
        CASE(CKR_SESSION_READ_ONLY);
319
0
        CASE(CKR_SESSION_EXISTS);
320
0
        CASE(CKR_SESSION_READ_ONLY_EXISTS);
321
0
        CASE(CKR_SESSION_READ_WRITE_SO_EXISTS);
322
0
        CASE(CKR_SIGNATURE_INVALID);
323
0
        CASE(CKR_SIGNATURE_LEN_RANGE);
324
0
        CASE(CKR_TEMPLATE_INCOMPLETE);
325
0
        CASE(CKR_TEMPLATE_INCONSISTENT);
326
0
        CASE(CKR_TOKEN_NOT_PRESENT);
327
0
        CASE(CKR_TOKEN_NOT_RECOGNIZED);
328
0
        CASE(CKR_TOKEN_WRITE_PROTECTED);
329
0
        CASE(CKR_UNWRAPPING_KEY_HANDLE_INVALID);
330
0
        CASE(CKR_UNWRAPPING_KEY_SIZE_RANGE);
331
0
        CASE(CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT);
332
0
        CASE(CKR_USER_ALREADY_LOGGED_IN);
333
0
        CASE(CKR_USER_NOT_LOGGED_IN);
334
0
        CASE(CKR_USER_PIN_NOT_INITIALIZED);
335
0
        CASE(CKR_USER_TYPE_INVALID);
336
0
        CASE(CKR_USER_ANOTHER_ALREADY_LOGGED_IN);
337
0
        CASE(CKR_USER_TOO_MANY_TYPES);
338
0
        CASE(CKR_WRAPPED_KEY_INVALID);
339
0
        CASE(CKR_WRAPPED_KEY_LEN_RANGE);
340
0
        CASE(CKR_WRAPPING_KEY_HANDLE_INVALID);
341
0
        CASE(CKR_WRAPPING_KEY_SIZE_RANGE);
342
0
        CASE(CKR_WRAPPING_KEY_TYPE_INCONSISTENT);
343
0
        CASE(CKR_RANDOM_SEED_NOT_SUPPORTED);
344
0
        CASE(CKR_RANDOM_NO_RNG);
345
0
        CASE(CKR_DOMAIN_PARAMS_INVALID);
346
0
        CASE(CKR_BUFFER_TOO_SMALL);
347
0
        CASE(CKR_SAVED_STATE_INVALID);
348
0
        CASE(CKR_INFORMATION_SENSITIVE);
349
0
        CASE(CKR_STATE_UNSAVEABLE);
350
0
        CASE(CKR_CRYPTOKI_NOT_INITIALIZED);
351
0
        CASE(CKR_CRYPTOKI_ALREADY_INITIALIZED);
352
0
        CASE(CKR_MUTEX_BAD);
353
0
        CASE(CKR_MUTEX_NOT_LOCKED);
354
0
        CASE(CKR_FUNCTION_REJECTED);
355
0
        CASE(CKR_ACTION_PROHIBITED);
356
0
        CASE(CKR_CURVE_NOT_SUPPORTED);
357
0
        CASE(CKR_NEW_PIN_MODE);
358
0
        CASE(CKR_NEXT_OTP);
359
0
        CASE(CKR_EXCEEDED_MAX_ITERATIONS);
360
0
        CASE(CKR_FIPS_SELF_TEST_FAILED);
361
0
        CASE(CKR_LIBRARY_LOAD_FAILED);
362
0
        CASE(CKR_PIN_TOO_WEAK);
363
0
        CASE(CKR_TOKEN_RESOURCE_EXCEEDED);
364
0
        CASE(CKR_OPERATION_CANCEL_FAILED);
365
0
        default:
366
0
            break;
367
0
    }
368
0
    if (a)
369
0
        PR_LOG(modlog, 1, ("  rv = %s\n", a));
370
0
    else
371
0
        PR_LOG(modlog, 1, ("  rv = 0x%x\n", rv));
372
0
}
373
374
static void
375
log_state(CK_STATE state)
376
0
{
377
0
    const char *a = NULL;
378
379
0
    switch (state) {
380
0
        CASE(CKS_RO_PUBLIC_SESSION);
381
0
        CASE(CKS_RO_USER_FUNCTIONS);
382
0
        CASE(CKS_RW_PUBLIC_SESSION);
383
0
        CASE(CKS_RW_USER_FUNCTIONS);
384
0
        CASE(CKS_RW_SO_FUNCTIONS);
385
0
        default:
386
0
            break;
387
0
    }
388
0
    if (a)
389
0
        PR_LOG(modlog, 1, ("  state = %s\n", a));
390
0
    else
391
0
        PR_LOG(modlog, 1, ("  state = 0x%x\n", state));
392
0
}
393
394
static void
395
log_handle(PRLogModuleLevel level, const char *format, CK_ULONG handle)
396
0
{
397
0
    char fmtBuf[80];
398
0
    if (handle)
399
0
        PR_LOG(modlog, level, (format, handle));
400
0
    else {
401
0
        PL_strncpyz(fmtBuf, format, sizeof fmtBuf);
402
0
        PL_strcatn(fmtBuf, sizeof fmtBuf, fmt_invalid_handle);
403
0
        PR_LOG(modlog, level, (fmtBuf, handle));
404
0
    }
405
0
}
406
407
static void
408
print_mechanism(CK_MECHANISM_PTR m)
409
0
{
410
411
0
    const char *a = NULL;
412
413
0
    switch (m->mechanism) {
414
0
        CASE(CKM_AES_CBC);
415
0
        CASE(CKM_AES_CBC_ENCRYPT_DATA);
416
0
        CASE(CKM_AES_CBC_PAD);
417
0
        CASE(CKM_AES_CCM);
418
0
        CASE(CKM_AES_CTR);
419
0
        CASE(CKM_AES_CTS);
420
0
        CASE(CKM_AES_GCM);
421
0
        CASE(CKM_AES_ECB);
422
0
        CASE(CKM_AES_ECB_ENCRYPT_DATA);
423
0
        CASE(CKM_AES_KEY_GEN);
424
0
        CASE(CKM_AES_MAC);
425
0
        CASE(CKM_AES_MAC_GENERAL);
426
0
        CASE(CKM_AES_CMAC);
427
0
        CASE(CKM_AES_CMAC_GENERAL);
428
0
        CASE(CKM_CAMELLIA_CBC);
429
0
        CASE(CKM_CAMELLIA_CBC_ENCRYPT_DATA);
430
0
        CASE(CKM_CAMELLIA_CBC_PAD);
431
0
        CASE(CKM_CAMELLIA_ECB);
432
0
        CASE(CKM_CAMELLIA_ECB_ENCRYPT_DATA);
433
0
        CASE(CKM_CAMELLIA_KEY_GEN);
434
0
        CASE(CKM_CAMELLIA_MAC);
435
0
        CASE(CKM_CAMELLIA_MAC_GENERAL);
436
0
        CASE(CKM_CHACHA20_KEY_GEN);
437
0
        CASE(CKM_CHACHA20);
438
0
        CASE(CKM_CDMF_CBC);
439
0
        CASE(CKM_CDMF_CBC_PAD);
440
0
        CASE(CKM_CDMF_ECB);
441
0
        CASE(CKM_CDMF_KEY_GEN);
442
0
        CASE(CKM_CDMF_MAC);
443
0
        CASE(CKM_CDMF_MAC_GENERAL);
444
0
        CASE(CKM_CMS_SIG);
445
0
        CASE(CKM_CONCATENATE_BASE_AND_DATA);
446
0
        CASE(CKM_CONCATENATE_BASE_AND_KEY);
447
0
        CASE(CKM_CONCATENATE_DATA_AND_BASE);
448
0
        CASE(CKM_DES2_KEY_GEN);
449
0
        CASE(CKM_DES3_CBC);
450
0
        CASE(CKM_DES3_CBC_ENCRYPT_DATA);
451
0
        CASE(CKM_DES3_CBC_PAD);
452
0
        CASE(CKM_DES3_ECB);
453
0
        CASE(CKM_DES3_ECB_ENCRYPT_DATA);
454
0
        CASE(CKM_DES3_KEY_GEN);
455
0
        CASE(CKM_DES3_MAC);
456
0
        CASE(CKM_DES3_MAC_GENERAL);
457
0
        CASE(CKM_DES_CBC);
458
0
        CASE(CKM_DES_CBC_ENCRYPT_DATA);
459
0
        CASE(CKM_DES_CBC_PAD);
460
0
        CASE(CKM_DES_CFB64);
461
0
        CASE(CKM_DES_CFB8);
462
0
        CASE(CKM_DES_ECB);
463
0
        CASE(CKM_DES_ECB_ENCRYPT_DATA);
464
0
        CASE(CKM_DES_KEY_GEN);
465
0
        CASE(CKM_DES_MAC);
466
0
        CASE(CKM_DES_MAC_GENERAL);
467
0
        CASE(CKM_DES_OFB64);
468
0
        CASE(CKM_DES_OFB8);
469
0
        CASE(CKM_DH_PKCS_DERIVE);
470
0
        CASE(CKM_DH_PKCS_KEY_PAIR_GEN);
471
0
        CASE(CKM_DH_PKCS_PARAMETER_GEN);
472
0
        CASE(CKM_DSA);
473
0
        CASE(CKM_DSA_KEY_PAIR_GEN);
474
0
        CASE(CKM_DSA_PARAMETER_GEN);
475
0
        CASE(CKM_DSA_SHA1);
476
0
        CASE(CKM_ECDH1_COFACTOR_DERIVE);
477
0
        CASE(CKM_ECDH1_DERIVE);
478
0
        CASE(CKM_ECDSA);
479
0
        CASE(CKM_ECDSA_SHA1);
480
0
        CASE(CKM_ECMQV_DERIVE);
481
0
        CASE(CKM_EC_KEY_PAIR_GEN); /* also CASE(CKM_ECDSA_KEY_PAIR_GEN); */
482
0
        CASE(CKM_EXTRACT_KEY_FROM_KEY);
483
0
        CASE(CKM_ECDSA_SHA224);
484
0
        CASE(CKM_ECDSA_SHA256);
485
0
        CASE(CKM_ECDSA_SHA384);
486
0
        CASE(CKM_ECDSA_SHA512);
487
0
        CASE(CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS);
488
0
        CASE(CKM_FASTHASH);
489
0
        CASE(CKM_FORTEZZA_TIMESTAMP);
490
0
        CASE(CKM_GENERIC_SECRET_KEY_GEN);
491
0
        CASE(CKM_IDEA_CBC);
492
0
        CASE(CKM_IDEA_CBC_PAD);
493
0
        CASE(CKM_IDEA_ECB);
494
0
        CASE(CKM_IDEA_KEY_GEN);
495
0
        CASE(CKM_IDEA_MAC);
496
0
        CASE(CKM_IDEA_MAC_GENERAL);
497
0
        CASE(CKM_KEA_KEY_DERIVE);
498
0
        CASE(CKM_KEA_KEY_PAIR_GEN);
499
0
        CASE(CKM_KEY_WRAP_LYNKS);
500
0
        CASE(CKM_KEY_WRAP_SET_OAEP);
501
0
        CASE(CKM_MD2);
502
0
        CASE(CKM_MD2_HMAC);
503
0
        CASE(CKM_MD2_HMAC_GENERAL);
504
0
        CASE(CKM_MD2_KEY_DERIVATION);
505
0
        CASE(CKM_MD2_RSA_PKCS);
506
0
        CASE(CKM_MD5);
507
0
        CASE(CKM_MD5_HMAC);
508
0
        CASE(CKM_MD5_HMAC_GENERAL);
509
0
        CASE(CKM_MD5_KEY_DERIVATION);
510
0
        CASE(CKM_MD5_RSA_PKCS);
511
0
        CASE(CKM_PBA_SHA1_WITH_SHA1_HMAC);
512
0
        CASE(CKM_PBE_MD2_DES_CBC);
513
0
        CASE(CKM_PBE_MD5_DES_CBC);
514
0
        CASE(CKM_PBE_SHA1_DES2_EDE_CBC);
515
0
        CASE(CKM_PBE_SHA1_DES3_EDE_CBC);
516
0
        CASE(CKM_PBE_SHA1_RC2_128_CBC);
517
0
        CASE(CKM_PBE_SHA1_RC2_40_CBC);
518
0
        CASE(CKM_PBE_SHA1_RC4_128);
519
0
        CASE(CKM_PBE_SHA1_RC4_40);
520
0
        CASE(CKM_PKCS5_PBKD2);
521
0
        CASE(CKM_POLY1305_KEY_GEN);
522
0
        CASE(CKM_POLY1305);
523
0
        CASE(CKM_RC2_CBC);
524
0
        CASE(CKM_RC2_CBC_PAD);
525
0
        CASE(CKM_RC2_ECB);
526
0
        CASE(CKM_RC2_KEY_GEN);
527
0
        CASE(CKM_RC2_MAC);
528
0
        CASE(CKM_RC2_MAC_GENERAL);
529
0
        CASE(CKM_RC4);
530
0
        CASE(CKM_RC4_KEY_GEN);
531
0
        CASE(CKM_RC5_CBC);
532
0
        CASE(CKM_RC5_CBC_PAD);
533
0
        CASE(CKM_RC5_ECB);
534
0
        CASE(CKM_RC5_KEY_GEN);
535
0
        CASE(CKM_RC5_MAC);
536
0
        CASE(CKM_RC5_MAC_GENERAL);
537
0
        CASE(CKM_RIPEMD128);
538
0
        CASE(CKM_RIPEMD128_HMAC);
539
0
        CASE(CKM_RIPEMD128_HMAC_GENERAL);
540
0
        CASE(CKM_RIPEMD128_RSA_PKCS);
541
0
        CASE(CKM_RIPEMD160);
542
0
        CASE(CKM_RIPEMD160_HMAC);
543
0
        CASE(CKM_RIPEMD160_HMAC_GENERAL);
544
0
        CASE(CKM_RIPEMD160_RSA_PKCS);
545
0
        CASE(CKM_RSA_9796);
546
0
        CASE(CKM_RSA_PKCS);
547
0
        CASE(CKM_RSA_PKCS_KEY_PAIR_GEN);
548
0
        CASE(CKM_RSA_PKCS_OAEP);
549
0
        CASE(CKM_RSA_PKCS_PSS);
550
0
        CASE(CKM_RSA_X9_31);
551
0
        CASE(CKM_RSA_X9_31_KEY_PAIR_GEN);
552
0
        CASE(CKM_RSA_X_509);
553
0
        CASE(CKM_SHA1_KEY_DERIVATION);
554
0
        CASE(CKM_SHA1_RSA_PKCS);
555
0
        CASE(CKM_SHA1_RSA_PKCS_PSS);
556
0
        CASE(CKM_SHA1_RSA_X9_31);
557
0
        CASE(CKM_SHA224);
558
0
        CASE(CKM_SHA224_HMAC);
559
0
        CASE(CKM_SHA224_HMAC_GENERAL);
560
0
        CASE(CKM_SHA224_KEY_DERIVATION);
561
0
        CASE(CKM_SHA224_RSA_PKCS);
562
0
        CASE(CKM_SHA224_RSA_PKCS_PSS);
563
0
        CASE(CKM_SHA256);
564
0
        CASE(CKM_SHA256_HMAC);
565
0
        CASE(CKM_SHA256_HMAC_GENERAL);
566
0
        CASE(CKM_SHA256_KEY_DERIVATION);
567
0
        CASE(CKM_SHA256_RSA_PKCS);
568
0
        CASE(CKM_SHA256_RSA_PKCS_PSS);
569
0
        CASE(CKM_SHA384);
570
0
        CASE(CKM_SHA384_HMAC);
571
0
        CASE(CKM_SHA384_HMAC_GENERAL);
572
0
        CASE(CKM_SHA384_KEY_DERIVATION);
573
0
        CASE(CKM_SHA384_RSA_PKCS);
574
0
        CASE(CKM_SHA384_RSA_PKCS_PSS);
575
0
        CASE(CKM_SHA512);
576
0
        CASE(CKM_SHA512_HMAC);
577
0
        CASE(CKM_SHA512_HMAC_GENERAL);
578
0
        CASE(CKM_SHA512_KEY_DERIVATION);
579
0
        CASE(CKM_SHA512_RSA_PKCS);
580
0
        CASE(CKM_SHA512_RSA_PKCS_PSS);
581
0
        CASE(CKM_SHA_1);
582
0
        CASE(CKM_SHA_1_HMAC);
583
0
        CASE(CKM_SHA_1_HMAC_GENERAL);
584
0
        CASE(CKM_SKIPJACK_CBC64);
585
0
        CASE(CKM_SKIPJACK_CFB16);
586
0
        CASE(CKM_SKIPJACK_CFB32);
587
0
        CASE(CKM_SKIPJACK_CFB64);
588
0
        CASE(CKM_SKIPJACK_CFB8);
589
0
        CASE(CKM_SKIPJACK_ECB64);
590
0
        CASE(CKM_SKIPJACK_KEY_GEN);
591
0
        CASE(CKM_SKIPJACK_OFB64);
592
0
        CASE(CKM_SKIPJACK_PRIVATE_WRAP);
593
0
        CASE(CKM_SKIPJACK_RELAYX);
594
0
        CASE(CKM_SKIPJACK_WRAP);
595
0
        CASE(CKM_SSL3_KEY_AND_MAC_DERIVE);
596
0
        CASE(CKM_SSL3_MASTER_KEY_DERIVE);
597
0
        CASE(CKM_SSL3_MASTER_KEY_DERIVE_DH);
598
0
        CASE(CKM_SSL3_MD5_MAC);
599
0
        CASE(CKM_SSL3_PRE_MASTER_KEY_GEN);
600
0
        CASE(CKM_SSL3_SHA1_MAC);
601
0
        CASE(CKM_TLS_KEY_AND_MAC_DERIVE);
602
0
        CASE(CKM_TLS_MASTER_KEY_DERIVE);
603
0
        CASE(CKM_TLS_MASTER_KEY_DERIVE_DH);
604
0
        CASE(CKM_TLS_PRE_MASTER_KEY_GEN);
605
0
        CASE(CKM_TLS_PRF);
606
0
        CASE(CKM_TWOFISH_CBC);
607
0
        CASE(CKM_TWOFISH_KEY_GEN);
608
0
        CASE(CKM_X9_42_DH_DERIVE);
609
0
        CASE(CKM_X9_42_DH_HYBRID_DERIVE);
610
0
        CASE(CKM_X9_42_DH_KEY_PAIR_GEN);
611
0
        CASE(CKM_X9_42_DH_PARAMETER_GEN);
612
0
        CASE(CKM_X9_42_MQV_DERIVE);
613
0
        CASE(CKM_XOR_BASE_AND_DATA);
614
0
        default:
615
0
            break;
616
0
    }
617
0
    if (a)
618
0
        PR_LOG(modlog, 4, ("      mechanism = %s", a));
619
0
    else
620
0
        PR_LOG(modlog, 4, ("      mechanism = 0x%p", m->mechanism));
621
0
}
622
623
static void
624
get_key_type(CK_KEY_TYPE keyType, char *str, int len)
625
0
{
626
627
0
    const char *a = NULL;
628
629
0
    switch (keyType) {
630
0
        CASE(CKK_AES);
631
0
        CASE(CKK_CAMELLIA);
632
0
        CASE(CKK_CDMF);
633
0
        CASE(CKK_DES);
634
0
        CASE(CKK_DES2);
635
0
        CASE(CKK_DES3);
636
0
        CASE(CKK_DH);
637
0
        CASE(CKK_DSA);
638
0
        CASE(CKK_EC); /* also CASE(CKK_ECDSA); */
639
0
        CASE(CKK_GENERIC_SECRET);
640
0
        CASE(CKK_IDEA);
641
0
        CASE(CKK_INVALID_KEY_TYPE);
642
0
        CASE(CKK_KEA);
643
0
        CASE(CKK_RC2);
644
0
        CASE(CKK_RC4);
645
0
        CASE(CKK_RC5);
646
0
        CASE(CKK_RSA);
647
0
        CASE(CKK_SKIPJACK);
648
0
        CASE(CKK_TWOFISH);
649
0
        CASE(CKK_X9_42_DH);
650
0
        CASE(CKK_MD5_HMAC);
651
0
        CASE(CKK_SHA_1_HMAC);
652
0
        CASE(CKK_RIPEMD128_HMAC);
653
0
        CASE(CKK_RIPEMD160_HMAC);
654
0
        CASE(CKK_SHA256_HMAC);
655
0
        CASE(CKK_SHA384_HMAC);
656
0
        CASE(CKK_SHA512_HMAC);
657
0
        CASE(CKK_SHA224_HMAC);
658
0
        CASE(CKK_GOSTR3410);
659
0
        CASE(CKK_GOSTR3411);
660
0
        CASE(CKK_GOST28147);
661
0
        CASE(CKK_CHACHA20);
662
0
        CASE(CKK_POLY1305);
663
0
        CASE(CKK_AES_XTS);
664
0
        CASE(CKK_SHA3_224_HMAC);
665
0
        CASE(CKK_SHA3_256_HMAC);
666
0
        CASE(CKK_SHA3_384_HMAC);
667
0
        CASE(CKK_SHA3_512_HMAC);
668
0
        CASE(CKK_BLAKE2B_160_HMAC);
669
0
        CASE(CKK_BLAKE2B_256_HMAC);
670
0
        CASE(CKK_BLAKE2B_384_HMAC);
671
0
        CASE(CKK_BLAKE2B_512_HMAC);
672
0
        CASE(CKK_SALSA20);
673
0
        CASE(CKK_X2RATCHET);
674
0
        CASE(CKK_EC_EDWARDS);
675
0
        CASE(CKK_EC_MONTGOMERY);
676
0
        CASE(CKK_HKDF);
677
0
        CASE(CKK_SHA512_224_HMAC);
678
0
        CASE(CKK_SHA512_256_HMAC);
679
0
        CASE(CKK_SHA512_T_HMAC);
680
0
        default:
681
0
            break;
682
0
    }
683
0
    if (a)
684
0
        PR_snprintf(str, len, "%s", a);
685
0
    else
686
0
        PR_snprintf(str, len, "0x%p", keyType);
687
0
}
688
689
static void
690
print_attr_value(CK_ATTRIBUTE_PTR attr)
691
0
{
692
0
    char atype[48];
693
0
    char valstr[49];
694
0
    int len;
695
696
0
    get_attr_type_str(attr->type, atype, sizeof atype);
697
0
    switch (attr->type) {
698
0
        case CKA_ALWAYS_SENSITIVE:
699
0
        case CKA_DECRYPT:
700
0
        case CKA_DERIVE:
701
0
        case CKA_ENCRYPT:
702
0
        case CKA_EXTRACTABLE:
703
0
        case CKA_LOCAL:
704
0
        case CKA_MODIFIABLE:
705
0
        case CKA_NEVER_EXTRACTABLE:
706
0
        case CKA_PRIVATE:
707
0
        case CKA_SENSITIVE:
708
0
        case CKA_SIGN:
709
0
        case CKA_SIGN_RECOVER:
710
0
        case CKA_TOKEN:
711
0
        case CKA_UNWRAP:
712
0
        case CKA_VERIFY:
713
0
        case CKA_VERIFY_RECOVER:
714
0
        case CKA_WRAP:
715
0
            if (attr->ulValueLen > 0 && attr->pValue) {
716
0
                CK_BBOOL tf = *((CK_BBOOL *)attr->pValue);
717
0
                PR_LOG(modlog, 4, (fmt_s_s_d, atype, tf ? "CK_TRUE" : "CK_FALSE", attr->ulValueLen));
718
0
                break;
719
0
            }
720
0
        case CKA_CLASS:
721
0
            if (attr->ulValueLen > 0 && attr->pValue) {
722
0
                CK_OBJECT_CLASS objClass = *((CK_OBJECT_CLASS *)attr->pValue);
723
0
                get_obj_class(objClass, valstr, sizeof valstr);
724
0
                PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen));
725
0
                break;
726
0
            }
727
0
        case CKA_TRUST_CLIENT_AUTH:
728
0
        case CKA_TRUST_CODE_SIGNING:
729
0
        case CKA_TRUST_EMAIL_PROTECTION:
730
0
        case CKA_TRUST_SERVER_AUTH:
731
0
            if (attr->ulValueLen > 0 && attr->pValue) {
732
0
                CK_TRUST trust = *((CK_TRUST *)attr->pValue);
733
0
                get_trust_val(trust, valstr, sizeof valstr);
734
0
                PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen));
735
0
                break;
736
0
            }
737
0
        case CKA_KEY_TYPE:
738
0
            if (attr->ulValueLen > 0 && attr->pValue) {
739
0
                CK_KEY_TYPE keyType = *((CK_KEY_TYPE *)attr->pValue);
740
0
                get_key_type(keyType, valstr, sizeof valstr);
741
0
                PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen));
742
0
                break;
743
0
            }
744
0
        case CKA_PIXEL_X:
745
0
        case CKA_PIXEL_Y:
746
0
        case CKA_RESOLUTION:
747
0
        case CKA_CHAR_ROWS:
748
0
        case CKA_CHAR_COLUMNS:
749
0
        case CKA_BITS_PER_PIXEL:
750
0
        case CKA_CERTIFICATE_CATEGORY:      /* should print as enum/string */
751
0
        case CKA_JAVA_MIDP_SECURITY_DOMAIN: /* should print as enum/string */
752
0
        case CKA_MODULUS_BITS:
753
0
        case CKA_PRIME_BITS:
754
0
        case CKA_SUBPRIME_BITS:
755
0
        case CKA_VALUE_BITS:
756
0
        case CKA_VALUE_LEN:
757
0
            if (attr->ulValueLen > 0 && attr->pValue) {
758
0
                CK_ULONG valueLen = *((CK_ULONG *)attr->pValue);
759
                /* XXX check for the special value CK_UNAVAILABLE_INFORMATION */
760
0
                PR_LOG(modlog, 4, (fmt_s_lu, atype, (PRUint32)valueLen));
761
0
                break;
762
0
            }
763
0
        case CKA_LABEL:
764
0
        case CKA_NSS_EMAIL:
765
0
        case CKA_NSS_URL:
766
0
            if (attr->ulValueLen > 0 && attr->pValue) {
767
0
                len = PR_MIN(attr->ulValueLen + 1, sizeof valstr);
768
0
                PR_snprintf(valstr, len, "%s", attr->pValue);
769
0
                PR_LOG(modlog, 4, (fmt_s_qsq_d, atype, valstr, attr->ulValueLen));
770
0
                break;
771
0
            }
772
0
        case CKA_PROFILE_ID:
773
0
            if (attr->ulValueLen > 0 && attr->pValue) {
774
0
                CK_PROFILE_ID profile = *((CK_PROFILE_ID *)attr->pValue);
775
0
                get_profile_val(profile, valstr, sizeof valstr);
776
0
                PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen));
777
0
                break;
778
0
            }
779
0
        case CKA_ISSUER:
780
0
        case CKA_SUBJECT:
781
0
            if (attr->ulValueLen > 0 && attr->pValue) {
782
0
                char *asciiName;
783
0
                SECItem derName;
784
0
                derName.type = siDERNameBuffer;
785
0
                derName.data = attr->pValue;
786
0
                derName.len = attr->ulValueLen;
787
0
                asciiName = CERT_DerNameToAscii(&derName);
788
0
                if (asciiName) {
789
0
                    PR_LOG(modlog, 4, (fmt_s_s_d, atype, asciiName, attr->ulValueLen));
790
0
                    PORT_Free(asciiName);
791
0
                    break;
792
0
                }
793
                /* else treat like a binary buffer */
794
0
                goto binary_buffer;
795
0
            }
796
0
        case CKA_ID:
797
0
            if (attr->ulValueLen > 0 && attr->pValue) {
798
0
                unsigned char *pV = attr->pValue;
799
0
                for (len = (int)attr->ulValueLen; len > 0; --len) {
800
0
                    unsigned int ch = *pV++;
801
0
                    if (ch >= 0x20 && ch < 0x7f)
802
0
                        continue;
803
0
                    if (!ch && len == 1) /* will ignore NUL if last character */
804
0
                        continue;
805
0
                    break;
806
0
                }
807
0
                if (!len) { /* entire string is printable */
808
0
                    len = PR_MIN(attr->ulValueLen + 1, sizeof valstr);
809
0
                    PR_snprintf(valstr, len, "%s", attr->pValue);
810
0
                    PR_LOG(modlog, 4, (fmt_s_qsq_d, atype, valstr, attr->ulValueLen));
811
0
                    break;
812
0
                }
813
                /* else fall through and treat like a binary buffer */
814
0
            }
815
0
        binary_buffer:
816
0
        case CKA_SERIAL_NUMBER:
817
0
        default:
818
0
            if (attr->ulValueLen > 0 && attr->pValue) {
819
0
                char *hexBuf;
820
0
                SECItem attrBuf;
821
0
                attrBuf.type = siDERNameBuffer;
822
0
                attrBuf.data = attr->pValue;
823
0
                attrBuf.len = PR_MIN(attr->ulValueLen, (sizeof valstr) / 2);
824
825
0
                hexBuf = CERT_Hexify(&attrBuf, PR_FALSE);
826
0
                if (hexBuf) {
827
0
                    PR_LOG(modlog, 4, (fmt_s_s_d, atype, hexBuf, attr->ulValueLen));
828
0
                    PORT_Free(hexBuf);
829
0
                    break;
830
0
                }
831
                /* else fall through and show only the address. :( */
832
0
            }
833
0
            PR_LOG(modlog, 4, ("    %s = [0x%p] [%d]", atype, attr->pValue, attr->ulValueLen));
834
0
            break;
835
0
    }
836
0
}
837
838
static void
839
print_template(CK_ATTRIBUTE_PTR templ, CK_ULONG tlen)
840
0
{
841
0
    CK_ULONG i;
842
0
    for (i = 0; i < tlen; i++) {
843
0
        print_attr_value(&templ[i]);
844
0
    }
845
0
}
846
847
struct nssdbg_prof_str {
848
    PRUint32 time;
849
    PRUint32 calls;
850
    char *function;
851
};
852
853
#define NSSDBG_DEFINE(func) \
854
    {                       \
855
        0, 0, #func         \
856
    }
857
858
struct nssdbg_prof_str nssdbg_prof_data[] = {
859
0
#define FUNC_C_INITIALIZE 0
860
    NSSDBG_DEFINE(C_Initialize),
861
0
#define FUNC_C_FINALIZE 1
862
    NSSDBG_DEFINE(C_Finalize),
863
0
#define FUNC_C_GETINFO 2
864
    NSSDBG_DEFINE(C_GetInfo),
865
0
#define FUNC_C_GETFUNCITONLIST 3
866
    NSSDBG_DEFINE(C_GetFunctionList),
867
0
#define FUNC_C_GETSLOTLIST 4
868
    NSSDBG_DEFINE(C_GetSlotList),
869
0
#define FUNC_C_GETSLOTINFO 5
870
    NSSDBG_DEFINE(C_GetSlotInfo),
871
0
#define FUNC_C_GETTOKENINFO 6
872
    NSSDBG_DEFINE(C_GetTokenInfo),
873
0
#define FUNC_C_GETMECHANISMLIST 7
874
    NSSDBG_DEFINE(C_GetMechanismList),
875
0
#define FUNC_C_GETMECHANISMINFO 8
876
    NSSDBG_DEFINE(C_GetMechanismInfo),
877
0
#define FUNC_C_INITTOKEN 9
878
    NSSDBG_DEFINE(C_InitToken),
879
0
#define FUNC_C_INITPIN 10
880
    NSSDBG_DEFINE(C_InitPIN),
881
0
#define FUNC_C_SETPIN 11
882
    NSSDBG_DEFINE(C_SetPIN),
883
0
#define FUNC_C_OPENSESSION 12
884
    NSSDBG_DEFINE(C_OpenSession),
885
0
#define FUNC_C_CLOSESESSION 13
886
    NSSDBG_DEFINE(C_CloseSession),
887
0
#define FUNC_C_CLOSEALLSESSIONS 14
888
    NSSDBG_DEFINE(C_CloseAllSessions),
889
0
#define FUNC_C_GETSESSIONINFO 15
890
    NSSDBG_DEFINE(C_GetSessionInfo),
891
0
#define FUNC_C_GETOPERATIONSTATE 16
892
    NSSDBG_DEFINE(C_GetOperationState),
893
0
#define FUNC_C_SETOPERATIONSTATE 17
894
    NSSDBG_DEFINE(C_SetOperationState),
895
0
#define FUNC_C_LOGIN 18
896
    NSSDBG_DEFINE(C_Login),
897
0
#define FUNC_C_LOGOUT 19
898
    NSSDBG_DEFINE(C_Logout),
899
0
#define FUNC_C_CREATEOBJECT 20
900
    NSSDBG_DEFINE(C_CreateObject),
901
0
#define FUNC_C_COPYOBJECT 21
902
    NSSDBG_DEFINE(C_CopyObject),
903
0
#define FUNC_C_DESTROYOBJECT 22
904
    NSSDBG_DEFINE(C_DestroyObject),
905
0
#define FUNC_C_GETOBJECTSIZE 23
906
    NSSDBG_DEFINE(C_GetObjectSize),
907
0
#define FUNC_C_GETATTRIBUTEVALUE 24
908
    NSSDBG_DEFINE(C_GetAttributeValue),
909
0
#define FUNC_C_SETATTRIBUTEVALUE 25
910
    NSSDBG_DEFINE(C_SetAttributeValue),
911
0
#define FUNC_C_FINDOBJECTSINIT 26
912
    NSSDBG_DEFINE(C_FindObjectsInit),
913
0
#define FUNC_C_FINDOBJECTS 27
914
    NSSDBG_DEFINE(C_FindObjects),
915
0
#define FUNC_C_FINDOBJECTSFINAL 28
916
    NSSDBG_DEFINE(C_FindObjectsFinal),
917
0
#define FUNC_C_ENCRYPTINIT 29
918
    NSSDBG_DEFINE(C_EncryptInit),
919
0
#define FUNC_C_ENCRYPT 30
920
    NSSDBG_DEFINE(C_Encrypt),
921
0
#define FUNC_C_ENCRYPTUPDATE 31
922
    NSSDBG_DEFINE(C_EncryptUpdate),
923
0
#define FUNC_C_ENCRYPTFINAL 32
924
    NSSDBG_DEFINE(C_EncryptFinal),
925
0
#define FUNC_C_DECRYPTINIT 33
926
    NSSDBG_DEFINE(C_DecryptInit),
927
0
#define FUNC_C_DECRYPT 34
928
    NSSDBG_DEFINE(C_Decrypt),
929
0
#define FUNC_C_DECRYPTUPDATE 35
930
    NSSDBG_DEFINE(C_DecryptUpdate),
931
0
#define FUNC_C_DECRYPTFINAL 36
932
    NSSDBG_DEFINE(C_DecryptFinal),
933
0
#define FUNC_C_DIGESTINIT 37
934
    NSSDBG_DEFINE(C_DigestInit),
935
0
#define FUNC_C_DIGEST 38
936
    NSSDBG_DEFINE(C_Digest),
937
0
#define FUNC_C_DIGESTUPDATE 39
938
    NSSDBG_DEFINE(C_DigestUpdate),
939
0
#define FUNC_C_DIGESTKEY 40
940
    NSSDBG_DEFINE(C_DigestKey),
941
0
#define FUNC_C_DIGESTFINAL 41
942
    NSSDBG_DEFINE(C_DigestFinal),
943
0
#define FUNC_C_SIGNINIT 42
944
    NSSDBG_DEFINE(C_SignInit),
945
0
#define FUNC_C_SIGN 43
946
    NSSDBG_DEFINE(C_Sign),
947
0
#define FUNC_C_SIGNUPDATE 44
948
    NSSDBG_DEFINE(C_SignUpdate),
949
0
#define FUNC_C_SIGNFINAL 45
950
    NSSDBG_DEFINE(C_SignFinal),
951
0
#define FUNC_C_SIGNRECOVERINIT 46
952
    NSSDBG_DEFINE(C_SignRecoverInit),
953
0
#define FUNC_C_SIGNRECOVER 47
954
    NSSDBG_DEFINE(C_SignRecover),
955
0
#define FUNC_C_VERIFYINIT 48
956
    NSSDBG_DEFINE(C_VerifyInit),
957
0
#define FUNC_C_VERIFY 49
958
    NSSDBG_DEFINE(C_Verify),
959
0
#define FUNC_C_VERIFYUPDATE 50
960
    NSSDBG_DEFINE(C_VerifyUpdate),
961
0
#define FUNC_C_VERIFYFINAL 51
962
    NSSDBG_DEFINE(C_VerifyFinal),
963
0
#define FUNC_C_VERIFYRECOVERINIT 52
964
    NSSDBG_DEFINE(C_VerifyRecoverInit),
965
0
#define FUNC_C_VERIFYRECOVER 53
966
    NSSDBG_DEFINE(C_VerifyRecover),
967
0
#define FUNC_C_DIGESTENCRYPTUPDATE 54
968
    NSSDBG_DEFINE(C_DigestEncryptUpdate),
969
0
#define FUNC_C_DECRYPTDIGESTUPDATE 55
970
    NSSDBG_DEFINE(C_DecryptDigestUpdate),
971
0
#define FUNC_C_SIGNENCRYPTUPDATE 56
972
    NSSDBG_DEFINE(C_SignEncryptUpdate),
973
0
#define FUNC_C_DECRYPTVERIFYUPDATE 57
974
    NSSDBG_DEFINE(C_DecryptVerifyUpdate),
975
0
#define FUNC_C_GENERATEKEY 58
976
    NSSDBG_DEFINE(C_GenerateKey),
977
0
#define FUNC_C_GENERATEKEYPAIR 59
978
    NSSDBG_DEFINE(C_GenerateKeyPair),
979
0
#define FUNC_C_WRAPKEY 60
980
    NSSDBG_DEFINE(C_WrapKey),
981
0
#define FUNC_C_UNWRAPKEY 61
982
    NSSDBG_DEFINE(C_UnWrapKey),
983
0
#define FUNC_C_DERIVEKEY 62
984
    NSSDBG_DEFINE(C_DeriveKey),
985
0
#define FUNC_C_SEEDRANDOM 63
986
    NSSDBG_DEFINE(C_SeedRandom),
987
0
#define FUNC_C_GENERATERANDOM 64
988
    NSSDBG_DEFINE(C_GenerateRandom),
989
0
#define FUNC_C_GETFUNCTIONSTATUS 65
990
    NSSDBG_DEFINE(C_GetFunctionStatus),
991
0
#define FUNC_C_CANCELFUNCTION 66
992
    NSSDBG_DEFINE(C_CancelFunction),
993
0
#define FUNC_C_WAITFORSLOTEVENT 67
994
    NSSDBG_DEFINE(C_WaitForSlotEvent),
995
0
#define FUNC_C_GETINTERFACELIST 68
996
    NSSDBG_DEFINE(C_GetInterfaceList),
997
0
#define FUNC_C_GETINTERFACE 69
998
    NSSDBG_DEFINE(C_GetInterface),
999
0
#define FUNC_C_LOGINUSER 70
1000
    NSSDBG_DEFINE(C_LoginUser),
1001
0
#define FUNC_C_SESSIONCANCEL 71
1002
    NSSDBG_DEFINE(C_SessionCancel),
1003
0
#define FUNC_C_MESSAGEENCRYPTINIT 72
1004
    NSSDBG_DEFINE(C_MessageEncryptInit),
1005
0
#define FUNC_C_ENCRYPTMESSAGE 73
1006
    NSSDBG_DEFINE(C_EncryptMessage),
1007
0
#define FUNC_C_ENCRYPTMESSAGEBEGIN 74
1008
    NSSDBG_DEFINE(C_EncryptMessageBegin),
1009
0
#define FUNC_C_ENCRYPTMESSAGENEXT 75
1010
    NSSDBG_DEFINE(C_EncryptMessageNext),
1011
0
#define FUNC_C_MESSAGEENCRYPTFINAL 76
1012
    NSSDBG_DEFINE(C_MessageEncryptFinal),
1013
0
#define FUNC_C_MESSAGEDECRYPTINIT 77
1014
    NSSDBG_DEFINE(C_MessageDecryptInit),
1015
0
#define FUNC_C_DECRYPTMESSAGE 78
1016
    NSSDBG_DEFINE(C_DecryptMessage),
1017
0
#define FUNC_C_DECRYPTMESSAGEBEGIN 79
1018
    NSSDBG_DEFINE(C_DecryptMessageBegin),
1019
0
#define FUNC_C_DECRYPTMESSAGENEXT 80
1020
    NSSDBG_DEFINE(C_DecryptMessageNext),
1021
0
#define FUNC_C_MESSAGEDECRYPTFINAL 81
1022
    NSSDBG_DEFINE(C_MessageDecryptFinal),
1023
0
#define FUNC_C_MESSAGESIGNINIT 82
1024
    NSSDBG_DEFINE(C_MessageSignInit),
1025
0
#define FUNC_C_SIGNMESSAGE 83
1026
    NSSDBG_DEFINE(C_SignMessage),
1027
0
#define FUNC_C_SIGNMESSAGEBEGIN 84
1028
    NSSDBG_DEFINE(C_SignMessageBegin),
1029
0
#define FUNC_C_SIGNMESSAGENEXT 85
1030
    NSSDBG_DEFINE(C_SignMessageNext),
1031
0
#define FUNC_C_MESSAGESIGNFINAL 86
1032
    NSSDBG_DEFINE(C_MessageSignFinal),
1033
0
#define FUNC_C_MESSAGEVERIFYINIT 87
1034
    NSSDBG_DEFINE(C_MessageVerifyInit),
1035
0
#define FUNC_C_VERIFYMESSAGE 88
1036
    NSSDBG_DEFINE(C_VerifyMessage),
1037
0
#define FUNC_C_VERIFYMESSAGEBEGIN 89
1038
    NSSDBG_DEFINE(C_VerifyMessageBegin),
1039
0
#define FUNC_C_VERIFYMESSAGENEXT 90
1040
    NSSDBG_DEFINE(C_VerifyMessageNext),
1041
0
#define FUNC_C_MESSAGEVERIFYFINAL 91
1042
    NSSDBG_DEFINE(C_MessageVerifyFinal)
1043
};
1044
1045
int nssdbg_prof_size = sizeof(nssdbg_prof_data) / sizeof(nssdbg_prof_data[0]);
1046
1047
static void
1048
nssdbg_finish_time(PRInt32 fun_number, PRIntervalTime start)
1049
0
{
1050
0
    PRIntervalTime ival;
1051
0
    PRIntervalTime end = PR_IntervalNow();
1052
1053
0
    ival = end - start;
1054
    /* sigh, lie to PRAtomic add and say we are using signed values */
1055
0
    PR_ATOMIC_ADD((PRInt32 *)&nssdbg_prof_data[fun_number].time, (PRInt32)ival);
1056
0
}
1057
1058
static void
1059
nssdbg_start_time(PRInt32 fun_number, PRIntervalTime *start)
1060
0
{
1061
0
    PR_ATOMIC_INCREMENT((PRInt32 *)&nssdbg_prof_data[fun_number].calls);
1062
0
    *start = PR_IntervalNow();
1063
0
}
1064
1065
#define COMMON_DEFINITIONS \
1066
0
    CK_RV rv;              \
1067
0
    PRIntervalTime start
1068
1069
CK_RV
1070
NSSDBGC_Initialize(
1071
    CK_VOID_PTR pInitArgs)
1072
0
{
1073
0
    COMMON_DEFINITIONS;
1074
1075
0
    PR_LOG(modlog, 1, ("C_Initialize"));
1076
0
    PR_LOG(modlog, 3, ("  pInitArgs = 0x%p", pInitArgs));
1077
0
    nssdbg_start_time(FUNC_C_INITIALIZE, &start);
1078
0
    rv = module_functions->C_Initialize(pInitArgs);
1079
0
    nssdbg_finish_time(FUNC_C_INITIALIZE, start);
1080
0
    log_rv(rv);
1081
0
    return rv;
1082
0
}
1083
1084
CK_RV
1085
NSSDBGC_Finalize(
1086
    CK_VOID_PTR pReserved)
1087
0
{
1088
0
    COMMON_DEFINITIONS;
1089
1090
0
    PR_LOG(modlog, 1, ("C_Finalize"));
1091
0
    PR_LOG(modlog, 3, ("  pReserved = 0x%p", pReserved));
1092
0
    nssdbg_start_time(FUNC_C_FINALIZE, &start);
1093
0
    rv = module_functions->C_Finalize(pReserved);
1094
0
    nssdbg_finish_time(FUNC_C_FINALIZE, start);
1095
0
    log_rv(rv);
1096
0
    return rv;
1097
0
}
1098
1099
CK_RV
1100
NSSDBGC_GetInfo(
1101
    CK_INFO_PTR pInfo)
1102
0
{
1103
0
    COMMON_DEFINITIONS;
1104
1105
0
    PR_LOG(modlog, 1, ("C_GetInfo"));
1106
0
    PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
1107
0
    nssdbg_start_time(FUNC_C_GETINFO, &start);
1108
0
    rv = module_functions->C_GetInfo(pInfo);
1109
0
    nssdbg_finish_time(FUNC_C_GETINFO, start);
1110
0
    if (rv == CKR_OK) {
1111
0
        PR_LOG(modlog, 4, ("  cryptoki version: %d.%d", pInfo->cryptokiVersion.major, pInfo->cryptokiVersion.minor));
1112
0
        PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID));
1113
0
        PR_LOG(modlog, 4, ("  library description = \"%.32s\"", pInfo->libraryDescription));
1114
0
        PR_LOG(modlog, 4, ("  library version: %d.%d", pInfo->libraryVersion.major, pInfo->libraryVersion.minor));
1115
0
    }
1116
0
    log_rv(rv);
1117
0
    return rv;
1118
0
}
1119
1120
CK_RV
1121
NSSDBGC_GetFunctionList(
1122
    CK_FUNCTION_LIST_PTR_PTR ppFunctionList)
1123
0
{
1124
0
    COMMON_DEFINITIONS;
1125
1126
0
    PR_LOG(modlog, 1, ("C_GetFunctionList"));
1127
0
    PR_LOG(modlog, 3, ("  ppFunctionList = 0x%p", ppFunctionList));
1128
0
    nssdbg_start_time(FUNC_C_GETFUNCITONLIST, &start);
1129
0
    rv = module_functions->C_GetFunctionList(ppFunctionList);
1130
0
    nssdbg_finish_time(FUNC_C_GETFUNCITONLIST, start);
1131
0
    log_rv(rv);
1132
0
    return rv;
1133
0
}
1134
1135
CK_RV
1136
NSSDBGC_GetSlotList(
1137
    CK_BBOOL tokenPresent,
1138
    CK_SLOT_ID_PTR pSlotList,
1139
    CK_ULONG_PTR pulCount)
1140
0
{
1141
0
    COMMON_DEFINITIONS;
1142
1143
0
    CK_ULONG i;
1144
0
    PR_LOG(modlog, 1, ("C_GetSlotList"));
1145
0
    PR_LOG(modlog, 3, ("  tokenPresent = 0x%x", tokenPresent));
1146
0
    PR_LOG(modlog, 3, ("  pSlotList = 0x%p", pSlotList));
1147
0
    PR_LOG(modlog, 3, (fmt_pulCount, pulCount));
1148
0
    nssdbg_start_time(FUNC_C_GETSLOTLIST, &start);
1149
0
    rv = module_functions->C_GetSlotList(tokenPresent, pSlotList, pulCount);
1150
0
    nssdbg_finish_time(FUNC_C_GETSLOTLIST, start);
1151
0
    PR_LOG(modlog, 4, (fmt_spulCount, *pulCount));
1152
0
    if (pSlotList) {
1153
0
        for (i = 0; i < *pulCount; i++) {
1154
0
            PR_LOG(modlog, 4, ("  slotID[%d] = %x", i, pSlotList[i]));
1155
0
        }
1156
0
    }
1157
0
    log_rv(rv);
1158
0
    return rv;
1159
0
}
1160
1161
CK_RV
1162
NSSDBGC_GetSlotInfo(
1163
    CK_SLOT_ID slotID,
1164
    CK_SLOT_INFO_PTR pInfo)
1165
0
{
1166
0
    COMMON_DEFINITIONS;
1167
1168
0
    PR_LOG(modlog, 1, ("C_GetSlotInfo"));
1169
0
    PR_LOG(modlog, 3, (fmt_slotID, slotID));
1170
0
    PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
1171
0
    nssdbg_start_time(FUNC_C_GETSLOTINFO, &start);
1172
0
    rv = module_functions->C_GetSlotInfo(slotID, pInfo);
1173
0
    nssdbg_finish_time(FUNC_C_GETSLOTINFO, start);
1174
0
    if (rv == CKR_OK) {
1175
0
        PR_LOG(modlog, 4, ("  slotDescription = \"%.64s\"", pInfo->slotDescription));
1176
0
        PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID));
1177
0
        PR_LOG(modlog, 4, ("  flags = %s %s %s", pInfo->flags & CKF_HW_SLOT ? "CKF_HW_SLOT" : "", pInfo->flags & CKF_REMOVABLE_DEVICE ? "CKF_REMOVABLE_DEVICE" : "", pInfo->flags & CKF_TOKEN_PRESENT ? "CKF_TOKEN_PRESENT" : ""));
1178
0
        PR_LOG(modlog, 4, (fmt_hwVersion, pInfo->hardwareVersion.major, pInfo->hardwareVersion.minor));
1179
0
        PR_LOG(modlog, 4, (fmt_fwVersion, pInfo->firmwareVersion.major, pInfo->firmwareVersion.minor));
1180
0
    }
1181
0
    log_rv(rv);
1182
0
    return rv;
1183
0
}
1184
1185
CK_RV
1186
NSSDBGC_GetTokenInfo(
1187
    CK_SLOT_ID slotID,
1188
    CK_TOKEN_INFO_PTR pInfo)
1189
0
{
1190
0
    COMMON_DEFINITIONS;
1191
1192
0
    PR_LOG(modlog, 1, ("C_GetTokenInfo"));
1193
0
    PR_LOG(modlog, 3, (fmt_slotID, slotID));
1194
0
    PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
1195
0
    nssdbg_start_time(FUNC_C_GETTOKENINFO, &start);
1196
0
    rv = module_functions->C_GetTokenInfo(slotID, pInfo);
1197
0
    nssdbg_finish_time(FUNC_C_GETTOKENINFO, start);
1198
0
    if (rv == CKR_OK) {
1199
0
        PR_LOG(modlog, 4, ("  label = \"%.32s\"", pInfo->label));
1200
0
        PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID));
1201
0
        PR_LOG(modlog, 4, ("  model = \"%.16s\"", pInfo->model));
1202
0
        PR_LOG(modlog, 4, ("  serial = \"%.16s\"", pInfo->serialNumber));
1203
0
        PR_LOG(modlog, 4, ("  flags = %s %s %s %s", pInfo->flags & CKF_RNG ? "CKF_RNG" : "", pInfo->flags & CKF_WRITE_PROTECTED ? "CKF_WRITE_PROTECTED" : "", pInfo->flags & CKF_LOGIN_REQUIRED ? "CKF_LOGIN_REQUIRED" : "", pInfo->flags & CKF_USER_PIN_INITIALIZED ? "CKF_USER_PIN_INIT" : ""));
1204
0
        PR_LOG(modlog, 4, ("  maxSessions = %u, Sessions = %u", pInfo->ulMaxSessionCount, pInfo->ulSessionCount));
1205
0
        PR_LOG(modlog, 4, ("  maxRwSessions = %u, RwSessions = %u", pInfo->ulMaxRwSessionCount, pInfo->ulRwSessionCount));
1206
        /* ignore Max & Min Pin Len, Public and Private Memory */
1207
0
        PR_LOG(modlog, 4, (fmt_hwVersion, pInfo->hardwareVersion.major, pInfo->hardwareVersion.minor));
1208
0
        PR_LOG(modlog, 4, (fmt_fwVersion, pInfo->firmwareVersion.major, pInfo->firmwareVersion.minor));
1209
0
    }
1210
0
    log_rv(rv);
1211
0
    return rv;
1212
0
}
1213
1214
CK_RV
1215
NSSDBGC_GetMechanismList(
1216
    CK_SLOT_ID slotID,
1217
    CK_MECHANISM_TYPE_PTR pMechanismList,
1218
    CK_ULONG_PTR pulCount)
1219
0
{
1220
0
    COMMON_DEFINITIONS;
1221
1222
0
    PR_LOG(modlog, 1, ("C_GetMechanismList"));
1223
0
    PR_LOG(modlog, 3, (fmt_slotID, slotID));
1224
0
    PR_LOG(modlog, 3, ("  pMechanismList = 0x%p", pMechanismList));
1225
0
    PR_LOG(modlog, 3, (fmt_pulCount, pulCount));
1226
0
    nssdbg_start_time(FUNC_C_GETMECHANISMLIST, &start);
1227
0
    rv = module_functions->C_GetMechanismList(slotID,
1228
0
                                              pMechanismList,
1229
0
                                              pulCount);
1230
0
    nssdbg_finish_time(FUNC_C_GETMECHANISMLIST, start);
1231
0
    PR_LOG(modlog, 4, (fmt_spulCount, *pulCount));
1232
0
    log_rv(rv);
1233
0
    return rv;
1234
0
}
1235
1236
CK_RV
1237
NSSDBGC_GetMechanismInfo(
1238
    CK_SLOT_ID slotID,
1239
    CK_MECHANISM_TYPE type,
1240
    CK_MECHANISM_INFO_PTR pInfo)
1241
0
{
1242
0
    COMMON_DEFINITIONS;
1243
1244
0
    PR_LOG(modlog, 1, ("C_GetMechanismInfo"));
1245
0
    PR_LOG(modlog, 3, (fmt_slotID, slotID));
1246
0
    PR_LOG(modlog, 3, ("  type = 0x%x", type));
1247
0
    PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
1248
0
    nssdbg_start_time(FUNC_C_GETMECHANISMINFO, &start);
1249
0
    rv = module_functions->C_GetMechanismInfo(slotID,
1250
0
                                              type,
1251
0
                                              pInfo);
1252
0
    nssdbg_finish_time(FUNC_C_GETMECHANISMINFO, start);
1253
0
    log_rv(rv);
1254
0
    return rv;
1255
0
}
1256
1257
CK_RV
1258
NSSDBGC_InitToken(
1259
    CK_SLOT_ID slotID,
1260
    CK_CHAR_PTR pPin,
1261
    CK_ULONG ulPinLen,
1262
    CK_CHAR_PTR pLabel)
1263
0
{
1264
0
    COMMON_DEFINITIONS;
1265
1266
0
    PR_LOG(modlog, 1, ("C_InitToken"));
1267
0
    PR_LOG(modlog, 3, (fmt_slotID, slotID));
1268
0
    PR_LOG(modlog, 3, (fmt_pPin, pPin));
1269
0
    PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
1270
0
    PR_LOG(modlog, 3, ("  pLabel = 0x%p", pLabel));
1271
0
    nssdbg_start_time(FUNC_C_INITTOKEN, &start);
1272
0
    rv = module_functions->C_InitToken(slotID,
1273
0
                                       pPin,
1274
0
                                       ulPinLen,
1275
0
                                       pLabel);
1276
0
    nssdbg_finish_time(FUNC_C_INITTOKEN, start);
1277
0
    log_rv(rv);
1278
0
    return rv;
1279
0
}
1280
1281
CK_RV
1282
NSSDBGC_InitPIN(
1283
    CK_SESSION_HANDLE hSession,
1284
    CK_CHAR_PTR pPin,
1285
    CK_ULONG ulPinLen)
1286
0
{
1287
0
    COMMON_DEFINITIONS;
1288
1289
0
    PR_LOG(modlog, 1, ("C_InitPIN"));
1290
0
    log_handle(3, fmt_hSession, hSession);
1291
0
    PR_LOG(modlog, 3, (fmt_pPin, pPin));
1292
0
    PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
1293
0
    nssdbg_start_time(FUNC_C_INITPIN, &start);
1294
0
    rv = module_functions->C_InitPIN(hSession,
1295
0
                                     pPin,
1296
0
                                     ulPinLen);
1297
0
    nssdbg_finish_time(FUNC_C_INITPIN, start);
1298
0
    log_rv(rv);
1299
0
    return rv;
1300
0
}
1301
1302
CK_RV
1303
NSSDBGC_SetPIN(
1304
    CK_SESSION_HANDLE hSession,
1305
    CK_CHAR_PTR pOldPin,
1306
    CK_ULONG ulOldLen,
1307
    CK_CHAR_PTR pNewPin,
1308
    CK_ULONG ulNewLen)
1309
0
{
1310
0
    COMMON_DEFINITIONS;
1311
1312
0
    PR_LOG(modlog, 1, ("C_SetPIN"));
1313
0
    log_handle(3, fmt_hSession, hSession);
1314
0
    PR_LOG(modlog, 3, ("  pOldPin = 0x%p", pOldPin));
1315
0
    PR_LOG(modlog, 3, ("  ulOldLen = %d", ulOldLen));
1316
0
    PR_LOG(modlog, 3, ("  pNewPin = 0x%p", pNewPin));
1317
0
    PR_LOG(modlog, 3, ("  ulNewLen = %d", ulNewLen));
1318
0
    nssdbg_start_time(FUNC_C_SETPIN, &start);
1319
0
    rv = module_functions->C_SetPIN(hSession,
1320
0
                                    pOldPin,
1321
0
                                    ulOldLen,
1322
0
                                    pNewPin,
1323
0
                                    ulNewLen);
1324
0
    nssdbg_finish_time(FUNC_C_SETPIN, start);
1325
0
    log_rv(rv);
1326
0
    return rv;
1327
0
}
1328
1329
static PRUint32 numOpenSessions = 0;
1330
static PRUint32 maxOpenSessions = 0;
1331
1332
CK_RV
1333
NSSDBGC_OpenSession(
1334
    CK_SLOT_ID slotID,
1335
    CK_FLAGS flags,
1336
    CK_VOID_PTR pApplication,
1337
    CK_NOTIFY Notify,
1338
    CK_SESSION_HANDLE_PTR phSession)
1339
0
{
1340
0
    COMMON_DEFINITIONS;
1341
1342
0
    PR_ATOMIC_INCREMENT((PRInt32 *)&numOpenSessions);
1343
0
    maxOpenSessions = PR_MAX(numOpenSessions, maxOpenSessions);
1344
0
    PR_LOG(modlog, 1, ("C_OpenSession"));
1345
0
    PR_LOG(modlog, 3, (fmt_slotID, slotID));
1346
0
    PR_LOG(modlog, 3, (fmt_flags, flags));
1347
0
    PR_LOG(modlog, 3, ("  pApplication = 0x%p", pApplication));
1348
0
    PR_LOG(modlog, 3, ("  Notify = 0x%x", Notify));
1349
0
    PR_LOG(modlog, 3, ("  phSession = 0x%p", phSession));
1350
0
    nssdbg_start_time(FUNC_C_OPENSESSION, &start);
1351
0
    rv = module_functions->C_OpenSession(slotID,
1352
0
                                         flags,
1353
0
                                         pApplication,
1354
0
                                         Notify,
1355
0
                                         phSession);
1356
0
    nssdbg_finish_time(FUNC_C_OPENSESSION, start);
1357
0
    log_handle(4, "  *phSession = 0x%x", *phSession);
1358
0
    log_rv(rv);
1359
0
    return rv;
1360
0
}
1361
1362
CK_RV
1363
NSSDBGC_CloseSession(
1364
    CK_SESSION_HANDLE hSession)
1365
0
{
1366
0
    COMMON_DEFINITIONS;
1367
1368
0
    PR_ATOMIC_DECREMENT((PRInt32 *)&numOpenSessions);
1369
0
    PR_LOG(modlog, 1, ("C_CloseSession"));
1370
0
    log_handle(3, fmt_hSession, hSession);
1371
0
    nssdbg_start_time(FUNC_C_CLOSESESSION, &start);
1372
0
    rv = module_functions->C_CloseSession(hSession);
1373
0
    nssdbg_finish_time(FUNC_C_CLOSESESSION, start);
1374
0
    log_rv(rv);
1375
0
    return rv;
1376
0
}
1377
1378
CK_RV
1379
NSSDBGC_CloseAllSessions(
1380
    CK_SLOT_ID slotID)
1381
0
{
1382
0
    COMMON_DEFINITIONS;
1383
1384
0
    PR_LOG(modlog, 1, ("C_CloseAllSessions"));
1385
0
    PR_LOG(modlog, 3, (fmt_slotID, slotID));
1386
0
    nssdbg_start_time(FUNC_C_CLOSEALLSESSIONS, &start);
1387
0
    rv = module_functions->C_CloseAllSessions(slotID);
1388
0
    nssdbg_finish_time(FUNC_C_CLOSEALLSESSIONS, start);
1389
0
    log_rv(rv);
1390
0
    return rv;
1391
0
}
1392
1393
CK_RV
1394
NSSDBGC_GetSessionInfo(
1395
    CK_SESSION_HANDLE hSession,
1396
    CK_SESSION_INFO_PTR pInfo)
1397
0
{
1398
0
    COMMON_DEFINITIONS;
1399
1400
0
    PR_LOG(modlog, 1, ("C_GetSessionInfo"));
1401
0
    log_handle(3, fmt_hSession, hSession);
1402
0
    PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
1403
0
    nssdbg_start_time(FUNC_C_GETSESSIONINFO, &start);
1404
0
    rv = module_functions->C_GetSessionInfo(hSession,
1405
0
                                            pInfo);
1406
0
    nssdbg_finish_time(FUNC_C_GETSESSIONINFO, start);
1407
0
    if (rv == CKR_OK) {
1408
0
        PR_LOG(modlog, 4, (fmt_slotID, pInfo->slotID));
1409
0
        log_state(pInfo->state);
1410
0
        PR_LOG(modlog, 4, ("  flags = %s %s", pInfo->flags & CKF_RW_SESSION ? "CKF_RW_SESSION" : "", pInfo->flags & CKF_SERIAL_SESSION ? "CKF_SERIAL_SESSION" : ""));
1411
0
        PR_LOG(modlog, 4, ("  deviceError = 0x%x", pInfo->ulDeviceError));
1412
0
    }
1413
0
    log_rv(rv);
1414
0
    return rv;
1415
0
}
1416
1417
CK_RV
1418
NSSDBGC_GetOperationState(
1419
    CK_SESSION_HANDLE hSession,
1420
    CK_BYTE_PTR pOperationState,
1421
    CK_ULONG_PTR pulOperationStateLen)
1422
0
{
1423
0
    COMMON_DEFINITIONS;
1424
1425
0
    PR_LOG(modlog, 1, ("C_GetOperationState"));
1426
0
    log_handle(3, fmt_hSession, hSession);
1427
0
    PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState));
1428
0
    PR_LOG(modlog, 3, ("  pulOperationStateLen = 0x%p", pulOperationStateLen));
1429
0
    nssdbg_start_time(FUNC_C_GETOPERATIONSTATE, &start);
1430
0
    rv = module_functions->C_GetOperationState(hSession,
1431
0
                                               pOperationState,
1432
0
                                               pulOperationStateLen);
1433
0
    nssdbg_finish_time(FUNC_C_GETOPERATIONSTATE, start);
1434
0
    PR_LOG(modlog, 4, ("  *pulOperationStateLen = 0x%x", *pulOperationStateLen));
1435
0
    log_rv(rv);
1436
0
    return rv;
1437
0
}
1438
1439
CK_RV
1440
NSSDBGC_SetOperationState(
1441
    CK_SESSION_HANDLE hSession,
1442
    CK_BYTE_PTR pOperationState,
1443
    CK_ULONG ulOperationStateLen,
1444
    CK_OBJECT_HANDLE hEncryptionKey,
1445
    CK_OBJECT_HANDLE hAuthenticationKey)
1446
0
{
1447
0
    COMMON_DEFINITIONS;
1448
1449
0
    PR_LOG(modlog, 1, ("C_SetOperationState"));
1450
0
    log_handle(3, fmt_hSession, hSession);
1451
0
    PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState));
1452
0
    PR_LOG(modlog, 3, ("  ulOperationStateLen = %d", ulOperationStateLen));
1453
0
    log_handle(3, "  hEncryptionKey = 0x%x", hEncryptionKey);
1454
0
    log_handle(3, "  hAuthenticationKey = 0x%x", hAuthenticationKey);
1455
0
    nssdbg_start_time(FUNC_C_SETOPERATIONSTATE, &start);
1456
0
    rv = module_functions->C_SetOperationState(hSession,
1457
0
                                               pOperationState,
1458
0
                                               ulOperationStateLen,
1459
0
                                               hEncryptionKey,
1460
0
                                               hAuthenticationKey);
1461
0
    nssdbg_finish_time(FUNC_C_SETOPERATIONSTATE, start);
1462
0
    log_rv(rv);
1463
0
    return rv;
1464
0
}
1465
1466
CK_RV
1467
NSSDBGC_Login(
1468
    CK_SESSION_HANDLE hSession,
1469
    CK_USER_TYPE userType,
1470
    CK_CHAR_PTR pPin,
1471
    CK_ULONG ulPinLen)
1472
0
{
1473
0
    COMMON_DEFINITIONS;
1474
1475
0
    PR_LOG(modlog, 1, ("C_Login"));
1476
0
    log_handle(3, fmt_hSession, hSession);
1477
0
    PR_LOG(modlog, 3, ("  userType = 0x%x", userType));
1478
0
    PR_LOG(modlog, 3, (fmt_pPin, pPin));
1479
0
    PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
1480
0
    nssdbg_start_time(FUNC_C_LOGIN, &start);
1481
0
    rv = module_functions->C_Login(hSession,
1482
0
                                   userType,
1483
0
                                   pPin,
1484
0
                                   ulPinLen);
1485
0
    nssdbg_finish_time(FUNC_C_LOGIN, start);
1486
0
    log_rv(rv);
1487
0
    return rv;
1488
0
}
1489
1490
CK_RV
1491
NSSDBGC_Logout(
1492
    CK_SESSION_HANDLE hSession)
1493
0
{
1494
0
    COMMON_DEFINITIONS;
1495
1496
0
    PR_LOG(modlog, 1, ("C_Logout"));
1497
0
    log_handle(3, fmt_hSession, hSession);
1498
0
    nssdbg_start_time(FUNC_C_LOGOUT, &start);
1499
0
    rv = module_functions->C_Logout(hSession);
1500
0
    nssdbg_finish_time(FUNC_C_LOGOUT, start);
1501
0
    log_rv(rv);
1502
0
    return rv;
1503
0
}
1504
1505
CK_RV
1506
NSSDBGC_CreateObject(
1507
    CK_SESSION_HANDLE hSession,
1508
    CK_ATTRIBUTE_PTR pTemplate,
1509
    CK_ULONG ulCount,
1510
    CK_OBJECT_HANDLE_PTR phObject)
1511
0
{
1512
0
    COMMON_DEFINITIONS;
1513
1514
0
    PR_LOG(modlog, 1, ("C_CreateObject"));
1515
0
    log_handle(3, fmt_hSession, hSession);
1516
0
    PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1517
0
    PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1518
0
    PR_LOG(modlog, 3, (fmt_phObject, phObject));
1519
0
    print_template(pTemplate, ulCount);
1520
0
    nssdbg_start_time(FUNC_C_CREATEOBJECT, &start);
1521
0
    rv = module_functions->C_CreateObject(hSession,
1522
0
                                          pTemplate,
1523
0
                                          ulCount,
1524
0
                                          phObject);
1525
0
    nssdbg_finish_time(FUNC_C_CREATEOBJECT, start);
1526
0
    log_handle(4, "  *phObject = 0x%x", *phObject);
1527
0
    log_rv(rv);
1528
0
    return rv;
1529
0
}
1530
1531
CK_RV
1532
NSSDBGC_CopyObject(
1533
    CK_SESSION_HANDLE hSession,
1534
    CK_OBJECT_HANDLE hObject,
1535
    CK_ATTRIBUTE_PTR pTemplate,
1536
    CK_ULONG ulCount,
1537
    CK_OBJECT_HANDLE_PTR phNewObject)
1538
0
{
1539
0
    COMMON_DEFINITIONS;
1540
1541
0
    PR_LOG(modlog, 1, ("C_CopyObject"));
1542
0
    log_handle(3, fmt_hSession, hSession);
1543
0
    log_handle(3, fmt_hObject, hObject);
1544
0
    PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1545
0
    PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1546
0
    PR_LOG(modlog, 3, ("  phNewObject = 0x%p", phNewObject));
1547
0
    print_template(pTemplate, ulCount);
1548
0
    nssdbg_start_time(FUNC_C_COPYOBJECT, &start);
1549
0
    rv = module_functions->C_CopyObject(hSession,
1550
0
                                        hObject,
1551
0
                                        pTemplate,
1552
0
                                        ulCount,
1553
0
                                        phNewObject);
1554
0
    nssdbg_finish_time(FUNC_C_COPYOBJECT, start);
1555
0
    log_handle(4, "  *phNewObject = 0x%x", *phNewObject);
1556
0
    log_rv(rv);
1557
0
    return rv;
1558
0
}
1559
1560
CK_RV
1561
NSSDBGC_DestroyObject(
1562
    CK_SESSION_HANDLE hSession,
1563
    CK_OBJECT_HANDLE hObject)
1564
0
{
1565
0
    COMMON_DEFINITIONS;
1566
1567
0
    PR_LOG(modlog, 1, ("C_DestroyObject"));
1568
0
    log_handle(3, fmt_hSession, hSession);
1569
0
    log_handle(3, fmt_hObject, hObject);
1570
0
    nssdbg_start_time(FUNC_C_DESTROYOBJECT, &start);
1571
0
    rv = module_functions->C_DestroyObject(hSession,
1572
0
                                           hObject);
1573
0
    nssdbg_finish_time(FUNC_C_DESTROYOBJECT, start);
1574
0
    log_rv(rv);
1575
0
    return rv;
1576
0
}
1577
1578
CK_RV
1579
NSSDBGC_GetObjectSize(
1580
    CK_SESSION_HANDLE hSession,
1581
    CK_OBJECT_HANDLE hObject,
1582
    CK_ULONG_PTR pulSize)
1583
0
{
1584
0
    COMMON_DEFINITIONS;
1585
1586
0
    PR_LOG(modlog, 1, ("C_GetObjectSize"));
1587
0
    log_handle(3, fmt_hSession, hSession);
1588
0
    log_handle(3, fmt_hObject, hObject);
1589
0
    PR_LOG(modlog, 3, ("  pulSize = 0x%p", pulSize));
1590
0
    nssdbg_start_time(FUNC_C_GETOBJECTSIZE, &start);
1591
0
    rv = module_functions->C_GetObjectSize(hSession,
1592
0
                                           hObject,
1593
0
                                           pulSize);
1594
0
    nssdbg_finish_time(FUNC_C_GETOBJECTSIZE, start);
1595
0
    PR_LOG(modlog, 4, ("  *pulSize = 0x%x", *pulSize));
1596
0
    log_rv(rv);
1597
0
    return rv;
1598
0
}
1599
1600
CK_RV
1601
NSSDBGC_GetAttributeValue(
1602
    CK_SESSION_HANDLE hSession,
1603
    CK_OBJECT_HANDLE hObject,
1604
    CK_ATTRIBUTE_PTR pTemplate,
1605
    CK_ULONG ulCount)
1606
0
{
1607
0
    COMMON_DEFINITIONS;
1608
1609
0
    PR_LOG(modlog, 1, ("C_GetAttributeValue"));
1610
0
    log_handle(3, fmt_hSession, hSession);
1611
0
    log_handle(3, fmt_hObject, hObject);
1612
0
    PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1613
0
    PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1614
0
    nssdbg_start_time(FUNC_C_GETATTRIBUTEVALUE, &start);
1615
0
    rv = module_functions->C_GetAttributeValue(hSession,
1616
0
                                               hObject,
1617
0
                                               pTemplate,
1618
0
                                               ulCount);
1619
0
    nssdbg_finish_time(FUNC_C_GETATTRIBUTEVALUE, start);
1620
0
    print_template(pTemplate, ulCount);
1621
0
    log_rv(rv);
1622
0
    return rv;
1623
0
}
1624
1625
CK_RV
1626
NSSDBGC_SetAttributeValue(
1627
    CK_SESSION_HANDLE hSession,
1628
    CK_OBJECT_HANDLE hObject,
1629
    CK_ATTRIBUTE_PTR pTemplate,
1630
    CK_ULONG ulCount)
1631
0
{
1632
0
    COMMON_DEFINITIONS;
1633
1634
0
    PR_LOG(modlog, 1, ("C_SetAttributeValue"));
1635
0
    log_handle(3, fmt_hSession, hSession);
1636
0
    log_handle(3, fmt_hObject, hObject);
1637
0
    PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1638
0
    PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1639
0
    print_template(pTemplate, ulCount);
1640
0
    nssdbg_start_time(FUNC_C_SETATTRIBUTEVALUE, &start);
1641
0
    rv = module_functions->C_SetAttributeValue(hSession,
1642
0
                                               hObject,
1643
0
                                               pTemplate,
1644
0
                                               ulCount);
1645
0
    nssdbg_finish_time(FUNC_C_SETATTRIBUTEVALUE, start);
1646
0
    log_rv(rv);
1647
0
    return rv;
1648
0
}
1649
1650
CK_RV
1651
NSSDBGC_FindObjectsInit(
1652
    CK_SESSION_HANDLE hSession,
1653
    CK_ATTRIBUTE_PTR pTemplate,
1654
    CK_ULONG ulCount)
1655
0
{
1656
0
    COMMON_DEFINITIONS;
1657
1658
0
    PR_LOG(modlog, 1, ("C_FindObjectsInit"));
1659
0
    log_handle(3, fmt_hSession, hSession);
1660
0
    PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1661
0
    PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1662
0
    print_template(pTemplate, ulCount);
1663
0
    nssdbg_start_time(FUNC_C_FINDOBJECTSINIT, &start);
1664
0
    rv = module_functions->C_FindObjectsInit(hSession,
1665
0
                                             pTemplate,
1666
0
                                             ulCount);
1667
0
    nssdbg_finish_time(FUNC_C_FINDOBJECTSINIT, start);
1668
0
    log_rv(rv);
1669
0
    return rv;
1670
0
}
1671
1672
CK_RV
1673
NSSDBGC_FindObjects(
1674
    CK_SESSION_HANDLE hSession,
1675
    CK_OBJECT_HANDLE_PTR phObject,
1676
    CK_ULONG ulMaxObjectCount,
1677
    CK_ULONG_PTR pulObjectCount)
1678
0
{
1679
0
    COMMON_DEFINITIONS;
1680
0
    CK_ULONG i;
1681
1682
0
    PR_LOG(modlog, 1, ("C_FindObjects"));
1683
0
    log_handle(3, fmt_hSession, hSession);
1684
0
    PR_LOG(modlog, 3, (fmt_phObject, phObject));
1685
0
    PR_LOG(modlog, 3, ("  ulMaxObjectCount = %d", ulMaxObjectCount));
1686
0
    PR_LOG(modlog, 3, ("  pulObjectCount = 0x%p", pulObjectCount));
1687
0
    nssdbg_start_time(FUNC_C_FINDOBJECTS, &start);
1688
0
    rv = module_functions->C_FindObjects(hSession,
1689
0
                                         phObject,
1690
0
                                         ulMaxObjectCount,
1691
0
                                         pulObjectCount);
1692
0
    nssdbg_finish_time(FUNC_C_FINDOBJECTS, start);
1693
0
    PR_LOG(modlog, 4, ("  *pulObjectCount = 0x%x", *pulObjectCount));
1694
0
    for (i = 0; i < *pulObjectCount; i++) {
1695
0
        PR_LOG(modlog, 4, ("  phObject[%d] = 0x%x%s", i, phObject[i], phObject[i] ? "" : fmt_invalid_handle));
1696
0
    }
1697
0
    log_rv(rv);
1698
0
    return rv;
1699
0
}
1700
1701
CK_RV
1702
NSSDBGC_FindObjectsFinal(
1703
    CK_SESSION_HANDLE hSession)
1704
0
{
1705
0
    COMMON_DEFINITIONS;
1706
1707
0
    PR_LOG(modlog, 1, ("C_FindObjectsFinal"));
1708
0
    log_handle(3, fmt_hSession, hSession);
1709
0
    nssdbg_start_time(FUNC_C_FINDOBJECTSFINAL, &start);
1710
0
    rv = module_functions->C_FindObjectsFinal(hSession);
1711
0
    nssdbg_finish_time(FUNC_C_FINDOBJECTSFINAL, start);
1712
0
    log_rv(rv);
1713
0
    return rv;
1714
0
}
1715
1716
CK_RV
1717
NSSDBGC_EncryptInit(
1718
    CK_SESSION_HANDLE hSession,
1719
    CK_MECHANISM_PTR pMechanism,
1720
    CK_OBJECT_HANDLE hKey)
1721
0
{
1722
0
    COMMON_DEFINITIONS;
1723
1724
0
    PR_LOG(modlog, 1, ("C_EncryptInit"));
1725
0
    log_handle(3, fmt_hSession, hSession);
1726
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
1727
0
    log_handle(3, fmt_hKey, hKey);
1728
0
    print_mechanism(pMechanism);
1729
0
    nssdbg_start_time(FUNC_C_ENCRYPTINIT, &start);
1730
0
    rv = module_functions->C_EncryptInit(hSession,
1731
0
                                         pMechanism,
1732
0
                                         hKey);
1733
0
    nssdbg_finish_time(FUNC_C_ENCRYPTINIT, start);
1734
0
    log_rv(rv);
1735
0
    return rv;
1736
0
}
1737
1738
CK_RV
1739
NSSDBGC_Encrypt(
1740
    CK_SESSION_HANDLE hSession,
1741
    CK_BYTE_PTR pData,
1742
    CK_ULONG ulDataLen,
1743
    CK_BYTE_PTR pEncryptedData,
1744
    CK_ULONG_PTR pulEncryptedDataLen)
1745
0
{
1746
0
    COMMON_DEFINITIONS;
1747
1748
0
    PR_LOG(modlog, 1, ("C_Encrypt"));
1749
0
    log_handle(3, fmt_hSession, hSession);
1750
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
1751
0
    PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
1752
0
    PR_LOG(modlog, 3, (fmt_pEncryptedData, pEncryptedData));
1753
0
    PR_LOG(modlog, 3, ("  pulEncryptedDataLen = 0x%p", pulEncryptedDataLen));
1754
0
    nssdbg_start_time(FUNC_C_ENCRYPT, &start);
1755
0
    rv = module_functions->C_Encrypt(hSession,
1756
0
                                     pData,
1757
0
                                     ulDataLen,
1758
0
                                     pEncryptedData,
1759
0
                                     pulEncryptedDataLen);
1760
0
    nssdbg_finish_time(FUNC_C_ENCRYPT, start);
1761
0
    PR_LOG(modlog, 4, ("  *pulEncryptedDataLen = 0x%x", *pulEncryptedDataLen));
1762
0
    log_rv(rv);
1763
0
    return rv;
1764
0
}
1765
1766
CK_RV
1767
NSSDBGC_EncryptUpdate(
1768
    CK_SESSION_HANDLE hSession,
1769
    CK_BYTE_PTR pPart,
1770
    CK_ULONG ulPartLen,
1771
    CK_BYTE_PTR pEncryptedPart,
1772
    CK_ULONG_PTR pulEncryptedPartLen)
1773
0
{
1774
0
    COMMON_DEFINITIONS;
1775
1776
0
    PR_LOG(modlog, 1, ("C_EncryptUpdate"));
1777
0
    log_handle(3, fmt_hSession, hSession);
1778
0
    PR_LOG(modlog, 3, (fmt_pPart, pPart));
1779
0
    PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
1780
0
    PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
1781
0
    PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen));
1782
0
    nssdbg_start_time(FUNC_C_ENCRYPTUPDATE, &start);
1783
0
    rv = module_functions->C_EncryptUpdate(hSession,
1784
0
                                           pPart,
1785
0
                                           ulPartLen,
1786
0
                                           pEncryptedPart,
1787
0
                                           pulEncryptedPartLen);
1788
0
    nssdbg_finish_time(FUNC_C_ENCRYPTUPDATE, start);
1789
0
    PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen));
1790
0
    log_rv(rv);
1791
0
    return rv;
1792
0
}
1793
1794
CK_RV
1795
NSSDBGC_EncryptFinal(
1796
    CK_SESSION_HANDLE hSession,
1797
    CK_BYTE_PTR pLastEncryptedPart,
1798
    CK_ULONG_PTR pulLastEncryptedPartLen)
1799
0
{
1800
0
    COMMON_DEFINITIONS;
1801
1802
0
    PR_LOG(modlog, 1, ("C_EncryptFinal"));
1803
0
    log_handle(3, fmt_hSession, hSession);
1804
0
    PR_LOG(modlog, 3, ("  pLastEncryptedPart = 0x%p", pLastEncryptedPart));
1805
0
    PR_LOG(modlog, 3, ("  pulLastEncryptedPartLen = 0x%p", pulLastEncryptedPartLen));
1806
0
    nssdbg_start_time(FUNC_C_ENCRYPTFINAL, &start);
1807
0
    rv = module_functions->C_EncryptFinal(hSession,
1808
0
                                          pLastEncryptedPart,
1809
0
                                          pulLastEncryptedPartLen);
1810
0
    nssdbg_finish_time(FUNC_C_ENCRYPTFINAL, start);
1811
0
    PR_LOG(modlog, 4, ("  *pulLastEncryptedPartLen = 0x%x", *pulLastEncryptedPartLen));
1812
0
    log_rv(rv);
1813
0
    return rv;
1814
0
}
1815
1816
CK_RV
1817
NSSDBGC_DecryptInit(
1818
    CK_SESSION_HANDLE hSession,
1819
    CK_MECHANISM_PTR pMechanism,
1820
    CK_OBJECT_HANDLE hKey)
1821
0
{
1822
0
    COMMON_DEFINITIONS;
1823
1824
0
    PR_LOG(modlog, 1, ("C_DecryptInit"));
1825
0
    log_handle(3, fmt_hSession, hSession);
1826
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
1827
0
    log_handle(3, fmt_hKey, hKey);
1828
0
    print_mechanism(pMechanism);
1829
0
    nssdbg_start_time(FUNC_C_DECRYPTINIT, &start);
1830
0
    rv = module_functions->C_DecryptInit(hSession,
1831
0
                                         pMechanism,
1832
0
                                         hKey);
1833
0
    nssdbg_finish_time(FUNC_C_DECRYPTINIT, start);
1834
0
    log_rv(rv);
1835
0
    return rv;
1836
0
}
1837
1838
CK_RV
1839
NSSDBGC_Decrypt(
1840
    CK_SESSION_HANDLE hSession,
1841
    CK_BYTE_PTR pEncryptedData,
1842
    CK_ULONG ulEncryptedDataLen,
1843
    CK_BYTE_PTR pData,
1844
    CK_ULONG_PTR pulDataLen)
1845
0
{
1846
0
    COMMON_DEFINITIONS;
1847
1848
0
    PR_LOG(modlog, 1, ("C_Decrypt"));
1849
0
    log_handle(3, fmt_hSession, hSession);
1850
0
    PR_LOG(modlog, 3, (fmt_pEncryptedData, pEncryptedData));
1851
0
    PR_LOG(modlog, 3, ("  ulEncryptedDataLen = %d", ulEncryptedDataLen));
1852
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
1853
0
    PR_LOG(modlog, 3, (fmt_pulDataLen, pulDataLen));
1854
0
    nssdbg_start_time(FUNC_C_DECRYPT, &start);
1855
0
    rv = module_functions->C_Decrypt(hSession,
1856
0
                                     pEncryptedData,
1857
0
                                     ulEncryptedDataLen,
1858
0
                                     pData,
1859
0
                                     pulDataLen);
1860
0
    nssdbg_finish_time(FUNC_C_DECRYPT, start);
1861
0
    PR_LOG(modlog, 4, (fmt_spulDataLen, *pulDataLen));
1862
0
    log_rv(rv);
1863
0
    return rv;
1864
0
}
1865
1866
CK_RV
1867
NSSDBGC_DecryptUpdate(
1868
    CK_SESSION_HANDLE hSession,
1869
    CK_BYTE_PTR pEncryptedPart,
1870
    CK_ULONG ulEncryptedPartLen,
1871
    CK_BYTE_PTR pPart,
1872
    CK_ULONG_PTR pulPartLen)
1873
0
{
1874
0
    COMMON_DEFINITIONS;
1875
1876
0
    PR_LOG(modlog, 1, ("C_DecryptUpdate"));
1877
0
    log_handle(3, fmt_hSession, hSession);
1878
0
    PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
1879
0
    PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen));
1880
0
    PR_LOG(modlog, 3, (fmt_pPart, pPart));
1881
0
    PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen));
1882
0
    nssdbg_start_time(FUNC_C_DECRYPTUPDATE, &start);
1883
0
    rv = module_functions->C_DecryptUpdate(hSession,
1884
0
                                           pEncryptedPart,
1885
0
                                           ulEncryptedPartLen,
1886
0
                                           pPart,
1887
0
                                           pulPartLen);
1888
0
    nssdbg_finish_time(FUNC_C_DECRYPTUPDATE, start);
1889
0
    PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen));
1890
0
    log_rv(rv);
1891
0
    return rv;
1892
0
}
1893
1894
CK_RV
1895
NSSDBGC_DecryptFinal(
1896
    CK_SESSION_HANDLE hSession,
1897
    CK_BYTE_PTR pLastPart,
1898
    CK_ULONG_PTR pulLastPartLen)
1899
0
{
1900
0
    COMMON_DEFINITIONS;
1901
1902
0
    PR_LOG(modlog, 1, ("C_DecryptFinal"));
1903
0
    log_handle(3, fmt_hSession, hSession);
1904
0
    PR_LOG(modlog, 3, ("  pLastPart = 0x%p", pLastPart));
1905
0
    PR_LOG(modlog, 3, ("  pulLastPartLen = 0x%p", pulLastPartLen));
1906
0
    nssdbg_start_time(FUNC_C_DECRYPTFINAL, &start);
1907
0
    rv = module_functions->C_DecryptFinal(hSession,
1908
0
                                          pLastPart,
1909
0
                                          pulLastPartLen);
1910
0
    nssdbg_finish_time(FUNC_C_DECRYPTFINAL, start);
1911
0
    PR_LOG(modlog, 4, ("  *pulLastPartLen = 0x%x", *pulLastPartLen));
1912
0
    log_rv(rv);
1913
0
    return rv;
1914
0
}
1915
1916
CK_RV
1917
NSSDBGC_DigestInit(
1918
    CK_SESSION_HANDLE hSession,
1919
    CK_MECHANISM_PTR pMechanism)
1920
0
{
1921
0
    COMMON_DEFINITIONS;
1922
1923
0
    PR_LOG(modlog, 1, ("C_DigestInit"));
1924
0
    log_handle(3, fmt_hSession, hSession);
1925
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
1926
0
    print_mechanism(pMechanism);
1927
0
    nssdbg_start_time(FUNC_C_DIGESTINIT, &start);
1928
0
    rv = module_functions->C_DigestInit(hSession,
1929
0
                                        pMechanism);
1930
0
    nssdbg_finish_time(FUNC_C_DIGESTINIT, start);
1931
0
    log_rv(rv);
1932
0
    return rv;
1933
0
}
1934
1935
CK_RV
1936
NSSDBGC_Digest(
1937
    CK_SESSION_HANDLE hSession,
1938
    CK_BYTE_PTR pData,
1939
    CK_ULONG ulDataLen,
1940
    CK_BYTE_PTR pDigest,
1941
    CK_ULONG_PTR pulDigestLen)
1942
0
{
1943
0
    COMMON_DEFINITIONS;
1944
1945
0
    PR_LOG(modlog, 1, ("C_Digest"));
1946
0
    log_handle(3, fmt_hSession, hSession);
1947
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
1948
0
    PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
1949
0
    PR_LOG(modlog, 3, (fmt_pDigest, pDigest));
1950
0
    PR_LOG(modlog, 3, (fmt_pulDigestLen, pulDigestLen));
1951
0
    nssdbg_start_time(FUNC_C_DIGEST, &start);
1952
0
    rv = module_functions->C_Digest(hSession,
1953
0
                                    pData,
1954
0
                                    ulDataLen,
1955
0
                                    pDigest,
1956
0
                                    pulDigestLen);
1957
0
    nssdbg_finish_time(FUNC_C_DIGEST, start);
1958
0
    PR_LOG(modlog, 4, (fmt_spulDigestLen, *pulDigestLen));
1959
0
    log_rv(rv);
1960
0
    return rv;
1961
0
}
1962
1963
CK_RV
1964
NSSDBGC_DigestUpdate(
1965
    CK_SESSION_HANDLE hSession,
1966
    CK_BYTE_PTR pPart,
1967
    CK_ULONG ulPartLen)
1968
0
{
1969
0
    COMMON_DEFINITIONS;
1970
1971
0
    PR_LOG(modlog, 1, ("C_DigestUpdate"));
1972
0
    log_handle(3, fmt_hSession, hSession);
1973
0
    PR_LOG(modlog, 3, (fmt_pPart, pPart));
1974
0
    PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
1975
0
    nssdbg_start_time(FUNC_C_DIGESTUPDATE, &start);
1976
0
    rv = module_functions->C_DigestUpdate(hSession,
1977
0
                                          pPart,
1978
0
                                          ulPartLen);
1979
0
    nssdbg_finish_time(FUNC_C_DIGESTUPDATE, start);
1980
0
    log_rv(rv);
1981
0
    return rv;
1982
0
}
1983
1984
CK_RV
1985
NSSDBGC_DigestKey(
1986
    CK_SESSION_HANDLE hSession,
1987
    CK_OBJECT_HANDLE hKey)
1988
0
{
1989
0
    COMMON_DEFINITIONS;
1990
1991
0
    PR_LOG(modlog, 1, ("C_DigestKey"));
1992
0
    log_handle(3, fmt_hSession, hSession);
1993
0
    nssdbg_start_time(FUNC_C_DIGESTKEY, &start);
1994
0
    rv = module_functions->C_DigestKey(hSession,
1995
0
                                       hKey);
1996
0
    nssdbg_finish_time(FUNC_C_DIGESTKEY, start);
1997
0
    log_rv(rv);
1998
0
    return rv;
1999
0
}
2000
2001
CK_RV
2002
NSSDBGC_DigestFinal(
2003
    CK_SESSION_HANDLE hSession,
2004
    CK_BYTE_PTR pDigest,
2005
    CK_ULONG_PTR pulDigestLen)
2006
0
{
2007
0
    COMMON_DEFINITIONS;
2008
2009
0
    PR_LOG(modlog, 1, ("C_DigestFinal"));
2010
0
    log_handle(3, fmt_hSession, hSession);
2011
0
    PR_LOG(modlog, 3, (fmt_pDigest, pDigest));
2012
0
    PR_LOG(modlog, 3, (fmt_pulDigestLen, pulDigestLen));
2013
0
    nssdbg_start_time(FUNC_C_DIGESTFINAL, &start);
2014
0
    rv = module_functions->C_DigestFinal(hSession,
2015
0
                                         pDigest,
2016
0
                                         pulDigestLen);
2017
0
    nssdbg_finish_time(FUNC_C_DIGESTFINAL, start);
2018
0
    PR_LOG(modlog, 4, (fmt_spulDigestLen, *pulDigestLen));
2019
0
    log_rv(rv);
2020
0
    return rv;
2021
0
}
2022
2023
CK_RV
2024
NSSDBGC_SignInit(
2025
    CK_SESSION_HANDLE hSession,
2026
    CK_MECHANISM_PTR pMechanism,
2027
    CK_OBJECT_HANDLE hKey)
2028
0
{
2029
0
    COMMON_DEFINITIONS;
2030
2031
0
    PR_LOG(modlog, 1, ("C_SignInit"));
2032
0
    log_handle(3, fmt_hSession, hSession);
2033
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2034
0
    log_handle(3, fmt_hKey, hKey);
2035
0
    print_mechanism(pMechanism);
2036
0
    nssdbg_start_time(FUNC_C_SIGNINIT, &start);
2037
0
    rv = module_functions->C_SignInit(hSession,
2038
0
                                      pMechanism,
2039
0
                                      hKey);
2040
0
    nssdbg_finish_time(FUNC_C_SIGNINIT, start);
2041
0
    log_rv(rv);
2042
0
    return rv;
2043
0
}
2044
2045
CK_RV
2046
NSSDBGC_Sign(
2047
    CK_SESSION_HANDLE hSession,
2048
    CK_BYTE_PTR pData,
2049
    CK_ULONG ulDataLen,
2050
    CK_BYTE_PTR pSignature,
2051
    CK_ULONG_PTR pulSignatureLen)
2052
0
{
2053
0
    COMMON_DEFINITIONS;
2054
2055
0
    PR_LOG(modlog, 1, ("C_Sign"));
2056
0
    log_handle(3, fmt_hSession, hSession);
2057
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
2058
0
    PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
2059
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2060
0
    PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen));
2061
0
    nssdbg_start_time(FUNC_C_SIGN, &start);
2062
0
    rv = module_functions->C_Sign(hSession,
2063
0
                                  pData,
2064
0
                                  ulDataLen,
2065
0
                                  pSignature,
2066
0
                                  pulSignatureLen);
2067
0
    nssdbg_finish_time(FUNC_C_SIGN, start);
2068
0
    PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen));
2069
0
    log_rv(rv);
2070
0
    return rv;
2071
0
}
2072
2073
CK_RV
2074
NSSDBGC_SignUpdate(
2075
    CK_SESSION_HANDLE hSession,
2076
    CK_BYTE_PTR pPart,
2077
    CK_ULONG ulPartLen)
2078
0
{
2079
0
    COMMON_DEFINITIONS;
2080
2081
0
    PR_LOG(modlog, 1, ("C_SignUpdate"));
2082
0
    log_handle(3, fmt_hSession, hSession);
2083
0
    PR_LOG(modlog, 3, (fmt_pPart, pPart));
2084
0
    PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
2085
0
    nssdbg_start_time(FUNC_C_SIGNUPDATE, &start);
2086
0
    rv = module_functions->C_SignUpdate(hSession,
2087
0
                                        pPart,
2088
0
                                        ulPartLen);
2089
0
    nssdbg_finish_time(FUNC_C_SIGNUPDATE, start);
2090
0
    log_rv(rv);
2091
0
    return rv;
2092
0
}
2093
2094
CK_RV
2095
NSSDBGC_SignFinal(
2096
    CK_SESSION_HANDLE hSession,
2097
    CK_BYTE_PTR pSignature,
2098
    CK_ULONG_PTR pulSignatureLen)
2099
0
{
2100
0
    COMMON_DEFINITIONS;
2101
2102
0
    PR_LOG(modlog, 1, ("C_SignFinal"));
2103
0
    log_handle(3, fmt_hSession, hSession);
2104
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2105
0
    PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen));
2106
0
    nssdbg_start_time(FUNC_C_SIGNFINAL, &start);
2107
0
    rv = module_functions->C_SignFinal(hSession,
2108
0
                                       pSignature,
2109
0
                                       pulSignatureLen);
2110
0
    nssdbg_finish_time(FUNC_C_SIGNFINAL, start);
2111
0
    PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen));
2112
0
    log_rv(rv);
2113
0
    return rv;
2114
0
}
2115
2116
CK_RV
2117
NSSDBGC_SignRecoverInit(
2118
    CK_SESSION_HANDLE hSession,
2119
    CK_MECHANISM_PTR pMechanism,
2120
    CK_OBJECT_HANDLE hKey)
2121
0
{
2122
0
    COMMON_DEFINITIONS;
2123
2124
0
    PR_LOG(modlog, 1, ("C_SignRecoverInit"));
2125
0
    log_handle(3, fmt_hSession, hSession);
2126
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2127
0
    log_handle(3, fmt_hKey, hKey);
2128
0
    print_mechanism(pMechanism);
2129
0
    nssdbg_start_time(FUNC_C_SIGNRECOVERINIT, &start);
2130
0
    rv = module_functions->C_SignRecoverInit(hSession,
2131
0
                                             pMechanism,
2132
0
                                             hKey);
2133
0
    nssdbg_finish_time(FUNC_C_SIGNRECOVERINIT, start);
2134
0
    log_rv(rv);
2135
0
    return rv;
2136
0
}
2137
2138
CK_RV
2139
NSSDBGC_SignRecover(
2140
    CK_SESSION_HANDLE hSession,
2141
    CK_BYTE_PTR pData,
2142
    CK_ULONG ulDataLen,
2143
    CK_BYTE_PTR pSignature,
2144
    CK_ULONG_PTR pulSignatureLen)
2145
0
{
2146
0
    COMMON_DEFINITIONS;
2147
2148
0
    PR_LOG(modlog, 1, ("C_SignRecover"));
2149
0
    log_handle(3, fmt_hSession, hSession);
2150
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
2151
0
    PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
2152
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2153
0
    PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen));
2154
0
    nssdbg_start_time(FUNC_C_SIGNRECOVER, &start);
2155
0
    rv = module_functions->C_SignRecover(hSession,
2156
0
                                         pData,
2157
0
                                         ulDataLen,
2158
0
                                         pSignature,
2159
0
                                         pulSignatureLen);
2160
0
    nssdbg_finish_time(FUNC_C_SIGNRECOVER, start);
2161
0
    PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen));
2162
0
    log_rv(rv);
2163
0
    return rv;
2164
0
}
2165
2166
CK_RV
2167
NSSDBGC_VerifyInit(
2168
    CK_SESSION_HANDLE hSession,
2169
    CK_MECHANISM_PTR pMechanism,
2170
    CK_OBJECT_HANDLE hKey)
2171
0
{
2172
0
    COMMON_DEFINITIONS;
2173
2174
0
    PR_LOG(modlog, 1, ("C_VerifyInit"));
2175
0
    log_handle(3, fmt_hSession, hSession);
2176
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2177
0
    log_handle(3, fmt_hKey, hKey);
2178
0
    print_mechanism(pMechanism);
2179
0
    nssdbg_start_time(FUNC_C_VERIFYINIT, &start);
2180
0
    rv = module_functions->C_VerifyInit(hSession,
2181
0
                                        pMechanism,
2182
0
                                        hKey);
2183
0
    nssdbg_finish_time(FUNC_C_VERIFYINIT, start);
2184
0
    log_rv(rv);
2185
0
    return rv;
2186
0
}
2187
2188
CK_RV
2189
NSSDBGC_Verify(
2190
    CK_SESSION_HANDLE hSession,
2191
    CK_BYTE_PTR pData,
2192
    CK_ULONG ulDataLen,
2193
    CK_BYTE_PTR pSignature,
2194
    CK_ULONG ulSignatureLen)
2195
0
{
2196
0
    COMMON_DEFINITIONS;
2197
2198
0
    PR_LOG(modlog, 1, ("C_Verify"));
2199
0
    log_handle(3, fmt_hSession, hSession);
2200
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
2201
0
    PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
2202
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2203
0
    PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen));
2204
0
    nssdbg_start_time(FUNC_C_VERIFY, &start);
2205
0
    rv = module_functions->C_Verify(hSession,
2206
0
                                    pData,
2207
0
                                    ulDataLen,
2208
0
                                    pSignature,
2209
0
                                    ulSignatureLen);
2210
0
    nssdbg_finish_time(FUNC_C_VERIFY, start);
2211
0
    log_rv(rv);
2212
0
    return rv;
2213
0
}
2214
2215
CK_RV
2216
NSSDBGC_VerifyUpdate(
2217
    CK_SESSION_HANDLE hSession,
2218
    CK_BYTE_PTR pPart,
2219
    CK_ULONG ulPartLen)
2220
0
{
2221
0
    COMMON_DEFINITIONS;
2222
2223
0
    PR_LOG(modlog, 1, ("C_VerifyUpdate"));
2224
0
    log_handle(3, fmt_hSession, hSession);
2225
0
    PR_LOG(modlog, 3, (fmt_pPart, pPart));
2226
0
    PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
2227
0
    nssdbg_start_time(FUNC_C_VERIFYUPDATE, &start);
2228
0
    rv = module_functions->C_VerifyUpdate(hSession,
2229
0
                                          pPart,
2230
0
                                          ulPartLen);
2231
0
    nssdbg_finish_time(FUNC_C_VERIFYUPDATE, start);
2232
0
    log_rv(rv);
2233
0
    return rv;
2234
0
}
2235
2236
CK_RV
2237
NSSDBGC_VerifyFinal(
2238
    CK_SESSION_HANDLE hSession,
2239
    CK_BYTE_PTR pSignature,
2240
    CK_ULONG ulSignatureLen)
2241
0
{
2242
0
    COMMON_DEFINITIONS;
2243
2244
0
    PR_LOG(modlog, 1, ("C_VerifyFinal"));
2245
0
    log_handle(3, fmt_hSession, hSession);
2246
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2247
0
    PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen));
2248
0
    nssdbg_start_time(FUNC_C_VERIFYFINAL, &start);
2249
0
    rv = module_functions->C_VerifyFinal(hSession,
2250
0
                                         pSignature,
2251
0
                                         ulSignatureLen);
2252
0
    nssdbg_finish_time(FUNC_C_VERIFYFINAL, start);
2253
0
    log_rv(rv);
2254
0
    return rv;
2255
0
}
2256
2257
CK_RV
2258
NSSDBGC_VerifyRecoverInit(
2259
    CK_SESSION_HANDLE hSession,
2260
    CK_MECHANISM_PTR pMechanism,
2261
    CK_OBJECT_HANDLE hKey)
2262
0
{
2263
0
    COMMON_DEFINITIONS;
2264
2265
0
    PR_LOG(modlog, 1, ("C_VerifyRecoverInit"));
2266
0
    log_handle(3, fmt_hSession, hSession);
2267
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2268
0
    log_handle(3, fmt_hKey, hKey);
2269
0
    print_mechanism(pMechanism);
2270
0
    nssdbg_start_time(FUNC_C_VERIFYRECOVERINIT, &start);
2271
0
    rv = module_functions->C_VerifyRecoverInit(hSession,
2272
0
                                               pMechanism,
2273
0
                                               hKey);
2274
0
    nssdbg_finish_time(FUNC_C_VERIFYRECOVERINIT, start);
2275
0
    log_rv(rv);
2276
0
    return rv;
2277
0
}
2278
2279
CK_RV
2280
NSSDBGC_VerifyRecover(
2281
    CK_SESSION_HANDLE hSession,
2282
    CK_BYTE_PTR pSignature,
2283
    CK_ULONG ulSignatureLen,
2284
    CK_BYTE_PTR pData,
2285
    CK_ULONG_PTR pulDataLen)
2286
0
{
2287
0
    COMMON_DEFINITIONS;
2288
2289
0
    PR_LOG(modlog, 1, ("C_VerifyRecover"));
2290
0
    log_handle(3, fmt_hSession, hSession);
2291
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2292
0
    PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen));
2293
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
2294
0
    PR_LOG(modlog, 3, (fmt_pulDataLen, pulDataLen));
2295
0
    nssdbg_start_time(FUNC_C_VERIFYRECOVER, &start);
2296
0
    rv = module_functions->C_VerifyRecover(hSession,
2297
0
                                           pSignature,
2298
0
                                           ulSignatureLen,
2299
0
                                           pData,
2300
0
                                           pulDataLen);
2301
0
    nssdbg_finish_time(FUNC_C_VERIFYRECOVER, start);
2302
0
    PR_LOG(modlog, 4, (fmt_spulDataLen, *pulDataLen));
2303
0
    log_rv(rv);
2304
0
    return rv;
2305
0
}
2306
2307
CK_RV
2308
NSSDBGC_DigestEncryptUpdate(
2309
    CK_SESSION_HANDLE hSession,
2310
    CK_BYTE_PTR pPart,
2311
    CK_ULONG ulPartLen,
2312
    CK_BYTE_PTR pEncryptedPart,
2313
    CK_ULONG_PTR pulEncryptedPartLen)
2314
0
{
2315
0
    COMMON_DEFINITIONS;
2316
2317
0
    PR_LOG(modlog, 1, ("C_DigestEncryptUpdate"));
2318
0
    log_handle(3, fmt_hSession, hSession);
2319
0
    PR_LOG(modlog, 3, (fmt_pPart, pPart));
2320
0
    PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
2321
0
    PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
2322
0
    PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen));
2323
0
    nssdbg_start_time(FUNC_C_DIGESTENCRYPTUPDATE, &start);
2324
0
    rv = module_functions->C_DigestEncryptUpdate(hSession,
2325
0
                                                 pPart,
2326
0
                                                 ulPartLen,
2327
0
                                                 pEncryptedPart,
2328
0
                                                 pulEncryptedPartLen);
2329
0
    nssdbg_finish_time(FUNC_C_DIGESTENCRYPTUPDATE, start);
2330
0
    PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen));
2331
0
    log_rv(rv);
2332
0
    return rv;
2333
0
}
2334
2335
CK_RV
2336
NSSDBGC_DecryptDigestUpdate(
2337
    CK_SESSION_HANDLE hSession,
2338
    CK_BYTE_PTR pEncryptedPart,
2339
    CK_ULONG ulEncryptedPartLen,
2340
    CK_BYTE_PTR pPart,
2341
    CK_ULONG_PTR pulPartLen)
2342
0
{
2343
0
    COMMON_DEFINITIONS;
2344
2345
0
    PR_LOG(modlog, 1, ("C_DecryptDigestUpdate"));
2346
0
    log_handle(3, fmt_hSession, hSession);
2347
0
    PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
2348
0
    PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen));
2349
0
    PR_LOG(modlog, 3, (fmt_pPart, pPart));
2350
0
    PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen));
2351
0
    nssdbg_start_time(FUNC_C_DECRYPTDIGESTUPDATE, &start);
2352
0
    rv = module_functions->C_DecryptDigestUpdate(hSession,
2353
0
                                                 pEncryptedPart,
2354
0
                                                 ulEncryptedPartLen,
2355
0
                                                 pPart,
2356
0
                                                 pulPartLen);
2357
0
    nssdbg_finish_time(FUNC_C_DECRYPTDIGESTUPDATE, start);
2358
0
    PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen));
2359
0
    log_rv(rv);
2360
0
    return rv;
2361
0
}
2362
2363
CK_RV
2364
NSSDBGC_SignEncryptUpdate(
2365
    CK_SESSION_HANDLE hSession,
2366
    CK_BYTE_PTR pPart,
2367
    CK_ULONG ulPartLen,
2368
    CK_BYTE_PTR pEncryptedPart,
2369
    CK_ULONG_PTR pulEncryptedPartLen)
2370
0
{
2371
0
    COMMON_DEFINITIONS;
2372
2373
0
    PR_LOG(modlog, 1, ("C_SignEncryptUpdate"));
2374
0
    log_handle(3, fmt_hSession, hSession);
2375
0
    PR_LOG(modlog, 3, (fmt_pPart, pPart));
2376
0
    PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
2377
0
    PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
2378
0
    PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen));
2379
0
    nssdbg_start_time(FUNC_C_SIGNENCRYPTUPDATE, &start);
2380
0
    rv = module_functions->C_SignEncryptUpdate(hSession,
2381
0
                                               pPart,
2382
0
                                               ulPartLen,
2383
0
                                               pEncryptedPart,
2384
0
                                               pulEncryptedPartLen);
2385
0
    nssdbg_finish_time(FUNC_C_SIGNENCRYPTUPDATE, start);
2386
0
    PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen));
2387
0
    log_rv(rv);
2388
0
    return rv;
2389
0
}
2390
2391
CK_RV
2392
NSSDBGC_DecryptVerifyUpdate(
2393
    CK_SESSION_HANDLE hSession,
2394
    CK_BYTE_PTR pEncryptedPart,
2395
    CK_ULONG ulEncryptedPartLen,
2396
    CK_BYTE_PTR pPart,
2397
    CK_ULONG_PTR pulPartLen)
2398
0
{
2399
0
    COMMON_DEFINITIONS;
2400
2401
0
    PR_LOG(modlog, 1, ("C_DecryptVerifyUpdate"));
2402
0
    log_handle(3, fmt_hSession, hSession);
2403
0
    PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
2404
0
    PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen));
2405
0
    PR_LOG(modlog, 3, (fmt_pPart, pPart));
2406
0
    PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen));
2407
0
    nssdbg_start_time(FUNC_C_DECRYPTVERIFYUPDATE, &start);
2408
0
    rv = module_functions->C_DecryptVerifyUpdate(hSession,
2409
0
                                                 pEncryptedPart,
2410
0
                                                 ulEncryptedPartLen,
2411
0
                                                 pPart,
2412
0
                                                 pulPartLen);
2413
0
    nssdbg_finish_time(FUNC_C_DECRYPTVERIFYUPDATE, start);
2414
0
    PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen));
2415
0
    log_rv(rv);
2416
0
    return rv;
2417
0
}
2418
2419
CK_RV
2420
NSSDBGC_GenerateKey(
2421
    CK_SESSION_HANDLE hSession,
2422
    CK_MECHANISM_PTR pMechanism,
2423
    CK_ATTRIBUTE_PTR pTemplate,
2424
    CK_ULONG ulCount,
2425
    CK_OBJECT_HANDLE_PTR phKey)
2426
0
{
2427
0
    COMMON_DEFINITIONS;
2428
2429
0
    PR_LOG(modlog, 1, ("C_GenerateKey"));
2430
0
    log_handle(3, fmt_hSession, hSession);
2431
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2432
0
    PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
2433
0
    PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
2434
0
    PR_LOG(modlog, 3, (fmt_phKey, phKey));
2435
0
    print_template(pTemplate, ulCount);
2436
0
    print_mechanism(pMechanism);
2437
0
    nssdbg_start_time(FUNC_C_GENERATEKEY, &start);
2438
0
    rv = module_functions->C_GenerateKey(hSession,
2439
0
                                         pMechanism,
2440
0
                                         pTemplate,
2441
0
                                         ulCount,
2442
0
                                         phKey);
2443
0
    nssdbg_finish_time(FUNC_C_GENERATEKEY, start);
2444
0
    log_handle(4, fmt_sphKey, *phKey);
2445
0
    log_rv(rv);
2446
0
    return rv;
2447
0
}
2448
2449
CK_RV
2450
NSSDBGC_GenerateKeyPair(
2451
    CK_SESSION_HANDLE hSession,
2452
    CK_MECHANISM_PTR pMechanism,
2453
    CK_ATTRIBUTE_PTR pPublicKeyTemplate,
2454
    CK_ULONG ulPublicKeyAttributeCount,
2455
    CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
2456
    CK_ULONG ulPrivateKeyAttributeCount,
2457
    CK_OBJECT_HANDLE_PTR phPublicKey,
2458
    CK_OBJECT_HANDLE_PTR phPrivateKey)
2459
0
{
2460
0
    COMMON_DEFINITIONS;
2461
2462
0
    PR_LOG(modlog, 1, ("C_GenerateKeyPair"));
2463
0
    log_handle(3, fmt_hSession, hSession);
2464
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2465
0
    PR_LOG(modlog, 3, ("  pPublicKeyTemplate = 0x%p", pPublicKeyTemplate));
2466
0
    PR_LOG(modlog, 3, ("  ulPublicKeyAttributeCount = %d", ulPublicKeyAttributeCount));
2467
0
    PR_LOG(modlog, 3, ("  pPrivateKeyTemplate = 0x%p", pPrivateKeyTemplate));
2468
0
    PR_LOG(modlog, 3, ("  ulPrivateKeyAttributeCount = %d", ulPrivateKeyAttributeCount));
2469
0
    PR_LOG(modlog, 3, ("  phPublicKey = 0x%p", phPublicKey));
2470
0
    print_template(pPublicKeyTemplate, ulPublicKeyAttributeCount);
2471
0
    PR_LOG(modlog, 3, ("  phPrivateKey = 0x%p", phPrivateKey));
2472
0
    print_template(pPrivateKeyTemplate, ulPrivateKeyAttributeCount);
2473
0
    print_mechanism(pMechanism);
2474
0
    nssdbg_start_time(FUNC_C_GENERATEKEYPAIR, &start);
2475
0
    rv = module_functions->C_GenerateKeyPair(hSession,
2476
0
                                             pMechanism,
2477
0
                                             pPublicKeyTemplate,
2478
0
                                             ulPublicKeyAttributeCount,
2479
0
                                             pPrivateKeyTemplate,
2480
0
                                             ulPrivateKeyAttributeCount,
2481
0
                                             phPublicKey,
2482
0
                                             phPrivateKey);
2483
0
    nssdbg_finish_time(FUNC_C_GENERATEKEYPAIR, start);
2484
0
    log_handle(4, "  *phPublicKey = 0x%x", *phPublicKey);
2485
0
    log_handle(4, "  *phPrivateKey = 0x%x", *phPrivateKey);
2486
0
    log_rv(rv);
2487
0
    return rv;
2488
0
}
2489
2490
CK_RV
2491
NSSDBGC_WrapKey(
2492
    CK_SESSION_HANDLE hSession,
2493
    CK_MECHANISM_PTR pMechanism,
2494
    CK_OBJECT_HANDLE hWrappingKey,
2495
    CK_OBJECT_HANDLE hKey,
2496
    CK_BYTE_PTR pWrappedKey,
2497
    CK_ULONG_PTR pulWrappedKeyLen)
2498
0
{
2499
0
    COMMON_DEFINITIONS;
2500
2501
0
    PR_LOG(modlog, 1, ("C_WrapKey"));
2502
0
    log_handle(3, fmt_hSession, hSession);
2503
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2504
0
    log_handle(3, "  hWrappingKey = 0x%x", hWrappingKey);
2505
0
    log_handle(3, fmt_hKey, hKey);
2506
0
    PR_LOG(modlog, 3, (fmt_pWrappedKey, pWrappedKey));
2507
0
    PR_LOG(modlog, 3, ("  pulWrappedKeyLen = 0x%p", pulWrappedKeyLen));
2508
0
    print_mechanism(pMechanism);
2509
0
    nssdbg_start_time(FUNC_C_WRAPKEY, &start);
2510
0
    rv = module_functions->C_WrapKey(hSession,
2511
0
                                     pMechanism,
2512
0
                                     hWrappingKey,
2513
0
                                     hKey,
2514
0
                                     pWrappedKey,
2515
0
                                     pulWrappedKeyLen);
2516
0
    nssdbg_finish_time(FUNC_C_WRAPKEY, start);
2517
0
    PR_LOG(modlog, 4, ("  *pulWrappedKeyLen = 0x%x", *pulWrappedKeyLen));
2518
0
    log_rv(rv);
2519
0
    return rv;
2520
0
}
2521
2522
CK_RV
2523
NSSDBGC_UnwrapKey(
2524
    CK_SESSION_HANDLE hSession,
2525
    CK_MECHANISM_PTR pMechanism,
2526
    CK_OBJECT_HANDLE hUnwrappingKey,
2527
    CK_BYTE_PTR pWrappedKey,
2528
    CK_ULONG ulWrappedKeyLen,
2529
    CK_ATTRIBUTE_PTR pTemplate,
2530
    CK_ULONG ulAttributeCount,
2531
    CK_OBJECT_HANDLE_PTR phKey)
2532
0
{
2533
0
    COMMON_DEFINITIONS;
2534
2535
0
    PR_LOG(modlog, 1, ("C_UnwrapKey"));
2536
0
    log_handle(3, fmt_hSession, hSession);
2537
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2538
0
    log_handle(3, "  hUnwrappingKey = 0x%x", hUnwrappingKey);
2539
0
    PR_LOG(modlog, 3, (fmt_pWrappedKey, pWrappedKey));
2540
0
    PR_LOG(modlog, 3, ("  ulWrappedKeyLen = %d", ulWrappedKeyLen));
2541
0
    PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
2542
0
    PR_LOG(modlog, 3, (fmt_ulAttributeCount, ulAttributeCount));
2543
0
    PR_LOG(modlog, 3, (fmt_phKey, phKey));
2544
0
    print_template(pTemplate, ulAttributeCount);
2545
0
    print_mechanism(pMechanism);
2546
0
    nssdbg_start_time(FUNC_C_UNWRAPKEY, &start);
2547
0
    rv = module_functions->C_UnwrapKey(hSession,
2548
0
                                       pMechanism,
2549
0
                                       hUnwrappingKey,
2550
0
                                       pWrappedKey,
2551
0
                                       ulWrappedKeyLen,
2552
0
                                       pTemplate,
2553
0
                                       ulAttributeCount,
2554
0
                                       phKey);
2555
0
    nssdbg_finish_time(FUNC_C_UNWRAPKEY, start);
2556
0
    log_handle(4, fmt_sphKey, *phKey);
2557
0
    log_rv(rv);
2558
0
    return rv;
2559
0
}
2560
2561
CK_RV
2562
NSSDBGC_DeriveKey(
2563
    CK_SESSION_HANDLE hSession,
2564
    CK_MECHANISM_PTR pMechanism,
2565
    CK_OBJECT_HANDLE hBaseKey,
2566
    CK_ATTRIBUTE_PTR pTemplate,
2567
    CK_ULONG ulAttributeCount,
2568
    CK_OBJECT_HANDLE_PTR phKey)
2569
0
{
2570
0
    COMMON_DEFINITIONS;
2571
2572
0
    PR_LOG(modlog, 1, ("C_DeriveKey"));
2573
0
    log_handle(3, fmt_hSession, hSession);
2574
0
    PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2575
0
    log_handle(3, "  hBaseKey = 0x%x", hBaseKey);
2576
0
    PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
2577
0
    PR_LOG(modlog, 3, (fmt_ulAttributeCount, ulAttributeCount));
2578
0
    PR_LOG(modlog, 3, (fmt_phKey, phKey));
2579
0
    print_template(pTemplate, ulAttributeCount);
2580
0
    print_mechanism(pMechanism);
2581
0
    nssdbg_start_time(FUNC_C_DERIVEKEY, &start);
2582
0
    rv = module_functions->C_DeriveKey(hSession,
2583
0
                                       pMechanism,
2584
0
                                       hBaseKey,
2585
0
                                       pTemplate,
2586
0
                                       ulAttributeCount,
2587
0
                                       phKey);
2588
0
    nssdbg_finish_time(FUNC_C_DERIVEKEY, start);
2589
0
    log_handle(4, fmt_sphKey, *phKey);
2590
0
    log_rv(rv);
2591
0
    return rv;
2592
0
}
2593
2594
CK_RV
2595
NSSDBGC_SeedRandom(
2596
    CK_SESSION_HANDLE hSession,
2597
    CK_BYTE_PTR pSeed,
2598
    CK_ULONG ulSeedLen)
2599
0
{
2600
0
    COMMON_DEFINITIONS;
2601
2602
0
    PR_LOG(modlog, 1, ("C_SeedRandom"));
2603
0
    log_handle(3, fmt_hSession, hSession);
2604
0
    PR_LOG(modlog, 3, ("  pSeed = 0x%p", pSeed));
2605
0
    PR_LOG(modlog, 3, ("  ulSeedLen = %d", ulSeedLen));
2606
0
    nssdbg_start_time(FUNC_C_SEEDRANDOM, &start);
2607
0
    rv = module_functions->C_SeedRandom(hSession,
2608
0
                                        pSeed,
2609
0
                                        ulSeedLen);
2610
0
    nssdbg_finish_time(FUNC_C_SEEDRANDOM, start);
2611
0
    log_rv(rv);
2612
0
    return rv;
2613
0
}
2614
2615
CK_RV
2616
NSSDBGC_GenerateRandom(
2617
    CK_SESSION_HANDLE hSession,
2618
    CK_BYTE_PTR RandomData,
2619
    CK_ULONG ulRandomLen)
2620
0
{
2621
0
    COMMON_DEFINITIONS;
2622
2623
0
    PR_LOG(modlog, 1, ("C_GenerateRandom"));
2624
0
    log_handle(3, fmt_hSession, hSession);
2625
0
    PR_LOG(modlog, 3, ("  RandomData = 0x%p", RandomData));
2626
0
    PR_LOG(modlog, 3, ("  ulRandomLen = %d", ulRandomLen));
2627
0
    nssdbg_start_time(FUNC_C_GENERATERANDOM, &start);
2628
0
    rv = module_functions->C_GenerateRandom(hSession,
2629
0
                                            RandomData,
2630
0
                                            ulRandomLen);
2631
0
    nssdbg_finish_time(FUNC_C_GENERATERANDOM, start);
2632
0
    log_rv(rv);
2633
0
    return rv;
2634
0
}
2635
2636
CK_RV
2637
NSSDBGC_GetFunctionStatus(
2638
    CK_SESSION_HANDLE hSession)
2639
0
{
2640
0
    COMMON_DEFINITIONS;
2641
2642
0
    PR_LOG(modlog, 1, ("C_GetFunctionStatus"));
2643
0
    log_handle(3, fmt_hSession, hSession);
2644
0
    nssdbg_start_time(FUNC_C_GETFUNCTIONSTATUS, &start);
2645
0
    rv = module_functions->C_GetFunctionStatus(hSession);
2646
0
    nssdbg_finish_time(FUNC_C_GETFUNCTIONSTATUS, start);
2647
0
    log_rv(rv);
2648
0
    return rv;
2649
0
}
2650
2651
CK_RV
2652
NSSDBGC_CancelFunction(
2653
    CK_SESSION_HANDLE hSession)
2654
0
{
2655
0
    COMMON_DEFINITIONS;
2656
2657
0
    PR_LOG(modlog, 1, ("C_CancelFunction"));
2658
0
    log_handle(3, fmt_hSession, hSession);
2659
0
    nssdbg_start_time(FUNC_C_CANCELFUNCTION, &start);
2660
0
    rv = module_functions->C_CancelFunction(hSession);
2661
0
    nssdbg_finish_time(FUNC_C_CANCELFUNCTION, start);
2662
0
    log_rv(rv);
2663
0
    return rv;
2664
0
}
2665
2666
CK_RV
2667
NSSDBGC_WaitForSlotEvent(
2668
    CK_FLAGS flags,
2669
    CK_SLOT_ID_PTR pSlot,
2670
    CK_VOID_PTR pRserved)
2671
0
{
2672
0
    COMMON_DEFINITIONS;
2673
2674
0
    PR_LOG(modlog, 1, ("C_WaitForSlotEvent"));
2675
0
    PR_LOG(modlog, 3, (fmt_flags, flags));
2676
0
    PR_LOG(modlog, 3, ("  pSlot = 0x%p", pSlot));
2677
0
    PR_LOG(modlog, 3, ("  pRserved = 0x%p", pRserved));
2678
0
    nssdbg_start_time(FUNC_C_WAITFORSLOTEVENT, &start);
2679
0
    rv = module_functions->C_WaitForSlotEvent(flags,
2680
0
                                              pSlot,
2681
0
                                              pRserved);
2682
0
    nssdbg_finish_time(FUNC_C_WAITFORSLOTEVENT, start);
2683
0
    log_rv(rv);
2684
0
    return rv;
2685
0
}
2686
2687
CK_RV
2688
NSSDBGC_GetInterfaceList(CK_INTERFACE_PTR interfaces,
2689
                         CK_ULONG_PTR pulCount)
2690
0
{
2691
0
    COMMON_DEFINITIONS;
2692
0
    PR_LOG(modlog, 1, ("C_GetInterfaceList"));
2693
0
    PR_LOG(modlog, 3, ("  interfaces = 0x%p", interfaces));
2694
0
    PR_LOG(modlog, 3, ("  pulCount = %d", pulCount));
2695
0
    nssdbg_start_time(FUNC_C_GETINTERFACELIST, &start);
2696
0
    rv = module_functions->C_GetInterfaceList(interfaces,
2697
0
                                              pulCount);
2698
0
    nssdbg_finish_time(FUNC_C_GETINTERFACELIST, start);
2699
0
    log_rv(rv);
2700
0
    return rv;
2701
0
}
2702
2703
CK_RV
2704
NSSDBGC_GetInterface(CK_UTF8CHAR_PTR pInterfaceName,
2705
                     CK_VERSION_PTR pVersion,
2706
                     CK_INTERFACE_PTR_PTR ppInterface,
2707
                     CK_FLAGS flags)
2708
0
{
2709
0
    COMMON_DEFINITIONS;
2710
0
    PR_LOG(modlog, 1, ("C_GetInterface"));
2711
0
    PR_LOG(modlog, 3, ("  pInterfaceName = 0x%p", pInterfaceName));
2712
0
    PR_LOG(modlog, 3, ("  pVersion = 0x%p", pVersion));
2713
0
    PR_LOG(modlog, 3, ("  ppInterface = 0x%p", ppInterface));
2714
0
    PR_LOG(modlog, 3, (fmt_flags, flags));
2715
0
    nssdbg_start_time(FUNC_C_GETINTERFACE, &start);
2716
0
    rv = module_functions->C_GetInterface(pInterfaceName,
2717
0
                                          pVersion,
2718
0
                                          ppInterface,
2719
0
                                          flags);
2720
0
    nssdbg_finish_time(FUNC_C_GETINTERFACE, start);
2721
0
    log_rv(rv);
2722
0
    return rv;
2723
0
}
2724
2725
CK_RV
2726
NSSDBGC_LoginUser(CK_SESSION_HANDLE hSession,
2727
                  CK_USER_TYPE userType,
2728
                  CK_CHAR_PTR pPin,
2729
                  CK_ULONG ulPinLen,
2730
                  CK_UTF8CHAR_PTR pUsername,
2731
                  CK_ULONG ulUsernameLen)
2732
0
{
2733
0
    COMMON_DEFINITIONS;
2734
0
    PR_LOG(modlog, 1, ("C_LoginUser"));
2735
0
    log_handle(3, fmt_hSession, hSession);
2736
0
    PR_LOG(modlog, 3, ("  userType = 0x%x", userType));
2737
0
    PR_LOG(modlog, 3, (fmt_pPin, pPin));
2738
0
    PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
2739
0
    PR_LOG(modlog, 3, ("  pUsername = 0x%p", pUsername));
2740
0
    PR_LOG(modlog, 3, ("  ulUsernameLen = %d", ulUsernameLen));
2741
0
    nssdbg_start_time(FUNC_C_LOGINUSER, &start);
2742
0
    rv = module_functions->C_LoginUser(hSession,
2743
0
                                       userType,
2744
0
                                       pPin,
2745
0
                                       ulPinLen,
2746
0
                                       pUsername,
2747
0
                                       ulUsernameLen);
2748
0
    nssdbg_finish_time(FUNC_C_LOGINUSER, start);
2749
0
    log_rv(rv);
2750
0
    return rv;
2751
0
}
2752
2753
CK_RV
2754
NSSDBGC_SessionCancel(CK_SESSION_HANDLE hSession,
2755
                      CK_FLAGS flags)
2756
0
{
2757
0
    COMMON_DEFINITIONS;
2758
0
    PR_LOG(modlog, 1, ("C_SessionCancel"));
2759
0
    log_handle(3, fmt_hSession, hSession);
2760
0
    PR_LOG(modlog, 3, (fmt_flags, flags));
2761
0
    nssdbg_start_time(FUNC_C_SESSIONCANCEL, &start);
2762
0
    rv = module_functions->C_SessionCancel(hSession,
2763
0
                                           flags);
2764
0
    nssdbg_finish_time(FUNC_C_SESSIONCANCEL, start);
2765
0
    log_rv(rv);
2766
0
    return rv;
2767
0
}
2768
2769
CK_RV
2770
NSSDBGC_MessageEncryptInit(CK_SESSION_HANDLE hSession,
2771
                           CK_MECHANISM_PTR pMechanism,
2772
                           CK_OBJECT_HANDLE hKey)
2773
0
{
2774
0
    COMMON_DEFINITIONS;
2775
0
    PR_LOG(modlog, 1, ("C_MessageEncryptInit"));
2776
0
    log_handle(3, fmt_hSession, hSession);
2777
0
    print_mechanism(pMechanism);
2778
0
    log_handle(3, fmt_hKey, hKey);
2779
0
    nssdbg_start_time(FUNC_C_MESSAGEENCRYPTINIT, &start);
2780
0
    rv = module_functions->C_MessageEncryptInit(hSession,
2781
0
                                                pMechanism,
2782
0
                                                hKey);
2783
0
    nssdbg_finish_time(FUNC_C_MESSAGEENCRYPTINIT, start);
2784
0
    log_rv(rv);
2785
0
    return rv;
2786
0
}
2787
2788
CK_RV
2789
NSSDBGC_EncryptMessage(CK_SESSION_HANDLE hSession,
2790
                       CK_VOID_PTR pParameter,
2791
                       CK_ULONG ulParameterLen,
2792
                       CK_BYTE_PTR pAssociatedData,
2793
                       CK_ULONG ulAssociatedDataLen,
2794
                       CK_BYTE_PTR pPlaintext,
2795
                       CK_ULONG ulPlaintextLen,
2796
                       CK_BYTE_PTR pCiphertext,
2797
                       CK_ULONG_PTR pulCiphertextLen)
2798
0
{
2799
0
    COMMON_DEFINITIONS;
2800
0
    PR_LOG(modlog, 1, ("C_EncryptMessage"));
2801
0
    log_handle(3, fmt_hSession, hSession);
2802
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
2803
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
2804
0
    PR_LOG(modlog, 3, (fmt_pAssociatedData, pAssociatedData));
2805
0
    PR_LOG(modlog, 3, (fmt_ulAssociatedDataLen, ulAssociatedDataLen));
2806
0
    PR_LOG(modlog, 3, (fmt_pPlaintext, pPlaintext));
2807
0
    PR_LOG(modlog, 3, (fmt_ulPlaintextLen, ulPlaintextLen));
2808
0
    PR_LOG(modlog, 3, (fmt_pCiphertext, pCiphertext));
2809
0
    PR_LOG(modlog, 3, (fmt_pulCiphertextLen, pulCiphertextLen));
2810
0
    nssdbg_start_time(FUNC_C_ENCRYPTMESSAGE, &start);
2811
0
    rv = module_functions->C_EncryptMessage(hSession,
2812
0
                                            pParameter,
2813
0
                                            ulParameterLen,
2814
0
                                            pAssociatedData,
2815
0
                                            ulAssociatedDataLen,
2816
0
                                            pPlaintext,
2817
0
                                            ulPlaintextLen,
2818
0
                                            pCiphertext,
2819
0
                                            pulCiphertextLen);
2820
0
    nssdbg_finish_time(FUNC_C_ENCRYPTMESSAGE, start);
2821
0
    log_rv(rv);
2822
0
    return rv;
2823
0
}
2824
2825
CK_RV
2826
NSSDBGC_EncryptMessageBegin(CK_SESSION_HANDLE hSession,
2827
                            CK_VOID_PTR pParameter,
2828
                            CK_ULONG ulParameterLen,
2829
                            CK_BYTE_PTR pAssociatedData,
2830
                            CK_ULONG ulAssociatedDataLen)
2831
0
{
2832
0
    COMMON_DEFINITIONS;
2833
0
    PR_LOG(modlog, 1, ("C_EncryptMessageBegin"));
2834
0
    log_handle(3, fmt_hSession, hSession);
2835
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
2836
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
2837
0
    PR_LOG(modlog, 3, (fmt_pAssociatedData, pAssociatedData));
2838
0
    PR_LOG(modlog, 3, (fmt_ulAssociatedDataLen, ulAssociatedDataLen));
2839
0
    nssdbg_start_time(FUNC_C_ENCRYPTMESSAGEBEGIN, &start);
2840
0
    rv = module_functions->C_EncryptMessageBegin(hSession,
2841
0
                                                 pParameter,
2842
0
                                                 ulParameterLen,
2843
0
                                                 pAssociatedData,
2844
0
                                                 ulAssociatedDataLen);
2845
0
    nssdbg_finish_time(FUNC_C_ENCRYPTMESSAGEBEGIN, start);
2846
0
    log_rv(rv);
2847
0
    return rv;
2848
0
}
2849
2850
CK_RV
2851
NSSDBGC_EncryptMessageNext(CK_SESSION_HANDLE hSession,
2852
                           CK_VOID_PTR pParameter,
2853
                           CK_ULONG ulParameterLen,
2854
                           CK_BYTE_PTR pPlaintextPart,
2855
                           CK_ULONG ulPlaintextPartLen,
2856
                           CK_BYTE_PTR pCiphertextPart,
2857
                           CK_ULONG_PTR pulCiphertextPartLen,
2858
                           CK_FLAGS flags)
2859
0
{
2860
0
    COMMON_DEFINITIONS;
2861
0
    PR_LOG(modlog, 1, ("C_EncryptMessageNext"));
2862
0
    log_handle(3, fmt_hSession, hSession);
2863
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
2864
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
2865
0
    PR_LOG(modlog, 3, (fmt_pPlaintextPart, pPlaintextPart));
2866
0
    PR_LOG(modlog, 3, (fmt_ulPlaintextPartLen, ulPlaintextPartLen));
2867
0
    PR_LOG(modlog, 3, (fmt_pCiphertextPart, pCiphertextPart));
2868
0
    PR_LOG(modlog, 3, (fmt_pulCiphertextPartLen, pulCiphertextPartLen));
2869
0
    nssdbg_start_time(FUNC_C_ENCRYPTMESSAGENEXT, &start);
2870
0
    rv = module_functions->C_EncryptMessageNext(hSession,
2871
0
                                                pParameter,
2872
0
                                                ulParameterLen,
2873
0
                                                pPlaintextPart,
2874
0
                                                ulPlaintextPartLen,
2875
0
                                                pCiphertextPart,
2876
0
                                                pulCiphertextPartLen,
2877
0
                                                flags);
2878
0
    nssdbg_finish_time(FUNC_C_ENCRYPTMESSAGENEXT, start);
2879
0
    log_rv(rv);
2880
0
    return rv;
2881
0
}
2882
2883
CK_RV
2884
NSSDBGC_MessageEncryptFinal(CK_SESSION_HANDLE hSession)
2885
0
{
2886
0
    COMMON_DEFINITIONS;
2887
0
    PR_LOG(modlog, 1, ("C_MessageEncryptFinal"));
2888
0
    log_handle(3, fmt_hSession, hSession);
2889
0
    nssdbg_start_time(FUNC_C_MESSAGEENCRYPTFINAL, &start);
2890
0
    rv = module_functions->C_MessageEncryptFinal(hSession);
2891
0
    nssdbg_finish_time(FUNC_C_MESSAGEENCRYPTFINAL, start);
2892
0
    log_rv(rv);
2893
0
    return rv;
2894
0
}
2895
2896
CK_RV
2897
NSSDBGC_MessageDecryptInit(CK_SESSION_HANDLE hSession,
2898
                           CK_MECHANISM_PTR pMechanism,
2899
                           CK_OBJECT_HANDLE hKey)
2900
0
{
2901
0
    COMMON_DEFINITIONS;
2902
0
    PR_LOG(modlog, 1, ("C_MessageDecryptInit"));
2903
0
    log_handle(3, fmt_hSession, hSession);
2904
0
    print_mechanism(pMechanism);
2905
0
    log_handle(3, fmt_hKey, hKey);
2906
0
    nssdbg_start_time(FUNC_C_MESSAGEDECRYPTINIT, &start);
2907
0
    rv = module_functions->C_MessageDecryptInit(hSession,
2908
0
                                                pMechanism,
2909
0
                                                hKey);
2910
0
    nssdbg_finish_time(FUNC_C_MESSAGEDECRYPTINIT, start);
2911
0
    log_rv(rv);
2912
0
    return rv;
2913
0
}
2914
2915
CK_RV
2916
NSSDBGC_DecryptMessage(CK_SESSION_HANDLE hSession,
2917
                       CK_VOID_PTR pParameter,
2918
                       CK_ULONG ulParameterLen,
2919
                       CK_BYTE_PTR pAssociatedData,
2920
                       CK_ULONG ulAssociatedDataLen,
2921
                       CK_BYTE_PTR pCiphertext,
2922
                       CK_ULONG ulCiphertextLen,
2923
                       CK_BYTE_PTR pPlaintext,
2924
                       CK_ULONG_PTR pulPlaintextLen)
2925
0
{
2926
0
    COMMON_DEFINITIONS;
2927
0
    PR_LOG(modlog, 1, ("C_DecryptMessage"));
2928
0
    log_handle(3, fmt_hSession, hSession);
2929
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
2930
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
2931
0
    PR_LOG(modlog, 3, (fmt_pAssociatedData, pAssociatedData));
2932
0
    PR_LOG(modlog, 3, (fmt_ulAssociatedDataLen, ulAssociatedDataLen));
2933
0
    PR_LOG(modlog, 3, (fmt_pCiphertext, pCiphertext));
2934
0
    PR_LOG(modlog, 3, (fmt_ulCiphertextLen, ulCiphertextLen));
2935
0
    PR_LOG(modlog, 3, (fmt_pPlaintext, pPlaintext));
2936
0
    PR_LOG(modlog, 3, (fmt_pulPlaintextLen, pulPlaintextLen));
2937
0
    nssdbg_start_time(FUNC_C_DECRYPTMESSAGE, &start);
2938
0
    rv = module_functions->C_DecryptMessage(hSession,
2939
0
                                            pParameter,
2940
0
                                            ulParameterLen,
2941
0
                                            pAssociatedData,
2942
0
                                            ulAssociatedDataLen,
2943
0
                                            pCiphertext,
2944
0
                                            ulCiphertextLen,
2945
0
                                            pPlaintext,
2946
0
                                            pulPlaintextLen);
2947
0
    nssdbg_finish_time(FUNC_C_DECRYPTMESSAGE, start);
2948
0
    log_rv(rv);
2949
0
    return rv;
2950
0
}
2951
2952
CK_RV
2953
NSSDBGC_DecryptMessageBegin(CK_SESSION_HANDLE hSession,
2954
                            CK_VOID_PTR pParameter,
2955
                            CK_ULONG ulParameterLen,
2956
                            CK_BYTE_PTR pAssociatedData,
2957
                            CK_ULONG ulAssociatedDataLen)
2958
0
{
2959
0
    COMMON_DEFINITIONS;
2960
0
    PR_LOG(modlog, 1, ("C_DecryptMessageBegin"));
2961
0
    log_handle(3, fmt_hSession, hSession);
2962
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
2963
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
2964
0
    PR_LOG(modlog, 3, (fmt_pAssociatedData, pAssociatedData));
2965
0
    PR_LOG(modlog, 3, (fmt_ulAssociatedDataLen, ulAssociatedDataLen));
2966
0
    nssdbg_start_time(FUNC_C_DECRYPTMESSAGEBEGIN, &start);
2967
0
    rv = module_functions->C_DecryptMessageBegin(hSession,
2968
0
                                                 pParameter,
2969
0
                                                 ulParameterLen,
2970
0
                                                 pAssociatedData,
2971
0
                                                 ulAssociatedDataLen);
2972
0
    nssdbg_finish_time(FUNC_C_DECRYPTMESSAGEBEGIN, start);
2973
0
    log_rv(rv);
2974
0
    return rv;
2975
0
}
2976
2977
CK_RV
2978
NSSDBGC_DecryptMessageNext(CK_SESSION_HANDLE hSession,
2979
                           CK_VOID_PTR pParameter,
2980
                           CK_ULONG ulParameterLen,
2981
                           CK_BYTE_PTR pCiphertextPart,
2982
                           CK_ULONG ulCiphertextPartLen,
2983
                           CK_BYTE_PTR pPlaintextPart,
2984
                           CK_ULONG_PTR pulPlaintextPartLen,
2985
                           CK_FLAGS flags)
2986
0
{
2987
0
    COMMON_DEFINITIONS;
2988
0
    PR_LOG(modlog, 1, ("C_DecryptMessageNext"));
2989
0
    log_handle(3, fmt_hSession, hSession);
2990
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
2991
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
2992
0
    PR_LOG(modlog, 3, (fmt_pCiphertextPart, pCiphertextPart));
2993
0
    PR_LOG(modlog, 3, (fmt_ulCiphertextPartLen, ulCiphertextPartLen));
2994
0
    PR_LOG(modlog, 3, (fmt_pPlaintextPart, pPlaintextPart));
2995
0
    PR_LOG(modlog, 3, (fmt_pulPlaintextPartLen, pulPlaintextPartLen));
2996
0
    nssdbg_start_time(FUNC_C_DECRYPTMESSAGENEXT, &start);
2997
0
    rv = module_functions->C_DecryptMessageNext(hSession,
2998
0
                                                pParameter,
2999
0
                                                ulParameterLen,
3000
0
                                                pCiphertextPart,
3001
0
                                                ulCiphertextPartLen,
3002
0
                                                pPlaintextPart,
3003
0
                                                pulPlaintextPartLen,
3004
0
                                                flags);
3005
0
    nssdbg_finish_time(FUNC_C_DECRYPTMESSAGENEXT, start);
3006
0
    log_rv(rv);
3007
0
    return rv;
3008
0
}
3009
3010
CK_RV
3011
NSSDBGC_MessageDecryptFinal(CK_SESSION_HANDLE hSession)
3012
0
{
3013
0
    COMMON_DEFINITIONS;
3014
0
    PR_LOG(modlog, 1, ("C_MessageDecryptFinal"));
3015
0
    log_handle(3, fmt_hSession, hSession);
3016
0
    nssdbg_start_time(FUNC_C_MESSAGEDECRYPTFINAL, &start);
3017
0
    rv = module_functions->C_MessageDecryptFinal(hSession);
3018
0
    nssdbg_finish_time(FUNC_C_MESSAGEDECRYPTFINAL, start);
3019
0
    log_rv(rv);
3020
0
    return rv;
3021
0
}
3022
3023
CK_RV
3024
NSSDBGC_MessageSignInit(CK_SESSION_HANDLE hSession,
3025
                        CK_MECHANISM_PTR pMechanism,
3026
                        CK_OBJECT_HANDLE hKey)
3027
0
{
3028
0
    COMMON_DEFINITIONS;
3029
0
    PR_LOG(modlog, 1, ("C_MessageSignInit"));
3030
0
    log_handle(3, fmt_hSession, hSession);
3031
0
    print_mechanism(pMechanism);
3032
0
    log_handle(3, fmt_hKey, hKey);
3033
0
    nssdbg_start_time(FUNC_C_MESSAGESIGNINIT, &start);
3034
0
    rv = module_functions->C_MessageSignInit(hSession,
3035
0
                                             pMechanism,
3036
0
                                             hKey);
3037
0
    nssdbg_finish_time(FUNC_C_MESSAGESIGNINIT, start);
3038
0
    log_rv(rv);
3039
0
    return rv;
3040
0
}
3041
3042
CK_RV
3043
NSSDBGC_SignMessage(CK_SESSION_HANDLE hSession,
3044
                    CK_VOID_PTR pParameter,
3045
                    CK_ULONG ulParameterLen,
3046
                    CK_BYTE_PTR pData,
3047
                    CK_ULONG ulDataLen,
3048
                    CK_BYTE_PTR pSignature,
3049
                    CK_ULONG_PTR pulSignatureLen)
3050
0
{
3051
0
    COMMON_DEFINITIONS;
3052
0
    PR_LOG(modlog, 1, ("C_SignMessage"));
3053
0
    log_handle(3, fmt_hSession, hSession);
3054
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
3055
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
3056
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
3057
0
    PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
3058
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
3059
0
    PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen));
3060
0
    nssdbg_start_time(FUNC_C_SIGNMESSAGE, &start);
3061
0
    rv = module_functions->C_SignMessage(hSession,
3062
0
                                         pParameter,
3063
0
                                         ulParameterLen,
3064
0
                                         pData,
3065
0
                                         ulDataLen,
3066
0
                                         pSignature,
3067
0
                                         pulSignatureLen);
3068
0
    nssdbg_finish_time(FUNC_C_SIGNMESSAGE, start);
3069
0
    log_rv(rv);
3070
0
    return rv;
3071
0
}
3072
3073
CK_RV
3074
NSSDBGC_SignMessageBegin(CK_SESSION_HANDLE hSession,
3075
                         CK_VOID_PTR pParameter,
3076
                         CK_ULONG ulParameterLen)
3077
0
{
3078
0
    COMMON_DEFINITIONS;
3079
0
    PR_LOG(modlog, 1, ("C_SignMessageBegin"));
3080
0
    log_handle(3, fmt_hSession, hSession);
3081
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
3082
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
3083
0
    nssdbg_start_time(FUNC_C_SIGNMESSAGEBEGIN, &start);
3084
0
    rv = module_functions->C_SignMessageBegin(hSession,
3085
0
                                              pParameter,
3086
0
                                              ulParameterLen);
3087
0
    nssdbg_finish_time(FUNC_C_SIGNMESSAGEBEGIN, start);
3088
0
    log_rv(rv);
3089
0
    return rv;
3090
0
}
3091
3092
CK_RV
3093
NSSDBGC_SignMessageNext(CK_SESSION_HANDLE hSession,
3094
                        CK_VOID_PTR pParameter,
3095
                        CK_ULONG ulParameterLen,
3096
                        CK_BYTE_PTR pData,
3097
                        CK_ULONG ulDataLen,
3098
                        CK_BYTE_PTR pSignature,
3099
                        CK_ULONG_PTR pulSignatureLen)
3100
0
{
3101
0
    COMMON_DEFINITIONS;
3102
0
    PR_LOG(modlog, 1, ("C_SignMessageNext"));
3103
0
    log_handle(3, fmt_hSession, hSession);
3104
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
3105
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
3106
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
3107
0
    PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
3108
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
3109
0
    PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen));
3110
0
    nssdbg_start_time(FUNC_C_SIGNMESSAGENEXT, &start);
3111
0
    rv = module_functions->C_SignMessageNext(hSession,
3112
0
                                             pParameter,
3113
0
                                             ulParameterLen,
3114
0
                                             pData,
3115
0
                                             ulDataLen,
3116
0
                                             pSignature,
3117
0
                                             pulSignatureLen);
3118
0
    nssdbg_finish_time(FUNC_C_SIGNMESSAGENEXT, start);
3119
0
    log_rv(rv);
3120
0
    return rv;
3121
0
}
3122
3123
CK_RV
3124
NSSDBGC_MessageSignFinal(CK_SESSION_HANDLE hSession)
3125
0
{
3126
0
    COMMON_DEFINITIONS;
3127
0
    PR_LOG(modlog, 1, ("C_MessageSignFinal"));
3128
0
    log_handle(3, fmt_hSession, hSession);
3129
0
    nssdbg_start_time(FUNC_C_MESSAGESIGNFINAL, &start);
3130
0
    rv = module_functions->C_MessageSignFinal(hSession);
3131
0
    nssdbg_finish_time(FUNC_C_MESSAGESIGNFINAL, start);
3132
0
    log_rv(rv);
3133
0
    return rv;
3134
0
}
3135
3136
CK_RV
3137
NSSDBGC_MessageVerifyInit(CK_SESSION_HANDLE hSession,
3138
                          CK_MECHANISM_PTR pMechanism,
3139
                          CK_OBJECT_HANDLE hKey)
3140
0
{
3141
0
    COMMON_DEFINITIONS;
3142
0
    PR_LOG(modlog, 1, ("C_MessageVerifyInit"));
3143
0
    log_handle(3, fmt_hSession, hSession);
3144
0
    print_mechanism(pMechanism);
3145
0
    log_handle(3, fmt_hKey, hKey);
3146
0
    nssdbg_start_time(FUNC_C_MESSAGEVERIFYINIT, &start);
3147
0
    rv = module_functions->C_MessageVerifyInit(hSession,
3148
0
                                               pMechanism,
3149
0
                                               hKey);
3150
0
    nssdbg_finish_time(FUNC_C_MESSAGEVERIFYINIT, start);
3151
0
    log_rv(rv);
3152
0
    return rv;
3153
0
}
3154
3155
CK_RV
3156
NSSDBGC_VerifyMessage(CK_SESSION_HANDLE hSession,
3157
                      CK_VOID_PTR pParameter,
3158
                      CK_ULONG ulParameterLen,
3159
                      CK_BYTE_PTR pData,
3160
                      CK_ULONG ulDataLen,
3161
                      CK_BYTE_PTR pSignature,
3162
                      CK_ULONG ulSignatureLen)
3163
0
{
3164
0
    COMMON_DEFINITIONS;
3165
0
    PR_LOG(modlog, 1, ("C_VerifyMessage"));
3166
0
    log_handle(3, fmt_hSession, hSession);
3167
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
3168
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
3169
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
3170
0
    PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
3171
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
3172
0
    PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen));
3173
0
    nssdbg_start_time(FUNC_C_VERIFYMESSAGE, &start);
3174
0
    rv = module_functions->C_VerifyMessage(hSession,
3175
0
                                           pParameter,
3176
0
                                           ulParameterLen,
3177
0
                                           pData,
3178
0
                                           ulDataLen,
3179
0
                                           pSignature,
3180
0
                                           ulSignatureLen);
3181
0
    nssdbg_finish_time(FUNC_C_VERIFYMESSAGE, start);
3182
0
    log_rv(rv);
3183
0
    return rv;
3184
0
}
3185
3186
CK_RV
3187
NSSDBGC_VerifyMessageBegin(CK_SESSION_HANDLE hSession,
3188
                           CK_VOID_PTR pParameter,
3189
                           CK_ULONG ulParameterLen)
3190
0
{
3191
0
    COMMON_DEFINITIONS;
3192
0
    PR_LOG(modlog, 1, ("C_VerifyMessageBegin"));
3193
0
    log_handle(3, fmt_hSession, hSession);
3194
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
3195
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
3196
0
    nssdbg_start_time(FUNC_C_VERIFYMESSAGEBEGIN, &start);
3197
0
    rv = module_functions->C_VerifyMessageBegin(hSession,
3198
0
                                                pParameter,
3199
0
                                                ulParameterLen);
3200
0
    nssdbg_finish_time(FUNC_C_VERIFYMESSAGEBEGIN, start);
3201
0
    log_rv(rv);
3202
0
    return rv;
3203
0
}
3204
3205
CK_RV
3206
NSSDBGC_VerifyMessageNext(CK_SESSION_HANDLE hSession,
3207
                          CK_VOID_PTR pParameter,
3208
                          CK_ULONG ulParameterLen,
3209
                          CK_BYTE_PTR pData,
3210
                          CK_ULONG ulDataLen,
3211
                          CK_BYTE_PTR pSignature,
3212
                          CK_ULONG ulSignatureLen)
3213
0
{
3214
0
    COMMON_DEFINITIONS;
3215
0
    PR_LOG(modlog, 1, ("C_VerifyMessageNext"));
3216
0
    log_handle(3, fmt_hSession, hSession);
3217
0
    PR_LOG(modlog, 3, (fmt_pParameter, pParameter));
3218
0
    PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen));
3219
0
    PR_LOG(modlog, 3, (fmt_pData, pData));
3220
0
    PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
3221
0
    PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
3222
0
    PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen));
3223
0
    nssdbg_start_time(FUNC_C_VERIFYMESSAGENEXT, &start);
3224
0
    rv = module_functions->C_VerifyMessageNext(hSession,
3225
0
                                               pParameter,
3226
0
                                               ulParameterLen,
3227
0
                                               pData,
3228
0
                                               ulDataLen,
3229
0
                                               pSignature,
3230
0
                                               ulSignatureLen);
3231
0
    nssdbg_finish_time(FUNC_C_VERIFYMESSAGENEXT, start);
3232
0
    log_rv(rv);
3233
0
    return rv;
3234
0
}
3235
3236
CK_RV
3237
NSSDBGC_MessageVerifyFinal(CK_SESSION_HANDLE hSession)
3238
0
{
3239
0
    COMMON_DEFINITIONS;
3240
0
    PR_LOG(modlog, 1, ("C_MessageVerifyFinal"));
3241
0
    log_handle(3, fmt_hSession, hSession);
3242
0
    nssdbg_start_time(FUNC_C_MESSAGEVERIFYFINAL, &start);
3243
0
    rv = module_functions->C_MessageVerifyFinal(hSession);
3244
0
    nssdbg_finish_time(FUNC_C_MESSAGEVERIFYFINAL, start);
3245
0
    log_rv(rv);
3246
0
    return rv;
3247
0
}
3248
3249
CK_FUNCTION_LIST_3_0_PTR
3250
nss_InsertDeviceLog(
3251
    CK_FUNCTION_LIST_3_0_PTR devEPV)
3252
0
{
3253
0
    module_functions = devEPV;
3254
0
    debug_functions.version = devEPV->version;
3255
0
    modlog = PR_NewLogModule("nss_mod_log");
3256
0
    debug_functions.C_Initialize = NSSDBGC_Initialize;
3257
0
    debug_functions.C_Finalize = NSSDBGC_Finalize;
3258
0
    debug_functions.C_GetInfo = NSSDBGC_GetInfo;
3259
0
    debug_functions.C_GetFunctionList = NSSDBGC_GetFunctionList;
3260
0
    debug_functions.C_GetSlotList = NSSDBGC_GetSlotList;
3261
0
    debug_functions.C_GetSlotInfo = NSSDBGC_GetSlotInfo;
3262
0
    debug_functions.C_GetTokenInfo = NSSDBGC_GetTokenInfo;
3263
0
    debug_functions.C_GetMechanismList = NSSDBGC_GetMechanismList;
3264
0
    debug_functions.C_GetMechanismInfo = NSSDBGC_GetMechanismInfo;
3265
0
    debug_functions.C_InitToken = NSSDBGC_InitToken;
3266
0
    debug_functions.C_InitPIN = NSSDBGC_InitPIN;
3267
0
    debug_functions.C_SetPIN = NSSDBGC_SetPIN;
3268
0
    debug_functions.C_OpenSession = NSSDBGC_OpenSession;
3269
0
    debug_functions.C_CloseSession = NSSDBGC_CloseSession;
3270
0
    debug_functions.C_CloseAllSessions = NSSDBGC_CloseAllSessions;
3271
0
    debug_functions.C_GetSessionInfo = NSSDBGC_GetSessionInfo;
3272
0
    debug_functions.C_GetOperationState = NSSDBGC_GetOperationState;
3273
0
    debug_functions.C_SetOperationState = NSSDBGC_SetOperationState;
3274
0
    debug_functions.C_Login = NSSDBGC_Login;
3275
0
    debug_functions.C_Logout = NSSDBGC_Logout;
3276
0
    debug_functions.C_CreateObject = NSSDBGC_CreateObject;
3277
0
    debug_functions.C_CopyObject = NSSDBGC_CopyObject;
3278
0
    debug_functions.C_DestroyObject = NSSDBGC_DestroyObject;
3279
0
    debug_functions.C_GetObjectSize = NSSDBGC_GetObjectSize;
3280
0
    debug_functions.C_GetAttributeValue = NSSDBGC_GetAttributeValue;
3281
0
    debug_functions.C_SetAttributeValue = NSSDBGC_SetAttributeValue;
3282
0
    debug_functions.C_FindObjectsInit = NSSDBGC_FindObjectsInit;
3283
0
    debug_functions.C_FindObjects = NSSDBGC_FindObjects;
3284
0
    debug_functions.C_FindObjectsFinal = NSSDBGC_FindObjectsFinal;
3285
0
    debug_functions.C_EncryptInit = NSSDBGC_EncryptInit;
3286
0
    debug_functions.C_Encrypt = NSSDBGC_Encrypt;
3287
0
    debug_functions.C_EncryptUpdate = NSSDBGC_EncryptUpdate;
3288
0
    debug_functions.C_EncryptFinal = NSSDBGC_EncryptFinal;
3289
0
    debug_functions.C_DecryptInit = NSSDBGC_DecryptInit;
3290
0
    debug_functions.C_Decrypt = NSSDBGC_Decrypt;
3291
0
    debug_functions.C_DecryptUpdate = NSSDBGC_DecryptUpdate;
3292
0
    debug_functions.C_DecryptFinal = NSSDBGC_DecryptFinal;
3293
0
    debug_functions.C_DigestInit = NSSDBGC_DigestInit;
3294
0
    debug_functions.C_Digest = NSSDBGC_Digest;
3295
0
    debug_functions.C_DigestUpdate = NSSDBGC_DigestUpdate;
3296
0
    debug_functions.C_DigestKey = NSSDBGC_DigestKey;
3297
0
    debug_functions.C_DigestFinal = NSSDBGC_DigestFinal;
3298
0
    debug_functions.C_SignInit = NSSDBGC_SignInit;
3299
0
    debug_functions.C_Sign = NSSDBGC_Sign;
3300
0
    debug_functions.C_SignUpdate = NSSDBGC_SignUpdate;
3301
0
    debug_functions.C_SignFinal = NSSDBGC_SignFinal;
3302
0
    debug_functions.C_SignRecoverInit = NSSDBGC_SignRecoverInit;
3303
0
    debug_functions.C_SignRecover = NSSDBGC_SignRecover;
3304
0
    debug_functions.C_VerifyInit = NSSDBGC_VerifyInit;
3305
0
    debug_functions.C_Verify = NSSDBGC_Verify;
3306
0
    debug_functions.C_VerifyUpdate = NSSDBGC_VerifyUpdate;
3307
0
    debug_functions.C_VerifyFinal = NSSDBGC_VerifyFinal;
3308
0
    debug_functions.C_VerifyRecoverInit = NSSDBGC_VerifyRecoverInit;
3309
0
    debug_functions.C_VerifyRecover = NSSDBGC_VerifyRecover;
3310
0
    debug_functions.C_DigestEncryptUpdate = NSSDBGC_DigestEncryptUpdate;
3311
0
    debug_functions.C_DecryptDigestUpdate = NSSDBGC_DecryptDigestUpdate;
3312
0
    debug_functions.C_SignEncryptUpdate = NSSDBGC_SignEncryptUpdate;
3313
0
    debug_functions.C_DecryptVerifyUpdate = NSSDBGC_DecryptVerifyUpdate;
3314
0
    debug_functions.C_GenerateKey = NSSDBGC_GenerateKey;
3315
0
    debug_functions.C_GenerateKeyPair = NSSDBGC_GenerateKeyPair;
3316
0
    debug_functions.C_WrapKey = NSSDBGC_WrapKey;
3317
0
    debug_functions.C_UnwrapKey = NSSDBGC_UnwrapKey;
3318
0
    debug_functions.C_DeriveKey = NSSDBGC_DeriveKey;
3319
0
    debug_functions.C_SeedRandom = NSSDBGC_SeedRandom;
3320
0
    debug_functions.C_GenerateRandom = NSSDBGC_GenerateRandom;
3321
0
    debug_functions.C_GetFunctionStatus = NSSDBGC_GetFunctionStatus;
3322
0
    debug_functions.C_CancelFunction = NSSDBGC_CancelFunction;
3323
0
    debug_functions.C_WaitForSlotEvent = NSSDBGC_WaitForSlotEvent;
3324
0
    debug_functions.C_GetInterfaceList = NSSDBGC_GetInterfaceList;
3325
0
    debug_functions.C_GetInterface = NSSDBGC_GetInterface;
3326
0
    debug_functions.C_LoginUser = NSSDBGC_LoginUser;
3327
0
    debug_functions.C_SessionCancel = NSSDBGC_SessionCancel;
3328
0
    debug_functions.C_MessageEncryptInit = NSSDBGC_MessageEncryptInit;
3329
0
    debug_functions.C_EncryptMessage = NSSDBGC_EncryptMessage;
3330
0
    debug_functions.C_EncryptMessageBegin = NSSDBGC_EncryptMessageBegin;
3331
0
    debug_functions.C_EncryptMessageNext = NSSDBGC_EncryptMessageNext;
3332
0
    debug_functions.C_MessageEncryptFinal = NSSDBGC_MessageEncryptFinal;
3333
0
    debug_functions.C_MessageDecryptInit = NSSDBGC_MessageDecryptInit;
3334
0
    debug_functions.C_DecryptMessage = NSSDBGC_DecryptMessage;
3335
0
    debug_functions.C_DecryptMessageBegin = NSSDBGC_DecryptMessageBegin;
3336
0
    debug_functions.C_DecryptMessageNext = NSSDBGC_DecryptMessageNext;
3337
0
    debug_functions.C_MessageDecryptFinal = NSSDBGC_MessageDecryptFinal;
3338
0
    debug_functions.C_MessageSignInit = NSSDBGC_MessageSignInit;
3339
0
    debug_functions.C_SignMessage = NSSDBGC_SignMessage;
3340
0
    debug_functions.C_SignMessageBegin = NSSDBGC_SignMessageBegin;
3341
0
    debug_functions.C_SignMessageNext = NSSDBGC_SignMessageNext;
3342
0
    debug_functions.C_MessageSignFinal = NSSDBGC_MessageSignFinal;
3343
0
    debug_functions.C_MessageVerifyInit = NSSDBGC_MessageVerifyInit;
3344
0
    debug_functions.C_VerifyMessage = NSSDBGC_VerifyMessage;
3345
0
    debug_functions.C_VerifyMessageBegin = NSSDBGC_VerifyMessageBegin;
3346
0
    debug_functions.C_VerifyMessageNext = NSSDBGC_VerifyMessageNext;
3347
0
    debug_functions.C_MessageVerifyFinal = NSSDBGC_MessageVerifyFinal;
3348
0
    return &debug_functions;
3349
0
}
3350
3351
/*
3352
 * scale the time factor up accordingly.
3353
 * This routine tries to keep at least 2 significant figures on output.
3354
 *    If the time is 0, then indicate that with a 'z' for units.
3355
 *    If the time is greater than 10 minutes, output the time in minutes.
3356
 *    If the time is less than 10 minutes but greater than 10 seconds output
3357
 * the time in second.
3358
 *    If the time is less than 10 seconds but greater than 10 milliseconds
3359
 * output * the time in millisecond.
3360
 *    If the time is less than 10 milliseconds but greater than 0 ticks output
3361
 * the time in microsecond.
3362
 *
3363
 */
3364
static PRUint32
3365
getPrintTime(PRIntervalTime time, char **type)
3366
0
{
3367
0
    PRUint32 prTime;
3368
3369
    /* detect a programming error by outputting 'bu' to the output stream
3370
     * rather than crashing */
3371
0
    *type = "bug";
3372
0
    if (time == 0) {
3373
0
        *type = "z";
3374
0
        return 0;
3375
0
    }
3376
3377
0
    prTime = PR_IntervalToSeconds(time);
3378
3379
0
    if (prTime >= 600) {
3380
0
        *type = "m";
3381
0
        return prTime / 60;
3382
0
    }
3383
0
    if (prTime >= 10) {
3384
0
        *type = "s";
3385
0
        return prTime;
3386
0
    }
3387
0
    prTime = PR_IntervalToMilliseconds(time);
3388
0
    if (prTime >= 10) {
3389
0
        *type = "ms";
3390
0
        return prTime;
3391
0
    }
3392
0
    *type = "us";
3393
0
    return PR_IntervalToMicroseconds(time);
3394
0
}
3395
3396
static void
3397
print_final_statistics(void)
3398
0
{
3399
0
    int total_calls = 0;
3400
0
    PRIntervalTime total_time = 0;
3401
0
    PRUint32 pr_total_time;
3402
0
    char *type;
3403
0
    char *fname;
3404
0
    FILE *outfile = NULL;
3405
0
    int i;
3406
3407
0
    fname = PR_GetEnvSecure("NSS_OUTPUT_FILE");
3408
0
    if (fname) {
3409
        /* need to add an optional process id to the filename */
3410
0
        outfile = fopen(fname, "w+");
3411
0
    }
3412
0
    if (!outfile) {
3413
0
        outfile = stdout;
3414
0
    }
3415
3416
0
    fprintf(outfile, "%-25s %10s %12s %12s %10s\n", "Function", "# Calls",
3417
0
            "Time", "Avg.", "% Time");
3418
0
    fprintf(outfile, "\n");
3419
0
    for (i = 0; i < nssdbg_prof_size; i++) {
3420
0
        total_calls += nssdbg_prof_data[i].calls;
3421
0
        total_time += nssdbg_prof_data[i].time;
3422
0
    }
3423
0
    for (i = 0; i < nssdbg_prof_size; i++) {
3424
0
        PRIntervalTime time = nssdbg_prof_data[i].time;
3425
0
        PRUint32 usTime = PR_IntervalToMicroseconds(time);
3426
0
        PRUint32 prTime = 0;
3427
0
        PRUint32 calls = nssdbg_prof_data[i].calls;
3428
        /* don't print out functions that weren't even called */
3429
0
        if (calls == 0) {
3430
0
            continue;
3431
0
        }
3432
3433
0
        prTime = getPrintTime(time, &type);
3434
3435
0
        fprintf(outfile, "%-25s %10d %10d%2s ", nssdbg_prof_data[i].function,
3436
0
                calls, prTime, type);
3437
        /* for now always output the average in microseconds */
3438
0
        fprintf(outfile, "%10.2f%2s", (float)usTime / (float)calls, "us");
3439
0
        fprintf(outfile, "%10.2f%%", ((float)time / (float)total_time) * 100);
3440
0
        fprintf(outfile, "\n");
3441
0
    }
3442
0
    fprintf(outfile, "\n");
3443
3444
0
    pr_total_time = getPrintTime(total_time, &type);
3445
3446
0
    fprintf(outfile, "%25s %10d %10d%2s\n", "Totals", total_calls,
3447
0
            pr_total_time, type);
3448
0
    fprintf(outfile, "\n\nMaximum number of concurrent open sessions: %d\n\n",
3449
0
            maxOpenSessions);
3450
0
    fflush(outfile);
3451
0
    if (outfile != stdout) {
3452
0
        fclose(outfile);
3453
0
    }
3454
0
}