The Tor Browser / file comparison

comparison: security/nss/lib/softoken/pkcs11.c

security/nss/lib/softoken/pkcs11.c

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:3e5e1fef3535
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 /*
5 * This file implements PKCS 11 on top of our existing security modules
6 *
7 * For more information about PKCS 11 See PKCS 11 Token Inteface Standard.
8 * This implementation has two slots:
9 * slot 1 is our generic crypto support. It does not require login.
10 * It supports Public Key ops, and all they bulk ciphers and hashes.
11 * It can also support Private Key ops for imported Private keys. It does
12 * not have any token storage.
13 * slot 2 is our private key support. It requires a login before use. It
14 * can store Private Keys and Certs as token objects. Currently only private
15 * keys and their associated Certificates are saved on the token.
16 *
17 * In this implementation, session objects are only visible to the session
18 * that created or generated them.
19 */
20 #include "seccomon.h"
21 #include "secitem.h"
22 #include "pkcs11.h"
23 #include "pkcs11i.h"
24 #include "softoken.h"
25 #include "lowkeyi.h"
26 #include "blapi.h"
27 #include "secder.h"
28 #include "secport.h"
29 #include "secrng.h"
30 #include "prtypes.h"
31 #include "nspr.h"
32 #include "softkver.h"
33 #include "secoid.h"
34 #include "sftkdb.h"
35 #include "utilpars.h"
36 #include "ec.h"
37 #include "secasn1.h"
38 #include "secerr.h"
39 #include "lgglue.h"
40
41 PRBool parentForkedAfterC_Initialize;
42
43 #ifndef NO_FORK_CHECK
44
45 PRBool sftkForkCheckDisabled;
46
47 #if defined(CHECK_FORK_PTHREAD) || defined(CHECK_FORK_MIXED)
48 PRBool forked = PR_FALSE;
49 #endif
50
51 #if defined(CHECK_FORK_GETPID) || defined(CHECK_FORK_MIXED)
52 #include <unistd.h>
53 pid_t myPid;
54 #endif
55
56 #ifdef CHECK_FORK_MIXED
57 #include <sys/systeminfo.h>
58 PRBool usePthread_atfork;
59 #endif
60
61 #endif
62
63 /*
64 * ******************** Static data *******************************
65 */
66
67 /* The next three strings must be exactly 32 characters long */
68 static char *manufacturerID = "Mozilla Foundation ";
69 static char manufacturerID_space[33];
70 static char *libraryDescription = "NSS Internal Crypto Services ";
71 static char libraryDescription_space[33];
72
73 /*
74 * In FIPS mode, we disallow login attempts for 1 second after a login
75 * failure so that there are at most 60 login attempts per minute.
76 */
77 static PRIntervalTime loginWaitTime;
78 static PRUint32 minSessionObjectHandle = 1U;
79
80 #define __PASTE(x,y) x##y
81
82 /*
83 * we renamed all our internal functions, get the correct
84 * definitions for them...
85 */
86 #undef CK_PKCS11_FUNCTION_INFO
87 #undef CK_NEED_ARG_LIST
88
89 #define CK_EXTERN extern
90 #define CK_PKCS11_FUNCTION_INFO(func) \
91 CK_RV __PASTE(NS,func)
92 #define CK_NEED_ARG_LIST 1
93
94 #include "pkcs11f.h"
95
96
97
98 /* build the crypto module table */
99 static const CK_FUNCTION_LIST sftk_funcList = {
100 { 1, 10 },
101
102 #undef CK_PKCS11_FUNCTION_INFO
103 #undef CK_NEED_ARG_LIST
104
105 #define CK_PKCS11_FUNCTION_INFO(func) \
106 __PASTE(NS,func),
107 #include "pkcs11f.h"
108
109 };
110
111 #undef CK_PKCS11_FUNCTION_INFO
112 #undef CK_NEED_ARG_LIST
113
114
115 #undef __PASTE
116
117 /* List of DES Weak Keys */
118 typedef unsigned char desKey[8];
119 static const desKey sftk_desWeakTable[] = {
120 #ifdef noParity
121 /* weak */
122 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
123 { 0x1e, 0x1e, 0x1e, 0x1e, 0x0e, 0x0e, 0x0e, 0x0e },
124 { 0xe0, 0xe0, 0xe0, 0xe0, 0xf0, 0xf0, 0xf0, 0xf0 },
125 { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
126 /* semi-weak */
127 { 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe },
128 { 0xfe, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0xfe },
129
130 { 0x1e, 0xe0, 0x1e, 0xe0, 0x0e, 0xf0, 0x0e, 0xf0 },
131 { 0xe0, 0x1e, 0xe0, 0x1e, 0xf0, 0x0e, 0xf0, 0x0e },
132
133 { 0x00, 0xe0, 0x00, 0xe0, 0x00, 0x0f, 0x00, 0x0f },
134 { 0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0, 0x00 },
135
136 { 0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe },
137 { 0xfe, 0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e },
138
139 { 0x00, 0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e },
140 { 0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e, 0x00 },
141
142 { 0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0, 0xfe },
143 { 0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0 },
144 #else
145 /* weak */
146 { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
147 { 0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e },
148 { 0xe0, 0xe0, 0xe0, 0xe0, 0xf1, 0xf1, 0xf1, 0xf1 },
149 { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
150
151 /* semi-weak */
152 { 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe },
153 { 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01 },
154
155 { 0x1f, 0xe0, 0x1f, 0xe0, 0x0e, 0xf1, 0x0e, 0xf1 },
156 { 0xe0, 0x1f, 0xe0, 0x1f, 0xf1, 0x0e, 0xf1, 0x0e },
157
158 { 0x01, 0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1 },
159 { 0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1, 0x01 },
160
161 { 0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe },
162 { 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e },
163
164 { 0x01, 0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e },
165 { 0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e, 0x01 },
166
167 { 0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1, 0xfe },
168 { 0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1 }
169 #endif
170 };
171
172
173 static const int sftk_desWeakTableSize = sizeof(sftk_desWeakTable)/
174 sizeof(sftk_desWeakTable[0]);
175
176 /* DES KEY Parity conversion table. Takes each byte/2 as an index, returns
177 * that byte with the proper parity bit set */
178 static const unsigned char parityTable[256] = {
179 /* Even...0x00,0x02,0x04,0x06,0x08,0x0a,0x0c,0x0e */
180 /* E */ 0x01,0x02,0x04,0x07,0x08,0x0b,0x0d,0x0e,
181 /* Odd....0x10,0x12,0x14,0x16,0x18,0x1a,0x1c,0x1e */
182 /* O */ 0x10,0x13,0x15,0x16,0x19,0x1a,0x1c,0x1f,
183 /* Odd....0x20,0x22,0x24,0x26,0x28,0x2a,0x2c,0x2e */
184 /* O */ 0x20,0x23,0x25,0x26,0x29,0x2a,0x2c,0x2f,
185 /* Even...0x30,0x32,0x34,0x36,0x38,0x3a,0x3c,0x3e */
186 /* E */ 0x31,0x32,0x34,0x37,0x38,0x3b,0x3d,0x3e,
187 /* Odd....0x40,0x42,0x44,0x46,0x48,0x4a,0x4c,0x4e */
188 /* O */ 0x40,0x43,0x45,0x46,0x49,0x4a,0x4c,0x4f,
189 /* Even...0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,0x5e */
190 /* E */ 0x51,0x52,0x54,0x57,0x58,0x5b,0x5d,0x5e,
191 /* Even...0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6e */
192 /* E */ 0x61,0x62,0x64,0x67,0x68,0x6b,0x6d,0x6e,
193 /* Odd....0x70,0x72,0x74,0x76,0x78,0x7a,0x7c,0x7e */
194 /* O */ 0x70,0x73,0x75,0x76,0x79,0x7a,0x7c,0x7f,
195 /* Odd....0x80,0x82,0x84,0x86,0x88,0x8a,0x8c,0x8e */
196 /* O */ 0x80,0x83,0x85,0x86,0x89,0x8a,0x8c,0x8f,
197 /* Even...0x90,0x92,0x94,0x96,0x98,0x9a,0x9c,0x9e */
198 /* E */ 0x91,0x92,0x94,0x97,0x98,0x9b,0x9d,0x9e,
199 /* Even...0xa0,0xa2,0xa4,0xa6,0xa8,0xaa,0xac,0xae */
200 /* E */ 0xa1,0xa2,0xa4,0xa7,0xa8,0xab,0xad,0xae,
201 /* Odd....0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe */
202 /* O */ 0xb0,0xb3,0xb5,0xb6,0xb9,0xba,0xbc,0xbf,
203 /* Even...0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce */
204 /* E */ 0xc1,0xc2,0xc4,0xc7,0xc8,0xcb,0xcd,0xce,
205 /* Odd....0xd0,0xd2,0xd4,0xd6,0xd8,0xda,0xdc,0xde */
206 /* O */ 0xd0,0xd3,0xd5,0xd6,0xd9,0xda,0xdc,0xdf,
207 /* Odd....0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee */
208 /* O */ 0xe0,0xe3,0xe5,0xe6,0xe9,0xea,0xec,0xef,
209 /* Even...0xf0,0xf2,0xf4,0xf6,0xf8,0xfa,0xfc,0xfe */
210 /* E */ 0xf1,0xf2,0xf4,0xf7,0xf8,0xfb,0xfd,0xfe,
211 };
212
213 /* Mechanisms */
214 struct mechanismList {
215 CK_MECHANISM_TYPE type;
216 CK_MECHANISM_INFO info;
217 PRBool privkey;
218 };
219
220 /*
221 * the following table includes a complete list of mechanism defined by
222 * PKCS #11 version 2.01. Those Mechanisms not supported by this PKCS #11
223 * module are ifdef'ed out.
224 */
225 #define CKF_EN_DE CKF_ENCRYPT | CKF_DECRYPT
226 #define CKF_WR_UN CKF_WRAP | CKF_UNWRAP
227 #define CKF_SN_VR CKF_SIGN | CKF_VERIFY
228 #define CKF_SN_RE CKF_SIGN_RECOVER | CKF_VERIFY_RECOVER
229
230 #define CKF_EN_DE_WR_UN CKF_EN_DE | CKF_WR_UN
231 #define CKF_SN_VR_RE CKF_SN_VR | CKF_SN_RE
232 #define CKF_DUZ_IT_ALL CKF_EN_DE_WR_UN | CKF_SN_VR_RE
233
234 #define CKF_EC_PNU CKF_EC_FP | CKF_EC_NAMEDCURVE | CKF_EC_UNCOMPRESS
235
236 #define CKF_EC_BPNU CKF_EC_F_2M | CKF_EC_PNU
237
238 #define CK_MAX 0xffffffff
239
240 static const struct mechanismList mechanisms[] = {
241
242 /*
243 * PKCS #11 Mechanism List.
244 *
245 * The first argument is the PKCS #11 Mechanism we support.
246 * The second argument is Mechanism info structure. It includes:
247 * The minimum key size,
248 * in bits for RSA, DSA, DH, EC*, KEA, RC2 and RC4 * algs.
249 * in bytes for RC5, AES, Camellia, and CAST*
250 * ignored for DES*, IDEA and FORTEZZA based
251 * The maximum key size,
252 * in bits for RSA, DSA, DH, EC*, KEA, RC2 and RC4 * algs.
253 * in bytes for RC5, AES, Camellia, and CAST*
254 * ignored for DES*, IDEA and FORTEZZA based
255 * Flags
256 * What operations are supported by this mechanism.
257 * The third argument is a bool which tells if this mechanism is
258 * supported in the database token.
259 *
260 */
261
262 /* ------------------------- RSA Operations ---------------------------*/
263 {CKM_RSA_PKCS_KEY_PAIR_GEN,{RSA_MIN_MODULUS_BITS,CK_MAX,
264 CKF_GENERATE_KEY_PAIR},PR_TRUE},
265 {CKM_RSA_PKCS, {RSA_MIN_MODULUS_BITS,CK_MAX,
266 CKF_DUZ_IT_ALL}, PR_TRUE},
267 {CKM_RSA_PKCS_PSS, {RSA_MIN_MODULUS_BITS,CK_MAX,
268 CKF_SN_VR}, PR_TRUE},
269 {CKM_RSA_PKCS_OAEP, {RSA_MIN_MODULUS_BITS,CK_MAX,
270 CKF_EN_DE_WR_UN}, PR_TRUE},
271 #ifdef SFTK_RSA9796_SUPPORTED
272 {CKM_RSA_9796, {RSA_MIN_MODULUS_BITS,CK_MAX,
273 CKF_DUZ_IT_ALL}, PR_TRUE},
274 #endif
275 {CKM_RSA_X_509, {RSA_MIN_MODULUS_BITS,CK_MAX,
276 CKF_DUZ_IT_ALL}, PR_TRUE},
277 /* -------------- RSA Multipart Signing Operations -------------------- */
278 {CKM_MD2_RSA_PKCS, {RSA_MIN_MODULUS_BITS,CK_MAX,
279 CKF_SN_VR}, PR_TRUE},
280 {CKM_MD5_RSA_PKCS, {RSA_MIN_MODULUS_BITS,CK_MAX,
281 CKF_SN_VR}, PR_TRUE},
282 {CKM_SHA1_RSA_PKCS, {RSA_MIN_MODULUS_BITS,CK_MAX,
283 CKF_SN_VR}, PR_TRUE},
284 {CKM_SHA224_RSA_PKCS, {RSA_MIN_MODULUS_BITS,CK_MAX,
285 CKF_SN_VR}, PR_TRUE},
286 {CKM_SHA256_RSA_PKCS, {RSA_MIN_MODULUS_BITS,CK_MAX,
287 CKF_SN_VR}, PR_TRUE},
288 {CKM_SHA384_RSA_PKCS, {RSA_MIN_MODULUS_BITS,CK_MAX,
289 CKF_SN_VR}, PR_TRUE},
290 {CKM_SHA512_RSA_PKCS, {RSA_MIN_MODULUS_BITS,CK_MAX,
291 CKF_SN_VR}, PR_TRUE},
292 /* ------------------------- DSA Operations --------------------------- */
293 {CKM_DSA_KEY_PAIR_GEN, {DSA_MIN_P_BITS, DSA_MAX_P_BITS,
294 CKF_GENERATE_KEY_PAIR}, PR_TRUE},
295 {CKM_DSA, {DSA_MIN_P_BITS, DSA_MAX_P_BITS,
296 CKF_SN_VR}, PR_TRUE},
297 {CKM_DSA_PARAMETER_GEN, {DSA_MIN_P_BITS, DSA_MAX_P_BITS,
298 CKF_GENERATE}, PR_TRUE},
299 {CKM_DSA_SHA1, {DSA_MIN_P_BITS, DSA_MAX_P_BITS,
300 CKF_SN_VR}, PR_TRUE},
301 /* -------------------- Diffie Hellman Operations --------------------- */
302 /* no diffie hellman yet */
303 {CKM_DH_PKCS_KEY_PAIR_GEN, {DH_MIN_P_BITS, DH_MAX_P_BITS,
304 CKF_GENERATE_KEY_PAIR}, PR_TRUE},
305 {CKM_DH_PKCS_DERIVE, {DH_MIN_P_BITS, DH_MAX_P_BITS,
306 CKF_DERIVE}, PR_TRUE},
307 #ifndef NSS_DISABLE_ECC
308 /* -------------------- Elliptic Curve Operations --------------------- */
309 {CKM_EC_KEY_PAIR_GEN, {EC_MIN_KEY_BITS, EC_MAX_KEY_BITS,
310 CKF_GENERATE_KEY_PAIR|CKF_EC_BPNU}, PR_TRUE},
311 {CKM_ECDH1_DERIVE, {EC_MIN_KEY_BITS, EC_MAX_KEY_BITS,
312 CKF_DERIVE|CKF_EC_BPNU}, PR_TRUE},
313 {CKM_ECDSA, {EC_MIN_KEY_BITS, EC_MAX_KEY_BITS,
314 CKF_SN_VR|CKF_EC_BPNU}, PR_TRUE},
315 {CKM_ECDSA_SHA1, {EC_MIN_KEY_BITS, EC_MAX_KEY_BITS,
316 CKF_SN_VR|CKF_EC_BPNU}, PR_TRUE},
317 #endif /* NSS_DISABLE_ECC */
318 /* ------------------------- RC2 Operations --------------------------- */
319 {CKM_RC2_KEY_GEN, {1, 128, CKF_GENERATE}, PR_TRUE},
320 {CKM_RC2_ECB, {1, 128, CKF_EN_DE_WR_UN}, PR_TRUE},
321 {CKM_RC2_CBC, {1, 128, CKF_EN_DE_WR_UN}, PR_TRUE},
322 {CKM_RC2_MAC, {1, 128, CKF_SN_VR}, PR_TRUE},
323 {CKM_RC2_MAC_GENERAL, {1, 128, CKF_SN_VR}, PR_TRUE},
324 {CKM_RC2_CBC_PAD, {1, 128, CKF_EN_DE_WR_UN}, PR_TRUE},
325 /* ------------------------- RC4 Operations --------------------------- */
326 {CKM_RC4_KEY_GEN, {1, 256, CKF_GENERATE}, PR_FALSE},
327 {CKM_RC4, {1, 256, CKF_EN_DE_WR_UN}, PR_FALSE},
328 /* ------------------------- DES Operations --------------------------- */
329 {CKM_DES_KEY_GEN, { 8, 8, CKF_GENERATE}, PR_TRUE},
330 {CKM_DES_ECB, { 8, 8, CKF_EN_DE_WR_UN}, PR_TRUE},
331 {CKM_DES_CBC, { 8, 8, CKF_EN_DE_WR_UN}, PR_TRUE},
332 {CKM_DES_MAC, { 8, 8, CKF_SN_VR}, PR_TRUE},
333 {CKM_DES_MAC_GENERAL, { 8, 8, CKF_SN_VR}, PR_TRUE},
334 {CKM_DES_CBC_PAD, { 8, 8, CKF_EN_DE_WR_UN}, PR_TRUE},
335 {CKM_DES2_KEY_GEN, {24, 24, CKF_GENERATE}, PR_TRUE},
336 {CKM_DES3_KEY_GEN, {24, 24, CKF_GENERATE}, PR_TRUE },
337 {CKM_DES3_ECB, {24, 24, CKF_EN_DE_WR_UN}, PR_TRUE },
338 {CKM_DES3_CBC, {24, 24, CKF_EN_DE_WR_UN}, PR_TRUE },
339 {CKM_DES3_MAC, {24, 24, CKF_SN_VR}, PR_TRUE },
340 {CKM_DES3_MAC_GENERAL, {24, 24, CKF_SN_VR}, PR_TRUE },
341 {CKM_DES3_CBC_PAD, {24, 24, CKF_EN_DE_WR_UN}, PR_TRUE },
342 /* ------------------------- CDMF Operations --------------------------- */
343 {CKM_CDMF_KEY_GEN, {8, 8, CKF_GENERATE}, PR_TRUE},
344 {CKM_CDMF_ECB, {8, 8, CKF_EN_DE_WR_UN}, PR_TRUE},
345 {CKM_CDMF_CBC, {8, 8, CKF_EN_DE_WR_UN}, PR_TRUE},
346 {CKM_CDMF_MAC, {8, 8, CKF_SN_VR}, PR_TRUE},
347 {CKM_CDMF_MAC_GENERAL, {8, 8, CKF_SN_VR}, PR_TRUE},
348 {CKM_CDMF_CBC_PAD, {8, 8, CKF_EN_DE_WR_UN}, PR_TRUE},
349 /* ------------------------- AES Operations --------------------------- */
350 {CKM_AES_KEY_GEN, {16, 32, CKF_GENERATE}, PR_TRUE},
351 {CKM_AES_ECB, {16, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
352 {CKM_AES_CBC, {16, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
353 {CKM_AES_MAC, {16, 32, CKF_SN_VR}, PR_TRUE},
354 {CKM_AES_MAC_GENERAL, {16, 32, CKF_SN_VR}, PR_TRUE},
355 {CKM_AES_CBC_PAD, {16, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
356 {CKM_AES_CTS, {16, 32, CKF_EN_DE}, PR_TRUE},
357 {CKM_AES_CTR, {16, 32, CKF_EN_DE}, PR_TRUE},
358 {CKM_AES_GCM, {16, 32, CKF_EN_DE}, PR_TRUE},
359 /* ------------------------- Camellia Operations --------------------- */
360 {CKM_CAMELLIA_KEY_GEN, {16, 32, CKF_GENERATE}, PR_TRUE},
361 {CKM_CAMELLIA_ECB, {16, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
362 {CKM_CAMELLIA_CBC, {16, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
363 {CKM_CAMELLIA_MAC, {16, 32, CKF_SN_VR}, PR_TRUE},
364 {CKM_CAMELLIA_MAC_GENERAL, {16, 32, CKF_SN_VR}, PR_TRUE},
365 {CKM_CAMELLIA_CBC_PAD, {16, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
366 /* ------------------------- SEED Operations --------------------------- */
367 {CKM_SEED_KEY_GEN, {16, 16, CKF_GENERATE}, PR_TRUE},
368 {CKM_SEED_ECB, {16, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
369 {CKM_SEED_CBC, {16, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
370 {CKM_SEED_MAC, {16, 16, CKF_SN_VR}, PR_TRUE},
371 {CKM_SEED_MAC_GENERAL, {16, 16, CKF_SN_VR}, PR_TRUE},
372 {CKM_SEED_CBC_PAD, {16, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
373 /* ------------------------- Hashing Operations ----------------------- */
374 {CKM_MD2, {0, 0, CKF_DIGEST}, PR_FALSE},
375 {CKM_MD2_HMAC, {1, 128, CKF_SN_VR}, PR_TRUE},
376 {CKM_MD2_HMAC_GENERAL, {1, 128, CKF_SN_VR}, PR_TRUE},
377 {CKM_MD5, {0, 0, CKF_DIGEST}, PR_FALSE},
378 {CKM_MD5_HMAC, {1, 128, CKF_SN_VR}, PR_TRUE},
379 {CKM_MD5_HMAC_GENERAL, {1, 128, CKF_SN_VR}, PR_TRUE},
380 {CKM_SHA_1, {0, 0, CKF_DIGEST}, PR_FALSE},
381 {CKM_SHA_1_HMAC, {1, 128, CKF_SN_VR}, PR_TRUE},
382 {CKM_SHA_1_HMAC_GENERAL, {1, 128, CKF_SN_VR}, PR_TRUE},
383 {CKM_SHA224, {0, 0, CKF_DIGEST}, PR_FALSE},
384 {CKM_SHA224_HMAC, {1, 128, CKF_SN_VR}, PR_TRUE},
385 {CKM_SHA224_HMAC_GENERAL, {1, 128, CKF_SN_VR}, PR_TRUE},
386 {CKM_SHA256, {0, 0, CKF_DIGEST}, PR_FALSE},
387 {CKM_SHA256_HMAC, {1, 128, CKF_SN_VR}, PR_TRUE},
388 {CKM_SHA256_HMAC_GENERAL, {1, 128, CKF_SN_VR}, PR_TRUE},
389 {CKM_SHA384, {0, 0, CKF_DIGEST}, PR_FALSE},
390 {CKM_SHA384_HMAC, {1, 128, CKF_SN_VR}, PR_TRUE},
391 {CKM_SHA384_HMAC_GENERAL, {1, 128, CKF_SN_VR}, PR_TRUE},
392 {CKM_SHA512, {0, 0, CKF_DIGEST}, PR_FALSE},
393 {CKM_SHA512_HMAC, {1, 128, CKF_SN_VR}, PR_TRUE},
394 {CKM_SHA512_HMAC_GENERAL, {1, 128, CKF_SN_VR}, PR_TRUE},
395 {CKM_TLS_PRF_GENERAL, {0, 512, CKF_SN_VR}, PR_FALSE},
396 {CKM_NSS_TLS_PRF_GENERAL_SHA256,
397 {0, 512, CKF_SN_VR}, PR_FALSE},
398 /* ------------------------- HKDF Operations -------------------------- */
399 {CKM_NSS_HKDF_SHA1, {1, 128, CKF_DERIVE}, PR_TRUE},
400 {CKM_NSS_HKDF_SHA256, {1, 128, CKF_DERIVE}, PR_TRUE},
401 {CKM_NSS_HKDF_SHA384, {1, 128, CKF_DERIVE}, PR_TRUE},
402 {CKM_NSS_HKDF_SHA512, {1, 128, CKF_DERIVE}, PR_TRUE},
403 /* ------------------------- CAST Operations --------------------------- */
404 #ifdef NSS_SOFTOKEN_DOES_CAST
405 /* Cast operations are not supported ( yet? ) */
406 {CKM_CAST_KEY_GEN, {1, 8, CKF_GENERATE}, PR_TRUE},
407 {CKM_CAST_ECB, {1, 8, CKF_EN_DE_WR_UN}, PR_TRUE},
408 {CKM_CAST_CBC, {1, 8, CKF_EN_DE_WR_UN}, PR_TRUE},
409 {CKM_CAST_MAC, {1, 8, CKF_SN_VR}, PR_TRUE},
410 {CKM_CAST_MAC_GENERAL, {1, 8, CKF_SN_VR}, PR_TRUE},
411 {CKM_CAST_CBC_PAD, {1, 8, CKF_EN_DE_WR_UN}, PR_TRUE},
412 {CKM_CAST3_KEY_GEN, {1, 16, CKF_GENERATE}, PR_TRUE},
413 {CKM_CAST3_ECB, {1, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
414 {CKM_CAST3_CBC, {1, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
415 {CKM_CAST3_MAC, {1, 16, CKF_SN_VR}, PR_TRUE},
416 {CKM_CAST3_MAC_GENERAL, {1, 16, CKF_SN_VR}, PR_TRUE},
417 {CKM_CAST3_CBC_PAD, {1, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
418 {CKM_CAST5_KEY_GEN, {1, 16, CKF_GENERATE}, PR_TRUE},
419 {CKM_CAST5_ECB, {1, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
420 {CKM_CAST5_CBC, {1, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
421 {CKM_CAST5_MAC, {1, 16, CKF_SN_VR}, PR_TRUE},
422 {CKM_CAST5_MAC_GENERAL, {1, 16, CKF_SN_VR}, PR_TRUE},
423 {CKM_CAST5_CBC_PAD, {1, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
424 #endif
425 #if NSS_SOFTOKEN_DOES_RC5
426 /* ------------------------- RC5 Operations --------------------------- */
427 {CKM_RC5_KEY_GEN, {1, 32, CKF_GENERATE}, PR_TRUE},
428 {CKM_RC5_ECB, {1, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
429 {CKM_RC5_CBC, {1, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
430 {CKM_RC5_MAC, {1, 32, CKF_SN_VR}, PR_TRUE},
431 {CKM_RC5_MAC_GENERAL, {1, 32, CKF_SN_VR}, PR_TRUE},
432 {CKM_RC5_CBC_PAD, {1, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
433 #endif
434 #ifdef NSS_SOFTOKEN_DOES_IDEA
435 /* ------------------------- IDEA Operations -------------------------- */
436 {CKM_IDEA_KEY_GEN, {16, 16, CKF_GENERATE}, PR_TRUE},
437 {CKM_IDEA_ECB, {16, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
438 {CKM_IDEA_CBC, {16, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
439 {CKM_IDEA_MAC, {16, 16, CKF_SN_VR}, PR_TRUE},
440 {CKM_IDEA_MAC_GENERAL, {16, 16, CKF_SN_VR}, PR_TRUE},
441 {CKM_IDEA_CBC_PAD, {16, 16, CKF_EN_DE_WR_UN}, PR_TRUE},
442 #endif
443 /* --------------------- Secret Key Operations ------------------------ */
444 {CKM_GENERIC_SECRET_KEY_GEN, {1, 32, CKF_GENERATE}, PR_TRUE},
445 {CKM_CONCATENATE_BASE_AND_KEY, {1, 32, CKF_GENERATE}, PR_FALSE},
446 {CKM_CONCATENATE_BASE_AND_DATA, {1, 32, CKF_GENERATE}, PR_FALSE},
447 {CKM_CONCATENATE_DATA_AND_BASE, {1, 32, CKF_GENERATE}, PR_FALSE},
448 {CKM_XOR_BASE_AND_DATA, {1, 32, CKF_GENERATE}, PR_FALSE},
449 {CKM_EXTRACT_KEY_FROM_KEY, {1, 32, CKF_DERIVE}, PR_FALSE},
450 /* ---------------------- SSL Key Derivations ------------------------- */
451 {CKM_SSL3_PRE_MASTER_KEY_GEN, {48, 48, CKF_GENERATE}, PR_FALSE},
452 {CKM_SSL3_MASTER_KEY_DERIVE, {48, 48, CKF_DERIVE}, PR_FALSE},
453 {CKM_SSL3_MASTER_KEY_DERIVE_DH, {8, 128, CKF_DERIVE}, PR_FALSE},
454 {CKM_SSL3_KEY_AND_MAC_DERIVE, {48, 48, CKF_DERIVE}, PR_FALSE},
455 {CKM_SSL3_MD5_MAC, { 0, 16, CKF_DERIVE}, PR_FALSE},
456 {CKM_SSL3_SHA1_MAC, { 0, 20, CKF_DERIVE}, PR_FALSE},
457 {CKM_MD5_KEY_DERIVATION, { 0, 16, CKF_DERIVE}, PR_FALSE},
458 {CKM_MD2_KEY_DERIVATION, { 0, 16, CKF_DERIVE}, PR_FALSE},
459 {CKM_SHA1_KEY_DERIVATION, { 0, 20, CKF_DERIVE}, PR_FALSE},
460 {CKM_SHA224_KEY_DERIVATION, { 0, 28, CKF_DERIVE}, PR_FALSE},
461 {CKM_SHA256_KEY_DERIVATION, { 0, 32, CKF_DERIVE}, PR_FALSE},
462 {CKM_SHA384_KEY_DERIVATION, { 0, 48, CKF_DERIVE}, PR_FALSE},
463 {CKM_SHA512_KEY_DERIVATION, { 0, 64, CKF_DERIVE}, PR_FALSE},
464 {CKM_TLS_MASTER_KEY_DERIVE, {48, 48, CKF_DERIVE}, PR_FALSE},
465 {CKM_NSS_TLS_MASTER_KEY_DERIVE_SHA256,
466 {48, 48, CKF_DERIVE}, PR_FALSE},
467 {CKM_TLS_MASTER_KEY_DERIVE_DH, {8, 128, CKF_DERIVE}, PR_FALSE},
468 {CKM_NSS_TLS_MASTER_KEY_DERIVE_DH_SHA256,
469 {8, 128, CKF_DERIVE}, PR_FALSE},
470 {CKM_TLS_KEY_AND_MAC_DERIVE, {48, 48, CKF_DERIVE}, PR_FALSE},
471 {CKM_NSS_TLS_KEY_AND_MAC_DERIVE_SHA256,
472 {48, 48, CKF_DERIVE}, PR_FALSE},
473 /* ---------------------- PBE Key Derivations ------------------------ */
474 {CKM_PBE_MD2_DES_CBC, {8, 8, CKF_DERIVE}, PR_TRUE},
475 {CKM_PBE_MD5_DES_CBC, {8, 8, CKF_DERIVE}, PR_TRUE},
476 /* ------------------ NETSCAPE PBE Key Derivations ------------------- */
477 {CKM_NETSCAPE_PBE_SHA1_DES_CBC, { 8, 8, CKF_GENERATE}, PR_TRUE},
478 {CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC, {24,24, CKF_GENERATE}, PR_TRUE},
479 {CKM_PBE_SHA1_DES3_EDE_CBC, {24,24, CKF_GENERATE}, PR_TRUE},
480 {CKM_PBE_SHA1_DES2_EDE_CBC, {24,24, CKF_GENERATE}, PR_TRUE},
481 {CKM_PBE_SHA1_RC2_40_CBC, {40,40, CKF_GENERATE}, PR_TRUE},
482 {CKM_PBE_SHA1_RC2_128_CBC, {128,128, CKF_GENERATE}, PR_TRUE},
483 {CKM_PBE_SHA1_RC4_40, {40,40, CKF_GENERATE}, PR_TRUE},
484 {CKM_PBE_SHA1_RC4_128, {128,128, CKF_GENERATE}, PR_TRUE},
485 {CKM_PBA_SHA1_WITH_SHA1_HMAC, {20,20, CKF_GENERATE}, PR_TRUE},
486 {CKM_PKCS5_PBKD2, {1,256, CKF_GENERATE}, PR_TRUE},
487 {CKM_NETSCAPE_PBE_SHA1_HMAC_KEY_GEN, {20,20, CKF_GENERATE}, PR_TRUE},
488 {CKM_NETSCAPE_PBE_MD5_HMAC_KEY_GEN, {16,16, CKF_GENERATE}, PR_TRUE},
489 {CKM_NETSCAPE_PBE_MD2_HMAC_KEY_GEN, {16,16, CKF_GENERATE}, PR_TRUE},
490 /* ------------------ AES Key Wrap (also encrypt) ------------------- */
491 {CKM_NETSCAPE_AES_KEY_WRAP, {16, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
492 {CKM_NETSCAPE_AES_KEY_WRAP_PAD, {16, 32, CKF_EN_DE_WR_UN}, PR_TRUE},
493 /* --------------------------- J-PAKE -------------------------------- */
494 {CKM_NSS_JPAKE_ROUND1_SHA1, {0, 0, CKF_GENERATE}, PR_TRUE},
495 {CKM_NSS_JPAKE_ROUND1_SHA256, {0, 0, CKF_GENERATE}, PR_TRUE},
496 {CKM_NSS_JPAKE_ROUND1_SHA384, {0, 0, CKF_GENERATE}, PR_TRUE},
497 {CKM_NSS_JPAKE_ROUND1_SHA512, {0, 0, CKF_GENERATE}, PR_TRUE},
498 {CKM_NSS_JPAKE_ROUND2_SHA1, {0, 0, CKF_DERIVE}, PR_TRUE},
499 {CKM_NSS_JPAKE_ROUND2_SHA256, {0, 0, CKF_DERIVE}, PR_TRUE},
500 {CKM_NSS_JPAKE_ROUND2_SHA384, {0, 0, CKF_DERIVE}, PR_TRUE},
501 {CKM_NSS_JPAKE_ROUND2_SHA512, {0, 0, CKF_DERIVE}, PR_TRUE},
502 {CKM_NSS_JPAKE_FINAL_SHA1, {0, 0, CKF_DERIVE}, PR_TRUE},
503 {CKM_NSS_JPAKE_FINAL_SHA256, {0, 0, CKF_DERIVE}, PR_TRUE},
504 {CKM_NSS_JPAKE_FINAL_SHA384, {0, 0, CKF_DERIVE}, PR_TRUE},
505 {CKM_NSS_JPAKE_FINAL_SHA512, {0, 0, CKF_DERIVE}, PR_TRUE},
506 /* -------------------- Constant Time TLS MACs ----------------------- */
507 {CKM_NSS_HMAC_CONSTANT_TIME, {0, 0, CKF_DIGEST}, PR_TRUE},
508 {CKM_NSS_SSL3_MAC_CONSTANT_TIME, {0, 0, CKF_DIGEST}, PR_TRUE}
509 };
510 static const CK_ULONG mechanismCount = sizeof(mechanisms)/sizeof(mechanisms[0]);
511
512 /* sigh global so fipstokn can read it */
513 PRBool nsc_init = PR_FALSE;
514
515 #if defined(CHECK_FORK_PTHREAD) || defined(CHECK_FORK_MIXED)
516
517 #include <pthread.h>
518
519 static void ForkedChild(void)
520 {
521 if (nsc_init || nsf_init) {
522 forked = PR_TRUE;
523 }
524 }
525
526 #endif
527
528 static char *
529 sftk_setStringName(const char *inString, char *buffer, int buffer_length, PRBool nullTerminate)
530 {
531 int full_length, string_length;
532
533 full_length = nullTerminate ? buffer_length -1 : buffer_length;
534 string_length = PORT_Strlen(inString);
535 /*
536 * shorten the string, respecting utf8 encoding
537 * to do so, we work backward from the end
538 * bytes looking from the end are either:
539 * - ascii [0x00,0x7f]
540 * - the [2-n]th byte of a multibyte sequence
541 * [0x3F,0xBF], i.e, most significant 2 bits are '10'
542 * - the first byte of a multibyte sequence [0xC0,0xFD],
543 * i.e, most significant 2 bits are '11'
544 *
545 * When the string is too long, we lop off any trailing '10' bytes,
546 * if any. When these are all eliminated we lop off
547 * one additional byte. Thus if we lopped any '10'
548 * we'll be lopping a '11' byte (the first byte of the multibyte sequence),
549 * otherwise we're lopping off an ascii character.
550 *
551 * To test for '10' bytes, we first AND it with
552 * 11000000 (0xc0) so that we get 10000000 (0x80) if and only if
553 * the byte starts with 10. We test for equality.
554 */
555 while ( string_length > full_length ) {
556 /* need to shorten */
557 while ( string_length > 0 &&
558 ((inString[string_length-1]&(char)0xc0) == (char)0x80)) {
559 /* lop off '10' byte */
560 string_length--;
561 }
562 /*
563 * test string_length in case bad data is received
564 * and string consisted of all '10' bytes,
565 * avoiding any infinite loop
566 */
567 if ( string_length ) {
568 /* remove either '11' byte or an asci byte */
569 string_length--;
570 }
571 }
572 PORT_Memset(buffer,' ',full_length);
573 if (nullTerminate) {
574 buffer[full_length] = 0;
575 }
576 PORT_Memcpy(buffer,inString,string_length);
577 return buffer;
578 }
579 /*
580 * Configuration utils
581 */
582 static CK_RV
583 sftk_configure(const char *man, const char *libdes)
584 {
585
586 /* make sure the internationalization was done correctly... */
587 if (man) {
588 manufacturerID = sftk_setStringName(man,manufacturerID_space,
589 sizeof(manufacturerID_space), PR_TRUE);
590 }
591 if (libdes) {
592 libraryDescription = sftk_setStringName(libdes,
593 libraryDescription_space, sizeof(libraryDescription_space),
594 PR_TRUE);
595 }
596
597 return CKR_OK;
598 }
599
600 /*
601 * ******************** Password Utilities *******************************
602 */
603
604 /*
605 * see if the key DB password is enabled
606 */
607 static PRBool
608 sftk_hasNullPassword(SFTKSlot *slot, SFTKDBHandle *keydb)
609 {
610 PRBool pwenabled;
611
612 pwenabled = PR_FALSE;
613 if (sftkdb_HasPasswordSet(keydb) == SECSuccess) {
614 PRBool tokenRemoved = PR_FALSE;
615 SECStatus rv = sftkdb_CheckPassword(keydb, "", &tokenRemoved);
616 if (tokenRemoved) {
617 sftk_CloseAllSessions(slot, PR_FALSE);
618 }
619 return (rv == SECSuccess);
620 }
621
622 return pwenabled;
623 }
624
625 /*
626 * ******************** Object Creation Utilities ***************************
627 */
628
629
630 /* Make sure a given attribute exists. If it doesn't, initialize it to
631 * value and len
632 */
633 CK_RV
634 sftk_defaultAttribute(SFTKObject *object,CK_ATTRIBUTE_TYPE type,
635 const void *value, unsigned int len)
636 {
637 if ( !sftk_hasAttribute(object, type)) {
638 return sftk_AddAttributeType(object,type,value,len);
639 }
640 return CKR_OK;
641 }
642
643 /*
644 * check the consistancy and initialize a Data Object
645 */
646 static CK_RV
647 sftk_handleDataObject(SFTKSession *session,SFTKObject *object)
648 {
649 CK_RV crv;
650
651 /* first reject private and token data objects */
652 if (sftk_isTrue(object,CKA_PRIVATE) || sftk_isTrue(object,CKA_TOKEN)) {
653 return CKR_ATTRIBUTE_VALUE_INVALID;
654 }
655
656 /* now just verify the required date fields */
657 crv = sftk_defaultAttribute(object,CKA_APPLICATION,NULL,0);
658 if (crv != CKR_OK) return crv;
659 crv = sftk_defaultAttribute(object,CKA_VALUE,NULL,0);
660 if (crv != CKR_OK) return crv;
661
662 return CKR_OK;
663 }
664
665 /*
666 * check the consistancy and initialize a Certificate Object
667 */
668 static CK_RV
669 sftk_handleCertObject(SFTKSession *session,SFTKObject *object)
670 {
671 CK_CERTIFICATE_TYPE type;
672 SFTKAttribute *attribute;
673 CK_RV crv;
674
675 /* certificates must have a type */
676 if ( !sftk_hasAttribute(object,CKA_CERTIFICATE_TYPE) ) {
677 return CKR_TEMPLATE_INCOMPLETE;
678 }
679
680 /* we can't store any certs private */
681 if (sftk_isTrue(object,CKA_PRIVATE)) {
682 return CKR_ATTRIBUTE_VALUE_INVALID;
683 }
684
685 /* We only support X.509 Certs for now */
686 attribute = sftk_FindAttribute(object,CKA_CERTIFICATE_TYPE);
687 if (attribute == NULL) return CKR_TEMPLATE_INCOMPLETE;
688 type = *(CK_CERTIFICATE_TYPE *)attribute->attrib.pValue;
689 sftk_FreeAttribute(attribute);
690
691 if (type != CKC_X_509) {
692 return CKR_ATTRIBUTE_VALUE_INVALID;
693 }
694
695 /* X.509 Certificate */
696
697 /* make sure we have a cert */
698 if ( !sftk_hasAttribute(object,CKA_VALUE) ) {
699 return CKR_TEMPLATE_INCOMPLETE;
700 }
701
702 /* in PKCS #11, Subject is a required field */
703 if ( !sftk_hasAttribute(object,CKA_SUBJECT) ) {
704 return CKR_TEMPLATE_INCOMPLETE;
705 }
706
707 /* in PKCS #11, Issuer is a required field */
708 if ( !sftk_hasAttribute(object,CKA_ISSUER) ) {
709 return CKR_TEMPLATE_INCOMPLETE;
710 }
711
712 /* in PKCS #11, Serial is a required field */
713 if ( !sftk_hasAttribute(object,CKA_SERIAL_NUMBER) ) {
714 return CKR_TEMPLATE_INCOMPLETE;
715 }
716
717 /* add it to the object */
718 object->objectInfo = NULL;
719 object->infoFree = (SFTKFree) NULL;
720
721 /* now just verify the required date fields */
722 crv = sftk_defaultAttribute(object, CKA_ID, NULL, 0);
723 if (crv != CKR_OK) { return crv; }
724
725 if (sftk_isTrue(object,CKA_TOKEN)) {
726 SFTKSlot *slot = session->slot;
727 SFTKDBHandle *certHandle = sftk_getCertDB(slot);
728
729 if (certHandle == NULL) {
730 return CKR_TOKEN_WRITE_PROTECTED;
731 }
732
733 crv = sftkdb_write(certHandle, object, &object->handle);
734 sftk_freeDB(certHandle);
735 return crv;
736 }
737
738 return CKR_OK;
739 }
740
741 /*
742 * check the consistancy and initialize a Trust Object
743 */
744 static CK_RV
745 sftk_handleTrustObject(SFTKSession *session,SFTKObject *object)
746 {
747 /* we can't store any certs private */
748 if (sftk_isTrue(object,CKA_PRIVATE)) {
749 return CKR_ATTRIBUTE_VALUE_INVALID;
750 }
751
752 /* certificates must have a type */
753 if ( !sftk_hasAttribute(object,CKA_ISSUER) ) {
754 return CKR_TEMPLATE_INCOMPLETE;
755 }
756 if ( !sftk_hasAttribute(object,CKA_SERIAL_NUMBER) ) {
757 return CKR_TEMPLATE_INCOMPLETE;
758 }
759 if ( !sftk_hasAttribute(object,CKA_CERT_SHA1_HASH) ) {
760 return CKR_TEMPLATE_INCOMPLETE;
761 }
762 if ( !sftk_hasAttribute(object,CKA_CERT_MD5_HASH) ) {
763 return CKR_TEMPLATE_INCOMPLETE;
764 }
765
766 if (sftk_isTrue(object,CKA_TOKEN)) {
767 SFTKSlot *slot = session->slot;
768 SFTKDBHandle *certHandle = sftk_getCertDB(slot);
769 CK_RV crv;
770
771 if (certHandle == NULL) {
772 return CKR_TOKEN_WRITE_PROTECTED;
773 }
774
775 crv = sftkdb_write(certHandle, object, &object->handle);
776 sftk_freeDB(certHandle);
777 return crv;
778 }
779
780 return CKR_OK;
781 }
782
783 /*
784 * check the consistancy and initialize a Trust Object
785 */
786 static CK_RV
787 sftk_handleSMimeObject(SFTKSession *session,SFTKObject *object)
788 {
789
790 /* we can't store any certs private */
791 if (sftk_isTrue(object,CKA_PRIVATE)) {
792 return CKR_ATTRIBUTE_VALUE_INVALID;
793 }
794
795 /* certificates must have a type */
796 if ( !sftk_hasAttribute(object,CKA_SUBJECT) ) {
797 return CKR_TEMPLATE_INCOMPLETE;
798 }
799 if ( !sftk_hasAttribute(object,CKA_NETSCAPE_EMAIL) ) {
800 return CKR_TEMPLATE_INCOMPLETE;
801 }
802
803 if (sftk_isTrue(object,CKA_TOKEN)) {
804 SFTKSlot *slot = session->slot;
805 SFTKDBHandle *certHandle;
806 CK_RV crv;
807
808 PORT_Assert(slot);
809 if (slot == NULL) {
810 return CKR_SESSION_HANDLE_INVALID;
811 }
812
813 certHandle = sftk_getCertDB(slot);
814 if (certHandle == NULL) {
815 return CKR_TOKEN_WRITE_PROTECTED;
816 }
817
818 crv = sftkdb_write(certHandle, object, &object->handle);
819 sftk_freeDB(certHandle);
820 return crv;
821 }
822
823 return CKR_OK;
824 }
825
826 /*
827 * check the consistancy and initialize a Trust Object
828 */
829 static CK_RV
830 sftk_handleCrlObject(SFTKSession *session,SFTKObject *object)
831 {
832
833 /* we can't store any certs private */
834 if (sftk_isTrue(object,CKA_PRIVATE)) {
835 return CKR_ATTRIBUTE_VALUE_INVALID;
836 }
837
838 /* certificates must have a type */
839 if ( !sftk_hasAttribute(object,CKA_SUBJECT) ) {
840 return CKR_TEMPLATE_INCOMPLETE;
841 }
842 if ( !sftk_hasAttribute(object,CKA_VALUE) ) {
843 return CKR_TEMPLATE_INCOMPLETE;
844 }
845
846 if (sftk_isTrue(object,CKA_TOKEN)) {
847 SFTKSlot *slot = session->slot;
848 SFTKDBHandle *certHandle = sftk_getCertDB(slot);
849 CK_RV crv;
850
851 if (certHandle == NULL) {
852 return CKR_TOKEN_WRITE_PROTECTED;
853 }
854
855 crv = sftkdb_write(certHandle, object, &object->handle);
856 sftk_freeDB(certHandle);
857 return crv;
858 }
859
860 return CKR_OK;
861 }
862
863 /*
864 * check the consistancy and initialize a Public Key Object
865 */
866 static CK_RV
867 sftk_handlePublicKeyObject(SFTKSession *session, SFTKObject *object,
868 CK_KEY_TYPE key_type)
869 {
870 CK_BBOOL encrypt = CK_TRUE;
871 CK_BBOOL recover = CK_TRUE;
872 CK_BBOOL wrap = CK_TRUE;
873 CK_BBOOL derive = CK_FALSE;
874 CK_BBOOL verify = CK_TRUE;
875 CK_RV crv;
876
877 switch (key_type) {
878 case CKK_RSA:
879 crv = sftk_ConstrainAttribute(object, CKA_MODULUS,
880 RSA_MIN_MODULUS_BITS, 0, 0);
881 if (crv != CKR_OK) {
882 return crv;
883 }
884 crv = sftk_ConstrainAttribute(object, CKA_PUBLIC_EXPONENT, 2, 0, 0);
885 if (crv != CKR_OK) {
886 return crv;
887 }
888 break;
889 case CKK_DSA:
890 crv = sftk_ConstrainAttribute(object, CKA_SUBPRIME,
891 DSA_MIN_Q_BITS, DSA_MAX_Q_BITS, 0);
892 if (crv != CKR_OK) {
893 return crv;
894 }
895 crv = sftk_ConstrainAttribute(object, CKA_PRIME,
896 DSA_MIN_P_BITS, DSA_MAX_P_BITS, 64);
897 if (crv != CKR_OK) {
898 return crv;
899 }
900 crv = sftk_ConstrainAttribute(object, CKA_BASE, 2, DSA_MAX_P_BITS, 0);
901 if (crv != CKR_OK) {
902 return crv;
903 }
904 crv = sftk_ConstrainAttribute(object, CKA_VALUE, 2, DSA_MAX_P_BITS, 0);
905 if (crv != CKR_OK) {
906 return crv;
907 }
908 encrypt = CK_FALSE;
909 recover = CK_FALSE;
910 wrap = CK_FALSE;
911 break;
912 case CKK_DH:
913 crv = sftk_ConstrainAttribute(object, CKA_PRIME,
914 DH_MIN_P_BITS, DH_MAX_P_BITS, 0);
915 if (crv != CKR_OK) {
916 return crv;
917 }
918 crv = sftk_ConstrainAttribute(object, CKA_BASE, 2, DH_MAX_P_BITS, 0);
919 if (crv != CKR_OK) {
920 return crv;
921 }
922 crv = sftk_ConstrainAttribute(object, CKA_VALUE, 2, DH_MAX_P_BITS, 0);
923 if (crv != CKR_OK) {
924 return crv;
925 }
926 verify = CK_FALSE;
927 derive = CK_TRUE;
928 encrypt = CK_FALSE;
929 recover = CK_FALSE;
930 wrap = CK_FALSE;
931 break;
932 #ifndef NSS_DISABLE_ECC
933 case CKK_EC:
934 if ( !sftk_hasAttribute(object, CKA_EC_PARAMS)) {
935 return CKR_TEMPLATE_INCOMPLETE;
936 }
937 if ( !sftk_hasAttribute(object, CKA_EC_POINT)) {
938 return CKR_TEMPLATE_INCOMPLETE;
939 }
940 derive = CK_TRUE; /* for ECDH */
941 verify = CK_TRUE; /* for ECDSA */
942 encrypt = CK_FALSE;
943 recover = CK_FALSE;
944 wrap = CK_FALSE;
945 break;
946 #endif /* NSS_DISABLE_ECC */
947 default:
948 return CKR_ATTRIBUTE_VALUE_INVALID;
949 }
950
951 /* make sure the required fields exist */
952 crv = sftk_defaultAttribute(object,CKA_SUBJECT,NULL,0);
953 if (crv != CKR_OK) return crv;
954 crv = sftk_defaultAttribute(object,CKA_ENCRYPT,&encrypt,sizeof(CK_BBOOL));
955 if (crv != CKR_OK) return crv;
956 crv = sftk_defaultAttribute(object,CKA_VERIFY,&verify,sizeof(CK_BBOOL));
957 if (crv != CKR_OK) return crv;
958 crv = sftk_defaultAttribute(object,CKA_VERIFY_RECOVER,
959 &recover,sizeof(CK_BBOOL));
960 if (crv != CKR_OK) return crv;
961 crv = sftk_defaultAttribute(object,CKA_WRAP,&wrap,sizeof(CK_BBOOL));
962 if (crv != CKR_OK) return crv;
963 crv = sftk_defaultAttribute(object,CKA_DERIVE,&derive,sizeof(CK_BBOOL));
964 if (crv != CKR_OK) return crv;
965
966 object->objectInfo = sftk_GetPubKey(object,key_type, &crv);
967 if (object->objectInfo == NULL) {
968 return crv;
969 }
970 object->infoFree = (SFTKFree) nsslowkey_DestroyPublicKey;
971
972 /* Check that an imported EC key is valid */
973 if (key_type == CKK_EC) {
974 NSSLOWKEYPublicKey *pubKey = (NSSLOWKEYPublicKey*) object->objectInfo;
975 SECStatus rv = EC_ValidatePublicKey(&pubKey->u.ec.ecParams,
976 &pubKey->u.ec.publicValue);
977
978 if (rv != SECSuccess) {
979 return CKR_TEMPLATE_INCONSISTENT;
980 }
981 }
982
983 if (sftk_isTrue(object,CKA_TOKEN)) {
984 SFTKSlot *slot = session->slot;
985 SFTKDBHandle *certHandle = sftk_getCertDB(slot);
986
987 if (certHandle == NULL) {
988 return CKR_TOKEN_WRITE_PROTECTED;
989 }
990
991 crv = sftkdb_write(certHandle, object, &object->handle);
992 sftk_freeDB(certHandle);
993 return crv;
994 }
995
996 return CKR_OK;
997 }
998
999 static NSSLOWKEYPrivateKey *
1000 sftk_mkPrivKey(SFTKObject *object,CK_KEY_TYPE key, CK_RV *rvp);
1001
1002 static SECStatus
1003 sftk_verifyRSAPrivateKey(SFTKObject *object, PRBool fillIfNeeded);
1004
1005 /*
1006 * check the consistancy and initialize a Private Key Object
1007 */
1008 static CK_RV
1009 sftk_handlePrivateKeyObject(SFTKSession *session,SFTKObject *object,CK_KEY_TYPE key_type)
1010 {
1011 CK_BBOOL cktrue = CK_TRUE;
1012 CK_BBOOL encrypt = CK_TRUE;
1013 CK_BBOOL sign = CK_FALSE;
1014 CK_BBOOL recover = CK_TRUE;
1015 CK_BBOOL wrap = CK_TRUE;
1016 CK_BBOOL derive = CK_TRUE;
1017 CK_BBOOL ckfalse = CK_FALSE;
1018 PRBool createObjectInfo = PR_TRUE;
1019 PRBool fillPrivateKey = PR_FALSE;
1020 int missing_rsa_mod_component = 0;
1021 int missing_rsa_exp_component = 0;
1022 int missing_rsa_crt_component = 0;
1023
1024 SECItem mod;
1025 CK_RV crv;
1026 SECStatus rv;
1027
1028 switch (key_type) {
1029 case CKK_RSA:
1030 if ( !sftk_hasAttribute(object, CKA_MODULUS)) {
1031 missing_rsa_mod_component++;
1032 }
1033 if ( !sftk_hasAttribute(object, CKA_PUBLIC_EXPONENT)) {
1034 missing_rsa_exp_component++;
1035 }
1036 if ( !sftk_hasAttribute(object, CKA_PRIVATE_EXPONENT)) {
1037 missing_rsa_exp_component++;
1038 }
1039 if ( !sftk_hasAttribute(object, CKA_PRIME_1)) {
1040 missing_rsa_mod_component++;
1041 }
1042 if ( !sftk_hasAttribute(object, CKA_PRIME_2)) {
1043 missing_rsa_mod_component++;
1044 }
1045 if ( !sftk_hasAttribute(object, CKA_EXPONENT_1)) {
1046 missing_rsa_crt_component++;
1047 }
1048 if ( !sftk_hasAttribute(object, CKA_EXPONENT_2)) {
1049 missing_rsa_crt_component++;
1050 }
1051 if ( !sftk_hasAttribute(object, CKA_COEFFICIENT)) {
1052 missing_rsa_crt_component++;
1053 }
1054 if (missing_rsa_mod_component || missing_rsa_exp_component ||
1055 missing_rsa_crt_component) {
1056 /* we are missing a component, see if we have enough to rebuild
1057 * the rest */
1058 int have_exp = 2- missing_rsa_exp_component;
1059 int have_component = 5-
1060 (missing_rsa_exp_component+missing_rsa_mod_component);
1061
1062 if ((have_exp == 0) || (have_component < 3)) {
1063 /* nope, not enough to reconstruct the private key */
1064 return CKR_TEMPLATE_INCOMPLETE;
1065 }
1066 fillPrivateKey = PR_TRUE;
1067 }
1068 /*verify the parameters for consistency*/
1069 rv = sftk_verifyRSAPrivateKey(object, fillPrivateKey);
1070 if (rv != SECSuccess) {
1071 return CKR_TEMPLATE_INCOMPLETE;
1072 }
1073
1074 /* make sure Netscape DB attribute is set correctly */
1075 crv = sftk_Attribute2SSecItem(NULL, &mod, object, CKA_MODULUS);
1076 if (crv != CKR_OK) return crv;
1077 crv = sftk_forceAttribute(object, CKA_NETSCAPE_DB,
1078 sftk_item_expand(&mod));
1079 if (mod.data) PORT_Free(mod.data);
1080 if (crv != CKR_OK) return crv;
1081
1082 sign = CK_TRUE;
1083 derive = CK_FALSE;
1084 break;
1085 case CKK_DSA:
1086 if ( !sftk_hasAttribute(object, CKA_SUBPRIME)) {
1087 return CKR_TEMPLATE_INCOMPLETE;
1088 }
1089 sign = CK_TRUE;
1090 derive = CK_FALSE;
1091 /* fall through */
1092 case CKK_DH:
1093 if ( !sftk_hasAttribute(object, CKA_PRIME)) {
1094 return CKR_TEMPLATE_INCOMPLETE;
1095 }
1096 if ( !sftk_hasAttribute(object, CKA_BASE)) {
1097 return CKR_TEMPLATE_INCOMPLETE;
1098 }
1099 if ( !sftk_hasAttribute(object, CKA_VALUE)) {
1100 return CKR_TEMPLATE_INCOMPLETE;
1101 }
1102 encrypt = CK_FALSE;
1103 recover = CK_FALSE;
1104 wrap = CK_FALSE;
1105 break;
1106 #ifndef NSS_DISABLE_ECC
1107 case CKK_EC:
1108 if ( !sftk_hasAttribute(object, CKA_EC_PARAMS)) {
1109 return CKR_TEMPLATE_INCOMPLETE;
1110 }
1111 if ( !sftk_hasAttribute(object, CKA_VALUE)) {
1112 return CKR_TEMPLATE_INCOMPLETE;
1113 }
1114 encrypt = CK_FALSE;
1115 sign = CK_TRUE;
1116 recover = CK_FALSE;
1117 wrap = CK_FALSE;
1118 break;
1119 #endif /* NSS_DISABLE_ECC */
1120 case CKK_NSS_JPAKE_ROUND1:
1121 if (!sftk_hasAttribute(object, CKA_PRIME) ||
1122 !sftk_hasAttribute(object, CKA_SUBPRIME) ||
1123 !sftk_hasAttribute(object, CKA_BASE)) {
1124 return CKR_TEMPLATE_INCOMPLETE;
1125 }
1126 /* fall through */
1127 case CKK_NSS_JPAKE_ROUND2:
1128 /* CKA_NSS_JPAKE_SIGNERID and CKA_NSS_JPAKE_PEERID are checked in
1129 the J-PAKE code. */
1130 encrypt = sign = recover = wrap = CK_FALSE;
1131 derive = CK_TRUE;
1132 createObjectInfo = PR_FALSE;
1133 break;
1134 default:
1135 return CKR_ATTRIBUTE_VALUE_INVALID;
1136 }
1137 crv = sftk_defaultAttribute(object,CKA_SUBJECT,NULL,0);
1138 if (crv != CKR_OK) return crv;
1139 crv = sftk_defaultAttribute(object,CKA_SENSITIVE,&cktrue,sizeof(CK_BBOOL));
1140 if (crv != CKR_OK) return crv;
1141 crv = sftk_defaultAttribute(object,CKA_EXTRACTABLE,&cktrue,sizeof(CK_BBOOL));
1142 if (crv != CKR_OK) return crv;
1143 crv = sftk_defaultAttribute(object,CKA_DECRYPT,&encrypt,sizeof(CK_BBOOL));
1144 if (crv != CKR_OK) return crv;
1145 crv = sftk_defaultAttribute(object,CKA_SIGN,&sign,sizeof(CK_BBOOL));
1146 if (crv != CKR_OK) return crv;
1147 crv = sftk_defaultAttribute(object,CKA_SIGN_RECOVER,&recover,
1148 sizeof(CK_BBOOL));
1149 if (crv != CKR_OK) return crv;
1150 crv = sftk_defaultAttribute(object,CKA_UNWRAP,&wrap,sizeof(CK_BBOOL));
1151 if (crv != CKR_OK) return crv;
1152 crv = sftk_defaultAttribute(object,CKA_DERIVE,&derive,sizeof(CK_BBOOL));
1153 if (crv != CKR_OK) return crv;
1154 /* the next two bits get modified only in the key gen and token cases */
1155 crv = sftk_forceAttribute(object,CKA_ALWAYS_SENSITIVE,
1156 &ckfalse,sizeof(CK_BBOOL));
1157 if (crv != CKR_OK) return crv;
1158 crv = sftk_forceAttribute(object,CKA_NEVER_EXTRACTABLE,
1159 &ckfalse,sizeof(CK_BBOOL));
1160 if (crv != CKR_OK) return crv;
1161
1162 /* should we check the non-token RSA private keys? */
1163
1164 if (sftk_isTrue(object,CKA_TOKEN)) {
1165 SFTKSlot *slot = session->slot;
1166 SFTKDBHandle *keyHandle = sftk_getKeyDB(slot);
1167
1168 if (keyHandle == NULL) {
1169 return CKR_TOKEN_WRITE_PROTECTED;
1170 }
1171
1172 crv = sftkdb_write(keyHandle, object, &object->handle);
1173 sftk_freeDB(keyHandle);
1174 return crv;
1175 } else if (createObjectInfo) {
1176 object->objectInfo = sftk_mkPrivKey(object,key_type,&crv);
1177 if (object->objectInfo == NULL) return crv;
1178 object->infoFree = (SFTKFree) nsslowkey_DestroyPrivateKey;
1179 }
1180 return CKR_OK;
1181 }
1182
1183 /* forward declare the DES formating function for handleSecretKey */
1184 void sftk_FormatDESKey(unsigned char *key, int length);
1185
1186 /* Validate secret key data, and set defaults */
1187 static CK_RV
1188 validateSecretKey(SFTKSession *session, SFTKObject *object,
1189 CK_KEY_TYPE key_type, PRBool isFIPS)
1190 {
1191 CK_RV crv;
1192 CK_BBOOL cktrue = CK_TRUE;
1193 CK_BBOOL ckfalse = CK_FALSE;
1194 SFTKAttribute *attribute = NULL;
1195 unsigned long requiredLen;
1196
1197 crv = sftk_defaultAttribute(object,CKA_SENSITIVE,
1198 isFIPS?&cktrue:&ckfalse,sizeof(CK_BBOOL));
1199 if (crv != CKR_OK) return crv;
1200 crv = sftk_defaultAttribute(object,CKA_EXTRACTABLE,
1201 &cktrue,sizeof(CK_BBOOL));
1202 if (crv != CKR_OK) return crv;
1203 crv = sftk_defaultAttribute(object,CKA_ENCRYPT,&cktrue,sizeof(CK_BBOOL));
1204 if (crv != CKR_OK) return crv;
1205 crv = sftk_defaultAttribute(object,CKA_DECRYPT,&cktrue,sizeof(CK_BBOOL));
1206 if (crv != CKR_OK) return crv;
1207 crv = sftk_defaultAttribute(object,CKA_SIGN,&ckfalse,sizeof(CK_BBOOL));
1208 if (crv != CKR_OK) return crv;
1209 crv = sftk_defaultAttribute(object,CKA_VERIFY,&ckfalse,sizeof(CK_BBOOL));
1210 if (crv != CKR_OK) return crv;
1211 crv = sftk_defaultAttribute(object,CKA_WRAP,&cktrue,sizeof(CK_BBOOL));
1212 if (crv != CKR_OK) return crv;
1213 crv = sftk_defaultAttribute(object,CKA_UNWRAP,&cktrue,sizeof(CK_BBOOL));
1214 if (crv != CKR_OK) return crv;
1215
1216 if ( !sftk_hasAttribute(object, CKA_VALUE)) {
1217 return CKR_TEMPLATE_INCOMPLETE;
1218 }
1219 /* the next two bits get modified only in the key gen and token cases */
1220 crv = sftk_forceAttribute(object,CKA_ALWAYS_SENSITIVE,
1221 &ckfalse,sizeof(CK_BBOOL));
1222 if (crv != CKR_OK) return crv;
1223 crv = sftk_forceAttribute(object,CKA_NEVER_EXTRACTABLE,
1224 &ckfalse,sizeof(CK_BBOOL));
1225 if (crv != CKR_OK) return crv;
1226
1227 /* some types of keys have a value length */
1228 crv = CKR_OK;
1229 switch (key_type) {
1230 /* force CKA_VALUE_LEN to be set */
1231 case CKK_GENERIC_SECRET:
1232 case CKK_RC2:
1233 case CKK_RC4:
1234 #if NSS_SOFTOKEN_DOES_RC5
1235 case CKK_RC5:
1236 #endif
1237 #ifdef NSS_SOFTOKEN_DOES_CAST
1238 case CKK_CAST:
1239 case CKK_CAST3:
1240 case CKK_CAST5:
1241 #endif
1242 #if NSS_SOFTOKEN_DOES_IDEA
1243 case CKK_IDEA:
1244 #endif
1245 attribute = sftk_FindAttribute(object,CKA_VALUE);
1246 /* shouldn't happen */
1247 if (attribute == NULL) return CKR_TEMPLATE_INCOMPLETE;
1248 crv = sftk_forceAttribute(object, CKA_VALUE_LEN,
1249 &attribute->attrib.ulValueLen, sizeof(CK_ULONG));
1250 sftk_FreeAttribute(attribute);
1251 break;
1252 /* force the value to have the correct parity */
1253 case CKK_DES:
1254 case CKK_DES2:
1255 case CKK_DES3:
1256 case CKK_CDMF:
1257 attribute = sftk_FindAttribute(object,CKA_VALUE);
1258 /* shouldn't happen */
1259 if (attribute == NULL)
1260 return CKR_TEMPLATE_INCOMPLETE;
1261 requiredLen = sftk_MapKeySize(key_type);
1262 if (attribute->attrib.ulValueLen != requiredLen) {
1263 sftk_FreeAttribute(attribute);
1264 return CKR_KEY_SIZE_RANGE;
1265 }
1266 sftk_FormatDESKey((unsigned char*)attribute->attrib.pValue,
1267 attribute->attrib.ulValueLen);
1268 sftk_FreeAttribute(attribute);
1269 break;
1270 case CKK_AES:
1271 attribute = sftk_FindAttribute(object,CKA_VALUE);
1272 /* shouldn't happen */
1273 if (attribute == NULL)
1274 return CKR_TEMPLATE_INCOMPLETE;
1275 if (attribute->attrib.ulValueLen != 16 &&
1276 attribute->attrib.ulValueLen != 24 &&
1277 attribute->attrib.ulValueLen != 32) {
1278 sftk_FreeAttribute(attribute);
1279 return CKR_KEY_SIZE_RANGE;
1280 }
1281 crv = sftk_forceAttribute(object, CKA_VALUE_LEN,
1282 &attribute->attrib.ulValueLen, sizeof(CK_ULONG));
1283 sftk_FreeAttribute(attribute);
1284 break;
1285 default:
1286 break;
1287 }
1288
1289 return crv;
1290 }
1291
1292 /*
1293 * check the consistancy and initialize a Secret Key Object
1294 */
1295 static CK_RV
1296 sftk_handleSecretKeyObject(SFTKSession *session,SFTKObject *object,
1297 CK_KEY_TYPE key_type, PRBool isFIPS)
1298 {
1299 CK_RV crv;
1300
1301 /* First validate and set defaults */
1302 crv = validateSecretKey(session, object, key_type, isFIPS);
1303 if (crv != CKR_OK) goto loser;
1304
1305 /* If the object is a TOKEN object, store in the database */
1306 if (sftk_isTrue(object,CKA_TOKEN)) {
1307 SFTKSlot *slot = session->slot;
1308 SFTKDBHandle *keyHandle = sftk_getKeyDB(slot);
1309 CK_RV crv;
1310
1311 if (keyHandle == NULL) {
1312 return CKR_TOKEN_WRITE_PROTECTED;
1313 }
1314
1315 crv = sftkdb_write(keyHandle, object, &object->handle);
1316 sftk_freeDB(keyHandle);
1317 return crv;
1318 }
1319
1320 loser:
1321
1322 return crv;
1323 }
1324
1325 /*
1326 * check the consistancy and initialize a Key Object
1327 */
1328 static CK_RV
1329 sftk_handleKeyObject(SFTKSession *session, SFTKObject *object)
1330 {
1331 SFTKAttribute *attribute;
1332 CK_KEY_TYPE key_type;
1333 CK_BBOOL ckfalse = CK_FALSE;
1334 CK_RV crv;
1335
1336 /* verify the required fields */
1337 if ( !sftk_hasAttribute(object,CKA_KEY_TYPE) ) {
1338 return CKR_TEMPLATE_INCOMPLETE;
1339 }
1340
1341 /* now verify the common fields */
1342 crv = sftk_defaultAttribute(object,CKA_ID,NULL,0);
1343 if (crv != CKR_OK) return crv;
1344 crv = sftk_defaultAttribute(object,CKA_START_DATE,NULL,0);
1345 if (crv != CKR_OK) return crv;
1346 crv = sftk_defaultAttribute(object,CKA_END_DATE,NULL,0);
1347 if (crv != CKR_OK) return crv;
1348 /* CKA_DERIVE is common to all keys, but it's default value is
1349 * key dependent */
1350 crv = sftk_defaultAttribute(object,CKA_LOCAL,&ckfalse,sizeof(CK_BBOOL));
1351 if (crv != CKR_OK) return crv;
1352
1353 /* get the key type */
1354 attribute = sftk_FindAttribute(object,CKA_KEY_TYPE);
1355 if (!attribute) {
1356 return CKR_ATTRIBUTE_VALUE_INVALID;
1357 }
1358 key_type = *(CK_KEY_TYPE *)attribute->attrib.pValue;
1359 sftk_FreeAttribute(attribute);
1360
1361 switch (object->objclass) {
1362 case CKO_PUBLIC_KEY:
1363 return sftk_handlePublicKeyObject(session,object,key_type);
1364 case CKO_PRIVATE_KEY:
1365 return sftk_handlePrivateKeyObject(session,object,key_type);
1366 case CKO_SECRET_KEY:
1367 /* make sure the required fields exist */
1368 return sftk_handleSecretKeyObject(session,object,key_type,
1369 (PRBool)(session->slot->slotID == FIPS_SLOT_ID));
1370 default:
1371 break;
1372 }
1373 return CKR_ATTRIBUTE_VALUE_INVALID;
1374 }
1375
1376 /*
1377 * check the consistancy and Verify a DSA Parameter Object
1378 */
1379 static CK_RV
1380 sftk_handleDSAParameterObject(SFTKSession *session, SFTKObject *object)
1381 {
1382 SFTKAttribute *primeAttr = NULL;
1383 SFTKAttribute *subPrimeAttr = NULL;
1384 SFTKAttribute *baseAttr = NULL;
1385 SFTKAttribute *seedAttr = NULL;
1386 SFTKAttribute *hAttr = NULL;
1387 SFTKAttribute *attribute;
1388 CK_RV crv = CKR_TEMPLATE_INCOMPLETE;
1389 PQGParams params;
1390 PQGVerify vfy, *verify = NULL;
1391 SECStatus result,rv;
1392 /* This bool keeps track of whether or not we need verify parameters.
1393 * If a P, Q and G or supplied, we dont' need verify parameters, as we
1394 * have PQ and G.
1395 * - If G is not supplied, the presumption is that we want to
1396 * verify P and Q only.
1397 * - If counter is supplied, it is presumed we want to verify PQ because
1398 * the counter is only used in verification.
1399 * - If H is supplied, is is presumed we want to verify G because H is
1400 * only used to verify G.
1401 * - Any verification step must have the SEED (counter or H could be
1402 * missing depending on exactly what we want to verify). If SEED is supplied,
1403 * the code just goes ahead and runs verify (other errors are parameter
1404 * errors are detected by the PQG_VerifyParams function). If SEED is not
1405 * supplied, but we determined that we are trying to verify (because needVfy
1406 * is set, go ahead and return CKR_TEMPLATE_INCOMPLETE.
1407 */
1408 PRBool needVfy = PR_FALSE;
1409
1410 primeAttr = sftk_FindAttribute(object,CKA_PRIME);
1411 if (primeAttr == NULL) goto loser;
1412 params.prime.data = primeAttr->attrib.pValue;
1413 params.prime.len = primeAttr->attrib.ulValueLen;
1414
1415 subPrimeAttr = sftk_FindAttribute(object,CKA_SUBPRIME);
1416 if (subPrimeAttr == NULL) goto loser;
1417 params.subPrime.data = subPrimeAttr->attrib.pValue;
1418 params.subPrime.len = subPrimeAttr->attrib.ulValueLen;
1419
1420 baseAttr = sftk_FindAttribute(object,CKA_BASE);
1421 if (baseAttr != NULL) {
1422 params.base.data = baseAttr->attrib.pValue;
1423 params.base.len = baseAttr->attrib.ulValueLen;
1424 } else {
1425 params.base.data = NULL;
1426 params.base.len = 0;
1427 needVfy = PR_TRUE; /* presumably only including PQ so we can verify
1428 * them. */
1429 }
1430
1431 attribute = sftk_FindAttribute(object, CKA_NETSCAPE_PQG_COUNTER);
1432 if (attribute != NULL) {
1433 vfy.counter = *(CK_ULONG *) attribute->attrib.pValue;
1434 sftk_FreeAttribute(attribute);
1435 needVfy = PR_TRUE; /* included a count so we can verify PQ */
1436 } else {
1437 vfy.counter = -1;
1438 }
1439
1440 hAttr = sftk_FindAttribute(object, CKA_NETSCAPE_PQG_H);
1441 if (hAttr != NULL) {
1442 vfy.h.data = hAttr->attrib.pValue;
1443 vfy.h.len = hAttr->attrib.ulValueLen;
1444 needVfy = PR_TRUE; /* included H so we can verify G */
1445 } else {
1446 vfy.h.data = NULL;
1447 vfy.h.len = 0;
1448 }
1449 seedAttr = sftk_FindAttribute(object, CKA_NETSCAPE_PQG_SEED);
1450 if (seedAttr != NULL) {
1451 vfy.seed.data = seedAttr->attrib.pValue;
1452 vfy.seed.len = seedAttr->attrib.ulValueLen;
1453
1454 verify = &vfy;
1455 } else if (needVfy) {
1456 goto loser; /* Verify always needs seed, if we need verify and not seed
1457 * then fail */
1458 }
1459
1460 crv = CKR_FUNCTION_FAILED;
1461 rv = PQG_VerifyParams(&params,verify,&result);
1462 if (rv == SECSuccess) {
1463 crv = (result== SECSuccess) ? CKR_OK : CKR_ATTRIBUTE_VALUE_INVALID;
1464 }
1465
1466 loser:
1467 if (hAttr) sftk_FreeAttribute(hAttr);
1468 if (seedAttr) sftk_FreeAttribute(seedAttr);
1469 if (baseAttr) sftk_FreeAttribute(baseAttr);
1470 if (subPrimeAttr) sftk_FreeAttribute(subPrimeAttr);
1471 if (primeAttr) sftk_FreeAttribute(primeAttr);
1472
1473 return crv;
1474 }
1475
1476 /*
1477 * check the consistancy and initialize a Key Parameter Object
1478 */
1479 static CK_RV
1480 sftk_handleKeyParameterObject(SFTKSession *session, SFTKObject *object)
1481 {
1482 SFTKAttribute *attribute;
1483 CK_KEY_TYPE key_type;
1484 CK_BBOOL ckfalse = CK_FALSE;
1485 CK_RV crv;
1486
1487 /* verify the required fields */
1488 if ( !sftk_hasAttribute(object,CKA_KEY_TYPE) ) {
1489 return CKR_TEMPLATE_INCOMPLETE;
1490 }
1491
1492 /* now verify the common fields */
1493 crv = sftk_defaultAttribute(object,CKA_LOCAL,&ckfalse,sizeof(CK_BBOOL));
1494 if (crv != CKR_OK) return crv;
1495
1496 /* get the key type */
1497 attribute = sftk_FindAttribute(object,CKA_KEY_TYPE);
1498 if (!attribute) {
1499 return CKR_ATTRIBUTE_VALUE_INVALID;
1500 }
1501 key_type = *(CK_KEY_TYPE *)attribute->attrib.pValue;
1502 sftk_FreeAttribute(attribute);
1503
1504 switch (key_type) {
1505 case CKK_DSA:
1506 return sftk_handleDSAParameterObject(session,object);
1507
1508 default:
1509 break;
1510 }
1511 return CKR_KEY_TYPE_INCONSISTENT;
1512 }
1513
1514 /*
1515 * Handle Object does all the object consistancy checks, automatic attribute
1516 * generation, attribute defaulting, etc. If handleObject succeeds, the object
1517 * will be assigned an object handle, and the object installed in the session
1518 * or stored in the DB.
1519 */
1520 CK_RV
1521 sftk_handleObject(SFTKObject *object, SFTKSession *session)
1522 {
1523 SFTKSlot *slot = session->slot;
1524 SFTKAttribute *attribute;
1525 SFTKObject *duplicateObject = NULL;
1526 CK_OBJECT_HANDLE handle;
1527 CK_BBOOL ckfalse = CK_FALSE;
1528 CK_BBOOL cktrue = CK_TRUE;
1529 CK_RV crv;
1530
1531 /* make sure all the base object types are defined. If not set the
1532 * defaults */
1533 crv = sftk_defaultAttribute(object,CKA_TOKEN,&ckfalse,sizeof(CK_BBOOL));
1534 if (crv != CKR_OK) return crv;
1535 crv = sftk_defaultAttribute(object,CKA_PRIVATE,&ckfalse,sizeof(CK_BBOOL));
1536 if (crv != CKR_OK) return crv;
1537 crv = sftk_defaultAttribute(object,CKA_LABEL,NULL,0);
1538 if (crv != CKR_OK) return crv;
1539 crv = sftk_defaultAttribute(object,CKA_MODIFIABLE,&cktrue,sizeof(CK_BBOOL));
1540 if (crv != CKR_OK) return crv;
1541
1542 /* don't create a private object if we aren't logged in */
1543 if ((!slot->isLoggedIn) && (slot->needLogin) &&
1544 (sftk_isTrue(object,CKA_PRIVATE))) {
1545 return CKR_USER_NOT_LOGGED_IN;
1546 }
1547
1548
1549 if (((session->info.flags & CKF_RW_SESSION) == 0) &&
1550 (sftk_isTrue(object,CKA_TOKEN))) {
1551 return CKR_SESSION_READ_ONLY;
1552 }
1553
1554 /* Assign a unique SESSION object handle to every new object,
1555 * whether it is a session object or a token object.
1556 * At this point, all new objects are structured as session objects.
1557 * Objects with the CKA_TOKEN attribute true will be turned into
1558 * token objects and will have a token object handle assigned to
1559 * them by a call to sftk_mkHandle in the handler for each object
1560 * class, invoked below.
1561 *
1562 * It may be helpful to note/remember that
1563 * sftk_narrowToXxxObject uses sftk_isToken,
1564 * sftk_isToken examines the sign bit of the object's handle, but
1565 * sftk_isTrue(...,CKA_TOKEN) examines the CKA_TOKEN attribute.
1566 */
1567 do {
1568 PRUint32 wrappedAround;
1569
1570 duplicateObject = NULL;
1571 PZ_Lock(slot->objectLock);
1572 wrappedAround = slot->sessionObjectHandleCount & SFTK_TOKEN_MASK;
1573 handle = slot->sessionObjectHandleCount & ~SFTK_TOKEN_MASK;
1574 if (!handle) /* don't allow zero handle */
1575 handle = minSessionObjectHandle;
1576 slot->sessionObjectHandleCount = (handle + 1U) | wrappedAround;
1577 /* Is there already a session object with this handle? */
1578 if (wrappedAround) {
1579 sftkqueue_find(duplicateObject, handle, slot->sessObjHashTable, \
1580 slot->sessObjHashSize);
1581 }
1582 PZ_Unlock(slot->objectLock);
1583 } while (duplicateObject != NULL);
1584 object->handle = handle;
1585
1586 /* get the object class */
1587 attribute = sftk_FindAttribute(object,CKA_CLASS);
1588 if (attribute == NULL) {
1589 return CKR_TEMPLATE_INCOMPLETE;
1590 }
1591 object->objclass = *(CK_OBJECT_CLASS *)attribute->attrib.pValue;
1592 sftk_FreeAttribute(attribute);
1593
1594 /* Now handle the specific object class.
1595 * At this point, all objects are session objects, and the session
1596 * number must be passed to the object class handlers.
1597 */
1598 switch (object->objclass) {
1599 case CKO_DATA:
1600 crv = sftk_handleDataObject(session,object);
1601 break;
1602 case CKO_CERTIFICATE:
1603 crv = sftk_handleCertObject(session,object);
1604 break;
1605 case CKO_NETSCAPE_TRUST:
1606 crv = sftk_handleTrustObject(session,object);
1607 break;
1608 case CKO_NETSCAPE_CRL:
1609 crv = sftk_handleCrlObject(session,object);
1610 break;
1611 case CKO_NETSCAPE_SMIME:
1612 crv = sftk_handleSMimeObject(session,object);
1613 break;
1614 case CKO_PRIVATE_KEY:
1615 case CKO_PUBLIC_KEY:
1616 case CKO_SECRET_KEY:
1617 crv = sftk_handleKeyObject(session,object);
1618 break;
1619 case CKO_KG_PARAMETERS:
1620 crv = sftk_handleKeyParameterObject(session,object);
1621 break;
1622 default:
1623 crv = CKR_ATTRIBUTE_VALUE_INVALID;
1624 break;
1625 }
1626
1627 /* can't fail from here on out unless the pk_handlXXX functions have
1628 * failed the request */
1629 if (crv != CKR_OK) {
1630 return crv;
1631 }
1632
1633 /* Now link the object into the slot and session structures.
1634 * If the object has a true CKA_TOKEN attribute, the above object
1635 * class handlers will have set the sign bit in the object handle,
1636 * causing the following test to be true.
1637 */
1638 if (sftk_isToken(object->handle)) {
1639 sftk_convertSessionToToken(object);
1640 } else {
1641 object->slot = slot;
1642 sftk_AddObject(session,object);
1643 }
1644
1645 return CKR_OK;
1646 }
1647
1648 /*
1649 * ******************** Public Key Utilities ***************************
1650 */
1651 /* Generate a low public key structure from an object */
1652 NSSLOWKEYPublicKey *sftk_GetPubKey(SFTKObject *object,CK_KEY_TYPE key_type,
1653 CK_RV *crvp)
1654 {
1655 NSSLOWKEYPublicKey *pubKey;
1656 PLArenaPool *arena;
1657 CK_RV crv;
1658
1659 if (object->objclass != CKO_PUBLIC_KEY) {
1660 *crvp = CKR_KEY_TYPE_INCONSISTENT;
1661 return NULL;
1662 }
1663
1664 if (sftk_isToken(object->handle)) {
1665 /* ferret out the token object handle */
1666 }
1667
1668 /* If we already have a key, use it */
1669 if (object->objectInfo) {
1670 *crvp = CKR_OK;
1671 return (NSSLOWKEYPublicKey *)object->objectInfo;
1672 }
1673
1674 /* allocate the structure */
1675 arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
1676 if (arena == NULL) {
1677 *crvp = CKR_HOST_MEMORY;
1678 return NULL;
1679 }
1680
1681 pubKey = (NSSLOWKEYPublicKey *)
1682 PORT_ArenaAlloc(arena,sizeof(NSSLOWKEYPublicKey));
1683 if (pubKey == NULL) {
1684 PORT_FreeArena(arena,PR_FALSE);
1685 *crvp = CKR_HOST_MEMORY;
1686 return NULL;
1687 }
1688
1689 /* fill in the structure */
1690 pubKey->arena = arena;
1691 switch (key_type) {
1692 case CKK_RSA:
1693 pubKey->keyType = NSSLOWKEYRSAKey;
1694 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.rsa.modulus,
1695 object,CKA_MODULUS);
1696 if (crv != CKR_OK) break;
1697 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.rsa.publicExponent,
1698 object,CKA_PUBLIC_EXPONENT);
1699 break;
1700 case CKK_DSA:
1701 pubKey->keyType = NSSLOWKEYDSAKey;
1702 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.dsa.params.prime,
1703 object,CKA_PRIME);
1704 if (crv != CKR_OK) break;
1705 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.dsa.params.subPrime,
1706 object,CKA_SUBPRIME);
1707 if (crv != CKR_OK) break;
1708 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.dsa.params.base,
1709 object,CKA_BASE);
1710 if (crv != CKR_OK) break;
1711 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.dsa.publicValue,
1712 object,CKA_VALUE);
1713 break;
1714 case CKK_DH:
1715 pubKey->keyType = NSSLOWKEYDHKey;
1716 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.dh.prime,
1717 object,CKA_PRIME);
1718 if (crv != CKR_OK) break;
1719 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.dh.base,
1720 object,CKA_BASE);
1721 if (crv != CKR_OK) break;
1722 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.dh.publicValue,
1723 object,CKA_VALUE);
1724 break;
1725 #ifndef NSS_DISABLE_ECC
1726 case CKK_EC:
1727 pubKey->keyType = NSSLOWKEYECKey;
1728 crv = sftk_Attribute2SSecItem(arena,
1729 &pubKey->u.ec.ecParams.DEREncoding,
1730 object,CKA_EC_PARAMS);
1731 if (crv != CKR_OK) break;
1732
1733 /* Fill out the rest of the ecParams structure
1734 * based on the encoded params
1735 */
1736 if (EC_FillParams(arena, &pubKey->u.ec.ecParams.DEREncoding,
1737 &pubKey->u.ec.ecParams) != SECSuccess) {
1738 crv = CKR_DOMAIN_PARAMS_INVALID;
1739 break;
1740 }
1741
1742 crv = sftk_Attribute2SSecItem(arena,&pubKey->u.ec.publicValue,
1743 object,CKA_EC_POINT);
1744 if (crv == CKR_OK) {
1745 int keyLen,curveLen;
1746
1747 curveLen = (pubKey->u.ec.ecParams.fieldID.size +7)/8;
1748 keyLen = (2*curveLen)+1;
1749
1750 /* special note: We can't just use the first byte to determine
1751 * between these 2 cases because both EC_POINT_FORM_UNCOMPRESSED
1752 * and SEC_ASN1_OCTET_STRING are 0x04 */
1753
1754 /* handle the non-DER encoded case (UNCOMPRESSED only) */
1755 if (pubKey->u.ec.publicValue.data[0] == EC_POINT_FORM_UNCOMPRESSED
1756 && pubKey->u.ec.publicValue.len == keyLen) {
1757 break; /* key was not DER encoded, no need to unwrap */
1758 }
1759
1760 /* if we ever support compressed, handle it here */
1761
1762 /* handle the encoded case */
1763 if ((pubKey->u.ec.publicValue.data[0] == SEC_ASN1_OCTET_STRING)
1764 && pubKey->u.ec.publicValue.len > keyLen) {
1765 SECItem publicValue;
1766 SECStatus rv;
1767
1768 rv = SEC_QuickDERDecodeItem(arena, &publicValue,
1769 SEC_ASN1_GET(SEC_OctetStringTemplate),
1770 &pubKey->u.ec.publicValue);
1771 /* nope, didn't decode correctly */
1772 if ((rv != SECSuccess)
1773 || (publicValue.data[0] != EC_POINT_FORM_UNCOMPRESSED)
1774 || (publicValue.len != keyLen)) {
1775 crv = CKR_ATTRIBUTE_VALUE_INVALID;
1776 break;
1777 }
1778 /* replace our previous with the decoded key */
1779 pubKey->u.ec.publicValue = publicValue;
1780 break;
1781 }
1782 crv = CKR_ATTRIBUTE_VALUE_INVALID;
1783 }
1784 break;
1785 #endif /* NSS_DISABLE_ECC */
1786 default:
1787 crv = CKR_KEY_TYPE_INCONSISTENT;
1788 break;
1789 }
1790 *crvp = crv;
1791 if (crv != CKR_OK) {
1792 PORT_FreeArena(arena,PR_FALSE);
1793 return NULL;
1794 }
1795
1796 object->objectInfo = pubKey;
1797 object->infoFree = (SFTKFree) nsslowkey_DestroyPublicKey;
1798 return pubKey;
1799 }
1800
1801 /* make a private key from a verified object */
1802 static NSSLOWKEYPrivateKey *
1803 sftk_mkPrivKey(SFTKObject *object, CK_KEY_TYPE key_type, CK_RV *crvp)
1804 {
1805 NSSLOWKEYPrivateKey *privKey;
1806 SFTKItemTemplate itemTemplate[SFTK_MAX_ITEM_TEMPLATE];
1807 int itemTemplateCount = 0;
1808 PLArenaPool *arena;
1809 CK_RV crv = CKR_OK;
1810 SECStatus rv;
1811
1812 arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
1813 if (arena == NULL) {
1814 *crvp = CKR_HOST_MEMORY;
1815 return NULL;
1816 }
1817
1818 privKey = (NSSLOWKEYPrivateKey *)
1819 PORT_ArenaZAlloc(arena,sizeof(NSSLOWKEYPrivateKey));
1820 if (privKey == NULL) {
1821 PORT_FreeArena(arena,PR_FALSE);
1822 *crvp = CKR_HOST_MEMORY;
1823 return NULL;
1824 }
1825
1826 /* in future this would be a switch on key_type */
1827 privKey->arena = arena;
1828 switch (key_type) {
1829 case CKK_RSA:
1830 privKey->keyType = NSSLOWKEYRSAKey;
1831
1832 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1833 &privKey->u.rsa.modulus,CKA_MODULUS);
1834 itemTemplateCount++;
1835 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1836 &privKey->u.rsa.publicExponent, CKA_PUBLIC_EXPONENT);
1837 itemTemplateCount++;
1838 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1839 &privKey->u.rsa.privateExponent, CKA_PRIVATE_EXPONENT);
1840 itemTemplateCount++;
1841 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1842 &privKey->u.rsa.prime1, CKA_PRIME_1);
1843 itemTemplateCount++;
1844 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1845 &privKey->u.rsa.prime2, CKA_PRIME_2);
1846 itemTemplateCount++;
1847 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1848 &privKey->u.rsa.exponent1, CKA_EXPONENT_1);
1849 itemTemplateCount++;
1850 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1851 &privKey->u.rsa.exponent2, CKA_EXPONENT_2);
1852 itemTemplateCount++;
1853 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1854 &privKey->u.rsa.coefficient, CKA_COEFFICIENT);
1855 itemTemplateCount++;
1856 rv = DER_SetUInteger(privKey->arena, &privKey->u.rsa.version,
1857 NSSLOWKEY_PRIVATE_KEY_INFO_VERSION);
1858 if (rv != SECSuccess) crv = CKR_HOST_MEMORY;
1859 break;
1860
1861 case CKK_DSA:
1862 privKey->keyType = NSSLOWKEYDSAKey;
1863 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1864 &privKey->u.dsa.params.prime, CKA_PRIME);
1865 itemTemplateCount++;
1866 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1867 &privKey->u.dsa.params.subPrime, CKA_SUBPRIME);
1868 itemTemplateCount++;
1869 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1870 &privKey->u.dsa.params.base, CKA_BASE);
1871 itemTemplateCount++;
1872 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1873 &privKey->u.dsa.privateValue, CKA_VALUE);
1874 itemTemplateCount++;
1875 /* privKey was zero'd so public value is already set to NULL, 0
1876 * if we don't set it explicitly */
1877 break;
1878
1879 case CKK_DH:
1880 privKey->keyType = NSSLOWKEYDHKey;
1881 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1882 &privKey->u.dh.prime, CKA_PRIME);
1883 itemTemplateCount++;
1884 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1885 &privKey->u.dh.base, CKA_BASE);
1886 itemTemplateCount++;
1887 SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
1888 &privKey->u.dh.privateValue, CKA_VALUE);
1889 itemTemplateCount++;
1890 /* privKey was zero'd so public value is already set to NULL, 0
1891 * if we don't set it explicitly */
1892 break;
1893
1894 #ifndef NSS_DISABLE_ECC
1895 case CKK_EC:
1896 privKey->keyType = NSSLOWKEYECKey;
1897 crv = sftk_Attribute2SSecItem(arena,
1898 &privKey->u.ec.ecParams.DEREncoding,
1899 object,CKA_EC_PARAMS);
1900 if (crv != CKR_OK) break;
1901
1902 /* Fill out the rest of the ecParams structure
1903 * based on the encoded params
1904 */
1905 if (EC_FillParams(arena, &privKey->u.ec.ecParams.DEREncoding,
1906 &privKey->u.ec.ecParams) != SECSuccess) {
1907 crv = CKR_DOMAIN_PARAMS_INVALID;
1908 break;
1909 }
1910 crv = sftk_Attribute2SSecItem(arena,&privKey->u.ec.privateValue,
1911 object,CKA_VALUE);
1912 if (crv != CKR_OK) break;
1913
1914 if (sftk_hasAttribute(object, CKA_NETSCAPE_DB)) {
1915 crv = sftk_Attribute2SSecItem(arena, &privKey->u.ec.publicValue,
1916 object, CKA_NETSCAPE_DB);
1917 if (crv != CKR_OK) break;
1918 /* privKey was zero'd so public value is already set to NULL, 0
1919 * if we don't set it explicitly */
1920 }
1921 rv = DER_SetUInteger(privKey->arena, &privKey->u.ec.version,
1922 NSSLOWKEY_EC_PRIVATE_KEY_VERSION);
1923 if (rv != SECSuccess) {
1924 crv = CKR_HOST_MEMORY;
1925 /* The following ifdef is needed for Linux arm distros and
1926 * Android as gcc 4.6 has a bug when targeting arm (but not
1927 * thumb). The bug has been fixed in gcc 4.7.
1928 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=56561
1929 */
1930 #if defined (__arm__) && !defined(__thumb__) && defined (__GNUC__)
1931 *crvp = CKR_HOST_MEMORY;
1932 break;
1933 #endif
1934 }
1935 break;
1936 #endif /* NSS_DISABLE_ECC */
1937
1938 default:
1939 crv = CKR_KEY_TYPE_INCONSISTENT;
1940 break;
1941 }
1942 if (crv == CKR_OK && itemTemplateCount != 0) {
1943 PORT_Assert(itemTemplateCount > 0);
1944 PORT_Assert(itemTemplateCount <= SFTK_MAX_ITEM_TEMPLATE);
1945 crv = sftk_MultipleAttribute2SecItem(arena, object, itemTemplate,
1946 itemTemplateCount);
1947 }
1948 *crvp = crv;
1949 if (crv != CKR_OK) {
1950 PORT_FreeArena(arena,PR_FALSE);
1951 return NULL;
1952 }
1953 return privKey;
1954 }
1955
1956 /*
1957 * If a partial RSA private key is present, fill in the rest if necessary,
1958 * and then verify the parameters are well-formed
1959 */
1960 static SECStatus
1961 sftk_verifyRSAPrivateKey(SFTKObject *object, PRBool fillIfNeeded)
1962 {
1963 RSAPrivateKey tmpKey = { 0 };
1964 SFTKAttribute *modulus = NULL;
1965 SFTKAttribute *prime1 = NULL;
1966 SFTKAttribute *prime2 = NULL;
1967 SFTKAttribute *privateExponent = NULL;
1968 SFTKAttribute *publicExponent = NULL;
1969 SFTKAttribute *exponent1 = NULL;
1970 SFTKAttribute *exponent2 = NULL;
1971 SFTKAttribute *coefficient = NULL;
1972 SECStatus rv;
1973 CK_RV crv;
1974
1975 /* first fill in the components that we have. Populate only uses
1976 * the non-crt components, so only fill those in */
1977 tmpKey.arena = NULL;
1978 modulus = sftk_FindAttribute(object, CKA_MODULUS);
1979 if (modulus) {
1980 tmpKey.modulus.data = modulus->attrib.pValue;
1981 tmpKey.modulus.len = modulus->attrib.ulValueLen;
1982 }
1983 prime1 = sftk_FindAttribute(object, CKA_PRIME_1);
1984 if (prime1) {
1985 tmpKey.prime1.data = prime1->attrib.pValue;
1986 tmpKey.prime1.len = prime1->attrib.ulValueLen;
1987 }
1988 prime2 = sftk_FindAttribute(object, CKA_PRIME_2);
1989 if (prime2) {
1990 tmpKey.prime2.data = prime2->attrib.pValue;
1991 tmpKey.prime2.len = prime2->attrib.ulValueLen;
1992 }
1993 privateExponent = sftk_FindAttribute(object, CKA_PRIVATE_EXPONENT);
1994 if (privateExponent) {
1995 tmpKey.privateExponent.data = privateExponent->attrib.pValue;
1996 tmpKey.privateExponent.len = privateExponent->attrib.ulValueLen;
1997 }
1998 publicExponent = sftk_FindAttribute(object, CKA_PUBLIC_EXPONENT);
1999 if (publicExponent) {
2000 tmpKey.publicExponent.data = publicExponent->attrib.pValue;
2001 tmpKey.publicExponent.len = publicExponent->attrib.ulValueLen;
2002 }
2003 exponent1 = sftk_FindAttribute(object, CKA_EXPONENT_1);
2004 if (exponent1) {
2005 tmpKey.exponent1.data = exponent1->attrib.pValue;
2006 tmpKey.exponent1.len = exponent1->attrib.ulValueLen;
2007 }
2008 exponent2 = sftk_FindAttribute(object, CKA_EXPONENT_2);
2009 if (exponent2) {
2010 tmpKey.exponent2.data = exponent2->attrib.pValue;
2011 tmpKey.exponent2.len = exponent2->attrib.ulValueLen;
2012 }
2013 coefficient = sftk_FindAttribute(object, CKA_COEFFICIENT);
2014 if (coefficient) {
2015 tmpKey.coefficient.data = coefficient->attrib.pValue;
2016 tmpKey.coefficient.len = coefficient->attrib.ulValueLen;
2017 }
2018
2019 if (fillIfNeeded) {
2020 /*
2021 * populate requires one exponent plus 2 other components to work.
2022 * we expected our caller to check that first. If that didn't happen,
2023 * populate will simply return an error here.
2024 */
2025 rv = RSA_PopulatePrivateKey(&tmpKey);
2026 if (rv != SECSuccess) {
2027 goto loser;
2028 }
2029 }
2030 rv = RSA_PrivateKeyCheck(&tmpKey);
2031 if (rv != SECSuccess) {
2032 goto loser;
2033 }
2034 /* now that we have a fully populated key, set all our attribute values */
2035 rv = SECFailure;
2036 if (!modulus || modulus->attrib.pValue != tmpKey.modulus.data) {
2037 crv = sftk_forceAttribute(object,CKA_MODULUS,
2038 sftk_item_expand(&tmpKey.modulus));
2039 if (crv != CKR_OK) goto loser;
2040 }
2041 if (!publicExponent ||
2042 publicExponent->attrib.pValue != tmpKey.publicExponent.data) {
2043 crv = sftk_forceAttribute(object, CKA_PUBLIC_EXPONENT,
2044 sftk_item_expand(&tmpKey.publicExponent));
2045 if (crv != CKR_OK) goto loser;
2046 }
2047 if (!privateExponent ||
2048 privateExponent->attrib.pValue != tmpKey.privateExponent.data) {
2049 crv = sftk_forceAttribute(object, CKA_PRIVATE_EXPONENT,
2050 sftk_item_expand(&tmpKey.privateExponent));
2051 if (crv != CKR_OK) goto loser;
2052 }
2053 if (!prime1 || prime1->attrib.pValue != tmpKey.prime1.data) {
2054 crv = sftk_forceAttribute(object, CKA_PRIME_1,
2055 sftk_item_expand(&tmpKey.prime1));
2056 if (crv != CKR_OK) goto loser;
2057 }
2058 if (!prime2 || prime2->attrib.pValue != tmpKey.prime2.data) {
2059 crv = sftk_forceAttribute(object, CKA_PRIME_2,
2060 sftk_item_expand(&tmpKey.prime2));
2061 if (crv != CKR_OK) goto loser;
2062 }
2063 if (!exponent1 || exponent1->attrib.pValue != tmpKey.exponent1.data) {
2064 crv = sftk_forceAttribute(object, CKA_EXPONENT_1,
2065 sftk_item_expand(&tmpKey.exponent1));
2066 if (crv != CKR_OK) goto loser;
2067 }
2068 if (!exponent2 || exponent2->attrib.pValue != tmpKey.exponent2.data) {
2069 crv = sftk_forceAttribute(object, CKA_EXPONENT_2,
2070 sftk_item_expand(&tmpKey.exponent2));
2071 if (crv != CKR_OK) goto loser;
2072 }
2073 if (!coefficient || coefficient->attrib.pValue != tmpKey.coefficient.data) {
2074 crv = sftk_forceAttribute(object, CKA_COEFFICIENT,
2075 sftk_item_expand(&tmpKey.coefficient));
2076 if (crv != CKR_OK) goto loser;
2077 }
2078 rv = SECSuccess;
2079
2080 /* we're done (one way or the other), clean up all our stuff */
2081 loser:
2082 if (tmpKey.arena) {
2083 PORT_FreeArena(tmpKey.arena,PR_TRUE);
2084 }
2085 if (modulus) {
2086 sftk_FreeAttribute(modulus);
2087 }
2088 if (prime1) {
2089 sftk_FreeAttribute(prime1);
2090 }
2091 if (prime2) {
2092 sftk_FreeAttribute(prime2);
2093 }
2094 if (privateExponent) {
2095 sftk_FreeAttribute(privateExponent);
2096 }
2097 if (publicExponent) {
2098 sftk_FreeAttribute(publicExponent);
2099 }
2100 if (exponent1) {
2101 sftk_FreeAttribute(exponent1);
2102 }
2103 if (exponent2) {
2104 sftk_FreeAttribute(exponent2);
2105 }
2106 if (coefficient) {
2107 sftk_FreeAttribute(coefficient);
2108 }
2109 return rv;
2110 }
2111
2112 /* Generate a low private key structure from an object */
2113 NSSLOWKEYPrivateKey *
2114 sftk_GetPrivKey(SFTKObject *object,CK_KEY_TYPE key_type, CK_RV *crvp)
2115 {
2116 NSSLOWKEYPrivateKey *priv = NULL;
2117
2118 if (object->objclass != CKO_PRIVATE_KEY) {
2119 *crvp = CKR_KEY_TYPE_INCONSISTENT;
2120 return NULL;
2121 }
2122 if (object->objectInfo) {
2123 *crvp = CKR_OK;
2124 return (NSSLOWKEYPrivateKey *)object->objectInfo;
2125 }
2126
2127 priv = sftk_mkPrivKey(object, key_type, crvp);
2128 object->objectInfo = priv;
2129 object->infoFree = (SFTKFree) nsslowkey_DestroyPrivateKey;
2130 return priv;
2131 }
2132
2133 /*
2134 **************************** Symetric Key utils ************************
2135 */
2136 /*
2137 * set the DES key with parity bits correctly
2138 */
2139 void
2140 sftk_FormatDESKey(unsigned char *key, int length)
2141 {
2142 int i;
2143
2144 /* format the des key */
2145 for (i=0; i < length; i++) {
2146 key[i] = parityTable[key[i]>>1];
2147 }
2148 }
2149
2150 /*
2151 * check a des key (des2 or des3 subkey) for weak keys.
2152 */
2153 PRBool
2154 sftk_CheckDESKey(unsigned char *key)
2155 {
2156 int i;
2157
2158 /* format the des key with parity */
2159 sftk_FormatDESKey(key, 8);
2160
2161 for (i=0; i < sftk_desWeakTableSize; i++) {
2162 if (PORT_Memcmp(key,sftk_desWeakTable[i],8) == 0) {
2163 return PR_TRUE;
2164 }
2165 }
2166 return PR_FALSE;
2167 }
2168
2169 /*
2170 * check if a des or triple des key is weak.
2171 */
2172 PRBool
2173 sftk_IsWeakKey(unsigned char *key,CK_KEY_TYPE key_type)
2174 {
2175
2176 switch(key_type) {
2177 case CKK_DES:
2178 return sftk_CheckDESKey(key);
2179 case CKM_DES2_KEY_GEN:
2180 if (sftk_CheckDESKey(key)) return PR_TRUE;
2181 return sftk_CheckDESKey(&key[8]);
2182 case CKM_DES3_KEY_GEN:
2183 if (sftk_CheckDESKey(key)) return PR_TRUE;
2184 if (sftk_CheckDESKey(&key[8])) return PR_TRUE;
2185 return sftk_CheckDESKey(&key[16]);
2186 default:
2187 break;
2188 }
2189 return PR_FALSE;
2190 }
2191
2192
2193 /**********************************************************************
2194 *
2195 * Start of PKCS 11 functions
2196 *
2197 **********************************************************************/
2198
2199
2200 /* return the function list */
2201 CK_RV NSC_GetFunctionList(CK_FUNCTION_LIST_PTR *pFunctionList)
2202 {
2203 CHECK_FORK();
2204
2205 *pFunctionList = (CK_FUNCTION_LIST_PTR) &sftk_funcList;
2206 return CKR_OK;
2207 }
2208
2209 /* return the function list */
2210 CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR *pFunctionList)
2211 {
2212 CHECK_FORK();
2213
2214 return NSC_GetFunctionList(pFunctionList);
2215 }
2216
2217 static PLHashNumber
2218 sftk_HashNumber(const void *key)
2219 {
2220 return (PLHashNumber) key;
2221 }
2222
2223 /*
2224 * eventually I'd like to expunge all occurances of XXX_SLOT_ID and
2225 * just go with the info in the slot. This is one place, however,
2226 * where it might be a little difficult.
2227 */
2228 const char *
2229 sftk_getDefTokName(CK_SLOT_ID slotID)
2230 {
2231 static char buf[33];
2232
2233 switch (slotID) {
2234 case NETSCAPE_SLOT_ID:
2235 return "NSS Generic Crypto Services ";
2236 case PRIVATE_KEY_SLOT_ID:
2237 return "NSS Certificate DB ";
2238 case FIPS_SLOT_ID:
2239 return "NSS FIPS 140-2 Certificate DB ";
2240 default:
2241 break;
2242 }
2243 sprintf(buf,"NSS Application Token %08x ",(unsigned int) slotID);
2244 return buf;
2245 }
2246
2247 const char *
2248 sftk_getDefSlotName(CK_SLOT_ID slotID)
2249 {
2250 static char buf[65];
2251
2252 switch (slotID) {
2253 case NETSCAPE_SLOT_ID:
2254 return
2255 "NSS Internal Cryptographic Services ";
2256 case PRIVATE_KEY_SLOT_ID:
2257 return
2258 "NSS User Private Key and Certificate Services ";
2259 case FIPS_SLOT_ID:
2260 return
2261 "NSS FIPS 140-2 User Private Key Services ";
2262 default:
2263 break;
2264 }
2265 sprintf(buf,
2266 "NSS Application Slot %08x ",
2267 (unsigned int) slotID);
2268 return buf;
2269 }
2270
2271 static CK_ULONG nscSlotCount[2] = {0 , 0};
2272 static CK_SLOT_ID_PTR nscSlotList[2] = {NULL, NULL};
2273 static CK_ULONG nscSlotListSize[2] = {0, 0};
2274 static PLHashTable *nscSlotHashTable[2] = {NULL, NULL};
2275
2276 static int
2277 sftk_GetModuleIndex(CK_SLOT_ID slotID)
2278 {
2279 if ((slotID == FIPS_SLOT_ID) || (slotID >= SFTK_MIN_FIPS_USER_SLOT_ID)) {
2280 return NSC_FIPS_MODULE;
2281 }
2282 return NSC_NON_FIPS_MODULE;
2283 }
2284
2285 /* look up a slot structure from the ID (used to be a macro when we only
2286 * had two slots) */
2287 /* if all is true, return the slot even if it has been 'unloaded' */
2288 /* if all is false, only return the slots which are present */
2289 SFTKSlot *
2290 sftk_SlotFromID(CK_SLOT_ID slotID, PRBool all)
2291 {
2292 SFTKSlot *slot;
2293 int index = sftk_GetModuleIndex(slotID);
2294
2295 if (nscSlotHashTable[index] == NULL) return NULL;
2296 slot = (SFTKSlot *)PL_HashTableLookupConst(nscSlotHashTable[index],
2297 (void *)slotID);
2298 /* cleared slots shouldn't 'show up' */
2299 if (slot && !all && !slot->present) slot = NULL;
2300 return slot;
2301 }
2302
2303 SFTKSlot *
2304 sftk_SlotFromSessionHandle(CK_SESSION_HANDLE handle)
2305 {
2306 CK_ULONG slotIDIndex = (handle >> 24) & 0x7f;
2307 CK_ULONG moduleIndex = (handle >> 31) & 1;
2308
2309 if (slotIDIndex >= nscSlotCount[moduleIndex]) {
2310 return NULL;
2311 }
2312
2313 return sftk_SlotFromID(nscSlotList[moduleIndex][slotIDIndex], PR_FALSE);
2314 }
2315
2316 static CK_RV
2317 sftk_RegisterSlot(SFTKSlot *slot, int moduleIndex)
2318 {
2319 PLHashEntry *entry;
2320 int index;
2321
2322 index = sftk_GetModuleIndex(slot->slotID);
2323
2324 /* make sure the slotID for this module is valid */
2325 if (moduleIndex != index) {
2326 return CKR_SLOT_ID_INVALID;
2327 }
2328
2329 if (nscSlotList[index] == NULL) {
2330 nscSlotListSize[index] = NSC_SLOT_LIST_BLOCK_SIZE;
2331 nscSlotList[index] = (CK_SLOT_ID *)
2332 PORT_ZAlloc(nscSlotListSize[index]*sizeof(CK_SLOT_ID));
2333 if (nscSlotList[index] == NULL) {
2334 return CKR_HOST_MEMORY;
2335 }
2336 }
2337 if (nscSlotCount[index] >= nscSlotListSize[index]) {
2338 CK_SLOT_ID* oldNscSlotList = nscSlotList[index];
2339 CK_ULONG oldNscSlotListSize = nscSlotListSize[index];
2340 nscSlotListSize[index] += NSC_SLOT_LIST_BLOCK_SIZE;
2341 nscSlotList[index] = (CK_SLOT_ID *) PORT_Realloc(oldNscSlotList,
2342 nscSlotListSize[index]*sizeof(CK_SLOT_ID));
2343 if (nscSlotList[index] == NULL) {
2344 nscSlotList[index] = oldNscSlotList;
2345 nscSlotListSize[index] = oldNscSlotListSize;
2346 return CKR_HOST_MEMORY;
2347 }
2348 }
2349
2350 if (nscSlotHashTable[index] == NULL) {
2351 nscSlotHashTable[index] = PL_NewHashTable(64,sftk_HashNumber,
2352 PL_CompareValues, PL_CompareValues, NULL, 0);
2353 if (nscSlotHashTable[index] == NULL) {
2354 return CKR_HOST_MEMORY;
2355 }
2356 }
2357
2358 entry = PL_HashTableAdd(nscSlotHashTable[index],(void *)slot->slotID,slot);
2359 if (entry == NULL) {
2360 return CKR_HOST_MEMORY;
2361 }
2362 slot->index = (nscSlotCount[index] & 0x7f) | ((index << 7) & 0x80);
2363 nscSlotList[index][nscSlotCount[index]++] = slot->slotID;
2364
2365 return CKR_OK;
2366 }
2367
2368
2369 /*
2370 * ths function has all the common initialization that happens whenever we
2371 * create a new slot or repurpose an old slot (only valid for slotID's 4
2372 * and greater).
2373 *
2374 * things that are not reinitialized are:
2375 * slotID (can't change)
2376 * slotDescription (can't change once defined)
2377 * the locks and hash tables (difficult to change in running code, and
2378 * unnecessary. hash tables and list are cleared on shutdown, but they
2379 * are cleared in a 'friendly' way).
2380 * session and object ID counters -- so any old sessions and objects in the
2381 * application will get properly notified that the world has changed.
2382 *
2383 * things that are reinitialized:
2384 * database (otherwise what would the point be;).
2385 * state variables related to databases.
2386 * session count stat info.
2387 * tokenDescription.
2388 *
2389 * NOTE: slotID's 4 and greater show up as removable devices.
2390 *
2391 */
2392 CK_RV
2393 SFTK_SlotReInit(SFTKSlot *slot, char *configdir, char *updatedir,
2394 char *updateID, sftk_token_parameters *params, int moduleIndex)
2395 {
2396 PRBool needLogin = !params->noKeyDB;
2397 CK_RV crv;
2398
2399 slot->hasTokens = PR_FALSE;
2400 slot->sessionIDConflict = 0;
2401 slot->sessionCount = 0;
2402 slot->rwSessionCount = 0;
2403 slot->needLogin = PR_FALSE;
2404 slot->isLoggedIn = PR_FALSE;
2405 slot->ssoLoggedIn = PR_FALSE;
2406 slot->DB_loaded = PR_FALSE;
2407 slot->certDB = NULL;
2408 slot->keyDB = NULL;
2409 slot->minimumPinLen = 0;
2410 slot->readOnly = params->readOnly;
2411 sftk_setStringName(params->tokdes ? params->tokdes :
2412 sftk_getDefTokName(slot->slotID), slot->tokDescription,
2413 sizeof(slot->tokDescription),PR_TRUE);
2414 sftk_setStringName(params->updtokdes ? params->updtokdes : " ",
2415 slot->updateTokDescription,
2416 sizeof(slot->updateTokDescription),PR_TRUE);
2417
2418 if ((!params->noCertDB) || (!params->noKeyDB)) {
2419 SFTKDBHandle * certHandle = NULL;
2420 SFTKDBHandle *keyHandle = NULL;
2421 crv = sftk_DBInit(params->configdir ? params->configdir : configdir,
2422 params->certPrefix, params->keyPrefix,
2423 params->updatedir ? params->updatedir : updatedir,
2424 params->updCertPrefix, params->updKeyPrefix,
2425 params->updateID ? params->updateID : updateID,
2426 params->readOnly, params->noCertDB, params->noKeyDB,
2427 params->forceOpen,
2428 moduleIndex == NSC_FIPS_MODULE,
2429 &certHandle, &keyHandle);
2430 if (crv != CKR_OK) {
2431 goto loser;
2432 }
2433
2434 slot->certDB = certHandle;
2435 slot->keyDB = keyHandle;
2436 }
2437 if (needLogin) {
2438 /* if the data base is initialized with a null password,remember that */
2439 slot->needLogin =
2440 (PRBool)!sftk_hasNullPassword(slot, slot->keyDB);
2441 if ((params->minPW >= 0) && (params->minPW <= SFTK_MAX_PIN)) {
2442 slot->minimumPinLen = params->minPW;
2443 }
2444 if ((slot->minimumPinLen == 0) && (params->pwRequired)) {
2445 slot->minimumPinLen = 1;
2446 }
2447 if ((moduleIndex == NSC_FIPS_MODULE) &&
2448 (slot->minimumPinLen < FIPS_MIN_PIN)) {
2449 slot->minimumPinLen = FIPS_MIN_PIN;
2450 }
2451 }
2452
2453 slot->present = PR_TRUE;
2454 return CKR_OK;
2455
2456 loser:
2457 SFTK_ShutdownSlot(slot);
2458 return crv;
2459 }
2460
2461 /*
2462 * initialize one of the slot structures. figure out which by the ID
2463 */
2464 CK_RV
2465 SFTK_SlotInit(char *configdir, char *updatedir, char *updateID,
2466 sftk_token_parameters *params, int moduleIndex)
2467 {
2468 unsigned int i;
2469 CK_SLOT_ID slotID = params->slotID;
2470 SFTKSlot *slot;
2471 CK_RV crv = CKR_HOST_MEMORY;
2472
2473 /*
2474 * first we initialize everything that is 'permanent' with this slot.
2475 * that is everything we aren't going to shutdown if we close this slot
2476 * and open it up again with different databases */
2477
2478 slot = PORT_ZNew(SFTKSlot);
2479
2480 if (slot == NULL) {
2481 return CKR_HOST_MEMORY;
2482 }
2483
2484 slot->optimizeSpace = params->optimizeSpace;
2485 if (slot->optimizeSpace) {
2486 slot->sessObjHashSize = SPACE_SESSION_OBJECT_HASH_SIZE;
2487 slot->sessHashSize = SPACE_SESSION_HASH_SIZE;
2488 slot->numSessionLocks = 1;
2489 } else {
2490 slot->sessObjHashSize = TIME_SESSION_OBJECT_HASH_SIZE;
2491 slot->sessHashSize = TIME_SESSION_HASH_SIZE;
2492 slot->numSessionLocks = slot->sessHashSize/BUCKETS_PER_SESSION_LOCK;
2493 }
2494 slot->sessionLockMask = slot->numSessionLocks-1;
2495
2496 slot->slotLock = PZ_NewLock(nssILockSession);
2497 if (slot->slotLock == NULL)
2498 goto mem_loser;
2499 slot->sessionLock = PORT_ZNewArray(PZLock *, slot->numSessionLocks);
2500 if (slot->sessionLock == NULL)
2501 goto mem_loser;
2502 for (i=0; i < slot->numSessionLocks; i++) {
2503 slot->sessionLock[i] = PZ_NewLock(nssILockSession);
2504 if (slot->sessionLock[i] == NULL)
2505 goto mem_loser;
2506 }
2507 slot->objectLock = PZ_NewLock(nssILockObject);
2508 if (slot->objectLock == NULL)
2509 goto mem_loser;
2510 slot->pwCheckLock = PR_NewLock();
2511 if (slot->pwCheckLock == NULL)
2512 goto mem_loser;
2513 slot->head = PORT_ZNewArray(SFTKSession *, slot->sessHashSize);
2514 if (slot->head == NULL)
2515 goto mem_loser;
2516 slot->sessObjHashTable = PORT_ZNewArray(SFTKObject *, slot->sessObjHashSize);
2517 if (slot->sessObjHashTable == NULL)
2518 goto mem_loser;
2519 slot->tokObjHashTable = PL_NewHashTable(64,sftk_HashNumber,PL_CompareValues,
2520 SECITEM_HashCompare, NULL, 0);
2521 if (slot->tokObjHashTable == NULL)
2522 goto mem_loser;
2523
2524 slot->sessionIDCount = 0;
2525 slot->sessionObjectHandleCount = minSessionObjectHandle;
2526 slot->slotID = slotID;
2527 sftk_setStringName(params->slotdes ? params->slotdes :
2528 sftk_getDefSlotName(slotID), slot->slotDescription,
2529 sizeof(slot->slotDescription), PR_TRUE);
2530
2531 /* call the reinit code to set everything that changes between token
2532 * init calls */
2533 crv = SFTK_SlotReInit(slot, configdir, updatedir, updateID,
2534 params, moduleIndex);
2535 if (crv != CKR_OK) {
2536 goto loser;
2537 }
2538 crv = sftk_RegisterSlot(slot, moduleIndex);
2539 if (crv != CKR_OK) {
2540 goto loser;
2541 }
2542 return CKR_OK;
2543
2544 mem_loser:
2545 crv = CKR_HOST_MEMORY;
2546 loser:
2547 SFTK_DestroySlotData(slot);
2548 return crv;
2549 }
2550
2551
2552 CK_RV sftk_CloseAllSessions(SFTKSlot *slot, PRBool logout)
2553 {
2554 SFTKSession *session;
2555 unsigned int i;
2556 SFTKDBHandle *handle;
2557
2558 /* first log out the card */
2559 /* special case - if we are in a middle of upgrade, we want to close the
2560 * sessions to fake a token removal to tell the upper level code we have
2561 * switched from one database to another, but we don't want to
2562 * explicity logout in case we can continue the upgrade with the
2563 * existing password if possible.
2564 */
2565 if (logout) {
2566 handle = sftk_getKeyDB(slot);
2567 SKIP_AFTER_FORK(PZ_Lock(slot->slotLock));
2568 slot->isLoggedIn = PR_FALSE;
2569 if (slot->needLogin && handle) {
2570 sftkdb_ClearPassword(handle);
2571 }
2572 SKIP_AFTER_FORK(PZ_Unlock(slot->slotLock));
2573 if (handle) {
2574 sftk_freeDB(handle);
2575 }
2576 }
2577
2578 /* now close all the current sessions */
2579 /* NOTE: If you try to open new sessions before NSC_CloseAllSessions
2580 * completes, some of those new sessions may or may not be closed by
2581 * NSC_CloseAllSessions... but any session running when this code starts
2582 * will guarrenteed be close, and no session will be partially closed */
2583 for (i=0; i < slot->sessHashSize; i++) {
2584 PZLock *lock = SFTK_SESSION_LOCK(slot,i);
2585 do {
2586 SKIP_AFTER_FORK(PZ_Lock(lock));
2587 session = slot->head[i];
2588 /* hand deque */
2589 /* this duplicates function of NSC_close session functions, but
2590 * because we know that we are freeing all the sessions, we can
2591 * do more efficient processing */
2592 if (session) {
2593 slot->head[i] = session->next;
2594 if (session->next) session->next->prev = NULL;
2595 session->next = session->prev = NULL;
2596 SKIP_AFTER_FORK(PZ_Unlock(lock));
2597 SKIP_AFTER_FORK(PZ_Lock(slot->slotLock));
2598 --slot->sessionCount;
2599 SKIP_AFTER_FORK(PZ_Unlock(slot->slotLock));
2600 if (session->info.flags & CKF_RW_SESSION) {
2601 PR_ATOMIC_DECREMENT(&slot->rwSessionCount);
2602 }
2603 } else {
2604 SKIP_AFTER_FORK(PZ_Unlock(lock));
2605 }
2606 if (session) sftk_FreeSession(session);
2607 } while (session != NULL);
2608 }
2609 return CKR_OK;
2610 }
2611
2612 /*
2613 * shut down the databases.
2614 * we get the slot lock (which also protects slot->certDB and slot->keyDB)
2615 * and clear the values so the new users will not find the databases.
2616 * once things are clear, we can release our references to the databases.
2617 * The databases will close when the last reference is released.
2618 *
2619 * We use reference counts so that we don't crash if someone shuts down
2620 * a token that another thread is actively using.
2621 */
2622 static void
2623 sftk_DBShutdown(SFTKSlot *slot)
2624 {
2625 SFTKDBHandle *certHandle;
2626 SFTKDBHandle *keyHandle;
2627 SKIP_AFTER_FORK(PZ_Lock(slot->slotLock));
2628 certHandle = slot->certDB;
2629 slot->certDB = NULL;
2630 keyHandle = slot->keyDB;
2631 slot->keyDB = NULL;
2632 SKIP_AFTER_FORK(PZ_Unlock(slot->slotLock));
2633 if (certHandle) {
2634 sftk_freeDB(certHandle);
2635 }
2636 if (keyHandle) {
2637 sftk_freeDB(keyHandle);
2638 }
2639 }
2640
2641 CK_RV
2642 SFTK_ShutdownSlot(SFTKSlot *slot)
2643 {
2644 /* make sure no new PK11 calls work except C_GetSlotInfo */
2645 slot->present = PR_FALSE;
2646
2647 /* close all outstanding sessions
2648 * the sessHashSize variable guarentees we have all the session
2649 * mechanism set up */
2650 if (slot->head) {
2651 sftk_CloseAllSessions(slot, PR_TRUE);
2652 }
2653
2654 /* clear all objects.. session objects are cleared as a result of
2655 * closing all the sessions. We just need to clear the token object
2656 * cache. slot->tokObjHashTable guarentees we have the token
2657 * infrastructure set up. */
2658 if (slot->tokObjHashTable) {
2659 SFTK_ClearTokenKeyHashTable(slot);
2660 }
2661
2662 /* clear the slot description for the next guy */
2663 PORT_Memset(slot->tokDescription, 0, sizeof(slot->tokDescription));
2664
2665 /* now shut down the databases. */
2666 sftk_DBShutdown(slot);
2667 return CKR_OK;
2668 }
2669
2670 /*
2671 * initialize one of the slot structures. figure out which by the ID
2672 */
2673 CK_RV
2674 SFTK_DestroySlotData(SFTKSlot *slot)
2675 {
2676 unsigned int i;
2677
2678 SFTK_ShutdownSlot(slot);
2679
2680 if (slot->tokObjHashTable) {
2681 PL_HashTableDestroy(slot->tokObjHashTable);
2682 slot->tokObjHashTable = NULL;
2683 }
2684
2685 if (slot->sessObjHashTable) {
2686 PORT_Free(slot->sessObjHashTable);
2687 slot->sessObjHashTable = NULL;
2688 }
2689 slot->sessObjHashSize = 0;
2690
2691 if (slot->head) {
2692 PORT_Free(slot->head);
2693 slot->head = NULL;
2694 }
2695 slot->sessHashSize = 0;
2696
2697 /* OK everything has been disassembled, now we can finally get rid
2698 * of the locks */
2699 SKIP_AFTER_FORK(PZ_DestroyLock(slot->slotLock));
2700 slot->slotLock = NULL;
2701 if (slot->sessionLock) {
2702 for (i=0; i < slot->numSessionLocks; i++) {
2703 if (slot->sessionLock[i]) {
2704 SKIP_AFTER_FORK(PZ_DestroyLock(slot->sessionLock[i]));
2705 slot->sessionLock[i] = NULL;
2706 }
2707 }
2708 PORT_Free(slot->sessionLock);
2709 slot->sessionLock = NULL;
2710 }
2711 if (slot->objectLock) {
2712 SKIP_AFTER_FORK(PZ_DestroyLock(slot->objectLock));
2713 slot->objectLock = NULL;
2714 }
2715 if (slot->pwCheckLock) {
2716 SKIP_AFTER_FORK(PR_DestroyLock(slot->pwCheckLock));
2717 slot->pwCheckLock = NULL;
2718 }
2719 PORT_Free(slot);
2720 return CKR_OK;
2721 }
2722
2723 /*
2724 * handle the SECMOD.db
2725 */
2726 char **
2727 NSC_ModuleDBFunc(unsigned long function,char *parameters, void *args)
2728 {
2729 char *secmod = NULL;
2730 char *appName = NULL;
2731 char *filename = NULL;
2732 NSSDBType dbType = NSS_DB_TYPE_NONE;
2733 PRBool rw;
2734 static char *success="Success";
2735 char **rvstr = NULL;
2736
2737 rvstr = NSSUTIL_DoModuleDBFunction(function, parameters, args);
2738 if (rvstr != NULL) {
2739 return rvstr;
2740 }
2741
2742 if (PORT_GetError() != SEC_ERROR_LEGACY_DATABASE) {
2743 return NULL;
2744 }
2745
2746 /* The legacy database uses the old dbm, which is only linked with the
2747 * legacy DB handler, which is only callable from softoken */
2748
2749 secmod = _NSSUTIL_GetSecmodName(parameters, &dbType, &appName,
2750 &filename, &rw);
2751
2752 switch (function) {
2753 case SECMOD_MODULE_DB_FUNCTION_FIND:
2754 if (secmod == NULL) {
2755 PORT_SetError(SEC_ERROR_INVALID_ARGS);
2756 return NULL;
2757 }
2758 if (rw && (dbType != NSS_DB_TYPE_LEGACY) &&
2759 (dbType != NSS_DB_TYPE_MULTIACCESS)) {
2760 /* if we get here, we are trying to update the local database */
2761 /* force data from the legacy DB */
2762 char *oldSecmod = NULL;
2763 char *oldAppName = NULL;
2764 char *oldFilename = NULL;
2765 PRBool oldrw;
2766 char **strings = NULL;
2767 int i;
2768
2769 dbType = NSS_DB_TYPE_LEGACY;
2770 oldSecmod = _NSSUTIL_GetSecmodName(parameters,&dbType, &oldAppName,
2771 &oldFilename, &oldrw);
2772 strings = sftkdbCall_ReadSecmodDB(appName, oldFilename, oldSecmod,
2773 (char *)parameters, oldrw);
2774 if (strings) {
2775 /* write out the strings */
2776 for (i=0; strings[i]; i++) {
2777 NSSUTIL_DoModuleDBFunction(SECMOD_MODULE_DB_FUNCTION_ADD,
2778 parameters, strings[i]);
2779 }
2780 sftkdbCall_ReleaseSecmodDBData(oldAppName,oldFilename,oldSecmod,
2781 (char **)strings,oldrw);
2782 } else {
2783 /* write out a dummy record */
2784 NSSUTIL_DoModuleDBFunction(SECMOD_MODULE_DB_FUNCTION_ADD,
2785 parameters, " ");
2786 }
2787 if (oldSecmod) { PR_smprintf_free(oldSecmod); }
2788 if (oldAppName) { PORT_Free(oldAppName); }
2789 if (oldFilename) { PORT_Free(oldFilename); }
2790 rvstr = NSSUTIL_DoModuleDBFunction(function, parameters, args);
2791 break;
2792 }
2793 rvstr = sftkdbCall_ReadSecmodDB(appName,filename,secmod,
2794 (char *)parameters,rw);
2795 break;
2796 case SECMOD_MODULE_DB_FUNCTION_ADD:
2797 if (secmod == NULL) {
2798 PORT_SetError(SEC_ERROR_INVALID_ARGS);
2799 return NULL;
2800 }
2801 rvstr = (sftkdbCall_AddSecmodDB(appName,filename,secmod,
2802 (char *)args,rw) == SECSuccess) ? &success: NULL;
2803 break;
2804 case SECMOD_MODULE_DB_FUNCTION_DEL:
2805 if (secmod == NULL) {
2806 PORT_SetError(SEC_ERROR_INVALID_ARGS);
2807 return NULL;
2808 }
2809 rvstr = (sftkdbCall_DeleteSecmodDB(appName,filename,secmod,
2810 (char *)args,rw) == SECSuccess) ? &success: NULL;
2811 break;
2812 case SECMOD_MODULE_DB_FUNCTION_RELEASE:
2813 rvstr = (sftkdbCall_ReleaseSecmodDBData(appName,filename,secmod,
2814 (char **)args,rw) == SECSuccess) ? &success: NULL;
2815 break;
2816 }
2817 if (secmod) PR_smprintf_free(secmod);
2818 if (appName) PORT_Free(appName);
2819 if (filename) PORT_Free(filename);
2820 return rvstr;
2821 }
2822
2823 static void nscFreeAllSlots(int moduleIndex)
2824 {
2825 /* free all the slots */
2826 SFTKSlot *slot = NULL;
2827 CK_SLOT_ID slotID;
2828 int i;
2829
2830 if (nscSlotList[moduleIndex]) {
2831 CK_ULONG tmpSlotCount = nscSlotCount[moduleIndex];
2832 CK_SLOT_ID_PTR tmpSlotList = nscSlotList[moduleIndex];
2833 PLHashTable *tmpSlotHashTable = nscSlotHashTable[moduleIndex];
2834
2835 /* first close all the session */
2836 for (i=0; i < (int) tmpSlotCount; i++) {
2837 slotID = tmpSlotList[i];
2838 (void) NSC_CloseAllSessions(slotID);
2839 }
2840
2841 /* now clear out the statics */
2842 nscSlotList[moduleIndex] = NULL;
2843 nscSlotCount[moduleIndex] = 0;
2844 nscSlotHashTable[moduleIndex] = NULL;
2845 nscSlotListSize[moduleIndex] = 0;
2846
2847 for (i=0; i < (int) tmpSlotCount; i++) {
2848 slotID = tmpSlotList[i];
2849 slot = (SFTKSlot *)
2850 PL_HashTableLookup(tmpSlotHashTable, (void *)slotID);
2851 PORT_Assert(slot);
2852 if (!slot) continue;
2853 SFTK_DestroySlotData(slot);
2854 PL_HashTableRemove(tmpSlotHashTable, (void *)slotID);
2855 }
2856 PORT_Free(tmpSlotList);
2857 PL_HashTableDestroy(tmpSlotHashTable);
2858 }
2859 }
2860
2861 static void
2862 sftk_closePeer(PRBool isFIPS)
2863 {
2864 CK_SLOT_ID slotID = isFIPS ? PRIVATE_KEY_SLOT_ID: FIPS_SLOT_ID;
2865 SFTKSlot *slot;
2866 int moduleIndex = isFIPS? NSC_NON_FIPS_MODULE : NSC_FIPS_MODULE;
2867 PLHashTable *tmpSlotHashTable = nscSlotHashTable[moduleIndex];
2868
2869 slot = (SFTKSlot *) PL_HashTableLookup(tmpSlotHashTable, (void *)slotID);
2870 if (slot == NULL) {
2871 return;
2872 }
2873 sftk_DBShutdown(slot);
2874 return;
2875 }
2876
2877 /* NSC_Initialize initializes the Cryptoki library. */
2878 CK_RV nsc_CommonInitialize(CK_VOID_PTR pReserved, PRBool isFIPS)
2879 {
2880 CK_RV crv = CKR_OK;
2881 SECStatus rv;
2882 CK_C_INITIALIZE_ARGS *init_args = (CK_C_INITIALIZE_ARGS *) pReserved;
2883 int i;
2884 int moduleIndex = isFIPS? NSC_FIPS_MODULE : NSC_NON_FIPS_MODULE;
2885
2886 if (isFIPS) {
2887 loginWaitTime = PR_SecondsToInterval(1);
2888 }
2889
2890 ENABLE_FORK_CHECK();
2891
2892 rv = SECOID_Init();
2893 if (rv != SECSuccess) {
2894 crv = CKR_DEVICE_ERROR;
2895 return crv;
2896 }
2897
2898 rv = RNG_RNGInit(); /* initialize random number generator */
2899 if (rv != SECSuccess) {
2900 crv = CKR_DEVICE_ERROR;
2901 return crv;
2902 }
2903 rv = BL_Init(); /* initialize freebl engine */
2904 if (rv != SECSuccess) {
2905 crv = CKR_DEVICE_ERROR;
2906 return crv;
2907 }
2908
2909 /* NOTE:
2910 * we should be getting out mutexes from this list, not statically binding
2911 * them from NSPR. This should happen before we allow the internal to split
2912 * off from the rest on NSS.
2913 */
2914
2915 /* initialize the key and cert db's */
2916 if (init_args && (!(init_args->flags & CKF_OS_LOCKING_OK))) {
2917 if (init_args->CreateMutex && init_args->DestroyMutex &&
2918 init_args->LockMutex && init_args->UnlockMutex) {
2919 /* softoken always uses NSPR (ie. OS locking), and doesn't know how
2920 * to use the lock functions provided by the application.
2921 */
2922 crv = CKR_CANT_LOCK;
2923 return crv;
2924 }
2925 if (init_args->CreateMutex || init_args->DestroyMutex ||
2926 init_args->LockMutex || init_args->UnlockMutex) {
2927 /* only some of the lock functions were provided by the
2928 * application. This is invalid per PKCS#11 spec.
2929 */
2930 crv = CKR_ARGUMENTS_BAD;
2931 return crv;
2932 }
2933 }
2934 crv = CKR_ARGUMENTS_BAD;
2935 if ((init_args && init_args->LibraryParameters)) {
2936 sftk_parameters paramStrings;
2937
2938 crv = sftk_parseParameters
2939 ((char *)init_args->LibraryParameters, &paramStrings, isFIPS);
2940 if (crv != CKR_OK) {
2941 return crv;
2942 }
2943 crv = sftk_configure(paramStrings.man, paramStrings.libdes);
2944 if (crv != CKR_OK) {
2945 goto loser;
2946 }
2947
2948 /* if we have a peer already open, have him close his DB's so we
2949 * don't clobber each other. */
2950 if ((isFIPS && nsc_init) || (!isFIPS && nsf_init)) {
2951 sftk_closePeer(isFIPS);
2952 if (sftk_audit_enabled) {
2953 if (isFIPS && nsc_init) {
2954 sftk_LogAuditMessage(NSS_AUDIT_INFO, NSS_AUDIT_FIPS_STATE,
2955 "enabled FIPS mode");
2956 } else {
2957 sftk_LogAuditMessage(NSS_AUDIT_INFO, NSS_AUDIT_FIPS_STATE,
2958 "disabled FIPS mode");
2959 }
2960 }
2961 }
2962
2963 for (i=0; i < paramStrings.token_count; i++) {
2964 crv = SFTK_SlotInit(paramStrings.configdir,
2965 paramStrings.updatedir, paramStrings.updateID,
2966 &paramStrings.tokens[i], moduleIndex);
2967 if (crv != CKR_OK) {
2968 nscFreeAllSlots(moduleIndex);
2969 break;
2970 }
2971 }
2972 loser:
2973 sftk_freeParams(&paramStrings);
2974 }
2975 if (CKR_OK == crv) {
2976 sftk_InitFreeLists();
2977 }
2978
2979 #ifndef NO_FORK_CHECK
2980 if (CKR_OK == crv) {
2981 #if defined(CHECK_FORK_MIXED)
2982 /* Before Solaris 10, fork handlers are not unregistered at dlclose()
2983 * time. So, we only use pthread_atfork on Solaris 10 and later. For
2984 * earlier versions, we use PID checks.
2985 */
2986 char buf[200];
2987 int major = 0, minor = 0;
2988
2989 long rv = sysinfo(SI_RELEASE, buf, sizeof(buf));
2990 if (rv > 0 && rv < sizeof(buf)) {
2991 if (2 == sscanf(buf, "%d.%d", &major, &minor)) {
2992 /* Are we on Solaris 10 or greater ? */
2993 if (major >5 || (5 == major && minor >= 10)) {
2994 /* we are safe to use pthread_atfork */
2995 usePthread_atfork = PR_TRUE;
2996 }
2997 }
2998 }
2999 if (usePthread_atfork) {
3000 pthread_atfork(NULL, NULL, ForkedChild);
3001 } else {
3002 myPid = getpid();
3003 }
3004
3005 #elif defined(CHECK_FORK_PTHREAD)
3006 pthread_atfork(NULL, NULL, ForkedChild);
3007 #elif defined(CHECK_FORK_GETPID)
3008 myPid = getpid();
3009 #else
3010 #error Incorrect fork check method.
3011 #endif
3012 }
3013 #endif
3014 return crv;
3015 }
3016
3017 CK_RV NSC_Initialize(CK_VOID_PTR pReserved)
3018 {
3019 CK_RV crv;
3020
3021 sftk_ForkReset(pReserved, &crv);
3022
3023 if (nsc_init) {
3024 return CKR_CRYPTOKI_ALREADY_INITIALIZED;
3025 }
3026 crv = nsc_CommonInitialize(pReserved,PR_FALSE);
3027 nsc_init = (PRBool) (crv == CKR_OK);
3028 return crv;
3029 }
3030
3031
3032 /* NSC_Finalize indicates that an application is done with the
3033 * Cryptoki library.*/
3034 CK_RV nsc_CommonFinalize (CK_VOID_PTR pReserved, PRBool isFIPS)
3035 {
3036 /* propagate the fork status to freebl and util */
3037 BL_SetForkState(parentForkedAfterC_Initialize);
3038 UTIL_SetForkState(parentForkedAfterC_Initialize);
3039
3040 nscFreeAllSlots(isFIPS ? NSC_FIPS_MODULE : NSC_NON_FIPS_MODULE);
3041
3042 /* don't muck with the globals if our peer is still initialized */
3043 if (isFIPS && nsc_init) {
3044 return CKR_OK;
3045 }
3046 if (!isFIPS && nsf_init) {
3047 return CKR_OK;
3048 }
3049
3050 sftk_CleanupFreeLists();
3051 sftkdb_Shutdown();
3052
3053 /* This function does not discard all our previously aquired entropy. */
3054 RNG_RNGShutdown();
3055
3056 /* tell freeBL to clean up after itself */
3057 BL_Cleanup();
3058
3059 /* reset fork status in freebl. We must do this before BL_Unload so that
3060 * this call doesn't force freebl to be reloaded. */
3061 BL_SetForkState(PR_FALSE);
3062
3063 /* unload freeBL shared library from memory. This may only decrement the
3064 * OS refcount if it's been loaded multiple times, eg. by libssl */
3065 BL_Unload();
3066
3067 /* clean up the default OID table */
3068 SECOID_Shutdown();
3069
3070 /* reset fork status in util */
3071 UTIL_SetForkState(PR_FALSE);
3072
3073 nsc_init = PR_FALSE;
3074
3075 #ifdef CHECK_FORK_MIXED
3076 if (!usePthread_atfork) {
3077 myPid = 0; /* allow CHECK_FORK in the next softoken initialization to
3078 * succeed */
3079 } else {
3080 forked = PR_FALSE; /* allow reinitialization */
3081 }
3082 #elif defined(CHECK_FORK_GETPID)
3083 myPid = 0; /* allow reinitialization */
3084 #elif defined (CHECK_FORK_PTHREAD)
3085 forked = PR_FALSE; /* allow reinitialization */
3086 #endif
3087 return CKR_OK;
3088 }
3089
3090 /* Hard-reset the entire softoken PKCS#11 module if the parent process forked
3091 * while it was initialized. */
3092 PRBool sftk_ForkReset(CK_VOID_PTR pReserved, CK_RV* crv)
3093 {
3094 #ifndef NO_FORK_CHECK
3095 if (PARENT_FORKED()) {
3096 parentForkedAfterC_Initialize = PR_TRUE;
3097 if (nsc_init) {
3098 /* finalize non-FIPS token */
3099 *crv = nsc_CommonFinalize(pReserved, PR_FALSE);
3100 PORT_Assert(CKR_OK == *crv);
3101 nsc_init = (PRBool) !(*crv == CKR_OK);
3102 }
3103 if (nsf_init) {
3104 /* finalize FIPS token */
3105 *crv = nsc_CommonFinalize(pReserved, PR_TRUE);
3106 PORT_Assert(CKR_OK == *crv);
3107 nsf_init = (PRBool) !(*crv == CKR_OK);
3108 }
3109 parentForkedAfterC_Initialize = PR_FALSE;
3110 return PR_TRUE;
3111 }
3112 #endif
3113 return PR_FALSE;
3114 }
3115
3116 /* NSC_Finalize indicates that an application is done with the
3117 * Cryptoki library.*/
3118 CK_RV NSC_Finalize (CK_VOID_PTR pReserved)
3119 {
3120 CK_RV crv;
3121
3122 /* reset entire PKCS#11 module upon fork */
3123 if (sftk_ForkReset(pReserved, &crv)) {
3124 return crv;
3125 }
3126
3127 if (!nsc_init) {
3128 return CKR_OK;
3129 }
3130
3131 crv = nsc_CommonFinalize (pReserved, PR_FALSE);
3132
3133 nsc_init = (PRBool) !(crv == CKR_OK);
3134
3135 return crv;
3136 }
3137
3138 extern const char __nss_softokn_rcsid[];
3139 extern const char __nss_softokn_sccsid[];
3140
3141 /* NSC_GetInfo returns general information about Cryptoki. */
3142 CK_RV NSC_GetInfo(CK_INFO_PTR pInfo)
3143 {
3144 volatile char c; /* force a reference that won't get optimized away */
3145
3146 CHECK_FORK();
3147
3148 c = __nss_softokn_rcsid[0] + __nss_softokn_sccsid[0];
3149 pInfo->cryptokiVersion.major = 2;
3150 pInfo->cryptokiVersion.minor = 20;
3151 PORT_Memcpy(pInfo->manufacturerID,manufacturerID,32);
3152 pInfo->libraryVersion.major = SOFTOKEN_VMAJOR;
3153 pInfo->libraryVersion.minor = SOFTOKEN_VMINOR;
3154 PORT_Memcpy(pInfo->libraryDescription,libraryDescription,32);
3155 pInfo->flags = 0;
3156 return CKR_OK;
3157 }
3158
3159
3160 /* NSC_GetSlotList obtains a list of slots in the system. */
3161 CK_RV nsc_CommonGetSlotList(CK_BBOOL tokenPresent,
3162 CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount, int moduleIndex)
3163 {
3164 *pulCount = nscSlotCount[moduleIndex];
3165 if (pSlotList != NULL) {
3166 PORT_Memcpy(pSlotList,nscSlotList[moduleIndex],
3167 nscSlotCount[moduleIndex]*sizeof(CK_SLOT_ID));
3168 }
3169 return CKR_OK;
3170 }
3171
3172 /* NSC_GetSlotList obtains a list of slots in the system. */
3173 CK_RV NSC_GetSlotList(CK_BBOOL tokenPresent,
3174 CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount)
3175 {
3176 CHECK_FORK();
3177 return nsc_CommonGetSlotList(tokenPresent, pSlotList, pulCount,
3178 NSC_NON_FIPS_MODULE);
3179 }
3180
3181 /* NSC_GetSlotInfo obtains information about a particular slot in the system. */
3182 CK_RV NSC_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo)
3183 {
3184 SFTKSlot *slot = sftk_SlotFromID(slotID, PR_TRUE);
3185
3186 CHECK_FORK();
3187
3188 if (slot == NULL) return CKR_SLOT_ID_INVALID;
3189
3190 PORT_Memcpy(pInfo->manufacturerID,manufacturerID,
3191 sizeof(pInfo->manufacturerID));
3192 PORT_Memcpy(pInfo->slotDescription,slot->slotDescription,
3193 sizeof(pInfo->slotDescription));
3194 pInfo->flags = (slot->present) ? CKF_TOKEN_PRESENT : 0;
3195
3196 /* all user defined slots are defined as removable */
3197 if (slotID >= SFTK_MIN_USER_SLOT_ID) {
3198 pInfo->flags |= CKF_REMOVABLE_DEVICE;
3199 } else {
3200 /* In the case where we are doing a merge update, we need
3201 * the DB slot to be removable so the token name can change
3202 * appropriately. */
3203 SFTKDBHandle *handle = sftk_getKeyDB(slot);
3204 if (handle) {
3205 if (sftkdb_InUpdateMerge(handle)) {
3206 pInfo->flags |= CKF_REMOVABLE_DEVICE;
3207 }
3208 sftk_freeDB(handle);
3209 }
3210 }
3211
3212 /* ok we really should read it out of the keydb file. */
3213 /* pInfo->hardwareVersion.major = NSSLOWKEY_DB_FILE_VERSION; */
3214 pInfo->hardwareVersion.major = SOFTOKEN_VMAJOR;
3215 pInfo->hardwareVersion.minor = SOFTOKEN_VMINOR;
3216 pInfo->firmwareVersion.major = SOFTOKEN_VPATCH;
3217 pInfo->firmwareVersion.minor = SOFTOKEN_VBUILD;
3218 return CKR_OK;
3219 }
3220
3221 /*
3222 * check the current state of the 'needLogin' flag in case the database has
3223 * been changed underneath us.
3224 */
3225 static PRBool
3226 sftk_checkNeedLogin(SFTKSlot *slot, SFTKDBHandle *keyHandle)
3227 {
3228 if (sftkdb_PWCached(keyHandle) == SECSuccess) {
3229 return slot->needLogin;
3230 }
3231 slot->needLogin = (PRBool)!sftk_hasNullPassword(slot, keyHandle);
3232 return (slot->needLogin);
3233 }
3234
3235 static PRBool
3236 sftk_isBlank(const char *s, int len)
3237 {
3238 int i;
3239 for (i=0; i < len; i++) {
3240 if (s[i] != ' ') {
3241 return PR_FALSE;
3242 }
3243 }
3244 return PR_TRUE;
3245 }
3246
3247 /* NSC_GetTokenInfo obtains information about a particular token in
3248 * the system. */
3249 CK_RV NSC_GetTokenInfo(CK_SLOT_ID slotID,CK_TOKEN_INFO_PTR pInfo)
3250 {
3251 SFTKSlot *slot;
3252 SFTKDBHandle *handle;
3253
3254 CHECK_FORK();
3255
3256 if (!nsc_init && !nsf_init) return CKR_CRYPTOKI_NOT_INITIALIZED;
3257 slot = sftk_SlotFromID(slotID, PR_FALSE);
3258 if (slot == NULL) return CKR_SLOT_ID_INVALID;
3259
3260 PORT_Memcpy(pInfo->manufacturerID,manufacturerID,32);
3261 PORT_Memcpy(pInfo->model,"NSS 3 ",16);
3262 PORT_Memcpy(pInfo->serialNumber,"0000000000000000",16);
3263 PORT_Memcpy(pInfo->utcTime,"0000000000000000",16);
3264 pInfo->ulMaxSessionCount = 0; /* arbitrarily large */
3265 pInfo->ulSessionCount = slot->sessionCount;
3266 pInfo->ulMaxRwSessionCount = 0; /* arbitarily large */
3267 pInfo->ulRwSessionCount = slot->rwSessionCount;
3268 pInfo->firmwareVersion.major = 0;
3269 pInfo->firmwareVersion.minor = 0;
3270 PORT_Memcpy(pInfo->label,slot->tokDescription,sizeof(pInfo->label));
3271 handle = sftk_getKeyDB(slot);
3272 pInfo->flags = CKF_RNG | CKF_DUAL_CRYPTO_OPERATIONS;
3273 if (handle == NULL) {
3274 pInfo->flags |= CKF_WRITE_PROTECTED;
3275 pInfo->ulMaxPinLen = 0;
3276 pInfo->ulMinPinLen = 0;
3277 pInfo->ulTotalPublicMemory = 0;
3278 pInfo->ulFreePublicMemory = 0;
3279 pInfo->ulTotalPrivateMemory = 0;
3280 pInfo->ulFreePrivateMemory = 0;
3281 pInfo->hardwareVersion.major = 4;
3282 pInfo->hardwareVersion.minor = 0;
3283 } else {
3284 /*
3285 * we have three possible states which we may be in:
3286 * (1) No DB password has been initialized. This also means we
3287 * have no keys in the key db.
3288 * (2) Password initialized to NULL. This means we have keys, but
3289 * the user has chosen not use a password.
3290 * (3) Finally we have an initialized password whicn is not NULL, and
3291 * we will need to prompt for it.
3292 */
3293 if (sftkdb_HasPasswordSet(handle) == SECFailure) {
3294 pInfo->flags |= CKF_LOGIN_REQUIRED;
3295 } else if (!sftk_checkNeedLogin(slot,handle)) {
3296 pInfo->flags |= CKF_USER_PIN_INITIALIZED;
3297 } else {
3298 pInfo->flags |= CKF_LOGIN_REQUIRED | CKF_USER_PIN_INITIALIZED;
3299 /*
3300 * if we are doing a merge style update, and we need to get the password
3301 * of our source database (the database we are updating from), make sure we
3302 * return a token name that will match the database we are prompting for.
3303 */
3304 if (sftkdb_NeedUpdateDBPassword(handle)) {
3305 /* if we have an update tok description, use it. otherwise
3306 * use the updateID for this database */
3307 if (!sftk_isBlank(slot->updateTokDescription,
3308 sizeof(pInfo->label))) {
3309 PORT_Memcpy(pInfo->label,slot->updateTokDescription,
3310 sizeof(pInfo->label));
3311 } else {
3312 /* build from updateID */
3313 const char *updateID = sftkdb_GetUpdateID(handle);
3314 if (updateID) {
3315 sftk_setStringName(updateID, (char *)pInfo->label,
3316 sizeof(pInfo->label), PR_FALSE);
3317 }
3318 }
3319 }
3320 }
3321 pInfo->ulMaxPinLen = SFTK_MAX_PIN;
3322 pInfo->ulMinPinLen = (CK_ULONG)slot->minimumPinLen;
3323 pInfo->ulTotalPublicMemory = 1;
3324 pInfo->ulFreePublicMemory = 1;
3325 pInfo->ulTotalPrivateMemory = 1;
3326 pInfo->ulFreePrivateMemory = 1;
3327 #ifdef SHDB_FIXME
3328 pInfo->hardwareVersion.major = CERT_DB_FILE_VERSION;
3329 pInfo->hardwareVersion.minor = handle->version;
3330 #else
3331 pInfo->hardwareVersion.major = 0;
3332 pInfo->hardwareVersion.minor = 0;
3333 #endif
3334 sftk_freeDB(handle);
3335 }
3336 /*
3337 * CKF_LOGIN_REQUIRED CKF_USER_PIN_INITIALIZED how CKF_TOKEN_INITIALIZED
3338 * should be set
3339 * 0 0 1
3340 * 1 0 0
3341 * 0 1 1
3342 * 1 1 1
3343 */
3344 if (!(pInfo->flags & CKF_LOGIN_REQUIRED) ||
3345 (pInfo->flags & CKF_USER_PIN_INITIALIZED)) {
3346 pInfo->flags |= CKF_TOKEN_INITIALIZED;
3347 }
3348 return CKR_OK;
3349 }
3350
3351 /* NSC_GetMechanismList obtains a list of mechanism types
3352 * supported by a token. */
3353 CK_RV NSC_GetMechanismList(CK_SLOT_ID slotID,
3354 CK_MECHANISM_TYPE_PTR pMechanismList, CK_ULONG_PTR pulCount)
3355 {
3356 CK_ULONG i;
3357
3358 CHECK_FORK();
3359
3360 switch (slotID) {
3361 /* default: */
3362 case NETSCAPE_SLOT_ID:
3363 *pulCount = mechanismCount;
3364 if (pMechanismList != NULL) {
3365 for (i=0; i < mechanismCount; i++) {
3366 pMechanismList[i] = mechanisms[i].type;
3367 }
3368 }
3369 break;
3370 default:
3371 *pulCount = 0;
3372 for (i=0; i < mechanismCount; i++) {
3373 if (mechanisms[i].privkey) {
3374 (*pulCount)++;
3375 if (pMechanismList != NULL) {
3376 *pMechanismList++ = mechanisms[i].type;
3377 }
3378 }
3379 }
3380 break;
3381 }
3382 return CKR_OK;
3383 }
3384
3385
3386 /* NSC_GetMechanismInfo obtains information about a particular mechanism
3387 * possibly supported by a token. */
3388 CK_RV NSC_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
3389 CK_MECHANISM_INFO_PTR pInfo)
3390 {
3391 PRBool isPrivateKey;
3392 CK_ULONG i;
3393
3394 CHECK_FORK();
3395
3396 switch (slotID) {
3397 case NETSCAPE_SLOT_ID:
3398 isPrivateKey = PR_FALSE;
3399 break;
3400 default:
3401 isPrivateKey = PR_TRUE;
3402 break;
3403 }
3404 for (i=0; i < mechanismCount; i++) {
3405 if (type == mechanisms[i].type) {
3406 if (isPrivateKey && !mechanisms[i].privkey) {
3407 return CKR_MECHANISM_INVALID;
3408 }
3409 PORT_Memcpy(pInfo,&mechanisms[i].info, sizeof(CK_MECHANISM_INFO));
3410 return CKR_OK;
3411 }
3412 }
3413 return CKR_MECHANISM_INVALID;
3414 }
3415
3416 CK_RV sftk_MechAllowsOperation(CK_MECHANISM_TYPE type, CK_ATTRIBUTE_TYPE op)
3417 {
3418 CK_ULONG i;
3419 CK_FLAGS flags;
3420
3421 switch (op) {
3422 case CKA_ENCRYPT: flags = CKF_ENCRYPT; break;
3423 case CKA_DECRYPT: flags = CKF_DECRYPT; break;
3424 case CKA_WRAP: flags = CKF_WRAP; break;
3425 case CKA_UNWRAP: flags = CKF_UNWRAP; break;
3426 case CKA_SIGN: flags = CKF_SIGN; break;
3427 case CKA_SIGN_RECOVER: flags = CKF_SIGN_RECOVER; break;
3428 case CKA_VERIFY: flags = CKF_VERIFY; break;
3429 case CKA_VERIFY_RECOVER: flags = CKF_VERIFY_RECOVER; break;
3430 case CKA_DERIVE: flags = CKF_DERIVE; break;
3431 default:
3432 return CKR_ARGUMENTS_BAD;
3433 }
3434 for (i=0; i < mechanismCount; i++) {
3435 if (type == mechanisms[i].type) {
3436 return (flags & mechanisms[i].info.flags) ? CKR_OK
3437 : CKR_MECHANISM_INVALID;
3438 }
3439 }
3440 return CKR_MECHANISM_INVALID;
3441 }
3442
3443 /* NSC_InitToken initializes a token. */
3444 CK_RV NSC_InitToken(CK_SLOT_ID slotID,CK_CHAR_PTR pPin,
3445 CK_ULONG ulPinLen,CK_CHAR_PTR pLabel) {
3446 SFTKSlot *slot = sftk_SlotFromID(slotID, PR_FALSE);
3447 SFTKDBHandle *handle;
3448 SFTKDBHandle *certHandle;
3449 SECStatus rv;
3450 unsigned int i;
3451 SFTKObject *object;
3452
3453 CHECK_FORK();
3454
3455 if (slot == NULL) return CKR_SLOT_ID_INVALID;
3456
3457 /* don't initialize the database if we aren't talking to a token
3458 * that uses the key database.
3459 */
3460 if (slotID == NETSCAPE_SLOT_ID) {
3461 return CKR_TOKEN_WRITE_PROTECTED;
3462 }
3463
3464 /* first, delete all our loaded key and cert objects from our
3465 * internal list. */
3466 PZ_Lock(slot->objectLock);
3467 for (i=0; i < slot->sessObjHashSize; i++) {
3468 do {
3469 object = slot->sessObjHashTable[i];
3470 /* hand deque */
3471 /* this duplicates function of NSC_close session functions, but
3472 * because we know that we are freeing all the sessions, we can
3473 * do more efficient processing */
3474 if (object) {
3475 slot->sessObjHashTable[i] = object->next;
3476
3477 if (object->next) object->next->prev = NULL;
3478 object->next = object->prev = NULL;
3479 }
3480 if (object) sftk_FreeObject(object);
3481 } while (object != NULL);
3482 }
3483 slot->DB_loaded = PR_FALSE;
3484 PZ_Unlock(slot->objectLock);
3485
3486 /* then clear out the key database */
3487 handle = sftk_getKeyDB(slot);
3488 if (handle == NULL) {
3489 return CKR_TOKEN_WRITE_PROTECTED;
3490 }
3491
3492 rv = sftkdb_ResetKeyDB(handle);
3493 sftk_freeDB(handle);
3494 if (rv != SECSuccess) {
3495 return CKR_DEVICE_ERROR;
3496 }
3497
3498 /* finally mark all the user certs as non-user certs */
3499 certHandle = sftk_getCertDB(slot);
3500 if (certHandle == NULL) return CKR_OK;
3501
3502 sftk_freeDB(certHandle);
3503
3504 return CKR_OK; /*is this the right function for not implemented*/
3505 }
3506
3507
3508 /* NSC_InitPIN initializes the normal user's PIN. */
3509 CK_RV NSC_InitPIN(CK_SESSION_HANDLE hSession,
3510 CK_CHAR_PTR pPin, CK_ULONG ulPinLen)
3511 {
3512 SFTKSession *sp = NULL;
3513 SFTKSlot *slot;
3514 SFTKDBHandle *handle = NULL;
3515 char newPinStr[SFTK_MAX_PIN+1];
3516 SECStatus rv;
3517 CK_RV crv = CKR_SESSION_HANDLE_INVALID;
3518 PRBool tokenRemoved = PR_FALSE;
3519
3520 CHECK_FORK();
3521
3522 sp = sftk_SessionFromHandle(hSession);
3523 if (sp == NULL) {
3524 goto loser;
3525 }
3526
3527 slot = sftk_SlotFromSession(sp);
3528 if (slot == NULL) {
3529 goto loser;
3530 }
3531
3532 handle = sftk_getKeyDB(slot);
3533 if (handle == NULL) {
3534 crv = CKR_PIN_LEN_RANGE;
3535 goto loser;
3536 }
3537
3538
3539 if (sp->info.state != CKS_RW_SO_FUNCTIONS) {
3540 crv = CKR_USER_NOT_LOGGED_IN;
3541 goto loser;
3542 }
3543
3544 sftk_FreeSession(sp);
3545 sp = NULL;
3546
3547 /* make sure the pins aren't too long */
3548 if (ulPinLen > SFTK_MAX_PIN) {
3549 crv = CKR_PIN_LEN_RANGE;
3550 goto loser;
3551 }
3552 if (ulPinLen < (CK_ULONG)slot->minimumPinLen) {
3553 crv = CKR_PIN_LEN_RANGE;
3554 goto loser;
3555 }
3556
3557 if (sftkdb_HasPasswordSet(handle) != SECFailure) {
3558 crv = CKR_DEVICE_ERROR;
3559 goto loser;
3560 }
3561
3562 /* convert to null terminated string */
3563 PORT_Memcpy(newPinStr, pPin, ulPinLen);
3564 newPinStr[ulPinLen] = 0;
3565
3566 /* build the hashed pins which we pass around */
3567
3568 /* change the data base */
3569 rv = sftkdb_ChangePassword(handle, NULL, newPinStr, &tokenRemoved);
3570 if (tokenRemoved) {
3571 sftk_CloseAllSessions(slot, PR_FALSE);
3572 }
3573 sftk_freeDB(handle);
3574 handle = NULL;
3575
3576 /* Now update our local copy of the pin */
3577 if (rv == SECSuccess) {
3578 if (ulPinLen == 0) slot->needLogin = PR_FALSE;
3579 return CKR_OK;
3580 }
3581 crv = CKR_PIN_INCORRECT;
3582
3583 loser:
3584 if (sp) {
3585 sftk_FreeSession(sp);
3586 }
3587 if (handle) {
3588 sftk_freeDB(handle);
3589 }
3590 return crv;
3591 }
3592
3593
3594 /* NSC_SetPIN modifies the PIN of user that is currently logged in. */
3595 /* NOTE: This is only valid for the PRIVATE_KEY_SLOT */
3596 CK_RV NSC_SetPIN(CK_SESSION_HANDLE hSession, CK_CHAR_PTR pOldPin,
3597 CK_ULONG ulOldLen, CK_CHAR_PTR pNewPin, CK_ULONG ulNewLen)
3598 {
3599 SFTKSession *sp = NULL;
3600 SFTKSlot *slot;
3601 SFTKDBHandle *handle = NULL;
3602 char newPinStr[SFTK_MAX_PIN+1],oldPinStr[SFTK_MAX_PIN+1];
3603 SECStatus rv;
3604 CK_RV crv = CKR_SESSION_HANDLE_INVALID;
3605 PRBool tokenRemoved = PR_FALSE;
3606
3607 CHECK_FORK();
3608
3609 sp = sftk_SessionFromHandle(hSession);
3610 if (sp == NULL) {
3611 goto loser;
3612 }
3613
3614 slot = sftk_SlotFromSession(sp);
3615 if (!slot) {
3616 goto loser;
3617 }
3618
3619 handle = sftk_getKeyDB(slot);
3620 if (handle == NULL) {
3621 sftk_FreeSession(sp);
3622 return CKR_PIN_LEN_RANGE; /* XXX FIXME wrong return value */
3623 }
3624
3625 if (slot->needLogin && sp->info.state != CKS_RW_USER_FUNCTIONS) {
3626 crv = CKR_USER_NOT_LOGGED_IN;
3627 goto loser;
3628 }
3629
3630 sftk_FreeSession(sp);
3631 sp = NULL;
3632
3633 /* make sure the pins aren't too long */
3634 if ((ulNewLen > SFTK_MAX_PIN) || (ulOldLen > SFTK_MAX_PIN)) {
3635 crv = CKR_PIN_LEN_RANGE;
3636 goto loser;
3637 }
3638 if (ulNewLen < (CK_ULONG)slot->minimumPinLen) {
3639 crv = CKR_PIN_LEN_RANGE;
3640 goto loser;
3641 }
3642
3643
3644 /* convert to null terminated string */
3645 PORT_Memcpy(newPinStr,pNewPin,ulNewLen);
3646 newPinStr[ulNewLen] = 0;
3647 PORT_Memcpy(oldPinStr,pOldPin,ulOldLen);
3648 oldPinStr[ulOldLen] = 0;
3649
3650 /* change the data base password */
3651 PR_Lock(slot->pwCheckLock);
3652 rv = sftkdb_ChangePassword(handle, oldPinStr, newPinStr, &tokenRemoved);
3653 if (tokenRemoved) {
3654 sftk_CloseAllSessions(slot, PR_FALSE);
3655 }
3656 if ((rv != SECSuccess) && (slot->slotID == FIPS_SLOT_ID)) {
3657 PR_Sleep(loginWaitTime);
3658 }
3659 PR_Unlock(slot->pwCheckLock);
3660
3661 /* Now update our local copy of the pin */
3662 if (rv == SECSuccess) {
3663 slot->needLogin = (PRBool)(ulNewLen != 0);
3664 /* Reset login flags. */
3665 if (ulNewLen == 0) {
3666 PRBool tokenRemoved = PR_FALSE;
3667 PZ_Lock(slot->slotLock);
3668 slot->isLoggedIn = PR_FALSE;
3669 slot->ssoLoggedIn = PR_FALSE;
3670 PZ_Unlock(slot->slotLock);
3671
3672 rv = sftkdb_CheckPassword(handle, "", &tokenRemoved);
3673 if (tokenRemoved) {
3674 sftk_CloseAllSessions(slot, PR_FALSE);
3675 }
3676 }
3677 sftk_update_all_states(slot);
3678 sftk_freeDB(handle);
3679 return CKR_OK;
3680 }
3681 crv = CKR_PIN_INCORRECT;
3682 loser:
3683 if (sp) {
3684 sftk_FreeSession(sp);
3685 }
3686 if (handle) {
3687 sftk_freeDB(handle);
3688 }
3689 return crv;
3690 }
3691
3692 /* NSC_OpenSession opens a session between an application and a token. */
3693 CK_RV NSC_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags,
3694 CK_VOID_PTR pApplication,CK_NOTIFY Notify,CK_SESSION_HANDLE_PTR phSession)
3695 {
3696 SFTKSlot *slot;
3697 CK_SESSION_HANDLE sessionID;
3698 SFTKSession *session;
3699 SFTKSession *sameID;
3700
3701 CHECK_FORK();
3702
3703 slot = sftk_SlotFromID(slotID, PR_FALSE);
3704 if (slot == NULL) return CKR_SLOT_ID_INVALID;
3705
3706 /* new session (we only have serial sessions) */
3707 session = sftk_NewSession(slotID, Notify, pApplication,
3708 flags | CKF_SERIAL_SESSION);
3709 if (session == NULL) return CKR_HOST_MEMORY;
3710
3711 if (slot->readOnly && (flags & CKF_RW_SESSION)) {
3712 /* NETSCAPE_SLOT_ID is Read ONLY */
3713 session->info.flags &= ~CKF_RW_SESSION;
3714 }
3715 PZ_Lock(slot->slotLock);
3716 ++slot->sessionCount;
3717 PZ_Unlock(slot->slotLock);
3718 if (session->info.flags & CKF_RW_SESSION) {
3719 PR_ATOMIC_INCREMENT(&slot->rwSessionCount);
3720 }
3721
3722 do {
3723 PZLock *lock;
3724 do {
3725 sessionID = (PR_ATOMIC_INCREMENT(&slot->sessionIDCount) & 0xffffff)
3726 | (slot->index << 24);
3727 } while (sessionID == CK_INVALID_HANDLE);
3728 lock = SFTK_SESSION_LOCK(slot,sessionID);
3729 PZ_Lock(lock);
3730 sftkqueue_find(sameID, sessionID, slot->head, slot->sessHashSize);
3731 if (sameID == NULL) {
3732 session->handle = sessionID;
3733 sftk_update_state(slot, session);
3734 sftkqueue_add(session, sessionID, slot->head,slot->sessHashSize);
3735 } else {
3736 slot->sessionIDConflict++; /* for debugging */
3737 }
3738 PZ_Unlock(lock);
3739 } while (sameID != NULL);
3740
3741 *phSession = sessionID;
3742 return CKR_OK;
3743 }
3744
3745
3746 /* NSC_CloseSession closes a session between an application and a token. */
3747 CK_RV NSC_CloseSession(CK_SESSION_HANDLE hSession)
3748 {
3749 SFTKSlot *slot;
3750 SFTKSession *session;
3751 PRBool sessionFound;
3752 PZLock *lock;
3753
3754 CHECK_FORK();
3755
3756 session = sftk_SessionFromHandle(hSession);
3757 if (session == NULL) return CKR_SESSION_HANDLE_INVALID;
3758 slot = sftk_SlotFromSession(session);
3759 sessionFound = PR_FALSE;
3760
3761 /* lock */
3762 lock = SFTK_SESSION_LOCK(slot,hSession);
3763 PZ_Lock(lock);
3764 if (sftkqueue_is_queued(session,hSession,slot->head,slot->sessHashSize)) {
3765 sessionFound = PR_TRUE;
3766 sftkqueue_delete(session,hSession,slot->head,slot->sessHashSize);
3767 session->refCount--; /* can't go to zero while we hold the reference */
3768 PORT_Assert(session->refCount > 0);
3769 }
3770 PZ_Unlock(lock);
3771
3772 if (sessionFound) {
3773 SFTKDBHandle *handle;
3774 handle = sftk_getKeyDB(slot);
3775 PZ_Lock(slot->slotLock);
3776 if (--slot->sessionCount == 0) {
3777 slot->isLoggedIn = PR_FALSE;
3778 if (slot->needLogin && handle) {
3779 sftkdb_ClearPassword(handle);
3780 }
3781 }
3782 PZ_Unlock(slot->slotLock);
3783 if (handle) {
3784 sftk_freeDB(handle);
3785 }
3786 if (session->info.flags & CKF_RW_SESSION) {
3787 PR_ATOMIC_DECREMENT(&slot->rwSessionCount);
3788 }
3789 }
3790
3791 sftk_FreeSession(session);
3792 return CKR_OK;
3793 }
3794
3795
3796 /* NSC_CloseAllSessions closes all sessions with a token. */
3797 CK_RV NSC_CloseAllSessions (CK_SLOT_ID slotID)
3798 {
3799 SFTKSlot *slot;
3800
3801 #ifndef NO_FORK_CHECK
3802 /* skip fork check if we are being called from C_Initialize or C_Finalize */
3803 if (!parentForkedAfterC_Initialize) {
3804 CHECK_FORK();
3805 }
3806 #endif
3807
3808 slot = sftk_SlotFromID(slotID, PR_FALSE);
3809 if (slot == NULL) return CKR_SLOT_ID_INVALID;
3810
3811 return sftk_CloseAllSessions(slot, PR_TRUE);
3812 }
3813
3814
3815
3816 /* NSC_GetSessionInfo obtains information about the session. */
3817 CK_RV NSC_GetSessionInfo(CK_SESSION_HANDLE hSession,
3818 CK_SESSION_INFO_PTR pInfo)
3819 {
3820 SFTKSession *session;
3821
3822 CHECK_FORK();
3823
3824 session = sftk_SessionFromHandle(hSession);
3825 if (session == NULL) return CKR_SESSION_HANDLE_INVALID;
3826
3827 PORT_Memcpy(pInfo,&session->info,sizeof(CK_SESSION_INFO));
3828 sftk_FreeSession(session);
3829 return CKR_OK;
3830 }
3831
3832 /* NSC_Login logs a user into a token. */
3833 CK_RV NSC_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
3834 CK_CHAR_PTR pPin, CK_ULONG ulPinLen)
3835 {
3836 SFTKSlot *slot;
3837 SFTKSession *session;
3838 SFTKDBHandle *handle;
3839 CK_FLAGS sessionFlags;
3840 SECStatus rv;
3841 CK_RV crv;
3842 char pinStr[SFTK_MAX_PIN+1];
3843 PRBool tokenRemoved = PR_FALSE;
3844
3845 CHECK_FORK();
3846
3847 /* get the slot */
3848 slot = sftk_SlotFromSessionHandle(hSession);
3849 if (slot == NULL) {
3850 return CKR_SESSION_HANDLE_INVALID;
3851 }
3852
3853 /* make sure the session is valid */
3854 session = sftk_SessionFromHandle(hSession);
3855 if (session == NULL) {
3856 return CKR_SESSION_HANDLE_INVALID;
3857 }
3858 sessionFlags = session->info.flags;
3859 sftk_FreeSession(session);
3860 session = NULL;
3861
3862 /* can't log into the Netscape Slot */
3863 if (slot->slotID == NETSCAPE_SLOT_ID) {
3864 return CKR_USER_TYPE_INVALID;
3865 }
3866
3867 if (slot->isLoggedIn) return CKR_USER_ALREADY_LOGGED_IN;
3868 if (!slot->needLogin) {
3869 return ulPinLen ? CKR_PIN_INCORRECT : CKR_OK;
3870 }
3871 slot->ssoLoggedIn = PR_FALSE;
3872
3873 if (ulPinLen > SFTK_MAX_PIN) return CKR_PIN_LEN_RANGE;
3874
3875 /* convert to null terminated string */
3876 PORT_Memcpy(pinStr,pPin,ulPinLen);
3877 pinStr[ulPinLen] = 0;
3878
3879 handle = sftk_getKeyDB(slot);
3880 if (handle == NULL) {
3881 return CKR_USER_TYPE_INVALID;
3882 }
3883
3884 /*
3885 * Deal with bootstrap. We allow the SSO to login in with a NULL
3886 * password if and only if we haven't initialized the KEY DB yet.
3887 * We only allow this on a RW session.
3888 */
3889 rv = sftkdb_HasPasswordSet(handle);
3890 if (rv == SECFailure) {
3891 /* allow SSO's to log in only if there is not password on the
3892 * key database */
3893 if (((userType == CKU_SO) && (sessionFlags & CKF_RW_SESSION))
3894 /* fips always needs to authenticate, even if there isn't a db */
3895 || (slot->slotID == FIPS_SLOT_ID)) {
3896 /* should this be a fixed password? */
3897 if (ulPinLen == 0) {
3898 sftkdb_ClearPassword(handle);
3899 PZ_Lock(slot->slotLock);
3900 slot->isLoggedIn = PR_TRUE;
3901 slot->ssoLoggedIn = (PRBool)(userType == CKU_SO);
3902 PZ_Unlock(slot->slotLock);
3903 sftk_update_all_states(slot);
3904 crv = CKR_OK;
3905 goto done;
3906 }
3907 crv = CKR_PIN_INCORRECT;
3908 goto done;
3909 }
3910 crv = CKR_USER_TYPE_INVALID;
3911 goto done;
3912 }
3913
3914 /* don't allow the SSO to log in if the user is already initialized */
3915 if (userType != CKU_USER) {
3916 crv = CKR_USER_TYPE_INVALID;
3917 goto done;
3918 }
3919
3920
3921 /* build the hashed pins which we pass around */
3922 PR_Lock(slot->pwCheckLock);
3923 rv = sftkdb_CheckPassword(handle,pinStr, &tokenRemoved);
3924 if (tokenRemoved) {
3925 sftk_CloseAllSessions(slot, PR_FALSE);
3926 }
3927 if ((rv != SECSuccess) && (slot->slotID == FIPS_SLOT_ID)) {
3928 PR_Sleep(loginWaitTime);
3929 }
3930 PR_Unlock(slot->pwCheckLock);
3931 if (rv == SECSuccess) {
3932 PZ_Lock(slot->slotLock);
3933 /* make sure the login state matches the underlying
3934 * database state */
3935 slot->isLoggedIn = sftkdb_PWCached(handle) == SECSuccess ?
3936 PR_TRUE : PR_FALSE;
3937 PZ_Unlock(slot->slotLock);
3938
3939 sftk_freeDB(handle);
3940 handle = NULL;
3941
3942 /* update all sessions */
3943 sftk_update_all_states(slot);
3944 return CKR_OK;
3945 }
3946
3947 crv = CKR_PIN_INCORRECT;
3948 done:
3949 if (handle) {
3950 sftk_freeDB(handle);
3951 }
3952 return crv;
3953 }
3954
3955 /* NSC_Logout logs a user out from a token. */
3956 CK_RV NSC_Logout(CK_SESSION_HANDLE hSession)
3957 {
3958 SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession);
3959 SFTKSession *session;
3960 SFTKDBHandle *handle;
3961
3962 CHECK_FORK();
3963
3964 if (slot == NULL) {
3965 return CKR_SESSION_HANDLE_INVALID;
3966 }
3967 session = sftk_SessionFromHandle(hSession);
3968 if (session == NULL) return CKR_SESSION_HANDLE_INVALID;
3969 sftk_FreeSession(session);
3970 session = NULL;
3971
3972 if (!slot->isLoggedIn) return CKR_USER_NOT_LOGGED_IN;
3973
3974 handle = sftk_getKeyDB(slot);
3975 PZ_Lock(slot->slotLock);
3976 slot->isLoggedIn = PR_FALSE;
3977 slot->ssoLoggedIn = PR_FALSE;
3978 if (slot->needLogin && handle) {
3979 sftkdb_ClearPassword(handle);
3980 }
3981 PZ_Unlock(slot->slotLock);
3982 if (handle) {
3983 sftk_freeDB(handle);
3984 }
3985
3986 sftk_update_all_states(slot);
3987 return CKR_OK;
3988 }
3989
3990 /*
3991 * Create or remove a new slot on the fly.
3992 * When creating a slot, "slot" is the slot that the request came from. The
3993 * resulting slot will live in the same module as "slot".
3994 * When removing a slot, "slot" is the slot to be removed.
3995 * "object" is the creation object that specifies the module spec for the slot
3996 * to add or remove.
3997 */
3998 static CK_RV sftk_CreateNewSlot(SFTKSlot *slot, CK_OBJECT_CLASS class,
3999 SFTKObject *object)
4000 {
4001 PRBool isValidUserSlot = PR_FALSE;
4002 PRBool isValidFIPSUserSlot = PR_FALSE;
4003 PRBool isValidSlot = PR_FALSE;
4004 PRBool isFIPS = PR_FALSE;
4005 unsigned long moduleIndex;
4006 SFTKAttribute *attribute;
4007 sftk_parameters paramStrings;
4008 char *paramString;
4009 CK_SLOT_ID slotID = 0;
4010 SFTKSlot *newSlot = NULL;
4011 CK_RV crv = CKR_OK;
4012
4013 if (class != CKO_NETSCAPE_DELSLOT && class != CKO_NETSCAPE_NEWSLOT) {
4014 return CKR_ATTRIBUTE_VALUE_INVALID;
4015 }
4016 if (class == CKO_NETSCAPE_NEWSLOT && slot->slotID == FIPS_SLOT_ID) {
4017 isFIPS = PR_TRUE;
4018 }
4019 attribute = sftk_FindAttribute(object, CKA_NETSCAPE_MODULE_SPEC);
4020 if (attribute == NULL) {
4021 return CKR_TEMPLATE_INCOMPLETE;
4022 }
4023 paramString = (char *)attribute->attrib.pValue;
4024 crv = sftk_parseParameters(paramString, &paramStrings, isFIPS);
4025 if (crv != CKR_OK) {
4026 goto loser;
4027 }
4028
4029 /* enforce only one at a time */
4030 if (paramStrings.token_count != 1) {
4031 crv = CKR_ATTRIBUTE_VALUE_INVALID;
4032 goto loser;
4033 }
4034
4035 slotID = paramStrings.tokens[0].slotID;
4036
4037 /* stay within the valid ID space */
4038 isValidUserSlot = (slotID >= SFTK_MIN_USER_SLOT_ID &&
4039 slotID <= SFTK_MAX_USER_SLOT_ID);
4040 isValidFIPSUserSlot = (slotID >= SFTK_MIN_FIPS_USER_SLOT_ID &&
4041 slotID <= SFTK_MAX_FIPS_USER_SLOT_ID);
4042
4043 if (class == CKO_NETSCAPE_DELSLOT) {
4044 if (slot->slotID == slotID) {
4045 isValidSlot = isValidUserSlot || isValidFIPSUserSlot;
4046 }
4047 } else {
4048 /* only the crypto or FIPS slots can create new slot objects */
4049 if (slot->slotID == NETSCAPE_SLOT_ID) {
4050 isValidSlot = isValidUserSlot;
4051 moduleIndex = NSC_NON_FIPS_MODULE;
4052 } else if (slot->slotID == FIPS_SLOT_ID) {
4053 isValidSlot = isValidFIPSUserSlot;
4054 moduleIndex = NSC_FIPS_MODULE;
4055 }
4056 }
4057
4058 if (!isValidSlot) {
4059 crv = CKR_ATTRIBUTE_VALUE_INVALID;
4060 goto loser;
4061 }
4062
4063 /* unload any existing slot at this id */
4064 newSlot = sftk_SlotFromID(slotID, PR_TRUE);
4065 if (newSlot && newSlot->present) {
4066 crv = SFTK_ShutdownSlot(newSlot);
4067 if (crv != CKR_OK) {
4068 goto loser;
4069 }
4070 }
4071
4072 /* if we were just planning on deleting the slot, then do so now */
4073 if (class == CKO_NETSCAPE_DELSLOT) {
4074 /* sort of a unconventional use of this error code, be we are
4075 * overusing CKR_ATTRIBUTE_VALUE_INVALID, and it does apply */
4076 crv = newSlot ? CKR_OK : CKR_SLOT_ID_INVALID;
4077 goto loser; /* really exit */
4078 }
4079
4080 if (newSlot) {
4081 crv = SFTK_SlotReInit(newSlot, paramStrings.configdir,
4082 paramStrings.updatedir, paramStrings.updateID,
4083 &paramStrings.tokens[0], moduleIndex);
4084 } else {
4085 crv = SFTK_SlotInit(paramStrings.configdir,
4086 paramStrings.updatedir, paramStrings.updateID,
4087 &paramStrings.tokens[0], moduleIndex);
4088 }
4089
4090 loser:
4091 sftk_freeParams(&paramStrings);
4092 sftk_FreeAttribute(attribute);
4093
4094 return crv;
4095 }
4096
4097
4098 /* NSC_CreateObject creates a new object. */
4099 CK_RV NSC_CreateObject(CK_SESSION_HANDLE hSession,
4100 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
4101 CK_OBJECT_HANDLE_PTR phObject)
4102 {
4103 SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession);
4104 SFTKSession *session;
4105 SFTKObject *object;
4106 /* make sure class isn't randomly CKO_NETSCAPE_NEWSLOT or
4107 * CKO_NETSCPE_DELSLOT. */
4108 CK_OBJECT_CLASS class = CKO_VENDOR_DEFINED;
4109 CK_RV crv;
4110 int i;
4111
4112 CHECK_FORK();
4113
4114 *phObject = CK_INVALID_HANDLE;
4115
4116 if (slot == NULL) {
4117 return CKR_SESSION_HANDLE_INVALID;
4118 }
4119 /*
4120 * now lets create an object to hang the attributes off of
4121 */
4122 object = sftk_NewObject(slot); /* fill in the handle later */
4123 if (object == NULL) {
4124 return CKR_HOST_MEMORY;
4125 }
4126
4127 /*
4128 * load the template values into the object
4129 */
4130 for (i=0; i < (int) ulCount; i++) {
4131 crv = sftk_AddAttributeType(object,sftk_attr_expand(&pTemplate[i]));
4132 if (crv != CKR_OK) {
4133 sftk_FreeObject(object);
4134 return crv;
4135 }
4136 if ((pTemplate[i].type == CKA_CLASS) && pTemplate[i].pValue) {
4137 class = *(CK_OBJECT_CLASS *)pTemplate[i].pValue;
4138 }
4139 }
4140
4141 /* get the session */
4142 session = sftk_SessionFromHandle(hSession);
4143 if (session == NULL) {
4144 sftk_FreeObject(object);
4145 return CKR_SESSION_HANDLE_INVALID;
4146 }
4147
4148 /*
4149 * handle pseudo objects (CKO_NEWSLOT)
4150 */
4151 if ((class == CKO_NETSCAPE_NEWSLOT) || (class == CKO_NETSCAPE_DELSLOT)) {
4152 crv = sftk_CreateNewSlot(slot, class, object);
4153 goto done;
4154 }
4155
4156 /*
4157 * handle the base object stuff
4158 */
4159 crv = sftk_handleObject(object,session);
4160 *phObject = object->handle;
4161 done:
4162 sftk_FreeSession(session);
4163 sftk_FreeObject(object);
4164
4165 return crv;
4166 }
4167
4168
4169
4170 /* NSC_CopyObject copies an object, creating a new object for the copy. */
4171 CK_RV NSC_CopyObject(CK_SESSION_HANDLE hSession,
4172 CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
4173 CK_OBJECT_HANDLE_PTR phNewObject)
4174 {
4175 SFTKObject *destObject,*srcObject;
4176 SFTKSession *session;
4177 CK_RV crv = CKR_OK;
4178 SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession);
4179 int i;
4180
4181 CHECK_FORK();
4182
4183 if (slot == NULL) {
4184 return CKR_SESSION_HANDLE_INVALID;
4185 }
4186 /* Get srcObject so we can find the class */
4187 session = sftk_SessionFromHandle(hSession);
4188 if (session == NULL) {
4189 return CKR_SESSION_HANDLE_INVALID;
4190 }
4191 srcObject = sftk_ObjectFromHandle(hObject,session);
4192 if (srcObject == NULL) {
4193 sftk_FreeSession(session);
4194 return CKR_OBJECT_HANDLE_INVALID;
4195 }
4196 /*
4197 * create an object to hang the attributes off of
4198 */
4199 destObject = sftk_NewObject(slot); /* fill in the handle later */
4200 if (destObject == NULL) {
4201 sftk_FreeSession(session);
4202 sftk_FreeObject(srcObject);
4203 return CKR_HOST_MEMORY;
4204 }
4205
4206 /*
4207 * load the template values into the object
4208 */
4209 for (i=0; i < (int) ulCount; i++) {
4210 if (sftk_modifyType(pTemplate[i].type,srcObject->objclass) == SFTK_NEVER) {
4211 crv = CKR_ATTRIBUTE_READ_ONLY;
4212 break;
4213 }
4214 crv = sftk_AddAttributeType(destObject,sftk_attr_expand(&pTemplate[i]));
4215 if (crv != CKR_OK) { break; }
4216 }
4217 if (crv != CKR_OK) {
4218 sftk_FreeSession(session);
4219 sftk_FreeObject(srcObject);
4220 sftk_FreeObject(destObject);
4221 return crv;
4222 }
4223
4224 /* sensitive can only be changed to CK_TRUE */
4225 if (sftk_hasAttribute(destObject,CKA_SENSITIVE)) {
4226 if (!sftk_isTrue(destObject,CKA_SENSITIVE)) {
4227 sftk_FreeSession(session);
4228 sftk_FreeObject(srcObject);
4229 sftk_FreeObject(destObject);
4230 return CKR_ATTRIBUTE_READ_ONLY;
4231 }
4232 }
4233
4234 /*
4235 * now copy the old attributes from the new attributes
4236 */
4237 /* don't create a token object if we aren't in a rw session */
4238 /* we need to hold the lock to copy a consistant version of
4239 * the object. */
4240 crv = sftk_CopyObject(destObject,srcObject);
4241
4242 destObject->objclass = srcObject->objclass;
4243 sftk_FreeObject(srcObject);
4244 if (crv != CKR_OK) {
4245 sftk_FreeObject(destObject);
4246 sftk_FreeSession(session);
4247 return crv;
4248 }
4249
4250 crv = sftk_handleObject(destObject,session);
4251 *phNewObject = destObject->handle;
4252 sftk_FreeSession(session);
4253 sftk_FreeObject(destObject);
4254
4255 return crv;
4256 }
4257
4258
4259 /* NSC_GetObjectSize gets the size of an object in bytes. */
4260 CK_RV NSC_GetObjectSize(CK_SESSION_HANDLE hSession,
4261 CK_OBJECT_HANDLE hObject, CK_ULONG_PTR pulSize)
4262 {
4263 CHECK_FORK();
4264
4265 *pulSize = 0;
4266 return CKR_OK;
4267 }
4268
4269
4270 /* NSC_GetAttributeValue obtains the value of one or more object attributes. */
4271 CK_RV NSC_GetAttributeValue(CK_SESSION_HANDLE hSession,
4272 CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)
4273 {
4274 SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession);
4275 SFTKSession *session;
4276 SFTKObject *object;
4277 SFTKAttribute *attribute;
4278 PRBool sensitive;
4279 CK_RV crv;
4280 int i;
4281
4282 CHECK_FORK();
4283
4284 if (slot == NULL) {
4285 return CKR_SESSION_HANDLE_INVALID;
4286 }
4287 /*
4288 * make sure we're allowed
4289 */
4290 session = sftk_SessionFromHandle(hSession);
4291 if (session == NULL) {
4292 return CKR_SESSION_HANDLE_INVALID;
4293 }
4294
4295 /* short circuit everything for token objects */
4296 if (sftk_isToken(hObject)) {
4297 SFTKSlot *slot = sftk_SlotFromSession(session);
4298 SFTKDBHandle *dbHandle = sftk_getDBForTokenObject(slot, hObject);
4299 SFTKDBHandle *keydb = NULL;
4300
4301 if (dbHandle == NULL) {
4302 sftk_FreeSession(session);
4303 return CKR_OBJECT_HANDLE_INVALID;
4304 }
4305
4306 crv = sftkdb_GetAttributeValue(dbHandle, hObject, pTemplate, ulCount);
4307
4308 /* make sure we don't export any sensitive information */
4309 keydb = sftk_getKeyDB(slot);
4310 if (dbHandle == keydb) {
4311 for (i=0; i < (int) ulCount; i++) {
4312 if (sftk_isSensitive(pTemplate[i].type,CKO_PRIVATE_KEY)) {
4313 crv = CKR_ATTRIBUTE_SENSITIVE;
4314 if (pTemplate[i].pValue && (pTemplate[i].ulValueLen!= -1)){
4315 PORT_Memset(pTemplate[i].pValue, 0,
4316 pTemplate[i].ulValueLen);
4317 }
4318 pTemplate[i].ulValueLen = -1;
4319 }
4320 }
4321 }
4322
4323 sftk_FreeSession(session);
4324 sftk_freeDB(dbHandle);
4325 if (keydb) {
4326 sftk_freeDB(keydb);
4327 }
4328 return crv;
4329 }
4330
4331 /* handle the session object */
4332 object = sftk_ObjectFromHandle(hObject,session);
4333 sftk_FreeSession(session);
4334 if (object == NULL) {
4335 return CKR_OBJECT_HANDLE_INVALID;
4336 }
4337
4338 /* don't read a private object if we aren't logged in */
4339 if ((!slot->isLoggedIn) && (slot->needLogin) &&
4340 (sftk_isTrue(object,CKA_PRIVATE))) {
4341 sftk_FreeObject(object);
4342 return CKR_USER_NOT_LOGGED_IN;
4343 }
4344
4345 crv = CKR_OK;
4346 sensitive = sftk_isTrue(object,CKA_SENSITIVE);
4347 for (i=0; i < (int) ulCount; i++) {
4348 /* Make sure that this attribute is retrievable */
4349 if (sensitive && sftk_isSensitive(pTemplate[i].type,object->objclass)) {
4350 crv = CKR_ATTRIBUTE_SENSITIVE;
4351 pTemplate[i].ulValueLen = -1;
4352 continue;
4353 }
4354 attribute = sftk_FindAttribute(object,pTemplate[i].type);
4355 if (attribute == NULL) {
4356 crv = CKR_ATTRIBUTE_TYPE_INVALID;
4357 pTemplate[i].ulValueLen = -1;
4358 continue;
4359 }
4360 if (pTemplate[i].pValue != NULL) {
4361 PORT_Memcpy(pTemplate[i].pValue,attribute->attrib.pValue,
4362 attribute->attrib.ulValueLen);
4363 }
4364 pTemplate[i].ulValueLen = attribute->attrib.ulValueLen;
4365 sftk_FreeAttribute(attribute);
4366 }
4367
4368 sftk_FreeObject(object);
4369 return crv;
4370 }
4371
4372 /* NSC_SetAttributeValue modifies the value of one or more object attributes */
4373 CK_RV NSC_SetAttributeValue (CK_SESSION_HANDLE hSession,
4374 CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)
4375 {
4376 SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession);
4377 SFTKSession *session;
4378 SFTKAttribute *attribute;
4379 SFTKObject *object;
4380 PRBool isToken;
4381 CK_RV crv = CKR_OK;
4382 CK_BBOOL legal;
4383 int i;
4384
4385 CHECK_FORK();
4386
4387 if (slot == NULL) {
4388 return CKR_SESSION_HANDLE_INVALID;
4389 }
4390 /*
4391 * make sure we're allowed
4392 */
4393 session = sftk_SessionFromHandle(hSession);
4394 if (session == NULL) {
4395 return CKR_SESSION_HANDLE_INVALID;
4396 }
4397
4398 object = sftk_ObjectFromHandle(hObject,session);
4399 if (object == NULL) {
4400 sftk_FreeSession(session);
4401 return CKR_OBJECT_HANDLE_INVALID;
4402 }
4403
4404 /* don't modify a private object if we aren't logged in */
4405 if ((!slot->isLoggedIn) && (slot->needLogin) &&
4406 (sftk_isTrue(object,CKA_PRIVATE))) {
4407 sftk_FreeSession(session);
4408 sftk_FreeObject(object);
4409 return CKR_USER_NOT_LOGGED_IN;
4410 }
4411
4412 /* don't modify a token object if we aren't in a rw session */
4413 isToken = sftk_isTrue(object,CKA_TOKEN);
4414 if (((session->info.flags & CKF_RW_SESSION) == 0) && isToken) {
4415 sftk_FreeSession(session);
4416 sftk_FreeObject(object);
4417 return CKR_SESSION_READ_ONLY;
4418 }
4419 sftk_FreeSession(session);
4420
4421 /* only change modifiable objects */
4422 if (!sftk_isTrue(object,CKA_MODIFIABLE)) {
4423 sftk_FreeObject(object);
4424 return CKR_ATTRIBUTE_READ_ONLY;
4425 }
4426
4427 for (i=0; i < (int) ulCount; i++) {
4428 /* Make sure that this attribute is changeable */
4429 switch (sftk_modifyType(pTemplate[i].type,object->objclass)) {
4430 case SFTK_NEVER:
4431 case SFTK_ONCOPY:
4432 default:
4433 crv = CKR_ATTRIBUTE_READ_ONLY;
4434 break;
4435
4436 case SFTK_SENSITIVE:
4437 legal = (pTemplate[i].type == CKA_EXTRACTABLE) ? CK_FALSE : CK_TRUE;
4438 if ((*(CK_BBOOL *)pTemplate[i].pValue) != legal) {
4439 crv = CKR_ATTRIBUTE_READ_ONLY;
4440 }
4441 break;
4442 case SFTK_ALWAYS:
4443 break;
4444 }
4445 if (crv != CKR_OK) break;
4446
4447 /* find the old attribute */
4448 attribute = sftk_FindAttribute(object,pTemplate[i].type);
4449 if (attribute == NULL) {
4450 crv =CKR_ATTRIBUTE_TYPE_INVALID;
4451 break;
4452 }
4453 sftk_FreeAttribute(attribute);
4454 crv = sftk_forceAttribute(object,sftk_attr_expand(&pTemplate[i]));
4455 if (crv != CKR_OK) break;
4456
4457 }
4458
4459 sftk_FreeObject(object);
4460 return crv;
4461 }
4462
4463 static CK_RV
4464 sftk_expandSearchList(SFTKSearchResults *search, int count)
4465 {
4466 search->array_size += count;
4467 search->handles = (CK_OBJECT_HANDLE *)PORT_Realloc(search->handles,
4468 sizeof(CK_OBJECT_HANDLE)*search->array_size);
4469 return search->handles ? CKR_OK : CKR_HOST_MEMORY;
4470 }
4471
4472
4473
4474 static CK_RV
4475 sftk_searchDatabase(SFTKDBHandle *handle, SFTKSearchResults *search,
4476 const CK_ATTRIBUTE *pTemplate, CK_ULONG ulCount)
4477 {
4478 CK_RV crv;
4479 int objectListSize = search->array_size-search->size;
4480 CK_OBJECT_HANDLE *array = &search->handles[search->size];
4481 SDBFind *find;
4482 CK_ULONG count;
4483
4484 crv = sftkdb_FindObjectsInit(handle, pTemplate, ulCount, &find);
4485 if (crv != CKR_OK)
4486 return crv;
4487 do {
4488 crv = sftkdb_FindObjects(handle, find, array, objectListSize, &count);
4489 if ((crv != CKR_OK) || (count == 0))
4490 break;
4491 search->size += count;
4492 objectListSize -= count;
4493 if (objectListSize > 0)
4494 break;
4495 crv = sftk_expandSearchList(search,NSC_SEARCH_BLOCK_SIZE);
4496 objectListSize = NSC_SEARCH_BLOCK_SIZE;
4497 array = &search->handles[search->size];
4498 } while (crv == CKR_OK);
4499 sftkdb_FindObjectsFinal(handle, find);
4500
4501 return crv;
4502 }
4503
4504 /* softoken used to search the SMimeEntries automatically instead of
4505 * doing this in pk11wrap. This code should really be up in
4506 * pk11wrap so that it will work with other tokens other than softoken.
4507 */
4508 CK_RV
4509 sftk_emailhack(SFTKSlot *slot, SFTKDBHandle *handle,
4510 SFTKSearchResults *search, CK_ATTRIBUTE *pTemplate, CK_ULONG ulCount)
4511 {
4512 PRBool isCert = PR_FALSE;
4513 int emailIndex = -1;
4514 int i;
4515 SFTKSearchResults smime_search;
4516 CK_ATTRIBUTE smime_template[2];
4517 CK_OBJECT_CLASS smime_class = CKO_NETSCAPE_SMIME;
4518 SFTKAttribute *attribute = NULL;
4519 SFTKObject *object = NULL;
4520 CK_RV crv = CKR_OK;
4521
4522
4523 smime_search.handles = NULL; /* paranoia, some one is bound to add a goto
4524 * loser before this gets initialized */
4525
4526 /* see if we are looking for email certs */
4527 for (i=0; i < ulCount; i++) {
4528 if (pTemplate[i].type == CKA_CLASS) {
4529 if ((pTemplate[i].ulValueLen != sizeof(CK_OBJECT_CLASS) ||
4530 (*(CK_OBJECT_CLASS *)pTemplate[i].pValue) != CKO_CERTIFICATE)) {
4531 /* not a cert, skip out */
4532 break;
4533 }
4534 isCert = PR_TRUE;
4535 } else if (pTemplate[i].type == CKA_NETSCAPE_EMAIL) {
4536 emailIndex = i;
4537
4538 }
4539 if (isCert && (emailIndex != -1)) break;
4540 }
4541
4542 if (!isCert || (emailIndex == -1)) {
4543 return CKR_OK;
4544 }
4545
4546 /* we are doing a cert and email search, find the SMimeEntry */
4547 smime_template[0].type = CKA_CLASS;
4548 smime_template[0].pValue = &smime_class;
4549 smime_template[0].ulValueLen = sizeof(smime_class);
4550 smime_template[1] = pTemplate[emailIndex];
4551
4552 smime_search.handles = (CK_OBJECT_HANDLE *)
4553 PORT_Alloc(sizeof(CK_OBJECT_HANDLE) * NSC_SEARCH_BLOCK_SIZE);
4554 if (smime_search.handles == NULL) {
4555 crv = CKR_HOST_MEMORY;
4556 goto loser;
4557 }
4558 smime_search.index = 0;
4559 smime_search.size = 0;
4560 smime_search.array_size = NSC_SEARCH_BLOCK_SIZE;
4561
4562 crv = sftk_searchDatabase(handle, &smime_search, smime_template, 2);
4563 if (crv != CKR_OK || smime_search.size == 0) {
4564 goto loser;
4565 }
4566
4567 /* get the SMime subject */
4568 object = sftk_NewTokenObject(slot, NULL, smime_search.handles[0]);
4569 if (object == NULL) {
4570 crv = CKR_HOST_MEMORY; /* is there any other reason for this failure? */
4571 goto loser;
4572 }
4573 attribute = sftk_FindAttribute(object,CKA_SUBJECT);
4574 if (attribute == NULL) {
4575 crv = CKR_ATTRIBUTE_TYPE_INVALID;
4576 goto loser;
4577 }
4578
4579 /* now find the certs with that subject */
4580 pTemplate[emailIndex] = attribute->attrib;
4581 /* now add the appropriate certs to the search list */
4582 crv = sftk_searchDatabase(handle, search, pTemplate, ulCount);
4583 pTemplate[emailIndex] = smime_template[1]; /* restore the user's template*/
4584
4585 loser:
4586 if (attribute) {
4587 sftk_FreeAttribute(attribute);
4588 }
4589 if (object) {
4590 sftk_FreeObject(object);
4591 }
4592 if (smime_search.handles) {
4593 PORT_Free(smime_search.handles);
4594 }
4595
4596 return crv;
4597 }
4598
4599 static void
4600 sftk_pruneSearch(CK_ATTRIBUTE *pTemplate, CK_ULONG ulCount,
4601 PRBool *searchCertDB, PRBool *searchKeyDB) {
4602 CK_ULONG i;
4603
4604 *searchCertDB = PR_TRUE;
4605 *searchKeyDB = PR_TRUE;
4606 for (i = 0; i < ulCount; i++) {
4607 if (pTemplate[i].type == CKA_CLASS && pTemplate[i].pValue != NULL) {
4608 CK_OBJECT_CLASS class = *((CK_OBJECT_CLASS*)pTemplate[i].pValue);
4609 if (class == CKO_PRIVATE_KEY || class == CKO_SECRET_KEY) {
4610 *searchCertDB = PR_FALSE;
4611 } else {
4612 *searchKeyDB = PR_FALSE;
4613 }
4614 break;
4615 }
4616 }
4617 }
4618
4619 static CK_RV
4620 sftk_searchTokenList(SFTKSlot *slot, SFTKSearchResults *search,
4621 CK_ATTRIBUTE *pTemplate, CK_ULONG ulCount,
4622 PRBool *tokenOnly, PRBool isLoggedIn)
4623 {
4624 CK_RV crv = CKR_OK;
4625 CK_RV crv2;
4626 PRBool searchCertDB;
4627 PRBool searchKeyDB;
4628
4629 sftk_pruneSearch(pTemplate, ulCount, &searchCertDB, &searchKeyDB);
4630
4631 if (searchCertDB) {
4632 SFTKDBHandle *certHandle = sftk_getCertDB(slot);
4633 crv = sftk_searchDatabase(certHandle, search, pTemplate, ulCount);
4634 crv2 = sftk_emailhack(slot, certHandle, search, pTemplate, ulCount);
4635 if (crv == CKR_OK) crv = crv2;
4636 sftk_freeDB(certHandle);
4637 }
4638
4639 if (crv == CKR_OK && isLoggedIn && searchKeyDB) {
4640 SFTKDBHandle *keyHandle = sftk_getKeyDB(slot);
4641 crv = sftk_searchDatabase(keyHandle, search, pTemplate, ulCount);
4642 sftk_freeDB(keyHandle);
4643 }
4644 return crv;
4645 }
4646
4647 /* NSC_FindObjectsInit initializes a search for token and session objects
4648 * that match a template. */
4649 CK_RV NSC_FindObjectsInit(CK_SESSION_HANDLE hSession,
4650 CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)
4651 {
4652 SFTKSearchResults *search = NULL, *freeSearch = NULL;
4653 SFTKSession *session = NULL;
4654 SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession);
4655 PRBool tokenOnly = PR_FALSE;
4656 CK_RV crv = CKR_OK;
4657 PRBool isLoggedIn;
4658
4659 CHECK_FORK();
4660
4661 if (slot == NULL) {
4662 return CKR_SESSION_HANDLE_INVALID;
4663 }
4664 session = sftk_SessionFromHandle(hSession);
4665 if (session == NULL) {
4666 crv = CKR_SESSION_HANDLE_INVALID;
4667 goto loser;
4668 }
4669
4670 search = (SFTKSearchResults *)PORT_Alloc(sizeof(SFTKSearchResults));
4671 if (search == NULL) {
4672 crv = CKR_HOST_MEMORY;
4673 goto loser;
4674 }
4675 search->handles = (CK_OBJECT_HANDLE *)
4676 PORT_Alloc(sizeof(CK_OBJECT_HANDLE) * NSC_SEARCH_BLOCK_SIZE);
4677 if (search->handles == NULL) {
4678 crv = CKR_HOST_MEMORY;
4679 goto loser;
4680 }
4681 search->index = 0;
4682 search->size = 0;
4683 search->array_size = NSC_SEARCH_BLOCK_SIZE;
4684 isLoggedIn = (PRBool)((!slot->needLogin) || slot->isLoggedIn);
4685
4686 crv = sftk_searchTokenList(slot, search, pTemplate, ulCount, &tokenOnly,
4687 isLoggedIn);
4688 if (crv != CKR_OK) {
4689 goto loser;
4690 }
4691
4692 /* build list of found objects in the session */
4693 if (!tokenOnly) {
4694 crv = sftk_searchObjectList(search, slot->sessObjHashTable,
4695 slot->sessObjHashSize, slot->objectLock,
4696 pTemplate, ulCount, isLoggedIn);
4697 }
4698 if (crv != CKR_OK) {
4699 goto loser;
4700 }
4701
4702 if ((freeSearch = session->search) != NULL) {
4703 session->search = NULL;
4704 sftk_FreeSearch(freeSearch);
4705 }
4706 session->search = search;
4707 sftk_FreeSession(session);
4708 return CKR_OK;
4709
4710 loser:
4711 if (search) {
4712 sftk_FreeSearch(search);
4713 }
4714 if (session) {
4715 sftk_FreeSession(session);
4716 }
4717 return crv;
4718 }
4719
4720
4721 /* NSC_FindObjects continues a search for token and session objects
4722 * that match a template, obtaining additional object handles. */
4723 CK_RV NSC_FindObjects(CK_SESSION_HANDLE hSession,
4724 CK_OBJECT_HANDLE_PTR phObject,CK_ULONG ulMaxObjectCount,
4725 CK_ULONG_PTR pulObjectCount)
4726 {
4727 SFTKSession *session;
4728 SFTKSearchResults *search;
4729 int transfer;
4730 int left;
4731
4732 CHECK_FORK();
4733
4734 *pulObjectCount = 0;
4735 session = sftk_SessionFromHandle(hSession);
4736 if (session == NULL) return CKR_SESSION_HANDLE_INVALID;
4737 if (session->search == NULL) {
4738 sftk_FreeSession(session);
4739 return CKR_OK;
4740 }
4741 search = session->search;
4742 left = session->search->size - session->search->index;
4743 transfer = ((int)ulMaxObjectCount > left) ? left : ulMaxObjectCount;
4744 if (transfer > 0) {
4745 PORT_Memcpy(phObject,&search->handles[search->index],
4746 transfer*sizeof(CK_OBJECT_HANDLE));
4747 } else {
4748 *phObject = CK_INVALID_HANDLE;
4749 }
4750
4751 search->index += transfer;
4752 if (search->index == search->size) {
4753 session->search = NULL;
4754 sftk_FreeSearch(search);
4755 }
4756 *pulObjectCount = transfer;
4757 sftk_FreeSession(session);
4758 return CKR_OK;
4759 }
4760
4761 /* NSC_FindObjectsFinal finishes a search for token and session objects. */
4762 CK_RV NSC_FindObjectsFinal(CK_SESSION_HANDLE hSession)
4763 {
4764 SFTKSession *session;
4765 SFTKSearchResults *search;
4766
4767 CHECK_FORK();
4768
4769 session = sftk_SessionFromHandle(hSession);
4770 if (session == NULL) return CKR_SESSION_HANDLE_INVALID;
4771 search = session->search;
4772 session->search = NULL;
4773 sftk_FreeSession(session);
4774 if (search != NULL) {
4775 sftk_FreeSearch(search);
4776 }
4777 return CKR_OK;
4778 }
4779
4780
4781
4782 CK_RV NSC_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR pSlot,
4783 CK_VOID_PTR pReserved)
4784 {
4785 CHECK_FORK();
4786
4787 return CKR_FUNCTION_NOT_SUPPORTED;
4788 }
4789

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial